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.geomroot;
028:
029: import java.awt.Color;
030:
031: import fr.ign.cogit.geoxygene.datatools.Geodatabase; //import fr.ign.cogit.geoxygene.datatools.oracle.OracleAlgorithms;
032: import fr.ign.cogit.geoxygene.spatial.coordgeom.DirectPosition;
033: import fr.ign.cogit.geoxygene.spatial.coordgeom.DirectPositionList;
034: import fr.ign.cogit.geoxygene.spatial.coordgeom.GM_Envelope;
035: import fr.ign.cogit.geoxygene.spatial.coordgeom.GM_Polygon;
036: import fr.ign.cogit.geoxygene.util.algo.JtsAlgorithms;
037: import fr.ign.cogit.geoxygene.util.conversion.ImgUtil;
038: import fr.ign.cogit.geoxygene.util.conversion.WktGeOxygene;
039:
040: /**
041: * Classe mère abstraite pour la géométrie, selon la norme OGC Topic 1 / ISO 19107.
042: * Cette classe définit les opérations communes aux différents objets géométriques qui en héritent.
043: * Toutes les opérations doivent se faire dans le même système de coordonnées.
044: * Un objet géométrique est en fait une combinaison d'un système de référence de coordonnées (CRS),
045: * et d'une géométrie munie de coordonnées (CoordGeom).
046: *
047: * <BR> Les methodes geometriques font par defaut appel a la bibliotheque JTS (jts.jar, version 1.4),
048: * via des appels aux methodes de la classe util.algo.JtsAlgorithms. Attention, bien souvent, ces méthodes
049: * ne fonctionnent que sur des primitives ou des agrégats homogènes (GM_MultiTruc).
050: * http://www.vividsolutions.com/jts/jtshome.htm
051: *
052: * <BR> Historiquememt, les methodes faisaient appel aux fonctions geometriques d'Oracle
053: * et a la bibliotheque fournie par Oracle sdoapi.zip,
054: * via des appels aux methodes de la classe util.algo.OracleAlgorithms,
055: * qui elles-memes appellent des methodes datatools.oracle.SpatialQuery.
056: * Ces methodes ont ete gardees et portent le suffixe "Oracle".
057: * Pour les appeler, il est nécessaire d'établir une connection à Oracle,
058: * c'est pourquoi on passe une "Geodatabase" en paramètre de chaque fonction.
059: * On suppose qu'il existe dans la base, dans le schéma utilisateur,
060: * une table TEMP_REQUETE, avec une colonne GID (NUMBER) et une colonne GEOM (SDO_GEOMETRY).
061: * Cette table est dédiée aux requêtes spatiales.
062: * De même, le paramètre tolérance est exigé par Oracle.
063: *
064: * ARNAUD 12 juillet 2005 : mise en commentaire de ce qui se rapporte à Oracle
065: * pour isoler la compilation. A décommenter pour utiliser Oracle.
066: *
067: * @author Thierry Badard & Arnaud Braun
068: * @version 1.2
069: *
070: * 19.02.2007 : ajout de la méthode intersectsStrictement
071: *
072: */
073:
074: abstract public class GM_Object implements Cloneable {
075:
076: /////////////////////////////////////////////////////////////////////////////////////////////////////
077: // Attributs et accesseurs //////////////////////////////////////////////////////////////////////////
078: /////////////////////////////////////////////////////////////////////////////////////////////////////
079: /** Identifiant de l'objet géométrique, dans la table du SGBD.
080: * Cet identifiant n'est pas spécifié dans la norme ISO.
081: * Non utilise a ce jour. */
082: // protected int GM_ObjectID;
083: /** Renvoie l'identifiant géométrique.*/
084: // public int getGM_ObjectID() { return this.GM_ObjectID; }
085: /** Affecte un identifiant. */
086: // public void setGM_ObjectID(int geomID) { this.GM_ObjectID = geomID; }
087: /** FT_Feature auquel est rattaché cette géométrie.
088: * Cette association n'est pas dans la norme.
089: * A prevoir : faire une liste pour gérer les partages de géométrie. */
090: // protected FT_Feature feature;
091: /** Renvoie le FT_Feature auquel est rattaché cette géométrie. */
092: // public FT_Feature getFeature() { return this.feature; }
093: /** Affecte un FT_Feature. */
094: // public void setFeature(FT_Feature Feature) { this.feature = Feature;}
095: /** Identifiant du système de coordonnées de référence (CRS en anglais).
096: * Par défaut, vaut 41014 : identifiant du Lambert II carto.
097: * Dans la norme ISO, cet attribut est une relation qui pointe vers la classe SC_CRS (non implémentée) */
098: protected int CRS = 41014;
099:
100: /** Renvoie l' identifiant du système de coordonnées de référence. */
101: public int getCRS() {
102: return this .CRS;
103: }
104:
105: /** Affecte une valeur au système de coordonnées de référence. */
106: public void setCRS(int crs) {
107: CRS = crs;
108: }
109:
110: /////////////////////////////////////////////////////////////////////////////////////////////////////
111: // Méthodes de la norme non implementees (souvent liees a l'utilisation de GM_Conplex) //////////////
112: /////////////////////////////////////////////////////////////////////////////////////////////////////
113: /** Collection de GM_Object représentant la frontière de self.
114: * Cette collection d'objets a une structure de GM_Boundary, qui est un sous-type de GM_Complex. */
115: // en commentaire car oblige a typer toute les méthodes boundary() des sous-classes en GM_Boundary : pénible à l'utilisation
116: //abstract public GM_Boundary boundary() ;
117: /** Union de l'objet et de sa frontière.
118: * Si l'objet est dans un GM_Complex, alors la frontière du GM_Complex retourné doit être dans le même complexe ;
119: * Si l'objet n'est pas dans un GM_Complex, alors sa frontière doit être construite en réponse à cette opération. */
120: //public GM_Complex closure() {
121: //}
122: /** Set de complexes maximaux auxquels apppartient l'objet. */
123: //public GM_Complex[] maximalComplex() {
124: //}
125: /** Renvoie TRUE si la frontière est vide. */
126: //public boolean isCycle() {
127: //}
128: /** Dimension du système de coordonnées (1D, 2D ou 3D). */
129: //public int coordinateDimension() {
130: //}
131:
132: /////////////////////////////////////////////////////////////////////////////////////////////////////
133: // diverses methodes utiles /////////////////////////////////////////////////////////////////////////
134: /////////////////////////////////////////////////////////////////////////////////////////////////////
135: /** Renvoie la liste des DirectPosition de l'objet.
136: Méthode abstraite redéfinie dans les sous-classes.
137: Cette méthode se comporte différemment selon le type d'objet géométrique. */
138: abstract public DirectPositionList coord();
139:
140: /** Clone l'objet. */
141: public Object clone() {
142: try {
143: return super .clone();
144: } catch (Exception e) {
145: e.printStackTrace();
146: return null;
147: }
148: }
149:
150: /** Ecrit la géométrie dans une chaine de caractere au format WKT. */
151: public String toString() {
152: try {
153: return WktGeOxygene.makeWkt(this );
154: } catch (Exception e) {
155: e.printStackTrace();
156: return "## ToSring() D'UN GM_OBJECT : PROBLEME ##";
157: }
158: }
159:
160: /** Exporte la géométrie dans un fichier texte au format WKT.
161: * Si append = false, un nouveau fichier est systematiquement cree.
162: * Si append = true, et que le fichier existe deja, la geometrie est ajoutee a la fin du fichier;
163: * si le fichier n'existe pas, il est cree. */
164: public void exportWkt(String path, boolean append) {
165: try {
166: WktGeOxygene.writeWkt(path, append, this );
167: } catch (Exception e) {
168: System.out
169: .println("## EXPORT WKT D'UN GM_OBJECT : PROBLEME ##");
170: e.printStackTrace();
171: }
172: }
173:
174: /** Exporte des géométries dans une image.
175: * Le format de l'image (.jpg ou .png par defaut) est determiné par l'extension du nom de fichier,
176: * a mettre dans le parametre "path".
177: * Le tableau de couleur permet d'affecter des couleurs différentes aux géométries.
178: * <BR> Exemple : GM_Object.exportImage(new GM_Object[] {geom1, geom2},"/home/users/truc/essai.jpg",
179: * new Color[] {Color.RED, Color.BLUE}, Color.WHITE, 150, 80) */
180: public static void exportImage(GM_Object[] geoms, String path,
181: Color foreground[], Color background, int width, int height) {
182: try {
183: ImgUtil.saveImage(geoms, path, foreground, background,
184: width, height);
185: } catch (Exception e) {
186: System.out
187: .println("## EXPORT IMAGE D'UN GM_OBJECT : PROBLEME ##");
188: e.printStackTrace();
189: }
190: }
191:
192: /** Exporte des géométries dans un fichier SVG compressé.
193: * Donner dans la variable "path" le chemin et le nom du fichier (avec l'extension .svgz)
194: * Le tableau de couleur permet d'affecter des couleurs différentes aux géométries.
195: * <BR> Exemple : GM_Object.exportSvgz(new GM_Object[] {geom1, geom2},"/home/users/truc/essai.jpg",
196: * new Color[] {Color.RED, Color.BLUE}, Color.WHITE, 150, 80) */
197: public static void exportSvgz(GM_Object[] geoms, String path,
198: Color foreground[], Color background, int width, int height) {
199: try {
200: ImgUtil.saveSvgz(geoms, path, foreground, background,
201: width, height);
202: } catch (Exception e) {
203: System.out
204: .println("## EXPORT SVG D'UN GM_OBJECT : PROBLEME ##");
205: e.printStackTrace();
206: }
207: }
208:
209: /////////////////////////////////////////////////////////////////////////////////////////////////////
210: // methodes geometriques directement codees /////////////////////////////////////////////////////////
211: /////////////////////////////////////////////////////////////////////////////////////////////////////
212: /** Rectangle englobant minimum de l'objet (en 2D) sous forme de GM_Envelope. */
213: public GM_Envelope envelope() {
214: DirectPositionList list = coord();
215: DirectPosition point = list.get(0);
216: double xmin = point.getX();
217: double xmax = point.getX();
218: double ymin = point.getY();
219: double ymax = point.getY();
220: list.initIterator();
221: while (list.hasNext()) {
222: point = list.next();
223: double x = point.getX();
224: double y = point.getY();
225: if (x > xmax)
226: xmax = x;
227: if (x < xmin)
228: xmin = x;
229: if (y < ymin)
230: ymin = y;
231: if (y > ymax)
232: ymax = y;
233: }
234: return new GM_Envelope(xmin, xmax, ymin, ymax);
235: }
236:
237: /** Rectangle englobant minimum de l'objet (en 2D) sous forme de GM_Polygon.
238: * Le but est d'obtenir une region contenant l'objet.
239: * Tout autre implémentation serait possible : le but serait de supporter des méthodes d'indexation
240: * qui n'utilisent pas les rectangles minimaux englobants. */
241: public GM_Polygon mbRegion(Geodatabase data) {
242: return new GM_Polygon(this .envelope());
243: }
244:
245: /**Teste l'intersection stricte entre la géométrie manipulée et celle passée en
246: * paramètre, i.e. l'intersection sans les cas où les géométries sont simplement
247: * adjacentes (intersection = point ou ligne) ou sont contenues l'une dans
248: * dans l'autre
249: * @param GM_Object geom
250: * @return boolean
251: */
252: public boolean intersectsStrictement(GM_Object geom) {
253: return (this .intersects(geom) && !this .contains(geom)
254: && !geom.contains(this ) && !this .touches(geom));
255: }
256:
257: /////////////////////////////////////////////////////////////////////////////////////////////////////
258: // methodes geometriques et topologiques faisant appel a JTS ////////////////////////////////////////
259: /////////////////////////////////////////////////////////////////////////////////////////////////////
260: /** Centre de gravité de l'objet (avec JTS). Le résultat n'est pas nécessairement dans l'objet. */
261: public GM_Object centroid() {
262: return new JtsAlgorithms().centroid(this );
263: }
264:
265: /** Enveloppe convexe de l'objet (avec JTS). */
266: public GM_Object convexHull() {
267: return new JtsAlgorithms().convexHull(this );
268: }
269:
270: /** Calcule de buffer sur l'objet (avec JTS).
271: * Les distances negatives sont acceptees (pour faire une érosion). */
272: public GM_Object buffer(double distance) {
273: return new JtsAlgorithms().buffer(this , distance);
274: }
275:
276: /** Calcule de buffer sur l'objet (avec JTS) en indiquant le nombre de segments approximant la partie courbe.
277: * Les distances negatives sont acceptees (pour faire une érosion). */
278: public GM_Object buffer(double distance, int nSegments) {
279: return new JtsAlgorithms().buffer(this , distance, nSegments);
280: }
281:
282: /** Union avec l'objet passé en paramètre (avec JTS).
283: * Renvoie éventuellement un aggrégat si les objets sont disjoints. */
284: public GM_Object union(GM_Object geom) {
285: return new JtsAlgorithms().union(this , geom);
286: }
287:
288: /** Intersection avec l'objet passé en paramètre (avec JTS).
289: * Renvoie un GM_Aggregate vide si les objets sont disjoints. */
290: public GM_Object intersection(GM_Object geom) {
291: return new JtsAlgorithms().intersection(this , geom);
292: }
293:
294: /** Différence avec l'objet passé en paramètre (avec JTS).
295: * Returns a Geometry representing the points making up this Geometry that do not make up "geom".*/
296: public GM_Object difference(GM_Object geom) {
297: return new JtsAlgorithms().difference(this , geom);
298: }
299:
300: /** Différence symétrique avec l'objet passé en paramètre (avec JTS).
301: * La différence symétrique (opérateur booléan XOR) est la différence de l'union avec l'intersection.
302: * Returns a set combining the points in this Geometry not in other, and the points in other not in this Geometry.*/
303: public GM_Object symmetricDifference(GM_Object geom) {
304: return new JtsAlgorithms().symDifference(this , geom);
305: }
306:
307: /** Predicat topologique sur la relation d'egalite (!= equalsExact) (avec JTS).
308: * Returns true if the DE-9IM intersection matrix for the two Geometrys is T*F**FFF*.*/
309: public boolean equals(GM_Object geom) {
310: return new JtsAlgorithms().equals(this , geom);
311: }
312:
313: /** This et l'objet passe en parametre appartiennent a la meme classe et ont exactement les memes coordonnees (avec JTS) */
314: public boolean equalsExact(GM_Object geom) {
315: return new JtsAlgorithms().equalsExact(this , geom);
316: }
317:
318: /** This et l'objet passe en parametre appartiennent a la meme classe et ont les memes coordonnees à une tolérance près (avec JTS) */
319: public boolean equalsExact(GM_Object geom, double tolerance) {
320: return new JtsAlgorithms().equalsExact(this , geom, tolerance);
321: }
322:
323: /** Predicat topologique sur la relation de contenance (avec JTS).
324: * Returns true if geom.within(this) returns true.*/
325: public boolean contains(GM_Object geom) {
326: return new JtsAlgorithms().contains(this , geom);
327: }
328:
329: /** Predicat topologique crosses (avec JTS).
330: * Returns true if the DE-9IM intersection matrix for the two Geometrys is T*T******
331: * (for a point and a curve, a point and an area or a line and an area),
332: * 0******** (for two curves) .*/
333: public boolean crosses(GM_Object geom) {
334: return new JtsAlgorithms().crosses(this , geom);
335: }
336:
337: /** Predicat topologique sur la relation de disjonction (avec JTS).
338: * Returns true if the DE-9IM intersection matrix for the two Geometrys is FF*FF****. */
339: public boolean disjoint(GM_Object geom) {
340: return new JtsAlgorithms().disjoint(this , geom);
341: }
342:
343: /** Predicat topologique sur la relation d'interieur (avec JTS).
344: * Returns true if the DE-9IM intersection matrix for the two Geometrys is T*F**F***. */
345: public boolean within(GM_Object geom) {
346: return new JtsAlgorithms().within(this , geom);
347: }
348:
349: /** Teste si la distance entre cette géométrie et geom est inférieure à la distance passée en paramètre. */
350: public boolean isWithinDistance(GM_Object geom, double distance) {
351: return new JtsAlgorithms().isWithinDistance(this , geom,
352: distance);
353: }
354:
355: /** Predicat topologique sur la relation d'intersection (avec JTS).
356: * Returns true if disjoint returns false. */
357: public boolean intersects(GM_Object geom) {
358: return new JtsAlgorithms().intersects(this , geom);
359: }
360:
361: /** Predicat topologique sur la relation de recouvrement (avec JTS).
362: * Returns true if the DE-9IM intersection matrix for the two Geometrys is T*T***T**
363: * (for two points or two surfaces), or 1*T***T** (for two curves) . */
364: public boolean overlaps(GM_Object geom) {
365: return new JtsAlgorithms().overlaps(this , geom);
366: }
367:
368: /** Predicat topologique sur la relation de contact (avec JTS).
369: * Returns true if the DE-9IM intersection matrix for the two Geometrys
370: * is FT*******, F**T***** or F***T****.*/
371: public boolean touches(GM_Object geom) {
372: return new JtsAlgorithms().touches(this , geom);
373: }
374:
375: /** Renvoie true si la geometrie est vide (avec JTS). */
376: public boolean isEmpty() {
377: return new JtsAlgorithms().isEmpty(this );
378: }
379:
380: /** Renvoie TRUE si l'objet n'a pas de point d'auto-intersection ou d'auto-tangence (avec JTS).
381: * Cette opération n'est pas applicable aux objets fermés (ceux pour lesquels isCycle() = TRUE). */
382: public boolean isSimple() {
383: return new JtsAlgorithms().isSimple(this );
384: }
385:
386: /** Renvoie TRUE si la geometrie est valide au sens JTS. Utile pour debugger. */
387: public boolean isValid() {
388: return new JtsAlgorithms().isValid(this );
389: }
390:
391: /** Distance entre this et l'objet passe en parametre (avec JTS).
392: * Returns the minimum distance between this Geometry and the Geometry geom. */
393: public double distance(GM_Object geom) {
394: return new JtsAlgorithms().distance(this , geom);
395: }
396:
397: /** Aire de l'objet (avec JTS) */
398: public double area() {
399: return new JtsAlgorithms().area(this );
400: }
401:
402: /** Longueur de l'objet (avec JTS) */
403: public double length() {
404: return new JtsAlgorithms().length(this );
405: }
406:
407: /** Dimension maximale de l'objet (point 0, courbe 1, surface 2) (avec JTS). */
408: public int dimension() {
409: return new JtsAlgorithms().dimension(this );
410: }
411:
412: /** Nombre de points de l'objet (avec JTS). */
413: public int numPoints() {
414: return new JtsAlgorithms().numPoints(this );
415: }
416:
417: /** Translation de l'objet (avec JTS). */
418: public GM_Object translate(final double tx, final double ty,
419: final double tz) {
420: return new JtsAlgorithms().translate(this , tx, ty, tz);
421: }
422:
423: /** Returns the DE-9IM intersection matrix for the two Geometrys. */
424: public String relate(GM_Object geom) {
425: return new JtsAlgorithms().relate(this , geom);
426: }
427:
428: /////////////////////////////////////////////////////////////////////////////////////////////////////
429: // methodes geometriques et topologiques faisant appel a Oracle /////////////////////////////////////
430: /////////////////////////////////////////////////////////////////////////////////////////////////////
431: /** Calcul de buffer optimisé sous Oracle, pour les agrégats.
432: * Cette methode semble meilleure en performance que "bufferOracle"
433: * pour calculer les buffer et les fusionner,
434: * si le GM_Object est un agrégat contenant beaucoup d'objets.
435: * Le GM_Object doit etre un GM_Aggregate ou une sous classe, sinon plantage.
436: * @param data Paramètres de connection à la base de données.
437: * @param tolerance Tolérance pour le calcul.
438: * @param radius Distance pour calculer le buffer. */
439: /* public GM_Object bufferAgregatOracle(Geodatabase data, double tolerance, double radius) {
440: return new OracleAlgorithms(data,tolerance).bufferAgregat(this,radius);
441: }
442: */
443: /** Calcule le buffer de self (avec Oracle). La distance doit être positive.
444: * @param data Paramètres de connection à la base de données.
445: * @param tolerance Tolérance pour le calcul.
446: * @param radius Distance pour calculer le buffer. */
447: /* public GM_Object bufferOracle (Geodatabase data, double tolerance, double radius) {
448: return new OracleAlgorithms(data,tolerance).buffer(this,radius);
449: }
450: */
451: /** Enveloppe convexe de self (avec Oracle). Renvoie NULL si self est un point, ou est défini avec moins de trois points.
452: * Le résultat est un GM_Polygon.
453: * @param data Paramètres de connection à la base de données.
454: * @param tolerance Tolérance pour le calcul. */
455: /* public GM_Object convexHullOracle (Geodatabase data, double tolerance) {
456: return new OracleAlgorithms(data,tolerance).convexHull(this);
457: }
458: */
459: /** Centre de gravité de self (avec Oracle). Le résultat n'est pas nécessairement dans l'objet.
460: * Pour un objet multi-dimensions, on ne prendra en compte que la plus grande dimension pour le calcul.
461: * ATTENTION implementé uniquement pour un polygone. Sinon renvoie NULL.
462: * @param data Paramètres de connection à la base de données.
463: * @param tolerance Tolérance pour le calcul. */
464: /* public GM_Object centroidOracle (Geodatabase data, double tolerance) {
465: return new OracleAlgorithms(data,tolerance).centroid(this);
466: }
467: */
468: /** Un point représentatif à l'intérieur de self (avec Oracle). Ce point peut être n'importe où.
469: * Deux appels différents à cette méthode sur un objet peuvent produire deux résultats différents.
470: * On garantit juste que le point est à l'intérieur.
471: * ATTENTION : implémenté uniquement pour un polygone, sinon renvoie NULL.
472: * Une utilisation peut être le placement de labels pour une présentation graphique.
473: * REMARQUE : dans la norme, on impose que ce point soit le centroide s'il est à l'intérieur, un autre point sinon.
474: * @param data Paramètres de connection à la base de données.
475: * @param tolerance Tolérance pour le calcul. */
476: /* public DirectPosition representativePointOracle (Geodatabase data, double tolerance) {
477: return new OracleAlgorithms(data,tolerance).representativePoint(this);
478: }
479: */
480: /** Rectangle englobant minimum de self (avec Oracle).
481: * @param data Paramètres de connection à la base de données. */
482: /* public GM_Envelope envelopeOracle (Geodatabase data) {
483: return new OracleAlgorithms(data,0.).envelope(this);
484: }
485: */
486: /** Différence de self avec l'objet passé en paramètre (avec Oracle).
487: * @param data Paramètres de connection à la base de données.
488: * @param tolerance Tolérance pour le calcul.
489: * @param g Objet géométrique avec lequel on va réaliser l'opération. */
490: /* public GM_Object differenceOracle (Geodatabase data, double tolerance, GM_Object g) {
491: return new OracleAlgorithms(data,tolerance).difference(this,g);
492: }
493: */
494: /** Intersection de self avec l'objet passé en paramètre (avec Oracle).
495: * Renvoie NULL si les objets sont disjoints.
496: * @param data Paramètres de connection à la base de données.
497: * @param tolerance Tolérance pour le calcul.
498: * @param g Objet géométrique avec lequel on va réaliser l'opération. */
499: /* public GM_Object intersectionOracle (Geodatabase data, double tolerance, GM_Object g) {
500: return new OracleAlgorithms(data,tolerance).intersection(this,g);
501: }
502: */
503: /** Union de self et de l'objet passé en paramètre (avec Oracle).
504: * Renvoie éventuellement un aggrégat si les objets sont disjoints.
505: * @param data Paramètres de connection à la base de données.
506: * @param tolerance Tolérance pour le calcul.
507: * @param g Objet géométrique avec lequel on va réaliser l'union. */
508: /* public GM_Object unionOracle (Geodatabase data, double tolerance, GM_Object g) {
509: return new OracleAlgorithms(data,tolerance).union(this,g);
510: }
511: */
512: /** Différence symétrique de self avec l'objet passé en paramètre (avec Oracle).
513: * La différence symétrique (opérateur booléan XOR) est la différence de l'union avec l'intersection.
514: * @param data Paramètres de connection à la base de données.
515: * @param tolerance Tolérance pour le calcul.
516: * @param g Objet géométrique avec lequel on va réaliser l'opération. */
517: /* public GM_Object symmetricDifferenceOracle (Geodatabase data, double tolerance, GM_Object g) {
518: return new OracleAlgorithms(data,tolerance).symDifference(this,g);
519: }
520: */
521: /** Teste si self contient l'objet passé en paramètre (avec Oracle).
522: * REMARQUE : les frontières ne doivent pas se toucher, sinon renvoie false - A TESTER.
523: * @param data Paramètres de connection à la base de données.
524: * @param tolerance Tolérance pour le calcul.
525: * @param g GM_Object avec lequel on teste l'intersection */
526: /* public boolean containsOracle (Geodatabase data, double tolerance, GM_Object g) {
527: return new OracleAlgorithms(data,tolerance).contains(this,g);
528: }
529: */
530: /** Teste si self contient le DirectPosition passé en paramètre (avec Oracle).
531: * @param data Paramètres de connection à la base de données.
532: * @param tolerance Tolérance pour le calcul.
533: * @param P DirectPosition avec lequel on teste l'intersection. */
534: /* public boolean containsOracle (Geodatabase data, double tolerance, DirectPosition P) {
535: return new OracleAlgorithms(data,tolerance).contains(this,P);
536: }
537: */
538: /** Teste si self intersecte l'objet géométrique passé en paramètre (avec Oracle). Renvoie un boolean.
539: * REMARQUE : si les 2 objets n'ont que la frontière en commun, alors renvoie false - A TESTER.
540: * CAS des COMPLEXES : a revoir (cf.norme)
541: * @param data Paramètres de connection à la base de données.
542: * @param tolerance Tolérance pour le calcul.
543: * @param g GM_Object avec lequel on teste l'intersection. */
544: /* public boolean intersectsOracle (Geodatabase data, double tolerance, GM_Object g) {
545: return new OracleAlgorithms(data,tolerance).intersects(this,g);
546: }
547: */
548: /** Teste si self et l'objet passé en paramètre sont géométriquement égaux (avec Oracle).
549: * @param data Paramètres de connection à la base de données.
550: * @param tolerance Tolérance pour le calcul.
551: * @param g GM_Object avec lequel on teste l'intersection. */
552: /* public boolean equalsOracle (Geodatabase data, double tolerance, GM_Object g) {
553: return new OracleAlgorithms(data,tolerance).equals(this,g);
554: }
555: */
556: /** Renvoie TRUE si self n'a pas de point d'auto-intersection ou d'auto-tangence (avec Oracle SDOAPI).
557: * Cette opération n'est pas applicable aux objets fermés (ceux pour lesquels isCycle() = TRUE).
558: * @param data Paramètres de connection à la base de données. */
559: /* public boolean isSimpleOracle(Geodatabase data) {
560: return new OracleAlgorithms(data,0.).isSimple(this);
561: }
562: */
563: /** Distance de self à l'objet passé en paramètre (avec Oracle).
564: * Cette distance est définie comme la distance euclidienne.
565: * Si les objets se recouvrent ou se touchent, la distance doit être nulle (pas de distance négative).
566: * @param data Paramètres de connection à la base de données.
567: * @param tolerance Tolérance pour le calcul.
568: * @param g GM_Object avec lequel on teste l'intersection. */
569: /* public double distanceOracle (Geodatabase data, double tolerance, GM_Object g) {
570: return new OracleAlgorithms(data,0.).distance(this,g);
571: }
572: */
573: /** Longueur de l'objet, si c'est une primitive linéaire (avec Oracle).
574: * Applicable sur GM_Curve et GM_MultiCurve.
575: * @param data Paramètres de connection à la base de données. */
576: /* public double lengthOracle (Geodatabase data) {
577: return new OracleAlgorithms(data,0.).length(this);
578: }
579: */
580: /** Surface de l'objet, si c'est une primitive surfacique (avec Oracle).
581: * Applicable sur GM_Surface et GM_MultiSurface.
582: * @param data Paramètres de connection à la base de données. */
583: /* public double areaOracle (Geodatabase data) {
584: return new OracleAlgorithms(data,0.).area(this);
585: }
586: */
587:
588: }
|