def getBox(self, forceExecute = False): """ return the bounding box """ if self._bb==None: self._bb = BoundingBox() theNet().add( self._bb) connect( self.geoConnectionPoint(), ConnectionPoint( self._bb, 'GridIn0' ) ) # Clear info queue so we dont read a previous BB output. # (If something goes wrong with the queue, this could be the reason.) coviseStartup.globalReceiverThread.infoQueue.clear() if not self.executeGeo(): saveExecute(self._bb) boxParser = BoundingBoxParser() boxParser.parseQueue(coviseStartup.globalReceiverThread.infoQueue) self._boundingBox = boxParser.getBox() elif forceExecute: # Clear info queue so we dont read a previous BB output. # (If something goes wrong with the queue, this could be the reason.) coviseStartup.globalReceiverThread.infoQueue.clear() if not self.executeGeo(): saveExecute(self._bb) boxParser = BoundingBoxParser() boxParser.parseQueue(coviseStartup.globalReceiverThread.infoQueue) try: oldbb = self._boundingBox self._boundingBox = boxParser.getBox() except (ValueError): self._boundingBox = oldbb return self._boundingBox
def delete(self, isInitialized, negMsgHandler=None): ''' delete this VisItem: remove the module ''' _infoer.function = str(self.delete) _infoer.write(" ") if isInitialized: if hasattr(self, '_module') and self._module: theNet().remove(self._module) VisItem.delete(self, isInitialized, negMsgHandler)
def delete(self, isInitialized, negMsgHandler=None): ''' delete this CoviseVis: remove the module ''' _infoer.function = str(self.delete) _infoer.write(" ") if isInitialized: # Manually remove the object from any parent object it is mounted to. # This is not very elegant because when an object (child) is deleted, the unmounting # done in OpenCOVER will send a removeChildMessage to the parent. However, because # it's a separate process, the child will already be fully deleted in vr-prepare # when receiving this message and the coverKey of the child is not known anymore. sceneObjects = [ obj for obj in globalKeyHandler().getAllElements().itervalues() if hasattr(obj, "typeNr") and (obj.typeNr == VIS_SCENE_OBJECT) ] for obj in sceneObjects: if self.key in obj.params.children: params = CopyParams(obj.params) params.children.remove(self.key) negMsgHandler.internalRecvParams(obj.key, params) negMsgHandler.sendParams(obj.key, params) self.sendDelete() theNet().remove(self.performerScene) VisItem.delete(self, isInitialized, negMsgHandler)
def delete(self, isInitialized, negMsgHandler=None): ''' delete this CoviseVis: remove the module ''' _infoer.function = str(self.delete) _infoer.write(" ") if isInitialized: theNet().remove(self.coverDocument) VisItem.delete(self, isInitialized, negMsgHandler)
def delete(self, isInitialized, negMsgHandler=None): ''' delete this CoviseVis: remove the module ''' _infoer.function = str(self.delete) _infoer.write(" ") if isInitialized: # Manually remove the object from any parent object it is mounted to. # This is not very elegant because when an object (child) is deleted, the unmounting # done in OpenCOVER will send a removeChildMessage to the parent. However, because # it's a separate process, the child will already be fully deleted in vr-prepare # when receiving this message and the coverKey of the child is not known anymore. sceneObjects = [obj for obj in globalKeyHandler().getAllElements().itervalues() if hasattr(obj,"typeNr") and (obj.typeNr == VIS_SCENE_OBJECT)] for obj in sceneObjects: if self.key in obj.params.children: params = CopyParams(obj.params) params.children.remove(self.key) negMsgHandler.internalRecvParams( obj.key, params ) negMsgHandler.sendParams( obj.key, params ) self.sendDelete() theNet().remove(self.performerScene) VisItem.delete(self, isInitialized, negMsgHandler)
def __init(self, negMsgHandler): """ __init is called from __update + start _module module if it does not already exist and connect output to COVER + set default parameters of module + set default boundingBox which is also used in the GUI to set borders of the float sliders + set color inport and corresponding module + send params to the gui """ if self.__firstTime == True: self.__firstTime = False PartModuleVis._init(self, negMsgHandler) PartColoredVis._init(self, negMsgHandler, self.__myColors, 'ColormapIn0') # make my custom connections between further self created modules here theNet().connect(self._module, 'GridOut0', self.__myCollect, 'GridIn0') if not self.params.variable == 'unset': theNet().connect(self.__myColors, 'DataOut0', self.__myCollect, 'DataIn0') theNet().connect(self._module, 'DataOut0', self.__myColors, 'DataIn0') else: theNet().disconnect(self.__myColors, 'DataOut0', self.__myCollect, 'DataIn0') theNet().disconnect(self._module, 'DataOut0', self.__myColors, 'DataIn0') # send params to gui self.sendParams()
def executeData(self, varName): self.__initData(varName) # reconnect data if varName in self.__dataInConnectionPoints.keys(): theNet().disconnectAllFromModulePort( self.__dataInConnectionPoints[varName].module, self.__dataInConnectionPoints[varName].port) connect(ParentClass.dataConnectionPoint(self, varName), self.__dataInConnectionPoints[varName]) # wenn voriges Modul tatsaechlich executed wurde, dann nicht mehr selbst executen if ParentClass.executeData(self, varName) == True: self.__needExecuteData[varName] = False return True if not self.__needExecuteData[varName]: return False self.__needExecuteData[varName] = False if varName in self.__dataInConnectionPoints.keys(): saveExecute(self.__dataInConnectionPoints[varName].module) return True return False
def __update(self): """ do init if necessary; update module parameters """ self.__init() # update input dataInConnect = self.importModule.dataConnectionPoint( self.params.variable) if not self.__lastDataConnection == None: disconnect(self.__lastDataConnection, self.__colorsIn) else: theNet().connect(self.__colors, 'TextureOut0', self.__collect, 'TextureIn0') if dataInConnect: connect( self.importModule.dataConnectionPoint(self.params.variable), self.__colorsIn) self.__lastDataConnection = self.importModule.dataConnectionPoint( self.params.variable) _infoer.function = str(self.__update) _infoer.write(": updating to variable " + self.params.variable) # update colormap settings self.__colors.set_numSteps(self.params.numSteps)
def __init(self): """ start COVISE ReadCAD Module """ if self.__readCad == None: self.__readCad = ReadCAD() theNet().add(self.__readCad) self.__readCadPolyOut = ConnectionPoint(self.__readCad, 'mesh') self.__readCadNormalsOut = ConnectionPoint(self.__readCad, 'Normals') self.__readCadColorsOut = ConnectionPoint(self.__readCad, 'colorOut') self.__readCad.set_catia_server('obie') self.__readCad.set_catia_server_port('7000') self.__readCad.set_partIndex(self.__index) self.__readCad.set_file_path(self.__filename) self.__collect = Collect() theNet().add(self.__collect) connect(self.__readCadPolyOut, ConnectionPoint(self.__collect, 'GridIn0')) connect(self.__readCadNormalsOut, ConnectionPoint(self.__collect, 'DataIn1')) connect(self.__readCadColorsOut, ConnectionPoint(self.__collect, 'DataIn0')) self.__connectGeoOut = ConnectionPoint(self.__collect, 'GeometryOut0')
def __update(self): """ __update is called from the run method to update the module parameter before execution + update module parameters """ _infoer.function = str(self.__update) _infoer.write(" ") if self.performerScene == None: self.performerScene = PerformerScene() theNet().add(self.performerScene) # update params self.performerScene.set_modelPath( covise.getCoConfigEntry("vr-prepare.Coxml.ResourceDirectory") + "/coxml/" + self.params.filename) self.performerScene.set_scale(self.params.scale) if (self.params.backface == True): self.performerScene.set_backface('TRUE') else: self.performerScene.set_backface('FALSE') if (self.params.orientation_iv == True): self.performerScene.set_orientation_iv('TRUE') else: self.performerScene.set_orientation_iv('FALSE') if (self.params.convert_xforms_iv == True): self.performerScene.set_convert_xforms_iv('TRUE') else: self.performerScene.set_convert_xforms_iv('FALSE') _infoer.write(" finished")
def executeOct(self): self.octTreeConnectionPoint() one_executed = False #quickfix #save/loading of a 2d composed probing point does not work with this #for part in self._parts: # if part.executeOct(): # one_executed = True numPorts = 0 numModules = 0 for part in self._parts: # dont reconnect BlockCollect inter-connections if (numPorts % 15 == 0) and (numModules != 0): numPorts += 1 theNet().disconnectAllFromModulePort(self._collectOct[numModules].objInConnectionPoint(numPorts).module, self._collectOct[numModules].objInConnectionPoint(numPorts).port) connect(part.octTreeConnectionPoint(), self._collectOct[numModules].objInConnectionPoint(numPorts)) numPorts = numPorts + 1 if numPorts % 15 == 0: numModules = numModules +1 numPorts = 0 if part.executeOct(): one_executed = True if not one_executed and self._firstTimeOct: for bc in self._collectOct: bc.execute() one_executed = True self._firstTimeOct = False return one_executed
def delete(self, isInitialized, negMsgHandler=None): ''' delete this CoviseVis: remove the module ''' _infoer.function = str(self.delete) _infoer.write(" ") if isInitialized: theNet().remove(self.performerScene) theNet().remove(self.addAttribute) VisItem.delete(self, isInitialized, negMsgHandler)
def initPartTree(self, negMsgHandler): readCAD = ReadCAD() theNet().add(readCAD) negMsgHandler.registerParamsNotfier(readCAD, self.key, ['SelectPart']) readCAD.set_catia_server('obie') readCAD.set_catia_server_port('7000') readCAD.set_file_path(self.params.filename) self.neg = negMsgHandler
def delete(self, isInitialized, negMsgHandler=None): """ delete this CoviseVis: remove the module """ _infoer.function = str(self.delete) _infoer.write(" ") if isInitialized: theNet().remove(self.performerScene) theNet().remove(self.addAttribute) VisItem.delete(self, isInitialized, negMsgHandler)
def initPartTree( self, negMsgHandler ): readCAD = ReadCAD() theNet().add(readCAD) negMsgHandler.registerParamsNotfier( readCAD, self.key, ['SelectPart'] ) readCAD.set_catia_server('obie') readCAD.set_catia_server_port('7000') readCAD.set_file_path( self.params.filename ) self.neg = negMsgHandler
def test_Geo(self): moduleCount = theNet().moduleCount() ip = self._ImportModule1() box = ip.getBox() (x,y,z) = box.getCenter() self.assertEqual((x,y,z), (-0.041321500000000011, 0.0, 0.1766115)) # delete ip.delete() self.assertEqual(theNet().moduleCount(), moduleCount)
def test_Data(self): moduleCount = theNet().moduleCount() ip = self._ImportModule1() value = 'Temperature' (a,b) = ip.getDataMinMax(value) self.assertEqual((a,b), (78.848465, 446.557648)) # delete ip.delete() self.assertEqual(theNet().moduleCount(), moduleCount)
def test_Data(self): moduleCount = theNet().moduleCount() ip = self._ImportModule1() value = 'Temperature' (a, b) = ip.getDataMinMax(value) self.assertEqual((a, b), (78.848465, 446.557648)) # delete ip.delete() self.assertEqual(theNet().moduleCount(), moduleCount)
def delete(self, isInitialized, negMsgHandler=None): if isInitialized: if hasattr(self, '_PartIsoCutterVis__myCollect') and self.__myCollect: theNet().remove(self.__myCollect) if hasattr(self, '_PartIsoCutterVis__myColors') and self.__myColors: theNet().remove(self.__myColors) PartModuleVis.delete(self, isInitialized, negMsgHandler)
def test_Geo(self): moduleCount = theNet().moduleCount() ip = self._ImportModule1() box = ip.getBox() (x, y, z) = box.getCenter() self.assertEqual((x, y, z), (-0.041321500000000011, 0.0, 0.1766115)) # delete ip.delete() self.assertEqual(theNet().moduleCount(), moduleCount)
def __init(self): """ start COVISE Module and connect output to COVER """ if self.__addAttribute==None : self.__addAttribute = AddAttribute() theNet().add(self.__addAttribute) self.__addAttribute.set_attrName( "COLOR" ) addAttributeIn = ConnectionPoint( self.__addAttribute, 'inObject' ) self.__addAttributeOut = ConnectionPoint( self.__addAttribute, 'outObject' ) connect( self.importModule.geoConnectionPoint(), addAttributeIn ) VisItem.connectToCover( self, self )
def __initBase(self): """ + __initBase is called from the constructor and after the class was unpickled + add privately created modules here """ self.__firstTime = True # create custom modules here self.__myCollect = Collect() theNet().add(self.__myCollect)
def testGroupGeo(self): moduleCount = theNet().moduleCount() gip = self._LargeGroup() bp = gip.getBox() (x,y,z) = bp.getCenter() self.assertEqual((x,y,z), (1.6700575000000002, 0.0, 0.40254699999999999)) # delete gip.delete() self._RemoveImportGroupModules() self.assertEqual(theNet().moduleCount(), moduleCount)
def testTransientGroupGeo(self): moduleCount = theNet().moduleCount() gip = self._TransientGroup() bp = gip.getBox() (x,y,z) = bp.getCenter() self.assertEqual((x,y,z), (0.099999999999999978, 0.012500000000000011, 0.050000000000000003)) # delete gip.delete() self._RemoveImportGroupModules() self.assertEqual(theNet().moduleCount(), moduleCount)
def testGroupGeo(): gip = testLargeGroup() bp = gip.getBox() (x,y,z) = bp.getCenter() theNet().save("/work/sk_te/testgui.net") if not (x,y,z)==(1.6700575000000002, 0.0, 0.40254699999999999): print("test failed", (x,y,z)) else: print("OK")
def testSample(): #ip = testSampleImportModule1() ip = testSampleGroup() ip.executeGeo() #ip.executeOct() ip.executeSampleData(COMPOSED_VELOCITY) #(a,b) = ip.getDataMinMax('rotvel')#COMPOSED_VELOCITY) #print("min, max " , a, b) #ip.executeSampleData('Temperature') theNet().save("/work/sk_te/testgui.net")
def __init(self): """ start COVISE Module and connect output to COVER """ if self.__addAttribute == None: self.__addAttribute = AddAttribute() theNet().add(self.__addAttribute) self.__addAttribute.set_attrName("COLOR") addAttributeIn = ConnectionPoint(self.__addAttribute, 'inObject') self.__addAttributeOut = ConnectionPoint(self.__addAttribute, 'outObject') connect(self.importModule.geoConnectionPoint(), addAttributeIn) VisItem.connectToCover(self, self)
def testGroupGeo(self): moduleCount = theNet().moduleCount() gip = self._LargeGroup() bp = gip.getBox() (x, y, z) = bp.getCenter() self.assertEqual((x, y, z), (1.6700575000000002, 0.0, 0.40254699999999999)) # delete gip.delete() self._RemoveImportGroupModules() self.assertEqual(theNet().moduleCount(), moduleCount)
def __init(self, negMsgHandler): """called from __update start rwCovise and connects to COVER send params to GUI""" _infoer.function = str(self.__init) _infoer.write(" ") if self.rwCovise == None: self.rwCovise = RWCovise() theNet().add(self.rwCovise) VisItem.connectToCover(self, self) self.__connected = True
def __update(self): """ __update is called from the run method to update the module parameter before execution + update module parameters """ _infoer.function = str(self.__update) _infoer.write("") if self.coverDocument==None: self.coverDocument = CoverDocument() theNet().add(self.coverDocument) #update params self.coverDocument.set_Filename(self.params.imageName) self.coverDocument.set_Title(self.params.documentName)
def testTransientGroupGeo(self): moduleCount = theNet().moduleCount() gip = self._TransientGroup() bp = gip.getBox() (x, y, z) = bp.getCenter() self.assertEqual( (x, y, z), (0.099999999999999978, 0.012500000000000011, 0.050000000000000003)) # delete gip.delete() self._RemoveImportGroupModules() self.assertEqual(theNet().moduleCount(), moduleCount)
def __update(self): """ __update is called from the run method to update the module parameter before execution + update module parameters """ _infoer.function = str(self.__update) _infoer.write("") if self.coverDocument == None: self.coverDocument = CoverDocument() theNet().add(self.coverDocument) #update params self.coverDocument.set_Filename(self.params.imageName) self.coverDocument.set_Title(self.params.documentName)
def __update(self, negMsgHandler): """ __update is called from the run method to update the module parameter before execution + do init of the IsoCutter module if necessary + update module parameters """ self.__init(negMsgHandler) PartModuleVis._update(self, negMsgHandler) if not self.params.variable == 'unset': PartColoredVis._update(self, negMsgHandler) else: self._dataInputNames = [] theNet().disconnect(self.__myColors, 'DataOut0', self.__myCollect, 'DataIn0') theNet().disconnect(self._module, 'DataOut0', self.__myColors, 'DataIn0')
def __init(self): """ start COVISE modules and connect output to COVER """ if self.__colors==None and self.__collect==None: self.__colors = Colors() theNet().add(self.__colors) self.__colorsIn = ConnectionPoint(self.__colors, 'GridIn0') self.__collect = Collect() theNet().add(self.__collect) self.__collectOut = ConnectionPoint(self.__collect, 'GeometryOut0') connect( self.importModule.geoConnectionPoint(), ConnectionPoint(self.__collect, 'GridIn0') ) VisItem.connectToCover( self, self )
def __init(self): """ start COVISE modules and connect output to COVER """ if self.__colors == None and self.__collect == None: self.__colors = Colors() theNet().add(self.__colors) self.__colorsIn = ConnectionPoint(self.__colors, 'GridIn0') self.__collect = Collect() theNet().add(self.__collect) self.__collectOut = ConnectionPoint(self.__collect, 'GeometryOut0') connect(self.importModule.geoConnectionPoint(), ConnectionPoint(self.__collect, 'GridIn0')) VisItem.connectToCover(self, self)
def test_TransientReduceSetGeo(self): moduleCount = theNet().moduleCount() gip_core = self._TransientGroup() gip = ImportGroupReduceSet(gip_core) gip.setReductionFactor(2) gip.executeGeo() bp = gip.getBox() (x,y,z) = bp.getCenter() self.assertEqual((x,y,z),(0.55000000000000004, -0.25, 0.050000000000000003)) # delete gip.delete() gip_core.delete() self._RemoveImportGroupModules() self.assertEqual(theNet().moduleCount(), moduleCount)
def delete(self): if hasattr(self, "_geo") and self._geo: self._geo.remove() if hasattr(self, "_data"): for module in self._data.values(): module.remove() if hasattr(self, "_oct") and self._oct: theNet().remove(self._oct) if hasattr(self, "_octTreeWriter") and self._octTreeWriter: theNet().remove(self._octTreeWriter) if hasattr(self, "_bb") and self._bb: theNet().remove(self._bb) if hasattr(self, "_ImportModule__bbFromGeoRWCovise" ) and self.__bbFromGeoRWCovise: theNet().remove(self.__bbFromGeoRWCovise) if hasattr(self, "_minMax") and self._minMax: theNet().remove(self._minMax)
def testSample(self): moduleCount = theNet().moduleCount() #ip = testSampleImportModule1() ip = self._SampleGroup() ip.executeGeo() #ip.executeOct() # ip.executeSampleData(COMPOSED_VELOCITY) # commented out: does not work at the moment #(a,b) = ip.getDataMinMax('rotvel')#COMPOSED_VELOCITY) #print("min, max " , a, b) #ip.executeSampleData('Temperature') # delete ip.delete() self._RemoveImportGroupModules() self.assertEqual(theNet().moduleCount(), moduleCount)
def executeData(self, varName): self.__initData(varName) # reconnect data if varName in self.__dataConnectionPoints.keys(): theNet().disconnectAllFromModulePort(self.__dataInConnectionPoints[varName].module, self.__dataInConnectionPoints[varName].port) theNet().connect(ParentClass.dataConnectionPoint(self, varName).module, ParentClass.dataConnectionPoint(self, varName).port, self.__dataInConnectionPoints[varName].module, self.__dataInConnectionPoints[varName].port) # reconnect geometry port theNet().disconnectAllFromModulePort(self.__dataInConnectionPoints[varName].module, 'GridIn0') theNet().connect(ParentClass.geoConnectionPoint(self).module, ParentClass.geoConnectionPoint(self).port, self.__dataInConnectionPoints[varName].module, 'GridIn0') # wenn voriges Modul tatsaechlich executed wurde, dann nicht mehr selbst executen if ParentClass.executeData(self, varName) == True: self.__needExecuteData[varName] = False return True if not self.__needExecuteData[varName]: return False self.__needExecuteData[varName] = False if varName in self.__dataInConnectionPoints.keys(): saveExecute(self.__dataInConnectionPoints[varName].module) return True
def executeData(self, vname): one_executed = False initialized = self._initData(vname) collectData = self._collectDataPerName[vname] # reconnecting part_cnt = 0 numModules = 0 numPorts = 0 for part in self._parts: varname = self._varInPart(vname, part_cnt) # dont reconnect BlockCollect inter-connections if (numPorts % 15 == 0) and (numModules != 0): numPorts += 1 theNet().disconnectAllFromModulePort( collectData[numModules].objInConnectionPoint(numPorts % 15).module, collectData[numModules].objInConnectionPoint(numPorts % 15).port) theNet().connect( part.dataConnectionPoint(varname).module, part.dataConnectionPoint(varname).port, collectData[numModules].objInConnectionPoint(numPorts % 15).module, collectData[numModules].objInConnectionPoint(numPorts % 15).port) part_cnt += 1 numPorts += 1 if numPorts % 15 == 0: numModules = numModules + 1 part_cnt = 0 numModules = 0 for part in self._parts: varname = self._varInPart(vname, part_cnt) part_cnt += 1 if part_cnt % 15 == 0: numModules = numModules + 1 _infoer.function = str(self.executeData) _infoer.write("Loading file " + varname) if part.executeData(varname): one_executed = True if not one_executed and self._firstTimeData.get(vname, True): for bc in self._collectDataPerName[vname]: bc.execute() one_executed = True self._firstTimeData[vname] = False return one_executed
def executeSampleData(self, vname, bbox=None, outside=USER_DEFINED): one_executed = False initialized = self._initSample(vname, outside) part_cnt = 0 numModules = 0 numPorts = 0 collectSampleData = self._collectSampleDataPerName[(vname, outside)] collectSampleGeo = self._collectSampleGeoPerName[(vname, outside)] for part in self._parts: varname = self._varInPart(vname, part_cnt) # dont reconnect BlockCollect inter-connections if (numPorts % 15 == 0) and (numModules != 0): numPorts += 1 theNet().disconnectAllFromModulePort( collectSampleData[numModules].objInConnectionPoint(numPorts % 15).module, collectSampleData[numModules].objInConnectionPoint(numPorts % 15).port) theNet().connect( part.dataSampleConnectionPoint(varname, outside).module, part.dataSampleConnectionPoint(varname, outside).port, collectSampleData[numModules].objInConnectionPoint(numPorts % 15).module, collectSampleData[numModules].objInConnectionPoint(numPorts % 15).port) theNet().disconnectAllFromModulePort( collectSampleGeo[numModules].objInConnectionPoint(numPorts % 15).module, collectSampleGeo[numModules].objInConnectionPoint(numPorts % 15).port) theNet().connect( part.geoSampleConnectionPoint(varname, outside).module, part.geoSampleConnectionPoint(varname, outside).port, collectSampleGeo[numModules].objInConnectionPoint(numPorts % 15).module, collectSampleGeo[numModules].objInConnectionPoint(numPorts % 15).port) part_cnt += 1 numPorts += 1 if numPorts % 15 == 0: numModules = numModules + 1 part_cnt = 0 numModules = 0 for part in self._parts: varname = self._varInPart(vname, part_cnt) part_cnt += 1 if part_cnt % 15 == 0: numModules = numModules + 1 if part.executeSampleData(varname, bbox, outside): one_executed = True if not one_executed and self._firstTimeSample.get(vname, True): for i in range(len(self._collectSampleGeoPerName[(vname, outside)])): self._collectSampleGeoPerName[(vname, outside)][i].execute() self._collectSampleDataPerName[(vname, outside)][i].execute() one_executed = True self._firstTimeSample[vname] = False return one_executed
def test_TransientReduceSetGeo(self): moduleCount = theNet().moduleCount() gip_core = self._TransientGroup() gip = ImportGroupReduceSet(gip_core) gip.setReductionFactor(2) gip.executeGeo() bp = gip.getBox() (x, y, z) = bp.getCenter() self.assertEqual((x, y, z), (0.55000000000000004, -0.25, 0.050000000000000003)) # delete gip.delete() gip_core.delete() self._RemoveImportGroupModules() self.assertEqual(theNet().moduleCount(), moduleCount)
def testGroupData(gip): value = 'Temperature' c = Colors() theNet().add(c) connect( gip.dataConnectionPoint(value), ConnectionPoint( c, 'Data' ) ) gip.executeData(value) coll = Collect() theNet().add(coll) connect( gip.geoConnectionPoint(value), ConnectionPoint( coll, 'grid' ) ) theNet().connect( c, 'texture', coll, 'textures' ) r = Renderer() theNet().add(r) theNet().connect( coll, 'geometry', r, 'RenderData') c.execute()
def getDataMinMax( self, variable): """ return min and max value of variable """ if variable==None: return if self._minMax==None: self._minMax = Colors() theNet().add(self._minMax) theNet().disconnectAllFromModulePort( self._minMax, 'DataIn0' ) connect(self.dataConnectionPoint(variable), ConnectionPoint(self._minMax, 'DataIn0')) if not self.executeData( variable ): saveExecute(self._minMax) return ( float(self._minMax.getParamValue('MinMax')[0]),\ float(self._minMax.getParamValue('MinMax')[1]) )
def delete(self): if hasattr(self, "_geo") and self._geo: self._geo.remove() if hasattr(self, "_data"): for module in self._data.values(): module.remove() if hasattr(self, "_oct") and self._oct: theNet().remove(self._oct) if hasattr(self, "_octTreeWriter") and self._octTreeWriter: theNet().remove(self._octTreeWriter) if hasattr(self, "_bb") and self._bb: theNet().remove(self._bb) if hasattr(self, "_ImportModule__bbFromGeoRWCovise") and self.__bbFromGeoRWCovise: theNet().remove(self.__bbFromGeoRWCovise) if hasattr(self, "_minMax") and self._minMax: theNet().remove(self._minMax)
def executeGeo(self): # reconnect geometry if self.__reduceSetModules != []: theNet().disconnectAllFromModulePort(self.__reduceSetModules[0].geoInConnectionPoint().module, self.__reduceSetModules[0].geoInConnectionPoint().port) connect( ParentClass.geoConnectionPoint(self), self.__reduceSetModules[0].geoInConnectionPoint() ) # wenn voriges Modul tatsaechlich executed wurde, dann nicht mehr selbst executen if ParentClass.executeGeo(self) == True: return True if not self.__needExecute: return False self.__needExecute = False if self.__reduceSetModules != []: self.__reduceSetModules[0].execute() return True
def getBoxFromGeoRWCovise(self): """ return the bounding box from the originally unfiltered geometry """ if self.__boundingBoxFromGeoRWCovise == None: self.__bbFromGeoRWCovise = BoundingBox() theNet().add(self.__bbFromGeoRWCovise) connect( self._geo.connectionPoint(), ConnectionPoint(self.__bbFromGeoRWCovise, 'GridIn0')) # Clear info queue so we dont read a previous BB output. # (If something goes wrong with the queue, this could be the reason.) coviseStartup.globalReceiverThread.infoQueue_.clear() saveExecute(self.__bbFromGeoRWCovise) boxParser = BoundingBoxParser() boxParser.parseQueue(coviseStartup.globalReceiverThread.infoQueue_) self.__boundingBoxFromGeoRWCovise = boxParser.getBox() return self.__boundingBoxFromGeoRWCovise
def _initOct(self): self._initGeo() if self._oct==None: # create or use disk-cached octtrees if enableCachedOctTrees == True and self._dim == 3: basename, extension = os.path.splitext(self._part.filename) self._octTreeFileName = basename + ".octtree" + extension print("self._octTreeFileName = ", self._octTreeFileName) if os.path.isfile(self._octTreeFileName) == False: # create disk-cached octtree self._octTreeFileExists = False self._oct = MakeOctTree() theNet().add(self._oct) self._octIn = ConnectionPoint( self._oct, 'inGrid' ) self._octOut = ConnectionPoint( self._oct, 'outOctTree' ) connect( self.geoConnectionPoint(), self._octIn ) # connect RWCovise to MakeOctTree self._octTreeWriter = RWCovise() # writable theNet().add(self._octTreeWriter) self._octTreeWriter.set_grid_path(self._octTreeFileName) connect(self._octOut, ConnectionPoint(self._octTreeWriter, 'mesh_in')) else: # use disk-cached octtree self._octTreeFileExists = True self._oct = RWCovise() theNet().add(self._oct) self._oct.set_grid_path(self._octTreeFileName) # cached octtrees must never get an input connection (RWCovise!) self._octIn = None # ConnectionPoint(self._oct, 'mesh_in') self._octOut = ConnectionPoint(self._oct, 'mesh') else: self._oct = MakeOctTree() theNet().add(self._oct) self._octIn = ConnectionPoint( self._oct, 'inGrid' ) self._octOut = ConnectionPoint( self._oct, 'outOctTree' ) connect( self.geoConnectionPoint(), self._octIn ) else: if enableCachedOctTrees == True and self._octTreeFileExists == True: # no reconnect necessary, if using disk-cached octtree pass else: # reconnect OctTree theNet().disconnectAllFromModulePort(self._oct, 'inGrid') connect(self.geoConnectionPoint(), self._octIn)
def executeData(self, varName): # reconnect data if varName in self.__dataConnectionPoints.keys(): theNet().disconnectAllFromModulePort(self.__dataConnectionPoints[varName].module, self.__dataConnectionPoints[varName].port.replace("out", "in")) theNet().connect(ParentClass.dataConnectionPoint(self, varName).module, ParentClass.dataConnectionPoint(self, varName).port, self.__dataConnectionPoints[varName].module, self.__dataConnectionPoints[varName].port.replace("out", "in")) # wenn voriges Modul tatsaechlich executed wurde, dann nicht mehr selbst executen if ParentClass.executeData(self, varName) == True: return True if not self.__needExecute: return False self.__needExecute = False for rS in self.__reduceSetModules: rS.execute() return True
def __init(self): """ start COVISE ReadCAD Module """ if self.__readCad==None : self.__readCad = ReadCAD() theNet().add(self.__readCad) self.__readCadPolyOut = ConnectionPoint( self.__readCad, 'mesh' ) self.__readCadNormalsOut = ConnectionPoint( self.__readCad, 'Normals' ) self.__readCadColorsOut = ConnectionPoint( self.__readCad, 'colorOut' ) self.__readCad.set_catia_server('obie') self.__readCad.set_catia_server_port('7000') self.__readCad.set_partIndex(self.__index) self.__readCad.set_file_path( self.__filename ) self.__collect = Collect() theNet().add(self.__collect) connect( self.__readCadPolyOut, ConnectionPoint(self.__collect, 'GridIn0') ) connect( self.__readCadNormalsOut, ConnectionPoint(self.__collect, 'DataIn1' ) ) connect( self.__readCadColorsOut, ConnectionPoint(self.__collect, 'DataIn0' ) ) self.__connectGeoOut = ConnectionPoint(self.__collect, 'GeometryOut0' )