OpenCV 3.x: Windows-Installation von C++ und Python für Visual Studio 2017

Diese Anleitung beschreibt die Installation von OpenCV auf Windows für Visual Studio 2017. Dabei liegt der Fokus auf C/C++, jedoch werden auch die Einstellungen für Python betrachtet.

Diese Anleitung wurde auf Windows 10 Home 10.0.14393 und mit Visual Studio 2017 VisualStudio/15.0.0+26228.12 sowie OpenCV 3.3.0 getestet.

Vorab: Auf OneDrive gibt es eine vorkompilierte Version von mir. Die Unterstützung für verschiedene Plattformen (x64, x86, ARM, jeweils für Windows und Linux) und OpenCV-Versionen kann variieren. Wenn ihr selber für eine neue, noch nicht verfügbare Plattform kompiliert habt, könnt ihr gerne einen Pull-Request schreiben. Zusätzlich gibt es auch vorkompilierte Versionen von OpenCV selbst, diese haben jedoch häufig den Nachteil, dass sie nicht die aktuelle Version von Visual Studio oder eine andere Entwicklungsumgebung unterstützen.

Schritt 1: Quellcode herunterladen

Den aktuellsten Quellcode von OpenCV gibt es auf der Github-Seite der Bibliothek (https://github.com/opencv/opencv). Dieser kann dort entweder als Zip-Datei heruntergeladen werden und anschließend entpackt werden oder mit Git heruntergeladen werden. Die letzte stabile Version kann man sich unter https://github.com/opencv/opencv/releases oder unter http://opencv.org/releases.html als Zip herunterladen (immer den Sourcecode) und entpacken. Ich würde euch empfehlen, den Code in den Ordner C:\OpenCV-[Version] zu speichern.

(Anm.: Ihr habt dort auch die Möglichkeit, eine .exe-Datei herunterzuladen. Diese tut nichts anderes, als den Quellcode in einen angegebenen Ordner zu entpacken. Dabei werden auch vorkompilierte Bibliotheken ausgepackt. Wenn ihr die Bibliothek selber mit zusätzlichen Features kompilieren wollt, könnt ihr löschen. Diese ist zudem meist veraltet und nicht mit der jeweils aktuellsten Version von Visual Studio oder anderen IDEs kompatibel.)

Falls ihr den Code mit Git herunterladen und verwalten wollt, so müsst ihr Git unter https://git-scm.com/downloads herunterladen, anschließend die Git-Bash öffnen. Dort navigiert ihr mit

in den Ordner (in der Git Bash werden die Befehle aus der Bash von Linux verwendet), in dem ihr den Code haben wollt und ladet diesen mit dem Befehl

herunter.

Der Ordner, in dem der Sourcecode liegt, wird ab jetzt „[Euer Source-Ordner]“ genannt.

Schritt 2 (optional): Zusatzbibliotheken

Wie ich bereits im Einstiegstutorial zu OpenCV besprochen hatte, unterstützt OpenCV eine Vielzahl von zusäztlichen Bibliotheken, die entweder zusätzliche/verbesserte Funktionalität oder gesteigerte Effizienz versprechen. Alle folgenden Erweiterungen sind optional! Sie können unabhängig voneinander aktiviert oder deaktiviert werden.

1. Python

Python ist natürlich keine Bibliothek, sondern eine Skriptsprache, mit der man ebenfalls OpenCV programmieren kann. Sowohl Python 2.x als auch 3.x sollten problemlos unterstützt werden. In diesem Tutorial werden wir später bei der Makefile-Konfiguration nur Python 3.x betrachten, die Konfiguration für Python 2.x ist aber analog.

Zunächst einmal muss natürlich Python installiert werden. Den Installer bekommt ihr hier (für Windows, Mac OS X und andere Plattformen). Achtet darauf, wo Python installiert wird, das ist nachher noch wichtig.

Danach muss die Mathematikbibliothek numpy installiert. Gebt dafür in der Kommandozeile

ein. Alternativ könnt ihr sie hier herunterladen.

2. Intel Threading Building Blocks (TBB)

Die Intel Threading Building Blocks ist eine von Intel entwickelte C++-Bibliothek zur effizienten Programmierung von Threads zur Nutzung von Mehrkernprozessoren. Herunterladen könnt ihr euch die Bibliothek hier. Dort ladet ihr euch die Datei „[Kryptische Zahlenkombination]oss_win.zip“ herunter. Erstellt dann den Ordner „dep“ (für dependencies, natürlich ist auch ein anderer Name möglich) im OpenCV-Verzeichnis und entpackt die Zip-Datei dorthinein (bei mir ist der Ordner z. B. „C:\OpenCV-3.3.0\sources\dep\tbb2017_20170226oss“).

3. Intel Integrated Performance Primitives (IPP)

Achtung: Diese Bibliothek kostet Geld, und das nicht zu knapp (etwa 200€)!

Auch die IPP ist eine Bibliothek von Intel, die einige Besonderheiten der Intel-Prozessoren für bessere Performance und besseres Multithreading nutzt.

Die Bibliothek ladet ihr hier herunter und entpackt sie in den „dep“-Ordner von gerade eben.

4. Eigen

Eigen ist eine C++-Bibliothek für Lineare Algebra (der Name kommt von den sog. Eigenwerten). OpenCV kann diese Bibliothek teilweise für Optimierungen nutzen. Auch sie ladet ihr einfach hier herunter und entpackt sie dann in den „dep“-Ordner.

5. CUDA

Achtung: CUDA läuft nur auf (bestimmten) GPUs von Nvidia! Dementsprechend lässt sich diese Erweiterung nur auf Computern mit einer unterstützen Grafikkarte von Nvidia installieren und nutzen. Da ich keine solche besitze, kann ich diesen Teil leider nicht testen. Sollte jemand von euch dazu in der Lage sein und Fehler in der Anleitung feststellen, so möge er/sie mir seine/ihre Ergebnisse bitte mitteilen.

Durch CUDA können rechenaufwendige Programmteile in der GPU (Grafikkarte) berechnet werden, die für einige Aufgaben viel besser optimiert ist als eine General Purpose CPU. Durch den Einsatz von CUDA kann sich die Performance locker um einen Faktor 20 oder höher steigern lassen. Der Nachteil ist, dass CUDA – anders als OpenCL – nur auf unterstützten Nvidia-GPUs läuft. Außerdem sieht ein OpenCV-Programm, welches die CUDA-Funktionalität nutzt, ein wenig anders aus, d. h., es ist ein Codeanpassung notwendig, um diesen Performanceboost zu bekommen. Die Mühe lohnt sich aber wirklich. Grund für die Geschwindigkeit ist, dass bei Bilderkennung sehr viele einfache, meist voneinander unabhängige Rechenoperationen ausgeführt werden. Genau dafür sind Grafikkarten, die zwar sehr viele, dafür aber weniger leistungsstarke Prozessorkerne haben, gemacht, da für Computerspiele genau die gleichen Anforderungen bestehen.

Um CUDA zu installieren, wählt ihr hier euren Installer aus. Wichtig ist, dass ihr bei der Installation die volle Installation wählt (dafür „Benutzerdefiniert“ wählen und dann alle Pakete markieren)!

Beim CUDA-Installer "Benutzerdefiniert" auswählen.
Beim CUDA-Installer „Benutzerdefiniert“ auswählen.
Alle Pakete auswählen.
Alle Pakete auswählen.

Schritt 3: Makefile konfigurieren

Nun müssen aus dem Code Bibliotheken erzeugt werden, welche später in Visual Studio eingebunden werden können. Dafür benötigen wir einen C++-Compiler. Visual Studio bringt einen solchen von Haus aus mit.

Wie genau der Sourcecode kompiliert wird, das regelt ein sogenannte Makefile, welche von einem Make-Programm eingelesen wird, welches dann die Kompilation automatisiert. Bei OpenCV wird hierfür CMake (für cross-platform make) eingesetzt. Dieses müsst ihr euch erst installieren. Dafür könnt ihr euch hier den Installer für Windows herunterladen. Ihr könnt die PATH-Variable zwar setzen lassen (das ermöglicht später einen bequemen Zugriff in der Command Line), müsst es aber nicht.

Die Aktivierung von "Add CMake to the system PATH for all/the current users" ist optional.
Die Aktivierung von „Add CMake to the system PATH for all/the current users“ ist optional.

Startet nun die CMake-GUI als Administrator. Ihr werdet durch einen Bildschirm begrüßt, der in etwa so aussieht:

CMake Begrüßungsfenster
Das CMake Begrüßungsfenster

Klickt nun auf „Browse Source…“ und wählt den Ordner mit dem Sourcecode von OpenCV aus (bei mir „C:\OpenCV-3.3.0\sources“). Klickt dann auf „Browse Build…“ und wählt den Ordner aus, in dem ihr die von CMake erzeugten Projektdateien haben wollt (in meinem Fall „C:\OpenCV-3.3.0\build“).

Wählt die entsprechenden Ordner aus.

Klickt anschließend auf „Configure“. Ihr werdet daraufhin gefragt, welchen Generator ihr für das Projekt haben wollt. Da wir das Projekt anschließend mit Visual Studio 2017 kompilieren wollen, wählen wir hier „Visual Studio 15 2017 [Plattform]“ aus (das 15 ist die interne Version von Visual Studio, hier wird wirklich Visual Studio 2017 ausgewählt). [Plattform] gibt an, für welchen Prozessortypen ihr das Projekt erstellen wollt. „Win64“ ist 64-Bit Windows, „ARM“ ist eben ARM (für Tablets oder Smartphones und andere ARM-Geräte), für 32-Bit Windows steht nichts dahinter. Das Konfigurieren dauert eine Weile, weil ggf. fehlende Bibliotheken heruntergeladen werden. Danach sollte es in etwa so aussehen:

Wählt den CMake Generator aus.
Wählt den CMake Generator (hier für 64-Bit Windows) aus.

Sobald ihr auf „Finish“ klickt, liest CMake die Makefiles, die mit OpenCV mitgeliefert werden, ein und erstellt daraus eine GUI zum Konfigurieren der Kompilation. Das kann eine kleine Weile dauern, danach sollte es etwa so aussehen:

CMake hat die Konfiguration geladen.
CMake hat die Konfiguration geladen.

Durch die Aktivierung des Häkchens „Grouped“ bekommt ihr eine bessere Übersicht, in der die Variablen des Makefiles gruppiert sind. Hier habt hier nun die Möglichkeit, die Variablen der Makefile zu verändern. Das sind teilweise einfache booleans, teilweise auch Pfäde zu den Bibliotheken, die ihr einbinden wollt. Sucht nun nach dem Wert „BUILD_opencv_world“ und setzt ihn auf true (Häkchen aktivieren). Dieser Schritt bewirkt, dass alle Teilbibliotheken von OpenCV – das sind ziemlich viele – in einer einzigen vereint werden, der „opencv_world“. Dieser Schritt ist optional, ich würde ihn aber dringend empfehlen, da euch das später viel Tipparbeit erspart. Erst, wenn es an die Auslieferung eures Programms gehen sollte und ihr genau wisst, welche Bibliotheken ihr braucht, ist es sinnvoll, nur diejenigen einzubinden, welche notwendig sind. Dieses Tutorial wird davon ausgehen, dass ihr „BUILD_opencv_world“ aktiviert habt.

Grundsätzlich seid ihr jetzt schon fertig mit der Konfiguration des Projektes. Für diejenigen unter euch, die noch weitere Bibliotheken einbinden wollen, gibt es jetzt wieder einen Abschnitt, den alle anderen überspringen können.

Konfiguration für die Einbindung von weiteren Bibliotheken

Die Makefile ist in der Lage, die von OpenCV unterstützten Bibliotheken größtenteils automatisch zu detektieren und die Variablen entsprechend zu setzen. Misslingt das, wird eine NOT_FOUND-Konstante gesetzt, die wir ersetzen müssen. Wir werden nun durch die wichtigsten Optionen gehen und das Makefile entsprechend konfigurieren.

1. Python

Wollt ihr die Python-Unterstützung kompilieren, dann müsst ihr in der Makefile einige Pfade setzen. Gebt zum Filtern der Variablen in der CMake-Suchleiste „python“ ein.

Konfiguration von Python in CMake.

Alle Pfade und Dateien findet ihr im Installationspfad von Python. Wenn ihr den nicht mehr wisst, öffnet die Python-Konsole und gebt folgendes ein:

Python: Gebe Installationsverzeichnis aus
Python: Gebe Installationsverzeichnis aus

Habt ihr den Hauptfad einmal bestimmt, sind die weiteren Pfade relativ klar. Die packages befinden sich in „Lib\site-packages“, in einem entsprechenden Unterverzeichnis davon befindet sich normalerweise auch numpy. Falls nicht, könnt ihr ihn mit der Eingabe von

in der Python-Konsole herausfinden.

2. Intel Threading Building Blocks (TBB)

Sucht nach der Variablen „WITH_TBB“ und aktiviert sie. Passt auf, dass ihr nicht „BUILD_TBB“ auswählt (wird unter Windows in der x64- und x86-Variante nicht unterstützt, ARM sollte allerdings funktionieren)! Wählt dann wieder „Configure“. Danach sollten die Variablen „TTB_ENV_INCLUDE“, „TBB_ENV_LIB“, „TBB_ENV_LIB_DEBUG“ und „TBB_VER_FILE“ auftauchen (oder ähnlich, das ändert sich ab und zu). Bei jeder Variable könnt ihr einen Pfad bzw. eine Datei auswählen. Klickt dazu auf die drei Punkte und navigiert zu den entsprechenden Verzeichnissen oder Dateien:

  • TBB_ENV_INCLUDE: „[Euer dep-Verzeichnis]/dep/tbbxxxx_xxxxxxxoss/include“
  • TBB_ENV_LIB: „[Euer dep-Verzeichnis]/dep/tbbxxxx_xxxxxxxoss/lib/[arch]/vcxx/tbb.lib“
  • TBB_ENV_LIB_DEBUG: „[Euer dep-Verzeichnis]/dep/tbbxxxx_xxxxxxxoss/lib/[arch]/vcxx/tbb_debug.lib“
  • TBB_VER_FILE: „[Euer dep-Verzeichnis]/dep/tbbxxxx_xxxxxxxoss/include/tbb/tbb_stddef.h“

Wichtig: Wählt nicht den „vcxx_ui“-Ordner aus, darin befinden sich Bibliotheken für Windows Store Apps (für nähere Informationen siehe hier).

„vcxx“ ist im Falle von Visual Studio 2017 „vc14“ (siehe hier für aktuellste Informationen). Für [arch] könnt ihr entweder „ia32“ für die IA-32-Architektur oder „intel64“ für die Intel-64-Architektur auswählen. Bei mir sieht die Konfiguration so aus:

TBB CMake Konfiguration
TBB CMake Konfiguration

3. Intel Integrated Performance Primitives (IPP)

Wie schon gesagt, ist IPP kostenpflichtig. Deshalb habe ich diesen Teil nicht selber getestet und verlasse mich auf die Beschreibungen anderer. Solltet ihr IPP gekauft haben und Fehler in der Beschreibung finden, so bitte ich euch, diese in den Kommentaren mitzuteilen.

Nach der Installation von IPP muss eine Umgebungsvariable namens IPP_ROOT gesetzt werden (evtl. existiert im Installer eine solche Funktion). Danach muss in CMake einfach nur die Option WITH_IPP aktiviert werden.

4. Eigen

WITH_EIGEN muss aktiviert werden, EIGEN_INCLUDE_PATH muss auf den Pfad zur Eigen-Bibliothek gesetzt werden. Dabei ist es wichtig, den Ordner „eigen-eigen-<kryptischer Hash>“ und nicht den darunter liegenden Ordner „Eigen“ auszuwählen.

CMake-Konfiguration für Eigen

5. CUDA

Da ich keine Grafikkarte von Nvidia besitze, mit der ich CUDA testen könnte, kann ich hier leider nur auf die Berichte anderer setzen. Findet ihr Fehler oder besitzt eine Nvidia Grafikkarte, so meldet euch bitte einfach in den Kommentaren.

Auch hier haben alle für CUDA relevanten Einstellungen „CUDA_“ als Präfix. Setzt die entsprechenden Pfade und aktiviert WITH_CUDA.

Normalerweise hat CUDA_SDK_ROOT_DIR den Wert „C:/Program Files/NVIDIA GPU Computing Toolkit/CUDA Tools SDK/vx.x“, CUDA_TOOLKIT_ROOT_DIR den Wert „C:/Program Files/NVDIDA GPU Computing Toolkit/CUDA/vx.x“, wobei „vx.x“ die aktuelle Version ist.

CUDA CMake Konfiguration
CUDA CMake Konfiguration

Schritt 4: Kompilation

Was jetzt noch zu tun bleibt, ist auf den Button „Generate“ zu klicken. Daraufhin werden die erforderlichen Projektmappen für Visual Studio im angegebenen Build-Ordner erstellt. Entweder ihr wechselt im Windows Explorer in das entsprechende Verzeichnis und öffnet die Visual Studio Solution „OpenCV.sln“ mit Visual Studio 2017, oder ihr klickt auf „Open“ in CMake.

Der Build-Ordner, in dem das Ergebnis von CMake liegt.
Wählt die Datei „OpenCV.sln“ aus und öffnet sie in Visual Studio 2017.

Wie ihr seht, besteht diese Solution aus vielen Unterprojekten in verschiedenen Unterordnern. Der einzig wichtige ist der Ordner „CMakeTargets“. Wer sich ein bisschen mit Makefiles auskennt, wird erkennen, dass hier die Targets der Makefile als Projekte auftreten. Standardmäßig ausgewählt ist das Target/Projekt „ALL_BUILD“. Wir wählen „Debug“ aus, klicken rechts auf das Projekt und klicken dann auf „Erstellen“ (bzw. „Build“ in der englischen Version“).

Wählt "Debug" aus, klickt rechts auf das Projekt und klickt dann "Erstellen".
Wählt „Debug“ aus, klickt rechts auf das Projekt und klickt dann „Erstellen“.

Daraufhin werden die Bibliotheken für das Debugging kompiliert. Das kann einige Minuten dauern. Ist der Prozess fertig, findet ihr im Ordner „[Euer Build-Ordner]\lib\Debug“ einige .lib-, .pdb- und .exp-Dateien. Nun stellen wir auf „Release“ um und klicken wieder „Erstellen“, um die Bibliotheken für die Release-Variante zu erstellen. Auch das dauert wieder einige Minuten. Danach ist ein Ordner „[Euer Build-Ordner]\lib\Release“ hinzugekommen, in dem sich ebenfalls Dateien befinden.

Nun kompiliert das Projekt „INSTALL“ ebenfalls sowohl im Debug- als auch im Release-Modus auf die gleiche Weise (das sollte jetzt deutlich schneller gehen). Dadurch wird ein weiterer Ordner „[Euer Build-Ordner]\install“ erzeugt. Je nach ausgewählter Plattform entsteht ein Ordner „x64“, „x86“ oder „ARM“, in dem wiederum ein Ordner „vcxx“ steht (aktuell „vc15“ für Visual Studio 2017). Darin sollte ein „bin“- und ein „lib“-Ordner existieren, die .dll- bzw. .lib-Dateien enthalten (wenn ihr „BUILD_opencv_world“ aktiviert habt, befindet sich hier auch die Datei „opencv_worldxxx[d].dll“ bzw. „opencv_worldxxx[d].lib“), jeweils einmal mit und einmal ohne das Postfix „d“ (für „Debug“). Habt ihr die Python-Option aktiviert, sollte sich im „bin“-Ordner auch ein „python“-Ordner mit einer Datei, die ihr in das Bibliotheksverzeichnis eurer Python-Installation kopieren müsst.

Schritt 5: Visual Studio einrichten

Nun müssen wir Visual Studio einrichten.

Für den folgenden Schritt braucht ihr Administratorrechte. Habt ihr die nicht, schaut etwas weiter unten. Falls ihr eure Anwendung weitergeben wollt, ist der zweite Weg wahrscheinlich ebenfalls der bessere.

Mit Administratorrechten

Zuerst müssen wir das Verzeichnis mit den .dll-Dateien in die PATH-Variable von Windows einbinden. Dafür geht ihr in der (klassischen) Systemsteuerung auf System und Sicherheit -> System -> Erweiterte Systemeinstellungen.

Systemeigenschaften
Systemeigenschaften

Dann klickt ihr auf Umgebungsvariablen. Dort wählt ihr dann Path.

Systemvariablen
Systemvariablen

Dann klickt ihr auf Bearbeiten.

Umgebungsvariable bearbeiten
Umgebungsvariable bearbeiten

Jetzt klickt ihr auf Neu und fügt den Pfad zum bin-Ordner von OpenCV ein, wo sich die .dlls befinden. OK beendet die Sache.

Wenn ihr mit TBB kompiliert habt, müsst ihr außerdem den Pfad zu den .dlls von TBB angeben. Diesen findet ihr in eurem TBB-Ordner (den ihr im dep-Verzeichnis für die Kompilation angelegt habt) und dann im Unterordner „bin\<Prozessorplattform>\<Visual Studio Compiler>“.

Ohne Administratorrechte

Solltet ihr keine Administratorrechte haben, so könnt ihr die .dll-Dateien ins Ausgabeverzeichnis (das Verzeichnis, in dem die .exe-Dateien landen) eures Projekts kopieren. Den Dateipfad findet ihr in der Titelleiste der Konsole.

Wenn ihr mit TBB kompiliert habt, müsst ihr außerdem die passenden TBB-dlls in den Ausgabeordner kopieren. Diese findet ihr normalerweise in eurem TBB-Ordner (den ihr im dep-Verzeichnis für die Kompilation angelegt habt) und dann im Unterordner „bin\<Prozessorplattform>\<Visual Studio Compiler>“. Je nach Konfiguration eures Projekts müsst ihr natürlich die Debug-Version oder die Release-Version kopieren.

Weiter geht es:

Sobald ihr ein Konsolen-Projekt erstellt habt (siehe dazu dieses Tutorial), müsst ihr in die Projekteigenschaften gehen.

Projekteigenschaften aufrufen
Projekteigenschaften aufrufen

Achtet darauf, dass verschiedene Konfigurationen bereitstehen, also die möglichen Kombinationen aus Debug/Release und den verschiedenen Plattformen. Ihr müsst die folgenden Einstellungen für alle möglichen Konfigurationen, die ihr später benutzen wollt, wiederholt treffen.

Ihr klickt nun auf C/C++ -> Allgemein. Bei Zusätzliche Includeverzeichnisse klickt ihr auf Bearbeiten.

Projekteigenschaften, allgemeine C++-Eigenschaften.
Projekteigenschaften, allgemeine C++-Eigenschaften

Dann klickt ihr auf das Ordnersymbol mit dem Stern. Mit dem „…“-Button wählt ihr dann im Dialog den include-Pfad aus, dann auf OK.

Include-Pfad setzen
Include-Pfad setzen

Anschließend müssen wir die allgemeinen Linker-Einstellungen ändern. Dort müsst ihr den Pfad für Zusätzliche Bibliotheksverzeichnisse aufden lib-Ordner von OpenCV stellen.

Allgemeine Linkereinstellungen
Allgemeine Linkereinstellungen

Als letztes muss die Linker-Einstellung Eingabe geändert werden, und zwar die Einstellung Zusätzliche Abhängigkeiten. Abhängig von der Konfiguration zu Debug/Release müsst ihr dort nun „opencv_worldxxx.lib“ oder „opencv_worldxxxd.lib“ eintragen, wobei xxx wieder für die Version steht, im Falle von OpenCV 3.3 steht dort also 330.

Habt ihr mit Eigen kompiliert, und wollt die Eigen-Bibliothek nutzen, dann müsst ihr als zusätzlichen Include-Pfad den Pfad zu den Quelldateien von Eigen angeben. Dies ist normalerweise genau derselbe Pfad, den ihr auch in CMake angegeben habt. Da Eigen nur aus Headern besteht, gibt es keine Bibliotheken u. a. m. zu verlinken.

7. Ende

So, das war es jetzt. Wir sind fertig mit der Einrichtung. Wie es weitergeht, seht ihr in diesem Beitrag, dem ersten Beitrag einer Serie, in der es um OpenCV geht.

3 Gedanken zu „OpenCV 3.x: Windows-Installation von C++ und Python für Visual Studio 2017“

  1. Hallo,
    erstmal wollte ich mich für die ausführliche Anleitung bedanken. Es ist alles sehr gut beschrieben und verständlich erklärt. *Daumen hoch*
    Leider kommt es beim kompilieren zu mehreren Fehlern im Visual Studio mit EIgen:
    Schweregrad Code Beschreibung Projekt Datei Zeile Unterdrückungszustand
    Fehler C1083 Datei (Include) kann nicht geöffnet werden: „Eigen/Core“: No such file or directory opencv_world_FP16 C:\opencv-3.3.0\sources\modules\core\include\opencv2\core\private.hpp 60

    wie du im Tutorial geschrieben hast, habe ich die Eigen***.zip herunter geladen und in den Ordner C:\opencv\dep\ entpackt. danach habe ich wie auf deinem Bild den Pfad in der CMake GUI so mit angegeben:
    C:/opencv-3.3.0/dep/eigen-eigen-5a0156e40feb/Eigen. Den hacken hab ich auch gesetzt. Leider findet er die Bibliothek Core nicht.
    Hast du einen Tipp woran das liegen kann?

    Mit freundlichem Gruß

    Peter

    Antworten
    • Also, ich habe das nochmal nachvollzogen. Du musst wohl einfach nur den Ordner eine Ebene höher angeben, d. h. nicht „…/eigen-eigen-/Eigen“ als Pfad angeben, sondern nur „…/eigen-eigen-„. Ich werde den Fehler im Tutorial verbessern, danke dir.

      Antworten

Schreibe einen Kommentar