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 java.util.ArrayList;
030: import java.util.Iterator;
031: import java.util.List;
032:
033: /**
034: * Liste de DirectPosition.
035: * On reprend les méthodes standards de <tt> java.util.List </tt> en les typant.
036: *
037: * @author Thierry Badard & Arnaud Braun
038: * @version 1.1
039: *
040: * 19.02.2007 : ajout de la méthode removeAll
041: *
042: */
043:
044: ///////// Dans la norme ISO, cette classe s'appelle GM_PointArray
045:
046: public class DirectPositionList {
047:
048: /** La liste des DirectPosition. */
049: protected List list = new ArrayList();
050:
051: /** Itérateur sur la liste des DirectPosition. */
052: private Iterator iList;
053:
054: /** Affecte une liste à this. Attention, ne vérifie pas que la liste
055: * passée en paramètre ne contient que des DirectPosition. Ne clone pas la liste
056: * passée en paramètre mais fait une référence. */
057: public void setList(List theList) {
058: list = theList;
059: }
060:
061: /** Renvoie la liste de DirectPosition. */
062: public List getList() {
063: return this .list;
064: }
065:
066: /** Renvoie l'élément de rang i */
067: public DirectPosition get(int i) {
068: return (DirectPosition) this .list.get(i);
069: }
070:
071: /** Affecte un élément au i-ème rang de la liste */
072: public void set(int i, DirectPosition value) {
073: this .list.set(i, value);
074: }
075:
076: /** Ajoute un élément en fin de liste */
077: public void add(DirectPosition value) {
078: this .list.add(value);
079: }
080:
081: /** Ajoute un élément au i-ème rang de la liste */
082: public void add(int i, DirectPosition value) {
083: this .list.add(i, value);
084: }
085:
086: /** Ajoute une liste deDirectPosititon en fin de liste */
087: public void addAll(DirectPositionList theList) {
088: this .list.addAll(theList.getList());
089: }
090:
091: /** Efface de la liste le (ou les) éléments passé en paramètre */
092: public void remove(DirectPosition value) {
093: this .list.remove(value);
094: }
095:
096: /** Efface le i-ème élément de la liste */
097: public void remove(int i) {
098: this .list.remove(i);
099: }
100:
101: /** Retire une liste de DirectPosititon */
102: public void removeAll(DirectPositionList theList) {
103: this .list.removeAll(theList.getList());
104: }
105:
106: /** Efface toute la liste */
107: public void clear() {
108: this .list.clear();
109: }
110:
111: /** Initialise l'itérateur de la liste. */
112: public void initIterator() {
113: iList = this .list.iterator();
114: }
115:
116: /** Renvoie true s'il reste des éléments avec l'itérateur, false sinon. */
117: public boolean hasNext() {
118: if (iList.hasNext())
119: return true;
120: else
121: return false;
122: }
123:
124: /** Renvoie le prochain element avec l'iterateur. */
125: public DirectPosition next() {
126: return (DirectPosition) iList.next();
127: }
128:
129: /** Renvoie le nombre de éléments */
130: public int size() {
131: return this .list.size();
132: }
133:
134: /** Constructeur par défaut. */
135: public DirectPositionList() {
136: }
137:
138: /** Constructeur à partir d'une liste de DirectPosition. Attention, ne vérifie pas que la liste
139: * passée en paramètre ne contient que des DirectPosition. Ne clone pas la liste
140: * passée en paramètre mais fait une référence. */
141: public DirectPositionList(List theList) {
142: setList(theList);
143: }
144:
145: /** Clone this, atester. */
146: public Object clone() {
147: DirectPositionList result = new DirectPositionList();
148: this .initIterator();
149: while (this .hasNext()) {
150: DirectPosition p = this .next();
151: DirectPosition pp = (DirectPosition) p.clone();
152: result.add(pp);
153: }
154: return result;
155: }
156:
157: /** Renvoie un tableau de double de la forme [X Y X Y ... X Y] */
158: public double[] toArray2D() {
159: double[] array = new double[list.size() * 2];
160: initIterator();
161: int i = 0;
162: while (hasNext()) {
163: DirectPosition p = next();
164: array[i] = p.getX();
165: i++;
166: array[i] = p.getY();
167: i++;
168: }
169: return array;
170: }
171:
172: /** Renvoie un tableau de double de la forme [X Y Z X Y Z ... X Y Z] */
173: public double[] toArray3D() {
174: double[] array = new double[list.size() * 3];
175: initIterator();
176: int i = 0;
177: while (hasNext()) {
178: DirectPosition p = next();
179: array[i] = p.getX();
180: i++;
181: array[i] = p.getY();
182: i++;
183: array[i] = p.getZ();
184: i++;
185: }
186: return array;
187: }
188:
189: /** Renvoie un tableau de double contenant tous les X des DirectPosition de la liste. */
190: public double[] toArrayX() {
191: double[] array = new double[list.size()];
192: initIterator();
193: int i = 0;
194: while (hasNext()) {
195: DirectPosition p = next();
196: array[i] = p.getX();
197: i++;
198: }
199: return array;
200: }
201:
202: /** Renvoie un tableau de double contenant tous les Y des DirectPosition de la liste. */
203: public double[] toArrayY() {
204: double[] array = new double[list.size()];
205: initIterator();
206: int i = 0;
207: while (hasNext()) {
208: DirectPosition p = next();
209: array[i] = p.getY();
210: i++;
211: }
212: return array;
213: }
214:
215: /** Renvoie un tableau de double contenant tous les Z des DirectPosition de la liste. */
216: public double[] toArrayZ() {
217: double[] array = new double[list.size()];
218: initIterator();
219: int i = 0;
220: while (hasNext()) {
221: DirectPosition p = next();
222: array[i] = p.getZ();
223: i++;
224: }
225: return array;
226: }
227:
228: /** Affiche les coordonnées des point (2D et 3D). */
229: public String toString() {
230: String result = new String();
231: if (size() == 0) {
232: result = "DirectPositionList : liste vide";
233: return result;
234: }
235: for (int i = 0; i < size(); i++)
236: result = result + get(i).toString() + "\n";
237: return result.substring(0, result.length() - 1); // on enleve le dernier "\n"
238: }
239:
240: }
|