OpenCascade/occt
1
0
Fork 0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-04-02 17:46:22 +03:00
Code Packages Releases Activity
occt/samples/OCCTOverview/code/GeometrySamples.cxx
asuraven a2176e6524 0031570: Samples - add Qt samples similar to standard MFC samples 
Added Qt sample OCCTOverview providing examples of use of OCCT API with relevant code and demonstration of results in the viewer.

Off-topic: some unused images are removed from dox/introduction/images/
2020-10-06 20:40:23 +03:00

2028 lines
82 KiB
C++
Raw Blame History

// Copyright (c) 2020 OPEN CASCADE SAS
//
// This file is part of the examples of the Open CASCADE Technology software library.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE
#include "GeometrySamples.h"
#include <limits>
#include <gp_Pnt.hxx>
#include <gp_XYZ.hxx>
#include <gp_Vec.hxx>
#include <gp_Dir.hxx>
#include <gp_Ax1.hxx>
#include <gp_Ax2.hxx>
#include <gp_Ax3.hxx>
#include <gp_Lin.hxx>
#include <gp_Circ.hxx>
#include <gp_Elips.hxx>
#include <gp_Parab.hxx>
#include <gp_Hypr.hxx>
#include <gp_Cylinder.hxx>
#include <gp_Cone.hxx>
#include <gp_Sphere.hxx>
#include <gp_Torus.hxx>
#include <gp_Pnt2d.hxx>
#include <gp_XY.hxx>
#include <gp_Ax2d.hxx>
#include <gp_Ax22d.hxx>
#include <gp_Lin2d.hxx>
#include <gp_Circ2d.hxx>
#include <gp_Elips2d.hxx>
#include <gp_Parab2d.hxx>
#include <gp_Hypr2d.hxx>
#include <Geom2d_BSplineCurve.hxx>
#include <Geom2d_BezierCurve.hxx>
#include <Geom2d_OffsetCurve.hxx>
#include <ProjLib.hxx>
#include <ElSLib.hxx>
#include <Extrema_ExtElCS.hxx>
#include <Extrema_POnCurv.hxx>
#include <IntAna_Quadric.hxx>
#include <IntAna_IntConicQuad.hxx>
#include <GccAna_Lin2d2Tan.hxx>
#include <GccEnt_QualifiedCirc.hxx>
#include <Geom2dAPI_ProjectPointOnCurve.hxx>
#include <Geom2dAPI_ExtremaCurveCurve.hxx>
#include <Geom2dAPI_InterCurveCurve.hxx>
#include <Geom2dAPI_PointsToBSpline.hxx>
#include <Geom_CartesianPoint.hxx>
#include <Geom_VectorWithMagnitude.hxx>
#include <Geom_Axis1Placement.hxx>
#include <Geom_Axis2Placement.hxx>
#include <Geom_Line.hxx>
#include <Geom_Circle.hxx>
#include <Geom_Ellipse.hxx>
#include <Geom_Parabola.hxx>
#include <Geom_Hyperbola.hxx>
#include <Geom_BSplineCurve.hxx>
#include <Geom_BezierCurve.hxx>
#include <Geom_TrimmedCurve.hxx>
#include <Geom_OffsetCurve.hxx>
#include <Geom_BSplineSurface.hxx>
#include <Geom_BezierSurface.hxx>
#include <Geom_Plane.hxx>
#include <Geom_CylindricalSurface.hxx>
#include <Geom_ConicalSurface.hxx>
#include <Geom_SphericalSurface.hxx>
#include <Geom_ToroidalSurface.hxx>
#include <Geom_RectangularTrimmedSurface.hxx>
#include <Geom_OffsetSurface.hxx>
#include <Geom_SurfaceOfLinearExtrusion.hxx>
#include <Geom_SurfaceOfRevolution.hxx>
#include <BndLib_Add3dCurve.hxx>
#include <BndLib_AddSurface.hxx>
#include <GeomAdaptor_Curve.hxx>
#include <GeomAdaptor_Surface.hxx>
#include <GeomAPI_PointsToBSpline.hxx>
#include <GeomAPI_PointsToBSplineSurface.hxx>
#include <GeomConvert.hxx>
#include "AdaptorPnt2d_AIS.h"
#include "AdaptorVec_AIS.h"
#include "AdaptorCurve_AIS.h"
#include "AdaptorCurve2d_AIS.h"
#include <Geom2d_CartesianPoint.hxx>
#include <Geom2d_VectorWithMagnitude.hxx>
#include <Geom2d_Line.hxx>
#include <Geom2d_Circle.hxx>
#include <Geom2d_Ellipse.hxx>
#include <Geom2d_Parabola.hxx>
#include <Geom2d_Hyperbola.hxx>
#include <Geom2d_TrimmedCurve.hxx>
#include <Geom2dAdaptor_Curve.hxx>
#include <Bnd_Box2d.hxx>
#include <BndLib_Add2dCurve.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <BRepBuilderAPI_MakeEdge.hxx>
#include <BRepBuilderAPI_MakeFace.hxx>
#include <BRepPrimAPI_MakeBox.hxx>
#include <AIS_Point.hxx>
#include <AIS_TextLabel.hxx>
#include <AIS_Axis.hxx>
#include <AIS_InteractiveContext.hxx>
#include <AIS_Circle.hxx>
#include <AIS_Plane.hxx>
#include <AIS_Shape.hxx>
#include <AIS_ColoredShape.hxx>
#include <GProp_PEquation.hxx>
void GeometrySamples::ExecuteSample (const TCollection_AsciiString& theSampleName)
{
Standard_Boolean anIsSamplePresent = Standard_True;
FindSourceCode(theSampleName);
if (theSampleName == "ZeroDimensionObjects3dSample")
ZeroDimensionObjects3dSample();
else if (theSampleName == "Vectors3dSample")
Vectors3dSample();
else if (theSampleName == "InfinityLines3dSample")
InfinityLines3dSample();
else if (theSampleName == "SecondOrderCurves3dSample")
SecondOrderCurves3dSample();
else if (theSampleName == "PlaneSurfaces3dSample")
PlaneSurfaces3dSample();
else if (theSampleName == "SecondOrderSurfaces3dSample")
SecondOrderSurfaces3dSample();
else if (theSampleName == "ZeroDimensionObjects2dSample")
ZeroDimensionObjects2dSample();
else if (theSampleName == "Vectors2dSample")
Vectors2dSample();
else if (theSampleName == "InfinityLines2dSample")
InfinityLines2dSample();
else if (theSampleName == "SecondOrderCurves2dSample")
SecondOrderCurves2dSample();
else if (theSampleName == "BarycenterPoint3dSample")
BarycenterPoint3dSample();
else if (theSampleName == "RotatedVector3dSample")
RotatedVector3dSample();
else if (theSampleName == "MirroredLine3dSample")
MirroredLine3dSample();
else if (theSampleName == "ScaledEllipse3dSample")
ScaledEllipse3dSample();
else if (theSampleName == "TransformedCylinder3dSample")
TransformedCylinder3dSample();
else if (theSampleName == "TranslatedTorus3dSample")
TranslatedTorus3dSample();
else if (theSampleName == "ConjugateObjects3dSample")
ConjugateObjects3dSample();
else if (theSampleName == "ProjectionOfPoint3dSample")
ProjectionOfPoint3dSample();
else if (theSampleName == "MinimalDistance3dSample")
MinimalDistance3dSample();
else if (theSampleName == "MirroredAxis2dSample")
MirroredAxis2dSample();
else if (theSampleName == "TransformedEllipse2dSample")
TransformedEllipse2dSample();
else if (theSampleName == "ConjugateObjects2dSample")
ConjugateObjects2dSample();
else if (theSampleName == "Intersection3dSample")
Intersection3dSample();
else if (theSampleName == "TranslatedPoint2dSample")
TranslatedPoint2dSample();
else if (theSampleName == "RotatedDirection2dSample")
RotatedDirection2dSample();
else if (theSampleName == "Tangent2dSample")
Tangent2dSample();
else if (theSampleName == "ProjectionOfPoint2dSample")
ProjectionOfPoint2dSample();
else if (theSampleName == "MinimalDistance2dSample")
MinimalDistance2dSample();
else if (theSampleName == "Intersection2dSample")
Intersection2dSample();
else if (theSampleName == "PointInfo3dSample")
PointInfo3dSample();
else if (theSampleName == "EllipseInfo3dSample")
EllipseInfo3dSample();
else if (theSampleName == "PointInfo2dSample")
PointInfo2dSample();
else if (theSampleName == "CircleInfo2dSample")
CircleInfo2dSample();
else if (theSampleName == "SecondOrderCurves3dSample")
SecondOrderCurves3dSample();
else if (theSampleName == "FreeStyleCurves3dSample")
FreeStyleCurves3dSample();
else if (theSampleName == "AnalyticalSurfaces3dSample")
AnalyticalSurfaces3dSample();
else if (theSampleName == "FreeStyleSurfaces3dSample")
FreeStyleSurfaces3dSample();
else if (theSampleName == "SecondOrderCurves2dSample")
SecondOrderCurves2dSample();
else if (theSampleName == "FreeStyleCurves2dSample")
FreeStyleCurves2dSample();
else if (theSampleName == "TrimmedCurve3dSample")
TrimmedCurve3dSample();
else if (theSampleName == "OffsetCurve3dSample")
OffsetCurve3dSample();
else if (theSampleName == "BSplineFromCircle3dSample")
BSplineFromCircle3dSample();
else if (theSampleName == "TrimmedSurface3dSample")
TrimmedSurface3dSample();
else if (theSampleName == "OffsetSurface3dSample")
OffsetSurface3dSample();
else if (theSampleName == "ExtrusionSurface3dSample")
ExtrusionSurface3dSample();
else if (theSampleName == "RevolutionSurface3dSample")
RevolutionSurface3dSample();
else if (theSampleName == "TrimmedCurve2dSample")
TrimmedCurve2dSample();
else if (theSampleName == "OffsetCurve2dSample")
OffsetCurve2dSample();
else if (theSampleName == "BoundingBoxOfSurface3dSample")
BoundingBoxOfSurface3dSample();
else if (theSampleName == "BoundingBoxOfCurves3dSample")
BoundingBoxOfCurves3dSample();
else if (theSampleName == "BoundingBoxOfCurves2dSample")
BoundingBoxOfCurves2dSample();
else if (theSampleName == "DumpCircleInfoSample")
DumpCircleInfoSample();
else if (theSampleName == "DumpBSplineCurveInfoSample")
DumpBSplineCurveInfoSample();
else
{
myResult << "No function found: " << theSampleName;
myCode += TCollection_AsciiString("No function found: ") + theSampleName;
anIsSamplePresent = Standard_False;
}
myIsProcessed = anIsSamplePresent;
}
void GeometrySamples::DisplayPnt (const gp_Pnt2d& thePnt2d, const TCollection_AsciiString& theText,
Aspect_TypeOfMarker theMarker, Standard_Real theDistance)
{
gp_Pnt aPnt(thePnt2d.X(), thePnt2d.Y(), 0.0);
Handle(Geom_CartesianPoint) aGeomPoint = new Geom_CartesianPoint(aPnt);
Handle(AIS_Point) anAisPoint = new AIS_Point(aGeomPoint);
anAisPoint->SetMarker(theMarker);
myObject2d.Append(anAisPoint);
Handle(AIS_TextLabel) aPntLabel = new AIS_TextLabel();
aPntLabel->SetText(theText);
aPntLabel->SetPosition(gp_Pnt(aPnt.X(), aPnt.Y() + theDistance, aPnt.Z()));
myObject2d.Append(aPntLabel);
}
void GeometrySamples::DisplayPnt (const gp_Pnt& thePnt, const TCollection_AsciiString& theText,
Aspect_TypeOfMarker theMarker, Standard_Real theDistance)
{
Handle(Geom_CartesianPoint) aPoint = new Geom_CartesianPoint(thePnt);
Handle(AIS_Point) anAisPoint = new AIS_Point(aPoint);
anAisPoint->SetMarker(theMarker);
myObject3d.Append(anAisPoint);
Handle(AIS_TextLabel) aPntLabel = new AIS_TextLabel();
aPntLabel->SetText(theText);
aPntLabel->SetPosition(gp_Pnt(thePnt.X(), thePnt.Y(), thePnt.Z() + theDistance));
myObject3d.Append(aPntLabel);
}
void GeometrySamples::ZeroDimensionObjects3dSample()
{
// gp_Pnt describes a point in 3D space. A Geom_CartesianPoint is defined by
// a gp_Pnt point, with its three Cartesian coordinates X, Y and Z.
gp_Pnt aCoordPnt(10.0, 20.0, 30.0);
Handle(Geom_CartesianPoint) aCoordGeomPoint = new Geom_CartesianPoint(aCoordPnt);
Handle(AIS_Point) aCoordAisPoint = new AIS_Point(aCoordGeomPoint);
myObject3d.Append(aCoordAisPoint);
Handle(AIS_TextLabel) aPntLabel = new AIS_TextLabel();
aPntLabel->SetText(" gp_Pnt");
aPntLabel->SetPosition(gp_Pnt(aCoordPnt.X(), aCoordPnt.Y(), aCoordPnt.Z() + 5.0));
myObject3d.Append(aPntLabel);
myResult << "gp_Pnt was created" << std::endl;
// gp_XYZ class describes a Cartesian coordinate entity in 3D space (X,Y,Z).
// This entity is used for algebraic calculation.
// This entity can be transformed with a "Trsf" or a "GTrsf" from package "gp".
// It is used in vectorial computations or for holding this type of information
// in data structures.
gp_XYZ aXyz1(10.0, 20.0, 30.0);
gp_XYZ aXyz2(20.0, 10.0, 30.0);
gp_XYZ aXyzSum = aXyz1 + aXyz2;
gp_Pnt aSumPnt(aXyzSum);
Handle(Geom_CartesianPoint) aXyzGeomPoint = new Geom_CartesianPoint(aSumPnt);
Handle(AIS_Point) aSumAisPoint = new AIS_Point(aXyzGeomPoint);
myObject3d.Append(aSumAisPoint);
Handle(AIS_TextLabel) aXyzLabel = new AIS_TextLabel();
aXyzLabel->SetText(" gp_XYZ");
aXyzLabel->SetPosition(gp_Pnt(aXyzSum.X(), aXyzSum.Y(), aXyzSum.Z() + 5.0));
myObject3d.Append(aXyzLabel);
myResult << "gp_XYZ was created" << std::endl;
}
void GeometrySamples::Vectors3dSample()
{
gp_Pnt aPnt1(0.0, 0.0, 0.0);
gp_Pnt aPnt2(5.0, 0.0, 0.0);
// gp_Vec defines a non-persistent vector in 3D space.
gp_Vec aVec(aPnt1, aPnt2);
Handle(AdaptorVec_AIS) aVecAIS = new AdaptorVec_AIS(aPnt1, aVec, 0.5);
aVecAIS->SetText(" gp_Vec");
myObject3d.Append(aVecAIS);
myResult << "gp_Vec magnitude: " << aVec.Magnitude() << std::endl;
// Describes a unit vector in 3D space.
// This unit vector is also called "Direction".
// See Also gce_MakeDir which provides functions for more complex unit vector
// constructions Geom_Direction which provides additional functions
// for constructing unit vectors and works, in particular,
// with the parametric equations of unit vectors.
gp_Dir aDir(aVec);
Handle(AdaptorVec_AIS) aDirAIS = new AdaptorVec_AIS(gp_Pnt(0.0, 0.0, 10.0), aDir, 1.0, 0.5);
aDirAIS->SetText(" gp_Dir");
myObject3d.Append(aDirAIS);
myResult << "gp_Dir coordinates: X: " << aDir.X() << ", Y: " << aDir.Y() << ", Z: " << aDir.Z() << std::endl;
}
void GeometrySamples::InfinityLines3dSample()
{
gp_Pnt aBasePoint(0.0, 0.0, 0.0);
gp_Dir aX_Direction(1.0, 0.0, 0.0);
gp_Dir anY_Direction(0.0, 1.0, 0.0);
gp_Dir aZ_Direction(0.0, 0.0, 1.0);
// Describes an axis in 3D space.
gp_Ax1 anAxis1(aBasePoint, aZ_Direction);
Handle(AdaptorVec_AIS) anAx1Ais = new AdaptorVec_AIS(anAxis1.Location(), anAxis1.Direction(), 1.0, 0.3);
anAx1Ais->SetText(" gp_Ax1");
myObject3d.Append(anAx1Ais);
myResult << "gp_Ax1 was created" << std::endl << std::endl;
// Describes a right - handed coordinate system in 3D space.
aBasePoint.SetCoord(0.0, 0.0, 3.0);
gp_Ax2 anAxis2(aBasePoint, aZ_Direction);
Handle(AdaptorVec_AIS) aAx2AisZ = new AdaptorVec_AIS(anAxis2.Location(), anAxis2.Direction(), 1.0, 0.3);
aAx2AisZ->SetText(" gp_Ax2 Z");
myObject3d.Append(aAx2AisZ);
Handle(AdaptorVec_AIS) aAx2AisX = new AdaptorVec_AIS(anAxis2.Location(), anAxis2.XDirection(), 1.0, 0.3);
aAx2AisX->SetText(" gp_Ax2 X");
myObject3d.Append(aAx2AisX);
Handle(AdaptorVec_AIS) aAx2AisY = new AdaptorVec_AIS(anAxis2.Location(), anAxis2.YDirection(), 1.0, 0.3);
aAx2AisY->SetText(" gp_Ax2 Y");
myObject3d.Append(aAx2AisY);
myResult << "gp_Ax2 was created" << std::endl;
// Describes a coordinate system in 3D space.Unlike a gp_Ax2 coordinate system,
// a gp_Ax3 can be right - handed("direct sense") or left - handed("indirect sense").
gp_Ax3 anAxis3(gp_XYZ(0.0, 0.0, 6.0), aZ_Direction, aX_Direction);
anAxis3.YReverse();
Handle(AdaptorVec_AIS) anAx3AisZ = new AdaptorVec_AIS(anAxis3.Location(), anAxis3.Direction(), 1.0, 0.3);
anAx3AisZ->SetText(" gp_Ax3 Z");
myObject3d.Append(anAx3AisZ);
Handle(AdaptorVec_AIS) anAx3AisX = new AdaptorVec_AIS(anAxis3.Location(), anAxis3.XDirection(), 1.0, 0.3);
anAx3AisX->SetText(" gp_Ax3 X");
myObject3d.Append(anAx3AisX);
Handle(AdaptorVec_AIS) anAx3AisY = new AdaptorVec_AIS(anAxis3.Location(), anAxis3.YDirection(), 1.0, 0.3);
anAx3AisY->SetText(" gp_Ax3 Y");
myObject3d.Append(anAx3AisY);
myResult << "gp_Ax3 was created" << std::endl;
const gp_Dir& anAxis3_xDir = anAxis3.XDirection();
const gp_Dir& anAxis3_yDir = anAxis3.YDirection();
myResult << "gp_Ax3 X direction: " << anAxis3_xDir.X() << " " << anAxis3_xDir.Y() << " " << anAxis3_xDir.Z() << std::endl;
myResult << "gp_Ax3 Y direction: " << anAxis3_yDir.X() << " " << anAxis3_yDir.Y() << " " << anAxis3_yDir.Z() << std::endl;
TCollection_AsciiString aDirectionDescription;
if (anAxis3.Direct())
{
aDirectionDescription = "anAxis3 is a right-handed axis system";
}
else
{
aDirectionDescription = "anAxis3 is a left-handed axis system";
}
myResult << aDirectionDescription << std::endl << std::endl;
// Describes a line in 3D space. A line is positioned in space with an axis
// (a gp_Ax1 object) which gives it an origin and a unit vector.
gp_Lin aLine(gp_Pnt(5.0, 0.0, 0.0), gp_Dir(0.0, 1.0, 0.0));
Handle(AdaptorVec_AIS) anLineAis = new AdaptorVec_AIS(aLine.Location(), aLine.Direction(), 8.0);
anLineAis->SetText(" gp_Lin");
myObject3d.Append(anLineAis);
myResult << "gp_Lin was created" << std::endl << std::endl;
}
void GeometrySamples::SecondOrderCurves3dSample()
{
gp_Ax2 anAxis2(gp_Pnt(0.0, 0.0, 0.0), gp_Dir(0.0, 0.0, 1.0));
gp_Circ aCirc(anAxis2, 10.0);
Handle(Geom_Circle) aGeomCircle = new Geom_Circle(aCirc);
Handle(AIS_Circle) anAisCircle = new AIS_Circle(aGeomCircle);
myObject3d.Append(anAisCircle);
// Describes an ellipse in 3D space. An ellipse is defined by its major and minor
// radii and positioned in space with a coordinate system (a gp_Ax2 object)
gp_Elips anElips(anAxis2.Translated(gp_Vec(0.0, 0.0, 10.0)), 20.0, 10.0);
Handle(Geom_Ellipse) aGeomEllipse = new Geom_Ellipse(anElips);
Handle(AdaptorCurve_AIS) anAisEllipce = new AdaptorCurve_AIS(aGeomEllipse);
myObject3d.Append(anAisEllipce);
// Describes a parabola in 3D space. A parabola is defined by its focal length
// (that is, the distance between its focus and apex) and positioned in space with
// a coordinate system (a gp_Ax2 object)
gp_Parab aParab(anAxis2.Translated(gp_Vec(0.0, 0.0, 20.0)), 2.0);
Handle(Geom_Parabola) aGeomParabola = new Geom_Parabola(aParab);
Handle(Geom_TrimmedCurve) aTrimmedParabola = new Geom_TrimmedCurve(aGeomParabola, 20.0, -20.0);
Handle(AdaptorCurve_AIS) anAisParabola = new AdaptorCurve_AIS(aTrimmedParabola);
myObject3d.Append(anAisParabola);
// Describes a branch of a hyperbola in 3D space. A hyperbola is defined by its major
// and minor radii and positioned in space with a coordinate system (a gp_Ax2 object)
gp_Hypr aHypr(anAxis2.Translated(gp_Vec(0.0, 0.0, 30.0)), 20.0, 10.0);
Handle(Geom_Hyperbola) aGeomHyperbola = new Geom_Hyperbola(aHypr);
Handle(Geom_TrimmedCurve) aTrimmedHyperbola = new Geom_TrimmedCurve(aGeomHyperbola, 2.0, -2.0);
Handle(AdaptorCurve_AIS) anAisHyperbola = new AdaptorCurve_AIS(aTrimmedHyperbola);
myObject3d.Append(anAisHyperbola);
}
void GeometrySamples::PlaneSurfaces3dSample()
{
// Describes a plane.A plane is positioned in space with a coordinate system(a gp_Ax3 object),
// such that the plane is defined by the origin, "X Direction" and "Y Direction" of this
// coordinate system, which is the "local coordinate system" of the plane.The "main Direction"
// of the coordinate system is a vector normal to the plane.
gp_Pln aPln(gp_Pnt(0.0, 0.0, 0.0), gp_Dir(0.0, 0.0, 1.0));
Handle(Geom_Plane) aPlane = new Geom_Plane(aPln);
Handle(AIS_Plane) anAisPlane = new AIS_Plane(aPlane, aPln.Location(),
gp_Pnt(10.0, 10.0, 0.0),
gp_Pnt(-10.0, -10.0, 0.0),
Standard_False);
myObject3d.Append(anAisPlane);
// Describes an infinite cylindrical surface.A cylinder is defined by its radius and positioned
// in space with a coordinate system(a gp_Ax3 object), the "main Axis" of which is the axis of
// the cylinder.This coordinate system is the "local coordinate system" of the cylinder.
gp_Cylinder aCylinder(gp_Ax3(gp_Pnt(0.0, 0.0, 10.0), gp_Dir(0.0, 0.0, 1.0)), 10.0);
Handle(Geom_CylindricalSurface) aCylindricalSurface = new Geom_CylindricalSurface(aCylinder);
Handle(AIS_Shape) anAisCylinder = new AIS_Shape(BRepBuilderAPI_MakeFace(
aCylindricalSurface, 0.0, 2.0*M_PI, 0.0, 10.0, Precision::Confusion()).Shape());
myObject3d.Append(anAisCylinder);
// Defines an infinite conical surface. A cone is defined by its half-angle (can be negative) at
// the apex and positioned in space with a coordinate system (a gp_Ax3 object) and a "reference radius"
gp_Cone aCone(gp_Ax3(gp_Pnt(0.0, 0.0, 30.0), gp_Dir(0.0, 0.0, 1.0)), 0.25*M_PI, 0.0);
Handle(Geom_ConicalSurface) aConicalSurface = new Geom_ConicalSurface(aCone);
Handle(AIS_Shape) anAisCone = new AIS_Shape(BRepBuilderAPI_MakeFace(
aConicalSurface, 0.0, 2.0*M_PI, 0.0, 20.0, Precision::Confusion()).Shape());
myObject3d.Append(anAisCone);
}
void GeometrySamples::SecondOrderSurfaces3dSample()
{
gp_Sphere aSphere(gp_Ax3(gp_Pnt(0.0, 0.0, 0.0), gp_Dir(0.0, 0.0, 1.0)), 10.0);
Handle(Geom_SphericalSurface) aSphericalSurface = new Geom_SphericalSurface(aSphere);
Handle(AIS_Shape) anAisSphere = new AIS_Shape(BRepBuilderAPI_MakeFace(
aSphericalSurface, 0.0, 2.0*M_PI, 0.0, 2.0*M_PI, Precision::Confusion()).Shape());
myObject3d.Append(anAisSphere);
gp_Torus aTorus(gp_Ax3(gp_Pnt(0.0, 0.0, 20.0), gp_Dir(0.0, 0.0, 1.0)), 40.0, 10.0);
Handle(Geom_ToroidalSurface) aToroidalSurface = new Geom_ToroidalSurface(aTorus);
Handle(AIS_Shape) anAisTorus = new AIS_Shape(BRepBuilderAPI_MakeFace(
aToroidalSurface, 0.0, 2.0*M_PI, 0.0, 2.0*M_PI, Precision::Confusion()).Shape());
myObject3d.Append(anAisTorus);
}
void GeometrySamples::ZeroDimensionObjects2dSample()
{
// Defines a non-persistent 2D Cartesian point.
gp_Pnt2d aCoordPnt(10.0, 20.0);
Handle(Geom2d_CartesianPoint) aCoordGeomPoint = new Geom2d_CartesianPoint(aCoordPnt);
Handle(AdaptorPnt2d_AIS) aCoordAisPoint = new AdaptorPnt2d_AIS(aCoordGeomPoint);
myObject2d.Append(aCoordAisPoint);
Handle(AIS_TextLabel) aPntLabel = new AIS_TextLabel();
aPntLabel->SetText("gp_Pnt2d");
aPntLabel->SetPosition(gp_Pnt(aCoordPnt.X(), aCoordPnt.Y() + 0.5, 0.0));
myObject2d.Append(aPntLabel);
myResult << "gp_Pnt was created" << std::endl;
// This class describes a Cartesian coordinate entity in 2D space{ X,Y }.
// This class is non persistent.This entity used for algebraic calculation.
// An XY can be transformed with a Trsf2d or a GTrsf2d from package gp.
// It is used in vectorial computations or for holding this type of information in data structures.
gp_XY aXy(20.0, 10.0);
Handle(Geom2d_CartesianPoint) aXyGeomPoint = new Geom2d_CartesianPoint(aXy);
Handle(AdaptorPnt2d_AIS) aXyAisPoint = new AdaptorPnt2d_AIS(aXyGeomPoint);
myObject2d.Append(aXyAisPoint);
Handle(AIS_TextLabel) aXyLabel = new AIS_TextLabel();
aXyLabel->SetText(" gp_XY");
aXyLabel->SetPosition(gp_Pnt(aXy.X(), aXy.Y() + 0.5, 0.0));
myObject2d.Append(aXyLabel);
myResult << "gp_XY was created" << std::endl;
}
void GeometrySamples::Vectors2dSample()
{
// Describes a unit vector in the plane (2D space).
// This unit vector is also called "Direction".
gp_Dir2d aDir(3.0, 4.0);
Handle(AdaptorVec_AIS) anAisDir = new AdaptorVec_AIS(gp_Pnt2d(0.0, 0.0), aDir, 1.0, 0.3);
anAisDir->SetText(" gp_Dir2d");
myObject2d.Append(anAisDir);
myResult << "gp_Dir2d coordinates: X: " << aDir.X() << ", Y: " << aDir.Y() << std::endl;
// Defines a non-persistent vector in 2D space.
gp_Vec2d aVec(aDir);
aVec = aVec * 2;
Handle(AdaptorVec_AIS) anAisVec = new AdaptorVec_AIS(gp_Pnt2d(0.0, 5.0), aVec, 0.3);
anAisVec->SetText(" gp_Vec2d");
myObject2d.Append(anAisVec);
myResult << "gp_Vec2d magnitude: " << aVec.Magnitude() << std::endl;
}
void GeometrySamples::InfinityLines2dSample()
{
// Describes an axis in the plane (2D space)
gp_Ax2d anAx2d(gp_Pnt2d(0.0, 0.0), gp_Dir2d(1.0, 0.0));
Handle(AdaptorVec_AIS) anAisAx2d = new AdaptorVec_AIS(anAx2d.Location(), anAx2d.Direction(), 1.0, 0.3);
anAisAx2d->SetText(" gp_Ax2d");
myObject2d.Append(anAisAx2d);
// Describes a coordinate system in a plane (2D space).
gp_Ax22d anAx22d(gp_Pnt2d(0.0, 2.0), gp_Dir2d(1.0, 1.0), Standard_False);
Handle(AdaptorVec_AIS) anAisAx2d_X = new AdaptorVec_AIS(anAx22d.Location(), anAx22d.XDirection(), 1.0, 0.3);
anAisAx2d_X->SetText(" gp_Ax2d X");
myObject2d.Append(anAisAx2d_X);
Handle(AdaptorVec_AIS) anAisAx2d_Y = new AdaptorVec_AIS(anAx22d.Location(), anAx22d.YDirection(), 1.0, 0.3);
anAisAx2d_Y->SetText(" gp_Ax2d Y");
myObject2d.Append(anAisAx2d_Y);
// Describes a line in 2D space. A line is positioned in the plane with an axis (a gp_Ax2d object) which gives
// the line its origin and unit vector. A line and an axis are similar objects, thus,
// we can convert one into the other. A line provides direct access to the majority of the edit and query
// functions available on its positioning axis.
gp_Lin2d aLin2d(gp_Pnt2d(2.0, 4.0), gp_Dir2d(0.0, -1.0));
Handle(AdaptorVec_AIS) anAisLin = new AdaptorVec_AIS(aLin2d.Location(), aLin2d.Direction(), 1.0, 0.3);
anAisLin->SetText(" gp_Lin2d");
myObject2d.Append(anAisLin);
}
void GeometrySamples::SecondOrderCurves2dSample()
{
// Describes a circle in the plane (2D space). A circle is defined by its radius
// and positioned in the plane with a coordinate system (a gp_Ax22d object)
gp_Circ2d aCirc2d;
aCirc2d.SetLocation(gp_Pnt2d(0.0, 0.0));
aCirc2d.SetRadius(10.0);
Handle(Geom2d_Circle) aGeomCircle = new Geom2d_Circle(aCirc2d);
Handle(AdaptorCurve2d_AIS) anAisCirc = new AdaptorCurve2d_AIS(aGeomCircle, Aspect_TOL_SOLID);
myObject2d.Append(anAisCirc);
// Describes an ellipse in the plane (2D space). An ellipse is defined by its major
// and minor radii and positioned in the plane with a coordinate system (a gp_Ax22d object)
gp_Elips2d anElips(gp_Ax2d(gp_Pnt2d(0.0, 30.0), gp_Dir2d(1.0, 0.0)), 20.0, 10.0);
Handle(Geom2d_Ellipse) aGeomEllipse = new Geom2d_Ellipse(anElips);
Handle(AdaptorCurve2d_AIS) anAisEllipse = new AdaptorCurve2d_AIS(aGeomEllipse, Aspect_TOL_DASH);
myObject2d.Append(anAisEllipse);
// Describes a parabola in the plane (2D space). A parabola is defined by its focal length
// (that is, the distance between its focus and apex) and positioned in the plane with
// a coordinate system (a gp_Ax22d object)
gp_Parab2d aParab2d(gp_Ax2d(gp_Pnt2d(20.0, 0.0), gp_Dir2d(1.0, 0.0)), 10.0);
Handle(Geom2d_Parabola) aGeomParabola = new Geom2d_Parabola(aParab2d);
Handle(Geom2d_TrimmedCurve) aTrimmedParabola = new Geom2d_TrimmedCurve(aGeomParabola, 40.0, -40.0);
Handle(AdaptorCurve2d_AIS) anAisParabola = new AdaptorCurve2d_AIS(aTrimmedParabola, Aspect_TOL_DOT);
myObject2d.Append(anAisParabola);
// Describes a branch of a hyperbola in the plane (2D space). A hyperbola is defined by its major and
// minor radii, and positioned in the plane with a coordinate system (a gp_Ax22d object)
gp_Hypr2d aHypr2d(gp_Ax2d(gp_Pnt2d(20.0, 0.0), gp_Dir2d(1.0, 0.0)), 20.0, 10.0);
Handle(Geom2d_Hyperbola) aGeomHyperbola = new Geom2d_Hyperbola(aHypr2d);
Handle(Geom2d_TrimmedCurve) aTrimmedHyperbola = new Geom2d_TrimmedCurve(aGeomHyperbola, 2.0, -2.0);
Handle(AdaptorCurve2d_AIS) anAisHyperbola = new AdaptorCurve2d_AIS(aTrimmedHyperbola, Aspect_TOL_DOTDASH);
myObject2d.Append(anAisHyperbola);
}
void GeometrySamples::BarycenterPoint3dSample()
{
// Barycenter of 2 points
gp_Pnt aPnt1(11, 2, 3);
gp_Pnt aPnt2(13, 4, 5);
gp_Pnt aBarycenterPnt2 = aPnt1;
Standard_Real anAlpha = 3;
Standard_Real anBeta = 7;
// Assigns the result of the following expression to this point:
// (Alpha*this + Beta*P) / (Alpha + Beta)
aBarycenterPnt2.BaryCenter(anAlpha, aPnt2, anBeta);
DisplayPnt(aPnt1, "Pnt1", Aspect_TOM_PLUS, 0.5);
DisplayPnt(aPnt2, "Pnt2", Aspect_TOM_PLUS, 0.5);
DisplayPnt(aBarycenterPnt2, "Barycenter Pnt", Aspect_TOM_O_PLUS, 0.5);
// BaryCenter of an array of point
gp_Pnt aP1(0, 0, 5);
gp_Pnt aP2(1, 2, 3);
gp_Pnt aP3(2, 3, -2);
gp_Pnt aP4(4, 3, 5);
gp_Pnt aP5(5, 5, 4);
TColgp_Array1OfPnt aPntArray(1, 5);
aPntArray.SetValue(1, aP1);
aPntArray.SetValue(2, aP2);
aPntArray.SetValue(3, aP3);
aPntArray.SetValue(4, aP4);
aPntArray.SetValue(5, aP5);
Standard_Real Tolerance = 8;
GProp_PEquation aPEquation(aPntArray, Tolerance);
gp_Pnt aBarycenterPnt5; // P declaration
bool isPoint = false;
if (aPEquation.IsPoint())
{
isPoint = true;
aBarycenterPnt5 = aPEquation.Point();
myResult << "GProp_PEquation is a point" << std::endl;
}
else
{
isPoint = false;
myResult << "GProp_PEquation is not a point" << std::endl;
}
if (aPEquation.IsLinear())
{
/*... */
}
if (aPEquation.IsPlanar())
{
/*... */
}
if (aPEquation.IsSpace())
{
/*... */
}
const TCollection_AsciiString aPointName("P");
for (Standard_Integer i = aPntArray.Lower(); i <= aPntArray.Upper(); i++)
{
TCollection_AsciiString aString(i);
aString = aPointName + aString;
DisplayPnt(aPntArray(i), aString, Aspect_TOM_STAR, 0.5);
}
DisplayPnt(aBarycenterPnt5, "Barycenter of 5 points", Aspect_TOM_O_STAR, 0.5);
myResult << " IsPoint = ";
if (isPoint)
{
myResult << "True --> " << " P ( " << aBarycenterPnt5.X() << aBarycenterPnt5.Y() << aBarycenterPnt5.Z() << " );" << std::endl;
}
else
{
myResult << "False";
}
myResult << std::endl << " IsLinear = " << (aPEquation.IsLinear() ? "True" : "False");
myResult << std::endl << " IsPlanar = " << (aPEquation.IsPlanar() ? "True" : "False");
myResult << std::endl << " IsSpace = " << (aPEquation.IsSpace() ? "True" : "False");
}
void GeometrySamples::RotatedVector3dSample()
{
gp_Vec aBaseVec(0.0, 0.0, 10.0);
gp_Pnt aZeroPnt(0.0, 0.0, 0.0);
gp_Vec aRotatedVec = aBaseVec.Rotated(gp_Ax1(aZeroPnt, gp_Dir(1.0, 0.0, 0.0)), M_PI_4);
Handle(AdaptorVec_AIS) aBaseVecAIS = new AdaptorVec_AIS(aZeroPnt, aBaseVec);
aBaseVecAIS->SetText(" Base vector");
myObject3d.Append(aBaseVecAIS);
Handle(AdaptorVec_AIS) aRotatedVecAIS = new AdaptorVec_AIS(aZeroPnt, aRotatedVec);
aRotatedVecAIS->SetText(" Rotated vector");
myObject3d.Append(aRotatedVecAIS);
Standard_Real anAdgle = aBaseVec.Angle(aRotatedVec)*180.0 / M_PI;
myResult << "An angle between vectors = " << anAdgle << std::endl;
}
void GeometrySamples::MirroredLine3dSample()
{
gp_Lin aBaseLin(gp_Pnt(0.0, 0.0, 0.0), gp_Dir(1.0, 1.0, 1.0));
gp_Ax2 aXyzAxis;
gp_Lin aMirroredLin = aBaseLin.Mirrored(aXyzAxis);
Handle(AdaptorVec_AIS) aBaseLineAis = new AdaptorVec_AIS(aBaseLin.Location(), aBaseLin.Direction(), 8.0);
aBaseLineAis->SetText(" Base Line");
myObject3d.Append(aBaseLineAis);
Handle(AdaptorVec_AIS) aMirroredLineAis = new AdaptorVec_AIS(aMirroredLin.Location(), aMirroredLin.Direction(), 8.0);
aMirroredLineAis->SetText(" Mirrored Line");
myObject3d.Append(aMirroredLineAis);
Handle(AIS_Plane) anAisPlane = new AIS_Plane (new Geom_Plane(gp_Ax3(aXyzAxis)), aXyzAxis.Location(),
gp_Pnt(10.0, 10.0, 0.0), gp_Pnt(-10.0, -10.0, 0.0), Standard_False);
myObject3d.Append(anAisPlane);
Standard_Real anAdgle = aBaseLin.Angle(aMirroredLin)*180.0 / M_PI;
myResult << "An angle between lines = " << anAdgle << std::endl;
}
void GeometrySamples::ScaledEllipse3dSample()
{
gp_Ax2 anAxis2(gp_Pnt(), gp_Dir(0.0, 0.0, 1.0));
gp_Elips anBaseElips(anAxis2, 20.0, 10.0);
gp_Elips anScaledElips = anBaseElips.Scaled(gp_Pnt(), 2.5);
Handle(Geom_Ellipse) aBaseGeomEllipse = new Geom_Ellipse(anBaseElips);
Handle(AdaptorCurve_AIS) anAisBaseEllipce = new AdaptorCurve_AIS(aBaseGeomEllipse);
myObject3d.Append(anAisBaseEllipce);
Handle(Geom_Ellipse) aScaledGeomEllipse = new Geom_Ellipse(anScaledElips);
Handle(AdaptorCurve_AIS) anAisScaledEllipce = new AdaptorCurve_AIS(aScaledGeomEllipse);
myObject3d.Append(anAisScaledEllipce);
}
void GeometrySamples::TransformedCylinder3dSample()
{
gp_Cylinder aBaseCylinder(gp_Ax3(), 10.0);
gp_Trsf aRotTrsf;
aRotTrsf.SetRotation(gp_Ax1(gp_Pnt(), gp_Dir(1.0, 0.0, 0.0)), M_PI_2);
gp_Trsf aScaleTrsf;
aScaleTrsf.SetScale(gp_Pnt(), 1.5);
gp_Trsf aTranslTrsf;
aTranslTrsf.SetTranslation(gp_Vec(30.0, 0.0, 0.0));
gp_Trsf aComplexTrsf = aRotTrsf * aScaleTrsf * aTranslTrsf;
gp_Cylinder aTransfCylinder = aBaseCylinder.Transformed(aComplexTrsf);
Handle(Geom_CylindricalSurface) aBaseCylinderSurface = new Geom_CylindricalSurface(aBaseCylinder);
Handle(AIS_Shape) anAisBaseCylinder = new AIS_Shape(BRepBuilderAPI_MakeFace(
aBaseCylinderSurface, 0.0, 2.0*M_PI, 0.0, 2.0*M_PI, Precision::Confusion()).Shape());
myObject3d.Append(anAisBaseCylinder);
Handle(Geom_CylindricalSurface) aTransfCylinderSurface = new Geom_CylindricalSurface(aTransfCylinder);
Handle(AIS_Shape) anAisTransfCylinder = new AIS_Shape(BRepBuilderAPI_MakeFace(
aTransfCylinderSurface, 0.0, 2.0*M_PI, 0.0, 2.0*M_PI, Precision::Confusion()).Shape());
myObject3d.Append(anAisTransfCylinder);
}
void GeometrySamples::TranslatedTorus3dSample()
{
gp_Torus aBaseTorus(gp_Ax3(gp_Pnt(), gp_Dir(0.0, 0.0, 1.0)), 40.0, 10.0);
gp_Torus aTranslatedTorus = aBaseTorus.Translated(gp_Vec(70.0, 70.0, 70.0));
Handle(Geom_ToroidalSurface) aBaseSurface = new Geom_ToroidalSurface(aBaseTorus);
Handle(AIS_Shape) anAisBaseShape = new AIS_Shape(BRepBuilderAPI_MakeFace(
aBaseSurface, 0.0, 2.0*M_PI, 0.0, 2.0*M_PI, Precision::Confusion()).Shape());
myObject3d.Append(anAisBaseShape);
Handle(Geom_ToroidalSurface) aTranslSurface = new Geom_ToroidalSurface(aTranslatedTorus);
Handle(AIS_Shape) anAisTranslShape = new AIS_Shape(BRepBuilderAPI_MakeFace(
aTranslSurface, 0.0, 2.0*M_PI, 0.0, 2.0*M_PI, Precision::Confusion()).Shape());
myObject3d.Append(anAisTranslShape);
}
void GeometrySamples::ConjugateObjects3dSample()
{
gp_Hypr aHypr(gp_Ax2(), 20.0, 10.0);
gp_Ax1 anAsymptote1 = aHypr.Asymptote1();
gp_Ax1 anAsymptote2 = aHypr.Asymptote2();
gp_Ax1 aDirectrix1 = aHypr.Directrix1();
gp_Ax1 aDirectrix2 = aHypr.Directrix2();
gp_Pnt aFocus1 = aHypr.Focus1();
gp_Pnt aFocus2 = aHypr.Focus2();
gp_Pnt aLocation = aHypr.Location();
Handle(AdaptorVec_AIS) anAsy1AIS = new AdaptorVec_AIS(anAsymptote1.Location(), gp_Vec(anAsymptote1.Direction())*10.0);
anAsy1AIS->SetText(" Asymptote 1");
myObject3d.Append(anAsy1AIS);
Handle(AdaptorVec_AIS) anAsy2AIS = new AdaptorVec_AIS(anAsymptote2.Location(), gp_Vec(anAsymptote2.Direction())*10.0);
anAsy2AIS->SetText(" Asymptote 2");
myObject3d.Append(anAsy2AIS);
Handle(AdaptorVec_AIS) anDir1AIS = new AdaptorVec_AIS(aDirectrix1.Location(), gp_Vec(aDirectrix1.Direction())*10.0);
anDir1AIS->SetText(" Directrix 1");
myObject3d.Append(anDir1AIS);
Handle(AdaptorVec_AIS) anDir2AIS = new AdaptorVec_AIS(aDirectrix2.Location(), gp_Vec(aDirectrix2.Direction())*10.0);
anDir2AIS->SetText(" Directrix 2");
myObject3d.Append(anDir2AIS);
DisplayPnt(aFocus1, "Focus 1", Aspect_TOM_PLUS, 2.0);
DisplayPnt(aFocus2, "Focus 2", Aspect_TOM_PLUS, 2.0);
DisplayPnt(aLocation, "Location", Aspect_TOM_O_STAR, 2.0);
Handle(Geom_Hyperbola) aGeomHyperbola = new Geom_Hyperbola(aHypr);
Handle(Geom_TrimmedCurve) aTrimmedHyperbola = new Geom_TrimmedCurve(aGeomHyperbola, 2.0, -2.0);
Handle(AdaptorCurve_AIS) anAisHyperbola = new AdaptorCurve_AIS(aTrimmedHyperbola);
myObject3d.Append(anAisHyperbola);
}
void GeometrySamples::ProjectionOfPoint3dSample()
{
gp_Sphere aSphere(gp_Ax3(), 10.0);
gp_Pnt aBasePnt(20.0, 20.0, 20.0);
// A projection point in surface coordinate
gp_Pnt2d aPrjPnt2d = ProjLib::Project(aSphere, aBasePnt);
gp_Pnt aPrjPnt = ElSLib::Value(aPrjPnt2d.X(), aPrjPnt2d.Y(), aSphere);
DisplayPnt(aBasePnt, "Base point", Aspect_TOM_PLUS, 2.0);
DisplayPnt(aPrjPnt, "Projection point", Aspect_TOM_O_STAR, 2.0);
Handle(Geom_SphericalSurface) aSphericalSurface = new Geom_SphericalSurface(aSphere);
Handle(AIS_Shape) anAisSphere = new AIS_Shape(BRepBuilderAPI_MakeFace(
aSphericalSurface, 0.0, 2.0*M_PI, 0.0, 2.0*M_PI, Precision::Confusion()).Shape());
myObject3d.Append(anAisSphere);
}
void GeometrySamples::MinimalDistance3dSample()
{
gp_Cylinder aCylinder(gp_Ax3(gp_Pnt(), gp_Dir(0.0, 0.0, 1.0)), 10.0);
gp_Lin aLine(gp_Pnt(20.0, 0.0, 5.0), gp_Dir(0.0, 1.0, 0.0));
Extrema_ExtElCS anExtrema_ExtElCS(aLine, aCylinder);
if (anExtrema_ExtElCS.IsDone())
{
NCollection_Array1<gp_Vec> aVecArray(1, anExtrema_ExtElCS.NbExt());
NCollection_Array1<gp_Pnt> aPntArray(1, anExtrema_ExtElCS.NbExt());
for (Standard_Integer i = 1; i <= anExtrema_ExtElCS.NbExt(); i++)
{
Extrema_POnCurv aCurvPoint;
Extrema_POnSurf aSurfPoint;
anExtrema_ExtElCS.Points(i, aCurvPoint, aSurfPoint);
gp_Pnt aCurvPnt = aCurvPoint.Value();
gp_Pnt aSurfPnt = aSurfPoint.Value();
DisplayPnt(aCurvPnt, TCollection_AsciiString(i), Aspect_TOM_O_PLUS, 2.0);
DisplayPnt(aSurfPnt, TCollection_AsciiString(i), Aspect_TOM_O_STAR, 2.0);
gp_Vec aVec(aCurvPnt, aSurfPnt);
aVecArray.SetValue(i, aVec);
aPntArray.SetValue(i, aCurvPnt);
}
Standard_Integer aMinDistIndex(0);
Standard_Real aMinDistance = std::numeric_limits<Standard_Real>::max();
for (Standard_Integer i = 1; i <= anExtrema_ExtElCS.NbExt(); i++)
{
if (aMinDistance > aVecArray(i).Magnitude())
{
aMinDistIndex = i;
aMinDistance = aVecArray(i).Magnitude();
}
}
Handle(AdaptorVec_AIS) anMinDistanceAis =
new AdaptorVec_AIS(aPntArray(aMinDistIndex), aVecArray(aMinDistIndex));
anMinDistanceAis->SetText(" Min distance");
myObject3d.Append(anMinDistanceAis);
}
Handle(Geom_CylindricalSurface) aCylindricalSurface = new Geom_CylindricalSurface(aCylinder);
Handle(AIS_Shape) anAisCylinder = new AIS_Shape(BRepBuilderAPI_MakeFace(
aCylindricalSurface, 0.0, 2.0*M_PI, 0.0, 10.0, Precision::Confusion()).Shape());
myObject3d.Append(anAisCylinder);
Handle(AdaptorVec_AIS) anLineAis = new AdaptorVec_AIS(aLine.Location(), aLine.Direction(), 8.0);
anLineAis->SetText(" gp_Lin");
myObject3d.Append(anLineAis);
}
void GeometrySamples::Intersection3dSample()
{
gp_Lin aLine(gp_Pnt(0.0, 0.0, 10.0), gp_Dir(0.0, 1.0, 0.0));
gp_Cone aCone(gp_Ax3(gp_Pnt(), gp_Dir(0.0, 0.0, 1.0)), 0.25*M_PI, 0.0);
IntAna_Quadric anIntAna_Quadric(aCone);
IntAna_IntConicQuad anIntAna_IntConicQuad(aLine, anIntAna_Quadric);
if (anIntAna_IntConicQuad.IsDone())
{
for (int i = 1; i <= anIntAna_IntConicQuad.NbPoints(); i++)
{
const gp_Pnt& aIntersectionPnt = anIntAna_IntConicQuad.Point(i);
DisplayPnt(aIntersectionPnt, TCollection_AsciiString(i));
}
}
Handle(AdaptorVec_AIS) aLineVecAIS = new AdaptorVec_AIS(aLine.Location(), gp_Vec(aLine.Direction())*5.0);
aLineVecAIS->SetText(" Base vector");
myObject3d.Append(aLineVecAIS);
Handle(Geom_ConicalSurface) aConicalSurface = new Geom_ConicalSurface(aCone);
Handle(AIS_Shape) anAisCone = new AIS_Shape(BRepBuilderAPI_MakeFace(
aConicalSurface, 0.0, 2.0*M_PI, 0.0, 20.0, Precision::Confusion()).Shape());
myObject3d.Append(anAisCone);
}
void GeometrySamples::TranslatedPoint2dSample()
{
gp_Pnt2d aPnt1;
gp_Pnt2d aPnt2 = aPnt1.Translated(gp_Vec2d(10.0, 10.0));
DisplayPnt(aPnt1, "1", Aspect_TOM_PLUS, 1.0);
DisplayPnt(aPnt2, "2", Aspect_TOM_PLUS, 1.0);
gp_Vec2d aTranslationVec(aPnt1, aPnt2);
Handle(AdaptorVec_AIS) aVecAIS = new AdaptorVec_AIS(aPnt1, aTranslationVec);
aVecAIS->SetText(" Translation");
myObject2d.Append(aVecAIS);
}
void GeometrySamples::RotatedDirection2dSample()
{
gp_Dir2d aBaseDir(1.0, 1.0);
gp_Dir2d aRotatedDir = aBaseDir.Rotated(M_PI_4);
myResult << "An angle between directions: " << aBaseDir.Angle(aRotatedDir)*180.0 / M_PI << " grad";
Handle(AdaptorVec_AIS) aBaseAIS = new AdaptorVec_AIS(gp_Pnt2d(), aBaseDir, 5.0);
aBaseAIS->SetText(" Base");
myObject2d.Append(aBaseAIS);
Handle(AdaptorVec_AIS) aRotatedAIS = new AdaptorVec_AIS(gp_Pnt2d(), aRotatedDir, 5.0);
aRotatedAIS->SetText(" Rotated");
myObject2d.Append(aRotatedAIS);
}
void GeometrySamples::MirroredAxis2dSample()
{
gp_Ax22d aBaseAx(gp_Pnt2d(10.0, 0.0), gp_Dir2d(1.0, 0.0), Standard_True);
gp_Ax22d aMirrorAx = aBaseAx.Mirrored(gp_Pnt2d());
DisplayPnt(gp_Pnt2d(), "Mirror point", Aspect_TOM_PLUS, 1.0);
Handle(AdaptorVec_AIS) aBaseX_AIS = new AdaptorVec_AIS(aBaseAx.Location(), aBaseAx.XDirection(), 5.0);
aBaseX_AIS->SetText(" X (Base)");
myObject2d.Append(aBaseX_AIS);
Handle(AdaptorVec_AIS) aBaseY_AIS = new AdaptorVec_AIS(aBaseAx.Location(), aBaseAx.YDirection(), 5.0);
aBaseY_AIS->SetText("Y (Base)");
myObject2d.Append(aBaseY_AIS);
Handle(AdaptorVec_AIS) aMirrorX_AIS = new AdaptorVec_AIS(aMirrorAx.Location(), aMirrorAx.XDirection(), 5.0);
aMirrorX_AIS->SetText("X (Mirror)");
myObject2d.Append(aMirrorX_AIS);
Handle(AdaptorVec_AIS) aMirrorY_AIS = new AdaptorVec_AIS(aMirrorAx.Location(), aMirrorAx.YDirection(), 5.0);
aMirrorY_AIS->SetText(" Y (Mirror)");
myObject2d.Append(aMirrorY_AIS);
}
void GeometrySamples::TransformedEllipse2dSample()
{
// Creates an ellipse with the major axis, the major and the minor radius.
// The location of the MajorAxis is the center of the ellipse.The sense of
// parametrization is given by Sense.Warnings : It is possible to create
// an ellipse with MajorRadius = MinorRadius.Raises
// ConstructionError if MajorRadius < MinorRadius or MinorRadius < 0.0.
gp_Elips2d aBaseEllips(gp_Ax2d(gp_Pnt2d(), gp_Dir2d(1.0, 0.0)), 20.0, 10.0);
gp_Trsf2d aRotTrsf;
aRotTrsf.SetRotation(gp_Pnt2d(), M_PI_4);
gp_Trsf2d aScaleTrsf;
aScaleTrsf.SetScale(gp_Pnt2d(), 1.5);
gp_Trsf2d aTranslTrsf;
aTranslTrsf.SetTranslation(gp_Vec2d(30.0, 0.0));
gp_Trsf2d aComplexTrsf = aRotTrsf * aScaleTrsf * aTranslTrsf;
gp_Elips2d aTransfEllips = aBaseEllips.Transformed(aComplexTrsf);
Handle(Geom2d_Ellipse) aBaseEllipse = new Geom2d_Ellipse(aBaseEllips);
Handle(AdaptorCurve2d_AIS) anAisBaseEllipse = new AdaptorCurve2d_AIS(aBaseEllipse, Aspect_TOL_DASH);
myObject2d.Append(anAisBaseEllipse);
Handle(Geom2d_Ellipse) aTransfEllipse = new Geom2d_Ellipse(aTransfEllips);
Handle(AdaptorCurve2d_AIS) anAisTransfEllipse = new AdaptorCurve2d_AIS(aTransfEllipse, Aspect_TOL_DASH);
myObject2d.Append(anAisTransfEllipse);
}
void GeometrySamples::ConjugateObjects2dSample()
{
gp_Parab2d aParab(gp_Ax2d(), 20.0);
gp_Ax2d aDirectrix = aParab.Directrix();
gp_Pnt2d aFocus = aParab.Focus();
gp_Pnt2d aLocation = aParab.Location();
gp_Ax2d aMirror = aParab.MirrorAxis();
Handle(AdaptorVec_AIS) aDirectAIS = new AdaptorVec_AIS(aDirectrix.Location(), gp_Vec2d(aDirectrix.Direction())*10.0);
aDirectAIS->SetText(" Directrix");
myObject2d.Append(aDirectAIS);
Handle(AdaptorVec_AIS) aMirrorAIS = new AdaptorVec_AIS(aMirror.Location(), gp_Vec2d(aMirror.Direction())*10.0);
aMirrorAIS->SetText(" Mirror Axis");
myObject2d.Append(aMirrorAIS);
DisplayPnt(aFocus, "Focus", Aspect_TOM_PLUS, -3.0);
DisplayPnt(aLocation, " Location", Aspect_TOM_O_STAR, 3.0);
Handle(Geom2d_Parabola) aGeomParabola = new Geom2d_Parabola(aParab);
Handle(Geom2d_TrimmedCurve) aTrimmedParabola = new Geom2d_TrimmedCurve(aGeomParabola, 40.0, -40.0);
Handle(AdaptorCurve2d_AIS) anAisParabola = new AdaptorCurve2d_AIS(aTrimmedParabola, Aspect_TOL_DOT);
myObject2d.Append(anAisParabola);
}
void GeometrySamples::Tangent2dSample()
{
gp_Circ2d aCirc1(gp_Ax2d(gp_Pnt2d(0.0, 0.0), gp_Vec2d(1.0, 0.0)), 10.0);
gp_Circ2d aCirc2 = aCirc1.Translated(gp_Vec2d(50.0, 0.0));
aCirc2.SetRadius(20.0);
GccEnt_QualifiedCirc aQaCirc1(aCirc1, GccEnt_outside);
GccEnt_QualifiedCirc aQaCirc2(aCirc2, GccEnt_outside);
GccAna_Lin2d2Tan aLin2d2Tan(aQaCirc1, aQaCirc2, 1E-6);
if (aLin2d2Tan.IsDone())
{
for (int i = 1; i <= aLin2d2Tan.NbSolutions(); i++)
{
const gp_Lin2d& aTangentLin = aLin2d2Tan.ThisSolution(i);
Handle(AdaptorVec_AIS) anAisLin = new AdaptorVec_AIS(aTangentLin.Location(), aTangentLin.Direction(), 20.0);
myObject2d.Append(anAisLin);
}
}
Handle(Geom2d_Circle) aCircle1 = new Geom2d_Circle(aCirc1);
Handle(AdaptorCurve2d_AIS) anAisCirc1 = new AdaptorCurve2d_AIS(aCircle1, Aspect_TOL_SOLID);
myObject2d.Append(anAisCirc1);
Handle(Geom2d_Circle) aCircle2 = new Geom2d_Circle(aCirc2);
Handle(AdaptorCurve2d_AIS) anAisCirc2 = new AdaptorCurve2d_AIS(aCircle2, Aspect_TOL_SOLID);
myObject2d.Append(anAisCirc2);
}
void GeometrySamples::ProjectionOfPoint2dSample()
{
gp_Pnt2d aPntToProject(40.0, 40.0);
gp_Circ2d aCirc(gp_Ax2d(), 20.0);
Handle(Geom2d_Circle) aGeom_Circle = new Geom2d_Circle(aCirc);
Geom2dAPI_ProjectPointOnCurve aProjector(aPntToProject, aGeom_Circle);
gp_Pnt2d aProjectionPnt = aProjector.NearestPoint();
Handle(AdaptorCurve2d_AIS) anAisCirc = new AdaptorCurve2d_AIS(aGeom_Circle, Aspect_TOL_SOLID);
myObject2d.Append(anAisCirc);
DisplayPnt(aPntToProject, "Pnt to project");
DisplayPnt(aProjectionPnt, "Projection Pnt", Aspect_TOM_O_STAR);
}
void GeometrySamples::MinimalDistance2dSample()
{
gp_Lin2d aLin(gp_Pnt2d(-40.0, 0.0), gp_Dir2d(1.0, 1.0));
Handle(Geom2d_Line) aGeom_Line = new Geom2d_Line(aLin);
gp_Circ2d aCirc(gp_Ax2d(), 20.0);
Handle(Geom2d_Circle) aGeom_Circle = new Geom2d_Circle(aCirc);
Geom2dAPI_ExtremaCurveCurve anExtremaFinder(aGeom_Line, aGeom_Circle,
std::numeric_limits<Standard_Real>::min(),
std::numeric_limits<Standard_Real>::max(), 0.0, M_PI*2.0);
if (anExtremaFinder.NbExtrema())
{
gp_Pnt2d aPnt1, aPnt2;
anExtremaFinder.NearestPoints(aPnt1, aPnt2);
myResult << "Extrema found: " << anExtremaFinder.NbExtrema() << std::endl;
myResult << "Minimal distance: " << anExtremaFinder.LowerDistance() << std::endl;
DisplayPnt(aPnt1, "1");
DisplayPnt(aPnt2, "2");
}
else
{
myResult << "No Extrema found" << std::endl;
}
Handle(AdaptorCurve2d_AIS) anAisCirc = new AdaptorCurve2d_AIS(aGeom_Circle, Aspect_TOL_SOLID);
myObject2d.Append(anAisCirc);
Handle(AdaptorVec_AIS) anAisLin = new AdaptorVec_AIS(aLin.Location(), aLin.Direction(), 60.0);
anAisLin->SetText(" gp_Lin2d");
myObject2d.Append(anAisLin);
}
void GeometrySamples::Intersection2dSample()
{
gp_Lin2d aLin(gp_Pnt2d(-20.0, 20.0), gp_Dir2d(1.0, -1.5));
Handle(Geom2d_Line) aGeom_Line = new Geom2d_Line(aLin);
gp_Parab2d aParab(gp_Ax2d(), 20.0);
Handle(Geom2d_Parabola) aGeom_Parabola = new Geom2d_Parabola(aParab);
Geom2dAPI_InterCurveCurve anIntersectFinder(aGeom_Line, aGeom_Parabola);
for (Standard_Integer i = 1; i <= anIntersectFinder.NbPoints(); i++)
{
gp_Pnt2d aPnt = anIntersectFinder.Point(i);
DisplayPnt(aPnt, i);
}
myResult << "Number of intersections : " << anIntersectFinder.NbPoints() << std::endl;
Handle(Geom2d_Parabola) aGeomParabola = new Geom2d_Parabola(aParab);
Handle(Geom2d_TrimmedCurve) aTrimmedParabola = new Geom2d_TrimmedCurve(aGeomParabola, 60.0, -60.0);
Handle(AdaptorCurve2d_AIS) anAisParabola = new AdaptorCurve2d_AIS(aTrimmedParabola, Aspect_TOL_DOT);
myObject2d.Append(anAisParabola);
Handle(AdaptorVec_AIS) anAisLin = new AdaptorVec_AIS(aLin.Location(), aLin.Direction(), 90.0);
anAisLin->SetText(" gp_Lin2d");
myObject2d.Append(anAisLin);
}
void GeometrySamples::PointInfo3dSample()
{
gp_Pnt aPnt1;
gp_Pnt aPnt2(10.0, 10.0, 10.0);
gp_Pnt aPnt3(10.0, -10.0, 0.0);
gp_Pnt aPnt4(10.0, 10.0, 10.0);
Standard_Boolean anIsEqual2_3 = aPnt2.IsEqual(aPnt3, 1E-6);
Standard_Boolean anIsEqual2_4 = aPnt2.IsEqual(aPnt4, 1E-6);
Standard_Real aDistance1_2 = aPnt1.Distance(aPnt2);
Standard_Real aDistance2_4 = aPnt2.Distance(aPnt4);
Standard_Real aSquareDistance1_2 = aPnt1.SquareDistance(aPnt2);
Standard_Real aSquareDistance2_4 = aPnt2.SquareDistance(aPnt4);
myResult << "A coordinate of a point 1: X: " << aPnt1.X() << " Y: " << aPnt1.Y() << " Z: " << aPnt1.Z() << std::endl;
myResult << "A coordinate of a point 2: X: " << aPnt2.X() << " Y: " << aPnt2.Y() << " Z: " << aPnt2.Z() << std::endl;
myResult << "A coordinate of a point 3: X: " << aPnt3.X() << " Y: " << aPnt3.Y() << " Z: " << aPnt3.Z() << std::endl;
myResult << "A coordinate of a point 4: X: " << aPnt4.X() << " Y: " << aPnt4.Y() << " Z: " << aPnt4.Z() << std::endl;
if (anIsEqual2_3)
{
myResult << "A point 2 is equal to a point 3" << std::endl;
}
else
{
myResult << "A point 2 is different from a point 3" << std::endl;
}
if (anIsEqual2_4)
{
myResult << "A point 2 is equal to a point 4" << std::endl;
}
else
{
myResult << "A point 2 is different from a point 4" << std::endl;
}
myResult << "A distance from a point 1 to a point 2 is: " << aDistance1_2 << std::endl;
myResult << "A distance from a point 2 to a point 4 is: " << aDistance2_4 << std::endl;
myResult << "A square distance from a point 1 to a point 2 is: " << aSquareDistance1_2 << std::endl;
myResult << "A square distance from a point 2 to a point 4 is: " << aSquareDistance2_4 << std::endl;
DisplayPnt(aPnt1, "1", Aspect_TOM_PLUS, 0.5);
DisplayPnt(aPnt2, "2 & 4", Aspect_TOM_PLUS, 0.5);
DisplayPnt(aPnt3, "3", Aspect_TOM_PLUS, 0.5);
DisplayPnt(aPnt4, "", Aspect_TOM_PLUS, 0.5);
}
void GeometrySamples::EllipseInfo3dSample()
{
gp_Elips anElips(gp_Ax2(gp_Pnt(), gp_Dir(1.0, 0.0, 0.0)), 20.0, 10.0);
Standard_Real anArea = anElips.Area();
// Returns the eccentricity of the ellipse between 0.0 and 1.0
// If f is the distance between the center of the ellipse and the Focus1 then
// the eccentricity e = f / MajorRadius. Returns 0 if MajorRadius = 0.
Standard_Real anEccentricity = anElips.Eccentricity();
// Returns the distance between the center of the ellipse and focus1 or focus2.
Standard_Real aFocal = anElips.Focal();
// Returns p = (1 - e * e) * MajorRadius where e is the eccentricity
// of the ellipse. Returns 0 if MajorRadius = 0.
Standard_Real aParameter = anElips.Parameter();
myResult << "Ellipse area = " << anArea << " square units" << std::endl;
myResult << "Eccentricity = " << anEccentricity;
myResult << "Focal distance = " << aFocal;
myResult << "Ellipse parameter = " << aParameter;
gp_Pnt aCenter = anElips.Location();
gp_Pnt aFocus1 = anElips.Focus1();
gp_Pnt aFocus2 = anElips.Focus2();
DisplayPnt(aCenter, "Center", Aspect_TOM_PLUS, 2.0);
DisplayPnt(aFocus1, "focus 1", Aspect_TOM_PLUS, 2.0);
DisplayPnt(aFocus2, "focus 2", Aspect_TOM_PLUS, 2.0);
Handle(Geom_Ellipse) aGeomEllipse = new Geom_Ellipse(anElips);
Handle(AdaptorCurve_AIS) anAisEllipce = new AdaptorCurve_AIS(aGeomEllipse);
myObject3d.Append(anAisEllipce);
}
void GeometrySamples::PointInfo2dSample()
{
gp_Pnt2d aPnt1;
gp_Pnt2d aPnt2(10.0, 10.0);
gp_Pnt2d aPnt3(10.0, -10.0);
gp_Pnt2d aPnt4(10.0, 10.0);
Standard_Boolean anIsEqual2_3 = aPnt2.IsEqual(aPnt3, 1E-6);
Standard_Boolean anIsEqual2_4 = aPnt2.IsEqual(aPnt4, 1E-6);
Standard_Real aDistance1_2 = aPnt1.Distance(aPnt2);
Standard_Real aDistance2_4 = aPnt2.Distance(aPnt4);
Standard_Real aSquareDistance1_2 = aPnt1.SquareDistance(aPnt2);
Standard_Real aSquareDistance2_4 = aPnt2.SquareDistance(aPnt4);
myResult << "A coordinate of a point 1: X: " << aPnt1.X() << " Y: " << aPnt1.Y() << std::endl;
myResult << "A coordinate of a point 2: X: " << aPnt2.X() << " Y: " << aPnt2.Y() << std::endl;
myResult << "A coordinate of a point 3: X: " << aPnt3.X() << " Y: " << aPnt3.Y() << std::endl;
myResult << "A coordinate of a point 4: X: " << aPnt4.X() << " Y: " << aPnt4.Y() << std::endl;
if (anIsEqual2_3)
{
myResult << "A point 2 is equal to a point 3" << std::endl;
}
else
{
myResult << "A point 2 is different from a point 3" << std::endl;
}
if (anIsEqual2_4)
{
myResult << "A point 2 is equal to a point 4" << std::endl;
}
else
{
myResult << "A point 2 is different from a point 4" << std::endl;
}
myResult << "A distance from a point 1 to a point 2 is: " << aDistance1_2 << std::endl;
myResult << "A distance from a point 2 to a point 4 is: " << aDistance2_4 << std::endl;
myResult << "A square distance from a point 1 to a point 2 is: " << aSquareDistance1_2 << std::endl;
myResult << "A square distance from a point 2 to a point 4 is: " << aSquareDistance2_4 << std::endl;
DisplayPnt(aPnt1, "1", Aspect_TOM_PLUS, 0.5);
DisplayPnt(aPnt2, "2 & 4", Aspect_TOM_PLUS, 0.5);
DisplayPnt(aPnt3, "3", Aspect_TOM_PLUS, 0.5);
DisplayPnt(aPnt4, "");
}
void GeometrySamples::CircleInfo2dSample()
{
gp_Circ2d aCirc(gp_Ax22d(gp_Pnt2d(10.0, 10.0), gp_Vec2d(1.0, 0.0)), 10.0);
gp_Pnt2d aPnt1(0.0, 10.0);
gp_Pnt2d aPnt2(10.0, 0.0);
gp_Pnt2d aPnt3(20.0, 20.0);
if (aCirc.Contains(aPnt1, 1E-6))
{
DisplayPnt(aPnt1, "1", Aspect_TOM_STAR, 3.0);
myResult << "A circle contains a point 1" << std::endl;
}
else
{
DisplayPnt(aPnt1, "1", Aspect_TOM_PLUS, 1.0);
myResult << "A circle does contain a point 1" << std::endl;
}
if (aCirc.Contains(aPnt2, 1E-6))
{
DisplayPnt(aPnt2, "2", Aspect_TOM_STAR, 1.0);
myResult << "A circle contains a point 2" << std::endl;
}
else
{
DisplayPnt(aPnt2, "2", Aspect_TOM_PLUS, 1.0);
myResult << "A circle does contain a point 2" << std::endl;
}
if (aCirc.Contains(aPnt3, 1E-6))
{
DisplayPnt(aPnt3, "3", Aspect_TOM_STAR, 1.0);
myResult << "A circle contains a point 3" << std::endl;
}
else
{
DisplayPnt(aPnt3, "3", Aspect_TOM_PLUS, 1.0);
myResult << "A circle does contain a point 3" << std::endl;
}
myResult << "Circle area = " << aCirc.Area() << "square units" << std::endl;
Handle(Geom2d_Circle) aGeomCircle = new Geom2d_Circle(aCirc);
Handle(AdaptorCurve2d_AIS) anAisCirc = new AdaptorCurve2d_AIS(aGeomCircle);
myObject2d.Append(anAisCirc);
}
void GeometrySamples::FreeStyleCurves3dSample()
{
// Define points.
gp_Pnt aPnt1(0.0, 0.0, 0.0);
gp_Pnt aPnt2(5.0, 5.0, 0.0);
gp_Pnt aPnt3(10.0, 5.0, 0.0);
gp_Pnt aPnt4(15.0, 0.0, 0.0);
// Add points to the curve poles array.
TColgp_Array1OfPnt aPoles(1, 4);
aPoles.SetValue(1, aPnt1);
aPoles.SetValue(2, aPnt2);
aPoles.SetValue(3, aPnt3);
aPoles.SetValue(4, aPnt4);
// Define BSpline weights.
TColStd_Array1OfReal aBSplineWeights(1, 4);
aBSplineWeights.SetValue(1, 1.0);
aBSplineWeights.SetValue(2, 0.5);
aBSplineWeights.SetValue(3, 0.5);
aBSplineWeights.SetValue(4, 1.0);
// Define knots.
TColStd_Array1OfReal aKnots(1, 2);
aKnots.SetValue(1, 0.0);
aKnots.SetValue(2, 1.0);
// Define multiplicities.
TColStd_Array1OfInteger aMults(1, 2);
aMults.SetValue(1, 4);
aMults.SetValue(2, 4);
// Define BSpline degree and periodicity.
Standard_Integer aDegree = 3;
Standard_Boolean aPeriodic = Standard_False;
// Create a BSpline curve.
Handle(Geom_BSplineCurve) aBSplineCurve = new Geom_BSplineCurve(
aPoles, aBSplineWeights, aKnots, aMults, aDegree, aPeriodic);
myResult << "Geom_BSplineCurve was created in red" << std::endl;
// Define Bezier weights.
TColStd_Array1OfReal aBezierWeights(1, 4);
aBezierWeights.SetValue(1, 0.5);
aBezierWeights.SetValue(2, 1.5);
aBezierWeights.SetValue(3, 1.5);
aBezierWeights.SetValue(4, 0.5);
// Create Bezier curve.
Handle(Geom_BezierCurve) aBezierCurve = new Geom_BezierCurve(aPoles, aBezierWeights);
myResult << "Geom_BezierCurve was created in green" << std::endl;
Handle(AIS_ColoredShape) anAisBSplineCurve = new AIS_ColoredShape(
BRepBuilderAPI_MakeEdge(aBSplineCurve).Shape());
Handle(AIS_ColoredShape) anAisBezierCurve = new AIS_ColoredShape(
BRepBuilderAPI_MakeEdge(aBezierCurve).Shape());
anAisBSplineCurve->SetColor(Quantity_Color(Quantity_NOC_RED));
anAisBezierCurve->SetColor(Quantity_Color(Quantity_NOC_GREEN));
myObject3d.Append(anAisBSplineCurve);
myObject3d.Append(anAisBezierCurve);
myObject3d.Append(new AIS_Point(new Geom_CartesianPoint(aPnt1)));
myObject3d.Append(new AIS_Point(new Geom_CartesianPoint(aPnt2)));
myObject3d.Append(new AIS_Point(new Geom_CartesianPoint(aPnt3)));
myObject3d.Append(new AIS_Point(new Geom_CartesianPoint(aPnt4)));
}
void GeometrySamples::AnalyticalSurfaces3dSample()
{
// Define a XY plane.
gp_Pln aPln(gp::Origin(), gp::DZ());
// Create plane geometry.
Handle(Geom_Plane) aPlaneSurf = new Geom_Plane(aPln);
myResult << "Geom_Plane was created in red" << std::endl;
// Define a cylinder.
gp_Cylinder aCyl(gp::XOY(), 2.5);
// Create cylindrical surface.
Handle(Geom_CylindricalSurface) aCylSurf = new Geom_CylindricalSurface(aCyl);
myResult << "Geom_CylindricalSurface was created in green" << std::endl;
// Define a cone.
gp_Cone aCone(gp::XOY(), M_PI_4, 2.5);
// Create conical surface.
Handle(Geom_ConicalSurface) aConeSurf = new Geom_ConicalSurface(aCone);
myResult << "Geom_ConicalSurface was created in blue" << std::endl;
// Define a sphere.
gp_Pnt aSphereCenter(15.0, 15.0, 15.0);
gp_Sphere aSphere(gp_Ax3(aSphereCenter, gp::DZ()), 8.0);
// Create conical surface.
Handle(Geom_SphericalSurface) aSphereSurf = new Geom_SphericalSurface(aSphere);
myResult << "Geom_SphericalSurface was created in cyan" << std::endl;
// Define a sphere.
gp_Pnt aTorusCenter(-15.0, -15.0, 25.0);
gp_Torus aTorus(gp_Ax3(aTorusCenter, gp::DZ()), 15.0, 5.0);
// Create toroidal surface.
Handle(Geom_ToroidalSurface) aTorusSurf = new Geom_ToroidalSurface(aTorus);
myResult << "Geom_ToroidalSurface was created in yellow" << std::endl;
Handle(AIS_ColoredShape) anAisPlane = new AIS_ColoredShape(BRepBuilderAPI_MakeFace(
aPlaneSurf, 0.0, 20.0, 0.0, 20.0, Precision::Confusion()).Shape());
Handle(AIS_ColoredShape) anAisCylinder = new AIS_ColoredShape(BRepBuilderAPI_MakeFace(
aCylSurf, 0.0, 2.0 * M_PI, 5.0, 15.0, Precision::Confusion()).Shape());
Handle(AIS_ColoredShape) anAisCone = new AIS_ColoredShape(BRepBuilderAPI_MakeFace(
aConeSurf, 0.0, 2.0 * M_PI, 0.0, 15.0, Precision::Confusion()).Shape());
Handle(AIS_ColoredShape) anAisSphere = new AIS_ColoredShape(BRepBuilderAPI_MakeFace(
aSphereSurf, Precision::Confusion()).Shape());
Handle(AIS_ColoredShape) anAisTorus = new AIS_ColoredShape(BRepBuilderAPI_MakeFace(
aTorusSurf, Precision::Confusion()).Shape());
anAisPlane->SetColor(Quantity_Color(Quantity_NOC_RED));
anAisCylinder->SetColor(Quantity_Color(Quantity_NOC_GREEN));
anAisCone->SetColor(Quantity_Color(Quantity_NOC_BLUE1));
anAisSphere->SetColor(Quantity_Color(Quantity_NOC_CYAN1));
anAisTorus->SetColor(Quantity_Color(Quantity_NOC_YELLOW));
myObject3d.Append(anAisPlane);
myObject3d.Append(anAisCylinder);
myObject3d.Append(anAisCone);
myObject3d.Append(anAisSphere);
myObject3d.Append(anAisTorus);
}
void GeometrySamples::FreeStyleSurfaces3dSample()
{
// Define a 4x4 grid of points for BSpline surface.
TColgp_Array2OfPnt aBSplinePnts(1, 4, 1, 4);
for (Standard_Integer i = 1; i <= 4; ++i)
{
gp_Pnt aPnt;
aPnt.SetX(5.0 * i);
for (Standard_Integer j = 1; j <= 4; ++j)
{
aPnt.SetY(5.0 * j);
if (1 < i && i < 4 && 1 < j && j < 4)
{
aPnt.SetZ(5.0);
}
else
{
aPnt.SetZ(0.0);
}
aBSplinePnts.SetValue(i, j, aPnt);
}
}
// Define a 4x4 grid of points for Bezier surface.
TColgp_Array2OfPnt aBezierPnts(1, 4, 1, 4);
for (Standard_Integer i = 1; i <= 4; ++i)
{
gp_Pnt aPnt;
aPnt.SetX(20.0 + 5.0 * i);
for (Standard_Integer j = 1; j <= 4; ++j)
{
aPnt.SetY(20.0 + 5.0 * j);
if (1 < i && i < 4 && 1 < j && j < 4)
{
aPnt.SetZ(5.0);
}
else
{
aPnt.SetZ(0.0);
}
aBezierPnts.SetValue(i, j, aPnt);
}
}
// Define BSpline weights.
TColStd_Array2OfReal aBSplineWeights(1, 4, 1, 4);
for (Standard_Integer i = 1; i <= 4; ++i)
{
for (Standard_Integer j = 1; j <= 4; ++j)
{
if (1 < i && i < 4 && 1 < j && j < 4)
{
aBSplineWeights.SetValue(i, j, 0.5);
}
else
{
aBSplineWeights.SetValue(i, j, 1.0);
}
}
}
// Define knots.
TColStd_Array1OfReal aUKnots(1, 2), aVKnots(1, 2);
aUKnots.SetValue(1, 0.0);
aUKnots.SetValue(2, 1.0);
aVKnots.SetValue(1, 0.0);
aVKnots.SetValue(2, 1.0);
// Define multiplicities.
TColStd_Array1OfInteger aUMults(1, 2), aVMults(1, 2);
aUMults.SetValue(1, 4);
aUMults.SetValue(2, 4);
aVMults.SetValue(1, 4);
aVMults.SetValue(2, 4);
// Define BSpline degree and periodicity.
Standard_Integer aUDegree = 3;
Standard_Integer aVDegree = 3;
Standard_Boolean aUPeriodic = Standard_False;
Standard_Boolean aVPeriodic = Standard_False;
// Create a BSpline surface.
Handle(Geom_BSplineSurface) aBSplineSurf = new Geom_BSplineSurface(
aBSplinePnts, aBSplineWeights, aUKnots, aVKnots,
aUMults, aVMults, aUDegree, aVDegree, aUPeriodic, aVPeriodic);
myResult << "Geom_BSplineSurface was created in red" << std::endl;
// Define BSpline weights.
TColStd_Array2OfReal aBezierWeights(1, 4, 1, 4);
for (Standard_Integer i = 1; i <= 4; ++i)
{
for (Standard_Integer j = 1; j <= 4; ++j)
{
if (1 < i && i < 4 && 1 < j && j < 4)
{
aBezierWeights.SetValue(i, j, 1.5);
}
else
{
aBezierWeights.SetValue(i, j, 0.5);
}
}
}
// Create a Bezier surface.
Handle(Geom_BezierSurface) aBezierSurf = new Geom_BezierSurface(aBezierPnts, aBezierWeights);
myResult << "Geom_BezierSurface was created in green" << std::endl;
Handle(AIS_ColoredShape) anAisBSplineSurf = new AIS_ColoredShape(
BRepBuilderAPI_MakeFace(aBSplineSurf, Precision::Confusion()).Shape());
Handle(AIS_ColoredShape) anAisBezierSurf = new AIS_ColoredShape(
BRepBuilderAPI_MakeFace(aBezierSurf, Precision::Confusion()).Shape());
anAisBSplineSurf->SetColor(Quantity_Color(Quantity_NOC_RED));
anAisBezierSurf->SetColor(Quantity_Color(Quantity_NOC_GREEN));
myObject3d.Append(anAisBSplineSurf);
myObject3d.Append(anAisBezierSurf);
for (TColgp_Array2OfPnt::Iterator anIt(aBSplinePnts); anIt.More(); anIt.Next())
{
myObject3d.Append(new AIS_Point(new Geom_CartesianPoint(anIt.Value())));
}
for (TColgp_Array2OfPnt::Iterator anIt(aBezierPnts); anIt.More(); anIt.Next())
{
myObject3d.Append(new AIS_Point(new Geom_CartesianPoint(anIt.Value())));
}
}
void GeometrySamples::FreeStyleCurves2dSample()
{
// Define points.
gp_Pnt2d aPnt1(0.0, 0.0);
gp_Pnt2d aPnt2(5.0, 5.0);
gp_Pnt2d aPnt3(10.0, 5.0);
gp_Pnt2d aPnt4(15.0, 0.0);
// Add points to the curve poles array.
TColgp_Array1OfPnt2d aBSplinePoles(1, 4);
aBSplinePoles.SetValue(1, aPnt1);
aBSplinePoles.SetValue(2, aPnt2);
aBSplinePoles.SetValue(3, aPnt3);
aBSplinePoles.SetValue(4, aPnt4);
// Define BSpline weights.
TColStd_Array1OfReal aBSplineWeights(1, 4);
aBSplineWeights.SetValue(1, 1.0);
aBSplineWeights.SetValue(2, 0.5);
aBSplineWeights.SetValue(3, 0.5);
aBSplineWeights.SetValue(4, 1.0);
// Define knots.
TColStd_Array1OfReal aKnots(1, 2);
aKnots.SetValue(1, 0.0);
aKnots.SetValue(2, 1.0);
// Define multiplicities.
TColStd_Array1OfInteger aMults(1, 2);
aMults.SetValue(1, 4);
aMults.SetValue(2, 4);
// Define BSpline degree and periodicity.
Standard_Integer aDegree = 3;
Standard_Boolean aPeriodic = Standard_False;
// Create a BSpline curve.
Handle(Geom2d_BSplineCurve) aBSplineCurve =
new Geom2d_BSplineCurve(aBSplinePoles, aBSplineWeights, aKnots, aMults, aDegree, aPeriodic);
TColgp_Array1OfPnt2d aBezierPoles(1, 4);
gp_Vec2d anUp10Vec(0.0, 10.0);
aBezierPoles.SetValue(1, aPnt1.Translated(anUp10Vec));
aBezierPoles.SetValue(2, aPnt2.Translated(anUp10Vec));
aBezierPoles.SetValue(3, aPnt3.Translated(anUp10Vec));
aBezierPoles.SetValue(4, aPnt4.Translated(anUp10Vec));
// Define Bezier weights.
TColStd_Array1OfReal aBezierWeights(1, 4);
aBezierWeights.SetValue(1, 0.5);
aBezierWeights.SetValue(2, 1.5);
aBezierWeights.SetValue(3, 1.5);
aBezierWeights.SetValue(4, 0.5);
// Create Bezier curve.
Handle(Geom2d_BezierCurve) aBezierCurve = new Geom2d_BezierCurve(aBezierPoles, aBezierWeights);
Handle(AdaptorCurve2d_AIS) anAisBSpline = new AdaptorCurve2d_AIS(aBSplineCurve);
myObject2d.Append(anAisBSpline);
Handle(AdaptorCurve2d_AIS) anAisBezier = new AdaptorCurve2d_AIS(aBezierCurve);
myObject2d.Append(anAisBezier);
DisplayPnt(aPnt1, "1", Aspect_TOM_PLUS, 0.5);
DisplayPnt(aPnt2, "2", Aspect_TOM_PLUS, 0.5);
DisplayPnt(aPnt3, "3", Aspect_TOM_PLUS, 0.5);
DisplayPnt(aPnt4, "4", Aspect_TOM_PLUS, 0.5);
}
void GeometrySamples::TrimmedCurve3dSample()
{
// Define a circle placed in the origin of XY coordinate
// plane and with the radius equal to 5.
gp_Circ aCirc(gp::XOY(), 5.0);
// Create a closed circular curve.
Handle(Geom_Circle) aCircCurve = new Geom_Circle(aCirc);
myResult << "Geom_Circle was created in yellow" << std::endl;
// Cut off a quarter of the circle.
Handle(Geom_TrimmedCurve) aCircQuater = new Geom_TrimmedCurve(aCircCurve, 0.0, M_PI_2);
myResult << "Geom_TrimmedCurve was created in red" << std::endl;
Handle(AIS_ColoredShape) anAisCirc = new AIS_ColoredShape (BRepBuilderAPI_MakeEdge(aCircCurve).Shape());
Handle(AIS_ColoredShape) anAisCircQuater = new AIS_ColoredShape (BRepBuilderAPI_MakeEdge(aCircQuater).Shape());
anAisCirc->SetColor(Quantity_Color(Quantity_NOC_YELLOW));
anAisCircQuater->SetColor(Quantity_Color(Quantity_NOC_RED));
anAisCircQuater->SetWidth(2.5);
myObject3d.Append(anAisCirc);
myObject3d.Append(anAisCircQuater);
}
void GeometrySamples::OffsetCurve3dSample()
{
// Define a circle placed in the origin of XY coordinate
// plane and with the radius equal to 5.
gp_Circ aCirc(gp::XOY(), 5.0);
// Create a closed circular curve.
Handle(Geom_Circle) aCircCurve = new Geom_Circle(aCirc);
myResult << "Geom_Circle was created in yellow" << std::endl;
// An offset curve is a curve at constant distance (Offset) from
// a basis curve in a reference direction V.
// The offset curve takes its parametrization from the basis curve.
// The Offset curve is in the direction of the normal N
// defined with the cross product T^V, where the vector T
// is given by the first derivative on the basis curve with non zero length.
// The distance offset may be positive or negative to indicate the
// preferred side of the curve:
// . distance offset >0 => the curve is in the direction of N
// . distance offset <0 => the curve is in the direction of - N
// On the Offset curve:
// Value (U) = BasisCurve.Value(U) + (Offset * (T ^ V)) / ||T ^ V||
// At any point the Offset direction V must not be parallel to the
// vector T and the vector T must not have null length else the
// offset curve is not defined.
// Expand the circle by Offset equal to a quarter of the radius
// with direction V equal to Z.
Standard_Real anExpandOffset = +aCirc.Radius() / 4.0;
gp_Dir anExpandDir = gp::DZ();
Handle(Geom_OffsetCurve) anExpandCircCurve = new Geom_OffsetCurve(
aCircCurve, anExpandOffset, anExpandDir);
myResult << "Geom_OffsetCurve (expanded circle) was created in red" << std::endl;
// Collapse the circle by Offset equal to a half of the radius with direction V equal to Z.
Standard_Real anCollapseOffset = -aCirc.Radius() / 2.0;
gp_Dir anCollapseDir = gp::DZ();
Handle(Geom_OffsetCurve) anCollapseCircCurve = new Geom_OffsetCurve (aCircCurve, anCollapseOffset, anCollapseDir);
myResult << "Geom_OffsetCurve (collapsed circle) was created in green" << std::endl;
Handle(AIS_ColoredShape) anAisCirc = new AIS_ColoredShape (BRepBuilderAPI_MakeEdge(aCircCurve).Shape());
Handle(AIS_ColoredShape) anAisExpandCirc = new AIS_ColoredShape (BRepBuilderAPI_MakeEdge(anExpandCircCurve).Shape());
Handle(AIS_ColoredShape) anAisCpllapsedCirc = new AIS_ColoredShape (BRepBuilderAPI_MakeEdge(anCollapseCircCurve).Shape());
anAisCirc->SetColor(Quantity_Color(Quantity_NOC_YELLOW));
anAisExpandCirc->SetColor(Quantity_Color(Quantity_NOC_RED));
anAisCpllapsedCirc->SetColor(Quantity_Color(Quantity_NOC_GREEN));
myObject3d.Append(anAisCirc);
myObject3d.Append(anAisExpandCirc);
myObject3d.Append(anAisCpllapsedCirc);
}
void GeometrySamples::BSplineFromCircle3dSample()
{
// Define a circle placed in the origin of XY coordinate
// plane and with the radius equal to 5.
gp_Circ aCirc(gp::XOY(), 5.0);
// Create a closed circular curve.
Handle(Geom_Circle) aCircCurve = new Geom_Circle(aCirc);
myResult << "Geom_Circle was created in yellow" << std::endl;
// Convert the circle curve to a BSpline one.
Handle(Geom_BSplineCurve) aBSplineFromCirc = GeomConvert::CurveToBSplineCurve(aCircCurve);
myResult << "Geom_BSplineCurve was created in red:" << std::endl;
myResult << "Degree: " << aBSplineFromCirc->Degree() << std::endl;
myResult << "Periodic: " << (aBSplineFromCirc->IsPeriodic() ? "Yes" : "No") << std::endl;
myResult << "Poles: [" << aBSplineFromCirc->Poles().Size() << "]" << std::endl;
for (TColgp_Array1OfPnt::Iterator anIt(aBSplineFromCirc->Poles()); anIt.More(); anIt.Next())
{
myResult << " (" << anIt.Value().X() << ", " << anIt.Value().Y() << ", " << anIt.Value().Z() << ")" << std::endl;
}
Handle(AIS_ColoredShape) anAisCirc = new AIS_ColoredShape (BRepBuilderAPI_MakeEdge(aCircCurve).Shape());
Handle(AIS_ColoredShape) anAisBSpline = new AIS_ColoredShape (BRepBuilderAPI_MakeEdge(aBSplineFromCirc).Shape());
anAisCirc->SetColor(Quantity_Color(Quantity_NOC_YELLOW));
anAisBSpline->SetColor(Quantity_Color(Quantity_NOC_RED));
myObject3d.Append(anAisCirc);
myObject3d.Append(anAisBSpline);
}
void GeometrySamples::TrimmedSurface3dSample()
{
// Define a XY plane.
gp_Pln aPln(gp::XOY());
// Create a plane surface.
Handle(Geom_Plane) aPlaneSurf = new Geom_Plane(aPln);
myResult << "Geom_Plane was created" << std::endl;
// Trim [0 ... 30 X 0 ... 50] rectangular range.
Standard_Real aUMin = 0.0;
Standard_Real aUMax = 30.0;
Standard_Real aVMin = 0.0;
Standard_Real aVMax = 50.0;
Handle(Geom_RectangularTrimmedSurface) aTrimmedPlaneSurf
= new Geom_RectangularTrimmedSurface(aPlaneSurf, aUMin, aUMax, aVMin, aVMax);
myResult << "Geom_RectangularTrimmedSurface was created in red" << std::endl;
Handle(AIS_Plane) anAisPlane = new AIS_Plane(aPlaneSurf);
Handle(AIS_ColoredShape) anAisTimmedPlane = new AIS_ColoredShape (BRepBuilderAPI_MakeFace (aTrimmedPlaneSurf, 0.001).Shape());
anAisTimmedPlane->SetColor(Quantity_Color(Quantity_NOC_RED));
myObject3d.Append(anAisPlane);
myObject3d.Append(anAisTimmedPlane);
}
void GeometrySamples::OffsetSurface3dSample()
{
// Define a XY plane.
gp_Pln aPln(gp::XOY());
// Create a plane surface.
Handle(Geom_Plane) aPlaneSurf = new Geom_Plane(aPln);
myResult << "Geom_Plane was created" << std::endl;
// An offset surface is defined by:
// - the basis surface to which it is parallel, and
// - the distance between the offset surface and its basis surface.
// A point on the offset surface is built by measuring the
// offset value along the normal vector at a point on the
// basis surface. This normal vector is given by the cross
// product D1u^D1v, where D1u and D1v are the
// vectors tangential to the basis surface in the u and v
// parametric directions at this point. The side of the
// basis surface on which the offset is measured
// depends on the sign of the offset value.
// Offset the plane in the normal direction.
Standard_Real aPosOffset = 10.0;
Handle(Geom_OffsetSurface) aPosOffsetSurf = new Geom_OffsetSurface(aPlaneSurf, aPosOffset);
myResult << "Geom_OffsetSurface with " << aPosOffset << " was created in red" << std::endl;
// Offset the plane in direction opposite to the normal one.
Standard_Real aNegOffset = -15.0;
Handle(Geom_OffsetSurface) aNegOffsetSurf = new Geom_OffsetSurface(aPlaneSurf, aNegOffset);
myResult << "Geom_OffsetSurface with " << aNegOffset << " was created in green" << std::endl;
Handle(AIS_ColoredShape) anAisPlane = new AIS_ColoredShape(
BRepBuilderAPI_MakeFace(aPlaneSurf, 0.0, 10.0, 0.0, 10.0, Precision::Confusion()).Shape());
Handle(AIS_ColoredShape) anAisPosOffsetPlane = new AIS_ColoredShape(
BRepBuilderAPI_MakeFace(aPosOffsetSurf, 0.0, 10.0, 0.0, 10.0, Precision::Confusion()).Shape());
Handle(AIS_ColoredShape) anAisNegOffsetPlane = new AIS_ColoredShape(
BRepBuilderAPI_MakeFace(aNegOffsetSurf, 0.0, 10.0, 0.0, 10.0, Precision::Confusion()).Shape());
anAisPosOffsetPlane->SetColor(Quantity_Color(Quantity_NOC_RED));
anAisNegOffsetPlane->SetColor(Quantity_Color(Quantity_NOC_GREEN));
myObject3d.Append(anAisPlane);
myObject3d.Append(anAisPosOffsetPlane);
myObject3d.Append(anAisNegOffsetPlane);
}
void GeometrySamples::ExtrusionSurface3dSample()
{
// Create an ellipse curve in XY plane.
Standard_Real aMinorRadius = 10.0;
Standard_Real aMajorRadius = 20.0;
Handle(Geom_Ellipse) anEllipseCurve = new Geom_Ellipse(gp::XOY(), aMajorRadius, aMinorRadius);
myResult << "Geom_Ellipse was created in yellow" << std::endl;
// Make a linear extrusion of the ellipse at 45 degrees to Z axis
gp_Dir aDirOfExtr = gp::DZ();
Handle(Geom_SurfaceOfLinearExtrusion) aLinExtrSurf
= new Geom_SurfaceOfLinearExtrusion(anEllipseCurve, aDirOfExtr);
myResult << "Geom_SurfaceOfLinearExtrusion was created in red" << std::endl;
Handle(AIS_ColoredShape) anAisEllipse = new AIS_ColoredShape(
BRepBuilderAPI_MakeEdge(anEllipseCurve).Shape());
Handle(AIS_ColoredShape) anAisExtrSurf = new AIS_ColoredShape(
BRepBuilderAPI_MakeFace(aLinExtrSurf, 0.0, 2.0 * M_PI, 0.0, 30.0,
Precision::Confusion()).Shape());
anAisEllipse->SetColor(Quantity_Color(Quantity_NOC_YELLOW));
anAisEllipse->SetWidth(2.5);
anAisExtrSurf->SetColor(Quantity_Color(Quantity_NOC_RED));
myObject3d.Append(anAisEllipse);
myObject3d.Append(anAisExtrSurf);
}
void GeometrySamples::RevolutionSurface3dSample()
{
// Create an ellipse curve in XY plane with
// the center at (-10, 0, 0).
Standard_Real aMinorRadius = 5.0;
Standard_Real aMajorRadius = 10.0;
gp_Pnt aCenter(-30.0, 0.0, 0.0);
Handle(Geom_Ellipse) anEllipseCurve = new Geom_Ellipse(gp_Ax2(aCenter, gp::DZ()),
aMajorRadius, aMinorRadius);
myResult << "Geom_Ellipse was created in yellow" << std::endl;
// Make a revolution of the ellipse around Y axis
Handle(Geom_SurfaceOfRevolution) aRevolSurf = new Geom_SurfaceOfRevolution(anEllipseCurve, gp::OY());
myResult << "Geom_SurfaceOfRevolution was created in red" << std::endl;
Handle(AIS_ColoredShape) anAisEllipse = new AIS_ColoredShape(
BRepBuilderAPI_MakeEdge(anEllipseCurve).Shape());
Handle(AIS_ColoredShape) anAisRevolSurf = new AIS_ColoredShape(
BRepBuilderAPI_MakeFace(aRevolSurf, Precision::Confusion()).Shape());
anAisEllipse->SetColor(Quantity_Color(Quantity_NOC_YELLOW));
anAisEllipse->SetWidth(2.5);
anAisRevolSurf->SetColor(Quantity_Color(Quantity_NOC_RED));
myObject3d.Append(anAisEllipse);
myObject3d.Append(anAisRevolSurf);
}
void GeometrySamples::TrimmedCurve2dSample()
{
// Create a closed circular curve.
Handle(Geom2d_Circle) aGeomCircle = new Geom2d_Circle(gp_Ax2d(gp_Pnt2d(), gp_Vec2d(1.0, 0.0)), 5.0);
Handle(AdaptorCurve2d_AIS) anAisCirc = new AdaptorCurve2d_AIS(aGeomCircle);
myObject2d.Append(anAisCirc);
// Cut off a quarter of the circle.
Handle(Geom2d_TrimmedCurve) aCircQuater = new Geom2d_TrimmedCurve(aGeomCircle, 0.0, M_PI_2);
aCircQuater->Translate(gp_Vec2d(15.0, 0.0));
Handle(AdaptorCurve2d_AIS) anAisCircQuater = new AdaptorCurve2d_AIS(aCircQuater);
myObject2d.Append(anAisCircQuater);
}
void GeometrySamples::OffsetCurve2dSample()
{
Handle(Geom2d_Circle) aGeomCircle = new Geom2d_Circle(gp_Ax2d(gp_Pnt2d(), gp_Vec2d(1.0, 0.0)), 5.0);
Standard_Real anExpandOffset = aGeomCircle->Radius() / 4.0;
Handle(Geom2d_OffsetCurve) anExpandCircCurve = new Geom2d_OffsetCurve(aGeomCircle, anExpandOffset);
Standard_Real anCollapseOffset = -aGeomCircle->Radius() / 2.0;
Handle(Geom2d_OffsetCurve) anCollapseCircCurve = new Geom2d_OffsetCurve(aGeomCircle, anCollapseOffset);
Handle(AdaptorCurve2d_AIS) anAisCirc = new AdaptorCurve2d_AIS(aGeomCircle);
myObject2d.Append(anAisCirc);
Handle(AdaptorCurve2d_AIS) anAisExpand = new AdaptorCurve2d_AIS(anExpandCircCurve);
myObject2d.Append(anAisExpand);
Handle(AdaptorCurve2d_AIS) anAisCollapse = new AdaptorCurve2d_AIS(anCollapseCircCurve);
myObject2d.Append(anAisCollapse);
}
void GeometrySamples::BoundingBoxOfSurface3dSample()
{
// Define a 4x4 grid of points for BSpline surface.
TColgp_Array2OfPnt aPoints(1, 4, 1, 4);
for (Standard_Integer i = 1; i <= 4; ++i)
{
gp_Pnt aPnt;
aPnt.SetX(5.0 * i);
for (Standard_Integer j = 1; j <= 4; ++j)
{
aPnt.SetY(5.0 * j);
if (1 < i && i < 4 && 1 < j && j < 4)
{
aPnt.SetZ(5.0);
}
else
{
aPnt.SetZ(0.0);
}
aPoints.SetValue(i, j, aPnt);
}
}
// Make a BSpline surface from the points array.
Handle(Geom_BSplineSurface) aBSplineSurf = GeomAPI_PointsToBSplineSurface(aPoints).Surface();
myResult << "Geom_BSplineSurface was created" << std::endl;
// Compute BSpline surface bounding box.
Bnd_Box aBndBox;
BndLib_AddSurface::AddOptimal(GeomAdaptor_Surface(aBSplineSurf), Precision::Confusion(), aBndBox);
myResult << "Bounding box:" << std::endl;
myResult << " Min corner = [ "
<< aBndBox.CornerMin().X() << ", "
<< aBndBox.CornerMin().Y() << ", "
<< aBndBox.CornerMin().Z() << " ]" << std::endl;
myResult << " Max corner = [ "
<< aBndBox.CornerMax().X() << ", "
<< aBndBox.CornerMax().Y() << ", "
<< aBndBox.CornerMax().Z() << " ]" << std::endl;
Handle(AIS_ColoredShape) anAisBSplineSurf = new AIS_ColoredShape(
BRepBuilderAPI_MakeFace(aBSplineSurf, Precision::Confusion()).Shape());
Handle(AIS_ColoredShape) anAisBndBox = new AIS_ColoredShape(
BRepPrimAPI_MakeBox(aBndBox.CornerMin(), aBndBox.CornerMax()).Shell());
myObject3d.Append(anAisBSplineSurf);
myObject3d.Append(anAisBndBox);
myContext->SetDisplayMode(anAisBndBox, 0, Standard_True);
}
void GeometrySamples::BoundingBoxOfCurves3dSample()
{
// Define points.
gp_Pnt aPnt1(0.0, 0.0, 10.0);
gp_Pnt aPnt2(5.0, 5.0, 5.0);
gp_Pnt aPnt3(10.0, 10.0, 15.0);
gp_Pnt aPnt4(15.0, 5.0, 20.0);
// Add points to the curve poles array.
TColgp_Array1OfPnt aPoles(1, 4);
aPoles.SetValue(1, aPnt1);
aPoles.SetValue(2, aPnt2);
aPoles.SetValue(3, aPnt3);
aPoles.SetValue(4, aPnt4);
// Make a BSpline curve from the points array.
Handle(Geom_BSplineCurve) aBSplineCurve = GeomAPI_PointsToBSpline(aPoles).Curve();
myResult << "aBSplineCurve was created" << std::endl;
// Compute BSpline curve bounding box.
Bnd_Box aBndBox;
BndLib_Add3dCurve::AddOptimal(GeomAdaptor_Curve(aBSplineCurve), Precision::Confusion(), aBndBox);
myResult << "Bounding box:" << std::endl;
myResult << " Min corner = [ "
<< aBndBox.CornerMin().X() << ", "
<< aBndBox.CornerMin().Y() << ", "
<< aBndBox.CornerMin().Z() << " ]" << std::endl;
myResult << " Max corner = [ "
<< aBndBox.CornerMax().X() << ", "
<< aBndBox.CornerMax().Y() << ", "
<< aBndBox.CornerMax().Z() << " ]" << std::endl;
Handle(AIS_ColoredShape) anAisBSplineCurve = new AIS_ColoredShape (BRepBuilderAPI_MakeEdge(aBSplineCurve).Shape());
Handle(AIS_ColoredShape) anAisBndBox = new AIS_ColoredShape (BRepPrimAPI_MakeBox(aBndBox.CornerMin(), aBndBox.CornerMax()).Shell());
myObject3d.Append(anAisBSplineCurve);
myObject3d.Append(anAisBndBox);
myContext->SetDisplayMode(anAisBndBox, 0, Standard_True);
}
void GeometrySamples::BoundingBoxOfCurves2dSample()
{
// Define points.
gp_Pnt2d aPnt1(0.0, 0.0);
gp_Pnt2d aPnt2(5.0, 5.0);
gp_Pnt2d aPnt3(10.0, 10.0);
gp_Pnt2d aPnt4(15.0, 5.0);
// Add points to the curve poles array.
TColgp_Array1OfPnt2d aPoles(1, 4);
aPoles.SetValue(1, aPnt1);
aPoles.SetValue(2, aPnt2);
aPoles.SetValue(3, aPnt3);
aPoles.SetValue(4, aPnt4);
// Make a BSpline curve from the points array.
Handle(Geom2d_BSplineCurve) aBSplineCurve = Geom2dAPI_PointsToBSpline(aPoles).Curve();
// Compute BSpline curve bounding box.
Bnd_Box2d aBndBox;
BndLib_Add2dCurve::AddOptimal(aBSplineCurve, 0.0, 1.0, Precision::PConfusion(), aBndBox);
Standard_Real aXmin, aYmin, aXmax, aYmax;
aBndBox.Get(aXmin, aYmin, aXmax, aYmax);
myResult << "Bounding box:" << std::endl;
myResult << " Min corner = [ " << aXmin << ", " << aYmin << " ]" << std::endl;
myResult << " Max corner = [ " << aXmax << ", " << aYmax << " ]" << std::endl;
Handle(AdaptorCurve2d_AIS) anAisBSpline = new AdaptorCurve2d_AIS(aBSplineCurve);
Handle(AdaptorVec_AIS) anAisVec1 = new AdaptorVec_AIS(gp_Pnt2d(aXmin, aYmin), gp_Pnt2d(aXmin, aYmax));
Handle(AdaptorVec_AIS) anAisVec2 = new AdaptorVec_AIS(gp_Pnt2d(aXmin, aYmax), gp_Pnt2d(aXmax, aYmax));
Handle(AdaptorVec_AIS) anAisVec3 = new AdaptorVec_AIS(gp_Pnt2d(aXmax, aYmax), gp_Pnt2d(aXmax, aYmin));
Handle(AdaptorVec_AIS) anAisVec4 = new AdaptorVec_AIS(gp_Pnt2d(aXmax, aYmin), gp_Pnt2d(aXmin, aYmin));
myObject2d.Append(anAisBSpline);
myObject2d.Append(anAisVec1);
myObject2d.Append(anAisVec2);
myObject2d.Append(anAisVec3);
myObject2d.Append(anAisVec4);
}
void GeometrySamples::DumpCircleInfoSample()
{
// Define a circle placed in the origin of XY coordinate
// plane and with the radius equal to 0.5.
gp_Circ aCirc(gp::XOY(), 0.5);
// Create a closed circular curve.
Handle(Geom_Circle) aCircCurve = new Geom_Circle(aCirc);
myResult << "Geom_Circle was created:" << std::endl;
myResult << " Center = [ "
<< aCircCurve->Position().Location().X() << ", "
<< aCircCurve->Position().Location().Y() << ", "
<< aCircCurve->Position().Location().Z() << " ]"
<< std::endl;
myResult << " Radius = " << aCircCurve->Radius() << std::endl;
myResult << " Plane normal = [ "
<< aCircCurve->Position().Direction().X() << ", "
<< aCircCurve->Position().Direction().Y() << ", "
<< aCircCurve->Position().Direction().Z() << " ]"
<< std::endl;
Handle(AIS_Circle) anAisCircle = new AIS_Circle(aCircCurve);
Handle(AIS_TextLabel) anAisCenterLabel = new AIS_TextLabel();
anAisCenterLabel->SetText(" Center");
anAisCenterLabel->SetPosition(aCircCurve->Position().Location());
Handle(AIS_Point) anAisCenter = new AIS_Point(new Geom_CartesianPoint(aCirc.Location()));
Handle(AIS_Axis) anAisAxis = new AIS_Axis(new Geom_Axis2Placement(aCircCurve->Position()), AIS_TOAX_ZAxis);
myObject3d.Append(anAisCircle);
myObject3d.Append(anAisCenterLabel);
myObject3d.Append(anAisAxis);
}
void GeometrySamples::DumpBSplineCurveInfoSample()
{
// Define points.
gp_Pnt aPnt1(0.0, 0.0, 10.0);
gp_Pnt aPnt2(5.0, 5.0, 5.0);
gp_Pnt aPnt3(10.0, 10.0, 15.0);
gp_Pnt aPnt4(15.0, 5.0, 20.0);
// Add points to the curve poles array.
TColgp_Array1OfPnt aPoles(1, 4);
aPoles.SetValue(1, aPnt1);
aPoles.SetValue(2, aPnt2);
aPoles.SetValue(3, aPnt3);
aPoles.SetValue(4, aPnt4);
// Make a BSpline curve from the points array
Handle(Geom_BSplineCurve) aBSplineCurve = GeomAPI_PointsToBSpline(aPoles).Curve();
myResult << "aBSplineCurve was created:" << std::endl;
myResult << " Degree = " << aBSplineCurve->Degree() << std::endl;
myResult << " Parameter range = [ "
<< aBSplineCurve->FirstParameter() << ", "
<< aBSplineCurve->LastParameter() << " ]"
<< std::endl;
NCollection_List<Standard_Real> aParams;
aParams.Append(0.75 * aBSplineCurve->FirstParameter() + 0.25 * aBSplineCurve->LastParameter());
aParams.Append(0.50 * aBSplineCurve->FirstParameter() + 0.50 * aBSplineCurve->LastParameter());
aParams.Append(0.25 * aBSplineCurve->FirstParameter() + 0.75 * aBSplineCurve->LastParameter());
myResult << " Curve info:" << std::endl;
for (NCollection_List<Standard_Real>::Iterator anIt(aParams); anIt.More(); anIt.Next())
{
Standard_Real aParam = anIt.Value();
gp_Pnt aPnt;
gp_Vec aVec;
aBSplineCurve->D1(aParam, aPnt, aVec);
myResult << " Param = " << aParam << std::endl;
myResult << " P = [ " << aPnt.X() << ", " << aPnt.Y() << ", " << aPnt.Z() << " ]" << std::endl;
myResult << " D = [ " << aVec.X() << ", " << aVec.Y() << ", " << aVec.Z() << " ]" << std::endl;
myObject3d.Append(new AIS_Point(new Geom_CartesianPoint(aPnt)));
Handle(AIS_TextLabel) anAisCenterLabel = new AIS_TextLabel();
Standard_SStream aSS;
aSS << "P [" << aPnt.X() << ", " << aPnt.Y() << ", " << aPnt.Z() << "]" << std::endl;
aSS << "D [" << aVec.X() << ", " << aVec.Y() << ", " << aVec.Z() << "]" << std::endl;
anAisCenterLabel->SetText(aSS.str().c_str());
anAisCenterLabel->SetPosition(aPnt);
myObject3d.Append(anAisCenterLabel);
Handle(AIS_Axis) anAisD = new AIS_Axis(new Geom_Axis1Placement(gp_Ax1(aPnt, aVec)));
myObject3d.Append(anAisD);
}
Handle(AIS_ColoredShape) anAisBSplineCurve = new AIS_ColoredShape (BRepBuilderAPI_MakeEdge(aBSplineCurve).Shape());
anAisBSplineCurve->SetColor(Quantity_Color(Quantity_NOC_RED));
myObject3d.Append(anAisBSplineCurve);
}
View Git Blame Copy Permalink