Returns the coordinate of the point on this segment for the given
parameter value.
320500
public Point2D getCoord2D(double t) {
		Point2D pt = new Point2D();
		getCoord2D(t, pt);
		return pt;
	}
269713
def get_coordinates(self, i, end=False):
        """"""
        if end:
            endpoint = self.endpoints[i][1]
        else:
            endpoint = self.endpoints[i][0]
        return (endpoint.real, endpoint.imag)
289834
def point(self, t):
        """"""
        return (1 - t)**2*self.start + 2*(1 - t)*t*self.control + t**2*self.end
968720
@Override
	@Pure
	public final P getNearest(Point2D<?, ?> position) {
		final Pair<P, Double> data = getNearestData(position.getX(), position.getY());
		if (data != null) {
			return data.getKey();
		}
		return null;
	}
72947
def point_image_value(image, xy, scale=1):
    """"""
    return getinfo(ee.Image(image).reduceRegion(
        reducer=ee.Reducer.first(), geometry=ee.Geometry.Point(xy),
        scale=scale))
1342620
def _convert_point(cls, feature):
        """"""
        lon, lat = feature['geometry']['coordinates']
        popup = feature['properties'].get('name', '')
        return cls(lat, lon)
692075
def start_point(self):
        
        edge = self.result.wire().val().Edges()[0]
        return edge.Vertices()[0].Center()
932961
private static Point getShapeIntersection(Shape shape,
                                              Line2D.Double line) {
        PathIterator it = shape.getPathIterator(null);
        double[] coords = new double[6];
        double[] pos = new double[2];
        Line2D.Double l = new Line2D.Double();
        while (!it.isDone()) {
            int type = it.currentSegment(coords);
            switch (type) {
                case PathIterator.SEG_MOVETO:
                    pos[0] = coords[0];
                    pos[1] = coords[1];
                    break;
                case PathIterator.SEG_LINETO:
                    l = new Line2D.Double(pos[0],
                                          pos[1],
                                          coords[0],
                                          coords[1]);
                    if (line.intersectsLine(l)) {
                        return getLinesIntersection(line,
                                                    l);
                    }
                    pos[0] = coords[0];
                    pos[1] = coords[1];
                    break;
                case PathIterator.SEG_CLOSE:
                    break;
                default:
                    // whatever
            }
            it.next();
        }
        return null;
    }
1204459
public double getDistanceToCenter(Point point) {
        return Nd4j.getExecutioner().execAndReturn(
                        ClusterUtils.createDistanceFunctionOp(distanceFunction, center.getArray(), point.getArray()))
                        .getFinalResult().doubleValue();
    }
867100
def getOffset(self, loc):
        
        return Location(loc.x - self.x, loc.y - self.y)
309811
static Point2D toAwtPoint(Point2d point) {
        return new Point2D.Double(point.x, point.y);
    }
225549
def C(self):
        '''
        
        '''
        return Point(self.maxX, self.maxY, self.origin.z)
264572
def ceil(self):
    """"""
    return Point(int(math.ceil(self.x)), int(math.ceil(self.y)))
1067146
private Parameter getParameterByOrdinal(Integer position)
    {
        for (Parameter p : parameters)
        {
            if (position.equals(p.getPosition()))
            {
                return p;
            }
        }

        return null;
    }
74922
private Point getPoint(Vector2f pt) {
		Point p = nextFreePoint;
		if (p != null) {
			nextFreePoint = p.next;
			// initialize new point to safe values
			p.next = null;
			p.prev = null;
			p.pt = pt;
			return p;
		}
		return new Point(pt);
	}
102252
public Coordinate getCoordinate(Geometry geometry) {
		LineString lineString = getLineString(geometry);
		if (lineString != null && coordinateIndex >= 0) {
			return lineString.getCoordinateN(coordinateIndex);
		}
		return null;
	}
200019
private GeographyPointValue getRandomPoint() {
        double lngRange = Regions.MAX_LNG - Regions.MIN_LNG;
        double lng = Regions.MIN_LNG + lngRange * m_rand.nextDouble();

        double latRange = Regions.MAX_LAT - Regions.MIN_LAT;
        double lat = Regions.MIN_LAT + latRange * m_rand.nextDouble();

        return new GeographyPointValue(lng, lat);
    }