coco dataset init

Author: rohitrango

coco_dataset/alpha.png

@@ -19,7 +19,7 @@
 J, img_paths = get_cropped_images('images/fotolia_processed', num_images, start, end, cropped_gx.shape)
 # get a random subset of J
 idx = [389, 144, 147, 468, 423, 92, 3, 354, 196, 53, 470, 445, 314, 349, 105, 366, 56, 168, 351, 15, 465, 368, 90, 96, 202, 54, 295, 137, 17, 79, 214, 413, 454, 305, 187, 4, 458, 330, 290, 73, 220, 118, 125, 180, 247, 243, 257, 194, 117, 320, 104, 252, 87, 95, 228, 324, 271, 398, 334, 148, 425, 190, 78, 151, 34, 310, 122, 376, 102, 260]
-idx = idx[:50]
+idx = idx[:25]
 # Wm = (255*PlotImage(W_m))
 Wm = W_m - W_m.min()
 
@@ -41,9 +41,7 @@
 Jt = J[idx]
 # now we have the values of alpha, Wm, J
 # Solve for all images
-Wk, Ik, W, alpha = solve_images(Jt, W_m, alpha, W)
-
-
+Wk, Ik, W, alpha1 = solve_images(Jt, W_m, alpha, W)
 # W_m_threshold = (255*PlotImage(np.average(W_m, axis=2))).astype(np.uint8)
 # ret, thr = cv2.threshold(W_m_threshold, 127, 255, cv2.THRESH_BINARY)  
 

coco_dataset/auth.png

@@ -0,0 +1,76 @@
+'''
+This main file is for the Microsoft Coco dataset
+'''
+from src import *
+
+IMAGE_FOLDER = "/media/rohitrango/2EC8DBB2C8DB7715/"
+IMG_LOC = "coco_dataset"
+IMG_PROCESSED_LOC = "coco_dataset_processed"
+
+def get_alpha_matte(watermark, threshold=128):
+	w = np.average(watermark, axis=2)
+	_, w = cv2.threshold(w, threshold, 255, cv2.THRESH_BINARY_INV)
+	return PlotImage(w)
+
+def P(img,e=None):
+    if e is None:
+        plt.imshow(PlotImage(img)); plt.show()
+    else:
+        plt.imshow(PlotImage(img),'gray'); plt.show()
+
+def bgr2rgb(img):
+	return img[:,:,[2, 1, 0]]
+'''
+Ground Truth values
+alpha -> coco_dataset/alpha.png
+copyright -> coco_dataset/copyright.png
+c = .45
+
+Experiments: Threshold for estimating initial alpha -> 153, and then subtract 1 from alpha
+'''
+if __name__ == "__main__":
+	# watermark = cv2.imread('coco_dataset/watermark.png')
+	# alpha = get_alpha_matte(watermark)
+	foldername = os.path.join(IMAGE_FOLDER, IMG_PROCESSED_LOC)
+	gx, gy, gxlist, gylist = estimate_watermark(foldername)
+
+	# est = poisson_reconstruct(gx, gy, np.zeros(gx.shape)[:,:,0])
+	cropped_gx, cropped_gy = crop_watermark(gx, gy)
+	W_m = poisson_reconstruct(cropped_gx, cropped_gy, num_iters=5000)
+
+	# random photo
+	img = cv2.imread(os.path.join(foldername, '000000051008.jpg'))
+	im, start, end = watermark_detector(img, cropped_gx, cropped_gy)
+	num_images = len(gxlist)
+
+	J, img_paths = get_cropped_images(foldername, num_images, start, end, cropped_gx.shape)
+	# get a random subset of J
+	idx = [389, 144, 147, 468, 423, 92, 3, 354, 196, 53, 470, 445, 314, 349, 105, 366, 56, 168, 351, 15, 465, 368, 90, 96, 202, 54, 295, 137, 17, 79, 214, 413, 454, 305, 187, 4, 458, 330, 290, 73, 220, 118, 125, 180, 247, 243, 257, 194, 117, 320, 104, 252, 87, 95, 228, 324, 271, 398, 334, 148, 425, 190, 78, 151, 34, 310, 122, 376, 102, 260]
+	idx = idx[:25]
+	# Wm = (255*PlotImage(W_m))
+	Wm = W_m - W_m.min()
+
+	# get threshold of W_m for alpha matte estimate
+	alph_est = estimate_normalized_alpha(J, Wm, num_images=15, threshold=125, invert=False, adaptive=False)
+	alph = np.stack([alph_est, alph_est, alph_est], axis=2)
+	C, est_Ik = estimate_blend_factor(J, Wm, alph)
+
+	alpha = alph.copy()
+	for i in xrange(3):
+		alpha[:,:,i] = C[i]*alpha[:,:,i]
+
+	# Wm = Wm + alpha*est_Ik
+
+	W = Wm.copy()
+	for i in xrange(3):
+		W[:,:,i]/=C[i]
+
+	Jt = J[idx]
+	# now we have the values of alpha, Wm, J
+	# Solve for all images
+	Wk, Ik, W, alpha1 = solve_images(Jt, W_m, alpha, W)
+	# W_m_threshold = (255*PlotImage(np.average(W_m, axis=2))).astype(np.uint8)
+	# ret, thr = cv2.threshold(W_m_threshold, 127, 255, cv2.THRESH_BINARY)  
+
+
+	

coco_dataset/copyright.png

@@ -110,9 +110,15 @@ def get_xSobel_matrix(m, n, p):
     return coo_matrix((vals, (i, j)), shape=(size, size))
 
 # get estimated normalized alpha matte
-def estimate_normalized_alpha(J, W_m, num_images=30):
+def estimate_normalized_alpha(J, W_m, num_images=30, threshold=170, invert=False, adaptive=False, adaptive_threshold=21, c2=10):
     _Wm = (255*PlotImage(np.average(W_m, axis=2))).astype(np.uint8)
-    ret, thr = cv2.threshold(_Wm, 140, 255, cv2.THRESH_BINARY)
+    if adaptive:
+        thr = cv2.adaptiveThreshold(_Wm, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, adaptive_threshold, c2)
+    else:
+        ret, thr = cv2.threshold(_Wm, threshold, 255, cv2.THRESH_BINARY)
+
+    if invert:
+        thr = 255-thr
     thr = np.stack([thr, thr, thr], axis=2)
 
     num, m, n, p = J.shape
@@ -122,47 +128,13 @@ def estimate_normalized_alpha(J, W_m, num_images=30):
     print("Estimating normalized alpha using %d images."%(num_images))
     # for all images, calculate alpha
     for idx in xrange(num_images):
-        # imgcopy = J[idx].copy()
-        # for i in xrange(iterpatch):
-        #     r = np.random.randint(10)
-        #     x = np.random.randint(m-r)
-        #     y = np.random.randint(n-r)
-        #     imgcopy[x:x+r, y:y+r, :] = thr[x:x+r, y:y+r, :]
         imgcopy = thr
         alph = closed_form_matte(J[idx], imgcopy)
         alpha[idx] = alph
 
     alpha = np.median(alpha, axis=0)
     return alpha
 
-# estimate the blend factor C
-# def estimate_blend_factor(J, W_m, alph, threshold=0.01*255):
-#     alpha_n = alph
-#     S = J.copy()
-#     num_images = S.shape[0]
-#     # for i in xrange(num_images):
-#     #     S[i] = PlotImage(S[i])
-#     # R = (S<=threshold).astype(np.float64)
-#     R = (S>-1).astype(np.float64)
-
-#     est_Ik = S.copy()
-#     # est_Ik[S>threshold] = nan
-#     est_Ik = np.nanmedian(est_Ik, axis=0)
-#     est_Ik[isnan(est_Ik)] = 0
-
-#     alpha_k = R.copy()
-#     beta_k = R*J
-#     for i in xrange(num_images):
-#         alpha_k[i] *= alpha_n*est_Ik
-#         beta_k[i] -= R[i]*W_m
-#     beta_k = np.abs(beta_k)
-#     # we have alpha and beta, solve for c's now
-#     c = []
-#     for i in range(3):
-#         c_i = np.sum(beta_k[:,:,:,i]*alpha_k[:,:,:,i])/np.sum(np.square(alpha_k[:,:,:,i]))
-#         c.append(c_i)
-#     return c
-
 def estimate_blend_factor(J, W_m, alph, threshold=0.01*255):
     K, m, n, p = J.shape
     Jm = (J - W_m)
@@ -219,6 +191,9 @@ def solve_images(J, W_m, alpha, W_init, gamma=1, beta=1, lambda_w=0.005, lambda_
     # Iterations
     for _ in xrange(iters):
 
+        print("------------------------------------")
+        print("Iteration: %d"%(_))
+
         # Step 1
         print("Step 1")
         alpha_gx = cv2.Sobel(alpha, cv2.CV_64F, 1, 0, 3)
@@ -316,4 +291,15 @@ def solve_images(J, W_m, alpha, W_init, gamma=1, beta=1, lambda_w=0.005, lambda_
         plt.draw()
         plt.pause(0.001)
 
-    return (Wk, Ik, W, alpha)
+    return (Wk, Ik, W, alpha)
+
+
+def changeContrastImage(J, I):
+    cJ1 = J[0, 0, :]
+    cJ2 = J[-1, -1, :]
+
+    cI1 = I[0, 0, :]
+    cI2 = I[-1,-1, :]
+
+    I_m = cJ1 + (I-cI1)/(cI2-cI1)*(cJ2-cJ1)
+    return I_m