def test_repaint_after_visible_change(self):
self.model = LayerStackModel()
self.o1 = Layer([])
self.o1.name = "Fancy Layer"
self.o1.opacity = 0.5
self.model.append(self.o1)
self.o2 = Layer([])
self.o2.name = "Some other Layer"
self.o2.opacity = 0.25
self.model.append(self.o2)
self.view = LayerWidget(None, self.model)
self.view.show()
self.view.updateGeometry()
self.w = QWidget()
self.lh = QHBoxLayout(self.w)
self.lh.addWidget(self.view)
self.w.setGeometry(100, 100, 300, 300)
self.w.show()
self.w.raise_()
# Run the test within the GUI event loop
QTimer.singleShot(500, self.impl)
self.app.exec_()
# Were there errors?
assert not TestLayerWidget.errors, "There were GUI errors/failures. See above."
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 testAddingAndRemoving(self):
lsm = LayerStackModel()
self.assertEqual(len(lsm), 0)
lsm.append(self.l1)
self.assertEqual(len(lsm), 1)
self.assertEqual(lsm[0].name, self.l1.name)
lsm.append(self.l2)
self.assertEqual(len(lsm), 2)
self.assertEqual(lsm[0].name, self.l2.name)
self.assertEqual(lsm[1].name, self.l1.name)
lsm.insert(1, self.l3)
self.assertEqual(len(lsm), 3)
self.assertEqual(lsm[0].name, self.l2.name)
self.assertEqual(lsm[1].name, self.l3.name)
self.assertEqual(lsm[2].name, self.l1.name)
lsm.selectRow(0)
lsm.deleteSelected()
self.assertEqual(len(lsm), 2)
self.assertEqual(lsm[0].name, self.l3.name)
self.assertEqual(lsm[1].name, self.l1.name)
lsm.clear()
self.assertEqual(len(lsm), 0)
def testNonEmptyLayerStackModel(self):
lsm = LayerStackModel()
lsm.append(self.layer1)
lsm.append(self.layer2)
lsm.append(self.layer3)
ip = ImagePump(lsm, SliceProjection())
self.assertEqual(len(lsm), 3)
self.assertEqual(len(ip.stackedImageSources), 3)
self.assertEqual(len(ip.syncedSliceSources), 3)
self.assertEqual(len(ip.stackedImageSources.getRegisteredLayers()), 3)
for layer in lsm:
self.assertTrue(ip.stackedImageSources.isRegistered(layer))
lsm.deleteSelected()
self.assertEqual(len(lsm), 2)
self.assertEqual(len(ip.stackedImageSources), 2)
self.assertEqual(len(ip.syncedSliceSources), 2)
self.assertEqual(len(ip.stackedImageSources.getRegisteredLayers()), 2)
for layer in lsm:
self.assertTrue(ip.stackedImageSources.isRegistered(layer))
lsm.clear()
self.assertEqual(len(lsm), 0)
self.assertEqual(len(ip.stackedImageSources), 0)
self.assertEqual(len(ip.syncedSliceSources), 0)
self.assertEqual(len(ip.stackedImageSources.getRegisteredLayers()), 0)
def testStackedImageSourcesProperty(self):
s = ImageScene2D(PositionModel(), (0, 3, 4), preemptive_fetch_number=0)
self.assertEqual(len(s.stackedImageSources), 0)
sims = StackedImageSources(LayerStackModel())
s.stackedImageSources = sims
self.assertEqual(id(s.stackedImageSources), id(sims))
def createWidget(self, parent):
model = LayerStackModel()
o1 = Layer()
o1.name = "Fancy Layer"
o1.opacity = 0.5
model.append(o1)
o2 = Layer()
o2.name = "Some other Layer"
o2.opacity = 0.25
model.append(o2)
o3 = Layer()
o3.name = "Invisible Layer"
o3.opacity = 0.15
o3.visible = False
model.append(o3)
o4 = Layer()
o4.name = "Fancy Layer II"
o4.opacity = 0.95
model.append(o4)
o5 = Layer()
o5.name = "Fancy Layer III"
o5.opacity = 0.65
model.append(o5)
view = LayerWidget(parent, model)
view.updateGeometry()
return view
def __init__(self,
posModel,
along,
preemptive_fetch_number=5,
parent=None,
name="Unnamed Scene",
swapped_default=False):
"""
* preemptive_fetch_number -- number of prefetched slices; 0 turns the feature off
* swapped_default -- whether axes should be swapped by default.
"""
QGraphicsScene.__init__(self, parent=parent)
self._along = along
self._posModel = posModel
# QGraphicsItems can change this if they are in a state that should temporarily forbid brushing
# (For example, when the slice intersection marker is in 'draggable' state.)
self.allow_brushing = True
self._dataShape = (0, 0)
self._dataRectItem = None #A QGraphicsRectItem (or None)
self._offsetX = 0
self._offsetY = 0
self.name = name
self._stackedImageSources = StackedImageSources(LayerStackModel())
self._showTileOutlines = False
# FIXME: We don't show the red 'progress pies' because they look terrible.
# If we could fix their timing, maybe it would be worth it.
self._showTileProgress = False
self._tileProvider = None
self._dirtyIndicator = None
self._prefetching_enabled = False
self._swappedDefault = swapped_default
self.reset()
# BowWave preemptive caching
self.setPreemptiveFetchNumber(preemptive_fetch_number)
self._course = (1, 1) # (along, pos or neg direction)
self._time = self._posModel.time
self._channel = self._posModel.channel
self._posModel.timeChanged.connect(self._onTimeChanged)
self._posModel.channelChanged.connect(self._onChannelChanged)
self._posModel.slicingPositionChanged.connect(
self._onSlicingPositionChanged)
self._allTilesCompleteEvent = threading.Event()
self.dirty = False
# We manually keep track of the tile-wise QGraphicsItems that
# we've added to the scene in this dict, otherwise we would need
# to use O(N) lookups for every tile by calling QGraphicsScene.items()
self.tile_graphicsitems = defaultdict(
set) # [Tile.id] -> set(QGraphicsItems)
def initLayerstackModel(self):
self.layerstack = LayerStackModel()
self.layerWidget.init(self.layerstack)
model = self.layerstack
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 testAddingAndRemovingLayers(self):
lsm = LayerStackModel()
sims = StackedImageSources(lsm)
ims_view = sims.viewImageSources()
self.assertEqual(len(lsm), 0)
self.assertEqual(len(sims), 0)
self.assertEqual(len(ims_view), 0)
lsm.append(self.layer1)
lsm.append(self.layer2)
sims.register(self.layer1, self.ims1)
sims.register(self.layer2, self.ims2)
self.assertEqual(sims.isRegistered(self.layer1), True)
self.assertEqual(sims.isRegistered(self.layer2), True)
self.assertEqual(len(lsm), 2)
self.assertEqual(len(sims), 2)
self.assertEqual(len(ims_view), 2)
self.assertEqual(ims_view[0], self.ims2)
self.assertEqual(ims_view[1], self.ims1)
lsm.append(self.layer3)
self.assertEqual(len(lsm), 3)
self.assertEqual(len(sims), 2)
self.assertEqual(len(ims_view), 2)
self.assertEqual(ims_view[0], self.ims2)
self.assertEqual(ims_view[1], self.ims1)
self.assertEqual(sims.isRegistered(self.layer1), True)
self.assertEqual(sims.isRegistered(self.layer2), True)
lsm.selectRow(1) # layer2
lsm.deleteSelected()
self.assertEqual(len(lsm), 2)
self.assertEqual(len(sims), 1)
self.assertEqual(len(ims_view), 1)
self.assertEqual(ims_view[0], self.ims1)
self.assertEqual(sims.isRegistered(self.layer1), True)
self.assertEqual(sims.isRegistered(self.layer2), False)
lsm.selectRow(0) # layer3
lsm.deleteSelected()
self.assertEqual(len(lsm), 1)
self.assertEqual(len(sims), 1)
self.assertEqual(len(ims_view), 1)
self.assertEqual(ims_view[0], self.ims1)
self.assertEqual(sims.isRegistered(self.layer1), True)
self.assertEqual(sims.isRegistered(self.layer2), False)
sims.deregister(self.layer1)
self.assertEqual(len(lsm), 1)
self.assertEqual(len(sims), 0)
self.assertEqual(len(ims_view), 0)
self.assertEqual(sims.isRegistered(self.layer1), False)
self.assertEqual(sims.isRegistered(self.layer2), False)
def testRegisterAndDeregister(self):
lsm = LayerStackModel()
sims = StackedImageSources(lsm)
self.assertEqual(len(lsm), 0)
self.assertEqual(len(sims), 0)
lsm.append(self.layer1)
lsm.append(self.layer2)
lsm.append(self.layer3)
self.assertEqual(lsm.layerIndex(self.layer1), 2)
self.assertEqual(lsm.layerIndex(self.layer2), 1)
self.assertEqual(lsm.layerIndex(self.layer3), 0)
self.assertEqual(len(lsm), 3)
self.assertEqual(len(sims), 0)
self.assertFalse(sims.isRegistered(self.layer2))
sims.register(self.layer2, self.ims2)
self.assertTrue(sims.isRegistered(self.layer2))
self.assertEqual(len(sims), 1)
self.assertEqual(sims.getImageSource(0), self.ims2)
sims.register(self.layer1, self.ims1)
sims.register(self.layer3, self.ims3)
sims.deregister(self.layer2)
self.assertTrue(sims.isRegistered(self.layer1))
self.assertFalse(sims.isRegistered(self.layer2))
self.assertTrue(sims.isRegistered(self.layer3))
self.assertEqual(len(lsm), 3)
self.assertEqual(len(sims), 2)
self.assertEqual(sims.getImageSource(0), self.ims3)
self.assertEqual(sims.getImageSource(1), self.ims1)
for i, v in enumerate(sims):
if i == 0:
self.assertEqual(len(v), 3)
self.assertEqual(v[0], self.layer3.visible)
self.assertEqual(v[1], self.layer3.opacity)
self.assertEqual(v[2], self.ims3)
elif i == 1:
self.assertEqual(len(v), 3)
self.assertEqual(v[0], self.layer1.visible)
self.assertEqual(v[1], self.layer1.opacity)
self.assertEqual(v[2], self.ims1)
else:
raise Exception("unexpected index")
sims.deregister(self.layer1)
sims.deregister(self.layer3)
self.assertEqual(len(lsm), 3)
self.assertEqual(len(sims), 0)
lsm.clear()
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 testMovingLayers(self):
lsm = LayerStackModel()
lsm.append(self.l1)
lsm.append(self.l2)
lsm.append(self.l3)
lsm.selectRow(1)
self.assertEqual(len(lsm), 3)
self.assertEqual(lsm[0].name, self.l3.name)
self.assertEqual(lsm[1].name, self.l2.name)
self.assertEqual(lsm[2].name, self.l1.name)
self.assertEqual(lsm.selectedRow(), 1)
lsm.moveSelectedDown()
self.assertEqual(lsm.selectedRow(), 2)
self.assertEqual(len(lsm), 3)
self.assertEqual(lsm[0].name, self.l3.name)
self.assertEqual(lsm[1].name, self.l1.name)
self.assertEqual(lsm[2].name, self.l2.name)
lsm.selectRow(1)
lsm.moveSelectedUp()
self.assertEqual(lsm.selectedRow(), 0)
self.assertEqual(len(lsm), 3)
self.assertEqual(lsm[0].name, self.l1.name)
self.assertEqual(lsm[1].name, self.l3.name)
self.assertEqual(lsm[2].name, self.l2.name)
# moving topmost layer up => nothing should happen
lsm.selectRow(0)
self.assertEqual(lsm.selectedRow(), 0)
self.assertEqual(lsm[0].name, self.l1.name)
self.assertEqual(lsm[1].name, self.l3.name)
self.assertEqual(lsm[2].name, self.l2.name)
lsm.moveSelectedUp()
self.assertEqual(lsm.selectedRow(), 0)
self.assertEqual(lsm[0].name, self.l1.name)
self.assertEqual(lsm[1].name, self.l3.name)
self.assertEqual(lsm[2].name, self.l2.name)
# moving bottommost layer down => nothing should happen
lsm.selectRow(2)
self.assertEqual(lsm.selectedRow(), 2)
self.assertEqual(lsm[0].name, self.l1.name)
self.assertEqual(lsm[1].name, self.l3.name)
self.assertEqual(lsm[2].name, self.l2.name)
lsm.moveSelectedDown()
self.assertEqual(lsm.selectedRow(), 2)
self.assertEqual(lsm[0].name, self.l1.name)
self.assertEqual(lsm[1].name, self.l3.name)
self.assertEqual(lsm[2].name, self.l2.name)
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):
self.layerstack = LayerStackModel()
self.sims = StackedImageSources(self.layerstack)
self.GRAY = 201
self.ds = ConstantSource(self.GRAY)
self.layer = GrayscaleLayer(self.ds)
self.layerstack.append(self.layer)
self.ims = imsfac.createImageSource(self.layer, [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 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 __init__(self,
posModel,
along,
preemptive_fetch_number=5,
parent=None,
name="Unnamed Scene",
swapped_default=False):
"""
* preemptive_fetch_number -- number of prefetched slices; 0 turns the feature off
* swapped_default -- whether axes should be swapped by default.
"""
QGraphicsScene.__init__(self, parent=parent)
self._along = along
self._posModel = posModel
self._dataShape = (0, 0)
self._dataRect = None #A QGraphicsRectItem (or None)
self._offsetX = 0
self._offsetY = 0
self.name = name
self._stackedImageSources = StackedImageSources(LayerStackModel())
self._showTileOutlines = False
self._showTileProgress = True
self._tileProvider = None
self._dirtyIndicator = None
self._prefetching_enabled = False
self._swappedDefault = swapped_default
self.reset()
# BowWave preemptive caching
self.setPreemptiveFetchNumber(preemptive_fetch_number)
self._course = (1, 1) # (along, pos or neg direction)
self._time = self._posModel.time
self._channel = self._posModel.channel
self._posModel.timeChanged.connect(self._onTimeChanged)
self._posModel.channelChanged.connect(self._onChannelChanged)
self._posModel.slicingPositionChanged.connect(
self._onSlicingPositionChanged)
self._allTilesCompleteEvent = threading.Event()
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 = SliceSource(self.ds, projectionAlongTZC)
self.layer = GrayscaleLayer(self.ds, normalize=False)
self.layerstack.append(self.layer)
self.ims = imsfac.createImageSource(self.layer, [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 testFirstFullyOpaque(self):
lsm = LayerStackModel()
sims = StackedImageSources(lsm)
self.assertEqual(sims.firstFullyOpaque(), None)
lsm.append(self.layer1)
lsm.append(self.layer2)
lsm.append(self.layer3)
self.assertEqual(lsm.layerIndex(self.layer1), 2)
self.assertEqual(lsm.layerIndex(self.layer2), 1)
self.assertEqual(lsm.layerIndex(self.layer3), 0)
sims.register(self.layer1, self.ims1)
sims.register(self.layer2, self.ims2)
sims.register(self.layer3, self.ims3)
self.assertEqual(sims.firstFullyOpaque(), 0)
lsm.clear()
sims = StackedImageSources(lsm)
lsm.append(self.layer2)
lsm.append(self.layer3)
lsm.append(self.layer1)
self.assertEqual(lsm.layerIndex(self.layer1), 0)
self.assertEqual(lsm.layerIndex(self.layer2), 2)
self.assertEqual(lsm.layerIndex(self.layer3), 1)
sims.register(self.layer1, self.ims1)
sims.register(self.layer2, self.ims2)
sims.register(self.layer3, self.ims3)
self.assertEqual(sims.firstFullyOpaque(), 1)
lsm.clear()
sims = StackedImageSources(lsm)
lsm.append(self.layer2)
lsm.append(self.layer1)
self.assertEqual(lsm.layerIndex(self.layer1), 0)
self.assertEqual(lsm.layerIndex(self.layer2), 1)
sims.register(self.layer1, self.ims1)
sims.register(self.layer2, self.ims2)
self.assertEqual(sims.firstFullyOpaque(), None)
lsm.clear()
def __init__(self, parent=None, model=None):
QListView.__init__(self, parent)
if model is None:
model = LayerStackModel()
self.init(model)
# *******************************************************************************
if __name__ == "__main__":
# make the program quit on Ctrl+C
import signal
signal.signal(signal.SIGINT, signal.SIG_DFL)
import sys, numpy
from PyQt5.QtWidgets import QPushButton, QHBoxLayout, QVBoxLayout
from volumina.pixelpipeline.datasources import ArraySource, ConstantSource
app = QApplication(sys.argv)
model = LayerStackModel()
o1 = Layer([ConstantSource()])
o1.name = "Fancy Layer"
o1.opacity = 0.5
model.append(o1)
o2 = Layer([ConstantSource()])
o2.name = "Some other Layer"
o2.opacity = 0.25
o2.numberOfChannels = 3
model.append(o2)
o3 = Layer([ConstantSource()])
o3.name = "Invisible Layer"
o3.opacity = 0.15
