X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FINTERP_KERNEL%2FGeometric2D%2FInterpKernelGeo2DEdge.cxx;h=95bced1da21d0378c4ec3877fcd76674e3076da2;hb=378cb2ebe08f8f4543ef632b2bd5f77fe180f978;hp=8a00bee6ee52ab13890f2485bbf617bcf3314291;hpb=b4b11b30ec3c8c59b9124a2c4efbd4b99039556f;p=tools%2Fmedcoupling.git

diff --git a/src/INTERP_KERNEL/Geometric2D/InterpKernelGeo2DEdge.cxx b/src/INTERP_KERNEL/Geometric2D/InterpKernelGeo2DEdge.cxx
old mode 100644
new mode 100755
index 8a00bee6e..95bced1da
--- a/src/INTERP_KERNEL/Geometric2D/InterpKernelGeo2DEdge.cxx
+++ b/src/INTERP_KERNEL/Geometric2D/InterpKernelGeo2DEdge.cxx
@@ -1,9 +1,9 @@
-// Copyright (C) 2007-2013  CEA/DEN, EDF R&D
+// Copyright (C) 2007-2014  CEA/DEN, EDF R&D
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Lesser General Public
 // License as published by the Free Software Foundation; either
-// version 2.1 of the License.
+// version 2.1 of the License, or (at your option) any later version.
 //
 // This library is distributed in the hope that it will be useful,
 // but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -31,7 +31,7 @@
 using namespace INTERP_KERNEL;
 
 MergePoints::MergePoints():_ass1Start1(0),_ass1End1(0),_ass1Start2(0),_ass1End2(0),
-                           _ass2Start1(0),_ass2End1(0),_ass2Start2(0),_ass2End2(0)
+    _ass2Start1(0),_ass2End1(0),_ass2Start2(0),_ass2End2(0)
 {
 }
 
@@ -163,22 +163,56 @@ unsigned MergePoints::getNumberOfAssociations() const
   return ret;
 }
 
+void MergePoints::PushInMap(int key, int value, std::map<int,int>& mergedNodes)
+{
+  if(key!=-1 && value!=-1)
+    mergedNodes[key]=value;
+}
+
+void MergePoints::updateMergedNodes(int e1Start, int e1End, int e2Start, int e2End, std::map<int,int>& mergedNodes)
+{
+  unsigned subTot(_ass1Start1+_ass1End1+_ass1Start2+_ass1End2);
+  if(subTot!=0)
+    {
+      if(_ass1Start1 && _ass1Start2)
+        PushInMap(e2Start,e1Start,mergedNodes);
+      if(_ass1Start1 && _ass1End2)
+        PushInMap(e2End,e1Start,mergedNodes);
+      if(_ass1End1 && _ass1Start2)
+        PushInMap(e2Start,e1End,mergedNodes);
+      if(_ass1End1 && _ass1End2)
+        PushInMap(e2End,e1End,mergedNodes);
+    }
+  subTot=_ass2Start1+_ass2End1+_ass2Start2+_ass2End2;
+  if(subTot!=0)
+    {
+      if(_ass2Start1 && _ass2Start2)
+        PushInMap(e2Start,e1Start,mergedNodes);
+      if(_ass2Start1 && _ass2End2)
+        PushInMap(e2End,e1Start,mergedNodes);
+      if(_ass2End1 && _ass2Start2)
+        PushInMap(e2Start,e1End,mergedNodes);
+      if(_ass2End1 && _ass2End2)
+        PushInMap(e2End,e1End,mergedNodes);
+    }
+}
+
 IntersectElement::IntersectElement(double val1, double val2, bool start1, bool end1, bool start2, bool end2, Node *node
                                    , const Edge& e1, const Edge& e2, bool keepOrder):_1S(keepOrder?start1:start2),
-                                                                                     _1E(keepOrder?end1:end2),
-                                                                                     _2S(keepOrder?start2:start1),
-                                                                                     _2E(keepOrder?end2:end1),
-                                                                                     _chararct_val_for_e1(keepOrder?val1:val2),
-                                                                                     _chararct_val_for_e2(keepOrder?val2:val1),
-                                                                                     _node(node),_loc_of_node(node->getLoc()),_e1(keepOrder?e1:e2),
-                                                                                     _e2(keepOrder?e2:e1)
+                                       _1E(keepOrder?end1:end2),
+                                       _2S(keepOrder?start2:start1),
+                                       _2E(keepOrder?end2:end1),
+                                       _chararct_val_for_e1(keepOrder?val1:val2),
+                                       _chararct_val_for_e2(keepOrder?val2:val1),
+                                       _node(node),_loc_of_node(node->getLoc()),_e1(keepOrder?e1:e2),
+                                       _e2(keepOrder?e2:e1)
 {
 }
 
 IntersectElement::IntersectElement(const IntersectElement& other):_1S(other._1S),_1E(other._1E),_2S(other._2S),_2E(other._2E),
-                                                                  _chararct_val_for_e1(other._chararct_val_for_e1),
-                                                                  _chararct_val_for_e2(other._chararct_val_for_e2),_node(other._node),
-                                                                  _loc_of_node(other._loc_of_node),_e1(other._e1), _e2(other._e2)
+    _chararct_val_for_e1(other._chararct_val_for_e1),
+    _chararct_val_for_e2(other._chararct_val_for_e2),_node(other._node),
+    _loc_of_node(other._loc_of_node),_e1(other._e1), _e2(other._e2)
 {
   if(_node)
     _node->incrRef();
@@ -302,7 +336,7 @@ bool IntersectElement::isIncludedByBoth() const
 {
   return _e1.isIn(_chararct_val_for_e1) && _e2.isIn(_chararct_val_for_e2);
 }
-  
+
 bool EdgeIntersector::intersect(const Bounds *whereToFind, std::vector<Node *>& newNodes, bool& order, MergePoints& commonNode)
 {
   std::list< IntersectElement > listOfIntesc=getIntersectionsCharacteristicVal();
@@ -358,7 +392,7 @@ bool EdgeIntersector::intersect(const Bounds *whereToFind, std::vector<Node *>&
  * Locates 'node' regarding edge this->_e1. If node is located close to (with distant lt epsilon) start or end point of _e1,
  * 'node' takes its place. In this case 'obvious' is set to true and 'commonNode' stores information of merge point and finally 'where' is set.
  * Furthermore 'node' is declared as ON LIMIT to indicate in locating process that an absolute location computation will have to be done.
- * If 'node' is not close to start or end point of _e1, 'obvious' is set to false and 'commonNode' and 'where' are let unchanged. 
+ * If 'node' is not close to start or end point of _e1, 'obvious' is set to false and 'commonNode' and 'where' are let unchanged.
  */
 void EdgeIntersector::obviousCaseForCurvAbscisse(Node *node, TypeOfLocInEdge& where, MergePoints& commonNode, bool& obvious) const
 {
@@ -438,7 +472,7 @@ void Edge::declareOut() const
 void Edge::fillXfigStreamForLoc(std::ostream& stream) const
 {
   switch(_loc)
-    {
+  {
     case FULL_IN_1:
       stream << '2';//Green
       break;
@@ -450,7 +484,7 @@ void Edge::fillXfigStreamForLoc(std::ostream& stream) const
       break;
     default:
       stream << '0';
-    }
+  }
 }
 
 bool Edge::changeStartNodeWith(Node *otherStartNode) const
@@ -662,7 +696,7 @@ EdgeIntersector *Edge::BuildIntersectorWith(const Edge *e1, const Edge *e2)
   e2->dynCastFunction(tmp1,tmp2);
   type1|=type2;
   switch(type1)
-    {
+  {
     case 1:// Intersection seg/seg
       ret=new SegSegIntersector((const EdgeLin &)(*e1),(const EdgeLin &)(*e2));
       break;
@@ -675,7 +709,7 @@ EdgeIntersector *Edge::BuildIntersectorWith(const Edge *e1, const Edge *e2)
     default:
       //Should never happen
       throw Exception("A non managed association of edge has been detected. Go work for intersection computation implementation.");
-    }
+  }
   return ret;
 }
 
@@ -755,48 +789,49 @@ bool Edge::SplitOverlappedEdges(const Edge *e1, const Edge *e2, Node *nS, Node *
 {
   Edge *tmp;
   switch(code)
-    {
+  {
     case OUT_BEFORE*OFFSET_FOR_TYPEOFLOCINEDGE+START:      // OUT_BEFORE - START
     case OUT_BEFORE*OFFSET_FOR_TYPEOFLOCINEDGE+OUT_BEFORE: // OUT_BEFORE - OUT_BEFORE
     case OUT_AFTER*OFFSET_FOR_TYPEOFLOCINEDGE+OUT_AFTER:   // OUT_AFTER - OUT_AFTER
     case END*OFFSET_FOR_TYPEOFLOCINEDGE+OUT_AFTER:         // END - OUT_AFTER
     case END*OFFSET_FOR_TYPEOFLOCINEDGE+START:             // END - START
-      return false;
+    return false;
     case INSIDE*OFFSET_FOR_TYPEOFLOCINEDGE+OUT_AFTER:      // INSIDE - OUT_AFTER
-      outVal1.pushBack(e1->buildEdgeLyingOnMe(e1->getStartNode(),nS,true));
-      tmp=e1->buildEdgeLyingOnMe(nS,e1->getEndNode()); tmp->incrRef();
-      outVal1.pushBack(tmp);
-      outVal2.resize(2);
-      outVal2.setValueAt(direction?0:1,tmp,direction); tmp->declareOn();
-      outVal2.setValueAt(direction?1:0,e1->buildEdgeLyingOnMe(e1->getEndNode(),nE,direction));
-      return true;
+    outVal1.pushBack(e1->buildEdgeLyingOnMe(e1->getStartNode(),nS,true));
+    tmp=e1->buildEdgeLyingOnMe(nS,e1->getEndNode()); tmp->incrRef();
+    outVal1.pushBack(tmp);
+    outVal2.resize(2);
+    outVal2.setValueAt(direction?0:1,tmp,direction); tmp->declareOn();
+    outVal2.setValueAt(direction?1:0,e1->buildEdgeLyingOnMe(e1->getEndNode(),nE,direction));
+    return true;
     case INSIDE*OFFSET_FOR_TYPEOFLOCINEDGE+INSIDE:         // INSIDE - INSIDE
-      {
-        if(!e2->isIn(e2->getCharactValue(*(e1->getStartNode()))))
-          {
-            e2->incrRef(); e2->incrRef();
-            outVal1.resize(3);
-            outVal1.setValueAt(0,e1->buildEdgeLyingOnMe(e1->getStartNode(),nS));
-            outVal1.setValueAt(1,const_cast<Edge*>(e2),direction);
-            outVal1.setValueAt(2,e1->buildEdgeLyingOnMe(nE,e1->getEndNode()));
-            outVal2.pushBack(const_cast<Edge*>(e2)); e2->declareOn();
-            return true;
-          }
-        else
-          {
-            outVal1.resize(3);
-            outVal2.resize(3);
-            tmp=e1->buildEdgeLyingOnMe(e1->getStartNode(),nE); tmp->incrRef(); tmp->declareOn();
-            outVal1.setValueAt(0,tmp,true); outVal2.setValueAt(direction?2:0,tmp,direction);
-            outVal1.setValueAt(1,e1->buildEdgeLyingOnMe(nE,nS));
-            tmp=e1->buildEdgeLyingOnMe(nS,e1->getEndNode()); tmp->incrRef(); tmp->declareOn();
-            outVal1.setValueAt(2,tmp,true); outVal2.setValueAt(direction?0:2,tmp,direction);
-            tmp=e1->buildEdgeLyingOnMe(e1->getEndNode(),e1->getStartNode());
-            outVal2.setValueAt(1,tmp,direction);
-            return true;
-          }
-      }
+    {
+      if(!e2->isIn(e2->getCharactValue(*(e1->getStartNode()))))
+        {
+          e2->incrRef(); e2->incrRef();
+          outVal1.resize(3);
+          outVal1.setValueAt(0,e1->buildEdgeLyingOnMe(e1->getStartNode(),nS));
+          outVal1.setValueAt(1,const_cast<Edge*>(e2),direction);
+          outVal1.setValueAt(2,e1->buildEdgeLyingOnMe(nE,e1->getEndNode()));
+          outVal2.pushBack(const_cast<Edge*>(e2)); e2->declareOn();
+          return true;
+        }
+      else
+        {
+          outVal1.resize(3);
+          outVal2.resize(3);
+          tmp=e1->buildEdgeLyingOnMe(e1->getStartNode(),nE); tmp->incrRef(); tmp->declareOn();
+          outVal1.setValueAt(0,tmp,true); outVal2.setValueAt(direction?2:0,tmp,direction);
+          outVal1.setValueAt(1,e1->buildEdgeLyingOnMe(nE,nS));
+          tmp=e1->buildEdgeLyingOnMe(nS,e1->getEndNode()); tmp->incrRef(); tmp->declareOn();
+          outVal1.setValueAt(2,tmp,true); outVal2.setValueAt(direction?0:2,tmp,direction);
+          tmp=e1->buildEdgeLyingOnMe(e1->getEndNode(),e1->getStartNode());
+          outVal2.setValueAt(1,tmp,direction);
+          return true;
+        }
+    }
     case OUT_BEFORE*OFFSET_FOR_TYPEOFLOCINEDGE+INSIDE:     // OUT_BEFORE - INSIDE
+    {
       tmp=e1->buildEdgeLyingOnMe(e1->getStartNode(),nE); tmp->incrRef();
       outVal1.pushBack(tmp);
       outVal1.pushBack(e1->buildEdgeLyingOnMe(nE,e1->getEndNode()));
@@ -804,7 +839,9 @@ bool Edge::SplitOverlappedEdges(const Edge *e1, const Edge *e2, Node *nS, Node *
       outVal2.setValueAt(direction?0:1,e1->buildEdgeLyingOnMe(nS,e1->getStartNode(),direction));
       outVal2.setValueAt(direction?1:0,tmp,direction); tmp->declareOn();
       return true;
+    }
     case OUT_BEFORE*OFFSET_FOR_TYPEOFLOCINEDGE+OUT_AFTER:  // OUT_BEFORE - OUT_AFTER
+    {
       e1->incrRef(); e1->incrRef();
       outVal1.pushBack(const_cast<Edge*>(e1));
       outVal2.resize(3);
@@ -812,38 +849,50 @@ bool Edge::SplitOverlappedEdges(const Edge *e1, const Edge *e2, Node *nS, Node *
       outVal2.setValueAt(1,const_cast<Edge*>(e1),direction); e1->declareOn();
       outVal2.setValueAt(direction?2:0,e1->buildEdgeLyingOnMe(e1->getEndNode(),nE,direction));
       return true;
+    }
     case START*OFFSET_FOR_TYPEOFLOCINEDGE+END:             // START - END
+    {
       e1->incrRef(); e1->incrRef();
       outVal1.pushBack(const_cast<Edge*>(e1));
       outVal2.pushBack(const_cast<Edge*>(e1),direction); e1->declareOn();
       return true;
+    }
     case START*OFFSET_FOR_TYPEOFLOCINEDGE+OUT_AFTER:       // START - OUT_AFTER
+    {
       e1->incrRef(); e1->incrRef();
       outVal1.pushBack(const_cast<Edge*>(e1));
       outVal2.resize(2);
       outVal2.setValueAt(direction?0:1,const_cast<Edge*>(e1),direction); e1->declareOn();
       outVal2.setValueAt(direction?1:0,e1->buildEdgeLyingOnMe(e1->getEndNode(),nE,direction));
       return true;
+    }
     case INSIDE*OFFSET_FOR_TYPEOFLOCINEDGE+END:            // INSIDE - END
+    {
       e2->incrRef(); e2->incrRef();
       outVal1.pushBack(e1->buildEdgeLyingOnMe(e1->getStartNode(),nS,true));
       outVal1.pushBack(const_cast<Edge*>(e2),direction);
       outVal2.pushBack(const_cast<Edge*>(e2)); e2->declareOn();
       return true;
+    }
     case OUT_BEFORE*OFFSET_FOR_TYPEOFLOCINEDGE+END:        // OUT_BEFORE - END
+    {
       e1->incrRef(); e1->incrRef();
       outVal1.pushBack(const_cast<Edge*>(e1));
       outVal2.resize(2);
       outVal2.setValueAt(direction?0:1,e1->buildEdgeLyingOnMe(nS,e1->getStartNode(),direction));
       outVal2.setValueAt(direction?1:0,const_cast<Edge*>(e1),direction); e1->declareOn();
       return true;
+    }
     case START*OFFSET_FOR_TYPEOFLOCINEDGE+INSIDE:          // START - INSIDE
+    {
       e2->incrRef(); e2->incrRef();
       outVal1.pushBack(const_cast<Edge*>(e2),direction);
       outVal1.pushBack(e1->buildEdgeLyingOnMe(nE,e1->getEndNode()));
       outVal2.pushBack(const_cast<Edge*>(e2)); e2->declareOn();
       return true;
+    }
     case INSIDE*OFFSET_FOR_TYPEOFLOCINEDGE+START:          // INSIDE - START
+    {
       outVal1.resize(2);
       outVal2.resize(2);
       tmp=e1->buildEdgeLyingOnMe(nS,e1->getEndNode()); tmp->incrRef(); tmp->declareOn();
@@ -852,7 +901,9 @@ bool Edge::SplitOverlappedEdges(const Edge *e1, const Edge *e2, Node *nS, Node *
       outVal2.setValueAt(direction?0:1,tmp,direction);
       outVal2.setValueAt(direction?1:0,e1->buildEdgeLyingOnMe(e1->getEndNode(),nE,direction));
       return true;
+    }
     case END*OFFSET_FOR_TYPEOFLOCINEDGE+INSIDE:            // END - INSIDE
+    {
       outVal1.resize(2);
       outVal2.resize(2);
       tmp=e1->buildEdgeLyingOnMe(e1->getStartNode(),nE); tmp->incrRef(); tmp->declareOn();
@@ -861,9 +912,10 @@ bool Edge::SplitOverlappedEdges(const Edge *e1, const Edge *e2, Node *nS, Node *
       outVal2.setValueAt(direction?0:1,e1->buildEdgeLyingOnMe(e1->getEndNode(),e1->getStartNode(),direction));
       outVal2.setValueAt(direction?1:0,tmp,direction);
       return true;
+    }
     default:
       throw Exception("Unexpected situation of overlapping edges : internal error occurs ! ");
-    }
+  }
 }
 
 bool Edge::isEqual(const Edge& other) const
@@ -876,6 +928,49 @@ inline bool eqpair(const std::pair<double,Node *>& p1, const std::pair<double,No
   return fabs(p1.first-p2.first)<QUADRATIC_PLANAR::_precision;
 }
 
+/**
+ * This method takes in input nodes in \a subNodes (using \a coo)
+ *
+ * \param [in,out] subNodes to be sorted
+ * \return true if a reordering was necessary false if not.
+ */
+bool Edge::sortSubNodesAbs(const double *coo, std::vector<int>& subNodes)
+{
+  Bounds b;
+  b.prepareForAggregation();
+  b.aggregate(getBounds());
+  double xBary,yBary;
+  double dimChar(b.getCaracteristicDim());
+  b.getBarycenter(xBary,yBary);
+  applySimilarity(xBary,yBary,dimChar);
+  _start->applySimilarity(xBary,yBary,dimChar);
+  _end->applySimilarity(xBary,yBary,dimChar);
+  //
+  std::size_t sz(subNodes.size()),i(0);
+  std::vector< std::pair<double,Node *> > an2(sz);
+  std::map<Node *, int> m;
+  for(std::vector<int>::const_iterator it=subNodes.begin();it!=subNodes.end();it++,i++)
+    {
+      Node *n(new Node(coo[2*(*it)],coo[2*(*it)+1]));
+      n->applySimilarity(xBary,yBary,dimChar);
+      m[n]=*it;
+      an2[i]=std::pair<double,Node *>(getCharactValueBtw0And1(*n),n);
+    }
+  std::sort(an2.begin(),an2.end());
+  //
+  bool ret(false);
+  for(i=0;i<sz;i++)
+    {
+      int id(m[an2[i].second]);
+      if(id!=subNodes[i])
+        { subNodes[i]=id; ret=true; }
+    }
+  //
+  for(std::map<INTERP_KERNEL::Node *,int>::const_iterator it2=m.begin();it2!=m.end();it2++)
+    (*it2).first->decrRef();
+  return ret;
+}
+
 /**
  * Sort nodes so that they all lie consecutively on the edge that has been cut.
  */