TAREA

November 11, 2020

Aaron Sanitago Pedraza Cardenas

Calibracion #Punto 1-2
[ ]: from google.colab.patches import cv2_imshow
#!/usr/bin/env python3
# -*- coding: utf-8 -*-

import numpy as np
import cv2 as cv2
import glob
DIMX=9
DIMY=6
square_size=25

# termination criteria
criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 30, 0.001)

# preparar puntos de objeto, como (0,0,0), (1,0,0), (2,0,0) ....,(6,5,0)

objp = np.zeros((DIMY*DIMX,3), np.float32)

objp[:,:2] = np.mgrid[0:DIMX,0:DIMY].T.reshape(-1,2)
objp *= square_size
print("se crea los puntos origen note la escala que es 1 en este caso aca se␣
,→multiplica por el tamanio del rectangulo en milimetros, metros, centimetros␣

,→o bananos")

print(objp)
# Matrices para almacenar puntos de objeto y puntos de imagen de todas las␣
,→imágenes.

objpoints = [] # Punto 3D en el espacio del mundo real.

imgpoints = [] # 2d puntos en el plano de la imagen.

images = glob.glob('/content/images/*.jpg')

for fname in images:

img = cv2.imread(fname)
gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)

# Encuentra las esquinas del tablero de ajedrez

1
 ret, corners = cv2.findChessboardCorners(gray, (DIMX,DIMY),None)

# Si lo encuentra, agregue puntos de objeto, puntos de imagen (después de␣

,→refinarlos)

if ret == True:
objpoints.append(objp)

corners2 = cv2.cornerSubPix(gray,corners,(11,11),(-1,-1),criteria)
imgpoints.append(corners2)

# Dibujar y mostrar las esquinas

img = cv2.drawChessboardCorners(img, (DIMX,DIMY), corners2,ret)
cv2_imshow(img)
cv2.waitKey(3 )

cv2.destroyAllWindows()
cv2.waitKey(1)
#print(imgpoints)

ret, mtx, dist, rvecs, tvecs = cv2.calibrateCamera(objpoints, imgpoints, gray.

,→shape[::-1],None,None)

print(mtx)
print(type(mtx))
print(dist)
print(type(dist))
# termina la calibración

# Inicia etapa de usuario

img = cv2.imread('/content/images/15.jpg')
h, w = img.shape[:2]
newcameramtx, roi=cv2.getOptimalNewCameraMatrix(mtx,dist,(w,h),0,(w,h))
# no distorsionar
dst = cv2.undistort(img, mtx, dist, None, newcameramtx)

# recortar la imagen
x,y,w,h = roi
dst = dst[y:y+h, x:x+w]
cv2.imwrite('calibresult1.png',dst)

# no distorsionar
mapx,mapy = cv2.initUndistortRectifyMap(mtx,dist,None,newcameramtx,(w,h),5)

2
dst = cv2.remap(img,mapx,mapy,cv2.INTER_LINEAR)

# recortar la imagen
x,y,w,h = roi
#dst = dst[y:y+h, x:x+w]
cv2.imwrite('calibresult2.png',dst)
mean_error = 0
for i in range(len(objpoints)):
imgpoints2, _ = cv2.projectPoints(objpoints[i], rvecs[i], tvecs[i], mtx,␣
,→dist)

error = cv2.norm(imgpoints[i],imgpoints2, cv2.NORM_L2)/len(imgpoints2)

mean_error += error

print ("total error: ", mean_error/len(objpoints))

print ("matriz inversa ")

mtx_inv=np.linalg.inv(mtx)

se crea los puntos origen note la escala que es 1 en este caso aca se multiplica
por el tamanio del rectangulo en milimetros, metros, centimetros o bananos
[[ 0. 0. 0.]
[ 25. 0. 0.]
[ 50. 0. 0.]
[ 75. 0. 0.]
[100. 0. 0.]
[125. 0. 0.]
[150. 0. 0.]
[175. 0. 0.]
[200. 0. 0.]
[ 0. 25. 0.]
[ 25. 25. 0.]
[ 50. 25. 0.]
[ 75. 25. 0.]
[100. 25. 0.]
[125. 25. 0.]
[150. 25. 0.]
[175. 25. 0.]
[200. 25. 0.]
[ 0. 50. 0.]
[ 25. 50. 0.]
[ 50. 50. 0.]
[ 75. 50. 0.]
[100. 50. 0.]
[125. 50. 0.]
[150. 50. 0.]
[175. 50. 0.]
[200. 50. 0.]

3
[ 0. 75. 0.]
[ 25. 75. 0.]
[ 50. 75. 0.]
[ 75. 75. 0.]
[100. 75. 0.]
[125. 75. 0.]
[150. 75. 0.]
[175. 75. 0.]
[200. 75. 0.]
[ 0. 100. 0.]
[ 25. 100. 0.]
[ 50. 100. 0.]
[ 75. 100. 0.]
[100. 100. 0.]
[125. 100. 0.]
[150. 100. 0.]
[175. 100. 0.]
[200. 100. 0.]
[ 0. 125. 0.]
[ 25. 125. 0.]
[ 50. 125. 0.]
[ 75. 125. 0.]
[100. 125. 0.]
[125. 125. 0.]
[150. 125. 0.]
[175. 125. 0.]
[200. 125. 0.]]

4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 [[967.74391241 0. 464.42978024]
[ 0. 968.10983863 349.95350063]
[ 0. 0. 1. ]]
<class 'numpy.ndarray'>
[[-2.49145534e-01 2.07985201e+00 -9.84672028e-03 -1.03043826e-03
-5.66350004e+00]]
<class 'numpy.ndarray'>
total error: 0.04244428419510854
matriz inversa

[ ]: print("La matriz de la camara es ",mtx)

print(type(mtx))
print("el Dist es:",dist)
print(type(dist))

La matriz de la camara es [[967.74391241 0. 464.42978024]

[ 0. 968.10983863 349.95350063]
[ 0. 0. 1. ]]
<class 'numpy.ndarray'>
el Dist es: [[-2.49145534e-01 2.07985201e+00 -9.84672028e-03 -1.03043826e-03

20
 -5.66350004e+00]]
<class 'numpy.ndarray'>

[ ]: print("total error: ", mean_error/len(objpoints))

mtx_inv=np.linalg.inv(mtx)
print("matriz inversa ",mtx_inv)

total error: 0.04244428419510854

matriz inversa [[ 0.00103333 0. -0.47990979]
[ 0. 0.00103294 -0.36148119]
[ 0. 0. 1. ]]

1 Punto 3
[ ]: import numpy as np
import cv2

DIM = (1280,720)
K = mtx
#np.array([[967.743914, 0.0, 464.4242978016], [0.0, 968.10984015, 349.
,→953550106], [0.0, 0.0, 1.0]])

D = np.array([[-2.49145540e-01], [2.07985205e+00], [-9.84672040e-03], [-5.

,→66350014e+00]])

cap = cv2.VideoCapture(0)

while True:
flag, img = cap.read()
try:
map1, map2 = cv2.fisheye.initUndistortRectifyMap(K, D, np.eye(3), K,␣
,→DIM, cv2.CV_16SC2)

calibrated = cv2.remap(img, map1, map2, interpolation=cv2.INTER_LINEAR,␣

,→borderMode=cv2.BORDER_CONSTANT)

cv2.imshow('result', calibrated)
except:
cap.release()
raise

k = cv2.waitKey(30)
if k == 27:
break
cap.release()
cv2.destroyAllWindows()
El anterior codigo permite realizar una aplicación que des-distorsione un streaming de video,
donde los resultados son los podemos observar a continuación:

21
[ ]: import cv2
from google.colab.patches import cv2_imshow
img = cv2.imread('/content/1.png')
img2 = cv2.imread('/content/2.png')
print('Resultado 1')
cv2_imshow(img)

Resultado 1

[ ]: print('Resultado 2')
cv2_imshow(img2)

Resultado 2

22
 Punto 4 #Realidad aumentada
[ ]: import numpy as np
import cv2
import glob

cap = cv2.VideoCapture(0)

images = glob.glob('/Users/aaronsantiagopedrazacardenas/Desktop/Augmented␣
,→Reality/images/*.jpg') #todas las imágenes jpg de la carpeta se pueden␣

,→mostrar

currentImage = 1

replaceImg=cv2.imread(images[currentImage])
rows,cols,ch = replaceImg.shape
pts1 = np.float32([[0,0],[cols,0],[cols,rows],[0,rows]]) #estos puntos son␣
,→necesarios para la transformación

zoomLevel = 0 #cuando el nivel de zoom es positivo, se acerca, cuando es␣

,→negativo, se aleja

processing = True #variable booleana que se utiliza para deshabilitar el␣

,→procesamiento de imágenes

maskThreshold=10

while(True):
# Captura fotograma a fotograma
ret, img = cap.read()

23
 # Nuestras operaciones en el marco vienen aquí
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
#Esta función se usa para detectar las esquinas del tablero de ajedrez, 9x6␣
,→es el número de esquinas a encontrar

ret, corners = cv2.findChessboardCorners(gray, (9,6),None)

# Si lo encuentra, haga el procesamiento

if ret == True and processing:
#pts2 se utiliza para definir la transformación de perspectiva
pts2 = np.
,→float32([corners[0,0],corners[8,0],corners[len(corners)-1,0],corners[len(corners)-9,0]])

#calcular la matriz de transformación

M = cv2.getPerspectiveTransform(pts1,pts2)
rows,cols,ch = img.shape
#hacer que la perspectiva cambie en una imagen del tamaño de la entrada␣
,→de la cámara

dst = cv2.warpPerspective(replaceImg,M,(cols,rows))
#Se crea una máscara para agregar las dos imágenes.
#El umbral de máscara es una variable porque permite restar el fondo␣
,→negro de diferentes imágenes.

ret, mask = cv2.threshold(cv2.cvtColor(dst, cv2.

,→COLOR_BGR2GRAY),maskThreshold, 1, cv2.THRESH_BINARY_INV)

#Erosionar y dilatar se utilizan para eliminar el ruido.

mask = cv2.erode(mask,(3,3))
mask = cv2.dilate(mask,(3,3))
#Las dos imágenes se agregan usando la máscara
for c in range(0,3):
img[:, :, c] = dst[:,:,c]*(1-mask[:,:]) + img[:,:,c]*mask[:,:]

#finalmente se presenta el resultado

cv2.imshow('img',img)

#Wait for the key

key = cv2.waitKey(1)

#decidir la acción en función del valor clave (salir, hacer zoom, cambiar␣
,→la imagen)

if key == ord('q'): # Salir

print('Quit')
break
if key == ord('p'): # procesar
processing = not processing
if processing:
print('Activated image processing')
else:
print('Desactivated image processing')

24
 if key == ord('z'): # + aumentar zoom
zoomLevel=zoomLevel+0.05
rows,cols,ch = replaceImg.shape
pts1 = np.float32([[0,0],[cols,0],[cols,rows],[0,rows]])
pts1 = pts1 + np.
,→float32([[zoomLevel*cols,zoomLevel*rows],[-zoomLevel*cols,zoomLevel*rows],[-zoomLevel*cols,-

print('Zoom in')
if key == ord('x'): # - disminuir zoom
zoomLevel=zoomLevel-0.05
rows,cols,ch = replaceImg.shape
pts1 = np.float32([[0,0],[cols,0],[cols,rows],[0,rows]])
pts1 = pts1 + np.
,→float32([[zoomLevel*cols,zoomLevel*rows],[-zoomLevel*cols,zoomLevel*rows],[-zoomLevel*cols,-

print ('Zoom out')

if key == ord('c'): # -> imagen siguiente
if currentImage<len(images)-1:
currentImage=currentImage+1
replaceImg=cv2.imread(images[currentImage])
rows,cols,ch = replaceImg.shape
pts1 = np.float32([[0,0],[cols,0],[cols,rows],[0,rows]])
pts1 = pts1 + np.
,→float32([[zoomLevel*cols,zoomLevel*rows],[-zoomLevel*cols,zoomLevel*rows],[-zoomLevel*cols,-

print ('Next image')

else:
print ('No more images on the right')
if key == ord('v'): # <- imagen anterior
if currentImage>0:
currentImage=currentImage-1
replaceImg=cv2.imread(images[currentImage])
rows,cols,ch = replaceImg.shape
pts1 = np.float32([[0,0],[cols,0],[cols,rows],[0,rows]])
pts1 = pts1 + np.
,→float32([[zoomLevel*cols,zoomLevel*rows],[-zoomLevel*cols,zoomLevel*rows],[-zoomLevel*cols,-

print ('Previous image')

else:
print ('No more images on the left')

if key == ord('b'): # aumentar el threshold

if maskThreshold<255:
maskThreshold=maskThreshold+1
print ('Increase Mask Threshold')
else:
print ('Mask Threshold at the maximun value')
if key == ord('n'): # disminuir el threshold
if maskThreshold>0:
maskThreshold=maskThreshold-1

25
 print ('Decrease Mask Threshold')
else:
print ('Mask Threshold at the minimun value')

# Cuando todo esté hecho, suelta la captura.

cap.release()
cv2.destroyAllWindows()

Increase Mask Threshold

Increase Mask Threshold
Previous image
No more images on the left
No more images on the left
Increase Mask Threshold
Next image
Next image
Zoom out
Zoom out
Zoom out
Zoom out
Zoom in
Zoom in
Zoom in
Zoom in
Zoom in
Zoom in
Zoom in
Zoom in
Zoom in
Zoom in
Zoom in
Zoom out
Zoom out
Zoom in
Zoom in
Zoom in
Zoom in
Zoom out
Zoom out
Next image
Next image
Next image
Next image
No more images on the right
No more images on the right
No more images on the right
Quit

26
[ ]: import cv2
from google.colab.patches import cv2_imshow
img2 = cv2.imread('/content/iron-zoom.png')

img4 = cv2.imread('/content/logo.png')
img5 = cv2.imread('/content/playa.png')
print('Casco Iron man con zoom')
cv2_imshow(img2)

Casco Iron man con zoom

[ ]: img3 = cv2.imread('/content/ironman.png')
print('Casco Iron man sin zoom')
cv2_imshow(img3)

Casco Iron man sin zoom

27
[ ]: print('Logo Opencv')
cv2_imshow(img4)

Logo Opencv

28
[ ]: print('Playa')
cv2_imshow(img5)

Playa

29