]> SALOME platform Git repositories - tools/medcoupling.git/blob - src/INTERP_KERNEL/Geometric2D/InterpKernelGeo2DEdge.hxx
Salome HOME
addition of MEDCouplingUMesh::conformize2D to conformize a 2D mesh
[tools/medcoupling.git] / src / INTERP_KERNEL / Geometric2D / InterpKernelGeo2DEdge.hxx
1 // Copyright (C) 2007-2014  CEA/DEN, EDF R&D
2 //
3 // This library is free software; you can redistribute it and/or
4 // modify it under the terms of the GNU Lesser General Public
5 // License as published by the Free Software Foundation; either
6 // version 2.1 of the License, or (at your option) any later version.
7 //
8 // This library is distributed in the hope that it will be useful,
9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
11 // Lesser General Public License for more details.
12 //
13 // You should have received a copy of the GNU Lesser General Public
14 // License along with this library; if not, write to the Free Software
15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
16 //
17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
18 //
19 // Author : Anthony Geay (CEA/DEN)
20
21 #ifndef __INTERPKERNELGEO2DEDGE_HXX__
22 #define __INTERPKERNELGEO2DEDGE_HXX__
23
24 #include "INTERPKERNELDefines.hxx"
25 #include "InterpKernelException.hxx"
26 #include "InterpKernelGeo2DBounds.hxx"
27 #include "InterpKernelGeo2DNode.hxx"
28
29 #include <iostream>
30 #include <vector>
31 #include <list>
32 #include <map>
33
34 namespace INTERP_KERNEL
35 {
36   typedef enum
37     {
38       SEG         = 1,
39       ARC_CIRCLE  = 4,
40       ARC_PARABOL = 8
41     } TypeOfFunction;
42
43   typedef enum
44     {
45       CIRCLE  = 0 ,
46       PARABOL = 1
47     } TypeOfMod4QuadEdge;
48
49   typedef enum
50     {
51       START       = 5,
52       END         = 1,
53       INSIDE      = 2,
54       OUT_BEFORE  = 3,
55       OUT_AFTER   = 4
56     } TypeOfLocInEdge; //see Edge::OFFSET_FOR_TYPEOFLOCINEDGE
57   
58   typedef enum
59     {
60       FULL_IN_1    = 1,
61       FULL_ON_1    = 4,
62       FULL_OUT_1   = 2,
63       FULL_UNKNOWN = 3
64     } TypeOfEdgeLocInPolygon;
65
66   class INTERPKERNEL_EXPORT MergePoints
67   {
68   public:
69     MergePoints();
70
71     //methods called during intersection edge-edge
72     void start1Replaced();
73     void end1Replaced();
74     void start1OnStart2();
75     void start1OnEnd2();
76     void end1OnStart2();
77     void end1OnEnd2();
78     //methods to be called during aggregation
79     bool isStart1(unsigned rk) const;
80     bool isEnd1(unsigned rk) const;
81     bool isStart2(unsigned rk) const;
82     bool isEnd2(unsigned rk) const;
83     void clear();
84     unsigned getNumberOfAssociations() const;
85   private:
86     unsigned _ass1Start1  : 1;
87     unsigned _ass1End1    : 1;
88     unsigned _ass1Start2  : 1;
89     unsigned _ass1End2    : 1;
90     unsigned _ass2Start1  : 1;
91     unsigned _ass2End1    : 1;
92     unsigned _ass2Start2  : 1;
93     unsigned _ass2End2    : 1;
94   };
95
96   class Edge;
97   class ComposedEdge;
98   /*!
99    * This class is in charge to store an intersection point as result of \b non oververlapping edge intersection.
100    * This class manages the cases when intersect element is one of the extrimities of edge1 and/or edge2.
101    */
102   class INTERPKERNEL_EXPORT IntersectElement
103   {
104   public:
105     IntersectElement(double val1, double val2, bool start1, bool end1, bool start2, bool end2, Node *node, const Edge& e1, const Edge& e2, bool keepOrder);
106     IntersectElement(const IntersectElement& other);
107     //! The sort operator is done on the edge 1 \b not edge 2.
108     bool operator<(const IntersectElement& other) const;
109     IntersectElement& operator=(const IntersectElement& other);
110     double getVal1() const { return _chararct_val_for_e1; }
111     double getVal2() const { return _chararct_val_for_e2; }
112     //! idem operator< method except that the orientation is done on edge 2 \b not edge 1.
113     bool isLowerOnOther(const IntersectElement& other) const;
114     unsigned isOnExtrForAnEdgeAndInForOtherEdge() const;
115     void attachLoc() { _node->setLoc(_loc_of_node); }
116     bool isOnMergedExtremity() const;
117     bool isIncludedByBoth() const;
118     void setNode(Node *node) const;
119     void performMerging(MergePoints& commonNode) const;
120     Node *getNodeOnly() const { return _node; }
121     Node *getNodeAndReleaseIt() { Node *tmp=_node; _node=0; return tmp; }
122     ~IntersectElement();
123   private:
124     bool _1S;
125     bool _1E;
126     bool _2S;
127     bool _2E;
128     double _chararct_val_for_e1;
129     double _chararct_val_for_e2;
130     Node *_node;
131     TypeOfLocInPolygon _loc_of_node;
132     const Edge& _e1;
133     const Edge& _e2;
134   public:
135     static const unsigned LIMIT_ALONE = 22;
136     static const unsigned LIMIT_ON = 73;
137     static const unsigned NO_LIMIT = 19;
138   };
139
140   /*!
141    * This abstract interface specifies all the methods to be overloaded of all possibilities edge-intersection.
142    */
143   class INTERPKERNEL_EXPORT EdgeIntersector
144   {
145   protected:
146     //! All non symetric methods are relative to 'e1'.
147     EdgeIntersector(const Edge& e1, const Edge& e2):_e1(e1),_e2(e2) { }
148   public:
149     virtual ~EdgeIntersector() { }
150     virtual bool keepOrder() const = 0;
151     //!to call only if 'areOverlapped' have been set to true when areOverlappedOrOnlyColinears was called
152     virtual bool haveTheySameDirection() const = 0;
153     //!to call only if 'areOverlapped' have been set to true when areOverlappedOrOnlyColinears was called
154     virtual void getPlacements(Node *start, Node *end, TypeOfLocInEdge& whereStart, TypeOfLocInEdge& whereEnd, MergePoints& commonNode) const = 0;
155     //! When true is returned, newNodes should contains at least 1 element. All merging nodes betw _e1 and _e2 extremities must be done.
156     bool intersect(const Bounds *whereToFind, std::vector<Node *>& newNodes, bool& order, MergePoints& commonNode);
157     //! Should be called only once per association.
158     virtual void areOverlappedOrOnlyColinears(const Bounds *whereToFind, bool& obviousNoIntersection, bool& areOverlapped) = 0;
159     //! The size of returned vector is equal to number of potential intersections point. The values are so that their are interpretable by virtual Edge::isIn method.
160     virtual std::list< IntersectElement > getIntersectionsCharacteristicVal() const = 0;
161   protected:
162     void obviousCaseForCurvAbscisse(Node *node, TypeOfLocInEdge& where, MergePoints& commonNode, bool& obvious) const;
163   protected:
164     const Edge& _e1;
165     const Edge& _e2;
166   };
167
168   class INTERPKERNEL_EXPORT SameTypeEdgeIntersector : public EdgeIntersector
169   {
170   protected:
171     SameTypeEdgeIntersector(const Edge& e1, const Edge& e2):EdgeIntersector(e1,e2) { }
172     bool keepOrder() const { return true; }
173   };
174
175   class INTERPKERNEL_EXPORT CrossTypeEdgeIntersector : public EdgeIntersector
176   {
177   protected:
178     CrossTypeEdgeIntersector(const Edge& e1, const Edge& e2, bool reverse):EdgeIntersector(e1,e2),_reverse(reverse) { }
179     bool keepOrder() const { return _reverse; }
180     bool haveTheySameDirection() const { throw Exception("Cross type intersector is not supposed to deal with overlapped in cross type."); }
181     const Edge *myE1() { if(_reverse) return &_e1; else return &_e2; }
182     const Edge *myE2() { if(_reverse) return &_e2; else return &_e1; }
183   protected:
184     //! boolean to inform intersector that unsymetrics treatments reverse of e1 and e2 should be done.
185     bool _reverse;
186   };
187
188   class EdgeLin;
189   class EdgeInfLin;
190   class EdgeArcCircle;
191
192   /*!
193    * Deal with an oriented edge of a polygon.
194    * An Edge is defined with a start node, an end node and an equation of 1D curve.
195    * All other attributes are mutable because they don't impact these 3 invariant attributes.
196    * To be exact start and end nodes can change (address) but their location remain
197    * the same (at precision).
198    */
199   class INTERPKERNEL_EXPORT Edge
200   {
201   public:
202     Edge(Node *start, Node *end, bool direction=true):_cnt(1),_loc(FULL_UNKNOWN) { if(direction) { _start=start; _end=end; } else { _start=end; _end=start; } _start->incrRef(); _end->incrRef(); }
203     Edge(double sX, double sY, double eX, double eY);
204     TypeOfEdgeLocInPolygon getLoc() const { return _loc; }
205     void incrRef() const { _cnt++; }
206     bool decrRef();
207     void initLocs() const { _loc=FULL_UNKNOWN; _start->initLocs(); _end->initLocs(); }
208     void declareOn() const;
209     void declareIn() const;
210     void declareOut() const;
211     const Bounds& getBounds() const { return _bounds; }
212     void fillXfigStreamForLoc(std::ostream& stream) const;
213     Node *getNode(TypeOfLocInEdge where) const { if(where==START) return _start; else if(where==END) return _end; else return 0; }
214     Node *getStartNode() const { return _start; }
215     Node *getEndNode() const { return _end; }
216     void setEndNodeWithoutChange(Node *newEnd);
217     void setStartNodeWithoutChange(Node *newStart);
218     bool changeStartNodeWith(Node *otherStartNode) const;
219     bool changeStartNodeWithAndKeepTrack(Node *otherStartNode, std::vector<Node *>& track) const;
220     bool changeEndNodeWith(Node *otherEndNode) const;
221     bool changeEndNodeWithAndKeepTrack(Node *otherEndNode, std::vector<Node *>& track) const;
222     void addSubEdgeInVector(Node *start, Node *end, ComposedEdge& vec) const;
223     void getNormalVector(double *vectOutput) const;
224     static EdgeIntersector *BuildIntersectorWith(const Edge *e1, const Edge *e2);
225     static Edge *BuildFromXfigLine(std::istream& str);
226     static Edge *BuildEdgeFrom(Node *start, Node *end);
227     template<TypeOfMod4QuadEdge type>
228     static Edge *BuildEdgeFrom(Node *start, Node *middle, Node *end);
229     static Edge *BuildEdgeFrom3Points(const double *start, const double *middle, const double *end);
230     virtual void update(Node *m) = 0;
231     //! returns area between this and axe Ox delimited along Ox by _start and _end.
232     virtual double getAreaOfZone() const = 0;
233     //! apply a similiraty transformation on 'this'
234     virtual void applySimilarity(double xBary, double yBary, double dimChar);
235     //! apply the inverse similiraty transformation on 'this'
236     virtual void unApplySimilarity(double xBary, double yBary, double dimChar);
237     //! return the length of arc. Value is always > 0. !
238     virtual double getCurveLength() const = 0;
239     virtual void getBarycenter(double *bary) const = 0;
240     virtual void getBarycenterOfZone(double *bary) const = 0;
241     virtual void getMiddleOfPoints(const double *p1, const double *p2, double *mid) const = 0;
242     //! Retrieves a point that is owning to this, well placed for IN/OUT detection of this. Typically midlle of this is returned.
243     virtual Node *buildRepresentantOfMySelf() const = 0;
244     //! Given a magnitude specified by sub-type returns if in or not. See getCharactValue method.
245     virtual bool isIn(double characterVal) const = 0;
246     //! With the same magnitude as defined in 'isIn' method perform a compararison. Precondition : val1 and val2 are different and exactly INSIDE this.
247     virtual bool isLower(double val1, double val2) const = 0;
248     //! node is expected to lay on 'this'. It returns a characteristic magnitude usable by isIn method.
249     virtual double getCharactValue(const Node& node) const = 0;
250     //! node is expected to lay on 'this'. It returns a characteristic magnitude between 0 and 1.
251     virtual double getCharactValueBtw0And1(const Node& node) const = 0;
252     //! retrieves the distance to this : The min distance from pt and any point of this.
253     virtual double getDistanceToPoint(const double *pt) const = 0;
254     //! return if node with coords 'coordOfNode' is on this (with precision).
255     virtual bool isNodeLyingOn(const double *coordOfNode) const = 0;
256     virtual TypeOfFunction getTypeOfFunc() const = 0;
257     virtual void dynCastFunction(const EdgeLin * &seg,
258                                  const EdgeArcCircle * &arcSeg) const = 0;
259     bool intersectWith(const Edge *other, MergePoints& commonNode,
260                        ComposedEdge& outVal1, ComposedEdge& outVal2) const;
261     static bool IntersectOverlapped(const Edge *f1, const Edge *f2, EdgeIntersector *intersector, MergePoints& commonNode,
262                                     ComposedEdge& outValForF1, ComposedEdge& outValForF2);
263     static void Interpolate1DLin(const std::vector<double>& distrib1, const std::vector<double>& distrib2,
264                                  std::map<int, std::map<int,double> >& result);
265     virtual void dumpInXfigFile(std::ostream& stream, bool direction, int resolution, const Bounds& box) const = 0;
266     bool isEqual(const Edge& other) const;
267   public:
268     bool sortSubNodesAbs(const double *coo, std::vector<int>& subNodes);
269     void sortIdsAbs(const std::vector<INTERP_KERNEL::Node *>& addNodes, const std::map<INTERP_KERNEL::Node *, int>& mapp1, const std::map<INTERP_KERNEL::Node *, int>& mapp2, std::vector<int>& edgesThis);
270     virtual void fillGlobalInfoAbs(bool direction, const std::map<INTERP_KERNEL::Node *,int>& mapThis, const std::map<INTERP_KERNEL::Node *,int>& mapOther, int offset1, int offset2, double fact, double baryX, double baryY,
271                                    std::vector<int>& edgesThis, std::vector<double>& addCoo, std::map<INTERP_KERNEL::Node *,int> mapAddCoo) const = 0;
272     virtual void fillGlobalInfoAbs2(const std::map<INTERP_KERNEL::Node *,int>& mapThis, const std::map<INTERP_KERNEL::Node *,int>& mapOther, int offset1, int offset2, double fact, double baryX, double baryY,
273                                     std::vector<int>& edgesOther, std::vector<double>& addCoo, std::map<INTERP_KERNEL::Node *,int>& mapAddCoo) const = 0;
274     virtual Edge *buildEdgeLyingOnMe(Node *start, Node *end, bool direction=true) const = 0;
275   protected:
276     Edge():_cnt(1),_loc(FULL_UNKNOWN),_start(0),_end(0) { }
277     virtual ~Edge();
278     static int CombineCodes(TypeOfLocInEdge code1, TypeOfLocInEdge code2);
279     static bool Intersect(const Edge *f1, const Edge *f2, EdgeIntersector *intersector, const Bounds *whereToFind, MergePoints& commonNode,
280                           ComposedEdge& outValForF1, ComposedEdge& outValForF2);
281     //! The code 'code' is built by method combineCodes
282     static bool SplitOverlappedEdges(const Edge *e1, const Edge *e2, Node *nS, Node *nE, bool direction, int code,
283                                      ComposedEdge& outVal1, ComposedEdge& outVal2);
284   protected:
285     mutable unsigned char _cnt;
286     mutable TypeOfEdgeLocInPolygon _loc;
287     Bounds _bounds;
288     Node *_start;
289     Node *_end;
290   protected:
291     //In relation with max possible value of TypeOfLocInEdge.
292     static const int OFFSET_FOR_TYPEOFLOCINEDGE = 8;
293   };
294 }
295
296 #endif