Integration of OCCT 6.5.0 from SVN
[occt.git] / src / GGraphic2d / GGraphic2d_SetOfCurves.cxx
1 #include <GGraphic2d_SetOfCurves.ixx>
2 #include <BndLib_Add2dCurve.hxx>
3 #include <Bnd_Box2d.hxx>
4 #include <Geom2dAdaptor_Curve.hxx>
5 #include <TColgp_Array1OfPnt2d.hxx>
6 #include <Geom2d_BezierCurve.hxx>
7 #include <Geom2d_BSplineCurve.hxx>
8 #include <Geom2d_Line.hxx>
9 #include <Geom2d_Circle.hxx>
10 #include <Geom2d_Ellipse.hxx>
11 #include <Geom2d_Parabola.hxx>
12 #include <Geom2d_Hyperbola.hxx>
13 #include <Geom2d_TrimmedCurve.hxx>
14 #include <Geom2d_OffsetCurve.hxx>
15 #include <GCPnts_UniformDeflection.hxx>
16 #include <gp_Pnt2d.hxx>
17 #include <gp_Dir2d.hxx>
18 #include <gp_Circ2d.hxx>
19 #include <gp_Elips2d.hxx>
20 #include <gp_Parab2d.hxx>
21 #include <gp_Hypr2d.hxx>
22
23 #include <gp_Pnt.hxx>
24 #include <TShort_Array1OfShortReal.hxx>
25 #include <Geom2dAPI_ProjectPointOnCurve.hxx>
26 #include <Standard_ErrorHandler.hxx>
27
28 #define G002
29 #define VERTEXMARKER 2
30 #define DEFAULTMARKERSIZE 3.0
31
32 GGraphic2d_SetOfCurves::GGraphic2d_SetOfCurves (
33         const Handle(Graphic2d_GraphicObject)& aGraphicObject)
34
35   : Graphic2d_Line (aGraphicObject) {
36
37 }
38
39 void GGraphic2d_SetOfCurves::Add (const Handle(Geom2d_Curve) &aCurve)
40 {
41         Bnd_Box2d Box;
42         BndLib_Add2dCurve::Add(Geom2dAdaptor_Curve(aCurve),0.,Box);
43         Standard_Real Xmin, Ymin, Xmax, Ymax;
44         Box.Get( Xmin, Ymin, Xmax, Ymax);
45         Standard_ShortReal minX = Standard_ShortReal(Xmin);
46         Standard_ShortReal minY = Standard_ShortReal(Ymin);
47         Standard_ShortReal maxX = Standard_ShortReal(Xmax);
48         Standard_ShortReal maxY = Standard_ShortReal(Ymax);
49         myMinX  = Min(myMinX,minX);
50         myMinY  = Min(myMinY,minY);
51         myMaxX  = Max(myMaxX,maxX);
52         myMaxY  = Max(myMaxY,maxY);
53
54         myCurves.Append(aCurve);
55 }
56
57 Standard_Integer GGraphic2d_SetOfCurves::Length () const {
58    return myCurves.Length();
59 }
60
61 Handle(Geom2d_Curve) GGraphic2d_SetOfCurves::Values(const Standard_Integer aRank) const {
62
63         if( aRank < 1 || aRank > myCurves.Length() ) 
64                 Standard_OutOfRange::Raise
65                         ("the curve rank is out of bounds in the set");
66
67         return myCurves.Value(aRank);
68 }
69
70 void GGraphic2d_SetOfCurves::Draw (const Handle(Graphic2d_Drawer)& aDrawer) {
71 //Standard_Integer i,length = myCurves.Length(),bufferize = 1;
72  Standard_Integer length = myCurves.Length(), bufferize = 1;
73  Standard_Boolean IsIn = Standard_False;
74  Standard_ShortReal minX,minY,maxX,maxY;
75  Standard_Real Xmin,Ymin,Xmax,Ymax;
76
77  if( length <= 0 ) return ;
78
79  gp_GTrsf2d aTrsf = myGOPtr->Transform ();
80  
81   if (! myGOPtr->IsTransformed ())
82     IsIn = aDrawer->IsIn (myMinX,myMaxX,myMinY,myMaxY);
83   else {
84     MinMax(minX,maxX,minY,maxY);
85     IsIn = aDrawer->IsIn (minX,maxX,minY,maxY);
86   }
87
88   if ( IsIn ) {
89     Standard_ShortReal Def;
90     Standard_ShortReal Coeff;
91     Aspect_TypeOfDeflection Type;
92     Standard_Boolean Controll = Standard_True;
93     Handle(Geom2d_Curve) aCurve;
94     Standard_Integer i,typeindex = TypeIndex();
95
96     aDrawer->DrawPrecision(Def,Coeff,Type);
97     DrawLineAttrib(aDrawer);
98     for( i=1 ; i<=length ; i++ ) {
99       aCurve = myCurves.Value(i);
100
101       if (Type == Aspect_TOD_RELATIVE) {
102         Bnd_Box2d Box;
103         BndLib_Add2dCurve::Add(Geom2dAdaptor_Curve(aCurve),0.,Box);
104         Box.Get( Xmin,Ymin,Xmax,Ymax );
105         Def = Standard_ShortReal( (Abs(Xmax-Xmin) + Abs(Ymax-Ymin) ) * Coeff);
106       }
107
108       Geom2dAdaptor_Curve GAC(aCurve);
109       GCPnts_UniformDeflection UD(GAC,Def,Controll);
110       if(UD.IsDone()) {
111         Standard_Integer j,nbp = UD.NbPoints();
112         gp_Pnt p2;
113         Standard_Real x,y,z;
114         Standard_ShortReal x1=0,y1=0,x2,y2;
115         for (j=1; j<=nbp; j++) {
116           p2 = UD.Value(j);
117           p2.Coord(x,y,z);
118           if (myGOPtr->IsTransformed ()) {
119             aTrsf.Transforms(x, y);
120           }
121           if( typeindex > 0 ) {
122             if( j > 1 ) {
123               if( j < nbp ) bufferize = 0;
124               else          bufferize = -1;
125             } else {
126               bufferize = nbp;
127             }
128           aDrawer->MapPolylineFromTo( Standard_ShortReal(x), Standard_ShortReal(y), bufferize);
129           } else {
130             if( j > 1 ) {
131               if( (i == length) && (j == nbp) ) bufferize = -1;
132               x2 = Standard_ShortReal(x); y2 = Standard_ShortReal(y);
133           aDrawer->MapSegmentFromTo(x1,y1,x2,y2,bufferize);
134               x1 = x2; y1 = y2;
135               bufferize = 0; 
136             } else {
137               x1 = Standard_ShortReal(x); y1 = Standard_ShortReal(y);
138             }
139           }
140         }
141       }
142     }
143   }
144 }
145
146 #ifdef G002
147
148 void GGraphic2d_SetOfCurves::DrawElement( const Handle(Graphic2d_Drawer)& aDrawer,
149                                           const Standard_Integer anIndex ) {
150
151  Standard_Integer length = myCurves.Length(), bufferize = 1;
152  Standard_Boolean IsIn = Standard_False;
153  Standard_ShortReal minX,minY,maxX,maxY;
154  Standard_Real Xmin,Ymin,Xmax,Ymax;
155
156  if ( length <= 0 ) return ;
157
158  gp_GTrsf2d aTrsf = myGOPtr->Transform ();
159  
160  if ( ! myGOPtr->IsTransformed() )
161     IsIn = aDrawer->IsIn( myMinX,myMaxX,myMinY,myMaxY );
162  else {
163     MinMax(minX,maxX,minY,maxY);
164     IsIn = aDrawer->IsIn (minX,maxX,minY,maxY);
165   }
166
167   if ( IsIn ) {
168
169    if ( anIndex > 0 && anIndex <= length ) { 
170
171     Standard_ShortReal Def, Coeff;
172     Aspect_TypeOfDeflection Type;
173     Standard_Boolean Controll = Standard_True;
174     Handle(Geom2d_Curve) aCurve;
175     Standard_Integer typeindex = TypeIndex();
176
177     aDrawer->DrawPrecision( Def, Coeff, Type );
178     DrawLineAttrib( aDrawer );
179     aCurve = myCurves.Value( anIndex );
180
181     if ( Type == Aspect_TOD_RELATIVE ) {
182       Bnd_Box2d Box;
183       BndLib_Add2dCurve::Add(Geom2dAdaptor_Curve(aCurve),0.,Box);
184       Box.Get( Xmin,Ymin,Xmax,Ymax  );
185       Def = Standard_ShortReal( (Abs(Xmax-Xmin) + Abs(Ymax-Ymin) ) * Coeff);
186     }
187
188     Geom2dAdaptor_Curve GAC(aCurve);
189     GCPnts_UniformDeflection UD(GAC,Def,Controll);
190     if ( UD.IsDone() ) {
191       Standard_Integer j,nbp = UD.NbPoints();
192       gp_Pnt p2;
193       Standard_Real x,y,z;
194       Standard_ShortReal x1=0,y1=0,x2,y2;
195       for ( j = 1; j <= nbp; j++ ) {
196           p2 = UD.Value( j );
197           p2.Coord( x, y, z );
198           if ( myGOPtr->IsTransformed() ) {
199             aTrsf.Transforms (x, y);
200           }
201               if ( typeindex > 0 ) {
202                 if ( j > 1 ) {
203               bufferize = ( j < nbp ) ? 0 : -1;
204             } else {
205                    bufferize = nbp;
206             }
207             aDrawer->MapPolylineFromTo( Standard_ShortReal(x), Standard_ShortReal(y), bufferize );
208           } else {
209                 if ( j > 1 ) {
210                  if ( ( anIndex == length ) && (j == nbp) ) 
211                  bufferize = -1;
212                  x2 = Standard_ShortReal(x); y2 = Standard_ShortReal(y);
213              aDrawer->MapSegmentFromTo( x1, y1, x2, y2, bufferize );
214                  x1 = x2; y1 = y2;
215                  bufferize = 0; 
216             } else {
217                  x1 = Standard_ShortReal(x); y1 = Standard_ShortReal(y);
218             }
219           }
220       } // end for
221     }
222   }
223  
224  } // end if IsIn
225 }
226
227 void GGraphic2d_SetOfCurves::DrawVertex( const Handle(Graphic2d_Drawer)& aDrawer,
228                                          const Standard_Integer anIndex ) {
229
230  Standard_Integer length = myCurves.Length();
231  Standard_Boolean IsIn = Standard_False;
232  Standard_ShortReal minX,minY,maxX,maxY;
233
234  if ( length <= 0 ) return ;
235
236  if ( ! myGOPtr->IsTransformed() )
237     IsIn = aDrawer->IsIn( myMinX,myMaxX,myMinY,myMaxY );
238  else {
239     MinMax(minX,maxX,minY,maxY);
240     IsIn = aDrawer->IsIn (minX,maxX,minY,maxY);
241   }
242
243   if ( IsIn ) {
244
245    if ( anIndex > 0 && anIndex <= 2*length ) { 
246       
247       DrawMarkerAttrib (aDrawer);
248       Handle(Geom2d_Curve) aCurve; 
249       Standard_Real theParam; 
250       if ( anIndex <= length ) { 
251        aCurve = myCurves.Value( anIndex );
252        theParam = aCurve->FirstParameter();
253       } else {
254        aCurve = myCurves.Value( anIndex - length);
255        theParam = aCurve->LastParameter();
256       }
257       gp_Pnt2d thePnt = aCurve->Value(theParam);
258       Standard_ShortReal a = Standard_ShortReal(thePnt.X()),
259                          b = Standard_ShortReal(thePnt.Y());
260       if ( myGOPtr->IsTransformed() ) {
261         gp_GTrsf2d aTrsf = myGOPtr->Transform ();
262         Standard_Real a1, b1;
263         a1 = Standard_Real(a);
264         b1 = Standard_Real(b);
265         aTrsf.Transforms( a1, b1 );
266         a = Standard_ShortReal( a1 );
267         b = Standard_ShortReal( b1 );
268       } 
269       aDrawer->MapMarkerFromTo( VERTEXMARKER, a, b,
270                         DEFAULTMARKERSIZE,DEFAULTMARKERSIZE,0.0);
271    } 
272   } // end if IsIn
273 }
274
275 #endif
276
277 Standard_Boolean GGraphic2d_SetOfCurves::Pick( 
278                       const Standard_ShortReal X,
279                       const Standard_ShortReal Y,
280                       const Standard_ShortReal aPrecision,
281                       const Handle(Graphic2d_Drawer)& /*aDrawer*/) {
282
283  Standard_Integer i,length = myCurves.Length();
284  //Standard_ShortReal SRX = X, SRY = Y;
285  static Standard_ShortReal SRX , SRY ;
286  SRX = X;
287  SRY = Y;
288  //Standard_Boolean isPicked = Standard_False;
289   
290  if ( (length > 0) && IsInMinMax (X, Y, aPrecision)) {
291   if (myGOPtr->IsTransformed ()) {
292     gp_GTrsf2d aTrsf = (myGOPtr->Transform()).Inverted();
293     Standard_Real RX = Standard_Real( SRX ), RY = Standard_Real( SRY );
294     aTrsf.Transforms( RX, RY );
295     SRX = Standard_ShortReal( RX ); SRY = Standard_ShortReal( RY );
296    }
297    try {
298      OCC_CATCH_SIGNALS
299       Handle(Geom2d_Curve) aCurve;
300       for ( i = 1 ; i <= length; i++ ) {
301         aCurve = myCurves.Value(i);
302         Standard_Real FParam = aCurve->FirstParameter(), 
303                       LParam = aCurve->LastParameter();
304         gp_Pnt2d FP = aCurve->Value(FParam), 
305                  LP = aCurve->Value(LParam);
306         Geom2dAPI_ProjectPointOnCurve PC(gp_Pnt2d(SRX, SRY),
307                                      aCurve,
308                                      FParam,
309                                      LParam );
310         if ( PC.NbPoints() > 0 ) {
311           gp_Pnt2d P = PC.NearestPoint();
312
313 #ifdef G002
314
315           if ( ( Abs( SRX - P.X() ) +  Abs( SRY - P.Y() ) ) < aPrecision ) {
316             SetPickedIndex( i );
317             return Standard_True;
318           } else if ( Graphic2d_Primitive::IsOn( SRX, SRY, 
319               Standard_ShortReal(FP.X()), Standard_ShortReal(FP.Y()), aPrecision) ) {
320             SetPickedIndex( -i );
321             return Standard_True;
322           } else if ( Graphic2d_Primitive::IsOn( SRX, SRY, 
323               Standard_ShortReal(LP.X()), Standard_ShortReal(LP.Y()), aPrecision) ) {
324             SetPickedIndex( -i - length );
325             return Standard_True;
326           }
327 #else
328           if ( ( Abs( SRX - P.X() ) +  Abs( SRY - P.Y() ) ) < aPrecision ) {
329                 myPickedIndex = i;
330             return Standard_True;
331           }
332 #endif
333         } // end if NbPoints() > 0
334       } // end for
335     } catch( Standard_Failure )  {
336       return Standard_False;
337     }
338   }
339
340   return Standard_False;
341  
342 }
343
344 void GGraphic2d_SetOfCurves::Save(Aspect_FStream& aFStream) const
345 {
346         int i,lngth = Length();
347         if ( ! lngth ) return;
348
349         *aFStream << "GGraphic2d_SetOfCurves" << endl;
350         *aFStream << lngth << endl;     
351
352
353         Handle(Geom2d_Curve) myCurve;
354
355         for ( i = 1; i <= lngth; i++ ) {
356
357         myCurve = myCurves.Value( i );
358
359         if ( myCurve->IsKind(STANDARD_TYPE(Geom2d_Line)) ) {
360
361         Handle(Geom2d_Line) theLine = Handle(Geom2d_Line)::DownCast( myCurve );
362         gp_Dir2d tDir = theLine->Direction();
363         gp_Pnt2d tPnt = theLine->Location();
364
365         *aFStream << "Geom2d_Line" << endl;
366         *aFStream << tDir.X() << ' ' << tDir.Y() << endl;
367         *aFStream << tPnt.X() << ' ' << tPnt.Y() << endl;
368
369         } else if ( myCurve->IsKind(STANDARD_TYPE(Geom2d_Circle)) ) {
370
371         Handle(Geom2d_Circle) theCirc = Handle(Geom2d_Circle)::DownCast( myCurve );
372         gp_Circ2d tCirc  = theCirc->Circ2d();
373         gp_Ax22d tAx22d = tCirc.Axis();
374         gp_Pnt2d tLoc  = tAx22d.Location();
375         gp_Dir2d tDirX = tAx22d.XDirection(),
376                tDirY = tAx22d.YDirection();
377
378         Standard_Real tRad = tCirc.Radius();
379
380         *aFStream << "Geom2d_Circle" << endl;
381         *aFStream << tLoc.X() << ' ' << tLoc.Y() << endl;
382         *aFStream << tDirX.X() << ' ' << tDirX.Y() << endl;
383         *aFStream << tDirY.X() << ' ' << tDirY.Y() << endl;
384         *aFStream << tRad << endl;
385
386         } else if ( myCurve->IsKind(STANDARD_TYPE(Geom2d_Parabola)) ) {
387
388         Handle(Geom2d_Parabola) theParab = Handle(Geom2d_Parabola)::DownCast( myCurve );
389         gp_Parab2d tParab = theParab->Parab2d();
390         gp_Ax22d tAx22d = tParab.Axis();
391         gp_Pnt2d tLoc  = tAx22d.Location();
392         gp_Dir2d tDirX = tAx22d.XDirection(),
393                 tDirY = tAx22d.YDirection();
394
395         Standard_Real tFocal = theParab->Focal();
396
397         *aFStream << "Geom2d_Parabola" << endl;
398         *aFStream << tLoc.X() << ' ' << tLoc.Y() << endl;
399         *aFStream << tDirX.X() << ' ' << tDirX.Y() << endl;
400         *aFStream << tDirY.X() << ' ' << tDirY.Y() << endl;
401         *aFStream << tFocal << endl;
402
403         } else if ( myCurve->IsKind(STANDARD_TYPE(Geom2d_Ellipse)) ) {
404         Handle(Geom2d_Ellipse) theEllipse = Handle(Geom2d_Ellipse)::DownCast(myCurve);
405         gp_Elips2d tElips = theEllipse->Elips2d();
406         Standard_Real tMin = tElips.MinorRadius(),
407                      tMaj = tElips.MajorRadius();
408         gp_Ax22d tAx22d = tElips.Axis();
409         gp_Pnt2d tLoc  = tAx22d.Location();
410         gp_Dir2d tDirX = tAx22d.XDirection(),
411                 tDirY = tAx22d.YDirection();
412
413         *aFStream << "Geom2d_Ellipse" << endl;
414
415         *aFStream << tMin << ' ' << tMaj << endl;
416         *aFStream << tLoc.X() << ' ' << tLoc.Y() << endl;
417         *aFStream << tDirX.X() << ' ' << tDirX.Y() << endl;
418         *aFStream << tDirY.X() << ' ' << tDirY.Y() << endl;
419
420         } else if ( myCurve->IsKind(STANDARD_TYPE(Geom2d_Hyperbola)) ) {
421
422         Handle(Geom2d_Hyperbola) theHypr = Handle(Geom2d_Hyperbola)::DownCast(myCurve);
423         gp_Hypr2d tHypr = theHypr->Hypr2d();
424         Standard_Real tMin = tHypr.MinorRadius(),
425                       tMaj = tHypr.MajorRadius();
426         gp_Ax22d tAx22d = tHypr.Axis();
427         gp_Pnt2d tLoc  = tAx22d.Location();
428         gp_Dir2d tDirX = tAx22d.XDirection(),
429                  tDirY = tAx22d.YDirection();
430
431         *aFStream << "Geom2d_Hyperbola" << endl;
432
433         *aFStream << tMin << ' ' << tMaj << endl;
434         *aFStream << tLoc.X() << ' ' << tLoc.Y() << endl;
435         *aFStream << tDirX.X() << ' ' << tDirX.Y() << endl;
436         *aFStream << tDirY.X() << ' ' << tDirY.Y() << endl;
437
438         } else if ( myCurve->IsKind(STANDARD_TYPE(Geom2d_BezierCurve)) ) {
439
440         Handle(Geom2d_BezierCurve) theBC = Handle(Geom2d_BezierCurve)::DownCast(myCurve);
441         Standard_Integer nbPoles = theBC->NbPoles();
442         TColgp_Array1OfPnt2d tpoles( 1, nbPoles );
443         theBC->Poles( tpoles );
444         *aFStream << "Geom2d_BezierCurve" << endl;
445
446         for ( i = 1; i <= nbPoles; i++ ) 
447           *aFStream << tpoles(i).X() << ' ' << tpoles(i).Y() << endl;
448
449         } else if ( myCurve->IsKind(STANDARD_TYPE(Geom2d_BSplineCurve)) ) {
450         Handle(Geom2d_BSplineCurve) theBSC = Handle(Geom2d_BSplineCurve)::DownCast(myCurve);
451
452         } else if ( myCurve->IsKind(STANDARD_TYPE(Geom2d_OffsetCurve)) ) {
453         Handle(Geom2d_OffsetCurve) theOC = Handle(Geom2d_OffsetCurve)::DownCast(myCurve);
454
455         } else if ( myCurve->IsKind(STANDARD_TYPE(Geom2d_TrimmedCurve)) ) {    
456         Handle(Geom2d_TrimmedCurve) theTC = Handle(Geom2d_TrimmedCurve)::DownCast(myCurve);
457         }
458
459         } // end for 
460         Graphic2d_Line::Save(aFStream);
461 }