Why do I want to compile hugin?

If you want to fiddle with the hugin code, test new features or help squashing bugs, and do all that on Windows, this is the guide for you. Be warned that building hugin on Windows is not a piece of cake, so only try if you know the dark sides with all the development tools involved.

For normal testers it is better to use the binary snapshots we will offer during the preparation period for hugin 0.7. This guide is designed to be a help for people who have expressed interest in build Windows version of the current hugin code on a regular basis.

This guide will describe two ways of building the latest trunk. It does not apply to the hugin code prior to 2007/10/27.

Deciding on the toolchain

Currently, there are two methods for building hugin. Both are based on the CMake build system.

Compilation with Microsoft Visual Studio .NET. MSVC 2003 or later is required. The recommended method is to download MSVC 2008 Express, and install it.

Compilation with MinGW32. This does not require the Microsoft compiler and even allows cross compilation of binaries for windows on a linux machine. Until now, only the cross compilation approach has been tried, but a building on a native system should also be possible.

The following additional programs are also required for building hugin:

For both approaches, the hardest task is the compilation of the libraries required by hugin. This mainly includes wxWidgets, boost, libpano13 and OpenEXR.

Building with Microsoft Visual Studio .Net 2003 (or later)

For simpler installation (and less headaches during building) I have build everything against the older, multithreaded runtime libraries (\MT option), and linked all exectuables statically.

Getting the dependencies

It is tempting to download precompiled libraries from the different projects, and use those. Be prepared that they might have been created with different compiler setting (Especially with a different runtime libraries). This can lead to hard to find and nasty problems and amount to days of depressing work (I speak from experience).

Downloading precompiled dependencies

Easy way, download the libraries I (Pablo d'Angelo) have used from http://hugin.panotools.org/sdk/MSVC/hugin_enblend_sdk_msvc2003_v2. I have uses MSVC 2003 to create these, they might work with newer versions of MSVC, except the boost libraries. I'm sure at least boost will only work with the compiler it has been build with, and thus needs to be recompiled if you use MSVC 2005 or later.

If you using this compiler, you can skip building the dependencies and continue with building hugin itself.

If you are using Visual C++ 7.1 (Visual Studio 2003) or 8.0 (Visual Studio 2005), you can save a lot of time and aggravation by getting precompiled Boost libraries from BoostConsulting. You first download an installer program, which when run lets you choose which library variants you want to install. For Hugin you need the multithreaded static libraries, built for the static Microsoft C runtime with the compiler you intend to use. If you already have a Boost installation, you can just add these libraries to it, otherwise install the Boost headers too.

Windows Boost libraries are named according to version, compiler and MS runtime variant (multi|single thread, static|dll) so take care that the Hugin build uses the right names. Example:

libboost_date_time-vc80-mt-s-1_34_1.lib

prefix 'lib' shows this is a static link library, not the import library for a Boost dll; 'vc80' says built with VC8.0; 'mt-s' built for release version of the Microsoft multithread static C runtime LIBCMT (i.e. with compiler switch '/MT') (the debug version has 'mt-sgd'); '1_34_1' built from Boost version 1.34.1 source.

It may be more reliable to build the wxWidgets libraries with the distributed MSVC projects, as described here. When I used the commandline method several libraries were built wrong, or not at all. -- TKSharpless

I never had trouble using the makefiles, maybe thats a MSVC 2005 issue? -- Pablo d'Angelo

Building boost

Refer to the boost documentation for details, especially Build binaries from source. Download bjam exectable and place it in the boost directory. Open the MSVC Command line prompt located in Start Menu -> Programs Microsoft Visual Studio -> Utilities, change directory to the boost dir and issue

bjam stage --with-thread

This will build the boost thread library.

Building OpenEXR

This is a tricky one, because the MSVC project files have been set up for DLL builds with the \MD runtime, and a custom program is used to prepare the DLLs. For the all static windows binaries, quite some changes to the MSVC project files are needed.

Build according to README_win in ilmbase-1.0.0 but changed the runtime of all projects to MT.

For all projects do:

set each project to static lib

remove OPENEXR_DLL, _USEDLL and *_EXPORTS defines

set runtime to MT

disable SSE2, to generate binaries that run on all platforms

remove the createDLL part of the post-build command, but keep the call to install*.cmd, such as ..\..\..\installIlmImf.cmd $(IntDir)

Apply the same procedure to the openexr-1.6 source code. Here only the IlmImf and IlmImfTest projects are needed by Hugin.
Follow the same process as for IlmBase, but additionally add include path for the zlib library (inside the wxWidget/src/zlib) to the IlmImf project, and wxWidget/libs/_vc/wxzlib.lib to the IlmImfTest linker options. The tests should run without errors.

It is a good idea to create new target configurations, say HuginRelease and HuginDebug, with the Visual Studio Configuration Manager, and apply the above changes to them, so that you don't lose the original project settings. This also makes the Hugin-appropriate libraries easy to find as they will be built in directories named for the configurations. They should be installed in directories named that way, too; the install commands make those directories in the Deploy/... tree, but fail to copy the static libraries there because the dll library names are built into them. However it is easy enough to copy the libs from the build folders by hand. The ilmbase libraries must be in the Deploy tree before IlmImf is built. -- TKSharpless

In this setup, the cmake build system will pick up most of the dependencies automatically. Otherwise the paths to
each dependency will have to specified manually during the following cmake step

Run cmake, select hugin source and build directories. Do not choose the same directories for both source and build.

Press 'Configure

fill out red fields, select appropriate library and include paths, if required. The msgfmt program can be found in the gettext package installed earlier. GNU make is also required, a Win32 port can be downloaded from http://sourceforge.net/projects/unxutils. zlib, jpeg, png and tiff libraries from the wxWidgets build can be reused. Their includes are in wxWidgets/src/(zlib|jpeg|png|tiff), and the libs are in wxWidgets/lib/vclib/wx*.lib

If building is done using an SVN checkout, the SVN revision number needs to be specified manually.

Press Configure

If more warnings and red lines appear, goto 3.

Adjust some compiler settings in the CMAKE_C*_FLAGS entries.

Reduce debug level from \Zl to \Zd (otherwise the debug files become bigger than MSVC can handle).

Once all fields have been filled out, the "Ok" button should be available. Press it and open the generated hugin.sln file with MSVC. Switch to Build Type to Release and start the build (press F7). After quite some time hugin should be build. In order to run hugin, it needs to be installed so that data files are in the right place. This is done by building the INSTALL project. The binaries and all required files will be installed into INSTALL/FILES subdirectory of the build directory specified during the CMake step.

Creating the .msi installer by opening INSTALL/hugin.warsetup with the WarSetup program available from http://warsetup.jgaa.com/ and clicking on the Build button.

Building using MinGW

I have managed to build the older, pre GSoC 2007 version with MinGW, but still having some problems with the new trunk. Once these are resolved, I will provide instructions