/** * Returns the weight value, which is the last value in the {@linkplain #getCoordinate() * coordinate array}. * * @return the weight as a positive real number. */ @Draft @UML(identifier="weight", obligation=MANDATORY, specification=ISO_19107) double getWeight();
/** * Reverses the orientation of the parameterizations of the curve. In most cases this involves * a reversal of the ordering of parameters in the curve segments, and a reversal of the order * of the segments with a curve. * * @return the reverse of the curve. */ @Draft @UML(identifier="reverse", obligation=MANDATORY, specification=ISO_19107) GenericCurve reverse(); }
/** * Transforms a direct position from the {@linkplain #getDomain() domain} coordinate * system to the {@linkplain #getRange() range} coordinate system. * * @param point The position in the {@linkplain #getDomain() domain} coordinate system. * @return the given position in the {@linkplain #getRange() range} coordinate system, * stored in a new object. */ @Draft @UML(identifier="transform(DirectPostion)", obligation=MANDATORY, specification=ISO_19107) DirectPosition transform(DirectPosition point);
/** * A character string identifier for this coordinate system. Since many of these systems * will be non-standard, this name may not map to any well know identifier, and the context * of the system may be required to understand how the mapping of {@link DirectPosition}s * to real locations is accomplished. * * @return the name of this coordinate system, or {@code null} if unspecified. */ @Draft @UML(identifier="name", obligation=OPTIONAL, specification=ISO_19107) String getName();
/** * The size of the ordinate array needed to represent a coordinate in this * {@code CoordinateSystem}, when non-homogeneous representations are used. * For example the dimension of (<var>X</var>, <var>Y</var>, <var>Z</var>) is 3 * and the dimension of (<var>Longitude</var>, <var>Latitude</var>) is 2. * * @return the dimension of this coordinate system. */ @Draft @UML(identifier="dimension", obligation=MANDATORY, specification=ISO_19107) int getDimension();
/** * Transforms a geometry from the {@linkplain #getDomain() domain} coordinate * system to the {@linkplain #getRange() range} coordinate system. * * @param object The geometry in the {@linkplain #getDomain() domain} coordinate system. * @return the given geometry in the {@linkplain #getRange() range} coordinate system, * stored in a new object. */ @Draft @UML(identifier="transform(Geometry)", obligation=MANDATORY, specification=ISO_19107) Geometry transform(Geometry object); }
/** * Returns the coordinate system which contains the values * to which this parameterization maps. * * <div class="note"> * In many cases where the parameterization is the constructive mechanism for a * {@linkplain Geometry geometry object}, such as a spline, the range will be * “coordinateSystem” of the target spline. In this case, the parameterization * shall also be a realization of {@linkplain Geometry geometry object}, e.g. the * object being constructed. The image in the range is thereby equivalent to a * GeometryProxy geometry proxy, under the parameterization of the * {@linkplain #getExtentOfValidity() extent of validity}. * </div> * * @return the coordinate system mapped by this parameterization. */ @Draft @UML(identifier="range", obligation=MANDATORY, specification=ISO_19107) CoordinateSystem getRange();
/** * The coordinate system which contains the values from which this parameterization maps. * This shall be the same as the coordinate system of the * {@linkplain #getExtentOfValidity() extent of validity}. * * <div class="note"> * In many cases where the parameterization is the constructive mechanism for * a {@linkplain Geometry geometry object}, such as a spline, the domain will * be a simple Euclidean space of the topological dimension of this target object. * </div> * * @return This parameterization {@linkplain #getDomain() domain} coordinate system. */ @Draft @UML(identifier="domain", obligation=MANDATORY, specification=ISO_19107) CoordinateSystem getDomain();
/** * The {@linkplain CoordinateReferenceSystem coordinate reference system} as * defined in ISO 19111 that describes this {@link CoordinateSystem}. * This is non-null if and only if the {@code CoordinateSystem} is acting * as a proxy for a pure spatial coordinate system, or if the system is compound, * one of its projections is such a proxy. In either case, the proxy is needed * to keep track of the {@linkplain CoordinateReferenceSystem coordinate reference system} * handedness, and provide a place for other information as needed by applications * classes implementing this interface. * * @return the coordinate reference system, or {@code null}. */ @Draft @UML(identifier="coordinateReferenceSystem", obligation=OPTIONAL, specification=ISO_19107) CoordinateReferenceSystem getCoordinateReferenceSystem();
/** * The {@linkplain CoordinateSystem coordinate system} in which the coordinate is given. * May be {@code null} if this particular {@code DirectPosition} is included in a larger * object with such a reference to a coordinate system. In this case, the coordinate system * is implicitly assumed to take on the value of the containing object's coordinate system. * And the first in the sequence of coordinate systems must be the spatial CRS from 19111. * * @return the coordinate system, or {@code null}. * * @see #getCoordinateReferenceSystem() */ @Draft @UML(identifier="coordinateSystem", obligation=MANDATORY, specification=ISO_19107) CoordinateSystem getCoordinateSystem(); }
/** * Returns the domain of the mapping being represented by this parameterization. The returned * geometry object will be in the coordinate system {@linkplain #getDomain() domain} of the * parameterization. * * <div class="note"> * The parameterization may be considered as a geometry proxy for * its “<code>extentOfValidity</code>” geometry object, since it creates an image of this * geometry object in its {@linkplain #getRange() range} coordinate system. Splines do * exactly this. * </div> * * @return the domain of the mapping being represented by this parameterization. */ @Draft @UML(identifier="extentOfValidity", obligation=MANDATORY, specification=ISO_19107) Geometry getExtentOfValidity();
/** * Determines whether the permutation is representable as an even or odd number of * transposition (2 element swaps). Even permutation preserve handedness and odd * ones do not. * * <div class="note"><b>Note:</b> * Under usual circumstances, the only reason to use a permutation is to change * a spatial {@linkplain CoordinateReferenceSystem coordinate reference system} * from left handed to right handedness. A {@code null} permutation is even, * and the usual (1, 0) swap is odd (1 transposition). * </div> * * @return {@code true} if permutation is even, or {@code false} if odd. */ @Draft @UML(identifier="isEven", obligation=MANDATORY, specification=ISO_19107) boolean isEven(); }
/** * describes the new ordering of offsets in terms of offset indexes of the original ordering. * The offsets shall be represented as a 0-up index; so a <var>n</var>-dimension array in * original order would be (0, 1, 2, … , n-1); the index will always ranges up to one less * than the cardinality of the array. If the array length is less than the dimension of the * coordinate, then all offsets beyond the length of the array will be unmoved by the permutation. * * <div class="note"><b>Note:</b> * Because of its definition, the {@code newOrder} array will normally be a rearrangement * of the integer between 0 and <var>n</var>-1 where <var>n</var> is the dimension of the * {@link CoordinateSystem} in which the permutation appears. Since the most common issue * is that the use of “lat-long” is left handed, the most common new order will be (1, 0) * which simply flips the order of the latitude and longitude offsets of a geographic * coordinate system. * </div> * * @return Returns a new order or the same order as in {@link DirectPosition}. */ @Draft @UML(identifier="newOrder", obligation=MANDATORY, specification=ISO_19107) int[] getNewOrder();
/** * Returns the geometry of the curve topological boundary. If the {@linkplain #getStartPoint() * start point} is not equal to the {@linkplain #getEndPoint() end point}, the boundary is a * two point array. If the start point is equal to the end point, the boundary is an empty array. * * <div class="note"><b>Note:</b> * The above point array will almost always be two distinct positions, but both * {@linkplain org.opengis.geometry.primitive.Curve curves} and * {@linkplain org.opengis.geometry.primitive.CurveSegment} can be cycles in themselves. * The most likely scenario is that all of the points used will be transients (constructed * to support the return value), except for the start point and end point of the aggregated * curve. These two positions, in the case where the curve is involved in a * {@linkplain org.opengis.geometry.complex.Complex complex}, will be represented as * {@linkplain org.opengis.geometry.primitive.Point points} in the same complex. * </div> * * @return the sets of positions on the boundary. */ @Draft @UML(identifier="boundary", obligation=MANDATORY, specification=ISO_19107) CurveBoundary getBoundary();
/** * Describes how offsets in the coordinate arrays are rearranged for storage within the * {@link DirectPosition} instances. The representation is as a list of integers representing * the new order of the coordinate array. The offsets are expressed in 0-up order. If the * permutation is absent, then the order of the {@link DirectPosition#getCoordinate()} array * will be the natural order implied by the manner in which the {@link CoordinateSystem} is * constructed. * * <div class="note"><b>Note:</b> * The most common use of the permutation is to allow the {@link DirectPosition}s * coordinates to be stored in an order consistent with the mathematical requirement to be * right-handed. For example, a lat-long 2D system is left-handed so that swapping the first * two offsets gives a system more consistent with most mathematical libraries. * </div> * * @return the offsets in the coordinate arrays for storage within the direct positions, * or {@code null} for natural ordering. */ @Draft @UML(identifier="permutation", obligation=OPTIONAL, specification=ISO_19107) Permutation getPermutation();
/** * Returns an ordered array of point values that lie on the curve. * In most cases, these will be related to control points used in the construction of the segment. * * <div class="note"><b>Note:</b> * The control points of a curve segment are used to control its shape, and are not always on the * curve segment itself. For example in a spline curve, the curve segment is given as a weighted * vector sum of the control points. Each weight function will have a maximum within the * constructive parameter interval, which will roughly correspond to the point on the curve * where it passes closest that the corresponding control point. These points, the values of * the curve at the maxima of the weight functions, will be the sample points for the curve * segment. * </div> * * @departure easeOfUse * The ISO 19107 specification returns an array of {@link org.opengis.geometry.primitive.Point} * object. GeoAPI returns a {@link PointArray} object instead, in order to allow deferred point * creation for implementors, and convenient access to the {@code PointArray} methods for users. * * @return the control points. */ @Draft @UML(identifier="samplePoints", obligation=MANDATORY, specification=ISO_19107) PointArray getSamplePoints();
/** * The enumerated value for “left” or “right” which will identify the spatial orientation of * this coordinate system in its unpermuted state. This information is needed to properly * calculate visual representations of the underlying geometry. Most display systems * are right-handed (OpenGL) and most {@link org.opengis.referencing.crs.GeographicCRS} * systems are left-handed, which means that a geometric object in a {@code GeographicCRS} * may require special treatment to obtain proper orientation of views to agree with reality. * Orientation is also dependent on coordinate system handedness, and is discussed in this * standard in the clauses for surfaces and solids. If not specified, the by default “right” * which is the standard for Mathematics and Geometry. * * <div class="note"><b>Note:</b> * A permutation can be represented by sequence of transpositions each swapping exactly two * offsets. Although the number of transpositions is not fixed, if one representation uses * an even number, then all representations use an even number. Using this, permutations can * be classified as either odd or even. An odd permutation changes the handedness of the system. * An even permutation does not. * </div> * * @return the coordinate system orientation, or {@code null} if unspecified. */ @Draft @UML(identifier="orientation", obligation=OPTIONAL, specification=ISO_19107) Handed getOrientation(); }
@Draft @UML(identifier="GM_Permutation", specification=ISO_19107) public interface Permutation {
@Draft @UML(identifier="DirectPosition", specification=ISO_19107) public interface HomogeneousDirectPosition extends DirectPosition {
@Draft @UML(identifier="GM_CoordinateSystem", specification=ISO_19107) public interface CoordinateSystem {