src/PythonAPI/model/features/revolution.py

   1 """Revolution Interface
   2 Author: Sergey Pokhodenko
   3 Copyright (C) 2014-20xx CEA/DEN, EDF R&D
   4 """
   5
   6 from model.roots import Interface
   7
   8
   9 def addRevolution(part, *args):
  10     """Add an Revolution feature to the Part and return Revolution.
  11
  12     Pass all args to Revolution __init__ function.
  13     """
  14     assert(len(args) > 0 and args[0] is not None)
  15     feature = part.addFeature("Revolution")
  16     return Revolution(feature, *args)
  17
  18
  19 class Revolution(Interface):
  20     """Interface on an Revolution feature."""
  21
  22     def __init__(self, feature, base=None, axis_object=None, *args):
  23         """Initialize an Revolution feature with given parameters.
  24
  25         Expected arguments for all modes:
  26         feature -- an Revolution feature
  27
  28         Expected arguments for initializing the feature:
  29         base -- name, sketch or list of names and sketches.
  30         If base is None then don't change the feature.
  31         axis_object -- name, edge for axis
  32
  33         For ByAngles mode (expect 2 arguments):
  34         to_angle -- upper angle
  35         from_angle -- lower angle
  36
  37         For ByPlanesAndOffsets mode (expect 4 arguments):
  38         to_object -- upper object (plane)
  39         to_offset -- offset from upper object
  40         from_object -- lower object (plane)
  41         from_offset -- offset from lower object
  42         """
  43         Interface.__init__(self, feature)
  44         assert(self._feature.getKind() == "Revolution")
  45
  46         self._base = self._feature.data().selectionList("base")
  47         self._axis_object = self._feature.data().selection("axis_object")
  48         self._CreationMethod = self._feature.string("CreationMethod")
  49         self._to_angle = self._feature.data().real("to_angle")
  50         self._from_angle = self._feature.data().real("from_angle")
  51         self._to_object = self._feature.data().selection("to_object")
  52         self._to_offset = self._feature.data().real("to_offset")
  53         self._from_object = self._feature.data().selection("from_object")
  54         self._from_offset = self._feature.data().real("from_offset")
  55
  56         assert(self._base)
  57         assert(self._axis_object)
  58         assert(self._CreationMethod)
  59         assert(self._to_angle)
  60         assert(self._from_angle)
  61         assert(self._to_object)
  62         assert(self._to_offset)
  63         assert(self._from_object)
  64         assert(self._from_offset)
  65
  66         if base is None:
  67             return
  68
  69         self.__setBase(base)
  70         self.__setAxisObject(axis_object)
  71
  72         if len(args) == 4:
  73             self.__createByPlanesAndOffsets(*args)
  74         elif len(args) == 2:
  75             self.__createByAngles(*args)
  76         else:
  77             raise AssertionError(
  78                 "Revolution takes 5 or 7 arguments (%s given)" %
  79                 (len(args) + 3)
  80                 )
  81
  82         self.__execute()
  83         pass
  84
  85     def __setBase(self, base):
  86         self._fill_attribute(self._base, base)
  87         pass
  88
  89     def __setAxisObject(self, axis_object):
  90         self._fill_attribute(self._axis_object, axis_object)
  91         pass
  92
  93     def __clear(self):
  94         self._CreationMethod.setValue("ByAngles")
  95         self._fill_attribute(self._to_angle, 0)
  96         self._fill_attribute(self._from_angle, 0)
  97         self._fill_attribute(self._to_object, None)
  98         self._fill_attribute(self._to_offset, 0)
  99         self._fill_attribute(self._from_object, None)
 100         self._fill_attribute(self._from_offset, 0)
 101         pass
 102
 103     def __createByAngles(self, to_angle, from_angle):
 104         self.__clear()
 105         self._CreationMethod.setValue("ByAngles")
 106         self._fill_attribute(self._to_angle, to_angle)
 107         self._fill_attribute(self._from_angle, from_angle)
 108         pass
 109
 110     def __createByPlanesAndOffsets(self, to_object, to_offset,
 111                                    from_object, from_offset):
 112         self.__clear()
 113         self._CreationMethod.setValue("ByPlanesAndOffsets")
 114         self._fill_attribute(self._to_object, to_object)
 115         self._fill_attribute(self._to_offset, to_offset)
 116         self._fill_attribute(self._from_object, from_object)
 117         self._fill_attribute(self._from_offset, from_offset)
 118         pass
 119
 120     def __execute(self):
 121         if self.areInputValid():
 122             self.execute()
 123         else:
 124             raise Exception("Cannot execute Revolution: %s" %
 125                             self._feature.error())
 126
 127     def setBase(self, base):
 128         """Modify base attribute of the feature.
 129
 130         See __init__.
 131         """
 132         self.__setBase(base)
 133         self.__execute()
 134         pass
 135
 136     def setAxisObject(self, axis_object):
 137         """Modify axis_object attribute of the feature.
 138
 139         See __init__.
 140         """
 141         self.__setAxisObject(axis_object)
 142         self.__execute()
 143         pass
 144
 145     def setAngles(self, *args):
 146         """Modify the to_angle, from_angle attributes of the feature.
 147
 148         See __init__.
 149         """
 150         self.__createByAngles(*args)
 151         self.__execute()
 152         pass
 153
 154     def setPlanesAndOffsets(self, *args):
 155         """Modify planes and offsets attributes of the feature.
 156
 157         See __init__.
 158         """
 159         self.__createByPlanesAndOffsets(*args)
 160         self.__execute()
 161         pass