Adds a data with label with coordinates (xOffset, yOffset). This point will be highlighted with
a circle centering (xOffset, yOffset)
500573
public void addData(double xOffset, double yOffset, String label) {

    DataPoint dp = new DataPoint(xOffset, yOffset, label);
    dataPointList.add(dp);
  }
1227363
def AddLabel(self, label):
    
    if not isinstance(label, py2to3.STRING_TYPES):
      raise TypeError('label is not a string type. Is {0:s}'.format(
          type(label)))
    if not self._VALID_LABEL_REGEX.match(label):
      raise ValueError((
          'Unsupported label: "{0:s}". A label must only consist of '
          'alphanumeric characters or underscores.').format(label))

    if label not in self.labels:
      self.labels.append(label)
279208
def point(self, x, y):
        """"""
        shapeType = POINT
        pointShape = Shape(shapeType)
        pointShape.points.append([x, y])
        self.shape(pointShape)
882832
def offset(self, dx, dy):
        
        return Location(self.x+dx, self.y+dy)
1323514
def set_pointing_label(self):
        """"""

        current = self.current
        pointing = self.pointings[current]
        self.delete_pointing(None)
        pointing["label"]['text'] = self.plabel.get()
        self.pointings.append(pointing)
        self.plot_pointings([pointing])
        self.current = current
1363927
def setPoint(self, x, group, y):
        
        if x == -1:
            # silence window
            self.plot([0],[y], symbol='o')
        else:
            yindex = self.groups.index(group)
            xdata, ydata = self.lines[yindex].getData()
            if ydata is None:
                xdata = [x]
                ydata = [y]
            else:
                xdata = np.append(xdata, x)
                ydata = np.append(ydata, y)
            self.lines[yindex].setData(xdata, ydata)
1372569
def add_to_results(self, data, label, results):
        
        for datum in data:
            if label is not None:
                datum.update({'type': label})

            results.append(datum)

        return results
748799
def tickmark(self, x, y, size=10, orientation=90):
        """"""

        (x1, y1) = self.p2c([x, y])
        x2 = x1 + size * math.cos(math.radians(orientation))
        y2 = y1 - size * math.sin(math.radians(orientation))
        self.create_line(x1, y1, x2, y2)
1098317
def add_data_point_xy(self, x, y):
        """"""
        self.x.append(x)
        self.y.append(y)
498489
def label(self,x,y,label,offset=[0,0]):
        """"""
        (xc,yc)=self.p2c([x,y])
        return self.create_text(xc-offset[0],yc-offset[1],text=label)
277975
function add(point, rhs) {
    if (typeof rhs === 'number') {
        return {
            x: point.x + rhs,
            y: point.y + rhs,
        };
    } else {
        return {
            x: point.x + rhs.x,
            y: point.y + rhs.y,
        };
    }
}
484406
function (from, to, edgeData) {
    edgeData = edgeData || {}
    edgeData.weight = Math.floor(Math.random() * 10) + 1;
    edgeData.label = edgeData.weight;
    edgeData.style = { 'pointer-events': 'none' }
    g.addEdge(from, to, edgeData);
  }
1005404
def add_label(self, name, addr):
        

        # set the label
        self._symbolization_needed = True

        self.symbol_manager.new_label(addr, name=name, force=True)
815997
function addInteraction() {
  let value = typeSelect.value;
  if (value !== 'None') {
    let geometryFunction;
    if (value === 'Square') {
      value = 'Circle';
      geometryFunction = createRegularPolygon(4);
    } else if (value === 'Box') {
      value = 'Circle';
      geometryFunction = createBox();
    } else if (value === 'Star') {
      value = 'Circle';
      geometryFunction = function(coordinates, geometry) {
        const center = coordinates[0];
        const last = coordinates[1];
        const dx = center[0] - last[0];
        const dy = center[1] - last[1];
        const radius = Math.sqrt(dx * dx + dy * dy);
        const rotation = Math.atan2(dy, dx);
        const newCoordinates = [];
        const numPoints = 12;
        for (let i = 0; i < numPoints; ++i) {
          const angle = rotation + i * 2 * Math.PI / numPoints;
          const fraction = i % 2 === 0 ? 1 : 0.5;
          const offsetX = radius * fraction * Math.cos(angle);
          const offsetY = radius * fraction * Math.sin(angle);
          newCoordinates.push([center[0] + offsetX, center[1] + offsetY]);
        }
        newCoordinates.push(newCoordinates[0].slice());
        if (!geometry) {
          geometry = new Polygon([newCoordinates]);
        } else {
          geometry.setCoordinates([newCoordinates]);
        }
        return geometry;
      };
    }
    draw = new Draw({
      source: source,
      type: value,
      geometryFunction: geometryFunction
    });
    map.addInteraction(draw);
  }
}
958864
def PlaceSOffsetT(self, x):
        
        N.enforce_number(x, N.SOffsetTFlags)
        self.head = self.head - N.SOffsetTFlags.bytewidth
        encode.Write(packer.soffset, self.Bytes, self.Head(), x)
1355853
def add(self, label):
        
        self._labels[label.id] = label
        self._dirty = True
19025
def mark(x,y,label=None):
	""""""
	if label is not None: 
	    os.system("xpaset -p ds9 regions color red ")
	    cmd="echo 'image; text %d %d # text={%s}' | xpaset ds9 regions " % ( x,y,label) 
	else:
	    os.system("xpaset -p ds9 regions color blue")
	    cmd="echo 'image; circle %d %d 10 ' | xpaset ds9 regions " % (x,y)
	os.system(cmd)
	return