utils

utils/Generator.py

@@ -0,0 +1,77 @@
+import torch.nn as nn
+import torch
+
+class Generator(torch.nn.Module):
+    def __init__(self, nc_input=1, nc_output=1, ndf=128, nz=128, ngf=128, dropout_rate = 0.5 ):
+        super(Generator, self).__init__()
+
+        self.encoder = nn.Sequential(
+            nn.Dropout(0.05),
+            # input is (nc) x 64 x 64
+            nn.Conv2d(nc_input, ndf, 4, 2, 1, bias=False),
+            nn.LeakyReLU(0.2, inplace=True),
+            # state size. (ndf) x 32 x 32
+            nn.Conv2d(ndf, ndf * 2, 4, 2, 1, bias=False),
+            nn.BatchNorm2d(ndf * 2),
+            nn.LeakyReLU(0.2, inplace=True),
+            # state size. (ndf*2) x 16 x 16
+            nn.Conv2d(ndf * 2, ndf * 4, 4, 2, 1, bias=False),
+            nn.BatchNorm2d(ndf * 4),
+            nn.LeakyReLU(0.2, inplace=True),
+            # state size. (ndf*4) x 8 x 8
+            nn.Conv2d(ndf * 4, ndf * 8, 4, 2, 1, bias=False),
+            nn.BatchNorm2d(ndf * 8),
+            nn.LeakyReLU(0.2, inplace=True),
+            # state size. (ndf*8) x 4 x 4
+            nn.Conv2d(ndf * 8, 1, 1, 1, 0, bias=False),
+            ##nn.Conv2d(1, 1, 5, 1, 0, bias=False),
+            ##nn.Sigmoid()
+        )
+        
+        self.linearEncoder = nn.Sequential(
+            nn.Linear(64, 128)
+        )
+        
+        self.decoder = nn.Sequential(
+            # input is Z, going into a convolution
+            nn.Dropout(0.05),
+            nn.ConvTranspose2d(nz, ngf * 8, 4, 1, 0, bias=False),
+            nn.BatchNorm2d(ngf * 8),
+            nn.ReLU(True),
+            nn.Dropout(dropout_rate),
+            # state size. (ngf*8) x 4 x 4 == 1024 x 4 x 4
+            nn.ConvTranspose2d(ngf * 8, ngf * 4, 4, 2, 1, bias=False),
+            nn.BatchNorm2d(ngf * 4),
+            nn.ReLU(True),
+            nn.Dropout(dropout_rate),            # state size. (ngf*4) x 8 x 8  == 512 x 4 x 4
+            nn.ConvTranspose2d(ngf * 4, ngf * 2, 4, 2, 1, bias=False),
+            nn.BatchNorm2d(ngf * 2),
+            nn.ReLU(True),
+            nn.Dropout(dropout_rate),            # state size. (ngf*2) x 16 x 16 == 256 x 4 x 4
+            nn.ConvTranspose2d(ngf * 2,     ngf, 4, 2, 1, bias=False),
+            nn.BatchNorm2d(ngf),
+            nn.ReLU(True),
+            nn.Dropout(dropout_rate),            # state size. (ngf) x 32 x 32 == 128 x 4 x 4
+            nn.ConvTranspose2d(ngf,     ngf, 4, 2, 1, bias=False),
+            nn.BatchNorm2d(ngf),
+            nn.ReLU(True),
+            nn.ConvTranspose2d(    ngf,      nc_output, 4, 2, 1, bias=False),
+            nn.Sigmoid()
+            # state size. (nc) x 64 x 64
+        )
+
+
+    def forward(self, x):
+        encoded = self.forward_encoder(x)
+        decoded = self.forward_decoder(encoded)
+        return decoded
+    
+    def forward_encoder(self, x):
+        encoded = self.encoder(x).reshape(-1, 64)
+        return self.linearEncoder(encoded).unsqueeze(2).unsqueeze(2)
+    
+    def forward_decoder(self, encoded):
+        decoded = self.decoder(encoded)
+        return decoded
+
+

utils/utils.py

@@ -0,0 +1,280 @@
+
+from torch import randperm, utils
+from torch._utils import _accumulate
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib import offsetbox
+from PIL import Image
+
+class Subset(utils.data.Dataset):
+    """
+    Subset of a dataset at specified indices.
+
+    Arguments:
+        dataset (Dataset): The whole Dataset
+        indices (sequence): Indices in the whole set selected for subset
+    """
+    def __init__(self, dataset, indices):
+        self.dataset = dataset
+        self.indices = indices
+
+    def __getitem__(self, idx):
+        return self.dataset[self.indices[idx]]
+
+    def __len__(self):
+        return len(self.indices)
+
+
+
+def random_split(dataset, lengths):
+    """
+    Randomly split a dataset into non-overlapping new datasets of given lengths.
+
+    Arguments:
+        dataset (Dataset): Dataset to be split
+        lengths (sequence): lengths of splits to be produced
+    """
+    if sum(lengths) != len(dataset):
+        raise ValueError("Sum of input lengths does not equal the length of the input dataset!")
+
+    indices = randperm(sum(lengths))
+    return [Subset(dataset, indices[offset - length:offset]) for offset, length in zip(_accumulate(lengths), lengths)]
+
+# Quizas deberia eliminar 3d o limpiar
+def plot_embedding(X, merged, title = None, classes=11., showimage=True, distPl=0.006, onlyRoman=False):
+    x_min, x_max = np.min(X, 0), np.max(X, 0)
+    X = (X - x_min) / (x_max - x_min)
+    
+    plt.figure()
+    ax = plt.subplot(111)
+    ax.set_facecolor('xkcd:white')
+    """
+    for i in range(X.shape[0]):
+        plt.text(X[i, 0], X[i, 1], str(merged.iloc[i][1]),
+                 color=plt.cm.Set1(int(merged.iloc[i][1]) / float(classes)),
+                 fontdict={'weight': 'bold', 'size': 9})
+    """
+    """
+    for i in range(X.shape[0]):
+        if int(merged.iloc[i][1]) == 22:
+            plt.plot([X[i, 0]], [X[i, 1]], 'X', c="black", markersize=10)
+            plt.plot([X[i, 0]], [X[i, 1]], 'X', c='black', markersize=8)
+        else:
+            plt.plot([X[i, 0]], [X[i, 1]], 'o', c="black", markersize=6)
+            plt.plot([X[i, 0]], [X[i, 1]], 'o',c=plt.cm.Set3(int(merged.iloc[i][1])), markersize=4)
+    """
+  
+    
+    if showimage and hasattr(offsetbox, 'AnnotationBbox'):
+        shown_images = np.array([[1., 1.]])
+        for i in range(merged.shape[0]):           
+            dist = np.sum((X[i] - shown_images) ** 2, 1)
+            
+            
+            if np.min(dist) < distPl: #6e-4:
+                # don't show points that are too close
+                continue
+
+            shown_images = np.r_[shown_images, [X[i]]]
+            image =  Image.open(merged.iloc[i][0])
+            inverted_image = image #PIL.ImageOps.invert(image)
+            inverted_image.thumbnail((40, 40), Image.ANTIALIAS)
+            
+            props = dict(facecolor=plt.cm.Set3(int(merged.iloc[i][1])), alpha=1, lw=1)
+            imagebox = offsetbox.AnnotationBbox(
+                offsetbox.OffsetImage(inverted_image, cmap=plt.cm.gray),
+                X[i]+0.030, bboxprops=props)
+            ax.add_artist(imagebox)
+    plt.xticks([]), plt.yticks([])
+    #cbar = plt.colorbar()
+    if title is not None:
+        plt.title(title)
+
+
+import numpy as np
+import cv2
+from skimage import measure
+def landmarks(img_grey, N = 50):
+    thresh = 200
+    ret,img = cv2.threshold(img_grey, thresh, 255, cv2.THRESH_BINARY)
+    if img.ndim == 2:
+        img_s = np.ones((img.shape[0] + 100, img.shape[0] + 100)) * 255
+        img_s[50:-50, 50:-50] = img
+        img = img_s
+        contours = measure.find_contours(img, 0.5)
+        #fig = plt.figure(figsize=(7, 7))
+        #ax = fig.add_subplot(111)
+        #ax.imshow(img, interpolation='nearest', cmap=plt.cm.gray)
+
+        # for n, contour in enumerate(contours):
+        #print(contours[0].shape)
+        contour = contours[0]
+        #ax.plot(contour[:, 1], contour[:, 0], linewidth=5)
+        # resample_contour = contour[np.random.choice(contour.shape[0], 150, replace=False), :]
+        resample_contour = interpcurve(N,  contour[:, 0],  contour[:, 1])
+        # print(resample_contour[:4, 0], resample_contour[:4, 1], resample_contour[:4].ravel())
+        #df_semilandmarks.loc[index] = [id_name, classe_name] + list(resample_contour.ravel())
+        #ax.plot(resample_contour[:, 1], resample_contour[:, 0], 'om', linewidth=5)
+        #plt.savefig('output/landmarked_'+id_name)
+        #plt.show()
+        return resample_contour
+    
+def interpcurve(N, pX, pY):
+    #equally spaced in arclength
+    N = np.transpose(np.linspace(0, 1, N))
+    #how many points will be uniformly interpolated?
+    nt = N.size
+
+    #number of points on the curve
+    n = pX.size
+    pxy = np.array((pX, pY)).T
+    p1 = pxy[0,:]
+    pend = pxy[-1,:]
+    last_segment = np.linalg.norm(np.subtract(p1, pend))
+    epsilon= 10 * np.finfo(float).eps
+
+    #IF the two end points are not close enough lets close the curve
+    if last_segment > epsilon * np.linalg.norm(np.amax(abs(pxy), axis=0)):
+        pxy = np.vstack((pxy, p1))
+        nt = nt + 1
+
+    pt = np.zeros((nt, 2))
+
+    #Compute the chordal arclength of each segment.
+    chordlen = (np.sum(np.diff(pxy, axis=0) ** 2, axis=1)) ** (1 / 2)
+    #Normalize the arclengths to a unit total
+    chordlen = chordlen / np.sum(chordlen)
+    #cumulative arclength
+    cumarc = np.append(0, np.cumsum(chordlen))
+
+    tbins= np.digitize(N, cumarc) # bin index in which each N is in
+
+    #catch any problems at the ends
+    tbins[np.where(tbins<=0 | (N<=0))]=1
+    tbins[np.where(tbins >= n | (N >= 1))] = n - 1      
+
+    s = np.divide((N - cumarc[tbins]), chordlen[tbins-1])
+    pt = pxy[tbins,:] + np.multiply((pxy[tbins,:] - pxy[tbins-1,:]), (np.vstack([s]*2)).T)
+
+    return pt 
+
+
+
+def segmentation(img, vertical):
+    img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+    #plt.imshow(img, cmap=plt.cm.gray)
+    if vertical:
+        background_0 = np.ones((img.shape)) + 254
+        background_0[img.shape[0]//2:, :] = img[img.shape[0]//2:,:] 
+        #plt.imshow(background_0, cmap=plt.cm.gray)
+        #fig = plt.figure()
+
+        background_1 = np.ones((img.shape)) + 254
+        background_1[:img.shape[0]//2, :] = img[:img.shape[0]//2,:] 
+        #plt.imshow(background_1, cmap=plt.cm.gray)
+        #fig = plt.figure()
+         
+
+    else:
+        background_1 = np.ones((img.shape)) + 254
+        background_1[:, :img.shape[0]//2] = img[:,:img.shape[0]//2] 
+        #plt.imshow(background_0, cmap=plt.cm.gray)
+        #fig = plt.figure()
+
+
+        background_0 = np.ones((img.shape)) + 254
+        background_0[:, img.shape[0]//2:] = img[:,img.shape[0]//2:] 
+        #plt.imshow(background_1, cmap=plt.cm.gray)
+        #fig = plt.figure()
+    
+    return background_0, background_1
+
+def plotTwoImages(img_1, img_2, title):
+    plt.figure(figsize=(12,5))
+    plt.subplot(1, 2, 1)
+
+    plt.imshow(img_1)
+    plt.title(title[0])
+    plt.xticks([])
+    plt.yticks([])
+    plt.subplot(1, 2, 2)
+    
+    plt.imshow(img_2)
+    plt.xticks([])
+    plt.yticks([])
+    plt.title(title[1])
+    
+def plotLandmarks(landmarks_img_1_part_2, landmarks_img_2_part_2, title, comparateShow=True):
+    plt.figure(figsize=(12,5))
+    size = (1, 2)
+    if comparateShow:
+        size = (1, 3)
+    plt.subplot( size[0],  size[1], 1)
+    plt.plot(landmarks_img_1_part_2[:,0], landmarks_img_1_part_2[:,1], '-o')
+    plt.fill(landmarks_img_1_part_2[:, 0] , landmarks_img_1_part_2[:, 1], 'k')
+    plt.title(title[0])
+    plt.xticks([])
+    plt.yticks([])
+
+
+    plt.subplot(size[0], size[1], 2)
+    plt.plot(landmarks_img_2_part_2[:,0], landmarks_img_2_part_2[:,1], '-o')
+    plt.fill(landmarks_img_2_part_2[:, 0] , landmarks_img_2_part_2[:, 1], 'k')
+    plt.title(title[1])
+    plt.xticks([])
+    plt.yticks([])
+
+
+    if comparateShow:
+        plt.subplot(size[0], size[1], 3)
+        plt.plot(landmarks_img_1_part_2[:,0], landmarks_img_1_part_2[:,1], '-o')
+        plt.plot(landmarks_img_2_part_2[:,0], landmarks_img_2_part_2[:,1], '-o')
+        plt.title(title[2])
+        plt.xticks([])
+        plt.yticks([])
+
+def plotLandmarks2(landmarks_img_1_part_2, landmarks_img_2_part_2, title, comparateShow=True):
+    plt.figure(figsize=(12,5))
+    fig, (ax1) = plt.subplots(1, 1, figsize=(12,5))
+    ax1.axis("off")
+    landmarks_img_1_part_2 = landmarks_img_1_part_2 * -1
+    landmarks_img_2_part_2 = landmarks_img_2_part_2 * -1
+    ax1.plot(landmarks_img_1_part_2[:,1], landmarks_img_1_part_2[:,0], '-o')
+    ax1.plot(landmarks_img_2_part_2[:,1], landmarks_img_2_part_2[:,0], '-o')
+    plt.title(title[2])
+    ax1.set_aspect(2)
+    plt.xticks([])
+    plt.yticks([])
+    
+
+def plotLandmarksItem(fig, ax1, landmarks_img_1_part_2, landmarks_img_2_part_2, title, comparateShow=True):
+    ax1.axis("off")
+    landmarks_img_1_part_2 = landmarks_img_1_part_2 * -1
+    landmarks_img_2_part_2 = landmarks_img_2_part_2 * -1
+    ax1.plot(landmarks_img_1_part_2[:,1], landmarks_img_1_part_2[:,0], '-o')
+    ax1.plot(landmarks_img_2_part_2[:,1], landmarks_img_2_part_2[:,0], '-o')
+    ax1.set_title(title)
+    ax1.set_aspect(1)
+    
+
+def plotLandmarksALL(img_0, img_1, landmarks_img_1_part_1, landmarks_img_2_part_1, landmarks_img_1_part_2, landmarks_img_2_part_2, title):
+    plt.figure(figsize=(12,5))
+    fig, (ax0, ax1, ax2, ax3) = plt.subplots(1, 4, figsize=(12,5))
+    ax0.axis("off")
+    ax0.set_title('INPUT')
+    ax3.axis("off")
+    ax3.set_title('OUTPUT')
+    plt.xticks([])
+    plt.yticks([])
+    ax0.imshow(img_0)
+    plotLandmarksItem(fig, ax1, landmarks_img_1_part_1, landmarks_img_2_part_1, title[0])
+    plotLandmarksItem(fig, ax2, landmarks_img_1_part_2, landmarks_img_2_part_2, title[1])
+    ax3.imshow(img_1)
+    plt.xticks([])
+    plt.yticks([])
+
+
+
+
+if __name__ == "__main__":
+    pass