exploring/brepgeometry/brepgeometry.py

Refer to the B-Rep Geometry Exploration Example.

base_explorer.py

#!/usr/bin/env python3
 
# $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.
 
 
import sys
from pathlib import Path
import os
 
 
import cadexchanger.CadExCore as cadex
 
sys.path.append(os.path.abspath(os.path.dirname(Path(__file__).resolve()) + r"/../../"))
 
class BaseExplorer:
    def __init__(self):
        super().__init__()
        self.myNestingLevel = 0
 
    @classmethod
    def PrintElementary(cls, theGeometry):
        cls.PrintDomain(theGeometry)
        aPosition = theGeometry.Position()
        aLoc =   aPosition.Location()
        anAxis = aPosition.Axis()
        aXDir =  aPosition.XDirection()
        aYDir =  aPosition.YDirection()
        cls.PrintNamedParameter("Location",    aLoc)
        cls.PrintNamedParameter("Axis",        anAxis)
        cls.PrintNamedParameter("X Direction", aXDir)
        cls.PrintNamedParameter("Y Direction", aYDir)
 
    @classmethod
    def PrintElementary2d(cls, theGeometry):
        cls.PrintDomain(theGeometry)
        aPosition = theGeometry.Position()
        aLoc =  aPosition.Location()
        aXDir = aPosition.XDirection()
        aYDir = aPosition.YDirection()
        cls.PrintNamedParameter("Location",    aLoc)
        cls.PrintNamedParameter("X Direction", aXDir)
        cls.PrintNamedParameter("Y Direction", aYDir)
 
    @classmethod
    def PrintRange(cls, aName: str, aFirstParameter: float, aLastParameter: float):
        print(f"{aName} = [{aFirstParameter}, {aLastParameter}]; ", end="")
 
    @classmethod
    def PrintCurveDomain(cls, theCurve):
        cls.PrintRange("Domain", theCurve.UMin(), theCurve.UMax())
 
    @classmethod
    def PrintSurfaceDomain(cls, theSurface):
        cls.PrintRange("Domain U", theSurface.UMin(), theSurface.UMax())
        cls.PrintRange("V", theSurface.VMin(), theSurface.VMax())
 
    @classmethod
    def PrintDomain(cls, theValue):
        if isinstance(theValue, cadex.ModelData_Curve) or isinstance(theValue, cadex.ModelData_Curve2d):
            cls.PrintCurveDomain(theValue)
        elif isinstance(theValue, cadex.ModelData_Surface):
            cls.PrintSurfaceDomain(theValue)
 
    @classmethod
    def Print3dParameter(cls, thePoint):
        print(f"({thePoint.X()}, {thePoint.Y()}, {thePoint.Z()}); ", end="")
 
    @classmethod
    def Print2dParameter(cls, thePoint):
        print(f"({thePoint.X()}, {thePoint.Y()}); ", end="")
 
    @classmethod
    def Print1dParameter(cls, theValue):
        print(f"{theValue}; ", end="")
 
    @classmethod
    def PrintParameter(cls, theValue):
        if isinstance(theValue, cadex.ModelData_Point) or isinstance(theValue, cadex.ModelData_Direction):
            cls.Print3dParameter(theValue)
        elif isinstance(theValue, cadex.ModelData_Point2d) or isinstance(theValue, cadex.ModelData_Direction2d):
            cls.Print2dParameter(theValue)
        elif isinstance(theValue, float):
            cls.Print1dParameter(theValue)
 
    @classmethod
    def PrintNamedParameter(cls, theName, TheValue):
        print(f"{theName} = ", end="")
        cls.PrintParameter(TheValue)
 
    @classmethod
    def PrintName(cls, theName: str):
        print(f"{theName}: ", end="")
 
    @classmethod
    def Print2dCollection(cls, theName: str, theFinalIndex: int, thePrintElement):
        if theName:
            print(f"{theName} = ", end="")
 
        print("[", end="")
        for i in range(1, theFinalIndex + 1):
            if(i > 3):
                print("...", end="")
                break
            thePrintElement(i)
 
        print("]; ", end="")
 
 
    @classmethod
    def Print3dCollection(cls, theName: str, theFinalIndex1: int, theFinalIndex2: int, thePrintElement):
        def PrintString(i: int):
            cls.Print2dCollection(None, theFinalIndex2, lambda j: thePrintElement(i, j))
        cls.Print2dCollection(theName, theFinalIndex1, PrintString)
 
    @classmethod
    def PrintOrientation(cls, theOrientation):
        print("Orientation = ", end="")
        if theOrientation == cadex.ModelData_SO_Forward:
            print("Forward", end="")
        elif theOrientation == cadex.ModelData_SO_Reversed:
            print("Reversed", end="")
        else:
            print("Undefined")
        print("; ", end="")
 
    def PrintTabulation(self):
        print("--- " * self.myNestingLevel, end="")

curve_explorer.py

#!/usr/bin/env python3
 
# $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.
 
 
import sys
from pathlib import Path
import os
 
 
import cadexchanger.CadExCore as cadex
from base_explorer import BaseExplorer
 
 
class CurveExplorer(BaseExplorer):
    # Prints curve type name and prints shape info in some cases
    @classmethod
    def PrintCurveInfo(cls, theCurve: cadex.ModelData_Curve):
        if theCurve.Type() == cadex.ModelData_CT_Line:
            cls.PrintLine(cadex.ModelData_Line.Cast(theCurve))
        elif theCurve.Type() == cadex.ModelData_CT_Circle:
            cls.PrintCircle(cadex.ModelData_Circle.Cast(theCurve))
        elif theCurve.Type() == cadex.ModelData_CT_Ellipse:
            cls.PrintEllipse(cadex.ModelData_Ellipse.Cast(theCurve))
        elif theCurve.Type() == cadex.ModelData_CT_Hyperbola:
            cls.PrintHyperbola(cadex.ModelData_Hyperbola.Cast(theCurve))
        elif theCurve.Type() == cadex.ModelData_CT_Parabola:
            cls.PrintParabola(cadex.ModelData_Parabola.Cast(theCurve))
        elif theCurve.Type() == cadex.ModelData_CT_Bezier:
            cls.PrintBezierCurve(cadex.ModelData_BezierCurve.Cast(theCurve))
        elif theCurve.Type() == cadex.ModelData_CT_BSpline:
            cls.PrintBSplineCurve(cadex.ModelData_BSplineCurve.Cast(theCurve))
        elif theCurve.Type() == cadex.ModelData_CT_Offset:
            cls.PrintOffsetCurve(cadex.ModelData_OffsetCurve.Cast(theCurve))
        elif theCurve.Type() == cadex.ModelData_CT_Trimmed:
            cls.PrintTrimmedCurve(cadex.ModelData_TrimmedCurve.Cast(theCurve))
 
    @classmethod
    def PrintLine(cls, theLine: cadex.ModelData_Line):
        cls.PrintName("Line")
        aLoc = theLine.Location()
        aDir = theLine.Direction()
        cls.PrintDomain(theLine)
        cls.PrintNamedParameter("Location",  aLoc)
        cls.PrintNamedParameter("Direction", aDir)
 
    @classmethod
    def PrintCircle(cls, theCircle: cadex.ModelData_Circle):
        cls.PrintName("Circle")
        aRadius = theCircle.Radius()
        cls.PrintElementary(theCircle)
        cls.PrintNamedParameter("Radius", aRadius)
 
    @classmethod
    def PrintEllipse(cls, theEllipse: cadex.ModelData_Ellipse):
        cls.PrintName("Ellipse")
        aMajorRadius = theEllipse.MajorRadius()
        aMinorRadius = theEllipse.MinorRadius()
        cls.PrintElementary(theEllipse)
        cls.PrintNamedParameter("Major Radius", aMajorRadius)
        cls.PrintNamedParameter("Minor Radius", aMinorRadius)
 
    @classmethod
    def PrintHyperbola(cls, theHyperbola: cadex.ModelData_Hyperbola):
        cls.PrintName("Hyperbola")
        aMajorRadius = theHyperbola.MajorRadius()
        aMinorRadius = theHyperbola.MinorRadius()
        cls.PrintElementary(theHyperbola)
        cls.PrintNamedParameter("Major Radius", aMajorRadius)
        cls.PrintNamedParameter("Minor Radius", aMinorRadius)
 
    @classmethod
    def PrintParabola(cls, theParabola: cadex.ModelData_Parabola):
        cls.PrintName("Parabola")
        aFocal = theParabola.Focal()
        cls.PrintElementary(theParabola)
        cls.PrintNamedParameter("Focal", aFocal)
 
    @classmethod
    def PrintBezierCurve(cls, theBezier: cadex.ModelData_BezierCurve):
        cls.PrintName("Bezier Curve")
        aDegree = theBezier.Degree()
        aNumberOfPoles = theBezier.NumberOfPoles()
        cls.PrintDomain(theBezier)
        cls.PrintNamedParameter("Degree",          aDegree)
        cls.PrintNamedParameter("Number Of Poles", aNumberOfPoles)
 
        def PrintPole(i):
            aPole = theBezier.Pole(i)
            cls.PrintParameter(aPole)
 
        cls.Print2dCollection("Poles", aNumberOfPoles, PrintPole)
 
        def PrintWeight(i):
            aWeight = theBezier.Weight(i)
            cls.PrintParameter(aWeight)
 
        cls.Print2dCollection("Weights", aNumberOfPoles, PrintWeight)
 
    @classmethod
    def PrintBSplineCurve(cls, theBSpline: cadex.ModelData_BSplineCurve):
        cls.PrintName("BSpline Curve")
        aDegree = theBSpline.Degree()
        aNumberOfKnots = theBSpline.NumberOfKnots()
        aNumberOfPoles = theBSpline.NumberOfPoles()
        cls.PrintDomain(theBSpline)
        cls.PrintNamedParameter("Degree", aDegree)
        cls.PrintNamedParameter("Number Of Knots", aNumberOfKnots)
        cls.PrintNamedParameter("Number Of Poles", aNumberOfPoles)
 
        def PrintKnot(i):
            aKnot = theBSpline.Knot(i)
            cls.PrintParameter(aKnot)
 
        cls.Print2dCollection("Knots", aNumberOfKnots, PrintKnot)
 
        def PrintMultiplicity(i):
            aMultiplicity = theBSpline.Multiplicity(i)
            cls.PrintParameter(aMultiplicity)
 
        cls.Print2dCollection("Multiplicities", aNumberOfKnots, PrintMultiplicity)
 
        def PrintPole(i):
            aPole = theBSpline.Pole(i)
            cls.PrintParameter(aPole)
 
        cls.Print2dCollection("Poles", aNumberOfPoles, PrintPole)
 
        def PrintWeight(i):
            aWeight = theBSpline.Weight(i)
            cls.PrintParameter(aWeight)            
 
        cls.Print2dCollection("Weights", aNumberOfPoles, PrintWeight)
 
    @classmethod
    def PrintOffsetCurve(cls, theOffset: cadex.ModelData_OffsetCurve):
        cls.PrintName("Offset Curve")
        aDir = theOffset.Direction()
        anOffset = theOffset.Offset()
        cls.PrintDomain(theOffset)
        cls.PrintNamedParameter("Direction", aDir)
        cls.PrintNamedParameter("Offset",    anOffset)
        print("Basis Curve = ", end="")
        cls.PrintCurveInfo(theOffset.BasisCurve())
 
    @classmethod
    def PrintTrimmedCurve(cls, theTrimmed: cadex.ModelData_TrimmedCurve):
        cls.PrintName("Trimmed Curve")
        cls.PrintDomain(theTrimmed)
        print("Basis Curve = ", end="")
        cls.PrintCurveInfo(theTrimmed.BasisCurve())

pcurve_explorer.py

#!/usr/bin/env python3
 
# $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.
 
 
import sys
from pathlib import Path
import os
 
 
import cadexchanger.CadExCore as cadex
from base_explorer import BaseExplorer
 
 
class PCurveExplorer(BaseExplorer):
 
# Prints 2d curve type name and prints shape info in some cases
    @classmethod
    def PrintPCurveInfo(cls, theCurve):
        if theCurve.Type() == cadex.ModelData_CT_Line:
            cls.PrintLine(cadex.ModelData_Line2d.Cast(theCurve))
        elif theCurve.Type() == cadex.ModelData_CT_Circle:
            cls.PrintCircle(cadex.ModelData_Circle2d.Cast(theCurve))
        elif theCurve.Type() == cadex.ModelData_CT_Ellipse:
            cls.PrintEllipse(cadex.ModelData_Ellipse2d.Cast(theCurve))
        elif theCurve.Type() == cadex.ModelData_CT_Hyperbola:
            cls.PrintHyperbola(cadex.ModelData_Hyperbola2d.Cast(theCurve))
        elif theCurve.Type() == cadex.ModelData_CT_Parabola:
            cls.PrintParabola(cadex.ModelData_Parabola2d.Cast(theCurve))
        elif theCurve.Type() == cadex.ModelData_CT_Bezier:
            cls.PrintBezierCurve(cadex.ModelData_BezierCurve2d.Cast(theCurve))
        elif theCurve.Type() == cadex.ModelData_CT_BSpline:
            cls.PrintBSplineCurve(cadex.ModelData_BSplineCurve2d.Cast(theCurve))
        elif theCurve.Type() == cadex.ModelData_CT_Offset:
            cls.PrintOffsetCurve(cadex.ModelData_OffsetCurve2d.Cast(theCurve))
        elif theCurve.Type() == cadex.ModelData_CT_Trimmed:
            cls.PrintTrimmedCurve(cadex.ModelData_TrimmedCurve2d.Cast(theCurve))
 
 
    @classmethod
    def PrintLine(cls, theLine: cadex.ModelData_Line2d):
        cls.PrintName("Line 2d")
        aLoc = theLine.Location()
        aDir = theLine.Direction()
        cls.PrintDomain(theLine)
        cls.PrintNamedParameter("Location",  aLoc)
        cls.PrintNamedParameter("Direction", aDir)
 
    @classmethod
    def PrintCircle(cls, theCircle: cadex.ModelData_Circle2d):
        cls.PrintName("Circle 2d")
        aRadius = theCircle.Radius()
        cls.PrintElementary2d(theCircle)
        cls.PrintNamedParameter("Radius", aRadius)
 
    @classmethod
    def PrintEllipse(cls, theEllipse: cadex.ModelData_Ellipse2d):
        cls.PrintName("Ellipse 2d")
        aMajorRadius = theEllipse.MajorRadius()
        aMinorRadius = theEllipse.MinorRadius()
        cls.PrintElementary2d(theEllipse)
        cls.PrintNamedParameter("Major Radius", aMajorRadius)
        cls.PrintNamedParameter("Minor Radius", aMinorRadius)
 
    @classmethod
    def PrintHyperbola(cls, theHyperbola: cadex.ModelData_Hyperbola2d):
        cls.PrintName("Hyperbola 2d")
        aMajorRadius = theHyperbola.MajorRadius()
        aMinorRadius = theHyperbola.MinorRadius()
        cls.PrintElementary2d(theHyperbola)
        cls.PrintNamedParameter("Major Radius", aMajorRadius)
        cls.PrintNamedParameter("Minor Radius", aMinorRadius)
 
    @classmethod
    def PrintParabola(cls, theParabola: cadex.ModelData_Parabola2d):
        cls.PrintName("Parabola 2d")
        aFocal = theParabola.Focal()
        cls.PrintElementary2d(theParabola)
        cls.PrintNamedParameter("Focal", aFocal)
 
    @classmethod
    def PrintBezierCurve(cls, theBezier: cadex.ModelData_BezierCurve2d):
        cls.PrintName("Bezier Curve 2d")
        aDegree = theBezier.Degree()
        aNumberOfPoles = theBezier.NumberOfPoles()
        cls.PrintDomain(theBezier)
        cls.PrintNamedParameter("Degree", aDegree)
        cls.PrintNamedParameter("Number Of Poles", aNumberOfPoles)
 
        def PrintPole(i):
            aPole = theBezier.Pole(i)
            cls.PrintNamedParameter(aPole)
 
        cls.Print2dCollection("Poles", aNumberOfPoles, PrintPole)
 
        def PrintWeight(i):
            aWeight = theBezier.Weight(i)
            cls.PrintNamedParameter(aWeight)
 
        cls.Print2dCollection("Weights", aNumberOfPoles, PrintWeight)
 
 
    @classmethod
    def PrintBSplineCurve(cls, theBSpline: cadex.ModelData_BSplineCurve2d):
        cls.PrintName("BSpline Curve 2d")
        aDegree = theBSpline.Degree()
        aNumberOfKnots = theBSpline.NumberOfKnots()
        aNumberOfPoles = theBSpline.NumberOfPoles()
        cls.PrintDomain(theBSpline)
        cls.PrintNamedParameter("Degree", aDegree)
        cls.PrintNamedParameter("Number Of Knots", aNumberOfKnots)
        cls.PrintNamedParameter("Number Of Poles", aNumberOfPoles)
 
        def PrintKnot(i):
            aKnot = theBSpline.Knot(i)
            cls.PrintParameter(aKnot)
 
        cls.Print2dCollection("Knots", aNumberOfKnots, PrintKnot)
 
        def PrintMultiplicity(i):
            aMultiplicity = theBSpline.Multiplicity(i)
            cls.PrintParameter(aMultiplicity)
 
        cls.Print2dCollection("Multiplicities", aNumberOfKnots, PrintMultiplicity)
 
        def PrintPole(i):
            aPole = theBSpline.Pole(i)
            cls.PrintParameter(aPole)
 
        cls.Print2dCollection("Poles", aNumberOfPoles, PrintPole)
 
        def PrintWeight(i):
            aWeight = theBSpline.Weight(i)
            cls.PrintParameter(aWeight)            
 
        cls.Print2dCollection("Weights", aNumberOfPoles, PrintWeight)
 
    @classmethod
    def PrintOffsetCurve(cls, theOffset: cadex.ModelData_OffsetCurve2d):
        cls.PrintName("Offset Curve 2d")
        anOffset = theOffset.Offset()
        cls.PrintDomain(theOffset)
        cls.PrintParameter("Offset", anOffset)
        print("Basis Curve = ", end="")
        cls.PrintPCurveInfo(theOffset.BasisCurve())
 
    @classmethod
    def PrintTrimmedCurve(cls, theTrimmed: cadex.ModelData_TrimmedCurve2d):
        cls.PrintName("Trimmed Curve 2d")
        cls.PrintDomain(theTrimmed)
        print("Basis Curve = ", end="")
        cls.PrintPCurveInfo(theTrimmed.BasisCurve())

shape_explorer.py

#!/usr/bin/env python3
 
# $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.
 
 
import sys
from pathlib import Path
import os
 
 
import cadexchanger.CadExCore as cadex
from base_explorer import BaseExplorer
from surface_explorer import SurfaceExplorer
from curve_explorer import CurveExplorer
from pcurve_explorer import PCurveExplorer
 
class ShapeExplorer(cadex.ModelData_Model_VoidElementVisitor, BaseExplorer):
    def __init__(self):
        BaseExplorer.__init__(self)
        cadex.ModelData_Model_VoidElementVisitor.__init__(self)
 
    def VisitPart(self, thePart: cadex.ModelData_Part):
        aBRep = thePart.BRepRepresentation()
        if aBRep:
            print(f"Part = \"{thePart.Name()}\"")
            self.ExploreBRep(aBRep)
 
    def ExploreBRep(self, theBRep: cadex.ModelData_BRepRepresentation):
        # 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)
        aBodyList = theBRep.Get()
 
        # Iterate over bodies
        for i, aBody in enumerate(aBodyList):
            print(f"Body {i}: {self.BodyType(aBody)}")
            self.ExploreShape(aBody)
 
 
    # Recursive iterating over the Shape until reaching vertices
    def ExploreShape(self, theShape: cadex.ModelData_Shape):
        if theShape.Type() == cadex.ModelData_ST_Face:
            self.myCurrentFace = cadex.ModelData_Face.Cast(theShape)
        self.myNestingLevel += 1
        for aShape in cadex.ModelData_Shape_Iterator(theShape):
            self.PrintShape(aShape)
            self.ExploreShape(aShape)
 
        if theShape.Type() == cadex.ModelData_ST_Face:
            self.myCurrentFace = None
 
        self.myNestingLevel -= 1
 
    # Returns body type name
    def BodyType(self, theBody: cadex.ModelData_Body) -> str:
        if theBody.BodyType() == cadex.ModelData_BT_Solid:
            return "Solid"
        if theBody.BodyType() == cadex.ModelData_BT_Sheet:
            return "Sheet"
        if theBody.BodyType() == cadex.ModelData_BT_Wireframe:
            return "Wireframe"
        if theBody.BodyType() == cadex.ModelData_BT_Acorn:
            return "Acorn"
        return "Undefined"
 
    # Returns shape type name and prints shape info in some cases
    def PrintShape(self, theShape: cadex.ModelData_Shape):
        self.PrintTabulation()
 
        if theShape.Type() == cadex.ModelData_ST_Solid:
            print("Solid", end="")
        elif theShape.Type() == cadex.ModelData_ST_Shell:  
            self.PrintShell(cadex.ModelData_Shell.Cast(theShape))
        elif theShape.Type() == cadex.ModelData_ST_Wire:   
            self.PrintWire(cadex.ModelData_Wire.Cast(theShape))
        elif theShape.Type() == cadex.ModelData_ST_Face:   
            self.PrintFace(cadex.ModelData_Face.Cast(theShape))
        elif theShape.Type() == cadex.ModelData_ST_Edge:   
            self.PrintEdge(cadex.ModelData_Edge.Cast(theShape))
        elif theShape.Type() == cadex.ModelData_ST_Vertex: 
            self.PrintVertex(cadex.ModelData_Vertex.Cast(theShape))
        else:
            print("Undefined", end="")
 
        print()
 
    def PrintShell(self, theShell: cadex.ModelData_Shell):
        self.PrintName("Shell")
        self.myNestingLevel += 1
        self.PrintOrientation(theShell.Orientation())
        self.myNestingLevel -= 1
 
    def PrintWire(self, theWire: cadex.ModelData_Wire):
        self.PrintName("Wire")
        self.myNestingLevel += 1
        self.PrintOrientation(theWire.Orientation())
        self.myNestingLevel -= 1
 
    def PrintFace(self, theFace: cadex.ModelData_Face):
        self.PrintName("Face")
        self.myNestingLevel += 1
        self.PrintOrientation(theFace.Orientation())
        print()
        aSurface = theFace.Surface()
        self.PrintTabulation()
        print("Surface: ")
        SurfaceExplorer.PrintSurface(aSurface)
        self.myNestingLevel -= 1
 
    def PrintEdge(self, theEdge: cadex.ModelData_Edge):
        self.PrintName("Edge")
        self.myNestingLevel += 1
        if theEdge.IsDegenerated():
            print("Degenerated: ", end="")
        self.PrintOrientation(theEdge.Orientation())
        self.PrintNamedParameter("Tolerance", theEdge.Tolerance())
 
        if not theEdge.IsDegenerated():
            aCurve, first, second = theEdge.Curve()
            print()
            self.PrintTabulation()
            self.PrintName("Curve")
            self.PrintRange("Edge Range", first, second)
            CurveExplorer.PrintCurveInfo(aCurve)
            
        if self.myCurrentFace:
            aPCurve, first, second = theEdge.PCurve(self.myCurrentFace)
            print()
            self.PrintTabulation()
            self.PrintName("PCurve")
            self.PrintRange("Edge Range", first, second)
            PCurveExplorer.PrintPCurveInfo(aPCurve)
            
        self.myNestingLevel -= 1
 
    def PrintVertex(self, theVertex:cadex.ModelData_Vertex):
        self.PrintName("Vertex")
        aLoc = theVertex.Point()
        aTolerance = theVertex.Tolerance()
        self.PrintOrientation(theVertex.Orientation())
        self.PrintNamedParameter("Tolerance", aTolerance)
        self.PrintNamedParameter("Location",  aLoc)

surface_explorer.py

#!/usr/bin/env python3
 
# $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.
 
 
import sys
from pathlib import Path
import os
 
 
import cadexchanger.CadExCore as cadex
from base_explorer import BaseExplorer
from curve_explorer import CurveExplorer
 
class SurfaceExplorer(BaseExplorer):
    def __init__():
        super().__init__()
 
    @classmethod
    def PrintSurface(cls, theSurface: cadex.ModelData_Surface):
        if theSurface.Type() == cadex.ModelData_ST_Plane:
            cls.PrintPlane(cadex.ModelData_Plane.Cast(theSurface))
        elif theSurface.Type() == cadex.ModelData_ST_Cylinder:
            cls.PrintCylinder(cadex.ModelData_CylindricalSurface.Cast(theSurface))
        elif theSurface.Type() == cadex.ModelData_ST_Cone:
            cls.PrintCone(cadex.ModelData_ConicalSurface.Cast(theSurface))
        elif theSurface.Type() == cadex.ModelData_ST_Sphere:
            cls.PrintSphere(cadex.ModelData_SphericalSurface.Cast(theSurface))
        elif theSurface.Type() == cadex.ModelData_ST_Torus:
            cls.PrintTorus(cadex.ModelData_ToroidalSurface.Cast(theSurface))
        elif theSurface.Type() == cadex.ModelData_ST_LinearExtrusion:
            cls.PrintLinearExtrusion(cadex.ModelData_SurfaceOfLinearExtrusion.Cast(theSurface))
        elif theSurface.Type() == cadex.ModelData_ST_Revolution:
            cls.PrintRevolution(cadex.ModelData_SurfaceOfRevolution.Cast(theSurface))
        elif theSurface.Type() == cadex.ModelData_ST_Bezier:
            cls.PrintBezierSurface(cadex.ModelData_BezierSurface.Cast(theSurface))
        elif theSurface.Type() == cadex.ModelData_ST_BSpline:
            cls.PrintBSplineSurface(cadex.ModelData_BSplineSurface.Cast(theSurface))
        elif theSurface.Type() == cadex.ModelData_ST_Offset:
            cls.PrintOffsetSurface(cadex.ModelData_OffsetSurface.Cast(theSurface))
        elif theSurface.Type() == cadex.ModelData_ST_Trimmed:
            cls.PrintTrimmedSurface(cadex.ModelData_RectangularTrimmedSurface.Cast(theSurface))
 
 
    @classmethod
    def PrintPlane(cls, thePlane: cadex.ModelData_Plane):
        cls.PrintName("Plane")
        cls.PrintElementary(thePlane)
 
    @classmethod
    def PrintCylinder(cls, theCylinder: cadex.ModelData_CylindricalSurface):
        cls.PrintName("Cylinder")
        aRadius = theCylinder.Radius()
        cls.PrintElementary(theCylinder)
        cls.PrintNamedParameter("Radius", aRadius)
 
    @classmethod
    def PrintCone(cls, theCone: cadex.ModelData_ConicalSurface):
        cls.PrintName("Cone")
        aRadius =    theCone.Radius()
        aSemiAngle = theCone.SemiAngle()
        cls.PrintElementary(theCone)
        cls.PrintNamedParameter("Radius", aRadius)
        cls.PrintNamedParameter("Semi-Angle", aSemiAngle)
 
    @classmethod
    def PrintSphere(cls, theSphere: cadex.ModelData_SphericalSurface):
        cls.PrintName("Sphere")
        aRadius = theSphere.Radius()
        cls.PrintElementary(theSphere)
        cls.PrintNamedParameter("Radius", aRadius)
 
    @classmethod
    def PrintTorus(cls, theTorus: cadex.ModelData_ToroidalSurface):
        cls.PrintName("Torus")
        aMajorRadius = theTorus.MajorRadius()
        aMinorRadius = theTorus.MinorRadius()
        cls.PrintElementary(theTorus)
        cls.PrintNamedParameter("Major Radius", aMajorRadius)
        cls.PrintNamedParameter("Minor Radius", aMinorRadius)
 
    @classmethod
    def PrintLinearExtrusion(cls, theLinearExtrusion: cadex.ModelData_SurfaceOfLinearExtrusion):
        cls.PrintName("Linear Extrusion Surface")
        aDir = theLinearExtrusion.Direction()
        cls.PrintDomain(theLinearExtrusion)
        cls.PrintNamedParameter("Direction", aDir)
        print("Basis Curve = ", end="")
        CurveExplorer.PrintCurveInfo(theLinearExtrusion.BasisCurve())
 
    @classmethod
    def PrintRevolution(cls, theRevolution: cadex.ModelData_SurfaceOfRevolution):
        cls.PrintName("Revolution Surface")
        aDir = theRevolution.Direction()
        aLoc = theRevolution.Location()
        print(cls.PrintDomain(theRevolution), end="")
        cls.PrintNamedParameter("Location", aLoc)
        cls.PrintNamedParameter("Direction", aDir)
        print("Basis Curve = ", end="")
        CurveExplorer.PrintCurveInfo(theRevolution.BasisCurve())
 
    @classmethod
    def PrintBezierSurface(cls, theBezier: cadex.ModelData_BezierSurface):
        cls.PrintName("Bezier Surface")
        aUDegree = theBezier.UDegree()
        aVDegree = theBezier.VDegree()
        aNumberOfUPoles = theBezier.NumberOfUPoles()
        aNumberOfVPoles = theBezier.NumberOfVPoles()
        cls.PrintDomain(theBezier)
        cls.PrintNamedParameter("UKnots Degree", aUDegree)
        cls.PrintNamedParameter("VKnots Degree", aVDegree)
        cls.PrintNamedParameter("Number Of UKnots Poles", aNumberOfUPoles)
        cls.PrintNamedParameter("Number Of VKnots Poles", aNumberOfVPoles)
 
        def PrintPole(i, j):
            aPole = theBezier.Pole(i, j)
            cls.PrintParameter(aPole)
 
        cls.PrintCollection("Poles", aNumberOfUPoles, aNumberOfVPoles, PrintPole)
 
        def PrintWeight(i,j):
            aWeight = theBezier.Weight(i, j)
            cls.PrintParameter(aWeight)
 
        cls.PrintCollection("Weights", aNumberOfUPoles, aNumberOfVPoles, PrintWeight)
 
    @classmethod
    def PrintBSplineSurface(cls, theBSpline: cadex.ModelData_BSplineSurface):
        cls.PrintName("BSpline Surface")
 
        aUDegree = theBSpline.UDegree()
        aVDegree = theBSpline.VDegree()
        aNumberOfUKnots = theBSpline.NumberOfUKnots()
        aNumberOfVKnots = theBSpline.NumberOfVKnots()
        aNumberOfUPoles = theBSpline.NumberOfUPoles()
        aNumberOfVPoles = theBSpline.NumberOfVPoles()
        cls.PrintDomain(theBSpline)
        cls.PrintNamedParameter("UKnots Degree", aUDegree)
        cls.PrintNamedParameter("VKnots Degree", aVDegree)
        cls.PrintNamedParameter("Number Of UKnots ", aNumberOfUKnots)
        cls.PrintNamedParameter("Number Of VKnots ", aNumberOfVKnots)
        cls.PrintNamedParameter("Number Of UKnots Poles", aNumberOfUPoles)
        cls.PrintNamedParameter("Number Of VKnots Poles", aNumberOfVPoles)
 
        def PrintUKnot(i):
            aKnot = theBSpline.UKnot(i)
            cls.PrintParameter(aKnot)
 
        cls.Print2dCollection("UKnots ", aNumberOfUKnots, PrintUKnot)
 
        def PrintVKnot(i):
            aKnot = theBSpline.VKnot(i)
            cls.PrintParameter(aKnot)
 
        cls.Print2dCollection("VKnots ", aNumberOfVKnots, PrintVKnot)
 
        def PrintUMultiplicity(i):
            aUMultiplicity = theBSpline.UMultiplicity(i)
            cls.PrintParameter(aUMultiplicity)
 
        cls.Print2dCollection("UKnots Multiplicities", aNumberOfUKnots, PrintUMultiplicity)
 
        def PrintVMultiplicity(i):
            aVMultiplicity = theBSpline.VMultiplicity(i)
            cls.PrintParameter(aVMultiplicity)
 
        cls.Print2dCollection("VKnots Multiplicities", aNumberOfVKnots, PrintVMultiplicity)
 
        def PrintPole(i, j):
            aPole = theBSpline.Pole(i, j)
            cls.PrintParameter(aPole)
 
        cls.Print3dCollection("Poles", aNumberOfUPoles, aNumberOfVPoles, PrintPole)
 
        def PrintWeight(i,j):
            aWeight = theBSpline.Weight(i, j)
            cls.PrintParameter(aWeight)
 
        cls.Print3dCollection("Weights", aNumberOfUPoles, aNumberOfVPoles, PrintWeight)
 
    @classmethod
    def PrintOffsetSurface(cls, theOffset: cadex.ModelData_OffsetSurface):
        cls.PrintName("Offset Surface")
        anOffset = theOffset.Offset()
        cls.PrintDomain(theOffset)
        cls.PrintNamedParameter("Offset", anOffset)
        print("Basis Surface = ", end="")
        cls.PrintSurface(theOffset.BasisSurface())
 
    @classmethod
    def PrintTrimmedSurface(cls, theTrimmed: cadex.ModelData_RectangularTrimmedSurface):
        cls.PrintName("Trimmed Surface")
        cls.PrintDomain(theTrimmed)
        print("Basis Surface = ", end="")
        cls.PrintSurface(theTrimmed.BasisSurface())

brepgeometry.py

#!/usr/bin/env python3
 
# $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.
 
 
import sys
from pathlib import Path
import os
 
import cadexchanger.CadExCore as cadex
 
sys.path.append(os.path.abspath(os.path.dirname(Path(__file__).resolve()) + r"/../../"))
import cadex_license as license
from shape_explorer import ShapeExplorer
 
def main(theSource: str):
    aKey = license.Value()
 
    if not cadex.LicenseManager.Activate(aKey):
        print("Failed to activate CAD Exchanger license.")
        return 1
 
    aModel = cadex.ModelData_Model()
 
    if not cadex.ModelData_ModelReader().Read(cadex.Base_UTF16String(theSource), aModel):
        print("Failed to read the file " + theSource)
        return 1
 
    # Explore B-Rep representation of model parts
    aVisitor = ShapeExplorer()
    aModel.AcceptElementVisitor(aVisitor)
 
    print("Completed")
    return 0
 
if __name__ == "__main__":
    if len(sys.argv) != 2:
        print("Usage: " + os.path.abspath(Path(__file__).resolve()) + " <input_file>, where:")
        print("    <input_file>  is a name of the XML file to be read")
        sys.exit(1)
 
    aSource = os.path.abspath(sys.argv[1])
 
    sys.exit(main(aSource))