En los últimos años, cada vez más desarrolladores de .NET se interesan por la visión por computadora. Ya sea para control de calidad industrial, videovigilancia inteligente o proyectos personales, OpenCV se ha vuelto casi indispensable. Sin embargo, surge un problema real: el ecosistema de C# y .NET, cuando se enfrenta al desarrollo multiplataforma —especialmente en servidores Linux o entornos macOS—, parece no adaptarse bien. El método tradicional de Windows, que consiste en instalar un ejecutable y configurar variables de entorno, no funciona en Linux o Mac. Aquí es donde EmguCV cobra valor: como envoltura .NET de OpenCV, permite a los desarrolladores de C# invocar potentes algoritmos de visión en el mundo multiplataforma de .NET Core/5/6/7+.

Este artículo está dirigido a ingenieros que necesitan desplegar servicios en producción en Linux o prototipar algoritmos de visión en MacBook (incluyendo chips M1/M2). No repetiré viejos tutoriales de Windows, sino que me centraré en tres esquemas de integración de EmguCV que he verificado en proyectos reales y que funcionan en Linux y macOS. Desde el despliegue más cómodo con Docker, hasta la compilación desde fuente para máximo rendimiento, pasando por el enlace flexible con librerías nativas. Cada enfoque tiene su escenario y sus trampas que evitar. Incluiré comandos concretos, fragmentos de configuración y ejemplos de código para guiarte paso a paso, y al final obtendrás una plantilla de código robusta y reutilizable para procesamiento de imágenes multiplataforma.

1. Fundamentos multiplataforma: cómo funciona EmguCV bajo .NET Core

En Windows, EmguCV suele venir como un paquete "runtime" con muchos DLL, y el instalador maneja las rutas de las librerías nativas de OpenCV. Pero en Linux o macOS las reglas cambian por completo. No hay DLL registrados globalmente; la gestión de dependencias de bibliotecas compartidas .so (Linux) o .dylib (Mac) se vuelve crítica. La esencia de EmguCV para .NET Core es una capa administrada (librería C#) que llama a las librerías nativas de OpenCV mediante P/Invoke. Por lo tanto, el núcleo del desarrollo multiplataforma es asegurar que tu aplicación encuentre y cargue correctamente esas librerías nativas en el sistema de destino.

Componentes clave:

• Paquete NuGet Emgu.CV.runtime.*: es el soporte principal multiplataforma. Proporciona librerías nativas de OpenCV precompiladas para diferentes plataformas (por ejemplo, ubuntu.20.04-x64, osx-x64, osx-arm64). Cuando tu proyecto lo referencia, durante la compilación o publicación se copian los archivos nativos correctos al directorio de salida.
• Identificador de tiempo de ejecución (RID): .NET Core usa RID para identificar un sistema operativo y arquitectura específicos (p. ej., linux-x64, osx-arm64). Configurar el RID correctamente es crucial para obtener la versión adecuada de la librería nativa.
• Cargador de librerías nativas: EmguCV internamente tiene un mecanismo que al inicio intenta cargar las librerías desde varias rutas predefinidas (como el directorio raíz de la aplicación o runtimes/{RID}/native). Entender este orden de búsqueda es esencial para resolver el clásico error "DllNotFoundException".

Nota: A partir de EmguCV 4.5, la recomendación oficial es usar el administrador de paquetes NuGet para el despliegue multiplataforma. El antiguo método de Windows (descargar un instalador completo y configurar manualmente) ya no es preferible, e incluso no es viable en sistemas no Windows.

Un error común es pensar que con solo referenciar el paquete NuGet Emgu.CV es suficiente. En realidad, Emgu.CV contiene principalmente código administrado y depende del paquete Emgu.CV.runtime.* correspondiente para proporcionar las librerías nativas. La estructura del proyecto debe ser similar a esta:

<!-- Fragmento de tu .csproj -->
<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net6.0</TargetFramework>
    <!-- Especifica los RIDs; importante para publicar aplicaciones de un solo archivo o asegurar las librerías nativas correctas -->
    <RuntimeIdentifiers>linux-x64;osx-x64;osx-arm64</RuntimeIdentifiers>
  </PropertyGroup>

  <ItemGroup>
    <!-- Librería administrada principal -->
    <PackageReference Include="Emgu.CV" Version="4.8.0" />
    <!-- Según tu plataforma objetivo, elige el paquete runtime correspondiente -->
    <!-- Para publicación multi-destino, puedes usar referencias condicionales o especificar el RID al publicar -->
    <PackageReference Include="Emgu.CV.runtime.ubuntu.20.04-x64" Version="4.8.0" Condition="'$(RuntimeIdentifier)' == 'linux-x64'" />
    <PackageReference Include="Emgu.CV.runtime.osx-arm64" Version="4.8.0" Condition="'$(RuntimeIdentifier)' == 'osx-arm64'" />
  </ItemGroup>
</Project>

2. Enfoque 1: Despliegue con Docker – la solución más elegante para servidores Linux

Si necesitas desplegar un servicio de visión basado en EmguCV en un servidor Linux (por ejemplo, una aplicación ASP.NET Core que proporcione una API de análisis de imágenes), Docker es la opción más recomendable. Resuelve el problema de la consistencia del entorno al encapsular todas las dependencias complejas de librerías nativas dentro de la imagen.

Pasos:

1. Preparar el Dockerfile: partimos de la imagen oficial de .NET runtime de Microsoft, instalamos las dependencias del sistema necesarias para OpenCV y EmguCV.

# Usa la imagen SDK de .NET para compilar la aplicación
FROM mcr.microsoft.com/dotnet/sdk:6.0-focal AS build
WORKDIR /src

# Copia los archivos del proyecto y restaura los paquetes NuGet
COPY *.csproj .
RUN dotnet restore

# Copia el resto del código y compila
COPY . .
RUN dotnet publish -c Release -o /app/publish

# Imagen de runtime
FROM mcr.microsoft.com/dotnet/aspnet:6.0-focal AS runtime
WORKDIR /app

# Instala dependencias del sistema necesarias para OpenCV
RUN apt-get update && apt-get install -y \
    libc6-dev \
    libgdiplus \
    libx11-dev \
    && rm -rf /var/lib/apt/lists/*

COPY --from=build /app/publish .

# Establece la variable de entorno para que EmguCV encuentre las librerías nativas
ENV LD_LIBRARY_PATH=/app/runtimes/linux-x64/native:$LD_LIBRARY_PATH

ENTRYPOINT ["dotnet", "TuApp.dll"]

Notas importantes:

• En el Dockerfile, copiamos la salida de publicación al directorio de trabajo. El paquete runtime de EmguCV ya habrá colocado los archivos .so en runtimes/linux-x64/native.
• La variable de entorno LD_LIBRARY_PATH ayuda al cargador dinámico a encontrar las librerías. Sin embargo, EmguCV moderno también busca en el directorio raíz de la aplicación, así que a menudo no es necesaria; pero si tienes problemas, añadirla es una solución rápida.
• Para aplicaciones que requieran interfaz gráfica (por ejempplo, imshow), necesitarás instalar más dependencias como libgtk-3-dev y configurar un servidor X virtual (Xvfb) si no hay pantalla.

3. Enfoque 2: Compilación desde fuente – máxima personalización y rendimiento

Cuando necesitas características específicas de OpenCV (como módulos adicionales de opencv_contrib) o deseas optimizar las compilaciones para hardware concreto (por ejemplo, instrucciones AVX2, NEON), la compilación desde fuente de OpenCV y EmguCV es la vía a seguir.

Procedimiento básico (Linux, Mac similar):

1. Compilar OpenCV desde fuente con las opciones deseadas.
2. Compilar el wrapper nativo de EmguCV (cvextern) para generar el archivo .so o .dylib correspondiente.
3. Usar la bibliotcea nativa personalizada en tu proyecto .NET, ya sea colocándola en un lugar conocido o configurando la ruta mediante Emgu.CV.CvInvoke.Init().

Ejemplo de comandos para compilar OpenCV con soporte de contrib y habilitar AVX2:

# Clonar OpenCV y contrib
git clone https://github.com/opencv/opencv.git
git clone https://github.com/opencv/opencv_contrib.git
cd opencv
mkdir build && cd build

cmake -D CMAKE_BUILD_TYPE=RELEASE \
      -D CMAKE_INSTALL_PREFIX=/usr/local \
      -D OPENCV_EXTRA_MODULES_PATH=../../opencv_contrib/modules \
      -D ENABLE_AVX2=ON \
      -D BUILD_TIFF=ON \
      -D WITH_TBB=ON \
      -D WITH_OPENGL=ON \
      -D BUILD_opencv_python3=OFF \
      -D BUILD_opencv_java=OFF \
      ..

make -j$(nproc)
sudo make install

Luego, deberás compilar el proyecto cvextern de EmguCV apuntando a tu OpenCV recién instalado. Esto genera una librería nativa (libcvextern.so o libcvextern.dylib) que debes colocar junto a tu aplicación. En tu código C#, puedes forzar la ruta de carga:

// Antes de cualquier llamada a OpenCV, especifica la ruta de las librerías nativas
CvInvoke.Init("/ruta/a/mis/librerias/nativas");

Este enfoque ofrece el máximo control, pero requiere mantenimiento y compilación periódica. No es recomendable si solo necesitas funcionalidades estándar.

4. Enfoque 3: Enlace flexible con librerías nativas precompiladas – equilibrio entre rapidez y control

Entre el Docker (todo empaquetado) y la compilación desde fuente (todo manual), existe un término medio: descargar o generar las librerías nativas de OpenCV para tu plataforma y hacer que EmguCV las cargue sin necesidad de compilar todo desde cero. Esto es útil cuando ya tienes OpenCV instalado en el sistema o cuando quieres usar una versión específica de OpenCV no proporcionada por los paquetes runtime de EmguCV.

Pasos:

1. Obtén las librerías nativas de OpenCV (por ejemplo, desde los repositorios del sistema: apt-get install libopencv-dev en Ubuntu, o desde una compilación previa).
2. Copia los archivos .so (o .dylib) necesarios a un directorio accesible por tu aplicación (por ejemplo, ./native/).
3. Configura EmguCV para que busque en ese directorio usando CvInvoke.Init() o configurando la varible de entorno EMGU_CV_NATIVE_PATH.

Ejemplo de código para cargar desde un directorio personalizado:

// Al inicio del programa
string nativePath = Path.Combine(AppContext.BaseDirectory, "native");
CvInvoke.Init(nativePath);

// Ahora puedes usar EmguCV normalmente
using (var img = new Image<Bgr, byte>(640, 480))
{
    CvInvoke.CvtColor(img, img, ColorConversion.Bgr2Gray);
}

Este método es rápido de configurar y te permite aprovechar librerías nativas ya existentes, pero debes asegurarte de que la versión de OpenCV en esas librerías sea compatible con la versión de EmguCV que estás usando (preferiblemente la misma versión principal). Además, es posible que falten algunos módulos si tu OpenCV se compiló sin ellos.

Resumen comparativo

Elige el enfoque según tus necesidades de portabilidad, rendimiento y tiempo de desarrollo. Todos ellos han sido probados en Linux (x86_64) y macOS (arm64) con .NET 6 y EmguCV 4.8.