GeoTools supports a "well known text" geometry parser that is able to produce ISO 19107 Geometry instances. This page documents the use of the parser, and provides a little bit of background on the state of ISO 19107 support in GeoTools.

ISO 19107 Support in GeoTools

The GeoAPI project provides interfaces for ISO Geometry interfaces, we make use of them day in and day out for transforming DirectPositions as described in the referencing module.

ISO 19107 also defines TransfineSet of which GeoTools has two implementations:

• unsupported/jts-wrapper
• unsupported/geometry

As indicated by their unsupported status neither has past our QA checks at this time.

What about JTS Topology Suite?

As mentioned in the introduction GeoTools makes use JTS Topology Suite (a representation of the Simple Features for SQL specification) rather than ISO Geometry. Just because the entire library is not using ISO Geometry yet; does not prevent you from going there in your own application. Just be sure to include one of the module mentioned above before you start.

What is TransfiniteSet

A TransfiniteSet is the same thing as a JTS Geometry near as I can tell...

From email - thanks Sunburned Surveyor and Bryce:

Creating an ISO Geometry from WKT

Start with a Factory

The first step to creating a Geometry is to acquire a GeometryFactory:

CoordianteReferenceSystem crs = CRS.decode("EPSG:4326");
Precision precision = new PrecisionModel();

GeometryFactory geometryFactory = new GeometryFactoryImpl( crs );

As you can see in the above example you need to already know your CoordinateReferenceSystem and Precision before creating a GeometryFactory. You can create and use several GeometryFactory instances at the same time if you need to work in several projections.

There is one problem here - the GeometryFactory is only good for making Geometry. And to make a Geometry you need Coordinates, and primitives and ...

Start with Several Factories

So I lied to you. You actually need a few more bits of the puzzle before we can accomplish anything.

PositionFactory positionFactory = new PositionFactoryImpl(...);
CoordinateFactory coordinateFactory = new CoordinateFactoryImpl(...);
PrimitiveFactory primitiveFactory = new PrimitiveFactoryImpl(...);
ComplexFactory complexFactory = new ComplexFactoryImpl(...);
AggregateFactory aggregtateFactory = new AggregateFactoryImpl(...);

WKTParser parser = new WKTParser( geometryFactory, primitiveFactory, positionFactory, aggregateFactory);

Point point = (Point) parser.parse( "POINT (80 340)" );

But wait!

• Where do all these Impls come from?
• What do they take as parameters?
• eek!

The answer is that the factory situation is starting to get so complex that we need to use a good tool to sort it out.

Use a Good Tool to Sort out the Factories

Using a container such as a PicoContainer, we can teach it about all the factories and dependencies and it will figure out what to use when you create a factory.

// create pico container
DefaultPicoContainer container = new DefaultPicoContainer();
		
// Teach Container about Factory Implementations we want to use
container.registerComponentImplementation(PositionFactoryImpl.class);
container.registerComponentImplementation(FeatGeomFactoryImpl.class);
container.registerComponentImplementation(AggregateFactoryImpl.class);
container.registerComponentImplementation(ComplexFactoryImpl.class);
container.registerComponentImplementation(GeometryFactoryImpl.class);
container.registerComponentImplementation(PrimitiveFactoryImpl.class);
		
// Teach Container about other dependencies needed
CoordinateReferenceSystem crs = DefaultGeographicCRS.WGS84;
container.registerComponentInstance( crs );
Precision pr = new PrecisionModel();
container.registerComponentInstance( pr );

// Now we can ask for factories and the container will figure out what dependencies that factory needs and do the work for you
PositionFactoryImpl pf = (PositionFactoryImpl ) container.getComponentInstanceOfType( PositionFactory.class );

// create something with the factory
DirectPosition dp = pf.createDirectPosition(new double[]{280,560});

Well Known Text Geometry Parser

The SFSQL specification defines a Well Known Text (WKT) format for representing the kind of simple (Point, Line, Polygon) geometry constructs covered by the simple feature for SQL specification.

We have a parser that will use a GeometryFactory to produce the ISO Geometry constructs for you. It will also parse some extra geometry types.

Examples

pending...