def lineDrawing(image):
# load image and create slightly smaller image due to gradients being smaller
image_mat = support.loadImage(image)
r, c = support.getSize(image_mat)
image_mat = image_mat[1:r - 1, 1:c - 1]
#print(image_mat[0:5,0:5])
#image_mat = image_mat / 255
#print(image_mat[0:5,0:5])
Kx, Ky = utils.makeKernel('sobel')
Kx, Ky = normalizeMatrix(Kx), normalizeMatrix(Ky)
Gx, Gy, G, D = utils.getEdges(image, Kx, Ky)
Tx, Ty = gradientTangents(Gx, Gy)
print(Tx[0:10, 0:10])
print(Ty[0:10, 0:10])
Tx_p, Ty_p = computeETF(Tx, Ty, G)
print(Tx_p[0:10, 0:10])
print(Ty_p[0:10, 0:10])
print("Saving...")
support.saveImage(Tx, "Tx_p_test")
support.saveImage(Ty, "Ty__p_test")
print("Saved")
return computeFDoG(image_mat, Tx_p, Tx_p)
def restoreRGB(image, mask):
# split the image into spherical coordinates
r, theta, phi = rgbToSphere(image)
# Make a copy of the matrices
rNew = r[:]
tNew = theta[:]
pNew = phi[:]
# For a certain amount of time run inpaint algorithm
for i in range(0, T + 1, 1):
# inpaint for each sphere matrix
inpaint(r, rNew, mask)
inpaint(theta, tNew, mask)
inpaint(phi, pNew, mask)
# curImage = newImage, newImage = curImage
r, rNew = rNew, r
theta, tNew = tNew, theta
phi, pNew = pNew, phi
# Every so many iterations save the result
if i % step == 0:
rgb_image = sphereToRgb(rNew, tNew, pNew)
support.saveImage(rgb_image, "rgb-%s-%04d.png" % (imgName, i))
#support.showImage(rgb_image)
return sphereToRgb(rNew, tNew, pNew)
def testTiffany(): #500/2000
image = support.loadImage('tiffany.pgm')
resultPoints, resultCells = stipple.stipple(image)
image = support.loadImageRGB('tiffany.png')
image = image / 255
image = colorutils.assignColors(image, resultCells)
#support.showImage(image)
support.saveImage(image, "tiffany_2000_0.65")
def testTable(): #1500/5000
image = support.loadImage('table.pgm')
resultPoints, resultCells = stipple.stipple(image)
image = support.loadImageRGB('table.png')
image = image / 255
image = colorutils.assignColors(image, resultCells)
#support.showImage(image)
support.saveImage(image, "table_1500_0.65")
def testEagle(): # 500/2000
image = support.loadImage('eagle.pgm')
resultPoints, resultCells = stipple.stipple(image)
image = support.loadImageRGB('eagle.png')
image = image / 255
image = colorutils.assignColors(image, resultCells)
#support.showImage(image)
support.saveImage(image, "eagle_2000_0.5")
def restoreGray(image, mask):
# Make a copy of the image
newImage = image[:]
support.showImage(newImage)
# For a certain amount of time run inpaint algorithm
for i in range(0, T + 1, 1):
inpaint(image, newImage, mask)
image, newImage = newImage, image
# Every so many iterations save the result
if i % step == 0:
support.saveImage(newImage, "%s-%04d.png" % (imgName, i))
support.showImage(newImage)
return newImage
def testRenderTiles():
result = halftone.halftone("monalisa.pgm", 12, halftone.renderTiles)
support.saveImage(result, "monalisa_tiles")
result = halftone.halftone("einstein.pgm", 12, halftone.renderTiles)
support.saveImage(result, "einstein_tiles")
result = halftone.halftone("table.pgm", 12, halftone.renderTiles)
support.saveImage(result, "table_tiles")
result = halftone.halftone("butterfly.pgm", 14, halftone.renderTiles)
support.saveImage(result, "butterfly_tiles")
def testRenderDots():
result = halftone.halftone("monalisa.pgm", 14, halftone.renderDots)
support.saveImage(result, "monalisa_dots")
result = halftone.halftone("einstein.pgm", 14, halftone.renderDots)
support.saveImage(result, "einstein_dots")
result = halftone.halftone("table.pgm", 14, halftone.renderDots)
support.saveImage(result, "table_dots")
result = halftone.halftone("butterfly.pgm", 14, halftone.renderDots)
support.saveImage(result, "butterfly_dots")
def testRenderOutline():
result = halftone.halftone("monalisa.pgm", 12, halftone.renderOutline)
support.saveImage(result, "monalisa_outl")
result = halftone.halftone("einstein.pgm", 12, halftone.renderOutline)
support.saveImage(result, "einstein_outl")
result = halftone.halftone("table.pgm", 12, halftone.renderOutline)
support.saveImage(result, "table_outl")
result = halftone.halftone("butterfly.pgm", 12, halftone.renderOutline)
support.saveImage(result, "butterfly_outl")
def testSmoothAverageCandies():
# size 3
K = utils.makeKernel('average', 3)
image = utils.smoothImage('candies.pgm', K)
support.saveImage(image, 'candies_average_3_smooth')
# size 5
K = utils.makeKernel('average', 5)
image = utils.smoothImage('candies.pgm', K)
support.saveImage(image, 'candies_average_5_smooth')
# size 7
K = utils.makeKernel('average', 7)
image = utils.smoothImage('candies.pgm', K)
support.saveImage(image, 'candies_average_7_smooth')
# size 9
K = utils.makeKernel('average', 9)
image = utils.smoothImage('candies.pgm', K)
support.saveImage(image, 'candies_average_9_smooth')
def testSmoothGaussPeppers():
# sig = 0.5 size = 3
K = utils.makeKernel('gauss', 3, 0.5)
image = utils.smoothImage('peppers.pgm', K)
support.saveImage(image, 'peppers_gauss_.5_smooth')
# sig = 1 size = 7
K = utils.makeKernel('gauss', 7, 1)
image = utils.smoothImage('peppers.pgm', K)
support.saveImage(image, 'peppers_gauss_1_smooth')
# sig = 2 size = 13
K = utils.makeKernel('gauss', 13, 2)
image = utils.smoothImage('peppers.pgm', K)
support.saveImage(image, 'peppers_gauss_2_smooth')
# sig = 3 size = 19
K = utils.makeKernel('gauss', 19, 3)
image = utils.smoothImage('peppers.pgm', K)
support.saveImage(image, 'peppers_gauss_3_smooth')
def testLotus(name):
image = tessellate.tessellate_main('lotus/lotus.png')
support.saveImage(image, name)
def testEagle(name):
image = tessellate.tessellate_main('eagle/eagle.png')
support.saveImage(image, name)
def testLotusIn():
image = support.loadImageRGB("lotus-in.png")
drawing = support.loadMatrix("lotus-curves.npy")
image = image / 255.0
rgbImage = tessellate.assignColors(image, drawing)
support.saveImage(rgbImage, "lotus-test.png")
def testTiffany(name):
image = tessellate.tessellate_main('tiffany/tiffany.png')
support.saveImage(image, name)
def testLion(name):
image = tessellate.tessellate_main('lion/lion.png')
support.saveImage(image, name)
def testRect():
image = support.loadImage("originals/rect.png")
mask = support.loadMatrix("originals/rect-mask.npy")
image = restoreGray(image, mask)
support.saveImage(image, "rect-9999.png")
def testfig5():
image = support.loadImage("originals/fig5.png")
mask = support.loadMatrix("originals/fig5-mask.npy")
image = restoreGray(image, mask)
support.saveImage(image, "fig5-9999.png")
def testTiffany():
image = support.loadImageRGB("originals/tiffany.png")
image = impress.impress(image)
support.showImage(image)
support.saveImage(image, 'tiffany_color' + color_plate)
def testRiver():
image = support.loadImageRGB("originals/riverfront.png")
image = impress.impress(image)
support.showImage(image)
support.saveImage(image, 'riverfront_color' + color_plate)
def testDesktop():
image = support.loadImageRGB("originals/desktop.png")
image = impress.impress(image)
support.showImage(image)
support.saveImage(image, 'desktop_color' + color_plate)
def testGetEdgesPeppers():
# prewitt
Kx, Ky = utils.makeKernel('prewitt')
Gx, Gy, G, D = utils.getEdges('peppers.pgm', Kx, Ky)
support.saveImage(Gx, 'peppers_prewitt_edges_gx')
support.saveImage(Gy, 'peppers_prewitt_edges_gy')
support.saveImage(G, 'peppers_prewitt_edges_g')
# sobel
Kx, Ky = utils.makeKernel('sobel')
Gx, Gy, G, D = utils.getEdges('peppers.pgm', Kx, Ky)
support.saveImage(Gx, 'peppers_sobel_edges_gx')
support.saveImage(Gy, 'peppers_sobel_edges_gy')
support.saveImage(G, 'peppers_sobel_edges_g')
def testAnimateRGB():
image = support.loadImageRGB("originals/animation-rgb.png")
mask = support.loadMatrix("originals/animation-mask.npy")
image = restoreRGB(image, mask)
support.saveImage(image, "rgb-animation-9999.png")
def testAnimate():
image = support.loadImage("originals/animation.png")
mask = support.loadMatrix("originals/animation-mask.npy")
image = restoreGray(image, mask)
support.saveImage(image, "animation-9999.png")
def testFlowers():
image = support.loadImageRGB("originals/flowers.png")
image = impress.impress(image)
support.showImage(image)
support.saveImage(image, 'flowers_color' + color_plate)
import support
#import linedrawing2 as linedrawing
import linedrawing
#images to png
#support.saveImage(support.loadImage('butterfly.pgm'), 'butterfly')
##support.saveImage(support.loadImage('circle-noisy.pgm'), 'circle-noisy')
##support.saveImage(support.loadImage('circle.pgm'), 'circle')
##support.saveImage(support.loadImage('disk.pgm'), 'disk')
##support.saveImage(support.loadImage('eagle-eye.pgm'), 'eagle-eye')
##support.saveImage(support.loadImage('eagle.pgm'), 'eagle')
##support.saveImage(support.loadImage('Einstein.pgm'), 'Einstein')
##support.saveImage(support.loadImage('fingerprint.pgm'), 'fingerprint')
##support.saveImage(support.loadImage('lighthouse.pgm'), 'lighthouse')
##support.saveImage(support.loadImage('mandrill.pgm'), 'mandrill')
support.saveImage(linedrawing.lineDrawing("butterfly.pgm"), "line_butterfly")
support.saveImage(linedrawing.lineDrawing("circle.pgm"), "line_circle")
support.saveImage(linedrawing.lineDrawing("circle-noisy.pgm"),
"line_circle-noisy")
support.saveImage(linedrawing.lineDrawing("fingerprint.pgm"),
"line_fingerprint")
support.saveImage(linedrawing.lineDrawing("disk.pgm"), "line_disk")
support.saveImage(linedrawing.lineDrawing("eagle-eye.pgm"), "line_eagle-eye")
support.saveImage(linedrawing.lineDrawing("eagle.pgm"), "line_eagle")
support.saveImage(linedrawing.lineDrawing("Einstein.pgm"), "line_Einstein")
support.saveImage(linedrawing.lineDrawing("lighthouse.pgm"), "line_lighthouse")
support.saveImage(linedrawing.lineDrawing("mandrill.pgm"), "line_mandrill")
def testTable():
image = support.loadImageRGB("originals/table.png")
image = impress.impress(image)
support.showImage(image)
support.saveImage(image, 'table_color' + color_plate)
#test.py
import support
from pixelart import *
image = support.loadImageRGB("obama80x54.png")
image = pixelart(image, 6, 4, 4)
support.showImage(image)
support.saveImage(image, "obama6x4")
def main(image):
pil_image = Image.open(BytesIO(image))
image = np.array(pil_image)
original = image.copy()
origHeight, origWidth, _ = image.shape
ratio = image.shape[0] / scaling
image = imutils.resize(image, height=scaling)
newHeight, newWidth, _ = image.shape
print('starting page extraction ...')
grayscale = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
blurred = cv2.GaussianBlur(grayscale, (5, 5), 0)
edged = cv2.Canny(blurred, 100, 200)
backupEdged = edged.copy()
target = None
(_, contours, _) = cv2.findContours(edged, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)
contours = sorted(contours, key=cv2.contourArea, reverse=True)
# print(contours)
for c in contours:
p = cv2.arcLength(c, True)
approx = cv2.approxPolyDP(c, 0.02 * p, True)
if len(approx) == 4:
target = approx
break
try:
imageArea = np.array([[[newWidth,0]], [[0, 0]], [[0, newHeight]], [[newWidth, newHeight]]], np.int32)
if target is None:
target = imageArea
else:
area1 = support.polyArea(target)
area2 = support.polyArea(imageArea)
if area1 / area2 < 1/3:
target = imageArea
print("AREA ",support.polyArea(target))
print('page found in image')
print('page found in image')
pageExtracted = True
target = support.scaleTarget(target, 0.015)
newTarget = target * ratio
#approx = support.cornerPoints(target)
approx = support.cornerPoints(newTarget)
print(approx)
print(approx[0][1] + approx[1][1])
warpedHeight = int(((approx[3][1]-approx[1][1]) + (approx[2][1] - approx[0][1])) / 2)
warpedWidth = int(((approx[2][0]-approx[3][0]) + (approx[1][0] - approx[0][0])) / 2)
print(warpedWidth, warpedHeight)
pts2 = np.float32([[0,0],[warpedWidth,0],[warpedWidth,warpedHeight],[0,warpedHeight]])
M = cv2.getPerspectiveTransform(approx,pts2)
dest = cv2.warpPerspective(original,M,(warpedWidth,warpedHeight))
destHeight, destWidth, _ = dest.shape
cv2.drawContours(image, [target], -1, (0, 255, 0), 2)
dest = cv2.cvtColor(dest, cv2.COLOR_BGR2GRAY)
warped = support.perspectiveTransform(original, target.reshape(4, 2) * ratio)
warped = cv2.cvtColor(warped, cv2.COLOR_BGR2GRAY)
T = threshold_local(warped, 11, offset = 10, method = "gaussian")
warped = (warped > T).astype("uint8") * 255
ret, threshold1 = cv2.threshold(dest, 127, 255, cv2.THRESH_BINARY)
threshold2 = cv2.adaptiveThreshold(dest, 255, cv2.ADAPTIVE_THRESH_MEAN_C, cv2.THRESH_BINARY, 11, 2)
threshold3 = cv2.adaptiveThreshold(dest, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, 11, 2)
ret2, threshold4 = cv2.threshold(dest, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
top, bottom, left, right = [10] * 4
print('outputting dest ... done')
dest = imutils.resize(dest, origHeight)
cropHeight, cropWidth = dest.shape
dest = Image.fromarray(dest)
tImage = dest
except NameError:
print('page not found in image')
print(traceback.print_exc(file=sys.stdout))
except:
print(traceback.print_exc(file=sys.stdout))
print('page extraction ... done')
#================================================================================================================
print('\nstarting text extraction ...')
print("SIZE: ",tImage.size)
scale, image = support.downscale_image(tImage)
edges = cv2.Canny(np.asarray(image), 100, 200)
_, contours, _ = cv2.findContours(edges, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
borders = support.findBorder(contours, edges)
borders.sort(key=lambda i_x1_y1_x2_y2: (i_x1_y1_x2_y2[3] - i_x1_y1_x2_y2[1]) * (i_x1_y1_x2_y2[4] - i_x1_y1_x2_y2[2]))
borderContour = None
if len(borders):
borderContour = contours[borders[0][0]]
edges = support.removeBorder(borderContour, edges)
edges = 255 * (edges > 0).astype(np.uint8)
maxed_rows = rank_filter(edges, -2, size=(1, 20))
maxed_cols = rank_filter(edges, -2, size=(20, 1))
debordered = np.minimum(np.minimum(edges, maxed_rows), maxed_cols)
edges = debordered
contours = support.findComponents(edges)
model = classify.load_model('bin')
mapping = pickle.load(open('%s/mapping.p' % 'bin', 'rb'))
if len(contours) == 0:
print('no text detected')
else:
crop = support.findOptimalComponents(contours, edges)
crop = support.padCrop(crop, contours, edges, borderContour)
crop = [int(x / scale) for x in crop]
print('outputting detection boxes ... done')
#support.textDetection(textExtractPath) <-- doesn't work
#support.textDetection2(textExtractPath) <-- doesn't work
print('outputting text ... done')
textImage = tImage.crop(crop)
retImages, image2 = support.textDetection3(textImage, cropWidth, cropHeight)
prefix = rand_num = random.randint(1, 999999999)
support.saveImage(image2, prefix)
svg_paths = []
document = []
for ind, line in enumerate(retImages):
line_pil = Image.fromarray(line['roi'])
svg_path = coords.makeSVG(line_pil, prefix, ind)
svg_paths.append({'svg_path': svg_path, 'width': line['width'], 'img': line_pil})
for p in svg_paths:
# get a line of text
if p['width'] < cropWidth / 2:
document.append("$" + coords.main(p['img']) + "$\\\\")
else:
document.append(extractletter.main(p['svg_path'], model, mapping) + "\\\\")
document = ("\n").join(document)
tmp_path = "tmp" + str(prefix) + os.sep
f = open(tmp_path + "doc.txt", 'w')
f.write(document)
f.close()
tex, tex_pdf = coords.make_document(document, tmp_path)
return tex, tex_pdf
def lineDrawing(image):
# load image and create slightly smaller image due to gradients being smaller
image_mat = support.loadImage(image)
r, c = support.getSize(image_mat)
image_mat = image_mat / 255.0
Kx, Ky = utils.makeKernel('sobel')
Kx, Ky = Kx / 8.0, Ky / 8.0
Gx, Gy, G, D = utils.getEdges(image, Kx, Ky)
image_mat = image_mat[1:r - 1, 1:c - 1]
G = normalizeMatrix(G)
Tx, Ty = gradientTangents(Gx, Gy)
support.saveImage(Tx, "Tx_test")
support.saveImage(Ty, "Ty_test")
support.saveImage(Gx, "Gx_test")
support.saveImage(Gy, "Gy_test")
Tx_p, Ty_p = computeETF(Tx, Ty, G)
support.saveImage(Tx, "Tx_p_test")
support.saveImage(Ty, "Ty_p_test")
return computeFDoG(image_mat, Tx_p, Tx_p)
