OCCT

// 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);
}