Пример #1
0
    def process_image(self, im):
        """

        :param im:
        :return: :raise TypeError:
        """
        if not isinstance(im, Image):
            raise TypeError("Must be a valid Image (package.image) object")

        if im.colorspace != self._colorspace:
            raise AttributeError("Image must be in BGR color space")

        # if app.DB:
        # try:
        #         mask = app.DB[self.dbname(im.imgname)]
        #         # print("returning mask for " + imgname + " [0][0:5]: " + str(mask[4][10:25]))
        #         return mask
        #     except FileNotFoundError:
        #         # Not in DataBase, continue calculating
        #         pass

        bgdmodel = np.zeros((1, 65), np.float64)
        fgdmodel = np.zeros((1, 65), np.float64)
        mask = self._mask.copy()
        # mask = copy.copy(self._mask)
        cv2.grabCut(im, mask, None, bgdmodel, fgdmodel, self._iter_count, cv2.GC_INIT_WITH_MASK)

        mask = np.where((mask == 2) | (mask == 0), 0, 1).astype('uint8')

        # if app.DB:
        #     app.DB[self.dbname(im.imgname)] = mask

        return mask
Пример #2
0
def findObject(img):
	"""Find object within image

	Input:
		-img: input image object

	Output: 
		-mask: mask containing object
		-contours: contours outlining mask
		-hierarchy: hierarchy of contours
	"""
	mask = np.zeros(img.shape[:2],np.uint8)	
	bgdModel = np.zeros((1,65),np.float64)
	fgdModel = np.zeros((1,65),np.float64)
	
	#Cut out object (this is quite slow)
	rect = (0,0,1023,833)
	cv2.grabCut(img,mask,rect,bgdModel,fgdModel,5,cv2.GC_INIT_WITH_RECT)	
	mask2 = np.where((mask==2)|(mask==0),0,1).astype('uint8')

	#Instead just set a threshold on intensity

	#Mask out background
	img = img*mask2[:,:,np.newaxis]
	
	im2, contours, hierarchy = cv2.findContours(mask2.copy(),cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)	
	#cv2.drawContours(img, contours, -1, (0,255,0), 3)
	#plt.imshow(img),plt.colorbar(),plt.show()
	return (mask2, contours, hierarchy)
def process_scan_leaf(scan_leaf_path, output_folder):
    leaf_picture_name = os.path.split(scan_leaf_path)[-1]

    image = cv2.imread(scan_leaf_path)
    grey_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    grey_image = cv2.GaussianBlur(grey_image, (5, 5), 3)
    ret, threshold = cv2.threshold(grey_image, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)

    contours, hierarchy = cv2.findContours(threshold, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_NONE)

    height, width, depth = image.shape

    if len(contours) <= 50:
        image = cv2.bitwise_and(image, image, mask=threshold)
        print "[leafscan] " + leaf_picture_name + ' a fost procesata de leaf scan simplu'

    else:
        rect = (10, 10, width - 21, height - 21)
        mask = np.zeros(image.shape[:2], np.uint8)
        bgd_model = np.zeros((1, 65), np.float64)
        fgd_model = np.zeros((1, 65), np.float64)
        cv2.grabCut(image, mask, rect, bgd_model, fgd_model, 5, cv2.GC_INIT_WITH_RECT)
        mask2 = np.where((mask == 2) | (mask == 0), 0, 1).astype('uint8')
        image = image * mask2[:, :, np.newaxis]
        print "[leafscan] " + leaf_picture_name + ' a fost procesata de leaf scan complex'

    image = crop_image(image, height, width)
    cv2.imwrite(os.path.join(output_folder, leaf_picture_name), image)
Пример #4
0
 def execute(self, image):
     gray = cv2.cvtColor(image, cv.CV_BGR2GRAY)
     cv2.equalizeHist(gray, gray)
     faces = self.face_cascade.detectMultiScale(gray,
                                                1.1,
                                                2,
                                                0 | cv.CV_HAAR_SCALE_IMAGE,
                                                (30, 30))
     for face in faces:
         faceimg = self.get_face(image, face)
         mask = np.zeros(
             (image.shape[0],
              image.shape[1],
              1),
             dtype=np.uint8)
         rect = (face[0], face[1], face[0] + face[2], face[1] + face[3])
         bgd_model = np.zeros((1, 5 * 13))
         fgd_model = np.zeros((1, 5 * 13))
         cv2.grabCut(
             image,
             mask,
             rect,
             bgd_model,
             fgd_model,
             10,
             mode=cv2.GC_INIT_WITH_RECT)
         b, g, r = cv2.split(image)
         b[mask == cv2.GC_BGD] = 255
         g[mask == cv2.GC_BGD] = 255
         r[mask == cv2.GC_BGD] = 255
Пример #5
0
def grabcuthm(im, hm):
    size = hm.shape

    bright = np.amax(hm)

    ret,fgd = cv2.threshold(hm, FGD_BOUND * bright, 1 * bright, cv2.THRESH_BINARY)
    fgd[1:size[0]/2] = 0
    fgd[1:size[0], 1:size[1]/4] = 0
    fgd[1:size[0], size[1]*3/4:size[1]] = 0

    ret,pr_fgd = cv2.threshold(hm, FGD_BGD_SEP * bright, 1 * bright, cv2.THRESH_BINARY)
    pr_fgd -= fgd

    ret, bgd = cv2.threshold(hm, BGD_BOUND * bright, 1 * bright, cv2.THRESH_BINARY_INV)
    bgd[size[0]/3:size[0]] = 0

    ret,pr_bgd = cv2.threshold(hm, FGD_BGD_SEP * bright, 1 * bright, cv2.THRESH_BINARY_INV)
    pr_bgd -= bgd

    mask = cv2.GC_BGD * bgd + cv2.GC_FGD * fgd + cv2.GC_PR_BGD * pr_bgd + cv2.GC_PR_FGD * pr_fgd
    mask = mask.astype(np.uint8, copy=False)

    bgdModel = np.zeros((1,65),np.float64)
    fgdModel = np.zeros((1,65),np.float64)

    rect = (0, im.shape[:2][0]/2, im.shape[:2][1], im.shape[:2][0])

    cv2.grabCut(im, mask, rect, bgdModel, fgdModel, 5, cv2.GC_INIT_WITH_MASK)
    mask2 = np.where((mask==2)|(mask==0),0,1).astype('uint8')

    return mask2
Пример #6
0
def grabcut(rgb_chip):
    (h, w) = rgb_chip.shape[0:2]
    _mask = np.zeros((h, w), dtype=np.uint8)  # Initialize: mask
    # Set inside to cv2.GC_PR_FGD (probably forground)
    _mask[ :, :] = cv2.GC_PR_FGD
    # Set border to cv2.GC_BGD (definitely background)
    _mask[ 0, :] = cv2.GC_BGD
    _mask[-1, :] = cv2.GC_BGD
    _mask[:,  0] = cv2.GC_BGD
    _mask[:, -1] = cv2.GC_BGD
    # Grab Cut Parameters
    rect = (0, 0, w, h)
    num_iters = 5
    mode = cv2.GC_INIT_WITH_MASK
    bgd_model = np.zeros((1, 13 * 5), np.float64)
    fgd_model = np.zeros((1, 13 * 5), np.float64)
    # Grab Cut Execution
    cv2.grabCut(rgb_chip, _mask, rect, bgd_model, fgd_model, num_iters, mode=mode)
    is_forground = (_mask == cv2.GC_FGD) + (_mask == cv2.GC_PR_FGD)
    chip_mask = np.where(is_forground, 255, 0).astype('uint8')
    # Crop
    chip_mask = clean_mask(chip_mask)
    chip_mask = np.array(chip_mask, np.float) / 255.0
    # Mask value component of HSV space
    chip_hsv = cv2.cvtColor(rgb_chip, cv2.COLOR_RGB2HSV)
    chip_hsv = np.array(chip_hsv, dtype=np.float) / 255.0
    chip_hsv[:, :, 2] *= chip_mask
    chip_hsv = np.array(np.round(chip_hsv * 255.0), dtype=np.uint8)
    seg_chip = cv2.cvtColor(chip_hsv, cv2.COLOR_HSV2RGB)
    return seg_chip
def get_foreground(img):
    """Divide the foreground && background of the given image"""
    h, w = img.shape[:2]
    rectangle = (1, 1, w, h)
    result = np.zeros(shape=(h, w), dtype=np.uint8)
    bgModel = np.zeros((1, 13 * 5))
    fgModel = np.zeros((1, 13 * 5))
    cv.grabCut(img, result, rectangle, bgModel, fgModel, 5, cv.GC_INIT_WITH_RECT)
    #cv.imshow("test", result)
    #cv.waitKey(100)
    temp1 = np.array(cv.GC_PR_FGD, dtype=np.uint8)
    result2 = cv.compare(result, temp1, cv.CMP_EQ)
    cv.imshow("test", result2)
    cv.waitKey(2000)
    #print result2
    x, y = img.shape[:2]
    background = np.ones(shape=(x, y, 3), dtype=np.uint8)
    #background *= 255
    foreground = np.ones(shape=(x, y, 3), dtype=np.uint8)
    #foreground *= 255
    for i in range(0, x):
        for j in range(0, y):
            if (result2[i, j].all() == 0):
                background[i, j] = img[i, j]
            else:
                foreground[i, j] = img[i, j]
    #print background
    cv.imshow("test", foreground)
    cv.waitKey(2000)
    cv.imshow("test1", background)
    cv.waitKey(2000)
    cv.imwrite("prueba.png", foreground)
    return foreground
Пример #8
0
def test_3():
    import urllib2
    import io

    url = "http://i.gzdmc.net/images/bd2888edd41a951de1ab8cbfb33c82e2.jpg@1e_400w_400h_1c_0i_1o_90Q_1x.png"
    res = urllib2.urlopen(url)
    # save data into Bytes
    imimage = io.BytesIO(res.read())

    nparr = np.fromstring(imimage.read(), np.uint8)
    img = cv2.imdecode(nparr, cv2.CV_LOAD_IMAGE_COLOR)
    print dir(img)
    height, width, channels = img.shape
    print height
    print width
    print channels
    # img = cv2.imread()
    mask = np.zeros(img.shape[:2], np.uint8)

    bgdModel = np.zeros((1, 65), np.float64)
    fgdModel = np.zeros((1, 65), np.float64)

    rect = (0, 0, height - 1, width - 1)
    cv2.grabCut(img, mask, rect, bgdModel, fgdModel, 5, cv2.GC_INIT_WITH_RECT)
    mask2 = np.where((mask == 2) | (mask == 0), 0, 1).astype("uint8")
    img = img * mask2[:, :, np.newaxis]

    plt.imshow(img), plt.colorbar(), plt.show()
Пример #9
0
def grabcut(img, targetness):
    u"""
    Segmenting the best target-like region from an targetness map.
    """

    mask = np.ones(img.shape[:2], np.uint8) * cv2.GC_BGD
    score_th = scoreatpercentile(targetness, 95)
    mask[targetness >= score_th] = cv2.GC_PR_FGD
    score_th = scoreatpercentile(targetness, 99)
    mask[targetness >= score_th] = cv2.GC_FGD
    mask = cv2.medianBlur(mask, 15)

    bgdModel = np.zeros((1, 65), np.float64)
    fgdModel = np.zeros((1, 65), np.float64)

    cv2.grabCut(img, mask, None, bgdModel, fgdModel, 5, cv2.GC_INIT_WITH_MASK)

    mask2 = np.where((mask == 2) | (mask == 0), 0, 1).astype('uint8')
    lab_mask2 = bwlabel(mask2)
    lab_list = np.unique(lab_mask2.flatten())[1:]
    lab_argmax = np.argmax(
        [np.max(targetness[lab_mask2 == i]) for i in lab_list])
    mask2[lab_mask2 != lab_list[lab_argmax]] = 0
    img2 = img.copy()
    img2[mask2 < 1, :] = [0, 43, 54]
    img2 = mark_boundaries(img2, mask2)

    return img2, mask2
Пример #10
0
def grabcut(bgr_img, prior_mask, binary=True):
    """
    Referencs:
        http://docs.opencv.org/trunk/doc/py_tutorials/py_imgproc/py_grabcut/py_grabcut.html
    """
    # Grab Cut Parameters
    (h, w) = bgr_img.shape[0:2]
    rect = (0, 0, w, h)
    num_iters = 5
    mode = cv2.GC_INIT_WITH_MASK
    bgd_model = np.zeros((1, 13 * 5), np.float64)
    fgd_model = np.zeros((1, 13 * 5), np.float64)
    # Grab Cut Execution
    post_mask = prior_mask.copy()
    cv2.grabCut(bgr_img, post_mask, rect, bgd_model, fgd_model, num_iters, mode=mode)
    if binary:
        is_forground = (post_mask == cv2.GC_FGD) + (post_mask == cv2.GC_PR_FGD)
        post_mask = np.where(is_forground, 255, 0).astype('uint8')
    else:
        label_colors = [       255,           170,            50,          0]
        label_values = [cv2.GC_FGD, cv2.GC_PR_FGD, cv2.GC_PR_BGD, cv2.GC_BGD]
        pos_list = [post_mask == value for value in label_values]
        for pos, color in zip(pos_list, label_colors):
            post_mask[pos] = color
    return post_mask
Пример #11
0
def grabcut_components(image, mask, num_components=1):
    h, w, _ = image.shape
    kernel_size = h / 100
    kernel = np.ones((kernel_size, kernel_size), np.uint8)

    foreground = cv2.erode(mask, kernel, iterations=1)
    foreground = largest_components(foreground, num_components)

    background = cv2.dilate(mask, kernel, iterations=1)

    mask = cv2.GC_PR_FGD*np.ones((h, w), dtype='uint8')
    mask[np.where(foreground > 0)] = cv2.GC_FGD
    mask[np.where(background < 255)] = cv2.GC_BGD

    backgroundModel = np.zeros((1, 65), np.float64)
    foregroundModel = np.zeros((1, 65), np.float64)

    cv2.grabCut(image, mask, rect=None, bgdModel=backgroundModel, fgdModel=foregroundModel, iterCount=10, mode=cv2.GC_INIT_WITH_MASK)

    mask = np.where((mask == 2) | (mask == 0), 0, 1).astype('uint8')

    mask_holes_removed = largest_components(mask, 
                                            num_components=1, 
                                            output_bounding_box=False)

    segmented_image = image * (mask_holes_removed[:, :, np.newaxis] / 255)
    return segmented_image, mask_holes_removed * 255
Пример #12
0
def remove_background(imgo) :

	#Load the Image
	height, width = imgo.shape[:2]

	#Create a mask holder
	mask = np.zeros(imgo.shape[:2],np.uint8)

	#Grab Cut the object
	bgdModel = np.zeros((1,65),np.float64)
	fgdModel = np.zeros((1,65),np.float64)

	#Hard Coding the Rect The object must lie within this rect.
	rect = (10,10,width-30,height-30)
	cv2.grabCut(imgo,mask,rect,bgdModel,fgdModel,5,cv2.GC_INIT_WITH_RECT)
	mask = np.where((mask==2)|(mask==0),0,1).astype('uint8')
	img1 = imgo*mask[:,:,np.newaxis]

	#Get the background
	background = imgo - img1

	#Change all pixels in the background that are not black to white
	background[np.where((background > [0,0,0]).all(axis = 2))] = [255,255,255]

	#Add the background and the image
	final = background + img1
	gray_pic = cv2.cvtColor(final, cv2.COLOR_BGR2GRAY)
	imghls = cv2.cvtColor(final, cv2.COLOR_BGR2HLS)

	return final, gray_pic, imghls
Пример #13
0
def grabcut(img, iters=5, roi=None, margin=5):
    """Wrapper for OpenCV's grabCut function.

    Runs the GrabCut algorithm for segmentation. Returns an 8-bit
    single-channel mask. Its elements may have the following values:

    * ``cv2.GC_BGD`` defines an obvious background pixel
    * ``cv2.GC_FGD`` defines an obvious foreground pixel
    * ``cv2.GC_PR_BGD`` defines a possible background pixel
    * ``cv2.GC_PR_FGD`` defines a possible foreground pixel

    The GrabCut algorithm is executed with `iters` iterations. The region
    of interest `roi` can be a 4-tuple ``(x,y,width,height)``. If the ROI
    is not set, the ROI is set to the entire image, with a margin of
    `margin` pixels from the borders.

    This method is indirectly executed by :meth:`make`.
    """
    mask = np.zeros(img.shape[:2], np.uint8)
    bgdmodel = np.zeros((1,65), np.float64)
    fgdmodel = np.zeros((1,65), np.float64)

    # Use the margin to set the ROI if the ROI was not provided.
    if not roi:
        roi = (margin, margin, img.shape[1]-margin*2, img.shape[0]-margin*2)

    cv2.grabCut(img, mask, roi, bgdmodel, fgdmodel, iters, cv2.GC_INIT_WITH_RECT)
    return mask
Пример #14
0
def fave_avg_glv(path):
    global face_cascade

    img = cv2.imread(path)
    height,width = img.shape[:2]

    mask = np.zeros(img.shape[:2], np.uint8)

    bgdModel = np.zeros((1,65), np.float64)
    fgdModel = np.zeros((1,65), np.float64)
    faces = face_cascade.detectMultiScale(img, 1.3, 5)
    if len(faces) > 1:
        face = [f for f in faces if f[2]>width/4 and f[3]>height/3]
    if len(faces) == 1:
        for (x,y,w,h) in faces:
            rect = (x,y,w,h)
    else:
        rect = (int(width*0.3),int(height*0.2),int(width*0.7),int(height*0.8))

    cv2.grabCut(img, mask, rect, bgdModel, fgdModel,5, cv2.GC_INIT_WITH_RECT)

    mask2 = np.where((mask==2)|(mask==0),0,1).astype('uint8')
    img = img*mask2[:,:,np.newaxis]
    
    (_, img) = cv2.threshold(img, 50, 255, cv2.THRESH_TOZERO)

    img = np.ma.masked_equal(img,0)

    return img.mean()
Пример #15
0
    def segment(self):
        print 'Keys:'
        print '\tPress "space" to skip the current image'
        print '\tPress "q" to quit and save your previous segmentations'
        print '\tPress w to run segmentation on the image'
        key = self.wait_for_key(' qnw')
        if key in [' ', 'q']:
            self.out_mask = None
            self.mask = None
            self.brush_size_change = None
            return None, key

        self.done_drawing = True

        bgdModel = np.zeros((1, 65), np.float64)
        fgdModel = np.zeros((1, 65), np.float64)

        out_mask = np.copy(self.mask)

        if out_mask[out_mask == 1].size == 0:
            out_mask = np.zeros(shape=image.shape[:2], dtype=np.uint8)
        else:
            cv2.grabCut(
                self.image,
                out_mask,
                None,
                bgdModel,
                fgdModel,
                1,
                cv2.GC_INIT_WITH_MASK
            )

        return_mask = np.zeros(out_mask.shape).astype(np.float64)
        display_mask = np.ones(out_mask.shape).astype(np.float64) * 0.1
        bgnd = (out_mask == cv2.GC_PR_BGD) | (out_mask == cv2.GC_BGD)

        ctr = self.get_biggest_ctr(np.logical_not(bgnd).astype(np.uint8))

        if ctr is not None:
            cv2.drawContours(display_mask, [ctr], -1, 1, -1)
            cv2.drawContours(return_mask, [ctr], -1, 1, -1)

        self.out_mask = out_mask
        display = display_mask[:, :, np.newaxis] * self.image.astype(np.float64)
        cv2.imshow('segment', display / np.max(display))

        cv2.imshow('all', np.logical_not(bgnd).astype(np.uint8) * 255)
        print 'Keys:'
        print '\tPress "space" to skip the current segmentation'
        print '\tPress "q" to quit and save all segmentations including this'
        print '\tPress w record this segmentation and move on to the next image'

        key = self.wait_for_key('qnzw ')
        if key in [' ', 'q']:
            self.out_mask = None
            self.mask = None
            self.brush_size_change = None
            return None, key

        return return_mask, key
Пример #16
0
	def refine(self):
		fg_mask = np.where((self.mask == self.FG) + (self.mask == self.PR_FG), 255, 0).astype('uint8')
		# Get rid of noise using morphological opening
		_, fg_mask = self.morph_open(fg_mask, 3, 3, 3)
		# Refine foreground/background mask
		eroded, opened = self.morph_open(fg_mask, 3, 8, 15)
		if DEBUG == 1:
			cv2.imshow('Eroded', eroded)
			cv2.imshow('Opened', opened)
			cv2.waitKey()
		has_fg = False
		for i in xrange(self.out_img.shape[0]):
			for j in xrange(self.out_img.shape[1]):
				if eroded[i, j] == 255:
					self.mask[i, j] = self.FG
					has_fg = True
				elif opened[i, j] == 255:
					self.mask[i, j] = self.PR_BG
				else:
					self.mask[i, j] = self.BG
		# Terminate if we haven't detected any big enough object.
		if has_fg:
			cv2.grabCut(self.out_img, self.mask, self.rect_init, self.bgdmodel, self.fgdmodel, 1, cv2.GC_INIT_WITH_MASK)
		else:
			logging.error("No foreground object.")
		if self.resize:
			factor = float(self.in_img.shape[1])/float(self.mask.shape[1])
			self.mask = cv2.resize(self.mask, (self.in_img.shape[1], self.in_img.shape[0]), interpolation = cv2.INTER_NEAREST)
Пример #17
0
 def apply_segmentation(self, coords=None, pix_locs=None):
     # actually take the coords and call grabcut
     # we're going to assume that cur_mask_ind points to the previous mask
     if len(self.mask_dict[self.cur_indv][self.cur_indv_ind]) != 0:
         # first we'll load up the previous mask and bgd/fgd mod (if they exist)
         bgd_mod = self.open_seg('bgd')
         fgd_mod = self.open_seg('fgd')
         mask = self.open_seg('mask')
         # so the idea is now we want to take the mask and the region outlined by the coordinates
         # we want to this in the form lower_y:upper_y,lower_x:upper_x
         if pix_locs is None and not (coords is None):
             mask[coords[1]:coords[3],coords[0]:coords[2]] = self.region_marker
         elif coords is None and not (pix_locs is None):
             print(pix_locs)
             mask[list(zip(*pix_locs))] = self.region_marker
         init = cv2.GC_INIT_WITH_MASK
     else:
         # if not, we'll initialize with rect
         bgd_mod = np.zeros((1,65))
         fgd_mod = np.zeros((1,65))
         mask = np.zeros(self.cur_img_shape[:2],np.uint8)
         init = cv2.GC_INIT_WITH_RECT
     iterations = 2 # TODO: Make this a selector
     print("SEGMENTING PLEASE WAIT")
     cv2.grabCut(self.cur_img, mask, coords, bgd_mod, fgd_mod, iterations, init)
     # then store the mask, fgd_mod, bgd_mod
     self.cur_mask_ind += 1
     seg_dict = self.save_segmentation(mask, fgd_mod, bgd_mod)
     # chop off the old list of segmentations
     old_seg_dicts = self.mask_dict[self.cur_indv][self.cur_indv_ind]
     new_seg_dicts = self.mask_dict[self.cur_indv][self.cur_indv_ind][:self.cur_mask_ind]
     # major TODO: clean up segmentations currently in that directory ahead of this one
     new_seg_dicts.append(seg_dict)
     self.mask_dict[self.cur_indv][self.cur_indv_ind] = new_seg_dicts
     self.cleanup_previous_files(old_seg_dicts)
Пример #18
0
def openCVGrabCut(img, bbox):
        mask = np.zeros(img.shape[:2],dtype='uint8')
        tmp1 = np.zeros((1, 13 * 5))
        tmp2 = np.zeros((1, 13 * 5))

        cv2.grabCut(img,mask,bbox,tmp1,tmp2,iterCount=1,mode=cv2.GC_INIT_WITH_RECT)
        return mask
Пример #19
0
def grabCut(img, rect=None, mask=None, ite=5):
    height, width, channels = img.shape
    # if no arguments, try to segment using a large rectangle
    if rect == None and mask == None:
        rect = (int(width*0.15), 15, int(width*0.85), height-15)
        initOpt = cv2.GC_INIT_WITH_RECT
    # if rectangle argument but no mask, init mask with rectangle
    elif mask == None:
        mask = np.zeros((height, width), np.uint8)
        initOpt = cv2.GC_INIT_WITH_RECT
    # if mask argument but no rectangle, use mask and let rect to None
    elif rect == None:
        initOpt = cv2.GC_INIT_WITH_MASK
        rect = (0, 0, width, height)
        mask = np.uint8(mask)
    # if mask argument and rectangle, set pixels outside the mask as background
    else:
        mask = np.uint8(mask)
        rect = rectangleutil.checkRectangleBounds(rect, mask.shape)
        maskRect = rectangleutil.rectangle2mask(rect, mask.shape)
        mask[maskRect == 0] = cv2.GC_BGD
        initOpt = cv2.GC_INIT_WITH_MASK
    #imageblured = np.zeros(img.shape, img.dtype)
    #cv2.smooth(img, imageblured, cv.CV_GAUSSIAN, 5)
    tmp1 = np.zeros((1, 13 * 5))
    tmp2 = np.zeros((1, 13 * 5))
    cv2.grabCut(img, mask, rect, tmp1, tmp2, ite, initOpt)
    mask[mask == cv2.GC_BGD] = 0
    mask[mask == cv2.GC_PR_BGD] = 0
    mask[mask == cv2.GC_FGD] = 255
    mask[mask == cv2.GC_PR_FGD] = 255
    return mask
Пример #20
0
def propagate_label_gmm(previmage,objmask,nextimage):
    rows = previmage.shape[0]
    cols = previmage.shape[1]
    gmm_mask = np.ones((rows,cols),np.uint8)
    gmm_mask = gmm_mask * 0
	#print np.sum(gmm_mask)
    gmm_mask[objmask[0],objmask[1]] = 3
    sure_fg = np.random.randint((objmask[0].shape[0]),size=100)
    for x in np.nditer(sure_fg):
        gmm_mask[objmask[0][x],objmask[1][x]] = 1
    bgdModel = np.zeros((1,65),np.float64)
    fgdModel = np.zeros((1,65),np.float64)
    img = nextimage
    print type(img[0][0])
    tmp_mask = np.zeros((rows,cols),np.uint8)
    m1,m2 = np.where(gmm_mask==1)
    r_mask, bgdModel, fgdModel     =  cv2.grabCut(img,gmm_mask,None,bgdModel,fgdModel,5,cv2.GC_INIT_WITH_MASK)
    r_mask, bgdModel, fgdModel     =  cv2.grabCut(img,tmp_mask,(0,199,120,120),bgdModel,fgdModel,5,cv2.GC_INIT_WITH_RECT| cv2.GC_INIT_WITH_MASK)
    print sure_fg
    print np.sum(gmm_mask)
    print r_mask.shape
    print objmask[1].shape
    print img.shape,r_mask.shape
    l_img =   img* r_mask[:,:,np.newaxis]
    cv2.imwrite('gmmm.png',l_img)
    rgb_np = np.zeros((self.gtframe.width,self.gtframe.height,3))
    rgb_np[np.where(r_mask)]=[0,255,0]
    data = rgb_np
    rescaled =  (255.0 / data.max() * (data - data.min())).astype(np.uint8)
    rgb_image = Image.fromarray(rescaled)
    return rgb_image
Пример #21
0
def main():
    """main method for grabCut."""
    image = cv2.imread('rawImage.png')
    mask = np.zeros(image.shape[:2], np.uint8)
    bgd_model = np.zeros((1, 65), np.float64)
    fgd_model = np.zeros((1, 65), np.float64)

    manual_mask = cv2.resize(cv2.imread('result.png', 0),
                            image.shape[:2][::-1],
                            0, 0, cv2.INTER_NEAREST)

    # Map mask to {0, 1}
    mask[manual_mask < 127] = 0
    mask[manual_mask >= 127] = 1

    mask, bgd_model, fgd_model = cv2.grabCut(image, mask, None, bgd_model,
                                             fgd_model, 5,
                                             cv2.GC_INIT_WITH_MASK)
    mask, bgd_model, fgd_model = cv2.grabCut(image, mask, None, bgd_model,
                                             fgd_model, 5, cv2.GC_EVAL)

    mask = np.where((mask == 2) | (mask == 0), 0, 1).astype('uint8')
    image = image * mask[:, :, np.newaxis]

    cv2.imwrite("masked.png", image)
Пример #22
0
def do_grabcut(f):
    img = cv2.imread(f)
    mask = np.zeros(img.shape[:2],np.uint8)
    (h,w,d) = img.shape
    #print (h,w,d)
    upper_corner=(h/10,w/10)
    lower_corner=(h-(h/10),w-(w/10))
    bgdModel = np.zeros((1,65),np.float64)
    fgdModel = np.zeros((1,65),np.float64)

    #rect = (upper_corner[0],upper_corner[1],lower_corner[0],lower_corner[1])
    rect= (50,50,w-100,h-100)
    #print rect
    iterCount=1
    cv2.grabCut(img,mask,rect,bgdModel,fgdModel,iterCount,cv2.GC_INIT_WITH_RECT)

    mask2 = np.where((mask==1) + (mask==3),255,0).astype('uint8')
    output = cv2.bitwise_and(img,img,mask=mask2)

    # mask2 = np.where((mask==2)|(mask==0),0,1).astype('uint8')
    # img = img*mask2[:,:,np.newaxis]

    #plt.imshow(img),plt.show()
    cv2.imwrite('gcut.jpg',output)
    return output
Пример #23
0
    def _refine_predug(self, candidate):
        """ uses the color information directly to specify the predug """
        # determine a bounding rectangle
        region = candidate.bounds
        size = max(region.width, region.height)
        region.buffer(0.5 * size)  # < increase by 50% in each direction

        # extract the region from the image
        slice_x, slice_y = region.slices
        img = self.image[slice_y, slice_x].astype(np.uint8, copy=True)

        # build the estimate polygon
        poly_p = affinity.translate(candidate.polygon, -region.x, -region.y)
        poly_s = affinity.translate(self.ground.get_sky_polygon(), -region.x, -region.y)

        def fill_mask(color, margin=0):
            """ fills the mask with the buffered regions """
            for poly in (poly_p, poly_s):
                pts = np.array(poly.buffer(margin).boundary.coords, np.int32)
                cv2.fillPoly(mask, [pts], color)

        # prepare the mask for the grabCut algorithm
        burrow_width = self.params["burrows/width"]
        mask = np.full_like(img, cv2.GC_BGD, dtype=np.uint8)  # < sure background
        fill_mask(cv2.GC_PR_BGD, 0.25 * burrow_width)  # < possible background
        fill_mask(cv2.GC_PR_FGD, 0)  # < possible foreground
        fill_mask(cv2.GC_FGD, -0.25 * burrow_width)  # < sure foreground

        # run GrabCut algorithm
        img = cv2.cvtColor(img, cv2.COLOR_GRAY2RGB)
        bgdmodel = np.zeros((1, 65), np.float64)
        fgdmodel = np.zeros((1, 65), np.float64)
        try:
            cv2.grabCut(img, mask, (0, 0, 1, 1), bgdmodel, fgdmodel, 2, cv2.GC_INIT_WITH_MASK)
        except:
            # any error in the GrabCut algorithm makes the whole function useless
            logging.warn("GrabCut algorithm failed for predug")
            return candidate

        # turn the sky into background
        pts = np.array(poly_s.boundary.coords, np.int32)
        cv2.fillPoly(mask, [pts], cv2.GC_BGD)

        # extract a binary mask determining the predug
        predug_mask = (mask == cv2.GC_FGD) | (mask == cv2.GC_PR_FGD)
        predug_mask = predug_mask.astype(np.uint8)

        # simplify the mask using binary operations
        w = int(0.5 * burrow_width)
        kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (w, w))
        predug_mask = cv2.morphologyEx(predug_mask, cv2.MORPH_OPEN, kernel)

        # extract the outline of the predug
        contour = regions.get_contour_from_largest_region(predug_mask)

        # translate curves back into global coordinate system
        contour = curves.translate_points(contour, region.x, region.y)

        return shapes.Polygon(contour)
def runGrabCutOnTheImage(image, seeds):
    bgdModel = np.zeros((1,65),np.float64)
    fgdModel = np.zeros((1,65),np.float64)
    import copy    
    mask = copy.deepcopy( seeds )
    cv2.grabCut(image, mask, None, bgdModel, fgdModel, 5, cv2.GC_INIT_WITH_MASK )
    result = np.where( (mask == cv2.GC_FGD) | (mask == cv2.GC_PR_FGD), 1, 0)
    return result
Пример #25
0
def grabCut(src, box):
    mask = np.zeros(src.shape[:2], np.uint8)
    bgdModel = np.zeros((1, 65), np.float64)
    fgdModel = np.zeros((1, 65), np.float64)

    cv2.grabCut(src, mask, box, bgdModel, fgdModel, 5, cv2.GC_INIT_WITH_RECT)
    mask2 = np.where((mask == 2) | (mask == 0), 0, 1).astype('uint8')
    dst = src*mask2[:, :, np.newaxis]
    return dst
Пример #26
0
def refine_saliency_with_grabcut(img, saliency):
	rect = largest_contours_rect(saliency)
	bgdmodel = np.zeros((1, 65),np.float64)
	fgdmodel = np.zeros((1, 65),np.float64)
	saliency[np.where(saliency > 0)] = cv2.GC_FGD
	mask = saliency
	cv2.grabCut(img, mask, rect, bgdmodel, fgdmodel, 1, cv2.GC_INIT_WITH_RECT)
	mask = np.where((mask==2)|(mask==0),0,1).astype('uint8')
	return mask
def refine_background_via_grabcut(img, is_background, dilate=False):
    #use grabcut (http://docs.opencv.org/trunk/doc/py_tutorials/py_imgproc/py_grabcut/py_grabcut.html) 
    # to cut out other background pixels
    bgdModel = np.zeros((1,65),np.float64)
    fgdModel = np.zeros((1,65),np.float64)
    rect = (0,0,img.shape[1],img.shape[0])
    grabcut_mask = np.where(is_background!=0,cv2.GC_BGD,cv2.GC_PR_FGD).astype(np.uint8) #background should be 0, probable foreground = 3 
    cv2.grabCut(img, grabcut_mask,rect,bgdModel,fgdModel,5,cv2.GC_INIT_WITH_MASK)
    return np.where((grabcut_mask ==2)|(grabcut_mask ==0),0,1).astype(np.uint8)
Пример #28
0
def grabcut(img, iters=5, roi=None, margin=5):
    """Run the GrabCut algorithm for segmentation and return the mask."""
    mask = np.zeros(img.shape[:2], np.uint8)
    bgdmodel = np.zeros((1,65), np.float64)
    fgdmodel = np.zeros((1,65), np.float64)
    if not roi:
        roi = (margin, margin, img.shape[1]-margin*2, img.shape[0]-margin*2)
    cv2.grabCut(img, mask, roi, bgdmodel, fgdmodel, iters, cv2.GC_INIT_WITH_RECT)
    return mask
Пример #29
0
 def callback(rect, dumb):
     mask = np.zeros(im.shape[:2], np.uint8)
     t_0 = time.time()
     cv2.grabCut(im, mask, rect, None, None, 6, cv2.GC_INIT_WITH_RECT)
     deltaT = time.time() - t_0
     print(f'deltaT = {deltaT}')
     mask = np.where((mask==2)|(mask==0), 0, 1).astype('uint8')
     img = im * mask[:,:, np.newaxis]
     pylab.imshow(img)
     pylab.show()
Пример #30
0
def foregroundExtract(input):
    x1,y1,x2,y2 = 0,0,500,350
    mask = np.zeros(input.shape[:2],np.uint8)
    bgd_model = np.zeros((1,65),np.float64)
    fgd_model = np.zeros((1,65),np.float64)
    rect = (x1,y1,x2,y2)
    cv2.grabCut(input,mask,rect,bgd_model,fgd_model,5,cv2.GC_INIT_WITH_RECT)
    mask2 = np.where((mask==2)|(mask==0),0,1).astype("uint8")
    output = input*mask2[:,:,np.newaxis]
    return output
Пример #31
0
            print('run grabcut - rect')
            print('crop_img.shape')
            print(crop_img.shape)
        rect = (gc_bg_rect, gc_bg_rect, cimg_w - gc_bg_rect,
                cimg_h - gc_bg_rect)
        if DEBUG:
            print(rect)

        #plt.imshow(crop_img),plt.colorbar(),plt.show()

        #raise SystemExit(0)

    # cv2.imshow("cropped",crop_img)
    #cv2.waitKey(0)

        cv2.grabCut(crop_img, crop_mask, rect, bgdModel, fgdModel, 5,
                    cv2.GC_INIT_WITH_RECT)
        mask2 = np.where((crop_mask == 2) | (crop_mask == 0), 0,
                         1).astype('uint8')
        img = crop_img * mask2[:, :, np.newaxis]
        if DEBUG:
            outimgname = img_name[0:-4] + '_img_grabcut.png'
            cv2.imwrite(os.path.join(debug_path, plate_num, outimgname), img)
            outimgname = img_name[0:-4] + '_mask_grabcut.png'
            cv2.imwrite(os.path.join(debug_path, plate_num, outimgname),
                        mask2 * 255)

    # apply CC mask

        if DEBUG:
            print(img.shape)
            print(ccmask_croped.shape)
rects = faces[0]
neighbours = faces[1]

for (x, y, w, h) in faces[0]:
    roi_gray = gray[y:y + h, x:x + w]
    roi_color = img[y:y + h, x:x + w]
    eyes = eye_cascade.detectMultiScale(roi_gray)
    for (ex, ey, ew, eh) in eyes:
        cv2.rectangle(roi_color, (ex, ey), (ex + ew, ey + eh), (0, 255, 0), 2)
cv2.imshow('img', img)

mask = np.zeros(img.shape[:2], np.uint8)
bgdModel = np.zeros((1, 65), np.float64)
fgdModel = np.zeros((1, 65), np.float64)
rect = (399, 277, 102, 102)
cv2.grabCut(img, mask, rect, bgdModel, fgdModel, 5, cv2.GC_INIT_WITH_RECT)
mask2 = np.where(((mask == 0) | (mask == 2)), 0, 1).astype('uint8')
img = img * mask2[:, :, np.newaxis]

body = bodydetection.detectMultiScale(gray, 1.1, 5, 60)

grown = 0
prev = 0
curr = 0
grow = 0
grow1 = grow
flag = 1
for y in faces[0]:
    for x in faces[2]:
        temp = y
        prev = x
Пример #33
0
import cv2
import numpy as np
import matplotlib.pyplot as pt

frame = cv2.imread('3d.jpg')

mask = np.zeros(frame.shape[:2], np.uint8)

bgM = np.zeros((1, 65), np.float64)
fgM = np.zeros((1, 65), np.float64)

rect = (40, 40, 170, 140)
cv2.grabCut(frame, mask, rect, bgM, fgM, 5, cv2.GC_INIT_WITH_RECT)
mask2 = np.where((mask == 2) | (mask == 0), 0, 1).astype('uint8')
img = frame * mask2[:, :, np.newaxis]

cv2.imshow('image', img)
cv2.waitKey(0)
cv2.destroyAllWindows()
Пример #34
0
def seg_butterfly(image,
                  method="otsu",
                  alpha=1.0,
                  gmmborder=0.1,
                  use_otsu=True):
    """ segment a given image and return statistics of the largest object """
    image_hsv = rgb2hsv(image)
    saturation = image_hsv[:, :, 1]

    if method == "otsu":
        t = alpha * threshold_otsu(saturation)
        print "Threshold: {}".format(t)

        contours = find_contours(saturation, t)
        binaryimage = saturation > t

    elif not mixture_disabled and method == "gmm":
        g = GMM(3)
        bx = int(gmmborder * image.shape[1]) - 1
        by = int(gmmborder * image.shape[0]) - 1
        X = np.concatenate([
            np.reshape(image_hsv[:, :bx, :], [-1, 3]),
            np.reshape(image_hsv[:, -bx:, :], [-1, 3]),
            np.reshape(image_hsv[:by, :, :], [-1, 3]),
            np.reshape(image_hsv[-by:, :, :], [-1, 3])
        ])
        print "GMM learning ..."
        g.fit(X)
        Xt = np.array(np.reshape(image_hsv, [-1, 3]), dtype=float)
        s = np.reshape(g.score(Xt), image_hsv.shape[:2])
        if use_otsu:
            t = alpha * threshold_otsu(s)
        else:
            t = alpha

        print "Threshold: {}".format(t)
        contours = find_contours(s, t)
        binaryimage = s > t
    elif not grabcut_disabled and method == "grabcut":
        grabcut_mask = np.zeros(image.shape[:2], np.uint8)
        grabcut_rect = (int(image.shape[1] * 0.05), int(image.shape[0] * 0.1),
                        int(image.shape[1] * 0.9), int(image.shape[0] * 0.8))
        bgd_model = np.zeros((1, 65), np.float64)
        fgd_model = np.zeros((1, 65), np.float64)
        grabCut(image.astype(np.uint8), grabcut_mask, grabcut_rect, bgd_model,
                fgd_model, 10, cv2.GC_INIT_WITH_RECT)
        grabcut_mask[grabcut_mask == 2] = 0
        grabcut_mask[grabcut_mask == 3] = 1
        binaryimage = grabcut_mask
        contours = find_contours(binaryimage, 0.5)
    else:
        raise Exception("Method {} not supported!".format(method))

    # The intensity channel
    value_channel = image_hsv[binaryimage, 2]
    # The saturation channel
    saturation = image_hsv[binaryimage, 1]
    # The hue channel
    hue = image_hsv[binaryimage, 0]

    stats = {}

    stats['median-intensity'] = np.median(value_channel)
    stats['mean-intensity'] = np.mean(value_channel)
    stats['stddev-intensity'] = np.std(value_channel)
    stats['median-saturation'] = np.median(saturation)
    stats['mean-saturation'] = np.mean(saturation)
    stats['stddev-saturation'] = np.std(saturation)
    stats['median-hue'] = np.median(hue)
    stats['mean-hue'] = np.mean(hue)
    stats['stddev-hue'] = np.std(hue)
    stats['seg-absolute-size'] = len(value_channel)
    stats['seg-relative-size'] = len(value_channel) / float(
        image_hsv.shape[0] * image_hsv.shape[1])

    maxc = 0
    for n, contour in enumerate(contours):
        if len(contours[n]) > len(contours[maxc]):
            maxc = n

    stats['c-length'] = len(contours[maxc])
    stats['c-area'] = contour_area(contours[maxc])

    # compute bounding box
    stats['c-xmin'] = np.amin(contours[maxc][:, 1])
    stats['c-xmax'] = np.amax(contours[maxc][:, 1])
    stats['c-ymin'] = np.amin(contours[maxc][:, 0])
    stats['c-ymax'] = np.amax(contours[maxc][:, 0])

    return stats, contours[maxc], binaryimage
Пример #35
0
# Show the rough, approximated output
cv2.imshow("Rough Output", roughOutput)
cv2.waitKey(0)

# Any mask values greater than zero should be set to probable foreground
mask[mask > 0] = cv2.GC_PR_FGD
mask[mask == 0] = cv2.GC_BGD

# Allocate memory for two arrays that the GrabCut algorithm internally uses
# when segmenting the foreground from the background
fgModel = np.zeros((1, 65), dtype="float")
bgModel = np.zeros((1, 65), dtype="float")

# Apply GrabCut using the mask segmentation method
start = time.time()
(mask, bgModel, fgModel) = cv2.grabCut(image, mask, None, bgModel,
                                       fgModel, iterCount=args["iter"], mode=cv2.GC_INIT_WITH_MASK)
end = time.time()
print("[INFO] Applying GrabCut took {:.2f} seconds".format(end - start))

# The output mask has 4 possible output values, marking each pixel in the mask as:
# (1) Definite Background
# (2) Definite Foreground
# (3) Probable Background
# (4) Probable Background
values = (("Definite Background", cv2.GC_BGD), ("Probable Background", cv2.GC_PR_BGD),
          ("Definite Foreground", cv2.GC_FGD), ("Probable Foreground", cv2.GC_PR_FGD))

# Loop over the possible GrabCut mask values
for (name, value) in values:
    # Construct a mask for each one of the current values
    print("[INFO] Showing mask for '{}'".format(name))
Пример #36
0
'''
使用 GrabCut 算法进行交互式前景提取
'''
import cv2
import numpy as np
from matplotlib import pyplot as plt
'''
原理
从用户的角度来看它到底是如何工作的呢?开始时用户需要用一个矩形将前景区域框住(前景区域应该完全被包括在矩形框内部)。
然后算法进行迭代式分割直达达到最好结果。但是有时分割的结果不够理想,比如把前景当成了背景,或者把背景当成了前景。
在这种情况下,就需要用户来进行修改了。用户只需要在不理想的部位画一笔(点一下鼠标)就可以了。
画一笔就等于在告诉计算机:“嗨,老兄,你把这里弄反了,下次迭代的时候记得改过来呀!”。
然后,在下一轮迭代的时候你就会得到一个更好的结果了
'''
'''
cv2.grabCut()
* img - 输入图像
* mask-掩模图像,用来确定哪些区域是背景,前景,可能是前景/背景等。可以设置为:cv2.GC_BGD,cv2.GC_FGD,cv2.GC_PR_BGD,cv2.GC_PR_FGD,或者直接输入 0,1,2,3 也行。
* rect - 包含前景的矩形,格式为 (x,y,w,h)
* bdgModel, fgdModel - 算法内部使用的数组. 你只需要创建两个大小为 (1,65),数据类型为 np.float64 的数组。
* iterCount - 算法的迭代次数
* mode 可以设置为 cv2.GC_INIT_WITH_RECT 或 cv2.GC_INIT_WITH_MASK,也可以联合使用。这是用来确定我们进行修改的方式,矩形模式或者掩模模式。
'''
image = cv2.imread('../data/plane.jpg')
mask = np.zeros(image.shape[:2], np.uint8)
bgdModel = np.zeros((1, 65), np.float64)
fgdModel = np.zeros((1, 65), np.float64)
rect = (50, 50, 450, 290)
# 函数的返回值是更新的 mask, bgdModel, fgdModel
cv2.grabCut(image, mask, rect, bgdModel, fgdModel, 5, cv2.GC_INIT_WITH_RECT)
Пример #37
0
import cv2
import numpy as np
img = cv2.imread('../img/shyaro.jpg')
mask = np.zeros(img.shape[:2], np.uint8)

src = np.zeros((1, 65), np.float64)
sub = np.zeros((1, 65), np.float64)
rect = (161, 79, 150, 150)

cv2.grabCut(img, mask, rect, src, sub, 5, cv2.GC_INIT_WITH_RECT)
mask2 = np.where((mask == 2) | (mask == 0), 0, 1).astype('uint8')

img = img * mask2[:, :, np.newaxis]

cv2.imshow('cut', img)
cv2.waitKey()
cv2.DestroyAllWindow()
Пример #38
0
def fgBgCombiner(path, bg_frame, save_dir):
    '''
	Change background in videos using GrabCut algorithm
	------------------------
	Parameters
		path (string): path of the video to change the background
		bg_frame (array like): background image (or nd.array)
		save_dir (string): path where to save obtained video
	Returns
		None
	------------------------
	'''

    # Get video name from full path
    file_name = path.split('/')[-1].split('.')[0]

    # Open the video and check if it successfully done
    cap = cv2.VideoCapture(cv2.samples.findFileOrKeep(path))
    if not cap.isOpened:
        print('Unable to open: ' + path)
        exit(0)

    # Get fps and shape of the video
    if int(MAJOR_VER) < 3:
        fps = cap.get(cv2.cv.CV_CAP_PROP_FPS)
    else:
        fps = cap.get(cv2.CAP_PROP_FPS)
    size = (int(cap.get(3)), int(cap.get(4)))

    # Create video writer
    fourcc = cv2.VideoWriter_fourcc(*'XVID')
    out = cv2.VideoWriter(save_dir + file_name + '.avi', fourcc, fps, size)

    # Resize background frame (image) to video shape
    background = cv2.resize(bg_frame, size, interpolation=cv2.INTER_AREA)

    # Loop over the frames of the video
    while True:
        # Grab the current frame
        _, frame = cap.read()
        # If the frame could not be grabbed, then we have reached the end of the video
        if frame is None:
            break

        # Convert it to grayscale
        frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
        # Initial mask
        mask = np.zeros(frame.shape[:2], np.uint8)
        # These are arrays used by the algorithm internally.
        bgdModel = np.zeros((1, 65), np.float64)
        fgdModel = np.zeros((1, 65), np.float64)
        # Specify a region of interest (RoI) and apply grabCut algorithm
        rect = (200, 50, 300, 400)
        # Number of iterations the algorithm should run is 1
        # which is fast but not good for correct segmentation
        cv2.grabCut(frame, mask, rect, bgdModel, fgdModel, 1,
                    cv2.GC_INIT_WITH_RECT)
        # New mask for moving object
        mask2 = np.where((mask == 2) | (mask == 0), (0, ),
                         (1, )).astype('uint8')
        frame = frame * mask2[:, :, np.newaxis]
        mask_1 = frame > 0
        mask_2 = frame <= 0
        # Linear combination of bgd and fgd frames with mask_1 and mask_2 "scaliars"
        combination = cv2.cvtColor(
            frame, cv2.COLOR_BGR2RGB) * mask_1 + background * mask_2
        combination = combination.astype(dtype=np.uint8)
        # Write combined frame
        out.write(combination)

    # When everything done, cleanup the camera and close any open windows
    print('Background change is finished')
    cap.release()
    cv2.destroyAllWindows()
import cv2
import numpy as np
from matplotlib import pyplot as plt

image_bgr = cv2.imread('images/input_2.jpg')
image_rgb = cv2.cvtColor(image_bgr, cv2.COLOR_BGR2RGB)

rectangle = (0, 0, 300, 380)
# 600, 550, 1150, 2000
mask = np.zeros(image_rgb.shape[:2], np.uint8)

bgdModel = np.zeros((1, 65), np.float64)
fgdModel = np.zeros((1, 65), np.float64)

cv2.grabCut(image_rgb, mask, rectangle, bgdModel, fgdModel, 5,
            cv2.GC_INIT_WITH_RECT)

mask_2 = np.where((mask == 2) | (mask == 0), 0, 1).astype('uint8')

image_rgd_nobg = image_rgb * mask_2[:, :, np.newaxis]

plt.imshow(image_rgd_nobg), plt.axis('off')
plt.show()
Пример #40
0
# 原图mask,与原图等大小
mask = np.zeros(src.shape[:2], dtype=np.uint8)

# 矩形roi
rect = (int(r[0]), int(r[1]), int(r[2]), int(r[3]))  # 包括前景的矩形,格式为(x,y,w,h)

# bg模型的临时数组
bgdmodel = np.zeros((1, 65), np.float64)
# fg模型的临时数组
fgdmodel = np.zeros((1, 65), np.float64)

cv2.grabCut(src,
            mask,
            rect,
            bgdmodel,
            fgdmodel,
            11,
            mode=cv2.GC_INIT_WITH_RECT)

print(np.unique(mask))
# 提取前景和可能的前景区域
mask2 = np.where((mask == 1) | (mask == 3), 255, 0).astype('uint8')

print(mask2.shape)

# 按位与 src & src == 0,得到的是二进制
result = cv2.bitwise_and(src, src, mask=mask2)
# cv2.imwrite('result.jpg', result)
# cv2.imwrite('roi.jpg', roi)
Пример #41
0
    erosion = cv.erode(mask_down, kernel, iterations = 25)

    gcmask = cv.addWeighted(erosion, 0.5, mask_down, 0.5,0)
    gcmask = np.where((gcmask != 128)&(gcmask != 255), cv.GC_BGD, gcmask)
    gcmask[gcmask == 128] = cv.GC_PR_FGD
    gcmask[gcmask == 255] = cv.GC_FGD

    backgroundModel = np.zeros((1, 65), np.float64)
    foregroundModel = np.zeros((1, 65), np.float64)

    rectangle = (150,150,100,100)

    start = time.time()

    cv.grabCut(road_down, gcmask, rectangle, 
                backgroundModel, foregroundModel,
                1, cv.GC_INIT_WITH_MASK)

    print(time.time() - start)

    mask2 = np.where((mask_down == 2)|(mask_down == 0), 0, 1).astype('uint8')
    mask2 = cv.pyrUp(mask2)

    gcroad = road * mask2[:, :, np.newaxis]

    # video.write(road)
    # output segmented image with colorbar
    cv.imshow('road', gcroad)
    cv.waitKey(10)

#cv.destroyAllWindows()
Пример #42
0
def fname(name, url):
    # # x = name[7:]
    # # path = 'media/'+name[7:]
    # # print(path)
    # # return path
    # #return type(name)
    # path = 'media/'
    # path += name
    # #return path
    # if path != "media/":
    #     with Image.open(path) as image:
    #         width, height = image.size
    #         image.save("media/"+name+"converted.jpeg")
    #     return image
    # else:
    #     return ''

    # global generator

    # generator = keras.models.load_model('home/pikay2.h5')

    path = 'media/'
    path += name
    #return path
    if path != "media/":
        img = cv2.imread(path)
        img2 = cv2.resize(img, (256, 256))
        x_test = cv2.cvtColor(img2, cv2.COLOR_BGR2RGB)
        x_test = np.array(x_test) / 127.5 - 1.
        x_test = x_test.reshape(
            (1, 256, 256, 3)
        )  #1 since keras expects first element of shape to be reserved for batch size
        gen = generator.predict(x_test)

        scipy.misc.imsave("home/static/home/downloaded_images/" + name, gen[0])

        image = img2  #pp is the grayscale gan I/P image
        template = cv2.imread("home/static/home/downloaded_images/" +
                              name)  #res is the result after predict

        kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (2, 2))
        template = cv2.morphologyEx(template,
                                    cv2.MORPH_ERODE,
                                    kernel,
                                    iterations=1)

        image[template == 0] = 255
        #    cv2.imwrite('resl.jpg', template)

        image = cv2.imread(path)
        image = cv2.resize(image, (256, 256))

        mask = np.zeros(image.shape[:2], np.uint8)

        backgroundModel = np.zeros((1, 65), np.float64)
        foregroundModel = np.zeros((1, 65), np.float64)

        rectangle = (0, 0, 255, 255)

        cv2.grabCut(image, mask, rectangle, backgroundModel, foregroundModel,
                    3, cv2.GC_INIT_WITH_RECT)

        mask2 = np.where((mask == 2) | (mask == 0), 0, 1).astype('uint8')
        image = image * mask2[:, :, np.newaxis]
        #    cv2.imwrite('temp2.jpg', image)
        result = template
        gray = image

        result[gray <= 2] = 255
        #    cv2.imshow('res', result)
        #    cv2.imshow('gray', gray)
        #    plt.imshow(cv2.cvtColor(result, cv2.COLOR_BGR2RGB))
        scipy.misc.imsave('home/static/home/downloaded_images/' + name,
                          cv2.cvtColor(result, cv2.COLOR_BGR2RGB))

        img = PIL.Image.open('home/static/home/downloaded_images/' + name)
        converter = PIL.ImageEnhance.Color(img)
        img2 = converter.enhance(1.5)
        img2.save('home/static/home/downloaded_images/' + name)

        # fs = FileSystemStorage()
        # fs.save("saved_img.png","my.png")
        #plt.imshow(gen[0])
        #print(type(img))
        return ''

    else:

        return ''
Пример #43
0
            rect = (0, 0, 1, 1)
            drawing = False
            rectangle = False
            rect_or_mask = 100
            rect_over = False
            value = DRAW_FG
            img = img2.copy()
            mask = np.zeros(img.shape[:2],
                            dtype=np.uint8)  # mask initialized to PR_BG
            output = np.zeros(img.shape, np.uint8)  # output image to be shown
        elif k == ord('n'):  # segment the image
            print(
                """ For finer touchups, mark foreground and background after pressing keys 0-3
            and again press 'n' \n""")
            if (rect_or_mask == 0):  # grabcut with rect
                bgdmodel = np.zeros((1, 65), np.float64)
                fgdmodel = np.zeros((1, 65), np.float64)
                cv.grabCut(img2, mask, rect, bgdmodel, fgdmodel, 1,
                           cv.GC_INIT_WITH_RECT)
                rect_or_mask = 1
            elif rect_or_mask == 1:  # grabcut with mask
                bgdmodel = np.zeros((1, 65), np.float64)
                fgdmodel = np.zeros((1, 65), np.float64)
                cv.grabCut(img2, mask, rect, bgdmodel, fgdmodel, 1,
                           cv.GC_INIT_WITH_MASK)

        mask2 = np.where((mask == 1) + (mask == 3), 255, 0).astype('uint8')
        output = cv.bitwise_and(img2, img2, mask=mask2)

    cv.destroyAllWindows()
import cv2
from watershed1 import *
from matplotlib import pyplot as plt

fig = plt.figure(figsize=(24, 24))
bgdModel = np.zeros((1, 65), np.float64)
fgdModel = np.zeros((1, 65), np.float64)
rect = (50, 50, 450, 290)
ax = []
imgs = ['trial6.jpg', 'index.jpeg', 'trial.jpg']
cvtimg = []
oimg = []
for i, img in enumerate(imgs):
    oimg.append(cv2.imread(img))
    mask = np.zeros(oimg[i].shape[:2], np.uint8)
    cv2.grabCut(oimg[i], mask, rect, bgdModel, fgdModel, 5,
                cv2.GC_INIT_WITH_RECT)
    mask2 = np.where((mask == 2) | (mask == 0), 0, 1).astype('uint8')
    maskimg = oimg[i] * mask2[:, :, np.newaxis]
    cvtimg.append(cv2.cvtColor(maskimg, cv2.COLOR_BGR2GRAY))
    watershed_algo(cvtimg[i])

for i, img in enumerate(oimg):
    ax.append(fig.add_subplot(len(imgs), 2, i * 2 + 1))
    ax[-1].set_title("original image")
    plt.imshow(img)
    ax.append(fig.add_subplot(len(imgs), 2, i * 2 + 2))
    ax[-1].set_title("segemented image")
    plt.imshow(cvtimg[i])
plt.show()
'''
img3=cv2.imread('trial6.jpg')
Пример #45
0
import cv2
import numpy as np
import matplotlib.pyplot as plt
import time

start =time.time()
img=cv2.imread('rose.jpg')
mask=np.zeros(img.shape[:2],np.uint8)

bgdModel=np.zeros((1,65),np.float64)
fgdModel=np.zeros((1,65),np.float64)

rect=(45,79,150,150)
rect2=(150,75,550,450)
cv2.grabCut(img,mask,rect2,bgdModel,fgdModel,5,cv2.GC_INIT_WITH_RECT)
mask2=np.where((mask==2)|(mask==0),0,1).astype('uint8')
img=img*mask2[:,:,np.newaxis]
plt.imshow(img)
plt.colorbar()
plt.show()
end=time.time()
print end-start
Пример #46
0
cv2.namedWindow('image')
cv2.setMouseCallback('image', mouse_callback)

while True:
    cv2.imshow('image', show_img)
    k = cv2.waitKey(1)

    if k == ord('a') and not mouse_pressed:
        if w * h > 0:
            break

cv2.destroyAllWindows()

labels = np.zeros(img.shape[:2], np.uint8)
labels, bgdModel, fgdModel = cv2.grabCut(img, labels, (x, y, w, h), None, None,
                                         5, cv2.GC_INIT_WITH_RECT)

show_img = np.copy(img)
show_img[(labels == cv2.GC_PR_BGD) | (labels == cv2.GC_BGD)] //= 3

cv2.imshow('image', show_img)
cv2.waitKey()
cv2.destroyAllWindows()

label = cv2.GC_BGD
lbl_clrs = {cv2.GC_BGD: (0, 0, 0), cv2.GC_FGD: (255, 255, 255)}


def mouse_callback(event, x, y, flags, param):
    global mouse_pressed
Пример #47
0
                              color=1,
                              thickness=-1)

            cv2.rectangle(m, (bbox[0] + (bbox[2] - bbox[0]) // 4, bbox[1] +
                              (bbox[3] - bbox[1]) // 4),
                          (bbox[0] + (bbox[2] - bbox[0]) // 4 * 3, bbox[1] +
                           (bbox[3] - bbox[1]) // 4 * 3),
                          color=2,
                          thickness=-1)
            m_ = np.where(m > 0, m + 1, 0)
            # # print(m.shape, m.dtype)
            # # print(cv_img.shape, cv_img.dtype)
            #
            cv2.grabCut(cv_img,
                        m_, (x1, y1, w, h),
                        bgModel,
                        fgModel,
                        iterCount=3,
                        mode=cv2.GC_INIT_WITH_MASK)

            # for visualization purpose
            m_cut = np.where(((m_ == 2) | (m_ == 0)), 0, 1).astype(np.uint8)
            # cat_image = np.concatenate([m // 2 * 255, m_cut * 255], axis=1)
            # cv2.imshow('mask vs. cut', cat_image)
            #
            # cv_img_mask = cv_img * m_cut[:, :, np.newaxis]
            # # cv_img_mask = cv_img * m[:, :, np.newaxis]
            # cv2.imshow('image', cv_img_mask)
            # if cv2.waitKey() & 0xFF == ord('q'):
            #     exit()

            result['segmentation'] = encode_mask(m_cut)
Пример #48
0
    elif k == ord('r') or k == ord('2'):
        print('Restart')
        mask_fore = np.zeros_like(img)
        mask_back = np.zeros_like(img)
    # clear foreground mask
    elif k == ord('4'):
        print('Reselect foreground')
        mask_fore = np.zeros_like(img)
    # clear background mask
    elif k == ord('5'):
        print('Reselect background')
        mask_back = np.zeros_like(img)
    # run grabcut algorithm
    elif k == ord('c') or k == ord('3') or k == 13:
        print('Cutting foreground from the picture')
        mask_global = np.zeros(img.shape[:2], np.uint8) + 2
        mask_global[mask_fore[:, :, 1] == 255] = 1
        mask_global[mask_back[:, :, 2] == 255] = 0
        mask_global, bgdModel, fgdModel = cv2.grabCut(img, mask_global, None,
                                                      bgdModel, fgdModel,
                                                      iteration,
                                                      cv2.GC_INIT_WITH_MASK)
        mask_global = np.where((mask_global == 2) | (mask_global == 0), 0,
                               1).astype('uint8')
        target = img * mask_global[:, :, np.newaxis]
        cv2.imshow('target', target)
        cv2.imwrite('result.jpg', target)
    elif k == 27:
        break
cv2.destroyAllWindows()
Пример #49
0
while(1):
    ret ,frame = cap.read()
    if not ret:
        break

    #gray = cv2.cvtColor(frame,cv2.COLOR_BGR2GRAY)

    # edges = cv2.Canny(gray,50,150,apertureSize = 3)
    #img = cv2.medianBlur(gray,5)
    #circles = cv2.HoughCircles(img,cv2.HOUGH_GRADIENT,1,50,param1=50,param2=30,minRadius=30,maxRadius=40)

    mask = np.zeros(frame.shape[:2],np.uint8)
    bgdModel = np.zeros((1,65),np.float64)
    fgdModel = np.zeros((1,65),np.float64)
    rect = (50,50,450,290)
    cv2.grabCut(frame,mask,rect,bgdModel,fgdModel,5,cv2.GC_INIT_WITH_RECT)
    mask2 = np.where((mask==2)|(mask==0),0,1).astype('uint8')
    frame = frame*mask2[:,:,np.newaxis]

    # if circles is None:
    #     continue

    # circles = np.uint16(np.around(circles))
    # for i in circles[0,:]:
    #     # draw the outer circle
    #     cv2.circle(frame,(i[0],i[1]),i[2],(0,255,0),2)
    #     # draw the center of the circle
    #     cv2.circle(frame,(i[0],i[1]),2,(0,0,255),3)

    # minLineLength = 600
    # maxLineGap = 10
Пример #50
0
def main(argv):
    kNumGrabCutIters = 5;
    kStartImage = 100;
    base_dir=sys.argv[1];

    # Setup.
    image_dir = os.path.join(base_dir, 'dump', 'feature_tracking_primary');
    bounding_box_file = os.path.join(base_dir, 'dump',
                                     'finger_bounding_box.txt');
    marker_pixels_file = os.path.join(base_dir,'dump', 'marker_pixels.txt');
    bounding_info = np.genfromtxt(bounding_box_file, delimiter=",");
    marker_info = np.genfromtxt(marker_pixels_file, delimiter=",");
    assert(len(marker_info) == len(bounding_info));

    image_format = 'image_%05d.ppm';
    output_dir = os.path.join(base_dir, 'dump', 'grabcut_refined1');
    grabcut_format = 'grabcut_%05d.jpg';


    # Create output dir if needed.
    call(['mkdir', '-p', output_dir]);

    timer_list = list();
    plt.hold(False);
    total_iters = len(bounding_info);
    counter = 0;
    print(('%.2f' % (float(counter) / total_iters * 100)) + ' %', end='\r');
    sys.stdout.flush();
    # traverse by row.
    for row_i in range(len(bounding_info)):
        if row_i < kStartImage :
            counter = counter + 1;
            continue;

        crop_info_i = bounding_info[row_i];
        marker_info_i = marker_info[row_i];
        assert (marker_info_i[0] == crop_info_i[0]);

        #  Extract Box data.
        image_num = crop_info_i[0].astype('uint32');
        #  Fix 1-indexing used by matlab.
        top_left_x = crop_info_i[1].astype('uint32') - 1;
        top_left_y = crop_info_i[2].astype('uint32') - 1;
        height = crop_info_i[3].astype('uint32');
        width = crop_info_i[4].astype('uint32');
        rect = (top_left_x, top_left_y, width, height);

        # Fix the 1-indexing used by matlab!
        marker_info_i = marker_info_i[1:] - 1;

        # Extract marker_masks  (cropped)
        marker_masks = ExtractMarkerMasksFromCoords(rect, marker_info_i);

        # Skip if not in bounds.
        if top_left_x < 0 or top_left_y < 0 or height < 1 or width < 1:
            # print('Could not extract bounding box ' + str(image_num));
            counter = counter + 1;
            continue;

        if len(marker_masks) == 0:
            # print('Could not extract marker box ' + str(image_num));
            counter = counter + 1;
            continue;

        # Load image.
        image_name = image_format % image_num;
        image_fullname = os.path.join(image_dir, image_name);
        cv_img = cv2.imread(image_fullname);
        full_mask = np.zeros(cv_img.shape[:2], np.uint8);

        # Histograms for GrabCut.
        bgdModel = np.zeros((1,65),np.float64);
        fgdModel = np.zeros((1,65),np.float64);

        # Run GrabCut using the rect on original image.
        start = time.time();
        cv2.grabCut(cv_img, full_mask, rect, bgdModel, fgdModel,  \
                    kNumGrabCutIters, cv2.GC_INIT_WITH_RECT);
        timer_list.append(time.time() - start);

        ## DEBUG
        # Reshape for concatenation.
        full_mask = np.where((full_mask==2) | (full_mask==0), \
                             0, 1).astype('uint8') * 255;
        full_mask = full_mask[:, :, np.newaxis];
        full_mask = np.concatenate((full_mask, full_mask, full_mask), \
                                            axis=2);
        # Concat the two images
        b,g,r = cv2.split(cv_img);
        rgb_img = cv2.merge([r,g,b]);
        stitched_img_show = np.hstack((rgb_img, full_mask));

        plt.imshow(stitched_img_show);
        plt.show(block=False);
        wait();
        ## End DEBUG

        # Crop image.
        crop_img = cv_img[top_left_y : top_left_y + height, \
                          top_left_x : top_left_x + width ];
        # Mask for combining returned masks from OpenCV.
        final_mask = np.zeros(crop_img.shape[:2], np.uint8);


        # Run OpenCV.
        for marker_mask in marker_masks:
            print( "size crop_img: " + str(crop_img.shape));
            print("mask shape: " + str(marker_mask.shape));

            # Create Mats for opencv.
            start = time.time();
            tmp_mask, tmp_bgd, tmp_fgd = cv2.grabCut(crop_img, marker_mask,  \
                                 None, bgdModel, fgdModel, kNumGrabCutIters, \
                                 cv2.GC_INIT_WITH_MASK);
            timer_list.append(time.time() - start);

            # Set foreground_pixel = 0
            tmp_mask = np.where((mask==2) | (mask==0), 0, 1).astype('uint8');

            # Add to final mask.
            final_mask = final_mask + tmp_mask;

        final_mask = np.where((final_mask > 0), 1, 0).astype('uint8');
        final_mask = final_mask * 255;

        # Reshape returned mask for concatenation.
        final_mask = final_mask[:, :, np.newaxis];
        final_mask = np.concatenate((final_mask, final_mask, final_mask), \
                                    axis=2);

        # Concat the two images
        b,g,r = cv2.split(cv_img);
        rgb_img = cv2.merge([r,g,b]);
        stitched_img_show = np.hstack((rgb_img, final_mask));
        stitched_img_save = np.hstack((cv_img, final_mask));

        ## Show the image.
        # plt.imshow(stitched_img_show);
        # plt.show(block=False);

        # Save the image.
        outfile = grabcut_format % image_num;
        outfullfile = os.path.join(output_dir, outfile);
        cv2.imwrite(outfullfile, stitched_img_save);

        wait();

        counter = counter + 1;
        print(('%.2f' % (float(counter) / total_iters * 100)) + ' %', end='\r');
        sys.stdout.flush();

    print('Timing Statistics: ');
    print('mean: ', np.average(timer_list));
    print('std-dev: ', np.std(timer_list));
    print('min: ', np.min(timer_list));
    print('max: ', np.max(timer_list));
Пример #51
0
pt4 = (200, 300)
rec2 = pt3 + pt4

#img4 = cv.line(img1, pt1, pt2,  (255, 0, 0), 3)
#img5 = cv.line(img2, pt3, pt4,  (255, 0, 0), 3)

#cv.imshow("1", img4)
#cv.imshow("2", img5)

mask1 = np.zeros(img1.shape[:2], np.uint8)
mask2 = np.zeros(img2.shape[:2], np.uint8)

bgdModel = np.zeros((1, 65), np.float64)
fgdModel = np.zeros((1, 65), np.float64)

cv.grabCut(img1, mask1, rec1, bgdModel, fgdModel, 5, cv.GC_INIT_WITH_RECT)
mask1_2 = np.where((mask1 == 2) | (mask1 == 0), 0, 1).astype('uint8')
img1 = img1 * mask1_2[:, :, np.newaxis]
#cv.imshow("4", img1)

cv.grabCut(img2, mask2, rec2, bgdModel, fgdModel, 5, cv.GC_INIT_WITH_RECT)
mask2_2 = np.where((mask2 == 2) | (mask2 == 0), 0, 1).astype('uint8')
img2 = img2 * mask2_2[:, :, np.newaxis]
#cv.imshow("5", img2)

img1 = img1.astype(float)
img2 = img2.astype(float)

person = cv.add(img1, img2)
#cv.imwrite("images/result99.jpg", person)
alpha = person
            bbox[0] = int(float(bbox[0]) * im.shape[0])
            bbox[2] = int(float(bbox[2]) * im.shape[0])
            bbox[1] = int(float(bbox[1]) * im.shape[1])
            bbox[3] = int(float(bbox[3]) * im.shape[1])
            t_mask = np.zeros((512, 512, 1), np.uint8)
            #print(bbox)
            cv2.rectangle(mask, (bbox[0], bbox[1]), (bbox[2], bbox[3]), (255),
                          -1)
            cv2.rectangle(t_mask, (bbox[0], bbox[1]), (bbox[2], bbox[3]),
                          (255), -1)

            grab_mask = np.zeros((512, 512, 1), np.uint8)
            grab_mask[t_mask == 255] = 1

            preproc_mask, bgdModel, fgdModel = cv2.grabCut(
                im, grab_mask, None, bgdModel, fgdModel, 5,
                cv2.GC_INIT_WITH_MASK)
            preproc_mask = np.where((preproc_mask == 2) | (preproc_mask == 0),
                                    0, 1).astype('uint8')

            temp = np.ones((im.shape[0], im.shape[1], 1), np.uint8)
            temp = temp * preproc_mask[:, :]  #,np.newaxis]
            #cv2.imshow('scrab', temp*255)#*255)
            mask_nonzero = np.where(target_mask == 0, 1, 0)
            #target_mask= target_mask + temp * mask_nonzero[:, :]
            target_mask[:, :,
                        target_class] = target_mask[:, :,
                                                    target_class] + temp[:, :,
                                                                         0]
            #cv2.imshow('scrab_temp', target_mask[:,:,target_class]*255)#*255)
"""

import cv2
import numpy as np

resim = cv2.imread("resim.jpg")

mask = np.zeros(resim.shape[:2], np.uint8)

bgdModel = np.zeros((1, 65), dtype=np.float64)
fgdModel = np.zeros((1, 65), dtype=np.float64)
100, 0, 300, 300
rect = (100, 0, 600, 5550)
80, 0, 300, 550  #agac
cv2.grabCut(resim, mask, rect, bgdModel, fgdModel, 5, cv2.GC_INIT_WITH_RECT)
mask2 = np.where((mask == 0) | (mask == 2), 0, 1).astype(np.uint8)

resim = resim * mask2[:, :, np.newaxis]

cv2.imshow("dizi resmi", resim)

cv2.waitKey(0)
cv2.destroyAllWindows()

#
"""
ders 18

keskinleştirme laplacian
resim
def main(input_dir, output_dir):
    input_path = Path(input_dir)
    output_path = Path(output_dir)

    if not input_path.exists():
        raise ValueError('Input directory not found. Please ensure it exists.')

    if not output_path.exists():
        output_path.mkdir(parents=True)

    wnd_name = "Labeling tool"
    io.named_window(wnd_name)
    io.capture_mouse(wnd_name)
    io.capture_keys(wnd_name)

    #for filename in io.progress_bar_generator (Path_utils.get_image_paths(input_path), desc="Labeling"):
    for filename in Path_utils.get_image_paths(input_path):
        filepath = Path(filename)

        if filepath.suffix == '.png':
            dflimg = DFLPNG.load(str(filepath))
        elif filepath.suffix == '.jpg':
            dflimg = DFLJPG.load(str(filepath))
        else:
            dflimg = None

        if dflimg is None:
            io.log_err("%s is not a dfl image file" % (filepath.name))
            continue

        lmrks = dflimg.get_landmarks()
        lmrks_list = lmrks.tolist()
        orig_img = cv2_imread(str(filepath))
        h, w, c = orig_img.shape

        mask_orig = LandmarksProcessor.get_image_hull_mask(
            orig_img.shape, lmrks).astype(np.uint8)[:, :, 0]
        ero_dil_rate = w // 8
        mask_ero = cv2.erode(
            mask_orig,
            cv2.getStructuringElement(cv2.MORPH_ELLIPSE,
                                      (ero_dil_rate, ero_dil_rate)),
            iterations=1)
        mask_dil = cv2.dilate(mask_orig,
                              cv2.getStructuringElement(
                                  cv2.MORPH_ELLIPSE,
                                  (ero_dil_rate, ero_dil_rate)),
                              iterations=1)

        #mask_bg = np.zeros(orig_img.shape[:2],np.uint8)
        mask_bg = 1 - mask_dil
        mask_bgp = np.ones(orig_img.shape[:2],
                           np.uint8)  #default - all background possible
        mask_fg = np.zeros(orig_img.shape[:2], np.uint8)
        mask_fgp = np.zeros(orig_img.shape[:2], np.uint8)

        img = orig_img.copy()

        l_thick = 2

        def draw_4_lines(masks_out, pts, thickness=1):
            fgp, fg, bg, bgp = masks_out
            h, w = fg.shape

            fgp_pts = []
            fg_pts = np.array([pts[i:i + 2] for i in range(len(pts) - 1)])
            bg_pts = []
            bgp_pts = []

            for i in range(len(fg_pts)):
                a, b = line = fg_pts[i]

                ba = b - a
                v = ba / npl.norm(ba)

                ccpv = np.array([v[1], -v[0]])
                cpv = np.array([-v[1], v[0]])
                step = 1 / max(np.abs(cpv))

                fgp_pts.append(
                    np.clip(line + ccpv * step * thickness, 0,
                            w - 1).astype(np.int))
                bg_pts.append(
                    np.clip(line + cpv * step * thickness, 0,
                            w - 1).astype(np.int))
                bgp_pts.append(
                    np.clip(line + cpv * step * thickness * 2, 0,
                            w - 1).astype(np.int))

            fgp_pts = np.array(fgp_pts)
            bg_pts = np.array(bg_pts)
            bgp_pts = np.array(bgp_pts)

            cv2.polylines(fgp, fgp_pts, False, (1, ), thickness=thickness)
            cv2.polylines(fg, fg_pts, False, (1, ), thickness=thickness)
            cv2.polylines(bg, bg_pts, False, (1, ), thickness=thickness)
            cv2.polylines(bgp, bgp_pts, False, (1, ), thickness=thickness)

        def draw_lines(masks_steps, pts, thickness=1):
            lines = np.array([pts[i:i + 2] for i in range(len(pts) - 1)])

            for mask, step in masks_steps:
                h, w = mask.shape

                mask_lines = []
                for i in range(len(lines)):
                    a, b = line = lines[i]
                    ba = b - a
                    ba_len = npl.norm(ba)
                    if ba_len != 0:
                        v = ba / ba_len
                        pv = np.array([-v[1], v[0]])
                        pv_inv_max = 1 / max(np.abs(pv))
                        mask_lines.append(
                            np.clip(line + pv * pv_inv_max * thickness * step,
                                    0, w - 1).astype(np.int))
                    else:
                        mask_lines.append(np.array(line, dtype=np.int))
                cv2.polylines(mask,
                              mask_lines,
                              False, (1, ),
                              thickness=thickness)

        def draw_fill_convex(mask_out, pts, scale=1.0):
            hull = cv2.convexHull(np.array(pts))

            if scale != 1.0:
                pts_count = hull.shape[0]

                sum_x = np.sum(hull[:, 0, 0])
                sum_y = np.sum(hull[:, 0, 1])

                hull_center = np.array([sum_x / pts_count, sum_y / pts_count])
                hull = hull_center + (hull - hull_center) * scale
                hull = hull.astype(pts.dtype)
            cv2.fillConvexPoly(mask_out, hull, (1, ))

        def get_gc_mask_bgr(gc_mask):
            h, w = gc_mask.shape
            bgr = np.zeros((h, w, 3), dtype=np.uint8)

            bgr[gc_mask == 0] = (0, 0, 0)
            bgr[gc_mask == 1] = (255, 255, 255)
            bgr[gc_mask == 2] = (0, 0, 255)  #RED
            bgr[gc_mask == 3] = (0, 255, 0)  #GREEN
            return bgr

        def get_gc_mask_result(gc_mask):
            return np.where((gc_mask == 1) + (gc_mask == 3), 1,
                            0).astype(np.int)

        #convex inner of right chin to end of right eyebrow
        #draw_fill_convex ( mask_fgp, lmrks_list[8:17]+lmrks_list[26:27] )

        #convex inner of start right chin to right eyebrow
        #draw_fill_convex ( mask_fgp, lmrks_list[8:9]+lmrks_list[22:27] )

        #convex inner of nose
        draw_fill_convex(mask_fgp, lmrks[27:36])

        #convex inner of nose half
        draw_fill_convex(mask_fg, lmrks[27:36], scale=0.5)

        #left corner of mouth to left corner of nose
        #draw_lines ( [ (mask_fg,0),   ], lmrks_list[49:50]+lmrks_list[32:33], l_thick)

        #convex inner: right corner of nose to centers of eyebrows
        #draw_fill_convex ( mask_fgp, lmrks_list[35:36]+lmrks_list[19:20]+lmrks_list[24:25])

        #right corner of mouth to right corner of nose
        #draw_lines ( [ (mask_fg,0),   ], lmrks_list[54:55]+lmrks_list[35:36], l_thick)

        #left eye
        #draw_fill_convex ( mask_fg, lmrks_list[36:40] )
        #right eye
        #draw_fill_convex ( mask_fg, lmrks_list[42:48] )

        #right chin
        draw_lines([
            (mask_bg, 0),
            (mask_fg, -1),
        ], lmrks[8:17], l_thick)

        #left eyebrow center to right eyeprow center
        draw_lines([
            (mask_bg, -1),
            (mask_fg, 0),
        ], lmrks_list[19:20] + lmrks_list[24:25], l_thick)
        #        #draw_lines ( [ (mask_bg,-1), (mask_fg,0),   ], lmrks_list[24:25] + lmrks_list[19:17:-1], l_thick)

        #half right eyebrow to end of right chin
        draw_lines([
            (mask_bg, -1),
            (mask_fg, 0),
        ], lmrks_list[24:27] + lmrks_list[16:17], l_thick)

        #import code
        #code.interact(local=dict(globals(), **locals()))

        #compose mask layers
        gc_mask = np.zeros(orig_img.shape[:2], np.uint8)
        gc_mask[mask_bgp == 1] = 2
        gc_mask[mask_fgp == 1] = 3
        gc_mask[mask_bg == 1] = 0
        gc_mask[mask_fg == 1] = 1

        gc_bgr_before = get_gc_mask_bgr(gc_mask)

        #io.show_image (wnd_name, gc_mask )

        ##points, hierarcy = cv2.findContours(original_mask,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)
        ##gc_mask = ( (1-erode_mask)*2 + erode_mask )# * dilate_mask
        #gc_mask = (1-erode_mask)*2 + erode_mask
        #cv2.addWeighted(
        #gc_mask = mask_0_27 + (1-mask_0_27)*2
        #
        ##import code
        ##code.interact(local=dict(globals(), **locals()))
        #
        #rect = (1,1,img.shape[1]-2,img.shape[0]-2)
        #
        #
        cv2.grabCut(img, gc_mask, None, np.zeros((1, 65), np.float64),
                    np.zeros((1, 65), np.float64), 5, cv2.GC_INIT_WITH_MASK)

        gc_bgr = get_gc_mask_bgr(gc_mask)
        gc_mask_result = get_gc_mask_result(gc_mask)
        gc_mask_result_1 = gc_mask_result[:, :, np.newaxis]

        #import code
        #code.interact(local=dict(globals(), **locals()))
        orig_img_gc_layers_masked = (0.5 * orig_img + 0.5 * gc_bgr).astype(
            np.uint8)
        orig_img_gc_before_layers_masked = (0.5 * orig_img +
                                            0.5 * gc_bgr_before).astype(
                                                np.uint8)

        pink_bg = np.full(orig_img.shape, (255, 0, 255), dtype=np.uint8)

        orig_img_result = orig_img * gc_mask_result_1
        orig_img_result_pinked = orig_img_result + pink_bg * (1 -
                                                              gc_mask_result_1)

        #io.show_image (wnd_name, blended_img)

        ##gc_mask, bgdModel, fgdModel =
        #
        #mask2 = np.where((gc_mask==1) + (gc_mask==3),255,0).astype('uint8')[:,:,np.newaxis]
        #mask2 = np.repeat(mask2, (3,), -1)
        #
        ##mask2 = np.where(gc_mask!=0,255,0).astype('uint8')
        #blended_img = orig_img #-\
        #              #0.3 * np.full(original_img.shape, (50,50,50)) * (1-mask_0_27)[:,:,np.newaxis]
        #              #0.3 * np.full(original_img.shape, (50,50,50)) * (1-dilate_mask)[:,:,np.newaxis] +\
        #              #0.3 * np.full(original_img.shape, (50,50,50)) * (erode_mask)[:,:,np.newaxis]
        #blended_img = np.clip(blended_img, 0, 255).astype(np.uint8)
        ##import code
        ##code.interact(local=dict(globals(), **locals()))
        orig_img_lmrked = orig_img.copy()
        LandmarksProcessor.draw_landmarks(orig_img_lmrked,
                                          lmrks,
                                          transparent_mask=True)

        screen = np.concatenate([
            orig_img_gc_before_layers_masked,
            orig_img_gc_layers_masked,
            orig_img,
            orig_img_lmrked,
            orig_img_result_pinked,
            orig_img_result,
        ],
                                axis=1)

        io.show_image(wnd_name, screen.astype(np.uint8))

        while True:
            io.process_messages()

            for (x, y, ev, flags) in io.get_mouse_events(wnd_name):
                pass
                #print (x,y,ev,flags)

            key_events = [ev for ev, in io.get_key_events(wnd_name)]
            for key in key_events:
                if key == ord('1'):
                    pass
                if key == ord('2'):
                    pass
                if key == ord('3'):
                    pass

            if ord(' ') in key_events:
                break

    import code
    code.interact(local=dict(globals(), **locals()))
Пример #55
0
from matplotlib import pyplot as ppl


# Lots of help from...
# http://docs.opencv.org/master/d8/d83/tutorial_py_grabcut.html#gsc.tab=0

input_image, fg_mat, bg_mat, output_image = sys.argv[1], sys.argv[2],sys.argv[3],sys.argv[4]

img_input = cv2.imread(input_image)
img_fg = cv2.imread(fg_mat,0)
img_bg = cv2.imread(bg_mat,0)

mask = np.zeros(img_input.shape[:2],np.uint8)

bgdModel = np.zeros((1,65), np.float64)
fgdModel = np.zeros((1,65), np.float64)

mask[:] = 3
mask[img_bg != 0] = 0
mask[img_fg != 0] = 1

rect = None
cv2.grabCut(img_input, mask, rect, bgdModel, fgdModel, 5, cv2.GC_INIT_WITH_MASK)
mask2 = np.where((mask==2)|(mask==0),0,1).astype('uint8')
img_out = img_input*mask2[:,:,np.newaxis]

# ppl.imshow(img_out)
# ppl.show()

cv2.imwrite(output_image, img_out)
Пример #56
0
# -*- coding: utf-8 -*-
"""
Created on Tue Jun 30 18:13:36 2020

@author: Avinash
"""

import cv2
import numpy as np
import matplotlib.pyplot as plt

newmask = cv2.imread("masked1.jpg", 0)

mask[newmask == 0] = 0
mask[newmask == 1] = 1

mask, bgdModel, fgdModel = cv2.grabCut(img, )
Пример #57
0
# cv2.imshow('img', img)
bgdModel = np.zeros((1, 65), np.float64)
fgdModel = np.zeros((1, 65), np.float64)
mask = np.zeros(img.shape[:2], np.uint8) + cv2.GC_PR_BGD

point = None
flag = True

cv2.namedWindow('image')
cv2.setMouseCallback('image', grabcut, [False, None])

while True:
    cv2.imshow('image', imga)
    cv2.imshow('mask', cv2.multiply(mask2, 255))
    if flag:
        cv2.grabCut(img, mask, None, bgdModel, fgdModel, 5)
        mask2 = np.where((mask == 2) | (mask == 0), 0, 1).astype(np.uint8)
        mask2_not = cv2.subtract(1, mask2)
        img_m = cv2.bitwise_and(img, img, mask=mask2)
        img_m = cv2.cvtColor(img_m, cv2.COLOR_BGR2BGRA)
        img_n = cv2.bitwise_and(gray, gray, mask=mask2_not)
        img_n = cv2.merge([
            img_n, img_n, img_n,
            cv2.add(np.zeros(gray.shape, np.uint8), 255)
        ])
        imga = cv2.add(img_m, img_n)
        flag = False
    if cv2.waitKey(20) == ord('q'):
        break
cv2.destroyAllWindows()
Пример #58
0
def background_removal(image_bytes):

    src = image_bytes
    #src = get_tensor(image_bytes)
    #src = src.numpy()[:, :, :]
    #src = src.transpose(2,0,1)
    #src = src.permute(1,2,0)

    #src1 = np.ascontiguousarray(src, dtype=np.uint8)
    #src2 = np.ascontiguousarray(src, dtype=np.float)

    hsv = cv2.bilateralFilter(src, 15, 50, 50)
    hsv = cv2.cvtColor(hsv, cv2.COLOR_BGR2HSV)

    mask = cv2.inRange(hsv, (18, 70, 0), (86, 225, 255))

    ## slice the green
    imask = mask > 0
    green = np.zeros_like(src, np.uint8)
    green[imask] = src[imask]

    blurred = cv2.GaussianBlur(green, (3, 3), 0)

    blurred_float = blurred.astype(np.float32) / 255.0
    edgeDetector = cv2.ximgproc.createStructuredEdgeDetection(
        r'model.yml/model.yml')
    edges = edgeDetector.detectEdges(blurred_float) * 255.0

    edges_8u = np.asarray(edges, np.uint8)
    edges_8u = cv2.medianBlur(edges_8u, 3)

    def findSignificantContour(edgeImg):
        contours, hierarchy = cv2.findContours(edgeImg, cv2.RETR_TREE,
                                               cv2.CHAIN_APPROX_SIMPLE)
        contours = sorted(contours, key=cv2.contourArea)  # Ascending Order
        largestContour = contours[-1]  # -1 => Largest Area
        return largestContour

    contour = findSignificantContour(edges_8u)
    # Draw the contour on the original image
    contourImg = np.copy(src)
    cv2.drawContours(contourImg, [contour],
                     0, (0, 255, 0),
                     2,
                     cv2.LINE_AA,
                     maxLevel=1)

    mask = np.zeros_like(edges_8u)
    cv2.fillPoly(mask, [contour], 255)

    # calculate sure foreground area by dilating the mask
    mapFg = cv2.erode(mask, np.ones((5, 5), np.uint8), iterations=10)

    # mark inital mask as "probably background"
    # and mapFg as sure foreground
    trimap = np.copy(mask)
    trimap[mask == 0] = cv2.GC_BGD
    trimap[mask == 255] = cv2.GC_PR_BGD
    trimap[mapFg == 255] = cv2.GC_FGD

    bgdModel = np.zeros((1, 65), np.float64)
    fgdModel = np.zeros((1, 65), np.float64)
    rect = (0, 0, mask.shape[0] - 1, mask.shape[1] - 1)
    cv2.grabCut(src, trimap, rect, bgdModel, fgdModel, 5,
                cv2.GC_INIT_WITH_MASK)

    # create mask again
    mask2 = np.where((trimap == cv2.GC_FGD) | (trimap == cv2.GC_PR_FGD), 255,
                     0).astype('uint8')

    contour2 = findSignificantContour(mask2)
    mask3 = np.zeros_like(mask2)
    cv2.fillPoly(mask3, [contour2], 255)

    foreground = np.copy(src).astype(float)
    foreground[mask3 == 0] = 255

    pil_cutout = Image.fromarray(
        cv2.cvtColor(foreground.astype('uint8'), cv2.COLOR_BGR2RGB))

    return (pil_cutout)
Пример #59
0
def background_sub(image):
    """
    This function:
    1. Takes image as input and
    2. Asks user to select ROI by dragging mouse pointer.
    3. Performs background subtraction.
    4. Displaying the updated image.
    5. Saving the processed image in your current directory.

    GrabCut Algorithm is used
    link : https://www.geeksforgeeks.org/python-foreground-extraction-in-an-image-using-grabcut-algorithm/

    :param image: Image on which Background subtraction is to be performed.
    :return:
    """

    # To check if ROI has been selected or not
    global drawn

    # This names the window so we can reference it
    cv2.namedWindow(winname='BG Subractor')
    # Connects the mouse button to our callback function
    cv2.setMouseCallback('BG Subractor', draw_rectangle)

    print("\nSelect ROI from mouse pointer.")

    # Creating mask, background and foregound models for Grabcut Algorithm
    black_mask = np.zeros(image.shape[:2], np.uint8)
    background = np.zeros((1, 65), np.float64)
    foreground = np.zeros((1, 65), np.float64)

    while True:  # Runs forever until we break with Esc key on keyboard

        # If ROI is selected
        if drawn:
            print("\nPerforming Background Subtraction")
            # Using Grabcut Algorithm only when ROI is drawn and saved in
            # variable named rectangle
            cv2.grabCut(image, black_mask, rectangle, background, foreground,
                        5, cv2.GC_INIT_WITH_RECT)

            # mask with 1 and 4 denotes foreground
            # mask with 2 and 0 denotes background so converting the bg pixels into black
            mask2 = np.where((black_mask == 2) | (black_mask == 0), 0,
                             1).astype('uint8')

            # multiplying mask2 with original image so that we can get our resultant
            image = image * mask2[:, :, np.newaxis]

            # For saving the file
            cv2.imwrite('Bg_removed.jpg', image)
            print(f'\nBg_removed.jpg saved in your current directory!')
            print('Great Success!!!')

            # Once the processing has been done setting drawn to False
            drawn = False

        # Shows the resultant image in image window
        cv2.imshow('BG Subractor', image)

        # Press ESC to exit
        if cv2.waitKey(1) & 0xFF == 27:
            break

    # It closes all windows (just in case you have multiple windows called)
    cv2.destroyAllWindows()
!wget "https://raw.githubusercontent.com/PedroHaupenthal/Image-Processing/master/Atividade03/Exercicio01/bmw.jpg" -O "bmw.jpg"

img1 = cv.imread("bmw.jpg")
img1 = cv.cvtColor(img1, cv.COLOR_BGR2RGB)

img2 = img1.copy()
p1 = (100, 194)
p2 = (597, 290)
img2 = cv.rectangle(img2, p1, p2, (255,0,0), 2)

mask = np.zeros(img1.shape[:2], np.uint8)
bgModel = np.zeros((1, 65), np.float64)
fgModel = np.zeros((1, 65), np.float64)
rectangle = p1 + p2

cv.grabCut(img1, 
           mask, 
           rectangle, 
           bgModel, 
           fgModel, 
           5, 
           cv.GC_INIT_WITH_RECT)

filter = np.where ( (mask == 0) | (mask == 2), 0, 1).astype('uint8')
img3 = img1.copy()
img3 = img3 * filter[:, :, np.newaxis]

plt.figure(figsize=(25,25))
plt.subplot(131), plt.imshow(img1)
plt.subplot(132), plt.imshow(img2)
plt.subplot(133), plt.imshow(img3)