A point in the real world may have different coordinates, depending on
35 | * the CoordinateReferenceSystem used. The different types of
36 | * CoordinateReferenceSystem defined by EPSG
37 | * are :
CoordinateReferenceSystem.
70 | *
71 | * @return
72 | */
73 | public CoordinateSystem getCoordinateSystem();
74 |
75 | /**
76 | * Returns the {@link Datum} to which this
77 | * CoordinateReferenceSystem is refering. For compound
78 | * CoordinateReferenceSystem, getDatum returns the the main
79 | * datum, ie the {@link org.cts.datum.GeodeticDatum} (or horizontal Datum).
80 | *
81 | * @return
82 | */
83 | public Datum getDatum();
84 |
85 | /**
86 | * Returns the {@link Projection} to which this
87 | * CoordinateReferenceSystem is refering. It returns null if no
88 | * projection is defined for this CRS.
89 | *
90 | * @return
91 | */
92 | public Projection getProjection();
93 |
94 | /**
95 | * Returns a WKT representation of the CoordinateReferenceSystem.
96 | *
97 | * @return
98 | */
99 | public String toWKT();
100 | }
101 |
--------------------------------------------------------------------------------
/src/main/java/org/cts/cs/Extent.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Coordinate Transformations Suite (abridged CTS) is a library developped to
3 | * perform Coordinate Transformations using well known geodetic algorithms
4 | * and parameter sets.
5 | * Its main focus are simplicity, flexibility, interoperability, in this order.
6 | *
7 | * This library has been originally developed by Michaël Michaud under the JGeod
8 | * name. It has been renamed CTS in 2009 and shared to the community from
9 | * the OrbisGIS code repository.
10 | *
11 | * CTS is free software: you can redistribute it and/or modify it under the
12 | * terms of the GNU Lesser General Public License as published by the Free Software
13 | * Foundation, either version 3 of the License.
14 | *
15 | * CTS is distributed in the hope that it will be useful, but WITHOUT ANY
16 | * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
17 | * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
18 | *
19 | * You should have received a copy of the GNU Lesser General Public License along with
20 | * CTS. If not, see Extent defines a part of an infinite n-dimension space thanks to
29 | * a method returning true for any set of coordinates lying inside this part and
30 | * false for coordinates lying outside (input coordinates must be an array of n
31 | * doubles).
32 | *
33 | * @author Michaël Michaud
34 | */
35 | public interface Extent {
36 |
37 | /**
38 | * Return the name of this extent.
39 | */
40 | public String getName();
41 |
42 | /**
43 | * Return wether coord is inside this Extent or not. It's up to the user to
44 | * check consistency between coord and extent type.
45 | */
46 | public boolean isInside(double[] coord);
47 | }
48 |
--------------------------------------------------------------------------------
/src/main/java/org/cts/cs/OutOfExtentException.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Coordinate Transformations Suite (abridged CTS) is a library developped to
3 | * perform Coordinate Transformations using well known geodetic algorithms
4 | * and parameter sets.
5 | * Its main focus are simplicity, flexibility, interoperability, in this order.
6 | *
7 | * This library has been originally developed by Michaël Michaud under the JGeod
8 | * name. It has been renamed CTS in 2009 and shared to the community from
9 | * the OrbisGIS code repository.
10 | *
11 | * CTS is free software: you can redistribute it and/or modify it under the
12 | * terms of the GNU Lesser General Public License as published by the Free Software
13 | * Foundation, either version 3 of the License.
14 | *
15 | * CTS is distributed in the hope that it will be useful, but WITHOUT ANY
16 | * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
17 | * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
18 | *
19 | * You should have received a copy of the GNU Lesser General Public License along with
20 | * CTS. If not, see
32 | * In surveying and geodesy, a datum is a reference point on the earth's surface
33 | * against which position measurements are made, and an associated model of the
34 | * shape of the earth for computing positions. Horizontal datums are used for
35 | * describing a point on the earth's surface, in latitude and longitude or
36 | * another coordinate system. Vertical datums are used to measure elevations or
37 | * underwater depths. In engineering and drafting, a datum is a reference point,
38 | * surface, or axis on an object against which measurements are made.
39 | * (Taken from wikipedia on
40 | * 2006-10-06)
41 | *
42 | * @author Michaël Michaud
43 | */
44 | public interface Datum extends Identifiable {
45 |
46 | /**
47 | * Returns origin description of this Datum.
48 | */
49 | public String getOrigin();
50 |
51 | /**
52 | * Returns the valid extent of this Datum.
53 | */
54 | public Extent getExtent();
55 |
56 | /**
57 | * Returns the realization epoch as a String.
58 | */
59 | public String getEpoch();
60 |
61 | /**
62 | * Returns the ellipsoid of this datum.
63 | */
64 | public Ellipsoid getEllipsoid();
65 |
66 | /**
67 | * Returns the ellipsoid of this datum.
68 | */
69 | public CoordinateOperation getToWGS84();
70 |
71 | /**
72 | * Returns the primemeridian of this datum.
73 | */
74 | public PrimeMeridian getPrimeMeridian();
75 | }
--------------------------------------------------------------------------------
/src/main/java/org/cts/op/AbstractCoordinateOperation.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Coordinate Transformations Suite (abridged CTS) is a library developped to
3 | * perform Coordinate Transformations using well known geodetic algorithms
4 | * and parameter sets.
5 | * Its main focus are simplicity, flexibility, interoperability, in this order.
6 | *
7 | * This library has been originally developed by Michaël Michaud under the JGeod
8 | * name. It has been renamed CTS in 2009 and shared to the community from
9 | * the OrbisGIS code repository.
10 | *
11 | * CTS is free software: you can redistribute it and/or modify it under the
12 | * terms of the GNU Lesser General Public License as published by the Free Software
13 | * Foundation, either version 3 of the License.
14 | *
15 | * CTS is distributed in the hope that it will be useful, but WITHOUT ANY
16 | * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
17 | * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
18 | *
19 | * You should have received a copy of the GNU Lesser General Public License along with
20 | * CTS. If not, see coord is not
58 | * compatible with this CoordinateOperation.
59 | * @throws org.cts.op.CoordinateOperationException if this operation
60 | * failed during the transformation process.
61 | */
62 | public abstract double[] transform(double[] coord)
63 | throws IllegalCoordinateException, CoordinateOperationException;
64 |
65 | /**
66 | * Creates the inverse CoordinateOperation. This method can be used to chain
67 | * {@link org.cts.op.CoordinateOperation}s and/or inverse CoordinateOperation in
68 | * a unique CoordinateOperationSequence. This method is not declared
69 | * abstract, so that implementation classes have not to implement it if they
70 | * represent non invertible operation.
71 | */
72 | public CoordinateOperation inverse()
73 | throws NonInvertibleOperationException {
74 | throw new NonInvertibleOperationException(this.toString()
75 | + " is non invertible");
76 | }
77 |
78 | /**
79 | * Returns the precision of the transformation.
Precision is a double 80 | * representing the mean error, in meters made on the position resulting 81 | * from this {@link org.cts.op.CoordinateOperation}.
ex. : 0.001 means that 82 | * the precision of the resulting position is about one millimeter
83 | * Default precision (or maximum precision) is considered to be equals to
84 | * 1E-9 which is the value of an ulp (units in the last place) for a double
85 | * value equals to 6378137.0 (Earth semi-major axis).
86 | */
87 | public double getPrecision() {
88 | return precision;
89 | }
90 |
91 |
92 | /**
93 | * @return true if this operation does not change coordinates.
94 | */
95 | public boolean isIdentity() {
96 | return false;
97 | }
98 | }
--------------------------------------------------------------------------------
/src/main/java/org/cts/op/ChangeCoordinateDimension.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Coordinate Transformations Suite (abridged CTS) is a library developped to
3 | * perform Coordinate Transformations using well known geodetic algorithms
4 | * and parameter sets.
5 | * Its main focus are simplicity, flexibility, interoperability, in this order.
6 | *
7 | * This library has been originally developed by Michaël Michaud under the JGeod
8 | * name. It has been renamed CTS in 2009 and shared to the community from
9 | * the OrbisGIS code repository.
10 | *
11 | * CTS is free software: you can redistribute it and/or modify it under the
12 | * terms of the GNU Lesser General Public License as published by the Free Software
13 | * Foundation, either version 3 of the License.
14 | *
15 | * CTS is distributed in the hope that it will be useful, but WITHOUT ANY
16 | * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
17 | * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
18 | *
19 | * You should have received a copy of the GNU Lesser General Public License along with
20 | * CTS. If not, see
31 | * This is the main interface used to implement geodetic algorithms and perform 32 | * coordinate conversions or coordinate transformations from one 33 | * {@link org.cts.crs.CoordinateReferenceSystem} to another. 34 | * 35 | * @author Michaël Michaud 36 | */ 37 | public interface CoordinateOperation extends Identifiable { 38 | 39 | /** 40 | * Transform values of a double array.
WARNING : In the general
41 | * case, double values of the coord parameter are changed without the
42 | * creation of a new array. In some cases (when the returned array must have
43 | * a different length, a new double array is created and returned.
44 | *
45 | * @param coord coordinate to be transformed
46 | * @return the same object with new values or a new double array
47 | * @throws IllegalCoordinateException if coord is not
48 | * compatible with this CoordinateOperation.
49 | * @throws org.cts.op.CoordinateOperationException if this operation
50 | * failed during the transformation process.
51 | */
52 | public double[] transform(double[] coord) throws IllegalCoordinateException, CoordinateOperationException;
53 |
54 | /**
55 | * Return the inverse CoordinateOperation, or throw a
56 | * NonInvertibleOperationException. If op.inverse() is not null,
57 | *
58 | * op.inverse().transform(op.transform(point)); 59 | *should let point unchanged. 60 | */ 61 | public CoordinateOperation inverse() throws NonInvertibleOperationException; 62 | 63 | /** 64 | * Return the precision of the transformation.
Precision is a double
65 | * representing the mean error, in meters made on the position resulting
66 | * from this
67 | * CoordinateOperation.
ex. : 0.001 means that the precision 68 | * of the resulting position is about one millimeter
Default precision
69 | * (or maximum precision) is considered to be equals to 1E-9 which is the
70 | * value of an ulp (units in the last place) for a double value equals to
71 | * 6378137.0 (Earth semi-major axis).
72 | */
73 | public double getPrecision();
74 |
75 | /**
76 | * @return true if this operation does not change coordinates.
77 | */
78 | public boolean isIdentity();
79 | }
--------------------------------------------------------------------------------
/src/main/java/org/cts/op/CoordinateOperationException.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Coordinate Transformations Suite (abridged CTS) is a library developped to
3 | * perform Coordinate Transformations using well known geodetic algorithms
4 | * and parameter sets.
5 | * Its main focus are simplicity, flexibility, interoperability, in this order.
6 | *
7 | * This library has been originally developed by Michaël Michaud under the JGeod
8 | * name. It has been renamed CTS in 2009 and shared to the community from
9 | * the OrbisGIS code repository.
10 | *
11 | * CTS is free software: you can redistribute it and/or modify it under the
12 | * terms of the GNU Lesser General Public License as published by the Free Software
13 | * Foundation, either version 3 of the License.
14 | *
15 | * CTS is distributed in the hope that it will be useful, but WITHOUT ANY
16 | * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
17 | * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
18 | *
19 | * You should have received a copy of the GNU Lesser General Public License along with
20 | * CTS. If not, see coord is not
87 | * compatible with this CoordinateOperation.
88 | */
89 | @Override
90 | public double[] transform(double[] coord) throws IllegalCoordinateException {
91 | if (coord == null || coord.length == 0) {
92 | throw new CoordinateDimensionException(Arrays.toString(coord)
93 | + " is an invalid coordinate");
94 | }
95 | for (int i = 0; i < coord.length; i++) {
96 | if (Double.isNaN(coord[i])) {
97 | continue;
98 | }
99 | coord[i] = Math.rint(coord[i] * inv_resolution) / inv_resolution;
100 | }
101 | return coord;
102 | }
103 |
104 | /**
105 | * Creates a coordinate rounding operation from a decimal place number.
106 | *
107 | * @param decimalPlaces number of decimal places
108 | */
109 | public static CoordinateRounding createCoordinateRoundingOperationFromDecimalPlaces(int decimalPlaces) {
110 | double u = 1.0;
111 | for (int i = 0; i < decimalPlaces; i++) {
112 | u *= 10.0;
113 | }
114 | return new CoordinateRounding(1.0 / u);
115 | }
116 |
117 | /**
118 | * Creates a coordinate rounding operation from the smallest representable
119 | * value.
120 | *
121 | * @param resolution smallest representable value
122 | */
123 | public static CoordinateRounding createCoordinateRoundingOperation(double resolution) {
124 | return new CoordinateRounding(resolution);
125 | }
126 | }
127 |
--------------------------------------------------------------------------------
/src/main/java/org/cts/op/CoordinateSwitch.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Coordinate Transformations Suite (abridged CTS) is a library developped to
3 | * perform Coordinate Transformations using well known geodetic algorithms
4 | * and parameter sets.
5 | * Its main focus are simplicity, flexibility, interoperability, in this order.
6 | *
7 | * This library has been originally developed by Michaël Michaud under the JGeod
8 | * name. It has been renamed CTS in 2009 and shared to the community from
9 | * the OrbisGIS code repository.
10 | *
11 | * CTS is free software: you can redistribute it and/or modify it under the
12 | * terms of the GNU Lesser General Public License as published by the Free Software
13 | * Foundation, either version 3 of the License.
14 | *
15 | * CTS is distributed in the hope that it will be useful, but WITHOUT ANY
16 | * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
17 | * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
18 | *
19 | * You should have received a copy of the GNU Lesser General Public License along with
20 | * CTS. If not, see coord is not
52 | * compatible with this CoordinateOperation.
53 | */
54 | @Override
55 | public double[] transform(double[] coord)
56 | throws IllegalCoordinateException {
57 | if (coord.length < Math.min(pos1, pos2)) {
58 | throw new CoordinateDimensionException(coord, Math.max(pos1, pos2));
59 | }
60 | double d1 = coord[pos1];
61 | coord[pos1] = coord[pos2];
62 | coord[pos2] = d1;
63 | return coord;
64 | }
65 |
66 | /**
67 | * Creates the inverse CoordinateOperation.
68 | */
69 | @Override
70 | public CoordinateOperation inverse() {
71 | return this;
72 | }
73 |
74 | /**
75 | * Creates a new operation to switch coord pos1 and coord pos2.
76 | *
77 | * @param pos1 position of the ordinate to switch to pos2
78 | * @param pos2 position of the ordinate to switch to pos1
79 | */
80 | public CoordinateSwitch(int pos1, int pos2) {
81 | super(new Identifier(CoordinateOperation.class, "Coordinates switch"));
82 | this.pos1 = pos1;
83 | this.pos2 = pos2;
84 | }
85 |
86 | /**
87 | * Returns true if o is equals to this operation.
88 | *
89 | * @param o The object to compare to
90 | */
91 | @Override
92 | public boolean equals(Object o) {
93 | if (this == o) return true;
94 | return o instanceof CoordinateSwitch &&
95 | pos1 == ((CoordinateSwitch) o).pos1 &&
96 | pos2 == ((CoordinateSwitch) o).pos2;
97 | }
98 | }
--------------------------------------------------------------------------------
/src/main/java/org/cts/op/Identity.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Coordinate Transformations Suite (abridged CTS) is a library developped to
3 | * perform Coordinate Transformations using well known geodetic algorithms
4 | * and parameter sets.
5 | * Its main focus are simplicity, flexibility, interoperability, in this order.
6 | *
7 | * This library has been originally developed by Michaël Michaud under the JGeod
8 | * name. It has been renamed CTS in 2009 and shared to the community from
9 | * the OrbisGIS code repository.
10 | *
11 | * CTS is free software: you can redistribute it and/or modify it under the
12 | * terms of the GNU Lesser General Public License as published by the Free Software
13 | * Foundation, either version 3 of the License.
14 | *
15 | * CTS is distributed in the hope that it will be useful, but WITHOUT ANY
16 | * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
17 | * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
18 | *
19 | * You should have received a copy of the GNU Lesser General Public License along with
20 | * CTS. If not, see
This transformation doesn't do anything.
33 | *
34 | * @author Michaël Michaud
35 | */
36 | public class Identity extends AbstractCoordinateOperation implements ParamBasedTransformation, GeocentricTransformation {
37 |
38 | /**
39 | * The identity transformation. When used to transform coordinates, it
40 | * returns the input coordinates.
41 | */
42 | public static final Identity IDENTITY = new Identity();
43 |
44 | /**
45 | * Identity is defined as a Singleton in order to avoid unuseful object
46 | * creation.
47 | */
48 | private Identity() {
49 | super(new Identifier(CoordinateOperation.class, "Identity"));
50 | this.precision = 0.0;
51 | }
52 |
53 | /**
54 | * Apply the identity transformation to input coordinates.
55 | *
56 | * @param coord is an array containing one, two or three ordinates
57 | */
58 | @Override
59 | public double[] transform(double[] coord) {
60 | return coord;
61 | }
62 |
63 | /**
64 | * Creates the inverse CoordinateOperation.
65 | */
66 | @Override
67 | public GeocentricTransformation inverse() {
68 | return this;
69 | }
70 |
71 | /**
72 | * Returns true if o is also an Identity CoordinateOperation.
73 | *
74 | * @param o The object to compare this ProjectedCRS against
75 | */
76 | @Override
77 | public boolean equals(Object o) {
78 | if (this == o) {
79 | return true;
80 | }
81 | if (o instanceof CoordinateOperation) {
82 | return ((CoordinateOperation) o).isIdentity();
83 | }
84 | return false;
85 | }
86 |
87 | /**
88 | * Returns 0 for all identity operations.
89 | */
90 | @Override
91 | public int hashCode() {
92 | return 0;
93 | }
94 |
95 | /**
96 | * @return true if this operation does not change coordinates.
97 | */
98 | public boolean isIdentity() {
99 | return true;
100 | }
101 | }
102 |
--------------------------------------------------------------------------------
/src/main/java/org/cts/op/IterativeTransformation.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Coordinate Transformations Suite (abridged CTS) is a library developped to
3 | * perform Coordinate Transformations using well known geodetic algorithms
4 | * and parameter sets.
5 | * Its main focus are simplicity, flexibility, interoperability, in this order.
6 | *
7 | * This library has been originally developed by Michaël Michaud under the JGeod
8 | * name. It has been renamed CTS in 2009 and shared to the community from
9 | * the OrbisGIS code repository.
10 | *
11 | * CTS is free software: you can redistribute it and/or modify it under the
12 | * terms of the GNU Lesser General Public License as published by the Free Software
13 | * Foundation, either version 3 of the License.
14 | *
15 | * CTS is distributed in the hope that it will be useful, but WITHOUT ANY
16 | * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
17 | * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
18 | *
19 | * You should have received a copy of the GNU Lesser General Public License along with
20 | * CTS. If not, see coord is not
64 | * compatible with this CoordinateOperation.
65 | */
66 | @Override
67 | public double[] transform(double[] coord) throws IllegalCoordinateException {
68 | if (coord.length < 4) {
69 | throw new IllegalCoordinateException("There is no saved value in these coordinates.");
70 | }
71 | double[] cc = new double[coord.length - 1];
72 | System.arraycopy(coord, 0, cc, 0, coord.length - 1);
73 | cc[indexSaved] = coord[coord.length - 1];
74 | return cc;
75 | }
76 | }
77 |
--------------------------------------------------------------------------------
/src/main/java/org/cts/op/MemorizeCoordinate.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Coordinate Transformations Suite (abridged CTS) is a library developped to
3 | * perform Coordinate Transformations using well known geodetic algorithms
4 | * and parameter sets.
5 | * Its main focus are simplicity, flexibility, interoperability, in this order.
6 | *
7 | * This library has been originally developed by Michaël Michaud under the JGeod
8 | * name. It has been renamed CTS in 2009 and shared to the community from
9 | * the OrbisGIS code repository.
10 | *
11 | * CTS is free software: you can redistribute it and/or modify it under the
12 | * terms of the GNU Lesser General Public License as published by the Free Software
13 | * Foundation, either version 3 of the License.
14 | *
15 | * CTS is distributed in the hope that it will be useful, but WITHOUT ANY
16 | * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
17 | * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
18 | *
19 | * You should have received a copy of the GNU Lesser General Public License along with
20 | * CTS. If not, see
Try to use an interpolation method which is not defined or not yet 28 | * implemented.
29 | * 30 | * @author Michaël Michaud 31 | */ 32 | public class NonInvertibleOperationException extends CoordinateOperationException { 33 | 34 | /** 35 | * Create a new NonInvertibleOperationException. 36 | * 37 | * @param exception description of this exception 38 | */ 39 | public NonInvertibleOperationException(String exception) { 40 | super(exception); 41 | } 42 | 43 | /** 44 | * Create a new InterpolationMethodException. 45 | * 46 | * @param op the interpolation method 47 | */ 48 | public NonInvertibleOperationException(CoordinateOperation op) { 49 | super("" + op.getName() + " is not invertible"); 50 | } 51 | } 52 | -------------------------------------------------------------------------------- /src/main/java/org/cts/op/OppositeCoordinate.java: -------------------------------------------------------------------------------- 1 | /* 2 | * Coordinate Transformations Suite (abridged CTS) is a library developped to 3 | * perform Coordinate Transformations using well known geodetic algorithms 4 | * and parameter sets. 5 | * Its main focus are simplicity, flexibility, interoperability, in this order. 6 | * 7 | * This library has been originally developed by Michaël Michaud under the JGeod 8 | * name. It has been renamed CTS in 2009 and shared to the community from 9 | * the OrbisGIS code repository. 10 | * 11 | * CTS is free software: you can redistribute it and/or modify it under the 12 | * terms of the GNU Lesser General Public License as published by the Free Software 13 | * Foundation, either version 3 of the License. 14 | * 15 | * CTS is distributed in the hope that it will be useful, but WITHOUT ANY 16 | * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR 17 | * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. 18 | * 19 | * You should have received a copy of the GNU Lesser General Public License along with 20 | * CTS. If not, seeGeocentricTransformation
33 | * rather than a 2D transformation like NTv2GridShiftTransformation.
34 | *
35 | * @author Michaël Michaud
36 | */
37 | public interface GeocentricTransformation extends CoordinateOperation {
38 |
39 | public GeocentricTransformation inverse() throws NonInvertibleOperationException;
40 | }
41 |
--------------------------------------------------------------------------------
/src/main/java/org/cts/op/transformation/GeocentricTransformationSequence.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Coordinate Transformations Suite (abridged CTS) is a library developped to
3 | * perform Coordinate Transformations using well known geodetic algorithms
4 | * and parameter sets.
5 | * Its main focus are simplicity, flexibility, interoperability, in this order.
6 | *
7 | * This library has been originally developed by Michaël Michaud under the JGeod
8 | * name. It has been renamed CTS in 2009 and shared to the community from
9 | * the OrbisGIS code repository.
10 | *
11 | * CTS is free software: you can redistribute it and/or modify it under the
12 | * terms of the GNU Lesser General Public License as published by the Free Software
13 | * Foundation, either version 3 of the License.
14 | *
15 | * CTS is distributed in the hope that it will be useful, but WITHOUT ANY
16 | * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
17 | * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
18 | *
19 | * You should have received a copy of the GNU Lesser General Public License along with
20 | * CTS. If not, see this. GeocentricTranslations
88 | * are equals if they both are identity, or if all their parameters are
89 | * equal.
90 | *
91 | * @param o The object to compare this ProjectedCRS against
92 | * @return
93 | */
94 | @Override
95 | public boolean equals(Object o) {
96 | if (this == o) {
97 | return true;
98 | }
99 | if (o instanceof GeocentricTransformationSequence) {
100 | if (sequence.length == ((GeocentricTransformationSequence) o).sequence.length) {
101 | for (int i = 0; i < sequence.length; i++) {
102 | if (!sequence[i].equals(((GeocentricTransformationSequence) o).sequence[i])) {
103 | return false;
104 | }
105 | }
106 | }
107 | }
108 | return false;
109 | }
110 |
111 | /**
112 | * Returns the hash code for this GeocentricTranslation.
113 | *
114 | * @return
115 | */
116 | @Override
117 | public int hashCode() {
118 | if (isIdentity()) {
119 | return 0;
120 | }
121 | int hash = 5;
122 | hash = 19 * hash + Arrays.deepHashCode(this.sequence);
123 | return hash;
124 | }
125 |
126 | }
127 |
--------------------------------------------------------------------------------
/src/main/java/org/cts/op/transformation/GridBasedTransformation.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Coordinate Transformations Suite (abridged CTS) is a library developped to
3 | * perform Coordinate Transformations using well known geodetic algorithms
4 | * and parameter sets.
5 | * Its main focus are simplicity, flexibility, interoperability, in this order.
6 | *
7 | * This library has been originally developed by Michaël Michaud under the JGeod
8 | * name. It has been renamed CTS in 2009 and shared to the community from
9 | * the OrbisGIS code repository.
10 | *
11 | * CTS is free software: you can redistribute it and/or modify it under the
12 | * terms of the GNU Lesser General Public License as published by the Free Software
13 | * Foundation, either version 3 of the License.
14 | *
15 | * CTS is distributed in the hope that it will be useful, but WITHOUT ANY
16 | * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
17 | * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
18 | *
19 | * You should have received a copy of the GNU Lesser General Public License along with
20 | * CTS. If not, see
42 | * If the grid is not packaged into the resources folder then we look into a
43 | * ./cts folder.
44 | * If the grid does not exist in this folder, we try to download it from
45 | * the CTS repository.
46 | *
47 | * @param nameGrid name of the grid with its extension
48 | * @return
49 | * @throws FileNotFoundException
50 | * @throws IOException
51 | */
52 | public static File findGrid(String nameGrid) throws FileNotFoundException, IOException {
53 | //If the grid doesn't exist in resources folder then
54 | //We look into a .cts folder
55 | String ctsFolderPath = new File(System.getProperty("user.home")).getAbsolutePath() + File.separator + ".cts";
56 | File ctsFileFolder = new File(ctsFolderPath);
57 | File gridFile = new File(ctsFolderPath + File.separator + nameGrid);
58 | if (ctsFileFolder.exists()) {
59 | if (gridFile.exists()) {
60 | return gridFile;
61 | } else if (ctsFileFolder.canWrite()) {
62 | //Try to download the grid on the CTS repository
63 | downloadFile(gridFile, new URL(URL_PATH + nameGrid));
64 | return gridFile;
65 | } else {
66 | throw new IOException("Cannot download the grid : " + nameGrid + " into .cts folder");
67 | }
68 | } else {
69 | boolean ctsDir = ctsFileFolder.mkdir();
70 | if (ctsDir && ctsFileFolder.canWrite()) {
71 | //Try to download the grid on the CTS repository
72 | downloadFile(gridFile, new URL(URL_PATH + nameGrid));
73 | return gridFile;
74 | } else {
75 | throw new IOException("Unable to create the .cts folder");
76 | }
77 | }
78 | }
79 |
80 | /**
81 | * Download a file from an URL to a specified target
82 | *
83 | * @param outputFile
84 | * @param urlGrid
85 | * @throws MalformedURLException
86 | * @throws IOException
87 | */
88 | public static void downloadFile(final File outputFile, final URL urlGrid)
89 | throws MalformedURLException, IOException {
90 | BufferedInputStream in = null;
91 | FileOutputStream fout = null;
92 | try {
93 | in = new BufferedInputStream(urlGrid.openStream());
94 | fout = new FileOutputStream(outputFile);
95 |
96 | final byte data[] = new byte[1024];
97 | int count;
98 | while ((count = in.read(data, 0, 1024)) != -1) {
99 | fout.write(data, 0, count);
100 | }
101 | } finally {
102 | try {
103 | if (in != null) {
104 | in.close();
105 | }
106 | } catch (IOException ie) {
107 | //Do nothing
108 | }
109 | try {
110 | if (fout != null) {
111 | fout.close();
112 | }
113 | } catch (IOException ie) {
114 | //Do nothing
115 | }
116 | }
117 | }
118 |
119 | }
120 |
--------------------------------------------------------------------------------
/src/main/java/org/cts/op/transformation/grids/InterpolationMethodException.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Coordinate Transformations Suite (abridged CTS) is a library developped to
3 | * perform Coordinate Transformations using well known geodetic algorithms
4 | * and parameter sets.
5 | * Its main focus are simplicity, flexibility, interoperability, in this order.
6 | *
7 | * This library has been originally developed by Michaël Michaud under the JGeod
8 | * name. It has been renamed CTS in 2009 and shared to the community from
9 | * the OrbisGIS code repository.
10 | *
11 | * CTS is free software: you can redistribute it and/or modify it under the
12 | * terms of the GNU Lesser General Public License as published by the Free Software
13 | * Foundation, either version 3 of the License.
14 | *
15 | * CTS is distributed in the hope that it will be useful, but WITHOUT ANY
16 | * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
17 | * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
18 | *
19 | * You should have received a copy of the GNU Lesser General Public License along with
20 | * CTS. If not, see
Try to use an interpolation method which is not defined or not yet 28 | * implemented.
29 | * 30 | * @author Michaël Michaud 31 | */ 32 | public class InterpolationMethodException extends Exception { 33 | 34 | /** 35 | * Create a new InterpolationMethodException. 36 | * 37 | * @param exception description of this exception 38 | */ 39 | public InterpolationMethodException(String exception) { 40 | super(exception); 41 | } 42 | 43 | /** 44 | * Create a new InterpolationMethodException. 45 | * 46 | * @param method the interpolation method 47 | */ 48 | public InterpolationMethodException(Grid.InterpolationMethod method) { 49 | super("" + method + " is not a valid interpolation method"); 50 | } 51 | 52 | /** 53 | * Create a new InterpolationMethodException. 54 | * 55 | * @param method the interpolation method 56 | * @param gridClass the class trying to use the interpolation method 57 | */ 58 | public InterpolationMethodException(Grid.InterpolationMethod method, Class gridClass) { 59 | super("" + method + " is not a valid interpolation method for " + gridClass.getName()); 60 | } 61 | } -------------------------------------------------------------------------------- /src/main/java/org/cts/parser/prj/AbstractPrjElement.java: -------------------------------------------------------------------------------- 1 | /* 2 | * Coordinate Transformations Suite (abridged CTS) is a library developped to 3 | * perform Coordinate Transformations using well known geodetic algorithms 4 | * and parameter sets. 5 | * Its main focus are simplicity, flexibility, interoperability, in this order. 6 | * 7 | * This library has been originally developed by Michaël Michaud under the JGeod 8 | * name. It has been renamed CTS in 2009 and shared to the community from 9 | * the OrbisGIS code repository. 10 | * 11 | * CTS is free software: you can redistribute it and/or modify it under the 12 | * terms of the GNU Lesser General Public License as published by the Free Software 13 | * Foundation, either version 3 of the License. 14 | * 15 | * CTS is distributed in the hope that it will be useful, but WITHOUT ANY 16 | * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR 17 | * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. 18 | * 19 | * You should have received a copy of the GNU Lesser General Public License along with 20 | * CTS. If not, seeQuantity SPEED = Quantity.Factory.create("Speed"); Otherwise, you
34 | * can create your own implementation of Quantity :
35 | *
36 | * public class Speed implements Quantity {
37 | * // your implementation
38 | * }
39 | * Note that two quantities are considered as comparable if their
40 | * toString method return equalsIgnoreCase values.
41 | *
42 | * For a complete package about units, quantities and measurements, see JSR-275.
43 | *
44 | * @author Michaël Michaud
45 | */
46 | public interface Quantity {
47 |
48 | public Quantity LENGTH = Factory.create("Length");
49 | public Quantity ANGLE = Factory.create("Angle");
50 | public Quantity NODIM = Factory.create("Dimensionless");
51 | public Quantity TIME = Factory.create("Time");
52 |
53 | /**
54 | * A factory to easily create
55 | * Quantities from simple Strings.
56 | */
57 | public class Factory {
58 |
59 | /**
60 | * Creates a new Quantity from a String.
61 | *
62 | * @param name the name of the Quantity to be created
63 | * @return a new Quantity object
64 | */
65 | public static Quantity create(final String name) {
66 | return new Quantity() {
67 | @Override
68 | public String toString() {
69 | return name;
70 | }
71 |
72 | @Override
73 | public boolean equals(Object o) {
74 | if (!(o instanceof Quantity)) {
75 | return false;
76 | }
77 | return toString().equalsIgnoreCase(o.toString());
78 | }
79 |
80 | @Override
81 | public int hashCode() {
82 | return 5;
83 | }
84 | };
85 | }
86 | }
87 | }
88 |
--------------------------------------------------------------------------------
/src/main/resources/org/cts/log4j.properties:
--------------------------------------------------------------------------------
1 | # Root logger option
2 | log4j.rootLogger=INFO, stdout
3 |
4 | # Direct log messages to stdout
5 | log4j.appender.stdout=org.apache.log4j.ConsoleAppender
6 | log4j.appender.stdout.Target=System.out
7 | log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
8 | log4j.appender.stdout.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %-5p %c{1}:%L - %m%n
9 |
10 |
--------------------------------------------------------------------------------
/src/test/java/org/cts/CRSHelperTest.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Coordinate Transformations Suite (abridged CTS) is a library developped to
3 | * perform Coordinate Transformations using well known geodetic algorithms
4 | * and parameter sets.
5 | * Its main focus are simplicity, flexibility, interoperability, in this order.
6 | *
7 | * This library has been originally developed by Michaël Michaud under the JGeod
8 | * name. It has been renamed CTS in 2009 and shared to the community from
9 | * the OrbisGIS code repository.
10 | *
11 | * CTS is free software: you can redistribute it and/or modify it under the
12 | * terms of the GNU Lesser General Public License as published by the Free Software
13 | * Foundation, either version 3 of the License.
14 | *
15 | * CTS is distributed in the hope that it will be useful, but WITHOUT ANY
16 | * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
17 | * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
18 | *
19 | * You should have received a copy of the GNU Lesser General Public License along with
20 | * CTS. If not, see