import model
import geom
-from model import WrongNumberOfArguments
from TestSketcher import SketcherTestCase
self.assertEqual(arc.startPoint().x(), 0)
self.assertEqual(arc.startPoint().y(), 0)
- # def test_number_of_args(self):
- # with self.assertRaises(WrongNumberOfArguments):
- # self.sketch.addArc(0, 1, 1, 1)
- # with self.assertRaises(WrongNumberOfArguments):
- # self.sketch.addArc(0, 1)
-
def test_modify_arc(self):
# Note: arc will modify startPoint and endPoint to be in circle
arc = self.sketch.addArc(0, 1, 0, 0, 1, 1, 0)
from services import *
from roots import *
-from tools import Selection
# Built-in features
from features import *
from parameter import *
from partset import *
-
-# Custom exceptions
-
-from errors import WrongNumberOfArguments
-from errors import FeatureInputInvalid
+++ /dev/null
-"""Export to GEOM Interface
-Author: Sergey Pokhodenko
-Copyright (C) 2014-20xx CEA/DEN, EDF R&D
-"""
-
-from model.roots import Interface
-
-
-def exportToGEOM(part):
- """Export the Part to GEOM module.
-
- Args:
- part (ModelAPI_Document): part document
- """
- feature = part.addFeature("ExportToGEOM")
- feature.execute()
"""Package for Construction plugin for the Parametric Geometry API of the Modeler.
"""
-from ConstructionAPI import addAxis
-from ConstructionAPI import addPlane
-from ConstructionAPI import addPoint
+from ConstructionAPI import addAxis, addPlane, addPoint
+++ /dev/null
-"""Axis Interface
-Author: Sergey Pokhodenko
-Copyright (C) 2014-20xx CEA/DEN, EDF R&D
-"""
-
-from model.roots import Interface
-
-
-def addAxis(part, *args):
- """Add an Axis feature to the Part.
-
- .. function:: addAxis(part, p1, p2)
-
- Args:
- part (ModelAPI_Document): part document
- p1 (Selection): first point
- p2 (Selection): second point
-
- .. function:: addAxis(part, face)
-
- Args:
- part (ModelAPI_Document): part document
- face (Selection): cylindrical face
-
- Returns:
- Axis: axis object
- """
- assert(args)
- feature = part.addFeature("Axis")
- return Axis(feature, *args)
-
-
-class Axis(Interface):
- """Interface class for Axis feature.
-
- .. function:: Axis(feature)
-
- Create interface for the feature without initialization.
-
- .. function:: Axis(feature, p1, p2)
-
- Create interface for the feature and initialize the feature with arguments.
-
- .. function:: Axis(feature, face)
-
- Create interface for the feature and initialize the feature with arguments.
- """
-
- def __init__(self, feature, *args):
- """x.__init__(...) initializes x; see x.__class__.__doc__ for signature"""
- Interface.__init__(self, feature)
- assert(self._feature.getKind() == "Axis")
-
- self._CreationMethod = self._feature.data().string("CreationMethod")
- self._FirstPoint = self._feature.data().selection("FirstPoint")
- self._SecondPoint = self._feature.data().selection("SecondPoint")
- self._CylindricalFace = self._feature.data().selection("CylindricalFace")
-
- assert(self._CreationMethod)
- assert(self._FirstPoint)
- assert(self._SecondPoint)
- assert(self._CylindricalFace)
-
- if not args:
- return
-
- assert(len(args) in (1, 2))
- if len(args) == 2:
- self.setPoints(*args)
- elif len(args) == 1:
- self.setCylindricalFace(*args)
-
- self.execute()
- pass
-
- def __clear(self):
- self._fillAttribute(self._CreationMethod, "AxisByPointsCase")
- self._fillAttribute(self._FirstPoint, None)
- self._fillAttribute(self._SecondPoint, None)
- self._fillAttribute(self._CylindricalFace, None)
-
- def setPoints(self, p1, p2):
- """Modify points attribute of the feature.
-
- See __init__.
- """
- self.__clear()
- self._fillAttribute(self._CreationMethod, "AxisByPointsCase")
- self._fillAttribute(self._FirstPoint, p1)
- self._fillAttribute(self._SecondPoint, p2)
- pass
-
- def setCylindricalFace(self, face):
- """Modify CylindricalFace attribute of the feature.
-
- See __init__.
- """
- self.__clear()
- self._fillAttribute(self._CreationMethod, "AxisByCylindricalFaceCase")
- self._fillAttribute(self._CylindricalFace, face)
- pass
+++ /dev/null
-"""Plane Interface
-Author: Sergey Pokhodenko
-Copyright (C) 2014-20xx CEA/DEN, EDF R&D
-"""
-
-from model.roots import Interface
-
-
-def addPlane(part, *args):
- """Add a Plane feature to the Part and return Plane.
-
- .. function:: addPartition(part, face, distance)
-
- Args:
- part (ModelAPI_Document): part document
- face (Selection): plane face
- distance (double): distance
-
- .. function:: addPartition(part, a, b, c, d)
-
- Args:
- part (ModelAPI_Document): part document
- a (double): general equation parameter
- b (double): general equation parameter
- c (double): general equation parameter
- d (double): general equation parameter
-
- Returns:
- Plane: plane object
- """
- assert(args)
- feature = part.addFeature("Plane")
- return Plane(feature, *args)
-
-
-class Plane(Interface):
- """Interface class for Plane feature.
-
- .. function:: Plane(feature)
-
- Create interface for the feature without initialization.
-
- .. function:: Plane(feature, face, distance)
-
- Create interface for the feature and initialize the feature with arguments.
-
- .. function:: Plane(feature, a, b, c, d)
-
- Create interface for the feature and initialize the feature with arguments.
- """
-
- def __init__(self, feature, *args):
- """x.__init__(...) initializes x; see x.__class__.__doc__ for signature"""
- Interface.__init__(self, feature)
- assert(self._feature.getKind() == "Plane")
-
- self._CreationMethod = self._feature.data().string("CreationMethod")
- self._plane_face = self._feature.data().selection("planeFace")
- self._distance = self._feature.data().real("distance")
- self._a = self._feature.data().real("A")
- self._b = self._feature.data().real("B")
- self._c = self._feature.data().real("C")
- self._d = self._feature.data().real("D")
-
- assert(self._CreationMethod)
- assert(self._plane_face)
- assert(self._distance)
- assert(self._a)
- assert(self._b)
- assert(self._c)
- assert(self._d)
-
- if not args:
- return
-
- assert(len(args) in (2, 4))
- if len(args) == 2:
- self.setFaceAndDistance(*args)
- elif len(args) == 4:
- self.setGeneralEquation(*args)
-
- self.execute()
- pass
-
- def __clear(self):
- self._fillAttribute(self._CreationMethod, "PlaneByFaceAndDistance")
- self._fillAttribute(self._plane_face, None)
- self._fillAttribute(self._distance, 0)
- self._fillAttribute(self._a, 0)
- self._fillAttribute(self._b, 0)
- self._fillAttribute(self._c, 0)
- self._fillAttribute(self._d, 0)
-
- def setFaceAndDistance(self, face, distance):
- """Modify face and distance attribute of the feature.
-
- See __init__.
- """
- self.__clear()
- self._fillAttribute(self._CreationMethod, "PlaneByFaceAndDistance")
- self._fillAttribute(self._plane_face, face)
- self._fillAttribute(self._distance, distance)
- pass
-
- def setGeneralEquation(self, a, b, c, d):
- """Modify GeneralEquation parameters of the feature.
-
- See __init__.
- """
- self.__clear()
- self._fillAttribute(self._CreationMethod, "PlaneByGeneralEquation")
- self._fillAttribute(self._a, a)
- self._fillAttribute(self._b, b)
- self._fillAttribute(self._c, c)
- self._fillAttribute(self._d, d)
- pass
+++ /dev/null
-"""Point Interface
-Author: Sergey Pokhodenko
-Copyright (C) 2014-20xx CEA/DEN, EDF R&D
-"""
-
-from model.roots import Interface
-
-
-def addPoint(part, *args):
- """Add an Point feature to the Part and return Point.
-
- .. function:: addPoint(part, x, y, z)
-
- Args:
- part (ModelAPI_Document): part document
- x (double): X coordinate for the point
- y (double): Y coordinate for the point
- z (double): Z coordinate for the point
-
- Returns:
- Point: point object
- """
- assert(args)
- feature = part.addFeature("Point")
- return Point(feature, *args)
-
-
-class Point(Interface):
- """Interface class for Point feature.
-
- .. function:: Point(feature)
-
- Create interface for the feature without initialization.
-
- .. function:: Point(feature, x, y, z)
-
- Create interface for the feature and initialize the feature with arguments.
- """
-
- def __init__(self, feature, *args):
- """x.__init__(...) initializes x; see x.__class__.__doc__ for signature"""
- Interface.__init__(self, feature)
- assert(self._feature.getKind() == "Point")
-
- self._x = self._feature.data().real("x")
- self._y = self._feature.data().real("y")
- self._z = self._feature.data().real("z")
-
- assert(self._x)
- assert(self._y)
- assert(self._z)
-
- if not args:
- return
-
- assert(len(args) == 3)
- self.setPoint(*args)
-
- self.execute()
- pass
-
- def setPoint(self, x, y, z):
- """Modify base attribute of the feature.
-
- See __init__.
- """
- self._fillAttribute(self._x, x)
- self._fillAttribute(self._y, y)
- self._fillAttribute(self._z, z)
- pass
+++ /dev/null
-# Package exceptions
-
-class ModelError(Exception):
- """Base class for exceptions in this package."""
- pass
-
-class WrongNumberOfArguments(ModelError):
- """Exception raised when a wrong number of arguments is given."""
- pass
-
-class FeatureInputInvalid(ModelError):
- """Exception raised if a feature input is invalid."""
- pass
-
- #Attributes:
- #expr -- input expression in which the error occurred
- #msg -- explanation of the error
- #"""
-
- #def __init__(self, expr, msg):
- #self.expr = expr
- #self.msg = msg
+++ /dev/null
-"""Import Interface
-Author: Sergey Pokhodenko
-Copyright (C) 2014-20xx CEA/DEN, EDF R&D
-"""
-
-from model.roots import Interface
-
-
-def addImport(part, *args):
- """Add an Import feature to the Part.
-
- .. function:: addImport(part, file_path)
-
- Args:
- part (ModelAPI_Document): part document
- file_path (string): path to the imported file
-
- Returns:
- Import: import object
- """
- assert(args)
- feature = part.addFeature("Import")
- return Import(feature, *args)
-
-
-class Import(Interface):
- """Interface class for Import feature.
-
- .. function:: Import(feature)
-
- Create interface for the feature without initialization.
-
- .. function:: Import(feature, file_path)
-
- Create interface for the feature and initialize the feature with arguments.
- """
-
- def __init__(self, feature, *args):
- """x.__init__(...) initializes x; see x.__class__.__doc__ for signature"""
- Interface.__init__(self, feature)
- assert(self._feature.getKind() == "Import")
-
- self._file_path = self._feature.data().string("file_path")
-
- assert(self._file_path)
-
- if not args:
- return
-
- assert(len(args) == 1)
- self.setFilePath(args[0])
-
- self.execute()
- pass
-
- def setFilePath(self, file_path):
- """Modify file path attribute of the feature.
-
- See __init__.
- """
- self._fillAttribute(self._file_path, file_path)
- pass
-
-
-def exportToFile(part, *args):
- """Perform export from the Part to file.
-
- .. function:: exportToFile(part, file_path, file_format, selection_list)
-
- Args:
- part (ModelAPI_Document): part document
- file_path (string): path to the exported file
- file_format (string): format of to the exported file
- selection_list (list of Selection): objects to export
-
- Returns:
- Export: export object
- """
- assert(args)
- feature = part.addFeature("Export")
- return Export(feature, *args)
-
-
-class Export(Interface):
- """Interface class for Export feature.
-
- .. function:: Export(feature)
-
- Create interface for the feature without initialization.
-
- .. function:: Export(feature, file_path, file_format, selection_list)
-
- Create interface for the feature and initialize the feature with arguments.
- """
-
- def __init__(self, feature, *args):
- """x.__init__(...) initializes x; see x.__class__.__doc__ for signature"""
- Interface.__init__(self, feature)
- assert(self._feature.getKind() == "Export")
-
- self._file_path = self._feature.data().string("file_path")
- self._file_format = self._feature.data().string("file_format")
- self._objects = self._feature.data().selectionList("selection_list")
-
- assert(self._file_path)
- assert(self._file_format)
- assert(self._objects)
-
- if not args:
- return
-
- assert(len(args) == 3)
- self.setFilePath(args[0])
- self.setFileFormat(args[1])
- self.setObjects(args[2])
-
- self.execute()
- pass
-
- def setFilePath(self, file_path):
- """Modify file path attribute of the feature.
-
- See __init__.
- """
- self._fillAttribute(self._file_path, file_path)
- pass
-
- def setFileFormat(self, file_format):
- """Modify file path attribute of the feature.
-
- See __init__.
- """
- self._fillAttribute(self._file_format, file_format)
- pass
-
- def setObjects(self, objects):
- """Modify file path attribute of the feature.
-
- See __init__.
- """
- self._fillAttribute(self._objects, object)
- pass
from FeaturesAPI import addFuse, addCut, addCommon
-from partition import addPartition
+from FeaturesAPI import addPartition
from FeaturesAPI import addExtrusion, addExtrusionCut, addExtrusionFuse
from FeaturesAPI import addRevolution, addRevolutionCut, addRevolutionFuse
+++ /dev/null
-"""Boolean operations Interface
-Author: Daniel Brunier-Coulin with contribution by Sergey Pokhodenko
-Copyright (C) 2014-20xx CEA/DEN, EDF R&D
-"""
-
-from GeomAlgoAPI import GeomAlgoAPI_Boolean
-
-from model.roots import Interface
-from model import Selection
-
-def addAddition(part, *args):
- """Perform addition in the Part.
-
- .. function:: addAddition(part, main_objects, tool_objects)
-
- This operation adds tools to the given objects.
-
- Args:
- part (ModelAPI_Document): part document
- main_objects (list of :class:`model.Selection`): main objects
- tool_objects (list of :class:`model.Selection`): (optional) tool_objects objects
-
- Returns:
- Boolean: boolean object
- """
- assert(args)
- feature = part.addFeature("Boolean")
- return Boolean(
- feature, GeomAlgoAPI_Boolean.BOOL_FUSE, *args)
-
-
-def addSubtraction(part, *args):
- """Perform subtraction in the Part.
-
- .. function:: addSubtraction(part, main_objects, tool_objects)
-
- This operation subtracts tools from the given objects.
-
- Args:
- part (ModelAPI_Document): part document
- main_objects (list of :class:`model.Selection`): main objects
- tool_objects (list of :class:`model.Selection`): tool_objects objects
-
- Returns:
- Boolean: boolean object
- """
- assert(args)
- main_objects, tool_objects = args
- feature = part.addFeature("Boolean")
- return Boolean(
- feature, GeomAlgoAPI_Boolean.BOOL_CUT, main_objects, tool_objects)
-
-
-def addIntersection(part, *args):
- """Perform intersection in the Part.
-
- .. function:: addIntersection(part, main_objects, tool_objects)
-
- This operation intersects tools with the given objects.
-
- Args:
- part (ModelAPI_Document): part document
- main_objects (list of :class:`model.Selection`): main objects
- tool_objects (list of :class:`model.Selection`): tool_objects objects
-
- Returns:
- Boolean: boolean object
- """
- assert(args)
- main_objects, tool_objects = args
- feature = part.addFeature("Boolean")
- return Boolean(
- feature, GeomAlgoAPI_Boolean.BOOL_COMMON, main_objects, tool_objects)
-
-
-class Boolean(Interface):
- """Interface class for Boolean features.
-
- .. function:: Boolean(feature)
-
- Create interface for the feature without initialization.
-
- .. function:: Boolean(feature, bool_type, main_objects)
-
- Create interface for the feature and initialize the feature with arguments.
-
- .. function:: Boolean(feature, bool_type, main_objects, tool_objects)
-
- Create interface for the feature and initialize the feature with arguments.
- """
-
- def __init__(self, feature, *args):
- """x.__init__(...) initializes x; see x.__class__.__doc__ for signature"""
- Interface.__init__(self, feature)
- assert(self._feature.getKind() == "Boolean")
-
- self._main_objects = self._feature.selectionList("main_objects")
- self._tool_objects = self._feature.selectionList("tool_objects")
- self._bool_type = self._feature.integer("bool_type")
-
- assert(self._main_objects)
- assert(self._tool_objects)
- assert(self._bool_type)
-
- if not args:
- return
-
- assert(len(args) in (2, 3))
- bool_type, main_objects = args[:2]
-
- self.setBoolType(bool_type)
- self.setMainObjects(main_objects)
-
- if len(args) == 3:
- tool_objects = args[2]
- self.setToolObjects(tool_objects)
-
- self.execute()
- pass
-
- def setMainObjects(self, main_objects):
- """Modify main_objects attribute of the feature.
-
- Args:
- main_objects (list of :class:`model.Selection`): main objects
- """
- self._fillAttribute(self._main_objects, main_objects)
- pass
-
- def setToolObjects(self, tool_objects):
- """Modify tool_objects attribute of the feature.
-
- Args:
- tool_objects (list of :class:`model.Selection`): tool objects
- """
- self._fillAttribute(self._tool_objects, tool_objects)
- pass
-
- def setBoolType(self, bool_type):
- """Modify bool_type attribute of the feature.
-
- Args:
- bool_type (integer): type of operation
-
- Available types:
-
- * GeomAlgoAPI_Boolean.BOOL_FUSE
- * GeomAlgoAPI_Boolean.BOOL_CUT
- * GeomAlgoAPI_Boolean.BOOL_COMMON
- """
- self._fillAttribute(self._bool_type, bool_type)
- pass
-
- def result(self):
- """F.result() -> list of Selection objects"""
- return [Selection(result, result.shape()) for result in (self.firstResult(),)]
+++ /dev/null
-"""Extrusion Interface
-Author: Daniel Brunier-Coulin with contribution by Mikhail Ponikarov
- and Sergey Pokhodenko
-Copyright (C) 2014-20xx CEA/DEN, EDF R&D
-"""
-
-from model.roots import Interface
-from model import Selection
-
-def addExtrusion(part, *args):
- """Add an Extrusion feature to the Part and return Extrusion.
-
- This function has *3 signatures*:
-
- .. function:: addExtrusion(base, size)
-
- Arguments:
- base(str, Sketch or list): base object(s)
- size(double): size of the extrusion, the side is decided by the sign
-
- .. function:: addExtrusion(base, to_size, from_size)
-
- Arguments:
- base(str, Sketch or list): base object(s)
- to_size(double): upper size of the extrusion
- from_size(double): lower size of the extrusion
-
- .. function:: addExtrusion(base, to_object, to_offset, from_object, from_offset)
-
- Arguments:
- base(str, Sketch or list): base object(s)
- to_object(plane): upper plane
- to_offset(double): offset from upper object
- from_object(plane): lower plane
- from_offset(double): offset from lower plane
-
- In all three cases the function returns an extrusion object
-
- Returns:
- Extrusion: extrusion object
- """
- assert(args)
- feature = part.addFeature("Extrusion")
- return Extrusion(feature, *args)
-
-
-class Extrusion(Interface):
- """Interface class for Extrusion feature.
- """
-
- def __init__(self, feature, *args):
- """
- Extrusion(feature) -> feature interface without initialization
- Extrusion(feature, base, size) ->
- feature interface initialized from arguments:
- - base -- name, sketch or list of names and sketches
- - size -- if positive -> to_size, if negative -> from_size
- Extrusion(feature, base, to_size, from_size) ->
- feature interface initialized from arguments:
- - base -- name, sketch or list of names and sketches
- - to_size -- upper size
- - from_size -- lower size
- Extrusion(feature, base, to_object, to_offset, from_object, from_offset) ->
- feature interface initialized from arguments:
- - base -- name, sketch or list of names and sketches
- - to_object -- upper object (plane)
- - to_offset -- offset from upper object
- - from_object -- lower object (plane)
- - from_offset -- offset from lower object
- """
- Interface.__init__(self, feature)
- assert(self._feature.getKind() == "Extrusion")
-
- self._base = self._feature.data().selectionList("base")
- self._CreationMethod = self._feature.string("CreationMethod")
- self._to_size = self._feature.data().real("to_size")
- self._from_size = self._feature.data().real("from_size")
- self._to_object = self._feature.data().selection("to_object")
- self._to_offset = self._feature.data().real("to_offset")
- self._from_object = self._feature.data().selection("from_object")
- self._from_offset = self._feature.data().real("from_offset")
-
- assert(self._base)
- assert(self._CreationMethod)
- assert(self._to_size)
- assert(self._from_size)
- assert(self._to_object)
- assert(self._to_offset)
- assert(self._from_object)
- assert(self._from_offset)
-
- if not args:
- return
-
- assert(len(args) in (2, 3, 5))
- base = args[0]
- args = args[1:]
-
- self.setBase(base)
-
- if len(args) == 4:
- self.setPlanesAndOffsets(*args)
- elif len(args) == 2:
- self.setSizes(*args)
- elif len(args) == 1:
- self.setSize(args[0])
-
- self.execute()
- pass
-
- def __clear(self):
- self._CreationMethod.setValue("BySizes")
- self._fillAttribute(self._to_size, 0)
- self._fillAttribute(self._from_size, 0)
- self._fillAttribute(self._to_object, None)
- self._fillAttribute(self._to_offset, 0)
- self._fillAttribute(self._from_object, None)
- self._fillAttribute(self._from_offset, 0)
- pass
-
- def setBase(self, base):
- """Modify base attribute of the feature.
-
- See __init__.
- """
- self._fillAttribute(self._base, base)
- pass
-
- def setSizes(self, to_size, from_size, to_size_text="", from_size_text=""):
- """Modify the to_size, from_size attributes of the feature.
-
- See __init__.
- """
- # MPV: with "clear" calling here the extrusion all the time becomes modificed (height is set to
- # zero and then to actual value, but this function is used in macro Bax, that causes "modified"
- # values without changes that causes cyclic dependency
- #self.__clear()
- self._fillAttribute(self._CreationMethod, "BySizes")
- if to_size_text == "":
- self._fillAttribute(self._to_size, to_size)
- else:
- self._fillAttribute(self._to_size, to_size_text)
-
- if from_size_text == "":
- self._fillAttribute(self._from_size, from_size)
- else:
- self._fillAttribute(self._to_size, from_size_text)
- pass
-
- def setSize(self, size, text=""):
- """Modify the size of the feature.
-
- If size is positive then initialize to_size with size.
- If size is negative then initialize from_size with -size.
- """
- to_size, from_size = 0, 0
- to_size_text, from_size_text = "", ""
- if size >= 0:
- to_size = size
- to_size_text = text
- else:
- from_size = -size
- from_size_text = text
-
- self.setSizes(to_size, from_size, to_size_text, from_size_text)
-
- pass
-
- def setPlanesAndOffsets(self, to_object, to_offset,
- from_object, from_offset):
- """Modify planes and offsets attributes of the feature.
-
- See __init__.
- """
- self.__clear()
- self._CreationMethod.setValue("ByPlanesAndOffsets")
- self._fillAttribute(self._to_object, to_object)
- self._fillAttribute(self._to_offset, to_offset)
- self._fillAttribute(self._from_object, from_object)
- self._fillAttribute(self._from_offset, from_offset)
- pass
-
- def result(self):
- """F.result() -> list of Selection objects"""
- return [Selection(result, result.shape()) for result in (self.firstResult(),)]
+++ /dev/null
-"""ExtrusionCut and ExtrusionFuse Interfaces
-Author: Sergey Pokhodenko
-Copyright (C) 2014-20xx CEA/DEN, EDF R&D
-"""
-
-from .roots import CompositeBoolean
-
-
-def addExtrusionCut(part, *args):
- """Add an ExtrusionCut feature to the Part.
-
- .. function:: addExtrusionCut(part, sketch, sketch_selection, boolean_objects, to_size, from_size)
-
- Args:
- part (ModelAPI_Document): part document
- sketch (ModelAPI_Object): sketch feature
- sketch_selection (Selection): sketch objects
- boolean_objects (list of Selection): boolean objects
- to_size (double): upper size of the extrusion
- from_size (double): lower size of the extrusion
-
- .. function:: addExtrusionCut(part, sketch, sketch_selection, boolean_objects, to_object, to_offset, from_object, from_offset)
-
- Args:
- part (ModelAPI_Document): part document
- sketch (ModelAPI_Object): sketch feature
- sketch_selection (Selection): sketch objects
- boolean_objects (list of Selection): boolean objects
- to_object (Selection): upper plane
- to_offset (double): offset from upper plane
- from_object (Selection): lower plane
- from_offset (double): offset from lower plane
-
- Returns:
- ExtrusionBoolean: extrusion boolean object
- """
- assert(args)
- feature = part.addFeature("ExtrusionCut")
- return ExtrusionBoolean(feature, *args)
-
-def addExtrusionFuse(part, *args):
- """Add an ExtrusionFuse feature to the Part and return ExtrusionBoolean.
-
- .. function:: addExtrusionFuse(part, sketch, sketch_selection, boolean_objects, to_size, from_size)
-
- Args:
- part (ModelAPI_Document): part document
- sketch (ModelAPI_Object): sketch feature
- sketch_selection (Selection): sketch objects
- boolean_objects (list of Selection): boolean objects
- to_size (double): upper size of the extrusion
- from_size (double): lower size of the extrusion
-
- .. function:: addExtrusionFuse(part, sketch, sketch_selection, boolean_objects, to_object, to_offset, from_object, from_offset)
-
- Args:
- part (ModelAPI_Document): part document
- sketch (ModelAPI_Object): sketch feature
- sketch_selection (Selection): sketch objects
- boolean_objects (list of Selection): boolean objects
- to_object (Selection): upper plane
- to_offset (double): offset from upper plane
- from_object (Selection): lower plane
- from_offset (double): offset from lower plane
-
- Returns:
- ExtrusionBoolean: extrusion boolean object
- """
- assert(args)
- feature = part.addFeature("ExtrusionFuse")
- return ExtrusionBoolean(feature, *args)
-
-
-class ExtrusionBoolean(CompositeBoolean):
- """Interface class for ExtrusionBoolean features.
-
- Supported features:
-
- * ExtrusionCut
- * ExtrusionFuse
-
- .. function:: ExtrusionBoolean(feature)
-
- Create interface for the feature without initialization.
-
- .. function:: ExtrusionBoolean(feature, sketch, sketch_selection, boolean_objects, to_size, from_size)
-
- Create interface for the feature and initialize the feature with arguments.
-
- .. function:: ExtrusionBoolean(feature, sketch, sketch_selection, boolean_objects, to_object, to_offset, from_object, from_offset)
-
- Create interface for the feature and initialize the feature with arguments.
- """
-
- def __init__(self, feature, *args):
- """x.__init__(...) initializes x; see x.__class__.__doc__ for signature"""
- CompositeBoolean.__init__(self, feature, *args[:3])
- args = args[3:]
-
- self._CreationMethod = self._feature.string("CreationMethod")
- self._to_size = self._feature.data().real("to_size")
- self._from_size = self._feature.data().real("from_size")
- self._to_object = self._feature.data().selection("to_object")
- self._to_offset = self._feature.data().real("to_offset")
- self._from_object = self._feature.data().selection("from_object")
- self._from_offset = self._feature.data().real("from_offset")
-
- assert(self._CreationMethod)
- assert(self._to_size)
- assert(self._from_size)
- assert(self._to_object)
- assert(self._to_offset)
- assert(self._from_object)
- assert(self._from_offset)
-
- if not args:
- return
-
- assert(len(args) in (2, 4))
- if len(args) == 4:
- self.setPlanesAndOffsets(*args)
- elif len(args) == 2:
- self.setSizes(*args)
-
- self.execute()
- pass
-
- def __clear(self):
- self._CreationMethod.setValue("BySizes")
- self._fillAttribute(self._to_size, 0)
- self._fillAttribute(self._from_size, 0)
- self._fillAttribute(self._to_object, None)
- self._fillAttribute(self._to_offset, 0)
- self._fillAttribute(self._from_object, None)
- self._fillAttribute(self._from_offset, 0)
- pass
-
- def setSizes(self, to_size, from_size):
- """Modify the to_size, from_size attributes of the feature.
-
- See __init__.
- """
- self.__clear()
- self._CreationMethod.setValue("BySizes")
- self._fillAttribute(self._to_size, to_size)
- self._fillAttribute(self._from_size, from_size)
- pass
-
- def setPlanesAndOffsets(self, to_object, to_offset,
- from_object, from_offset):
- """Modify planes and offsets attributes of the feature.
-
- See __init__.
- """
- self.__clear()
- self._CreationMethod.setValue("ByPlanesAndOffsets")
- self._fillAttribute(self._to_object, to_object)
- self._fillAttribute(self._to_offset, to_offset)
- self._fillAttribute(self._from_object, from_object)
- self._fillAttribute(self._from_offset, from_offset)
- pass
-
+++ /dev/null
-"""Group Interface
-Author: Sergey Pokhodenko
-Copyright (C) 2014-20xx CEA/DEN, EDF R&D
-"""
-
-from model.roots import Interface
-
-
-def addGroup(part, *args):
- """Add a Group feature to the Part.
-
- .. function:: addGroup(part, group_list)
-
- Args:
- part (ModelAPI_Document): part document
- group_list (list of Selection): list of objects
-
- Returns:
- Group: group object
- """
- assert(args)
- feature = part.addFeature("Group")
- return Group(feature, *args)
-
-
-class Group(Interface):
- """Interface class for Group feature.
-
- .. function:: Group(feature)
-
- Create interface for the feature without initialization.
-
- .. function:: Group(feature, group_list)
-
- Create interface for the feature and initialize the feature with arguments.
- """
-
- def __init__(self, feature, *args):
- """x.__init__(...) initializes x; see x.__class__.__doc__ for signature"""
- Interface.__init__(self, feature)
- assert(self._feature.getKind() == "Group")
-
- self._group_list = self._feature.data().selectionList("group_list")
-
- assert(self._group_list)
-
- if not args:
- return
-
- assert(len(args) == 1)
- self.setGroupList(args[0])
-
- self.execute()
- pass
-
- def setGroupList(self, main_objects):
- """Modify group_list attribute of the feature.
-
- See __init__.
- """
- self._fillAttribute(self._group_list, group_list)
- pass
+++ /dev/null
-"""Partition Interface
-Author: Sergey Pokhodenko
-Copyright (C) 2014-20xx CEA/DEN, EDF R&D
-"""
-
-from model.roots import Interface
-
-
-def addPartition(part, *args):
- """Add a Partition feature to the Part.
-
- .. function:: addPartition(part, main_objects, tool_objects, partition_combine)
-
- Args:
- part (ModelAPI_Document): part document
- main_objects (list of Selection): main objects
- tool_objects (list of Selection): tool objects
- partition_combine (boolean):
- If True combines all results to one. If False builds separate result for each object.
-
- Returns:
- Partition: partition object
- """
- assert(len(args) > 0 and args[0] is not None)
- feature = part.addFeature("Partition")
- return Partition(feature, *args)
-
-
-class Partition(Interface):
- """Interface class for Partition feature.
-
- .. function:: Partition(feature)
-
- Create interface for the feature without initialization.
-
- .. function:: Partition(feature, main_objects, tool_objects, partition_combine)
-
- Create interface for the feature and initialize the feature with arguments.
- """
-
- def __init__(self, feature, *args):
- """x.__init__(...) initializes x; see x.__class__.__doc__ for signature"""
- Interface.__init__(self, feature)
- assert(self._feature.getKind() == "Partition")
-
- self._main_objects = self._feature.data().selectionList("main_objects")
- self._tool_objects = self._feature.data().selectionList("tool_objects")
- self._partition_combine = self._feature.data().boolean("partition_combine")
-
- assert(self._main_objects)
- assert(self._tool_objects)
- assert(self._partition_combine)
-
- if not args:
- return
-
- assert(len(args) == 3)
- main_objects, tool_objects, partition_combine = args
-
- self.setMainObjects(main_objects)
- self.setToolObjects(tool_objects)
- self.setPartitionCombine(partition_combine)
-
- self.execute()
- pass
-
- def setMainObjects(self, main_objects):
- """Modify base attribute of the feature.
-
- See __init__.
- """
- self._fillAttribute(self._main_objects, main_objects)
- pass
-
- def setToolObjects(self, tool_objects):
- """Modify the to_size, from_size attributes of the feature.
-
- See __init__.
- """
- self._fillAttribute(self._tool_objects, tool_objects)
- pass
-
- def setPartitionCombine(self, partition_combine):
- """Modify planes and offsets attributes of the feature.
-
- See __init__.
- """
- self._fillAttribute(self._partition_combine, partition_combine)
- pass
+++ /dev/null
-"""Placement Interface
-Author: Sergey Pokhodenko
-Copyright (C) 2014-20xx CEA/DEN, EDF R&D
-"""
-
-from model.roots import Interface
-
-
-def addPlacement(part, *args):
- """Add a Placement feature to the Part.
-
- .. function:: addPlacement(part, objects_list, start_shape, end_shape, reverse_direction, centering)
-
- Args:
- part (ModelAPI_Document): part document
- objects_list (list of Selection): solid objects
- start_shape (Selection): start face, edge or vertex
- end_shape (Selection): end face, edge or vertex
- reverse_direction (boolean): reverse placement direction
- centering (boolean): center faces under placement
-
- Returns:
- Placement: placement object
- """
- assert(args)
- feature = part.addFeature("Placement")
- return Placement(feature, *args)
-
-
-class Placement(Interface):
- """Interface class for Placement feature.
-
- .. function:: Placement(feature)
-
- Create interface for the feature without initialization.
-
- .. function:: Placement(feature, objects_list, start_shape, end_shape, reverse_direction, centering)
-
- Create interface for the feature and initialize the feature with arguments.
- """
-
- def __init__(self, feature, *args):
- """x.__init__(...) initializes x; see x.__class__.__doc__ for signature"""
- Interface.__init__(self, feature)
- assert(self._feature.getKind() == "Placement")
-
- self._objects_list = self._feature.data().selectionList("placement_objects_list")
- self._start_shape = self._feature.data().selection("placement_start_shape")
- self._end_shape = self._feature.data().selection("placement_end_shape")
- self._reverse_direction = self._feature.data().boolean("placement_reverse_direction")
- self._centering = self._feature.data().boolean("placement_centering")
-
- assert(self._objects_list)
- assert(self._start_shape)
- assert(self._end_shape)
- assert(self._reverse_direction)
- assert(self._centering)
-
- if not args:
- return
-
- assert(len(args) == 5)
- self.setObjectList(args[0])
- self.setStartShape(args[1])
- self.setEndShape(args[2])
- self.setReverseDirection(args[3])
- self.setCentering(args[4])
-
- self.execute()
- pass
-
- def setObjectList(self, objects_list):
- """Modify placement_objects_list attribute of the feature.
-
- See __init__.
- """
- self._fillAttribute(self._objects_list, objects_list)
- pass
-
- def setStartShape(self, start_shape):
- """Modify start_shape attribute of the feature.
-
- See __init__.
- """
- self._fillAttribute(self._start_shape, start_shape)
- pass
-
- def setEndShape(self, end_shape):
- """Modify end_shape attribute of the feature.
-
- See __init__.
- """
- self._fillAttribute(self._end_shape, end_shape)
- pass
-
- def setReverseDirection(self, reverse_direction):
- """Modify reverse_direction attribute of the feature.
-
- See __init__.
- """
- self._fillAttribute(self._reverse_direction, reverse_direction)
- pass
-
- def setCentering(self, centering):
- """Modify centering attribute of the feature.
-
- See __init__.
- """
- self._fillAttribute(self._centering, centering)
- pass
+++ /dev/null
-"""Revolution Interface
-Author: Sergey Pokhodenko
-Copyright (C) 2014-20xx CEA/DEN, EDF R&D
-"""
-
-from model.roots import Interface
-
-
-def addRevolution(part, *args):
- """Add a Revolution feature to the Part.
-
- .. function:: addRevolution(part, base, axis_object, to_angle, from_angle)
-
- Args:
- part (ModelAPI_Document): part document
- base (list of Selection): base objects
- axis_object (Selection): axis object
- to_angle (double): to angle
- from_angle (double): from angle
-
- .. function:: addRevolution(feature, base, axis_object, to_object, to_offset, from_object, from_offset)
-
- Args:
- part (ModelAPI_Document): part document
- base (list of Selection): base objects
- axis_object (Selection): axis object
- to_object (plane): upper plane
- to_offset (double): offset from upper object
- from_object (plane): lower plane
- from_offset (double): offset from lower plane
-
- Returns:
- Revolution: revolution object
- """
- assert(len(args) > 0 and args[0] is not None)
- feature = part.addFeature("Revolution")
- return Revolution(feature, *args)
-
-
-class Revolution(Interface):
- """Interface class for Revolution features.
-
- .. function:: Revolution(feature)
-
- Create interface for the feature without initialization.
-
- .. function:: Revolution(feature, base, axis_object, to_angle, from_angle)
-
- Create interface for the feature and initialize the feature with arguments.
-
- .. function:: Revolution(feature, base, axis_object, to_object, to_offset, from_object, from_offset)
-
- Create interface for the feature and initialize the feature with arguments.
- """
-
- def __init__(self, feature, *args):
- """x.__init__(...) initializes x; see x.__class__.__doc__ for signature"""
- Interface.__init__(self, feature)
- assert(self._feature.getKind() == "Revolution")
-
- self._base = self._feature.data().selectionList("base")
- self._axis_object = self._feature.data().selection("axis_object")
- self._CreationMethod = self._feature.string("CreationMethod")
- self._to_angle = self._feature.data().real("to_angle")
- self._from_angle = self._feature.data().real("from_angle")
- self._to_object = self._feature.data().selection("to_object")
- self._to_offset = self._feature.data().real("to_offset")
- self._from_object = self._feature.data().selection("from_object")
- self._from_offset = self._feature.data().real("from_offset")
-
- assert(self._base)
- assert(self._axis_object)
- assert(self._CreationMethod)
- assert(self._to_angle)
- assert(self._from_angle)
- assert(self._to_object)
- assert(self._to_offset)
- assert(self._from_object)
- assert(self._from_offset)
-
- if not args:
- return
-
- assert(len(args) in (4, 6))
-
- base, axis_object = args[:2]
- args = args[2:]
-
- self.setBase(base)
- self.setAxisObject(axis_object)
-
- if len(args) == 4:
- self.setPlanesAndOffsets(*args)
- elif len(args) == 2:
- self.setAngles(*args)
-
- self.execute()
- pass
-
- def __clear(self):
- self._CreationMethod.setValue("ByAngles")
- self._fillAttribute(self._to_angle, 0)
- self._fillAttribute(self._from_angle, 0)
- self._fillAttribute(self._to_object, None)
- self._fillAttribute(self._to_offset, 0)
- self._fillAttribute(self._from_object, None)
- self._fillAttribute(self._from_offset, 0)
- pass
-
- def setBase(self, base):
- """Modify base attribute of the feature.
-
- See __init__.
- """
- self._fillAttribute(self._base, base)
- pass
-
- def setAxisObject(self, axis_object):
- """Modify axis_object attribute of the feature.
-
- See __init__.
- """
- self._fillAttribute(self._axis_object, axis_object)
- pass
-
- def setAngles(self, to_angle, from_angle):
- """Modify the to_angle, from_angle attributes of the feature.
-
- See __init__.
- """
- self.__clear()
- self._CreationMethod.setValue("ByAngles")
- self._fillAttribute(self._to_angle, to_angle)
- self._fillAttribute(self._from_angle, from_angle)
- pass
-
- def setPlanesAndOffsets(self, to_object, to_offset,
- from_object, from_offset):
- """Modify planes and offsets attributes of the feature.
-
- See __init__.
- """
- self.__clear()
- self._CreationMethod.setValue("ByPlanesAndOffsets")
- self._fillAttribute(self._to_object, to_object)
- self._fillAttribute(self._to_offset, to_offset)
- self._fillAttribute(self._from_object, from_object)
- self._fillAttribute(self._from_offset, from_offset)
- pass
+++ /dev/null
-"""RevolutionCut and RevolutionFuse Interface
-Author: Sergey Pokhodenko
-Copyright (C) 2014-20xx CEA/DEN, EDF R&D
-"""
-
-from .roots import CompositeBoolean
-
-
-def addRevolutionCut(part, *args):
- """Add a RevolutionCut feature to the Part.
-
- .. function:: addRevolutionCut(part, sketch, sketch_selection, boolean_objects, axis_object, to_angle, from_angle)
-
- Args:
- part (ModelAPI_Document): part document
- sketch (ModelAPI_Object): sketch feature
- sketch_selection (Selection): sketch objects
- boolean_objects (list of Selection): boolean objects
- axis_object (Selection): axis object
- to_size (double): upper size of the extrusion
- from_size (double): lower size of the extrusion
-
- .. function:: addRevolutionCut(part, sketch, sketch_selection, boolean_objects, axis_object, to_object, to_offset, from_object, from_offset)
-
- Args:
- part (ModelAPI_Document): part document
- sketch (ModelAPI_Object): sketch feature
- sketch_selection (Selection): sketch objects
- boolean_objects (list of Selection): boolean objects
- axis_object (Selection): axis object
- to_object (Selection): upper plane
- to_offset (double): offset from upper plane
- from_object (Selection): lower plane
- from_offset (double): offset from lower plane
-
- Returns:
- RevolutionBoolean: revolution boolean object
- """
- assert(args)
- feature = part.addFeature("RevolutionCut")
- return RevolutionBoolean(feature, *args)
-
-def addRevolutionFuse(part, *args):
- """Add a RevolutionFuse feature to the Part.
-
- .. function:: addRevolutionFuse(part, sketch, sketch_selection, boolean_objects, axis_object, to_angle, from_angle)
-
- Args:
- part (ModelAPI_Document): part document
- sketch (ModelAPI_Object): sketch feature
- sketch_selection (Selection): sketch objects
- boolean_objects (list of Selection): boolean objects
- axis_object (Selection): axis object
- to_size (double): upper size of the extrusion
- from_size (double): lower size of the extrusion
-
- .. function:: addRevolutionFuse(part, sketch, sketch_selection, boolean_objects, axis_object, to_object, to_offset, from_object, from_offset)
-
- Args:
- part (ModelAPI_Document): part document
- sketch (ModelAPI_Object): sketch feature
- sketch_selection (Selection): sketch objects
- boolean_objects (list of Selection): boolean objects
- axis_object (Selection): axis object
- to_object (Selection): upper plane
- to_offset (double): offset from upper plane
- from_object (Selection): lower plane
- from_offset (double): offset from lower plane
-
-
- Pass all args to RevolutionFuse __init__ function.
-
- Returns:
- RevolutionBoolean: revolution boolean object
- """
- assert(args)
- feature = part.addFeature("RevolutionFuse")
- return RevolutionBoolean(feature, *args)
-
-
-class RevolutionBoolean(CompositeBoolean):
- """Interface class for RevolutionBoolean features.
-
- Supported features:
-
- * RevolutionCut
- * RevolutionFuse
-
- .. function:: RevolutionBoolean(feature)
-
- Create interface for the feature without initialization.
-
- .. function:: RevolutionBoolean(feature, sketch, sketch_selection, boolean_objects, axis_object, to_angle, from_angle)
-
- Create interface for the feature and initialize the feature with arguments.
-
- .. function:: RevolutionBoolean(feature, sketch, sketch_selection, boolean_objects, axis_object, to_object, to_offset, from_object, from_offset)
-
- Create interface for the feature and initialize the feature with arguments.
- """
-
- def __init__(self, feature, *args):
- """x.__init__(...) initializes x; see x.__class__.__doc__ for signature"""
- CompositeBoolean.__init__(self, feature, *args[:3])
- args = args[3:]
-
- self._axis_object = self._feature.data().selection("axis_object")
- self._CreationMethod = self._feature.string("CreationMethod")
- self._to_angle = self._feature.data().real("to_angle")
- self._from_angle = self._feature.data().real("from_angle")
- self._to_object = self._feature.data().selection("to_object")
- self._to_offset = self._feature.data().real("to_offset")
- self._from_object = self._feature.data().selection("from_object")
- self._from_offset = self._feature.data().real("from_offset")
-
- assert(self._axis_object)
- assert(self._CreationMethod)
- assert(self._to_angle)
- assert(self._from_angle)
- assert(self._to_object)
- assert(self._to_offset)
- assert(self._from_object)
- assert(self._from_offset)
-
- if not args:
- return
-
- assert(len(args) in (3, 5))
- axis_object = args[0]
- args = args[1:]
-
- self.setAxisObject(axis_object)
-
- if len(args) == 4:
- self.setPlanesAndOffsets(*args)
- elif len(args) == 2:
- self.setAngles(*args)
-
- self.execute()
- pass
-
- def __clear(self):
- self._CreationMethod.setValue("ByAngles")
- self._fillAttribute(self._to_angle, 0)
- self._fillAttribute(self._from_angle, 0)
- self._fillAttribute(self._to_object, None)
- self._fillAttribute(self._to_offset, 0)
- self._fillAttribute(self._from_object, None)
- self._fillAttribute(self._from_offset, 0)
- pass
-
- def setAxisObject(self, axis_object):
- """Modify axis_object attribute of the feature.
-
- See __init__.
- """
- self._fillAttribute(self._axis_object, axis_object)
- pass
-
- def setAngles(self, to_angle, from_angle):
- """Modify the to_angle, from_angle attributes of the feature.
-
- See __init__.
- """
- self.__clear()
- self._CreationMethod.setValue("ByAngles")
- self._fillAttribute(self._to_angle, to_angle)
- self._fillAttribute(self._from_angle, from_angle)
- pass
-
- def setPlanesAndOffsets(self, to_object, to_offset,
- from_object, from_offset):
- """Modify planes and offsets attributes of the feature.
-
- See __init__.
- """
- self.__clear()
- self._CreationMethod.setValue("ByPlanesAndOffsets")
- self._fillAttribute(self._to_object, to_object)
- self._fillAttribute(self._to_offset, to_offset)
- self._fillAttribute(self._from_object, from_object)
- self._fillAttribute(self._from_offset, from_offset)
- pass
-
+++ /dev/null
-
-from model.roots import Interface
-
-
-class CompositeBoolean(Interface):
- """Interface class for CompositeBoolean features.
-
- CompositeBoolean(feature) -> feature interface without initialization
- CompositeBoolean(feature, sketch, sketch_selection, boolean_objects) ->
- feature interface initialized from arguments:
- - sketch
- - sketch_selection
- - boolean_objects
- """
-
- def __init__(self, feature, *args):
- """x.__init__(...) initializes x; see x.__class__.__doc__ for signature"""
- Interface.__init__(self, feature)
-
- self._sketch = self._feature.reference("sketch")
- self._sketch_selection = self._feature.selection("sketch_selection")
- self._boolean_objects = self._feature.selectionList("boolean_objects")
-
- assert(self._sketch)
- assert(self._sketch_selection)
- assert(self._boolean_objects)
-
- if not args:
- return
-
- assert(len(args) == 3)
- sketch, sketch_selection, boolean_objects = args
-
- self.setSketch(sketch)
- self.setSketchSelection(sketch_selection)
- self.setBooleanObjects(boolean_objects)
- pass
-
- def setSketch(self, sketch):
- """Modify sketch attribute"""
- self._fillAttribute(self._sketch, sketch)
- pass
-
- def setSketchSelection(self, sketch_selection):
- """Modify sketch_selection attribute"""
- self._fillAttribute(self._sketch_selection, sketch_selection)
- pass
-
- def setBooleanObjects(self, boolean_objects):
- """Modify boolean_objects attribute"""
- self._fillAttribute(self._boolean_objects, boolean_objects)
- pass
-
-
-class CompositeSketch(Interface):
- """Interface class for CompositeSketch features.
-
- CompositeSketch(feature) -> feature interface without initialization
- CompositeSketch(feature, sketch, sketch_selection) ->
- feature interface initialized from arguments:
- - sketch
- - sketch_selection
- """
-
-
- def __init__(self, feature, *args):
- """x.__init__(...) initializes x; see x.__class__.__doc__ for signature"""
- Interface.__init__(self, feature)
-
- self._sketch = self._feature.reference("sketch")
- self._sketch_selection = self._feature.selection("sketch_selection")
-
- assert(self._sketch)
- assert(self._sketch_selection)
-
- if not args:
- return
-
- assert(len(args) == 2)
- sketch, sketch_selection = args
-
- self.setSketch(sketch)
- self.setSketchSelection(sketch_selection)
- pass
-
- def setSketch(self, sketch):
- """Modify sketch attribute"""
- self._fillAttribute(self._sketch, sketch)
- pass
-
- def setSketchSelection(self, sketch_selection):
- """Modify sketch_selection attribute"""
- self._fillAttribute(self._sketch_selection, sketch_selection)
- pass
+++ /dev/null
-"""Rotation Interface
-Author: Sergey Pokhodenko
-Copyright (C) 2014-20xx CEA/DEN, EDF R&D
-"""
-
-from model.roots import Interface
-
-
-def addRotation(part, *args):
- """Add a Rotation feature to the Part.
-
- .. function:: addRotation(part, main_objects, axis_object, angle)
-
- Args:
- part (ModelAPI_Document): part document
- main_objects (list of Selection): main objects
- axis_object (list of Selection): axis object
- angle (double): angle
-
- Returns:
- Rotation: rotation object
- """
- assert(args)
- feature = part.addFeature("Rotation")
- return Rotation(feature, *args)
-
-
-class Rotation(Interface):
- """Interface class for Rotation features.
-
- .. function:: Rotation(feature)
-
- Create interface for the feature without initialization.
-
- .. function:: Rotation(feature, main_objects, axis_object, angle)
-
- Create interface for the feature and initialize the feature with arguments.
- """
-
- def __init__(self, feature, *args):
- """x.__init__(...) initializes x; see x.__class__.__doc__ for signature"""
- Interface.__init__(self, feature)
- assert(self._feature.getKind() == "Rotation")
-
- self._main_objects = self._feature.data().selectionList("main_objects")
- self._axis_object = self._feature.data().selection("axis_object")
- self._angle = self._feature.data().real("angle")
-
- assert(self._main_objects)
- assert(self._axis_object)
- assert(self._angle)
-
- if not args:
- return
-
- assert(len(args) == 3)
- self.setMainObjects(args[0])
- self.setAxisObject(args[1])
- self.setAngle(args[2])
-
- self.execute()
- pass
-
- def setMainObjects(self, main_objects):
- """Modify main_objects attribute of the feature.
-
- See __init__.
- """
- self._fillAttribute(self._main_objects, main_objects)
- pass
-
- def setAxisObject(self, axis_object):
- """Modify axis_object attribute of the feature.
-
- See __init__.
- """
- self._fillAttribute(self._axis_object, axis_object)
- pass
-
- def setAngle(self, angle):
- """Modify angle attribute of the feature.
-
- See __init__.
- """
- self._fillAttribute(self._angle, angle)
- pass
+++ /dev/null
-"""Translation Interface
-Author: Sergey Pokhodenko
-Copyright (C) 2014-20xx CEA/DEN, EDF R&D
-"""
-
-from model.roots import Interface
-
-
-def addTranslation(part, *args):
- """Add a Translation feature to the Part.
-
- .. function:: addTranslation(part, main_objects, axis_object, distance)
-
- Args:
- part (ModelAPI_Document): part document
- main_objects (list of Selection): main objects
- axis_object (Selection): axis objects
- distance (double): distance
-
- Returns:
- Translation: translation object
- """
- assert(args)
- feature = part.addFeature("Translation")
- return Translation(feature, *args)
-
-
-class Translation(Interface):
- """Interface class for Translation features.
-
- .. function:: Translation(feature)
-
- Create interface for the feature without initialization.
-
- .. function:: Translation(feature, main_objects, axis_object, distance)
-
- Create interface for the feature and initialize the feature with arguments.
- """
-
- def __init__(self, feature, *args):
- """x.__init__(...) initializes x; see x.__class__.__doc__ for signature"""
- Interface.__init__(self, feature)
- assert(self._feature.getKind() == "Translation")
-
- self._main_objects = self._feature.data().selectionList("main_objects")
- self._axis_object = self._feature.data().selection("axis_object")
- self._distance = self._feature.data().real("distance")
-
- assert(self._main_objects)
- assert(self._axis_object)
- assert(self._distance)
-
- if not args:
- return
-
- assert(len(args) == 3)
- self.setMainObjects(args[0])
- self.setAxisObject(args[1])
- self.setDistance(args[2])
-
- self.execute()
- pass
-
- def setMainObjects(self, main_objects):
- """Modify main_objects attribute of the feature.
-
- See __init__.
- """
- self._fillAttribute(self._main_objects, main_objects)
- pass
-
- def setAxisObject(self, axis_object):
- """Modify axis_object attribute of the feature.
-
- See __init__.
- """
- self._fillAttribute(self._axis_object, axis_object)
- pass
-
- def setDistance(self, distance):
- """Modify distance attribute of the feature.
-
- See __init__.
- """
- self._fillAttribute(self._distance, distance)
- pass
+++ /dev/null
-"""Parameter Interface
-Author: Sergey Pokhodenko
-Copyright (C) 2014-20xx CEA/DEN, EDF R&D
-"""
-
-from model.roots import Interface
-
-
-def addParameter(part, *args):
- """Add a Parameter feature to the Part and return Parameter.
-
- .. function:: addParameter(part, variable, expression)
-
- Args:
- part (ModelAPI_Document): part document
- variable (string): variable name
- expression (string): Python expression
-
- Returns:
- Parameter: parameter object
-
- Pass all args to Parameter __init__ function.
- """
- assert(args)
- feature = part.addFeature("Parameter")
- return Parameter(feature, *args)
-
-
-class Parameter(Interface):
- """Interface class for Parameter feature.
-
- .. function:: Point(feature)
-
- Create interface for the feature without initialization.
-
- .. function:: Point(feature, variable, expression)
-
- Create interface for the feature and initialize the feature with arguments.
- """
-
- def __init__(self, feature, *args):
- """x.__init__(...) initializes x; see x.__class__.__doc__ for signature"""
- Interface.__init__(self, feature)
- assert(self._feature.getKind() == "Parameter")
-
- self._variable = self._feature.string("variable")
- self._expression = self._feature.string("expression")
-
- assert(self._variable)
- assert(self._expression)
-
- if not args:
- return
-
- assert(len(args) == 2)
- self.setName(args[0])
- self.setExpression(args[1])
-
- self.execute()
- pass
-
- def setName(self, name):
- """Modify variable name attribute of the feature.
-
- See __init__.
- """
- self._fillAttribute(self._variable, name)
- pass
-
- def setExpression(self, expression):
- """Modify expression attribute of the feature.
-
- See __init__.
- """
- self._fillAttribute(self._expression, expression)
- pass
+++ /dev/null
-"""Part Feature Interface
-Author: Daniel Brunier-Coulin
-Copyright (C) 2014-20xx CEA/DEN, EDF R&D
-"""
-
-import ModelAPI
-
-from model.roots import Interface
-
-
-def addPart(partset):
- """Add a Part feature to the Part and return Part.
-
- Args:
- partset (ModelAPI_Document): partset document
-
- Returns:
- Part: part object
- """
- feature = partset.addFeature("Part")
- return Part(feature)
-
-def duplicatePart(part):
- """Create a copy of the Part.
-
- Args:
- part (ModelAPI_Document): part document
-
- Returns:
- Part: part object
- """
- feature = part.addFeature("Duplicate")
- feature.execute()
- return Part(feature)
-
-def removePart(part):
- """Remove the Part.
-
- Args:
- part (ModelAPI_Document): part document
- """
- feature = part.addFeature("Remove")
- feature.execute()
-
-
-class Part(Interface):
- """Interface class for Part feature.
-
- .. function:: Part(feature)
-
- Create interface for the feature without initialization.
- """
-
- def __init__(self, feature):
- """x.__init__(...) initializes x; see x.__class__.__doc__ for signature"""
- Interface.__init__(self, feature)
- assert(self._feature.getKind() == "Part")
-
- self.execute()
- pass
-
- def document(self):
- """Returns the Part document created by this feature."""
- result_part = ModelAPI.modelAPI_ResultPart(self._feature.firstResult())
- return result_part.partDoc()
import ModelAPI
import GeomAPI
-import geom # To be removed when gp_Ax3 will be Pythonized
-
-
def moduleDocument ():
"""Return the main document (the Partset) created or open from the Modeler.
+++ /dev/null
-"""Sketch circle feature interface."""
-
-from GeomDataAPI import geomDataAPI_Point2D
-from model.errors import WrongNumberOfArguments
-from model.roots import Interface
-
-class Arc(Interface):
- """Interface to a sketch arc feature."""
- def __init__(self, feature, *args, **kwargs):
- Interface.__init__(self, feature)
- assert(self._feature.getKind() == "SketchArc")
-
- self._center = geomDataAPI_Point2D(
- self._feature.data().attribute("ArcCenter")
- )
- self._start_point = geomDataAPI_Point2D(
- self._feature.data().attribute("ArcStartPoint")
- )
- self._end_point = geomDataAPI_Point2D(
- self._feature.data().attribute("ArcEndPoint")
- )
- self._inversed = self._feature.boolean("InversedArc")
- if len(args) == 6:
- self.__createByCoordinates(*args)
- elif len(args) == 3:
- self.__createByPoints(*args)
- else:
- raise WrongNumberOfArguments(
- "Arc takes 3 or 6 arguments (%s given)" % len(args)
- )
- if "inversed" in kwargs:
- self.setInversed(kwargs["inversed"])
- self.execute()
-
-
- ########
- #
- # Getters
- #
- ########
-
-
- def center(self):
- """Return the center point."""
- return self._center
-
- def startPoint(self):
- """Return the start point."""
- return self._start_point
-
- def endPoint(self):
- """Return the end point."""
- return self._end_point
-
- def result(self):
- """Return the arc circular line attribute."""
- return self._feature.lastResult()
-
-
- ########
- #
- # Set methods
- #
- ########
-
- def setCenter(self, x, y):
- """Set arc center."""
- self._center.setValue(x, y)
-
- def setStartPoint(self, x, y):
- """Set start point."""
- self._start_point.setValue(x, y)
-
- def setEndPoint(self, x, y):
- """Set end point value."""
- self._end_point.setValue(x, y)
-
- def setInversed(self, inversed):
- self._fillAttribute(self._inversed, inversed)
-
- ########
- #
- # Private methods
- #
- ########
-
-
- def __createByCoordinates(self, center_x, center_y,
- start_x, start_y,
- end_x, end_y):
- """Create an arc by point coordinates."""
- self.setCenter(center_x, center_y)
- self.setStartPoint(start_x, start_y)
- self.setEndPoint(end_x, end_y)
-
- def __createByPoints(self, center, start, end):
- """Create an arc with point objects."""
- self.setCenter(center.x(), center.y())
- self.setStartPoint(start.x(), start.y())
- self.setEndPoint(end.x(), end.y())
+++ /dev/null
-"""Sketch circle feature interface."""
-
-from GeomDataAPI import geomDataAPI_Point2D
-from model.roots import Interface
-
-class Circle(Interface):
- """Interface for circle feature data manipulation."""
- def __init__(self, feature, *args):
- Interface.__init__(self, feature)
- assert(self._feature.getKind() == "SketchCircle")
-
- self._center = geomDataAPI_Point2D(
- self._feature.data().attribute("CircleCenter")
- )
- self._radius = self._feature.data().real("CircleRadius")
-
- if not args:
- return
-
- if len(args) != 3:
- raise TypeError(
- "Invalid number of arguments, 3 arguments needed (%s given)"
- % len(args)
- )
-
- self.setCenter(args[0], args[1])
- self.setRadius(args[2])
- self.execute()
-
- def setCenter(self, x, y):
- """Set the center of the circle."""
- self._center.setValue(x, y)
-
- def setRadius(self, radius):
- """Set the radius of the circle."""
- self._radius.setValue(radius)
-
- def center(self):
- """Return the center attribute of the circle."""
- return self._center
-
- def radius(self):
- """Return the radius value.
-
- :return: radius
- :rtype: double
- """
- return self._radius.value()
-
- def result(self):
- """Return the cicular line attribute."""
- return self._feature.lastResult()
+++ /dev/null
-
-from model.roots import Interface
-
-class Entity(Interface):
- """Interface for editing of a sketch entity feature."""
-
- def __init__(self, feature):
- Interface.__init__(self, feature)
-
- # Initialize attributes
- self._auxiliary = self._feature.boolean("Auxiliary")
-
- def setAuxiliary(self, a):
- """Set the Auxiliarity."""
- self._auxiliary.setValue(a)
+++ /dev/null
-from GeomDataAPI import geomDataAPI_Point2D
-from model.roots import Interface
-from model.errors import WrongNumberOfArguments
-
-from .entity import Entity
-
-class Line(Entity):
- """Interface for editing of a sketch line feature."""
- def __init__(self, feature, *args):
- Entity.__init__(self, feature)
- assert(self._feature.getKind() == "SketchLine")
-
- # Initialize attributes
- self._start_point = geomDataAPI_Point2D(
- self._feature.data().attribute("StartPoint")
- )
- self._end_point = geomDataAPI_Point2D(
- self._feature.data().attribute("EndPoint")
- )
- self._external = self._feature.selection("External")
-
- # If no arguments are given the attributes of the feature
- # are'nt initialized
- if args is None:
- return
-
- # Set attribute values and execute
- if len(args) == 4:
- self.__createByCoordinates(*args)
- elif len(args) == 2:
- self.__createByPoints(*args)
- elif len(args) == 1:
- self.__createByName(*args)
- else:
- raise WrongNumberOfArguments(
- "Arc takes 1, 2 or 4 arguments (%s given)" % len(args)
- )
- self.execute()
-
- def __createByCoordinates(self, x1, y1, x2, y2):
- self.setStartPoint(x1, y1)
- self.setEndPoint(x2, y2)
-
- def __createByPoints(self, p1, p2):
- self.setStartPoint(p1.x(), p1.y())
- self.setEndPoint(p2.x(), p2.y())
-
- def __createByName(self, name):
- self.setExternal(name)
-
- #######
- #
- # Set methods
- #
- #######
-
- def setStartPoint(self, x, y):
- """Set the start point of the line."""
- self._start_point.setValue(x, y)
-
- def setEndPoint(self, x, y):
- """Set the end point of the line."""
- self._end_point.setValue(x, y)
-
- # TODO : methods below will be removed.
- # Kept until all tests have been updated
- def startPoint(self):
- return self._start_point
-
- def endPoint(self):
- return self._end_point
-
- def setExternal(self, name):
- """Set external edge"""
- self._external.selectSubShape("EDGE", name)
-
- def result(self):
- return self._feature.firstResult()
+++ /dev/null
-"""Sketch point feature interface."""
-
-from GeomDataAPI import geomDataAPI_Point2D
-from ModelAPI import ModelAPI_Feature
-from model.roots import Interface
-from model.errors import FeatureInputInvalid
-
-class Mirror(Interface):
- """Interface on mirror constraint for data manipulation."""
- def __init__(self, feature, mirror_line, *mirror_objects):
- Interface.__init__(self, feature)
- assert(self._feature.getKind() == "SketchConstraintMirror")
-
- self._feature.data().refattr("ConstraintEntityA").setObject(mirror_line)
- self._feature.data().reflist("ConstraintEntityB").clear()
- for object_ in mirror_objects:
- self._feature.data().reflist("ConstraintEntityB").append(object_)
- self._feature.data().reflist("ConstraintMirrorList").append(object_)
- self.execute()
-
- def mirroredObjects(self):
- return self._feature.data().reflist("ConstraintEntityC")
- #feature = ModelAPI_Feature(object_)
- #if feature.getKind() == "SketchCircle":
- #objects.append(Circle(feature))
- #elif feature.getKind() == "SketchLine":
- #objects.append(Line(feature))
- #else:
- #raise TypeError(
- #"%s is not a valid feature type" % feature.getKind()
- #)
-
+++ /dev/null
-"""Sketch point feature interface."""
-
-from GeomDataAPI import geomDataAPI_Point2D
-from model.roots import Interface
-from model.errors import FeatureInputInvalid
-
-class Point(Interface):
- """Interface on point feature for data manipulation."""
- def __init__(self, feature, x, y):
- Interface.__init__(self, feature)
- assert(self._feature.getKind() == "SketchPoint")
-
- # Initialize attributes of the feature
- self._point_data = geomDataAPI_Point2D(
- self._feature.data().attribute("PointCoordindates")
- )
- self.setValue(x, y)
- self.execute()
-
- def setValue(self, x, y):
- """Set point coordinates."""
- self._point_data.setValue(x, y)
-
- def pointData (self):
- """Return the point data."""
- return self._point_data
-
- def result (self):
- """Return the feature result."""
- return self._point_feature.firstResult()
+++ /dev/null
-# Author: Daniel Brunier-Coulin with contribution by Mikhail Ponikarov
-# finalized by Renaud Nedelec and Sergey Pokhodenko
-# Copyright (C) 2014-20xx CEA/DEN, EDF R&D
-
-"""Sketcher interface.
-This interface allows to add a sketch
-in a part or partset.
-The created sketch object provides all the needed methods
-for sketch modification and constraint edition.
-
-Example of code:
-
-.. doctest::
-
- >>> import model
- >>> model.begin()
- >>> partset = model.moduleDocument()
- >>> part = model.addPart(partset).document()
- >>> plane = model.defaultPlane("XOY")
- >>> sketch = model.addSketch(part, plane)
- >>> line = sketch.addLine(0, 0, 0, 1)
- >>> line.endPoint().x()
- 0.0
- >>> line.endPoint().y()
- 1.0
-"""
-
-from ModelAPI import modelAPI_ResultConstruction, featureToCompositeFeature
-from GeomDataAPI import geomDataAPI_Point, geomDataAPI_Dir
-from GeomAlgoAPI import GeomAlgoAPI_SketchBuilder, ShapeList
-
-from model.sketcher.point import Point
-from model.sketcher.line import Line
-from model.sketcher.circle import Circle
-from model.sketcher.arc import Arc
-from model.sketcher.mirror import Mirror
-from model.roots import Interface
-from model.tools import Selection
-
-
-def addSketch(document, plane):
- """Add a sketch to a Part or PartSet.
-
- Arguments:
- document(ModelAPI_Document): part or partset document
- plane(geom.Ax3): plane on wich the sketch is built
-
- Returns:
- Sketch: sketch object
- """
- feature = featureToCompositeFeature(document.addFeature("Sketch"))
- return Sketch(feature, plane)
-
-class Sketch(Interface):
- """Interface class for Sketch feature."""
- def __init__(self, feature, *args):
- """Initialize a 2D Sketch on the given plane.
-
- The plane can be defined either by:
- - a 3D axis system (geom.Ax3),
- - an existing face identified by its topological name.
- """
- Interface.__init__(self, feature)
- assert(self._feature.getKind() == "Sketch")
-
- self._origin = geomDataAPI_Point(
- self._feature.data().attribute("Origin")
- )
- self._dir_x = geomDataAPI_Dir(
- self._feature.data().attribute("DirX")
- )
- self._norm = geomDataAPI_Dir(
- self._feature.data().attribute("Norm")
- )
- self._external = self._feature.data().selection("External")
-
- # If no arguments are given the attributes of the feature
- # are not Initialized
- if args is not None:
- plane = args[0]
- if isinstance(plane, str):
- self.__sketchOnFace(plane)
- else:
- self.__sketchOnPlane(plane)
-
- def __sketchOnPlane(self, plane):
- """Create the sketch on a plane."""
- origin = plane.location()
- normal = plane.direction()
- x_direction = plane.xDirection()
- self._origin.setValue(origin.x(), origin.y(), origin.z())
- self._norm.setValue(normal.x(), normal.y(), normal.z())
- self._dir_x.setValue(x_direction.x(), x_direction.y(), x_direction.z())
-
- def __sketchOnFace(self, name):
- """Initialize the sketch on a face given by its name."""
- self._external.selectSubShape("FACE", name)
-
- #-------------------------------------------------------------
- #
- # Creation of Geometries
- #
- #-------------------------------------------------------------
-
- def addPoint(self, *args):
- """Add a point to the sketch."""
- if not args:
- raise TypeError("No arguments given")
- point_feature = self._feature.addFeature("SketchPoint")
- return Point(point_feature, *args)
-
- def addLine(self, *args):
- """Add a line to the sketch.
-
- .. function:: addLine(name)
- Select an existing line. The line is added to the sketch with a rigid
- constraint (it cannot be modified by the sketch)
-
- Arguments:
- name(str): name of an existing line
-
- .. function:: addLine(start, end)
- Create a line by points
-
- Arguments:
- start(point): start point of the line
- end(point): end point of the line
-
- .. function:: addLine(start_x, start_y, end_x, end_y)
- Create a line by coordinates
-
- Arguments:
- start_x(double): start point x coordinate
- """
- if not args:
- raise TypeError("No arguments given")
- line_feature = self._feature.addFeature("SketchLine")
- line_interface = Line(line_feature, *args)
- # if the line is created by name add a rigid constraint
- # to the created line
- if len(args) == 1 and isinstance(args[0], str):
- constraint = self._feature.addFeature("SketchConstraintRigid")
- constraint.refattr("ConstraintEntityA").setObject(
- line_feature.firstResult()
- )
- return line_interface
-
- def addCircle(self, *args):
- """Add a circle to this Sketch."""
- if not args:
- raise TypeError("No arguments given")
- circle_feature = self._feature.addFeature("SketchCircle")
- return Circle(circle_feature, *args)
-
- def addArc(self, *args, **kwargs):
- """Add an arc of circle to the sketch and return an arc object.
-
- Two different syntaxes are allowed:
-
- .. function:: addArc(center, start, end)
-
- Arguments:
- center (point): center of the arc
- start (point): start point of the arc
- end (point): end point of the arc
-
- .. function:: addArc(center_x, center_y, start_x, start_y, end_x, end_y)
-
- Same as above but with coordinates
-
- Returns:
- Arc: arc object
- Raises:
- TypeError: if no argument is provided
- """
- if not args:
- raise TypeError("No arguments given")
- arc_feature = self._feature.addFeature("SketchArc")
- return Arc(arc_feature, *args, **kwargs)
-
- #-------------------------------------------------------------
- #
- # Creation of Geometrical and Dimensional Constraints
- #
- #-------------------------------------------------------------
-
- def setCoincident(self, p1, p2):
- """Set coincident the two given points and add the corresponding
- constraint to this Sketch."""
- # assert(p1 and p2) NOTE : if an argument is missing python
- # will raise TypeError by itself.
- # It seems better to check only that provided arguments are not
- # None
- if p1 is None or p2 is None:
- raise TypeError("NoneType argument given")
- constraint = self._feature.addFeature("SketchConstraintCoincidence")
- self._fillAttribute(constraint.refattr("ConstraintEntityA"), p1)
- self._fillAttribute(constraint.refattr("ConstraintEntityB"), p2)
- self.execute()
- return constraint
-
- def setParallel(self, l1, l2):
- """Set parallel the two given lines and add the corresponding
- constraint to this Sketch."""
- if l1 is None or l2 is None:
- raise TypeError("NoneType argument given")
- constraint = self._feature.addFeature("SketchConstraintParallel")
- constraint.data().refattr("ConstraintEntityA").setObject(l1)
- constraint.data().refattr("ConstraintEntityB").setObject(l2)
- self.execute()
- return constraint
-
- def setPerpendicular(self, l1, l2):
- """Set perpendicular the two given lines and add the corresponding
- constraint to this Sketch."""
- if l1 is None or l2 is None:
- raise TypeError("NoneType argument given")
- constraint = self._feature.addFeature("SketchConstraintPerpendicular")
- constraint.data().refattr("ConstraintEntityA").setObject(l1)
- constraint.data().refattr("ConstraintEntityB").setObject(l2)
- self.execute()
- return constraint
-
- def setHorizontal(self, line):
- """Set horizontal the given line and add the corresponding
- constraint to this Sketch."""
- if line is None:
- raise TypeError("NoneType argument given")
- constraint = self._feature.addFeature("SketchConstraintHorizontal")
- constraint.data().refattr("ConstraintEntityA").setObject(line)
- self.execute()
- return constraint
-
- def setVertical(self, line):
- """Set vertical the given line and add the corresponding
- constraint to this Sketch."""
- if line is None:
- raise TypeError("NoneType argument given")
- constraint = self._feature.addFeature("SketchConstraintVertical")
- constraint.data().refattr("ConstraintEntityA").setObject(line)
- self.execute()
- return constraint
-
- def setDistance(self, point, line, length):
- """Set the distance between the given point and line, and add
- the corresponding constraint to this Sketch."""
- if point is None or line is None:
- raise TypeError("NoneType argument given")
- constraint = self._feature.addFeature("SketchConstraintDistance")
- if isinstance(line, basestring):
- # Add the edge identified by the given topological name
- # to this Sketch
- line = self.addLine(line).result()
- constraint.data().refattr("ConstraintEntityA").setAttr(point)
- constraint.data().refattr("ConstraintEntityB").setObject(line)
- constraint.data().real("ConstraintValue").setValue(length)
- self.execute()
- return constraint
-
- def setLength(self, line, length):
- """Set the length of the given line and add the corresponding
- constraint to this Sketch."""
- if line is None:
- raise TypeError("NoneType argument given")
- constraint = self._feature.addFeature("SketchConstraintLength")
- constraint.data().refattr("ConstraintEntityA").setObject(line)
- self._fillAttribute(constraint.real("ConstraintValue"), length)
- self.execute()
- return constraint
-
- def setRadius(self, circle, radius):
- """Set the radius of the given circle and add the corresponding
- constraint to this Sketch."""
- constraint = self._feature.addFeature("SketchConstraintRadius")
- self._fillAttribute(constraint.refattr("ConstraintEntityA"), circle)
- self._fillAttribute(constraint.real("ConstraintValue"), radius)
- self.execute()
- return constraint
-
- def setEqual(self, object_1, object_2):
- """Set the radii of two circles or the length of two lines equal.
-
- The corresponding constraint is added to the sketch"""
- constraint = self._feature.addFeature("SketchConstraintEqual")
- constraint.data().refattr("ConstraintEntityA").setObject(object_1)
- constraint.data().refattr("ConstraintEntityB").setObject(object_2)
- self.execute()
- return constraint
-
- def setAngle(self, line_1, line_2, angle):
- """Set the angle between the given 2 lines and add the corresponding
- constraint to the sketch."""
- constraint = self._feature.addFeature("SketchConstraintAngle")
- constraint.data().refattr("ConstraintEntityA").setObject(line_1)
- constraint.data().refattr("ConstraintEntityB").setObject(line_2)
- constraint.data().real("ConstraintValue").setValue(angle)
- self.execute()
- return constraint
-
- def setTangent(self, object_1, object_2):
- """Set a tangential continuity between two objects
- at their coincidence point."""
- if object_1 is None or object_2 is None:
- raise TypeError("NoneType argument given")
- constraint = self._feature.addFeature("SketchConstraintTangent")
- constraint.data().refattr("ConstraintEntityA").setObject(object_1)
- constraint.data().refattr("ConstraintEntityB").setObject(object_2)
- self.execute()
- return constraint
-
- def setFillet(self, *args):
- """Set a fillet constraint between the 2 given lines with the given
- filleting radius."""
- assert(args)
- constraint = self._feature.addFeature("SketchConstraintFillet")
- if len(args) == 3:
- line_1, line_2, radius = args
- constraint.data().refattr("ConstraintEntityA").setObject(line_1)
- constraint.data().reflist("ConstraintEntityB").clear()
- constraint.data().reflist("ConstraintEntityB").append(line_2)
- elif len(args) == 2:
- point, radius = args
- self._fillAttribute(constraint.data().refattrlist("ConstraintEntityA"), [point])
- self._fillAttribute(constraint.real("ConstraintValue"), radius)
- self.execute()
- return constraint
-
- def setRigid(self, object_):
- """Set a rigid constraint on a given object."""
- constraint = self._feature.addFeature("SketchConstraintRigid")
- self._fillAttribute(constraint.refattr("ConstraintEntityA"), object_)
- self.execute()
- return constraint
-
- #-------------------------------------------------------------
- #
- # Transformation constraints
- #
- #-------------------------------------------------------------
-
- def addMirror(self, mirror_line, sketch_objects):
- """Add a mirror transformation of the given objects to the sketch.
-
- This transformation is a constraint.
-
- :return: interface to the constraint
- :rtype: Mirror object
- """
- mirror_constraint = self._feature.addFeature("SketchConstraintMirror")
- mirror_interface = Mirror(mirror_constraint, mirror_line, sketch_objects)
- self.execute()
- return mirror_interface
-
-
- #-------------------------------------------------------------
- #
- # Edition of Dimensional Constraints
- #
- #-------------------------------------------------------------
-
- def setValue(self, constraint, value):
- """Modify the value of the given dimensional constraint."""
- constraint.data().real("ConstraintValue").setValue(value)
-
- #-------------------------------------------------------------
- #
- # Edition of Dimensional Constraints
- #
- #-------------------------------------------------------------
-
- def setText(self, constraint, text):
- """Modify the value of the given dimensional constraint."""
- constraint.data().real("ConstraintValue").setText(text)
-
- #-------------------------------------------------------------
- #
- # Macro functions combining geometry creation and constraints
- #
- #-------------------------------------------------------------
-
- def addPolyline(self, *coords):
- """Add a poly-line to this Sketch.
-
- The end of consecutive segments are defined as coincident.
- """
- c0 = coords[0]
- c1 = coords[1]
- polyline = []
- line_1 = self.addLine(c0, c1)
- polyline.append(line_1)
- # Adding and connecting next lines
- for c2 in coords[2:]:
- line_2 = self.addLine(c1, c2)
- self.setCoincident(line_1.endPoint(), line_2.startPoint())
- polyline.append(line_2)
- c1 = c2
- line_1 = line_2
- return polyline
-
- def addPolygon(self, *coords):
- """Add a polygon to this Sketch.
-
- The end of consecutive segments are defined as coincident.
- """
- pg = self.addPolyline(*coords)
- # Closing the poly-line supposed being defined by at least 3 points
- c0 = coords[0]
- cn = coords[len(coords) - 1]
- ln = self.addLine(cn, c0)
- self.setCoincident(
- pg[len(coords) - 2].endPoint(), ln.startPoint()
- )
- self.setCoincident(
- ln.endPoint(), pg[0].startPoint()
- )
- pg.append(ln)
- return pg
-
- #-------------------------------------------------------------
- #
- # Getters
- #
- #-------------------------------------------------------------
-
- def selectFace(self, *args):
- """Select the geometrical entities of this Sketch on which
- the result Face must be built.
-
- When no entity is given, the face is based on all existing
- geometry of this Sketch.
- """
- if len(args) == 0:
- wire = modelAPI_ResultConstruction(
- self._feature.firstResult()
- ).shape()
- elif len(args) == 1:
- wire = args[0].shape()
- else:
- raise Exception("not yet implemented")
- # TODO: simple version now, should be a list of selected faces
- return [Selection(self.result(), self.buildShape(wire))]
-
- def buildShape(self, wire):
- """Build the result Shape of this Sketch according to the
- selected geometrical entities."""
- o = self._origin.pnt()
- dx = self._dir_x.dir()
- n = self._norm.dir()
-
- # The faces are kept otherwise they are destroyed at exit
- faces = ShapeList()
- GeomAlgoAPI_SketchBuilder.createFaces(o, dx, n, wire, faces)
- # TODO: Deal with several faces
- return faces[0]
-
- def result(self):
- """Returns the result data of this Feature."""
- return self._feature.firstResult()
+++ /dev/null
-"""Common tools for other modules.
-Author: Sergey Pokhodenko
-Copyright (C) 2014-20xx CEA/DEN, EDF R&D
-"""
-
-import re
-import collections
-
-import ModelAPI
-import GeomAPI
-import GeomDataAPI
-
-# from .sketcher.sketch import Sketch
-
-
-def convert_to_underscore(name):
- """Convert CamelCase to underscore_case."""
- s1 = re.sub('(.)([A-Z][a-z]+)', r'\1_\2', name)
- return re.sub('([a-z0-9])([A-Z])', r'\1_\2', s1).lower()
-
-
-class Selection:
- """Class for selection.
-
- Selection() -> empty selection
- Selection(name, type) -> selection initialized with arguments:
- - name -- topological name
- - type -- type of the object
- Selection(context, shape) -> selection initialized with arguments:
- - context -- ModelAPI_Result object
- - shape -- GeomAPI_Shape shape
- """
-
- def __init__(self, *args):
- """x.__init__(...) initializes x; see x.__class__.__doc__ for signature"""
-
- if not args:
- self.args = (None, None)
- return
-
- if len(args) == 1 and isinstance(args[0], basestring):
- self.args = args
- return
-
- assert(len(args) > 1 and len(args) < 4)
- assert(isinstance(args[0], basestring) or
- isinstance(args[0], ModelAPI.ModelAPI_Result))
- if isinstance(args[0], basestring):
- assert(isinstance(args[1], basestring))
- elif isinstance(args[0], ModelAPI.ModelAPI_Result) or args[0] is None:
- assert(isinstance(args[1], GeomAPI.GeomAPI_Shape))
- self.args = args
-
-
-def fill_attribute(attribute, value):
- """Set value to attribure.
-
- This function processes complex cases.
- ModelAPI_AttributeSelectionList can accept string, result + shape, list of
- strings and [result + shape]...
- ModelAPI_AttributeDouble can accept float and string
- """
- if (isinstance(attribute, ModelAPI.ModelAPI_AttributeBoolean) or
- isinstance(attribute, ModelAPI.ModelAPI_AttributeDocRef) or
- isinstance(attribute, ModelAPI.ModelAPI_AttributeReference)
- ):
- attribute.setValue(value)
-
- elif isinstance(attribute, ModelAPI.ModelAPI_AttributeString):
- attribute.setValue(str(value))
-
- elif (isinstance(attribute, ModelAPI.ModelAPI_AttributeDouble) or
- isinstance(attribute, ModelAPI.ModelAPI_AttributeInteger)
- ):
- if isinstance(value, basestring):
- attribute.setText(value)
- else:
- attribute.setValue(value)
-
- elif isinstance(attribute, ModelAPI.ModelAPI_AttributeIntArray):
- attrubute.setSize(len(value))
- for i in range(len(value)):
- attrubute.setValue(i, value[i])
-
- elif isinstance(attribute, ModelAPI.ModelAPI_AttributeRefAttr):
- assert(isinstance(value, ModelAPI.ModelAPI_Attribute) or
- isinstance(value, ModelAPI.ModelAPI_Object))
- if isinstance(value, ModelAPI.ModelAPI_Attribute):
- attribute.setAttr(value)
- elif isinstance(value, ModelAPI.ModelAPI_Object):
- attribute.setObject(value)
-
- elif isinstance(attribute, ModelAPI.ModelAPI_AttributeRefList):
- attribute.clear()
- if not value:
- return
-
- assert(isinstance(value, collections.Iterable))
- for item in value:
- assert(isinstance(item, ModelAPI.ModelAPI_Object))
- attribute.append(item)
-
- elif isinstance(attribute, ModelAPI.ModelAPI_AttributeRefAttrList):
- attribute.clear()
- if not value:
- return
-
- assert(isinstance(value, collections.Iterable))
- for item in value:
- assert(isinstance(item, ModelAPI.ModelAPI_Attribute))
- attribute.append(item)
-
- elif isinstance(attribute, ModelAPI.ModelAPI_AttributeSelection):
- if value is None:
- attribute.setValue(None, None)
- return
-
- assert(isinstance(value, Selection))
- attribute.setValue(*value.args)
-
- elif isinstance(attribute, ModelAPI.ModelAPI_AttributeSelectionList):
- attribute.clear()
- if not value:
- return
-
- assert(isinstance(value, collections.Iterable))
- for item in value:
- assert(isinstance(item, Selection))
- attribute.append(*item.args)
-
- elif (isinstance(attribute, GeomDataAPI.GeomDataAPI_Dir) or
- isinstance(attribute, GeomDataAPI.GeomDataAPI_Point) or
- isinstance(attribute, GeomDataAPI.GeomDataAPI_Point2D)
- ):
- assert(isinstance(value, collections.Iterable))
- attribute.setValue(*value)
-
- else:
- raise AssertionError("Wrong attribute type: %s" % type(attribute))
