use of com.revolsys.geometry.cs.ProjectedCoordinateSystem in project com.revolsys.open by revolsys.
the class UsgsGriddedElevationReader method readHeader.
private void readHeader() {
try {
if (readBuffer()) {
final String fileName = getString(40);
final String descriptor = getString(40);
// Blank 81 - 109
skip(29);
final String seGeographic = getString(26);
final String processCode = getString(1);
// Blank 137
skip(1);
final String sectionIndicator = getString(3);
final String originCode = getString(4);
final int demLevelCode = getInteger();
final int elevationPattern = getInteger();
final int planimetricReferenceSystem = getInteger();
final int zone = getInteger();
final double[] projectionParameters = new double[15];
for (int i = 0; i < projectionParameters.length; i++) {
projectionParameters[i] = getDoubleSci();
}
final int planimetricUom = getInteger();
final int verticalUom = getInteger();
this.polygonBounds = getPolygonCoordinates();
final double min = getDouble24();
final double max = getDouble24();
final double angle = getDouble24();
if (angle != 0) {
throw new IllegalArgumentException("Angle=" + angle + " not currently supported for USGS DEM: " + this.resource);
}
final int verticalAccuracy = getInteger();
final double resolutionX = getDouble12();
final double resolutionY = getDouble12();
if (resolutionX != resolutionY) {
throw new IllegalArgumentException("resolutionX " + resolutionX + " != " + resolutionY + " resolutionY for USGS DEM: " + this.resource);
}
this.resolutionX = (int) resolutionX;
this.resolutionY = (int) resolutionY;
if (resolutionX != this.resolutionX) {
throw new IllegalArgumentException("resolutionX " + resolutionX + " must currently be an integer for USGS DEM: " + this.resource);
}
this.resolutionZ = getDouble12();
this.rasterRowCount = getInteger();
this.rasterColCount = getInteger();
final Short largestContourInterval = getShort();
final Byte largestContourIntervalUnits = getByte();
final Short smallestContourInterval = getShort();
final Byte smallest = getByte();
final Integer sourceYear = getInteger(4);
final Integer revisionYear = getInteger(4);
final String inspectionFlag = getString(1);
final String dataValidationFlag = getString(1);
final String suspectAndVoidAreaFlag = getString(1);
final Integer verticalDatum = getInteger(2);
final Integer horizontalDatum = getInteger(2);
final Integer dataEdition = getInteger(4);
final Integer percentVoid = getInteger(4);
final Integer edgeMatchWest = getInteger(2);
final Integer edgeMatchNorth = getInteger(2);
final Integer edgeMatchEast = getInteger(2);
final Integer edgeMatchSouth = getInteger(2);
final Double verticalDatumShift = getDouble(7);
LinearUnit linearUnit = null;
if (planimetricUom == 1) {
linearUnit = EpsgCoordinateSystems.getLinearUnit("foot");
} else if (planimetricUom == 2) {
linearUnit = EpsgCoordinateSystems.getLinearUnit("metre");
}
GeographicCoordinateSystem geographicCoordinateSystem;
switch(horizontalDatum) {
case 0:
geographicCoordinateSystem = null;
break;
case 1:
geographicCoordinateSystem = (GeographicCoordinateSystem) EpsgCoordinateSystems.getCoordinateSystem("NAD27");
break;
case 2:
geographicCoordinateSystem = (GeographicCoordinateSystem) EpsgCoordinateSystems.getCoordinateSystem("WGS 72");
break;
case 3:
geographicCoordinateSystem = (GeographicCoordinateSystem) EpsgCoordinateSystems.getCoordinateSystem("WGS 84");
break;
case 4:
geographicCoordinateSystem = (GeographicCoordinateSystem) EpsgCoordinateSystems.getCoordinateSystem("NAD83");
break;
default:
throw new IllegalArgumentException("horizontalDatum=" + horizontalDatum + " not currently supported for USGS DEM: " + this.resource);
}
final double scaleZ = 1.0 / this.resolutionZ;
int coordinateSystemId = 0;
CoordinateSystem coordinateSystem = null;
if (0 == planimetricReferenceSystem) {
coordinateSystemId = geographicCoordinateSystem.getCoordinateSystemId();
} else if (1 == planimetricReferenceSystem) {
coordinateSystemId = 26900 + zone;
} else if (2 == planimetricReferenceSystem) {
throw new IllegalArgumentException("planimetricReferenceSystem=" + planimetricReferenceSystem + " not currently supported for USGS DEM: " + this.resource);
} else if (3 == planimetricReferenceSystem) {
final Map<ParameterName, ParameterValue> parameters = new LinkedHashMap<>();
parameters.put(ParameterNames.CENTRAL_MERIDIAN, fromDms(projectionParameters[4]));
parameters.put(ParameterNames.STANDARD_PARALLEL_1, fromDms(projectionParameters[2]));
parameters.put(ParameterNames.STANDARD_PARALLEL_2, fromDms(projectionParameters[3]));
parameters.put(ParameterNames.LATITUDE_OF_ORIGIN, fromDms(projectionParameters[5]));
parameters.put(ParameterNames.FALSE_EASTING, new ParameterValueNumber(projectionParameters[6]));
parameters.put(ParameterNames.FALSE_NORTHING, new ParameterValueNumber(projectionParameters[7]));
final CoordinateOperationMethod coordinateOperationMethod = new CoordinateOperationMethod("Albers_Equal_Area");
final ProjectedCoordinateSystem projectedCoordinateSystem = new ProjectedCoordinateSystem(-1, "", geographicCoordinateSystem, coordinateOperationMethod, parameters, linearUnit);
final ProjectedCoordinateSystem projectedCoordinateSystem2 = (ProjectedCoordinateSystem) EpsgCoordinateSystems.getCoordinateSystem(projectedCoordinateSystem);
if (projectedCoordinateSystem2 == projectedCoordinateSystem || projectedCoordinateSystem2 == null) {
coordinateSystem = projectedCoordinateSystem2;
} else {
coordinateSystemId = projectedCoordinateSystem2.getCoordinateSystemId();
}
} else {
throw new IllegalArgumentException("planimetricReferenceSystem=" + planimetricReferenceSystem + " not currently supported for USGS DEM: " + this.resource);
}
if (coordinateSystemId > 0) {
this.geometryFactory = GeometryFactory.fixed3d(coordinateSystemId, 0, 0, scaleZ);
} else if (coordinateSystem == null) {
throw new IllegalArgumentException("No coordinate system found: " + this.resource);
} else {
this.geometryFactory = GeometryFactory.fixed3d(coordinateSystem, 0, 0, scaleZ);
}
final Polygon polygon = this.geometryFactory.polygon(this.geometryFactory.linearRing(2, this.polygonBounds));
this.boundingBox = polygon.getBoundingBox();
}
} catch (final Exception e) {
try {
close();
} catch (final Exception e1) {
}
throw Exceptions.wrap(e);
}
}
use of com.revolsys.geometry.cs.ProjectedCoordinateSystem in project com.revolsys.open by revolsys.
the class EsriGeodatabaseXmlRecordWriter method writeSpatialReference.
public void writeSpatialReference(final GeometryFactory geometryFactory) {
if (geometryFactory != null) {
final CoordinateSystem coordinateSystem = geometryFactory.getCoordinateSystem();
if (coordinateSystem != null) {
final String wkt = geometryFactory.toWktCs();
this.out.startTag(SPATIAL_REFERENCE);
if (coordinateSystem instanceof ProjectedCoordinateSystem) {
this.out.attribute(XsiConstants.TYPE, PROJECTED_COORDINATE_SYSTEM_TYPE);
} else {
this.out.attribute(XsiConstants.TYPE, GEOGRAPHIC_COORDINATE_SYSTEM_TYPE);
}
this.out.element(WKT, wkt);
this.out.element(X_ORIGIN, 0);
this.out.element(Y_ORIGIN, 0);
final double scaleXy = geometryFactory.getScaleXY();
this.out.element(XY_SCALE, (int) scaleXy);
this.out.element(Z_ORIGIN, 0);
final double scaleZ = geometryFactory.getScaleZ();
this.out.element(Z_SCALE, (int) scaleZ);
this.out.element(M_ORIGIN, 0);
this.out.element(M_SCALE, 1);
this.out.element(XY_TOLERANCE, Doubles.toString(1.0 / scaleXy * 2.0));
this.out.element(Z_TOLERANCE, Doubles.toString(1.0 / scaleZ * 2.0));
this.out.element(M_TOLERANCE, 1);
this.out.element(HIGH_PRECISION, true);
this.out.element(WKID, coordinateSystem.getCoordinateSystemId());
this.out.endTag(SPATIAL_REFERENCE);
}
}
}
use of com.revolsys.geometry.cs.ProjectedCoordinateSystem in project com.revolsys.open by revolsys.
the class PointTest method assertEquals.
public static void assertEquals(final Point point, final double... coordinates) {
final GeometryFactory geometryFactory = point.getGeometryFactory();
final GeometryFactory geometryFactory2;
final int axisCount = geometryFactory.getAxisCount();
if (geometryFactory.getCoordinateSystem() instanceof ProjectedCoordinateSystem) {
final ProjectedCoordinateSystem projectedCs = (ProjectedCoordinateSystem) geometryFactory.getCoordinateSystem();
final GeographicCoordinateSystem geographicCoordinateSystem = projectedCs.getGeographicCoordinateSystem();
geometryFactory2 = GeometryFactory.floating(geographicCoordinateSystem.getCoordinateSystemId(), axisCount);
} else {
geometryFactory2 = GeometryFactory.floating(26910, axisCount);
}
assertCoordinatesEquals(point, coordinates);
final Point clone = point.newPoint();
assertCoordinatesEquals(clone, coordinates);
final Point converted = point.convertGeometry(geometryFactory);
assertCoordinatesEquals(converted, coordinates);
Assert.assertSame(point, converted);
final Point convertedOther = point.convertGeometry(geometryFactory2);
final Point convertedBack = convertedOther.convertGeometry(geometryFactory);
assertCoordinatesEquals(convertedBack, coordinates);
Assert.assertNotSame(point, convertedBack);
final Point copy = point.newGeometry(geometryFactory);
assertCoordinatesEquals(copy, coordinates);
Assert.assertNotSame(point, copy);
final Point copyOther = point.convertGeometry(geometryFactory2);
final Point copyBack = copyOther.convertGeometry(geometryFactory);
assertCoordinatesEquals(copyBack, coordinates);
Assert.assertNotSame(point, copyBack);
final String string = point.toString();
final Point pointString = geometryFactory.geometry(string);
assertCoordinatesEquals(pointString, coordinates);
final String wkt = point.toEwkt();
final Point pointWkt = geometryFactory.geometry(wkt);
assertCoordinatesEquals(pointWkt, coordinates);
}
use of com.revolsys.geometry.cs.ProjectedCoordinateSystem in project com.revolsys.open by revolsys.
the class TestUtil method doTestGeometry.
public static void doTestGeometry(final Class<?> clazz, final String file) {
boolean valid = true;
final Resource resource = new ClassPathResource(file, clazz);
try (Reader<Record> reader = RecordReader.newRecordReader(resource)) {
int i = 0;
for (final Record object : reader) {
final int srid = object.getInteger("srid");
final int axisCount = object.getInteger("axisCount");
final double scaleXy = object.getInteger("scaleXy");
final double scaleZ = object.getInteger("scaleZ");
final double[] scales = { scaleXy, scaleXy, scaleZ };
final GeometryFactory geometryFactory = GeometryFactory.fixed(srid, axisCount, scales);
final String wkt = object.getValue("wkt");
final Geometry geometry = geometryFactory.geometry(wkt);
valid &= equalsExpectedWkt(i, object, geometry);
final CoordinateSystem coordinateSystem = geometry.getCoordinateSystem();
GeometryFactory otherGeometryFactory;
if (coordinateSystem instanceof ProjectedCoordinateSystem) {
final ProjectedCoordinateSystem projectedCoordinateSystem = (ProjectedCoordinateSystem) coordinateSystem;
otherGeometryFactory = GeometryFactory.fixed(projectedCoordinateSystem.getCoordinateSystemId(), axisCount, scales);
} else {
otherGeometryFactory = GeometryFactory.fixed(3005, axisCount, scales);
}
final Geometry convertedGeometry = geometry.convertGeometry(otherGeometryFactory);
final Geometry convertedBackGeometry = convertedGeometry.convertGeometry(geometryFactory);
valid &= equalsExpectedGeometry(i, convertedBackGeometry, geometry);
i++;
}
}
if (!valid) {
Assert.fail("Has Errors");
}
}
use of com.revolsys.geometry.cs.ProjectedCoordinateSystem in project com.revolsys.open by revolsys.
the class LasProjection method convertGeoTiffProjection.
@SuppressWarnings("unused")
private static Object convertGeoTiffProjection(final LasPointCloudHeader header, final byte[] bytes) {
try {
final List<Double> doubleParams = new ArrayList<>();
{
final LasVariableLengthRecord doubleParamsProperty = header.getLasProperty(new Pair<>(LASF_PROJECTION, LASF_PROJECTION_TIFF_GEO_DOUBLE_PARAMS));
if (doubleParamsProperty != null) {
final byte[] doubleParamBytes = doubleParamsProperty.getBytes();
final ByteBuffer buffer = ByteBuffer.wrap(doubleParamBytes);
buffer.order(ByteOrder.LITTLE_ENDIAN);
for (int i = 0; i < doubleParamBytes.length / 8; i++) {
final double value = buffer.getDouble();
doubleParams.add(value);
}
}
}
byte[] asciiParamsBytes;
{
final LasVariableLengthRecord asciiParamsProperty = header.getLasProperty(new Pair<>(LASF_PROJECTION, LASF_PROJECTION_TIFF_GEO_ASCII_PARAMS));
if (asciiParamsProperty == null) {
asciiParamsBytes = new byte[0];
} else {
asciiParamsBytes = asciiParamsProperty.getBytes();
}
}
final Map<Integer, Object> properties = new LinkedHashMap<>();
final ByteBuffer buffer = ByteBuffer.wrap(bytes);
buffer.order(ByteOrder.LITTLE_ENDIAN);
final int keyDirectoryVersion = Buffers.getLEUnsignedShort(buffer);
final int keyRevision = Buffers.getLEUnsignedShort(buffer);
final int minorRevision = Buffers.getLEUnsignedShort(buffer);
final int numberOfKeys = Buffers.getLEUnsignedShort(buffer);
for (int i = 0; i < numberOfKeys; i++) {
final int keyId = Buffers.getLEUnsignedShort(buffer);
final int tagLocation = Buffers.getLEUnsignedShort(buffer);
final int count = Buffers.getLEUnsignedShort(buffer);
final int offset = Buffers.getLEUnsignedShort(buffer);
if (tagLocation == 0) {
properties.put(keyId, offset);
} else if (tagLocation == LASF_PROJECTION_TIFF_GEO_DOUBLE_PARAMS) {
final double value = doubleParams.get(offset);
properties.put(keyId, value);
} else if (tagLocation == LASF_PROJECTION_TIFF_GEO_ASCII_PARAMS) {
final String value = new String(asciiParamsBytes, offset, count, StandardCharsets.US_ASCII);
properties.put(keyId, value);
}
}
CoordinateSystem coordinateSystem = null;
int coordinateSystemId = Maps.getInteger(properties, TiffImage.PROJECTED_COORDINATE_SYSTEM_ID, 0);
if (coordinateSystemId == 0) {
coordinateSystemId = Maps.getInteger(properties, TiffImage.GEOGRAPHIC_COORDINATE_SYSTEM_ID, 0);
if (coordinateSystemId != 0) {
coordinateSystem = EpsgCoordinateSystems.getCoordinateSystem(coordinateSystemId);
}
} else if (coordinateSystemId <= 0 || coordinateSystemId == 32767) {
final int geoSrid = Maps.getInteger(properties, TiffImage.GEOGRAPHIC_COORDINATE_SYSTEM_ID, 0);
if (geoSrid != 0) {
if (geoSrid > 0 && geoSrid < 32767) {
final GeographicCoordinateSystem geographicCoordinateSystem = EpsgCoordinateSystems.getCoordinateSystem(geoSrid);
final String name = "unknown";
final CoordinateOperationMethod coordinateOperationMethod = TiffImage.getProjection(properties);
final Map<ParameterName, ParameterValue> parameters = new LinkedHashMap<>();
TiffImage.addDoubleParameter(parameters, ParameterNames.STANDARD_PARALLEL_1, properties, TiffImage.STANDARD_PARALLEL_1_KEY);
TiffImage.addDoubleParameter(parameters, ParameterNames.STANDARD_PARALLEL_2, properties, TiffImage.STANDARD_PARALLEL_2_KEY);
TiffImage.addDoubleParameter(parameters, ParameterNames.CENTRAL_MERIDIAN, properties, TiffImage.LONGITUDE_OF_CENTER_2_KEY);
TiffImage.addDoubleParameter(parameters, ParameterNames.LATITUDE_OF_ORIGIN, properties, TiffImage.LATITUDE_OF_CENTER_2_KEY);
TiffImage.addDoubleParameter(parameters, ParameterNames.FALSE_EASTING, properties, TiffImage.FALSE_EASTING_KEY);
TiffImage.addDoubleParameter(parameters, ParameterNames.FALSE_NORTHING, properties, TiffImage.FALSE_NORTHING_KEY);
final LinearUnit linearUnit = TiffImage.getLinearUnit(properties);
final ProjectedCoordinateSystem projectedCoordinateSystem = new ProjectedCoordinateSystem(coordinateSystemId, name, geographicCoordinateSystem, coordinateOperationMethod, parameters, linearUnit);
coordinateSystem = EpsgCoordinateSystems.getCoordinateSystem(projectedCoordinateSystem);
}
}
} else {
coordinateSystem = EpsgCoordinateSystems.getCoordinateSystem(coordinateSystemId);
}
header.setCoordinateSystemInternal(coordinateSystem);
return coordinateSystem;
} catch (final IOException e) {
throw Exceptions.wrap(e);
}
}
Aggregations