def gradientTangents(Gx, Gy): rows, cols = support.getSize(Gx) Tx = support.makeMatrix(rows, cols) Ty = support.makeMatrix(rows, cols) for r in range(0, rows, 1): for c in range(0, cols, 1): vec = support.makeVector(Gx[r, c], Gy[r, c]) tangent = rotateCCW(vec) normaltangent = normalizeVector(tangent) Tx[r, c], Ty[r, c] = normaltangent[0], normaltangent[1] return Tx, Ty
def renderTiles(rows, cols, rectsList): image = support.makeMatrix(rows, cols, 255) for rect in rectsList: rect.draw_tiles(image) return image
def renderDots(rows, cols, rectsList): image = support.makeMatrix(rows, cols, 255) for rect in rectsList: rect.draw_center(image) return image
def renderOutline(rows, cols, rectsList): image = support.makeMatrix(rows, cols, 255) for rect in rectsList: rect.draw_outline(image) return image
def computeP(I): rows, cols = support.getSize(I) P = support.makeMatrix(rows, cols) P[0:rows, 0] = I[0:rows, 0] for r in range(0, rows, 1): for c in range(1, cols, 1): P[r, c] = I[r, c] + P[r, c - 1] return P
def computeQ(P): rows, cols = support.getSize(P) Q = support.makeMatrix(rows, cols) Q[0:rows, 1] = P[0:rows, 0] for r in range(0, rows, 1): for c in range(2, cols, 1): Q[r, c] = P[r, c - 1] + Q[r, c - 1] return Q
def computeField(strokesList, rows, cols): heightMap = support.loadImage(heightMap_f) / 255.0 opacityMap = support.loadImage(opacityMap_f) / 255.0 mapRows, mapCols = support.getSize(heightMap) heightField = support.makeMatrix(rows, cols, 0) colorField = support.makeVecMatrix(rows, cols, 3) # for each stroke print "Total = %d" % len(strokesList) for index, stroke in enumerate(strokesList): ## if index%20 == 0: ## os.system("pkill -f display") ## support.showImage( heightField ) if index % 100 == 0: print index samples = stroke.length # compute corner point r and coordinate system dirL = stroke.end2 - stroke.end1 dirW = rotateCW(dirL) dirL = impress.normalizeVector(dirL) dirW = impress.normalizeVector(dirW) r = stroke.end1 - dirW * (stroke.width / 2) # step sizes stepL = float(stroke.length) / samples stepW = float(stroke.width) / samples mapStepL = float(mapCols) / samples mapStepW = float(mapRows) / samples i = 0 while i < samples: j = 0 while j < samples: x = r + dirL * i * stepL + dirW * j * stepW if not impress.isOutOfBounds(rows, cols, x): f = impress.interpolate(x[0], x[1], heightField) map_c = i * mapStepL map_r = j * mapStepW h = impress.interpolate(map_r, map_c, heightMap) t = impress.interpolate(map_r, map_c, opacityMap) x = x.astype(int) heightField[x[0], x[1]] = f * (1 - t) + h * t heightField[x[0], x[1]] += fixedHeight colorField[x[0], x[1]] = colorField[x[0], x[1]] * ( 1 - t) + stroke.color * t j = j + 1 i = i + 1 heightField = normalizeMatrix(heightField) return heightField, colorField
def gradientTangents(Gx, Gy): rows, cols = support.getSize(Gx) zero_matrix = support.makeMatrix(rows, cols) Tx, Ty = zero_matrix, zero_matrix for r in range(0, rows, 1): for c in range(0, cols, 1): vec = support.makeVector(Gx[r, c], Gy[r, c]) tangent = rotateCCW(vec) Tx[r, c], Ty[r, c] = tangent[0], tangent[1] return Tx, Ty
def tessellate(image, pointsList, ETFr, ETFc): rows,cols = support.getSize(image) print("SIZE: %d x %d" % (rows,cols)) drawing = support.makeMatrix(rows,cols,-1) if curveType == 'ETF': growCurveETF(pointsList, drawing, ETFr, ETFc) print("Curve grown!") elif curveType == 'Lorentz': growCurveLorentz(pointsList,drawing) return assignColors(image,drawing)
def makeKernel(*params): if (params[0] == 'prewitt'): Kx = support.makeMatrix([(-1, 0, 1), (-1, 0, 1), (-1, 0, -1)]) Ky = support.makeMatrix([(-1, -1, -1), (0, 0, 0), (1, 1, 1)]) return Kx, Ky elif (params[0] == 'sobel'): Kx = support.makeMatrix([(-1, 0, 1), (-2, 0, 2), (-1, 0, -1)]) Ky = support.makeMatrix([(-1, -2, -1), (0, 0, 0), (1, 2, 1)]) return Kx, Ky elif (params[0] == 'average'): n = params[1] value = 1.0 / (n * n) K = support.makeMatrix(n, n, value) return K elif (params[0] == 'gauss'): n = params[1] sig = params[2] K = support.makeMatrix(n, n) bound = n / 2 r = 0 for y in range(-bound, bound + 1, 1): c = 0 for x in range(-bound, bound + 1, 1): value = 1 / (2 * math.pi * (sig * sig)) * math.exp(-(x * x + y * y) / (2 * sig * sig)) K[r, c] = value c = c + 1 r = r + 1 # Normalize array K = K / np.sum(K) return K
def testCentroid(): M = support.makeMatrix(10, 10, 1) P = stipple.computeP(M) print "p", P Q = stipple.computeQ(P) print "q", Q r, c = stipple.computeCentroid(P, Q, 2, 2, 5, 5) print r, c, "Expect 3.5,3.5" r, c = stipple.computeCentroid(P, Q, 2, 2, 6, 6) print r, c, "Expect 4,4" r, c = stipple.computeCentroid(P, Q, 2, 3, 5, 7) print r, c, "Expect 3.5,5"
def computeGauss(n, sig): K = support.makeMatrix(n,n) bound = n/2 r = 0 for y in range(-bound,bound+1,1): c = 0 for x in range(-bound,bound+1,1): value = 1/(2*math.pi*(sig*sig)) * math.exp(-(x*x+y*y)/(2*sig*sig)) K[r,c] = value c = c+1 r = r+1 # Normalize array K = K / np.sum(K) return K
def renderTSP(rows, cols, rectsList): image = support.makeMatrix(rows, cols, 255) # get vertex list of rect centers rect_centers = [] for rect in rectsList: row, col = rect.get_center() rect_centers.append(Vertex(row, col, "")) dimension = len(rect_centers) # create tour.in using rect_centers f = file("tour.in", "w") print >> f, "NAME tour.in" print >> f, "TYPE TSP" print >> f, "DIMENSION %d" % dimension print >> f, "EDGE_WEIGHT_TYPE : EUC_2D" print >> f, "NODE_COORD_TYPE : TWOD_COORDS" print >> f, "NODE_COORD_SECTION" i = 0 for v in rect_centers: print >> f, "%d %d %d" % (i, v.r, v.c) i = i + 1 f.close() # run the TSP program os.system("tsp_solver -o tour.out tour.in") # read the results from tour.out f = file("tour.out") line = f.readline().strip() line = f.readline() # remove first line pairs = [] while line != "": values = line.split(" ") v0 = rect_centers[int(values[0])] pairs.append((v0.c, v0.r)) line = f.readline() v1 = rect_centers[int(values[1])] pairs.append((v1.c, v1.r)) f.close() # draw a line between all pairs return drawPolyLine(rows, cols, pairs)
def convolve(image, kernel): image_matrix = support.loadImage(image) image_rows, image_cols = support.getSize(image_matrix) kernel_rows = support.getRows(kernel) new_image_rows = image_rows - kernel_rows new_image_cols = image_cols - kernel_rows # A new matrix of zeros of final size of new image new_image = support.makeMatrix(new_image_rows, new_image_cols) # for each row in new image for r in range(0, new_image_rows, 1): end_row = r + kernel_rows # for each col in new image for c in range(0, new_image_cols, 1): # current matrix of image values end_col = c + kernel_rows conveq_matrix = image_matrix[r:end_row, c:end_col] # convolve image values and kernel new_image[r, c] = conveq(conveq_matrix, kernel) return new_image
def convolve(image, kernel): image_matrix = support.loadImage(image) image_rows, image_cols = support.getSize(image_matrix) kernel_rows, kernel_cols = support.getSize(kernel) kernel_rows, kernel_cols = kernel_rows / 2, kernel_cols / 2 # A new matrix of zeros of final size of new image new_image = support.makeMatrix(image_rows, image_cols) # for each row in new image for r in range(kernel_rows, image_rows - kernel_rows, 1): # for each col in new image for c in range(kernel_cols, image_cols - kernel_cols, 1): # current matrix of image values conveq_matrix = image_matrix[r - kernel_rows:r + kernel_rows + 1, c - kernel_cols:c + kernel_cols + 1] # convolve image values and kernel new_image[r, c] = conveq(conveq_matrix, kernel) return new_image[kernel_rows:image_rows - kernel_rows, kernel_cols:image_cols - kernel_cols]
def computeETF(Tx, Ty, G): #EQUATIONS# #Spatial Weight Function # Eq 2 # Return 1 if ||x-y|| < r # 0 otherwise def sWeight(x, y): dist = distBetweenVectors(x, y) if dist < radius: return 1 return 0 # Magnitute Weight Function # Eq 3 # Returns (1/2)(1+tanh[(g^(y)-g^(x))]) # g^(z) - normalized gradient magnitude at z def mWeight(x, y, G): g_hat = normalizeMatrix(G) gx_hat = g_hat[x[0], x[1]] gy_hat = g_hat[y[0], y[1]] return .5 * (1 + math.tanh(N * (gy_hat - gx_hat))) # Direction Weight Function # Eq 4 # Returns |tcur(x) (dot) tcur(y)| # tcur(z) = current normalized tangent vector at z def dWeight(x, y, tcur): tcur_x = tcur[x[0], x[1]] tcur_y = tcur[y[0], y[1]] result = getDotProduct(tcur_x, tcur_y) # absolute value of result (always 0 or positive) if (result < 0): result = -result return result # Phi # Eq 5 # Return 1 if tcur(x) (dot) tcur(y) > 0 # Return -1 otherwise def phi(x, y, tcur): tcur_x = tcur[x[0], x[1]] tcur_y = tcur[y[0], y[1]] result = getDotProduct(tcur_x, tcur_y) if (result < 0): return 1 return -1 rows, cols = support.getSize(Tx) Tx_cur, Ty_cur = Tx, Ty zero_matrix = support.makeMatrix(rows, cols) Tx_new, Ty_new = zero_matrix, zero_matrix for i in range(0, s_factor, 1): print("iteration: %d" % i) # For every pixel in T for r in range(0, rows, 1): for c in range(0, cols, 1): x = support.makeVector(r, c) # For every neighbor of x sum_x = 0 sum_y = 0 # Calculate mask for neighbors of x rn_init = r - radius rn_end = r + radius cn_init = c - radius cn_end = c + radius if rn_init < 0: rn_init = 0 if rn_end > rows: rn_end = rows if cn_init < 0: cn_init = 0 if cn_end > cols: cn_end = cols for rn in range(rn_init, rn_end, 1): for cn in range(cn_init, cn_end, 1): y = support.makeVector(rn, cn) if sWeight(x, y) == 1: mW = mWeight(x, y, G) sum_x = sum_x + phi(x, y, Tx_cur) * Tx_cur[ y[0], y[1]] * mW * dWeight(x, y, Tx_cur) sum_y = sum_y + phi(x, y, Ty_cur) * Ty_cur[ y[0], y[1]] * mW * dWeight(x, y, Ty_cur) #Normalize Vector v = support.makeVector(sum_x, sum_y) normal_v = normalizeVector(v) Tx_new[r, c] = normal_v[0] Ty_new[r, c] = normal_v[1] Tx_cur = Tx_new Ty_cur = Ty_new return Tx_cur, Ty_cur
def computeFDoG(image, Tx, Ty): #VARIABLES# p = 6 * sig_m q = 6 * sig_c #EQUATIONS# # Gsig(x) # Eq 8 def gaussian(t, sig): return 1.0 / (math.sqrt(2 * math.pi) * sig) * math.exp(-(t * t) / (2 * sig * sig)) # f(t) # Eq 7 def filter1d(t): return gaussian(t, sig_c) - p_noise * gaussian(t, sig_s) # F(s) # x is a vector # Eq 6 def filteringFramework(x): r = int(x[0]) # row of x c = int(x[1]) # col of x end = int(p / 2) # t = 0 total_sum = image[r, c] * filter1d(0) # Calculate Direction tan = support.makeVector(Tx[r, c], Ty[r, c]) direct = rotateCW(tan) # Loop forwards (t=1,2,3,4) z = x #print "t forward" for t in range(1, end + 1, 1): z = z + delta_n * direct z_int = z.astype(int) #print(z_int) if isOutOfBounds(rows, cols, z_int): #print "out of bounds 1", z_int, t break total_sum = total_sum + image[z_int[0], z_int[1]] * filter1d(t) # Loop backwards (t=1,2,3,4) z = x #print "t backward" for t in range(1, end + 1, 1): z = x - delta_n * direct z_int = z.astype(int) #print(z_int) if isOutOfBounds(rows, cols, z_int): #print "out of bounds 2", z_int, t break total_sum = total_sum + image[z_int[0], z_int[1]] * filter1d(t) return total_sum # H(x) # Eq 9 def filterAccumulated(x): rows, cols = support.getSize(Tx) end = int(q / 2) # s = 0 total_sum = gaussian(0, sig_m) * filteringFramework(x) z = x # Loop forwards (s=1,2,3,4) #print "s forward" for s in range(1, end + 1, 1): tan = getTangentVector(z) if isZeroVector(tan): break z = z + delta_m * tan z_int = z.astype(int) #print(z_int) if isOutOfBounds(rows, cols, z_int): #print "out of bounds 3", z_int, s break total_sum = total_sum + gaussian(s, sig_m) * filteringFramework(z) # Loop backwards z = x #print "s backward" for s in range(1, end + 1, 1): tan = getTangentVector(z) if isZeroVector(tan): break z = z - delta_m * tan z_int = z.astype(int) #print(z_int) if isOutOfBounds(rows, cols, z_int): #print "out of bounds 4", z_int, s break total_sum = total_sum + gaussian(s, sig_m) * filteringFramework(z) return total_sum # OTHER FUNCTIONS # # Returns the tangent vector at z, or zero vector if out of bounds def getTangentVector(z): z = z.astype(int) return support.makeVector(Tx[z[0], z[1]], Ty[z[0], z[1]]) rows, cols = support.getSize(image) line_image = support.makeMatrix(rows, cols) print(support.getSize(line_image)) for r in range(0, rows, 1): print "Row", r for c in range(0, cols, 1): x = support.makeVector(r, c) Hx = filterAccumulated(x) #print (Hx) if Hx > 0: line_image[r, c] = 1 else: line_image[r, c] = 1 + np.tanh(Hx) ## if Hx < 0 and 1 + np.tanh(Hx) < thresh: ## line_image[r,c] =0 ## else: ## line_image[r,c] = 1 return line_image
def computeETF(Tx, Ty, G): #EQUATIONS# #Spatial Weight Function # Eq 2 # Return 1 if ||x-y|| < r # 0 otherwise def sWeight(x, y): dist = getVectorLength(x - y) if dist < radius: return 1 return 0 # Magnitute Weight Function # Eq 3 # Returns (1/2)(1+tanh[(g^(y)-g^(x))]) # g^(z) - normalized gradient magnitude at z def mWeight(x, y): gx_hat = G[x[0], x[1]] gy_hat = G[y[0], y[1]] return .5 * (1 + math.tanh(eta * (gy_hat - gx_hat))) # Direction Weight Function # Eq 4 # Returns |tcur(x) (dot) tcur(y)| # tcur(z) = current normalized tangent vector at z def dWeight(x, y): T_at_x = support.makeVector(Tx[x[0], x[1]], Ty[x[0], x[1]]) T_at_y = support.makeVector(Tx[y[0], y[1]], Ty[y[0], y[1]]) result = getDotProduct(T_at_x, T_at_y) # absolute value of result (always 0 or positive) if (result < 0): result = -result #print(tcur_x, tcur_y) #print(result) return result # Phi # Eq 5 # Return 1 if tcur(x) (dot) tcur(y) > 0 # Return -1 otherwise def phi(x, y): T_at_x = support.makeVector(Tx[x[0], x[1]], Ty[x[0], x[1]]) T_at_y = support.makeVector(Tx[y[0], y[1]], Ty[y[0], y[1]]) result = getDotProduct(T_at_x, T_at_y) if (result > 0): return 1 return -1 rows, cols = support.getSize(Tx) Tx_new = support.makeMatrix(rows, cols) Ty_new = support.makeMatrix(rows, cols) print "ETF start" for i in range(0, s_factor, 1): print("iteration: %d" % i) # For every pixel in T for r in range(0, rows, 1): print "Row", r for c in range(0, cols, 1): x = support.makeVector(r, c) sum_x = 0 sum_y = 0 # Calculate mask for neighbors of x rn_init = r - radius rn_end = r + radius cn_init = c - radius cn_end = c + radius # For each neighbor within radius for rn in range(rn_init, rn_end + 1, 1): for cn in range(cn_init, cn_end + 1, 1): y = support.makeVector(rn, cn) if isOutOfBounds(rows, cols, y): break if sWeight(x, y) == 1: mW = mWeight(x, y) dW = dWeight(x, y) phi_eq = phi(x, y) #print(x, y) sum_x = sum_x + phi_eq * Tx[y[0], y[1]] * mW * dW sum_y = sum_y + phi_eq * Ty[y[0], y[1]] * mW * dW #Normalize Vector v = support.makeVector(sum_x, sum_y) normal_v = normalizeVector(v) Tx_new[r, c] = normal_v[0] Ty_new[r, c] = normal_v[1] Tx = Tx_new Ty = Ty_new return Tx, Ty
def computeFDoG(image, Tx, Ty): #VARIABLES# p = 6 * sig_m q = 6 * sig_c #EQUATIONS# # Gsig(x) # Eq 8 def gaussian(t, sig): return 1 / (math.sqrt(2 * math.pi) * sig) * math.exp(-(t * t) / (2 * sig * sig)) # f(t) # Eq 7 def filter1d(t): return gaussian(t, sig_c) - p_noise * gaussian(t, sig_s) # F(s) # x is a vector # Eq 6 def filteringFramework(x, Tx, Ty): r = x[0] # row of x c = x[1] # col of x end = int(q / 2) total_sum = 0 # Calculate Direction tan = support.makeVector(Tx[r, c], Ty[r, c]) direct = rotateCW(tan) # Loop forwards (t=1,2,3,4) init_x = x for t in range(1, end, 1): z = np.add(x, delta_n * direct) z = z.astype(int) total_sum = total_sum + image[z[0], z[1]] * filter1d(t) x = z # Loop backwards (t=1,2,3,4) x = init_x for t in range(1, end, 1): z = np.subtract(x, delta_n * direct) z = z.astype(int) total_sum = total_sum + image[z[0], z[1]] * filter1d(t) x = z # t = 0 return total_sum + image[r, c] * filter1d(0) # H(x) # Eq 9 def filterAccumulated(x, Tx, Ty): r = x[0] # row of x c = x[1] # col of x rows, cols = support.getSize(Tx) end = int(p / 2) total_sum = 0 # Loop forwards (s=1,2,3,4) for s in range(1, end, 1): tan = getTangentVector(Tx, Ty, x) if isZeroVector(tan): break print("Not Zero Vector: loop 1") z = np.add(x, delta_m * tan) z = z.astype(int) if isOutOfBounds(rows, cols, z): break total_sum = total_sum + gaussian(s, sig_m) * filteringFramework( z, Tx, Ty) x = z # Loop backwards x = support.makeVector(r, c) # reset x to s=0 for s in range(1, end, 1): tan = getTangentVector(Tx, Ty, x) if isZeroVector(tan): break print("Not Zero Vector: loop 2") z = np.subtract(x, delta_m * tan) z.astype(int) if isOutOfBounds(rows, cols, z): break total_sum = total_sum + gaussian(s, sig_m) * filteringFramework( z, Tx, Ty) x = z # s = 0 x = support.makeVector(r, c) # reset to s = 0 return gaussian(0, sig_m) * filteringFramework(x, Tx, Ty) # OTHER FUNCTIONS # # Returns the tangent vector at z, or zero vector if out of bounds def getTangentVector(Tx, Ty, z): rows, cols = support.getSize(Tx) T = support.makeVector(Tx[z[0], z[1]], Ty[z[0], z[1]]) T_tan = rotateCW(T) # round answers to integers Tx_tan = int(T_tan[0]) Ty_tan = int(T_tan[1]) return support.makeVector(Tx_tan, Ty_tan) rows, cols = support.getSize(image) line_image = support.makeMatrix(rows, cols) print(support.getSize(line_image)) for r in range(0, rows, 1): print("Row", r) for c in range(0, cols, 1): x = support.makeVector(r, c) Hx = filterAccumulated(x, Tx, Ty) if Hx < 0: line_image[r, c] = 0 else: line_image[r, c] = 1 + np.tanh(Hx) ## if Hx < 0 and 1 + np.tanh(Hx) < thresh: ## line_image[r,c] = 0 ## else: ## line_image[r,c] = 1 return line_image