def testOutputCrash(self):
     """
     Bare-minimum test: Just make sure we can request the output without crashing.
     """
     slicing = sl[0:1, 0:5, 6:20, 30:40, 0:1]
     result = self.op.Output[slicing].wait()
     assert result.shape == slicing2shape(slicing)
    def testDeleteLabel2(self):
        """
        Another test to check behavior after deleting an entire label class from the sparse array.
        This one ensures that different blocks have different max label values before the delete occurs.
        """
        op = self.op
        slicing = self.slicing
        data = self.data

        assert op.maxLabel.value == 2
        
        # Choose slicings that do NOT intersect with any of the previous data or with each other
        # The goal is to make sure that the data for each slice ends up in a separate block
        slicing1 = sl[0:1, 60:65, 0:10, 3:7, 0:1]
        slicing2 = sl[0:1, 90:95, 0:90, 3:7, 0:1]

        expectedData = self.data[...]

        labels1 = numpy.ndarray(slicing2shape(slicing1), dtype=numpy.uint8)
        labels1[...] = 1
        op.Input[slicing1] = labels1
        expectedData[slicing1] = labels1

        labels2 = numpy.ndarray(slicing2shape(slicing2), dtype=numpy.uint8)
        labels2[...] = 2
        op.Input[slicing2] = labels2
        expectedData[slicing2] = labels2

        # Sanity check:
        # Does the data contain our new labels?
        assert (op.Output[...].wait() == expectedData).all()
        assert expectedData.max() == 2
        assert op.maxLabel.value == 2

        # Delete label 1
        op.deleteLabel.setValue(1)
        outputData = op.Output[...].wait()

        # Expected: All 1s removed, all 2s converted to 1s
        expectedData = numpy.where(expectedData == 1, 0, expectedData)
        expectedData = numpy.where(expectedData == 2, 1, expectedData)
        assert (outputData[...] == expectedData[...]).all()
        
        assert op.maxLabel.value == expectedData.max() == 1
    def testWithSeeds(self):
        """
        Bare-minimum test: Just make sure we can request the output without crashing.
        """
        seeds = numpy.zeros( self.inputData.shape, dtype=numpy.uint32 )
        self.op.SeedImage.setValue( seeds )

        slicing = sl[0:1, 0:5, 6:20, 30:40, 0:1]
        result = self.op.Output[slicing].wait()

        assert result.shape == slicing2shape(slicing)
    def testEraseAll(self):
        """
        Test behavior when all labels of a particular class are erased.
        Note that this is not the same as deleting a label class, but should have the same effect on the output slots.
        """
        op = self.op
        slicing = self.slicing
        data = self.data

        assert op.maxLabel.value == 2
        
        newSlicing = list(slicing)
        newSlicing[1] = slice(1,2)

        # Add some new labels for a class that hasn't been seen yet (3)        
        threeData = numpy.ndarray(slicing2shape(newSlicing), dtype=numpy.uint8)
        threeData[...] = 3
        op.Input[newSlicing] = threeData        
        expectedData = data[...]
        expectedData[newSlicing] = 3
        
        # Sanity check: Are the new labels in the data?
        assert (op.Output[...].wait() == expectedData).all()
        assert expectedData.max() == 3
        assert op.maxLabel.value == 3

        # Now erase all the 3s
        eraserData = numpy.ones(slicing2shape(newSlicing), dtype=numpy.uint8) * 100
        op.Input[newSlicing] = eraserData        
        expectedData = data[...]
        expectedData[newSlicing] = 0
        
        # The data we erased should be zeros
        assert (op.Output[...].wait() == expectedData).all()
        
        # The maximum label should be reduced, because all the 3s were removed.
        assert expectedData.max() == 2
        assert op.maxLabel.value == 2
    def testWithFullSeeds(self):
        """
        If every pixel is seeded, there's nothing for the watershed to do.
        Output should be a copy of the seeds
        """
        # Random seed data
        seeds = 4 * numpy.random.random( self.inputData.shape )
        seeds = seeds.astype(numpy.uint32)
        seeds += 1
        
        self.op.SeedImage.setValue( seeds )

        slicing = sl[0:1, 0:5, 6:20, 30:40, 0:1]
        result = self.op.Output[slicing].wait()

        assert result.shape == slicing2shape(slicing)
        assert (result == seeds[slicing]).all()
    def setup(self):
        graph = Graph()
        op = OpSparseLabelArray(graph=graph)
        arrayshape = numpy.array([1,10,10,10,1])
        op.inputs["shape"].setValue( arrayshape )
        op.eraser.setValue(100)

        slicing = sl[0:1, 1:5, 2:6, 3:7, 0:1]
        inDataShape = slicing2shape(slicing)
        inputData = ( 3*numpy.random.random(inDataShape) ).astype(numpy.uint8)
        op.Input[slicing] = inputData
        data = numpy.zeros(arrayshape, dtype=numpy.uint8)
        data[slicing] = inputData
        
        self.op = op
        self.slicing = slicing
        self.inData = inputData
        self.data = data
    def setup(self):
        graph = Graph()
        op = OpBlockedSparseLabelArray(graph=graph)
        arrayshape = (1,100,100,10,1)
        op.inputs["shape"].setValue( arrayshape )
        blockshape = (1,10,10,10,1) # Why doesn't this work if blockshape is an ndarray?
        op.inputs["blockShape"].setValue( blockshape )
        op.eraser.setValue(100)

        dummyData = vigra.VigraArray(arrayshape, axistags=vigra.defaultAxistags('txyzc'))
        op.Input.setValue( dummyData )

        slicing = sl[0:1, 1:15, 2:36, 3:7, 0:1]
        inDataShape = slicing2shape(slicing)
        inputData = ( 3*numpy.random.random(inDataShape) ).astype(numpy.uint8)
        op.Input[slicing] = inputData
        data = numpy.zeros(arrayshape, dtype=numpy.uint8)
        data[slicing] = inputData
        
        self.op = op
        self.slicing = slicing
        self.inData = inputData
        self.data = data
Exemple #8
0
 def __getitem__( self, slicing ):
     sl3d = (slicing[1], slicing[2], slicing[3])
     ret = np.zeros(slicing2shape(slicing), dtype=self.dtype)
     ret[0,:,:,:,0] = self.a[tuple(sl3d)]
     return ret