* Added a stripped version of NLOPT sources as external library, so that the...

 * Added a stripped version of NLOPT sources as external library, so that the registration module can be built right away.
 * Some minor improvements in CMake files

CMakeLists.txt

@@ -18,10 +18,10 @@ OPTION(CAMPVIS_BUILD_CORE           "Build CAMPVis Core"
 OPTION(CAMPVIS_BUILD_MODULES        "Build CAMPVis Modules"                                         ON)
 OPTION(CAMPVIS_BUILD_LIB_TGT        "Build TGT Library"                                             ON)
 OPTION(CAMPVIS_BUILD_LIB_KISSCL     "Build KissCL Library"                                          OFF)
-OPTION(CAMPVIS_BUILD_DOXYGEN        "Build Doxygen Documentation"                                   ON)
+OPTION(CAMPVIS_BUILD_DOXYGEN        "Build Doxygen Documentation"                                   OFF)
 
 OPTION(CAMPVIS_DEPLOY_SHADERS       "Deploy Shader files to binary directory"                       OFF)
-OPTION(CAMPVIS_GROUP_SOURCE_FILES   "Group source files by directory"                               OFF)
+OPTION(CAMPVIS_GROUP_SOURCE_FILES   "Group source files by directory"                               ON)
 
 IF(WIN32)
     OPTION(CAMPVIS_COPY_EXTERNAL_DLLS   "Copy external DLLs to bin directory?"                      ON)

application/CMakeLists.txt

@@ -68,12 +68,11 @@ LIST(APPEND CampvisApplicationDefinitions "-DCAMPVIS_SOURCE_DIR=\"${CampvisHome}
 #
 # Qt related stuff:
 #
-FIND_PACKAGE(Qt4 ${CampvisRequiredQtVersion} REQUIRED QtCore QtGui QtOpenGL)
 QT4_WRAP_CPP(CampvisApplicationMoc ${CampvisApplicationToBeMocced})
 LIST(APPEND CampvisApplicationSources ${CampvisApplicationMoc})
+
 QT4_WRAP_UI(CampvisApplicationFormsHeaders ${CampvisApplicationForms})
 LIST(APPEND CampvisApplicationSources ${CampvisApplicationFormsHeaders})
-INCLUDE(${QT_USE_FILE})
 
 LINK_DIRECTORIES(${CampvisGlobalLinkDirectories} ${CampvisModulesLinkDirectories})
 

cmake/commonconf.cmake

@@ -135,6 +135,8 @@ ENDIF()
  
 # minimum Qt version
 IF(CAMPVIS_BUILD_APPLICATION)
+    FIND_PACKAGE(Qt4 ${CampvisRequiredQtVersion} REQUIRED QtCore QtGui QtOpenGL)
+    INCLUDE(${QT_USE_FILE})
     SET(TGT_WITH_QT true)
     SET(CampvisRequiredQtVersion "4.8")
 ENDIF(CAMPVIS_BUILD_APPLICATION)

ext/tgt/CMakeLists.txt

@@ -16,7 +16,7 @@ ENDIF(TGT_WITH_WMI)
 
 
 # headers
-FILE(GLOB TGT_HEADERS *.h event/*.h navigation/*.h qt/*.h)
+FILE(GLOB TGT_HEADERS *.h event/*.h navigation/*.h)
 
 # sources
 SET(TGT_SOURCES
@@ -71,9 +71,6 @@ SET(TGT_SOURCES
 
 # Qt related stuff:
 IF(TGT_WITH_QT)
-	FIND_PACKAGE(Qt4 ${CampvisRequiredQtVersion} REQUIRED QtCore QtGui QtOpenGL)
-	INCLUDE(${QT_USE_FILE})
-	
 	LIST(APPEND TGT_HEADERS 
 		qt/qtapplication.h
 		qt/qtcanvas.h

modules/registration/ext/nlopt-stripped/AUTHORS

+NLopt was written/packaged by:
+
+Steven G. Johnson <stevenj@alum.mit.edu>
+
+See the subdirectories for the authors of the original nonlinear optimization
+libraries utilized by NLopt.

modules/registration/ext/nlopt-stripped/CMakeLists.txt

+PROJECT(NLOPT)
+
+#==============================================================================
+# NLOPT CMake file
+# 
+# NLopt is a free/open-source library for nonlinear optimization, providing 
+# a common interface for a number of different free optimization routines 
+# available online as well as original implementations of various other 
+# algorithms
+# WEBSITE: http://ab-initio.mit.edu/wiki/index.php/NLopt 
+# AUTHOR: Steven G. Johnson
+#
+# This CMakeLists.txt file was created to compile NLOPT with the CMAKE utility.
+# Benoit Scherrer, 2010 CRL, Harvard Medical School
+# Copyright (c) 2008-2009 Children's Hospital Boston 
+#==============================================================================
+
+CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
+INCLUDE(CheckIncludeFiles)
+INCLUDE(CheckFunctionExists)
+INCLUDE(CheckTypeSize)
+
+
+#==============================================================================
+# COMPILATION CHECKINGS and CONFIGURATION GENERATION
+#==============================================================================
+CHECK_INCLUDE_FILES( unistd.h HAVE_UNISTD_H)
+CHECK_INCLUDE_FILES( string.h HAVE_STRING_H)
+CHECK_INCLUDE_FILES( strings.h HAVE_STRINGS_H)
+CHECK_INCLUDE_FILES( sys/stat.h HAVE_SYS_STAT_H)
+CHECK_INCLUDE_FILES( inttypes.h HAVE_INTTYPES_H)
+CHECK_INCLUDE_FILES( memory.h HAVE_MEMORY_H)
+CHECK_INCLUDE_FILES( stdlib.h HAVE_STDLIB_H)
+CHECK_INCLUDE_FILES( stdint.h HAVE_STDINT_H)
+
+CHECK_INCLUDE_FILES( sys/types.h HAVE_SYS_TYPES_H)
+CHECK_INCLUDE_FILES( sys/types.h HAVE_SYS_TYPES_H)
+CHECK_INCLUDE_FILES( sys/types.h HAVE_SYS_TYPES_H)
+
+CHECK_FUNCTION_EXISTS( isinf HAVE_ISINF)
+CHECK_FUNCTION_EXISTS( isinf HAVE_ISNAN)
+CHECK_FUNCTION_EXISTS( gettimeofday HAVE_GETTIMEOFDAY)
+CHECK_FUNCTION_EXISTS( qsort_r HAVE_QSORT_R)
+CHECK_FUNCTION_EXISTS( time HAVE_TIME)
+CHECK_FUNCTION_EXISTS( copysign HAVE_COPYSIGN)
+
+CHECK_TYPE_SIZE(uint32_t    UINT32_T)
+IF(NOT HAVE_UINT32_T)
+  IF(MSVC)
+    SET(uint32_t "unsigned int")
+    SET(SIZEOF_UNSIGNED_INT 4)
+  ENDIF(MSVC)
+ENDIF(NOT HAVE_UINT32_T)
+
+#==============================================================================
+# CREATE config.h
+#==============================================================================
+
+CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/config.cmake.h.in ${CMAKE_CURRENT_BINARY_DIR}/config.h IMMEDIATE )
+
+
+#==============================================================================
+# INCLUDE DIRECTORIES
+#==============================================================================
+SET(${INCLUDE_DIRECTORIES} "")
+INCLUDE_DIRECTORIES (
+	${CMAKE_CURRENT_SOURCE_DIR}
+        ${CMAKE_CURRENT_BINARY_DIR}
+#	esch
+	stogo 
+	util 
+	direct 
+	cdirect 
+	praxis 
+	luksan 
+	crs 
+	mlsl 
+	mma 
+	cobyla 
+	newuoa 
+	neldermead 
+	auglag 
+	bobyqa 
+	isres 
+	slsqp
+	api   )
+
+
+#==============================================================================
+# nlopt LIBRARY TARGET (SHARED OR STATIC)
+#==============================================================================
+
+SET ( NLOPT_SOURCES   
+#	esch/esch.c
+	direct/DIRect.c direct/direct_wrap.c direct/DIRserial.c direct/DIRsubrout.c direct/direct-internal.h direct/direct.h
+	cdirect/cdirect.c cdirect/hybrid.c cdirect/cdirect.h
+	praxis/praxis.c praxis/praxis.h
+	luksan/plis.c luksan/plip.c luksan/pnet.c luksan/mssubs.c luksan/pssubs.c luksan/luksan.h
+	crs/crs.c crs/crs.h
+	mlsl/mlsl.c mlsl/mlsl.h
+	mma/mma.c mma/mma.h mma/ccsa_quadratic.c
+	cobyla/cobyla.c cobyla/cobyla.h
+	newuoa/newuoa.c newuoa/newuoa.h 
+	neldermead/nldrmd.c neldermead/neldermead.h neldermead/sbplx.c	 
+	auglag/auglag.c auglag/auglag.h
+	bobyqa/bobyqa.c bobyqa/bobyqa.h
+	isres/isres.c isres/isres.h 
+	slsqp/slsqp.c slsqp/slsqp.h 
+	api/general.c api/options.c api/optimize.c api/deprecated.c api/nlopt-internal.h api/nlopt.h api/f77api.c api/f77funcs.h api/f77funcs_.h api/nlopt.hpp api/nlopt-in.hpp
+	util/mt19937ar.c util/sobolseq.c util/soboldata.h util/timer.c util/stop.c util/nlopt-util.h util/redblack.c util/redblack.h util/qsort_r.c util/rescale.c 
+	stogo/global.cc stogo/linalg.cc stogo/local.cc stogo/stogo.cc stogo/tools.cc stogo/global.h stogo/linalg.h stogo/local.h stogo/stogo_config.h stogo/stogo.h stogo/tools.h 
+        )
+
+OPTION(NLOPT_BUILD_SHARED "Build NLOPT as a shared library" OFF )
+
+IF(NLOPT_BUILD_SHARED)
+  ADD_DEFINITIONS(-DNLOPT_DLL)
+  ADD_DEFINITIONS(-DNLOPT_DLL_EXPORT )
+  ADD_LIBRARY (nlopt SHARED ${NLOPT_SOURCES} )
+ELSE(NLOPT_BUILD_SHARED)
+  ADD_LIBRARY (nlopt STATIC ${NLOPT_SOURCES} )
+ENDIF(NLOPT_BUILD_SHARED)
+
+
+

modules/registration/ext/nlopt-stripped/COPYING

+NLopt combines several free/open-source nonlinear optimization
+libraries by various authors.  See the COPYING, COPYRIGHT, and README
+files in the subdirectories for the original copyright and licensing
+information of these packages.
+
+The compiled NLopt library, i.e. the combined work of all of the
+included optimization routines, is licensed under the conjunction of
+all of these licensing terms.  Currently, the most restrictive terms
+are for the code in the "luksan" directory, which is licensed under
+the GNU Lesser General Public License (GNU LGPL), version 2.1 or
+later (see luksan/COPYRIGHT).
+
+That means that the compiled NLopt library is governed by the terms of
+the LGPL.
+
+---------------------------------------------------------------------------
+
+Other portions of NLopt, including any modifications to the abovementioned
+packages, are licensed under the standard "MIT License:"
+
+Copyright (c) 2007-2011 Massachusetts Institute of Technology
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

modules/registration/ext/nlopt-stripped/api/deprecated.c

+/* Copyright (c) 2007-2012 Massachusetts Institute of Technology
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 
+ */
+
+#include "nlopt.h"
+
+/*************************************************************************/
+
+nlopt_algorithm nlopt_local_search_alg_deriv = NLOPT_LD_MMA;
+nlopt_algorithm nlopt_local_search_alg_nonderiv = NLOPT_LN_COBYLA;
+int nlopt_local_search_maxeval = -1; /* no maximum by default */
+
+void
+NLOPT_STDCALL nlopt_get_local_search_algorithm(nlopt_algorithm *deriv,
+				      nlopt_algorithm *nonderiv,
+				      int *maxeval)
+{
+     *deriv = nlopt_local_search_alg_deriv;
+     *nonderiv = nlopt_local_search_alg_nonderiv;
+     *maxeval = nlopt_local_search_maxeval;
+}
+
+void
+NLOPT_STDCALL nlopt_set_local_search_algorithm(nlopt_algorithm deriv,
+				      nlopt_algorithm nonderiv,
+				      int maxeval)
+{
+     nlopt_local_search_alg_deriv = deriv;
+     nlopt_local_search_alg_nonderiv = nonderiv;
+     nlopt_local_search_maxeval = maxeval;
+}
+
+/*************************************************************************/
+
+int nlopt_stochastic_population = 0;
+
+int
+NLOPT_STDCALL nlopt_get_stochastic_population(void) { 
+     return nlopt_stochastic_population; }
+void
+NLOPT_STDCALL nlopt_set_stochastic_population(int pop) { 
+     nlopt_stochastic_population = pop <= 0 ? 0 : (unsigned) pop; }
+
+/*************************************************************************/
+
+nlopt_result
+NLOPT_STDCALL nlopt_minimize_econstrained(
+     nlopt_algorithm algorithm,
+     int n, nlopt_func_old f, void *f_data,
+     int m, nlopt_func_old fc, void *fc_data_, ptrdiff_t fc_datum_size,
+     int p, nlopt_func_old h, void *h_data_, ptrdiff_t h_datum_size,
+     const double *lb, const double *ub, /* bounds */
+     double *x, /* in: initial guess, out: minimizer */
+     double *minf, /* out: minimum */
+     double minf_max, double ftol_rel, double ftol_abs,
+     double xtol_rel, const double *xtol_abs,
+     double htol_rel, double htol_abs,
+     int maxeval, double maxtime)
+{
+     char *fc_data = (char *) fc_data_;
+     char *h_data = (char *) h_data_;
+     nlopt_opt opt;
+     nlopt_result ret;
+     int i;
+
+     if (n < 0 || m < 0 || p < 0) return NLOPT_INVALID_ARGS;
+
+     opt = nlopt_create(algorithm, (unsigned) n);
+     if (!opt) return NLOPT_INVALID_ARGS;
+
+     ret = nlopt_set_min_objective(opt, (nlopt_func) f, f_data);
+     if (ret != NLOPT_SUCCESS) { nlopt_destroy(opt); return ret; }
+
+     for (i = 0; i < m; ++i) {
+	  ret = nlopt_add_inequality_constraint(opt, (nlopt_func) fc, 
+						fc_data + i*fc_datum_size,
+						0.0);
+	  if (ret != NLOPT_SUCCESS) { nlopt_destroy(opt); return ret; }
+     }
+
+     (void) htol_rel; /* unused */
+     for (i = 0; i < p; ++i) {
+	  ret = nlopt_add_equality_constraint(opt, (nlopt_func) h, 
+					      h_data + i*h_datum_size,
+					      htol_abs);
+	  if (ret != NLOPT_SUCCESS) { nlopt_destroy(opt); return ret; }
+     }
+
+     ret = nlopt_set_lower_bounds(opt, lb);
+     if (ret != NLOPT_SUCCESS) { nlopt_destroy(opt); return ret; }
+     ret = nlopt_set_upper_bounds(opt, ub);
+     if (ret != NLOPT_SUCCESS) { nlopt_destroy(opt); return ret; }
+
+     ret = nlopt_set_stopval(opt, minf_max);
+     if (ret != NLOPT_SUCCESS) { nlopt_destroy(opt); return ret; }
+
+     ret = nlopt_set_ftol_rel(opt, ftol_rel);
+     if (ret != NLOPT_SUCCESS) { nlopt_destroy(opt); return ret; }
+     ret = nlopt_set_ftol_abs(opt, ftol_abs);
+     if (ret != NLOPT_SUCCESS) { nlopt_destroy(opt); return ret; }
+
+     ret = nlopt_set_xtol_rel(opt, xtol_rel);
+     if (ret != NLOPT_SUCCESS) { nlopt_destroy(opt); return ret; }
+     if (xtol_abs) ret = nlopt_set_xtol_abs(opt, xtol_abs);
+     if (ret != NLOPT_SUCCESS) { nlopt_destroy(opt); return ret; }
+     
+     ret = nlopt_set_maxeval(opt, maxeval);
+     if (ret != NLOPT_SUCCESS) { nlopt_destroy(opt); return ret; }
+
+     ret = nlopt_set_maxtime(opt, maxtime);
+     if (ret != NLOPT_SUCCESS) { nlopt_destroy(opt); return ret; }
+
+     ret = nlopt_optimize(opt, x, minf);
+
+     nlopt_destroy(opt);
+     return ret;
+}
+
+nlopt_result
+NLOPT_STDCALL nlopt_minimize_constrained(
+     nlopt_algorithm algorithm,
+     int n, nlopt_func_old f, void *f_data,
+     int m, nlopt_func_old fc, void *fc_data, ptrdiff_t fc_datum_size,
+     const double *lb, const double *ub, /* bounds */
+     double *x, /* in: initial guess, out: minimizer */
+     double *minf, /* out: minimum */
+     double minf_max, double ftol_rel, double ftol_abs,
+     double xtol_rel, const double *xtol_abs,
+     int maxeval, double maxtime)
+{
+     return nlopt_minimize_econstrained(
+	  algorithm, n, f, f_data, 
+	  m, fc, fc_data, fc_datum_size, 0, NULL, NULL, 0,
+	  lb, ub, x, minf, minf_max, ftol_rel, ftol_abs,
+	  xtol_rel, xtol_abs, ftol_rel, ftol_abs, maxeval, maxtime);
+}
+
+nlopt_result
+NLOPT_STDCALL nlopt_minimize(
+     nlopt_algorithm algorithm,
+     int n, nlopt_func_old f, void *f_data,
+     const double *lb, const double *ub, /* bounds */
+     double *x, /* in: initial guess, out: minimizer */
+     double *minf, /* out: minimum */
+     double minf_max, double ftol_rel, double ftol_abs,
+     double xtol_rel, const double *xtol_abs,
+     int maxeval, double maxtime)
+{
+     return nlopt_minimize_constrained(
+	  algorithm, n, f, f_data, 0, NULL, NULL, 0,
+	  lb, ub, x, minf, minf_max, ftol_rel, ftol_abs,
+	  xtol_rel, xtol_abs, maxeval, maxtime);
+}

modules/registration/ext/nlopt-stripped/api/f77api.c

+/* Copyright (c) 2007-2012 Massachusetts Institute of Technology
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 
+ */
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "nlopt.h"
+
+/*-----------------------------------------------------------------------*/
+/* wrappers around f77 procedures */
+
+typedef void (*nlopt_f77_func)(double *val, const int *n, const double *x,
+			       double *gradient, const int *need_gradient,
+			       void *func_data);
+
+typedef void (*nlopt_f77_mfunc)(const int *m,
+				double *val, const int *n, const double *x,
+				double *gradient, const int *need_gradient,
+				void *func_data);
+
+typedef struct {
+     nlopt_f77_func f;
+     nlopt_f77_mfunc mf;
+     void *f_data;
+} f77_func_data;
+
+static void *free_f77_func_data(void *p) { free(p); return NULL; }
+static void *dup_f77_func_data(void *p) { 
+     void *pnew = (void*) malloc(sizeof(f77_func_data));
+     if (pnew) memcpy(pnew, p, sizeof(f77_func_data));
+     return pnew;
+}
+
+static double f77_func_wrap_old(int n, const double *x, double *grad, void *data)
+{
+     f77_func_data *d = (f77_func_data *) data;
+     double val;
+     int need_gradient = grad != 0;
+     d->f(&val, &n, x, grad, &need_gradient, d->f_data);
+     return val;
+}
+
+static double f77_func_wrap(unsigned n, const double *x, double *grad, void *data)
+{
+     f77_func_data *d = (f77_func_data *) data;
+     int ni = (int) n;
+     double val;
+     int need_gradient = grad != 0;
+     d->f(&val, &ni, x, grad, &need_gradient, d->f_data);
+     return val;
+}
+
+static void f77_mfunc_wrap(unsigned m, double *result, unsigned n, const double *x, double *grad, void *data)
+{
+     f77_func_data *d = (f77_func_data *) data;
+     int mi = (int) m;
+     int ni = (int) n;
+     int need_gradient = grad != 0;
+     d->mf(&mi, result, &ni, x, grad, &need_gradient, d->f_data);
+}
+
+/*-----------------------------------------------------------------------*/
+
+#define F77_GET(name,NAME,T) void F77_(nlo_get_##name,NLO_GET_##NAME)(T *val, nlopt_opt *opt) { *val = (T) nlopt_get_##name(*opt); }
+#define F77_SET(name,NAME,T) void F77_(nlo_set_##name,NLO_SET_##NAME)(int *ret, nlopt_opt *opt, T *val) { *ret = (int) nlopt_set_##name(*opt, *val); }
+#define F77_GETSET(name,NAME,T) F77_GET(name,NAME,T) F77_SET(name,NAME,T)
+
+#define F77_GETA(name,NAME,T) void F77_(nlo_get_##name,NLO_GET_##NAME)(int *ret, nlopt_opt *opt, T *val) { *ret = (int) nlopt_get_##name(*opt, val); }
+#define F77_SETA(name,NAME,T) void F77_(nlo_set_##name,NLO_SET_##NAME)(int *ret, nlopt_opt *opt, T *val) { *ret = (int) nlopt_set_##name(*opt, val); }
+#define F77_GETSETA(name,NAME,T) F77_GETA(name,NAME,T) F77_SETA(name,NAME,T) F77_SET(name##1,NAME##1,T)
+
+/*-----------------------------------------------------------------------*/
+/* rather than trying to detect the Fortran name-mangling scheme with
+   autoconf, we just include wrappers with all common name-mangling
+   schemes ... this avoids problems and also allows us to work with
+   multiple Fortran compilers on the same machine.  Since the Fortran
+   wrapper functions are so small, the library bloat of including them
+   multiple times is negligible and seems well worth the benefit. */
+
+#  define F77CALL(a, A) F77(a, A)
+
+/* name + underscore is by far the most common (gfortran, g77, Intel, ...) */
+#  define F77(a, A) a ## _
+#  include "f77funcs.h"
+
+/* also include g77 convention of name + double underscore for identifiers
+   containing underscores */
+#  define F77_(a, A) a ## __
+#  include "f77funcs_.h"
+#  undef F77_
+
+/* AIX and HPUX use just the lower-case name */
+#  undef F77
+#  define F77(a, A) a
+#  include "f77funcs.h"
+
+/* Old Cray Unicos, as well as several Windows Fortran compilers
+   (Digital/Compaq/HP Visual Fortran and Intel Fortran) use all-uppercase
+   name */
+
+/* Digital/Compaq/HP Visual Fortran, Intel Fortran.  stdcall attribute
+   is apparently required to adjust for calling conventions (callee
+   pops stack in stdcall).  See also:
+       http://msdn.microsoft.com/library/en-us/vccore98/html/_core_mixed.2d.language_programming.3a_.overview.asp
+*/
+#  undef F77
+#  undef F77CALL
+#  define F77(a, A) NLOPT_STDCALL A
+#  define F77CALL(a, A) A
+#  include "f77funcs.h"

modules/registration/ext/nlopt-stripped/api/f77funcs.h

+/* Copyright (c) 2007-2012 Massachusetts Institute of Technology
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 
+ */
+
+/* Fortran API wrappers, using the F77 macro defined in f77api.c.
+   This header file is #included one or more times from f77api.c
+   in order to define verions of the Fortran API for various compilers. 
+
+   In homage to Fortran 77, we stick with 6-character subroutine names.
+   The return value of the function is converted into the first argument
+   of the subroutine. */
+
+/* nlopt_minimize_constrained */
+void F77(nloptc,NLOPTC)(int *info, 
+			const int *algorithm,
+			const int *n, nlopt_f77_func f, void *f_data,
+			const int *m, nlopt_f77_func fc, 
+			char *fc_data, char *fc_second_datum,
+			const double *lb, const double *ub,
+			double *x, double *minf,
+			const double *minf_max,
+			const double *ftol_rel, const double *ftol_abs,
+			const double *xtol_rel, const double *xtol_abs,
+			const int *have_xtol_abs,
+			const int *maxeval, const double *maxtime)
+{
+     f77_func_data d, *dc;
+     int i;
+
+     d.f = f; d.f_data = f_data;
+     if (*m < 0) { *info = NLOPT_INVALID_ARGS; return; }
+     dc = (f77_func_data *) malloc(sizeof(f77_func_data) * *m);
+     if (*m > 0 && !dc) { *info = NLOPT_OUT_OF_MEMORY; return; }
+     for (i = 0; i < *m; ++i) {
+	  dc[i].f = fc;
+	  dc[i].f_data = fc_data + i * (fc_second_datum - fc_data);
+     }
+
+     *info = nlopt_minimize_constrained((nlopt_algorithm) *algorithm, 
+					*n, f77_func_wrap_old, &d,
+					*m, f77_func_wrap_old, 
+					dc, sizeof(f77_func_data),
+					lb, ub, x, minf,
+					*minf_max, *ftol_rel, *ftol_abs,