Repository: tum-vision/online_photometric_calibration
Branch: master
Commit: 3ede3f960ad0
Files: 33
Total size: 366.0 KB

Directory structure:
gitextract_g6ru51pt/

├── .gitignore
├── .gitlab-ci.yml
├── .travis.yml
├── AUTHORS.txt
├── CHANGELOG.md
├── CMakeLists.txt
├── LICENSE.txt
├── README.md
└── src/
    ├── CLI11.hpp
    ├── Database.cpp
    ├── Database.h
    ├── Feature.h
    ├── Frame.h
    ├── GainRobustTracker.cpp
    ├── GainRobustTracker.h
    ├── ImageReader.cpp
    ├── ImageReader.h
    ├── JacobianGenerator.cpp
    ├── JacobianGenerator.h
    ├── NonlinearOptimizer.cpp
    ├── NonlinearOptimizer.h
    ├── OptimizationBlock.cpp
    ├── OptimizationBlock.h
    ├── OptimizedPoint.h
    ├── RapidExposureTimeEstimator.cpp
    ├── RapidExposureTimeEstimator.h
    ├── ResponseModel.h
    ├── StandardIncludes.h
    ├── Tracker.cpp
    ├── Tracker.h
    ├── VignetteModel.cpp
    ├── VignetteModel.h
    └── main.cpp

================================================
FILE CONTENTS
================================================

================================================
FILE: .gitignore
================================================
# IDE files
.idea/*

# Compiled Object files
*.slo
*.lo
*.o
*.obj

# Precompiled Headers
*.gch
*.pch

# Compiled Dynamic libraries
*.so
*.dylib
*.dll

# Fortran module files
*.mod
*.smod

# Compiled Static libraries
*.lai
*.la
*.a
*.lib

# Executables
*.exe
*.out
*.app

# Ignored by Rui
CMakeLists.txt.user*
build/
*/build/
*/bin/
*/lib/
*~
cmake-build-*/


================================================
FILE: .gitlab-ci.yml
================================================
# defaults
image: nikolausdemmel/ubuntu-dev-cv:16.04
variables:
  BUILD_TYPE: Release


# template definition
.compile_template: &compile_definition
  stage: build
  before_script:
    - mkdir -p ccache
    - export CCACHE_BASEDIR=${PWD}
    - export CCACHE_DIR=${PWD}/ccache
  cache:
    paths:
    - ccache/
  script:
    - mkdir build
    - cd build
    - cmake .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE}
    - make -j3


release-16.04:
  <<: *compile_definition
  
debug-16.04:
  variables:
    BUILD_TYPE: Debug
  <<: *compile_definition

clang-16.04:
  variables:
    CC: /usr/bin/clang-5.0
    CXX: /usr/bin/clang++-5.0
  <<: *compile_definition

release-14.04:
  image: nikolausdemmel/ubuntu-dev-cv:14.04
  variables:
    CC: /usr/lib/ccache/gcc
    CXX: /usr/lib/ccache/g++
  <<: *compile_definition


================================================
FILE: .travis.yml
================================================
sudo: required

language: cpp

services:
  - docker

cache: ccache

env:
  global:
    - DOCKER_CONTAINER_NAME=nikolausdemmel/ubuntu-dev-cv-gui
    - CC=/usr/bin/gcc
    - CXX=/usr/bin/g++
    - BUILD_TYPE=Release
matrix:
  include:
  - os: linux
    env: DIST_VERS=16.04 
  - os: linux
    env: DIST_VERS=16.04 CC=/usr/bin/clang-5.0 CXX=/usr/bin/clang++-5.0
  - os: linux
    env: DIST_VERS=16.04 BUILD_TYPE=Debug
  - os: linux
    env: DIST_VERS=14.04
  - os: osx

before_install:
  - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then brew update; fi
  
install: |
  if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then
    docker pull $DOCKER_CONTAINER_NAME:$DIST_VERS
  fi
  if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then
    # upgrade python first, else linking python@2 fails (dependency of opencv@2)
    brew upgrade python
    # removing pip numpy, else installing brew numpy fails (dependency of opencv@2)
    brew install python@2
    /usr/bin/yes | pip uninstall numpy

    # upgrade already installed
    brew upgrade cmake
    # install additional dependencies
    brew install opencv@2 ccache
  fi



script: |
  if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then
    docker run --name ci -it \
        -v ${TRAVIS_BUILD_DIR}:/repo \
        -v $HOME/.ccache:/root/.ccache \
        -e BUILD_TYPE -e CC -e CXX \
        $DOCKER_CONTAINER_NAME:$DIST_VERS \
        /bin/bash -c '
    export PS4='\''+ \e[33;1m($0 @ line $LINENO) \$\e[0m '\'' # quotes must be escaped
    set -e # exit on failure
    set -x # trace for debug
    mkdir build && cd build
    cmake -DCMAKE_BUILD_TYPE=$BUILD_TYPE /repo
    cmake --build .'
  fi
  if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then
    mkdir build && cd build
    cmake -DCMAKE_BUILD_TYPE=$BUILD_TYPE ..
    cmake --build .
  fi


# TODO: try w/o docker, just installing from apt; compare speed.
#jobs:
#  foo:



================================================
FILE: AUTHORS.txt
================================================
Authors ordered by first contribution.

Paul Bergmann <bergmann@in.tum.de>
Rui Wang <wangr@in.tum.de>
Nikolaus Demmel <demmeln@in.tum.de>


================================================
FILE: CHANGELOG.md
================================================
# Changelog

## [0.1.0] - 2018-05-22
### Added
- Initial release


================================================
FILE: CMakeLists.txt
================================================
cmake_minimum_required(VERSION 3.2)
set(PROJECT_NAME online_photometric_calibration)

project(${PROJECT_NAME})

# Set default build type if not specified otherwise.
# See https://cmake.org/pipermail/cmake/2012-May/050243.html
if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
  set(CMAKE_BUILD_TYPE Release CACHE STRING "Choose the type of build." FORCE)
  message(STATUS "Setting build type to '${CMAKE_BUILD_TYPE}' as none was specified.")
  # Set the possible values of build type for cmake-gui
  set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "Debug" "Release"
    "MinSizeRel" "RelWithDebInfo")
endif()

# We need at least C++11
set(CMAKE_CXX_STANDARD 11)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF)

# set march=native unless specified
if(NOT CXX_MARCH)
  set(CXX_MARCH native)
endif()
SET(CMAKE_CXX_FLAGS_RELEASE "-march=${CXX_MARCH} ${CMAKE_CXX_FLAGS_RELEASE}")
SET(CMAKE_CXX_FLAGS_RELWITHDEBINFO  "-march=${CXX_MARCH} ${CMAKE_CXX_FLAGS_RELWITHDEBINFO}")

# warnings
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -Wno-sign-compare")

# Required libraries
if(APPLE)
  # give the homebrew path as hint, since the formula is keg-only
  find_package(OpenCV 2.4 REQUIRED HINTS /usr/local/opt/opencv@2)
else()
  find_package(OpenCV 2.4 REQUIRED)
endif()
find_package(Threads REQUIRED)

# Configure CCache if available (requires cmake 3.4 or newer)
find_program(CCACHE_PROGRAM ccache)
if(CCACHE_PROGRAM)
  message(STATUS "Found ccache: ${CCACHE_PROGRAM}")
  set(CMAKE_C_COMPILER_LAUNCHER   ${CCACHE_PROGRAM})
  set(CMAKE_CXX_COMPILER_LAUNCHER ${CCACHE_PROGRAM})
endif()

# output paths in the build directory
set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)

# include path
include_directories(${PROJECT_SOURCE_DIR}/src)

# Source files
set(ONLINE_CALIB_SOURCE_FILES
  src/Database.cpp
  src/GainRobustTracker.cpp
  src/ImageReader.cpp
  src/JacobianGenerator.cpp
  src/NonlinearOptimizer.cpp
  src/OptimizationBlock.cpp
  src/RapidExposureTimeEstimator.cpp
  src/Tracker.cpp
  src/VignetteModel.cpp
)

# add include files to custom target so they show up in IDEs like
# QtCreator in the project view
file(GLOB_RECURSE _INCLUDE_FILES "src/*.h" "src/*.hpp")
add_custom_target(_include_files_fix_target SOURCES ${_INCLUDE_FILES})

# main library
add_library(online_pcalib SHARED ${ONLINE_CALIB_SOURCE_FILES})
target_link_libraries(online_pcalib
  ${OpenCV_LIBS}
  ${CMAKE_THREAD_LIBS_INIT})

# demo executable for online calibration
add_executable(online_pcalib_demo src/main.cpp)
target_link_libraries(online_pcalib_demo
  online_pcalib)

# install rules
install (TARGETS online_pcalib online_pcalib_demo
  ARCHIVE DESTINATION lib
  LIBRARY DESTINATION lib
  RUNTIME DESTINATION bin)


================================================
FILE: LICENSE.txt
================================================
3-Clause BSD License

Copyright 2017-2018 Paul Bergmann and co-authors (see AUTHORS.txt)

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:

1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.

2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.

3. Neither the name of the copyright holder nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


================================================
FILE: README.md
================================================
# Online Photometric Calibration

Recent direct visual odometry and SLAM algorithms have demonstrated
impressive levels of precision. However, they require a photometric
camera calibration in order to achieve competitive results. Hence, the
respective algorithm cannot be directly applied to an
off-the-shelf-camera or to a video sequence acquired with an unknown
camera. In this work we propose a method for online photometric
calibration which enables to process auto exposure videos with visual
odometry precisions that are on par with those of photometrically
calibrated videos. Our algorithm recovers the exposure times of
consecutive frames, the camera response function, and the attenuation
factors of the sensor irradiance due to vignetting. Gain robust KLT
feature tracks are used to obtain scene point correspondences as input
to a nonlinear optimization framework. We show that our approach can
reliably calibrate arbitrary video sequences by evaluating it on
datasets for which full photometric ground truth is available. We
further show that our calibration can improve the performance of a
state-of-the-art direct visual odometry method that works solely on
pixel intensities, calibrating for photometric parameters in an online
fashion in realtime. For more details please refer to our paper.

If you use this code in your research, we would appreciate if you cite
the respective publication.

**Online Photometric Calibration of Auto Exposure Video for Realtime Visual Odometry and SLAM**
(P. Bergmann, R. Wang, D. Cremers),
*In IEEE Robotics and Automation Letters (RA-L)*, volume 3, 2018.
[[pdf](https://vision.in.tum.de/_media/spezial/bib/bergmann17calibration.pdf)]
[[video](https://youtu.be/nQHMG0c6Iew)]

For more information on photometric calibration, see
https://vision.in.tum.de/research/vslam/photometric-calibration.

**Note:** *This is a preliminary release. You should consider this
research code in beta. All interfaces are subject to change.*

## Install

We support Ubuntu 14.04 and 16.04, and macOS, but it might work on a
variety of other platforms that meet the dependency requirements.

### Dependencies

The main dependencies are cmake 3.2 or later, a C++11 compiler, and
OpenCV 2.4.

#### Ubuntu 14.04

On Ubuntu 14.04 you need to get a more recent version of cmake.

```
sudo add-apt-repository ppa:george-edison55/cmake-3.x
```

Now continue to install dependencies like for Ubuntu 16.04.

#### Ubuntu 16.04

**Required:**

```
sudo apt-get update
sudo apt-get install \
    build-essential \
    g++ \
    cmake \
    libopencv-dev
```

**Optional:**

CCache can help you speed up repeated builds.

*Note:* You need at least cmake version 3.4 for ccache to work
 automatically.

```
sudo apt-get install ccache
```

### macOS

We assume you have installed [Homebrew](https://brew.sh).


**Required:**

```
brew install cmake opencv@2
```

**Optional:**

```
brew install ccache
```

### Compile

Start in the package directory.

```
mkdir build
cd build
cmake ..
make -j4
```

Optionally you can install the built libraries and executables.

```
sudo make install
```


## Usage

### Online calibration

**Example usage:**

Download sequence of the TUMmono VO dataset.

```
SEQ=30
wget http://vision.in.tum.de/mono/dataset/sequence_$SEQ.zip
unzip sequence_$SEQ.zip
unzip -d sequence_$SEQ/images sequence_$SEQ/images.zip
```

Run online calibration.

```
build/bin/online_pcalib_demo -i sequence_$SEQ/images --exposure-gt-file sequence_$SEQ/times.txt
```

*Note:* Currently the implementation is not suitable for
 fisheye-lenses with black borders around the image, which includes
 some of the TUMmono VO dataset sequences as well as the TUM VI
 dataset sequences.

### Batch calibration

Online calibration runs the code in a multithreaded way in parallel on the CPU.
If tracking and backend optimization should be performed sequentially and real time 
performance is not required, the system can be run in batch calibration mode.
For running in batch mode, simply add the command line option

```
  --calibration-mode batch
```

For batch calibration you might want to use the exposure times from the optimization
backend rather than the rapidly estimated exposure times from the frontend. In order 
to extract more keyframes to the backend optimizer, the run_settings parameters have to
be adjusted.

These parameters can be changed by manually setting:

```
  --nr-active-frames INT      Maximum number of frames to be stored in the database.
  --keyframe-spacing INT      Number of frames that keyframes are apart in the backend optimizer.
  --min-keyframes-valid INT   Minimum number of frames a feature has to be tracked to be considered for optimization.
```

### Command line options

```
Photometric Calibration
Usage: online_pcalib_demo [OPTIONS]

Options:
  -h,--help                   Print this help message and exit
  -i,--image-folder TEXT=images
                              Folder with image files to read.
  --start-image-index INT=0   Start reading from this image index.
  --end-image-index INT=-1    Stop reading at this image index.
  --image-width INT=640       Resize image to this width.
  --image-height INT=480      Resize image to this height.
  --exposure-gt-file TEXT=times.txt
                              Textfile containing ground truth exposure times for each frame for visualization.
  --calibration-mode TEXT=online
                              Choose 'online' or 'batch'
  --nr-active-frames INT=200  Maximum number of frames to be stored in the database.
  --keyframe-spacing INT=15   Number of frames that keyframes are apart in the backend optimizer.
  --min-keyframes-valid INT=3 Minimum number of frames a feature has to be tracked to be considered for optimization.
```


## License

This project was originally developed at the [TUM computer vision
group](https://vision.in.tum.de) in 2017 by Paul Bergmann.

It is currently maintained by Paul Bermann,
[Rui Wang](https://vision.in.tum.de/members/wangr) and
[Nikolaus Demmel](https://vision.in.tum.de/members/demmeln). See
[AUTHROS.txt](AUTHORS.txt) for a list of contributors.

This project is available under a BSD 3-Clause license.
See [LICENSE.txt](LICENSE.txt)

Among others, we make use of the following libraries:

 * OpenCV ([BSD](https://opencv.org/license.html))
 * CLI11 ([BSD](https://github.com/CLIUtils/CLI11/blob/master/LICENSE))




================================================
FILE: src/CLI11.hpp
================================================
#pragma once

// CLI11: Version 1.5.3
// Originally designed by Henry Schreiner
// https://github.com/CLIUtils/CLI11
//
// This is a standalone header file generated by MakeSingleHeader.py in CLI11/scripts
// from: v1.5.3
//
// From LICENSE:
//
// CLI11 1.5 Copyright (c) 2017-2018 University of Cincinnati, developed by Henry
// Schreiner under NSF AWARD 1414736. All rights reserved.
// 
// Redistribution and use in source and binary forms of CLI11, with or without
// modification, are permitted provided that the following conditions are met:
// 
// 1. Redistributions of source code must retain the above copyright notice, this
//    list of conditions and the following disclaimer. 
// 2. Redistributions in binary form must reproduce the above copyright notice,
//    this list of conditions and the following disclaimer in the documentation
//    and/or other materials provided with the distribution.
// 3. Neither the name of the copyright holder nor the names of its contributors
//    may be used to endorse or promote products derived from this software without
//    specific prior written permission.
// 
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
// ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


// Standard combined includes:

#include <algorithm>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <istream>
#include <iterator>
#include <locale>
#include <memory>
#include <numeric>
#include <set>
#include <sstream>
#include <stdexcept>
#include <string>
#include <sys/stat.h>
#include <sys/types.h>
#include <tuple>
#include <type_traits>
#include <utility>
#include <vector>


// Verbatim copy from CLI/Optional.hpp:

#ifdef __has_include

#if defined(CLI11_CPP17) && __has_include(<optional>) && \
    defined(__cpp_lib_optional) && !defined(CLI11_STD_OPTIONAL)
#define CLI11_STD_OPTIONAL
#endif

#if defined(CLI11_CPP14) && __has_include(<experimental/optional>) && \
    !defined(CLI11_EXPERIMENTAL_OPTIONAL)
#define CLI11_EXPERIMENTAL_OPTIONAL
#endif

#if __has_include(<boost/optional.hpp>) && !defined(CLI11_BOOST_OPTIONAL)
#include <boost/version.hpp>
#if BOOST_VERSION >= 105800
#define CLI11_BOOST_OPTIONAL
#endif
#endif

#endif

#ifdef CLI11_STD_OPTIONAL
#include <optional>
#endif
#ifdef CLI11_EXPERIMENTAL_OPTIONAL
#include <experimental/optional>
#endif
#ifdef CLI11_BOOST_OPTIONAL
#include <boost/optional.hpp>
#endif


// From CLI/Version.hpp:

namespace CLI {

// Note that all code in CLI11 must be in a namespace, even if it just a define.

#define CLI11_VERSION_MAJOR 1
#define CLI11_VERSION_MINOR 5
#define CLI11_VERSION_PATCH 3
#define CLI11_VERSION "1.5.3"

} // namespace CLI

// From CLI/Macros.hpp:

namespace CLI {

// Note that all code in CLI11 must be in a namespace, even if it just a define.

// The following version macro is very similar to the one in PyBind11

#if !(defined(_MSC_VER) && __cplusplus == 199711L) && !defined(__INTEL_COMPILER)
#if __cplusplus >= 201402L
#define CLI11_CPP14
#if __cplusplus >= 201703L
#define CLI11_CPP17
#if __cplusplus > 201703L
#define CLI11_CPP20
#endif
#endif
#endif
#elif defined(_MSC_VER) && __cplusplus == 199711L
// MSVC sets _MSVC_LANG rather than __cplusplus (supposedly until the standard is fully implemented)
// Unless you use the /Zc:__cplusplus flag on Visual Studio 2017 15.7 Preview 3 or newer
#if _MSVC_LANG >= 201402L
#define CLI11_CPP14
#if _MSVC_LANG > 201402L && _MSC_VER >= 1910
#define CLI11_CPP17
#if __MSVC_LANG > 201703L && _MSC_VER >= 1910
#define CLI11_CPP20
#endif
#endif
#endif
#endif

#if defined(PYBIND11_CPP14)
#define CLI11_DEPRECATED(reason) [[deprecated(reason)]]
#elif defined(_MSC_VER)
#define CLI11_DEPRECATED(reason) __declspec(deprecated(reason))
#else
#define CLI11_DEPRECATED(reason) __attribute__((deprecated(reason)))
#endif

} // namespace CLI

// From CLI/Optional.hpp:

namespace CLI {

#ifdef CLI11_STD_OPTIONAL
template <typename T> std::istream &operator>>(std::istream &in, std::optional<T> &val) {
    T v;
    in >> v;
    val = v;
    return in;
}
#endif

#ifdef CLI11_EXPERIMENTAL_OPTIONAL
template <typename T> std::istream &operator>>(std::istream &in, std::experimental::optional<T> &val) {
    T v;
    in >> v;
    val = v;
    return in;
}
#endif

#ifdef CLI11_BOOST_OPTIONAL
template <typename T> std::istream &operator>>(std::istream &in, boost::optional<T> &val) {
    T v;
    in >> v;
    val = v;
    return in;
}
#endif

// Export the best optional to the CLI namespace
#if defined(CLI11_STD_OPTIONAL)
using std::optional;
#elif defined(CLI11_EXPERIMENTAL_OPTIONAL)
using std::experimental::optional;
#elif defined(CLI11_BOOST_OPTIONAL)
using boost::optional;
#endif

// This is true if any optional is found
#if defined(CLI11_STD_OPTIONAL) || defined(CLI11_EXPERIMENTAL_OPTIONAL) || defined(CLI11_BOOST_OPTIONAL)
#define CLI11_OPTIONAL
#endif

} // namespace CLI

// From CLI/StringTools.hpp:

namespace CLI {
namespace detail {

// Based on http://stackoverflow.com/questions/236129/split-a-string-in-c
/// Split a string by a delim
inline std::vector<std::string> split(const std::string &s, char delim) {
    std::vector<std::string> elems;
    // Check to see if empty string, give consistent result
    if(s.empty())
        elems.emplace_back("");
    else {
        std::stringstream ss;
        ss.str(s);
        std::string item;
        while(std::getline(ss, item, delim)) {
            elems.push_back(item);
        }
    }
    return elems;
}

/// Simple function to join a string
template <typename T> std::string join(const T &v, std::string delim = ",") {
    std::ostringstream s;
    size_t start = 0;
    for(const auto &i : v) {
        if(start++ > 0)
            s << delim;
        s << i;
    }
    return s.str();
}

/// Join a string in reverse order
template <typename T> std::string rjoin(const T &v, std::string delim = ",") {
    std::ostringstream s;
    for(size_t start = 0; start < v.size(); start++) {
        if(start > 0)
            s << delim;
        s << v[v.size() - start - 1];
    }
    return s.str();
}

// Based roughly on http://stackoverflow.com/questions/25829143/c-trim-whitespace-from-a-string

/// Trim whitespace from left of string
inline std::string &ltrim(std::string &str) {
    auto it = std::find_if(str.begin(), str.end(), [](char ch) { return !std::isspace<char>(ch, std::locale()); });
    str.erase(str.begin(), it);
    return str;
}

/// Trim anything from left of string
inline std::string &ltrim(std::string &str, const std::string &filter) {
    auto it = std::find_if(str.begin(), str.end(), [&filter](char ch) { return filter.find(ch) == std::string::npos; });
    str.erase(str.begin(), it);
    return str;
}

/// Trim whitespace from right of string
inline std::string &rtrim(std::string &str) {
    auto it = std::find_if(str.rbegin(), str.rend(), [](char ch) { return !std::isspace<char>(ch, std::locale()); });
    str.erase(it.base(), str.end());
    return str;
}

/// Trim anything from right of string
inline std::string &rtrim(std::string &str, const std::string &filter) {
    auto it =
        std::find_if(str.rbegin(), str.rend(), [&filter](char ch) { return filter.find(ch) == std::string::npos; });
    str.erase(it.base(), str.end());
    return str;
}

/// Trim whitespace from string
inline std::string &trim(std::string &str) { return ltrim(rtrim(str)); }

/// Trim anything from string
inline std::string &trim(std::string &str, const std::string filter) { return ltrim(rtrim(str, filter), filter); }

/// Make a copy of the string and then trim it
inline std::string trim_copy(const std::string &str) {
    std::string s = str;
    return trim(s);
}

/// Make a copy of the string and then trim it, any filter string can be used (any char in string is filtered)
inline std::string trim_copy(const std::string &str, const std::string &filter) {
    std::string s = str;
    return trim(s, filter);
}
/// Print a two part "help" string
inline void format_help(std::stringstream &out, std::string name, std::string description, size_t wid) {
    name = "  " + name;
    out << std::setw(static_cast<int>(wid)) << std::left << name;
    if(!description.empty()) {
        if(name.length() >= wid)
            out << std::endl << std::setw(static_cast<int>(wid)) << "";
        out << description;
    }
    out << std::endl;
}

/// Verify the first character of an option
template <typename T> bool valid_first_char(T c) { return std::isalpha(c, std::locale()) || c == '_'; }

/// Verify following characters of an option
template <typename T> bool valid_later_char(T c) {
    return std::isalnum(c, std::locale()) || c == '_' || c == '.' || c == '-';
}

/// Verify an option name
inline bool valid_name_string(const std::string &str) {
    if(str.empty() || !valid_first_char(str[0]))
        return false;
    for(auto c : str.substr(1))
        if(!valid_later_char(c))
            return false;
    return true;
}

/// Return a lower case version of a string
inline std::string to_lower(std::string str) {
    std::transform(std::begin(str), std::end(str), std::begin(str), [](const std::string::value_type &x) {
        return std::tolower(x, std::locale());
    });
    return str;
}

/// Split a string '"one two" "three"' into 'one two', 'three'
inline std::vector<std::string> split_up(std::string str) {

    std::vector<char> delims = {'\'', '\"'};
    auto find_ws = [](char ch) { return std::isspace<char>(ch, std::locale()); };
    trim(str);

    std::vector<std::string> output;

    while(!str.empty()) {
        if(str[0] == '\'') {
            auto end = str.find('\'', 1);
            if(end != std::string::npos) {
                output.push_back(str.substr(1, end - 1));
                str = str.substr(end + 1);
            } else {
                output.push_back(str.substr(1));
                str = "";
            }
        } else if(str[0] == '\"') {
            auto end = str.find('\"', 1);
            if(end != std::string::npos) {
                output.push_back(str.substr(1, end - 1));
                str = str.substr(end + 1);
            } else {
                output.push_back(str.substr(1));
                str = "";
            }

        } else {
            auto it = std::find_if(std::begin(str), std::end(str), find_ws);
            if(it != std::end(str)) {
                std::string value = std::string(str.begin(), it);
                output.push_back(value);
                str = std::string(it, str.end());
            } else {
                output.push_back(str);
                str = "";
            }
        }
        trim(str);
    }

    return output;
}

/// Add a leader to the beginning of all new lines (nothing is added
/// at the start of the first line). `"; "` would be for ini files
///
/// Can't use Regex, or this would be a subs.
inline std::string fix_newlines(std::string leader, std::string input) {
    std::string::size_type n = 0;
    while(n != std::string::npos && n < input.size()) {
        n = input.find('\n', n);
        if(n != std::string::npos) {
            input = input.substr(0, n + 1) + leader + input.substr(n + 1);
            n += leader.size();
        }
    }
    return input;
}

} // namespace detail
} // namespace CLI

// From CLI/Error.hpp:

namespace CLI {

// Use one of these on all error classes
#define CLI11_ERROR_DEF(parent, name)                                                                                  \
  protected:                                                                                                           \
    name(std::string name, std::string msg, int exit_code) : parent(std::move(name), std::move(msg), exit_code) {}     \
    name(std::string name, std::string msg, ExitCodes exit_code)                                                       \
        : parent(std::move(name), std::move(msg), exit_code) {}                                                        \
                                                                                                                       \
  public:                                                                                                              \
    name(std::string msg, ExitCodes exit_code) : parent(#name, std::move(msg), exit_code) {}                           \
    name(std::string msg, int exit_code) : parent(#name, std::move(msg), exit_code) {}

// This is added after the one above if a class is used directly and builds its own message
#define CLI11_ERROR_SIMPLE(name)                                                                                       \
    explicit name(std::string msg) : name(#name, msg, ExitCodes::name) {}

/// These codes are part of every error in CLI. They can be obtained from e using e.exit_code or as a quick shortcut,
/// int values from e.get_error_code().
enum class ExitCodes {
    Success = 0,
    IncorrectConstruction = 100,
    BadNameString,
    OptionAlreadyAdded,
    FileError,
    ConversionError,
    ValidationError,
    RequiredError,
    RequiresError,
    ExcludesError,
    ExtrasError,
    INIError,
    InvalidError,
    HorribleError,
    OptionNotFound,
    ArgumentMismatch,
    BaseClass = 127
};

// Error definitions

/// @defgroup error_group Errors
/// @brief Errors thrown by CLI11
///
/// These are the errors that can be thrown. Some of them, like CLI::Success, are not really errors.
/// @{

/// All errors derive from this one
class Error : public std::runtime_error {
    int exit_code;
    std::string name{"Error"};

  public:
    int get_exit_code() const { return exit_code; }

    std::string get_name() const { return name; }

    Error(std::string name, std::string msg, int exit_code = static_cast<int>(ExitCodes::BaseClass))
        : runtime_error(msg), exit_code(exit_code), name(std::move(name)) {}

    Error(std::string name, std::string msg, ExitCodes exit_code) : Error(name, msg, static_cast<int>(exit_code)) {}
};

// Note: Using Error::Error constructors does not work on GCC 4.7

/// Construction errors (not in parsing)
class ConstructionError : public Error {
    CLI11_ERROR_DEF(Error, ConstructionError)
};

/// Thrown when an option is set to conflicting values (non-vector and multi args, for example)
class IncorrectConstruction : public ConstructionError {
    CLI11_ERROR_DEF(ConstructionError, IncorrectConstruction)
    CLI11_ERROR_SIMPLE(IncorrectConstruction)
    static IncorrectConstruction PositionalFlag(std::string name) {
        return IncorrectConstruction(name + ": Flags cannot be positional");
    }
    static IncorrectConstruction Set0Opt(std::string name) {
        return IncorrectConstruction(name + ": Cannot set 0 expected, use a flag instead");
    }
    static IncorrectConstruction SetFlag(std::string name) {
        return IncorrectConstruction(name + ": Cannot set an expected number for flags");
    }
    static IncorrectConstruction ChangeNotVector(std::string name) {
        return IncorrectConstruction(name + ": You can only change the expected arguments for vectors");
    }
    static IncorrectConstruction AfterMultiOpt(std::string name) {
        return IncorrectConstruction(
            name + ": You can't change expected arguments after you've changed the multi option policy!");
    }
    static IncorrectConstruction MissingOption(std::string name) {
        return IncorrectConstruction("Option " + name + " is not defined");
    }
    static IncorrectConstruction MultiOptionPolicy(std::string name) {
        return IncorrectConstruction(name + ": multi_option_policy only works for flags and exact value options");
    }
};

/// Thrown on construction of a bad name
class BadNameString : public ConstructionError {
    CLI11_ERROR_DEF(ConstructionError, BadNameString)
    CLI11_ERROR_SIMPLE(BadNameString)
    static BadNameString OneCharName(std::string name) { return BadNameString("Invalid one char name: " + name); }
    static BadNameString BadLongName(std::string name) { return BadNameString("Bad long name: " + name); }
    static BadNameString DashesOnly(std::string name) {
        return BadNameString("Must have a name, not just dashes: " + name);
    }
    static BadNameString MultiPositionalNames(std::string name) {
        return BadNameString("Only one positional name allowed, remove: " + name);
    }
};

/// Thrown when an option already exists
class OptionAlreadyAdded : public ConstructionError {
    CLI11_ERROR_DEF(ConstructionError, OptionAlreadyAdded)
    explicit OptionAlreadyAdded(std::string name)
        : OptionAlreadyAdded(name + " is already added", ExitCodes::OptionAlreadyAdded) {}
    static OptionAlreadyAdded Requires(std::string name, std::string other) {
        return OptionAlreadyAdded(name + " requires " + other, ExitCodes::OptionAlreadyAdded);
    }
    static OptionAlreadyAdded Excludes(std::string name, std::string other) {
        return OptionAlreadyAdded(name + " excludes " + other, ExitCodes::OptionAlreadyAdded);
    }
};

// Parsing errors

/// Anything that can error in Parse
class ParseError : public Error {
    CLI11_ERROR_DEF(Error, ParseError)
};

// Not really "errors"

/// This is a successful completion on parsing, supposed to exit
class Success : public ParseError {
    CLI11_ERROR_DEF(ParseError, Success)
    Success() : Success("Successfully completed, should be caught and quit", ExitCodes::Success) {}
};

/// -h or --help on command line
class CallForHelp : public ParseError {
    CLI11_ERROR_DEF(ParseError, CallForHelp)
    CallForHelp() : CallForHelp("This should be caught in your main function, see examples", ExitCodes::Success) {}
};

/// Does not output a diagnostic in CLI11_PARSE, but allows to return from main() with a specific error code.
class RuntimeError : public ParseError {
    CLI11_ERROR_DEF(ParseError, RuntimeError)
    explicit RuntimeError(int exit_code = 1) : RuntimeError("Runtime error", exit_code) {}
};

/// Thrown when parsing an INI file and it is missing
class FileError : public ParseError {
    CLI11_ERROR_DEF(ParseError, FileError)
    CLI11_ERROR_SIMPLE(FileError)
    static FileError Missing(std::string name) { return FileError(name + " was not readable (missing?)"); }
};

/// Thrown when conversion call back fails, such as when an int fails to coerce to a string
class ConversionError : public ParseError {
    CLI11_ERROR_DEF(ParseError, ConversionError)
    CLI11_ERROR_SIMPLE(ConversionError)
    ConversionError(std::string member, std::string name)
        : ConversionError("The value " + member + " is not an allowed value for " + name) {}
    ConversionError(std::string name, std::vector<std::string> results)
        : ConversionError("Could not convert: " + name + " = " + detail::join(results)) {}
    static ConversionError TooManyInputsFlag(std::string name) {
        return ConversionError(name + ": too many inputs for a flag");
    }
    static ConversionError TrueFalse(std::string name) {
        return ConversionError(name + ": Should be true/false or a number");
    }
};

/// Thrown when validation of results fails
class ValidationError : public ParseError {
    CLI11_ERROR_DEF(ParseError, ValidationError)
    CLI11_ERROR_SIMPLE(ValidationError)
    explicit ValidationError(std::string name, std::string msg) : ValidationError(name + ": " + msg) {}
};

/// Thrown when a required option is missing
class RequiredError : public ParseError {
    CLI11_ERROR_DEF(ParseError, RequiredError)
    explicit RequiredError(std::string name) : RequiredError(name + " is required", ExitCodes::RequiredError) {}
    static RequiredError Subcommand(size_t min_subcom) {
        if(min_subcom == 1)
            return RequiredError("A subcommand");
        else
            return RequiredError("Requires at least " + std::to_string(min_subcom) + " subcommands",
                                 ExitCodes::RequiredError);
    }
};

/// Thrown when the wrong number of arguments has been received
class ArgumentMismatch : public ParseError {
    CLI11_ERROR_DEF(ParseError, ArgumentMismatch)
    CLI11_ERROR_SIMPLE(ArgumentMismatch)
    ArgumentMismatch(std::string name, int expected, size_t recieved)
        : ArgumentMismatch(expected > 0 ? ("Expected exactly " + std::to_string(expected) + " arguments to " + name +
                                           ", got " + std::to_string(recieved))
                                        : ("Expected at least " + std::to_string(-expected) + " arguments to " + name +
                                           ", got " + std::to_string(recieved)),
                           ExitCodes::ArgumentMismatch) {}

    static ArgumentMismatch AtLeast(std::string name, int num) {
        return ArgumentMismatch(name + ": At least " + std::to_string(num) + " required");
    }
    static ArgumentMismatch TypedAtLeast(std::string name, int num, std::string type) {
        return ArgumentMismatch(name + ": " + std::to_string(num) + " required " + type + " missing");
    }
};

/// Thrown when a requires option is missing
class RequiresError : public ParseError {
    CLI11_ERROR_DEF(ParseError, RequiresError)
    RequiresError(std::string curname, std::string subname)
        : RequiresError(curname + " requires " + subname, ExitCodes::RequiresError) {}
};

/// Thrown when an excludes option is present
class ExcludesError : public ParseError {
    CLI11_ERROR_DEF(ParseError, ExcludesError)
    ExcludesError(std::string curname, std::string subname)
        : ExcludesError(curname + " excludes " + subname, ExitCodes::ExcludesError) {}
};

/// Thrown when too many positionals or options are found
class ExtrasError : public ParseError {
    CLI11_ERROR_DEF(ParseError, ExtrasError)
    explicit ExtrasError(std::vector<std::string> args)
        : ExtrasError((args.size() > 1 ? "The following arguments were not expected: "
                                       : "The following argument was not expected: ") +
                          detail::rjoin(args, " "),
                      ExitCodes::ExtrasError) {}
};

/// Thrown when extra values are found in an INI file
class INIError : public ParseError {
    CLI11_ERROR_DEF(ParseError, INIError)
    CLI11_ERROR_SIMPLE(INIError)
    static INIError Extras(std::string item) { return INIError("INI was not able to parse " + item); }
    static INIError NotConfigurable(std::string item) {
        return INIError(item + ": This option is not allowed in a configuration file");
    }
};

/// Thrown when validation fails before parsing
class InvalidError : public ParseError {
    CLI11_ERROR_DEF(ParseError, InvalidError)
    explicit InvalidError(std::string name)
        : InvalidError(name + ": Too many positional arguments with unlimited expected args", ExitCodes::InvalidError) {
    }
};

/// This is just a safety check to verify selection and parsing match - you should not ever see it
/// Strings are directly added to this error, but again, it should never be seen.
class HorribleError : public ParseError {
    CLI11_ERROR_DEF(ParseError, HorribleError)
    CLI11_ERROR_SIMPLE(HorribleError)
};

// After parsing

/// Thrown when counting a non-existent option
class OptionNotFound : public Error {
    CLI11_ERROR_DEF(Error, OptionNotFound)
    explicit OptionNotFound(std::string name) : OptionNotFound(name + " not found", ExitCodes::OptionNotFound) {}
};

/// @}

} // namespace CLI

// From CLI/TypeTools.hpp:

namespace CLI {

// Type tools

// We could check to see if C++14 is being used, but it does not hurt to redefine this
// (even Google does this: https://github.com/google/skia/blob/master/include/private/SkTLogic.h)
// It is not in the std namespace anyway, so no harm done.

template <bool B, class T = void> using enable_if_t = typename std::enable_if<B, T>::type;

template <typename T> struct is_vector { static const bool value = false; };

template <class T, class A> struct is_vector<std::vector<T, A>> { static bool const value = true; };

template <typename T> struct is_bool { static const bool value = false; };

template <> struct is_bool<bool> { static bool const value = true; };

namespace detail {
// Based generally on https://rmf.io/cxx11/almost-static-if
/// Simple empty scoped class
enum class enabler {};

/// An instance to use in EnableIf
constexpr enabler dummy = {};

// Type name print

/// Was going to be based on
///  http://stackoverflow.com/questions/1055452/c-get-name-of-type-in-template
/// But this is cleaner and works better in this case

template <typename T,
          enable_if_t<std::is_integral<T>::value && std::is_signed<T>::value, detail::enabler> = detail::dummy>
constexpr const char *type_name() {
    return "INT";
}

template <typename T,
          enable_if_t<std::is_integral<T>::value && std::is_unsigned<T>::value, detail::enabler> = detail::dummy>
constexpr const char *type_name() {
    return "UINT";
}

template <typename T, enable_if_t<std::is_floating_point<T>::value, detail::enabler> = detail::dummy>
constexpr const char *type_name() {
    return "FLOAT";
}

/// This one should not be used, since vector types print the internal type
template <typename T, enable_if_t<is_vector<T>::value, detail::enabler> = detail::dummy>
constexpr const char *type_name() {
    return "VECTOR";
}

template <typename T,
          enable_if_t<!std::is_floating_point<T>::value && !std::is_integral<T>::value && !is_vector<T>::value,
                      detail::enabler> = detail::dummy>
constexpr const char *type_name() {
    return "TEXT";
}

// Lexical cast

/// Signed integers / enums
template <typename T,
          enable_if_t<(std::is_integral<T>::value && std::is_signed<T>::value), detail::enabler> = detail::dummy>
bool lexical_cast(std::string input, T &output) {
    try {
        size_t n = 0;
        long long output_ll = std::stoll(input, &n, 0);
        output = static_cast<T>(output_ll);
        return n == input.size() && static_cast<long long>(output) == output_ll;
    } catch(const std::invalid_argument &) {
        return false;
    } catch(const std::out_of_range &) {
        return false;
    }
}

/// Unsigned integers
template <typename T,
          enable_if_t<std::is_integral<T>::value && std::is_unsigned<T>::value, detail::enabler> = detail::dummy>
bool lexical_cast(std::string input, T &output) {
    if(!input.empty() && input.front() == '-')
        return false; // std::stoull happily converts negative values to junk without any errors.

    try {
        size_t n = 0;
        unsigned long long output_ll = std::stoull(input, &n, 0);
        output = static_cast<T>(output_ll);
        return n == input.size() && static_cast<unsigned long long>(output) == output_ll;
    } catch(const std::invalid_argument &) {
        return false;
    } catch(const std::out_of_range &) {
        return false;
    }
}

/// Floats
template <typename T, enable_if_t<std::is_floating_point<T>::value, detail::enabler> = detail::dummy>
bool lexical_cast(std::string input, T &output) {
    try {
        size_t n = 0;
        output = static_cast<T>(std::stold(input, &n));
        return n == input.size();
    } catch(const std::invalid_argument &) {
        return false;
    } catch(const std::out_of_range &) {
        return false;
    }
}

/// String and similar
template <typename T,
          enable_if_t<!std::is_floating_point<T>::value && !std::is_integral<T>::value &&
                          std::is_assignable<T &, std::string>::value,
                      detail::enabler> = detail::dummy>
bool lexical_cast(std::string input, T &output) {
    output = input;
    return true;
}

/// Non-string parsable
template <typename T,
          enable_if_t<!std::is_floating_point<T>::value && !std::is_integral<T>::value &&
                          !std::is_assignable<T &, std::string>::value,
                      detail::enabler> = detail::dummy>
bool lexical_cast(std::string input, T &output) {
    std::istringstream is;

    is.str(input);
    is >> output;
    return !is.fail() && !is.rdbuf()->in_avail();
}

} // namespace detail
} // namespace CLI

// From CLI/Split.hpp:

namespace CLI {
namespace detail {

// Returns false if not a short option. Otherwise, sets opt name and rest and returns true
inline bool split_short(const std::string &current, std::string &name, std::string &rest) {
    if(current.size() > 1 && current[0] == '-' && valid_first_char(current[1])) {
        name = current.substr(1, 1);
        rest = current.substr(2);
        return true;
    } else
        return false;
}

// Returns false if not a long option. Otherwise, sets opt name and other side of = and returns true
inline bool split_long(const std::string &current, std::string &name, std::string &value) {
    if(current.size() > 2 && current.substr(0, 2) == "--" && valid_first_char(current[2])) {
        auto loc = current.find("=");
        if(loc != std::string::npos) {
            name = current.substr(2, loc - 2);
            value = current.substr(loc + 1);
        } else {
            name = current.substr(2);
            value = "";
        }
        return true;
    } else
        return false;
}

// Splits a string into multiple long and short names
inline std::vector<std::string> split_names(std::string current) {
    std::vector<std::string> output;
    size_t val;
    while((val = current.find(",")) != std::string::npos) {
        output.push_back(trim_copy(current.substr(0, val)));
        current = current.substr(val + 1);
    }
    output.push_back(trim_copy(current));
    return output;
}

/// Get a vector of short names, one of long names, and a single name
inline std::tuple<std::vector<std::string>, std::vector<std::string>, std::string>
get_names(const std::vector<std::string> &input) {

    std::vector<std::string> short_names;
    std::vector<std::string> long_names;
    std::string pos_name;

    for(std::string name : input) {
        if(name.length() == 0)
            continue;
        else if(name.length() > 1 && name[0] == '-' && name[1] != '-') {
            if(name.length() == 2 && valid_first_char(name[1]))
                short_names.emplace_back(1, name[1]);
            else
                throw BadNameString::OneCharName(name);
        } else if(name.length() > 2 && name.substr(0, 2) == "--") {
            name = name.substr(2);
            if(valid_name_string(name))
                long_names.push_back(name);
            else
                throw BadNameString::BadLongName(name);
        } else if(name == "-" || name == "--") {
            throw BadNameString::DashesOnly(name);
        } else {
            if(pos_name.length() > 0)
                throw BadNameString::MultiPositionalNames(name);
            pos_name = name;
        }
    }

    return std::tuple<std::vector<std::string>, std::vector<std::string>, std::string>(
        short_names, long_names, pos_name);
}

} // namespace detail
} // namespace CLI

// From CLI/Ini.hpp:

namespace CLI {
namespace detail {

inline std::string inijoin(std::vector<std::string> args) {
    std::ostringstream s;
    size_t start = 0;
    for(const auto &arg : args) {
        if(start++ > 0)
            s << " ";

        auto it = std::find_if(arg.begin(), arg.end(), [](char ch) { return std::isspace<char>(ch, std::locale()); });
        if(it == arg.end())
            s << arg;
        else if(arg.find(R"(")") == std::string::npos)
            s << R"(")" << arg << R"(")";
        else
            s << R"(')" << arg << R"(')";
    }

    return s.str();
}

struct ini_ret_t {
    /// This is the full name with dots
    std::string fullname;

    /// Listing of inputs
    std::vector<std::string> inputs;

    /// Current parent level
    size_t level = 0;

    /// Return parent or empty string, based on level
    ///
    /// Level 0, a.b.c would return a
    /// Level 1, a.b.c could return b
    std::string parent() const {
        std::vector<std::string> plist = detail::split(fullname, '.');
        if(plist.size() > (level + 1))
            return plist[level];
        else
            return "";
    }

    /// Return name
    std::string name() const {
        std::vector<std::string> plist = detail::split(fullname, '.');
        return plist.at(plist.size() - 1);
    }
};

/// Internal parsing function
inline std::vector<ini_ret_t> parse_ini(std::istream &input) {
    std::string name, line;
    std::string section = "default";

    std::vector<ini_ret_t> output;

    while(getline(input, line)) {
        std::vector<std::string> items;

        detail::trim(line);
        size_t len = line.length();
        if(len > 1 && line[0] == '[' && line[len - 1] == ']') {
            section = line.substr(1, len - 2);
        } else if(len > 0 && line[0] != ';') {
            output.emplace_back();
            ini_ret_t &out = output.back();

            // Find = in string, split and recombine
            auto pos = line.find("=");
            if(pos != std::string::npos) {
                name = detail::trim_copy(line.substr(0, pos));
                std::string item = detail::trim_copy(line.substr(pos + 1));
                items = detail::split_up(item);
            } else {
                name = detail::trim_copy(line);
                items = {"ON"};
            }

            if(detail::to_lower(section) == "default")
                out.fullname = name;
            else
                out.fullname = section + "." + name;

            out.inputs.insert(std::end(out.inputs), std::begin(items), std::end(items));
        }
    }
    return output;
}

/// Parse an INI file, throw an error (ParseError:INIParseError or FileError) on failure
inline std::vector<ini_ret_t> parse_ini(const std::string &name) {

    std::ifstream input{name};
    if(!input.good())
        throw FileError::Missing(name);

    return parse_ini(input);
}

} // namespace detail
} // namespace CLI

// From CLI/Validators.hpp:

namespace CLI {

/// @defgroup validator_group Validators
/// @brief Some validators that are provided
///
/// These are simple `void(std::string&)` validators that are useful. They throw
/// a ValidationError if they fail (or the normally expected error if the cast fails)
/// @{

/// Check for an existing file
inline std::string ExistingFile(const std::string &filename) {
    struct stat buffer;
    bool exist = stat(filename.c_str(), &buffer) == 0;
    bool is_dir = (buffer.st_mode & S_IFDIR) != 0;
    if(!exist) {
        return "File does not exist: " + filename;
    } else if(is_dir) {
        return "File is actually a directory: " + filename;
    }
    return std::string();
}

/// Check for an existing directory
inline std::string ExistingDirectory(const std::string &filename) {
    struct stat buffer;
    bool exist = stat(filename.c_str(), &buffer) == 0;
    bool is_dir = (buffer.st_mode & S_IFDIR) != 0;
    if(!exist) {
        return "Directory does not exist: " + filename;
    } else if(!is_dir) {
        return "Directory is actually a file: " + filename;
    }
    return std::string();
}

/// Check for an existing path
inline std::string ExistingPath(const std::string &filename) {
    struct stat buffer;
    bool const exist = stat(filename.c_str(), &buffer) == 0;
    if(!exist) {
        return "Path does not exist: " + filename;
    }
    return std::string();
}

/// Check for a non-existing path
inline std::string NonexistentPath(const std::string &filename) {
    struct stat buffer;
    bool exist = stat(filename.c_str(), &buffer) == 0;
    if(exist) {
        return "Path already exists: " + filename;
    }
    return std::string();
}

/// Produce a range validator function
template <typename T> std::function<std::string(const std::string &)> Range(T min, T max) {
    return [min, max](std::string input) {
        T val;
        detail::lexical_cast(input, val);
        if(val < min || val > max)
            return "Value " + input + " not in range " + std::to_string(min) + " to " + std::to_string(max);

        return std::string();
    };
}

/// Range of one value is 0 to value
template <typename T> std::function<std::string(const std::string &)> Range(T max) {
    return Range(static_cast<T>(0), max);
}

/// @}

} // namespace CLI

// From CLI/Option.hpp:

namespace CLI {

using results_t = std::vector<std::string>;
using callback_t = std::function<bool(results_t)>;

class Option;
class App;

using Option_p = std::unique_ptr<Option>;

enum class MultiOptionPolicy { Throw, TakeLast, TakeFirst, Join };

template <typename CRTP> class OptionBase {
    friend App;

  protected:
    /// The group membership
    std::string group_ = std::string("Options");

    /// True if this is a required option
    bool required_{false};

    /// Ignore the case when matching (option, not value)
    bool ignore_case_{false};

    /// Allow this option to be given in a configuration file
    bool configurable_{true};

    /// Policy for multiple arguments when `expected_ == 1`  (can be set on bool flags, too)
    MultiOptionPolicy multi_option_policy_{MultiOptionPolicy::Throw};

    template <typename T> void copy_to(T *other) const {
        other->group(group_);
        other->required(required_);
        other->ignore_case(ignore_case_);
        other->configurable(configurable_);
        other->multi_option_policy(multi_option_policy_);
    }

  public:
    // setters

    /// Changes the group membership
    CRTP *group(std::string name) {
        group_ = name;
        return static_cast<CRTP *>(this);
        ;
    }

    /// Set the option as required
    CRTP *required(bool value = true) {
        required_ = value;
        return static_cast<CRTP *>(this);
    }

    /// Support Plumbum term
    CRTP *mandatory(bool value = true) { return required(value); }

    // Getters

    /// Get the group of this option
    const std::string &get_group() const { return group_; }

    /// True if this is a required option
    bool get_required() const { return required_; }

    /// The status of ignore case
    bool get_ignore_case() const { return ignore_case_; }

    /// The status of configurable
    bool get_configurable() const { return configurable_; }

    /// The status of the multi option policy
    MultiOptionPolicy get_multi_option_policy() const { return multi_option_policy_; }

    // Shortcuts for multi option policy

    /// Set the multi option policy to take last
    CRTP *take_last() {
        auto self = static_cast<CRTP *>(this);
        self->multi_option_policy(MultiOptionPolicy::TakeLast);
        return self;
    }

    /// Set the multi option policy to take last
    CRTP *take_first() {
        auto self = static_cast<CRTP *>(this);
        self->multi_option_policy(MultiOptionPolicy::TakeFirst);
        return self;
    }

    /// Set the multi option policy to take last
    CRTP *join() {
        auto self = static_cast<CRTP *>(this);
        self->multi_option_policy(MultiOptionPolicy::Join);
        return self;
    }

    /// Allow in a configuration file
    CRTP *configurable(bool value = true) {
        configurable_ = value;
        return static_cast<CRTP *>(this);
    }
};

class OptionDefaults : public OptionBase<OptionDefaults> {
  public:
    OptionDefaults() = default;

    // Methods here need a different implementation if they are Option vs. OptionDefault

    /// Take the last argument if given multiple times
    OptionDefaults *multi_option_policy(MultiOptionPolicy value = MultiOptionPolicy::Throw) {
        multi_option_policy_ = value;
        return this;
    }

    /// Ignore the case of the option name
    OptionDefaults *ignore_case(bool value = true) {
        ignore_case_ = value;
        return this;
    }
};

class Option : public OptionBase<Option> {
    friend App;

  protected:
    /// @name Names
    ///@{

    /// A list of the short names (`-a`) without the leading dashes
    std::vector<std::string> snames_;

    /// A list of the long names (`--a`) without the leading dashes
    std::vector<std::string> lnames_;

    /// A positional name
    std::string pname_;

    /// If given, check the environment for this option
    std::string envname_;

    ///@}
    /// @name Help
    ///@{

    /// The description for help strings
    std::string description_;

    /// A human readable default value, usually only set if default is true in creation
    std::string defaultval_;

    /// A human readable type value, set when App creates this
    std::string typeval_;

    /// True if this option has a default
    bool default_{false};

    ///@}
    /// @name Configuration
    ///@{

    /// The number of arguments that make up one option. -1=unlimited (vector-like), 0=flag, 1=normal option,
    /// 2=complex/pair, etc. Set only when the option is created; this is intrinsic to the type. Eventually, -2 may mean
    /// vector of pairs.
    int type_size_{1};

    /// The number of expected values, type_size_ must be < 0. Ignored for flag. N < 0 means at least -N values.
    int expected_{1};

    /// A list of validators to run on each value parsed
    std::vector<std::function<std::string(std::string &)>> validators_;

    /// A list of options that are required with this option
    std::set<Option *> requires_;

    /// A list of options that are excluded with this option
    std::set<Option *> excludes_;

    ///@}
    /// @name Other
    ///@{

    /// Remember the parent app
    App *parent_;

    /// Options store a callback to do all the work
    callback_t callback_;

    ///@}
    /// @name Parsing results
    ///@{

    /// Results of parsing
    results_t results_;

    /// Whether the callback has run (needed for INI parsing)
    bool callback_run_{false};

    ///@}

    /// Making an option by hand is not defined, it must be made by the App class
    Option(std::string name,
           std::string description = "",
           std::function<bool(results_t)> callback = [](results_t) { return true; },
           bool default_ = true,
           App *parent = nullptr)
        : description_(std::move(description)), default_(default_), parent_(parent), callback_(std::move(callback)) {
        std::tie(snames_, lnames_, pname_) = detail::get_names(detail::split_names(name));
    }

  public:
    /// @name Basic
    ///@{

    /// Count the total number of times an option was passed
    size_t count() const { return results_.size(); }

    /// This class is true if option is passed.
    operator bool() const { return count() > 0; }

    /// Clear the parsed results (mostly for testing)
    void clear() { results_.clear(); }

    ///@}
    /// @name Setting options
    ///@{

    /// Set the number of expected arguments (Flags don't use this)
    Option *expected(int value) {
        // Break if this is a flag
        if(type_size_ == 0)
            throw IncorrectConstruction::SetFlag(single_name());

        // Setting 0 is not allowed
        else if(value == 0)
            throw IncorrectConstruction::Set0Opt(single_name());

        // No change is okay, quit now
        else if(expected_ == value)
            return this;

        // Type must be a vector
        else if(type_size_ >= 0)
            throw IncorrectConstruction::ChangeNotVector(single_name());

        // TODO: Can support multioption for non-1 values (except for join)
        else if(value != 1 && multi_option_policy_ != MultiOptionPolicy::Throw)
            throw IncorrectConstruction::AfterMultiOpt(single_name());

        expected_ = value;
        return this;
    }

    /// Adds a validator
    Option *check(std::function<std::string(const std::string &)> validator) {
        validators_.emplace_back(validator);
        return this;
    }

    /// Adds a validator-like function that can change result
    Option *transform(std::function<std::string(std::string)> func) {
        validators_.emplace_back([func](std::string &inout) {
            try {
                inout = func(inout);
            } catch(const ValidationError &e) {
                return std::string(e.what());
            }
            return std::string();
        });
        return this;
    }

    /// Sets required options
    Option *needs(Option *opt) {
        auto tup = requires_.insert(opt);
        if(!tup.second)
            throw OptionAlreadyAdded::Requires(single_name(), opt->single_name());
        return this;
    }

    /// Can find a string if needed
    template <typename T = App> Option *needs(std::string opt_name) {
        for(const Option_p &opt : dynamic_cast<T *>(parent_)->options_)
            if(opt.get() != this && opt->check_name(opt_name))
                return needs(opt.get());
        throw IncorrectConstruction::MissingOption(opt_name);
    }

    /// Any number supported, any mix of string and Opt
    template <typename A, typename B, typename... ARG> Option *needs(A opt, B opt1, ARG... args) {
        needs(opt);
        return needs(opt1, args...);
    }

#ifndef CLI11_CPP20
    /// Sets required options \deprecated
    CLI11_DEPRECATED("Use needs instead of requires (eventual keyword clash)")
    Option *requires(Option *opt) { return needs(opt); }

    /// Can find a string if needed \deprecated
    template <typename T = App> Option *requires(std::string opt_name) {
        for(const Option_p &opt : dynamic_cast<T *>(parent_)->options_)
            if(opt.get() != this && opt->check_name(opt_name))
                return needs(opt.get());
        throw IncorrectConstruction::MissingOption(opt_name);
    }

    /// Any number supported, any mix of string and Opt \deprecated
    template <typename A, typename B, typename... ARG> Option *requires(A opt, B opt1, ARG... args) {
        requires(opt);
        return requires(opt1, args...);
    }
#endif

    /// Sets excluded options
    Option *excludes(Option *opt) {
        excludes_.insert(opt);

        // Help text should be symmetric - excluding a should exclude b
        opt->excludes_.insert(this);

        // Ignoring the insert return value, excluding twice is now allowed.
        // (Mostly to allow both directions to be excluded by user, even though the library does it for you.)

        return this;
    }

    /// Can find a string if needed
    template <typename T = App> Option *excludes(std::string opt_name) {
        for(const Option_p &opt : dynamic_cast<T *>(parent_)->options_)
            if(opt.get() != this && opt->check_name(opt_name))
                return excludes(opt.get());
        throw IncorrectConstruction::MissingOption(opt_name);
    }

    /// Any number supported, any mix of string and Opt
    template <typename A, typename B, typename... ARG> Option *excludes(A opt, B opt1, ARG... args) {
        excludes(opt);
        return excludes(opt1, args...);
    }

    /// Sets environment variable to read if no option given
    Option *envname(std::string name) {
        envname_ = name;
        return this;
    }

    /// Ignore case
    ///
    /// The template hides the fact that we don't have the definition of App yet.
    /// You are never expected to add an argument to the template here.
    template <typename T = App> Option *ignore_case(bool value = true) {
        ignore_case_ = value;
        auto *parent = dynamic_cast<T *>(parent_);

        for(const Option_p &opt : parent->options_)
            if(opt.get() != this && *opt == *this)
                throw OptionAlreadyAdded(opt->get_name());

        return this;
    }

    /// Take the last argument if given multiple times (or another policy)
    Option *multi_option_policy(MultiOptionPolicy value = MultiOptionPolicy::Throw) {

        if(get_items_expected() < 0)
            throw IncorrectConstruction::MultiOptionPolicy(single_name());
        multi_option_policy_ = value;
        return this;
    }

    ///@}
    /// @name Accessors
    ///@{

    /// The number of arguments the option expects
    int get_type_size() const { return type_size_; }

    /// The number of times the option expects to be included
    int get_expected() const { return expected_; }

    /// \breif The total number of expected values (including the type)
    /// This is positive if exactly this number is expected, and negitive for at least N values
    ///
    /// v = fabs(size_type*expected)
    /// !MultiOptionPolicy::Throw
    ///           | Expected < 0  | Expected == 0 | Expected > 0
    /// Size < 0  |      -v       |       0       |     -v
    /// Size == 0 |       0       |       0       |      0
    /// Size > 0  |      -v       |       0       |     -v       // Expected must be 1
    ///
    /// MultiOptionPolicy::Throw
    ///           | Expected < 0  | Expected == 0 | Expected > 0
    /// Size < 0  |      -v       |       0       |      v
    /// Size == 0 |       0       |       0       |      0
    /// Size > 0  |       v       |       0       |      v      // Expected must be 1
    ///
    int get_items_expected() const {
        return std::abs(type_size_ * expected_) *
               ((multi_option_policy_ != MultiOptionPolicy::Throw || (expected_ < 0 && type_size_ < 0) ? -1 : 1));
    }

    /// True if this has a default value
    int get_default() const { return default_; }

    /// True if the argument can be given directly
    bool get_positional() const { return pname_.length() > 0; }

    /// True if option has at least one non-positional name
    bool nonpositional() const { return (snames_.size() + lnames_.size()) > 0; }

    /// True if option has description
    bool has_description() const { return description_.length() > 0; }

    /// Get the description
    const std::string &get_description() const { return description_; }

    // Just the pname
    std::string get_pname() const { return pname_; }

    ///@}
    /// @name Help tools
    ///@{

    /// Gets a , sep list of names. Does not include the positional name if opt_only=true.
    std::string get_name(bool opt_only = false) const {
        std::vector<std::string> name_list;
        if(!opt_only && pname_.length() > 0)
            name_list.push_back(pname_);
        for(const std::string &sname : snames_)
            name_list.push_back("-" + sname);
        for(const std::string &lname : lnames_)
            name_list.push_back("--" + lname);
        return detail::join(name_list);
    }

    /// The name and any extras needed for positionals
    std::string help_positional() const {
        std::string out = pname_;
        if(get_expected() > 1)
            out = out + "(" + std::to_string(get_expected()) + "x)";
        else if(get_expected() == -1)
            out = out + "...";
        out = get_required() ? out : "[" + out + "]";
        return out;
    }

    /// The most descriptive name available
    std::string single_name() const {
        if(!lnames_.empty())
            return std::string("--") + lnames_[0];
        else if(!snames_.empty())
            return std::string("-") + snames_[0];
        else
            return pname_;
    }

    /// The first half of the help print, name plus default, etc. Setting opt_only to true avoids the positional name.
    std::string help_name(bool opt_only = false) const {
        std::stringstream out;
        out << get_name(opt_only) << help_aftername();
        return out.str();
    }

    /// pname with type info
    std::string help_pname() const {
        std::stringstream out;
        out << get_pname() << help_aftername();
        return out.str();
    }

    /// This is the part after the name is printed but before the description
    std::string help_aftername() const {
        std::stringstream out;

        if(get_type_size() != 0) {
            if(!typeval_.empty())
                out << " " << typeval_;
            if(!defaultval_.empty())
                out << "=" << defaultval_;
            if(get_expected() > 1)
                out << " x " << get_expected();
            if(get_expected() == -1)
                out << " ...";
            if(get_required())
                out << " (REQUIRED)";
        }
        if(!envname_.empty())
            out << " (env:" << envname_ << ")";
        if(!requires_.empty()) {
            out << " Needs:";
            for(const Option *opt : requires_)
                out << " " << opt->single_name();
        }
        if(!excludes_.empty()) {
            out << " Excludes:";
            for(const Option *opt : excludes_)
                out << " " << opt->single_name();
        }
        return out.str();
    }

    ///@}
    /// @name Parser tools
    ///@{

    /// Process the callback
    void run_callback() {

        // Run the validators (can change the string)
        if(!validators_.empty()) {
            for(std::string &result : results_)
                for(const std::function<std::string(std::string &)> &vali : validators_) {
                    std::string err_msg = vali(result);
                    if(!err_msg.empty())
                        throw ValidationError(single_name(), err_msg);
                }
        }

        bool local_result;

        // Num items expected or length of vector, always at least 1
        // Only valid for a trimming policy
        int trim_size = std::min(std::max(std::abs(get_items_expected()), 1), static_cast<int>(results_.size()));

        // Operation depends on the policy setting
        if(multi_option_policy_ == MultiOptionPolicy::TakeLast) {
            // Allow multi-option sizes (including 0)
            results_t partial_result{results_.end() - trim_size, results_.end()};
            local_result = !callback_(partial_result);

        } else if(multi_option_policy_ == MultiOptionPolicy::TakeFirst) {
            results_t partial_result{results_.begin(), results_.begin() + trim_size};
            local_result = !callback_(partial_result);

        } else if(multi_option_policy_ == MultiOptionPolicy::Join) {
            results_t partial_result = {detail::join(results_, "\n")};
            local_result = !callback_(partial_result);

        } else {
            // For now, vector of non size 1 types are not supported but possibility included here
            if((get_items_expected() > 0 && results_.size() != static_cast<size_t>(get_items_expected())) ||
               (get_items_expected() < 0 && results_.size() < static_cast<size_t>(-get_items_expected())))
                throw ArgumentMismatch(single_name(), get_items_expected(), results_.size());
            else
                local_result = !callback_(results_);
        }

        if(local_result)
            throw ConversionError(get_name(), results_);
    }

    /// If options share any of the same names, they are equal (not counting positional)
    bool operator==(const Option &other) const {
        for(const std::string &sname : snames_)
            if(other.check_sname(sname))
                return true;
        for(const std::string &lname : lnames_)
            if(other.check_lname(lname))
                return true;
        // We need to do the inverse, just in case we are ignore_case
        for(const std::string &sname : other.snames_)
            if(check_sname(sname))
                return true;
        for(const std::string &lname : other.lnames_)
            if(check_lname(lname))
                return true;
        return false;
    }

    /// Check a name. Requires "-" or "--" for short / long, supports positional name
    bool check_name(std::string name) const {

        if(name.length() > 2 && name.substr(0, 2) == "--")
            return check_lname(name.substr(2));
        else if(name.length() > 1 && name.substr(0, 1) == "-")
            return check_sname(name.substr(1));
        else {
            std::string local_pname = pname_;
            if(ignore_case_) {
                local_pname = detail::to_lower(local_pname);
                name = detail::to_lower(name);
            }
            return name == local_pname;
        }
    }

    /// Requires "-" to be removed from string
    bool check_sname(std::string name) const {
        if(ignore_case_) {
            name = detail::to_lower(name);
            return std::find_if(std::begin(snames_), std::end(snames_), [&name](std::string local_sname) {
                       return detail::to_lower(local_sname) == name;
                   }) != std::end(snames_);
        } else
            return std::find(std::begin(snames_), std::end(snames_), name) != std::end(snames_);
    }

    /// Requires "--" to be removed from string
    bool check_lname(std::string name) const {
        if(ignore_case_) {
            name = detail::to_lower(name);
            return std::find_if(std::begin(lnames_), std::end(lnames_), [&name](std::string local_sname) {
                       return detail::to_lower(local_sname) == name;
                   }) != std::end(lnames_);
        } else
            return std::find(std::begin(lnames_), std::end(lnames_), name) != std::end(lnames_);
    }

    /// Puts a result at the end, unless last_ is set, in which case it just keeps the last one
    void add_result(std::string s) {
        results_.push_back(s);
        callback_run_ = false;
    }

    /// Get a copy of the results
    std::vector<std::string> results() const { return results_; }

    /// See if the callback has been run already
    bool get_callback_run() const { return callback_run_; }

    ///@}
    /// @name Custom options
    ///@{

    /// Set a custom option, typestring, type_size
    void set_custom_option(std::string typeval, int type_size = 1) {
        typeval_ = typeval;
        type_size_ = type_size;
        if(type_size_ == 0)
            required_ = false;
        if(type_size < 0)
            expected_ = -1;
    }

    /// Set the default value string representation
    void set_default_str(std::string val) { defaultval_ = val; }

    /// Set the default value string representation and evaluate
    void set_default_val(std::string val) {
        set_default_str(val);
        auto old_results = results_;
        results_ = {val};
        run_callback();
        results_ = std::move(old_results);
    }

    /// Set the type name displayed on this option
    void set_type_name(std::string val) { typeval_ = val; }

    /// Get the typename for this option
    std::string get_type_name() const { return typeval_; }

    ///@}

  protected:
    /// @name App Helpers
    ///@{
    /// Can print positional name detailed option if true
    bool _has_help_positional() const {
        return get_positional() && (has_description() || !requires_.empty() || !excludes_.empty());
    }
    ///@}
};

} // namespace CLI

// From CLI/App.hpp:

namespace CLI {

#ifndef CLI11_PARSE
#define CLI11_PARSE(app, argc, argv)                                                                                   \
    try {                                                                                                              \
        (app).parse((argc), (argv));                                                                                   \
    } catch(const CLI::ParseError &e) {                                                                                \
        return (app).exit(e);                                                                                          \
    }
#endif

namespace detail {
enum class Classifer { NONE, POSITIONAL_MARK, SHORT, LONG, SUBCOMMAND };
struct AppFriend;
} // namespace detail

namespace FailureMessage {
std::string simple(const App *app, const Error &e);
std::string help(const App *app, const Error &e);
} // namespace FailureMessage

class App;

using App_p = std::unique_ptr<App>;

/// Creates a command line program, with very few defaults.
/** To use, create a new `Program()` instance with `argc`, `argv`, and a help description. The templated
 *  add_option methods make it easy to prepare options. Remember to call `.start` before starting your
 * program, so that the options can be evaluated and the help option doesn't accidentally run your program. */
class App {
    friend Option;
    friend detail::AppFriend;

  protected:
    // This library follows the Google style guide for member names ending in underscores

    /// @name Basics
    ///@{

    /// Subcommand name or program name (from parser if name is empty)
    std::string name_;

    /// Description of the current program/subcommand
    std::string description_;

    /// If true, allow extra arguments (ie, don't throw an error). INHERITABLE
    bool allow_extras_{false};

    /// If true, allow extra arguments in the ini file (ie, don't throw an error). INHERITABLE
    bool allow_ini_extras_{false};

    ///  If true, return immediately on an unrecognised option (implies allow_extras) INHERITABLE
    bool prefix_command_{false};

    /// This is a function that runs when complete. Great for subcommands. Can throw.
    std::function<void()> callback_;

    ///@}
    /// @name Options
    ///@{

    /// The default values for options, customizable and changeable INHERITABLE
    OptionDefaults option_defaults_;

    /// The list of options, stored locally
    std::vector<Option_p> options_;

    ///@}
    /// @name Help
    ///@{

    /// Footer to put after all options in the help output INHERITABLE
    std::string footer_;

    /// A pointer to the help flag if there is one INHERITABLE
    Option *help_ptr_{nullptr};

    /// The error message printing function INHERITABLE
    std::function<std::string(const App *, const Error &e)> failure_message_ = FailureMessage::simple;

    ///@}
    /// @name Parsing
    ///@{

    using missing_t = std::vector<std::pair<detail::Classifer, std::string>>;

    /// Pair of classifier, string for missing options. (extra detail is removed on returning from parse)
    ///
    /// This is faster and cleaner than storing just a list of strings and reparsing. This may contain the -- separator.
    missing_t missing_;

    /// This is a list of pointers to options with the original parse order
    std::vector<Option *> parse_order_;

    /// This is a list of the subcommands collected, in order
    std::vector<App *> parsed_subcommands_;

    ///@}
    /// @name Subcommands
    ///@{

    /// Storage for subcommand list
    std::vector<App_p> subcommands_;

    /// If true, the program name is not case sensitive INHERITABLE
    bool ignore_case_{false};

    /// Allow subcommand fallthrough, so that parent commands can collect commands after subcommand.  INHERITABLE
    bool fallthrough_{false};

    /// A pointer to the parent if this is a subcommand
    App *parent_{nullptr};

    /// True if this command/subcommand was parsed
    bool parsed_{false};

    /// Minimum required subcommands
    size_t require_subcommand_min_ = 0;

    /// Max number of subcommands allowed (parsing stops after this number). 0 is unlimited INHERITABLE
    size_t require_subcommand_max_ = 0;

    /// The group membership INHERITABLE
    std::string group_{"Subcommands"};

    ///@}
    /// @name Config
    ///@{

    /// The name of the connected config file
    std::string config_name_;

    /// True if ini is required (throws if not present), if false simply keep going.
    bool config_required_{false};

    /// Pointer to the config option
    Option *config_ptr_{nullptr};

    ///@}

    /// Special private constructor for subcommand
    App(std::string description_, std::string name, App *parent)
        : name_(std::move(name)), description_(std::move(description_)), parent_(parent) {
        // Inherit if not from a nullptr
        if(parent_ != nullptr) {
            if(parent_->help_ptr_ != nullptr)
                set_help_flag(parent_->help_ptr_->get_name(), parent_->help_ptr_->get_description());

            /// OptionDefaults
            option_defaults_ = parent_->option_defaults_;

            // INHERITABLE
            failure_message_ = parent_->failure_message_;
            allow_extras_ = parent_->allow_extras_;
            allow_ini_extras_ = parent_->allow_ini_extras_;
            prefix_command_ = parent_->prefix_command_;
            ignore_case_ = parent_->ignore_case_;
            fallthrough_ = parent_->fallthrough_;
            group_ = parent_->group_;
            footer_ = parent_->footer_;
            require_subcommand_max_ = parent_->require_subcommand_max_;
        }
    }

  public:
    /// @name Basic
    ///@{

    /// Create a new program. Pass in the same arguments as main(), along with a help string.
    explicit App(std::string description_ = "", std::string name = "") : App(description_, name, nullptr) {
        set_help_flag("-h,--help", "Print this help message and exit");
    }

    /// virtual destructor
    virtual ~App() = default;

    /// Set a callback for the end of parsing.
    ///
    /// Due to a bug in c++11,
    /// it is not possible to overload on std::function (fixed in c++14
    /// and backported to c++11 on newer compilers). Use capture by reference
    /// to get a pointer to App if needed.
    App *set_callback(std::function<void()> callback) {
        callback_ = callback;
        return this;
    }

    /// Set a name for the app (empty will use parser to set the name)
    App *set_name(std::string name = "") {
        name_ = name;
        return this;
    }

    /// Remove the error when extras are left over on the command line.
    App *allow_extras(bool allow = true) {
        allow_extras_ = allow;
        return this;
    }

    /// Remove the error when extras are left over on the command line.
    /// Will also call App::allow_extras().
    App *allow_ini_extras(bool allow = true) {
        allow_extras(allow);
        allow_ini_extras_ = allow;
        return this;
    }

    /// Do not parse anything after the first unrecognised option and return
    App *prefix_command(bool allow = true) {
        prefix_command_ = allow;
        return this;
    }

    /// Ignore case. Subcommand inherit value.
    App *ignore_case(bool value = true) {
        ignore_case_ = value;
        if(parent_ != nullptr) {
            for(const auto &subc : parent_->subcommands_) {
                if(subc.get() != this && (this->check_name(subc->name_) || subc->check_name(this->name_)))
                    throw OptionAlreadyAdded(subc->name_);
            }
        }
        return this;
    }

    /// Check to see if this subcommand was parsed, true only if received on command line.
    bool parsed() const { return parsed_; }

    /// Get the OptionDefault object, to set option defaults
    OptionDefaults *option_defaults() { return &option_defaults_; }

    ///@}
    /// @name Adding options
    ///@{

    /// Add an option, will automatically understand the type for common types.
    ///
    /// To use, create a variable with the expected type, and pass it in after the name.
    /// After start is called, you can use count to see if the value was passed, and
    /// the value will be initialized properly. Numbers, vectors, and strings are supported.
    ///
    /// ->required(), ->default, and the validators are options,
    /// The positional options take an optional number of arguments.
    ///
    /// For example,
    ///
    ///     std::string filename;
    ///     program.add_option("filename", filename, "description of filename");
    ///
    Option *add_option(std::string name, callback_t callback, std::string description = "", bool defaulted = false) {
        Option myopt{name, description, callback, defaulted, this};

        if(std::find_if(std::begin(options_), std::end(options_), [&myopt](const Option_p &v) {
               return *v == myopt;
           }) == std::end(options_)) {
            options_.emplace_back();
            Option_p &option = options_.back();
            option.reset(new Option(name, description, callback, defaulted, this));
            option_defaults_.copy_to(option.get());
            return option.get();
        } else
            throw OptionAlreadyAdded(myopt.get_name());
    }

    /// Add option for non-vectors (duplicate copy needed without defaulted to avoid `iostream << value`)
    template <typename T, enable_if_t<!is_vector<T>::value, detail::enabler> = detail::dummy>
    Option *add_option(std::string name,
                       T &variable, ///< The variable to set
                       std::string description = "") {

        std::string simple_name = CLI::detail::split(name, ',').at(0);
        CLI::callback_t fun = [&variable, simple_name](CLI::results_t res) {
            return detail::lexical_cast(res[0], variable);
        };

        Option *opt = add_option(name, fun, description, false);
        opt->set_custom_option(detail::type_name<T>());
        return opt;
    }

    /// Add option for non-vectors with a default print
    template <typename T, enable_if_t<!is_vector<T>::value, detail::enabler> = detail::dummy>
    Option *add_option(std::string name,
                       T &variable, ///< The variable to set
                       std::string description,
                       bool defaulted) {

        std::string simple_name = CLI::detail::split(name, ',').at(0);
        CLI::callback_t fun = [&variable, simple_name](CLI::results_t res) {
            return detail::lexical_cast(res[0], variable);
        };

        Option *opt = add_option(name, fun, description, defaulted);
        opt->set_custom_option(detail::type_name<T>());
        if(defaulted) {
            std::stringstream out;
            out << variable;
            opt->set_default_str(out.str());
        }
        return opt;
    }

    /// Add option for vectors (no default)
    template <typename T>
    Option *add_option(std::string name,
                       std::vector<T> &variable, ///< The variable vector to set
                       std::string description = "") {

        CLI::callback_t fun = [&variable](CLI::results_t res) {
            bool retval = true;
            variable.clear();
            for(const auto &a : res) {
                variable.emplace_back();
                retval &= detail::lexical_cast(a, variable.back());
            }
            return (!variable.empty()) && retval;
        };

        Option *opt = add_option(name, fun, description, false);
        opt->set_custom_option(detail::type_name<T>(), -1);
        return opt;
    }

    /// Add option for vectors
    template <typename T>
    Option *add_option(std::string name,
                       std::vector<T> &variable, ///< The variable vector to set
                       std::string description,
                       bool defaulted) {

        CLI::callback_t fun = [&variable](CLI::results_t res) {
            bool retval = true;
            variable.clear();
            for(const auto &a : res) {
                variable.emplace_back();
                retval &= detail::lexical_cast(a, variable.back());
            }
            return (!variable.empty()) && retval;
        };

        Option *opt = add_option(name, fun, description, defaulted);
        opt->set_custom_option(detail::type_name<T>(), -1);
        if(defaulted)
            opt->set_default_str("[" + detail::join(variable) + "]");
        return opt;
    }

    /// Set a help flag, replaced the existing one if present
    Option *set_help_flag(std::string name = "", std::string description = "") {
        if(help_ptr_ != nullptr) {
            remove_option(help_ptr_);
            help_ptr_ = nullptr;
        }

        // Empty name will simply remove the help flag
        if(!name.empty()) {
            help_ptr_ = add_flag(name, description);
            help_ptr_->configurable(false);
        }

        return help_ptr_;
    }

    /// Add option for flag
    Option *add_flag(std::string name, std::string description = "") {
        CLI::callback_t fun = [](CLI::results_t) { return true; };

        Option *opt = add_option(name, fun, description, false);
        if(opt->get_positional())
            throw IncorrectConstruction::PositionalFlag(name);
        opt->set_custom_option("", 0);
        return opt;
    }

    /// Add option for flag integer
    template <typename T,
              enable_if_t<std::is_integral<T>::value && !is_bool<T>::value, detail::enabler> = detail::dummy>
    Option *add_flag(std::string name,
                     T &count, ///< A variable holding the count
                     std::string description = "") {

        count = 0;
        CLI::callback_t fun = [&count](CLI::results_t res) {
            count = static_cast<T>(res.size());
            return true;
        };

        Option *opt = add_option(name, fun, description, false);
        if(opt->get_positional())
            throw IncorrectConstruction::PositionalFlag(name);
        opt->set_custom_option("", 0);
        return opt;
    }

    /// Bool version - defaults to allowing multiple passings, but can be forced to one if
    /// `multi_option_policy(CLI::MultiOptionPolicy::Throw)` is used.
    template <typename T, enable_if_t<is_bool<T>::value, detail::enabler> = detail::dummy>
    Option *add_flag(std::string name,
                     T &count, ///< A variable holding true if passed
                     std::string description = "") {

        count = false;
        CLI::callback_t fun = [&count](CLI::results_t res) {
            count = true;
            return res.size() == 1;
        };

        Option *opt = add_option(name, fun, description, false);
        if(opt->get_positional())
            throw IncorrectConstruction::PositionalFlag(name);
        opt->set_custom_option("", 0);
        opt->multi_option_policy(CLI::MultiOptionPolicy::TakeLast);
        return opt;
    }

    /// Add option for callback
    Option *add_flag_function(std::string name,
                              std::function<void(size_t)> function, ///< A function to call, void(size_t)
                              std::string description = "") {

        CLI::callback_t fun = [function](CLI::results_t res) {
            auto count = static_cast<size_t>(res.size());
            function(count);
            return true;
        };

        Option *opt = add_option(name, fun, description, false);
        if(opt->get_positional())
            throw IncorrectConstruction::PositionalFlag(name);
        opt->set_custom_option("", 0);
        return opt;
    }

#ifdef CLI11_CPP14
    /// Add option for callback (C++14 or better only)
    Option *add_flag(std::string name,
                     std::function<void(size_t)> function, ///< A function to call, void(size_t)
                     std::string description = "") {
        return add_flag_function(name, function, description);
    }
#endif

    /// Add set of options (No default)
    template <typename T>
    Option *add_set(std::string name,
                    T &member,           ///< The selected member of the set
                    std::set<T> options, ///< The set of possibilities
                    std::string description = "") {

        std::string simple_name = CLI::detail::split(name, ',').at(0);
        CLI::callback_t fun = [&member, options, simple_name](CLI::results_t res) {
            bool retval = detail::lexical_cast(res[0], member);
            if(!retval)
                throw ConversionError(res[0], simple_name);
            return std::find(std::begin(options), std::end(options), member) != std::end(options);
        };

        Option *opt = add_option(name, fun, description, false);
        std::string typeval = detail::type_name<T>();
        typeval += " in {" + detail::join(options) + "}";
        opt->set_custom_option(typeval);
        return opt;
    }

    /// Add set of options
    template <typename T>
    Option *add_set(std::string name,
                    T &member,           ///< The selected member of the set
                    std::set<T> options, ///< The set of posibilities
                    std::string description,
                    bool defaulted) {

        std::string simple_name = CLI::detail::split(name, ',').at(0);
        CLI::callback_t fun = [&member, options, simple_name](CLI::results_t res) {
            bool retval = detail::lexical_cast(res[0], member);
            if(!retval)
                throw ConversionError(res[0], simple_name);
            return std::find(std::begin(options), std::end(options), member) != std::end(options);
        };

        Option *opt = add_option(name, fun, description, defaulted);
        std::string typeval = detail::type_name<T>();
        typeval += " in {" + detail::join(options) + "}";
        opt->set_custom_option(typeval);
        if(defaulted) {
            std::stringstream out;
            out << member;
            opt->set_default_str(out.str());
        }
        return opt;
    }

    /// Add set of options, string only, ignore case (no default)
    Option *add_set_ignore_case(std::string name,
                                std::string &member,           ///< The selected member of the set
                                std::set<std::string> options, ///< The set of possibilities
                                std::string description = "") {

        std::string simple_name = CLI::detail::split(name, ',').at(0);
        CLI::callback_t fun = [&member, options, simple_name](CLI::results_t res) {
            member = detail::to_lower(res[0]);
            auto iter = std::find_if(std::begin(options), std::end(options), [&member](std::string val) {
                return detail::to_lower(val) == member;
            });
            if(iter == std::end(options))
                throw ConversionError(member, simple_name);
            else {
                member = *iter;
                return true;
            }
        };

        Option *opt = add_option(name, fun, description, false);
        std::string typeval = detail::type_name<std::string>();
        typeval += " in {" + detail::join(options) + "}";
        opt->set_custom_option(typeval);

        return opt;
    }

    /// Add set of options, string only, ignore case
    Option *add_set_ignore_case(std::string name,
                                std::string &member,           ///< The selected member of the set
                                std::set<std::string> options, ///< The set of posibilities
                                std::string description,
                                bool defaulted) {

        std::string simple_name = CLI::detail::split(name, ',').at(0);
        CLI::callback_t fun = [&member, options, simple_name](CLI::results_t res) {
            member = detail::to_lower(res[0]);
            auto iter = std::find_if(std::begin(options), std::end(options), [&member](std::string val) {
                return detail::to_lower(val) == member;
            });
            if(iter == std::end(options))
                throw ConversionError(member, simple_name);
            else {
                member = *iter;
                return true;
            }
        };

        Option *opt = add_option(name, fun, description, defaulted);
        std::string typeval = detail::type_name<std::string>();
        typeval += " in {" + detail::join(options) + "}";
        opt->set_custom_option(typeval);
        if(defaulted) {
            opt->set_default_str(member);
        }
        return opt;
    }

    /// Add a complex number
    template <typename T>
    Option *add_complex(std::string name,
                        T &variable,
                        std::string description = "",
                        bool defaulted = false,
                        std::string label = "COMPLEX") {

        std::string simple_name = CLI::detail::split(name, ',').at(0);
        CLI::callback_t fun = [&variable, simple_name, label](results_t res) {
            if(res[1].back() == 'i')
                res[1].pop_back();
            double x, y;
            bool worked = detail::lexical_cast(res[0], x) && detail::lexical_cast(res[1], y);
            if(worked)
                variable = T(x, y);
            return worked;
        };

        CLI::Option *opt = add_option(name, fun, description, defaulted);
        opt->set_custom_option(label, 2);
        if(defaulted) {
            std::stringstream out;
            out << variable;
            opt->set_default_str(out.str());
        }
        return opt;
    }

    /// Set a configuration ini file option, or clear it if no name passed
    Option *set_config(std::string name = "",
                       std::string default_filename = "",
                       std::string help = "Read an ini file",
                       bool required = false) {

        // Remove existing config if present
        if(config_ptr_ != nullptr)
            remove_option(config_ptr_);

        // Only add config if option passed
        if(!name.empty()) {
            config_name_ = default_filename;
            config_required_ = required;
            config_ptr_ = add_option(name, config_name_, help, !default_filename.empty());
            config_ptr_->configurable(false);
        }

        return config_ptr_;
    }

    /// Removes an option from the App. Takes an option pointer. Returns true if found and removed.
    bool remove_option(Option *opt) {
        auto iterator =
            std::find_if(std::begin(options_), std::end(options_), [opt](const Option_p &v) { return v.get() == opt; });
        if(iterator != std::end(options_)) {
            options_.erase(iterator);
            return true;
        }
        return false;
    }

    ///@}
    /// @name Subcommmands
    ///@{

    /// Add a subcommand. Inherits INHERITABLE and OptionDefaults, and help flag
    App *add_subcommand(std::string name, std::string description = "") {
        subcommands_.emplace_back(new App(description, name, this));
        for(const auto &subc : subcommands_)
            if(subc.get() != subcommands_.back().get())
                if(subc->check_name(subcommands_.back()->name_) || subcommands_.back()->check_name(subc->name_))
                    throw OptionAlreadyAdded(subc->name_);
        return subcommands_.back().get();
    }

    /// Check to see if a subcommand is part of this command (doesn't have to be in command line)
    App *get_subcommand(App *subcom) const {
        for(const App_p &subcomptr : subcommands_)
            if(subcomptr.get() == subcom)
                return subcom;
        throw OptionNotFound(subcom->get_name());
    }

    /// Check to see if a subcommand is part of this command (text version)
    App *get_subcommand(std::string subcom) const {
        for(const App_p &subcomptr : subcommands_)
            if(subcomptr->check_name(subcom))
                return subcomptr.get();
        throw OptionNotFound(subcom);
    }

    /// Changes the group membership
    App *group(std::string name) {
        group_ = name;
        return this;
    }

    /// The argumentless form of require subcommand requires 1 or more subcommands
    App *require_subcommand() {
        require_subcommand_min_ = 1;
        require_subcommand_max_ = 0;
        return this;
    }

    /// Require a subcommand to be given (does not affect help call)
    /// The number required can be given. Negative values indicate maximum
    /// number allowed (0 for any number). Max number inheritable.
    App *require_subcommand(int value) {
        if(value < 0) {
            require_subcommand_min_ = 0;
            require_subcommand_max_ = static_cast<size_t>(-value);
        } else {
            require_subcommand_min_ = static_cast<size_t>(value);
            require_subcommand_max_ = static_cast<size_t>(value);
        }
        return this;
    }

    /// Explicitly control the number of subcommands required. Setting 0
    /// for the max means unlimited number allowed. Max number inheritable.
    App *require_subcommand(size_t min, size_t max) {
        require_subcommand_min_ = min;
        require_subcommand_max_ = max;
        return this;
    }

    /// Stop subcommand fallthrough, so that parent commands cannot collect commands after subcommand.
    /// Default from parent, usually set on parent.
    App *fallthrough(bool value = true) {
        fallthrough_ = value;
        return this;
    }

    /// Check to see if this subcommand was parsed, true only if received on command line.
    /// This allows the subcommand to be directly checked.
    operator bool() const { return parsed_; }

    ///@}
    /// @name Extras for subclassing
    ///@{

    /// This allows subclasses to inject code before callbacks but after parse.
    ///
    /// This does not run if any errors or help is thrown.
    virtual void pre_callback() {}

    ///@}
    /// @name Parsing
    ///@{

    /// Parses the command line - throws errors
    /// This must be called after the options are in but before the rest of the program.
    void parse(int argc, char **argv) {
        // If the name is not set, read from command line
        if(name_.empty())
            name_ = argv[0];

        std::vector<std::string> args;
        for(int i = argc - 1; i > 0; i--)
            args.emplace_back(argv[i]);
        parse(args);
    }

    /// The real work is done here. Expects a reversed vector.
    /// Changes the vector to the remaining options.
    void parse(std::vector<std::string> &args) {
        _validate();
        _parse(args);
        run_callback();
    }

    /// Provide a function to print a help message. The function gets access to the App pointer and error.
    void set_failure_message(std::function<std::string(const App *, const Error &e)> function) {
        failure_message_ = function;
    }

    /// Print a nice error message and return the exit code
    int exit(const Error &e, std::ostream &out = std::cout, std::ostream &err = std::cerr) const {

        /// Avoid printing anything if this is a CLI::RuntimeError
        if(dynamic_cast<const CLI::RuntimeError *>(&e) != nullptr)
            return e.get_exit_code();

        if(dynamic_cast<const CLI::CallForHelp *>(&e) != nullptr) {
            out << help();
            return e.get_exit_code();
        }

        if(e.get_exit_code() != static_cast<int>(ExitCodes::Success)) {
            if(failure_message_)
                err << failure_message_(this, e) << std::flush;
        }

        return e.get_exit_code();
    }

    /// Reset the parsed data
    void reset() {

        parsed_ = false;
        missing_.clear();
        parsed_subcommands_.clear();

        for(const Option_p &opt : options_) {
            opt->clear();
        }
        for(const App_p &app : subcommands_) {
            app->reset();
        }
    }

    ///@}
    /// @name Post parsing
    ///@{

    /// Counts the number of times the given option was passed.
    size_t count(std::string name) const {
        for(const Option_p &opt : options_) {
            if(opt->check_name(name)) {
                return opt->count();
            }
        }
        throw OptionNotFound(name);
    }

    /// Get a subcommand pointer list to the currently selected subcommands (after parsing by default, in command line
    /// order)
    std::vector<App *> get_subcommands(bool parsed = true) const {
        if(parsed) {
            return parsed_subcommands_;
        } else {
            std::vector<App *> subcomms(subcommands_.size());
            std::transform(std::begin(subcommands_), std::end(subcommands_), std::begin(subcomms), [](const App_p &v) {
                return v.get();
            });
            return subcomms;
        }
    }

    /// Check to see if given subcommand was selected
    bool got_subcommand(App *subcom) const {
        // get subcom needed to verify that this was a real subcommand
        return get_subcommand(subcom)->parsed_;
    }

    /// Check with name instead of pointer to see if subcommand was selected
    bool got_subcommand(std::string name) const { return get_subcommand(name)->parsed_; }

    ///@}
    /// @name Help
    ///@{

    /// Set footer.
    App *set_footer(std::string footer) {
        footer_ = footer;
        return this;
    }

    /// Produce a string that could be read in as a config of the current values of the App. Set default_also to include
    /// default arguments. Prefix will add a string to the beginning of each option.
    std::string
    config_to_str(bool default_also = false, std::string prefix = "", bool write_description = false) const {
        std::stringstream out;
        for(const Option_p &opt : options_) {

            // Only process option with a long-name and configurable
            if(!opt->lnames_.empty() && opt->get_configurable()) {
                std::string name = prefix + opt->lnames_[0];
                std::string value;

                // Non-flags
                if(opt->get_type_size() != 0) {

                    // If the option was found on command line
                    if(opt->count() > 0)
                        value = detail::inijoin(opt->results());

                    // If the option has a default and is requested by optional argument
                    else if(default_also && !opt->defaultval_.empty())
                        value = opt->defaultval_;
                    // Flag, one passed
                } else if(opt->count() == 1) {
                    value = "true";

                    // Flag, multiple passed
                } else if(opt->count() > 1) {
                    value = std::to_string(opt->count());

                    // Flag, not present
                } else if(opt->count() == 0 && default_also) {
                    value = "false";
                }

                if(!value.empty()) {
                    if(write_description && opt->has_description()) {
                        if(static_cast<int>(out.tellp()) != 0) {
                            out << std::endl;
                        }
                        out << "; " << detail::fix_newlines("; ", opt->get_description()) << std::endl;
                    }
                    out << name << "=" << value << std::endl;
                }
            }
        }
        for(const App_p &subcom : subcommands_)
            out << subcom->config_to_str(default_also, prefix + subcom->name_ + ".");
        return out.str();
    }

    /// Makes a help message, with a column wid for column 1
    std::string help(size_t wid = 30, std::string prev = "") const {
        // Delegate to subcommand if needed
        if(prev.empty())
            prev = name_;
        else
            prev += " " + name_;

        auto selected_subcommands = get_subcommands();
        if(!selected_subcommands.empty())
            return selected_subcommands.at(0)->help(wid, prev);

        std::stringstream out;
        out << description_ << std::endl;
        out << "Usage:" << (prev.empty() ? "" : " ") << prev;

        // Check for options_
        bool npos = false;
        std::vector<std::string> groups;
        for(const Option_p &opt : options_) {
            if(opt->nonpositional()) {
                npos = true;

                // Add group if it is not already in there
                if(std::find(groups.begin(), groups.end(), opt->get_group()) == groups.end()) {
                    groups.push_back(opt->get_group());
                }
            }
        }

        if(npos)
            out << " [OPTIONS]";

        // Positionals
        bool pos = false;
        for(const Option_p &opt : options_)
            if(opt->get_positional()) {
                // A hidden positional should still show up in the usage statement
                // if(detail::to_lower(opt->get_group()).empty())
                //    continue;
                out << " " << opt->help_positional();
                if(opt->_has_help_positional())
                    pos = true;
            }

        if(!subcommands_.empty()) {
            if(require_subcommand_min_ > 0)
                out << " SUBCOMMAND";
            else
                out << " [SUBCOMMAND]";
        }

        out << std::endl;

        // Positional descriptions
        if(pos) {
            out << std::endl << "Positionals:" << std::endl;
            for(const Option_p &opt : options_) {
                if(detail::to_lower(opt->get_group()).empty())
                    continue; // Hidden
                if(opt->_has_help_positional())
                    detail::format_help(out, opt->help_pname(), opt->get_description(), wid);
            }
        }

        // Options
        if(npos) {
            for(const std::string &group : groups) {
                if(detail::to_lower(group).empty())
                    continue; // Hidden
                out << std::endl << group << ":" << std::endl;
                for(const Option_p &opt : options_) {
                    if(opt->nonpositional() && opt->get_group() == group)
                        detail::format_help(out, opt->help_name(true), opt->get_description(), wid);
                }
            }
        }

        // Subcommands
        if(!subcommands_.empty()) {
            std::set<std::string> subcmd_groups_seen;
            for(const App_p &com : subcommands_) {
                const std::string &group_key = detail::to_lower(com->get_group());
                if(group_key.empty() || subcmd_groups_seen.count(group_key) != 0)
                    continue; // Hidden or not in a group

                subcmd_groups_seen.insert(group_key);
                out << std::endl << com->get_group() << ":" << std::endl;
                for(const App_p &new_com : subcommands_)
                    if(detail::to_lower(new_com->get_group()) == group_key)
                        detail::format_help(out, new_com->get_name(), new_com->description_, wid);
            }
        }

        if(!footer_.empty()) {
            out << std::endl << footer_ << std::endl;
        }

        return out.str();
    }

    ///@}
    /// @name Getters
    ///@{

    /// Get the app or subcommand description
    std::string get_description() const { return description_; }

    /// Get the list of options (user facing function, so returns raw pointers)
    std::vector<Option *> get_options() const {
        std::vector<Option *> options(options_.size());
        std::transform(std::begin(options_), std::end(options_), std::begin(options), [](const Option_p &val) {
            return val.get();
        });
        return options;
    }

    /// Check the status of ignore_case
    bool get_ignore_case() const { return ignore_case_; }

    /// Check the status of fallthrough
    bool get_fallthrough() const { return fallthrough_; }

    /// Get the group of this subcommand
    const std::string &get_group() const { return group_; }

    /// Get footer.
    std::string get_footer() const { return footer_; }

    /// Get the required min subcommand value
    size_t get_require_subcommand_min() const { return require_subcommand_min_; }

    /// Get the required max subcommand value
    size_t get_require_subcommand_max() const { return require_subcommand_max_; }

    /// Get the prefix command status
    bool get_prefix_command() const { return prefix_command_; }

    /// Get the status of allow extras
    bool get_allow_extras() const { return allow_extras_; }

    /// Get the status of allow extras
    bool get_allow_ini_extras() const { return allow_ini_extras_; }

    /// Get a pointer to the help flag.
    Option *get_help_ptr() { return help_ptr_; }

    /// Get a pointer to the help flag. (const)
    const Option *get_help_ptr() const { return help_ptr_; }

    /// Get a pointer to the config option.
    Option *get_config_ptr() { return config_ptr_; }

    /// Get the parent of this subcommand (or nullptr if master app)
    App *get_parent() { return parent_; }

    /// Get a pointer to the config option. (const)
    const Option *get_config_ptr() const { return config_ptr_; }

    /// Get the name of the current app
    std::string get_name() const { return name_; }

    /// Check the name, case insensitive if set
    bool check_name(std::string name_to_check) const {
        std::string local_name = name_;
        if(ignore_case_) {
            local_name = detail::to_lower(name_);
            name_to_check = detail::to_lower(name_to_check);
        }

        return local_name == name_to_check;
    }

    /// This gets a vector of pointers with the original parse order
    const std::vector<Option *> &parse_order() const { return parse_order_; }

    /// This returns the missing options from the current subcommand
    std::vector<std::string> remaining(bool recurse = false) const {
        std::vector<std::string> miss_list;
        for(const std::pair<detail::Classifer, std::string> &miss : missing_) {
            miss_list.push_back(std::get<1>(miss));
        }

        // Recurse into subcommands
        if(recurse) {
            for(const App *sub : parsed_subcommands_) {
                std::vector<std::string> output = sub->remaining(recurse);
                std::copy(std::begin(output), std::end(output), std::back_inserter(miss_list));
            }
        }
        return miss_list;
    }

    /// This returns the number of remaining options, minus the -- seperator
    size_t remaining_size(bool recurse = false) const {
        size_t count = static_cast<size_t>(std::count_if(
            std::begin(missing_), std::end(missing_), [](const std::pair<detail::Classifer, std::string> &val) {
                return val.first != detail::Classifer::POSITIONAL_MARK;
            }));
        if(recurse) {
            for(const App_p &sub : subcommands_) {
                count += sub->remaining_size(recurse);
            }
        }
        return count;
    }

    ///@}

  protected:
    /// Check the options to make sure there are no conflicts.
    ///
    /// Currently checks to see if multiple positionals exist with -1 args
    void _validate() const {
        auto count = std::count_if(std::begin(options_), std::end(options_), [](const Option_p &opt) {
            return opt->get_items_expected() < 0 && opt->get_positional();
        });
        if(count > 1)
            throw InvalidError(name_);
        for(const App_p &app : subcommands_)
            app->_validate();
    }

    /// Internal function to run (App) callback, top down
    void run_callback() {
        pre_callback();
        if(callback_)
            callback_();
        for(App *subc : get_subcommands()) {
            subc->run_callback();
        }
    }

    /// Check to see if a subcommand is valid. Give up immediately if subcommand max has been reached.
    bool _valid_subcommand(const std::string &current) const {
        // Don't match if max has been reached - but still check parents
        if(require_subcommand_max_ != 0 && parsed_subcommands_.size() >= require_subcommand_max_) {
            return parent_ != nullptr && parent_->_valid_subcommand(current);
        }

        for(const App_p &com : subcommands_)
            if(com->check_name(current) && !*com)
                return true;

        // Check parent if exists, else return false
        return parent_ != nullptr && parent_->_valid_subcommand(current);
    }

    /// Selects a Classifier enum based on the type of the current argument
    detail::Classifer _recognize(const std::string &current) const {
        std::string dummy1, dummy2;

        if(current == "--")
            return detail::Classifer::POSITIONAL_MARK;
        if(_valid_subcommand(current))
            return detail::Classifer::SUBCOMMAND;
        if(detail::split_long(current, dummy1, dummy2))
            return detail::Classifer::LONG;
        if(detail::split_short(current, dummy1, dummy2))
            return detail::Classifer::SHORT;
        return detail::Classifer::NONE;
    }

    /// Internal parse function
    void _parse(std::vector<std::string> &args) {
        parsed_ = true;
        bool positional_only = false;

        while(!args.empty()) {
            _parse_single(args, positional_only);
        }

        if(help_ptr_ != nullptr && help_ptr_->count() > 0) {
            throw CallForHelp();
        }

        // Process an INI file
        if(config_ptr_ != nullptr) {
            if(*config_ptr_) {
                config_ptr_->run_callback();
                config_required_ = true;
            }
            if(!config_name_.empty()) {
                try {
                    std::vector<detail::ini_ret_t> values = detail::parse_ini(config_name_);
                    while(!values.empty()) {
                        if(!_parse_ini(values)) {
                            throw INIError::Extras(values.back().fullname);
                        }
                    }
                } catch(const FileError &) {
                    if(config_required_)
                        throw;
                }
            }
        }

        // Get envname options if not yet passed
        for(const Option_p &opt : options_) {
            if(opt->count() == 0 && !opt->envname_.empty()) {
                char *buffer = nullptr;
                std::string ename_string;

#ifdef _MSC_VER
                // Windows version
                size_t sz = 0;
                if(_dupenv_s(&buffer, &sz, opt->envname_.c_str()) == 0 && buffer != nullptr) {
                    ename_string = std::string(buffer);
                    free(buffer);
                }
#else
                // This also works on Windows, but gives a warning
                buffer = std::getenv(opt->envname_.c_str());
                if(buffer != nullptr)
                    ename_string = std::string(buffer);
#endif

                if(!ename_string.empty()) {
                    opt->add_result(ename_string);
                }
            }
        }

        // Process callbacks
        for(const Option_p &opt : options_) {
            if(opt->count() > 0 && !opt->get_callback_run()) {
                opt->run_callback();
            }
        }

        // Verify required options
        for(const Option_p &opt : options_) {
            // Required or partially filled
            if(opt->get_required() || opt->count() != 0) {
                // Make sure enough -N arguments parsed (+N is already handled in parsing function)
                if(opt->get_items_expected() < 0 && opt->count() < static_cast<size_t>(-opt->get_items_expected()))
                    throw ArgumentMismatch::AtLeast(opt->single_name(), -opt->get_items_expected());

                // Required but empty
                if(opt->get_required() && opt->count() == 0)
                    throw RequiredError(opt->single_name());
            }
            // Requires
            for(const Option *opt_req : opt->requires_)
                if(opt->count() > 0 && opt_req->count() == 0)
                    throw RequiresError(opt->single_name(), opt_req->single_name());
            // Excludes
            for(const Option *opt_ex : opt->excludes_)
                if(opt->count() > 0 && opt_ex->count() != 0)
                    throw ExcludesError(opt->single_name(), opt_ex->single_name());
        }

        auto selected_subcommands = get_subcommands();
        if(require_subcommand_min_ > selected_subcommands.size())
            throw RequiredError::Subcommand(require_subcommand_min_);

        // Convert missing (pairs) to extras (string only)
        if(!(allow_extras_ || prefix_command_)) {
            size_t num_left_over = remaining_size();
            if(num_left_over > 0) {
                args = remaining(false);
                std::reverse(std::begin(args), std::end(args));
                throw ExtrasError(args);
            }
        }
    }

    /// Parse one ini param, return false if not found in any subcommand, remove if it is
    ///
    /// If this has more than one dot.separated.name, go into the subcommand matching it
    /// Returns true if it managed to find the option, if false you'll need to remove the arg manually.
    bool _parse_ini(std::vector<detail::ini_ret_t> &args) {
        detail::ini_ret_t &current = args.back();
        std::string parent = current.parent(); // respects current.level
        std::string name = current.name();

        // If a parent is listed, go to a subcommand
        if(!parent.empty()) {
            current.level++;
            for(const App_p &com : subcommands_)
                if(com->check_name(parent))
                    return com->_parse_ini(args);
            return false;
        }

        auto op_ptr = std::find_if(
            std::begin(options_), std::end(options_), [name](const Option_p &v) { return v->check_lname(name); });

        if(op_ptr == std::end(options_)) {
            if(allow_ini_extras_) {
                // Should we worry about classifying the extras properly?
                missing_.emplace_back(detail::Classifer::NONE, current.fullname);
                args.pop_back();
                return true;
            }
            return false;
        }

        // Let's not go crazy with pointer syntax
        Option_p &op = *op_ptr;

        if(!op->get_configurable())
            throw INIError::NotConfigurable(current.fullname);

        if(op->results_.empty()) {
            // Flag parsing
            if(op->get_type_size() == 0) {
                if(current.inputs.size() == 1) {
                    std::string val = current.inputs.at(0);
                    val = detail::to_lower(val);
                    if(val == "true" || val == "on" || val == "yes")
                        op->results_ = {""};
                    else if(val == "false" || val == "off" || val == "no")
                        ;
                    else
                        try {
                            size_t ui = std::stoul(val);
                            for(size_t i = 0; i < ui; i++)
                                op->results_.emplace_back("");
                        } catch(const std::invalid_argument &) {
                            throw ConversionError::TrueFalse(current.fullname);
                        }
                } else
                    throw ConversionError::TooManyInputsFlag(current.fullname);
            } else {
                op->results_ = current.inputs;
                op->run_callback();
            }
        }

        args.pop_back();
        return true;
    }

    /// Parse "one" argument (some may eat more than one), delegate to parent if fails, add to missing if missing from
    /// master
    void _parse_single(std::vector<std::string> &args, bool &positional_only) {

        detail::Classifer classifer = positional_only ? detail::Classifer::NONE : _recognize(args.back());
        switch(classifer) {
        case detail::Classifer::POSITIONAL_MARK:
            missing_.emplace_back(classifer, args.back());
            args.pop_back();
            positional_only = true;
            break;
        case detail::Classifer::SUBCOMMAND:
            _parse_subcommand(args);
            break;
        case detail::Classifer::LONG:
            // If already parsed a subcommand, don't accept options_
            _parse_arg(args, true);
            break;
        case detail::Classifer::SHORT:
            // If already parsed a subcommand, don't accept options_
            _parse_arg(args, false);
            break;
        case detail::Classifer::NONE:
            // Probably a positional or something for a parent (sub)command
            _parse_positional(args);
        }
    }

    /// Count the required remaining positional arguments
    size_t _count_remaining_positionals(bool required = false) const {
        size_t retval = 0;
        for(const Option_p &opt : options_)
            if(opt->get_positional() && (!required || opt->get_required()) && opt->get_items_expected() > 0 &&
               static_cast<int>(opt->count()) < opt->get_items_expected())
                retval = static_cast<size_t>(opt->get_items_expected()) - opt->count();

        return retval;
    }

    /// Parse a positional, go up the tree to check
    void _parse_positional(std::vector<std::string> &args) {

        std::string positional = args.back();
        for(const Option_p &opt : options_) {
            // Eat options, one by one, until done
            if(opt->get_positional() &&
               (static_cast<int>(opt->count()) < opt->get_items_expected() || opt->get_items_expected() < 0)) {

                opt->add_result(positional);
                parse_order_.push_back(opt.get());
                args.pop_back();
                return;
            }
        }

        if(parent_ != nullptr && fallthrough_)
            return parent_->_parse_positional(args);
        else {
            args.pop_back();
            missing_.emplace_back(detail::Classifer::NONE, positional);

            if(prefix_command_) {
                while(!args.empty()) {
                    missing_.emplace_back(detail::Classifer::NONE, args.back());
                    args.pop_back();
                }
            }
        }
    }

    /// Parse a subcommand, modify args and continue
    ///
    /// Unlike the others, this one will always allow fallthrough
    void _parse_subcommand(std::vector<std::string> &args) {
        if(_count_remaining_positionals(/* required */ true) > 0)
            return _parse_positional(args);
        for(const App_p &com : subcommands_) {
            if(com->check_name(args.back())) {
                args.pop_back();
                if(std::find(std::begin(parsed_subcommands_), std::end(parsed_subcommands_), com.get()) ==
                   std::end(parsed_subcommands_))
                    parsed_subcommands_.push_back(com.get());
                com->_parse(args);
                return;
            }
        }
        if(parent_ != nullptr)
            return parent_->_parse_subcommand(args);
        else
            throw HorribleError("Subcommand " + args.back() + " missing");
    }

    /// Parse a short (false) or long (true) argument, must be at the top of the list
    void _parse_arg(std::vector<std::string> &args, bool second_dash) {

        detail::Classifer current_type = second_dash ? detail::Classifer::LONG : detail::Classifer::SHORT;

        std::string current = args.back();

        std::string name;
        std::string value;
        std::string rest;

        if(second_dash) {
            if(!detail::split_long(current, name, value))
                throw HorribleError("Long parsed but missing (you should not see this):" + args.back());
        } else {
            if(!detail::split_short(current, name, rest))
                throw HorribleError("Short parsed but missing! You should not see this");
        }

        auto op_ptr = std::find_if(std::begin(options_), std::end(options_), [name, second_dash](const Option_p &opt) {
            return second_dash ? opt->check_lname(name) : opt->check_sname(name);
        });

        // Option not found
        if(op_ptr == std::end(options_)) {
            // If a subcommand, try the master command
            if(parent_ != nullptr && fallthrough_)
                return parent_->_parse_arg(args, second_dash);
            // Otherwise, add to missing
            else {
                args.pop_back();
                missing_.emplace_back(current_type, current);
                return;
            }
        }

        args.pop_back();

        // Get a reference to the pointer to make syntax bearable
        Option_p &op = *op_ptr;

        int num = op->get_items_expected();

        // Make sure we always eat the minimum for unlimited vectors
        int collected = 0;

        // --this=value
        if(!value.empty()) {
            // If exact number expected
            if(num > 0)
                num--;
            op->add_result(value);
            parse_order_.push_back(op.get());
            collected += 1;
        } else if(num == 0) {
            op->add_result("");
            parse_order_.push_back(op.get());
            // -Trest
        } else if(!rest.empty()) {
            if(num > 0)
                num--;
            op->add_result(rest);
            parse_order_.push_back(op.get());
            rest = "";
            collected += 1;
        }

        // Unlimited vector parser
        if(num < 0) {
            while(!args.empty() && _recognize(args.back()) == detail::Classifer::NONE) {
                if(collected >= -num) {
                    // We could break here for allow extras, but we don't

                    // If any positionals remain, don't keep eating
                    if(_count_remaining_positionals() > 0)
                        break;
                }
                op->add_result(args.back());
                parse_order_.push_back(op.get());
                args.pop_back();
                collected++;
            }

            // Allow -- to end an unlimited list and "eat" it
            if(!args.empty() && _recognize(args.back()) == detail::Classifer::POSITIONAL_MARK)
                args.pop_back();

        } else {
            while(num > 0 && !args.empty()) {
                num--;
                std::string current_ = args.back();
                args.pop_back();
                op->add_result(current_);
                parse_order_.push_back(op.get());
            }

            if(num > 0) {
                throw ArgumentMismatch::TypedAtLeast(op->single_name(), num, op->get_type_name());
            }
        }

        if(!rest.empty()) {
            rest = "-" + rest;
            args.push_back(rest);
        }
    }
};

namespace FailureMessage {

inline std::string simple(const App *app, const Error &e) {
    std::string header = std::string(e.what()) + "\n";
    if(app->get_help_ptr() != nullptr)
        header += "Run with " + app->get_help_ptr()->single_name() + " for more information.\n";
    return header;
}

inline std::string help(const App *app, const Error &e) {
    std::string header = std::string("ERROR: ") + e.get_name() + ": " + e.what() + "\n";
    header += app->help();
    return header;
}

} // namespace FailureMessage

namespace detail {
/// This class is simply to allow tests access to App's protected functions
struct AppFriend {

    /// Wrap _parse_short, perfectly forward arguments and return
    template <typename... Args>
    static auto parse_arg(App *app, Args &&... args) ->
        typename std::result_of<decltype (&App::_parse_arg)(App, Args...)>::type {
        return app->_parse_arg(std::forward<Args>(args)...);
    }

    /// Wrap _parse_subcommand, perfectly forward arguments and return
    template <typename... Args>
    static auto parse_subcommand(App *app, Args &&... args) ->
        typename std::result_of<decltype (&App::_parse_subcommand)(App, Args...)>::type {
        return app->_parse_subcommand(std::forward<Args>(args)...);
    }
};
} // namespace detail

} // namespace CLI



================================================
FILE: src/Database.cpp
================================================
//
//  Database.cpp
//  OnlinePhotometricCalibration
//
//  Created by Paul on 16.11.17.
//  Copyright (c) 2017-2018 Paul Bergmann and co-authors. All rights reserved.
//
//  See LICENSE.txt
//

#include "Database.h"

/**
 * Initialize vignette model with some vignetting
 */
Database::Database(int image_width,int image_height) :
    m_vignette_estimate(-0.3,0,0,image_width,image_height),
    m_response_estimate()
{
    m_image_width  = image_width;
    m_image_height = image_height;
}

void Database::visualizeTracking()
{
    // Fetch tracking information and create a canvas
    Frame last_frame = m_tracked_frames.at(m_tracked_frames.size()-1);
    // Todo: change to class member
    cv::Mat draw_image = last_frame.m_image.clone();
    
    // Draw features on the canvas
    for(int i = 0;i < last_frame.m_features.size();i++)
    {
        cv::circle(draw_image, last_frame.m_features.at(i)->m_xy_location, 3, cv::Scalar(255,0,0));
    }
    
    // Correct the frame based on the current estimate
    // Todo: change to class member
    cv::Mat corrected_frame = last_frame.m_image.clone();
    
    for(int r = 0; r < corrected_frame.rows;r++)
    {
        for(int c = 0;c < corrected_frame.cols;c++)
        {
            // Apply rsponse and vignette for each pixel
            int o_value = corrected_frame.at<uchar>(r,c);
            double new_o_value = m_response_estimate.removeResponse(o_value);
            
            double v_factor = m_vignette_estimate.getVignetteFactor(cv::Point2f(c,r));
            new_o_value /= v_factor;
            
            // Correct by exposure time
            new_o_value /= last_frame.m_exp_time;
            if(new_o_value > 255)new_o_value = 255; 
            corrected_frame.at<uchar>(r,c) = (uchar)new_o_value;
        }
    }
    
    //resize drawing images to an acceptable size
    int image_width  = 640;
    int image_height = 480;
    
    cv::resize(draw_image, draw_image, cv::Size(image_width,image_height));
    cv::resize(corrected_frame, corrected_frame, cv::Size(image_width,image_height));
    
    // Display
    cv::imshow("Tracked frame", draw_image);
    cv::imshow("Corrected frame", corrected_frame);
    cv::waitKey(1);
}

void Database::visualizeRapidExposureTimeEstimates(double exponent)
{
    // Visualize exposure times 
    // If GT data is available, the estimated exposure times will be aligned 
    // to the GT by computing an optimal alignment factor alignment_alpha
    // If no GT data is available, the estimated exposure is simply scaled between [0,1]
    int nr_frames_to_vis = int(fmin(m_tracked_frames.size(),40));
    int exp_image_height = 150;
    int draw_spacing = 8;
    std::vector<double> estimated_exp_times;
    std::vector<double> gt_exp_times;
    double alignment_alpha = 1.0;
    double max_exp = -10000.0;
    double min_exp = 10000.0;
    double top = 0;
    double bot = 0;
    for(int i = 0;i < nr_frames_to_vis;i++)
    {
        // Fetch estimated and GT exposure time data, pow estimates with alignment exponent
        Frame current_frame = m_tracked_frames.at(m_tracked_frames.size()-nr_frames_to_vis+i);
        double frame_exp_time = pow(current_frame.m_exp_time,exponent);
        double frame_time_gt  = current_frame.m_gt_exp_time;

        // Keep track of max and min exposure to scale between [0,1]
        if(frame_exp_time > max_exp)
            max_exp = frame_exp_time;
        if(frame_exp_time < min_exp)
            min_exp = frame_exp_time;

        // Accumulate information for least square fit between GT and estimated exposure
        top += frame_exp_time*frame_time_gt;
        bot += frame_exp_time*frame_exp_time;
        
        // Push back estimated exposure values
        estimated_exp_times.push_back(frame_exp_time);

        // Push gt exposure time if available
        if(!(frame_time_gt < 0))
            gt_exp_times.push_back(frame_time_gt);
    }

    // Set alignment factor only if GT exposure is available
    if(gt_exp_times.size() == estimated_exp_times.size())
        alignment_alpha = top/bot;
    else
    {
        // Normalize estimated exposures between [0,1]
        for(int k = 0;k < estimated_exp_times.size();k++)
        {
            estimated_exp_times.at(k) = (estimated_exp_times.at(k)-min_exp)/(max_exp-min_exp);
        }
    }

    // Create exposure time canvas
    cv::Mat exposure_vis_image(exp_image_height,draw_spacing*nr_frames_to_vis,CV_8UC3,cv::Scalar(0,0,0));

    // Draw estimated exposure times as lines to graph
    for(int i = 0;i < nr_frames_to_vis-1;i++)
    {
        int drawing_y_exp_1 = exp_image_height - exp_image_height*(alignment_alpha * estimated_exp_times.at(i));
        drawing_y_exp_1 = int(fmax(0,drawing_y_exp_1));
        drawing_y_exp_1 = int(fmin(exp_image_height-1,drawing_y_exp_1));

        int drawing_y_exp_2 = exp_image_height - exp_image_height*(alignment_alpha * estimated_exp_times.at(i+1));
        drawing_y_exp_2 = int(fmax(0,drawing_y_exp_2));
        drawing_y_exp_2 = int(fmin(exp_image_height-1,drawing_y_exp_2));

        // Draw exposure lines
        cv::line(exposure_vis_image, cv::Point(draw_spacing*i,drawing_y_exp_1), cv::Point(draw_spacing*(i+1),drawing_y_exp_2), cv::Scalar(0,0,255));
     }

    // Draw GT exposure line only if GT exposure data is available
    if(gt_exp_times.size() == estimated_exp_times.size())
    {
        for(int i = 0;i < nr_frames_to_vis-1;i++)
        {
            int drawing_y_gt_exp_1 = exp_image_height - exp_image_height * gt_exp_times.at(i);
            drawing_y_gt_exp_1 = int(fmax(0,drawing_y_gt_exp_1));
            drawing_y_gt_exp_1 = int(fmin(exp_image_height-1,drawing_y_gt_exp_1));

            int drawing_y_gt_exp_2 = exp_image_height - exp_image_height * gt_exp_times.at(i+1);
            drawing_y_gt_exp_2 = int(fmax(0,drawing_y_gt_exp_2));
            drawing_y_gt_exp_2 = int(fmin(exp_image_height-1,drawing_y_gt_exp_2));

            cv::line(exposure_vis_image, cv::Point(draw_spacing*i,drawing_y_gt_exp_1), cv::Point(draw_spacing*(i+1),drawing_y_gt_exp_2), cv::Scalar(255,255,0));
        }
    }   

    cv::imshow("Estimated Exposure (Rapid)", exposure_vis_image);
    cv::moveWindow("Estimated Exposure (Rapid)", 20+20+256,20);

}

// Todo: change the return to parameter passed by reference
std::vector<cv::Point2f> Database::fetchActiveFeatureLocations()
{
    std::vector<cv::Point2f> point_locations;
    
    Frame last_frame = m_tracked_frames.at(m_tracked_frames.size()-1);
    
    for(int i = 0;i < last_frame.m_features.size();i++)
    {
        point_locations.push_back(last_frame.m_features.at(i)->m_xy_location);
    }
    
    return point_locations;
}

void Database::removeLastFrame()
{
    // Erase the information about the first frame
    m_tracked_frames.erase(m_tracked_frames.begin());
    
    // Let all pointers of the new first frame point to NULL
    for(int i = 0;i < m_tracked_frames.at(0).m_features.size();i++)
    {
        m_tracked_frames.at(0).m_features.at(i)->m_prev_feature = NULL;
    }
}



================================================
FILE: src/Database.h
================================================
//
//  Database.h
//  OnlinePhotometricCalibration
//
//  Created by Paul on 16.11.17.
//  Copyright (c) 2017-2018 Paul Bergmann and co-authors. All rights reserved.
//
//  See LICENSE.txt
//

#ifndef OnlinePhotometricCalibration_Database_h_
#define OnlinePhotometricCalibration_Database_h_

#include "StandardIncludes.h"
#include "Frame.h"
#include "VignetteModel.h"
#include "ResponseModel.h"

class Database
{
    
public:
    
    /**
     * Initialize database
     *
     * @param image_width  Width of input images in pixels
     * @param image_height Height of input images in pixels
     */
    Database(int image_width,int image_height);
    
    /**
     * Tracked frames, exposure time estimates + radiance estimates of tracked points
     * Frames also include the tracking information + output intensities
     */
    std::vector<Frame> m_tracked_frames;
    
    /**
     * Vignette and response estimates
     */
    VignetteModel m_vignette_estimate;
    ResponseModel m_response_estimate;
    
    /**
     * Information about stored image size
     */
    int m_image_width;
    int m_image_height;
    
    /**
     * Fetch current active feature locations
     *
     * @returns Vector of feature locations active in the most current frame
     */
    std::vector<cv::Point2f> fetchActiveFeatureLocations();
    
    /**
     * Fetch most current image
     *
     * @returns Most current image in the databse
     */
     // Todo: change return type to reference
    cv::Mat fetchActiveImage()
    {
        return m_tracked_frames.at(m_tracked_frames.size()-1).m_image;
    }
    
    /**
     * Remove last frame and tracking information from the database
     */
    void removeLastFrame();
    
    /**
     * Visualize the current tracking state
     * Shows current active image with feature locations 
     * And corrected image based on current photometric estimates
     * Calling this method slows down performance of the system significantly
     */
    void visualizeTracking();

    /**
    * Visualize the rapid exposure time estimates
    */
    void visualizeRapidExposureTimeEstimates(double exponent);

};

#endif // include guard


================================================
FILE: src/Feature.h
================================================
//
//  Feature.h
//  OnlinePhotometricCalibration
//
//  Created by Paul on 16.11.17.
//  Copyright (c) 2017-2018 Paul Bergmann and co-authors. All rights reserved.
//
//  See LICENSE.txt
//

#ifndef OnlinePhotometricCalibration_Feature_h_
#define OnlinePhotometricCalibration_Feature_h_

#include <stdio.h>

#include "StandardIncludes.h"

/**
 * Stores tracking information of one feature in one particular image
 */

class Feature
{
    
public:
    
    /**
     * Location of the feature in the image
     */
    cv::Point2f m_xy_location;
    
    /**
     * Output values of the image patch centered around the feature location
     */
    std::vector<double> m_output_values;
    
    /**
     * Radiance estimates of the image patch centered around the feature location
     */
    std::vector<double> m_radiance_estimates;
    
    /**
     * Gradient values of the image patch centered around the feature location
     */
    std::vector<double> m_gradient_values;
    
    /*
     * Link to the feature in the previous image corresponding to the same scene point
     * (Obtained from tracking)
     */
    Feature* m_prev_feature;
    
    /*
     * Link to the feature in the previous image corresponding to the same scene point
     * (Obtained from tracking)
     */
    Feature* m_next_feature;
    
};

#endif // include guard


================================================
FILE: src/Frame.h
================================================
//
//  Frame.h
//  OnlinePhotometricCalibration
//
//  Created by Paul on 16.11.17.
//  Copyright (c) 2017-2018 Paul Bergmann and co-authors. All rights reserved.
//
//  See LICENSE.txt
//

#ifndef OnlinePhotometricCalibration_Frame_h_
#define OnlinePhotometricCalibration_Frame_h_

#include "StandardIncludes.h"
#include "Feature.h"

/**
 * Stores tracking information for one entire image
 */
class Frame
{
    
public:
    
    /**
     * Original input image
     */
    cv::Mat m_image;
    
    /**
     * Photometrically corrected image
     */
    cv::Mat m_image_corrected;
    
    /**
     * Gradient information
     */
    cv::Mat m_gradient_image;
    
    /**
     * List of features present in this frame
     */
    std::vector<Feature*> m_features;
    
    /**
     * Exposure time estimate (from rapid exposure time estimation)
     */
    double m_exp_time;

    /**
    * Ground truth exposure time if available
    */
    double m_gt_exp_time;
};

#endif // include guard


================================================
FILE: src/GainRobustTracker.cpp
================================================
//
//  GainRobustTracker.cpp
//  OnlinePhotometricCalibration
//
//  Created by Paul on 17.11.17.
//  Copyright (c) 2017-2018 Paul Bergmann and co-authors. All rights reserved.
//
//  See LICENSE.txt
//

#include "GainRobustTracker.h"

GainRobustTracker::GainRobustTracker(int patch_size,int pyramid_levels)
{
    // Initialize patch size and pyramid levels
    m_patch_size = patch_size;
    m_pyramid_levels = pyramid_levels;
}

// Todo: change frame_1 frame 2 to ref (or const ref), pts_1 to ref
double GainRobustTracker::trackImagePyramids(cv::Mat frame_1,
                                             cv::Mat frame_2,
                                             std::vector<cv::Point2f> pts_1,
                                             std::vector<cv::Point2f>& pts_2,
                                             std::vector<int>& point_status)
{
    // All points valid in the beginning of tracking
    std::vector<int> point_validity;
    for(int i = 0;i < pts_1.size();i++)
    {
        point_validity.push_back(1);
    }
    
    // Calculate image pyramid of frame 1 and frame 2
    std::vector<cv::Mat> new_pyramid;
    cv::buildPyramid(frame_2, new_pyramid, m_pyramid_levels);
    
    std::vector<cv::Mat> old_pyramid;
    cv::buildPyramid(frame_1, old_pyramid, m_pyramid_levels);
    
    // Temporary vector to update tracking estiamtes over time
    std::vector<cv::Point2f> tracking_estimates = pts_1;
    
    double all_exp_estimates = 0.0;
    int nr_estimates = 0;
    
    // Iterate all pyramid levels and perform gain robust KLT on each level (coarse to fine)
    for(int level = (int)new_pyramid.size()-1;level >= 0;level--)
    {
        // Scale the input points and tracking estimates to the current pyramid level
        std::vector<cv::Point2f> scaled_tracked_points;
        std::vector<cv::Point2f> scaled_tracking_estimates;
        for(int i = 0;i < pts_1.size();i++)
        {
            cv::Point2f scaled_point;
            scaled_point.x = (float)(pts_1.at(i).x/pow(2,level));
            scaled_point.y = (float)(pts_1.at(i).y/pow(2,level));
            scaled_tracked_points.push_back(scaled_point);
            
            cv::Point2f scaled_estimate;
            scaled_estimate.x = (float)(tracking_estimates.at(i).x/pow(2,level));
            scaled_estimate.y = (float)(tracking_estimates.at(i).y/pow(2,level));
            scaled_tracking_estimates.push_back(scaled_estimate);
        }
        
        // Perform tracking on current level
        double exp_estimate = trackImageExposurePyr(old_pyramid.at(level),
                                                    new_pyramid.at(level),
                                                    scaled_tracked_points,
                                                    scaled_tracking_estimates,
                                                    point_validity);
        
        // Optional: Do something with the estimated exposure ratio
        // std::cout << "Estimated exposure ratio of current level: " << exp_estimate << std::endl;
        
        // Average estimates of each level later
        all_exp_estimates += exp_estimate;
        nr_estimates++;
        
        // Update the current tracking result by scaling down to pyramid level 0
        for(int i = 0;i < scaled_tracking_estimates.size();i++)
        {
            if(point_validity.at(i) == 0)
                continue;
            
            cv::Point2f scaled_point;
            scaled_point.x = (float)(scaled_tracking_estimates.at(i).x*pow(2,level));
            scaled_point.y = (float)(scaled_tracking_estimates.at(i).y*pow(2,level));
            
            tracking_estimates.at(i) = scaled_point;
        }
    }
    
    // Write result to output vectors passed by reference
    pts_2 = tracking_estimates;
    point_status = point_validity;
    
    // Average exposure ratio estimate
    double overall_exp_estimate = all_exp_estimates / nr_estimates;
    return overall_exp_estimate;
}

/**
 * For a reference on the meaning of the optimization variables and the overall concept of this function
 * refer to the photometric calibration paper 
 * introducing gain robust KLT tracking by Kim et al.
 */
 // Todo: change Mat and vector to ref
double GainRobustTracker::trackImageExposurePyr(cv::Mat old_image,
                                                cv::Mat new_image,
                                                std::vector<cv::Point2f> input_points,
                                                std::vector<cv::Point2f>& output_points,
                                                std::vector<int>& point_validity)
{
    // Number of points to track
    int nr_points = static_cast<int>(input_points.size());
    
    // Updated point locations which are updated throughout the iterations
    if(output_points.size() == 0)
    {
        output_points = input_points;
    }
    else if(output_points.size() != input_points.size())
    {
        std::cout << "ERROR - OUTPUT POINT SIZE != INPUT POINT SIZE!" << std::endl;
        return -1;
    }
    
    // Input image dimensions
    int image_rows = new_image.rows;
    int image_cols = new_image.cols;
    
    // Final exposure time estimate
    double K_total = 0.0;
    
    for(int round = 0;round < 1;round++)
    {
        // Get the currently valid points
        int nr_valid_points = getNrValidPoints(point_validity);
        
        // Allocate space for W,V matrices
        cv::Mat W(2*nr_valid_points,1,CV_64F,0.0);
        cv::Mat V(2*nr_valid_points,1,CV_64F,0.0);
        
        // Allocate space for U_INV and the original Us
        cv::Mat U_INV(2*nr_valid_points,2*nr_valid_points,CV_64F,0.0);
        std::vector<cv::Mat> Us;
        
        double lambda = 0;
        double m = 0;

        int absolute_point_index = -1;
        
        for(int p = 0;p < input_points.size();p++)
        {
            if(point_validity.at(p) == 0)
            {
                continue;
            }
            
            absolute_point_index++;
            
            // Build U matrix
            cv::Mat U(2,2, CV_64F, 0.0);
            
            // Bilinear image interpolation
            cv::Mat patch_intensities_1;
            cv::Mat patch_intensities_2;
            int absolute_patch_size = ((m_patch_size+1)*2+1);  // Todo: why m_patch_size+1?
            cv::getRectSubPix(new_image, cv::Size(absolute_patch_size,absolute_patch_size), output_points.at(p), patch_intensities_2,CV_32F);
            cv::getRectSubPix(old_image, cv::Size(absolute_patch_size,absolute_patch_size), input_points.at(p), patch_intensities_1,CV_32F);
            
            // Go through image patch around this point
            for(int r = 0; r < 2*m_patch_size+1;r++)
            {
                for(int c = 0; c < 2*m_patch_size+1;c++)
                {
                    // Fetch patch intensity values
                    double i_frame_1 = patch_intensities_1.at<float>(1+r,1+c);
                    double i_frame_2 = patch_intensities_2.at<float>(1+r,1+c);
                    
                    if(i_frame_1 < 1)
                        i_frame_1 = 1;
                    if(i_frame_2 < 1)
                        i_frame_2 = 1;
                    
                    // Estimate patch gradient values
                    double grad_1_x = (patch_intensities_1.at<float>(1+r,1+c+1) - patch_intensities_1.at<float>(1+r,1+c-1))/2;
                    double grad_1_y = (patch_intensities_1.at<float>(1+r+1,1+c) - patch_intensities_1.at<float>(1+r-1,1+c))/2;
                    
                    double grad_2_x = (patch_intensities_2.at<float>(1+r,1+c+1) - patch_intensities_2.at<float>(1+r,1+c-1))/2;
                    double grad_2_y = (patch_intensities_2.at<float>(1+r+1,1+c) - patch_intensities_2.at<float>(1+r-1,1+c))/2;
                    
                    double a = (1.0/i_frame_2)*grad_2_x + (1.0/i_frame_1)*grad_1_x;
                    double b = (1.0/i_frame_2)*grad_2_y + (1.0/i_frame_1)*grad_1_y;
                    double beta = log(i_frame_2/255.0) - log(i_frame_1/255.0);
                    
                    U.at<double>(0,0) += 0.5*a*a;
                    U.at<double>(1,0) += 0.5*a*b;
                    U.at<double>(0,1) += 0.5*a*b;
                    U.at<double>(1,1) += 0.5*b*b;
                    
                    W.at<double>(2*absolute_point_index,0)   -= a;
                    W.at<double>(2*absolute_point_index+1,0) -= b;
                    
                    V.at<double>(2*absolute_point_index,0)   -= beta*a;
                    V.at<double>(2*absolute_point_index+1,0) -= beta*b;
                    
                    lambda += 2;
                    m += 2*beta;
                }
            }
            
            //Back up U for re-substitution
            Us.push_back(U);
            
            //Invert matrix U for this point and write it to diagonal of overall U_INV matrix
            cv::Mat U_INV_p = U.inv();
            //std::cout << cv::determinant(U_INV_p) << std::endl;
            //std::cout << U_INV_p << std::endl;
            //std::cout << U << std::endl;
            
            U_INV.at<double>(2*absolute_point_index,2*absolute_point_index) = U_INV_p.at<double>(0,0);
            U_INV.at<double>(2*absolute_point_index+1,2*absolute_point_index) = U_INV_p.at<double>(1,0);
            U_INV.at<double>(2*absolute_point_index,2*absolute_point_index+1) = U_INV_p.at<double>(0,1);
            U_INV.at<double>(2*absolute_point_index+1,2*absolute_point_index+1) = U_INV_p.at<double>(1,1);
        }

        // Todo: check if opencv utilizes the sparsity of U
        //solve for the exposure
        cv::Mat K_MAT;
        cv::solve(-W.t()*U_INV*W+lambda, -W.t()*U_INV*V+m, K_MAT);
        double K = K_MAT.at<double>(0,0);
        
        //std::cout << -W.t()*U_INV*W+lambda << std::endl;
        //std::cout << -W.t()*U_INV*V+m << std::endl;
        //std::cout << K_MAT << std::endl;
        
        // Solve for the displacements
        absolute_point_index = -1;
        for(int p = 0;p < nr_points;p++)
        {
            if(point_validity.at(p) == 0)
                continue;
            
            absolute_point_index++;
            
            cv::Mat U_p = Us.at(absolute_point_index);
            cv::Mat V_p = V(cv::Rect(0,2*absolute_point_index,1,2));
            cv::Mat W_p = W(cv::Rect(0,2*absolute_point_index,1,2));
            
            cv::Mat displacement;
            cv::solve(U_p, V_p - K*W_p, displacement);
            
            //std::cout << displacement << std::endl;
            
            output_points.at(p).x += displacement.at<double>(0,0);
            output_points.at(p).y += displacement.at<double>(1,0);
            
            // Filter out this point if too close at the boundaries
            int filter_margin = 2;
            double x = output_points.at(p).x;
            double y = output_points.at(p).y;
            // Todo: the latter two should be ">=" ?
            if(x < filter_margin || y < filter_margin || x > image_cols-filter_margin || y > image_rows-filter_margin)
            {
                point_validity.at(p) = 0;
            }
        }
        
        K_total += K;
    }
    
    return exp(K_total);
}

int GainRobustTracker::getNrValidPoints(std::vector<int> validity_vector)
{
    // Simply sum up the validity vector
    int result = 0;
    for(int i = 0;i < validity_vector.size();i++)
    {
        result += validity_vector.at(i);
    }
    return result;
}


================================================
FILE: src/GainRobustTracker.h
================================================
//
//  GainRobustTracker.h
//  OnlinePhotometricCalibration
//
//  Created by Paul on 17.11.17.
//  Copyright (c) 2017-2018 Paul Bergmann and co-authors. All rights reserved.
//
//  See LICENSE.txt
//

#ifndef OnlinePhotometricCalibration_GainRobustTracker_h_
#define OnlinePhotometricCalibration_GainRobustTracker_h_

#include "StandardIncludes.h"

/**
 * This class implements gain robust KLT tracking
 * optimizing jointly for displacements of features and an exposure ratio between input frames
 */

class GainRobustTracker
{
    
public:
    
    /**
     * Constructor 
     * 
     * @param patch_size Size of tracking patches
     * @param pyramid_levels Number of pyramid levels used for KLT tracking
     */
    GainRobustTracker(int patch_size,int pyramid_levels);
    
    /*
     * Track a new image using exposure estimation + image pyramids
     *
     * @param frame_1 Frame to track points from
     * @param frame_2 Frame to track points to
     * @param pts_1 Given point locations in frame_1
     * @param pts_2 Output point locations in frame_2 (tracked from frame_1 to frame_2)
     * @param point_status Vector indicating point validity (set to 0 by tracker if e.g. tracked patches leave input images)
     * @returns Exposure ratio estimate between frame_1 and frame_2 based on KLT optimization
     */
    double trackImagePyramids(cv::Mat frame_1,
                              cv::Mat frame_2,
                              std::vector<cv::Point2f> pts_1,
                              std::vector<cv::Point2f>& pts_2,
                              std::vector<int>& point_status);
    
private:
    
    /*
     * Patch size used for tracking of image patches
     */
    int m_patch_size;
    
    /*
     * Number of pyramid levels used for tracking
     */
    int m_pyramid_levels;
    
    /**
     * Get number of valid points inside the specified validity vector
     * 
     * @param validity_vector Vector of validity flags corresponding to tracking points
     * @returns Number of valid flags inside the input vector
     */
    int getNrValidPoints(std::vector<int> validity_vector);
    
    /**
     * Track points on a specific pyramid layer
     *
     * @param old_image First input image
     * @param new_image Second input image, track new features to this image
     * @param input_points Original points in first input image
     * @param output_points Tracked point locations in second input image
     * @returns Exposure ratio estimate between first and second input image
     */
    double trackImageExposurePyr(cv::Mat old_image,
                                 cv::Mat new_image,
                                 std::vector<cv::Point2f> input_points,
                                 std::vector<cv::Point2f>& output_points,
                                 std::vector<int>& point_validity);
};

#endif // include guard


================================================
FILE: src/ImageReader.cpp
================================================
//
//  ImageReader.cpp
//  OnlinePhotometricCalibration
//
//  Created by Paul on 16.11.17.
//  Copyright (c) 2017-2018 Paul Bergmann and co-authors. All rights reserved.
//
//  See LICENSE.txt
//

#include "ImageReader.h"

ImageReader::ImageReader(std::string image_folder,
                         cv::Size new_img_size)
{
    m_img_new_size = new_img_size;
    getDir(image_folder, m_files);
    printf("ImageReader: got %d files in %s!\n", (int)m_files.size(), image_folder.c_str());
}

cv::Mat ImageReader::readImage(int image_index)
{
    // Read image from disk
    cv::Mat image = cv::imread(m_files.at(image_index), CV_LOAD_IMAGE_GRAYSCALE);
        
    if(!image.data)
    {
        std::cout << "ERROR READING IMAGE " << m_files.at(image_index) << std::endl;
        return cv::Mat();
    }
    
    // Resize input image
    cv::resize(image, image, m_img_new_size);
    
    return image;
}

int ImageReader::getDir(std::string dir, std::vector<std::string> &files)
{
    DIR *dp;
    struct dirent *dirp;
    if((dp = opendir(dir.c_str())) == NULL)
    {
        return -1;
    }

    while ((dirp = readdir(dp)) != NULL)
    {
        std::string name = std::string(dirp->d_name);

        if(name != "." && name != "..")
            files.push_back(name);
    }

    closedir(dp);
    std::sort(files.begin(), files.end());

    if(dir.at(dir.length() - 1) != '/')
        dir = dir+"/";

    for(unsigned int i = 0; i < files.size(); i++)
    {
        if(files[i].at(0) != '/')
            files[i] = dir + files[i];
    }

    return (int)files.size();
}


================================================
FILE: src/ImageReader.h
================================================
//
//  ImageReader.h
//  OnlinePhotometricCalibration
//
//  Created by Paul on 16.11.17.
//  Copyright (c) 2017-2018 Paul Bergmann and co-authors. All rights reserved.
//
//  See LICENSE.txt
//

#ifndef OnlinePhotometricCalibration_ImageReader_h_
#define OnlinePhotometricCalibration_ImageReader_h_

#include <stdio.h>
#include <iostream>
#include <dirent.h>

#include "StandardIncludes.h"

/**
 * Read input images from image files
 * Resizes the images if requested
 */

class ImageReader
{
public:
    
    /** 
     * Initialize the image reader
     * @param image_folder Image folder
     * @param new_size Resize input images to new_size
     */
    ImageReader(std::string image_folder,
                cv::Size new_size);

    /**
     * Read a new input image from the hard drive and return it
     *
     * @param Input image index to read
     * @return Read input image
     */
    cv::Mat readImage(int image_index);

    int getNumImages() { return (int)m_files.size(); }

    int getDir(std::string dir, std::vector<std::string> &files);
    
private:
    
    /**
     * Resize images to this size
     */
    cv::Size m_img_new_size;

    std::vector<std::string> m_files;
};

#endif // include guard


================================================
FILE: src/JacobianGenerator.cpp
================================================
//
//  JacobianGenerator.cpp
//  OnlinePhotometricCalibration
//
//  Created by Paul on 16.11.17.
//  Copyright (c) 2017-2018 Paul Bergmann and co-authors. All rights reserved.
//
//  See LICENSE.txt
//

#include "JacobianGenerator.h"

JacobianGenerator::JacobianGenerator()
{
    // Nothing to initialize
}

void JacobianGenerator::getRawJacobianRow(double I,
                                          double r,
                                          double e,
                                          std::vector<double>& j_res,
                                          std::vector<double>& j_vig,
                                          double& j_e,
                                          double& j_I)
{
    j_res.clear();
    j_vig.clear();
    
    // Get the vignetting value
    double a2 = m_vignetting_params.at(0);
    double a4 = m_vignetting_params.at(1);
    double a6 = m_vignetting_params.at(2);
    double r2 = r * r;
    double r4 = r2 * r2;
    double r6 = r4 * r2;
    double v  = 1 + a2*r2 + a4*r4 + a6*r6;
        
    // Evaluate the Grossberg base functions at the derivatives for the other derivatives
    double eIv = e * I * v;
    double h_0_d = evaluateGrossbergBaseFunction(0, true, eIv);
    double h_1_d = evaluateGrossbergBaseFunction(1, true, eIv);
    double h_2_d = evaluateGrossbergBaseFunction(2, true, eIv);
    double h_3_d = evaluateGrossbergBaseFunction(3, true, eIv);
    double h_4_d = evaluateGrossbergBaseFunction(4, true, eIv);
        
    double deriv_value = h_0_d +
                         m_response_params.at(0)*h_1_d +
                         m_response_params.at(1)*h_2_d +
                         m_response_params.at(2)*h_3_d +
                         m_response_params.at(3)*h_4_d;
    
    // Derive by the 4 Grossberg parameters
    double j_res_1  = 255*evaluateGrossbergBaseFunction(1, false, eIv);
    double j_res_2  = 255*evaluateGrossbergBaseFunction(2, false, eIv);
    double j_res_3  = 255*evaluateGrossbergBaseFunction(3, false, eIv);
    double j_res_4  = 255*evaluateGrossbergBaseFunction(4, false, eIv);
        
    j_res.push_back(j_res_1);
    j_res.push_back(j_res_2);
    j_res.push_back(j_res_3);
    j_res.push_back(j_res_4);
    
    // Derive by the 3 vignetting parameters
    double j_vig_1 = 255 * deriv_value * e * I * r2;
    double j_vig_2 = 255 * deriv_value * e * I * r4;
    double j_vig_3 = 255 * deriv_value * e * I * r6;
    
    j_vig.push_back(j_vig_1);
    j_vig.push_back(j_vig_2);
    j_vig.push_back(j_vig_3);
    
    // Derive by exposure time
    j_e = 255 * deriv_value * (I*v);

    double j_I_temp;
    getJacobianRadiance(I, r, e, j_I_temp);
    j_I = j_I_temp;
}

void JacobianGenerator::getJacobianRow_eca(double I,
                                           double r,
                                           double e,
                                           cv::Mat jacobian,
                                           int image_index,
                                           int residual_index)
{
    // Get the vignetting value
    double a2 = m_vignetting_params.at(0);
    double a4 = m_vignetting_params.at(1);
    double a6 = m_vignetting_params.at(2);
    double r2 = r * r;
    double r4 = r2 * r2;
    double r6 = r4 * r2;
    double v  = 1 + a2*r2 + a4*r4 + a6*r6;
        
    // Evaluate the grossberg base functions' derivatives for the other derivatives
    double eIv = e * I * v;
    double h_0_d = evaluateGrossbergBaseFunction(0, true, eIv);
    double h_1_d = evaluateGrossbergBaseFunction(1, true, eIv);
    double h_2_d = evaluateGrossbergBaseFunction(2, true, eIv);
    double h_3_d = evaluateGrossbergBaseFunction(3, true, eIv);
    double h_4_d = evaluateGrossbergBaseFunction(4, true, eIv);

    double deriv_value = h_0_d +
                         m_response_params.at(0)*h_1_d +
                         m_response_params.at(1)*h_2_d +
                         m_response_params.at(2)*h_3_d +
                         m_response_params.at(3)*h_4_d;
        
    // Derive by the 4 Grossberg parameters
    jacobian.at<double>(residual_index,0) = 255*evaluateGrossbergBaseFunction(1, false, eIv);
    jacobian.at<double>(residual_index,1) = 255*evaluateGrossbergBaseFunction(2, false, eIv);
    jacobian.at<double>(residual_index,2) = 255*evaluateGrossbergBaseFunction(3, false, eIv);
    jacobian.at<double>(residual_index,3) = 255*evaluateGrossbergBaseFunction(4, false, eIv);
    
    // Derive by the 3 vignetting parameters
    jacobian.at<double>(residual_index,4) = 255 * deriv_value * e * I * r2;
    jacobian.at<double>(residual_index,5) = 255 * deriv_value * e * I * r4;
    jacobian.at<double>(residual_index,6) = 255 * deriv_value * e * I * r6;
        
    // Derive by exposure time
    jacobian.at<double>(residual_index,7+image_index) = 255 * deriv_value * (I*v);
}

void JacobianGenerator::getJacobianRadiance(double I,double r,double e,double& j_I)
{
    double a2 = m_vignetting_params.at(0);
    double a4 = m_vignetting_params.at(1);
    double a6 = m_vignetting_params.at(2);
    
    // Get the vignetting value
    double r2 = r * r;
    double r4 = r2 * r2;
    double r6 = r4 * r2;
    double v  = 1 + a2*r2 + a4*r4 + a6*r6;
        
    // Evaluate the Grossberg base functions' derivatives for the other derivatives
    double h_0_d = evaluateGrossbergBaseFunction(0, true, e*I*v);
    double h_1_d = evaluateGrossbergBaseFunction(1, true, e*I*v);
    double h_2_d = evaluateGrossbergBaseFunction(2, true, e*I*v);
    double h_3_d = evaluateGrossbergBaseFunction(3, true, e*I*v);
    double h_4_d = evaluateGrossbergBaseFunction(4, true, e*I*v);
        
    double deriv_value = h_0_d +
                         m_response_params.at(0)*h_1_d +
                         m_response_params.at(1)*h_2_d +
                         m_response_params.at(2)*h_3_d +
                         m_response_params.at(3)*h_4_d;
    
    j_I = 255 * deriv_value * (e*v);
}


double JacobianGenerator::evaluateGrossbergBaseFunction(int base_function_index,bool is_derivative,double x)
{
    if(x < 0)x = 0.0;
    else if(x > 1)x = 1.0;
    
    int x_int = round(x*1023);
    int x_der_int = round(x*1021);
    
    if(base_function_index == 0)
    {
        if(!is_derivative)
        {
            return m_f_0[x_int];
        }
        else
        {
            return m_f_0_der[x_der_int];
        }
    }
    
    if(base_function_index == 1)
    {
        if(!is_derivative)
        {
            return m_h_1[x_int];
        }
        else
        {
            return m_h_1_der[x_der_int];
        }
    }
    
    if(base_function_index == 2)
    {
        if(!is_derivative)
        {
            return m_h_2[x_int];
        }
        else
        {
            return m_h_2_der[x_der_int];
        }
    }
    
    if(base_function_index == 3)
    {
        if(!is_derivative)
        {
            return m_h_3[x_int];
        }
        else
        {
            return m_h_3_der[x_der_int];
        }
    }
    
    if(base_function_index == 4)
    {
        if(!is_derivative)
        {
            return m_h_4[x_int];
        }
        else
        {
            return m_h_4_der[x_der_int];
        }
    }
    
    // Error code
    return -1.0;
}

double JacobianGenerator::applyGrossbergResponse(double x)
{
    double v0 = evaluateGrossbergBaseFunction(0, false, x);
    double v1 = evaluateGrossbergBaseFunction(1, false, x);
    double v2 = evaluateGrossbergBaseFunction(2, false, x);
    double v3 = evaluateGrossbergBaseFunction(3, false, x);
    double v4 = evaluateGrossbergBaseFunction(4, false, x);
    
    double c1 = m_response_params.at(0);
    double c2 = m_response_params.at(1);
    double c3 = m_response_params.at(2);
    double c4 = m_response_params.at(3);
    
    return v0 + c1*v1 + c2*v2 + c3*v3 + c4*v4;
}

std::vector<double> JacobianGenerator::fitGrossbergModelToResponseVector(double* response)
{
    // Given a response vector, find Grossberg parameters that fit well
    cv::Mat LeftSide(4,4,CV_64F,0.0);
    cv::Mat RightSide(4,1,CV_64F,0.0);
    
    for(int i = 10;i < 240;i++)
    {
        response[i] /= 255.0;
        
        double input = i/256.0;
        
        double f0 = evaluateGrossbergBaseFunction(0, false, input);
        double f1 = evaluateGrossbergBaseFunction(1, false, input);
        double f2 = evaluateGrossbergBaseFunction(2, false, input);
        double f3 = evaluateGrossbergBaseFunction(3, false, input);
        double f4 = evaluateGrossbergBaseFunction(4, false, input);

        // For equation 1
        LeftSide.at<double>(0,0) += f1*f1;
        LeftSide.at<double>(0,1) += f1*f2;
        LeftSide.at<double>(0,2) += f1*f3;
        LeftSide.at<double>(0,3) += f1*f4;
        
        RightSide.at<double>(0,0) += (response[i]*f1 - f0*f1);
        
        // For equation 2
        LeftSide.at<double>(1,0) += f2*f1;
        LeftSide.at<double>(1,1) += f2*f2;
        LeftSide.at<double>(1,2) += f2*f3;
        LeftSide.at<double>(1,3) += f2*f4;
        
        RightSide.at<double>(1,0) += (response[i]*f2 - f0*f2);
        
        // For equation 3
        LeftSide.at<double>(2,0) += f3*f1;
        LeftSide.at<double>(2,1) += f3*f2;
        LeftSide.at<double>(2,2) += f3*f3;
        LeftSide.at<double>(2,3) += f3*f4;
        
        RightSide.at<double>(2,0) += (response[i]*f3 - f0*f3);
        
        // For equation 4
        LeftSide.at<double>(3,0) += f4*f1;
        LeftSide.at<double>(3,1) += f4*f2;
        LeftSide.at<double>(3,2) += f4*f3;
        LeftSide.at<double>(3,3) += f4*f4;
        
        RightSide.at<double>(3,0) += (response[i]*f4 - f0*f4);
    }
    
    cv::Mat Solution;
    cv::solve(LeftSide, RightSide, Solution,cv::DECOMP_SVD);
    
    std::vector<double> solution_response;
    solution_response.push_back(Solution.at<double>(0,0));
    solution_response.push_back(Solution.at<double>(1,0));
    solution_response.push_back(Solution.at<double>(2,0));
    solution_response.push_back(Solution.at<double>(3,0));
    
    return solution_response;
}


================================================
FILE: src/JacobianGenerator.h
================================================
//
//  JacobianGenerator.h
//  OnlinePhotometricCalibration
//
//  Created by Paul on 16.11.17.
//  Copyright (c) 2017-2018 Paul Bergmann and co-authors. All rights reserved.
//
//  See LICENSE.txt
//

#ifndef OnlinePhotometricCalibration_JacobianGenerator_h_
#define OnlinePhotometricCalibration_JacobianGenerator_h_

#include "StandardIncludes.h"

class JacobianGenerator
{
    
public:
    
    /**
     * Constructor
     */
    JacobianGenerator();
    
    /**
     * Initialize Grossberg response parameters
     */
    void setResponseParameters(std::vector<double> response_params)
    {
        m_response_params = response_params;
    };
    
    /**
     * Initialize vignette parameters
     */
    void setVignettingParameters(std::vector<double> vignetting_params)
    {
        m_vignetting_params = vignetting_params;
    };
    
    /**
     * Get the raw Jacobian row to construct the Hessian directly
     */
    void getRawJacobianRow(double I,
                           double r,
                           double e,
                           std::vector<double>& j_res,
                           std::vector<double>& j_vig,
                           double& j_e,
                           double& j_I);
    
    /**
     * Apply the Grossberg response to a value x
     */
    double applyGrossbergResponse(double x);
    
    /**
     * Get the Jacobian information, passing the irradiance, radius of the point and exposure time
     * of the image
     */
     // Todo: what does eca mean? Term for evf from old version.
    void getJacobianRow_eca(double I, double r, double e,cv::Mat jacobian,int image_index,int residual_index);
    
    /**
     * Get the Jacobian entry for the irradiance
     */
    void getJacobianRadiance(double I,double r,double e, double& j_I);
    
    /**
     * Get 4 least squares parameters for an input response vector
     */
    std::vector<double> fitGrossbergModelToResponseVector(double* response);
    
private:
    
    /**
     * Response and vignette parameters
     */
    std::vector<double> m_response_params;
    std::vector<double> m_vignetting_params;

    //Evaluate one of the Grossberg base functions or their derivatives (f0,h0,h1,h2,h3,..) at location x
    //Base functions are approximated by polynomials (of max. degree 10)
    double evaluateGrossbergBaseFunction(int base_function_index,bool is_derivative,double x);
    
    /**
     * Here follow the PCA components of the first 4 basis functions of the Grossberg model as discrete 1024 component vectors
     * The derivatives have 1023 components, obtained by symmetric differences
     */
    double m_f_0[1024] = {0,0.0088337,0.014976,0.020237,0.024986,0.029375,0.033483,0.037402,0.041166,0.044812,0.048351,0.05179,0.055148,0.058435,0.061671,0.064858,0.067999,0.071094,0.074141,0.077147,0.080112,0.083033,0.085917,0.08876,0.091569,0.094344,0.097087,0.099801,0.10249,0.10515,0.10778,0.1104,0.11299,0.11557,0.11813,0.12068,0.1232,0.12572,0.12823,0.13072,0.13319,0.13566,0.13811,0.14055,0.14298,0.14539,0.14778,0.15016,0.15253,0.15489,0.15723,0.15957,0.1619,0.16423,0.16654,0.16885,0.17114,0.17343,0.1757,0.17797,0.18023,0.18247,0.1847,0.18693,0.18914,0.19135,0.19355,0.19575,0.19793,0.20011,0.20228,0.20445,0.2066,0.20875,0.2109,0.21303,0.21516,0.21729,0.21941,0.22152,0.22363,0.22574,0.22784,0.22994,0.23204,0.23413,0.23621,0.2383,0.24038,0.24246,0.24453,0.2466,0.24867,0.25073,0.25279,0.25484,0.25689,0.25893,0.26097,0.263,0.26502,0.26705,0.26906,0.27107,0.27308,0.27508,0.27708,0.27908,0.28107,0.28305,0.28503,0.28701,0.28898,0.29094,0.2929,0.29485,0.2968,0.29874,0.30068,0.30261,0.30453,0.30645,0.30836,0.31026,0.31216,0.31406,0.31595,0.31783,0.31971,0.32159,0.32345,0.32532,0.32717,0.32903,0.33087,0.33271,0.33455,0.33638,0.33821,0.34003,0.34184,0.34365,0.34546,0.34726,0.34905,0.35084,0.35262,0.35439,0.35616,0.35792,0.35968,0.36143,0.36318,0.36492,0.36665,0.36838,0.3701,0.37182,0.37354,0.37525,0.37695,0.37865,0.38035,0.38204,0.38372,0.3854,0.38707,0.38874,0.39041,0.39207,0.39372,0.39537,0.39702,0.39866,0.4003,0.40193,0.40356,0.40519,0.40681,0.40842,0.41003,0.41164,0.41324,0.41484,0.41644,0.41803,0.41961,0.4212,0.42278,0.42435,0.42593,0.42749,0.42906,0.43062,0.43217,0.43372,0.43527,0.43681,0.43835,0.43989,0.44142,0.44294,0.44446,0.44598,0.44749,0.449,0.4505,0.452,0.4535,0.45499,0.45647,0.45795,0.45943,0.4609,0.46236,0.46382,0.46528,0.46673,0.46817,0.46962,0.47105,0.47249,0.47392,0.47535,0.47677,0.47819,0.4796,0.48101,0.48242,0.48382,0.48521,0.48661,0.488,0.48938,0.49076,0.49214,0.49351,0.49487,0.49624,0.49759,0.49895,0.50029,0.50164,0.50298,0.50431,0.50564,0.50697,0.50829,0.50961,0.51092,0.51223,0.51354,0.51484,0.51614,0.51743,0.51872,0.52001,0.5213,0.52258,0.52385,0.52513,0.5264,0.52766,0.52893,0.53019,0.53145,0.5327,0.53395,0.5352,0.53644,0.53768,0.53891,0.54014,0.54137,0.54259,0.54382,0.54503,0.54625,0.54746,0.54867,0.54987,0.55107,0.55226,0.55346,0.55465,0.55583,0.55702,0.5582,0.55937,0.56055,0.56172,0.56289,0.56405,0.56521,0.56637,0.56753,0.56868,0.56983,0.57098,0.57213,0.57327,0.57441,0.57554,0.57667,0.5778,0.57892,0.58004,0.58116,0.58228,0.58339,0.58449,0.5856,0.58669,0.58779,0.58888,0.58997,0.59106,0.59214,0.59322,0.5943,0.59537,0.59644,0.5975,0.59856,0.59962,0.60068,0.60173,0.60278,0.60383,0.60487,0.60591,0.60695,0.60799,0.60902,0.61005,0.61108,0.6121,0.61312,0.61414,0.61515,0.61617,0.61717,0.61818,0.61918,0.62018,0.62117,0.62217,0.62316,0.62414,0.62513,0.62611,0.62709,0.62807,0.62904,0.63001,0.63098,0.63195,0.63291,0.63388,0.63484,0.6358,0.63675,0.63771,0.63866,0.63961,0.64056,0.6415,0.64245,0.64339,0.64433,0.64526,0.6462,0.64713,0.64806,0.64898,0.64991,0.65083,0.65175,0.65266,0.65358,0.65449,0.6554,0.6563,0.65721,0.65811,0.65901,0.65991,0.6608,0.6617,0.66259,0.66347,0.66436,0.66524,0.66613,0.66701,0.66788,0.66876,0.66963,0.67051,0.67137,0.67224,0.67311,0.67397,0.67483,0.67568,0.67654,0.67739,0.67824,0.67909,0.67994,0.68078,0.68162,0.68246,0.6833,0.68414,0.68497,0.6858,0.68663,0.68746,0.68828,0.68911,0.68993,0.69075,0.69157,0.69239,0.69321,0.69402,0.69483,0.69564,0.69645,0.69726,0.69807,0.69888,0.69968,0.70048,0.70128,0.70208,0.70288,0.70367,0.70447,0.70526,0.70604,0.70683,0.70762,0.7084,0.70918,0.70996,0.71074,0.71152,0.71229,0.71306,0.71384,0.71461,0.71537,0.71614,0.71691,0.71767,0.71843,0.71919,0.71996,0.72071,0.72147,0.72223,0.72298,0.72374,0.72449,0.72524,0.72599,0.72674,0.72748,0.72823,0.72897,0.72971,0.73046,0.7312,0.73193,0.73267,0.73341,0.73414,0.73487,0.7356,0.73633,0.73706,0.73778,0.73851,0.73923,0.73995,0.74067,0.74138,0.7421,0.74281,0.74352,0.74423,0.74494,0.74565,0.74635,0.74705,0.74775,0.74846,0.74915,0.74985,0.75055,0.75124,0.75194,0.75263,0.75332,0.75401,0.7547,0.75539,0.75608,0.75676,0.75745,0.75813,0.75881,0.75949,0.76016,0.76084,0.76151,0.76218,0.76286,0.76352,0.76419,0.76486,0.76552,0.76619,0.76685,0.76751,0.76817,0.76883,0.76949,0.77014,0.7708,0.77146,0.77211,0.77276,0.77342,0.77407,0.77472,0.77537,0.77602,0.77667,0.77732,0.77796,0.77861,0.77925,0.77989,0.78053,0.78117,0.78181,0.78244,0.78308,0.78371,0.78435,0.78498,0.78561,0.78624,0.78687,0.7875,0.78813,0.78876,0.78939,0.79001,0.79064,0.79126,0.79189,0.79251,0.79313,0.79375,0.79438,0.795,0.79562,0.79623,0.79685,0.79747,0.79808,0.7987,0.79931,0.79992,0.80053,0.80114,0.80175,0.80236,0.80296,0.80357,0.80417,0.80477,0.80537,0.80598,0.80657,0.80717,0.80777,0.80837,0.80896,0.80956,0.81016,0.81075,0.81134,0.81194,0.81253,0.81312,0.81371,0.8143,0.81489,0.81547,0.81606,0.81665,0.81724,0.81782,0.81841,0.81899,0.81957,0.82015,0.82073,0.82131,0.82188,0.82246,0.82303,0.82361,0.82418,0.82475,0.82532,0.82589,0.82646,0.82703,0.82759,0.82816,0.82872,0.82928,0.82985,0.83041,0.83097,0.83153,0.83209,0.83265,0.8332,0.83376,0.83432,0.83488,0.83543,0.83599,0.83654,0.8371,0.83765,0.8382,0.83875,0.8393,0.83985,0.8404,0.84094,0.84149,0.84203,0.84257,0.84311,0.84365,0.84419,0.84473,0.84526,0.8458,0.84633,0.84687,0.8474,0.84793,0.84846,0.84899,0.84952,0.85005,0.85058,0.8511,0.85163,0.85215,0.85268,0.8532,0.85373,0.85425,0.85477,0.85529,0.85581,0.85633,0.85685,0.85737,0.85789,0.85841,0.85892,0.85944,0.85995,0.86047,0.86098,0.86149,0.862,0.86251,0.86301,0.86352,0.86402,0.86453,0.86503,0.86553,0.86604,0.86654,0.86704,0.86753,0.86803,0.86853,0.86903,0.86952,0.87001,0.87051,0.871,0.87149,0.87198,0.87248,0.87297,0.87346,0.87395,0.87443,0.87492,0.87541,0.8759,0.87639,0.87687,0.87736,0.87784,0.87832,0.8788,0.87928,0.87976,0.88024,0.88072,0.8812,0.88167,0.88215,0.88263,0.8831,0.88358,0.88405,0.88452,0.885,0.88547,0.88594,0.88641,0.88689,0.88736,0.88783,0.8883,0.88877,0.88924,0.88971,0.89017,0.89064,0.89111,0.89157,0.89204,0.8925,0.89296,0.89342,0.89388,0.89434,0.89481,0.89526,0.89572,0.89618,0.89664,0.8971,0.89755,0.89801,0.89847,0.89892,0.89938,0.89983,0.90029,0.90074,0.9012,0.90165,0.90211,0.90256,0.90301,0.90346,0.90392,0.90437,0.90482,0.90527,0.90572,0.90617,0.90662,0.90706,0.90751,0.90795,0.9084,0.90884,0.90929,0.90973,0.91017,0.91061,0.91105,0.91149,0.91193,0.91237,0.91281,0.91325,0.91369,0.91413,0.91456,0.915,0.91544,0.91587,0.91631,0.91675,0.91718,0.91762,0.91806,0.91849,0.91893,0.91936,0.9198,0.92023,0.92067,0.9211,0.92153,0.92196,0.92239,0.92282,0.92325,0.92368,0.9241,0.92453,0.92495,0.92538,0.9258,0.92623,0.92665,0.92707,0.9275,0.92792,0.92834,0.92876,0.92918,0.9296,0.93002,0.93044,0.93086,0.93129,0.93171,0.93212,0.93254,0.93296,0.93338,0.9338,0.93422,0.93463,0.93505,0.93546,0.93588,0.93629,0.9367,0.93711,0.93753,0.93794,0.93835,0.93876,0.93917,0.93957,0.93998,0.94039,0.94079,0.9412,0.94161,0.94202,0.94242,0.94283,0.94324,0.94364,0.94405,0.94445,0.94485,0.94526,0.94566,0.94607,0.94647,0.94687,0.94728,0.94768,0.94808,0.94848,0.94888,0.94928,0.94967,0.95007,0.95047,0.95086,0.95125,0.95165,0.95204,0.95243,0.95282,0.95322,0.95361,0.954,0.95439,0.95478,0.95516,0.95555,0.95594,0.95633,0.95671,0.9571,0.95749,0.95787,0.95826,0.95865,0.95903,0.95941,0.9598,0.96018,0.96057,0.96095,0.96133,0.96172,0.9621,0.96248,0.96287,0.96325,0.96363,0.96401,0.96439,0.96477,0.96515,0.96553,0.96591,0.96629,0.96667,0.96705,0.96742,0.9678,0.96818,0.96856,0.96893,0.96931,0.96969,0.97006,0.97044,0.97081,0.97118,0.97156,0.97193,0.9723,0.97268,0.97305,0.97342,0.97379,0.97416,0.97452,0.97489,0.97526,0.97562,0.97599,0.97636,0.97672,0.97709,0.97745,0.97781,0.97818,0.97854,0.9789,0.97926,0.97962,0.97998,0.98034,0.9807,0.98105,0.98141,0.98177,0.98213,0.98248,0.98284,0.9832,0.98355,0.98391,0.98426,0.98462,0.98497,0.98533,0.98568,0.98603,0.98638,0.98673,0.98707,0.98742,0.98777,0.98811,0.98846,0.9888,0.98915,0.98949,0.98983,0.99017,0.99051,0.99086,0.9912,0.99153,0.99187,0.9922,0.99254,0.99287,0.99321,0.99354,0.99387,0.99421,0.99454,0.99487,0.9952,0.99553,0.99586,0.99618,0.99651,0.99683,0.99715,0.99747,0.99779,0.9981,0.99842,0.99874,0.99905,0.99937,0.99968,1
    };
    
    double m_h_1[1024] = {0,-0.0014523,-0.0021332,-0.0026743,-0.0031499,-0.0035824,-0.0039809,-0.0043598,-0.0047252,-0.0050806,-0.0054271,-0.0057658,-0.0060988,-0.0064263,-0.0067504,-0.0070713,-0.0073899,-0.0077059,-0.0080188,-0.0083293,-0.0086366,-0.0089397,-0.0092394,-0.0095354,-0.0098288,-0.010119,-0.010407,-0.010692,-0.010976,-0.011259,-0.011539,-0.011819,-0.012097,-0.012375,-0.012651,-0.012926,-0.0132,-0.013474,-0.013747,-0.014019,-0.01429,-0.014561,-0.014831,-0.015099,-0.015367,-0.015633,-0.015897,-0.016161,-0.016424,-0.016685,-0.016947,-0.017208,-0.017468,-0.017728,-0.017987,-0.018244,-0.018501,-0.018757,-0.019011,-0.019264,-0.019516,-0.019766,-0.020016,-0.020264,-0.020512,-0.020759,-0.021005,-0.02125,-0.021494,-0.021738,-0.02198,-0.022221,-0.022462,-0.022701,-0.02294,-0.023177,-0.023414,-0.02365,-0.023884,-0.024118,-0.02435,-0.024582,-0.024813,-0.025043,-0.025271,-0.025499,-0.025726,-0.025951,-0.026175,-0.026398,-0.02662,-0.026839,-0.027058,-0.027275,-0.027491,-0.027705,-0.027918,-0.028129,-0.028339,-0.028548,-0.028755,-0.028961,-0.029167,-0.02937,-0.029573,-0.029775,-0.029975,-0.030174,-0.030371,-0.030567,-0.030762,-0.030955,-0.031147,-0.031337,-0.031526,-0.031713,-0.031899,-0.032083,-0.032265,-0.032445,-0.032624,-0.032801,-0.032976,-0.033149,-0.033321,-0.03349,-0.033658,-0.033824,-0.033989,-0.034151,-0.034313,-0.034472,-0.034631,-0.034787,-0.034942,-0.035096,-0.035248,-0.035399,-0.035548,-0.035696,-0.035843,-0.035988,-0.036132,-0.036275,-0.036415,-0.036555,-0.036692,-0.036829,-0.036963,-0.037096,-0.037228,-0.037358,-0.037486,-0.037614,-0.037739,-0.037863,-0.037986,-0.038107,-0.038227,-0.038346,-0.038463,-0.03858,-0.038695,-0.038809,-0.038922,-0.039034,-0.039146,-0.039256,-0.039365,-0.039472,-0.039579,-0.039685,-0.03979,-0.039893,-0.039995,-0.040097,-0.040197,-0.040296,-0.040393,-0.04049,-0.040585,-0.040678,-0.040771,-0.040862,-0.040951,-0.041039,-0.041126,-0.041211,-0.041295,-0.041377,-0.041458,-0.041538,-0.041616,-0.041693,-0.041768,-0.041842,-0.041915,-0.041987,-0.042057,-0.042127,-0.042195,-0.042263,-0.042329,-0.042395,-0.04246,-0.042524,-0.042588,-0.04265,-0.042711,-0.042772,-0.042831,-0.04289,-0.042948,-0.043004,-0.04306,-0.043115,-0.043169,-0.043222,-0.043274,-0.043326,-0.043376,-0.043426,-0.043475,-0.043522,-0.043568,-0.043614,-0.043658,-0.043702,-0.043745,-0.043787,-0.043828,-0.043869,-0.043909,-0.043948,-0.043986,-0.044023,-0.04406,-0.044096,-0.044131,-0.044165,-0.044199,-0.044232,-0.044265,-0.044296,-0.044327,-0.044358,-0.044387,-0.044416,-0.044444,-0.044471,-0.044497,-0.044523,-0.044547,-0.044571,-0.044594,-0.044617,-0.044638,-0.044659,-0.044679,-0.044698,-0.044717,-0.044734,-0.04475,-0.044765,-0.04478,-0.044793,-0.044806,-0.044819,-0.044831,-0.044842,-0.044853,-0.044864,-0.044875,-0.044885,-0.044894,-0.044903,-0.044912,-0.04492,-0.044928,-0.044935,-0.044942,-0.044948,-0.044954,-0.044959,-0.044964,-0.044969,-0.044973,-0.044976,-0.044978,-0.04498,-0.044982,-0.044983,-0.044983,-0.044983,-0.044982,-0.04498,-0.044978,-0.044975,-0.044971,-0.044967,-0.044962,-0.044957,-0.044951,-0.044945,-0.044938,-0.044931,-0.044924,-0.044916,-0.044908,-0.0449,-0.044891,-0.044882,-0.044873,-0.044863,-0.044852,-0.044842,-0.044831,-0.044819,-0.044807,-0.044795,-0.044781,-0.044768,-0.044754,-0.04474,-0.044725,-0.044709,-0.044694,-0.044678,-0.044661,-0.044643,-0.044625,-0.044606,-0.044587,-0.044567,-0.044547,-0.044527,-0.044507,-0.044486,-0.044465,-0.044443,-0.044422,-0.0444,-0.044378,-0.044356,-0.044333,-0.044311,-0.044288,-0.044265,-0.044242,-0.044218,-0.044194,-0.04417,-0.044145,-0.04412,-0.044094,-0.044068,-0.044042,-0.044015,-0.043987,-0.043959,-0.043931,-0.043901,-0.043872,-0.043842,-0.043811,-0.043781,-0.04375,-0.043719,-0.043687,-0.043656,-0.043624,-0.043592,-0.043559,-0.043527,-0.043494,-0.043461,-0.043428,-0.043394,-0.043361,-0.043327,-0.043293,-0.043259,-0.043224,-0.04319,-0.043155,-0.04312,-0.043085,-0.043049,-0.043013,-0.042977,-0.042941,-0.042904,-0.042866,-0.042829,-0.042791,-0.042753,-0.042715,-0.042676,-0.042637,-0.042598,-0.042558,-0.042519,-0.042479,-0.042439,-0.042398,-0.042358,-0.042317,-0.042277,-0.042236,-0.042195,-0.042154,-0.042113,-0.042072,-0.042031,-0.041989,-0.041947,-0.041905,-0.041863,-0.041821,-0.041778,-0.041735,-0.041692,-0.041648,-0.041604,-0.04156,-0.041516,-0.041472,-0.041427,-0.041382,-0.041336,-0.04129,-0.041244,-0.041197,-0.041151,-0.041104,-0.041057,-0.04101,-0.040963,-0.040917,-0.04087,-0.040823,-0.040777,-0.04073,-0.040683,-0.040636,-0.040588,-0.040541,-0.040494,-0.040446,-0.040399,-0.040352,-0.040305,-0.040257,-0.04021,-0.040162,-0.040114,-0.040066,-0.040018,-0.039969,-0.03992,-0.039871,-0.039821,-0.039771,-0.039721,-0.039671,-0.039621,-0.03957,-0.039519,-0.039468,-0.039417,-0.039366,-0.039315,-0.039264,-0.039212,-0.03916,-0.039108,-0.039056,-0.039004,-0.038951,-0.038899,-0.038847,-0.038794,-0.038742,-0.03869,-0.038638,-0.038585,-0.038533,-0.038481,-0.038429,-0.038377,-0.038324,-0.038272,-0.03822,-0.038167,-0.038115,-0.038062,-0.038009,-0.037956,-0.037903,-0.03785,-0.037796,-0.037743,-0.037689,-0.037635,-0.037581,-0.037526,-0.037472,-0.037417,-0.037362,-0.037307,-0.037252,-0.037198,-0.037142,-0.037088,-0.037033,-0.036978,-0.036923,-0.036869,-0.036814,-0.03676,-0.036705,-0.03665,-0.036595,-0.03654,-0.036485,-0.03643,-0.036375,-0.036319,-0.036264,-0.036208,-0.036152,-0.036096,-0.03604,-0.035984,-0.035927,-0.03587,-0.035812,-0.035755,-0.035697,-0.035639,-0.035581,-0.035523,-0.035465,-0.035407,-0.035349,-0.035291,-0.035234,-0.035176,-0.035119,-0.035062,-0.035004,-0.034947,-0.034889,-0.034832,-0.034774,-0.034716,-0.034658,-0.0346,-0.034542,-0.034484,-0.034426,-0.034367,-0.034308,-0.034249,-0.03419,-0.03413,-0.03407,-0.034011,-0.03395,-0.03389,-0.03383,-0.033769,-0.033709,-0.033648,-0.033588,-0.033527,-0.033466,-0.033406,-0.033345,-0.033285,-0.033224,-0.033164,-0.033104,-0.033044,-0.032984,-0.032924,-0.032864,-0.032804,-0.032743,-0.032683,-0.032622,-0.032561,-0.0325,-0.032439,-0.032378,-0.032316,-0.032254,-0.032193,-0.032131,-0.032069,-0.032007,-0.031944,-0.031881,-0.031818,-0.031755,-0.031692,-0.031628,-0.031564,-0.031501,-0.031437,-0.031373,-0.031309,-0.031246,-0.031182,-0.031119,-0.031056,-0.030993,-0.03093,-0.030867,-0.030804,-0.030741,-0.030678,-0.030616,-0.030553,-0.03049,-0.030427,-0.030364,-0.0303,-0.030237,-0.030173,-0.030109,-0.030045,-0.029981,-0.029917,-0.029852,-0.029788,-0.029723,-0.029657,-0.029591,-0.029526,-0.02946,-0.029393,-0.029327,-0.029261,-0.029195,-0.029128,-0.029062,-0.028995,-0.028929,-0.028863,-0.028797,-0.028731,-0.028665,-0.028599,-0.028534,-0.028468,-0.028402,-0.028337,-0.028271,-0.028205,-0.02814,-0.028074,-0.028008,-0.027942,-0.027876,-0.02781,-0.027745,-0.027678,-0.027612,-0.027545,-0.027479,-0.027411,-0.027344,-0.027276,-0.027208,-0.02714,-0.027072,-0.027004,-0.026935,-0.026867,-0.026798,-0.026729,-0.02666,-0.026592,-0.026523,-0.026454,-0.026386,-0.026317,-0.026249,-0.02618,-0.026112,-0.026044,-0.025976,-0.025908,-0.02584,-0.025772,-0.025704,-0.025636,-0.025568,-0.025499,-0.025431,-0.025362,-0.025294,-0.025226,-0.025157,-0.025089,-0.02502,-0.024951,-0.024881,-0.024812,-0.024742,-0.024672,-0.024601,-0.024531,-0.024461,-0.024391,-0.024321,-0.024251,-0.024181,-0.024111,-0.024041,-0.023971,-0.023901,-0.023831,-0.023761,-0.02369,-0.02362,-0.02355,-0.02348,-0.02341,-0.02334,-0.023269,-0.023198,-0.023128,-0.023057,-0.022986,-0.022915,-0.022844,-0.022772,-0.0227,-0.022629,-0.022557,-0.022484,-0.022412,-0.02234,-0.022268,-0.022196,-0.022123,-0.022051,-0.021978,-0.021906,-0.021834,-0.021762,-0.02169,-0.021618,-0.021546,-0.021473,-0.0214,-0.021328,-0.021255,-0.021182,-0.021109,-0.021035,-0.020962,-0.020888,-0.020814,-0.02074,-0.020666,-0.020592,-0.020518,-0.020443,-0.020368,-0.020292,-0.020216,-0.020141,-0.020065,-0.019989,-0.019913,-0.019837,-0.019762,-0.019686,-0.019611,-0.019535,-0.01946,-0.019385,-0.01931,-0.019235,-0.01916,-0.019085,-0.019009,-0.018934,-0.018859,-0.018784,-0.018709,-0.018633,-0.018558,-0.018482,-0.018407,-0.018331,-0.018254,-0.018178,-0.018101,-0.018024,-0.017947,-0.01787,-0.017793,-0.017715,-0.017637,-0.017558,-0.01748,-0.017401,-0.017323,-0.017244,-0.017166,-0.017087,-0.017008,-0.01693,-0.016852,-0.016774,-0.016697,-0.016619,-0.016542,-0.016464,-0.016387,-0.01631,-0.016232,-0.016154,-0.016077,-0.015999,-0.015921,-0.015844,-0.015766,-0.015689,-0.015611,-0.015533,-0.015455,-0.015376,-0.015298,-0.015219,-0.01514,-0.015061,-0.014982,-0.014902,-0.014823,-0.014744,-0.014665,-0.014586,-0.014507,-0.014428,-0.01435,-0.014271,-0.014193,-0.014115,-0.014036,-0.013958,-0.01388,-0.013801,-0.013723,-0.013644,-0.013566,-0.013488,-0.013409,-0.01333,-0.013251,-0.013171,-0.013092,-0.013012,-0.012933,-0.012853,-0.012772,-0.012692,-0.012611,-0.01253,-0.012449,-0.012368,-0.012286,-0.012205,-0.012124,-0.012042,-0.011961,-0.01188,-0.011798,-0.011717,-0.011636,-0.011556,-0.011475,-0.011395,-0.011315,-0.011235,-0.011155,-0.011076,-0.010996,-0.010916,-0.010836,-0.010756,-0.010676,-0.010597,-0.010517,-0.010437,-0.010358,-0.010278,-0.010198,-0.010118,-0.010038,-0.0099572,-0.0098768,-0.0097964,-0.0097162,-0.009636,-0.0095558,-0.0094755,-0.009395,-0.0093142,-0.0092332,-0.0091522,-0.0090711,-0.0089901,-0.0089092,-0.0088283,-0.0087475,-0.0086667,-0.0085857,-0.0085044,-0.0084229,-0.0083413,-0.0082596,-0.0081778,-0.0080958,-0.0080136,-0.0079313,-0.0078489,-0.0077663,-0.0076835,-0.0076005,-0.0075175,-0.0074344,-0.0073511,-0.0072679,-0.0071848,-0.0071016,-0.0070185,-0.0069354,-0.006852,-0.0067684,-0.006685,-0.0066018,-0.0065188,-0.0064358,-0.006353,-0.0062704,-0.0061877,-0.006105,-0.0060221,-0.005939,-0.005856,-0.0057731,-0.0056902,-0.0056076,-0.0055251,-0.0054426,-0.0053602,-0.0052777,-0.005195,-0.0051119,-0.0050288,-0.0049455,-0.0048622,-0.0047786,-0.0046949,-0.0046111,-0.0045274,-0.0044436,-0.0043596,-0.0042749,-0.00419,-0.0041049,-0.0040198,-0.0039347,-0.0038496,-0.0037645,-0.0036794,-0.0035945,-0.0035096,-0.0034243,-0.0033393,-0.0032545,-0.0031698,-0.0030852,-0.0030005,-0.0029159,-0.0028313,-0.0027468,-0.0026623,-0.0025773,-0.002492,-0.0024067,-0.0023215,-0.0022367,-0.0021519,-0.0020668,-0.0019817,-0.0018966,-0.0018116,-0.0017261,-0.0016399,-0.0015535,-0.0014668,-0.0013798,-0.0012927,-0.0012056,-0.001119,-0.0010326,-0.00094644,-0.00086078,-0.00077461,-0.00068832,-0.00060193,-0.0005156,-0.00042937,-0.00034323,-0.00025723,-0.00017134,-8.5608e-05,-1.7347e-18
    };
    double m_h_2[1024] = {0,-0.0068347,-0.010307,-0.013097,-0.015503,-0.017653,-0.019616,-0.021445,-0.023169,-0.02481,-0.026374,-0.02787,-0.029302,-0.030675,-0.031995,-0.033266,-0.034488,-0.035667,-0.036804,-0.037904,-0.038969,-0.04,-0.040994,-0.041958,-0.042891,-0.043794,-0.04467,-0.045518,-0.04634,-0.047138,-0.047913,-0.048664,-0.049394,-0.050103,-0.050793,-0.051466,-0.052121,-0.052758,-0.05338,-0.053986,-0.054576,-0.05515,-0.055709,-0.056253,-0.056783,-0.057298,-0.057798,-0.058284,-0.058756,-0.059215,-0.05966,-0.060092,-0.060511,-0.060917,-0.06131,-0.061691,-0.062059,-0.062413,-0.062753,-0.063078,-0.06339,-0.063689,-0.063975,-0.064249,-0.06451,-0.064758,-0.064995,-0.06522,-0.065435,-0.065637,-0.065827,-0.066007,-0.066177,-0.066336,-0.066485,-0.066622,-0.06675,-0.066867,-0.066974,-0.067073,-0.067162,-0.067241,-0.06731,-0.067371,-0.067423,-0.067465,-0.067499,-0.067524,-0.067538,-0.067544,-0.06754,-0.067528,-0.067507,-0.067477,-0.067438,-0.06739,-0.067334,-0.06727,-0.067196,-0.067114,-0.067025,-0.066928,-0.066822,-0.066708,-0.066588,-0.066461,-0.066327,-0.066185,-0.066038,-0.065885,-0.065724,-0.065559,-0.065389,-0.065212,-0.065029,-0.064842,-0.064649,-0.064451,-0.064249,-0.064041,-0.06383,-0.063614,-0.063393,-0.063169,-0.062939,-0.062705,-0.062467,-0.062225,-0.06198,-0.061731,-0.061479,-0.061223,-0.060964,-0.060702,-0.060437,-0.060169,-0.0599,-0.059626,-0.059352,-0.059075,-0.058795,-0.058513,-0.058227,-0.057939,-0.057649,-0.057357,-0.057063,-0.056766,-0.056468,-0.056167,-0.055864,-0.055559,-0.055251,-0.054943,-0.054634,-0.054323,-0.054009,-0.053694,-0.053376,-0.053058,-0.052738,-0.052417,-0.052093,-0.051768,-0.051441,-0.051113,-0.050783,-0.050453,-0.050119,-0.049785,-0.04945,-0.049114,-0.048775,-0.048434,-0.048092,-0.047749,-0.047404,-0.047058,-0.046711,-0.046363,-0.046011,-0.04566,-0.045308,-0.044954,-0.044597,-0.044241,-0.043882,-0.043521,-0.043161,-0.042797,-0.042432,-0.042066,-0.041697,-0.041326,-0.040954,-0.040581,-0.040207,-0.039831,-0.039455,-0.039078,-0.038699,-0.038319,-0.037939,-0.037559,-0.037178,-0.036798,-0.036419,-0.036039,-0.035662,-0.035285,-0.034908,-0.034532,-0.034158,-0.033784,-0.033412,-0.03304,-0.032669,-0.032299,-0.031929,-0.031562,-0.031194,-0.030827,-0.030462,-0.030098,-0.029735,-0.029373,-0.029011,-0.028651,-0.028292,-0.027933,-0.027575,-0.027219,-0.026863,-0.026508,-0.026154,-0.0258,-0.025447,-0.025096,-0.024746,-0.024397,-0.024048,-0.023702,-0.023355,-0.02301,-0.022668,-0.022325,-0.021983,-0.021642,-0.021302,-0.020963,-0.020624,-0.020287,-0.019952,-0.019618,-0.019284,-0.018952,-0.018621,-0.018291,-0.017962,-0.017634,-0.017309,-0.016984,-0.016661,-0.016338,-0.016017,-0.015699,-0.015381,-0.015063,-0.014747,-0.014432,-0.014119,-0.013807,-0.013496,-0.013185,-0.012877,-0.012569,-0.012262,-0.011957,-0.011652,-0.011349,-0.011047,-0.010746,-0.010446,-0.010148,-0.0098508,-0.0095548,-0.0092602,-0.0089671,-0.0086748,-0.0083839,-0.0080947,-0.007806,-0.0075181,-0.0072313,-0.0069458,-0.0066611,-0.0063777,-0.0060952,-0.0058141,-0.0055343,-0.0052557,-0.0049783,-0.0047019,-0.0044267,-0.0041522,-0.003879,-0.0036074,-0.0033367,-0.003067,-0.002798,-0.0025299,-0.0022637,-0.0019984,-0.0017338,-0.0014707,-0.0012081,-0.00094708,-0.00068784,-0.00043029,-0.00017447,8.0061e-05,0.00033373,0.00058625,0.00083738,0.0010864,0.0013345,0.0015814,0.0018269,0.0020714,0.0023141,0.0025552,0.0027949,0.0030335,0.0032705,0.0035057,0.00374,0.0039728,0.0042041,0.0044347,0.004664,0.0048907,0.0051161,0.0053408,0.0055642,0.0057866,0.0060076,0.0062269,0.0064447,0.0066615,0.006877,0.0070915,0.0073043,0.0075159,0.0077268,0.0079358,0.008143,0.0083492,0.0085539,0.0087573,0.0089598,0.0091611,0.0093613,0.0095593,0.0097565,0.0099527,0.010148,0.010341,0.010533,0.010725,0.010916,0.011105,0.011294,0.011482,0.011668,0.011853,0.012037,0.012221,0.012403,0.012583,0.012763,0.012943,0.01312,0.013297,0.013472,0.013647,0.013821,0.013993,0.014164,0.014334,0.014504,0.014671,0.014837,0.015001,0.015166,0.015329,0.01549,0.015651,0.015811,0.01597,0.016126,0.016282,0.016437,0.016591,0.016745,0.016897,0.017047,0.017198,0.017346,0.017493,0.017639,0.017785,0.01793,0.018073,0.018216,0.018358,0.0185,0.01864,0.01878,0.018918,0.019054,0.01919,0.019325,0.019458,0.01959,0.019722,0.019852,0.019981,0.02011,0.020237,0.020363,0.020488,0.020613,0.020736,0.020857,0.020977,0.021097,0.021216,0.021334,0.021451,0.021567,0.021682,0.021796,0.021908,0.022019,0.02213,0.022239,0.022348,0.022455,0.022562,0.022668,0.022773,0.022877,0.02298,0.023083,0.023184,0.023285,0.023384,0.023482,0.023579,0.023675,0.023771,0.023865,0.02396,0.024053,0.024145,0.024237,0.024327,0.024417,0.024506,0.024594,0.024681,0.024768,0.024853,0.024937,0.025021,0.025104,0.025187,0.025269,0.02535,0.02543,0.02551,0.025589,0.025667,0.025744,0.02582,0.025895,0.02597,0.026044,0.026117,0.026189,0.02626,0.026331,0.026401,0.02647,0.026538,0.026605,0.026672,0.026738,0.026803,0.026867,0.02693,0.026992,0.027054,0.027116,0.027177,0.027237,0.027296,0.027354,0.027413,0.027471,0.027527,0.027583,0.027638,0.027693,0.027747,0.0278,0.027853,0.027904,0.027955,0.028006,0.028055,0.028104,0.028152,0.028198,0.028243,0.028289,0.028334,0.028378,0.02842,0.028463,0.028504,0.028545,0.028586,0.028626,0.028665,0.028703,0.02874,0.028776,0.028813,0.028848,0.028883,0.028916,0.028949,0.028982,0.029015,0.029047,0.029078,0.029108,0.029138,0.029168,0.029197,0.029226,0.029254,0.02928,0.029306,0.029332,0.029357,0.029382,0.029406,0.029429,0.029451,0.029474,0.029495,0.029516,0.029536,0.029556,0.029575,0.029594,0.029613,0.02963,0.029647,0.029663,0.029679,0.029694,0.029709,0.029724,0.029738,0.029751,0.029763,0.029775,0.029787,0.029799,0.02981,0.029821,0.02983,0.02984,0.029849,0.029857,0.029865,0.029872,0.029878,0.029884,0.029889,0.029895,0.0299,0.029905,0.029909,0.029912,0.029914,0.029916,0.029918,0.029919,0.029919,0.029919,0.029917,0.029916,0.029914,0.029911,0.029909,0.029906,0.029902,0.029898,0.029893,0.029888,0.029883,0.029878,0.029872,0.029866,0.029859,0.029853,0.029846,0.029838,0.02983,0.029822,0.029813,0.029803,0.029792,0.029781,0.02977,0.029759,0.029747,0.029735,0.029721,0.029708,0.029694,0.029679,0.029665,0.029649,0.029632,0.029615,0.029598,0.02958,0.029562,0.029544,0.029524,0.029504,0.029483,0.029461,0.029439,0.029418,0.029396,0.029374,0.029351,0.029328,0.029304,0.02928,0.029257,0.029233,0.029209,0.029183,0.029158,0.029131,0.029105,0.029078,0.02905,0.029022,0.028994,0.028965,0.028936,0.028906,0.028876,0.028845,0.028814,0.028782,0.028749,0.028716,0.028683,0.028649,0.028615,0.028581,0.028546,0.02851,0.028474,0.028438,0.028402,0.028365,0.028327,0.028289,0.028251,0.028212,0.028172,0.028131,0.028091,0.02805,0.028009,0.027968,0.027927,0.027884,0.02784,0.027797,0.027753,0.027709,0.027665,0.02762,0.027574,0.027527,0.02748,0.027433,0.027386,0.027338,0.027289,0.027241,0.027191,0.027141,0.027091,0.027041,0.02699,0.02694,0.026889,0.026839,0.026787,0.026735,0.026682,0.026629,0.026576,0.026523,0.02647,0.026415,0.02636,0.026305,0.02625,0.026195,0.026139,0.026083,0.026027,0.02597,0.025913,0.025855,0.025797,0.025738,0.02568,0.025621,0.025562,0.025503,0.025443,0.025383,0.025323,0.025261,0.025201,0.02514,0.025079,0.025018,0.024956,0.024895,0.024833,0.024772,0.02471,0.024647,0.024584,0.02452,0.024456,0.024392,0.024328,0.024264,0.024199,0.024134,0.024069,0.024003,0.023938,0.023871,0.023804,0.023737,0.023669,0.023602,0.023535,0.023467,0.023399,0.023331,0.023262,0.023193,0.023124,0.023056,0.022987,0.022918,0.022848,0.022779,0.022709,0.022639,0.022568,0.022497,0.022426,0.022354,0.022283,0.022211,0.02214,0.022068,0.021995,0.021922,0.021849,0.021775,0.021701,0.021626,0.021551,0.021476,0.021399,0.021322,0.021246,0.021168,0.021091,0.021014,0.020937,0.020859,0.020781,0.020702,0.020623,0.020543,0.020464,0.020384,0.020305,0.020225,0.020146,0.020066,0.019985,0.019904,0.019823,0.019741,0.01966,0.019578,0.019497,0.019415,0.019332,0.019249,0.019165,0.019082,0.018998,0.018915,0.018831,0.018747,0.018662,0.018577,0.018491,0.018405,0.018318,0.018232,0.018145,0.018058,0.017971,0.017885,0.017798,0.017711,0.017624,0.017536,0.017448,0.017359,0.017271,0.017183,0.017095,0.017007,0.016918,0.016828,0.016737,0.016647,0.016557,0.016467,0.016376,0.016285,0.016194,0.016102,0.016009,0.015916,0.015823,0.01573,0.015636,0.015543,0.015449,0.015355,0.015261,0.015167,0.015072,0.014976,0.014881,0.014784,0.014688,0.014593,0.014497,0.014402,0.014306,0.014209,0.014112,0.014015,0.013918,0.01382,0.013723,0.013625,0.013528,0.01343,0.013332,0.013234,0.013136,0.013037,0.012939,0.01284,0.01274,0.012641,0.012541,0.012442,0.012342,0.012242,0.012142,0.012042,0.011942,0.011841,0.011741,0.01164,0.011539,0.011439,0.011338,0.011237,0.011135,0.011035,0.010934,0.010833,0.010732,0.010631,0.01053,0.010428,0.010327,0.010225,0.010122,0.01002,0.0099181,0.0098158,0.0097133,0.0096106,0.0095075,0.0094048,0.0093019,0.0091988,0.009095,0.008991,0.0088871,0.008783,0.0086783,0.0085738,0.0084696,0.0083655,0.0082614,0.0081571,0.0080524,0.0079474,0.0078423,0.0077377,0.0076328,0.0075276,0.0074223,0.0073169,0.0072114,0.007106,0.0070003,0.0068945,0.0067887,0.0066829,0.0065767,0.0064702,0.0063634,0.0062568,0.0061502,0.0060436,0.0059369,0.0058299,0.0057232,0.0056165,0.0055096,0.005402,0.005294,0.0051864,0.0050787,0.004971,0.0048633,0.0047556,0.0046473,0.004539,0.0044306,0.0043225,0.0042146,0.0041068,0.0039989,0.0038912,0.0037835,0.0036757,0.0035675,0.0034594,0.0033513,0.0032426,0.0031342,0.0030257,0.0029175,0.0028102,0.0027027,0.0025957,0.0024887,0.0023812,0.0022729,0.002164,0.0020547,0.0019452,0.0018357,0.0017267,0.0016181,0.0015099,0.0014027,0.0012957,0.0011884,0.0010802,0.0009714,0.00086302,0.00075512,0.0006472,0.00053931,0.00043141,0.00032353,0.00021566,0.00010782,1.8173e-18
    };
    double m_h_3[1024] = {0,-0.014921,-0.021271,-0.026188,-0.030308,-0.033903,-0.037108,-0.040033,-0.042748,-0.045285,-0.04766,-0.049885,-0.05197,-0.053922,-0.055754,-0.057472,-0.059081,-0.060593,-0.062013,-0.063351,-0.064611,-0.065796,-0.066905,-0.067948,-0.068925,-0.069842,-0.0707,-0.0715,-0.072245,-0.072937,-0.073576,-0.074163,-0.074698,-0.07518,-0.075616,-0.076006,-0.07635,-0.076644,-0.076897,-0.077103,-0.077268,-0.077385,-0.077459,-0.077495,-0.077489,-0.077442,-0.077359,-0.077234,-0.077072,-0.076878,-0.076646,-0.076378,-0.076083,-0.075751,-0.075388,-0.074998,-0.074578,-0.07413,-0.07365,-0.073142,-0.072605,-0.072043,-0.071456,-0.070849,-0.070214,-0.069554,-0.068877,-0.068179,-0.067463,-0.066727,-0.065971,-0.065199,-0.064414,-0.063615,-0.062804,-0.061977,-0.061139,-0.06029,-0.05943,-0.058561,-0.057681,-0.056788,-0.055883,-0.054974,-0.054051,-0.053119,-0.052183,-0.051232,-0.050271,-0.049303,-0.048324,-0.047338,-0.04634,-0.045334,-0.044322,-0.043299,-0.042269,-0.041233,-0.040189,-0.039139,-0.038085,-0.037026,-0.035965,-0.034903,-0.033844,-0.032782,-0.031718,-0.030655,-0.029596,-0.028541,-0.027482,-0.02643,-0.025382,-0.024335,-0.023294,-0.022258,-0.021226,-0.020198,-0.019181,-0.018168,-0.017162,-0.016161,-0.015167,-0.014182,-0.013201,-0.012227,-0.011264,-0.010308,-0.0093601,-0.0084202,-0.0074881,-0.0065665,-0.0056555,-0.0047563,-0.0038666,-0.0029902,-0.0021261,-0.0012678,-0.00042104,0.00041688,0.0012467,0.002067,0.0028773,0.00368,0.0044721,0.0052528,0.0060233,0.0067886,0.0075441,0.0082887,0.0090257,0.0097539,0.010475,0.011187,0.011888,0.012583,0.013267,0.013943,0.014612,0.015273,0.015928,0.016571,0.017206,0.01783,0.018444,0.01905,0.019645,0.020231,0.02081,0.021383,0.021945,0.022502,0.023049,0.023588,0.024118,0.02464,0.025149,0.02565,0.026142,0.026626,0.0271,0.027566,0.028021,0.02847,0.028911,0.029342,0.029766,0.030181,0.030587,0.030985,0.031374,0.031753,0.032125,0.032486,0.032838,0.03318,0.033517,0.033843,0.034162,0.034472,0.034775,0.035071,0.03536,0.035642,0.035915,0.03618,0.036437,0.03669,0.036934,0.037173,0.037409,0.037637,0.037857,0.03807,0.038275,0.038474,0.038664,0.038851,0.039031,0.039207,0.039378,0.039545,0.039708,0.039862,0.040014,0.040159,0.040299,0.040435,0.040565,0.040691,0.040813,0.040927,0.041039,0.041146,0.041247,0.041343,0.041432,0.041516,0.041594,0.041664,0.041731,0.041791,0.041845,0.041892,0.041932,0.04197,0.042002,0.042029,0.042053,0.042071,0.042087,0.042096,0.0421,0.0421,0.042097,0.042089,0.042079,0.042065,0.042047,0.042027,0.041999,0.041966,0.041932,0.041893,0.041846,0.041796,0.041743,0.041688,0.04163,0.041567,0.0415,0.04143,0.041354,0.041273,0.04119,0.041103,0.041013,0.040921,0.040824,0.040722,0.040618,0.040512,0.040403,0.040292,0.040178,0.040062,0.039944,0.039823,0.039699,0.039575,0.039451,0.039326,0.039199,0.03907,0.038939,0.038807,0.038674,0.038537,0.038397,0.038254,0.038111,0.037965,0.037817,0.037666,0.037514,0.037359,0.037203,0.037044,0.036882,0.036719,0.036554,0.036386,0.036214,0.036041,0.035867,0.035692,0.035517,0.035341,0.035162,0.034981,0.034798,0.034612,0.034425,0.034237,0.034046,0.033854,0.033662,0.033469,0.033276,0.033083,0.032887,0.032689,0.032488,0.032287,0.032084,0.031878,0.031669,0.03146,0.03125,0.031035,0.03082,0.030603,0.030386,0.030166,0.029946,0.029724,0.0295,0.029274,0.029047,0.028821,0.028593,0.028363,0.028133,0.027903,0.027671,0.027437,0.027203,0.026966,0.026732,0.026497,0.026262,0.026026,0.025789,0.025551,0.025314,0.025077,0.02484,0.024602,0.024366,0.024128,0.023889,0.02365,0.023411,0.02317,0.022928,0.022684,0.022441,0.022198,0.021954,0.021709,0.021466,0.021222,0.020978,0.020734,0.020492,0.02025,0.020008,0.019766,0.019523,0.019282,0.019042,0.0188,0.018558,0.018317,0.018077,0.017836,0.017595,0.017354,0.017113,0.016873,0.016633,0.016392,0.016152,0.015913,0.015673,0.015432,0.015193,0.014954,0.014713,0.014471,0.01423,0.013989,0.013749,0.013509,0.013267,0.013026,0.012786,0.012546,0.012305,0.012064,0.011824,0.011583,0.011342,0.011101,0.01086,0.010619,0.01038,0.010141,0.0099011,0.0096599,0.0094194,0.0091791,0.0089374,0.0086957,0.008456,0.0082158,0.007976,0.0077362,0.0074965,0.0072567,0.0070153,0.0067754,0.0065347,0.0062935,0.0060531,0.0058136,0.0055748,0.0053366,0.0050992,0.0048638,0.0046283,0.0043931,0.0041588,0.0039253,0.0036928,0.0034598,0.0032279,0.0029962,0.0027652,0.0025358,0.002308,0.002081,0.0018547,0.0016299,0.0014069,0.0011842,0.00096186,0.00074029,0.00051977,0.00029953,8.0471e-05,-0.00013786,-0.00035613,-0.00057425,-0.00079129,-0.0010066,-0.0012213,-0.0014365,-0.0016525,-0.0018679,-0.0020822,-0.0022967,-0.0025112,-0.0027253,-0.0029389,-0.003152,-0.0033641,-0.0035754,-0.0037855,-0.0039961,-0.0042057,-0.0044139,-0.0046208,-0.0048281,-0.0050346,-0.0052394,-0.0054423,-0.0056443,-0.0058464,-0.006048,-0.0062491,-0.006448,-0.006646,-0.0068419,-0.0070365,-0.0072305,-0.0074234,-0.0076144,-0.0078043,-0.0079922,-0.0081782,-0.0083641,-0.0085491,-0.0087333,-0.0089189,-0.0091032,-0.0092876,-0.0094723,-0.0096552,-0.0098374,-0.01002,-0.010201,-0.010383,-0.010563,-0.010742,-0.01092,-0.011097,-0.011273,-0.011449,-0.011624,-0.011797,-0.011969,-0.012141,-0.012312,-0.012483,-0.012652,-0.012819,-0.012987,-0.013154,-0.013321,-0.013487,-0.013652,-0.013816,-0.013981,-0.014146,-0.014311,-0.014475,-0.014638,-0.014802,-0.014965,-0.015128,-0.015289,-0.01545,-0.015609,-0.015768,-0.015926,-0.016085,-0.016243,-0.0164,-0.016557,-0.016712,-0.016867,-0.017021,-0.017175,-0.017327,-0.017478,-0.017628,-0.017777,-0.017927,-0.018077,-0.018226,-0.018374,-0.018522,-0.018669,-0.018816,-0.018963,-0.019111,-0.019259,-0.019405,-0.019551,-0.019697,-0.019844,-0.01999,-0.020136,-0.02028,-0.020425,-0.020571,-0.020716,-0.020859,-0.021001,-0.021142,-0.021283,-0.021422,-0.021559,-0.021696,-0.021832,-0.021969,-0.022105,-0.022239,-0.022372,-0.022504,-0.022636,-0.022766,-0.022895,-0.023022,-0.023149,-0.023276,-0.023402,-0.023528,-0.023653,-0.023777,-0.023898,-0.024019,-0.02414,-0.024259,-0.024379,-0.024499,-0.024618,-0.024736,-0.024852,-0.024969,-0.025085,-0.025201,-0.025315,-0.025429,-0.025541,-0.025652,-0.025762,-0.02587,-0.025976,-0.026081,-0.026185,-0.026288,-0.02639,-0.02649,-0.026588,-0.026685,-0.026781,-0.026876,-0.02697,-0.027061,-0.027151,-0.027241,-0.027329,-0.027417,-0.027504,-0.02759,-0.027676,-0.027762,-0.027848,-0.027931,-0.028014,-0.028098,-0.028181,-0.028264,-0.028345,-0.028425,-0.028504,-0.028582,-0.02866,-0.028737,-0.028813,-0.028888,-0.028961,-0.029033,-0.029104,-0.029174,-0.029242,-0.02931,-0.029376,-0.029441,-0.029505,-0.029565,-0.029623,-0.029681,-0.029738,-0.029794,-0.029847,-0.0299,-0.02995,-0.030001,-0.030051,-0.0301,-0.030148,-0.030196,-0.030242,-0.030286,-0.030328,-0.03037,-0.030411,-0.030452,-0.030493,-0.030535,-0.030576,-0.030615,-0.030654,-0.030691,-0.030727,-0.030762,-0.030797,-0.030832,-0.030865,-0.030897,-0.030927,-0.030956,-0.030984,-0.031011,-0.031037,-0.031061,-0.031083,-0.031104,-0.031125,-0.031144,-0.031162,-0.031179,-0.031197,-0.031214,-0.031231,-0.031247,-0.031262,-0.031277,-0.03129,-0.031303,-0.031315,-0.031326,-0.031336,-0.031345,-0.031352,-0.031359,-0.031366,-0.031372,-0.031379,-0.031384,-0.031388,-0.031392,-0.031394,-0.031396,-0.031397,-0.031398,-0.031399,-0.031399,-0.031398,-0.031396,-0.031392,-0.031388,-0.031383,-0.031379,-0.031375,-0.031371,-0.031367,-0.031362,-0.031356,-0.03135,-0.031344,-0.031337,-0.031331,-0.031325,-0.031318,-0.031309,-0.031299,-0.031289,-0.031277,-0.031265,-0.031254,-0.031244,-0.031234,-0.031222,-0.031209,-0.031196,-0.031181,-0.031166,-0.03115,-0.031134,-0.031117,-0.0311,-0.031083,-0.031065,-0.031046,-0.031027,-0.031008,-0.030988,-0.030969,-0.030949,-0.030928,-0.030906,-0.030884,-0.030861,-0.030838,-0.030816,-0.030793,-0.03077,-0.030745,-0.03072,-0.030693,-0.030665,-0.030637,-0.030606,-0.030575,-0.030544,-0.03051,-0.030476,-0.030442,-0.030406,-0.030368,-0.03033,-0.030291,-0.030251,-0.030211,-0.030169,-0.030126,-0.030082,-0.030038,-0.029992,-0.029947,-0.029901,-0.029856,-0.02981,-0.029763,-0.029717,-0.029669,-0.029621,-0.029571,-0.029521,-0.02947,-0.029419,-0.029367,-0.029314,-0.029261,-0.029207,-0.029152,-0.029095,-0.029038,-0.02898,-0.02892,-0.02886,-0.0288,-0.028739,-0.028676,-0.028612,-0.028546,-0.028479,-0.028412,-0.028344,-0.028277,-0.028208,-0.02814,-0.028071,-0.028002,-0.027932,-0.027862,-0.027791,-0.02772,-0.027648,-0.027576,-0.027502,-0.027428,-0.027353,-0.027277,-0.0272,-0.027121,-0.027041,-0.02696,-0.026878,-0.026796,-0.026713,-0.026629,-0.026544,-0.026457,-0.026368,-0.026277,-0.026185,-0.026091,-0.025996,-0.0259,-0.025803,-0.025706,-0.025608,-0.025508,-0.025408,-0.025308,-0.025206,-0.025102,-0.024998,-0.024893,-0.024788,-0.024683,-0.024577,-0.02447,-0.024362,-0.024253,-0.024142,-0.02403,-0.023918,-0.023806,-0.023693,-0.023578,-0.023463,-0.023346,-0.023229,-0.02311,-0.02299,-0.022868,-0.022746,-0.022622,-0.022498,-0.022373,-0.022247,-0.022121,-0.021993,-0.021864,-0.021733,-0.021602,-0.021468,-0.021334,-0.0212,-0.021065,-0.02093,-0.020794,-0.020656,-0.020517,-0.020377,-0.020236,-0.020094,-0.01995,-0.019806,-0.01966,-0.019514,-0.019367,-0.019218,-0.019068,-0.018918,-0.018766,-0.018613,-0.018459,-0.018304,-0.018147,-0.01799,-0.017831,-0.017671,-0.017511,-0.01735,-0.017189,-0.017026,-0.016861,-0.016696,-0.01653,-0.016364,-0.016197,-0.01603,-0.015862,-0.015693,-0.015521,-0.015348,-0.015174,-0.014999,-0.014823,-0.014647,-0.01447,-0.01429,-0.01411,-0.013928,-0.013745,-0.013561,-0.013375,-0.013188,-0.012999,-0.012808,-0.012617,-0.012425,-0.012232,-0.012037,-0.011841,-0.011644,-0.011445,-0.011244,-0.011042,-0.010839,-0.010637,-0.010434,-0.01023,-0.010025,-0.0098193,-0.0096123,-0.0094013,-0.0091896,-0.008978,-0.0087664,-0.0085547,-0.0083427,-0.0081303,-0.0079163,-0.0076998,-0.0074827,-0.0072628,-0.0070403,-0.0068173,-0.0065936,-0.0063689,-0.0061436,-0.0059164,-0.0056888,-0.0054595,-0.0052283,-0.0049945,-0.0047578,-0.0045202,-0.0042818,-0.0040406,-0.0037982,-0.0035542,-0.0033093,-0.0030641,-0.0028175,-0.0025668,-0.0023127,-0.0020571,-0.0018,-0.0015428,-0.0012856,-0.0010284,-0.00077119,-0.00051403,-0.00025699,-7.4722e-18
    };
    double m_h_4[1024] = {0,-0.036868,-0.047079,-0.054243,-0.059747,-0.064217,-0.068097,-0.071502,-0.074567,-0.077356,-0.07992,-0.082274,-0.084399,-0.086256,-0.087799,-0.089046,-0.090015,-0.090725,-0.091243,-0.091587,-0.091825,-0.092002,-0.09208,-0.092102,-0.092019,-0.091842,-0.091583,-0.091238,-0.090835,-0.090355,-0.089779,-0.089105,-0.088331,-0.087452,-0.086465,-0.08538,-0.084192,-0.082872,-0.081453,-0.079943,-0.078343,-0.076651,-0.0749,-0.073089,-0.071228,-0.069322,-0.067386,-0.065429,-0.063436,-0.061417,-0.059368,-0.057269,-0.05513,-0.052946,-0.050746,-0.04853,-0.046307,-0.044096,-0.041895,-0.039726,-0.037586,-0.035494,-0.033418,-0.031357,-0.029308,-0.027276,-0.025261,-0.023273,-0.021315,-0.01938,-0.017463,-0.015579,-0.013726,-0.011897,-0.010093,-0.0083305,-0.0066009,-0.0048927,-0.003205,-0.0015393,0.00010878,0.0017415,0.0033578,0.0049465,0.0065261,0.0080872,0.0096236,0.011143,0.012631,0.01409,0.015531,0.016938,0.018321,0.019673,0.020993,0.022284,0.023542,0.024761,0.02594,0.027097,0.028224,0.029323,0.030396,0.031443,0.03247,0.033476,0.034457,0.035417,0.03636,0.037281,0.038172,0.039035,0.039882,0.0407,0.04148,0.042228,0.042944,0.043635,0.044293,0.044918,0.045506,0.046065,0.046591,0.047088,0.047554,0.047989,0.048396,0.048784,0.049148,0.049492,0.049817,0.050128,0.050418,0.050687,0.050937,0.051171,0.051391,0.051605,0.051806,0.051988,0.052161,0.052321,0.052455,0.052581,0.052684,0.052772,0.052845,0.0529,0.052943,0.052952,0.052939,0.052908,0.052858,0.052787,0.052691,0.052584,0.052454,0.052308,0.052153,0.051978,0.051795,0.051602,0.051383,0.051158,0.05092,0.050665,0.050403,0.050124,0.04983,0.049531,0.049224,0.048905,0.048559,0.048207,0.04785,0.047485,0.04709,0.046682,0.046265,0.045847,0.045391,0.044931,0.044464,0.043968,0.043458,0.042942,0.042401,0.04184,0.041274,0.040669,0.040058,0.039425,0.03877,0.038099,0.0374,0.036692,0.035955,0.035212,0.034454,0.033685,0.0329,0.032107,0.031306,0.030498,0.029695,0.028888,0.02809,0.02729,0.026503,0.025711,0.024929,0.024149,0.023384,0.022623,0.021868,0.021119,0.020373,0.019636,0.018897,0.018176,0.017455,0.016738,0.016033,0.01533,0.014632,0.013939,0.013248,0.012567,0.011894,0.011219,0.010554,0.0098912,0.009226,0.0085706,0.0079248,0.0072788,0.006636,0.0060032,0.00537,0.0047369,0.004115,0.0034978,0.0028842,0.0022729,0.0016699,0.0010683,0.00046891,-0.00012734,-0.00071357,-0.001299,-0.0018845,-0.0024658,-0.0030351,-0.0036026,-0.0041658,-0.0047265,-0.0052728,-0.0058155,-0.0063525,-0.0068818,-0.007399,-0.0079097,-0.0084129,-0.0089077,-0.0093985,-0.0098752,-0.010346,-0.010812,-0.011273,-0.011725,-0.012166,-0.0126,-0.01303,-0.013453,-0.013867,-0.014274,-0.014673,-0.015067,-0.015455,-0.015832,-0.016201,-0.016566,-0.016926,-0.01728,-0.017627,-0.017966,-0.018299,-0.018627,-0.01895,-0.019269,-0.019582,-0.01989,-0.020195,-0.020494,-0.020789,-0.021077,-0.021362,-0.021644,-0.021923,-0.022197,-0.022466,-0.022731,-0.022994,-0.023253,-0.023511,-0.023764,-0.024012,-0.024259,-0.024506,-0.024752,-0.025003,-0.02525,-0.025492,-0.025734,-0.025973,-0.02621,-0.026445,-0.026679,-0.026911,-0.027142,-0.027369,-0.027595,-0.027821,-0.028043,-0.028262,-0.02848,-0.028693,-0.028902,-0.029107,-0.029305,-0.029495,-0.029681,-0.029867,-0.030047,-0.030222,-0.030394,-0.030562,-0.030725,-0.030885,-0.031041,-0.031194,-0.031342,-0.031482,-0.031616,-0.031746,-0.031872,-0.031993,-0.032107,-0.032218,-0.032325,-0.032427,-0.032522,-0.032613,-0.032698,-0.032777,-0.032848,-0.032918,-0.032985,-0.033048,-0.033105,-0.033158,-0.033205,-0.033239,-0.033272,-0.033304,-0.033336,-0.033362,-0.033388,-0.033414,-0.03343,-0.033442,-0.033449,-0.033455,-0.033459,-0.03346,-0.033461,-0.033457,-0.033448,-0.033438,-0.033427,-0.033414,-0.0334,-0.033384,-0.033367,-0.033349,-0.033331,-0.03331,-0.033287,-0.033262,-0.033239,-0.033214,-0.033181,-0.033147,-0.033113,-0.03308,-0.033047,-0.033011,-0.032974,-0.032937,-0.032893,-0.032849,-0.032804,-0.032761,-0.032716,-0.03267,-0.032623,-0.032578,-0.032534,-0.032484,-0.032432,-0.032377,-0.032321,-0.032266,-0.032207,-0.032146,-0.032082,-0.032018,-0.031951,-0.03188,-0.031803,-0.031723,-0.031641,-0.031556,-0.031467,-0.031374,-0.031278,-0.031184,-0.031084,-0.030979,-0.030872,-0.030763,-0.030651,-0.030534,-0.03041,-0.030286,-0.030162,-0.030037,-0.029908,-0.02978,-0.029654,-0.029526,-0.029393,-0.029255,-0.029113,-0.028973,-0.028832,-0.028689,-0.028545,-0.028399,-0.028254,-0.028107,-0.027961,-0.027812,-0.027657,-0.027502,-0.027344,-0.027183,-0.027019,-0.026857,-0.026697,-0.026533,-0.026371,-0.026207,-0.026039,-0.025869,-0.025697,-0.025525,-0.025349,-0.025172,-0.024993,-0.024818,-0.024644,-0.024466,-0.024287,-0.024102,-0.023918,-0.023733,-0.023549,-0.023364,-0.023177,-0.02299,-0.022805,-0.022621,-0.022436,-0.022249,-0.022061,-0.021874,-0.021686,-0.021496,-0.021304,-0.021114,-0.020925,-0.020737,-0.020547,-0.020356,-0.020166,-0.019977,-0.019785,-0.019592,-0.019397,-0.0192,-0.019006,-0.018811,-0.018617,-0.018422,-0.018226,-0.018031,-0.017837,-0.017646,-0.017458,-0.017267,-0.017073,-0.016879,-0.016687,-0.016495,-0.016304,-0.016113,-0.015922,-0.01573,-0.015538,-0.015346,-0.015157,-0.014967,-0.014773,-0.014578,-0.014384,-0.014188,-0.013993,-0.013795,-0.013597,-0.0134,-0.013204,-0.013005,-0.012806,-0.012603,-0.0124,-0.012196,-0.011989,-0.011777,-0.011567,-0.011356,-0.011143,-0.010929,-0.010715,-0.0105,-0.010285,-0.010067,-0.009846,-0.0096244,-0.009401,-0.0091754,-0.0089505,-0.0087226,-0.0084913,-0.008259,-0.0080253,-0.0077892,-0.0075518,-0.0073111,-0.007066,-0.0068186,-0.0065705,-0.0063226,-0.0060728,-0.0058209,-0.005566,-0.005309,-0.0050518,-0.0047917,-0.0045281,-0.0042628,-0.0039963,-0.0037282,-0.0034616,-0.0031953,-0.0029282,-0.0026611,-0.0023933,-0.0021255,-0.0018581,-0.001591,-0.0013247,-0.0010584,-0.00079132,-0.00052219,-0.00025102,2.1408e-05,0.00029281,0.00056306,0.00083526,0.0011089,0.0013835,0.001658,0.0019327,0.0022076,0.0024824,0.0027587,0.0030373,0.0033116,0.0035855,0.0038579,0.0041311,0.0044047,0.0046824,0.0049621,0.0052415,0.0055207,0.0057989,0.0060765,0.0063552,0.0066302,0.0068963,0.0071608,0.007423,0.0076836,0.0079428,0.0082002,0.0084565,0.0087107,0.0089649,0.0092187,0.0094694,0.0097184,0.0099671,0.010217,0.010461,0.010698,0.010933,0.011166,0.011399,0.011632,0.011867,0.0121,0.012332,0.012561,0.012789,0.013014,0.01324,0.013468,0.013694,0.013917,0.014136,0.014353,0.014571,0.014789,0.015006,0.015218,0.015428,0.015635,0.015838,0.016034,0.016227,0.016421,0.016614,0.016806,0.016997,0.017188,0.017377,0.017563,0.01775,0.017935,0.018116,0.018297,0.018476,0.018654,0.018833,0.019013,0.019194,0.019374,0.019553,0.019733,0.01991,0.020076,0.020239,0.020402,0.020565,0.020725,0.020884,0.021044,0.021197,0.02135,0.021503,0.021656,0.021808,0.021959,0.022108,0.022247,0.022378,0.022508,0.02264,0.022772,0.022904,0.023033,0.023159,0.023283,0.023405,0.023527,0.023648,0.023766,0.023882,0.023997,0.024108,0.024217,0.024322,0.024422,0.024519,0.024616,0.024714,0.024809,0.024901,0.024991,0.025081,0.025175,0.025271,0.025366,0.02546,0.025553,0.025644,0.025735,0.025825,0.025916,0.026007,0.02609,0.02617,0.026247,0.026322,0.026396,0.026466,0.026536,0.026607,0.026678,0.026749,0.026818,0.026886,0.026953,0.02702,0.027087,0.027152,0.027219,0.027287,0.027354,0.02742,0.027484,0.027546,0.027608,0.02767,0.027731,0.027787,0.027841,0.027894,0.027947,0.027999,0.028051,0.028101,0.028151,0.028201,0.028249,0.028295,0.028337,0.028377,0.028418,0.02846,0.028503,0.028547,0.028588,0.028628,0.028667,0.028708,0.02875,0.028793,0.028837,0.028878,0.02892,0.028962,0.029005,0.029046,0.029088,0.029127,0.029161,0.029195,0.029227,0.029258,0.029287,0.029314,0.02934,0.029365,0.029389,0.029415,0.02944,0.029461,0.02948,0.029496,0.02951,0.029522,0.029534,0.029544,0.029554,0.029565,0.029574,0.02958,0.029586,0.02959,0.029593,0.029596,0.0296,0.029605,0.02961,0.029615,0.02962,0.029625,0.029629,0.029631,0.029632,0.029634,0.029633,0.029631,0.029626,0.029617,0.029605,0.02959,0.029573,0.029552,0.029531,0.029508,0.029485,0.02946,0.029435,0.029408,0.02938,0.029352,0.029321,0.02929,0.02926,0.029231,0.0292,0.02917,0.029139,0.029107,0.029075,0.029041,0.029009,0.028978,0.028947,0.028915,0.028881,0.028847,0.028812,0.028775,0.028737,0.028698,0.028659,0.028617,0.028574,0.02853,0.028482,0.028432,0.028381,0.028329,0.028274,0.02822,0.028165,0.02811,0.028054,0.028001,0.027947,0.027893,0.027839,0.027782,0.027726,0.027671,0.027615,0.027558,0.027502,0.027444,0.027386,0.027328,0.027268,0.027205,0.027144,0.027083,0.02702,0.026954,0.026886,0.026815,0.026742,0.026666,0.026585,0.026502,0.026419,0.026334,0.026248,0.026158,0.026066,0.025972,0.025876,0.025778,0.025677,0.025576,0.025475,0.025374,0.025274,0.025171,0.025065,0.024956,0.024846,0.024736,0.024625,0.024512,0.0244,0.024286,0.024173,0.024058,0.023942,0.023825,0.023707,0.023588,0.023468,0.023347,0.023224,0.023099,0.022972,0.022844,0.022712,0.022581,0.022449,0.022315,0.02218,0.022044,0.021906,0.021767,0.021626,0.021485,0.021338,0.021191,0.021042,0.020893,0.020742,0.020588,0.020434,0.02028,0.020124,0.019968,0.019807,0.019644,0.01948,0.019314,0.019147,0.018978,0.018807,0.018634,0.018459,0.018282,0.0181,0.017915,0.017727,0.017537,0.017345,0.017148,0.016947,0.016743,0.016537,0.016329,0.016118,0.015902,0.015685,0.015468,0.015248,0.015028,0.014807,0.014584,0.014359,0.014133,0.013907,0.013675,0.013444,0.013212,0.01298,0.012747,0.012514,0.01228,0.012047,0.011812,0.011576,0.011332,0.011085,0.010838,0.01059,0.01034,0.010089,0.0098379,0.0095838,0.009327,0.0090686,0.0088051,0.0085413,0.008277,0.0080112,0.0077418,0.0074711,0.0071992,0.0069267,0.0066521,0.0063729,0.0060903,0.0058045,0.0055188,0.0052333,0.0049468,0.0046598,0.0043737,0.0040836,0.0037914,0.0034959,0.0031876,0.002873,0.0025578,0.0022418,0.0019248,0.0016068,0.0012878,0.00096758,0.00064622,0.00032366,7.4351e-18
    };
    
    double m_f_0_der[1022] = {7.6602,5.8328,5.1201,4.6742,4.3465,4.1059,3.9298,3.7902,3.675,3.569,3.4764,3.3991,3.3368,3.2854,3.2364,3.1894,3.1419,3.0962,3.0541,3.0108,2.9692,2.9293,2.8911,2.8561,2.8225,2.7915,2.7626,2.7352,2.7092,2.6852,2.6637,2.6449,2.6282,2.6117,2.5951,2.5816,2.5691,2.5551,2.5412,2.5283,2.5155,2.5008,2.4873,2.4742,2.4584,2.4431,2.4295,2.4162,2.4055,2.3973,2.3886,2.3809,2.3722,2.3621,2.354,2.3434,2.3324,2.324,2.3133,2.3002,2.2896,2.2805,2.2712,2.2637,2.2563,2.2477,2.2394,2.2325,2.2259,2.2182,2.21,2.2027,2.1953,2.1887,2.1832,2.177,2.171,2.1653,2.1608,2.1569,2.1531,2.1481,2.1444,2.1423,2.1379,2.1343,2.1315,2.1276,2.1239,2.1193,2.1153,2.1116,2.1064,2.1019,2.0973,2.0912,2.0858,2.0812,2.0758,2.0703,2.0652,2.0607,2.0565,2.0514,2.0465,2.0421,2.0376,2.0333,2.0286,2.0226,2.0167,2.0123,2.0076,2.001,1.9947,1.9898,1.9836,1.9773,1.9705,1.964,1.9582,1.9521,1.9467,1.941,1.9352,1.93,1.9251,1.9198,1.9142,1.9089,1.9033,1.8972,1.8917,1.8866,1.881,1.8762,1.8706,1.8643,1.8595,1.8541,1.8487,1.8433,1.8373,1.831,1.8248,1.8194,1.8132,1.8064,1.8007,1.7951,1.7889,1.7825,1.7759,1.7703,1.7661,1.7616,1.7569,1.7516,1.7461,1.7408,1.7361,1.7316,1.7259,1.7201,1.7144,1.7093,1.705,1.7008,1.6963,1.691,1.6868,1.6827,1.6777,1.673,1.6684,1.6641,1.6591,1.6537,1.6499,1.6459,1.6413,1.6378,1.6345,1.6301,1.626,1.6224,1.6182,1.6144,1.61,1.6058,1.6024,1.598,1.5938,1.5889,1.584,1.5801,1.5756,1.5715,1.5677,1.5632,1.5589,1.5548,1.5498,1.5448,1.5402,1.5353,1.5301,1.5257,1.5211,1.5165,1.5115,1.5061,1.5013,1.4965,1.4918,1.4867,1.4821,1.4776,1.4732,1.4696,1.4659,1.4612,1.4565,1.4526,1.4485,1.4442,1.4402,1.4361,1.4316,1.4271,1.4232,1.4188,1.414,1.4096,1.405,1.4001,1.3959,1.3911,1.3859,1.3813,1.3765,1.3717,1.367,1.3631,1.3594,1.3544,1.3498,1.3461,1.3424,1.3387,1.3341,1.3297,1.3264,1.3229,1.3187,1.3154,1.3124,1.3086,1.3046,1.3011,1.298,1.2947,1.2914,1.2875,1.2835,1.2802,1.2773,1.2739,1.2696,1.2651,1.2613,1.2574,1.2536,1.2503,1.2473,1.2443,1.2404,1.2364,1.2326,1.2289,1.2258,1.2227,1.2195,1.2156,1.2121,1.2082,1.2043,1.2017,1.199,1.1964,1.1941,1.1912,1.1881,1.1848,1.1813,1.1779,1.1753,1.1727,1.1695,1.1662,1.1626,1.1589,1.1551,1.1513,1.148,1.1447,1.1418,1.1384,1.1344,1.1303,1.1259,1.1221,1.1189,1.1158,1.1132,1.1097,1.1055,1.102,1.0983,1.0946,1.0911,1.0878,1.0847,1.0813,1.0782,1.0756,1.0727,1.0703,1.0674,1.064,1.061,1.0581,1.0551,1.0524,1.0494,1.0459,1.0429,1.0395,1.0357,1.032,1.0285,1.0259,1.0232,1.0201,1.0176,1.0148,1.0114,1.0084,1.0058,1.0033,1.0007,0.99799,0.99538,0.99323,0.99098,0.98873,0.98633,0.98377,0.98198,0.98039,0.97783,0.97517,0.97292,0.97042,0.96822,0.96627,0.96382,0.96126,0.95901,0.95681,0.95487,0.95246,0.94863,0.9453,0.9431,0.9405,0.93758,0.93543,0.93374,0.93154,0.92934,0.92689,0.92413,0.92167,0.91917,0.91691,0.91482,0.91246,0.90986,0.90735,0.90541,0.90341,0.90121,0.89911,0.89692,0.89466,0.89247,0.89001,0.88755,0.88561,0.88372,0.88116,0.87819,0.87559,0.87328,0.87093,0.86868,0.86612,0.86367,0.86208,0.8605,0.85835,0.8563,0.85426,0.8519,0.84975,0.84791,0.84597,0.84408,0.84229,0.8406,0.83891,0.83717,0.83589,0.83451,0.83252,0.83068,0.82935,0.82791,0.82679,0.82531,0.82316,0.82121,0.81978,0.8184,0.8161,0.81375,0.81216,0.81011,0.80745,0.80536,0.80382,0.80244,0.80075,0.79871,0.79661,0.79477,0.79334,0.79211,0.79068,0.78894,0.7872,0.78587,0.78444,0.78193,0.77994,0.77922,0.77835,0.77687,0.77538,0.77426,0.77293,0.77124,0.76991,0.76899,0.76751,0.76582,0.76444,0.76331,0.76208,0.7604,0.75891,0.75753,0.75574,0.75426,0.75313,0.75185,0.75022,0.74858,0.74684,0.74469,0.74229,0.73999,0.7385,0.73728,0.73559,0.73344,0.73134,0.72981,0.72848,0.72694,0.72551,0.72403,0.72183,0.71989,0.71876,0.71774,0.71605,0.71405,0.71257,0.7116,0.71047,0.70904,0.70792,0.70694,0.70587,0.70454,0.70341,0.70214,0.7004,0.69856,0.69707,0.69579,0.69405,0.6918,0.68971,0.68802,0.68669,0.68521,0.68347,0.68193,0.68045,0.67927,0.6781,0.67723,0.67651,0.67528,0.67365,0.67232,0.6717,0.67129,0.67032,0.66909,0.66822,0.66746,0.66669,0.66592,0.66515,0.66408,0.66249,0.66076,0.65932,0.65815,0.65687,0.65544,0.6539,0.65278,0.65216,0.65145,0.65022,0.64874,0.64761,0.64674,0.64602,0.64526,0.64449,0.64336,0.64209,0.64117,0.6405,0.64009,0.63989,0.63943,0.63835,0.63712,0.63636,0.63595,0.63528,0.63421,0.63313,0.63237,0.6316,0.63037,0.62889,0.62776,0.62674,0.62551,0.62398,0.62265,0.62168,0.62065,0.61932,0.61753,0.6159,0.61508,0.61467,0.6139,0.61262,0.6116,0.61104,0.61048,0.60991,0.60925,0.60863,0.60807,0.6071,0.60556,0.60434,0.60357,0.60296,0.6028,0.60244,0.60152,0.60065,0.59994,0.59932,0.59871,0.59764,0.5959,0.59406,0.59288,0.59186,0.59037,0.58915,0.58828,0.5873,0.58623,0.58495,0.58393,0.58311,0.58193,0.58071,0.57938,0.57799,0.57687,0.5762,0.57569,0.57487,0.57395,0.57308,0.57257,0.57237,0.57181,0.57109,0.57068,0.56991,0.56904,0.56828,0.56736,0.56664,0.56613,0.56572,0.56495,0.56337,0.56147,0.55999,0.55881,0.55784,0.55626,0.55426,0.55283,0.55186,0.55119,0.55048,0.5495,0.54833,0.54715,0.54618,0.54541,0.54424,0.54311,0.54234,0.54153,0.54081,0.53979,0.53861,0.53794,0.53774,0.53769,0.53754,0.53636,0.53498,0.53426,0.5337,0.53314,0.53252,0.53191,0.53104,0.53027,0.52956,0.52884,0.52797,0.52695,0.52618,0.5248,0.52296,0.52158,0.52009,0.51851,0.51754,0.51682,0.51595,0.51513,0.51436,0.51355,0.51252,0.51124,0.51043,0.50981,0.50904,0.50823,0.50725,0.50598,0.5048,0.50413,0.50352,0.50306,0.5027,0.50234,0.50214,0.50122,0.5002,0.49989,0.49963,0.49917,0.49841,0.49728,0.49621,0.49518,0.49401,0.49288,0.49186,0.49104,0.49027,0.48971,0.48899,0.48797,0.48725,0.48664,0.48613,0.48582,0.48541,0.48506,0.48475,0.48413,0.48347,0.48316,0.48275,0.48234,0.48188,0.48112,0.48061,0.48015,0.47958,0.47907,0.47815,0.47702,0.47616,0.47534,0.47426,0.47334,0.47288,0.47222,0.47145,0.47094,0.47038,0.46966,0.46915,0.46889,0.46823,0.46756,0.46726,0.46685,0.46633,0.46593,0.46546,0.46526,0.46536,0.46536,0.46511,0.46465,0.46408,0.46357,0.46337,0.46316,0.4626,0.46163,0.46066,0.45989,0.45928,0.45861,0.45789,0.45708,0.45621,0.45534,0.45437,0.4536,0.45314,0.45263,0.45196,0.45135,0.45063,0.45012,0.44981,0.44925,0.44874,0.44859,0.44802,0.44736,0.44726,0.44736,0.44731,0.4469,0.44664,0.44654,0.44639,0.44623,0.44613,0.44608,0.44598,0.44557,0.4447,0.44362,0.44281,0.44209,0.44102,0.44004,0.43902,0.43795,0.43713,0.43641,0.43585,0.43539,0.43493,0.43431,0.43396,0.43385,0.43355,0.43304,0.43237,0.4316,0.43079,0.43032,0.43038,0.43053,0.43053,0.43043,0.43022,0.42976,0.42935,0.4291,0.42879,0.42828,0.42756,0.42685,0.42603,0.42516,0.42444,0.42388,0.42327,0.4226,0.42204,0.42112,0.4203,0.42004,0.41958,0.41882,0.41795,0.41733,0.41672,0.41621,0.41621,0.41636,0.41651,0.41657,0.41641,0.41559,0.41462,0.41426,0.41391,0.41365,0.4137,0.41365,0.41334,0.41288,0.41242,0.41176,0.41114,0.41068,0.41022,0.40946,0.40787,0.40649,0.40582,0.40506,0.40429,0.40357,0.40286,0.40199,0.40143,0.40132,0.40112,0.40081,0.39989,0.39871,0.39779,0.39703,0.39667,0.39641,0.39631,0.39636,0.39621,0.39585,0.39539,0.39503,0.39442,0.39386,0.39355,0.39309,0.39288,0.39268,0.39242,0.39237,0.39227,0.39212,0.39186,0.39166,0.39084,0.38961,0.38925,0.38951,0.3894,0.38905,0.38889,0.38869,0.38802,0.38741,0.3871,0.38685,0.38685,0.3868,0.38669,0.38654,0.38588,0.38506,0.38419,0.38337,0.38281,0.3824,0.38219,0.38209,0.38153,0.38056,0.37964,0.37897,0.37856,0.37805,0.37744,0.37657,0.37534,0.37472,0.37483,0.37467,0.37432,0.37391,0.37299,0.37135,0.36987,0.36889,0.36843,0.36854,0.36889,0.36905,0.36859,0.36767,0.3669,0.36675,0.3668,0.36577,0.3646,0.36444,0.36485,0.36449,0.36332,0.36281,0.36276,0.36265,0.36214,0.36107,0.35994,0.35887,0.35733,0.35565,0.35473,0.35442,0.35406,0.3537,0.3536,0.35304,0.35099,0.34925,0.34925,0.34915,0.34864,0.34808,0.34634,0.3448,0.34342,0.3423,0.34224,0.34107,0.3402,0.34086,0.34143,0.34168,0.3404,0.33851,0.33744,0.33539,0.33324,0.33227,0.33017,0.32849,0.32767,0.32572,0.3246,0.32439,0.32414,0.32378,0.32347,0.32317,0.32281
    };
    
    double m_h_1_der[1022] = {-1.0911,-0.62502,-0.52003,-0.46452,-0.42506,-0.39764,-0.38072,-0.3687,-0.359,-0.35047,-0.34357,-0.33787,-0.33331,-0.32991,-0.32709,-0.32461,-0.3217,-0.31887,-0.31601,-0.31217,-0.30829,-0.30473,-0.30149,-0.29859,-0.29576,-0.29321,-0.29118,-0.28958,-0.28806,-0.28661,-0.28531,-0.2842,-0.28317,-0.28203,-0.28087,-0.28017,-0.27968,-0.27896,-0.27807,-0.27731,-0.27654,-0.27525,-0.27402,-0.27293,-0.27141,-0.27017,-0.2692,-0.26823,-0.26769,-0.26725,-0.2665,-0.26598,-0.26528,-0.26417,-0.26333,-0.26204,-0.26065,-0.25962,-0.2583,-0.25676,-0.25569,-0.25482,-0.25384,-0.2531,-0.25225,-0.25117,-0.25013,-0.24932,-0.24846,-0.24741,-0.24641,-0.24557,-0.24454,-0.24345,-0.24251,-0.24157,-0.24051,-0.23938,-0.23845,-0.23756,-0.23661,-0.23548,-0.23448,-0.23363,-0.23236,-0.23115,-0.22998,-0.2286,-0.22721,-0.22569,-0.22426,-0.2229,-0.22128,-0.21979,-0.21847,-0.21702,-0.21556,-0.21417,-0.21282,-0.21161,-0.21041,-0.20915,-0.20802,-0.20687,-0.20558,-0.20412,-0.20266,-0.20127,-0.19978,-0.19822,-0.19673,-0.1955,-0.19409,-0.19228,-0.19057,-0.18904,-0.18734,-0.18556,-0.18371,-0.18184,-0.18007,-0.17823,-0.17636,-0.17448,-0.17252,-0.17071,-0.16909,-0.16738,-0.16576,-0.16418,-0.1626,-0.16092,-0.15934,-0.15795,-0.1564,-0.155,-0.15361,-0.15213,-0.15084,-0.14946,-0.14793,-0.14646,-0.14485,-0.14316,-0.14158,-0.14012,-0.13858,-0.1369,-0.13532,-0.13385,-0.13237,-0.13085,-0.12918,-0.12766,-0.12622,-0.12472,-0.12344,-0.12207,-0.12089,-0.11973,-0.11845,-0.11734,-0.11623,-0.11523,-0.11424,-0.11311,-0.11198,-0.11094,-0.10985,-0.10878,-0.10761,-0.10643,-0.10525,-0.10413,-0.10293,-0.10173,-0.10054,-0.099226,-0.097927,-0.096551,-0.095139,-0.093758,-0.09229,-0.090822,-0.089431,-0.087988,-0.08652,-0.084986,-0.083461,-0.082039,-0.080628,-0.079201,-0.077809,-0.076382,-0.075134,-0.074009,-0.072812,-0.071671,-0.070572,-0.069508,-0.068536,-0.067748,-0.066955,-0.065983,-0.06514,-0.064301,-0.063273,-0.062377,-0.061513,-0.060454,-0.05939,-0.058388,-0.057447,-0.056603,-0.055667,-0.054736,-0.053927,-0.053078,-0.052219,-0.051344,-0.050378,-0.049022,-0.047835,-0.046976,-0.046025,-0.045247,-0.044403,-0.043493,-0.042659,-0.041784,-0.041012,-0.040301,-0.039447,-0.038618,-0.03781,-0.037125,-0.036501,-0.035687,-0.034895,-0.034153,-0.033421,-0.032736,-0.032035,-0.031447,-0.030741,-0.029754,-0.028915,-0.028153,-0.027381,-0.026542,-0.025585,-0.024757,-0.023994,-0.023171,-0.022409,-0.021764,-0.020982,-0.020138,-0.019176,-0.018082,-0.01712,-0.016189,-0.015197,-0.014261,-0.013529,-0.012967,-0.012542,-0.012087,-0.011626,-0.011319,-0.0109,-0.010343,-0.0099589,-0.0095957,-0.0091098,-0.0087108,-0.0081635,-0.007473,-0.0069206,-0.0065523,-0.0062147,-0.0057646,-0.0053452,-0.0048592,-0.0043375,-0.0036879,-0.0029207,-0.0023478,-0.001867,-0.0013146,-0.00065472,2.5575e-05,0.00069052,0.0014117,0.0021125,0.0028132,0.0034884,0.0040818,0.004537,0.0049309,0.0054935,0.006092,0.0066137,0.0070638,0.0074168,0.0078055,0.008138,0.0083937,0.0086904,0.0089922,0.0094679,0.0098924,0.010261,0.010721,0.011089,0.011504,0.012056,0.012619,0.013181,0.013703,0.014107,0.014496,0.014936,0.015417,0.015836,0.016286,0.016951,0.017596,0.018168,0.018803,0.019432,0.019923,0.020291,0.020578,0.02091,0.021258,0.021463,0.021734,0.021979,0.022209,0.02245,0.022588,0.0227,0.02292,0.02314,0.02337,0.023677,0.023938,0.024271,0.024716,0.025156,0.025575,0.026015,0.026419,0.026879,0.027447,0.027943,0.028445,0.028951,0.029437,0.030005,0.030496,0.030884,0.031268,0.03157,0.031769,0.031979,0.03225,0.032496,0.0327,0.032879,0.033058,0.033411,0.033805,0.034005,0.034122,0.034296,0.03446,0.034639,0.0349,0.03512,0.035283,0.035478,0.035677,0.035918,0.036189,0.036449,0.036777,0.037186,0.037641,0.03804,0.038286,0.038495,0.038787,0.03912,0.039426,0.039708,0.039953,0.040235,0.040495,0.040685,0.04093,0.041166,0.041304,0.041396,0.041478,0.041575,0.041713,0.041856,0.041943,0.04204,0.042255,0.042516,0.0427,0.042843,0.043048,0.043283,0.043554,0.043866,0.044107,0.044316,0.044572,0.044859,0.04514,0.045314,0.045523,0.045943,0.04647,0.046935,0.047242,0.047513,0.047743,0.047841,0.047876,0.047933,0.047984,0.047876,0.047682,0.047667,0.047779,0.047912,0.04805,0.048107,0.048183,0.048296,0.048383,0.048439,0.048398,0.048342,0.048357,0.048424,0.048521,0.048623,0.048812,0.049135,0.049462,0.049764,0.05002,0.050306,0.050608,0.050812,0.050991,0.051242,0.051513,0.051702,0.051897,0.052045,0.052101,0.052168,0.052306,0.052531,0.052766,0.052981,0.053135,0.053211,0.053314,0.053457,0.053585,0.053595,0.053534,0.053498,0.053482,0.053431,0.053355,0.053329,0.053395,0.053426,0.053426,0.053442,0.053467,0.053554,0.053646,0.053707,0.053789,0.053912,0.054014,0.054163,0.054413,0.05471,0.054838,0.054894,0.055099,0.05536,0.055595,0.055789,0.055948,0.056076,0.056117,0.056117,0.056178,0.05626,0.05625,0.056188,0.056025,0.055881,0.055846,0.055789,0.055769,0.055876,0.056025,0.056117,0.056224,0.056296,0.056403,0.056546,0.056664,0.056802,0.05692,0.056996,0.057129,0.057334,0.057605,0.057958,0.058306,0.058562,0.058802,0.059083,0.059262,0.05938,0.059441,0.059441,0.05939,0.059206,0.058971,0.058833,0.058782,0.058725,0.058705,0.058741,0.058787,0.058853,0.058904,0.05895,0.059037,0.059175,0.059324,0.05938,0.059411,0.059503,0.059687,0.059989,0.060342,0.060638,0.060909,0.061104,0.061221,0.06137,0.061528,0.061697,0.061866,0.061953,0.061968,0.061963,0.061999,0.06203,0.061973,0.061917,0.061866,0.061815,0.061764,0.061656,0.061518,0.061426,0.06139,0.061406,0.061493,0.061651,0.061835,0.061999,0.062173,0.062347,0.062505,0.062684,0.062833,0.06295,0.063037,0.06315,0.063344,0.063533,0.063779,0.064117,0.064444,0.064689,0.064848,0.064986,0.065104,0.06517,0.065232,0.065252,0.065196,0.065068,0.064904,0.064766,0.064654,0.064562,0.064495,0.064408,0.064347,0.064316,0.064285,0.06426,0.064239,0.064316,0.064423,0.064592,0.064787,0.064899,0.065022,0.065145,0.065278,0.065472,0.065692,0.065922,0.066147,0.066408,0.066756,0.067099,0.067334,0.067492,0.067605,0.067697,0.067789,0.067845,0.067937,0.068024,0.068014,0.067891,0.067748,0.067631,0.067462,0.067324,0.067257,0.067226,0.067206,0.067175,0.067145,0.06715,0.06718,0.067211,0.067272,0.067324,0.067308,0.067303,0.067329,0.06738,0.067544,0.067774,0.06803,0.06828,0.068521,0.068838,0.069134,0.069334,0.069523,0.069707,0.069881,0.070055,0.070183,0.070265,0.070306,0.070336,0.070347,0.070311,0.070249,0.070208,0.070173,0.070096,0.070014,0.069896,0.069748,0.069661,0.069605,0.069544,0.069533,0.069559,0.06959,0.069697,0.069845,0.069922,0.069927,0.069881,0.069871,0.069973,0.070132,0.070326,0.070592,0.070894,0.071191,0.071421,0.071584,0.071733,0.071815,0.071835,0.07183,0.071799,0.071707,0.071605,0.071554,0.071528,0.071518,0.071574,0.071687,0.071769,0.071779,0.071728,0.071687,0.071702,0.071794,0.071948,0.072101,0.072203,0.07227,0.072336,0.072439,0.072618,0.072832,0.073027,0.073252,0.073482,0.073625,0.073722,0.073809,0.073855,0.073871,0.073902,0.073994,0.07406,0.074029,0.073902,0.073743,0.073641,0.073636,0.073753,0.073963,0.074193,0.074336,0.074387,0.074459,0.074613,0.074771,0.074904,0.075073,0.075257,0.075421,0.075549,0.075697,0.075901,0.076147,0.076439,0.07673,0.077022,0.077303,0.077487,0.077574,0.077584,0.077533,0.077472,0.077395,0.077323,0.077283,0.077175,0.077006,0.076919,0.076878,0.076838,0.076843,0.076863,0.076838,0.076791,0.076817,0.076884,0.07694,0.077032,0.077175,0.077323,0.077462,0.077615,0.077809,0.07805,0.078295,0.07851,0.078699,0.078914,0.079196,0.079502,0.079763,0.079978,0.080157,0.080275,0.080346,0.080392,0.080449,0.080485,0.080413,0.080234,0.079958,0.079676,0.079451,0.079298,0.079216,0.079196,0.079221,0.079247,0.079272,0.079339,0.079426,0.079467,0.079446,0.079375,0.079344,0.079415,0.079543,0.079666,0.07984,0.080075,0.080305,0.080505,0.080679,0.080873,0.081011,0.081073,0.081078,0.081011,0.08093,0.080848,0.080745,0.080577,0.080403,0.080321,0.080275,0.080193,0.080132,0.080152,0.080162,0.080152,0.080157,0.080157,0.080152,0.080254,0.08049,0.080689,0.080837,0.081001,0.08117,0.081318,0.081461,0.081707,0.082009,0.082295,0.082541,0.082725,0.082889,0.083022,0.083165,0.083262,0.083247,0.083242,0.083252,0.083149,0.083078,0.083037,0.082858,0.082612,0.082392,0.082167,0.081968,0.08184,0.081738,0.081671,0.081722,0.081768,0.081717,0.081656,0.081528,0.081415,0.081451,0.081528,0.081538,0.081559,0.081733,0.081953,0.082055,0.082132,0.082231,0.082249,0.08215,0.082051,0.082032,0.082092,0.082265,0.082546,0.08277,0.082854,0.082884,0.08288,0.082851,0.082794,0.082693,0.082662,0.082779,0.083014,0.083242,0.083384,0.083515,0.08364,0.083821,0.084012,0.08413,0.08425,0.084389,0.084605,0.084801,0.084869,0.084981,0.085117,0.085138,0.085102,0.085059,0.085028,0.085025,0.085187,0.085416,0.085394,0.085211,0.085054,0.084915,0.084772,0.084633,0.084546,0.084574,0.084734,0.084922,0.084955,0.084878,0.084804,0.084641,0.084455,0.0844,0.084358,0.08435,0.084496,0.08479,0.085004,0.08509,0.085224,0.085399,0.085555,0.08569,0.085672,0.08564,0.08585,0.086324,0.08674,0.086916,0.087025,0.087063,0.087087,0.087098,0.087034,0.086921,0.086881,0.087043,0.08708,0.086887,0.08673,0.08661,0.08656,0.086554,0.086545,0.086494,0.086451,0.0867,0.087101,0.087273,0.087248,0.086976,0.086758,0.086874,0.087031,0.087087,0.087006,0.087194,0.087825,0.088309,0.088564,0.088821,0.089021,0.08912,0.088884,0.088479,0.08824,0.087883,0.087894,0.088209,0.088322,0.088347,0.088265,0.088168,0.088052,0.087923,0.087784,0.08764
    };
    double m_h_2_der[1022] = {-5.2718,-3.2029,-2.6578,-2.3308,-2.1038,-1.9393,-1.8178,-1.7212,-1.6393,-1.5653,-1.4975,-1.4348,-1.3776,-1.3251,-1.2749,-1.2281,-1.1849,-1.1442,-1.1072,-1.0721,-1.0361,-1.0018,-0.97018,-0.93924,-0.90999,-0.88182,-0.8544,-0.8285,-0.80415,-0.78047,-0.75768,-0.73605,-0.71573,-0.69694,-0.67896,-0.66112,-0.64437,-0.62814,-0.61167,-0.59549,-0.5795,-0.56404,-0.54925,-0.53438,-0.51924,-0.50448,-0.49013,-0.47617,-0.46235,-0.44856,-0.4353,-0.4222,-0.40882,-0.39577,-0.38263,-0.36917,-0.35511,-0.34041,-0.32616,-0.31252,-0.29916,-0.28637,-0.27333,-0.26029,-0.24824,-0.23654,-0.22485,-0.21306,-0.20092,-0.18923,-0.17858,-0.16827,-0.15773,-0.14632,-0.13538,-0.12532,-0.11505,-0.10531,-0.095865,-0.085901,-0.075789,-0.066669,-0.057554,-0.047876,-0.039232,-0.030204,-0.019954,-0.010123,-0.0009207,0.0078362,0.016695,0.026086,0.035345,0.04468,0.053431,0.061518,0.070572,0.079666,0.087584,0.095333,0.10365,0.11234,0.11986,0.12635,0.13354,0.14105,0.14784,0.15377,0.16024,0.16644,0.17172,0.1775,0.18379,0.18909,0.19437,0.20029,0.20489,0.20965,0.21437,0.21867,0.22334,0.2276,0.23225,0.23711,0.24151,0.24547,0.24898,0.25283,0.25636,0.25967,0.26326,0.26647,0.26979,0.27257,0.27474,0.27778,0.28025,0.28222,0.28482,0.28729,0.29034,0.2933,0.29559,0.29781,0.29971,0.30233,0.30458,0.30638,0.30912,0.31129,0.3131,0.31468,0.31594,0.31748,0.31967,0.32178,0.32347,0.32508,0.3263,0.32768,0.33013,0.33223,0.33371,0.33522,0.33615,0.33749,0.33964,0.34164,0.34244,0.34327,0.34528,0.34763,0.34918,0.35032,0.35208,0.35369,0.35462,0.35549,0.3576,0.35955,0.35987,0.36121,0.36367,0.36463,0.36579,0.36799,0.3688,0.3705,0.37265,0.37403,0.37627,0.37816,0.37971,0.38106,0.38247,0.38361,0.38451,0.38562,0.38679,0.3879,0.3885,0.38905,0.38911,0.38897,0.38857,0.38812,0.38706,0.38604,0.38568,0.38498,0.38368,0.38245,0.38169,0.38075,0.37985,0.37899,0.37838,0.37716,0.37603,0.37564,0.37444,0.37311,0.37208,0.3707,0.36992,0.36912,0.36799,0.36757,0.3668,0.3652,0.3643,0.36365,0.36262,0.36193,0.36136,0.36024,0.35885,0.35765,0.3567,0.35559,0.35451,0.35347,0.35179,0.35063,0.35033,0.34946,0.34818,0.34733,0.34667,0.34558,0.34379,0.34227,0.34151,0.34075,0.33942,0.33794,0.33698,0.33598,0.33423,0.3324,0.33122,0.33045,0.32925,0.32716,0.32566,0.32506,0.32395,0.3227,0.32137,0.3199,0.31884,0.31791,0.31665,0.31536,0.31431,0.31316,0.31221,0.31098,0.30941,0.30815,0.30715,0.30621,0.3046,0.30317,0.30212,0.30063,0.29943,0.29832,0.29672,0.29555,0.29493,0.29396,0.29271,0.29166,0.29059,0.28945,0.28827,0.28691,0.28564,0.2844,0.28328,0.28215,0.28115,0.28015,0.2787,0.2774,0.27637,0.27553,0.27473,0.27329,0.2719,0.27102,0.26989,0.2689,0.26784,0.26613,0.26434,0.26259,0.26104,0.25994,0.25891,0.25762,0.25585,0.2543,0.25317,0.25182,0.25064,0.24922,0.24744,0.24594,0.24468,0.24324,0.24153,0.24016,0.23893,0.23741,0.23624,0.23523,0.23325,0.23125,0.23024,0.22919,0.22798,0.22682,0.22526,0.22357,0.22226,0.22109,0.21998,0.21856,0.21707,0.21615,0.21475,0.21286,0.21146,0.21021,0.20878,0.20759,0.20653,0.20536,0.2037,0.20215,0.20119,0.20006,0.19849,0.19717,0.19676,0.19583,0.19418,0.19324,0.19259,0.19135,0.19006,0.18902,0.18804,0.18692,0.18545,0.18429,0.18376,0.18276,0.18118,0.18009,0.17917,0.17801,0.17677,0.17574,0.17481,0.17368,0.17222,0.17037,0.16893,0.16828,0.16737,0.16603,0.16504,0.16418,0.16287,0.16117,0.15983,0.15889,0.15806,0.15737,0.15626,0.15488,0.15397,0.15287,0.15112,0.14984,0.14929,0.14853,0.14742,0.14653,0.1459,0.14518,0.14428,0.14324,0.14183,0.14009,0.13912,0.1385,0.13724,0.13595,0.13489,0.13386,0.13275,0.13166,0.13057,0.1295,0.12858,0.12778,0.12662,0.1249,0.12368,0.12305,0.12215,0.12089,0.11993,0.11944,0.11849,0.11697,0.11554,0.11417,0.11331,0.11273,0.11156,0.11031,0.10943,0.10881,0.10809,0.10693,0.10593,0.10519,0.10454,0.10347,0.10197,0.10074,0.099758,0.098878,0.098126,0.097405,0.096633,0.095794,0.094837,0.093998,0.093211,0.092316,0.091339,0.090397,0.089579,0.089021,0.087978,0.086715,0.085866,0.085359,0.085016,0.08428,0.083318,0.082449,0.081681,0.081022,0.080454,0.079564,0.078275,0.077237,0.076669,0.07626,0.075416,0.074024,0.072919,0.072551,0.072162,0.071114,0.069896,0.06916,0.068781,0.068045,0.067073,0.065861,0.064761,0.063963,0.063416,0.063349,0.062879,0.061815,0.060792,0.060168,0.059907,0.059518,0.058654,0.057636,0.056787,0.056199,0.055564,0.054812,0.054137,0.053191,0.05228,0.051841,0.05138,0.050511,0.04937,0.047938,0.046787,0.046424,0.046183,0.045472,0.044342,0.043416,0.042889,0.042373,0.04179,0.041186,0.040393,0.039171,0.038214,0.03782,0.037488,0.036756,0.0356,0.034485,0.034005,0.03401,0.033785,0.033155,0.032138,0.031273,0.030869,0.030572,0.030225,0.0298,0.02893,0.027713,0.026792,0.026363,0.026168,0.025815,0.024874,0.02379,0.023186,0.022864,0.022475,0.021918,0.020977,0.020174,0.019877,0.019642,0.019186,0.018506,0.017657,0.016711,0.01602,0.015667,0.015509,0.015263,0.014747,0.013949,0.013094,0.012491,0.012123,0.011928,0.011688,0.011202,0.010542,0.0098259,0.0092428,0.0087466,0.00823,0.0076265,0.0068081,0.0061278,0.0058413,0.0056009,0.005427,0.0051201,0.0044859,0.003693,0.0028081,0.0022762,0.0018056,0.0012685,0.00077236,-5.6265e-05,-0.00097185,-0.0015447,-0.001867,-0.0022711,-0.002624,-0.0027826,-0.0031969,-0.0040255,-0.0045984,-0.0048592,-0.0051866,-0.0054679,-0.0057339,-0.0061431,-0.0065983,-0.006762,-0.0069206,-0.0073349,-0.0077901,-0.0084346,-0.0090638,-0.009739,-0.010476,-0.010921,-0.0111,-0.011243,-0.011775,-0.012644,-0.013345,-0.013698,-0.014056,-0.014511,-0.014982,-0.015724,-0.016598,-0.01712,-0.017365,-0.017877,-0.018419,-0.018833,-0.019457,-0.020327,-0.021278,-0.021846,-0.022092,-0.022174,-0.022209,-0.022465,-0.022992,-0.023601,-0.023994,-0.024158,-0.024153,-0.02425,-0.02467,-0.025345,-0.026056,-0.026588,-0.026956,-0.027432,-0.027974,-0.028327,-0.028649,-0.029166,-0.029733,-0.030306,-0.030808,-0.03115,-0.031606,-0.032378,-0.033145,-0.033703,-0.034081,-0.03423,-0.034511,-0.034992,-0.035401,-0.035964,-0.036623,-0.036946,-0.037186,-0.037595,-0.038132,-0.038639,-0.039053,-0.039616,-0.04049,-0.041109,-0.041432,-0.041682,-0.041728,-0.04181,-0.042204,-0.043094,-0.04402,-0.044516,-0.044685,-0.044859,-0.04514,-0.045564,-0.046552,-0.047641,-0.047984,-0.048004,-0.048306,-0.048858,-0.049329,-0.049605,-0.050086,-0.050807,-0.051278,-0.051493,-0.051656,-0.051636,-0.051421,-0.051488,-0.05228,-0.053257,-0.05382,-0.054071,-0.054117,-0.05426,-0.054587,-0.055145,-0.05583,-0.056265,-0.056357,-0.056367,-0.056654,-0.057114,-0.0576,-0.05804,-0.058424,-0.058822,-0.059242,-0.059631,-0.059897,-0.060009,-0.060076,-0.060285,-0.060812,-0.06138,-0.061805,-0.062239,-0.062321,-0.062234,-0.062383,-0.062531,-0.062659,-0.062807,-0.062904,-0.063037,-0.063262,-0.063631,-0.064357,-0.065058,-0.065365,-0.065375,-0.065375,-0.065707,-0.066086,-0.066326,-0.066577,-0.066843,-0.067093,-0.067564,-0.068239,-0.068781,-0.069037,-0.06893,-0.068858,-0.069017,-0.069216,-0.069564,-0.070147,-0.070531,-0.070439,-0.070352,-0.070449,-0.070653,-0.070853,-0.070966,-0.07118,-0.071687,-0.072162,-0.072423,-0.072705,-0.072976,-0.073119,-0.073104,-0.07317,-0.073487,-0.073978,-0.074572,-0.075011,-0.075267,-0.075605,-0.07605,-0.076459,-0.076914,-0.077717,-0.078454,-0.078658,-0.078751,-0.078837,-0.078935,-0.079216,-0.079559,-0.079804,-0.080249,-0.080817,-0.081037,-0.081185,-0.08138,-0.081467,-0.081421,-0.081339,-0.081543,-0.082096,-0.082623,-0.083062,-0.083349,-0.083318,-0.083257,-0.08339,-0.083773,-0.08428,-0.084878,-0.085303,-0.085364,-0.085395,-0.085518,-0.085661,-0.085912,-0.086418,-0.086894,-0.087369,-0.087952,-0.088382,-0.088566,-0.088669,-0.088755,-0.08875,-0.088648,-0.088536,-0.08872,-0.089236,-0.089727,-0.090055,-0.090223,-0.090131,-0.090096,-0.090213,-0.090305,-0.090643,-0.091564,-0.092367,-0.092351,-0.092198,-0.092392,-0.092648,-0.092822,-0.093211,-0.093799,-0.094356,-0.095067,-0.095415,-0.095287,-0.095354,-0.095599,-0.095876,-0.095937,-0.095937,-0.096234,-0.096929,-0.097579,-0.09784,-0.098157,-0.098341,-0.098009,-0.097748,-0.097773,-0.097927,-0.0983,-0.099011,-0.099538,-0.099507,-0.099548,-0.099707,-0.099773,-0.099778,-0.099763,-0.099906,-0.10014,-0.10044,-0.10079,-0.10096,-0.10116,-0.10138,-0.10164,-0.10183,-0.10184,-0.10193,-0.10212,-0.10231,-0.10238,-0.10235,-0.1026,-0.10285,-0.1029,-0.10302,-0.10313,-0.10321,-0.10331,-0.10338,-0.10332,-0.10312,-0.10308,-0.10332,-0.10339,-0.10342,-0.10358,-0.10389,-0.10425,-0.1044,-0.10445,-0.10453,-0.10463,-0.10475,-0.10495,-0.10526,-0.10527,-0.10517,-0.10539,-0.10585,-0.10625,-0.10634,-0.10643,-0.10677,-0.10697,-0.10675,-0.10656,-0.10653,-0.1066,-0.10691,-0.10729,-0.10745,-0.10725,-0.10717,-0.10747,-0.10766,-0.10775,-0.10787,-0.10786,-0.10798,-0.1082,-0.10823,-0.10824,-0.10842,-0.10881,-0.10911,-0.10912,-0.10909,-0.10905,-0.10906,-0.10932,-0.10934,-0.10916,-0.10927,-0.10972,-0.11023,-0.11027,-0.11014,-0.11017,-0.11019,-0.11018,-0.11047,-0.1108,-0.11085,-0.11074,-0.11048,-0.11034,-0.11031,-0.11027,-0.11023,-0.11024,-0.11047,-0.11063,-0.1106,-0.11089,-0.11105,-0.11092,-0.11079,-0.11024,-0.1099,-0.10969,-0.10944,-0.10974,-0.11041,-0.11107,-0.1116,-0.11193,-0.11198,-0.11176,-0.11134,-0.11089,-0.11018,-0.10957,-0.10958,-0.11025,-0.111,-0.11107,-0.11063,-0.11039,-0.11039,-0.11038,-0.11037,-0.11036,-0.11034,-0.11031
    };
    double m_h_3_der[1022] = {-10.88,-5.763,-4.6224,-3.946,-3.4783,-3.1358,-2.8848,-2.6861,-2.5124,-2.3532,-2.205,-2.0649,-1.9353,-1.8156,-1.7017,-1.5966,-1.4997,-1.4107,-1.3288,-1.2505,-1.1736,-1.1009,-1.0332,-0.96872,-0.90761,-0.84833,-0.79048,-0.73475,-0.68087,-0.62715,-0.57364,-0.51998,-0.46958,-0.42293,-0.37554,-0.32623,-0.27967,-0.23482,-0.18975,-0.14387,-0.097768,-0.056275,-0.015713,0.027069,0.066904,0.1064,0.14668,0.18177,0.2176,0.25578,0.2882,0.32099,0.3553,0.38487,0.41466,0.44421,0.47461,0.5054,0.53427,0.56215,0.58799,0.61067,0.63537,0.66229,0.68393,0.70334,0.72304,0.74288,0.76305,0.78118,0.7966,0.81059,0.82356,0.83776,0.85133,0.86261,0.8742,0.88465,0.89485,0.90677,0.91942,0.92788,0.93726,0.94868,0.95558,0.96527,0.97799,0.98703,0.9958,1.0047,1.0146,1.0253,1.0323,1.0406,1.0501,1.057,1.0641,1.0711,1.0761,1.0806,1.0844,1.0858,1.0851,1.0851,1.0874,1.0878,1.0855,1.0817,1.081,1.0795,1.0745,1.0716,1.0681,1.0625,1.0578,1.0534,1.0456,1.0386,1.0329,1.0267,1.0201,1.0123,1.0056,0.99949,0.99114,0.98193,0.97371,0.96551,0.95749,0.94814,0.93741,0.92592,0.91503,0.90336,0.89025,0.88102,0.87214,0.86171,0.85307,0.84402,0.83401,0.82506,0.81576,0.80447,0.79344,0.78558,0.77788,0.76729,0.75784,0.74945,0.7412,0.73284,0.72265,0.71419,0.70574,0.69561,0.68797,0.68021,0.67279,0.66434,0.65408,0.64357,0.63308,0.62404,0.61442,0.60412,0.596,0.58917,0.58025,0.57255,0.56479,0.55561,0.54697,0.5378,0.52698,0.51697,0.50801,0.49917,0.49023,0.4807,0.47108,0.46234,0.45499,0.44631,0.43727,0.42909,0.42002,0.41087,0.40249,0.3932,0.38437,0.37498,0.36448,0.35496,0.34731,0.33894,0.32995,0.32161,0.31385,0.30671,0.29911,0.29211,0.28375,0.27476,0.26719,0.261,0.254,0.24711,0.24329,0.23712,0.229,0.22159,0.21398,0.20684,0.19871,0.19257,0.18782,0.18219,0.17731,0.17292,0.16888,0.16208,0.1564,0.1518,0.14586,0.14155,0.13625,0.13075,0.1265,0.12063,0.11567,0.11199,0.10677,0.10115,0.094326,0.08849,0.082899,0.075242,0.069871,0.065053,0.058372,0.051733,0.044869,0.0398,0.035795,0.030271,0.025846,0.021744,0.017217,0.012424,0.0066853,0.0020562,-0.0011764,-0.0052326,-0.0092326,-0.012404,-0.016286,-0.019729,-0.02492,-0.031094,-0.034311,-0.037334,-0.043605,-0.04938,-0.05292,-0.055564,-0.057851,-0.061891,-0.066536,-0.069948,-0.07448,-0.080377,-0.083845,-0.086709,-0.0905,-0.093267,-0.096633,-0.1016,-0.10548,-0.10767,-0.10999,-0.11241,-0.1149,-0.11776,-0.12016,-0.12229,-0.12504,-0.12669,-0.12687,-0.12719,-0.12908,-0.13125,-0.13269,-0.13419,-0.13579,-0.13815,-0.14155,-0.14476,-0.1463,-0.14786,-0.15051,-0.15289,-0.15502,-0.15738,-0.15907,-0.16115,-0.16393,-0.1659,-0.16808,-0.17059,-0.17367,-0.17609,-0.17768,-0.17859,-0.17877,-0.17969,-0.1815,-0.18405,-0.18622,-0.18868,-0.19085,-0.19204,-0.19382,-0.19566,-0.1967,-0.19687,-0.19718,-0.19778,-0.19908,-0.20151,-0.20431,-0.20562,-0.20667,-0.20907,-0.21195,-0.21375,-0.21466,-0.2174,-0.21986,-0.22103,-0.22197,-0.22358,-0.22485,-0.22604,-0.22824,-0.2304,-0.23169,-0.23176,-0.23206,-0.23378,-0.23521,-0.23558,-0.23679,-0.23831,-0.23926,-0.24079,-0.24104,-0.24023,-0.24035,-0.24087,-0.24172,-0.24271,-0.24318,-0.24255,-0.24222,-0.24277,-0.24261,-0.24255,-0.2438,-0.2444,-0.24481,-0.24584,-0.24669,-0.24833,-0.24949,-0.24892,-0.24907,-0.2499,-0.24941,-0.24889,-0.24966,-0.24968,-0.24859,-0.24762,-0.24746,-0.24764,-0.24807,-0.24765,-0.24633,-0.24636,-0.24727,-0.24701,-0.24626,-0.24623,-0.24658,-0.24651,-0.24614,-0.24603,-0.24563,-0.24586,-0.24595,-0.24497,-0.24509,-0.24603,-0.24536,-0.24467,-0.24591,-0.24699,-0.2469,-0.24645,-0.24584,-0.24571,-0.24662,-0.24707,-0.24615,-0.24542,-0.24588,-0.2467,-0.24644,-0.24599,-0.2465,-0.2466,-0.24637,-0.24648,-0.24561,-0.24429,-0.24486,-0.24628,-0.24636,-0.24592,-0.24657,-0.24726,-0.2462,-0.24545,-0.24555,-0.24536,-0.24526,-0.24526,-0.24611,-0.24616,-0.24584,-0.24651,-0.24634,-0.24549,-0.24462,-0.24398,-0.24327,-0.24183,-0.24088,-0.24073,-0.24013,-0.23928,-0.23835,-0.23811,-0.23783,-0.23713,-0.23665,-0.23549,-0.23386,-0.23264,-0.23185,-0.23074,-0.22909,-0.22799,-0.22762,-0.22705,-0.22613,-0.22545,-0.2247,-0.22372,-0.22332,-0.22321,-0.22259,-0.22113,-0.21997,-0.21989,-0.22054,-0.22066,-0.2198,-0.21935,-0.21942,-0.21922,-0.21879,-0.21825,-0.21745,-0.21657,-0.21558,-0.21522,-0.21489,-0.21367,-0.21236,-0.21188,-0.21163,-0.21038,-0.20856,-0.20713,-0.20668,-0.2065,-0.20601,-0.2046,-0.20302,-0.20147,-0.19973,-0.19876,-0.19788,-0.19635,-0.19482,-0.19325,-0.19125,-0.19025,-0.18972,-0.18886,-0.18917,-0.18916,-0.18858,-0.1888,-0.18803,-0.18677,-0.18644,-0.18595,-0.18566,-0.18539,-0.18395,-0.18228,-0.18145,-0.18089,-0.18026,-0.17915,-0.17752,-0.17675,-0.17645,-0.17556,-0.17451,-0.17359,-0.17222,-0.17143,-0.17139,-0.17079,-0.17007,-0.16934,-0.16833,-0.16841,-0.16891,-0.16866,-0.16824,-0.16754,-0.16697,-0.16695,-0.16683,-0.16592,-0.16473,-0.1637,-0.16286,-0.16222,-0.162,-0.16204,-0.16126,-0.16044,-0.15965,-0.15838,-0.15778,-0.15756,-0.15659,-0.15522,-0.15393,-0.153,-0.15297,-0.15334,-0.15288,-0.15214,-0.15164,-0.15081,-0.15013,-0.15051,-0.15112,-0.15093,-0.15044,-0.14966,-0.1493,-0.14973,-0.14987,-0.14922,-0.14849,-0.14815,-0.14838,-0.14853,-0.1475,-0.14593,-0.14493,-0.14422,-0.14287,-0.14135,-0.1404,-0.13978,-0.13946,-0.1392,-0.13807,-0.1367,-0.13581,-0.13487,-0.13386,-0.13268,-0.13112,-0.13008,-0.12972,-0.12949,-0.12898,-0.12822,-0.12721,-0.12531,-0.12401,-0.12356,-0.1229,-0.12257,-0.1225,-0.1223,-0.12125,-0.11972,-0.11917,-0.1189,-0.11847,-0.11791,-0.11686,-0.11552,-0.11409,-0.11291,-0.11125,-0.10931,-0.10799,-0.10706,-0.10615,-0.10498,-0.1032,-0.10123,-0.09986,-0.098776,-0.097799,-0.096464,-0.09453,-0.092796,-0.091778,-0.091134,-0.090254,-0.089114,-0.088326,-0.088116,-0.087988,-0.087814,-0.086766,-0.085323,-0.08497,-0.085119,-0.084924,-0.084034,-0.082495,-0.081052,-0.080331,-0.080024,-0.079554,-0.078464,-0.07716,-0.075472,-0.073861,-0.073104,-0.072265,-0.070848,-0.069385,-0.068285,-0.067058,-0.065799,-0.063308,-0.060654,-0.05962,-0.058889,-0.057518,-0.055702,-0.054408,-0.052828,-0.051549,-0.051227,-0.050874,-0.050045,-0.048874,-0.047994,-0.046291,-0.043943,-0.042644,-0.042393,-0.042291,-0.042071,-0.042168,-0.042183,-0.041345,-0.04005,-0.038859,-0.037554,-0.03623,-0.035708,-0.035437,-0.034562,-0.033288,-0.031887,-0.030516,-0.02914,-0.027994,-0.026818,-0.025483,-0.023877,-0.02225,-0.021284,-0.020153,-0.018798,-0.018117,-0.017892,-0.017805,-0.017667,-0.016941,-0.015995,-0.015125,-0.014368,-0.013534,-0.01246,-0.01157,-0.010644,-0.009606,-0.0084653,-0.0074168,-0.0068643,-0.0067211,-0.0066393,-0.0059948,-0.0048848,-0.0039027,-0.002982,-0.0021841,-0.0014834,-0.0010383,-0.00085932,-0.00055242,0.00013811,0.0015652,0.0030383,0.0039846,0.0046547,0.0047058,0.0042557,0.0039385,0.0040255,0.0048183,0.0057544,0.006005,0.0062301,0.006803,0.0065012,0.0058516,0.0064909,0.0082556,0.0097748,0.010486,0.011335,0.012036,0.011611,0.010614,0.010511,0.011422,0.012593,0.01355,0.014312,0.015202,0.016122,0.016158,0.016424,0.017396,0.017729,0.01801,0.018613,0.019335,0.019754,0.02002,0.02003,0.020199,0.020971,0.021749,0.022388,0.023002,0.023299,0.023023,0.023023,0.023657,0.024532,0.025503,0.026726,0.027861,0.028792,0.030184,0.031406,0.031994,0.033299,0.034511,0.035079,0.036194,0.037559,0.038721,0.039549,0.040281,0.041145,0.042255,0.04336,0.044255,0.045099,0.045933,0.046393,0.046526,0.046587,0.04693,0.047477,0.047595,0.047876,0.04891,0.05024,0.051007,0.051534,0.052265,0.052904,0.053651,0.054357,0.054853,0.055794,0.057247,0.058275,0.059012,0.060065,0.06093,0.061549,0.062301,0.063477,0.065017,0.066372,0.067682,0.068807,0.069109,0.069104,0.069482,0.06984,0.070004,0.070434,0.071139,0.071656,0.072208,0.072873,0.073375,0.073743,0.074577,0.075584,0.076086,0.077109,0.078572,0.079963,0.081109,0.082254,0.083334,0.083973,0.084587,0.085267,0.086433,0.087942,0.089845,0.091876,0.093814,0.095615,0.09674,0.097579,0.098244,0.098909,0.099886,0.10125,0.10218,0.10261,0.10376,0.10521,0.10599,0.10679,0.10738,0.10746,0.1081,0.10914,0.11006,0.11107,0.11234,0.1137,0.11459,0.11503,0.11548,0.11622,0.11749,0.11872,0.11965,0.121,0.12231,0.12345,0.12481,0.12593,0.12666,0.12741,0.1283,0.12898,0.12988,0.13142,0.13293,0.1342,0.13565,0.13666,0.13724,0.1378,0.13822,0.1387,0.13983,0.14147,0.14277,0.14377,0.14501,0.14639,0.14736,0.14813,0.14913,0.15037,0.15166,0.15273,0.15348,0.15422,0.1558,0.15741,0.15826,0.15928,0.1602,0.16189,0.16343,0.16378,0.16412,0.16449,0.16583,0.16772,0.16884,0.1694,0.16973,0.17009,0.17065,0.17156,0.17275,0.17415,0.17597,0.17776,0.17881,0.17935,0.17998,0.18094,0.18247,0.18415,0.18545,0.1864,0.18757,0.18949,0.19098,0.1923,0.19397,0.19525,0.19621,0.19717,0.19862,0.19988,0.20074,0.20266,0.20479,0.20604,0.20679,0.20706,0.20728,0.20795,0.20926,0.2103,0.21116,0.21378,0.21618,0.21652,0.21647,0.21653,0.21677,0.21706,0.2181,0.22022,0.22177,0.22353,0.22631,0.2279,0.22846,0.22934,0.23019,0.23145,0.23265,0.23368,0.23551,0.23786,0.24068,0.24261,0.24348,0.24533,0.24735,0.24877,0.25005,0.25072,0.25158,0.25435,0.25819,0.26071,0.26227,0.26307,0.26311,0.26313,0.26312,0.26308,0.26301,0.26292
    };
    double m_h_4_der[1022] = {-24.081,-8.8875,-6.4795,-5.1017,-4.2713,-3.7263,-3.3094,-2.9945,-2.7379,-2.5156,-2.291,-2.0368,-1.7392,-1.4269,-1.1332,-0.85892,-0.62824,-0.44061,-0.29802,-0.21254,-0.13043,-0.050997,0.031248,0.13322,0.22316,0.30864,0.38272,0.45163,0.54022,0.63966,0.74063,0.84528,0.95424,1.0599,1.1627,1.2826,1.4008,1.4984,1.591,1.6837,1.7608,1.822,1.8786,1.927,1.9649,1.9909,2.0205,2.0525,2.081,2.1214,2.1675,2.2115,2.2426,2.2585,2.2704,2.268,2.2566,2.2355,2.2041,2.1647,2.132,2.116,2.1025,2.0872,2.0698,2.0476,2.0184,1.9916,1.9704,1.9441,1.9117,1.8832,1.858,1.8243,1.7863,1.7584,1.737,1.7153,1.695,1.6782,1.6619,1.6394,1.6206,1.6065,1.5844,1.5631,1.5382,1.5076,1.4832,1.4563,1.4273,1.3992,1.3665,1.3354,1.3039,1.2672,1.2267,1.1947,1.1684,1.1389,1.1108,1.084,1.0611,1.0399,1.016,0.99307,0.97347,0.95343,0.92674,0.89705,0.87482,0.85164,0.81728,0.78134,0.74904,0.71994,0.69021,0.65647,0.62032,0.58657,0.55465,0.52311,0.49283,0.46078,0.43049,0.40669,0.38478,0.36204,0.34237,0.32548,0.30722,0.28596,0.26536,0.24743,0.23212,0.22232,0.21269,0.19556,0.1813,0.17068,0.1506,0.13254,0.11711,0.098009,0.082229,0.065308,0.050137,0.026828,-0.002092,-0.022567,-0.041416,-0.062024,-0.085405,-0.10372,-0.12127,-0.14149,-0.15404,-0.16852,-0.18294,-0.19261,-0.21091,-0.22669,-0.23643,-0.25221,-0.26445,-0.27704,-0.29331,-0.30323,-0.31022,-0.32,-0.33978,-0.35706,-0.36294,-0.36929,-0.38863,-0.41063,-0.4217,-0.42745,-0.44735,-0.46815,-0.47425,-0.49258,-0.51453,-0.52509,-0.54067,-0.5634,-0.57656,-0.59903,-0.62165,-0.63645,-0.65901,-0.67815,-0.70048,-0.72002,-0.73923,-0.75675,-0.76775,-0.78125,-0.79495,-0.80702,-0.81528,-0.82303,-0.82432,-0.82367,-0.82088,-0.81711,-0.81136,-0.80775,-0.8051,-0.79911,-0.79029,-0.78061,-0.77583,-0.76921,-0.7645,-0.75859,-0.75475,-0.74685,-0.73797,-0.73523,-0.72733,-0.72041,-0.71632,-0.71156,-0.70797,-0.7013,-0.69262,-0.68968,-0.68554,-0.67924,-0.67919,-0.67548,-0.66556,-0.66075,-0.65923,-0.65245,-0.64755,-0.64775,-0.64195,-0.63381,-0.62953,-0.62652,-0.62112,-0.61615,-0.61432,-0.61156,-0.60484,-0.59931,-0.59891,-0.59682,-0.58858,-0.5815,-0.57832,-0.57483,-0.56623,-0.55704,-0.55227,-0.54542,-0.53529,-0.52577,-0.51861,-0.51047,-0.50412,-0.49486,-0.48468,-0.47926,-0.47437,-0.467,-0.45669,-0.44772,-0.4417,-0.43628,-0.42803,-0.41959,-0.41266,-0.40601,-0.39962,-0.39084,-0.38183,-0.37564,-0.37055,-0.36537,-0.35857,-0.35064,-0.34398,-0.338,-0.33279,-0.32858,-0.32326,-0.3177,-0.31353,-0.30887,-0.30385,-0.29802,-0.29302,-0.29016,-0.28711,-0.28308,-0.27759,-0.27315,-0.27024,-0.26671,-0.26457,-0.26169,-0.25609,-0.25321,-0.25269,-0.25216,-0.25424,-0.25443,-0.25027,-0.24758,-0.24594,-0.24342,-0.2412,-0.24014,-0.23874,-0.23685,-0.23415,-0.23186,-0.23137,-0.22876,-0.22521,-0.22381,-0.22077,-0.21565,-0.21167,-0.20601,-0.19843,-0.19255,-0.19006,-0.18702,-0.18165,-0.1775,-0.17384,-0.1693,-0.16524,-0.16177,-0.15818,-0.1539,-0.14737,-0.14036,-0.13508,-0.13091,-0.1264,-0.12015,-0.11472,-0.11133,-0.10709,-0.10108,-0.095338,-0.089748,-0.083661,-0.076674,-0.072306,-0.070464,-0.066173,-0.060966,-0.056434,-0.051222,-0.041483,-0.034204,-0.033222,-0.03271,-0.029897,-0.026644,-0.026138,-0.021846,-0.014394,-0.0097134,-0.0069717,-0.0047774,-0.0025524,-0.0010946,0.0014424,0.00645,0.0097287,0.010757,0.01244,0.013882,0.015534,0.016987,0.017938,0.018209,0.019913,0.022659,0.024204,0.024363,0.024808,0.030061,0.034076,0.034332,0.034235,0.034071,0.035263,0.037508,0.038168,0.041053,0.045058,0.045672,0.0447,0.044853,0.046864,0.047518,0.046838,0.045912,0.047999,0.052055,0.05516,0.056608,0.056352,0.058326,0.061697,0.06404,0.06537,0.067047,0.070659,0.075651,0.08029,0.082781,0.085461,0.088904,0.09317,0.096612,0.096853,0.099635,0.10511,0.1084,0.1105,0.11282,0.11713,0.12312,0.12658,0.12732,0.12773,0.12971,0.13127,0.12992,0.1298,0.13345,0.13871,0.14327,0.14435,0.14386,0.14514,0.14679,0.1484,0.14888,0.14906,0.14975,0.15124,0.15522,0.15819,0.16053,0.16364,0.16621,0.16631,0.1646,0.16574,0.16692,0.16708,0.16944,0.17271,0.17499,0.17602,0.17808,0.18069,0.18191,0.18073,0.17881,0.18018,0.18239,0.18622,0.18899,0.18877,0.18844,0.1889,0.19057,0.19122,0.19043,0.18873,0.18863,0.19004,0.19156,0.19218,0.19179,0.193,0.19532,0.19542,0.19388,0.19315,0.19353,0.19483,0.19496,0.19393,0.1947,0.19651,0.19864,0.20053,0.20006,0.19897,0.1989,0.19894,0.19977,0.20045,0.19939,0.19656,0.19378,0.19417,0.19674,0.19812,0.19728,0.19664,0.19587,0.19513,0.19567,0.19632,0.19617,0.19609,0.19533,0.19416,0.19634,0.19856,0.1988,0.19985,0.20014,0.20089,0.20257,0.20179,0.20101,0.20208,0.20356,0.20578,0.20772,0.20807,0.21,0.21431,0.21596,0.21545,0.21659,0.21842,0.21934,0.21955,0.21976,0.22152,0.22456,0.22629,0.22758,0.22965,0.23046,0.23159,0.23489,0.23714,0.23837,0.24033,0.24215,0.24453,0.24849,0.25191,0.25348,0.25371,0.25455,0.25664,0.25925,0.2618,0.26299,0.26461,0.26788,0.27055,0.27204,0.27344,0.27348,0.27257,0.27286,0.27327,0.27357,0.27394,0.27378,0.2734,0.27284,0.27244,0.27281,0.27425,0.27636,0.27805,0.27817,0.27705,0.27746,0.27921,0.28043,0.28084,0.28091,0.28113,0.28114,0.28187,0.28386,0.28281,0.28038,0.27943,0.27912,0.27972,0.28198,0.28512,0.28596,0.28569,0.28512,0.28432,0.28455,0.28322,0.27674,0.27139,0.26944,0.26742,0.26585,0.26422,0.26278,0.26114,0.26006,0.25982,0.25804,0.25564,0.25457,0.25479,0.25254,0.24622,0.24135,0.23936,0.2383,0.23862,0.23969,0.23942,0.23764,0.23562,0.23371,0.23183,0.2309,0.23193,0.2323,0.22988,0.22607,0.22313,0.22258,0.2228,0.2222,0.21945,0.21601,0.2132,0.2096,0.20409,0.19916,0.19794,0.19782,0.19687,0.19581,0.19571,0.19441,0.1917,0.19076,0.19029,0.18735,0.18517,0.18396,0.18249,0.18261,0.18381,0.18458,0.18441,0.18382,0.18353,0.18273,0.17548,0.16814,0.167,0.16683,0.1649,0.16321,0.16316,0.16024,0.15677,0.1561,0.15637,0.15614,0.15488,0.15343,0.14732,0.13796,0.1338,0.13415,0.13515,0.13496,0.13322,0.13067,0.12786,0.12566,0.12486,0.12449,0.12212,0.11975,0.11826,0.11565,0.11272,0.10947,0.10458,0.10037,0.099569,0.1001,0.098525,0.095369,0.093159,0.092331,0.09428,0.096955,0.097564,0.096945,0.095359,0.093896,0.093323,0.092745,0.092612,0.092786,0.0892,0.083323,0.080004,0.078075,0.076459,0.073769,0.071472,0.071871,0.072761,0.072674,0.071538,0.070147,0.068981,0.068398,0.068459,0.067707,0.067462,0.069068,0.06937,0.06782,0.066024,0.06429,0.063441,0.063595,0.063313,0.059871,0.056035,0.054838,0.054086,0.053421,0.053155,0.052526,0.051314,0.051191,0.050219,0.047979,0.044741,0.04182,0.041774,0.042603,0.043544,0.044137,0.043498,0.041549,0.040306,0.041155,0.042342,0.043263,0.044327,0.043769,0.042593,0.042843,0.043309,0.04313,0.042449,0.041017,0.037718,0.03491,0.033805,0.03247,0.030455,0.028286,0.027104,0.026081,0.025217,0.025718,0.025805,0.023744,0.020685,0.017529,0.01511,0.013442,0.012286,0.011366,0.010496,0.010629,0.010358,0.0076623,0.0057748,0.0053298,0.0039795,0.0030076,0.0035549,0.004716,0.005115,0.0049411,0.0051457,0.005115,0.0042966,0.0029872,0.0016931,0.0017851,0.00047058,-0.0019846,-0.0037544,-0.0069411,-0.010711,-0.013775,-0.016255,-0.019243,-0.021575,-0.022526,-0.023473,-0.024644,-0.0258,-0.026716,-0.027739,-0.028736,-0.030572,-0.031616,-0.030797,-0.030373,-0.030685,-0.030992,-0.031329,-0.032178,-0.033002,-0.033621,-0.033488,-0.03247,-0.031912,-0.032342,-0.033447,-0.034649,-0.0356,-0.0367,-0.038429,-0.039411,-0.039616,-0.041345,-0.043575,-0.044864,-0.047089,-0.049979,-0.051498,-0.052741,-0.054838,-0.055656,-0.055805,-0.056444,-0.056664,-0.055769,-0.054725,-0.054858,-0.055472,-0.056787,-0.057416,-0.057042,-0.056797,-0.057462,-0.058137,-0.058306,-0.058945,-0.059626,-0.060848,-0.062991,-0.06317,-0.062377,-0.063549,-0.065922,-0.068674,-0.071052,-0.073574,-0.076439,-0.079993,-0.083441,-0.08496,-0.086034,-0.087697,-0.090331,-0.093103,-0.094945,-0.096868,-0.099379,-0.10195,-0.10324,-0.10357,-0.10314,-0.10279,-0.10396,-0.10678,-0.1099,-0.1117,-0.11237,-0.11339,-0.11461,-0.11517,-0.11563,-0.11584,-0.11672,-0.11843,-0.11937,-0.12005,-0.12103,-0.12217,-0.12342,-0.12505,-0.12699,-0.12863,-0.13034,-0.13285,-0.13431,-0.13468,-0.13607,-0.13759,-0.13874,-0.14011,-0.14179,-0.14316,-0.14422,-0.14721,-0.15014,-0.15145,-0.15243,-0.1534,-0.15609,-0.15762,-0.15773,-0.15867,-0.15965,-0.16244,-0.16539,-0.16705,-0.16881,-0.17023,-0.17195,-0.17384,-0.17576,-0.17828,-0.1804,-0.18351,-0.1878,-0.19082,-0.19296,-0.19537,-0.19917,-0.20362,-0.2069,-0.20958,-0.21182,-0.21443,-0.21847,-0.22139,-0.22227,-0.22333,-0.22475,-0.22599,-0.22709,-0.22885,-0.23064,-0.23152,-0.23437,-0.23667,-0.23673,-0.23722,-0.23779,-0.23834,-0.23893,-0.23896,-0.23953,-0.24113,-0.2458,-0.25076,-0.25237,-0.25364,-0.25488,-0.25585,-0.25675,-0.25858,-0.26131,-0.26352,-0.26694,-0.26971,-0.27015,-0.27117,-0.27375,-0.27626,-0.27753,-0.27844,-0.27983,-0.28325,-0.28738,-0.29076,-0.2923,-0.29217,-0.29258,-0.29335,-0.29315,-0.2947,-0.29784,-0.30063,-0.30888,-0.3186,-0.3221,-0.32289,-0.32381,-0.32478,-0.32582,-0.32697,-0.32817,-0.32936,-0.33054
    };
    
};

#endif // include guard


================================================
FILE: src/NonlinearOptimizer.cpp
================================================
//
//  NonlinearOptimizer.cpp
//  OnlinePhotometricCalibration
//
//  Created by Paul on 16.11.17.
//  Copyright (c) 2017-2018 Paul Bergmann and co-authors. All rights reserved.
//
//  See LICENSE.txt
//

#include "NonlinearOptimizer.h"

NonlinearOptimizer::NonlinearOptimizer(int keyframe_spacing,
                                       Database* database,
                                       int safe_zone_size,
                                       int min_keyframes_valid,
                                       int patch_size)
{
    // Initialize object parameters with passed values
    m_keyframe_spacing = keyframe_spacing;
    m_database = database;
    m_safe_zone_size = safe_zone_size;
    m_min_keyframes_valid = min_keyframes_valid;
    m_patch_size = patch_size;
    
    // No optimization data yet on initialization
    m_optimization_block = NULL;
    
    // Keep an estimate of the inverse response here for fast plotting
    m_raw_inverse_response = new double[256];
}

bool NonlinearOptimizer::extractOptimizationBlock()
{
    int nr_images_in_database = static_cast<int>(m_database->m_tracked_frames.size());

    // Not enough images in the database yet -> extraction fails
    // Todo: why 2 times?
    if(nr_images_in_database < 2*(m_keyframe_spacing*m_min_keyframes_valid)+m_safe_zone_size)
    {
        return false;
    }
    
    // Create a new optimization block, delete the old block (if an old one exists)    
    if(m_optimization_block != NULL)
    {
        delete m_optimization_block;
    }
    m_optimization_block = new OptimizationBlock(m_patch_size);
    
    int nr_images_in_block = 0;
    m_optimization_block->deleteExposureTimes();
    
    // Iterate through all images in the database (except the most current ones used for exposure optimization)
    for(int i = 0;i < nr_images_in_database - m_safe_zone_size;i++)
    {
        // Only add keyframe images
        if(i%m_keyframe_spacing == 0)
        {
            nr_images_in_block++;
            
            // Store the image inside the optimization block for later correction
            m_optimization_block->addImage(m_database->m_tracked_frames.at(i).m_image);
            
            // Push exposure time estimate (use either the one found from rapid exposure time estimation or 1.0)
            // If 1.0 is used, then all the optimization parameters should also be initialized with the same constant values (for V,f,E,L)
            m_optimization_block->pushExposureTime(m_database->m_tracked_frames.at(i).m_exp_time,m_database->m_tracked_frames.at(i).m_gt_exp_time);
            //m_optimization_block->pushExposureTime(1.0);
        }
        
        // Get all features in the current keyframe and iterate them
        // Todo: change features to pointer?
        std::vector<Feature*> features = m_database->m_tracked_frames.at(i).m_features;
        
        for(int p = 0;p < features.size();p++)
        {
            // Skip features that are not new, don't attempt at creating a new optimization point
            if(features.at(p)->m_prev_feature != NULL)
                continue;
            
            // Find out in how many and which keyframes this point is visible
            Feature* feature_iterator = features.at(p);
            std::vector<int> keyframes_valid;
            int feature_iterator_image_index = i;
            
            // Track the feature forward until either we hit NULL or the feature is tracked out of the safe zone
            while(feature_iterator != NULL && feature_iterator_image_index < nr_images_in_database-m_safe_zone_size)
            {
                if(feature_iterator_image_index%m_keyframe_spacing == 0) //feature_iterator_image_index is a keyframe image
                    keyframes_valid.push_back(feature_iterator_image_index/m_keyframe_spacing);
                
                // Check the next feature, break if the min. number of keyframes necessary for this feature has been reached
                // -> then go on to extract image information for this feature
                feature_iterator = feature_iterator->m_next_feature;
                feature_iterator_image_index++;
                
                // Break early if the feature has been identified as tracked long enough
                if(keyframes_valid.size() >= m_min_keyframes_valid)
                    break;
            }
            
            // Feature not tracked long enough
            if(keyframes_valid.size() < m_min_keyframes_valid)
                continue;
            
            // Allocate new optimization point
            OptimizedPoint opt_p;
            opt_p.start_image_idx = keyframes_valid.at(0);
            
            // Initialize vector for radiance estimates
            std::vector<double> radiance_estimate;
            for(int r = 0;r < features.at(p)->m_radiance_estimates.size();r++)
            {
                radiance_estimate.push_back(0.0);
            }
            
            // Iterate the good feature again, now completely and extract its information
            feature_iterator = features.at(p);
            feature_iterator_image_index = i;
            int nr_keyframes_valid = 0;
            
            while(feature_iterator != NULL && feature_iterator_image_index < nr_images_in_database-m_safe_zone_size)
            {
                if(feature_iterator_image_index%m_keyframe_spacing != 0) //only extract data on keyframe images
                {
                    feature_iterator = feature_iterator->m_next_feature;
                    feature_iterator_image_index++;
                    continue;
                }
                
                nr_keyframes_valid++;
                
                // Accumulate radiance estimates (obtained using the previously corrected image data)
                for(int r = 0;r < feature_iterator->m_radiance_estimates.size();r++)
                {
                    radiance_estimate.at(r) += feature_iterator->m_radiance_estimates.at(r);
                }
                
                // Initialize the estimation problem with the average of the output intensities of the original images
                // This should be exchanged with the above initialization, if exposure values = 1.0 are used for initialization
                // Assuming unit response and no vignetting (for this, the avg. of outputs is the optimal radiance estimate)
                /*for(int r = 0;r < feature_iterator->m_output_values.size();r++)
                {
                    radiance_estimate.at(r) += feature_iterator->m_output_values.at(r);
                }*/
                
                // Store output intensities to the optimization point
                opt_p.output_intensities.push_back(feature_iterator->m_output_values);
                
                // Store xy locations
                opt_p.xy_image_locations.push_back(feature_iterator->m_xy_location);
                
                // Calculate point radius
                double radius = m_database->m_vignette_estimate.getNormalizedRadius(feature_iterator->m_xy_location);
                opt_p.radii.push_back(radius);
                
                // Set gradient weights
                std::vector<double> grad_weights;
                for(int r = 0;r < feature_iterator->m_gradient_values.size();r++)
                {
                    double grad_value = feature_iterator->m_gradient_values.at(r);
                    double weight = 1.0 - (grad_value/255.0);
                    grad_weights.push_back(weight);
                }
                opt_p.grad_weights.push_back(grad_weights);
                
                feature_iterator = feature_iterator->m_next_feature;
                feature_iterator_image_index++;
            }
            
            // Average radiance estimates
            for(int r = 0;r < features.at(p)->m_radiance_estimates.size();r++)
            {
                radiance_estimate.at(r) /= 255.0*nr_keyframes_valid;
            }
            
            // Store information about in how many keyframes this feature is valid
            opt_p.num_images_valid = nr_keyframes_valid;
            
            // Store the radiance estimates to the optimization point
            opt_p.radiances = radiance_estimate;
            
            // Add point to optimization block
            m_optimization_block->addOptimizationPoint(opt_p);
        }
    }
    
    return true;
}

double NonlinearOptimizer::evfOptimization(bool show_debug_prints)
{
    // Used for calculating first order derivatives, creating the Jacobian
    JacobianGenerator jacobian_generator;
    jacobian_generator.setResponseParameters(m_response_estimate);
    jacobian_generator.setVignettingParameters(m_vignette_estimate);
    
    // Find maximum number of residuals
    int points_per_patch = pow(2*m_patch_size+1,2);
    int num_residuals = m_optimization_block->getNrResiduals();
    
    // Number of parameters to optimize for (4 response, 3 vignette + exposure times)
    int num_parameters = C_NR_RESPONSE_PARAMS + C_NR_VIGNETTE_PARAMS + m_optimization_block->getNrImages();
    
    // Initialize empty matrices for the Jacobian and the residual vector
    cv::Mat Jacobian(num_residuals,num_parameters,CV_64F,0.0);
    cv::Mat Residuals(num_residuals,1,CV_64F,0.0);
    
    // Weight matrix for the Jacobian
    cv::Mat Weights_Jacobian(num_residuals,num_parameters,CV_64F,0.0);
    
    // Fill the Jacobian
    int residual_id = -1;
    double residual_sum = 0;
    int overall_image_index = 0;
    
    std::vector<OptimizedPoint>* points_to_optimize = m_optimization_block->getOptimizedPoints();
    
    // Iterate all tracked points
    for(int p = 0;p < points_to_optimize->size();p++)
    {
        int image_start_index = points_to_optimize->at(p).start_image_idx;
        int nr_img_valid = points_to_optimize->at(p).num_images_valid;
        
        // Iterate images the point is valid
        for(int i = 0;i < nr_img_valid;i++)
        {
            double radius = points_to_optimize->at(p).radii.at(i);
            double exposure = m_optimization_block->getExposureTime(image_start_index+i);
                
            //iterate all the points in the patch
            for(int r = 0;r < points_per_patch;r++)
            {
                double grad_weight = points_to_optimize->at(p).grad_weights.at(i).at(r);
                if(grad_weight < 0.001) // Dont include a point with close to 0 weight in optimization
                    continue;
                
                double radiance = points_to_optimize->at(p).radiances.at(r);
                double o_value = points_to_optimize->at(p).output_intensities.at(i).at(r);
                
                // Avoid I = 0 which leads to NaN errors in the Jacobian, also ignore implausible radiance estimates much larger than 1
                if(radiance < 0.001 || radiance > 1.1)
                    continue;
                if(radiance > 1)
                    radiance = 1;
                
                // Count the actual number of residuals up
                residual_id++;
                
                // Fill the Jacobian row
                jacobian_generator.getJacobianRow_eca(radiance,
                                                      radius,
                                                      exposure,
                                                      Jacobian,
                                                      overall_image_index + image_start_index + i,
                                                      residual_id);
                
                // For debugging
                /*if(show_debug_prints)
                {
                    std::cout << "JACOBIAN ROW ADDED " << std::endl;
                    for(int j = 0;j < num_parameters;j++)
                    {
                        std::cout << Jacobian.at<double>(residual_id,j) << " ";
                            
                        if(Jacobian.at<double>(residual_id,j) != Jacobian.at<double>(residual_id,j))
                        {
                            std::cout << "NAN" << std::endl;
                        }
                    }
                    std::cout << std::endl;
                }*/
                    
                // Write weight values to weight matrix
                for(int k = 0;k < num_parameters;k++)
                {
                    Weights_Jacobian.at<double>(residual_id,k) = grad_weight;
                }
                    
                // Fill the residual vector
                double residual = getResidualValue(o_value, radiance, radius, exposure);
                Residuals.at<double>(residual_id,0) = grad_weight * residual;
                
                residual_sum += std::abs(grad_weight * residual);
            }
        }
    }
        
    overall_image_index += m_optimization_block->getNrImages();
    
    int real_number_of_residuals = residual_id+1;
    
    // Get only the relevant part of the Jacobian (actual number of residuals)
    Jacobian = Jacobian(cv::Rect(0,0,num_parameters,real_number_of_residuals));
    Weights_Jacobian = Weights_Jacobian(cv::Rect(0,0,num_parameters,real_number_of_residuals));
    Residuals = Residuals(cv::Rect(0,0,1,real_number_of_residuals));
    
    // Transpose the Jacobian, calculate J^T * W *J * X = - J^T * W * r
    cv::Mat Jacobian_T;
    cv::transpose(Jacobian, Jacobian_T);
    
    cv::Mat A = Jacobian_T* (Weights_Jacobian.mul(Jacobian));
    //cv::Mat A = Jacobian.t()*Jacobian;
    cv::Mat b = - Jacobian.t() * Residuals; // Todo: reuse Jacobian_T to save time?
    
    // Get the current residual before optimization in order to compare progress
    double total_error, avg_error;
    getTotalResidualError(total_error,avg_error);
    
    if(show_debug_prints)
        std::cout << "Error before ECA adjustment: total: " << total_error << " avg: " << avg_error << std::endl;
    
    // Prepare identity matrix for Levenberg-Marquardt dampening
    cv::Mat Identity = cv::Mat::eye(num_parameters, num_parameters, CV_64F);
    Identity = Identity.mul(A);
    
    // Backup photometric parameters in order to revert if update is not good
    std::vector<double> response_param_backup    = m_response_estimate;
    std::vector<double> vignetting_param_backup = m_vignette_estimate;
    std::vector<double> exp_backups;
    for(int i = 0;i < m_optimization_block->getNrImages();i++)
    {
        exp_backups.push_back(m_optimization_block->getExposureTime(i));
    }
    
    // Perform update steps
    int max_rounds = 6; // Todo: change this to const class member
    cv::Mat BestStateUpdate(num_parameters,1,CV_64F,0.0);
    double current_best_error = total_error;
    
    double lambda = 1.0f;
    double lm_dampening = 1.0;

    // Todo: are these the right LM iterations???
    // Rui: may be because of the alternative optimization of evf and radiances, thus only one iteration in the evf GN.
    for(int round = 0;round < max_rounds;round++)
    {
        if(show_debug_prints)
            std::cout << "ECA Optimization round with dampening = " << lm_dampening << std::endl;
        
        //solve the linear equation system
        cv::Mat State_Update;

        lambda = 1.0;
  
        // Solve state update equation (+LM damping)
        // Todo: reuse Jacobian_T to save time?
        State_Update = - (Jacobian.t()* Weights_Jacobian.mul(Jacobian) + lm_dampening*Identity).inv(cv::DECOMP_SVD)*(Jacobian.t()*Residuals);
        
        // Update the estimated parameters
        for(int k = 0;k < m_response_estimate.size();k++)
        {
            m_response_estimate.at(k) = response_param_backup.at(k) + lambda * State_Update.at<double>(k,0);
        }
        
        for(int k = 0;k < m_vignette_estimate.size();k++)
        {
            m_vignette_estimate.at(k) = vignetting_param_backup.at(k) + lambda * State_Update.at<double>((int)m_response_estimate.size()+k,0);
        }
        
        int abs_image_index = 0;
        for(int i = 0;i < m_optimization_block->getNrImages();i++)
        {
            double new_exp_time = exp_backups.at(i) + lambda*State_Update.at<double>((int)m_response_estimate.size()+(int)m_vignette_estimate.size()+abs_image_index,0);
            m_optimization_block->setExposureTime(i,new_exp_time);
            abs_image_index++;
        }
        
        // Evaluate new residual error with new parameter estimate
        double current_error;
        getTotalResidualError(current_error,avg_error);
        
        if(show_debug_prints)
            std::cout << "error after ECA adjustment: total: " << current_error << " avg: " << avg_error << std::endl;
        
        // Improvement?
        if(current_error < current_best_error)
        {
            //increase damping factor, re-perform
            if(lm_dampening >= 0.0625)
                lm_dampening /= 2.0f;
            
            current_best_error = current_error;
            BestStateUpdate = State_Update;
        }
        else
        {
            if(lm_dampening <= 1000000)
            {
                lm_dampening *= 2;
            }
            else
            {
                if(show_debug_prints)
                    std::cout << "MAX DAMPING REACHED, BREAK EARLY " << std::endl;
                break;
            }
        }
    }
    
    // Apply the best of the found state updates
    
    for(int k = 0;k < m_response_estimate.size();k++)
    {
        m_response_estimate.at(k) = response_param_backup.at(k) + lambda * BestStateUpdate.at<double>(k,0);
    }
    
    for(int k = 0;k < m_vignette_estimate.size();k++)
    {
        m_vignette_estimate.at(k) = vignetting_param_backup.at(k) + lambda * BestStateUpdate.at<double>((int)m_response_estimate.size()+k,0);
    }
    
    int abs_image_index = 0;
    for(int i = 0;i < m_optimization_block->getNrImages();i++)
    {
        double new_exp_time = exp_backups.at(i) +
                              lambda*BestStateUpdate.at<double>((int)m_response_estimate.size() +
                                                                (int)m_vignette_estimate.size() +
                                                                abs_image_index,0);
        m_optimization_block->setExposureTime(i,new_exp_time);
        abs_image_index++;
    }
    
    if(show_debug_prints)
        std::cout << "Best update " << BestStateUpdate << std::endl;
    
    double error_after_optimization;
    getTotalResidualError(error_after_optimization,avg_error);
    
    if(show_debug_prints)
        std::cout << "error after ECA adjustment: total: " << error_after_optimization << " avg: " << avg_error << std::endl;
    
    return avg_error;
}

double NonlinearOptimizer::getResidualValue(double O, double I, double r, double e)
{
    double vignetting = applyVignetting(r);
    
    if(vignetting < 0)
    {
        vignetting = 0;
    }
    if(vignetting > 1)
    {
        vignetting = 1;
    }
    
    // Argument of response function
    double inside = e*I*vignetting;
    double response_value;
    
    // Apply response function
    if(inside < 0)
    {
        response_value = 0;
    }
    else if(inside > 1)
    {
        response_value = 255;
    }
    else
    {
        response_value = applyResponse(inside);
    }
    
    // Compute residual
    double residual = response_value - O;
    
    return residual;
}

void NonlinearOptimizer::getTotalResidualError(double& total_error,double& avg_error)
{
    int residual_id = -1;
    double residual_sum = 0;
    int points_per_patch = pow(2*m_patch_size+1,2);
    
    std::vector<OptimizedPoint>* points_to_optimize = m_optimization_block->getOptimizedPoints();
    
    // Iterate all tracked points
    for(int p = 0;p < points_to_optimize->size();p++)
    {
        int image_start_index = points_to_optimize->at(p).start_image_idx;
        int nr_images         = points_to_optimize->at(p).num_images_valid;
        
        // Iterate all images of the point
        for(int i = 0;i < nr_images;i++)
        {
            double radius = points_to_optimize->at(p).radii.at(i);
            double exposure = m_optimization_block->getExposureTime(image_start_index+i);
                
            // Iterate all the points in the patch
            for(int r = 0;r < points_per_patch;r++)
            {
                // Handle next residual
                residual_id++;
                    
                // Get the radiance value of this residual (image independent)
                double radiance = points_to_optimize->at(p).radiances.at(r);
                
                // Get image output value of this residual (original image)
                double o_value = points_to_optimize->at(p).output_intensities.at(i).at(r);
                    
                // Compute residual
                double residual = getResidualValue(o_value, radiance, radius, exposure);
                    
                // Get the weight of the residual
                double residual_weight = points_to_optimize->at(p).grad_weights.at(i).at(r);
                
                // Accumulate resdiual values
                residual_sum += residual_weight*std::abs(residual);
            }
        }
    }
    
    // Average residual error
    total_error = residual_sum;
    avg_error   = total_error/(residual_id+1);
}

double NonlinearOptimizer::radianceFullOptimization()
{
    // Compute derivatives using this object
    JacobianGenerator jacobian_generator;
    jacobian_generator.setResponseParameters(m_response_estimate);
    jacobian_generator.setVignettingParameters(m_vignette_estimate);
    
    // Get the error before optimization
    double total_error, avg_error;
    getTotalResidualError(total_error,avg_error);
    std::cout << "error before radiance adjustment: total: " << total_error << " avg: " << avg_error << std::endl;
    
    // Nr of residuals around one tracked point
    int nr_patch_points = pow(2*m_patch_size+1,2);
    
    std::vector<OptimizedPoint>* points_to_optimize = m_optimization_block->getOptimizedPoints();
    
    // Iterate all tracked points
    for(int  p = 0;p < points_to_optimize->size();p++)
    {
        int start_image = points_to_optimize->at(p).start_image_idx;
        int num_images  = points_to_optimize->at(p).num_images_valid;
        
        // Iterate all point patches
        for(int r = 0;r < nr_patch_points;r++)
        {
            double radiance_guess = points_to_optimize->at(p).radiances.at(r);
            double left_side_sum = 0;
            double right_side_sum = 0;
            double initialResidualError = getResidualErrorPoint(points_to_optimize->at(p),r);
            
            // Iterate all images
            for(int i = 0;i < num_images;i++)
            {
                double exposure = m_optimization_block->getExposureTime(start_image+i);
                double radius   = points_to_optimize->at(p).radii.at(i);
                double output_value = points_to_optimize->at(p).output_intensities.at(i).at(r);
                    
                // Get the jacobian value
                double jacobian_I_value;
                jacobian_generator.getJacobianRadiance(radiance_guess, radius, exposure, jacobian_I_value);
                jacobian_I_value *= 255;
                    
                // Get the residual value
                double residual = getResidualValue(output_value, radiance_guess, radius, exposure);
                    
                left_side_sum += (jacobian_I_value*jacobian_I_value);
                right_side_sum += (jacobian_I_value*residual);
            }
            
            // Update radiance estimate
            double lambda = 1;
            double new_error = initialResidualError+1;
            int max_iterations = 10;
            int curr_iteration = 0;

            while(new_error > initialResidualError)
            {
                if(curr_iteration == max_iterations)
                {
                    lambda = 0;
                }

                // Todo: change to use a local variable
                points_to_optimize->at(p).radiances.at(r) = radiance_guess - lambda * (right_side_sum/left_side_sum);
                if(points_to_optimize->at(p).radiances.at(r) < 0.001)
                { 
                    points_to_optimize->at(p).radiances.at(r) = 0.001;
                }
                if(points_to_optimize->at(p).radiances.at(r) > 0.999)
                {
                    points_to_optimize->at(p).radiances.at(r) = 0.999;
                }
                    
                lambda /= 2; // Todo: to justify this in literature
                curr_iteration++;
                    
                if(lambda < 0.001)
                    break;

                new_error = getResidualErrorPoint(points_to_optimize->at(p), r);
            }
        }
    }
    
    getTotalResidualError(total_error,avg_error);
    std::cout << "error after Radiance adjustment: total: " << total_error << " avg: " << avg_error << std::endl;
    
    return avg_error;
}

double NonlinearOptimizer::getResidualErrorPoint(OptimizedPoint p,int r)
{
    int start_image = p.start_image_idx;
    int num_images  = p.num_images_valid;
    double radiance_guess = p.radiances.at(r);
    double totalError = 0;
    
    for(int i = 0;i < num_images;i++)
    {
        double radius = p.radii.at(i);
        double output_value = p.output_intensities.at(i).at(r);
        double exposure = m_optimization_block->getExposureTime(start_image+i);
        double residual = getResidualValue(output_value, radiance_guess, radius, exposure);
        totalError += std::abs(residual);
    }
    
    return totalError;
}


void NonlinearOptimizer::fetchResponseVignetteFromDatabase()
{
    // Fetch vignette estimate from database
    m_vignette_estimate = m_database->m_vignette_estimate.getVignetteEstimate();
    
    // Set response estimate to unit response
    m_response_estimate.clear();
    m_response_estimate.push_back(6.3);
    m_response_estimate.push_back(0.0);
    m_response_estimate.push_back(0.0);
    m_response_estimate.push_back(0.0);
}

double NonlinearOptimizer::applyVignetting(double r)
{
    double r_2 = r*r;
    double r_4 = r_2 * r_2;
    double r_6 = r_4 * r_2;
    
    double result_vignette = 1 + m_vignette_estimate.at(0) * r_2 + m_vignette_estimate.at(1)*r_4 + m_vignette_estimate.at(2) * r_6;
    
    if(result_vignette < 0)
        result_vignette = 0.0;
    if(result_vignette > 1)
        result_vignette = 1.0;
    
    return result_vignette;
}

double NonlinearOptimizer::applyResponse(double x)
{
    JacobianGenerator jacobian_generator;
    jacobian_generator.setResponseParameters(m_response_estimate);
    double result = jacobian_generator.applyGrossbergResponse(x);
    return 255*result;
}

double NonlinearOptimizer::visualizeOptimizationResult(double* inverse_response)
{
    // Define an exponential factor here to scale response + vignette
    // double exponent = 1.0;
    // To go through one point of the GT response of the TUM Mono camera
    //double exponent = determineGammaFixResponseAt(inverse_response, 206, 0.5);
    double exponent = determineGammaFixResponseAt(inverse_response, 148, 0.3);
    
    // Setup output image windows
    cv::namedWindow("Estimated Vignetting");
    cv::namedWindow("Estimated Response");
    
    double inverse_response_scaled[256];
    
    // Scale up inverse response from range [0,1] to range [0,255]
    for(int i = 0;i < 256;i++)
    {
        inverse_response_scaled[i] = 255*pow(inverse_response[i],exponent);
    }
    
    // Invert the inverse response to get the response
    double response_function[256];
    response_function[0] = 0;
    response_function[255] = 255;

    // For each response value i find s, such that inverse_response[s] = i
    for(int i=1;i<255;i++)
    {
        for(int s=0;s<255;s++)
        {
            if(inverse_response_scaled[s] <= i && inverse_response_scaled[s+1] >= i)
            {
                response_function[i] = s+(i - inverse_response_scaled[s]) / (inverse_response_scaled[s+1]-inverse_response_scaled[s]);
                break;
            }
        }
    }
    
    // Setup a 256x256 mat to display inverse response + response
    // Todo: change to class member
    cv::Mat response_vis_image(256,256,CV_8UC3,cv::Scalar(0,0,0));
    for(int i = 0;i < 256;i++)
    {
        int response_value = static_cast<int>(round(response_function[i]));
        int inv_response_value = static_cast<int>(round(inverse_response_scaled[i]));
        
        if(response_value < 0)
            response_value = 0;
        if(response_value > 255)
            response_value = 255;
        if(inv_response_value < 0)
            inv_response_value = 0;
        if(inv_response_value > 255)
            inv_response_value = 255;
        
        //plot the response
        response_vis_image.at<cv::Vec3b>(255-response_value,i)[0] = 0;
        response_vis_image.at<cv::Vec3b>(255-response_value,i)[1] = 0;
        response_vis_image.at<cv::Vec3b>(255-response_value,i)[2] = 255;
        
        //plot the inverse response
        //response_vis_image.at<cv::Vec3b>(255-inv_response_value,i)[0] = 0;
        //response_vis_image.at<cv::Vec3b>(255-inv_response_value,i)[1] = 0;
        //response_vis_image.at<cv::Vec3b>(255-inv_response_value,i)[2] = 255;
        
        //draw the diagonal
        //response_vis_image.at<cv::Vec3b>(255-i,i)[0] = 255;
        //response_vis_image.at<cv::Vec3b>(255-i,i)[1] = 255;
        //response_vis_image.at<cv::Vec3b>(255-i,i)[2] = 255;
        
        // Draw a variety of GT response functions
        double x = i/255.0;
        
        // [1] Draw the best gamma approximation for DSO response
        /*double dso_gamma_approx_y = pow(x,0.7-0.3*x);
         int dso_gamma_approx_y_int = static_cast<int>(dso_gamma_approx_y*255);
         if(dso_gamma_approx_y_int > 255)
             dso_gamma_approx_y_int = 255;
         response_vis_image.at<cv::Vec3b>(255-dso_gamma_approx_y_int,i)[0] = 255;
         response_vis_image.at<cv::Vec3b>(255-dso_gamma_approx_y_int,i)[1] = 255;
         response_vis_image.at<cv::Vec3b>(255-dso_gamma_approx_y_int,i)[2] = 0;*/
        
        double m;
        double t;
        //draw GT response for DSO camera
        if(x < 0.1)
        {
            m = (90/255.0)/0.1;
            t = 0.0f;
        }
        else if(x < 0.48)
        {
            m = (110.0/255)/0.38;
            t = (200.0/255.0) - m*0.48;
        }
        else
        {
            m = (55.0/255)/0.52;
            t = 1 - m*1;
        }
        double dso_value_f = m*x + t;
        int dso_value = static_cast<int>(dso_value_f*255);
        if(dso_value > 255)
            dso_value = 255;
        response_vis_image.at<cv::Vec3b>(255-dso_value,i)[0] = 255;
        response_vis_image.at<cv::Vec3b>(255-dso_value,i)[1] = 255;
        response_vis_image.at<cv::Vec3b>(255-dso_value,i)[2] = 0;
        
//        /*
//         * Draw GT response for artificial dataset
//         */
//        //draw the GT response for canon EOS 600 D
//        double artificial_value_f = pow(x,0.6-0.2*x);
//        int artificial_value = static_cast<int>(artificial_value_f*255);
//        if(artificial_value > 255)
//            artificial_value = 255;
//        response_vis_image.at<cv::Vec3b>(255-artificial_value,i)[0] = 0;
//        response_vis_image.at<cv::Vec3b>(255-artificial_value,i)[1] = 255;
//        response_vis_image.at<cv::Vec3b>(255-artificial_value,i)[2] = 255;
        
    }
    
    cv::imshow("Estimated Response", response_vis_image);
    // TODO: move only the first time the window is created,
    //       to allow the user to move it somewhere else.
    //       Same for other calls to "moveWindow".
    cv::moveWindow("Estimated Response", 20,20);

    // Show the vignetting
    
    //Setup a 256x256 mat to display vignetting
    cv::Mat vignette_vis_image(256,256,CV_8UC3,cv::Scalar(0,0,0));
    for(int i = 0;i < 256;i++)
    {
        double r = i/255.0f;
        
        double r_2 = r*r;
        double r_4 = r_2 * r_2;
        double r_6 = r_4 * r_2;
        
        double vignette = 1 + m_vignette_estimate.at(0) * r_2 + m_vignette_estimate.at(1)*r_4 + m_vignette_estimate.at(2) * r_6;
        
        vignette = pow(vignette,exponent);
        
        int y_pos = 245 - round(235*vignette);
        if(y_pos < 0)
            y_pos = 0;
        if(y_pos > 255)
            y_pos = 255;
        
        // Plot the vignetting
        vignette_vis_image.at<cv::Vec3b>(y_pos,i)[0] = 0;
        vignette_vis_image.at<cv::Vec3b>(y_pos,i)[1] = 0;
        vignette_vis_image.at<cv::Vec3b>(y_pos,i)[2] = 255;
        
        // Plot the reference line for V = 1
        //vignette_vis_image.at<cv::Vec3b>(10,i)[0] = 255;
        //vignette_vis_image.at<cv::Vec3b>(10,i)[1] = 255;
        //vignette_vis_image.at<cv::Vec3b>(10,i)[2] = 255;
        
        // Plot the reference line for V = 0
        //vignette_vis_image.at<cv::Vec3b>(235,i)[0] = 255;
        //vignette_vis_image.at<cv::Vec3b>(235,i)[1] = 255;
        //vignette_vis_image.at<cv::Vec3b>(235,i)[2] = 255;
        
        // Plot the vignetting for DSO sequence 47
         double dso_vignette_47 = 0.971 + 0.1891*r - 1.5958*r_2 + 1.4473*r_2*r - 0.5143* r_4;
         y_pos = 245 - round(235*dso_vignette_47  );
         vignette_vis_image.at<cv::Vec3b>(y_pos,i)[0] = 255;
         vignette_vis_image.at<cv::Vec3b>(y_pos,i)[1] = 255;
         vignette_vis_image.at<cv::Vec3b>(y_pos,i)[2] = 0;
        
//        // Plot the vignetting for artificial dataset
//        double art_vignette =  0.9983-0.0204*r -0.2341*r_2 - 0.0463*r_2*r;
//        y_pos = 245 - round(235*art_vignette  );
//        vignette_vis_image.at<cv::Vec3b>(y_pos,i)[0] = 0;
//        vignette_vis_image.at<cv::Vec3b>(y_pos,i)[1] = 255;
//        vignette_vis_image.at<cv::Vec3b>(y_pos,i)[2] = 255;
        
    }
    
    cv::imshow("Estimated Vignetting", vignette_vis_image);
    cv::moveWindow("Estimated Vignetting", 20,20+50+256);


    // Visualize exposure times 
    // If GT data is available, the estimated exposure times will be aligned 
    // to the GT by computing an optimal alignment factor alignment_alpha
    // If no GT data is available, the estimated exposure is simply scaled between [0,1]
    int exp_image_height = 150;
    int draw_spacing = 5;
    double alignment_alpha = 1.0;
    double max_exp = -10000.0;
    double min_exp = 10000.0;
    double top = 0;
    double bot = 0;
    int nr_block_images = m_optimization_block->getNrImages();
    std::vector<double> block_exp_estimates;
    std::vector<double> block_exp_gt;
    for(int i = 0;i < nr_block_images;i++)
    {
        double estimated_exp = m_optimization_block->getExposureTime(i);
        estimated_exp = pow(estimated_exp,exponent);
        double gt_exp = m_optimization_block->getGTExposureTime(i);

        // Store max and min exposure for normalization to [0,1] range 
        if(estimated_exp > max_exp)
            max_exp = estimated_exp;
        if(estimated_exp < min_exp)
            min_exp = estimated_exp;

        // Accumulate information for least square fit between GT and estimated exposure
        top += estimated_exp*gt_exp;
        bot += estimated_exp*estimated_exp;

        block_exp_estimates.push_back(estimated_exp);
        if(!(gt_exp < 0))
            block_exp_gt.push_back(gt_exp);
    }

    if(block_exp_estimates.size() == block_exp_gt.size())
    {
        alignment_alpha = top/bot;
    }
    else
    {
        // Normalize estimated exposures between [0,1] if no gt information is available for alignment
        for(int i = 0;i < block_exp_estimates.size();i++)
        {
            block_exp_estimates.at(i) = (block_exp_estimates.at(i)-min_exp)/(max_exp-min_exp);
        }
    }

    for(int i = 0;i < block_exp_estimates.size();i++)
    {
        block_exp_estimates.at(i) *= alignment_alpha;
    }

    // Create exposure time canvas
    draw_spacing = 20;
    int block_exp_window_width = int(fmax(400,draw_spacing*block_exp_estimates.size()));
    cv::Mat block_exposure_vis_image(exp_image_height,block_exp_window_width,CV_8UC3,cv::Scalar(0,0,0));

    // Draw estimated exposure times as lines to graph
    for(int i = 0;i < block_exp_estimates.size()-1;i++)
    {
        int drawing_y_exp_1 = exp_image_height - exp_image_height*(block_exp_estimates.at(i));
        drawing_y_exp_1 = int(fmax(0,drawing_y_exp_1));
        drawing_y_exp_1 = int(fmin(exp_image_height-1,drawing_y_exp_1));

        int drawing_y_exp_2 = exp_image_height - exp_image_height*(block_exp_estimates.at(i+1));
        drawing_y_exp_2 = int(fmax(0,drawing_y_exp_2));
        drawing_y_exp_2 = int(fmin(exp_image_height-1,drawing_y_exp_2));

        //draw exposure lines
        cv::line(block_exposure_vis_image, cv::Point(draw_spacing*i,drawing_y_exp_1), cv::Point(draw_spacing*(i+1),drawing_y_exp_2), cv::Scalar(0,0,255));
     }

    // draw GT exposure line only if GT exposure data is available
    if(block_exp_estimates.size() == block_exp_gt.size())
    {
        for(int i = 0;i < block_exp_estimates.size()-1;i++)
        {
            int drawing_y_gt_exp_1 = exp_image_height - exp_image_height * block_exp_gt.at(i);
            drawing_y_gt_exp_1 = int(fmax(0,drawing_y_gt_exp_1));
            drawing_y_gt_exp_1 = int(fmin(exp_image_height-1,drawing_y_gt_exp_1));

            int drawing_y_gt_exp_2 = exp_image_height - exp_image_height * block_exp_gt.at(i+1);
            drawing_y_gt_exp_2 = int(fmax(0,drawing_y_gt_exp_2));
            drawing_y_gt_exp_2 = int(fmin(exp_image_height-1,drawing_y_gt_exp_2));

            cv::line(block_exposure_vis_image, cv::Point(draw_spacing*i,drawing_y_gt_exp_1), cv::Point(draw_spacing*(i+1),drawing_y_gt_exp_2), cv::Scalar(255,255,0));
        }
    }   

    cv::imshow("Estimated Keyframe Exposures (Backend)", block_exposure_vis_image);
    cv::moveWindow("Estimated Keyframe Exposures (Backend)", 20+20+256,20+40+exp_image_height);


    cv::waitKey(1);

    // Return gamma that was used for visualization
    return exponent;
}

double NonlinearOptimizer::getInverseResponseFixGamma(double* inverse_response_function)
{
    getInverseResponseRaw(inverse_response_function);
    double gamma = determineGammaFixResponseAt(inverse_response_function, 127, 0.5);
    
    // Scale the inverse response
    for(int i = 0;i < 256;i++)
    {
        inverse_response_function[i] = pow(inverse_response_function[i],gamma);
    }
    
    // Return the obtained gamma factor
    return gamma;
}

void NonlinearOptimizer::getInverseResponseRaw(double* inverse_response_function)
{
    //set boundaries of the inverse response
    inverse_response_function[0] = 0;
    inverse_response_function[255] = 1.0;
    
    // For each inverse response value i find s, such that response[s] = i
    for(int i=1;i<255;i++)
    {
        bool inversion_found = false;
        
        for(int s=0;s<255;s++)
        {
            double response_s1 = applyResponse(s/255.0f);
            double response_s2 = applyResponse((s+1)/255.0f);
            if(response_s1 <= i && response_s2 >= i)
            {
                inverse_response_function[i] = s+(i - response_s1) / (response_s2-response_s1);
                inverse_response_function[i] /= 255.0;
                inversion_found = true;
                break;
            }
        }
        
        if(!inversion_found)
        {
            std::cout << "Error, no inversion found in getInverseResponse(..)" << std::endl;
        }
    }
}

double NonlinearOptimizer::determineGammaFixResponseAt(double*inverse_response,int x,double y)
{
    double v_y = inverse_response[x];
    double gamma = log(y) / log(v_y);
    return gamma;
}

void NonlinearOptimizer::smoothResponse()
{
    // Get inverse response estimate, fixing the gamma value reasonably
    double inverse_response[256];
    double gamma = getInverseResponseFixGamma(inverse_response);
    
    // Scale up the inverse response to range [0,255]
    for(int i = 0;i < 256;i++)
    {
        inverse_response[i] = 255*inverse_response[i];
    }
    
    // Invert the inverse response to get the response again
    double response_function[256];
    response_function[0] = 0;
    response_function[255] = 255;
    
    // For each response value i find s, such that inverse_response[s] = i
    for(int i=1;i<255;i++)
    {
        for(int s=0;s<255;s++)
        {
            if(inverse_response[s] <= i && inverse_response[s+1] >= i)
            {
                response_function[i] = s+(i - inverse_response[s]) / (inverse_response[s+1]-inverse_response[s]);
                break;
            }
        }
    }
    
    // Fit the Grossberg parameters new to the acquired data
    JacobianGenerator generator;
    m_response_estimate = generator.fitGrossbergModelToResponseVector(response_function);
    
    // Scale vignette by gamma factor
    double vfactors[100];
    for(int r = 0;r < 100;r++)
    {
        double radius = r/100.0;
        double vfactor = applyVignetting(radius);
        vfactor = pow(vfactor,gamma);
        vfactors[r] = vfactor;
    }
    
    //[Note] Radiances of optimization should be scaled as well, but since these are not used anymore, its not done
    int nr_block_images = m_optimization_block->getNrImages();
    for(int k = 0;k < nr_block_images;k++)
    {
        double old_exposure = m_optimization_block->getExposureTime(k);
        double new_exposure = pow(old_exposure,gamma);
        m_optimization_block->setExposureTime(k,new_exposure);
    }

    // Fit new vignetting parameters in least square manner
    cv::Mat LeftSide(3,3,CV_64F,0.0);
    cv::Mat RightSide(3,1,CV_64F,0.0);
    
    int nr_bad_v = 0;
    
    for(int r = 0;r < 100;r++)
    {
        double w = 1.0;
        if(r > 0)
        {
            double diff = vfactors[r] - vfactors[r-1];
            if(diff > 0)
            {
                w = 0.5;
                vfactors[r] = vfactors[r-1];
                nr_bad_v++;
            }
        }

        double radius = r/100.0;
        double r2 = radius*radius;
        double r4 = r2*r2;
        double r6 = r4*r2;
        double r8 = r4*r4;
        double r10 = r6*r4;
        double r12 = r6*r6;
        
        LeftSide.at<double>(0,0) += w*r4;
        LeftSide.at<double>(0,1) += w*r6;
        LeftSide.at<double>(0,2) += w*r8;
        RightSide.at<double>(0,0) += (w*vfactors[r]*r2 - w*r2);
        
        LeftSide.at<double>(1,0) += w*r6;
        LeftSide.at<double>(1,1) += w*r8;
        LeftSide.at<double>(1,2) += w*r10;
        RightSide.at<double>(1,0) += (w*vfactors[r]*r4 - w*r4);
        
        LeftSide.at<double>(2,0) += w*r8;
        LeftSide.at<double>(2,1) += w*r10;
        LeftSide.at<double>(2,2) += w*r12;
        RightSide.at<double>(2,0) += (w*vfactors[r]*r6 - w*r6);
    }
    
    cv::Mat Solution;
    cv::solve(LeftSide, RightSide, Solution, cv::DECOMP_SVD);
    
    std::vector<double> solution_vig;
    solution_vig.push_back(Solution.at<double>(0,0));
    solution_vig.push_back(Solution.at<double>(1,0));
    solution_vig.push_back(Solution.at<double>(2,0));
    
    m_vignette_estimate = solution_vig;
}


================================================
FILE: src/NonlinearOptimizer.h
================================================
//
//  NonlinearOptimizer.h
//  OnlinePhotometricCalibration
//
//  Created by Paul on 16.11.17.
//  Copyright (c) 2017-2018 Paul Bergmann and co-authors. All rights reserved.
//
//  See LICENSE.txt
//

#ifndef OnlinePhotometricCalibration_NonlinearOptimizer_h_
#define OnlinePhotometricCalibration_NonlinearOptimizer_h_

#include "Database.h"

#include "OptimizationBlock.h"

#include "JacobianGenerator.h"


/**
 * Implements optimization functions in order to recover photometric parameters 
 * from a data block (optimization block) of keyframes and tracked features
 * Can optimize jointly for exposure times E, vignette V, response function F (EVF optimization), fixing radiances
 * Can optimize for radiances, fixing exposure, response and vignette
 */

class NonlinearOptimizer
{
        
public:
    
    /**
     * Number of response and vignette parameters to optimize, must be 4 for response, 3 for vignette
     */
    const int C_NR_RESPONSE_PARAMS = 4;
    const int C_NR_VIGNETTE_PARAMS = 3;
    
    /**
     * Safe zone size is the number of frames in the database in the end that should not 
     * be read by the opt. backend because it still might be modified by the tracking.
     *
     * @param keyframe_spacing Number of frames that keyframes are apart (relative to all input frames)
     * @param database Handle to the database
     * @param safe_zone_size Don't take images from the first safe_zone_size frames of the database since they are still
     *        being processed by exposure optimization
     * @param min_keyframes_valid Minimum amount of keyframes a feature should be present in in order to include it to optimization
     * @param patch_size Size of tracking patch extracted around features
     */
    NonlinearOptimizer(int keyframe_spacing, Database* database,int safe_zone_size,int min_keyframes_valid,int patch_size);
    
    /**
     * Extract new optimization data from the database
     */
    bool extractOptimizationBlock();
    
    /**
     * Optimize jointly for exposure times E, Vignette V, response F
     * Keep radiance estimates fixed for tracked points
     * 
     * @param show_debug_prints Print some debug information such as reduction of the energy
     */
    double evfOptimization(bool show_debug_prints);
    
    /**
     * Optimize for irradiance values, keeping EVF estimate fixed
     */
    double radianceFullOptimization();
    
    /**
     * Read the current response + vignette estimates from the database and store them to the local variables of the object
     */
    void fetchResponseVignetteFromDatabase();
    
    /**
     * Current estimate of response and vignette parameters
     */
    std::vector<double> m_response_estimate;
    std::vector<double> m_vignette_estimate;
    
    /**
     * Show inverse response + vignette estimate
     * Returns the exponential factor that was used to align data to the ground truth
     */
    double visualizeOptimizationResult(double* inverse_response);
    
    /**
     * Handle exponential ambiguity by fixing the response in one point, also adjusting the vignette estimate
     */
    void smoothResponse();
    
    /**
     * Get the inverse response function vector without gamma optimization!
     */
    void getInverseResponseRaw(double* inverse_response_function);
    
    /**
     * Visualize passed information to the optimization block
     * @param img_width  Width of input images
     * @param img_height Height of input images
     */
    void visualizeOptimizationBlock(int img_width,int img_height)
    {
        m_optimization_block->visualizeBlockInformation(img_width,img_height);
    }
    
    /**
     * Store inverse response function here, used for fast plotting
     */
    double* m_raw_inverse_response;
    
private:
    
    /**
     * Spacing of keyframes used for optimization relative to all available input images
     */
    int m_keyframe_spacing;
    
    /**
     * Handle to database
     */
    Database* m_database;
    
    /**
     * Number of most recent images that should not be used for optimization since they are still modified by the tracker
     */
    int m_safe_zone_size;
    
    /**
     * Size of tracking patches
     */
    int m_patch_size;
    
    /**
     * Min. amount of keyframes a feature must be valid to be added to opt. block
     */
    int m_min_keyframes_valid;
    
    /**
     * Current optimization data for the optimizer
     */
    OptimizationBlock* m_optimization_block;
    
    /**
     * Compute photometric error O - f(eVL) for one point in one image
     */
    double getResidualValue(double O,double I,double r,double e);
    
    /**
     * Compute total photometric error for entire optimization data
     * 
     * @param total_error Summed up absolute residual error
     * @param avg_error Average absolute residual error per point
     */
    void getTotalResidualError(double& total_error,double& avg_error);
    
    /**
     * Evaluate the response function at x based on current estimate within the optimizer
     */
    double applyResponse(double x);
    
    /**
     * Evaluate the vignetting factor at radius r based on current estimate within the optimizer
     */
    double applyVignetting(double r);
    
    /**
     * Get the residual error for point p, subpoint r (in the patch region)
     */
    double getResidualErrorPoint(OptimizedPoint p,int r);
    
    /**
     * Determine the gamma factor that is needed to fix the current inverse response estimate at (x,y)
     */
    double determineGammaFixResponseAt(double* inverse_response,int x,double y);
    
    /**
     * Get the inverse response function vector, fixing it for a reasonable gamma factor (which is also returned)
     */
    double getInverseResponseFixGamma(double* inverse_response_function);
    
};

#endif // include guard


================================================
FILE: src/OptimizationBlock.cpp
================================================
//
//  OptimizationBlock.cpp
//  OnlinePhotometricCalibration
//
//  Created by Paul on 17.11.17.
//  Copyright (c) 2017-2018 Paul Bergmann and co-authors. All rights reserved.
//
//  See LICENSE.txt
//

#include "OptimizationBlock.h"

OptimizationBlock::OptimizationBlock(int patch_size)
{
    m_patch_size = patch_size;
    m_nr_patch_points =(2*m_patch_size+1)*(2*m_patch_size+1);
}

void OptimizationBlock::addOptimizationPoint(OptimizedPoint p)
{
    m_optimized_points.push_back(p);
}

/**
 * A residual arises from a tracked point location within one image, comparing the 
 * photometric image formation process to the actual output intensity
 * Residual r = O - f(e V(r) L)
 */
int OptimizationBlock::getNrResiduals()
{
    int nr_residuals = 0;
    
    for(int i = 0;i < m_optimized_points.size();i++)
    {
        int nr_images = m_optimized_points.at(i).num_images_valid;
        
        nr_residuals += (nr_images * m_nr_patch_points);
    }
    
    return nr_residuals;
}

void OptimizationBlock::visualizeBlockInformation(int image_width,int image_height)
{
    // Iterate each key frame image
    for(int i = 0;i < m_exposure_times.size();i++)
    {
        cv::Mat debug_image(image_height,image_width,CV_8UC3,cv::Scalar(0,0,0));

        // Project each tracked point patch into the debug output image
        for(int p = 0;p < m_optimized_points.size();p++)
        {
            // Is p valid in image i? if yes -> draw its output pixel information on the image
            int start_img = m_optimized_points.at(p).start_image_idx;
            int end_img = start_img + m_optimized_points.at(p).num_images_valid - 1;
            
            if(i < start_img || i > end_img)
            {
                continue;
            }
            
            // Drawing happens here
            cv::Point2f location = m_optimized_points.at(p).xy_image_locations.at(i-start_img);
            std::vector<double> outputs = m_optimized_points.at(p).output_intensities.at(i-start_img);
            
            int output_index = 0;
            for(int x = -m_patch_size;x <= m_patch_size;x++)
            {
                for(int y = -m_patch_size;y <= m_patch_size;y++)
                {
                    int x_location = (int)(location.x + x);
                    int y_location = (int)(location.y + y);
                                    
                    
                    double output = outputs.at(output_index);
                    output_index++;
                    debug_image.at<cv::Vec3b>(y_location,x_location)[0] = (uchar)output;
                    debug_image.at<cv::Vec3b>(y_location,x_location)[1] = (uchar)output;
                    debug_image.at<cv::Vec3b>(y_location,x_location)[2] = (uchar)output;
                }
            }
            
            
        }
        
        // For each pixel where no tracking information is present, draw the original image data around (in different color)
        // in order to check for consistency of the tracking data with the original images
        cv::Mat original_image = m_original_images.at(i);

        for(int r = 0;r < image_height;r++)
        {
            for(int c = 0; c < image_width;c++)
            {
                if(debug_image.at<cv::Vec3b>(r,c)[0] == 0)
                {
                    debug_image.at<cv::Vec3b>(r,c)[0] = original_image.at<uchar>(r,c);
                    debug_image.at<cv::Vec3b>(r,c)[1] = original_image.at<uchar>(r,c);
                    debug_image.at<cv::Vec3b>(r,c)[2] = 0;
                }
            }
        }
        
        cv::resize(debug_image, debug_image, cv::Size(640,480));
        
        cv::imshow("DEB", debug_image);
        cv::waitKey(0);
    }
}


================================================
FILE: src/OptimizationBlock.h
================================================
//
//  OptimizationBlock.h
//  OnlinePhotometricCalibration
//
//  Created by Paul on 17.11.17.
//  Copyright (c) 2017-2018 Paul Bergmann and co-authors. All rights reserved.
//
//  See LICENSE.txt
//

#ifndef OnlinePhotometricCalibration_OptimizationBlock_h_
#define OnlinePhotometricCalibration_OptimizationBlock_h_

#include "StandardIncludes.h"

#include "OptimizedPoint.h"

/**
 * An optimization block takes up the entire optimization data necessary 
 * to optimize for photometric parameters f,V,e,L in the backend.
 */

class OptimizationBlock
{
public:
    
    /**
     * Constructor, takes the patch size of the tracking patches in pixels
     */
    OptimizationBlock(int patch_size);
    
    /**
     * Add data to the optimization block
     * An optimization point corresponds to a feature tracked through several images
     * together with associated information
     */
    void addOptimizationPoint(OptimizedPoint p);
    
    /**
     * Set the exposure time estimate for image at index i
     */
    void setExposureTime(int i,double exp_time)
    {
        m_exposure_times.at(i) = exp_time;
    }
    
    /**
     * Push back a new exposure time
     */
    void pushExposureTime(double exp_time,double gt_exp_time)
    {
        m_exposure_times.push_back(exp_time);
        m_gt_exposure_times.push_back(gt_exp_time);
    }
    
    /**
     * Clear exposure time vector
     */
    void deleteExposureTimes()
    {
        m_exposure_times.clear();
        m_gt_exposure_times.clear();
    }
    
    /**
     * Get the exposure time of image i
     */
    double getExposureTime(int i){return m_exposure_times.at(i);}

    /**
    * Get the ground truth exposure time of image i
    */
    double getGTExposureTime(int i){return m_gt_exposure_times.at(i);}

    /**
     * Get the number of residuals within this optimization block
     */
    int getNrResiduals();
    
    /**
     * Get the number of images within the optimization block
     */
    int getNrImages()
    {
        return static_cast<int>(m_exposure_times.size());
    }
    
    /**
     * Get optimized point information
     */
    std::vector<OptimizedPoint>* getOptimizedPoints()
    {
        return &m_optimized_points;
    }
    
    /**
     * Add the original image to the optimization block
     * (Image data only needed for later correction and visual verification of the optimization result)
     */
    void addImage(cv::Mat image)
    {
        m_original_images.push_back(image);
    }
    
    /**
     * Return the original image at index i
     */
    cv::Mat getImage(int i)
    {
        return m_original_images.at(i);
    }

    /**
     * Visualize the block (for debugging only)
     * (Shows the original images + projects the tracked image patches inside)
     */
    void visualizeBlockInformation(int image_width,int image_height);
    
    
private:
    
    /**
     * Contains all information necessary for backend optimization
     * Is extracted from the database
     */
    std::vector<OptimizedPoint> m_optimized_points;
    
    /**
     * Size of tracked patches
     */
    int m_patch_size;
    
    /**
     * Total number of points in one patch (equals (2*m_patch_size+1)^2)
     */
    int m_nr_patch_points;
    
    /**
     * Exposure time estimates of the keyframes used for backend optimization
     */
    std::vector<double> m_exposure_times;

    /**
     * Ground truth exposure times for the keyframes used for backend optimization
     */
    std::vector<double> m_gt_exposure_times;
    
    /**
     * Original images used for this block
     * (Only stored here for debugging, visual verification)
     */
    std::vector<cv::Mat> m_original_images;
};

#endif // include guard


================================================
FILE: src/OptimizedPoint.h
================================================
//
//  OptimizedPoint.h
//  OnlinePhotometricCalibration
//
//  Created by Paul on 17.11.17.
//  Copyright (c) 2017-2018 Paul Bergmann and co-authors. All rights reserved.
//
//  See LICENSE.txt
//

#ifndef OnlineCalibration_OptimizedPoint_h
#define OnlineCalibration_OptimizedPoint_h

#include <vector>

/**
 * Struct storing the data for one optimized feature within this optimization block
 */
class OptimizedPoint
{
public:
    
    /**
     * Estimated radiances of this point (patch)
     */
    std::vector<double> radiances;
    
    /**
     * First keyframe this point is valid
     */
    int start_image_idx;
    
    /**
     * Number of keyframes this point is valid in
     */
    int num_images_valid;
    
    /**
     * Output intensities of the original input image
     */
    std::vector<std::vector<double> > output_intensities;
    
    /**
     * Normalized radii of the point in its keyframe images
     */
    std::vector<double> radii;
    
    /**
     * Gradient based weights used for optimization
     */
    std::vector<std::vector<double> > grad_weights;
    
    /**
     * x,y locations in the keyframe images
     */
    std::vector<cv::Point2f>  xy_image_locations;
        
    /**
     * Residual error for this point after optimization
     */
    double optimization_error;
};

#endif


================================================
FILE: src/RapidExposureTimeEstimator.cpp
================================================
//
//  RapidExposureTimeEstimator.cpp
//  OnlinePhotometricCalibration
//
//  Created by Paul on 16.11.17.
//  Copyright (c) 2017-2018 Paul Bergmann and co-authors. All rights reserved.
//
//  See LICENSE.txt
//

#include "RapidExposureTimeEstimator.h"

RapidExposureTimeEstimator::RapidExposureTimeEstimator(int window_size,Database* database)
{
    m_window_size = window_size;
    m_database    = database;
}

double RapidExposureTimeEstimator::estimateExposureTime()
{
    /*
     * A minimum number of m_window_size frames is required for exposure time estimation
     * Not enough frames available yet, fix exposure time to 1.0
     */
    if(m_database->m_tracked_frames.size() < m_window_size)
    {
        return 1.0;
    }
    
    /*
     * Iterate all features in the most current frame backwards for m_window_size images
     */
    std::vector<Feature*> features_last_frame = m_database->m_tracked_frames.at(m_database->m_tracked_frames.size()-1).m_features;
    
    double e_estimate = 0.0;
    double nr_estimates = 0;
    
    for(int i = 0;i < features_last_frame.size();i++)
    {
        //skip newly extracted features (no link to previous frame, cannot be used for exp. estimation)
        if(features_last_frame.at(i)->m_prev_feature == NULL)
            continue;
        
        // average the radiance estimate for this feature from the last m_window_size frames
        std::vector<double> radiances = features_last_frame.at(i)->m_prev_feature->m_radiance_estimates;
        
        // count the number of features used to estimate the point radiances
        int nr_features_used  = 1;
        
        // Iterate the rest of the m_window_size features in the other images to accumulate radiance information
        Feature* curr_feature = features_last_frame.at(i)->m_prev_feature;

        // Todo: k should start from 1?
        for(int k = 0;k < m_window_size;k++)
        {
            // Go one feature backwards
            curr_feature = curr_feature->m_prev_feature;
            
            // No tracking information anymore -> break
            if(curr_feature == NULL)
                break;
            
            // Tracking information is available
            nr_features_used++;
            
            // Accumulate radiance information
            std::vector<double> radiances_temp = curr_feature->m_radiance_estimates;
            for(int r = 0;r < radiances_temp.size();r++)
            {
                radiances.at(r) += radiances_temp.at(r);
            }
        }
        
        // Average radiance estimates for this feature
        for(int r = 0;r < radiances.size();r++)
        {
            radiances.at(r) /= nr_features_used;
        }
  
        // Image output values (corrected by vignette + response but NOT yet by exposure) taken from the current frame
        std::vector<double> outputs = features_last_frame.at(i)->m_radiance_estimates;
        
        // Fetch gradient values for the tracked feature
        std::vector<double> grad_values = features_last_frame.at(i)->m_gradient_values;
        
        // Estimate one exposure ratio for each of the tracking patch points
        for(int k = 0;k < radiances.size();k++)
        {
            // Weight the estimate depending on the gradient (high gradient = low confidence)
            double weight = 1.0 - grad_values.at(k)/125;
            if(weight < 0)weight = 0;
            
            // Avoid division by 0 for underexposed points
            if(fabs(radiances.at(k)) < 0.0001)
                continue;
            
            // Estimate the exposure ratio
            double curr_e_estimate = (outputs.at(k) / radiances.at(k));
            
            // Skip spurious implausible estimates (such as radiance = 0)
            if(curr_e_estimate < 0.001 || curr_e_estimate > 100)
                continue;
            
            // Accumulate estimation information
            e_estimate   += weight*curr_e_estimate;
            nr_estimates += weight;
        }
    }
    
    // This should not happen, just for safety
    if(nr_estimates == 0)
        return 1.0;
    
    // Average the exposure information for each patch
    // [TODO] Maybe use a more robust way to select an exposure time in the presence of severe noise
    double final_exp_estimate = e_estimate / nr_estimates;

    // Todo: this part is confusing...
    // Handle exposure time drift
    // If corrected images are highly over/underexposes, push exposure times
    // Todo: change to use ref
    cv::Mat corrected_image = m_database->m_tracked_frames.at(m_database->m_tracked_frames.size()-1).m_image_corrected;
    cv::Mat original_image  = m_database->m_tracked_frames.at(m_database->m_tracked_frames.size()-1).m_image;
    corrected_image /= final_exp_estimate;
    
    // Count the number of pixels that are under/overexposed in the corrected image
    // And not under/overexposed in the original input image
    int nr_underexposed = 0;
    int nr_overexposed  = 0;
    int nr_pixels = corrected_image.rows*corrected_image.cols;
    
    for(int r = 0;r < corrected_image.rows;r++)
    {
        for(int c = 0;c < corrected_image.cols;c++)
        {
            uchar image_value = corrected_image.at<uchar>(r,c);
            uchar orig_value  = original_image.at<uchar>(r,c);
            if(image_value < 15 && orig_value >= 30)
            {
                nr_underexposed++;
            }
            else if(image_value > 240 && orig_value <= 200)
            {
                nr_overexposed++;
            }
        }
    }
    
    double percentage_underexposed = nr_underexposed / (1.0*nr_pixels);
    double percentage_overexposed  = nr_overexposed / (1.0*nr_pixels);
    
    //std::cout << "UNDER: " << percentage_underexposed << " -- OVER: " << percentage_overexposed << std::endl;
    
    // If the amount of over/underexposed images are too large, correct the exposure time drift
    if(percentage_overexposed > 0.05)
    {
        final_exp_estimate += 0.03;
    }
    else if(percentage_underexposed > 0.03)
    {
        final_exp_estimate -= 0.05;
    }
    
    return final_exp_estimate;
}


================================================
FILE: src/RapidExposureTimeEstimator.h
================================================
//
//  RapidExposureTimeEstimator.h
//  OnlinePhotometricCalibration
//
//  Created by Paul on 16.11.17.
//  Copyright (c) 2017-2018 Paul Bergmann and co-authors. All rights reserved.
//
//  See LICENSE.txt
//

#ifndef OnlinePhotometricCalibration_RapidExposureTimeEstimator_h_
#define OnlinePhotometricCalibration_RapidExposureTimeEstimator_h_

#include "StandardIncludes.h"

#include "Database.h"

class RapidExposureTimeEstimator
{
    
public:
    
    /**
     * Constructor
     * @param window_size Number of frames to use for exposure optimization
     * @param database Handle to the database
     */
    RapidExposureTimeEstimator(int window_size,Database* database);
    
    /**
     * Estimate a fast exposure time for the latest frame in the database
     * The tracks of the last m_window_size frames are considered for exposure time optimization
     * Response and vignette and considered fixed, based on the current estimate in the database
     */
    double estimateExposureTime();
    
private:
    
    /**
     * Handle to the database
     */
    Database* m_database;
    
    /**
     * How many frames to take into account for exposure time estimation
     */
    int m_window_size;
};

#endif // include guard


================================================
FILE: src/ResponseModel.h
================================================
//
//  ResponseModel.h
//  OnlinePhotometricCalibration
//
//  Created by Paul on 16.11.17.
//  Copyright (c) 2017-2018 Paul Bergmann and co-authors. All rights reserved.
//
//  See LICENSE.txt
//

#ifndef OnlinePhotometricCalibration_ResponseModel_h_
#define OnlinePhotometricCalibration_ResponseModel_h_

#include "StandardIncludes.h"

/**
 * Represents data needed for the Grossberg camera response model using the first 4 basis functions
 */
class ResponseModel
{
public:
    
    /**
     * Constructor
     * 
     * Initialize response model with Grossberg parameters that correspond to identity response
     * Also initialize discretely sampled inverse response vector for 256 output intensity values
     */
    ResponseModel()
    {
        m_inverse_response_vector.clear();
        for(int i = 0;i < 256;i++)
        {
            m_inverse_response_vector.push_back(i);
        }
        
        m_grossberg_parameters.clear();
        m_grossberg_parameters.push_back(6.1);
        m_grossberg_parameters.push_back(0.0);
        m_grossberg_parameters.push_back(0.0);
        m_grossberg_parameters.push_back(0.0);
    }
    
    /**
     * Apply inverse response function to output intensity 
     *
     * @param o Output intensity {0,1,...,255}
     * @returns Inverse response applied to o i.e. f^(-1)(o)
     */
    double removeResponse(int o)
    {
        return m_inverse_response_vector.at(o);
    }
    
    /**
     * Overwrite Grossberg parameter vector
     */
    // Todo: change parameter to ref
    void setGrossbergParameterVector(std::vector<double> params)
    {
        m_grossberg_parameters = params;
    }
    
    /**
     * Fetch Grossberg parameter vector
     */
    std::vector<double> getResponseEstimate()
    {
        return m_grossberg_parameters;
    }
    
    /**
     * Overwrite inverse response function vector
     */
    void setInverseResponseVector(double* new_inverse)
    {
        for(int i = 0;i < 256;i++)
        {
            m_inverse_response_vector.at(i) = 255.0 * new_inverse[i];
        }
    }

private:
    
    /**
     * Discrete vector of 256 values representing the sampled inverse camera response function
     * for the 256 image output intensities.
     * This vector is stored here for efficiency since it is not straightforward to invert the response 
     * given only the Grossberg parameters.
     */
    std::vector<double> m_inverse_response_vector;
    
    /**
     * Grossberg parameter vector (4 values) representing the camera response
     */
    std::vector<double> m_grossberg_parameters;

};

#endif // include guard


================================================
FILE: src/StandardIncludes.h
================================================
//
//  OpencvIncludes.h
//  OnlinePhotometricCalibration
//
//  Created by Paul on 16.11.17.
//  Copyright (c) 2017-2018 Paul Bergmann and co-authors. All rights reserved.
//
//  See LICENSE.txt
//

/**
 * Defines all kinds of standard includes that are used in most of the classes
 */

#ifndef OnlineCalibration_StandardIncludes_h
#define OnlineCalibration_StandardIncludes_h

/**
 * Opencv includes
 */
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/video/tracking.hpp>
#include <opencv2/imgproc/imgproc.hpp>

/**
 * Standard library includes
 */
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <vector>
#include <fstream>

#endif


================================================
FILE: src/Tracker.cpp
================================================
//
//  Tracker.cpp
//  OnlinePhotometricCalibration
//
//  Created by Paul on 16.11.17.
//  Copyright (c) 2017-2018 Paul Bergmann and co-authors. All rights reserved.
//
//  See LICENSE.txt
//

#include "Tracker.h"

Tracker::Tracker(int patch_size,int nr_active_features,int nr_pyramid_levels,Database* database)
{
    // Simply store all passed arguments to object
    m_patch_size = patch_size;
    m_max_nr_active_features = nr_active_features;
    m_nr_pyramid_levels = nr_pyramid_levels;
    m_database = database;
}

void Tracker::trackNewFrame(cv::Mat input_image,double gt_exp_time)
{
    // Compute gradient (necessary for weighting factors)
    // Todo: move to class member
    cv::Mat gradient_image;
    computeGradientImage(input_image, gradient_image);
    
    // Correct the input image based on the current response and vignette estimate (exposure time not known yet)
    // Todo: move to class member
    cv::Mat corrected_frame = input_image.clone();
    photometricallyCorrectImage(corrected_frame);
 
    // Empty database -> First frame - extract features and push them back
    if(m_database->m_tracked_frames.size() == 0)
    {
        initialFeatureExtraction(input_image,gradient_image,gt_exp_time);
        return;
    }
    
    // Database not empty
    
    // Fetch the old active feature locations together with their image
    std::vector<cv::Point2f> feature_locations = m_database->fetchActiveFeatureLocations();
    cv::Mat last_frame = m_database->fetchActiveImage();
    
    // Track the feature locations forward using gain robust KLT
    std::vector<cv::Point2f> tracked_points_new_frame;
    std::vector<unsigned char> tracked_point_status;
    std::vector<float> tracking_error_values;

    GainRobustTracker gain_robust_klt_tracker(C_KLT_PATCH_SIZE,C_NR_PYRAMID_LEVELS);
    std::vector<int> tracked_point_status_int;
    gain_robust_klt_tracker.trackImagePyramids(last_frame,
                                               input_image,
                                               feature_locations,
                                               tracked_points_new_frame,
                                               tracked_point_status_int);
    for(int i = 0;i < tracked_point_status_int.size();i++)
    {
        if(tracked_point_status_int.at(i) == 0)
        {
            tracked_point_status.push_back(0);
        }
        else
        {
            tracked_point_status.push_back(1);
        }
    }
     
    // Bidirectional tracking filter: Track points backwards and make sure its consistent
    std::vector<cv::Point2f> tracked_points_backtracking;
    std::vector<unsigned char> tracked_point_status_backtracking;
    std::vector<float> tracking_error_values_backtracking;
    GainRobustTracker gain_robust_klt_tracker_2(C_KLT_PATCH_SIZE,C_NR_PYRAMID_LEVELS);
    std::vector<int> tracked_point_status_int2;
    gain_robust_klt_tracker_2.trackImagePyramids(input_image,
                                                 last_frame,
                                                 tracked_points_new_frame,
                                                 tracked_points_backtracking,
                                                 tracked_point_status_int2);
    for(int i = 0;i < tracked_point_status_int.size();i++)
    {
        if(tracked_point_status_int.at(i) == 0)
        {
            tracked_point_status_backtracking.push_back(0);
        }
        else
        {
            tracked_point_status_backtracking.push_back(1);
        }
    }
    
    // Tracked points from backtracking and old frame should be the same -> check and filter by distance
    for(int p = 0;p < feature_locations.size();p++)
    {
        if(tracked_point_status.at(p) == 0) // Point already set invalid by forward tracking -> ignore
            continue;
        
        if(tracked_point_status_backtracking.at(p) == 0) // Invalid in backtracking -> set generally invalid
            tracked_point_status.at(p) = 0;
        
        // Valid in front + backtracked images -> calculate displacement error
        cv::Point2d d_p = feature_locations.at(p) - tracked_points_backtracking.at(p);
        double distance = sqrt(d_p.x*d_p.x + d_p.y*d_p.y);
        
        if(distance > C_FWD_BWD_TRACKING_THRESH)
        {
            tracked_point_status.at(p) = 0;
        }
    }
    
    Frame frame;
    frame.m_image = input_image;
    frame.m_image_corrected = corrected_frame;
    frame.m_gradient_image = gradient_image;
    frame.m_exp_time = 1.0;
    frame.m_gt_exp_time = gt_exp_time;

    // Reject features that have been tracked to the side of the image
    // Todo: validity_vector can be combined with tracked_point_status to one vector?
    std::vector<int> validity_vector = checkLocationValidity(tracked_points_new_frame);
    
    int nr_pushed_features = 0;
    for(int i = 0;i < feature_locations.size();i++)
    {
        // If the feature became invalid don't do anything, otherwise if its still valid, push it to the database and set the feature pointers
        if(tracked_point_status.at(i) == 0 || validity_vector.at(i) == 0)
            continue;
        
        // Feature is valid, set its data and push it back
        Feature* f = new Feature();
        // Todo: remove os, is, gs
        std::vector<double> os = bilinearInterpolateImagePatch(input_image,tracked_points_new_frame.at(i).x,tracked_points_new_frame.at(i).y);
        f->m_output_values = os;
        std::vector<double> is = bilinearInterpolateImagePatch(corrected_frame,tracked_points_new_frame.at(i).x,tracked_points_new_frame.at(i).y);
        f->m_radiance_estimates = is;
        std::vector<double> gs = bilinearInterpolateImagePatch(gradient_image, tracked_points_new_frame.at(i).x, tracked_points_new_frame.at(i).y);
        f->m_gradient_values = gs;
        f->m_xy_location = tracked_points_new_frame.at(i);
        f->m_next_feature = NULL;
        f->m_prev_feature =  m_database->m_tracked_frames.at(m_database->m_tracked_frames.size()-1).m_features.at(i);
        
        m_database->m_tracked_frames.at(m_database->m_tracked_frames.size()-1).m_features.at(i)->m_next_feature = f;
        
        frame.m_features.push_back(f);
        nr_pushed_features++;
    }
    
    m_database->m_tracked_frames.push_back(frame);
    
    // Extract new features
    std::vector<cv::Point2f> new_feature_locations = extractFeatures(input_image,m_database->fetchActiveFeatureLocations());
    std::vector<int> new_validity_vector = checkLocationValidity(new_feature_locations);
    for(int p = 0;p < new_feature_locations.size();p++)
    {
        // Skip invalid points (too close to the side of image)
        if(new_validity_vector.at(p) == 0)
            continue;
        
        // Push back new feature information
        Feature* f = new Feature();
        f->m_xy_location = new_feature_locations.at(p);
        f->m_next_feature = NULL;
        f->m_prev_feature = NULL;
        // Todo: remove os, is, gs
        std::vector<double> os = bilinearInterpolateImagePatch(input_image,new_feature_locations.at(p).x,new_feature_locations.at(p).y);
        f->m_output_values = os;
        std::vector<double> is = bilinearInterpolateImagePatch(corrected_frame,new_feature_locations.at(p).x,new_feature_locations.at(p).y);
        f->m_radiance_estimates = is;
        std::vector<double> gs = bilinearInterpolateImagePatch(gradient_image, new_feature_locations.at(p).x, new_feature_locations.at(p).y);
        f->m_gradient_values = gs;
        m_database->m_tracked_frames.at(m_database->m_tracked_frames.size()-1).m_features.push_back(f);
    }
}

// Todo: change both types to reference
std::vector<cv::Point2f> Tracker::extractFeatures(cv::Mat frame,std::vector<cv::Point2f> old_features)
{
    std::vector<cv::Point2f> new_features;

    // No new features have to be extracted
    if(old_features.size() >= m_max_nr_active_features)
    {
        return new_features;
    }
    
    int nr_features_to_extract = static_cast<int>(m_max_nr_active_features-old_features.size());
    
    // Build spatial distribution map to check where to extract features
    int cells_r = 10;
    int cells_c = 10;
    
    double im_width  = m_database->m_image_width;
    double im_height = m_database->m_image_height;
        
    int cell_height = floor(im_height / cells_r);
    int cell_width  = floor(im_width  / cells_c);

    // Todo: change to class member
    int pointDistributionMap[cells_r][cells_c];
    for(int r = 0;r < cells_r;r++)
    {
        for(int c = 0;c < cells_c;c++)
        {
            pointDistributionMap[r][c] = 0;
        }
    }
    
    // Build the point distribution map to check where features need to be extracted mostly
    for(int p = 0;p < old_features.size();p++)
    {
        double x_value = old_features.at(p).x;
        double y_value = old_features.at(p).y;
        
        int c_bin = x_value / cell_width;
        if(c_bin >= cells_c)
            c_bin = cells_c - 1;
        
        int r_bin = y_value / cell_height;
        if(r_bin >= cells_r)
            r_bin = cells_r - 1;
        
        pointDistributionMap[r_bin][c_bin]++;
    }
    
    // Identify empty cells
    std::vector<int> empty_row_indices;
    std::vector<int> empty_col_indices;
    
    for(int r = 0;r < cells_r;r++)
    {
        for(int c = 0;c < cells_c;c++)
        {
            if(pointDistributionMap[r][c] == 0)
            {
                empty_row_indices.push_back(r);
                empty_col_indices.push_back(c);
            }
        }
    }

    // Todo: empty_col_indices might be 0!!!
    // Todo: Another bad case is: only one cell is empty and all other cells have only 1 feature inside,
    // Todo: then all the features to extract will be extracted from the single empty cell.
    int points_per_cell = ceil(nr_features_to_extract / (empty_col_indices.size()*1.0));
    
    // Extract "points per cell" features from each empty cell
    for(int i = 0;i < empty_col_indices.size();i++)
    {
        // Select random cell from where to extract features
        int random_index = rand() % empty_row_indices.size();
        
        // Select row and col
        int selected_row = empty_row_indices.at(random_index);
        int selected_col = empty_col_indices.at(random_index);
        
        // Define the region of interest where to detect a feature
        cv::Rect ROI(selected_col * cell_width,selected_row * cell_height,cell_width,cell_height);
        
        // Extract features from this frame
        cv::Mat frame_roi = frame(ROI);
        
        // Extract features
        std::vector<cv::Point2f> good_corners;
        cv::goodFeaturesToTrack(frame_roi,
                                good_corners,
                                points_per_cell,
                                0.01,
                                7,
                                cv::Mat(),
                                7,
                                false,
                                0.04);
        
        // Add the strongest "points per cell" features from this extraction
        for(int k = 0;k < good_corners.size();k++)
        {
            if(k == points_per_cell)
                break;
            
            // Add the offset to the point location
            cv::Point2f point_location = good_corners.at(k);
            point_location.x += selected_col*cell_width;
            point_location.y += selected_row*cell_height;
            
            new_features.push_back(point_location);
        }
    }
    
    return new_features;
}

/**
 * Note: For this function, it is assumed that x,y lies within the image!
 */
double Tracker::bilinearInterpolateImage(cv::Mat image,double x,double y)
{
    double floor_x = std::floor(x);
    double ceil_x  = std::ceil(x);
    
    double floor_y = std::floor(y);
    double ceil_y  = std::ceil(y);
    
    // Normalize x,y to be in [0,1)
    double x_normalized = x - floor_x;
    double y_normalized = y - floor_y;
    
    // Get bilinear interpolation weights
    double w1 = (1-x_normalized)*(1-y_normalized);
    double w2 = x_normalized*(1-y_normalized);
    double w3 = (1-x_normalized)*y_normalized;
    double w4 = x_normalized*y_normalized;
    
    // Evaluate image locations
    double i1 = static_cast<double>(image.at<uchar>(floor_y,floor_x));
    double i2 = static_cast<double>(image.at<uchar>(floor_y,ceil_x));
    double i3 = static_cast<double>(image.at<uchar>(ceil_y,floor_x));
    double i4 = static_cast<double>(image.at<uchar>(ceil_y,ceil_x));
    
    // Interpolate the result
    return w1*i1 + w2*i2 + w3*i3 + w4*i4;
}

/**
 * Note: For this function, it is assumed that x,y lies within the image!
 */
std::vector<double> Tracker::bilinearInterpolateImagePatch(cv::Mat image,double x,double y)
{
    std::vector<double> result;
    
    for(int x_offset = -m_patch_size;x_offset <= m_patch_size;x_offset++)
    {
        for(int y_offset = -m_patch_size;y_offset <= m_patch_size;y_offset++)
        {
            double o_value = bilinearInterpolateImage(image,x+x_offset,y+y_offset);
            result.push_back(o_value);
        }
    }
    
    return result;
}

// Todo: change return to parameter passed by ref
std::vector<int> Tracker::checkLocationValidity(std::vector<cv::Point2f> points)
{
    // Check for each passed point location if the patch centered around it falls completely within the input images
    // Return 0 for a point if not, 1 if yes
    
    int min_x = m_patch_size+1;  //Todo: should be m_patch_size?
    int min_y = m_patch_size+1;
    
    int max_x = m_database->m_image_width-m_patch_size-1;
    int max_y = m_database->m_image_height-m_patch_size-1;
    
    std::vector<int> is_valid;
    
    for(int i = 0;i < points.size();i++)
    {
        if(points.at(i).x < min_x || points.at(i).x > max_x || points.at(i).y < min_y || points.at(i).y > max_y)
        {
            is_valid.push_back(0);
        }
        else
        {
            is_valid.push_back(1);
        }
    }
    
    return is_valid;
}

// Todo: change parameter type to reference (or const reference)
void Tracker::initialFeatureExtraction(cv::Mat input_image,cv::Mat gradient_image,double gt_exp_time)
{
    std::vector<cv::Point2f> old_f;
    std::vector<cv::Point2f> feature_locations = extractFeatures(input_image,old_f);
    std::vector<int> validity_vector = checkLocationValidity(feature_locations);
    
    // Initialize new tracking Frame
    Frame frame;
    frame.m_image = input_image;
    frame.m_image_corrected = input_image.clone();
    frame.m_exp_time = 1.0;
    frame.m_gt_exp_time = gt_exp_time;
    
    // Push back tracked feature points to the tracking Frame
    for(int p = 0;p < feature_locations.size();p++)
    {
        // Skip invalid points (too close to the side of image)
        if(validity_vector.at(p) == 0)
            continue;
        
        // Create new feature object and associate with it output intensities, gradient values, etc.
        Feature* f = new Feature();
        f->m_xy_location = feature_locations.at(p);
        f->m_next_feature = NULL;
        f->m_prev_feature = NULL;
        std::vector<double> os = bilinearInterpolateImagePatch(input_image,feature_locations.at(p).x,feature_locations.at(p).y);
        std::vector<double> gs = bilinearInterpolateImagePatch(gradient_image,feature_locations.at(p).x,feature_locations.at(p).y);
        f->m_gradient_values = gs;
        f->m_output_values = os;
        f->m_radiance_estimates = os;
        frame.m_features.push_back(f);
    }
    
    m_database->m_tracked_frames.push_back(frame);
}

void Tracker::computeGradientImage(cv::Mat input_image,cv::Mat &gradient_image)
{
    // Blur the input image a little and apply discrete 3x3 sobel filter in x,y directions to obtain a gradient estimate
    // Todo: change to class member
    cv::Mat blurred_image;
    cv::GaussianBlur( input_image, blurred_image, cv::Size(3,3), 0, 0, cv::BORDER_DEFAULT );
    // Todo: change to class member
    cv::Mat grad_x,grad_y;
    cv::Sobel( blurred_image, grad_x, CV_16S, 1, 0, 3, 1.0, 0, cv::BORDER_DEFAULT );
    cv::Sobel( blurred_image, grad_y, CV_16S, 0, 1, 3, 1.0, 0, cv::BORDER_DEFAULT );
    cv::convertScaleAbs( grad_x, grad_x );
    cv::convertScaleAbs( grad_y, grad_y );
    cv::addWeighted( grad_x, 0.5, grad_y, 0.5, 0, gradient_image );
}

void Tracker::photometricallyCorrectImage(cv::Mat &corrected_frame)
{
    for(int r = 0;r < corrected_frame.rows;r++)
    {
        for(int c = 0;c < corrected_frame.cols;c++)
        {
            int o_value = corrected_frame.at<uchar>(r,c);
            double radiance = m_database->m_response_estimate.removeResponse(o_value);
            double vig = m_database->m_vignette_estimate.getVignetteFactor(cv::Point2f(c,r));
            radiance /= vig;
            if(radiance > 255)radiance = 255;
            if(radiance < 0)radiance = 0;
            corrected_frame.at<uchar>(r,c) = (uchar)radiance;
        }
    }
    
    /*
     * For debugging: visualize the corrected frame
     *
     * cv::imshow("radiance image", corrected_frame);
     * cv::waitKey(0);
     *
     */
}



================================================
FILE: src/Tracker.h
================================================
//
//  Tracker.h
//  OnlinePhotometricCalibration
//
//  Created by Paul on 16.11.17.
//  Copyright (c) 2017-2018 Paul Bergmann and co-authors. All rights reserved.
//
//  See LICENSE.txt
//

#ifndef OnlinePhotometricCalibration_Tracker_h_
#define OnlinePhotometricCalibration_Tracker_h_

#include "StandardIncludes.h"

#include "Database.h"

#include "GainRobustTracker.h"

#include "Frame.h"

#include "Feature.h"

/**
 *
 * Keeps original input images, corrects them based on the current V,f estimates
 *
 * Extracts features from input images and tracks them between consecutive frames 
 *
 * Implements forward backward tracking in order to filter out spurious tracks
 *
 * Uses gain robust KLT tracking to track robustly when large illumination changes between 2 frames occur
 *
 */

class Tracker
{
    
    /**
     * Forward backward tracking error threshold (if error is larger than this the track is set invalid)
     */
    const int C_FWD_BWD_TRACKING_THRESH = 2.0;
    
    /**
     * Patch size used for KLT offset optimization
     */
    const int C_KLT_PATCH_SIZE = 2;
    
    /**
     * Number of pyramid levels used
     */
    const int C_NR_PYRAMID_LEVELS = 3;
    
public:
    
    /**
     * Constructor
     * @param patch_size Size of the tracked image patches
     * @param nr_active_features Number of active features aimed to be kept for tracking
     * @param nr_pyramid_levels Number of pyramid levels to be used for KLT tracking
     * @param database Handle to the information database
     */
    Tracker(int patch_size,int nr_active_features,int nr_pyramid_levels,Database* database);
    
    /**
     * Track features from old frame to the new input frame
     * Extract new features if necessary
     * Filter out spurious tracks
     */
     // Todo: change param to reference
    void trackNewFrame(cv::Mat frame,double gt_exp_time);
    
private:
    
    /**
     * Patchsize extracted around the tracked points 
     * (not the one used for KLT tracking optimization)
     */
    int m_patch_size;
    
    /**
     * Number of active features aimed at when tracking
     */
    int m_max_nr_active_features;
    
    /**
     * Number of pyramid levels used for KLT tracking
     */
    int m_nr_pyramid_levels;
    
    /**
     * Pointer to the database to fetch and update information
     */
    Database* m_database;
    
    /**
     * Extract new features from the frame
     */
    // Todo: change param to reference
    std::vector<cv::Point2f> extractFeatures(cv::Mat frame,std::vector<cv::Point2f> old_features);
    
    /**
     * Bilinear interpolation, evaluate image at floating point location (x,y)
     */
    // Todo: change param to reference
    double bilinearInterpolateImage(cv::Mat image,double x,double y);
    
    /**
     * Evaluate entire image patch at floating point location (x,y)
     */
    // Todo: change param to reference
    std::vector<double> bilinearInterpolateImagePatch(cv::Mat image,double x,double y);
    
    /**
     * Check if points locations are not too close to the border of the image
     */
    std::vector<int> checkLocationValidity(std::vector<cv::Point2f> points);
    
    /**
     * Extract features for the first time
     */
    // Todo: change param to reference
    void initialFeatureExtraction(cv::Mat input_image,cv::Mat gradient_image,double gt_exp_time);
    
    /**
     * Compute gradient image
     */
    // Todo: change param to reference
    void computeGradientImage(cv::Mat input_image,cv::Mat &gradient_image);
    
    /**
     * Photometrically correct image based on vignette + response estimate
     */
    void photometricallyCorrectImage(cv::Mat &corrected_image);
};

#endif // include guard



================================================
FILE: src/VignetteModel.cpp
================================================
//
//  VignetteModel.cpp
//  OnlinePhotometricCalibration
//
//  Created by Paul on 16.11.17.
//  Copyright (c) 2017-2018 Paul Bergmann and co-authors. All rights reserved.
//
//  See LICENSE.txt
//

#include "VignetteModel.h"

VignetteModel::VignetteModel(double v1,double v2,double v3,int image_width,int image_height)
{
    // Initialize vignette parameters
    m_v1 = v1;
    m_v2 = v2;
    m_v3 = v3;
    
    // Image information is necessary to compute normalized radial information from pixel coordinates
    m_image_width = image_width;
    m_image_height= image_height;
    
    // Max. non normalized image radius (center of image = center of radial vignetting assumption)
    m_max_radius = sqrt((image_width/2)*(image_width/2) + (image_height/2)*(image_height/2));
}

double VignetteModel::getNormalizedRadius(cv::Point2f xy_location)
{
    double x = xy_location.x;
    double y = xy_location.y;
    
    double x_norm = x - m_image_width/2;
    double y_norm = y - m_image_height/2;
    
    double radius = sqrt(x_norm*x_norm + y_norm*y_norm);
    radius /= m_max_radius;
    
    return radius;
}

double VignetteModel::getVignetteFactor(cv::Point2f xy_location)
{
    double r = getNormalizedRadius(xy_location);
    double r2 = r * r;
    double r4 = r2 * r2;
    double v = 1 + m_v1 * r2 + m_v2 * r4 + m_v3 * r2 * r4;
    
    return v;
}

double VignetteModel::getVignetteFactor(double norm_radius)
{
    double r = norm_radius;
    double r2 = r * r;
    double r4 = r2 * r2;
    double v = 1 + m_v1 * r2 + m_v2 * r4 + m_v3 * r2 * r4;
    
    return v;
}

void VignetteModel::setVignetteParameters(std::vector<double> vignette_model)
{
    m_v1 = vignette_model.at(0);
    m_v2 = vignette_model.at(1);
    m_v3 = vignette_model.at(2);
}




================================================
FILE: src/VignetteModel.h
================================================
//
//  VignetteModel.h
//  OnlinePhotometricCalibration
//
//  Created by Paul on 16.11.17.
//  Copyright (c) 2017-2018 Paul Bergmann and co-authors. All rights reserved.
//
//  See LICENSE.txt
//

#ifndef OnlinePhotometricCalibration_VignetteModel_h_
#define OnlinePhotometricCalibration_VignetteModel_h_

#include "StandardIncludes.h"

#include <math.h>

/**
 * Stores vignetting model parameters and provides functionality to 
 * apply / remove vignetting
 */

class VignetteModel
{
    
public:
    
    /**
     * Initialize vignette model
     * @param v1,v2,v3 parameters of polynomial vignetting model v(r) = 1 + v1*r^2 + v2*r^4 + v3*r^6
     * @param image_width,image_height dimensions of the input images
     */
    VignetteModel(double v1,double v2,double v3,int image_width,int image_height);
    
    /**
     * Calculate a radius value between [0,1] for a given point location
     */
    double getNormalizedRadius(cv::Point2f xy_location);
    
    /**
     * Calculate vignette factor for a given point location based on the current vignette estimate
     */
    double getVignetteFactor(cv::Point2f xy_location);
    
    /**
     * Calculate vignette factor for a given normalize radius based on the current vignette estimate
     */
    double getVignetteFactor(double norm_radius);
    
    /**
     * Return current vignette estimate parameter vector
     */
    std::vector<double> getVignetteEstimate()
    {
        std::vector<double> result;
        result.push_back(m_v1);
        result.push_back(m_v2);
        result.push_back(m_v3);
        return result;
    }
    
    /**
     * Overwrite vignette estimate parameters
     */
    void setVignetteParameters(std::vector<double> vignette_model);
    
private:
    
    /**
     * Parameter values of the vignette model
     */
    double m_v1;
    double m_v2;
    double m_v3;
    
    /**
     * Input image dimensions
     */
    int m_image_width;
    int m_image_height;
    
    /**
     * Maximum pixel radius in image coordinates (used for normalization of radius to [0,1])
     */
    double m_max_radius;
};

#endif // include guard


================================================
FILE: src/main.cpp
================================================
//
//  main.cpp
//  OnlinePhotometricCalibration
//
//  Created by Paul on 16.11.17.
//  Copyright (c) 2017-2018 Paul Bergmann and co-authors. All rights reserved.
//
//  See LICENSE.txt
//

#include "StandardIncludes.h"

#include "ImageReader.h"
#include "Tracker.h"
#include "RapidExposureTimeEstimator.h"
#include "Database.h"
#include "NonlinearOptimizer.h"
#include "CLI11.hpp"

using namespace std;

// Optimization thread handle
pthread_t opt_thread = 0;

// This variable indicates if currently an optimization task is running in a second thread
pthread_mutex_t g_is_optimizing_mutex;
bool g_is_optimizing = false;

struct Settings{
    int start_image_index;      // Start image index.
    int end_image_index;        // End image index.
    int image_width;            // Image width to resize to.
    int image_height;           // Image height to resize to.
    int visualize_cnt;          // Visualize every visualize_cnt image (tracking + correction), rather slow.
    int tracker_patch_size;     // Image patch size used in tracker.
    int nr_pyramid_levels;      // Number of image pyramid levels used in tracker.
    int nr_active_features;     // Number of features maintained for each frame.
    int nr_images_rapid_exp;    // Number of images for rapid exposure time estimation.
    int nr_active_frames;       // Number of frames maintained in database.
    int keyframe_spacing;       // Spacing for sampling keyframes in backend optimization.
    int min_keyframes_valid;    // Minimum amount of keyframes a feature should be present to be included in optimization.
    string image_folder;        // Image folder.
    string exposure_gt_file;    // Exposure times ground truth file.
    string calibration_mode;    // Choose "online" or "batch".
};

void run_batch_optimization_task(NonlinearOptimizer *optimizer)
{
    std::cout << "START BATCH OPTIMIZATION" << std::endl;
    
    optimizer->fetchResponseVignetteFromDatabase();

    // Perform optimization (since its offline just do )
    optimizer->evfOptimization(false);
    std::cout << "EVF 1 DONE" << std::endl;
    optimizer->radianceFullOptimization();
    std::cout << "RAD 1 DONE" << std::endl;
    optimizer->evfOptimization(false);
    std::cout << "EVF 2 DONE" << std::endl;
    optimizer->radianceFullOptimization();
    std::cout << "RAD 2 DONE" << std::endl;
    optimizer->evfOptimization(false);
    std::cout << "EVF 3 DONE" << std::endl;
    
    // Smooth optimization data
    optimizer->smoothResponse();
    
    // Initialize the inverse response vector with the current inverse response estimate
    // (in order to write it to the database later + visualization)
    // better to do this here since currently the inversion is done rather inefficiently and not to slow down tracking
    optimizer->getInverseResponseRaw(optimizer->m_raw_inverse_response);
    std::cout << "END OPTIMIZATION" << std::endl;
}

void *run_optimization_task(void* thread_arg)
{
    std::cout << "START OPTIMIZATION" << std::endl;
    
    pthread_mutex_lock(&g_is_optimizing_mutex);
    g_is_optimizing = true;
    pthread_mutex_unlock(&g_is_optimizing_mutex);
    
    // The nonlinear optimizer contains all the optimization information
    NonlinearOptimizer* optimizer = (NonlinearOptimizer*)thread_arg;
    
    optimizer->fetchResponseVignetteFromDatabase();

    // Perform optimization
    optimizer->evfOptimization(false);
    optimizer->evfOptimization(false);
    optimizer->evfOptimization(false);
    
    // Smooth optimization data
    optimizer->smoothResponse();
    
    // Initialize the inverse response vector with the current inverse response estimate
    // (in order to write it to the database later + visualization)
    // better to do this here since currently the inversion is done rather inefficiently and not to slow down tracking
    optimizer->getInverseResponseRaw(optimizer->m_raw_inverse_response);
    
    pthread_mutex_lock(&g_is_optimizing_mutex);
    g_is_optimizing = false;
    pthread_mutex_unlock(&g_is_optimizing_mutex);
    std::cout << "END OPTIMIZATION" << std::endl;
    
    pthread_exit(NULL);
}

// Split a string into substrings given a char delimiter
std::vector<string> split(const string &s, char delim) {
    stringstream ss(s);
    string item;
    vector<string> tokens;
    while (getline(ss, item, delim)) {
        tokens.push_back(item);
    }
    return tokens;
}

int run_batch_calibration(Settings *run_settings,std::vector<double> gt_exp_times)
{
    int safe_zone_size = 0;

    double vis_exponent = 1.0;

    //  Set up the object to read new images from
    ImageReader image_reader(run_settings->image_folder, cv::Size(run_settings->image_width, run_settings->image_height));

    // Set up the information database
    Database database(run_settings->image_width,run_settings->image_height);

    // Setup the rapid  exposure time estimator
    RapidExposureTimeEstimator exposure_estimator(run_settings->nr_images_rapid_exp, &database);

    // Setup the nonlinear optimizer
    NonlinearOptimizer backend_optimizer(run_settings->keyframe_spacing,
                                         &database,
                                         safe_zone_size,
                                         run_settings->min_keyframes_valid,
                                         run_settings->tracker_patch_size);

    // Set up the object that handles the tracking and receives new images, extracts features
    Tracker tracker(run_settings->tracker_patch_size,run_settings->nr_active_features,run_settings->nr_pyramid_levels,&database);
    
    int num_images = image_reader.getNumImages();
    
    // Run over all input images, track the new image, estimate exposure time and optimize other parameters in the background
    for(int i = run_settings->start_image_index; i < num_images && (run_settings->end_image_index < 0 || i < run_settings->end_image_index); i++)
    {
        std::cout << "image: " << i << std::endl;

        // Read GT exposure time if available for this frame
        // Todo: Check if index is out of bounds, if gt exp file has not enough lines
        double gt_exp_time = -1.0;
        if(gt_exp_times.size() > 0)
        {
            gt_exp_time = gt_exp_times.at(i);
        }
        
        // Read next input image
        cv::Mat new_image = image_reader.readImage(i);
        
        // Track input image (+ time the result)
        tracker.trackNewFrame(new_image,gt_exp_time);

        // Rapid exposure time estimation (+ time the result)
        double exposure_time = exposure_estimator.estimateExposureTime();
        database.m_tracked_frames.at(database.m_tracked_frames.size()-1).m_exp_time = exposure_time;
        database.visualizeRapidExposureTimeEstimates(vis_exponent);

        // Remove the exposure time from the radiance estimates
        std::vector<Feature*>* features = &database.m_tracked_frames.at(database.m_tracked_frames.size()-1).m_features;
        for(int k = 0;k < features->size();k++)
        {
            for(int r = 0;r < features->at(k)->m_radiance_estimates.size();r++)
            {
                features->at(k)->m_radiance_estimates.at(r) /= exposure_time;
            }
        }
  
        // Visualize tracking
        if(i%run_settings->visualize_cnt == 0)
            database.visualizeTracking();

        //check if number of frames in database are enough to start the optimization
        if(database.m_tracked_frames.size() != run_settings->nr_active_frames)
        {
            continue;
        }
        
        // Required number of frames has been reached, calibrate all of them
        
        // Try to fetch a new optimization block
        bool succeeded = backend_optimizer.extractOptimizationBlock();
        
        if(succeeded)
        {
            // Optimize all frames
            run_batch_optimization_task(&backend_optimizer);

            // Show optimization result
            vis_exponent = backend_optimizer.visualizeOptimizationResult(backend_optimizer.m_raw_inverse_response);

            // Remove frames except for some overlap in order to align exposures later
            for(int k = 0;k < run_settings->nr_active_frames-30;k++)
            {
                database.removeLastFrame();
            }
        }
        else
        {
            //Something went wrong..
            std::cout << "Error: Optimization block could not be fetched." << std::endl;
            return -1;
        }
    }
    
    return 0;
}

int run_online_calibration(Settings *run_settings,std::vector<double> gt_exp_times)
{
    double vis_exponent = 1.0;

    int safe_zone_size = run_settings->nr_images_rapid_exp + 5;

    //  Set up the object to read new images from
    ImageReader image_reader(run_settings->image_folder, cv::Size(run_settings->image_width, run_settings->image_height));

    // Set up the information database
    Database database(run_settings->image_width,run_settings->image_height);

    // Setup the rapid  exposure time estimator
    RapidExposureTimeEstimator exposure_estimator(run_settings->nr_images_rapid_exp, &database);

    // Setup the nonlinear optimizer
    NonlinearOptimizer backend_optimizer(run_settings->keyframe_spacing,
                                         &database,
                                         safe_zone_size,
                                         run_settings->min_keyframes_valid,
                                         run_settings->tracker_patch_size);

    // Set up the object that handles the tracking and receives new images, extracts features
    Tracker tracker(run_settings->tracker_patch_size,run_settings->nr_active_features,run_settings->nr_pyramid_levels,&database);
    
    int optimize_cnt = 0;
    int num_images = image_reader.getNumImages();
    
    // Run over all input images, track the new image, estimate exposure time and optimize other parameters in the background
    for(int i = run_settings->start_image_index; i < num_images && (run_settings->end_image_index < 0 || i < run_settings->end_image_index); i++)
    {
        std::cout << "image: " << i << std::endl;

        // Read GT exposure time if available for this frame
        // Todo: Check if index is out of bounds, if gt exp file has not enough lines
        double gt_exp_time = -1.0;
        if(gt_exp_times.size() > 0)
        {
            gt_exp_time = gt_exp_times.at(i);
        }
        
        // If enough images are in the database, remove once all initial images for which no exposure time could be optimized
        // Since those frames will not be that good for backend optimization
        if(i == run_settings->nr_images_rapid_exp*2 + safe_zone_size)
        {
            for(int ii = 0;ii < run_settings->nr_images_rapid_exp;ii++)
            {
                database.removeLastFrame();
            }
        }
        
        // If the database is large enough, start removing old frames
        if(i > run_settings->nr_active_frames)
            database.removeLastFrame();
        
        // Read next input image
        cv::Mat new_image = image_reader.readImage(i);
        
        // Track input image (+ time the result)
        tracker.trackNewFrame(new_image,gt_exp_time);
      
        // Rapid exposure time estimation (+ time the result)
        double exposure_time = exposure_estimator.estimateExposureTime();
        database.m_tracked_frames.at(database.m_tracked_frames.size()-1).m_exp_time = exposure_time;
        database.visualizeRapidExposureTimeEstimates(vis_exponent);

        // Remove the exposure time from the radiance estimates
        std::vector<Feature*>* features = &database.m_tracked_frames.at(database.m_tracked_frames.size()-1).m_features;
        for(int k = 0;k < features->size();k++)
        {
            for(int r = 0;r < features->at(k)->m_radiance_estimates.size();r++)
            {
                features->at(k)->m_radiance_estimates.at(r) /= exposure_time;
            }
        }
  
        // Visualize tracking
        if(i%run_settings->visualize_cnt == 0)
            database.visualizeTracking();
        
        pthread_mutex_lock(&g_is_optimizing_mutex);
        bool is_optimizing = g_is_optimizing;
        pthread_mutex_unlock(&g_is_optimizing_mutex);
        
        // Optimization is still running, don't do anything and keep tracking
        if(is_optimizing)
        {
            continue;
        }
        
        //optimization is currently not running
        // (1) Fetch the current optimization result and update database
        // (2) Try to extract a new optimization block and restart optimization in the background
        
        // Fetch the old optimization result from the optimizer, if available
        if(optimize_cnt > 0)
        {
            // Write the result to the database, visualize the result
            database.m_vignette_estimate.setVignetteParameters(backend_optimizer.m_vignette_estimate);
            database.m_response_estimate.setGrossbergParameterVector(backend_optimizer.m_response_estimate);
            database.m_response_estimate.setInverseResponseVector(backend_optimizer.m_raw_inverse_response);
            
            vis_exponent = backend_optimizer.visualizeOptimizationResult(backend_optimizer.m_raw_inverse_response);
        }
        
        // Try to fetch a new optimization block
        bool succeeded = backend_optimizer.extractOptimizationBlock();
        
        if(succeeded)
        {
            // TODO: reuse thread
            //start a new optimization task here
            pthread_create(&opt_thread, NULL, run_optimization_task, (void*)&backend_optimizer);
            optimize_cnt++;
        }
    }

    pthread_join(opt_thread,NULL);

    if(optimize_cnt > 0)
    {
        // Write the result to the database, visualize the result
        database.m_vignette_estimate.setVignetteParameters(backend_optimizer.m_vignette_estimate);
        database.m_response_estimate.setGrossbergParameterVector(backend_optimizer.m_response_estimate);
        database.m_response_estimate.setInverseResponseVector(backend_optimizer.m_raw_inverse_response);

        vis_exponent = backend_optimizer.visualizeOptimizationResult(backend_optimizer.m_raw_inverse_response);
    }
    
    return 0;
}

int main(int argc, char** argv)
{
    CLI::App app("Photometric Calibration");

    Settings run_settings;
    run_settings.start_image_index   = 0;      
    run_settings.end_image_index     = -1;
    run_settings.image_width         = 640;    
    run_settings.image_height        = 480;   
    run_settings.visualize_cnt       = 1;       
    run_settings.tracker_patch_size  = 3;       
    run_settings.nr_pyramid_levels   = 2;       
    run_settings.nr_active_features  = 200;     
    run_settings.nr_images_rapid_exp = 15;     
    run_settings.image_folder = "images";
    run_settings.exposure_gt_file = "times.txt";
    run_settings.calibration_mode = "online";
    run_settings.nr_active_frames    = 200;    
    run_settings.keyframe_spacing    = 15; 
    run_settings.min_keyframes_valid = 3;

    app.add_option("-i,--image-folder", run_settings.image_folder, "Folder with image files to read.", true);
    app.add_option("--start-image-index", run_settings.start_image_index, "Start reading from this image index.", true);
    app.add_option("--end-image-index", run_settings.end_image_index, "Stop reading at this image index.", true);
    app.add_option("--image-width", run_settings.image_width, "Resize image to this width.", true);
    app.add_option("--image-height", run_settings.image_height, "Resize image to this height.", true);
    app.add_option("--exposure-gt-file", run_settings.exposure_gt_file, "Textfile containing ground truth exposure times for each frame for visualization.", true);
    app.add_option("--calibration-mode", run_settings.calibration_mode, "Choose 'online' or 'batch'", true);
    
    app.add_option("--nr-active-frames", run_settings.nr_active_frames, "Maximum number of frames to be stored in the database.", true);
    app.add_option("--keyframe-spacing", run_settings.keyframe_spacing, "Number of frames that keyframes are apart in the backend optimizer.", true);
    app.add_option("--min-keyframes-valid", run_settings.min_keyframes_valid, "Minimum number of frames a feature has to be tracked to be considered for optimization.", true);

    CLI11_PARSE(app, argc, argv);

    printf("Loading images from '%s'\n", run_settings.image_folder.c_str());
    printf("Start at index %d\n", run_settings.start_image_index);
    printf("End at index %d\n", run_settings.end_image_index);
    printf("Image width %d\n", run_settings.image_width);
    printf("Image height %d\n", run_settings.image_height);

    // Parse gt exposure times from file if available
    // Only use the last number in each line, delimiter is the space character ' '
    std::ifstream exposure_gt_file_handle(run_settings.exposure_gt_file);
    std::vector<double> gt_exp_times;
    string line;
    double min_time = 10000.0;
    double max_time = -10000.0;
    if (exposure_gt_file_handle.is_open())
    {
        while(getline(exposure_gt_file_handle,line))
        {
            std::string delimiter = " ";
            std::vector<string> split_line = split(line,' ');
            double gt_exp_time = stod(split_line.at(split_line.size()-1));
            gt_exp_times.push_back(gt_exp_time);
            if(gt_exp_time < min_time)
                min_time = gt_exp_time;
            if(gt_exp_time > max_time)
                max_time = gt_exp_time;
        }    
        std::cout << "Ground truth exposure time file successfully read (" << run_settings.exposure_gt_file << ")." << std::endl;
    }
    else
    {
        std::cout << "Ground truth exposure time file not found (" << run_settings.exposure_gt_file << ")." << std::endl;
    }
    exposure_gt_file_handle.close();

    for(int k = 0;k < gt_exp_times.size();k++)
    {    
        //normalize gt exposures to range [0,1]
        gt_exp_times.at(k) = (gt_exp_times.at(k) - min_time)/(max_time - min_time);
    }

    // Run program either in multithreaded online mode 
    // or in linearized batch mode
    if(run_settings.calibration_mode == "online")
    {
        std::cout << "Run online calibration mode." << std::endl;
        run_online_calibration(&run_settings, gt_exp_times);
    }
    else if(run_settings.calibration_mode == "batch")
    {
        std::cout << "Run batch calibration mode." << std::endl;
        run_batch_calibration(&run_settings, gt_exp_times);
    }
    else
    {
        std::cout << "Error: Unknown calibration mode '" << run_settings.calibration_mode << "'." << std::endl;
        return -1;
    }

    // wait for key-press, then exit
    std::cout << "Finished. Press key to exit." << std::endl;
    cv::waitKey(0);

    return 0;
}