001: /*
002: * This file is part of the GeOxygene project source files.
003: *
004: * GeOxygene aims at providing an open framework which implements OGC/ISO specifications for
005: * the development and deployment of geographic (GIS) applications. It is a open source
006: * contribution of the COGIT laboratory at the Institut Géographique National (the French
007: * National Mapping Agency).
008: *
009: * See: http://oxygene-project.sourceforge.net
010: *
011: * Copyright (C) 2005 Institut Géographique National
012: *
013: * This library is free software; you can redistribute it and/or modify it under the terms
014: * of the GNU Lesser General Public License as published by the Free Software Foundation;
015: * either version 2.1 of the License, or any later version.
016: *
017: * This library is distributed in the hope that it will be useful, but WITHOUT ANY
018: * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
019: * PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
020: *
021: * You should have received a copy of the GNU Lesser General Public License along with
022: * this library (see file LICENSE if present); if not, write to the Free Software
023: * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
024: *
025: */
026:
027: package fr.ign.cogit.geoxygene.spatial.coordgeom;
028:
029: //import SRC.SC_CRS -> non implemente;
030: import fr.ign.cogit.geoxygene.spatial.geomprim.GM_Point;
031:
032: /**
033: * Point connu par ses coordonnées.
034: * Les coordonnées sont connues par un tableau, de longueur la dimension des géométries (2D ou 3D).
035: * Dans cette version, tous les DirectPosition sont en 3D.
036: * Si on est en 2D, la 3ieme coordonnée vaut NaN.
037: *
038: * @author Thierry Badard & Arnaud Braun
039: * @version 1.1
040: *
041: * 19.02.2007 : correction de bug méthode move(double offsetX, double offsetY, double offsetZ)
042: *
043: */
044:
045: public class DirectPosition {
046:
047: //////////////////////////////////////////////////////////////////////////////////////////
048: // Attribut CRS //////////////////////////////////////////////////////////////////////////
049: //////////////////////////////////////////////////////////////////////////////////////////
050: /** Identifiant du système de coordonnées de référence (CRS en anglais).
051: * Lorsque les DirectPosition servent à définir un GM_Object, cet attribut doit être null.
052: * En effet, il est alors porté par le GM_Object. */
053: // Dans la norme ISO, cet attribut est une relation qui pointe vers la classe SC_CRS (non implémentée)
054: protected int CRS;
055:
056: /** Renvoie l' identifiant du système de coordonnées de référence. */
057: public int getCRS() {
058: return this .CRS;
059: }
060:
061: /** Affecte une valeur au système de coordonnées de référence. */
062: public void setCRS(int crs) {
063: CRS = crs;
064: }
065:
066: //////////////////////////////////////////////////////////////////////////////////////////
067: // Attribut coordinate et dimension //////////////////////////////////////////////////////
068: //////////////////////////////////////////////////////////////////////////////////////////
069: /** Tableau des coordonnées du point. */
070: protected double[] coordinate = new double[3];
071:
072: /** Dimension des coordonnées (2D ou 3D) - dimension = coordinate.length */
073: protected int dimension = 3;
074:
075: //////////////////////////////////////////////////////////////////////////////////////////
076: // Constructeurs /////////////////////////////////////////////////////////////////////////
077: //////////////////////////////////////////////////////////////////////////////////////////
078: /** Constructeur par défaut (3D): crée un tableau de coordonées à 3 dimensions, vide.*/
079: public DirectPosition() {
080: coordinate[0] = Double.NaN;
081: coordinate[1] = Double.NaN;
082: coordinate[2] = Double.NaN;
083: }
084:
085: /** Constructeur d'un DirectPosition à n dimensions : crée un tableau de coordonées à n dimensions, vide.*/
086: /*public DirectPosition(int n) {
087: coordinate = new double[n];
088: dimension = n;
089: }*/
090:
091: /** Constructeur à partir d'un tableau de coordonnées.
092: * Si le tableau passé en paramètre est 2D, la 3ième coordonnée du DirectPosition vaudra NaN.
093: * Le tableau est recopié et non passé en référence. */
094: public DirectPosition(double[] coord) {
095: coordinate[0] = coord[0];
096: coordinate[1] = coord[1];
097: if (coord.length == 3)
098: coordinate[2] = coord[2];
099: else
100: coordinate[2] = Double.NaN;
101: }
102:
103: /** Constructeur à partir de 2 coordonnées. */
104: public DirectPosition(double X, double Y) {
105: coordinate[0] = X;
106: coordinate[1] = Y;
107: coordinate[2] = Double.NaN;
108: }
109:
110: /** Constructeur à partir de 3 coordonnées. */
111: public DirectPosition(double X, double Y, double Z) {
112: coordinate[0] = X;
113: coordinate[1] = Y;
114: coordinate[2] = Z;
115: }
116:
117: //////////////////////////////////////////////////////////////////////////////////////////
118: // Méthodes get //////////////////////////////////////////////////////////////////////////
119: //////////////////////////////////////////////////////////////////////////////////////////
120: /** Renvoie le tableau des coordonnées. */
121: public double[] getCoordinate() {
122: return this .coordinate;
123: }
124:
125: /** Renvoie la dimension (toujours 3). */
126: public int getDimension() {
127: return this .dimension;
128: }
129:
130: /** Renvoie la i-ème coordonnées (i=0 pour X, i=1 pour Y, i=3 pour Z). */
131: public double getCoordinate(int i) {
132: return this .coordinate[i];
133: }
134:
135: /** Renvoie X (1ère coordonnee du tableau, indice 0). */
136: public double getX() {
137: return this .coordinate[0];
138: }
139:
140: /** Renvoie Y (2ième coordonnée du tableau, indice 1). */
141: public double getY() {
142: return this .coordinate[1];
143: }
144:
145: /** Renvoie Z (3ième coordonnée du tableau, indice 2). */
146: public double getZ() {
147: return this .coordinate[2];
148: }
149:
150: //////////////////////////////////////////////////////////////////////////////////////////
151: // Méthodes set //////////////////////////////////////////////////////////////////////////
152: //////////////////////////////////////////////////////////////////////////////////////////
153: /** Affecte les coordonnées d'un tableau des coordonnées (2D ou 3D).
154: * Si le tableau passé en paramètre est 2D, la 3ième coordonnée du DirectPosition vaudra NaN.
155: * Le tableau est recopié et non passé en référence. */
156: public void setCoordinate(double[] coord) {
157: coordinate[0] = coord[0];
158: coordinate[1] = coord[1];
159: if (coord.length == 3)
160: coordinate[2] = coord[2];
161: else
162: coordinate[2] = Double.NaN;
163: }
164:
165: /** Affecte la position d'un point géométrique. Le point passé en paramètre doit avoir la même dimension que this.*/
166: public void setCoordinate(GM_Point thePoint) {
167: DirectPosition pt = thePoint.getPosition();
168: double[] coord = pt.getCoordinate();
169: /*if (dimension == coord.length)
170: for (int i=0; i<coord.length; i++) coordinate[i] = coord[i];*/
171: setCoordinate(coord);
172: }
173:
174: /** Affecte une valeur à la i-ème coordonnées (i=0 pour X, i=1 pour Y, i=3 pour Z.). */
175: public void setCoordinate(int i, double x) {
176: coordinate[i] = x;
177: }
178:
179: /** Affecte une valeur à X et Y. */
180: public void setCoordinate(double x, double y) {
181: coordinate[0] = x;
182: coordinate[1] = y;
183: coordinate[2] = Double.NaN;
184: }
185:
186: /** Affecte une valeur à X, Y et Z. */
187: public void setCoordinate(double x, double y, double z) {
188: coordinate[0] = x;
189: coordinate[1] = y;
190: coordinate[2] = z;
191: }
192:
193: /** Affecte une valeur à X (1ère coordonnée du tableau). */
194: public void setX(double x) {
195: coordinate[0] = x;
196: }
197:
198: /** Affecte une valeur à Y (2ième coordonnée du tableau). */
199: public void setY(double y) {
200: coordinate[1] = y;
201: }
202:
203: /** Affecte une valeur à Z (3ième coordonnée du tableau). */
204: public void setZ(double z) {
205: coordinate[2] = z;
206: }
207:
208: //////////////////////////////////////////////////////////////////////////////////////////
209: // Méthodes move /////////////////////////////////////////////////////////////////////////
210: //////////////////////////////////////////////////////////////////////////////////////////
211: /** Déplace le point suivant toutes les dimensions. Le point passé en paramètre doit avoir la même dimension que this.*/
212: public void move(DirectPosition offsetPoint) {
213: if (dimension == offsetPoint.getDimension())
214: for (int i = 0; i < dimension; i++)
215: coordinate[i] += offsetPoint.getCoordinate(i);
216: }
217:
218: /** Déplace le point suivant X et Y. */
219: public void move(double offsetX, double offsetY) {
220: coordinate[0] += offsetX;
221: coordinate[1] += offsetY;
222: }
223:
224: /** Déplace le point suivant X, Y et Z.
225: * coordinate.length<3 -> coordinate.length<4
226: */
227: public void move(double offsetX, double offsetY, double offsetZ) {
228: if (coordinate.length < 4) {
229: coordinate[0] += offsetX;
230: coordinate[1] += offsetY;
231: coordinate[2] += offsetZ;
232: }
233: }
234:
235: //////////////////////////////////////////////////////////////////////////////////////////
236: // Méthode equals ////////////////////////////////////////////////////////////////////////
237: //////////////////////////////////////////////////////////////////////////////////////////
238: /** Indique si self et le point passé en paramètre sont égaux, à une tolérance près.
239: * Si les 2 points ont une troisième dimension affectée, on teste cette dimension.
240: * Tolérance est un double qui doit être > 0. */
241: public boolean equals(DirectPosition pt, double tolerance) {
242: double x1, x2;
243: for (int i = 0; i <= 1; i++) {
244: x1 = coordinate[i];
245: x2 = pt.getCoordinate(i);
246: if ((x2 > x1 + tolerance) || (x2 < x1 - tolerance))
247: return false;
248: }
249: if (!Double.isNaN(this .getZ()))
250: if (!Double.isNaN(pt.getZ())) {
251: x1 = coordinate[2];
252: x2 = pt.getCoordinate(2);
253: if ((x2 > x1 + tolerance) || (x2 < x1 - tolerance))
254: return false;
255: }
256: return true;
257: }
258:
259: /** Indique si self et le point passé en paramètre sont égaux EN 2D, à une tolérance près.
260: * Tolérance est un double qui doit être > 0. */
261: public boolean equals2D(DirectPosition pt, double tolerance) {
262: double x1, x2;
263: for (int i = 0; i <= 1; i++) {
264: x1 = coordinate[i];
265: x2 = pt.getCoordinate(i);
266: if ((x2 > x1 + tolerance) || (x2 < x1 - tolerance))
267: return false;
268: }
269: return true;
270: }
271:
272: //////////////////////////////////////////////////////////////////////////////////////////
273: // Méthode clone /////////////////////////////////////////////////////////////////////////
274: //////////////////////////////////////////////////////////////////////////////////////////
275: /** Clone le point. */
276: public Object clone() {
277: DirectPosition dp = new DirectPosition(this .getCoordinate());
278: return dp;
279: }
280:
281: //////////////////////////////////////////////////////////////////////////////////////////
282: // Méthode toGM_Point ////////////////////////////////////////////////////////////////////
283: //////////////////////////////////////////////////////////////////////////////////////////
284: /** Créée un GM_Point à partir de this.*/
285: public GM_Point toGM_Point() {
286: return new GM_Point(this );
287: }
288:
289: //////////////////////////////////////////////////////////////////////////////////////////
290: // Méthode d'affichage ///////////////////////////////////////////////////////////////////
291: //////////////////////////////////////////////////////////////////////////////////////////
292: /** Affiche les coordonnées du point (2D et 3D). */
293: public String toString() {
294: if (Double.isNaN(this .getZ()))
295: return new String("DirectPosition - X : " + this .getX()
296: + " Y : " + this .getY());
297: else
298: return new String("DirectPosition - X : " + this .getX()
299: + " Y : " + this .getY() + " Z : "
300: + this.getZ());
301: }
302:
303: }
|