Compiling VXL with VS 2008

I’ve been working the last days with VXL, it is a collection of libraries for computer vision. It includes numeric, imaging, geometry, streaming and more libraries. When one started looking at the code impresses the amount of work people put into it. Also, it has a lot of good features and it is really easy to use, once you know how to compile it and the projects using it.

I struggle a few days trying to compile VXL itself and then linking the projects. Because of that I want to summarize a few tips to do it smoother.

Compiling VXL on Windows

I will describe the Windows steps, but if you are using other OS you can find some info here.

1. First, you need to install
   • Visual Studio with C++
   • Tortoise SVN
   • CMake
2. First create a folder for the VXL libraries. For example, could be “C:\vxl” or whatever you want. Inside that folder create two more:
   • A sources folder “C:\vxl\vxl,” from now on $VXLSRC.
   • A binary folder “C:\vxl\bin,” from now on $VXLBIN.
3. I download VXL from their site, but I have some trouble because the libraries were bugged. Therefore, I suggest you to use the SVN sources. So, lets check out the latest revision.
   • Right click on $VXLSRC, choose the “SVN Checkout” option.
   • In the “URL of repository” box, type in: https://vxl.svn.sourceforge.net/svnroot/vxl/trunk.
   • In the “Checkout directory” box, the folder path $VXLSRC.
   • In the “Checkout depth“, choose “Fully recursive.”
   • In the “Revision” box, choose “Head revision.”
   • Click “OK.”
   • Tortoise SVN should now download the souce code.
4. Now, we need to prepare the Visual Project using CMake. CMake it is a tool that creates all the dependencies and resolve links necessary to build the sources.
   • Open CMake program (from Start menu).
   • In the “Where is the source” box, browse to $VXLSRC.
   • In the “Where to build the binaries” box, browse to $VXLBIN.
   • Click “Configure” (in bottom left of the window).
   • A window will show up, asking for the type of compiler. Choose the version of Visual Studio you’re using. Stay away from “Win64” option for now.
   • CMake will run a whole bunch of tests to determine the settings of the machine, compilers, packages, etc. The progress is shown in bottom of the window. This may take up to several minutes.
   • Once this is done, a window shows up, with a lot of red rows.
   • Scroll to find “BUILD_VGUI.” If it is unchecked,  check it. Click “Configure” again.
   • Scroll to find “VGUI_USE_MFC” (should be in red). If it is unchecked,  check it. Click “Configure.” If you can’t find this option, that means Microsoft Visual Studio was not installed properly. Ask someone.
   • Now the option “Generate” should be active, click it. CMake will now make all the “Projects” and “Solution” files for Microsoft Visual Studio in the $VXLBIN.
   • We finish with CMake for now, you can close it.
5. Compile VXL code
   • Go to $VXLBIN.
   • Double-click on “vxl.sln.” This will open Microsoft Visual Studio.
   • From top menu, View –> Solution Explorer.
   • Right-click on “ALL_BUILD,” click on “Build.” This will build ALL projects in VXL. You can selectively build individual projects by right-click and “Build” that project, if you only need that one.
   • This process can take a while, up to a couple hours, depending on how fast the machine is.
   • After this is done, VXL is ready to use.

Using VXL on a project

Now that we compiled the libraries we can use them in our projects. There are two ways to use them (1) with CMake to create the project or (2) linking the libraries manually.

1. Using CMake for the project. CMake is a tool that creates the projects and solutions for us. It support projects in Visual Studio.
   • First we should create two folders in the project folder. Similar to the steps when compiling VXL with CMake, one for the sources and one for the binaries, from now on I will call them $PRJSRC and $PRJBIN, respectively.
   • Now, we need to create a configuration file to tell CMake all the requirements we need. I will give here a basic one, for more details you can check here.

     # The name of your project. This will be the name of the solution
     PROJECT( test )
     
     # Automatic setting of the VXL libraries
     FIND_PACKAGE(VXL)
     IF(VXL_FOUND)
       INCLUDE(${VXL_CMAKE_DIR}/UseVXL.cmake)
     ENDIF(VXL_FOUND)
     # Another option is to set the path directly:
     #   SET( VXL_DIR D:\vxl\bin )
     
     # Here you tell to CMake which files to include
     IF( VXL_VGUI_FOUND )
       INCLUDE_DIRECTORIES( ${VXL_VGUI_INCLUDE_DIR} )
       SET( test_sources ${test_sources}
         # Put all your source code here: code and headers
         test.cpp
       )
     ENDIF( VXL_VGUI_FOUND )
     
     # Specify the executable to be built
     ADD_EXECUTABLE( test ${test_sources} )
     
     # Specify any other dependent libraries
     IF( VXL_VGUI_FOUND )
       TARGET_LINK_LIBRARIES( test ${VXL_VGUI_LIBRARIES} )
     ENDIF( VXL_VGUI_FOUND )<code>
     

   • Place the configuration file and all your source code in the $PRJSRC folder.
   • Open CMake and put the sources and destination folders to $PRJSRC and $PRJBIN, respectively (The steps are the same as the VXL compilation).
   • Click “Configure” button. The “Generate” button should be active afterward, then click it.
   • Now you can go to $PRJBIN and compile the project.
2. If you don’t want to use CMake or you cannot use it because you have a project already, you need to include the libraries and link them manually.
   • In Visual Studio Tools–>Options, go to the “Projects and Solutions” option.  Then in that tree under “VC++ Directories” change the option “Show directories for:” and choose “Include files.” Then add the paths
     • $VXLSRC\vcl
     • $VXLSRC\core
     • $VXLBIN\vcl
     • $VXLBIN\core
   • Now, in the same place change the option “Show directories for:” to “Library files” and add $VXLBIN\lib
   • If you are using any non-core library you should add them too. For example, if you are using vsol in contrib/gel then you should add $VXLSRC/contrib/gel.
   • Click “OK.”
   • In the Solution Explorer, right-click to your project and choose “Properties.” Go to Configuration Properties–>Linker
   • Under “General,” in the option “Additional Library Directories” add $VXLBIN\lib\Debug
   • Under “Input,” in the option “Additional Dependencies” add vcl.lib, at least. Then link against all the libraries you used or the ones the compiler complains about. For example, if you use $VXLBIN\vil libraries add vil.lib, or if you use $VXLBIN\vil\algo libraries add vil_algo.lib.
   • Click “OK.”