[Fudaa-svn-commit] SF.net SVN: fudaa:[4261] branches/FudaaModeleur_TC1Bis/fudaa_devel

[<emm...@us...>]

Revision: 4261
          http://fudaa.svn.sourceforge.net/fudaa/?rev=4261&view=rev
Author:   emmanuel_martin
Date:     2008-12-03 11:49:10 +0000 (Wed, 03 Dec 2008)

Log Message:
-----------
Tache #118 : "Rendre rectiligne une polyligne"

Modified Paths:
--------------
    branches/FudaaModeleur_TC1Bis/fudaa_devel/ebli/src/org/fudaa/ebli/geometrie/GrSegment.java
    branches/FudaaModeleur_TC1Bis/fudaa_devel/fudaa/src/org/fudaa/fudaa/modeleur/MdlEditionManager.java
    branches/FudaaModeleur_TC1Bis/fudaa_devel/fudaa/src/org/fudaa/fudaa/modeleur/MdlSceneEditor.java

Added Paths:
-----------
    branches/FudaaModeleur_TC1Bis/fudaa_devel/fudaa/src/org/fudaa/fudaa/modeleur/action/SceneLinearisePolyligne.java

Modified: branches/FudaaModeleur_TC1Bis/fudaa_devel/ebli/src/org/fudaa/ebli/geometrie/GrSegment.java
===================================================================
--- branches/FudaaModeleur_TC1Bis/fudaa_devel/ebli/src/org/fudaa/ebli/geometrie/GrSegment.java	2008-12-02 15:14:53 UTC (rev 4260)
+++ branches/FudaaModeleur_TC1Bis/fudaa_devel/ebli/src/org/fudaa/ebli/geometrie/GrSegment.java	2008-12-03 11:49:10 UTC (rev 4261)
@@ -11,6 +11,8 @@
 
 import org.fudaa.ctulu.CtuluLibGeometrie;
 
+import com.vividsolutions.jts.geom.Coordinate;
+
 /**
  * Un segment 3D.
  * 
@@ -134,17 +136,16 @@
   /**
    * Retourne le point appartenant au segment le plus proche du point donne.
    */
-  public GrPoint pointPlusProche(final GrPoint _p) {
-    final double d = _p.soustraction(o_).division(vecteur());
-    GrPoint r;
-    if (d <= 0.) {
-      r = new GrPoint(o_.x_, o_.y_, o_.z_);
-    } else if (d >= 1.) {
-      r = new GrPoint(e_.x_, e_.y_, e_.z_);
-    } else {
-      r = o_.addition(vecteur().multiplication(d));
-    }
-    return r;
+  public GrPoint pointPlusProche(final GrPoint _a) {
+    GrVecteur vecOA=new GrVecteur(_a.x_-o_.x_, _a.y_-o_.y_, _a.z_-o_.z_);
+    GrPoint r3;
+    if(vecOA.division(vecteur())<=0.)
+      r3=new GrPoint(o_.x_, o_.y_, o_.z_);
+    else if(vecOA.division(vecteur())>=1.)
+      r3=new GrPoint(e_.x_, e_.y_, e_.z_);
+    else
+      r3=o_.addition(vecOA.projection(vecteur()));
+   return r3;
   }
 
   /**

Modified: branches/FudaaModeleur_TC1Bis/fudaa_devel/fudaa/src/org/fudaa/fudaa/modeleur/MdlEditionManager.java
===================================================================
--- branches/FudaaModeleur_TC1Bis/fudaa_devel/fudaa/src/org/fudaa/fudaa/modeleur/MdlEditionManager.java	2008-12-02 15:14:53 UTC (rev 4260)
+++ branches/FudaaModeleur_TC1Bis/fudaa_devel/fudaa/src/org/fudaa/fudaa/modeleur/MdlEditionManager.java	2008-12-03 11:49:10 UTC (rev 4261)
@@ -33,6 +33,7 @@
 import org.fudaa.fudaa.modeleur.action.SceneInvertAction;
 import org.fudaa.fudaa.modeleur.action.SceneMoveInLayerAction;
 import org.fudaa.fudaa.modeleur.action.SceneProfilInterpolation;
+import org.fudaa.fudaa.modeleur.action.SceneLinearisePolyligne;
 import org.fudaa.fudaa.modeleur.action.SceneProjectionAction;
 import org.fudaa.fudaa.modeleur.action.SceneRefinementAction;
 import org.fudaa.fudaa.sig.layer.FSigEditor;
@@ -76,6 +77,7 @@
     acts.add(new SceneInvertAction((MdlSceneEditor)sceneEditor_));
     acts.add(new SceneProjectionAction((MdlSceneEditor)sceneEditor_));
     acts.add(new SceneProfilInterpolation((MdlSceneEditor)sceneEditor_));
+    acts.add(new SceneLinearisePolyligne((MdlSceneEditor) sceneEditor_));
     acts.add(new SceneAbscisseCurviligneAction(this));
     getSceneEditor().setActions(acts.toArray(new EbliActionAbstract[0]));
   }

Modified: branches/FudaaModeleur_TC1Bis/fudaa_devel/fudaa/src/org/fudaa/fudaa/modeleur/MdlSceneEditor.java
===================================================================
--- branches/FudaaModeleur_TC1Bis/fudaa_devel/fudaa/src/org/fudaa/fudaa/modeleur/MdlSceneEditor.java	2008-12-02 15:14:53 UTC (rev 4260)
+++ branches/FudaaModeleur_TC1Bis/fudaa_devel/fudaa/src/org/fudaa/fudaa/modeleur/MdlSceneEditor.java	2008-12-03 11:49:10 UTC (rev 4261)
@@ -11,7 +11,10 @@
 import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
 import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 
 import javax.swing.BorderFactory;
 import javax.swing.JButton;
@@ -22,6 +25,7 @@
 import org.fudaa.ctulu.CtuluCommandComposite;
 import org.fudaa.ctulu.CtuluListSelection;
 import org.fudaa.ctulu.CtuluListSelectionInterface;
+import org.fudaa.ctulu.collection.CtuluCollection;
 import org.fudaa.ctulu.gis.GISAttributeConstants;
 import org.fudaa.ctulu.gis.GISAttributeInterface;
 import org.fudaa.ctulu.gis.GISAttributeModelDoubleArray;
@@ -49,7 +53,10 @@
 import org.fudaa.ebli.calque.ZScene;
 import org.fudaa.ebli.calque.dessin.DeForme;
 import org.fudaa.ebli.calque.edition.ZCalqueEditable;
+import org.fudaa.ebli.calque.edition.ZModeleEditable;
 import org.fudaa.ebli.calque.edition.ZSceneEditor;
+import org.fudaa.ebli.geometrie.GrPoint;
+import org.fudaa.ebli.geometrie.GrVecteur;
 import org.fudaa.fudaa.commun.FudaaLib;
 import org.fudaa.fudaa.modeleur.layer.MdlModel2dLine;
 import org.fudaa.fudaa.modeleur.layer.MdlModel2dMultiPoint;
@@ -384,6 +391,127 @@
   }
 
   /**
+   * Rend rectiligne une polyligne.
+   */
+  public void linearisePolyligne() {
+    /** Class contenant les informations relativent \xE0 une polyligne. */
+    class Poly {
+      public GISPolyligne poly;
+      public Object[] data;
+      public Poly(GISPolyligne _poly, Object[] _data) {
+        poly=_poly;
+        data=_data;
+      }
+    }
+    /** Class contenant les infromations relatives \xE0 une coordonn\xE9s projet\xE9e. */
+    class PointProj implements Comparable<PointProj> {
+      public Coordinate c; // Coordonn\xE9 projet\xE9e
+      public double indiceCurviligne; // Indice Curviligne (k tq k*VecDirecteur=Vec(PtOrigine, c)) 
+      public List<Object> data=new ArrayList<Object>(); // valeur des attributs atomiques
+      /** M\xE9thode pour utiliser les alorithmes de tris fournis par java. */
+      public int compareTo(PointProj o) {
+        if (indiceCurviligne<o.indiceCurviligne)
+          return -1;
+        else if (indiceCurviligne==o.indiceCurviligne)
+          return 0;
+        else
+          return 1;
+      }
+    }
+    int[] geoms=getScene().getSelectionHelper().getSelectedIndexes();
+    Map<ZCalqueAffichageDonneesInterface, List<Poly>> newPoly=new HashMap<ZCalqueAffichageDonneesInterface, List<Poly>>();
+    // Verification de la selection \\
+    boolean selectionValid=true;
+    int w=-1;
+    while(selectionValid&&++w<geoms.length)
+      selectionValid=getScene().getObject(geoms[w]) instanceof GISPolyligne;
+    if(selectionValid){
+      // Pour chaque polyligne selectionn\xE9es
+      for (int i : geoms) {
+        GISPolyligne polyligne=((GISPolyligne)getScene().getObject(i));
+        ZCalqueAffichageDonneesInterface calque=getScene().getLayerForId(i);
+        GISZoneCollection zone=((ZModeleEditable)calque.modeleDonnees()).getGeomData();
+        /*
+         * Si deux points sont selectionn\xE9s dans cette polyligne, on les utilises
+         * comme destination de projection, sinon, ou si le nombre de point
+         * selectionn\xE9 n'est pas exactement deux, on utilise le premier et le
+         * dernier point de la polyligne comme destination de la projection. pt1
+         * et pt2 sont ces deux points de r\xE9f\xE9rence.
+         */
+        GrPoint pt1;
+        GrPoint pt2;
+        if (getScene().isAtomicMode()&&getScene().getLayerSelectionMulti().getSelection(i).getNbSelectedIndex()==2) {
+          pt1=new GrPoint(polyligne.getCoordinateSequence().getCoordinate(getScene().getLayerSelectionMulti().getSelection(i).getSelectedIndex()[0]));
+          pt2=new GrPoint(polyligne.getCoordinateSequence().getCoordinate(getScene().getLayerSelectionMulti().getSelection(i).getSelectedIndex()[1]));
+        }
+        else {
+          pt1=new GrPoint(polyligne.getCoordinateSequence().getCoordinate(0));
+          pt2=new GrPoint(polyligne.getCoordinateSequence().getCoordinate(polyligne.getCoordinateSequence().size()-1));
+        }
+        // Vecteur de la droite de destination
+        GrVecteur vecP1P2=new GrVecteur(pt2.x_-pt1.x_, pt2.y_-pt1.y_, pt2.z_-pt1.z_);
+        // Construction de l'ensemble des points composant la nouvelle polyligne \\
+        PointProj[] newPtsCurv=new PointProj[polyligne.getCoordinateSequence().size()];
+        for (int j=0; j<newPtsCurv.length; j++) {
+          GrPoint a=new GrPoint(polyligne.getCoordinateSequence().getCoordinate(j));
+          // Projection
+          GrVecteur vecP1A=new GrVecteur(a.x_-pt1.x_, a.y_-pt1.y_, a.z_-pt1.z_);
+          GrPoint p=pt1.addition(vecP1A.projection(vecP1P2));
+          Coordinate cp=new Coordinate(p.x_, p.y_, p.z_);
+          // Remplissage des informations relatives au point calcul\xE9
+          newPtsCurv[j]=new PointProj();
+          newPtsCurv[j].c=cp;
+          newPtsCurv[j].indiceCurviligne=new GrVecteur(cp.x-pt1.x_, cp.y-pt1.y_, cp.z-pt1.z_).division(vecP1P2);
+          for (int k=0; k<zone.getNbAttributes(); k++)
+            if (zone.getAttribute(k).isAtomicValue())
+              newPtsCurv[j].data.add(((CtuluCollection)zone.getValue(k, getScene().sceneId2LayerId(i))).getObjectValueAt(j));
+        }
+        // Tri des points en fonction de leur abcisse curviligne \\
+        Arrays.sort(newPtsCurv);
+        // R\xE9cup\xE9ration des coordonn\xE9s
+        Coordinate[] newPts=new Coordinate[newPtsCurv.length];
+        for (int j=0; j<newPts.length; j++)
+          newPts[j]=newPtsCurv[j].c;
+        // R\xE9cup\xE9ration des values des attributs atomiques
+        Object[] newData=new Object[zone.getNbAttributes()];
+        int nemeAttAtomique=0;
+        for (int j=0; j<zone.getNbAttributes(); j++) {
+          if (zone.getAttribute(j).isAtomicValue()) {
+            Object[] values=new Object[newPtsCurv.length];
+            for (int k=0; k<newPtsCurv.length; k++)
+              values[k]=newPtsCurv[k].data.get(nemeAttAtomique);
+            newData[j]=zone.getAttribute(j).createDataForGeom(values, newPtsCurv.length);
+            nemeAttAtomique++;
+          }
+          else
+            newData[j]=zone.getValue(j, getScene().sceneId2LayerId(i));
+        }
+        // Ajout \xE0 la list des nouvelles polylignes \\
+        if (!newPoly.containsKey(calque))
+          newPoly.put(calque, new ArrayList<Poly>());
+        newPoly.get(calque).add(new Poly(GISGeometryFactory.INSTANCE.createLineString(newPts), newData));
+      }
+      CtuluCommandComposite cmd=new CtuluCommandComposite();
+      // Destruction des anciennes polylignes
+      Arrays.sort(geoms);
+      for (int i=geoms.length-1; i>=0; i--)
+        ((ZModeleEditable)getScene().getLayerForId(geoms[i]).modeleDonnees()).getGeomData().removeGeometries(new int[]{getScene().sceneId2LayerId(geoms[i])}, cmd);
+      // Ajout des nouvelles polylignes
+      for (Map.Entry<ZCalqueAffichageDonneesInterface, List<Poly>> entry : newPoly.entrySet()) {
+        GISZoneCollection zone=((ZModeleEditable)((ZCalqueEditable)entry.getKey()).modeleDonnees()).getGeomData();
+        List<Poly> polys=entry.getValue();
+        for (int i=0; i<polys.size(); i++)
+          zone.addGeometry(polys.get(i).poly, polys.get(i).data, cmd);
+      }
+      // Mise \xE0 jour du undo/redo
+      if(mng_!=null)
+        mng_.addCmd(cmd.getSimplify());
+      // Suppression de la selection
+      getScene().clearSelection();
+    }
+  }
+  
+  /**
    * Interpole un profil \xE0 partir d'un nuage de point.
    */
   public void interpolateProfile() {

Added: branches/FudaaModeleur_TC1Bis/fudaa_devel/fudaa/src/org/fudaa/fudaa/modeleur/action/SceneLinearisePolyligne.java
===================================================================
--- branches/FudaaModeleur_TC1Bis/fudaa_devel/fudaa/src/org/fudaa/fudaa/modeleur/action/SceneLinearisePolyligne.java	                        (rev 0)
+++ branches/FudaaModeleur_TC1Bis/fudaa_devel/fudaa/src/org/fudaa/fudaa/modeleur/action/SceneLinearisePolyligne.java	2008-12-03 11:49:10 UTC (rev 4261)
@@ -0,0 +1,73 @@
+/*
+ * @creation     2 d\xE9c. 2008
+ * @modification $Date:$
+ * @license      GNU General Public License 2
+ * @copyright    (c)1998-2008 CETMEF 2 bd Gambetta F-60231 Compiegne
+ * @mail         fud...@li...
+ */
+package org.fudaa.fudaa.modeleur.action;
+
+import java.awt.event.ActionEvent;
+
+import org.fudaa.ctulu.CtuluLib;
+import org.fudaa.ctulu.gis.GISAttributeConstants;
+import org.fudaa.ctulu.gis.GISPolyligne;
+import org.fudaa.ctulu.gis.GISZoneCollection;
+import org.fudaa.ebli.calque.ZCalqueAffichageDonneesInterface;
+import org.fudaa.ebli.calque.ZModeleGeometry;
+import org.fudaa.ebli.calque.ZScene;
+import org.fudaa.ebli.calque.ZSelectionEvent;
+import org.fudaa.ebli.calque.ZSelectionListener;
+import org.fudaa.ebli.calque.ZScene.SceneSelectionHelper;
+import org.fudaa.ebli.commun.EbliActionSimple;
+import org.fudaa.fudaa.modeleur.MdlSceneEditor;
+import org.fudaa.fudaa.ressource.FudaaResource;
+
+/**
+ * Action permettant de rendre rectiligne un profil.
+ * @author Emmanuel MARTIN
+ * @version $Id:$
+ */
+public class SceneLinearisePolyligne extends EbliActionSimple implements ZSelectionListener {
+  protected MdlSceneEditor sceneEditor_;
+  
+  public SceneLinearisePolyligne(MdlSceneEditor _sceneEditor) {
+    super(FudaaResource.FUDAA.getString("Rendre rectiligne une ou plusieurs polyligne(s)"), null, "RECTILIGNE_POLYLIGNE");
+    setDefaultToolTip(FudaaResource.FUDAA.getString("Rend rectiligne une ou plusieurs polyligne(s)"));
+    sceneEditor_=_sceneEditor;
+    sceneEditor_.getScene().addSelectionListener(this);
+  }
+
+  public void actionPerformed(final ActionEvent _e) {
+    sceneEditor_.linearisePolyligne();
+  }
+
+  public void updateForSelectionChanged() {
+    ZScene scn=sceneEditor_.getScene();
+    SceneSelectionHelper hlp=sceneEditor_.getScene().getSelectionHelper();
+    // Au moins une et seulement des polylignes de selectionn\xE9es. Et si en mode
+    // atomique, deux sommets doivent \xEAtre selectionn\xE9s pour chacune d'entre
+    // elles.
+    int[] geomSelected=scn.getSelectionHelper().getSelectedIndexes();
+    boolean b=geomSelected.length>0;
+    int i=0;
+    while(b&&i<geomSelected.length){
+      b=scn.getObject(geomSelected[i]) instanceof GISPolyligne;
+      if(scn.isAtomicMode())
+        b=b&&scn.getLayerSelectionMulti()!=null&&scn.getLayerSelectionMulti().getSelection(geomSelected[i]).getNbSelectedIndex()==2;
+      i++;
+    }
+    setEnabled(b);
+  }
+
+  public String getEnableCondition() {
+    return CtuluLib.getS("Selectionner une ou plusieurs polyligne(s), en mode global ou atomique (pour cette derni\xE8re selectionnez deux points pour chaque polyligne).");
+  }
+
+  /* (non-Javadoc)
+   * @see org.fudaa.ebli.calque.ZSelectionListener#selectionChanged(org.fudaa.ebli.calque.ZSelectionEvent)
+   */
+  public void selectionChanged(ZSelectionEvent _evt) {
+    updateForSelectionChanged();
+  }
+}


Property changes on: branches/FudaaModeleur_TC1Bis/fudaa_devel/fudaa/src/org/fudaa/fudaa/modeleur/action/SceneLinearisePolyligne.java
___________________________________________________________________
Added: svn:keywords
   + Id
Added: svn:eol-style
   + native


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.