exploring/brepgeometry/main.cxx

Refer to the B-Rep Geometry Exploration Example.

base_explorer.hxx

// ****************************************************************************
// $Id$
//
// Copyright (C) 2008-2014, Roman Lygin. All rights reserved.
// Copyright (C) 2014-2023, CADEX. All rights reserved.
//
// This file is part of the CAD Exchanger software.
//
// You may use this file under the terms of the BSD license as follows:
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
// * Redistributions of source code must retain the above copyright notice,
//   this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above copyright notice,
//   this list of conditions and the following disclaimer in the documentation
//   and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
// ****************************************************************************
 
 
#ifndef _BaseExplorer_HeaderFile
#define _BaseExplorer_HeaderFile
 
#include <cadex/ModelData_Axis2Placement2d.hxx>
#include <cadex/ModelData_Curve2d.hxx>
#include <cadex/ModelData_Direction.hxx>
#include <cadex/ModelData_Direction2d.hxx>
#include <cadex/ModelData_Point.hxx>
#include <cadex/ModelData_Point2d.hxx>
#include <cadex/ModelData_ShapeOrientation.hxx>
#include <cadex/ModelData_Surface.hxx>
#include <cadex/ModelData_XY.hxx>
#include <cadex/ModelData_XYZ.hxx>
 
#include <functional>
#include <iostream>
 
using namespace std;
using namespace cadex;
 
class BaseExplorer
{
public:
 
    template <typename T>
    static void PrintElementary (const T& theGeometry)
    {
        PrintDomain (theGeometry);
        auto& aPosition = theGeometry.Position();
        const ModelData_Point&     aLoc =   aPosition.Location();
        const ModelData_Direction& anAxis = aPosition.Axis();
        const ModelData_Direction& aXDir =  aPosition.XDirection();
        const ModelData_Direction& aYDir =  aPosition.YDirection();
        PrintParameter ("Location",    aLoc.Coord());
        PrintParameter ("Axis",        anAxis.Coord());
        PrintParameter ("X Direction", aXDir.Coord());
        PrintParameter ("Y Direction", aYDir.Coord());
    }
 
    template <typename T>
    static void PrintElementary2d (const T& theGeometry)
    {
        PrintDomain (theGeometry);
        auto& aPosition = theGeometry.Position();
        const ModelData_Point2d&     aLoc =  aPosition.Location();
        const ModelData_Direction2d& aXDir = aPosition.XDirection();
        const ModelData_Direction2d& aYDir = aPosition.YDirection();
        PrintParameter ("Location",    aLoc.Coord());
        PrintParameter ("X Direction", aXDir.Coord());
        PrintParameter ("Y Direction", aYDir.Coord());
    }
 
    static void PrintRange (const char* aName, double aFirstParameter, double aLastParameter)
    {
        cout << aName << " = [" << aFirstParameter << ", " << aLastParameter << "]; ";
    }
 
    static void PrintDomain (const ModelData_Curve& theCurve)
    {
        PrintRange ("Domain", theCurve.UMin(), theCurve.UMax());
    }
    
    static void PrintDomain (const ModelData_Curve2d& theCurve)
    {
        PrintRange ("Domain", theCurve.UMin(), theCurve.UMax());
    }
 
    static void PrintDomain (const ModelData_Surface& theSurface)
    {
        PrintRange ("Domain U", theSurface.UMin(), theSurface.UMax());
        PrintRange ("V", theSurface.VMin(), theSurface.VMax());
    }
 
    static void PrintParameter (ModelData_XYZd thePoint)
    {
        cout << "(" << thePoint.X() << ", " << thePoint.Y() << ", " << thePoint.Z() << "); ";
    }
 
    static void PrintParameter (ModelData_XYd thePoint)
    {
        cout << "(" << thePoint.X() << ", " << thePoint.Y() << "); ";
    }
 
    static void PrintParameter (double theValue)
    {
        cout << theValue << "; ";
    }
 
    template <typename T>
    static void PrintParameter (const char* theName, T theValue)
    {
        cout << theName << " = ";
        PrintParameter (theValue);
    }
 
    static void PrintName (const char* theName)
    {
        cout << theName << ": ";
    }
 
    static void PrintCollection (const char* theName,
                                 int theFinalIndex,
                                 std::function <void (int)> thePrintElement)
    {
        if (theName) {
            cout << theName << " = ";
        }
 
        cout << "[";
        for (int i = 1; i <= theFinalIndex; ++i)
        {
            if (i > 3) {
                cout << "...";
                break;
            }
            thePrintElement(i);
        }
        cout << "]; ";
    }
 
    static void PrintCollection (const char* theName,
                                 int theFinalIndex1,
                                 int theFinalIndex2,
                                 std::function <void (int, int)> thePrintElement)
    {
        PrintCollection (theName, theFinalIndex1, [&](int i)
        {
            PrintCollection (nullptr, theFinalIndex2, [&](int j) {thePrintElement(i, j); });
        });
    }
 
    static void PrintOrientation (const ModelData_ShapeOrientation& theOrientation)
    {
        cout << "Orientation = ";
        switch (theOrientation) {
        case ModelData_SO_Forward:  cout << "Forward";  break;
        case ModelData_SO_Reversed: cout << "Reversed"; break;
        default:
            cout << "Undefined";
            break;
        }
        cout << "; ";
    }
 
    void PrintTabulation()
    {
        for (size_t i = 0; i < myNestingLevel; ++i) {
            cout << "--- ";
        }
    }
 
    size_t myNestingLevel = 0;
};
 
#endif

curve_explorer.hxx

// ****************************************************************************
// $Id$
//
// Copyright (C) 2008-2014, Roman Lygin. All rights reserved.
// Copyright (C) 2014-2023, CADEX. All rights reserved.
//
// This file is part of the CAD Exchanger software.
//
// You may use this file under the terms of the BSD license as follows:
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
// * Redistributions of source code must retain the above copyright notice,
//   this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above copyright notice,
//   this list of conditions and the following disclaimer in the documentation
//   and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
// ****************************************************************************
 
 
#ifndef _CurveExplorer_HeaderFile
#define _CurveExplorer_HeaderFile
 
#include <cadex/ModelData_Axis2Placement.hxx>
#include <cadex/ModelData_BezierCurve.hxx>
#include <cadex/ModelData_BSplineCurve.hxx>
#include <cadex/ModelData_Circle.hxx>
#include <cadex/ModelData_Ellipse.hxx>
#include <cadex/ModelData_Hyperbola.hxx>
#include <cadex/ModelData_Line.hxx>
#include <cadex/ModelData_OffsetCurve.hxx>
#include <cadex/ModelData_Parabola.hxx>
#include <cadex/ModelData_TrimmedCurve.hxx>
 
#include <base_explorer.hxx>
 
using namespace std;
using namespace cadex;
 
class CurveExplorer : public BaseExplorer
{
public:
    static void PrintCurveInfo (const ModelData_Curve& theCurve)
    {
        switch (theCurve.Type()) {
        case ModelData_CT_Line:
            PrintLine         (static_cast <const ModelData_Line&>         (theCurve));
            break;
        case ModelData_CT_Circle:
            PrintCircle       (static_cast <const ModelData_Circle&>       (theCurve));
            break;
        case ModelData_CT_Ellipse:
            PrintEllipse      (static_cast <const ModelData_Ellipse&>      (theCurve));
            break;
        case ModelData_CT_Hyperbola:
            PrintHyperbola    (static_cast <const ModelData_Hyperbola&>    (theCurve));
            break;
        case ModelData_CT_Parabola:
            PrintParabola     (static_cast <const ModelData_Parabola&>     (theCurve));
            break;
        case ModelData_CT_Bezier:
            PrintBezierCurve  (static_cast <const ModelData_BezierCurve&>  (theCurve));
            break;
        case ModelData_CT_BSpline:
            PrintBSplineCurve (static_cast <const ModelData_BSplineCurve&> (theCurve));
            break;
        case ModelData_CT_Offset:
            PrintOffsetCurve  (static_cast <const ModelData_OffsetCurve&>  (theCurve));
            break;
        case ModelData_CT_Trimmed:
            PrintTrimmedCurve (static_cast <const ModelData_TrimmedCurve&> (theCurve));
            break;
        default:
            break;
        }
    }
 
    static void PrintLine (const ModelData_Line& theLine)
    {
        PrintName ("Line");
        const ModelData_Point& aLoc =     theLine.Location();
        const ModelData_Direction& aDir = theLine.Direction();
        PrintDomain (theLine);
        PrintParameter ("Location",  aLoc.Coord());
        PrintParameter ("Direction", aDir.Coord());
    }
 
    static void PrintCircle (const ModelData_Circle& theCircle)
    {
        PrintName ("Circle");
        double aRadius = theCircle.Radius();
        PrintElementary (theCircle);
        PrintParameter ("Radius", aRadius);
    }
 
    static void PrintEllipse (const ModelData_Ellipse& theEllipse)
    {
        PrintName ("Ellipse");
        double aMajorRadius = theEllipse.MajorRadius();
        double aMinorRadius = theEllipse.MinorRadius();
        PrintElementary (theEllipse);
        PrintParameter ("Major Radius", aMajorRadius);
        PrintParameter ("Minor Radius", aMinorRadius);
    }
 
    static void PrintHyperbola (const ModelData_Hyperbola& theHyperbola)
    {
        PrintName ("Hyperbola");
        double aMajorRadius = theHyperbola.MajorRadius();
        double aMinorRadius = theHyperbola.MinorRadius();
        PrintElementary (theHyperbola);
        PrintParameter ("Major Radius", aMajorRadius);
        PrintParameter ("Minor Radius", aMinorRadius);
    }
 
    static void PrintParabola (const ModelData_Parabola& theParabola)
    {
        PrintName ("Parabola");
        double aFocal = theParabola.Focal();
        PrintElementary (theParabola);
        PrintParameter ("Focal", aFocal);
    }
 
    static void PrintBezierCurve (const ModelData_BezierCurve& theBezier)
    {
        PrintName ("Bezier Curve");
        int aDegree =        theBezier.Degree();
        int aNumberOfPoles = theBezier.NumberOfPoles();
        PrintDomain (theBezier);
        PrintParameter ("Degree",          aDegree);
        PrintParameter ("Number Of Poles", aNumberOfPoles);
 
        PrintCollection ("Poles", aNumberOfPoles, [&](int i)
        {
            auto aPole = theBezier.Pole (i);
            PrintParameter (aPole.Coord());
        });
 
        PrintCollection ("Weights", aNumberOfPoles, [&](int i)
        {
            double aWeight = theBezier.Weight (i);
            PrintParameter (aWeight);
        });
    }
 
    static void PrintBSplineCurve (const ModelData_BSplineCurve& theBSpline)
    {
        PrintName ("BSpline Curve");
        int aDegree =        theBSpline.Degree();
        int aNumberOfKnots = theBSpline.NumberOfKnots();
        int aNumberOfPoles = theBSpline.NumberOfPoles();
        PrintDomain (theBSpline);
        PrintParameter ("Degree",          aDegree);
        PrintParameter ("Number Of Knots", aNumberOfKnots);
        PrintParameter ("Number Of Poles", aNumberOfPoles);
 
        PrintCollection ("Knots", aNumberOfKnots, [&](int i)
        {
            double aKnot = theBSpline.Knot (i);
            PrintParameter (aKnot);
        });
 
        PrintCollection ("Multiplicities", aNumberOfKnots, [&](int i)
        {
            int aMultiplicity = theBSpline.Multiplicity (i);
            PrintParameter (aMultiplicity);
        });
 
        PrintCollection ("Poles", aNumberOfPoles, [&](int i)
        {
            auto aPole = theBSpline.Pole (i);
            PrintParameter (aPole.Coord());
        });
 
        PrintCollection ("Weights", aNumberOfPoles, [&](int i)
        {
            double aWeight = theBSpline.Weight (i);
            PrintParameter (aWeight);
        });
    }
 
    static void PrintOffsetCurve (const ModelData_OffsetCurve& theOffset)
    {
        PrintName ("Offset Curve");
        const ModelData_Direction& aDir = theOffset.Direction();
        double anOffset = theOffset.Offset();
        PrintDomain (theOffset);
        PrintParameter ("Direction", aDir.Coord());
        PrintParameter ("Offset",    anOffset);
        cout << "Basis Curve = ";
        PrintCurveInfo (theOffset.BasisCurve());
    }
 
    static void PrintTrimmedCurve (const ModelData_TrimmedCurve& theTrimmed)
    {
        PrintName ("Trimmed Curve");
        PrintDomain (theTrimmed);
        cout << "Basis Curve = ";
        PrintCurveInfo (theTrimmed.BasisCurve());
    }
};
#endif

pcurve_explorer.hxx

// ****************************************************************************
// $Id$
//
// Copyright (C) 2008-2014, Roman Lygin. All rights reserved.
// Copyright (C) 2014-2023, CADEX. All rights reserved.
//
// This file is part of the CAD Exchanger software.
//
// You may use this file under the terms of the BSD license as follows:
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
// * Redistributions of source code must retain the above copyright notice,
//   this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above copyright notice,
//   this list of conditions and the following disclaimer in the documentation
//   and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
// ****************************************************************************
 
 
#ifndef _PCurveExplorer_HeaderFile
#define _PCurveExplorer_HeaderFile
 
#include <base_explorer.hxx>
 
#include <cadex/ModelData_Axis2Placement.hxx>
#include <cadex/ModelData_BezierCurve2d.hxx>
#include <cadex/ModelData_BSplineCurve2d.hxx>
#include <cadex/ModelData_Circle2d.hxx>
#include <cadex/ModelData_Ellipse2d.hxx>
#include <cadex/ModelData_Hyperbola2d.hxx>
#include <cadex/ModelData_Line2d.hxx>
#include <cadex/ModelData_OffsetCurve2d.hxx>
#include <cadex/ModelData_Parabola2d.hxx>
#include <cadex/ModelData_TrimmedCurve2d.hxx>
 
 
using namespace std;
using namespace cadex;
 
class PCurveExplorer : public BaseExplorer
{
public:
    static void PrintPCurveInfo (const ModelData_Curve2d& theCurve)
    {
        switch (theCurve.Type()) {
            case ModelData_CT_Line:
            PrintLine         (static_cast <const ModelData_Line2d&>         (theCurve));
        break;
            case ModelData_CT_Circle:
            PrintCircle       (static_cast <const ModelData_Circle2d&>       (theCurve));
        break;
            case ModelData_CT_Ellipse:
            PrintEllipse      (static_cast <const ModelData_Ellipse2d&>      (theCurve));
        break;
        case ModelData_CT_Hyperbola:
            PrintHyperbola    (static_cast <const ModelData_Hyperbola2d&>    (theCurve));
            break;
        case ModelData_CT_Parabola:
            PrintParabola     (static_cast <const ModelData_Parabola2d&>     (theCurve));
            break;
        case ModelData_CT_Bezier:
            PrintBezierCurve  (static_cast <const ModelData_BezierCurve2d&>  (theCurve));
            break;
        case ModelData_CT_BSpline:
            PrintBSplineCurve (static_cast <const ModelData_BSplineCurve2d&> (theCurve));
            break;
        case ModelData_CT_Offset:
            PrintOffsetCurve  (static_cast <const ModelData_OffsetCurve2d&>  (theCurve));
            break;
        case ModelData_CT_Trimmed:
            PrintTrimmedCurve (static_cast <const ModelData_TrimmedCurve2d&> (theCurve));
            break;
        default:
            break;
        }
    }
 
    static void PrintLine (const ModelData_Line2d& theLine)
    {
        PrintName ("Line 2d");
        const ModelData_Point2d&     aLoc = theLine.Location();
        const ModelData_Direction2d& aDir = theLine.Direction();
        PrintDomain (theLine);
        PrintParameter ("Location",  aLoc.Coord());
        PrintParameter ("Direction", aDir.Coord());
    }
 
    static void PrintCircle (const ModelData_Circle2d& theCircle)
    {
        PrintName ("Circle 2d");
        double aRadius = theCircle.Radius();
        PrintElementary2d (theCircle);
        PrintParameter ("Radius", aRadius);
    }
 
    static void PrintEllipse (const ModelData_Ellipse2d& theEllipse)
    {
        PrintName ("Ellipse 2d");
        double aMajorRadius = theEllipse.MajorRadius();
        double aMinorRadius = theEllipse.MinorRadius();
        PrintElementary2d (theEllipse);
        PrintParameter ("Major Radius", aMajorRadius);
        PrintParameter ("Minor Radius", aMinorRadius);
    }
 
    static void PrintHyperbola (const ModelData_Hyperbola2d& theHyperbola)
    {
        PrintName ("Hyperbola 2d");
        double aMajorRadius = theHyperbola.MajorRadius();
        double aMinorRadius = theHyperbola.MinorRadius();
        PrintElementary2d (theHyperbola);
        PrintParameter ("Major Radius", aMajorRadius);
        PrintParameter ("Minor Radius", aMinorRadius);
    }
 
    static void PrintParabola (const ModelData_Parabola2d& theParabola)
    {
        PrintName ("Parabola 2d");
        double aFocal = theParabola.Focal();
        PrintElementary2d (theParabola);
        PrintParameter ("Focal", aFocal);
    }
 
    static void PrintBezierCurve (const ModelData_BezierCurve2d& theBezier)
    {
        PrintName ("Bezier Curve 2d");
        int aDegree =        theBezier.Degree();
        int aNumberOfPoles = theBezier.NumberOfPoles();
        PrintDomain (theBezier);
        PrintParameter ("Degree",          aDegree);
        PrintParameter ("Number Of Poles", aNumberOfPoles);
 
        PrintCollection ("Poles", aNumberOfPoles, [&](int i)
        {
            auto aPole = theBezier.Pole (i);
            PrintParameter (aPole.Coord());
        });
 
        PrintCollection ("Weights", aNumberOfPoles, [&](int i)
        {
            double aWeight = theBezier.Weight (i);
            PrintParameter (aWeight);
        });
    }
 
    static void PrintBSplineCurve (const ModelData_BSplineCurve2d& theBSpline)
    {
        PrintName ("BSpline Curve 2d");
        int aDegree =        theBSpline.Degree();
        int aNumberOfKnots = theBSpline.NumberOfKnots();
        int aNumberOfPoles = theBSpline.NumberOfPoles();
        PrintDomain (theBSpline);
        PrintParameter ("Degree",          aDegree);
        PrintParameter ("Number Of Knots", aNumberOfKnots);
        PrintParameter ("Number Of Poles", aNumberOfPoles);
 
        PrintCollection ("Knots", aNumberOfKnots, [&](int i)
        {
            double aKnot = theBSpline.Knot (i);
            PrintParameter (aKnot);
        });
 
        PrintCollection ("Multiplicities", aNumberOfKnots, [&](int i)
        {
            int aMultiplicity = theBSpline.Multiplicity (i);
            PrintParameter (aMultiplicity);
        });
 
        PrintCollection ("Poles", aNumberOfPoles, [&](int i)
        {
            auto aPole = theBSpline.Pole (i);
            PrintParameter (aPole.Coord());
        });
 
        PrintCollection ("Weights", aNumberOfPoles, [&](int i)
        {
            double aWeight = theBSpline.Weight (i);
            PrintParameter (aWeight);
        });
    }
 
    static void PrintOffsetCurve (const ModelData_OffsetCurve2d& theOffset)
    {
        PrintName ("Offset Curve 2d");
        double anOffset = theOffset.Offset();
        PrintDomain (theOffset);
        PrintParameter ("Offset", anOffset);
        cout << "Basis Curve = ";
        PrintPCurveInfo (theOffset.BasisCurve());
    }
 
    static void PrintTrimmedCurve (const ModelData_TrimmedCurve2d& theTrimmed)
    {
        PrintName ("Trimmed Curve 2d");
        PrintDomain (theTrimmed);
        cout << "Basis Curve = ";
        PrintPCurveInfo (theTrimmed.BasisCurve());
    }
};
 
#endif

shape_explorer.hxx

// ****************************************************************************
// $Id$
//
// Copyright (C) 2008-2014, Roman Lygin. All rights reserved.
// Copyright (C) 2014-2023, CADEX. All rights reserved.
//
// This file is part of the CAD Exchanger software.
//
// You may use this file under the terms of the BSD license as follows:
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
// * Redistributions of source code must retain the above copyright notice,
//   this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above copyright notice,
//   this list of conditions and the following disclaimer in the documentation
//   and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
// ****************************************************************************
 
 
#ifndef _ShapeExplorer_HeaderFile
#define _ShapeExplorer_HeaderFile
 
#include <curve_explorer.hxx>
#include <base_explorer.hxx>
#include <pcurve_explorer.hxx>
#include <surface_explorer.hxx>
 
#include <cadex/ModelData_Body.hxx>
#include <cadex/ModelData_BodyList.hxx>
#include <cadex/ModelData_BodyType.hxx>
#include <cadex/ModelData_BRepRepresentation.hxx>
#include <cadex/ModelData_Curve.hxx>
#include <cadex/ModelData_Curve2d.hxx>
#include <cadex/ModelData_Edge.hxx>
#include <cadex/ModelData_Face.hxx>
#include <cadex/ModelData_Model.hxx>
#include <cadex/ModelData_Part.hxx>
#include <cadex/ModelData_Shell.hxx>
#include <cadex/ModelData_Surface.hxx>
#include <cadex/ModelData_Vertex.hxx>
#include <cadex/ModelData_Wire.hxx>
 
#include <array>
#include <functional>
#include <iostream>
#include <unordered_map>
 
 
using namespace std;
using namespace cadex;
 
// Visits directly each part and calls B-Rep representation exploring if a part has one
class ShapeExplorer : public ModelData_Model::VoidElementVisitor, public BaseExplorer
{
protected:
 
    void operator() (const ModelData_Part& thePart) override
    {
        const ModelData_BRepRepresentation& aBRep = thePart.BRepRepresentation();
        if (aBRep) {
            cout << "Part = \"" << thePart.Name() << "\"" << endl;
            ExploreBRep (aBRep);
        }
    }
 
private:
 
    void ExploreBRep (const ModelData_BRepRepresentation& theBRep)
    {
        // Get() method retrieves bodies listed in B-Rep representation by calling data providers flushing
        // Flushing isn't an elementary process so it can take a significant time (seconds, minutes depending on a model structure)
        const ModelData_BodyList& aBodyList = theBRep.Get();
 
        // Iterate over bodies
        for (ModelData_BodyList::SizeType i = 0; i < aBodyList.Size(); ++i) {
            const ModelData_Body& aBody = aBodyList[i];
            cout << "Body " << i << ": " << BodyType (aBody) << endl;
 
            ExploreShape (aBody);
        }
    }
 
    // Recursive iterating over the Shape until reaching vertices
    void ExploreShape (const ModelData_Shape& theShape)
    {
        if (theShape.Type() == ModelData_ST_Face) {
            myCurrentFace = ModelData_Face::Cast (theShape);
        }
        ++myNestingLevel;
        ModelData_Shape::Iterator aShapeIt (theShape);
        while (aShapeIt.HasNext()) {
            const ModelData_Shape& aShape = aShapeIt.Next();
            PrintShape (aShape);
            ExploreShape (aShape);
        }
        if (theShape.Type() == ModelData_ST_Face) {
            myCurrentFace = ModelData_Face();
        }
        --myNestingLevel;
    }
 
    // Returns body type name
    const char* BodyType (const ModelData_Body& theBody)
    {
        switch (theBody.BodyType()) {
        case ModelData_BT_Solid:     return "Solid";
        case ModelData_BT_Sheet:     return "Sheet";
        case ModelData_BT_Wireframe: return "Wireframe";
        case ModelData_BT_Acorn:     return "Acorn";
        default:
        break;
        }
        return "Undefined";
    }
 
    // Returns shape type name and prints shape info in some cases
    void PrintShape (const ModelData_Shape& theShape)
    {
        PrintTabulation();
 
        switch (theShape.Type()) {
        case ModelData_ST_Solid:  cout << "Solid";                                 break;
        case ModelData_ST_Shell:  PrintShell  (ModelData_Shell::Cast  (theShape)); break;
        case ModelData_ST_Wire:   PrintWire   (ModelData_Wire::Cast   (theShape)); break;
        case ModelData_ST_Face:   PrintFace   (ModelData_Face::Cast   (theShape)); break;
        case ModelData_ST_Edge:   PrintEdge   (ModelData_Edge::Cast   (theShape)); break;
        case ModelData_ST_Vertex: PrintVertex (ModelData_Vertex::Cast (theShape)); break;
        default:
        cout << "Undefined"; break;
        }
 
        cout << endl;
    }
 
    void PrintShell (const ModelData_Shell& theWire)
    {
        PrintName ("Shell");
        ++myNestingLevel;
        PrintOrientation (theWire.Orientation());
        --myNestingLevel;
    }
 
    void PrintWire (const ModelData_Wire& theWire)
    {
        PrintName ("Wire");
        ++myNestingLevel;
        PrintOrientation (theWire.Orientation());
        --myNestingLevel;
    }
 
    void PrintFace (const ModelData_Face& theFace)
    {
        PrintName ("Face");
        ++myNestingLevel;
        PrintOrientation (theFace.Orientation());
        cout << endl;
        ModelData_Surface aSurface = theFace.Surface();
        PrintTabulation();
        cout << "Surface: ";
        SurfaceExplorer::PrintSurface (aSurface);
        --myNestingLevel;
    }
 
    void PrintEdge (const ModelData_Edge& theEdge)
    {
        PrintName ("Edge");
        ++myNestingLevel;
        if (theEdge.IsDegenerated()) {
            cout << "Degenerated: ";
        }
        PrintOrientation (theEdge.Orientation());
        PrintParameter ("Tolerance", theEdge.Tolerance());
 
        if (!theEdge.IsDegenerated()) {
            pair<double, double> aParameters;
            ModelData_Curve aCurve = theEdge.Curve (aParameters.first, aParameters.second);
            cout << endl;
            PrintTabulation();
            PrintName ("Curve");
            PrintRange ("Edge Range", aParameters.first, aParameters.second);
            CurveExplorer::PrintCurveInfo (aCurve);
        }
            
        if (myCurrentFace) {
            pair<double, double> aParameters2d;
            const ModelData_Curve2d& aPCurve = theEdge.PCurve (myCurrentFace,
                                                               aParameters2d.first, 
                                                               aParameters2d.second);
            cout << endl;
            PrintTabulation();
            PrintName ("PCurve");
            PrintRange ("Edge Range", aParameters2d.first, aParameters2d.second);
            PCurveExplorer::PrintPCurveInfo (aPCurve);
        }
        --myNestingLevel;
    }
 
    void PrintVertex (const ModelData_Vertex& theVertex)
    {
        PrintName ("Vertex");
        ModelData_Point aLoc =       theVertex.Point();
        double          aTolerance = theVertex.Tolerance();
        PrintOrientation (theVertex.Orientation());
        PrintParameter ("Tolerance", aTolerance);
        PrintParameter ("Location",  aLoc.Coord());
    }
 
    private: 
        ModelData_Face myCurrentFace;
};
 
#endif

surface_explorer.hxx

// ****************************************************************************
// $Id$
//
// Copyright (C) 2008-2014, Roman Lygin. All rights reserved.
// Copyright (C) 2014-2023, CADEX. All rights reserved.
//
// This file is part of the CAD Exchanger software.
//
// You may use this file under the terms of the BSD license as follows:
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
// * Redistributions of source code must retain the above copyright notice,
//   this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above copyright notice,
//   this list of conditions and the following disclaimer in the documentation
//   and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
// ****************************************************************************
 
 
#ifndef _SurfaceExplorer_HeaderFile
#define _SurfaceExplorer_HeaderFile
 
#include <base_explorer.hxx>
 
#include <cadex/ModelData_Axis3Placement.hxx>
#include <cadex/ModelData_BezierSurface.hxx>
#include <cadex/ModelData_BSplineSurface.hxx>
#include <cadex/ModelData_ConicalSurface.hxx>
#include <cadex/ModelData_CylindricalSurface.hxx>
#include <cadex/ModelData_OffsetSurface.hxx>
#include <cadex/ModelData_Plane.hxx>
#include <cadex/ModelData_RectangularTrimmedSurface.hxx>
#include <cadex/ModelData_SphericalSurface.hxx>
#include <cadex/ModelData_SurfaceOfLinearExtrusion.hxx>
#include <cadex/ModelData_SurfaceOfRevolution.hxx>
#include <cadex/ModelData_ToroidalSurface.hxx>
 
 
using namespace std;
using namespace cadex;
 
class SurfaceExplorer : public BaseExplorer
{
public:
    static void PrintSurface (const ModelData_Surface& theSurface)
    {
        switch (theSurface.Type()) {
        case ModelData_ST_Plane:
            PrintPlane           (static_cast <const ModelData_Plane&>                     (theSurface));
            break;
        case ModelData_ST_Cylinder:
            PrintCylinder        (static_cast <const ModelData_CylindricalSurface&>        (theSurface));
            break;
        case ModelData_ST_Cone:
            PrintCone            (static_cast <const ModelData_ConicalSurface&>            (theSurface));
            break;
        case ModelData_ST_Sphere:
            PrintSphere          (static_cast <const ModelData_SphericalSurface&>          (theSurface));
            break;
        case ModelData_ST_Torus:
            PrintTorus           (static_cast <const ModelData_ToroidalSurface&>           (theSurface));
            break;
        case ModelData_ST_LinearExtrusion:
            PrintLinearExtrusion (static_cast <const ModelData_SurfaceOfLinearExtrusion&>  (theSurface));
            break;
        case ModelData_ST_Revolution:
            PrintRevolution      (static_cast <const ModelData_SurfaceOfRevolution&>       (theSurface));
            break;
        case ModelData_ST_Bezier:
            PrintBezierSurface   (static_cast <const ModelData_BezierSurface&>             (theSurface));
            break;
        case ModelData_ST_BSpline:
            PrintBSplineSurface  (static_cast <const ModelData_BSplineSurface&>            (theSurface));
            break;
        case ModelData_ST_Offset:
            PrintOffsetSurface   (static_cast <const ModelData_OffsetSurface&>             (theSurface));
            break;
        case ModelData_ST_Trimmed:
            PrintTrimmedSurface  (static_cast <const ModelData_RectangularTrimmedSurface&> (theSurface));
            break;
        default:
            break;
        }
    }
 
    static void PrintPlane (const ModelData_Plane& thePlane)
    {
        PrintName ("Plane");
        PrintElementary (thePlane);
    }
 
    static void PrintCylinder (const ModelData_CylindricalSurface& theCylinder)
    {
        PrintName ("Cylinder");
        double aRadius = theCylinder.Radius();
        PrintElementary (theCylinder);
        PrintParameter ("Radius", aRadius);
    }
 
    static void PrintCone (const ModelData_ConicalSurface& theCone)
    {
        PrintName ("Cone");
        double aRadius =    theCone.Radius();
        double aSemiAngle = theCone.SemiAngle();
        PrintElementary (theCone);
        PrintParameter ("Radius", aRadius);
        PrintParameter ("Semi-Angle", aSemiAngle);
    }
 
    static void PrintSphere (const ModelData_SphericalSurface& theSphere)
    {
        PrintName ("Sphere");
        double aRadius = theSphere.Radius();
        PrintElementary (theSphere);
        PrintParameter ("Radius", aRadius);
    }
 
    static void PrintTorus (const ModelData_ToroidalSurface& theTorus)
    {
        PrintName ("Torus");
        double aMajorRadius = theTorus.MajorRadius();
        double aMinorRadius = theTorus.MinorRadius();
        PrintElementary (theTorus);
        PrintParameter ("Major Radius", aMajorRadius);
        PrintParameter ("Minor Radius", aMinorRadius);
    }
 
    static void PrintLinearExtrusion (const ModelData_SurfaceOfLinearExtrusion& theLinearExtrusion)
    {
        PrintName ("Linear Extrusion Surface");
        const ModelData_Direction& aDir = theLinearExtrusion.Direction();
        PrintDomain (theLinearExtrusion);
        PrintParameter ("Direction", aDir.Coord());
        cout << "Basis Curve = ";
        CurveExplorer::PrintCurveInfo (theLinearExtrusion.BasisCurve());
    }
 
    static void PrintRevolution (const ModelData_SurfaceOfRevolution& theRevolution)
    {
        PrintName ("Revolution Surface");
        const ModelData_Direction& aDir = theRevolution.Direction();
        const ModelData_Point&     aLoc = theRevolution.Location();
        PrintDomain (theRevolution);
        PrintParameter ("Location",  aLoc.Coord());
        PrintParameter ("Direction", aDir.Coord());
        cout << "Basis Curve = ";
        CurveExplorer::PrintCurveInfo (theRevolution.BasisCurve());
    }
 
    static void PrintBezierSurface (const ModelData_BezierSurface& theBezier)
    {
        PrintName ("Bezier Surface");
        int aUDegree =        theBezier.UDegree();
        int aVDegree =        theBezier.VDegree();
        int aNumberOfUPoles = theBezier.NumberOfUPoles();
        int aNumberOfVPoles = theBezier.NumberOfVPoles();
        PrintDomain (theBezier);
        PrintParameter ("U Degree",          aUDegree);
        PrintParameter ("V Degree",          aVDegree);
        PrintParameter ("Number Of U Poles", aNumberOfUPoles);
        PrintParameter ("Number Of V Poles", aNumberOfVPoles);
 
        PrintCollection ("Poles", aNumberOfUPoles, aNumberOfVPoles, [&](int i, int j)
        {
            auto aPole = theBezier.Pole (i, j);
            PrintParameter (aPole.Coord());
        });
 
        PrintCollection ("Weights", aNumberOfUPoles, aNumberOfVPoles, [&](int i, int j)
        {
            double aWeight = theBezier.Weight (i, j);
            PrintParameter (aWeight);
        });
    }
 
    static void PrintBSplineSurface (const ModelData_BSplineSurface& theBSpline)
    {
        PrintName ("BSpline Surface");
 
        int aUDegree =        theBSpline.UDegree();
        int aVDegree =        theBSpline.VDegree();
        int aNumberOfUKnots = theBSpline.NumberOfUKnots();
        int aNumberOfVKnots = theBSpline.NumberOfVKnots();
        int aNumberOfUPoles = theBSpline.NumberOfUPoles();
        int aNumberOfVPoles = theBSpline.NumberOfVPoles();
        PrintDomain (theBSpline);
        PrintParameter ("U Degree",          aUDegree);
        PrintParameter ("V Degree",          aVDegree);
        PrintParameter ("Number Of U Knots", aNumberOfUKnots);
        PrintParameter ("Number Of V Knots", aNumberOfVKnots);
        PrintParameter ("Number Of U Poles", aNumberOfUPoles);
        PrintParameter ("Number Of V Poles", aNumberOfVPoles);
 
        PrintCollection ("U Knots", aNumberOfUKnots, [&](int i)
        {
            double aKnot = theBSpline.UKnot (i);
            PrintParameter (aKnot);
        });
 
        PrintCollection ("V Knots", aNumberOfVKnots, [&](int i)
        {
            double aKnot = theBSpline.VKnot (i);
            PrintParameter (aKnot);
        });
 
 
        PrintCollection ("U Multiplicities", aNumberOfUKnots, [&](int i)
        {
            int aUMultiplicity = theBSpline.UMultiplicity (i);
            PrintParameter (aUMultiplicity);
        });
 
        PrintCollection ("V Multiplicities", aNumberOfVKnots, [&](int i)
        {
            int aVMultiplicity = theBSpline.VMultiplicity (i);
            PrintParameter (aVMultiplicity);
        });
 
        PrintCollection ("Poles", aNumberOfUPoles, aNumberOfVPoles, [&](int i, int j)
        {
            auto aPole = theBSpline.Pole (i, j);
            PrintParameter (aPole.Coord());
        });
 
        PrintCollection ("Weights", aNumberOfUPoles, aNumberOfVPoles, [&](int i, int j)
        {
            double aWeight = theBSpline.Weight (i, j);
            PrintParameter (aWeight);
        });
    }
 
    static void PrintOffsetSurface (const ModelData_OffsetSurface& theOffset)
    {
        PrintName ("Offset Surface");
        double anOffset = theOffset.Offset();
        PrintDomain (theOffset);
        PrintParameter ("Offset", anOffset);
        cout << "Basis Surface = ";
        PrintSurface (theOffset.BasisSurface());
    }
 
    static void PrintTrimmedSurface (const ModelData_RectangularTrimmedSurface& theTrimmed)
    {
        PrintName ("Trimmed Surface");
        PrintDomain (theTrimmed);
        cout << "Basis Surface = ";
        PrintSurface (theTrimmed.BasisSurface());
    }
};
#endif

main.cxx

// ****************************************************************************
// $Id$
//
// Copyright (C) 2008-2014, Roman Lygin. All rights reserved.
// Copyright (C) 2014-2023, CADEX. All rights reserved.
//
// This file is part of the CAD Exchanger software.
//
// You may use this file under the terms of the BSD license as follows:
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
// * Redistributions of source code must retain the above copyright notice,
//   this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above copyright notice,
//   this list of conditions and the following disclaimer in the documentation
//   and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
// ****************************************************************************
 
#include <shape_explorer.hxx>
#include <cadex/ModelData_ModelReader.hxx>
 
#include <cadex/LicenseManager_Activate.h>
#include "../../cadex_license.cxx"
 
int main (int argc, char* argv[])
{
    auto aKey = LicenseKey::Value();
 
    // Activate the license (aKey must be defined in cadex_license.cxx)
    if (!CADExLicense_Activate (aKey)) {
        cerr << "Failed to activate CAD Exchanger license." << endl;
        return 1;
    }
 
    // Get the input
    if (argc != 2) {
        cerr << "Usage: " << argv[0] << " <input_file>, where:" << endl;
        cerr << "    <input_file> is a name of the XML file to be read" << endl;
        return 1;
    }
 
    const char* aSource = argv[1];
 
    ModelData_Model aModel;
 
    if (!ModelData_ModelReader().Read (aSource, aModel)) {
        cerr << "Failed to read the file " << aSource << endl;
        return 1;
    }
 
    // Explore B-Rep representation of model parts
    ShapeExplorer aVisitor;
    aModel.Accept (aVisitor);
 
    return 0;
}