def get_original(db, _id):
"""Chama mongo_image e joga em uma lista.
Apenas para retirar um if de dentro do for, permitindo atribuir
ponteiro de função antes.
"""
image = mongo_image(db, _id)
PILimage = Image.open(io.BytesIO(image))
return [PILimage]
def anexo():
"""Recupera aenxo do banco e serializa para stream HTTP.
"""
db = app.config['mongo_risco']
filtro = {'metadata.' + key: value for key, value in request.args.items()}
row = db['fs.files'].find_one(filtro)
if row:
_id = row['_id']
mimetype = row.get('metadata').get('contentType') or 'image/jpeg'
image = mongo_image(db, _id)
print(mimetype)
if image:
return Response(response=image, mimetype=mimetype)
return 'Sem Anexo'
def api_image(_id):
db = current_app.config['mongodb']
_id = mongo_sanitizar(_id)
try:
current_app.logger.warning(_id)
image = mongo_image(db, _id)
if image:
return jsonify(dict(
content=b64encode(image).decode(),
mimetype='image/jpeg'
)), 200
return jsonify({}), 404
except Exception as err:
current_app.logger.error(err, exc_info=True)
return jsonify({'msg': 'Erro inesperado: %s' % str(err)}), 400
def update_conformidade(db, engine, start=None, end=None, limit=2000):
Session = sessionmaker(bind=engine)
session = Session()
if start is None:
start = session.query(func.max(Conformidade.uploadDate)).scalar()
if end is None:
end = datetime.datetime.combine(datetime.datetime.now(),
datetime.time.max)
tempo = time.time()
query = {
'metadata.contentType': 'image/jpeg',
'uploadDate': {
'$gte': start,
'$lte': end
}
}
logger.info(query)
cursor = db['fs.files'].find(query).limit(limit)
qtde = 0
for linha in cursor:
image_bytes = mongo_image(db, linha['_id'])
# print(image_bytes)
try:
image = Image.open(io.BytesIO(image_bytes))
conformidade = Conformidade()
conformidade.set_size(image.size)
conformidade.cod_recinto = linha['metadata']['recinto']
conformidade.uploadDate = linha['uploadDate']
conformidade.id_imagem = str(linha['_id'])
conformidade.dataescaneamento = linha['metadata'][
'dataescaneamento']
conformidade.numeroinformado = linha['metadata']['numeroinformado']
session.add(conformidade)
session.commit()
qtde += 1
except UnicodeDecodeError:
logger.error(f'Erro de encoding no id: {linha["_id"]}')
except PIL.UnidentifiedImageError:
logger.error(f'Erro de imagem no id: {linha["_id"]}')
except IntegrityError:
session.rollback()
logger.error(f'Linha duplicada: {linha["_id"]}')
tempo = time.time() - tempo
tempo_registro = 0 if (qtde == 0) else (tempo / qtde)
logger.info(
f'{qtde} análises de conformidade inseridas em {tempo} segundos.' +
f'{tempo_registro} por registro')
def monta_ovr_dict(self,
db,
session,
id: int,
explode=True,
rvfs=True,
imagens=True) -> dict:
"""Retorna um dicionário com conteúdo do OVR, inclusive imagens."""
ovr = get_ovr_one(session, id)
ovr_dict = ovr.dump(explode=explode)
if rvfs:
lista_rvfs = session.query(RVF).filter(RVF.ovr_id == id).all()
rvfs_dicts = [rvf.dump(explode=True) for rvf in lista_rvfs]
ovr_dict['rvfs'] = rvfs_dicts
try:
empresa = get_empresa(session, ovr.cnpj_fiscalizado)
if empresa:
ovr_dict['nome_fiscalizado'] = empresa.nome
except ValueError:
ovr_dict['nome_fiscalizado'] = ''
usuario = get_usuario(session, ovr.cpfauditorresponsavel)
if usuario:
ovr_dict['nome_auditorresponsavel'] = usuario.nome
ovr_dict['auditor_responsavel'] = usuario.nome
ovr_dict['marcas'] = []
descricoes = []
for rvf_dict in rvfs_dicts:
ovr_dict['marcas'].extend(rvf_dict['marcasencontradas'])
if rvf_dict['descricao']:
descricoes.append(rvf_dict['descricao'])
ovr_dict['descricao_mercadoria'] = ' '.join(descricoes)
ovr_dict['marcas'] = ', '.join(ovr_dict['marcas'])
if imagens:
lista_imagens = []
for rvf_dict in rvfs_dicts:
# Garantir que as imagens sigam a ordem definida pelo usuário na exbibição
imagens_rvf = sorted(rvf_dict['imagens'],
key=lambda x: x['ordem'])
for imagem_dict in imagens_rvf:
image = mongo_image(db, imagem_dict['imagem'])
imagem_dict['content'] = io.BytesIO(image)
lista_imagens.append(imagem_dict)
ovr_dict['imagens'] = lista_imagens
for processo in ovr.processos:
ovr_dict['processo_%s' %
processo.tipoprocesso.descricao] = processo.numero
return ovr_dict
def monta_rvf_dict(self,
db,
session,
id: int,
explode=True,
imagens=True) -> dict:
"""Retorna um dicionário com conteúdo do RVF, inclusive imagens."""
rvf = get_rvf_one(session, id)
rvf_dump = rvf.dump(explode=explode, imagens=imagens)
ovr = rvf.ovr
rvf_dump['rvf_id'] = id
if ovr.cpfauditorresponsavel:
usuario = get_usuario(session, ovr.cpfauditorresponsavel)
if usuario:
rvf_dump['auditor_responsavel'] = usuario.nome
if ovr.responsavel:
rvf_dump['responsavel'] = ovr.responsavel.nome
if ovr.recinto:
rvf_dump['recinto'] = ovr.recinto.nome
if ovr.setor:
rvf_dump['setor'] = ovr.setor.nome
exibicao = ExibicaoOVR(session, 1, '')
if ovr.numerodeclaracao:
due = get_due(db, ovr.numerodeclaracao)
due_str = ''
for k, v in due.items():
due_str = f'{k}: {v}\n'
rvf_dump['resumo_due'] = due_str
if ovr.numeroCEmercante:
if exibicao.get_mercante_resumo(ovr):
porto_origem = exibicao.get_mercante_resumo(ovr)[2][24:]
porto_destino = exibicao.get_mercante_resumo(ovr)[3][31:]
rvf_dump['porto_origem'] = porto_origem
rvf_dump['porto_destino'] = porto_destino
resumo_mercante = exibicao.get_mercante_resumo(ovr)
resumo_mercante = '\n'.join(resumo_mercante)
resumo_mercante = re.sub(re.compile('<.*?>'), ' ', resumo_mercante)
rvf_dump['resumo_mercante'] = resumo_mercante
imagens_rvf = sorted(rvf_dump['imagens'], key=lambda x: x['ordem'])
lista_imagens = []
for imagem_dict in imagens_rvf:
image = mongo_image(db, imagem_dict['imagem'])
imagem_dict['content'] = io.BytesIO(image)
lista_imagens.append(imagem_dict)
rvf_dump['imagens'] = lista_imagens
return rvf_dump
def image_id(db, _id):
"""Recupera a imagem do banco e serializa para stream HTTP.
"""
image = mongo_image(db, _id)
try:
size = request.args.get('size')
if size:
width, height = map(int, size.split(','))
pil_img = Image.open(io.BytesIO(image))
pil_img.thumbnail((width, height))
image = PIL_tobytes(pil_img)
except Exception as err:
logger.error('Erro ao processar parâmetro size em /image: %s' %
str(err))
if image:
return Response(response=image, mimetype='image/jpeg')
return 'Sem Imagem'
def predictions_update2(modelo, campo, tamanho, qtde):
"""Consulta padma e grava predições de retorno no MongoDB."""
if not campo:
campo = modelo
cursor = monta_filtro(campo, False, None, tamanho, pulaerros=True)
if not cursor:
return False
registros_processados = 0
registros_vazios = 0
s_inicio = time.time()
images = []
logger.info('get_event_loop')
loop = asyncio.get_event_loop()
for registro in cursor:
_id = registro['_id']
pred_gravado = registro.get('metadata').get('predictions')
if pred_gravado == []:
registros_vazios += 1
logger.info('Pulando registros com anterior insucesso ' +
' (vazios:[]). Registro % d ' % registros_vazios)
continue
registros_processados += 1
if registros_processados == 1:
logger.info('Iniciando varredura de registros')
image = mongo_image(db, _id)
images.extend(
get_images(model=modelo,
_id=_id,
image=image,
predictions=pred_gravado))
if registros_processados % qtde == 0:
s0 = time.time()
loop.run_until_complete(fazconsulta(images, modelo, campo))
images = []
s1 = time.time()
logger.info('Sequência real ...... %d ' % registros_processados +
'{0: .2f} segundos'.format(s1 - s0) +
' modelo %s' % modelo)
# Processa pilha restante...
logger.info('final_loop')
loop.run_until_complete(fazconsulta(images, modelo, campo))
logger.info('end final_loop')
mostra_tempo_final(s_inicio, registros_vazios, registros_processados)
def image_id(_id):
"""Recupera a imagem do banco e serializa para stream HTTP.
Estes métodos dispensam autenticação, pois é necessário ter um _id válido.
O padrão é retornar um bounding box desenhado.
Para evitar o bbox, passar ?bboxes=False na url
"""
db = app.config['mongodb']
bboxes = request.args.get('bboxes', 'True').lower() == 'true'
image = mongo_image(db, _id, bboxes=bboxes)
if image:
contrast, color = get_contrast_and_color_(request)
if contrast or color:
PILimage = bytes_toPIL(image)
if contrast:
PILimage = ImgEnhance.enhancedcontrast_cv2(PILimage)
if color:
PILimage = ImgEnhance.expand_tocolor(PILimage)
image = PIL_tobytes(PILimage)
return Response(response=image, mimetype='image/jpeg')
return 'Sem Imagem'
def do():
print('Iniciando...')
s0 = time.time()
sizes_recinto = defaultdict(list)
cursor = db.fs.files.find(
{
'metadata.contentType': 'image/jpeg',
'metadata.recinto': {
'$exists': True
}
}, {
'_id': 1,
'metadata.recinto': 1
}).limit(100)
for doc in cursor:
_id = doc['_id']
image = Image.open(io.BytesIO(mongo_image(db, _id)))
# print(image.size)
sizes_recinto[doc['metadata']['recinto']].append(image.size)
s1 = time.time()
print('{:0.2f} segundos'.format(s1 - s0))
print(sizes_recinto)
def tfs_predictions_update(modelo, limit=2000, batch_size=20,
pulaerros=False, campo=None,
tfserving_url=TFSERVING_URL):
if not campo:
campo = modelo
cursor = monta_filtro(campo, limit, pulaerros)
if not cursor:
return False
registros_processados = 0
registros_vazios = 0
s_inicio = time.time()
images = []
_ids = []
logger.info('Iniciando leitura das imagens')
for registro in cursor:
_id = registro['_id']
pred_gravado = registro.get('metadata').get('predictions')
registros_processados += 1
image_bytes = mongo_image(db, _id)
image = Image.open(io.BytesIO(image_bytes))
coords = pred_gravado[0].get('bbox')
# logger.info('Image size: %s - bbox: %s' % (image.size, coords))
image = image.crop((coords[1], coords[0], coords[3], coords[2]))
# logger.info('Image size after crop: %s ' % (image.size, ))
image_array = prepara_imagem(image, modelo)
# logger.info('Image array shape: %s ' % (image_array.shape, ) )
images.append(image_array.tolist())
_ids.append(_id)
# print(len(images), end=' ')
if len(images) >= batch_size:
logger.info('Batch carregado, enviando ao Servidor TensorFlow.'
' Modelo: %s' % modelo)
s1 = time.time()
json_batch = {"signature_name": "serving_default", "instances": images}
r = requests.post(tfserving_url + '%s:predict' % modelo,
json=json_batch)
logger.info('Predições recebidas do Servidor TensorFlow'
' Modelo: %s' % modelo)
s2 = time.time()
logger.info('Consulta ao tensorflow serving em %s segundos' % (s2 - s1) +
' para %s exemplos' % batch_size +
' Modelo: %s' % modelo)
try:
preds = r.json()['predictions']
# print(preds)
except Exception as err:
print(r.status_code)
print(r.text)
raise err
# TODO: Salvar predições
for oid, new_pred in zip(_ids, preds):
pred_gravado[0][modelo] = interpreta_pred(new_pred[0], modelo)
# print('Gravando...', pred_gravado, oid)
db['fs.files'].update(
{'_id': oid},
{'$set': {'metadata.predictions': pred_gravado}}
)
logger.info('Predições novas salvas no MongoDB')
images = []
_ids = []
mostra_tempo_final(s_inicio, registros_vazios, registros_processados)
def plot_imagens(imagens):
plt.figure(figsize=(14, 16))
for ind, imagem in enumerate(imagens, 1):
img = Image.open(io.BytesIO(imagem))
plt.subplot(len(imagens), 1, ind)
plt.imshow(img)
st.write('Inicio')
inicio = datetime.datetime(2017, 7, 1)
fim = datetime.datetime(2017, 7, 3)
conhecimentos = get_conhecimentos_um_ncm(inicio, fim)
st.write('Total de conhecimentos do período: %s' % len(conhecimentos))
conhecimentos_ids, ids_indexes = get_indexes_and_ids(mongodb, conhecimentos)
conhecimentos_anomalia = filtra_anomalias(conhecimentos_ids, ids_indexes)
st.write('Total de conhecimentos filtrados: %s' % len(conhecimentos_anomalia))
option = st.selectbox('Qual conhecimento?', conhecimentos_anomalia)
imagens = []
for id in conhecimentos_ids[option]:
img = mongo_image(mongodb, ObjectId(id))
if img:
imagens.append(img)
# print(imagens)
plot_imagens(imagens)
# db.fs.files.find({'metadata.contentType': 'image/jpeg', 'metadata.carga.ncm': {'$size': 1}, 'metadata.carga.container.indicadorusoparcial': {'$ne': 's'}, 'metadata.dataescaneamento': {'$gte': ISODate("2017-07-01"), '$lte': ISODate("2017-07-08")}})
import time
from ajna_commons.utils.images import mongo_image
from predictionsupdate import fazconsulta, get_images, monta_filtro
from virasana.views import db
s0 = time.time()
# Monta lista com 50 imagens recortadas
modelo = 'peso'
filtro = monta_filtro(modelo, sovazios=False, update=True)
cursor = db['fs.files'].find(filtro, {'metadata.predictions': 1}).limit(500)
imagens_recortadas = []
for registro in cursor:
_id = registro['_id']
pred_gravado = registro.get('metadata').get('predictions')
image = mongo_image(db, _id)
imagens_recortadas.extend(get_images(model=modelo, _id=_id, image=image,
predictions=pred_gravado))
print(len(imagens_recortadas))
loop = asyncio.get_event_loop()
index = 0
tempos = {}
for lote in [1, 10, 20, 40, 50, 60, 80, 100]:
index += lote
img_lote = imagens_recortadas[index: index + lote]
s0 = time.time()
loop.run_until_complete(fazconsulta(img_lote, modelo))
s1 = time.time()