mpvc 0.0.1__tar.gz

mpvc-0.0.1/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: mpvc
+Version: 0.0.1
+Summary: Módulo para detecção de mão, rosto e malha facial usando MediaPipe e OpenCV
+Author-email: Mundo Python <mundopython98@gmail.com>
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: <=3.12,>=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: opencv-python
+Requires-Dist: mediapipe==0.10.21

mpvc-0.0.1/mpvc/__init__.py

@@ -0,0 +1,17 @@
+"""
+MPVC - MediaPipe & OpenCV Detectors
+Módulo profissional para detecção simplificada de mãos, rostos e malha facial.
+"""
+
+from .detector_maos import DetectorMaos
+from.detector_rosto import DetectorRosto
+from .malha_rosto import DetectorMalhaRosto
+
+__all__ = [
+    'DetectorMaos',
+    'DetectorRosto',
+    'DetectorMalhaRosto'
+]
+
+__version__ = '0.0.1'
+__author__ = 'Mundo Python'

mpvc-0.0.1/mpvc/detector_maos.py

@@ -0,0 +1,244 @@
+# --- Importar as bibliotecas --- #
+import cv2
+import math
+import numpy as np
+import mediapipe as mp
+from typing import Any, List, Tuple
+
+
+class DetectorMaos:
+    """Classe responsável pela detecção de mãos."""
+    def __init__(
+            self,
+            modo: bool = False,
+            max_maos: int = 2,
+            deteccao_confianca: float = 0.5,
+            rastreio_confianca: float = 0.5,
+            cor_pontos: Tuple[int, int, int] = (0, 0, 255),
+            cor_conexoes: Tuple[int, int, int] = (255, 255, 255),
+    ):
+        """
+        Função responsável por inicializar a classe.
+
+        :param modo: Modo de captura da imagem. Se True, a detecção e rastreio serão feitos a todo momento;
+        fica muito travado. Se False, não são feitas a detecção e rastreio a todo momento; pode perder por
+        alguns instantes as marcações, porém não trava.
+
+        :param max_maos: Quantidade máxima de mãos para serem detectadas.
+
+        :param deteccao_confianca: Percentual da taxa de detecção da mão. Se for menor do que este limite,
+        a deteção não ocorre.
+
+        :param rastreio_confianca: Percentual da taxa de detecção da mão. Se for menor do que este limite,
+        a detecção não ocorre.
+
+        :param cor_pontos: Cor dos pontos.
+
+        :param cor_conexoes: Cor das conexões.
+        """
+        # --- Inicializar os módulos de detecção das mãos --- #
+        self.maos_mp = mp.solutions.hands
+        self.maos = self.maos_mp.Hands(
+            modo,
+            max_maos,
+            1,
+            deteccao_confianca,
+            rastreio_confianca
+        )
+
+        # --- Função para desenhar os pontos nas mãos --- #
+        self.desenho = mp.solutions.drawing_utils
+
+        # --- Confifuração do desenho dos pontos --- #
+        self.desenho_pontos = self.desenho.DrawingSpec(color=cor_pontos)
+
+        # --- Configuração do desenho das conexões --- #
+        self.desenho_conexoes = self.desenho.DrawingSpec(color=cor_conexoes)
+
+    def encontrar_maos(self, imagem: np.ndarray, desenho: bool = True) -> np.ndarray:
+        """
+        Função responsável por detectar a(s) mão(s).
+        :param imagem: Imagem capturada.
+        :param desenho: Desenhar os pontos e as conexões na(s) mão(s).
+        :return: Retorna a imagem com a detecção.
+        """
+        # --- Converter a imagem de BGR para RGB --- #
+        imagem_rgb = cv2.cvtColor(imagem, cv2.COLOR_BGR2RGB)
+
+        # --- Passar a imagem convertida para o detector --- #
+        self.resultado = self.maos.process(imagem_rgb)
+
+        # --- Verificar se alguma mão foi detectada --- #
+        if self.resultado.multi_hand_landmarks:
+            for pontos in self.resultado.multi_hand_landmarks:
+                if desenho:
+                    # --- Desenhar os pontos nas mãos detectadas --- #
+                    self.desenho.draw_landmarks(
+                        imagem,
+                        pontos,
+                        self.maos_mp.HAND_CONNECTIONS,
+                        self.desenho_pontos,
+                        self.desenho_conexoes
+                    )
+
+        return imagem
+
+    def encontrar_pontos(
+            self,
+            imagem: np.ndarray,
+            mao_num: int = 0,
+            desenho: bool = True,
+            cor: Tuple[int, int, int] = (255, 0, 255),
+            raio: int = 7,
+            ponto_detectado: Any = 0
+    ) -> List:
+        """
+        Função responsável por encontrar a posição dps pontos da(s) mão(s).
+        :param imagem: Imagem capturada.
+        :param mao_num: Número da mão detectada.
+        :param desenho: Desenhar o ponto encontrado.
+        :param cor: Tupla com a cor do ponto (RGB).
+        :param raio: Raio do círculo do ponto.
+        :param ponto_detectado: Ponto a ser detectado.
+        :return: Lista com os pontos detectados.
+        """
+        # --- Lista com os pontos detectados --- #
+        lista_pontos = []
+
+        # --- Garantir que o ponto_detectado seja uma lista --- #
+        if isinstance(ponto_detectado, int):
+            pontos_alvo = [ponto_detectado]
+        else:
+            pontos_alvo = ponto_detectado
+
+        # --- Obter as dimensões da imagem capturada --- #
+        altura, largura, _ = imagem.shape
+
+        # --- Verificar se alguma mão foi detectada --- #
+        if self.resultado.multi_hand_landmarks:
+            for num_mao, landmark_mao in enumerate(self.resultado.multi_hand_landmarks):
+                # --- Lista com os pontos da mão detectada --- #
+                lista_pontos_mao = []
+                # --- Obter as informações dos pontos --- #
+                for id_, ponto in enumerate(landmark_mao.landmark):
+                    if id_ in pontos_alvo:
+                        # --- Transformar a posição do ponto de proporção para pixel --- #
+                        centro_x, centro_y = int(ponto.x * largura), int(ponto.y * altura)
+
+                        # --- Adicionar os pontos da mão detectda na lista --- #
+                        lista_pontos_mao.append([id_, centro_x, centro_y])
+
+                        # --- Colocar um círculo em um ponto --- #
+                        if desenho:
+                            cv2.circle(
+                                imagem,
+                                (centro_x, centro_y),
+                                raio,
+                                cor,
+                                cv2.FILLED
+                            )
+                lista_pontos.append(lista_pontos_mao)
+
+        return lista_pontos
+
+    def encontrar_distancia(
+            self,
+            ponto_1: int,
+            ponto_2: int,
+            imagem: np.ndarray,
+            mao_num: int = 0,
+            desenho_linha: bool = True,
+            desenho_ponto: bool = True,
+            cor_linha: Tuple[int, int, int] = (255, 0, 255),
+            cor_ponto: Tuple[int, int, int] = (0, 255, 0),
+            espessura: int = 2,
+            raio: int = 7
+    ) -> Tuple[float, np.ndarray, List[int]]:
+        """
+        Função responsável por calcular a distância entre dois pontos da mão.
+        :param ponto_1: ID do primeiro ponto.
+        :param ponto_2: ID do segundo ponto.
+        :param imagem: Imagem capturada.
+        :param mao_num: Índice da mão detectada.
+        :param desenho_linha: Se True, desenha uma linha entre os pontos e o centro.
+        :param desenho_ponto: Se True, desenha o ponto médio entre os pontos selecionados.
+        :param cor_linha: Cor da linha.
+        :param cor_ponto: Cor do ponto médio.
+        :param espessura: Espessura da linha que conecta os pontos.
+        :param raio: Raio do ponto central da linha.
+        :return: Uma tupla contendo a distância calculada, a imagem e uma lista com as coordenadas.
+        """
+        distancia = 0
+        info_pontos = []
+
+        # --- Verificar se alguma mão foi detectada e se o índice da mão existe --- #
+        if self.resultado.multi_hand_landmarks and len(self.resultado.multi_hand_landmarks) > mao_num:
+            mao_alvo = self.resultado.multi_hand_landmarks[mao_num]
+            altura, largura, _ = imagem.shape
+
+            # --- Extrair as coordenadas em pixels dos dois pontos --- #
+            x_1 = int(mao_alvo.landmark[ponto_1].x * largura)
+            y_1 = int(mao_alvo.landmark[ponto_1].y * altura)
+
+            x_2 = int(mao_alvo.landmark[ponto_2].x * largura)
+            y_2 = int(mao_alvo.landmark[ponto_2].y * altura)
+
+            # --- Encontrar o ponto central entre os pontos --- #
+            centro_x, centro_y = (x_1 + x_2) // 2, (y_1 + y_2) // 2
+            info_pontos = [x_1, y_1, x_1, y_2, centro_x, centro_y]
+
+            # --- Calcular a distância euclidiana --- #
+            distancia = math.hypot(x_2 - x_1, y_2 - y_1)
+
+            # --- Desenhar a linha e o ponto central --- #
+            if desenho_linha:
+                cv2.line(imagem, (x_1, y_1), (x_2, y_2), cor_linha, espessura)
+            if desenho_ponto:
+                cv2.circle(imagem, (centro_x, centro_y), raio, cor_ponto, cv2.FILLED)
+
+        return distancia, imagem, info_pontos
+
+
+def main():
+    # --- Capturar o vídeo pela webcam --- #
+    cap = cv2.VideoCapture(0)
+
+    # --- Instanciar a classe do detector --- #
+    detector = DetectorMaos()
+
+    # --- Realizar a captura --- #
+    while True:
+        # --- Obter a imagem --- #
+        _, imagem = cap.read()
+
+        # --- Inverter a imagem --- #
+        imagem = cv2.flip(imagem, 1)
+
+        # --- Realizar a detecção das mãos --- #
+        imagem = detector.encontrar_maos(imagem)
+
+        # --- Lista com os pontos --- #
+        lista_pontos = detector.encontrar_pontos(imagem)
+
+        # --- Distância entre os pontos --- #
+        if len(lista_pontos) != 0 and len(lista_pontos[0]) > 0:
+            distancia, imagem, info = detector.encontrar_distancia(4, 8, imagem, desenho_ponto=False)
+            cv2.putText(
+                imagem,
+                f'Dist: {int(distancia)}',
+                (10, 50),
+                cv2.FONT_HERSHEY_SIMPLEX,
+                1,
+                (255, 255, 0),
+                2
+            )
+
+        # --- Mostrar a imagem de captura --- #
+        cv2.imshow('Captura', imagem)
+
+        # --- Tempo de atualização da captura --- #
+        cv2.waitKey(1)
+
+
+if __name__ == '__main__':
+    main()

mpvc-0.0.1/mpvc/detector_rosto.py

@@ -0,0 +1,232 @@
+# --- Importar as bibliotecas --- #
+import cv2
+import numpy as np
+import mediapipe as mp
+from typing import List, Tuple
+
+class DetectorRosto:
+    """Classe responsável por detectar rostos."""
+    def __init__(self, deteccao_confianca: float = 0.5):
+        """
+        Função responsável por iniciar a classe.
+        :param deteccao_confianca: Percentual da taxa de detecção do rosto. Se for menor que este limite,
+        a detecção não ocorre.
+        """
+        # --- Inicializar a função de detecção do rosto --- #
+        self.rosto_mp = mp.solutions.face_detection
+        self.rosto = self.rosto_mp.FaceDetection(deteccao_confianca)
+
+    def encontrar_rosto(
+            self,
+            imagem: np.ndarray,
+            desenho: bool = True,
+            cor_caixa: Tuple[int, int, int] = (255, 0, 255),
+            cor_moldura: Tuple[int, int, int] = (255, 0, 255),
+            comprimento: int = 30,
+            espessura_moldura: int = 5,
+            espessura_retangulo: int = 1,
+            desenho_caixa: bool = True,
+            desenho_moldura: bool = True,
+            texto: bool = True
+    ) -> Tuple[np.ndarray, List]:
+        """
+        Função responsável por detectar o(s) rosto(s).
+        :param imagem: Imagem capturada.
+        :param desenho: Desenhar a(s) caixa(s) de detecção do(s) rosto(s).
+        :param cor_caixa: Cor da caixa.
+        :param cor_moldura: Cor da moldura.
+        :param comprimento: Comprimento da linha da moldura.
+        :param espessura_moldura: Espessura da linha da moldura.
+        :param espessura_retangulo: Espessura do retângulo da(s) caixa(s).
+        :param desenho_caixa: Desenhar a caixa de detecção.
+        :param desenho_moldura: Desenhar a moldura na caixa de detecção.
+        :param texto: Escrever o texto da porcentagem de detecção.
+        :return: Retorna a imagem com a detecção e a lista com a(s) caixa(s) de detecção.
+        """
+        # --- Converter a imagem de BGR para RGB --- #
+        imagem_rgb = cv2.cvtColor(imagem, cv2.COLOR_BGR2RGB)
+
+        # --- Passar a imagem convertida para o detector --- #
+        resultado = self.rosto.process(imagem_rgb)
+
+        # --- Dimensões da imagem de captura --- #
+        altura, largura, _ = imagem.shape
+
+        # --- Lista com as caixa de detecção do rosto --- #
+        caixas = []
+
+        # --- Verificar se ocorreu a detecção do rosto --- #
+        if resultado.detections:
+            # --- Obter o ID da detecção, bem como a detecção --- #
+            for id_, deteccao in enumerate(resultado.detections):
+                # --- Informações da caixa de reconhecimento --- #
+                info_caixa = deteccao.location_data.relative_bounding_box
+
+                # --- Caixa de detecção --- #
+                caixa = (int(info_caixa.xmin * largura), int(info_caixa.ymin * altura),
+                         int(info_caixa.width * largura), int(info_caixa.height * altura))
+
+                # --- Adicionar a caixa à lista de caixas --- #
+                caixas.append([id_, caixa, deteccao.score])
+
+                # --- Desenhar a caixa em volta do rosto detectado --- #
+                if desenho:
+                    imagem = self.desenho_moldura(
+                        imagem,
+                        caixa,
+                        cor_caixa,
+                        cor_moldura,
+                        comprimento,
+                        espessura_moldura,
+                        espessura_retangulo,
+                        desenho_caixa,
+                        desenho_moldura
+                    )
+
+                    if texto:
+                        # --- Colocar na caixa de detecção a porcentagem de certeza da detecção --- #
+                        cv2.putText(
+                            imagem,
+                            f'{int(deteccao.score[0] * 100)}%',
+                            (caixa[0], caixa[1] - 20),
+                            cv2.FONT_HERSHEY_PLAIN,
+                            2,
+                            cor_caixa,
+                            2
+                        )
+
+        return imagem, caixas
+
+    def desenho_moldura(
+            self,
+            imagem: np.ndarray,
+            caixa: List,
+            cor_caixa: Tuple,
+            cor_moldura: Tuple,
+            comprimento: int,
+            espessura_moldura: int,
+            espessura_retangulo: int,
+            desenho_caixa: bool,
+            desenho_moldura: bool
+    )-> np.ndarray:
+        """
+        Função responsável por criar a moldura da caixa de detecção do(s) rosto(s).
+        :param imagem: Imagem capturada.
+        :param caixa: Caixa de detecção.
+        :param cor_caixa: Cor da caixa.
+        :param cor_moldura: Cor da moldura.
+        :param comprimento: Comprimento da linha da moldura.
+        :param espessura_moldura: Espessura da linha da moldura.
+        :param espessura_retangulo: Espessura do retângulo da(s) caixa(s).
+        :param desenho_caixa: Desenhar a caixa de detecção.
+        :param desenho_moldura: DEsenhar a moldura na caixa de detecção.
+        :return: Retorna a imagem com a caixa de detecção desenhada.
+        """
+        # --- Dimensões da caixa --- #
+        x, y, largura, altura = caixa
+
+        # --- Pontos iniciais da moldura --- #
+        x_1, y_1 = x + largura, y + largura
+
+        if desenho_caixa:
+            # --- Desenhar a caixa em volta do rosto detectado --- #
+            cv2.rectangle(
+                imagem,
+                caixa,
+                cor_caixa,
+                espessura_retangulo
+            )
+
+        if desenho_moldura:
+            # --- Canto superior esquerdo --- #
+            cv2.line(
+                imagem,
+                (x, y),
+                (x + comprimento, y),
+                cor_moldura,
+                espessura_moldura
+            )
+            cv2.line(
+                imagem,
+                (x, y),
+                (x, y + comprimento),
+                cor_moldura,
+                espessura_moldura
+            )
+
+            # --- Canto superior direito --- #
+            cv2.line(
+                imagem,
+                (x_1, y),
+                (x_1 - comprimento, y),
+                cor_moldura,
+                espessura_moldura
+            )
+            cv2.line(
+                imagem,
+                (x_1, y),
+                (x_1, y + comprimento),
+                cor_moldura,
+                espessura_moldura
+            )
+
+            # --- Canto inferior esquerdo --- #
+            cv2.line(
+                imagem,
+                (x, y_1),
+                (x + comprimento, y_1),
+                cor_moldura,
+                espessura_moldura
+            )
+            cv2.line(
+                imagem,
+                (x, y_1),
+                (x, y_1 - comprimento),
+                cor_moldura,
+                espessura_moldura
+            )
+
+            # --- Canto inferior direito --- #
+            cv2.line(
+                imagem,
+                (x_1, y_1),
+                (x_1 - comprimento, y_1),
+                cor_moldura,
+                espessura_moldura
+            )
+            cv2.line(
+                imagem,
+                (x_1, y_1),
+                (x_1, y_1 - comprimento),
+                cor_moldura,
+                espessura_moldura
+            )
+
+        return imagem
+
+
+def main():
+    # --- Captura da webcam --- #
+    cap = cv2.VideoCapture(0)
+
+    # --- Instanciar o detector de rosto --- #
+    detector = DetectorRosto()
+
+    # --- Loop de captura --- #
+    while True:
+        # --- Obter a imagem --- #
+        _, imagem = cap.read()
+
+        # --- Inverter a imagem --- #
+        imagem = cv2.flip(imagem, 1)
+
+        imagem, caixas = detector.encontrar_rosto(imagem)
+
+        # --- Mostrar a captura --- #
+        cv2.imshow('Captura', imagem)
+
+        # --- Tempo de atualização da captura --- #
+        cv2.waitKey(1)
+
+if __name__ == '__main__':
+    main()

mpvc-0.0.1/mpvc/malha_rosto.py

@@ -0,0 +1,160 @@
+# --- Importar as bibliotecas --- #
+import cv2
+import numpy as np
+import mediapipe as mp
+from typing import List, Tuple
+
+class DetectorMalhaRosto:
+    def __init__(
+            self,
+            modo: bool = False,
+            max_rosto: int = 2,
+            refinar_pontos: bool = False,
+            deteccao_confianca: float = 0.5,
+            rastreio_confianca: float = 0.5,
+            cor_pontos: Tuple = (255, 255, 255),
+            cor_conexoes: Tuple = (0, 255, 0)
+    ):
+        """
+        Função responsável por inicializar a classe.
+
+        :param modo: Modo de captura da imagem. Se True, a detecção e o rastrio serão feitos a todo momento;
+        deixa muito travado. Se False, não são feitas a detecção e rastrio a todo momento; pode perder
+        pos alguns instântes as marcações, porém não trava.
+
+        :param max_rostos: Quantidade máxima de rostos para serem detectados.
+
+        :param refinar_pontos: Refinar as coordenadas dos pontos da boca e dos olhos.
+
+        :param deteccao_confianca: Percentual da taxa de detecção do rosto. Se for menor do que este limite,
+        a detecção não ocorre.
+
+        :param rastreio_confianca:  Percentual da taxa do rastreio do rosto. Se for menor do que este limite,
+        o rastreio não ocorre.
+
+        :param cor_pontos: Cor dos pontos.
+
+        :param cor_conexoes: Cor das conexões.
+        """
+
+        # --- Inicializar a função de detecção da malha do rosto --- #
+        self.malha_rosto_mp = mp.solutions.face_mesh
+        self.malha_rosto = self.malha_rosto_mp.FaceMesh(
+            modo,
+            max_rosto,
+            refinar_pontos,
+            deteccao_confianca,
+            rastreio_confianca
+        )
+        self.malha_rosto_conexoes = mp.solutions.face_mesh_connections
+
+        # --- Função para desenhar a malha no rosto --- #
+        self.desenho = mp.solutions.drawing_utils
+
+        # --- Configuração do desenho dos pontos --- #
+        self.desenho_pontos = self.desenho.DrawingSpec(
+            color=cor_pontos,
+            thickness=1,
+            circle_radius=1
+        )
+
+        # --- Configuração do desenho das conexões --- #
+        self.desenho_conexoes = self.desenho.DrawingSpec(
+            color=cor_conexoes,
+            thickness=1
+        )
+
+    def encontrar_malha_rosto(
+            self,
+            imagem: np.ndarray,
+            desenho: bool = True
+    )-> np.ndarray:
+        """
+        Função responsável por detectar o(s) rosto(s) e aplicar a malha.
+        :param imagem: Imagem capturada.
+        :param desenho: Desenhar a(s) malha(s) no(s) rosto(s).
+        :return: Retorna a imagem com a malha facial.
+        """
+        # --- Converter a imagem de BGR para RGB --- #
+        imagem_rgb = cv2.cvtColor(imagem, cv2.COLOR_BGR2RGB)
+
+        # --- Passar a imagem convertida para o detector --- #
+        self.resultado = self.malha_rosto.process(imagem_rgb)
+
+        # --- Verificar se ocorreu detecção do rosto --- #
+        if self.resultado.multi_face_landmarks:
+            # --- Obter os pontos da malha facial --- #
+            for ponto in self.resultado.multi_face_landmarks:
+                if desenho:
+                    # --- Desenhar os pontos da malha --- #
+                    self.desenho.draw_landmarks(
+                        imagem,
+                        ponto,
+                        self.malha_rosto_conexoes.FACEMESH_CONTOURS,
+                        self.desenho_pontos,
+                        self.desenho_conexoes
+                    )
+
+        return imagem
+
+    def encontrar_pontos(self, imagem: np.ndarray) -> List:
+        """
+        Função responsável por informar os pontos da malha facial.
+        :param imagem: Imagem capturada.
+        :return: Retorna a lista com os pontos da(s) malha(s) do(s) rosto(s) detectado(s).
+        """
+        # --- Lista com os pontos do rosto --- #
+        rostos = []
+
+        # --- Obter as dimensões da imagem --- #
+        altura, largura, _ = imagem.shape
+
+        # --- Verificar se ocorreu a detecção do rosto --- #
+        if self.resultado.multi_face_landmarks:
+            # --- Obter os pontos da malha facial --- #
+            for pontos in self.resultado.multi_face_landmarks:
+                # --- Lista com a malha do rosto detectado --- #
+                rosto = []
+
+                # --- Obter a informação de cada ponto da malha --- #
+                for  id_, ponto in enumerate(pontos.landmark):
+                    # --- Converter os valores de proporção para pixels --- #
+                    x, y = int(ponto.x * largura), int(ponto.y * altura)
+
+                    # --- Adicionar à lista de rosto o ponto do rosto --- #
+                    rosto.append([id_, x, y])
+
+                # --- Adicionar a lista com os pontos do rosto à lista de rostos detectados --- #
+                rostos.append(rosto)
+
+        return rostos
+
+
+def main():
+    # --- Captura da webcam --- #
+    cap = cv2.VideoCapture(0)
+
+    # --- Instanciar o detector da malha facial --- #
+    detector = DetectorMalhaRosto()
+
+    # --- Loop de captura --- #
+    while True:
+        # --- Captura da imagem --- #
+        _, imagem = cap.read()
+
+        # --- Inverter a imagem --- #
+        imagem = cv2.flip(imagem, 1)
+
+        # --- Detectar a malha do rosto --- #
+        imagem = detector.encontrar_malha_rosto(imagem)
+        rostos = detector.encontrar_pontos(imagem)
+
+        # --- Mostrar a imagem --- #
+        cv2.imshow('Captura', imagem)
+
+        # --- Tempo de atualização --- #
+        cv2.waitKey(1)
+
+
+if __name__ == '__main__':
+    main()

mpvc-0.0.1/mpvc.egg-info/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: mpvc
+Version: 0.0.1
+Summary: Módulo para detecção de mão, rosto e malha facial usando MediaPipe e OpenCV
+Author-email: Mundo Python <mundopython98@gmail.com>
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: <=3.12,>=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: opencv-python
+Requires-Dist: mediapipe==0.10.21

mpvc-0.0.1/mpvc.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+README.md
+pyproject.toml
+mpvc/__init__.py
+mpvc/detector_maos.py
+mpvc/detector_rosto.py
+mpvc/malha_rosto.py
+mpvc.egg-info/PKG-INFO
+mpvc.egg-info/SOURCES.txt
+mpvc.egg-info/dependency_links.txt
+mpvc.egg-info/requires.txt
+mpvc.egg-info/top_level.txt

mpvc-0.0.1/mpvc.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

mpvc-0.0.1/mpvc.egg-info/requires.txt

@@ -0,0 +1,2 @@
+opencv-python
+mediapipe==0.10.21

mpvc-0.0.1/mpvc.egg-info/top_level.txt

@@ -0,0 +1 @@
+mpvc

mpvc-0.0.1/pyproject.toml

@@ -0,0 +1,26 @@
+[build-system]
+requires = ["setuptools>=61.0.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "mpvc"
+version = "0.0.1"
+authors = [
+  { name="Mundo Python", email="mundopython98@gmail.com" },
+]
+description = "Módulo para detecção de mão, rosto e malha facial usando MediaPipe e OpenCV"
+readme = "README.md"
+requires-python = ">=3.9, <=3.12"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+    "opencv-python",
+    "mediapipe==0.10.21",
+]
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["mpvc*"]

mpvc-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+