def _runAll(self):
        for runNr in range(20):
            model = self._buildModel()
            averaged = self.optimizeModel(model)
            c = self.updatePExperts(averaged)
            if c < 0.00001:
                break

        vigra.segShow(imgRgb, self.lastNodeLabels + 1)
        vigra.show()
Esempio n. 2
0
def makeRag(raw, showSeg=False):
    # raw = vigra.gaussianSmoothing(raw,1.0)
    ew = vigra.filters.hessianOfGaussianEigenvalues(-1.0 * raw, 2.3)[:, :, 0]
    seg, nseg = vigra.analysis.watershedsNew(ew)

    # seg, nseg = vigra.analysis.slicSuperpixels(raw,intensityScaling=4.5, seedDistance=20)

    seg = seg.squeeze()
    if showSeg:
        vigra.segShow(raw, seg)
        vigra.show()

    # get the rag
    seg -= 1
    assert seg.min() == 0
    assert seg.max() == nseg - 1
    return nifty.graph.rag.gridRag(seg)
Esempio n. 3
0
def makeRag(raw, showSeg=False):
    #raw = vigra.gaussianSmoothing(raw,1.0)
    ew = vigra.filters.hessianOfGaussianEigenvalues(-1.0 * raw, 2.3)[:, :, 0]
    seg, nseg = vigra.analysis.watershedsNew(ew)

    #seg, nseg = vigra.analysis.slicSuperpixels(raw,intensityScaling=4.5, seedDistance=20)

    seg = seg.squeeze()
    if showSeg:
        vigra.segShow(raw, seg)
        vigra.show()

    # get the rag
    seg -= 1
    assert seg.min() == 0
    assert seg.max() == nseg - 1
    return nifty.graph.rag.gridRag(seg)
    def optimizeModel(self, model):

        if self.gtAsCut is None:
            # generate external proposals
            # ( we should do this only once)
            self.gtAsCut = []
            for gti in range(self.nExperts):
                gt2d = self.gts[:, :, gti].astype('uint64')
                #print gt2d.shape
                gt1d = model.flattenLabels(gt2d)
                #print gt1d
                edgeGt = model.nodeLabelsToEdgeLabels(gt1d)
                self.gtAsCut.append(edgeGt)

        # settings for proposal generator
        settingsProposalGen = agraph.settingsProposalsFusionMovesSubgraphProposals(
            model)
        settingsProposalGen.subgraphRadius = 20

        # settings for solver itself
        settings = agraph.settingsFusionMoves(settingsProposalGen)
        settings.maxNumberOfIterations = 4
        settings.nParallelProposals = 50
        settings.reduceIterations = 0
        settings.seed = 42
        for ep in self.gtAsCut:
            settings.addPropoal(ep)

        # solver
        solver = agraph.fusionMoves(model, settings)

        # solve the damn thing
        out = solver.run()
        nodeLabels = model.edgeLabelsToNodeLabels(out)
        nodeLabels = nodeLabels.astype('uint32')

        nodeLabels = nodeLabels.reshape(shape, order='F')
        nodeLabels = vigra.taggedView(nodeLabels, 'xy')

        self.lastNodeLabels = nodeLabels
        vigra.segShow(imgRgb, nodeLabels + 1)
        vigra.show()

        return out
Esempio n. 5
0
def runLiftedMc(dataDict, settings):

    rawData = dataDict['raw']
    outDir = dataDict['outDir']
    localRfPredictDir = os.path.join(outDir, 'localClfProbs')
    ragsAndSuperpixels = getRagsAndSuperpixels(dataDict, settings)
    liftedFeaturesDir = os.path.join(outDir, 'liftedFeatures')
    liftedProbsDir = os.path.join(outDir, 'liftedProbs')

    ragsAndSuperpixels = getRagsAndSuperpixels(dataDict, settings)

    for sliceIndex in range(rawData.shape[0]):

        # local probs
        predictionFile = os.path.join(
            localRfPredictDir, 'rag_pred_clf%s_%d.h5' % ('0', sliceIndex))
        localProbs = h5Read(predictionFile)[:, 1]

        # lifted probs
        liftedProbsFile = os.path.join(liftedProbsDir,
                                       'lifted_probs_%d.h5' % (sliceIndex))
        liftedProbs = h5Read(liftedProbsFile)

        # set up the lifted objective
        rag, sp = ragsAndSuperpixels[sliceIndex]
        obj = nifty.graph.lifted_multicut.liftedMulticutObjective(rag)
        liftedGraph = obj.liftedGraph
        distance = obj.insertLiftedEdgesBfs(
            5, returnDistance=True).astype('float32')
        liftedUvIds = obj.liftedUvIds()

        # numeric factor to not get to small weights
        # might not be necessary
        C = 100.0

        # local weights
        eps = 0.0001
        clipped = numpy.clip(localProbs, eps, 1.0 - eps)
        beta = settings['betaLocal']
        wLocal = numpy.log((1.0 - clipped) / (clipped)) + numpy.log(
            (1.0 - beta) / (beta))
        # normalize by number of local edges length
        wLocal *= C / len(wLocal)
        wLocal *= settings['gamma']

        # non local weights
        eps = 0.0001
        clipped = numpy.clip(liftedProbs, eps, 1.0 - eps)
        beta = settings['betaLifted']
        wLifted = numpy.log((1.0 - clipped) / (clipped)) + numpy.log(
            (1.0 - beta) / (beta))

        # normalize by the distance (give close one more weight)
        distanceWeight = 1.0 / (distance - 1.0)
        #wLifted *= C/distanceWeight.sum()
        wLifted *= C / len(wLifted)

        print numpy.abs(wLocal).sum(), numpy.abs(wLifted).sum()

        # write the weighs into the objective
        obj.setLiftedEdgesCosts(wLifted, overwrite=True)
        obj.setGraphEdgesCosts(wLocal, overwrite=True)

        # warm start with normal multicut
        mcObj = nifty.graph.multicut.multicutObjective(rag, wLocal)
        solverFactory = mcObj.multicutIlpCplexFactory()
        solver = solverFactory.create(mcObj)
        visitor = mcObj.multicutVerboseVisitor()
        argMc = solver.optimize(visitor)
        emc = obj.evalNodeLabels(argMc)

        # finaly optimize it
        solverFactory = obj.liftedMulticutAndresGreedyAdditiveFactory()
        solver = solverFactory.create(obj)
        visitor = obj.verboseVisitor()
        arg = solver.optimize(visitor)
        eg = obj.evalNodeLabels(arg)

        solverFactory = obj.liftedMulticutAndresKernighanLinFactory()
        solver = solverFactory.create(obj)
        visitor = obj.verboseVisitor()
        arg = solver.optimize(visitor, arg.copy())
        ekl = obj.evalNodeLabels(arg)

        print "e", emc, eg, ekl

        #projectToPixels
        pixelData = nifty.graph.rag.projectScalarNodeDataToPixels(
            rag, arg.astype('uint32'))

        vigra.segShow(rawData[sliceIndex, :, :], pixelData)
        vigra.show()
Esempio n. 6
0
    volume = vigra.impex.readHDF5(*imPath).astype('float32')
    volume = volume[0:1000,0:1000,0:40]
    volume = vigra.taggedView(volume,'xyz')

    if False:
        print "hessianEv2"
        ev = hessianEv2(volume, 2.5)
        print ev.shape, ev.dtype
        ev = vigra.filters.gaussianSmoothing(ev, 2.5)

        vigra.imshow(ev[:,:,0])
        vigra.show()

        print "watershedsNew"
        labels, nseg = vigra.analysis.watershedsNew(ev)
        vigra.segShow(volume[:,:,0], labels[:,:,0])
        vigra.show()

        print "gridGraph"
        gridGraph = graphs.gridGraph(labels.shape)
        rag = graphs.regionAdjacencyGraph(gridGraph, labels)
        rag.writeHDF5("ragb.h5",'data')
    else:
        rag = vigra.graphs.loadGridRagHDF5("ragb.h5",'data')
        labels=rag.labels
print labels.shape, volume.shape




Esempio n. 7
0
#learner = learning.structMaxMarginLearner(dataset, 0.1, 0.001, 0)


learner.learn(infCls=opengm.inference.QpboExternal, 
              parameter=opengm.InfParam())


w = dataset.getWeights()

for wi in range(len(w)):
    print "wi ",w[wi]


# predict on test test
for (rgbImg, sp, gm) in test_set :
    # infer for test image
    inf = opengm.inference.QpboExternal(gm)
    inf.infer()
    arg = inf.arg()+1


    gg  = vigra.graphs.gridGraph(rgbImg.shape[0:2])
    rag = vigra.graphs.regionAdjacencyGraph(gg,sp)

    seg = rag.projectLabelsToBaseGraph(arg.astype('uint32'))

    vigra.segShow(rgbImg, seg+2)
    vigra.show()

Esempio n. 8
0
def runLiftedMc(dataDict, settings):


    rawData = dataDict['raw']
    outDir = dataDict['outDir']
    localRfPredictDir  =  os.path.join(outDir,'localClfProbs')
    ragsAndSuperpixels = getRagsAndSuperpixels(dataDict, settings)
    liftedFeaturesDir  =  os.path.join(outDir,'liftedFeatures')
    liftedProbsDir =  os.path.join(outDir,'liftedProbs')

    ragsAndSuperpixels = getRagsAndSuperpixels(dataDict, settings)

    for sliceIndex  in range(rawData.shape[0]):


        # local probs
        predictionFile = os.path.join(localRfPredictDir,'rag_pred_clf%s_%d.h5'%('0', sliceIndex))
        localProbs = h5Read(predictionFile)[:,1]
    
        # lifted probs
        liftedProbsFile = os.path.join(liftedProbsDir,'lifted_probs_%d.h5'%(sliceIndex))
        liftedProbs = h5Read(liftedProbsFile)

        # set up the lifted objective
        rag, sp = ragsAndSuperpixels[sliceIndex]
        obj = nifty.graph.lifted_multicut.liftedMulticutObjective(rag)
        liftedGraph = obj.liftedGraph
        distance = obj.insertLiftedEdgesBfs(5, returnDistance=True).astype('float32')
        liftedUvIds = obj.liftedUvIds()

        # numeric factor to not get to small weights
        # might not be necessary
        C = 100.0

        # local weights
        eps = 0.0001
        clipped = numpy.clip(localProbs, eps, 1.0-eps)
        beta = settings['betaLocal']
        wLocal = numpy.log((1.0-clipped)/(clipped)) + numpy.log((1.0-beta)/(beta))
        # normalize by number of local edges length
        wLocal *= C/len(wLocal)
        wLocal *= settings['gamma']

        # non local weights
        eps = 0.0001
        clipped = numpy.clip(liftedProbs, eps, 1.0-eps)
        beta = settings['betaLifted']
        wLifted = numpy.log((1.0-clipped)/(clipped)) + numpy.log((1.0-beta)/(beta))
       

        # normalize by the distance (give close one more weight)
        distanceWeight = 1.0 / (distance-1.0)
        #wLifted *= C/distanceWeight.sum()
        wLifted *= C/len(wLifted)

        print numpy.abs(wLocal).sum(), numpy.abs(wLifted).sum()

        # write the weighs into the objective
        obj.setLiftedEdgesCosts(wLifted, overwrite=True)
        obj.setGraphEdgesCosts(wLocal, overwrite=True)
        


        # warm start with normal multicut
        mcObj =  nifty.graph.multicut.multicutObjective(rag, wLocal)
        solverFactory = mcObj.multicutIlpCplexFactory()
        solver = solverFactory.create(mcObj)
        visitor = mcObj.multicutVerboseVisitor()
        argMc = solver.optimize(visitor)
        emc = obj.evalNodeLabels(argMc)


        # finaly optimize it
        solverFactory = obj.liftedMulticutAndresGreedyAdditiveFactory()
        solver = solverFactory.create(obj)
        visitor = obj.verboseVisitor()
        arg = solver.optimize(visitor)
        eg = obj.evalNodeLabels(arg)
        

        solverFactory = obj.liftedMulticutAndresKernighanLinFactory()
        solver = solverFactory.create(obj)
        visitor = obj.verboseVisitor()
        arg = solver.optimize(visitor, arg.copy())
        ekl = obj.evalNodeLabels(arg)

        
        print "e",emc,eg,ekl

        #projectToPixels
        pixelData = nifty.graph.rag.projectScalarNodeDataToPixels(rag, arg.astype('uint32'))
        
        vigra.segShow(rawData[sliceIndex,:,:], pixelData)
        vigra.show()
Esempio n. 9
0
def test_mcgala():

    # get the dataset
    imgs, gts = make_dataset(10, noise=4.5, shape=(200, 200))

    Obj = G.MulticutObjective
    CG = G.EdgeContractionGraph
    CGObj = CG.MulticutObjective

    greedyFactory = Obj.greedyAdditiveFactory()
    ilpFactory = Obj.multicutIlpFactory(
        ilpSolver="cplex",
        addThreeCyclesConstraints=False,
        addOnlyViolatedThreeCyclesConstraints=False
        # memLimit= 0.01
    )
    fmFactoryA = CGObj.fusionMoveBasedFactory(
        # fusionMove=CGObj.fusionMoveSettings(mcFactory=greedyFactory),
        fusionMove=CGObj.fusionMoveSettings(mcFactory=ilpFactory),
        # proposalGen=nifty.greedyAdditiveProposals(sigma=30,nodeNumStopCond=-1,weightStopCond=0.0),
        proposalGen=CGObj.watershedProposals(sigma=1, seedFraction=0.1),
        numberOfIterations=10,
        numberOfParallelProposals=40,  # no effect if nThreads equals 0 or 1
        numberOfThreads=40,
        stopIfNoImprovement=2,
        fuseN=2,
    )

    ragTrain = makeRag(imgs[0], showSeg=True)
    fOpTrain, minVal, maxVal = makeFeatureOp(ragTrain, imgs[0])
    edgeGt = makeEdgeGt(ragTrain, gts[0])

    cOrderSettigns = G.galaContractionOrderSettings(mcMapFactory=fmFactoryA, runMcMapEachNthTime=10)

    # gala class
    settings = G.galaSettings(
        threshold0=0.1,
        threshold1=0.9,
        thresholdU=0.1,
        numberOfEpochs=1,
        numberOfTrees=200,
        contractionOrderSettings=cOrderSettigns
        # mapFactory=fmFactoryA,
        # perturbAndMapFactory=fmFactoryB
    )
    gala = G.gala(settings)

    trainingInstance = ngala.galaTrainingInstance(ragTrain, fOpTrain, edgeGt)
    gala.addTrainingInstance(trainingInstance)
    gala.train()

    for x in range(3, 10):

        ragTest = makeRag(imgs[x], showSeg=False)
        fOpTest, minVal, maxVal = makeFeatureOp(ragTest, imgs[x], minVal, maxVal)
        instance = ngala.galaInstance(ragTest, fOpTest)
        edgeGt = makeEdgeGt(ragTest, gts[x])

        nodeRes = gala.predict(instance)

        pixelNodeRes = nrag.projectScalarNodeDataToPixels(ragTest, nodeRes, -1)
        vigra.segShow(imgs[x], pixelNodeRes)
        vigra.show()
Esempio n. 10
0
if False:
    f = "/media/tbeier/AD9A-CE7E/data_sub.h5"
    hfile = h5py.File(f)
    data = hfile['data'][0:500,0:1000,0:1000].astype('float32')
    #data = 255.0 - data
    data = vigra.taggedView(data, 'xyz')
    with vigra.Timer("ew"):
        opt = vigra.blockwise.convolutionOptions(sigma=1.5, blockShape=(100,100,100))
        ev = vigra.blockwise.hessianOfGaussianEigenvalues(data,opt)[:,:,:,0]
    with vigra.Timer("ws"):
        seg, nseg = vigra.analysis.unionFindWatershed3D(ev, (300,300,300))
        seg = numpy.array(seg-1)
        print(seg.strides)

        vigra.impex.writeHDF5(seg, "/home/tbeier/labels.h5", "data")
        vigra.segShow(data[:,:,0],seg[:,:,0])
        vigra.show()

else:
    with vigra.Timer("read seg"):
        seg = vigra.impex.readHDF5("/home/tbeier/labels.h5", "data")
        print("loaded strides", seg.strides)


with vigra.Timer("rag parallel"):
    gp =  nifty.graph.rag.explicitLabelsGridRag3D(seg,-1)

with vigra.Timer("rag serial"):
    gs =  nifty.graph.rag.explicitLabelsGridRag3D(seg,0)
Esempio n. 11
0
                                          fUnary=fUnary, fBinary=fBinary, 
                                          addConstFeature=False)





learner =  learning.subgradientSSVM(dataset, learningRate=0.05, C=100, 
                                    learningMode='batch',maxIterations=1000)


#learner = learning.structMaxMarginLearner(dataset, 0.1, 0.001, 0)


learner.learn(infCls=opengm.inference.LazyFlipper, 
              parameter=opengm.InfParam(maxSubgraphSize=3))



# predict on test test
for (rgbImg, gtImg, gm) in test_set :
    # infer for test image
    inf = opengm.inference.QpboExternal(gm)
    inf.infer()
    arg = inf.arg()
    arg = arg.reshape( numpy.squeeze(gtImg.shape))

    vigra.segShow(rgbImg, arg+2)
    vigra.show()

Esempio n. 12
0
def test_mcgala():

    # get the dataset
    imgs, gts = make_dataset(10, noise=4.5, shape=(200, 200))

    Obj = G.MulticutObjective
    CG = G.EdgeContractionGraph
    CGObj = CG.MulticutObjective

    greedyFactory = Obj.greedyAdditiveFactory()
    ilpFactory = Obj.multicutIlpFactory(
        ilpSolver='cplex',
        addThreeCyclesConstraints=False,
        addOnlyViolatedThreeCyclesConstraints=False
        #memLimit= 0.01
    )
    fmFactoryA = CGObj.fusionMoveBasedFactory(
        #fusionMove=CGObj.fusionMoveSettings(mcFactory=greedyFactory),
        fusionMove=CGObj.fusionMoveSettings(mcFactory=ilpFactory),
        #proposalGen=nifty.greedyAdditiveProposals(sigma=30,nodeNumStopCond=-1,weightStopCond=0.0),
        proposalGen=CGObj.watershedProposals(sigma=1, seedFraction=0.1),
        numberOfIterations=10,
        numberOfParallelProposals=40,  # no effect if nThreads equals 0 or 1
        numberOfThreads=40,
        stopIfNoImprovement=2,
        fuseN=2,
    )

    ragTrain = makeRag(imgs[0], showSeg=True)
    fOpTrain, minVal, maxVal = makeFeatureOp(ragTrain, imgs[0])
    edgeGt = makeEdgeGt(ragTrain, gts[0])

    cOrderSettigns = G.galaContractionOrderSettings(mcMapFactory=fmFactoryA,
                                                    runMcMapEachNthTime=10)

    # gala class
    settings = G.galaSettings(
        threshold0=0.1,
        threshold1=0.9,
        thresholdU=0.1,
        numberOfEpochs=1,
        numberOfTrees=200,
        contractionOrderSettings=cOrderSettigns
        #mapFactory=fmFactoryA,
        #perturbAndMapFactory=fmFactoryB
    )
    gala = G.gala(settings)

    trainingInstance = ngala.galaTrainingInstance(ragTrain, fOpTrain, edgeGt)
    gala.addTrainingInstance(trainingInstance)
    gala.train()

    for x in range(3, 10):

        ragTest = makeRag(imgs[x], showSeg=False)
        fOpTest, minVal, maxVal = makeFeatureOp(ragTest, imgs[x], minVal,
                                                maxVal)
        instance = ngala.galaInstance(ragTest, fOpTest)
        edgeGt = makeEdgeGt(ragTest, gts[x])

        nodeRes = gala.predict(instance)

        pixelNodeRes = nrag.projectScalarNodeDataToPixels(ragTest, nodeRes, -1)
        vigra.segShow(imgs[x], pixelNodeRes)
        vigra.show()
Esempio n. 13
0
    volume = vigra.impex.readHDF5(*imPath).astype('float32')
    volume = volume[0:1000, 0:1000, 0:40]
    volume = vigra.taggedView(volume, 'xyz')

    if False:
        print "hessianEv2"
        ev = hessianEv2(volume, 2.5)
        print ev.shape, ev.dtype
        ev = vigra.filters.gaussianSmoothing(ev, 2.5)

        vigra.imshow(ev[:, :, 0])
        vigra.show()

        print "watershedsNew"
        labels, nseg = vigra.analysis.watershedsNew(ev)
        vigra.segShow(volume[:, :, 0], labels[:, :, 0])
        vigra.show()

        print "gridGraph"
        gridGraph = graphs.gridGraph(labels.shape)
        rag = graphs.regionAdjacencyGraph(gridGraph, labels)
        rag.writeHDF5("ragb.h5", 'data')
    else:
        rag = vigra.graphs.loadGridRagHDF5("ragb.h5", 'data')
        labels = rag.labels
print labels.shape, volume.shape

app = QtGui.QApplication([])


class DownCtrl(QtGui.QWidget):
Esempio n. 14
0
        segRaw = f['data'][x[0]:x[1], y[0]:y[1], z[0]:z[1]]
        f.close()

        seg = segRaw[xx,:, :]
        mSeg = seg.max()

        colors = numpy.random.rand(3*(mSeg+1)).reshape(mSeg+1,3)*255.0

        fseg  = seg.reshape(-1)

        fcolorseg = colors[fseg,:]
        fcolorseg = fcolorseg.reshape([seg.shape[0], seg.shape[1], 3])

        alpha = 0.5
        segAndRaw  = (1.0 - alpha)*raw + alpha*fcolorseg
        vigra.impex.writeImage(segAndRaw,"for_anna/seg%d.png"%l)



        raw = vigra.taggedView(raw,'xyc')



        niceImg = vigra.segShow(img=raw.astype(numpy.float32).squeeze(),labels=vigra.analysis.labelImage(seg),
            edgeColor=(0.1,0.9,0.2),
            alpha=0.3,
            show=True,
            returnImg=True,
            r=1)
        
        vigra.impex.writeImage(niceImg.astype(numpy.float32),"for_anna/nseg%d.png"%l)
Esempio n. 15
0
    def __init__(self, raw, seg, gt=None, patchSize=[100, 100], **kwargs):

        #raw input data
        self.raw = numpy.squeeze(raw)
        self.seg = numpy.squeeze(seg)
        self.gt = numpy.squeeze(gt)

        # shorthands
        self.shape = self.raw.shape

        # settings
        self.patchSize = patchSize

        # apply paddings
        ps = self.patchSize
        padding = ((ps[0], ps[0]), (ps[1], ps[1]))
        pad = partial(numpy.pad, pad_width=padding)

        self.paddingMask = pad(numpy.zeros(self.shape),
                               mode='constant',
                               constant_values=1)
        self.paddedRaw = pad(self.raw, mode='reflect')
        self.paddedSeg = vigra.analysis.labelImage(
            pad(self.seg, mode='reflect')).squeeze()
        self.paddedGt = None
        if self.gt is not None:
            self.paddedGt = vigra.analysis.labelImage(
                pad(self.gt, mode='reflect')).squeeze()
            #self.paddedGt = pad(self.gt + 1, mode='constant', constant_values=0)

        # compute cgp
        self.tGrid = ncgp.TopologicalGrid2D(self.paddedSeg)
        self.tShape = self.tGrid.topologicalGridShape
        self.numberOfCells = self.tGrid.numberOfCells
        self.fGrid = ncgp.FilledTopologicalGrid2D(self.tGrid)
        self.cellGrids = [
            self.fGrid.cellMask([1, 0, 0]),
            self.fGrid.cellMask([0, 1, 0]), None
        ]
        self.cellGrids[0][
            self.cellGrids[0] != 0] -= self.fGrid.cellTypeOffset[0]
        self.cellGrids[1][
            self.cellGrids[1] != 0] -= self.fGrid.cellTypeOffset[1]

        self.cellMasks = [numpy.clip(x, 0, 1)
                          for x in self.cellGrids[0:2]] + [None]
        rawT = vigra.sampling.resize(self.paddedRaw, self.tShape)
        #rawT[self.cellMasks[1]!=0] = 0

        self.cellsBounds = self.tGrid.extractCellsBounds()
        self.cellsGeometry = self.tGrid.extractCellsGeometry(fill=True)
        self.cells1Bounds = self.cellsBounds[1]
        self.cells1Geometry = self.cellsGeometry[1]

        # center of mass
        self.cell1CentersOfMass = self.cells1Geometry.centersOfMass()

        print(self.cell1CentersOfMass)

        # compute gt
        ol = Overlap(self.numberOfCells[2], self.paddedSeg, self.paddedGt)
        cell1Probs = ol.differentOverlaps(numpy.array(self.cells1Bounds))

        with nifty.Timer("makeCellImage"):
            probImg = ncgp.makeCellImage(rawT, self.cellGrids[1],
                                         cell1Probs * 255.0)

        vigra.imshow(probImg.astype('uint8'), cmap='gist_heat')
        vigra.show()

        if False:
            vigra.imshow(self.paddingMask)
            vigra.show()

            vigra.imshow(self.paddedRaw)
            vigra.show()

            vigra.segShow(self.paddedRaw, self.paddedSeg)
            vigra.show()

            vigra.segShow(self.paddedRaw, self.paddedGt)
            vigra.show()
Esempio n. 16
0
    if i < 1:
        vigra.imshow(gtImg)
        vigra.show()

    img = gtImg + numpy.random.random(shape) * float(noise)
    if i < 1:
        vigra.imshow(img)
        vigra.show()

    sp, nSeg = vigra.analysis.slicSuperpixels(gtImg,
                                              intensityScaling=0.2,
                                              seedDistance=5)
    sp = vigra.analysis.labelImage(sp) - 1

    if i < 1:
        vigra.segShow(img, sp + 1, edgeColor=(1, 0, 0))
        vigra.show()

    gg = vigra.graphs.gridGraph(gtImg.shape[0:2])
    rag = vigra.graphs.regionAdjacencyGraph(gg, sp)

    gt, qtq = rag.projectBaseGraphGt(gtImg)

    #rag.show(img, gt)
    #vigra.show()

    imgs.append(img.astype('float32'))
    gts.append(gt)
    sps.append(sp)

    pbar.update(i)
Esempio n. 17
0
    partial(vigra.filters.gaussianGradientMagnitude, sigma=1.0),
    partial(vigra.filters.gaussianGradientMagnitude, sigma=2.0),
]

dataset, test_set = secondOrderImageDataset(imgs=imgs,
                                            gts=gt,
                                            numberOfLabels=2,
                                            fUnary=fUnary,
                                            fBinary=fBinary,
                                            addConstFeature=False)

learner = learning.subgradientSSVM(dataset,
                                   learningRate=0.1,
                                   C=100,
                                   learningMode='batch',
                                   maxIterations=10)

learner.learn(infCls=opengm.inference.QpboExternal,
              parameter=opengm.InfParam())

# predict on test test
for (rgbImg, gtImg, gm) in test_set:
    # infer for test image
    inf = opengm.inference.QpboExternal(gm)
    inf.infer()
    arg = inf.arg()
    arg = arg.reshape(numpy.squeeze(gtImg.shape))

    vigra.segShow(rgbImg, arg + 2)
    vigra.show()
Esempio n. 18
0
show = False
verbose = 1

img = vigra.readImage('12003.jpg')
shape = img.shape[0:2]

# get a rag
sp, nSeg = vigra.analysis.slicSuperpixels(img,
                                          intensityScaling=100.0,
                                          seedDistance=20)
sp -= 1
gg = vigra.graphs.gridGraph(shape)
rag = vigra.graphs.regionAdjacencyGraph(gg, sp)

# get edge weights
gradMag = vigra.filters.structureTensorEigenvalues(img, 1.0, 1.0)[:, :, 0]
gradMag -= gradMag.min()
gradMag /= gradMag.max()
gridGraphEdgeIndicator = vigra.graphs.edgeFeaturesFromImage(gg, gradMag)

#svigra.imshow(gradMag)
# get region adjacency graph from super-pixel labels
rag = vigra.graphs.regionAdjacencyGraph(gg, sp)
edgeWeights = rag.accumulateEdgeFeatures(gridGraphEdgeIndicator)
# accumulate edge weights from gradient magnitude

vigra.segShow(img, sp)
vigra.show()

allPairsOfShortestPath(rag, weights=edgeWeights)