def recreate(self, negMsgHandler, parentKey, offset): # start cutting suface not on sampled grid if not covise.coConfigIsOn("vr-prepare.ArrowsOnSampledGrid", True) or not covise.coConfigIsOn("vr-prepare.UseSamplingModules", False): PartCuttingSurfaceVis.recreate(self, negMsgHandler, parentKey, ['GridIn0'], [], [], ['DataIn0'], USER_DEFINED, offset) # start cutting surface on sampled grid else: PartCuttingSurfaceVis.recreate(self, negMsgHandler, parentKey, [], ['GridIn0'], ['DataIn0'], [], USER_DEFINED, offset) #self.params.arrow_head_factor = 0.2 self.params.setMoreParams()
def __init__(self): # start cutting suface not on sampled grid if not covise.coConfigIsOn("vr-prepare.ArrowsOnSampledGrid", True) or not covise.coConfigIsOn("vr-prepare.UseSamplingModules", False): PartCuttingSurfaceVis.__init__(self, ['GridIn0'], [], [], ['DataIn0'], USER_DEFINED) # start cutting surface on sampled grid else: PartCuttingSurfaceVis.__init__(self, [], ['GridIn0'], ['DataIn0'], [], USER_DEFINED) self.params = PartVectorVisParams() self.params.name = 'Arrows' NameArrowsCuttingSurface = covise.getCoConfigEntry("vr-prepare.NameArrowsCuttingSurface") if NameArrowsCuttingSurface: self.params.name = NameArrowsCuttingSurface self.params.option = 1 self.params.vector = 3
def __init__(self, parent): QtWidgets.QDockWidget.__init__(self, coTranslate("Video Capture Manager"), parent) self.setWidget(VideoCaptureManagerBase(self)) #connection of the DockWidget visibilityChanged self.visibilityChanged.connect(self.visibilityChangedS) # connection of buttons self.widget().buttonCapture.clicked.connect(self.capture) self.widget().buttonPreview.clicked.connect(self.startPreview) self.widget().comboBox.activated.connect(self.selectMode) # connect open self.widget().pushButton.clicked.connect(self.openFile) # connect filename self.widget().lineEdit.returnPressed.connect(self.setFilename) self.widget().lineEdit.editingFinished.connect(self.checkFilename) self.widget().groupSettings.setVisible(True) self.widget().groupCapturing.setVisible(True) #self.recording = False; self.filename = "C:\capture.wmv" if covise.coConfigIsOn("COVER.Plugin.Video", False): filename = covise.getCoConfigEntry("COVER.Plugin.Video.Filename") if filename: self.filename = filename self.widget().lineEdit.setText(self.filename) self.oldFilename = self.filename self.freeCapture = False self.mode=0
def updateForObject( self, keys ): if isinstance( keys, int): self.__keys = [keys] else: self.__keys = keys # set the variables if len(self.__keys)==1 : # enable the visualization and the transform tab self.tabWidget.setTabEnabled(0, True) self.tabWidget.setTabEnabled(1, True) scalar = ObjectMgr().getPossibleScalarVariablesForType(self.__keys[0]) vector = ObjectMgr().getPossibleVectorVariablesForType(self.__keys[0]) if covise.coConfigIsOn("vr-prepare.UseComposedVelocity", False): myObject = globalKeyHandler().getObject(self.__keys[0]) if (myObject.typeNr == TYPE_3D_COMPOSED_PART): vector.append(COMPOSED_VELOCITY) self._setUnsetVariable(True) self._setScalarVariables(scalar) self._setVectorVariables(vector) self.setGridName(ObjectMgr().getNameOfType(self.__keys[0]) ) else : # multi selection # disable the visualization and the transform tab self.tabWidget.setTabEnabled(0, False) self.tabWidget.setTabEnabled(1, False) # apply params params = ObjectMgr().getParamsOfObject(self.__keys[0]) params.name = ObjectMgr().getNameOfType(self.__keys[0]) #if self.__key in Application.vrpApp.guiKey2visuKey: # params.isVisible = ObjectMgr().getParamsOfObject(Application.vrpApp.guiKey2visuKey[self.__key]).isVisible self.__setParams( params )
def __init__(self, parent=None): QtWidgets.QWidget.__init__(self, parent) Ui_ClipIntervalPanelBase.__init__(self) self.setupUi(self) #current object key self.__key = -1 #default setting of the panel self.vrpCheckBoxMapVariable.setEnabled(False) self.vrpComboBoxVariable.setEnabled(False) self.visibilityCheckBox.setVisible(covise.coConfigIsOn("vr-prepare.AdditionalVisibilityCheckbox", False)) self.__baseVariable = None #temporary storage of this parameter part self.colorCreator = None middleFloatInRangeCtrls = [self.floatInRangeIsoValueLow] self.__boundingBox = ((-1, 1), (-1, 1), (-1, 1)) for w, r in zip(middleFloatInRangeCtrls, self.__boundingBox): w.setRange(r) sideRange = 0, self.__heuristicProbeMaxSideLengthFromBox( self.__boundingBox) ClipIntervalPanelConnector(self)
def __init__(self, parent=None): _infoer.function = str(self.__init__) _infoer.write("") QtWidgets.QWidget.__init__(self, parent) Ui_DocumentViewerBase.__init__(self) self.setupUi(self) self.__key = -1 changeIndicatedLEs = [ self.floatX, self.floatY, self.floatZ, self.floatHsize, self.floatVsize, self.floatScaling ] for w in changeIndicatedLEs: w.returnPressed.connect(self.emitParamsChange) self.spinBoxPage.valueChanged.connect(self.emitParamsChange) self.ChangeButton.clicked.connect(self.change) ObjectMgr().sigGuiParamChanged.connect(self.paramChanged) #validators: # allow only double values for changeIndicatedLEs doubleValidator = QtGui.QDoubleValidator(self) self.floatX.setValidator(doubleValidator) self.floatY.setValidator(doubleValidator) self.floatZ.setValidator(doubleValidator) self.floatHsize.setValidator(doubleValidator) self.floatVsize.setValidator(doubleValidator) self.floatScaling.setValidator(doubleValidator) self.spinBoxPage.setMinimum(1) self.spinBoxPage.setMaximum(1) self.currentImage_ = None self.currentPixmap_ = None self.documentsInGUI_ = covise.coConfigIsOn("vr-prepare.DocumentsInGUI", False)
def takeSnapshot(self): _infoer.function = str(self.takeSnapshot) _infoer.write("") filename = "" if covise.coConfigIsOn("vr-prepare.ShowSnapshotDialog", True): directory = covise.getCoConfigEntry("COVER.Plugin.PBufferSnapShot.Directory") if (directory == None): directory = "snapshot.png" else: directory = directory + "/" + "snapshot.png" filenameQt = QtWidgets.QFileDialog.getSaveFileName( self, self.__tr('Snapshot'), directory, self.__tr('Image (*.png)'), None, QtWidgets.QFileDialog.DontConfirmOverwrite) if filenameQt == "": return #filenameQt is filename + extension touple filename = filenameQt[0] print(filename) if not filename.lower().endswith(".png"): filename += ".png" if os.path.exists(filename): asker = ReallyWantToOverrideAsker(self, filename) decicion = asker.exec_() if decicion == QtWidgets.QDialog.Rejected: self.statusBar().showMessage( self.__tr('Cancelled overwrite of "%s"') % filename ) return msg = coGRSnapshotMsg( filename, "snapOnce" ) covise.sendRendMsg(msg.c_str())
def _initBase(self, modName, geoInputNames=['GridIn0'], octtreeInputNames=[], geoSampleNames=[], dataSampleNames=[], \ dataInputNames=[], scalarInputNames=[], twoDInputNames=[], sampleType=1, bbox = True, octtree= True): '''called from the constructor and after the class was unpickled ''' self._module = None self._lastDataConnection = None self._lastScalarConnection = None self._last2DPartConnection = None self._moduleName = modName self._geoInputNames = geoInputNames self._octtreeInputNames = octtreeInputNames self._geoSampleNames = geoSampleNames self._dataSampleNames = dataSampleNames self._sampleType = sampleType self._dataInputNames = dataInputNames self._scalarInputNames = scalarInputNames self._2DPartInputNames = twoDInputNames self.__createBBox = bbox self.__createOcttree = octtree self.__firstTime = True self.__connectedToCOVER = False #register for UI Actions self._registered = False self._firstGeoForVars = True if not covise.coConfigIsOn("vr-prepare.UseSamplingModules", False): self._geoSampleNames = [] self._dataSampleNames = []
def executeSampleData(self, varname, bbox=None, outside=USER_DEFINED): if not covise.coConfigIsOn("vr-prepare.UseSamplingModules", False): return self._updateSample(2, varname, bbox, outside) sample = self._sample saveExecute(sample)
def executeSampleGeo( self, dim ): if not covise.coConfigIsOn("vr-prepare.UseSamplingModules", False): return self._updateSample( dim ) # if not Import2DModule.executeGeo(self): if not ParentClass2D.executeGeo(self): saveExecute(self._sample)
def updateForObject( self, key): self.__key = key scalar = ObjectMgr().getPossibleScalarVariablesForType(self.__key) vector = ObjectMgr().getPossibleVectorVariablesForType(self.__key) if covise.coConfigIsOn("vr-prepare.UseComposedVelocity", False): myObject = globalKeyHandler().getObject(key) while (myObject.typeNr == TYPE_2D_CUTGEOMETRY_PART): myObject = globalKeyHandler().getObject(myObject.parentKey) if (myObject.typeNr == TYPE_2D_COMPOSED_PART): scalar.append(COMPOSED_VELOCITY) self._setScalarVariables(scalar) self._setVectorVariables(vector) self.setGridName(ObjectMgr().getNameOfType(self.__key))
def run(self, runmode, negMsgHandler=None): if runmode==RUN_GEO: self.importModule.executeGeo() elif runmode==RUN_OCT: self.importModule.executeOct() # sample over first vel value if covise.coConfigIsOn("vr-prepare.UseSamplingModules", False): if not self.importModule.getIsTransient(): for v in self.params.partcase.variables: if v.variableDimension==3: self.importModule.executeSampleData(v.name) else: coKeydObject.run(self, runmode, negMsgHandler)
def executeSampleData(self, varname, bbox=None, outside=USER_DEFINED): if not covise.coConfigIsOn("vr-prepare.UseSamplingModules", False): return if bbox==None: if not (varname,outside) in self._bbox: self._bbox[(varname,outside)] = Box() box = self._bbox[(varname,outside)] else: box = bbox self._updateSample( varname, box, outside) sample = self._sample[(varname,outside)] saveExecute(sample)
def __init__(self, parent=None): QtWidgets.QWidget.__init__(self, parent) Ui_GenericVisualizerPanelBase.__init__(self) self.setupUi(self) #current object key self.__key = -1 # remove unneccessary tabs self.TabWidgetGeneralAdvanced.removeTab(self.TabWidgetGeneralAdvanced.indexOf(self.tabAdjustmentStreamline)) self.TabWidgetGeneralAdvanced.removeTab(self.TabWidgetGeneralAdvanced.indexOf(self.tabAdjustmentCuttingSurface)) self.TabWidgetGeneralAdvanced.removeTab(self.TabWidgetGeneralAdvanced.indexOf(self.tabAdvanced)) self.TabWidgetGeneralAdvanced.removeTab(self.TabWidgetGeneralAdvanced.indexOf(self.tabClipPlane)) self.TabWidgetGeneralAdvanced.removeTab(self.TabWidgetGeneralAdvanced.indexOf(self.tabPositioning)) self.__generalTab = self.tab self.__generalTabText = self.TabWidgetGeneralAdvanced.tabText(self.TabWidgetGeneralAdvanced.indexOf(self.tab)) self.TabWidgetGeneralAdvanced.setCurrentIndex(0) # ignore index set by the designer (usually no one cares about the active index when editing ui-files) self.visibilityCheckBox.setVisible(covise.coConfigIsOn("vr-prepare.AdditionalVisibilityCheckbox", False)) #default setting of the panel self.vrpCheckBoxMapVariable.hide() self.vrpComboBoxVariable.hide() #self.vrpToolButtonChain.hide() self.floatInRangeEndPointX.hide() self.floatInRangeEndPointY.hide() self.floatInRangeEndPointZ.hide() self.textEndPointX.hide() self.textEndPointY.hide() self.textEndPointZ.hide() self.checkBoxFreeStartpoints.hide() self.vrpPushButtonAdjustPreview.hide() self.__baseVariable = None #temporary storage of this parameter part self.colorCreator = None middleFloatInRangeCtrls = [self.floatInRangeX] self.__boundingBox = ((-1, 1), (-1, 1), (-1, 1)) for w, r in zip(middleFloatInRangeCtrls, self.__boundingBox): w.setRange(r) sideRange = 0, self.__heuristicProbeMaxSideLengthFromBox( self.__boundingBox) DomainSurfacePanelConnector(self)
def addGrid(self, key, name, vectorvars): if not key in self.__key2name.keys(): self.__key2name[key] = name self.CheckBoxVariable[key] = QtWidgets.QCheckBox(self.box) self.CheckBoxVariable[key].setGeometry(QtCore.QRect(10,20,150,24)) self.CheckBoxVariable[key].setText(name) self.CheckBoxVariable[key].setChecked(True) self.CheckBoxVariable[key].toggled.connect(self.checkSelection) self.ComboBoxVariable[key] = QtWidgets.QComboBox(self.box) self.ComboBoxVariable[key].setGeometry(QtCore.QRect(160,20,178,24)) self.ComboBoxVariable[key].setSizePolicy(QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred,QtWidgets.QSizePolicy.Fixed)) self.ComboBoxVariable[key].setCursor(QtGui.QCursor(QtCore.Qt.CursorShape(13))) for varname in vectorvars: self.ComboBoxVariable[key].addItem(varname) self.boxLayout.addWidget(self.CheckBoxVariable[key], self.cnt, 0) self.boxLayout.addWidget(self.ComboBoxVariable[key], self.cnt, 1) self.ComboBoxVariable[key].setVisible(covise.coConfigIsOn("vr-prepare.UseComposedVelocity", False)) self.cnt=self.cnt+1
def __readButtonConfig(self): # read buttons from config buttonList = covise.getCoConfigSubEntries("vr-prepare.TrackingManager.ButtonMap") completeButtonList = ['TRANS_LEFT', 'TRANS_RIGHT', 'TRANS_UP', 'TRANS_DOWN', 'TRANS_FRONT', 'TRANS_BACK', \ 'ROT_X_MINUS', 'ROT_X_PLUS', 'ROT_Y_MINUS', 'ROT_Y_PLUS', 'ROT_Z_MINUS', 'ROT_Z_PLUS', \ 'SCALE_PLUS', 'SCALE_MINUS'] for b in buttonList: if b in completeButtonList: self.__dict__[b] = int(covise.getCoConfigEntry("vr-prepare.TrackingManager.ButtonMap." + b, "button")) # if not all buttons are described in config.vr-prepare.xml for b in completeButtonList: if not b in self.__dict__.keys(): self.__dict__[b] = -1 TranslateBarrier = covise.getCoConfigEntry("vr-prepare.TrackingManager.TranslateBarrier") if TranslateBarrier: self.TranslateBarrier = float(TranslateBarrier) else: self.TranslateBarrier = 1.0 self.VRCJoystick = covise.coConfigIsOn("vr-prepare.TrackingManager.VRCJoystick", False) # buttons for vrml sensors ButtonSensor1 = covise.getCoConfigEntry("vr-prepare.TrackingManager.ButtonSensor1") ButtonSensor2 = covise.getCoConfigEntry("vr-prepare.TrackingManager.ButtonSensor2") if ButtonSensor1: self.BUTTON_SENSOR_1 = int(ButtonSensor1) else: self.BUTTON_SENSOR_1 = -1 if ButtonSensor2: self.BUTTON_SENSOR_2 = int(ButtonSensor2) else: self.BUTTON_SENSOR_2 = -1 WrlName = covise.getCoConfigEntry("vr-prepare.TrackingManager.WrlName") if WrlName: self.wrl_name = WrlName else: self.wrl_name = ""
def __init__(self, parent=None): QtWidgets.QWidget.__init__(self, parent) Ui_VectorFieldPanelBase.__init__(self) self.setupUi(self) TransformManager.__init__(self, self.emitTransformChanged) #current object key self.__key = -1 # for custom RGB color self.__r = None self.__g = None self.__b = None self.__coloringOption = None #default setting of the panel self.vrpCheckBoxMapVariable.setEnabled(False) self.vrpComboBoxVariable.setEnabled(False) self.vrpLineEditVariable.hide() self.__baseVariable = None #temporary storage of this parameter part self.colorCreator = None # middleFloatInRangeCtrls = [self.floatInRangeScalingValue] # self.__boundingBox = ((-1, 1), (-1, 1), (-1, 1)) # for w, r in zip(middleFloatInRangeCtrls, self.__boundingBox): # w.setRange(r) # sideRange = 0, self.__heuristicProbeMaxSideLengthFromBox(self.__boundingBox) VectorFieldPanelConnector(self) self.visibilityCheckBox.setVisible(covise.coConfigIsOn("vr-prepare.AdditionalVisibilityCheckbox", False)) # set up initial radio group status self.emitChangedRadioGroup()
def __init__(self, parent=None): _infoer.function = str(self.__init__) _infoer.write("") QtWidgets.QWidget.__init__(self, parent) Ui_GenericVisualizerPanelBase.__init__(self) self.setupUi(self) # current object key self.__key = -1 self.TabWidgetGeneralAdvanced.removeTab(self.TabWidgetGeneralAdvanced.indexOf(self.tabAdjustmentCuttingSurface)) self.TabWidgetGeneralAdvanced.removeTab(self.TabWidgetGeneralAdvanced.indexOf(self.tabClipPlane)) self.TabWidgetGeneralAdvanced.setCurrentIndex(0) # ignore index set by the designer (usually no one cares about the active index when editing ui-files) self.visibilityCheckBox.setVisible(covise.coConfigIsOn("vr-prepare.AdditionalVisibilityCheckbox", False)) self.vrpPushButtonAdjustPreview.hide() # manager handling the starting rectangle self.__rectangleManager = RectangleManager( self, self.emitTraceParametersApply, self.emitRadioBttnsTracerApply, self.emitRectangleChange ) # keys of 2D objects in combobox self.__key2UsePart = {} self.__UsePart2key = {} # current task type self.__taskType = STREAMLINE # start style of tracer to that the panel will change self.__startStyle = PLANE self.__baseVariable = None #temporary storage of this parameter part self.colorCreator = None # qt connections and settings StreamlinesPanelConnector(self)
def geoSampleConnectionPoint(self, varname=None, outside=USER_DEFINED): if not covise.coConfigIsOn("vr-prepare.UseSamplingModules", False): return self._initSample(varname, outside) return ConnectionPoint(self._showgrid, 'points')
def __init__(self): VisualizationPanel.__init__(self) self.vrpLocalisationLabel.hide() self.vrpLabelLocalisation.hide() #dictionaries to enable the buttons self._enableDictComposedMode = { self.CuttingSurfaceColoredPushButton: False, self.IsoSurfacePushButton: False, self.IsoCutterPushButton: False, self.ClipIntervalPushButton: False, self.MovingPointsPushButton: False, self.PathlinesPushButton: False, self.ProbingPointPushButton: False, #True self.ProbingSquarePushButton: False, self.StreaklinesPushButton: False, self.Streamlines2DPushButton: False, self.SurfaceVectorsPushButton: False, self.MagmaTracePushButton: False, } self._enableDictVectorVariable = { self.CuttingSurfaceColoredPushButton: True, self.IsoSurfacePushButton: False, self.IsoCutterPushButton: False, self.ClipIntervalPushButton: False, self.MovingPointsPushButton: True, self.PathlinesPushButton: True, self.ProbingPointPushButton: False, self.ProbingSquarePushButton: False, self.StreaklinesPushButton: True, self.Streamlines2DPushButton: True, self.SurfaceVectorsPushButton: True, self.MagmaTracePushButton: False, } self._enableDictScalarVariable = { self.CuttingSurfaceColoredPushButton: True, self.IsoSurfacePushButton: True, self.IsoCutterPushButton: True, self.ClipIntervalPushButton: True, self.MovingPointsPushButton: False, self.PathlinesPushButton: False, self.ProbingPointPushButton: False, #True self.ProbingSquarePushButton: False, #True self.StreaklinesPushButton: False, self.Streamlines2DPushButton: False, self.SurfaceVectorsPushButton: False, self.MagmaTracePushButton: True, } #disabled buttons self._disablees = [ self.CuttingSurfaceColoredPushButton, self.IsoSurfacePushButton, self.ProbingPointPushButton, self.ProbingSquarePushButton, self.MovingPointsPushButton, self.PathlinesPushButton, self.StreaklinesPushButton, ] # hide buttons if not covise.coConfigIsOn("CFDGui.VISUALIZER_MAGMATRACE"): self.MagmaTracePushButton.hide() # current key self.__key = None self._disableBrokenParts() self.Streamlines2DPushButton.clicked.connect(self.emitStreamline2DRequest) self.MovingPointsPushButton.clicked.connect(self.emitMovingPointsRequest) self.PathlinesPushButton.clicked.connect(self.emitPathlinesRequest) self.vrpComboBoxVariable.activated[str].connect(self._enableMethodButtsForVariableSlot) self.CuttingSurfaceColoredPushButton.clicked.connect(self.emitPlaneRequest) self.IsoSurfacePushButton.clicked.connect(self.emitIsoPlaneRequest) self.IsoCutterPushButton.clicked.connect(self.emitIsoCutterRequest) self.ClipIntervalPushButton.clicked.connect(self.emitClipIntervalRequest) self.SurfaceVectorsPushButton.clicked.connect(self.emitVectorFieldRequest) self.MagmaTracePushButton.clicked.connect(self.emitMagmaTraceRequest)
def dataSampleConnectionPoint(self, varname=None, outside=USER_DEFINED): if not covise.coConfigIsOn("vr-prepare.UseSamplingModules", False): return self._initSample( varname, outside) return ConnectionPoint(self._sample[(varname,outside)], 'DataOut')
def dataSampleConnectionPoint(self, varname=None, outside=USER_DEFINED): if not covise.coConfigIsOn("vr-prepare.UseSamplingModules", False): return self._initSample(varname, outside) return ConnectionPoint(self._sample, 'DataOut')
def __init__(self, parent=None): QtWidgets.QWidget.__init__(self, parent) Ui_GenericVisualizerPanelBase.__init__(self) self.setupUi(self) #current object self.__key = -1 self.vrpPushButtonAdjustPreview.hide() self.floatInRangeRotX.setEnabled(False) self.floatInRangeRotY.setEnabled(True) self.floatInRangeRotZ.setEnabled(True) self.floatInRangeEndPointX.hide() self.floatInRangeEndPointY.hide() self.floatInRangeEndPointZ.hide() self.textEndPointX.hide() self.textEndPointY.hide() self.textEndPointZ.hide() self.vrpCheckBoxShow.setText(self.__tr("Show Preview")) self.vrpGroupBoxPositioning.setTitle(self.__tr("Plane Positioning")) self.checkBoxFreeStartpoints.hide() self.vrpCheckBoxMapVariable.hide() self.vrpComboBoxVariable.hide() self.textLabel4_3_3.hide() self.floatInRangeWidth.hide() self.textLabel4_3_2_3.hide() self.floatInRangeHeight.hide() self.checkBoxDomainFromList.hide() self.comboBoxDomain.hide() self.checkBoxFreeStartpoints.hide() self.groupOrientation.setTitle(self.__tr("Normal:")) # change tooltips self.textLabel4_4_3.setToolTip(self.__tr("x, y, z define one point on the plane.")) self.textLabel4_4_3.setWhatsThis(self.__tr("x, y, z define one point on the plane.")) self.textLabel4_4_2_3.setToolTip(self.__tr("x, y, z define one point on the plane.")) self.textLabel4_4_2_3.setWhatsThis(self.__tr("x, y, z define one point on the plane.")) self.textLabel4_4_2_2_2.setToolTip(self.__tr("x, y, z define one point on the plane.")) self.textLabel4_4_2_2_2.setWhatsThis(self.__tr("x, y, z define one point on the plane.")) self.xAxisRadioButton.setToolTip(self.__tr("Orientation defines the normal of the plane.")) self.xAxisRadioButton.setWhatsThis(self.__tr("Orientation defines the normal of the plane.")) self.yAxisRadioButton.setToolTip(self.__tr("Orientation defines the normal of the plane.")) self.yAxisRadioButton.setWhatsThis(self.__tr("Orientation defines the normal of the plane.")) self.zAxisRadioButton.setToolTip(self.__tr("Orientation defines the normal of the plane.")) self.zAxisRadioButton.setWhatsThis(self.__tr("Orientation defines the normal of the plane.")) self.textLabelRotX.setToolTip(self.__tr("For finetuning the orientation<br> of the plane, you can add rotations around each axis.")) self.textLabelRotX.setWhatsThis(self.__tr("For finetuning the orientation<br> of the plane, you can add rotations around each axis.")) self.textLabelRotY.setToolTip(self.__tr("For finetuning the orientation<br> of the plane, you can add rotations around each axis.")) self.textLabelRotY.setWhatsThis(self.__tr("For finetuning the orientation<br> of the plane, you can add rotations around each axis.")) self.textLabelRotZ.setToolTip(self.__tr("For finetuning the orientation<br> of the plane, you can add rotations around each axis.")) self.textLabelRotZ.setWhatsThis(self.__tr("For finetuning the orientation<br> of the plane, you can add rotations around each axis.")) self.TabWidgetGeneralAdvanced.removeTab(self.TabWidgetGeneralAdvanced.indexOf(self.tabAdjustmentStreamline)) self.TabWidgetGeneralAdvanced.removeTab(self.TabWidgetGeneralAdvanced.indexOf(self.tabAdvanced)) self.TabWidgetGeneralAdvanced.setCurrentIndex(0) # ignore index set by the designer (usually no one cares about the active index when editing ui-files) self.visibilityCheckBox.setVisible(covise.coConfigIsOn("vr-prepare.AdditionalVisibilityCheckbox", False)) # manager handling the starting rectangle self.__rectangleManager = RectangleManager( self, self.emitPlaneParametersApply, self.emitPlaneParametersApply, self.emitRectangleChange, CUTTINGSURFACE ) self.__vector = PLANE self.__baseVariable = None #temporary storage of this parameter part self.colorCreator = None #qt connections and settings CuttingSurfacePanelConnector(self)
def setParams(self, params, negMsgHandler=None, sendToCover=False): _infoer.function = str(self.setParams) _infoer.write(" ") # change of maxIdx means shorten the history oldParams = self.params changedParams = ParamsDiff( self.params, params) if hasattr(params, 'currentStep'): diffStep = params.currentStep - oldParams.currentStep else: diffStep = params.currentKey - oldParams.currentKey coKeydObject.setParams( self, params ) if 'currentKey' in changedParams or 'reloadStep' in changedParams: if os.getenv('VR_PREPARE_DEBUG_VISITEMS_DIR'): for key in globalKeyHandler().getAllElements(): if globalKeyHandler().getObject(key) and isinstance(globalKeyHandler().getObject(key), VisItem): globalKeyHandler().getObject(key).updateDebugFilename(self.params.currentKey) # send message presentationstep changed if diffStep == 1: msg = coGRKeyWordMsg("presForward", True) covise.sendRendMsg(msg.c_str()) elif diffStep == -1: msg = coGRKeyWordMsg("presBackward", True) covise.sendRendMsg(msg.c_str()) elif 'reloadStep' in changedParams: msg = coGRKeyWordMsg("presReload", True) covise.sendRendMsg(msg.c_str()) else: msg_str = "goToStep "+str(params.currentStep) msg = coGRKeyWordMsg(msg_str, True) covise.sendRendMsg(msg.c_str()) if negMsgHandler: #if hasattr(globalKeyHandler().getObject(self.params.currentKey).params, 'status'): key2stateParam = globalKeyHandler().getObject(self.params.currentKey).params.status project = globalKeyHandler().getObject(0) keysInProject = [] keysInProject.append(globalProjectKey) self.__addToList(project, keysInProject) orderedKeysInProject1 = [] orderedKeysInProject2 = [] for key in keysInProject: # put some objects at the beginning of the list obj = globalKeyHandler().getObject(key) #check if visItem is readyToChange otherwise send message if diffStep > 0 and hasattr(obj.params, 'nextPresStep') and not obj.params.nextPresStep and covise.coConfigIsOn("vr-prepare.SolvePresentationStep"): #roll back changes negMsgHandler.sendParams(globalPresentationMgrKey, oldParams) msg = coGRKeyWordMsg("showNotReady", True) covise.sendRendMsg(msg.c_str()) return if (obj.typeNr in [VIS_DOCUMENT, TYPE_TRACKING_MGR]): orderedKeysInProject1.append(key) else: orderedKeysInProject2.append(key) orderedKeysInProject1.extend(orderedKeysInProject2) for key in orderedKeysInProject1: if key in key2stateParam: params = key2stateParam[key] if not hasattr(params, 'flyingMode'): # do not save settings of viewpointMgr obj = globalKeyHandler().getObject(key) newparams = CopyParams(obj.getParams()) # take the objects params as base (so we have all the merged defaultParams) paramChanged = False for pkey in params.__dict__: if pkey in newparams.__dict__: if covise.coConfigIsOn("vr-prepare.DoNotUpdateCuttingSurfaces", False) \ and isinstance(obj, PartCuttingSurfaceVis. PartCuttingSurfaceVis) and pkey=='isVisible': pass elif hasattr(newparams, "isStaticParam") and newparams.isStaticParam(pkey): # skip static params pass elif pkey=='actTimeStep' and (not hasattr(params, 'version') or params.__dict__['version'] < 7): # change actual timestep for old 6.0 projects newparams.__dict__[pkey] = params.__dict__[pkey] -1 if newparams.__dict__[pkey] < 0: newparams.__dict__[pkey] = newparams.__dict__['numTimeSteps'] - 1 paramChanged = True elif (pkey=='autoActiveSensorIDs') and (len(params.autoActiveSensorIDs) > 0): # always set params if the new step has autoActiveSensorIDs newparams.__dict__[pkey] = copy.deepcopy(params.__dict__[pkey]) paramChanged = True else: if (newparams.__dict__[pkey] != params.__dict__[pkey]): newparams.__dict__[pkey] = copy.deepcopy(params.__dict__[pkey]) # need a deepcopy in case we have a list/dict paramChanged = True if (paramChanged): if key != globalProjectKey and 'currentKey' in changedParams: negMsgHandler.presentationRecvParams( key, newparams ) negMsgHandler.sendParams(key, newparams) elif key != globalProjectKey: negMsgHandler.presentationRecvParams( key, newparams, True) #TODO, ueberpruefen, ob das nach kompletter portierung noetig ist negMsgHandler.sendParams(key, newparams) else : negMsgHandler.sendParams(key, newparams) project.setParams(newparams) project.sendMessages() # hide all visItem which are not in list else: params = globalKeyHandler().getObject(key).params if params: #do not save settings of viewpointMgr if not hasattr(params, 'flyingMode'): if hasattr(params, 'isVisible') and params.isVisible: cparams = CopyParams(params) cparams.isVisible = False negMsgHandler.presentationRecvParams( key, cparams) negMsgHandler.sendParams(key, cparams)
def isTransientCB(self, isTransient): if covise.coConfigIsOn("vr-prepare.Panels.AnimationManager", "visible", True): Application.vrpApp.mw.showAnimationWindow(isTransient) Application.vrpApp.mw.windowAnimation_ManagerAction.setEnabled(isTransient)
# Set the socket parameters secondUDP_IP = covise.getCoConfigEntry("vr-prepare.SecondUDP.IP") if secondUDP_IP: host = QHostAddress(secondUDP_IP) else: host = QHostAddress("127.0.0.1") secondUDP_Port = covise.getCoConfigEntry("vr-prepare.SecondUDP.Port") if secondUDP_Port: port = int(secondUDP_Port) else: port = 6666 buf = 1024 addr = (host,port) # Create socket and bind to address if covise.coConfigIsOn("vr-prepare.SecondUDP"): UDPSock = QUdpSocket() UDPSock.bind(port) udpMode = True except: pass #-------- # # receiver thread filling up the global message queue # class Rec(Thread): #================ lastInfo_ = ""
from VRPCoviseNetAccess import saveExecute, connect, disconnect, theNet, ConnectionPoint, RWCoviseModule#, TransformModule from coPyModules import BoundingBox, MakeOctTree, Colors, RWCovise from BoundingBox import BoundingBoxParser, Box import coviseStartup from coviseCase import SCALARVARIABLE from Utils import getExistingFilename from ErrorManager import CoviseFileNotFoundError from printing import InfoPrintCapable _infoer = InfoPrintCapable() _infoer.doPrint = False # True enableCachedOctTrees = False if covise.coConfigIsOn("vr-prepare.CachedOctTrees"): enableCachedOctTrees = True """ ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ """ """ """ """ import a part( 2d or 3d geometry) and all data on that part """ """ """ """ load files only once """ """ """ """ ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ """ class ImportModule(object): def __init__(self, dimension, partcase ): global testPath self._dim = dimension
def _init(self, negMsgHandler, sampleType=None): '''called from _update if module exists connect output of it to COVER ''' if not sampleType == None: self._sampleType = sampleType if self._module == None and hasattr(self, 'importModule') and self.__firstTime: self.__firstTime = False self._module = self._moduleName() theNet().add(self._module) # need to execute blockcollect for geo if type(self.importModule) == ImportGroupManager.ImportGroup3DModule: self.importModule.executeGeo() for geoInput in self._geoInputNames: connect( self.importModule.geoConnectionPoint(), ConnectionPoint(self._module, geoInput) ) if self.__createOcttree: if len(self._octtreeInputNames) > 0: for octtree in self._octtreeInputNames: connect( self.importModule.octTreeConnectionPoint(), ConnectionPoint(self._module, octtree) ) self.importModule.executeOct() if (len(self._dataInputNames)>0): if hasattr(self.params, 'variable') and self.params.variable and self.params.variable!='Select a variable' and self.params.variable != 'unset': for dataInput in self._dataInputNames: connect( self.importModule.dataConnectionPoint(self.params.variable), ConnectionPoint(self._module, dataInput) ) if len(self._geoSampleNames) > 0 and not self.importModule.getIsTransient(): if hasattr(self.params, 'variable') and self.params.variable and self.params.variable!='Select a variable' and self.params.variable != 'unset': assert self.params.variable!='Select a variable' self.importModule.executeSampleData(self.params.variable, None, self._sampleType) for geoSample in self._geoSampleNames: connect( self.importModule.geoSampleConnectionPoint(self.params.variable, self._sampleType), ConnectionPoint(self._module, geoSample) ) if len(self._dataSampleNames) > 0 and not self.importModule.getIsTransient(): if hasattr(self.params, 'variable') and self.params.variable and self.params.variable!='Select a variable' and self.params.variable != 'unset': assert self.params.variable!='Select a variable' for dataSample in self._dataSampleNames: connect( self.importModule.dataSampleConnectionPoint(self.params.variable, self._sampleType), ConnectionPoint(self._module, dataSample) ) self.reloadBBox() # optionally connect to COVER if not covise.coConfigIsOn("vr-prepare.InvisibleConnectToRenderer", True): # only connect to COVER if this visualizer really is visible if self.params.isVisible and not self.__connectedToCOVER: VisItem.connectToCover( self, self ) self.__connectedToCOVER = True else: VisItem.connectToCover( self, self ) self.__connectedToCOVER = True # refresh all connections as they might have changed if self._module != None and hasattr(self, 'importModule'): for geoInput in self._geoInputNames: theNet().disconnectAllFromModulePort(self._module, geoInput) # remove all connections at the inport connect( self.importModule.geoConnectionPoint(), ConnectionPoint(self._module, geoInput) ) if self.__createOcttree: for octtree in self._octtreeInputNames: theNet().disconnectAllFromModulePort(self._module, octtree) # remove all connections at the inport connect( self.importModule.octTreeConnectionPoint(), ConnectionPoint(self._module, octtree) ) if (len(self._dataInputNames)>0): if hasattr(self.params, 'variable') and self.params.variable and self.params.variable!='Select a variable' and self.params.variable != 'unset': for dataInput in self._dataInputNames: theNet().disconnectAllFromModulePort(self._module, dataInput) connect( self.importModule.dataConnectionPoint(self.params.variable), ConnectionPoint(self._module, dataInput) ) if hasattr(self.params, 'variable') and self.params.variable and self.params.variable!='Select a variable' and self.params.variable != 'unset': if self.params.variable != 'Select a variable' and not self.importModule.getIsTransient(): for geoSample in self._geoSampleNames: theNet().disconnectAllFromModulePort(self._module, geoSample) connect( self.importModule.geoSampleConnectionPoint(self.params.variable, self._sampleType), ConnectionPoint(self._module, geoSample) ) if hasattr(self.params, 'variable') and self.params.variable and self.params.variable!='Select a variable' and self.params.variable != 'unset': if self.params.variable != 'Select a variable' and not self.importModule.getIsTransient(): for dataSample in self._dataSampleNames: theNet().disconnectAllFromModulePort(self._module, dataSample) connect( self.importModule.dataSampleConnectionPoint(self.params.variable, self._sampleType), ConnectionPoint(self._module, dataSample) ) self.reloadBBox() # connect to COVER if visible and wasnt done initially if self.params.isVisible and not self.__connectedToCOVER: VisItem.connectToCover( self, self ) self.__connectedToCOVER = True
def sendImagePathToWebserver(self): if covise.coConfigIsOn("vr-prepare.RemoteDeviceControll", False) and self.params.imageName != None: import os import vtrans import PathTranslator # starting point of # image path processing imageName = self.params.imageName sNum = '1' # compute the image corresponding to step number imageName = imageName.replace('\\', '/') ## just to be shure imageName = imageName.replace(os.sep, '/') pos = imageName.rfind('/') if pos >= 0: dirName = imageName[:pos] baseName = imageName[pos+1:] imageNumber = int(self.params.pageNo) imageSuffix = '' nPos = baseName.rfind('.') if nPos >= 0: sNum = baseName[:nPos] imageSuffix = baseName[nPos+1:] iNum = int(sNum) # for backward compatibility # in cc versions lesser than 3.2 # images were alloed to start with zero (0.png) if iNum == 0: imageNumber = int(self.params.pageNo) - 1 #compose all back togerther imageName = dirName + '/' + str(imageNumber) + '.' + imageSuffix # get the language environment settings coPath = vtrans.covisePath localePrefix = covise.getCoConfigEntry("COVER.Localization.LocalePrefix") languageLocale = vtrans.languageLocale loc = localePrefix + "/" + languageLocale fullPathToImage = coPath + "/" +imageName # retrieve localized path fullPathToImage = PathTranslator.translate_path(loc, fullPathToImage) # retrieve relative path again imageName = fullPathToImage[len(coPath)+1:] path_to_current_image = imageName # again... # this time for the browser # compute the image corresponding to step number path_to_current_image = path_to_current_image.replace('\\', '/') ## just to be shure path_to_current_image = path_to_current_image.replace(os.sep, '/') # pack the message msg = 'VRT IMAGE ' + path_to_current_image + '.' + str(self.params.maxPage)+ '.' + sNum # send it away destinationHost = covise.getCoConfigEntry("vr-prepare.RemoteDeviceHost") if not destinationHost: destinationHost = "127.0.0.1" destinationPort = covise.getCoConfigEntry("vr-prepare.RemoteDevicePort") if not destinationPort: destinationPort = "44142" sock = socket.socket(socket.AF_INET,socket.SOCK_DGRAM) sock.sendto( str(msg),(destinationHost,int(destinationPort)) )