@SuppressWarnings("unchecked") public static <P extends Position> CoordinateReferenceSystem<P> mkCoordinateReferenceSystem( CoordinateReferenceSystem<?> baseCrs, LinearUnit verticalUnit, LinearUnit measureUnit, Class<P> positionType) { CoordinateReferenceSystem<?> crs = mkCoordinateReferenceSystem(baseCrs, verticalUnit, measureUnit); if (crs.getPositionClass().equals(positionType)) { return (CoordinateReferenceSystem<P>)crs; } throw new IllegalArgumentException(format("Invalid positionClass: %s not equals %s", crs.getPositionClass().getName(), positionType.getName())); }
public static Geographic2DCoordinateReferenceSystem getGeographicCoordinateReferenceSystemForEPSG(int epsgCode) { CoordinateReferenceSystem<? extends Position> crs = crsMap.get(CrsId.valueOf(epsgCode)); if (crs == null) return null; if (crs.getPositionClass().equals(G2D.class)) { return (Geographic2DCoordinateReferenceSystem) crs; } throw new RuntimeException(String.format("EPSG code %d doesn't refer to geographic projection system", epsgCode)); }
public static ProjectedCoordinateReferenceSystem getProjectedCoordinateReferenceSystemForEPSG(int epsgCode) { CoordinateReferenceSystem<? extends Position> crs = crsMap.get(CrsId.valueOf(epsgCode)); if (crs.getPositionClass().equals(C2D.class)) { return (ProjectedCoordinateReferenceSystem) crs; } throw new RuntimeException(String.format("EPSG code %d doesn't refer to geographic projection system", epsgCode)); }
@SuppressWarnings("unchecked") public static <P extends Position> P mkPosition(CoordinateReferenceSystem<P> crs, double... coordinates) { return mkPosition( crs.getPositionClass(), coordinates ); }
/** * Creates an empty Geometry * * @param crs the CoordinateReferenceSystem to use */ protected Geometry(CoordinateReferenceSystem<P> crs) { if (crs == null) throw new IllegalArgumentException("Received null CRS argument"); this.crs = crs; this.positions = PositionSequenceBuilders.fixedSized(0, crs.getPositionClass()).toPositionSequence(); }
@SuppressWarnings("unchecked") @SafeVarargs public static <P extends Position> MultiPoint<P> multipoint(CoordinateReferenceSystem<P> crs, P... positions) { PositionSequence<P> ps = Positions.collect(crs.getPositionClass(), positions); return Geometries.mkMultiPoint(ps, crs); }
public CountingPositionSequenceBuilder(CoordinateReferenceSystem<P> crs) { delegate = PositionSequenceBuilders.variableSized(crs.getPositionClass()); dim = crs.getCoordinateDimension(); }
public Point(P position, CoordinateReferenceSystem<P> crs) { this(new PackedPositionSequence<P>( Positions.getFactoryFor(crs.getPositionClass()), position.coords), crs); }
/** * @inheritDoc */ @Override public <P extends C2D, M extends C2D & Measured> Geometry<M> measureOnLength( final Geometry<P> geometry, final Class<M> positionTypeMarker, final boolean keepBeginMeasure) { if (geometry == null) throw new IllegalArgumentException("Geometry parameter must not be NULL"); if (positionTypeMarker == null) throw new IllegalArgumentException("PositionTypeMarker parameter must not be NULL"); if (geometry.getGeometryType() != GeometryType.LINESTRING && geometry.getGeometryType() != GeometryType.MULTILINESTRING) { throw new IllegalArgumentException("Geometry parameter must be of type LineString or MultiLineString"); } final CoordinateReferenceSystem<P> sourceCRS = geometry.getCoordinateReferenceSystem(); final CoordinateReferenceSystem<M> measuredVariant = !hasMeasureAxis(sourceCRS) ? (CoordinateReferenceSystem<M>) addLinearSystem(sourceCRS, Unit.METER) : (CoordinateReferenceSystem<M>)sourceCRS; if (!measuredVariant.getPositionClass().equals(positionTypeMarker)) { throw new IllegalArgumentException(String.format( "Inconsistent types: measured CRS has position type %s, but positionTypeMarker is %s.", measuredVariant.getPositionClass().getName(), positionTypeMarker.getName())); } return new OnLengthMeasureOp<M>(geometry, measuredVariant, keepBeginMeasure).execute(); }
private static <P extends Position> org.geolatte.geom.LineString<P> from(LineString jtsLineString, CoordinateReferenceSystem<P> crs) { CoordinateSequence cs = jtsLineString.getCoordinateSequence(); return new org.geolatte.geom.LineString<P>(pscsFactory.toPositionSequence(cs, crs.getPositionClass(), crs), crs); }
private static <P extends Position> org.geolatte.geom.Point<P> from(org.locationtech.jts.geom.Point jtsPoint, CoordinateReferenceSystem<P> crs) { CoordinateSequence cs = jtsPoint.getCoordinateSequence(); return new org.geolatte.geom.Point<P>(pscsFactory.toPositionSequence(cs, crs.getPositionClass(), crs), crs); }
public Class<P> getPositionClass() { return !getPositions().isEmpty() ? getPositions().getPositionClass() : this.crs.getPositionClass(); }
private <P extends Position> CoordinateSequence fromCoordinateArray(Coordinate[] coordinates, CoordinateReferenceSystem<P> crs) { PositionSequenceBuilder<P> builder = PositionSequenceBuilders.fixedSized(coordinates.length, crs.getPositionClass()); double[] ordinates = new double[crs.getCoordinateDimension()]; for (Coordinate co : coordinates) { copy(co, ordinates, crs); builder.add(ordinates); } return (CoordinateSequence) builder.toPositionSequence(); }
private <P extends Position> PositionSequence<P> readPositions(int numPos, ByteBuffer byteBuffer, CoordinateReferenceSystem<P> crs) { PositionSequenceBuilder<P> psBuilder = PositionSequenceBuilders.fixedSized(numPos, crs.getPositionClass()); double[] coordinates = new double[crs.getCoordinateDimension()]; for (int i = 0; i < numPos; i++) { readPosition(byteBuffer, coordinates, crs); psBuilder.add(coordinates); } return psBuilder.toPositionSequence(); }
/** * Checks whether this <code>Envelope</code> contains the specifies <code>Envelope</code>. * * @param p the <code>Point</code> * @return true iff this instance contains the specified <code>Point</code> * @throws IllegalArgumentException when the specified <code>Point</code> doesn't have the same coordinate reference system as this instance. */ public boolean contains(P p) { if (!p.getClass().equals(this.getCoordinateReferenceSystem().getPositionClass())) throw new IllegalArgumentException("Position and envelope of different types"); if (isEmpty()) return false; return getMinC0() <= p.getCoordinate(0) && getMaxC0() >= p.getCoordinate(0) && getMinC1() <= p.getCoordinate(1) && getMaxC1() >= p.getCoordinate(1); }
static <P extends Position> PositionSequence<P> toSeq(CoordinateReferenceSystem<P> crs, P[] positions) { PositionSequenceBuilder<P> builder = PositionSequenceBuilders.fixedSized(positions.length, crs.getPositionClass()); double[] coords = new double[crs.getCoordinateDimension()]; for (P t : positions) { P pos = Positions.mkPosition(crs, t.toArray(coords)); builder.add(pos); } return builder.toPositionSequence(); }
if (geometry instanceof Simple) { Simple simple = (Simple) geometry; PositionSequence<Q> positions = Positions.copy(geometry.getPositions(), crs.getPositionClass()); return Geometries.mkGeometry(simple.getClass(), positions, crs); } else {
PositionSequence<?> coordinateRange(IndexRange range) { crs = getCRS(getSrid(), hasZValues(), hasMValues()); PositionSequenceBuilder<?> psBuilder = PositionSequenceBuilders.fixedSized(range.end - range.start, crs.getPositionClass()); double[] coordinates = new double[crs.getCoordinateDimension()]; for (int idx = range.start, i = 0; idx < range.end; idx++, i++) { copyCoordinate(idx, coordinates, crs); psBuilder.add(coordinates); } return psBuilder.toPositionSequence(); }
@Override WktToken numericToken() { CoordinateReferenceSystem<?> crs = getCoordinateReferenceSystem(); int numPoints = countPoints(); //Note that the coords array can be larger than the number of coordinates available in the pointsequence // e.g. when a composite CRS is passed in the decode function for a 2D WKT. // this works because fastReadNumber returns 0 when attempting to read beyond a point delimiter double[] coords = new double[crs.getCoordinateDimension()]; PositionSequenceBuilder<?> psBuilder = PositionSequenceBuilders.fixedSized(numPoints, crs.getPositionClass()); for (int i = 0; i < numPoints; i++) { readPoint(coords); psBuilder.add(coords); skipPointDelimiter(); } return new WktPointSequenceToken(psBuilder.toPositionSequence(), getCoordinateReferenceSystem()); }
private <P extends Position> PositionSequence<P> env2Seq(P p0, P p1, boolean asExteriorRing) { Envelope<P> env = new Envelope<P>(p0, p1, (CoordinateReferenceSystem<P>) crs); if (asExteriorRing) { return fixedSized(5, (Class<P>) crs.getPositionClass()) .add(env.lowerLeft()) .add(env.lowerRight()) .add(env.upperRight()) .add(env.upperLeft()) .add(env.lowerLeft()).toPositionSequence(); } else { return fixedSized(5, (Class<P>) crs.getPositionClass()) .add(env.lowerLeft()) .add(env.upperLeft()) .add(env.upperRight()) .add(env.lowerRight()) .add(env.lowerLeft()).toPositionSequence(); } }