In [ ]:

    

import menpo.io as mio

image1 = mio.import_builtin_asset.takeo_ppm()
image1.crop_to_landmarks_proportion_inplace(0.3)
image1 = image1.as_greyscale()

image2 = mio.import_builtin_asset.breakingbad_jpg()
image2.crop_to_landmarks_proportion_inplace(0.3)

%matplotlib inline
image2.view_landmarks()


    

In [ ]:

    

import numpy as np

def extract_patches_joan(image, centres, patch_shape, normalize_patches=False):
    # extract patches
    patches = image.extract_patches(centres, patch_size=patch_shape,
                                    as_single_array=False)

    # normalize if asked to
    if normalize_patches:
        for p in range(len(patches)):
            patches[p].normalize_norm_inplace()
    return patches

def vectorize_patches_joan(patches):
    # find lengths
    patch_len = np.prod(patches[0].shape) * patches[0].n_channels
    n_points = len(patches)

    # initialize output matrix
    patches_vectors = np.empty(patch_len * n_points)

    # extract each vector
    for p in range(n_points):
        # find indices in target vector
        i_from = p * patch_len
        i_to = (p + 1) * patch_len

        # store vector
        patches_vectors[i_from:i_to] = patches[p].as_vector()

    return patches_vectors

def vectorize1(patches_list):
    r"""
    Vectorization function A: It vectorizes a given list of patches.
    Returns an ndarray of size (m*n) x 1
    """
    return vectorize_patches_joan(patches_list)

def warp1(image, centres, patch_shape):
    r"""
    Warp function F: It extracts the patches around each shape point
    returns a list with the patches
    """
    return extract_patches_joan(image, centres, patch_shape,
                                normalize_patches=False)

def gradient1(patches):
    r"""
    Returns the gradients of the patches
    n_dims x n_channels x n_points x (w x h)
    """
    n_dims = patches[0].n_dims
    n_channels = patches[0].n_channels
    wh = np.prod(patches[0].shape)
    n_points = len(patches)
    gradients = np.empty((n_dims, n_channels, wh, n_points))
    for k, i in enumerate(patches):
        g = i.gradient().as_vector(keep_channels=True)
        gradients[..., k] = np.reshape(g, (-1, n_channels, n_dims)).T
    gradients = np.rollaxis(gradients, 3, 2)
    return gradients


    

In [ ]:

    

from cvpr15.utils import build_patches_image, vectorize_patches_image
from menpo.image import Image

def warp2(image, centres, patch_shape):
    r"""
    Warp function F: It extracts the patches around each shape point
    returns an image object of size:
    n_points x patch_shape[0] x patch_shape[1] x n_channels
    """
    return build_patches_image(image, centres, patch_shape)

def vectorize2(patches_image):
    r"""
    Vectorization function A: It vectorizes a given patches image.
    Returns an ndarray of size (m*n) x 1
    """
    return vectorize_patches_image(patches_image)

def gradient2(patches):
    r"""
    Returns the gradients of the patches
    n_dims x n_channels x n_points x (w x h)
    """
    n_points = patches.pixels.shape[0]
    h = patches.pixels.shape[1]
    w = patches.pixels.shape[2]
    n_channels = patches.pixels.shape[3]
    
    # initial patches: n_parts x height x width x n_channels
    pixels = patches.pixels
    # move parts axis to end: height x width x n_channels x n_parts
    pixels = np.rollaxis(pixels, 0, pixels.ndim)
    # merge channels and parts axes: height x width x (n_channels * n_parts)
    pixels = np.reshape(pixels, (h, w, -1), order='F')
    # compute and vectorize gradient: (height * width) x (n_channels * n_parts * n_dims)
    g = Image(pixels).gradient().as_vector(keep_channels=True)
    # reshape gradient: (height * width) x n_parts x n_channels x n_dims
    # then trnspose it: n_dims x n_channels x n_parts x (height * width)
    return np.reshape(g, (-1, n_points, n_channels, 2)).T


    

In [ ]:

    

image = image2
patch_shape = (17, 17)
n_channels = image.n_channels


    

In [ ]:

    

i1 = warp1(image, image.landmarks['PTS']['all'], patch_shape)
vec_i1 = vectorize1(i1)
#e1 = vec_i1 - self.appearance_model[0]
nabla_i1 = gradient1(i1)


    

In [ ]:

    

i2 = warp2(image, image.landmarks['PTS']['all'], patch_shape)
vec_i2 = vectorize2(i2)
#e1 = vec_i1 - self.appearance_model[0]
nabla_i2 = gradient2(i2)


    

In [ ]:

    

import numpy as np

print vec_i1.shape, vec_i2.shape, np.array_equal(vec_i1, vec_i2)
print nabla_i1.shape, nabla_i2.shape, np.array_equal(nabla_i1, nabla_i2)


    

In [ ]:

    

%matplotlib inline

k = 37
d = 1
c = 2

m1 = nabla_i1[d, c, k, :].reshape(patch_shape[0], patch_shape[1])
m2 = nabla_i2[d, c, k, :].reshape(patch_shape[0], patch_shape[1])

Image(m1).view()
Image(m2).view_new()


    

In [ ]:

    

%matplotlib inline

k = 37

l = np.prod(patch_shape) * n_channels

from_i = k * l
to_i = (k+1) * l

Image(vec_i1[from_i:to_i].reshape(patch_shape[0], patch_shape[1], n_channels)).view()
Image(vec_i2[from_i:to_i].reshape(patch_shape[0], patch_shape[1], n_channels)).view_new()


    

In [ ]: