Nanofibras.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "collapsed_sections": [
        "K_BVBQ-fMXCq",
        "daxxq1cqMZ3t",
        "komMbDrOSUrS"
      ],
      "toc_visible": true,
      "mount_file_id": "1Xwgu_ifecXJbTLXukdJcxmqZka8dnnME",
      "authorship_tag": "ABX9TyMOIwPduraL/2veeIgFe0LN",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/MilaMatos/Calculo-do-diametro-em-imagens/blob/main/Nanofibras.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Dataset\n"
      ],
      "metadata": {
        "id": "K_BVBQ-fMXCq"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Aumentar a base de dados\n"
      ],
      "metadata": {
        "id": "daxxq1cqMZ3t"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "O Laboratório de Engenharia de Materiais da Universidade Federal do Cariri forneceu 15 imagens microscópicas de fibras. Essas imagens foram utilizadas para treinar a rede neural com o objetivo de identificar e segmentar o máximo de fibras, bem como a escala utilizada.\n",
        "\n",
        "Técnicas de aumento de dados foram aplicadas para expandir a base de dados de treinamento em algoritmos de aprendizado de máquina voltados para imagens. Essas técnicas são utilizadas para aumentar a variabilidade dos dados disponíveis, ajudando o modelo a generalizar melhor para novas situações. Com base nisso, aplicou-se a técnica de 'flip' em três diferentes orientações para cada imagem base.\n",
        "\n",
        "A técnica de 'flip' consiste em espelhar a imagem horizontalmente, verticalmente ou em ambas as direções. Isso é feito para introduzir variações adicionais nos dados de treinamento, contribuindo para melhorar a capacidade do modelo em lidar com diferentes perspectivas e orientações das fibras.\n",
        "\n",
        "**O resultado obtido foi a triplicação da base de dados.**"
      ],
      "metadata": {
        "id": "9nhVCkCXPpdg"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "A função **flip_image** recebe o caminho de uma imagem, o diretório de saída e o nome do arquivo original.\n",
        "\n",
        "Ela verifica se a imagem existe, a carrega, e em seguida, realiza a operação 'flip' em **três direções diferentes: horizontal, vertical e ambas.** As imagens resultantes são salvas no diretório de saída com nomes modificados para indicar a direção do 'flip'."
      ],
      "metadata": {
        "id": "EgnGzlz_Qq5w"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import cv2\n",
        "import os\n",
        "\n",
        "def flip_image(image_path, folder, file_name):\n",
        "    # Verifique se o arquivo de imagem existe\n",
        "    if not os.path.exists(image_path):\n",
        "        print(f\"Erro: O arquivo de imagem {image_path} não foi encontrado.\")\n",
        "        return\n",
        "\n",
        "    img = cv2.imread(image_path)\n",
        "\n",
        "    # Verifique se a imagem foi carregada com sucesso\n",
        "    if img is None:\n",
        "        print(f\"Erro: Falha ao carregar a imagem {image_path}. Certifique-se de que é uma imagem válida.\")\n",
        "        return\n",
        "\n",
        "    base_name, extension = os.path.splitext(file_name)\n",
        "\n",
        "    # Flip\n",
        "    flip_codes = [0, 1, -1]\n",
        "    for flip_code in flip_codes:\n",
        "        flipped_img = cv2.flip(img, flip_code)\n",
        "        output_path = os.path.join(folder, f\"{base_name}_flipped_{flip_code}{extension}\")\n",
        "        cv2.imwrite(output_path, flipped_img)"
      ],
      "metadata": {
        "id": "bHp4KBIrROuZ"
      },
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "A **increase_dataset** foi criada para simplificar o processo de aumento de um conjunto de dados de imagens em uma determinada pasta. O procedimento envolve a aplicação da operação 'flip' em todas as imagens da pasta de entrada, resultando em versões espelhadas das imagens para enriquecer a base de dados.\n",
        "\n",
        "Uso da Função:\n",
        "\n",
        "```\n",
        "folder = \"C:/Users/cvane/Desktop/Nova pasta (2)/database\"\n",
        "increase_dataset(folder)\n",
        "\n",
        "```\n",
        "\n",
        "Em resumo, ao chamar increase_dataset com o caminho da pasta de entrada contendo as imagens, a função automaticamente verifica a existência da pasta, cria uma pasta de saída (se necessário), lista os arquivos de imagem na pasta de entrada e aplica a operação 'flip' a cada imagem, gerando versões espelhadas."
      ],
      "metadata": {
        "id": "ZPoz73XLR251"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def increase_dataset(folder):\n",
        "    # Verifique se a pasta de entrada existe\n",
        "    if not os.path.exists(folder):\n",
        "        print(f\"Erro: A pasta de entrada {folder} não foi encontrada.\")\n",
        "        return\n",
        "\n",
        "    # Verifique se a pasta de saída existe, se não, crie-a\n",
        "    if not os.path.exists(folder):\n",
        "        os.makedirs(folder)\n",
        "\n",
        "    # Listar todos os arquivos na pasta de entrada\n",
        "    image_files = [f for f in os.listdir(folder) if f.lower().endswith(('.png', '.jpg', '.jpeg', '.bmp', 'tif'))]\n",
        "\n",
        "    # Iterar sobre os arquivos e aplicar a função flip_image\n",
        "    for image_file in image_files:\n",
        "        image_path = os.path.join(folder, image_file)\n",
        "        flip_image(image_path, folder, image_file)"
      ],
      "metadata": {
        "id": "uVuPa6_kSGGK"
      },
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Anotação de dados"
      ],
      "metadata": {
        "id": "komMbDrOSUrS"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Para o processo de rotulação das imagens será usado o [Labelbox](https://app.labelbox.com/home) com as 60 imagens disponíveis.\n",
        "\n",
        "As imagens originais possuiam a extensão .TIFF e para podermos utilizar o software mencionado anteriormente foram convertidas para .PNG"
      ],
      "metadata": {
        "id": "aGWQraOq8SEB"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Atualmente as imagens serão mudadas e está apenas 1 imagem disponível para testes e testar algumas funções que serão criadas"
      ],
      "metadata": {
        "id": "dViHsqI5iaUI"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Conceito base da pesquisa"
      ],
      "metadata": {
        "id": "9lK-CEIohg_l"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "- O que são nanofibras\n",
        "- Quais os usos\n",
        "- Importância do cálculo do diâmetro"
      ],
      "metadata": {
        "id": "6i3xRlxNhpJ2"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Considerando as imagens das fibras segmentadas de forma podemos calcular o diâmetro aproximado com base no raio da fibra em determinados pontos escolhidos aleatoriamente no decorrer do esqueleto da fibra."
      ],
      "metadata": {
        "id": "ZzZH-65FmXW2"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Acesso ao Labelbox\n",
        "\n"
      ],
      "metadata": {
        "id": "CPF3EUswJ69R"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install labelbox"
      ],
      "metadata": {
        "id": "TxCISu9NLG7h",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "35fb86e1-3157-45d0-9253-4f140dabb37c"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Collecting labelbox\n",
            "  Downloading labelbox-3.69.0-py3-none-any.whl (238 kB)\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m238.3/238.3 kB\u001b[0m \u001b[31m3.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hCollecting geojson>=3.1.0 (from labelbox)\n",
            "  Downloading geojson-3.1.0-py3-none-any.whl (15 kB)\n",
            "Requirement already satisfied: google-api-core>=1.22.1 in /usr/local/lib/python3.10/dist-packages (from labelbox) (2.11.1)\n",
            "Requirement already satisfied: pydantic>=1.8 in /usr/local/lib/python3.10/dist-packages (from labelbox) (2.7.0)\n",
            "Requirement already satisfied: python-dateutil<2.9.0,>=2.8.2 in /usr/local/lib/python3.10/dist-packages (from labelbox) (2.8.2)\n",
            "Requirement already satisfied: requests>=2.22.0 in /usr/local/lib/python3.10/dist-packages (from labelbox) (2.31.0)\n",
            "Collecting strenum>=0.4.15 (from labelbox)\n",
            "  Downloading StrEnum-0.4.15-py3-none-any.whl (8.9 kB)\n",
            "Requirement already satisfied: tqdm>=4.66.2 in /usr/local/lib/python3.10/dist-packages (from labelbox) (4.66.2)\n",
            "Requirement already satisfied: googleapis-common-protos<2.0.dev0,>=1.56.2 in /usr/local/lib/python3.10/dist-packages (from google-api-core>=1.22.1->labelbox) (1.63.0)\n",
            "Requirement already satisfied: protobuf!=3.20.0,!=3.20.1,!=4.21.0,!=4.21.1,!=4.21.2,!=4.21.3,!=4.21.4,!=4.21.5,<5.0.0.dev0,>=3.19.5 in /usr/local/lib/python3.10/dist-packages (from google-api-core>=1.22.1->labelbox) (3.20.3)\n",
            "Requirement already satisfied: google-auth<3.0.dev0,>=2.14.1 in /usr/local/lib/python3.10/dist-packages (from google-api-core>=1.22.1->labelbox) (2.27.0)\n",
            "Requirement already satisfied: annotated-types>=0.4.0 in /usr/local/lib/python3.10/dist-packages (from pydantic>=1.8->labelbox) (0.6.0)\n",
            "Requirement already satisfied: pydantic-core==2.18.1 in /usr/local/lib/python3.10/dist-packages (from pydantic>=1.8->labelbox) (2.18.1)\n",
            "Requirement already satisfied: typing-extensions>=4.6.1 in /usr/local/lib/python3.10/dist-packages (from pydantic>=1.8->labelbox) (4.11.0)\n",
            "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.10/dist-packages (from python-dateutil<2.9.0,>=2.8.2->labelbox) (1.16.0)\n",
            "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from requests>=2.22.0->labelbox) (3.3.2)\n",
            "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests>=2.22.0->labelbox) (3.7)\n",
            "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from requests>=2.22.0->labelbox) (2.0.7)\n",
            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/dist-packages (from requests>=2.22.0->labelbox) (2024.2.2)\n",
            "Requirement already satisfied: cachetools<6.0,>=2.0.0 in /usr/local/lib/python3.10/dist-packages (from google-auth<3.0.dev0,>=2.14.1->google-api-core>=1.22.1->labelbox) (5.3.3)\n",
            "Requirement already satisfied: pyasn1-modules>=0.2.1 in /usr/local/lib/python3.10/dist-packages (from google-auth<3.0.dev0,>=2.14.1->google-api-core>=1.22.1->labelbox) (0.4.0)\n",
            "Requirement already satisfied: rsa<5,>=3.1.4 in /usr/local/lib/python3.10/dist-packages (from google-auth<3.0.dev0,>=2.14.1->google-api-core>=1.22.1->labelbox) (4.9)\n",
            "Requirement already satisfied: pyasn1<0.7.0,>=0.4.6 in /usr/local/lib/python3.10/dist-packages (from pyasn1-modules>=0.2.1->google-auth<3.0.dev0,>=2.14.1->google-api-core>=1.22.1->labelbox) (0.6.0)\n",
            "Installing collected packages: strenum, geojson, labelbox\n",
            "Successfully installed geojson-3.1.0 labelbox-3.69.0 strenum-0.4.15\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Esse trecho de código abaixo é responsável por acessar uma base de dados hospedada na plataforma Labelbox, uma ferramenta usada para rotular e gerenciar conjuntos de dados para treinamento de modelos de aprendizado de máquina. Aqui está uma explicação detalhada das etapas realizadas:\n",
        "\n",
        "1. **Autenticação e Conexão com o Labelbox:**\n",
        "   - A variável `LB_API_KEY` contém a chave de API necessária para autenticar e acessar os recursos do Labelbox.\n",
        "   - O identificador do projeto, `PROJECT_ID`, é fornecido para especificar qual projeto dentro do Labelbox será acessado.\n",
        "   - Utilizando a biblioteca `labelbox`, é criado um cliente Labelbox e uma conexão é estabelecida com o projeto especificado.\n",
        "\n",
        "2. **Definição dos Parâmetros de Exportação:**\n",
        "   - O dicionário `export_params` pode ser utilizado para especificar parâmetros adicionais para a exportação dos dados do projeto, como o formato do arquivo de exportação, filtros de dados, entre outros.\n",
        "\n",
        "3. **Exportação dos Dados do Projeto:**\n",
        "   - O método `export_v2()` é chamado no objeto `project` para iniciar a exportação dos dados do projeto para o Labelbox.\n",
        "   - Um objeto `export_task` é retornado, representando a tarefa de exportação em andamento.\n",
        "\n",
        "4. **Espera pela Conclusão da Exportação:**\n",
        "   - O método `wait_till_done()` é chamado no objeto `export_task` para esperar até que a exportação seja concluída.\n",
        "\n",
        "5. **Verificação de Erros na Exportação:**\n",
        "   - Após a conclusão da exportação, é verificado se houve algum erro durante o processo.\n",
        "   - Se houver erros, eles são impressos para fins de depuração ou registro.\n",
        "\n",
        "6. **Obtenção dos Resultados da Exportação:**\n",
        "   - O resultado da exportação é obtido do objeto `export_task` através do atributo `result`.\n",
        "   - O conteúdo exportado é armazenado na variável `export_json`, que pode ser usada para análise posterior ou processamento adicional.\n"
      ],
      "metadata": {
        "id": "NwjiGA5Yg5ap"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import labelbox\n",
        "LB_API_KEY = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VySWQiOiJjbHE4M3gyN3owcTA3MDcxdzhmOXZnMnlmIiwib3JnYW5pemF0aW9uSWQiOiJjbHE4M3gyN3IwcTA2MDcxdzN2MjhhZ25yIiwiYXBpS2V5SWQiOiJjbHF5OTFzZDEwMG41MDd4dTI4emdodmh2Iiwic2VjcmV0IjoiNjdmMmVkODk4ZjMwNGZlZDkxMzU3OWI1YThmMDZiNjciLCJpYXQiOjE3MDQzMTQ4MzYsImV4cCI6MjMzNTQ2NjgzNn0.73s16s1jO54toIgHIYPiaXwnwkZ_KWbMNInKzZGEn9s'\n",
        "PROJECT_ID = 'clq8482cn04w6073s2jvda4km'\n",
        "client = labelbox.Client(api_key=LB_API_KEY)\n",
        "project = client.get_project(PROJECT_ID)\n",
        "\n",
        "# Define parâmetros de exportação\n",
        "export_params = {\n",
        "}\n",
        "\n",
        "# Exporta os dados do projeto\n",
        "export_task = project.export_v2(params=export_params)\n",
        "export_task.wait_till_done()\n",
        "\n",
        "# Verifica se houve erros na exportação\n",
        "if export_task.errors:\n",
        "    print(export_task.errors)\n",
        "\n",
        "# Obtém o resultado da exportação\n",
        "export_json = export_task.result\n",
        "print(\"Resultados: \", export_json)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "L83Lhet7KGC0",
        "outputId": "e2e5665d-ef7a-4f97-8f9a-12b33b539205"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Resultados:  [{'data_row': {'id': 'clqa9c6ls3lli0788ynnbozjs', 'external_id': 'fibra_equalizacao.png', 'row_data': 'https://storage.labelbox.com/clq83x27r0q06071w3v28agnr%2F65405dbc-0d9b-19f9-8609-29d58f318241-fibra_equalizacao.png?Expires=1714533131348&KeyName=labelbox-assets-key-3&Signature=tF_b2vbuocphlfAdF4iDOmuomEE'}, 'media_attributes': {'height': 640, 'width': 800, 'mime_type': 'image/png', 'exif_rotation': '1'}, 'projects': {'clq8482cn04w6073s2jvda4km': {'name': 'Segmentação de nanofibras', 'labels': [{'label_kind': 'Default', 'version': '1.0.0', 'id': 'clqaa74c02m4p07inaodc1it6', 'annotations': {'objects': [{'feature_id': 'clqaa7cpd00033d6o1vxggx82', 'feature_schema_id': 'clq84hc5012hy073rfye57h7c', 'name': 'escala', 'value': 'escala', 'annotation_kind': 'ImageBoundingBox', 'classifications': [], 'bounding_box': {'top': 611.0, 'left': 297.0, 'height': 9.0, 'width': 147.0}}, {'feature_id': 'clqaa7n9a00063d6oma4e0vex', 'feature_schema_id': 'clq84hc5012i0073r7ir39nf1', 'name': 'nanofibra', 'value': 'nanofibra', 'annotation_kind': 'ImageSegmentationMask', 'classifications': [], 'mask': {'url': 'https://api.labelbox.com/api/v1/projects/clq8482cn04w6073s2jvda4km/annotations/clqaa7n9a00063d6oma4e0vex/index/1/mask'}, 'composite_mask': {'url': 'https://api.labelbox.com/api/v1/tasks/clvltbg550c8d07xt859fgmv2/masks/clqaa76c300013d6o1g16irw5/index/1', 'color_rgb': [117, 218, 200]}}, {'feature_id': 'clqaa9zvx001a3d6o2gr5d4hj', 'feature_schema_id': 'clq84hc5012i0073r7ir39nf1', 'name': 'nanofibra', 'value': 'nanofibra', 'annotation_kind': 'ImageSegmentationMask', 'classifications': [], 'mask': {'url': 'https://api.labelbox.com/api/v1/projects/clq8482cn04w6073s2jvda4km/annotations/clqaa9zvx001a3d6o2gr5d4hj/index/1/mask'}, 'composite_mask': {'url': 'https://api.labelbox.com/api/v1/tasks/clvltbg550c8d07xt859fgmv2/masks/clqaa76c300013d6o1g16irw5/index/1', 'color_rgb': [79, 151, 173]}}, {'feature_id': 'clqaac0jq00303d6o6vbxgyb1', 'feature_schema_id': 'clq84hc5012i0073r7ir39nf1', 'name': 'nanofibra', 'value': 'nanofibra', 'annotation_kind': 'ImageSegmentationMask', 'classifications': [], 'mask': {'url': 'https://api.labelbox.com/api/v1/projects/clq8482cn04w6073s2jvda4km/annotations/clqaac0jq00303d6o6vbxgyb1/index/1/mask'}, 'composite_mask': {'url': 'https://api.labelbox.com/api/v1/tasks/clvltbg550c8d07xt859fgmv2/masks/clqaa76c300013d6o1g16irw5/index/1', 'color_rgb': [122, 82, 141]}}, {'feature_id': 'clqaadqww003t3d6ooc5gmmmg', 'feature_schema_id': 'clq84hc5012i0073r7ir39nf1', 'name': 'nanofibra', 'value': 'nanofibra', 'annotation_kind': 'ImageSegmentationMask', 'classifications': [], 'mask': {'url': 'https://api.labelbox.com/api/v1/projects/clq8482cn04w6073s2jvda4km/annotations/clqaadqww003t3d6ooc5gmmmg/index/1/mask'}, 'composite_mask': {'url': 'https://api.labelbox.com/api/v1/tasks/clvltbg550c8d07xt859fgmv2/masks/clqaa76c300013d6o1g16irw5/index/1', 'color_rgb': [192, 231, 248]}}, {'feature_id': 'clqaai4it006d3d6ofy8fy6qi', 'feature_schema_id': 'clq84hc5012i0073r7ir39nf1', 'name': 'nanofibra', 'value': 'nanofibra', 'annotation_kind': 'ImageSegmentationMask', 'classifications': [], 'mask': {'url': 'https://api.labelbox.com/api/v1/projects/clq8482cn04w6073s2jvda4km/annotations/clqaai4it006d3d6ofy8fy6qi/index/1/mask'}, 'composite_mask': {'url': 'https://api.labelbox.com/api/v1/tasks/clvltbg550c8d07xt859fgmv2/masks/clqaa76c300013d6o1g16irw5/index/1', 'color_rgb': [76, 102, 237]}}, {'feature_id': 'clqaajlve00783d6oz21rgc9a', 'feature_schema_id': 'clq84hc5012i0073r7ir39nf1', 'name': 'nanofibra', 'value': 'nanofibra', 'annotation_kind': 'ImageSegmentationMask', 'classifications': [], 'mask': {'url': 'https://api.labelbox.com/api/v1/projects/clq8482cn04w6073s2jvda4km/annotations/clqaajlve00783d6oz21rgc9a/index/1/mask'}, 'composite_mask': {'url': 'https://api.labelbox.com/api/v1/tasks/clvltbg550c8d07xt859fgmv2/masks/clqaa76c300013d6o1g16irw5/index/1', 'color_rgb': [97, 119, 14]}}, {'feature_id': 'clqaak3d5007k3d6o12jrnqwp', 'feature_schema_id': 'clq84hc5012i0073r7ir39nf1', 'name': 'nanofibra', 'value': 'nanofibra', 'annotation_kind': 'ImageSegmentationMask', 'classifications': [], 'mask': {'url': 'https://api.labelbox.com/api/v1/projects/clq8482cn04w6073s2jvda4km/annotations/clqaak3d5007k3d6o12jrnqwp/index/1/mask'}, 'composite_mask': {'url': 'https://api.labelbox.com/api/v1/tasks/clvltbg550c8d07xt859fgmv2/masks/clqaa76c300013d6o1g16irw5/index/1', 'color_rgb': [164, 41, 209]}}, {'feature_id': 'clqaalnyz008g3d6objc5cxss', 'feature_schema_id': 'clq84hc5012i0073r7ir39nf1', 'name': 'nanofibra', 'value': 'nanofibra', 'annotation_kind': 'ImageSegmentationMask', 'classifications': [], 'mask': {'url': 'https://api.labelbox.com/api/v1/projects/clq8482cn04w6073s2jvda4km/annotations/clqaalnyz008g3d6objc5cxss/index/1/mask'}, 'composite_mask': {'url': 'https://api.labelbox.com/api/v1/tasks/clvltbg550c8d07xt859fgmv2/masks/clqaa76c300013d6o1g16irw5/index/1', 'color_rgb': [115, 186, 109]}}, {'feature_id': 'clqaamerf008z3d6om4705o3q', 'feature_schema_id': 'clq84hc5012i0073r7ir39nf1', 'name': 'nanofibra', 'value': 'nanofibra', 'annotation_kind': 'ImageSegmentationMask', 'classifications': [], 'mask': {'url': 'https://api.labelbox.com/api/v1/projects/clq8482cn04w6073s2jvda4km/annotations/clqaamerf008z3d6om4705o3q/index/1/mask'}, 'composite_mask': {'url': 'https://api.labelbox.com/api/v1/tasks/clvltbg550c8d07xt859fgmv2/masks/clqaa76c300013d6o1g16irw5/index/1', 'color_rgb': [24, 192, 52]}}, {'feature_id': 'clqaaok8700ak3d6o8dwox9pc', 'feature_schema_id': 'clq84hc5012i0073r7ir39nf1', 'name': 'nanofibra', 'value': 'nanofibra', 'annotation_kind': 'ImageSegmentationMask', 'classifications': [], 'mask': {'url': 'https://api.labelbox.com/api/v1/projects/clq8482cn04w6073s2jvda4km/annotations/clqaaok8700ak3d6o8dwox9pc/index/1/mask'}, 'composite_mask': {'url': 'https://api.labelbox.com/api/v1/tasks/clvltbg550c8d07xt859fgmv2/masks/clqaa76c300013d6o1g16irw5/index/1', 'color_rgb': [15, 23, 106]}}, {'feature_id': 'clqaaptkj00br3d6ojre9pf5o', 'feature_schema_id': 'clq84hc5012i0073r7ir39nf1', 'name': 'nanofibra', 'value': 'nanofibra', 'annotation_kind': 'ImageSegmentationMask', 'classifications': [], 'mask': {'url': 'https://api.labelbox.com/api/v1/projects/clq8482cn04w6073s2jvda4km/annotations/clqaaptkj00br3d6ojre9pf5o/index/1/mask'}, 'composite_mask': {'url': 'https://api.labelbox.com/api/v1/tasks/clvltbg550c8d07xt859fgmv2/masks/clqaa76c300013d6o1g16irw5/index/1', 'color_rgb': [81, 106, 66]}}, {'feature_id': 'clqaarvjw00d83d6ot6pk0j6i', 'feature_schema_id': 'clq84hc5012i0073r7ir39nf1', 'name': 'nanofibra', 'value': 'nanofibra', 'annotation_kind': 'ImageSegmentationMask', 'classifications': [], 'mask': {'url': 'https://api.labelbox.com/api/v1/projects/clq8482cn04w6073s2jvda4km/annotations/clqaarvjw00d83d6ot6pk0j6i/index/1/mask'}, 'composite_mask': {'url': 'https://api.labelbox.com/api/v1/tasks/clvltbg550c8d07xt859fgmv2/masks/clqaa76c300013d6o1g16irw5/index/1', 'color_rgb': [97, 19, 52]}}, {'feature_id': 'clqaavsn000fr3d6oz8dl952u', 'feature_schema_id': 'clq84hc5012i0073r7ir39nf1', 'name': 'nanofibra', 'value': 'nanofibra', 'annotation_kind': 'ImageSegmentationMask', 'classifications': [], 'mask': {'url': 'https://api.labelbox.com/api/v1/projects/clq8482cn04w6073s2jvda4km/annotations/clqaavsn000fr3d6oz8dl952u/index/1/mask'}, 'composite_mask': {'url': 'https://api.labelbox.com/api/v1/tasks/clvltbg550c8d07xt859fgmv2/masks/clqaa76c300013d6o1g16irw5/index/1', 'color_rgb': [2, 14, 253]}}, {'feature_id': 'clqaaw01z00fw3d6o2wdactvp', 'feature_schema_id': 'clq84hc5012i0073r7ir39nf1', 'name': 'nanofibra', 'value': 'nanofibra', 'annotation_kind': 'ImageSegmentationMask', 'classifications': [], 'mask': {'url': 'https://api.labelbox.com/api/v1/projects/clq8482cn04w6073s2jvda4km/annotations/clqaaw01z00fw3d6o2wdactvp/index/1/mask'}, 'composite_mask': {'url': 'https://api.labelbox.com/api/v1/tasks/clvltbg550c8d07xt859fgmv2/masks/clqaa76c300013d6o1g16irw5/index/1', 'color_rgb': [82, 186, 186]}}, {'feature_id': 'clqaawr4400gg3d6ouu1bhoa3', 'feature_schema_id': 'clq84hc5012i0073r7ir39nf1', 'name': 'nanofibra', 'value': 'nanofibra', 'annotation_kind': 'ImageSegmentationMask', 'classifications': [], 'mask': {'url': 'https://api.labelbox.com/api/v1/projects/clq8482cn04w6073s2jvda4km/annotations/clqaawr4400gg3d6ouu1bhoa3/index/1/mask'}, 'composite_mask': {'url': 'https://api.labelbox.com/api/v1/tasks/clvltbg550c8d07xt859fgmv2/masks/clqaa76c300013d6o1g16irw5/index/1', 'color_rgb': [183, 169, 195]}}, {'feature_id': 'clqaaz4g900hy3d6oskttdsps', 'feature_schema_id': 'clq84hc5012i0073r7ir39nf1', 'name': 'nanofibra', 'value': 'nanofibra', 'annotation_kind': 'ImageSegmentationMask', 'classifications': [], 'mask': {'url': 'https://api.labelbox.com/api/v1/projects/clq8482cn04w6073s2jvda4km/annotations/clqaaz4g900hy3d6oskttdsps/index/1/mask'}, 'composite_mask': {'url': 'https://api.labelbox.com/api/v1/tasks/clvltbg550c8d07xt859fgmv2/masks/clqaa76c300013d6o1g16irw5/index/1', 'color_rgb': [249, 14, 107]}}, {'feature_id': 'clqab10dr00iz3d6oms5f74s5', 'feature_schema_id': 'clq84hc5012i0073r7ir39nf1', 'name': 'nanofibra', 'value': 'nanofibra', 'annotation_kind': 'ImageSegmentationMask', 'classifications': [], 'mask': {'url': 'https://api.labelbox.com/api/v1/projects/clq8482cn04w6073s2jvda4km/annotations/clqab10dr00iz3d6oms5f74s5/index/1/mask'}, 'composite_mask': {'url': 'https://api.labelbox.com/api/v1/tasks/clvltbg550c8d07xt859fgmv2/masks/clqaa76c300013d6o1g16irw5/index/1', 'color_rgb': [231, 199, 64]}}, {'feature_id': 'clqab30go00jt3d6ofpewh5vh', 'feature_schema_id': 'clq84hc5012i0073r7ir39nf1', 'name': 'nanofibra', 'value': 'nanofibra', 'annotation_kind': 'ImageSegmentationMask', 'classifications': [], 'mask': {'url': 'https://api.labelbox.com/api/v1/projects/clq8482cn04w6073s2jvda4km/annotations/clqab30go00jt3d6ofpewh5vh/index/1/mask'}, 'composite_mask': {'url': 'https://api.labelbox.com/api/v1/tasks/clvltbg550c8d07xt859fgmv2/masks/clqaa76c300013d6o1g16irw5/index/1', 'color_rgb': [157, 175, 27]}}, {'feature_id': 'clqab6qgo00lj3d6onyqiq520', 'feature_schema_id': 'clq84hc5012i0073r7ir39nf1', 'name': 'nanofibra', 'value': 'nanofibra', 'annotation_kind': 'ImageSegmentationMask', 'classifications': [], 'mask': {'url': 'https://api.labelbox.com/api/v1/projects/clq8482cn04w6073s2jvda4km/annotations/clqab6qgo00lj3d6onyqiq520/index/1/mask'}, 'composite_mask': {'url': 'https://api.labelbox.com/api/v1/tasks/clvltbg550c8d07xt859fgmv2/masks/clqaa76c300013d6o1g16irw5/index/1', 'color_rgb': [121, 192, 187]}}], 'classifications': [], 'relationships': []}}]}}}]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Exemplo de acesso em uma das \"máscaras\" das fibras segmentadas dentro do Labelbox"
      ],
      "metadata": {
        "id": "z4sIOHH7hYgZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "export_json[0]['projects']['clq8482cn04w6073s2jvda4km']['labels'][0]['annotations']['objects'][1]['mask']"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9Fn27YJoSNsT",
        "outputId": "a6624efe-6845-49b9-f7cd-9972cc8cf35b"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'url': 'https://api.labelbox.com/api/v1/projects/clq8482cn04w6073s2jvda4km/annotations/clqaa7n9a00063d6oma4e0vex/index/1/mask'}"
            ]
          },
          "metadata": {},
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Acesso à dimensão da largura criado pelo bounding box da escala"
      ],
      "metadata": {
        "id": "Tz0RUbLFhhdF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#export_json[0]['projects']['clq8482cn04w6073s2jvda4km']['labels'][0]['annotations']['objects'][0]['bounding_box']['width']\n",
        "largura_escala = export_json[0]['projects']['clq8482cn04w6073s2jvda4km']['labels'][0]['annotations']['objects'][0]['bounding_box']['width']\n",
        "print(largura_escala)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FLi-PJzx5rC_",
        "outputId": "bda12cb8-4167-4591-ed27-ba3189ee820c"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "147.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "O código abaixo percorre os objetos exportados para obter as URLs das máscaras geradas durante a demarcação das fibras. Inicialmente, uma lista chamada `mascaras` é inicializada para armazenar as URLs das máscaras. Em seguida, o código itera sobre os objetos exportados e verifica se há uma chave chamada 'mask' em cada objeto. Se essa chave existir, significa que uma máscara foi gerada para o objeto e sua URL é adicionada à lista de máscaras. Finalmente, as URLs das máscaras são impressas para permitir o acesso às mesmas. Esta abordagem permite listar e acessar todas as máscaras associadas às demarcações de fibras no Labelbox."
      ],
      "metadata": {
        "id": "op_WyKpuiG1a"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Inicialize uma lista para armazenar as máscaras\n",
        "mascaras = []\n",
        "\n",
        "# Iterar sobre os objetos e obter as máscaras, se existirem\n",
        "for obj in export_json[0]['projects']['clq8482cn04w6073s2jvda4km']['labels'][0]['annotations']['objects']:\n",
        "    if 'mask' in obj:\n",
        "        mascaras.append(obj['mask']['url'])\n",
        "\n",
        "# Imprimir a lista de máscaras\n",
        "for mascara in mascaras:\n",
        "    print(mascara)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TynHMUzkXj4i",
        "outputId": "5c31d622-fb7f-4f8c-934a-3d943145e1d6"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "https://api.labelbox.com/api/v1/projects/clq8482cn04w6073s2jvda4km/annotations/clqaa7n9a00063d6oma4e0vex/index/1/mask\n",
            "https://api.labelbox.com/api/v1/projects/clq8482cn04w6073s2jvda4km/annotations/clqaa9zvx001a3d6o2gr5d4hj/index/1/mask\n",
            "https://api.labelbox.com/api/v1/projects/clq8482cn04w6073s2jvda4km/annotations/clqaac0jq00303d6o6vbxgyb1/index/1/mask\n",
            "https://api.labelbox.com/api/v1/projects/clq8482cn04w6073s2jvda4km/annotations/clqaadqww003t3d6ooc5gmmmg/index/1/mask\n",
            "https://api.labelbox.com/api/v1/projects/clq8482cn04w6073s2jvda4km/annotations/clqaai4it006d3d6ofy8fy6qi/index/1/mask\n",
            "https://api.labelbox.com/api/v1/projects/clq8482cn04w6073s2jvda4km/annotations/clqaajlve00783d6oz21rgc9a/index/1/mask\n",
            "https://api.labelbox.com/api/v1/projects/clq8482cn04w6073s2jvda4km/annotations/clqaak3d5007k3d6o12jrnqwp/index/1/mask\n",
            "https://api.labelbox.com/api/v1/projects/clq8482cn04w6073s2jvda4km/annotations/clqaalnyz008g3d6objc5cxss/index/1/mask\n",
            "https://api.labelbox.com/api/v1/projects/clq8482cn04w6073s2jvda4km/annotations/clqaamerf008z3d6om4705o3q/index/1/mask\n",
            "https://api.labelbox.com/api/v1/projects/clq8482cn04w6073s2jvda4km/annotations/clqaaok8700ak3d6o8dwox9pc/index/1/mask\n",
            "https://api.labelbox.com/api/v1/projects/clq8482cn04w6073s2jvda4km/annotations/clqaaptkj00br3d6ojre9pf5o/index/1/mask\n",
            "https://api.labelbox.com/api/v1/projects/clq8482cn04w6073s2jvda4km/annotations/clqaarvjw00d83d6ot6pk0j6i/index/1/mask\n",
            "https://api.labelbox.com/api/v1/projects/clq8482cn04w6073s2jvda4km/annotations/clqaavsn000fr3d6oz8dl952u/index/1/mask\n",
            "https://api.labelbox.com/api/v1/projects/clq8482cn04w6073s2jvda4km/annotations/clqaaw01z00fw3d6o2wdactvp/index/1/mask\n",
            "https://api.labelbox.com/api/v1/projects/clq8482cn04w6073s2jvda4km/annotations/clqaawr4400gg3d6ouu1bhoa3/index/1/mask\n",
            "https://api.labelbox.com/api/v1/projects/clq8482cn04w6073s2jvda4km/annotations/clqaaz4g900hy3d6oskttdsps/index/1/mask\n",
            "https://api.labelbox.com/api/v1/projects/clq8482cn04w6073s2jvda4km/annotations/clqab10dr00iz3d6oms5f74s5/index/1/mask\n",
            "https://api.labelbox.com/api/v1/projects/clq8482cn04w6073s2jvda4km/annotations/clqab30go00jt3d6ofpewh5vh/index/1/mask\n",
            "https://api.labelbox.com/api/v1/projects/clq8482cn04w6073s2jvda4km/annotations/clqab6qgo00lj3d6onyqiq520/index/1/mask\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "A função `open_image` recebe uma URL de uma imagem e um identificador como entrada e realiza uma solicitação HTTP para obter a imagem correspondente a partir da URL fornecida. A função então usa a biblioteca PIL (Python Imaging Library) para abrir a imagem e convertê-la em uma matriz numpy. Em seguida, a imagem é exibida usando a função `cv2_imshow`. Este processo permite que você visualize a imagem carregada diretamente do URL fornecido."
      ],
      "metadata": {
        "id": "cYfJ3v7Jgawv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import urllib.request\n",
        "from PIL import Image\n",
        "from google.colab.patches import cv2_imshow\n",
        "import numpy as np\n",
        "\n",
        "def open_image(url, id):\n",
        "  project_id = PROJECT_ID\n",
        "  feature_id = id\n",
        "  # URL da imagem da máscara\n",
        "  mask_url = ulr\n",
        "\n",
        "  # Make the API request\n",
        "  req = urllib.request.Request(mask_url, headers=client.headers)\n",
        "  image = Image.open(urllib.request.urlopen(req))\n",
        "\n",
        "  # Converter a imagem para uma matriz numpy\n",
        "  img = np.array(image)\n",
        "\n",
        "  # Exibir a imagem\n",
        "    #cv2_imshow(img)\n",
        "  return img"
      ],
      "metadata": {
        "id": "GeMObLzieSIJ"
      },
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "ulr = \"https://api.labelbox.com/api/v1/projects/clq8482cn04w6073s2jvda4km/annotations/clqaa9zvx001a3d6o2gr5d4hj/index/1/mask\"\n",
        "id = \"clqaa9zvx001a3d6o2gr5d4hj\"\n",
        "img = open_image(ulr, id)\n",
        "cv2_imshow(img)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 657
        },
        "id": "HmUOgmJTf54C",
        "outputId": "44563fa7-f4d8-4b39-831a-7d397cb0f2ec"
      },
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<PIL.Image.Image image mode=L size=800x640>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "area = np.sum(img == 255)\n",
        "print (area)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qQa2dYvBV1V3",
        "outputId": "1e02db27-6cb2-4d8f-8375-6fbc3ac52c9e"
      },
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "17624\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Esqueletização"
      ],
      "metadata": {
        "id": "IqZeB7fDhIGd"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "A função `skeletonization` recebe uma imagem como entrada e realiza o processo de esqueletização para destacar o esqueleto da estrutura presente na imagem. Primeiro, a imagem é suavizada para reduzir o ruído usando um filtro gaussiano. Em seguida, um processo de fechamento é aplicado para diminuir ainda mais o ruído, seguido pela detecção de bordas na imagem suavizada usando o algoritmo de Canny. A imagem suavizada é binarizada para criar uma imagem binária onde os pixels de interesse são brancos. A esqueletização é então aplicada à imagem binarizada para extrair o esqueleto da estrutura. Este processo é realizado iterativamente até que o esqueleto seja completamente extraído. O esqueleto é representado em azul e é sobreposto à imagem de detecção de bordas para destacar tanto as bordas quanto a estrutura esquelética da imagem. O resultado final é exibido usando a função `cv2_imshow`."
      ],
      "metadata": {
        "id": "0P2NrSdfe5H3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from google.colab.patches import cv2_imshow\n",
        "import cv2\n",
        "import numpy as np\n",
        "\n",
        "def skeletonization(img):\n",
        "  cv2_imshow(img)\n",
        "\n",
        "  # Aplicar suavização para reduzir o ruído\n",
        "  smoothed_img = cv2.GaussianBlur(img, (5, 5), 0)\n",
        "\n",
        "  # Aplicar fechamento para diminuir o ruído\n",
        "  kernel = np.ones((5, 5), np.uint8)\n",
        "  closed_img = cv2.morphologyEx(smoothed_img, cv2.MORPH_CLOSE, kernel)\n",
        "\n",
        "  # Detecção de bordas na imagem suavizada\n",
        "  edges = cv2.Canny(closed_img, 50, 150)\n",
        "\n",
        "  # Binarizar a imagem suavizada\n",
        "  _, binary_img = cv2.threshold(closed_img, 127, 255, cv2.THRESH_BINARY)\n",
        "\n",
        "  # Aplicar a esqueletização na imagem binarizada\n",
        "  element = cv2.getStructuringElement(cv2.MORPH_CROSS, (3, 3))\n",
        "  size = np.size(binary_img)\n",
        "  skel = np.zeros(binary_img.shape, np.uint8)\n",
        "\n",
        "  while True:\n",
        "      eroded = cv2.erode(binary_img, element)\n",
        "      temp = cv2.dilate(eroded, element)\n",
        "      temp = cv2.subtract(binary_img, temp)\n",
        "      skel = cv2.bitwise_or(skel, temp)\n",
        "      binary_img = eroded.copy()\n",
        "\n",
        "      zeros = size - cv2.countNonZero(binary_img)\n",
        "      if zeros == size:\n",
        "          break\n",
        "\n",
        "  # Criar uma imagem azul para representar o esqueleto\n",
        "  skel_color = cv2.merge([skel, np.zeros_like(skel), np.zeros_like(skel)])\n",
        "\n",
        "  # Converter a imagem de bordas para a escala BGR\n",
        "  edges_bgr = cv2.cvtColor(edges, cv2.COLOR_GRAY2BGR)\n",
        "\n",
        "  # Sobrepor o esqueleto azul na detecção de bordas\n",
        "  result = cv2.bitwise_or(edges_bgr, skel_color)\n",
        "\n",
        "  # Exibir o resultado\n",
        "  cv2_imshow(result)\n",
        "\n",
        "  return result\n"
      ],
      "metadata": {
        "id": "hM0ibNJi4RYD"
      },
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import cv2\n",
        "import numpy as np\n",
        "\n",
        "def skeletonization_with_pixels(img):\n",
        "    \"\"\"\n",
        "    Aplica o processo de esqueletização em uma imagem binária e retorna o esqueleto,\n",
        "    juntamente com os pixels que fazem parte do esqueleto e a borda da imagem.\n",
        "\n",
        "    Args:\n",
        "    - img: imagem binária original (com o esqueleto em azul e a borda branca)\n",
        "\n",
        "    Returns:\n",
        "    - skel: imagem binária do esqueleto\n",
        "    - skeleton_pixels: lista de coordenadas (x, y) dos pixels pertencentes ao esqueleto\n",
        "    - edges: imagem binária representando a borda\n",
        "    \"\"\"\n",
        "    # Aplicar suavização para reduzir o ruído\n",
        "    smoothed_img = cv2.GaussianBlur(img, (5, 5), 0)\n",
        "\n",
        "    # Aplicar fechamento para diminuir o ruído\n",
        "    kernel = np.ones((5, 5), np.uint8)\n",
        "    closed_img = cv2.morphologyEx(smoothed_img, cv2.MORPH_CLOSE, kernel)\n",
        "\n",
        "    # Detecção de bordas na imagem suavizada\n",
        "    edges = cv2.Canny(closed_img, 50, 150)\n",
        "\n",
        "    # Binarizar a imagem suavizada\n",
        "    _, binary_img = cv2.threshold(closed_img, 127, 255, cv2.THRESH_BINARY)\n",
        "\n",
        "    # Aplicar a esqueletização na imagem binarizada\n",
        "    element = cv2.getStructuringElement(cv2.MORPH_CROSS, (3, 3))\n",
        "    size = np.size(binary_img)\n",
        "    skel = np.zeros(binary_img.shape, np.uint8)\n",
        "    skeleton_pixels = []\n",
        "\n",
        "    while True:\n",
        "        eroded = cv2.erode(binary_img, element)\n",
        "        temp = cv2.dilate(eroded, element)\n",
        "        temp = cv2.subtract(binary_img, temp)\n",
        "        skel = cv2.bitwise_or(skel, temp)\n",
        "        binary_img = eroded.copy()\n",
        "\n",
        "        zeros = size - cv2.countNonZero(binary_img)\n",
        "        if zeros == size:\n",
        "            break\n",
        "\n",
        "        skeleton_pixels.extend(zip(*np.where(temp > 0)))\n",
        "\n",
        "    return skel, skeleton_pixels, edges\n"
      ],
      "metadata": {
        "id": "doteZXVAtSH1"
      },
      "execution_count": 21,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Carregar a imagem\n",
        "  #img = cv2.imread('/content/drive/MyDrive/Colab Notebooks/Nanofibras/mask_1.png', cv2.IMREAD_GRAYSCALE)\n",
        "imagem = img #img carregada anteriormente nos blocos de execução\n",
        "esqueleto = skeletonization(img)\n",
        "esqueleto2, skeleton_pixels, bordas = skeletonization_with_pixels(img)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "yryyBRXfem9P",
        "outputId": "1ace3c5e-f0f7-43a8-9b82-e14b4c8d926d"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<PIL.Image.Image image mode=L size=800x640>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<PIL.Image.Image image mode=RGB size=800x640>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tamanho = len(skeleton_pixels)\n",
        "print(tamanho)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "k-0Ey9egW3zL",
        "outputId": "021ae1c1-562c-4d88-fa7a-12f29d428697"
      },
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1002\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "A análise de imagens é crucial para a caracterização de nanofibras em pesquisas científicas, especialmente para identificar sua estrutura esquelética e bordas. Para isso, técnicas como detecção de bordas, realizada através do algoritmo de Canny, e esqueletização são comumente aplicadas. No processo, a imagem é inicialmente suavizada para reduzir o ruído, seguida pela detecção de bordas para identificar contornos. Posteriormente, a esqueletização é empregada para extrair o esqueleto da estrutura, destacando sua forma principal. A sobreposição do esqueleto na imagem de bordas permite uma análise mais precisa, facilitando a caracterização das nanofibras. Essas técnicas são frequentemente utilizadas em estudos relacionados à nanotecnologia e caracterização de materiais fibrosos, contribuindo para avanços significativos na compreensão e aplicação de nanofibras.\"\n",
        "\n",
        "**Referências:**\n",
        "> CALÍOPE, Priscila Braga. Caracterização de nanofibras através de técnicas de processamento de imagens. 2009. Tese (Doutorado) – Universidade de São Paulo, São Paulo, 2009.\n",
        "\n",
        "Disponível em: http://www.teses.usp.br/teses/disponiveis/3/3142/tde-28102009-172405/.\n",
        "\n",
        "Acesso em: 24 fev. 2024."
      ],
      "metadata": {
        "id": "_okB9RUCtyzx"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Cálculo da distância em pixels"
      ],
      "metadata": {
        "id": "azwp_fOlo0rE"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Para calcular o diâmetro de uma fibra em relação ao seu esqueleto, podemos usar a distância perpendicular entre o centro da fibra e a sua borda ao longo do esqueleto. Essa distância é equivalente ao raio da fibra, e o dobro desse valor representa o diâmetro completo da fibra. Essa abordagem é uma aplicação direta de conceitos de geometria euclidiana."
      ],
      "metadata": {
        "id": "cuGpVSmJZPBu"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Utilizando a marcação da largura da escala feita pelo Labelbox temos a referência para ser usada para converter a quantidade de pixels em um tamanho real juntamente com a entrada do usuário informando qual seria o valor equivalente daquela escala, neste caso estamos tomando como base os valores em nanômetros, 1 para 1 nanômetro."
      ],
      "metadata": {
        "id": "sn5guqTodl0z"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"Largura da escala: \", largura_escala)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LIKu4hAjfoH9",
        "outputId": "9acd58d5-bece-4f41-dd20-50d1aa71ac2f"
      },
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Largura da escala:  147.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def pixels_to_real_size(pixels, largura_escala, tamanho_escala_nm):\n",
        "    # Conversão para metros\n",
        "    tamanho_escala_metros = tamanho_escala_nm\n",
        "\n",
        "    # Calcula o tamanho de um pixel para o tamanho real\n",
        "    tamanho_pixel_metros = tamanho_escala_metros / largura_escala\n",
        "\n",
        "    # Calcula o tamanho real relativo aos pixels fornecidos\n",
        "    tamanho_real = pixels * tamanho_pixel_metros\n",
        "\n",
        "    return tamanho_real\n",
        "\n",
        "# Exemplo de uso\n",
        "tamanho_escala_nm = float(input(\"Digite o tamanho da escala em nanômetros (por exemplo, 1 para 1 nanômetro): \"))  # Tamanho da escala em nanômetros\n",
        "\n",
        "# Quantidade de pixels que queremos converter\n",
        "pixels = 30\n",
        "\n",
        "# Convertendo para tamanho real\n",
        "tamanho_real = pixels_to_real_size(pixels, largura_escala, tamanho_escala_nm)\n",
        "\n",
        "print(\"Tamanho real:\", tamanho_real, \"nanômetros\")"
      ],
      "metadata": {
        "id": "IuLo6K3xha93",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b7cef106-6837-4a57-8132-daecc66f9c2b"
      },
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Digite o tamanho da escala em nanômetros (por exemplo, 1 para 1 nanômetro): 1\n",
            "Tamanho real: 0.20408163265306123 nanômetros\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "O código abaixo é usado para encontrar uma linha perpendicular ao esqueleto de uma imagem binária. Ele usa a biblioteca OpenCV (cv2) para operações de processamento de imagem e a biblioteca NumPy para manipulação de arrays.\n",
        "\n",
        "A função find_perpendicular_line recebe dois parâmetros: skeleton_pixels, que são os pixels que formam o esqueleto da imagem, e border_matrix, que é uma matriz binária que indica a borda da imagem.\n",
        "\n",
        "Aqui está uma explicação passo a passo do que o código faz:\n",
        "\n",
        "1. Escolhe aleatoriamente um pixel do esqueleto.\n",
        "2. Encontra os pixels vizinhos para esse pixel escolhido.\n",
        "3. Traça uma linha (line_ske) que passa pelos pixels vizinhos e pelo pixel escolhido.\n",
        "4. Calcula o vetor direção da linha (line_ske).\n",
        "5. Calcula o vetor perpendicular a esse vetor direção.\n",
        "6. Começa a traçar uma linha perpendicular a partir do ponto escolhido.\n",
        "7. Itera ao longo dessa linha perpendicular até atingir a borda da imagem ou um número máximo de iterações."
      ],
      "metadata": {
        "id": "Tf78EWDm6kem"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import cv2\n",
        "import numpy as np\n",
        "\n",
        "def find_perpendicular_line(skeleton_pixels, border_matrix):\n",
        "    while True:\n",
        "        # Escolha aleatória de um pixel do esqueleto\n",
        "        random_index = np.random.randint(2, len(skeleton_pixels) - 2)  # Não escolher os dois primeiros ou dois últimos\n",
        "        x, y = skeleton_pixels[random_index]\n",
        "        #print(\"Pixel escolhido:\", x, y)\n",
        "\n",
        "        # Encontrar pixels vizinhos\n",
        "        x_before, y_before = skeleton_pixels[random_index - 2]\n",
        "        x_after, y_after = skeleton_pixels[random_index + 2]\n",
        "\n",
        "        # Traçar a reta line_ske\n",
        "        line_ske = np.array([(x_before, y_before), (x, y), (x_after, y_after)])\n",
        "\n",
        "        # Encontrar vetor direção da line_ske\n",
        "        dx = x_after - x_before\n",
        "        dy = y_after - y_before\n",
        "\n",
        "        # Encontrar vetor perpendicular\n",
        "        perpendicular_vector = np.array([-dy, dx])\n",
        "\n",
        "        # Normalizar o vetor perpendicular\n",
        "        perpendicular_vector = perpendicular_vector / np.linalg.norm(perpendicular_vector)\n",
        "\n",
        "        # Começar a traçar a reta perpendicular a partir do ponto escolhido aleatoriamente\n",
        "        x_p = x\n",
        "        y_p = y\n",
        "        perpendicular_line = []\n",
        "\n",
        "        # Adicionar o ponto inicial à reta perpendicular\n",
        "        perpendicular_line.append((x_p, y_p))\n",
        "\n",
        "        # Número máximo de iterações antes de parar\n",
        "        max_iterations = len(skeleton_pixels)\n",
        "        iteration = 0\n",
        "\n",
        "        # Enquanto não atingir a borda e não exceder o número máximo de iterações\n",
        "        while border_matrix[int(round(x_p)), int(round(y_p))] == 0 and iteration < max_iterations:\n",
        "            # Avançar na direção perpendicular\n",
        "            x_p += perpendicular_vector[0]\n",
        "            y_p += perpendicular_vector[1]\n",
        "\n",
        "            # Clip para garantir que x_p e y_p permaneçam dentro dos limites da matriz\n",
        "            x_p = np.clip(x_p, 0, border_matrix.shape[0] - 1)\n",
        "            y_p = np.clip(y_p, 0, border_matrix.shape[1] - 1)\n",
        "\n",
        "            # Adicionar o novo ponto à reta perpendicular\n",
        "            perpendicular_line.append((int(round(x_p)), int(round(y_p))))\n",
        "\n",
        "            # Incrementar o contador de iterações\n",
        "            iteration += 1\n",
        "\n",
        "        # Se a linha não atingiu a borda, continue o loop e escolha outro pixel\n",
        "        if iteration < max_iterations:\n",
        "            return perpendicular_line"
      ],
      "metadata": {
        "id": "ZmSUEZKc6jr8"
      },
      "execution_count": 17,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "O código calcula o diâmetro da fibra em diferentes partes, criando retas perpendiculares ao esqueleto da fibra várias vezes e retornando um vetor com os tamanhos dessas retas, que são usados como estimativas do diâmetro da fibra."
      ],
      "metadata": {
        "id": "awID-TFe8zpX"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def calculate_sizes(skeleton_pixels, border_matrix, largura_escala, tamanho_escala_nm, vezes=10):\n",
        "    sizes = []\n",
        "    for _ in range(vezes):\n",
        "        perpendicular_line = find_perpendicular_line(skeleton_pixels, border_matrix)\n",
        "        size = len(perpendicular_line)\n",
        "        size_real = pixels_to_real_size(size, largura_escala, tamanho_escala_nm) * 2\n",
        "        sizes.append(size_real)\n",
        "    return sizes\n"
      ],
      "metadata": {
        "id": "V-2SW8_C99AL"
      },
      "execution_count": 18,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns\n",
        "\n",
        "def plot_histogram_and_boxplot(data):\n",
        "    # Plot Histogram\n",
        "    plt.figure(figsize=(10, 5))\n",
        "    sns.histplot(data, bins='auto', kde=True, kde_kws={'bw_adjust': 0.5})\n",
        "    plt.title('Histogram')\n",
        "    plt.xlabel('Values')\n",
        "    plt.ylabel('Frequency')\n",
        "    plt.grid(True)\n",
        "    plt.show()\n",
        "\n",
        "    # Plot Boxplot\n",
        "    plt.figure(figsize=(5, 5))\n",
        "    sns.boxplot(data=data, orient='v')\n",
        "    plt.title('Boxplot')\n",
        "    plt.ylabel('Values')\n",
        "    plt.grid(True)\n",
        "    plt.show()"
      ],
      "metadata": {
        "id": "EnlZvN1q-SLb"
      },
      "execution_count": 27,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Para servir como demonstração do cálculo dos diâmetros fibra temos uma imagem de uma fibra única e corretamente segmentada pertencente a base de dados feita pelo Labelbox, e em seguida mostraremos a distribuição desses diâmetros em um histograma e um boxplot que serão usados como base para a análise da fibra."
      ],
      "metadata": {
        "id": "6J-wWMPh-CpZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "tamanho_escala_nm = float(input(\"Digite o tamanho da escala em nanômetros (por exemplo, 1 para 1 nanômetro): \"))  # Tamanho da escala em nanômetros\n",
        "\n",
        "ulr = \"https://api.labelbox.com/api/v1/projects/clq8482cn04w6073s2jvda4km/annotations/clqaa9zvx001a3d6o2gr5d4hj/index/1/mask\"\n",
        "id = \"clqaa9zvx001a3d6o2gr5d4hj\"\n",
        "img = open_image(ulr, id)\n",
        "esqueleto2, skeleton_pixels, border_matrix = skeletonization_with_pixels(img)\n",
        "\n",
        "sizes = None\n",
        "sizes = calculate_sizes(skeleton_pixels, border_matrix, largura_escala, tamanho_escala_nm)\n",
        "\n",
        "plot_histogram_and_boxplot(sizes)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 940
        },
        "id": "pvmzH3qd-9BD",
        "outputId": "5008fbb3-8d30-4f3f-a85a-6dcaa629be17"
      },
      "execution_count": 29,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Digite o tamanho da escala em nanômetros (por exemplo, 1 para 1 nanômetro): 1\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x500 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 500x500 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Histograma:**\n",
        "> O histograma mostra a distribuição dos diâmetros das fibras estimados com base nas retas perpendiculares ao esqueleto da fibra.\n",
        "Ele nos permite visualizar a frequência com que diferentes faixas de diâmetros ocorrem. Isso é útil para entender a distribuição geral dos diâmetros e identificar se existe uma tendência central.\n",
        "Além disso, podemos usar o histograma para verificar se a distribuição dos diâmetros se assemelha a uma distribuição normal ou se possui alguma assimetria.\n",
        "\n",
        "**Boxplot:**\n",
        "> O boxplot complementa o histograma fornecendo informações sobre a dispersão dos dados e identificando valores atípicos.\n",
        "Ele mostra a mediana, quartis e os limites dos dados, permitindo identificar rapidamente a variação e possíveis valores extremos.\n",
        "No contexto da pesquisa sobre fibras, o boxplot nos ajuda a entender a variabilidade nos diâmetros das fibras, bem como detectar se existem valores discrepantes que podem ser causados por erros de medição ou características incomuns das fibras."
      ],
      "metadata": {
        "id": "ZxS0CuIXB2q2"
      }
    }
  ]
}