[Fudaa-cvs-commit] fudaa_devel/fudaa/src/org/fudaa/fudaa/hydraulique1d/editor/casier/tableau Hydraulique1dCasierTabXYZModel.java,1.2,1.3

[<jm_...@us...>]

Update of /cvsroot/fudaa//fudaa_devel/fudaa/src/org/fudaa/fudaa/hydraulique1d/editor/casier/tableau
In directory sc8-pr-cvs1:/tmp/cvs-serv14568/editor/casier/tableau

Modified Files:
	Hydraulique1dCasierTabXYZModel.java 
Log Message:
Debug et import export


Index: Hydraulique1dCasierTabXYZModel.java
===================================================================
RCS file: /cvsroot/fudaa//fudaa_devel/fudaa/src/org/fudaa/fudaa/hydraulique1d/editor/casier/tableau/Hydraulique1dCasierTabXYZModel.java,v
retrieving revision 1.2
retrieving revision 1.3
diff -C2 -d -r1.2 -r1.3
*** Hydraulique1dCasierTabXYZModel.java	23 Jul 2003 09:13:49 -0000	1.2
--- Hydraulique1dCasierTabXYZModel.java	4 Aug 2003 17:50:08 -0000	1.3
***************
*** 42,45 ****
--- 42,46 ----
    private ArrayList listePts_;
  
+   private String message="";
  
    public Hydraulique1dCasierTabXYZModel()  {
***************
*** 181,192 ****
  
    boolean getValeurs() {
!     ArrayList listeTmp = new ArrayList(listePts_.size());
!     Iterator ite = listePts_.iterator();
!     while (ite.hasNext()) {
!       XYZ pt = (XYZ)ite.next();
!       if ((pt.X != null)&&(pt.Y != null)&&(pt.Z != null)) {
!         listeTmp.add(pt);
!       }
!     }
  
      SPoint[] pts = new SPoint[listeTmp.size()];
--- 182,187 ----
  
    boolean getValeurs() {
! 
!     ArrayList listeTmp = getListePtsComplets();
  
      SPoint[] pts = new SPoint[listeTmp.size()];
***************
*** 206,209 ****
--- 201,253 ----
    }
  
+   public ArrayList getListePtsComplets() {
+     ArrayList listeTmp = new ArrayList(listePts_.size());
+     Iterator ite = listePts_.iterator();
+     while (ite.hasNext()) {
+       XYZ pt = (XYZ)ite.next();
+       if ((pt.X != null)&&(pt.Y != null)&&(pt.Z != null)) {
+         listeTmp.add(pt);
+       }
+     }
+     return listeTmp;
+   }
+ 
+   public String validationDonnees() {
+     ArrayList listePts = getListePtsComplets();
+     String res="";
+     if (mode_ == POINTS_FRONTIERES) {
+       if (listePts.size() < 3) {
+         res+="Le nombre de points frontière doit être supérieur à 3";
+       }
+       else {
+         if (pointsAlignes(listePts)) {
+           res+="Des points frontières suivant sont alignés dans la plan (XY) :";
+           res+="\t"+message;
+         }
+       }
+     }
+     else if (mode_ == POINTS_INTERIEURS) {
+       if (listePts.size() < 1) {
+         res+="Le nombre de points frontière doit être supérieur à 1";
+       }
+     }
+     return res;
+   }
+ 
+   public double getPlusPetitEcartCote() {
+     double plusPetitEcart = Double.MAX_VALUE;
+     ArrayList listePts = getListePtsComplets();
+     if (listePts.size() > 2) {
+       Iterator ite = listePts.iterator();
+       double zPrec = ((XYZ)ite.next()).Z.doubleValue();
+       while(ite.hasNext()) {
+         double z = ((XYZ)ite.next()).Z.doubleValue();
+         double ecart = Math.abs(z - zPrec);
+         plusPetitEcart = Math.min(plusPetitEcart, ecart);
+         zPrec = z;
+       }
+     }
+     return plusPetitEcart;
+   }
  
    void ajouterLigne() {
***************
*** 216,219 ****
--- 260,388 ----
      fireTableDataChanged();
    }
+ 
+   private boolean pointsAlignes(ArrayList listePts) {
+     boolean res = false;
+     if (listePts.size() >=3) {
+       ArrayList listeDroites = new ArrayList();
+       for (int i = 0; i < (listePts.size()-1); i++) {
+         XYZ pti = (XYZ)listePts.get(i);
+         XYZ ptiPlus1 = (XYZ)listePts.get(i+1);
+ 
+         Droite d = new Droite();
+         d.pt1=new XY(pti);
+         d.pt2=new XY(ptiPlus1);
+         listeDroites.add(d);
+       }
+ 
+       for (int i = 0; i < listeDroites.size(); i++) {
+         Droite di = (Droite)listeDroites.get(i);
+         for (int j = (i+1); j < listeDroites.size(); j++) {
+           Droite dj = (Droite)listeDroites.get(j);
+           if (di.alignee(dj)) {
+             message =di.toString()+" et "+dj.toString() ;
+             return true;
+           }
+         }
+       }
+     }
+     return res;
+   }
+ 
+   private static final double determinant(XYZ v1, XYZ v2) {
+     return (v1.X.doubleValue()*v2.Y.doubleValue()) - (v2.X.doubleValue()*v1.Y.doubleValue());
+   }
+ }
+ class Droite {
+   XY pt1;
+   XY pt2;
+ 
+   //coefficient de la droite y = ax+b
+   private double a=Double.NaN;
+   private double b=Double.NaN;
+ 
+   public boolean alignee(Droite d2) {
+     boolean vert = vertical();
+     boolean d2Vert = d2.vertical();
+     if ( (vert && !d2Vert) || (!vert && d2Vert) ) return false;
+     if (parallele(d2)) {
+       return existeIntersection(d2);
+     }
+     return false;
+   }
+   /**
+    * @return true s'il existe une intersection entre 2 droites parallèles this et d2
+    */
+   private boolean existeIntersection(Droite d2) {
+     boolean vert = vertical();
+     boolean d2Vert = d2.vertical();
+     if (vert && d2Vert) { // 2 droites verticales
+       if (pt1.x == d2.pt1.x) return true;
+       else return false;
+     }
+     else if ( (vert && !d2Vert) || (!vert && d2Vert) ) {// 1 seule droite verticale
+       return true;
+     }
+     else {
+       return (d2.pt1.y == calculOrdonnee(d2.pt1.x));
+     }
+   }
+ 
+   public double calculOrdonnee(double x) {
+     calculCoefs();
+     return (a*x) + b;
+   }
+   private void calculCoefs() {
+     a = (pt1.y-pt2.y)/(pt1.x-pt2.x);
+     b= pt1.y - (a * pt1.x);
+   }
+ 
+   public boolean parallele(Droite d2) {
+     XY vec=vecteur();
+     XY vec2=d2.vecteur();
+     if (XY.determinant(vec,vec2) == 0) return true;
+     else return false;
+   }
+ 
+   public XY vecteur() {
+     XY vec = new XY();
+     vec.x = pt2.x - pt1.x;
+     vec.y = pt2.y - pt1.y;
+     return vec;
+   }
+ 
+   public boolean vertical() {
+     XY vec=vecteur();
+     if (vec.x == 0.) return true;
+     return false;
+   }
+ 
+   public String toString() {
+     return pt1.toString()+"-"+pt2.toString();
+   }
+ }
+ 
+ class XY {
+   double x=Double.NaN;
+   double y=Double.NaN;
+ 
+   XY() {
+   }
+ 
+   XY(XYZ xyz) {
+     x=xyz.X.doubleValue();
+     y=xyz.Y.doubleValue();
+   }
+ 
+   XY(double _x, double _y) {
+     x=_x;
+     y=_y;
+   }
+   public String toString() {
+     return "("+x+","+y+")";
+   }
+ 
+   public static final double determinant(XY a, XY b) {
+     return (a.x*b.y) - (b.x*a.y);
+   }
  }
  
***************
*** 237,240 ****
--- 406,413 ----
      Y=y;
      Z=z;
+   }
+ 
+   public String toString() {
+     return "X="+X+" Y="+Y+" Z="+Z;
    }
  }