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.
- 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.
- 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
Muestro un listado del software de terceros incluido en la compilación. Si pincháis en cada línea os llevará a su apartado correspondiente:
- CUDA Toolkit 11.2
- cuDNN 8.1.1
- Qt 5.15.2
- TBB. Intel Threading Building Blocks. 2021.2.0
- Gstreamer 1.18.3
- Tesseract 5
- Leptonica 1.80.0
- Zlib V1.2.11
- libpng 1.6.37
- libtiff 4.2.0
- libarchive 3.5.1
- GLOG 0.4.0
- GFLAGS 2.2.2
- Gtests 1.10.0
- Doxygen 1.9.1
- Graphviz 2.47.1
- HDF5 1.12.0
- EIGEN 3.3.9
- OPENBLAS 0.3.13
- VTK 9.0.1
- OpenCV 4.5.2
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:
- Instalar los drivers de la tarjeta gráfica, los cuales podemos descargarlos de: https://www.nvidia.es/Download/index.aspx?lang=es
- Instalar el CUDA toolkit para Windows.
- Descarga: https://developer.nvidia.com/cuda-downloads
- 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\
- 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:
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.
- 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í:
Si no la tenéis no habría problema por continuar el proceso así.
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:
Ahora lo hemos corregido y los directorios están modificados:
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.
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
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.
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.
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.
- Doxygen: https://www.doxygen.nl/index.html
- Graphviz: https://graphviz.org/download/
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
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
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.
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.
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
Ungrouped Entries
Dejamos todo como está y comprobamos que localiza los directorios de Eigen así como de VTK.
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
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:
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:
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:
Marcamos:
√ OpenCV_DOCS_HAVE_DOT
Le damos a Configure y nos sale una nueva línea en rojo:
Á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.
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.
Configuramos también el directorio con los archivos .lib.
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.
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.
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.