Merge branch 'clemens-fixes' of dbv.inf-cv.uni-jena.de:nice/nice-core into erik-cleaning-fixes

Conflicts:
	core/image/BlockImageAccessT.tcc

CMakeLists.txt

@@ -1,5 +1,5 @@
 #cmake_minimum_required(VERSION 2.8.6) #version 2.8.6 at least required because of command set(CMAKE_AUTOMOC TRUE) for qt moc-ing (see below)
-cmake_minimum_required(VERSION 2.8.12) #version 2.8.12 at least required because of command  get_filename_component(__testname_dir ${__testname_abspath} DIRECTORY) (getting directory path of filename)
+cmake_minimum_required(VERSION 2.8.6)
 project (NICELibrary)
 
 include(CheckSymbolExists)
@@ -29,8 +29,6 @@ endif()
 
 set(CMAKE_INSTALL_PREFIX ${PROJECT_BINARY_DIR})
 
-set(NICE_BUILD_LIBS_STATIC_SHARED STATIC)
-
 set(NICE_SOURCEFILES_FIND_GLOBALLYRECURSIVE ON CACHE STRING "Scan a sublibraries directory for source files instead of using an explicit src file list")
 
 NICE_OPTION(WITH_BOOST "Build with Boost support" OFF)
@@ -132,7 +130,7 @@ endif()
 
 NICE_OPTION(WITH_QT "Build with Qt" ON)
 if(WITH_QT)
-  FIND_PACKAGE(Qt4)# COMPONENTS Qt3Support QtOpenGl)
+  FIND_PACKAGE(Qt4 REQUIRED)# COMPONENTS Qt3Support QtOpenGl)
   SET(QT_USE_QTOPENGL TRUE)
   SET(QT_USE_QTXML TRUE)
   SET(QT_USE_QT3SUPPORT TRUE)

NOTES

@@ -0,0 +1,38 @@
+## Wichtigere Sachen
+*Für die generischen Klassen müssen wir uns etwas überlegen*. Die Implementationen müssen mit in die Header, aber wir können die Lib so "von außen" nicht benutzen, weil wir beim Kompilieren der Templates definitiv unser Buildsystem brauchen (die ganzen Makros, Libs...). Das macht eine Distribution von Binaries quasi unmöglich.
+
+```
+$ grep --include={*.h,*.tcc} -rnw ./ -e ".*def.*USELIB.*" | wc -l
+185
+
+```
+
+Daher mein Vorschlag:
+
+1. Wir schränken für jede betroffene Klasse die möglichen Instanzen ein und kompilieren alle davon explizit mit. Ein Beispiel habe ich in den Ordner "ignore" gepackt.
+Vorteile:
+	* Benutzer braucht nur noch die Header einzubinden und mit nice_core zu linken -> er muss nice_core nicht kompilieren, sondern kann einfach Binaries und Header installieren.
+	* Je nach Lizenzen können wir einige Libraries statisch reinlinken, dabei fallen die nicht benutzten Funktionen raus und die Benutzer muss nicht einmal die sos der Abhängigkeiten installieren.
+	* Wenn wir in der Implementierung eine weitere Abhängigkeit einbauen, machen wir dem Benutzer seinen Buildprozess nicht kaputt.
+Nachteile:
+	* Für Containertypen eher unbrauchbar.
+	* Speicher?
+
+## Buildsystem
+-- WITH_QT OFF verhindert nicht das Kompilieren von libimagedisplay, die hängt aber von Qt ab.
+?? NICE_USELIB_QT verwenden, um in ImageDisplay.h die QT-Header auszuschließen
+
+-- Das Verzeichnis von GLUT ist für Windows hardcoded, sollte eigentlich Umgebungsvariable nutzen. 
+?? Rausnehmen
+
+-- WITH... sind Voreinstellungen in CMakeLists
+?? In Abhängigkeit der gefundenen Libs setzen
+
+-- Die Abhängigkeiten werden in nice-core/CMakeLists.txt gesucht, aber in nice-core/core/CMakeLists.txt werden unabhängig davon die Ergebnisse der find_package()-Aufrufe benutzt.
+?? Wenn nice-core ohnehin nur aus "core" besteht, reicht vielleicht auch nur eine CMakeLists.txt. Dann können wir target_link_libraries aufrufen, nachdem wir eine Abhängigkeit gefunden haben. Alternativ: Wenn jedes Projekt seine eigenen Abhängigkeiten hat, dann kann auch jedes Projekt selbst danach suchen.
+
+## Aufräumen
+-- "Filter.h is obsolete" - hängt noch sehr viel davon ab?
+
+## Bugs
+-- Konstruktor von ImageT ruft string::substr mit falschen Parametern auf, wenn der Punkt im Dateinamen fehlt.

cmake/NiceModules.cmake

@@ -121,12 +121,17 @@ macro(nice_get_source_files)
 endmacro()
 
 macro(nice_build_library)
-  ADD_LIBRARY("nice_${the_library}" ${NICE_BUILD_LIBS_STATIC_SHARED} ${nice_${the_library}_HDR} ${nice_${the_library}_SRC})
+  ADD_LIBRARY("nice_${the_library}" ${nice_${the_library}_HDR} ${nice_${the_library}_SRC})
   TARGET_LINK_LIBRARIES("nice_${the_library}" ${nice_${the_library}_LINKING_DEPENDENCIES})
   #TARGET_LINK_LIBRARIES("nice_${the_library}" ${nice_${the_library}_LINKING_DEPENDENCIES} ${Boost_LIBRARIES} ${OPENGL_LIBRARY} ${GLUT_LIBRARY} ${QT_LIBRARIES})
   SET_PROPERTY(TARGET "nice_${the_library}" PROPERTY FOLDER "library")
   INSTALL(TARGETS "nice_${the_library}" DESTINATION lib)
 
+  install(DIRECTORY ./ DESTINATION "include/${the_library}"
+          FILES_MATCHING 
+          PATTERN "*.h"
+          PATTERN "*.tcc")
+
   configure_file( ../cmake/niceConfig.cmake.in "${PROJECT_BINARY_DIR}/lib/nice_${the_library}Config.cmake" )
 endmacro()
 
@@ -187,7 +192,7 @@ macro(nice_add_unittests)
     foreach(__testcpp ${nice_${the_library}_TESTFILES_SRC})
       get_filename_component(__testname ${__testcpp} NAME_WE )
       nice_get_real_path(__testname_abspath ${__testcpp})
-      get_filename_component(__testname_dir ${__testname_abspath} DIRECTORY)
+      get_filename_component(__testname_dir ${__testname_abspath} PATH)
 
       message(STATUS "unittest: ${__testname} ${__testcpp}")
       

core/CMakeLists.txt

@@ -64,4 +64,4 @@ nice_add_unittests()
 #         install(FILES ${hdr} DESTINATION "${OPENCV_INCLUDE_INSTALL_PATH}/${CMAKE_MATCH_1}" COMPONENT main)
 #       endif()
 #     endforeach()
-#   endif()
+#   endif()

core/NOTES

@@ -0,0 +1,28 @@
+## Wichtigere Sachen
+*Für die generischen Klassen müssen wir uns etwas überlegen*. Die Implementationen müssen mit in die Header, aber wir können die Lib so "von außen" nicht benutzen, weil wir beim Kompilieren der Templates die NICE_USELIB.. aus unserem Buildsystem brauchen und damit auch noch beim Benutzer Abhängigkeiten erzeugen, die vermeidbar wären.
+
+```
+$ grep --include={*.h,*.tcc} -rnw ./ -e ".*def.*USELIB.*" | wc -l
+185
+
+```
+In den meisten Fällen können wir wohl die Template-Funktion explizit instantiieren und in den Header nur noch "extern template..." angeben.
+
+## Buildsystem
+-- WITH_QT OFF verhindert nicht das Kompilieren von libimagedisplay, die hängt aber von Qt ab.
+?? NICE_USELIB_QT verwenden, um in ImageDisplay.h die QT-Header auszuschließen
+
+-- Das Verzeichnis von GLUT ist für Windows hardcoded, sollte eigentlich Umgebungsvariable nutzen. 
+?? Rausnehmen
+
+-- WITH... sind Voreinstellungen in CMakeLists
+?? In Abhängigkeit der gefundenen Libs setzen
+
+-- Die Abhängigkeiten werden in nice-core/CMakeLists.txt gesucht, aber in nice-core/core/CMakeLists.txt werden unabhängig davon die Ergebnisse der find_package()-Aufrufe benutzt.
+?? Wenn nice-core ohnehin nur aus "core" besteht, reicht vielleicht auch nur eine CMakeLists.txt. Dann können wir target_link_libraries aufrufen, nachdem wir eine Abhängigkeit gefunden haben. Alternativ: Wenn jedes Projekt seine eigenen Abhängigkeiten hat, dann kann auch jedes Projekt selbst danach suchen.
+
+## Aufräumen
+-- "Filter.h is obsolete" - hängt noch sehr viel davon ab?
+
+## Bugs
+-- Konstruktor von ImageT ruft string::substr mit falschen Parametern auf, wenn der Punkt im Dateinamen fehlt.

core/basics/progs/testConfig.cpp

@@ -16,8 +16,13 @@ using namespace std;
 */
 int main (int argc, char **argv)
 {   
+
 #ifndef WIN32
+#ifndef __clang__
+#ifndef __llvm__ 
     std::set_terminate(__gnu_cxx::__verbose_terminate_handler);
+#endif
+#endif
 #endif
 
     Config conf ( argc, argv );

core/ignore/OpaqueT.cpp

@@ -0,0 +1,15 @@
+/*
+   Example files for explicit opaque templates
+*/
+
+#include <iostream>
+#include <string>
+
+#include "OpaqueT.h"
+#include "OpaqueT.tcc"
+
+namespace NICE {
+		// Explicit instances
+		template class OpaqueT<std::string>;
+		template class OpaqueT<int>;
+}

core/ignore/OpaqueT.h

@@ -0,0 +1,15 @@
+/*
+   Example files for explicit opaque templates
+*/
+
+#ifndef IGNORE_OPAQUET_H_
+#define IGNORE_OPAQUET_H_
+
+namespace NICE {
+	template <class T> class OpaqueT {
+		public:
+			void CallMe(T arg);
+	};
+}
+
+#endif

core/ignore/OpaqueT.tcc

@@ -0,0 +1,12 @@
+/*
+   Example files for explicit opaque templates
+*/
+
+#include "OpaqueT.h"
+
+namespace NICE {
+	// Implementations
+	template<class T>void OpaqueT<T>::CallMe(T arg) {
+		std::cout << arg;
+	}
+}

core/image/FilterT.h

@@ -68,6 +68,14 @@ class FilterT
     */
     static void filterY ( const ImageT<SrcType>& src, const VectorT<CalcType>& kernel, ImageT<DstType> &result, const int& anchor = -1 );
 
+    /**
+    * Filters (=convolves) Image \c src into the
+    * Image \c dst using filter (=convolution) kernel \c kernel.
+    * @copydoc filter()
+    */
+    static void filter ( const ImageT<SrcType>& src, const MatrixT<CalcType>& kernel, ImageT<DstType>& result,
+            const int& anchorx = -1, const int& anchory = -1 );
+
     /**
     * Compute horizontal part of the gradient of a Image \c src via Sobel into Image \c dst.
     * The resulting image \c dst is of the same size as \c src.

core/image/FilterT.tcc

@@ -72,6 +72,46 @@ void FilterT<SrcType, CalcType, DstType>::filterY ( const ImageT<SrcType>& src,
   }
 }
 
+template<class SrcType, class CalcType, class DstType>
+void FilterT<SrcType, CalcType, DstType>::filter(const ImageT<SrcType>& src,
+		const MatrixT<CalcType>& kernel, ImageT<DstType>& result,
+		const int& anchorx, const int& anchory) {
+
+	if (result.width() != src.width() || result.height() != src.height()) {
+		result.resize(src.width(), src.height());
+	}
+
+	IppiPoint anchor;
+	anchor.x = (anchorx < 0) ? (kernel.cols() / 2) : anchorx;
+	anchor.y = (anchory < 0) ? (kernel.rows() / 2) : anchory;
+
+	unsigned int kernel_rows = kernel.rows() - 1;
+	unsigned int kernel_cols = kernel.cols() - 1;
+
+	int runs = 0;
+
+	for (unsigned int y = anchor.y; y < src.height() - (kernel_rows - anchor.y);
+			y++) {
+		for (unsigned int x = anchor.x; x < src.width() - (kernel_cols - anchor.x);
+				x++) {
+			CalcType sum = 0;
+
+			for (int j = -anchor.y; j <= ((int)kernel_rows - anchor.y); j++) {
+				for (int i = -anchor.x; i <= ((int)kernel_cols - anchor.x); i++) {
+					sum += static_cast<CalcType>(src(x + i, y + j))
+							* kernel(kernel_cols - (anchor.x + i),
+									kernel_rows - (anchor.y + j));
+				}
+			}
+
+			result(x, y) = static_cast<DstType>(sum);
+
+		}
+	}
+
+	return;
+}
+
 template<class SrcType, class CalcType, class DstType>
 void FilterT<SrcType, CalcType, DstType>::sobelX ( const NICE::ImageT<SrcType> &src, NICE::ImageT<DstType> &dst)
 {

core/image/GHough.cpp

@@ -52,7 +52,7 @@ GHough& GHough::operator=(const GHough& ex)
 void GHough::initialize(IppiSize imageSize,IppiSize transformSize, NeighborType addMode)
 {
     this->imageSize = imageSize;
-    transformSize = transformSize;
+    this->transformSize = transformSize;
     this->addMode = addMode;
     
     //! Allocates memory for data

core/image/GrayColorImageCommonImplementationT.h

@@ -178,10 +178,7 @@ public:
    * @note   If you want to explicitly select a file format,
    *         use read(ImageFile, const GrayColorImageCommonImplementation::MemoryLayout)
    */
-  inline void read(const std::string &filename /*,
-                   const GrayColorImageCommonImplementation::MemoryLayout _memoryLayout = ippAlignment*/) {
-    read(ImageFile(filename)/*, _memoryLayout*/);
-  }
+  void read(const std::string &filename); 
 
   /**
   * Write this image to a file. See also documentation of \c ImageFile.
@@ -196,9 +193,7 @@ public:
    * @note If you want to explicitly select a file format,
    *       use write(ImageFile)
    */
-  inline void write(const std::string &filename) const {
-    write(ImageFile(filename));
-  }
+  inline void write(const std::string &filename) const; 
 
   /**
   * Read this image from a PPM or PGM file.

core/image/GrayColorImageCommonImplementationT.tcc

@@ -195,4 +195,14 @@ void GrayColorImageCommonImplementationT<P>::writePXM(const char* pxmFileName) c
   }
 }
 
+template <class P>
+void GrayColorImageCommonImplementationT<P>::read(const std::string &filename) {
+    read(ImageFile(filename)/*, _memoryLayout*/);
+}
+
+template <class P>
+void GrayColorImageCommonImplementationT<P>::write(const std::string &filename) const {
+    write(ImageFile(filename));
+}
+
 } // namespace

core/image/ImageFile.cpp

@@ -240,6 +240,9 @@ ImageFile::Format ImageFile::name2Format(const std::string &filename)
 	#endif
 
 		int pos=filename.find_last_of('.');
+		if(pos==std::string::npos)
+			return ImageFile::FormatUnknown;
+
 		magic=filename.substr(pos);
 		if(magic==".pgm" || magic==".PGM")
 				return ImageFile::PGM_RAW;

core/image/tests/TestImageFile.cpp

@@ -295,6 +295,12 @@ void TestImageFile::testJPG_IO()
     }
 }
 
+void TestImageFile::testInvalidFileName() {
+	ImageFile image_file;
+	ImageFile::Format fileformat = image_file.name2Format("nodothere");
+	CPPUNIT_ASSERT_EQUAL(fileformat,ImageFile::FormatUnknown);
+}
+
 #endif
 
 

core/image/tests/TestImageFile.h

@@ -21,6 +21,7 @@ class TestImageFile : public CppUnit::TestFixture
 	CPPUNIT_TEST( testColorImage );
 	CPPUNIT_TEST( testGrayImage  );
 	CPPUNIT_TEST( testJPG_IO     );
+	CPPUNIT_TEST( testInvalidFileName );
 	CPPUNIT_TEST_SUITE_END();
 
    private:
@@ -51,6 +52,11 @@ class TestImageFile : public CppUnit::TestFixture
 	* Test JPEG Input and Output
 	*/
   	void testJPG_IO();
+
+  	/**
+  	* Test for correct detection of file names without appropriate endings
+  	*/
+  	void testInvalidFileName();
 };
 
 #endif // _TESTIMAGEFILE_IMAGE_H

core/imagedisplay/QtFramework.cpp

@@ -30,7 +30,11 @@ QtFramework::QtFramework()
 #endif
 
 #ifndef WIN32
-  std::set_terminate(__gnu_cxx::__verbose_terminate_handler);
+#ifndef __clang__
+#ifndef __llvm__ 
+    std::set_terminate(__gnu_cxx::__verbose_terminate_handler);
+#endif
+#endif
 #endif
 }
 
@@ -42,7 +46,11 @@ QtFramework::QtFramework(int& argc, char** argv)
 #endif
 
 #ifndef WIN32
-  std::set_terminate(__gnu_cxx::__verbose_terminate_handler);
+#ifndef __clang__
+#ifndef __llvm__ 
+    std::set_terminate(__gnu_cxx::__verbose_terminate_handler);
+#endif
+#endif
 #endif
 }
 

core/imagedisplay/progs/showImage.cpp

@@ -18,8 +18,13 @@ using namespace std;
 */
 int main ( int argc, char **argv )
 {
+
 #ifndef WIN32
-  std::set_terminate ( __gnu_cxx::__verbose_terminate_handler );
+#ifndef __clang__
+#ifndef __llvm__ 
+    std::set_terminate(__gnu_cxx::__verbose_terminate_handler);
+#endif
+#endif
 #endif
 
   for ( int i = 1 ; i < argc ; i++ )

core/matlabAccess/MatFileIO.h

@@ -25,7 +25,6 @@
 #else //#ifdef NICE_USELIB_MATIO
 
 #include <matio.h>
-#include <matio_private.h>
 
 #ifndef sparse_t
 #define sparse_t mat_sparse_t

core/tutorial/TODO

@@ -0,0 +1,31 @@
+# Tutorials TODO
+
+## General
+- Add "tutorial 0", a cheat sheet-like overview of NICE?
+
+## Tutorial 1 - Basic Image I/O Operations
+- Complete list of file formats vs. dependencies
+- Write down what parts of NICE support certain ImageT<> instances
+- Add recommendations on what pixel formats to use because of this
+
+## Tutorial 2 - Grayscale Image Operations
+- Add overview of different gray value transforms
+- Expand section about Image operator overloads
+- Add section on histogram specifications
+
+## Tutorial 3 - Color Image Operations
+- Section about differences and similarities between ImageT<> and ColorImageT<>
+- Section about conversion between color spaces
+
+## Tutorial 4 - Filters
+- Section about mean filters
+- Section about separable linear filters
+- Section about gaussian filters
+- Section about gradient images
+
+# Proposals for tutorials > 4
+- Drawing
+- Gauss pyramids? (Requires IPP)
+- Hough transform? (Lots of questions...)
+- Linear algebra examples?
+

core/tutorial/doc/00_install.md

@@ -0,0 +1,59 @@
+# Tutorial 00 - Building and installing NICE-core
+
+## Dependencies
+
+### Linux
+The following libraries and programs are required in order to build NICE-core.
+
+ - Command line developer tools 
+ - CMake 2.8.6 or later
+ - Qt 4.x
+ - OpenGL
+ - GLUT 2.x
+
+### Mac OS X
+Newer version of Mac OS X ship with clang as the default compiler.
+NICE depends on some libraries that are available from _homebrew_,
+so you need to install it from [brew.sh](http://brew.sh) first.
+
+You also need to install Qt 4.8.5 for Mac.
+If you have Mac OS X 10.9, you also have to remove lines 330-332 from
+_qtglobal.h_:
+
+```c++
+#  if (MAC_OS_X_VERSION_MAX_ALLOWED > MAC_OS_X_VERSION_10_8)
+#    warning "This version of Mac OS X is unsupported"
+#  endif
+```
+
+And finally FreeGLUT (using _homebrew_):
+
+```bash
+$ brew install freeglut
+```
+
+## Preparing the file system
+Make a new working directory and clone the repository from GitHub:
+
+```bash
+$ mkdir nice
+$ cd nice
+$ git clone https://github.com/cvjena/nice-core.git
+```
+
+NICE needs to be built out-of-tree (in a separate directory next
+to __nice-core__):
+
+```bash
+$ cd nice
+$ mkdir build
+$ cd build
+```
+
+## Building NICE-core
+Navigate to the __build__ directory and build NICE-core like this:
+
+```bash
+$ cmake ../nice-core
+$ make
+```

core/tutorial/doc/01_imageio.md

@@ -0,0 +1,141 @@
+# Tutorial 01 - Basic Image I/O Operations
+
+In this first tutorial you will learn how to read and write image files and how images are represented in NICE.
+
+## Prerequisites
+If you need support for a specific image file format other than PGM/PPM, you have to compile nice-core yourself and add the necessary libraries and CMake flags.
+
+The sample code for this tutorial does not have any dependencies other than nice-core. You can find it in the tutorial/progs subfolder.
+
+## Images in memory
+NICE provides a common generic interface for grayscale and multi-channel
+images.
+The corresponding classes are _ImageT_ and _ColorImageT_, both subclasses of
+_GrayColorImageCommonImplementationT_ which contains the most basic image
+access methods.
+Those are used by many of the other modules.
+You can find typical use cases in the next tutorials.
+
+Note that NICE does not have generic implementations of every function.
+We recommend using 8-bit images for most applications and also
+provide a shorthand typedef called _Image_.
+
+## Image files
+In NICE, instances of _ImageT_ or _ColorImageT_ do not have to exist on disk. Files are different, completely independent objects. The _ImageFile_ class serves as a pointer to a file in the file system.
+
+An instance of _ImageFile_ can be read from or written to, but it does not modify the file in any way unless you call those methods.
+
+Constructing an _ImageFile_ is simple:
+
+```c++
+ImageFile file("path/to/file.pgm");
+```
+
+This does not touch the file at all and it doesn't need to exist. If it does exist, you can read the image file into memory like this:
+
+```c++
+Image image_in_memory;
+file.reader(&image_in_memory);
+```
+
+After making our changes to the image (in memory), we can write them to the file:
+
+```c++
+file.writer(&image_in_memory);
+```
+
+## Header information
+Sometimes it can be useful to access metadata without reading the whole image into memory. _ImageFile_ provides the __getHeader__ method for this. It reads the file and returns an instance of _Header_ with the fields __width__, __height__, __bitdepth__, __channel__.
+
+## Formats
+Note that _ImageFile_ attemtps to determine the file format by looking at the file name. You can override this behaviour by providing the __type__ parameter using the _Format_ enumeration.
+
+Supported file formats include PGM/PPM out of the box and those provided by libpng, libjpeg and libimagemagick++.
+
+The sample images do not need any additional libraries.
+
+# Sample code
+There is a complete sample program for every tutorial in this series.
+These samples are built along with NICE and can be found in the
+__core__ output directory.
+
+The sample program for this tutorial reads a file from disk to memory,
+displays metadata from the file header and writes the image to another
+file.
+
+You can find PXM sample images to use with the sample code
+in the __tutorial__ folder.
+
+## Includes
+We start of the sample program by including the necessary header files.
+The first few tutorials explain the usage of classes in the __image__
+subdirectory.
+
+Header files are usually named after the classes they declare.
+We need the _ImageT_ and _ImageFile_ classes, so our sample code
+starts like this:
+
+```c++
+#include <iostream>
+#include <string>
+#include <core/image/ImageT.h>
+#include <core/image/ImageFile.h>
+```
+
+## File names
+We then get the file names from the command line.
+NICE will automatically determine the file type from its ending.
+This works for reads and writes, so you can use this sample program
+as a simple converter between image formats.
+
+This next part simply checks if the user specified both source and
+destination file.
+If there are enough arguments, they are stored in a _string_.
+ 
+```c++
+// Check if enough parameters were supplied
+if (argc < 3) {
+	std::cout << "USAGE: " << argv[0] << " <input image> <output image>\n";
+	return -1;
+}	
+
+// These are our file names
+std::string input_path(argv[1]);
+std::string output_path(argv[2]);
+```
+
+## Image metadata
+_ImageFile_ can read the header information without reading the whole image
+into memory.
+We use the __getHeader__ method to obtain a _Header_ instance.
+The fields are written to the standard output.
+
+```c++
+// Read file header and display header information
+NICE::ImageFile source_file(input_path);
+NICE::ImageFile::Header source_header = source_file.getHeader();
+
+std::cout << "Source image dimensions: " << source_header.width << " x " << source_header.height;
+std::cout << " (" << source_header.channel << " channels, " << source_header.bitdepth << " bpp)\n";
+```
+
+## Reading and writing the image
+To read the image, we create an empty instance of _ColorImage_ hand it over
+to the file's __reader__ method.
+
+Writing the image to disk is just as easy: contruct an _ImageFile_ with the
+destination path and call the __writer__ method.
+
+```c++
+// Read image into memory
+NICE::ColorImage source_image;
+source_file.reader(&source_image);
+
+// Write image to disk
+NICE::ImageFile dest_image(output_path);
+dest_image.writer(&source_image);
+return 0;
+```
+
+Remember that _ImageFile_ objects are just containers for a file's location
+and only open the file when you call methods that require reading or writing.

core/tutorial/doc/02_grayscale.md

@@ -0,0 +1,153 @@
+# Tutorial 02 - Grayscale Image Operations
+
+After reading your image from a file into memory, you may want to optimize its histogram using gray value transforms. This tutorial will tech you the basics.
+
+## Pattern for gray value transforms
+You can use the following pattern for your gray value transforms.
+
+```c++
+template <class P> void MyTransform(NICE::ImageT<P>& image)
+{
+	for(int x = 0; x < image.width(); x++) {
+		for(int y=0; y < image.height(); y++) {
+			P pixel = image.getPixelQuick(x, y);
+			// Insert transform here	
+			image.setPixelQuick(x, y, pixel);
+		}
+	}
+}
+```
+
+Note that the get/setPixelQuick Methods don't perform boundary checks!
+
+### Optimization
+If you have access to Intel IPP, you can use the overloaded operators provided in ImageOperators.h.
+
+Another easy way to improve performance is adding a "parallel for" OpenMP compilation hint.
+
+## Gamma transforms
+Gamma transforms are a little more complicated, because gray values are not always in the [0,1] range.
+For example, the _Image_ and _GrayImage16s_ use the full positive range of their data types while the _FloatImage_ class can handle arbitrary ranges.
+
+You can use the __max()__ and __min()__ methods on your image to find its specific range. 
+
+## Histogram
+NICE provides a _Histogram_ class for 8-bit grayscale and color images (_Image_ and _ColorImage_).
+To calculate an image's histogram, use the constructor:
+
+``` c++
+NICE::Histogram histogram(image, 0, 256);
+```
+
+# Sample code
+This sample program attempts to equalize an image's histogram by deriving a
+gray value transform from the cumulative histogram.
+
+Take this ![sample image](screenshots/tut02_eq_org.png):
+the ![histogram](screenshots/tut02_eq_hist_org.png) shows that it doesn't make
+use of the whole range of gray values.
+After running the sample program, the image should look like
+![this](screenshot/tut02_eq_new.png).
+We can see in its ![histogram](screenshot/tut02_eq_hist_new.png) that is uses
+the complete range now.
+
+## Includes and file names
+Just like the previous sample, the program needs input and output file names.
+It also uses the _ImageT_ and _ImageFile_ classes, but needs the relevant
+headers for _Histogram_ and _VectorT_ as well.
+
+```c++
+#include <iostream>
+#include <string>
+#include <core/image/ImageT.h>
+#include <core/image/ImageFile.h>
+#include <core/image/Histogram.h>
+#include <core/vector/VectorT.h>
+```
+
+The command line is then checked and stored like in the first sample. Most
+sample programs will use this pattern.
+
+```c++
+// Check if enough parameters were supplied
+if (argc < 3) {
+	std::cout << "USAGE: " << argv[0] << " <input image> <output image>\n";
+	return -1;
+}
+
+// These are our file names
+std::string input_path(argv[1]);
+std::string output_path(argv[2]);
+```
+
+## Calculating the histogram
+We read the image file specified as a command line argument using _ImageFile_
+like we learned in the first tutorial. This time we don't use _ColorImage_,
+because the sample program describes a gray value transform.
+
+When constructing a _Histogram_, we need to specify the range of gray values
+in our image. 8-bit images have values ranging from 0 to 255, but while the
+histogram includes the lower boundary as a bin, it does not include the upper
+boundary because it uses the difference between the boundarys to calculate the
+number of bins. This is why the sample program uses the values 0 and 256.
+
+The cumulative functions doesn't return another _Histogram_, but an _IntVector_.
+
+```c++
+// Read image into memory
+NICE::ImageFile source_file(input_path);
+NICE::Image image;
+source_file.reader(&image);
+
+// Calculate cumulative histogram
+NICE::Histogram histogram(image, 0, 256);
+NICE::IntVector* cumulative_histogram = histogram.cumulative();
+```
+
+## The transform
+In theory, if we use the cumulative histogram as a mapping for our gray value
+transform, the resulting image has a perfectly uniform histogram. We can prove
+this for images that are continuously differentiable functions of real numbers.
+This is not the case for digital images:
+suppose an image is filled with a single color.
+There is no gray value transform that can turn this image into one with a
+uniform distribution of gray values.
+
+We also need to scale the cumulative histogram down to our 8-bit range.
+The largest value will match the total number of pixels in the source image,
+so we use that to calculate a scaling factor.
+
+```c++
+double factor = 255.0/(double)(image.width()*image.height());
+
+// Transform using our pattern
+for(int x = 0; x < image.width(); x++) {
+	for(int y=0; y < image.height(); y++) {
+		// This is the old gray value
+		Ipp8u pixel = image.getPixelQuick(x, y);
+
+		// We use it as and index into the cumulative histogram to
+		// computer the new one. This has to be scaled appropriately
+		// using our precomputed factor.
+		double new_pixel_f =
+				((double)cumulative_histogram->get(pixel))*factor;
+
+		// The pixel format is 8-bit integer, so we have to convert
+		// the result
+		Ipp8u new_pixel = static_cast<Ipp8u>(new_pixel_f + 0.5);
+
+		// ..and save it
+		image.setPixelQuick(x, y, new_pixel);
+
+	}
+}
+```
+
+We can now write the changed image back to disk. We use a new file to preserve
+the original.
+
+```c++
+NICE::ImageFile dest_image(output_path);
+dest_image.writer(&image);
+return 0;
+```

core/tutorial/doc/03_color.md

@@ -0,0 +1,126 @@
+# Tutorial 03 - Color Image Operations
+
+## Architecture
+As mentioned in tutorial 01, color images in memory are represented by instances of
+_ColorImageT<>_.
+
+## File input/output
+Because _ImageT<>_ and _ColorImageT<>_ are both subclasses of 
+_GrayColorImageCommonImplementationT<>_, you can use the __reader__ and __writer__ methods
+as explained in tutorial 01.
+
+Note that using a file format that doesn't match the number of channels used by your image
+results in undefined behavior.
+
+## Read/write operations
+For pixel access, the __setPixelQuick__ methods accepts either a matching instance of
+_ColorT<>_ (_Color_ for 8-bit images) or three pixel values:
+
+```c++
+// Using Color
+color_image.setPixelQuick(4, 3, NICE::Color(0, 255, 0));
+
+// Using separate parameters
+color_image.setPixelQuick(4, 3, 0, 255, 0);
+```
+
+To read a pixel, use __getPixelQuick__ with the additional _channel_ parameter:
+
+```c++
+r = color_image.getPixelQuick(4, 3, 0);
+g = color_image.getPixelQuick(4, 3, 1);
+b = color_image.getPixelQuick(4, 3, 2);
+```
+
+## Conversion between color spaces
+NICE can convert between the three-channel color spaces YUV, HSV and RGB.
+The following methods are available:
+
+- __rgbToHSV__
+- __hsvToRGB__
+- __rgbToYUV__
+- __yuvToRGB__
+
+These methods allocate a new _ColorImageT<>_ (you can specify your own if you want to) and
+return a pointer to it:
+
+```c++
+// Use the return value
+NICE::ColorImage my_rgb_image = NICE::hsvToRGB(my_hsv_image);
+
+// Specify your own!
+NICE::ColorImage my_yuv_image(my_hsv_image.width(), my_hsv_image.height());
+NICE::rgbToYUV(my_rgb_image, my_yuv_image);
+```
+
+### Pseudocolors
+While not strictly a conversion, you can enhance a gray image with pseudocolors using the
+built-in function _imageToPseudoColor_. This is a very helpful visualization technique
+if your gray values represent something other than intensity (e.g depth or temperature):
+
+```c++
+// Allocate color image of appropriate dimensions
+NICE::ColorImage color_image(image.width(), image.height());
+
+// Convert to pseudocolor image
+NICE::imageToPseudoColor(image, color_image);
+```
+
+# Sample code
+The sample program for this chapter follows the input-transform-output pattern
+of the previous examples. Because conversions between color spaces are
+very easy to do with NICE-core, but also very hard to visualize, we will
+show you how to work with _ColorImageT<>_ by coloring a grayscale input
+using pseudocolors.
+
+## Includes and file names
+You can find the pseudocolor and conversion functions in __Convert.h_.
+_ColorImageT<>_ has its own header file.
+
+```c++
+#include <iostream>
+#include <string>
+#include <core/image/ImageT.h>
+#include <core/image/ColorImageT.h>
+#include <core/image/ImageFile.h>
+#include <core/image/Convert.h>
+```
+
+We also need to check the command line for arguments and store them
+if there are enough:
+
+```c++
+// Check if enough parameters were supplied
+if (argc < 3) {
+	std::cout << "USAGE: " << argv[0] << " <input image> <output image>\n";
+	return -1;
+}
+
+// These are our file names
+std::string input_path(argv[1]);
+std::string output_path(argv[2]);
+```
+
+## Pseudocolors
+The next step is reading the file into an _Image_ and calling the
+_imageToPseudoColor_ method to perform the colorization. This methods needs
+a destination _ColorImage_ of similar dimensions.
+
+```c++
+// Read image into memory
+NICE::ImageFile source_file(input_path);
+NICE::Image image;
+source_file.reader(&image);
+
+// Calculate pseudocolors
+NICE::ColorImage pseudo_image(image.width(), image.height());
+NICE::imageToPseudoColor(image, pseudo_image);
+```
+
+After this is done, we write __pseudo_image__ to disk so we can look at it:
+
+```c++
+NICE::ImageFile dest_image(output_path);
+dest_image.writer(&pseudo_image);
+return 0;
+```

core/tutorial/doc/04_filter.md

@@ -0,0 +1,87 @@
+# Tutorial 04 - Filters
+Linear filters play an important role in image processing.
+They are used for dealing with noise and in many computer vision applications.
+NICE provides generic implementations of several common filter types and
+supports custom kernels.
+
+## Data types
+The class _FilterT<>_ contains static methods for every filter type supported
+by NICE.
+You can specify different data types for your source and destination images and
+also
+for the calculations used during convolution.
+
+We recommend sticking to 8-bit-per-channel images (using the Image typedef as
+recommended throughout this tutorial series) and using _double_ values for
+the filter calculations.
+
+In this case you can use the _Filter_ typedef.
+
+## Source and destination image
+Most filter methods expect a destination image to write their results to.
+This image should have the same dimensions as the source image, otherwise
+it will be resized or an exception will be thrown.
+
+You should always construct a destination image like this:
+
+```c++
+// [...]
+NICE::Image image;
+// [...]
+NICE::Image result(image.width(), image.height());
+```
+
+## Filter types
+This section will give you an overview of the different kinds of filter NICE
+supports.
+
+### Mean filter
+A very simple filter for noise reduction is the mean filter.
+NICE implements this filter two times: for small and for large kernels.
+
+For most applications, the small implementation will suffice:
+
+```c++
+const unsigned int size = 3;
+NICE::Filter::filterMean(image, size, result);
+```
+
+The __size__ parameter describes the radius of the neighborhood
+(not including the center)
+used as a filter kernel. For size = 3, you get a 7x7 mean filter.
+
+### Sobel filter
+For some detection algorithms, you need gradient images.
+To compute the first derivative of your image in X and Y directions,
+use the following methods:
+
+```c++
+NICE::Filter::sobelX(image,gradientImageX);
+NICE::Filter::sobelY(image,gradientImageY);
+```
+
+
+### Using your own filter kernel
+Some applications require a specific filter kernel.
+You can supply an instance of _MatrixT<>_ with your values.
+
+The template argument should match the type used for calculations in
+_FilterT_.
+If you use the _Filter_ typedef, you can use the _Matrix_ typedef as well.
+
+You can then apply the filter like this:
+
+```c++
+NICE::Filter::filter(image, kernel, result);
+```
+
+If your filter kernel is separable, you can get better performance by applying
+two one-dimensional convolutions.
+Instead of _MatrixT<>_, you supply two _VectorT<>_ instances.
+As with _Matrix_, there's a typedef _Vector_ for _VectorT<double>_.
+
+You need to call two methods in this case:
+
+```c++
+NICE::Filter::filterX(image, kernel, result);
+NICE::Filter::filterY(image, kernel, result);

core/tutorial/doc/05_vecmat.md

@@ -0,0 +1,143 @@
+# Tutorial 05 - Vectors and Matrices
+## Vectors
+NICE provides the generic _VectorT<>_ class for vector data storage and
+calculations.
+It supports the same, large number of operations for all data types.
+
+There are deep and shallow copy functions for LinAl interoperability.
+
+### Construction
+While _VectorT<>_ provides a default constructor, it is only if you want
+to avoid pointers as member variables.
+
+_VectorT<>_ needs to know the number of elements because resizing a vector is
+extremely inefficient. You can also initialize the elements if you want to:
+
+```c++
+// This line creates an empty vector
+VectorT<double> empty_vector();
+
+// This line creates a three-dimensional vector
+// The elements are not initialized
+VectorT<double> threed_vector(3);
+
+// This line creates a two-dimensional vector
+// We initialize the elements to the value 25.3
+VectorT<double> twod_vector(3, 25.3);
+```
+
+
+### Operators
+For easy and expressive calculations, _VectorT<>_ defines the following
+classes of operators:
+
+* Unary operators:
+    - Unchecked read or reference access to element ([])
+    - Checked read or reference access to element (())
+
+* Binary operators:
+    - Vector addition and subtraction (+,-)
+    - Scalar multiplication (\*)
+
+* Combined assignment operators:
+    - Vector addition and subtraction (+=,-=)
+    - Vector multiplication and division (\*=,/=)
+    - Scalar addition and subtraction (+=,-=)
+    - Scalar multiplication and division (\*=,/=)
+
+### Methods
+In addition to basic algebra, _VectorT<>_ supports more complex operations.
+These include:
+
+* Calculating the scalar product of two _VectorT<>_: __scalarProduct__
+* Determining various statistics: __Sum__, __Mean__, __Median__, __StdDev__,
+  __Min__, __Max__
+* Additional information on these statistics: __MaxIndex__, __MinIndex__
+* Mean in non-euclidean vector spaces: __CircularMean__
+* Several norms: __normInf__, __normL1__, __normL2__
+* ...and normalization routines: __normalizeInf__, __normalizeL1__, __normalizeL2__
+* Basic sorting functions: __sortAscend__, __sortDescend__
+
+## Matrices
+Just like vectors, matrices have a generic representation in NICE.
+The class is called _MatrixT<>_ and is not related to _VectorT<>_ in that it
+is not a construct like _VectorT<VectorT<>>_.
+
+### Construction
+_MatrixT<>_ has a large number of constructors for different use cases.
+The default constructor creates a _MatrixT<>_ of dimensions 0x0 and should
+only be used for RAII purposes because resizing a _MatrixT<>_ is a very
+inefficient operation.
+
+```c++
+// Construction and expansion
+NICE::MatrixT<double> empty_matrix();
+empty_matrix.resize(5,4);
+```
+
+Instead, you can specifiy the dimensions and an optional default element.
+When no default element is given to the constructor, the matrix will not
+be initialized contains unpredictable data.
+
+```c++
+// 4x5 matrix - no initialization
+NICE::MatrixT<double> undefined_matrix(4,5);
+
+// 5x6 matrix - default element: 1
+NICE::MatrixT<double> simple_matrix(5,6,1);
+```
+
+### Data access
+_MatrixT<>_ provides different methods for read and write access to fit as
+many applications as possible.
+See the following snippet for important use cases:
+
+```c++
+// This is our matrix
+NICE::MatrixT<double> matrix(3,3);
+
+// At this point, the elements are unknown, so let's set them all to zero.
+matrix.set(0);
+
+// Now, create a vector
+NICE::VectorT<double> vector(3);
+vector[0]=1, vector[1]=2, vector[2]=3;
+
+// We can use this vector with the setRow method
+matrix.setRow(0, vector);
+
+// Set the center element to 5
+matrix(1,1)=5;
+
+// How can we set a column using a VectorT?
+matrix.getColumnRef(2)=vector;
+```
+
+### Operators
+_MatrixT<>_ exports basic calculations and methods as operators:
+
+* Unary operators:
+    - Unchecked read or reference access to element (())
+
+* Binary operators:
+    - Matrix addition and subtraction (+,-)
+    - Matrix-scalar multiplication (\*)
+    - Matrix-vector multiplication (\*)
+    - Matrix multiplication (\*)
+
+* Combined assignment operators:
+    - Matrix addition and subtraction (+=,-=)
+    - Matrix multiplication and division - element-wise (\*=,/=)
+    - Scalar addition and subtraction (+=,-=)
+    - Scalar multiplication and division (\*=,/=)
+
+### Methods
+More advanced calculations are available as member functions:
+
+* Set the matrix to a multiple of the identity matrix or
+  add to the existing matrix: __setIdentity__, __addIdentity__
+* Add a vector's elements as a diagonal matrix: __addDiagonal__
+* Calculate the tensor product of two vectors and store it
+  or add it to the matrix: __tensorProduct__, __addTensorProduct__
+* Store the result of a matrix multiplication: __multiply__
+* Check if a floating point matrix contains a NaN element: __containsNaN__

core/tutorial/doc/06_algebra.md

@@ -0,0 +1,57 @@
+# Tutorial 06 - Linear Algebra
+
+## Singular value decomposition
+_Note: Currently, calculating the SVD of a matrix requires LinAL_
+
+Use the _SVD_ class for fast singular value decomposition.
+The calculation is performed at initialization and the resulting
+matrices are available from getter functions.
+
+Calculating the SVD is a very straightforward task.
+See this short example on how to use the SVD class:
+
+```c++
+// Create a matrix
+NICE::MatrixT<double> my_matrix(3,3,0);
+my_matrix.addIdentity(1);
+my_matrix(0,2) = 5;
+my_matrix(1,0) = 3;
+
+// Calculate the SVD
+NICE::SVD svd(my_matrix);
+
+// Store the results
+NICE::MatrixT<double> result_vt = svd.getVt();
+NICE::MatrixT<double> result_u = svd.getU();
+
+// This returns the singular values in a diagonal matrix
+// This diagonal matrix is allocated only if you call this function.
+NICE::MatrixT<double> result_s_matrix = svd.getS();
+
+// This returns the singular values as a vector. Use this function for
+// increased efficiency
+NICE::VectorT<double> result_s_vector = svd.getSingularValues();
+```
+
+## Eigenvalues
+_Note: Currently, calculating the eigenvalues of a matrix requires IPP._
+
+Calculating the eigenvalues of a matrix is as simple as single function call.
+The __eigenvalues__ function takes a _MatrixT<>_ and returns a _VectorT<>_ 
+that contains the eigenvalues. It allocates a _VectorT<>_ of matching dimensions
+on the heap.
+This behavior can be overridden be specifying a pointer as the second parameter.
+
+```c++
+// Create a matrix
+NICE::MatrixT<double> matrix(3,3,0);
+matrix.addIdentity(4);
+matrix(0,1) = -2;
+
+// Calculate the eigenvalues
+NICE::VectorT<double> eigenvals = NICE::eigenvalues(matrix);
+
+// ..or use your own vector
+NICE::VectorT<double> my_own_vector(3);
+NICE::eigenvalues(matrix, my_own_vector);
+```

core/tutorial/doc/samples.md

@@ -0,0 +1,38 @@
+# Sample code
+Some tutorials come with sample code for a more hands-on learning experience.
+The following sample programs are available:
+
+| Tutorial | Sample Program |
+| -: | - |
+| 01 | Simple program that reads a file and writes the image to another|
+| 02 | Program that optimizes the contrast of a grayscale image|
+| 03 | Program that colorizes a grayscale image using pseudocolors|
+| 04 | Program that applies a motion blur effect to an image using a linear filter|
+| 05 | Program that loads a Matlab file to showcase algebra functions|
+
+# Sample images for sample code
+NICE-core supports PPM and PGM images out of the box without any additional
+dependencies.
+
+See the __samples__ folder for sample images that work with the sample code
+from the tutorials.
+
+## Grayscale sample images
+The grayscale samples are 8-bit PGM files.
+You can use them with the following sample programs:
+
+* Tutorial 02
+* Tutorial 03
+* Tutorial 04
+
+## Color sample images
+The color samples are 8-bit-per-channel PPM images.
+They work with the sample code from these tutorials:
+
+* Tutorial 01
+
+# Other samples
+We also include some Matlab files for use with the following samples:
+
+* Tutorial 05
+* Tutorial 06

core/tutorial/progs/01_imageio.cpp

@@ -0,0 +1,45 @@
+/*
+ * Tutorial 01 - Basic Image I/O Operations
+ * Sample Implementation
+ *
+ * @file 01_imageio.cpp
+ * @brief Sample implementation for tutorial 01
+ * @date 09.03.2014
+ * @author Clemens-A. Brust
+ */
+
+#include <iostream>
+#include <string>
+#include <core/image/ImageT.h>
+#include <core/image/ImageFile.h>
+
+/*
+ * Entry point
+ */
+int main(int argc, char** argv) {
+	// Check if enough parameters were supplied
+	if (argc < 3) {
+		std::cout << "USAGE: " << argv[0] << " <input image> <output image>\n";
+		return -1;
+	}	
+
+	// These are our file names
+	std::string input_path(argv[1]);
+	std::string output_path(argv[2]);
+
+	// Read file header and display header information
+	NICE::ImageFile source_file(input_path);
+	NICE::ImageFile::Header source_header = source_file.getHeader();
+
+	std::cout << "Source image dimensions: " << source_header.width << " x " << source_header.height;
+	std::cout << " (" << source_header.channel << " channels, " << source_header.bitdepth << " bpp)\n";
+
+	// Read image into memory
+	NICE::ColorImage source_image;
+	source_file.reader(&source_image);
+
+	// Write image to disk
+	NICE::ImageFile dest_image(output_path);
+	dest_image.writer(&source_image);
+	return 0;
+}

core/tutorial/progs/02_grayscale.cpp

@@ -0,0 +1,74 @@
+/*
+ * Tutorial 02 - Grayscale Image Operations
+ * Sample Implementation
+ *
+ * @file 02_grayscale.cpp
+ * @brief Sample implementation for tutorial 02
+ * @date 09.03.2014
+ * @author Clemens-A. Brust
+ */
+
+#include <iostream>
+#include <string>
+#include <core/image/ImageT.h>
+#include <core/image/ImageFile.h>
+#include <core/image/Histogram.h>
+#include <core/vector/VectorT.h>
+
+/*
+ * Entry point
+ */
+
+int main(int argc, char** argv) {
+	// Check if enough parameters were supplied
+	if (argc < 3) {
+		std::cout << "USAGE: " << argv[0] << " <input image> <output image>\n";
+		return -1;
+	}
+
+	// These are our file names
+	std::string input_path(argv[1]);
+	std::string output_path(argv[2]);
+
+	// Read image into memory
+	NICE::ImageFile source_file(input_path);
+	NICE::Image image;
+	source_file.reader(&image);
+
+	// Calculate cumulative histogram
+	NICE::Histogram histogram(image, 0, 256);
+	NICE::IntVector* cumulative_histogram = histogram.cumulative();
+
+	// The largest value in the cumulative histogram is the total pixel count
+	// of the source image. We need to scale this down to 255 to match the pixel
+	// format of the image.
+	double factor = 255.0/(double)(image.width()*image.height());
+
+	// Transform using our pattern
+	for(int x = 0; x < image.width(); x++) {
+		for(int y=0; y < image.height(); y++) {
+			// This is the old gray value
+			Ipp8u pixel = image.getPixelQuick(x, y);
+
+			// We use it as and index into the cumulative histogram to
+			// computer the new one. This has to be scaled appropriately
+			// using our precomputed factor.
+			double new_pixel_f =
+					((double)cumulative_histogram->get(pixel))*factor;
+
+			// The pixel format is 8-bit integer, so we have to convert
+			// the result
+			Ipp8u new_pixel = static_cast<Ipp8u>(new_pixel_f + 0.5);
+
+			// ..and save it
+			image.setPixelQuick(x, y, new_pixel);
+
+		}
+	}
+
+
+	// Write image to disk
+	NICE::ImageFile dest_image(output_path);
+	dest_image.writer(&image);
+	return 0;
+}

core/tutorial/progs/03_color.cpp

@@ -0,0 +1,45 @@
+/*
+ * Tutorial 03 - Color Image Operations
+ * Sample Implementation
+ *
+ * @file 03_color.cpp
+ * @brief Sample implementation for tutorial 03
+ * @date 09.03.2014
+ * @author Clemens-A. Brust
+ */
+ 
+#include <iostream>
+#include <string>
+#include <core/image/ImageT.h>
+#include <core/image/ColorImageT.h>
+#include <core/image/ImageFile.h>
+#include <core/image/Convert.h>
+
+/*
+ * Entry point
+ */
+int main(int argc, char** argv) {
+	// Check if enough parameters were supplied
+	if (argc < 3) {
+		std::cout << "USAGE: " << argv[0] << " <input image> <output image>\n";
+		return -1;
+	}
+
+	// These are our file names
+	std::string input_path(argv[1]);
+	std::string output_path(argv[2]);
+
+	// Read image into memory
+	NICE::ImageFile source_file(input_path);
+	NICE::Image image;
+	source_file.reader(&image);
+
+	// Calculate pseudocolors
+	NICE::ColorImage pseudo_image(image.width(), image.height());
+	NICE::imageToPseudoColor(image, pseudo_image);
+
+	// Write image to disk
+	NICE::ImageFile dest_image(output_path);
+	dest_image.writer(&pseudo_image);
+	return 0;
+}

core/tutorial/progs/04_filter.cpp

@@ -0,0 +1,53 @@
+/*
+ * Tutorial 04 - Filters
+ * Sample Implementation
+ *
+ * @file 04_filter.cpp
+ * @brief Sample implementation for tutorial 04
+ * @date 09.03.2014
+ * @author Clemens-A. Brust
+ */
+
+#include <iostream>
+#include <string>
+#include <core/image/ImageT.h>
+#include <core/vector/MatrixT.h>
+#include <core/image/FilterT.h>
+
+/*
+ * Entry point
+ */
+int main(int argc, char** argv) {
+	// Check if enough parameters were supplied
+		if (argc < 3) {
+			std::cout << "USAGE: " << argv[0] << " <input image> <output image>\n";
+			return -1;
+		}
+
+		// These are our file names
+		std::string input_path(argv[1]);
+		std::string output_path(argv[2]);
+
+		// Read file header and display header information
+		NICE::ImageFile source_file(input_path);
+
+		// Read image into memory
+		NICE::Image image;
+		source_file.reader(&image);
+
+		// Allocate memory for result image
+		NICE::Image result(image.width(), image.height());
+
+		// Put together a simple convolution kernel for our motion blur effect
+		NICE::Matrix kernel(10,10);
+		kernel.set(0);
+		kernel.addIdentity(0.1);
+
+		// Filter the image
+		NICE::Filter::filter(image, kernel, result);
+
+		// Write image to disk
+		NICE::ImageFile dest_image(output_path);
+		dest_image.writer(&result);
+		return 0;
+}

core/tutorial/progs/05_matio.cpp

@@ -0,0 +1,125 @@
+/*
+ * Tutorials 05/06 - Matlab I/O and Linear Algebra
+ * Sample Implementation
+ *
+ * @file 05_matio.cpp
+ * @brief Sample implementation for tutorials 05/06
+ * @date 09.03.2014
+ * @author Clemens-A. Brust
+ */
+
+#include <iostream>
+#include <string>
+#include <exception>
+#include <core/image/ImageT.h>
+#include <core/vector/MatrixT.h>
+#include <core/vector/VectorT.h>
+#include <core/vector/Eigen.h>
+#include <core/vector/SVD.h>
+#include <core/image/FilterT.h>
+
+#ifdef NICE_USELIB_MATIO
+#include <core/matlabAccess/MatFileIO.h>
+
+template<typename T> void printMatrix(NICE::MatrixT<T> matrix);
+
+/*
+ * Entry point
+ */
+int main(int argc, char** argv) {
+	// Check if enough parameters were supplied
+	if (argc < 3) {
+		std::cout << "USAGE: " << argv[0] << " <matlab file> <matrix name>\n";
+		return -1;
+	}
+
+	// These are our file names
+	std::string input_path(argv[1]);
+	std::string matrix_name(argv[2]);
+
+	NICE::MatFileIO matlab_file(input_path, MAT_ACC_RDONLY);
+	
+	// Show the number of variables in the file
+	int vars_in_file = matlab_file.getNumberOfVariables();
+	std::cout << vars_in_file << " Variables in " << input_path << "\n";
+
+	// Load the matrix
+	std::cout << "Loading matrix \"" << matrix_name << "\"...\n";
+
+	// Check if the variable is a matrix
+	matvar_t* matrix_variable = matlab_file.getVariableViaName(matrix_name);
+	if(matrix_variable->rank != 2) {
+		std::cout << "Variable is not a matrix. Rank: " << matrix_variable->rank << ".\n";
+		return -1;
+	}
+
+	// Read the dimensions
+	int cols = matrix_variable->dims[1];
+	int rows = matrix_variable->dims[0];
+	std::cout << "Dimensions: " << cols << " x " << rows << "\n";
+
+	// Read the matrix into a vector of vectors
+	std::vector< std::vector<double> > matrix_vecvec(rows, std::vector<double>(cols));
+	matlab_file.getFeatureMatrixViaName(matrix_vecvec, matrix_name);
+
+	// Now, we want a NICE matrix
+	NICE::MatrixT<double> matrix(rows, cols);
+	for(int i = 0; i < rows; i++) {
+		for(int j = 0; j < cols; j++) {
+			matrix(i,j) = matrix_vecvec[i][j];
+		}
+	}
+
+	// Print the NICE matrix
+	printMatrix(matrix);
+
+	// Check if eigenvalues exist
+	if(rows != cols) {
+		std::cout << "Matrix is not square, cannot calculate eigenvalues!\n";
+		return -1;
+	}
+
+	// Calculate eigenvalues
+	try {
+		NICE::VectorT<double>* matrix_eigenvalues = NICE::eigenvalues(matrix);
+	} catch (std::exception& e) {
+		std::cout << "Exception occured during eigenvalue calculation, "
+			<< "is IPP installed?\n";
+	}
+
+#ifdef NICE_USELIB_LINAL
+	// Calculate singular value decomposition
+	NICE::SVD matrix_svd(matrix);
+
+	std::cout << "Vt:\n";
+	printMatrix(matrix_svd.getVt());
+
+	std::cout << "U:\n";
+	printMatrix(matrix_svd.getU());
+
+	std::cout << "S:\n";
+	printMatrix(matrix_svd.getS());
+#else
+	std::cout << "LinAL is not installed, SVD calculation is not possible!\n";
+#endif
+	return 0;
+
+}
+
+template<typename T> void printMatrix(NICE::MatrixT<T> matrix) {
+	for(int i = 0; i < matrix.rows(); i++) {
+		for(int j = 0; j < matrix.cols(); j++) {
+			std::cout << matrix(i,j) << "\t";
+		}
+		std::cout << "\n";
+	}
+}
+#else
+
+/*
+ * Replacement entry point
+ */
+int main(int argc, char** argv) {
+	std::cout << "This sample needs MATIO to work!\n";
+}
+#endif

core/vector/ippwrapper.tcc

@@ -4,6 +4,7 @@
 #include <numeric>
 #include <cmath>
 #include <functional>
+#include <cstdlib>
 
 template<class P>
 inline IppStatus ippsCopy( const P* pSrc, P* pDst, int len ) {

core/vector/progs/testCholeskySpeed.cpp

@@ -38,7 +38,11 @@ double getInvError ( const Matrix & A, const Matrix & Ainv )
 int main (int argc, char **argv)
 {   
 #ifndef WIN32
+#ifndef __clang__
+#ifndef __llvm__ 
     std::set_terminate(__gnu_cxx::__verbose_terminate_handler);
+#endif
+#endif
 #endif
 
     int size = 500;