Menu
▾
▴
[Fudaa-svn-commit] SF.net SVN: fudaa:[4033] branches/Prepro-0.92-SNAPSHOT/fudaa/src/org/fudaa/ fudaa/tr/post/TrComputeLigneCourantTrajectoire.java
|
From: <de...@us...> - 2008-10-05 20:43:42
|
Revision: 4033
http://fudaa.svn.sourceforge.net/fudaa/?rev=4033&view=rev
Author: deniger
Date: 2008-10-05 20:43:37 +0000 (Sun, 05 Oct 2008)
Log Message:
-----------
Modified Paths:
--------------
branches/Prepro-0.92-SNAPSHOT/fudaa/src/org/fudaa/fudaa/tr/post/TrComputeLigneCourantTrajectoire.java
Modified: branches/Prepro-0.92-SNAPSHOT/fudaa/src/org/fudaa/fudaa/tr/post/TrComputeLigneCourantTrajectoire.java
===================================================================
--- branches/Prepro-0.92-SNAPSHOT/fudaa/src/org/fudaa/fudaa/tr/post/TrComputeLigneCourantTrajectoire.java 2008-10-03 21:29:46 UTC (rev 4032)
+++ branches/Prepro-0.92-SNAPSHOT/fudaa/src/org/fudaa/fudaa/tr/post/TrComputeLigneCourantTrajectoire.java 2008-10-05 20:43:37 UTC (rev 4033)
@@ -1,14 +1,22 @@
package org.fudaa.fudaa.tr.post;
+import gnu.trove.TIntHashSet;
+import gnu.trove.TIntIterator;
+
import java.awt.Point;
+import java.io.IOException;
import java.util.ArrayList;
+import java.util.List;
+import org.fudaa.ctulu.CtuluVariable;
import org.fudaa.ctulu.ProgressionInterface;
import org.fudaa.dodico.ef.EfData;
+import org.fudaa.dodico.ef.EfElement;
import org.fudaa.dodico.ef.EfGridData;
import org.fudaa.dodico.ef.EfGridInterface;
import org.fudaa.dodico.ef.EfNeighborMesh;
import org.fudaa.dodico.ef.interpolation.EfGridDataInterpolator;
+import org.fudaa.dodico.ef.interpolation.EfGridDataInterpolatorDefault;
import org.fudaa.dodico.ef.interpolation.EfInterpolator;
import org.fudaa.dodico.ef.operation.EfIndexVisitorNearestElt;
import org.fudaa.dodico.ef.operation.EfIndexVisitorNearestNode;
@@ -25,329 +33,345 @@
import com.vividsolutions.jts.geom.LineString;
import com.vividsolutions.jts.geom.PrecisionModel;
-
/**
- * Algorithme de Calcul les lignes de courants
+ * Algorithme de Calcul les lignes de courants TODO mettre la classe dans EF il y a la classe qui est charge de faire le
+ * calcul qui doit implementer CtulActivity et la classe qui implemente EfLineIntersectionParent.
+ *
* @author Adrien Hadoux
- *
*/
-public class TrComputeLigneCourantTrajectoire implements EfLineIntersectionParent{
+public class TrComputeLigneCourantTrajectoire implements EfLineIntersectionParent {
+ /**
+ * data
+ */
+ TrPostVisuPanel calque_;
+ final TrPostSource data_;
- /**
- * data
- */
- TrPostVisuPanel calque_;
- final TrPostSource data_;
+ /**
+ * pour interpoler les valeur
+ */
+ final EfInterpolator interpolator_;
- /**
- * pour interpoler les valeur
- */
- final EfInterpolator interpolator_;
+ final EfLineIntersectorActivity lineIntersect_;
+ ProgressionInterface prog_;
+ List<Coordinate> listePointsARepartir_ = new ArrayList<Coordinate>(); // les GrPoint ne sont utilisee que pour
+ // l'affichage
- final EfLineIntersectorActivity lineIntersect_;
- ProgressionInterface prog_;
+ /**
+ * Liste des intersections r\xE9sultats
+ */
+ ArrayList<EfLineIntersection> listeIntersection_ = null;
-
- ArrayList<GrPoint> listePointsARepartir_=new ArrayList<GrPoint>();
-
- /**
- * Liste des intersections r\xE9sultats
- */
- ArrayList<EfLineIntersection> listeIntersection_=null;
+ public TrComputeLigneCourantTrajectoire(TrPostVisuPanel calque) {
+ super();
+ calque_ = calque;
+ this.data_ = calque.getSource();
+ this.interpolator_ = data_.getInterpolator();
+ this.lineIntersect_ = new EfLineIntersectorActivity(data_);
+ }
+ /**
+ * Methode qui permet de repartir uniformement un nombre d points nb sur un segment.
+ *
+ * @param point1 extremites 1 du segment
+ * @param point2 extremite 2 du segment
+ * @param nbPointsARepartir nombre entier de points a repartir
+ * @return la liste des points repartis
+ */
+ public static ArrayList<Coordinate> repartirUniformementPointsSurSegment(GrPoint point1, GrPoint point2,
+ int nbPointsARepartir) {
- public TrComputeLigneCourantTrajectoire(TrPostVisuPanel calque) {
- super();
- calque_=calque;
- this.data_ =calque.getSource();
- this.interpolator_ = data_.getInterpolator();
- this.lineIntersect_ = new EfLineIntersectorActivity(data_);
- }
+ // on calcul leur droite d'equation
+ double coeff = 0;
+ if (point1.x_ - point2.x_ != 0) coeff = (point1.y_ - point2.y_) / (point1.x_ - point2.x_);
+ double ordonneeOrigine = point1.y_ - coeff * point1.x_;
-
-
- /**
- * Methode qui permet de repartir uniformement un nombre d points nb sur un segment.
- * @param point1 extremites 1 du segment
- * @param point2 extremite 2 du segment
- * @param nbPointsARepartir nombre entier de points a repartir
- * @return la liste des points repartis
- */
- public static ArrayList<GrPoint> repartirUniformementPointsSurSegment(GrPoint point1, GrPoint point2, int nbPointsARepartir){
-
- //on calcul leur droite d'equation
- double coeff=0;
- if(point1.x_-point2.x_!=0)
- coeff=(point1.y_-point2.y_)/(point1.x_-point2.x_);
- double ordonneeOrigine=point1.y_-coeff*point1.x_;
-
-
-
- int nbPoints=nbPointsARepartir;
- if(nbPoints<2)
- //on en met au moins 2 qui seront les extremites
- nbPoints=2;
-
-
- //on part du principe que le point 1 est le plus a gauche (abscisse plus petite)
- if(point1.x_>point2.x_){
- GrPoint temp=new GrPoint();
- temp.initialiseAvec(point1);
- point1.initialiseAvec(point2);
- point2.initialiseAvec(temp);
- }
-
- double distanceToAddEachPoint=Math.sqrt((point1.y_-point2.y_)*(point1.y_-point2.y_)+ (point1.x_-point2.x_)*(point1.x_-point2.x_))/nbPoints;
-
- ArrayList<GrPoint> listePointsARepartir=new ArrayList<GrPoint>(nbPoints);
-
- //ajout du point 1 dans la liste
- listePointsARepartir.add(point1);
-
- // ajout des nbPoints-2 autre points
- for(int i=0;i<nbPoints-2;i++){
- if(point1.x_-point2.x_!=0){
- double x=point1.x_+distanceToAddEachPoint*(i+1);
- double y=coeff*x+ordonneeOrigine;
- GrPoint newpoint=new GrPoint(x,y,0);
- listePointsARepartir.add(newpoint);
- }
- else{
- //car droite perpendiculaire a l axe des x
- double x=point1.x_;
- double y=Math.min(point1.y_,point2.y_)+distanceToAddEachPoint*(i+1);
- GrPoint newpoint=new GrPoint(x,y,0);
- listePointsARepartir.add(newpoint);
- }
- }
-
- //ajout du point autre extremite
- listePointsARepartir.add(point2);
-
- return listePointsARepartir;
- }
-
-
-
-
- public void progression(String desc, int completionRate){
- if(prog_==null)
- return;
- prog_.setDesc(TrResource.getS(desc));
- prog_.setProgression(5);
+ int nbPoints = nbPointsARepartir;
+ if (nbPoints < 2)
+ // on en met au moins 2 qui seront les extremites
+ nbPoints = 2;
- }
- /**
- * Methode appel\xE9e par l'interface de calcul des lignes de courant.
- * @param init point de depart
- * @param dureeIntegration duree totale de l'integration en secondes
- * @param indicePdt indice du pas de temps
- * @param finesse coefficient de finesse double
- * @param variable la variable a utiliser
- * @param prog l'interface de progression, peut etre null
- * @return
- */
- public ArrayList<EfLineIntersection> computeLigneCourant(GrPoint extrem1segment,GrPoint extrem2segment, int nbPointsARepartirUniformement, double dureeIntegration, int indicePdt,double finesse ,H2dVariableType variable, ProgressionInterface prog){
- prog_=prog;
-
-
- //on repartit les points uniform\xE9ment sur le segment
- listePointsARepartir_=repartirUniformementPointsSurSegment(extrem1segment, extrem2segment, nbPointsARepartirUniformement);
-
- //test de l'algo avec le premier point
- GrPoint init=listePointsARepartir_.get(0);
-
-
- //on init le temps total avec l'indice du pas de temps fourni au depart
- double tempsTotal=data_.getTimeStep(indicePdt);
- double oldTempsTotal;
- boolean termine=false;
+ // on part du principe que le point 1 est le plus a gauche (abscisse plus petite)
+ if (point1.x_ > point2.x_) {
+ GrPoint temp = new GrPoint();
+ temp.initialiseAvec(point1);
+ point1.initialiseAvec(point2);
+ point2.initialiseAvec(temp);
+ }
+ // TODO pour calculer une distance utilise getDistanceXY
+ double distanceToAddEachPoint = Math.sqrt((point1.y_ - point2.y_) * (point1.y_ - point2.y_)
+ + (point1.x_ - point2.x_) * (point1.x_ - point2.x_))
+ / nbPoints;
- //-- variables d'initialisation
- //point courant tout au long de l'algo
- GrPoint pointCourant=init;
- //element sur lequel on se situe a l'iteration i
- int elementCourant;
- //intersection courante
- EfLineIntersection intersectionCourante;
- //donn\xE9es r\xE9cup\xE9r\xE9es fixe pour les lignes de courants
- EfData dataX;
+ ArrayList<Coordinate> listePointsARepartir = new ArrayList<Coordinate>(nbPoints);
- //initialisation
- progression("Recherche \xE9l\xE9ment englobant",5);
- elementCourant=elementEnglobant(pointCourant);
- //creation de l'intersection avec l'\xE9l\xE9ment courant
- progression("Recherche des intersection",7);
- intersectionCourante=new EfLineIntersection.ItemMesh(elementCourant,pointCourant.x_,pointCourant.y_);
+ // ajout du point 1 dans la liste
+ listePointsARepartir.add(new Coordinate(point1.x_, point1.y_));
- //recup des datas a partir de la var et du pas de temps initial
- dataX=data_.getData(variable, indicePdt);
+ // ajout des nbPoints-2 autre points
+ for (int i = 0; i < nbPoints - 2; i++) {
+ if (point1.x_ - point2.x_ != 0) {
+ double x = point1.x_ + distanceToAddEachPoint * (i + 1);
+ double y = coeff * x + ordonneeOrigine;
+ Coordinate newpoint = new Coordinate(x, y, 0);
+ listePointsARepartir.add(newpoint);
+ } else {
+ // car droite perpendiculaire a l axe des x
+ double x = point1.x_;
+ double y = Math.min(point1.y_, point2.y_) + distanceToAddEachPoint * (i + 1);
+ Coordinate newpoint = new Coordinate(x, y, 0);
+ listePointsARepartir.add(newpoint);
+ }
+ }
+ // ajout du point autre extremite
+ listePointsARepartir.add(new Coordinate(point2.x_, point2.y_));
+ return listePointsARepartir;
+ }
- //-- Algo principal --//
+ public void progression(String desc, int completionRate) {
+ if (prog_ == null) return;
+ prog_.setDesc(TrResource.getS(desc));
+ prog_.setProgression(5);
- if(elementCourant !=-1){
+ }
- while(!termine && tempsTotal<=dureeIntegration){
- oldTempsTotal=tempsTotal;
+ EfNeighborMesh voisinage_;
- //ajout de l'intersection dans la liste r\xE9sultats
- listeIntersection_.add(intersectionCourante);
+ /**
+ * Methode appel\xE9e par l'interface de calcul des lignes de courant.
+ *
+ * @param init point de depart
+ * @param dureeIntegration duree totale de l'integration en secondes
+ * @param indicePdt indice du pas de temps
+ * @param finesse coefficient de finesse double
+ * @param vx la variable a utiliser
+ * @param prog l'interface de progression, peut etre null
+ * @return
+ */
+ public ArrayList<EfLineIntersection> computeLigneCourant(GrPoint extrem1segment, GrPoint extrem2segment,
+ int nbPointsARepartirUniformement, double dureeIntegration, int indicePdt, double finesse, CtuluVariable vx,
+ CtuluVariable vy, ProgressionInterface prog) {// FIXME trop de variable faire une classe
+ prog_ = prog;
- //recherche des vitesses
- double vitesseX=intersectionCourante.getDistanceFrom(pointCourant.x_, pointCourant.y_);
- double vitesseY=intersectionCourante.getValueBadInterpolation(dataX);
+ // on repartit les points uniform\xE9ment sur le segment
+ listePointsARepartir_ = repartirUniformementPointsSurSegment(extrem1segment, extrem2segment,
+ nbPointsARepartirUniformement);
+ // test de l'algo avec le premier point
+ Coordinate init = listePointsARepartir_.get(0);
- //calcul des distances avec son voisinage
- progression("Calcul des distances avec le voisinage",10);
- EfNeighborMesh voisinage=EfNeighborMesh.compute(data_.getGrid(), prog_);
- double distanceMaxEntrePoints=0;
- int[] listeEltVoisins=null;
- int voisinChoisi=0;
- //cas sur un noeud
- if(intersectionCourante.isNodeIntersection()){
- int nbVoisins=voisinage.getNbNeighborMeshes(elementCourant);
- listeEltVoisins=new int[nbVoisins];
- for(int i=0;i<nbVoisins;i++){
- //On calcule la distance avec lequel de ces points???
- listeEltVoisins[i] =voisinage.getNeighborMesh(elementCourant, i);
- }
+ // on init le temps total avec l'indice du pas de temps fourni au depart
+ double tempsTotal = data_.getTimeStep(indicePdt);
+ double oldTempsTotal;
+ boolean termine = false;
- }else {
- //comment faire en fudaa pour les autres cas???
- //cas des arretes
+ // -- variables d'initialisation
+ // point courant tout au long de l'algo
+ Coordinate pointCourant = init;
+ // element sur lequel on se situe a l'iteration i
+ int elementCourant;
+ // intersection courante
+ EfLineIntersection intersectionCourante;
+ // initialisation
+ progression("Recherche \xE9l\xE9ment englobant", 5);
+ elementCourant = elementEnglobant(pointCourant);
+ // creation de l'intersection avec l'\xE9l\xE9ment courant
+ progression("Recherche des intersection", 7);
+ intersectionCourante = new EfLineIntersection.ItemMesh(elementCourant, pointCourant.x, pointCourant.y);
- }
+ // recup des datas a partir de la var et du pas de temps initial
+ // donn\xE9es r\xE9cup\xE9r\xE9es fixe pour les lignes de courants
+ EfData dataX=null;
+ EfData dataY=null;
+ try {
+ dataX = data_.getData(vx, indicePdt);
+ dataY = data_.getData(vy, indicePdt);
+ } catch (IOException e) {
+ e.printStackTrace();//erreur de lecteur arrrete le tout
+ }
+ // -- Algo principal --//
+Coordinate c=new Coordinate();
+ if (elementCourant != -1) {
+ TIntHashSet elementsAdjacent=new TIntHashSet();
+ while (!termine && tempsTotal <= dureeIntegration) {//FIXME faux comparaison d'une duree et d'un temps. En fait la duree initiale (tempsTotal) vaut zero
+ //il faut faire attention: si la dureeIntegration est negative. Il faut comparer les valeurs absolues
+ oldTempsTotal = tempsTotal;
+
+ // ajout de l'intersection dans la liste r\xE9sultats
+ listeIntersection_.add(intersectionCourante);
- //calcul de la distance max
- if(listeEltVoisins!=null && listeEltVoisins.length>0)
- voisinChoisi=listeEltVoisins[0];
- for(int i=0;i<listeEltVoisins.length;i++){
- int eltVoisin=listeEltVoisins[i];
+ // recherche des vitesses
+ // double vitesseX = intersectionCourante.getDistanceFrom(pointCourant.x, pointCourant.y);//FIXME la vitesse
+ // c'est pas la distance depuis le debut
+ // mais la valeur de vx
+ //FIXME attention pour les trajectoires les valeurs dataX et dataY doivent etre recalcule au vrai temps
+ //il faudra surement interpoler en temps !
+ double vitesseX = intersectionCourante.getValueBadInterpolation(dataX);
+ double vitesseY = intersectionCourante.getValueBadInterpolation(dataY);
- // coordonn\xE9es de l'\xE9l\xE9ment voisin
- double x= getCoordonnees(eltVoisin).x_;
- double y=getCoordonnees(eltVoisin).y_;
- double distance=Math.sqrt((pointCourant.x_-x)*(pointCourant.x_-x) + (pointCourant.y_-y)*(pointCourant.y_-y) );
- if(distanceMaxEntrePoints>distance){
- //candidat potentiel
+ // calcul des distances avec son voisinage
+ progression("Calcul des distances avec le voisinage", 10);
+ // FIXME ce calcul est long il faut le faire en dehors de la boucld !
+ // EfNeighborMesh voisinage = EfNeighborMesh.compute(data_.getGrid(), prog_);
+ elementsAdjacent.clear();
+ //la set elementAdjacent comporte tous les \xE9l\xE9ements adjacents \xE0 l'intersection courante
+ intersectionCourante.fillWithAdjacentMeshes(elementsAdjacent);
+ double distanceMaxEntrePoints = 0;
+ int[] listeEltVoisins = null;
+ int voisinChoisi = 0;//ne sert a rien
+ //ATTENTION: pour calcul le prochain point il faut partir du point en cours,
+ //et se d\xE9placer selon les vitesses x2=x1*vx*delta T
+ //REATTENTION: il faut prendre en compte le fait que la duree d'integration peut etre negative
+ // cas sur un noeud
+ //FIXME inutile desormais
+// if (intersectionCourante.isNodeIntersection()) {
+// int nbVoisins = voisinage_.getNbNeighborMeshes(elementCourant);
+// listeEltVoisins = new int[nbVoisins];
+// for (int i = 0; i < nbVoisins; i++) {
+// // On calcule la distance avec lequel de ces points???
+// // avec tous
+// listeEltVoisins[i] = voisinage_.getNeighborMesh(elementCourant, i);
+// }
+//
+// } else {
+// // comment faire en fudaa pour les autres cas???
+// // cas des arretes
+//
+// }
- //ACHTUNG!! VERIFIER QUE LE t+ deltaT<dureeIntegration si on choisit cette distance
- if(vitesseY!=0 && (tempsTotal+ distance/vitesseY<=dureeIntegration)){
- distanceMaxEntrePoints=distance;
- voisinChoisi=eltVoisin;
- }
- }
- }
+ // calcul de la distance max
+ //pour calculer la distance max, il faut parcourir tous les \xE9l\xE9ments trouve et tous les noeuds des \xE9l\xE9ments
+ for(TIntIterator it=elementsAdjacent.iterator();it.hasNext();){
+ int idxElt=it.next();
+ EfElement elt=data_.getGrid().getElement(idxElt);
+ for (int i = 0; i < elt.getPtNb(); i++) {
+ data_.getGrid().getCoord(elt.getPtIndex(i), c);
+ distanceMaxEntrePoints=Math.max(distanceMaxEntrePoints, intersectionCourante.getDistanceFrom(c.x, c.y));
+ }
+ }
+ //maintenant, on a la distance max, on calcul la duree du d\xE9placement. On a la vitesse qui vaut sqrt(vx*vx+vy*vy)
+ //Attenion. si la duree d'integration est negative il faut avoir une duree de deplacement n\xE9gative
+ //y=y1+vy*(delta t) et meme chose pour x
+
+ //le reste est faux: on calcule une trajectoire et donc il faut se deplacer selon vx et vy et ne pas prendre le noeud du voisinage le plus loin !
+ if (listeEltVoisins != null && listeEltVoisins.length > 0) voisinChoisi = listeEltVoisins[0];// pourquoi le
+ // premier ?
+ for (int i = 0; i < listeEltVoisins.length; i++) {
+ int eltVoisin = listeEltVoisins[i];
+ // coordonn\xE9es de l'\xE9l\xE9ment voisin
+ double x = 123456789;//getCoordonnees(eltVoisin).x_;//FAUX
+ double y = 123456789;//getCoordonnees(eltVoisin).y_;//FAUX
+ double distance = Math.sqrt((pointCourant.x - x) * (pointCourant.x - x) + (pointCourant.y - y)
+ * (pointCourant.y - y));
+ if (distanceMaxEntrePoints > distance) {
+ // candidat potentiel
+ // ACHTUNG!! VERIFIER QUE LE t+ deltaT<dureeIntegration si on choisit cette distance
+ if (vitesseY != 0 && (tempsTotal + distance / vitesseY <= dureeIntegration)) {//FIXME pourquoi seulement la vitesse y. Il faut faire sqrt(vx*vx+vy*vy)
+ distanceMaxEntrePoints = distance;
+ voisinChoisi = eltVoisin;
+ }
+ }
+ }
- //on calcul le nouveau temps total
- if(vitesseY !=0)
- tempsTotal+=distanceMaxEntrePoints/vitesseY;
+ // on calcul le nouveau temps total
+ if (vitesseY != 0) tempsTotal += distanceMaxEntrePoints / vitesseY;//FIXME pour calcul le
- //on verifie que l'on n'est pas inactif
- if(oldTempsTotal==tempsTotal ){
- termine=true;
- }else{
+ // on verifie que l'on n'est pas inactif: pas necessaire
+ if (oldTempsTotal == tempsTotal) {
+ termine = true;
+ } else {
- //on a ondc un segment form\xE9 par element courant vers element choisi
- GrPoint pointchoisi=new GrPoint(data_.getGrid().getCoor(voisinChoisi).x,data_.getGrid().getCoor(voisinChoisi).y,0);
+ // on a ondc un segment form\xE9 par element courant vers element choisi
+ GrPoint pointchoisi = new GrPoint(data_.getGrid().getCoor(voisinChoisi).x, data_.getGrid().getCoor(
+ voisinChoisi).y, 0);
- //recherche des intersection entre les points
- Coordinate[] listeCoor=new Coordinate[2];
- listeCoor[0]=new Coordinate(pointCourant.x_,pointCourant.y_);
- listeCoor[1]=new Coordinate(pointchoisi.x_,pointchoisi.y_);
+ // recherche des intersection entre les points
+ Coordinate[] listeCoor = new Coordinate[2];
+ listeCoor[0] = new Coordinate(pointCourant.x, pointCourant.y);//FIXME non on recherche le point le plus eloigne pour savoir sur combien de temps on doit bouge
+
+// listeCoor[1] = new Coordinate(pointchoisi.x, pointchoisi.y);
- LineString ligne=new LineString(listeCoor,new PrecisionModel(),0);
- progression("Recherche des intersections",50);
- EfLineIntersectionsResultsMng res= lineIntersect_.computeForMeshes(ligne, prog_);
+ LineString ligne = new LineString(listeCoor, new PrecisionModel(), 0);//utilse GISGeometryFactory.createSegment
+ progression("Recherche des intersections", 50);
+ EfLineIntersectionsResultsMng res = lineIntersect_.computeForMeshes(ligne, prog_);
+ if (res.isSegmentOut(0)) {
+ // particules est sortie du maillage, le calcul s'arrete
+ termine = true;
+ } else {
+ // recuperationde la nouvelle intersection aui devien courante
+ intersectionCourante = res.getFoundIntersect(0);//Je crois qu'il faut prendre l'intersection 1 car la 0 est le point de d\xE9part
- if(res.isSegmentOut(0)){
- //particules est sortie du maillage, le calcul s'arrete
- termine=true;
- }
- else{
- //recuperationde la nouvelle intersection aui devien courante
- intersectionCourante=res.getFoundIntersect(0);
+ // cette intersection sera automatiquement ajout\xE9e a la liste solution a la prochaine it\xE9ration (premiere
+ // instruction du while)
- // cette intersection sera automatiquement ajout\xE9e a la liste solution a la prochaine it\xE9ration (premiere instruction du while)
+ }
- }
+ }
- }
+ }// fin du while
+ }
+ return listeIntersection_;
+ }
- }//fin du while
-
- }
- return listeIntersection_;
- }
+ /**
+ * Retourne les coordonn\xE9es associ\xE9es a l \xE9l\xE9ment du point FIXME faux
+ *
+ * @param element
+ * @return
+ */
+ // GrPoint getCoordonnees(int element) {
+ // GrPoint point = new GrPoint();
+ // calque_.getIsoLayer().getIsoModel().point(element, point);// FIXME Faux on passe un element et on renvoie un point
+ // !
+ // return point;
+ // }
+ /**
+ * Recherche l'\xE9l\xE9lment englobant pour un point donn\xE9
+ *
+ * @param _prReel
+ * @param grid
+ * @return
+ */
+ public int elementEnglobant(final Coordinate _prReel) {
+ EfGridInterface grid = data_.getGrid();
+ if (grid.getIndex() != null) {
+ final EfIndexVisitorNearestElt visitor = new EfIndexVisitorNearestElt(grid, _prReel.x, _prReel.y, 0);
+ grid.getIndex().query(EfIndexVisitorNearestNode.getEnvelope(_prReel.x, _prReel.y, 0), visitor);
+ return visitor.isIn() ? visitor.getSelected() : -1;
+ } else return -1;
+ }
+ public void buildNeighbor(ProgressionInterface _prog) {
+ if (voisinage_ == null) {
+ voisinage_ = EfNeighborMesh.compute(data_.getGrid(), _prog);
+ }
+ // TODO Auto-generated method stub
+ }
- /**
- * Retourne les coordonn\xE9es associ\xE9es a l \xE9l\xE9ment du point
- * @param element
- * @return
- */
- GrPoint getCoordonnees(int element){
- GrPoint point =new GrPoint();
- calque_.getIsoLayer().getIsoModel().point(element, point);
- return point;
- }
-
+ public EfGridInterface getGrid() {
+ // TODO Auto-generated method stub
+ return data_.getGrid();
+ }
- /**
- * Recherche l'\xE9l\xE9lment englobant pour un point donn\xE9
- * @param _prReel
- * @param grid
- * @return
- */
- public int elementEnglobant(final GrPoint _prReel) {
- EfGridInterface grid=data_.getGrid();
- if (grid.getIndex() != null) {
- final EfIndexVisitorNearestElt visitor = new EfIndexVisitorNearestElt(grid, _prReel.x_, _prReel.y_, 0);
- grid.getIndex().query(EfIndexVisitorNearestNode.getEnvelope(_prReel.x_, _prReel.y_, 0), visitor);
- return visitor.isIn() ? visitor.getSelected() : -1;
- }
- else
- return -1;
- }
+ public EfGridDataInterpolator getGridData() {
+ // TODO le stocker dans un champ prive
+ return new EfGridDataInterpolatorDefault(data_, interpolator_);
+ }
- @Override
- public void buildNeighbor(ProgressionInterface _prog) {
- // TODO Auto-generated method stub
+ public EfNeighborMesh getNeighbor() {
+ return voisinage_;
+ }
- }
-
- @Override
- public EfGridInterface getGrid() {
- // TODO Auto-generated method stub
- return data_.getGrid();
- }
-
- @Override
- public EfGridDataInterpolator getGridData() {
- // TODO Auto-generated method stub
- return null;
- }
-
- @Override
- public EfNeighborMesh getNeighbor() {
- // TODO Auto-generated method stub
- return null;
- }
-
-
-
- }
+}
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
