debug = True

def __init__(self, imageA, imageA1):

self.A = imageA

self.A1 = imageA1

def quietMode(self):

self.debug = False

def annFromFVs(self):

# [for px in A, get featureVector]

fvs = featureVector.getAllFeatureVectors(self.A,self.A1)

# get dim

print(len(fvs),len(fvs[0]))

dim = len(fvs[0])

self.ann = ANN(dim)

# add these feature vectors to ann

self.ann.addVectors(fvs)

if self.debug:

print("populated the ANN")

self.ann.save()

def annFromFile(self, fsize):

self.ann = ANN(fsize)

self.ann.load("analogies.ann")

if self.debug:

print("Loaded the ANN")

def XYToLinear(self, x, y, imgshape):

return x*imgshape[1]+y

def LinearToXY(self, p, imgshape):

return p/imgshape[1], p%imgshape[1]

def getRandomImageFrom(self, outputShape, imageRef):

image = np.zeros(outputShape)

for i in range(image.shape[0]):

for j in range(image.shape[1]):

x = random.randint(0,imageRef.shape[0]-1)

y = random.randint(0,imageRef.shape[1]-1)

image[i][j] = imageRef[x][y]

self.s[ self.XYToLinear(i,j,image.shape) ] = self.XYToLinear(x,y,imageRef.shape)

# print("b1:",image)

return image

def getRandomPatchImage(self):

alpha = 0.5

image = np.array(self.B)

for i in range(0,image.shape[0],10):

for j in range(0,image.shape[1],10):

x = random.randint(0, self.A1.shape[0]-11)

y = random.randint(0, self.A1.shape[1]-11)

for k in range(0,10):

for l in range(0,10):

if i+k < image.shape[0] and j+l < image.shape[1]:

image[i+k][j+l] = self.A1[x+k][y+l]

self.s[self.XYToLinear(i+k,j+l,image.shape)] = self.XYToLinear(x+k,y+l,self.A1.shape)

else:

pass

image = cv2.addWeighted(image, alpha, self.B, 1-alpha, 0)

print("Done intermediate")

cv2.imwrite("Output/inter1.jpg",image)

return image

def getAnalogy(self, imageB):

self.K = 0.5

self.B = imageB

self.B1 = self.getRandomImageFrom(self.B.shape, self.A1) # self.getRandomPatchImage() # np.zeros(self.B.shape)

self.s = {}

for i in range(self.B.size/3):

if i >= self.A.size/3:

self.s[i] = self.A.size/3-1

else:

self.s[i] = i

self.ashape = self.A.shape

self.bshape = self.B.shape

# self.A = self.A.flatten()

# self.A1 = self.A1.flatten()

# self.B = self.B.flatten()

# self.B1 = self.B1.flatten()

numcoh = 0

numapp = 0

if self.debug:

print("initialized")

print self.A.size/3,self.B.size/3

for i in range(self.bshape[0]):

for j in range(self.bshape[1]):

idx = self.XYToLinear(i,j,self.bshape)

if idx%5000 == 0 and self.debug:

print("loop",idx)

index, which = self.bestMatch(idx)

self.s[idx] = index

x,y = self.LinearToXY(index,self.ashape)

self.s[idx] = index

if which=="app":

numapp = numapp+1

else:

numcoh = numcoh+1

# print x,y

# if x>=self.ashape[0] or y>=self.ashape[1]:

# print "xy out of bounds",x,y,index

# if which == "app":

a1y,a1i,a1q = featureVector.getPixelAsYIQ(self.A1,x,y)

by,bi,bq = featureVector.getPixelAsYIQ(self.B,i,j)

featureVector.setPixelFromYIQ([a1y,bi,bq],self.B1,i,j)

# else:

# a1y,a1i,a1q = featureVector.getPixelAsYIQ(self.B,x,y)

# by,bi,bq = featureVector.getPixelAsYIQ(self.B,i,j)

# featureVector.setPixelFromYIQ([a1y,bi,bq],self.B1,i,j)

# self.B1[i,j] = self.A1[x,y]

# for idx,elem in enumerate(self.B):

# if idx%100000 == 0:

# print("loop",idx)

# self.A = self.A.reshape(self.ashape)

# self.A1 = self.A1.reshape(self.ashape)

# self.B = self.B.reshape(self.bshape)

# self.B1 = self.B1.reshape(self.bshape)

if self.debug:

print numcoh,numapp

return self.B1

def bestMatch(self,q):

p_app, d_app = self.bestApproximateMatch(q)

# return p_app, "app"

p_coh, d_coh = self.bestCoherenceMatch(q)

# # d_app

# # d_coh

if d_coh < d_app*(1+0.5*self.K):

return p_coh, "coh"

else:

return p_app, "app"

def bestApproximateMatch(self, q):

# v = feature at q

x,y = self.LinearToXY(q,self.bshape)

if x>=self.bshape[0] or y>=self.bshape[1]:

print "out of bounds",x,y,q

v = featureVector.getFeatureVectorForRowCol(self.B.reshape(self.bshape),self.B1.reshape(self.bshape),x,y)

p = self.ann.query(v)

x,y = self.LinearToXY(p,self.ashape)

v2 = featureVector.getFeatureVectorForRowCol(self.A.reshape(self.ashape),self.A1.reshape(self.ashape),x,y)

return p, self.getDiff(v,v2)

def bestCoherenceMatch(self, q):

# in nbd of q

x,y = self.LinearToXY(q,self.bshape)

if x>=self.bshape[0] or y>=self.bshape[1]:

print "out of bounds",x,y,q

fvq = featureVector.getFeatureVectorForRowCol(self.B.reshape(self.bshape),self.B1.reshape(self.bshape),x,y)

minNeighbor = None

minDiff = 13*99 # A random high value

#top 3 neighbors

for l in range(-1, 2):

i = (x - 1) % self.bshape[0]

j = (y + l) % self.bshape[1]

r = self.XYToLinear(i,j,self.bshape)

p = self.s[r]

i,j = self.LinearToXY(p, self.ashape)

if i>=self.ashape[0] or j>=self.ashape[1]:

print "neighbor out of bounds",i,j,p

fvij = featureVector.getFeatureVectorForRowCol(self.A.reshape(self.ashape),self.A1.reshape(self.ashape),i,j)

diff = self.getDiff(fvij, fvq)

if diff < minDiff:

minDiff = diff

minNeighbor = self.XYToLinear(i, j, self.ashape)

#left neighbor

i = x;

j = (y-1)%self.bshape[1]

r = self.XYToLinear(i,j,self.bshape)

p = self.s[r]

i,j = self.LinearToXY(p, self.ashape)

fvij = featureVector.getFeatureVectorForRowCol(self.A.reshape(self.ashape),self.A1.reshape(self.ashape),i,j)

diff = self.getDiff(fvij, fvq)

if diff < minDiff:

minDiff = diff

minNeighbor = self.XYToLinear(i, j, self.ashape)

# print(minNeighbor)

return minNeighbor, minDiff

def getDiff(self, fv1, fv2):

diffVec = np.array(fv1) - np.array(fv2)

diffVec = diffVec**2

diff = sum(diffVec)