Comenzando con opencv

Carga y muestra una imagen con OpenCV #

Con este ejemplo, veremos cómo cargar una imagen en color desde el disco y mostrarla usando las funciones integradas de OpenCV. Podemos usar los enlaces C/C++, Python o Java para lograr esto.

En C++:

#include <opencv2/core.hpp>
#include <opencv2/highgui.hpp>

#include <iostream>

using namespace cv;

int main(int argc, char** argv) {
    // We'll start by loading an image from the drive
    Mat image = imread("image.jpg", CV_LOAD_IMAGE_COLOR);

    // We check that our image has been correctly loaded
    if(image.empty()) {
        std::cout << "Error: the image has been incorrectly loaded." << std::endl;
        return 0;
    }

    // Then we create a window to display our image
    namedWindow("My first OpenCV window");

    // Finally, we display our image and ask the program to wait for a key to be pressed
    imshow("My first OpenCV window", image);
    waitKey(0);

    return 0;
}

En Python:

import sys
import cv2

# We load the image from disk
img = cv2.imread("image.jpg", cv2.CV_LOAD_IMAGE_COLOR)

# We check that our image has been correctly loaded
if img.size == 0
    sys.exit("Error: the image has not been correctly loaded.")

# We create a window to display our image
cv2.namedwindow("My first OpenCV window")

# We display our image and ask the program to wait until a key is pressed
cv2.imshow("My first OpenCV window", img)
cv2.waitKey(0)

# We close the window
cv2.destroyAllWindows()

En Java:

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.core.CvType;
import org.opencv.highgui.Highgui;
public class Sample{
public static void main (String[] args) {

    //Load native opencv library
    System.loadLibrary(Core.NATIVE_LIBRARY_NAME);

    //Read image from file first param:file location ,second param:color space
    Mat img = imread("image.jpg",CV_LOAD_IMAGE_COLOR);

    //If the image is successfully read.
    if (img.size() == 0) {
        System.exit(1);
    }
}

HighGui no tiene ventanas con nombre o equivalentes imshow en opencv java. Use swing o swt para mostrar la imagen.

Compile e instale OpenCV desde la fuente #

Esta es una guía paso a paso para instalar OpenCV 3 en un sistema Linux basado en Debian desde la fuente. Los pasos deben seguir siendo los mismos para otras distribuciones, solo reemplace los comandos relevantes del administrador de paquetes al instalar paquetes para la compilación.

Nota: Si no tiene ganas de perder el tiempo construyendo cosas o no le gusta la terminal, lo más probable es que pueda instalar OpenCV desde la GUI del administrador de paquetes Synaptic. Sin embargo, estas bibliotecas suelen estar desactualizadas.

Prepárese para la construcción #

Ejecute los siguientes comandos en su terminal para instalar los paquetes necesarios:

sudo apt-get update
sudo apt-get install build-essential
sudo apt-get install cmake git libgtk2.0-dev pkg-config \
                     libavcodec-dev libavformat-dev libswscale-dev

Los siguientes paquetes son opcionales:

sudo apt-get install python-dev python-numpy libtbb2 libtbb-dev libjpeg-dev \
                     libpng-devlibtiff-dev libjasper-dev libdc1394-22-dev

Ejecute el siguiente comando para obtener el código fuente de OpenCV y preparar la compilación:

mkdir ~/src
cd ~/src
git clone https://github.com/opencv/opencv.git
cd opencv
mkdir build && cd build

Construir e instalar #

Incluimos los ejemplos en la compilación, pero siéntete libre de omitirlos. También siéntase libre de establecer otras banderas y personalizar su construcción como mejor le parezca.

cmake -D CMAKE_BUILD_TYPE=RELEASE \
      -D CMAKE_INSTALL_PREFIX=/usr/local \
      -D INSTALL_PYTHON_EXAMPLES=ON \
      -D INSTALL_C_EXAMPLES=ON ..

Si CMake no informó ningún error o bibliotecas faltantes, continúe con la compilación.

make -j$(nproc)

Si no se produjeron errores, podemos continuar con la instalación de OpenCV en el sistema:

sudo make install

Ahora OpenCV debería estar disponible para su sistema. Puede usar las siguientes líneas para saber dónde se instaló OpenCV y qué bibliotecas se instalaron:

pkg-config --cflags opencv  # get the include path (-I)
pkg-config --libs opencv    # get the libraries path (-L) and the libraries (-l)

Instalación de prueba #

Primero construimos los ejemplos de C++:

cd ~/src/opencv/samples
cmake .
make

Si no se produjeron errores, ejecute cualquier muestra, p.

./cpp/cpp-example-edge

Si se ejecuta el ejemplo, las bibliotecas de C++ están instaladas correctamente.

A continuación, pruebe los enlaces de Python:

python
>> import cv2
>> print cv2.__version__

Si estos comandos importan OpenCV e imprimen la versión correcta sin quejarse, entonces los enlaces de Python están instalados correctamente.

Felicidades, acabas de construir e instalar OpenCV. ¡Feliz programación!

Para Mac consulte aquí http://stackoverflow.com/questions/19671827/opencv-installation-on-mac-os-x

Primeros pasos con OpenCV 3.1 en Windows #

Instalamos OpenCV 3.1.0 en Windows y comenzamos. Hay dos formas de instalar OpenCV en Windows. Una es descargar el instalador y ejecutarlo. Otro es construir desde la fuente.

Esta es la forma más fácil de instalar OpenCV y comenzar. OpenCV ofrece binarios precompilados para instalar en Windows aquí. Después de que termine de descargarse, extráigalo e instálelo en la ruta elegida.

Consejo profesional: Asegúrese de que su ruta de OpenCV no incluya espacios. Por lo tanto, es mejor si lo instala en el directorio raíz C:\ o D:\

El problema con el método anterior es que no puede usar los módulos opencv_contrib. Además, no viene con todas las herramientas y bibliotecas de terceros. Entonces, si desea usar todos estos, solo siga adelante.

Explicaré los mínimos mínimos para instalar OpenCV desde la fuente. Para uno más avanzado, consulte aquí.

• Instalar CMake.
• Clone la fuente OpenCV de https://github.com/Itseez/opencv.git en algún directorio que no tenga espacios. Vamos a referirnos a él como “OpenCVdir”.
• Ahora, abra la GUI de CMake y agregue su directorio de origen (OpenCVdir) al menú Fuentes y cree el directorio en el menú de compilación. Consejo: Si no hay un directorio de compilación, cree uno en su carpeta opencv.
• Haga clic en Configurar y seleccione su versión del compilador de Visual Studio. Tenía Visual Studio 2013 Professional de 32 bits, así que elegí el compilador Visual Studio 12.

Consejo: Puede descargar Visual Studio 2013 Professional desde aquí. viene con 30 días de prueba + 90 días de prueba extendida después de iniciar sesión.

• Presione Finalizar y CMake cargará todos los paquetes automáticamente. Puede agregar o eliminar paquetes. Pulse Configurar de nuevo.
• Si desea compilar con módulos opencv_contrib adicionales, debe descargarlos desde [aquí] 7. Luego, extráigalos y agregue el directorio opencv_contrib/modules a su CMake como se muestra a continuación.
• Ahora presiona Configurar nuevamente y luego presiona Generar.
• Cierra CMake. Vaya a la carpeta your_opencv\build y abra el archivo llamado ‘OpenCV.sln’. - Se abrirá Visual Studio. Ahora, ejecútelo tanto en el modo Depurar como en el modo Liberar .
• Ahora, en el explorador de soluciones en la parte superior derecha de su Visual Studio, seleccione INSTALAR proyectarlo y construirlo.

¡¡Viva!! Disfruta de tu OpenCV.

** Agregar el directorio incluido de OpenCV a la variable PATH de Variables de entorno: **

• Vaya a Propiedades del sistema y haga clic en Configuración avanzada del sistema.

• Ahora, haga clic en Variables de entorno » Ruta » Editar.

• Aquí, agregue la carpeta bin ubicada en su OpenCVdir/build/install/x86/vc**/bin a esta variable. Tenga cuidado de no reemplazar los valores de Path existentes.

• Después de esto, debe reiniciar su sistema para que cambien las variables de entorno y ahora está listo para comenzar.

¿Qué y por qué OPENCV? #

OpenCV (Biblioteca de visión artificial de código abierto) es una biblioteca de software de aprendizaje automático y visión artificial de código abierto. Fue creado para varios propósitos, como aprendizaje automático, visión por computadora, algoritmos, operaciones matemáticas, captura de video, procesamiento de imágenes, etc. A lo largo de los años, se ha vuelto muy popular entre los investigadores y desarrolladores en cuanto a su soporte en diferentes plataformas (Windows, Linux , androide, ios). También cuenta con wrapper en varios lenguajes de programación de renombre. Según el acuerdo de licencia, tiene acceso para que las empresas utilicen y modifiquen el código.

La biblioteca contiene más de 2500 algoritmos optimizados, que tiene una excelente precisión en rendimiento y velocidad. Estos algoritmos se pueden usar para detectar y reconocer rostros, identificar objetos, clasificar acciones humanas en videos, rastrear movimientos de cámara, rastrear objetos en movimiento, extraer modelos 3D de objetos, producir nubes de puntos 3D de cámaras estéreo, unir imágenes para producir una alta resolución. imagen de una escena completa, encuentre imágenes similares de una base de datos de imágenes, elimine los ojos rojos de las imágenes tomadas con flash, siga los movimientos de los ojos, reconozca el escenario y establezca marcadores para superponerlo con la realidad aumentada, etc. OpenCV tiene grandes personas y una comunidad involucrada como usuarios , desarrolladores e investigadores, el número es más de 47 mil y el número estimado de descargas supera los 7 millones. La biblioteca se encuentra ampliamente en empresas profesionales, grupos de investigación y otros grupos.

Muchas empresas bien establecidas como Google, Yahoo, Microsoft, Intel, IBM, Sony, Honda, Toyota que emplean la biblioteca, hay muchas nuevas empresas como Applied Minds, VideoSurf y Zeitera, que hacen un uso extensivo de OpenCV. Los usos desplegados de OpenCV abarcan desde unir imágenes de streetview, detectar intrusiones en videos de vigilancia en Israel, monitorear equipos mineros en China, ayudar a los robots a navegar y recoger objetos en Willow Garage, detectar accidentes por ahogamiento en piscinas en Europa, ejecutar arte interactivo en España y Nueva York, revisando las pistas en busca de escombros en Turquía, inspeccionando las etiquetas de los productos en fábricas de todo el mundo hasta la detección rápida de rostros en Japón. Tiene interfaces C++, C, Python, Java y MATLAB y es compatible con Windows, Linux, Android y Mac OS. OpenCV se inclina principalmente hacia aplicaciones de visión en tiempo real y aprovecha las instrucciones MMX y SSE cuando están disponibles. En este momento se están desarrollando activamente interfaces CUDA y OpenCL con todas las funciones. Hay más de 500 algoritmos y aproximadamente 10 veces más funciones que componen o admiten esos algoritmos. OpenCV está escrito de forma nativa en C++ y tiene una interfaz con plantilla que funciona a la perfección con contenedores STL.

Información recopilada del sitio web oficial

Ejemplo de hola mundo en Java #

Imagen OpenCv leída del sistema de archivos en Java

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.imgcodecs.Imgcodecs;
 
public class Giris {    
    public static void main(String[] args) {
        //Load native library
        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
        //image container object
        Mat imageArray;
        //Read image from file system
        imageArray=Imgcodecs.imread("C:\\Users\\mesutpiskin\\sample.jpg");
        //Get image with & height
        System.out.println(imageArray.rows());
        System.out.println(imageArray.cols());
    }
}

Obtener imagen de la cámara web #

Muestre un video en vivo tomado de una cámara web utilizando la clase VideoCapture de OpenCV con Java, C/C++ y Python.

#Java

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.videoio.VideoCapture;
 
public class Camera {
    public static void main(String[] args) {
        // Load Native Library
        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
        // image container object
        Mat imageArray = new Mat();
        // Video device acces
        VideoCapture videoDevice = new VideoCapture();
        // 0:Start default video device 1,2 etc video device id
        videoDevice.open(0);
        // is contected
        if (videoDevice.isOpened()) {
        // Get frame from camera
            videoDevice.read(imageArray);
            // image array
            System.out.println(imageArray.toString());
            // Release video device
            videoDevice.release();
        } else {
            System.out.println("Error.");
        }
    }
}

#C++

#include "opencv2/opencv.hpp"
#include "iostream"

int main(int, char**) {
    // open the first webcam plugged in the computer
    cv::VideoCapture camera(0);
    if (!camera.isOpened()) {
        std::cerr << "ERROR: Could not open camera" << std::endl;
        return 1;
    }

    // create a window to display the images from the webcam
    cv::namedWindow("Webcam", CV_WINDOW_AUTOSIZE);

    // this will contain the image from the webcam
    cv::Mat frame;
        
    // capture the next frame from the webcam
    camera >> frame;
    
    // display the frame until you press a key
    while (1) {
        // show the image on the window
        cv::imshow("Webcam", frame);
        // wait (10ms) for a key to be pressed
        if (cv::waitKey(10) >= 0)
            break;
    }
    return 0;
}

pitón #

import numpy as np
import cv2

# Video source - can be camera index number given by 'ls /dev/video*
# or can be a video file, e.g. '~/Video.avi'
cap = cv2.VideoCapture(0)

while(True):
    # Capture frame-by-frame
    ret, frame = cap.read()

    # Our operations on the frame come here
    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)

    # Display the resulting frame
    cv2.imshow('frame',gray)
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

# When everything done, release the capture
cap.release()
cv2.destroyAllWindows()