src/PY/SHAPERSTUDY.py

   1 # Copyright (C) 2007-2019  CEA/DEN, EDF R&D, OPEN CASCADE
   2 #
   3 # Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 # CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 #
   6 # This library is free software; you can redistribute it and/or
   7 # modify it under the terms of the GNU Lesser General Public
   8 # License as published by the Free Software Foundation; either
   9 # version 2.1 of the License, or (at your option) any later version.
  10 #
  11 # This library is distributed in the hope that it will be useful,
  12 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 # Lesser General Public License for more details.
  15 #
  16 # You should have received a copy of the GNU Lesser General Public
  17 # License along with this library; if not, write to the Free Software
  18 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 #
  20 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21 #
  22
  23 import SHAPERSTUDY_ORB__POA
  24 import SHAPERSTUDY_ORB
  25 import SALOME_ComponentPy
  26 import SALOME_DriverPy
  27 import SALOMEDS
  28 from SHAPERSTUDY_utils import findOrCreateComponent, moduleName, getStudy, getORB
  29 import salome
  30 import SHAPERSTUDY_Object
  31
  32 __entry2IOR__ = {}
  33
  34 class SHAPERSTUDY(SHAPERSTUDY_ORB__POA.Gen,
  35                   SALOME_ComponentPy.SALOME_ComponentPy_i,
  36                   SALOME_DriverPy.SALOME_DriverPy_i):
  37
  38
  39     ShapeType = {"AUTO":-1, "COMPOUND":0, "COMPSOLID":1, "SOLID":2, "SHELL":3, "FACE":4, "WIRE":5, "EDGE":6, "VERTEX":7, "SHAPE":8, "FLAT":9}
  40
  41     def __init__ ( self, orb, poa, contID, containerName, instanceName, interfaceName ):
  42         """
  43         Construct an instance of SHAPERSTUDY module engine.
  44         The class SHAPERSTUDY implements CORBA interface Gen (see SHAPERSTUDY_Gen.idl).
  45         It is inherited (via GEOM_Gen) from the classes SALOME_ComponentPy_i (implementation of
  46         Engines::EngineComponent CORBA interface - SALOME component) and SALOME_DriverPy_i
  47         (implementation of SALOMEDS::Driver CORBA interface - SALOME module's engine).
  48         """
  49         SALOME_ComponentPy.SALOME_ComponentPy_i.__init__(self, orb, poa,
  50                     contID, containerName, instanceName, interfaceName, False)
  51         SALOME_DriverPy.SALOME_DriverPy_i.__init__(self, interfaceName)
  52         #
  53         #self._naming_service = SALOME_ComponentPy.SALOME_NamingServicePy_i( self._orb )
  54         #
  55         pass
  56
  57     def FindOrCreateShape( self, theInternalEntry ):
  58         """
  59         Searches existing or creates a new SHAPERSTUDY_Object to interact with SHAPER
  60         """
  61         # Searching in the study tree
  62         aComponent = findOrCreateComponent()
  63         aSOIter = getStudy().NewChildIterator(aComponent)
  64         while aSOIter.More():
  65           aSO = aSOIter.Value()
  66           anIOR = aSO.GetIOR()
  67           anObj = salome.orb.string_to_object(anIOR)
  68           if isinstance(anObj, SHAPERSTUDY_ORB._objref_SHAPER_Object):
  69             if anObj.GetEntry() == theInternalEntry:
  70               return anObj
  71           aSOIter.Next()
  72
  73         aShapeObj = SHAPERSTUDY_Object.SHAPERSTUDY_Object()
  74         aShapeObj.SetEntry(theInternalEntry)
  75         return aShapeObj._this()
  76
  77     def AddInStudy( self, theObject, theName, theFather ):
  78         """
  79         Adds in theStudy a object theObject under theFather with a name theName,
  80         if theFather is not NULL the object is placed under theFather's SObject.
  81         Returns a SObject where theObject is placed
  82         """
  83         aStudy = getStudy()
  84         aBuilder = aStudy.NewBuilder()
  85         if not theFather:
  86           theFather = findOrCreateComponent()
  87         aResultSO = aBuilder.NewObject(theFather);
  88         aResultSO.SetAttrString("AttributeName", theName)
  89         if theObject:
  90           anIOR = salome.orb.object_to_string(theObject)
  91           aResultSO.SetAttrString("AttributeIOR", anIOR)
  92           theObject.SetSO(aResultSO)
  93
  94         return aResultSO
  95
  96     def AddSubShape( theMainShape, theIndices ):
  97         """
  98         Add a sub-shape defined by indices in theIndices
  99         (contains unique IDs of sub-shapes inside theMainShape)
 100         """
 101         go = SHAPERSTUDY_Object()._this()
 102         return go
 103
 104     def RemoveObject( self, theObject ):
 105         """
 106         Removes the object from the component
 107         """
 108         return
 109
 110     def GetIFieldOperations( self ):
 111         """
 112         """
 113         return SHAPERSTUDY_IFieldOperations()
 114
 115     def GetIGroupOperations( self ):
 116         """
 117         """
 118         return SHAPERSTUDY_IGroupOperations()
 119
 120     def GetIShapesOperations( self ):
 121         """
 122         """
 123         return SHAPERSTUDY_IShapesOperations()
 124
 125     def GetIMeasureOperations( self ):
 126         """
 127         """
 128         return SHAPERSTUDY_IMeasureOperations()
 129
 130     def GetStringFromIOR( self, theObject ):
 131         """
 132         Returns a string which contains an IOR of the SHAPERSTUDY_Object
 133         """
 134         IOR = ""
 135         if theObject and getORB():
 136             IOR = getORB().object_to_string( theObject )
 137             pass
 138         return IOR
 139
 140     def GetAllDumpNames( self ):
 141         """
 142         Returns all names with which Object's was dumped
 143         into python script to avoid the same names in SMESH script
 144         """
 145         return [""]
 146
 147     def GetDumpName( self, theStudyEntry ):
 148         """
 149         Returns a name with which a GEOM_Object was dumped into python script
 150
 151         Parameters:
 152             theStudyEntry is an entry of the Object in the study
 153         """
 154         print("My Test")
 155         return "test"
 156
 157
 158     def Save( self, component, URL, isMultiFile ):
 159         """
 160         Saves data.
 161         Nothing to do here because in our case all data
 162         are stored in the SALOMEDS attributes.
 163         """
 164         return ""
 165
 166     def Load( self, component, stream, URL, isMultiFile ):
 167         """
 168         Loads data
 169         """
 170         global __entry2IOR__
 171         __entry2IOR__.clear()
 172         #
 173         return 1
 174
 175     def IORToLocalPersistentID(self, sobject, IOR, isMultiFile, isASCII):
 176         """
 177         Gets persistent ID for the CORBA object.
 178         It's enough to use study entry.
 179         """
 180         return sobject.GetID()
 181
 182     def LocalPersistentIDToIOR(self, sobject, persistentID, isMultiFile, isASCII):
 183         "Converts persistent ID of the object to its IOR."
 184         global __entry2IOR__
 185         if persistentID in __entry2IOR__:
 186             return __entry2IOR__[persistentID]
 187         return ""
 188
 189     def DumpPython( self, isPublished, isMultiFile ):
 190         """
 191         Dump module data to the Python script.
 192         """
 193         return ("".encode(), 1)
 194
 195
 196
 197     def CreateGroup( self, theMainShape, theShapeType ):
 198         """
 199         Creates a new group which will store sub-shapes of theMainShape
 200         """
 201         return GetIGroupOperations().CreateGroup( theMainShape, theShapeType );
 202
 203     def ExtractShapes( self, aShape, aType, isSorted = False ):
 204         """
 205         Extract shapes (excluding the main shape) of given type.
 206
 207         Parameters:
 208             aShape The shape.
 209             aType  The shape type (see geompy.ShapeType)
 210             isSorted Boolean flag to switch sorting on/off.
 211
 212         Returns:
 213             List of sub-shapes of type aType, contained in aShape.
 214         """
 215         return [ SHAPERSTUDY_Object()._this() ]
 216
 217     def GetSubShape( self, aShape, ListOfID ):
 218         """
 219         Obtain a composite sub-shape of aShape, composed from sub-shapes
 220         of aShape, selected by their unique IDs inside aShape
 221
 222         Parameters:
 223             aShape Shape to get sub-shape of.
 224             ListOfID List of sub-shapes indices.
 225         """
 226         return SHAPERSTUDY_Object()._this()
 227
 228     def GetSubShapeID( self, aShape, aSubShape ):
 229         """
 230         Obtain unique ID of sub-shape aSubShape inside aShape
 231         of aShape, selected by their unique IDs inside aShape
 232
 233         Parameters:
 234            aShape Shape to get sub-shape of.
 235            aSubShape Sub-shapes of aShape.
 236         """
 237         return 1
 238
 239     def MinDistance( self, theShape1, theShape2 ):
 240         """
 241         Get minimal distance between the given shapes.
 242         """
 243         return 0.
 244
 245     def NumberOfEdges( self, theShape ):
 246         """
 247         Gives quantity of edges in the given shape.
 248         """
 249         return 0
 250
 251     def NumberOfFaces( self,  ):
 252         """
 253         Gives quantity of faces in the given shape.
 254         """
 255         return 0
 256
 257     def PointCoordinates( self, theVertex ):
 258         """
 259         Get point coordinates
 260         """
 261         return 0,0,0
 262
 263     def SubShapeAll( self, aShape, aType ):
 264         """
 265         Explode a shape on sub-shapes of a given type.
 266         If the shape itself matches the type, it is also returned.
 267         """
 268         return [ SHAPERSTUDY_Object()._this() ]
 269
 270     def SubShapeName( self, aSubObj, aMainObj ):
 271         """
 272         Get name for sub-shape aSubObj of shape aMainObj
 273         """
 274         return ""
 275
 276     def SubShapes( self, aShape, anIDs ):
 277         """
 278         Get a set of sub-shapes defined by their unique IDs inside theMainShape
 279         """
 280         return  [ SHAPERSTUDY_Object()._this() ]
 281
 282     def Tolerance( self, theShape ):
 283         """
 284         Get min and max tolerances of sub-shapes of theShape
 285
 286         Returns:
 287             [FaceMin,FaceMax, EdgeMin,EdgeMax, VertMin,VertMax]
 288         """
 289         return [0,0, 0,0, 0,0]
 290
 291     def UnionList( self, theGroup, theSubShapes ):
 292         """
 293         Adds to the group all the given shapes. No errors, if some shapes are already included.
 294         """
 295         return GetIGroupOperations().UnionList( theGroup, theSubShapes )