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)