lab2-nome-sobrenome.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "0f662b44",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "![banner-pdi](https://user-images.githubusercontent.com/58775072/141189378-b5df3287-e8c0-48a1-ad11-825ba317463b.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3812ab62",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Universidade Federal de Campina Grande (UFCG)\n",
    "## Centro de Engenharia Elétrica e Informática (CEEI) \n",
    "## Disciplina: Int. ao Processamento de Imagem Digital e Visão Computacional\n",
    "## Professora: Luciana Ribeiro Veloso\n",
    "## Aluno(a): Coloque seu nome aqui"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "simplified-progress",
   "metadata": {},
   "source": [
    "## Observações\n",
    "***\n",
    "\n",
    "1. Os arquivos de laboratório devem ser salvos seguindo o seguinte padrão: `lab-x-nome-sobrenome.ipynb`.\n",
    "2. Não esqueça de colocar o seu nome no cabeçalho acima.\n",
    "3. Não altere a ordem das células e realize as implementações somente nos campos específicados.  \n",
    "4. Ao longo do laboratório será solicitado perguntas teóricas relativas aos assuntos das aulas da disciplina e implementações de código utilizando a linguagem de programação Python. \n",
    "5. As células de implementação com código serão indicadas pelos seguintes comentários: `# IMPLEMENTE O SEU CÓDIGO AQUI`.\n",
    "6. Para editar uma célula de texto, basta clicar duas vezes com o cursos do mouse para editar, e `Ctrl + Enter` para finalizar a edição. \n",
    "7. Para rodar as células com os códigos desenvolvidos, digite `Ctrl + Enter` ou clique em `Run` no menu do Jupyter.\n",
    "8. Dúvidas, problemas de execução de código ou dificuldades com a linguagem de programação Python devem ser feitas durante as aulas de laboratório, encaminhadas para o grupo de WhatsApp da turma ou fórum do PVAE da disciplina.\n",
    "9. Os laboratórios devem ser enviados nos campos especificados pelo PVAE. ATENTE-SE AOS PRAZOS DE ENTREGA!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d1ab7f1d",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# <span style='color:red'>Laboratório 2: Processamento Digital de Imagens</span>\n",
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a7f9ad6",
   "metadata": {},
   "source": [
    "### Importação dos Pacotes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "986f67bf",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "import cv2                           # opencv para manipulação de imagens\n",
    "import numpy as np                   # numpy para manipulação de matrizes e arrays\n",
    "import matplotlib.pyplot as plt      # pyplot para plotagem de gráficos e imagens\n",
    "import urllib.request as url         # urllib para baixar arquivos via HTTPS\n",
    "import zipfile                       # zipfile para lidar com pastas compactadas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d0e8b0b4",
   "metadata": {},
   "outputs": [],
   "source": [
    "# baixando as imagens de referência\n",
    "url.urlretrieve('https://github.com/Alyssonmach/pdi-labs/raw/main/imagens.zip', 'imagens.zip')\n",
    "with zipfile.ZipFile('imagens.zip', 'r') as zip_ref:\n",
    "    zip_ref.extractall('')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2ab62222",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Numpy Arrays\n",
    "\n",
    "Podemos utilizar a biblioteca Numpy para escrever arrays e matrizes de forma semelhante ao Matlab:  \n",
    "\n",
    "* `a) A = np.array( [1, 2, 3, 4, 5])`\n",
    "* `b) B = np.array( [ [1, 2, 3], [4, 5, 6], [7, 8, 9] ])`  \n",
    "* `c) C = np.array( [ [ [1, 2], [3, 4] ], [ [1, 2], [3, 4] ] ])`\n",
    "    \n",
    "Descrição:  \n",
    "* O código do item **a)** produz um array unidimensional a partir de uma lista;\n",
    "* Já o do item **b)** produz um array bidimensional, ou uma matriz, a partir de uma lista de listas;\n",
    "* Por fim, o código do item **c)** produz um array tridimensional;\n",
    "* Os arrays podem ser exibidos a partir do comando **print**, como por exemplo em **print(A)**;\n",
    "* É possível checar as dimensões de cada array printando o atributo **shape**, digitando por exemplo **print(A.shape)**;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "approved-threshold",
   "metadata": {},
   "outputs": [],
   "source": [
    "A = np.array([1, 2, 3, 4, 5])\n",
    "B = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])\n",
    "C = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "58e1eb27",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Array A: {}\".format(A))\n",
    "print(\"Shape de A: {}\".format(A.shape))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "da265ad9",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Array B:\\n{}\".format(B))\n",
    "print(\"Shape de B: {}\".format(B.shape))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "794459cb",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Array C:\\n{}\".format(C))\n",
    "print(\"Shape de C: {}\".format(C.shape))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2874cddb",
   "metadata": {},
   "source": [
    "Elementos internos dos arrays podem ser acessados utilizando colchetes, por exemplo:\n",
    "\n",
    "* **A[0]** acessa o primeiro elemento de A, nesse caso 1;\n",
    "* **B[0, 2]** acessa o terceiro elemento da primeira linha de B, ou seja 3.\n",
    "* **C[1, 0, 1]** acessa o segundo elemento da primeira linha da segunda matriz de C, ou seja 6;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d6cc9464",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"A[0] == {}\".format(A[0]))\n",
    "print(\"B[0,2] == {}\".format(B[0,2]))\n",
    "print(\"C[1, 0, 1] == {}\".format(C[1, 0, 1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6f57a37e",
   "metadata": {},
   "source": [
    "Também é possível acessar fatias do array utilizando o operador `:` como pode ser visto a seguir:\n",
    "\n",
    "* **A[0:4]** retorna um array formado pelos quatro primeiros elementos de A;\n",
    "* **B[2, 0:2]** retorna um array unidimensional formado pelos dois primeiros elementos da terceira linha de B;\n",
    "* **C[0, :, :]** retorna um array bidimensional formado por todas as linhas e colunas da primeira matriz de C;\n",
    "* Observe que a contagem dos índices é iniciada em 0;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7360eaa6",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"A[0:4]: {}\\n\".format(A[0:4]))\n",
    "print(\"B[2, 0:2]: {}\\n\".format(B[2, 0:2]))\n",
    "print(\"C[0, :, :]:\\n{}\".format(C[0, :, :]))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f546cc3a",
   "metadata": {},
   "source": [
    " ## <span style='color:blue'>Questão 1: [Valor da Questão: 1.5][Taxa de acerto: x.x]</span>\n",
    "\n",
    "* (a) Produza as seguintes matrizes:\n",
    "    * `A1 = A[1:4]`\n",
    "    * `B1 = B[1:2, 0:1]`\n",
    "    * `B2 = B[-1, -2]`\n",
    "    * `C1 = C[-2, -2, -2]` \n",
    "    * `C2 = C[0, 0, 0]`\n",
    "    * `C3 = C[:, 0, 0]`  \n",
    "* (b) Analisando os resultados obtidos, o que os índices negativos significam?\n",
    "* (c) **C1** e **C2** são iguais? Explique."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9903b6cc-df41-4de8-8ff7-595961097d12",
   "metadata": {},
   "outputs": [],
   "source": [
    "# IMPLEMENTE SEU CÓDIGO AQUI -> QUESTÃO 1 - LETRA (a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "geological-reading",
   "metadata": {},
   "source": [
    "## <span style='color:green'>Respostas da Questão 1:</span>\n",
    "\n",
    "* (b) Adicione sua resposta aqui.\n",
    "* (c) Adicione sua resposta aqui."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0dd239f4",
   "metadata": {},
   "source": [
    "### Tipos de Imagem\n",
    "\n",
    "1. Vamos trabalhar com quatro tipos de imagens:  \n",
    "\n",
    "    a. **Imagens de Intensidades:** São matrizes cujos valores representam intensidades em cada ponto. Elementos de intensidade da classe **uint8** terão valores no intervalo [0, 255]. Já elementos da classe **uint16** terão valores entre [0, 65535].\n",
    "    \n",
    "    b. **Imagens Binárias:** São um arranjo lógico em forma de matriz cujos valores são booleanos, podendo ser 0s ou 1s;   \n",
    "    \n",
    "    c. **Imagens Indexadas:** São imagens cujo valor de cada pixel está associado a uma cor descrita por um mapa de cores (colormap);  \n",
    "    \n",
    "    d. **Imagens Coloridas:** São Imagens com múltiplos canais onde os múltiplos valores associados a um determinado pixel descrevem a sua cor. Um exemplo seriam imagens RGB, onde os diferentes canais descrevem a intensidade luminosa das cores vermelho (R), verde (G) e azul (B), respectivamente, de uma imagem;  \n",
    "    \n",
    "* Note que os tipos de imagem não são excludentes, uma mesma imagem pode estar associada a mais de um dos tipos descritos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "52c87116",
   "metadata": {},
   "outputs": [],
   "source": [
    "# a próxima linha de código torna a figura do matplotlib interativa, permitindo visualizar os valores de cada pixel \n",
    "# a figura deixará de ser interativa quando outra célula for executada\n",
    "# é possível reativá-la ao rodar essa célula novamente\n",
    "%matplotlib notebook \n",
    "\n",
    "# um array do numpy pode ser interpretado como uma imagem de intensidade\n",
    "I = np.array([[0, 50, 100, 150, 200, 250], \n",
    "              [0, 50, 100, 150, 200, 250], \n",
    "              [0, 50, 100, 150, 200, 250], \n",
    "              [0, 50, 100, 150, 200, 250], \n",
    "              [0, 50, 100, 150, 200, 250]]).astype(np.uint8)\n",
    "\n",
    "# podemos utilizar o matplotlib para visualizar a imagem através da função imshow\n",
    "plt.figure(figsize = (4, 4))\n",
    "plt.imshow(I, cmap = \"gray\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "df2d083c",
   "metadata": {},
   "source": [
    "* Observe que a associação das intensidades a cores é arbitrária, podendo ser obtida uma imagem diferente mudando o colormap."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a2083dd6",
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib notebook \n",
    "fig, axs = plt.subplots(nrows = 2, ncols = 3, figsize=(8, 6))\n",
    "\n",
    "# primeira linha de subfiguras\n",
    "\n",
    "# primeira subfigura\n",
    "axs[0][0].imshow(I)\n",
    "axs[0][0].set_title(\"Colormap Padrão\", fontsize = 10)\n",
    "\n",
    "# segunda subfigura\n",
    "axs[0][1].imshow(I, cmap = \"gray\")\n",
    "axs[0][1].set_title(\"Colormap em Escala de Cinza\", fontsize = 10)\n",
    "\n",
    "# terceira subfigura\n",
    "axs[0][2].imshow(I, cmap = \"Purples\")\n",
    "axs[0][2].set_title(\"Colormap em tons de roxo\", fontsize = 10)\n",
    "\n",
    "# segunda linha de subfiguras\n",
    "\n",
    "# primeira subfigura  \n",
    "axs[1][0].imshow(I, cmap=\"Reds\")\n",
    "axs[1][0].set_title(\"Colormap em tons de vermelho\", fontsize = 10)\n",
    "\n",
    "# segunda subfigura\n",
    "axs[1][1].imshow(I, cmap=\"Greens\")\n",
    "axs[1][1].set_title(\"Colormap em tons de verde\", fontsize = 10)\n",
    "\n",
    "# terceira subfigura\n",
    "axs[1][2].imshow(I, cmap=\"Blues\")\n",
    "axs[1][2].set_title(\"Colormap em tons de azul\", fontsize = 10)  \n",
    "\n",
    "# Referências de colormaps: https://matplotlib.org/stable/tutorials/colors/colormaps.html"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8bf89c81",
   "metadata": {},
   "source": [
    "* Observe que a associação dos valores mínimos e máximos também é arbitrária e pode ser controlada pelos argumentos **vmin** e **vmax**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3de2515d",
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib notebook\n",
    "fig, axs = plt.subplots(nrows = 2, ncols = 3, figsize=(8, 6))\n",
    "\n",
    "# primeira linha de subfiguras\n",
    "\n",
    "# primeira Subfigura\n",
    "axs[0][0].imshow(I, cmap = \"gray\")\n",
    "axs[0][0].set_title(\"Valores Padrão\", fontsize = 10)\n",
    "\n",
    "# segunda Subfigura\n",
    "axs[0][1].imshow(I, vmin = 100, vmax = 200, cmap = \"gray\")\n",
    "axs[0][1].set_title(\"vmin = 100, vmax = 200\", fontsize = 10)\n",
    "\n",
    "# terceira Subfigura\n",
    "axs[0][2].imshow(I, vmin = 25, vmax = 75, cmap = \"gray\")\n",
    "axs[0][2].set_title(\"vmin = 25, vmax = 75\", fontsize = 10)\n",
    "\n",
    "## segunda linha de subfiguras\n",
    "\n",
    "# primeira Subfigura\n",
    "axs[1][0].imshow(I, vmin = -1, vmax = 0, cmap = \"gray\")\n",
    "axs[1][0].set_title(\"vmin = -1, vmax = 0\", fontsize = 10)\n",
    "\n",
    "# segunda Subfigura\n",
    "axs[1][1].imshow(I, vmin = 115, vmax = 125, cmap = \"gray\")\n",
    "axs[1][1].set_title(\"vmin = 115, vmax = 125\", fontsize = 10)\n",
    "\n",
    "# terceira Subfigura\n",
    "axs[1][2].imshow(I, vmin = 255, vmax = 256, cmap = \"gray\")\n",
    "axs[1][2].set_title(\"vmin = 255, vmax = 256\", fontsize = 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5ac41ce9",
   "metadata": {},
   "source": [
    " ## <span style='color:blue'>Questão 2: [Valor da Questão: 1.0][Taxa de acerto: x.x]</span>\n",
    "\n",
    "* Ao ajustar os argumentos **vmin** e **vmax**, as imagens geradas foram diferentes da imagem com cores padrão. Que tipo de alteração ocorreu? A matriz original sofreu alguma modificação?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d3f4072c",
   "metadata": {},
   "source": [
    "## <span style='color:green'>Respostas da Questão 2:</span>\n",
    "\n",
    "* Adicione sua resposta aqui."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "45ac2e82",
   "metadata": {},
   "source": [
    "### Convertendo Tipos de Dados"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5f30bbd4",
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib notebook \n",
    "fig, axs = plt.subplots(nrows = 1, ncols = 3, figsize=(8, 6))\n",
    "\n",
    "# é preciso se atentar aos valores da matriz ao converter entre os tipos de array\n",
    "I16 = np.array([[  0,   0,   0,   0,   0,   0], \n",
    "                [ 50,  50,  50,  50,  50,  50], \n",
    "                [100, 100, 100, 100, 100, 100], \n",
    "                [150, 150, 150, 150, 150, 150], \n",
    "                [200, 200, 200, 200, 200, 200], \n",
    "                [250, 250, 250, 250, 250, 250], \n",
    "                [300, 300, 300, 300, 300, 300]]).astype(np.uint16)\n",
    "\n",
    "axs[0].imshow(I16, vmin = 0, vmax = 255, cmap = \"gray\")\n",
    "axs[0].set_title(\"Imagem Original uint16\", fontsize = 10)\n",
    "axs[0].set_xlabel(\"vmin = 0\\n vmax = 255\", fontsize = 10)\n",
    "\n",
    "# a conversão direta sem o reescalonamento dos valores pode produzir resultados inesperados\n",
    "I8a = I16.astype(np.uint8)\n",
    "axs[1].imshow(I8a, vmin = 0, vmax = 255, cmap = \"gray\")\n",
    "axs[1].set_title(\"Imagem uint8 s/ \\nreescalonamento\", fontsize = 10)\n",
    "axs[1].set_xlabel(\"vmin = 0\\n vmax = 255\", fontsize = 10)\n",
    "\n",
    "# o reescalonamento melhora os resultados, mas como uint8 não aceita valores decimais, ocorrem erros de quantização\n",
    "rescale_factor = 255 / np.max(I16)\n",
    "I8b = ( rescale_factor * I16 ).astype(np.uint8)\n",
    "axs[2].imshow(I8b, vmin = 0, vmax = 255, cmap = \"gray\")\n",
    "axs[2].set_title(\"Imagem uint8 c/ \\nreescalonamento\", fontsize = 10)\n",
    "axs[2].set_xlabel(\"vmin = 0\\n vmax = 255\", fontsize = 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "41b52aea",
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib notebook \n",
    "fig, axs = plt.subplots(nrows = 1, ncols = 3, figsize=(8, 6))\n",
    "\n",
    "# é preciso se atentar aos valores da matriz ao converter entre os tipos de array\n",
    "I8 = np.array([[36,  47,  75,  32,  18], \n",
    "               [0,  90,   0,  67,  29], \n",
    "               [150,  22,  50,  20,  54], \n",
    "               [50,  34,  65,  40,  50], \n",
    "               [6,  50,   5,  50,  13], \n",
    "               [39,   1,  50,  25,   0]]).astype(np.uint8)\n",
    "\n",
    "axs[0].imshow(I8, vmin = 0, vmax = 255, cmap = \"gray\")\n",
    "axs[0].set_title(\"Imagem Original uint8\", fontsize = 10)\n",
    "axs[0].set_xlabel(\"vmin = 0\\n vmax = 255\", fontsize = 10)\n",
    "\n",
    "# imagens formadas a partir de arrays float32 são tipicamente utilizadas em aplicações de IA como redes convolucionais\n",
    "# nesse caso, a conversão pode ser realizada dividindo os elementos da matriz por 255, maior valor para imagens uint8\n",
    "# como o tipo float32 aceita valores decimais e dispõe de mais bits para representar os valores, não ocorrem perdas.\n",
    "Ifloat = (I8 / 255).astype(np.float32)\n",
    "axs[1].imshow(Ifloat, vmin=0, vmax=1, cmap = \"gray\")\n",
    "axs[1].set_title(\"Imagem Float\", fontsize = 10)\n",
    "axs[1].set_xlabel(\"vmin = 0\\n vmax = 1.0\", fontsize = 10)\n",
    "\n",
    "# imagens (ou máscaras) binárias são geralmente utilizadas para a extração de características em imagens\n",
    "# nesse caso, a conversão pode ser realizada a partir de um processo de limiarização (thresholding)\n",
    "# os valores booleanos podem ser convertidos em números (0s e 1s) mudando o tipo de array para float ou uint\n",
    "Ibin = (I8 >= 50)\n",
    "axs[2].imshow(Ibin, cmap = \"gray\")\n",
    "axs[2].set_title(\"Imagem Binária\", fontsize = 10)\n",
    "axs[2].set_xlabel(\"vmin = False\\n vmax = True\", fontsize = 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "225e51e7",
   "metadata": {},
   "source": [
    "## <span style='color:blue'>Questão 3: [Valor da Questão: 1.5][Taxa de Acerto: x.x]</span>\n",
    "\n",
    "* (a) reproduza e plote as seguintes matrizes:\n",
    "    * `A = [[16, 3, 2, 13], [6, 9, 12, 7], [5, 10, 11, 8], [4, 15, 14, 8]]` \n",
    "    * `B = [[16, 8, 2, 4], [20, 30, 40, 50], [5, 7, 8, 11]]`\n",
    "    * `C = [[20, 30, 40], [50, 90, 15], [80, 30, 10]]`\n",
    "    * `D = [[1, 2, 3, 4], [5, 6, 7, 8], [9, 8, 8, 9], [8, 7, 7, 8], [4, 5, 9, 8]]`\n",
    "* (b) Plote as seguintes Imagens de Intensidade e comente os resultados obtidos.\n",
    "    * `IA = A`  \n",
    "    * `IB = B, vmin =  4, vmax = 30`\n",
    "    * `IC = C, vmin = 15, vmax = 20`  \n",
    "    * `ID = D, vmin =  0, vmax = 20`   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "de2deb5a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# IMPLEMENTE SEU CÓDIGO AQUI -> QUESTÃO 3 - LETRA (a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8169035f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# IMPLEMENTE SEU CÓDIGO AQUI -> QUESTÃO 3 - LETRA (b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "clean-restriction",
   "metadata": {},
   "source": [
    "## <span style='color:green'>Resposta da Questão 3:</span>\n",
    "\n",
    "* (b) Adicione sua resposta aqui."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "23f0c950",
   "metadata": {},
   "source": [
    "## <span style='color:blue'>Questão 4: [Valor da Questão: 1.0][Taxa de acerto: x.x]</span>\n",
    "\n",
    "* A partir da matriz **G** abaixo, gere as imagens solicitadas. Comente os resultados obtidos.\n",
    "    * Uma imagem de intensidade com valores entre [0, 1].\n",
    "    * Uma imagem binária com limiar de 0.25.\n",
    "    * Uma imagem com valores no intervalo [0, 255].\n",
    "\n",
    "`G = [[-0.7, 1.2, 0.4, -0.6, -0.4, 1.2],  \n",
    "      [-1.6, -0.6, 0.4, 0.8, 0.0, 0.8],  \n",
    "      [1.5, -0.5, 0.1, 0.2, -0.8, 1.1],  \n",
    "      [2.1, 0.9, 0.5, -0.5, -1.6, -0.7],  \n",
    "      [0.1, -1.4, 1.1, -1.2, 0.2, -0.9],  \n",
    "      [-1.0, -2.0, 1.0, 0.6, -0.1, -1.3]]`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "challenging-commons",
   "metadata": {},
   "outputs": [],
   "source": [
    "# IMPLEMENTE SEU CÓDIGO AQUI - QUESTÃO 4"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "collectible-courage",
   "metadata": {},
   "source": [
    "## <span style='color:green'>Resposta da Questão 4:</span>\n",
    "\n",
    "* Adicione sua resposta aqui."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e8f4c69b",
   "metadata": {},
   "source": [
    "## <span style='color:blue'>Questão 5: [Valor da Questão: 1.0][Taxa de acerto: x.x]</span>\n",
    "\n",
    "* Com base na matriz G, comente a diferença entre as imagens G1 e G2 abaixo. Observe os valores de diferentes pixels nas mesmas posições."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dfcbda6a",
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib notebook\n",
    "\n",
    "G = np.array([[-0.7, 1.2, 0.4, -0.6, -0.4, 1.2], [-1.6, -0.6, 0.4, 0.8, 0.0, 0.8], \n",
    "               [1.5, -0.5, 0.1, 0.2, -0.8, 1.1], [2.1, 0.9, 0.5, -0.5, -1.6, -0.7], \n",
    "               [0.1, -1.4, 1.1, -1.2, 0.2, -0.9], [-1.0, -2.0, 1.0, 0.6, -0.1, -1.3] ]).astype(np.float32)\n",
    "\n",
    "# produzindo G1 a partir de G\n",
    "G1 = G - np.min(G)\n",
    "rescale_factor = 255 / np.max(G1)\n",
    "G1 = (rescale_factor * G1).astype(np.uint8)\n",
    "G1 = (G1 / 255).astype(np.float32)\n",
    "\n",
    "# produzindo G2 a partir de G\n",
    "G2 = G - np.min(G)\n",
    "G2 = (G2 / np.max(G2)).astype(np.float32)\n",
    "\n",
    "fig, axs = plt.subplots(nrows = 1, ncols = 2, figsize=(8, 6))\n",
    "\n",
    "axs[0].imshow(G1, vmin=0, vmax=1, cmap=\"gray\")\n",
    "axs[0].set_title(\"Imagem G1\", fontsize=10)\n",
    "\n",
    "axs[1].imshow(G2, vmin=0, vmax=1, cmap=\"gray\")\n",
    "axs[1].set_title(\"Imagem G2\", fontsize=10) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "occupied-sector",
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Informações Estatísticas de G:\\n')\n",
    "print('Dimensão da Imagem:', G.shape)\n",
    "print('Quantidade de Pixels:', G.size)\n",
    "print('Média: {:.3f}'.format(np.mean(G)))\n",
    "print('Desvio Padrão: {:.3f}'.format(np.std(G)))\n",
    "print('Valor Mínimo:', np.min(G))\n",
    "print('Valor Máximo:', np.max(G))\n",
    "\n",
    "print('\\nInformações Estatísticas de G1:\\n')\n",
    "print('Dimensão da Imagem:', G1.shape)\n",
    "print('Quantidade de Pixels:', G1.size)\n",
    "print('Média: {:.3f}'.format(np.mean(G1)))\n",
    "print('Desvio Padrão: {:.3f}'.format(np.std(G1)))\n",
    "print('Valor Mínimo:', np.min(G1))\n",
    "print('Valor Máximo:', np.max(G1))\n",
    "\n",
    "print('\\nInformações Estatísticas de G2:\\n')\n",
    "print('Dimensão da Imagem:', G2.shape)\n",
    "print('Quantidade de Pixels:', G2.size)\n",
    "print('Média: {:.3f}'.format(np.mean(G2)))\n",
    "print('Desvio Padrão: {:.3f}'.format(np.std(G2)))\n",
    "print('Valor Mínimo:', np.min(G2))\n",
    "print('Valor Máximo:', np.max(G2))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4d2ef891-e431-4da8-9c1e-2b953861093d",
   "metadata": {},
   "source": [
    "## <span style='color:green'>Resposta da Questão 5:</span>\n",
    "\n",
    "* Adicione sua resposta aqui."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "95f5ab32",
   "metadata": {},
   "source": [
    "### Lendo imagens do computador\n",
    "***\n",
    "\n",
    "A biblioteca OpenCV possibilita carregar imagens do computador como arrays do numpy através da função **imread** (Observe que o comando cv2.imread lê uma imagem colorida como BGR, enquanto o comando plt.imread lê como RGB):  \n",
    "\n",
    "* **Sintaxe:** `im = cv2.imread( filepath, 0)`\n",
    "\n",
    "* **Descrição:** A função carrega a o arquivo cujo caminho está contido na string <filepath> e a armazena na variável im como um array do numpy. O flag 0 indica o carregamento do arquivo como imagem monocromática.  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c6c32371",
   "metadata": {},
   "source": [
    "## <span style='color:blue'>Questão 06: [Valor da Questão: 2.0][Taxa de Acerto: x.x]</span>\n",
    "\n",
    "* (a) Realize a leitura da imagem lenna.jpg (ou outra a sua escolha) e utilize o matplotlib para visualizar a imagem. Analise a variável im produzida, verificando suas dimensões e valores máximo e mínimo.\n",
    "* (b) Faça o mesmo para a imagem morangos.jpg (ou outra a sua escolha), mas utilize também a mágica \"%matplotlib notebook\". Explore as ferramentas da janela produzida."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6324432f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# IMPLEMENTE O SEU CÓDIGO AQUI -> QUESTÃO 6 - LETRA (a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f5003d7a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# IMPLEMENTE O SEU CÓDIGO AQUI -> QUESTÃO 6 - LETRA (b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "766e256c",
   "metadata": {},
   "source": [
    "A biblioteca OpenCV possibilita redimensionar imagens carregadas através da função **resize**:  \n",
    "\n",
    "* **Sintaxe:** `dst_img = cv2.resize(src_img, (cols, rows))`  \n",
    "\n",
    "* **Descrição:** A função altera as dimensões da imagem <src_img> para as dimensões fornecidas (cols, rows), retornando  <dst_img>, que é a imagem redimensionada. <src_img> pode ser uma imagem monocromática, colorida ou binária e as novas dimensões podem ser maiores ou menores que as originais."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6072a367",
   "metadata": {},
   "source": [
    "## <span style='color:blue'>Questão 7: [Valor da Questão: 2.0][Taxa de acerto: x.x]</span>\n",
    "\n",
    "* (a) Carregue a imagem **mandril.tiff** e altere suas dimensões utilizando a função resize para as dimensões listadas a seguir. Verifique as dimensões de cada imagem para confirmar o redimensionamento.\n",
    "\n",
    "    * 240 x 240\n",
    "    * 120 x 120\n",
    "    *  60 x  60\n",
    "    *  30 x  30\n",
    "* (b) Plote as imagens redimensionadas utilizando subplots e comente os resultados observados.\n",
    "* (c) Comente os resultados obtidos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8abd4495",
   "metadata": {},
   "outputs": [],
   "source": [
    "# IMPLEMENTE O SEU CÓDIGO AQUI -> QUESTÃO 7 - LETRA (a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a49607cc",
   "metadata": {},
   "outputs": [],
   "source": [
    "# IMPLEMENTE O SEU CÓDIGO AQUI - QUESTÃO 7 - LETRA (b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3768e806-6f52-47d8-a003-3e139d9de4bf",
   "metadata": {},
   "source": [
    "## <span style='color:green'>Resposta da Questão 7:</span>\n",
    "\n",
    "* Adicione sua resposta aqui."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "803f6ced",
   "metadata": {},
   "source": [
    "***\n",
    "![image](https://user-images.githubusercontent.com/58775072/142712576-857585e2-09a4-49a2-92cd-17507e2e2fc9.gif)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.7"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "226.188px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}