def execute(self):
     """
     Kick off the execution of the step, in this case an interactive dialog.
     User invokes the _doneExecution() method when finished, via pushbutton.
     """
     self._model = MeshGeneratorModel(self._location, self._config['identifier'])
     self._view = MeshGeneratorWidget(self._model)
     self._view.registerDoneExecution(self._doneExecution)
     self._setCurrentWidget(self._view)
Esempio n. 2
0
 def execute(self):
     """
     Kick off the execution of the step, in this case an interactive dialog.
     User invokes the _doneExecution() method when finished, via pushbutton.
     """
     self._model = MasterModel(self._location, self._config['identifier'])
     self._view = MeshGeneratorWidget(self._model)
     self._view.setImageInfo(self._images_info)
     # self._view.setWindowFlags(QtCore.Qt.Widget)
     self._view.registerDoneExecution(self._myDoneExecution)
     self._setCurrentWidget(self._view)
 def execute(self):
     """
     Kick off the execution of the step, in this case an interactive dialog.
     User invokes the _doneExecution() method when finished, via pushbutton.
     """
     self._model = MasterModel(self._location, self._config['identifier'])
     if self._port1_inputZincDataFile:
         self._model.setSegmentationDataFile(self._port1_inputZincDataFile)
     self._view = MeshGeneratorWidget(self._model)
     # self._view.setWindowFlags(QtCore.Qt.Widget)
     self._view.registerDoneExecution(self._myDoneExecution)
     self._setCurrentWidget(self._view)
class MeshGeneratorStep(WorkflowStepMountPoint):
    """
    Skeleton step which is intended to be a helpful starting point
    for new steps.
    """
    def __init__(self, location):
        super(MeshGeneratorStep, self).__init__('Mesh Generator', location)
        self._configured = False  # A step cannot be executed until it has been configured.
        self._category = 'Source'
        # Add any other initialisation code here:
        self._icon = QtGui.QImage(
            ':/meshgeneratorstep/images/model-viewer.png')
        # Ports:
        self.addPort(
            ('http://physiomeproject.org/workflow/1.0/rdf-schema#port',
             'http://physiomeproject.org/workflow/1.0/rdf-schema#provides',
             'http://physiomeproject.org/workflow/1.0/rdf-schema#file_location'
             ))
        # Port data:
        self._portData0 = None  # http://physiomeproject.org/workflow/1.0/rdf-schema#file_location
        # Config:
        self._config = {}
        self._config['identifier'] = ''
        self._config['AutoDone'] = False
        self._model = None
        self._view = None

    def execute(self):
        """
        Kick off the execution of the step, in this case an interactive dialog.
        User invokes the _doneExecution() method when finished, via pushbutton.
        """
        self._model = MasterModel(self._location, self._config['identifier'])
        self._view = MeshGeneratorWidget(self._model)
        # self._view.setWindowFlags(QtCore.Qt.Widget)
        self._view.registerDoneExecution(self._myDoneExecution)
        self._setCurrentWidget(self._view)

    def _myDoneExecution(self):
        self._portData0 = self._model.getOutputModelFilename()
        self._view = None
        self._model = None
        self._doneExecution()

    def getPortData(self, index):
        """
        Add your code here that will return the appropriate objects for this step.
        The index is the index of the port in the port list.  If there is only one
        provides port for this step then the index can be ignored.

        :param index: Index of the port to return.
        """
        return self._portData0  # http://physiomeproject.org/workflow/1.0/rdf-schema#file_location

    def setPortData(self, index, data):
        pass

    def configure(self):
        """
        This function will be called when the configure icon on the step is
        clicked.  It is appropriate to display a configuration dialog at this
        time.  If the conditions for the configuration of this step are complete
        then set:
            self._configured = True
        """
        dlg = ConfigureDialog(
            QtGui.QApplication.activeWindow().currentWidget())
        dlg.identifierOccursCount = self._identifierOccursCount
        dlg.setConfig(self._config)
        dlg.validate()
        dlg.setModal(True)

        if dlg.exec_():
            self._config = dlg.getConfig()

        self._configured = dlg.validate()
        self._configuredObserver()

    def getIdentifier(self):
        """
        The identifier is a string that must be unique within a workflow.
        """
        return self._config['identifier']

    def setIdentifier(self, identifier):
        """
        The framework will set the identifier for this step when it is loaded.
        """
        self._config['identifier'] = identifier

    def serialize(self):
        """
        Add code to serialize this step to string.  This method should
        implement the opposite of 'deserialize'.
        """
        return json.dumps(self._config,
                          default=lambda o: o.__dict__,
                          sort_keys=True,
                          indent=4)

    def deserialize(self, string):
        """
        Add code to deserialize this step from string.  This method should
        implement the opposite of 'serialize'.

        :param string: JSON representation of the configuration in a string.
        """
        self._config.update(json.loads(string))

        d = ConfigureDialog()
        d.identifierOccursCount = self._identifierOccursCount
        d.setConfig(self._config)
        self._configured = d.validate()