testgeomcurve.java

用于GIS(全球地理系统)的分析和处理的代码。

        Integer gid;
        GM_Curve curve;
        GM_OrientableCurve oriCurve;
        GM_CurveBoundary curveBdy;

        System.out.println("#### test boundary");
        
        // Debut d'une transaction
        System.out.println("Debut transaction");
        db.begin();
                
        // On charge un FT_Feature et sa geometrie
        gid = new Integer(identifiant1);
        tron = (FT_Feature)db.load(tronconClass,gid);
        System.out.println("identifiant de l'objet charge : "+tron.getId());
        curve = (GM_Curve)tron.getGeom();
                
        // Frontiere de la courbe en passant par GM_CurveBoundary
        // l'operation "boundary" recupere un GM_CurveBoundary
        // l'operation getEndPoint() et getStartPoint() recupere des GM_Point.
        // Donc : on connait le CRS
        curveBdy = curve.boundary();
        System.out.println("start point  : "+curveBdy.getStartPoint());
        System.out.println("end point  : "+curveBdy.getEndPoint());  
        System.out.println("CRS du end point : "+curveBdy.getEndPoint().getCRS());
        
        // Frontiere de la courbe en passant par startPoint() et endPoint()
        // on recupere des DirectPosition
        // Il n'y a pas de CRS a priori
        System.out.println("start point  : "+curve.startPoint());
        System.out.println("end point  : "+curve.endPoint());
                
        // Une petite experience...
        // On change la valeur de la coordonnees Y du premier point de la courbe
        double oldY = ((GM_LineString)curve.getSegment(0)).getControlPoint(0).getY();
        ((GM_LineString)curve.getSegment(0)).getControlPoint(0).setY(100000.0);
        // On regarde
        System.out.println("nouveau start point(Y)  : "+curveBdy.getStartPoint().getPosition().getY()); // ca n'a pas change
        System.out.println("nouveau start point(Y)  : "+curve.startPoint().getY()); // ici, ca a change
        // Pourquoi ? avec startPoint() on accede directement aux coordonnees, 
        // alors qu'avec "boundary" on a cree des nouveaux points "independants" des coordonnees de la courbe.
        // Il faut donc rappeler la methode "boundary" pour repercuter le changement de coordonnees.
        curveBdy = curve.boundary();
        System.out.println("nouveau start point(Y)  : "+curveBdy.getStartPoint().getPosition().getY()); // OK maintenant
        
        // on reaffecte l'ancienne valeur ...        
        ((GM_LineString)curve.getSegment(0)).getControlPoint(0).setY(oldY);                
                
        // Rejouons avec les courbes orientees
        oriCurve = curve.getNegative();
        // la methode "boundary()" s'applique sur GM_OrientableCurve (et donc aussi sur GM_Curve)
        curveBdy = oriCurve.boundary();
        System.out.println("start point  : "+curveBdy.getStartPoint());
        System.out.println("end point  : "+curveBdy.getEndPoint());  
        // startPoint() et endPoint() ne marche que sur GM_Curve (et pas GM_OrientableCurve) -> on passe par la primitive
        curve = oriCurve.getPrimitive();
        System.out.println("start point  : "+curve.startPoint());
        System.out.println("end point  : "+curve.endPoint());                
        
        // Commit
        System.out.println("Commit");    
        db.commit();
  
    }
    
    
  
    /* Amusons nous avec les composite curves */
    public void testComposite ()  {
           
        // Declaration des variables
        FT_Feature tron;
        Integer gid;
        GM_Curve curve;
        GM_Primitive prim;
        GM_OrientableCurve oriCurve;
        GM_CompositeCurve compCurve;
        GM_CurveBoundary curveBdy;
        
        System.out.println("#### test composite");        
        
        // on recupere la tolerance dans les metadonnees d'Oracle
        // rigoureusement ici, on recupere la tolerance sur les X, on suppose que c'est la meme sur les Y
        double tolerance = db.getMetadata(tronconClass).getTolerance(0);
        System.out.println("tolerance : "+tolerance);
                
        // Debut d'une transaction
        System.out.println("Debut transaction");
        db.begin();
                
        // On charge un FT_Feature et sa geometrie
        gid = new Integer(identifiant1);
        tron = (FT_Feature)db.load(tronconClass,gid);
        System.out.println("identifiant de l'objet charge : "+tron.getId());
        curve = (GM_Curve)tron.getGeom();
        System.out.println(curve);
                
        // On cree une composite curve a partir d'une courbe orientee (positivement ou negativement)
        //compCurve = new GM_CompositeCurve(curve.getNegative());
        compCurve = new GM_CompositeCurve(curve);
                
        // On charge un FT_Feature et sa geometrie
        gid = new Integer(identifiant2);
        tron = (FT_Feature)db.load(tronconClass,gid);
        System.out.println("identifiant de l'objet charge : "+tron.getId());
        curve = (GM_Curve)tron.getGeom();
        System.out.println(curve);
        
        // On ajoute un element a la composite curve
        //compCurve.appendGenerator(curve);             //  sans filet (pas de parametre "tolerance")
        //compCurve.appendGenerator(curve,tolerance);     // avec verification du chainage, mais sans retourner la courbe  
        // essayer en rompant le chainage pour voir.
        
        // proprement, il faut faire comme ceci :
        // si ca chaine, on ajoute, sinon on ajoute l'oppose, 
        // sinon affiche un message et on continue sans avoir rien fait en affichant une exception
        try {
            compCurve.addGeneratorTry(curve,tolerance); 
        } catch (Exception e1) {
                System.out.println(e1.getMessage());
        }
                
        // On charge un FT_Feature et sa geometrie
        gid = new Integer(identifiant3);
        tron = (FT_Feature)db.load(tronconClass,gid);
        System.out.println("identifiant de l'objet charge : "+tron.getId());
        curve = (GM_Curve)tron.getGeom();
        System.out.println(curve);
                
        // On ajoute encore
        try {
            compCurve.addGeneratorTry(curve,tolerance); 
        } catch (Exception e1) {
                System.out.println(e1.getMessage());
        }
                
        // On charge un FT_Feature et sa geometrie
        gid = new Integer(identifiant4);
        tron = (FT_Feature)db.load(tronconClass,gid);
        System.out.println("identifiant de l'objet charge : "+tron.getId());
        curve = (GM_Curve)tron.getGeom();
        System.out.println(curve);
        
        
        // On ajoute encore
        try {
            compCurve.addGeneratorTry(curve,tolerance); 
        } catch (Exception e1) {
                System.out.println(e1.getMessage());
        }
           
        // Verifions que le chainage est OK
        System.out.println("validate : "+compCurve.validate(tolerance));
                
        // Examinons la frontiere
        curveBdy = compCurve.boundary();
        System.out.println("start point  : "+curveBdy.getStartPoint());
        System.out.println("end point  : "+curveBdy.getEndPoint());
                
        // Examinons la primitive
        System.out.println("nombre de composants de la composite curve : "+compCurve.sizeGenerator());
        curve = compCurve.getPrimitive();
        System.out.println("hash code de la primitive : "+curve.hashCode());
        System.out.println(curve);
        // on observe qu'il y a des doublon : la courbe est en fait constituee de plusieurs segments 
        //(corresondant aux courbes initiales)
        System.out.println("nombre de segments de la primitive : "+curve.sizeSegment());
        // pour eliminer les doublons : caster en une seule linestring
        GM_LineString theLinestring = curve.asLineString(0.0,0.0,tolerance);
        System.out.println("linestring : ");
        System.out.println(theLinestring);
                        
        // Examinons les courbe orientees  a partir de compCurve
        oriCurve = compCurve.getPositive();
        System.out.println("hash code de la courbe orientee positivement : "+oriCurve.hashCode());  // meme chose que la primitive
        oriCurve = compCurve.getNegative();
        System.out.println("hash code de la courbe orientee negativement : "+oriCurve.hashCode());  // nouvel objet
        System.out.println(oriCurve.getPrimitive()); // courbe renversee par rapport a plus haut
        
        // Utilisons GM_Ring(anneau)
        // constructeur a partir d'une compCurve - sans filet
        // GM_Ring ring = new GM_Ring(compCurve); 
        
        // constructeur a partir d'une compCurve - avec verification du chainage et de la fermeture
        try {
            GM_Ring ring = new GM_Ring(compCurve, tolerance);
            System.out.println("validate ring :"+ring.validate(tolerance));
        } catch (Exception e) {System.out.println(e.getMessage());}
                    
        // Commit
        System.out.println("Commit");
        db.commit();
    }
    
}