def transformaItem(square2, altura1, largura1, identificador, idx2):
square2 = utils.resize(square2, width=largura1, height=altura1)
im2, contours2, hierarchy = cv2.findContours(square2, cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)
cnts = sorted(contours2, key=functionSort, reverse=True)[0]
novaMat = np.zeros(square2.shape, dtype="uint8")
cv2.drawContours(novaMat, [cnts], -1, 255, -1)
utils.save('_img_{}.jpg'.format(idx2), novaMat, id=identificador)
#recarrega a imagem do disco, suaviza e contorna
path = utils.buildPath(identificador, path="_img_" + str(idx2) + ".jpg")
imgGray = cv2.imread(path, cv2.COLOR_BGR2GRAY)
#utils.save('debug_{}_antes.jpg'.format(idx2), imgGray, id=identificador)
imgGray = cv2.medianBlur(imgGray, 5)
utils.save('__{}_depois.jpg'.format(idx2), imgGray, id=identificador)
retval, imgGray = cv2.threshold(imgGray,
2,
255,
type=cv2.THRESH_BINARY | cv2.THRESH_OTSU)
im2, contours, hierarchy = cv2.findContours(imgGray, cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)
cnts2 = contours[0]
debugMat = np.zeros(imgGray.shape, dtype="uint8")
cv2.drawContours(debugMat, [cnts2], -1, 255, -1)
utils.save('debug_{}.jpg'.format(idx2), debugMat, id=identificador)
return cnts2
def escreveImagem(self, imagemBase64, cnhBase64, cnhDimencoes,
identificador):
with open(utils.buildPath(identificador, path=names.ORIGINAL),
"wb") as fh:
fh.write(base64.b64decode(imagemBase64))
if (cnhBase64 != ""):
pathCnhFull = utils.buildPath(identificador,
path=names.CNH_ORIGINAL)
with open(pathCnhFull, "wb") as fh:
fh.write(base64.b64decode(cnhBase64))
#extrai assinatura CNH
cnhFull = cv2.imread(pathCnhFull, cv2.IMREAD_GRAYSCALE)
x = int(cnhDimencoes[0])
y = int(cnhDimencoes[1])
w = int(cnhDimencoes[2])
h = int(cnhDimencoes[3])
cnhAss = cnhFull[y:y + h, x:x + w]
utils.save(names.CNH_ASSINATURA, cnhAss, id=identificador)
def validaAssinaturaCnh(cnhColor, square1, identificador):
cnhColor = utils.removeSombras(cnhColor)
utils.save('cnh_semSombra.jpg', cnhColor, id=identificador)
imgGray = cnhColor #cv2.cvtColor(cnhColor, cv2.IMREAD_GRAYSCALE)
#imgGray = cv2.medianBlur(imgGray, 21)
imgTh, contours, hierarchy = extraiContornos(imgGray, identificador)
contours, resized = utils.ajustaEspacosContorno(contours, imgTh)
utils.save('cnh_resized.jpg', resized, id=identificador)
cnts = contours[0]
novaMat = np.zeros(imgGray.shape, dtype = "uint8")
cv2.drawContours(novaMat, [cnts], -1, 255, -1)
xA, yA, wA, hA = cv2.boundingRect(cnts)
square = novaMat[yA :yA + hA, xA : xA + wA ]
utils.save('cnh_square.jpg', square, id=identificador)
h, w = square1.shape
resized = utils.resize(square, width=w, height=h)
utils.save('_img_6.jpg', resized, id=identificador)
path = utils.buildPath(identificador, path="_img_6.jpg")
print("Novo path " + path)
imgGray = cv2.imread(path, cv2.COLOR_BGR2GRAY)
print(imgGray)
#imgGray = cv2.cvtColor(color, cv2.COLOR_BGR2GRAY)
retval, imgGray = cv2.threshold(imgGray, 2, 255, type = cv2.THRESH_BINARY_INV | cv2.THRESH_OTSU)
imgGray, densidade = utils.removeContornosPqnosImg(imgGray)
im2, contours, hierarchy = cv2.findContours(imgGray, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
#contours, resized = utils.ajustaEspacosContorno(contours, imgTh)
cnts2 = contours[0]
print("Total de contornos CNH ANTES: " + str(len(cnts)))
print("Total de contornos CNH DEPOIS: " + str(len(cnts2)))
return cnts2, resized
def iniciaExtracaoAssinatura(self, identificador):
path = utils.buildPath(identificador, names.ORIGINAL)
print('Processando : ' + path)
return extratorAssinaturaCnh.extraiAssinatura(path, identificador)
def iniciaProcessamento(self, identificador):
path = utils.buildPath(identificador, names.ORIGINAL)
pathCnh = utils.buildPath(identificador, names.CNH_ASSINATURA)
print('Processando : ' + path)
return extrator.extrai(path, pathCnh, identificador)
def criaEstrutura(self):
identificador = self.identificador()
os.makedirs(utils.buildPath(identificador))
return identificador
def extrai(path, identificador):
color = cv2.imread(path, -1)
color = cv2.resize(color, (0, 0), fx = 0.3, fy = 0.3)
imgOriginal = color.copy()
color = utils.removeSombras(color)
utils.save('semSombra.jpg', color, id=identificador)
#imgOriginal, color = recuperaAreaAssinada(color.copy(), imgOriginal, identificador)
#utils.save('antesGray.jpg', color, id=identificador)
imgGray = cv2.cvtColor(color, cv2.COLOR_BGR2GRAY)
imgPbOriginal = imgGray.copy()
utils.save('pb1.jpg', imgGray, id=identificador)
#imgGray = rotate_bound(imgGray, 90)
#utils.save('pb2.jpg', imgGray)
#imgGray = cv2.blur(imgGray, (blurI, blurI))
#utils.save('blur.jpg', imgGray)
utils.save('AntesThr.jpg', imgGray, id=identificador)
imgGray, contours, hierarchy = extraiContornos(imgGray, identificador)
utils.save('thr.jpg', imgGray, id=identificador)
cnts2 = sorted(contours, key=functionSort, reverse=True)[0:5]
printaContornoEncontrado(imgOriginal, cnts2, identificador)
cnts2 = sorted(cnts2, key=functionSortPrimeiroPapel)
printaOrdem(imgOriginal, cnts2, identificador)
originalEmGray = cv2.cvtColor(imgOriginal, cv2.COLOR_BGR2GRAY)
#originalHisto = cv2.equalizeHist(originalEmGray)
originalHisto = originalEmGray
lista = dict()
cntArr = dict()
#ratioDilatacao = recuperaRatioDilatacao(cnts2, imgPbOriginal, identificador)
for i, c in enumerate(cnts2):
x, y, w, h = cv2.boundingRect(c)
b = 0
#print('{} x={} - y{}'.format(i,x,y))
utils.save('imgPbSemSombra2-{}.jpg'.format(i), imgPbOriginal, id=identificador)
roi = imgPbOriginal[y-b:y + h+b, x-b:x + w+b]
utils.save('roi_{}.jpg'.format(i), roi, id=identificador)
#utils.save('_1_hist_{}.jpg'.format(i), roi)
#roi = utils.resize(roi, width=300, height=300)
resized = roi.copy()
#resized = cv2.blur(resized, (blurI,blurI))
#utils.save('__{}_blur1.jpg'.format(i), resized)
#resized = cv2.cvtColor(resized, cv2.COLOR_BGR2GRAY)
#resized = cv2.blur(resized, (5,5))
retval, resized = cv2.threshold(resized, 120, 255, type = cv2.THRESH_BINARY_INV | cv2.THRESH_OTSU)
resized = utils.removeContornosPqnosImg(resized)
utils.save('t_{}.jpg'.format(i), resized, id=identificador)
cv2.waitKey(0)
#print('ratioDilatacao ' + str(ratioDilatacao))
resized = utils.dilatation(resized, ratio=0.3)
utils.save('t1_{}.jpg'.format(i), resized, id=identificador)
im2, contours2, hierarchy = cv2.findContours(resized, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
print('Ajustando espacos')
contours2, resized = ajustaEspacosContorno(contours2, resized)
print('espacos ajustados')
cnts = sorted(contours2, key=functionSort, reverse=True)[0]
#roi = cv2.cvtColor(roi, cv2.COLOR_BGR2GRAY)
novaMat = np.zeros(roi.shape, dtype = "uint8")
cv2.drawContours(novaMat, [cnts], -1, 255, -1)
#novaMat = cv2.resize(novaMat, (200,200), interpolation = cv2.INTER_AREA)
#lista[i] = mahotas.features.zernike_moments(novaMat, 21)
lista[i] = cnts
cntArr[i] = cnts
utils.save('_img_{}.jpg'.format(i), novaMat, id=identificador)
#utils.show(color)
hd = cv2.createHausdorffDistanceExtractor()
sd = cv2.createShapeContextDistanceExtractor()
out = ""
sizeOut = ""
resultadoApi = True
imgResultado = imgOriginal.copy()
for idx1 in range(0,1): #recupera apenas a primeira imagem e a compara com as outras
item1 = lista[idx1]
altura1, largura1 = calculaAlturaLargura(item1)
soma = 0
for idx2 in range(0,5):
item2 = lista[idx2]
altura2, largura2 = calculaAlturaLargura(item2)
#sizeOut += 'Altura {} - {} = {} / {}\n'.format(altura1, altura2, abs(altura1 - altura2), calcPercentual(largura1, largura2))
#sizeOut += 'Largura {} - {} = {} / {}\n'.format(largura1, largura2, abs(largura1 - largura2), calcPercentual(largura1, largura2))
sizeOut += 'Dimensao {} x {} \n'.format(largura2, altura2)
tamanhoCompativel = alturaLarguraCompativel(altura1, largura1, altura2, largura2)
#match = hd.computeDistance(item1, item2)
#match = cv2.matchShapes(cntArr[idx1], cntArr[idx2], 1, 0.0)
ida = sd.computeDistance(item1, item2)
volta = sd.computeDistance(item2, item1)
#ida = dist.euclidean(item1, item2)
#volta = dist.euclidean(item2, item1)
ida = round(ida, 5)
volta = round(volta, 5)
out += '{} vs {} ({}) == {} - {}\n'.format(idx1, idx2, tamanhoCompativel, ida, volta)
#BGR
if ( idx2 == 0 ):
imgResultado = contorna(imgResultado, cnts2[idx2], (0,255,0)) #sucesso
elif ( ida < 10 and volta < 10 and tamanhoCompativel == True):
imgResultado = contorna(imgResultado, cnts2[idx2], (0,255,0)) #sucesso
else:
imgResultado = contorna(imgResultado, cnts2[idx2], (0,0,255)) #falha
resultadoApi = False
pathTxt = utils.buildPath(identificador, path="calc.txt")
with open(pathTxt, "w") as text_file:
text_file.write(sizeOut)
text_file.write('\n')
text_file.write(out)
utils.save(names.RESULTADO, imgResultado, id=identificador)
return resultadoApi
def extrai(path, pathCnh, identificador):
paramsDb = db.select()
valorAceitavel = paramsDb[1]
valorAceitavelCnh = paramsDb[1]
whTolerancia = paramsDb[2]
pxWhiteTolerancia = paramsDb[3]
paramsOut = """ PARAMETROS
Tolerancia Pontos: {0}
Tolerancia Pontos CNH: {1}
Variacao no tamanho: {2}%
Tolerancia densidade: {3}%\n
""".format(valorAceitavel, valorAceitavelCnh, whTolerancia,
pxWhiteTolerancia)
densidadeOut = ""
cnhColor = cv2.imread(pathCnh, -1)
existeCnh = (cnhColor is not None)
if (existeCnh == True):
print("Existe")
color = cv2.imread(path, -1)
color = cv2.resize(color, (0, 0), fx=0.3, fy=0.3)
imgOriginal = color.copy()
color = utils.removeSombras(color)
utils.save('semSombra.jpg', color, id=identificador)
imgGray = cv2.cvtColor(color, cv2.COLOR_BGR2GRAY)
imgPbOriginal = imgGray.copy()
utils.save('pb1.jpg', imgGray, id=identificador)
imgGray, contours, hierarchy = extraiContornos(imgGray, identificador)
utils.save('thr.jpg', imgGray, id=identificador)
cnts2 = sorted(contours, key=sortAltura, reverse=True)
assinaturas = list()
for i, c in enumerate(cnts2):
x, y, w, h = cv2.boundingRect(c)
existeEntre = existeEntreAlgumaFaixa(assinaturas, y, h)
if existeEntre == False:
assinaturas.append((y - 5, y + h + 5))
imgCopy = imgOriginal.copy()
larguraImg = imgOriginal.shape[1]
for ass in assinaturas:
cv2.rectangle(imgCopy, (50, ass[0]), (larguraImg - 50, ass[1]),
(255, 0, 0), 2)
utils.save('identificadas_ass.jpg', imgCopy, id=identificador)
if len(assinaturas) != 5:
msgEx = "Numero de assinaturas encontradas ({}) é diferente do esperado (5)".format(
len(assinaturas))
raise QtdeAssinaturasException(msgEx, identificador)
assinaturas = sorted(assinaturas)
lista = dict()
#ratioDilatacao = recuperaRatioDilatacao(cnts2, imgPbOriginal, identificador)
for i, ass in enumerate(assinaturas):
roi = imgPbOriginal[ass[0]:ass[1], 0:larguraImg]
utils.save('roi_{}.jpg'.format(i), roi, id=identificador)
#roi = utils.resize(roi, width=300, height=300)
resized = roi.copy()
#resized = cv2.blur(resized, (blurI,blurI))
#utils.save('__{}_blur1.jpg'.format(i), resized)
#resized = cv2.cvtColor(resized, cv2.COLOR_BGR2GRAY)
#resized = cv2.blur(resized, (5,5))
retval, resized = cv2.threshold(resized,
120,
255,
type=cv2.THRESH_BINARY_INV
| cv2.THRESH_OTSU)
utils.save('th_roi_{}.jpg'.format(i), resized, id=identificador)
resized, densidade = utils.removeContornosPqnosImg(resized)
utils.save('t_{}.jpg'.format(i), resized, id=identificador)
#cv2.waitKey(0)
#print('ratioDilatacao ' + str(ratioDilatacao))
#resized = utils.dilatation(resized, ratio=0.4)
utils.save('t1_{}.jpg'.format(i), resized, id=identificador)
im2, contours2, hierarchy = cv2.findContours(resized,
cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)
contours2, resized = utils.ajustaEspacosContorno(contours2, resized)
cnts = sorted(contours2, key=functionSort, reverse=True)[0]
novaMat = np.zeros(roi.shape, dtype="uint8")
cv2.drawContours(novaMat, [cnts], -1, 255, -1)
xA, yA, wA, hA = cv2.boundingRect(cnts)
square = novaMat[yA:yA + hA, xA:xA + wA]
utils.save('square_{}.jpg'.format(i), square, id=identificador)
#moment = mahotas.features.zernike_moments(square, 21)
densidadeOut += "Densidade {} = {}\n".format(i, densidade)
lista[i] = cnts, ass, square, densidade
#utils.show(color)
hd = cv2.createHausdorffDistanceExtractor()
sd = cv2.createShapeContextDistanceExtractor()
out = ""
outCnh = ""
sizeOut = ""
resultadoApi = True
imgResultado = imgOriginal.copy()
percentCnh = []
for idx1 in range(
0,
1): #recupera apenas a primeira imagem e a compara com as outras
item1 = lista[idx1][0]
square1 = lista[idx1][2]
dens1 = lista[idx1][3]
altura1, largura1 = calculaAlturaLargura(item1)
soma = 0
item1 = transformaItem(square1, altura1, largura1, identificador, idx1)
itemCnh = None
if (existeCnh == True):
itemCnh, squareCnh = cnh.validaAssinaturaCnh(
cnhColor, square1, identificador)
itemCnh = transformaItem(squareCnh, altura1, largura1,
identificador, 6)
print("Contornos img_6 = " + str(len(itemCnh)))
for idx2 in range(0, 5):
print("Processando imagem " + str(idx2))
item2 = lista[idx2][0]
ass = lista[idx2][1]
square2 = lista[idx2][2]
dens2 = lista[idx2][3]
altura2, largura2 = calculaAlturaLargura(item2)
sizeOut += 'Dimensao {} x {} \n'.format(largura2, altura2)
tamanhoCompativel = alturaLarguraCompativel(
altura1, largura1, altura2, largura2, whTolerancia)
densidadeCompativel = calcDensidadeCompativel(
dens1, dens2, pxWhiteTolerancia)
item2 = transformaItem(square2, altura1, largura1, identificador,
idx2)
print("Contornos img_" + str(idx2) + " = " + str(len(item2)))
#match = hd.computeDistance(item1, item2)
if (idx1 != idx2):
idaSD = round(sd.computeDistance(item1, item2), 5)
voltaSD = round(sd.computeDistance(item2, item1), 5)
idaHD = round(hd.computeDistance(item1, item2), 5)
voltaHD = round(hd.computeDistance(item2, item1), 5)
idaMM = calculaMoment(item1, idx1, item2, idx2, identificador)
voltaMM = idaMM
else:
idaSD = 0
voltaSD = 0
idaHD = 0
voltaHD = 0
idaMM = 0
voltaMM = 0
if (existeCnh == True):
idaCnh = round(sd.computeDistance(item2, itemCnh), 5)
voltaCnh = round(sd.computeDistance(itemCnh, item2), 5)
percentSimCnh = calculaSimilaridade(idaCnh, voltaCnh,
valorAceitavelCnh)
outCnh += '{} == {} - {} = {}%\n'.format(
idx2, idaCnh, voltaCnh, percentSimCnh)
percentCnh.append(percentSimCnh)
#ida = dist.euclidean(item1, item2)
#volta = dist.euclidean(item2, item1)
out += '{} vs {} (T{}, D{}) \n'.format(idx1, idx2,
tamanhoCompativel,
densidadeCompativel)
out += '----SD: {} - {} \n'.format(idaSD, voltaSD)
out += '----HD: {} - {} \n'.format(idaHD, voltaHD)
out += '----MH: {} - {} \n'.format(idaMM, voltaMM)
#BGR
if (idaSD < valorAceitavel and voltaSD < valorAceitavel
and tamanhoCompativel == True
and densidadeCompativel == True):
imgResultado = contorna(imgResultado, larguraImg, ass,
(0, 255, 0)) #sucesso
else:
imgResultado = contorna(imgResultado, larguraImg, ass,
(0, 0, 255)) #falha
resultadoApi = False
pathTxt = utils.buildPath(identificador, path="calc.txt")
with open(pathTxt, "w") as text_file:
text_file.write(paramsOut)
text_file.write('\n')
text_file.write(sizeOut)
text_file.write('\n')
text_file.write(densidadeOut)
text_file.write('\n')
text_file.write(out)
text_file.write('\n')
text_file.write(outCnh)
utils.save(names.RESULTADO, imgResultado, id=identificador)
return {
'folhaAssinatura': resultadoApi,
'resultadoCnh': False,
'percentCnh': percentCnh
}