笔记

如果您需要负责坐标的存储方式（也许是浮点数而不是双精度数），则可以使用这些“高级”配置选项。这两个概念可以一起使用：如果将坐标存储在浮点数数组中，则仅使用JTS在计算过程中需要考虑浮点精度。

默认情况下创建的GeometryFactory可以正常工作。

Creating a Point

This time we are using a JTS GeometryFactory, although you can create one yourself (if you want to fiddle with Precision}} there is a global one available using the FactoryFinder.:

        GeometryFactory geometryFactory = JTSFactoryFinder.getGeometryFactory();Coordinate coord = new Coordinate(1, 1);Point point = geometryFactory.createPoint(coord);

“Well Known Text” is a simple text format defined by the Simple Feature for SQL specification:

        GeometryFactory geometryFactory = JTSFactoryFinder.getGeometryFactory();WKTReader reader = new WKTReader(geometryFactory);Point point = (Point) reader.read("POINT (1 1)");

If you need to represent many points (perhaps fence posts forming a fence) you can use use a MultiPoint.

Creating a LineString

The following makes a line string in the shape of a check mark:

GeometryFactory geometryFactory = JTSFactoryFinder.getGeometryFactory();Coordinate[] coords  =new Coordinate[] {new Coordinate(0, 2), new Coordinate(2, 0), new Coordinate(8, 6) };LineString line = geometryFactory.createLineString(coordinates);

Alternative - Reading a LineString from WKT:

GeometryFactory geometryFactory = JTSFactoryFinder.getGeometryFactory();WKTReader reader = new WKTReader( geometryFactory );
LineString line = (LineString) reader.read("LINESTRING(0 2, 2 0, 8 6)");

If you need to represent a line with gaps in it you can use a MultiLineString.

Creating a Polygon

The following makes a Polygon in the shape of a square:

GeometryFactory geometryFactory = JTSFactoryFinder.getGeometryFactory();Coordinate[] coords  =new Coordinate[] {new Coordinate(4, 0), new Coordinate(2, 2),new Coordinate(4, 4), new Coordinate(6, 2), new Coordinate(4, 0) };LinearRing ring = geometryFactory.createLinearRing( coords );
LinearRing holes[] = null; // use LinearRing[] to represent holes
Polygon polygon = geometryFactory.createPolygon(ring, holes );

Alternative - Reading a Polygon from WKT:

GeometryFactory geometryFactory = JTSFactoryFinder.getGeometryFactory( null );WKTReader reader = new WKTReader( geometryFactory );
Polygon polygon = (Polygon) reader.read("POLYGON((20 10, 30 0, 40 10, 30 20, 20 10))");

You can also create a Polygon will holes in it. And once again use a MultiPolygon to represent a single geometry made up of distinct shapes.

Creating CircularString

To create a CircularString (or a CircularRing) use the GeoTools CurvedGeometryFactory. When setting up a CurvedGeometryFactory the provided tolerance will be used during linearization:

        GeometryFactory geometryFactory = JTSFactoryFinder.getGeometryFactory();CurvedGeometryFactory curvedFactory =new CurvedGeometryFactory(geometryFactory, Double.MAX_VALUE);CoordinateSequence coords =PackedCoordinateSequenceFactory.DOUBLE_FACTORY.create(new double[] {10, 14, 6, 10, 14, 10}, 2);CircularString arc = (CircularString) curvedFactory.createCurvedGeometry(coords);

The circle arc is defined between coordinates 10,14 and 14, 10 passing through point 6,10. The example uses a PackedCoordinateSequence allowing an array of doubles to be used directly. Curve support is limited to 2D coordinates. A CircularLineString is returned in this case, a CircularRing would be produced if two or more curves were provided form a closed ring.

Reading a circular arc from WKT:

        GeometryFactory geometryFactory = JTSFactoryFinder.getGeometryFactory();CurvedGeometryFactory curvedfactory = new CurvedGeometryFactory(Double.MAX_VALUE);WKTReader2 reader = new WKTReader2(curvedfactory);CircularString arc = (CircularString) reader.read("CIRCULARSTRING(10 14,6 10,14 10)");

A CompoundCurve (or closed CompoundRing) consists mix of CircularString and/or plain LineString components.

Custom Curves

The JTS Topology Suite does not have any constructs to represent a “curve” or “circle” - GeoTools added that as an extension. The mathematics used by JTS is strictly limited to geometry made up of straight (i.e. linear) lines.

The GeoTools curve implementations rely on using control points to define a curve, and converting it to a straight lines at the last possible moment.

Curves can also be produced by hand using a little bit of math.

Creating a Circle:

private static Geometry createCircle(double x, double y, final double RADIUS) {GeometricShapeFactory shapeFactory = new GeometricShapeFactory();shapeFactory.setNumPoints(32);shapeFactory.setCentre(new Coordinate(x, y));shapeFactory.setSize(RADIUS * 2);return shapeFactory.createCircle();
}

Even though GeometricShapeFactory is provided out of the box from JTS; there is nothing fancy about the code. It creates a series of coordinates in a circle.

Another approach is to create a curve or shape object with one of Java’s handy Shape classes and then extract the coordinates from that object to create your geometry.

Arcs without the math:

private static Geometry createBezierCurve(Coordinate start,Coordinate end,Coordinate ctrlPoint1,Coordinate ctrlPoint2double smooth) {Shape curve = new CubicCurve2D.Double(start.x, start.y,ctrlPoint1.x, ctrlPoint1.y,ctrlPoint2.x, ctrlPoint2.y,end.x, end.y);// the value of the smooth arg determines how closely the line// segments between points approximate the smooth curve// (see javadocs for Shape.getPathIterator method)PathIterator iter = curve.getPathIterator(null, smooth);// a length 6 array is required for the iteratordouble[] iterBuf = new double[6];List<Coordinate> coords = new ArrayList<Coordinate>();while (!iter.isDone()) {iter.currentSegment(iterBuf);coords.add(new Coordinate(buf[0], buf[1]);iter.next();}GeometryFactory gf = new GeometryFactory();return gf.createLineString(coords.toArray(new Coordinate[coords.size()]));
}

Here’s an example of some randomly orientated and shaped curves generated in this way…

Sometimes you need to generate a smooth curve that is guaranteed to pass through a specified set of points. The tried and true approach here is to use a spline function. This generates a set of polynomial (cubic) curves, each of which fits a part of the data and joins smoothly to its neighboring curves.

Splines:

public Geometry splineInterpolatePoints(double[] xPoints, double[] yPoints) {/** First we create a LineString of segments with the* input points as vertices.*/final int N = xPoints.length;Coordinate[] coords = new Coordinate[N];for (int i = 0; i < N; i++) {coords[i] = new Coordinate(xPoints[i], yPoints[i]);}GeometryFactory gf = new GeometryFactory();LineString line = gf.createLineString(coords);/** Now we use the GeoTools JTS utility class to smooth the* line. The returned Geometry will have all of the vertices* of the input line plus extra vertices tracing a spline* curve. The second argument is the 'fit' parameter which* can be in the range 0 (loose fit) to 1 (tightest fit).*/return JTS.smooth(line, 0.0);
}

Here is an example of this in use:

Example smoothing a polygon:

WKTReader reader = new WKTReader();
Geometry tShape = reader.read(
"POLYGON((10 0, 10 20, 0 20, 0 30, 30 30, 30 20, 20 20, 20 0, 10 0))");Geometry tLoose = JTS.smooth(tShape, 0.0);
Geometry tTighter = JTS.smooth(tShape, 0.75);

Here is the resulting image:

Geometry

Using Geometry is pretty straight forward, although a little intimidating when starting out due to the number of methods.

Some summary information is available:

• getArea() - area returned in the same units as the coordinates (be careful of latitude/longitude data!)

• getCentroid() - the center of the geometry

• getEnvelope() - returns a geometry which is probably not what you wanted

• getEnvelopeInternal() - this returns a useful Envelope

• getInteriorPoint() - the center of the geometry (that is actually on the geometry)

• getDimension()

Geometry relationships are represented by the following functions returning true or false:

• disjoint(Geometry) - same as “not” intersects

• touches(Geometry) - geometry have to just touch, crossing or overlap will not work

• intersects(Geometry)

• crosses(Geometry)

• within(Geometry) - geometry has to be full inside

• contains(Geometry)

• overlaps(Geometry) - has to actually overlap the edge, being within or touching will not work

• covers(Geometry)

• coveredBy(Geometry)

• relate(Geometry, String) - allows general check of relationship see dim9 page

• relate(Geometry)

To actually determine a shape based on two geometry:

• intersection(Geometry)

• union(Geometry)

• difference(Geometry)

• symDifference(Geometry)

Some of the most helpful functions are:

• distance(Geometry)

• buffer(double) - used to buffer the edge of a geometry to produce a polygon

• union() - used on a geometry collection to produce a single geometry

The three most difficult methods are here (they will be discussed in detail):

• equals(Object) - normal Java equals which checks that the two objects are the same instance

• equals(Geometry) - checks if the geometry is the same shape

• equalsExact(Geometry) - check if the data structure is the same

有一些簿记方法可以帮助您发现如何构造几何体：

• getGeometryFactory()

• getPreceisionModel()

• toText() -几何的WKT表示

• getGeoemtryType()-称为工厂方法（即point，linestring等。）

有两种方法可以存储您的开发人员信息：

• getSRID() -存储“空间参考ID”，在使用数据库时用作外部键

• getUserData()-旨在供开发人员使用，最佳做法是存储java.util.Map。GeoTools有时会使用此字段来存储asrsName或full CoordinateReferenceSystem。

几何枚举

使用Geometry的代码最终需要进行大量instanceof测试，以确定Geometry所使用的类型（采取适当的措施）。

在这种情况下，我们定义了一个枚举来帮助您：

    public boolean hit(Point point, Geometry geometry) {final double MAX_DISTANCE = 0.001;switch (Geometries.get(geometry)) {case POINT:case MULTIPOINT:case LINESTRING:case MULTILINESTRING:// Test if p is within a threshold distancereturn geometry.isWithinDistance(point, MAX_DISTANCE);case POLYGON:case MULTIPOLYGON:// Test if the polygonal geometry contains preturn geometry.contains(point);            default:// For simplicity we just assume distance check will work for other// types (e.g. GeometryCollection) in this examplereturn geometry.isWithinDistance(point, MAX_DISTANCE);}}

精密模型

开箱即用的JTS使用默认的双精度模型。使用配置您GeometryFactory的PrecisionModel可以使您以与默认值不同的分辨率工作。

PrecisionModel在使用几何图形时，形成了“数值稳定性”的核心。当使用大值时，Java内置的数学不是很准确。通过在PrecisionModelJTS中明确捕获“舍入”过程，可以管理这些类型的错误，并在工作速度与准确性之间做出适当的权衡。

• 即使以双精度工作时，也会经常发生舍入。

  特别是如果您正在使用具有大量数字的坐标系，并且距原点还有很长的路要走。

• 要查看的另一个原因PrecisionModel是确保它与您的数据最终用途相匹配。如果您知道只在屏幕上显示答案，则可能会降低精度。

  通过PrecisionModel与您的预期用途匹配，某些长时间运行的操作（需要收敛于一个答案）可以在达到您期望的详细程度时停止。如果结果要在一天结束时四舍五入，就没有必要为更高的位数做额外的工作。

以下代码示例考虑到传递的位置仅作为浮点值x / y提供。我们创建了这个测试点处理此GeometryFactory，需要一个PrecisionModel说法。测试点将被标记为具有一定的有限精度，并且所有JTS操作都将考虑这一点。

有多种指定a的方法，PrecisionModel但在此我们将其基于用于坐标比较的小数位数。

private boolean polyContains(Polygon poly, float x, float y, int numDecPlaces) {double scale = Math.pow(10, numDecPlaces);PrecisionModel pm = new PrecisionModel(scale);GeometryFactory gf = new GeometryFactory(pm);Geometry testPoint = gf.createPoint(new Coordinate(x, y));return poly.contains(testPoint);
}

您还可以PrecisionModel使用几个常量定义：

pm = new PrecisionModel( PrecisionModel.Type.FIXED ); // fixed decimal point
pm = new PrecisionModel( PrecisionModel.Type.FLOATING ); // for Java double
pm = new PrecisionModel( PrecisionModel.Type.FLOATING_SINGLE ); // for Java float

这是一个不经常使用的高级功能。

CoordinateSequence

您可能CoordinateSequenceFactory出于效率和/或减少内存使用的原因而希望提供一个自定义。

内部几何通常与Coordinate []一起使用。但是，为提高效率，许多用于JTS的空间格式会将值存储为flat double []或float []。通过实现CoordinateSequenceFactoryGeoTools，可以教导JTS如何例如直接从shapefile中处理值。

这是一个不经常使用的高级功能。

捷讯

上面使用的一些代码示例引用了JTS实用程序类。此类由gt-main模块提供；并包含许多用于处理几何的有用方法。