def setUp( self ): self.GRAY1 = 60 self.ds1 = ConstantSource( self.GRAY1 ) self.GRAY2 = 120 self.ds2 = ConstantSource( self.GRAY2 ) self.GRAY3 = 190 self.ds3 = ConstantSource( self.GRAY3 ) self.layer1 = GrayscaleLayer( self.ds1, normalize = False ) self.layer1.visible = False self.layer1.opacity = 0.1 self.ims1 = GrayscaleImageSource( self.ds1, self.layer1 ) self.layer2 = GrayscaleLayer( self.ds2, normalize = False ) self.layer2.visible = True self.layer2.opacity = 0.3 self.ims2 = GrayscaleImageSource( self.ds2, self.layer2 ) self.layer3 = GrayscaleLayer( self.ds3, normalize = False ) self.layer3.visible = True self.layer3.opacity = 1.0 self.ims3 = GrayscaleImageSource( self.ds3, self.layer3 ) lsm = LayerStackModel() lsm.append(self.layer1) lsm.append(self.layer2) lsm.append(self.layer3) self.lsm = lsm sims = StackedImageSources( lsm ) sims.register( self.layer1, self.ims1 ) sims.register( self.layer2, self.ims2 ) sims.register( self.layer3, self.ims3 ) self.sims = sims
def _onReady(self, slot): if slot is self.mainOperator.RawImage: if slot.meta.shape and not self.rawsrc: self.rawsrc = LazyflowSource(self.mainOperator.RawImage) layerraw = GrayscaleLayer(self.rawsrc) layerraw.name = "Raw" self.layerstack.append(layerraw)
def setUp(self): self.ds = ConstantSource() self.layer1 = GrayscaleLayer(self.ds) self.layer1.visible = False self.layer1.opacity = 0.1 self.layer2 = GrayscaleLayer(self.ds) self.layer2.visible = True self.layer2.opacity = 0.3 self.layer3 = GrayscaleLayer(self.ds) self.layer3.visible = True self.layer3.opacity = 1.0
def setUp( self ): dataShape = (1, 900, 400, 10, 1) # t,x,y,z,c data = np.indices(dataShape)[3].astype(np.uint8) # Data is labeled according to z-index self.ds1 = ArraySource( data ) self.CONSTANT = 13 self.ds2 = ConstantSource( self.CONSTANT ) self.layer1 = GrayscaleLayer( self.ds1, normalize=False ) self.layer1.visible = True self.layer1.opacity = 1.0 self.layer2 = GrayscaleLayer( self.ds2, normalize=False ) self.lsm = LayerStackModel() self.pump = ImagePump( self.lsm, SliceProjection(), sync_along=(0,1,2) )
def setUp(self): super(GrayscaleImageSourceTest, self).setUp() self.raw = numpy.load( os.path.join(volumina._testing.__path__[0], 'lena.npy')).astype(numpy.uint32) self.ars = _ArraySource2d(self.raw) self.ims = GrayscaleImageSource(self.ars, GrayscaleLayer(self.ars))
def _onMetaChanged(self, slot): if slot is self.mainOperator.LabelImage: if slot.meta.shape: self.editor.dataShape = slot.meta.shape maxt = slot.meta.shape[0] - 1 self._setRanges() self._drawer.from_time.setValue(0) self._drawer.to_time.setValue(maxt) if slot is self.mainOperator.RawImage: if slot.meta.shape and not self.rawsrc: self.rawsrc = LazyflowSource(self.mainOperator.RawImage) layerraw = GrayscaleLayer(self.rawsrc) layerraw.name = "Raw" self.layerstack.append(layerraw)
def setUp(self): self.layerstack = LayerStackModel() self.sims = StackedImageSources(self.layerstack) self.GRAY = 201 self.ds = ConstantSource(self.GRAY) self.layer = GrayscaleLayer(self.ds) self.layer.set_normalize(0, False) self.layerstack.append(self.layer) self.ims = self.layer.createImageSource([PlanarSliceSource(self.ds)]) self.sims.register(self.layer, self.ims) self.scene = ImageScene2D(PositionModel(), (0, 3, 4), preemptive_fetch_number=0) self.scene.stackedImageSources = self.sims self.scene.dataShape = (310, 290)
def setupLayers(self): layers = [] op = self.topLevelOperatorView # Superpixels if op.Superpixels.ready(): layer = ColortableLayer( LazyflowSource(op.Superpixels), self._sp_colortable ) layer.colortableIsRandom = True layer.name = "Superpixels" layer.visible = True layer.opacity = 0.5 layers.append(layer) del layer # Debug layers if op.debug_results: for name, compressed_array in op.debug_results.items(): axiskeys = op.Superpixels.meta.getAxisKeys()[:-1] # debug images don't have a channel axis permutation = map(lambda key: axiskeys.index(key) if key in axiskeys else None, 'txyzc') arraysource = ArraySource( TransposedView(compressed_array, permutation) ) if compressed_array.dtype == np.uint32: layer = ColortableLayer(arraysource, self._sp_colortable) else: layer = GrayscaleLayer(arraysource) # TODO: Normalize? Maybe the drange should be included with the debug image. layer.name = name layer.visible = False layer.opacity = 1.0 layers.append(layer) del layer # Threshold if op.ThresholdedInput.ready(): layer = ColortableLayer( LazyflowSource(op.ThresholdedInput), self._threshold_colortable ) layer.name = "Thresholded Input" layer.visible = True layer.opacity = 1.0 layers.append(layer) del layer # Raw Data (grayscale) if op.Input.ready(): layer = self._create_grayscale_layer_from_slot( op.Input, op.Input.meta.getTaggedShape()['c'] ) layer.name = "Input" layer.visible = False layer.opacity = 1.0 layers.append(layer) del layer # Raw Data (grayscale) if op.RawData.ready(): layer = self.createStandardLayerFromSlot( op.RawData ) layer.name = "Raw Data" layer.visible = True layer.opacity = 1.0 layers.append(layer) del layer return layers
def _add_grayscale_layer(self, data, name=None, visible=False): ''' adds a grayscale layer to the layerstack :param data: numpy array (2D) containing the data :param name: name of layer :param visible: bool determining whether this layer should be set to visible :return: ''' #assert len(data.shape) == 2 a, data_shape = createDataSource(data, True) self.editor.dataShape = list(data_shape) new_layer = GrayscaleLayer(a) new_layer.visible = visible if name is not None: new_layer.name = name self.layerstack.append(new_layer)
def setUp(self): super(GrayscaleImageSourceTest, self).setUp() self.raw = numpy.load( os.path.join(volumina._testing.__path__[0], "2d_cells_apoptotic_1channel.npy")).astype( numpy.uint32) self.ars = _ArraySource2d(self.raw) self.ims = GrayscaleImageSource(self.ars, GrayscaleLayer(self.ars))
def initUic(self): self.g = g = Graph() #get the absolute path of the 'ilastik' module uic.loadUi("designerElements/MainWindow.ui", self) self.actionQuit.triggered.connect(qApp.quit) def toggleDebugPatches(show): self.editor.showDebugPatches = show self.actionShowDebugPatches.toggled.connect(toggleDebugPatches) self.layerstack = LayerStackModel() readerNew = op.OpH5ReaderBigDataset(g) readerNew.inputs["Filenames"].setValue([ "scripts/CB_compressed_XY.h5", "scripts/CB_compressed_XZ.h5", "scripts/CB_compressed_YZ.h5" ]) readerNew.inputs["hdf5Path"].setValue("volume/data") datasrc = LazyflowSource(readerNew.outputs["Output"]) layer1 = GrayscaleLayer(datasrc) layer1.name = "Big Data" self.layerstack.append(layer1) shape = readerNew.outputs["Output"].meta.shape print shape self.editor = VolumeEditor(shape, self.layerstack) #self.editor.setDrawingEnabled(False) self.volumeEditorWidget.init(self.editor) model = self.editor.layerStack self.layerWidget.init(model) self.UpButton.clicked.connect(model.moveSelectedUp) model.canMoveSelectedUp.connect(self.UpButton.setEnabled) self.DownButton.clicked.connect(model.moveSelectedDown) model.canMoveSelectedDown.connect(self.DownButton.setEnabled) self.DeleteButton.clicked.connect(model.deleteSelected) model.canDeleteSelected.connect(self.DeleteButton.setEnabled)
def setUp(self): self.ds = ConstantSource() self.layer1 = GrayscaleLayer(self.ds) self.layer1.visible = False self.layer1.opacity = 0.1 self.ims1 = GrayscaleImageSource(PlanarSliceSource(self.ds), self.layer1) self.layer2 = GrayscaleLayer(self.ds) self.layer2.visible = True self.layer2.opacity = 0.3 self.ims2 = GrayscaleImageSource(PlanarSliceSource(self.ds), self.layer2) self.layer3 = GrayscaleLayer(self.ds) self.layer3.visible = True self.layer3.opacity = 1.0 self.ims3 = GrayscaleImageSource(PlanarSliceSource(self.ds), self.layer3)
def setUp(self): self.layerstack = LayerStackModel() self.sims = StackedImageSources(self.layerstack) self.g = Graph() self.op = OpLazy(self.g) self.ds = LazyflowSource(self.op.Output) self.ss = PlanarSliceSource(self.ds, projectionAlongTZC) self.layer = GrayscaleLayer(self.ds, normalize=False) self.layerstack.append(self.layer) self.ims = self.layer.createImageSource([self.ss]) self.sims.register(self.layer, self.ims) self.scene = ImageScene2D(PositionModel(), (0, 0, 0), preemptive_fetch_number=0) self.scene.setCacheSize(1) self.scene.stackedImageSources = self.sims self.scene.dataShape = (30, 30)
def setUp(self): super(GrayscaleImageSourceTest2, self).setUp() self.raw = numpy.load(os.path.join(volumina._testing.__path__[0], "lena.npy")).astype(numpy.uint32) self.raw = numpy.ma.masked_array(self.raw, numpy.zeros(self.raw.shape, dtype=bool), shrink=False) self.raw[:10, :] = numpy.ma.masked self.raw[-10:, :] = numpy.ma.masked self.raw[:, :10] = numpy.ma.masked self.raw[:, -10:] = numpy.ma.masked self.ars = _ArraySource2d(self.raw) self.ims = GrayscaleImageSource(self.ars, GrayscaleLayer(self.ars))
def createWidget(self, parent): a = (numpy.random.random((1, 100, 200, 300, 1)) * 255).astype(numpy.uint8) source = ArraySource(a) layerstack = LayerStackModel() layerstack.append(GrayscaleLayer(source)) editor = VolumeEditor(layerstack, labelsink=None, parent=self) widget = VolumeEditorWidget(parent=parent) if not _has_lazyflow: widget.setEnabled(False) widget.init(editor) editor.dataShape = a.shape return widget
def showStuff(raw_name, pred_viewer1, pred_viewer2, cutout_name, one_extra=None): # display the raw and annotations for cremi challenge data raw = vigra.impex.readHDF5(indir + datasets[raw_name], "data", order='C') # raw_old = vigra.readHDF5(indir+datasets["raw_bad"], "data", order = 'C') defect_prediction_128 = vigra.impex.readHDF5(indir + datasets[pred_viewer2], "data", order='C') defect_prediction_150 = vigra.impex.readHDF5(indir + datasets[pred_viewer1], "data", order='C') cutout_from_150_pred = vigra.impex.readHDF5(indir + datasets[cutout_name], "data", order='C') #################################################################################################################### # only used for fast testing stuff #change_one = vigra.readHDF5(indir+datasets["segmentation_on_equalized_image"], "data", order = 'C') #pdb.set_trace() #defect_prediction_150[1,:,:] = change_one[0,:,:,0] #################################################################################################################### # defect_prediction_150 = gt[..., 0] cutout = numpy.asarray(cutout_from_150_pred) rawdata = numpy.asarray(raw) # rawdata_old = numpy.asarray(raw_old) # op5ify # shape5d = rawdata.shape shape5d = (1, ) + rawdata.shape + (1, ) print shape5d, rawdata.shape, rawdata.dtype app = QApplication([]) v = Viewer() direct = False # layer for raw data rawdata = numpy.reshape(rawdata, shape5d) rawsource = ArraySource(rawdata) v.dataShape = shape5d lraw = GrayscaleLayer(rawsource, direct=direct) lraw.visible = True lraw.name = "raw" v.layerstack.append(lraw) # layer for cutout regions from raw data cutout = numpy.reshape(cutout, shape5d) cutoutsource = ArraySource(cutout) lcutout = GrayscaleLayer(cutoutsource, direct=direct) lcutout.visible = False lcutout.name = "cut_out" v.layerstack.append(lcutout) # layer for first prediction result defect_prediction_128 = numpy.reshape(defect_prediction_128, shape5d) synsource = ArraySource(defect_prediction_128) ct = create_random_16bit() ct[0] = 0 lsyn = ColortableLayer(synsource, ct) lsyn.name = pred_viewer2 lsyn.visible = False v.layerstack.append(lsyn) # layer for second prediction result segm = numpy.reshape(defect_prediction_150, shape5d) segsource = ArraySource(segm) ct = create_random_16bit() ct[0] = 0 lseg = ColortableLayer(segsource, ct) lseg.name = pred_viewer1 lseg.visible = False v.layerstack.append(lseg) if one_extra is None: v.showMaximized() app.exec_() if one_extra is not None: # layer for third prediction result extra_prediction = vigra.readHDF5(indir + datasets[one_extra], "data", order='C') extra_pred_reshaped = numpy.reshape(extra_prediction, shape5d) segsource = ArraySource(extra_pred_reshaped) ct = create_random_16bit() ct[0] = 0 # ct = create_default_16bit() lseg = ColortableLayer(segsource, ct) lseg.name = one_extra lseg.visible = False v.layerstack.append(lseg) v.showMaximized() app.exec_()
from volumina.pixelpipeline.datasources import ArraySinkSource, ArraySource from volumina.layer import ColortableLayer, GrayscaleLayer from PyQt5.QtWidgets import QApplication SHAPE = (1, 600, 800, 1, 1) # volumina expects 5d txyzc data_arr = (255 * numpy.random.random(SHAPE)).astype(numpy.uint8) label_arr = numpy.zeros(SHAPE, dtype=numpy.uint8) ##----- app = QApplication(sys.argv) v = Viewer() data_src = ArraySource(data_arr) data_layer = GrayscaleLayer(data_src) data_layer.name = "Raw" data_layer.numberOfChannels = 1 label_src = ArraySinkSource(label_arr) label_layer = ColortableLayer(label_src, colorTable=default16_new, direct=False) label_layer.name = "Labels" label_layer.ref_object = None assert SHAPE == label_arr.shape == data_arr.shape v.dataShape = SHAPE v.layerstack.append(data_layer) v.layerstack.append(label_layer)
def setUp(self): self.raw = numpy.load( os.path.join(volumina._testing.__path__[0], 'lena.npy')) self.ars = _ArraySource2d(self.raw) self.ims = GrayscaleImageSource(self.ars, GrayscaleLayer(self.ars))
# self.editor.imageViews[self.editor._lastImageViewFocus]._cursorBackup = self.editor.imageViews[self.editor._lastImageViewFocus].cursor() # self.editor.imageViews[self.editor._lastImageViewFocus].setCursor(Qt.CrossCursor) # else: # self.editor.imageViews[self.editor._lastImageViewFocus]._isRubberBandZoom = False # self.editor.imageViews[self.editor._lastImageViewFocus].setCursor(self.editor.imageViews[self.editor._lastImageViewFocus]._cursorBackup) # self._viewMenu.addAction( "RubberBand zoom" ).triggered.connect(rubberBandZoom) # ******************************************************************************* # i f _ _ n a m e _ _ = = " _ _ m a i n _ _ " * # ******************************************************************************* if __name__ == "__main__": import sys from .layerstack import LayerStackModel from volumina.layer import GrayscaleLayer array = numpy.random.rand(1, 100, 100, 100, 1) array *= 255 array = array.astype("uint8") layer = GrayscaleLayer(ArraySource(array)) app = QApplication(sys.argv) layerStackModel = LayerStackModel() layerStackModel.insert(0, layer) volumeEditor = VolumeEditor(layerStackModel, parent=None) volumeEditor.dataShape = array.shape volumeEditorWidget = VolumeEditorWidget(editor=volumeEditor) volumeEditorWidget.show() app.exec_()
def setupLayers(self): layers = [] if "MergerOutput" in self.topLevelOperatorView.outputs and self.topLevelOperatorView.MergerOutput.ready( ): ct = colortables.create_default_8bit() for i in range(7): ct[i] = self.mergerColors[i].rgba() self.mergersrc = LazyflowSource( self.topLevelOperatorView.MergerOutput) mergerLayer = ColortableLayer(self.mergersrc, ct) mergerLayer.name = "Merger" mergerLayer.visible = True layers.append(mergerLayer) ct = colortables.create_random_16bit() ct[0] = QColor(0, 0, 0, 0).rgba() # make 0 transparent ct[1] = QColor(128, 128, 128, 255).rgba( ) # misdetections have id 1 and will be indicated by grey if self.topLevelOperatorView.CachedOutput.ready(): self.trackingsrc = LazyflowSource( self.topLevelOperatorView.CachedOutput) trackingLayer = ColortableLayer(self.trackingsrc, ct) trackingLayer.name = "Tracking" trackingLayer.visible = True trackingLayer.opacity = 1.0 layers.append(trackingLayer) elif self.topLevelOperatorView.zeroProvider.Output.ready(): # provide zeros while waiting for the tracking result self.trackingsrc = LazyflowSource( self.topLevelOperatorView.zeroProvider.Output) trackingLayer = ColortableLayer(self.trackingsrc, ct) trackingLayer.name = "Tracking" trackingLayer.visible = True trackingLayer.opacity = 1.0 layers.append(trackingLayer) if self.topLevelOperatorView.LabelImage.ready(): self.objectssrc = LazyflowSource( self.topLevelOperatorView.LabelImage) ct = colortables.create_random_16bit() ct[0] = QColor(0, 0, 0, 0).rgba() # make 0 transparent objLayer = ColortableLayer(self.objectssrc, ct) objLayer.name = "Objects" objLayer.opacity = 1.0 objLayer.visible = True layers.append(objLayer) if self.mainOperator.RawImage.ready(): self.rawsrc = None self.rawsrc = LazyflowSource(self.mainOperator.RawImage) rawLayer = GrayscaleLayer(self.rawsrc) rawLayer.name = "Raw" layers.insert(len(layers), rawLayer) if self.topLevelOperatorView.LabelImage.meta.shape: self.editor.dataShape = self.topLevelOperatorView.LabelImage.meta.shape maxt = self.topLevelOperatorView.LabelImage.meta.shape[0] - 1 maxx = self.topLevelOperatorView.LabelImage.meta.shape[1] - 1 maxy = self.topLevelOperatorView.LabelImage.meta.shape[2] - 1 maxz = self.topLevelOperatorView.LabelImage.meta.shape[3] - 1 if not self.mainOperator.Parameters.ready(): raise Exception("Parameter slot is not ready") parameters = self.mainOperator.Parameters.value self._setRanges() if 'size_range' in parameters: self._drawer.to_size.setValue(parameters['size_range'][1] - 1) self._drawer.from_size.setValue(parameters['size_range'][0]) else: self._drawer.from_size.setValue(0) self._drawer.to_size.setValue(10000) if 'x_range' in parameters: self._drawer.to_x.setValue(parameters['x_range'][1] - 1) self._drawer.from_x.setValue(parameters['x_range'][0]) else: self._drawer.from_x.setValue(0) self._drawer.to_x.setValue(maxx) if 'y_range' in parameters: self._drawer.to_y.setValue(parameters['y_range'][1] - 1) self._drawer.from_y.setValue(parameters['y_range'][0]) else: self._drawer.from_y.setValue(0) self._drawer.to_y.setValue(maxy) if 'z_range' in parameters: self._drawer.to_z.setValue(parameters['z_range'][1] - 1) self._drawer.from_z.setValue(parameters['z_range'][0]) else: self._drawer.from_z.setValue(0) self._drawer.to_z.setValue(maxz) if 'time_range' in parameters: self._drawer.to_time.setValue(parameters['time_range'][1]) self._drawer.from_time.setValue(parameters['time_range'][0]) else: self._drawer.from_time.setValue(0) self._drawer.to_time.setValue(maxt) if 'scales' in parameters: self._drawer.x_scale.setValue(parameters['scales'][0]) self._drawer.y_scale.setValue(parameters['scales'][1]) self._drawer.z_scale.setValue(parameters['scales'][2]) else: self._drawer.x_scale.setValue(1) self._drawer.y_scale.setValue(1) self._drawer.z_scale.setValue(1) self.topLevelOperatorView.RawImage.notifyReady(self._onReady) self.topLevelOperatorView.RawImage.notifyMetaChanged( self._onMetaChanged) return layers
def setupLayers( self, currentImageIndex ): layers = [] def onButtonsEnabled(slot, roi): currObj = self._carvingApplet.topLevelOperator.opCarving[currentImageIndex].CurrentObjectName.value hasSeg = self._carvingApplet.topLevelOperator.opCarving[currentImageIndex].HasSegmentation.value nzLB = self._carvingApplet.topLevelOperator.opLabeling.NonzeroLabelBlocks[currentImageIndex][:].wait()[0] self.labelingDrawerUi.currentObjectLabel.setText("current object: %s" % currObj) self.labelingDrawerUi.save.setEnabled(currObj != "" and hasSeg) self.labelingDrawerUi.saveAs.setEnabled(currObj == "" and hasSeg) #rethink this #self.labelingDrawerUi.segment.setEnabled(len(nzLB) > 0) #self.labelingDrawerUi.clear.setEnabled(len(nzLB) > 0) self._carvingApplet.topLevelOperator.opCarving[currentImageIndex].CurrentObjectName.notifyDirty(onButtonsEnabled) self._carvingApplet.topLevelOperator.opCarving[currentImageIndex].HasSegmentation.notifyDirty(onButtonsEnabled) self._carvingApplet.topLevelOperator.opLabeling.NonzeroLabelBlocks[currentImageIndex].notifyDirty(onButtonsEnabled) # Labels labellayer, labelsrc = self.createLabelLayer(currentImageIndex, direct=True) if labellayer is not None: layers.append(labellayer) # Tell the editor where to draw label data self.editor.setLabelSink(labelsrc) #segmentation seg = self._carvingApplet.topLevelOperator.opCarving.Segmentation[currentImageIndex] #seg = self._carvingApplet.topLevelOperator.opCarving[0]._mst.segmentation #temp = self._done_lut[self._mst.regionVol[sl[1:4]]] if seg.ready(): #source = RelabelingArraySource(seg) #source.setRelabeling(numpy.arange(256, dtype=numpy.uint8)) colortable = [QColor(0,0,0,0).rgba(), QColor(0,0,0,0).rgba(), QColor(0,255,0).rgba()] for i in range(256-len(colortable)): r,g,b = numpy.random.randint(0,255), numpy.random.randint(0,255), numpy.random.randint(0,255) colortable.append(QColor(r,g,b).rgba()) #layer = DirectColorTableLayer(seg, colortable, lazyflow=True) layer = ColortableLayer(LazyflowSource(seg), colortable, direct=True) layer.name = "segmentation" layer.visible = True layer.opacity = 0.3 layers.append(layer) #done done = self._carvingApplet.topLevelOperator.opCarving.DoneObjects[currentImageIndex] if done.ready(): colortable = [QColor(0,0,0,0).rgba(), QColor(0,0,255).rgba()] for i in range(254-len(colortable)): r,g,b = numpy.random.randint(0,255), numpy.random.randint(0,255), numpy.random.randint(0,255) colortable.append(QColor(r,g,b).rgba()) #have to use lazyflow because it provides dirty signals #layer = DirectColorTableLayer(done, colortable, lazyflow=True) layer = ColortableLayer(LazyflowSource(done), colortable, direct=True) layer.name = "done" layer.visible = False layer.opacity = 0.5 layers.append(layer) doneSeg = self._carvingApplet.topLevelOperator.opCarving.DoneSegmentation[currentImageIndex] if doneSeg.ready(): layer = ColortableLayer(LazyflowSource(doneSeg), self._doneSegmentationColortable, direct=True) layer.name = "done seg" layer.visible = False layer.opacity = 0.5 self._doneSegmentationLayer = layer layers.append(layer) #supervoxel sv = self._carvingApplet.topLevelOperator.opCarving.Supervoxels[currentImageIndex] if sv.ready(): for i in range(256): r,g,b = numpy.random.randint(0,255), numpy.random.randint(0,255), numpy.random.randint(0,255) colortable.append(QColor(r,g,b).rgba()) #layer = DirectColorTableLayer(sv, colortable, lazyflow=True) layer = ColortableLayer(LazyflowSource(sv), colortable, direct=True) layer.name = "supervoxels" layer.visible = False layer.opacity = 1.0 layers.append(layer) # # load additional layer: features / probability map # import h5py f = h5py.File("pmap.h5") pmap = f["data"].value # # here we load the actual raw data from an ArraySource rather than from a LazyflowSource for speed reasons # raw = self._carvingApplet.topLevelOperator.opCarving[0]._mst.raw raw5D = numpy.zeros((1,)+raw.shape+(1,), dtype=raw.dtype) raw5D[0,:,:,:,0] = raw[:,:,:] #layer = DirectGrayscaleLayer(raw5D) layer = GrayscaleLayer(ArraySource(raw5D), direct=True) layer.name = "raw" layer.visible = True layer.opacity = 1.0 #layers.insert(1, layer) layers.append(layer) return layers
class ImageScene2D_RenderTest(ut.TestCase): @classmethod def setUpClass(cls): cls.app = None if QApplication.instance(): cls.app = QApplication.instance() else: cls.app = QApplication([]) @classmethod def tearDownClass(cls): del cls.app def setUp(self): self.layerstack = LayerStackModel() self.sims = StackedImageSources(self.layerstack) self.GRAY = 201 self.ds = ConstantSource(self.GRAY) self.layer = GrayscaleLayer(self.ds) self.layer.set_normalize(0, False) self.layerstack.append(self.layer) self.ims = self.layer.createImageSource([self.ds]) self.sims.register(self.layer, self.ims) self.scene = ImageScene2D(PositionModel(), (0, 3, 4), preemptive_fetch_number=0) self.scene.stackedImageSources = self.sims self.scene.dataShape = (310, 290) def renderScene(self, s, exportFilename=None): img = QImage(310, 290, QImage.Format_ARGB32_Premultiplied) img.fill(0) p = QPainter(img) s.render(p) s.joinRenderingAllTiles(viewport_only=False) s.render(p) p.end() if exportFilename is not None: img.save(exportFilename) return byte_view(img) def testBasicImageRenderingCapability(self): aimg = self.renderScene(self.scene) self.assertTrue(np.all(aimg[:, :, 0:3] == self.GRAY)) self.assertTrue(np.all(aimg[:, :, 3] == 255)) def testToggleVisibilityOfOneLayer(self): aimg = self.renderScene(self.scene) self.assertTrue(np.all(aimg[:, :, 0:3] == self.GRAY)) self.assertTrue(np.all(aimg[:, :, 3] == 255)) self.layer.visible = False aimg = self.renderScene(self.scene) self.assertTrue(np.all(aimg[:, :, 0:3] == 0)) # all white self.assertTrue(np.all(aimg[:, :, 3] == 0)) self.layer.visible = True aimg = self.renderScene(self.scene) self.assertTrue(np.all(aimg[:, :, 0:3] == self.GRAY)) self.assertTrue(np.all(aimg[:, :, 3] == 255))
def setupLayers(self): logger.debug("setupLayers") layers = [] def onButtonsEnabled(slot, roi): currObj = self.topLevelOperatorView.CurrentObjectName.value hasSeg = self.topLevelOperatorView.HasSegmentation.value self.labelingDrawerUi.currentObjectLabel.setText(currObj) self.labelingDrawerUi.save.setEnabled(hasSeg) self.topLevelOperatorView.CurrentObjectName.notifyDirty( onButtonsEnabled) self.topLevelOperatorView.HasSegmentation.notifyDirty(onButtonsEnabled) self.topLevelOperatorView.opLabelArray.NonzeroBlocks.notifyDirty( onButtonsEnabled) # Labels labellayer, labelsrc = self.createLabelLayer(direct=True) if labellayer is not None: labellayer._allowToggleVisible = False layers.append(labellayer) # Tell the editor where to draw label data self.editor.setLabelSink(labelsrc) # uncertainty # if self._showUncertaintyLayer: # uncert = self.topLevelOperatorView.Uncertainty # if uncert.ready(): # colortable = [] # for i in range(256-len(colortable)): # r,g,b,a = i,0,0,i # colortable.append(QColor(r,g,b,a).rgba()) # layer = ColortableLayer(createDataSource(uncert), colortable, direct=True) # layer.name = "Uncertainty" # layer.visible = True # layer.opacity = 0.3 # layers.append(layer) # segmentation seg = self.topLevelOperatorView.Segmentation # seg = self.topLevelOperatorView.MST.value.segmentation # temp = self._done_lut[self.MST.value.supervoxelUint32[sl[1:4]]] if seg.ready(): # source = RelabelingArraySource(seg) # source.setRelabeling(numpy.arange(256, dtype=numpy.uint8)) # assign to the object label color, 0 is transparent, 1 is background colortable = [ QColor(0, 0, 0, 0).rgba(), QColor(0, 0, 0, 0).rgba(), labellayer._colorTable[2] ] for i in range(256 - len(colortable)): r, g, b = numpy.random.randint(0, 255), numpy.random.randint( 0, 255), numpy.random.randint(0, 255) colortable.append(QColor(r, g, b).rgba()) layer = ColortableLayer(createDataSource(seg), colortable, direct=True) layer.name = "Segmentation" layer.setToolTip( "This layer displays the <i>current</i> segmentation. Simply add foreground and background " "labels, then press <i>Segment</i>.") layer.visible = True layer.opacity = 0.3 layers.append(layer) # done doneSeg = self.topLevelOperatorView.DoneSegmentation if doneSeg.ready(): # FIXME: if the user segments more than 255 objects, those with indices that divide by 255 will be shown as transparent # both here and in the _doneSegmentationColortable colortable = 254 * [QColor(230, 25, 75).rgba()] colortable.insert(0, QColor(0, 0, 0, 0).rgba()) # have to use lazyflow because it provides dirty signals layer = ColortableLayer(createDataSource(doneSeg), colortable, direct=True) layer.name = "Completed segments (unicolor)" layer.setToolTip( "In order to keep track of which objects you have already completed, this layer " "shows <b>all completed object</b> in one color (<b>blue</b>). " "The reason for only one color is that for finding out which " "objects to label next, the identity of already completed objects is unimportant " "and destracting.") layer.visible = False layer.opacity = 0.5 layers.append(layer) layer = ColortableLayer(createDataSource(doneSeg), self._doneSegmentationColortable, direct=True) layer.name = "Completed segments (one color per object)" layer.setToolTip( "<html>In order to keep track of which objects you have already completed, this layer " "shows <b>all completed object</b>, each with a random color.</html>" ) layer.visible = False layer.opacity = 0.5 layer.colortableIsRandom = True self._doneSegmentationLayer = layer layers.append(layer) # supervoxel sv = self.topLevelOperatorView.Supervoxels if sv.ready(): colortable = [] for i in range(256): r, g, b = numpy.random.randint(0, 255), numpy.random.randint( 0, 255), numpy.random.randint(0, 255) colortable.append(QColor(r, g, b).rgba()) layer = ColortableLayer(createDataSource(sv), colortable, direct=True) layer.name = "Supervoxels" layer.setToolTip( "<html>This layer shows the partitioning of the input image into <b>supervoxels</b>. The carving " "algorithm uses these tiny puzzle-piceces to piece together the segmentation of an " "object. Sometimes, supervoxels are too large and straddle two distinct objects " "(undersegmentation). In this case, it will be impossible to achieve the desired " "segmentation. This layer helps you to understand these cases.</html>" ) layer.visible = False layer.colortableIsRandom = True layer.opacity = 0.5 layers.append(layer) # Visual overlay (just for easier labeling) overlaySlot = self.topLevelOperatorView.OverlayData if overlaySlot.ready(): overlay5D = self.topLevelOperatorView.OverlayData.value layer = GrayscaleLayer(ArraySource(overlay5D), direct=True) layer.visible = True layer.name = "Overlay" layer.opacity = 1.0 # if the flag window_leveling is set the contrast # of the layer is adjustable layer.window_leveling = True self.labelingDrawerUi.thresToolButton.show() layers.append(layer) del layer inputSlot = self.topLevelOperatorView.InputData if inputSlot.ready(): layer = GrayscaleLayer(createDataSource(inputSlot), direct=True) layer.name = "Input Data" layer.setToolTip( "<html>The data originally loaded into ilastik (unprocessed).</html>" ) # layer.visible = not rawSlot.ready() layer.visible = True layer.opacity = 1.0 # Window leveling is already active on the Overlay, # but if no overlay was provided, then activate window_leveling on the raw data instead. if not overlaySlot.ready(): # if the flag window_leveling is set the contrast # of the layer is adjustable layer.window_leveling = True self.labelingDrawerUi.thresToolButton.show() layers.append(layer) del layer filteredSlot = self.topLevelOperatorView.FilteredInputData if filteredSlot.ready(): layer = GrayscaleLayer(createDataSource(filteredSlot)) layer.name = "Filtered Input" layer.visible = False layer.opacity = 1.0 layers.append(layer) return layers
def setupLayers(self): layers = [] op = self.topLevelOperatorView ravelerLabelsSlot = op.RavelerLabels if ravelerLabelsSlot.ready(): colortable = [] for _ in range(256): r,g,b = numpy.random.randint(0,255), numpy.random.randint(0,255), numpy.random.randint(0,255) colortable.append(QColor(r,g,b).rgba()) ravelerLabelLayer = ColortableLayer(LazyflowSource(ravelerLabelsSlot), colortable, direct=True) ravelerLabelLayer.name = "Raveler Labels" ravelerLabelLayer.visible = False ravelerLabelLayer.opacity = 0.4 layers.append(ravelerLabelLayer) def addFragmentSegmentationLayers(mslot, name): if mslot.ready(): for index, slot in enumerate(mslot): if slot.ready(): raveler_label = slot.meta.selected_label colortable = map(QColor.rgba, self._fragmentColors) fragSegLayer = ColortableLayer(LazyflowSource(slot), colortable, direct=True) fragSegLayer.name = "{} #{} ({})".format( name, index, raveler_label ) fragSegLayer.visible = False fragSegLayer.opacity = 1.0 layers.append(fragSegLayer) addFragmentSegmentationLayers( op.FragmentedBodies, "Saved Fragments" ) addFragmentSegmentationLayers( op.RelabeledFragments, "Relabeled Fragments" ) addFragmentSegmentationLayers( op.FilteredFragmentedBodies, "CC-Filtered Fragments" ) addFragmentSegmentationLayers( op.WatershedFilledBodies, "Watershed-filled Fragments" ) mslot = op.EditedRavelerBodies for index, slot in enumerate(mslot): if slot.ready(): raveler_label = slot.meta.selected_label # 0=Black, 1=Transparent colortable = [QColor(0, 0, 0).rgba(), QColor(0, 0, 0, 0).rgba()] bodyMaskLayer = ColortableLayer(LazyflowSource(slot), colortable, direct=True) bodyMaskLayer.name = "Raveler Body Mask #{} ({})".format( index, raveler_label ) bodyMaskLayer.visible = False bodyMaskLayer.opacity = 1.0 layers.append(bodyMaskLayer) finalSegSlot = op.FinalSegmentation if finalSegSlot.ready(): colortable = [] for _ in range(256): r,g,b = numpy.random.randint(0,255), numpy.random.randint(0,255), numpy.random.randint(0,255) colortable.append(QColor(r,g,b).rgba()) finalLayer = ColortableLayer(LazyflowSource(finalSegSlot), colortable, direct=True) finalLayer.name = "Final Segmentation" finalLayer.visible = False finalLayer.opacity = 0.4 layers.append(finalLayer) inputSlot = op.InputData if inputSlot.ready(): layer = GrayscaleLayer( LazyflowSource(inputSlot) ) layer.name = "WS Input" layer.visible = False layer.opacity = 1.0 layers.append(layer) #raw data rawSlot = self.topLevelOperatorView.RawData rawLayer = None if rawSlot.ready(): raw5D = self.topLevelOperatorView.RawData.value rawLayer = GrayscaleLayer(ArraySource(raw5D), direct=True) #rawLayer = GrayscaleLayer( LazyflowSource(rawSlot) ) rawLayer.name = "raw" rawLayer.visible = True rawLayer.opacity = 1.0 rawLayer.shortcutRegistration = ( "g", ShortcutManager.ActionInfo( "Postprocessing", "Raw Data to Top", "Raw Data to Top", partial(self._toggleRawDataPosition, rawLayer), self.viewerControlWidget(), rawLayer ) ) layers.append(rawLayer) return layers
class ImageScene2D_LazyTest(ut.TestCase): def setUp(self): self.layerstack = LayerStackModel() self.sims = StackedImageSources(self.layerstack) self.g = Graph() self.op = OpLazy(self.g) self.ds = LazyflowSource(self.op.Output) self.ss = PlanarSliceSource(self.ds, projectionAlongTZC) self.layer = GrayscaleLayer(self.ds, normalize=False) self.layerstack.append(self.layer) self.ims = self.layer.createImageSource([self.ss]) self.sims.register(self.layer, self.ims) self.scene = ImageScene2D(PositionModel(), (0, 0, 0), preemptive_fetch_number=0) self.scene.setCacheSize(1) self.scene.stackedImageSources = self.sims self.scene.dataShape = (30, 30) def renderScene(self, s, exportFilename=None, joinRendering=True): img = QImage(30, 30, QImage.Format_ARGB32_Premultiplied) img.fill(Qt.white) p = QPainter(img) s.render(p) # trigger a rendering of the whole scene if joinRendering: # wait for all the data to arrive s.joinRenderingAllTiles( viewport_only=False) # There is no viewport! # finally, render everything s.render(p) p.end() if exportFilename is not None: img.save(exportFilename) return byte_view(img) def testLazy(self): for i in range(3): self.op.setConstant(i) aimg = self.renderScene(self.scene, "/tmp/a_%03d.png" % i) assert numpy.all( aimg[:, :, 0] == i), "!= %d, [0,0,0]=%d" % (i, aimg[0, 0, 0]) self.op.setConstant(42) self.op.setDelay(1) aimg = self.renderScene(self.scene, joinRendering=False, exportFilename="/tmp/x_%03d.png" % i) # this should be "i", not 255 (the default background for the imagescene) assert numpy.all( aimg[:, :, 0] == i), "!= %d, [0,0,0]=%d" % (i, aimg[0, 0, 0]) # Now give the scene time to update before we change it again... self.scene.joinRenderingAllTiles(viewport_only=False)
def setupLayers(self): layers = [] op = self.topLevelOperatorView ravelerLabelsSlot = op.RavelerLabels if ravelerLabelsSlot.ready(): colortable = [] for _ in range(256): r, g, b = numpy.random.randint(0, 255), numpy.random.randint( 0, 255), numpy.random.randint(0, 255) colortable.append(QColor(r, g, b).rgba()) ravelerLabelLayer = ColortableLayer( LazyflowSource(ravelerLabelsSlot), colortable, direct=True) ravelerLabelLayer.name = "Raveler Labels" ravelerLabelLayer.visible = False ravelerLabelLayer.opacity = 0.4 layers.append(ravelerLabelLayer) supervoxelsSlot = op.Supervoxels if supervoxelsSlot.ready(): colortable = [] for i in range(256): r, g, b = numpy.random.randint(0, 255), numpy.random.randint( 0, 255), numpy.random.randint(0, 255) colortable.append(QColor(r, g, b).rgba()) supervoxelsLayer = ColortableLayer(LazyflowSource(supervoxelsSlot), colortable) supervoxelsLayer.name = "Input Supervoxels" supervoxelsLayer.visible = False supervoxelsLayer.opacity = 1.0 layers.append(supervoxelsLayer) def addFragmentSegmentationLayers(mslot, name): if mslot.ready(): for index, slot in enumerate(mslot): if slot.ready(): raveler_label = slot.meta.selected_label colortable = [] for i in range(256): r, g, b = numpy.random.randint( 0, 255), numpy.random.randint( 0, 255), numpy.random.randint(0, 255) colortable.append(QColor(r, g, b).rgba()) colortable[0] = QColor(0, 0, 0, 0).rgba() fragSegLayer = ColortableLayer(LazyflowSource(slot), colortable, direct=True) fragSegLayer.name = "{} #{} ({})".format( name, index, raveler_label) fragSegLayer.visible = False fragSegLayer.opacity = 1.0 layers.append(fragSegLayer) addFragmentSegmentationLayers(op.MaskedSupervoxels, "Masked Supervoxels") addFragmentSegmentationLayers(op.FilteredMaskedSupervoxels, "Filtered Masked Supervoxels") addFragmentSegmentationLayers(op.HoleFilledSupervoxels, "Hole Filled Supervoxels") addFragmentSegmentationLayers(op.RelabeledSupervoxels, "Relabeled Supervoxels") mslot = op.EditedRavelerBodies for index, slot in enumerate(mslot): if slot.ready(): raveler_label = slot.meta.selected_label # 0=Black, 1=Transparent colortable = [ QColor(0, 0, 0).rgba(), QColor(0, 0, 0, 0).rgba() ] bodyMaskLayer = ColortableLayer(LazyflowSource(slot), colortable, direct=True) bodyMaskLayer.name = "Raveler Body Mask #{} ({})".format( index, raveler_label) bodyMaskLayer.visible = False bodyMaskLayer.opacity = 1.0 layers.append(bodyMaskLayer) finalSegSlot = op.FinalSupervoxels if finalSegSlot.ready(): colortable = [] for _ in range(256): r, g, b = numpy.random.randint(0, 255), numpy.random.randint( 0, 255), numpy.random.randint(0, 255) colortable.append(QColor(r, g, b).rgba()) finalLayer = ColortableLayer(LazyflowSource(finalSegSlot), colortable) finalLayer.name = "Final Supervoxels" finalLayer.visible = False finalLayer.opacity = 0.4 layers.append(finalLayer) inputSlot = op.InputData if inputSlot.ready(): layer = GrayscaleLayer(LazyflowSource(inputSlot)) layer.name = "WS Input" layer.visible = False layer.opacity = 1.0 layers.append(layer) #raw data rawSlot = self.topLevelOperatorView.RawData if rawSlot.ready(): raw5D = self.topLevelOperatorView.RawData.value layer = GrayscaleLayer(ArraySource(raw5D), direct=True) #layer = GrayscaleLayer( LazyflowSource(rawSlot) ) layer.name = "raw" layer.visible = True layer.opacity = 1.0 layers.append(layer) return layers
def setupLayers( self ): logger.debug( "setupLayers" ) layers = [] def onButtonsEnabled(slot, roi): currObj = self.topLevelOperatorView.CurrentObjectName.value hasSeg = self.topLevelOperatorView.HasSegmentation.value self.labelingDrawerUi.currentObjectLabel.setText(currObj) self.labelingDrawerUi.save.setEnabled(hasSeg) self.topLevelOperatorView.CurrentObjectName.notifyDirty(onButtonsEnabled) self.topLevelOperatorView.HasSegmentation.notifyDirty(onButtonsEnabled) self.topLevelOperatorView.opLabelArray.NonzeroBlocks.notifyDirty(onButtonsEnabled) # Labels labellayer, labelsrc = self.createLabelLayer(direct=True) if labellayer is not None: labellayer._allowToggleVisible = False layers.append(labellayer) # Tell the editor where to draw label data self.editor.setLabelSink(labelsrc) #uncertainty if self._showUncertaintyLayer: uncert = self.topLevelOperatorView.Uncertainty if uncert.ready(): colortable = [] for i in range(256-len(colortable)): r,g,b,a = i,0,0,i colortable.append(QColor(r,g,b,a).rgba()) layer = ColortableLayer(LazyflowSource(uncert), colortable, direct=True) layer.name = "Uncertainty" layer.visible = True layer.opacity = 0.3 layers.append(layer) #segmentation seg = self.topLevelOperatorView.Segmentation #seg = self.topLevelOperatorView.MST.value.segmentation #temp = self._done_lut[self.MST.value.regionVol[sl[1:4]]] if seg.ready(): #source = RelabelingArraySource(seg) #source.setRelabeling(numpy.arange(256, dtype=numpy.uint8)) colortable = [QColor(0,0,0,0).rgba(), QColor(0,0,0,0).rgba(), QColor(0,255,0).rgba()] for i in range(256-len(colortable)): r,g,b = numpy.random.randint(0,255), numpy.random.randint(0,255), numpy.random.randint(0,255) colortable.append(QColor(r,g,b).rgba()) layer = ColortableLayer(LazyflowSource(seg), colortable, direct=True) layer.name = "Segmentation" layer.setToolTip("This layer displays the <i>current</i> segmentation. Simply add foreground and background " \ "labels, then press <i>Segment</i>.") layer.visible = True layer.opacity = 0.3 layers.append(layer) #done done = self.topLevelOperatorView.DoneObjects if done.ready(): colortable = [QColor(0,0,0,0).rgba(), QColor(0,0,255).rgba()] #have to use lazyflow because it provides dirty signals layer = ColortableLayer(LazyflowSource(done), colortable, direct=True) layer.name = "Completed segments (unicolor)" layer.setToolTip("In order to keep track of which objects you have already completed, this layer " \ "shows <b>all completed object</b> in one color (<b>blue</b>). " \ "The reason for only one color is that for finding out which " \ "objects to label next, the identity of already completed objects is unimportant " \ "and destracting.") layer.visible = False layer.opacity = 0.5 layers.append(layer) #done seg doneSeg = self.topLevelOperatorView.DoneSegmentation if doneSeg.ready(): layer = ColortableLayer(LazyflowSource(doneSeg), self._doneSegmentationColortable, direct=True) layer.name = "Completed segments (one color per object)" layer.setToolTip("<html>In order to keep track of which objects you have already completed, this layer " \ "shows <b>all completed object</b>, each with a random color.</html>") layer.visible = False layer.opacity = 0.5 self._doneSegmentationLayer = layer layers.append(layer) #supervoxel sv = self.topLevelOperatorView.Supervoxels if sv.ready(): colortable = [] for i in range(256): r,g,b = numpy.random.randint(0,255), numpy.random.randint(0,255), numpy.random.randint(0,255) colortable.append(QColor(r,g,b).rgba()) layer = ColortableLayer(LazyflowSource(sv), colortable, direct=True) layer.name = "Supervoxels" layer.setToolTip("<html>This layer shows the partitioning of the input image into <b>supervoxels</b>. The carving " \ "algorithm uses these tiny puzzle-piceces to piece together the segmentation of an " \ "object. Sometimes, supervoxels are too large and straddle two distinct objects " \ "(undersegmentation). In this case, it will be impossible to achieve the desired " \ "segmentation. This layer helps you to understand these cases.</html>") layer.visible = False layer.opacity = 1.0 layers.append(layer) #raw data rawSlot = self.topLevelOperatorView.RawData if rawSlot.ready(): raw5D = self.topLevelOperatorView.RawData.value layer = GrayscaleLayer(ArraySource(raw5D), direct=True) #layer = GrayscaleLayer( LazyflowSource(rawSlot) ) layer.visible = True layer.name = 'Raw Data' layer.opacity = 1.0 layers.append(layer) inputSlot = self.topLevelOperatorView.InputData if inputSlot.ready(): layer = GrayscaleLayer( LazyflowSource(inputSlot), direct=True ) layer.name = "Input Data" layer.setToolTip("<html>The data originally loaded into ilastik (unprocessed).</html>") #layer.visible = not rawSlot.ready() layer.visible = True layer.opacity = 1.0 # if the flag window_leveling is set the contrast # of the layer is adjustable layer.window_leveling = True layers.append(layer) if layer.window_leveling: self.labelingDrawerUi.thresToolButton.show() else: self.labelingDrawerUi.thresToolButton.hide() filteredSlot = self.topLevelOperatorView.FilteredInputData if filteredSlot.ready(): layer = GrayscaleLayer( LazyflowSource(filteredSlot) ) layer.name = "Filtered Input" layer.visible = False layer.opacity = 1.0 layers.append(layer) return layers