def convertImage(rowsOut, colsOut, superpixels): result = support.makeVecMatrix(rowsOut * scale, colsOut * scale, 3) for sp in superpixels: r, c = sp.outPos[0], sp.outPos[1] result[r * scale:(r + 1) * scale, c * scale:(c + 1) * scale] = sp.ms return support.lab2rgb(result)
def pixelart(imageRGB, rowsOut, colsOut, K): rowsIn, colsIn = support.getSize(imageRGB) N = rowsOut * colsOut # Number of superpixels M = rowsIn * colsIn # Number of input pixels # Convert the input image to lab space imageLAB = support.rgb2lab(imageRGB) # Initialize superpixels, palette, and temperature superpixels = initSuperPixels(imageLAB, rowsOut, colsOut) palette = initPalette(imageLAB) T = initT(imageLAB) # While (T > Tf) i = 0 while T > Tf: if printProgress: print "Iteration: %d T: %d" % (i, T) # REFINE superpixels with 1 step of modified SLIC refineSuperPixels(imageLAB, superpixels) # ASSOCIATE superpixels to colors in the palette for cluster in palette: cluster.sub1.associate(superpixels, T, palette) cluster.sub2.associate(superpixels, T, palette) # REFINE colors in the palette totalChange = refinePalette(superpixels, palette) if printProgress: print "totalChange", totalChange # If (palette converged) print "Palette size: %d" % len(palette) if totalChange < ep_palette: # REDUCE temperature T = aT T = alpha * T # EXPAND palette expandPalette(palette, K) i += 1 # convert SuperPixels to matrix image result = support.makeVecMatrix(rowsOut * scale, colsOut * scale, 3) for sp in superpixels: r, c = int(sp.outPos[0]), int(sp.outPos[1]) result[r * scale:(r + 1) * scale, c * scale:(c + 1) * scale] = sp.ms # Post-process result[:, :, 1] = result[:, :, 1] * beta result[:, :, 2] = result[:, :, 2] * beta # Convert LAB image to RGB result = support.lab2rgb(result) return result
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 assignColors(image, drawing): #print "assign" rows, cols = support.getSize(drawing) rgbImage = support.makeVecMatrix(rows, cols, 3) for r in range(0, rows, 1): for c in range(0, cols, 1): if drawing[r, c] == -1: total, numPixels = computeColor(r, c, image, drawing) rgbColor = total / numPixels #print(rgbColor * 255) floodRegion(r, c, rgbColor, drawing, rgbImage) return rgbImage * 255
def sphereToRgb(r_mat, t_mat, p_mat): rows, cols = support.getSize(r_mat) x = r_mat * np.sin(t_mat) * np.cos(p_mat) y = r_mat * np.sin(t_mat) * np.sin(p_mat) z = r_mat * np.cos(t_mat) # load x, y, z into new matrix rgb_image = support.makeVecMatrix(rows, cols, 3) rgb_image[:, :, 0] = x rgb_image[:, :, 1] = y rgb_image[:, :, 2] = z return rgb_image
def convertImage(rowsOut, colsOut, superpixels): if not shouldScale: global scale scale = 1 # convert SuperPixels to matrix image result = support.makeVecMatrix(rowsOut*scale, colsOut*scale, 3) for sp in superpixels.itervalues(): r,c = int(sp.outPos[0]), int(sp.outPos[1]) result[r*scale:(r+1)*scale,c*scale:(c+1)*scale] = sp.ms # Post-process result[:,:,1] = result[:,:,1] * beta result[:,:,2] = result[:,:,2] * beta # Convert LAB image to RGB return support.lab2rgb(result)
def computeNormals(heightField): print "Computing normals..." rows, cols = support.getSize(heightField) normalField = support.makeVecMatrix(rows, cols, 3) # For each pixel that's not a boundary pixel for r in range(1, rows - 1, 1): for c in range(1, cols - 1, 1): v = support.makeVector(r, c, heightField[r, c]) # list of neighbor pixels of v (top, left, bottom, right) verts = support.makeVector(support.makeVector(r-1,c, heightField[r-1,c]),\ support.makeVector(r,c-1, heightField[r,c-1]),\ support.makeVector(r+1,c, heightField[r+1,c]),\ support.makeVector(r,c+1, heightField[r,c+1])) vects = verts - v #vector from v to each vertex norms = [cross(vects[0],vects[1]), cross(vects[1],vects[2]),\ cross(vects[2],vects[3]), cross(vects[3],vects[0])] normalField[r, c] = normalizeVector3D(sum(norms)) return normalField