Transforms a point as specified, storing the result in the point provided.
@return a reference to the result point, for chaining.
486455
public static Point transform (float x, float y, float sx, float sy, float rotation,
                                   float tx, float ty, Point result) {
        return transform(x, y, sx, sy, FloatMath.sin(rotation), FloatMath.cos(rotation), tx, ty,
                         result);
    }
735917
private Point translate(Point point) {
		Coordinate c = point.getCoordinate();
		return point.getGeometryFactory().createPoint(new Coordinate(c.getX() + translateX, c.getY() + translateY));
	}
1086319
@Override
	public void transform(Transform3D transform) {
		if (transform!=null) {
			Point3D p = new Point3d();
			for(int i=0; i<this.numCoordsProperty.get();) {
				p.set(this.coordsProperty[i].get(), this.coordsProperty[i+1].get(), this.coordsProperty[i+2].get());
				transform.transform(p);
				this.coordsProperty[i++].set(p.getX());
				this.coordsProperty[i++].set(p.getY());
				this.coordsProperty[i++].set(p.getZ());
			}
			this.graphicalBounds = null;
			this.logicalBounds = null;
		}
	}
29072
public BatchPoints point(final Point point) {
    point.getTags().putAll(this.tags);
    this.points.add(point);
    return this;
  }
1117148
public PointExpression<Point> startPoint() {
        if (startPoint == null) {
            startPoint = GeometryExpressions.pointOperation(SpatialOps.START_POINT, mixin);
        }
        return startPoint;
    }
173419
private Point getCellPoint() {
        double x1 = (minX + cellI * deltaX) + (deltaX / 2d);
        double y1 = (minY + cellJ * deltaY) + (deltaY / 2d);
        cellI++;
        return GF.createPoint(new Coordinate(x1, y1));
    }
390170
public List<Point> getPoints2() {
        verifyPropertyPresence(POINTS2);
        //noinspection unchecked
        return ((List<Map<String, Object>>) getCommandResult().get(POINTS2)).stream()
                .map(ComparisonResult::mapToPoint)
                .collect(Collectors.toList());
    }
441585
public Point2D_F64 transform( Point3D_F64 worldPt ) {
		Point2D_F64 out = new Point2D_F64();
		if( transform(worldPt,out))
			return out;
		else
			return null;
	}
963220
public GeoShapeMapper transform(GeoTransformation... transformations) {
        if (this.transformations == null) {
            this.transformations = Arrays.asList(transformations);
        } else {
            this.transformations.addAll(Arrays.asList(transformations));
        }
        return this;
    }
1320452
public PointF mapViewToImage(PointF viewPoint) {
    float[] points = mTempValues;
    points[0] = viewPoint.x;
    points[1] = viewPoint.y;
    mActiveTransform.invert(mActiveTransformInverse);
    mActiveTransformInverse.mapPoints(points, 0, points, 0, 1);
    mapAbsoluteToRelative(points, points, 1);
    return new PointF(points[0], points[1]);
  }
1304486
public MultiPointTo toTransferObject(MultiPoint input) {
        MultiPointTo result = new MultiPointTo();
        result.setCrs(GeoJsonTo.createCrsTo("EPSG:" + input.getSRID()));
        result.setCoordinates(getPoints(input));
        return result;
    }
861518
@Pure
	@Override
	public Point3f getCenter() {
		return new Point3f(
				(this.minx + this.maxx) / 2.,
				(this.miny + this.maxy) / 2.,
				(this.minz + this.maxz) / 2.);
	}
1360232
public static double[] bbox(@NonNull Point point) {
    List<Point> resultCoords = TurfMeta.coordAll(point);
    return bboxCalculator(resultCoords);
  }
784055
private static Point getCursorLocation()
    {
        try
        {
            final PointerInfo a = MouseInfo.getPointerInfo();
            final java.awt.Point b = a.getLocation();
            return new Point((int) b.getX(), (int) b.getY());
        }
        catch (final HeadlessException exception)
        {
            Verbose.exception(exception);
            return new Point();
        }
    }
805749
protected float[] transformPosition(float x, float y)
    {
        Point2D.Float point = super.transformedPoint(x, y);
        AffineTransform pageTransform = createCurrentPageTransformation();
        Point2D.Float transformedPoint = (Point2D.Float) pageTransform.transform(point, null);

        return new float[]{(float) transformedPoint.getX(), (float) transformedPoint.getY()};
    }
813947
public CompactSketch<S> getResult() {
    sketch_.trim();
    if (theta_ < sketch_.theta_) {
      sketch_.setThetaLong(theta_);
      sketch_.rebuild();
    }
    return sketch_.compact();
  }
390727
public Enumeration<Point<Object>> values() {
    Vector<Point<Object>>	result;
    Vector<Point<Integer>>	points;
    int			i;

    result = new Vector<Point<Object>>();

    points = listPoints();
    for (i = 0; i < points.size(); i++)
      result.add(getValues(points.get(i)));

    return result.elements();
  }

  /**
   * Returns a string representation of the space.
   *
   * @return		 a string representation
   */
  public String toString() {
    StringBuilder	result;
    int			i;

    result = new StringBuilder(dimensions() + "-dimensional space:");
    for (i = 0; i < dimensions(); i++)
      result.append("\n - " + (i+1) + ". " + getDimension(i));

    return result.toString();
  }
}