public static Ring invertOrientation( Ring ring ) { Ring fixedRing = null; switch ( ring.getRingType() ) { case LinearRing: { LinearRing linearRing = (LinearRing) ring; fixedRing = new DefaultLinearRing( ring.getId(), ring.getCoordinateSystem(), ring.getPrecision(), invertOrientation( linearRing.getControlPoints() ) ); break; } case Ring: { List<Curve> fixedMemberCurves = new ArrayList<Curve>( ring.getMembers().size() ); for ( Curve memberCurve : ring.getMembers() ) { fixedMemberCurves.add( invertOrientation( memberCurve ) ); } fixedRing = new DefaultRing( ring.getId(), ring.getCoordinateSystem(), ring.getPrecision(), fixedMemberCurves ); break; } } fixedRing.setProperties( ring.getProperties() ); return fixedRing; }
/** * Extracts the coordinates in the given ring by calling the get as linestring method. * * @param someRing * to extract the geometries from. * @param min * will contain the minimum of all geometries of the given geometry * @param max * will contain the maximum of all geometries in the given geometry * @return the coordinates of this ring. */ private float[] extractGeometries( Ring someRing, double[] min, double[] max ) { float[] coordinates = null; if ( someRing != null ) { LineString ls = someRing.getAsLineString(); coordinates = extractGeometries( ls, min, max ); } return coordinates; }
private LinearRing transform( Ring ring, Transformation trans ) throws TransformationException { if ( ring != null ) { // TODO DefaultRing.getAsLineString currently returns an UnsupportedOpertionException // interior.getAsLineString().getControlPoints(), Points cP = ring.getControlPoints(); Points tcP = transform( cP, trans ); return geomFactory.createLinearRing( ring.getId(), getTargetCRS(), tcP ); } return null; }
switch ( ring.getRingType() ) { case LinearRing: { LinearRing linearRing = (LinearRing) ring; Points fixedPoints = getFixedPoints( linearRing.getControlPoints(), linearRing.getStartPoint() ); fixedCurve = new DefaultLinearRing( ring.getId(), ring.getCoordinateSystem(), ring.getPrecision(), fixedPoints ); break; List<Curve> repairedCurves = new ArrayList<Curve>( ring.getMembers() ); Curve lastCurve = repairedCurves.get( repairedCurves.size() - 1 ); repairedCurves.set( repairedCurves.size() - 1, fixCurve( lastCurve, ring.getStartPoint() ) ); fixedCurve = new DefaultRing( ring.getId(), ring.getCoordinateSystem(), ring.getPrecision(), repairedCurves ); break;
throws XMLStreamException, UnknownCRSException, TransformationException { switch ( ring.getRingType() ) { case Ring: if ( GML_32 != version ) { for ( Curve c : ring.getMembers() ) { writer.writeStartElement( gmlNs, "curveMember" ); exportCurve( c );
if ( curve instanceof Ring ) { Ring ring = (Ring) curve; List<Curve> curves = ring.getMembers(); List<Curve> linearizedMembers = new ArrayList<Curve>( curves.size() ); for ( Curve member : curves ) { linearizedMembers.add( linearize( member, crit ) ); linearizedCurve = geomFac.createRing( ring.getId(), ring.getCoordinateSystem(), linearizedMembers ); } else { List<CurveSegment> segments = curve.getCurveSegments();
LinearRing movedExteriorRing = null; if ( exterior != null ) { movedExteriorRing = fac.createLinearRing( exterior.getId(), exterior.getCoordinateSystem(), move( exterior.getAsLineString().getControlPoints(), offx, offy ) ); List<Ring> movedInteriorRings = new ArrayList<Ring>( interiorRings.size() ); for ( Ring interior : interiorRings ) { movedInteriorRings.add( fac.createLinearRing( interior.getId(), interior.getCoordinateSystem(), move( interior.getAsLineString().getControlPoints(), offx, offy ) ) );
@Override public boolean isSFSCompliant() { if ( exteriorRing == null || exteriorRing.getRingType() != RingType.LinearRing ) { return false; } if ( interiorRings != null ) { for ( Ring interiorRing : interiorRings ) { if ( interiorRing.getRingType() != RingType.LinearRing ) { return false; } } } return true; }
@Override public Points getExteriorRingCoordinates() { if ( patches.size() == 1 ) { if ( patches.get( 0 ) instanceof PolygonPatch ) { PolygonPatch patch = (PolygonPatch) patches.get( 0 ); return patch.getExteriorRing().getControlPoints(); } throw new IllegalArgumentException( Messages.getMessage( "SURFACE_IS_NON_PLANAR" ) ); } throw new IllegalArgumentException( Messages.getMessage( "SURFACE_MORE_THAN_ONE_PATCH" ) ); }
ring.setType( type ); ring.setProperties( props );
/** * Returns a JTS geometry for the given {@link Ring} (which is linearized first). * * @param ring * {@link Ring} that consists of {@link LineStringSegment}, {@link Arc} and {@link Circle} segments only * @return linear JTS ring geometry, null if no * @throws IllegalArgumentException * if the given input ring contains other segment types than {@link LineStringSegment}, {@link Arc} and * {@link Circle} */ private LinearRing getJTSRing( Ring ring ) { Ring linearizedRing = (Ring) linearizer.linearize( ring, crit ); List<Coordinate> coordinates = new LinkedList<Coordinate>(); for ( Curve member : linearizedRing.getMembers() ) { for ( CurveSegment segment : member.getCurveSegments() ) { for ( Point point : ( (LineStringSegment) segment ).getControlPoints() ) { coordinates.add( new Coordinate( point.get0(), point.get1() ) ); } } } return jtsFactory.createLinearRing( coordinates.toArray( new Coordinate[coordinates.size()] ) ); }
if ( outerRing.getId() != null && referenceExportStrategy.isObjectExported( outerRing.getId() ) ) { writer.writeEmptyElement( "gml", "outerBoundaryIs", GML21NS ); writer.writeAttribute( "xlink", XLNNS, "href", "#" + outerRing.getId() ); } else { writer.writeStartElement( "gml", "outerBoundaryIs", GML21NS ); for ( Ring ring : rings ) { writer.writeStartElement( "gml", "innerBoundaryIs", GML21NS ); if ( referenceExportStrategy.isObjectExported( ring.getId() ) ) { writer.writeAttribute( "xlink", XLNNS, "href", "#" + ring.getId() ); } else {
@Override public int getCoordinateDimension() { return exteriorRing.getCoordinateDimension(); }
/** * Writes a ring. * * @param geometry * @param writer * @throws IOException */ public void writeRing( Ring geometry, Writer writer ) throws IOException { switch ( geometry.getRingType() ) { case LinearRing: writeLinearRing( (LinearRing) geometry, writer ); break; case Ring: writeCurveGeometry( geometry, writer ); break; } }
/** * @param linearRing * @throws XMLStreamException * @throws UnknownCRSException * @throws TransformationException */ public void exportLinearRing( Ring linearRing ) throws XMLStreamException, TransformationException, UnknownCRSException { startGeometry( "LinearRing", linearRing ); exportCoordinates( linearRing.getControlPoints() ); writer.writeEndElement(); // </gml:LinearRing> }
public static Ring forceOrientation( Ring ring, boolean ccw ) { double shoelaceSum = 0; final List<Curve> curves = ring.getMembers(); for ( final Curve curve : curves ) { final List<CurveSegment> curveSegments = curve.getCurveSegments(); for ( final CurveSegment curveSegment : curveSegments ) { final CurveSegmentType segmentType = curveSegment.getSegmentType(); Points points; switch ( segmentType ) { case ARC_STRING: points = ( (ArcString) curveSegment ).getControlPoints(); case LINE_STRING_SEGMENT: points = ( (LineStringSegment) curveSegment ).getControlPoints(); for ( int i = 0; i < points.size(); i++ ) { final Point first = points.get( i ); final Point second = points.get( ( i + 1 ) % points.size() ); shoelaceSum += ( second.get0() - first.get0() ) * ( second.get1() + first.get1() ); } continue; default: LOG.warn( "Calculating orientation of " + segmentType.name() + " segments is not implemented yet. Ring orientation remains unchanged." ); return ring; } } } return shoelaceSum > 0 == ccw ? invertOrientation( ring ) : ring; }
private void exportPolygon( Polygon polygon ) throws XMLStreamException, UnknownCRSException, TransformationException { startGeometry( "Polygon", polygon ); Ring exteriorRing = polygon.getExteriorRing(); if ( exteriorRing.getId() != null && referenceExportStrategy.isObjectExported( exteriorRing.getId() ) ) { writer.writeEmptyElement( gmlNs, "exterior" ); writer.writeAttribute( XLNNS, "href", "#" + exteriorRing.getId() ); } else { referenceExportStrategy.addExportedId( exteriorRing.getId() ); writer.writeStartElement( gmlNs, "exterior" ); exportRing( exteriorRing ); writer.writeEndElement(); } if ( polygon.getInteriorRings() != null ) { for ( Ring ring : polygon.getInteriorRings() ) { if ( ring.getId() != null && referenceExportStrategy.isObjectExported( ring.getId() ) ) { writer.writeEmptyElement( gmlNs, "interior" ); writer.writeAttribute( XLNNS, "href", "#" + ring.getId() ); } else { referenceExportStrategy.addExportedId( ring.getId() ); writer.writeStartElement( gmlNs, "interior" ); exportRing( ring ); writer.writeEndElement(); } } } exportAdditionalProps( polygon ); writer.writeEndElement(); }
/** * Returns a fixed version of the given {@link Ring} object. * * @param ring * ring to be repaired * @return repaired ring, never <code>null</code> */ public static Ring fixUnclosedRing( Ring ring ) { Ring repaired = null; switch ( ring.getRingType() ) { case LinearRing: { LinearRing linearRing = (LinearRing) ring; Points fixedPoints = getFixedPoints( linearRing.getControlPoints(), linearRing.getStartPoint() ); repaired = new DefaultLinearRing( ring.getId(), ring.getCoordinateSystem(), ring.getPrecision(), fixedPoints ); break; } case Ring: { List<Curve> repairedCurves = new ArrayList<Curve>( ring.getMembers() ); Curve lastCurve = repairedCurves.get( repairedCurves.size() - 1 ); repairedCurves.set( repairedCurves.size() - 1, fixCurve( lastCurve, ring.getStartPoint() ) ); repaired = new DefaultRing( ring.getId(), ring.getCoordinateSystem(), ring.getPrecision(), repairedCurves ); break; } } repaired.setProperties( ring.getProperties() ); return repaired; }
private static Ring fixOrientation( Ring ring, boolean forceClockwise ) { if ( ring.getRingType() != LinearRing ) { throw new UnsupportedOperationException(); } LinearRing jtsRing = (LinearRing) ( (AbstractDefaultGeometry) ring ).getJTSGeometry(); Coordinate[] coords = jtsRing.getCoordinates(); // TODO check if inversions can be applied in any case (i.e. whether JTS has a guaranteed orientation of // intersection result polygons) boolean needsInversion = isCCW( coords ) == forceClockwise; if ( needsInversion ) { return invertOrientation( ring ); } return ring; }
@Override public List<Points> getInteriorRingsCoordinates() { List<Points> controlPoints = new ArrayList<Points>(); if ( patches.size() == 1 ) { if ( patches.get( 0 ) instanceof PolygonPatch ) { PolygonPatch patch = (PolygonPatch) patches.get( 0 ); List<Ring> interiorRings = patch.getInteriorRings(); for ( Ring ring : interiorRings ) { controlPoints.add( ring.getControlPoints() ); } } else { throw new IllegalArgumentException( Messages.getMessage( "SURFACE_IS_NON_PLANAR" ) ); } } else { throw new IllegalArgumentException( Messages.getMessage( "SURFACE_MORE_THAN_ONE_PATCH" ) ); } return controlPoints; }