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