0031939: Coding - correction of spelling errors in comments [part 2]
[occt.git] / samples / OCCTOverview / code / TopologySamples.cxx
1 // Copyright (c) 2020 OPEN CASCADE SAS
2 //
3 // This file is part of the examples of the Open CASCADE Technology software library.
4 //
5 // Permission is hereby granted, free of charge, to any person obtaining a copy
6 // of this software and associated documentation files (the "Software"), to deal
7 // in the Software without restriction, including without limitation the rights
8 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9 // copies of the Software, and to permit persons to whom the Software is
10 // furnished to do so, subject to the following conditions:
11 //
12 // The above copyright notice and this permission notice shall be included in all
13 // copies or substantial portions of the Software.
14 //
15 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE
21
22 #include "TopologySamples.h"
23
24 #include "AdaptorVec_AIS.h"
25
26 #include <gp_Circ.hxx>
27 #include <gp_Circ2d.hxx>
28 #include <gp_Cylinder.hxx>
29 #include <gp_Lin.hxx>
30 #include <gp_Pln.hxx>
31 #include <gp_Sphere.hxx>
32 #include <gp_Torus.hxx>
33
34 #include <Geom_Axis1Placement.hxx>
35 #include <Geom_Axis2Placement.hxx>
36 #include <Geom_BSplineCurve.hxx>
37 #include <Geom2d_BSplineCurve.hxx>
38 #include <Geom_BSplineSurface.hxx>
39 #include <Geom_CartesianPoint.hxx>
40 #include <Geom_CylindricalSurface.hxx>
41 #include <Geom_Line.hxx>
42 #include <Geom_Plane.hxx>
43 #include <Geom_ToroidalSurface.hxx>
44 #include <GeomAPI_PointsToBSpline.hxx>
45 #include <Geom2dAPI_PointsToBSpline.hxx>
46 #include <GeomAPI_PointsToBSplineSurface.hxx>
47
48 #include <TopoDS.hxx>
49 #include <TopoDS_Iterator.hxx>
50 #include <TopoDS_Compound.hxx>
51 #include <TopoDS_Edge.hxx>
52 #include <TopoDS_Face.hxx>
53 #include <TopoDS_Shell.hxx>
54 #include <TopoDS_Solid.hxx>
55 #include <TopoDS_Vertex.hxx>
56 #include <TopoDS_Wire.hxx>
57 #include <TopExp.hxx>
58 #include <TopExp_Explorer.hxx>
59
60 #include <TColgp_Array2OfPnt.hxx>
61
62 #include <BRep_Builder.hxx>
63 #include <BRepGProp.hxx>
64 #include <BRep_Tool.hxx>
65 #include <BRepTools.hxx>
66 #include <BRepTools_ReShape.hxx>
67 #include <BRepAdaptor_Curve.hxx>
68 #include <BRepAdaptor_CompCurve.hxx>
69 #include <BRepAdaptor_Surface.hxx>
70 #include <BRepAlgoAPI_Common.hxx>
71 #include <BRepAlgoAPI_Cut.hxx>
72 #include <BRepAlgoAPI_Fuse.hxx>
73 #include <BRepAlgoAPI_Section.hxx>
74 #include <BRepAlgoAPI_Splitter.hxx>
75 #include <BRepAlgoAPI_Defeaturing.hxx>
76 #include <BRepBuilderAPI_Copy.hxx>
77 #include <BRepBuilderAPI_MakeVertex.hxx>
78 #include <BRepBuilderAPI_MakeEdge.hxx>
79 #include <BRepBuilderAPI_MakeEdge2d.hxx>
80 #include <BRepBuilderAPI_MakeFace.hxx>
81 #include <BRepBuilderAPI_MakePolygon.hxx>
82 #include <BRepBuilderAPI_MakeShell.hxx>
83 #include <BRepBuilderAPI_MakeSolid.hxx>
84 #include <BRepBuilderAPI_MakeWire.hxx>
85 #include <BRepBuilderAPI_NurbsConvert.hxx>
86 #include <BRepBuilderAPI_Sewing.hxx>
87 #include <BRepBuilderAPI_Transform.hxx>
88 #include <BRepCheck_Analyzer.hxx>
89 #include <BRepPrimAPI_MakeBox.hxx>
90 #include <BRepPrimAPI_MakeCylinder.hxx>
91 #include <BRepPrimAPI_MakeRevol.hxx>
92 #include <BRepFilletAPI_MakeChamfer.hxx>
93 #include <BRepFilletAPI_MakeFillet.hxx>
94 #include <BRepOffsetAPI_MakeOffset.hxx>
95 #include <BRepOffsetAPI_MakeEvolved.hxx>
96 #include <Extrema_ExtCS.hxx>
97 #include <GCPnts_QuasiUniformDeflection.hxx>
98 #include <GProp_GProps.hxx>
99 #include <GProp_PrincipalProps.hxx>
100
101 #include <AIS_Axis.hxx>
102 #include <AIS_ColoredShape.hxx>
103 #include <AIS_Plane.hxx>
104 #include <AIS_Point.hxx>
105 #include <AIS_TextLabel.hxx>
106
107 void TopologySamples::ExecuteSample (const TCollection_AsciiString& theSampleName)
108 {
109   Standard_Boolean anIsSamplePresent = Standard_True;
110   FindSourceCode(theSampleName);
111   if (theSampleName == "Vertex3dSample")
112     Vertex3dSample();
113   else if (theSampleName == "Edge3dSample")
114     Edge3dSample();
115   else if (theSampleName == "Face3dSample")
116     Face3dSample();
117   else if (theSampleName == "Wire3dSample")
118     Wire3dSample();
119   else if (theSampleName == "Shell3dSample")
120     Shell3dSample();
121   else if (theSampleName == "Solid3dSample")
122     Solid3dSample();
123   else if (theSampleName == "Edge2dSample")
124     Edge2dSample();
125   else if (theSampleName == "Box3dSample")
126     Box3dSample();
127   else if (theSampleName == "Cylinder3dSample")
128     Cylinder3dSample();
129   else if (theSampleName == "Revolution3dSample")
130     Revolution3dSample();
131   else if (theSampleName == "TopologyIterator3dSample")
132     TopologyIterator3dSample();
133   else if (theSampleName == "TopologyExplorer3dSample")
134     TopologyExplorer3dSample();
135   else if (theSampleName == "AssessToCurve3dSample")
136     AssessToCurve3dSample();
137   else if (theSampleName == "AssessToCompositeCurve3dSample")
138     AssessToCompositeCurve3dSample();
139   else if (theSampleName == "AssessToSurface3dSample")
140     AssessToSurface3dSample();
141   else if (theSampleName == "Common3dSample")
142     Common3dSample();
143   else if (theSampleName == "Cut3dSample")
144     Cut3dSample();
145   else if (theSampleName == "Cut3dSample")
146     Cut3dSample();
147   else if (theSampleName == "Fuse3dSample")
148     Fuse3dSample();
149   else if (theSampleName == "Section3dSample")
150     Section3dSample();
151   else if (theSampleName == "Splitter3dSample")
152     Splitter3dSample();
153   else if (theSampleName == "Defeaturing3dSample")
154     Defeaturing3dSample();
155   else if (theSampleName == "Fillet3dSample")
156     Fillet3dSample();
157   else if (theSampleName == "Chamfer3dSample")
158     Chamfer3dSample();
159   else if (theSampleName == "Offset3dSample")
160     Offset3dSample();
161   else if (theSampleName == "Evolved3dSample")
162     Evolved3dSample();
163   else if (theSampleName == "Copy3dSample")
164     Copy3dSample();
165   else if (theSampleName == "Transform3dSample")
166     Transform3dSample();
167   else if (theSampleName == "ConvertToNurbs3dSample")
168     ConvertToNurbs3dSample();
169   else if (theSampleName == "SewContiguousFaces3dSample")
170     SewContiguousFaces3dSample();
171   else if (theSampleName == "CheckValidity3dSample")
172     CheckValidity3dSample();
173   else if (theSampleName == "ComputeLinearProperties3dSample")
174     ComputeLinearProperties3dSample();
175   else if (theSampleName == "ComputeSurfaceProperties3dSample")
176     ComputeSurfaceProperties3dSample();
177   else if (theSampleName == "ComputeVolumeProperties3dSample")
178     ComputeVolumeProperties3dSample();
179   else
180   {
181     myResult << "No function found: " << theSampleName;
182     myCode += TCollection_AsciiString("No function found: ") + theSampleName;
183     anIsSamplePresent = Standard_False;
184   }
185   myIsProcessed = anIsSamplePresent;
186 }
187
188 void TopologySamples::Vertex3dSample()
189 {
190   // Make a vertex from a 3D point.
191   gp_Pnt aPnt(0.0, 0.0, 10.0);
192   TopoDS_Vertex aVertex = BRepBuilderAPI_MakeVertex(aPnt);
193   myResult << "TopoDS_Vertex was created at [ "
194            << aPnt.X() << ", " << aPnt.Y() << ", " << aPnt.Z()
195            << " ]" << std::endl;
196
197   Handle(AIS_Shape) aAisVertex = new AIS_Shape(aVertex);
198   Handle(AIS_TextLabel) anAisLabel = new AIS_TextLabel();
199   Standard_SStream aSS;
200   aSS << "TopoDS_Vertex [" << aPnt.X() << ", " << aPnt.Y() << ", " << aPnt.Z() << "]" << std::endl;
201   anAisLabel->SetText(aSS.str().c_str());
202   anAisLabel->SetPosition(aPnt);
203   myObject3d.Append(aAisVertex);
204   myObject3d.Append(anAisLabel);
205 }
206
207 void TopologySamples::Edge3dSample()
208 {
209   // Make an edge from two 3D points.
210   gp_Pnt aPnt1(0.0, 10.0, 0.0);
211   gp_Pnt aPnt2(10.0, 10.0, 0.0);
212   TopoDS_Edge anEdgeP12 = BRepBuilderAPI_MakeEdge(aPnt1, aPnt2);
213   myResult << "TopoDS_Edge between [ "
214            << aPnt1.X() << ", " << aPnt1.Y() << ", " << aPnt1.Z()
215            << " ] and [ "
216            << aPnt2.X() << ", " << aPnt2.Y() << ", " << aPnt2.Z()
217            << " ] was created in yellow" << std::endl
218            << std::endl;
219
220   // Make an edge from a circular segment.
221   // Create a circle in XY plane of the radius 5.0.
222   gp_Circ aCirc(gp::XOY(), 5.0);
223   // Make a circular edge from the 1st quoter in the parametric space.
224   TopoDS_Edge anEdgeCirc = BRepBuilderAPI_MakeEdge(aCirc, 0.0, M_PI_2);
225   myResult << "TopoDS_Edge on the circle's 1st quoter" << std::endl
226            << "with the center at [ "
227            << aCirc.Location().X() << ", " << aCirc.Location().Y() << ", " << aCirc.Location().Z()
228            << " ] and R = " << aCirc.Radius() << " was created in red" << std::endl
229            << std::endl;
230
231   // Make an edge from a 3D curve (BSpline).
232   // Define points.
233   gp_Pnt aPole1(0.0, 0.0, 10.0);
234   gp_Pnt aPole2(5.0, 5.0, 5.0);
235   gp_Pnt aPole3(10.0, 10.0, 15.0);
236   gp_Pnt aPole4(15.0, 5.0, 20.0);
237   // Add points to the curve poles array.
238   TColgp_Array1OfPnt aPoles(1, 4);
239   aPoles.SetValue(1, aPole1);
240   aPoles.SetValue(2, aPole2);
241   aPoles.SetValue(3, aPole3);
242   aPoles.SetValue(4, aPole4);
243   // Make a BSpline curve from the points array
244   Handle(Geom_BSplineCurve) aBSplineCurve = GeomAPI_PointsToBSpline(aPoles).Curve();
245   // Make an edge between two point on the BSpline curve.
246   gp_Pnt aPntOnCurve1, aPntOnCurve2;
247   aBSplineCurve->D0 (0.75 * aBSplineCurve->FirstParameter()
248                    + 0.25 * aBSplineCurve->LastParameter(),
249                      aPntOnCurve1);
250   aBSplineCurve->D0 (0.25 * aBSplineCurve->FirstParameter()
251                    + 0.75 * aBSplineCurve->LastParameter(),
252                      aPntOnCurve2);
253   TopoDS_Edge anEdgeBSpline = BRepBuilderAPI_MakeEdge(aBSplineCurve, aPntOnCurve1, aPntOnCurve2);
254   myResult << "TopoDS_Edge on the BSpline curve" << std::endl
255            << "between [ "
256            << aPntOnCurve1.X() << ", " << aPntOnCurve1.Y() << ", " << aPntOnCurve1.Z()
257            << " ] and [ "
258            << aPntOnCurve2.X() << ", " << aPntOnCurve2.Y() << ", " << aPntOnCurve2.Z()
259            << " ]" << std::endl
260            << "was created in green" << std::endl;
261
262   Handle(AIS_ColoredShape) anAisEdgeP12 = new AIS_ColoredShape(anEdgeP12);
263   Handle(AIS_ColoredShape) anAisEdgeCirc = new AIS_ColoredShape(anEdgeCirc);
264   Handle(AIS_ColoredShape) anAisEdgeBSpline = new AIS_ColoredShape(anEdgeBSpline);
265   anAisEdgeP12->SetColor(Quantity_Color(Quantity_NOC_YELLOW));
266   anAisEdgeCirc->SetColor(Quantity_Color(Quantity_NOC_RED));
267   anAisEdgeBSpline->SetColor(Quantity_Color(Quantity_NOC_GREEN));
268   myObject3d.Append(anAisEdgeP12);
269   myObject3d.Append(anAisEdgeCirc);
270   myObject3d.Append(anAisEdgeBSpline);
271   Handle(AIS_TextLabel) anAisEdgeP12Label = new AIS_TextLabel();
272   anAisEdgeP12Label->SetText("Edge between two points");
273   anAisEdgeP12Label->SetPosition(0.5 * (aPnt1.XYZ() + aPnt2.XYZ()));
274   anAisEdgeP12Label->SetColor(Quantity_Color(Quantity_NOC_YELLOW));
275   myObject3d.Append(anAisEdgeP12Label);
276   Handle(AIS_TextLabel) anAisEdgeCircLabel = new AIS_TextLabel();
277   anAisEdgeCircLabel->SetText("Circular edge");
278   anAisEdgeCircLabel->SetPosition(aCirc.Location());
279   anAisEdgeCircLabel->SetColor(Quantity_Color(Quantity_NOC_RED));
280   myObject3d.Append(anAisEdgeCircLabel);
281   Handle(AIS_TextLabel) anAisEdgeBSplineLabel = new AIS_TextLabel();
282   anAisEdgeBSplineLabel->SetText("BSpline edge");
283   anAisEdgeBSplineLabel->SetPosition(aPole3);
284   anAisEdgeBSplineLabel->SetColor(Quantity_Color(Quantity_NOC_GREEN));
285   myObject3d.Append(anAisEdgeBSplineLabel);
286   TopoDS_Vertex anEdgeP12_V1, anEdgeP12_V2;
287   TopExp::Vertices(anEdgeP12, anEdgeP12_V1, anEdgeP12_V2);
288   myObject3d.Append(new AIS_Shape(anEdgeP12_V1));
289   myObject3d.Append(new AIS_Shape(anEdgeP12_V2));
290   TopoDS_Vertex anEdgeCirc_V1, anEdgeCirc_V2;
291   TopExp::Vertices(anEdgeCirc, anEdgeCirc_V1, anEdgeCirc_V2);
292   myObject3d.Append(new AIS_Shape(anEdgeCirc_V1));
293   myObject3d.Append(new AIS_Shape(anEdgeCirc_V2));
294   TopoDS_Vertex anEdgeBSpline_V1, anEdgeBSpline_V2;
295   TopExp::Vertices(anEdgeBSpline, anEdgeBSpline_V1, anEdgeBSpline_V2);
296   myObject3d.Append(new AIS_Shape(anEdgeBSpline_V1));
297   myObject3d.Append(new AIS_Shape(anEdgeBSpline_V2));
298 }
299
300 void TopologySamples::Face3dSample()
301 {
302   // Make a face from a sphere with the center
303   // at [0.0, 0.0, 10.0] and R = 5.
304   gp_Sphere aSphere(gp_Ax3(gp_Pnt(0.0, 0.0, 10.0), gp::DZ()), 5.0);
305   TopoDS_Face aFaceSphere = BRepBuilderAPI_MakeFace(aSphere);
306   myResult << "TopoDS_Face on the sphere with" << std::endl
307            << "the center at [ "
308            << aSphere.Location().X() << ", " << aSphere.Location().Y() << ", " << aSphere.Location().Z()
309            << " ] and R = " << aSphere.Radius() << " was created in yellow" << std::endl
310            << std::endl;
311
312   // Make a flat rectangular face on XY plane.
313   gp_Pln aPln(gp::XOY());
314   TopoDS_Face aFaceRect = BRepBuilderAPI_MakeFace(aPln, -10.0, +10.0, -20.0, +20.0);
315   myResult << "TopoDS_Face on the rectangle was created in red" << std::endl
316            << std::endl;
317
318   // Make a face from a BSpline surface.
319   // Define a 4x4 grid of points for BSpline surface.
320   TColgp_Array2OfPnt aPoints(1, 4, 1, 4);
321   for (Standard_Integer i = 1; i <= 4; ++i)
322   {
323     gp_Pnt aPnt;
324     aPnt.SetX(5.0 * i);
325     for (Standard_Integer j = 1; j <= 4; ++j)
326     {
327       aPnt.SetY(5.0 * j);
328       if (1 < i && i < 4 && 1 < j && j < 4)
329       {
330         aPnt.SetZ(15.0);
331       }
332       else
333       {
334         aPnt.SetZ(10.0);
335       }
336       aPoints.SetValue(i, j, aPnt);
337     }
338   }
339   // Make a BSpline surface from the points array.
340   Handle(Geom_BSplineSurface) aBSplineSurf = GeomAPI_PointsToBSplineSurface(aPoints).Surface();
341   Standard_Real aU1, aU2, aV1, aV2;
342   aBSplineSurf->Bounds(aU1, aU2, aV1, aV2);
343   TopoDS_Face aFaceBSpline = BRepBuilderAPI_MakeFace(aBSplineSurf, aU1, aU2, aV1, aV2, Precision::Confusion());
344   myResult << "TopoDS_Face on the BSpline surface was created in green" << std::endl << std::endl;
345
346   Handle(AIS_ColoredShape) anAisFaceSphere = new AIS_ColoredShape(aFaceSphere);
347   Handle(AIS_ColoredShape) anAisFaceRect = new AIS_ColoredShape(aFaceRect);
348   Handle(AIS_ColoredShape) anAisFaceBSpline = new AIS_ColoredShape(aFaceBSpline);
349   anAisFaceSphere->SetColor(Quantity_Color(Quantity_NOC_YELLOW));
350   anAisFaceRect->SetColor(Quantity_Color(Quantity_NOC_RED));
351   anAisFaceBSpline->SetColor(Quantity_Color(Quantity_NOC_GREEN));
352   myObject3d.Append(anAisFaceSphere);
353   myObject3d.Append(anAisFaceRect);
354   myObject3d.Append(anAisFaceBSpline);
355   Handle(AIS_TextLabel) anAisFaceSphereLabel = new AIS_TextLabel();
356   anAisFaceSphereLabel->SetText("Spherical face");
357   anAisFaceSphereLabel->SetPosition(aSphere.Location().XYZ() + aSphere.Radius() * gp::DZ().XYZ());
358   anAisFaceSphereLabel->SetColor(Quantity_Color(Quantity_NOC_YELLOW));
359   myObject3d.Append(anAisFaceSphereLabel);
360   Handle(AIS_TextLabel) anAisFaceRectLabel = new AIS_TextLabel();
361   anAisFaceRectLabel->SetText("Flat rectangular face");
362   anAisFaceRectLabel->SetPosition(aPln.Location().XYZ() + 2.5 * gp::DZ().XYZ());
363   anAisFaceRectLabel->SetColor(Quantity_Color(Quantity_NOC_RED));
364   myObject3d.Append(anAisFaceRectLabel);
365   Handle(AIS_TextLabel) anAisFaceBSplineLabel = new AIS_TextLabel();
366   anAisFaceBSplineLabel->SetText("BSpline face");
367   anAisFaceBSplineLabel->SetPosition(aPoints(4, 4));
368   anAisFaceBSplineLabel->SetColor(Quantity_Color(Quantity_NOC_GREEN));
369   myObject3d.Append(anAisFaceBSplineLabel);
370 }
371
372 void TopologySamples::Wire3dSample()
373 {
374   // Make a wire from edges created on a set of points.
375   // Add points to the curve poles array.
376   TColgp_Array1OfPnt aPoints(1, 4);
377   aPoints.SetValue(1, gp_Pnt(0.0, 0.0, 0.0));
378   aPoints.SetValue(2, gp_Pnt(20.0, 0.0, 0.0));
379   aPoints.SetValue(3, gp_Pnt(20.0, 10.0, 0.0));
380   aPoints.SetValue(4, gp_Pnt(0.0, 10.0, 0.0));
381   // A wire maker contains an empty wire.
382   BRepBuilderAPI_MakeWire aMakeWire;
383   for (Standard_Integer i = 1; i <= 4; ++i)
384   {
385     Standard_Integer i1 = i;
386     Standard_Integer i2 = i1 < 4 ? i1 + 1 : 1;
387     const gp_Pnt& aPnt1 = aPoints.Value(i1);
388     const gp_Pnt& aPnt2 = aPoints.Value(i2);
389     TopoDS_Edge anEdge = BRepBuilderAPI_MakeEdge(aPnt1, aPnt2);
390     // Add an edge to the wire under construction.
391     // The edge must be connectible to the wire under construction, and,
392     // unless it is the first edge of the wire, must satisfy the following
393     // condition: one of its vertices must be geometrically coincident
394     // with one of the vertices of the wire (provided that the highest
395     // tolerance factor is assigned to the two vertices).
396     // It could also be the same vertex.
397     // Warning
398     // If the edge is not connectible to the wire under construction it is not added.
399     // The function IsDone will return false and the function
400     // Wire will raise an error, until a new connectible edge is added.
401     aMakeWire.Add(anEdge);
402     Standard_ASSERT_VOID(aMakeWire.IsDone(), "Added edge isn't connectible!");
403   }
404   // Retrieve a constructed wire.
405   TopoDS_Wire aWire = aMakeWire.Wire();
406   myResult << "TopoDS_Wire was created. Vertices :" << std::endl;
407   // Retrieve wire vertices. 4 vertices are expected, because of
408   // edges connecting during wire constructing.
409   TopTools_IndexedMapOfShape aVertices;
410   TopExp::MapShapes(aWire, TopAbs_VERTEX, aVertices);
411   for (TopTools_IndexedMapOfShape::Iterator anIt(aVertices); anIt.More(); anIt.Next())
412   {
413     TopoDS_Vertex aVertex = TopoDS::Vertex(anIt.Value());
414     gp_Pnt aPnt = BRep_Tool::Pnt(aVertex);
415     myResult << "[ " << aPnt.X() << ", " << aPnt.Y() << ", " << aPnt.Z() << " ]" << std::endl;
416     Handle(AIS_Shape) anAisVertex = new AIS_Shape(aVertex);
417     myObject3d.Append(anAisVertex);
418   }
419
420   Handle(AIS_Shape) anAisWire = new AIS_Shape(aWire);
421   myObject3d.Append(anAisWire);
422 }
423
424 void TopologySamples::Shell3dSample()
425 {
426   // Make a shell from a cylinder with R = 5 and directed along Z axis
427   gp_Cylinder aCyl(gp::XOY(), 5.0);
428   Handle(Geom_Surface) aCylSurf = new Geom_CylindricalSurface(aCyl);
429   TopoDS_Shell aCylShell = BRepBuilderAPI_MakeShell(aCylSurf, 0.0, 2.0 * M_PI, -10.0, +10.0);
430   myResult << "TopoDS_Shell on the cylinder R = " << aCyl.Radius() << std::endl
431            << "with axis [ "
432            << aCyl.Position().Direction().X() << ", "
433            << aCyl.Position().Direction().Y() << ", "
434            << aCyl.Position().Direction().Z() << " ]" << std::endl
435            << "limited in length [-10 ... +10] was created" << std::endl;
436
437   Handle(AIS_Shape) anAisShell = new AIS_Shape(aCylShell);
438   myObject3d.Append(anAisShell);
439 }
440
441 void TopologySamples::Solid3dSample()
442 {
443   // Make a torus from a shell.
444   gp_Torus aTorus(gp::XOY(), 20.0, 7.5);
445   Handle(Geom_Surface) aTorusSurf = new Geom_ToroidalSurface(aTorus);
446   TopoDS_Shell aTorusShell = BRepBuilderAPI_MakeShell(aTorusSurf, 0.0, 2.0 * M_PI, 0.0, 2.0 * M_PI);
447   // Make a solid on the torus shell.
448   TopoDS_Solid aTorusSolid = BRepBuilderAPI_MakeSolid(aTorusShell);
449   myResult << "TopoDS_Solid on the torus with" << std::endl
450            << "R major = " << aTorus.MajorRadius() << std::endl
451            << "R minor = " << aTorus.MinorRadius() << std::endl
452            << "was created" << std::endl;
453
454   Handle(AIS_Shape) anAisSolid = new AIS_Shape(aTorusSolid);
455   myObject3d.Append(anAisSolid);
456 }
457
458 void TopologySamples::Edge2dSample()
459 {
460   // Make an edge from two 2D points.
461   gp_Pnt2d aPnt1(0.0, 10.0);
462   gp_Pnt2d aPnt2(10.0, 10.0);
463   TopoDS_Edge anEdgeP12 = BRepBuilderAPI_MakeEdge2d(aPnt1, aPnt2);
464   myResult << "TopoDS_Edge between [ "
465            << aPnt1.X() << ", " << aPnt1.Y() << " ] and [ "
466            << aPnt2.X() << ", " << aPnt2.Y() << " ] was created in yellow" << std::endl
467            << std::endl;
468
469   // Make an edge from a circular segment.
470   // Create a circle of the radius 5.0.
471   gp_Circ2d aCirc(gp::OX2d(), 5.0);
472   // Make a circular edge from the 1st quoter in the parametric space.
473   TopoDS_Edge anEdgeCirc = BRepBuilderAPI_MakeEdge2d(aCirc, 0.0, M_PI_2);
474   myResult << "TopoDS_Edge on the 2D circle's 1st quoter" << std::endl
475            << "with the center at [ " << aCirc.Location().X() << ", " << aCirc.Location().Y()
476            << " ] and R = " << aCirc.Radius() << " was created in red" << std::endl
477            << std::endl;
478
479   // Make an edge from a 2D curve (BSpline).
480   // Define points.
481   gp_Pnt2d aPole1(0.0, 0.0);
482   gp_Pnt2d aPole2(5.0, 5.0);
483   gp_Pnt2d aPole3(10.0, 10.0);
484   gp_Pnt2d aPole4(15.0, 5.0);
485   // Add points to the curve poles array.
486   TColgp_Array1OfPnt2d aPoles(1, 4);
487   aPoles.SetValue(1, aPole1);
488   aPoles.SetValue(2, aPole2);
489   aPoles.SetValue(3, aPole3);
490   aPoles.SetValue(4, aPole4);
491   // Make a BSpline curve from the points array
492   Handle(Geom2d_BSplineCurve) aBSplineCurve = Geom2dAPI_PointsToBSpline(aPoles).Curve();
493   // Make an edge between two point on the BSpline curve.
494   gp_Pnt2d aPntOnCurve1, aPntOnCurve2;
495   aBSplineCurve->D0 (0.75 * aBSplineCurve->FirstParameter()
496                    + 0.25 * aBSplineCurve->LastParameter(),
497                      aPntOnCurve1);
498   aBSplineCurve->D0 (0.25 * aBSplineCurve->FirstParameter()
499                    + 0.75 * aBSplineCurve->LastParameter(),
500                      aPntOnCurve2);
501   TopoDS_Edge anEdgeBSpline = BRepBuilderAPI_MakeEdge2d(aBSplineCurve, aPntOnCurve1, aPntOnCurve2);
502   myResult << "TopoDS_Edge on the 2D BSpline curve" << std::endl
503            << "between [ " << aPntOnCurve1.X() << ", " << aPntOnCurve1.Y()
504            << " ] and [ " << aPntOnCurve2.X() << ", " << aPntOnCurve2.Y() << " ]" << std::endl
505            << "was created in green" << std::endl;
506
507   Handle(AIS_ColoredShape) anAisEdgeP12 = new AIS_ColoredShape(anEdgeP12);
508   Handle(AIS_ColoredShape) anAisEdgeCirc = new AIS_ColoredShape(anEdgeCirc);
509   Handle(AIS_ColoredShape) anAisEdgeBSpline = new AIS_ColoredShape(anEdgeBSpline);
510   anAisEdgeP12->SetColor(Quantity_Color(Quantity_NOC_YELLOW));
511   anAisEdgeCirc->SetColor(Quantity_Color(Quantity_NOC_RED));
512   anAisEdgeBSpline->SetColor(Quantity_Color(Quantity_NOC_GREEN));
513   myObject2d.Append(anAisEdgeP12);
514   myObject2d.Append(anAisEdgeCirc);
515   myObject2d.Append(anAisEdgeBSpline);
516   Handle(AIS_TextLabel) anAisEdgeP12Label = new AIS_TextLabel();
517   anAisEdgeP12Label->SetText("Edge between two 2d points");
518   anAisEdgeP12Label->SetPosition(0.5 * (gp_XYZ(aPnt1.X(), aPnt1.Y() + 0.5, 0.0) + gp_XYZ(aPnt2.X(), aPnt2.Y() + 0.5, 0.0)));
519   anAisEdgeP12Label->SetColor(Quantity_Color(Quantity_NOC_YELLOW));
520   myObject2d.Append(anAisEdgeP12Label);
521   Handle(AIS_TextLabel) anAisEdgeCircLabel = new AIS_TextLabel();
522   anAisEdgeCircLabel->SetText("Circular edge");
523   anAisEdgeCircLabel->SetPosition(gp_XYZ(aCirc.Location().X(), aCirc.Location().Y() + 0.5, 0.0));
524   anAisEdgeCircLabel->SetColor(Quantity_Color(Quantity_NOC_RED));
525   myObject2d.Append(anAisEdgeCircLabel);
526   Handle(AIS_TextLabel) anAisEdgeBSplineLabel = new AIS_TextLabel();
527   anAisEdgeBSplineLabel->SetText("BSpline edge");
528   anAisEdgeBSplineLabel->SetPosition(gp_XYZ(aPole3.X(), aPole3.Y() + 0.5, 0.0));
529   anAisEdgeBSplineLabel->SetColor(Quantity_Color(Quantity_NOC_GREEN));
530   myObject2d.Append(anAisEdgeBSplineLabel);
531   TopoDS_Vertex anEdgeP12_V1, anEdgeP12_V2;
532   TopExp::Vertices(anEdgeP12, anEdgeP12_V1, anEdgeP12_V2);
533   myObject2d.Append(new AIS_Shape(anEdgeP12_V1));
534   myObject2d.Append(new AIS_Shape(anEdgeP12_V2));
535   TopoDS_Vertex anEdgeCirc_V1, anEdgeCirc_V2;
536   TopExp::Vertices(anEdgeCirc, anEdgeCirc_V1, anEdgeCirc_V2);
537   myObject2d.Append(new AIS_Shape(anEdgeCirc_V1));
538   myObject2d.Append(new AIS_Shape(anEdgeCirc_V2));
539   TopoDS_Vertex anEdgeBSpline_V1, anEdgeBSpline_V2;
540   TopExp::Vertices(anEdgeBSpline, anEdgeBSpline_V1, anEdgeBSpline_V2);
541   myObject2d.Append(new AIS_Shape(anEdgeBSpline_V1));
542   myObject2d.Append(new AIS_Shape(anEdgeBSpline_V2));
543 }
544
545 void TopologySamples::Box3dSample()
546 {
547   // Make a box with a corner at [0, 0, 0] and the specified sizes.
548   Standard_Real aSizeX = 5.0;
549   Standard_Real aSizeY = 10.0;
550   Standard_Real aSizeZ = 15.0;
551   TopoDS_Shape aBox1 = BRepPrimAPI_MakeBox(aSizeX, aSizeY, aSizeZ);
552   myResult << "Box at corner [0, 0, 0] and sizes ["
553            << aSizeX << ", " << aSizeY << ", " << aSizeZ
554            << "] was created in yellow" << std::endl;
555
556   // Make a box by two points.
557   gp_Pnt aPnt1(10.0, 0.0, 0.0);
558   gp_Pnt aPnt2(20.0, 10.0, 15.0);
559   TopoDS_Shape aBox2 = BRepPrimAPI_MakeBox(aPnt1, aPnt2);
560   myResult << "Box with corners ["
561            << aPnt1.X() << ", " << aPnt1.Y() << ", " << aPnt1.Z()
562            << "] and ["
563            << aPnt2.X() << ", " << aPnt2.Y() << ", " << aPnt2.Z()
564            << "] was created in red" << std::endl;
565
566   Handle(AIS_ColoredShape) anAisBox1 = new AIS_ColoredShape(aBox1);
567   Handle(AIS_ColoredShape) anAisBox2 = new AIS_ColoredShape(aBox2);
568   anAisBox1->SetColor(Quantity_Color(Quantity_NOC_YELLOW));
569   anAisBox2->SetColor(Quantity_Color(Quantity_NOC_RED));
570   myObject3d.Append(anAisBox1);
571   myObject3d.Append(anAisBox2);
572 }
573
574 void TopologySamples::Cylinder3dSample()
575 {
576   // Make a cylinder of the specified radius and length.
577   Standard_Real aRadius1 = 5.0;
578   Standard_Real aLength1 = 15.0;
579   TopoDS_Shape aCyl1 = BRepPrimAPI_MakeCylinder(aRadius1, aLength1);
580   myResult << "Cylinder with Radius = " << aRadius1
581            << " and Length = " << aLength1
582            << " was created in yellow" << std::endl;
583
584   // Make a cylinder of the specified radius, length and sector angle.
585   Standard_Real aRadius2 = 8.0;
586   Standard_Real aLength2 = 25.0;
587   Standard_Real anAngle = M_PI_2;
588   TopoDS_Shape aCyl2 = BRepPrimAPI_MakeCylinder(aRadius2, aLength2, anAngle);
589   myResult << "Cylinder with Radius = " << aRadius2
590            << " , Length = " << aLength2
591            << " and Angle = " << anAngle
592            << " was created in red" << std::endl;
593
594   Handle(AIS_ColoredShape) anAisCyl1 = new AIS_ColoredShape(aCyl1);
595   Handle(AIS_ColoredShape) anAisCyl2 = new AIS_ColoredShape(aCyl2);
596   anAisCyl1->SetColor(Quantity_Color(Quantity_NOC_YELLOW));
597   anAisCyl2->SetColor(Quantity_Color(Quantity_NOC_RED));
598   myObject3d.Append(anAisCyl1);
599   myObject3d.Append(anAisCyl2);
600 }
601
602 void TopologySamples::Revolution3dSample()
603 {
604   // Make a toroidal face by a series of shape revolves.
605   // Make a starting vertex at [-1.0, 0, 0].
606   TopoDS_Shape aVertex = BRepBuilderAPI_MakeVertex(gp_Pnt(-1.0, 0.0, 0.0));
607
608   // Make a circular edge by revolting aVertex around
609   // an axis Y positioned at [-1.5, 0.0, 0.0] on 2*Pi angle
610   gp_Ax1 anAxis1(gp_Pnt(-1.5, 0.0, 0.0), gp::DY());
611   TopoDS_Shape anEdge = BRepPrimAPI_MakeRevol(aVertex, anAxis1);
612   myResult << "Circular edge was created in yellow" << std::endl;
613
614   // Make a toroidal face by revolting anEdge around
615   // Z axis on 2*Pi angle.
616   TopoDS_Shape aFace = BRepPrimAPI_MakeRevol(anEdge, gp::OZ());
617   myResult << "Toroidal face was created in red" << std::endl;
618
619   Handle(AIS_Axis) anAisAxis1 = new AIS_Axis(new Geom_Axis1Placement(anAxis1));
620   Handle(AIS_Axis) anAisAxis2 = new AIS_Axis(new Geom_Axis1Placement(gp::OZ()));
621   Handle(AIS_Shape) anAisVertex = new AIS_Shape(aVertex);
622   Handle(AIS_ColoredShape) anAisEdge = new AIS_ColoredShape(anEdge);
623   Handle(AIS_ColoredShape) anAisFace = new AIS_ColoredShape(aFace);
624   anAisEdge->SetColor(Quantity_Color(Quantity_NOC_GREEN));
625   anAisEdge->SetWidth(1.5);
626   anAisAxis1->SetColor(Quantity_NOC_GREEN);
627   anAisFace->SetColor(Quantity_Color(Quantity_NOC_RED));
628   anAisAxis2->SetColor(Quantity_NOC_RED);
629   myObject3d.Append(anAisVertex);
630   myObject3d.Append(anAisEdge);
631   myObject3d.Append(anAisFace);
632 }
633
634 void TopologySamples::TopologyIterator3dSample()
635 {
636   // Make a compound shape.
637   TopoDS_Compound aComp;
638   BRep_Builder aBuilder;
639   aBuilder.MakeCompound(aComp);
640   // Add shapes to the compound.
641   aBuilder.Add(aComp, BRepBuilderAPI_MakeVertex(gp::Origin()));
642   aBuilder.Add(aComp, BRepBuilderAPI_MakeEdge(gp_Pnt(5.0, 0.0, 0.0), gp_Pnt(10.0, 0.0, 0.0)));
643   aBuilder.Add(aComp, BRepBuilderAPI_MakeFace(gp_Sphere(gp::XOY(), 10.0)));
644   aBuilder.Add(aComp, BRepBuilderAPI_MakeWire(
645     BRepBuilderAPI_MakeEdge(gp_Pnt(15.0, 0.0, 0.0), gp_Pnt(20.0, 0.0, 0.0)),
646     BRepBuilderAPI_MakeEdge(gp_Pnt(20.0, 0.0, 0.0), gp_Pnt(25.0, 10.0, 5.0))
647   ));
648   aBuilder.Add(aComp, BRepPrimAPI_MakeBox(5.0, 6.0, 7.0).Shell());
649   aBuilder.Add(aComp, BRepPrimAPI_MakeBox(5.0, 6.0, 7.0).Solid());
650   TopoDS_Compound aComp1;
651   aBuilder.MakeCompound(aComp1);
652   aBuilder.Add(aComp, aComp1);
653
654   // Iterate over compound components.
655   myResult << "Compound components:" << std::endl;
656   Standard_Integer anI = 1;
657   for (TopoDS_Iterator anIt(aComp); anIt.More(); anIt.Next(), ++anI)
658   {
659     const TopoDS_Shape& aShape = anIt.Value();
660     myResult << "#" << anI << " : ";
661     Handle(AIS_ColoredShape) anAisShape;
662     switch (aShape.ShapeType())
663     {
664       case TopAbs_VERTEX:
665         myResult << "TopAbs_VERTEX";
666         anAisShape = new AIS_ColoredShape(aShape);
667         anAisShape->SetColor(Quantity_Color(Quantity_NOC_YELLOW));
668         break;
669       case TopAbs_EDGE:
670         anAisShape = new AIS_ColoredShape(aShape);
671         anAisShape->SetColor(Quantity_Color(Quantity_NOC_GREEN));
672         myResult << "TopAbs_EDGE";
673         break;
674       case TopAbs_WIRE:
675         myResult << "TopAbs_WIRE";
676         break;
677       case TopAbs_FACE:
678         anAisShape = new AIS_ColoredShape(aShape);
679         anAisShape->SetColor(Quantity_Color(Quantity_NOC_RED));
680         myResult << "TopAbs_FACE";
681         break;
682       case TopAbs_SHELL:
683         myResult << "TopAbs_SHELL";
684         break;
685       case TopAbs_SOLID:
686         myResult << "TopAbs_SOLID";
687         break;
688       case TopAbs_COMPOUND:
689         myResult << "TopAbs_COMPOUND";
690         break;
691       case TopAbs_COMPSOLID:
692         myResult << "TopAbs_COMPSOLID";
693         break;
694       case TopAbs_SHAPE:
695         myResult << "TopAbs_SHAPE";
696         break;
697     }
698     myResult << std::endl;
699     if (anAisShape)
700     {
701       myObject3d.Append(anAisShape);
702     }
703   }
704 }
705
706 void TopologySamples::TopologyExplorer3dSample()
707 {
708   // Make a box with a corner at [0, 0, 0] and the specified sizes.
709   Standard_Real aSizeX = 5.0;
710   Standard_Real aSizeY = 10.0;
711   Standard_Real aSizeZ = 15.0;
712   TopoDS_Shape aBox = BRepPrimAPI_MakeBox(aSizeX, aSizeY, aSizeZ);
713
714   // Explore vertex references.
715   myResult << "Vertex refs. : ";
716   Standard_Integer nbVertices = 0;
717   for (TopExp_Explorer anExp(aBox, TopAbs_VERTEX); anExp.More(); anExp.Next(), ++nbVertices)
718   {
719     const TopoDS_Shape& aShape = anExp.Current();
720     Handle(AIS_ColoredShape) anAisShape = new AIS_ColoredShape(aShape);
721     anAisShape->SetColor(Quantity_Color(Quantity_NOC_YELLOW));
722     myObject3d.Append(anAisShape);
723   }
724   myResult << nbVertices << std::endl;
725
726   // Explore edge references.
727   myResult << "Edge refs.   : ";
728   Standard_Integer nbEdges = 0;
729   for (TopExp_Explorer anExp(aBox, TopAbs_EDGE); anExp.More(); anExp.Next(), ++nbEdges)
730   {
731     const TopoDS_Shape& aShape = anExp.Current();
732     Handle(AIS_ColoredShape) anAisShape = new AIS_ColoredShape(aShape);
733     anAisShape->SetColor(Quantity_Color(Quantity_NOC_GREEN));
734     anAisShape->SetWidth(2.5);
735     myObject3d.Append(anAisShape);
736   }
737   myResult << nbEdges << std::endl;
738
739   // Explore face references.
740   myResult << "Face refs.   : ";
741   Standard_Integer nbFaces = 0;
742   for (TopExp_Explorer anExp(aBox, TopAbs_FACE); anExp.More(); anExp.Next(), ++nbFaces)
743   {
744     const TopoDS_Shape& aShape = anExp.Current();
745     Handle(AIS_ColoredShape) anAisShape = new AIS_ColoredShape(aShape);
746     anAisShape->SetColor(Quantity_Color(Quantity_NOC_GREEN));
747     anAisShape->SetWidth(2.5);
748     myObject3d.Append(anAisShape);
749   }
750   myResult << nbFaces << std::endl;
751
752   // Explore shell references.
753   myResult << "Wire refs.   : ";
754   Standard_Integer nbWires = 0;
755   for (TopExp_Explorer anExp(aBox, TopAbs_WIRE); anExp.More(); anExp.Next(), ++nbWires)
756   {
757   }
758   myResult << nbWires << std::endl;
759
760   // Explore shell references.
761   myResult << "Shell refs.  : ";
762   Standard_Integer nbShells = 0;
763   for (TopExp_Explorer anExp(aBox, TopAbs_SHELL); anExp.More(); anExp.Next(), ++nbShells)
764   {
765   }
766   myResult << nbShells << std::endl;
767
768   // Explore solid references.
769   myResult << "Solid refs.  : ";
770   Standard_Integer nbSolids = 0;
771   for (TopExp_Explorer anExp(aBox, TopAbs_SOLID); anExp.More(); anExp.Next(), ++nbSolids)
772   {
773   }
774   myResult << nbSolids << std::endl;
775 }
776
777 void TopologySamples::AssessToCurve3dSample()
778 {
779   // Make a face from a sphere.
780   gp_Sphere aSphere(gp::XOY(), 1.0);
781   TopoDS_Face aFace = BRepBuilderAPI_MakeFace(aSphere);
782   myResult << "TopoDS_Face on the sphere with" << std::endl
783            << "the center at [ "
784            << aSphere.Location().X() << ", " << aSphere.Location().Y() << ", " << aSphere.Location().Z()
785            << " ] and R = " << aSphere.Radius() << " was created in yellow" << std::endl
786            << std::endl;
787
788   Handle(AIS_ColoredShape) anAisFace = new AIS_ColoredShape(aFace);
789   anAisFace->SetColor(Quantity_Color(Quantity_NOC_YELLOW));
790   myObject3d.Append(anAisFace);
791
792   // Retrieve the first not degenerated edge.
793   TopoDS_Edge aCurveEdge;
794   for (TopExp_Explorer anExp(aFace, TopAbs_EDGE); anExp.More(); anExp.Next())
795   {
796     TopoDS_Edge anEdge = TopoDS::Edge(anExp.Current());
797     if (!BRep_Tool::Degenerated(anEdge))
798     {
799       aCurveEdge = anEdge;
800       break;
801     }
802   }
803   if (!aCurveEdge.IsNull())
804   {
805     // Make a curve on edge adaptor.
806     BRepAdaptor_Curve aCurveAdaptor(aCurveEdge);
807     myResult << "Curve adaptor for edge was built in red" << std::endl;
808
809     Handle(AIS_ColoredShape) anAisCurveEdge = new AIS_ColoredShape(aCurveEdge);
810     anAisCurveEdge->SetColor(Quantity_Color(Quantity_NOC_RED));
811     anAisCurveEdge->SetWidth(1.5);
812     myObject3d.Append(anAisCurveEdge);
813
814     // Use the curve adaptor for some calculations, e.g. compute
815     // a set of points using GCPnts_QuasiUniformDeflection algo.
816     Standard_Real aDeflection = 0.1;
817     GCPnts_QuasiUniformDeflection anAlgo(aCurveAdaptor, aDeflection);
818     Standard_ASSERT_VOID(anAlgo.IsDone(), "Success is expected!");
819     myResult << "Distribution of point on the curve with " << aDeflection
820              << " deflection was performed:" << std::endl;
821     for (Standard_Integer i = 1; i <= anAlgo.NbPoints(); ++i)
822     {
823       gp_Pnt aPnt = anAlgo.Value(i);
824       myResult << "Point #" << i << " : [ "
825                << aPnt.X() << ", " << aPnt.Y() << ", " << aPnt.Z() << " ]" << std::endl;
826       Handle(AIS_Point) anAisPnt = new AIS_Point(new Geom_CartesianPoint(aPnt));
827       myObject3d.Append(anAisPnt);
828     }
829   }
830 }
831
832 void TopologySamples::AssessToCompositeCurve3dSample()
833 {
834   // Make a wire containing two BSpline curves.
835   // Define points.
836   gp_Pnt aPole1(0.0, 0.0, 10.0);
837   gp_Pnt aPole2(5.0, 5.0, 5.0);
838   gp_Pnt aPole3(10.0, 10.0, 15.0);
839   gp_Pnt aPole4(15.0, 5.0, 20.0);
840   gp_Pnt aPole5(25.0, 15.0, 20.0);
841   gp_Pnt aPole6(35.0, 15.0, 15.0);
842   gp_Pnt aPole7(45.0, 25.0, 10.0);
843   // Add points to the curve poles array.
844   TColgp_Array1OfPnt aPoles1(1, 4), aPoles2(1, 4);
845   aPoles1.SetValue(1, aPole1);
846   aPoles1.SetValue(2, aPole2);
847   aPoles1.SetValue(3, aPole3);
848   aPoles1.SetValue(4, aPole4);
849   aPoles2.SetValue(1, aPole4);
850   aPoles2.SetValue(2, aPole5);
851   aPoles2.SetValue(3, aPole6);
852   aPoles2.SetValue(4, aPole7);
853   // Make a BSpline curves from the point arrays
854   Handle(Geom_BSplineCurve) aBSplineCurve1 = GeomAPI_PointsToBSpline(aPoles1).Curve();
855   Handle(Geom_BSplineCurve) aBSplineCurve2 = GeomAPI_PointsToBSpline(aPoles2).Curve();
856   // Make edges
857   TopoDS_Edge anEdge1 = BRepBuilderAPI_MakeEdge(aBSplineCurve1);
858   TopoDS_Edge anEdge2 = BRepBuilderAPI_MakeEdge(aBSplineCurve2);
859   // Make a wire
860   BRepBuilderAPI_MakeWire aMakeWire;
861   aMakeWire.Add(anEdge1);
862   aMakeWire.Add(anEdge2);
863   Standard_ASSERT_VOID(aMakeWire.IsDone(), "Added edge isn't connectible!");
864   TopoDS_Wire aWire = aMakeWire.Wire();
865   myResult << "Wire of two BSpline curves was created" << std::endl;
866
867   Handle(AIS_ColoredShape) anAisWire = new AIS_ColoredShape(aWire);
868   myObject3d.Append(anAisWire);
869
870   // Make an adaptor.
871   BRepAdaptor_CompCurve aCurveAdaptor(aWire);
872
873   // Use the curve adaptor for some calculations, e.g. compute
874   // a set of points using GCPnts_QuasiUniformDeflection algo.
875   Standard_Real aDeflection = 0.5;
876   GCPnts_QuasiUniformDeflection anAlgo(aCurveAdaptor, aDeflection);
877   Standard_ASSERT_VOID(anAlgo.IsDone(), "Success is expected!");
878   myResult << "Distribution of point on the curve with " << aDeflection
879            << " deflection was performed:" << std::endl;
880   for (Standard_Integer i = 1; i <= anAlgo.NbPoints(); ++i)
881   {
882     gp_Pnt aPnt = anAlgo.Value(i);
883     myResult << "Point #" << i << " : [ "
884              << aPnt.X() << ", " << aPnt.Y() << ", " << aPnt.Z() << " ]" << std::endl;
885     Handle(AIS_Point) anAisPnt = new AIS_Point(new Geom_CartesianPoint(aPnt));
886     myObject3d.Append(anAisPnt);
887   }
888 }
889
890 void TopologySamples::AssessToSurface3dSample()
891 {
892   // Make a face from a sphere.
893   gp_Sphere aSphere(gp::XOY(), 4.0);
894   TopoDS_Face aFace = BRepBuilderAPI_MakeFace(aSphere);
895   myResult << "TopoDS_Face on the sphere with" << std::endl
896            << "the center at [ "
897            << aSphere.Location().X() << ", " << aSphere.Location().Y() << ", " << aSphere.Location().Z()
898            << " ] and R = " << aSphere.Radius() << " was created in yellow" << std::endl
899            << std::endl;
900
901   // Make a surface adaptor.
902   BRepAdaptor_Surface aSurfAdaptor(aFace);
903
904   // Use the surface adaptor for some calculations, e.g. compute
905   // a normal vector at a surface point.
906   Standard_Real anU = 0.0, aV = 0.0;
907   gp_Pnt aPnt;
908   gp_Vec aDU, aDV;
909   aSurfAdaptor.D1(anU, aV, aPnt, aDU, aDV);
910   gp_Vec aNorm = aDU.Crossed(aDV);
911   Standard_ASSERT_VOID(aNorm.Magnitude() > Precision::Confusion(), "Non zero vector is expected!");
912   aNorm.Normalize();
913   myResult << "Normal vector at ( " << anU << ", " << aV << " )" << std::endl
914            << " = " << aNorm.X() << ", " << aNorm.Y() << ", " << aNorm.Z() << " ] is in red" << std::endl;
915
916   Handle(AIS_ColoredShape) anAisFace = new AIS_ColoredShape(aFace);
917   anAisFace->SetColor(Quantity_Color(Quantity_NOC_YELLOW));
918   Handle(AIS_Point) anAisPnt = new AIS_Point(new Geom_CartesianPoint(aPnt));
919   Handle(AIS_ColoredShape) anAisNorm = new AIS_ColoredShape(
920     BRepBuilderAPI_MakeEdge(aPnt, aPnt.XYZ() + aNorm.XYZ()));
921   myObject3d.Append(anAisFace);
922   myObject3d.Append(anAisNorm);
923   myObject3d.Append(anAisPnt);
924 }
925
926 void TopologySamples::Common3dSample()
927 {
928   // Make a box #1 with a corner at [0, 0, 0] and the specified sizes.
929   Standard_Real aSizeX = 10.0;
930   Standard_Real aSizeY = 15.0;
931   Standard_Real aSizeZ = 20.0;
932   TopoDS_Shape aShape1 = BRepPrimAPI_MakeBox(aSizeX, aSizeY, aSizeZ);
933   myResult << "Box at corner [0, 0, 0] and sizes ["
934            << aSizeX << ", " << aSizeY << ", " << aSizeZ
935            << "] was created in yellow wireframe" << std::endl;
936
937   // Make a box #2 by two points.
938   gp_Pnt aPnt1(5.0, 7.5, 10.0);
939   gp_Pnt aPnt2(20.0, 25.0, 30.0);
940   TopoDS_Shape aShape2 = BRepPrimAPI_MakeBox(aPnt1, aPnt2);
941   myResult << "Box with corners ["
942            << aPnt1.X() << ", " << aPnt1.Y() << ", " << aPnt1.Z()
943            << "] and ["
944            << aPnt2.X() << ", " << aPnt2.Y() << ", " << aPnt2.Z()
945            << "] was created in green wirefreme" << std::endl;
946
947   // Create a boolean algo.
948   BRepAlgoAPI_Common anAlgo(aShape1, aShape2);
949
950   // Make operation.
951   anAlgo.Build();
952
953   if (!anAlgo.IsDone()) // Process errors
954   {
955     myResult << "Errors : " << std::endl;
956     anAlgo.DumpErrors(myResult);
957   }
958   if (anAlgo.HasWarnings()) // Process warnings
959   {
960     myResult << "Warnings : " << std::endl;
961     anAlgo.DumpErrors(myResult);
962   }
963
964   if (anAlgo.IsDone())
965   {
966     // Get result.
967     TopoDS_Shape aResultShape = anAlgo.Shape();
968     myResult << "Result shape was created in red shading" << std::endl;
969
970     Handle(AIS_ColoredShape) anAisShape1 = new AIS_ColoredShape(aShape1);
971     Handle(AIS_ColoredShape) anAisShape2 = new AIS_ColoredShape(aShape2);
972     anAisShape1->SetColor(Quantity_Color(Quantity_NOC_YELLOW));
973     anAisShape2->SetColor(Quantity_Color(Quantity_NOC_GREEN));
974     Handle(AIS_ColoredShape) anAisResult = new AIS_ColoredShape(aResultShape);
975     anAisResult->SetColor(Quantity_Color(Quantity_NOC_RED));
976     myObject3d.Append(anAisShape1);
977     myObject3d.Append(anAisShape2);
978     myObject3d.Append(anAisResult);
979     myContext->SetDisplayMode(anAisShape1, 0, Standard_True);
980     myContext->SetDisplayMode(anAisShape2, 0, Standard_True);
981     myContext->SetDisplayMode(anAisResult, 1, Standard_True);
982   }
983 }
984
985 void TopologySamples::Cut3dSample()
986 {
987   // Make a box #1 with a corner at [0, 0, 0] and the specified sizes.
988   Standard_Real aSizeX = 10.0;
989   Standard_Real aSizeY = 15.0;
990   Standard_Real aSizeZ = 20.0;
991   TopoDS_Shape aShape1 = BRepPrimAPI_MakeBox(aSizeX, aSizeY, aSizeZ);
992   myResult << "Box at corner [0, 0, 0] and sizes ["
993            << aSizeX << ", " << aSizeY << ", " << aSizeZ
994            << "] was created in yellow wireframe" << std::endl;
995
996   // Make a box #2 by two points as a cutting tool.
997   gp_Pnt aPnt1(5.0, 7.5, 10.0);
998   gp_Pnt aPnt2(20.0, 25.0, 30.0);
999   TopoDS_Shape aShape2 = BRepPrimAPI_MakeBox(aPnt1, aPnt2);
1000   myResult << "Box with corners ["
1001            << aPnt1.X() << ", " << aPnt1.Y() << ", " << aPnt1.Z()
1002            << "] and ["
1003            << aPnt2.X() << ", " << aPnt2.Y() << ", " << aPnt2.Z()
1004            << "] was created in green wireframe" << std::endl;
1005
1006   // Create a boolean algo.
1007   BRepAlgoAPI_Cut anAlgo(aShape1, aShape2);
1008
1009   // Make operation.
1010   anAlgo.Build();
1011
1012   if (!anAlgo.IsDone()) // Process errors
1013   {
1014     myResult << "Errors : " << std::endl;
1015     anAlgo.DumpErrors(myResult);
1016   }
1017   if (anAlgo.HasWarnings()) // Process warnings
1018   {
1019     myResult << "Warnings : " << std::endl;
1020     anAlgo.DumpErrors(myResult);
1021   }
1022
1023   if (anAlgo.IsDone())
1024   {
1025     // Get result.
1026     TopoDS_Shape aResultShape = anAlgo.Shape();
1027     myResult << "Result shape was created in red shading" << std::endl;
1028     Handle(AIS_ColoredShape) anAisShape1 = new AIS_ColoredShape(aShape1);
1029     Handle(AIS_ColoredShape) anAisShape2 = new AIS_ColoredShape(aShape2);
1030     anAisShape1->SetColor(Quantity_Color(Quantity_NOC_YELLOW));
1031     anAisShape2->SetColor(Quantity_Color(Quantity_NOC_GREEN));
1032     Handle(AIS_ColoredShape) anAisResult = new AIS_ColoredShape(aResultShape);
1033     anAisResult->SetColor(Quantity_Color(Quantity_NOC_RED));
1034     myObject3d.Append(anAisShape1);
1035     myObject3d.Append(anAisShape2);
1036     myObject3d.Append(anAisResult);
1037     myContext->SetDisplayMode(anAisShape1, 0, Standard_True);
1038     myContext->SetDisplayMode(anAisShape2, 0, Standard_True);
1039     myContext->SetDisplayMode(anAisResult, 1, Standard_True);
1040   }
1041 }
1042
1043 void TopologySamples::Fuse3dSample()
1044 {
1045   // Make a box #1 with a corner at [0, 0, 0] and the specified sizes.
1046   Standard_Real aSizeX = 10.0;
1047   Standard_Real aSizeY = 15.0;
1048   Standard_Real aSizeZ = 20.0;
1049   TopoDS_Shape aShape1 = BRepPrimAPI_MakeBox(aSizeX, aSizeY, aSizeZ);
1050   myResult << "Box at corner [0, 0, 0] and sizes ["
1051            << aSizeX << ", " << aSizeY << ", " << aSizeZ
1052            << "] was created in yellow wireframe" << std::endl;
1053
1054   // Make a box #2 by two points.
1055   gp_Pnt aPnt1(5.0, 7.5, 10.0);
1056   gp_Pnt aPnt2(20.0, 25.0, 30.0);
1057   TopoDS_Shape aShape2 = BRepPrimAPI_MakeBox(aPnt1, aPnt2);
1058   myResult << "Box with corners ["
1059            << aPnt1.X() << ", " << aPnt1.Y() << ", " << aPnt1.Z()
1060            << "] and ["
1061            << aPnt2.X() << ", " << aPnt2.Y() << ", " << aPnt2.Z()
1062            << "] was created in green wireframe" << std::endl;
1063
1064   // Create a boolean algo.
1065   BRepAlgoAPI_Fuse anAlgo(aShape1, aShape2);
1066
1067   // Make operation.
1068   anAlgo.Build();
1069
1070   if (!anAlgo.IsDone()) // Process errors
1071   {
1072     myResult << "Errors : " << std::endl;
1073     anAlgo.DumpErrors(myResult);
1074   }
1075   if (anAlgo.HasWarnings()) // Process warnings
1076   {
1077     myResult << "Warnings : " << std::endl;
1078     anAlgo.DumpErrors(myResult);
1079   }
1080
1081   if (anAlgo.IsDone())
1082   {
1083     // Get result.
1084     TopoDS_Shape aResultShape = anAlgo.Shape();
1085     myResult << "Result shape was created in red shading" << std::endl;
1086     Handle(AIS_ColoredShape) anAisShape1 = new AIS_ColoredShape(aShape1);
1087     Handle(AIS_ColoredShape) anAisShape2 = new AIS_ColoredShape(aShape2);
1088     anAisShape1->SetColor(Quantity_Color(Quantity_NOC_YELLOW));
1089     anAisShape2->SetColor(Quantity_Color(Quantity_NOC_GREEN));
1090     Handle(AIS_ColoredShape) anAisResult = new AIS_ColoredShape(aResultShape);
1091     anAisResult->SetColor(Quantity_Color(Quantity_NOC_RED));
1092     myObject3d.Append(anAisShape1);
1093     myObject3d.Append(anAisShape2);
1094     myObject3d.Append(anAisResult);
1095     myContext->SetDisplayMode(anAisShape1, 0, Standard_True);
1096     myContext->SetDisplayMode(anAisShape2, 0, Standard_True);
1097     myContext->SetDisplayMode(anAisResult, 1, Standard_True);
1098   }
1099 }
1100
1101 void TopologySamples::Section3dSample()
1102 {
1103   // Make a box #1 with a corner at [0, 0, 0] and the specified sizes.
1104   Standard_Real aSizeX = 10.0;
1105   Standard_Real aSizeY = 15.0;
1106   Standard_Real aSizeZ = 20.0;
1107   TopoDS_Shape aShape = BRepPrimAPI_MakeBox(aSizeX, aSizeY, aSizeZ);
1108   myResult << "Box at corner [0, 0, 0] and sizes ["
1109            << aSizeX << ", " << aSizeY << ", " << aSizeZ
1110            << "] was created in yellow wireframe" << std::endl;
1111
1112   // Create a boolean algo.
1113   // Make a section by a plane.
1114   gp_Pln aPln(gp_Pnt(aSizeX / 2.0, aSizeY / 2.0, aSizeZ / 2.0), gp::DZ());
1115   BRepAlgoAPI_Section anAlgo(aShape, aPln, Standard_False);
1116
1117   // Make operation.
1118   anAlgo.Build();
1119
1120   if (!anAlgo.IsDone()) // Process errors
1121   {
1122     myResult << "Errors : " << std::endl;
1123     anAlgo.DumpErrors(myResult);
1124   }
1125   if (anAlgo.HasWarnings()) // Process warnings
1126   {
1127     myResult << "Warnings : " << std::endl;
1128     anAlgo.DumpErrors(myResult);
1129   }
1130
1131   if (anAlgo.IsDone())
1132   {
1133     // Get result.
1134     TopoDS_Shape aResultShape = anAlgo.Shape();
1135     myResult << "Result shape was created in red" << std::endl;
1136     Handle(AIS_ColoredShape) anAisShape = new AIS_ColoredShape(aShape);
1137     Handle(AIS_Plane) anAisPlane = new AIS_Plane(new Geom_Plane(aPln));
1138     anAisShape->SetColor(Quantity_Color(Quantity_NOC_YELLOW));
1139     Handle(AIS_ColoredShape) anAisResult = new AIS_ColoredShape(aResultShape);
1140     anAisResult->SetColor(Quantity_Color(Quantity_NOC_RED));
1141     myObject3d.Append(anAisShape);
1142     myObject3d.Append(anAisPlane);
1143     myObject3d.Append(anAisResult);
1144     myContext->SetDisplayMode(anAisShape, 0, Standard_True);
1145   }
1146 }
1147
1148 void TopologySamples::Splitter3dSample()
1149 {
1150   // Make a box by two points.
1151   gp_Pnt aPnt1(-5.0, -7.5, -10.0);
1152   gp_Pnt aPnt2(10.0, 15.0, 10.0);
1153   TopoDS_Shape aBox = BRepPrimAPI_MakeBox(aPnt1, aPnt2);
1154   myResult << "Box with corners ["
1155            << aPnt1.X() << ", " << aPnt1.Y() << ", " << aPnt1.Z()
1156            << "] and ["
1157            << aPnt2.X() << ", " << aPnt2.Y() << ", " << aPnt2.Z()
1158            << "] was created in yellow" << std::endl;
1159
1160   // Make a splitting tool as XY plane.
1161   TopoDS_Shape aTool = BRepBuilderAPI_MakeFace(gp_Pln(gp::XOY()));
1162
1163   // Create a splitter algo.
1164   BRepAlgoAPI_Splitter aSplitter;
1165
1166   // Add shapes to be split.
1167   TopTools_ListOfShape anArguments;
1168   anArguments.Append(aBox);
1169   aSplitter.SetArguments(anArguments);
1170
1171   // Add tool shapes.
1172   TopTools_ListOfShape aTools;
1173   aTools.Append(aTool);
1174   aSplitter.SetTools(aTools);
1175
1176   // Perform splitting.
1177   aSplitter.Build();
1178
1179   if (!aSplitter.IsDone()) // Process errors
1180   {
1181     myResult << "Errors : " << std::endl;
1182     aSplitter.DumpErrors(myResult);
1183   }
1184   if (aSplitter.HasWarnings()) // Process warnings
1185   {
1186     myResult << "Warnings : " << std::endl;
1187     aSplitter.DumpErrors(myResult);
1188   }
1189
1190   Handle(AIS_ColoredShape) anAisBox = new AIS_ColoredShape(aBox);
1191   anAisBox->SetColor(Quantity_Color(Quantity_NOC_YELLOW));
1192   myObject3d.Append(anAisBox);
1193
1194   if (aSplitter.IsDone()) // Process results
1195   {
1196     // Simplification of the result shape is performed by the means of
1197     // ShapeUpgrade_UnifySameDomain algorithm. The result of the operation will
1198     // be overwritten with the simplified result.
1199     // The simplification is performed without creation of the Internal shapes,
1200     // i.e. shapes connections will never be broken.
1201     // Simplification is performed on the whole result shape. Thus, if the input
1202     // shapes contained connected tangent edges or faces unmodified during the operation
1203     // they will also be unified.
1204     aSplitter.SimplifyResult();
1205
1206     // Get result of splitting.
1207     TopoDS_Shape aResult = aSplitter.Shape();
1208     myResult << "Splitting result (shapes are moved apart for illustativeness) is in red" << std::endl;
1209
1210     // In this particular sample two shapes in the result are expected.
1211     // Lets move apart them for illustrative purposes.
1212     TopoDS_Iterator anIt(aResult);
1213     Standard_ASSERT_VOID(anIt.More(), "Not empty result is expected!");
1214     TopoDS_Shape aBox1 = anIt.Value(); anIt.Next();
1215     Standard_ASSERT_VOID(anIt.More(), "Two shapes in the result are expected!");
1216     TopoDS_Shape aBox2 = anIt.Value();
1217     gp_Trsf aTrsf1; aTrsf1.SetTranslation(gp_Vec(0.0, 0.0, -15.0));
1218     aBox1.Move(aTrsf1);
1219     gp_Trsf aTrsf2; aTrsf2.SetTranslation(gp_Vec(0.0, 0.0, +15.0));
1220     aBox2.Move(aTrsf2);
1221
1222     Handle(AIS_ColoredShape) anAisBox1 = new AIS_ColoredShape(aBox1);
1223     Handle(AIS_ColoredShape) anAisBox2 = new AIS_ColoredShape(aBox2);
1224     anAisBox1->SetColor(Quantity_Color(Quantity_NOC_RED));
1225     anAisBox2->SetColor(Quantity_Color(Quantity_NOC_RED));
1226     myObject3d.Append(anAisBox1);
1227     myObject3d.Append(anAisBox2);
1228   }
1229 }
1230
1231 void TopologySamples::Defeaturing3dSample()
1232 {
1233   // Prepare a box with a chamfer.
1234   // Make a box with a corner at [0, 0, 0] and the specified sizes.
1235   Standard_Real aSizeX = 8.0;
1236   Standard_Real aSizeY = 10.0;
1237   Standard_Real aSizeZ = 15.0;
1238   TopoDS_Shape aBox = BRepPrimAPI_MakeBox(aSizeX, aSizeY, aSizeZ);
1239   // Initialize chamfer algo.
1240   BRepFilletAPI_MakeChamfer anAlgo(aBox);
1241   // Set edge to apply a chamfer with specified distance from it.
1242   // Select the 5th edge in the map returned by TopExp::MapShapes method.
1243   TopTools_IndexedMapOfShape anEdges;
1244   TopExp::MapShapes(aBox, TopAbs_EDGE, anEdges);
1245   TopoDS_Edge anEdge = TopoDS::Edge(anEdges.FindKey(5));
1246   Standard_Real aDist = 4.0;
1247   anAlgo.Add(aDist, anEdge);
1248   // Make a chamfer.
1249   anAlgo.Build();
1250   Standard_ASSERT_VOID(anAlgo.IsDone(), "Couldn't prepare a box with a chamfer!");
1251   // Get a box with a chamfer.
1252   TopoDS_Shape aBoxWithChamfer = anAlgo.Shape();
1253   myResult << "Box with a chamfer is in yellow shading" << std::endl;
1254
1255   Handle(AIS_ColoredShape) anAisBoxWithChamfer = new AIS_ColoredShape(aBoxWithChamfer);
1256   anAisBoxWithChamfer->SetColor(Quantity_Color(Quantity_NOC_YELLOW));
1257   myObject3d.Append(anAisBoxWithChamfer);
1258   myContext->SetDisplayMode(anAisBoxWithChamfer, 1, Standard_True);
1259
1260   // Retrieve chamfer faces generated from the edge
1261   const TopTools_ListOfShape& aGenShapes = anAlgo.Generated(anEdge);
1262   Standard_ASSERT_VOID(!aGenShapes.IsEmpty(), "Chamfer face is expected!");
1263   for (TopTools_ListOfShape::Iterator anIt(aGenShapes); anIt.More(); anIt.Next())
1264   {
1265     Handle(AIS_ColoredShape) anAisShape = new AIS_ColoredShape(anIt.Value());
1266     anAisShape->SetColor(Quantity_Color(Quantity_NOC_GREEN));
1267     anAisShape->SetWidth(2.5);
1268     myObject3d.Append(anAisShape);
1269     myContext->SetDisplayMode(anAisBoxWithChamfer, 1, Standard_True);
1270   }
1271   myResult << "Chamfer faces : " << aGenShapes.Size() << std::endl;
1272   myResult << "The first one is using to remove" << std::endl;
1273   myResult << "The removed face is in green" << std::endl;
1274
1275   // Initialize defeaturing algo.
1276   BRepAlgoAPI_Defeaturing aDefeatAlgo;
1277   aDefeatAlgo.SetShape(aBoxWithChamfer);
1278   aDefeatAlgo.AddFaceToRemove(aGenShapes.First());
1279
1280   // Remove the chamfer.
1281   aDefeatAlgo.Build();
1282
1283   if (aDefeatAlgo.IsDone())
1284   {
1285     // Get result.
1286     TopoDS_Shape aResult = aDefeatAlgo.Shape();
1287     myResult << "Defeatured box is in red wireframe" << std::endl;
1288
1289     Handle(AIS_ColoredShape) anAisResult = new AIS_ColoredShape(aResult);
1290     anAisResult->SetColor(Quantity_Color(Quantity_NOC_RED));
1291     myObject3d.Append(anAisResult);
1292     myContext->SetDisplayMode(anAisResult, 0, Standard_True);
1293   }
1294 }
1295
1296 void TopologySamples::Fillet3dSample()
1297 {
1298   // Make a box with a corner at [0, 0, 0] and the specified sizes.
1299   Standard_Real aSizeX = 8.0;
1300   Standard_Real aSizeY = 10.0;
1301   Standard_Real aSizeZ = 15.0;
1302   TopoDS_Shape aBox = BRepPrimAPI_MakeBox(aSizeX, aSizeY, aSizeZ);
1303   myResult << "Box at corner [0, 0, 0] and sizes ["
1304            << aSizeX << ", " << aSizeY << ", " << aSizeZ
1305            << "] was created in yellow wireframe" << std::endl;
1306
1307   // Initialize fillet algo.
1308   BRepFilletAPI_MakeFillet anAlgo(aBox);
1309
1310   // Set edge to apply a fillet with specified radius.
1311   // Select the first edge in the map returned by TopExp::MapShapes method.
1312   TopTools_IndexedMapOfShape anEdges;
1313   TopExp::MapShapes(aBox, TopAbs_EDGE, anEdges);
1314   TopoDS_Edge anEdge = TopoDS::Edge(anEdges.FindKey(1));
1315   Standard_Real aRadius = 3.0;
1316   anAlgo.Add(aRadius, anEdge);
1317   myResult << "Make a fillet of " << aRadius << " radius on an edge in green" << std::endl;
1318
1319   Handle(AIS_ColoredShape) anAisBox = new AIS_ColoredShape(aBox);
1320   Handle(AIS_ColoredShape) anAisEdge = new AIS_ColoredShape(anEdge);
1321   anAisBox->SetColor(Quantity_Color(Quantity_NOC_YELLOW));
1322   anAisEdge->SetColor(Quantity_Color(Quantity_NOC_GREEN));
1323   anAisEdge->SetWidth(2.5);
1324   myObject3d.Append(anAisBox);
1325   myObject3d.Append(anAisEdge);
1326   myContext->SetDisplayMode(anAisBox, 0, Standard_True);
1327
1328   // Make a fillet.
1329   anAlgo.Build();
1330
1331   if (anAlgo.IsDone())
1332   {
1333     // Get result.
1334     TopoDS_Shape aResult = anAlgo.Shape();
1335     myResult << "Fillet was built. Result shape is in red shading" << std::endl;
1336
1337     Handle(AIS_ColoredShape) anAisResult = new AIS_ColoredShape(aResult);
1338     anAisResult->SetColor(Quantity_Color(Quantity_NOC_RED));
1339     myObject3d.Append(anAisResult);
1340     myContext->SetDisplayMode(anAisResult, 1, Standard_True);
1341   }
1342 }
1343
1344 void TopologySamples::Chamfer3dSample()
1345 {
1346   // Make a box with a corner at [0, 0, 0] and the specified sizes.
1347   Standard_Real aSizeX = 8.0;
1348   Standard_Real aSizeY = 10.0;
1349   Standard_Real aSizeZ = 15.0;
1350   TopoDS_Shape aBox = BRepPrimAPI_MakeBox(aSizeX, aSizeY, aSizeZ);
1351   myResult << "Box at corner [0, 0, 0] and sizes ["
1352            << aSizeX << ", " << aSizeY << ", " << aSizeZ
1353            << "] was created in yellow wirewrame" << std::endl;
1354
1355   // Initialize chamfer algo.
1356   BRepFilletAPI_MakeChamfer anAlgo(aBox);
1357
1358   // Set edge to apply a chamfer with specified distance from it.
1359   // Select the 5th edge in the map returned by TopExp::MapShapes method.
1360   TopTools_IndexedMapOfShape anEdges;
1361   TopExp::MapShapes(aBox, TopAbs_EDGE, anEdges);
1362   TopoDS_Edge anEdge = TopoDS::Edge(anEdges.FindKey(5));
1363   Standard_Real aDist = 4.0;
1364   anAlgo.Add(aDist, anEdge);
1365   myResult << "Make a chamfer of " << aDist << " size on an edge in green" << std::endl;
1366
1367   Handle(AIS_ColoredShape) anAisBox = new AIS_ColoredShape(aBox);
1368   Handle(AIS_ColoredShape) anAisEdge = new AIS_ColoredShape(anEdge);
1369   anAisBox->SetColor(Quantity_Color(Quantity_NOC_YELLOW));
1370   anAisEdge->SetColor(Quantity_Color(Quantity_NOC_GREEN));
1371   anAisEdge->SetWidth(2.5);
1372   myObject3d.Append(anAisBox);
1373   myObject3d.Append(anAisEdge);
1374   myContext->SetDisplayMode(anAisBox, 0, Standard_True);
1375
1376   // Make a chamfer.
1377   anAlgo.Build();
1378   if (anAlgo.IsDone())
1379   {
1380     // Get result.
1381     TopoDS_Shape aResult = anAlgo.Shape();
1382     myResult << "Fillet was built. Result shape is in red shading" << std::endl;
1383
1384     Handle(AIS_ColoredShape) anAisResult = new AIS_ColoredShape(aResult);
1385     anAisResult->SetColor(Quantity_Color(Quantity_NOC_RED));
1386     myObject3d.Append(anAisResult);
1387     myContext->SetDisplayMode(anAisResult, 1, Standard_True);
1388
1389     const TopTools_ListOfShape& aGenShapes = anAlgo.Generated(anEdge);
1390     for (TopTools_ListOfShape::Iterator anIt(aGenShapes); anIt.More(); anIt.Next())
1391     {
1392       Handle(AIS_ColoredShape) anAisShape = new AIS_ColoredShape(anIt.Value());
1393       anAisShape->SetColor(Quantity_Color(Quantity_NOC_RED));
1394       anAisShape->SetWidth(2.5);
1395       myObject3d.Append(anAisShape);
1396     }
1397   }
1398 }
1399
1400 void TopologySamples::Offset3dSample()
1401 {
1402   // Make a triangle wire.
1403   BRepBuilderAPI_MakePolygon aTria;
1404   TopoDS_Vertex aVertA = BRepBuilderAPI_MakeVertex(gp_Pnt(-0.5, 0.0, 0.0));
1405   TopoDS_Vertex aVertB = BRepBuilderAPI_MakeVertex(gp_Pnt(0.0, 0.0, +1.0));
1406   TopoDS_Vertex aVertC = BRepBuilderAPI_MakeVertex(gp_Pnt(+0.5, 0.0, 0.0));
1407   aTria.Add(aVertA);
1408   aTria.Add(aVertB);
1409   aTria.Add(aVertC);
1410   aTria.Close();
1411   TopoDS_Wire aWire = aTria.Wire();
1412   myResult << "Triangular wire was created in yellow" << std::endl;
1413
1414   Handle(AIS_ColoredShape) anAisWire = new AIS_ColoredShape(aWire);
1415   anAisWire->SetColor(Quantity_Color(Quantity_NOC_YELLOW));
1416   myObject3d.Append(anAisWire);
1417
1418   // Initialize offset algo.
1419   BRepOffsetAPI_MakeOffset anAlgo(aWire);
1420
1421   // Perform a series of offsets with linearly increasing value and altitude.
1422   Standard_Real anOffsetStep = 0.2;
1423   Standard_Real anAltitudeStep = 0.1;
1424   for (Standard_Integer i = 1; i <= 4; ++i)
1425   {
1426     Standard_Real anOffset = anOffsetStep * i;
1427     Standard_Real anAltitude = anAltitudeStep * i;
1428     anAlgo.Perform(anOffset, anAltitude);
1429     if (anAlgo.IsDone())
1430     {
1431       // Get result.
1432       TopoDS_Shape aResult = anAlgo.Shape();
1433       myResult << "#" << i << " : Offset = " << anOffset << " Altitude = " << anAltitude
1434                << ". Result is in red." << std::endl;
1435
1436       Handle(AIS_ColoredShape) anAisResult = new AIS_ColoredShape(aResult);
1437       anAisResult->SetColor(Quantity_Color(Quantity_NOC_RED));
1438       myObject3d.Append(anAisResult);
1439     }
1440   }
1441 }
1442
1443 void TopologySamples::Evolved3dSample()
1444 {
1445   // Make a triangle wire as a spine.
1446   BRepBuilderAPI_MakePolygon aTria;
1447   TopoDS_Vertex aVertA = BRepBuilderAPI_MakeVertex(gp_Pnt(-0.5, 0.0, 0.0));
1448   TopoDS_Vertex aVertB = BRepBuilderAPI_MakeVertex(gp_Pnt(0.0, +1.0, 0.0));
1449   TopoDS_Vertex aVertC = BRepBuilderAPI_MakeVertex(gp_Pnt(+0.5, 0.0, 0.0));
1450   aTria.Add(aVertA);
1451   aTria.Add(aVertB);
1452   aTria.Add(aVertC);
1453   aTria.Close();
1454   TopoDS_Wire aSpine = aTria.Wire();
1455   myResult << "Profile wire was created in yellow" << std::endl;
1456
1457   // Make a wire as a profile.
1458   BRepBuilderAPI_MakePolygon aPoly;
1459   TopoDS_Vertex aVert1 = BRepBuilderAPI_MakeVertex(gp_Pnt(-0.5, 0.0, 0.0));
1460   TopoDS_Vertex aVert2 = BRepBuilderAPI_MakeVertex(gp_Pnt(-0.5, -0.1, 0.5));
1461   TopoDS_Vertex aVert3 = BRepBuilderAPI_MakeVertex(gp_Pnt(-0.5, -0.2, 1.0));
1462   aPoly.Add(aVert1);
1463   aPoly.Add(aVert2);
1464   aPoly.Add(aVert3);
1465   TopoDS_Wire aProfile = aPoly.Wire();
1466   myResult << "Spine wire was created in greed" << std::endl;
1467
1468   Handle(AIS_ColoredShape) anAisSpine = new AIS_ColoredShape(aSpine);
1469   Handle(AIS_ColoredShape) anAisProfile = new AIS_ColoredShape(aProfile);
1470   anAisSpine->SetColor(Quantity_Color(Quantity_NOC_YELLOW));
1471   anAisSpine->SetWidth(2.5);
1472   anAisProfile->SetColor(Quantity_Color(Quantity_NOC_GREEN));
1473   anAisProfile->SetWidth(2.5);
1474   myObject3d.Append(anAisSpine);
1475   myObject3d.Append(anAisProfile);
1476
1477   // Initialize evolving algo.
1478   GeomAbs_JoinType aJoinType = GeomAbs_Arc;
1479   Standard_Boolean aIsGlobalCS = Standard_False;
1480   Standard_Boolean aIsSolid = Standard_True;
1481   BRepOffsetAPI_MakeEvolved anAlgo(aSpine, aProfile, aJoinType, aIsGlobalCS, aIsSolid);
1482
1483   // Perform evolving.
1484   anAlgo.Build();
1485
1486   if (anAlgo.IsDone())
1487   {
1488     // Get result.
1489     TopoDS_Shape aResult = anAlgo.Shape();
1490     myResult << "Evolving result is in red" << std::endl;
1491
1492     Handle(AIS_ColoredShape) anAisResult = new AIS_ColoredShape(aResult);
1493     anAisResult->SetColor(Quantity_Color(Quantity_NOC_RED));
1494     myObject3d.Append(anAisResult);
1495   }
1496 }
1497
1498 void TopologySamples::Copy3dSample()
1499 {
1500   // Make a box with a corner at [0, 0, 0] and the specified sizes.
1501   Standard_Real aSizeX = 10.0;
1502   Standard_Real aSizeY = 15.0;
1503   Standard_Real aSizeZ = 20.0;
1504   BRepPrimAPI_MakeBox aBoxMake(aSizeX, aSizeY, aSizeZ);
1505   TopoDS_Shape aBox = aBoxMake.Shape();
1506   myResult << "Box at corner [0, 0, 0] and sizes ["
1507            << aSizeX << ", " << aSizeY << ", " << aSizeZ
1508            << "] was created in yellow" << std::endl;
1509
1510   // Make a box copy.
1511   TopoDS_Shape aBoxCopy = BRepBuilderAPI_Copy(aBox);
1512   myResult << "Box copy was created in red" << std::endl;
1513
1514   gp_Trsf aTrsf1; aTrsf1.SetTranslation(gp_Vec(15.0, 0.0, 0.0));
1515   aBoxCopy.Move(aTrsf1);
1516   myResult << "Box copy shape is moved apart for illustativeness" << std::endl;
1517
1518   Handle(AIS_ColoredShape) anAisBox = new AIS_ColoredShape(aBox);
1519   anAisBox->SetColor(Quantity_Color(Quantity_NOC_YELLOW));
1520   anAisBox->SetWidth(2.5);
1521   Handle(AIS_ColoredShape) anAisBoxCopy = new AIS_ColoredShape(aBoxCopy);
1522   anAisBoxCopy->SetColor(Quantity_Color(Quantity_NOC_RED));
1523   myObject3d.Append(anAisBox);
1524   myObject3d.Append(anAisBoxCopy);
1525 }
1526
1527 void TopologySamples::Transform3dSample()
1528 {
1529   // Make a box with a corner at [0, 0, 0] and the specified sizes.
1530   Standard_Real aSizeX = 10.0;
1531   Standard_Real aSizeY = 15.0;
1532   Standard_Real aSizeZ = 20.0;
1533   BRepPrimAPI_MakeBox aBoxMake(aSizeX, aSizeY, aSizeZ);
1534   TopoDS_Shape aBox = aBoxMake.Shape();
1535   myResult << "Box at corner [0, 0, 0] and sizes ["
1536            << aSizeX << ", " << aSizeY << ", " << aSizeZ
1537            << "] was created in yellow" << std::endl;
1538
1539   // Move the box.
1540   gp_Trsf aTrMove; aTrMove.SetTranslation(gp_Vec(15.0, 20.0, 25.0));
1541   TopoDS_Shape aMovedBox = BRepBuilderAPI_Transform(aBox, aTrMove, Standard_True);
1542   myResult << "Moved box in green" << std::endl;
1543
1544   // Rotate the moved box
1545   gp_Trsf aTrRot; aTrRot.SetRotation(gp_Ax1(gp_Pnt(15.0, 20.0, 25.0), gp::DZ()), 3.0*M_PI_4);
1546   TopoDS_Shape aRotatedBox = BRepBuilderAPI_Transform(aBox, aTrRot, Standard_True);
1547   myResult << "Rotated box in red" << std::endl;
1548
1549   Handle(AIS_ColoredShape) anAisBox = new AIS_ColoredShape(aBox);
1550   Handle(AIS_ColoredShape) anAisMovedBox = new AIS_ColoredShape(aMovedBox);
1551   Handle(AIS_ColoredShape) anAisRotatedBox = new AIS_ColoredShape(aRotatedBox);
1552   anAisBox->SetColor(Quantity_Color(Quantity_NOC_YELLOW));
1553   anAisMovedBox->SetColor(Quantity_Color(Quantity_NOC_GREEN));
1554   anAisRotatedBox->SetColor(Quantity_Color(Quantity_NOC_RED));
1555   myObject3d.Append(anAisBox);
1556   myObject3d.Append(anAisMovedBox);
1557   myObject3d.Append(anAisRotatedBox);
1558 }
1559
1560 void TopologySamples::ConvertToNurbs3dSample()
1561 {
1562   // Make a torus face.
1563   gp_Torus aTorus(gp::XOY(), 20.0, 7.5);
1564   TopoDS_Shape aTorusFace = BRepBuilderAPI_MakeFace(aTorus);
1565   myResult << "TopoDS_Solid on the torus with" << std::endl
1566            << "R major = " << aTorus.MajorRadius() << std::endl
1567            << "R minor = " << aTorus.MinorRadius() << std::endl
1568            << "was created in yellow" << std::endl;
1569
1570   // Convert faces/edges from analytic to NURBS geometry.
1571   TopoDS_Shape aNurbsFace = BRepBuilderAPI_NurbsConvert(aTorusFace);
1572   myResult << "Converted torus in red" << std::endl;
1573   gp_Trsf aTrsf1; aTrsf1.SetTranslation(gp_Vec(60.0, 0.0, 0.0));
1574   aNurbsFace.Move(aTrsf1);
1575   myResult << "Converted torus is moved apart for illustativeness" << std::endl;
1576
1577   Handle(AIS_ColoredShape) anAisTorus = new AIS_ColoredShape(aTorusFace);
1578   Handle(AIS_ColoredShape) anAisNurbs = new AIS_ColoredShape(aNurbsFace);
1579   anAisTorus->SetColor(Quantity_Color(Quantity_NOC_YELLOW));
1580   anAisTorus->SetWidth(2.5);
1581   anAisNurbs->SetColor(Quantity_Color(Quantity_NOC_RED));
1582   myObject3d.Append(anAisTorus);
1583   myObject3d.Append(anAisNurbs);
1584 }
1585
1586 void TopologySamples::SewContiguousFaces3dSample()
1587 {
1588   // Make a sphere.
1589   gp_Sphere aSphere(gp::XOY(), 1.0);
1590   // South hemisphere.
1591   TopoDS_Face aFace1 = BRepBuilderAPI_MakeFace(aSphere, 0.0, 2.0 * M_PI, -M_PI_2, 0.0);
1592   // North hemisphere.
1593   TopoDS_Face aFace2 = BRepBuilderAPI_MakeFace(aSphere, 0.0, 2.0 * M_PI, 0.0, +M_PI_2);
1594
1595   // Make a default tailor.
1596   BRepBuilderAPI_Sewing aTailor;
1597
1598   // Add hemisphere faces.
1599   aTailor.Add(aFace1);
1600   aTailor.Add(aFace2);
1601
1602   // Perform sewing.
1603   aTailor.Perform();
1604
1605   // Get result.
1606   const TopoDS_Shape& aSewedSphere = aTailor.SewedShape();
1607   myResult << "Two hemispheres were sewed : " << aTailor.NbFreeEdges() << " free edges" << std::endl;
1608
1609   Handle(AIS_ColoredShape) anAisSewedSphere = new AIS_ColoredShape(aSewedSphere);
1610   anAisSewedSphere->SetColor(Quantity_Color(Quantity_NOC_RED));
1611   myObject3d.Append(anAisSewedSphere);
1612 }
1613
1614 void TopologySamples::CheckValidity3dSample()
1615 {
1616   // Make a box with a corner at [0, 0, 0] and the specified sizes.
1617   Standard_Real aSizeX = 10.0;
1618   Standard_Real aSizeY = 15.0;
1619   Standard_Real aSizeZ = 20.0;
1620   BRepPrimAPI_MakeBox aBoxMake(aSizeX, aSizeY, aSizeZ);
1621   TopoDS_Shape aBox = aBoxMake.Shape();
1622   myResult << "Box at corner [0, 0, 0] and sizes ["
1623            << aSizeX << ", " << aSizeY << ", " << aSizeZ
1624            << "] was created in yellow" << std::endl;
1625
1626   // Analyze the box.
1627   BRepCheck_Analyzer anAnalyzer(aBox);
1628   myResult << "Box is " << (anAnalyzer.IsValid() ? "valid" : "invalid") << std::endl;
1629
1630   // Make the box invalid manually.
1631   Handle(BRepTools_ReShape) aReShape = new BRepTools_ReShape();
1632   myResult << "Remove the top face from the box (red)" << std::endl;
1633   aReShape->Remove(aBoxMake.TopFace());
1634   TopoDS_Shape aBox1 = aReShape->Apply(aBox);
1635   myResult << "The top face was removed" << std::endl;
1636
1637   // Analyze the modified box.
1638   BRepCheck_Analyzer anAnalyzer1(aBox1);
1639   myResult << "Modified box is " << (anAnalyzer1.IsValid() ? "valid" : "invalid") << std::endl;
1640
1641   Handle(AIS_ColoredShape) anAisBox = new AIS_ColoredShape(aBox);
1642   Handle(AIS_ColoredShape) anAisTopFace = new AIS_ColoredShape(aBoxMake.TopFace());
1643   anAisBox->SetColor(Quantity_Color(Quantity_NOC_YELLOW));
1644   anAisTopFace->SetColor(Quantity_Color(Quantity_NOC_RED));
1645   myObject3d.Append(anAisBox);
1646   myObject3d.Append(anAisTopFace);
1647 }
1648
1649 void TopologySamples::ComputeLinearProperties3dSample()
1650 {
1651   // Make an edge from a circular segment.
1652   // Create a circle in XY plane of the radius 1.0.
1653   gp_Circ aCirc(gp::XOY(), 1.0);
1654   // Make a circular edge from the 1st quoter in the parametric space.
1655   TopoDS_Edge aShape = BRepBuilderAPI_MakeEdge(aCirc, 0.0, M_PI);
1656   myResult << "TopoDS_Edge on the circle's 1st quoter" << std::endl
1657            << "with the center at [ "
1658            << aCirc.Location().X() << ", " << aCirc.Location().Y() << ", " << aCirc.Location().Z()
1659            << " ] and R = " << aCirc.Radius() << " was created in red" << std::endl
1660            << std::endl;
1661
1662   // Retrieve linear properties from the edge.
1663   GProp_GProps aGProps;
1664   BRepGProp::LinearProperties(aShape, aGProps);
1665   Standard_Real aLength = aGProps.Mass();
1666   gp_Pnt aCOM = aGProps.CentreOfMass();
1667   Standard_Real anIx, anIy, anIz;
1668   aGProps.StaticMoments(anIx, anIy, anIz);
1669   gp_Mat aMOI = aGProps.MatrixOfInertia();
1670   myResult << "Linear properties:" << std::endl
1671            << "  Length            = " << aLength << std::endl
1672            << "  Center of mass    = [ " << aCOM.X() << ", " << aCOM.Y() << ", " << aCOM.Z() << " ]" << std::endl
1673            << "  Static moments    = [ " << anIx << ", " << anIy << ", " << anIz << " ]" << std::endl
1674            << "  Matrix of inertia = [ "
1675            << aMOI(1, 1) << ", " << aMOI(1, 2) << ", " << aMOI(1, 3) << std::endl
1676            << std::setw(33) << aMOI(2, 1) << ", " << aMOI(2, 2) << ", " << aMOI(2, 3) << std::endl
1677            << std::setw(33) << aMOI(3, 1) << ", " << aMOI(3, 2) << ", " << aMOI(3, 3) << " ]" << std::endl;
1678   GProp_PrincipalProps aPProps = aGProps.PrincipalProperties();
1679   Standard_Real anIxx, anIyy, anIzz;
1680   aPProps.Moments(anIxx, anIyy, anIzz);
1681   Standard_Real aRxx, aRyy, aRzz;
1682   aPProps.RadiusOfGyration(aRxx, aRyy, aRzz);
1683   myResult << "Principal properties:" << std::endl
1684            << "  Has symmetric axis  : " << (aPProps.HasSymmetryAxis() ? "YES" : "NO") << std::endl
1685            << "  Has symmetric point : " << (aPProps.HasSymmetryPoint() ? "YES" : "NO") << std::endl
1686            << "  Moments of inertia  = [ " << anIxx << ", " << anIyy << ", " << anIzz << " ]" << std::endl
1687            << "  Radius of gyration  = [ " << aRxx << ", " << aRyy << ", " << aRzz << " ]" << std::endl;
1688   if (!aPProps.HasSymmetryPoint())
1689   {
1690     const gp_Vec& anAxis1 = aPProps.FirstAxisOfInertia();
1691     myResult << "  1st axis of inertia = [ " << anAxis1.X() << ", " << anAxis1.Y() << ", " << anAxis1.Z() << " ]" << std::endl;
1692     Handle(AIS_ColoredShape) anAisAxis1 = new AIS_ColoredShape(
1693       BRepBuilderAPI_MakeEdge(aCOM, aCOM.XYZ() + anAxis1.XYZ()));
1694     anAisAxis1->SetColor(Quantity_Color(Quantity_NOC_GREEN));
1695     myObject3d.Append(anAisAxis1);
1696     if (!aPProps.HasSymmetryPoint())
1697     {
1698       const gp_Vec& anAxis2 = aPProps.SecondAxisOfInertia();
1699       myResult << "  2nd axis of inertia = [ " << anAxis2.X() << ", " << anAxis2.Y() << ", " << anAxis2.Z() << " ]" << std::endl;
1700       Handle(AIS_ColoredShape) anAisAxis2 = new AIS_ColoredShape(
1701         BRepBuilderAPI_MakeEdge(aCOM, aCOM.XYZ() + anAxis2.XYZ()));
1702       anAisAxis2->SetColor(Quantity_Color(Quantity_NOC_GREEN));
1703       myObject3d.Append(anAisAxis2);
1704       const gp_Vec& anAxis3 = aPProps.ThirdAxisOfInertia();
1705       myResult << "  3rd axis of inertia = [ " << anAxis3.X() << ", " << anAxis3.Y() << ", " << anAxis3.Z() << " ]" << std::endl;
1706       Handle(AIS_ColoredShape) anAisAxis3 = new AIS_ColoredShape(
1707         BRepBuilderAPI_MakeEdge(aCOM, aCOM.XYZ() + anAxis3.XYZ()));
1708       anAisAxis3->SetColor(Quantity_Color(Quantity_NOC_GREEN));
1709       myObject3d.Append(anAisAxis3);
1710     }
1711   }
1712
1713   Handle(AIS_ColoredShape) anAisShape = new AIS_ColoredShape(aShape);
1714   Handle(AIS_Point) anAisCOM = new AIS_Point(new Geom_CartesianPoint(aCOM));
1715   anAisShape->SetColor(Quantity_Color(Quantity_NOC_RED));
1716   Handle(AIS_TextLabel) aCOMLabel = new AIS_TextLabel();
1717   aCOMLabel->SetText("Center of mass");
1718   aCOMLabel->SetPosition(aCOM);
1719   Handle(AIS_Axis) anAisAxisX = new AIS_Axis(new Geom_Axis2Placement(gp::YOZ()), AIS_TOAX_XAxis);
1720   Handle(AIS_Axis) anAisAxisY = new AIS_Axis(new Geom_Axis2Placement(gp::ZOX()), AIS_TOAX_YAxis);
1721   Handle(AIS_Axis) anAisAxisZ = new AIS_Axis(new Geom_Axis2Placement(gp::XOY()), AIS_TOAX_ZAxis);
1722   myObject3d.Append(anAisAxisX);
1723   myObject3d.Append(anAisAxisY);
1724   myObject3d.Append(anAisAxisZ);
1725   myObject3d.Append(anAisShape);
1726   myObject3d.Append(anAisCOM);
1727   myObject3d.Append(aCOMLabel);
1728 }
1729
1730 void TopologySamples::ComputeSurfaceProperties3dSample()
1731 {
1732   // Make a face from a cylinder with R = 1
1733   // and directed along Z axis
1734   gp_Cylinder aCyl(gp::XOY(), 1.0);
1735   TopoDS_Face aShape = BRepBuilderAPI_MakeFace(aCyl, 0.0, M_PI, -1.0, +1.0).Face();
1736   myResult << "TopoDS_Face on the cylinder R = " << aCyl.Radius() << std::endl
1737            << "with axis [ " << aCyl.Position().Direction().X() << ", " << aCyl.Position().Direction().Y() << ", " << aCyl.Position().Direction().Z() << " ]" << std::endl
1738            << "limited in length [-1 ... +1] was created in red" << std::endl;
1739
1740   // Retrieve surface properties from the face.
1741   GProp_GProps aGProps;
1742   BRepGProp::SurfaceProperties(aShape, aGProps);
1743   Standard_Real aArea = aGProps.Mass();
1744   gp_Pnt aCOM = aGProps.CentreOfMass();
1745   Standard_Real anIx, anIy, anIz;
1746   aGProps.StaticMoments(anIx, anIy, anIz);
1747   gp_Mat aMOI = aGProps.MatrixOfInertia();
1748   myResult << "Linear properties:" << std::endl
1749            << "  Area              = " << aArea << std::endl
1750            << "  Center of mass    = [ " << aCOM.X() << ", " << aCOM.Y() << ", " << aCOM.Z() << " ]" << std::endl
1751            << "  Static moments    = [ " << anIx << ", " << anIy << ", " << anIz << " ]" << std::endl
1752            << "  Matrix of inertia = [ "
1753            << aMOI(1, 1) << ", " << aMOI(1, 2) << ", " << aMOI(1, 3) << std::endl
1754            << std::setw(33) << aMOI(2, 1) << ", " << aMOI(2, 2) << ", " << aMOI(2, 3) << std::endl
1755            << std::setw(33) << aMOI(3, 1) << ", " << aMOI(3, 2) << ", " << aMOI(3, 3) << " ]" << std::endl;
1756   GProp_PrincipalProps aPProps = aGProps.PrincipalProperties();
1757   Standard_Real anIxx, anIyy, anIzz;
1758   aPProps.Moments(anIxx, anIyy, anIzz);
1759   Standard_Real aRxx, aRyy, aRzz;
1760   aPProps.RadiusOfGyration(aRxx, aRyy, aRzz);
1761   myResult << "Principal properties:" << std::endl
1762            << "  Has symmetric axis  : " << (aPProps.HasSymmetryAxis() ? "YES" : "NO") << std::endl
1763            << "  Has symmetric point : " << (aPProps.HasSymmetryPoint() ? "YES" : "NO") << std::endl
1764            << "  Moments of inertia  = [ " << anIxx << ", " << anIyy << ", " << anIzz << " ]" << std::endl
1765            << "  Radius of gyration  = [ " << aRxx << ", " << aRyy << ", " << aRzz << " ]" << std::endl;
1766   if (!aPProps.HasSymmetryPoint())
1767   {
1768     const gp_Vec& anAxis1 = aPProps.FirstAxisOfInertia();
1769     myResult << "  1st axis of inertia = [ " << anAxis1.X() << ", " << anAxis1.Y() << ", " << anAxis1.Z() << " ]" << std::endl;
1770     Handle(AIS_ColoredShape) anAisAxis1 = new AIS_ColoredShape(
1771       BRepBuilderAPI_MakeEdge(aCOM, aCOM.XYZ() + anAxis1.XYZ()));
1772     anAisAxis1->SetColor(Quantity_Color(Quantity_NOC_GREEN));
1773     myObject3d.Append(anAisAxis1);
1774     if (!aPProps.HasSymmetryPoint())
1775     {
1776       const gp_Vec& anAxis2 = aPProps.SecondAxisOfInertia();
1777       myResult << "  2nd axis of inertia = [ " << anAxis2.X() << ", " << anAxis2.Y() << ", " << anAxis2.Z() << " ]" << std::endl;
1778       Handle(AIS_ColoredShape) anAisAxis2 = new AIS_ColoredShape(
1779         BRepBuilderAPI_MakeEdge(aCOM, aCOM.XYZ() + anAxis2.XYZ()));
1780       anAisAxis2->SetColor(Quantity_Color(Quantity_NOC_GREEN));
1781       myObject3d.Append(anAisAxis2);
1782       const gp_Vec& anAxis3 = aPProps.ThirdAxisOfInertia();
1783       myResult << "  3rd axis of inertia = [ " << anAxis3.X() << ", " << anAxis3.Y() << ", " << anAxis3.Z() << " ]" << std::endl;
1784       Handle(AIS_ColoredShape) anAisAxis3 = new AIS_ColoredShape(
1785         BRepBuilderAPI_MakeEdge(aCOM, aCOM.XYZ() + anAxis3.XYZ()));
1786       anAisAxis3->SetColor(Quantity_Color(Quantity_NOC_GREEN));
1787       myObject3d.Append(anAisAxis3);
1788     }
1789   }
1790
1791   Handle(AIS_ColoredShape) anAisShape = new AIS_ColoredShape(aShape);
1792   Handle(AIS_Point) anAisCOM = new AIS_Point(new Geom_CartesianPoint(aCOM));
1793   anAisShape->SetColor(Quantity_Color(Quantity_NOC_RED));
1794   Handle(AIS_TextLabel) aCOMLabel = new AIS_TextLabel();
1795   aCOMLabel->SetText("Center of mass");
1796   aCOMLabel->SetPosition(aCOM);
1797   Handle(AIS_Axis) anAisAxisX = new AIS_Axis(new Geom_Axis2Placement(gp::YOZ()), AIS_TOAX_XAxis);
1798   Handle(AIS_Axis) anAisAxisY = new AIS_Axis(new Geom_Axis2Placement(gp::ZOX()), AIS_TOAX_YAxis);
1799   Handle(AIS_Axis) anAisAxisZ = new AIS_Axis(new Geom_Axis2Placement(gp::XOY()), AIS_TOAX_ZAxis);
1800   myObject3d.Append(anAisAxisX);
1801   myObject3d.Append(anAisAxisY);
1802   myObject3d.Append(anAisAxisZ);
1803   myObject3d.Append(anAisShape);
1804   myObject3d.Append(anAisCOM);
1805   myObject3d.Append(aCOMLabel);
1806 }
1807
1808 void TopologySamples::ComputeVolumeProperties3dSample()
1809 {
1810   // Make a box by two points.
1811   gp_Pnt aPnt1(-0.5, -0.6, -0.7);
1812   gp_Pnt aPnt2(+0.8, +0.9, +1.0);
1813   TopoDS_Shape aShape = BRepPrimAPI_MakeBox(aPnt1, aPnt2);
1814   myResult << "Box with corners [" << aPnt1.X() << ", " << aPnt1.Y() << ", " << aPnt1.Z()
1815            << "] and [" << aPnt2.X() << ", " << aPnt2.Y() << ", " << aPnt2.Z()
1816            << "] was created in red" << std::endl;
1817
1818   // Retrieve volume properties from the face.
1819   GProp_GProps aGProps;
1820   BRepGProp::VolumeProperties(aShape, aGProps);
1821   Standard_Real aVolume = aGProps.Mass();
1822   gp_Pnt aCOM = aGProps.CentreOfMass();
1823   Standard_Real anIx, anIy, anIz;
1824   aGProps.StaticMoments(anIx, anIy, anIz);
1825   gp_Mat aMOI = aGProps.MatrixOfInertia();
1826   myResult << "Linear properties:" << std::endl
1827            << "  Volume            = " << aVolume << std::endl
1828            << "  Center of mass    = [ " << aCOM.X() << ", " << aCOM.Y() << ", " << aCOM.Z() << " ]" << std::endl
1829            << "  Static moments    = [ " << anIx << ", " << anIy << ", " << anIz << " ]" << std::endl
1830            << "  Matrix of inertia = [ "
1831            << aMOI(1, 1) << ", " << aMOI(1, 2) << ", " << aMOI(1, 3) << std::endl
1832            << std::setw(33) << aMOI(2, 1) << ", " << aMOI(2, 2) << ", " << aMOI(2, 3) << std::endl
1833            << std::setw(33) << aMOI(3, 1) << ", " << aMOI(3, 2) << ", " << aMOI(3, 3) << " ]" << std::endl;
1834   GProp_PrincipalProps aPProps = aGProps.PrincipalProperties();
1835   Standard_Real anIxx, anIyy, anIzz;
1836   aPProps.Moments(anIxx, anIyy, anIzz);
1837   Standard_Real aRxx, aRyy, aRzz;
1838   aPProps.RadiusOfGyration(aRxx, aRyy, aRzz);
1839   myResult << "Principal properties:" << std::endl
1840            << "  Has symmetric axis  : " << (aPProps.HasSymmetryAxis() ? "YES" : "NO") << std::endl
1841            << "  Has symmetric point : " << (aPProps.HasSymmetryPoint() ? "YES" : "NO") << std::endl
1842            << "  Moments of inertia  = [ " << anIxx << ", " << anIyy << ", " << anIzz << " ]" << std::endl
1843            << "  Radius of gyration  = [ " << aRxx << ", " << aRyy << ", " << aRzz << " ]" << std::endl;
1844   if (!aPProps.HasSymmetryPoint())
1845   {
1846     const gp_Vec& anAxis1 = aPProps.FirstAxisOfInertia();
1847     myResult << "  1st axis of inertia = [ " << anAxis1.X() << ", " << anAxis1.Y() << ", " << anAxis1.Z() << " ]" << std::endl;
1848     Handle(AIS_ColoredShape) anAisAxis1 = new AIS_ColoredShape(
1849       BRepBuilderAPI_MakeEdge(aCOM, aCOM.XYZ() + anAxis1.XYZ()));
1850     anAisAxis1->SetColor(Quantity_Color(Quantity_NOC_GREEN));
1851     myObject3d.Append(anAisAxis1);
1852     if (!aPProps.HasSymmetryPoint())
1853     {
1854       const gp_Vec& anAxis2 = aPProps.SecondAxisOfInertia();
1855       myResult << "  2nd axis of inertia = [ " << anAxis2.X() << ", " << anAxis2.Y() << ", " << anAxis2.Z() << " ]" << std::endl;
1856       Handle(AIS_ColoredShape) anAisAxis2 = new AIS_ColoredShape(
1857         BRepBuilderAPI_MakeEdge(aCOM, aCOM.XYZ() + anAxis2.XYZ()));
1858       anAisAxis2->SetColor(Quantity_Color(Quantity_NOC_GREEN));
1859       myObject3d.Append(anAisAxis2);
1860       const gp_Vec& anAxis3 = aPProps.ThirdAxisOfInertia();
1861       myResult << "  3rd axis of inertia = [ " << anAxis3.X() << ", " << anAxis3.Y() << ", " << anAxis3.Z() << " ]" << std::endl;
1862       Handle(AIS_ColoredShape) anAisAxis3 = new AIS_ColoredShape(
1863         BRepBuilderAPI_MakeEdge(aCOM, aCOM.XYZ() + anAxis3.XYZ()));
1864       anAisAxis3->SetColor(Quantity_Color(Quantity_NOC_GREEN));
1865       myObject3d.Append(anAisAxis3);
1866     }
1867   }
1868
1869   Handle(AIS_ColoredShape) anAisShape = new AIS_ColoredShape(aShape);
1870   Handle(AIS_Point) anAisCOM = new AIS_Point(new Geom_CartesianPoint(aCOM));
1871   anAisShape->SetColor(Quantity_Color(Quantity_NOC_RED));
1872   Handle(AIS_TextLabel) aCOMLabel = new AIS_TextLabel();
1873   aCOMLabel->SetText("Center of mass");
1874   aCOMLabel->SetPosition(aCOM);
1875   Handle(AIS_Axis) anAisAxisX = new AIS_Axis(new Geom_Axis2Placement(gp::YOZ()), AIS_TOAX_XAxis);
1876   Handle(AIS_Axis) anAisAxisY = new AIS_Axis(new Geom_Axis2Placement(gp::ZOX()), AIS_TOAX_YAxis);
1877   Handle(AIS_Axis) anAisAxisZ = new AIS_Axis(new Geom_Axis2Placement(gp::XOY()), AIS_TOAX_ZAxis);
1878   myObject3d.Append(anAisAxisX);
1879   myObject3d.Append(anAisAxisY);
1880   myObject3d.Append(anAisAxisZ);
1881   myObject3d.Append(anAisShape);
1882   myObject3d.Append(anAisCOM);
1883   myObject3d.Append(aCOMLabel);
1884 }