Portada » Blog » OpenCV 4.5.2 en Windows 10

OpenCV 4.5.2 en Windows 10

Compilar OpenCV 4.5.2 en Windows 10

Me dispongo a explicaros los pasos que se necesita para compilar OpenCV 4.5.2 en Windows 10 usando el código fuente y con el uso de una gran parte de software de terceros durante el proceso de compilación. OpenCV es una biblioteca de código abierto centrada en visión artificial y que ya data de 1999. Sin embargo, es una de las librerías más utilizadas y que evoluciona constantemente adaptándose a nuevas tecnologías como la aplicación de Inteligencia Artificial o el uso de las más modernas GPU.

Debido a mis proyectos basados en visión artificial me he dado cuenta de que no hay una gran cantidad de tutoriales, sobre todo en español, en el que expliquen paso a paso como instalar OpenCV a partir del código y aprovechando las posibilidades que ofrece el compilarlo con soporte de diferentes librerías como Qt, Tesseract, HDF5… Además, hay todavía menos recursos si nos centramos en Windows 10 y en Visual Studio.

Idealmente es siempre recomendable utilizar Linux, pero a veces, sobre todo si hablamos de automatización industrial, no queda más remedio que trabajar sobre Windows debido a la necesidad de usar algún software comercial específico, algo que por otra parte y afortunadamente, es cada vez más raro. ¡Empecemos!

Herramientas utilizadas

Se ha usado para la compilación de todas las librerías Visual Studio Community versión 16.9.4 junto con el Framework de Microsoft.NET versión 4.8.04084 y que lo podéis descargar de aquí: https://visualstudio.microsoft.com/es/vs/community/

Cmake 3.19.6 y Cmake GUI creado mediante QT 5.12.1. Link para descargar: https://cmake.org/

Por ultimo, también se ha usado Git para la descarga del código fuente de la página correspondiente a ciertos desarrollos. Versión 2.31.1.windows.1
La web para descargar es: https://git-scm.com/

Pasos generales para compilar

Resumiendo el modo de trabajar a lo largo del post, hay varios pasos que se repiten y que se utilizan para cualquier software que queramos compilar a partir del código fuente y usando CMake:

  • Creamos dos directorios en una carpeta temporal, uno para descargar el código fuente (sources) y el otro para crear los proyectos y soluciones (build).
  • Normalmente entraremos en la carpeta sources creada mediante un terminal (Yo estoy usando Windows Terminal y Powershell) y descargamos el código fuente mediante Git usando el siguiente comando de Windows. Seguidamente Git creará otra carpeta dentro de sources con el nombre del desarrollo. Por el contrario, al descargar el código directamente de la web, copiamos todos los archivos directamente en sources.
  • Arrancamos CMake y elegimos las carpetas de fuente y destino, que son las creadas antes.
  • Le damos a Configure con las opciones por defecto y elegimos la versión que tengamos instalada de Visual Studio.
  • Si no hay error, crea la primera configuración con las variables que se han modificado de forma automática, las cuales están en color rojo. Pongo un ejemplo  debajo.
Esquema de CMake para compilar OpenCV 4.5.2 en Windows 10
  • Modificamos las opciones de compilación según sea necesario y volvemos a presionar hasta que no queda ninguna línea de color rojo en la zona de opciones y no hay error. Hay que prestar atención al log cada vez que le damos a Configure, para ver si hay algún problema o hay variables necesarias que no han sido detectadas automáticamente, sobre todo respecto a los INCLUDE o LIB.
  • Le damos a Generate y se crea la solución en la carpeta que elegimos para la build con varios proyectos.
  • Abrimos el Visual Studio, generalmente con permisos de administrador por si la instalación es en C:\Archivos de programa\ y abrimos el archivo *.sln creado en el directorio de build. Una vez abierto buscamos los proyectos que más nos interesan: ALL_BUILD e INSTALL. Compilamos primero ALL_BUILD en configuración Debug y después en configuración Release. Posteriormente hacemos lo propio con el proyecto INSTALL, también con las dos configuraciones mencionadas, siendo esto importante, ya que muchas veces nos piden ambas configuraciones durante el proceso. Comentar que los archivos para versión Debug estarán marcados con la letra d como última letra del nombre del archivo.
Como compilar Visual Studio
  • Ya tendríamos el programa instalado en el directorio que CMake tenía configurado y que si nos interesa podríamos modificar durante el proceso de configuración.

Sofware utilizado

En mi caso tengo un AMD Ryzen así que he instalado también estas librerías específicas para AMD: AOCL (AMD Optimizing CPU Libraries), aunque no es necesario para la compilación, simplemente por comentar que existe software específico para esta marca, pues hay muchas herramientas que están enfocadas en procesadores Intel. Os pongo el link https://developer.amd.com/amd-aocl/

Primer Sofware a descargar

En estos primeros pasos descargamos software que podemos decir que es importante por su funcionalidad y características. Se trata de CUDA y de Qt.

Descargamos CUDA 11.2

Antes de nada, si no tenéis tarjeta NVDIA nos olvidamos de este paso. Instalamos las librerías CUDA de NVIDIA en el caso de que tengáis una tarjeta gráfica que pueda hacer uso de ellas y descargamos también las cuDNN para Deep Learning. Os aviso que es necesario crear una cuenta para poder descargarse ambas librerías.

Básicamente hay 3 pasos importantes:

  1. Instalar los drivers de la tarjeta gráfica, los cuales podemos descargarlos de: https://www.nvidia.es/Download/index.aspx?lang=es
  2. Instalar el CUDA toolkit para Windows.
    1. Descarga: https://developer.nvidia.com/cuda-downloads
    2. Documentación: https://docs.nvidia.com/cuda/cuda-installation-guide-microsoft-windows/index.html#introduction
      El directorio del CUDA toolkit donde va a instalarse es C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v11.2\
  3. Descargar las librerías cuDNN para Windows. En la página que pongo debajo de documentación está explicado todo el proceso de instalación, que básicamente consiste en copiar las librerías en el lugar donde se ha instalado el CUDA toolkit:
      1. Descarga: https://developer.nvidia.com/cudnn
      2. Documentación: https://docs.nvidia.com/deeplearning/cudnn/install-guide/index.html#download-windows

Os resumo debajo la instalación de cuDNN con la versión utilizada, así que si instaláis una versión diferente, simplemente cambiáis los números. El directorio de cuDNN es donde hemos descargado las librerías, le llamamos <installpath> y lo que hacemos es descomprimir el zip en ese directorio.

  • Copiamos <installpath>\cuda\bin\cudnn*.dll a C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v11.2\bin.
  • Copiamos <installpath>\cuda\include\cudnn*.h a C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v11.2\include.
  • Copiamos <installpath>\cuda\lib\x64\cudnn*.lib a C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v11.2\lib\x64.

Ojo, en la instalación de CUDA Toolkit hay un error un poco extraño y que es difícil de localizar. Resulta que si ya tienes instalado software para tu tarjeta NVIDIA, como puede ser NVIDIA Geforce Experience, e instalas el CUDA toolkit, te puede dar error y no sigue la instalación. Sin embargo, no te dice las razones particulares del error. La solución es desinstalar manualmente desde Windows (Panel de Control > Programas > Programas y características) el programa FrameView SDK. Una vez desinstalado, el programa de instalación de CUDA toolkit te permite continuar y se instala correctamente. La siguiente vez que actualices los controladores de NVIDIA, vuelve a instalarse el Frame View SDK, pero ya no hay problema con el resto de software.

Por último, tenemos que configurar las variables de entorno apuntando a donde está instalado ahora cuDNN y CUDA toolkit.
  • Variable Name: CUDA_PATH
  • Variable Value: C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v11.2

Descargamos Qt 5.15.2

Descargamos QT mediante la herramienta de instalación online desde su página web: https://www.qt.io/

Al igual que ocurría con NVIDIA hay que registrarse e instalar el software. Una vez instalado arrancamos el programa de Maintanence tool (C:\Qt\MaintenanceTool.exe) y comprobamos las opciones instaladas. Yo he usado la versión 5.15.2, aunque hay una versión nueva (6.0.3), pero por si hay alguna incompatibilidad, me quedo con la versión anterior. La opción importante que tengo marcada es Qt > Qt 5.15.2 > MSVC 2019 64-bit

Las otras opciones no las uso, pero dependiendo de las necesidades o de lo que podría ser interesante, podéis explorar las herramientas Qt. Sin embargo, no es el objetivo de este post, solo queremos el soporte de Qt para nuestro trabajo con OpenCV.

Por otro lado, apuntaros este directorio, ya que nos hará falta al compilar OpenCV: C:\Qt\5.15.2\msvc2019_64\lib\cmake\Qt5\

Dependencias

Vamos a aprovechar para descargar diferentes tipo de software, compilar el código fuente e instalarlo, el cual usaremos posteriormente en la compilación de OpenCV. En la mayor parte seguiremos los mismos pasos que hemos comentando en la introducción, por lo que os remito a seguirlos en cada caso.

Podría pedirse en algún caso el uso de la aplicación Software Network (https://software-network.org/), pero en este post hemos desmarcado la opción correspondiente SW_BUILD cuando lo pide, ya que en ocasiones es incompatible con Windows.

TBB. Intel Threading Building Blocks

Intel Threading Building Blocks es una biblioteca para C++ desarrollada por Intel para facilitar la escritura de programas que usen las posibilidades de paralelismo de los procesadores con varios núcleos.

Una opción es descargar todo el software en el que están incluidas (Intel® oneAPI Base Toolkit), pero son más de 22 Gb. De todas maneras, son más aplicaciones que pueden ser interesantes tener, por lo que os pongo el link a continuación:

https://software.intel.com/content/www/us/en/develop/tools/oneapi/base-toolkit/download.html

Yo lo que hice fue bajar las fuentes, compilarlas e instalarlas mediante el uso de Git. Escribimos en nuestra ventana de comandos:

git clone https://github.com/oneapi-src/oneTBB

En este caso podría pedir usar la siguiente herramienta, Intel® Software Development Emulator que la podéis descargar de aquí:

https://software.intel.com/content/www/us/en/develop/articles/intel-software-development-emulator.html

Si no la tenéis no habría problema por continuar el proceso así.

CMAKE image of TBB

Arrancamos CMake y le damos a Configure y después a Generate. Posteriormente abrimos la solución TBB.sln y compilamos ALL_BUILD en Debug y Release, compilando posteriormente del mismo modo INSTALL. Hemos elegido como directorio de instalación C:\Program files (x86)\TBB. Una vez finalizado, para poder usar las librerías creamos en el Path variables de entorno que apunten al directorio de instalación y a donde están instaladas las dll para más tarde en nuestro programa C++ indicar donde están los archivos .lib y los .h.

Gstreamer 1.18.3

GStreamer es un framework multimedia libre escrito en C cuyas librerías permiten crear aplicaciones audiovisuales: vídeo, sonido, codificación, etc. Las aplicaciones abarcan desde opciones simples como playback o streaming, a procesamiento más complejo de audio o vídeo. No vamos a compilarlos, solo necesitamos descargar los archivos de desarrollador y runtime e instalarlos. Lo hacemos desde su página web.

https://gstreamer.freedesktop.org/download/

Las diferentes carpetas que usaremos durante la compilación de OPenCV y en algún otro caso son las siguientes. En mi caso he tenido que configurarlo siempre manualmente ya que nunca son detectadas.

Tesseract 4.1.1

Tesseract es un motor de reconocimiento óptico de caracteres para varios sistemas operativos. He compilado Tesseract descargando el código fuente y usando Leptonica, Zlib, libpng, libtiff y libarchive. Vamos yendo una por una.

ZLIB 1.2.11

Se trata de una biblioteca de software utilizada para la compresión de datos. En este caso no usamos git y descargamos el código fuente de su web: https://zlib.net/ 

Usamos CMake de la misma forma que hemos hecho previamente sin modificar ninguna opción y no debería dar ningún error ni problema. Vamos al directorio destino y abrimos la solución generada: zlib.sln y compilamos ALL_BUILD e INSTALL en modo Debug y Release.

Recordemos que si los directorios de instalación están en C:, necesitaremos abrir el Visual Studio como Administrador para que pueda crear el directorio y copiar los archivos.

Directorio de instalación: C:\Program Files (x86)\zlib\

LIBPNG 1.6.37

Es una biblioteca para leer o crear imágenes en formato PNG, siendo la biblioteca oficial de referencia de dicho formato. No usamos git y descargamos las fuentes de https://sourceforge.net/projects/libpng/

Decir que es necesaria la instalación previa de Zlib. Normalmente CMake es capaz de localizar la instalación y si no es así, se deberá de poner manualmente. Hacemos igual que antes sin modificar ninguna opción por defecto.

Directorio de instalación: C:\Program Files (x86)\libpng

LIBTIFF 4.2.0

Es una librería para leer y escribir archivos tiff que también contiene herramientas de línea de comando para procesar dichos archivos. Tenemos la opción de descargar el código fuente en https://download.osgeo.org/libtiff/ o podemos usar git:

git clone https://gitlab.com/libtiff/libtiff.git

Usamo CMake del mismo modo que antes.

Directorio de instalación: C:/Program Files (x86)/tiff
Directorio de documentación: C:/Program Files (x86)/tiff/share/doc/tiff

LEPTONICA 1.80.0

Es código open source que es ampliamente usado para procesamiento de imagen y para aplicaciones de análisis. Descargamos el código fuente de su página web: http://www.leptonica.org/download.html

Actuamos como en anteriores casos, abriendo CMake y eligiendo el directorio del código fuente y el de destino. Después de darle a Configure, comprobamos que los directorios de libpng y libtiff no son detectados, así que los modificamos manualmente en CMake. La primera imagen es el CMake sin modificar:

Opciones Leptonica sin modificar

Ahora lo hemos corregido y los directorios están modificados:

Opciones Leptonica modificado

El directorio de instalación es C:/Program Files (x86)/leptonica

LIBARCHIVE 3.5.1

Se trata de una librería usada para la compresión de archivos. Descargamos las fuentes de https://www.libarchive.org/ y hacemos el mismo proceso que hemos realizado previamente.

Ojo, he comprobado que puede haber algún error en la localización de algunas de las librerías. Por ejemplo, en ZLIB localizó mal los directorios y es necesario que modificarlos correctamente con los valores que hemos usado en el caso de Leptonica. Vemos en la imagen que no ha elegido correctamente los directorios.

Opciones CMake libarchive mal configuradas

Compilando Tesseract 5.0.0

En este punto hemos instalado varias librerías que además usaremos más tarde en OpenCV, así que vamos a compilar Tesseract usándolas. Como hemos hecho otras veces, primero descargamos el código fuente mediante git.

git clone https://github.com/tesseract-ocr/tesseract.git

Tenemos que tener en cuenta que si hacemos el build de las “training tools”, nor marcará un error ya que hacerlo sin sw no está soportado en windows, así que desmarcamos esa opción:

   × SW_BUILD

Opciones marcadas a mayores: 

   √ USE_SYSTEM_ICU

   √ libArchive

CMake Tesseract

GLOG

Es una librería de C++ que implementa herramientas de logging a nivel aplicación, proveyendo APIs y macros. Tenemos que instalar previamente Gflags y Gtests. Durante el proceso de compilación hay más software que se podría incluir, pero podemos comprobar que no vamos a poder hacerlo ya que no tienen soporte para Windows.

GFLAGS

Es una librería C++ que implementa el uso de “flags” en línea de comando, el cual incluye soporte para tipos de datos estándar como string y la capacidad para definir flags en el código fuente en el cual están siendo usados.

Descargamos mediante git.

git clone https://github.com/gflags/gflags.git

En CMake he marcado:

  √ BUILD_SHARED_LIBS

Actuamos como en anteriores ocasiones y compilamos ALL_BUILD e INSTALL en la solución generada.

CMake GFLags

GTEST

Google Test es una biblioteca de pruebas unitarias para el lenguaje de programación C ++, basada en la arquitectura xUnit. El primer paso es descargar mediante Git:

git clone https://github.com/google/googletest.git

En CMake he marcado:

  √ BUILD_SHARED_LIBS

  √ gtest_build_samples

Por otro lado he desinstalado el componente “Test Adapter for Google Test” en Visual Studio, por si acaso podría haber algún tipo de incompatibilidad al realizar también la instalación del mismo componente, quizás con otra versión.

Compilamos GLOG

Una vez instalamos el anterior software descargamos el código fuente de GLog mediente git:

git clone https://github.com/google/glog.git

En CMake he desmarcado:

  × WITH_UNWIND

La variables de la carpeta de instalación de gflags, gflags_DIR se detectaron de forma automática pero las de Gtest las tuve que poner manualmente. Si habéis cambiado el directorio tendréis que actualizarla con el vuestro particular.

CMake Clog

Doxygen y Graphviz

Doxygen es un generador de documentación para diferentes lenguajes de programación, mientras que Graphviz es un conjunto de herramientas software usado para el diseño de diagramas. En este caso solo necesitamos instalar los binarios de la web e instalarlos, los cuales se podrán usar posteriormente para crear documentación de los desarrollos realizados.

HDF5 1.12.0

HDF (Hierarchical Data Format) es un conjunto de formatos de archivo diseñados específicamente para almacenar y organizar grandes cantidades de datos.

Descargamos las fuentes de https://www.hdfgroup.org/downloads/hdf5/source-code/. Además, necesitamos instalar JDK previamente, así que lo descargamos de https://www.oracle.com/java/technologies/javase-jdk16-downloads.html

Usamos CMake del mismo modo.

Marcamos:

  √ HDF5_ENABLE_Z_LIB_SUPPORT

Desmarcamos:

  × HDF5_TEST_FORTRAN y JAVA

Lo único extraño es que la variable ZLIB_DIR fue imposible de actualizarlo correctamente, incluso de modo manual. El resto de carpetas no tuvieron problema.

Directorio de instalación: C:/Program Files/HDF_Group/HDF5/1.12.0

CMake HDF5

EIGEN 3.3.9

Es una biblioteca C ++ de alto nivel para álgebra lineal, operaciones matriciales y vectoriales, transformaciones geométricas y algoritmos relacionados. Podemos descargar las librerías EIGEN de https://eigen.tuxfamily.org/index.php?title=Main_Page

Se podría utilizar Qt en este caso, sin embargo solo está soportado en una versión anterior de Qt diferente a la que estamos usando. El problema es detectado de manera automática.

Directorio de instalación: C:/Program Files (x86)/Eigen3

OPENBLAS 0.3.13

Es una implementación de código abierto de las API de BLAS y LAPACK con muchas optimizaciones hechas a mano para tipos de procesadores específicos. Usamos git para descargar el código fuente.

git clone https://github.com/xianyi/OpenBlas.git

La página web es https://www.openblas.net/

Directorio de instalación: C:/Program Files (x86)/OpenBLAS

Durante la configuración vemos que el uso de Cmake por ahora es experimental. Sin embargo, manteniendo las opciones por defecto, no hemos encontrado ningún problema a la hora de la compilación.

VTK 9.0.1

VTK (Visualization Toolki) es un software de código abierto para manipular y mostrar datos científicos. Tiene herramientas de renderizado 3D, así como una serie de widgets para la interacción 3D y capacidad para graficación 2D. La página web: https://vtk.org/

Usamos git para descargar el código fuente:

git clone https://gitlab.kitware.com/vtk/vtk.git

Marcamos las siguientes variables:

  √  VTK_MODULE_USE_EXTERNAL_VTK_eigen

  √  VTK_MODULE_USE_EXTERNAL_VTK_hdf5

  √  VTK_MODULE_USE_EXTERNAL_VTK_png

  √  VTK_MODULE_USE_EXTERNAL_VTK_tiff

  √  VTK_MODULE_USE_EXTERNAL_VTK_zlib

  √  VTK_USE_CUDA

Al marcar dichas variables nos darán varios errores con png, Eigen3, tiff y HDF5, así que modificamos las variables de los softwares que ya hemos instalado. Usamos para png y tiff los mismos valores que para el caso de leptonica, mientras que en el caso de HDF5 lo muestro en la siguiente imagen

CMake HDF5 variables

Rellenamos la línea de Eigen3_INCLUDE_DIR con el siguiente valor:

C:/Program Files (x86)/Eigen3/include/eigen3

Modificamos también las variables para obtener soporte en Qt.

Opciones CMake VTK

Una vez que hayamos modificado todo, le damos a Configure. Nos dará también un error al marcar Qt, pero no hay problema (nos pasará también con OpenCV).

Vamos a Qt5_DIR y el valor es C:\Qt\5.15.2\msvc2019_64\lib\cmake\Qt5\

Os podéis encontrar con el siguiente error, pero en el log del CMake ya te dice la solución.

CMake Error at ThirdParty/vtkm/vtkvtkm/CMakeLists.txt:2 (message): VTKm requested, but the VTKm submodule is not initialized. Please run ‘git
submodule update –init –recursive’ in the source directory.

Si nos sale el error mencionado, mediante una terminal escribe la siguiente orden en el directorio donde descargaste el código fuente.

git submodule update –init –recursive

Viendo el log podríamos tener un warning que podemos solucionar con el valor de la variable DUMPBIN_EXECUTABLE:

C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.28.29910/bin/Hostx64/x64/dumpbin.exe

Le damos a Configure las veces necesarias hasta que no tengamos ninguna línea marcada con rojo y posteriormente abrimos la solución y compilamos como siempre.

Directorio de instalación: C:/Program Files (x86)/VTK

Compilando OPENCV

Nos disponemos a realizar la compilación e instalación de OpenCV con el soporte del software que hemos compilado e instalado en los anteriores pasos. Como es la parte importante, vamos a explicar paso a paso, así como las opciones usadas.

Descargamos OpenCV

Descargamos OpenCV y los módulos de OpenCV utilizando Git.

  • git clone https://github.com/opencv/opencv.git

  • git clone https://github.com/opencv/opencv_contrib.git

Ya tenemos descargados en nuestro directorio sources, el código fuente de OpenCV, así como los extra_modules. Elegimos como hemos hecho otras veces las carpetas de código fuente y donde estarán las soluciones generadas.

Carpetas CMake OpenCV

Le damos a Configure y vemos que encuentra ya bastantes elementos, pero es necesario configurar otros manualmente además de marcar diferentes configuraciones. Os dejo mi log del CMake para que os hagáis una idea: Log primer Configure

Opciones CMake OpenCV

Ungrouped Entries

Dejamos todo como está y comprobamos que localiza los directorios de Eigen así como de VTK.

CMake Ungrouped entries

BLAS

No lo hemos instalado, pero si queréis incluirlo se podría. En un principio yo no lo hice.

BUILD

Marcamos las siguientes opciones:

  √  BUILD_DOCS

  √  BUILD_EXAMPLES

Desmarcamos:

  × BUILD_PNG. Ya habíamos realizado la compilación e instalación.

  × BUILD_TIFF. Lo mismo.

  × BUILD_ZLIB. Lo mismo.

  × BUILD_JAVA. No voy a utilizar Java. Se puede marcar si queréis tener soporte.

  × BUILD_opencv_java_bindings_generator. Por la misma razón.

  × BULD_opencv_js_bindings_generator

Si no queremos tener instalación de Python, tenemos que desmarcar las casillas correspondientes. Yo las he desmarcado ya que me interesa solo tener la versión de C++.

  × BUILD_opencv_python3

  × BUILD_opencv_python_bindings_generator

  × BUILD_opencv_python_tests

CMake BUILD

CMAKE

Vemos que el directorio de instalación será D:/DocsTrabajo/OpenCVBuilt/install, el cual lo podemos modificar con el directorio en el que queremos tener instaladas las librerías.

GSTREAMER

Normalmente no detecta nada así que lo cubrimos manualmente. Recordamos que los directorios son:

INSTALL

Marcamos:

  √  INSTALL_C_EXAMPLES

OPENCV

Marcamos:

  √  OPENCV_DNN_CUDA.

Además cubrimos OPENCV_EXTRA_MODULES_PATH con el directorio donde lo descargamos previamente:

D:/DocsTrabajo/temp/OpenCVSources/opencv_contrib/modules

OPENBLAS

No ha detectado nada, por lo tanto lo cubrimos manualmente:

CMake OPenBLAS OpenCV

WITH

Desmarqué:

  × WITH_1394, pues no lo necesitaré.

Marco:

  √  WITH_CUDA

  √  WITH_OPENGL

  √  WITH_QT

  √  WITH_TBB

ÚLTIMOS PASOS

Por ahora no modificamos nada más y le volvemos a dar a Configure, saltándonos previsiblemente un error de Qt al no encontrar el directorio pero no hay problema. Vamos a Ungrouped Entries y en Qt5_DIR ponemos C:\Qt\5.15.2\msvc2019_64\lib\cmake\Qt5

Marcamos también:

  √  WITH_NVCUVID

Aprovechamos y vemos que no detectó las librerías PNG y TIFF, así que las modificamos y nos queda:

Opciones CMake OpenCV

Volvemos a darle a Configure y ahora no debería dar ningún error. Comprobamos el log y que encuentra las librerías necesarias.

Vemos que se han detectado de forma automática varias instalaciones, entre ellas Gflags, Glog, Leptonica y Tesseract. Sin embargo no detectó HDF5, así que  lo modificamos manualmente:

OPenCV HDF5

Marcamos:

  √  OpenCV_DOCS_HAVE_DOT

Le damos a Configure y nos sale una nueva línea en rojo:

OpenCV New option

Ánimo, que es el último paso. Volvemos a darle a Configure y debería de estar todo ok y sin líneas rojas ni errores. Os pongo el link del log de mi último Configure: Log último Configure

Le damos a Generate y creamos la solución. Después, abrimos el proyecto en VisualStudio y en este caso no haría falta que fuera como Administrador si el directorio de instalación no se encuentra en Archivos de Programa. En mi caso vemos que hay 722 proyectos abiertos y cargados.

Visual Studio OpenCV

De nuevo hacemos el mismo proceso, solo que en este caso llevará mucho más tiempo que en anteriores compilaciones.  Compilamos ALL_BUILD en configuración debug y release y al acabar, hacemos lo mismo con INSTALL, los cuales se encientran en la carpeta CMakeTargets. Tened paciencia debido a que llevará varias horas. Por ejemplo, en mi caso ha llevado 4 horas aproximadamente cada compilación de ALL_BUILD. Podría pensarse en algún momento que se encuentra en una especie de bucle infinito debido al log que va saliendo, pero no hay problema, dejad que compile y no paréis el Visual Studio.

Si no hemos tenido ningún error (espero que no, si no comentad) deberíamos tener todo instalado en el directorio que hayamos elegido.

EJEMPLO DE PROGRAMA OPENCV en WINDOWS 10

Llegados hasta aquí comprobemos que no hay ningún problema con la instalación haciendo un pequeño ejemplo, aunque antes tenemos que modificar el Path de Windows para que apunte a los directorios con las librerías dll que usarán nuestros programas.

  • TBB: C:\Program Files\TBB\bin

  • OpenCV: D:\DocsTrabajo\OpenCVInstall\x64\vc16\bin

  • Graphviz: C:\Program Files\Graphviz\bin

  • Qt_DIR: C:\Qt\5.15.2\msvc2019_64\bin

  • gstreamer: C:\Program Files (x86)\gstreamer\1.0\msvc_x86_64\bin

  • zlib: C:\Program Files (x86)\zlib\bin

  • CUDA: C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v11.2

Abrimos el Visual Studio y creamos una solución de consola en C++.

Tenemos que configurar el Visual Studio para decirle donde están las carpetas include y las librerías *.lib. Botón derecho en nuestro proyecto y vamos a propiedades. En Directorios de VC++ elegimos el directorio include de nuestro OpenCV.

Visual Studio Include

Configuramos también el directorio con los archivos .lib.

Visual Studio .lib folder

Además, configuramos el vinculador para decirles las librerías que utilizamos. En el pantallazo que os pongo debajo he puesto todas, pero para el ejemplo de prueba no es necesario. Fijaros que en mi caso estoy con la configuración Debug, de ahí que el nombre de las dependencias acaben en d.

Visual Studio Linker

Copiamos el siguiente código en el archivo cpp creado por el Visual Studio, el cual está basado en el ejemplo de erode y dilation de la página web de OpenCV.

#include «opencv2/imgproc.hpp»
#include «opencv2/highgui.hpp»
#include <iostream>

using namespace cv;
using namespace std;

Mat src, erosion_dst, dilation_dst;

int erosion_elem = 0;
int erosion_size = 0;
int dilation_elem = 0;
int dilation_size = 0;
int const max_elem = 2;
int const max_kernel_size = 21;

void Erosion(int, void*);
void Dilation(int, void*);
Mat ReadData();

int main(){

src = ReadData();

namedWindow(«Erosion Demo», WINDOW_NORMAL);
namedWindow(«Dilation Demo», WINDOW_NORMAL);
moveWindow(«Dilation Demo», src.cols, 0);

createTrackbar(«Element:\n 0: Rect \n 1: Cross \n 2: Ellipse», «Erosion Demo»,
&erosion_elem, max_elem,
Erosion);

createTrackbar(«Kernel size:\n 2n +1», «Erosion Demo»,
&erosion_size, max_kernel_size,
Erosion);

createTrackbar(«Element:\n 0: Rect \n 1: Cross \n 2: Ellipse», «Dilation Demo»,
&dilation_elem, max_elem,
Dilation);

createTrackbar(«Kernel size:\n 2n +1», «Dilation Demo»,
&dilation_size, max_kernel_size,
Dilation);

Erosion(0, 0);
Dilation(0, 0);
waitKey(0);
return 0;

}

void Erosion(int, void*){

int erosion_type = 0;
if (erosion_elem == 0) { erosion_type = MORPH_RECT; }
else if (erosion_elem == 1) { erosion_type = MORPH_CROSS; }
else if (erosion_elem == 2) { erosion_type = MORPH_ELLIPSE; }
Mat element = getStructuringElement(erosion_type,
Size(2 * erosion_size + 1, 2 * erosion_size + 1),
Point(erosion_size, erosion_size));
erode(src, erosion_dst, element);
imshow(«Erosion Demo», erosion_dst);

}

void Dilation(int, void*){

int dilation_type = 0;
if (dilation_elem == 0) { dilation_type = MORPH_RECT; }
else if (dilation_elem == 1) { dilation_type = MORPH_CROSS; }
else if (dilation_elem == 2) { dilation_type = MORPH_ELLIPSE; }
Mat element = getStructuringElement(dilation_type,
Size(2 * dilation_size + 1, 2 * dilation_size + 1),
Point(dilation_size, dilation_size));
dilate(src, dilation_dst, element);
imshow(«Dilation Demo», dilation_dst);

}

Mat ReadData(){

Mat I;

cout << «Read Done.» << endl;
// Read the image file
I = imread(«D:/images/ThumbsUp.jpg», IMREAD_COLOR); // Read the file

// Check for failure
if (I.empty())
{
cout << «Could not open or find the image» << endl;
cin.get(); //wait for any key press
}
else
{
cout << «Loading input image: » << endl;
}
return I;

}

Compilamos nuestro proyecto y ejecutamos el exe, aunque también podemos depurarlo desde el propio Visual Studio. Tenéis que modificar en la función ReadData, línea 84, la ruta de la imagen a vuestro propio archivo. Podéis comprobar que al haber compilado OpenCV con el soporte de Qt, las ventanas mostradas tienen más funcionalidades que si lo hacemos sin dicho soporte.

Erode Dilation demo

Y hasta aquí el tutorial para compilar OpenCV 4.5.2 para Windows 10 con el soporte de múltiples herramientas. Espero que os gustara y que os ayudara. ¿Habéis tenido algún error durante el proceso? ¿Utilizasteis otro tipo de software? ¿Sería necesario añadir más herramientas durante el proceso de compilación? Dejad comentarios para poder aprender todos acerca de las herramientas que nos proporciona OpenCV y aprovechar todo su potencial.

2 comentarios en «OpenCV 4.5.2 en Windows 10»

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *