use of com.revolsys.geometry.cs.CoordinateOperationMethod 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.CoordinateOperationMethod 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);
}
}
use of com.revolsys.geometry.cs.CoordinateOperationMethod in project com.revolsys.open by revolsys.
the class EpsgCoordinateSystems method loadCoordOperationMethod.
private static IntHashMap<CoordinateOperationMethod> loadCoordOperationMethod(final IntHashMap<List<ParameterName>> paramOrderByMethodId, final IntHashMap<List<Byte>> paramReversalByMethodId) {
final IntHashMap<CoordinateOperationMethod> methodById = new IntHashMap<>();
try (ChannelReader reader = newChannelReader("coordOperationMethod")) {
while (true) {
final int id = reader.getInt();
final String name = reader.getStringUtf8ByteCount();
final boolean reverse = readBoolean(reader);
final boolean deprecated = readBoolean(reader);
final List<ParameterName> parameterNames = paramOrderByMethodId.getOrDefault(id, Collections.emptyList());
final List<Byte> reversal = paramReversalByMethodId.getOrDefault(id, Collections.emptyList());
final CoordinateOperationMethod method = new CoordinateOperationMethod(id, name, reverse, deprecated, parameterNames);
methodById.put(id, method);
}
} catch (final NoSuchResourceException e) {
} catch (final WrappedException e) {
if (Exceptions.isException(e, EOFException.class)) {
} else {
throw e;
}
}
return methodById;
}
use of com.revolsys.geometry.cs.CoordinateOperationMethod in project com.revolsys.open by revolsys.
the class EpsgCoordinateSystems method initialize.
public static synchronized void initialize() {
if (!initialized) {
initialized = true;
final long startTime = System.currentTimeMillis();
try {
loadUnitOfMeasure();
loadCoordinateAxisNames();
final IntHashMap<List<Axis>> axisMap = loadCoordinateAxis();
loadArea();
loadPrimeMeridians();
loadDatum();
loadCoordOperationParam();
final IntHashMap<List<ParameterName>> paramOrderByMethodId = new IntHashMap<>();
final IntHashMap<List<Byte>> paramReversalByMethodId = new IntHashMap<>();
loadCoordOperationParamUsage(paramOrderByMethodId, paramReversalByMethodId);
final IntHashMap<CoordinateOperationMethod> methodById = loadCoordOperationMethod(paramOrderByMethodId, paramReversalByMethodId);
final IntHashMap<Map<ParameterName, ParameterValue>> operationParameters = new IntHashMap<>();
loadCoordOperationParamValue(methodById, operationParameters, paramReversalByMethodId);
loadCoordOperation(methodById, operationParameters, paramReversalByMethodId);
loadCoordinateSystem();
loadCoordinateReferenceSystem(axisMap);
final ProjectedCoordinateSystem worldMercator = (ProjectedCoordinateSystem) coordinateSystemsById.get(3857);
coordinateSystemsById.put(900913, worldMercator);
coordinateSystems = Collections.unmodifiableSet(new LinkedHashSet<>(coordinateSystemsById.values()));
Dates.debugEllapsedTime(EpsgCoordinateSystems.class, "initialize", startTime);
} catch (final Throwable t) {
t.printStackTrace();
}
}
}
use of com.revolsys.geometry.cs.CoordinateOperationMethod in project com.revolsys.open by revolsys.
the class EpsgCoordinateSystems method loadCoordOperation.
private static void loadCoordOperation(final IntHashMap<CoordinateOperationMethod> methodById, final IntHashMap<Map<ParameterName, ParameterValue>> operationParameters, final IntHashMap<List<Byte>> paramReversal) {
try (ChannelReader reader = newChannelReader("coordOperation")) {
while (true) {
final int id = reader.getInt();
final CoordinateOperationMethod method = readCode(reader, methodById);
final String name = reader.getStringUtf8ByteCount();
final byte type = reader.getByte();
final int sourceCrsCode = reader.getInt();
final int targetCrsCode = reader.getInt();
final String transformationVersion = reader.getStringUtf8ByteCount();
final int variant = reader.getInt();
final Area area = readCode(reader, AREA_BY_ID);
final double accuracy = reader.getDouble();
final boolean deprecated = readBoolean(reader);
final Map<ParameterName, ParameterValue> parameters = operationParameters.getOrDefault(id, Collections.emptyMap());
final CoordinateOperation coordinateOperation = new CoordinateOperation(id, method, name, type, sourceCrsCode, targetCrsCode, transformationVersion, variant, area, accuracy, parameters, deprecated);
OPERATION_BY_ID.put(id, coordinateOperation);
}
} catch (final NoSuchResourceException e) {
} catch (final WrappedException e) {
if (Exceptions.isException(e, EOFException.class)) {
} else {
Logs.error(EpsgCoordinateSystems.class, "Error loading coordOperation", e);
}
}
}
Aggregations