def main(imagePath):
# Create OCR
ocr = Ocr()
# Run OCR over image. It generates a JSON with the text and the coordinates of each word
ocr.processFile(imagePath, './')
# Read JSON and delete it
jsonFile = changeFileExtension(imagePath.split("/")[-1], "json")
with open(jsonFile, 'r') as f:
image = json.load(f)
# Extract tokens (Each word, its width, height and its coordinates)
tokens = extractTokens(image)
# Sort the tokens into lines
lines = extractLines(tokens)
txt = ""
for line in lines:
print(line)
line = list(filter(lambda x: x != "–", line))
try:
txt += "{:>40}{:>40}{:>40}{:>40}\n".format(line[0], line[1],
line[2], line[3])
except:
try:
txt += "{:>40}{:>40}\n".format(line[0], line[1])
except:
pass
with open(changeFileExtension(imagePath.split("/")[-1], "txt"), 'w') as f:
f.write(txt)
def getCampaign(self):
source = BeautifulSoup(self.response.content,"html.parser")
#print(source.find("div",attrs={"class":self.group}))
allgroups=source.findAll("div",attrs={"class":self.group})
bimCampaigns=[]
#C:/inetpub/wwwroot/marketbrosuru.com/wwwroot
os.chdir(static.appPath+"img/bros-img")
ocr=Ocr()
if os.path.isdir('bim')==False:
os.mkdir('bim')
os.chdir(static.appPath+"img/bros-img/bim")
for number, group in enumerate(allgroups, start=1):
title=group.select("a>span")[0].text
hrefs=group.select("div.row>div.imageArea>div.row>div.smallArea>a")
texts=[]
Path(str(number)).mkdir(parents=True, exist_ok=True)
for imgx, href in enumerate(hrefs, start=1):
urllib.request.urlretrieve("http://www.bim.com.tr/"+urllib.parse.quote(href.get('data-bigimg')), static.appPath+'img/bros-img/bim/'+str(number)+'/'+str(imgx)+".jpg")
imgContent=ocr.read(static.appPath+'img/bros-img/bim/'+str(number)+'/'+str(imgx)+".jpg")
texts.append(imgContent)
openedImage= Image.open(static.appPath+'img/bros-img/bim/'+str(number)+'/'+str(imgx)+".jpg")
openedImage.thumbnail([810,810])
openedImage.save(static.appPath+'img/bros-img/bim/'+str(number)+'/'+str(imgx)+"thumb.jpg")
bimCampaigns.append({"title":title, "text":texts})
return bimCampaigns
def ocr():
submitted_file = request.files['file']
file_name = submitted_file.filename
if submitted_file and allowed_filename(file_name):
filename = secure_filename(file_name)
directory = os.path.join(app.root_path, UPLOAD_PATH)
if not os.path.exists(directory):
os.mkdir(directory)
# upload image
file_path = os.path.join(directory, filename)
submitted_file.save(file_path)
print('Image Name: ', file_name)
# analyze image
ocr_img = Ocr(UPLOAD_PATH + "/" + file_name, lcd_mask_rcnn,
num_mask_rcnn)
result = ocr_img.ocr_run()
# delete image
os.remove(file_path)
return json.dumps(result, ensure_ascii=False)
else:
# result = json.dumps({'code': CODE_FILE_NOTALLOWED,
# 'message': "Upload is failed. The file is not 'jpg' or 'png'.",
# 'result': {'LCD': None,
# 'NUM': None}}, ensure_ascii=False)
result = {'NUM': None}
return json.dumps(result, ensure_ascii=False)
def _do_ocr(self, img, path):
buf = BytesIO()
img.save(buf, format="png")
buf.seek(0)
img.save(path)
ocr = Ocr()
rslt = ocr.process(buf)
logger.debug(rslt)
return [PageObj('text', (0, 0, 0, 0), texts=rslt['results'])]
def ocr_process():
if request.method == 'POST':
if 'file' not in request.files:
flash('No file part')
return redirect('/ocr')
file = request.files['file']
if file.filename == '':
flash('No selected file')
return redirect('/ocr')
print(file)
ocr = Ocr()
res = ocr.process(file.stream)
return jsonify(res)
def create_cache(self, text):
o = Ocr()
font_face = re.findall(r'@font-face\{.*?base64,(.*?)\)', text)[0]
onlineFront = TTFont(io.BytesIO(base64.b64decode(font_face)))
with open(os.path.join(self.CACHE_ROOT_PATH, self.CACHE_FILE_NAME),
'r') as f:
try:
words_cache = json.loads(f.read())
except:
words_cache = {}
font_md5 = hashlib.md5(font_face.encode()).hexdigest()
if font_md5 in list(words_cache.keys()):
return
else:
words_cache[font_md5] = {}
# 随机保存为ttf文件，文件名不能重复，这里的save操作在之后加入缓存的时候，如果命中缓存，则不去save，对应的文件名需要保存在json里
# 文件名保存是为了之后识别数字之后方便修改
file_name = '58' + font_md5[:19] + '.ttf'
onlineFront.save(os.path.join(self.FONT_DATA_PATH,
file_name)) # 保存为字体格式的文件
font = ParseTTFont(os.path.join(self.FONT_DATA_PATH, file_name))
all_unicode = font.get_glyphnames()[2:]
for unicode in all_unicode:
im = font.one_to_image(unicode)
img_file_name = hashlib.md5(str(
time.time()).encode()).hexdigest() + '.png'
im.save(os.path.join(self.IMG_DATA_PATH, img_file_name))
result = o.img_to_word_api(
os.path.join(self.IMG_DATA_PATH, img_file_name))
os.remove(img_file_name)
words_cache[font_md5][unicode] = result
time.sleep(0.5)
words_cache[font_md5]['file_name'] = file_name
with open(os.path.join(self.CACHE_ROOT_PATH, self.CACHE_FILE_NAME),
'w') as f1:
f1.write(json.dumps(words_cache))
persistor = AWSPersistor('mesoor-ocr')
persistor.upload(
os.path.join(self.CACHE_ROOT_PATH, self.CACHE_FILE_NAME),
'58tongcheng/test.json')
return font_md5, words_cache[font_md5]
class PitcherNameDetector:
THRESHOLD_VALUE = 50
THRESHOLD_MAX_VALUE = 255
X = 965
Y = 435
WIDTH = 155
HEIGHT = 40
def __init__(self):
self.ocr = Ocr()
def detect(self, image):
gray_image = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
_, threshold_image = cv2.threshold(gray_image, self.THRESHOLD_VALUE,
self.THRESHOLD_MAX_VALUE,
cv2.THRESH_BINARY_INV)
pitch_name_image = threshold_image[self.Y:self.Y + self.HEIGHT,
self.X:self.X + self.WIDTH]
pitch_name = self.ocr.image_to_string(pitch_name_image)
frame1 = cv2.rectangle(image, (self.X, self.Y),
(self.X + self.WIDTH, self.Y + self.HEIGHT),
(0, 255, 0), 1)
#cv2.imshow("", frame1)
#cv2.imshow("", pitch_name_image)
#cv2.waitKey(3000)
print(pitch_name)
return pitch_name, pitch_name_image
def __init__(self):
self.vlogger = None
self.pre= None
self.edged= None
self.warp= ImageBlobWarping()
self.bnight= False
self.ocr_engine = Ocr('spa', logger)
def receive():
data = request.form['data']
ocr_c = OcrCache()
ocr_obj = Ocr()
parser_58 = Parser(data,ocr_obj,ocr_c)
text = parser_58.parse()
return text
def execute(self):
parser = argparse.ArgumentParser()
parser.add_argument(
'--file',
help=
'PDF file to be converted (If not specified, It will convert the entire source folder instead)'
)
parser.add_argument(
'--only_ocr',
help='true to execute only OCR without converting the file to PDF/A'
)
parser.add_argument(
'--only_pdfa',
help='true to ignore OCR conversion. Final file will be PDF/A tough'
)
parser.add_argument(
'--keep_filename',
help='true to keep the original filename after conversion')
parser.add_argument(
'--delete_original',
help='true to delete the original files after conversion')
args = parser.parse_args()
filePath = None
delete_original = True if args.delete_original == 'true' else False
keep_filename = True if args.keep_filename == 'true' else False
if args.only_pdfa != 'true':
ocr = Ocr(self.confs)
if args.file == None:
ocr.convert_folder(delete_original, keep_filename)
else:
filePath = ocr.convert_file(args.file, delete_original,
keep_filename)
if args.only_ocr != 'true':
pdfa = PdfA(self.confs)
if args.file == None and filePath == None:
pdfa.convert_folder(keep_filename, True, delete_original)
else:
if filePath == None:
filePath = args.file
pdfa.convert_file(filePath, delete_original, keep_filename)
def convertImageToText(imagePath):
# Create OCR
ocr = Ocr()
# Run OCR over image. It generates a JSON with the text and the coordinates of each word
jsonFile = ocr.processFile(imagePath, './')
# Read JSON
# jsonFile = changeFileExtension(imagePath.split("/")[-1], "json")
# with open(jsonFile, 'r') as f:
# image = json.load(f)
# Extract tokens (Each word, its width, height and its coordinates)
#tokens = extractTokens(image)
tokens = extractTokens(jsonFile)
# Sort the tokens into lines
lines = extractLines(tokens)
txt = ""
response = {}
linesList = []
for line in lines:
print(json.dumps(line))
linesList.append(line)
line = list(filter(lambda x: x != "–", line))
try:
txt += "{:>40}{:>40}{:>40}{:>40}\n".format(line[0], line[1],
line[2], line[3])
except:
try:
txt += "{:>40}{:>40}\n".format(line[0], line[1])
except:
pass
# with open(changeFileExtension(imagePath.split("/")[-1], "txt"), 'w') as f:
# f.write(txt)
response["0"] = linesList
return json.dumps(response, indent=4)
def push_load_button(self):
'ファイル選択ボタンが押された時の処理'
# ファイル選択画面表示
file_path = self.view.select_file()
# 画像ファイルの読み込みと描画
if len(file_path) != 0:
self.model.read(file_path)
self.selection = None
# 選択範囲を表示するオブジェクトを削除
self.view.delete_selection(self.view.LEFT_CANVAS)
# 画像処理前の画像を左側のキャンバスに描画
self.view.draw_image(View.LEFT_CANVAS)
#画像文字認識
ocr1 = Ocr()
#画像結果出力
self.view.draw_Text(View.RIGHT_CANVAS,
ocr1.ocr_image_to_string(file_path))
# ラベルにメッセージを描画
self.view.draw_message("読込終了")
def getCampaign(self, campaignNo):
source = BeautifulSoup(self.response.content, "html.parser")
#print(source.find("div",attrs={"class":self.group}))
title = source.select("ul.brochures-actions-list>li")[
campaignNo - 1].find('a').select('div.dates')[0].get('data-date')
images = source.select(
"div.brochure-tabs>div.contents>div.content")[0].findAll(
'img', attrs={"class": "image0"})
ocr = Ocr()
a101Campaigns = []
os.chdir(static.appPath + "img/bros-img")
if os.path.isdir('a101') == False:
os.mkdir('a101')
os.chdir(static.appPath + "img/bros-img/a101")
texts = []
for number, image in enumerate(images, start=1):
Path(str(campaignNo)).mkdir(parents=True, exist_ok=True)
urllib.request.urlretrieve(
image.get('src'), static.appPath + 'img/bros-img/a101/' +
str(campaignNo) + '/' + str(number) + ".jpg")
imgContent = ocr.read(static.appPath + 'img/bros-img/a101/' +
str(campaignNo) + '/' + str(number) + ".jpg")
texts.append(imgContent)
openedImage = Image.open(static.appPath + 'img/bros-img/a101/' +
str(campaignNo) + '/' + str(number) +
".jpg")
openedImage.thumbnail([810, 810])
openedImage.save(static.appPath + 'img/bros-img/a101/' +
str(campaignNo) + '/' + str(number) + "thumb.jpg")
a101Campaigns.append({"title": title, "text": texts})
return a101Campaigns
def edit_cache(self):
o = Ocr()
with open('./cache/words_cache.json', 'r') as f:
data = json.loads(f.read())
data_copy = data.copy()
for key, val in data_copy.items():
file_name = val['file_name']
font = ParseTTFont(os.path.join(self.FONT_DATA_PATH, file_name))
for k, v in val:
# k是unicode,v是对应的识别值
im = font.one_to_image(k)
img_file_name = hashlib.md5(str(
time.time()).encode()).hexdigest() + '.png'
im.save(os.path.join(self.IMG_DATA_PATH, img_file_name))
# 这里可以使用修改之后的ocr
# result = o.img_to_word_api(os.path.join(self.IMG_DATA_PATH, img_file_name))
# data[key][k] = result
os.remove(img_file_name)
class PitchTypeDetector:
THRESHOLD_VALUE = 210
THRESHOLD_MAX_VALUE = 255
X = 512
Y = 576
WIDTH = 256
HEIGHT = 50
def __init__(self):
self.ocr = Ocr()
def detect(self, image):
gray_image = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
_, threshold_image = cv2.threshold(gray_image, self.THRESHOLD_VALUE, self.THRESHOLD_MAX_VALUE, cv2.THRESH_BINARY)
pitch_type_image = threshold_image[self.Y : self.Y + self.HEIGHT, self.X : self.X + self.WIDTH]
pitch_type = self.ocr.image_to_string(pitch_type_image)
return pitch_type, pitch_type_image
def main():
document = None
page_num = 0
options, args = parseCmdLineOpt()
config_file = options.configFile
config = readConfig(config_file)
channel = create_connection(config)
documents = []
scanner = init_scanner(config)
for output, image_bar in start_scanning(scanner):
for symbol in image_bar:
logger.debug("symbol %s" % symbol.data)
for clef, valeur in config.items("type"):
if re.match(valeur, symbol.data):
page_num = 0
logger.debug("new document detected")
document = Document()
logger.debug(document)
document.name = symbol.data
document.genre = clef
documents.append(document)
break
if re.match(("^%s.*" % config.get("workflow", "key")), symbol.data):
document.workflows.append(symbol.data)
page_num += 1
if document is not None:
filename = "%s_%s.tiff" % (document.name, str(page_num))
else:
document = Document()
filename = "undefined_%s_%s.tiff" % (datetime.today().strftime("%Y%m%d-%H%M%S"), str(page_num))
document.name = "undefined_%s" % datetime.today().strftime("%Y%m%d-%H%M%S")
documents.append(document)
filepath = os.path.join(config.get("output", "tmp_dir"), filename)
output.save(filepath, 'TIFF')
document.files.append(filepath)
for symbol in image_bar:
document.barcodes.append(symbol.data)
print str(document)
ocr = Ocr()
ocr.bin_path = config.get("ocr","ocr_bin")
ocr.input_image = filepath
ocr.parse()
document.ocr.append(ocr.content)
if config.get("scanner", "interactive") == "True":
input_cmd = raw_input("press enter to scan the next document or 'quit' to leave ")
if input_cmd == "quit":
break
for document in documents:
logger.debug("documents : %s" % documents)
logger.debug("document : %s" % document)
old_files = document.files
logger.debug(" old_files :")
logger.debug(old_files)
document.files = []
file_format = config.get("output", "file_format")
for image in old_files:
logger.debug(" image : %s" % image)
document.files.append(convert_file(image,file_format))
if file_format == "PDF":
new_file = merge_files(document.files,file_format)
document.files = [new_file]
logger.debug("we gonna produce a new message in the queue for %s" % document)
produce_msg_document(channel, document, config.get("queues", "documents"))
import json
import logging
from bot import Bot
from fxstock import FxStock
from ocr import Ocr
# Setting
token = 'YOUR_TOKEN'
modules = [FxStock(lambda_mode=True), Ocr()]
logger = logging.getLogger('FxStock')
logger.setLevel(logging.DEBUG)
formatter = logging.Formatter(
'[%(asctime)s] %(levelname)s [%(module)s.%(funcName)s:%(lineno)d] %(message)s'
)
stream_handler = logging.StreamHandler()
stream_handler.setFormatter(formatter)
logger.addHandler(stream_handler)
bot = Bot(token, modules)
def lambda_handler(event, context):
current_update = json.loads(event['body'])
bot.process_update(current_update)
return {'statusCode': 200}
from flask import Flask, render_template, request
from werkzeug.utils import secure_filename
import os
from ocr import Ocr
from detect import Detect
import time
import pytesseract
import cv2
from pdf2image import convert_from_path
from datetime import datetime
app = Flask(__name__)
ocr = Ocr()
detect = Detect()
@app.route('/hello', methods=['GET'])
def get():
return 'hello i am dung'
@app.route('/process', methods=['POST'])
def processUrl():
log = open("log.txt", "a")
result = []
if request.method == 'POST':
for e in request.files:
try:
f = request.files[e]
timestamp = datetime.now().timestamp()
def __init__(self):
self.ocr = Ocr()
class PlateDetector(object):
def __init__(self):
self.vlogger = None
self.pre= None
self.edged= None
self.warp= ImageBlobWarping()
self.bnight= False
self.ocr_engine = Ocr('spa', logger)
def set_logger(self, logger):
self.vlogger = logger
def bestocr(self, ocrlst):
ocr_overall_acc_lst= []
imax= -1
if len(ocrlst) == 0:
return imax
ocr_acc= 0
#~ print ocrlst
for ocritm in ocrlst:
#~ print ocritm
for det in ocritm:
if det is not None and det[1] != None:
try:
ocr_acc = ocr_acc + det[1]**2
except:
pass
if len(ocritm) > 0:
ocr_acc /= len(ocritm)
ocr_acc= ocr_acc**0.5
print "ocr_acc: %.3f %%"%ocr_acc
ocr_overall_acc_lst.append(round(ocr_acc,3))
imax= max(ocr_overall_acc_lst)
return ocr_overall_acc_lst.index(imax)
""" Return best text recognized """
def first(self, img):
bbox= None
code= None
cnt= None
blobs= self.findBlobs( img )
ocrlst= []
bboxlst= []
for orig_rot_blob in blobs:
bb= np.int0(cv2.boxPoints( orig_rot_blob ))
bbox= cv2.boundingRect( bb )
w= bbox[2]
h= bbox[3]
if (w > 2*h) and (w > 80) and (w < 200): # this should be relative to image dimensions
code = self.ocr( orig_rot_blob )
if code:
ocrlst.append( code )
bboxlst.append( bbox )
print code
if len(code) == 6:
break
# hardcoded -- width should not be higher than img.width / 8
if (w > 2*h) and (w > 80) and (w < 400): # second stage without max size constraints
code = self.ocr( orig_rot_blob )
if code:
ocrlst.append( code )
bboxlst.append( bbox )
if len(code) == 6:
break
if len( ocrlst ) > 0:
ocr_best_index= self.bestocr( ocrlst )
if ocr_best_index != -1:
code = ocrlst[ ocr_best_index ]
bbox = bboxlst[ ocr_best_index ]
else:
print "none"
return code, bbox
def findBlobs(self, img):
rects= []
cnts= self.findContours(img)
for c in cnts:
c= c.reshape(-1, 2)
if len(c) < 4:
continue
arcl= cv2.arcLength(c, True)
approx= cv2.approxPolyDP(c, 0.02 * arcl, True)
approx= approx.reshape(-1, 2)
rect= cv2.minAreaRect(approx)
w, h= rect[1]
if len(approx) >= 4:
if (h > 0) and (w > h):
ratio = float(w) / h
if 2.4 < ratio < 4.2:
rects.append(rect)
return rects
def ocr(self, rect):
ang= rect[2]
w,h= rect[1]
if ang < -45:
ang= ang + 90
w= h
h= rect[1][0]
box= cv2.boxPoints(rect)
box= np.int0(box)
box= self.warp.order_points(box)
letters= []
code= []
try:
roic= self.warp.transform(self.edged, box)
roi= self.warp.transform(self.pre, box)
roi_orig= self.warp.transform(self.original_image, box)
except:
pass
print "some error"
return code
(roich, roicw)= roic.shape[:2]
nh= 143
if roich > 200:
nw= (roicw * nh)/roich
roi= cv2.resize(roi,(nw, nh), interpolation= cv2.INTER_LINEAR)
roic= cv2.resize(roic,(nw, nh), interpolation= cv2.INTER_LINEAR)
#~ self.do_skeleton(roi)
image_rect= self.prepare_for_ocr(roi)
image_rect2= image_rect.copy()
if self.vlogger:
self.vlogger.debug(VisualRecord("candidate", [image_rect], fmt = "jpg"))
i, cnts, hie_letters= cv2.findContours(image_rect, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
if self.vlogger:
self.vlogger.debug(VisualRecord("candidate after contours", [cv2.drawContours(roi_orig,cnts,-1,(0,255,0),1)], fmt = "jpg"))
h= roic.shape[0]
filtered_cnts= []
for i,b in enumerate(cnts):
hie_let= hie_letters[0][i]
# [next, previous, first_child, parent]
if hie_let[3] == -1: # if contour has no parent then continue with next
continue
c = b.reshape(-1,2)
if len(b) < 3: # ??
continue
r= cv2.boundingRect(c)
# pantentes.txt - las letras miden 3.2cm y la patente completa 29.4cm
if r[2] < (image_rect.shape[1] / 10):
continue
ratio= float(r[3]) / r[2]
if not 1.5 <= ratio <= 2.5:
continue
letters.append(r)
filtered_cnts.append(b)
if len(letters) >= 4:
for p in enumerate(sorted(letters, key= lambda b:b[0])):
code.append(self._do_ocr(image_rect2, p[1], p[0]))
if self.vlogger:
self.vlogger.debug(VisualRecord("LETTER DETECTION", [cv2.drawContours(image_rect2,filtered_cnts,-1,(0,255,0),1)], fmt = "jpg"))
return code
def _do_ocr(self, img, b, i):
x,y,w,h = b
l = cv2.copyMakeBorder(
img[y:y+h, x:x+w],
5, 5, 5, 5, cv2.BORDER_CONSTANT,
value=255)
if i > 2:
return self.ocr_engine.read_digit(l)
return self.ocr_engine.read_text(l)
def findContours(self, img):
imgcopy= img.copy()
if self.bnight:
i= self.prepare_night(img)
else:
i= self.prepare_day(img)
_,cnts, hie = cv2.findContours(i, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
if self.vlogger:
if self.bnight:
self.vlogger.debug(VisualRecord("contours", [cv2.drawContours(imgcopy,cnts,-1, (80,255,80),2),i], fmt = "jpg"))
else:
self.vlogger.debug(VisualRecord("contours", [cv2.drawContours(imgcopy,cnts,-1, (255,120,120),2),i], fmt = "jpg"))
return cnts
####################################################################################################
def prepare_night(self, img):
tinit= timer()
self.original_image= img
gray= cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
gauss_gray= cv2.GaussianBlur(gray, (5, 5), 0)
max_gray= np.max(gray)
std_gray= np.std(gray)
saturated_night= np.uint8(( gray > ( max_gray - 2 * std_gray )) * 255) # argentina
self.pre= gauss_gray
self.edged= cv2.Canny(saturated_night, 10, 200, apertureSize= 5)
if self.vlogger:
self.vlogger.debug(VisualRecord("thresholding > (max - 2 * std)", [saturated_night], fmt = "jpg"))
print "e:%.3f"%(timer()-tinit)
return self.edged
####################################################################################################
def prepare_day(self, img):
self.original_image= img
gray= cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
gauss_gray= cv2.GaussianBlur(gray, (5, 5), 0)
self.pre= gauss_gray
self.edged= cv2.Canny(gauss_gray, 1000, 1700, apertureSize= 5)
if self.vlogger:
self.vlogger.debug(VisualRecord("day prepare", [self.pre, self.edged], fmt = "jpg"))
return self.edged
####################################################################################################
def angle_cos(self, p0, p1, p2):
d1, d2 = (p0-p1).astype('float'), (p2-p1).astype('float')
return abs( np.dot(d1, d2) / np.sqrt( np.dot(d1, d1)*np.dot(d2, d2) ) )
def prepare_for_ocr(self, img, scale=True):
kern= cv2.getStructuringElement(cv2.MORPH_RECT,(3,3))
# http://docs.opencv.org/master/d5/daf/tutorial_py_histogram_equalization.html#gsc.tab=0
clahe= cv2.createCLAHE(clipLimit=2.0, tileGridSize=(5,5))
ims= clahe.apply(img)
ret,th= cv2.threshold(ims, 150, 255, cv2.THRESH_BINARY_INV+cv2.THRESH_OTSU)
th1= cv2.morphologyEx(th, cv2.MORPH_CLOSE, kern)
th2= self.create_rect(th1)
if self.vlogger:
self.vlogger.debug(VisualRecord("prepare_for_ocr", [img, ims, th], fmt = "jpg"))
return th2
def create_rect(self, img):
dims= img.shape
imgcop= img.copy()
imgcop[0:4,0:dims[1]]= 255
imgcop[dims[0]-2:dims[0],0:dims[1]]= 255
if self.vlogger:
self.vlogger.debug(VisualRecord("CREATE RECT", [imgcop], fmt = "jpg"))
return imgcop
def getCampaign(self):
os.chdir(static.appPath + "img/bros-img")
if os.path.isdir('sok') == False:
os.mkdir('sok')
os.chdir(static.appPath + "img/bros-img/sok")
haftaUrl = "https://kurumsal.sokmarket.com.tr/firsatlar/carsamba/"
haftaSonuUrl = "https://kurumsal.sokmarket.com.tr/firsatlar/hafta-sonu/"
Path('haftanin-firsatlari').mkdir(parents=True, exist_ok=True)
Path('haftasonu-firsatlari').mkdir(parents=True, exist_ok=True)
Path('temp').mkdir(parents=True, exist_ok=True)
urllib.request.urlretrieve(haftaUrl, 'temp/hafta.pdf')
urllib.request.urlretrieve(haftaSonuUrl, 'temp/haftaSonu.pdf')
images = convert_from_path(
'temp/hafta.pdf',
poppler_path='C:\\Program Files\\poppler\\Library\\bin')
ocr = Ocr()
texts = []
for i, image in enumerate(images, start=1):
image.save(static.appPath +
'img/bros-img/sok/haftanin-firsatlari/' + str(i) +
'.jpg')
haftaText = ocr.read(static.appPath +
'img/bros-img/sok/haftanin-firsatlari/' +
str(i) + '.jpg')
openedImage = Image.open(static.appPath +
'img/bros-img/sok/haftanin-firsatlari/' +
str(i) + '.jpg')
openedImage.thumbnail(size=[1010, 1010])
openedImage.save(static.appPath +
'img/bros-img/sok/haftanin-firsatlari/' + str(i) +
'.jpg')
openedImage.thumbnail(size=[810, 810])
openedImage.save(static.appPath +
'img/bros-img/sok/haftanin-firsatlari/' + str(i) +
'thumb.jpg')
images = convert_from_path(
'temp/haftaSonu.pdf',
poppler_path='C:\\Program Files\\poppler\\Library\\bin')
for i, image in enumerate(images, start=1):
image.save(static.appPath +
'img/bros-img/sok/haftasonu-firsatlari/' + str(i) +
'.jpg')
haftaSonuText = ocr.read(static.appPath +
'img/bros-img/sok/haftasonu-firsatlari/' +
str(i) + '.jpg')
openedImage = Image.open(static.appPath +
'img/bros-img/sok/haftasonu-firsatlari/' +
str(i) + '.jpg')
openedImage.thumbnail(size=[1010, 1010])
openedImage.save(static.appPath +
'img/bros-img/sok/haftasonu-firsatlari/' +
str(i) + '.jpg')
openedImage.thumbnail(size=[810, 810])
openedImage.save(static.appPath +
'img/bros-img/sok/haftasonu-firsatlari/' +
str(i) + 'thumb.jpg')
return {
'Brand':
'ŞOK',
'Code':
'sok',
'Campaigns': [{
'title': 'Haftanın Fırsatları',
'contents': 'haftanin-firsatlari',
'texts': haftaText
}, {
'title': 'Haftasonu Fırsatları',
'contents': 'haftasonu-firsatlari',
'texts': haftaSonuText
}]
}
def main(imagePath):
# Create OCR
ocr = Ocr()
# Run OCR over image. It generates a JSON with the text and the coordinates of each word
ocr.processFile(imagePath, './')
# Read JSON
jsonFile = changeFileExtension(imagePath.split("/")[-1], "json")
with open(jsonFile, 'r') as f:
image = json.load(f)
# Extract tokens (Each word, its width, height and its coordinates)
tokens = extractTokens(image)
# Sort the tokens into lines
lines, x, y = extractLines(tokens)
os.remove(jsonFile)
output = []
#txt = ""
num_row = 0
num_col = 0
for line in lines:
output.append(line)
num_row += 1
if (len(line) > num_col):
num_col = len(line)
dataframe, data = list_to_dataframe(output, y, x)
writer = pd.ExcelWriter(os.path.splitext(imagePath)[0] + '.xlsx',
engine='xlsxwriter',
options={'strings_to_numbers': True})
data.to_excel(writer, index=False, header=None, sheet_name='Sheet1')
workbook = writer.book
worksheet = writer.sheets['Sheet1']
for column in dataframe:
max_length = 0
adjustment = 1
for i in dataframe[column]:
#get number of chinese and japanese characters/symbols in string
east_asian_text_adj = len(extract_unicode_block(i))
#adjust column_length by the amount of normal eng chars + jpn/chn chars
column_length = len(i) + east_asian_text_adj
if column_length > max_length:
max_length = column_length
col_idx = dataframe.columns.get_loc(column)
writer.sheets['Sheet1'].set_column(col_idx, col_idx, max_length)
writer.save()
dataframe.to_csv(os.path.splitext(imagePath)[0] + '.csv',
index=False,
header=False,
encoding='utf-8-sig')
import logging
import sys
from logging.handlers import TimedRotatingFileHandler
from bot import Bot
from fxstock import FxStock
from ocr import Ocr
# Setting
token = 'YOUR_TOKEN'
refresh_time = 0.2
modules = [FxStock(send_email=False), Ocr()]
logger = logging.getLogger('FxStock')
logger.setLevel(logging.DEBUG)
formatter = logging.Formatter(
'[%(asctime)s] %(levelname)s [%(module)s.%(funcName)s:%(lineno)d] %(message)s'
)
file_handler = TimedRotatingFileHandler('log/fxstock.log',
when='d',
interval=30,
backupCount=3)
file_handler.setFormatter(formatter)
stream_handler = logging.StreamHandler()
stream_handler.setFormatter(formatter)
logger.addHandler(file_handler)
logger.addHandler(stream_handler)
def main():
from ocr import Ocr import cv2 abc = Ocr() img = cv2.imread() abc()
class SpeedDetector:
THRESHOLD_VALUE = 240 # 極力ノイズを取って文字認識の結果を安定させる狙いで高めのチューニングにしている
THRESHOLD_MAX_VALUE = 255
X = 575
Y = 626
WIDTH = 25
HEIGHT = 50
def __init__(self):
self.ocr = Ocr(lang='eng', type='text')
def detect(self, image):
gray_image = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
_, threshold_image = cv2.threshold(gray_image, self.THRESHOLD_VALUE,
self.THRESHOLD_MAX_VALUE,
cv2.THRESH_BINARY)
speed_image = threshold_image[self.Y:self.Y + self.HEIGHT,
self.X:self.X + self.WIDTH * 3]
#黄色文字の対応
if np.sum(speed_image) < 100:
img_blue_c1, img_green_c1, img_red_c1 = cv2.split(image)
_, threshold_image = cv2.threshold(img_green_c1,
self.THRESHOLD_VALUE,
self.THRESHOLD_MAX_VALUE,
cv2.THRESH_BINARY)
speed_image = threshold_image[self.Y:self.Y + self.HEIGHT,
self.X:self.X + self.WIDTH * 3]
speed = self.__image_to_string(speed_image, allow_blank=False)
# 一桁ずつ認識させることで揺らぎ率を下げる狙い
#one_image = threshold_image[self.Y : self.Y + self.HEIGHT, self.X + self.WIDTH * 0 : self.X + self.WIDTH * 1]
#one_speed = self.__image_to_string(one_image, allow_blank=True)
#two_image = threshold_image[self.Y : self.Y + self.HEIGHT, self.X + self.WIDTH * 1: self.X + self.WIDTH * 2 - 5]
#two_speed = self.__image_to_string(two_image)
# if one_speed == '':
# kd = np.sum(one_image)
# if 5600 < kd and kd < 5900:
# one_speed = '1'
# if two_speed == '8':
# kd = np.sum(two_image)
# if 25754 < kd and kd < 27796:
# two_speed = '0'
# elif two_speed == '9':
# kd = np.sum(two_image)
# if 25754 < kd and kd < 27796:
# two_speed = '0'
# elif 33404 < kd and kd < 34936:
# two_speed = '8'
# elif two_speed == '0':
# kd = np.sum(two_image)
# if 33404 < kd and kd < 34936:
# two_speed = '8'
# if one_speed == '1' and two_speed == '9':
# two_speed = '0'
# elif one_speed == '' and two_speed == '0':
# two_speed = '9'
#three_image = threshold_image[self.Y : self.Y + self.HEIGHT, self.X + self.WIDTH * 2 - 5: self.X + self.WIDTH * 3]
#three_speed = self.__image_to_string(three_image)
# kd = np.sum(three_image)
# if 28304 < kd and kd < 29326:
# three_speed = '9'
# if three_speed == '9':
# if kd < 25501:
# three_speed = '0'
# elif 30599 < kd and kd < 31621:
# three_speed = '6'
# elif 29834 < kd and kd < 30246:
# three_speed = '3'
# elif 32894 < kd and kd < 33916:
# three_speed = '8'
# if three_speed == '1':
# if 25244 < kd and kd < 25756:
# three_speed = '0'
# if three_speed == '0':
# ke = np.ones((3,3))
# dst = cv2.dilate(three_image, ke)
# kd = np.sum(dst)
# if 48449 < kd and kd < 51256:
# three_speed = '4'
#cv2.imshow('',speed_image)
#cv2.waitKey(1000)
return speed, speed_image
#return one_speed + two_speed + three_speed, speed_image
def __image_to_string(self, image, allow_blank=False):
speed = self.ocr.image_to_string(image)
#ke = np.ones((3,3))
#dst = cv2.dilate(image, ke)
#print(np.sum(dst))
# cv2.imshow('',image)
# cv2.waitKey(500)
# kd = np.sum(three_image)
if allow_blank and speed == '':
return ''
# ここはもうパターン列挙で精度を上げにかかる
# 上手く行かない数字があったらマッピングしてあげる
return speed
def __image_to_string1(self, image, allow_blank=False):
#kernel = np.ones(3,3)
speed = self.ocr.image_to_string(image)
print(np.sum(image))
cv2.imshow('', image)
cv2.waitKey(500)
kd = np.sum(image)
# ここはもうパターン列挙で精度を上げにかかる
# 上手く行かない数字があったらマッピングしてあげる
if 5600 < kd and kd < 5900:
return '1'
else:
return ' '
return ' '
def __image_to_string2(self, image, allow_blank=False):
speed = self.ocr.image_to_string(image)
print(np.sum(image))
cv2.imshow('', image)
cv2.waitKey(500)
kd = np.sum(image)
if 5600 < kd and kd < 5600:
return '0'
if 5600 < kd and kd < 5600:
return '1'
if 5600 < kd and kd < 5600:
return '2'
if 29000 < kd and kd < 31000:
return '3'
if 21000 < kd and kd < 22000:
return '4'
if 5600 < kd and kd < 5600:
return '6'
if 5600 < kd and kd < 5600:
return '7'
if 5600 < kd and kd < 5600:
return '8'
if 5600 < kd and kd < 5600:
return '9'
else:
return ' '
return ' '
def __image_to_string3(self, image, allow_blank=False):
speed = self.ocr.image_to_string(image)
print(np.sum(image))
cv2.imshow('', image)
cv2.waitKey(500)
kd = np.sum(image)
if 5600 < kd and kd < 5600:
return '0'
if 5600 < kd and kd < 5600:
return '1'
if 25245 < kd and kd < 5600:
return '2'
if 29000 < kd and kd < 31000:
return '3'
if 21000 < kd and kd < 22000:
return '4'
if 5600 < kd and kd < 5600:
return '6'
if 5600 < kd and kd < 5600:
return '7'
if 5600 < kd and kd < 5600:
return '8'
if 5600 < kd and kd < 5600:
return '9'
else:
return ' '
return ' '
def __init__(self):
self.ocr = Ocr(lang='eng', type='text')
class SpeedDetector:
THRESHOLD_VALUE = 225 # 極力ノイズを取って文字認識の結果を安定させる狙いで高めのチューニングにしている
THRESHOLD_MAX_VALUE = 255
X = 575
Y = 626
WIDTH = 25
HEIGHT = 50
def __init__(self):
self.ocr = Ocr(lang='eng', type='digit')
def detect(self, image):
gray_image = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
_, threshold_image = cv2.threshold(gray_image, self.THRESHOLD_VALUE,
self.THRESHOLD_MAX_VALUE,
cv2.THRESH_BINARY)
# 一桁ずつ認識させることで揺らぎ率を下げる狙い
one_image = threshold_image[self.Y:self.Y + self.HEIGHT, self.X +
self.WIDTH * 0:self.X + self.WIDTH * 1]
one_speed = self.__image_to_string(one_image, allow_blank=True)
two_image = threshold_image[self.Y:self.Y + self.HEIGHT, self.X +
self.WIDTH * 1:self.X + self.WIDTH * 2]
two_speed = self.__image_to_string(two_image)
if one_speed == '1' and two_speed == '9':
two_speed = '0'
elif one_speed == '' and two_speed == '0':
two_speed = '9'
if one_speed == '' and int(two_speed) < 5:
one_speed = '1'
three_image = threshold_image[self.Y:self.Y + self.HEIGHT, self.X +
self.WIDTH * 2:self.X + self.WIDTH * 3]
three_speed = self.__image_to_string(three_image)
speed_image = threshold_image[self.Y:self.Y + self.HEIGHT,
self.X:self.X + self.WIDTH * 3]
return one_speed + two_speed + three_speed, speed_image
def __image_to_string(self, image, allow_blank=False):
speed = self.ocr.image_to_string(image)
if allow_blank and speed == '':
return ''
# ここはもうパターン列挙で精度を上げにかかる
# 上手く行かない数字があったらマッピングしてあげる
if speed.startswith('q', 0) or speed.startswith('0', 0):
return '0'
elif speed == '|' or speed == 'i' or speed == '':
return '1'
elif speed.startswith('r', 0) or speed == '=':
return '2'
elif speed.startswith('E', 0):
return '3'
elif speed.startswith('u', 0) or speed == 'A' or speed == 'cs':
return '4'
elif speed == '=)':
return '5'
elif speed == 'J' or speed == ']':
return '6'
elif speed.endswith(')') or speed == 'S':
return '9'
return speed
def __init__(self, device):
super(Process, self).__init__()
self.detect = Detect(device)
self.ocr = Ocr(device)
