use of org.apache.sis.internal.jaxb.gml.Measure in project sis by apache.
the class DefaultEllipsoid method setSecondDefiningParameter.
/**
* Sets the second defining parameter value, either the inverse of the flattening
* value or the semi minor axis value, according to what have been defined in the
* second defining parameter given. This is for JAXB unmarshalling process only.
*
* @see #setSemiMajorAxisMeasure(Measure)
* @see #afterUnmarshal(Unmarshaller, Object)
*/
private void setSecondDefiningParameter(SecondDefiningParameter second) {
if (second.secondDefiningParameter != null) {
second = second.secondDefiningParameter;
}
boolean duplicate = false;
if (Boolean.TRUE.equals(second.isSphere)) {
duplicate = (inverseFlattening != 0);
if (!duplicate) {
inverseFlattening = Double.POSITIVE_INFINITY;
}
}
final Measure measure = second.measure;
if (measure != null) {
final boolean isIvfDefinitive = second.isIvfDefinitive();
duplicate |= (isIvfDefinitive ? inverseFlattening : semiMinorAxis) != 0;
if (!duplicate) {
ivfDefinitive = isIvfDefinitive;
double value = measure.value;
if (isIvfDefinitive) {
/*
* Interpreting an inverse flattening factor of 0 as synonymous of infinity
* is a Well-Known Text (WKT) convention, not part of GML standard. However
* in practice some software do that.
*/
if (value == 0) {
value = Double.POSITIVE_INFINITY;
}
ensureStrictlyPositive("inverseFlattening", inverseFlattening = value);
} else {
ensureStrictlyPositive("semiMinorAxis", semiMinorAxis = value);
harmonizeAxisUnits(measure.getUnit(Length.class));
}
}
}
if (duplicate) {
MetadataUtilities.propertyAlreadySet(DefaultEllipsoid.class, "setSecondDefiningParameter", "secondDefiningParameter");
}
}
use of org.apache.sis.internal.jaxb.gml.Measure in project geotoolkit by Geomatys.
the class GeometryTransformer method drawArc.
/**
* Draw a succession of segments representing an arc or a circle.
* @implNote
* This method checks given angles to ensure that a full circle is drawn using
* the strict necessary amount of points.
*
* @param center The center point of the arc to draw. The unit of measure MUST
* be consistent with the unit of given radius.
* @param radius The Radius of the arc to draw. Unit must be the same as the
* one of input center point.
* @param startAzimuth Start of the drawn line relative to the geographic north (clockwise order).
* @param endAzimuth End of the drawn line relative to the geographic north (clockwise order). If
* it's inferior to start angle, the arc is drawn on counter-clockwise order. If superior, the arc is
* drawn on clockwise order.
* @param angularStep The step to apply on the trigonometric circle to find
* next point of the arc. its sign will be adapted to match draw order (clockwise
* or counter clockwise).
* @return An arc, as a discrete succession of points of configured precision.
*/
private static Coordinate[] drawArc(final DirectPosition center, final Measure radius, final Measure startAzimuth, final Measure endAzimuth, final Measure angularStep) throws TransformException {
ArgumentChecks.ensureNonNull("Center point", center);
final CoordinateReferenceSystem sourceCrs = center.getCoordinateReferenceSystem();
ArgumentChecks.ensureNonNull("coordinate reference system", sourceCrs);
final SingleCRS hCrs = CRS.getHorizontalComponent(sourceCrs);
if (hCrs == null) {
throw new UnconvertibleObjectException("Cannot extract geometries without projected part.");
}
final int xAxis = AxisDirections.indexOfColinear(sourceCrs.getCoordinateSystem(), hCrs.getCoordinateSystem());
final int yAxis = xAxis + 1;
final GeodeticCalculator gc = GeodeticCalculator.create(sourceCrs);
gc.setStartPoint(center);
final Unit<Length> radiusUnit = gc.getDistanceUnit();
final double r = radius.getUnit(Length.class).getConverterTo(radiusUnit).convert(radius.value);
double theta = startAzimuth.getUnit(Angle.class).getConverterTo(Units.DEGREE).convert(startAzimuth.value);
double end = endAzimuth.getUnit(Angle.class).getConverterTo(Units.DEGREE).convert(endAzimuth.value);
double phi = end - theta;
// Draw a circle. We don"t bother preserving iteration order
double positivePhi = Math.abs(phi);
final boolean isCircle = positivePhi - 1e-8 <= 0 || positivePhi >= 360.0;
if (isCircle) {
phi = 360.0;
}
double step = (phi < 0 ? -1 : 1) * angularStep.getUnit(Angle.class).getConverterTo(Units.DEGREE).convert(angularStep.value);
if ((phi / step) < 3) {
step = phi / 3;
}
final Coordinate[] arcPerimeter = new Coordinate[(int) Math.ceil(phi / step) + 1];
final DoubleFunction<Coordinate> pointOnCircle = azimuth -> {
azimuth = ((azimuth + 180) % 360) - 180;
gc.setStartingAzimuth(azimuth);
gc.setGeodesicDistance(r);
final DirectPosition pt = gc.getEndPoint();
return new Coordinate(pt.getOrdinate(xAxis), pt.getOrdinate(yAxis));
};
/* Don't entirely fill array. Last point will be computed in a sepcial case,
* to ensure it's closed properly if it's a circle.
*/
for (int i = 0; i < arcPerimeter.length - 1; i++, theta += step) {
arcPerimeter[i] = pointOnCircle.apply(theta);
}
if (isCircle) {
// Ensure last point is the start point
arcPerimeter[arcPerimeter.length - 1] = arcPerimeter[0];
} else {
arcPerimeter[arcPerimeter.length - 1] = pointOnCircle.apply(end);
}
return arcPerimeter;
}
use of org.apache.sis.internal.jaxb.gml.Measure in project geotoolkit by Geomatys.
the class GeometryTransformer method getCoordinates.
/**
* Check that given geometry is a primitive geometry (implements {@link WithCoordinates}), and
* get its points.
* @param source The geometry to extract points from.
* @return Found points, never null, but can be empty.
* @throws UnconvertibleObjectException If the given geometry does not implement {@link WithCoordinates}.
*/
private Spliterator<Coordinate> getCoordinates(final Object source) throws UnconvertibleObjectException {
List<Double> values = null;
if (source instanceof WithCoordinates) {
final Coordinates coords = ((WithCoordinates) source).getCoordinates();
if (coords != null) {
/* HACK : In GML 3, coordinates are just a list of decimal values.
* The grouping by coordinate is done using "srsDimension" attribute
* on parent geometry type. However, with GML 2, there's another
* possibility : Coordinates use two distinct separators : one for
* decimal value separation, and another for coordinate separation.
* To manage both ways, we first check if coordinates object has
* succeeded in splitting underlying decimals in coordinates. If
* it does (return arrays with more than one element), we use
* that approach. Otherwise, we fallback on standard way which
* will try to determine manually the number of dimensions.
*/
Iterator<double[]> it = coords.points().iterator();
if (it.hasNext() && it.next().length > 1) {
return coords.points().map(GeometryTransformer::toCoordinate).spliterator();
} else {
values = coords.getValues();
}
} else if (source instanceof Point) {
DirectPosition dp = ((Point) source).getPos();
if (dp != null) {
return Stream.of(convertDirectPosition(dp)).spliterator();
} else
// recognized object, but no value. Empty geometry
return Spliterators.emptySpliterator();
}
}
// TODO : below conditions should be removed when proper abstraction is setup on GML geometry definition.
if (values == null) {
final boolean isLineString = source instanceof org.geotoolkit.gml.xml.LineString;
final boolean isLineStringSegment = source instanceof org.geotoolkit.gml.xml.LineStringSegment;
if (isLineString || isLineStringSegment) {
final DirectPositionList posList;
if (isLineString) {
posList = ((org.geotoolkit.gml.xml.LineString) source).getPosList();
} else {
posList = ((org.geotoolkit.gml.xml.LineStringSegment) source).getPosList();
}
if (posList != null) {
values = posList.getValue();
} else {
final List<? extends DirectPosition> pList;
if (isLineString) {
pList = ((org.geotoolkit.gml.xml.LineString) source).getPos();
} else {
pList = ((org.geotoolkit.gml.xml.LineStringSegment) source).getPos();
}
if (pList != null) {
return pList.stream().map(GeometryTransformer::convertDirectPosition).filter(Objects::nonNull).spliterator();
} else {
// We've identified a line, but there's no data in it
values = Collections.EMPTY_LIST;
}
}
} else if (source instanceof org.geotoolkit.gml.xml.LinearRing) {
// Note : do not check "getCoordinates", because it should have been done above.
values = asDoubles(() -> ((org.geotoolkit.gml.xml.LinearRing) source).getPosList());
} else if (source instanceof org.geotoolkit.gml.xml.v311.GeodesicStringType) {
values = asDoubles(() -> ((org.geotoolkit.gml.xml.v311.GeodesicStringType) source).getPosList());
} else if (source instanceof org.geotoolkit.gml.xml.v321.GeodesicStringType) {
values = asDoubles(() -> ((org.geotoolkit.gml.xml.v321.GeodesicStringType) source).getPosList());
} else if (source instanceof Curve) {
CurveSegmentArrayProperty segments = ((Curve) source).getSegments();
if (segments != null) {
final List<? extends AbstractCurveSegment> curveSegments = segments.getAbstractCurveSegment();
if (curveSegments != null) {
return curveSegments.stream().flatMap(seg -> StreamSupport.stream(getCoordinates(seg), false)).spliterator();
}
}
// If we arrive here, we've got an empty curve.
values = Collections.EMPTY_LIST;
} else if (source instanceof ArcByCenterPointType) {
final ArcByCenterPointType arc = (ArcByCenterPointType) source;
org.opengis.geometry.DirectPosition dp = arc.getPos();
if (dp == null) {
PointPropertyType pp = arc.getPointProperty();
if (pp == null) {
pp = arc.getPointRep();
}
if (pp == null) {
throw new UnconvertibleObjectException("Not enough information to build an arc.");
}
final Geometry point = new GeometryTransformer(pp.getPoint(), this).get();
dp = JTS.toEnvelope(point).getLowerCorner();
}
CoordinateReferenceSystem crs = dp.getCoordinateReferenceSystem();
if (crs == null) {
crs = getSrsName().map(this::findCRS).orElseThrow(() -> new UnconvertibleObjectException("Cannot create an arc without its coordinate reference system"));
final GeneralDirectPosition gdp = new GeneralDirectPosition(dp);
gdp.setCoordinateReferenceSystem(crs);
dp = gdp;
}
try {
final Measure startAngle, endAngle;
// If we miss a start or end angle, it means we're in presence of a circle.
if (arc.getStartAngle() == null || arc.getEndAngle() == null) {
startAngle = new Measure(0, Units.DEGREE);
endAngle = new Measure(360, Units.DEGREE);
} else {
startAngle = asMeasure(arc.getStartAngle());
endAngle = asMeasure(arc.getEndAngle());
}
final Coordinate[] coordinates = drawArc(dp, asMeasure(arc.getRadius()), startAngle, endAngle, ARC_PRECISION);
return Spliterators.spliterator(coordinates, Spliterator.ORDERED);
} catch (TransformException ex) {
throw new UnconvertibleObjectException("Cannot draw an arc.", ex);
}
} else if (source instanceof org.geotoolkit.gml.xml.v311.ArcByCenterPointType) {
// TODO : factorize with above case
final org.geotoolkit.gml.xml.v311.ArcByCenterPointType arc = (org.geotoolkit.gml.xml.v311.ArcByCenterPointType) source;
org.opengis.geometry.DirectPosition dp = arc.getPos();
if (dp == null) {
org.geotoolkit.gml.xml.v311.PointPropertyType pp = arc.getPointProperty();
if (pp == null) {
pp = arc.getPointRep();
}
if (pp == null) {
throw new UnconvertibleObjectException("Not enough information to build an arc.");
}
final Geometry point = new GeometryTransformer(pp.getPoint(), this).get();
dp = JTS.toEnvelope(point).getLowerCorner();
}
CoordinateReferenceSystem crs = dp.getCoordinateReferenceSystem();
if (crs == null) {
crs = getSrsName().map(this::findCRS).orElseThrow(() -> new UnconvertibleObjectException("Cannot create an arc without its coordinate reference system"));
final GeneralDirectPosition gdp = new GeneralDirectPosition(dp);
gdp.setCoordinateReferenceSystem(crs);
dp = gdp;
}
try {
final Measure startAngle, endAngle;
// If we miss a start or end angle, it means we're in presence of a circle.
if (arc.getStartAngle() == null || arc.getEndAngle() == null) {
startAngle = new Measure(0, Units.DEGREE);
endAngle = new Measure(360, Units.DEGREE);
} else {
startAngle = asMeasure(arc.getStartAngle());
endAngle = asMeasure(arc.getEndAngle());
}
final Coordinate[] coordinates = drawArc(dp, asMeasure(arc.getRadius()), startAngle, endAngle, ARC_PRECISION);
return Spliterators.spliterator(coordinates, Spliterator.ORDERED);
} catch (TransformException ex) {
throw new UnconvertibleObjectException("Cannot draw an arc.", ex);
}
}
}
if (values != null) {
if (values.isEmpty()) {
return Spliterators.emptySpliterator();
}
return new CoordinateSpliterator(values, getCoordinateDimension());
}
throw new UnconvertibleObjectException("Cannot extract coordinates from source geometry.");
}
use of org.apache.sis.internal.jaxb.gml.Measure in project sis by apache.
the class DefaultParameterValue method setXmlValue.
/**
* Invoked by JAXB at unmarshalling time.
*/
@SuppressWarnings("unchecked")
private void setXmlValue(Object xmlValue) {
if (value == null && unit == null) {
if (xmlValue instanceof Measure) {
final Measure measure = (Measure) xmlValue;
xmlValue = measure.value;
unit = measure.unit;
} else if (xmlValue instanceof MeasureList) {
final MeasureList measure = (MeasureList) xmlValue;
xmlValue = measure.toArray();
unit = measure.unit;
} else if (xmlValue instanceof IntegerList) {
xmlValue = ((IntegerList) xmlValue).toArray();
}
if (descriptor != null) {
/*
* Should never happen with default SIS implementation, but may happen if the user created
* a sub-type of DefaultParameterValue with a default constructor providing the descriptor.
*/
value = ObjectConverters.convert(xmlValue, descriptor.getValueClass());
} else {
/*
* Temporarily accept the value without checking its type. This is required because the
* descriptor is normally defined after the value in a GML document. The type will need
* to be verified when the descriptor will be set.
*
* There is no way we can prove that this cast is correct before the descriptor is set,
* and maybe that descriptor will never be set if the GML document is illegal. However
* this code is executed only during XML unmarshalling, in which case our unmarshalling
* process will construct a descriptor compatible with the value rather than the converse.
*/
value = (T) xmlValue;
}
} else {
MetadataUtilities.propertyAlreadySet(DefaultParameterValue.class, "setXmlValue", "value");
}
}
Aggregations