コード例 #1
0
    def onBtnCreateSaliencyMaskClicked(self, widget):

        ROI_X = 0
        ROI_Y = 76
        ROI_WIDTH = 230
        ROI_HEIGHT = 100

        #ROI_WIDTH = 10

        if self.image != None:

            # Create a saliency map from the current image
            grayImage = np.ndarray((self.image.height, self.image.width),
                                   dtype=np.uint8)
            cv.CvtColor(self.image, grayImage, cv.CV_RGB2GRAY)

            saliencyMap, largeSaliencyMap = self.residualSaliencyFilter.calcSaliencyMap(
                grayImage)
            self.dwgSaliencyDisplay.setImageFromNumpyArray(largeSaliencyMap)

            # Threshold to get blobs
            blobPixels = largeSaliencyMap >= 160
            largeSaliencyMap[blobPixels] = 255
            largeSaliencyMap[blobPixels == False] = 0

            # Label blobs
            largeSaliencyMap, numBlobs = PyBlobLib.labelBlobs(largeSaliencyMap)

            # Find blobs in the region of interest
            testMap = np.copy(largeSaliencyMap)
            testMap[:ROI_Y, :] = 0  # Mask out area above the ROI
            testMap[:, :ROI_X] = 0  # Mask out area to the left of the ROI
            testMap[ROI_Y + ROI_HEIGHT:] = 0  # Mask out area below the ROI
            testMap[:, ROI_X +
                    ROI_WIDTH:] = 0  # Mask out area to the right of the ROI

            biggestBlobIdx = None
            biggestBlobSize = 0

            for blobIdx in range(1, numBlobs + 1):
                if testMap[testMap == blobIdx].size > 0:
                    blobSize = largeSaliencyMap[largeSaliencyMap ==
                                                blobIdx].size
                    if blobSize > biggestBlobSize:
                        biggestBlobSize = blobSize
                        biggestBlobIdx = blobIdx

            # Isolate the largest blob
            if biggestBlobIdx != None:
                biggestBlobPixels = (largeSaliencyMap == biggestBlobIdx)
                print biggestBlobPixels.size
                largeSaliencyMap[biggestBlobPixels] = self.GC_PR_FGD
                largeSaliencyMap[biggestBlobPixels == False] = self.GC_PR_BGD

                # Use the largest blob as the segmentation mask
                self.maskArray = largeSaliencyMap
                self.redrawImageWithMask()
コード例 #2
0
    def onBtnCreateSaliencyMaskClicked(self, widget):

        ROI_X = 0
        ROI_Y = 76
        ROI_WIDTH = 230
        ROI_HEIGHT = 100

        # ROI_WIDTH = 10

        if self.image != None:

            # Create a saliency map from the current image
            grayImage = np.ndarray((self.image.height, self.image.width), dtype=np.uint8)
            cv.CvtColor(self.image, grayImage, cv.CV_RGB2GRAY)

            saliencyMap, largeSaliencyMap = self.residualSaliencyFilter.calcSaliencyMap(grayImage)
            self.dwgSaliencyDisplay.setImageFromNumpyArray(largeSaliencyMap)

            # Threshold to get blobs
            blobPixels = largeSaliencyMap >= 160
            largeSaliencyMap[blobPixels] = 255
            largeSaliencyMap[blobPixels == False] = 0

            # Label blobs
            largeSaliencyMap, numBlobs = PyBlobLib.labelBlobs(largeSaliencyMap)

            # Find blobs in the region of interest
            testMap = np.copy(largeSaliencyMap)
            testMap[:ROI_Y, :] = 0  # Mask out area above the ROI
            testMap[:, :ROI_X] = 0  # Mask out area to the left of the ROI
            testMap[ROI_Y + ROI_HEIGHT :] = 0  # Mask out area below the ROI
            testMap[:, ROI_X + ROI_WIDTH :] = 0  # Mask out area to the right of the ROI

            biggestBlobIdx = None
            biggestBlobSize = 0

            for blobIdx in range(1, numBlobs + 1):
                if testMap[testMap == blobIdx].size > 0:
                    blobSize = largeSaliencyMap[largeSaliencyMap == blobIdx].size
                    if blobSize > biggestBlobSize:
                        biggestBlobSize = blobSize
                        biggestBlobIdx = blobIdx

            # Isolate the largest blob
            if biggestBlobIdx != None:
                biggestBlobPixels = largeSaliencyMap == biggestBlobIdx
                print biggestBlobPixels.size
                largeSaliencyMap[biggestBlobPixels] = self.GC_PR_FGD
                largeSaliencyMap[biggestBlobPixels == False] = self.GC_PR_BGD

                # Use the largest blob as the segmentation mask
                self.maskArray = largeSaliencyMap
                self.redrawImageWithMask()
コード例 #3
0
 def produceSegmentation( self, startFrame, impactMotionImage, 
                             preMotionImages, postMotionImages ):
     
     ROI_X = 0
     ROI_Y = 76
     ROI_WIDTH = 230
     ROI_HEIGHT = 100
     
     blankFrame = np.zeros( ( startFrame.height, startFrame.width ), dtype=np.uint8 )
     
     imageFlowFilter = ImageFlowFilter()    
     
     # Create the accumulator image
     accumulatorArray = np.copy( impactMotionImage ).astype( np.int32 )
         
     # Take maximum values from motion images after the impact but
     # don't add them in to de-emphasise the manipulator
     imageNum = 1
     for postMotionImage in postMotionImages:
         
         print "Aligning post impact image {0}...".format( imageNum )
         imageNum += 1
         
         ( transX, transY, rotationAngle, alignedImage ) = \
             imageFlowFilter.calcImageFlow( impactMotionImage, postMotionImage )
         accumulatorArray = np.maximum( accumulatorArray, alignedImage )
                 
     # Dilate and subtract motion images from before the impact
     imageNum = 1
     for preMotionImage in preMotionImages:
         
         print "Aligning pre impact image {0}...".format( imageNum )
         imageNum += 1
         
         ( transX, transY, rotationAngle, alignedImage ) = \
             imageFlowFilter.calcImageFlow( impactMotionImage, preMotionImage )
             
         cv.Dilate( alignedImage, alignedImage )
         cv.Dilate( alignedImage, alignedImage )
         cv.Dilate( alignedImage, alignedImage )
         accumulatorArray = accumulatorArray - alignedImage
         
     accumulatorImage = np.clip( accumulatorArray, 0, 255 ).astype( np.uint8 )
     
     # Create the segmentation mask from the accumulator image
     startMask = np.copy( accumulatorImage )
     cv.Dilate( startMask, startMask )
     cv.Erode( startMask, startMask )
     cv.Dilate( startMask, startMask )
     cv.Erode( startMask, startMask )
     startMask = scipy.ndimage.filters.gaussian_filter( 
         startMask, 5.0, mode='constant' )
     
     startMask[ startMask > 0 ] = 255
         
     # Find the larget blob in the ROI
     # Label blobs
     startMask, numBlobs = PyBlobLib.labelBlobs( startMask )
     
     # Find blobs in the region of interest
     testMap = np.copy( startMask )
     testMap[ :ROI_Y, : ] = 0       # Mask out area above the ROI
     testMap[ :, :ROI_X ] = 0       # Mask out area to the left of the ROI
     testMap[ ROI_Y+ROI_HEIGHT: ] = 0   # Mask out area below the ROI
     testMap[ :, ROI_X+ROI_WIDTH: ] = 0   # Mask out area to the right of the ROI
 
     biggestBlobIdx = None
     biggestBlobSize = 0
 
     for blobIdx in range( 1, numBlobs + 1 ):
         if testMap[ testMap == blobIdx ].size > 0:
             blobSize = startMask[ startMask == blobIdx ].size
             if blobSize > biggestBlobSize:
                 biggestBlobSize = blobSize
                 biggestBlobIdx = blobIdx
 
     # Isolate the largest blob
     if biggestBlobIdx != None:
         biggestBlobPixels = (startMask == biggestBlobIdx)
         startMask[ biggestBlobPixels ] = 255
         startMask[ biggestBlobPixels == False ] = 0
     else:
         print "No central blob"
         return blankFrame
         
     # Now expand it to get exclusion mask
     exclusionMask = np.copy( startMask )
     for i in range( 10 ):
         cv.Dilate( exclusionMask, exclusionMask )
     cv.Erode( exclusionMask, exclusionMask )
     cv.Erode( exclusionMask, exclusionMask )
     
     #----------------------------------------------------
     
     maskArray = np.copy( startMask )
     possiblyForeground = ( maskArray > 0 ) & ( accumulatorImage > 0 )
     maskArray[ possiblyForeground ] = self.GC_PR_FGD
     maskArray[ possiblyForeground == False ] = self.GC_PR_BGD
     maskArray[ exclusionMask == 0 ] = self.GC_BGD
     
     definiteMask = np.copy( accumulatorImage )
     definiteMask[ possiblyForeground ] = 255
     definiteMask[ possiblyForeground == False ] = 0
     cv.Erode( definiteMask, definiteMask )
     cv.Erode( definiteMask, definiteMask )
     maskArray[ definiteMask == 255 ] = self.GC_FGD
     
     # Now create the working mask and segment the image
     
     workingMask = np.copy( maskArray )
         
     fgModel = cv.CreateMat( 1, 5*13, cv.CV_64FC1 )
     cv.Set( fgModel, 0 )
     bgModel = cv.CreateMat( 1, 5*13, cv.CV_64FC1 )
     cv.Set( bgModel, 0 )
     
     workingImage = np.copy( startFrame )
     cv.GrabCut( workingImage, workingMask, 
         (0,0,0,0), fgModel, bgModel, 6, self.GC_INIT_WITH_MASK )
         
     cv.Set( fgModel, 0 )
     cv.Set( bgModel, 0 )
     bgdPixels = (workingMask != self.GC_PR_FGD) & (workingMask != self.GC_FGD)
     workingMask[ bgdPixels ] = 0
     workingMask[ bgdPixels == False ] = 255
     cv.Erode( workingMask, workingMask )
     bgdPixels = workingMask == 0
     workingMask[ bgdPixels ] = self.GC_PR_BGD
     workingMask[ bgdPixels == False ] = self.GC_PR_FGD
     workingMask[ exclusionMask == 0 ] = self.GC_BGD
     
     cv.GrabCut( workingImage, workingMask, 
         (0,0,0,0), fgModel, bgModel, 6, self.GC_INIT_WITH_MASK )
     
     segmentation = np.copy( startFrame )
     segmentation[ (workingMask != self.GC_PR_FGD) & (workingMask != self.GC_FGD) ] = 0
     
     # Remove everything apart from the biggest blob in the ROI
     graySeg = np.zeros( ( startFrame.height, startFrame.width ), dtype=np.uint8 )
     cv.CvtColor( segmentation, graySeg, cv.CV_RGB2GRAY )
     startMask = np.copy( graySeg )
     startMask[ startMask > 0 ] = 255
         
     # Find the larget blob in the ROI
     
     # Label blobs
     startMask, numBlobs = PyBlobLib.labelBlobs( startMask )
     
     # Find blobs in the region of interest
     testMap = np.copy( startMask )
     testMap[ :ROI_Y, : ] = 0       # Mask out area above the ROI
     testMap[ :, :ROI_X ] = 0       # Mask out area to the left of the ROI
     testMap[ ROI_Y+ROI_HEIGHT: ] = 0   # Mask out area below the ROI
     testMap[ :, ROI_X+ROI_WIDTH: ] = 0   # Mask out area to the right of the ROI
 
     biggestBlobIdx = None
     biggestBlobSize = 0
 
     for blobIdx in range( 1, numBlobs + 1 ):
         if testMap[ testMap == blobIdx ].size > 0:
             blobSize = startMask[ startMask == blobIdx ].size
             if blobSize > biggestBlobSize:
                 biggestBlobSize = blobSize
                 biggestBlobIdx = blobIdx
 
     # Isolate the largest blob
     if biggestBlobIdx != None:
         biggestBlobPixels = (startMask == biggestBlobIdx)
         segmentation[ biggestBlobPixels == False, 0 ] = 255
         segmentation[ biggestBlobPixels == False, 1 ] = 0
         segmentation[ biggestBlobPixels == False, 2 ] = 255
     else:
         print "No central blob after main segmentation"
         return blankFrame
     
     return segmentation
コード例 #4
0
 def updateMaskImage( self ):
     
     USING_OPTICAL_FLOW = False
     ROI_X = 0
     ROI_Y = 76
     ROI_WIDTH = 230
     ROI_HEIGHT = 100
     
     if self.accumulatorImage != None:
         
         # Create the segmentation mask from the accumulator image
         startMask = np.copy( self.accumulatorImage )
         cv.Dilate( startMask, startMask )
         cv.Erode( startMask, startMask )
         cv.Dilate( startMask, startMask )
         cv.Erode( startMask, startMask )
         startMask = scipy.ndimage.filters.gaussian_filter( 
             startMask, 5.0, mode='constant' )
         
         startMask[ startMask > 0 ] = 255
         #cv.Erode( startMask, startMask )
         #cv.Dilate( startMask, startMask )
         
         #if USING_OPTICAL_FLOW:
         #    cv.Erode( startMask, startMask )
         #    cv.Erode( startMask, startMask )
             
         # Find the larget blob in the ROI
         # Label blobs
         startMask, numBlobs = PyBlobLib.labelBlobs( startMask )
         
         # Find blobs in the region of interest
         testMap = np.copy( startMask )
         testMap[ :ROI_Y, : ] = 0       # Mask out area above the ROI
         testMap[ :, :ROI_X ] = 0       # Mask out area to the left of the ROI
         testMap[ ROI_Y+ROI_HEIGHT: ] = 0   # Mask out area below the ROI
         testMap[ :, ROI_X+ROI_WIDTH: ] = 0   # Mask out area to the right of the ROI
     
         biggestBlobIdx = None
         biggestBlobSize = 0
     
         for blobIdx in range( 1, numBlobs + 1 ):
             if testMap[ testMap == blobIdx ].size > 0:
                 blobSize = startMask[ startMask == blobIdx ].size
                 if blobSize > biggestBlobSize:
                     biggestBlobSize = blobSize
                     biggestBlobIdx = blobIdx
     
         # Isolate the largest blob
         if biggestBlobIdx != None:
             biggestBlobPixels = (startMask == biggestBlobIdx)
             startMask[ biggestBlobPixels ] = 255
             startMask[ biggestBlobPixels == False ] = 0
         else:
             print "No central blob"
             self.maskArray = None
             self.dwgMaskImageDisplay.clear()
             
         # Now expand it to get exclusion mask
         self.exclusionMask = np.copy( startMask )
         for i in range( 10 ):
             cv.Dilate( self.exclusionMask, self.exclusionMask )
         cv.Erode( self.exclusionMask, self.exclusionMask )
         cv.Erode( self.exclusionMask, self.exclusionMask )
         
         #----------------------------------------------------
         
         self.maskArray = np.copy( startMask )
         possiblyForeground = ( self.maskArray > 0 ) & ( self.accumulatorImage > 0 )
         self.maskArray[ possiblyForeground ] = self.GC_PR_FGD
         self.maskArray[ possiblyForeground == False ] = self.GC_PR_BGD
         self.maskArray[ self.exclusionMask == 0 ] = self.GC_BGD
         
         self.definiteMask = np.copy( self.accumulatorImage )
         self.definiteMask[ possiblyForeground ] = 255
         self.definiteMask[ possiblyForeground == False ] = 0
         cv.Erode( self.definiteMask, self.definiteMask )
         cv.Erode( self.definiteMask, self.definiteMask )
         self.maskArray[ self.definiteMask == 255 ] = self.GC_FGD
         
         #if not USING_OPTICAL_FLOW:
         #    smallMask = np.copy( startMask )
         #    smallMask[ smallMask > 0 ] = 255
         #    cv.Erode( smallMask, smallMask )
         #    self.maskArray[ smallMask > 0 ] = self.GC_FGD
         
         # Draw the segmentation mask
         composedImage = None
         if "ImpactImage" in self.images.keys() \
             and self.images[ "ImpactImage" ] != None:
             composedImage = np.copy( self.images[ "ImpactImage" ] )
             
         if composedImage == None:
             height = self.accumulatorImage.shape[ 1 ]
             width = self.accumulatorImage.shape[ 0 ]
             composedImage = np.zeros( ( height, width, 3 ), dtype=np.uint8 )
         
         composedImage[ self.maskArray == self.GC_FGD ] = self.FOREGROUND_BRUSH_COLOUR
         composedImage[ self.maskArray == self.GC_PR_FGD ] = self.PROBABLY_FOREGROUND_BRUSH_COLOUR
         composedImage[ self.maskArray == self.GC_BGD ] = self.BACKGROUND_BRUSH_COLOUR
         
         self.dwgMaskImageDisplay.setImageFromNumpyArray( composedImage )
     else:
         
         self.maskArray = None
         self.dwgMaskImageDisplay.clear()
コード例 #5
0
    def updateMaskImage(self):

        USING_OPTICAL_FLOW = False
        ROI_X = 0
        ROI_Y = 76
        ROI_WIDTH = 230
        ROI_HEIGHT = 100

        if self.accumulatorImage != None:

            # Create the segmentation mask from the accumulator image
            startMask = np.copy(self.accumulatorImage)
            cv.Dilate(startMask, startMask)
            cv.Erode(startMask, startMask)
            cv.Dilate(startMask, startMask)
            cv.Erode(startMask, startMask)
            startMask = scipy.ndimage.filters.gaussian_filter(startMask,
                                                              5.0,
                                                              mode='constant')

            startMask[startMask > 0] = 255
            #cv.Erode( startMask, startMask )
            #cv.Dilate( startMask, startMask )

            #if USING_OPTICAL_FLOW:
            #    cv.Erode( startMask, startMask )
            #    cv.Erode( startMask, startMask )

            # Find the larget blob in the ROI
            # Label blobs
            startMask, numBlobs = PyBlobLib.labelBlobs(startMask)

            # Find blobs in the region of interest
            testMap = np.copy(startMask)
            testMap[:ROI_Y, :] = 0  # Mask out area above the ROI
            testMap[:, :ROI_X] = 0  # Mask out area to the left of the ROI
            testMap[ROI_Y + ROI_HEIGHT:] = 0  # Mask out area below the ROI
            testMap[:, ROI_X +
                    ROI_WIDTH:] = 0  # Mask out area to the right of the ROI

            biggestBlobIdx = None
            biggestBlobSize = 0

            for blobIdx in range(1, numBlobs + 1):
                if testMap[testMap == blobIdx].size > 0:
                    blobSize = startMask[startMask == blobIdx].size
                    if blobSize > biggestBlobSize:
                        biggestBlobSize = blobSize
                        biggestBlobIdx = blobIdx

            # Isolate the largest blob
            if biggestBlobIdx != None:
                biggestBlobPixels = (startMask == biggestBlobIdx)
                startMask[biggestBlobPixels] = 255
                startMask[biggestBlobPixels == False] = 0
            else:
                print "No central blob"
                self.maskArray = None
                self.dwgMaskImageDisplay.clear()

            # Now expand it to get exclusion mask
            self.exclusionMask = np.copy(startMask)
            for i in range(10):
                cv.Dilate(self.exclusionMask, self.exclusionMask)
            cv.Erode(self.exclusionMask, self.exclusionMask)
            cv.Erode(self.exclusionMask, self.exclusionMask)

            #----------------------------------------------------

            self.maskArray = np.copy(startMask)
            possiblyForeground = (self.maskArray > 0) & (self.accumulatorImage
                                                         > 0)
            self.maskArray[possiblyForeground] = self.GC_PR_FGD
            self.maskArray[possiblyForeground == False] = self.GC_PR_BGD
            self.maskArray[self.exclusionMask == 0] = self.GC_BGD

            self.definiteMask = np.copy(self.accumulatorImage)
            self.definiteMask[possiblyForeground] = 255
            self.definiteMask[possiblyForeground == False] = 0
            cv.Erode(self.definiteMask, self.definiteMask)
            cv.Erode(self.definiteMask, self.definiteMask)
            self.maskArray[self.definiteMask == 255] = self.GC_FGD

            #if not USING_OPTICAL_FLOW:
            #    smallMask = np.copy( startMask )
            #    smallMask[ smallMask > 0 ] = 255
            #    cv.Erode( smallMask, smallMask )
            #    self.maskArray[ smallMask > 0 ] = self.GC_FGD

            # Draw the segmentation mask
            composedImage = None
            if "ImpactImage" in self.images.keys() \
                and self.images[ "ImpactImage" ] != None:
                composedImage = np.copy(self.images["ImpactImage"])

            if composedImage == None:
                height = self.accumulatorImage.shape[1]
                width = self.accumulatorImage.shape[0]
                composedImage = np.zeros((height, width, 3), dtype=np.uint8)

            composedImage[self.maskArray ==
                          self.GC_FGD] = self.FOREGROUND_BRUSH_COLOUR
            composedImage[self.maskArray == self.
                          GC_PR_FGD] = self.PROBABLY_FOREGROUND_BRUSH_COLOUR
            composedImage[self.maskArray ==
                          self.GC_BGD] = self.BACKGROUND_BRUSH_COLOUR

            self.dwgMaskImageDisplay.setImageFromNumpyArray(composedImage)
        else:

            self.maskArray = None
            self.dwgMaskImageDisplay.clear()