{"id":17124378,"url":"https://github.com/wittline/computer-vision-and-deep-learning","last_synced_at":"2025-07-19T07:07:49.434Z","repository":{"id":111709950,"uuid":"166850283","full_name":"Wittline/Computer-Vision-and-Deep-Learning","owner":"Wittline","description":"This repository contains information on the basic techniques and algorithms used in computer image processing, in addition to some projects related to pattern recognition using deep learning.","archived":false,"fork":false,"pushed_at":"2020-11-11T14:00:14.000Z","size":7803,"stargazers_count":2,"open_issues_count":0,"forks_count":1,"subscribers_count":2,"default_branch":"master","last_synced_at":"2025-06-09T20:38:02.692Z","etag":null,"topics":["computer-vision","deep-learning","image-processing"],"latest_commit_sha":null,"homepage":"https://wittline.github.io/Computer-Vision-and-Deep-Learning/","language":"Python","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":null,"status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/Wittline.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":null,"code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null}},"created_at":"2019-01-21T17:05:10.000Z","updated_at":"2023-04-23T16:06:20.000Z","dependencies_parsed_at":null,"dependency_job_id":"df3620dd-c11a-41e0-97b5-2fec2a31aa84","html_url":"https://github.com/Wittline/Computer-Vision-and-Deep-Learning","commit_stats":null,"previous_names":[],"tags_count":0,"template":false,"template_full_name":null,"purl":"pkg:github/Wittline/Computer-Vision-and-Deep-Learning","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Wittline%2FComputer-Vision-and-Deep-Learning","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Wittline%2FComputer-Vision-and-Deep-Learning/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Wittline%2FComputer-Vision-and-Deep-Learning/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Wittline%2FComputer-Vision-and-Deep-Learning/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/Wittline","download_url":"https://codeload.github.com/Wittline/Computer-Vision-and-Deep-Learning/tar.gz/refs/heads/master","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Wittline%2FComputer-Vision-and-Deep-Learning/sbom","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":265899938,"owners_count":23845879,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["computer-vision","deep-learning","image-processing"],"created_at":"2024-10-14T18:42:29.949Z","updated_at":"2025-07-19T07:07:49.397Z","avatar_url":"https://github.com/Wittline.png","language":"Python","funding_links":[],"categories":[],"sub_categories":[],"readme":"# Ramses Alexander Coraspe Valdez\n# Computer vision and Deep Learning homeworks\n\nThis repository contains information on the basic techniques and algorithms used in computer image processing, in addition to some projects related to pattern recognition using deep learning.\n\n\n## 1. Image processing - Image transformations\n\t\t\n\t\t\t\n![alt text](https://wittline.github.io/Computer-Vision-and-Deep-Learning/Visi%C3%B3n%20Computacional%20y%20Deep%20Learning/Tarea%201/ejemplos/baboon.png)\n\t\n### 1. Transformar a una imagen de grises usando la transformación ponderada.\n\t\nLa funciòn recibe una imagen en 24 bits (RGB) y retorna una imagen en la escala de grises en 8 bits\n```\ndef TransformacionPonderada(list24bits):\n    return  [round((0.29894 * list24bits[i][0]) + \n                     (0.58704 * list24bits[i][1]) + \n                     (0.11402 * list24bits[i][2])) \n                for i in range(len(list24bits))]   \n```\n![alt text](https://wittline.github.io/Computer-Vision-and-Deep-Learning/Visi%C3%B3n%20Computacional%20y%20Deep%20Learning/Tarea%201/ejemplos/baboon_TP.png)\n     \t\n### 2. Transformarla a una imagen de grises con el promedio aritmético.\n\nLa funcion recibe una imagen en 24 bits (RGB) y retorna una imagen en la escala de grises en 8 bits\n\n```\ndef TransformacionPromedioAritmetico(list24bits):\n    return  [((list24bits[i][0]) +\n              (list24bits[i][1]) +  \n              (list24bits[i][2]) /3) \n             for i in range(len(list24bits))]   \n   \n```\n\n![alt text](https://wittline.github.io/Computer-Vision-and-Deep-Learning/Visi%C3%B3n%20Computacional%20y%20Deep%20Learning/Tarea%201/ejemplos/baboon_TPA.png)\t\n\n### 3. A partir de la imagen de grises ponderada, realizar las siguientes transformaciones:\n#### 3.1. Aplicarle la transformación negativa.\n\nLa funcion recibe una imagen en 8 bits y retorna una imagen negativa\n\n```\ndef TransformacionNegativa(list8bits):\n    return  [(255 - list8bits[i]) \n             for i in range(len(list8bits))]   \n   \n```\n![alt text](https://wittline.github.io/Computer-Vision-and-Deep-Learning/Visi%C3%B3n%20Computacional%20y%20Deep%20Learning/Tarea%201/ejemplos/baboon_TN.png)\n\n\n#### 3.2. Binarizarla con un umbral de  150 y la función: t(x) = 0, x\u003c= 150; t(x)=255, x\u003e150.\n\nLa funcion recibe una imagen en 8 bits y retorna una imagen binarizada usando un umbral de 150\n\n```\ndef TransformacionBinarizadaUmbral(list8bits, umbral):\n    return  [ (0 if list8bits[i]\u003c= umbral else 255 ) \n              for i in range(len(list8bits))]\n   \n```\n\n![alt text](https://wittline.github.io/Computer-Vision-and-Deep-Learning/Visi%C3%B3n%20Computacional%20y%20Deep%20Learning/Tarea%201/ejemplos/baboon_TB.png)\n\n#### 3.3 Aplicar la transformación de raíz cuadrada y escalarla en (0, 255). \n\nLa funcion recibe una imagen en 8 bits, se calcula la raiz cuadrada del valor de cada pixel y el resultado final se escala\n\n```\ndef escalar(list8bits):        \n    mi = min(list8bits)\n    ma = max(list8bits)    \n    newlist =  [ ((255) /(ma - mi)) * (list8bits[i] - mi) \n                          for i in range(len(list8bits))]        \n    return newlist\n\ndef TransformacionRaizCuadrada(list8bits):\n    return  [( math.sqrt(list8bits[i])) \n               for i in range(len(list8bits))]\n               \nTRC = escalar(TransformacionRaizCuadrada(TP))\n     \n``` \n![alt text](https://wittline.github.io/Computer-Vision-and-Deep-Learning/Visi%C3%B3n%20Computacional%20y%20Deep%20Learning/Tarea%201/ejemplos/baboon_TRC.png)\n\n#### 3.4 Aplicar la transformación de potencia al cubo y escalarla en (0, 255).\n\nLa funcion recibe una imagen en 8 bits, se calcula la la potencia al cubo del valor de cada pixel y el resultado final se escala\n\n```\ndef escalar(list8bits):        \n    mi = min(list8bits)\n    ma = max(list8bits)    \n    newlist =  [ ((255) /(ma - mi)) * (list8bits[i] - mi) \n                          for i in range(len(list8bits))]        \n    return newlist\n\ndef TransformacionPotencia(list8bits, potencia):\n    return [(list8bits[i]**potencia) \n           for i in range(len(list8bits))]\n               \nTPC = escalar(TransformacionPotencia(TP, 3))\n     \n```\n![alt text](https://wittline.github.io/Computer-Vision-and-Deep-Learning/Visi%C3%B3n%20Computacional%20y%20Deep%20Learning/Tarea%201/ejemplos/baboon_TPC.png)\n\n### Código\n```\nimport math\nfrom PIL import Image\n\n\ndef escalar(list8bits):        \n    mi = min(list8bits)\n    ma = max(list8bits)    \n    newlist =  [ ((255) /(ma - mi)) * (list8bits[i] - mi) \n                          for i in range(len(list8bits))]        \n    return newlist\n\n\ndef TransformacionPonderada(list24bits):\n    return  [round((0.29894 * list24bits[i][0]) + \n                     (0.58704 * list24bits[i][1]) + \n                     (0.11402 * list24bits[i][2])) \n                for i in range(len(list24bits))]   \n\ndef TransformacionPromedioAritmetico(list24bits):\n    return  [((list24bits[i][0]) +\n              (list24bits[i][1]) +  \n              (list24bits[i][2]) /3) \n             for i in range(len(list24bits))]   \n\n\ndef TransformacionNegativa(list8bits):\n    return  [(255 - list8bits[i]) \n             for i in range(len(list8bits))] \n\ndef TransformacionBinarizadaUmbral(list8bits, umbral):\n    return  [ (0 if list8bits[i]\u003c= umbral else 255 ) \n              for i in range(len(list8bits))]\n\ndef TransformacionRaizCuadrada(list8bits):\n    return  [( math.sqrt(list8bits[i])) \n               for i in range(len(list8bits))]\n\ndef TransformacionPotencia(list8bits, potencia):\n    return [(list8bits[i]**potencia) \n           for i in range(len(list8bits))]\n\n\ndef convertirImagen(size, list8bits, filename):\n    newimage = Image.new('L', size) \n    newimage.putdata(list8bits) \n    newimage.save(filename)\n    newimage.close()\n    return 1\n\n \nimagenColor = Image.open('C:/ejemplos/baboon.png')\nMatrix = list(imagenColor.getdata())\n\nTP = TransformacionPonderada(Matrix)\nconvertirImagen(imagenColor.size,TP,'C:/ejemplos/baboon_TP.png')\nTPA = TransformacionPromedioAritmetico(Matrix)\nconvertirImagen(imagenColor.size,TPA,'C:/ejemplos/baboon_TPA.png')\nTN = TransformacionNegativa(TP);\nconvertirImagen(imagenColor.size,TN,'C:/ejemplos/baboon_TN.png')\nTB = TransformacionBinarizadaUmbral(TP, 150)\nconvertirImagen(imagenColor.size,TB,'C:/ejemplos/baboon_TB.png')\nTRC = escalar(TransformacionRaizCuadrada(TP))\nconvertirImagen(imagenColor.size,TRC,'C:/ejemplos/baboon_TRC.png')\nTPC = escalar(TransformacionPotencia(TP, 3))\nconvertirImagen(imagenColor.size,TPC,'C:/ejemplos/baboon_TPC.png')\nimagenColor.close()\n     \n```\n\n## 2. Edge Detection\n\n### 1. Obtener la correlación cruzada H ⨂ w, de la imagen con dicho kernel, y obtener la convolucion H * w\n\n```\ndef correlacion_cruzada(i, k):\n    return sn.correlate2d(i,k,'same',boundary='wrap', fillvalue=0)    \n\ndef convolucion(i, k):\n    return sn.convolve2d(i,k,'same',boundary='wrap', fillvalue=0)    \n\ndef rotar(a, g):    \n    if g == 0:\n        return a\n    elif g \u003e 0:\n        return rotar(list(zip(*a[::-1])), g-90)\n    else:\n        return rotar(list(zip(*a)[::-1]), g+90)     \n\n   #kernel w\n    w = np.array(([-10,-10, 0],\n                  [-10, 0, 10], \n                  [ 0, 10, 10]),\n                np.float32)\n\n    #matriz h\n    h = np.array(([10, 20, 0, 30, 30],\n                  [20, 0, 10, 20,  0], \n                  [10, 0, 40, 10, 10],  \n                  [20, 40, 0, 30, 10], \n                  [0, 10, 40, 20, 0]), \n                 np.float32)\n\n    print(\"** Primer ejercicio ** \")\n    cr = correlacion_cruzada(h,w)\n    print(\"Correlacion cruzada:\")\n    print(cr)\n    cv = convolucion(h,np.array(rotar(w,180),np.float32))\n    print(\"Convolucion:\")\n    print(cv)\n```\n\n### 2. Obtener las convoluciones H*Q , H*q y (H * q) qt,  q= [-1,3,-1]\n\n```\ndef convolucion(i, k):\n    return sn.convolve2d(i,k,'same',boundary='wrap', fillvalue=0)    \n\nprint(\"** Segundo ejercicio ** \")\n    # Vector q\n    q = np.array(([-1, 3, -1]), np.float32)\n    print(\"q:\")\n    # Traspuesta de q = qt\n    qt = q.reshape((-1,1))\n    print(\"qt:\")\n    #Q = qt*q\n    Q= np.outer(q, qt);\n    print(Q)\n\n    crQ = convolucion(h,Q)\n    print(\"Convolucion h * Q:\")\n    print(crQ)\n    crq = convolucion(h, q[None,:])\n    print(\"Convolucion h * q:\")\n    print(crq)\n    crqt = convolucion(crq, qt)\n    print(\"Convolucion (h * q)qt:\")\n    print(crqt)        \n```\n### 3. Usando la herramienta que mejor consideres, utiliza el operador Sobel de dicha librería para hacer la práctica que se indica en la diapositiva\n\n```\ndef contornos_sobel(filename):    \n    imyo = Image.open(filename);\n    imyoo = np.array(Image.open(filename))    \n    \n    ##sobel\n    img_sobelx = cv2.Sobel(imyoo,cv2.CV_8U,1,0,None,ksize=3,scale=1,delta=0)\n    img_sobely = cv2.Sobel(imyoo,cv2.CV_8U,0,1,None,ksize=3,scale=1,delta=0)\n    img_total = imyoo + img_sobelx + img_sobely    \n    scipy.misc.imsave(\"imyogray_sobelx.jpg\", img_sobelx)\n    scipy.misc.imsave(\"imyogray_sobely.jpg\", img_sobely)\n    scipy.misc.imsave(\"imyogray_sobel.jpg\", img_total )    \n    images = np.array([])\n    images = np.append(images, imyoo)\n    images = np.append(images, img_sobelx)\n    images = np.append(images, img_sobely)\n    images = np.append(images, img_total)    \n    imyo.close()\n    return images\n    \n    print(\"** Tercer ejercicio ** \")\n    contornos = contornos_sobel('yo.jpg')    \n```\n![alt text](https://wittline.github.io/Computer-Vision-and-Deep-Learning/Visi%C3%B3n%20Computacional%20y%20Deep%20Learning/Tarea%202/imyogray_sobelx.jpg)\n![alt text](https://wittline.github.io/Computer-Vision-and-Deep-Learning/Visi%C3%B3n%20Computacional%20y%20Deep%20Learning/Tarea%202/imyogray_sobely.jpg)\n![alt text](https://wittline.github.io/Computer-Vision-and-Deep-Learning/Visi%C3%B3n%20Computacional%20y%20Deep%20Learning/Tarea%202/imyogray_sobel.jpg)\n\n### 4. Este ejercicio debe usar la imagen en tono de grises de panda.png, la cual Usando la información del gradiente con el operador derivada que creas más conveniente (ver archivo 02_Transformaciones_Varias.pdf, diapositiva 36), dibujar en la imagen los vectores gradiente ortogonales a como se muestran en las imágenes de las diapositivas 36 y 37 del archivo mencionado. Para calcular y aproximar el gradiente puedes utilizar cualquiera de los kernels derivada que desees para obtener las parciales con X y Y. Sin embargo, la magnitud de todos ellos darle un valor constante a tu elección. Además, para una mejor visualización de los vectores gradientes, puedes dibujar solamente un porcentaje de dichos vectores gradientes y solo aquellos que tengan las magnitudes más significativas. \n\n```\ndef vectores_gradientes(filename): \n    \n    #leo la imagen y obtengo una en gris para aplicar el sobel\n    img = Image.open(filename);\n    im = np.array(Image.open(filename).convert('L'))\n    # obtengo las dimensiones de las columnas y filas\n    Ro = np.arange(0,im.shape[0]-1)\n    Co = np.arange(0,im.shape[1]-1)\n\n    #obtengo el filtro sobel para las lineas horizontales\n    imx = np.zeros(im.shape)\n    filters.sobel(im,1,imx)\n    #obtengo el filtro sobel para las lineas verticales\n    imy = np.zeros(im.shape)\n    filters.sobel(im,0,imy)\n    #obtengo las magnitudes y los angulos de todos los vectores, usando las derivadas de sobel\n    mag, angle = cv2.cartToPolar(imx, imy, angleInDegrees=True)\n    #obtego el promedio de las magnitudes\n    alphavectors = np.mean(mag)\n\n    #elimino vectores no relevantes que tengan una magnitud  menor al promedio\n    for x in range(0, mag.shape[0]):\n        for y in range(0, mag.shape[1]):\n            if mag[x, y] \u003c= alphavectors:\n                   imx[x, y] = None\n                   imy[x, y] = None\n\n    x, y = np.meshgrid(Ro, Co)\n    skip = (slice(None, None,4), slice(None, None, 4))\n    fig, ax = plt.subplots()\n    imi = ax.imshow(img)\n    ax.quiver(x[skip], y[skip], imx[skip], imy[skip], angles='xy', scale_units='xy', scale=25, pivot='mid',color='g')    \n    plt.show()\n    \n    \n  print(\"** Cuarto ejercicio ** \")\n  vectores_gradientes(\"panda.jpg\")\n```\n\n![alt text](https://wittline.github.io/Computer-Vision-and-Deep-Learning/Visi%C3%B3n%20Computacional%20y%20Deep%20Learning/Tarea%202/panda.jpg)\n\n![alt text](https://wittline.github.io/Computer-Vision-and-Deep-Learning/Visi%C3%B3n%20Computacional%20y%20Deep%20Learning/Tarea%202/panda_vector.jpg)\n        \n### Código\n```\nimport cv2\nimport numpy as np\nimport scipy.signal as sn\nimport scipy.misc\nfrom matplotlib import pyplot as plt\nfrom PIL import Image\nfrom scipy.ndimage import filters\n\ndef magnitud_Constante(v):\n    if(v\u003c0): return -100\n    else: return 100    \n\ndef correlacion_cruzada(i, k):\n    return sn.correlate2d(i,k,'same',boundary='wrap', fillvalue=0)    \n\ndef convolucion(i, k):\n    return sn.convolve2d(i,k,'same',boundary='wrap', fillvalue=0)    \n\ndef rotar(a, g):    \n    if g == 0:\n        return a\n    elif g \u003e 0:\n        return rotar(list(zip(*a[::-1])), g-90)\n    else:\n        return rotar(list(zip(*a)[::-1]), g+90)       \n\ndef vectores_gradientes(filename): \n    \n    #leo la imagen y obtengo una en gris para aplicar el sobel\n    img = Image.open(filename);\n    im = np.array(Image.open(filename).convert('L'))\n    # obtengo las dimensiones de las columnas y filas\n    Ro = np.arange(0,im.shape[0]-1)\n    Co = np.arange(0,im.shape[1]-1)\n\n    #obtengo el filtro sobel para las lineas horizontales\n    imx = np.zeros(im.shape)\n    filters.sobel(im,1,imx)\n    #obtengo el filtro sobel para las lineas verticales\n    imy = np.zeros(im.shape)\n    filters.sobel(im,0,imy)\n    #obtengo las magnitudes y los angulos de todos los vectores, usando las derivadas de sobel\n    mag, angle = cv2.cartToPolar(imx, imy, angleInDegrees=True)\n    #obtego el promedio de las magnitudes\n    alphavectors = np.mean(mag)\n\n    #elimino vectores no relevantes que tengan una magnitud  menor al promedio\n    for x in range(0, mag.shape[0]):\n        for y in range(0, mag.shape[1]):\n            if mag[x, y] \u003c= alphavectors:\n                   imx[x, y] = None\n                   imy[x, y] = None\n\n    x, y = np.meshgrid(Ro, Co)\n    skip = (slice(None, None,4), slice(None, None, 4))\n    fig, ax = plt.subplots()\n    imi = ax.imshow(img)\n    ax.quiver(x[skip], y[skip], imx[skip], imy[skip], angles='xy', scale_units='xy', scale=25, pivot='mid',color='g')    \n    plt.show()\n\ndef contornos_sobel(filename):    \n    imyo = Image.open(filename);\n    imyoo = np.array(Image.open(filename))    \n    \n    ##sobel\n    img_sobelx = cv2.Sobel(imyoo,cv2.CV_8U,1,0,None,ksize=3,scale=1,delta=0)\n    img_sobely = cv2.Sobel(imyoo,cv2.CV_8U,0,1,None,ksize=3,scale=1,delta=0)\n    img_total = imyoo + img_sobelx + img_sobely    \n    scipy.misc.imsave(\"imyogray_sobelx.jpg\", img_sobelx)\n    scipy.misc.imsave(\"imyogray_sobely.jpg\", img_sobely)\n    scipy.misc.imsave(\"imyogray_sobel.jpg\", img_total )    \n    images = np.array([])\n    images = np.append(images, imyoo)\n    images = np.append(images, img_sobelx)\n    images = np.append(images, img_sobely)\n    images = np.append(images, img_total)    \n    imyo.close()\n\n    return images\n\ndef main():\n\n    \n\n    #kernel w\n    w = np.array(([-10,-10, 0],\n                  [-10, 0, 10], \n                  [ 0, 10, 10]),\n                np.float32)\n\n    #matriz h\n    h = np.array(([10, 20, 0, 30, 30],\n                  [20, 0, 10, 20,  0], \n                  [10, 0, 40, 10, 10],  \n                  [20, 40, 0, 30, 10], \n                  [0, 10, 40, 20, 0]), \n                 np.float32)\n\n    print(\"** Primer ejercicio ** \")\n    cr = correlacion_cruzada(h,w)\n    print(\"Correlacion cruzada:\")\n    print(cr)\n    cv = convolucion(h,np.array(rotar(w,180),np.float32))\n    print(\"Convolucion:\")\n    print(cv)\n    print(\"** Segundo ejercicio ** \")\n    # Vector q\n    q = np.array(([-1, 3, -1]), np.float32)\n    print(\"q:\")\n    # Traspuesta de q = qt\n    qt = q.reshape((-1,1))\n    print(\"qt:\")\n    #Q = qt*q\n    Q= np.outer(q, qt);\n    print(Q)\n\n    crQ = convolucion(h,Q)\n    print(\"Convolucion h * Q:\")\n    print(crQ)\n    crq = convolucion(h, q[None,:])\n    print(\"Convolucion h * q:\")\n    print(crq)\n    crqt = convolucion(crq, qt)\n    print(\"Convolucion (h * q)qt:\")\n    print(crqt)        \n\n    print(\"** Tercer ejercicio ** \")\n    contornos = contornos_sobel('yo.jpg')\n    \n    print(\"** Cuarto ejercicio ** \")\n    vectores_gradientes(\"panda.jpg\")\n           \nif __name__ == '__main__':\n    main()     \n```\n## 3. Counting objects\n\n### Imagen original para las pruebas\n\n![alt text](https://wittline.github.io/Computer-Vision-and-Deep-Learning/Visi%C3%B3n%20Computacional%20y%20Deep%20Learning/Tarea%203/monedas.png)\n\n### Metodología\n![alt text](https://wittline.github.io/Computer-Vision-and-Deep-Learning/Visi%C3%B3n%20Computacional%20y%20Deep%20Learning/Tarea%203/image.png)\n\n### 1. Leer imagen\n```\ndef LeerImagen(l):\n    Imagen = cv2.imread(l)\n    return Imagen, Imagen.copy()\n```\n### 2. Transformar la imagen a escala de grises, ecualizar el histograma y filtrar el ruido\n```\ndef PreprocessImage(i):\n    return cv2.GaussianBlur(cv2.equalizeHist(cv2.cvtColor(i, cv2.COLOR_BGR2GRAY)), (5,5),0)\n```\n\n### 3. Deteccion de bordes usando Canny\n```\ndef DetectarContornos(i, min, max):\n    ImagenBordes = cv2.Canny(i, min, max)\n    contornos,_ = cv2.findContours(ImagenBordes.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\n    return ImagenBordes, contornos\n```\n\n### 4. Conteo de bordes\n```\ndef DibujarContornos(c):\n    global ImagenContornos\n    i = 0\n    for cn in c:    \n        cv2.drawContours(ImagenContornos, cn, -1, (57,255,20),2)    \n        x,y,w,h = cv2.boundingRect(cn)  \n        cv2.putText(ImagenContornos, str(i+1), (x, y-5), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (57, 255, 20), lineType=cv2.LINE_AA)     \n        i=i+1\n    return i\n\n```\n### 4. Resultados\n![alt text](https://wittline.github.io/Computer-Vision-and-Deep-Learning/Visi%C3%B3n%20Computacional%20y%20Deep%20Learning/Tarea%203/resultados.png)\n\n### Código\n```\nimport numpy as np\nimport cv2\nfrom matplotlib import pyplot as plt\n\nImagenContornos= None\n\ndef LeerImagen(l):\n    Imagen = cv2.imread(l)\n    return Imagen, Imagen.copy()\n\ndef PreprocessImage(i):\n    return cv2.GaussianBlur(cv2.equalizeHist(cv2.cvtColor(i, cv2.COLOR_BGR2GRAY)), (5,5),0)\n\ndef DetectarContornos(i, min, max):\n    ImagenBordes = cv2.Canny(i, min, max)\n    contornos,_ = cv2.findContours(ImagenBordes.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\n    return ImagenBordes, contornos\n\ndef DibujarContornos(c):\n    global ImagenContornos\n    i = 0\n    for cn in c:    \n        cv2.drawContours(ImagenContornos, cn, -1, (57,255,20),2)    \n        x,y,w,h = cv2.boundingRect(cn)  \n        cv2.putText(ImagenContornos, str(i+1), (x, y-5), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (57, 255, 20), lineType=cv2.LINE_AA)     \n        i=i+1\n    return i\n\ndef Plotear(t,im,s, n):\n    for i in range(n):\n        plt.subplot(2, 2, i+1)\n        plt.title(t[i])\n        if(s[i]):\n            plt.imshow(im[i], cmap='gray',vmin=0,vmax=255)        \n        else:\n            plt.imshow(cv2.cvtColor(im[i], cv2.COLOR_BGR2RGB))        \n        plt.xticks([])\n        plt.yticks([])\n    plt.show()  \n\ndef ContarMonedas(location):      \n    global ImagenContornos\n    Imagen, ImagenContornos = LeerImagen(location)\n    ImagenGauss = PreprocessImage(Imagen)\n    ImagenBordes,contornos= DetectarContornos(ImagenGauss, 50, 300)\n    i = DibujarContornos(contornos)\n    Titulos = ['Original', 'Gaussiana', 'Bordes de la imagen', 'Imagen Final: ' + str(i) + ' monedas']\n    Imagenes = [Imagen, ImagenGauss, ImagenBordes, ImagenContornos]\n    Types = [0, 1, 0, 0]\n    Plotear(Titulos, Imagenes, Types, 4)\n\n\ndef main():    \n    ContarMonedas('monedas.png')\nif __name__ == '__main__':\n    main()\n\n```   \n\n## 4. Morphological Operations and Geometric Transformations\n\n\n### Imagen para las pruebas\n\n![alt text](https://wittline.github.io/Computer-Vision-and-Deep-Learning/Visi%C3%B3n%20Computacional%20y%20Deep%20Learning/Tarea%204/letras.png)\n![alt text](https://wittline.github.io/Computer-Vision-and-Deep-Learning/Visi%C3%B3n%20Computacional%20y%20Deep%20Learning/Tarea%204/caballo.png)\n![alt text](https://wittline.github.io/Computer-Vision-and-Deep-Learning/Visi%C3%B3n%20Computacional%20y%20Deep%20Learning/Tarea%204/minerva.png)\n\n\n### 1. Obtener un esqueleto\n```\ndef ObtenerEsqueleto(imagename, inverse):      \n    global EE\n    fin = False\n\n    Imagen = Binarize(cv2.GaussianBlur(LeerImagen(imagename), (61,61),0),inverse)[1]\n    \n    #cv2.imshow(\"e\", Imagen)\n    #cv2.waitKey(0)\n    tamaño = np.size(Imagen)\n    esqueleto = np.zeros(Imagen.shape, np.uint8)\n\n    while(not fin):\n        e= cv2.erode(Imagen, EE)\n        d= cv2.dilate(e,EE)\n        r= cv2.subtract(Imagen, d)\n        esqueleto= cv2.bitwise_or(esqueleto, r)\n        Imagen = e.copy() \n\n        if ((tamaño-cv2.countNonZero(Imagen))==tamaño):\n            fin= True\n    return esqueleto\n\n```\n\n### 3. Rotacion de la imagen\n```\n\ndef RotarImagen(imagen, angulo, punto):\n    i = LeerImagen(imagen)\n    tamaño = np.size(i)\n    rotada = np.zeros(i.shape, np.uint8)        \n\n    R = [[math.cos(math.radians(angulo)), -math.sin(math.radians(angulo)), 0], \n         [math.sin(math.radians(angulo)), math.cos(math.radians(angulo)), 0],\n         [0, 0, 1]]\n\n    T = [[1, 0, -punto[0]], \n         [0, 1, -punto[1]],\n         [0, 0,  1]]\n        \n    T_i =   np.linalg.inv(T)        \n    A = np.dot(T_i, R)    \n    A = np.dot(A, T)       \n\n    F = np.zeros(shape=(3,1))               \n    \n    for x in range(0, i.shape[0]):\n        for y in range(0, i.shape[1]):\n            p = [[x],[y],[1]]\n            F = np.dot(A, p).astype(int)                           \n            try:                                \n              rotada[F[[0,1]][0],F[[0,1]][1]] = i[x,y]                         \n            except:\n              error= True                  \n    \n    return rotada\n\n```\n### 4. Resultados\n![alt text](https://wittline.github.io/Computer-Vision-and-Deep-Learning/Visi%C3%B3n%20Computacional%20y%20Deep%20Learning/Tarea%204/resultados.PNG)\n\n### Código\n```\nimport math\nimport numpy as np\nimport cv2\nfrom matplotlib import pyplot as plt\n\nEE = cv2.getStructuringElement(cv2.MORPH_CROSS,(3,3))\n\ndef LeerImagen(l):    \n    return cv2.imread(l,0)\n\ndef Plotear(t,im,s, n):\n    for i in range(n):\n        plt.subplot(1, 3, i+1)\n        plt.title(t[i])\n        if(s[i]):\n            plt.imshow(im[i], cmap='gray',vmin=0,vmax=255)        \n        else:\n            plt.imshow(cv2.cvtColor(im[i], cv2.COLOR_BGR2RGB))        \n        plt.xticks([])\n        plt.yticks([])\n    plt.show()  \n\n\ndef Binarize(i,inverse):\n    t = 0\n    if inverse:\n        t= 1\n    return cv2.threshold(i,200, 255, t)\n    \ndef ObtenerEsqueleto(imagename, inverse):      \n    global EE\n    fin = False\n\n    Imagen = Binarize(cv2.GaussianBlur(LeerImagen(imagename), (61,61),0),inverse)[1]\n    \n    #cv2.imshow(\"e\", Imagen)\n    #cv2.waitKey(0)\n    tamaño = np.size(Imagen)\n    esqueleto = np.zeros(Imagen.shape, np.uint8)\n\n    while(not fin):\n        e= cv2.erode(Imagen, EE)\n        d= cv2.dilate(e,EE)\n        r= cv2.subtract(Imagen, d)\n        esqueleto= cv2.bitwise_or(esqueleto, r)\n        Imagen = e.copy() \n\n        if ((tamaño-cv2.countNonZero(Imagen))==tamaño):\n            fin= True\n    return esqueleto\n\ndef RotarImagen(imagen, angulo, punto):\n    i = LeerImagen(imagen)\n    tamaño = np.size(i)\n    rotada = np.zeros(i.shape, np.uint8)        \n\n    R = [[math.cos(math.radians(angulo)), -math.sin(math.radians(angulo)), 0], \n         [math.sin(math.radians(angulo)), math.cos(math.radians(angulo)), 0],\n         [0, 0, 1]]\n\n    T = [[1, 0, -punto[0]], \n         [0, 1, -punto[1]],\n         [0, 0,  1]]\n        \n    T_i =   np.linalg.inv(T)        \n    A = np.dot(T_i, R)    \n    A = np.dot(A, T)       \n\n    F = np.zeros(shape=(3,1))               \n    \n    for x in range(0, i.shape[0]):\n        for y in range(0, i.shape[1]):\n            p = [[x],[y],[1]]\n            F = np.dot(A, p).astype(int)                           \n            try:                                \n              rotada[F[[0,1]][0],F[[0,1]][1]] = i[x,y]                         \n            except:\n              error= True                  \n    \n    return rotada\n\n                           \ndef main():    \n    Letras= ObtenerEsqueleto('letras.png', False)\n    Caballo= ObtenerEsqueleto('caballo.png', True)\n    punto = [180, 270]\n    Minerva = RotarImagen('minerva.png', 35, punto)\n\n    \n    Titulos = ['Letras esqueleto', \"Caballo esqueleto\", \"Minerva\"]\n    Imagenes = [Letras, Caballo, Minerva ]\n    Types = [1, 1, 1]\n    Plotear(Titulos, Imagenes, Types, 3)\n\nif __name__ == '__main__':\n    main()\n```  \n\n## 5. Projective Transformation\n\n### Imagen para las pruebas\n\n![alt text](https://wittline.github.io/Computer-Vision-and-Deep-Learning/Visi%C3%B3n%20Computacional%20y%20Deep%20Learning/Tarea%205/mural.jpg)\n\n### Seleccionar primero los 4 puntos de la imagen origen\n![alt text](https://wittline.github.io/Computer-Vision-and-Deep-Learning/Visi%C3%B3n%20Computacional%20y%20Deep%20Learning/Tarea%205/Image_source_points.PNG)\n### Seleccionar despues los 4 puntos de la imagen destino\n![alt text](https://wittline.github.io/Computer-Vision-and-Deep-Learning/Visi%C3%B3n%20Computacional%20y%20Deep%20Learning/Tarea%205/Image_final_points.png)\n### 4. Resultados\n![alt text](https://wittline.github.io/Computer-Vision-and-Deep-Learning/Visión%20Computacional%20y%20Deep%20Learning/Tarea%205/ImagenProyetivaMejorada.jpg)\n\n### Código\n```\nimport numpy as np\nfrom scipy import misc\nimport cv2\nfrom matplotlib import pyplot as plt\nfrom PIL import Image\n\ncolor_point = (0,0,255)\n\ndef mouse_handler(event, x, y, flags, data) :    \n    if event == cv2.EVENT_LBUTTONDOWN :\n        cv2.circle(data['im'], (x,y),3, color_point, 5, 16);\n        cv2.imshow(\"Image\", data['im']);\n        if len(data['points']) \u003c 4 :\n            data['points'].append([x,y])\n\ndef getXYMouse(im, color):\n\n    global color_point\n    color_point = color\n        \n    data = {}\n    data['im'] = im.copy()\n    data['points'] = []\n        \n    cv2.imshow(\"Image\",im)\n    cv2.setMouseCallback(\"Image\", mouse_handler, data)\n    cv2.waitKey(0)\n    \n    points = np.vstack(data['points']).astype(int)\n    \n    return points\n\ndef LeerImagen(l):    \n    return cv2.imread(l)\n\ndef TransformacionProyectiva(i, o, d):\n    im = misc.imread(i)\n    \n    if(len(o)\u003c1 or len(d)\u003c1):\n        cv2.imshow(\"Image\", im)\n        o = obtenerCoordenada(im,(0,0,255))\n        print(o)\n        d = obtenerCoordenada(im,(255,0,0))\n        print(d)\n\n    MAT = np.zeros((8,9))\n    for ite in range(4):\n        MAT[ite*2,:] = [ o[ite][1], o[ite][0], 1, \n                    0, 0, 0, \n                    -d[ite][1]*o[ite][1], -d[ite][1]*o[ite][0], -d[ite][1] ]\n        MAT[ite*2+1,:] = [0, 0, 0, \n                      o[ite][1], o[ite][0], 1, \n                      -d[ite][0]*o[ite][1], -d[ite][0]*o[ite][0], -d[ite][0] ]\n\n    mx=[];\n    my=[];    \n    [Z,Y,X]=np.linalg.svd(MAT)\n    mat = X[-1,:]\n    matH = np.reshape(mat,(3,3))\n\n    txy = np.array([[1],[1],[1]])\n    txytemporal = np.dot(matH,txy)\n    mx.append(txytemporal[0]/txytemporal[2])\n    my.append(txytemporal[1]/txytemporal[2])\n\n    txy = np.array([[im.shape[1]],[1],[1]])\n    txytemporal = np.dot(matH,txy)\n    mx.append(txytemporal[0]/txytemporal[2])\n    my.append(txytemporal[1]/txytemporal[2])\n\n    txy = np.array([[1],[im.shape[0]],[1]])\n    txytemporal = np.dot(matH,txy)\n    mx.append(txytemporal[0]/txytemporal[2])\n    my.append(txytemporal[1]/txytemporal[2])\n\n    txy = np.array([[im.shape[1]],[im.shape[0]],[1]])\n    txytemporal = np.dot(matH,txy)\n    mx.append(txytemporal[0]/txytemporal[2])\n    my.append(txytemporal[1]/txytemporal[2])\n\n    XX1 = int(np.min(mx))\n    XX2 = int(np.max(mx))\n    YY1 = int(np.min(my))\n    YY2 = int(np.max(my))\n    \n    proyectiva = np.zeros((int(YY2-YY1),int(XX2-XX1),3))\n\n    imX=im.shape[0]\n    imY=im.shape[1]\n\n    for i in range(imX):\n            for j in range(imY):\n                    txy = np.array([[j],[i],[1]])\n                    txytemporal = np.dot(matH,txy)\n                    px=int(txytemporal[0]/txytemporal[2])-XX1\n                    py=int(txytemporal[1]/txytemporal[2])-YY1\n\n                    if (px\u003e0 and py\u003e0 and py\u003cYY2-YY1 and px\u003cXX2-XX1):\n                            proyectiva[py,px,:]=im[i,j,:]\n    \n    return proyectiva, matH, im, (XX1, YY1)\n\ndef obtenerCoordenada(i,c):    \n    coordenadasPuntos = getXYMouse(i, color= c);\n    punto= []; \n    punto.append((coordenadasPuntos[0,1], coordenadasPuntos[0,0]))\n    punto.append((coordenadasPuntos[1,1], coordenadasPuntos[1,0]))\n    punto.append((coordenadasPuntos[2,1], coordenadasPuntos[2,0] ))\n    punto.append((coordenadasPuntos[3,1], coordenadasPuntos[3,0]))\n    return punto;  \n    \n\ndef Interpolar(im,imo, h, lc):\n    print(lc[0])\n    imX=im.shape[0]\n    imY=im.shape[1]\n    imxx=imo.shape[0]\n    imyy=imo.shape[1]    \n    h_inversa = np.linalg.inv(h)\n\n    for i in range(imX):\n            for j in range(imY):\n                    if sum(im[i,j,:])==0:\n                            txy = np.array([[j+lc[0]],[i+lc[1]],[1]])\n                            t = np.dot(h_inversa,txy)\n                            px=int(t[0]/t[2])\n                            py=int(t[1]/t[2])\n\n                            if (px\u003e0 and py\u003e0 and px\u003cimyy and py\u003cimxx):\n                                    im[i,j,:] = imo[py,px,:]\n   \n    return im\n\n\nif __name__ == '__main__':\n    origen= []; \n    destino= [];\n    #origen = [(220,110),(30,500),\n    #          (375,95),(325,500)]\n    #destino = [(150,200),(150,700),\n    #        (300,200),(300,700)]\n\n    ImagenProyectiva, H, imo, llc = TransformacionProyectiva(\"mural.jpg\", origen, destino)\n    ImagenProyetivaMejorada = Interpolar(ImagenProyectiva, imo, H, llc)\n    misc.imsave(\"ImagenProyetivaMejorada.jpg\",ImagenProyetivaMejorada)\n\n```\n\n\n## 5. Deep learning\n\n## Execution requirements\nVisual studio 2017\nPython 3.6\nOpenCv\nNumpy\nPIL\nmatplotlib\nscipy\n\n## Contributing and Feedback\nAny ideas or feedback about this research?. Help me to improve it.\n\n## Authors\n- Created by \u003ca href=\"https://www.linkedin.com/in/ramsescoraspe\"\u003e\u003cstrong\u003eRamses Alexander Coraspe Valdez\u003c/strong\u003e\u003c/a\u003e\n- Created on April, 2019\n\n## License\nThis project is licensed under the terms of the MIT license.\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fwittline%2Fcomputer-vision-and-deep-learning","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fwittline%2Fcomputer-vision-and-deep-learning","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fwittline%2Fcomputer-vision-and-deep-learning/lists"}