0022627: Change OCCT memory management defaults
[occt.git] / src / GeomToIGES / GeomToIGES_GeomSurface.cxx
CommitLineData
7fd59977 1// File: GeomToIGES_GeomSurface.cxx
2
3// modif du 22/10/96 mjm
4// ajout du champ TheLength
5//:l6 abv 15.01.99: CTS22022: writing full tori
6//szv#4:S4163:12Mar99
7//S4181 pdn 20.04.99 implementing of writing IGES elementary surfaces.
8//szv#10:PRO19566:05Oct99 workaround against weights array loss
9
10#include <GeomToIGES_GeomSurface.ixx>
11#include <GeomToIGES_GeomCurve.hxx>
12#include <GeomToIGES_GeomPoint.hxx>
13#include <GeomToIGES_GeomVector.hxx>
14
15#include <Geom_BSplineSurface.hxx>
16#include <Geom_BezierSurface.hxx>
17#include <Geom_BoundedSurface.hxx>
18#include <Geom_CartesianPoint.hxx>
19#include <Geom_ConicalSurface.hxx>
20#include <Geom_Circle.hxx>
21#include <Geom_Curve.hxx>
22#include <Geom_CylindricalSurface.hxx>
23#include <Geom_Curve.hxx>
24#include <Geom_Direction.hxx>
25#include <Geom_Geometry.hxx>
26#include <Geom_Line.hxx>
27#include <Geom_OffsetSurface.hxx>
28#include <Geom_Plane.hxx>
29#include <Geom_Point.hxx>
30#include <Geom_RectangularTrimmedSurface.hxx>
31#include <Geom_SphericalSurface.hxx>
32#include <Geom_Surface.hxx>
33#include <Geom_SurfaceOfLinearExtrusion.hxx>
34#include <Geom_SurfaceOfRevolution.hxx>
35#include <Geom_SweptSurface.hxx>
36#include <Geom_ToroidalSurface.hxx>
37
38#include <GeomConvert.hxx>
39
40#include <GeomLProp_SLProps.hxx>
41
42#include <IGESConvGeom_GeomBuilder.hxx>
43
44#include <IGESData_IGESEntity.hxx>
45
46#include <IGESGeom_BoundedSurface.hxx>
47#include <IGESGeom_BSplineSurface.hxx>
48#include <IGESGeom_CircularArc.hxx>
49#include <IGESGeom_CurveOnSurface.hxx>
50#include <IGESGeom_Direction.hxx>
51#include <IGESGeom_Line.hxx>
52#include <IGESGeom_OffsetSurface.hxx>
53#include <IGESGeom_Plane.hxx>
54#include <IGESGeom_Point.hxx>
55#include <IGESGeom_RuledSurface.hxx>
56#include <IGESGeom_SurfaceOfRevolution.hxx>
57#include <IGESGeom_TabulatedCylinder.hxx>
58#include <IGESGeom_TransformationMatrix.hxx>
59
60#include <IGESSolid_PlaneSurface.hxx>
61#include <Interface_Macros.hxx>
62
63#include <gce_MakeLin.hxx>
64
65#include <gp.hxx>
66#include <gp_Ax1.hxx>
67#include <gp_Ax3.hxx>
68#include <gp_Cone.hxx>
69#include <gp_Cylinder.hxx>
70#include <gp_Dir.hxx>
71#include <gp_Pln.hxx>
72#include <gp_Pnt.hxx>
73#include <gp_Sphere.hxx>
74#include <gp_Torus.hxx>
75#include <gp_Trsf.hxx>
76#include <gp_Vec.hxx>
77#include <gp_XYZ.hxx>
78
79#include <Precision.hxx>
80
81#include <TColgp_HArray2OfXYZ.hxx>
82#include <TColStd_HArray1OfReal.hxx>
83#include <TColStd_HArray2OfReal.hxx>
84#include <IGESSolid_CylindricalSurface.hxx>
85#include <IGESSolid_ConicalSurface.hxx>
86#include <IGESSolid_SphericalSurface.hxx>
87#include <IGESSolid_ToroidalSurface.hxx>
88#include <Geom_TrimmedCurve.hxx>
89
90
91//=============================================================================
92// GeomToIGES_GeomSurface
93//=============================================================================
94
95GeomToIGES_GeomSurface::GeomToIGES_GeomSurface()
96:GeomToIGES_GeomEntity()
97{
98 myBRepMode = Standard_False;
99 myAnalytic = Standard_False;
100}
101
102
103//=============================================================================
104// GeomToIGES_GeomSurface
105//=============================================================================
106
107GeomToIGES_GeomSurface::GeomToIGES_GeomSurface(const GeomToIGES_GeomEntity& GE)
108 :GeomToIGES_GeomEntity(GE)
109{
110 myBRepMode = Standard_False;
111 myAnalytic = Standard_False;
112}
113
114
115//=============================================================================
116// Transfer des Entites Surface de Geom vers IGES
117// TransferSurface
118//=============================================================================
119
120Handle(IGESData_IGESEntity) GeomToIGES_GeomSurface::TransferSurface(const Handle(Geom_Surface)& start,
121 const Standard_Real Udeb,
122 const Standard_Real Ufin,
123 const Standard_Real Vdeb,
124 const Standard_Real Vfin)
125{
126 Handle(IGESData_IGESEntity) res;
127 if (start.IsNull()) {
128 return res;
129 }
130
131 if (start->IsKind(STANDARD_TYPE(Geom_BoundedSurface))) {
132 DeclareAndCast(Geom_BoundedSurface, Bounded, start);
133 res = TransferSurface(Bounded, Udeb, Ufin, Vdeb, Vfin);
134 }
135 else if (start->IsKind(STANDARD_TYPE(Geom_ElementarySurface))) {
136 DeclareAndCast(Geom_ElementarySurface, Elementary, start);
137 res = TransferSurface(Elementary, Udeb, Ufin, Vdeb, Vfin);
138 }
139 else if ( start->IsKind(STANDARD_TYPE(Geom_SweptSurface))) {
140 DeclareAndCast(Geom_SweptSurface, Swept, start);
141 res = TransferSurface(Swept, Udeb, Ufin, Vdeb, Vfin);
142 }
143 else if ( start->IsKind(STANDARD_TYPE(Geom_OffsetSurface))) {
144 DeclareAndCast(Geom_OffsetSurface, OffsetS, start);
145 res = TransferSurface(OffsetS, Udeb, Ufin, Vdeb, Vfin);
146 }
147
148 return res;
149}
150
151
152//=============================================================================
153// Transfer des Entites BoundedSurface de Geom vers IGES
154// TransferSurface
155//=============================================================================
156
157Handle(IGESData_IGESEntity) GeomToIGES_GeomSurface::TransferSurface(const Handle(Geom_BoundedSurface)& start,
158 const Standard_Real Udeb,
159 const Standard_Real Ufin,
160 const Standard_Real Vdeb,
161 const Standard_Real Vfin)
162{
163 Handle(IGESData_IGESEntity) res;
164 if (start.IsNull()) {
165 return res;
166 }
167
168 if (start->IsKind(STANDARD_TYPE(Geom_BSplineSurface))) {
169 DeclareAndCast(Geom_BSplineSurface, BSpline, start);
170 res = TransferSurface(BSpline, Udeb, Ufin, Vdeb, Vfin);
171 }
172 else if (start->IsKind(STANDARD_TYPE(Geom_BezierSurface))) {
173 DeclareAndCast(Geom_BezierSurface, Bezier, start);
174 res = TransferSurface(Bezier, Udeb, Ufin, Vdeb, Vfin);
175 }
176 else if ( start->IsKind(STANDARD_TYPE(Geom_RectangularTrimmedSurface))) {
177 DeclareAndCast(Geom_RectangularTrimmedSurface, Trimmed, start);
178 res = TransferSurface(Trimmed,Udeb, Ufin, Vdeb, Vfin);
179 }
180
181 return res;
182}
183
184
185//=============================================================================
186// Transfer des Entites BSplineSurface de Geom vers IGES
187// TransferSurface
188//=============================================================================
189
190Handle(IGESData_IGESEntity) GeomToIGES_GeomSurface::TransferSurface(const Handle(Geom_BSplineSurface)& start,
191 const Standard_Real Udeb,
192 const Standard_Real Ufin,
193 const Standard_Real Vdeb,
194 const Standard_Real Vfin)
195{
196 // a b-spline surface is defined by :
197 // The U and V Degree (up to 25)
198 // The Poles (and the weights if it is rational)
199 // The U and V Knots and Multiplicities
200 //
201 // The knot vector is an increasing sequence of reals without repetition.
202 // The multiplicities are the repetition of the knots.
203 //
204 // If the knots are regularly spaced (the difference of two consecutive knots
205 // is a constant),
206 // the knots repartition (in U or V) is :
207 // - Uniform if all multiplicities are 1.
208 // - Quasi-uniform if all multiplicities are 1
209 // but the first and the last which are Degree+1.
210 // - PiecewiseBezier if all multiplicites are
211 // Degree but the first and the last which are
212 // Degree+1.
213 //
214 // The surface may be periodic in U and in V.
215 // On a U periodic surface if there are k U knots
216 // and the poles table has p rows. the U period
217 // is uknot(k) - uknot(1)
218 //
219 // the poles and knots are infinite vectors with :
220 // uknot(i+k) = uknot(i) + period
221 // pole(i+p,j) = pole(i,j)
222
223
224 Handle(IGESData_IGESEntity) res;
225 TheLength = 1;
226 if (start.IsNull()) {
227 return res;
228 }
229
230 Handle(IGESGeom_BSplineSurface) BSpline = new IGESGeom_BSplineSurface;
231 Handle(Geom_BSplineSurface) mysurface;
232
233 Standard_Boolean PeriodU = start->IsUPeriodic();
234 Standard_Boolean PeriodV = start->IsVPeriodic();
235 if (PeriodU || PeriodV) {
236 mysurface = Handle(Geom_BSplineSurface)::DownCast(start->Copy());
237
238 //szv#10:PRO19566:05Oct99
239 Standard_Boolean workaround = !(mysurface->IsURational() || mysurface->IsVRational());
240 if (workaround) mysurface->SetWeight(1,1,0.3);
241
242 if ( PeriodU ) mysurface->SetUNotPeriodic();
243 if ( PeriodV ) mysurface->SetVNotPeriodic();
244
245 //szv#10:PRO19566:05Oct99
246 if (workaround) mysurface->SetWeight(1,1,1.);
247 }
248 else {
249 mysurface = start;
250 }
251
252 Standard_Integer DegU = mysurface->UDegree();
253 Standard_Integer DegV = mysurface->VDegree();
254 Standard_Boolean CloseU = mysurface->IsUClosed();
255 Standard_Boolean CloseV = mysurface->IsVClosed();
256 //Standard_Boolean PeriodU = start->IsUPeriodic();
257 //Standard_Boolean PeriodV = start->IsVPeriodic();
258 Standard_Boolean RationU = mysurface->IsURational();
259 Standard_Boolean RationV = mysurface->IsVRational();
260 Standard_Integer NbUPoles = mysurface->NbUPoles();
261 Standard_Integer NbVPoles = mysurface->NbVPoles();
262 Standard_Integer IndexU = NbUPoles -1;
263 Standard_Integer IndexV = NbVPoles -1;
264 Standard_Boolean Polynom = !(RationU || RationV); //szv#10:PRO19566:05Oct99 && was wrong
265
266 // filling knots array for U :
267 // Sequence des Knots de [-DegU, IndexU+1] dans IGESGeom.
268 Standard_Integer Knotindex;
269 Standard_Real rtampon;
270 Standard_Integer itampon;
271 TColStd_Array1OfReal KU(1, NbUPoles+ DegU+ 1);
272 mysurface->UKnotSequence(KU);
273 itampon = -DegU;
274 Handle(TColStd_HArray1OfReal) KnotsU =
275 new TColStd_HArray1OfReal(-DegU,IndexU+1 );
276 for ( Knotindex=KU.Lower(); Knotindex<=KU.Upper(); Knotindex++) {
277 rtampon = KU.Value(Knotindex);
278 KnotsU->SetValue(itampon, rtampon);
279 itampon++;
280 }
281
282 // filling knots array for V :
283 // Sequence des Knots de [-DegV, IndexV+1] dans IGESGeom.
284 TColStd_Array1OfReal KV(1, NbVPoles+ DegV+ 1);
285 mysurface->VKnotSequence(KV);
286 itampon = -DegV;
287 Handle(TColStd_HArray1OfReal) KnotsV =
288 new TColStd_HArray1OfReal(-DegV, IndexV+1);
289 for ( Knotindex=KV.Lower(); Knotindex<=KV.Upper(); Knotindex++) {
290 rtampon = KV.Value(Knotindex);
291 KnotsV->SetValue(itampon, rtampon);
292 itampon++;
293 }
294
295 // filling Weights array de [0, IndexU, 0, IndexV]
296 // ----------------------------------------------
297 Handle(TColStd_HArray2OfReal) Weights =
298 new TColStd_HArray2OfReal(0 , IndexU, 0, IndexV);
299 Standard_Integer WeightRow = Weights->LowerRow();
300 Standard_Integer WeightCol = Weights->LowerCol();
301 Standard_Integer iw, jw;
302
303 if(RationU || RationV) {
304 for ( iw = 1; iw<= IndexU+1; iw++) {
305 for ( jw = 1; jw<= IndexV+1; jw++)
306 Weights->SetValue(WeightRow, WeightCol++, mysurface->Weight(iw,jw));
307 WeightRow++;
308 WeightCol = Weights->LowerCol();
309 }
310 } else {
311 for ( iw = 1; iw<= IndexU+1; iw++) {
312 for ( jw = 1; jw<= IndexV+1; jw++)
313 Weights->SetValue(WeightRow, WeightCol++, 1.0);
314 WeightRow++;
315 WeightCol = Weights->LowerCol();
316 }
317
318 }
319
320 // filling Poles array de [0, IndexU, 0, IndexV]
321 // ---------------------------------------------
322 Handle(TColgp_HArray2OfXYZ) Poles =
323 new TColgp_HArray2OfXYZ(0, IndexU, 0, IndexV);
324 Standard_Integer UIndex = Poles->LowerRow();
325 Standard_Integer VIndex = Poles->LowerCol();
326 Standard_Integer ipole, jpole;
327 Standard_Real Xd, Yd, Zd;
328
329 for ( ipole = 1; ipole<= IndexU+1; ipole++) {
330 for ( jpole = 1; jpole<= IndexV+1; jpole++) {
331 gp_Pnt tempPnt = mysurface-> Pole(ipole, jpole);
332 tempPnt.Coord(Xd, Yd, Zd);
333 gp_XYZ PXYZ = gp_XYZ( Xd/GetUnit(), Yd/GetUnit(), Zd/GetUnit());
334 Poles->SetValue(UIndex, VIndex++, PXYZ);
335 }
336 UIndex++;
337 VIndex = Poles->LowerCol();
338 }
339
340 // mjm le 9/10/97 mise en place d`une protection
341 Standard_Real U1,U2,V1,V2;
342 Standard_Real Umin = Udeb;
343 Standard_Real Umax = Ufin;
344 Standard_Real Vmin = Vdeb;
345 Standard_Real Vmax = Vfin;
346 mysurface->Bounds(U1,U2,V1,V2);
347 if ( U1 > Umin ) Umin = U1;
348 if ( V1 > Vmin ) Vmin = V1;
349 if ( U2 < Umax ) Umax = U2;
350 if ( V2 < Vmax ) Vmax = V2;
351
352 BSpline-> Init (IndexU, IndexV, DegU, DegV, CloseU, CloseV, Polynom, PeriodU,
353 PeriodV, KnotsU, KnotsV, Weights, Poles, Umin, Umax, Vmin, Vmax);
354 res = BSpline;
355 return res;
356}
357
358
359//=============================================================================
360// Transfer des Entites BezierSurface de Geom vers IGES
361// TransferSurface
362//=============================================================================
363
364Handle(IGESData_IGESEntity) GeomToIGES_GeomSurface::TransferSurface(const Handle(Geom_BezierSurface)& start,
365 const Standard_Real /*Udeb*/,
366 const Standard_Real /*Ufin*/,
367 const Standard_Real /*Vdeb*/,
368 const Standard_Real /*Vfin*/)
369{
370 Handle(IGESData_IGESEntity) res;
371 if (start.IsNull()) {
372 return res;
373 }
374
375 Handle(Geom_BSplineSurface) Bspline =
376 GeomConvert::SurfaceToBSplineSurface(start);
377 Standard_Real U1,U2,V1,V2;
378 Bspline->Bounds(U1,U2,V1,V2);
379 res = TransferSurface(Bspline, U1, U2, V1, V2);
380 return res;
381}
382
383
384//=============================================================================
385// Transfer des Entites RectangularTrimmedSurface de Geom vers IGES
386// TransferSurface
387//=============================================================================
388
389Handle(IGESData_IGESEntity) GeomToIGES_GeomSurface::TransferSurface(const Handle(Geom_RectangularTrimmedSurface)& start,
390 const Standard_Real Udeb,
391 const Standard_Real Ufin,
392 const Standard_Real Vdeb,
393 const Standard_Real Vfin)
394{
395 Handle(IGESData_IGESEntity) res;
396 if (start.IsNull()) {
397 return res;
398 }
399
400 Handle(Geom_Surface) st = start->BasisSurface();
401 if (st->IsKind(STANDARD_TYPE(Geom_RectangularTrimmedSurface))) {
402 //message d'erreur pas de trimmed a partir d'une trimmed ,
403 //on peut eventuellement ecrire la surface de base : st.
404 return res;
405 }
406
407 res = TransferSurface(st, Udeb, Ufin, Vdeb, Vfin);
408 return res;
409
410}
411
412
413//=============================================================================
414// Transfer des Entites ElementarySurface de Geom vers IGES
415// TransferSurface
416//=============================================================================
417
418Handle(IGESData_IGESEntity) GeomToIGES_GeomSurface::TransferSurface(const Handle(Geom_ElementarySurface)& start,
419 const Standard_Real Udeb,
420 const Standard_Real Ufin,
421 const Standard_Real Vdeb,
422 const Standard_Real Vfin)
423{
424 Handle(IGESData_IGESEntity) res;
425 // All these entities are located in 3D space with an axis
426 // placement (Location point, XAxis, YAxis, ZAxis). It is
427 // their local coordinate system.
428
429 //S4181 pdn 16.04.99 Hereunder, the implementation of translation of CAS.CADE
430 // elementary surfaces into different types of IGES surfaces according to boolean flags
431 if (start.IsNull()) {
432 return res;
433 }
434 if (start->IsKind(STANDARD_TYPE(Geom_Plane))) {
435 DeclareAndCast(Geom_Plane, Plane, start);
436 if(myBRepMode)
437 res = TransferPlaneSurface(Plane, Udeb, Ufin, Vdeb, Vfin);
438 else
439 res = TransferSurface(Plane, Udeb, Ufin, Vdeb, Vfin);
440 }
441 else if (start->IsKind(STANDARD_TYPE(Geom_CylindricalSurface))) {
442 DeclareAndCast(Geom_CylindricalSurface, Cylindrical, start);
443 if(myBRepMode&&myAnalytic)
444 res = TransferCylindricalSurface(Cylindrical, Udeb, Ufin, Vdeb, Vfin);
445 else
446 res = TransferSurface(Cylindrical, Udeb, Ufin, Vdeb, Vfin);
447 }
448 else if ( start->IsKind(STANDARD_TYPE(Geom_ConicalSurface))) {
449 DeclareAndCast(Geom_ConicalSurface, Conical, start);
450 if(myBRepMode&&myAnalytic)
451 res = TransferConicalSurface(Conical, Udeb, Ufin, Vdeb, Vfin);
452 else
453 res = TransferSurface(Conical, Udeb, Ufin, Vdeb, Vfin);
454 }
455 else if (start->IsKind(STANDARD_TYPE(Geom_SphericalSurface))) {
456 DeclareAndCast(Geom_SphericalSurface, Spherical, start);
457 if(myBRepMode&&myAnalytic)
458 res = TransferSphericalSurface(Spherical, Udeb, Ufin, Vdeb, Vfin);
459 else
460 res = TransferSurface(Spherical, Udeb, Ufin, Vdeb, Vfin);
461 }
462 else if ( start->IsKind(STANDARD_TYPE(Geom_ToroidalSurface))) {
463 DeclareAndCast(Geom_ToroidalSurface, Toroidal, start);
464 if(myBRepMode&&myAnalytic)
465 res = TransferToroidalSurface(Toroidal, Udeb, Ufin, Vdeb, Vfin);
466 else
467 res = TransferSurface(Toroidal, Udeb, Ufin, Vdeb, Vfin);
468 }
469
470 return res;
471
472}
473
474
475//=============================================================================
476// Transfer des Entites Plane de Geom vers IGES
477// TransferSurface
478//=============================================================================
479
480Handle(IGESData_IGESEntity) GeomToIGES_GeomSurface::TransferSurface(const Handle(Geom_Plane)& start,
481 const Standard_Real Udeb,
482 const Standard_Real Ufin,
483 const Standard_Real Vdeb,
484 const Standard_Real Vfin)
485{
486 // on va ecrire une BSplineSurface pour pouvoir etre coherent avec les courbes 2d
487 Handle(IGESData_IGESEntity) res;
488 TheLength = 1;
489 if (start.IsNull()) {
490 return res;
491 }
492
493 Handle(IGESGeom_BSplineSurface) BSpline = new IGESGeom_BSplineSurface;
494 gp_Pnt P1 ,P2, P3, P4;
495 start->D0(Udeb, Vdeb, P1);
496 start->D0(Udeb, Vfin, P2);
497 start->D0(Ufin, Vdeb, P3);
498 start->D0(Ufin, Vfin, P4);
499 Handle(TColgp_HArray2OfXYZ) Poles = new TColgp_HArray2OfXYZ(0, 1, 0, 1);
500 Standard_Real X,Y,Z;
501 P1.Coord(X,Y,Z);
502 Poles->SetValue (0, 0, gp_XYZ(X/GetUnit(),Y/GetUnit(),Z/GetUnit()));
503 P2.Coord(X,Y,Z);
504 Poles->SetValue (0, 1, gp_XYZ(X/GetUnit(),Y/GetUnit(),Z/GetUnit()));
505 P3.Coord(X,Y,Z);
506 Poles->SetValue (1, 0, gp_XYZ(X/GetUnit(),Y/GetUnit(),Z/GetUnit()));
507 P4.Coord(X,Y,Z);
508 Poles->SetValue (1, 1, gp_XYZ(X/GetUnit(),Y/GetUnit(),Z/GetUnit()));
509
510 Handle(TColStd_HArray1OfReal) KnotsU = new TColStd_HArray1OfReal(-1,2);
511 KnotsU->SetValue(-1, Udeb);
512 KnotsU->SetValue(0, Udeb);
513 KnotsU->SetValue(1, Ufin);
514 KnotsU->SetValue(2, Ufin);
515
516 Handle(TColStd_HArray1OfReal) KnotsV = new TColStd_HArray1OfReal(-1,2);
517 KnotsV->SetValue(-1, Vdeb);
518 KnotsV->SetValue(0, Vdeb);
519 KnotsV->SetValue(1, Vfin);
520 KnotsV->SetValue(2, Vfin);
521
522 Handle(TColStd_HArray2OfReal) Weights =
523 new TColStd_HArray2OfReal(0, 1, 0, 1, 1.);
524
525 //#32 rln 19.10.98
526 BSpline-> Init ( 1, 1, 1, 1, Standard_False , Standard_False, Standard_True,
527 Standard_False, Standard_False,
528 KnotsU, KnotsV, Weights, Poles, Udeb, Ufin, Vdeb, Vfin);
529 res = BSpline;
530 return res;
531
532}
533
534
535//=============================================================================
536// Transfer des Entites CylindricalSurface de Geom vers IGES
537// TransferSurface
538//=============================================================================
539
540Handle(IGESData_IGESEntity) GeomToIGES_GeomSurface::TransferSurface
541( const Handle(Geom_CylindricalSurface)& start, const Standard_Real Udeb,
542 const Standard_Real Ufin, const Standard_Real Vdeb, const Standard_Real Vfin)
543{
544 // The "ZAxis" is the symmetry axis of the CylindricalSurface,
545 // it gives the direction of increasing parametric value V.
546 // The parametrization range is :
547 // U [0, 2*PI], V ]- infinite, + infinite[
548 // The "XAxis" and the "YAxis" define the placement plane of the
549 // surface (Z = 0, and parametric value V = 0) perpendicular to
550 // the symmetry axis. The "XAxis" defines the origin of the
551 // parameter U = 0. The trigonometric sense gives the positive
552 // orientation for the parameter U.
553
554 Handle(IGESData_IGESEntity) res;
555 TheLength = 1;
556 if (start.IsNull()) {
557 return res;
558 }
559
560 Handle(IGESGeom_SurfaceOfRevolution) Surf = new IGESGeom_SurfaceOfRevolution;
561 Standard_Real U1 = Udeb;
562 Standard_Real U2 = Ufin;
563 Standard_Real V1 = Vdeb;
564 Standard_Real V2 = Vfin;
565 if (Precision::IsNegativeInfinite(Vdeb)) V1 = -Precision::Infinite();
566 if (Precision::IsPositiveInfinite(Vfin)) V2 = Precision::Infinite();
567
568 // creation de la generatrice : Generatrix
569 Handle(Geom_Line) Ligne =
570 new Geom_Line (gp_Pnt(start->Cylinder().Radius(), 0.0, 0.0),
571 gp_Dir(0.0, 0.0, 1.0));
572 GeomToIGES_GeomCurve GC(*this);
573 Handle(IGESData_IGESEntity) Generatrix = GC.TransferCurve( Ligne, V1, V2);
574 gp_Pnt gen1 = Ligne->Value(V1);
575 gp_Pnt gen2 = Ligne->Value(V2);
576 TheLength = gen1.Distance(gen2);
577
578
579 // creation de l`axe : Axis .
580 Handle(IGESGeom_Line) Axis = new IGESGeom_Line;
581 //#30 rln 19.10.98 IGES axis = reversed CAS.CADE axis
582 //Axis->Init(gp_XYZ(0.0, 0.0, 0.0), gp_XYZ(0.0, 0.0, 1.0/GetUnit()));
583 //Surf->Init (Axis, Generatrix, U1, U2);
584 Axis->Init(gp_XYZ (0, 0, 1. / GetUnit()), gp_XYZ (0, 0, 0));
c6541a0c 585 Surf->Init (Axis, Generatrix, 2 * M_PI - U2, 2 * M_PI - U1);
7fd59977 586
587
588 // creation de la Trsf (#124)
589 // il faut tenir compte de l`unite pour la matrice de transformation
590 // (partie translation).
591 IGESConvGeom_GeomBuilder Build;
592 Standard_Real xloc,yloc,zloc;
593 start->Cylinder().Location().Coord(xloc,yloc,zloc);
594 gp_Pnt Loc;
595 Loc.SetCoord(xloc, yloc, zloc);
596 gp_Ax3 Pos = start->Cylinder().Position();
597 Pos.SetLocation(Loc);
598 Build.SetPosition(Pos);
599 if (!Build.IsIdentity()){
600 Handle(IGESGeom_TransformationMatrix) TMat =
601 new IGESGeom_TransformationMatrix;
602 TMat = Build.MakeTransformation(GetUnit());
603 Surf->InitTransf(TMat);
604 }
605 res = Surf;
606 return res;
607
608}
609
610
611//=============================================================================
612// Transfer des Entites ConicalSurface de Geom vers IGES
613// TransferSurface
614//=============================================================================
615
616Handle(IGESData_IGESEntity) GeomToIGES_GeomSurface::TransferSurface
617( const Handle(Geom_ConicalSurface)& start, const Standard_Real Udeb,
618 const Standard_Real Ufin, const Standard_Real Vdeb, const Standard_Real Vfin)
619{
620 // The "ZAxis" is the symmetry axis of the ConicalSurface,
621 // it gives the direction of increasing parametric value V.
622 // The apex of the surface is on the negative side of this axis.
623 // The parametrization range is :
624 // U [0, 2*PI], V ]-infinite, + infinite[
625 // The "XAxis" and the "YAxis" define the placement plane of the
626 // surface (Z = 0, and parametric value V = 0) perpendicular to
627 // the symmetry axis. The "XAxis" defines the origin of the
628 // parameter U = 0. The trigonometric sense gives the positive
629 // orientation for the parameter U.
630
631
632 Handle(IGESData_IGESEntity) res;
633 TheLength = 1;
634 if (start.IsNull()) {
635 return res;
636 }
637 Handle(IGESGeom_SurfaceOfRevolution) Surf = new IGESGeom_SurfaceOfRevolution;
638 Standard_Real U1 = Udeb;
639 Standard_Real U2 = Ufin;
640 Standard_Real V1 = Vdeb;
641 Standard_Real V2 = Vfin;
642 if (Precision::IsNegativeInfinite(Vdeb)) V1 = -Precision::Infinite();
643 if (Precision::IsPositiveInfinite(Vfin)) V2 = Precision::Infinite();
644
645 // creation de la generatrice : Generatrix
646 Handle(Geom_Line) Ligne =
647 new Geom_Line( gp_Pnt(start->Cone().RefRadius(), 0.0, 0.0),
648 gp_Dir(sin(start->Cone().SemiAngle()), 0.,
649 cos(start->Cone().SemiAngle())));
650 GeomToIGES_GeomCurve GC(*this);
651 Handle(IGESData_IGESEntity) Generatrix = GC.TransferCurve( Ligne, V1, V2);
652 gp_Pnt gen1 = Ligne->Value(V1);
653 gp_Pnt gen2 = Ligne->Value(V2);
654// TheLength = gen1.Distance(gen2)*Cos(start->Cone().SemiAngle());
655 TheLength = gen1.Distance(gen2);
656
657 // creation de l`axe : Axis .
658 Handle(IGESGeom_Line) Axis = new IGESGeom_Line;
659 //#30 rln 19.10.98 IGES axis = reversed CAS.CADE axis
660 //Axis->Init(gp_XYZ(0.0, 0.0, 0.0), gp_XYZ(0.0, 0.0, 1.0/GetUnit()));
661 //Surf->Init (Axis, Generatrix, U1, U2);
662 Axis->Init(gp_XYZ (0, 0, 1. / GetUnit()), gp_XYZ (0, 0, 0));
c6541a0c 663 Surf->Init (Axis, Generatrix, 2 * M_PI - U2, 2 * M_PI - U1);
7fd59977 664
665
666 // creation de la Trsf (#124)
667 // il faut tenir compte de l`unite pour la matrice de transformation
668 // (partie translation).
669 IGESConvGeom_GeomBuilder Build;
670 Standard_Real xloc,yloc,zloc;
671 start->Cone().Location().Coord(xloc,yloc,zloc);
672 gp_Pnt Loc;
673 Loc.SetCoord(xloc, yloc, zloc);
674 gp_Ax3 Pos = start->Cone().Position();
675 Pos.SetLocation(Loc);
676 Build.SetPosition(Pos);
677 if (!Build.IsIdentity()){
678 Handle(IGESGeom_TransformationMatrix) TMat =
679 new IGESGeom_TransformationMatrix;
680 TMat = Build.MakeTransformation(GetUnit());
681 Surf->InitTransf(TMat);
682 }
683 res = Surf;
684 return res;
685
686}
687
688
689//=============================================================================
690// Transfer des Entites SphericalSurface de Geom vers IGES
691// TransferSurface
692//=============================================================================
693
694Handle(IGESData_IGESEntity) GeomToIGES_GeomSurface::TransferSurface
695( const Handle(Geom_SphericalSurface)& start, const Standard_Real Udeb,
696 const Standard_Real Ufin, const Standard_Real Vdeb, const Standard_Real Vfin)
697{
698 // The center of the sphere is the "Location" point of the local
699 // coordinate system.
700 // The V isoparametric curves of the surface are defined by
701 // the section of the spherical surface with plane parallel to the
702 // plane (Location, XAxis, YAxis). This plane defines the origin of
703 // parametrization V.
704 // The U isoparametric curves of the surface are defined by the
705 // section of the spherical surface with plane obtained by rotation
706 // of the plane (Location, XAxis, ZAxis) around ZAxis. This plane
707 // defines the origin of parametrization u.
708 // The parametrization range is U [0, 2*PI], V [- PI/2, + PI/2]
709
710 Handle(IGESData_IGESEntity) res;
711 TheLength = 1;
712 if (start.IsNull()) {
713 return res;
714 }
715
716 Handle(IGESGeom_SurfaceOfRevolution) Surf = new IGESGeom_SurfaceOfRevolution;
717
718 Standard_Real U1 = Udeb;
719 Standard_Real U2 = Ufin;
720 Standard_Real V1 = Vdeb;
721 Standard_Real V2 = Vfin;
722
723 // creation de la generatrice : Generatrix (1/2 cercle)
724 gp_Ax2 Axe(gp::Origin(), -gp::DY(), gp::DX());
725 Handle(Geom_Circle) Cercle =
726 new Geom_Circle(Axe, start->Sphere().Radius());
727 GeomToIGES_GeomCurve GC(*this);
728 Handle(IGESData_IGESEntity) Gen = GC.TransferCurve( Cercle, V1, V2);
729
730 // creation de l`axe : Axis .
731 Handle(IGESGeom_Line) Axis = new IGESGeom_Line;
732 //#30 rln 19.10.98 IGES axis = reversed CAS.CADE axis
733 //Axis->Init(gp_XYZ(0.0, 0.0, 0.0), gp_XYZ(0.0, 0.0, 1.0/GetUnit()));
734 Axis->Init(gp_XYZ (0, 0, 1. / GetUnit()), gp_XYZ (0, 0, 0));
735
736 if ( Gen->IsKind(STANDARD_TYPE(IGESGeom_CircularArc))) {
737 //#30 rln 19.10.98 Surf->Init (Axis, Gen, U1, U2);
c6541a0c 738 Surf->Init (Axis, Gen, 2 * M_PI - U2, 2 * M_PI - U1);
7fd59977 739 IGESConvGeom_GeomBuilder Build;
740 Standard_Real xloc,yloc,zloc;
741 start->Sphere().Location().Coord(xloc,yloc,zloc);
742 gp_Pnt Loc;
743 Loc.SetCoord(xloc, yloc, zloc);
744 gp_Ax3 Pos = start->Sphere().Position();
745 Pos.SetLocation(Loc);
746 Build.SetPosition(Pos);
747 if (!Build.IsIdentity()){
748 Handle(IGESGeom_TransformationMatrix) TMat =
749 new IGESGeom_TransformationMatrix;
750 TMat = Build.MakeTransformation(GetUnit());
751 Surf->InitTransf(TMat);
752 }
753 }
754 res = Surf;
755 return res;
756}
757
758
759//=============================================================================
760// Transfer des Entites ToroidalSurface de Geom vers IGES
761// TransferSurface
762//=============================================================================
763
764Handle(IGESData_IGESEntity) GeomToIGES_GeomSurface::TransferSurface
765( const Handle(Geom_ToroidalSurface)& start, const Standard_Real Udeb,
766 const Standard_Real Ufin, const Standard_Real Vdeb, const Standard_Real Vfin)
767{
768 // The "Location point" of the axis placement is the center
769 // of the surface.
770 // The plane (Location, XAxis, ZAxis) defines the origin of the
771 // parametrization U. The plane (Location, XAxis, YAxis)
772 // defines the origin of the parametrization V.
773 // The parametrization range is U [0, 2*PI], V [0, 2*PI]
774
775
776 Handle(IGESData_IGESEntity) res;
777 TheLength = 1;
778 if (start.IsNull()) {
779 return res;
780 }
781
782 Handle(IGESGeom_SurfaceOfRevolution) Surf = new IGESGeom_SurfaceOfRevolution;
783 Standard_Real U1 = Udeb;
784 Standard_Real U2 = Ufin;
785 Standard_Real V1 = Vdeb;
786 Standard_Real V2 = Vfin;
787
7fd59977 788 // creation de la generatrice : Generatrix (cercle)
789 gp_Ax2 Axe = gp_Ax2(gp_Pnt((start->Torus().MajorRadius()), 0., 0.),
790 -gp::DY(), gp::DX());
791 Handle(Geom_Circle) Cercle =
792 new Geom_Circle(Axe, start->Torus().MinorRadius());
793 GeomToIGES_GeomCurve GC(*this);
794 Handle(IGESData_IGESEntity) Gen = GC.TransferCurve( Cercle, V1, V2);
795
796 // creation de l`axe : Axis .
797 Handle(IGESGeom_Line) Axis = new IGESGeom_Line;
798 //#30 rln 19.10.98 IGES axis = reversed CAS.CADE axis
799 //Axis->Init(gp_XYZ(0.0, 0.0, 0.0), gp_XYZ(0.0, 0.0, 1.0/GetUnit()));
800 Axis->Init(gp_XYZ (0, 0, 1. / GetUnit()), gp_XYZ (0, 0, 0));
801
802//:l6 abv: CTS22022: writing full tori: if ( Gen->IsKind(STANDARD_TYPE(IGESGeom_CircularArc))) {
803 //#30 rln 19.10.98 Surf->Init (Axis, Gen, U1, U2);
c6541a0c 804 Surf->Init (Axis, Gen, 2 * M_PI - U2, 2 * M_PI - U1);
7fd59977 805 IGESConvGeom_GeomBuilder Build;
806/* //:l6: useless
807 Standard_Real xloc,yloc,zloc;
808 start->Torus().Location().Coord(xloc,yloc,zloc);
809 gp_Pnt Loc;
810 Loc.SetCoord(xloc, yloc, zloc);
811*/
812 gp_Ax3 Pos = start->Torus().Position();
813//:l6 Pos.SetLocation(Loc);
814 Build.SetPosition(Pos);
815 if (!Build.IsIdentity()){
816 Handle(IGESGeom_TransformationMatrix) TMat =
817 new IGESGeom_TransformationMatrix;
818 TMat = Build.MakeTransformation(GetUnit());
819 Surf->InitTransf(TMat);
820 }
821//:l6 }
822 res = Surf;
823 return res;
824
825}
826
827//=============================================================================
828// Transfer des Entites SweptSurface de Geom vers IGES
829// TransferSurface
830//=============================================================================
831
832Handle(IGESData_IGESEntity) GeomToIGES_GeomSurface::TransferSurface
833( const Handle(Geom_SweptSurface)& start, const Standard_Real Udeb,
834 const Standard_Real Ufin, const Standard_Real Vdeb, const Standard_Real Vfin)
835{
836 Handle(IGESData_IGESEntity) res;
837 if (start.IsNull()) {
838 return res;
839 }
840
841 if (start->IsKind(STANDARD_TYPE(Geom_SurfaceOfLinearExtrusion))) {
842 DeclareAndCast(Geom_SurfaceOfLinearExtrusion, Extrusion, start);
843 res = TransferSurface(Extrusion, Udeb, Ufin, Vdeb, Vfin);
844 }
845 else if (start->IsKind(STANDARD_TYPE(Geom_SurfaceOfRevolution))) {
846 DeclareAndCast(Geom_SurfaceOfRevolution, Revolution, start);
847 res = TransferSurface(Revolution, Udeb, Ufin, Vdeb, Vfin);
848 }
849
850 return res;
851
852}
853
854//=============================================================================
855// Transfer des Entites SurfaceOfLinearExtrusion de Geom vers IGES
856// TransferSurface
857//=============================================================================
858
859Handle(IGESData_IGESEntity) GeomToIGES_GeomSurface::TransferSurface
860( const Handle(Geom_SurfaceOfLinearExtrusion)& start, const Standard_Real Udeb,
861 const Standard_Real Ufin, const Standard_Real Vdeb, const Standard_Real Vfin)
862{
863 // This surface is obtained by sweeping a curve in a given direction.
864 // The parametrization range for the parameter U is defined with the
865 // referenced curve.
866 // The parametrization range for the parameter V is
867 // ]-infinite, + infinite[
868 // The position of the curve gives the origin for the parameter V.
869
870
871 Handle(IGESData_IGESEntity) res;
872 TheLength = 1;
873 if (start.IsNull()) {
874 return res;
875 }
876
877 Handle(IGESGeom_TabulatedCylinder) Surf = new IGESGeom_TabulatedCylinder;
878 Standard_Real U1 = Udeb;
879 Standard_Real U2 = Ufin;
880 Standard_Real V1 = Vdeb;
881 Standard_Real V2 = Vfin;
882 if (Precision::IsNegativeInfinite(Vdeb)) V1 = -Precision::Infinite();
883 if (Precision::IsPositiveInfinite(Vfin)) V2 = Precision::Infinite();
884
885 // added by skl 18.07.2005 for OCC9490
886 Standard_Real UF,UL,VF,VL;
887 start->Bounds(UF,UL,VF,VL);
888 U1=UF;
889 U2=UL;
890
891 Handle(Geom_Curve) TheCurve = start->BasisCurve();
892
893 //dans IGES l'origine de la generatrice est identique a l'origine
894 //de la directrice , il faut translater la courbe si les deux
895 //points ne sont pas confondus dans Geom et donc la copier !!!!!!!
896 gp_Pnt TheEnd = start->Value(U1,V2);
897 Standard_Real Xe, Ye, Ze;
898 TheEnd.Coord(Xe, Ye, Ze);
899 gp_XYZ End = gp_XYZ (Xe/GetUnit(), Ye/GetUnit(), Ze/GetUnit());
900
901 GeomToIGES_GeomCurve GC(*this);
902// commented by skl 18.07.2005 for OCC9490
903 Handle(Geom_Curve) CopyCurve;
904 if ( Abs(V1) > Precision::Confusion()) {
905 CopyCurve = Handle(Geom_Curve)::DownCast
906 (TheCurve->Translated (start->Value(U1,0.), start->Value(U1,V1)));
907 }
908 else {
909 CopyCurve = TheCurve;
910 }
911 //Handle(IGESData_IGESEntity) Directrix = GC.TransferCurve( CopyCurve, V1, V2);
912 Handle(IGESData_IGESEntity) Directrix = GC.TransferCurve( CopyCurve, U1, U2);
913 //Handle(IGESData_IGESEntity) Directrix = GC.TransferCurve( TheCurve, U1, U2);
914 //gp_Pnt gen1 = start->Value(U1,V1);
915 //TheLength = gen1.Distance(TheEnd);
916
917 Surf->Init (Directrix, End);
918 res = Surf;
919 return res;
920
921}
922
923//=============================================================================
924// Transfer des Entites SurfaceOfRevolution de Geom vers IGES
925// TransferSurface
926//=============================================================================
927
928Handle(IGESData_IGESEntity) GeomToIGES_GeomSurface::TransferSurface
929( const Handle(Geom_SurfaceOfRevolution)& start, const Standard_Real Udeb,
930 const Standard_Real Ufin, const Standard_Real Vdeb, const Standard_Real Vfin)
931{
932 // The surface is obtained by rotating a curve a complete revolution
933 // about an axis. The curve and the axis must be in the same plane.
934 // For a complete surface of revolution the parametric range is
935 // 0 <= U <= 2*PI.
936 // The parametric range for V is defined with the revolved curve.
937 // The origin of the U parametrization is given by the position
938 // of the revolved curve (reference). The direction of the revolution
939 // axis defines the positive sense of rotation (trigonometric sense)
940 // corresponding to the increasing of the parametric value U.
941 // The derivatives are always defined for the u direction.
942 // For the v direction the definition of the derivatives depends on
943 // the degree of continuity of the referenced curve.
944
945 Handle(IGESData_IGESEntity) res;
946 TheLength = 1;
947 if (start.IsNull()) {
948 return res;
949 }
950
951 Handle(IGESGeom_SurfaceOfRevolution) Surf = new IGESGeom_SurfaceOfRevolution;
952 Standard_Real U1 = Udeb;
953 Standard_Real U2 = Ufin;
954 Standard_Real V1 = Vdeb;
955 Standard_Real V2 = Vfin;
956 if (Precision::IsNegativeInfinite(Vdeb)) V1 = -Precision::Infinite();
957 if (Precision::IsPositiveInfinite(Vfin)) V2 = Precision::Infinite();
958
959 // creation de la generatrice : Generatrix
960 Handle(Geom_Curve) Curve = start->BasisCurve();
961 GeomToIGES_GeomCurve GC(*this);
962 Handle(IGESData_IGESEntity) Generatrix = GC.TransferCurve( Curve, V1, V2);
963 //pdn BUC184: decoding a trimmed curve
964 while( Curve->IsKind(STANDARD_TYPE(Geom_TrimmedCurve))) {
965 Handle(Geom_TrimmedCurve) aTrCurve = Handle(Geom_TrimmedCurve)::
966 DownCast(Curve);
967 Curve = aTrCurve->BasisCurve();
968 }
969
970 if ( Curve->IsKind(STANDARD_TYPE(Geom_Line))) {
971 DeclareAndCast(Geom_Line, Line, Curve);
972 gp_Pnt gen1 = Line->Value(V1);
973 gp_Pnt gen2 = Line->Value(V2);
974 TheLength = gen1.Distance(gen2);
975 }
976
977 // creation de l`axe : Axis .
978 Handle(IGESGeom_Line) Axis = new IGESGeom_Line;
979 gp_Ax1 Axe = start->Axis();
980 Standard_Real X1,Y1,Z1,X2,Y2,Z2;
981 Axe.Location().Coord(X1,Y1,Z1);
982 Axe.Direction().Coord(X2,Y2,Z2);
983
984 //#30 rln 19.10.98 IGES axis = reversed CAS.CADE axis
985 //Axis->Init(gp_XYZ(X1/GetUnit(),Y1/GetUnit(),Z1/GetUnit()),
986 // gp_XYZ(X2/GetUnit(),Y2/GetUnit(),Z2/GetUnit()));
987 //#36 rln 27.10.98 BUC60328 face 7
988 Axis->Init(gp_XYZ(X1/GetUnit(),Y1/GetUnit(),Z1/GetUnit()),
989 gp_XYZ( (X1 - X2) / GetUnit(), (Y1 - Y2) / GetUnit(), (Z1 - Z2) / GetUnit()));
990
c6541a0c 991 Surf->Init (Axis, Generatrix, 2 * M_PI - U2, 2 * M_PI - U1);
7fd59977 992 res = Surf;
993 return res;
994
995}
996
997
998//=============================================================================
999// Transfer des Entites OffsetSurface de Geom vers IGES
1000// TransferSurface
1001//=============================================================================
1002
1003Handle(IGESData_IGESEntity) GeomToIGES_GeomSurface::TransferSurface
1004( const Handle(Geom_OffsetSurface)& start, const Standard_Real Udeb, const Standard_Real
1005 Ufin, const Standard_Real Vdeb, const Standard_Real Vfin)
1006{
1007 // An offset surface is a surface at constant distance
1008 // (Offset) from a basis surface. The distance may be positive
1009 // or negative to the preferred side of the surface.
1010 // The positive side is defined by the cross product D1u ^ D1v
1011 // where D1u and D1v are the tangent vectors of the basis
1012 // surface in the U and V parametric directions. The previous
1013 // cross product defines the normal direction to the basis
1014 // surface.
1015
1016 Handle(IGESData_IGESEntity) res;
1017 if (start.IsNull()) {
1018 return res;
1019 }
1020
1021 Handle(IGESGeom_OffsetSurface) Surf = new IGESGeom_OffsetSurface;
1022 Handle(Geom_Surface) TheSurf = start->BasisSurface();
1023 Standard_Real U1, U2, V1, V2 , Um, Vm;
1024 start->Bounds (U1, U2, V1, V2);
1025 Um = (U1 + U2 ) /2.;
1026 Vm = (V1 + V2 ) /2.;
1027 Handle(IGESData_IGESEntity) Surface = TransferSurface
1028 (TheSurf, Udeb, Ufin, Vdeb, Vfin);
1029 Standard_Real Distance = start->Offset()/GetUnit();
1030 GeomLProp_SLProps Prop = GeomLProp_SLProps
1031 (TheSurf, Um, Vm, 1, Precision::Confusion());
1032 gp_Dir Dir = Prop.Normal();
1033 Standard_Real Xd, Yd, Zd;
1034 Dir.Coord(Xd, Yd, Zd);
1035 gp_XYZ Indicator = gp_XYZ(Xd/GetUnit(), Yd/GetUnit(), Zd/GetUnit());
1036
1037 Surf-> Init (Indicator, Distance, Surface);
1038 res = Surf;
1039 return res;
1040
1041}
1042
1043
1044//=============================================================================
1045// Transfer des Entites Plane de Geom vers IGESSolid
1046// TransferPlaneSurface
1047//=============================================================================
1048
1049Handle(IGESData_IGESEntity) GeomToIGES_GeomSurface::TransferPlaneSurface(const Handle(Geom_Plane)& start,
1050 const Standard_Real /*Udeb*/,
1051 const Standard_Real /*Ufin*/,
1052 const Standard_Real /*Vdeb*/,
1053 const Standard_Real /*Vfin*/)
1054{
1055 // The parametrization range is U, V ]- infinite, + infinite[
1056 // The local coordinate system of the plane is defined with
1057 // an axis placement two axis.
1058
1059 Handle(IGESData_IGESEntity) res;
1060 TheLength = 1;
1061 if (start.IsNull()) {
1062 return res;
1063 }
1064
1065 Handle(IGESSolid_PlaneSurface) Plsurf = new IGESSolid_PlaneSurface;
1066 GeomToIGES_GeomPoint GP(*this);
1067 GeomToIGES_GeomVector GV(*this);
1068
1069 gp_Pln Pln = start->Pln();
1070
1071 Handle(Geom_CartesianPoint) mypoint = new Geom_CartesianPoint(Pln.Location());
1072 Handle(IGESGeom_Point) aLocation = GP.TransferPoint(mypoint);
1073
1074 gp_Ax1 Axe = Pln.Axis();
1075 Handle(Geom_Direction) mydir = new Geom_Direction(Axe.Direction());
1076 Handle(IGESGeom_Direction) aNormal = GV.TransferVector(mydir);
1077
1078 gp_Ax1 XAxe = Pln.XAxis();
1079 Handle(Geom_Direction) rdir = new Geom_Direction(XAxe.Direction());
1080 Handle(IGESGeom_Direction) refdir = GV.TransferVector(rdir);
1081
1082 Plsurf->Init (aLocation, aNormal, refdir);
1083 res = Plsurf;
1084 return res;
1085
1086}
1087
1088//=======================================================================
1089//function : TransferCylindricaSurface
1090//purpose :
1091//=======================================================================
1092
1093Handle(IGESData_IGESEntity) GeomToIGES_GeomSurface::TransferCylindricalSurface(const Handle(Geom_CylindricalSurface)& start,
1094 const Standard_Real /*Udeb*/,
1095 const Standard_Real /*Ufin*/,
1096 const Standard_Real /*Vdeb*/,
1097 const Standard_Real /*Vfin*/)
1098{
1099
1100 Handle(IGESData_IGESEntity) res;
1101 TheLength = 1;
1102 if (start.IsNull()) {
1103 return res;
1104 }
1105
1106 Handle(IGESSolid_CylindricalSurface) CylSurf = new IGESSolid_CylindricalSurface;
1107 GeomToIGES_GeomPoint GP(*this);
1108 GeomToIGES_GeomVector GV(*this);
1109
1110 gp_Cylinder Cyl = start->Cylinder();
1111
1112 Handle(Geom_CartesianPoint) mypoint = new Geom_CartesianPoint(Cyl.Location());
1113 Handle(IGESGeom_Point) aLocation = GP.TransferPoint(mypoint);
1114
1115 gp_Ax1 Axe = Cyl.Axis();
1116 Handle(Geom_Direction) mydir = new Geom_Direction(Axe.Direction());
1117 Handle(IGESGeom_Direction) Axis = GV.TransferVector(mydir);
1118
1119 gp_Ax1 XAxe = Cyl.XAxis();
1120 Handle(Geom_Direction) rdir = new Geom_Direction(XAxe.Direction());
1121 Handle(IGESGeom_Direction) refdir = GV.TransferVector(rdir);
1122
1123 Standard_Real radius = Cyl.Radius();
1124
1125 CylSurf->Init (aLocation, Axis, radius, refdir);
1126 res = CylSurf;
1127 return res;
1128}
1129
1130
1131//=======================================================================
1132//function : TransferConicalSurface
1133//purpose :
1134//=======================================================================
1135
1136Handle(IGESData_IGESEntity) GeomToIGES_GeomSurface::TransferConicalSurface(const Handle(Geom_ConicalSurface)& start,
1137 const Standard_Real /*Udeb*/,
1138 const Standard_Real /*Ufin*/,
1139 const Standard_Real /*Vdeb*/,
1140 const Standard_Real /*Vfin*/)
1141{
1142
1143 Handle(IGESData_IGESEntity) res;
1144 TheLength = 1;
1145 if (start.IsNull()) {
1146 return res;
1147 }
1148
1149 Handle(IGESSolid_ConicalSurface) ConSurf = new IGESSolid_ConicalSurface;
1150 GeomToIGES_GeomPoint GP(*this);
1151 GeomToIGES_GeomVector GV(*this);
1152
1153 gp_Cone Con = start->Cone();
1154 Standard_Real radius = Con.RefRadius();
1155 Standard_Real angle = Con.SemiAngle();
1156 gp_Ax1 Axe = Con.Axis();
1157 gp_Ax1 XAxe = Con.XAxis();
1158 gp_Dir XDir = XAxe.Direction();
1159
1160 Handle(Geom_CartesianPoint) mypoint = new Geom_CartesianPoint(Con.Location());
1161 if(angle < 0.) {
1162 gp_Pnt pnt = mypoint->Pnt();
1163 mypoint->SetPnt(Con.Apex().XYZ()*2-pnt.XYZ());
1164 angle = -angle;
1165 XDir.Reverse();
1166 }
1167 Handle(IGESGeom_Point) aLocation = GP.TransferPoint(mypoint);
1168
1169 Handle(Geom_Direction) mydir = new Geom_Direction(Axe.Direction());
1170 Handle(IGESGeom_Direction) Axis = GV.TransferVector(mydir);
1171
1172 Handle(Geom_Direction) rdir = new Geom_Direction(XDir);//XAxe.Direction());
1173 Handle(IGESGeom_Direction) refdir = GV.TransferVector(rdir);
1174
c6541a0c 1175 ConSurf->Init (aLocation, Axis, radius, angle*180./M_PI, refdir);
7fd59977 1176 res = ConSurf;
1177 return res;
1178}
1179
1180
1181//=======================================================================
1182//function : TransferSphericalSurface
1183//purpose :
1184//=======================================================================
1185
1186Handle(IGESData_IGESEntity) GeomToIGES_GeomSurface::TransferSphericalSurface(const Handle(Geom_SphericalSurface)& start,
1187 const Standard_Real /*Udeb*/,
1188 const Standard_Real /*Ufin*/,
1189 const Standard_Real /*Vdeb*/,
1190 const Standard_Real /*Vfin*/)
1191{
1192
1193 Handle(IGESData_IGESEntity) res;
1194 TheLength = 1;
1195 if (start.IsNull()) {
1196 return res;
1197 }
1198
1199 Handle(IGESSolid_SphericalSurface) SphSurf = new IGESSolid_SphericalSurface;
1200 GeomToIGES_GeomPoint GP(*this);
1201 GeomToIGES_GeomVector GV(*this);
1202
1203 gp_Sphere Sph = start->Sphere();
1204
1205 Handle(Geom_CartesianPoint) mypoint = new Geom_CartesianPoint(Sph.Location());
1206 Handle(IGESGeom_Point) aLocation = GP.TransferPoint(mypoint);
1207
1208 gp_Ax1 Axe = Sph.Position().Axis();
1209 Handle(Geom_Direction) mydir = new Geom_Direction(Axe.Direction());
1210 Handle(IGESGeom_Direction) Axis = GV.TransferVector(mydir);
1211
1212 gp_Ax1 XAxe = Sph.XAxis();
1213 Handle(Geom_Direction) rdir = new Geom_Direction(XAxe.Direction());
1214 Handle(IGESGeom_Direction) refdir = GV.TransferVector(rdir);
1215
1216 Standard_Real radius = Sph.Radius();
1217
1218 SphSurf->Init (aLocation, radius, Axis, refdir);
1219 res = SphSurf;
1220 return res;
1221}
1222
1223Handle(IGESData_IGESEntity) GeomToIGES_GeomSurface::TransferToroidalSurface(const Handle(Geom_ToroidalSurface)& start,
1224 const Standard_Real /*Udeb*/,
1225 const Standard_Real /*Ufin*/,
1226 const Standard_Real /*Vdeb*/,
1227 const Standard_Real /*Vfin*/)
1228{
1229
1230 Handle(IGESData_IGESEntity) res;
1231 TheLength = 1;
1232 if (start.IsNull()) {
1233 return res;
1234 }
1235
1236 Handle(IGESSolid_ToroidalSurface) TorSurf = new IGESSolid_ToroidalSurface;
1237 GeomToIGES_GeomPoint GP(*this);
1238 GeomToIGES_GeomVector GV(*this);
1239
1240 gp_Torus Tor = start->Torus();
1241
1242 Handle(Geom_CartesianPoint) mypoint = new Geom_CartesianPoint(Tor.Location());
1243 Handle(IGESGeom_Point) aLocation = GP.TransferPoint(mypoint);
1244
1245 gp_Ax1 Axe = Tor.Axis();
1246 Handle(Geom_Direction) mydir = new Geom_Direction(Axe.Direction());
1247 Handle(IGESGeom_Direction) Axis = GV.TransferVector(mydir);
1248
1249 gp_Ax1 XAxe = Tor.XAxis();
1250 Handle(Geom_Direction) rdir = new Geom_Direction(XAxe.Direction());
1251 Handle(IGESGeom_Direction) refdir = GV.TransferVector(rdir);
1252
1253 Standard_Real major = Tor.MajorRadius();
1254 Standard_Real minor = Tor.MinorRadius();
1255
1256 TorSurf->Init (aLocation, Axis, major, minor, refdir);
1257 res = TorSurf;
1258 return res;
1259}
1260
1261
1262//=======================================================================
1263//function : Length
1264//purpose :
1265//=======================================================================
1266Standard_Real GeomToIGES_GeomSurface::Length() const
1267{ return TheLength; }
1268
1269//=======================================================================
1270//function : GetBRepMode
1271//purpose :
1272//=======================================================================
1273
1274Standard_Boolean GeomToIGES_GeomSurface::GetBRepMode() const
1275{
1276 return myBRepMode;
1277}
1278
1279//=======================================================================
1280//function : SetBRepMode
1281//purpose :
1282//=======================================================================
1283
1284void GeomToIGES_GeomSurface::SetBRepMode(const Standard_Boolean flag)
1285{
1286 myBRepMode = flag;
1287}
1288
1289//=======================================================================
1290//function : GetAnalyticMode
1291//purpose :
1292//=======================================================================
1293
1294Standard_Boolean GeomToIGES_GeomSurface::GetAnalyticMode() const
1295{
1296 return myAnalytic;
1297}
1298
1299void GeomToIGES_GeomSurface::SetAnalyticMode(const Standard_Boolean flag)
1300{
1301 myAnalytic = flag;
1302}
1303