def encode_all_images(self):
encoded = PyZip()
encoded['diferenciador.jpg'] = ImagePack.convert_to_bytes(self.differentiator_image)
for i in range(0, len(self.captures_images)):
image = self.captures_images[i]
encoded[f'captura_{i + 1}.jpg'] = ImagePack.convert_to_bytes(image)
return b64encode(encoded.to_bytes())
def draw_rectangle(self, frame):
""" Método que recupera os pontos do retângulo, valida-os e desenha no frame recebido como parâmetro.
Sempre retorna uma imagem no padrão OpenCV (ndarray).
A imagem retornada terá um retângulo desenhado caso exista um retângulo válido salvo.
"""
if self.is_valid_rectangle():
ImagePack.draw_rectangle(frame, self.initial_xy(), self.final_xy())
return frame
def get_image(self):
""" Retorna a imagem atualmente em foco do projeto.
A imagem pode ser tanto a de um upload feito pelo usuário ou o frame atual da webcam.
A imagem retornada está no formato jpeg e contêm o retângulo desenhado pelo usuário (caso exista).
"""
try:
if(self.uploaded_frame.is_valid()):
copy = self.uploaded_frame.get_copy()
else:
copy = self.captured_frame.get_copy()
return self.draw_and_convert_frame(copy)
except:
return ImagePack.encode_to_jpg(ImagePack.black_image())
def save_uploaded_image(self, image):
""" Recebe uma imagem enviada pelo usuário e armazena para uso posterior.
A imagem é convertida para o padrão do OpenCV (ndarray).
Antes de ser salva, a imagem é também redimensionada para o mesmo tamanho do frame atual da webcam.
Nenhum retorno.
"""
try:
frame = ImagePack.convert_to_frame(image)
video_dimensions = self.video_capture.get_video_dimensions()
new_image = ImagePack.resize_image(frame, video_dimensions)
self.uploaded_frame.set_frame(new_image)
except:
pass
def start_video_stream(self, port):
""" Método que efetivamente cria a instância de VideoCapture da biblioteca OpenCv.
O método recebe um inteiro correspondente a porta que será usada pela webcam (inicialmente a porta 0).
Nenhum retorno.
"""
with self.lock_video:
self.video_capture = ImagePack.new_stream(port)
def capture_frame(self):
""" Método chamado pela Thread para capturar o frame. Sempre retorna uma imagem no padrão OpenCV (ndarray).
Se _is_working for true e a webcam atual é valida, captura um frame.
Caso contrário, retorna uma imagem padrão setada para preto.
"""
if (self.is_working() and self.is_valid()):
return self._do_capture()
return ImagePack.black_image()
def get_differentiator_image(self):
""" Recupera a imagem do diferenciador e a formata para ser retornada ao front-end.
Se nenhum erro ocorrer, retorna uma imagem em formato JPG codificada em bytes na base64.
Se um erro ocorrer, retorna uma string vazia.
"""
try:
jpg_image = ImagePack.encode_to_jpg(self.differentiator_image)
return b64encode(jpg_image)
except:
return ''
def webcans_list(self):
""" retorna a lista de webcans disponíveis atualmente.
O método tenta abrir as portas de webcam diferentes da atual e finaliza quando falha pela primeira vez.
Isso se baseia no princípio de que as portas da webcam sempre iniciam no 0 (principal do computador) e vão aumentando de 1 em 1.
"""
list_webcans = []
for index in range(100):
if index == self.current_port:
continue
if not ImagePack.is_valid_webcam(index):
break
list_webcans.append(index)
list_webcans.insert(self.current_port, self.current_port)
return list_webcans
def change(self, new_port):
""" Método encarregado de liberar o video atual e inicializar uma nova webcam a partir da porta recebida por parâmetro.
O parâmetro recebido deve ser um inteiro maior ou igual a zero.
Caso o processo seja um sucesso, retorna a resolução da webcam.
Caso algo falhe, retorna uma string vazia.
"""
try:
with self.lock_video:
to_dispose = self.video_capture
self.video_capture = ImagePack.new_stream(new_port)
self._is_working = True
self.define_resolution()
to_dispose.release()
return self.video_status()
except:
return ''
def _do_capture(self):
""" Método que efetivamente faz a captura do frame. Sempre retorna uma imagem no padrão OpenCV (ndarray). """
with self.lock_video:
success, frame = self.video_capture.read()
self.set_working_state(success)
return frame if success else ImagePack.black_image()
def draw_and_convert_frame(self, copy): drawed_image = self.rectangle.draw_rectangle(copy) return ImagePack.encode_to_jpg(drawed_image)
def is_valid(self):
with self._lock:
return ImagePack.validate_image(self._frame)