GeometryFactory (RS Core TRUNK-SNAPSHOT API)

java.lang.Object
- com.revolsys.jts.geom.GeometryFactory

All Implemented Interfaces:

MapSerializer, Serializable
```
public class GeometryFactory
extends Object
implements Serializable, MapSerializer
```
Supplies a set of utility methods for building Geometry objects from lists of Coordinates.
Note that the factory constructor methods do not change the input coordinates in any way. In particular, they are not rounded to the supplied PrecisionModel. It is assumed that input Point meet the given precision.

Version:

1.7

See Also:
Serialized Form

Constructor Summary

Constructors
Modifier	Constructor and Description
`protected`	`GeometryFactory(CoordinateSystem coordinateSystem, int axisCount, double... scales)`
`protected`	`GeometryFactory(int srid, int axisCount, double... scales)`

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`addGeometries(List<Geometry> geometryList, Geometry geometry)`
`BoundingBox`	`boundingBox()`
`Geometry`	`buildGeometry(Collection<? extends Geometry> geometries)` Build an appropriate `Geometry`, `MultiGeometry`, or `GeometryCollection` to contain the `Geometry`s in it.
`static void`	`clear()`
`GeometryFactory`	`convertAxisCount(int axisCount)`
`GeometryFactory`	`convertScales(double... scales)`
`GeometryFactory`	`convertSrid(int srid)`
`double[]`	`copyPrecise(double[] values)`
`static GeometryFactory`	`create(Map<String,Object> properties)`
`Point`	`createCoordinates(double... coordinates)`
`Point`	`createCoordinates(Point point)`
`LineString`	`createCoordinatesList(Collection<?> points)`
`static GeometryFactory`	`fixed(CoordinateSystem coordinateSystem, int axisCount, double... scales)`
`static GeometryFactory`	`fixed(int srid, double... scales)` Get a GeometryFactory with the coordinate system, 2D axis (x & y) and a fixed x, y precision model.
`static GeometryFactory`	`fixed(int srid, int axisCount, double... scales)` Get a GeometryFactory with the coordinate system, number of axis and a fixed x, y & fixed z precision models.
`static GeometryFactory`	`fixedNoSrid(double... scales)` Get a GeometryFactory with no coordinate system, 3D axis (x, y & z) and a fixed x, y & floating z precision models.
`static GeometryFactory`	`floating(CoordinateSystem coordinateSystem, int axisCount)` get a geometry factory with a floating scale.
`static GeometryFactory`	`floating(int srid, int axisCount)` Get a GeometryFactory with the coordinate system, number of axis and a floating precision model.
`static GeometryFactory`	`floating3()` Get a GeometryFactory with no coordinate system, 3D axis (x, y & z) and a floating precision model.
`static GeometryFactory`	`floating3(CoordinateSystem coordinateSystem)` get a 3d geometry factory with a floating scale.
`static GeometryFactory`	`floating3(int srid)` Get a GeometryFactory with the coordinate system, 3D axis (x, y & z) and a floating precision models.
`Geometry`	`geometry()`
`<V extends Geometry> V`	`geometry(Class<?> targetClass, Geometry geometry)` Create a new geometry of the requested target geometry class.
`<V extends Geometry> V`	`geometry(Collection<? extends Geometry> geometries)` Create a new geometry my flattening the input geometries, ignoring and null or empty geometries.
`<V extends Geometry> V`	`geometry(Geometry... geometries)`
`Geometry`	`geometry(Geometry geometry)` Creates a deep copy of the input `Geometry`.
`<T extends Geometry> T`	`geometry(String wkt)`
`<T extends Geometry> T`	`geometry(String wkt, boolean useAxisCountFromGeometryFactory)`
`GeometryCollection`	`geometryCollection()`
`<V extends GeometryCollection> V`	`geometryCollection(Collection<? extends Geometry> geometries)`
`<V extends GeometryCollection> V`	`geometryCollection(Geometry... geometries)`
`static GeometryFactory`	`get(Object factory)`
`int`	`getAxisCount()`
`static String`	`getAxisName(int axisIndex)`
`Point`	`getCoordinates(Point point)`
`CoordinatesOperation`	`getCoordinatesOperation(GeometryFactory geometryFactory)` Get the `CoordinatesOperation` to convert between this factory's and the other factory's `CoordinateSystem`.
`CoordinateSystem`	`getCoordinateSystem()`
`static GeometryFactory`	`getFactory(String wkt)` Get a GeometryFactory with the coordinate system, 3D axis (x, y & z) and a floating precision models.
`GeometryFactory`	`getGeographicGeometryFactory()`
`List<Geometry>`	`getGeometries(Collection<? extends Geometry> geometries)`
`LineString[]`	`getLineStringArray(Collection<?> lines)`
`int`	`getMaximumSignificantDigits()` Returns the maximum number of significant digits provided by this precision model.
`Point[]`	`getPointArray(Collection<?> pointsList)`
`Polygon[]`	`getPolygonArray(Collection<?> polygonList)`
`Point[]`	`getPrecise(Point... points)`
`Point`	`getPreciseCoordinates(Point point)`
`double`	`getResolution(int axisIndex)`
`double`	`getResolutionXy()`
`double`	`getResolutionZ()`
`double`	`getScale(int axisIndex)`
`static double[]`	`getScales(int axisCount, double... scales)`
`double`	`getScaleXY()`
`double`	`getScaleZ()`
`int`	`getSrid()` Gets the srid value defined for this factory.
`int`	`hashCode()`
`boolean`	`hasM()`
`boolean`	`hasZ()`
`protected void`	`init(int axisCount, double... scales)`
`boolean`	`isFloating()`
`boolean`	`isGeographics()`
`boolean`	`isProjected()`
`boolean`	`isSameCoordinateSystem(GeometryFactory geometryFactory)`
`LinearRing`	`linearRing()`
`LinearRing`	`linearRing(Collection<?> points)`
`LinearRing`	`linearRing(int axisCount, double... coordinates)`
`LinearRing`	`linearRing(int axisCount, int vertexCount, double... coordinates)`
`LinearRing`	`linearRing(LineString points)` Creates a `LinearRing` using the given `LineString`.
`LinearRing`	`linearRing(Point... points)` Creates a `LinearRing` using the given `Coordinates`s.
`LineSegment`	`lineSegment(Point p0, Point p1)`
`LineString`	`lineString()`
`LineString`	`lineString(Collection<?> points)`
`LineString`	`lineString(int axisCount, double... coordinates)`
`LineString`	`lineString(int axisCount, int vertexCount, double... coordinates)`
`LineString`	`lineString(LineString lineString)`
`LineString`	`lineString(Point... points)`
`void`	`makePrecise(double... values)`
`void`	`makePrecise(double[] values, double[] valuesPrecise)`
`void`	`makePrecise(int axisCount, double... coordinates)`
`double`	`makePrecise(int axisIndex, double value)`
`double`	`makeXyPrecise(double value)`
`double`	`makeZPrecise(double value)`
`MultiLineString`	`multiLineString(Collection<?> lines)`
`MultiLineString`	`multiLineString(Geometry geometry)`
`MultiLineString`	`multiLineString(LineString... lines)` Creates a MultiLineString using the given LineStrings; a null or empty array will create an empty MultiLineString.
`MultiLineString`	`multiLineString(Object... lines)`
`MultiPoint`	`multiPoint()`
`MultiPoint`	`multiPoint(Collection<?> points)`
`MultiPoint`	`multiPoint(Geometry geometry)`
`MultiPoint`	`multiPoint(int axisCount, double... coordinates)`
`MultiPoint`	`multiPoint(LineString coordinatesList)` Creates a `MultiPoint` using the points in the given `LineString`.
`MultiPoint`	`multiPoint(Object... points)`
`MultiPoint`	`multiPoint(Point... points)` Creates a `MultiPoint` using the given `Point`s.
`MultiPolygon`	`multiPolygon(Collection<?> polygons)`
`MultiPolygon`	`multiPolygon(Geometry geometry)`
`MultiPolygon`	`multiPolygon(Object... polygons)`
`MultiPolygon`	`multiPolygon(Polygon[] polygons)` Creates a MultiPolygon using the given Polygons; a null or empty array will create an empty Polygon.
`Point`	`point()` Create an empty `Point`.
`Point`	`point(double... coordinates)` Create a new `Point` from the specified point coordinates.
`Point`	`point(LineString points)` Creates a Point using the given LineString; a null or empty LineString will create an empty Point.
`Point`	`point(Object object)` Create a new `Point` from the object using the following rules.
`Point`	`point(Point point)` Create a new `Point` from the specified point (`Coordinates`).
`PolygonImpl`	`polygon()`
`Polygon`	`polygon(LinearRing shell)` Constructs a `Polygon` with the given exterior boundary.
`Polygon`	`polygon(LineString... rings)`
`Polygon`	`polygon(List<?> rings)`
`Polygon`	`polygon(Object... rings)`
`Polygon`	`polygon(Polygon polygon)`
`<G extends Geometry> G`	`project(G geometry)` Project the geometry if it is in a different coordinate system
`Map<String,Object>`	`toMap()` Convert the object to a Map of property name, value pairs.
`String`	`toString()`
`static GeometryFactory`	`wgs84()`
`static GeometryFactory`	`worldMercator()`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, notify, notifyAll, wait, wait, wait

- Constructor Detail
  - GeometryFactory
```
protected GeometryFactory(CoordinateSystem coordinateSystem,
               int axisCount,
               double... scales)
```
  - GeometryFactory
```
protected GeometryFactory(int srid,
               int axisCount,
               double... scales)
```
- Method Detail
  - clear
```
public static void clear()
```
  - create
```
public static GeometryFactory create(Map<String,Object> properties)
```
  - fixed
```
public static GeometryFactory fixed(CoordinateSystem coordinateSystem,
                    int axisCount,
                    double... scales)
```
  - fixed
```
public static GeometryFactory fixed(int srid,
                    double... scales)
```
    Get a GeometryFactory with the coordinate system, 2D axis (x & y) and a fixed x, y precision model.
    
    Parameters:
    srid - The EPSG coordinate system id.
    scaleXY - The scale factor used to round the x, y coordinates. The precision is 1 / scaleXy. A scale factor of 1000 will give a precision of 1 / 1000 = 1mm for projected coordinate systems using metres.
    
    Returns:
    The geometry factory.
  - fixed
```
public static GeometryFactory fixed(int srid,
                    int axisCount,
                    double... scales)
```
    Get a GeometryFactory with the coordinate system, number of axis and a fixed x, y & fixed z precision models.
    
    Parameters:
    srid - The EPSG coordinate system id.
    axisCount - The number of coordinate axis. 2 for 2D x & y coordinates. 3 for 3D x, y & z coordinates.
    scaleXY - The scale factor used to round the x, y coordinates. The precision is 1 / scaleXy. A scale factor of 1000 will give a precision of 1 / 1000 = 1mm for projected coordinate systems using metres.
    scaleZ - The scale factor used to round the z coordinates. The precision is 1 / scaleZ. A scale factor of 1000 will give a precision of 1 / 1000 = 1mm for projected coordinate systems using metres.
    
    Returns:
    The geometry factory.
  - fixedNoSrid
```
public static GeometryFactory fixedNoSrid(double... scales)
```
    Get a GeometryFactory with no coordinate system, 3D axis (x, y & z) and a fixed x, y & floating z precision models.
    
    Parameters:
    scaleXY - The scale factor used to round the x, y coordinates. The precision is 1 / scaleXy. A scale factor of 1000 will give a precision of 1 / 1000 = 1mm for projected coordinate systems using metres.
    
    Returns:
    The geometry factory.
  - floating
```
public static GeometryFactory floating(CoordinateSystem coordinateSystem,
                       int axisCount)
```
    get a geometry factory with a floating scale.
  - floating
```
public static GeometryFactory floating(int srid,
                       int axisCount)
```
    Get a GeometryFactory with the coordinate system, number of axis and a floating precision model.
    
    Parameters:
    srid - The EPSG coordinate system id.
    axisCount - The number of coordinate axis. 2 for 2D x & y coordinates. 3 for 3D x, y & z coordinates.
    
    Returns:
    The geometry factory.
  - floating3
```
public static GeometryFactory floating3()
```
    Get a GeometryFactory with no coordinate system, 3D axis (x, y & z) and a floating precision model.
    
    Returns:
    The geometry factory.
  - floating3
```
public static GeometryFactory floating3(CoordinateSystem coordinateSystem)
```
    get a 3d geometry factory with a floating scale.
  - floating3
```
public static GeometryFactory floating3(int srid)
```
    Get a GeometryFactory with the coordinate system, 3D axis (x, y & z) and a floating precision models.
    
    Parameters:
    srid - The EPSG coordinate system id.
    
    Returns:
    The geometry factory.
  - get
```
public static GeometryFactory get(Object factory)
```
  - getAxisName
```
public static String getAxisName(int axisIndex)
```
  - getFactory
```
public static GeometryFactory getFactory(String wkt)
```
    Get a GeometryFactory with the coordinate system, 3D axis (x, y & z) and a floating precision models.
    
    Parameters:
    srid - The EPSG coordinate system id.
    
    Returns:
    The geometry factory.
  - getScales
```
public static double[] getScales(int axisCount,
                 double... scales)
```
  - wgs84
```
public static GeometryFactory wgs84()
```
  - worldMercator
```
public static GeometryFactory worldMercator()
```
  - addGeometries
```
public void addGeometries(List<Geometry> geometryList,
                 Geometry geometry)
```
  - boundingBox
```
public BoundingBox boundingBox()
```
  - buildGeometry
```
public Geometry buildGeometry(Collection<? extends Geometry> geometries)
```
    Build an appropriate Geometry, MultiGeometry, or GeometryCollection to contain the Geometrys in it. For example:
    - If geomList contains a single Polygon, the Polygon is returned.
    - If geomList contains several Polygons, a MultiPolygon is returned.
    - If geomList contains some Polygons and some LineStrings, a GeometryCollection is returned.
    - If geomList is empty, an empty GeometryCollection is returned
    Note that this method does not "flatten" Geometries in the input, and hence if any MultiGeometries are contained in the input a GeometryCollection containing them will be returned.
    Parameters:
    geometries - the Geometrys to combine
    
    Returns:
    a Geometry of the "smallest", "most type-specific" class that can contain the elements of geomList .
  - convertAxisCount
```
public GeometryFactory convertAxisCount(int axisCount)
```
  - convertScales
```
public GeometryFactory convertScales(double... scales)
```
  - convertSrid
```
public GeometryFactory convertSrid(int srid)
```
  - copyPrecise
```
public double[] copyPrecise(double[] values)
```
  - createCoordinates
```
public Point createCoordinates(double... coordinates)
```
  - createCoordinates
```
public Point createCoordinates(Point point)
```
  - createCoordinatesList
```
public LineString createCoordinatesList(Collection<?> points)
```
  - geometry
```
public Geometry geometry()
```
  - geometry
```
public <V extends Geometry> V geometry(Class<?> targetClass,
                              Geometry geometry)
```
    Create a new geometry of the requested target geometry class.
    
    Parameters:
    targetClass -
    geometry -
    
    Returns:
  - geometry
```
public <V extends Geometry> V geometry(Collection<? extends Geometry> geometries)
```
    Create a new geometry my flattening the input geometries, ignoring and null or empty geometries. If there are no geometries an empty GeometryCollection will be returned. If there is one geometry that single geometry will be returned. Otherwise the result will be a subclass of GeometryCollection.
    
    Parameters:
    geometries -
    
    Returns:
  - geometry
```
public <V extends Geometry> V geometry(Geometry... geometries)
```
  - geometry
```
public Geometry geometry(Geometry geometry)
```
    Creates a deep copy of the input Geometry.
    This is a convenient way to change the LineString used to represent a geometry, or to change the factory used for a geometry.
    Geometry.clone() can also be used to make a deep copy, but it does not allow changing the LineString type.
    
    Returns:
    a deep copy of the input geometry, using the LineString type of this factory
    See Also:
    Geometry.clone()
  - geometry
```
public <T extends Geometry> T geometry(String wkt)
```
  - geometry
```
public <T extends Geometry> T geometry(String wkt,
                              boolean useAxisCountFromGeometryFactory)
```
  - geometryCollection
```
public GeometryCollection geometryCollection()
```
  - geometryCollection
```
public <V extends GeometryCollection> V geometryCollection(Collection<? extends Geometry> geometries)
```
  - geometryCollection
```
public <V extends GeometryCollection> V geometryCollection(Geometry... geometries)
```
  - getAxisCount
```
public int getAxisCount()
```
  - getCoordinates
```
public Point getCoordinates(Point point)
```
  - getCoordinatesOperation
```
public CoordinatesOperation getCoordinatesOperation(GeometryFactory geometryFactory)
```
    Get the CoordinatesOperation to convert between this factory's and the other factory's CoordinateSystem.
    
    Parameters:
    geometryFactory - The geometry factory to convert to.
    
    Returns:
    The coordinates operation or null if no conversion is available.
  - getCoordinateSystem
```
public CoordinateSystem getCoordinateSystem()
```
  - getGeographicGeometryFactory
```
public GeometryFactory getGeographicGeometryFactory()
```
  - getGeometries
```
public List<Geometry> getGeometries(Collection<? extends Geometry> geometries)
```
  - getLineStringArray
```
public LineString[] getLineStringArray(Collection<?> lines)
```
  - getMaximumSignificantDigits
```
public int getMaximumSignificantDigits()
```
    Returns the maximum number of significant digits provided by this precision model. Intended for use by routines which need to print out decimal representations of precise values .
    This method would be more correctly called getMinimumDecimalPlaces, since it actually computes the number of decimal places that is required to correctly display the full precision of an ordinate value.
    Since it is difficult to compute the required number of decimal places for scale factors which are not powers of 10, the algorithm uses a very rough approximation in this case. This has the side effect that for scale factors which are powers of 10 the value returned is 1 greater than the true value.
    
    Returns:
    the maximum number of decimal places provided by this precision model
  - getPointArray
```
public Point[] getPointArray(Collection<?> pointsList)
```
  - getPolygonArray
```
public Polygon[] getPolygonArray(Collection<?> polygonList)
```
  - getPrecise
```
public Point[] getPrecise(Point... points)
```
  - getPreciseCoordinates
```
public Point getPreciseCoordinates(Point point)
```
  - getResolution
```
public double getResolution(int axisIndex)
```
  - getResolutionXy
```
public double getResolutionXy()
```
  - getResolutionZ
```
public double getResolutionZ()
```
  - getScale
```
public double getScale(int axisIndex)
```
  - getScaleXY
```
public double getScaleXY()
```
  - getScaleZ
```
public double getScaleZ()
```
  - getSrid
```
public int getSrid()
```
    Gets the srid value defined for this factory.
    
    Returns:
    the factory srid value
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - hasM
```
public boolean hasM()
```
  - hasZ
```
public boolean hasZ()
```
  - init
```
protected void init(int axisCount,
        double... scales)
```
  - isFloating
```
public boolean isFloating()
```
  - isGeographics
```
public boolean isGeographics()
```
  - isProjected
```
public boolean isProjected()
```
  - isSameCoordinateSystem
```
public boolean isSameCoordinateSystem(GeometryFactory geometryFactory)
```
  - linearRing
```
public LinearRing linearRing()
```
  - linearRing
```
public LinearRing linearRing(Collection<?> points)
```
  - linearRing
```
public LinearRing linearRing(int axisCount,
                    double... coordinates)
```
  - linearRing
```
public LinearRing linearRing(int axisCount,
                    int vertexCount,
                    double... coordinates)
```
  - linearRing
```
public LinearRing linearRing(LineString points)
```
    Creates a LinearRing using the given LineString. A null or empty array creates an empty LinearRing. The points must form a closed and simple linestring.
    
    Parameters:
    coordinates - a LineString (possibly empty), or null
    
    Returns:
    the created LinearRing
    
    Throws:
    
    IllegalArgumentException - if the ring is not closed, or has too few points
  - linearRing
```
public LinearRing linearRing(Point... points)
```
    Creates a LinearRing using the given Coordinatess. A null or empty array creates an empty LinearRing. The points must form a closed and simple linestring.
    
    Parameters:
    coordinates - an array without null elements, or an empty array, or null
    
    Returns:
    the created LinearRing
    
    Throws:
    
    IllegalArgumentException - if the ring is not closed, or has too few points
  - lineSegment
```
public LineSegment lineSegment(Point p0,
                      Point p1)
```
  - lineString
```
public LineString lineString()
```
  - lineString
```
public LineString lineString(Collection<?> points)
```
  - lineString
```
public LineString lineString(int axisCount,
                    double... coordinates)
```
  - lineString
```
public LineString lineString(int axisCount,
                    int vertexCount,
                    double... coordinates)
```
  - lineString
```
public LineString lineString(LineString lineString)
```
  - lineString
```
public LineString lineString(Point... points)
```
  - makePrecise
```
public void makePrecise(double... values)
```
  - makePrecise
```
public void makePrecise(double[] values,
               double[] valuesPrecise)
```
  - makePrecise
```
public double makePrecise(int axisIndex,
                 double value)
```
  - makePrecise
```
public void makePrecise(int axisCount,
               double... coordinates)
```
  - makeXyPrecise
```
public double makeXyPrecise(double value)
```
  - makeZPrecise
```
public double makeZPrecise(double value)
```
  - multiLineString
```
public MultiLineString multiLineString(Collection<?> lines)
```
  - multiLineString
```
public MultiLineString multiLineString(Geometry geometry)
```
  - multiLineString
```
public MultiLineString multiLineString(LineString... lines)
```
    Creates a MultiLineString using the given LineStrings; a null or empty array will create an empty MultiLineString.
    
    Parameters:
    lineStrings - LineStrings, each of which may be empty but not null
    
    Returns:
    the created MultiLineString
  - multiLineString
```
public MultiLineString multiLineString(Object... lines)
```
  - multiPoint
```
public MultiPoint multiPoint()
```
  - multiPoint
```
public MultiPoint multiPoint(Collection<?> points)
```
  - multiPoint
```
public MultiPoint multiPoint(Geometry geometry)
```
  - multiPoint
```
public MultiPoint multiPoint(int axisCount,
                    double... coordinates)
```
  - multiPoint
```
public MultiPoint multiPoint(LineString coordinatesList)
```
    Creates a MultiPoint using the points in the given LineString. A null or empty LineString creates an empty MultiPoint.
    
    Parameters:
    coordinates - a LineString (possibly empty), or null
    
    Returns:
    a MultiPoint geometry
  - multiPoint
```
public MultiPoint multiPoint(Object... points)
```
  - multiPoint
```
public MultiPoint multiPoint(Point... points)
```
    Creates a MultiPoint using the given Points. A null or empty array will create an empty MultiPoint.
    
    Parameters:
    coordinates - an array (without null elements), or an empty array, or null
    
    Returns:
    a MultiPoint object
  - multiPolygon
```
public MultiPolygon multiPolygon(Collection<?> polygons)
```
  - multiPolygon
```
public MultiPolygon multiPolygon(Geometry geometry)
```
  - multiPolygon
```
public MultiPolygon multiPolygon(Object... polygons)
```
  - multiPolygon
```
public MultiPolygon multiPolygon(Polygon[] polygons)
```
    Creates a MultiPolygon using the given Polygons; a null or empty array will create an empty Polygon. The polygons must conform to the assertions specified in the OpenGIS Simple Features Specification for SQL.
    
    Parameters:
    polygons - Polygons, each of which may be empty but not null
    
    Returns:
    the created MultiPolygon
  - point
```
public Point point()
```
    Create an empty Point.
    
    Returns:
    The point.
  - point
```
public Point point(double... coordinates)
```
    Create a new Point from the specified point coordinates. If the point is null or has length < 2 an empty point will be returned. The result point will have the same getAxisCount() from this factory. Additional coordinates in the point will be ignored. If the point length is < getAxisCount() then Double.NaN will be used for that axis.
    
    Parameters:
    point - The coordinates to create the point from.
    
    Returns:
    The point.
  - point
```
public Point point(LineString points)
```
    Creates a Point using the given LineString; a null or empty LineString will create an empty Point.
    
    Parameters:
    points - a LineString (possibly empty), or null
    
    Returns:
    the created Point
  - point
```
public Point point(Object object)
```
    Create a new Point from the object using the following rules.
    - null using point()
    - Instances of Point using Geometry.copy(GeometryFactory)
    - Instances of Coordinates using point(Point)
    - Instances of LineString using point(LineString)
    - Instances of double[] using point(double[])
    - Instances of any other class throws IllegalArgumentException.
    Parameters:
    point - The coordinates to create the point from.
    
    Returns:
    The point.
    
    Throws:
    
    IllegalArgumentException - If the object is not an instance of a supported class.
  - point
```
public Point point(Point point)
```
    Create a new Point from the specified point (Coordinates). If the point is null or has Coordinates#getAxisCount() < 2 an empty point will be returned. The result point will have the same getAxisCount() from this factory. Additional axis in the point will be ignored. If the point has a smaller Geometry.getAxisCount() then Double.NaN will be used for that axis.
    
    Parameters:
    point - The coordinates to create the point from.
    
    Returns:
    The point.
  - polygon
```
public PolygonImpl polygon()
```
  - polygon
```
public Polygon polygon(LinearRing shell)
```
    Constructs a Polygon with the given exterior boundary.
    
    Parameters:
    shell - the outer boundary of the new Polygon, or null or an empty LinearRing if the empty geometry is to be created.
    
    Throws:
    
    IllegalArgumentException - if the boundary ring is invalid
  - polygon
```
public Polygon polygon(LineString... rings)
```
  - polygon
```
public Polygon polygon(List<?> rings)
```
  - polygon
```
public Polygon polygon(Object... rings)
```
  - polygon
```
public Polygon polygon(Polygon polygon)
```
  - project
```
public <G extends Geometry> G project(G geometry)
```
    Project the geometry if it is in a different coordinate system
    
    Parameters:
    geometry -
    
    Returns:
  - toMap
```
public Map<String,Object> toMap()
```
    Description copied from interface: MapSerializer
    Convert the object to a Map of property name, value pairs. The values can be one of the following supported types. Other values should be converted to one of these values.
    - boolean or Boolean
    - byte or Byte
    - short or Short
    - int or Integer
    - long or Long
    - float or Float
    - double or Double
    - String
    - Number subclasses
    - Collection of supported values
    - Map of supported values
    - null
    Specified by:
    
    toMap in interface MapSerializer
    
    Returns:
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object

Class GeometryFactory

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

GeometryFactory

GeometryFactory

Method Detail

clear

create

fixed

fixed

fixed

fixedNoSrid

floating

floating

floating3

floating3

floating3

get

getAxisName

getFactory

getScales

wgs84

worldMercator

addGeometries

boundingBox

buildGeometry

convertAxisCount

convertScales

convertSrid

copyPrecise

createCoordinates

createCoordinates

createCoordinatesList

geometry

geometry

geometry

geometry

geometry

geometry

geometry

geometryCollection

geometryCollection

geometryCollection

getAxisCount

getCoordinates

getCoordinatesOperation

getCoordinateSystem

getGeographicGeometryFactory

getGeometries

getLineStringArray

getMaximumSignificantDigits

getPointArray

getPolygonArray

getPrecise

getPreciseCoordinates

getResolution

getResolutionXy

getResolutionZ

getScale

getScaleXY

getScaleZ

getSrid

hashCode

hasM

hasZ

init

isFloating

isGeographics

isProjected

isSameCoordinateSystem

linearRing

linearRing

linearRing

linearRing

linearRing

linearRing

lineSegment

lineString