Visión artificial, OpenCV y Python

¿Qué es OpenCV?

OpenCV es una librería de visión por computador de código abierto, disponible

en http://sourceforge.net/projects/opencvlibrary/
La librería está escrita en los lenguajes C y C++ y es compatible con Linux,
Windows y Mac OS X. Cuenta con un desarrollo activo en interfaces para Python,
Ruby, Matlab y otros lenguajes.

OpenCV ha sido diseñado para ser eficiente en cuanto a gasto de recursos

computacionales y con un enfoque hacia las aplicaciones de tiempo real.
OpenCV está escrito y optimizado en C y puede tomar ventaja de los
procesadores con múltiples núcleos.

Si necesitas mayor optimización en arquitecturas Intel, puedes adquirir las

librerías integradas IPP de Intel (https://software.intel.com/es-es/intel-ipp)

Uno de los objetivos de OpenCV es proveer una infraestructura de visión por

computador fácil de utilizar que ayuda a los programadores a desarrollar
aplicaciones ‘sofisticadas’ de CV (Computer Vision) rápidamente.

La librería OpenCV contiene aproximadamente 500 funciones que abarcan

muchas áreas de CV, incluyendo inspección de productos de fábricas, escaneo
médico, seguridad, interfaces de usuario, calibración de cámaras, robótica…etc,
porque la visión por computador y el aprendizaje automático van de la mano.
OpenCV también tiene una completa librería de uso general de aprendizaje
automático (MLL o Machine Learning Library), la cual es muy útil para cualquier
problema de aprendizaje automático. Esta sublibrería está especializada en el
reconocimiento estadístico de patrones y clustering.

En junio de 2015 se produjo un hito importante, por fin la versión 3.0 estaba
disponible. Si hechos números, en 16 años (de 1999 a 2015) solo ha habido 3
versiones. Esto es debido a que desde un principio esta biblioteca ha sido
robusta y muy eficiente.
En esta última versión cabe destacar que por fin es compatible con la última
versión de Python, la 3.0. Esto permite aprovechar todas las ventajas de la última
versión de este lenguaje.

Quizás sea la biblioteca de visión artificial más importante y más usada del
mundo. Es utilizada por universidades, empresas y gente del movimiento
Maker para dar rienda suelta a su imaginación al tratarse de un software libre.

Módulos de OpenCV:

OpenCV tiene una estructura modular. Los módulos principales de OpenCV los
listo debajo.

Core:

Este es el módulo básico de OpenCV. Incluye las estructuras de datos básicas y

las funciones básicas de procesamiento de imágenes. Este módulo también es
usado por otros módulos como highgui.

Highhui:

Este módulo provee interfaz de usuario, códecs de imagen y vídeo y capacidad

para capturar imágenes y vídeo, además de otras capacidades como la de
capturar eventos del ratón…etc.

Si necesitas capacidades de UI (User Interface) más avanzadas debes usar

frameworks tales como Qt, WinForms…etc.

Imgproc:

Este módulo incluye algoritmos básicos de procesado de imágenes, incluyendo

filtrado de imágenes, transformado de imágenes…etc.

Video:

Este módulo de análisis de vídeo incluye algoritmos de seguimiento de objetos,

entre otros…

objdetect:
Incluye algoritmos de detección y reconocimiento de objetos para objetos
estándar.

A continuación, un código para capturar imágenes de una cámara, utilizando la

librería OpenCV.

#include “cv.h”
#include “highgui.h”
int main(int argc,char** argv)
{
IplImage *frame;
// Crear dispositivo de captura
// El 0 quiere decir que usarás el dispositivo con índice 0
CvCapture *capture = cvCaptureFromCAM(0);
//Se necesita highgui.h
cvNamedWindow(“capture”,CV_WINDOW_AUTOSIZE);
while(1) //Bucle infinito
{
//Consulta para el marco de la cámara
frame = cvQueryFrame(capture);
//Mostrar la imagen capturada
cvShowImage(“capture”,frame);
char ch = cvWaitKey(25); //Esperar 25 ms para presionar la tecla
if(ch==27) break; //Tecla Escape pulsada
}
//Liberar la memoria ocupada por las imágenes
cvReleaseImage(&frame);
cvDestroyWindow(“capture”);
return 0;
}

Pasos para instalar OpenCV y Python

¿por qué Python?, este lenguaje es muy sencillo de usar, favoreciendo el código
legible gracias a su sintaxis sencilla.

Debemos ser conscientes que el lenguaje nativo de OpenCV es C/C++, con la

complejidad que ello conlleva si queremos utilizar esta biblioteca en nuestros
proyectos.

Python es que es un lenguaje fácilmente portable a otras plataformas entre las

que se incluye Raspberry Pi.
La decisión de empezar por Windows es muy sencilla. Es el sistema operativo
más utilizado del mundo.

Lo primero que debemos saber antes de empezar con los pasos a seguir para
instalar OpenCV y Python, es que esto ya no es una tecnología plug and play.
Estamos acostumbrados a hablar de Processing, Arduino, Scratch y las
tecnologías fáciles de usar. Con OpenCV la cosa se complica, sobre todo a la
hora de preparar el sistema. La instalación consta de 3 pasos.

Paso 1: Instalación de Python 3.0 con paquetes adicionales

Ya no solo tenemos que instalar el lenguaje de programación, para utilizar

OpenCV necesitamos instalar, además, ciertos paquetes de Python que nos
ayuda cuando desarrollemos aplicaciones en visión artificial.

NumPy: es una biblioteca de código abierto que da soporte a vectores y arrays

para Python.

SciPy: es una biblioteca de código abierto que contiene herramientas y

algoritmos matemáticos para Python.

Matplotlib: es una biblioteca de código abierto para la generación de gráficos a

partir de vectores y arrays.
Pip: gestor de paquetes para Python.

Se puede instalar cada paquete por separado, pero existen plataformas

como Anaconda donde viene todo integrado en un único instalador. Te
recomiendo que lo hagas con este tipo de plataformas.

Paso 2: Instalar OpenCV para Python 3

Quizás este paso pudiera ser el más complicado, pero gracias al gestor de
paquetes Pip se hace muy sencillo. Solo debemos de descargar la versión para
nuestro sistema operativo en formato whl y luego instalarlo. Es muy simple
gracias al gestor de paquetes.

Paso 3: Instalar el entorno de desarrollo (Opcional)

Este paso es opcional, podemos utilizar el bloc de notas de Windows para

programar en Python. o Sublime Text 3 y el plugin Anaconda, que convierte este
IDE en un entorno de desarrollo optimizado para Python con todas sus
funcionalidades.

Y estos serían los 3 pasos recomendados para configurar el sistema. Puedes ver
cómo instalar OpenCV paso a paso con imágenes y el código necesario para
que todo funcione correctamente.

Qué es Anaconda Python

Para instalar Python y todos los paquetes que necesita OpenCV lo puedes hacer
de diferentes maneras. La primera sería ir uno por uno descargando e instalando.
Es un buen ejercicio, pero puede llevarnos mucho tiempo y darnos muchos
dolores de cabeza.

El sistema operativo, las diferentes versiones, los diferentes procesadores y no

perder de vista todo aquello que pueda generar algún tipo de error en la
instalación.

Sin embargo, existe otro método bastante más sencillo, utilizando Anaconda. Se
trata de una distribución de Python destinado a procesamiento de datos masivos,
análisis predictivo y programación científica que simplifica la gestión de
paquetes.

Y no solo eso, además es de código abierto.

Anaconda es el mejor punto de partida para instalar OpenCV y empezar lo más

rápido posible a desarrollar tus proyectos. ¿Por qué perder el tiempo en
instalaciones complejas si lo que queremos es programar?

Instalar Python con Anaconda

Vamos a comenzar instalando la distribución de Python Anaconda. Accede a

la web oficial y descarga Anaconda.

Existen diferentes versiones para los diferentes sistemas operativos Windows,

Mac y Linux. Descarga y sigue las instrucciones para instalar el que más te
convenga.
Una vez descargado ejecuta el instalador. Las siguientes ventanas dependerán
del sistema operativo. En mi caso estoy utilizando Windows 10.
Con estos pasos ya tendrías instalado Python y los paquetes que vas a necesitar para
instalar OpenCV. Para comprobarlo abre una línea de comandos y escribe lo siguiente

1 python -V

Debes tener un resultado algo parecido a esto

Te informa de que tienes instalada la versión 3.6.0 de Python y la 4.3.1 de
Anaconda de 64-bit.

Gestor de paquetes Pip

Además de instalar los paquetes necesarios para Python y OpenCV, Anaconda

instala el gestor de paquetes Pip. Es una herramienta que te permitirá instalar
paquetes adicionales y actualizar los que ya están instalados de una forma muy
sencilla.

Nos hará falta más adelante para instalar OpenCV. Para comprobar que está todo
correctamente instalado abre una línea de comandos y ejecuta lo siguiente

1 pip -V

Obtendrás un resultado parecido a esto

Si quieres comprobar si existe una versión nueva del gestor de paquetes Pip, ejecuta el
siguiente comando

1 python -m pip install -U pip

Si tu versión del gestor de paquetes Pip no está actualizado descargará la nueva

versión y lo actualizará. En caso contrario te mostrará un mensaje como este.
Ahora ya tenemos todo preparado para comenzar a instalar OpenCV.

Instalar OpenCV para Python 3 en Windows

OpenCV es una librería para visión artificial de código abierto y que está
disponible para muchos lenguajes de programación. Entre ellos se encuentra
Python. Desde la última versión, OpenCV 3, esta librería permite trabajar con
Python 3.

Esto aporta varias ventajas, pero sobre todo, nos permite utilizar las últimas
funcionalidades del lenguaje Python.

Vamos a hacerlo por partes así no te perderás en ningún momento.

#1 Descargar archivo whl

Accede a esta web y descarga los binarios que están en el archivo con extensión
.whl. Cuando abres la página aparecen diferentes archivos y tendrás que elegir
el más adecuado para tu sistema.
Según van surgiendo nuevas versiones de OpenCV y Python, estos archivos se
van actualizando. El mismo día que escribo este artículo la última versión de
OpenCV es la 3.2 y de Python es la 3.6.

Por lo tanto, es recomendable descargar el archivo para estas versiones.

Además, deberás elegir entre versión 32-bit (win32) o de 64-bit (amd64).
Descarga además el archivo que ponga +contrib. Esto indica que instalará
paquetes adicionales para hacer ciertos algoritmos.

#2 Instalar el archivo. whl con Pip

Es importante recordar dónde está el archivo que has descargado en el paso

anterior. Ahora necesitamos acceder a través de la línea de comandos e
instalarlo. Ejecuta el siguiente comando

pip install "d:\opencv\opencv_python-3.2.0+contrib-cp36-cp36m-win_amd64.whl"

Sustituye la ruta entre comillas por la ruta donde hayas descargado el archivo.
Una vez que lo tengas escrito pulsa enter. Te deberá aparecer un mensaje como
el de la siguiente imagen donde informa que se ha instalado correctamente
OpenCV 3.2.0+contrib
#3 Probando la instalación de OpenCV

Instalar OpenCV puede ser una tarea bastante compleja pero como has podido
comprobar, en unos sencillos pasos ya lo tenemos todo preparado. Para
asegurarnos de que todo está correctamente instalado vamos a crear un
pequeño programa.

Copia y pega el siguiente código en el bloc de notas u otro editor

import cv2

# Cargamos la imagen del

disco duro

imagen =
cv2.imread("logo.jpg")

cv2.imshow("prueba", imagen)

cv2.waitKey(0)
Guarda el archivo con el nombre prueba-opencv.py. Ahora descarga la siguiente
imagen y la guardas en la misma carpeta donde has guardado el archivo anterior.

Abre una línea de comandos y vas a la carpeta donde tienes el archivo prueba-
opencv.py y la imagen. Ejecuta el siguiente comando

python prueba-opencv.py

Si todo ha ido bien te aparecerá la imagen en una ventana. Esto indica que
OpenCV se ha instalado correctamente.
Y con esto ya habríamos terminado de instalar OpenCV con Python en nuestro
Windows. Ahora vamos a ver cómo instalar un paquete para Sublime Text que
nos permite programar con Python y OpenCV.

Instalar paquete Python Anaconda para Sublime Text

Sublime Text es uno de mis IDEs favoritos. Lo utilizo para programar webs,
Python e incluso se puede utilizar para programar Arduino. Si quieres utilizarlo
para programar con OpenCV necesitarás tener instalado el paquete Python
Anaconda.

#1 Instalar Sublime Text 3

Lo primero es descargar el IDE. Lo puedes descargar de la web oficial. Es

importante que instales la versión 3. Es un instalador muy sencillo así que lo
descargas y lo ejecutas y listo.

#2 Activar gestor de paquete en Sublime Text

Este IDE tiene un gestor de paquete parecido al que hemos visto con Anaconda,
Pip. Por defecto no viene instalado así que tendrás que instalarlo manualmente.

Abre la consola desde View/Show Console

Esto abre la consola. Copia el siguiente código en la consola y pulsa Enter.

import urllib.request,os,hashlib; h = 'df21e130d211cfc94d9b0905775a7c0f' +

'1e3d39e33b79698005270310898eea76'; pf = 'Package Control.sublime-
package'; ipp = sublime.installed_packages_path(); urllib.request.install_opener(
urllib.request.build_opener( urllib.request.ProxyHandler()) ); by =
urllib.request.urlopen( 'http://packagecontrol.io/' + pf.replace(' ', '%20')).read(); dh
= hashlib.sha256(by).hexdigest(); print('Error validating download (got %s
instead of %s), please try manual install' % (dh, h)) if dh != h else
open(os.path.join( ipp, pf), 'wb' ).write(by)
Con este paso ya tenemos instalado el gestor de paquetes. Si quieres ocultar la
consola tendrás una opción en el menú View/Hide Console.
#3 Instalar el paquete Python Anaconda

Por último, vamos a instalar el paquete Python Anaconda a través del gestor de
paquetes. Accede al menú Preferences/Package Control. Se abrirá un nuevo
menú. Busca Package Control: Install Package y lo seleccionas.

Ahora en el cuadro de texto que aparece buscas Anaconda y te saldrá un

paquete donde pone solo Anaconda. Ese es el que tienes que instalar.
Y con esto hemos finalizado la instalación del IDE con el que vamos a programar
en Python. Como ves, instalar OpenCV no solo se ciñe al propio software,
también tenemos que instalar el IDE y el lenguaje de programación con el que
queremos programar.

Ahora bien, que ya tenemos todo preparado para empezar a usar la visión
artificial en nuestro pc podemos empezar explicando el código

Numpy

Numpy es la biblioteca central para computación científica en

Python. Proporciona un objeto de matriz multidimensional de alto rendimiento y
herramientas para trabajar con estas matrices. Si ya está familiarizado con
MATLAB, puede encontrar este tutorial útil para comenzar con Numpy.

Arrays

Una matriz numpy es una cuadrícula de valores, todos del mismo tipo, y está
indexada por una tupla de enteros no negativos. El número de dimensiones es
el rango de la matriz; la forma de una matriz es una tupla de enteros que da el
tamaño de la matriz a lo largo de cada dimensión.

Podemos inicializar matrices numpy desde listas anidadas de Python y acceder

a elementos mediante corchetes:
import numpy as np

a = np.array([1, 2, 3]) # Create a rank 1 array

print(type(a)) # Prints "<class 'numpy.ndarray'>"
print(a.shape) # Prints "(3,)"
print(a[0], a[1], a[2]) # Prints "1 2 3"
a[0] = 5 # Change an element of the array
print(a) # Prints "[5, 2, 3]"

b = np.array([[1,2,3],[4,5,6]]) # Create a rank 2 array

print(b.shape) # Prints "(2, 3)"
print(b[0, 0], b[0, 1], b[1, 0]) # Prints "1 2 4"

Numpy también proporciona muchas funciones para crear matrices:

import numpy as np

a = np.zeros((2,2)) # Create an array of all zeros

print(a) # Prints "[[ 0. 0.]
# [ 0. 0.]]"

b = np.ones((1,2)) # Create an array of all ones

print(b) # Prints "[[ 1. 1.]]"

c = np.full((2,2), 7) # Create a constant array

print(c) # Prints "[[ 7. 7.]
# [ 7. 7.]]"

d = np.eye(2) # Create a 2x2 identity matrix

print(d) # Prints "[[ 1. 0.]
# [ 0. 1.]]"

e = np.random.random((2,2)) # Create an array filled with

random values
print(e) # Might print "[[ 0.91940167
0.08143941]
# [ 0.68744134
0.87236687]]"
Puede leer sobre otros métodos de creación de matrices en la documentación .

Indexación de matrices

Numpy ofrece varias formas de indexar en matrices.

Rebanado: Al igual que en las listas de Python, los arreglos numpy se pueden
rebanar. Dado que las matrices pueden ser multidimensionales, debe especificar
un sector para cada dimensión de la matriz:
import numpy as np

# Create the following rank 2 array with shape (3, 4)

# [[ 1 2 3 4]
# [ 5 6 7 8]
# [ 9 10 11 12]]
a = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]])

# Use slicing to pull out the subarray consisting of the

first 2 rows
# and columns 1 and 2; b is the following array of shape (2,
2):
# [[2 3]
# [6 7]]
b = a[:2, 1:3]

# A slice of an array is a view into the same data, so

modifying it
# will modify the original array.
print(a[0, 1]) # Prints "2"
b[0, 0] = 77 # b[0, 0] is the same piece of data as a[0,
1]
print(a[0, 1]) # Prints "77"

También puede mezclar la indexación de enteros con la indexación de

segmentos. Sin embargo, hacerlo producirá una matriz de rango más bajo que
la matriz original. Tenga en cuenta que esto es muy diferente de la forma en que
MATLAB maneja la división de matrices:

import numpy as np

# Create the following rank 2 array with shape (3, 4)

# [[ 1 2 3 4]
# [ 5 6 7 8]
# [ 9 10 11 12]]
a = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]])

# Two ways of accessing the data in the middle row of the

array.
# Mixing integer indexing with slices yields an array of
lower rank,
# while using only slices yields an array of the same rank as
the
# original array:
row_r1 = a[1, :] # Rank 1 view of the second row of a
row_r2 = a[1:2, :] # Rank 2 view of the second row of a
print(row_r1, row_r1.shape) # Prints "[5 6 7 8] (4,)"
print(row_r2, row_r2.shape) # Prints "[[5 6 7 8]] (1, 4)"
# We can make the same distinction when accessing columns of
an array:
col_r1 = a[:, 1]
col_r2 = a[:, 1:2]
print(col_r1, col_r1.shape) # Prints "[ 2 6 10] (3,)"
print(col_r2, col_r2.shape) # Prints "[[ 2]
# [ 6]
# [10]] (3, 1)"
Indización de matriz entera: cuando indexa en matrices numpy utilizando la
segmentación, la vista de matriz resultante siempre será una subarreglo de la
matriz original. En contraste, la indexación de matrices enteras le permite
construir matrices arbitrarias utilizando los datos de otra matriz. Aquí hay un
ejemplo:
import numpy as np

a = np.array([[1,2], [3, 4], [5, 6]])

# An example of integer array indexing.

# The returned array will have shape (3,) and
print(a[[0, 1, 2], [0, 1, 0]]) # Prints "[1 4 5]"

# The above example of integer array indexing is equivalent

to this:
print(np.array([a[0, 0], a[1, 1], a[2, 0]])) # Prints "[1 4
5]"

# When using integer array indexing, you can reuse the same
# element from the source array:
print(a[[0, 0], [1, 1]]) # Prints "[2 2]"

# Equivalent to the previous integer array indexing example

print(np.array([a[0, 1], a[0, 1]])) # Prints "[2 2]"
Un truco útil con la indexación de matrices de enteros es seleccionar o mutar un
elemento de cada fila de una matriz:
import numpy as np

# Create a new array from which we will select elements

a = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])

print(a) # prints "array([[ 1, 2, 3],

# [ 4, 5, 6],
# [ 7, 8, 9],
# [10, 11, 12]])"

# Create an array of indices

b = np.array([0, 2, 0, 1])

# Select one element from each row of a using the indices in

b
print(a[np.arange(4), b]) # Prints "[ 1 6 7 11]"
# Mutate one element from each row of a using the indices in
b
a[np.arange(4), b] += 10

print(a) # prints "array([[11, 2, 3],

# [ 4, 5, 16],
# [17, 8, 9],
# [10, 21, 12]])

Indexación de matriz booleana: la indexación de matriz booleana le permite

seleccionar elementos arbitrarios de una matriz. Con frecuencia, este tipo de
indexación se utiliza para seleccionar los elementos de una matriz que satisfacen
alguna condición. Aquí hay un ejemplo:

import numpy as np

a = np.array([[1,2], [3, 4], [5, 6]])

bool_idx = (a > 2) # Find the elements of a that are bigger

than 2;
# this returns a numpy array of Booleans
of the same
# shape as a, where each slot of
bool_idx tells
# whether that element of a is > 2.

print(bool_idx) # Prints "[[False False]

# [ True True]
# [ True True]]"

# We use boolean array indexing to construct a rank 1 array

# consisting of the elements of a corresponding to the True
values
# of bool_idx
print(a[bool_idx]) # Prints "[3 4 5 6]"

# We can do all of the above in a single concise statement:

print(a[a > 2]) # Prints "[3 4 5 6]"

Por brevedad, hemos omitido muchos detalles sobre la indexación de matrices

numpy; Si quieres saber más debes leer la documentación .
Tipos de datos
Cada matriz numpy es una cuadrícula de elementos del mismo tipo. Numpy
proporciona un gran conjunto de tipos de datos numéricos que puede utilizar
para construir matrices. Numpy intenta adivinar un tipo de datos cuando crea una
matriz, pero las funciones que construyen matrices generalmente también
incluyen un argumento opcional para especificar explícitamente el tipo de
datos. Aquí hay un ejemplo:

import numpy as np

x = np.array([1, 2]) # Let numpy choose the datatype

print(x.dtype) # Prints "int64"

x = np.array([1.0, 2.0]) # Let numpy choose the datatype

print(x.dtype) # Prints "float64"

x = np.array([1, 2], dtype=np.int64) # Force a particular

datatype
print(x.dtype) # Prints "int64"

Puede leer todo acerca de los tipos de datos numpy en la documentación .

Matemática

Las funciones matemáticas básicas funcionan de manera elemental en los

arreglos, y están disponibles como sobrecargas de operador y como funciones
en el módulo numpy:

import numpy as np

x = np.array([[1,2],[3,4]], dtype=np.float64)
y = np.array([[5,6],[7,8]], dtype=np.float64)

# Elementwise sum; both produce the array

# [[ 6.0 8.0]
# [10.0 12.0]]
print(x + y)
print(np.add(x, y))

# Elementwise difference; both produce the array

# [[-4.0 -4.0]
# [-4.0 -4.0]]
print(x - y)
print(np.subtract(x, y))

# Elementwise product; both produce the array

# [[ 5.0 12.0]
# [21.0 32.0]]
print(x * y)
print(np.multiply(x, y))

# Elementwise division; both produce the array

# [[ 0.2 0.33333333]
# [ 0.42857143 0.5 ]]
print(x / y)
print(np.divide(x, y))

# Elementwise square root; produces the array

# [[ 1. 1.41421356]
# [ 1.73205081 2. ]]
print(np.sqrt(x))

Tenga en cuenta que, a diferencia de MATLAB, * es la multiplicación por

elementos, no la multiplicación de matrices. En su lugar, utilizamos la dot función

para calcular los productos internos de los vectores, para multiplicar un vector
por una matriz y para multiplicar las matrices. dot está disponible como una

función en el módulo numpy y como un método de instancia de objetos de matriz:

import numpy as np

x = np.array([[1,2],[3,4]])
y = np.array([[5,6],[7,8]])

v = np.array([9,10])
w = np.array([11, 12])

# Inner product of vectors; both produce 219

print(v.dot(w))
print(np.dot(v, w))

# Matrix / vector product; both produce the rank 1 array [29

67]
print(x.dot(v))
print(np.dot(x, v))

# Matrix / matrix product; both produce the rank 2 array

# [[19 22]
# [43 50]]
print(x.dot(y))
print(np.dot(x, y))
Numpy proporciona muchas funciones útiles para realizar cálculos en
arreglos; Una de las más útiles es sum :

import numpy as np

x = np.array([[1,2],[3,4]])

print(np.sum(x)) # Compute sum of all elements; prints "10"

print(np.sum(x, axis=0)) # Compute sum of each column;
prints "[4 6]"
print(np.sum(x, axis=1)) # Compute sum of each row; prints
"[3 7]"
Puede encontrar la lista completa de funciones matemáticas proporcionadas por
numpy en la documentación .
Además de calcular funciones matemáticas utilizando matrices, con frecuencia
necesitamos cambiar la forma de los datos o manipularlos en matrices. El
ejemplo más simple de este tipo de operación es la transposición de una
matriz; para transponer una matriz, simplemente use el T atributo de un objeto

de matriz:

import numpy as np

x = np.array([[1,2], [3,4]])
print(x) # Prints "[[1 2]
# [3 4]]"
print(x.T) # Prints "[[1 3]
# [2 4]]"

# Note that taking the transpose of a rank 1 array does

nothing:
v = np.array([1,2,3])
print(v) # Prints "[1 2 3]"
print(v.T) # Prints "[1 2 3]"

Numpy proporciona muchas más funciones para manipular matrices; Puedes ver
la lista completa en la documentación .

Radiodifusión

La radiodifusión es un mecanismo poderoso que permite que Númpy funcione

con matrices de diferentes formas al realizar operaciones aritméticas. Con
frecuencia tenemos una matriz más pequeña y una matriz más grande, y
queremos usar la matriz más pequeña varias veces para realizar alguna
operación en la matriz más grande.

Por ejemplo, supongamos que queremos agregar un vector constante a cada fila
de una matriz. Podríamos hacerlo así:

import numpy as np

# We will add the vector v to each row of the matrix x,

# storing the result in the matrix y
x = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])
v = np.array([1, 0, 1])
y = np.empty_like(x) # Create an empty matrix with the same
shape as x

# Add the vector v to each row of the matrix x with an

explicit loop
for i in range(4):
y[i, :] = x[i, :] + v

# Now y is the following

# [[ 2 2 4]
# [ 5 5 7]
# [ 8 8 10]
# [11 11 13]]
print(y)

Esto funciona; sin embargo, cuando la matriz xes muy grande, el cálculo de un
bucle explícito en Python podría ser lento. Tenga en cuenta que agregar el
vector va cada fila de la matriz xequivale a formar una matriz vval apilar varias
copias de forma vvertical, luego realizar la suma elemental de xy vv. Podríamos
implementar este enfoque de esta manera:

import numpy as np

# We will add the vector v to each row of the matrix x,

# storing the result in the matrix y
x = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])
v = np.array([1, 0, 1])
vv = np.tile(v, (4, 1)) # Stack 4 copies of v on top of
each other
print(vv) # Prints "[[1 0 1]
# [1 0 1]
# [1 0 1]
# [1 0 1]]"
y = x + vv # Add x and vv elementwise
print(y) # Prints "[[ 2 2 4
 # [ 5 5 7]
# [ 8 8 10]
# [11 11 13]]"

La transmisión de Numpy nos permite realizar este cálculo sin crear copias
múltiples de v. Considere esta versión, utilizando la difusión:

import numpy as np

# We will add the vector v to each row of the matrix x,

# storing the result in the matrix y
x = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])
v = np.array([1, 0, 1])
y = x + v # Add v to each row of x using broadcasting
print(y) # Prints "[[ 2 2 4]
# [ 5 5 7]
# [ 8 8 10]
# [11 11 13]]"

La línea y = x + vfunciona aunque xtiene forma (4, 3)y vtiene forma (3,)debido a
la difusión; esta línea funciona como si vrealmente tuviera forma (4, 3), donde
cada fila era una copia de v, y la suma se realizó elementwise.

La difusión de dos matrices juntas sigue estas reglas:

Si las matrices no tienen el mismo rango, anteponga la forma de la matriz de

rango inferior con 1s hasta que ambas formas tengan la misma longitud.

Se dice que las dos matrices son compatibles en una dimensión si tienen el mismo
tamaño en la dimensión, o si una de las matrices tiene el tamaño 1 en esa
dimensión.

Los arreglos se pueden transmitir juntos si son compatibles en todas las

dimensiones.

Después de la difusión, cada matriz se comporta como si tuviera una forma igual
al máximo elemental de las dos matrices de entrada.

En cualquier dimensión donde una matriz tenía un tamaño 1 y la otra matriz tenía
un tamaño mayor que 1, la primera matriz se comporta como si se hubiera
copiado a lo largo de esa dimensión
Si esta explicación no tiene sentido, intente leer la explicación de la
documentación o esta explicación .

Las funciones que admiten la difusión se conocen como funciones

universales . Puede encontrar la lista de todas las funciones universales en la
documentación .

Aquí hay algunas aplicaciones de la radiodifusión:

import numpy as np

# Compute outer product of vectors

v = np.array([1,2,3]) # v has shape (3,)
w = np.array([4,5]) # w has shape (2,)
# To compute an outer product, we first reshape v to be a
column
# vector of shape (3, 1); we can then broadcast it against w
to yield
# an output of shape (3, 2), which is the outer product of v
and w:
# [[ 4 5]
# [ 8 10]
# [12 15]]
print(np.reshape(v, (3, 1)) * w)

# Add a vector to each row of a matrix

x = np.array([[1,2,3], [4,5,6]])
# x has shape (2, 3) and v has shape (3,) so they broadcast
to (2, 3),
# giving the following matrix:
# [[2 4 6]
# [5 7 9]]
print(x + v)

# Add a vector to each column of a matrix

# x has shape (2, 3) and w has shape (2,).
# If we transpose x then it has shape (3, 2) and can be
broadcast
# against w to yield a result of shape (3, 2); transposing
this result
# yields the final result of shape (2, 3) which is the matrix
x with
# the vector w added to each column. Gives the following
matrix:
# [[ 5 6 7]
# [ 9 10 11]]
print((x.T + w).T)
# Another solution is to reshape w to be a column vector of
shape (2, 1);
# we can then broadcast it directly against x to produce the
same
# output.
print(x + np.reshape(w, (2, 1)))

# Multiply a matrix by a constant:

# x has shape (2, 3). Numpy treats scalars as arrays of shape
();
# these can be broadcast together to shape (2, 3), producing
the
# following array:
# [[ 2 4 6]
# [ 8 10 12]]
print(x * 2)

La difusión generalmente hace que su código sea más conciso y rápido, por lo
que debe esforzarse por usarlo cuando sea posible.

Ciencia

Numpy proporciona una matriz multidimensional de alto rendimiento y

herramientas básicas para calcular y manipular estas matrices. SciPy se basa en
esto, y proporciona una gran cantidad de funciones que operan en numerosos
arreglos y son útiles para diferentes tipos de aplicaciones científicas y de
ingeniería.

La mejor manera de familiarizarse con SciPy es navegar por la

documentación . Resaltaremos algunas partes de SciPy que podrían ser útiles
para esta clase.

Operaciones de imagen

SciPy proporciona algunas funciones básicas para trabajar con imágenes. Por
ejemplo, tiene funciones para leer imágenes del disco en matrices numpy, para
escribir matrices numpy en el disco como imágenes y para redimensionar
imágenes. Aquí hay un ejemplo simple que muestra estas funciones:

from scipy.misc import imread, imsave, imresize

# Read an JPEG image into a numpy array

img = imread('assets/cat.jpg')
print(img.dtype, img.shape) # Prints "uint8 (400, 248, 3)"
# We can tint the image by scaling each of the color channels
# by a different scalar constant. The image has shape (400,
248, 3);
# we multiply it by the array [1, 0.95, 0.9] of shape (3,);
# numpy broadcasting means that this leaves the red channel
unchanged,
# and multiplies the green and blue channels by 0.95 and 0.9
# respectively.
img_tinted = img * [1, 0.95, 0.9]

# Resize the tinted image to be 300 by 300 pixels.

img_tinted = imresize(img_tinted, (300, 300))

# Write the tinted image back to disk

imsave('assets/cat_tinted.jpg', img_tinted)

Izquierda: La imagen original. Derecha: La imagen teñida y redimensionada.

Archivos MATLAB

Las funciones scipy.io.loadmat y le scipy.io.savemat permiten leer y escribir

archivos MATLAB. Puedes leer sobre ellos en la documentación .

Distancia entre puntos

SciPy define algunas funciones útiles para calcular distancias entre conjuntos de
puntos.
La función scipy.spatial.distance.pdist calcula la distancia entre todos los pares

de puntos en un conjunto dado:

import numpy as np
from scipy.spatial.distance import pdist, squareform

# Create the following array where each row is a point in 2D

space:
# [[0 1]
# [1 0]
# [2 0]]
x = np.array([[0, 1], [1, 0], [2, 0]])
print(x)

# Compute the Euclidean distance between all rows of x.

# d[i, j] is the Euclidean distance between x[i, :] and x[j,
:],
# and d is the following array:
# [[ 0. 1.41421356 2.23606798]
# [ 1.41421356 0. 1. ]
# [ 2.23606798 1. 0. ]]
d = squareform(pdist(x, 'euclidean'))
print(d)

Puedes leer todos los detalles sobre esta función en la documentación .

Una función similar ( scipy.spatial.distance.cdist) calcula la distancia entre todos los pares a
través de dos conjuntos de puntos; Puedes leerlo en la documentación .

Matplotlib

Matplotlib es una biblioteca de trazado. En esta sección, proporcione una breve introducción
al matplotlib.pyplotmódulo, que proporciona un sistema de trazado similar al de MATLAB.

Trazar

La función más importante en matplotlib es plot, que le permite trazar datos 2D. Aquí hay un
ejemplo simple:

import numpy as np
import matplotlib.pyplot as plt

# Compute the x and y coordinates for points on a sine curve

x = np.arange(0, 3 * np.pi, 0.1)
y = np.sin(x)
# Plot the points using matplotlib
plt.plot(x, y)
plt.show() # You must call plt.show() to make graphics
appear.
Ejecutar este código produce la siguiente gráfica:

Con solo un poco de trabajo adicional, podemos trazar fácilmente varias líneas
a la vez, y agregar un título, leyenda y etiquetas de eje:

import numpy as np
import matplotlib.pyplot as plt

# Compute the x and y coordinates for points on sine and

cosine curves
x = np.arange(0, 3 * np.pi, 0.1)
y_sin = np.sin(x)
y_cos = np.cos(x)

# Plot the points using matplotlib

plt.plot(x, y_sin)
plt.plot(x, y_cos)
plt.xlabel('x axis label')
plt.ylabel('y axis label')
plt.title('Sine and Cosine')
plt.legend(['Sine', 'Cosine'])
plt.show()
Puedes leer mucho más sobre la plot función en la documentación .

Subparcelas

Puedes trazar diferentes cosas en la misma figura usando

la subplot función. Aquí hay un ejemplo:

import numpy as np
import matplotlib.pyplot as plt

# Compute the x and y coordinates for points on sine and

cosine curves
x = np.arange(0, 3 * np.pi, 0.1)
y_sin = np.sin(x)
y_cos = np.cos(x)

# Set up a subplot grid that has height 2 and width 1,

# and set the first such subplot as active.
plt.subplot(2, 1, 1)

# Make the first plot

plt.plot(x, y_sin)
plt.title('Sine')

# Set the second subplot as active, and make the second plot.
plt.subplot(2, 1, 2)
plt.plot(x, y_cos)
plt.title('Cosine')

# Show the figure.

plt.show()
Puedes leer mucho más sobre la subplot función en la documentación .

Imágenes
Puede utilizar la imshow función para mostrar imágenes. Aquí hay un ejemplo:

import numpy as np
from scipy.misc import imread, imresize
import matplotlib.pyplot as plt

img = imread('assets/cat.jpg')
img_tinted = img * [1, 0.95, 0.9]

# Show the original image

plt.subplot(1, 2, 1)
plt.imshow(img)

# Show the tinted image

plt.subplot(1, 2, 2)

# A slight gotcha with imshow is that it might give strange

results
# if presented with data that is not uint8. To work around
this, we
# explicitly cast the image to uint8 before displaying it.
plt.imshow(np.uint8(img_tinted))
plt.show()
funciones: cv2.VideoCapture ()

 Aprender a leer vídeo, mostrar vídeo y guardar vídeo.

 Aprender a capturar video desde la cámara y mostrarlo.
 Aprenderás el funcionamiento de las siguientes
funciones: cv2.VideoCapture ()
Capturar video de la webcam

No solo podemos trabajar con imágenes cargadas desde archivos, también

podemos leer imágenes desde la cámara web de nuestro PC, si capturamos una
serie de imágenes sucesivas tendremos un video en tiempo real, veamos como
se hace.

Para capturar imágenes provenientes de la cámara usaremos un objeto

VideoCapture(0) debemos indicar el índice de la cámara que deseamos utilizar,
por ejemplo, si tenemos dos habilitadas, indicamos cero para la primera, uno
para la siguiente y así sucesivamente.

En lugar de indicar el índice de cámara, también es posible indicar el nombre de

un archivo de video, si el formato esta soportado este se visualizará.

import cv2

cap = cv2.VideoCapture(0)

while(True):
ret, frame = cap.read()

if ret:
cv2.imshow('video', frame)

if cv2.waitKey(1) & 0xFF == 27:

break
cap.release()
cv2.destroyAllWindows()

Para capturar un cuadro de video usamos cap.read() este devuelve un booleano

que indica si la captura es válida y el objeto imagen que representa la captura,

de aquí en adelanta tratamos la captura como si fuese cualquier otra imagen, al
terminar usaremos cap.release() para liberar recursos.