Beispiel #1
0
    def setInSlot(self, slot, subindex, roi, value):
        key = roi.toSlice()
        if slot == self.WriteSeeds:
            with Timer() as timer:
                logger.info("Writing seeds to label array")
                self.opLabelArray.LabelSinkInput[roi.toSlice()] = value
                logger.info(
                    "Writing seeds to label array took {} seconds".format(
                        timer.seconds()))

            assert self._mst is not None

            # Important: mst.seeds will requires erased values to be 255 (a.k.a -1)
            #value[:] = numpy.where(value == 100, 255, value)
            seedVal = value.max()
            with Timer() as timer:
                logger.info("Writing seeds to MST")
                if hasattr(key, '__len__'):
                    self._mst.addSeeds(roi=roi, brushStroke=value.squeeze())
                else:
                    raise RuntimeError("when is this part of the code called")
                    self._mst.seeds[key] = value
            logger.info("Writing seeds to MST took {} seconds".format(
                timer.seconds()))

            self.has_seeds = True
        else:
            raise RuntimeError("unknown slots")
Beispiel #2
0
class EventPlayer(object):
    def __init__(self, playback_speed=None, comment_display=None):
        self._playback_speed = playback_speed
        self._timer = Timer()
        self._timer.unpause()
        if comment_display is None:
            self._comment_display = self._default_comment_display
        else:
            self._comment_display = comment_display

    def play_script(self, path, finish_callback=None):
        """
        Start execution of the given script in a separate thread and return immediately.
        Note: You should handle any exceptions from the playback script via sys.execpthook.
        """
        _globals = {}
        _locals = {}
        """ 
        Calls to events in the playback script like: player.post_event(obj,PyQt4.QtGui.QMouseEvent(...),t)
        are/were responsible for the xcb-error on Ubuntu, because you may not use
        a Gui-object from a thread other than the MainThread running the Gui
        """
        execfile(path, _globals, _locals)
        def run():
            _locals['playback_events'](player=self)
            if finish_callback is not None:
                finish_callback()
        th = threading.Thread( target=run )
        th.daemon = True
        th.start()
    
    def post_event(self, obj, event, timestamp_in_seconds):
        if self._playback_speed is not None:
            self._timer.sleep_until(timestamp_in_seconds / self._playback_speed)
        assert threading.current_thread().name != "MainThread"
        event.spont = True
        QApplication.postEvent(obj, event)
        assert QApplication.instance().thread() == obj.thread()
        
        flusher = EventFlusher()
        flusher.moveToThread( obj.thread() )
        flusher.setParent( QApplication.instance() )
    
        signaler = Signaler()
        signaler.sig.connect( flusher.set, Qt.QueuedConnection )
        signaler.sig.emit()
        flusher.wait()
        flusher.clear()

    def display_comment(self, comment):
        self._comment_display(comment)

    def _default_comment_display(self, comment):
        print "--------------------------------------------------"
        print comment
        print "--------------------------------------------------"
Beispiel #3
0
    def execute(self, slot, subindex, roi, result):
        if tuple(roi.stop - roi.start) != self.Output.meta.shape:
            raise ValueError("Blockwise Watershed must be run on the entire volume")

        if self.Input.meta.getAxisKeys() != list("txyzc"):
            raise ValueError(f"Unsupported input axis keys {self.Input.meta.getAxisKeys()}")

        if self.Input.meta.getTaggedShape()["z"] > 1:
            result_idx = numpy.s_[0, ..., 0]
        else:
            result_idx = numpy.s_[0, ..., 0, 0]

        input_ = self.Input(roi.start, roi.stop).wait().squeeze()
        if input_.ndim not in (2, 3):
            raise ValueError(f"Input shape {input_.shape} has an invalid number of non-singleton dimensions")

        with Timer() as timer:
            logger.info("Run block-wise watershed in %dd", input_.ndim)

            if self.DoAgglo.value:
                result[result_idx], max_id = watershed_and_agglomerate(
                    input_,
                    max_workers=max(1, Request.global_thread_pool.num_workers),
                    size_regularizer=self.SizeRegularizer.value,
                    reduce_to=self.ReduceTo.value,
                )
            else:
                result[result_idx], max_id = vigra.analysis.watershedsNew(input_)

            logger.info("done %d", max_id)
            logger.info("Blockwise Watershed took %f seconds", timer.seconds())

        return result
Beispiel #4
0
    def execute(self, slot, subindex, roi, result):
        assert roi.stop - roi.start == self.Output.meta.shape, "Watershed must be run on the entire volume."
        input_image = self.Input(roi.start, roi.stop).wait()
        volume_feat = input_image[0, ..., 0]
        result_view = result[0, ..., 0]
        with Timer() as watershedTimer:
            if self.Input.meta.getTaggedShape()['z'] > 1:
                sys.stdout.write("Watershed...")
                sys.stdout.flush()
                #result_view[...] = vigra.analysis.watersheds(volume_feat[:,:])[0].astype(numpy.int32)
                result_view[...] = vigra.analysis.watershedsNew(
                    volume_feat[:, :].astype(numpy.uint8))[0]
                logger.info("done {}".format(numpy.max(result[...])))
            else:
                sys.stdout.write("Watershed...")
                sys.stdout.flush()

                labelVolume = vigra.analysis.watershedsNew(
                    volume_feat[:, :, 0])[0]  #.view(dtype=numpy.int32)
                result_view[...] = labelVolume[:, :, numpy.newaxis]
                logger.info("done {}".format(numpy.max(labelVolume)))

        logger.info("Watershed took {} seconds".format(
            watershedTimer.seconds()))
        return result
Beispiel #5
0
    def _loadProject(self, hdf5File, projectFilePath, readOnly):
        """
        Load the data from the given hdf5File (which should already be open).
        
        :param hdf5File: An already-open h5py.File, usually created via ``ProjectManager.createBlankProjectFile``
        :param projectFilePath: The path to the file represented in the ``hdf5File`` parameter.
        :param readOnly: Set to True if the project file should NOT be modified.
        """
        # We are about to create a LOT of tiny objects.
        # Temporarily disable garbage collection while we do this.
        gc.disable()

        assert self.currentProjectFile is None

        # Minor GUI nicety: Pre-activate the progress signals for all applets so
        #  the progress manager treats these tasks as a group instead of several sequential jobs.
        for aplt in self._applets:
            aplt.progressSignal.emit(0)

        # Save this as the current project
        self.currentProjectFile = hdf5File
        self.currentProjectPath = projectFilePath
        self.currentProjectIsReadOnly = readOnly
        try:
            # Applet serializable items are given the whole file (root group)
            for aplt in self._applets:
                with Timer() as timer:
                    for serializer in aplt.dataSerializers:
                        assert serializer.base_initialized, "AppletSerializer subclasses must call AppletSerializer.__init__ upon construction."
                        serializer.ignoreDirty = True

                        if serializer.caresOfHeadless:
                            serializer.deserializeFromHdf5(
                                self.currentProjectFile, projectFilePath,
                                self._headless)
                        else:
                            serializer.deserializeFromHdf5(
                                self.currentProjectFile, projectFilePath)

                        serializer.ignoreDirty = False
                logger.debug(
                    'Deserializing applet "{}" took {} seconds'.format(
                        aplt.name, timer.seconds()))

            self.closed = False
            # Call the workflow's custom post-load initialization (if any)
            self.workflow.onProjectLoaded(self)

            self.workflow.handleAppletStateUpdateRequested()
        except:
            msg = "Project could not be loaded due to the exception shown above.\n"
            msg += "Aborting Project Open Action"
            log_exception(logger, msg)
            self._closeCurrentProject()
            raise
        finally:
            gc.enable()
            for aplt in self._applets:
                aplt.progressSignal.emit(100)
Beispiel #6
0
 def __init__(self, playback_speed=None, comment_display=None):
     self._playback_speed = playback_speed
     self._timer = Timer()
     self._timer.unpause()
     if comment_display is None:
         self._comment_display = self._default_comment_display
     else:
         self._comment_display = comment_display
Beispiel #7
0
 def __init__(self, parent=None, ignore_parent_events=True):
     QObject.__init__(self, parent=parent)
     self._ignore_parent_events = False
     if parent is not None and ignore_parent_events:
         self._ignore_parent_events = True
         self._parent_name = get_fully_qualified_name(parent)
     self._captured_events = []
     self._timer = Timer()
Beispiel #8
0
    def read(self, view_roi, result_out):
        """
        roi: (start, stop) tuples, ordered according to description.output_axes
             roi should be relative to the view
        """
        output_axes = self.description.output_axes
        roi_transposed = list(zip(*view_roi))
        roi_dict = dict(list(zip(output_axes, roi_transposed)))
        view_roi = list(zip(*(roi_dict["z"], roi_dict["y"], roi_dict["x"])))

        # First, normalize roi and result to zyx order
        result_out = vigra.taggedView(result_out, output_axes)
        result_out = result_out.withAxes(*"zyx")

        assert numpy.array(view_roi).shape == (2, 3), "Invalid roi for 3D volume: {}".format(view_roi)
        view_roi = numpy.array(view_roi)
        assert (result_out.shape == (view_roi[1] - view_roi[0])).all()

        # User gave roi according to the view output.
        # Now offset it find global roi.
        roi = view_roi + self.description.view_origin_zyx

        tile_blockshape = (1,) + tuple(self.description.tile_shape_2d_yx)
        tile_starts = getIntersectingBlocks(tile_blockshape, roi)

        pool = RequestPool()
        for tile_start in tile_starts:
            tile_roi_in = getBlockBounds(self.description.bounds_zyx, tile_blockshape, tile_start)
            tile_roi_in = numpy.array(tile_roi_in)

            # This tile's portion of the roi
            intersecting_roi = getIntersection(roi, tile_roi_in)
            intersecting_roi = numpy.array(intersecting_roi)

            # Compute slicing within destination array and slicing within this tile
            destination_relative_intersection = numpy.subtract(intersecting_roi, roi[0])
            tile_relative_intersection = intersecting_roi - tile_roi_in[0]

            # Get a view to the output slice
            result_region = result_out[roiToSlice(*destination_relative_intersection)]

            rest_args = self._get_rest_args(tile_blockshape, tile_roi_in)
            if self.description.tile_url_format.startswith("http"):
                retrieval_fn = partial(self._retrieve_remote_tile, rest_args, tile_relative_intersection, result_region)
            else:
                retrieval_fn = partial(self._retrieve_local_tile, rest_args, tile_relative_intersection, result_region)

            PARALLEL_REQ = True
            if PARALLEL_REQ:
                pool.add(Request(retrieval_fn))
            else:
                # execute serially (leave the pool empty)
                retrieval_fn()

        if PARALLEL_REQ:
            with Timer() as timer:
                pool.wait()
            logger.info("Loading {} tiles took a total of {}".format(len(tile_starts), timer.seconds()))
        def impl():
            workflow = self.shell.projectManager.workflow
            pixClassApplet = workflow.pcApplet
            gui = pixClassApplet.getMultiLaneGui()

            # Clear all the labels
            while len(gui.currentGui()._labelControlUi.labelListModel) > 2:
                gui.currentGui()._labelControlUi.labelListModel.removeRow(2)

            # Re-add all labels
            self.test_4_AddLabels()

            # Make sure the entire slice is visible
            viewMenu = gui.currentGui().menus()[0]
            viewMenu.actionFitToScreen.trigger()

            with Timer() as timer:
                # Enable interactive mode
                assert gui.currentGui(
                )._labelControlUi.liveUpdateButton.isChecked() == False
                gui.currentGui()._labelControlUi.liveUpdateButton.click()

                # Do to the way we wait for the views to finish rendering, the GUI hangs while we wait.
                self.waitForViews(gui.currentGui().editor.imageViews)

            logger.debug("Interactive Mode Rendering Time: {}".format(
                timer.seconds()))

            # There should be a prediction layer for each label
            labelNames = [
                label.name for label in gui.currentGui().labelListData
            ]
            labelColors = gui.currentGui()._colorTable16[1:5]
            for i, labelName in enumerate(labelNames):
                try:
                    index = gui.currentGui().layerstack.findMatchingIndex(
                        lambda layer: labelName in layer.name)
                    layer = gui.currentGui().layerstack[index]

                    # Check the color
                    assert isinstance(
                        layer,
                        AlphaModulatedLayer), "layer is {}".format(layer)
                    assert layer.tintColor.rgba(
                    ) == labelColors[i], "Expected {}, got {}".format(
                        hex(labelColors[i]), hex(layer.tintColor.rgba()))
                except ValueError:
                    assert False, "Could not find layer for label with name: {}".format(
                        labelName)

            # Disable iteractive mode.
            gui.currentGui()._labelControlUi.liveUpdateButton.click()

            self.waitForViews(gui.currentGui().editor.imageViews)
Beispiel #10
0
    def setup_class(cls):
        # Base class first
        super().setup_class()

        # input files:
        current_dir = os.path.split(__file__)[0]
        cls.sample_data_raw = os.path.abspath(
            os.path.join(current_dir, "../data/inputdata/3d.h5"))

        # output files:
        cls.temp_dir = tempfile.mkdtemp()
        # uncomment for debugging
        # cls.temp_dir = os.path.expanduser('~/tmp')
        # if os.path.exists(cls.temp_dir):
        #     shutil.rmtree(cls.temp_dir)
        # os.makedirs(cls.temp_dir)
        cls.project_file = os.path.join(cls.temp_dir,
                                        "test_project_carving.ilp")
        cls.output_file = os.path.join(cls.temp_dir,
                                       "out_carving_object_segmentation.h5")
        cls.output_obj_file = os.path.join(cls.temp_dir,
                                           "out_carving_object_1.obj")

        # reference files
        # unzip the zip-file ;)
        cls.reference_zip_file = os.path.join(
            current_dir, "../data/outputdata/testCarvingGuiReference.zip")
        cls.reference_path = os.path.join(cls.temp_dir, "reference")
        cls.reference_files = {
            "output_obj_file":
            os.path.join(cls.reference_path,
                         "testCarvingGuiReference/3d_carving_object_1.obj"),
            "output_file":
            os.path.join(
                cls.reference_path,
                "testCarvingGuiReference/3d_carving_completed_segments_1_object.h5"
            ),
            "carving_label_file":
            os.path.join(cls.reference_path,
                         "testCarvingGuiReference/3d_carving_labels.h5"),
        }
        os.makedirs(cls.reference_path)
        with zipfile.ZipFile(cls.reference_zip_file, mode="r") as zip_file:
            zip_file.extractall(path=cls.reference_path)
        cls.unzipped_reference_files = [
            os.path.join(cls.reference_path, fp) for fp in zip_file.namelist()
        ]

        for file_name in cls.reference_files.values():
            assert os.path.exists(file_name)

        # Start the timer
        cls.timer = Timer()
        cls.timer.unpause()
Beispiel #11
0
        def impl():
            shell = self.shell
            workflow = shell.projectManager.workflow
            object_classification_applet = workflow.objectClassificationApplet
            gui = object_classification_applet.getMultiLaneGui()

            # activate the object classification applet
            shell.setSelectedAppletDrawer(3)
            # let the gui catch up
            QApplication.processEvents()

            with Timer() as timer:
                # Enable interactive mode
                assert gui.currentGui(
                )._labelControlUi.liveUpdateButton.isChecked() is False
                gui.currentGui()._labelControlUi.liveUpdateButton.click()
                assert gui.currentGui(
                )._labelControlUi.liveUpdateButton.isChecked() is True
                # Do to the way we wait for the views to finish rendering, the GUI hangs while we wait.
                self.waitForViews(gui.currentGui().editor.imageViews)
            logger.debug(f"Interactive Mode Rendering Time: {timer.seconds()}")

            # Disable iteractive mode.
            gui.currentGui()._labelControlUi.liveUpdateButton.click()
            assert gui.currentGui()._labelControlUi.liveUpdateButton.isChecked(
            ) is False

            # There should be a prediction layer for each label
            labelNames = [
                label.name for label in gui.currentGui().labelListData
            ]
            labelColors = gui.currentGui()._colorTable16[1:4]
            for i, labelName in enumerate(labelNames):
                try:
                    index = gui.currentGui().layerstack.findMatchingIndex(
                        lambda layer: labelName in layer.name)
                    layer = gui.currentGui().layerstack[index]

                    # Check the color
                    assert isinstance(layer,
                                      AlphaModulatedLayer), f"layer is {layer}"
                    assert (
                        layer.tintColor.rgba() == labelColors[i]
                    ), f"Expected {hex(labelColors[i])}, got {hex(layer.tintColor.rgba())}"
                except ValueError:
                    assert False, "Could not find layer for label with name: {}".format(
                        labelName)

            # Save the project
            saveThread = self.shell.onSaveProjectActionTriggered()
            saveThread.join()

            self.waitForViews(gui.currentGui().editor.imageViews)
Beispiel #12
0
    def execute(self, slot, subindex, ignored_roi, result):
        configFilePath = self.ConfigFilePath.value
        config = parseClusterConfigFile(configFilePath)

        blockwiseFileset = self._primaryBlockwiseFileset

        # Check axis compatibility
        inputAxes = list(self.Input.meta.getTaggedShape().keys())
        outputAxes = list(blockwiseFileset.description.axes)
        assert set(inputAxes) == set(
            outputAxes
        ), "Output dataset has the wrong set of axes.  Input axes: {}, Output axes: {}".format(
            "".join(inputAxes), "".join(outputAxes))

        roiString = self.RoiString.value
        roi = Roi.loads(roiString)
        if len(roi.start) != len(self.Input.meta.shape):
            assert (
                False
            ), "Task roi: {} is not valid for this input.  Did the master launch this task correctly?".format(
                roiString)

        logger.info("Executing for roi: {}".format(roi))

        if config.use_node_local_scratch:
            assert False, "FIXME."

        assert (
            blockwiseFileset.getEntireBlockRoi(roi.start)[1] == roi.stop
        ).all(
        ), "Each task must execute exactly one full block.  ({},{}) is not a valid block roi.".format(
            roi.start, roi.stop)
        assert self.Input.ready()

        with Timer() as computeTimer:
            # Stream the data out to disk.
            request_blockshape = (
                self._primaryBlockwiseFileset.description.sub_block_shape
            )  # Could be None.  That's okay.
            streamer = BigRequestStreamer(self.Input, (roi.start, roi.stop),
                                          request_blockshape)
            streamer.progressSignal.subscribe(self.progressSignal)
            streamer.resultSignal.subscribe(self._handlePrimaryResultBlock)
            streamer.execute()

            # Now the block is ready.  Update the status.
            blockwiseFileset.setBlockStatus(roi.start,
                                            BlockwiseFileset.BLOCK_AVAILABLE)

        logger.info("Finished task in {} seconds".format(
            computeTimer.seconds()))
        result[0] = True
        return result
Beispiel #13
0
    def execute(self, slot, subindex, roi, result):
        assert all(roi.stop <= self.Input.meta.shape),\
            "Requested roi {} is too large for this input image of shape {}.".format(roi, self.Input.meta.shape)

        # Determine how much input data we'll need, and where the result will be
        # relative to that input roi
        # inputRoi is a 5d roi, computeRoi depends on the number of singletons
        # in shape, but is at most 3d
        inputRoi, computeRoi = self._getInputComputeRois(roi)

        # Obtain the input data
        with Timer() as resultTimer:
            data = self.Input(*inputRoi).wait()
        logger.debug("Obtaining input data took {} seconds for roi {}".format(
            resultTimer.seconds(), inputRoi))
        data = vigra.taggedView(data, axistags='txyzc')

        # input is in txyzc order
        tIndex = 0
        cIndex = 4

        # Must be float32
        if data.dtype != numpy.float32:
            data = data.astype(numpy.float32)

        # we need to remove a singleton z axis, otherwise we get
        # 'kernel longer than line' errors
        ts = self.Input.meta.getTaggedShape()
        tags = [k for k in 'xyz' if ts[k] > 1]
        sigma = [self._sigmas[k] for k in tags]

        # Check if we need to smooth
        if any([x < 0.1 for x in sigma]):
            # just pipe the input through
            result[...] = data
            return

        for i, t in enumerate(xrange(roi.start[tIndex], roi.stop[tIndex])):
            for j, c in enumerate(xrange(roi.start[cIndex], roi.stop[cIndex])):
                # prepare the result as an argument
                resview = vigra.taggedView(result[i, ..., j], axistags='xyz')
                dataview = data[i, ..., j]
                # TODO make this general, not just for z axis
                resview = resview.withAxes(*tags)
                dataview = dataview.withAxes(*tags)

                # Smooth the input data
                vigra.filters.gaussianSmoothing(dataview,
                                                sigma,
                                                window_size=2.0,
                                                roi=computeRoi,
                                                out=resview)
Beispiel #14
0
        def impl():
            workflow = self.shell.projectManager.workflow
            pixClassApplet = workflow.pcApplet
            gui = pixClassApplet.getMultiLaneGui()

            with Timer() as timer:
                gui.currentGui().editor.posModel.slicingPos = (0, 0, 1)

                # Do to the way we wait for the views to finish rendering, the GUI hangs while we wait.
                self.waitForViews(gui.currentGui().editor.imageViews)

            logger.debug("New Slice Rendering Time: {}".format(
                timer.seconds()))
    def setup_class(cls):
        # Base class first
        super().setup_class()

        # input files:
        current_dir = os.path.split(__file__)[0]
        cls.sample_data_raw = os.path.abspath(os.path.join(current_dir, "../data/inputdata/3d.h5"))
        cls.sample_data_prob = os.path.abspath(os.path.join(current_dir, "../data/inputdata/3d_Probabilities.h5"))

        # output files:
        cls.temp_dir = tempfile.mkdtemp()
        # uncomment for debugging
        # cls.temp_dir = os.path.expanduser('~/tmp')
        # if os.path.exists(cls.temp_dir):
        #     shutil.rmtree(cls.temp_dir)
        # os.makedirs(cls.temp_dir)
        cls.project_file = os.path.join(cls.temp_dir, "test_project_oc.ilp")
        cls.output_file = os.path.join(cls.temp_dir, "out_object_prediction.h5")
        cls.table_h5_file = os.path.join(cls.temp_dir, "table.h5")
        cls.table_h5_file_exported = None  # Will be filled in test_06
        cls.table_csv_file = os.path.join(cls.temp_dir, "table.csv")
        cls.table_csv_file_exported = None  # Will be filled in test_06

        # reference files
        # unzip the zip-file ;)
        cls.reference_zip_file = os.path.join(
            current_dir, "../data/outputdata/testObjectClassificationGuiReference.zip"
        )
        cls.reference_path = os.path.join(cls.temp_dir, "reference")
        cls.reference_files = {
            "csv_table": os.path.join(
                cls.reference_path, "testObjectClassificationGuiReference/table-test_data_table.csv"
            ),
            "h5_table": os.path.join(cls.reference_path, "testObjectClassificationGuiReference/table-test_data.h5"),
            "predictions_h5": os.path.join(
                cls.reference_path, "testObjectClassificationGuiReference/reference_out_object_prediction.h5"
            ),
        }
        os.makedirs(cls.reference_path)
        with zipfile.ZipFile(cls.reference_zip_file, mode="r") as zip_file:
            zip_file.extractall(path=cls.reference_path)
        cls.unzipped_reference_files = [os.path.join(cls.reference_path, fp) for fp in zip_file.namelist()]

        for file_name in cls.reference_files.values():
            assert os.path.exists(file_name)

        # Start the timer
        cls.timer = Timer()
        cls.timer.unpause()
Beispiel #16
0
 def setupClass(cls):
     # Base class first
     super(TestPixelClassificationGui, cls).setupClass()
     
     if hasattr(cls, 'SAMPLE_DATA'):
         cls.using_random_data = False
     else:
         cls.using_random_data = True
         cls.SAMPLE_DATA = os.path.split(__file__)[0] + '/random_data.npy'
         data = numpy.random.random((1,200,200,50,1))
         data *= 256
         numpy.save(cls.SAMPLE_DATA, data.astype(numpy.uint8))
     
     # Start the timer
     cls.timer = Timer()
     cls.timer.unpause()
Beispiel #17
0
 def _buildDone(self):
     """
     Builds the done segmentation anew, for example after saving an object or
     deleting an object.
     """
     if self._mst is None:
         return
     with Timer() as timer:
         self._done_lut = numpy.zeros(self._mst.numNodes+1, dtype=numpy.int32)
         self._done_seg_lut = numpy.zeros(self._mst.numNodes+1, dtype=numpy.int32)
         logger.info( "building 'done' luts" )
         for name, objectSupervoxels in self._mst.object_lut.items():
             if name == self._currObjectName:
                 continue
             self._done_lut[objectSupervoxels] += 1
             assert name in self._mst.object_names, "%s not in self._mst.object_names, keys are %r" % (name, list(self._mst.object_names.keys()))
             self._done_seg_lut[objectSupervoxels] = self._mst.object_names[name]
     logger.info( "building the 'done' luts took {} seconds".format( timer.seconds() ) )
Beispiel #18
0
        def impl():
            workflow = self.shell.projectManager.workflow
            pixClassApplet = workflow.pcApplet
            gui = pixClassApplet.getMultiLaneGui()

            # Make sure the entire slice is visible
            gui.currentGui().menuGui.actionFitToScreen.trigger()

            with Timer() as timer:
                # Enable interactive mode
                assert gui.currentGui(
                )._labelControlUi.liveUpdateButton.isChecked() == False
                gui.currentGui()._labelControlUi.liveUpdateButton.click()

                # Do to the way we wait for the views to finish rendering, the GUI hangs while we wait.
                self.waitForViews(gui.currentGui().editor.imageViews)

            logger.debug("Interactive Mode Rendering Time: {}".format(
                timer.seconds()))
Beispiel #19
0
    def setup_class(cls):
        # Base class first
        super(TestObjectCountingGui, cls).setup_class()

        if hasattr(cls, "SAMPLE_DATA"):
            cls.using_random_data = False
        else:
            cls.using_random_data = True
            cls.SAMPLE_DATA = os.path.join(os.path.split(__file__)[0], "random_data.npy")
            data = numpy.random.random((200, 200, 3))
            data *= 256
            numpy.save(cls.SAMPLE_DATA, data.astype(numpy.uint8))

        # Sample Sigma value for OpCounting.opTrain (OpTrainCounter).
        cls.COUNTING_SIGMA = 4.2

        # Start the timer
        cls.timer = Timer()
        cls.timer.unpause()
Beispiel #20
0
    def setupClass(cls):
        # This test is useful for performance evaluation,
        #  but it takes too long to be useful as part of the normal test suite.
        raise nose.SkipTest

        # Base class first
        super(TestPixelClassificationGuiBenchmarking, cls).setupClass()

        if hasattr(cls, 'SAMPLE_DATA'):
            cls.using_random_data = False
        else:
            cls.using_random_data = True
            cls.SAMPLE_DATA = os.path.split(__file__)[0] + '/random_data.npy'
            data = numpy.random.random((1, 512, 512, 128, 1))
            data *= 256
            numpy.save(cls.SAMPLE_DATA, data.astype(numpy.uint8))

        # Start the timer
        cls.timer = Timer()
        cls.timer.start()
Beispiel #21
0
 def setupClass(cls):
     if 'TRAVIS' in os.environ:
         # The counting workflow doesn't import correctly on Travis, so skip this test.
         import nose
         raise nose.SkipTest
     # Base class first
     super(TestObjectCountingGui, cls).setupClass()
     
     if hasattr(cls, 'SAMPLE_DATA'):
         cls.using_random_data = False
     else:
         cls.using_random_data = True
         cls.SAMPLE_DATA = os.path.split(__file__)[0] + '/random_data.npy'
         data = numpy.random.random((200,200,3))
         data *= 256
         numpy.save(cls.SAMPLE_DATA, data.astype(numpy.uint8))
     
     # Start the timer
     cls.timer = Timer()
     cls.timer.unpause()
Beispiel #22
0
    def associate_skeletons(self, skeleton_association_input, debug=False):
        with Timer() as node_timer:
            node_segmenter_outputs = associate_skeletons(
                self.hdf5_path, self.opPixelClassification,
                self.multicut_shell, self.catmaid, skeleton_association_input)

        logging.getLogger(self.inner_logger.name + '.timing').info(
            "TILE TIMER: {}".format(node_timer.seconds()))

        # if debug:
        #     node_locations_arr = node_locations_to_array(segmentation_xy.shape, node_locations)
        #     path = os.path.join(
        #         self.paths.debug_synapse_dir, '{}_{}.hdf5'.format(synapse_object_id, roi_xyz[0, 2])
        #     )
        #     dump_images(
        #         path, roi_xyz, raw=raw_xy, synapse_cc=synapse_cc_xy, predictions=predictions_xyc,
        #         segmentation=segmentation_xy, node_locations=node_locations_arr
        #     )

        return node_segmenter_outputs
Beispiel #23
0
    def detect_synapses(self, tile_idx, debug=False):
        self.inner_logger.debug("detect_synapses called")
        with Timer() as timer:
            output = detect_synapses(self.tile_size,
                                     self.opPixelClassification, tile_idx)

        logging.getLogger(self.inner_logger.name + '.timing').info(
            "NODE TIMER: {}".format(timer.seconds()))

        if debug:
            roi_xyz = tile_index_to_bounds(tile_idx, self.tile_size)
            path = os.path.join(
                self.paths.debug_tile_dir,
                'x{}-y{}-z{}.hdf5'.format(tile_idx.x_idx, tile_idx.y_idx,
                                          tile_idx.z_idx))
            dump_images(path,
                        roi_xyz,
                        synapse_cc=output.synapse_cc_xy,
                        predictions=output.predictions_xyc)

        return output
    def setup_class(cls):
        # Base class first
        super(TestPixelClassificationGuiBenchmarking, cls).setup_class()

        # This test is useful for performance evaluation,
        # but it takes too long to be useful as part of the normal test suite.
        super().teardown_class()
        pytest.skip("For benchmark purposes only")

        if hasattr(cls, "SAMPLE_DATA"):
            cls.using_random_data = False
        else:
            cls.using_random_data = True
            cls.SAMPLE_DATA = os.path.split(__file__)[0] + "/random_data.npy"
            data = numpy.random.random((1, 512, 512, 128, 1))
            data *= 256
            numpy.save(cls.SAMPLE_DATA, data.astype(numpy.uint8))

        # Start the timer
        cls.timer = Timer()
        cls.timer.unpause()
Beispiel #25
0
    def execute(self, slot, subindex, roi, result):
        assert roi.stop - roi.start == self.Output.meta.shape, "Blockwise Watershed must be run on the entire volume."
        input_image = self.Input(roi.start, roi.stop).wait()
        volume_feat = input_image[0, ..., 0]
        result_view = result[0, ..., 0]
        with Timer() as watershedTimer:
            if self.Input.meta.getTaggedShape()['z'] > 1:
                sys.stdout.write("Blockwise Watershed 3D...")
                sys.stdout.flush()

                if not self.DoAgglo.value:
                    result_view[...] = vigra.analysis.watersheds(
                        volume_feat[...])[0].astype(numpy.int32)

                else:
                    result_view[...] = simple_parallel_ws(
                        volume_feat,
                        max_workers=Request.global_thread_pool.num_workers,
                        size_regularizer=self.SizeRegularizer.value,
                        reduce_to=self.ReduceTo.value)
                logger.info("done {}".format(numpy.max(result[...])))
            else:
                if not self.DoAgglo.value:
                    result_view[...] = vigra.analysis.watersheds(
                        volume_feat[:, :, 0])[0].astype(numpy.int32)
                else:
                    sys.stdout.write("Blockwise Watershed...")
                    sys.stdout.flush()
                    labelVolume = simple_parallel_ws(
                        volume_feat[:, :, 0],
                        max_workers=Request.global_thread_pool.num_workers,
                        size_regularizer=self.SizeRegularizer.value,
                        reduce_to=self.ReduceTo.value)
                    result_view[...] = labelVolume[:, :, numpy.newaxis]
                logger.info("done {}".format(numpy.max(labelVolume)))

        logger.info("Blockwise Watershed took {} seconds".format(
            watershedTimer.seconds()))
        return result
Beispiel #26
0
    def execute(self, slot, subindex, roi, result):
        assert roi.stop - roi.start == self.Output.meta.shape, "Blockwise Watershed must be run on the entire volume."
        input_image = self.Input(roi.start, roi.stop).wait()
        volume_feat = input_image[0, ..., 0]
        result_view = result[0, ..., 0]
        # handle the special case of the Request threadpool not having any workers
        max_workers = max(1, Request.global_thread_pool.num_workers)
        with Timer() as watershedTimer:
            # 3d watersheds
            if self.Input.meta.getTaggedShape()['z'] > 1:
                logger.info("Run block-wise watershed in 3d")
                if self.DoAgglo.value:
                    result_view[...], max_id = watershed_and_agglomerate(
                        volume_feat,
                        max_workers=max_workers,
                        size_regularizer=self.SizeRegularizer.value,
                        reduce_to=self.ReduceTo.value)
                else:
                    result_view[...], max_id = vigra.analysis.watershedsNew(
                        volume_feat)
            # 2d watersheds
            else:
                logger.info("Run block-wise watershed in 2d")
                if self.DoAgglo.value:
                    result_view[...], max_id = watershed_and_agglomerate(
                        volume_feat[:, :, 0],
                        max_workers=max_workers,
                        size_regularizer=self.SizeRegularizer.value,
                        reduce_to=self.ReduceTo.value)
                else:
                    result_view[...], max_id = vigra.analysis.watersheds(
                        volume_feat[:, :, 0])

            logger.info("done {}".format(max_id))

        logger.info("Blockwise Watershed took {} seconds".format(
            watershedTimer.seconds()))
        return result
Beispiel #27
0
    def execute(self, slot, subindex, roi, result):
        assert all(
            roi.stop <= self.Input.meta.shape
        ), "Requested roi {} is too large for this input image of shape {}.".format(
            roi, self.Input.meta.shape)
        # Determine how much input data we'll need, and where the result will be relative to that input roi
        inputRoi, computeRoi = self._getInputComputeRois(roi)
        # Obtain the input data
        with Timer() as resultTimer:
            data = self.Input(*inputRoi).wait()
        logger.debug("Obtaining input data took {} seconds for roi {}".format(
            resultTimer.seconds(), inputRoi))

        xIndex = self.Input.meta.axistags.index('x')
        yIndex = self.Input.meta.axistags.index('y')
        zIndex = self.Input.meta.axistags.index(
            'z') if self.Input.meta.axistags.index('z') < len(
                self.Input.meta.shape) else None
        cIndex = self.Input.meta.axistags.index(
            'c') if self.Input.meta.axistags.index('c') < len(
                self.Input.meta.shape) else None

        # Must be float32
        if data.dtype != numpy.float32:
            data = data.astype(numpy.float32)

        axiskeys = self.Input.meta.getAxisKeys()
        spatialkeys = filter(lambda k: k in 'xyz', axiskeys)

        # we need to remove a singleton z axis, otherwise we get
        # 'kernel longer than line' errors
        reskey = [slice(None, None, None)] * len(self.Input.meta.shape)
        reskey[cIndex] = 0
        if zIndex and self.Input.meta.shape[zIndex] == 1:
            removedZ = True
            data = data.reshape((data.shape[xIndex], data.shape[yIndex]))
            reskey[zIndex] = 0
            spatialkeys = filter(lambda k: k in 'xy', axiskeys)
        else:
            removedZ = False

        sigma = map(self._sigmas.get, spatialkeys)
        #Check if we need to smooth
        if any([x < 0.1 for x in sigma]):
            if removedZ:
                resultXY = vigra.taggedView(result, axistags="".join(axiskeys))
                resultXY = resultXY.withAxes(*'xy')
                resultXY[:] = data
            else:
                result[:] = data
            return result

        # Smooth the input data
        smoothed = vigra.filters.gaussianSmoothing(
            data,
            sigma,
            window_size=2.0,
            roi=computeRoi,
            out=result[tuple(reskey)])  # FIXME: Assumes channel is last axis
        expectedShape = tuple(
            TinyVector(computeRoi[1]) - TinyVector(computeRoi[0]))
        assert tuple(
            smoothed.shape
        ) == expectedShape, "Smoothed data shape {} didn't match expected shape {}".format(
            smoothed.shape, roi.stop - roi.start)

        return result
Beispiel #28
0
    def loadObject(self, name):
        logger.info("want to load object with name = %s" % name)
        if not self.hasObjectWithName(name):
            logger.info("  --> no such object '%s'" % name)
            return False

        if self.hasCurrentObject():
            self.saveCurrentObject()
        self._clearLabels()

        fgVoxels, bgVoxels = self.loadObject_impl(name)

        fg_bounding_box_start = numpy.array(map(numpy.min, fgVoxels))
        fg_bounding_box_stop = 1 + numpy.array(map(numpy.max, fgVoxels))

        bg_bounding_box_start = numpy.array(map(numpy.min, bgVoxels))
        bg_bounding_box_stop = 1 + numpy.array(map(numpy.max, bgVoxels))

        bounding_box_start = numpy.minimum(fg_bounding_box_start,
                                           bg_bounding_box_start)
        bounding_box_stop = numpy.maximum(fg_bounding_box_stop,
                                          bg_bounding_box_stop)

        bounding_box_slicing = roiToSlice(bounding_box_start,
                                          bounding_box_stop)

        bounding_box_shape = tuple(bounding_box_stop - bounding_box_start)
        dtype = self.opLabelArray.Output.meta.dtype

        # Convert coordinates to be relative to bounding box
        fgVoxels = numpy.array(fgVoxels)
        fgVoxels = fgVoxels - numpy.array([bounding_box_start]).transpose()
        fgVoxels = list(fgVoxels)

        bgVoxels = numpy.array(bgVoxels)
        bgVoxels = bgVoxels - numpy.array([bounding_box_start]).transpose()
        bgVoxels = list(bgVoxels)

        with Timer() as timer:
            logger.info("Loading seeds....")
            z = numpy.zeros(bounding_box_shape, dtype=dtype)
            logger.info("Allocating seed array took {} seconds".format(
                timer.seconds()))
            z[fgVoxels] = 2
            z[bgVoxels] = 1
            self.WriteSeeds[(slice(0, 1), ) + bounding_box_slicing +
                            (slice(0, 1), )] = z[numpy.newaxis, :, :, :,
                                                 numpy.newaxis]
        logger.info("Loading seeds took a total of {} seconds".format(
            timer.seconds()))

        #restore the correct parameter values
        mst = self._mst

        assert name in mst.object_lut
        assert name in mst.object_seeds_fg_voxels
        assert name in mst.object_seeds_bg_voxels
        assert name in mst.bg_priority
        assert name in mst.no_bias_below

        assert name in mst.bg_priority
        assert name in mst.no_bias_below

        self.BackgroundPriority.setValue(mst.bg_priority[name])
        self.NoBiasBelow.setValue(mst.no_bias_below[name])

        #self.updatePreprocessing()
        # The entire segmentation layer needs to be refreshed now.
        self.Segmentation.setDirty()

        return True
Beispiel #29
0
class EventRecorder( QObject ):
    """
    Records spontaneous events from the UI and serializes them as strings that can be evaluated in Python.
    """
    def __init__(self, parent=None, ignore_parent_events=True):
        QObject.__init__(self, parent=parent)
        self._ignore_parent_events = False
        if parent is not None and ignore_parent_events:
            self._ignore_parent_events = True
            self._parent_name = get_fully_qualified_name(parent)
        self._captured_events = []
        self._timer = Timer()

    @property
    def paused(self):
        return self._timer.paused

    QEvent_Style = 91
    IgnoredEventTypes = set( [ QEvent.Paint,
                              QEvent.KeyboardLayoutChange,
                              QEvent.WindowActivate,
                              QEvent.WindowDeactivate,
                              QEvent.ActivationChange,
                              # These event symbols are not exposed in pyqt, so we pull them from our own enum
                              EventTypes.Style,
                              EventTypes.ApplicationActivate,
                              EventTypes.ApplicationDeactivate,
                              EventTypes.NonClientAreaMouseMove,
                              EventTypes.NonClientAreaMouseButtonPress,
                              EventTypes.NonClientAreaMouseButtonRelease,
                              EventTypes.NonClientAreaMouseButtonDblClick
                               ] )
    IgnoredEventClasses = (QChildEvent, QTimerEvent, QGraphicsSceneMouseEvent, QWindowStateChangeEvent, QMoveEvent)

    def captureEvent(self, watched, event):
        if self._shouldSaveEvent(event):
            try:
                eventstr = event_to_string(event)
            except KeyError:
                logger.warn("Don't know how to record event: {}".format( str(event) ))
                print "Don't know", str(event)
            else:
                timestamp_in_seconds = self._timer.seconds()
                objname = str(get_fully_qualified_name(watched))
                if not ( self._ignore_parent_events and objname.startswith(self._parent_name) ):
                    self._captured_events.append( (eventstr, objname, timestamp_in_seconds) )
        return False

    def insertComment(self, comment):
        self._captured_events.append( (comment, "comment", None) )

    def _shouldSaveEvent(self, event):
        if isinstance(event, QMouseEvent):
            # Ignore most mouse movement events if the user isn't pressing anything.
            if event.type() == QEvent.MouseMove \
                and int(event.button()) == 0 \
                and int(event.buttons()) == 0 \
                and int(event.modifiers()) == 0:
                # Somewhat hackish (and slow), but we have to record mouse movements during combo box usage.
                # Same for QMenu usage (on Mac, it doesn't seem to matter, but on Fedora it does matter.)
                widgetUnderCursor = QApplication.instance().widgetAt( QCursor.pos() )
                if widgetUnderCursor is not None and widgetUnderCursor.objectName() == "qt_scrollarea_viewport":
                    return has_ancestor(widgetUnderCursor, QComboBox)
                if isinstance(widgetUnderCursor, QMenu):
                    return True 
                return False
            else:
                return True
        
        # Ignore non-spontaneous events
        if not event.spontaneous():
            return False
        if event.type() in self.IgnoredEventTypes:
            return False
        if isinstance(event, self.IgnoredEventClasses):
            return False
        return True

    def unpause(self):
        # Here, we use a special override of QApplication.notify() instead of using QApplication.instance().installEventFilter().
        # That's because (contrary to the documentation), the QApplication eventFilter does NOT get to see every event in the application.
        # Testing shows that events that were "filtered out" by a different event filter may not be seen by the QApplication event filter.
        self._timer.unpause()

        def _notify(receiver, event):
            self.captureEvent(receiver, event)
            return _orig_QApp_notify(receiver, event)

        from ilastik.shell.gui.startShellGui import EventRecordingApp
        assert isinstance( QApplication.instance(), EventRecordingApp )
        QApplication.instance()._notify =_notify

    def pause(self):
        self._timer.pause()
        QApplication.instance()._notify = _orig_QApp_notify
    
    def writeScript(self, fileobj):
        # Write header comments
        fileobj.write(
"""
# Event Recording
# Started at: {}
""".format( str(self._timer.start_time) ) )

        # Write playback function definition
        fileobj.write(
"""
def playback_events(player):
    import PyQt4.QtCore
    from PyQt4.QtCore import Qt, QEvent, QPoint
    import PyQt4.QtGui
    from ilastik.utility.gui.eventRecorder.objectNameUtils import get_named_object
    from ilastik.utility.gui.eventRecorder.eventRecorder import EventPlayer
    from ilastik.shell.gui.startShellGui import shell    

    player.display_comment("SCRIPT STARTING")

""")

        # Write all events and comments
        for eventstr, objname, timestamp_in_seconds in self._captured_events:
            if objname == "comment":
                eventstr = eventstr.replace('\\', '\\\\')
                eventstr = eventstr.replace('"', '\\"')
                eventstr = eventstr.replace("'", "\\'")
                fileobj.write(
"""
    ########################
    player.display_comment(\"""{eventstr}\""")
    ########################
""".format( **locals() ) )
            else:
                fileobj.write(
"""
    obj = get_named_object( '{objname}' )
    player.post_event( obj,  {eventstr}, {timestamp_in_seconds} )
""".format( **locals() )
)
        fileobj.write(
"""
    player.display_comment("SCRIPT COMPLETE")
""")
Beispiel #30
0
    def execute(self, slot, subindex, roi, result):
        #make sure raw data is 5D: t,{x,y,z},c
        ax = self.Input.meta.axistags
        sh = self.Input.meta.shape
        assert len(ax) == 5
        assert ax[0].key == "t" and sh[0] == 1
        for i in range(1, 4):
            assert ax[i].isSpatial()
        assert ax[4].key == "c" and sh[4] == 1

        volume5d = self.Input.value
        sigma = self.Sigma.value
        volume = volume5d[0, :, :, :, 0]
        result_view = result[0, :, :, :, 0]

        logger.info("input volume shape: %r" % (volume.shape, ))
        logger.info("input volume size: %r MB",
                    (old_div(volume.nbytes, 1024**2), ))
        fvol = numpy.asarray(volume, numpy.float32)

        #Choose filter selected by user
        volume_filter = self.Filter.value
        filter_name = self.FILTER_NAMES[volume_filter]

        logger.info("applying filter on shape = %r" % (fvol.shape, ))
        with Timer() as filterTimer:

            # check dimensionality of input and reduce to 2d volume
            # if we have actual 2d input
            if fvol.shape[2] == 1:
                fvol = fvol[:, :, 0]

            # we need to invert the input for filter mode RAW_INVERTED
            if volume_filter == OpFilter.RAW_INVERTED:
                fvol = -fvol

            # for the hessian filters, we only need to keep one channel,
            # and we discard the other channels during block-wise computation to save memory
            if volume_filter == OpFilter.HESSIAN_BRIGHT:  # HESSIAN_BRIGHT -> last eigenvalue
                channel = fvol.ndim - 1
            elif volume_filter == OpFilter.HESSIAN_DARK:  # HESSIAN_DARK -> first eigenvalue
                channel = 0
            else:
                channel = None

            # handle the special case of the Request threadpool not having any workers
            max_workers = max(1, Request.global_thread_pool.num_workers)
            # compute the filter response block-wise
            response = parallel_filter(filter_name,
                                       fvol,
                                       sigma,
                                       max_workers=max_workers,
                                       return_channel=channel)

            # need to invert response for hessian bright
            if volume_filter == OpFilter.HESSIAN_BRIGHT:
                response = numpy.max(response) - response

            # write the response to result view
            if fvol.ndim == 2:
                result_view[:, :, 0] = response
            else:
                result_view[...] = response

            logger.info("Filter took {} seconds".format(filterTimer.seconds()))

        return result
Beispiel #31
0
    def execute(self, slot, subindex, roi, result):
        #make sure raw data is 5D: t,{x,y,z},c
        ax = self.Input.meta.axistags
        sh = self.Input.meta.shape
        assert len(ax) == 5
        assert ax[0].key == "t" and sh[0] == 1
        for i in range(1, 4):
            assert ax[i].isSpatial()
        assert ax[4].key == "c" and sh[4] == 1

        volume5d = self.Input.value
        sigma = self.Sigma.value
        volume = volume5d[0, :, :, :, 0]
        result_view = result[0, :, :, :, 0]

        logger.info("input volume shape: %r" % (volume.shape, ))
        logger.info("input volume size: %r MB", (volume.nbytes / 1024**2, ))
        fvol = numpy.asarray(volume, numpy.float32)

        #Choose filter selected by user
        volume_filter = self.Filter.value

        logger.info("applying filter on shape = %r" % (fvol.shape, ))
        with Timer() as filterTimer:
            if fvol.shape[2] > 1:
                # true 3D volume
                if volume_filter == OpFilter.HESSIAN_BRIGHT:
                    logger.info("lowest eigenvalue of Hessian of Gaussian")
                    options = vigra.blockwise.BlockwiseConvolutionOptions3D()
                    options.stdDev = (sigma, ) * 3
                    result_view[
                        ...] = vigra.blockwise.hessianOfGaussianLastEigenvalue(
                            fvol, options)[:, :, :]
                    result_view[:] = numpy.max(result_view) - result_view

                elif volume_filter == OpFilter.HESSIAN_DARK:
                    logger.info("greatest eigenvalue of Hessian of Gaussian")
                    options = vigra.blockwise.BlockwiseConvolutionOptions3D()
                    options.stdDev = (sigma, ) * 3
                    result_view[
                        ...] = vigra.blockwise.hessianOfGaussianFirstEigenvalue(
                            fvol, options)[:, :, :]

                elif volume_filter == OpFilter.STEP_EDGES:
                    logger.info("Gaussian Gradient Magnitude")
                    result_view[...] = vigra.filters.gaussianGradientMagnitude(
                        fvol, sigma)

                elif volume_filter == OpFilter.RAW:
                    logger.info("Gaussian Smoothing")
                    result_view[...] = vigra.filters.gaussianSmoothing(
                        fvol, sigma)

                elif volume_filter == OpFilter.RAW_INVERTED:
                    logger.info("negative Gaussian Smoothing")
                    result_view[...] = vigra.filters.gaussianSmoothing(
                        -fvol, sigma)

                logger.info("Filter took {} seconds".format(
                    filterTimer.seconds()))
            else:
                # 2D Image
                fvol = fvol[:, :, 0]
                if volume_filter == OpFilter.HESSIAN_BRIGHT:
                    logger.info("lowest eigenvalue of Hessian of Gaussian")
                    volume_feat = vigra.filters.hessianOfGaussianEigenvalues(
                        fvol, sigma)[:, :, 1]
                    volume_feat[:] = numpy.max(volume_feat) - volume_feat

                elif volume_filter == OpFilter.HESSIAN_DARK:
                    logger.info("greatest eigenvalue of Hessian of Gaussian")
                    volume_feat = vigra.filters.hessianOfGaussianEigenvalues(
                        fvol, sigma)[:, :, 0]

                elif volume_filter == OpFilter.STEP_EDGES:
                    logger.info("Gaussian Gradient Magnitude")
                    volume_feat = vigra.filters.gaussianGradientMagnitude(
                        fvol, sigma)

                elif volume_filter == OpFilter.RAW:
                    logger.info("Gaussian Smoothing")
                    volume_feat = vigra.filters.gaussianSmoothing(fvol, sigma)

                elif volume_filter == OpFilter.RAW_INVERTED:
                    logger.info("negative Gaussian Smoothing")
                    volume_feat = vigra.filters.gaussianSmoothing(-fvol, sigma)

                result_view[:, :, 0] = volume_feat
                logger.info("Filter took {} seconds".format(
                    filterTimer.seconds()))
        return result
Beispiel #32
0
        def impl():
            shell = self.shell
            workflow = shell.projectManager.workflow
            object_export_applet = workflow.dataExportApplet
            gui = object_export_applet.getMultiLaneGui()
            op_object_export = object_export_applet.topLevelOperator.getLane(0)
            object_classification_applet = workflow.objectClassificationApplet
            op_object_classification = object_classification_applet.topLevelOperator.getLane(
                0)
            op_object_export_tlo = object_export_applet.topLevelOperator

            # activate the object information export applet
            shell.setSelectedAppletDrawer(4)
            # let the gui catch up
            QApplication.processEvents()

            op_object_export.OutputFilenameFormat.setValue(self.output_file)
            op_object_export.OutputFormat.setValue("hdf5")
            op_object_export.OutputInternalPath.setValue("exported_data")

            initial_table_export_settings = {
                "file type": "csv",
                "file path": self.table_csv_file,
                "normalize":
                True,  # self.ui.normalizeLabeling.checkState() == Qt.Checked,
                "margin": 3,
                "include raw": False,
                # compression settings cannot be edited in the gui atm.
                # values here are assumed defaults (taken from exportObjectInfoDialog.ui)
                "compression": {
                    "compression": "gzip",
                    "shuffle": False,
                    "compression_opts": 9
                },
            }
            table_export_settings, export_features = self.configure_export_dialog(
                gui, initial_table_export_settings)
            # here is some awkwardness of the csv output, which will alter the
            # table name: some_name.csv -> some_name_test_data_table.csv
            base, ext = os.path.splitext(self.table_csv_file)
            csv_out = f"{base}_table{ext}"
            TestObjectClassificationGui.table_csv_file_exported = csv_out

            exporter = gui.get_exporting_operator()

            exporter.configure_table_export_settings(table_export_settings,
                                                     export_features)

            # self.configure_export_dialog(op_object_export_tlo)

            with Timer() as timer:
                # this will not properly wait for the export to finish.
                # gui.drawer.exportAllButton.click()
                gui.exportSync(op_object_export_tlo)

            assert object_export_applet.busy is False
            assert os.path.exists(csv_out), f"Could not find {csv_out}"
            assert os.path.exists(self.output_file)
            logger.debug(f"Export time (data + csv): {timer.seconds()}")

            initial_table_export_settings.update({
                "file type":
                "h5",
                "file path":
                self.table_h5_file
            })

            table_export_settings, export_features = self.configure_export_dialog(
                gui, initial_table_export_settings)

            # here is some awkwardness of the h5 output, which will alter the
            # table name: some_name.h5 -> some_name_test_data.h5
            base, ext = os.path.splitext(self.table_h5_file)
            h5_out = f"{base}{ext}"
            TestObjectClassificationGui.table_h5_file_exported = h5_out

            exporter.configure_table_export_settings(table_export_settings,
                                                     export_features)

            with Timer() as timer:
                # this will not properly wait for the export to finish.
                # gui.drawer.exportAllButton.click()
                gui.exportSync(op_object_export_tlo)

            assert object_export_applet.busy is False
            assert os.path.exists(h5_out), f"Could not find {h5_out}"
            assert os.path.exists(self.output_file)
            logger.debug(f"Export time (data + h5): {timer.seconds()}")

            # Save the project
            saveThread = self.shell.onSaveProjectActionTriggered()
            saveThread.join()