예제 #1
0
 def setup_method(self, method):
     v = _volume()
     self.op = OpDetectMissing(graph=Graph())
     self.op.InputVolume.setValue(v)
     self.op.PatchSize.setValue(64)
     self.op.HaloSize.setValue(0)
     self.op.DetectionMethod.setValue("svm")
     self.op.train(force=True)
예제 #2
0
    def testDetectorOmnipresence(self):
        assert self.op.has(self.op.NHistogramBins.value, method="svm"), "Detector is untrained after call to train()"
        assert not self.op.has(self.op.NHistogramBins.value + 2, method="svm"), "Wrong bin size trained."

        op2 = OpDetectMissing(graph=Graph())
        assert op2.has(self.op.NHistogramBins.value, method="svm"), "Trained detectors are not global"

        self.op.reset()
        assert not self.op.has(self.op.NHistogramBins.value, method="svm"), "Detector not reset."
        assert not op2.has(self.op.NHistogramBins.value, method="svm"), "Detector not reset globally."
예제 #3
0
 def testDetectorOmnipresence(self):
     if not havesklearn:
         raise SkipTest
     assert self.op.has(self.op.NHistogramBins.value, method='svm'), "Detector is untrained after call to train()"
     assert not self.op.has(self.op.NHistogramBins.value+2, method='svm'), "Wrong bin size trained."
     
     op2 = OpDetectMissing(graph=Graph())
     assert op2.has(self.op.NHistogramBins.value, method='svm'), "Trained detectors are not global"
     
     self.op.reset()
     assert not self.op.has(self.op.NHistogramBins.value, method='svm'), "Detector not reset."
     assert not op2.has(self.op.NHistogramBins.value, method='svm'), "Detector not reset globally."
예제 #4
0
 def setUp(self):
     v = _volume()
     self.op = OpDetectMissing(graph=Graph())
     self.op.InputVolume.setValue(v)
     self.op.PatchSize.setValue(64)
     self.op.HaloSize.setValue(0)
     self.op.DetectionMethod.setValue('svm')
     self.op.train(force=True)
예제 #5
0
class TestDetection(unittest.TestCase):
    def setUp(self):
        v = _volume()
        self.op = OpDetectMissing(graph=Graph())
        self.op.InputVolume.setValue(v)
        self.op.PatchSize.setValue(64)
        self.op.HaloSize.setValue(0)
        self.op.DetectionMethod.setValue('svm')
        self.op.train(force=True)

    def testDetectorOmnipresence(self):
        if not havesklearn:
            raise SkipTest
        assert self.op.has(self.op.NHistogramBins.value, method='svm'), "Detector is untrained after call to train()"
        assert not self.op.has(self.op.NHistogramBins.value+2, method='svm'), "Wrong bin size trained."
        
        op2 = OpDetectMissing(graph=Graph())
        assert op2.has(self.op.NHistogramBins.value, method='svm'), "Trained detectors are not global"
        
        self.op.reset()
        assert not self.op.has(self.op.NHistogramBins.value, method='svm'), "Detector not reset."
        assert not op2.has(self.op.NHistogramBins.value, method='svm'), "Detector not reset globally."
        
        
    
    def testDetectorPropagation(self):
        if not havesklearn:
            raise SkipTest
        s = self.op.Detector[:].wait()
        self.op.reset()
        assert not self.op.has(self.op.NHistogramBins.value, method='svm'), "Detector not reset."
        self.op.OverloadDetector.setValue(s)
        assert self.op.has(self.op.NHistogramBins.value, method='svm'), "Detector not loaded."
        
        
    def testClassicDetection(self):
        self.op.DetectionMethod.setValue('classic')
        self.op.PatchSize.setValue(1)
        self.op.HaloSize.setValue(0)
        (v,m,_) = _singleMissingLayer(layer=15, nx=1,ny=1,nz=50,method='linear')
        self.op.InputVolume.setValue(v)
        
        assert_array_equal(self.op.Output[:].wait().view(type=np.ndarray),\
                                m.view(type=np.ndarray),\
                                err_msg="input with single black layer")
                            
                            
    def testSVMDetection(self):
        if not havesklearn:
            raise SkipTest
        self.op.DetectionMethod.setValue('svm')
        self.op.PatchSize.setValue(1)
        self.op.HaloSize.setValue(0)
        (v,m,_) = _singleMissingLayer(layer=15, nx=1,ny=1,nz=50,method='linear')
        self.op.InputVolume.setValue(v)
        
        assert_array_equal(self.op.Output[:].wait().view(type=np.ndarray),\
                                m.view(type=np.ndarray),\
                                err_msg="input with single black layer")


    def testSVMDetectionWithHalo(self):
        nBlack = 15
        if not havesklearn:
            raise SkipTest
        self.op.DetectionMethod.setValue('svm')
        self.op.PatchSize.setValue(5)
        self.op.HaloSize.setValue(2)
        (v,m,_) = _singleMissingLayer(layer=nBlack, nx=10,ny=15,nz=50,method='linear')
        self.op.InputVolume.setValue(v)
        
        assert_array_equal(self.op.Output[:].wait()[...,nBlack].view(type=np.ndarray),\
                                m[...,nBlack].view(type=np.ndarray),\
                                err_msg="input with single black layer")
                            
                            
    def testSVMWithHalo(self):
        if not havesklearn:
            raise SkipTest
        self.op.DetectionMethod.setValue('svm')
        self.op.PatchSize.setValue(2)
        self.op.HaloSize.setValue(1)
        (v,m,_) = _singleMissingLayer(layer=15, nx=4,ny=4,nz=50,method='linear')
        self.op.InputVolume.setValue(v)
        
        assert_array_equal(self.op.Output[:].wait().view(type=np.ndarray),\
                                m.view(type=np.ndarray),\
                                err_msg="input with single black layer")
    
    def testSingleMissingLayer(self):
        (v,m,_) = _singleMissingLayer(layer=15, nx=64,ny=64,nz=50,method='linear')
        self.op.InputVolume.setValue(v)
        
        assert_array_equal(self.op.Output[:].wait().view(type=np.ndarray),\
                                m.view(type=np.ndarray),\
                                err_msg="input with single black layer")
                            
    def testDoubleMissingLayer(self):
        (v,m,_) = _singleMissingLayer(layer=15, nx=64,ny=64,nz=50,method='linear')
        (v2,m2,_) = _singleMissingLayer(layer=35, nx=64,ny=64,nz=50,method='linear')
        m2[np.where(m2==1)] = 2
        self.op.InputVolume.setValue(np.sqrt(v*v2))
        
        assert_array_equal(self.op.Output[:].wait().view(type=np.ndarray)>0,\
                                (m+m2).view(type=np.ndarray)>0,\
                                err_msg="input with two black layers")
                            
                            
    def test4D(self):
        vol = vigra.VigraArray( np.ones((10,64,64,3)), axistags=vigra.defaultAxistags('cxyz') )
        self.op.InputVolume.setValue(vol)
        self.op.Output[:].wait()
                            
    
    def test5D(self):
        vol = vigra.VigraArray( np.ones((15,64,10,3,64)), axistags=vigra.defaultAxistags('cxzty') )
        self.op.InputVolume.setValue(vol)
        self.op.Output[:].wait()
            
    
    def testPersistence(self):
        dumpedString = self.op.dumps()
        self.op.loads(dumpedString)
        
    def testPatchify(self):
        from lazyflow.operators.opDetectMissingData import _patchify as patchify
        
        X = np.vander(np.arange(2,5))
        ''' results in 
        X = array([[ 4,  2,  1],
                   [ 9,  3,  1],
                   [16,  4,  1]])
        '''
        (patches,slices) = patchify(X,1,1)
        
        expected = [np.array([[4,2],[9,3]]), \
                    np.array([[4,2,1],[9,3,1]]), \
                    np.array([[2,1],[3,1]]), \
                    np.array([[4,2],[9,3],[16,4]]), \
                    np.array([[4,2,1],[9,3,1],[16,4,1]]), \
                    np.array([[2,1],[3,1],[4,1]]), \
                    np.array([[9,3],[16,4]]), \
                    np.array([[9,3,1],[16,4,1]]), \
                    np.array([[3,1],[4,1]])]

        expSlices = [(slice(0,1),slice(0,1)), \
                  (slice(0,1), slice(1,2)), \
                  (slice(0,1), slice(2,3)), \
                  (slice(1,2), slice(0,1)), \
                  (slice(1,2), slice(1,2)), \
                  (slice(1,2), slice(2,3)), \
                  (slice(2,3), slice(0,1)), \
                  (slice(2,3), slice(1,2)), \
                  (slice(2,3), slice(2,3))]
                
        for ep, s in zip(expected,expSlices):
            #check if patch is in the result
            has = False
            for i,p in enumerate(patches):
                if np.all(p == ep):
                    has = True
                    # check if slice is ok
                    self.assertEqual(s, slices[i])
            
            assert has, "Mising patch {}".format(ep)
            pass
        
    def testPatchDetection(self):
        vol = vigra.taggedView(np.ones((5,5), dtype=np.uint8)*128, axistags=vigra.defaultAxistags('xy'))
        vol[2:5,2:5] = 0
        expected = np.zeros((5,5))
        expected[3:5,3:5] = 1

        self.op.PatchSize.setValue(2)
        self.op.HaloSize.setValue(1)
        self.op.DetectionMethod.setValue('classic')
        self.op.InputVolume.setValue(vol)

        out = self.op.Output[:].wait()
        
        assert_array_equal(expected[3:5,3:5], out[3:5,3:5])
예제 #6
0
class TestDetection(unittest.TestCase):
    def setup_method(self, method):
        v = _volume()
        self.op = OpDetectMissing(graph=Graph())
        self.op.InputVolume.setValue(v)
        self.op.PatchSize.setValue(64)
        self.op.HaloSize.setValue(0)
        self.op.DetectionMethod.setValue("svm")
        self.op.train(force=True)

    def testDetectorOmnipresence(self):
        if not havesklearn:
            raise SkipTest
        assert self.op.has(self.op.NHistogramBins.value, method="svm"), "Detector is untrained after call to train()"
        assert not self.op.has(self.op.NHistogramBins.value + 2, method="svm"), "Wrong bin size trained."

        op2 = OpDetectMissing(graph=Graph())
        assert op2.has(self.op.NHistogramBins.value, method="svm"), "Trained detectors are not global"

        self.op.reset()
        assert not self.op.has(self.op.NHistogramBins.value, method="svm"), "Detector not reset."
        assert not op2.has(self.op.NHistogramBins.value, method="svm"), "Detector not reset globally."

    def testDetectorPropagation(self):
        if not havesklearn:
            raise SkipTest
        s = self.op.Detector[:].wait()
        self.op.reset()
        assert not self.op.has(self.op.NHistogramBins.value, method="svm"), "Detector not reset."
        self.op.OverloadDetector.setValue(s)
        assert self.op.has(self.op.NHistogramBins.value, method="svm"), "Detector not loaded."

    def testClassicDetection(self):
        self.op.DetectionMethod.setValue("classic")
        self.op.PatchSize.setValue(1)
        self.op.HaloSize.setValue(0)
        (v, m, _) = _singleMissingLayer(layer=15, nx=1, ny=1, nz=50, method="linear")
        self.op.InputVolume.setValue(v)

        assert_array_equal(
            self.op.Output[:].wait().view(type=np.ndarray),
            m.view(type=np.ndarray),
            err_msg="input with single black layer",
        )

    def testSVMDetection(self):
        if not havesklearn:
            raise SkipTest
        self.op.DetectionMethod.setValue("svm")
        self.op.PatchSize.setValue(1)
        self.op.HaloSize.setValue(0)
        (v, m, _) = _singleMissingLayer(layer=15, nx=1, ny=1, nz=50, method="linear")
        self.op.InputVolume.setValue(v)

        assert_array_equal(
            self.op.Output[:].wait().view(type=np.ndarray),
            m.view(type=np.ndarray),
            err_msg="input with single black layer",
        )

    def testSVMDetectionWithHalo(self):
        nBlack = 15
        if not havesklearn:
            raise SkipTest
        self.op.DetectionMethod.setValue("svm")
        self.op.PatchSize.setValue(5)
        self.op.HaloSize.setValue(2)
        (v, m, _) = _singleMissingLayer(layer=nBlack, nx=10, ny=15, nz=50, method="linear")
        self.op.InputVolume.setValue(v)

        assert_array_equal(
            self.op.Output[:].wait()[..., nBlack].view(type=np.ndarray),
            m[..., nBlack].view(type=np.ndarray),
            err_msg="input with single black layer",
        )

    def testSVMWithHalo(self):
        if not havesklearn:
            raise SkipTest
        self.op.DetectionMethod.setValue("svm")
        self.op.PatchSize.setValue(2)
        self.op.HaloSize.setValue(1)
        (v, m, _) = _singleMissingLayer(layer=15, nx=4, ny=4, nz=50, method="linear")
        self.op.InputVolume.setValue(v)

        assert_array_equal(
            self.op.Output[:].wait().view(type=np.ndarray),
            m.view(type=np.ndarray),
            err_msg="input with single black layer",
        )

    def testSingleMissingLayer(self):
        (v, m, _) = _singleMissingLayer(layer=15, nx=64, ny=64, nz=50, method="linear")
        self.op.InputVolume.setValue(v)

        assert_array_equal(
            self.op.Output[:].wait().view(type=np.ndarray),
            m.view(type=np.ndarray),
            err_msg="input with single black layer",
        )

    def testDoubleMissingLayer(self):
        (v, m, _) = _singleMissingLayer(layer=15, nx=64, ny=64, nz=50, method="linear")
        (v2, m2, _) = _singleMissingLayer(layer=35, nx=64, ny=64, nz=50, method="linear")
        m2[np.where(m2 == 1)] = 2
        self.op.InputVolume.setValue(np.sqrt(v * v2))

        assert_array_equal(
            self.op.Output[:].wait().view(type=np.ndarray) > 0,
            (m + m2).view(type=np.ndarray) > 0,
            err_msg="input with two black layers",
        )

    def test4D(self):
        vol = vigra.VigraArray(np.ones((10, 64, 64, 3)), axistags=vigra.defaultAxistags("cxyz"))
        self.op.InputVolume.setValue(vol)
        self.op.Output[:].wait()

    def test5D(self):
        vol = vigra.VigraArray(np.ones((15, 64, 10, 3, 64)), axistags=vigra.defaultAxistags("cxzty"))
        self.op.InputVolume.setValue(vol)
        self.op.Output[:].wait()

    def testPersistence(self):
        dumpedString = self.op.dumps()
        self.op.loads(dumpedString)

    def testPatchify(self):
        from lazyflow.operators.opDetectMissingData import _patchify as patchify

        X = np.vander(np.arange(2, 5))
        """ results in
        X = array([[ 4,  2,  1],
                   [ 9,  3,  1],
                   [16,  4,  1]])
        """
        (patches, slices) = patchify(X, 1, 1)

        expected = [
            np.array([[4, 2], [9, 3]]),
            np.array([[4, 2, 1], [9, 3, 1]]),
            np.array([[2, 1], [3, 1]]),
            np.array([[4, 2], [9, 3], [16, 4]]),
            np.array([[4, 2, 1], [9, 3, 1], [16, 4, 1]]),
            np.array([[2, 1], [3, 1], [4, 1]]),
            np.array([[9, 3], [16, 4]]),
            np.array([[9, 3, 1], [16, 4, 1]]),
            np.array([[3, 1], [4, 1]]),
        ]

        expSlices = [
            (slice(0, 1), slice(0, 1)),
            (slice(0, 1), slice(1, 2)),
            (slice(0, 1), slice(2, 3)),
            (slice(1, 2), slice(0, 1)),
            (slice(1, 2), slice(1, 2)),
            (slice(1, 2), slice(2, 3)),
            (slice(2, 3), slice(0, 1)),
            (slice(2, 3), slice(1, 2)),
            (slice(2, 3), slice(2, 3)),
        ]

        for ep, s in zip(expected, expSlices):
            # check if patch is in the result
            has = False
            for i, p in enumerate(patches):
                if np.array_equal(p, ep):
                    has = True
                    # check if slice is ok
                    self.assertEqual(s, slices[i])

            assert has, "Mising patch {}".format(ep)
            pass

    def testPatchDetection(self):
        vol = vigra.taggedView(np.ones((5, 5), dtype=np.uint8) * 128, axistags=vigra.defaultAxistags("xy"))
        vol[2:5, 2:5] = 0
        expected = np.zeros((5, 5))
        expected[3:5, 3:5] = 1

        self.op.PatchSize.setValue(2)
        self.op.HaloSize.setValue(1)
        self.op.DetectionMethod.setValue("classic")
        self.op.InputVolume.setValue(vol)

        out = self.op.Output[:].wait()

        assert_array_equal(expected[3:5, 3:5], out[3:5, 3:5])