Transform a WGS84 point to the projection

@param point
@return
504770
public Point toProjection(Point point) {
        if (projection != null) {
            point = fromWgs84.transform(point);
        }
        return point;
    }
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);
    }
49598
public static LineString of(Iterable<Point> points) {
        LinearPositions.Builder positionsBuilder = LinearPositions.builder();
        for(Point point : points) {
            positionsBuilder.addSinglePosition(point.positions());
        }
        return new LineString(positionsBuilder.build());

    }
40472
public TriangulationPoint pointCW( TriangulationPoint point )
    {
        if( point == points[0] )
        {
            return points[2];
        }
        else if( point == points[1] )
        {
            return points[0];
        }
        else if( point == points[2] )
        {
            return points[1];
        }
        logger.error( "point location error" );
        throw new RuntimeException("[FIXME] point location error");
    }
1349230
function convertGeopoint (point) {
  const t = typeof point;

  if (!point || (t !== 'string' && t !== 'object')) {
    return null;
  }

  // Format: "lat, lon" or "geohash"
  if (t === 'string') {
    return fromString(point);
  }

  // Format: [lat, lon]
  if (Array.isArray(point)) {
    if (point.length === 2) {
      return toCoordinate(point[0], point[1]);
    }

    return null;
  }

  const camelCased = geoLocationToCamelCase(point);

  // Format: { lat, lon }
  if (camelCased.hasOwnProperty('lat') && camelCased.hasOwnProperty('lon')) {
    return toCoordinate(camelCased.lat, camelCased.lon);
  }

  if (camelCased.latLon) {
    // Format: { latLon: [lat, lon] }
    if (Array.isArray(camelCased.latLon)) {
      if (camelCased.latLon.length === 2) {
        return toCoordinate(camelCased.latLon[0], camelCased.latLon[1]);
      }

      return null;
    }

    // Format: { latLon: { lat, lon } }
    if (typeof camelCased.latLon === 'object' && camelCased.latLon.hasOwnProperty('lat') && camelCased.latLon.hasOwnProperty('lon')) {
      return toCoordinate(camelCased.latLon.lat, camelCased.latLon.lon);
    }

    if (typeof camelCased.latLon === 'string') {
      return fromString(camelCased.latLon);
    }
  }

  return null;
}
1281864
public TriangulationPoint pointCCW( TriangulationPoint point )
    {
        if( point == points[0] )
        {
            return points[1];
        }
        else if( point == points[1] )
        {
            return points[2];
        }
        else if( point == points[2] )
        {
            return points[0];
        }
        logger.error( "point location error" );
        throw new RuntimeException("[FIXME] point location error");
    }
1039438
public static CellPosition of(final Point point) {
        ArgUtils.notNull(point, "point");
        return of(point.y, point.x);
    }
606507
function (point) {
    var latlng = this.getNativeMap().containerPointToLatLng([point.x, point.y]);
    return {
      lat: latlng.lat,
      lng: latlng.lng
    };
  }
812866
@Pure
	public final Transform2D toTransform2D(Segment1D<?, ?> segment) {
		assert segment != null : AssertMessages.notNullParameter(0);
		final Point2D<?, ?> a = segment.getFirstPoint();
		if (a == null) {
			return null;
		}
		final Point2D<?, ?> b = segment.getLastPoint();
		if (b == null) {
			return null;
		}
		return toTransform2D(a.getX(), a.getY(), b.getX(), b.getY());
	}
867527
function normalizePoint (point) {
            return {
                x: point.x * canvas.width,
                y: point.y * canvas.height
            };
        }
950322
function(point) {
        var node = this.createElementNS(this.namespaces.gpx, "trkpt");
        node.setAttribute("lon", point.x);
        node.setAttribute("lat", point.y);
        return node;
    }
719900
public static Geometry rotate(Geometry geom, double theta, Point point) {
        return rotate(geom, theta, point.getX(), point.getY());
    }
1304654
public void transformPoint(final double[] point) {
		Point3d p = new Point3d(point[0],point[1],point[2]);
		transformation.transform(p);
		point[0] = p.x;
		point[1] = p.y;
		point[2] = p.z;
	}
1052452
public Point getPoint(int position) {
        if (position<0 || position>=size()) throw new ArrayIndexOutOfBoundsException("Invalid position: " + position);
        return new Point(coordinates[0][position],coordinates[1][position]);
    }
313652
@SuppressWarnings("unchecked")
    public GoogleMapShape toShape(Geometry geometry) {

        GoogleMapShape shape = null;

        GeometryType geometryType = geometry.getGeometryType();
        switch (geometryType) {
            case POINT:
                shape = new GoogleMapShape(geometryType,
                        GoogleMapShapeType.LAT_LNG, toLatLng((Point) geometry));
                break;
            case LINESTRING:
                shape = new GoogleMapShape(geometryType,
                        GoogleMapShapeType.POLYLINE_OPTIONS,
                        toPolyline((LineString) geometry));
                break;
            case POLYGON:
                shape = new GoogleMapShape(geometryType,
                        GoogleMapShapeType.POLYGON_OPTIONS,
                        toPolygon((Polygon) geometry));
                break;
            case MULTIPOINT:
                shape = new GoogleMapShape(geometryType,
                        GoogleMapShapeType.MULTI_LAT_LNG,
                        toLatLngs((MultiPoint) geometry));
                break;
            case MULTILINESTRING:
                shape = new GoogleMapShape(geometryType,
                        GoogleMapShapeType.MULTI_POLYLINE_OPTIONS,
                        toPolylines((MultiLineString) geometry));
                break;
            case MULTIPOLYGON:
                shape = new GoogleMapShape(geometryType,
                        GoogleMapShapeType.MULTI_POLYGON_OPTIONS,
                        toPolygons((MultiPolygon) geometry));
                break;
            case CIRCULARSTRING:
                shape = new GoogleMapShape(geometryType,
                        GoogleMapShapeType.POLYLINE_OPTIONS,
                        toPolyline((CircularString) geometry));
                break;
            case COMPOUNDCURVE:
                shape = new GoogleMapShape(geometryType,
                        GoogleMapShapeType.MULTI_POLYLINE_OPTIONS,
                        toPolylines((CompoundCurve) geometry));
                break;
            case CURVEPOLYGON:
                shape = new GoogleMapShape(geometryType,
                        GoogleMapShapeType.POLYGON_OPTIONS,
                        toCurvePolygon((CurvePolygon) geometry));
                break;
            case POLYHEDRALSURFACE:
                shape = new GoogleMapShape(geometryType,
                        GoogleMapShapeType.MULTI_POLYGON_OPTIONS,
                        toPolygons((PolyhedralSurface) geometry));
                break;
            case TIN:
                shape = new GoogleMapShape(geometryType,
                        GoogleMapShapeType.MULTI_POLYGON_OPTIONS,
                        toPolygons((TIN) geometry));
                break;
            case TRIANGLE:
                shape = new GoogleMapShape(geometryType,
                        GoogleMapShapeType.POLYGON_OPTIONS,
                        toPolygon((Triangle) geometry));
                break;
            case GEOMETRYCOLLECTION:
                shape = new GoogleMapShape(geometryType,
                        GoogleMapShapeType.COLLECTION,
                        toShapes((GeometryCollection<Geometry>) geometry));
                break;
            default:
                throw new GeoPackageException("Unsupported Geometry Type: "
                        + geometryType.getName());
        }

        return shape;
    }
617095
public static LineString of(Stream<Point> points) {
        return of(points.collect(Collectors.toList()));
    }
476872
public GeoMultiPoint addPoint(GeoPoint point) {
		Contracts.assertNotNull( point, "point" );
		this.points.add( point );
		return this;
	}