142 lines
3.9 KiB
Python
Executable File
142 lines
3.9 KiB
Python
Executable File
#! /usr/local/bin/python3
|
|
from io import BytesIO
|
|
from numpy import asarray
|
|
from PIL import Image
|
|
from redis import Redis
|
|
import base64
|
|
import json
|
|
import os
|
|
import potrace
|
|
import re
|
|
import time
|
|
|
|
color = 65280
|
|
environ = os.environ
|
|
host = environ['DB_HOST'] if 'DB_HOST' in os.environ else "localhost"
|
|
port = environ['DB_PORT'] if 'DB_PORT' in os.environ else 6379
|
|
r = Redis(host=host, port=port)
|
|
|
|
|
|
def convertImg(src, image_path="/tmp/"):
|
|
base64_data = re.sub('^data:image/.+;base64,', '', src)
|
|
byte_data = base64.b64decode(base64_data)
|
|
image_data = BytesIO(byte_data)
|
|
img = Image.open(image_data).convert("1")
|
|
return img
|
|
|
|
# Read results from redis
|
|
data = r.lpop('image-convert')
|
|
while data :
|
|
try:
|
|
item = json.loads(data)
|
|
image_data = item["image_data"]
|
|
text = item["text"]
|
|
hash_name = item["hash_name"]
|
|
|
|
# Vectorize the image
|
|
image = convertImg( image_data )
|
|
bmp = potrace.Bitmap( asarray( image ) )
|
|
|
|
# Trace the bitmap to a path
|
|
path = bmp.trace(turdsize=16,alphamax=0.0, opticurve=0, opttolerance=1.0)
|
|
|
|
|
|
# Record the min/max coordinates and a list of points
|
|
min_x = 0
|
|
min_y = 0
|
|
max_x = -9999
|
|
max_y = -9999
|
|
|
|
pl = []
|
|
pl_index = 0
|
|
odd_indices = []
|
|
def plappend( point ):
|
|
global pl, pl_index, odd_indices, min_x, min_y, max_x, max_y
|
|
pl.append(point)
|
|
pl_index += 1
|
|
suspect = False
|
|
|
|
if point[0] <= min_x :
|
|
min_x = point[0]
|
|
suspect = True
|
|
if point[0] >= max_x :
|
|
max_x = point[0]
|
|
suspect = True
|
|
if point[1] <= min_y :
|
|
min_y = point[1]
|
|
suspect = True
|
|
if point[1] >= max_y :
|
|
max_y = point[1]
|
|
suspect = True
|
|
if suspect == True:
|
|
odd_indices.append(pl_index)
|
|
return True
|
|
return False
|
|
|
|
|
|
for curve in path:
|
|
start = curve.start_point
|
|
plappend([int(start[0]),int(start[1]),0])
|
|
plappend([int(start[0]),int(start[1]),color])
|
|
for segment in curve:
|
|
end_point_x, end_point_y = segment.end_point
|
|
if segment.is_corner:
|
|
c_x, c_y = segment.c
|
|
plappend([int(c_x),int(c_y),color])
|
|
pass
|
|
#
|
|
else:
|
|
c1_x, c1_y = segment.c1
|
|
x, y = segment.c2
|
|
plappend([int(x),int(y),color])
|
|
plappend([int(c1_x),int(c1_y),color])
|
|
#
|
|
plappend([int(start[0]),int(start[1]),0])
|
|
|
|
# Run the border detection
|
|
def isBorder( pt ):
|
|
result = []
|
|
# calculate the distance to min/max
|
|
min_x_dst = abs(min_x - pt[0])
|
|
max_x_dst = abs(max_x - pt[0])
|
|
min_y_dst = abs(min_y - pt[1])
|
|
max_y_dst = abs(max_y - pt[1])
|
|
if min_x_dst <= 1 :
|
|
result.append("min_x")
|
|
if max_x_dst <= 1 :
|
|
result.append("max_x")
|
|
if min_y_dst <= 1 :
|
|
result.append("min_y")
|
|
if max_y_dst <= 1 :
|
|
result.append("max_y")
|
|
return result
|
|
|
|
deleteList = []
|
|
for i in range(len(odd_indices) - 1) :
|
|
ind = odd_indices[i]
|
|
pt = pl[ind]
|
|
nextpt = pl[ind+1]
|
|
# Early skip black points
|
|
if 0 == pt[2] or 0 == nextpt[2]:
|
|
continue
|
|
pt_is_bord = isBorder(pt)
|
|
nextpt_is_bord = isBorder(nextpt)
|
|
if 0 == len(pt_is_bord) or 0 == len(nextpt_is_bord):
|
|
continue
|
|
#print( "{} and {} are border.".format(pt,nextpt))
|
|
deleteList.append(ind)
|
|
deleteList.append(ind+1)
|
|
|
|
deleteList = sorted(set(deleteList), reverse=True)
|
|
for i in deleteList:
|
|
pl[i] = [pl[i][0],pl[i][1],0]
|
|
item["points_list"] = pl
|
|
item["created_at"] = time.time()
|
|
r.hset("images",hash_name, json.dumps(item))
|
|
print("Handled image {}".format(hash_name))
|
|
data = r.lpop('image-convert')
|
|
|
|
except Exception as e:
|
|
print("woops",e)
|
|
break
|