Commit cc1a1c85550bc4d0cc275d62b0cf159779c56ad7 - libvigraimpex

+5

-1

CMakeLists.txt less more

25	25	include(VigraSetDefaults)
26	26	include(VigraCMakeUtils)
27	27	INCLUDE_DIRECTORIES(${vigra_SOURCE_DIR}/include)
	28
	29	if(SUPPRESS_3RD_PARTY_WARNINGS)
	30	set(SUPPRESS_WARNINGS SYSTEM)
	31	endif()
28	32
29	33	IF(VIGRA_STATIC_LIB)
30	34	SET(LIBTYPE STATIC)

151	155	ENDIF()
152	156
153	157	if(WITH_BOOST AND Boost_FOUND)
154		INCLUDE_DIRECTORIES(${Boost_INCLUDE_DIR})
	158	INCLUDE_DIRECTORIES(${SUPPRESS_WARNINGS} ${Boost_INCLUDE_DIR})
155	159	IF(WITH_BOOST_THREAD)
156	160	ADD_DEFINITIONS(-DUSE_BOOST_THREAD)
157	161	ENDIF()

+6

-6

README.md less more

5	5
6	6	Copyright 1998-2013 by Ullrich Koethe
7	7
	8
8	9	This file is part of the VIGRA computer vision library.
9	10	You may use, modify, and distribute this software according
10	11	to the terms stated in the LICENSE.txt file included in
11	12	the VIGRA distribution.
12	13
13	14	The VIGRA Website is
14		http://hci.iwr.uni-heidelberg.de/vigra/
	15	http://ukoethe.github.io/vigra/
15	16	Please direct questions, bug reports, and contributions to
16	17	ullrich.koethe@iwr.uni-heidelberg.de or
17	18	vigra@informatik.uni-hamburg.de

31	32	snapshot), you find these instructions in
32	33	$VIGRA_PATH/docsrc/installation.dxx
33	34	or online at
34		http://hci.iwr.uni-heidelberg.de/vigra/doc/vigra/Installation.html
	35	http://ukoethe.github.io/vigra/doc-release/vigra/Installation.html
35	36
36	37	Documentation
37	38	-------------
38	39
39	40	If you downloaded an official release, the documentation can be found in `$VIGRA_PATH/doc/vigra/`, the start file
40		is `$VIGRA_PATH/doc/vigra/index.html`.
	41	is `$VIGRA_PATH/doc/vigra/index.html` or online at http://ukoethe.github.io/vigra/#documentation.
41	42
42		When you use the development version from github, you can generate documentation by `make doc`. Up-to-date
43		online documentation for the 'master' branch is regularly pushed to http://ukoethe.github.io/vigra/doc/vigra/
	43	When you use the development version from github, you can generate documentation by `make doc`.
44	44
45	45	Download
46	46	--------
47	47
48		VIGRA can be downloaded at http://hci.iwr.uni-heidelberg.de/vigra/#download The official development
	48	VIGRA can be downloaded at http://ukoethe.github.io/vigra/#download. The official development
49	49	repository is at https://github.com/ukoethe/vigra
50	50
51	51	What is VIGRA

+30

-7

config/FindOpenEXR.cmake less more

24	24
25	25	FIND_PATH(OPENEXR_INCLUDE_DIR ImfRgbaFile.h PATH_SUFFIXES OpenEXR)
26	26
27		FIND_LIBRARY(OPENEXR_ILMIMF_LIBRARY NAMES IlmImf)
28		FIND_LIBRARY(OPENEXR_IMATH_LIBRARY NAMES Imath)
	27	FOREACH(V "" -2_2 -2_1 -2_0 -1_7)
	28	if(NOT OPENEXR_ILMIMF_LIBRARY)
	29	FIND_LIBRARY(OPENEXR_ILMIMF_LIBRARY NAMES IlmImf${V})
	30	if(OPENEXR_ILMIMF_LIBRARY)
	31	set(OPENEXR_VERSION ${V})
	32	endif()
	33	endif()
	34	ENDFOREACH(V)
	35
	36	FIND_LIBRARY(OPENEXR_IMATH_LIBRARY NAMES Imath${OPENEXR_VERSION})
	37	FIND_LIBRARY(OPENEXR_IEX_LIBRARY NAMES Iex${OPENEXR_VERSION})
	38	FIND_LIBRARY(OPENEXR_ILMTHREAD_LIBRARY NAMES IlmThread${OPENEXR_VERSION})
29	39	FIND_LIBRARY(OPENEXR_HALF_LIBRARY NAMES Half)
30		FIND_LIBRARY(OPENEXR_IEX_LIBRARY NAMES Iex)
31		FIND_LIBRARY(OPENEXR_ILMTHREAD_LIBRARY NAMES IlmThread)
32	40
33	41	INCLUDE(FindPackageHandleStandardArgs)
34		FIND_PACKAGE_HANDLE_STANDARD_ARGS(OPENEXR DEFAULT_MSG
	42	FIND_PACKAGE_HANDLE_STANDARD_ARGS(OpenEXR DEFAULT_MSG
35	43	OPENEXR_HALF_LIBRARY OPENEXR_IEX_LIBRARY OPENEXR_IMATH_LIBRARY
36	44	OPENEXR_ILMIMF_LIBRARY OPENEXR_INCLUDE_DIR
37	45	)
38	46
39		IF(OPENEXR_FOUND)
	47	IF(OpenEXR_FOUND)
40	48	SET(OPENEXR_LIBRARIES ${OPENEXR_ILMIMF_LIBRARY}
41	49	${OPENEXR_IMATH_LIBRARY} ${OPENEXR_HALF_LIBRARY}
42	50	${OPENEXR_IEX_LIBRARY} ${OPENEXR_ILMTHREAD_LIBRARY} )
43		ENDIF(OPENEXR_FOUND)
	51
	52	if(MSVC)
	53	execute_process(
	54	COMMAND lib /list "${OPENEXR_HALF_LIBRARY}"
	55	OUTPUT_VARIABLE OPENEXR_HALF_CONTENTS)
	56	if(OPENEXR_HALF_CONTENTS MATCHES "Half.dll")
	57	SET(OPENEXR_CPPFLAGS -DOPENEXR_DLL)
	58	endif()
	59	endif()
	60	ELSE()
	61	SET(OPENEXR_ILMIMF_LIBRARY OPENEXR_ILMIMF_LIBRARY-NOTFOUND)
	62	SET(OPENEXR_IMATH_LIBRARY OPENEXR_IMATH_LIBRARY-NOTFOUND)
	63	SET(OPENEXR_IEX_LIBRARY OPENEXR_IEX_LIBRARY-NOTFOUND)
	64	SET(OPENEXR_ILMTHREAD_LIBRARY OPENEXR_ILMTHREAD_LIBRARY-NOTFOUND)
	65	SET(OPENEXR_HALF_LIBRARY OPENEXR_HALF_LIBRARY-NOTFOUND)
	66	ENDIF()

+2

-1

config/FindVIGRANUMPY_DEPENDENCIES.cmake less more

69	69	OUTPUT_VARIABLE PYTHON_LIBRARY_NAME OUTPUT_STRIP_TRAILING_WHITESPACE)
70	70	execute_process(COMMAND ${PYTHON_EXECUTABLE} -c
71	71	"from distutils.sysconfig import *; print(get_config_var('LIBDIR'))"
72		OUTPUT_VARIABLE PYTHON_LIBRARY_PREFIX OUTPUT_STRIP_TRAILING_WHITESPACE)
	72	OUTPUT_VARIABLE PYTHON_LIBRARY_PREFIX OUTPUT_STRIP_TRAILING_WHITESPACE)
73	73	ENDIF()
74	74	FIND_LIBRARY(PYTHON_LIBRARIES ${PYTHON_LIBRARY_NAME} HINTS "${PYTHON_LIBRARY_PREFIX}" "${PYTHON_PREFIX}"
75	75	PATH_SUFFIXES lib lib64 libs DOC "Python libraries")

119	119
120	120	FIND_LIBRARY(Boost_PYTHON_LIBRARY
121	121	NAMES ${BOOST_PYTHON_NAMES}
	122	NAMES_PER_DIR
122	123	HINTS "${Boost_LIBRARY_DIR}"
123	124	DOC "boost_python libraries")
124	125	ENDIF()

+2

-2

config/VigraDetectCppVersion.cmake less more

11	11
12	12	if(RUN_RESULT)
13	13	message(FATAL_ERROR "Failed to detect c++ version with a simple test program!\n"
14		"Test program compiled, but did not execute cleanly. Run output is shown below.\n"
15		"${VIGRA_CPP_VERSION}")
	14	"Test program compiled, but did not execute cleanly. Run output is shown below.\n"
	15	"${VIGRA_CPP_VERSION}")
16	16	endif()
17	17
18	18	message(STATUS "Detected C++ version: ${VIGRA_CPP_VERSION}")

+3

-5

config/VigraSetDefaults.cmake less more

41	41	OPTION(WITH_BOOST_THREAD "Use boost::thread instead of std::thread" OFF)
42	42
43	43	OPTION(TEST_VIGRANUMPY "Consider lack of vigranumpy or failed vigranumpy test an error?" OFF)
	44
	45	OPTION(SUPPRESS_3RD_PARTY_WARNINGS "Switch-off compiler warnings originating from dependencies?" ON)
44	46
45	47	IF(TEST_VIGRANUMPY OR NOT DEFINED WITH_VIGRANUMPY)
46	48	SET(WITH_VIGRANUMPY "ON")

115	117	# executed once in the first configure run.
116	118	IF(CMAKE_COMPILER_IS_GNUCXX OR CMAKE_COMPILER_IS_CLANGXX)
117	119	IF(NOT CMAKE_CXX_FLAGS)
118		if(NOT MINGW AND NOT MACOSX)
119		SET(CMAKE_CXX_FLAGS "-W -Wall -Wextra -Wno-unused-parameter -Wno-sign-compare -Wno-unused-variable -Wno-type-limits")
120		elseif(MACOSX)
121		SET(CMAKE_CXX_FLAGS "-W -Wall -Wextra -Wno-unused-parameter -Wno-sign-compare -Wno-unused-variable")
122		endif()
	120	SET(CMAKE_CXX_FLAGS "-W -Wall -Wextra")
123	121	ENDIF()
124	122	IF(NOT CMAKE_C_FLAGS)
125	123	SET(CMAKE_C_FLAGS "-W -Wall -Wextra -pedantic -std=c99 -Wno-sign-compare")

+20

-0

config/shorten_path.bat less more

	0	@echo off
	1
	2	SET MyPath=%PATH%
	3	rem echo %MyPath%
	4	rem echo --
	5
	6	setlocal EnableDelayedExpansion
	7
	8	SET TempPath="%MyPath:;=";"%"
	9	SET var=
	10	FOR %%a IN (%TempPath%) DO (
	11	IF exist %%~sa (
	12	SET "var=!var!;%%~sa"
	13	) ELSE (
	14	rem echo %%a does not exist
	15	)
	16	)
	17
	18	rem echo --
	19	echo !var:~1!

+7

-4

docsrc/Doxyfile.in less more

531	531	# directories like "/usr/src/myproject". Separate the files or directories
532	532	# with spaces.
533	533
534		INPUT = @PROJECT_SOURCE_DIR@/include \
535		@PROJECT_SOURCE_DIR@/docsrc
	534	INPUT = @PROJECT_SOURCE_DIR@/docsrc \
	535	@PROJECT_SOURCE_DIR@/include
536	536
537	537	# This tag can be used to specify the character encoding of the source files
538	538	# that doxygen parses. Internally doxygen uses the UTF-8 encoding, which is

555	555	installation.dxx \
556	556	tutorial.dxx \
557	557	image_processing.dxx \
	558	parallel_processing.dxx \
558	559	*.hxx \
559	560	viff.h
560	561

616	617	# directories that contain image that are included in the documentation (see
617	618	# the \image command).
618	619
619		IMAGE_PATH = @PROJECT_SOURCE_DIR@/src/images
	620	IMAGE_PATH = @PROJECT_SOURCE_DIR@/src/images \
	621	@PROJECT_SOURCE_DIR@/docsrc/documents
620	622
621	623	# The INPUT_FILTER tag can be used to specify a program that doxygen should
622	624	# invoke to filter for each input file. Doxygen will invoke the filter program

1186	1188
1187	1189	PREDEFINED = DOXYGEN \
1188	1190	__cplusplus \
1189		VIGRA_EXPORT=
	1191	VIGRA_EXPORT= \
	1192	WITH_LEMON
1190	1193
1191	1194	# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then
1192	1195	# this tag can be used to specify a list of macro names that should be expanded.

+27

-9

docsrc/credits_changelog.dxx less more

19	19	<li> Gunnar Kedenburg
20	20	(<a href="mailto:gunnar@haquebright.de">gunnar@haquebright.de</a>)
21	21	completely rewrote the image import/export library and implemented
22		much of the \ref vigra::MultiArray functionality.
	22	the initial version of the \ref vigra::MultiArray functionality.
23	23
24	24	<li> Yevgen Reznichenko
25	25	(<a href="mailto:rezniche@kogs.informatik.uni-hamburg.de">rezniche@kogs.informatik.uni-hamburg.de</a>)

27	27
28	28	<li> Christian Dennis Rahn
29	29	(<a href="mailto:rahn@informatik.uni-hamburg.de">rahn@informatik.uni-hamburg.de</a>)
30		implemented much of the \ref MultiArrayConvolutionFilters.
	30	implemented initial versions of multi-dimensional convolution filters.
31	31
32	32	<li> Kasim Terzic, Florian Heinrich and Benjamin Seppke
33	33	implemented image analysis functionality for 3- and higher-dimensional data.

64	64
65	65	<li> Benjamin Seppke contributed various \ref Registration "image registration" algorithms.
66	66
	67	<li> John Kirkham figured out how to configure Travis to run tests for Python3 and on OS X.
	68
	69	<li> Philip Schill implemented version 3 of the Random Forest.
	70
	71	<li> David Stöckel contributed the 3D convex hull functionality.
	72
67	73	<li> Numerous people reported and fixed bugs and made suggestions.
68	74	</ul>
69	75
70	76	Many thanks to all!
71	77	<p>
72	78
	79	<b> Changes from Version 1.11.0 to 1.11.1</b>
	80
	81	<ul>
	82	<li> Added 3D convex hull computation and features (David Stöckel).
	83
	84	<li> Added Random Forest version 3, inspired by LEMON's graph API, to simplify customization of RF variants (Philip Schill).
	85
	86	<li> Improved hierarchical clustering (Cpnstantin Pape).
	87
	88	<li> Minor improvements and bug fixes in the code and documentation.
	89	</ul>
	90
73	91	<b> Changes from Version 1.10.0 to 1.11.0</b>
74	92
75	93	<ul>

87	105
88	106	<li> Added many \ref Registration "image registration" functions.
89	107
90		<li> Extended the collection of \ref MultiArrayDistanceTransform "multi-dimensional distance transform" algorithms by vectorial DT, boundary DT, and eccentricity transform.
	108	<li> Extended the collection of \ref DistanceTransform "multi-dimensional distance transform" algorithms by vectorial DT, boundary DT, and eccentricity transform.
91	109
92	110	<li> Added \ref skeletonizeImage(), nonLocalMean(), multi-dimensional integral images.
93	111

191	209
192	210	<li> Added \ref vigra::StridedScanOrderIterator and corresponding \ref vigra::MultiArrayView::begin().
193	211
194		<li> Extended \ref vigra::MultiArrayView. Added \ref vigra::Shape1 ... \ref vigra::Shape5 convenience typedefs.
	212	<li> Extended \ref vigra::MultiArrayView. Added vigra::Shape1 ... vigra::Shape5 convenience typedefs.
195	213
196	214	<li> Implemented \ref MultiMathModule (arithmetic and algebraic functions for multi-dimensional arrays).
197	215

289	307	<ul>
290	308	<li> Added functions for arrays of arbitrary dimensions:
291	309	<ul>
292		<li> \ref MultiArrayDistanceTransform "Euclidean distance transform"
	310	<li> \ref DistanceTransform "Euclidean distance transform"
293	311	<li> \ref MultiArrayMorphology "separable morphology"
294	312	<li> \ref resizeMultiArraySplineInterpolation()
295	313	</ul>

466	484	<b> Changes from Version 1.2.0 to 1.3.0</b>
467	485
468	486	<ul>
469		<li> Added algorithms for \ref MultiDimensionalArrays :
470		\ref MultiPointoperators and \ref MultiArrayConvolutionFilters
	487	<li> Added algorithms for multi-dimensional arrays: see
	488	\ref MultiPointoperators and \ref ConvolutionFilters
471	489	and the \link vigra::MultiArrayNavigator navigator utility\endlink.
472	490
473	491	<li> Extended \ref convolveImage() (non-separable convolution)

542	560	"metaprogramming.hxx", "tuple.hxx". "utilities.hxx" now includes
543	561	these other files.
544	562
545		<li> Added \ref MultiDimensionalArrays and \ref VolumeImpex
	563	<li> Added multi-dimensional arrays and \ref VolumeImpex
546	564
547	565	<li> Redesigned \ref vigra::TinyVector, added \ref vigra::TinyVectorView
548	566	</ul>

588	606	<li> Added \ref FourierTransform "Fourier transform" support,
589	607	and \ref vigra::FFTWComplex "FFTWComplex" complex number type.
590	608
591		<li> Added convolution convenience functions (see \ref CommonConvolutionFilters).
	609	<li> Added convolution convenience functions (see \ref ConvolutionFilters).
592	610
593	611	<li> Added \ref vigra::IteratorAdaptor template for quick and
594	612	easy generation of iterator adaptors.

+155

-0

docsrc/documents/CollapsibleLists.js less more

	0	/*
	1
	2	CollapsibleLists.js
	3
	4	An object allowing lists to dynamically expand and collapse
	5
	6	Created by Stephen Morley - http://code.stephenmorley.org/ - and released under
	7	the terms of the CC0 1.0 Universal legal code:
	8
	9	http://creativecommons.org/publicdomain/zero/1.0/legalcode
	10
	11	*/
	12
	13	// create the CollapsibleLists object
	14	var CollapsibleLists =
	15	new function(){
	16
	17	/* Makes all lists with the class 'collapsibleList' collapsible. The
	18	* parameter is:
	19	*
	20	* doNotRecurse - true if sub-lists should not be made collapsible
	21	*/
	22	this.apply = function(doNotRecurse){
	23
	24	// loop over the unordered lists
	25	var uls = document.getElementsByTagName('ul');
	26	for (var index = 0; index < uls.length; index ++){
	27
	28	// check whether this list should be made collapsible
	29	if (uls[index].className.match(/(^\| )collapsibleList( \|$)/)){
	30
	31	// make this list collapsible
	32	this.applyTo(uls[index], true);
	33
	34	// check whether sub-lists should also be made collapsible
	35	if (!doNotRecurse){
	36
	37	// add the collapsibleList class to the sub-lists
	38	var subUls = uls[index].getElementsByTagName('ul');
	39	for (var subIndex = 0; subIndex < subUls.length; subIndex ++){
	40	subUls[subIndex].className += ' collapsibleList';
	41	}
	42
	43	}
	44
	45	}
	46
	47	}
	48
	49	};
	50
	51	/* Makes the specified list collapsible. The parameters are:
	52	*
	53	* node - the list element
	54	* doNotRecurse - true if sub-lists should not be made collapsible
	55	*/
	56	this.applyTo = function(node, doNotRecurse){
	57
	58	// loop over the list items within this node
	59	var lis = node.getElementsByTagName('li');
	60	for (var index = 0; index < lis.length; index ++){
	61
	62	// check whether this list item should be collapsible
	63	if (!doNotRecurse \|\| node == lis[index].parentNode){
	64
	65	// prevent text from being selected unintentionally
	66	if (lis[index].addEventListener){
	67	lis[index].addEventListener(
	68	'mousedown', function (e){ e.preventDefault(); }, false);
	69	}else{
	70	lis[index].attachEvent(
	71	'onselectstart', function(){ event.returnValue = false; });
	72	}
	73
	74	// add the click listener
	75	if (lis[index].addEventListener){
	76	lis[index].addEventListener(
	77	'click', createClickListener(lis[index]), false);
	78	}else{
	79	lis[index].attachEvent(
	80	'onclick', createClickListener(lis[index]));
	81	}
	82
	83	// close the unordered lists within this list item
	84	toggle(lis[index]);
	85
	86	}
	87
	88	}
	89
	90	};
	91
	92	/* Returns a function that toggles the display status of any unordered
	93	* list elements within the specified node. The parameter is:
	94	*
	95	* node - the node containing the unordered list elements
	96	*/
	97	function createClickListener(node){
	98
	99	// return the function
	100	return function(e){
	101
	102	// ensure the event object is defined
	103	if (!e) e = window.event;
	104
	105	// find the list item containing the target of the event
	106	var li = (e.target ? e.target : e.srcElement);
	107	while (li.nodeName != 'LI') li = li.parentNode;
	108
	109	// toggle the state of the node if it was the target of the event
	110	if (li == node) toggle(node);
	111
	112	};
	113
	114	}
	115
	116	/* Opens or closes the unordered list elements directly within the
	117	* specified node. The parameter is:
	118	*
	119	* node - the node containing the unordered list elements
	120	*/
	121	function toggle(node){
	122
	123	// determine whether to open or close the unordered lists
	124	var open = node.className.match(/(^\| )collapsibleListClosed( \|$)/);
	125
	126	// loop over the unordered list elements with the node
	127	var uls = node.getElementsByTagName('ul');
	128	for (var index = 0; index < uls.length; index ++){
	129
	130	// find the parent list item of this unordered list
	131	var li = uls[index];
	132	while (li.nodeName != 'LI') li = li.parentNode;
	133
	134	// style the unordered list if it is directly within this node
	135	if (li == node) uls[index].style.display = (open ? 'block' : 'none');
	136
	137	}
	138
	139	// remove the current class from the node
	140	node.className =
	141	node.className.replace(
	142	/(^\| )collapsibleList(Open\|Closed)( \|$)/, '');
	143
	144	// if the node contains unordered lists, set its class
	145	if (uls.length > 0){
	146	node.className += ' collapsibleList' + (open ? 'Open' : 'Closed');
	147	}
	148	else {
	149	node.className += ' lastItem';
	150	}
	151
	152	}
	153
	154	}();

docsrc/documents/blockwise-watersheds-slides.pdf less more

Binary diff not shown

docsrc/documents/diamond.gif less more

Binary diff not shown

+24

-2

docsrc/header.html less more

4	4	<link rel="shortcut icon" href="vigra-icon.ico" />
5	5	<script type="text/javascript">
6	6	function toggleHiddenDocumentation( textID, toggleID, toggleMessage )
7		{
	7	{
8	8	if( document.getElementById(textID).style.display == 'none' )
9	9	{
10	10	document.getElementById(textID).style.display = 'block';

18	18	return false;
19	19	}
20	20	</script>
	21	<script>
	22	var runOnLoad=function(c,o,d,e){function x(){for(e=1;c.length;)c.shift()()}o[d]?(document[d]('DOMContentLoaded',x,0),o[d]('load',x,0)):o.attachEvent('onload',x);return function(t){e?o.setTimeout(t,0):c.push(t)}}([],window,'addEventListener');
	23	</script>
	24	<script type="text/javascript" src="documents/CollapsibleLists.js"></script>
	25	<script type="text/javascript">
	26	runOnLoad(function(){ CollapsibleLists.apply(); });
	27	</script>
	28	<style type="text/css">
	29	.collapsibleList li.collapsibleListOpen{
	30	list-style-image:url('documents/pfeil.gif');
	31	cursor:pointer;
	32	}
	33
	34	.collapsibleList li.collapsibleListClosed{
	35	list-style-image:url('documents/bullet.gif');
	36	cursor:pointer;
	37	}
	38
	39	.collapsibleList li.lastItem{
	40	list-style-image:url('documents/diamond.gif');
	41	}
	42	</style>
21	43	</head>
22	44	<body bgcolor="#f8f0e0" link="#0040b0" vlink="#a00040">
23	45	<basefont face="Helvetica,Arial,sans-serif" size=3>
24	46	<p align=right>
25		[ <a href="http://hci.iwr.uni-heidelberg.de/vigra/">VIGRA Homepage</a> \|
	47	[ <a href="http://ukoethe.github.io/vigra/">VIGRA Homepage</a> \|
26	48	<a href="functionindex.html">Function Index</a> \|
27	49	<a href="classes.html">Class Index</a> \|
28	50	<a href="namespaces.html">Namespaces</a> \|

+378

-90

docsrc/image_processing.dxx less more

0	0	/** \page ImageProcessingTutorial Image Processing
1	1
2	2	<h2>Section Contents</h2>
3
	3
4	4	In this chapter we'll use VIGRA's methods for some applications of Image Processing.
5	5
6		<ul style="list-style-image:url(documents/bullet.gif)">
	6	<ul style="list-style-image:url(documents/diamond.gif)">
7	7	<li> \ref CallingConventions
8	8	<li> \ref ImageInversion
9	9	<li> \ref ImageBlending
10	10	<li> \ref CompositeImage
11	11	<li> \ref SmoothingTutorial
12		<ul type="disc">
	12	<ul>
13	13	<li> \ref Convolve2DTutorial
14	14	<li> \ref SeparableConvolveTutorial
	15	<li> \ref ParallelConvolveTutorial
15	16	</ul>
16	17	</ul>
17	18
18	19	\section CallingConventions Calling Conventions
19
	20
20	21	VIGRA's image processing functions follow a uniform calling convention: The argument list start with the input images or arrays, followed by the output images or arrays, followed by the function's parameters (if any). Some functions additionally accept an option object that allows more fine-grained control of the function's actions and must be passed as the last argument. Most functions assume that the output arrays already have the appropriate shape.
21
	22
22	23	All functions working on arrays expect their arguments to be passed as \ref vigra::MultiArrayView instances. Functions that only support 2-dimensional images usually contain the term "Image" in their name, whereas functions that act on arbitrary many dimensions usually contain the term "Multi" in their name. <br/>
23		Examples:
	24	Examples:
24	25	\code
25	26	// determine the connected components in a binary image, using the 8-neighborhood
26	27	MultiArray<2, UInt8> image(width, height);
27	28	MultiArray<2, UInt32> labels(width, height);
28	29	... // fill image
29	30	labelImage(image, labels, true);
30
	31
31	32	// smooth a 3D array with a gaussian filter with sigma=2.0
32	33	MultiArray<3, float> volume(Shape3(300, 200, 100)),
33	34	smoothed(Shape3(300, 200, 100));
34	35	... // fill volume
35	36	gaussianSmoothMultiArray(volume, smoothed, 2.0);
36
	37
37	38	// compute the determinant of a 5x5 matrix
38	39	MultiArray<2, float> matrix(Shape2(5, 5));
39	40	... // fill matrix with data
40	41	float det = linalg::determinant(matrix);
41	42	\endcode
42
	43
43	44	For historical reasons, VIGRA also supports two alternative APIs in terms of iterators. These APIs used to be considerably faster, but meanwhile compilers and processors have improved to the point where the much simpler MultiArrayView API no longer imposes a significant abstraction penalty. While there are no plans to remove support for the old APIs, they should not be used in new code.
44
	45
45	46	<ul>
46	47	<li> Functions on 2-dimensional images may support an \ref ImageIterators API. These iterators are best passed to the functions via the convenience functions <tt>srcImageRange(array)</tt>, <tt>srcImage(array)</tt>, and <tt>destImage(array)</tt>. A detailed description of the convenience functions can be found in section \ref ArgumentObjectFactories. Example:
47	48	\code

51	52	... // fill input with data
52	53	transformImage(srcImageRange(input), destImage(result), &sqrt); // deprecated API
53	54	\endcode
54
	55
55	56	<li> Functions for arbitrary-dimensional arrays may support hierarchical \ref MultiIteratorPage. These iterators are best passed to the functions via the convenience functions <tt>srcMultiArrayRange(array)</tt>, <tt>srcMultiArray(array)</tt>, and <tt>destMultiArray(array)</tt>. A detailed description of these convenience functions can also be found in section \ref ArgumentObjectFactories. Example:
56	57	\code
57	58	// compute the element-wise square root of a 4-dimensional array

60	61	... // fill input with data
61	62	transformMultiArray(srcMultiArrayRange(input), destMultiArray(result), &sqrt); // deprecated API
62	63	\endcode
63
	64
64	65	\section ImageInversion Inverting an Image
65
66		Inverting an (gray scale) image is quite easy. We just need to subtract every pixel's
67		value from white (255). This simple task doesn't need an explicit function call at all, but is best solved with a arithmetic expression implemented in namespace \ref MultiMathModule. To avoid possible overload ambiguities,
	66
	67	Inverting an (gray scale) image is quite easy. We just need to subtract every pixel's
	68	value from white (255). This simple task doesn't need an explicit function call at all, but is best solved with a arithmetic expression implemented in namespace \ref MultiMathModule. To avoid possible overload ambiguities,
68	69	you must explicitly activate array arithmetic via the command <tt>using namespace vigra::multi_math</tt> before use. To invert <tt>imageArray</tt> and overwrite its original contents, you write:
69	70
70	71	\code

84	85	</Table>
85	86
86	87	\section ImageBlending Image Blending
87
88		In this example, we have two input images and want to blend them into one another.
	88
	89	In this example, we have two input images and want to blend them into one another.
89	90	In the combined output image every pixel value is the mean of the two appropriate original pixels. This is also best solved with array arithmetic:
90	91
91	92	\code

94	95	\endcode
95	96
96	97	Since it is not guaranteed that the two input images have the same shape, we first
97		determine the maximum possible shape of the blended image, which equals the minimum
98		size along each axis. With the help of subarray-method we just blend the appropriate
99		parts of the two images. These parts (subimages) are aligned around the centers
	98	determine the maximum possible shape of the blended image, which equals the minimum
	99	size along each axis. With the help of subarray-method we just blend the appropriate
	100	parts of the two images. These parts (subimages) are aligned around the centers
100	101	of the original images.
101	102
102	103	Here's the code:

112	113	</table>
113	114
114	115	\section CompositeImage Creating a Composite Image
115
116		Let's come to a little gimmick. Given one input image we want to create a composite image
	116
	117	Let's come to a little gimmick. Given one input image we want to create a composite image
117	118	of 4 images reflected with respect to each other. The result resembles the effect of a
118		kaleidoscope. Two of VIGRA's functions are sufficient for this purpose: \ref MultiArray_subarray
119		and \ref reflectImage(). Input and output images of reflectImage() are specified by MultiArrayViews.
	119	kaleidoscope. Two of VIGRA's functions are sufficient for this purpose: \ref MultiArray_subarray
	120	and \ref reflectImage(). Input and output images of reflectImage() are specified by MultiArrayViews.
120	121	The third parameter specifies the desired reflection axis. The axis can either
121	122	be horizontal, vertical or both (as in this example):
122	123

136	137	</Table>
137	138
138	139	\section SmoothingTutorial Smoothing
139
	140
140	141	\subsection Convolve2DTutorial 2-dimensional Convolution
141
142		There are many different ways to smooth an image. Before we use VIGRA's methods, we
143		want to write a smoothing code of our own. The idea is to choose each pixel in turn and
	142
	143	There are many different ways to smooth an image. Before we use VIGRA's methods, we
	144	want to write a smoothing code of our own. The idea is to choose each pixel in turn and
144	145	replace it with the mean of itself and the pixels in 5x5 window around it.
145		To calculate the mean in a window, we can just devide the sum of the pixel values
146		within the corresponding subarray by their number. MultiArrayView provides two useful
147		methods for doing this: <tt>sum</tt> and <tt>size</tt>.
148		In our code we iterate over every pixel, construct the surrounding 5x5 window via
	146	To calculate the mean in a window, we can just devide the sum of the pixel values
	147	within the corresponding subarray by their number. MultiArrayView provides two useful
	148	methods for doing this: <tt>sum</tt> and <tt>size</tt>.
	149	In our code we iterate over every pixel, construct the surrounding 5x5 window via
149	150	<tt>subarray</tt>, and write the average of the window into the corresponding output pixel.
150	151	Near the borders of the image we truncate the window appropriately so that it remains
151	152	inside the image, and only take the average over the actually existing neighbours of the pixel.

161	162	</TR>
162	163	</Table>
163	164
164		The technical term for this kind of operation is <i>convolution</i>. VIGRA provides
165		<dfn>convolveImage</dfn> as a comfortable way to perform 2-dimensional convolutions
	165	The technical term for this kind of operation is <i>convolution</i>. VIGRA provides
	166	<dfn>convolveImage</dfn> as a comfortable way to perform 2-dimensional convolutions
166	167	with arbitrary filters. You may use it as follows:
167	168
168	169	\code

170	171	\endcode
171	172
172	173	The filter of <i>convolution kernel</i> is given as argument object by <dfn>kernel2d()</dfn>.
173		To implement the above smoothing by taking averages in 3x3 windows, you need an averaging
174		kernel with radius 1. Kernel truncation near the image borders is performed when the
	174	To implement the above smoothing by taking averages in 3x3 windows, you need an averaging
	175	kernel with radius 1. Kernel truncation near the image borders is performed when the
175	176	filter's border treatment mode is set to <tt>BORDER_TREATMENT_CLIP</tt>:
176
	177
177	178	\code
178	179	Kernel2D<double> filter;
179	180	filter.initAveraging(1);
180	181	filter.setBorderTreatment(BORDER_TREATMENT_CLIP);
181	182	\endcode
182
	183
183	184	By default, VIGRA's convolution functions use <tt>BORDER_TREATMENT_REFLECT</tt> (i.e. the
184	185	image is virtually enlarged by reflecting the pixel values about the border), which usually
185		leads to superior results. The strength of smoothing can be controlled by increasing the filter
	186	leads to superior results. The strength of smoothing can be controlled by increasing the filter
186	187	radius.
187
188		Another improvement over simple averaging can be achieved when one takes a <i>weighted
	188
	189	Another improvement over simple averaging can be achieved when one takes a <i>weighted
189	190	average</i> such that pixels near the center have more influence on the result.
190	191	A popular choice here is the 5x5 binomial filter. VIGRA allows to specify arbitrary filter
191	192	shapes and coefficients via the <tt>Kernel2D::initExplicitly()</tt>:
192
	193
193	194	\code
194	195	Kernel2D<float> filter;
195
	196
196	197	// specify filter shape (lower right corner is inclusive here!)
197	198	filter.initExplicitly(Shape2(-2,-2), Shape2(2,2));
198
	199
199	200	// specify filter coefficients
200	201	filter = 1.0/256.0, 4.0/256.0, 6.0/256.0, 4.0/256.0, 1.0/256.0,
201	202	4.0/256.0, 16.0/256.0, 24.0/256.0, 16.0/256.0, 4.0/256.0,
202	203	6.0/256.0, 24.0/256.0, 36.0/256.0, 24.0/256.0, 6.0/256.0,
203	204	4.0/256.0, 16.0/256.0, 24.0/256.0, 16.0/256.0, 4.0/256.0,
204	205	1.0/256.0, 4.0/256.0, 6.0/256.0, 4.0/256.0, 1.0/256.0;
205
	206
206	207	// apply filter
207	208	convolveImage(inputImage, resultImage, filter);
208	209	\endcode
209
210		<tt>initExplicitly()</tt> receives the upper left and lower right corners of the
	210
	211	<tt>initExplicitly()</tt> receives the upper left and lower right corners of the
211	212	filter window. Note that the lower right corner here is <i>included</i> in the window,
212		in contrast to <tt>MultiArray::subarray()</tt> where the end point is not included.
213
214		The filter weights are provided in a comma separated list. Normally, the sum of the
215		coefficients should to be 1 in order to preserve the average intensity of the image.
216		You must provide either as many coefficients as needed for the given filter size,
217		or exactly one value which will be used for all filter coefficients. Thus, the 3x3
	213	in contrast to <tt>MultiArray::subarray()</tt> where the end point is not included.
	214
	215	The filter weights are provided in a comma separated list. Normally, the sum of the
	216	coefficients should to be 1 in order to preserve the average intensity of the image.
	217	You must provide either as many coefficients as needed for the given filter size,
	218	or exactly one value which will be used for all filter coefficients. Thus, the 3x3
218	219	averaging filter can also be created like this:
219
	220
220	221	\code
221	222	Kernel2D<double> filter;
222	223	filter.initExplicitly(Shape2(-1,-1), Shape2(1,1)) = 1.0/9.0;
223	224	\endcode
224	225
225	226	For various theoretical and practical reasons, the Gaussian filter is the best choice
226		in most situations. Its coefficients are chosen according to a Gaussian (i.e.
227		bell-shaped) function with given standard deviation. The kernel class has a
228		convenient <dfn>initGaussian(std_dev)</dfn> method that creates the appropriate
	227	in most situations. Its coefficients are chosen according to a Gaussian (i.e.
	228	bell-shaped) function with given standard deviation. The kernel class has a
	229	convenient <dfn>initGaussian(std_dev)</dfn> method that creates the appropriate
229	230	coefficients:
230	231
231	232	\code
232		vigra::Kernel2D<float> filter;
	233	vigra::Kernel2D<float> filter;
233	234	filter.initGaussian(1.5);
234	235	convolveImage(inputImage, resultImage, filter);
235	236	\endcode
236
	237
237	238	A complete example using these possibilities can be found in <a href="smooth_convolve_8cxx-example.html">smooth_convolve.cxx</a>.
238	239
239	240	<hr>
240	241
241	242	\subsection SeparableConvolveTutorial Separable Convolution in 2D and nD Images
242
243		When filtering is implemented with 2-dimensional windows as in the previous section,
244		we need as many multiplications per pixel as there are coefficients in the filter.
245		Fortunately, many important filters (including averaging and Gaussian smoothing)
246		have the property of beeing <i>separable</i>, which allows a much more efficient
247		implementation in terms of 1-dimensional windows. A 2-dimensional filter is
248		separable if its coefficients \f$f_{ij}\f$ can be expressend as an outer product
	243
	244	When filtering is implemented with 2-dimensional windows as in the previous section,
	245	we need as many multiplications per pixel as there are coefficients in the filter.
	246	Fortunately, many important filters (including averaging and Gaussian smoothing)
	247	have the property of beeing <i>separable</i>, which allows a much more efficient
	248	implementation in terms of 1-dimensional windows. A 2-dimensional filter is
	249	separable if its coefficients \f$f_{ij}\f$ can be expressend as an outer product
249	250	of two 1-dimensional filters \f$h_i\f$ and \f$c_j\f$:
250	251
251	252	\f[
252	253	f_{ij} = h_i \cdot c_j
253	254	\f]
254
255		For example, the 3x3 averaging filter (with coefficients 1/9) is obtained as the outer
	255
	256	For example, the 3x3 averaging filter (with coefficients 1/9) is obtained as the outer
256	257	product of two 3x1 filters (with coefficients 1/3):
257
258		\f[ \left( \begin{array}{ccc} \frac{1}{9} & \frac{1}{9} & \frac{1}{9} \\[1ex]
259		\frac{1}{9} & \frac{1}{9} & \frac{1}{9} \\[1ex]
260		\frac{1}{9} & \frac{1}{9} & \frac{1}{9} \end{array} \right) =
	258
	259	\f[ \left( \begin{array}{ccc} \frac{1}{9} & \frac{1}{9} & \frac{1}{9} \\[1ex]
	260	\frac{1}{9} & \frac{1}{9} & \frac{1}{9} \\[1ex]
	261	\frac{1}{9} & \frac{1}{9} & \frac{1}{9} \end{array} \right) =
261	262	\left( \begin{array}{c} \frac{1}{3} \\[1ex] \frac{1}{3} \\[1ex] \frac{1}{3} \end{array} \right) \cdot
262	263	\left( \begin{array}{ccc} \frac{1}{3} & \frac{1}{3} & \frac{1}{3} \end{array} \right)
263	264	\f]
264
	265
265	266	The convolution with separable filters can be implemented by two consecutive 1-dimensional
266	267	convolutions: first, one filters all rows of the image with the horizontal filter, and then
267	268	all columns of the result with the vertical filter. Instead of the (n x m) operations required
268	269	for a 2-dimensional window, we now only need (n + m) operations for the two 1-dimensional ones.
269	270	Already for a 5x5 window, this reduces the number of operations from 25 to 10, and the difference
270	271	becomes even bigger with increasing window size.
271
	272
272	273	To construct and apply 1-dimensional filters, VIGRA provides the class \ref vigra::Kernel1D and
273	274	the functions separableConvolveX() resp. separableConvolveY(). To compute a 2D Gaussian filter
274	275	we use the following code:
275	276
276	277	\code
277		Kernel1D<double> filter;
	278	Kernel1D<double> filter;
278	279	filter.initGaussian(1.5);
279
	280
280	281	MultiArray<2, float> tmpImage(inputImage.shape());
281	282	separateConvolveX(inputImage, tmpImage, filter);
282	283	separateConvolveY(tmpImage, resultImage, filter);

286	287	The same result is more conveniently achieved by the functions \ref convolveImage() and
287	288	\ref gaussianSmoothing() (see <a href="smooth_convolve_8cxx-example.html">smooth_convolve.cxx</a>
288	289	for a working example):
289
290		\code
291		// apply 'filter' to both the x- and y-axis
	290
	291	\code
	292	// apply 'filter' to both the x- and y-axis
292	293	// (calls separateConvolveX() and separateConvolveY() internally)
293	294	convolveImage(inputImage, resultImage, filter, filter);
294
	295
295	296	// smooth image with Gaussian filter with sigma=1.5
296	297	// (calls convolveImage() with Gaussian filter internally)
297	298	gaussianSmoothing(inputImage, resultImage, 1.5);
298	299	\endcode
299	300
300		It is, of course, also possible to apply different filters in the x- and y-directions.
	301	It is, of course, also possible to apply different filters in the x- and y-directions.
301	302	This is especially useful for derivative filters which are commonly used to compute
302	303	image features, for example \ref gaussianGradient() and \ref gaussianGradientMagnitude().
303		For more information see \ref CommonConvolutionFilters and \ref Convolution.
304
	304	For more information see \ref ConvolutionFilters.
	305
305	306	Separable filters are also the key for efficient convolution of higher-dimensional images
306		and arrays: An n-dimensional filter is simply implemented by n consecutive 1-dimensional
307		filter applications, regardsless of the size of n. This is the basis for VIGRA's
	307	and arrays: An n-dimensional filter is simply implemented by n consecutive 1-dimensional
	308	filter applications, regardless of the size of n. This is the basis for VIGRA's
308	309	multi-dimensional filter functions. For example, Gaussian smoothing in arbitrary many
309	310	dimensions is implemented in \ref gaussianSmoothMultiArray():
310
	311
311	312	\code
312	313	MultiArray<3, UInt8> inputArray(Shape3(100, 100, 100));
313	314	... // fill inputArray with data
314
	315
315	316	MultiArray<3, float> resultArray(inputArray.shape());
316
	317
317	318	// perform isotropic Gaussian smoothing at scale 1.5
318	319	gaussianSmoothMultiArray(inputArray, resultArray, 1.5);
319	320	\endcode
320
	321
321	322	More information about VIGRA's multi-dimensional convolution funcions can be found in
322		the reference manual under \ref MultiArrayConvolutionFilters .
	323	the reference manual under \ref ConvolutionFilters.
	324
	325	\subsection ParallelConvolveTutorial Parallel Execution of Gaussian Filters
	326
	327	The computation of Gaussian filters and their derivatives can be accelerated significantly
	328	when rectangular blocks of a large image as processed in parallel.
	329	This is easily achieved in VIGRA by passing the option object
	330	\ref vigra::BlockwiseConvolutionOptions to the convolution functions:
	331
	332	\code
	333	// create a big array
	334	MultiArray<3, UInt8> inputArray(Shape3(1000, 1000, 100));
	335	... // fill inputArray with data
	336
	337	MultiArray<3, float> resultArray(inputArray.shape());
	338
	339	// perform isotropic Gaussian smoothing at scale 1.5 in parallel
	340	gaussianSmoothMultiArray(inputArray, resultArray, 1.5,
	341	BlockwiseConvolutionOptions<3>());
	342	\endcode
	343
	344	This call will spawn the standard number of threads for the present platform
	345	(as returned by <tt>std::thread::hardware_concurrency()</tt>) and distributes
	346	the work across these threads in blocks with a suitable default shape.
	347	You can customize the number of threads and the block shape via the option
	348	object:
	349
	350	\code
	351	gaussianSmoothMultiArray(inputArray, resultArray, 1.5,
	352	BlockwiseConvolutionOptions<3>().numThreads(6)
	353	.blockShape(Shape3(128, 128, 100)));
	354	\endcode
	355
	356	The same works for Gaussian derivative filters such as \ref gaussianGradientMultiArray(),
	357	\ref gaussianGradientMagnitude(), and \ref hessianOfGaussianMultiArray(). Refer to section
	358	\ref ConvolutionFilters for more details.
323	359	*/
324	360
325	361	/** \example invert_tutorial.cxx

351	387	<br>
352	388	Usage: <TT>smooth_convolve infile outfile</TT>
353	389	*/
	390
	391	/** \page ImageSegmentationTutorial Image Segmentation
	392
	393	<h2>Section Contents</h2>
	394
	395	<ul style="list-style-image:url(documents/diamond.gif)">
	396	<li> \ref SuperpixelsTutorial
	397	<li> \ref RAGTutorial
	398	<li> \ref ClusteringTutorial
	399	</ul>
	400
	401	The complete code of the example described here can be found in <a href="graph_agglomerative_clustering_8cxx-example.html">graph_agglomerative_clustering.cxx</a>.
	402
	403	\section SuperpixelsTutorial Computing Superpixels
	404
	405	Hierarchical or agglomerative clustering can be applied either to the pixels directly
	406	by using a \ref vigra::GridGraph, or on an initial oversegmentation into superpixels
	407	whose region adjacency graph is represented in a \ref vigra::AdjacencyListGraph. We
	408	describe the second variant here, as it offers more possibilities, but the first
	409	works essentially in the same way.
	410
	411	Before computing superpixels, it is useful to transform the data from the RGB colorspace
	412	into the Lab colorspace, because distances in the Lab space are perceptually more meaningful:
	413
	414	\code
	415	// read the input image
	416	ImageImportInfo info(filename);
	417	MultiArray<2, TinyVector<float, 3> > imageArrayRGB(info.shape());
	418	importImage(info, imageArrayRGB);
	419
	420	// convert into Lab color space
	421	MultiArray<2, TinyVector<float, 3> > imageArrayLab(imageArrayRGB.shape());
	422	transformMultiArray(imageArrayRGB, imageArrayLab, RGB2LabFunctor<float>());
	423	\endcode
	424
	425	VIGRA offers two superpixel algorithms: watersheds and SLIC superpixels. We use
	426	the watershed algorithm here, see \ref slicSuperpixels() for more information on
	427	the alternative. To run the watershed algorithm, we first need an edge indicator
	428	(i.e. an image with big values along edges and small values elsewhere) like the
	429	gradient magnitude:
	430
	431	\code
	432	// detect edges by the Gaussian gradient magnitude
	433	MultiArray<2, float> gradMag(imageArrayLab.shape());
	434
	435	float sigmaGradMag = 3.0f;
	436	gaussianGradientMagnitude(imageArrayLab, gradMag, sigmaGradMag);
	437	\endcode
	438
	439	<Table cellspacing = "10">
	440	<TR valign = "bottom">
	441	<TD> \image html bears.jpg "input image" </TD>
	442	<TD> \image html bears_gradient.png "gradient magnitude" </TD>
	443	</TR>
	444	</Table>
	445
	446	The watershed algorithm initiates a superpixel at every local minimum of the gradient
	447	image and then grows these seeds along increasing gradients until they meet at the
	448	gradient ridges (called "watersheds" because we can interpret the gradient as the
	449	altitude of a landscape) which partly correspond to true image edges, but are also located
	450	elsewhere. The goal of the subsequent hierarchical clustering is to identify the
	451	true edges and delete the spurious ones. The superpixels are represented in a label
	452	image that assigns the superpixel ID to every pixel. To visualize the superpixels,
	453	it is useful to display the watershed lines as an overlay on an enlarged version
	454	of the input image (Enlarging the image is necessary because the watersheds are
	455	actually between pixels, i.e. at half-integer coordinates. Doubling maps these
	456	to odd-valued coordinates in the enlarged image, so that rounding is avoided.).
	457	In this example, we use the fast union-find watershed algorithm, which is also
	458	available in a parallel version in function \ref unionFindWatershedsBlockwise():
	459
	460	\code
	461	// create watershed superpixels with the fast union-find algorithm
	462	MultiArray<2, unsigned int> labelArray(gradMag.shape());
	463	unsigned int max_label = watershedsMultiArray(gradMag, labelArray, DirectNeighborhood,
	464	WatershedOptions().unionFind());
	465
	466	// double the image resolution and create watershed overlay
	467	MultiArray<2, TinyVector<float, 3> > imageArrayBig(imageArrayRGB.shape()*2-Shape2(1));
	468	resizeMultiArraySplineInterpolation(imageArrayRGB, imageArrayBig);
	469	regionImageToCrackEdgeImage(labelArray, imageArrayBig,
	470	RGBValue<float>(255, 0, 0), EdgeOverlayOnly);
	471	\endcode
	472
	473	\image html bears_superpixels.png
	474
	475	\section RAGTutorial Constructing the Region Adjacency Graph and its Feature Maps
	476
	477	Next, we invoke \ref makeRegionAdjacencyGraph() to construct the region adjacency
	478	graph (RAG) of the superpixels. This function takes any graph along with a connected
	479	components labeling and creates a new graph that has exactly one node per connected
	480	component, and nodes are connected by an edge whenever the corresponding components are
	481	neighbors in the original graph, i.e. the original graph contains at least one edge
	482	with one end point in the first and the other in the second component. In general,
	483	each pair of components has several edges with this property, and all of them are
	484	mapped onto a single edge in the RAG. To keep track of this mapping,
	485	makeRegionAdjacencyGraph() accepts an additional parameter \a affiliatedEdges, which
	486	is a map from edge IDs in the RAG to vectors of edge IDs in the original graph.
	487	In our case, the input graph is a \ref vigra::GridGraph whose labeling is stored
	488	in the \a labelArray, and the output graph is a \ref vigra::AdjacencyListGraph.
	489	The mapping \a affiliatedEdges is best constructed by using embedded types of
	490	these graph classes:
	491
	492	\code
	493	// create grid-graph of appropriate size
	494	typedef GridGraph<2, undirected_tag> ImageGraph;
	495	ImageGraph imageGraph(labelArray.shape());
	496
	497	// construct an empty graph to hold the region adjacency graph for the superpixels
	498	typedef AdjacencyListGraph RAG;
	499	RAG rag;
	500
	501	// create the mapping 'affiliatedEdges' from RAG edges to
	502	// corresponding imageGraph edges and build the RAG
	503	RAG::EdgeMap<std::vector<ImageGraph::Edge>> affiliatedEdges(rag);
	504	makeRegionAdjacencyGraph(imageGraph, labelArray, rag, affiliatedEdges);
	505	\endcode
	506
	507	Note that VIGRA's graph classes conform to the elegant API defined in the
	508	<a href="https://lemon.cs.elte.hu/">LEMON Graph Library</a>. Although VIGRA
	509	doesn't use LEMON's implementation of this API, it is worth reading their
	510	<a href="http://lemon.cs.elte.hu/pub/tutorial/index.html">tutorial</a>
	511	because VIGRA's graph classes behave in exactly the same way.
	512
	513	To control agglomerative clustering, i.e. to define the order in which
	514	edges are contracted and nodes merged, we need some features that describe
	515	the dissimilarity of superpixels. The more dissimilar two superpixels are,
	516	the more likely they will remain separated, i.e. belong to different regions
	517	of the final segmentation. We distinguish two kinds of features: edge weights
	518	and node features.
	519
	520	Edge weights should be high when two superpixels are separated by an object
	521	edge, i.e. when the gradient magnitude along the common superpixel boundary is high.
	522	We define the edge weight as the average gradient magnitude along the boundary,
	523	i.e. as the average over the grid edges that correspond to the present RAG edge.
	524	However, as pointed out earlier, watershed boundaries are located between pixels,
	525	i.e. on half-integer coordinates, whereas the gradient has been computed on pixels,
	526	i.e. at integer coordinates. We solve this problem by linear interpolation: the
	527	gradient of a grid edge is the average gradient of its two end points.
	528
	529	\code
	530	// create edge maps for weights and lengths of the RAG edges (zero initialized)
	531	RAG::EdgeMap<float> edgeWeights(rag),
	532	edgeLengths(rag);
	533
	534	// iterate over all RAG edges (this loop follows a standard LEMON idiom)
	535	for(RAG::EdgeIt rag_edge(rag); rag_edge != lemon::INVALID; ++rag_edge)
	536	{
	537	// iterate over all grid edges that constitute the present RAG edge
	538	for(unsigned int k = 0; k < affiliatedEdges[*rag_edge].size(); ++k)
	539	{
	540	// look up the current grid edge and its end points
	541	auto const & grid_edge = affiliatedEdges[*rag_edge][k];
	542	auto start = imageGraph.u(grid_edge),
	543	end = imageGraph.v(grid_edge);
	544
	545	// compute gradient by linear interpolation between end points
	546	double grid_edge_gradient = 0.5 * (gradMag[start] + gradMag[end]);
	547	// aggregate the total
	548	edgeWeights[*rag_edge] += grid_edge_gradient;
	549	}
	550
	551	// the length of the RAG edge equals the number of constituent grid edges
	552	edgeLengths[rag_edge] = affiliatedEdges[rag_edge].size();
	553	// define edge weights by the average gradient
	554	edgeWeights[rag_edge] /= edgeLengths[rag_edge];
	555	}
	556	\endcode
	557
	558	Node features are defined by the average Lab color of each superpixel.
	559	Hierarchical clustering will later turn this into a node dissimilarity by
	560	computing the Euclidean distance between the average colors of neighboring
	561	superpixels, possibly weighted by the superpixels' sizes. To compute these
	562	features, we invoke VIGRA's \ref FeatureAccumulators framework:
	563
	564	\code
	565	// determine size and average Lab color of each superpixel
	566	using namespace acc;
	567	AccumulatorChainArray<CoupledArrays<2, TinyVector<float, 3>, unsigned int>,
	568	Select<DataArg<1>, LabelArg<2>, // where to look for data and region labels
	569	Count, Mean> > // what statistics to compute
	570	features;
	571	extractFeatures(imageArrayLab, labelArray, features);
	572	\endcode
	573
	574	To be understood by hierarchicalClustering(), we must copy the features into
	575	node property maps which are compatible with the RAG data structure:
	576
	577	\code
	578	// copy superpixel features into NodeMaps to be passed to hierarchicalClustering()
	579	RAG::NodeMap<TinyVector<float, 3>> meanColor(rag);
	580	RAG::NodeMap<unsigned int> regionSize(rag);
	581	for(unsigned int k=0; k<=max_label; ++k) // max_label was returned from watershedsMultiArray()
	582	{
	583	meanColor[k] = get<Mean>(features, k);
	584	regionSize[k] = get<Count>(features, k);
	585	}
	586	\endcode
	587
	588	\section ClusteringTutorial Perform Hierarchical Clustering
	589
	590	Now we have collected all information needed to perform agglomerative clustering.
	591	We pass the superpixel adjacency graph and its feature maps to the clustering
	592	function, and it returns the cluster assignment in a new property map
	593	\a nodeLabels that assigns to every RAG node the ID of the cluster the node belongs
	594	to. Thus, \a nodeLabels plays exactly the same role for the RAG as \a labelArray
	595	did for the grid graph. Cluster IDs are identical to the node IDs of arbitrarly
	596	chosen cluster representatives, i.e. they form a sparse subset of the original IDs.
	597
	598	\code
	599	// customize parameters of the clustering algorithm
	600	float beta = 0.5f; // importance of node features relative to edge weights
	601	float wardness = 0.8f; // importance of cluster size
	602	int numClusters = 30; // desired number of resulting regions (clusters)
	603
	604	// create a node map for the new (clustered) region labels and perform
	605	// clustering to remove unimportant watershed edges
	606	RAG::NodeMap<unsigned int> nodeLabels(rag);
	607	hierarchicalClustering(rag, // input: the superpixel adjacency graph
	608	edgeWeights, edgeLengths, meanColor, regionSize, // features
	609	nodeLabels, // output: a cluster labeling of the RAG
	610	ClusteringOptions().minRegionCount(numClusters)
	611	.nodeFeatureImportance(beta)
	612	.sizeImportance(wardness)
	613	.nodeFeatureMetric(metrics::L2Norm)
	614	);
	615	\endcode
	616
	617	The details of the clustering algorithm can be customized by the option object
	618	\ref vigra::ClusteringOptions. Here, we set the termination criterion \a numClusters,
	619	the relative importance of node features and sizes (\a beta and \a wardness) and the
	620	norm to be used to compute node feature dissimiliarity. Option objects like this are
	621	a common idiom in the VIGRA library, because code readability matters.
	622
	623	Finally, we replace the original superpixel labels in \a labelArray with the new cluster
	624	labels from \a nodeLabels and visualize the resulting region boundaries, this time
	625	with a green overlay on the enlarged input image:
	626
	627	\code
	628	// update label image with the new labels
	629	transformMultiArray(labelArray, labelArray,
	630	[&nodeLabels](unsigned int oldlabel)
	631	{
	632	return nodeLabels[oldlabel];
	633	});
	634
	635	// visualize the salient edges as a green overlay
	636	regionImageToCrackEdgeImage(labelArray, imageArrayBig,
	637	RGBValue<float>( 0, 255, 0), EdgeOverlayOnly);
	638	\endcode
	639
	640	\image html bears_segmentation.png
	641	*/

+269

-282

docsrc/index.dxx less more

0	0	/** \mainpage VIGRA Reference Manual
1	1
2		<UL style="list-style-image:url(documents/bullet.gif)">
	2	<UL class="collapsibleList">
	3
3	4	<LI> \ref Installation
4	5	<BR>   <em>how to get started</em>
5		<LI> \ref Tutorial
	6	<LI> \ref Tutorial
6	7	<BR>   <em>first steps with VIGRA</em>
7		<LI> \ref Concepts
	8	<LI> <span style="font-weight:bold; color:#0040b0">Data Structures</span>
	9	<BR>   <em>multi-dimensional arrays, graphs, numeric types etc.</em>
	10	<UL>
	11	<LI> \ref vigra::TinyVector
	12	<BR>   <em>fixed-size arrays</em>
	13	<LI> \ref vigra::MultiArrayView
	14	<BR>   <em>multi-dimensional array interface</em>
	15	<LI> \ref vigra::MultiArray
	16	<BR>   <em>multi-dimensional array class that holds the actual memory</em>
	17	<LI> \ref vigra::NumpyArray and \ref vigra::NumpyAnyArray
	18	<BR>   <em>wrappers offering VIGRA's multi-array API for Python arrays</em>
	19	<LI> \ref vigra::linalg::Matrix
	20	<BR>   <em>array specialization for linear algebra</em>
	21	<LI> \ref ImageContainers
	22	<BR>   <em>classes to manage multiple images and pyramids</em>
	23	<LI> \ref vigra::SplineImageView
	24	<BR>   <em>on-the-fly interpolation of 2D images and their derivatives</em>
	25	<LI> \ref ChunkedArrayClasses
	26	<BR>   <em>big data (potentially larger than RAM) stored as a collection of rectangular blocks</em>
	27	<LI> \ref vigra::AdjacencyListGraph
	28	<BR>   <em>general graph class</em>
	29	<LI> \ref vigra::GridGraph
	30	<BR>   <em>direct and indirect neighbor graphs on arbitrary dimensional grids</em>
	31	<LI> \ref vigra::BinaryForest
	32	<BR>   <em>a collection of binary trees</em>
	33	<LI> <span style="font-weight:bold; color:#0040b0">Pixel and Number Types</span>
	34	<BR>   <em>rationals, complex numbers, RGB tuples etc.</em>
	35	<UL>
	36	<LI> \ref FixedSizeInt
	37	<LI> \ref vigra::RGBValue
	38	<LI> \ref RGBValueTraits
	39	<LI> \ref vigra::TinyVector
	40	<LI> \ref vigra::TinyVectorView
	41	<LI> \ref TinyVectorTraits
	42	<LI> \ref vigra::FFTWComplex
	43	<LI> \ref FFTWComplexTraits
	44	<LI> \ref vigra::Rational
	45	<LI> \ref vigra::FixedPoint
	46	<LI> \ref vigra::FixedPoint16
	47	</UL>
	48	<LI> \ref vigra::BucketQueue and \ref vigra::MappedBucketQueue
	49	<BR>   <em>efficient priority queues for integer priorities</em>
	50	<LI> \ref vigra::Any
	51	<BR>   <em>typesafe storage of arbitrary values</em>
	52	<LI> \ref vigra::ArrayVector
	53	<BR>   <em>replacement for std::vector with stronger guarantees (deprecated as of C++ 11)</em>
	54	<LI> \ref vigra::BasicImage
	55	<BR>   <em>deprecated type for 2D images</em>
	56	<LI> \ref vigra::BasicImageView
	57	<BR>   <em>deprecated type for 2D images that use external memory</em>
	58	</UL>
	59	<LI> <span style="font-weight:bold; color:#0040b0">Image and Array I/O</span>
	60	<BR>   <em>read and write data from/to disk</em>
	61	<UL>
	62	<LI> \ref VigraImpex
	63	<BR>   <em>highlevel import/export interface for 2D images</em>
	64	<LI> \ref VolumeImpex
	65	<BR>   <em>import/export interface for volume data</em>
	66	<LI> \ref VigraHDF5Impex
	67	<BR>   <em>import/export of arbitrary-dimensional arrays in the
	68	<a href="http://www.hdfgroup.org/HDF5/">HDF5</a> format</em>
	69	<LI> \ref vigra::ChunkedArrayHDF5
	70	<BR>   <em>automated memory management of huge datasets via HDF5</em>
	71	<LI> \ref TIFFImpex
	72	<BR>   <em>image import/export interface to call libtiff functions directly</em>
	73	</UL>
	74	<LI> \ref ParallelProcessing
	75	<BR>   <em>using std::thread</em>
	76	<LI> <span style="font-weight:bold; color:#0040b0">Image Processing</span>
	77	<BR>   <em>array arithmetic, convolution filters, morphology, color conversion, registration etc.</em>
	78	<UL>
	79	<LI> \ref MultiMathModule
	80	<BR>   <em>arithmetic and algebraic expressions for multi-dimensional arrays</em>
	81	<LI> \ref MultiPointoperators
	82	<BR>   <em>point operators on multi-dimensional arrays</em>
	83	<LI> \ref ColorConversions
	84	<BR>   <em>convert between RGB and other color spaces like Luv* and Y'PbPr</em>
	85	<LI> <span style="font-weight:bold; color:#0040b0">Filters</span>
	86	<BR>   <em>Gaussian filters, smoothing and sharpening, gradients etc.</em>
	87	<UL>
	88	<LI> \ref ConvolutionFilters
	89	<BR>   <em>arbitrary-dimensional filters in the spatial and Fourier domains</em>
	90	<LI> \ref RecursiveConvolution
	91	<BR>   <em>recursive filters (1st and 2nd order)</em>
	92	<LI> \ref ResamplingConvolutionFilters
	93	<BR>   <em>filters changing the array size</em>
	94	<LI> \ref GaborFilter
	95	<BR>   <em>Gabor filter creation and related functionality</em>
	96	<LI> \ref TensorImaging
	97	<BR>   <em>tensor-valued pixel features</em>
	98	<LI> \ref vigra::Kernel1D and \ref vigra::Kernel2D
	99	<BR>   <em>generic discrete convolution kernels</em>
	100	<LI> \ref SeparableConvolution
	101	<BR>   <em>1D convolution and separable filters in 2 dimensions</em>
	102	<LI> \ref BorderTreatmentMode
	103	</UL>
	104	<LI> \ref GeometricTransformations "Geometric Transformations and Resizing"
	105	<BR>   <em>arbitrary-dimensional resize and interpolation, mirroring, rotation, affine warping</em>
	106	<LI> \ref vigra::SplineImageView
	107	<BR>   <em>on-the-fly interpolation of 2D images and their derivatives</em>
	108	<LI> \ref FourierTransform
	109	<BR>   <em>fast Fourier transform for arrays of arbitrary dimension</em>
	110	<LI> \ref Correlation
	111	<BR>   <em>estimate the correlation between images</em>
	112	<LI> \ref Registration
	113	<BR>   <em>transform images into a common coordinate system</em>
	114	<LI> \ref NonLinearDiffusion
	115	<BR>   <em>edge-preserving smoothing and denoising</em>
	116	<LI> \ref DistanceTransform
	117	<BR>   <em>distance transforms in arbitrary dimensions</em>
	118	<LI> \ref MultiArrayMorphology
	119	<BR>   <em>separable morphology with parabola structuring functions in arbitrary dimensions</em>
	120	<LI> \ref Morphology
	121	<BR>   <em>2D erosion, dilation, and median with disc structuring functions</em>
	122	<LI> \ref NoiseNormalization
	123	<BR>   <em>transform intensity-dependent noise into additive Gaussian noise</em>
	124	<LI> \ref SlantedEdgeMTF
	125	<BR>   <em>determine the magnitude transfer function (MTF) of a camera using the slanted edge method</em>
	126	</UL>
	127	<LI> <span style="font-weight:bold; color:#0040b0">Image Analysis</span>
	128	<BR>   <em>from pixels to structured data</em>
	129	<UL>
	130	<LI> \ref FeatureAccumulators
	131	<BR>   <em>computate multi-dimensional statistics for regions or hte entire image</em>
	132	<LI> \ref InspectAlgo and \ref InspectFunctor
	133	<BR>   <em>outdated statistical analysis functions</em>
	134	<LI> \ref vigra::Threshold
	135	<BR>   <em>good old thresholding</em>
	136	<LI> \ref Labeling
	137	<BR>   <em>connected components labeling</em>
	138	<LI> \ref LocalMinMax
	139	<BR>   <em>Including extremal plateaus larger than 1 pixel</em>
	140	<LI> \ref DistanceTransform
	141	<BR>   <em>including vector distance, eccentricity transforms, and skeletons</em>
	142	<LI> \ref EdgeDetection
	143	<BR>   <em>edge detectors based on first and second derivatives</em>
	144	<LI> \ref CornerDetection
	145	<BR>   <em>measure the 'cornerness' at each pixel </em>
	146	<LI> \ref SymmetryDetection
	147	<BR>   <em>measure the local symmetry at each pixel </em>
	148	<LI> \ref Superpixels
	149	<BR>   <em>watersheds, SLIC superpixels, and seeded region growing</em>
	150	<LI> \ref GraphDataStructures
	151	<BR>   <em>graph-based segmentation algorithms</em>
	152	</UL>
	153	<LI> \ref GraphDataStructures
	154	<BR>   <em>graph classes and graph-based algorithms</em>
	155	<LI> \ref MachineLearning
	156	<BR>   <em>classification algorithms</em>
	157	<LI> <span style="font-weight:bold; color:#0040b0">Mathematical Tools</span>
	158	<BR>   <em>number types, special functions, linear algebra and optimization etc.</em>
	159	<UL>
	160	<LI> \ref NumericPromotionTraits
	161	<BR>   <em>meta-information about arithmetic types</em>
	162	<LI> \ref MathConstants
	163	<BR>   <em>M_PI, M_SQRT2</em>
	164	<LI> \ref MathFunctions
	165	<BR>   <em>and functors</em>
	166	<LI> <span style="font-weight:bold; color:#0040b0">Number Types</span>
	167	<UL>
	168	<LI> \ref vigra::Rational
	169	<LI> \ref vigra::TinyVector
	170	<LI> \ref vigra::autodiff::DualVector
	171	<LI> \ref vigra::FFTWComplex
	172	<LI> \ref vigra::FixedPoint16
	173	<LI> \ref vigra::Quaternion
	174	</UL>
	175	<LI> \ref RandomNumberGeneration
	176	<BR>   <em>Mersenne twister class and random number functors</em>
	177	<LI> \ref Polynomials
	178	<BR>   <em>Polynomials and root determination</em>
	179	<LI> \ref vigra::linalg::Matrix
	180	<BR>   <em>array specialization for linear algebra</em>
	181	<LI> \ref LinearAlgebraModule "Linear Algebra"
	182	<BR>   <em>matrix algebra, solution of linear systems, eigenvalue calculation etc.</em>
	183	<LI> \ref Unsupervised_Decomposition "Unsupervised Decomposition"
	184	<BR>   <em>Unsupervised matrix decomposition methods (pLSA)</em>
	185	<LI> \ref Optimization "Optimization and Regression"
	186	<BR>   <em>ordinary and non-negative least squares, ridge regression, least angle regression (LARS and LASSO)</em>
	187	<LI> \ref AlgebraicConcepts
	188	<BR>   <em>Requirements for types that implement arithmetic operations</em>
	189	</UL>
	190	<LI> <span style="font-weight:bold; color:#0040b0">Utilities</span>
	191	<BR>   <em>error handling, speed measurement</em>
	192	<UL>
	193	<LI> \ref ErrorReporting
	194	<BR>   <em>exceptions and assertions</em>
	195	<LI> \ref TimingMacros
	196	<BR>   <em>macros for taking execution speed measurements</em>
	197	<LI> \ref VIGRA_FINALLY
	198	<BR>   <em>emulation of the 'finally' keyword from Python</em>
	199	<LI> \ref vigra::Any
	200	<BR>   <em>typesafe storage of arbitrary values</em>
	201	<LI> \ref vigra::BucketQueue and \ref vigra::MappedBucketQueue
	202	<BR>   <em>efficient priority queues for integer priorities</em>
	203	<LI> \ref RangesAndPoints
	204	<BR>   <em>2-D and N-D positions, extents, and boxes</em>
	205	<LI> \ref vigra::FilterIterator
	206	<BR>   <em>skip elements in a range that don't fulfill a predicate</em>
	207	<LI> \ref vigra::IteratorAdaptor
	208	<BR>   <em>quickly create STL-compatible 1D iterator adaptors</em>
	209	<LI> \ref TupleTypes
	210	<BR>   <em>pair, triple, tuple4, tuple5</em>
	211	<LI> \ref PixelNeighborhood
	212	<BR>   <em>2D neighborhood definitions (deprecated, use \ref vigra::GridGraph instead)</em>
	213	<LI> \ref VoxelNeighborhood
	214	<BR>   <em>3D neighborhood definitions (deprecated, use \ref vigra::GridGraph instead)</em>
	215	<LI> \ref vigra::ArrayVector
	216	<BR>   <em>replacement for std::vector with stronger guarantees (deprecated as of C++ 11)</em>
	217	</UL>
	218	<LI> <span style="font-weight:bold; color:#0040b0">Concepts</span>
8	219	<BR>   <em>generic interface definitions</em>
9		<LI> \ref Utilities
10		<BR>   <em>Basic helper functionality needed throughout</em>
11		<LI> \ref ErrorReporting
12		<BR>   <em>Exceptions and assertions</em>
13		<LI> \ref MathFunctionality
14		<BR>   <em>Number types, mathematical constants and functions, linear algebra etc.</em>
15		<LI> \ref PixelTypes
16		<BR>   <em>Non-scalar types such as RGBValue and TinyVector</em>
17		<LI> \ref ImageDataStructures
18		<BR>   <em>Images, image iterators, and supporting types and functions</em>
19		<LI> \ref MultiDimensionalArrays
20		<BR>   <em>Arrays, iterators, and supporting types and functions
21		for arbitrary dimensions</em>
22		<LI> \ref ChunkedArrayClasses
23		<BR>   <em>Store big data (potentially larger than RAM) as a collection of rectangular blocks</em>
24		<LI> \ref GraphDataStructures
25		<BR>   <em>Graph-based algorithms (e.g. segmentation) and underlying graph classes (e.g. grid graphs for arbitrary dimensions)</em>
26		<LI> \ref ImportExport
27		<BR>   <em>Conversion from and to other image data types</em>
28		<LI> \ref ColorConversions
29		<BR>   <em>Convert between RGB and other color spaces, such as Luv*, Y'PbPr</em>
30		<LI> \ref ImageProcessing
31		<BR>   <em>Point operators, image arithmetic, convolution, morphology</em>
32		<LI> \ref Registration
33		<BR>   <em>Transforming different images into a common coordinate system</em>
34		<LI> \ref ImageAnalysis
35		<BR>   <em>Segmentation and feature extraction algorithms</em>
36		<LI> \ref MachineLearning
37		<BR>   <em>Classification algorithms</em>
	220	<UL>
	221	<LI> \ref AlgebraicConcepts
	222	<BR>   <em>requirements for types that implement arithmetic operations</em>
	223	<LI> \ref ImageIterators
	224	<BR>   <em>2D iterator API</em>
	225	<LI> \ref MultiIteratorPage
	226	<BR>   <em>multi-dimensional iterator API</em>
	227	<LI> \ref vigra::MultiArrayNavigator
	228	<BR>   <em>navigator utility for multi-dimensional arrays</em>
	229	<LI> \ref vigra::FunctorTraits
	230	<BR>   <em>requirements for functor traits</em>
	231	<LI> \ref CrackEdgeImage
	232	<BR>   <em>topologically correct treatment of interpixel contours</em>
	233	<LI> \ref DataAccessors
	234	<BR>   <em>requirements for data accessors (deprecated)</em>
	235	</UL>
38	236	<LI> \ref ExampleList
39		<BR>   <em>Demonstration programs for VIGRA's usage </em>
	237	<BR>   <em>demonstration programs for VIGRA's usage </em>
40	238	<LI> \ref VigraMatlab
41		<BR>   <em>VIGRA Matlab bindings</em>
42		<LI> <b><a href="../vigranumpy/index.html">vigranumpy</a></b>
	239	<BR>   <em>VIGRA Matlab bindings (unsupported)</em>
	240	<LI> <a href="../vigranumpy/index.html" style="text-decoration:none; font-weight:bold; color:#0040b0">vigranumpy</a>
43	241	<BR>   <em>VIGRA Python bindings</em>
44	242	<LI> \ref CreditsChangelog
45		<BR>   <em>Who contributed what?</em>
	243	<BR>   <em>who contributed what?</em>
46	244	</UL>
47	245
48	246	\anchor _details

84	282	VIGRA is subject to this <a href="LICENSE.txt">LICENSE</a>.
85	283
86	284	You can also subscribe to the <a href="https://mailhost.informatik.uni-hamburg.de/mailman/listinfo/vigra">VIGRA Mailing List</a> to get instant information about new releases, discuss VIGRA's features and development, and ask the experts for help.
87
88
89
90		*/
91
92		/** \page Concepts Concepts
93
94		<DL>
95		<DT>
96		Description of the generic interface concepts used within VIGRA.
97		<DD>
98		<UL style="list-style-image:url(documents/bullet.gif)">
99		<LI> \ref AlgebraicConcepts
100		<BR>   <em>Requirements for types that implement arithmetic operations</em>
101		<LI> \ref ImageIterators
102		<BR>   <em>Requirements for 2D iterators</em>
103		<LI> \ref MultiIteratorPage
104		<BR>   <em>Iterators for multi-dimensional arrays</em>
105		<LI> \ref DataAccessors
106		<BR>   <em>Requirements for data accessors</em>
107		<LI> \ref vigra::FunctorTraits
108		<BR>   <em>Requirements for functor traits</em>
109		<LI> \ref CrackEdgeImage
110		</UL>
111		</DL>
112		*/
113
114		/** \page MathFunctionality Mathematical Tools
115
116		<b>Number types, mathematical constants, special functions, linear algebra</b>
117		<p>
118		<UL style="list-style-image:url(documents/bullet.gif)">
119		<LI> \ref AlgebraicConcepts
120		<BR>   <em>Requirements for types that implement arithmetic operations</em>
121		<LI> \ref NumericPromotionTraits
122		<BR>   <em>Meta-information about arithmetic types</em>
123		<LI> \ref MathConstants
124		<BR>   <em>M_PI, M_SQRT2</em>
125		<LI> <b>Grid Neighborhood Specification</b>
126		<UL style="list-style-image:url(documents/bullet.gif)">
127		<LI> \ref PixelNeighborhood "2-dimensional" (4- and 8-neighborhood)
128		<LI> \ref VoxelNeighborhood "3-dimensional" (6- and 26-neighborhood)
129		</UL>
130		<LI> <b>Number Types</b>
131		<UL style="list-style-image:url(documents/bullet.gif)">
132		<LI> \ref vigra::Rational
133		<LI> \ref vigra::TinyVector
134		<LI> \ref vigra::autodiff::DualVector
135		<LI> \ref vigra::FFTWComplex
136		<LI> \ref vigra::FixedPoint16
137		<LI> \ref vigra::Quaternion
138		</UL>
139		<LI> \ref RandomNumberGeneration
140		<BR>   <em>Mersenne twister class and random number functors</em>
141		<LI> \ref Polynomials
142		<BR>   <em>Polynomials and root determination</em>
143		<LI> \ref MathFunctions
144		<BR>   <em>and functors</em>
145		<LI> \ref vigra::linalg::Matrix "Matrix class"
146		<BR>   <em>the matrix class</em>
147		<LI> \ref LinearAlgebraModule "Linear Algebra"
148		<BR>   <em>matrix algebra, solution of linear systems, eigenvalue calculation etc.</em>
149		<LI> \ref Unsupervised_Decomposition "Unsupervised Decomposition"
150		<BR>   <em>Unsupervised matrix decomposition methods (pLSA)</em>
151		<LI> \ref Optimization "Optimization and Regression"
152		<BR>   <em>ordinary and non-negative least squares, ridge regression, least angle regression (LARS and LASSO)</em>
153		</UL>
154
155		*/
156
157		/** \page PixelTypes Pixel Types
158
159		<DL>
160		<DT>
161		<b>Scalar types</b>
162		<DD>
163		<UL style="list-style-image:url(documents/bullet.gif)">
164		<LI> \ref FixedSizeInt
165		<LI> \ref vigra::Rational
166		<LI> \ref vigra::FixedPoint
167		<LI> \ref vigra::FixedPoint16
168		</UL>
169		<p>
170		<DT>
171		<b>RGB colors and related functionality</b>
172		<DD>
173		<UL style="list-style-image:url(documents/bullet.gif)">
174		<LI> \ref vigra::RGBValue
175		<LI> \ref RGBValueTraits
176		<LI> \ref RGBValueOperators
177		<LI> \ref RGBValueAccessors
178		</UL>
179		<p>
180		<DT>
181		<b>Fixed-size vectors and related functionality</b>
182		<DD>
183		<UL style="list-style-image:url(documents/bullet.gif)">
184		<LI> \ref vigra::TinyVector
185		<LI> \ref vigra::TinyVectorView
186		<LI> \ref TinyVectorTraits
187		<LI> \ref TinyVectorOperators
188		</UL>
189		<p>
190		<DT>
191		<b>Complex Numbers</b>
192		<DD>
193		<UL style="list-style-image:url(documents/bullet.gif)">
194		<LI> \ref vigra::FFTWComplex
195		<LI> \ref FFTWComplexTraits
196		<LI> \ref FFTWComplexOperators
197		<LI> \ref FFTWComplexAccessors
198		</UL>
199		</DL>
200		*/
201
202		/** \page ImageDataStructures Image Data Structures and Iterators
203
204		<UL style="list-style-image:url(documents/bullet.gif)">
205		<LI> \ref vigra::BasicImage
206		<BR>   <em>Fundamental class template for images </em>
207		<LI> \ref vigra::BasicImageView
208		<BR>   <em>Class template for images that use external memory</em>
209		<LI> \ref StandardImageTypes
210		<BR>   <em>The most common instantiations of \ref vigra::BasicImage</em>
211		<LI> \ref vigra::SplineImageView
212		<BR>   <em>Wrap a discrete image as a continous function</em>
213		<LI> \ref VigraImpex
214		<BR>   <em>Image import/export</em>
215		<LI> \ref ImageContainers
216		<BR>   <em>Classes to manage multiple images (ImageArray..)</em>
217		<LI> \ref PixelNeighborhood
218		<BR>   <em>Easy access to the 4- and 8-neighbors of a pixel</em>
219		<LI> \ref ImageIterators
220		<BR>   <em>Basic image iterator implementations </em>
221		<LI> \ref ImageIteratorAdapters
222		<BR>   <em>Iterate over rows, columns, and other image subsets </em>
223		<LI> \ref DataAccessors
224		<BR>   <em>Basic templates to encapsulate access to the data of an iterator</em>
225		<LI> \ref ArgumentObjectFactories
226		<BR>   <em>Factory functions to create argument objects which simplify long argument lists </em>
227		</UL>
228		*/
229
230		/** \page MultiDimensionalArrays Multi-Dimensional Arrays and Iterators
231
232		<UL style="list-style-image:url(documents/bullet.gif)">
233		<LI> \ref vigra::MultiArrayView
234		<BR>   <em>Interface for multi-dimensional arrays </em>
235		<LI> \ref vigra::MultiArray
236		<BR>   <em>Array class that holds the actual memory</em>
237		<LI> \ref MultiMathModule
238		<BR>   <em>Arithmetic and algebraic expressions for multi-dimensional arrays</em>
239		<LI> \ref MultiArrayTags
240		<BR>   <em>Meta-programming tags to mark array's as strided or unstrided</em>
241		<LI> \ref MultiIteratorPage
242		<BR>   <em>Iterators for multi-dimensional arrays</em>
243		<LI> \ref vigra::MultiArrayNavigator
244		<BR>   <em>Navigator utility for multi-dimensional arrays</em>
245		<LI> \ref VolumeImpex
246		<BR>   <em>Import/export of volume data.</em>
247		<LI> \ref MultiPointoperators
248		<BR>   <em>Point operators on multi-dimensional arrays</em>
249		<LI> \ref MultiArrayConvolutionFilters
250		<BR>   <em>Convolution filters in arbitrary dimensions</em>
251		<LI> \ref FourierTransform
252		<BR>   <em>Fast Fourier transform for arrays of arbitrary dimension</em>
253		<LI> \ref resizeMultiArraySplineInterpolation()
254		<BR>   <em>Interpolation of arrays in arbitrary dimensions</em>
255		<LI> \ref MultiArrayDistanceTransform
256		<BR>   <em>Separable distance transform for arrays of arbitrary dimension</em>
257		<LI> \ref MultiArrayMorphology
258		<BR>   <em>Separable morphology with parabola structuring function for arrays of arbitrary dimension</em>
259		<LI> \ref labelVolume(), \ref seededRegionGrowing3D(), \ref watersheds3D(), \ref localMinima3D(), \ref localMaxima3D(),
260		<BR>   <em>3-dimensional image (i.e. volume) analysis</em>
261		<LI> \ref VoxelNeighborhood
262		<BR>   <em>Easy access to the 6- and 26-neighbors of a voxel</em>
263		<LI> \ref vigra::NumpyArray and \ref vigra::NumpyAnyArray
264		<BR>   <em>Provide the VIGRA multi array interface Python arrays</em>
265		</UL>
266		*/
	285	*/
	286
	287	/** \addtogroup ConvolutionFilters Convolution Filters
	288
	289	The functions in this group implement separable convolutions (e.g. smoothing and sharpening,
	290	Gaussian derivatives) and related filters (like the gradient magnitude) on
	291	arbitrary-dimensional arrays. In addition, non-separable filters are supported for 2D images.
	292	All functions accept the \ref vigra::MultiArrayView API (which can be wrapped around a wide
	293	variety of data structures) as well as a number of deprecated APIs such as \ref ImageIterators.
	294	*/
	295
	296	/** \addtogroup GeometricTransformations Geometric Transformations
	297
	298	Resize or warp an array using various interpolation schemes or just pixel repetition.
	299
	300	See also: \ref Registration, \ref vigra::SplineImageView
	301	*/
	302
	303	/** \addtogroup DistanceTransform Distance Transform
	304
	305	The functions in this group perfrom Euclidean distance transforms in arbitrary dimensions,
	306	as well Manhattan and chessboard distance transforms in 2D (this can easily be extended to nD
	307	if need arises). In addition, a number of related transforms such as vector distance transforms,
	308	eccentricity transforms, and 2D skeleton computations are offered.
	309	*/
	310
	311	/** \addtogroup Superpixels Superpixel Creation
	312
	313	Watersheds, SLIC superpixels, and seeded region growing.
	314	*/
	315
	316	/** \addtogroup ParallelProcessing Parallel Processing
	317
	318	\sa These algorithms and data structures also support parallel processing:
	319	*/
267	320
268	321	/** \page ImportExport Image Import and Export
269	322

302	355
303	356	*/
304	357
305		/** \page ImageProcessing Image Processing
306
307		<UL style="list-style-image:url(documents/bullet.gif)">
308		<LI> \ref PointOperators
309		<BR>   <em>algorithms and functors for image arithmetic, inspection, transformations etc.</em>
310		<LI> \ref MultiMathModule
311		<BR>   <em>Arithmetic and algebraic expressions for multi-dimensional arrays</em>
312		<LI> \ref FunctorExpressions
313		<BR>   <em>Expression templates for automated functor creation</em>
314		<LI> \ref GeometricTransformations "Resize and Other Geometric Image Transformations"
315		<BR>   <em>resize and interpolation, image mirroring, rotation, arbitrary affine transformations</em>
316		<LI> \ref vigra::SplineImageView
317		<BR>   <em>Wrap a discrete image as a continous function</em>
318		<LI> \ref Convolution
319		<BR>   <em>1D, 2D, and nD filters, including separable and recursive convolution</em>
320		<LI> \ref NonLinearDiffusion
321		<BR>   <em>Edge-preserving smoothing and denoising</em>
322		<LI> \ref Correlation
323		<BR>   <em>Fast and slow algorithms to estimate the correlation between images</em>
324		<LI> \ref Registration
325		<BR>   <em>Transforming different images into a common coordinate system</em>
326		<LI> \ref FourierTransform
327		<BR>   <em>forward and backward FFT, cosine transform, and related
328		functionality</em>
329		<LI> \ref GaborFilter
330		<BR>   <em>Gabor filter generation and related
331		functionality</em>
332		<LI> \ref TensorImaging
333		<BR>   <em>Tensor image processing</em>
334		<LI> \ref Morphology
335		<BR>   <em>erosion, dilation, and median with disc structuring functions</em>
336		<LI> \ref NoiseNormalization
337		<BR>   <em>transform intensity-dependent noise into additive Gaussian noise</em>
338		<LI> \ref SlantedEdgeMTF
339		<BR>   <em>determine the magnitude transfer function (MTF) of a camera using the slanted edge method</em>
340		</UL>
341		*/
342
343		/** \page ImageAnalysis Image Analysis
344
345		<UL style="list-style-image:url(documents/bullet.gif)">
346		<LI> \ref InspectAlgo and \ref InspectFunctor
347		<BR>   <em>Statistical analysis of images and regions</em>
348		<LI> \ref FeatureAccumulators
349		<BR>   <em>Computation of global and per-region statistics of multi arrays via accumulators framework</em>
350		<LI> \ref vigra::Threshold
351		<BR>   <em>Good old thresholding</em>
352		<LI> \ref Labeling
353		<BR>   <em>Connected components labeling using 4 or 8 connectivity </em>
354		<LI> \ref LocalMinMax
355		<BR>   <em>Including extremal plateaus larger than 1 pixel</em>
356		<LI> \ref DistanceTransform
357		<BR>   <em>Distance transform using Euclidean, Manhattan, or chessboard metrics </em>
358		<LI> \ref TensorImaging
359		<BR>   <em>Tensor image analysis</em>
360		<LI> \ref EdgeDetection
361		<BR>   <em>Edge detectors based on first and second derivatives</em>
362		<LI> \ref CornerDetection
363		<BR>   <em>Measure the 'cornerness' at each pixel </em>
364		<LI> \ref SymmetryDetection
365		<BR>   <em>Measure the local symmetry at each pixel </em>
366		<LI> \ref SeededRegionGrowing
367		<BR>   <em>Region growing, watersheds, and voronoi tesselation</em>
368		</UL>
369		*/
370
371	358	/** \page AlgebraicConcepts Algebraic Concepts
372	359
373	360	The algebraic concepts describe requirements for algebraic types, that is

+190

-175

docsrc/tutorial.dxx less more

0	0	/** \page Tutorial Tutorial
1
	1
2	2	This tutorial will help you to learn VIGRA's most important concepts by means of simple examples. The tutorial consists of the following parts:
3
4		<ul style="list-style-image:url(documents/bullet.gif)">
	3
	4	<ul style="list-style-image:url(documents/diamond.gif)">
5	5	<li> \ref MultiDimensionalArrayTutorial
6	6	<BR>   <em>VIGRA's most important data structure</em>
7		<ul style="list-style-image:url(documents/bullet.gif)">
	7	<ul style="list-style-image:url(documents/diamond.gif)">
8	8	<li> \ref MultiArrayBasics
9	9	<li> \ref MultiArrayIndexing
10	10	<li> \ref MultiArrayScanOrder

18	18	<li> \ref MultiArray_unstrided
19	19	</ul>
20	20	</ul>
21
	21
22	22	<li> \ref MultiArrayArithmeticTutorial
23	23	<BR>   <em>mathematical operations on MultiArrays</em>
24		<ul style="list-style-image:url(documents/bullet.gif)">
	24	<ul style="list-style-image:url(documents/diamond.gif)">
25	25	<li> \ref MultiMathModule "Array Expressions"
26	26	<li> \ref LinearAlgebraModule "Linear Algebra"
27	27	<li> \ref MultiPointoperators "STL-style transformation algorithms"
28	28	<li> \ref FeatureAccumulators
29	29	</ul>
30
	30
31	31	<li> \ref ImageInputOutputTutorial
32	32	<BR>   <em>importing and exporting images and arbitrary-dimensional arrays</em>
33		<ul style="list-style-image:url(documents/bullet.gif)">
	33	<ul style="list-style-image:url(documents/diamond.gif)">
34	34	<li> \ref Impex2D
35	35	<li> \ref ImpexND
36	36	</ul>
37	37
38	38	<li> \ref ImageProcessingTutorial
39	39	<BR>   <em>basic applications of VIGRA's functions</em>
40		<ul style="list-style-image:url(documents/bullet.gif)">
	40	<ul style="list-style-image:url(documents/diamond.gif)">
41	41	<li> \ref CallingConventions
42	42	<li> \ref ImageInversion
43	43	<li> \ref ImageBlending

46	46	<ul type="disc">
47	47	<li> \ref Convolve2DTutorial
48	48	<li> \ref SeparableConvolveTutorial
	49	<li> \ref ParallelConvolveTutorial
49	50	</ul>
50	51	</ul>
51	52
	53	<li> \ref ImageSegmentationTutorial
	54	<BR>   <em>extracting meaningful regions from pixels</em>
	55	<ul style="list-style-image:url(documents/diamond.gif)">
	56	<li> \ref SuperpixelsTutorial
	57	<li> \ref RAGTutorial
	58	<li> \ref ClusteringTutorial
	59	</ul>
	60
52	61	<li> \ref OwnFunctionsTutorial
53	62	<BR>   <em>... without getting confused by templates</em>
54	63
55	64	<li> \ref PythonBindingsTutorial
56	65	<BR>   <em>scripting with VIGRA made easy</em>
57
	66
58	67	</ul>
59	68	*/
60	69
61	70	/** \page MultiDimensionalArrayTutorial Multi-Dimensional Arrays
62	71
63	72	<h2>Section Contents</h2>
64
65		<ul style="list-style-image:url(documents/bullet.gif)">
	73
	74	<ul style="list-style-image:url(documents/diamond.gif)">
66	75	<li> \ref MultiArrayBasics
67	76	<li> \ref MultiArrayIndexing
68	77	<li> \ref MultiArrayScanOrder

76	85	<li> \ref MultiArray_unstrided
77	86	</ul>
78	87	</ul>
79
	88
80	89	\section MultiArrayBasics Basic MultiArray Usage
81
82		\ref vigra::MultiArray is the most fundamental data structure in VIGRA. It holds a rectangular block of values in arbitrary many dimensions. Most VIGRA functions operate on top of MultiArray or the associated class MultiArrayView (see \ref MultiArrayViewBasics).
83
	90
	91	\ref vigra::MultiArray is the most fundamental data structure in VIGRA. It holds a rectangular block of values in arbitrary many dimensions. Most VIGRA functions operate on top of MultiArray or the associated class MultiArrayView (see \ref MultiArrayViewBasics).
	92
84	93	A 2D image can be interpreted as a matrix, i.e. a 2-dimensional array, where each element holds the information of a specific pixel. Internally, the data are stored in a single 1-dimensional piece of memory, and MultiArray encapsulates the entire mapping between our familiar 2-dimensional notation and the raw memory. Pixels in an image are identified by a coordinate pair (x,y), where indexing starts at 0. That is, the pixels in a 800x600 image are indexed by <tt>x = 0,...,799 and y = 0,...,599</tt>. The principle analoguously extends to higher dimensions.
85
86		The structure of a multidimensional array is given by its <tt>shape</tt> vector, and the length of the shape vector is the array's <i>dimension</i>. The dimension must be fixed as a template parameter at compule time, while the shape is passed to the array's constructor. The second important template parameter is the pixel's <tt>value_type</tt>, as you know it form <tt>std::vector</tt>.
87
88		To represent the data of a gray scale image, we just need to store one value per pixel, so we
89		choose a 2-dimensional array, where each element has the <tt> unsigned char </tt> type
	94
	95	The structure of a multidimensional array is given by its <tt>shape</tt> vector, and the length of the shape vector is the array's <i>dimension</i>. The dimension must be fixed as a template parameter at compule time, while the shape is passed to the array's constructor. The second important template parameter is the pixel's <tt>value_type</tt>, as you know it form <tt>std::vector</tt>.
	96
	97	To represent the data of a gray scale image, we just need to store one value per pixel, so we
	98	choose a 2-dimensional array, where each element has the <tt> unsigned char </tt> type
90	99	(in VIGRA, this type is also available as \ref vigra::UInt8). We instantiate a gray scale image object like this:
91	100
92	101	\code
93	102	#include <vigra/multi_array.hxx>
94
	103
95	104	using namespace vigra; // for brevity in the examples - don't do this in header files!
96
	105
97	106	int width = ..., height = ...;
98	107	MultiArray<2, UInt8> image(Shape2(width, height));
99	108	\endcode
100
	109
101	110	By default, VIGRA arrays are <b>always zero-initialized</b>. Another initial value can be provided in the constructor, or later via the <tt>init()</tt> function or the assignment operator:
102
	111
103	112	\code
104	113	MultiArray<2, UInt8> image(Shape2(width, height), 255); // init with value 255
105
	114
106	115	image.init(128); // same effect, different initial value
107	116	image = 100; // yet another way
108	117	\endcode
109
110		The <tt>Shape2</tt> typedef also exists for higher dimensions up to five as <tt>Shape3</tt> etc. If you need even more dimensions, use <tt>MultiArrayShape<N>::type</tt> instead, were N is the number of dimensions:
	118
	119	The <tt>Shape2</tt> typedef also exists for higher dimensions up to five as <tt>Shape3</tt> etc. If you need even more dimensions, use <tt>MultiArrayShape<N>::type</tt> instead, were N is the number of dimensions:
111	120
112	121	\code
113	122	// dimension 0 runs from 0, 1, ..., 299
114	123	// dimension 1 runs from 0, 1, ..., 199
115	124	// dimension 2 runs from 0, 1, ..., 99
116	125	MultiArray<3, double> volume(Shape3(300, 200, 100));
117
	126
118	127	MultiArray<7, float> array7D(MultiArrayShape<7>::type(20, 10, ...));
119		\endcode
	128	\endcode
120	129
121	130	When storing RGB images we obviously can't simply use the unsigned char type because every pixel contains 3 numbers: values for red, green and blue. Mathematically, you want to store a data vector for each pixel. To this end, VIGRA
122	131	provides the <tt>vigra::RGBValue<ValueType></tt> class. So for RGB-images just use: </p>

129	138
130	139	Alternatively you can use a 3-dimensional array <tt>vigra::MultiArray<3, unsigned
131	140	char></tt> to represent a color image. The third dimension has size 3 and contains the
132		information for the red, green and blue channel.
133
	141	information for the red, green and blue channel.
	142
134	143	\code
135	144	MultiArray<3, UInt8> rgb_array(Shape3(256, 128, 3));
136	145	\endcode

154	163	\endcode
155	164
156	165	<B>Important Remark:</B> Notice that VIGRA follows the mathematical convention of the index order: dimension 0 corresponds to the x (horizontal) coordinate, dimension 1 to the y (vertical) coordinate, and so on. Accordingly, dimension 0 is changing fastest in memory: when we increase x by one, we get to the next memory location. In matrix jargon, this is also known as <i>Fortran order</i>. Many image processing libraries (e.g. <a href="http://www.imagemagick.org/">Image Magick</a>, <a href="http://opencv.willowgarage.com/">OpenCV</a>, and <a href="http://qt-project.org/">Qt</a>) use the same convention. However, others like Matlab and numpy, use the reverse order (so called <i>C order</i>). Don't be confused!
157
	166
158	167	Internally, shape objects are implemented in terms of the powerful \ref vigra::TinyVector class. This means that shape objects support the usual mathematical operations like addition, multiplication and scalar products. Coordinate computations can thus be performed on entire coordinate objects at once - there is no need to manipulate the individual coordinates separately.
159
	168
160	169	Nonetheless, in some circumstances it is more convenient to provide coordinates individually rather than in a shape object. This is possible with round brackets (x,y):
161	170
162	171	\code
163	172	// access via individual coordinates
164	173	image(1,2) = 22;
165	174	\endcode
166
	175
167	176	This kind of indexing is supported for dimensions up to five, and only if the array's dimension is known (this is not always the case: in a generic function where the dimension is a template parameter, you must use shape objects).
168		In combination with the method <tt>shape(n)</tt>, that returns the length of the n-th dimension,
	177	In combination with the method <tt>shape(n)</tt>, that returns the length of the n-th dimension,
169	178	we can use the coordinates to set the element of an entire row or column:
170	179
171	180	\code

183	192	// bind x=2
184	193	p[0] = 2;
185	194	// iterator over row 2
186		for(p[1]=0; p[1]<image.shape(1); ++p[1])
	195	for(p[1]=0; p[1]<image.shape(1); ++p[1])
187	196	image[p] = 7;
188	197	\endcode
189	198
190	199	We will discuss more powerful methods to access certain parts of an array in section \ref MultiArrayMethods.
191	200
192	201	\section MultiArrayScanOrder One-dimensional Indexing and Scan-Order Iterator
193
194		Regardless of the array's dimension, it is always possible to access elements with 1-dimensional index, its <i>scan-order index</i>, via the normal indexing operator. For example, <tt>array[1]</tt> refers to the index of the second array element. Defining a scan order is often called <i>flattening</i> of an array, because a high-dimensional data structure is accessed like a 1-dimensional vector. Notive that scan-order access in VIGRA does not require the data to be copied.
195
196		VIGRA defines scan-order by considering the dimensions from front to back. Thus, items are accessed such that only the x coordinate is incremented, while y (and possibly further coordinates) are held fixed at 0. When x is exhausted, y is incremented by one and the iteration starts again at x=0. To control iteration, the function <tt>array.size()</tt> returns the total number of elements:
	202
	203	Regardless of the array's dimension, it is always possible to access elements with 1-dimensional index, its <i>scan-order index</i>, via the normal indexing operator. For example, <tt>array[1]</tt> refers to the index of the second array element. Defining a scan order is often called <i>flattening</i> of an array, because a high-dimensional data structure is accessed like a 1-dimensional vector. Notive that scan-order access in VIGRA does not require the data to be copied.
	204
	205	VIGRA defines scan-order by considering the dimensions from front to back. Thus, items are accessed such that only the x coordinate is incremented, while y (and possibly further coordinates) are held fixed at 0. When x is exhausted, y is incremented by one and the iteration starts again at x=0. To control iteration, the function <tt>array.size()</tt> returns the total number of elements:
197	206
198	207	\code
199	208	MultiArray<2, int> intArray(Shape2(3,2));
200	209
201	210	for(int k=0; k<intArray.size(); ++k=
202	211	intArray[k] = k+1;
203
	212
204	213	// the array now contains the values
205	214	//
206	215	// 1 2 3
207	216	// 4 5 6
208	217	\endcode
209
	218
210	219	Alternatively, scan-order access can be achieved with an STL-compatible iterator pair obtained by calling <tt>array.begin()</tt> and <tt>array.end()</tt>. Continuing with the example above, we can write:
211	220
212	221	\code

217	226	for (Iter i = intArray.begin(); i != intArray.end(); ++i)
218	227	std::cout << *i << " ";
219	228	std::cout << std::endl;
220
	229
221	230	// output: 1 2 3 4 5 6
222	231	\endcode
223	232
224		The iterator is implemented by class <tt>StridedScanOrderIterator</tt> which encapsulates all the bookkeeping necessary to get the elements in the correct order, even when the array was transposed (see below).
225
226		Scan-order access is useful to implement pointwise operations, e.g. the addition of two matrices. The following code adds two matrices and stores the result in the first one:
	233	The iterator is implemented by class <tt>StridedScanOrderIterator</tt> which encapsulates all the bookkeeping necessary to get the elements in the correct order, even when the array was transposed (see below).
	234
	235	Scan-order access is useful to implement pointwise operations, e.g. the addition of two matrices. The following code adds two matrices and stores the result in the first one:
227	236
228	237	\code
229	238	MultiArray<2, int> matrix1(Shape2(3,3)),

233	242	// use indexing
234	243	for (int i=0; i < matrix1.size(); ++i)
235	244	matrix1[i] += matrix2[i];
236
	245
237	246	// use iterators
238	247	for (Iter i = matrix1.begin(), j = matrix2.begin(); i != matrix1.end(); ++i, ++j)
239	248	i += j;

259	268
260	269	For more information on mathematical operations on arrays see the \ref MultiMathModule "multi_math" module.
261	270
262		As mentioned, VIGRA's scan order is similar to the NumPy-method <tt>array.flatten()</tt>. You use it,
	271	As mentioned, VIGRA's scan order is similar to the NumPy-method <tt>array.flatten()</tt>. You use it,
263	272	to copy a multi-dimensional array into an one-dimensional array, or to access elements in flattened order. The only
264	273	difference is that NumPy uses "C-order" , i.e. the rightmost dimension takes priority, whereas
265	274	VIGRA uses Fortran-order, i.e. the leftmost dimension takes priority. A method like flatten can be implemented in VIGRA as:

269	278
270	279	for(int k=0; k<intArray.size(); ++k=
271	280	intArray[k] = k+1;
272
	281
273	282	// create 1D-array of appropriate size
274	283	std::vector<int> flatArray(intArray.size());
275
	284
276	285	// copy 2D-array into 1D-array using the STL
277	286	std::copy(intArray.begin(), intArray.end(), flatArray.begin());
278
	287
279	288	// print 1D-array on console
280		// (same output as printing from the StridedScanOrderIterator directly)
	289	// (same output as printing from the StridedScanOrderIterator directly)
281	290	for (std::vector<int>::iterator i = flatArray.begin(); i != flatArray.end(); ++i)
282	291	std::cout << *iter << " ";
283	292	std::cout << std::endl;

287	296	used C-order in the code above:
288	297
289	298	\verbatim
290		flatArray - index 0 1 2 3 4 5
	299	flatArray - index 0 1 2 3 4 5
291	300	-----------------------------------------------------------------
292	301	VIGRA-output: 1 2 3 4 5 6
293	302	intArray - index [0,0] [1,0] [2,0] [0,1] [1,1] [2,1]

298	307
299	308	To change the axis priorities of the StridedScanOrderIterator, look at the transpose-function
300	309	in the next section.
301
	310
302	311	\section MultiArrayMethods Important MultiArray Methods
303	312
304	313	This part of the tutorial explains important methods of MultiArray. However, before we proceed, we need to introduce the class \ref vigra::MultiArrayView.
305
	314
306	315	\subsection MultiArrayViewBasics The MultiArrayView Interface
307
	316
308	317	A \ref vigra::MultiArrayView has the same interface as a MultiArray (with the exception of <tt>reshape()</tt> and <tt>swap()</tt>), but it doesn't own its data. Instead, it provides a <i>view</i> onto the data of some other array. In contrast, a MultiArray owns its data and is responsible for freeing it in the destructor. MultiArrays are automatically converted into MultiArrayViews when needed.
309
	318
310	319	The point of this distinction is that MultiArrayViews can be used to access and manipulate the same data in many different ways <i>without any need for creating copies</i>. For example, we can work with a 2-dimensional slice of a volume dataset (i.e. a lower dimensional part of a 3D array) without first copying the slice into a 2D image. This is possible whenever the desired view can be realized by just manipulating the internal <i>mapping</i> from indices and shapes to memory locations, and not the memory layout itself.
311
	320
312	321	This possibility -- which is similarly implemented in other packages like Matlab and numpy -- is a key ingredient for efficient computations with multi-dimensional arrays. Thus, most VIGRA functions actually receive MultiArrayViews to maximize flexibility. This section describes the most important ways to create new MultiArrayViews from an existing array or view. The complete documentation is available in the \ref vigra::MultiArrayView reference.
313	322
314	323	<hr>
315	324
316	325	\subsection MultiArray_subarray subarray(p,q)
317
	326
318	327	This method creates a rectangular subarray of your array between the points p and q, where p (the starting point of the subregion) is included, q (the ending point) is not. <tt>subarray</tt> does not change the dimension of the array (this is the task of the various <tt>bind</tt>-methods).
319
	328
320	329	To give an example, we create a 4x4 array that consitst of a checkerboard with 2x2 squares:
321	330
322	331	\code
323	332	MultiArray<2, float> array_4x4(Shape2(4,4)); // zero (black) initialized
324
	333
325	334	// paint the upper left 2x2 square white
326	335	array_4x4.subarray(Shape2(0,0), Shape2(2,2)) = 1.0;
327
328		// likewise for the lower right 2x2 square, but this time we
	336
	337	// likewise for the lower right 2x2 square, but this time we
329	338	// store the array view explicitly for illustration
330	339	MultiArrayView<2, int> lower_right_square = array_4x4.subarray(Shape2(2,2), Shape2(4,4));
331	340	lower_right_square = 1.0;
332
	341
333	342	// contents of array_4x4 now:
334	343	// 1 1 0 0
335	344	// 1 1 0 0

344	353	\skip // read image
345	354	\until exportImage
346	355
347		After reading the (here: gray scale) image data to an array we need to calculate the
348		coordinates of our subimage. In this case we want to cut out the middle part of the image.
	356	After reading the (here: gray scale) image data to an array we need to calculate the
	357	coordinates of our subimage. In this case we want to cut out the middle part of the image.
349	358	Afterwards we write the subimage into a new array. Look at the result:
350	359
351	360	<Table cellspacing = "10">

358	367	<hr>
359	368
360	369	\subsection MultiArray_bind bind<M>(i) and bindAt(M, i)
361
362		These methods bind axis M to the index i and thus reduce the dimension of the array by one. The only difference between the two forms is that the axis to be bound must be known at compile time in the first form, whereas it can be specified at runtime in the second.
363
	370
	371	These methods bind axis M to the index i and thus reduce the dimension of the array by one. The only difference between the two forms is that the axis to be bound must be known at compile time in the first form, whereas it can be specified at runtime in the second.
	372
364	373	Binding is useful when we want to access and/or manipulate a particular row or column of an image, or a single slice of a volume. In principle, the same can also be achieved by explicit loops, but use of <tt>bind</tt> often leads to more elegant and more generic code. Consider the following code to initialize the third column of an image with the constant 5:
365	374
366	375	\code

370	379	// initialize column 2 with value 5 using a loop
371	380	for(int y=0; y<array2d.shape(1); ++y)
372	381	array2d(2, y) = 5;
373
	382
374	383	// the same using bind
375	384	array2d.bind<0>(2) = 5;
376	385	\endcode

387	396	MultiArray<1, int> array1d = array2d.bind<0>(2);
388	397	\endcode
389	398
390		The array <tt>array1d</tt> contains the elements the 3rd column of <tt>array2d</tt>. This bahavior nicely illustrates the difference between a copy and a view: <tt>array1d</tt> contains a copy of the 3rd column, whereas the <tt>bind</tt> function only creates a new view to the existing data in <tt>array2d</tt>.
391
392		At this point we have to distinguish between the classes <tt> MultiArray </tt> and
	399	The array <tt>array1d</tt> contains the elements the 3rd column of <tt>array2d</tt>. This bahavior nicely illustrates the difference between a copy and a view: <tt>array1d</tt> contains a copy of the 3rd column, whereas the <tt>bind</tt> function only creates a new view to the existing data in <tt>array2d</tt>.
	400
	401	At this point we have to distinguish between the classes <tt> MultiArray </tt> and
393	402	<tt> MultiArrayView </tt>. MultiArray inherits from MultiArrayView and contains the
394		memory management of the array. With MultiArrayView we can view the data stored in a
	403	memory management of the array. With MultiArrayView we can view the data stored in a
395	404	MultiArray. The code above produces a copy of the 3rd column of intArray. If we change the
396	405	elements of <tt>lowArray</tt> nothing happens to <tt> intArray </tt>.
397	406

401	410
402	411	// initialize new 1D array with 3rd column of a 2D array
403	412	MultiArray<1, int> array1d = array2d.bind<0>(2);
404
	413
405	414	// overwrite element [0] of array1d
406	415	array1d[0] = 1;
407
	416
408	417	// this has no effect on the original array2d
409	418	// output: 0 1
410	419	std::cout << array2d(2, 0) << " " << array1d[0] << std::endl;
411
	420
412	421	// initialize a view and overwrite element [0]
413	422	MultiArrayView<1, int> array_view = array2d.bind<0>(2);
414	423	array_view[0] = 2;
415
	424
416	425	// now, the original array2d has changed as well
417	426	// output: 2 2
418	427	std::cout << array2d(2, 0) << " " << array_view[0] << std::endl;
419	428	\endcode
420	429
421		Moving on to image processing we'll give an example how you can flip an image by using
422		bind. We read a gray scale image into a 2-dimensional array called <tt> imageArray </tt>.
	430	Moving on to image processing we'll give an example how you can flip an image by using
	431	bind. We read a gray scale image into a 2-dimensional array called <tt> imageArray </tt>.
423	432	Then we initalize a new array <tt> newImageArray </tt> of the same dimension and size
424		and set the first row of <tt> newImageArray </tt> to the values of the last row of
	433	and set the first row of <tt> newImageArray </tt> to the values of the last row of
425	434	<tt> imageArray </tt>, the second row to the values of the second last row and so on.
426	435	Hence, we flip the image top to bottom.
427	436
428	437	\dontinclude mirror_tutorial.cxx
429		\skip // mirror the image horizontally
	438	\skip // mirror the image horizontally
430	439	\until }
431
432		However, you don't need to implement a method like this yourself because VIGRA already provides the
	440
	441	However, you don't need to implement a method like this yourself because VIGRA already provides the
433	442	function \ref reflectImage(). We use this function to flip the image left-to-right:
434
	443
435	444	\dontinclude mirror_tutorial.cxx
436	445	\skip // mirror the image vertically
437	446	\until reflectImage
438
	447
439	448	The complete example can be found in <a href="mirror_tutorial_8cxx-example.html">mirror_tutorial.cxx</a>.
440		(This program needs an infile and an outfile as command-line arguments and contains additional I/O code
	449	(This program needs an infile and an outfile as command-line arguments and contains additional I/O code
441	450	which will be explained in section \ref ImageInputOutputTutorial.) Here you can see what happens to an input file:
442	451
443	452	<Table cellspacing = "10">

449	458	</Table>
450	459
451	460	For completeness, there are five additional versions of the bind()-method:
452
	461
453	462	<DL>
454	463	<DT><b> bindInner(i) </b> with scalar or multi-dimensional index i:</DT>
455	464	<DD> if i is an <tt> integer </tt>, the innermost dimension (axis 0) is fixed to i, <br>
456		if i is <tt>MultiArrayShape<M>::type</tt> (a shape of size M), then the M innermost
	465	if i is <tt>MultiArrayShape<M>::type</tt> (a shape of size M), then the M innermost
457	466	dimensions (axes 0...M-1) are fixed to the values in the shape vector </DD>
458	467	<DT><b> bindOuter(i) </b> with scalar or multi-dimensional index i:</DT>
459	468	<DD> if i is an <tt> integer </tt>, the outmost dimension (axis N-1) is fixed to i, <br>
460		if i is <tt>MultiArrayShape<M>::type</tt> (a shape of size M), then the M outmost dimensions
	469	if i is <tt>MultiArrayShape<M>::type</tt> (a shape of size M), then the M outmost dimensions
461	470	(axes N-M ... N-1) are fixed to the values in the shape vector </DD>
462	471	<DT><b> diagonal() </b>:</DT>
463		<DD> Create a 1-dimensional view to the diagonal elements of the original array
	472	<DD> Create a 1-dimensional view to the diagonal elements of the original array
464	473	(i.e. <tt>view[i] == array(i,i,i)</tt> for a 3D original array). </DD>
465	474	</DL>
466
	475
467	476	The opposite of binding - inserting a new axis - is also possible. However, since we cannot alter the internal memory layout and thus cannot insert additional data elements, a new axis must be singleton axis, i.e. an axis with length 1. The argument of <tt>insertSingletonDimension(k)</tt> determines the position of the new axis, with <tt>0 <= k <= N</tt> when the original array has <tt>N</tt> dimensions:
468
	477
469	478	\code
470	479	MultiArray<2, int> array(20,10);
471	480	std::cout << array.insertSingletonDimension(1).shape() << "\n"; // prints "(20, 1, 10)"
472	481	\endcode
473
	482
474	483	<hr>
475	484
476	485	\subsection MultiArray_vector_elements expandElements(k) and bindElementChannel(i)
477
	486
478	487	When the array elements are vectors (i.e. \ref vigra::TinyVector or \ref vigra::RGBValue), we can expand these elements into an addtional array dimension:
479	488	\code
480	489	MultiArray<2, TinyVector<int, 3> > vector_array(20, 10);
481	490	std::cout << vector_array.shape() << "\n"; // prints "(20, 10)"
482
	491
483	492	MultiArrayView<3, int> expanded(vector_array.expandElements(2));
484	493	std::cout << expanded.shape() << "\n"; // prints "(20, 10, 3)"
485	494	\endcode
486
487		The argument <tt>k</tt> of <tt>expandElements(k)</tt> determines the desired position of the channel axis, i.e. the index that refers to the vector elements. When the original vector array has <tt>N</tt> dimensions (not counting the channel axis), it is required that <tt>0 <= k <= N</tt>.
488
	495
	496	The argument <tt>k</tt> of <tt>expandElements(k)</tt> determines the desired position of the channel axis, i.e. the index that refers to the vector elements. When the original vector array has <tt>N</tt> dimensions (not counting the channel axis), it is required that <tt>0 <= k <= N</tt>.
	497
489	498	Often, we are only interested in a single channel of a vector-valued array. This can be achieved with the function <tt>bindElementChannel(i)</tt>. For example, we can extract the green channel (i.e. channel 1) from an RGB image like this:
490	499	\code
491	500	MultiArray<2, RGBValue<UInt8> > rgb_array(20, 10);

547	556	Shape of array5D: (1, 2, 3, 4, 5)
548	557	Shape of array5D view after default transpose(): (5, 4, 3, 2, 1)
549	558	\endverbatim
550
	559
551	560	Finally, <tt>MultiArrayView::transpose()</tt> can also be called with a shape object that specifies the desired permutation of the axes: When <tt>permutation[k] = j</tt>, axis <tt>j</tt> of the original array becomes axis <tt>k</tt> of the transposed array (remember, that VIGRA counts the axes from 0):
552
	561
553	562	\dontinclude transpose.cxx
554	563	\skip transpose to an explicitly specified axis permutation
555	564	\until applied permutation
556
	565
557	566	The permutation in the example is 2,1,3,4,0. Thus, original dimension 0 appears in the last position of the new view, original dimension 2 appears in the first position, and so on as demonstrated by the output of the example:
558
	567
559	568	\verbatim
560	569	Shape of array5D view after user-defined transpose(): (3, 2, 4, 5, 1)
561	570	(applied permutation 2 => 0, 1 => 1, 3 => 2, 4 => 3, 0 => 4 to the axes)

580	589
581	590	<b>Important note:</b> Transposing an array also changes the direction of the StridedScanOrderIterator. Imagine a 3x4-
582	591	matrix. Scan-order means that we iterate from left to right, row by row. Now, let's transpose the matrix to a 4x3 view. Than, scan-order in the new view is again left to right, row by row. However, in the original matrix this now corresponds to a transposed scan: from top to bottom, column by column. The same applies to the array's index operator with integer argument.
583
	592
584	593	<hr>
585	594
586	595	\subsection MultiArray_unstrided isUnstrided(k)
587
	596
588	597	A MultiArray always accesses its elements in consecutive memory order, i.e. <tt>&array[i] == &array.data()[i]</tt> for all <tt>i</tt> in the range <tt>[0, array.size())</tt>. However, this does in general not hold for MultiArrayViews, because changing array access is the whole point of view creation. Sometimes, it is necessary to find out if a view still has consecutive, unstrided memory access, for example when you want to pass on the view's data to an external library that only accepts plain C arrays: When the view happens to be unstrided, you can avoid to create a copy of the data. You can determine this with the function <tt>isUnstrided(k)</tt> which returns <tt>true</tt> when the array is unstrided up to dimension <tt>k</tt> (<tt>k</tt> defaults to <tt>N-1</tt>, i.e. the entire array must be unstrided):
589		\code
	598	\code
590	599	MultiArray<2, int> array(20,10);
591	600	std::cout << array.isUnstrided() << " " << array.transpose().isUnstrided() << "\n"; // prints "true false"
592	601	\endcode

617	626	Usage: <TT>subimage_tutorial infile outfile</TT>
618	627	*/
619	628
620
621		/** \page ImageInputOutputTutorial Image Input and Output
	629	/** \example graph_agglomerative_clustering.cxx
	630	Segment an image by hierarchical clustering on top of watershed superpixels
	631	<br>
	632	Usage: <TT>subimage_tutorial infile outfile</TT>
	633	*/
	634
	635
	636	/** \page ImageInputOutputTutorial Image Input and Output
622	637
623	638	<h2>Section Contents</h2>
624		<ul style="list-style-image:url(documents/bullet.gif)">
	639	<ul style="list-style-image:url(documents/diamond.gif)">
625	640	<li> \ref Impex2D
626	641	<li> \ref ImpexND
627	642	</ul>
628	643
629	644	\section Impex2D Two-Dimensional Images
630
	645
631	646	In this section we'll show you how to import and export an image with VIGRA. If you
632		want to import an image from disk and enquire about its properties, you must use an
633		object of <tt>vigra::ImageImportInfo</tt> class. It reads the header of the image file.
634		The constructor expects the file name, the file type will be determined automatically.
635
	647	want to import an image from disk and enquire about its properties, you must use an
	648	object of <tt>vigra::ImageImportInfo</tt> class. It reads the header of the image file.
	649	The constructor expects the file name, the file type will be determined automatically.
	650
636	651	The <tt>vigra::ImageImportInfo</tt> class currently recognizes the following file formats:
637	652
638	653	<DL>

669	684	\dontinclude imageImportInfo_tutorial.cxx
670	685	\skip read image
671	686	\until numBands
672
	687
673	688
674	689	As you can see, the <tt> ImageImportInfo </tt> object contains a lot of information,
675	690	some of it is printed in the example. Using this image

692	707	\dontinclude imageIO_tutorial.cxx
693	708	\skip read image
694	709	\until importImage(imageInfo
695
	710
696	711	If you already know the type of data in the file, you can also just pass the filename and a MultiArray, which will automatically be resized as appropariate:
697	712
698	713	\dontinclude imageIO_tutorial.cxx
699	714	\skip if you don't need
700	715	\until importImage(in_filename
701
	716
702	717	Writing the image data from an array to a file is quite similar. For this purpose, you use the function \ref vigra::exportImage(), which takes an 2D MultiArrayView and an \ref vigra::ImageExportInfo object or a string (the filename). The ImageExportInfo object also needs a file name, but gives you more control over how the image is written. The desired file format is guessed from the file name's extension (but can be overridden with the method <tt>ImageExportInfo::setFileType</tt>. Recognized extensions are: '.bmp', '.exr', '.gif', '.jpeg', '.jpg', '.p7', '.png', '.pbm', '.pgm', '.pnm', '.ppm', '.ras', '.tif', '.tiff', '.xv', '.hdr' (as for reading, '.exr' requires libopenexr, '.jpg' requires libjpeg, '.png' requires libpng and '.tif' requires libtiff). In the following example, we create and save a 160x160 pixels image, where the image is a checkerboard. The image is saved as "testimage.gif" in the same folder as the executed code.
703	718
704	719	\include imageExportInfo_tutorial.cxx

720	735	\include imageIO_tutorial.cxx
721	736
722	737	The input image and the resulting output image are:
723
	738
724	739	<Table cellspacing = "10">
725	740	<TR valign="bottom">
726	741	<TD> \image html lenna_small.gif "input image" </TD>

737	752	In this case, it is better to import and convert the data into a <tt>float</tt> array (i.e. <tt>vigra::MultiArray<2, float></tt>) instead of the simple <tt>unsigned char</tt> type in order to minimize rounding errors. When a file is imported into such an array, the conversion is automatically performed by the importImage() function. When an array is to be exported, the handling of <tt>float</tt> depends on the file format: If the file format supports float (currently: TIFF and VIFF), the data are written verbatim (unless this is explicitly overridden, see below). Otherwise, the data are mapped to <tt>unsigned char</tt> via a linear transform of the orginal range, followed by rounding (use \ref vigra::linearRangeMapping() to override this behavior by an explicit user-defined mapping).
738	753
739	754	The <tt>ImageExportInfo</tt> class provides a number of additional methods to <b>customize data export</b>, including:
740
	755
741	756	<DL>
742	757	<DT><b>setCompression():</b></dt>
743	758	<DD>Request compressed storage if the file format supports it.</DD>

748	763	<DT><b> setXResolution(), setYResolution:</b></dt>
749	764	<DD>Store resolution information for the two axes (ignored if unsupported by the file format).</DD>
750	765	</DL>
751
	766
752	767	See \ref vigra::ImageExportInfo for a complete list and more details.
753	768
754	769	\section ImpexND Higher Dimensional Arrays
755
	770
756	771	The recommended file format for arrays of arbitrary dimension is <a href="http://www.hdfgroup.org/HDF5/">HDF5</a>. It supports all possible pixel types, arbitrary dimensions, on-the-fly compression, arbitrary many arrays per file, and flexible metadata storage along with arrays. See \ref VigraHDF5Impex for more information.
757	772
758	773	The functions \ref importVolume() and \ref exportVolume() support three additional methods to read and write 3D volume data:

782	797	*/
783	798
784	799	/** \page MultiArrayArithmeticTutorial Mathematics with Multi-Dimensional Arrays
785
	800
786	801	VIGRA supports various way to perform mathematical operations (arithmetic and algebraic functions, linear alebra) on arrays. Most of these functions operate element-wise.
787
788		<ul style="list-style-image:url(documents/bullet.gif)">
	802
	803	<ul style="list-style-image:url(documents/diamond.gif)">
789	804	<li> \ref MultiMathModule "Array Expressions"
790	805	<BR>The \ref MultiMathModule "vigra::multi_math" module overloads the usual arithmetic operators and algebraic functions for array arguments, similar to Matlab and numpy. This leads to very efficient and readable code.
791	806	<li> \ref LinearAlgebraModule "Linear Algebra"

794	809	<BR>VIGRA also provides functions like <tt>transformMultiArray()</tt> that generalize the corresponding STL functions to multiple dimensions. The functors needed for these functions are most easily created with the \ref FunctorExpressions module, VIGRA's "lambda library". This approach offers more flexibility than the array expressions above.
795	810	<li> \ref FeatureAccumulators
796	811	<BR>The \ref FeatureAccumulators "vigra::acc" module provides powerful and efficient methods to compute statistics accross entire arrays or arbitrary subparts of them.
797		</ul>
	812	</ul>
798	813	*/
799	814
800	815	/** \page OwnFunctionsTutorial Writing your own Functions
801
802		Sooner or later, you will want to implement your own functions on the basis of VIGRA's functionality. Some people believe that this is very difficult because one needs to provide a lot of template magic and full genericity. However, this is <i>not</i> true: Your VIGRA functions need not be templated at all -- function arguments can simply be hard-wired. In other cases, it makes sense to template on the pixel type, but leave averything else fixed. Full genericity should only be implemented step-by-step as needed.
803
804		As an example, consider again the image smoothing example program <a href="smooth_explicitly_8cxx-example.html">smooth_explicitly.cxx</a>. It makes sense to encapsulate the smoothing algorithm into a function of its own. When we only need to support <tt>float</tt> images, the function is simply a verbatim copy of the algorithm. In contrast to the original version, we now allow an arbitrary window radius to be passed to the algorithm, so that the amount of smoothing can be controlled (this also nicely illustrates the use of <tt>vigra_precondition()</tt> for \ref ErrorReporting):
805
	816
	817	Sooner or later, you will want to implement your own functions on the basis of VIGRA's functionality. Some people believe that this is very difficult because one needs to provide a lot of template magic and full genericity. However, this is <i>not</i> true: Your VIGRA functions need not be templated at all -- function arguments can simply be hard-wired. In other cases, it makes sense to template on the pixel type, but leave averything else fixed. Full genericity should only be implemented step-by-step as needed.
	818
	819	As an example, consider again the image smoothing example program <a href="smooth_explicitly_8cxx-example.html">smooth_explicitly.cxx</a>. It makes sense to encapsulate the smoothing algorithm into a function of its own. When we only need to support <tt>float</tt> images, the function is simply a verbatim copy of the algorithm. In contrast to the original version, we now allow an arbitrary window radius to be passed to the algorithm, so that the amount of smoothing can be controlled (this also nicely illustrates the use of <tt>vigra_precondition()</tt> for \ref ErrorReporting):
	820
806	821	\code
807	822	void smooth(MultiArrayView<2, float> input, MultiArrayView<2, float> result, int radius)
808	823	{
809	824	vigra_precondition(radius >= 0, "smooth(): window radius must not be negative.");
810
	825
811	826	Shape2 current;
812	827	for(current[1] = 0; current[1] < input.shape(1); ++current[1])
813	828	{

821	836	}
822	837	}
823	838	\endcode
824
825		If we don't need to support any higher dimension or other pixel type, we can just leave it at this -- no templates are required then.
826
	839
	840	If we don't need to support any higher dimension or other pixel type, we can just leave it at this -- no templates are required then.
	841
827	842	But suppose now that we want to generalize this code for arbitrary dimensional arrays. To do so, we specify the dimension <tt>N</tt> as a template parameter. Then we can no longer use <tt>Shape2</tt> because this class only works for 2-dimensional arrays. Instead, we use the <tt>MultiArrayShape</tt> traits class to ask for the appropriate shape object. Moreover, we cannot iterate over the array with two explicitly nested loops because the number of loops must correspond to the (unknown) number of dimensions. We can solve this problems by means of a \ref vigra::MultiCoordinateIterator from <tt>multi_iterator_coupled.hxx</tt> that iterates over all coordinates of an array, regardless of dimension. The current coordinate is returned by dereferencing the iterator:
828
	843
829	844	\code
830	845	#include <vigra/multi_iterator_coupled.hxx>
831
	846
832	847	template <unsigned int N>
833	848	void smooth(MultiArrayView<N, float> input, MultiArrayView<N, float> result, int radius)
834	849	{
835	850	vigra_precondition(radius >= 0, "smooth(): window radius must not be negative.");
836
	851
837	852	typedef typename MultiArrayShape<N>::type Shape;
838
	853
839	854	typename MultiCoordinateIterator<N> current(input.shape()),
840	855	end = current.getEndIterator();
841
	856
842	857	for(; current != end; ++current)
843	858	{
844	859	Shape windowStart = max(Shape(0), *current - Shape(radius));

848	863	}
849	864	}
850	865	\endcode
851
	866
852	867	Another useful generalization is in terms of the array's value_type. For one, we want to be able to smooth color images as well. Furthermore, most images are stored with pixel type <tt>unsigned char</tt>, and we don't want to force the user to convert them into <tt>float</tt> images before smoothing. We therefore specify the value_types as template parameters as well (notice that we allow input and result to have different types). In addition, we have to make the type of the sum in <tt>window.sum<...>()</tt> generic. However, there is a caveat: We cannot simply use the input value_type here, because this might lead to overflow. This is easily seen when the value_type is <tt>unsigned char</tt>: This type already overflows when the sum exceeds the value 255, which is very likely to happen even if the windows is only 3x3. In situations like this, a suitable temporary type for the sum can be obtained from the <tt>RealPromote</tt> type in VIGRA's \ref NumericTraits "NumericTraits" class:
853
	868
854	869	\code
855	870	template <unsigned int N, class InputValue, class ResultValue>
856		void smooth(MultiArrayView<N, InputValue> input,
857		MultiArrayView<N, ResultValue> result,
	871	void smooth(MultiArrayView<N, InputValue> input,
	872	MultiArrayView<N, ResultValue> result,
858	873	int radius)
859	874	{
860	875	vigra_precondition(radius >= 0, "smooth(): window radius must not be negative.");
861
	876
862	877	typedef typename MultiArrayShape<N>::type Shape;
863	878	typedef typename NumericTraits<InputValue>::RealPromote SumType;
864
	879
865	880	typename MultiCoordinateIterator<N> current(input.shape()),
866	881	end = current.getEndIterator();
867
	882
868	883	for(; current != end; ++current)
869	884	{
870	885	Shape windowStart = max(Shape(0), *current - Shape(radius));

874	889	}
875	890	}
876	891	\endcode
877
	892
878	893	These simple tricks already get you a long way in the advanced use of VIGRA. You will notice, that many existing VIGRA functions are not implemented in temrs of \ref vigra::MultiArrayView, but in terms of \ref ImageIterators "image iterators" and \ref MultiIteratorGroup "hierarchical iterators". However, these iterators are more difficult to use, so the MultiArrayView approach is recommended for new code.
879	894	*/
880	895
881	896	/** \page PythonBindingsTutorial VIGRA Python Bindings
882
	897
883	898	See also the full <a href="../vigranumpy/index.html">vigranumpy reference</a>!
884
	899
885	900	When you configure VIGRA with the option <tt>-DWITH_VIGRANUMPY=1</tt> while running cmake, a Python module <tt>vigra</tt> will be compiled and installed. It exposes most of VIGRA's functionality for easy scripting and prototyping in Python. Most importantly, VIGRA's Python bindings are fully integrated with the popular 'numpy' package so that you can call vigra functions directly with numpy <tt>ndarrays</tt>. No explicit or implicit conversion of data formats is required.
886
	901
887	902	The syntax of the Python version is usually very similar to the C++ syntax, with one important difference: You do not have to pass pre-allocated result arrays to the functions. That is, while the call to <tt>gaussianSmoothing()</tt> in C++ is written like this
888
889		\code
890		MultiArray<2, float> inputImage(Shape2(width, height)),
	903
	904	\code
	905	MultiArray<2, float> inputImage(Shape2(width, height)),
891	906	resultImage(inputImage.shape()); // pre-allocate result with correct shape
892	907	... // fill inputImage
893
	908
894	909	// smooth image with Gaussian filter with sigma=1.5
895	910	// (pre-allocated resultImage must be passed to the function)
896	911	gaussianSmoothing(inputImage, resultImage, 1.5);
897	912	\endcode
898
	913
899	914	the corresponding Python call is
900
	915
901	916	\code
902	917	>>> import numpy, vigra
903
	918
904	919	>>> inputImage = numpy.zeros((width, height), dtype=numpy.float32)
905	920	... # fill inputImage
906
	921
907	922	>>> resultImage = vigra.filters.gaussianSmoothing(inputImage, 1.5);
908	923	\endcode
909
	924
910	925	The result image is automatically allocated and returned by the function. Nonetheless, it is still possible to pass a result array of appropriate shape explicitly by means of the <tt>out</tt> parameter:
911
	926
912	927	\code
913	928	>>> resultImage = numpy.zeros(inputImage.shape, dtype=numpy.float32)
914	929	>>> vigra.filters.gaussianSmoothing(inputImage, 1.5, out=resultImage)
915	930	\endcode
916
	931
917	932	This is, for example, useful when the same result image should be reused in several calls of the same function to avoid the repeated creation of new result arrays. Another possible use is the application of a function to only a rectangular region-of-interest: When the full result array is already allocated, you can pass a view of the approriate subarray to the <tt>out</tt> parameter in order to fill just the desired ROI.
918
	933
919	934	When a C++ function provides options, they are exposed on the Python side as keyword arguments:
920
	935
921	936	\code
922	937	>>> labeling, max_label = vigra.analysis.watersheds(inputImage, seeds=seedImage, method='UnionFind')
923	938	\endcode
924
	939
925	940	In general, the correspondence between a Python function and its C++ counterpart is straightforward, and the Python documentation frequently refers to the C++ documentation for details. However, there is a crucial difference: the default axis interpretation is different in VIGRA's <tt>MultiArray</tt> (which interpretes axes as x, y, z, so called 'Fortran' order) and in numpy's <tt>ndarray</tt> (which interpretes them as z, y, x, so called 'C'-order). To help you deal with this difficulty, vigranumpy provides a subclass <a href="../vigranumpy/index.html#axistags-and-the-vigraarray-data-structure">VigraArray</a> of <tt>ndarray</tt> and the concept of <a href="../vigranumpy/index.html#more-on-the-motivation-and-use-of-axistags">axistags</a>. Please take the time to read this material in order to avoid surprises.
926
	941
927	942	The full <a href="../vigranumpy/index.html">vigranumpy reference</a> is available via HTML or can be obtained directly at the Python prompt by the <tt>help()</tt> command:
928
	943
929	944	\code
930	945	>>> help(vigra.filters.gaussianSmoothing)
931	946	\endcode
932
	947
933	948	Another important difference between C++ and Python is that vigranumpy exposes most functions only for a restricted set of pixel types. This restriction is necessary because support for all possible type combinations would result in a combinatorial explosion and unreasonably large Python modules. In general, all functions are implemented for <tt>float</tt> pixel types (called <tt>numpy.float32</tt> on the Python side), and some provide <tt>uint8</tt> and/or <tt>uint32</tt> versions in addition. If you call a function with an unsupported pixel type, an error message listing the supported types will be printed:
934
	949
935	950	\code
936	951	>>> a = vigra.ScalarImage((20,20), dtype=numpy.float64)
937	952

939	954	ArgumentError: Python argument types in
940	955	vigra.filters.gaussianSmoothing(numpy.ndarray, int)
941	956	did not match C++ signature:
942		gaussianSmoothing(class vigra::NumpyArray<3,struct vigra::Multiband<float>,struct vigra::StridedArrayTag> array, class boost::python::api::object sigma, class vigra::NumpyArray<3,struct vigra::Multiband<float>,struct vigra::StridedArrayTag> out=None, class boost::python::api::object sigma_d=0.0, class boost::python::api::object step_size=1.0, double window_size=0.0, class boost::python::api::object roi=None)
	957	gaussianSmoothing(class vigra::NumpyArray<3,struct vigra::Multiband<float>,struct vigra::StridedArrayTag> array, class boost::python::api::object sigma, class vigra::NumpyArray<3,struct vigra::Multiband<float>,struct vigra::StridedArrayTag> out=None, class boost::python::api::object sigma_d=0.0, class boost::python::api::object step_size=1.0, double window_size=0.0, class boost::python::api::object roi=None)
943	958
944	959	gaussianSmoothing(class vigra::NumpyArray<4,struct vigra::Multiband<float>,struct vigra::StridedArrayTag> array, class boost::python::api::object sigma, class vigra::NumpyArray<4,struct vigra::Multiband<float>,struct vigra::StridedArrayTag> out=None, class boost::python::api::object sigma_d=0.0, class boost::python::api::object step_size=1.0, double window_size=0.0, class boost::python::api::object roi=None)
945	960	\endcode
946
947		The error message is automatically generated by boost::python and therefore rather technical. It says that <tt>%gaussianSmoothing()</tt> supports 3- and 4-dimensional arrays where the rightmost dimension is interpreted as a channel axis, and the pixel type must be <tt>float</tt> (these properties are indicated by the type specifications <tt>NumpyArray<3,struct vigra::Multiband<float></tt> and <tt>NumpyArray<4,struct vigra::Multiband<float></tt> respectively). Thus, the input array must be a <tt>float32</tt> image or volume with either no explicit channel axis (in which case a singleton channel axis will be inserted automatically) or with arbitrary many channels (e.g. RGB).
948
	961
	962	The error message is automatically generated by boost::python and therefore rather technical. It says that <tt>%gaussianSmoothing()</tt> supports 3- and 4-dimensional arrays where the rightmost dimension is interpreted as a channel axis, and the pixel type must be <tt>float</tt> (these properties are indicated by the type specifications <tt>NumpyArray<3,struct vigra::Multiband<float></tt> and <tt>NumpyArray<4,struct vigra::Multiband<float></tt> respectively). Thus, the input array must be a <tt>float32</tt> image or volume with either no explicit channel axis (in which case a singleton channel axis will be inserted automatically) or with arbitrary many channels (e.g. RGB).
	963
949	964	<a href="../vigranumpy/index.html#more-on-the-motivation-and-use-of-axistags">Axistags</a> allow vigranumpy to distinguish if a given 3-dimensional array is to be interpreted as a 2D image with multiple channels, or as a 3D volume with only a single channel. If no axistags are attached to the array, it is unspecified which version of an algorithm will be called. Axistags are automatically specified when arrays are created with one of the factory functions in the <tt>vigra</tt> module, for example:
950
	965
951	966	\code
952	967	>>> a = vigra.ScalarImage((30, 20))
953	968	>>> print("%s \n %r" % (a.shape, a.axistags))

969	984	(30L, 20L, 10L, 3L)
970	985	x y z c
971	986	\endcode
972
	987
973	988	Axistags are encoded 'x', 'y', 'z' for the three spatial axes, 'c' for a channel axis, and 't' for a time axis. If the channel axis is missing, vigranumpy will assume that the array has only a single channel. That is, arrays with shape (30, 20, 1) and axistags 'x y c' are equivalent to arrays with shape (30, 20) and axistags 'x y'. Functions that change the order of the axes (such as <tt>%array.transpose()</tt>) or reduce the number of axes (e.g. <tt>array[:, 1, :]</tt>) also modify the axistags accordingly, so that you can always ask for the axis meaning by simply calling <tt>array.axistags</tt>.
974	989	*/

+7

-1

include/vigra/accumulator-grammar.hxx less more

101	101	class RegionCircularity; // compare perimeter of a 2D region with a circle of same area
102	102	class RegionEccentricity; // ecentricity of a 2D region from major and minor axis
103	103
104		class ConvexHull; // base class for convex hull features
	104	#ifdef WITH_LEMON
	105	class ConvexHull; // base class for convex hull computation
	106	class ConvexHullFeatures; // base class for convex hull features
	107	#endif
105	108
106	109	/*
107	110	Quantiles other than minimum and maximum require more thought:

488	491
489	492	// ignore all modifiers of RegionContour and related features
490	493	VIGRA_REDUCE_MODFIER(template <class> class A, A<RegionContour>, RegionContour)
	494	#ifdef WITH_LEMON
491	495	VIGRA_REDUCE_MODFIER(template <class> class A, A<ConvexHull>, ConvexHull)
	496	VIGRA_REDUCE_MODFIER(template <class> class A, A<ConvexHullFeatures>, ConvexHullFeatures)
	497	#endif // WITH_LEMON
492	498	VIGRA_REDUCE_MODFIER(template <class> class A, A<RegionPerimeter>, RegionPerimeter)
493	499	VIGRA_REDUCE_MODFIER(template <class> class A, A<RegionCircularity>, RegionCircularity)
494	500	VIGRA_REDUCE_MODFIER(template <class> class A, A<RegionEccentricity>, RegionEccentricity)

+381

-311

include/vigra/accumulator.hxx less more

52	52	#include "eigensystem.hxx"
53	53	#include "histogram.hxx"
54	54	#include "polygon.hxx"
	55	#ifdef WITH_LEMON
	56	#include "polytope.hxx"
	57	#endif
55	58	#include "functorexpression.hxx"
56	59	#include "labelimage.hxx"
	60	#include "multi_labeling.hxx"
57	61	#include <algorithm>
58	62	#include <iostream>
59	63

372	376	*/
373	377
374	378
375		/** This namespace contains the accumulator classes, fundamental statistics and modifiers. See \ref FeatureAccumulators for examples of usage.
	379	/** \brief Efficient computation of object statistics.
	380
	381	This namespace contains the accumulator classes, fundamental statistics and modifiers. See \ref FeatureAccumulators for examples of usage.
376	382	*/
377	383	namespace acc {
378	384

709	715	struct CollectAccumulatorNames<void>
710	716	{
711	717	template <class BackInsertable>
712		static void exec(BackInsertable & a, bool skipInternals=true)
	718	static void exec(BackInsertable &, bool /* skipInternals */ = true)
713	719	{}
714	720	};
715	721

739	745	struct ApplyVisitorToTag<void>
740	746	{
741	747	template <class Accu, class Visitor>
742		static bool exec(Accu & a, std::string const & tag, Visitor const & v)
	748	static bool exec(Accu &, std::string const &, Visitor const &)
743	749	{
744	750	return false;
745	751	}

775	781	struct SetHistogramBincount
776	782	{
777	783	template <class Accu>
778		static void exec(Accu & a, HistogramOptions const & options)
	784	static void exec(Accu &, HistogramOptions const &)
779	785	{}
780	786	};
781	787

793	799	struct ApplyHistogramOptions
794	800	{
795	801	template <class Accu>
796		static void exec(Accu & a, HistogramOptions const & options)
	802	static void exec(Accu &, HistogramOptions const &)
797	803	{}
798	804	};
799	805

801	807	struct ApplyHistogramOptions<StandardQuantiles<TAG> >
802	808	{
803	809	template <class Accu>
804		static void exec(Accu & a, HistogramOptions const & options)
	810	static void exec(Accu &, HistogramOptions const &)
805	811	{}
806	812	};
807	813

990	996	struct DecoratorImpl
991	997	{
992	998	template <class T>
993		static void exec(A & a, T const & t)
	999	static void exec(A &, T const &)
994	1000	{}
995	1001
996	1002	template <class T>
997		static void exec(A & a, T const & t, double weight)
	1003	static void exec(A &, T const &, double)
998	1004	{}
999	1005	};
1000	1006

2326	2332
2327	2333	template<class IGNORED_DATA>
2328	2334	void
2329		updatePassN(const IGNORED_DATA & ignoreData,
	2335	updatePassN(const IGNORED_DATA &,
2330	2336	const CoordType & coord,
2331	2337	unsigned int p)
2332	2338	{

3637	3643
3638	3644	static const unsigned int workInPass = 2;
3639	3645
3640		void operator+=(Impl const & o)
	3646	void operator+=(Impl const &)
3641	3647	{
3642	3648	vigra_precondition(false,
3643	3649	"Central<...>::operator+=(): not supported.");
3644	3650	}
3645	3651
3646	3652	template <class T>
3647		void update(T const & t)
	3653	void update(T const &)
3648	3654	{
3649	3655	ImplType::update(getDependency<Centralize>(*this));
3650	3656	}
3651	3657
3652	3658	template <class T>
3653		void update(T const & t, double weight)
	3659	void update(T const &, double weight)
3654	3660	{
3655	3661	ImplType::update(getDependency<Centralize>(*this), weight);
3656	3662	}

3789	3795
3790	3796	static const unsigned int workInPass = 2;
3791	3797
3792		void operator+=(Impl const & o)
	3798	void operator+=(Impl const &)
3793	3799	{
3794	3800	vigra_precondition(false,
3795	3801	"Principal<...>::operator+=(): not supported.");
3796	3802	}
3797	3803
3798	3804	template <class T>
3799		void update(T const & t)
	3805	void update(T const &)
3800	3806	{
3801	3807	ImplType::update(getDependency<PrincipalProjection>(*this));
3802	3808	}
3803	3809
3804	3810	template <class T>
3805		void update(T const & t, double weight)
	3811	void update(T const &, double weight)
3806	3812	{
3807	3813	ImplType::update(getDependency<PrincipalProjection>(*this), weight);
3808	3814	}

3936	3942	struct Impl
3937	3943	: public SumBaseImpl<BASE, T, double, double>
3938	3944	{
3939		void update(T const & t)
	3945	void update(T const &)
3940	3946	{
3941	3947	++this->value_;
3942	3948	}
3943	3949
3944		void update(T const & t, double weight)
	3950	void update(T const &, double weight)
3945	3951	{
3946	3952	this->value_ += weight;
3947	3953	}

4355	4361	}
4356	4362	}
4357	4363
4358		void update(U const & t)
	4364	void update(U const &)
4359	4365	{
4360	4366	using namespace vigra::multi_math;
4361	4367	this->value_ += pow(getDependency<Centralize>(*this), 3);
4362	4368	}
4363	4369
4364		void update(U const & t, double weight)
	4370	void update(U const &, double weight)
4365	4371	{
4366	4372	using namespace vigra::multi_math;
4367	4373	this->value_ += weightpow(getDependency<Centralize>(this), 3);

4416	4422	}
4417	4423	}
4418	4424
4419		void update(U const & t)
	4425	void update(U const &)
4420	4426	{
4421	4427	using namespace vigra::multi_math;
4422	4428	this->value_ += pow(getDependency<Centralize>(*this), 4);
4423	4429	}
4424	4430
4425		void update(U const & t, double weight)
	4431	void update(U const &, double weight)
4426	4432	{
4427	4433	using namespace vigra::multi_math;
4428	4434	this->value_ += weightpow(getDependency<Centralize>(this), 4);

5325	5331	value_ = t;
5326	5332	}
5327	5333
5328		void update(U const & t, double weight)
	5334	void update(U const & t, double)
5329	5335	{
5330	5336	update(t);
5331	5337	}

5424	5430	}
5425	5431	}
5426	5432
5427		void update(U const & t)
	5433	void update(U const &)
5428	5434	{
5429	5435	vigra_precondition(false, "ArgMinWeight::update() needs weights.");
5430	5436	}

5499	5505	}
5500	5506	}
5501	5507
5502		void update(U const & t)
	5508	void update(U const &)
5503	5509	{
5504	5510	vigra_precondition(false, "ArgMaxWeight::update() needs weights.");
5505	5511	}

5814	5820	++this->value_[index];
5815	5821	}
5816	5822
5817		void update(int index, double weight)
	5823	void update(int, double)
5818	5824	{
5819	5825	// cannot compute quantile from weighted integer histograms,
5820	5826	// so force people to use UserRangeHistogram or AutoRangeHistogram

6137	6143	}
6138	6144
6139	6145	template <class U, class NEXT>
6140		void update(CoupledHandle<U, NEXT> const & t, double weight)
	6146	void update(CoupledHandle<U, NEXT> const & t, double)
6141	6147	{
6142	6148	update(t);
6143	6149	}
6144	6150
6145		void operator+=(Impl const & o)
	6151	void operator+=(Impl const &)
6146	6152	{
6147	6153	vigra_precondition(false,
6148	6154	"RegionContour::operator+=(): RegionContour cannot be merged.");

6255	6261	};
6256	6262	};
6257	6263
6258		template <int N>
6259		struct feature_ConvexHull_can_only_be_computed_for_2D_arrays
6260		: vigra::staticAssert::AssertBool<N==2>
6261		{};
6262
6263		/** \brief Compute the contour of a 2D region.
6264
6265		AccumulatorChain must be used with CoupledIterator in order to have access to pixel coordinates.
	6264	// Compile only if lemon is available
	6265	#ifdef WITH_LEMON
	6266
	6267	/** \brief Compute the convex hull of a region.
	6268
	6269	AccumulatorChain must be used with CoupledIterator in order to have access
	6270	to pixel coordinates.
	6271
	6272	The result type is the ConvexPolytop class.
6266	6273	*/
6267	6274	class ConvexHull
6268	6275	{
6269	6276	public:
6270		typedef Select<BoundingBox, RegionContour, RegionCenter> Dependencies;
	6277	typedef Select<RegionCenter> Dependencies;
6271	6278
6272	6279	static std::string name()
6273	6280	{
6274	6281	return std::string("ConvexHull");
6275		// static const std::string n = std::string("ConvexHull");
6276		// return n;
6277	6282	}
6278	6283
6279	6284	template <class T, class BASE>
6280	6285	struct Impl
6281	6286	: public BASE
6282	6287	{
6283		static const unsigned int workInPass = 2;
6284
6285		typedef HandleArgSelector<T, LabelArgTag, BASE> LabelHandle;
6286		typedef TinyVector<double, 2> point_type;
6287		typedef Polygon<point_type> polygon_type;
6288		typedef Impl value_type;
6289		typedef value_type const & result_type;
6290
6291		polygon_type convex_hull_;
6292		point_type input_center_, convex_hull_center_, defect_center_;
6293		double convexity_, rugosity_, mean_defect_displacement_,
6294		defect_area_mean_, defect_area_variance_, defect_area_skewness_, defect_area_kurtosis_;
6295		int convexity_defect_count_;
6296		ArrayVector<MultiArrayIndex> convexity_defect_area_;
6297		bool features_computed_;
	6288	static const unsigned int workInPass = 2;
	6289	static const unsigned int dimensions = T::dimensions;
	6290
	6291	typedef ConvexPolytope<dimensions, double> polytope_type;
	6292	typedef polytope_type value_type;
	6293	typedef value_type const & result_type;
	6294	typedef TinyVector<double, dimensions> point_type;
	6295	typedef HandleArgSelector<T, CoordArgTag, BASE> coord_handle_type;
	6296	typedef typename coord_handle_type::value_type coord_type;
	6297
	6298	polytope_type convex_hull_;
	6299	bool initialized_;
6298	6300
6299	6301	Impl()
6300	6302	: convex_hull_()
6301		, input_center_()
6302		, convex_hull_center_()
6303		, defect_center_()
6304		, convexity_()
6305		, rugosity_()
6306		, mean_defect_displacement_()
6307		, defect_area_mean_()
6308		, defect_area_variance_()
6309		, defect_area_skewness_()
6310		, defect_area_kurtosis_()
6311		, convexity_defect_count_()
6312		, convexity_defect_area_()
6313		, features_computed_(false)
	6303	, initialized_(false)
6314	6304	{}
6315	6305
6316	6306	template <class U, class NEXT>
6317	6307	void update(CoupledHandle<U, NEXT> const & t)
6318	6308	{
6319		VIGRA_STATIC_ASSERT((feature_ConvexHull_can_only_be_computed_for_2D_arrays<
6320		CoupledHandle<U, NEXT>::dimensions>));
6321		if(!features_computed_)
	6309	if (!initialized_)
6322	6310	{
6323		using namespace functor;
6324		Shape2 start = getDependency<Coord<Minimum> >(*this),
6325		stop = getDependency<Coord<Maximum> >(*this) + Shape2(1);
6326		point_type offset(start);
6327		input_center_ = getDependency<RegionCenter>(*this);
6328		MultiArrayIndex label = LabelHandle::getValue(t);
6329
6330		convex_hull_.clear();
6331		convexHull(getDependency<RegionContour>(*this), convex_hull_);
6332		convex_hull_center_ = centroid(convex_hull_);
6333
6334		convexity_ = getDependency<RegionContour>(*this).area() / convex_hull_.area();
6335		rugosity_ = getDependency<RegionContour>(*this).length() / convex_hull_.length();
6336
6337		MultiArray<2, UInt8> convex_hull_difference(stop-start);
6338		fillPolygon(convex_hull_ - offset, convex_hull_difference, 1);
6339		combineTwoMultiArrays(convex_hull_difference,
6340		LabelHandle::getHandle(t).arrayView().subarray(start, stop),
6341		convex_hull_difference,
6342		ifThenElse(Arg2() == Param(label), Param(0), Arg1()));
6343
6344		MultiArray<2, UInt32> convexity_defects(stop-start);
6345		convexity_defect_count_ =
6346		labelImageWithBackground(convex_hull_difference, convexity_defects, false, 0);
6347
6348		if (convexity_defect_count_ != 0)
	6311	initialize();
	6312	}
	6313	point_type vec(t.point().begin());
	6314	convex_hull_.addExtremeVertex(vec);
	6315	}
	6316
	6317	template <class U, class NEXT>
	6318	void update(CoupledHandle<U, NEXT> const & t, double)
	6319	{
	6320	update(t);
	6321	}
	6322
	6323	void initialize()
	6324	{
	6325	convex_hull_.addVertex(getDependency<RegionCenter>(*this));
	6326	for (int dim = 0; dim < dimensions; dim++)
	6327	{
	6328	coord_type vec;
	6329	vec[dim] = .5;
	6330	convex_hull_.addVertex(
	6331	vec + getDependency<RegionCenter>(*this));
	6332	}
	6333	initialized_ = true;
	6334	}
	6335
	6336	void operator+=(Impl const &)
	6337	{
	6338	vigra_precondition(
	6339	false,
	6340	"ConvexHull::operator+=(): ConvexHull features cannot be merged.");
	6341	}
	6342
	6343	result_type operator()() const
	6344	{
	6345	return convex_hull_;
	6346	}
	6347	};
	6348	};
	6349
	6350	/** \brief Compute object features related to the convex hull.
	6351
	6352	AccumulatorChain must be used with CoupledIterator in order to have access
	6353	to pixel coordinates. The convex hull features are only available when
	6354	`WITH_LEMON` is set.
	6355
	6356	Minimal example how to calculate the features:
	6357	\code
	6358	// "labels" is the array with the region labels
	6359	MultiArrayView<2, int> labels = ...;
	6360
	6361	// Set up the accumulator chain and ignore the zero label
	6362	AccumulatorChainArray<
	6363	CoupledArrays<2, int>,
	6364	Select<LabelArg<1>, ConvexHullFeatures> > chain;
	6365	chain.ignoreLabel(0);
	6366
	6367	// Extract the features
	6368	extractFeatures(labels, chain);
	6369
	6370	// Finalize the calculation for label 1
	6371	getAccumulator<ConvexHullFeatures>(chain, 1).finalize();
	6372
	6373	// Get the features
	6374	... = getAccumulator<ConvexHullFeatures>(chain, 1).inputCenter();
	6375	\endcode
	6376
	6377	*/
	6378	class ConvexHullFeatures
	6379	{
	6380	public:
	6381	typedef Select<BoundingBox, RegionCenter, Count, ConvexHull> Dependencies;
	6382
	6383	static std::string name()
	6384	{
	6385	return std::string("ConvexHullFeatures");
	6386	}
	6387
	6388	/** \brief Result type of the covex hull feature calculation
	6389	*/
	6390	template <class T, class BASE>
	6391	struct Impl
	6392	: public BASE
	6393	{
	6394	static const unsigned int workInPass = 3;
	6395	static const unsigned int dimensions = T::dimensions;
	6396
	6397	typedef ConvexPolytope<dimensions, double> polytope_type;
	6398	typedef Impl<T, BASE> value_type;
	6399	typedef value_type const & result_type;
	6400	typedef TinyVector<double, dimensions> point_type;
	6401	typedef HandleArgSelector<T, CoordArgTag, BASE> coord_handle_type;
	6402	typedef typename coord_handle_type::value_type coord_type;
	6403
	6404	typedef MultiArray<dimensions, unsigned int> array_type;
	6405
	6406	array_type label_array_;
	6407	point_type hull_center_;
	6408	int hull_volume_;
	6409	point_type defect_center_;
	6410	double defect_displacement_mean_;
	6411	double defect_volume_mean_;
	6412	double defect_volume_variance_;
	6413	double defect_volume_skewness_;
	6414	double defect_volume_kurtosis_;
	6415	int defect_count_;
	6416	bool initialized_;
	6417	bool finalized_;
	6418	int num_values_;
	6419
	6420	Impl()
	6421	: hull_center_()
	6422	, hull_volume_()
	6423	, defect_center_()
	6424	, defect_volume_mean_()
	6425	, defect_volume_variance_()
	6426	, defect_volume_skewness_()
	6427	, defect_volume_kurtosis_()
	6428	, defect_count_()
	6429	, initialized_(false)
	6430	, finalized_(false)
	6431	, num_values_(0)
	6432	{}
	6433
	6434	template <class U, class NEXT>
	6435	void update(CoupledHandle<U, NEXT> const & t)
	6436	{
	6437	vigra_precondition(
	6438	finalized_ == false,
	6439	"ConvexHullFeatures::update(): "
	6440	"Finalize must not be called before update");
	6441	if (!initialized_)
	6442	{
	6443	initialize();
	6444	}
	6445	const coord_type & coord_min = getDependency<Coord<Minimum> >(*this);
	6446	// Update label array
	6447	label_array_[coord_handle_type::getValue(t) - coord_min] = 0;
	6448	}
	6449
	6450	template <class U, class NEXT>
	6451	void update(CoupledHandle<U, NEXT> const & t, double)
	6452	{
	6453	update(t);
	6454	}
	6455
	6456	void initialize()
	6457	{
	6458	// Get hull and bounding box
	6459	const polytope_type & hull = getDependency<ConvexHull>(*this);
	6460	const coord_type & coord_min = getDependency<Coord<Minimum> >(*this);
	6461	coord_type coord_max = getDependency<Coord<Maximum> >(*this);
	6462	coord_max += coord_type(1);
	6463	// Get offset
	6464	point_type offset;
	6465	std::copy(coord_min.begin(), coord_min.end(), offset.begin());
	6466	// Create the label array
	6467	label_array_.reshape(coord_max - coord_min, 0);
	6468	hull.fill(label_array_, 1, offset);
	6469	// Extract convex hull features
	6470	AccumulatorChainArray<
	6471	CoupledArrays<dimensions, unsigned int>,
	6472	Select<LabelArg<1>, Count, RegionCenter> > hull_acc;
	6473	hull_acc.ignoreLabel(0);
	6474	extractFeatures(label_array_, hull_acc);
	6475	hull_center_ = get<RegionCenter>(hull_acc, 1) + coord_min;
	6476	hull_volume_ = get<Count>(hull_acc, 1);
	6477	// Set initialized flag
	6478	initialized_ = true;
	6479	}
	6480
	6481	/* \brief Finalize the calculation of the convex hull features.
	6482
	6483	Finalize must be called in order to trigger the calculation of
	6484	the convexity defect features.
	6485	*/
	6486	void finalize()
	6487	{
	6488	if (!finalized_)
	6489	{
	6490	dofinalize();
	6491	finalized_ = true;
	6492	}
	6493	}
	6494
	6495	void dofinalize()
	6496	{
	6497	vigra_precondition(
	6498	initialized_,
	6499	"ConvexHullFeatures::finalize(): "
	6500	"Feature computation was not initialized.");
	6501	const coord_type & coord_min = getDependency<Coord<Minimum> >(*this);
	6502	// Calculate defect center
	6503	AccumulatorChainArray<
	6504	CoupledArrays<dimensions, unsigned int>,
	6505	Select<LabelArg<1>, RegionCenter, Count> > defect_acc;
	6506	extractFeatures(label_array_, defect_acc);
	6507	defect_center_ = get<RegionCenter>(defect_acc, 1) + coord_min;
	6508	// Calculate defect stats
	6509	array_type defects_array(label_array_.shape());
	6510	defect_count_ = labelMultiArrayWithBackground(
	6511	label_array_,
	6512	defects_array);
	6513	defect_volume_mean_ = 0.0;
	6514	defect_volume_variance_ = 0.0;
	6515	defect_volume_skewness_ = 0.0;
	6516	defect_volume_kurtosis_ = 0.0;
	6517	if (defect_count_ != 0)
	6518	{
	6519	AccumulatorChainArray<
	6520	CoupledArrays<dimensions, unsigned int>,
	6521	Select<LabelArg<1>, Count, RegionCenter> > defects_acc;
	6522	extractFeatures(defects_array, defects_acc);
	6523	ArrayVector<double> defect_volumes;
	6524	point_type center = getDependency<RegionCenter>(*this)
	6525	-getDependency<Coord<Minimum> >(*this);
	6526	for (int k = 1; k <= defect_count_; k++)
6349	6527	{
6350		AccumulatorChainArray<CoupledArrays<2, UInt32>,
6351		Select<LabelArg<1>, Count, RegionCenter> > convexity_defects_stats;
6352		convexity_defects_stats.ignoreLabel(0);
6353		extractFeatures(convexity_defects, convexity_defects_stats);
6354
6355		double total_defect_area = 0.0;
6356		mean_defect_displacement_ = 0.0;
6357		defect_center_ = point_type();
6358		for (int k = 1; k <= convexity_defect_count_; ++k)
6359		{
6360		double area = get<Count>(convexity_defects_stats, k);
6361		point_type center = get<RegionCenter>(convexity_defects_stats, k) + offset;
6362
6363		convexity_defect_area_.push_back(area);
6364		total_defect_area += area;
6365		defect_center_ += area*center;
6366		mean_defect_displacement_ += area*norm(input_center_ - center);
6367		}
6368		sort(convexity_defect_area_.begin(), convexity_defect_area_.end(),
6369		std::greater<MultiArrayIndex>());
6370		mean_defect_displacement_ /= total_defect_area;
6371		defect_center_ /= total_defect_area;
6372
6373		AccumulatorChain<MultiArrayIndex,
6374		Select<Mean, UnbiasedVariance, UnbiasedSkewness, UnbiasedKurtosis> > defect_area_stats;
6375		extractFeatures(convexity_defect_area_.begin(),
6376		convexity_defect_area_.end(), defect_area_stats);
6377
6378		defect_area_mean_ = convexity_defect_count_ > 0
6379		? get<Mean>(defect_area_stats)
6380		: 0.0;
6381		defect_area_variance_ = convexity_defect_count_ > 1
6382		? get<UnbiasedVariance>(defect_area_stats)
6383		: 0.0;
6384		defect_area_skewness_ = convexity_defect_count_ > 2
6385		? get<UnbiasedSkewness>(defect_area_stats)
6386		: 0.0;
6387		defect_area_kurtosis_ = convexity_defect_count_ > 3
6388		? get<UnbiasedKurtosis>(defect_area_stats)
6389		: 0.0;
	6528	defect_volumes.push_back(get<Count>(defects_acc, k));
	6529	defect_displacement_mean_ += get<Count>(defects_acc, k)
	6530	* norm(get<RegionCenter>(defects_acc, k) - center);
6390	6531	}
6391		/**********************************************/
6392		features_computed_ = true;
	6532	defect_displacement_mean_ /= get<Count>(defect_acc, 1);
	6533	AccumulatorChain<
	6534	MultiArrayIndex,
	6535	Select< Mean,
	6536	UnbiasedVariance,
	6537	UnbiasedSkewness,
	6538	UnbiasedKurtosis> > volumes_acc;
	6539	extractFeatures(
	6540	defect_volumes.begin(),
	6541	defect_volumes.end(),
	6542	volumes_acc);
	6543	defect_volume_mean_ = get<Mean>(volumes_acc);
	6544	if (defect_count_ > 1)
	6545	{
	6546	defect_volume_variance_ = get<UnbiasedVariance>(volumes_acc);
	6547	}
	6548	if (defect_count_ > 2)
	6549	{
	6550	defect_volume_skewness_ = get<UnbiasedSkewness>(volumes_acc);
	6551	}
	6552	if (defect_count_ > 3)
	6553	{
	6554	defect_volume_kurtosis_ = get<UnbiasedKurtosis>(volumes_acc);
	6555	}
6393	6556	}
6394	6557	}
6395	6558
6396		template <class U, class NEXT>
6397		void update(CoupledHandle<U, NEXT> const & t, double weight)
6398		{
6399		update(t);
6400		}
6401
6402		void operator+=(Impl const & o)
6403		{
6404		vigra_precondition(false,
6405		"ConvexHull::operator+=(): ConvexHull features cannot be merged.");
	6559	void operator+=(Impl const &)
	6560	{
	6561	vigra_precondition(
	6562	false,
	6563	"ConvexHullFeatures::operator+=(): features cannot be merged.");
6406	6564	}
6407	6565
6408	6566	result_type operator()() const
6409	6567	{
	6568	vigra_precondition(
	6569	finalized_,
	6570	"ConvexHullFeatures::operator(): "
	6571	"Finalize must be called before operator()");
6410	6572	return *this;
6411	6573	}
6412	6574
6413		/*
6414		* Returns the convex hull polygon.
6415		*/
6416		polygon_type const & hull() const
6417		{
6418		return convex_hull_;
6419		}
6420
6421		/*
6422		* Returns the area enclosed by the input polygon.
6423		*/
6424		double inputArea() const
6425		{
6426		vigra_precondition(features_computed_,
6427		"ConvexHull: features must be calculated first.");
6428		return getDependency<RegionContour>(*this).area();
6429		}
6430
6431		/*
6432		* Returns the area enclosed by the convex hull polygon.
6433		*/
6434		double hullArea() const
6435		{
6436		vigra_precondition(features_computed_,
6437		"ConvexHull: features must be calculated first.");
6438		return convex_hull_.area();
6439		}
6440
6441		/*
6442		* Returns the perimeter of the input polygon.
6443		*/
6444		double inputPerimeter() const
6445		{
6446		vigra_precondition(features_computed_,
6447		"ConvexHull: features must be calculated first.");
6448		return getDependency<RegionContour>(*this).length();
6449		}
6450
6451		/*
6452		* Returns the perimeter of the convex hull polygon.
6453		*/
6454		double hullPerimeter() const
6455		{
6456		vigra_precondition(features_computed_,
6457		"ConvexHull: features must be calculated first.");
6458		return convex_hull_.length();
6459		}
6460
6461		/*
6462		* Center of the original region.
6463		*/
6464		point_type const & inputCenter() const
6465		{
6466		return input_center_;
6467		}
6468
6469		/*
6470		* Center of the region enclosed by the convex hull.
6471		*/
6472		point_type const & hullCenter() const
6473		{
6474		return convex_hull_center_;
6475		}
6476
6477		/*
6478		* Center of difference between the convex hull and the original region.
6479		*/
6480		point_type const & convexityDefectCenter() const
6481		{
	6575	/** \brief Center of the input region.
	6576	*/
	6577	const point_type & inputCenter() const {
	6578	return getDependency<RegionCenter>(*this);
	6579	}
	6580
	6581	/** \brief Center of the convex hull of the input region.
	6582	*/
	6583	const point_type & hullCenter() const {
	6584	return hull_center_;
	6585	}
	6586
	6587	/** \brief Volume of the input region.
	6588	*/
	6589	int inputVolume() const {
	6590	return getDependency<Count>(*this);
	6591	}
	6592
	6593	/** \brief Volume of the convex hull of the input region.
	6594	*/
	6595	int hullVolume() const {
	6596	return hull_volume_;
	6597	}
	6598
	6599	/** \brief Weighted center of mass of the convexity defects.
	6600	*/
	6601	const point_type & defectCenter() const {
6482	6602	return defect_center_;
6483	6603	}
6484	6604
6485		/*
6486		* Returns the ratio between the input area and the convex hull area.
6487		* This is always <tt><= 1</tt>, and the smaller the value is,
6488		* the less convex is the input polygon.
6489		*/
6490		double convexity() const
6491		{
6492		vigra_precondition(features_computed_,
6493		"ConvexHull: features must be calculated first.");
6494		return convexity_;
6495		}
6496
6497		/*
6498		* Returns the ratio between the input perimeter and the convex perimeter.
6499		* This is always <tt>>= 1</tt>, and the higher the value is, the less
6500		* convex is the input polygon.
6501		*/
6502		double rugosity() const
6503		{
6504		vigra_precondition(features_computed_,
6505		"ConvexHull: features must be calculated first.");
6506		return rugosity_;
6507		}
6508
6509		/*
6510		* Returns the number of convexity defects (i.e. number of connected components
6511		* of the difference between convex hull and input region).
6512		*/
6513		int convexityDefectCount() const
6514		{
6515		vigra_precondition(features_computed_,
6516		"ConvexHull: features must be calculated first.");
6517		return convexity_defect_count_;
6518		}
6519
6520		/*
6521		* Returns the mean area of the convexity defects.
6522		*/
6523		double convexityDefectAreaMean() const
6524		{
6525		vigra_precondition(features_computed_,
6526		"ConvexHull: features must be calculated first.");
6527		return defect_area_mean_;
6528		}
6529
6530		/*
6531		* Returns the variance of the convexity defect areas.
6532		*/
6533		double convexityDefectAreaVariance() const
6534		{
6535		vigra_precondition(features_computed_,
6536		"ConvexHull: features must be calculated first.");
6537		return defect_area_variance_;
6538		}
6539
6540		/*
6541		* Returns the skewness of the convexity defect areas.
6542		*/
6543		double convexityDefectAreaSkewness() const
6544		{
6545		vigra_precondition(features_computed_,
6546		"ConvexHull: features must be calculated first.");
6547		return defect_area_skewness_;
6548		}
6549
6550		/*
6551		* Returns the kurtosis of the convexity defect areas.
6552		*/
6553		double convexityDefectAreaKurtosis() const
6554		{
6555		vigra_precondition(features_computed_,
6556		"ConvexHull: features must be calculated first.");
6557		return defect_area_kurtosis_;
6558		}
6559
6560		/*
6561		* Returns the mean distance between the defect areas and the center of
6562		* the input region, weighted by the area of each defect region.
6563		*/
6564		double meanDefectDisplacement() const
6565		{
6566		vigra_precondition(features_computed_,
6567		"ConvexHull: features must be calculated first.");
6568		return mean_defect_displacement_;
6569		}
6570
6571		/*
6572		* Returns the areas of the convexity defect regions (ordered descending).
6573		*/
6574		ArrayVector<MultiArrayIndex> const & defectAreaList() const
6575		{
6576		vigra_precondition(features_computed_,
6577		"ConvexHull: features must be calculated first.");
6578		return convexity_defect_area_;
	6605	/** \brief Average volume of the convexity defects.
	6606	*/
	6607	double defectVolumeMean() const {
	6608	return defect_volume_mean_;
	6609	}
	6610
	6611	/** \brief Variance of the volumes of the convexity defects.
	6612	*/
	6613	double defectVolumeVariance() const {
	6614	return defect_volume_variance_;
	6615	}
	6616
	6617	/** \brief Skewness of the volumes of the convexity defects.
	6618	*/
	6619	double defectVolumeSkewness() const {
	6620	return defect_volume_skewness_;
	6621	}
	6622
	6623	/** \brief Kurtosis of the volumes of the convexity defects.
	6624	*/
	6625	double defectVolumeKurtosis() const {
	6626	return defect_volume_kurtosis_;
	6627	}
	6628
	6629	/** \brief Number of convexity defects.
	6630	*/
	6631	int defectCount() const {
	6632	return defect_count_;
	6633	}
	6634
	6635	/** \brief Average displacement of the convexity defects from the input
	6636	region center weighted by their size.
	6637	*/
	6638	double defectDisplacementMean() const {
	6639	return defect_displacement_mean_;
	6640	}
	6641
	6642	/** \brief Convexity of the input region
	6643
	6644	The convexity is the ratio of the input volume to the convex hull
	6645	volume: \f[c = \frac{V_\mathrm{input}}{V_\mathrm{hull}}\f]
	6646	*/
	6647	double convexity() const {
	6648	return static_cast<double>(inputVolume()) / hullVolume();
6579	6649	}
6580	6650	};
6581	6651	};
6582
	6652	#endif // WITH_LEMON
6583	6653
6584	6654	}} // namespace vigra::acc
6585	6655

+4

-4

include/vigra/adjacency_list_graph.hxx less more

72	72	typedef typename G::index_type index_type;
73	73
74	74	public:
75		ItemIter(const lemon::Invalid & iv = lemon::INVALID)
	75	ItemIter(const lemon::Invalid & /iv/ = lemon::INVALID)
76	76	: graph_(NULL),
77	77	id_(-1),
78	78	item_(lemon::INVALID)

142	142	typedef typename Graph::Arc Arc;
143	143	typedef typename Graph::Edge Edge;
144	144	typedef typename Graph::EdgeIt EdgeIt;
145		ArcIt(const lemon::Invalid invalid = lemon::INVALID )
	145	ArcIt(const lemon::Invalid /invalid/ = lemon::INVALID )
146	146	: graph_(NULL),
147	147	pos_(),
148	148	inFirstHalf_(false),

573	573	}
574	574
575	575	template<class ITER>
576		void deserialize(ITER begin, ITER end){
	576	void deserialize(ITER begin, ITER){
577	577
578	578
579	579	nodeNum_ = *begin; ++begin;

687	687
688	688	inline AdjacencyListGraph::Node
689	689	AdjacencyListGraph::addNode(const AdjacencyListGraph::index_type id){
690		if(id == nodes_.size()){
	690	if((std::size_t)id == nodes_.size()){
691	691	nodes_.push_back(NodeStorage(id));
692	692	++nodeNum_;
693	693	return Node(id);

+1

-0

include/vigra/affine_registration_fft.hxx less more

506	506	double & correlation_coefficent,
507	507	Diff2D border = Diff2D(0,0))
508	508	{
	509	ignore_argument(d_lr);
509	510	typename SrcIterator::difference_type s_shape = s_lr - s_ul;
510	511
511	512	//determine matrix by using 5 quater-matches and a maximum likelihood decision:

+70

-70

include/vigra/affinegeometry.hxx less more

28	28	/* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, */
29	29	/* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING */
30	30	/* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR */
31		/* OTHER DEALINGS IN THE SOFTWARE. */
	31	/* OTHER DEALINGS IN THE SOFTWARE. */
32	32	/* */
33	33	/************************************************************************/
34
	34
35	35	#ifndef VIGRA_AFFINEGEOMETRY_HXX
36	36	#define VIGRA_AFFINEGEOMETRY_HXX
37	37

45	45
46	46	namespace vigra {
47	47
48		/** \addtogroup GeometricTransformations Geometric Transformations
	48	/** \addtogroup GeometricTransformations
49	49	*/
50	50	//@{
51	51

56	56	/********************************************************/
57	57
58	58	/** \brief Create homogeneous matrix representing a 2D translation.
59
	59
60	60	For use with \ref affineWarpImage().
61	61	*/
62	62	inline

69	69	}
70	70
71	71	/** \brief Create homogeneous matrix representing a 2D uniform scaling about the coordinate origin.
72
	72
73	73	For use with \ref affineWarpImage().
74	74	*/
75	75	inline

82	82	}
83	83
84	84	/** \brief Create homogeneous matrix representing a 2D non-uniform scaling about the coordinate origin.
85
	85
86	86	For use with \ref affineWarpImage().
87	87	*/
88	88	inline

95	95	}
96	96
97	97	/** \brief Create homogeneous matrix representing a 2D shearing.
98
	98
99	99	For use with \ref affineWarpImage().
100	100	*/
101	101	inline

108	108	}
109	109
110	110	/** \brief Create homogeneous matrix representing a 2D rotation about the coordinate origin.
111
	111
112	112	For use with \ref affineWarpImage(). Angle must be in radians.
113	113	*/
114	114	inline

125	125	}
126	126
127	127	/** \brief Create homogeneous matrix representing a 2D rotation about the coordinate origin.
128
	128
129	129	For use with \ref affineWarpImage(). Angle must be in degrees.
130	130	*/
131	131	inline

135	135	}
136	136
137	137	/** \brief Create homogeneous matrix representing a 2D rotation about the given point.
138
	138
139	139	For use with \ref affineWarpImage(). Angle must be in radians.
140	140	*/
141	141	inline

145	145	}
146	146
147	147	/** \brief Create homogeneous matrix representing a 2D rotation about the given point.
148
	148
149	149	For use with \ref affineWarpImage(). Angle must be in degrees.
150	150	*/
151	151	inline

161	161	/********************************************************/
162	162
163	163	// documentation is in basicgeometry.hxx
164		template <int ORDER, class T,
	164	template <int ORDER, class T,
165	165	class DestIterator, class DestAccessor>
166	166	void rotateImage(SplineImageView<ORDER, T> const & src,
167		DestIterator id, DestAccessor dest,
	167	DestIterator id, DestAccessor dest,
168	168	double angleInDegree, TinyVector<double, 2> const & center)
169	169	{
170	170	int w = src.width();
171	171	int h = src.height();
172
	172
173	173	double angle = angleInDegree/180.0;
174	174	double c = cos_pi(angle); // avoid round-off errors for simple rotations
175	175	double s = sin_pi(angle);
176
	176
177	177	for(int y = 0; y < h; ++y, ++id.y)
178	178	{
179	179	typename DestIterator::row_iterator rd = id.rowIterator();

187	187	}
188	188	}
189	189
190		template <int ORDER, class T,
	190	template <int ORDER, class T,
191	191	class DestIterator, class DestAccessor>
192		inline void
	192	inline void
193	193	rotateImage(SplineImageView<ORDER, T> const & src,
194		pair<DestIterator, DestAccessor> dest,
	194	pair<DestIterator, DestAccessor> dest,
195	195	double angleInDegree, TinyVector<double, 2> const & center)
196	196	{
197	197	rotateImage(src, dest.first, dest.second, angleInDegree, center);
198	198	}
199	199
200		template <int ORDER, class T,
	200	template <int ORDER, class T,
201	201	class DestIterator, class DestAccessor>
202		inline void
	202	inline void
203	203	rotateImage(SplineImageView<ORDER, T> const & src,
204		DestIterator id, DestAccessor dest,
	204	DestIterator id, DestAccessor dest,
205	205	double angleInDegree)
206	206	{
207	207	TinyVector<double, 2> center((src.width()-1.0) / 2.0, (src.height()-1.0) / 2.0);
208	208	rotateImage(src, id, dest, angleInDegree, center);
209	209	}
210	210
211		template <int ORDER, class T,
	211	template <int ORDER, class T,
212	212	class DestIterator, class DestAccessor>
213		inline void
	213	inline void
214	214	rotateImage(SplineImageView<ORDER, T> const & src,
215		pair<DestIterator, DestAccessor> dest,
	215	pair<DestIterator, DestAccessor> dest,
216	216	double angleInDegree)
217	217	{
218	218	TinyVector<double, 2> center((src.width()-1.0) / 2.0, (src.height()-1.0) / 2.0);
219	219	rotateImage(src, dest.first, dest.second, angleInDegree, center);
220	220	}
221	221
222		template <int ORDER, class T,
	222	template <int ORDER, class T,
223	223	class T2, class S2>
224		inline void
	224	inline void
225	225	rotateImage(SplineImageView<ORDER, T> const & src,
226		MultiArrayView<2, T2, S2> dest,
	226	MultiArrayView<2, T2, S2> dest,
227	227	double angleInDegree, TinyVector<double, 2> const & center)
228	228	{
229	229	rotateImage(src, destImage(dest), angleInDegree, center);
230	230	}
231	231
232		template <int ORDER, class T,
	232	template <int ORDER, class T,
233	233	class T2, class S2>
234		inline void
	234	inline void
235	235	rotateImage(SplineImageView<ORDER, T> const & src,
236		MultiArrayView<2, T2, S2> dest,
	236	MultiArrayView<2, T2, S2> dest,
237	237	double angleInDegree)
238	238	{
239	239	TinyVector<double, 2> center((src.width()-1.0) / 2.0, (src.height()-1.0) / 2.0);

249	249	/** \brief Warp an image according to an affine transformation.
250	250
251	251	<b> Declarations:</b>
252
	252
253	253	pass 2D array views:
254	254	\code
255	255	namespace vigra {
256		template <int ORDER, class T,
	256	template <int ORDER, class T,
257	257	class T2, class S2,
258	258	class C>
259	259	void
260	260	affineWarpImage(SplineImageView<ORDER, T> const & src,
261		MultiArrayView<2, T2, S2> dest,
	261	MultiArrayView<2, T2, S2> dest,
262	262	MultiArrayView<2, double, C> const & affineMatrix);
263	263	}
264	264	\endcode
265
	265
266	266	\deprecatedAPI{affineWarpImage}
267	267	pass \ref ImageIterators and \ref DataAccessors :
268	268	\code
269	269	namespace vigra {
270		template <int ORDER, class T,
	270	template <int ORDER, class T,
271	271	class DestIterator, class DestAccessor,
272	272	class C>
273	273	void affineWarpImage(SplineImageView<ORDER, T> const & src,
274		DestIterator dul, DestIterator dlr, DestAccessor dest,
	274	DestIterator dul, DestIterator dlr, DestAccessor dest,
275	275	MultiArrayView<2, double, C> const & affineMatrix);
276	276	}
277	277	\endcode
278	278	use argument objects in conjunction with \ref ArgumentObjectFactories :
279	279	\code
280	280	namespace vigra {
281		template <int ORDER, class T,
	281	template <int ORDER, class T,
282	282	class DestIterator, class DestAccessor,
283	283	class C>
284	284	void affineWarpImage(SplineImageView<ORDER, T> const & src,
285		triple<DestIterator, DestIterator, DestAccessor> dest,
	285	triple<DestIterator, DestIterator, DestAccessor> dest,
286	286	MultiArrayView<2, double, C> const & affineMatrix);
287	287	}
288	288	\endcode
289	289	\deprecatedEnd
290
	290
291	291	The algorithm applies the given \a affineMatrix to the <i>destination coordinates</i> and copies
292		the image value from the resulting source coordinates, using the given SplineImageView \a src for interpolation.
	292	the image value from the resulting source coordinates, using the given SplineImageView \a src for interpolation.
293	293	If the resulting coordinate is outside the source image, nothing will be written at that destination point.
294
	294
295	295	\code
296	296	for all dest pixels:
297	297	currentSrcCoordinate = affineMatrix * currentDestCoordinate;
298	298	if src.isInside(currentSrcCoordinate):
299	299	dest[currentDestCoordinate] = src[currentSrcCoordinate]; // copy an interpolated value
300	300	\endcode
301
	301
302	302	The matrix represents a 2-dimensional affine transform by means of homogeneous coordinates,
303	303	i.e. it must be a 3x3 matrix whose last row is (0,0,1).
304
	304
305	305	<b> Usage:</b>
306
	306
307	307	<b>\#include</b> \<vigra/affinegeometry.hxx\><br>
308	308	Namespace: vigra
309	309
310	310	\code
311	311	MultiArray<2, float> src(width, height);
312	312	SplineImageView<3, float> spline(src);
313
	313
314	314	MultiArray<2, float> dest1(src.shape());
315
316		// equivalent (up to round-off errors) to
	315
	316	// equivalent (up to round-off errors) to
317	317	// rotateImage(spline, dest1, 45.0);
318	318	TinyVector<double, 2> center((width-1.0)/2.0, (height-1.0)/2.0);
319	319	affineWarpImage(spline, dest1, rotationMatrix2DDegrees(45.0, center));
320
	320
321	321	MultiArray<2, float> dest2(2width-1, 2height-1);
322
323		// equivalent (up to round-off errors) to
	322
	323	// equivalent (up to round-off errors) to
324	324	// resizeImageSplineInterpolation(img, dest2);
325	325	// note that scaleFactor = 0.5, because we must pass the transformation from destination to source
326	326	affineWarpImage(spline, dest2, scalingMatrix2D(0.5));

330	330	\code
331	331	FImage src(width, height);
332	332	SplineImageView<3, Image::value_type> spline(srcImageRange(src));
333
	333
334	334	FImage dest1(width, height);
335
336		// equivalent (up to round-off errors) with
	335
	336	// equivalent (up to round-off errors) with
337	337	// rotateImage(spline, destImage(dest1), 45.0);
338	338	TinyVector<double, 2> center((width-1.0)/2.0, (height-1.0)/2.0);
339	339	affineWarpImage(spline, destImageRange(dest1), rotationMatrix2DDegrees(45.0, center));
340
	340
341	341	FImage dest2(2width-1, 2height-1);
342
343		// equivalent (up to round-off errors) with
	342
	343	// equivalent (up to round-off errors) with
344	344	// resizeImageSplineInterpolation(srcImageRange(img), destImageRange(dest2));
345	345	// note that scaleFactor = 0.5, because we must pass the transformation from destination to source
346	346	affineWarpImage(spline, destImageRange(dest2), scalingMatrix2D(0.5));

348	348	<b> Required Interface:</b>
349	349	\code
350	350	DestImageIterator dest_upperleft;
351
	351
352	352	double x = ..., y = ...;
353
	353
354	354	if (spline.isInside(x,y))
355	355	dest_accessor.set(spline(x, y), dest_upperleft);
356	356	\endcode
357	357	\deprecatedEnd
358
359		<b>See also:</b> Functions to specify affine transformation: \ref translationMatrix2D(), \ref scalingMatrix2D(),
	358
	359	<b>See also:</b> Functions to specify affine transformation: \ref translationMatrix2D(), \ref scalingMatrix2D(),
360	360	\ref shearMatrix2D(), \ref rotationMatrix2DRadians(), \ref rotationMatrix2DDegrees()
361	361	*/
362	362	doxygen_overloaded_function(template <...> void affineWarpImage)
363	363
364		template <int ORDER, class T,
	364	template <int ORDER, class T,
365	365	class DestIterator, class DestAccessor,
366	366	class C>
367	367	void affineWarpImage(SplineImageView<ORDER, T> const & src,
368		DestIterator dul, DestIterator dlr, DestAccessor dest,
	368	DestIterator dul, DestIterator dlr, DestAccessor dest,
369	369	MultiArrayView<2, double, C> const & affineMatrix)
370	370	{
371		vigra_precondition(rowCount(affineMatrix) == 3 && columnCount(affineMatrix) == 3 &&
	371	vigra_precondition(rowCount(affineMatrix) == 3 && columnCount(affineMatrix) == 3 &&
372	372	affineMatrix(2,0) == 0.0 && affineMatrix(2,1) == 0.0 && affineMatrix(2,2) == 1.0,
373	373	"affineWarpImage(): matrix doesn't represent an affine transformation with homogeneous 2D coordinates.");
374
375
	374
	375
376	376	double w = dlr.x - dul.x;
377	377	double h = dlr.y - dul.y;
378
	378
379	379	for(double y = 0.0; y < h; ++y, ++dul.y)
380	380	{
381	381	typename DestIterator::row_iterator rd = dul.rowIterator();

389	389	}
390	390	}
391	391
392		template <int ORDER, class T,
	392	template <int ORDER, class T,
393	393	class DestIterator, class DestAccessor,
394	394	class C>
395	395	inline void
396	396	affineWarpImage(SplineImageView<ORDER, T> const & src,
397		triple<DestIterator, DestIterator, DestAccessor> dest,
	397	triple<DestIterator, DestIterator, DestAccessor> dest,
398	398	MultiArrayView<2, double, C> const & affineMatrix)
399	399	{
400	400	affineWarpImage(src, dest.first, dest.second, dest.third, affineMatrix);
401	401	}
402	402
403		template <int ORDER, class T,
	403	template <int ORDER, class T,
404	404	class T2, class S2,
405	405	class C>
406	406	inline void
407	407	affineWarpImage(SplineImageView<ORDER, T> const & src,
408		MultiArrayView<2, T2, S2> dest,
	408	MultiArrayView<2, T2, S2> dest,
409	409	MultiArrayView<2, double, C> const & affineMatrix)
410	410	{
411	411	affineWarpImage(src, destImageRange(dest), affineMatrix);

+3

-3

include/vigra/algorithm.hxx less more

498	498	static bool isLittleEndian()
499	499	{
500	500	static const UIntBiggest testint = 0x01;
501		return ((UInt8 *)&testint)[0] == 0x01;
	501	return reinterpret_cast<const UInt8 *>(&testint)[0] == 0x01;
502	502	}
503	503
504	504	template <class INT>

734	734	if(isLittleEndian() && size > 3)
735	735	{
736	736	// take care of alignment
737		for(; (std::size_t)i % 4 != 0; ++i)
	737	for(; reinterpret_cast<std::size_t>(i) % 4 != 0; ++i)
738	738	{
739	739	crc = (crc >> 8) ^ table0[(crc ^ *i) & 0xFF];
740	740	}
741	741	for(; i < end-3; i+=4)
742	742	{
743		crc ^= ((UInt32 )i);
	743	crc ^= (reinterpret_cast<const UInt32 >(i));
744	744	crc = table3[crc & 0xFF] ^
745	745	table2[(crc >> 8) & 0xFF] ^
746	746	table1[(crc >> 16) & 0xFF] ^

+4

-4

include/vigra/any.hxx less more

214	214	assert(a.cast<double>() == 20.0);
215	215
216	216	// delete the stored value
217		a.release();
	217	a.destroy();
218	218	assert(a.empty());
219	219	assert(a == false);
220	220

274	274
275	275	/** Delete the contained object (make this 'Any' object empty).
276	276	*/
277		void release()
278		{
279		handle_.release();
	277	void destroy()
	278	{
	279	handle_.reset((detail::AnyHandle*)0);
280	280	}
281	281
282	282	/** Exchange the value of this object with other's.

+3

-3

include/vigra/array_vector.hxx less more

701	701	template <class T, class Alloc>
702	702	inline void ArrayVector<T, Alloc>::push_back( value_type const & t )
703	703	{
704		size_type old_capacity = this->capacity_;
705		pointer old_data = reserveImpl(false);
	704	size_type old_capacity = this->capacity_;
	705	pointer old_data = reserveImpl(false);
706	706	alloc_.construct(this->data_ + this->size_, t);
707	707	// deallocate old data _after_ construction of new element, so that
708	708	// 't' can refer to the old data as in 'push_back(front())'

955	955	template <class T>
956	956	ostream & operator<<(ostream & s, vigra::ArrayVectorView<T> const & a)
957	957	{
958		for(std::size_t k=0; k<a.size()-1; ++k)
	958	for(std::ptrdiff_t k=0; k<(std::ptrdiff_t)a.size()-1; ++k)
959	959	s << a[k] << ", ";
960	960	if(a.size())
961	961	s << a.back();

+1

-1

include/vigra/axistags.hxx less more

356	356
357	357	AxisTags(std::string const & tags)
358	358	{
359		for(int k=0; k<tags.size(); ++k)
	359	for(std::string::size_type k=0; k<tags.size(); ++k)
360	360	{
361	361	switch(tags[k])
362	362	{

+157

-157

include/vigra/basicgeometry.hxx less more

28	28	/* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, */
29	29	/* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING */
30	30	/* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR */
31		/* OTHER DEALINGS IN THE SOFTWARE. */
	31	/* OTHER DEALINGS IN THE SOFTWARE. */
32	32	/* */
33	33	/************************************************************************/
34
	34
35	35	#ifndef VIGRA_BASICGEOMETRY_HXX
36	36	#define VIGRA_BASICGEOMETRY_HXX
37	37

44	44
45	45	namespace vigra {
46	46
47		/** \addtogroup GeometricTransformations Geometric Transformations
	47	/** \addtogroup GeometricTransformations
48	48	*/
49	49	//@{
50	50

57	57	/** \brief Rotate an image by a multiple of 90 degrees or by an arbitrary angle.
58	58
59	59	If you specify the angle as an integer which is a multiple of 90 degrees, rotateImage()
60		just copies the pixels in the appropriate new order. It expects the destination image to
	60	just copies the pixels in the appropriate new order. It expects the destination image to
61	61	have the correct shape for the desired rotation. That is, when the rotation is a multiple
62	62	of 180 degrees, source and destination must have the same shape, otherwise destination
63	63	must have the transposed shape of the source.
64
	64
65	65	If you want to rotate by an arbitrary angle and around an arbitrary center point,
66	66	you must specify the source image as a \ref vigra::SplineImageView, which is used for
67		interpolation at the required subpixel positions. If no center point is provided, the image
	67	interpolation at the required subpixel positions. If no center point is provided, the image
68	68	center is used by default. The destination image must have the same size
69		as the source SplineImageView.
70
	69	as the source SplineImageView.
	70
71	71	Positive angles refer to counter-clockwise rotation, negative ones to clockwise rotation.
72	72	All angles must be given in degrees.
73
	73
74	74	<b> Declarations:</b>
75
	75
76	76	pass 2D array views:
77	77	\code
78	78	namespace vigra {
79	79	// rotate by a multiple of 90 degrees
80	80	template <class T1, class S1,
81	81	class T2, class S2>
82		void
	82	void
83	83	rotateImage(MultiArrayView<2, T1, S1> const & src,
84	84	MultiArrayView<2, T2, S2> dest,
85	85	int rotation);
86
	86
87	87	// rotate by an arbitrary angle around the given center point
88		template <int ORDER, class T,
	88	template <int ORDER, class T,
89	89	class T2, class S2>
90		void
	90	void
91	91	rotateImage(SplineImageView<ORDER, T> const & src,
92		MultiArrayView<2, T2, S2> dest,
93		double angleInDegree,
	92	MultiArrayView<2, T2, S2> dest,
	93	double angleInDegree,
94	94	TinyVector<double, 2> const & center = (src.shape() - Shape2(1)) / 2.0);
95	95	}
96	96	\endcode
97
	97
98	98	\deprecatedAPI{rotateImage}
99	99	pass \ref ImageIterators and \ref DataAccessors :
100	100	\code

102	102	// rotate by a multiple of 90 degrees
103	103	template <class SrcIterator, class SrcAccessor,
104	104	class DestIterator, class DestAccessor>
105		void
	105	void
106	106	rotateImage(SrcIterator is, SrcIterator end, SrcAccessor as,
107	107	DestIterator id, DestAccessor ad, int rotation);
108	108
109	109	// rotate by an arbitrary angle around the given center point
110		template <int ORDER, class T,
	110	template <int ORDER, class T,
111	111	class DestIterator, class DestAccessor>
112	112	void rotateImage(SplineImageView<ORDER, T> const & src,
113		DestIterator id, DestAccessor dest,
	113	DestIterator id, DestAccessor dest,
114	114	double angleInDegree, TinyVector<double, 2> const & center = (src.shape() - Shape2(1)) / 2.0);
115	115	}
116	116	\endcode

120	120	// rotate by a multiple of 90 degrees
121	121	template <class SrcImageIterator, class SrcAccessor,
122	122	class DestImageIterator, class DestAccessor>
123		void
	123	void
124	124	rotateImage(triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src,
125	125	pair<DestImageIterator, DestAccessor> dest, int rotation);
126
	126
127	127	// rotate by an arbitrary angle around the given center point
128		template <int ORDER, class T,
	128	template <int ORDER, class T,
129	129	class DestIterator, class DestAccessor>
130		void
	130	void
131	131	rotateImage(SplineImageView<ORDER, T> const & src,
132		pair<DestImageIterator, DestAccessor> dest,
	132	pair<DestImageIterator, DestAccessor> dest,
133	133	double angleInDegree, TinyVector<double, 2> const & center = (src.shape() - Shape2(1)) / 2.0);
134	134	}
135	135	\endcode
136	136	\deprecatedEnd
137
	137
138	138	<b> Usage:</b>
139
	139
140	140	<b>\#include</b> \<vigra/basicgeometry.hxx\><br>
141	141	Namespace: vigra
142
	142
143	143	\code
144	144	// rotate counter-clockwise by 90 degrees (no interpolation required)
145	145	MultiArray<2, float> src(width, height),
146	146	dest(height, width); // note that width and height are exchanged
147	147	... // fill src
148	148	rotateImage(src, dest, 90);
149
	149
150	150	// rotate clockwise by 38.5 degrees, using a SplieImageView for cubic interpolation
151	151	SplineImageView<3, float> spline(srcImageRange(src));
152	152	MultiArray<2, float> dest2(src.shape());
153
	153
154	154	vigra::rotateImage(spline, dest2, -38.5);
155	155	\endcode
156	156

160	160	BImage src(width, height),
161	161	dest(height, width); // note that width and height are exchanged
162	162	... // fill src
163
	163
164	164	rotateImage(srcImageRange(src), destImage(dest), 90);
165
	165
166	166	// rotate clockwise by 38.5 degrees, using a SplieImageView for cubic interpolation
167	167	SplineImageView<3, float> spline(srcImageRange(src));
168	168	FImage dest2(width, height);
169
	169
170	170	rotateImage(spline, destImage(dest), -38.5);
171	171	\endcode
172	172	<b> Required Interface:</b>
173	173	\code
174	174	SrcImageIterator src_upperleft, src_lowerright;
175	175	DestImageIterator dest_upperleft;
176
	176
177	177	SrcAccessor src_accessor;
178
	178
179	179	dest_accessor.set(src_accessor(src_upperleft), dest_upperleft);
180	180	\endcode
181	181	\deprecatedEnd
182
	182
183	183	<b> Preconditions:</b>
184	184	\code
185		src.shape(0) > 1 && src.shape(1) > 1
	185	src.shape(0) > 1 && src.shape(1) > 1
186	186	\endcode
187	187	*/
188	188	doxygen_overloaded_function(template <...> void rotateImage)
189	189
190		template <class SrcIterator, class SrcAccessor,
	190	template <class SrcIterator, class SrcAccessor,
191	191	class DestIterator, class DestAccessor>
192	192	void rotateImage(SrcIterator is, SrcIterator end, SrcAccessor as,
193	193	DestIterator id, DestAccessor ad, int rotation)

196	196	int ws = end.x - is.x;
197	197	int hs = end.y - is.y;
198	198
199		vigra_precondition(rotation % 90 == 0,
	199	vigra_precondition(rotation % 90 == 0,
200	200	"rotateImage(): "
201	201	"This function rotates images only about multiples of 90 degree");
202	202
203		rotation = rotation%360;
	203	rotation = rotation%360;
204	204	if (rotation < 0)
205	205	rotation += 360;
206
	206
207	207	switch(rotation)
208	208	{
209	209	case 0:
210	210	copyImage(is, end, as, id, ad);
211	211	break;
212		case 90:
	212	case 90:
213	213	is.x += (ws-1);
214	214	for(x=0; x != ws; x++, is.x--, id.y++)
215	215	{

219	219	{
220	220	ad.set(as(cs), rd);
221	221	}
222
	222
223	223	}
224	224	break;
225	225

234	234	{
235	235	ad.set(as(cs), cd);
236	236	}
237
	237
238	238	}
239	239	break;
240	240
241		case 270:
	241	case 270:
242	242	is.y += (hs-1);
243	243	for(x=0; x != ws; x++, is.x++, id.y++)
244	244	{

248	248	{
249	249	ad.set(as(cs), rd);
250	250	}
251
	251
252	252	}
253	253	break;
254		default: //not needful, because of the exception handig in if-statement
255		vigra_fail("internal error");
	254	default: //not needful, because of the exception handig in if-statement
	255	vigra_fail("internal error");
256	256	}
257	257	}
258	258
259	259	template <class SrcImageIterator, class SrcAccessor,
260	260	class DestImageIterator, class DestAccessor>
261		inline void
	261	inline void
262	262	rotateImage(triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src,
263	263	pair<DestImageIterator, DestAccessor> dest, int rotation)
264	264	{

267	267
268	268	template <class T1, class S1,
269	269	class T2, class S2>
270		inline void
	270	inline void
271	271	rotateImage(MultiArrayView<2, T1, S1> const & src,
272	272	MultiArrayView<2, T2, S2> dest,
273	273	int rotation)

289	289
290	290	enum Reflect {horizontal = 1, vertical = 2};
291	291
292		inline
	292	inline
293	293	Reflect operator\|(Reflect l, Reflect r)
294	294	{
295	295	return Reflect((unsigned int)l \| (unsigned int)r);

300	300	The reflection direction refers to the reflection axis, i.e.
301	301	horizontal reflection turns the image upside down, vertical reflection
302	302	changes left for right. The directions are selected by the enum values
303		<tt>vigra::horizontal</tt> and <tt>vigra::vertical</tt>. The two directions
304		can also be "or"ed together to perform both reflections simultaneously
305		(see example below) -- this is the same as a 180 degree rotation.
306
	303	<tt>vigra::horizontal</tt> and <tt>vigra::vertical</tt>. The two directions
	304	can also be "or"ed together to perform both reflections simultaneously
	305	(see example below) -- this is the same as a 180 degree rotation.
	306
307	307	<b> Declarations:</b>
308
	308
309	309	pass 2D array views:
310	310	\code
311	311	namespace vigra {
312	312	template <class T1, class S1,
313	313	class T2, class S2>
314		void
	314	void
315	315	reflectImage(MultiArrayView<2, T1, S1> const & src,
316	316	MultiArrayView<2, T2, S2> dest, Reflect reflect);
317	317	}
318	318	\endcode
319
	319
320	320	\deprecatedAPI{reflectImage}
321	321	pass \ref ImageIterators and \ref DataAccessors :
322	322	\code
323	323	namespace vigra {
324	324	template <class SrcIterator, class SrcAccessor,
325	325	class DestIterator, class DestAccessor>
326		void
	326	void
327	327	reflectImage(SrcIterator is, SrcIterator end, SrcAccessor as,
328	328	DestIterator id, DestAccessor ad, Reflect axis);
329	329	}

333	333	namespace vigra {
334	334	template <class SrcImageIterator, class SrcAccessor,
335	335	class DestImageIterator, class DestAccessor>
336		void
	336	void
337	337	reflectImage(triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src,
338	338	pair<DestImageIterator, DestAccessor> dest, Reflect axis);
339	339	}
340	340	\endcode
341	341	\deprecatedEnd
342
	342
343	343	<b> Usage:</b>
344
	344
345	345	<b>\#include</b> \<vigra/basicgeometry.hxx\><br>
346	346	Namespace: vigra
347
	347
348	348	\code
349	349	MultiArray<2, float> src(width, height),
350	350	dest(width, height);
351	351	... // fill src
352	352	// reflect about both dimensions
353	353	vigra::reflectImage(src, dest, vigra::horizontal \| vigra::vertical);
354
	354
355	355	\endcode
356	356
357	357	\deprecatedUsage{reflectImage}

359	359	BImage src(width, height),
360	360	dest(width, height);
361	361	... // fill src
362
	362
363	363	vigra::reflectImage(srcImageRange(src), destImage(dest), vigra::horizontal \| vigra::vertical);
364	364	\endcode
365	365	<b> Required Interface:</b>
366	366	\code
367	367	SrcImageIterator src_upperleft, src_lowerright;
368	368	DestImageIterator dest_upperleft;
369
	369
370	370	SrcAccessor src_accessor;
371
	371
372	372	dest_accessor.set(src_accessor(src_upperleft), dest_upperleft);
373	373	\endcode
374	374	\deprecatedEnd
375
	375
376	376	<b> Preconditions:</b>
377	377	\code
378		src.shape(0) > 1 && src.shape(1) > 1
	378	src.shape(0) > 1 && src.shape(1) > 1
379	379	\endcode
380	380	*/
381	381	doxygen_overloaded_function(template <...> void reflectImage)
382	382
383		template <class SrcIterator, class SrcAccessor,
	383	template <class SrcIterator, class SrcAccessor,
384	384	class DestIterator, class DestAccessor>
385	385	void reflectImage(SrcIterator is, SrcIterator end, SrcAccessor as,
386	386	DestIterator id, DestAccessor ad, Reflect reflect)
387	387	{
388
	388
389	389	int ws = end.x - is.x;
390	390	int hs = end.y - is.y;
391	391

394	394	if(reflect == horizontal)
395	395	{//flipImage
396	396	is.y += (hs-1);
397		for(x=0; x<ws; ++x, ++is.x, ++id.x)
	397	for(x=0; x<ws; ++x, ++is.x, ++id.x)
398	398	{
399	399	typename SrcIterator::column_iterator cs = is.columnIterator();
400	400	typename DestIterator::column_iterator cd = id.columnIterator();

407	407	else if(reflect == vertical)
408	408	{//flopImage
409	409	is.x += (ws-1);
410		for(x=0; x < ws; ++x, --is.x, ++id.x)
	410	for(x=0; x < ws; ++x, --is.x, ++id.x)
411	411	{
412	412
413	413	typename SrcIterator::column_iterator cs = is.columnIterator();

432	432	}
433	433	}
434	434	}
435		else
	435	else
436	436	vigra_fail("reflectImage(): "
437	437	"This function reflects horizontal or vertical,"
438	438	" 'and' is included");

440	440
441	441	template <class SrcImageIterator, class SrcAccessor,
442	442	class DestImageIterator, class DestAccessor>
443		inline void
	443	inline void
444	444	reflectImage(triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src,
445	445	pair<DestImageIterator, DestAccessor> dest, Reflect reflect)
446	446	{

449	449
450	450	template <class T1, class S1,
451	451	class T2, class S2>
452		inline void
	452	inline void
453	453	reflectImage(MultiArrayView<2, T1, S1> const & src,
454	454	MultiArrayView<2, T2, S2> dest, Reflect reflect)
455	455	{

470	470	/** \brief Transpose an image over the major or minor diagonal.
471	471
472	472	The transposition direction refers to the axis, i.e.
473		major transposition turns the upper right corner into the lower left one,
474		whereas minor transposition changes the upper left corner into the lower right one.
	473	major transposition turns the upper right corner into the lower left one,
	474	whereas minor transposition changes the upper left corner into the lower right one.
475	475	The directions are selected by the enum values
476		<tt>vigra::major</tt> and <tt>vigra::minor</tt>. The two directions
477		can also be "or"ed together to perform both reflections simultaneously
	476	<tt>vigra::major</tt> and <tt>vigra::minor</tt>. The two directions
	477	can also be "or"ed together to perform both reflections simultaneously
478	478	(see example below) -- this is the same as a 180 degree rotation.
479	479	(Caution: When doing multi-platform development, you should be
480	480	aware that some <sys/types.h> define major/minor, too. Do not omit
481	481	the vigra namespace prefix.)
482
	482
483	483	Note that a similar effect can be chieved by MultiArrayView::transpose(). However,
484	484	the latter can only transpose about the major diagonal, and it doesn't rearrange the data
485	485	- it just creates a view with transposed axis ordering. It depends on the context
486	486	which function is more appropriate.
487
	487
488	488	<b> Declarations:</b>
489
	489
490	490	pass 2D array views:
491	491	\code
492	492	namespace vigra {
493	493	template <class T1, class S1,
494	494	class T2, class S2>
495		void
	495	void
496	496	transposeImage(MultiArrayView<2, T1, S1> const & src,
497	497	MultiArrayView<2, T2, S2> dest, Transpose axis);
498	498	}
499	499	\endcode
500
	500
501	501	\deprecatedAPI{transposeImage}
502	502	pass \ref ImageIterators and \ref DataAccessors :
503	503	\code
504	504	namespace vigra {
505	505	template <class SrcIterator, class SrcAccessor,
506	506	class DestIterator, class DestAccessor>
507		void
	507	void
508	508	transposeImage(SrcIterator is, SrcIterator end, SrcAccessor as,
509	509	DestIterator id, DestAccessor ad, Transpose axis);
510	510	}

514	514	namespace vigra {
515	515	template <class SrcImageIterator, class SrcAccessor,
516	516	class DestImageIterator, class DestAccessor>
517		void
	517	void
518	518	transposeImage(triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src,
519	519	pair<DestImageIterator, DestAccessor> dest, Transpose axis);
520	520	}
521	521	\endcode
522	522	\deprecatedEnd
523
	523
524	524	<b> Usage:</b>
525
	525
526	526	<b>\#include</b> \<vigra/basicgeometry.hxx\><br>
527	527	Namespace: vigra
528
	528
529	529	\code
530	530	MultiArray<2, float> src(width, height),
531	531	dest(height, width); // note that dimensions are transposed
532	532	... // fill src
533
	533
534	534	// transpose about the major diagonal
535	535	vigra::transposeImage(src, dest, vigra::major);
536
	536
537	537	// this produces the same data as transposing the view
538	538	assert(dest == src.transpose());
539
	539
540	540	// transposition about the minor diagonal has no correspondence in MultiArrayView
541	541	vigra::transposeImage(src, dest, vigra::minor);
542	542	\endcode

546	546	BImage src(width, height),
547	547	dest(width, height);
548	548	... // fill src
549
	549
550	550	// transpose about both diagonals simultaneously
551	551	vigra::transposeImage(srcImageRange(src), destImage(dest), vigra::major \| vigra::minor);
552	552	\endcode

554	554	\code
555	555	SrcImageIterator src_upperleft, src_lowerright;
556	556	DestImageIterator dest_upperleft;
557
	557
558	558	SrcAccessor src_accessor;
559
	559
560	560	dest_accessor.set(src_accessor(src_upperleft), dest_upperleft);
561	561	\endcode
562	562	\deprecatedEnd
563
	563
564	564	<b> Preconditions:</b>
565	565	\code
566		src.shape(0) > 1 && src.shape(1) > 1
	566	src.shape(0) > 1 && src.shape(1) > 1
567	567	\endcode
568	568	*/
569	569	doxygen_overloaded_function(template <...> void transposeImage)
570	570
571		template <class SrcIterator, class SrcAccessor,
	571	template <class SrcIterator, class SrcAccessor,
572	572	class DestIterator, class DestAccessor>
573	573	void transposeImage(SrcIterator is, SrcIterator end, SrcAccessor as,
574	574	DestIterator id, DestAccessor ad, Transpose transpose)

619	619	ad.set(as(cs), cd);
620	620	}
621	621	}
622
623		}
624		else
	622
	623	}
	624	else
625	625	vigra_fail("transposeImage(): "
626	626	"This function transposes major or minor,"
627	627	" 'and' is included");

630	630
631	631	template <class SrcImageIterator, class SrcAccessor,
632	632	class DestImageIterator, class DestAccessor>
633		inline void
	633	inline void
634	634	transposeImage(triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src,
635	635	pair<DestImageIterator, DestAccessor> dest, Transpose transpose)
636	636	{

639	639
640	640	template <class T1, class S1,
641	641	class T2, class S2>
642		inline void
	642	inline void
643	643	transposeImage(MultiArrayView<2, T1, S1> const & src,
644	644	MultiArrayView<2, T2, S2> dest, Transpose transpose)
645	645	{

655	655	/********************************************************/
656	656
657	657	/*
658		* Vergroessert eine Linie um einen Faktor.
	658	* Vergroessert eine Linie um einen Faktor.
659	659	* Ist z.B. der Faktor = 4 so werden in der
660		* neuen Linie(Destination) jedes Pixel genau 4 mal
661		* vorkommen, also es findet auch keine Glaetung
	660	* neuen Linie(Destination) jedes Pixel genau 4 mal
	661	* vorkommen, also es findet auch keine Glaetung
662	662	* statt (NoInterpolation). Als Parameter sollen
663	663	* der Anfangs-, der Enditerator und der Accessor
664	664	* der Ausgangslinie (Source line), der Anfangsiterator
665	665	* und Accessor der Ziellinie (destination line) und
666	666	* anschliessend der Faktor um den die Linie (Zeile)
667		* vergroessert bzw. verkleinert werden soll.
	667	* vergroessert bzw. verkleinert werden soll.
668	668	*/
669		template <class SrcIterator, class SrcAccessor,
	669	template <class SrcIterator, class SrcAccessor,
670	670	class DestIterator, class DestAccessor>
671	671	void resampleLine(SrcIterator src_iter, SrcIterator src_iter_end, SrcAccessor src_acc,
672	672	DestIterator dest_iter, DestAccessor dest_acc, double factor)
673	673	{
674		// The width of the src line.
	674	// The width of the src line.
675	675	int src_width = src_iter_end - src_iter;
676
	676
677	677	vigra_precondition(src_width > 0,
678	678	"resampleLine(): input image too small.");
679	679	vigra_precondition(factor > 0.0,
680	680	"resampleLine(): factor must be positive.");
681
	681
682	682	if (factor >= 1.0)
683	683	{
684	684	int int_factor = (int)factor;

700	700	}
701	701	else
702	702	{
703		DestIterator dest_end = dest_iter + (int)VIGRA_CSTD::ceil(src_width*factor);
	703	DestIterator dest_end = dest_iter + (int)VIGRA_CSTD::ceil(src_width*factor);
704	704	factor = 1.0/factor;
705	705	int int_factor = (int)factor;
706	706	double dx = factor - int_factor;
707	707	double saver = dx;
708	708	src_iter_end -= 1;
709		for ( ; src_iter != src_iter_end && dest_iter != dest_end ;
	709	for ( ; src_iter != src_iter_end && dest_iter != dest_end ;
710	710	++dest_iter, src_iter += int_factor, saver += dx)
711	711	{
712	712	if (saver >= 1.0)

726	726	inline int sizeForResamplingFactor(int oldsize, double factor)
727	727	{
728	728	return (factor < 1.0)
729		? (int)VIGRA_CSTD::ceil(oldsize * factor)
	729	? (int)VIGRA_CSTD::ceil(oldsize * factor)
730	730	: (int)(oldsize * factor);
731	731	}
732	732

739	739
740	740	/** \brief Resample image by a given factor.
741	741
742		This algorithm is very fast and does not require any arithmetic on the pixel types.
	742	This algorithm is very fast and does not require any arithmetic on the pixel types.
743	743	The input image must have a size of at
744	744	least 2x2. Destiniation pixels are directly copied from the appropriate
745	745	source pixels. The size of the result image is the product of <tt>factor</tt>
746	746	and the original size, where we round up if <tt>factor < 1.0</tt> and down otherwise.
747		This size calculation is the main difference to the convention used in the similar
	747	This size calculation is the main difference to the convention used in the similar
748	748	function \ref resizeImageNoInterpolation():
749		there, the result size is calculated as <tt>n*(old_width-1)+1</tt> and
750		<tt>n*(old_height-1)+1</tt>. This is because \ref resizeImageNoInterpolation()
	749	there, the result size is calculated as <tt>n*(old_width-1)+1</tt> and
	750	<tt>n*(old_height-1)+1</tt>. This is because \ref resizeImageNoInterpolation()
751	751	does not replicate the last pixel of every row/column in order to make it compatible
752	752	with the other functions of the <tt>resizeImage...</tt> family.
753
	753
754	754	The function can be called with different resampling factors for x and y, or
755	755	with a single factor to be used for both directions.
756	756
757	757	It should also be noted that resampleImage() is implemented so that an enlargement followed
758		by the corresponding shrinking reproduces the original image.
759
	758	by the corresponding shrinking reproduces the original image.
	759
760	760	<b> Declarations:</b>
761
	761
762	762	pass 2D array views:
763	763	\code
764	764	namespace vigra {
765	765	template <class T1, class S1,
766	766	class T2, class S2>
767		void
	767	void
768	768	resampleImage(MultiArrayView<2, T1, S1> const & src,
769	769	MultiArrayView<2, T2, S2> dest, double factor);
770	770
771	771	template <class T1, class S1,
772	772	class T2, class S2>
773		void
	773	void
774	774	resampleImage(MultiArrayView<2, T1, S1> const & src,
775	775	MultiArrayView<2, T2, S2> dest, double xfactor, double yfactor);
776	776	}
777	777	\endcode
778
	778
779	779	\deprecatedAPI{resampleImage}
780	780	pass \ref ImageIterators and \ref DataAccessors :
781	781	\code
782	782	namespace vigra {
783	783	template <class SrcIterator, class SrcAccessor,
784	784	class DestIterator, class DestAccessor>
785		void
	785	void
786	786	resampleImage(SrcIterator is, SrcIterator iend, SrcAccessor sa,
787	787	DestIterator id, DestAccessor ad, double factor);
788
	788
789	789	template <class SrcIterator, class SrcAccessor,
790	790	class DestIterator, class DestAccessor>
791		void
	791	void
792	792	resampleImage(SrcIterator is, SrcIterator iend, SrcAccessor sa,
793	793	DestIterator id, DestAccessor ad, double xfactor, double yfactor);
794	794	}

798	798	namespace vigra {
799	799	template <class SrcImageIterator, class SrcAccessor,
800	800	class DestImageIterator, class DestAccessor>
801		void
	801	void
802	802	resampleImage(triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src,
803	803	pair<DestImageIterator, DestAccessor> dest, double factor);
804
	804
805	805	template <class SrcImageIterator, class SrcAccessor,
806	806	class DestImageIterator, class DestAccessor>
807		void
	807	void
808	808	resampleImage(triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src,
809	809	pair<DestImageIterator, DestAccessor> dest, double xfactor, double yfactor);
810	810	}
811	811	\endcode
812	812	\deprecatedEnd
813
	813
814	814	<b> Usage:</b>
815
	815
816	816	<b>\#include</b> \<vigra/basicgeometry.hxx\><br>
817	817	Namespace: vigra
818
	818
819	819	\code
820	820	double factor = 2.0;
821	821	MultiArray<2, float> src(width, height),
822	822	dest((int)(factorwidth), (int)(factorheight)); // enlarge image by factor
823	823	... // fill src
824
	824
825	825	resampleImage(src, dest, factor);
826	826	\endcode
827
	827
828	828	\deprecatedUsage{resampleImage}
829	829	\code
830	830	// use old API
831		vigra::resampleImage(srcImageRange(src), destImage(dest), factor);
	831	vigra::resampleImage(srcImageRange(src), destImage(dest), factor);
832	832	\endcode
833	833	<b> Required Interface:</b>
834	834	\code
835	835	SrcImageIterator src_upperleft, src_lowerright;
836	836	DestImageIterator dest_upperleft;
837
	837
838	838	SrcAccessor src_accessor;
839
	839
840	840	dest_accessor.set(src_accessor(src_upperleft), dest_upperleft);
841	841	\endcode
842	842	\deprecatedEnd
843
	843
844	844	<b> Preconditions:</b>
845	845	\code
846		src.shape(0) > 1 && src.shape(1) > 1
	846	src.shape(0) > 1 && src.shape(1) > 1
847	847	\endcode
848	848	*/
849	849	doxygen_overloaded_function(template <...> void resampleImage)
850	850
851	851	template <class SrcIterator, class SrcAccessor,
852	852	class DestIterator, class DestAccessor>
853		void
	853	void
854	854	resampleImage(SrcIterator is, SrcIterator iend, SrcAccessor sa,
855	855	DestIterator id, DestAccessor ad, double xfactor, double yfactor)
856	856	{
857	857	int width_old = iend.x - is.x;
858	858	int height_old = iend.y - is.y;
859
	859
860	860	//Bei Verkleinerung muss das dest-Bild ceiling(src*factor), da z.B.
861	861	//aus 6x6 grossem Bild wird eins 18x18 grosses gemacht bei Vergroesserungsfaktor 3.1
862	862	//umgekehrt damit wir vom 18x18 zu 6x6 (und nicht 5x5) bei Vergroesserung von 1/3.1
863	863	//muss das kleinste Integer das groesser als 18/3.1 ist genommen werden.
864	864	int height_new = sizeForResamplingFactor(height_old, yfactor);
865	865	int width_new = sizeForResamplingFactor(width_old, xfactor);
866
	866
867	867	vigra_precondition((width_old > 1) && (height_old > 1),
868	868	"resampleImage(): "
869	869	"Source image too small.\n");
870	870	vigra_precondition((width_new > 1) && (height_new > 1),
871	871	"resampleImage(): "
872	872	"Destination image too small.\n");
873
	873
874	874	typedef typename SrcAccessor::value_type SRCVT;
875	875	typedef BasicImage<SRCVT> TmpImage;
876	876	typedef typename TmpImage::traverser TmpImageIterator;
877	877
878	878	BasicImage<SRCVT> tmp(width_old, height_new);
879
	879
880	880	int x,y;
881
	881
882	882	typename BasicImage<SRCVT>::Iterator yt = tmp.upperLeft();
883	883
884		for(x=0; x<width_old; ++x, ++is.x, ++yt.x)
	884	for(x=0; x<width_old; ++x, ++is.x, ++yt.x)
885	885	{
886	886	typename SrcIterator::column_iterator c1 = is.columnIterator();
887	887	typename TmpImageIterator::column_iterator ct = yt.columnIterator();

890	890
891	891	yt = tmp.upperLeft();
892	892
893		for(y=0; y < height_new; ++y, ++yt.y, ++id.y)
	893	for(y=0; y < height_new; ++y, ++yt.y, ++id.y)
894	894	{
895	895	typename DestIterator::row_iterator rd = id.rowIterator();
896	896	typename TmpImageIterator::row_iterator rt = yt.rowIterator();

901	901
902	902	template <class SrcIterator, class SrcAccessor,
903	903	class DestIterator, class DestAccessor>
904		void
	904	void
905	905	resampleImage(SrcIterator is, SrcIterator iend, SrcAccessor sa,
906	906	DestIterator id, DestAccessor ad, double factor)
907	907	{

910	910
911	911	template <class SrcImageIterator, class SrcAccessor,
912	912	class DestImageIterator, class DestAccessor>
913		inline void
	913	inline void
914	914	resampleImage(triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src,
915	915	pair<DestImageIterator, DestAccessor> dest, double factor)
916	916	{

919	919
920	920	template <class SrcImageIterator, class SrcAccessor,
921	921	class DestImageIterator, class DestAccessor>
922		inline void
	922	inline void
923	923	resampleImage(triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src,
924	924	pair<DestImageIterator, DestAccessor> dest, double xfactor, double yfactor)
925	925	{

928	928
929	929	template <class T1, class S1,
930	930	class T2, class S2>
931		inline void
	931	inline void
932	932	resampleImage(MultiArrayView<2, T1, S1> const & src,
933	933	MultiArrayView<2, T2, S2> dest, double factor)
934	934	{

938	938	else
939	939	vigra_precondition(ceil(factor*src.shape()) == dest.shape(),
940	940	"resampleImage(): shape mismatch between input and output.");
941
	941
942	942	resampleImage(srcImageRange(src), destImage(dest), factor);
943	943	}
944	944
945	945	template <class T1, class S1,
946	946	class T2, class S2>
947		inline void
	947	inline void
948	948	resampleImage(MultiArrayView<2, T1, S1> const & src,
949	949	MultiArrayView<2, T2, S2> dest, double xfactor, double yfactor)
950	950	{

960	960	else
961	961	vigra_precondition(ceil(yfactor*src.shape(1)) == dest.shape(1),
962	962	"resampleImage(): shape mismatch between input and output.");
963
	963
964	964	resampleImage(srcImageRange(src), destImage(dest), xfactor, yfactor);
965	965	}
966	966

+2

-0

include/vigra/basicimage.hxx less more

462	462
463	463	/** \brief Fundamental class template for images.
464	464
	465	<b>deprecated</b>, use \ref vigra::MultiArray instead
	466
465	467	A customized memory allocator can be specified as a templated argument
466	468	and passed in the constructor.
467	469

+2

-0

include/vigra/basicimageview.hxx less more

58	58
59	59	/** \brief BasicImage using foreign memory.
60	60
	61	<b>deprecated</b>, use \ref vigra::MultiArrayView instead
	62
61	63	This class provides the same interface as \ref vigra::BasicImage
62	64	(with the exception of <tt>resize()</tt>) but the image's
63	65	memory is provided from the outside instead of allocated internally.

+409

-0

include/vigra/binary_forest.hxx less more

	0	/************************************************************************/
	1	/* */
	2	/* Copyright 2014-2015 by Ullrich Koethe and Philip Schill */
	3	/* */
	4	/* This file is part of the VIGRA computer vision library. */
	5	/* The VIGRA Website is */
	6	/* http://hci.iwr.uni-heidelberg.de/vigra/ */
	7	/* Please direct questions, bug reports, and contributions to */
	8	/* ullrich.koethe@iwr.uni-heidelberg.de or */
	9	/* vigra@informatik.uni-hamburg.de */
	10	/* */
	11	/* Permission is hereby granted, free of charge, to any person */
	12	/* obtaining a copy of this software and associated documentation */
	13	/* files (the "Software"), to deal in the Software without */
	14	/* restriction, including without limitation the rights to use, */
	15	/* copy, modify, merge, publish, distribute, sublicense, and/or */
	16	/* sell copies of the Software, and to permit persons to whom the */
	17	/* Software is furnished to do so, subject to the following */
	18	/* conditions: */
	19	/* */
	20	/* The above copyright notice and this permission notice shall be */
	21	/* included in all copies or substantial portions of the */
	22	/* Software. */
	23	/* */
	24	/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND */
	25	/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES */
	26	/* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND */
	27	/* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT */
	28	/* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, */
	29	/* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING */
	30	/* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR */
	31	/* OTHER DEALINGS IN THE SOFTWARE. */
	32	/* */
	33	/************************************************************************/
	34	#ifndef VIGRA_BINARY_FOREST_HXX
	35	#define VIGRA_BINARY_FOREST_HXX
	36
	37	#include <vector>
	38	#include "graphs.hxx"
	39
	40	namespace vigra
	41	{
	42
	43	/** \addtogroup GraphDataStructures
	44	*/
	45	//@{
	46
	47	/********************************************************/
	48	/* */
	49	/* BinaryForest */
	50	/* */
	51	/********************************************************/
	52
	53	/**
	54	* @brief BinaryForest stores a collection of rooted binary trees.
	55	*
	56	* Each connected component of the BinaryForest is thus a tree, and all edges are
	57	* directed away from the root node of the corresponding tree.
	58	*
	59	* @note If there is an arc from node <tt>u</tt> to node <tt>v</tt>, then the
	60	* arc ID is <tt>2id(u)</tt> when <tt>v</tt> is the left child and <tt>2id(u)+1</tt>
	61	* when <tt>v</tt> is the right child.
	62	*/
	63	class BinaryForest
	64	{
	65	public:
	66
	67	typedef Int64 index_type;
	68	/// Node descriptor type of the present graph.
	69	typedef detail::NodeDescriptor<index_type> Node;
	70	/// Arc descriptor type of the present graph.
	71	typedef detail::ArcDescriptor<index_type> Arc;
	72
	73	/// @brief Create an empty forest.
	74	BinaryForest();
	75
	76	/// @brief Add a new node (its node ID will be selected automatically).
	77	Node addNode();
	78	/// @brief Add a new arc from node \a u to node \a v.
	79	/// The arc ID is <tt>2id(u)</tt> if \a v is the left child of \a u, <tt>2id(u)+1</tt> otherwise.
	80	Arc addArc(Node const & u, Node const & v);
	81	/// @brief Check if \a node exists.
	82	bool valid(Node const & node) const;
	83	/// @brief Check if \a arc exists.
	84	bool valid(Arc const & arc) const;
	85	/// @brief Find start node of \a arc.
	86	Node source(Arc const & arc) const;
	87	/// @brief Find end node of \a arc.
	88	Node target(Arc const & arc) const;
	89	/// @brief Get ID for node descriptor \a node.
	90	index_type id(Node const & node) const;
	91	/// @brief Get ID for arc descriptor \a arc.
	92	index_type id(Arc const & arc) const;
	93	/// @brief Get node descriptor for \a id.
	94	Node nodeFromId(index_type const & id) const;
	95	/// @brief Get arc descriptor for \a id.
	96	Arc arcFromId(index_type const & id) const;
	97	/// @brief Return the highest existing node ID.
	98	index_type maxNodeId() const;
	99	/// @brief Return the highest possible arc ID (equivalent to <tt>2*maxNodeId() + 1</tt>).
	100	index_type maxArcId() const;
	101	/// @brief Return the number of nodes (equivalent to <tt>maxNodeId()+1</tt>).
	102	size_t numNodes() const;
	103	/// @brief Return the number of arcs.
	104	/// Always less than <tt>maxArcId()</tt> because not all arcs actually exist.
	105	size_t numArcs() const;
	106	/// @brief Return the number of incoming edges of \a node.
	107	/// <tt>0</tt> for a root node, <tt>1</tt> otherwise.
	108	size_t inDegree(Node const & node) const;
	109	/// @brief Return the number of outgoing edges of \a node.
	110	/// <tt>0</tt> for a leaf node, <tt>1</tt> or <tt>2</tt> otherwise.
	111	size_t outDegree(Node const & node) const;
	112	/// @brief Return the number of parents of \a node (equivalent to <tt>inDegree()</tt>).
	113	size_t numParents(Node const & node) const;
	114	/// @brief Return the number of children of \a node (equivalent to <tt>outDegree()</tt>).
	115	size_t numChildren(Node const & node) const;
	116	/// @brief Return the number of trees in the forest.
	117	size_t numRoots() const;
	118	/// @brief Create node cescriptor for ID \a i, or <tt>lemon::INVALID</tt> if
	119	/// \a i is not a valid ID.
	120	Node getNode(size_t i) const;
	121	/// @brief Get the parent node descriptor of \a node, or <tt>lemon::INVALID</tt>
	122	/// if \a node is a root or \a i is non-zero.
	123	Node getParent(Node const & node, size_t i = 0) const;
	124	/// @brief Get child number \a i of \a node.
	125	/// Returns the left child if <tt>i=0</tt>, the right child if <tt>i=1</tt>,
	126	/// and <tt>lemon::INVALID</tt> for other values of \a i or when the respective
	127	/// is undefined.
	128	Node getChild(Node const & node, size_t i = 0) const;
	129	/// @brief Get the root node descriptor of tree \a i in the forest, or
	130	/// <tt>lemon::INVALID</tt> if \a i is invalid.
	131	Node getRoot(size_t i = 0) const;
	132	/// @brief Merge two forests and increase the IDs of \a other to avoid ID clashes.
	133	/// The function returns the offset that has been added to these IDs.
	134	size_t merge(BinaryForest const & other);
	135
	136	private:
	137
	138	struct NodeT
	139	{
	140	NodeT()
	141	:
	142	parent(-1),
	143	left_child(-1),
	144	right_child(-1)
	145	{}
	146	index_type parent, left_child, right_child;
	147	};
	148
	149	std::vector<NodeT> nodes_;
	150
	151	// Sorted vector with the node ids of the roots.
	152	std::vector<index_type> root_nodes_;
	153
	154	size_t num_arcs_;
	155	};
	156
	157
	158
	159	inline BinaryForest::BinaryForest()
	160	:
	161	nodes_(),
	162	root_nodes_(),
	163	num_arcs_(0)
	164	{}
	165
	166	inline BinaryForest::Node BinaryForest::addNode()
	167	{
	168	Node n = Node(nodes_.size());
	169	nodes_.push_back(NodeT());
	170	root_nodes_.push_back(n.id());
	171	return n;
	172	}
	173
	174	inline BinaryForest::Arc BinaryForest::addArc(
	175	Node const & u,
	176	Node const & v
	177	){
	178	NodeT & u_node = nodes_[u.id()];
	179	NodeT & v_node = nodes_[v.id()];
	180	index_type arc_id = 2*u.id();
	181
	182	// Make sure that the arc is not inserted twice.
	183	if (u_node.left_child == v.id())
	184	return Arc(arc_id);
	185	if (u_node.right_child == v.id())
	186	return Arc(arc_id+1);
	187
	188	// Add v as child of u.
	189	if (u_node.left_child == -1)
	190	{
	191	u_node.left_child = v.id();
	192	}
	193	else if (u_node.right_child == -1)
	194	{
	195	u_node.right_child = v.id();
	196	++arc_id;
	197	}
	198	else
	199	{
	200	vigra_fail("BinaryForest::addArc(): The node u already has two children.");
	201	}
	202
	203	// Add u as parent of v.
	204	v_node.parent = u.id();
	205
	206	// If v was a root node, remove it from the list.
	207	auto it = std::lower_bound(root_nodes_.begin(), root_nodes_.end(), v.id());
	208	if (it != root_nodes_.end() && !(v.id() < *it))
	209	root_nodes_.erase(it);
	210
	211	++num_arcs_;
	212	return Arc(arc_id);
	213	}
	214
	215	inline bool BinaryForest::valid(
	216	Node const & node
	217	) const {
	218	// NOTE: The conversion to size_t is valid since we first check for >= 0.
	219	return node.id() >= 0 && (size_t)node.id() < nodes_.size();
	220	}
	221
	222	inline bool BinaryForest::valid(
	223	Arc const & arc
	224	) const {
	225	if (arc == lemon::INVALID)
	226	return false;
	227
	228	index_type const uid = arc.id()/2;
	229	if (!valid(Node(uid)))
	230	return false;
	231
	232	if (arc.id() % 2 == 0)
	233	return nodes_[uid].left_child != -1;
	234	else
	235	return nodes_[uid].right_child != -1;
	236	}
	237
	238	inline BinaryForest::Node BinaryForest::source(
	239	Arc const & arc
	240	) const {
	241	return Node(arc.id()/2);
	242	}
	243
	244	inline BinaryForest::Node BinaryForest::target(
	245	Arc const & arc
	246	) const {
	247	NodeT const & u_node = nodes_[arc.id()/2];
	248	if (arc.id() % 2 == 0)
	249	return Node(u_node.left_child);
	250	else
	251	return Node(u_node.right_child);
	252	}
	253
	254	inline BinaryForest::index_type BinaryForest::id(
	255	Node const & node
	256	) const {
	257	return node.id();
	258	}
	259
	260	inline BinaryForest::index_type BinaryForest::id(
	261	Arc const & arc
	262	) const {
	263	return arc.id();
	264	}
	265
	266	inline BinaryForest::Node BinaryForest::nodeFromId(
	267	index_type const & id
	268	) const {
	269	return Node(id);
	270	}
	271
	272	inline BinaryForest::Arc BinaryForest::arcFromId(
	273	index_type const & id
	274	) const {
	275	return Arc(id);
	276	}
	277
	278	inline BinaryForest::index_type BinaryForest::maxNodeId() const
	279	{
	280	return nodes_.size()-1;
	281	}
	282
	283	inline BinaryForest::index_type BinaryForest::maxArcId() const
	284	{
	285	return 2*maxNodeId() + 1;
	286	}
	287
	288	inline size_t BinaryForest::numNodes() const
	289	{
	290	return nodes_.size();
	291	}
	292
	293	inline size_t BinaryForest::numArcs() const
	294	{
	295	return num_arcs_;
	296	}
	297
	298	inline size_t BinaryForest::inDegree(
	299	Node const & node
	300	) const {
	301	if (nodes_[node.id()].parent == -1)
	302	return 0;
	303	else
	304	return 1;
	305	}
	306
	307	inline size_t BinaryForest::outDegree(
	308	Node const & node
	309	) const {
	310	NodeT const & n = nodes_[node.id()];
	311	if (n.left_child == -1 && n.right_child == -1)
	312	return 0;
	313	else if (n.left_child == -1 \|\| n.right_child == -1)
	314	return 1;
	315	else
	316	return 2;
	317	}
	318
	319	inline size_t BinaryForest::numParents(
	320	Node const & node
	321	) const {
	322	return inDegree(node);
	323	}
	324
	325	inline size_t BinaryForest::numChildren(
	326	Node const & node
	327	) const {
	328	return outDegree(node);
	329	}
	330
	331	inline size_t BinaryForest::numRoots() const
	332	{
	333	return root_nodes_.size();
	334	}
	335
	336	inline BinaryForest::Node BinaryForest::getNode(
	337	size_t i
	338	) const {
	339	if (i >= numNodes())
	340	return Node(lemon::INVALID);
	341	else
	342	return Node(i);
	343	}
	344
	345	inline BinaryForest::Node BinaryForest::getParent(
	346	Node const & node,
	347	size_t i
	348	) const {
	349	NodeT const & n = nodes_[node.id()];
	350	if (n.parent == -1 \|\| i != 0)
	351	return Node(lemon::INVALID);
	352	else
	353	return Node(n.parent);
	354	}
	355
	356	inline BinaryForest::Node BinaryForest::getChild(
	357	Node const & node,
	358	size_t i
	359	) const {
	360	NodeT const & n = nodes_[node.id()];
	361	if (i == 0)
	362	return Node(n.left_child);
	363	else if (i == 1)
	364	return Node(n.right_child);
	365	else
	366	return Node(lemon::INVALID);
	367	}
	368
	369	inline BinaryForest::Node BinaryForest::getRoot(
	370	size_t i
	371	) const {
	372	if (i >= root_nodes_.size())
	373	return Node(lemon::INVALID);
	374	else
	375	return Node(root_nodes_[i]);
	376	}
	377
	378	inline size_t BinaryForest::merge(
	379	BinaryForest const & other
	380	){
	381	num_arcs_ += other.num_arcs_;
	382	size_t const offset = nodes_.size();
	383	nodes_.insert(nodes_.end(), other.nodes_.begin(), other.nodes_.end());
	384	for (size_t i = offset; i < nodes_.size(); ++i)
	385	{
	386	NodeT & n = nodes_[i];
	387	if (n.parent != -1)
	388	n.parent += offset;
	389	if (n.left_child != -1)
	390	n.left_child += offset;
	391	if (n.right_child != -1)
	392	n.right_child += offset;
	393	}
	394
	395	size_t const root_offset = root_nodes_.size();
	396	root_nodes_.insert(root_nodes_.end(), other.root_nodes_.begin(), other.root_nodes_.end());
	397	for (size_t i = root_offset; i < root_nodes_.size(); ++i)
	398	{
	399	root_nodes_[i] += offset;
	400	}
	401	return offset;
	402	}
	403
	404	//@}
	405
	406	} // namespace vigra
	407
	408	#endif

+1

-1

include/vigra/blockify.hxx less more

83	83	Shape current_block_begin,
84	84	Shape current_block_end,
85	85	Shape current_block_pos,
86		Shape block_shape)
	86	Shape /block_shape/)
87	87	{
88	88	blocks[current_block_pos] = source.subarray(current_block_begin, current_block_end);
89	89	}

+7

-1

include/vigra/blockwise_labeling.hxx less more

148	148	vigra_precondition(blocks_shape == label_blocks_begin.shape() &&
149	149	blocks_shape == mapping.shape(),
150	150	"shapes of blocks of blocks do not match");
	151	vigra_precondition(std::distance(data_blocks_begin,data_blocks_end) == std::distance(label_blocks_begin,label_blocks_end),
	152	"the sizes of input ranges are different");
151	153
152	154	static const unsigned int Dimensions = DataBlocksIterator::dimension + 1;
153	155	MultiArray<Dimensions, Label> label_offsets(label_blocks_begin.shape());

171	173	//std::iota(ids.begin(), ids.end(), 0 );
172	174
173	175	parallel_foreach(options.getNumThreads(), d,
174		[&](const int threadId, const uint64_t i){
	176	[&](const int /threadId/, const uint64_t i){
175	177	Label resVal = labelMultiArray(data_blocks_it[i], label_blocks_it[i],
176	178	options, equal);
177	179	if(has_background) // FIXME: reversed condition?

301	303	/* */
302	304	/*************************************************************/
303	305
	306	/** \weakgroup ParallelProcessing
	307	\sa labelMultiArrayBlockwise <B>(...)</B>
	308	*/
	309
304	310	/** \brief Connected components labeling for MultiArrays and ChunkedArrays.
305	311
306	312	<b> Declarations:</b>

+8

-2

include/vigra/blockwise_watersheds.hxx less more

40	40	#include "multi_gridgraph.hxx"
41	41	#include "blockify.hxx"
42	42	#include "blockwise_labeling.hxx"
	43	#include "metaprogramming.hxx"
43	44	#include "overlapped_blocks.hxx"
44	45
45	46	#include <limits>

47	48	namespace vigra
48	49	{
49	50
50		/** \addtogroup SeededRegionGrowing
	51	/** \addtogroup Superpixels
51	52	*/
52	53	//@{
53	54

60	61	BlockwiseLabelOptions const & options)
61	62	{
62	63	static const unsigned int N = DataArray::actual_dimension;
	64	ignore_argument(N);
63	65	typedef typename MultiArrayShape<DataArray::actual_dimension>::type Shape;
64	66	typedef typename DirectionsBlocksIterator::value_type DirectionsBlock;
65	67	Shape shape = overlaps.shape();

71	73
72	74	parallel_foreach(options.getNumThreads(),
73	75	itBegin,end,
74		[&](const int threadId, const Coordinate iterVal){
	76	[&](const int /threadId/, const Coordinate iterVal){
75	77
76	78	DirectionsBlock directions_block = directions_blocks_begin[iterVal];
77	79	OverlappingBlock<DataArray> data_block = overlaps[iterVal];

136	138	/* */
137	139	/*************************************************************/
138	140
	141	/** \weakgroup ParallelProcessing
	142	\sa unionFindWatershedsBlockwise <B>(...)</B>
	143	*/
	144
139	145	/** \brief Blockwise union-find watersheds transform for MultiArrays and ChunkedArrays.
140	146
141	147	<b> Declaration:</b>

+4

-4

include/vigra/boundarytensor.hxx less more

355	355
356	356	} // namespace detail
357	357
358		/** \addtogroup CommonConvolutionFilters Common Filters
	358	/** \addtogroup ConvolutionFilters
359	359	*/
360	360	//@{
361	361

678	678
679	679	/** \brief Boundary tensor variant.
680	680
681		This function implements a variant of the boundary tensor where the
682		0th-order Riesz transform has been dropped, so that the tensor is no
683		longer sensitive to blobs. See \ref boundaryTensor() for more detailed
	681	This function implements a variant of the boundary tensor where the
	682	0th-order Riesz transform has been dropped, so that the tensor is no
	683	longer sensitive to blobs. See \ref boundaryTensor() for more detailed
684	684	documentation.
685	685
686	686	<b> Declarations:</b>

+2

-2

include/vigra/config_version.hxx less more

38	38
39	39	#define VIGRA_VERSION_MAJOR 1
40	40	#define VIGRA_VERSION_MINOR 11
41		#define VIGRA_VERSION_PATCH 0
42		#define VIGRA_VERSION "1.11.0"
	41	#define VIGRA_VERSION_PATCH 1
	42	#define VIGRA_VERSION "1.11.1"
43	43
44	44	#endif /* VIGRA_CONFIG_VERSION_HXX */

+5

-38

include/vigra/convolution.hxx less more

45	45	#include "multi_shape.hxx"
46	46
47	47
48		/** \page Convolution Functions to Convolve Images and Signals
49
50		1D and 2D filters, including separable and recursive convolution, and non-linear diffusion
51
52		<b>\#include</b> \<vigra/convolution.hxx\><br>
53		Namespace: vigra
54
55		<UL style="list-style-image:url(documents/bullet.gif)">
56		<LI> \ref CommonConvolutionFilters
57		<BR>   <em>Short-hands for many common 2D convolution filters (including normalized convolution)</em>
58		<LI> \ref MultiArrayConvolutionFilters
59		<BR>   <em>Convolution filters for arbitrary dimensional arrays (MultiArray etc.)</em>
60		<LI> \ref ResamplingConvolutionFilters
61		<BR>   <em>Resampling convolution filters</em>
62		<LI> \ref vigra::Kernel2D
63		<BR>   <em>Generic 2-dimensional discrete convolution kernel </em>
64		<LI> \ref SeparableConvolution
65		<BR>   <em>1D convolution and separable filters in 2 dimensions </em>
66		<LI> \ref vigra::Kernel1D
67		<BR>   <em>Generic 1-dimensional discrete convolution kernel </em>
68		<LI> \ref RecursiveConvolution
69		<BR>   <em>Recursive filters (1st and 2nd order)</em>
70		<LI> \ref NonLinearDiffusion
71		<BR>   <em>Edge-preserving smoothing </em>
72		<LI> \ref BorderTreatmentMode
73		<BR>   <em>Choose between different border treatment modes </em>
74		<LI> \ref KernelArgumentObjectFactories
75		<BR>   <em>Factory functions to create argument objects to simplify passing kernels</em>
76		</UL>
77		*/
78
79	48	/** \page KernelArgumentObjectFactories Kernel Argument Object Factories
80	49
81	50	These factory functions allow to create argument objects for 1D

173	142
174	143	namespace vigra {
175	144
176
177
178	145	/********************************************************/
179	146	/* */
180	147	/* Common convolution filters */
181	148	/* */
182	149	/********************************************************/
183	150
184		/** \addtogroup CommonConvolutionFilters Common Filters
185
186		These functions calculate common filters by appropriate sequences of calls
187		to \ref separableConvolveX() and \ref separableConvolveY() or explicit 2-dimensional
188		convolution.
	151	/** \addtogroup ConvolutionFilters
189	152	*/
190	153	//@{
191	154

1068	1031	gaussianGradient(srcImageRange(src),
1069	1032	destImage(dest), scale);
1070	1033	}
	1034
	1035	/** \weakgroup ParallelProcessing
	1036	\sa gaussianGradientMagnitude <B>(...,</B> BlockwiseConvolutionOptions<B>)</B>
	1037	*/
1071	1038
1072	1039	/** \brief Calculate the gradient magnitude by means of a 1st derivatives of
1073	1040	Gaussian filter.

+1

-1

include/vigra/counting_iterator.hxx less more

148	148
149	149	} // namespace detail
150	150
151		/** \addtogroup MathFunctions
	151	/** \addtogroup RangesAndPoints
152	152	*/
153	153	//@{
154	154

+89

-89

include/vigra/delegate/detail/delegate_template.hxx less more

41	41	#else
42	42	#define VIGRA_DELEGATE_CLASS_NAME VIGRA_DELEGATE_JOIN_MACRO(delegate,VIGRA_DELEGATE_PARAM_COUNT)
43	43	#define VIGRA_DELEGATE_INVOKER_CLASS_NAME VIGRA_DELEGATE_JOIN_MACRO(delegate_invoker,VIGRA_DELEGATE_PARAM_COUNT)
44		template <typename R VIGRA_DELEGATE_SEPARATOR VIGRA_DELEGATE_TEMPLATE_PARAMS>
45		class VIGRA_DELEGATE_INVOKER_CLASS_NAME;
	44	template <typename R VIGRA_DELEGATE_SEPARATOR VIGRA_DELEGATE_TEMPLATE_PARAMS>
	45	class VIGRA_DELEGATE_INVOKER_CLASS_NAME;
46	46	#endif
47	47
48		template <typename R VIGRA_DELEGATE_SEPARATOR VIGRA_DELEGATE_TEMPLATE_PARAMS>
	48	template <typename R VIGRA_DELEGATE_SEPARATOR VIGRA_DELEGATE_TEMPLATE_PARAMS>
49	49	#ifdef VIGRA_DELEGATE_PREFERRED_SYNTAX
50		class VIGRA_DELEGATE_CLASS_NAME<R (VIGRA_DELEGATE_TEMPLATE_ARGS)>
	50	class VIGRA_DELEGATE_CLASS_NAME<R (VIGRA_DELEGATE_TEMPLATE_ARGS)>
51	51	#else
52		class VIGRA_DELEGATE_CLASS_NAME
	52	class VIGRA_DELEGATE_CLASS_NAME
53	53	#endif
54		{
55		public:
56		typedef R return_type;
	54	{
	55	public:
	56	typedef R return_type;
57	57	#ifdef VIGRA_DELEGATE_PREFERRED_SYNTAX
58		typedef return_type (VIGRA_DELEGATE_CALLTYPE *signature_type)(VIGRA_DELEGATE_TEMPLATE_ARGS);
59		typedef VIGRA_DELEGATE_INVOKER_CLASS_NAME<signature_type> invoker_type;
	58	typedef return_type (VIGRA_DELEGATE_CALLTYPE *signature_type)(VIGRA_DELEGATE_TEMPLATE_ARGS);
	59	typedef VIGRA_DELEGATE_INVOKER_CLASS_NAME<signature_type> invoker_type;
60	60	#else
61		typedef VIGRA_DELEGATE_INVOKER_CLASS_NAME<R VIGRA_DELEGATE_SEPARATOR VIGRA_DELEGATE_TEMPLATE_ARGS> invoker_type;
	61	typedef VIGRA_DELEGATE_INVOKER_CLASS_NAME<R VIGRA_DELEGATE_SEPARATOR VIGRA_DELEGATE_TEMPLATE_ARGS> invoker_type;
62	62	#endif
63	63
64		VIGRA_DELEGATE_CLASS_NAME()
65		: object_ptr(0)
66		, stub_ptr(0)
67		{}
	64	VIGRA_DELEGATE_CLASS_NAME()
	65	: object_ptr(0)
	66	, stub_ptr(0)
	67	{}
68	68
69		template <return_type (*TMethod)(VIGRA_DELEGATE_TEMPLATE_ARGS)>
70		static VIGRA_DELEGATE_CLASS_NAME from_function()
71		{
72		return from_stub(0, &function_stub<TMethod>);
73		}
	69	template <return_type (*TMethod)(VIGRA_DELEGATE_TEMPLATE_ARGS)>
	70	static VIGRA_DELEGATE_CLASS_NAME from_function()
	71	{
	72	return from_stub(0, &function_stub<TMethod>);
	73	}
74	74
75		template <class T, return_type (T::*TMethod)(VIGRA_DELEGATE_TEMPLATE_ARGS)>
76		static VIGRA_DELEGATE_CLASS_NAME from_method(T* object_ptr)
77		{
78		return from_stub(object_ptr, &method_stub<T, TMethod>);
79		}
	75	template <class T, return_type (T::*TMethod)(VIGRA_DELEGATE_TEMPLATE_ARGS)>
	76	static VIGRA_DELEGATE_CLASS_NAME from_method(T* object_ptr)
	77	{
	78	return from_stub(object_ptr, &method_stub<T, TMethod>);
	79	}
80	80
81		template <class T, return_type (T::*TMethod)(VIGRA_DELEGATE_TEMPLATE_ARGS) const>
82		static VIGRA_DELEGATE_CLASS_NAME from_const_method(T const* object_ptr)
83		{
84		return from_stub(const_cast<T*>(object_ptr), &const_method_stub<T, TMethod>);
85		}
	81	template <class T, return_type (T::*TMethod)(VIGRA_DELEGATE_TEMPLATE_ARGS) const>
	82	static VIGRA_DELEGATE_CLASS_NAME from_const_method(T const* object_ptr)
	83	{
	84	return from_stub(const_cast<T*>(object_ptr), &const_method_stub<T, TMethod>);
	85	}
86	86
87		return_type operator()(VIGRA_DELEGATE_PARAMS) const
88		{
89		return (*stub_ptr)(object_ptr VIGRA_DELEGATE_SEPARATOR VIGRA_DELEGATE_ARGS);
90		}
	87	return_type operator()(VIGRA_DELEGATE_PARAMS) const
	88	{
	89	return (*stub_ptr)(object_ptr VIGRA_DELEGATE_SEPARATOR VIGRA_DELEGATE_ARGS);
	90	}
91	91
92		operator bool () const
93		{
94		return stub_ptr != 0;
95		}
	92	operator bool () const
	93	{
	94	return stub_ptr != 0;
	95	}
96	96
97		bool operator!() const
98		{
99		return !(operator bool());
100		}
	97	bool operator!() const
	98	{
	99	return !(operator bool());
	100	}
101	101
102		private:
103
104		typedef return_type (VIGRA_DELEGATE_CALLTYPE stub_type)(void object_ptr VIGRA_DELEGATE_SEPARATOR VIGRA_DELEGATE_PARAMS);
	102	private:
	103
	104	typedef return_type (VIGRA_DELEGATE_CALLTYPE stub_type)(void object_ptr VIGRA_DELEGATE_SEPARATOR VIGRA_DELEGATE_PARAMS);
105	105
106		void* object_ptr;
107		stub_type stub_ptr;
	106	void* object_ptr;
	107	stub_type stub_ptr;
108	108
109		static VIGRA_DELEGATE_CLASS_NAME from_stub(void* object_ptr, stub_type stub_ptr)
110		{
111		VIGRA_DELEGATE_CLASS_NAME d;
112		d.object_ptr = object_ptr;
113		d.stub_ptr = stub_ptr;
114		return d;
115		}
	109	static VIGRA_DELEGATE_CLASS_NAME from_stub(void* object_ptr, stub_type stub_ptr)
	110	{
	111	VIGRA_DELEGATE_CLASS_NAME d;
	112	d.object_ptr = object_ptr;
	113	d.stub_ptr = stub_ptr;
	114	return d;
	115	}
116	116
117		template <return_type (*TMethod)(VIGRA_DELEGATE_TEMPLATE_ARGS)>
118		static return_type VIGRA_DELEGATE_CALLTYPE function_stub(void* VIGRA_DELEGATE_SEPARATOR VIGRA_DELEGATE_PARAMS)
119		{
120		return (TMethod)(VIGRA_DELEGATE_ARGS);
121		}
	117	template <return_type (*TMethod)(VIGRA_DELEGATE_TEMPLATE_ARGS)>
	118	static return_type VIGRA_DELEGATE_CALLTYPE function_stub(void* VIGRA_DELEGATE_SEPARATOR VIGRA_DELEGATE_PARAMS)
	119	{
	120	return (TMethod)(VIGRA_DELEGATE_ARGS);
	121	}
122	122
123		template <class T, return_type (T::*TMethod)(VIGRA_DELEGATE_TEMPLATE_ARGS)>
124		static return_type VIGRA_DELEGATE_CALLTYPE method_stub(void* object_ptr VIGRA_DELEGATE_SEPARATOR VIGRA_DELEGATE_PARAMS)
125		{
126		T* p = static_cast<T*>(object_ptr);
127		return (p->*TMethod)(VIGRA_DELEGATE_ARGS);
128		}
	123	template <class T, return_type (T::*TMethod)(VIGRA_DELEGATE_TEMPLATE_ARGS)>
	124	static return_type VIGRA_DELEGATE_CALLTYPE method_stub(void* object_ptr VIGRA_DELEGATE_SEPARATOR VIGRA_DELEGATE_PARAMS)
	125	{
	126	T* p = static_cast<T*>(object_ptr);
	127	return (p->*TMethod)(VIGRA_DELEGATE_ARGS);
	128	}
129	129
130		template <class T, return_type (T::*TMethod)(VIGRA_DELEGATE_TEMPLATE_ARGS) const>
131		static return_type VIGRA_DELEGATE_CALLTYPE const_method_stub(void* object_ptr VIGRA_DELEGATE_SEPARATOR VIGRA_DELEGATE_PARAMS)
132		{
133		T const* p = static_cast<T*>(object_ptr);
134		return (p->*TMethod)(VIGRA_DELEGATE_ARGS);
135		}
136		};
	130	template <class T, return_type (T::*TMethod)(VIGRA_DELEGATE_TEMPLATE_ARGS) const>
	131	static return_type VIGRA_DELEGATE_CALLTYPE const_method_stub(void* object_ptr VIGRA_DELEGATE_SEPARATOR VIGRA_DELEGATE_PARAMS)
	132	{
	133	T const* p = static_cast<T*>(object_ptr);
	134	return (p->*TMethod)(VIGRA_DELEGATE_ARGS);
	135	}
	136	};
137	137
138		template <typename R VIGRA_DELEGATE_SEPARATOR VIGRA_DELEGATE_TEMPLATE_PARAMS>
	138	template <typename R VIGRA_DELEGATE_SEPARATOR VIGRA_DELEGATE_TEMPLATE_PARAMS>
139	139	#ifdef VIGRA_DELEGATE_PREFERRED_SYNTAX
140		class VIGRA_DELEGATE_INVOKER_CLASS_NAME<R (VIGRA_DELEGATE_TEMPLATE_ARGS)>
	140	class VIGRA_DELEGATE_INVOKER_CLASS_NAME<R (VIGRA_DELEGATE_TEMPLATE_ARGS)>
141	141	#else
142		class VIGRA_DELEGATE_INVOKER_CLASS_NAME
	142	class VIGRA_DELEGATE_INVOKER_CLASS_NAME
143	143	#endif
144		{
145		VIGRA_DELEGATE_INVOKER_DATA
	144	{
	145	VIGRA_DELEGATE_INVOKER_DATA
146	146
147		public:
148		VIGRA_DELEGATE_INVOKER_CLASS_NAME(VIGRA_DELEGATE_PARAMS)
	147	public:
	148	VIGRA_DELEGATE_INVOKER_CLASS_NAME(VIGRA_DELEGATE_PARAMS)
149	149	#if VIGRA_DELEGATE_PARAM_COUNT > 0
150		:
	150	:
151	151	#endif
152		VIGRA_DELEGATE_INVOKER_INITIALIZATION_LIST
153		{
154		}
	152	VIGRA_DELEGATE_INVOKER_INITIALIZATION_LIST
	153	{
	154	}
155	155
156		template <class TDelegate>
157		R operator()(TDelegate d) const
158		{
159		return d(VIGRA_DELEGATE_ARGS);
160		}
161		};
	156	template <class TDelegate>
	157	R operator()(TDelegate d) const
	158	{
	159	return d(VIGRA_DELEGATE_ARGS);
	160	}
	161	};
162	162	}
163	163
164	164	#undef VIGRA_DELEGATE_CLASS_NAME

+62

-66

include/vigra/distancetransform.hxx less more

28	28	/* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, */
29	29	/* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING */
30	30	/* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR */
31		/* OTHER DEALINGS IN THE SOFTWARE. */
	31	/* OTHER DEALINGS IN THE SOFTWARE. */
32	32	/* */
33	33	/************************************************************************/
34
35
	34
	35
36	36	#ifndef VIGRA_DISTANCETRANSFORM_HXX
37	37	#define VIGRA_DISTANCETRANSFORM_HXX
38	38

43	43	namespace vigra {
44	44
45	45	/*
46		* functors to determine the distance norm
	46	* functors to determine the distance norm
47	47	* these functors assume that dx and dy are positive
48	48	* (this is OK for use in internalDistanceTransform())
49	49	*/
50
	50
51	51	// chessboard metric
52	52	struct InternalDistanceTransformLInifinityNormFunctor
53	53	{

80	80	class DestImageIterator, class DestAccessor,
81	81	class ValueType, class NormFunctor>
82	82	void
83		internalDistanceTransform(SrcImageIterator src_upperleft,
	83	internalDistanceTransform(SrcImageIterator src_upperleft,
84	84	SrcImageIterator src_lowerright, SrcAccessor sa,
85	85	DestImageIterator dest_upperleft, DestAccessor da,
86	86	ValueType background, NormFunctor norm)
87	87	{
88		int w = src_lowerright.x - src_upperleft.x;
89		int h = src_lowerright.y - src_upperleft.y;
90
	88	int w = src_lowerright.x - src_upperleft.x;
	89	int h = src_lowerright.y - src_upperleft.y;
	90
91	91	FImage xdist(w,h), ydist(w,h);
92
	92
93	93	xdist = (FImage::value_type)w; // init x and
94	94	ydist = (FImage::value_type)h; // y distances with 'large' values
95	95

101	101	DestImageIterator rx = ry;
102	102	FImage::Iterator xdx = xdy;
103	103	FImage::Iterator ydx = ydy;
104
	104
105	105	const Diff2D left(-1, 0);
106	106	const Diff2D right(1, 0);
107	107	const Diff2D top(0, -1);
108	108	const Diff2D bottom(0, 1);
109
	109
110	110	int x,y;
111	111	if(sa(sx) != background) // first pixel
112	112	{

118	118	{
119	119	da.set(norm(xdx, ydx), rx);
120	120	}
121
122
123		for(x=1, ++xdx.x, ++ydx.x, ++sx.x, ++rx.x;
124		x<w;
	121
	122
	123	for(x=1, ++xdx.x, ++ydx.x, ++sx.x, ++rx.x;
	124	x<w;
125	125	++x, ++xdx.x, ++ydx.x, ++sx.x, ++rx.x) // first row left to right
126	126	{
127	127	if(sa(sx) != background)

137	137	da.set(norm(xdx, ydx), rx); // calculate distance from x and y components
138	138	}
139	139	}
140		for(x=w-2, xdx.x -= 2, ydx.x -= 2, sx.x -= 2, rx.x -= 2;
141		x>=0;
	140	for(x=w-2, xdx.x -= 2, ydx.x -= 2, sx.x -= 2, rx.x -= 2;
	141	x>=0;
142	142	--x, --xdx.x, --ydx.x, --sx.x, --rx.x) // first row right to left
143	143	{
144	144	float d = norm(xdx[right] + 1.0f, ydx[right]);
145
	145
146	146	if(da(rx) < d) continue;
147
	147
148	148	*xdx = xdx[right] + 1.0f;
149	149	*ydx = ydx[right];
150	150	da.set(d, rx);
151	151	}
152		for(y=1, ++xdy.y, ++ydy.y, ++sy.y, ++ry.y;
	152	for(y=1, ++xdy.y, ++ydy.y, ++sy.y, ++ry.y;
153	153	y<h;
154	154	++y, ++xdy.y, ++ydy.y, ++sy.y, ++ry.y) // top to bottom
155	155	{

157	157	rx = ry;
158	158	xdx = xdy;
159	159	ydx = ydy;
160
	160
161	161	if(sa(sx) != background) // first pixel of current row
162	162	{
163	163	*xdx = 0.0f;

170	170	*ydx = ydx[top] + 1.0f;
171	171	da.set(norm(xdx, ydx), rx);
172	172	}
173
174		for(x=1, ++xdx.x, ++ydx.x, ++sx.x, ++rx.x;
175		x<w;
	173
	174	for(x=1, ++xdx.x, ++ydx.x, ++sx.x, ++rx.x;
	175	x<w;
176	176	++x, ++xdx.x, ++ydx.x, ++sx.x, ++rx.x) // current row left to right
177	177	{
178	178	if(sa(sx) != background)

185	185	{
186	186	float d1 = norm(xdx[left] + 1.0f, ydx[left]);
187	187	float d2 = norm(xdx[top], ydx[top] + 1.0f);
188
	188
189	189	if(d1 < d2)
190	190	{
191	191	*xdx = xdx[left] + 1.0f;

200	200	}
201	201	}
202	202	}
203		for(x=w-2, xdx.x -= 2, ydx.x -= 2, sx.x -= 2, rx.x -= 2;
204		x>=0;
	203	for(x=w-2, xdx.x -= 2, ydx.x -= 2, sx.x -= 2, rx.x -= 2;
	204	x>=0;
205	205	--x, --xdx.x, --ydx.x, --sx.x, --rx.x) // current row right to left
206	206	{
207	207	float d1 = norm(xdx[right] + 1.0f, ydx[right]);
208
	208
209	209	if(da(rx) < d1) continue;
210
	210
211	211	*xdx = xdx[right] + 1.0f;
212	212	*ydx = ydx[right];
213	213	da.set(d1, rx);
214	214	}
215	215	}
216		for(y=h-2, xdy.y -= 2, ydy.y -= 2, sy.y -= 2, ry.y -= 2;
	216	for(y=h-2, xdy.y -= 2, ydy.y -= 2, sy.y -= 2, ry.y -= 2;
217	217	y>=0;
218	218	--y, --xdy.y, --ydy.y, --sy.y, --ry.y) // bottom to top
219	219	{

221	221	rx = ry;
222	222	xdx = xdy;
223	223	ydx = ydy;
224
	224
225	225	float d = norm(xdx[bottom], ydx[bottom] + 1.0f);
226	226	if(d < da(rx)) // first pixel of current row
227		{
	227	{
228	228	*xdx = xdx[bottom];
229	229	*ydx = ydx[bottom] + 1.0f;
230	230	da.set(d, rx);
231	231	}
232
233		for(x=1, ++xdx.x, ++ydx.x, ++sx.x, ++rx.x;
	232
	233	for(x=1, ++xdx.x, ++ydx.x, ++sx.x, ++rx.x;
234	234	x<w;
235	235	++x, ++xdx.x, ++ydx.x, ++sx.x, ++rx.x) // current row left to right
236	236	{
237	237	float d1 = norm(xdx[left] + 1.0f, ydx[left]);
238	238	float d2 = norm(xdx[bottom], ydx[bottom] + 1.0f);
239
	239
240	240	if(d1 < d2)
241	241	{
242	242	if(da(rx) < d1) continue;

252	252	da.set(d2, rx);
253	253	}
254	254	}
255		for(x=w-2, xdx.x -= 2, ydx.x -= 2, sx.x -= 2, rx.x -= 2;
256		x>=0;
	255	for(x=w-2, xdx.x -= 2, ydx.x -= 2, sx.x -= 2, rx.x -= 2;
	256	x>=0;
257	257	--x, --xdx.x, --ydx.x, --sx.x, --rx.x) // current row right to left
258	258	{
259	259	float d1 = norm(xdx[right] + 1.0f, ydx[right]);

273	273	/********************************************************/
274	274
275	275	/** \addtogroup DistanceTransform Distance Transform
276		Perform a distance transform using either the Euclidean, Manhattan,
277		or chessboard metrics.
278
279		See also: \ref MultiArrayDistanceTransform "multi-dimensional distance transforms"
280	276	*/
281	277	//@{
282	278
283		/** For all background pixels, calculate the distance to
284		the nearest object or contour. The label of the pixels to be considered
	279	/** For all background pixels, calculate the distance to
	280	the nearest object or contour. The label of the pixels to be considered
285	281	background in the source image is passed in the parameter 'background'.
286		Source pixels with other labels will be considered objects. In the
287		destination image, all pixels corresponding to background will be assigned
	282	Source pixels with other labels will be considered objects. In the
	283	destination image, all pixels corresponding to background will be assigned
288	284	the their distance value, all pixels corresponding to objects will be
289	285	assigned 0.
290
	286
291	287	The parameter 'norm' gives the distance norm to be used:
292
	288
293	289	<ul>
294	290
295	291	<li> norm == 0: use chessboard distance (L-infinity norm)
296	292	<li> norm == 1: use Manhattan distance (L1 norm)
297	293	<li> norm == 2: use Euclidean distance (L2 norm)
298
	294
299	295	</ul>
300
	296
301	297	If you use the L2 norm, the destination pixels must be real valued to give
302	298	correct results.
303
	299
304	300	<b> Declarations:</b>
305
	301
306	302	pass 2D array views:
307	303	\code
308	304	namespace vigra {

315	311	ValueType background, int norm);
316	312	}
317	313	\endcode
318
	314
319	315	\deprecatedAPI{distanceTransform}
320	316	pass \ref ImageIterators and \ref DataAccessors :
321	317	\code

323	319	template <class SrcImageIterator, class SrcAccessor,
324	320	class DestImageIterator, class DestAccessor,
325	321	class ValueType>
326		void distanceTransform(SrcImageIterator src_upperleft,
	322	void distanceTransform(SrcImageIterator src_upperleft,
327	323	SrcImageIterator src_lowerright, SrcAccessor sa,
328	324	DestImageIterator dest_upperleft, DestAccessor da,
329	325	ValueType background, int norm);

341	337	}
342	338	\endcode
343	339	\deprecatedEnd
344
	340
345	341	<b> Usage:</b>
346
	342
347	343	<b>\#include</b> \<vigra/distancetransform.hxx\><br>
348	344	Namespace: vigra
349	345

354	350
355	351	// detect edges in src image (edges will be marked 1, background 0)
356	352	differenceOfExponentialEdgeImage(src, edges, 0.8, 4.0);
357
	353
358	354	// find distance of all pixels from nearest edge
359	355	distanceTransform(edges, distance, 0, 2);
360	356	// ^ background label ^ norm (Euclidean)

362	358
363	359	\deprecatedUsage{distanceTransform}
364	360	\code
365
	361
366	362	vigra::BImage src(w,h), edges(w,h);
367	363	vigra::FImage distance(w, h);
368	364

371	367	...
372	368
373	369	// detect edges in src image (edges will be marked 1, background 0)
374		vigra::differenceOfExponentialEdgeImage(srcImageRange(src), destImage(edges),
	370	vigra::differenceOfExponentialEdgeImage(srcImageRange(src), destImage(edges),
375	371	0.8, 4.0);
376
	372
377	373	// find distance of all pixels from nearest edge
378	374	vigra::distanceTransform(srcImageRange(edges), destImage(distance),
379	375	0, 2);

381	377	\endcode
382	378	<b> Required Interface:</b>
383	379	\code
384
	380
385	381	SrcImageIterator src_upperleft, src_lowerright;
386	382	DestImageIterator dest_upperleft;
387
	383
388	384	SrcAccessor sa;
389	385	DestAccessor da;
390
	386
391	387	ValueType background;
392	388	float distance;
393
	389
394	390	sa(src_upperleft) != background;
395	391	da(dest_upperleft) < distance;
396	392	da.set(distance, dest_upperleft);
397
	393
398	394	\endcode
399	395	\deprecatedEnd
400	396	*/

404	400	class DestImageIterator, class DestAccessor,
405	401	class ValueType>
406	402	inline void
407		distanceTransform(SrcImageIterator src_upperleft,
	403	distanceTransform(SrcImageIterator src_upperleft,
408	404	SrcImageIterator src_lowerright, SrcAccessor sa,
409	405	DestImageIterator dest_upperleft, DestAccessor da,
410	406	ValueType background, int norm)

+35

-35

include/vigra/eccentricitytransform.hxx less more

52	52	{
53	53
54	54
55		template <class Graph, class WeightType,
	55	template <class Graph, class WeightType,
56	56	class EdgeMap, class Shape>
57		TinyVector<MultiArrayIndex, Shape::static_size>
	57	TinyVector<MultiArrayIndex, Shape::static_size>
58	58	eccentricityCentersOneRegionImpl(ShortestPathDijkstra<Graph, WeightType> & pathFinder,
59	59	const EdgeMap & weights, WeightType maxWeight,
60	60	Shape anchor, Shape const & start, Shape const & stop)

66	66	anchor = pathFinder.target();
67	67	// FIXME: implement early stopping when source and target don't change anymore
68	68	}
69
	69
70	70	Polygon<TinyVector<float, Shape::static_size> > path;
71	71	path.push_back_unsafe(anchor);
72	72	while(pathFinder.predecessors()[path.back()] != path.back())

76	76
77	77	template <unsigned int N, class T, class S, class Graph,
78	78	class ACCUMULATOR, class DIJKSTRA, class Array>
79		void
	79	void
80	80	eccentricityCentersImpl(const MultiArrayView<N, T, S> & src,
81	81	Graph const & g,
82	82	ACCUMULATOR const & r,

88	88	typedef typename Graph::Node Node;
89	89	typedef typename Graph::EdgeIt EdgeIt;
90	90	typedef float WeightType;
91
	91
92	92	typename Graph::template EdgeMap<WeightType> weights(g);
93	93	WeightType maxWeight = 0.0,
94	94	minWeight = N;
95	95	{
96	96	AccumulatorChainArray<CoupledArrays<N, WeightType, T>,
97	97	Select< DataArg<1>, LabelArg<2>, Maximum> > a;
98
	98
99	99	MultiArray<N, WeightType> distances(src.shape());
100	100	boundaryMultiDistance(src, distances, true);
101	101	extractFeatures(distances, src, a);

109	109	}
110	110	else
111	111	{
112		WeightType weight = norm(u - v) *
	112	WeightType weight = norm(u - v) *
113	113	(get<Maximum>(a, label) + minWeight - 0.5*(distances[u] + distances[v]));
114	114	weights[*edge] = weight;
115	115	maxWeight = std::max(weight, maxWeight);

117	117	}
118	118	}
119	119	maxWeight *= src.size();
120
	120
121	121	T maxLabel = r.maxRegionLabel();
122	122	centers.resize(maxLabel+1);
123	123

125	125	{
126	126	if(get<Count>(r, i) == 0)
127	127	continue;
128		centers[i] = eccentricityCentersOneRegionImpl(pathFinder, weights, maxWeight,
129		get<RegionAnchor>(r, i),
	128	centers[i] = eccentricityCentersOneRegionImpl(pathFinder, weights, maxWeight,
	129	get<RegionAnchor>(r, i),
130	130	get<Coord<Minimum> >(r, i),
131	131	get<Coord<Maximum> >(r, i) + Shape(1));
132	132	}
133	133	}
134	134
135		/** \addtogroup MultiArrayDistanceTransform
	135	/** \addtogroup DistanceTransform
136	136	*/
137	137	//@{
138	138
139	139	/** \brief Find the (approximate) eccentricity center in each region of a labeled image.
140
	140
141	141	<b> Declarations:</b>
142	142
143	143	pass arbitrary-dimensional array views:
144	144	\code
145	145	namespace vigra {
146	146	template <unsigned int N, class T, class S, class Array>
147		void
	147	void
148	148	eccentricityCenters(MultiArrayView<N, T, S> const & src,
149	149	Array & centers);
150	150	}
151	151	\endcode
152
	152
153	153	\param[in] src : labeled array
154		\param[out] centers : list of eccentricity centers (required interface:
155		<tt>centers[k] = TinyVector<int, N>()</tt> must be supported)
156
	154	\param[out] centers : list of eccentricity centers (required interface:
	155	<tt>centers[k] = TinyVector<int, N>()</tt> must be supported)
	156
157	157	<b> Usage:</b>
158	158
159	159	<b>\#include</b> \<vigra/eccentricitytransform.hxx\><br/>

169	169	\endcode
170	170	*/
171	171	template <unsigned int N, class T, class S, class Array>
172		void
	172	void
173	173	eccentricityCenters(const MultiArrayView<N, T, S> & src,
174	174	Array & centers)
175	175	{
176	176	using namespace acc;
177	177	typedef GridGraph<N> Graph;
178	178	typedef float WeightType;
179
	179
180	180	Graph g(src.shape(), IndirectNeighborhood);
181	181	ShortestPathDijkstra<Graph, WeightType> pathFinder(g);
182	182

184	184	Select< DataArg<1>, LabelArg<1>,
185	185	Count, BoundingBox, RegionAnchor> > a;
186	186	extractFeatures(src, a);
187
	187
188	188	eccentricityCentersImpl(src, g, a, pathFinder, centers);
189	189	}
190	190
191	191	/** \brief Computes the (approximate) eccentricity transform on each region of a labeled image.
192
	192
193	193	<b> Declarations:</b>
194	194
195	195	pass arbitrary-dimensional array views:

197	197	namespace vigra {
198	198	// compute only the accentricity transform
199	199	template <unsigned int N, class T, class S>
200		void
	200	void
201	201	eccentricityTransformOnLabels(MultiArrayView<N, T> const & src,
202	202	MultiArrayView<N, S> dest);
203
	203
204	204	// also return the eccentricity center of each region
205	205	template <unsigned int N, class T, class S, class Array>
206		void
	206	void
207	207	eccentricityTransformOnLabels(MultiArrayView<N, T> const & src,
208	208	MultiArrayView<N, S> dest,
209	209	Array & centers);
210	210	}
211	211	\endcode
212
	212
213	213	\param[in] src : labeled array
214	214	\param[out] dest : eccentricity transform of src
215		\param[out] centers : (optional) list of eccentricity centers (required interface:
216		<tt>centers[k] = TinyVector<int, N>()</tt> must be supported)
217
	215	\param[out] centers : (optional) list of eccentricity centers (required interface:
	216	<tt>centers[k] = TinyVector<int, N>()</tt> must be supported)
	217
218	218	<b> Usage:</b>
219	219
220	220	<b>\#include</b> \<vigra/eccentricitytransform.hxx\><br/>

231	231	\endcode
232	232	*/
233	233	template <unsigned int N, class T, class S, class Array>
234		void
	234	void
235	235	eccentricityTransformOnLabels(MultiArrayView<N, T> const & src,
236	236	MultiArrayView<N, S> dest,
237	237	Array & centers)

242	242	typedef typename Graph::Node Node;
243	243	typedef typename Graph::EdgeIt EdgeIt;
244	244	typedef float WeightType;
245
246		vigra_precondition(src.shape() == dest.shape(),
	245
	246	vigra_precondition(src.shape() == dest.shape(),
247	247	"eccentricityTransformOnLabels(): Shape mismatch between src and dest.");
248
	248
249	249	Graph g(src.shape(), IndirectNeighborhood);
250	250	ShortestPathDijkstra<Graph, WeightType> pathFinder(g);
251	251
252		using namespace acc;
	252	using namespace acc;
253	253	AccumulatorChainArray<CoupledArrays<N, T>,
254	254	Select< DataArg<1>, LabelArg<1>,
255	255	Count, BoundingBox, RegionAnchor> > a;
256	256	extractFeatures(src, a);
257
	257
258	258	eccentricityCentersImpl(src, g, a, pathFinder, centers);
259	259
260	260	typename Graph::template EdgeMap<WeightType> weights(g);

276	276	}
277	277
278	278	template <unsigned int N, class T, class S>
279		inline void
	279	inline void
280	280	eccentricityTransformOnLabels(MultiArrayView<N, T> const & src,
281	281	MultiArrayView<N, S> dest)
282	282	{

+6

-61

include/vigra/error.hxx less more

203	203	{}
204	204	};
205	205
206		//#ifndef NDEBUG
207
208		#if 1
209
210	206	inline
211	207	void throw_invariant_error(bool predicate, char const * message, char const * file, int line)
212	208	{

267	263
268	264	#define vigra_precondition(PREDICATE, MESSAGE) vigra::throw_precondition_error((PREDICATE), MESSAGE, __FILE__, __LINE__)
269	265
270		#define vigra_assert(PREDICATE, MESSAGE) vigra_precondition(PREDICATE, MESSAGE)
	266	// Compile assertions only in debug mode
	267	#ifdef NDEBUG
	268	#define vigra_assert(PREDICATE, MESSAGE)
	269	#else
	270	#define vigra_assert(PREDICATE, MESSAGE) vigra_precondition(PREDICATE, MESSAGE)
	271	#endif
271	272
272	273	#define vigra_postcondition(PREDICATE, MESSAGE) vigra::throw_postcondition_error((PREDICATE), MESSAGE, __FILE__, __LINE__)
273	274

275	276
276	277	#define vigra_fail(MESSAGE) vigra::throw_runtime_error(MESSAGE, __FILE__, __LINE__)
277	278
278		#else // NDEBUG
279
280		inline
281		void throw_invariant_error(bool predicate, char const * message)
282		{
283		if(!predicate)
284		throw vigra::InvariantViolation(message);
285		}
286
287		inline
288		void throw_precondition_error(bool predicate, char const * message)
289		{
290		if(!predicate)
291		throw vigra::PreconditionViolation(message);
292		}
293
294		inline
295		void throw_postcondition_error(bool predicate, char const * message)
296		{
297		if(!predicate)
298		throw vigra::PostconditionViolation(message);
299		}
300
301		inline
302		void throw_invariant_error(bool predicate, std::string message)
303		{
304		if(!predicate)
305		throw vigra::InvariantViolation(message.c_str());
306		}
307
308		inline
309		void throw_precondition_error(bool predicate, std::string message)
310		{
311		if(!predicate)
312		throw vigra::PreconditionViolation(message.c_str());
313		}
314
315		inline
316		void throw_postcondition_error(bool predicate, std::string message)
317		{
318		if(!predicate)
319		throw vigra::PostconditionViolation(message.c_str());
320		}
321
322		#define vigra_precondition(PREDICATE, MESSAGE) vigra::throw_precondition_error((PREDICATE), MESSAGE)
323
324		#define vigra_assert(PREDICATE, MESSAGE)
325
326		#define vigra_postcondition(PREDICATE, MESSAGE) vigra::throw_postcondition_error((PREDICATE), MESSAGE)
327
328		#define vigra_invariant(PREDICATE, MESSAGE) vigra::throw_invariant_error((PREDICATE), MESSAGE)
329
330		#define vigra_fail(MESSAGE) throw std::runtime_error(MESSAGE)
331
332		#endif // NDEBUG
333
334	279	} // namespace vigra
335	280
336	281	#endif // VIGRA_ERROR_HXX

+6

-6

include/vigra/fftw3.hxx less more

692	692	{}
693	693
694	694	template<class Other>
695		FFTWAllocator(const FFTWAllocator<Other>& right) throw()
	695	FFTWAllocator(const FFTWAllocator<Other>& /right/) throw()
696	696	{}
697	697
698	698	template<class Other>
699		FFTWAllocator& operator=(const FFTWAllocator<Other>& right)
	699	FFTWAllocator& operator=(const FFTWAllocator<Other>& /right/)
700	700	{
701	701	return *this;
702	702	}

706	706	return (pointer)fftw_malloc(count * sizeof(Ty));
707	707	}
708	708
709		void deallocate(pointer ptr, size_type count)
	709	void deallocate(pointer ptr, size_type /count/)
710	710	{
711	711	fftw_free(ptr);
712	712	}

760	760	{}
761	761
762	762	template<class Other>
763		allocator(const allocator<Other>& right) throw()
	763	allocator(const allocator<Other>& /right/) throw()
764	764	{}
765	765
766	766	template<class Other>
767		allocator& operator=(const allocator<Other>& right)
	767	allocator& operator=(const allocator<Other>& /right/)
768	768	{
769	769	return *this;
770	770	}

2399	2399	void applyFourierFilterFamilyImpl(
2400	2400	FFTWComplexImage::const_traverser srcUpperLeft,
2401	2401	FFTWComplexImage::const_traverser srcLowerRight,
2402		FFTWComplexImage::ConstAccessor sa,
	2402	FFTWComplexImage::ConstAccessor /sa/,
2403	2403	const ImageArray<FilterType> &filters,
2404	2404	ImageArray<DestImage> &results)
2405	2405	{

+158

-0

include/vigra/filter_iterator.hxx less more

	0	/************************************************************************/
	1	/* */
	2	/* Copyright 2014-2015 by Ullrich Koethe and Philip Schill */
	3	/* */
	4	/* This file is part of the VIGRA computer vision library. */
	5	/* The VIGRA Website is */
	6	/* http://hci.iwr.uni-heidelberg.de/vigra/ */
	7	/* Please direct questions, bug reports, and contributions to */
	8	/* ullrich.koethe@iwr.uni-heidelberg.de or */
	9	/* vigra@informatik.uni-hamburg.de */
	10	/* */
	11	/* Permission is hereby granted, free of charge, to any person */
	12	/* obtaining a copy of this software and associated documentation */
	13	/* files (the "Software"), to deal in the Software without */
	14	/* restriction, including without limitation the rights to use, */
	15	/* copy, modify, merge, publish, distribute, sublicense, and/or */
	16	/* sell copies of the Software, and to permit persons to whom the */
	17	/* Software is furnished to do so, subject to the following */
	18	/* conditions: */
	19	/* */
	20	/* The above copyright notice and this permission notice shall be */
	21	/* included in all copies or substantial portions of the */
	22	/* Software. */
	23	/* */
	24	/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND */
	25	/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES */
	26	/* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND */
	27	/* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT */
	28	/* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, */
	29	/* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING */
	30	/* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR */
	31	/* OTHER DEALINGS IN THE SOFTWARE. */
	32	/* */
	33	/************************************************************************/
	34	#ifndef VIGRA_FILTER_ITERATOR_HXX
	35	#define VIGRA_FILTER_ITERATOR_HXX
	36
	37	#include <type_traits>
	38	#include <iterator>
	39
	40	#include "iteratorfacade.hxx"
	41
	42	namespace vigra
	43	{
	44
	45	namespace detail
	46	{
	47	template <typename T>
	48	struct is_const_pointer
	49	{
	50	static bool const value = false;
	51	};
	52
	53	template <typename T>
	54	struct is_const_pointer<T const *>
	55	{
	56	static bool const value = true;
	57	};
	58
	59	template <typename ITER>
	60	struct is_const_iterator
	61	{
	62	typedef typename std::iterator_traits<ITER>::pointer pointer;
	63	static bool const value = is_const_pointer<pointer>::value;
	64	};
	65	}
	66
	67
	68	/********************************************************/
	69	/* */
	70	/* FilterIterator */
	71	/* */
	72	/********************************************************/
	73
	74	/**
	75	* @brief This iterator creates a view of another iterator and skips elements that
	76	* do not fulfill a given predicate.
	77	*
	78	* The iterator is compatible to an STL forward iterator as defined in the C++ standard.
	79	*
	80	* @note The equality comparison only checks, whether the iterators point to the same place. The predicate is not checked.
	81	*/
	82	template <typename PREDICATE, typename ITER>
	83	class FilterIterator
	84	: public ForwardIteratorFacade<FilterIterator<PREDICATE, ITER>,
	85	typename std::iterator_traits<ITER>::value_type,
	86	detail::is_const_iterator<ITER>::value>
	87	{
	88	public:
	89
	90	typedef PREDICATE Predicate;
	91	typedef ITER Iter;
	92	typedef typename std::iterator_traits<Iter>::value_type IterValueType;
	93	typedef FilterIterator<Predicate, Iter> SelfType;
	94	typedef ForwardIteratorFacade<SelfType,
	95	IterValueType,
	96	detail::is_const_iterator<ITER>::value> Parent;
	97	typedef typename Parent::value_type value_type;
	98	typedef typename Parent::reference reference;
	99	typedef reference const const_reference;
	100
	101	/// Construct a filter iterator with the given predicate for
	102	/// a base iterator range \a iter to \a end.
	103	FilterIterator(Predicate pred, Iter iter, Iter end = Iter())
	104	:
	105	pred_(pred),
	106	iter_(iter),
	107	end_(end)
	108	{
	109	satisfy_predicate();
	110	}
	111
	112	private:
	113
	114	void satisfy_predicate()
	115	{
	116	while (iter_ != end_ && !pred_(*iter_))
	117	++iter_;
	118	}
	119
	120	void increment()
	121	{
	122	++iter_;
	123	satisfy_predicate();
	124	}
	125
	126	reference dereference() const
	127	{
	128	return *iter_;
	129	}
	130
	131	bool equal(FilterIterator const & other) const
	132	{
	133	return iter_ == other.iter_;
	134	}
	135
	136	Predicate pred_;
	137	Iter iter_;
	138	Iter end_;
	139
	140	friend class vigra::IteratorFacadeCoreAccess;
	141
	142	};
	143
	144	template <typename PREDICATE, typename ITER>
	145	FilterIterator<PREDICATE, ITER>
	146	make_filter_iterator(PREDICATE pred, ITER iter, ITER end = ITER())
	147	{
	148	return FilterIterator<PREDICATE, ITER>(pred, iter, end);
	149	}
	150
	151
	152
	153	} // namespace vigra
	154
	155
	156
	157	#endif

+9

-0

include/vigra/functorexpression.hxx less more

1706	1706
1707	1707	/************************************************************/
1708	1708
	1709	#ifdef __GNUC__
	1710	#pragma GCC diagnostic push
	1711	#pragma GCC diagnostic ignored "-Wsign-compare"
	1712	#endif
	1713
1709	1714	MAKE_FUNCTOR_BINARY_OPERATOR_BOOL(equals, ==)
1710	1715	MAKE_FUNCTOR_BINARY_OPERATOR_BOOL(differs, !=)
1711	1716	MAKE_FUNCTOR_BINARY_OPERATOR_BOOL(less, <)

1715	1720	MAKE_FUNCTOR_BINARY_OPERATOR_BOOL(and, &&)
1716	1721	MAKE_FUNCTOR_BINARY_OPERATOR_BOOL(or, \|\|)
1717	1722
	1723	#ifdef __GNUC__
	1724	#pragma GCC diagnostic pop
	1725	#endif
	1726
1718	1727	#undef MAKE_FUNCTOR_BINARY_OPERATOR_BOOL
1719	1728
1720	1729	/************************************************************/

+9

-10

include/vigra/graph_algorithms.hxx less more

214	214
215	215	template<unsigned int DIM, class DTAG, class AFF_EDGES>
216	216	size_t affiliatedEdgesSerializationSize(
217		const GridGraph<DIM,DTAG> & gridGraph,
	217	const GridGraph<DIM,DTAG> &,
218	218	const AdjacencyListGraph & rag,
219	219	const AFF_EDGES & affEdges
220	220	){

233	233
234	234	template<class OUT_ITER, unsigned int DIM, class DTAG, class AFF_EDGES>
235	235	void serializeAffiliatedEdges(
236		const GridGraph<DIM,DTAG> & gridGraph,
	236	const GridGraph<DIM,DTAG> &,
237	237	const AdjacencyListGraph & rag,
238	238	const AFF_EDGES & affEdges,
239	239	OUT_ITER outIter

260	260
261	261	template<class IN_ITER, unsigned int DIM, class DTAG, class AFF_EDGES>
262	262	void deserializeAffiliatedEdges(
263		const GridGraph<DIM,DTAG> & gridGraph,
	263	const GridGraph<DIM,DTAG> &,
264	264	const AdjacencyListGraph & rag,
265	265	AFF_EDGES & affEdges,
266	266	IN_ITER begin,
267		IN_ITER end
	267	IN_ITER
268	268	){
269	269
270	270	typedef typename AdjacencyListGraph::EdgeIt EdgeIt;

723	723	for(NodeIt n(graph);n!=lemon::INVALID;++n){
724	724	Node node(*n);
725	725	if(seeds[node]==0){
726		int label = 0 ;
727	726	Node pred=predMap[node];
728	727	while(seeds[pred]==0){
729	728	pred=predMap[pred];

736	735	namespace detail_watersheds_segmentation{
737	736
738	737	struct RawPriorityFunctor{
739		template<class L, class T>
740		T operator()(const L label,const T priority)const{
	738	template<class LabelType, class T>
	739	T operator()(const LabelType /label/,const T priority)const{
741	740	return priority;
742	741	}
743	742	};

980	979	nodeSizeAcc[newRepNode] = sizeRu+sizeRv;
981	980	}
982	981	}
983		if(nodeNum==nodeNumStopCond){
	982	if(nodeNumStopCond >= 0 && nodeNum==static_cast<size_t>(nodeNumStopCond)){
984	983	break;
985	984	}
986	985	}

988	987	break;
989	988	}
990	989	else{
991		if(nodeNum>nodeNumStopCond){
	990	if(nodeNumStopCond >= 0 && nodeNum>static_cast<size_t>(nodeNumStopCond)){
992	991	k *= 1.2f;
993	992	}
994	993	else{

1201	1200	const BASE_GRAPH_RAG_LABELS & baseGraphRagLabels,
1202	1201	const BASE_GRAPH_GT & baseGraphGt,
1203	1202	RAG_GT & ragGt,
1204		RAG_GT_QT & ragGtQt
	1203	RAG_GT_QT &
1205	1204	){
1206	1205	typedef typename BASE_GRAPH::Node BaseGraphNode;
1207	1206	typedef typename BASE_GRAPH::NodeIt BaseGraphNodeIt;

+12

-12

include/vigra/graph_generalization.hxx less more

50	50
51	51	template<class MAP>
52	52	struct GraphMapTypeTraits{
53		typedef typename MAP::Value Value;
54		typedef typename MAP::Reference Reference;
55		typedef typename MAP::ConstReference ConstReference;
	53	typedef typename MAP::value_type Value;
	54	typedef typename MAP::reference Reference;
	55	typedef typename MAP::const_reference ConstReference;
56	56	};
57	57
58	58	// generalizes the iterator begin end accessed

79	79	}
80	80
81	81
82		static NodeIt nodesEnd(const Graph & g){ return NodeIt(lemon::INVALID);}
83		static EdgeIt edgesEnd(const Graph & g){ return EdgeIt(lemon::INVALID);}
84		static ArcIt arcsEnd( const Graph & g){ return ArcIt( lemon::INVALID);}
85		static OutArcIt outArcEnd(const Graph & g,const Node & node){
	82	static NodeIt nodesEnd(const Graph &){ return NodeIt(lemon::INVALID);}
	83	static EdgeIt edgesEnd(const Graph &){ return EdgeIt(lemon::INVALID);}
	84	static ArcIt arcsEnd( const Graph &){ return ArcIt( lemon::INVALID);}
	85	static OutArcIt outArcEnd(const Graph &,const Node &){
86	86	return OutArcIt(lemon::INVALID);
87	87	}
88		static IncEdgeIt incEdgeEnd(const Graph & g,const Node & node){
	88	static IncEdgeIt incEdgeEnd(const Graph &,const Node &){
89	89	return IncEdgeIt(lemon::INVALID);
90	90	}
91	91	};

119	119	static OutArcIt outArcEnd(const Graph & g,const Node & node){
120	120	return g.get_out_edge_end_iterator(node);
121	121	}
122		static IncEdgeIt incEdgeEnd(const Graph & g,const Node & node){
	122	static IncEdgeIt incEdgeEnd(const Graph &,const Node &){
123	123	return IncEdgeIt(lemon::INVALID);
124	124	}
125	125	};

230	230	typedef typename IntrinsicGraphShape<Graph>::IntrinsicArcMapShape IntrinsicArcMapShape;
231	231
232	232
233		static Node intrinsicNodeCoordinate(const Graph & g,const Node & node){
	233	static Node intrinsicNodeCoordinate(const Graph &,const Node & node){
234	234	return node;
235	235	}
236		static Edge intrinsicEdgeCoordinate(const Graph & g,const Edge & edge){
	236	static Edge intrinsicEdgeCoordinate(const Graph &,const Edge & edge){
237	237	return edge;
238	238	}
239		static Arc intrinsicArcCoordinate (const Graph & g,const Arc & arc){
	239	static Arc intrinsicArcCoordinate (const Graph &,const Arc & arc){
240	240	return arc;
241	241	}
242	242

+24

-24

include/vigra/graph_item_impl.hxx less more

42	42	typedef typename GRAPH::NodeStorage::AdjacencyElement AdjacencyElement;
43	43
44	44	static bool valid(
45		const GRAPH & g,
46		const AdjacencyElement & adj,
47		const typename GRAPH::index_type ownNodeId
	45	const GRAPH &,
	46	const AdjacencyElement &,
	47	const typename GRAPH::index_type /ownNodeId/
48	48	){
49	49	return true;
50	50	}

53	53	static ResultType transform(
54	54	const GRAPH & g,
55	55	const AdjacencyElement & adj,
56		const typename GRAPH::index_type ownNodeId
	56	const typename GRAPH::index_type /ownNodeId/
57	57	){
58	58	return g.nodeFromId(adj.nodeId());
59	59	}

67	67	typedef typename GRAPH::NodeStorage::AdjacencyElement AdjacencyElement;
68	68
69	69	static bool valid(
70		const GRAPH & g,
71		const AdjacencyElement & adj,
72		const typename GRAPH::index_type ownNodeId
	70	const GRAPH &,
	71	const AdjacencyElement &,
	72	const typename GRAPH::index_type /ownNodeId/
73	73	){
74	74	return true;
75	75	}

77	77	static ResultType transform(
78	78	const GRAPH & g,
79	79	const AdjacencyElement & adj,
80		const typename GRAPH::index_type ownNodeId
	80	const typename GRAPH::index_type /ownNodeId/
81	81	){
82	82	return g.edgeFromId(adj.edgeId());
83	83	}

91	91	typedef typename GRAPH::NodeStorage::AdjacencyElement AdjacencyElement;
92	92
93	93	static bool valid(
94		const GRAPH & g,
	94	const GRAPH &,
95	95	const AdjacencyElement & adj,
96	96	const typename GRAPH::index_type ownNodeId
97	97	){

101	101	static ResultType transform(
102	102	const GRAPH & g,
103	103	const AdjacencyElement & adj,
104		const typename GRAPH::index_type ownNodeId
	104	const typename GRAPH::index_type /ownNodeId/
105	105	){
106	106	return g.edgeFromId(adj.edgeId());
107	107	}

114	114	typedef typename GRAPH::NodeStorage::AdjacencyElement AdjacencyElement;
115	115
116	116	static bool valid(
117		const GRAPH & g,
	117	const GRAPH &,
118	118	const AdjacencyElement & adj,
119	119	const typename GRAPH::index_type ownNodeId
120	120	){

136	136	typedef typename GRAPH::NodeStorage::AdjacencyElement AdjacencyElement;
137	137
138	138	static bool valid(
139		const GRAPH & g,
140		const AdjacencyElement & adj,
141		const typename GRAPH::index_type ownNodeId
	139	const GRAPH &,
	140	const AdjacencyElement &,
	141	const typename GRAPH::index_type /ownNodeId/
142	142	){
143	143	return true;
144	144	}

161	161	typedef typename GRAPH::NodeStorage::AdjacencyElement AdjacencyElement;
162	162
163	163	static bool valid(
164		const GRAPH & g,
165		const AdjacencyElement & adj,
166		const typename GRAPH::index_type ownNodeId
	164	const GRAPH &,
	165	const AdjacencyElement &,
	166	const typename GRAPH::index_type /ownNodeId/
167	167	){
168	168	return true;
169	169	}
170	170	ResultType static transform(
171	171	const GRAPH & g,
172	172	const AdjacencyElement & adj,
173		const typename GRAPH::index_type ownNodeId
	173	const typename GRAPH::index_type /ownNodeId/
174	174	){
175	175	return g.direct(g.edgeFromId(adj.edgeId()) ,g.nodeFromId(adj.nodeId()));
176	176	}

195	195	//typedef typename GraphItemHelper<GRAPH,typename FILTER::ResultType> ResultItem
196	196
197	197	// default constructor
198		GenericIncEdgeIt(const lemon::Invalid & invalid = lemon::INVALID)
	198	GenericIncEdgeIt(const lemon::Invalid & /invalid/ = lemon::INVALID)
199	199	: nodeImpl_(NULL),
200	200	graph_(NULL),
201	201	ownNodeId_(-1),

332	332	typedef typename SetType::const_iterator AdjIt;
333	333	public:
334	334
335		GenericNodeImpl(const lemon::Invalid iv=lemon::INVALID)
	335	GenericNodeImpl(const lemon::Invalid /iv/=lemon::INVALID)
336	336	: id_(-1){
337	337	}
338	338

405	405	public:
406	406	typedef INDEX_TYPE index_type;
407	407
408		GenericEdgeImpl(const lemon::Invalid iv=lemon::INVALID)
	408	GenericEdgeImpl(const lemon::Invalid /iv/=lemon::INVALID)
409	409	: vigra::TinyVector<INDEX_TYPE,3>(-1){
410	410	}
411	411

429	429	public:
430	430	typedef INDEX_TYPE index_type;
431	431
432		GenericArc(const lemon::Invalid & iv = lemon::INVALID)
	432	GenericArc(const lemon::Invalid & /iv/ = lemon::INVALID)
433	433	: id_(-1),
434	434	edgeId_(-1){
435	435

477	477	public:
478	478	typedef INDEX_TYPE index_type;
479	479
480		GenericEdge(const lemon::Invalid & iv = lemon::INVALID)
	480	GenericEdge(const lemon::Invalid & /iv/ = lemon::INVALID)
481	481	: id_(-1){
482	482
483	483	}

523	523	public:
524	524	typedef INDEX_TYPE index_type;
525	525
526		GenericNode(const lemon::Invalid & iv = lemon::INVALID)
	526	GenericNode(const lemon::Invalid & /iv/ = lemon::INVALID)
527	527	: id_(-1){
528	528
529	529	}

+2

-2

include/vigra/graph_maps.hxx less more

119	119	: DenseReferenceMapType(ItemHelper::itemNum(g)==0 ? 0: ItemHelper::maxItemId(g) ){
120	120
121	121	}
122		DenseGraphItemReferenceMap(const Graph & g,typename DenseReferenceMapType::ConstReference value)
	122	DenseGraphItemReferenceMap(const Graph & g,typename DenseReferenceMapType::ConstReference)
123	123	: DenseReferenceMapType(ItemHelper::itemNum(g)==0 ? 0: ItemHelper::maxItemId(g)){
124	124
125	125	}

251	251	ZeroNodeMap()
252	252	{}
253	253
254		value_type operator[](const Key & key) const
	254	value_type operator[](const Key &) const
255	255	{
256	256	return value_type();
257	257	}

+516

-1

include/vigra/graphs.hxx less more

0	0	/************************************************************************/
1	1	/* */
2		/* Copyright 2011-2012 Stefan Schmidt and Ullrich Koethe */
	2	/* Copyright 2011-2015 by Stefan Schmidt, Philip Schill and */
	3	/* Ullrich Koethe */
3	4	/* */
4	5	/* This file is part of the VIGRA computer vision library. */
5	6	/* The VIGRA Website is */

41	42	#ifndef VIGRA_GRAPH_HXX
42	43	#define VIGRA_GRAPH_HXX
43	44
	45	#include <stdexcept>
	46	#include <vector>
	47	#include <map>
	48
44	49	#include "metaprogramming.hxx"
45	50	#include "tinyvector.hxx"
	51	#include "filter_iterator.hxx"
46	52
47	53	#ifdef WITH_BOOST_GRAPH
48	54

297	303
298	304	}} // namespace vigra::lemon_graph
299	305
	306
	307
	308	namespace vigra {
	309	namespace detail {
	310
	311	template <typename INDEXTYPE>
	312	class NodeDescriptor
	313	{
	314	public:
	315	typedef INDEXTYPE index_type;
	316	NodeDescriptor(lemon::Invalid = lemon::INVALID)
	317	: id_(-1)
	318	{}
	319	explicit NodeDescriptor(index_type const & id)
	320	: id_(id)
	321	{}
	322	bool operator!=(NodeDescriptor const & other) const
	323	{
	324	return id_ != other.id_;
	325	}
	326	bool operator==(NodeDescriptor const & other) const
	327	{
	328	return id_ == other.id_;
	329	}
	330	bool operator<(NodeDescriptor const & other) const
	331	{
	332	return id_ < other.id_;
	333	}
	334	index_type id() const
	335	{
	336	return id_;
	337	}
	338	protected:
	339	index_type id_;
	340	};
	341
	342	template <typename INDEXTYPE>
	343	std::ostream & operator << (std::ostream & os, NodeDescriptor<INDEXTYPE> const & item)
	344	{
	345	return os << item.id();
	346	}
	347
	348	template <typename INDEXTYPE>
	349	class ArcDescriptor
	350	{
	351	public:
	352	typedef INDEXTYPE index_type;
	353	ArcDescriptor(lemon::Invalid = lemon::INVALID)
	354	: id_(-1)
	355	{}
	356	explicit ArcDescriptor(index_type const & id)
	357	: id_(id)
	358	{}
	359	bool operator!=(ArcDescriptor const & other) const
	360	{
	361	return id_ != other.id_;
	362	}
	363	bool operator==(ArcDescriptor const & other) const
	364	{
	365	return id_ == other.id_;
	366	}
	367	bool operator<(ArcDescriptor const & other) const
	368	{
	369	return id_ < other.id_;
	370	}
	371	index_type id() const
	372	{
	373	return id_;
	374	}
	375	protected:
	376	index_type id_;
	377	};
	378
	379	template <typename INDEXTYPE>
	380	std::ostream & operator << (std::ostream & os, ArcDescriptor<INDEXTYPE> const & item)
	381	{
	382	return os << item.id();
	383	}
	384
	385	} // namespace detail
	386
	387
	388
	389	enum ContainerTag
	390	{
	391	MapTag,
	392	VectorTag,
	393	IndexVectorTag
	394	};
	395
	396	/**
	397	* @brief The PropertyMap is used to store Node or Arc information of graphs.
	398	*
	399	* @tparam <KEYTYPE> the key type
	400	* @tparam <MAPPEDTYPE> the mapped type
	401	* @tparam <ContainerTag = MapTag> whether to use a map or a vector as underlying storage
	402	*
	403	* @note
	404	* In contrast to std::map, operator[] does not insert elements. Use insert() instead.
	405	* If ContainerTag == MapTag: at() and operator[] behave like std::map::at().
	406	* If ContainerTag == IndexVectorTag: at() behaves like std::map::at(). operator[] does not check if the key exists.
	407	*/
	408	template <typename KEYTYPE, typename MAPPEDTYPE, ContainerTag = MapTag >
	409	class PropertyMap
	410	{
	411	public:
	412	typedef KEYTYPE key_type;
	413	typedef MAPPEDTYPE mapped_type;
	414	typedef std::pair<key_type const, mapped_type> value_type;
	415	typedef value_type & reference;
	416	typedef value_type const & const_reference;
	417	typedef std::map<key_type, mapped_type> Map;
	418	typedef typename Map::iterator iterator;
	419	typedef typename Map::const_iterator const_iterator;
	420
	421	mapped_type & at(key_type const & k)
	422	{
	423	return map_.at(k);
	424	}
	425	mapped_type const & at(key_type const & k) const
	426	{
	427	return map_.at(k);
	428	}
	429	mapped_type & operator[](key_type const & k)
	430	{
	431	return map_.at(k);
	432	}
	433	mapped_type const & operator[](key_type const & k) const
	434	{
	435	return map_.at(k);
	436	}
	437	void insert(key_type const & k, mapped_type const & v)
	438	{
	439	map_[k] = v;
	440	}
	441	iterator begin()
	442	{
	443	return map_.begin();
	444	}
	445	const_iterator begin() const
	446	{
	447	return map_.begin();
	448	}
	449	const_iterator cbegin() const
	450	{
	451	return map_.cbegin();
	452	}
	453	iterator end()
	454	{
	455	return map_.end();
	456	}
	457	const_iterator end() const
	458	{
	459	return map_.end();
	460	}
	461	const_iterator cend() const
	462	{
	463	return map_.cend();
	464	}
	465	void clear()
	466	{
	467	map_.clear();
	468	}
	469	iterator find(key_type const & k)
	470	{
	471	return map_.find(k);
	472	}
	473	const_iterator find(key_type const & k) const
	474	{
	475	return map_.find(k);
	476	}
	477	size_t size() const
	478	{
	479	return map_.size();
	480	}
	481	size_t erase(key_type const & k)
	482	{
	483	return map_.erase(k);
	484	}
	485
	486	protected:
	487	Map map_;
	488	};
	489
	490
	491
	492	namespace detail
	493	{
	494	template <typename VALUE_TYPE>
	495	struct PMapValueSkipper
	496	{
	497	public:
	498	typedef VALUE_TYPE value_type;
	499	typedef typename value_type::first_type key_type;
	500	PMapValueSkipper(key_type default_key)
	501	:
	502	default_key_(default_key)
	503	{}
	504	bool operator()(value_type const & v)
	505	{
	506	return v.first != default_key_;
	507	}
	508	private:
	509	key_type const default_key_;
	510	};
	511	}
	512
	513	/**
	514	* @brief Specialization of PropertyMap that stores the elements in a vector (size = max node id of stored elements).
	515	*/
	516	template <typename KEYTYPE, typename MAPPEDTYPE>
	517	class PropertyMap<KEYTYPE, MAPPEDTYPE, VectorTag>
	518	{
	519	public:
	520	typedef KEYTYPE key_type;
	521	typedef MAPPEDTYPE mapped_type;
	522	typedef std::pair<key_type, mapped_type> value_type;
	523	typedef value_type & reference;
	524	typedef value_type const & const_reference;
	525	typedef std::vector<value_type> Map;
	526	typedef detail::PMapValueSkipper<value_type> ValueSkipper;
	527	typedef FilterIterator<ValueSkipper, typename Map::iterator> iterator;
	528	typedef FilterIterator<ValueSkipper, typename Map::const_iterator> const_iterator;
	529
	530	PropertyMap(key_type default_key = lemon::INVALID)
	531	:
	532	num_elements_(0),
	533	default_key_(default_key)
	534	{}
	535
	536	mapped_type & at(key_type const & k)
	537	{
	538	#ifdef VIGRA_CHECK_BOUNDS
	539	if (k.id() < 0 \|\| k.id() >= map_.size() \|\| map_[k.id()].first == default_key_)
	540	throw std::out_of_range("PropertyMap::at(): Key not found.");
	541	#endif
	542	return map_[k.id()].second;
	543	}
	544
	545	mapped_type const & at(key_type const & k) const
	546	{
	547	#ifdef VIGRA_CHECK_BOUNDS
	548	if (k.id() < 0 \|\| k.id() >= map_.size() \|\| map_[k.id()].first == default_key_)
	549	throw std::out_of_range("PropertyMap::at(): Key not found.");
	550	#endif
	551	return map_[k.id()].second;
	552	}
	553
	554	mapped_type & operator[](key_type const & k)
	555	{
	556	return map_[k.id()].second;
	557	}
	558
	559	mapped_type const & operator[](key_type const & k) const
	560	{
	561	return map_[k.id()].second;
	562	}
	563
	564	void insert(key_type const & k, mapped_type const & v)
	565	{
	566	if (k.id() < 0)
	567	throw std::out_of_range("PropertyMap::insert(): Key must not be negative.");
	568
	569	if ((size_t)k.id() >= map_.size())
	570	map_.resize(k.id()+1, value_type(default_key_, mapped_type()));
	571
	572	auto & elt = map_[k.id()];
	573	if (elt.first == default_key_)
	574	++num_elements_;
	575
	576	elt.first = k;
	577	elt.second = v;
	578	}
	579
	580	#define MAKE_ITER(it) make_filter_iterator(ValueSkipper(default_key_), it, map_.end())
	581	#define MAKE_CITER(it) make_filter_iterator(ValueSkipper(default_key_), it, map_.cend())
	582
	583	iterator begin()
	584	{
	585	return MAKE_ITER(map_.begin());
	586	}
	587
	588	const_iterator begin() const
	589	{
	590	return MAKE_ITER(map_.begin());
	591	}
	592
	593	const_iterator cbegin() const
	594	{
	595	return MAKE_CITER(map_.cbegin());
	596	}
	597
	598	iterator end()
	599	{
	600	return MAKE_ITER(map_.end());
	601	}
	602
	603	const_iterator end() const
	604	{
	605	return MAKE_ITER(map_.end());
	606	}
	607
	608	const_iterator cend() const
	609	{
	610	return MAKE_CITER(map_.cend());
	611	}
	612
	613	iterator find(key_type const & k)
	614	{
	615	if (k.id() < 0 \|\| k.id() >= map_.size() \|\| map_[k.id()].first == default_key_)
	616	return end();
	617	else
	618	return MAKE_ITER(std::next(map_.begin(), k.id()));
	619	}
	620
	621	const_iterator find(key_type const & k) const
	622	{
	623	if (k.id() < 0 \|\| k.id() >= map_.size() \|\| map_[k.id()].first == default_key_)
	624	return end();
	625	else
	626	return MAKE_ITER(std::next(map_.begin(), k.id()));
	627	}
	628
	629	#undef MAKE_ITER
	630	#undef MAKE_CITER
	631
	632	void clear()
	633	{
	634	map_.clear();
	635	num_elements_ = 0;
	636	}
	637
	638	size_t size() const
	639	{
	640	return num_elements_;
	641	}
	642
	643	size_t erase(key_type const & k)
	644	{
	645	if (k.id() < 0 \|\| k.id() >= map_.size() \|\| map_[k.id()].first == default_key_)
	646	{
	647	return 0;
	648	}
	649	else
	650	{
	651	map_[k.id()].first = default_key_;
	652	--num_elements_;
	653	return 1;
	654	}
	655	}
	656
	657	protected:
	658	Map map_;
	659	size_t num_elements_;
	660	key_type default_key_;
	661	};
	662
	663
	664
	665	/**
	666	* @brief
	667	* Specialization of PropertyMap that stores the elements in a vector (size = number of stored elements).
	668	* An additional index vector is needed for bookkeeping (size = max node id of stored elements).
	669	*/
	670	template <typename KEYTYPE, typename MAPPEDTYPE>
	671	class PropertyMap<KEYTYPE, MAPPEDTYPE, IndexVectorTag>
	672	{
	673	public:
	674	typedef KEYTYPE key_type;
	675	typedef MAPPEDTYPE mapped_type;
	676	typedef std::pair<key_type, mapped_type> value_type;
	677	typedef value_type & reference;
	678	typedef value_type const & const_reference;
	679	typedef std::vector<value_type> Map;
	680	typedef typename Map::iterator iterator;
	681	typedef typename Map::const_iterator const_iterator;
	682
	683	mapped_type & at(key_type const & k)
	684	{
	685	#ifdef VIGRA_CHECK_BOUNDS
	686	if (indices_.at(k.id()) == -1)
	687	throw std::out_of_range("PropertyMap::at(): Key not found.");
	688	#endif
	689	return map_[indices_[k.id()]].second;
	690	}
	691
	692	mapped_type const & at(key_type const & k) const
	693	{
	694	#ifdef VIGRA_CHECK_BOUNDS
	695	if (indices_.at(k.id()) == -1)
	696	throw std::out_of_range("PropertyMap::at(): Key not found.");
	697	#endif
	698	return map_[indices_[k.id()]].second;
	699	}
	700
	701	mapped_type & operator[](key_type const & k)
	702	{
	703	return map_[indices_[k.id()]].second;
	704	}
	705
	706	mapped_type const & operator[](key_type const & k) const
	707	{
	708	return map_[indices_[k.id()]].second;
	709	}
	710
	711	void insert(key_type const & k, mapped_type const & v)
	712	{
	713	if (k.id() < 0)
	714	throw std::out_of_range("PropertyMap::insert(): Key must not be negative.");
	715
	716	if (k.id() >= indices_.size())
	717	indices_.resize(k.id()+1, -1);
	718
	719	if (indices_[k.id()] == -1)
	720	{
	721	indices_[k.id()] = map_.size();
	722	map_.push_back(value_type(k, v));
	723	}
	724	}
	725
	726	iterator begin()
	727	{
	728	return map_.begin();
	729	}
	730
	731	const_iterator begin() const
	732	{
	733	return map_.begin();
	734	}
	735
	736	const_iterator cbegin() const
	737	{
	738	return map_.cend();
	739	}
	740
	741	iterator end()
	742	{
	743	return map_.end();
	744	}
	745
	746	const_iterator end() const
	747	{
	748	return map_.end();
	749	}
	750
	751	const_iterator cend() const
	752	{
	753	return map_.cend();
	754	}
	755
	756	void clear()
	757	{
	758	map_.clear();
	759	indices_.clear();
	760	}
	761
	762	iterator find(key_type const & k)
	763	{
	764	if (k.id() < 0 \|\| k.id() >= indices_.size() \|\| indices_[k.id()] == -1)
	765	return map_.end();
	766	else
	767	return std::next(map_.begin(), indices_[k.id()]);
	768	}
	769
	770	const_iterator find(key_type const & k) const
	771	{
	772	if (k.id() < 0 \|\| k.id() >= indices_.size() \|\| indices_[k.id()] == -1)
	773	return map_.end();
	774	else
	775	return std::next(map_.begin(), indices_[k.id()]);
	776	}
	777
	778	size_t size() const
	779	{
	780	return map_.size();
	781	}
	782
	783	size_t erase(key_type const & k)
	784	{
	785	if (k.id() < 0 \|\| k.id() >= indices_.size() \|\| indices_[k.id()] == -1)
	786	{
	787	return 0;
	788	}
	789	else
	790	{
	791	// Erase the element from the index vector and the map.
	792	size_t ind = indices_[k.id()];
	793	indices_[k.id()] = -1;
	794	map_.erase(std::next(map_.begin(), ind));
	795
	796	// Adjust the indices.
	797	for (size_t i = 0; i < indices_.size(); ++i)
	798	if (indices_[i] > ind)
	799	--indices_[i];
	800	return 1;
	801	}
	802	}
	803
	804	protected:
	805	Map map_;
	806	std::vector<int> indices_;
	807	};
	808
	809
	810
	811	} // namespace vigra
	812
	813
	814
300	815	#endif // VIGRA_GRAPH_HXX

+101

-58

include/vigra/hdf5impex.hxx less more

44	44	#define H5Dopen_vers 2
45	45	#define H5Dcreate_vers 2
46	46	#define H5Acreate_vers 2
	47	#define H5Eset_auto_vers 2
	48	#define H5Eget_auto_vers 2
47	49
48	50	#include <hdf5.h>
49	51

126	128	*/
127	129	class HDF5DisableErrorOutput
128	130	{
129		H5E_auto2_t old_func_;
	131	H5E_auto1_t old_func1_;
	132	H5E_auto2_t old_func2_;
130	133	void *old_client_data_;
	134	int error_handler_version_;
131	135
132	136	HDF5DisableErrorOutput(HDF5DisableErrorOutput const &);
133	137	HDF5DisableErrorOutput & operator=(HDF5DisableErrorOutput const &);
134	138
135	139	public:
136	140	HDF5DisableErrorOutput()
137		: old_func_(0)
	141	: old_func1_(0)
	142	, old_func2_(0)
138	143	, old_client_data_(0)
139		{
140		H5Eget_auto2(H5E_DEFAULT, &old_func_, &old_client_data_);
141		H5Eset_auto2(H5E_DEFAULT, NULL, NULL);
	144	, error_handler_version_(-1)
	145	{
	146	if(H5Eget_auto2(H5E_DEFAULT, &old_func2_, &old_client_data_) >= 0)
	147	{
	148	// prefer new-style error handling
	149	H5Eset_auto2(H5E_DEFAULT, NULL, NULL);
	150	error_handler_version_ = 2;
	151	}
	152	else if(H5Eget_auto1(&old_func1_, &old_client_data_) >= 0)
	153	{
	154	// fall back to old-style if another module (e.g. h5py)
	155	// prevents us from using new-style (i.e. H5Eget_auto2()
	156	// returned a negative error code)
	157	H5Eset_auto1(NULL, NULL);
	158	error_handler_version_ = 1;
	159	}
142	160	}
143	161
144	162	~HDF5DisableErrorOutput()
145	163	{
146		H5Eset_auto2(H5E_DEFAULT, old_func_, old_client_data_);
	164	if(error_handler_version_ == 1)
	165	H5Eset_auto1(old_func1_, old_client_data_);
	166	else if(error_handler_version_ == 2)
	167	H5Eset_auto2(H5E_DEFAULT, old_func2_, old_client_data_);
147	168	}
148	169	};
149	170

706	727	ordered as 'z', 'y', 'x', this function will return the shape in the order
707	728	'x', 'y', 'z'.
708	729	*/
709		VIGRA_EXPORT ArrayVector<hsize_t> const & shape() const
710		{
711		return m_dims;
712		}
	730	VIGRA_EXPORT ArrayVector<hsize_t> const & shape() const;
713	731
714	732	/** Get the shape (length) of the dataset along dimension \a dim.
715	733

1041	1059	/** \brief Open or create an HDF5File object.
1042	1060
1043	1061	Creates or opens HDF5 file with given filename.
1044		The current group is set to "/".
1045
1046		Note that the HDF5File class is not copyable (the copy constructor is
1047		private to enforce this).
1048		*/
1049		HDF5File(std::string filePath, OpenMode mode, bool track_creation_times = false)
	1062	The current group is set to "/". By default, the files is opened in read-only mode.
	1063	*/
	1064	explicit HDF5File(std::string filePath, OpenMode mode = ReadOnly, bool track_creation_times = false)
1050	1065	: track_time(track_creation_times ? 1 : 0)
1051	1066	{
1052	1067	open(filePath, mode);
	1068	}
	1069
	1070	/** \brief Open or create an HDF5File object.
	1071
	1072	Creates or opens HDF5 file with given filename.
	1073	The current group is set to "/". By default, the files is opened in read-only mode.
	1074	*/
	1075	explicit HDF5File(char const * filePath, OpenMode mode = ReadOnly, bool track_creation_times = false)
	1076	: track_time(track_creation_times ? 1 : 0)
	1077	{
	1078	open(std::string(filePath), mode);
1053	1079	}
1054	1080
1055	1081	/** \brief Initialize an HDF5File object from HDF5 file handle

1065	1091	\a read_only is 'true', you cannot create new datasets or
1066	1092	overwrite data.
1067	1093
1068		\warning In case the underlying HDF5 library used by Vigra is not
1069		exactly the same library used to open the file with the given id,
1070		this method will lead to crashes.
	1094	\warning When VIRA is linked against a different HDF5 library than the one
	1095	used to open the file with the given id, this method will lead to crashes.
1071	1096	*/
1072	1097	explicit HDF5File(HDF5HandleShared const & fileHandle,
1073	1098	const std::string & pathname = "",

1119	1144
1120	1145	/** \brief Assign a HDF5File object.
1121	1146
1122		Calls close() on the present file and The new object will refer to the same file and group as \a other.
	1147	Calls close() on the present file and refers to the same file and group as \a other afterwards.
1123	1148	*/
1124	1149	HDF5File & operator=(HDF5File const & other)
1125	1150	{

1142	1167
1143	1168	bool isOpen() const
1144	1169	{
1145		return fileHandle_ != 0;
	1170	return fileHandle_ != (hid_t)0;
1146	1171	}
1147	1172
1148	1173	bool isReadOnly() const

1376	1401
1377	1402	errorMessage = "HDF5File::getDatasetShape(): Unable to access dataspace.";
1378	1403	HDF5Handle dataspaceHandle(H5Dget_space(datasetHandle), &H5Sclose, errorMessage.c_str());
1379
1380	1404	//get dimension information
1381	1405	ArrayVector<hsize_t>::size_type dimensions = H5Sget_simple_extent_ndims(dataspaceHandle);
1382	1406
1383	1407	ArrayVector<hsize_t> shape(dimensions);
1384	1408	ArrayVector<hsize_t> maxdims(dimensions);
1385	1409	H5Sget_simple_extent_dims(dataspaceHandle, shape.data(), maxdims.data());
	1410
	1411	// invert the dimensions to guarantee VIGRA-compatible order.
	1412	std::reverse(shape.begin(), shape.end());
	1413	return shape;
	1414	}
	1415
	1416	/** \brief Get the shape of chunks along each dimension of a certain dataset.
	1417
	1418	Normally, this function is called after determining the dimension of the
	1419	dataset using \ref getDatasetDimensions().
	1420	If the first character is a "/", the path will be interpreted as absolute path,
	1421	otherwise it will be interpreted as path relative to the current group.
	1422
	1423	Note that the memory order between VIGRA and HDF5 files differs: VIGRA uses
	1424	Fortran-order, while HDF5 uses C-order. This function therefore reverses the axis
	1425	order relative to the file contents. That is, when the axes in the file are
	1426	ordered as 'z', 'y', 'x', this function will return the shape in the order
	1427	'x', 'y', 'z'.
	1428	*/
	1429	ArrayVector<hsize_t> getChunkShape(std::string datasetName) const
	1430	{
	1431	// make datasetName clean
	1432	datasetName = get_absolute_path(datasetName);
	1433
	1434	//Open dataset and dataspace
	1435	std::string errorMessage = "HDF5File::getChunkShape(): Unable to open dataset '" + datasetName + "'.";
	1436	HDF5Handle datasetHandle = HDF5Handle(getDatasetHandle_(datasetName), &H5Dclose, errorMessage.c_str());
	1437
	1438	errorMessage = "HDF5File::getChunkShape(): Unable to access dataspace.";
	1439	HDF5Handle dataspaceHandle(H5Dget_space(datasetHandle), &H5Sclose, errorMessage.c_str());
	1440	HDF5Handle properties(H5Dget_create_plist(datasetHandle),
	1441	&H5Pclose, "HDF5File::read(): failed to get property list");
	1442
	1443
	1444	//get dimension information
	1445	ArrayVector<hsize_t>::size_type dimensions = H5Sget_simple_extent_ndims(dataspaceHandle);
	1446
	1447	ArrayVector<hsize_t> shape(dimensions);
	1448	H5Pget_chunk(properties, dimensions, shape.data());
1386	1449
1387	1450	// invert the dimensions to guarantee VIGRA-compatible order.
1388	1451	std::reverse(shape.begin(), shape.end());

1809	1872	datasetName = get_absolute_path(datasetName);
1810	1873
1811	1874	typename MultiArrayShape<N>::type chunkSize;
1812		for(int i = 0; i < N; i++){
	1875	for(unsigned i = 0; i < N; i++){
1813	1876	chunkSize[i] = iChunkSize;
1814	1877	}
1815	1878	write_(datasetName, array, detail::getH5DataType<T>(), SIZE, chunkSize, compression);

1857	1920	datasetName = get_absolute_path(datasetName);
1858	1921
1859	1922	typename MultiArrayShape<N>::type chunkSize;
1860		for(int i = 0; i < N; i++){
	1923	for(unsigned i = 0; i < N; i++){
1861	1924	chunkSize[i] = iChunkSize;
1862	1925	}
1863	1926	write_(datasetName, array, detail::getH5DataType<T>(), 3, chunkSize, compression);

2412	2475	groupName = groupName + '/';
2413	2476	}
2414	2477
2415		// open or create subgroups one by one
	2478	// We determine if the group exists by checking the return value of H5Gopen.
	2479	// To do so, we must temporarily disable error reporting.
	2480	// Alternatively, we could use H5LTfind_dataset(), but this is much slower.
	2481	HDF5DisableErrorOutput disable_error;
	2482
	2483	// Open or create subgroups one by one
2416	2484	std::string::size_type begin = 0, end = groupName.find('/');
2417	2485	while (end != std::string::npos)
2418	2486	{
2419	2487	std::string group(groupName.begin()+begin, groupName.begin()+end);
	2488
2420	2489	hid_t prevParent = parent;
2421
2422		if(H5LTfind_dataset(parent, group.c_str()) == 0)
2423		{
2424		if(create)
2425		parent = H5Gcreate(prevParent, group.c_str(), H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
2426		else
2427		parent = -1;
2428		}
2429		else
2430		{
2431		parent = H5Gopen(prevParent, group.c_str(), H5P_DEFAULT);
2432		}
	2490	parent = H5Gopen(prevParent, group.c_str(), H5P_DEFAULT);
	2491	if(parent < 0 && create) // group doesn't exist, but we are supposed to create it
	2492	parent = H5Gcreate(prevParent, group.c_str(), H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
2433	2493	H5Gclose(prevParent);
2434	2494
2435	2495	if(parent < 0)
2436		{
2437		return parent;
2438		}
	2496	break;
	2497
2439	2498	begin = end + 1;
2440	2499	end = groupName.find('/', begin);
2441	2500	}

2950	3009	boffset.resize(N);
2951	3010	}
2952	3011
2953		for(int i = 0; i < N; ++i)
	3012	for(unsigned i = 0; i < N; ++i)
2954	3013	{
2955	3014	// vigra and hdf5 use different indexing
2956	3015	bshape[N-1-i] = array.shape(i);

3203	3262	boffset.resize(N);
3204	3263	}
3205	3264
3206		for(int i = 0; i < N; ++i)
	3265	for(unsigned i = 0; i < N; ++i)
3207	3266	{
3208	3267	// vigra and hdf5 use different indexing
3209	3268	bshape[N-1-i] = blockShape[i];

3341	3400	template<unsigned int N, class T, class StrideTag>
3342	3401	inline void readHDF5(const HDF5ImportInfo &info, MultiArrayView<N, T, StrideTag> array)
3343	3402	{
3344		readHDF5(info, array, 0, 0); // last two arguments are not used
3345		}
3346
3347		template<unsigned int N, class T, class StrideTag>
3348		void readHDF5(const HDF5ImportInfo &info, MultiArrayView<N, T, StrideTag> array, const hid_t datatype, const int numBandsOfType)
3349		{
3350	3403	HDF5File file(info.getFilePath(), HDF5File::OpenReadOnly);
3351	3404	file.read(info.getPathInFile(), array);
3352		file.close();
3353	3405	}
3354	3406
3355	3407	inline hid_t openGroup(hid_t parent, std::string group_name)

3555	3607	template<unsigned int N, class T, class StrideTag>
3556	3608	inline void writeHDF5(const char* filePath, const char* pathInFile, const MultiArrayView<N, T, StrideTag> & array)
3557	3609	{
3558		//last two arguments are not used
3559		writeHDF5(filePath, pathInFile, array, 0, 0);
3560		}
3561
3562		template<unsigned int N, class T, class StrideTag>
3563		void writeHDF5(const char* filePath, const char* pathInFile, const MultiArrayView<N, T, StrideTag> & array, const hid_t datatype, const int numBandsOfType)
3564		{
3565	3610	HDF5File file(filePath, HDF5File::Open);
3566	3611	file.write(pathInFile, array);
3567		file.close();
3568	3612	}
3569
3570	3613
3571	3614	namespace detail
3572	3615	{

+531

-226

include/vigra/hierarchical_clustering.hxx less more

46	46	/vigra/
47	47	#include "priority_queue.hxx"
48	48	#include "metrics.hxx"
	49	#include "merge_graph_adaptor.hxx"
49	50
50	51	namespace vigra{
	52
	53	/** \addtogroup GraphDataStructures
	54	*/
	55	//@{
51	56
52	57	namespace cluster_operators{
53	58

253	258	const Node u = mergeGraph_.u(e);
254	259	const Node v = mergeGraph_.v(e);
255	260
256		const size_t dU = mergeGraph_.degree(u);
257		const size_t dV = mergeGraph_.degree(u);
258	261	const BaseGraphEdge ee=EdgeHelper::itemToGraphItem(mergeGraph_,e);
259	262	const BaseGraphNode uu=NodeHelper::itemToGraphItem(mergeGraph_,u);
260	263	const BaseGraphNode vv=NodeHelper::itemToGraphItem(mergeGraph_,v);

279	282	vigra::ChangeablePriorityQueue< ValueType > pq_;
280	283	ValueType wardness_;;
281	284	};
282
283	285	/// \brief This Cluster Operator is a MONSTER.
284	286	/// It can really do a lot.
285	287	///

361	363	NODE_LABEL_MAP nodeLabelMap,
362	364	const ValueType beta,
363	365	const metrics::MetricType metricType,
364		const ValueType wardness=1.0,
365		const ValueType gamma = 10000000.0,
366		const ValueType sameLabelMultiplier = 0.8
	366	const ValueType wardness=static_cast<ValueType>(1.0),
	367	const ValueType gamma = static_cast<ValueType>(10000000.0),
	368	const ValueType sameLabelMultiplier = static_cast<ValueType>(0.8)
367	369	)
368	370	: mergeGraph_(mergeGraph),
369	371	edgeIndicatorMap_(edgeIndicatorMap),

377	379	wardness_(wardness),
378	380	gamma_(gamma),
379	381	sameLabelMultiplier_(sameLabelMultiplier),
380		metric_(metricType)
	382	metric_(metricType),
	383	useStopWeight_(false),
	384	stopWeight_()
381	385	{
382	386	typedef typename MergeGraph::MergeNodeCallBackType MergeNodeCallBackType;
383	387	typedef typename MergeGraph::MergeEdgeCallBackType MergeEdgeCallBackType;

408	412	/// \brief will be called via callbacks from mergegraph
409	413	void mergeEdges(const Edge & a,const Edge & b){
410	414	// update features / weigts etc
	415	bool done = false;
411	416	const BaseGraphEdge aa=EdgeHelper::itemToGraphItem(mergeGraph_,a);
412	417	const BaseGraphEdge bb=EdgeHelper::itemToGraphItem(mergeGraph_,b);
413		EdgeIndicatorReference va=edgeIndicatorMap_[aa];
414		EdgeIndicatorReference vb=edgeIndicatorMap_[bb];
415		va*=edgeSizeMap_[aa];
416		vb*=edgeSizeMap_[bb];
417
418
419		va+=vb;
420		edgeSizeMap_[aa]+=edgeSizeMap_[bb];
421		va/=(edgeSizeMap_[aa]);
422		vb/=edgeSizeMap_[bb];
423		// delete b from pq
424		pq_.deleteItem(b.id());
	418	if(!isLifted_.empty()){
	419	const bool isLiftedA = isLifted_[mergeGraph_.graph().id(aa)];
	420	const bool isLiftedB = isLifted_[mergeGraph_.graph().id(bb)];
	421	if(isLiftedA && isLiftedB){
	422	pq_.deleteItem(b.id());
	423	done = true;
	424	}
	425	isLifted_[mergeGraph_.graph().id(aa)] = isLiftedA && isLiftedB;
	426	}
	427	if(!done){
	428
	429	EdgeIndicatorReference va=edgeIndicatorMap_[aa];
	430	EdgeIndicatorReference vb=edgeIndicatorMap_[bb];
	431	va*=edgeSizeMap_[aa];
	432	vb*=edgeSizeMap_[bb];
	433
	434	va+=vb;
	435	edgeSizeMap_[aa]+=edgeSizeMap_[bb];
	436	va/=(edgeSizeMap_[aa]);
	437	vb/=edgeSizeMap_[bb];
	438	// delete b from pq
	439	pq_.deleteItem(b.id());
	440	}
425	441	}
426	442
427	443	/// \brief will be called via callbacks from mergegraph

496	512	pq_.deleteItem(minLabel);
497	513	minLabel = pq_.top();
498	514	}
	515	//std::cout<<"mg e"<<mergeGraph_.edgeNum()<<" mg n"<<mergeGraph_.nodeNum()<<" cw"<< this->contractionWeight()<<"\n";
	516	if(!isLifted_.empty()){
	517	if(isLifted_[minLabel])
	518	throw std::runtime_error("use lifted edges only if you are DerThorsten or know what you are doing\n");
	519	}
499	520	return Edge(minLabel);
500	521	}
501	522

517	538	}
518	539
519	540	bool done(){
520
521	541	index_type minLabel = pq_.top();
522	542	while(mergeGraph_.hasEdgeId(minLabel)==false){
523	543	pq_.deleteItem(minLabel);
524	544	minLabel = pq_.top();
525	545	}
526	546	const ValueType p = pq_.topPriority();
527
	547	if(useStopWeight_){
	548	if(p >= stopWeight_){
	549	return true;
	550	}
	551	}
528	552	return p>= gamma_;
529	553	}
530	554
	555	template<class ITER>
	556	void setLiftedEdges(ITER idsBegin, ITER idsEnd){
	557	if(isLifted_.size()<std::size_t(mergeGraph_.graph().maxEdgeId()+1)){
	558	isLifted_.resize(mergeGraph_.graph().maxEdgeId()+1,false);
	559	std::fill(isLifted_.begin(), isLifted_.end(), false);
	560	}
	561	while(idsBegin!=idsEnd){
	562	isLifted_[*idsBegin] = true;
	563
	564	const ValueType currentWeight = this->getEdgeWeight(Edge(*idsBegin));
	565	pq_.push(*idsBegin,currentWeight);
	566	minWeightEdgeMap_[mergeGraph_.graph().edgeFromId(*idsBegin)]=currentWeight;
	567	++idsBegin;
	568	}
	569	}
	570
	571	void enableStopWeight(const ValueType stopWeight){
	572	useStopWeight_ = true;
	573	stopWeight_ = stopWeight;
	574	}
531	575	private:
532	576	ValueType getEdgeWeight(const Edge & e){
533
	577	const BaseGraphEdge ee=EdgeHelper::itemToGraphItem(mergeGraph_,e);
	578	if(!isLifted_.empty() && isLifted_[mergeGraph_.graph().id(ee)]){
	579	//std::cout<<"found lifted edge\n";
	580	return 10000000.0;// std::numeric_limits<ValueType>::infinity();
	581	}
534	582	const Node u = mergeGraph_.u(e);
535	583	const Node v = mergeGraph_.v(e);
536	584
537		const size_t dU = mergeGraph_.degree(u);
538		const size_t dV = mergeGraph_.degree(u);
539		const BaseGraphEdge ee=EdgeHelper::itemToGraphItem(mergeGraph_,e);
540	585	const BaseGraphNode uu=NodeHelper::itemToGraphItem(mergeGraph_,u);
541	586	const BaseGraphNode vv=NodeHelper::itemToGraphItem(mergeGraph_,v);
542	587

579	624	ValueType gamma_;
580	625	ValueType sameLabelMultiplier_;
581	626	metrics::Metric<float> metric_;
	627
	628	std::vector<bool> isLifted_;
	629	bool useStopWeight_;
	630	ValueType stopWeight_;
582	631	};
583	632
584	633
585	634
586	635	} // end namespace cluster_operators
587	636
588
589
590		/// \brief do hierarchical clustering with a given cluster operator
591		template< class CLUSTER_OPERATOR>
592		class HierarchicalClustering{
593
594		public:
595		typedef CLUSTER_OPERATOR ClusterOperator;
596		typedef typename ClusterOperator::MergeGraph MergeGraph;
597		typedef typename MergeGraph::Graph Graph;
598		typedef typename Graph::Edge BaseGraphEdge;
599		typedef typename Graph::Node BaseGraphNode;
600		typedef typename MergeGraph::Edge Edge;
601		typedef typename MergeGraph::Node Node;
602		typedef typename CLUSTER_OPERATOR::WeightType ValueType;
603		typedef typename MergeGraph::index_type MergeGraphIndexType;
604
605		struct Parameter{
606		Parameter(
607		const size_t nodeNumStopCond = 1,
608		const bool buildMergeTree = true,
609		const bool verbose = false
610		)
611		: nodeNumStopCond_ (nodeNumStopCond),
612		buildMergeTreeEncoding_(buildMergeTree),
613		verbose_(verbose){
614		}
615		size_t nodeNumStopCond_;
616		bool buildMergeTreeEncoding_;
617		bool verbose_;
618		};
619
620		struct MergeItem{
621		MergeItem(
622		const MergeGraphIndexType a,
623		const MergeGraphIndexType b,
624		const MergeGraphIndexType r,
625		const ValueType w
626		):
627		a_(a),b_(b),r_(r),w_(w){
628		}
629		MergeGraphIndexType a_;
630		MergeGraphIndexType b_;
631		MergeGraphIndexType r_;
632		ValueType w_;
633		};
634
635		typedef std::vector<MergeItem> MergeTreeEncoding;
636
637		/// \brief construct HierarchicalClustering from clusterOperator and an optional parameter object
638		HierarchicalClustering(
639		ClusterOperator & clusterOperator,
640		const Parameter & parameter = Parameter()
641		)
642		:
643		clusterOperator_(clusterOperator),
644		param_(parameter),
645		mergeGraph_(clusterOperator_.mergeGraph()),
646		graph_(mergeGraph_.graph()),
647		timestamp_(graph_.maxNodeId()+1),
648		toTimeStamp_(),
649		timeStampIndexToMergeIndex_(),
650		mergeTreeEndcoding_()
651		{
	637	/** \brief Options object for hierarchical clustering.
	638
	639	<b>\#include</b> \<vigra/hierarchical_clustering.hxx\><br/>
	640	Namespace: vigra
	641
	642	This class allows to set various parameters of \ref hierarchicalClustering().
	643	See there for usage examples.
	644	*/
	645	class ClusteringOptions
	646	{
	647	public:
	648
	649	ClusteringOptions(
	650	const size_t nodeNumStopCond = 1,
	651	const bool buildMergeTree = false,
	652	const bool verbose = false)
	653	: nodeNumStopCond_ (nodeNumStopCond)
	654	, maxMergeWeight_(NumericTraits<double>::max())
	655	, nodeFeatureImportance_(0.5)
	656	, sizeImportance_(1.0)
	657	, nodeFeatureMetric_(metrics::ManhattanMetric)
	658	, buildMergeTreeEncoding_(buildMergeTree)
	659	, verbose_(verbose)
	660	{}
	661
	662	/** Stop merging when the number of clusters reaches this threshold.
	663
	664	Default: 1 (don't stop early)
	665	*/
	666	ClusteringOptions & minRegionCount(size_t count)
	667	{
	668	nodeNumStopCond_ = count;
	669	return *this;
	670	}
	671
	672	/** Stop merging when the weight of the cheapest edge exceeds this threshold.
	673
	674	Default: infinity (don't stop early)
	675	*/
	676	ClusteringOptions & maxMergeDistance(double val)
	677	{
	678	maxMergeWeight_ = val;
	679	return *this;
	680	}
	681
	682	/** Importance of node features relative to edge weights.
	683
	684	Must be between 0 and 1, with 0 meaning that node features
	685	are ignored, and 1 meaning that edge weights are ignored.
	686
	687	Default: 0.5 (equal importance)
	688	*/
	689	ClusteringOptions & nodeFeatureImportance(double val)
	690	{
	691	vigra_precondition(0.0 <= val && val <= 1.0,
	692	"ClusteringOptions::nodePropertyImportance(val): 0 <= val <= 1 required.");
	693	nodeFeatureImportance_ = val;
	694	return *this;
	695	}
	696
	697	/** Importance of node size.
	698
	699	Must be between 0 and 1, with 0 meaning that size is ignored,
	700	and 1 meaning that the algorithm prefers to keep cluster sizes
	701	balanced.
	702
	703	Default: 1.0 (prefer like-sized clusters)
	704	*/
	705	ClusteringOptions & sizeImportance(double val)
	706	{
	707	vigra_precondition(0.0 <= val && val <= 1.0,
	708	"ClusteringOptions::sizeImportance(val): 0 <= val <= 1 required.");
	709	sizeImportance_ = val;
	710	return *this;
	711	}
	712
	713
	714	/** Metric to be used when transforming node features into cluster distances.
	715
	716	The cluster (= node) distance is the respective norm of the difference
	717	vector between the corresponding node feature vectors.
	718
	719	Default: metrics::ManhattanMetric (L1-norm of the feature difference)
	720	*/
	721	ClusteringOptions & nodeFeatureMetric(metrics::MetricType metric)
	722	{
	723	nodeFeatureMetric_ = metric;
	724	return *this;
	725	}
	726
	727	ClusteringOptions & buildMergeTreeEncoding(bool val=true)
	728	{
	729	buildMergeTreeEncoding_ = val;
	730	return *this;
	731	}
	732
	733	/** Display progress information.
	734
	735	Default: false
	736	*/
	737	ClusteringOptions & verbose(bool val=true)
	738	{
	739	verbose_ = val;
	740	return *this;
	741	}
	742
	743	size_t nodeNumStopCond_;
	744	double maxMergeWeight_;
	745	double nodeFeatureImportance_;
	746	double sizeImportance_;
	747	metrics::MetricType nodeFeatureMetric_;
	748	bool buildMergeTreeEncoding_;
	749	bool verbose_;
	750	};
	751
	752	// \brief do hierarchical clustering with a given cluster operator
	753	template< class CLUSTER_OPERATOR>
	754	class HierarchicalClusteringImpl
	755	{
	756	public:
	757	typedef CLUSTER_OPERATOR ClusterOperator;
	758	typedef typename ClusterOperator::MergeGraph MergeGraph;
	759	typedef typename MergeGraph::Graph Graph;
	760	typedef typename Graph::Edge BaseGraphEdge;
	761	typedef typename Graph::Node BaseGraphNode;
	762	typedef typename MergeGraph::Edge Edge;
	763	typedef typename MergeGraph::Node Node;
	764	typedef typename CLUSTER_OPERATOR::WeightType ValueType;
	765	typedef typename MergeGraph::index_type MergeGraphIndexType;
	766
	767	typedef ClusteringOptions Parameter;
	768
	769	struct MergeItem{
	770	MergeItem(
	771	const MergeGraphIndexType a,
	772	const MergeGraphIndexType b,
	773	const MergeGraphIndexType r,
	774	const ValueType w
	775	):
	776	a_(a),b_(b),r_(r),w_(w){
	777	}
	778	MergeGraphIndexType a_;
	779	MergeGraphIndexType b_;
	780	MergeGraphIndexType r_;
	781	ValueType w_;
	782	};
	783
	784	typedef std::vector<MergeItem> MergeTreeEncoding;
	785
	786	/// \brief construct HierarchicalClusteringImpl from clusterOperator and an optional parameter object
	787	HierarchicalClusteringImpl(
	788	ClusterOperator & clusterOperator,
	789	const Parameter & parameter = Parameter()
	790	)
	791	:
	792	clusterOperator_(clusterOperator),
	793	param_(parameter),
	794	mergeGraph_(clusterOperator_.mergeGraph()),
	795	graph_(mergeGraph_.graph()),
	796	timestamp_(graph_.maxNodeId()+1),
	797	toTimeStamp_(),
	798	timeStampIndexToMergeIndex_(),
	799	mergeTreeEndcoding_()
	800	{
	801	if(param_.buildMergeTreeEncoding_){
	802	// this can be be made smater since user can pass
	803	// stoping condition based on nodeNum
	804	mergeTreeEndcoding_.reserve(graph_.nodeNum()*2);
	805	toTimeStamp_.resize(graph_.maxNodeId()+1);
	806	timeStampIndexToMergeIndex_.resize(graph_.maxNodeId()+1);
	807	for(MergeGraphIndexType nodeId=0;nodeId<=mergeGraph_.maxNodeId();++nodeId){
	808	toTimeStamp_[nodeId]=nodeId;
	809	}
	810	}
	811
	812
	813
	814	}
	815
	816	/// \brief start the clustering
	817	void cluster(){
	818	if(param_.verbose_)
	819	std::cout<<"\n";
	820	while(mergeGraph_.nodeNum()>param_.nodeNumStopCond_ && mergeGraph_.edgeNum()>0 && !clusterOperator_.done()){
	821
	822	const Edge edgeToRemove = clusterOperator_.contractionEdge();
652	823	if(param_.buildMergeTreeEncoding_){
653		// this can be be made smater since user can pass
654		// stoping condition based on nodeNum
655		mergeTreeEndcoding_.reserve(graph_.nodeNum()*2);
656		toTimeStamp_.resize(graph_.maxNodeId()+1);
657		timeStampIndexToMergeIndex_.resize(graph_.maxNodeId()+1);
658		for(MergeGraphIndexType nodeId=0;nodeId<=mergeGraph_.maxNodeId();++nodeId){
659		toTimeStamp_[nodeId]=nodeId;
660		}
661		}
662
663
664
665		}
666
667		/// \brief start the clustering
668		void cluster(){
669		if(param_.verbose_)
670		std::cout<<"\n";
671		while(mergeGraph_.nodeNum()>param_.nodeNumStopCond_ && mergeGraph_.edgeNum()>0 && !clusterOperator_.done()){
672
673		const Edge edgeToRemove = clusterOperator_.contractionEdge();
674		if(param_.buildMergeTreeEncoding_){
675		const MergeGraphIndexType uid = mergeGraph_.id(mergeGraph_.u(edgeToRemove));
676		const MergeGraphIndexType vid = mergeGraph_.id(mergeGraph_.v(edgeToRemove));
677		const ValueType w = clusterOperator_.contractionWeight();
678		// do the merge
679		mergeGraph_.contractEdge( edgeToRemove);
680		const MergeGraphIndexType aliveNodeId = mergeGraph_.hasNodeId(uid) ? uid : vid;
681		const MergeGraphIndexType deadNodeId = aliveNodeId==vid ? uid : vid;
682		timeStampIndexToMergeIndex_[timeStampToIndex(timestamp_)]=mergeTreeEndcoding_.size();
683		mergeTreeEndcoding_.push_back(MergeItem( toTimeStamp_[aliveNodeId],toTimeStamp_[deadNodeId],timestamp_,w));
684		toTimeStamp_[aliveNodeId]=timestamp_;
685		timestamp_+=1;
686		}
687		else{
688		//std::cout<<"constract\n";
689		// do the merge
690		mergeGraph_.contractEdge( edgeToRemove );
691		}
692		if(param_.verbose_ && mergeGraph_.nodeNum()%1==0){
693		std::cout<<"\rNodes: "<<std::setw(10)<<mergeGraph_.nodeNum()<<std::flush;
694		}
695
696		}
697		if(param_.verbose_)
698		std::cout<<"\n";
699		}
700
701		/// \brief get the encoding of the merge tree
702		const MergeTreeEncoding & mergeTreeEndcoding()const{
703		return mergeTreeEndcoding_;
704		}
705
706		template<class EDGE_MAP>
707		void ucmTransform(EDGE_MAP & edgeMap)const{
708		typedef typename Graph::EdgeIt BaseGraphEdgeIt;
709
710		for(BaseGraphEdgeIt iter(graph()); iter!=lemon::INVALID; ++iter ){
711		const BaseGraphEdge edge=*iter;
712		edgeMap[edge] = edgeMap[mergeGraph().reprGraphEdge(edge)];
713		}
714		}
715
716		/// \brief get the node id's which are the leafes of a treeNodeId
717		template<class OUT_ITER>
718		size_t leafNodeIds(const MergeGraphIndexType treeNodeId, OUT_ITER begin)const{
719		if(treeNodeId<=graph_.maxNodeId()){
720		*begin=treeNodeId;
721		++begin;
722		return 1;
	824	const MergeGraphIndexType uid = mergeGraph_.id(mergeGraph_.u(edgeToRemove));
	825	const MergeGraphIndexType vid = mergeGraph_.id(mergeGraph_.v(edgeToRemove));
	826	const ValueType w = clusterOperator_.contractionWeight();
	827	// do the merge
	828	mergeGraph_.contractEdge( edgeToRemove);
	829	const MergeGraphIndexType aliveNodeId = mergeGraph_.hasNodeId(uid) ? uid : vid;
	830	const MergeGraphIndexType deadNodeId = aliveNodeId==vid ? uid : vid;
	831	timeStampIndexToMergeIndex_[timeStampToIndex(timestamp_)]=mergeTreeEndcoding_.size();
	832	mergeTreeEndcoding_.push_back(MergeItem( toTimeStamp_[aliveNodeId],toTimeStamp_[deadNodeId],timestamp_,w));
	833	toTimeStamp_[aliveNodeId]=timestamp_;
	834	timestamp_+=1;
723	835	}
724	836	else{
725		size_t leafNum=0;
726		std::queue<MergeGraphIndexType> queue;
727		queue.push(treeNodeId);
728
729		while(!queue.empty()){
730
731		const MergeGraphIndexType id = queue.front();
732		queue.pop();
733		const MergeGraphIndexType mergeIndex = timeStampToMergeIndex(id);
734		const MergeGraphIndexType ab[]= { mergeTreeEndcoding_[mergeIndex].a_, mergeTreeEndcoding_[mergeIndex].b_};
735
736		for(size_t i=0;i<2;++i){
737		if(ab[i]<=graph_.maxNodeId()){
738		*begin=ab[i];
739		++begin;
740		++leafNum;
741		}
742		else{
743		queue.push(ab[i]);
744		}
	837	//std::cout<<"constract\n";
	838	// do the merge
	839	mergeGraph_.contractEdge( edgeToRemove );
	840	}
	841	if(param_.verbose_ && mergeGraph_.nodeNum()%1==0){
	842	std::cout<<"\rNodes: "<<std::setw(10)<<mergeGraph_.nodeNum()<<std::flush;
	843	}
	844
	845	}
	846	if(param_.verbose_)
	847	std::cout<<"\n";
	848	}
	849
	850	/// \brief get the encoding of the merge tree
	851	const MergeTreeEncoding & mergeTreeEndcoding()const{
	852	return mergeTreeEndcoding_;
	853	}
	854
	855	template<class EDGE_MAP>
	856	void ucmTransform(EDGE_MAP & edgeMap)const{
	857	typedef typename Graph::EdgeIt BaseGraphEdgeIt;
	858
	859	for(BaseGraphEdgeIt iter(graph()); iter!=lemon::INVALID; ++iter ){
	860	const BaseGraphEdge edge=*iter;
	861	edgeMap[edge] = edgeMap[mergeGraph().reprGraphEdge(edge)];
	862	}
	863	}
	864
	865	/// \brief get the node id's which are the leafes of a treeNodeId
	866	template<class OUT_ITER>
	867	size_t leafNodeIds(const MergeGraphIndexType treeNodeId, OUT_ITER begin)const{
	868	if(treeNodeId<=graph_.maxNodeId()){
	869	*begin=treeNodeId;
	870	++begin;
	871	return 1;
	872	}
	873	else{
	874	size_t leafNum=0;
	875	std::queue<MergeGraphIndexType> queue;
	876	queue.push(treeNodeId);
	877
	878	while(!queue.empty()){
	879
	880	const MergeGraphIndexType id = queue.front();
	881	queue.pop();
	882	const MergeGraphIndexType mergeIndex = timeStampToMergeIndex(id);
	883	const MergeGraphIndexType ab[]= { mergeTreeEndcoding_[mergeIndex].a_, mergeTreeEndcoding_[mergeIndex].b_};
	884
	885	for(size_t i=0;i<2;++i){
	886	if(ab[i]<=graph_.maxNodeId()){
	887	*begin=ab[i];
	888	++begin;
	889	++leafNum;
	890	}
	891	else{
	892	queue.push(ab[i]);
745	893	}
746	894	}
747		return leafNum;
748		}
749		}
750
751		/// \brief get the graph the merge graph is based on
752		const Graph & graph()const{
753		return graph_;
754		}
755
756		/// \brief get the merge graph
757		const MergeGraph & mergeGraph()const{
758		return mergeGraph_;
759		}
760
761		/// \brief get the representative node id
762		const MergeGraphIndexType reprNodeId(const MergeGraphIndexType id)const{
763		return mergeGraph_.reprNodeId(id);
764		}
765		private:
766
767		MergeGraphIndexType timeStampToIndex(const MergeGraphIndexType timestamp)const{
768		return timestamp- graph_.maxNodeId();
769		}
770
771
772		MergeGraphIndexType timeStampToMergeIndex(const MergeGraphIndexType timestamp)const{
773		return timeStampIndexToMergeIndex_[timeStampToIndex(timestamp)];
774		}
775
776		ClusterOperator & clusterOperator_;
777		Parameter param_;
778		MergeGraph & mergeGraph_;
779		const Graph & graph_;
780		// parameter object
781
782
783		// timestamp
784		MergeGraphIndexType timestamp_;
785		std::vector<MergeGraphIndexType> toTimeStamp_;
786		std::vector<MergeGraphIndexType> timeStampIndexToMergeIndex_;
787		// data which can reconstruct the merge tree
788		MergeTreeEncoding mergeTreeEndcoding_;
789
790
791		};
792
793
	895	}
	896	return leafNum;
	897	}
	898	}
	899
	900	/// \brief get the graph the merge graph is based on
	901	const Graph & graph()const{
	902	return graph_;
	903	}
	904
	905	/// \brief get the merge graph
	906	const MergeGraph & mergeGraph()const{
	907	return mergeGraph_;
	908	}
	909
	910	/// \brief get the representative node id
	911	const MergeGraphIndexType reprNodeId(const MergeGraphIndexType id)const{
	912	return mergeGraph_.reprNodeId(id);
	913	}
	914	private:
	915
	916	MergeGraphIndexType timeStampToIndex(const MergeGraphIndexType timestamp)const{
	917	return timestamp- graph_.maxNodeId();
	918	}
	919
	920
	921	MergeGraphIndexType timeStampToMergeIndex(const MergeGraphIndexType timestamp)const{
	922	return timeStampIndexToMergeIndex_[timeStampToIndex(timestamp)];
	923	}
	924
	925
	926	ClusterOperator & clusterOperator_;
	927	Parameter param_;
	928	MergeGraph & mergeGraph_;
	929	const Graph & graph_;
	930	// parameter object
	931
	932
	933	// timestamp
	934	MergeGraphIndexType timestamp_;
	935	std::vector<MergeGraphIndexType> toTimeStamp_;
	936	std::vector<MergeGraphIndexType> timeStampIndexToMergeIndex_;
	937	// data which can reconstruct the merge tree
	938	MergeTreeEncoding mergeTreeEndcoding_;
	939
	940
	941
	942	};
	943
	944
	945	/********************************************************/
	946	/* */
	947	/* hierarchicalClustering */
	948	/* */
	949	/********************************************************/
	950
	951	/** \brief Reduce the number of nodes in a graph by iteratively contracting
	952	the cheapest edge.
	953
	954	<b> Declarations:</b>
	955
	956	\code
	957	namespace vigra {
	958	template <class GRAPH,
	959	class EDGE_WEIGHT_MAP, class EDGE_LENGTH_MAP,
	960	class NODE_FEATURE_MAP, class NOSE_SIZE_MAP,
	961	class NODE_LABEL_MAP>
	962	void
	963	hierarchicalClustering(GRAPH const & graph,
	964	EDGE_WEIGHT_MAP const & edgeWeights, EDGE_LENGTH_MAP const & edgeLengths,
	965	NODE_FEATURE_MAP const & nodeFeatures, NOSE_SIZE_MAP const & nodeSizes,
	966	NODE_LABEL_MAP & labelMap,
	967	ClusteringOptions options = ClusteringOptions());
	968	}
	969	\endcode
	970
	971	Hierarchical clustering is a simple and versatile image segmentation
	972	algorithm that typically operates either directly on the pixels (e.g. on
	973	a \ref vigra::GridGraph) or on a region adjacency graph over suitable
	974	superpixels (e.g. on an \ref vigra::AdjacencyListGraph). The graph is
	975	passed to the function in its first argument. After clustering is completed,
	976	the parameter \a labelMap contains a mapping from original node IDs to
	977	the ID of the cluster each node belongs to. Cluster IDs correspond to
	978	the ID of an arbitrarily chosen representative node within each cluster,
	979	i.e. they form a sparse subset of the original IDs.
	980
	981	Properties of the graph's edges and nodes are provided in the property maps
	982	\a edgeWeights, \a edgeLengths, \a nodeFeatures, and \a nodeSizes. These maps
	983	are indexed by edge or node ID and return the corresponding feature. Features
	984	must by arithmetic scalars or, in case of node features, scalars or vectors
	985	of scalars (precisely: objects that provide <tt>begin()</tt> and <tt>end()</tt>
	986	to create an STL range). Edge weights are typically derived from an edge
	987	indicator such as the gradient magnitude, and node features are either the
	988	responses of a filter family (when clustering on the pixel grid), or region
	989	statistics as computed by \ref FeatureAccumulators (when clustering on
	990	superpixels).
	991
	992	In each step, the algorithm merges the two nodes \f$u\f$ and \f$v\f$ whose
	993	cluster distance is smallest, where the cluster distance is defined as
	994
	995	\f[
	996	d_{uv} = \left( (1-\beta) w_{uv} + \beta \|\| f_u - f_v \|\|_M \right)
	997	\cdot \frac{2}{s_u^{-\omega} + s_v^{-\omega}}
	998	\f]
	999
	1000	with \f$ w_{uv} \f$ denoting the weight of edge \f$uv\f$, \f$f_u\f$ and \f$f_v\f$
	1001	being the node features (possibly vectors to be compared with metric \f$M\f$),
	1002	and \f$s_u\f$ and \f$s_v\f$ the corresponding node sizes. The metric is defined
	1003	in the option object by calling \ref vigra::ClusteringOptions::nodeFeatureMetric()
	1004	and must be selected from the tags defined in \ref vigra::metrics::MetricType.
	1005
	1006	The parameters \f$0 \le \beta \le 1\f$ and \f$0 \le \omega \le 1\f$ control the
	1007	relative influence of the inputs: With \f$\beta = 0\f$, the node features are
	1008	ignored, whereas with \f$\beta = 1\f$ the edge weights are ignored. Similarly,
	1009	with \f$\omega = 0\f$, the node size is ignored, whereas with \f$\omega = 1\f$,
	1010	cluster distances are scaled by the harmonic mean of the cluster sizes, making
	1011	the merging of small clusters more favorable. The parameters are defined in the
	1012	option object by calling \ref vigra::ClusteringOptions::nodeFeatureImportance() and
	1013	\ref vigra::ClusteringOptions::sizeImportance() respectively.
	1014
	1015	After each merging step, the features of the resulting cluster \f$z\f$ and the weights
	1016	of its outgoing edges are updated by mean of the corresponding properties of the original
	1017	clusters \f$u\f$ and \f$v\f$, weighted by the respective node sizes \f$s_z\f$ and
	1018	edge lengths \f$l_{zy}\f$:
	1019
	1020	\f{eqnarray*}{
	1021	s_z & = & s_u + s_v \\
	1022	f_z & = & \frac{s_u f_u + s_v f_v}{s_z} \\
	1023	l_{zy} & = & l_{uy} + l_{vy} \textrm{ for all nodes }y\textrm{ connected to }u\textrm{ or }v \\
	1024	w_{zy} & = & \frac{l_{uy} w_{uy} + l_{vy} w_{vy}}{l_{zy}}
	1025	\f}
	1026
	1027	Clustering normally stops when only one cluster remains. This default can be overridden
	1028	by the option object parameters \ref vigra::ClusteringOptions::minRegionCount()
	1029	and \ref vigra::ClusteringOptions::maxMergeDistance() to stop at a particular number of
	1030	clusters or a particular cluster distance respectively.
	1031
	1032	<b> Usage:</b>
	1033
	1034	<b>\#include</b> \<vigra/hierarchical_clustering.hxx\><br>
	1035	Namespace: vigra
	1036
	1037	A fully worked example can be found in <a href="graph_agglomerative_clustering_8cxx-example.html">graph_agglomerative_clustering.cxx</a>
	1038	*/
	1039	doxygen_overloaded_function(template <...> void hierarchicalClustering)
	1040
	1041	template <class GRAPH,
	1042	class EDGE_WEIGHT_MAP, class EDGE_LENGTH_MAP,
	1043	class NODE_FEATURE_MAP, class NOSE_SIZE_MAP,
	1044	class NODE_LABEL_MAP>
	1045	void
	1046	hierarchicalClustering(GRAPH const & graph,
	1047	EDGE_WEIGHT_MAP const & edgeWeights, EDGE_LENGTH_MAP const & edgeLengths,
	1048	NODE_FEATURE_MAP const & nodeFeatures, NOSE_SIZE_MAP const & nodeSizes,
	1049	NODE_LABEL_MAP & labelMap,
	1050	ClusteringOptions options = ClusteringOptions())
	1051	{
	1052	typedef typename NODE_LABEL_MAP::Value LabelType;
	1053	typedef MergeGraphAdaptor<GRAPH> MergeGraph;
	1054	typedef typename GRAPH::template EdgeMap<float> EdgeUltrametric;
	1055	typedef typename GRAPH::template NodeMap<LabelType> NodeSeeds;
	1056
	1057	MergeGraph mergeGraph(graph);
	1058
	1059	// create property maps to store the computed ultrametric and
	1060	// to provide optional cannot-link constraints;
	1061	// we don't use these options here and therefore leave the maps empty
	1062	EdgeUltrametric edgeUltrametric(graph);
	1063	NodeSeeds nodeSeeds(graph);
	1064
	1065	// create an operator that stores all property maps needed for
	1066	// hierarchical clustering and updates them after every merge step
	1067	typedef cluster_operators::EdgeWeightNodeFeatures<
	1068	MergeGraph,
	1069	EDGE_WEIGHT_MAP,
	1070	EDGE_LENGTH_MAP,
	1071	NODE_FEATURE_MAP,
	1072	NOSE_SIZE_MAP,
	1073	EdgeUltrametric,
	1074	NodeSeeds>
	1075	MergeOperator;
	1076
	1077	MergeOperator mergeOperator(mergeGraph,
	1078	edgeWeights, edgeLengths,
	1079	nodeFeatures, nodeSizes,
	1080	edgeUltrametric, nodeSeeds,
	1081	options.nodeFeatureImportance_,
	1082	options.nodeFeatureMetric_,
	1083	options.sizeImportance_,
	1084	options.maxMergeWeight_);
	1085
	1086	typedef HierarchicalClusteringImpl<MergeOperator> Clustering;
	1087
	1088	Clustering clustering(mergeOperator, options);
	1089	clustering.cluster();
	1090
	1091	for(typename GRAPH::NodeIt node(graph); node != lemon::INVALID; ++node)
	1092	{
	1093	labelMap[node] = mergeGraph.reprNodeId(graph.id(node));
	1094	}
794	1095	}
795	1096
	1097	//@}
	1098
	1099	} // namespace vigra
	1100
796	1101	#endif // VIGRA_HIERARCHICAL_CLUSTERING_HXX

+1

-2

include/vigra/histogram.hxx less more

156	156
157	157	void getBinCenters(ArrayVector<DataType> * centers) const
158	158	{
159		double invScale = 1.0 / scale_;
160	159	for(int k=0; k < size_; ++k)
161	160	{
162	161	(*centers)[k] = mapItemInverse(k + 0.5) ;

347	346
348	347	public:
349	348	Histogram(DataType const & min, DataType const & max, int binCount,
350		BinType * bins = 0, int stride = 1)
	349	BinType * /bins/ = 0, int /stride/ = 1)
351	350	: BaseType(min, max, binCount),
352	351	data_(binCount)
353	352	{

+1

-1

include/vigra/imagecontainer.hxx less more

762	762	/** swap contents of this array with the contents of other
763	763	(STL-Container interface)
764	764	*/
765		void swap(const ImagePyramid<ImageType, Alloc> &other)
	765	void swap(ImagePyramid<ImageType, Alloc> &other)
766	766	{
767	767	images_.swap(other.images_);
768	768	std::swap(lowestLevel_, other.lowestLevel_);

+1

-1

include/vigra/integral_image.hxx less more

78	78
79	79	cumulativeSum(array, intarray, 0, f);
80	80
81		for(int axis=1; axis < N; ++axis)
	81	for(unsigned axis=1; axis < N; ++axis)
82	82	cumulativeSum(intarray, intarray, axis, functor::Identity());
83	83	}
84	84

+93

-52

include/vigra/labelimage.hxx less more

706	706	/* */
707	707	/********************************************************/
708	708
	709
	710	enum EdgeImageLabelPolicy { CopyRegionLabels, EdgeOverlayOnly };
	711
	712
709	713	/** \brief Transform a labeled image into a crack edge (interpixel edge) image.
710	714
711	715	<b> Declarations:</b>

718	722	void
719	723	regionImageToCrackEdgeImage(MultiArrayView<2, T1, S1> const & src,
720	724	MultiArrayView<2, T2, S2> dest,
721		DestValue edge_marker);
	725	DestValue edge_marker,
	726	EdgeImageLabelPolicy labelPolicy = CopyRegionLabels);
722	727	}
723	728	\endcode
724	729

731	736	void regionImageToCrackEdgeImage(
732	737	SrcIterator sul, SrcIterator slr, SrcAccessor sa,
733	738	DestIterator dul, DestAccessor da,
734		DestValue edge_marker)
	739	DestValue edge_marker,
	740	EdgeImageLabelPolicy labelPolicy = CopyRegionLabels)
735	741	}
736	742	\endcode
737	743	use argument objects in conjunction with \ref ArgumentObjectFactories :

742	748	void regionImageToCrackEdgeImage(
743	749	triple<SrcIterator, SrcIterator, SrcAccessor> src,
744	750	pair<DestIterator, DestAccessor> dest,
745		DestValue edge_marker)
	751	DestValue edge_marker,
	752	EdgeImageLabelPolicy labelPolicy = CopyRegionLabels)
746	753	}
747	754	\endcode
748	755	\deprecatedEnd
749	756
750		This algorithm inserts border pixels (so called "crack edges" or "interpixel edges")
751		between regions in a labeled image like this (<TT>a</TT> and
752		<TT>c</TT> are the original labels, and <TT>0</TT> is the value of
753		<TT>edge_marker</TT> and denotes the inserted edges):
754
755		\code
756		original image insert zero- and one-cells
	757	The destination image must be twice the size of the input image (precisely,
	758	<TT>(2w-1)</TT> by <TT>(2h-1)</TT> pixels) to have space for the so called
	759	"crack edges" or "interpixel edges" which are logically situated between pixels
	760	(at half-integer coordinates of the input image) and correspond to the odd-valued
	761	coordinates in the result image (see \ref CrackEdgeImage for more details).
	762
	763	When <tt>labelPolicy == CopyRegionLabels</tt> (the default), this algorithm
	764	transfers the labels of a labeled image to the output image (repeating them
	765	as appropriate to account for the output image size) and inserts border pixels
	766	when the label changes. For example, if <TT>a</TT> and <TT>c</TT> are the
	767	original labels, and <TT>0</TT> is the value of <TT>edge_marker</TT>, the
	768	transformation looks like this:
	769
	770	\code
	771	original image copy labels and insert edges
757	772
758	773	a 0 c c c
759	774	a c c a 0 0 0 c

762	777	a a a a a
763	778	\endcode
764	779
	780	When <tt>labelPolicy == EdgeOverlayOnly</tt>, the region pixels of the output
	781	image remain untouched, and only the edge marker is inserted. This is especially
	782	useful for visualization, when the output is the interpolated original image:
	783	\code
	784	original image destination image overlay edges only
	785
	786	d d d d d d 0 d d d
	787	a c c d d d d d d 0 0 0 d
	788	a a c + d d d d d => d d d 0 d
	789	a a a d d d d d d d d 0 0
	790	d d d d d d d d d d
	791	\endcode
	792
765	793	The algorithm assumes that the original labeled image contains
766	794	no background. Therefore, it is suitable as a post-processing
767	795	operation of \ref labelImage() or \ref seededRegionGrowing().
768	796
769		The destination image must be twice the size of the original
770		(precisely, <TT>(2w-1)</TT> by <TT>(2h-1)</TT> pixels). The
771		source value type (<TT>SrcAccessor::value-type</TT>) must be
	797	The source value type (<TT>SrcAccessor::value-type</TT>) must be
772	798	equality-comparable.
773	799
774	800	<b> Usage:</b>

840	866	void regionImageToCrackEdgeImage(
841	867	SrcIterator sul, SrcIterator slr, SrcAccessor sa,
842	868	DestIterator dul, DestAccessor da,
843		DestValue edge_marker)
	869	DestValue edge_marker,
	870	EdgeImageLabelPolicy labelPolicy = CopyRegionLabels)
844	871	{
845	872	int w = slr.x - sul.x;
846	873	int h = slr.y - sul.y;

862	889
863	890	for(x=0; x<w-1; ++x, ++ix.x, dx.x+=2)
864	891	{
	892	if(labelPolicy == CopyRegionLabels)
	893	{
	894	da.set(sa(ix), dx);
	895	da.set(sa(ix), dx, bottomright);
	896	}
	897
	898	if(sa(ix, right) != sa(ix))
	899	{
	900	da.set(edge_marker, dx, right);
	901	}
	902	else if(labelPolicy == CopyRegionLabels)
	903	{
	904	da.set(sa(ix), dx, right);
	905	}
	906	if(sa(ix, bottom) != sa(ix))
	907	{
	908	da.set(edge_marker, dx, bottom);
	909	}
	910	else if(labelPolicy == CopyRegionLabels)
	911	{
	912	da.set(sa(ix), dx, bottom);
	913	}
	914
	915	}
	916
	917	if(labelPolicy == CopyRegionLabels)
	918	{
865	919	da.set(sa(ix), dx);
866		da.set(sa(ix), dx, bottomright);
867
868		if(sa(ix, right) != sa(ix))
869		{
870		da.set(edge_marker, dx, right);
871		}
872		else
873		{
874		da.set(sa(ix), dx, right);
875		}
876		if(sa(ix, bottom) != sa(ix))
877		{
878		da.set(edge_marker, dx, bottom);
879		}
880		else
881		{
882		da.set(sa(ix), dx, bottom);
883		}
884
885		}
886
887		da.set(sa(ix), dx);
	920	}
888	921	if(sa(ix, bottom) != sa(ix))
889	922	{
890	923	da.set(edge_marker, dx, bottom);
891	924	}
892		else
	925	else if(labelPolicy == CopyRegionLabels)
893	926	{
894	927	da.set(sa(ix), dx, bottom);
895	928	}

900	933
901	934	for(x=0; x<w-1; ++x, ++ix.x, dx.x+=2)
902	935	{
	936	if(labelPolicy == CopyRegionLabels)
	937	{
	938	da.set(sa(ix), dx);
	939	}
	940	if(sa(ix, right) != sa(ix))
	941	{
	942	da.set(edge_marker, dx, right);
	943	}
	944	else if(labelPolicy == CopyRegionLabels)
	945	{
	946	da.set(sa(ix), dx, right);
	947	}
	948	}
	949	if(labelPolicy == CopyRegionLabels)
	950	{
903	951	da.set(sa(ix), dx);
904		if(sa(ix, right) != sa(ix))
905		{
906		da.set(edge_marker, dx, right);
907		}
908		else
909		{
910		da.set(sa(ix), dx, right);
911		}
912		}
913		da.set(sa(ix), dx);
914
	952	}
915	953	dy = dul + Diff2D(1,1);
916	954
917	955	const Diff2D dist[] = {right, top, left, bottom };

938	976	inline void
939	977	regionImageToCrackEdgeImage(triple<SrcIterator, SrcIterator, SrcAccessor> src,
940	978	pair<DestIterator, DestAccessor> dest,
941		DestValue edge_marker)
	979	DestValue edge_marker,
	980	EdgeImageLabelPolicy labelPolicy = CopyRegionLabels)
942	981	{
943	982	regionImageToCrackEdgeImage(src.first, src.second, src.third,
944	983	dest.first, dest.second,
945		edge_marker);
	984	edge_marker, labelPolicy);
946	985	}
947	986
948	987	template <class T1, class S1,

950	989	inline void
951	990	regionImageToCrackEdgeImage(MultiArrayView<2, T1, S1> const & src,
952	991	MultiArrayView<2, T2, S2> dest,
953		DestValue edge_marker)
	992	DestValue edge_marker,
	993	EdgeImageLabelPolicy labelPolicy = CopyRegionLabels)
954	994	{
955	995	vigra_precondition(2*src.shape()-Shape2(1) == dest.shape(),
956	996	"regionImageToCrackEdgeImage(): shape mismatch between input and output.");
957	997	regionImageToCrackEdgeImage(srcImageRange(src),
958	998	destImage(dest),
959		edge_marker);
	999	edge_marker,
	1000	labelPolicy);
960	1001	}
961	1002
962	1003	/********************************************************/

+61

-8

include/vigra/linear_solve.hxx less more

58	58
59	59	MultiArrayIndex m = rowCount(a), n = columnCount(a);
60	60	vigra_precondition(n == m,
61		"determinant(): square matrix required.");
62
	61	"determinantByLUDecomposition(): square matrix required.");
	62	vigra_precondition(NumericTraits<T>::isIntegral::value == false,
	63	"determinantByLUDecomposition(): Input matrix must not be an integral type.");
	64
63	65	Matrix<T> LU(a);
64	66	T det = 1.0;
65	67

90	92	break; // det is zero
91	93	}
92	94	return det;
	95	}
	96
	97	template <class T, class C1>
	98	typename NumericTraits<T>::Promote
	99	determinantByMinors(MultiArrayView<2, T, C1> const & mat)
	100	{
	101	typedef typename NumericTraits<T>::Promote PromoteType;
	102	MultiArrayIndex m = rowCount(mat);
	103	MultiArrayIndex n = columnCount(mat);
	104	vigra_precondition(
	105	n == m,
	106	"determinantByMinors(): square matrix required.");
	107	vigra_precondition(
	108	NumericTraits<PromoteType>::isSigned::value,
	109	"determinantByMinors(): promote type must be signed.");
	110	if (m == 1)
	111	{
	112	return mat(0, 0);
	113	}
	114	else
	115	{
	116	Matrix<T> minor_mat(Shape2(m-1, n-1));
	117	PromoteType det = NumericTraits<PromoteType>::zero();
	118	for (MultiArrayIndex i = 0; i < m; i++)
	119	{
	120	for (MultiArrayIndex j = 0, jj = 0; j < (m - 1); j++, jj++)
	121	{
	122	if (j == i)
	123	{
	124	jj++;
	125	}
	126	rowVector(minor_mat, j) = rowVector(mat, Shape2(jj, 1), m);
	127	}
	128	const PromoteType sign = 1 - 2 * (i % 2);
	129	det += sign * mat(i, 0) * determinantByMinors(minor_mat);
	130	}
	131	return det;
	132	}
93	133	}
94	134
95	135	// returns the new value of 'a' (when this Givens rotation is applied to 'a' and 'b')

800	840
801	841	\a method must be one of the following:
802	842	<DL>
	843	<DT>"default"<DD> Use "minor" for integral types and "LU" for any other.
803	844	<DT>"Cholesky"<DD> Compute the solution by means of Cholesky decomposition. This
804	845	method is faster than "LU", but requires the matrix \a a
805	846	to be symmetric positive definite. If this is
806	847	not the case, a <tt>ContractViolation</tt> exception is thrown.
807
808		<DT>"LU"<DD> (default) Compute the solution by means of LU decomposition.
	848	<DT>"LU"<DD> Compute the solution by means of LU decomposition.
	849	<DT>"minor"<DD> Compute the solution by means of determinants of minors.
809	850	</DL>
810	851
811	852	<b>\#include</b> \<vigra/linear_solve.hxx\> or<br>

813	854	Namespaces: vigra and vigra::linalg
814	855	*/
815	856	template <class T, class C1>
816		T determinant(MultiArrayView<2, T, C1> const & a, std::string method = "LU")
817		{
	857	typename NumericTraits<T>::Promote
	858	determinant(MultiArrayView<2, T, C1> const & a, std::string method = "default")
	859	{
	860	typedef typename NumericTraits<T>::Promote PromoteType;
818	861	MultiArrayIndex n = columnCount(a);
819	862	vigra_precondition(rowCount(a) == n,
820	863	"determinant(): Square matrix required.");
821	864
822	865	method = tolower(method);
823
	866
	867	if(method == "default")
	868	{
	869	method = NumericTraits<T>::isIntegral::value ? "minor" : "lu";
	870	}
824	871	if(n == 1)
825	872	return a(0,0);
826	873	if(n == 2)

828	875	if(method == "lu")
829	876	{
830	877	return detail::determinantByLUDecomposition(a);
	878	}
	879	else if(method == "minor")
	880	{
	881	return detail::determinantByMinors(a);
831	882	}
832	883	else if(method == "cholesky")
833	884	{

843	894	{
844	895	vigra_precondition(false, "determinant(): Unknown solution method.");
845	896	}
846		return T();
	897	return PromoteType();
847	898	}
848	899
849	900	/** Compute the logarithm of the determinant of a symmetric positive definite matrix.

908	959	MultiArrayView<2, T, C2> &L)
909	960	{
910	961	MultiArrayIndex n = columnCount(A);
	962	vigra_precondition(NumericTraits<T>::isIntegral::value == false,
	963	"choleskyDecomposition(): Input matrix must not be an integral type.");
911	964	vigra_precondition(rowCount(A) == n,
912	965	"choleskyDecomposition(): Input matrix must be square.");
913	966	vigra_precondition(n == columnCount(L) && n == rowCount(L),

+2

-2

include/vigra/localminmax.hxx less more

179	179	localMinMax3D(SrcIterator sul, SrcShape shp, SrcAccessor sa,
180	180	DestIterator dul, DestAccessor da,
181	181	DestValue marker,
182		Neighborhood neighborhood,
	182	Neighborhood,
183	183	typename SrcAccessor::value_type threshold,
184	184	Compare compare,
185	185	bool allowExtremaAtBorder = false)

348	348	DestValue marker,
349	349	Neighborhood neighbourhood,
350	350	Compare compare,
351		Equal equal,
	351	Equal,
352	352	typename SrcAccessor::value_type threshold,
353	353	bool allowExtremaAtBorder = false)
354	354	{

+27

-3

include/vigra/mathutil.hxx less more

162	162
163	163	using std::isinf;
164	164	using std::isnan;
	165	using std::isfinite;
165	166
166	167	#else
167	168
168	169	template <class REAL>
169	170	inline bool isinf(REAL v)
170	171	{
171		return _finite(v) == 0;
	172	return _finite(v) == 0 && _isnan(v) == 0;
172	173	}
173	174
174	175	template <class REAL>
175	176	inline bool isnan(REAL v)
176	177	{
177	178	return _isnan(v) != 0;
	179	}
	180
	181	template <class REAL>
	182	inline bool isfinite(REAL v)
	183	{
	184	return _finite(v) != 0;
178	185	}
179	186
180	187	#endif

264	271	: (long long)(t - 0.5);
265	272	}
266	273
	274	/** \brief Determine whether x is a power of 2
	275	Bit twiddle from https://graphics.stanford.edu/~seander/bithacks.html#DetermineIfPowerOf2
	276	*/
	277	inline bool isPower2(UInt32 x)
	278	{
	279	return x && !(x & (x - 1));
	280	}
	281
	282
267	283	/** \brief Round up to the nearest power of 2.
268	284
269	285	Efficient algorithm for finding the smallest power of 2 which is not smaller than \a x

286	302	x = x \| (x >>16);
287	303	return x + 1;
288	304	}
	305
289	306
290	307	/** \brief Round down to the nearest power of 2.
291	308

727	744	This uses a numerically stable version of the analytical eigenvalue formula according to
728	745	<p>
729	746	David Eberly: <a href="http://www.geometrictools.com/Documentation/EigenSymmetric3x3.pdf">
730		<em>"Eigensystems for 3 × 3 Symmetric Matrices (Revisited)"</em></a>, Geometric Tools Documentation, 2006
	747	<em>"Eigensystems for 3 x 3 Symmetric Matrices (Revisited)"</em></a>, Geometric Tools Documentation, 2006
731	748
732	749	<b>\#include</b> \<vigra/mathutil.hxx\><br>
733	750	Namespace: vigra

1725	1742	}
1726	1743
1727	1744
	1745	#ifdef __GNUC__
	1746	#pragma GCC diagnostic push
	1747	#pragma GCC diagnostic ignored "-Wtype-limits"
	1748	#endif
	1749
1728	1750	VIGRA_MATH_FUNC_HELPER(unsigned char)
1729	1751	VIGRA_MATH_FUNC_HELPER(unsigned short)
1730	1752	VIGRA_MATH_FUNC_HELPER(unsigned int)

1739	1761	VIGRA_MATH_FUNC_HELPER(double)
1740	1762	VIGRA_MATH_FUNC_HELPER(long double)
1741	1763
1742
	1764	#ifdef __GNUC__
	1765	#pragma GCC diagnostic pop
	1766	#endif
1743	1767
1744	1768	#undef VIGRA_MATH_FUNC_HELPER
1745	1769

+39

-41

include/vigra/matlab.hxx less more

54	54
55	55	namespace matlab {
56	56
	57	/++++++++++++++++++++++++++HELPERFUNC+++++++++++++++++++++++++++++++
	58	* This is used for better readability of the test cases .
	59	* Nothing to be done here.
	60	+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++/
	61	int cantorPair(int x, int y){
	62	return (int)(((x+y)*(x+y+1))/2+y);
	63	}
	64
	65	int cantorPair(int x, int y, int z){
	66	return cantorPair(cantorPair(x,y),z);
	67	}
	68
	69	template <int x, int y>
	70	struct cP{
	71	enum { value = (int)(((x+y)*(x+y+1))/2+y)};
	72	};
	73
	74	template <int x, int y, int z>
	75	struct cP3{
	76	enum { value = cP<cP<x, y>::value, z>::value};
	77	};
	78
	79	template <class T>
	80	inline bool is_in_range(T in, T min, T max)
	81	{
	82	return (in >= min && in <= max);
	83	}
	84	template<class T>
	85	inline bool is_in_range(T in, std::string min, T max)
	86	{
	87	return(in <= max);
	88	}
	89
	90	template<class T>
	91	inline bool is_in_range(T in, T min, std::string max)
	92	{
	93	return (in >= min);
	94	}
	95
57	96	template <class T>
58	97	struct ValueType;
59	98

1083	1122	using namespace vigra;
1084	1123
1085	1124
1086		/++++++++++++++++++++++++++HELPERFUNC+++++++++++++++++++++++++++++++
1087		* This is used for better readability of the test cases .
1088		* Nothing to be done here.
1089		+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++/
1090		int cantorPair(int x, int y){
1091		return (int)(((x+y)*(x+y+1))/2+y);
1092		}
1093
1094		int cantorPair(int x, int y, int z){
1095		return cantorPair(cantorPair(x,y),z);
1096		}
1097
1098		template <int x, int y>
1099		struct cP{
1100		enum { value = (int)(((x+y)*(x+y+1))/2+y)};
1101		};
1102
1103		template <int x, int y, int z>
1104		struct cP3{
1105		enum { value = cP<cP<x, y>::value, z>::value};
1106		};
1107
1108		template <class T>
1109		inline bool is_in_range(T in, T min, T max)
1110		{
1111		return (in >= min && in <= max);
1112		}
1113		template<class T>
1114		inline bool is_in_range(T in, std::string min, T max)
1115		{
1116		return(in <= max);
1117		}
1118
1119		template<class T>
1120		inline bool is_in_range(T in, T min, std::string max)
1121		{
1122		return (in >= min);
1123		}
1124
1125
1126
1127	1125	//Wrapper classes to STL-Map for use as a sparse array.
1128	1126
1129	1127	//This is used for the ordering of the map. Lexicographical ordering of the index pairs.

+153

-151

include/vigra/matrix.hxx less more

55	55
56	56	/** \ingroup LinearAlgebraModule
57	57
	58	\brief Linear algebra functions.
	59
58	60	Namespace <tt>vigra/linalg</tt> hold VIGRA's linear algebra functionality. But most of its contents
59	61	is exported into namespace <tt>vigra</tt> via <tt>using</tt> directives.
60	62	*/

62	64	{
63	65
64	66	template <class T, class C>
65		inline MultiArrayIndex
	67	inline MultiArrayIndex
66	68	rowCount(const MultiArrayView<2, T, C> &x);
67	69
68	70	template <class T, class C>
69		inline MultiArrayIndex
	71	inline MultiArrayIndex
70	72	columnCount(const MultiArrayView<2, T, C> &x);
71	73
72	74	template <class T, class C>

94	96	/* */
95	97	/********************************************************/
96	98
97		/** Matrix class.
98
99		\ingroup LinearAlgebraModule
	99	/** Matrix class.
	100
	101	\ingroup LinearAlgebraModule
100	102
101	103	This is the basic class for all linear algebra computations. Matrices are
102	104	stored in a <i>column-major</i> format, i.e. the row index is varying fastest.

397	399	vigra::FindSum<T>() );
398	400	return result;
399	401	}
400
	402
401	403	/** sums over dimension \a d of the matrix.
402	404	*/
403	405	TemporaryMatrix<T> sum(difference_type_1 d) const

420	422	vigra::FindAverage<T>() );
421	423	return result;
422	424	}
423
	425
424	426	/** calculates mean over dimension \a d of the matrix.
425	427	*/
426	428	TemporaryMatrix<T> mean(difference_type_1 d) const

458	460	typename NormTraits<Matrix>::NormType norm() const;
459	461
460	462	/** create a transposed view of this matrix.
461		No data are copied. If you want to transpose this matrix permanently,
	463	No data are copied. If you want to transpose this matrix permanently,
462	464	you have to assign the transposed view:
463
	465
464	466	\code
465	467	a = a.transpose();
466	468	\endcode

585	587	{
586	588	this->swap(const_cast<TemporaryMatrix &>(rhs));
587	589	}
588
	590
589	591	template <class U>
590	592	TemporaryMatrix & init(const U & init)
591	593	{

652	654	/** \defgroup LinearAlgebraFunctions Matrix Functions
653	655
654	656	\brief Basic matrix algebra, element-wise mathematical functions, row and columns statistics, data normalization etc.
655
	657
656	658	\ingroup LinearAlgebraModule
657	659	*/
658	660	//@{

664	666	Namespaces: vigra and vigra::linalg
665	667	*/
666	668	template <class T, class C>
667		inline MultiArrayIndex
	669	inline MultiArrayIndex
668	670	rowCount(const MultiArrayView<2, T, C> &x)
669	671	{
670	672	return x.shape(0);

677	679	Namespaces: vigra and vigra::linalg
678	680	*/
679	681	template <class T, class C>
680		inline MultiArrayIndex
	682	inline MultiArrayIndex
681	683	columnCount(const MultiArrayView<2, T, C> &x)
682	684	{
683	685	return x.shape(1);

698	700	}
699	701
700	702
701		/** Create a row vector view of the matrix \a m starting at element \a first and ranging
	703	/** Create a row vector view of the matrix \a m starting at element \a first and ranging
702	704	to column \a end (non-inclusive).
703	705
704	706	<b>\#include</b> \<vigra/matrix.hxx\> or<br>

727	729	return m.subarray(Shape(0, d), Shape(rowCount(m), d+1));
728	730	}
729	731
730		/** Create a column vector view of the matrix \a m starting at element \a first and
	732	/** Create a column vector view of the matrix \a m starting at element \a first and
731	733	ranging to row \a end (non-inclusive).
732	734
733	735	<b>\#include</b> \<vigra/matrix.hxx\> or<br>

742	744	return m.subarray(first, Shape(end, first[1]+1));
743	745	}
744	746
745		/** Create a sub vector view of the vector \a m starting at element \a first and
	747	/** Create a sub vector view of the vector \a m starting at element \a first and
746	748	ranging to row \a end (non-inclusive).
747
	749
748	750	Note: This function may only be called when either <tt>rowCount(m) == 1</tt> or
749		<tt>columnCount(m) == 1</tt>, i.e. when \a m really represents a vector.
	751	<tt>columnCount(m) == 1</tt>, i.e. when \a m really represents a vector.
750	752	Otherwise, a PreconditionViolation exception is raised.
751	753
752	754	<b>\#include</b> \<vigra/matrix.hxx\> or<br>

760	762	typedef typename MultiArrayView <2, T, C>::difference_type Shape;
761	763	if(columnCount(m) == 1)
762	764	return m.subarray(Shape(first, 0), Shape(end, 1));
763		vigra_precondition(rowCount(m) == 1,
	765	vigra_precondition(rowCount(m) == 1,
764	766	"linalg::subVector(): Input must be a vector (1xN or Nx1).");
765	767	return m.subarray(Shape(0, first), Shape(1, end));
766	768	}

798	800	trace(MultiArrayView<2, T, C> const & m)
799	801	{
800	802	typedef typename NumericTraits<T>::Promote SumType;
801
	803
802	804	const MultiArrayIndex size = rowCount(m);
803	805	vigra_precondition(size == columnCount(m), "linalg::trace(): Matrix must be square.");
804	806

971	973	}
972	974
973	975	/** create the transpose of matrix \a v.
974		This does not copy any data, but only creates a transposed view
	976	This does not copy any data, but only creates a transposed view
975	977	to the original matrix. A copy is only made when the transposed view
976	978	is assigned to another matrix.
977	979	Usage:

988	990	Namespaces: vigra and vigra::linalg
989	991	*/
990	992	template <class T, class C>
991		inline MultiArrayView<2, T, StridedArrayTag>
	993	inline MultiArrayView<2, T, StridedArrayTag>
992	994	transpose(MultiArrayView<2, T, C> const & v)
993	995	{
994	996	return v.transpose();

1007	1009	joinVertically(const MultiArrayView<2, T, C1> &a, const MultiArrayView<2, T, C2> &b)
1008	1010	{
1009	1011	typedef typename TemporaryMatrix<T>::difference_type Shape;
1010
	1012
1011	1013	MultiArrayIndex n = columnCount(a);
1012	1014	vigra_precondition(n == columnCount(b),
1013	1015	"joinVertically(): shape mismatch.");
1014
	1016
1015	1017	MultiArrayIndex ma = rowCount(a);
1016	1018	MultiArrayIndex mb = rowCount(b);
1017	1019	TemporaryMatrix<T> t(ma + mb, n, T());

1033	1035	joinHorizontally(const MultiArrayView<2, T, C1> &a, const MultiArrayView<2, T, C2> &b)
1034	1036	{
1035	1037	typedef typename TemporaryMatrix<T>::difference_type Shape;
1036
	1038
1037	1039	MultiArrayIndex m = rowCount(a);
1038	1040	vigra_precondition(m == rowCount(b),
1039	1041	"joinHorizontally(): shape mismatch.");
1040
	1042
1041	1043	MultiArrayIndex na = columnCount(a);
1042	1044	MultiArrayIndex nb = columnCount(b);
1043	1045	TemporaryMatrix<T> t(m, na + nb, T());

1047	1049	}
1048	1050
1049	1051	/** Initialize a matrix with repeated copies of a given matrix.
1050
	1052
1051	1053	Matrix \a r will consist of \a verticalCount downward repetitions of \a v,
1052	1054	and \a horizontalCount side-by-side repetitions. When \a v has size <tt>m</tt> by <tt>n</tt>,
1053	1055	\a r must have size <tt>(mverticalCount)</tt> by <tt>(nhorizontalCount)</tt>.

1057	1059	Namespace: vigra::linalg
1058	1060	*/
1059	1061	template <class T, class C1, class C2>
1060		void repeatMatrix(MultiArrayView<2, T, C1> const & v, MultiArrayView<2, T, C2> &r,
	1062	void repeatMatrix(MultiArrayView<2, T, C1> const & v, MultiArrayView<2, T, C2> &r,
1061	1063	unsigned int verticalCount, unsigned int horizontalCount)
1062	1064	{
1063	1065	typedef typename Matrix<T>::difference_type Shape;

1065	1067	MultiArrayIndex m = rowCount(v), n = columnCount(v);
1066	1068	vigra_precondition(mverticalCount == rowCount(r) && nhorizontalCount == columnCount(r),
1067	1069	"repeatMatrix(): Shape mismatch.");
1068
	1070
1069	1071	for(MultiArrayIndex l=0; l<static_cast<MultiArrayIndex>(horizontalCount); ++l)
1070	1072	{
1071	1073	for(MultiArrayIndex k=0; k<static_cast<MultiArrayIndex>(verticalCount); ++k)

1076	1078	}
1077	1079
1078	1080	/** Create a new matrix by repeating a given matrix.
1079
	1081
1080	1082	The resulting matrix \a r will consist of \a verticalCount downward repetitions of \a v,
1081		and \a horizontalCount side-by-side repetitions, i.e. it will be of size
	1083	and \a horizontalCount side-by-side repetitions, i.e. it will be of size
1082	1084	<tt>(mverticalCount)</tt> by <tt>(nhorizontalCount)</tt> when \a v has size <tt>m</tt> by <tt>n</tt>.
1083	1085	The result is returned as a temporary matrix.
1084	1086

1087	1089	Namespace: vigra::linalg
1088	1090	*/
1089	1091	template <class T, class C>
1090		TemporaryMatrix<T>
	1092	TemporaryMatrix<T>
1091	1093	repeatMatrix(MultiArrayView<2, T, C> const & v, unsigned int verticalCount, unsigned int horizontalCount)
1092	1094	{
1093	1095	MultiArrayIndex m = rowCount(v), n = columnCount(v);

1325	1327	/** calculate the inner product of two matrices representing vectors.
1326	1328	Typically, matrix \a x has a single row, and matrix \a y has
1327	1329	a single column, and the other dimensions match. In addition, this
1328		function handles the cases when either or both of the two inputs are
1329		transposed (e.g. it can compute the dot product of two column vectors).
	1330	function handles the cases when either or both of the two inputs are
	1331	transposed (e.g. it can compute the dot product of two column vectors).
1330	1332	A <tt>PreconditionViolation</tt> exception is thrown when
1331		the shape conditions are violated.
	1333	the shape conditions are violated.
1332	1334
1333	1335	<b>\#include</b> \<vigra/matrix.hxx\> or<br>
1334	1336	<b>\#include</b> \<vigra/linear_algebra.hxx\><br>
1335	1337	Namespaces: vigra and vigra::linalg
1336	1338	*/
1337	1339	template <class T, class C1, class C2>
1338		typename NormTraits<T>::SquaredNormType
	1340	typename NormTraits<T>::SquaredNormType
1339	1341	dot(const MultiArrayView<2, T, C1> &x, const MultiArrayView<2, T, C2> &y)
1340	1342	{
1341		typename NormTraits<T>::SquaredNormType ret =
	1343	typename NormTraits<T>::SquaredNormType ret =
1342	1344	NumericTraits<typename NormTraits<T>::SquaredNormType>::zero();
1343	1345	if(y.shape(1) == 1)
1344	1346	{

1349	1351	else if(x.shape(1) == 1u && x.shape(0) == size) // two column vectors
1350	1352	for(std::ptrdiff_t i = 0; i < size; ++i)
1351	1353	ret += x(i, 0) * y(i, 0);
1352		else
	1354	else
1353	1355	vigra_precondition(false, "dot(): wrong matrix shapes.");
1354	1356	}
1355	1357	else if(y.shape(0) == 1)

1361	1363	else if(x.shape(1) == 1u && x.shape(0) == size) // column dot row
1362	1364	for(std::ptrdiff_t i = 0; i < size; ++i)
1363	1365	ret += x(i, 0) * y(0, i);
1364		else
	1366	else
1365	1367	vigra_precondition(false, "dot(): wrong matrix shapes.");
1366	1368	}
1367	1369	else

1377	1379	Namespaces: vigra and vigra::linalg
1378	1380	*/
1379	1381	template <class T, class C1, class C2>
1380		typename NormTraits<T>::SquaredNormType
	1382	typename NormTraits<T>::SquaredNormType
1381	1383	dot(const MultiArrayView<1, T, C1> &x, const MultiArrayView<1, T, C2> &y)
1382	1384	{
1383	1385	const MultiArrayIndex n = x.elementCount();
1384	1386	vigra_precondition(n == y.elementCount(),
1385	1387	"dot(): shape mismatch.");
1386		typename NormTraits<T>::SquaredNormType ret =
	1388	typename NormTraits<T>::SquaredNormType ret =
1387	1389	NumericTraits<typename NormTraits<T>::SquaredNormType>::zero();
1388	1390	for(MultiArrayIndex i = 0; i < n; ++i)
1389	1391	ret += x(i) * y(i);

1545	1547	{
1546	1548	public:
1547	1549	T const & t;
1548
	1550
1549	1551	PointWise(T const & it)
1550	1552	: t(it)
1551	1553	{}

1609	1611	"mmul(): Matrix shapes must agree.");
1610	1612
1611	1613	// order of loops ensures that inner loop goes down columns
1612		for(MultiArrayIndex i = 0; i < rcols; ++i)
1613		{
1614		for(MultiArrayIndex j = 0; j < rrows; ++j)
	1614	for(MultiArrayIndex i = 0; i < rcols; ++i)
	1615	{
	1616	for(MultiArrayIndex j = 0; j < rrows; ++j)
1615	1617	r(j, i) = a(j, 0) * b(0, i);
1616		for(MultiArrayIndex k = 1; k < acols; ++k)
1617		for(MultiArrayIndex j = 0; j < rrows; ++j)
	1618	for(MultiArrayIndex k = 1; k < acols; ++k)
	1619	for(MultiArrayIndex j = 0; j < rrows; ++j)
1618	1620	r(j, i) += a(j, k) * b(k, i);
1619	1621	}
1620	1622	}

1680	1682	/** multiply matrices \a a and \a b pointwise.
1681	1683	\a a and \a b must have matching shapes.
1682	1684	The result is returned as a temporary matrix.
1683
	1685
1684	1686	Usage:
1685
	1687
1686	1688	\code
1687	1689	Matrix<double> a(m,n), b(m,n);
1688
	1690
1689	1691	Matrix<double> c = a * pointWise(b);
1690	1692	// is equivalent to
1691	1693	// Matrix<double> c = pmul(a, b);

1867	1869	/** divide matrices \a a and \a b pointwise.
1868	1870	\a a and \a b must have matching shapes.
1869	1871	The result is returned as a temporary matrix.
1870
	1872
1871	1873	Usage:
1872
	1874
1873	1875	\code
1874	1876	Matrix<double> a(m,n), b(m,n);
1875
	1877
1876	1878	Matrix<double> c = a / pointWise(b);
1877	1879	// is equivalent to
1878	1880	// Matrix<double> c = pdiv(a, b);

1930	1932	using vigra::argMaxIf;
1931	1933
1932	1934	/** \brief Find the index of the minimum element in a matrix.
1933
	1935
1934	1936	The function returns the index in column-major scan-order sense,
1935	1937	i.e. according to the order used by <tt>MultiArrayView::operator[]</tt>.
1936	1938	If the matrix is actually a vector, this is just the row or columns index.
1937		In case of a truly 2-dimensional matrix, the index can be converted to an
	1939	In case of a truly 2-dimensional matrix, the index can be converted to an
1938	1940	index pair by calling <tt>MultiArrayView::scanOrderIndexToCoordinate()</tt>
1939
	1941
1940	1942	<b>Required Interface:</b>
1941
	1943
1942	1944	\code
1943	1945	bool f = a[0] < NumericTraits<T>::max();
1944	1946	\endcode

1963	1965	}
1964	1966
1965	1967	/** \brief Find the index of the maximum element in a matrix.
1966
	1968
1967	1969	The function returns the index in column-major scan-order sense,
1968	1970	i.e. according to the order used by <tt>MultiArrayView::operator[]</tt>.
1969	1971	If the matrix is actually a vector, this is just the row or columns index.
1970		In case of a truly 2-dimensional matrix, the index can be converted to an
	1972	In case of a truly 2-dimensional matrix, the index can be converted to an
1971	1973	index pair by calling <tt>MultiArrayView::scanOrderIndexToCoordinate()</tt>
1972
	1974
1973	1975	<b>Required Interface:</b>
1974
	1976
1975	1977	\code
1976	1978	bool f = NumericTraits<T>::min() < a[0];
1977	1979	\endcode

1996	1998	}
1997	1999
1998	2000	/** \brief Find the index of the minimum element in a matrix subject to a condition.
1999
	2001
2000	2002	The function returns <tt>-1</tt> if no element conforms to \a condition.
2001	2003	Otherwise, the index of the maximum element is returned in column-major scan-order sense,
2002	2004	i.e. according to the order used by <tt>MultiArrayView::operator[]</tt>.
2003	2005	If the matrix is actually a vector, this is just the row or columns index.
2004		In case of a truly 2-dimensional matrix, the index can be converted to an
	2006	In case of a truly 2-dimensional matrix, the index can be converted to an
2005	2007	index pair by calling <tt>MultiArrayView::scanOrderIndexToCoordinate()</tt>
2006
	2008
2007	2009	<b>Required Interface:</b>
2008
	2010
2009	2011	\code
2010	2012	bool c = condition(a[0]);
2011	2013	bool f = a[0] < NumericTraits<T>::max();

2031	2033	}
2032	2034
2033	2035	/** \brief Find the index of the maximum element in a matrix subject to a condition.
2034
	2036
2035	2037	The function returns <tt>-1</tt> if no element conforms to \a condition.
2036	2038	Otherwise, the index of the maximum element is returned in column-major scan-order sense,
2037	2039	i.e. according to the order used by <tt>MultiArrayView::operator[]</tt>.
2038	2040	If the matrix is actually a vector, this is just the row or columns index.
2039		In case of a truly 2-dimensional matrix, the index can be converted to an
	2041	In case of a truly 2-dimensional matrix, the index can be converted to an
2040	2042	index pair by calling <tt>MultiArrayView::scanOrderIndexToCoordinate()</tt>
2041
	2043
2042	2044	<b>Required Interface:</b>
2043
	2045
2044	2046	\code
2045	2047	bool c = condition(a[0]);
2046	2048	bool f = NumericTraits<T>::min() < a[0];

2347	2349
2348	2350	template <class T1, class C1, class T2, class C2, class T3, class C3>
2349	2351	void
2350		columnStatisticsImpl(MultiArrayView<2, T1, C1> const & A,
	2352	columnStatisticsImpl(MultiArrayView<2, T1, C1> const & A,
2351	2353	MultiArrayView<2, T2, C2> & mean, MultiArrayView<2, T3, C3> & sumOfSquaredDifferences)
2352	2354	{
2353	2355	MultiArrayIndex m = rowCount(A);

2359	2361	// West's algorithm for incremental variance computation
2360	2362	mean.init(NumericTraits<T2>::zero());
2361	2363	sumOfSquaredDifferences.init(NumericTraits<T3>::zero());
2362
	2364
2363	2365	for(MultiArrayIndex k=0; k<m; ++k)
2364	2366	{
2365	2367	typedef typename NumericTraits<T2>::RealPromote TmpType;

2373	2375
2374	2376	template <class T1, class C1, class T2, class C2, class T3, class C3>
2375	2377	void
2376		columnStatistics2PassImpl(MultiArrayView<2, T1, C1> const & A,
	2378	columnStatistics2PassImpl(MultiArrayView<2, T1, C1> const & A,
2377	2379	MultiArrayView<2, T2, C2> & mean, MultiArrayView<2, T3, C3> & sumOfSquaredDifferences)
2378	2380	{
2379	2381	MultiArrayIndex m = rowCount(A);

2383	2385	"columnStatistics(): Shape mismatch between input and output.");
2384	2386
2385	2387	// two-pass algorithm for incremental variance computation
2386		mean.init(NumericTraits<T2>::zero());
	2388	mean.init(NumericTraits<T2>::zero());
2387	2389	for(MultiArrayIndex k=0; k<m; ++k)
2388	2390	{
2389	2391	mean += rowVector(A, k);
2390	2392	}
2391	2393	mean /= static_cast<double>(m);
2392
	2394
2393	2395	sumOfSquaredDifferences.init(NumericTraits<T3>::zero());
2394	2396	for(MultiArrayIndex k=0; k<m; ++k)
2395	2397	{

2403	2405	*/
2404	2406	//@{
2405	2407	/** Compute statistics of every column of matrix \a A.
2406
	2408
2407	2409	The result matrices must be row vectors with as many columns as \a A.
2408	2410
2409	2411	<b> Declarations:</b>

2413	2415	namespace vigra { namespace linalg {
2414	2416	template <class T1, class C1, class T2, class C2>
2415	2417	void
2416		columnStatistics(MultiArrayView<2, T1, C1> const & A,
	2418	columnStatistics(MultiArrayView<2, T1, C1> const & A,
2417	2419	MultiArrayView<2, T2, C2> & mean);
2418	2420	} }
2419	2421	\endcode

2423	2425	namespace vigra { namespace linalg {
2424	2426	template <class T1, class C1, class T2, class C2, class T3, class C3>
2425	2427	void
2426		columnStatistics(MultiArrayView<2, T1, C1> const & A,
2427		MultiArrayView<2, T2, C2> & mean,
	2428	columnStatistics(MultiArrayView<2, T1, C1> const & A,
	2429	MultiArrayView<2, T2, C2> & mean,
2428	2430	MultiArrayView<2, T3, C3> & stdDev);
2429	2431	} }
2430	2432	\endcode

2434	2436	namespace vigra { namespace linalg {
2435	2437	template <class T1, class C1, class T2, class C2, class T3, class C3, class T4, class C4>
2436	2438	void
2437		columnStatistics(MultiArrayView<2, T1, C1> const & A,
2438		MultiArrayView<2, T2, C2> & mean,
2439		MultiArrayView<2, T3, C3> & stdDev,
	2439	columnStatistics(MultiArrayView<2, T1, C1> const & A,
	2440	MultiArrayView<2, T2, C2> & mean,
	2441	MultiArrayView<2, T3, C3> & stdDev,
2440	2442	MultiArrayView<2, T4, C4> & norm);
2441	2443	} }
2442	2444	\endcode

2460	2462
2461	2463	template <class T1, class C1, class T2, class C2>
2462	2464	void
2463		columnStatistics(MultiArrayView<2, T1, C1> const & A,
	2465	columnStatistics(MultiArrayView<2, T1, C1> const & A,
2464	2466	MultiArrayView<2, T2, C2> & mean)
2465	2467	{
2466	2468	MultiArrayIndex m = rowCount(A);

2469	2471	"columnStatistics(): Shape mismatch between input and output.");
2470	2472
2471	2473	mean.init(NumericTraits<T2>::zero());
2472
	2474
2473	2475	for(MultiArrayIndex k=0; k<m; ++k)
2474	2476	{
2475	2477	mean += rowVector(A, k);

2479	2481
2480	2482	template <class T1, class C1, class T2, class C2, class T3, class C3>
2481	2483	void
2482		columnStatistics(MultiArrayView<2, T1, C1> const & A,
	2484	columnStatistics(MultiArrayView<2, T1, C1> const & A,
2483	2485	MultiArrayView<2, T2, C2> & mean, MultiArrayView<2, T3, C3> & stdDev)
2484	2486	{
2485	2487	detail::columnStatisticsImpl(A, mean, stdDev);
2486
	2488
2487	2489	if(rowCount(A) > 1)
2488	2490	stdDev = sqrt(stdDev / T3(rowCount(A) - 1.0));
2489	2491	}
2490	2492
2491	2493	template <class T1, class C1, class T2, class C2, class T3, class C3, class T4, class C4>
2492	2494	void
2493		columnStatistics(MultiArrayView<2, T1, C1> const & A,
	2495	columnStatistics(MultiArrayView<2, T1, C1> const & A,
2494	2496	MultiArrayView<2, T2, C2> & mean, MultiArrayView<2, T3, C3> & stdDev, MultiArrayView<2, T4, C4> & norm)
2495	2497	{
2496	2498	MultiArrayIndex m = rowCount(A);

2506	2508	}
2507	2509
2508	2510	/** Compute statistics of every row of matrix \a A.
2509
	2511
2510	2512	The result matrices must be column vectors with as many rows as \a A.
2511	2513
2512	2514	<b> Declarations:</b>

2516	2518	namespace vigra { namespace linalg {
2517	2519	template <class T1, class C1, class T2, class C2>
2518	2520	void
2519		rowStatistics(MultiArrayView<2, T1, C1> const & A,
	2521	rowStatistics(MultiArrayView<2, T1, C1> const & A,
2520	2522	MultiArrayView<2, T2, C2> & mean);
2521	2523	} }
2522	2524	\endcode

2526	2528	namespace vigra { namespace linalg {
2527	2529	template <class T1, class C1, class T2, class C2, class T3, class C3>
2528	2530	void
2529		rowStatistics(MultiArrayView<2, T1, C1> const & A,
2530		MultiArrayView<2, T2, C2> & mean,
	2531	rowStatistics(MultiArrayView<2, T1, C1> const & A,
	2532	MultiArrayView<2, T2, C2> & mean,
2531	2533	MultiArrayView<2, T3, C3> & stdDev);
2532	2534	} }
2533	2535	\endcode

2537	2539	namespace vigra { namespace linalg {
2538	2540	template <class T1, class C1, class T2, class C2, class T3, class C3, class T4, class C4>
2539	2541	void
2540		rowStatistics(MultiArrayView<2, T1, C1> const & A,
2541		MultiArrayView<2, T2, C2> & mean,
2542		MultiArrayView<2, T3, C3> & stdDev,
	2542	rowStatistics(MultiArrayView<2, T1, C1> const & A,
	2543	MultiArrayView<2, T2, C2> & mean,
	2544	MultiArrayView<2, T3, C3> & stdDev,
2543	2545	MultiArrayView<2, T4, C4> & norm);
2544	2546	} }
2545	2547	\endcode

2563	2565
2564	2566	template <class T1, class C1, class T2, class C2>
2565	2567	void
2566		rowStatistics(MultiArrayView<2, T1, C1> const & A,
	2568	rowStatistics(MultiArrayView<2, T1, C1> const & A,
2567	2569	MultiArrayView<2, T2, C2> & mean)
2568	2570	{
2569	2571	vigra_precondition(1 == columnCount(mean) && rowCount(A) == rowCount(mean),

2574	2576
2575	2577	template <class T1, class C1, class T2, class C2, class T3, class C3>
2576	2578	void
2577		rowStatistics(MultiArrayView<2, T1, C1> const & A,
	2579	rowStatistics(MultiArrayView<2, T1, C1> const & A,
2578	2580	MultiArrayView<2, T2, C2> & mean, MultiArrayView<2, T3, C3> & stdDev)
2579	2581	{
2580	2582	vigra_precondition(1 == columnCount(mean) && rowCount(A) == rowCount(mean) &&

2587	2589
2588	2590	template <class T1, class C1, class T2, class C2, class T3, class C3, class T4, class C4>
2589	2591	void
2590		rowStatistics(MultiArrayView<2, T1, C1> const & A,
	2592	rowStatistics(MultiArrayView<2, T1, C1> const & A,
2591	2593	MultiArrayView<2, T2, C2> & mean, MultiArrayView<2, T3, C3> & stdDev, MultiArrayView<2, T4, C4> & norm)
2592	2594	{
2593	2595	vigra_precondition(1 == columnCount(mean) && rowCount(A) == rowCount(mean) &&

2595	2597	1 == columnCount(norm) && rowCount(A) == rowCount(norm),
2596	2598	"rowStatistics(): Shape mismatch between input and output.");
2597	2599	MultiArrayView<2, T2, StridedArrayTag> tm = transpose(mean);
2598		MultiArrayView<2, T3, StridedArrayTag> ts = transpose(stdDev);
	2600	MultiArrayView<2, T3, StridedArrayTag> ts = transpose(stdDev);
2599	2601	MultiArrayView<2, T4, StridedArrayTag> tn = transpose(norm);
2600	2602	columnStatistics(transpose(A), tm, ts, tn);
2601	2603	}

2613	2615	"updateCovarianceMatrix(): Shape mismatch between feature vector and mean vector.");
2614	2616	vigra_precondition(n == rowCount(covariance) && n == columnCount(covariance),
2615	2617	"updateCovarianceMatrix(): Shape mismatch between feature vector and covariance matrix.");
2616
	2618
2617	2619	// West's algorithm for incremental covariance matrix computation
2618	2620	Matrix<T2> t = features - mean;
2619	2621	++count;
2620	2622	T2 f = T2(1.0) / count,
2621	2623	f1 = T2(1.0) - f;
2622	2624	mean += f*t;
2623
	2625
2624	2626	if(rowCount(features) == 1) // update column covariance from current row
2625	2627	{
2626	2628	for(MultiArrayIndex k=0; k<n; ++k)

2650	2652	} // namespace detail
2651	2653
2652	2654	/** \brief Compute the covariance matrix between the columns of a matrix \a features.
2653
	2655
2654	2656	The result matrix \a covariance must by a square matrix with as many rows and
2655	2657	columns as the number of columns in matrix \a features.
2656	2658

2673	2675	}
2674	2676
2675	2677	/** \brief Compute the covariance matrix between the columns of a matrix \a features.
2676
	2678
2677	2679	The result is returned as a square temporary matrix with as many rows and
2678	2680	columns as the number of columns in matrix \a features.
2679	2681

2681	2683	Namespace: vigra
2682	2684	*/
2683	2685	template <class T, class C>
2684		TemporaryMatrix<T>
	2686	TemporaryMatrix<T>
2685	2687	covarianceMatrixOfColumns(MultiArrayView<2, T, C> const & features)
2686	2688	{
2687	2689	TemporaryMatrix<T> res(columnCount(features), columnCount(features));

2690	2692	}
2691	2693
2692	2694	/** \brief Compute the covariance matrix between the rows of a matrix \a features.
2693
	2695
2694	2696	The result matrix \a covariance must by a square matrix with as many rows and
2695	2697	columns as the number of rows in matrix \a features.
2696	2698

2713	2715	}
2714	2716
2715	2717	/** \brief Compute the covariance matrix between the rows of a matrix \a features.
2716
	2718
2717	2719	The result is returned as a square temporary matrix with as many rows and
2718	2720	columns as the number of rows in matrix \a features.
2719	2721

2721	2723	Namespace: vigra
2722	2724	*/
2723	2725	template <class T, class C>
2724		TemporaryMatrix<T>
	2726	TemporaryMatrix<T>
2725	2727	covarianceMatrixOfRows(MultiArrayView<2, T, C> const & features)
2726	2728	{
2727	2729	TemporaryMatrix<T> res(rowCount(features), rowCount(features));

2740	2742
2741	2743	template <class T, class C1, class C2, class C3, class C4>
2742	2744	void
2743		prepareDataImpl(const MultiArrayView<2, T, C1> & A,
2744		MultiArrayView<2, T, C2> & res, MultiArrayView<2, T, C3> & offset, MultiArrayView<2, T, C4> & scaling,
	2745	prepareDataImpl(const MultiArrayView<2, T, C1> & A,
	2746	MultiArrayView<2, T, C2> & res, MultiArrayView<2, T, C3> & offset, MultiArrayView<2, T, C4> & scaling,
2745	2747	DataPreparationGoals goals)
2746	2748	{
2747	2749	MultiArrayIndex m = rowCount(A);
2748	2750	MultiArrayIndex n = columnCount(A);
2749		vigra_precondition(A.shape() == res.shape() &&
	2751	vigra_precondition(A.shape() == res.shape() &&
2750	2752	n == columnCount(offset) && 1 == rowCount(offset) &&
2751	2753	n == columnCount(scaling) && 1 == rowCount(scaling),
2752	2754	"prepareDataImpl(): Shape mismatch between input and output.");

2758	2760	scaling.init(NumericTraits<T>::one());
2759	2761	return;
2760	2762	}
2761
	2763
2762	2764	bool zeroMean = (goals & ZeroMean) != 0;
2763	2765	bool unitVariance = (goals & UnitVariance) != 0;
2764	2766	bool unitNorm = (goals & UnitNorm) != 0;

2768	2770	{
2769	2771	vigra_precondition(goals == UnitSum,
2770	2772	"prepareData(): Unit sum is not compatible with any other data preparation goal.");
2771
	2773
2772	2774	transformMultiArray(srcMultiArrayRange(A), destMultiArrayRange(scaling), FindSum<T>());
2773
	2775
2774	2776	offset.init(NumericTraits<T>::zero());
2775
	2777
2776	2778	for(MultiArrayIndex k=0; k<n; ++k)
2777	2779	{
2778	2780	if(scaling(0, k) != NumericTraits<T>::zero())

2785	2787	scaling(0, k) = NumericTraits<T>::one();
2786	2788	}
2787	2789	}
2788
2789		return;
	2790
	2791	return;
2790	2792	}
2791	2793
2792	2794	vigra_precondition(!(unitVariance && unitNorm),

2794	2796
2795	2797	Matrix<T> mean(1, n), sumOfSquaredDifferences(1, n);
2796	2798	detail::columnStatisticsImpl(A, mean, sumOfSquaredDifferences);
2797
	2799
2798	2800	for(MultiArrayIndex k=0; k<n; ++k)
2799	2801	{
2800	2802	T stdDev = std::sqrt(sumOfSquaredDifferences(0, k) / T(m-1));
2801	2803	if(closeAtTolerance(stdDev / mean(0,k), NumericTraits<T>::zero()))
2802	2804	stdDev = NumericTraits<T>::zero();
2803		if(zeroMean && stdDev > NumericTraits<T>::zero())
	2805	if(zeroMean && stdDev > NumericTraits<T>::zero())
2804	2806	{
2805	2807	columnVector(res, k) = columnVector(A, k) - mean(0,k);
2806	2808	offset(0, k) = mean(0, k);
2807	2809	mean(0, k) = NumericTraits<T>::zero();
2808	2810	}
2809		else
	2811	else
2810	2812	{
2811	2813	columnVector(res, k) = columnVector(A, k);
2812	2814	offset(0, k) = NumericTraits<T>::zero();
2813	2815	}
2814
	2816
2815	2817	T norm = mean(0,k) == NumericTraits<T>::zero()
2816	2818	? std::sqrt(sumOfSquaredDifferences(0, k))
2817	2819	: std::sqrt(sumOfSquaredDifferences(0, k) + T(m) * sq(mean(0,k)));

2835	2837	} // namespace detail
2836	2838
2837	2839	/** \brief Standardize the columns of a matrix according to given <tt>DataPreparationGoals</tt>.
2838
2839		For every column of the matrix \a A, this function computes mean,
2840		standard deviation, and norm. It then applies a linear transformation to the values of
	2840
	2841	For every column of the matrix \a A, this function computes mean,
	2842	standard deviation, and norm. It then applies a linear transformation to the values of
2841	2843	the column according to these statistics and the given <tt>DataPreparationGoals</tt>.
2842	2844	The result is returned in matrix \a res which must have the same size as \a A.
2843	2845	Optionally, the transformation applied can also be returned in the matrices \a offset
2844	2846	and \a scaling (see below for an example how these matrices can be used to standardize
2845	2847	more data according to the same transformation).
2846
	2848
2847	2849	The following <tt>DataPreparationGoals</tt> are supported:
2848
	2850
2849	2851	<DL>
2850		<DT><tt>ZeroMean</tt><DD> Subtract the column mean form every column if the values in the column are not constant.
	2852	<DT><tt>ZeroMean</tt><DD> Subtract the column mean form every column if the values in the column are not constant.
2851	2853	Do nothing in a constant column.
2852		<DT><tt>UnitSum</tt><DD> Scale the columns so that the their sum is one if the sum was initially non-zero.
	2854	<DT><tt>UnitSum</tt><DD> Scale the columns so that the their sum is one if the sum was initially non-zero.
2853	2855	Do nothing in a zero-sum column.
2854		<DT><tt>UnitVariance</tt><DD> Divide by the column standard deviation if the values in the column are not constant.
	2856	<DT><tt>UnitVariance</tt><DD> Divide by the column standard deviation if the values in the column are not constant.
2855	2857	Do nothing in a constant column.
2856	2858	<DT><tt>UnitNorm</tt><DD> Divide by the column norm if it is non-zero.
2857		<DT><tt>ZeroMean \| UnitVariance</tt><DD> First subtract the mean and then divide by the standard deviation, unless the
	2859	<DT><tt>ZeroMean \| UnitVariance</tt><DD> First subtract the mean and then divide by the standard deviation, unless the
2858	2860	column is constant (in which case the column remains unchanged).
2859	2861	<DT><tt>ZeroMean \| UnitNorm</tt><DD> If the column is non-constant, subtract the mean. Then divide by the norm
2860	2862	of the result if the norm is non-zero.

2868	2870	namespace vigra { namespace linalg {
2869	2871	template <class T, class C1, class C2, class C3, class C4>
2870	2872	void
2871		prepareColumns(MultiArrayView<2, T, C1> const & A,
2872		MultiArrayView<2, T, C2> & res,
2873		MultiArrayView<2, T, C3> & offset,
2874		MultiArrayView<2, T, C4> & scaling,
	2873	prepareColumns(MultiArrayView<2, T, C1> const & A,
	2874	MultiArrayView<2, T, C2> & res,
	2875	MultiArrayView<2, T, C3> & offset,
	2876	MultiArrayView<2, T, C4> & scaling,
2875	2877	DataPreparationGoals goals = ZeroMean \| UnitVariance);
2876	2878	} }
2877	2879	\endcode

2881	2883	namespace vigra { namespace linalg {
2882	2884	template <class T, class C1, class C2>
2883	2885	void
2884		prepareColumns(MultiArrayView<2, T, C1> const & A,
2885		MultiArrayView<2, T, C2> & res,
	2886	prepareColumns(MultiArrayView<2, T, C1> const & A,
	2887	MultiArrayView<2, T, C2> & res,
2886	2888	DataPreparationGoals goals = ZeroMean \| UnitVariance);
2887	2889	} }
2888	2890	\endcode

2899	2901	Matrix standardizedA(rows, columns), offset(1, columns), scaling(1, columns);
2900	2902
2901	2903	prepareColumns(A, standardizedA, offset, scaling, ZeroMean \| UnitNorm);
2902
	2904
2903	2905	// use offset and scaling to prepare additional data according to the same transformation
2904	2906	Matrix newData(nrows, columns);
2905
	2907
2906	2908	Matrix standardizedNewData = (newData - repeatMatrix(offset, nrows, 1)) * pointWise(repeatMatrix(scaling, nrows, 1));
2907	2909
2908	2910	\endcode

2911	2913
2912	2914	template <class T, class C1, class C2, class C3, class C4>
2913	2915	inline void
2914		prepareColumns(MultiArrayView<2, T, C1> const & A,
2915		MultiArrayView<2, T, C2> & res, MultiArrayView<2, T, C3> & offset, MultiArrayView<2, T, C4> & scaling,
	2916	prepareColumns(MultiArrayView<2, T, C1> const & A,
	2917	MultiArrayView<2, T, C2> & res, MultiArrayView<2, T, C3> & offset, MultiArrayView<2, T, C4> & scaling,
2916	2918	DataPreparationGoals goals = ZeroMean \| UnitVariance)
2917	2919	{
2918	2920	detail::prepareDataImpl(A, res, offset, scaling, goals);

2920	2922
2921	2923	template <class T, class C1, class C2>
2922	2924	inline void
2923		prepareColumns(MultiArrayView<2, T, C1> const & A, MultiArrayView<2, T, C2> & res,
	2925	prepareColumns(MultiArrayView<2, T, C1> const & A, MultiArrayView<2, T, C2> & res,
2924	2926	DataPreparationGoals goals = ZeroMean \| UnitVariance)
2925	2927	{
2926	2928	Matrix<T> offset(1, columnCount(A)), scaling(1, columnCount(A));

2928	2930	}
2929	2931
2930	2932	/** \brief Standardize the rows of a matrix according to given <tt>DataPreparationGoals</tt>.
2931
	2933
2932	2934	This algorithm works in the same way as \ref prepareColumns() (see there for detailed
2933	2935	documentation), but is applied to the rows of the matrix \a A instead. Accordingly, the
2934	2936	matrices holding the parameters of the linear transformation must be column vectors

2939	2941	Standardize the matrix and return the parameters of the linear transformation.
2940	2942	The matrices \a offset and \a scaling must be column vectors
2941	2943	with as many rows as \a A.
2942
	2944
2943	2945	\code
2944	2946	namespace vigra { namespace linalg {
2945	2947	template <class T, class C1, class C2, class C3, class C4>
2946	2948	void
2947		prepareRows(MultiArrayView<2, T, C1> const & A,
2948		MultiArrayView<2, T, C2> & res,
2949		MultiArrayView<2, T, C3> & offset,
2950		MultiArrayView<2, T, C4> & scaling,
	2949	prepareRows(MultiArrayView<2, T, C1> const & A,
	2950	MultiArrayView<2, T, C2> & res,
	2951	MultiArrayView<2, T, C3> & offset,
	2952	MultiArrayView<2, T, C4> & scaling,
2951	2953	DataPreparationGoals goals = ZeroMean \| UnitVariance)´;
2952	2954	} }
2953	2955	\endcode

2957	2959	namespace vigra { namespace linalg {
2958	2960	template <class T, class C1, class C2>
2959	2961	void
2960		prepareRows(MultiArrayView<2, T, C1> const & A,
2961		MultiArrayView<2, T, C2> & res,
	2962	prepareRows(MultiArrayView<2, T, C1> const & A,
	2963	MultiArrayView<2, T, C2> & res,
2962	2964	DataPreparationGoals goals = ZeroMean \| UnitVariance);
2963	2965	} }
2964	2966	\endcode

2975	2977	Matrix standardizedA(rows, columns), offset(rows, 1), scaling(rows, 1);
2976	2978
2977	2979	prepareRows(A, standardizedA, offset, scaling, ZeroMean \| UnitNorm);
2978
	2980
2979	2981	// use offset and scaling to prepare additional data according to the same transformation
2980	2982	Matrix newData(rows, ncolumns);
2981
	2983
2982	2984	Matrix standardizedNewData = (newData - repeatMatrix(offset, 1, ncolumns)) * pointWise(repeatMatrix(scaling, 1, ncolumns));
2983	2985
2984	2986	\endcode

2987	2989
2988	2990	template <class T, class C1, class C2, class C3, class C4>
2989	2991	inline void
2990		prepareRows(MultiArrayView<2, T, C1> const & A,
2991		MultiArrayView<2, T, C2> & res, MultiArrayView<2, T, C3> & offset, MultiArrayView<2, T, C4> & scaling,
	2992	prepareRows(MultiArrayView<2, T, C1> const & A,
	2993	MultiArrayView<2, T, C2> & res, MultiArrayView<2, T, C3> & offset, MultiArrayView<2, T, C4> & scaling,
2992	2994	DataPreparationGoals goals = ZeroMean \| UnitVariance)
2993	2995	{
2994	2996	MultiArrayView<2, T, StridedArrayTag> tr = transpose(res), to = transpose(offset), ts = transpose(scaling);

2997	2999
2998	3000	template <class T, class C1, class C2>
2999	3001	inline void
3000		prepareRows(MultiArrayView<2, T, C1> const & A, MultiArrayView<2, T, C2> & res,
	3002	prepareRows(MultiArrayView<2, T, C1> const & A, MultiArrayView<2, T, C2> & res,
3001	3003	DataPreparationGoals goals = ZeroMean \| UnitVariance)
3002	3004	{
3003	3005	MultiArrayView<2, T, StridedArrayTag> tr = transpose(res);

+8

-9

include/vigra/merge_graph_adaptor.hxx less more

296	296	typedef MERGE_GRAPH Graph;
297	297	typedef typename Graph::Node Node;
298	298	// Invalid constructor & conversion.
299		MergeGraphNodeIt(const lemon::Invalid & invalid = lemon::INVALID)
	299	MergeGraphNodeIt(const lemon::Invalid & /invalid/ = lemon::INVALID)
300	300	: graph_(NULL),
301	301	nodeIdIt_(),
302	302	node_(){

345	345	typedef MERGE_GRAPH Graph;
346	346	typedef typename Graph::Edge Edge;
347	347	// Invalid constructor & conversion.
348		MergeGraphEdgeIt(const lemon::Invalid & invalid = lemon::INVALID)
	348	MergeGraphEdgeIt(const lemon::Invalid & /invalid/ = lemon::INVALID)
349	349	: graph_(NULL),
350	350	edgeIdIt_(),
351	351	edge_(){

399	399	typedef typename Graph::Arc Arc;
400	400	typedef typename Graph::Edge Edge;
401	401	typedef typename Graph::EdgeIt EdgeIt;
402		MergeGraphArcIt(const lemon::Invalid invalid = lemon::INVALID )
	402	MergeGraphArcIt(const lemon::Invalid /invalid/ = lemon::INVALID )
403	403	: graph_(NULL),
404	404	pos_(),
405	405	inFirstHalf_(false),

1138	1138	inline bool MergeGraphAdaptor<GRAPH>::stateOfInitalEdge(
1139	1139	const typename MergeGraphAdaptor<GRAPH>::IdType initalEdge
1140	1140	)const{
1141		const index_type rep = reprEdgeId(initalEdge);
1142	1141
1143	1142	const index_type rnid0= reprNodeId( graphUId(initalEdge) );
1144	1143	const index_type rnid1= reprNodeId( graphVId(initalEdge) );

1179	1178	nDoubleEdges_=0;
1180	1179	for(;iter!=end;++iter){
1181	1180	const size_t adjToDeadNodeId = iter->nodeId();
1182		if(adjToDeadNodeId!=newNodeRep){
	1181	if(newNodeRep < 0 \|\| adjToDeadNodeId!=static_cast<unsigned long long>(newNodeRep)){
1183	1182
1184	1183	// REFACTOR ME, we can make that faster if
1185	1184	// we do that in set intersect style

1425	1424	}
1426	1425
1427	1426	template<class T>
1428		inline bool operator == (const ConstRepIter<T> & iter,const lemon::Invalid & iv){
	1427	inline bool operator == (const ConstRepIter<T> & iter,const lemon::Invalid & /iv/){
1429	1428	return iter.isEnd();
1430	1429	}
1431	1430	template<class T>
1432		inline bool operator == (const lemon::Invalid & iv , const ConstRepIter<T> & iter){
	1431	inline bool operator == (const lemon::Invalid & /iv/ , const ConstRepIter<T> & iter){
1433	1432	return iter.isEnd();
1434	1433	}
1435	1434
1436	1435	template<class T>
1437		inline bool operator != (const ConstRepIter<T> & iter,const lemon::Invalid & iv){
	1436	inline bool operator != (const ConstRepIter<T> & iter,const lemon::Invalid & /iv/){
1438	1437	return !iter.isEnd();
1439	1438	}
1440	1439	template<class T>
1441		inline bool operator != (const lemon::Invalid & iv , const ConstRepIter<T> & iter){
	1440	inline bool operator != (const lemon::Invalid & /iv/ , const ConstRepIter<T> & iter){
1442	1441	return !iter.isEnd();
1443	1442	}
1444	1443

+72

-21

include/vigra/metaprogramming.hxx less more

28	28	/* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, */
29	29	/* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING */
30	30	/* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR */
31		/* OTHER DEALINGS IN THE SOFTWARE. */
	31	/* OTHER DEALINGS IN THE SOFTWARE. */
32	32	/* */
33	33	/************************************************************************/
34	34

85	85	};
86	86
87	87	/** \addtogroup MultiArrayTags Multi-dimensional Array Tags
88		Meta-programming tags to mark array's as strided or unstrided.
	88
	89	Meta-programming tags to mark array's as strided, unstrided, or chunked.
	90
	91	An array is unstrided if the array elements occupy consecutive
	92	memory locations, strided if adjacent elements have a constant
	93	offset (e.g. when a view skips every other array element),
	94	and chunked if the array is stored in rectangular blocks with
	95	arbitrary offsets inbetween.
	96
	97	These tags are used to specialize algorithms for different memory
	98	layouts. Older compilers can generate faster code for unstrided arrays.
	99	Normally, users don't have to worry about these tags.
89	100	*/
90	101
91	102	//@{

142	153	typedef VigraTrueType isConst;
143	154	};
144	155
145		template<class T>
	156	template<class T>
146	157	class TypeTraits<T *>
147	158	{
148	159	public:

151	162	typedef VigraTrueType isBuiltinType;
152	163	};
153	164
154		template<class T>
	165	template<class T>
155	166	class TypeTraits<T const *>
156	167	{
157	168	public:

167	178	template <int size>
168	179	struct SizeToType;
169	180
170		} // namespace detail
	181	} // namespace detail
171	182
172	183	#define VIGRA_TYPE_TRAITS(type, size) \
173	184	template<> \

188	199	{ \
189	200	typedef type result; \
190	201	}; \
191		}
	202	}
192	203
193	204	VIGRA_TYPE_TRAITS(char, 1)
194	205	VIGRA_TYPE_TRAITS(signed char, 2)

381	392	{
382	393	typedef char falseResult[1];
383	394	typedef char trueResult[2];
384
	395
385	396	static From const & check();
386
	397
387	398	static falseResult * testIsConvertible(...);
388	399	static trueResult * testIsConvertible(To const &);
389
	400
390	401	enum { resultSize = sizeof(*testIsConvertible(check())) };
391
	402
392	403	static const bool value = (resultSize == 2);
393		typedef typename
	404	typedef typename
394	405	IfBool<value, VigraTrueType, VigraFalseType>::type
395	406	type;
396	407	};

400	411	{
401	412	typedef char falseResult[1];
402	413	typedef char trueResult[2];
403
	414
404	415	static falseResult * testIsDerivedFrom(...);
405	416	static trueResult * testIsDerivedFrom(BASE const *);
406
	417
407	418	enum { resultSize = sizeof(testIsDerivedFrom(static_cast<DERIVED const >(0))) };
408
	419
409	420	static const bool value = (resultSize == 2);
410		typedef typename
	421	typedef typename
411	422	IfBool<value, VigraTrueType, VigraFalseType>::type
412	423	type;
413	424

473	484	{
474	485	typedef char falseResult[1];
475	486	typedef char trueResult[2];
476
	487
477	488	static falseResult * test(...);
478	489	static trueResult * test(USER<sfinae_void>);
479
	490
480	491	enum { resultSize = sizeof(test(static_cast<T>(0))) };
481
	492
482	493	static const bool value = (resultSize == 2);
483	494	typedef typename
484	495	IfBool<value, VigraTrueType, VigraFalseType>::type

546	557	{
547	558	typedef char falseResult[1];
548	559	typedef char trueResult[2];
549
	560
550	561	static falseResult * test(...);
551	562	template <class U, unsigned n>
552	563	static trueResult * test(U (*)[n]);
553
	564
554	565	enum { resultSize = sizeof(test(static_cast<T>(0))) };
555
	566
556	567	static const bool value = (resultSize == 2);
557	568	typedef typename
558	569	IfBool<value, VigraTrueType, VigraFalseType>::type

863	874	typedef L01 type;
864	875	};
865	876
	877	template <typename T0>
	878	inline void ignore_argument(const T0 &)
	879	{}
	880
	881	template <typename T0, typename T1>
	882	inline void ignore_argument(const T0 &, const T1 &)
	883	{}
	884
	885	template <typename T0, typename T1, typename T2>
	886	inline void ignore_argument(const T0 &, const T1 &, const T2 &)
	887	{}
	888
	889	template <typename T0, typename T1, typename T2, typename T3>
	890	inline void ignore_argument(const T0 &, const T1 &, const T2 &, const T3 &)
	891	{}
	892
	893	template <typename T0, typename T1, typename T2, typename T3, typename T4>
	894	inline void ignore_argument(const T0 &, const T1 &, const T2 &, const T3 &, const T4 &)
	895	{}
	896
	897	template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5>
	898	inline void ignore_argument(const T0 &, const T1 &, const T2 &, const T3 &, const T4 &, const T5 &)
	899	{}
	900
	901	template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
	902	inline void ignore_argument(const T0 &, const T1 &, const T2 &, const T3 &, const T4 &, const T5 &, const T6 &)
	903	{}
	904
	905	template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
	906	inline void ignore_argument(const T0 &, const T1 &, const T2 &, const T3 &, const T4 &, const T5 &, const T6 &, const T7 &)
	907	{}
	908
	909	template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
	910	inline void ignore_argument(const T0 &, const T1 &, const T2 &, const T3 &, const T4 &, const T5 &, const T6 &, const T7 &, const T8 &)
	911	{}
	912
	913	template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
	914	inline void ignore_argument(const T0 &, const T1 &, const T2 &, const T3 &, const T4 &, const T5 &, const T6 &, const T7 &, const T8 &, const T9 &)
	915	{}
	916
866	917	// mask cl.exe shortcomings [end]
867	918	#if defined(_MSC_VER)
868	919	#pragma warning( pop )

+68

-45

include/vigra/metrics.hxx less more

39	39
40	40	#include <cmath>
41	41
	42	/** \addtogroup MathFunctions
	43	*/
	44	//@{
	45
	46
42	47	namespace vigra{
	48
	49	/// \brief Define functors for various common metrics.
43	50	namespace metrics{
44	51
45
46	52	template<class T>
47	53	class ChiSquared{
48	54	public:

53	59	template<class A, class B>
54	60	T operator()(const A & a,const B & b)const{
55	61	return opImpl(a.begin(),a.end(),b.begin());
56		}
57		private:
58		template<class ITER_A,class ITER_B>
59		T opImpl(
60		ITER_A iterA ,ITER_A endA ,ITER_B iterB
61		)const{
	62	}
	63	private:
	64	template<class ITER_A,class ITER_B>
	65	T opImpl(
	66	ITER_A iterA ,ITER_A endA ,ITER_B iterB
	67	)const{
62	68	T res = 0.0;
63	69	while(iterA!=endA){
64	70	const T aa=static_cast<T>(*iterA);
65	71	const T bb=static_cast<T>(*iterB);
66	72	const T sum = aa + bb;
67		const T diff = aa - bb;
	73	const T diff = aa - bb;
68	74	if(sum> static_cast<T>(0.0000001))
69	75	res+=(diff*diff)/sum;
70	76	++iterA;

84	90	template<class A, class B>
85	91	T operator()(const A & a,const B & b)const{
86	92	return opImpl(a.begin(),a.end(),b.begin());
87		}
88		private:
89		template<class ITER_A,class ITER_B>
90		T opImpl(
91		ITER_A iterA ,ITER_A endA ,ITER_B iterB
92		)const{
	93	}
	94	private:
	95	template<class ITER_A,class ITER_B>
	96	T opImpl(
	97	ITER_A iterA ,ITER_A endA ,ITER_B iterB
	98	)const{
93	99	T res = 0.0;
94	100	while(iterA!=endA){
95	101	const T aa=std::sqrt(static_cast<T>(*iterA));
96	102	const T bb=std::sqrt(static_cast<T>(*iterB));
97		const T diff = aa - bb;
	103	const T diff = aa - bb;
98	104	res+=diff*diff;
99	105	++iterA;
100	106	++iterB;

102	108	return std::sqrt(res)/std::sqrt(2.0);
103	109	}
104	110	};
105
	111
106	112	template<class T,unsigned int NORM,bool TAKE_ROOT=true>
107	113	class PNorm{
108	114	public:

113	119	template<class A, class B>
114	120	T operator()(const A & a,const B & b)const{
115	121	return opImpl(a.begin(),a.end(),b.begin());
116		}
117		private:
118		template<class ITER_A,class ITER_B>
119		T opImpl(
120		ITER_A iterA ,ITER_A endA ,ITER_B iterB
	122	}
	123	private:
	124	template<class ITER_A,class ITER_B>
	125	T opImpl(
	126	ITER_A iterA ,ITER_A endA ,ITER_B iterB
121	127	)const{
122	128	T res = static_cast<T>(0.0);
123	129	while(iterA!=endA){

169	175	template<class A, class B>
170	176	T operator()(const A & a,const B & b)const{
171	177	return opImpl(a.begin(),a.end(),b.begin());
172		}
173		private:
174		template<class ITER_A,class ITER_B>
175		T opImpl(
176		ITER_A iterA ,ITER_A endA ,ITER_B iterB
	178	}
	179	private:
	180	template<class ITER_A,class ITER_B>
	181	T opImpl(
	182	ITER_A iterA ,ITER_A endA ,ITER_B iterB
177	183	)const{
178	184	T res = static_cast<T>(0.0);
179	185	while(iterA!=endA){

199	205	template<class A, class B>
200	206	T operator()(const A & a,const B & b)const{
201	207	return opImpl(a.begin(),a.end(),b.begin());
202		}
203		private:
204		template<class ITER_A,class ITER_B>
205		T opImpl(
206		ITER_A iterA ,ITER_A endA ,ITER_B iterB
	208	}
	209	private:
	210	template<class ITER_A,class ITER_B>
	211	T opImpl(
	212	ITER_A iterA ,ITER_A endA ,ITER_B iterB
207	213	)const{
208	214	T res = static_cast<T>(0.0);
209	215	while(iterA!=endA){

217	223	}
218	224	};
219	225
220		enum MetricType{
221		ChiSquaredMetric=0,
222		HellingerMetric=1,
223		SquaredNormMetric=2,
224		NormMetric=3,
225		ManhattanMetric=4,
226		SymetricKlMetric=5,
227		BhattacharyaMetric=6
228		};
229
230
	226	/** \brief Tags to select a metric for vector distance computation.
	227	*/
	228	enum MetricType
	229	{
	230	ChiSquaredMetric=0, //!< chi-squared distance for histograms (sum of squared differences normalized by means)
	231	HellingerMetric=1, //!< Hellinger distance (Euclidean distance between the square-root vectors)
	232	SquaredNormMetric=2, //!< squared Euclidean distance
	233	NormMetric=3, //!< Euclidean distance (L2 norm)
	234	L2Norm=NormMetric, //!< Euclidean distance (L2 norm)
	235	ManhattanMetric=4, //!< Manhattan distance (L1 norm)
	236	L1Norm=ManhattanMetric, //!< Manhattan distance (L1 norm)
	237	SymetricKlMetric=5, //!< symmetric Kullback-Leibler divergence
	238	BhattacharyaMetric=6 //!< Bhattacharya distance (sum of elementwise geometric means)
	239	};
	240
	241
	242	/** \brief Functor to compute a metric between two vectors.
	243
	244	The value type of the metric is given by template parameter <tt>T</tt>. Supported
	245	metrics are defined in \ref vigra::metrics::MetricType. The functor's argument
	246	must support <tt>begin()</tt> and <tt>end()</tt> to create an STL range.
	247	*/
231	248	template<class T>
232	249	class Metric{
233	250	public:
234	251
	252	/** \brief Construct functor for the given metric.
	253
	254	The value type of the metric is given by template parameter <tt>T</tt>. Supported
	255	metrics are defined in \ref vigra::metrics::MetricType.
	256	*/
235	257	Metric(const MetricType metricType = ManhattanMetric)
236	258	: metricType_(metricType){
237	259

251	273	case 4:
252	274	return manhattan_(a,b);
253	275	case 5:
254		return symetricKlDivergenz_(a,b);
	276	return symetricKlDivergenz_(a,b);
255	277	case 6 :
256		return bhattacharyaDistance_(a,b);
	278	return bhattacharyaDistance_(a,b);
257	279	default :
258	280	return 0;
259	281	}
260		}
	282	}
261	283	private:
262	284	MetricType metricType_;
263	285	ChiSquared<T> chiSquared_;

272	294	} // end namespace metric
273	295	} // end namepsace vigra
274	296
	297	//@}
275	298
276	299	#endif //VIGRA_METRIC_HXX

+175

-123

include/vigra/multi_array.hxx less more

123	123	{
124	124	typedef StridedMultiIterator <N, T, REFERENCE, POINTER> type;
125	125	};
126
	126
127	127	template <unsigned int N, class T, class REFERENCE, class POINTER>
128	128	struct Iterator
129	129	{
130	130	typedef StridedScanOrderIterator <N, T, REFERENCE, POINTER> type;
131	131	};
132
	132
133	133	template <class Iter, class View>
134	134	static Iter constructIterator(View * v)
135	135	{

156	156	{
157	157	typedef MultiIterator <N, T, REFERENCE, POINTER> type;
158	158	};
159
	159
160	160	template <unsigned int N, class T, class REFERENCE, class POINTER>
161	161	struct Iterator
162	162	{
163	163	typedef POINTER type;
164	164	};
165
	165
166	166	template <class Iter, class View>
167	167	static Iter constructIterator(View * v)
168	168	{

470	470
471	471	/********************************************************/
472	472	/* */
473		/* MultiArrayView */
	473	/* namespace multi_math forward declarations */
474	474	/* */
475	475	/********************************************************/
476	476
477		// forward declarations
478
	477	/** \brief Arithmetic and algebraic functions for multi-dimensional arrays.
	478
	479	\defgroup MultiMathModule vigra::multi_math
	480
	481	Namespace <tt>vigra::multi_math</tt> holds VIGRA's support for efficient arithmetic and algebraic functions on multi-dimensional arrays (that is, \ref MultiArrayView and its subclasses). All <tt>multi_math</tt> functions operate element-wise. If you need matrix multiplication, use \ref LinearAlgebraModule instead.
	482
	483	In order to avoid overload ambiguities, multi-array arithmetic must be explicitly activated by
	484	\code
	485	using namespace vigra::multi_math;
	486	\endcode
	487	(this should not be done globally, but only in the scope where the functionality is actually used).
	488
	489	You can then use the standard operators in the expected way:
	490	\code
	491	MultiArray<2, float> i(Shape2(100, 100)), j(Shape2(100, 100));
	492
	493	MultiArray<2, float> h = i + 4.0 * j;
	494	h += (i.transpose() - j) / 2.0;
	495	\endcode
	496	etc. (supported operators are <tt>+ - * / ! ~ % && \|\| == != < <= > >= << >> & \| ^ = += -= *= /=</tt>, with both scalar and array arguments).
	497
	498	Algebraic functions are available as well:
	499	\code
	500	h = exp(-(sq(i) + sq(j)));
	501	h *= atan2(-i, j);
	502	\endcode
	503	The following functions are implemented: <tt>abs, erf, even, odd, sign, signi, round, roundi, sqrt, sqrti, sq,
	504	norm, squaredNorm, gamma, loggamma, exp, log, log10, sin, sin_pi, cos, cos_pi, asin, acos, tan, atan,
	505	floor, ceil, conj, real, imag, arg, atan2, pow, fmod, min, max</tt>,
	506	provided the array's element type supports the respective function.
	507
	508	Supported element types currently include the built-in numeric types, \ref TinyVector, \ref RGBValue,
	509	<tt>std::complex</tt>, and \ref FFTWComplex.
	510
	511	In addition, <tt>multi_math</tt> supports a number of functions that reduce arrays to scalars:
	512	\code
	513	double s = sum<double>(i); // compute the sum of the elements, using 'double' as accumulator type
	514	double p = product<double>(abs(i)); // compute the product of the elements' absolute values
	515
	516	bool a = any(i < 0.0); // check if any element of i is negative
	517	bool b = all(i > 0.0); // check if all elements of i are positive
	518	\endcode
	519
	520	Expressions are expanded so that no temporary arrays have to be created. To optimize cache locality,
	521	loops are executed in the stride ordering of the left-hand-side array.
	522
	523	<b>\#include</b> \<vigra/multi_math.hxx\>
	524
	525	Namespace: vigra::multi_math
	526	*/
479	527	namespace multi_math {
480	528
481	529	template <class T>

609	657	typedef typename BaseType::NormType NormType;
610	658	};
611	659
	660	/********************************************************/
	661	/* */
	662	/* MultiArrayView */
	663	/* */
	664	/********************************************************/
	665
612	666	/** \brief Base class for, and view to, \ref vigra::MultiArray.
613	667
614	668	This class implements the interface of both MultiArray and
615	669	MultiArrayView. By default, MultiArrayViews are tagged as
616		strided (using <tt>StridedArrayTag</tt> as third template parameter).
	670	strided (using <tt>StridedArrayTag</tt> as third template parameter).
617	671	This means that the array elements need not be consecutive in memory,
618	672	making the view flexible to represent all kinds of subarrays and slices.
619		In certain cases (which have become rare due to improvements of
620		optimizer and processor technology), an array may be tagged with
	673	In certain cases (which have become rare due to improvements of
	674	optimizer and processor technology), an array may be tagged with
621	675	<tt>UnstridedArrayTag</tt> which indicates that the first array dimension
622	676	is guaranteed to be unstrided, i.e. has consecutive elements in memory.
623	677
624	678	In addition to the member functions described here, <tt>MultiArrayView</tt>
625		and its subclasses support arithmetic and algebraic functions via the
	679	and its subclasses support arithmetic and algebraic functions via the
626	680	module \ref MultiMathModule.
627	681
628	682	If you want to apply an algorithm requiring an image to a

636	690
637	691	T: the type of the array elements
638	692
639		C: a tag determining whether the array's inner dimension is strided
640		or not. An array is unstrided if the array elements occupy consecutive
641		memory location, strided if there is an offset in between (e.g.
642		when a view is created that skips every other array element).
643		The compiler can generate faster code for unstrided arrays.
644		Possible values: StridedArrayTag (default), UnstridedArrayTag
	693	C: a tag determining if the array's inner dimension is strided
	694	(the tag can be used to specialize algorithms for different memory
	695	layouts, see \ref MultiArrayTags for details). Users normally need
	696	not care about this parameter.
645	697	\endcode
646	698
647	699	<b>\#include</b> \<vigra/multi_array.hxx\> <br/>

727	779	{
728	780	return m_stride[0] <= 1;
729	781	}
730
	782
731	783	bool checkInnerStride(StridedArrayTag) const
732	784	{
733	785	return true;

778	830	{}
779	831
780	832	/** construct from another array view.
781		Throws a precondition error if this array has UnstridedArrayTag, but the
	833	Throws a precondition error if this array has UnstridedArrayTag, but the
782	834	innermost dimension of \a other is strided.
783	835	*/
784	836	template <class Stride>

814	866	vigra_precondition(checkInnerStride(StrideTag()),
815	867	"MultiArrayView<..., UnstridedArrayTag>::MultiArrayView(): First dimension of given array is not unstrided.");
816	868	}
817
	869
818	870	/** Construct from an old-style BasicImage.
819	871	*/
820	872	template <class ALLOC>

823	875	m_stride (detail::defaultStride<actual_dimension>(m_shape)),
824	876	m_ptr (const_cast<pointer>(image.data()))
825	877	{}
826
	878
827	879	/** Conversion to a strided view.
828	880	*/
829	881	operator MultiArrayView<N, T, StridedArrayTag>() const

831	883	return MultiArrayView<N, T, StridedArrayTag>(m_shape, m_stride, m_ptr);
832	884	}
833	885
834		/** Reset this <tt>MultiArrayView</tt> to an invalid state (as after default construction).
835		Can e.g. be used prior to assignment to make a view object point to new data.
	886	/** Reset this <tt>MultiArrayView</tt> to an invalid state (as after default construction).
	887	Can e.g. be used prior to assignment to make a view object point to new data.
836	888	*/
837	889	void reset() {
838		m_shape = diff_zero_t(0);
839		m_stride = diff_zero_t(0);
840		m_ptr = 0;
	890	m_shape = diff_zero_t(0);
	891	m_stride = diff_zero_t(0);
	892	m_ptr = 0;
841	893	}
842	894
843	895

846	898	<ul>
847	899	<li> When this <tt>MultiArrayView</tt> does not point to valid data
848	900	(e.g. after default construction), it becomes a new view of \a rhs.
849		<li> Otherwise, when the shapes of the two arrays match, the contents
	901	<li> Otherwise, when the shapes of the two arrays match, the contents
850	902	(i.e. the elements) of \a rhs are copied.
851	903	<li> Otherwise, a <tt>PreconditionViolation</tt> exception is thrown.
852	904	</ul>

866	918	}
867	919
868	920	/** Assignment of a differently typed MultiArrayView. It copies the elements
869		of\a rhs or fails with <tt>PreconditionViolation</tt> exception when
	921	of\a rhs or fails with <tt>PreconditionViolation</tt> exception when
870	922	the shapes do not match.
871	923	*/
872	924	template<class U, class C1>

1019	1071	Mostly useful to support standard indexing for 1-dimensional multi-arrays,
1020	1072	but works for any N. Use scanOrderIndexToCoordinate() and
1021	1073	coordinateToScanOrderIndex() for conversion between indices and coordinates.
1022
	1074
1023	1075	<b>Note:</b> This function should not be used in the inner loop, because the
1024	1076	conversion of the scan order index into a memory address is expensive
1025	1077	(it must take into account that memory may not be consecutive for subarrays
1026		and/or strided arrays). Always prefer operator() if possible.
	1078	and/or strided arrays). Always prefer operator() if possible.
1027	1079	*/
1028	1080	reference operator[](difference_type_1 d)
1029	1081	{

1035	1087	Mostly useful to support standard indexing for 1-dimensional multi-arrays,
1036	1088	but works for any N. Use scanOrderIndexToCoordinate() and
1037	1089	coordinateToScanOrderIndex() for conversion between indices and coordinates.
1038
	1090
1039	1091	<b>Note:</b> This function should not be used in the inner loop, because the
1040	1092	conversion of the scan order index into a memory address is expensive
1041	1093	(it must take into account that memory may not be consecutive for subarrays
1042		and/or strided arrays). Always prefer operator() if possible.
	1094	and/or strided arrays). Always prefer operator() if possible.
1043	1095	*/
1044	1096	const_reference operator[](difference_type_1 d) const
1045	1097	{

1176	1228	}
1177	1229
1178	1230	/** Swap the pointers, shaes and strides between two array views.
1179
	1231
1180	1232	This function must be used with care. Never swap a MultiArray
1181	1233	(which owns data) with a MultiArrayView:
1182	1234	\code
1183	1235	MultiArray<2, int> a(3,2), b(3,2);
1184	1236	MultiArrayView<2, int> va(a);
1185
	1237
1186	1238	va.swap(b); // danger!
1187	1239	\endcode
1188	1240	Now, <tt>a</tt> and <tt>b</tt> refer to the same memory. This may lead
1189		to a crash in their destructor, and in any case leaks <tt>b</tt>'s original
	1241	to a crash in their destructor, and in any case leaks <tt>b</tt>'s original
1190	1242	memory. Only use swap() on copied MultiArrayViews:
1191	1243	\code
1192	1244	MultiArray<2, int> a(3,2), b(3,2);
1193	1245	MultiArrayView<2, int> va(a), vb(b);
1194
	1246
1195	1247	va.swap(vb); // OK
1196	1248	\endcode
1197	1249	*/

1223	1275	{
1224	1276	swapDataImpl(rhs);
1225	1277	}
1226
1227		/** check whether the array is unstrided (i.e. has consecutive memory) up
	1278
	1279	/** check whether the array is unstrided (i.e. has consecutive memory) up
1228	1280	to the given dimension.
1229	1281
1230		\a dimension can range from 0 ... N-1. If a certain dimension is unstrided,
	1282	\a dimension can range from 0 ... N-1. If a certain dimension is unstrided,
1231	1283	all lower dimensions are also unstrided.
1232	1284	*/
1233	1285	bool isUnstrided(unsigned int dimension = N-1) const

1342	1394	*/
1343	1395	MultiArrayView <N-1, T, StridedArrayTag>
1344	1396	bindAt (difference_type_1 m, difference_type_1 d) const;
1345
	1397
1346	1398	/** Create a view to channel 'i' of a vector-like value type. Possible value types
1347		(of the original array) are: \ref TinyVector, \ref RGBValue, \ref FFTWComplex,
	1399	(of the original array) are: \ref TinyVector, \ref RGBValue, \ref FFTWComplex,
1348	1400	and <tt>std::complex</tt>. The list can be extended to any type whose memory
1349		layout is equivalent to a fixed-size C array, by specializing
	1401	layout is equivalent to a fixed-size C array, by specializing
1350	1402	<tt>ExpandElementResult</tt>.
1351	1403
1352	1404	<b>Usage:</b>
1353	1405	\code
1354	1406	MultiArray<2, RGBValue<float> > rgb_image(Shape2(w, h));
1355
	1407
1356	1408	MultiArrayView<2, float, StridedArrayTag> red = rgb_image.bindElementChannel(0);
1357	1409	MultiArrayView<2, float, StridedArrayTag> green = rgb_image.bindElementChannel(1);
1358	1410	MultiArrayView<2, float, StridedArrayTag> blue = rgb_image.bindElementChannel(2);
1359	1411	\endcode
1360	1412	*/
1361		MultiArrayView <N, typename ExpandElementResult<T>::type, StridedArrayTag>
	1413	MultiArrayView <N, typename ExpandElementResult<T>::type, StridedArrayTag>
1362	1414	bindElementChannel(difference_type_1 i) const
1363	1415	{
1364	1416	vigra_precondition(0 <= i && i < ExpandElementResult<T>::size,

1366	1418	return expandElements(0).bindInner(i);
1367	1419	}
1368	1420
1369		/** Create a view where a vector-like element type is expanded into a new
	1421	/** Create a view where a vector-like element type is expanded into a new
1370	1422	array dimension. The new dimension is inserted at index position 'd',
1371	1423	which must be between 0 and N inclusive.
1372
1373		Possible value types of the original array are: \ref TinyVector, \ref RGBValue,
1374		\ref FFTWComplex, <tt>std::complex</tt>, and the built-in number types (in this
1375		case, <tt>expandElements</tt> is equivalent to <tt>insertSingletonDimension</tt>).
	1424
	1425	Possible value types of the original array are: \ref TinyVector, \ref RGBValue,
	1426	\ref FFTWComplex, <tt>std::complex</tt>, and the built-in number types (in this
	1427	case, <tt>expandElements</tt> is equivalent to <tt>insertSingletonDimension</tt>).
1376	1428	The list of supported types can be extended to any type whose memory
1377		layout is equivalent to a fixed-size C array, by specializing
	1429	layout is equivalent to a fixed-size C array, by specializing
1378	1430	<tt>ExpandElementResult</tt>.
1379	1431
1380	1432	<b>Usage:</b>
1381	1433	\code
1382	1434	MultiArray<2, RGBValue<float> > rgb_image(Shape2(w, h));
1383
	1435
1384	1436	MultiArrayView<3, float, StridedArrayTag> multiband_image = rgb_image.expandElements(2);
1385	1437	\endcode
1386	1438	*/
1387		MultiArrayView <N+1, typename ExpandElementResult<T>::type, StridedArrayTag>
	1439	MultiArrayView <N+1, typename ExpandElementResult<T>::type, StridedArrayTag>
1388	1440	expandElements(difference_type_1 d) const;
1389
	1441
1390	1442	/** Add a singleton dimension (dimension of length 1).
1391	1443
1392	1444	Singleton dimensions don't change the size of the data, but introduce

1418	1470	*/
1419	1471	MultiArrayView <N+1, T, StrideTag>
1420	1472	insertSingletonDimension (difference_type_1 i) const;
1421
	1473
1422	1474	/** create a multiband view for this array.
1423	1475
1424	1476	The type <tt>MultiArrayView<N, Multiband<T> ></tt> tells VIGRA
1425	1477	algorithms which recognize the <tt>Multiband</tt> modifier to
1426		interpret the outermost (last) dimension as a channel dimension.
1427		In effect, these algorithms will treat the data as a set of
	1478	interpret the outermost (last) dimension as a channel dimension.
	1479	In effect, these algorithms will treat the data as a set of
1428	1480	(N-1)-dimensional arrays instead of a single N-dimensional array.
1429	1481	*/
1430	1482	MultiArrayView<N, Multiband<value_type>, StrideTag> multiband() const

1433	1485	}
1434	1486
1435	1487	/** Create a view to the diagonal elements of the array.
1436
	1488
1437	1489	This produces a 1D array view whose size equals the size
1438	1490	of the shortest dimension of the original array.
1439	1491

1450	1502	*/
1451	1503	MultiArrayView<1, T, StridedArrayTag> diagonal() const
1452	1504	{
1453		return MultiArrayView<1, T, StridedArrayTag>(Shape1(vigra::min(m_shape)),
	1505	return MultiArrayView<1, T, StridedArrayTag>(Shape1(vigra::min(m_shape)),
1454	1506	Shape1(vigra::sum(m_stride)), m_ptr);
1455	1507	}
1456	1508
1457	1509	/** create a rectangular subarray that spans between the
1458		points p and q, where p is in the subarray, q not.
	1510	points p and q, where p is in the subarray, q not.
1459	1511	If an element of p or q is negative, it is subtracted
1460	1512	from the correspongng shape.
1461	1513

1467	1519
1468	1520	// get a subarray set is smaller by one element at all sides
1469	1521	MultiArrayView <3, double> subarray = array3.subarray(Shape(1,1,1), Shape(39, 29, 19));
1470
	1522
1471	1523	// specifying the end point with a vector of '-1' is equivalent
1472	1524	MultiArrayView <3, double> subarray2 = array3.subarray(Shape(1,1,1), Shape(-1, -1, -1));
1473	1525	\endcode

1520	1572
1521	1573	/** Permute the dimensions of the array.
1522	1574	The function exchanges the orer of the array's axes without copying the data.
1523		Argument\a permutation specifies the desired order such that
	1575	Argument\a permutation specifies the desired order such that
1524	1576	<tt>permutation[k] = j</tt> means that axis <tt>j</tt> in the original array
1525		becomes axis <tt>k</tt> in the transposed array.
	1577	becomes axis <tt>k</tt> in the transposed array.
1526	1578
1527	1579	<b>Usage:</b><br>
1528	1580	\code

1550	1602	*/
1551	1603	MultiArrayView <N, T, StridedArrayTag>
1552	1604	permuteStridesAscending() const;
1553
	1605
1554	1606	/** Permute the dimensions of the array so that the strides are in descending order.
1555	1607	Determines the appropriate permutation and then calls permuteDimensions().
1556	1608	*/
1557	1609	MultiArrayView <N, T, StridedArrayTag>
1558	1610	permuteStridesDescending() const;
1559
	1611
1560	1612	/** Compute the ordering of the strides in this array.
1561		The result is describes the current permutation of the axes relative
	1613	The result is describes the current permutation of the axes relative
1562	1614	to the standard ascending stride order.
1563	1615	*/
1564	1616	difference_type strideOrdering() const
1565	1617	{
1566	1618	return strideOrdering(m_stride);
1567	1619	}
1568
	1620
1569	1621	/** Compute the ordering of the given strides.
1570		The result is describes the current permutation of the axes relative
	1622	The result is describes the current permutation of the axes relative
1571	1623	to the standard ascending stride order.
1572	1624	*/
1573	1625	static difference_type strideOrdering(difference_type strides);

1685	1737	{
1686	1738	bool res = true;
1687	1739	detail::reduceOverMultiArray(traverser_begin(), shape(),
1688		res,
	1740	res,
1689	1741	detail::AllTrueReduceFunctor(),
1690	1742	MetaInt<actual_dimension-1>());
1691	1743	return res;

1698	1750	{
1699	1751	bool res = false;
1700	1752	detail::reduceOverMultiArray(traverser_begin(), shape(),
1701		res,
	1753	res,
1702	1754	detail::AnyTrueReduceFunctor(),
1703	1755	MetaInt<actual_dimension-1>());
1704	1756	return res;
1705	1757	}
1706	1758
1707		/** Find the minimum and maximum element in this array.
1708		See \ref FeatureAccumulators for a general feature
	1759	/** Find the minimum and maximum element in this array.
	1760	See \ref FeatureAccumulators for a general feature
1709	1761	extraction framework.
1710	1762	*/
1711	1763	void minmax(T * minimum, T * maximum) const
1712	1764	{
1713	1765	std::pair<T, T> res(NumericTraits<T>::max(), NumericTraits<T>::min());
1714	1766	detail::reduceOverMultiArray(traverser_begin(), shape(),
1715		res,
	1767	res,
1716	1768	detail::MinmaxReduceFunctor(),
1717	1769	MetaInt<actual_dimension-1>());
1718	1770	*minimum = res.first;
1719	1771	*maximum = res.second;
1720	1772	}
1721	1773
1722		/** Compute the mean and variance of the values in this array.
1723		See \ref FeatureAccumulators for a general feature
	1774	/** Compute the mean and variance of the values in this array.
	1775	See \ref FeatureAccumulators for a general feature
1724	1776	extraction framework.
1725	1777	*/
1726	1778	template <class U>

1730	1782	R zero = R();
1731	1783	triple<double, R, R> res(0.0, zero, zero);
1732	1784	detail::reduceOverMultiArray(traverser_begin(), shape(),
1733		res,
	1785	res,
1734	1786	detail::MeanVarianceReduceFunctor(),
1735	1787	MetaInt<actual_dimension-1>());
1736	1788	*mean = res.second;

1742	1794	You must provide the type of the result by an explicit template parameter:
1743	1795	\code
1744	1796	MultiArray<2, UInt8> A(width, height);
1745
	1797
1746	1798	double sum = A.sum<double>();
1747	1799	\endcode
1748	1800	*/

1751	1803	{
1752	1804	U res = NumericTraits<U>::zero();
1753	1805	detail::reduceOverMultiArray(traverser_begin(), shape(),
1754		res,
	1806	res,
1755	1807	detail::SumReduceFunctor(),
1756	1808	MetaInt<actual_dimension-1>());
1757	1809	return res;
1758	1810	}
1759	1811
1760	1812	/** Compute the sum of the array elements over selected axes.
1761
	1813
1762	1814	\arg sums must have the same shape as this array, except for the
1763		axes along which the sum is to be accumulated. These axes must be
	1815	axes along which the sum is to be accumulated. These axes must be
1764	1816	singletons. Note that you must include <tt>multi_pointoperators.hxx</tt>
1765	1817	for this function to work.
1766	1818

1768	1820	\code
1769	1821	#include <vigra/multi_array.hxx>
1770	1822	#include <vigra/multi_pointoperators.hxx>
1771
	1823
1772	1824	MultiArray<2, double> A(Shape2(rows, cols));
1773	1825	... // fill A
1774
	1826
1775	1827	// make the first axis a singleton to sum over the first index
1776	1828	MultiArray<2, double> rowSums(Shape2(1, cols));
1777	1829	A.sum(rowSums);
1778
	1830
1779	1831	// this is equivalent to
1780	1832	transformMultiArray(srcMultiArrayRange(A),
1781	1833	destMultiArrayRange(rowSums),

1795	1847	You must provide the type of the result by an explicit template parameter:
1796	1848	\code
1797	1849	MultiArray<2, UInt8> A(width, height);
1798
	1850
1799	1851	double prod = A.product<double>();
1800	1852	\endcode
1801	1853	*/

1804	1856	{
1805	1857	U res = NumericTraits<U>::one();
1806	1858	detail::reduceOverMultiArray(traverser_begin(), shape(),
1807		res,
	1859	res,
1808	1860	detail::ProdReduceFunctor(),
1809	1861	MetaInt<actual_dimension-1>());
1810	1862	return res;

1812	1864
1813	1865	/** Compute the squared Euclidean norm of the array (sum of squares of the array elements).
1814	1866	*/
1815		typename NormTraits<MultiArrayView>::SquaredNormType
	1867	typename NormTraits<MultiArrayView>::SquaredNormType
1816	1868	squaredNorm() const
1817	1869	{
1818	1870	typedef typename NormTraits<MultiArrayView>::SquaredNormType SquaredNormType;
1819	1871	SquaredNormType res = NumericTraits<SquaredNormType>::zero();
1820	1872	detail::reduceOverMultiArray(traverser_begin(), shape(),
1821		res,
	1873	res,
1822	1874	detail::SquaredL2NormReduceFunctor(),
1823	1875	MetaInt<actual_dimension-1>());
1824	1876	return res;

1837	1889	Parameter \a useSquaredNorm has no effect when \a type != 2. Defaults: compute L2 norm as square root of
1838	1890	<tt>squaredNorm()</tt>.
1839	1891	*/
1840		typename NormTraits<MultiArrayView>::NormType
	1892	typename NormTraits<MultiArrayView>::NormType
1841	1893	norm(int type = 2, bool useSquaredNorm = true) const;
1842	1894
1843	1895	/** return the pointer to the image data

1846	1898	{
1847	1899	return m_ptr;
1848	1900	}
1849
	1901
1850	1902	pointer & unsafePtr()
1851	1903	{
1852	1904	return m_ptr;

1960	2012	{
1961	2013	vigra_precondition(rhs.checkInnerStride(Stride1()),
1962	2014	"MultiArrayView<..., UnstridedArrayTag>::operator=(MultiArrayView const &): cannot create unstrided view from strided array.");
1963
	2015
1964	2016	m_shape = rhs.shape();
1965	2017	m_stride = rhs.stride();
1966	2018	m_ptr = rhs.data();

2079	2131	}
2080	2132
2081	2133	template <unsigned int N, class T, class StrideTag>
2082		typename MultiArrayView <N, T, StrideTag>::difference_type
	2134	typename MultiArrayView <N, T, StrideTag>::difference_type
2083	2135	MultiArrayView <N, T, StrideTag>::strideOrdering(difference_type stride)
2084	2136	{
2085	2137	difference_type permutation;

2273	2325	{
2274	2326	vigra_precondition(0 <= d && d <= static_cast <difference_type_1> (N),
2275	2327	"MultiArrayView<N, ...>::expandElements(d): 0 <= 'd' <= N required.");
2276
	2328
2277	2329	int elementSize = ExpandElementResult<T>::size;
2278	2330	typename MultiArrayShape<N+1>::type newShape, newStrides;
2279	2331	for(int k=0; k<d; ++k)
2280	2332	{
2281	2333	newShape[k] = m_shape[k];
2282	2334	newStrides[k] = m_stride[k]*elementSize;
2283		}
2284
	2335	}
	2336
2285	2337	newShape[d] = elementSize;
2286	2338	newStrides[d] = 1;
2287
2288		for(int k=d; k<N; ++k)
	2339
	2340	for(unsigned k=d; k<N; ++k)
2289	2341	{
2290	2342	newShape[k+1] = m_shape[k];
2291	2343	newStrides[k+1] = m_stride[k]*elementSize;
2292		}
2293
2294		typedef typename ExpandElementResult<T>::type U;
	2344	}
	2345
	2346	typedef typename ExpandElementResult<T>::type U;
2295	2347	return MultiArrayView<N+1, U, StridedArrayTag>(
2296	2348	newShape, newStrides, reinterpret_cast<U*>(m_ptr));
2297	2349	}

2325	2377	case 0:
2326	2378	{
2327	2379	NormType res = NumericTraits<NormType>::zero();
2328		detail::reduceOverMultiArray(traverser_begin(), shape(),
2329		res,
	2380	detail::reduceOverMultiArray(traverser_begin(), shape(),
	2381	res,
2330	2382	detail::MaxNormReduceFunctor(),
2331	2383	MetaInt<actual_dimension-1>());
2332	2384	return res;

2334	2386	case 1:
2335	2387	{
2336	2388	NormType res = NumericTraits<NormType>::zero();
2337		detail::reduceOverMultiArray(traverser_begin(), shape(),
2338		res,
	2389	detail::reduceOverMultiArray(traverser_begin(), shape(),
	2390	res,
2339	2391	detail::L1NormReduceFunctor(),
2340	2392	MetaInt<actual_dimension-1>());
2341	2393	return res;

2349	2401	else
2350	2402	{
2351	2403	NormType normMax = NumericTraits<NormType>::zero();
2352		detail::reduceOverMultiArray(traverser_begin(), shape(),
2353		normMax,
	2404	detail::reduceOverMultiArray(traverser_begin(), shape(),
	2405	normMax,
2354	2406	detail::MaxNormReduceFunctor(),
2355	2407	MetaInt<actual_dimension-1>());
2356	2408	if(normMax == NumericTraits<NormType>::zero())
2357	2409	return normMax;
2358	2410	NormType res = NumericTraits<NormType>::zero();
2359		detail::reduceOverMultiArray(traverser_begin(), shape(),
2360		res,
	2411	detail::reduceOverMultiArray(traverser_begin(), shape(),
	2412	res,
2361	2413	detail::WeightedL2NormReduceFunctor<NormType>(1.0/normMax),
2362	2414	MetaInt<actual_dimension-1>());
2363	2415	return sqrt(res)*normMax;

2418	2470	Namespace: vigra
2419	2471	*/
2420	2472	template <unsigned int N, class T, class A /* default already declared above */>
2421		class MultiArray
2422		: public MultiArrayView <N, typename vigra::detail::ResolveMultiband<T>::type,
	2473	class MultiArray
	2474	: public MultiArrayView <N, typename vigra::detail::ResolveMultiband<T>::type,
2423	2475	typename vigra::detail::ResolveMultiband<T>::Stride>
2424	2476	{
2425	2477	public:

2427	2479
2428	2480	/** the view type associated with this array.
2429	2481	*/
2430		typedef MultiArrayView <N, typename vigra::detail::ResolveMultiband<T>::type,
	2482	typedef MultiArrayView <N, typename vigra::detail::ResolveMultiband<T>::type,
2431	2483	typename vigra::detail::ResolveMultiband<T>::Stride> view_type;
2432
	2484
2433	2485	using view_type::actual_dimension;
2434	2486
2435	2487	/** the allocator type used to allocate the memory

2546	2598	{}
2547	2599
2548	2600	/** construct with given length
2549
	2601
2550	2602	Use only for 1-dimensional arrays (<tt>N==1</tt>).
2551	2603	*/
2552	2604	explicit MultiArray (difference_type_1 length,

2554	2606
2555	2607
2556	2608	/** construct with given width and height
2557
	2609
2558	2610	Use only for 2-dimensional arrays (<tt>N==2</tt>).
2559	2611	*/
2560	2612	MultiArray (difference_type_1 width, difference_type_1 height,

2570	2622	MultiArray (const difference_type &shape, const_reference init,
2571	2623	allocator_type const & alloc = allocator_type());
2572	2624
2573		/** construct from shape and initialize with a linear sequence in scan order
	2625	/** construct from shape and initialize with a linear sequence in scan order
2574	2626	(i.e. first pixel gets value 0, second on gets value 1 and so on).
2575	2627	*/
2576	2628	MultiArray (const difference_type &shape, MultiArrayInitializationTag init,

2642	2694
2643	2695	/** Add-assignment from arbitrary MultiArrayView. Fails with
2644	2696	<tt>PreconditionViolation</tt> exception when the shapes do not match.
2645		If the left array has no data (hasData() is false), this function is
	2697	If the left array has no data (hasData() is false), this function is
2646	2698	equivalent to a normal assignment (i.e. an empty
2647	2699	array is interpreted as a zero-array of appropriate size).
2648	2700	*/

2658	2710
2659	2711	/** Subtract-assignment from arbitrary MultiArrayView. Fails with
2660	2712	<tt>PreconditionViolation</tt> exception when the shapes do not match.
2661		If the left array has no data (hasData() is false), this function is
	2713	If the left array has no data (hasData() is false), this function is
2662	2714	equivalent to an assignment of the negated rhs (i.e. an empty
2663	2715	array is interpreted as a zero-array of appropriate size).
2664	2716	*/

2673	2725
2674	2726	/** Multiply-assignment from arbitrary MultiArrayView. Fails with
2675	2727	<tt>PreconditionViolation</tt> exception when the shapes do not match.
2676		If the left array has no data (hasData() is false), this function is
	2728	If the left array has no data (hasData() is false), this function is
2677	2729	equivalent to reshape(rhs.shape()) with zero initialisation (i.e. an empty
2678	2730	array is interpreted as a zero-array of appropriate size).
2679	2731	*/

2689	2741
2690	2742	/** Divide-assignment from arbitrary MultiArrayView. Fails with
2691	2743	<tt>PreconditionViolation</tt> exception when the shapes do not match.
2692		If the left array has no data (hasData() is false), this function is
	2744	If the left array has no data (hasData() is false), this function is
2693	2745	equivalent to reshape(rhs.shape()) with zero initialisation (i.e. an empty
2694	2746	array is interpreted as a zero-array of appropriate size).
2695	2747	*/

2858	2910	{
2859	2911	return m_alloc;
2860	2912	}
2861
	2913
2862	2914	static difference_type defaultStride(difference_type const & shape)
2863	2915	{
2864	2916	return vigra::detail::ResolveMultiband<T>::defaultStride(shape);

3407	3459	/********************************************************/
3408	3460
3409	3461	/** \addtogroup MultiArrayToImage Create BasicImageView from MultiArrayViews
3410
	3462
3411	3463	Some convenience functions for wrapping a \ref vigra::MultiArrayView's
3412		data in a \ref vigra::BasicImageView.
	3464	data in a \ref vigra::BasicImageView.
3413	3465	*/
3414	3466	//@{
3415	3467	/** Create a \ref vigra::BasicImageView from an unstrided 2-dimensional

3422	3474	BasicImageView <T>
3423	3475	makeBasicImageView (MultiArrayView <2, T, Stride> const &array)
3424	3476	{
3425		vigra_precondition(array.isUnstrided(),
3426		"makeBasicImageView(array): array must be unstrided (i.e. array.isUnstrided() == true).");
	3477	vigra_precondition(array.isUnstrided(0),
	3478	"makeBasicImageView(array): array must be unstrided along x (i.e. array.isUnstrided(0) == true).");
3427	3479	return BasicImageView <T> (array.data (), array.shape (0),
3428	3480	array.shape (1), array.stride(1));
3429	3481	}

3458	3510	BasicImageView <RGBValue<T> >
3459	3511	makeRGBImageView (MultiArrayView<3, T, Stride> const &array)
3460	3512	{
3461		vigra_precondition(array.shape (0) == 3,
	3513	vigra_precondition(array.shape (0) == 3,
3462	3514	"makeRGBImageView(): array.shape(0) must be 3.");
3463	3515	vigra_precondition(array.isUnstrided(),
3464	3516	"makeRGBImageView(array): array must be unstrided (i.e. array.isUnstrided() == true).");

+25

-10

include/vigra/multi_array_chunked.hxx less more

139	139	#include "threading.hxx"
140	140	#include "compression.hxx"
141	141
142		// // FIXME: why is this needed when compiling the Python bindng,
143		// // but not when compiling test_multiarray_chunked?
144		// #if defined(__GNUC__)
145		// # define memory_order_release memory_order_seq_cst
146		// # define memory_order_acquire memory_order_seq_cst
147		// #endif
148
149	142	#ifdef _WIN32
150	143	# include "windows.h"
151	144	#else

456	449
457	450	bool isInside(shape_type const & p) const
458	451	{
459		for(int d=0; d<N; ++d)
	452	for(unsigned d=0; d<N; ++d)
460	453	if(p[d] < 0 \|\| p[d] >= shape_[d])
461	454	return false;
462	455	return true;

1330	1323	int cache_max;
1331	1324	CompressionMethod compression_method;
1332	1325	};
	1326
	1327	/** \weakgroup ParallelProcessing
	1328	\sa ChunkedArray
	1329	*/
1333	1330
1334	1331	/** \brief Interface and base class for chunked arrays.
1335	1332

1837	1834	if(chunk)
1838	1835	{
1839	1836	long rc = chunk->chunk_state_.fetch_sub(1);
	1837	ignore_argument(rc);
1840	1838	#ifdef VIGRA_CHECK_BOUNDS
1841	1839	vigra_invariant(rc >= 0,
1842	1840	"ChunkedArray::unrefChunk(): chunk refcount got negative!");

2512	2510	P0(m.shape())));
2513	2511	}
2514	2512
	2513	/** \weakgroup ParallelProcessing
	2514	\sa ChunkedArrayFull
	2515	*/
	2516
2515	2517	/** Implement ChunkedArray as an ordinary MultiArray with a single chunk.
2516	2518
2517	2519	<b>\#include</b> \<vigra/multi_array_chunked.hxx\> <br/>

2543	2545
2544	2546	static shape_type computeChunkShape(shape_type s)
2545	2547	{
2546		for(int k=0; k<N; ++k)
	2548	for(unsigned k=0; k<N; ++k)
2547	2549	s[k] = ceilPower2(s[k]);
2548	2550	return s;
2549	2551	}

2620	2622	return false; // never destroys the data
2621	2623	}
2622	2624
2623		virtual std::size_t dataBytes(Chunk * c) const
	2625	virtual std::size_t dataBytes(Chunk *) const
2624	2626	{
2625	2627	return prod(this->shape());
2626	2628	}

2672	2674	shape_type upper_bound_;
2673	2675	Chunk chunk_; // a dummy chunk to fulfill the API
2674	2676	};
	2677
	2678	/** \weakgroup ParallelProcessing
	2679	\sa ChunkedArrayLazy
	2680	*/
2675	2681
2676	2682	/** Implement ChunkedArray as a collection of in-memory chunks.
2677	2683

2793	2799
2794	2800	Alloc alloc_;
2795	2801	};
	2802
	2803	/** \weakgroup ParallelProcessing
	2804	\sa ChunkedArrayCompressed
	2805	*/
2796	2806
2797	2807	/** Implement ChunkedArray as a collection of potentially compressed
2798	2808	in-memory chunks.

2984	2994
2985	2995	CompressionMethod compression_method_;
2986	2996	};
	2997
	2998	/** \weakgroup ParallelProcessing
	2999	\sa ChunkedArrayTmpFile
	3000	*/
2987	3001
2988	3002	/** Implement ChunkedArray as a collection of chunks that can be
2989	3003	swapped out into a temporary file when asleep.

3121	3135	, file_size_()
3122	3136	, file_capacity_()
3123	3137	{
	3138	ignore_argument(path);
3124	3139	#ifdef VIGRA_NO_SPARSE_FILE
3125	3140	file_capacity_ = 4prod(this->chunk_shape_)sizeof(T);
3126	3141	#else

+26

-5

include/vigra/multi_array_chunked_hdf5.hxx less more

53	53	/** \addtogroup ChunkedArrayClasses
54	54	*/
55	55	//@{
	56
	57	/** \weakgroup ParallelProcessing
	58	\sa ChunkedArrayHDF5
	59	*/
56	60
57	61	/** Implement ChunkedArray as a chunked dataset in an HDF5 file.
58	62

221	225	HDF5File::OpenMode mode = HDF5File::ReadOnly,
222	226	ChunkedArrayOptions const & options = ChunkedArrayOptions(),
223	227	Alloc const & alloc = Alloc())
224		: ChunkedArray<N, T>(shape_type(), shape_type(), options),
	228	: ChunkedArray<N, T>(shape_type(),
	229	ceilPower2<N>(shape_type(file.getChunkShape(dataset).begin())),
	230	options),
225	231	file_(file),
226	232	dataset_name_(dataset),
227	233	dataset_(),

231	237	init(mode);
232	238	}
233	239
	240
	241	// copy constructor
	242	ChunkedArrayHDF5(const ChunkedArrayHDF5 & src)
	243	: ChunkedArray<N, T>(src),
	244	file_(src.file_),
	245	dataset_name_(src.dataset_name_),
	246	compression_(src.compression_),
	247	alloc_(src.alloc_)
	248	{
	249	if( file_.isReadOnly() )
	250	init(HDF5File::ReadOnly);
	251	else
	252	init(HDF5File::ReadWrite);
	253	}
	254
234	255	void init(HDF5File::OpenMode mode)
235	256	{
236	257	bool exists = file_.existsDataset(dataset_name_);

263	284	// H5Pset_chunk_cache (dapl, rdcc_nslots, rdcc_nbytes, rdcc_w0);
264	285	// Chunk cache size (rdcc_nbytes) should be large
265	286	// enough to hold all the chunks in a selection
266		// • If this is not possible, it may be best to disable chunk
	287	// * If this is not possible, it may be best to disable chunk
267	288	// caching altogether (set rdcc_nbytes to 0)
268		// • rdcc_slots should be a prime number that is at
	289	// * rdcc_slots should be a prime number that is at
269	290	// least 10 to 100 times the number of chunks that can fit
270	291	// into rdcc_nbytes
271		// • rdcc_w0 should be set to 1 if chunks that have been
	292	// * rdcc_w0 should be set to 1 if chunks that have been
272	293	// fully read/written will never be read/written again
273	294	//
274	295	// the above may be WRONG in general - it may only apply if the

300	321	{
301	322	vigra_precondition(fileShape.size() == N+1,
302	323	"ChunkedArrayHDF5(file, dataset): dataset has wrong dimension.");
303		vigra_precondition(fileShape[0] == TypeTraits::numberOfBands(),
	324	vigra_precondition(fileShape[0] == static_cast<unsigned>(TypeTraits::numberOfBands()),
304	325	"ChunkedArrayHDF5(file, dataset): dataset has wrong number of bands.");
305	326	shape_type shape(fileShape.begin()+1);
306	327	if(this->size() > 0)

+20

-18

include/vigra/multi_blockwise.hxx less more

197	197
198	198	parallel_foreach(options.getNumThreads(),
199	199	beginIter, endIter,
200		[&](const int threadId, const BlockWithBorder bwb)
	200	[&](const int /threadId/, const BlockWithBorder bwb)
201	201	{
202	202	// get the input of the block as a view
203	203	vigra::MultiArrayView<DIM, T_IN, ST_IN> sourceSub = source.subarray(bwb.border().begin(),

249	249
250	250	parallel_foreach(options.getNumThreads(),
251	251	beginIter, endIter,
252		[&](const int threadId, const BlockWithBorder bwb)
	252	[&](const int /threadId/, const BlockWithBorder bwb)
253	253	{
254	254	// get the input of the block as a view
255	255	vigra::MultiArrayView<DIM, T_IN, ST_IN> sourceSub = source.subarray(bwb.border().begin(),

273	273	public: \
274	274	typedef ConvolutionOptions<DIM> ConvOpt; \
275	275	FUNCTOR_NAME(const ConvOpt & convOpt) \
276		: convOpt_(convOpt){} \
	276	: sharedOpt_(convOpt){} \
277	277	template<class S, class D> \
278	278	void operator()(const S & s, D & d)const{ \
279		FUNCTION_NAME(s, d, convOpt_); \
	279	FUNCTION_NAME(s, d, sharedOpt_); \
280	280	} \
281	281	template<class S, class D,class SHAPE> \
282	282	void operator()(const S & s, D & d, const SHAPE & roiBegin, const SHAPE & roiEnd){ \
283		ConvOpt convOpt(convOpt_); \
284		convOpt.subarray(roiBegin, roiEnd); \
285		FUNCTION_NAME(s, d, convOpt); \
	283	ConvOpt localOpt(sharedOpt_); \
	284	localOpt.subarray(roiBegin, roiEnd); \
	285	FUNCTION_NAME(s, d, localOpt); \
286	286	} \
287	287	private: \
288		ConvOpt convOpt_; \
	288	ConvOpt sharedOpt_; \
289	289	};
290	290
291	291

305	305	public:
306	306	typedef ConvolutionOptions<DIM> ConvOpt;
307	307	HessianOfGaussianEigenvaluesFunctor(const ConvOpt & convOpt)
308		: convOpt_(convOpt){}
	308	: sharedOpt_(convOpt){}
309	309	template<class S, class D>
310	310	void operator()(const S & s, D & d)const{
311	311	typedef typename vigra::NumericTraits<typename S::value_type>::RealPromote RealType;
312	312	vigra::MultiArray<DIM, TinyVector<RealType, int(DIM*(DIM+1)/2)> > hessianOfGaussianRes(d.shape());
313		vigra::hessianOfGaussianMultiArray(s, hessianOfGaussianRes, convOpt_);
	313	vigra::hessianOfGaussianMultiArray(s, hessianOfGaussianRes, sharedOpt_);
314	314	vigra::tensorEigenvaluesMultiArray(hessianOfGaussianRes, d);
315	315	}
316	316	template<class S, class D,class SHAPE>
317	317	void operator()(const S & s, D & d, const SHAPE & roiBegin, const SHAPE & roiEnd){
318	318	typedef typename vigra::NumericTraits<typename S::value_type>::RealPromote RealType;
319	319	vigra::MultiArray<DIM, TinyVector<RealType, int(DIM*(DIM+1)/2)> > hessianOfGaussianRes(roiEnd-roiBegin);
320		convOpt_.subarray(roiBegin, roiEnd);
321		vigra::hessianOfGaussianMultiArray(s, hessianOfGaussianRes, convOpt_);
	320	ConvOpt localOpt(sharedOpt_);
	321	localOpt.subarray(roiBegin, roiEnd);
	322	vigra::hessianOfGaussianMultiArray(s, hessianOfGaussianRes, localOpt);
322	323	vigra::tensorEigenvaluesMultiArray(hessianOfGaussianRes, d);
323	324	}
324	325	private:
325		ConvOpt convOpt_;
	326	ConvOpt sharedOpt_;
326	327	};
327	328
328	329	template<unsigned int DIM, unsigned int EV>

330	331	public:
331	332	typedef ConvolutionOptions<DIM> ConvOpt;
332	333	HessianOfGaussianSelectedEigenvalueFunctor(const ConvOpt & convOpt)
333		: convOpt_(convOpt){}
	334	: sharedOpt_(convOpt){}
334	335	template<class S, class D>
335	336	void operator()(const S & s, D & d)const{
336	337	typedef typename vigra::NumericTraits<typename S::value_type>::RealPromote RealType;
337	338
338	339	// compute the hessian of gaussian and extract eigenvalue
339	340	vigra::MultiArray<DIM, TinyVector<RealType, int(DIM*(DIM+1)/2)> > hessianOfGaussianRes(s.shape());
340		vigra::hessianOfGaussianMultiArray(s, hessianOfGaussianRes, convOpt_);
	341	vigra::hessianOfGaussianMultiArray(s, hessianOfGaussianRes, sharedOpt_);
341	342
342	343	vigra::MultiArray<DIM, TinyVector<RealType, DIM > > allEigenvalues(s.shape());
343	344	vigra::tensorEigenvaluesMultiArray(hessianOfGaussianRes, allEigenvalues);

351	352
352	353	// compute the hessian of gaussian and extract eigenvalue
353	354	vigra::MultiArray<DIM, TinyVector<RealType, int(DIM*(DIM+1)/2)> > hessianOfGaussianRes(roiEnd-roiBegin);
354		convOpt_.subarray(roiBegin, roiEnd);
355		vigra::hessianOfGaussianMultiArray(s, hessianOfGaussianRes, convOpt_);
	355	ConvOpt localOpt(sharedOpt_);
	356	localOpt.subarray(roiBegin, roiEnd);
	357	vigra::hessianOfGaussianMultiArray(s, hessianOfGaussianRes, localOpt);
356	358
357	359	vigra::MultiArray<DIM, TinyVector<RealType, DIM > > allEigenvalues(roiEnd-roiBegin);
358	360	vigra::tensorEigenvaluesMultiArray(hessianOfGaussianRes, allEigenvalues);

360	362	d = allEigenvalues.bindElementChannel(EV);
361	363	}
362	364	private:
363		ConvOpt convOpt_;
	365	ConvOpt sharedOpt_;
364	366	};
365	367
366	368

+31

-8

include/vigra/multi_convolution.hxx less more

681	681
682	682	} // namespace detail
683	683
684		/** \addtogroup MultiArrayConvolutionFilters Convolution filters for multi-dimensional arrays.
685
686		These functions realize a separable convolution on an arbitrary dimensional
687		array that is specified by iterators (compatible to \ref MultiIteratorPage)
688		and shape objects. It can therefore be applied to a wide range of data structures
689		(\ref vigra::MultiArrayView, \ref vigra::MultiArray etc.).
	684	/** \addtogroup ConvolutionFilters
690	685	*/
691	686	//@{
692	687

1168	1163	/* */
1169	1164	/********************************************************/
1170	1165
	1166	/** \weakgroup ParallelProcessing
	1167	\sa gaussianSmoothMultiArray <B>(...,</B> BlockwiseConvolutionOptions<B>)</B>
	1168	*/
	1169
1171	1170	/** \brief Isotropic Gaussian smoothing of a multi-dimensional arrays.
1172	1171
1173	1172	This function computes an isotropic convolution of the given N-dimensional

1211	1210	MultiArrayView<N, T2, S2> dest,
1212	1211	ConvolutionOptions<N> opt);
1213	1212
1214		// as above, but execute algorirhm in parallel
	1213	// as above, but execute algorithm in parallel
1215	1214	template <unsigned int N, class T1, class S1,
1216	1215	class T2, class S2>
1217	1216	void

1391	1390	/* */
1392	1391	/********************************************************/
1393	1392
	1393	/** \weakgroup ParallelProcessing
	1394	\sa gaussianGradientMultiArray <B>(...,</B> BlockwiseConvolutionOptions<B>)</B>
	1395	*/
	1396
1394	1397	/** \brief Calculate Gaussian gradient of a multi-dimensional arrays.
1395	1398
1396	1399	This function computes the Gaussian gradient of the given N-dimensional

1733	1736	/* */
1734	1737	/********************************************************/
1735	1738
	1739	/** \weakgroup ParallelProcessing
	1740	\sa symmetricGradientMultiArray <B>(...,</B> BlockwiseConvolutionOptions<B>)</B>
	1741	*/
	1742
1736	1743	/** \brief Calculate gradient of a multi-dimensional arrays using symmetric difference filters.
1737	1744
1738	1745	This function computes the gradient of the given N-dimensional

1912	1919	/* laplacianOfGaussianMultiArray */
1913	1920	/* */
1914	1921	/********************************************************/
	1922
	1923	/** \weakgroup ParallelProcessing
	1924	\sa laplacianOfGaussianMultiArray <B>(...,</B> BlockwiseConvolutionOptions<B>)</B>
	1925	*/
1915	1926
1916	1927	/** \brief Calculate Laplacian of a N-dimensional arrays using Gaussian derivative filters.
1917	1928

2152	2163	/* */
2153	2164	/********************************************************/
2154	2165
	2166	/** \weakgroup ParallelProcessing
	2167	\sa gaussianDivergenceMultiArray <B>(...,</B> BlockwiseConvolutionOptions<B>)</B>
	2168	*/
	2169
2155	2170	/** \brief Calculate the divergence of a vector field using Gaussian derivative filters.
2156	2171
2157	2172	This function computes the divergence of the given N-dimensional vector field

2335	2350	/* hessianOfGaussianMultiArray */
2336	2351	/* */
2337	2352	/********************************************************/
	2353
	2354	/** \weakgroup ParallelProcessing
	2355	\sa hessianOfGaussianMultiArray <B>(...,</B> BlockwiseConvolutionOptions<B>)</B>
	2356	*/
2338	2357
2339	2358	/** \brief Calculate Hessian matrix of a N-dimensional arrays using Gaussian derivative filters.
2340	2359

2606	2625	/* */
2607	2626	/********************************************************/
2608	2627
2609		/** \brief Calculate th structure tensor of a multi-dimensional arrays.
	2628	/** \weakgroup ParallelProcessing
	2629	\sa structureTensorMultiArray <B>(...,</B> BlockwiseConvolutionOptions<B>)</B>
	2630	*/
	2631
	2632	/** \brief Calculate the structure tensor of a multi-dimensional arrays.
2610	2633
2611	2634	This function computes the gradient (outer product) tensor for each element
2612	2635	of the given N-dimensional array with first-derivative-of-Gaussian filters at

+95

-98

include/vigra/multi_distance.hxx less more

61	61	{
62	62	double left, center, right;
63	63	Value apex_height;
64
	64
65	65	DistParabolaStackEntry(Value const & p, double l, double c, double r)
66	66	: left(l), center(c), right(r), apex_height(p)
67	67	{}

84	84	double w = iend - is;
85	85	if(w <= 0)
86	86	return;
87
	87
88	88	double sigma2 = sigma * sigma;
89	89	double sigma22 = 2.0 * sigma2;
90
	90
91	91	typedef typename SrcAccessor::value_type SrcType;
92	92	typedef DistParabolaStackEntry<SrcType> Influence;
93	93	std::vector<Influence> _stack;
94	94	_stack.push_back(Influence(sa(is), 0.0, 0.0, w));
95
	95
96	96	++is;
97	97	double current = 1.0;
98	98	for(;current < w; ++is, ++current)
99	99	{
100	100	double intersection;
101
	101
102	102	while(true)
103	103	{
104	104	Influence & s = _stack.back();
105	105	double diff = current - s.center;
106	106	intersection = current + (sa(is) - s.apex_height - sigma2sq(diff)) / (sigma22 diff);
107
	107
108	108	if( intersection < s.left) // previous point has no influence
109	109	{
110	110	_stack.pop_back();

128	128	typename std::vector<Influence>::iterator it = _stack.begin();
129	129	for(current = 0.0; current < w; ++current, ++id)
130	130	{
131		while( current >= it->right)
132		++it;
	131	while( current >= it->right)
	132	++it;
133	133	da.set(sigma2 * sq(current - it->center) + it->apex_height, id);
134	134	}
135	135	}

162	162
163	163	// we need the Promote type here if we want to invert the image (dilation)
164	164	typedef typename NumericTraits<typename DestAccessor::value_type>::RealPromote TmpType;
165
	165
166	166	// temporary array to hold the current line to enable in-place operation
167	167	ArrayVector<TmpType> tmp( shape[0] );
168	168
169	169	typedef MultiArrayNavigator<SrcIterator, N> SNavigator;
170	170	typedef MultiArrayNavigator<DestIterator, N> DNavigator;
171
172
	171
	172
173	173	// only operate on first dimension here
174	174	SNavigator snav( si, shape, 0 );
175	175	DNavigator dnav( di, shape, 0 );

182	182	// Invert the values if necessary. Only needed for grayscale morphology
183	183	if(invert)
184	184	transformLine( snav.begin(), snav.end(), src, tmp.begin(),
185		typename AccessorTraits<TmpType>::default_accessor(),
	185	typename AccessorTraits<TmpType>::default_accessor(),
186	186	Param(NumericTraits<TmpType>::zero())-Arg1());
187	187	else
188	188	copyLine( snav.begin(), snav.end(), src, tmp.begin(),

192	192	typename AccessorTraits<TmpType>::default_const_accessor()),
193	193	destIter( dnav.begin(), dest ), sigmas[0] );
194	194	}
195
	195
196	196	// operate on further dimensions
197	197	for( int d = 1; d < N; ++d )
198	198	{
199	199	DNavigator dnav( di, shape, d );
200	200
201	201	tmp.resize( shape[d] );
202
	202
203	203
204	204	for( ; dnav.hasMore(); dnav++ )
205	205	{

234	234
235	235	} // namespace detail
236	236
237		/** \addtogroup MultiArrayDistanceTransform Euclidean distance transform for multi-dimensional arrays.
238
239		These functions perform variants of the Euclidean distance transform on
240		arbitrary dimensional arrays.
	237	/** \addtogroup DistanceTransform
241	238	*/
242	239	//@{
243	240

259	256	namespace vigra {
260	257	// explicitly specify pixel pitch for each coordinate
261	258	template <unsigned int N, class T1, class S1,
262		class T2, class S2,
	259	class T2, class S2,
263	260	class Array>
264	261	void
265	262	separableMultiDistSquared(MultiArrayView<N, T1, S1> const & source,

272	269	class T2, class S2>
273	270	void
274	271	separableMultiDistSquared(MultiArrayView<N, T1, S1> const & source,
275		MultiArrayView<N, T2, S2> dest,
	272	MultiArrayView<N, T2, S2> dest,
276	273	bool background);
277	274	}
278	275	\endcode

284	281	// explicitly specify pixel pitch for each coordinate
285	282	template <class SrcIterator, class SrcShape, class SrcAccessor,
286	283	class DestIterator, class DestAccessor, class Array>
287		void
	284	void
288	285	separableMultiDistSquared( SrcIterator s, SrcShape const & shape, SrcAccessor src,
289		DestIterator d, DestAccessor dest,
	286	DestIterator d, DestAccessor dest,
290	287	bool background,
291	288	Array const & pixelPitch);
292
	289
293	290	// use default pixel pitch = 1.0 for each coordinate
294	291	template <class SrcIterator, class SrcShape, class SrcAccessor,
295	292	class DestIterator, class DestAccessor>
296	293	void
297	294	separableMultiDistSquared(SrcIterator siter, SrcShape const & shape, SrcAccessor src,
298		DestIterator diter, DestAccessor dest,
	295	DestIterator diter, DestAccessor dest,
299	296	bool background);
300	297
301	298	}

306	303	// explicitly specify pixel pitch for each coordinate
307	304	template <class SrcIterator, class SrcShape, class SrcAccessor,
308	305	class DestIterator, class DestAccessor, class Array>
309		void
	306	void
310	307	separableMultiDistSquared( triple<SrcIterator, SrcShape, SrcAccessor> const & source,
311		pair<DestIterator, DestAccessor> const & dest,
	308	pair<DestIterator, DestAccessor> const & dest,
312	309	bool background,
313	310	Array const & pixelPitch);
314
	311
315	312	// use default pixel pitch = 1.0 for each coordinate
316	313	template <class SrcIterator, class SrcShape, class SrcAccessor,
317	314	class DestIterator, class DestAccessor>

329	326	arrays are represented by iterators, shape objects and accessors.
330	327	The destination array is required to already have the correct size.
331	328
332		This function expects a mask as its source, where background pixels are
333		marked as zero, and non-background pixels as non-zero. If the parameter
	329	This function expects a mask as its source, where background pixels are
	330	marked as zero, and non-background pixels as non-zero. If the parameter
334	331	<i>background</i> is true, then the squared distance of all background
335	332	pixels to the nearest object is calculated. Otherwise, the distance of all
336	333	object pixels to the nearest background pixel is calculated.
337
338		Optionally, one can pass an array that specifies the pixel pitch in each direction.
	334
	335	Optionally, one can pass an array that specifies the pixel pitch in each direction.
339	336	This is necessary when the data have non-uniform resolution (as is common in confocal
340		microscopy, for example).
	337	microscopy, for example).
341	338
342	339	This function may work in-place, which means that <tt>siter == diter</tt> is allowed.
343	340	A full-sized internal array is only allocated if working on the destination

356	353	MultiArray<3, unsigned int> dest(shape);
357	354	...
358	355
359		// Calculate Euclidean distance squared for all background pixels
	356	// Calculate Euclidean distance squared for all background pixels
360	357	separableMultiDistSquared(source, dest, true);
361	358	\endcode
362	359

386	383	pixelPitchIsReal = true;
387	384	dmax += sq(pixelPitch[k]*shape[k]);
388	385	}
389
	386
390	387	using namespace vigra::functor;
391
392		if(dmax > NumericTraits<DestType>::toRealPromote(NumericTraits<DestType>::max())
	388
	389	if(dmax > NumericTraits<DestType>::toRealPromote(NumericTraits<DestType>::max())
393	390	\|\| pixelPitchIsReal) // need a temporary array to avoid overflows
394	391	{
395	392	// Threshold the values so all objects have infinity value in the beginning
396	393	Real maxDist = (Real)dmax, rzero = (Real)0.0;
397	394	MultiArray<SrcShape::static_size, Real> tmpArray(shape);
398	395	if(background == true)
399		transformMultiArray( s, shape, src,
	396	transformMultiArray( s, shape, src,
400	397	tmpArray.traverser_begin(), typename AccessorTraits<Real>::default_accessor(),
401	398	ifThenElse( Arg1() == Param(zero), Param(maxDist), Param(rzero) ));
402	399	else
403		transformMultiArray( s, shape, src,
	400	transformMultiArray( s, shape, src,
404	401	tmpArray.traverser_begin(), typename AccessorTraits<Real>::default_accessor(),
405	402	ifThenElse( Arg1() != Param(zero), Param(maxDist), Param(rzero) ));
406
407		detail::internalSeparableMultiArrayDistTmp( tmpArray.traverser_begin(),
	403
	404	detail::internalSeparableMultiArrayDistTmp( tmpArray.traverser_begin(),
408	405	shape, typename AccessorTraits<Real>::default_accessor(),
409		tmpArray.traverser_begin(),
	406	tmpArray.traverser_begin(),
410	407	typename AccessorTraits<Real>::default_accessor(), pixelPitch);
411
	408
412	409	copyMultiArray(srcMultiArrayRange(tmpArray), destIter(d, dest));
413	410	}
414		else // work directly on the destination array
	411	else // work directly on the destination array
415	412	{
416	413	// Threshold the values so all objects have infinity value in the beginning
417	414	DestType maxDist = DestType(std::ceil(dmax)), rzero = (DestType)0;

419	416	transformMultiArray( s, shape, src, d, dest,
420	417	ifThenElse( Arg1() == Param(zero), Param(maxDist), Param(rzero) ));
421	418	else
422		transformMultiArray( s, shape, src, d, dest,
	419	transformMultiArray( s, shape, src, d, dest,
423	420	ifThenElse( Arg1() != Param(zero), Param(maxDist), Param(rzero) ));
424
	421
425	422	detail::internalSeparableMultiArrayDistTmp( d, shape, dest, d, dest, pixelPitch);
426	423	}
427	424	}
428	425
429	426	template <class SrcIterator, class SrcShape, class SrcAccessor,
430	427	class DestIterator, class DestAccessor>
431		inline
	428	inline
432	429	void separableMultiDistSquared( SrcIterator s, SrcShape const & shape, SrcAccessor src,
433	430	DestIterator d, DestAccessor dest, bool background)
434	431	{

456	453	}
457	454
458	455	template <unsigned int N, class T1, class S1,
459		class T2, class S2,
	456	class T2, class S2,
460	457	class Array>
461	458	inline void
462	459	separableMultiDistSquared(MultiArrayView<N, T1, S1> const & source,

497	494	// explicitly specify pixel pitch for each coordinate
498	495	template <unsigned int N, class T1, class S1,
499	496	class T2, class S2, class Array>
500		void
	497	void
501	498	separableMultiDistance(MultiArrayView<N, T1, S1> const & source,
502		MultiArrayView<N, T2, S2> dest,
	499	MultiArrayView<N, T2, S2> dest,
503	500	bool background,
504	501	Array const & pixelPitch);
505	502
506	503	// use default pixel pitch = 1.0 for each coordinate
507	504	template <unsigned int N, class T1, class S1,
508	505	class T2, class S2>
509		void
	506	void
510	507	separableMultiDistance(MultiArrayView<N, T1, S1> const & source,
511		MultiArrayView<N, T2, S2> dest,
	508	MultiArrayView<N, T2, S2> dest,
512	509	bool background);
513	510	}
514	511	\endcode

520	517	// explicitly specify pixel pitch for each coordinate
521	518	template <class SrcIterator, class SrcShape, class SrcAccessor,
522	519	class DestIterator, class DestAccessor, class Array>
523		void
	520	void
524	521	separableMultiDistance( SrcIterator s, SrcShape const & shape, SrcAccessor src,
525		DestIterator d, DestAccessor dest,
	522	DestIterator d, DestAccessor dest,
526	523	bool background,
527	524	Array const & pixelPitch);
528
	525
529	526	// use default pixel pitch = 1.0 for each coordinate
530	527	template <class SrcIterator, class SrcShape, class SrcAccessor,
531	528	class DestIterator, class DestAccessor>
532	529	void
533	530	separableMultiDistance(SrcIterator siter, SrcShape const & shape, SrcAccessor src,
534		DestIterator diter, DestAccessor dest,
	531	DestIterator diter, DestAccessor dest,
535	532	bool background);
536	533
537	534	}

542	539	// explicitly specify pixel pitch for each coordinate
543	540	template <class SrcIterator, class SrcShape, class SrcAccessor,
544	541	class DestIterator, class DestAccessor, class Array>
545		void
	542	void
546	543	separableMultiDistance( triple<SrcIterator, SrcShape, SrcAccessor> const & source,
547		pair<DestIterator, DestAccessor> const & dest,
	544	pair<DestIterator, DestAccessor> const & dest,
548	545	bool background,
549	546	Array const & pixelPitch);
550
	547
551	548	// use default pixel pitch = 1.0 for each coordinate
552	549	template <class SrcIterator, class SrcShape, class SrcAccessor,
553	550	class DestIterator, class DestAccessor>

564	561	multi-dimensional array. It simply calls \ref separableMultiDistSquared()
565	562	and takes the pixel-wise square root of the result. See \ref separableMultiDistSquared()
566	563	for more documentation.
567
	564
568	565	<b> Usage:</b>
569	566
570	567	<b>\#include</b> \<vigra/multi_distance.hxx\><br/>

576	573	MultiArray<3, float> dest(shape);
577	574	...
578	575
579		// Calculate Euclidean distance for all background pixels
	576	// Calculate Euclidean distance for all background pixels
580	577	separableMultiDistance(source, dest, true);
581	578	\endcode
582	579

591	588	Array const & pixelPitch)
592	589	{
593	590	separableMultiDistSquared( s, shape, src, d, dest, background, pixelPitch);
594
	591
595	592	// Finally, calculate the square root of the distances
596	593	using namespace vigra::functor;
597
	594
598	595	transformMultiArray( d, shape, dest, d, dest, sqrt(Arg1()) );
599	596	}
600	597

604	601	DestIterator d, DestAccessor dest, bool background)
605	602	{
606	603	separableMultiDistSquared( s, shape, src, d, dest, background);
607
	604
608	605	// Finally, calculate the square root of the distances
609	606	using namespace vigra::functor;
610
	607
611	608	transformMultiArray( d, shape, dest, d, dest, sqrt(Arg1()) );
612	609	}
613	610

632	629
633	630	template <unsigned int N, class T1, class S1,
634	631	class T2, class S2, class Array>
635		inline void
	632	inline void
636	633	separableMultiDistance(MultiArrayView<N, T1, S1> const & source,
637		MultiArrayView<N, T2, S2> dest,
	634	MultiArrayView<N, T2, S2> dest,
638	635	bool background,
639	636	Array const & pixelPitch)
640	637	{

646	643
647	644	template <unsigned int N, class T1, class S1,
648	645	class T2, class S2>
649		inline void
	646	inline void
650	647	separableMultiDistance(MultiArrayView<N, T1, S1> const & source,
651		MultiArrayView<N, T2, S2> dest,
	648	MultiArrayView<N, T2, S2> dest,
652	649	bool background)
653	650	{
654	651	vigra_precondition(source.shape() == dest.shape(),

660	657	//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% BoundaryDistanceTransform %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
661	658
662	659	//rewrite labeled data and work with separableMultiDist
663		namespace lemon_graph {
	660	namespace lemon_graph {
664	661
665	662	template <class Graph, class T1Map, class T2Map>
666		void
	663	void
667	664	markRegionBoundaries(Graph const & g,
668	665	T1Map const & labels,
669	666	T2Map & out)

672	669	typedef typename Graph::OutBackArcIt neighbor_iterator;
673	670
674	671	//find faces
675		for (graph_scanner node(g); node != INVALID; ++node)
	672	for (graph_scanner node(g); node != INVALID; ++node)
676	673	{
677	674	typename T1Map::value_type center = labels[*node];
678
	675
679	676	for (neighbor_iterator arc(g, node); arc != INVALID; ++arc)
680	677	{
681	678	// set adjacent nodes with different labels to 1

719	716	/********************************************************/
720	717
721	718	template <class DestIterator, class LabelIterator>
722		void
723		boundaryDistParabola(DestIterator is, DestIterator iend,
724		LabelIterator ilabels,
	719	void
	720	boundaryDistParabola(DestIterator is, DestIterator iend,
	721	LabelIterator ilabels,
725	722	double dmax,
726	723	bool array_border_is_active=false)
727	724	{

755	752	Influence & s = _stack.back();
756	753	double diff = current - s.center;
757	754	double intersection = current + (apex_height - s.apex_height - sq(diff)) / (2.0 * diff);
758
	755
759	756	if(intersection < s.left) // previous parabola has no influence
760	757	{
761	758	_stack.pop_back();

772	769	_stack.push_back(Influence(apex_height, intersection, current, w));
773	770	if(current < w && current_label == *ilabels)
774	771	break; // finished present pixel, advance to next one
775
	772
776	773	// label changed => finalize the current segment
777	774	typename Stack::iterator it = _stack.begin();
778	775	for(double c = begin; c < current; ++c, ++id)
779	776	{
780		while(c >= it->right)
781		++it;
	777	while(c >= it->right)
	778	++it;
782	779	*id = sq(c - it->center) + it->apex_height;
783	780	}
784	781	if(current == w)
785	782	break; // stop when this was the last segment
786
	783
787	784	// initialize the new segment
788	785	begin = current;
789	786	current_label = *ilabels;
790	787	apex_height = *is;
791	788	Stack(1, Influence(0.0, begin-1.0, begin-1.0, w)).swap(_stack);
792		// don't advance to next pixel here, because the present pixel must also
	789	// don't advance to next pixel here, because the present pixel must also
793	790	// be analysed in the context of the new segment
794	791	}
795	792	}

813	810	typedef typename MultiArrayView<N, T2, S2>::traverser DestIterator;
814	811	typedef MultiArrayNavigator<LabelIterator, N> LabelNavigator;
815	812	typedef MultiArrayNavigator<DestIterator, N> DNavigator;
816
	813
817	814	dest = dmax;
818		for( int d = 0; d < N; ++d )
	815	for( unsigned d = 0; d < N; ++d )
819	816	{
820	817	LabelNavigator lnav( labels.traverser_begin(), labels.shape(), d );
821	818	DNavigator dnav( dest.traverser_begin(), dest.shape(), d );

823	820	for( ; dnav.hasMore(); dnav++, lnav++ )
824	821	{
825	822	boundaryDistParabola(dnav.begin(), dnav.end(),
826		lnav.begin(),
	823	lnav.begin(),
827	824	dmax, array_border_is_active);
828	825	}
829	826	}

831	828
832	829	} // namespace detail
833	830
834		/** \brief Specify which boundary is used for boundaryMultiDistance().
835
	831	/** \brief Specify which boundary is used for boundaryMultiDistance().
	832
836	833	*/
837	834	enum BoundaryDistanceTag {
838	835	OuterBoundary, ///< Pixels just outside of each region

863	860	BoundaryDistanceTag boundary=InterpixelBoundary);
864	861	}
865	862	\endcode
866
	863
867	864	This function computes the distance transform of a labeled image <i>simultaneously</i>
868	865	for all regions. Depending on the requested type of \a boundary, three modes
869	866	are supported:

874	871	<li><tt>InterpixelBoundary</tt> (default): Like <tt>OuterBoundary</tt>, but shift the distance
875	872	to the interpixel boundary by subtractiong 1/2. This make the distences consistent
876	873	accross boundaries.</li>
877		<li><tt>InnerBoundary</tt>: In each region, compute the distance to the nearest pixel in the
	874	<li><tt>InnerBoundary</tt>: In each region, compute the distance to the nearest pixel in the
878	875	region which is adjacent to the boundary. </li>
879	876	</ul>
880		If <tt>array_border_is_active=true</tt>, the
881		outer border of the array (i.e. the interpixel boundary between the array
882		and the infinite region) is also used. Otherwise (the default), regions
	877	If <tt>array_border_is_active=true</tt>, the
	878	outer border of the array (i.e. the interpixel boundary between the array
	879	and the infinite region) is also used. Otherwise (the default), regions
883	880	touching the array border are treated as if they extended to infinity.
884
	881
885	882	<b> Usage:</b>
886	883
887	884	<b>\#include</b> \<vigra/multi_distance.hxx\><br/>

896	893
897	894	// find regions (interpixel boundaries are implied)
898	895	labelMultiArray(source, labels);
899
900		// Calculate Euclidean distance to interpixel boundary for all pixels
	896
	897	// Calculate Euclidean distance to interpixel boundary for all pixels
901	898	boundaryMultiDistance(labels, dest);
902	899	\endcode
903	900

915	912	{
916	913	vigra_precondition(labels.shape() == dest.shape(),
917	914	"boundaryMultiDistance(): shape mismatch between input and output.");
918
	915
919	916	using namespace vigra::functor;
920
	917
921	918	if(boundary == InnerBoundary)
922	919	{
923	920	MultiArray<N, unsigned char> boundaries(labels.shape());
924
	921
925	922	markRegionBoundaries(labels, boundaries, IndirectNeighborhood);
926	923	if(array_border_is_active)
927	924	initMultiArrayBorder(boundaries, 1, 1);

930	927	else
931	928	{
932	929	T2 offset = 0.0;
933
	930
934	931	if(boundary == InterpixelBoundary)
935	932	{
936	933	vigra_precondition(!NumericTraits<T2>::isIntegral::value,

+653

-650

include/vigra/multi_fft.hxx less more

36	36	#define VIGRA_MULTI_FFT_HXX
37	37
38	38	#include "fftw3.hxx"
	39	#include "metaprogramming.hxx"
39	40	#include "multi_array.hxx"
40	41	#include "multi_math.hxx"
41	42	#include "navigator.hxx"

50	51	/* */
51	52	/********************************************************/
52	53
53		/** \addtogroup FourierTransform
	54	/** \addtogroup FourierTransform
54	55	*/
55	56	//@{
56	57

62	63	typedef typename MultiArrayView<N, T, C>::traverser Traverser;
63	64	typedef MultiArrayNavigator<Traverser, N> Navigator;
64	65	typedef typename Navigator::iterator Iterator;
65
	66
66	67	for(unsigned int d = startDimension; d < N; ++d)
67	68	{
68	69	Navigator nav(a.traverser_begin(), a.shape(), d);

72	73	Iterator i = nav.begin();
73	74	int s = nav.end() - i;
74	75	int s2 = s/2;
75
	76
76	77	if(even(s))
77	78	{
78	79	for(int k=0; k<s2; ++k)

80	81	std::swap(i[k], i[k+s2]);
81	82	}
82	83	}
83		else
	84	else
84	85	{
85	86	T v = i[0];
86	87	for(int k=0; k<s2; ++k)

100	101	typedef typename MultiArrayView<N, T, C>::traverser Traverser;
101	102	typedef MultiArrayNavigator<Traverser, N> Navigator;
102	103	typedef typename Navigator::iterator Iterator;
103
	104
104	105	for(unsigned int d = startDimension; d < N; ++d)
105	106	{
106	107	Navigator nav(a.traverser_begin(), a.shape(), d);

110	111	Iterator i = nav.begin();
111	112	int s = nav.end() - i;
112	113	int s2 = s/2;
113
	114
114	115	if(even(s))
115	116	{
116	117	for(int k=0; k<s2; ++k)

118	119	std::swap(i[k], i[k+s2]);
119	120	}
120	121	}
121		else
	122	else
122	123	{
123	124	T v = i[s2];
124	125	for(int k=s2; k>0; --k)

174	175	{
175	176	public:
176	177	threading::lock_guard<threading::mutex> guard_;
177
	178
178	179	FFTWLock()
179	180	: guard_(plan_mutex_)
180	181	{}
181
	182
182	183	static threading::mutex plan_mutex_;
183	184	};
184	185

191	192	class FFTWLock
192	193	{
193	194	public:
194
	195
195	196	FFTWLock()
196	197	{}
197	198	};
198	199
199	200	#endif // not VIGRA_SINGLE_THREADED
200	201
201		inline fftw_plan
202		fftwPlanCreate(unsigned int N, int* shape,
	202	inline fftw_plan
	203	fftwPlanCreate(unsigned int N, int* shape,
203	204	FFTWComplex<double> * in, int* instrides, int instep,
204	205	FFTWComplex<double> * out, int* outstrides, int outstep,
205	206	int sign, unsigned int planner_flags)

210	211	sign, planner_flags);
211	212	}
212	213
213		inline fftw_plan
214		fftwPlanCreate(unsigned int N, int* shape,
	214	inline fftw_plan
	215	fftwPlanCreate(unsigned int N, int* shape,
215	216	double * in, int* instrides, int instep,
216	217	FFTWComplex<double> * out, int* outstrides, int outstep,
217	218	int /sign is ignored/, unsigned int planner_flags)

222	223	planner_flags);
223	224	}
224	225
225		inline fftw_plan
226		fftwPlanCreate(unsigned int N, int* shape,
	226	inline fftw_plan
	227	fftwPlanCreate(unsigned int N, int* shape,
227	228	FFTWComplex<double> * in, int* instrides, int instep,
228	229	double * out, int* outstrides, int outstep,
229	230	int /sign is ignored/, unsigned int planner_flags)

234	235	planner_flags);
235	236	}
236	237
237		inline fftwf_plan
238		fftwPlanCreate(unsigned int N, int* shape,
	238	inline fftwf_plan
	239	fftwPlanCreate(unsigned int N, int* shape,
239	240	FFTWComplex<float> * in, int* instrides, int instep,
240	241	FFTWComplex<float> * out, int* outstrides, int outstep,
241	242	int sign, unsigned int planner_flags)

246	247	sign, planner_flags);
247	248	}
248	249
249		inline fftwf_plan
250		fftwPlanCreate(unsigned int N, int* shape,
	250	inline fftwf_plan
	251	fftwPlanCreate(unsigned int N, int* shape,
251	252	float * in, int* instrides, int instep,
252	253	FFTWComplex<float> * out, int* outstrides, int outstep,
253	254	int /sign is ignored/, unsigned int planner_flags)

258	259	planner_flags);
259	260	}
260	261
261		inline fftwf_plan
262		fftwPlanCreate(unsigned int N, int* shape,
	262	inline fftwf_plan
	263	fftwPlanCreate(unsigned int N, int* shape,
263	264	FFTWComplex<float> * in, int* instrides, int instep,
264	265	float * out, int* outstrides, int outstep,
265	266	int /sign is ignored/, unsigned int planner_flags)

270	271	planner_flags);
271	272	}
272	273
273		inline fftwl_plan
274		fftwPlanCreate(unsigned int N, int* shape,
	274	inline fftwl_plan
	275	fftwPlanCreate(unsigned int N, int* shape,
275	276	FFTWComplex<long double> * in, int* instrides, int instep,
276	277	FFTWComplex<long double> * out, int* outstrides, int outstep,
277	278	int sign, unsigned int planner_flags)

282	283	sign, planner_flags);
283	284	}
284	285
285		inline fftwl_plan
286		fftwPlanCreate(unsigned int N, int* shape,
	286	inline fftwl_plan
	287	fftwPlanCreate(unsigned int N, int* shape,
287	288	long double * in, int* instrides, int instep,
288	289	FFTWComplex<long double> * out, int* outstrides, int outstep,
289	290	int /sign is ignored/, unsigned int planner_flags)

294	295	planner_flags);
295	296	}
296	297
297		inline fftwl_plan
298		fftwPlanCreate(unsigned int N, int* shape,
	298	inline fftwl_plan
	299	fftwPlanCreate(unsigned int N, int* shape,
299	300	FFTWComplex<long double> * in, int* instrides, int instep,
300	301	long double * out, int* outstrides, int outstep,
301	302	int /sign is ignored/, unsigned int planner_flags)

324	325	fftwl_destroy_plan(plan);
325	326	}
326	327
327		inline void
328		fftwPlanExecute(fftw_plan plan)
	328	inline void
	329	fftwPlanExecute(fftw_plan plan)
329	330	{
330	331	fftw_execute(plan);
331	332	}
332	333
333		inline void
334		fftwPlanExecute(fftwf_plan plan)
	334	inline void
	335	fftwPlanExecute(fftwf_plan plan)
335	336	{
336	337	fftwf_execute(plan);
337	338	}
338	339
339		inline void
340		fftwPlanExecute(fftwl_plan plan)
	340	inline void
	341	fftwPlanExecute(fftwl_plan plan)
341	342	{
342	343	fftwl_execute(plan);
343	344	}
344	345
345		inline void
346		fftwPlanExecute(fftw_plan plan, FFTWComplex<double> * in, FFTWComplex<double> * out)
	346	inline void
	347	fftwPlanExecute(fftw_plan plan, FFTWComplex<double> * in, FFTWComplex<double> * out)
347	348	{
348	349	fftw_execute_dft(plan, (fftw_complex )in, (fftw_complex )out);
349	350	}
350	351
351		inline void
352		fftwPlanExecute(fftw_plan plan, double * in, FFTWComplex<double> * out)
	352	inline void
	353	fftwPlanExecute(fftw_plan plan, double * in, FFTWComplex<double> * out)
353	354	{
354	355	fftw_execute_dft_r2c(plan, in, (fftw_complex *)out);
355	356	}
356	357
357		inline void
358		fftwPlanExecute(fftw_plan plan, FFTWComplex<double> * in, double * out)
	358	inline void
	359	fftwPlanExecute(fftw_plan plan, FFTWComplex<double> * in, double * out)
359	360	{
360	361	fftw_execute_dft_c2r(plan, (fftw_complex *)in, out);
361	362	}
362	363
363		inline void
364		fftwPlanExecute(fftwf_plan plan, FFTWComplex<float> * in, FFTWComplex<float> * out)
	364	inline void
	365	fftwPlanExecute(fftwf_plan plan, FFTWComplex<float> * in, FFTWComplex<float> * out)
365	366	{
366	367	fftwf_execute_dft(plan, (fftwf_complex )in, (fftwf_complex )out);
367	368	}
368	369
369		inline void
370		fftwPlanExecute(fftwf_plan plan, float * in, FFTWComplex<float> * out)
	370	inline void
	371	fftwPlanExecute(fftwf_plan plan, float * in, FFTWComplex<float> * out)
371	372	{
372	373	fftwf_execute_dft_r2c(plan, in, (fftwf_complex *)out);
373	374	}
374	375
375		inline void
376		fftwPlanExecute(fftwf_plan plan, FFTWComplex<float> * in, float * out)
	376	inline void
	377	fftwPlanExecute(fftwf_plan plan, FFTWComplex<float> * in, float * out)
377	378	{
378	379	fftwf_execute_dft_c2r(plan, (fftwf_complex *)in, out);
379	380	}
380	381
381		inline void
382		fftwPlanExecute(fftwl_plan plan, FFTWComplex<long double> * in, FFTWComplex<long double> * out)
	382	inline void
	383	fftwPlanExecute(fftwl_plan plan, FFTWComplex<long double> * in, FFTWComplex<long double> * out)
383	384	{
384	385	fftwl_execute_dft(plan, (fftwl_complex )in, (fftwl_complex )out);
385	386	}
386	387
387		inline void
388		fftwPlanExecute(fftwl_plan plan, long double * in, FFTWComplex<long double> * out)
	388	inline void
	389	fftwPlanExecute(fftwl_plan plan, long double * in, FFTWComplex<long double> * out)
389	390	{
390	391	fftwl_execute_dft_r2c(plan, in, (fftwl_complex *)out);
391	392	}
392	393
393		inline void
394		fftwPlanExecute(fftwl_plan plan, FFTWComplex<long double> * in, long double * out)
	394	inline void
	395	fftwPlanExecute(fftwl_plan plan, FFTWComplex<long double> * in, long double * out)
395	396	{
396	397	fftwl_execute_dft_c2r(plan, (fftwl_complex *)in, out);
397	398	}

403	404	static const int evenSize = 1063;
404	405	static int goodSizes[size];
405	406	static int goodEvenSizes[evenSize];
406
	407
407	408	static inline int find(int s)
408	409	{
409	410	if(s <= 0 \|\| s >= goodSizes[size-1])

428	429	return *upperBound;
429	430	}
430	431	};
431
	432
432	433	// Image sizes where FFTW is fast. The list contains all
433	434	// numbers less than 100000 whose prime decomposition is of the form
434		// 2^a3^b5^c7^d11^e*13^f, where e+f is either 0 or 1, and the
	435	// 2^a3^b5^c7^d11^e*13^f, where e+f is either 0 or 1, and the
435	436	// other exponents are arbitrary
436	437	template <int DUMMY>
437	438	int FFTWPaddingSize<DUMMY>::goodSizes[size] = {
438		1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
439		18, 20, 21, 22, 24, 25, 26, 27, 28, 30, 32, 33, 35, 36, 39, 40, 42, 44, 45, 48,
440		49, 50, 52, 54, 55, 56, 60, 63, 64, 65, 66, 70, 72, 75, 77, 78, 80, 81,
441		84, 88, 90, 91, 96, 98, 99, 100, 104, 105, 108, 110, 112, 117, 120, 125,
442		126, 128, 130, 132, 135, 140, 144, 147, 150, 154, 156, 160, 162, 165,
443		168, 175, 176, 180, 182, 189, 192, 195, 196, 198, 200, 208, 210, 216,
444		220, 224, 225, 231, 234, 240, 243, 245, 250, 252, 256, 260, 264, 270,
445		273, 275, 280, 288, 294, 297, 300, 308, 312, 315, 320, 324, 325, 330,
446		336, 343, 350, 351, 352, 360, 364, 375, 378, 384, 385, 390, 392, 396,
447		400, 405, 416, 420, 432, 440, 441, 448, 450, 455, 462, 468, 480, 486,
448		490, 495, 500, 504, 512, 520, 525, 528, 539, 540, 546, 550, 560, 567,
449		576, 585, 588, 594, 600, 616, 624, 625, 630, 637, 640, 648, 650, 660,
450		672, 675, 686, 693, 700, 702, 704, 720, 728, 729, 735, 750, 756, 768,
451		770, 780, 784, 792, 800, 810, 819, 825, 832, 840, 864, 875, 880, 882,
452		891, 896, 900, 910, 924, 936, 945, 960, 972, 975, 980, 990, 1000, 1008,
453		1024, 1029, 1040, 1050, 1053, 1056, 1078, 1080, 1092, 1100, 1120, 1125,
454		1134, 1152, 1155, 1170, 1176, 1188, 1200, 1215, 1225, 1232, 1248, 1250,
455		1260, 1274, 1280, 1296, 1300, 1320, 1323, 1344, 1350, 1365, 1372, 1375,
456		1386, 1400, 1404, 1408, 1440, 1456, 1458, 1470, 1485, 1500, 1512, 1536,
457		1540, 1560, 1568, 1575, 1584, 1600, 1617, 1620, 1625, 1638, 1650, 1664,
458		1680, 1701, 1715, 1728, 1750, 1755, 1760, 1764, 1782, 1792, 1800, 1820,
459		1848, 1872, 1875, 1890, 1911, 1920, 1925, 1944, 1950, 1960, 1980, 2000,
460		2016, 2025, 2048, 2058, 2079, 2080, 2100, 2106, 2112, 2156, 2160, 2184,
461		2187, 2200, 2205, 2240, 2250, 2268, 2275, 2304, 2310, 2340, 2352, 2376,
462		2400, 2401, 2430, 2450, 2457, 2464, 2475, 2496, 2500, 2520, 2548, 2560,
463		2592, 2600, 2625, 2640, 2646, 2673, 2688, 2695, 2700, 2730, 2744, 2750,
464		2772, 2800, 2808, 2816, 2835, 2880, 2912, 2916, 2925, 2940, 2970, 3000,
465		3024, 3072, 3080, 3087, 3120, 3125, 3136, 3150, 3159, 3168, 3185, 3200,
466		3234, 3240, 3250, 3276, 3300, 3328, 3360, 3375, 3402, 3430, 3456, 3465,
467		3500, 3510, 3520, 3528, 3564, 3584, 3600, 3640, 3645, 3675, 3696, 3744,
468		3750, 3773, 3780, 3822, 3840, 3850, 3888, 3900, 3920, 3960, 3969, 4000,
469		4032, 4050, 4095, 4096, 4116, 4125, 4158, 4160, 4200, 4212, 4224, 4312,
470		4320, 4368, 4374, 4375, 4400, 4410, 4455, 4459, 4480, 4500, 4536, 4550,
471		4608, 4620, 4680, 4704, 4725, 4752, 4800, 4802, 4851, 4860, 4875, 4900,
472		4914, 4928, 4950, 4992, 5000, 5040, 5096, 5103, 5120, 5145, 5184, 5200,
473		5250, 5265, 5280, 5292, 5346, 5376, 5390, 5400, 5460, 5488, 5500, 5544,
474		5600, 5616, 5625, 5632, 5670, 5733, 5760, 5775, 5824, 5832, 5850, 5880,
475		5940, 6000, 6048, 6075, 6125, 6144, 6160, 6174, 6237, 6240, 6250, 6272,
476		6300, 6318, 6336, 6370, 6400, 6468, 6480, 6500, 6552, 6561, 6600, 6615,
477		6656, 6720, 6750, 6804, 6825, 6860, 6875, 6912, 6930, 7000, 7020, 7040,
478		7056, 7128, 7168, 7200, 7203, 7280, 7290, 7350, 7371, 7392, 7425, 7488,
479		7500, 7546, 7560, 7644, 7680, 7700, 7776, 7800, 7840, 7875, 7920, 7938,
480		8000, 8019, 8064, 8085, 8100, 8125, 8190, 8192, 8232, 8250, 8316, 8320,
481		8400, 8424, 8448, 8505, 8575, 8624, 8640, 8736, 8748, 8750, 8775, 8800,
482		8820, 8910, 8918, 8960, 9000, 9072, 9100, 9216, 9240, 9261, 9360, 9375,
483		9408, 9450, 9477, 9504, 9555, 9600, 9604, 9625, 9702, 9720, 9750, 9800,
484		9828, 9856, 9900, 9984, 10000, 10080, 10125, 10192, 10206, 10240, 10290,
485		10368, 10395, 10400, 10500, 10530, 10560, 10584, 10692, 10752, 10780,
486		10800, 10920, 10935, 10976, 11000, 11025, 11088, 11200, 11232, 11250,
487		11264, 11319, 11340, 11375, 11466, 11520, 11550, 11648, 11664, 11700,
488		11760, 11880, 11907, 12000, 12005, 12096, 12150, 12250, 12285, 12288,
489		12320, 12348, 12375, 12474, 12480, 12500, 12544, 12600, 12636, 12672,
490		12740, 12800, 12936, 12960, 13000, 13104, 13122, 13125, 13200, 13230,
491		13312, 13365, 13377, 13440, 13475, 13500, 13608, 13650, 13720, 13750,
492		13824, 13860, 14000, 14040, 14080, 14112, 14175, 14256, 14336, 14400,
493		14406, 14553, 14560, 14580, 14625, 14700, 14742, 14784, 14850, 14976,
494		15000, 15092, 15120, 15288, 15309, 15360, 15400, 15435, 15552, 15600,
495		15625, 15680, 15750, 15795, 15840, 15876, 15925, 16000, 16038, 16128,
496		16170, 16200, 16250, 16380, 16384, 16464, 16500, 16632, 16640, 16800,
497		16807, 16848, 16875, 16896, 17010, 17150, 17199, 17248, 17280, 17325,
498		17472, 17496, 17500, 17550, 17600, 17640, 17820, 17836, 17920, 18000,
499		18144, 18200, 18225, 18375, 18432, 18480, 18522, 18711, 18720, 18750,
500		18816, 18865, 18900, 18954, 19008, 19110, 19200, 19208, 19250, 19404,
501		19440, 19500, 19600, 19656, 19683, 19712, 19800, 19845, 19968, 20000,
502		20160, 20250, 20384, 20412, 20475, 20480, 20580, 20625, 20736, 20790,
503		20800, 21000, 21060, 21120, 21168, 21384, 21504, 21560, 21600, 21609,
504		21840, 21870, 21875, 21952, 22000, 22050, 22113, 22176, 22275, 22295,
505		22400, 22464, 22500, 22528, 22638, 22680, 22750, 22932, 23040, 23100,
506		23296, 23328, 23400, 23520, 23625, 23760, 23814, 24000, 24010, 24057,
507		24192, 24255, 24300, 24375, 24500, 24570, 24576, 24640, 24696, 24750,
508		24948, 24960, 25000, 25088, 25200, 25272, 25344, 25480, 25515, 25600,
509		25725, 25872, 25920, 26000, 26208, 26244, 26250, 26325, 26400, 26411,
510		26460, 26624, 26730, 26754, 26880, 26950, 27000, 27216, 27300, 27440,
511		27500, 27648, 27720, 27783, 28000, 28080, 28125, 28160, 28224, 28350,
512		28431, 28512, 28665, 28672, 28800, 28812, 28875, 29106, 29120, 29160,
513		29250, 29400, 29484, 29568, 29700, 29952, 30000, 30184, 30240, 30375,
514		30576, 30618, 30625, 30720, 30800, 30870, 31104, 31185, 31200, 31213,
515		31250, 31360, 31500, 31590, 31680, 31752, 31850, 32000, 32076, 32256,
516		32340, 32400, 32500, 32760, 32768, 32805, 32928, 33000, 33075, 33264,
517		33280, 33600, 33614, 33696, 33750, 33792, 33957, 34020, 34125, 34300,
518		34375, 34398, 34496, 34560, 34650, 34944, 34992, 35000, 35100, 35200,
519		35280, 35640, 35672, 35721, 35840, 36000, 36015, 36288, 36400, 36450,
520		36750, 36855, 36864, 36960, 37044, 37125, 37422, 37440, 37500, 37632,
521		37730, 37800, 37908, 38016, 38220, 38400, 38416, 38500, 38808, 38880,
522		39000, 39200, 39312, 39366, 39375, 39424, 39600, 39690, 39936, 40000,
523		40095, 40131, 40320, 40425, 40500, 40625, 40768, 40824, 40950, 40960,
524		41160, 41250, 41472, 41580, 41600, 42000, 42120, 42240, 42336, 42525,
525		42768, 42875, 43008, 43120, 43200, 43218, 43659, 43680, 43740, 43750,
526		43875, 43904, 44000, 44100, 44226, 44352, 44550, 44590, 44800, 44928,
527		45000, 45056, 45276, 45360, 45500, 45864, 45927, 46080, 46200, 46305,
528		46592, 46656, 46800, 46875, 47040, 47250, 47385, 47520, 47628, 47775,
529		48000, 48020, 48114, 48125, 48384, 48510, 48600, 48750, 49000, 49140,
530		49152, 49280, 49392, 49500, 49896, 49920, 50000, 50176, 50400, 50421,
531		50544, 50625, 50688, 50960, 51030, 51200, 51450, 51597, 51744, 51840,
532		51975, 52000, 52416, 52488, 52500, 52650, 52800, 52822, 52920, 53248,
533		53460, 53508, 53760, 53900, 54000, 54432, 54600, 54675, 54880, 55000,
534		55125, 55296, 55440, 55566, 56000, 56133, 56160, 56250, 56320, 56448,
535		56595, 56700, 56862, 56875, 57024, 57330, 57344, 57600, 57624, 57750,
536		58212, 58240, 58320, 58500, 58800, 58968, 59049, 59136, 59400, 59535,
537		59904, 60000, 60025, 60368, 60480, 60750, 61152, 61236, 61250, 61425,
538		61440, 61600, 61740, 61875, 62208, 62370, 62400, 62426, 62500, 62720,
539		63000, 63180, 63360, 63504, 63700, 64000, 64152, 64512, 64680, 64800,
540		64827, 65000, 65520, 65536, 65610, 65625, 65856, 66000, 66150, 66339,
541		66528, 66560, 66825, 66885, 67200, 67228, 67375, 67392, 67500, 67584,
542		67914, 68040, 68250, 68600, 68750, 68796, 68992, 69120, 69300, 69888,
543		69984, 70000, 70200, 70400, 70560, 70875, 71280, 71344, 71442, 71680,
544		72000, 72030, 72171, 72576, 72765, 72800, 72900, 73125, 73500, 73710,
545		73728, 73920, 74088, 74250, 74844, 74880, 75000, 75264, 75460, 75600,
546		75816, 76032, 76440, 76545, 76800, 76832, 77000, 77175, 77616, 77760,
547		78000, 78125, 78400, 78624, 78732, 78750, 78848, 78975, 79200, 79233,
548		79380, 79625, 79872, 80000, 80190, 80262, 80640, 80850, 81000, 81250,
549		81536, 81648, 81900, 81920, 82320, 82500, 82944, 83160, 83200, 83349,
550		84000, 84035, 84240, 84375, 84480, 84672, 85050, 85293, 85536, 85750,
551		85995, 86016, 86240, 86400, 86436, 86625, 87318, 87360, 87480, 87500,
552		87750, 87808, 88000, 88200, 88452, 88704, 89100, 89180, 89600, 89856,
553		90000, 90112, 90552, 90720, 91000, 91125, 91728, 91854, 91875, 92160,
554		92400, 92610, 93184, 93312, 93555, 93600, 93639, 93750, 94080, 94325,
555		94500, 94770, 95040, 95256, 95550, 96000, 96040, 96228, 96250, 96768,
556		97020, 97200, 97500, 98000, 98280, 98304, 98415, 98560, 98784, 99000,
557		99225, 99792, 99840
558		};
	439	1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
	440	18, 20, 21, 22, 24, 25, 26, 27, 28, 30, 32, 33, 35, 36, 39, 40, 42, 44, 45, 48,
	441	49, 50, 52, 54, 55, 56, 60, 63, 64, 65, 66, 70, 72, 75, 77, 78, 80, 81,
	442	84, 88, 90, 91, 96, 98, 99, 100, 104, 105, 108, 110, 112, 117, 120, 125,
	443	126, 128, 130, 132, 135, 140, 144, 147, 150, 154, 156, 160, 162, 165,
	444	168, 175, 176, 180, 182, 189, 192, 195, 196, 198, 200, 208, 210, 216,
	445	220, 224, 225, 231, 234, 240, 243, 245, 250, 252, 256, 260, 264, 270,
	446	273, 275, 280, 288, 294, 297, 300, 308, 312, 315, 320, 324, 325, 330,
	447	336, 343, 350, 351, 352, 360, 364, 375, 378, 384, 385, 390, 392, 396,
	448	400, 405, 416, 420, 432, 440, 441, 448, 450, 455, 462, 468, 480, 486,
	449	490, 495, 500, 504, 512, 520, 525, 528, 539, 540, 546, 550, 560, 567,
	450	576, 585, 588, 594, 600, 616, 624, 625, 630, 637, 640, 648, 650, 660,
	451	672, 675, 686, 693, 700, 702, 704, 720, 728, 729, 735, 750, 756, 768,
	452	770, 780, 784, 792, 800, 810, 819, 825, 832, 840, 864, 875, 880, 882,
	453	891, 896, 900, 910, 924, 936, 945, 960, 972, 975, 980, 990, 1000, 1008,
	454	1024, 1029, 1040, 1050, 1053, 1056, 1078, 1080, 1092, 1100, 1120, 1125,
	455	1134, 1152, 1155, 1170, 1176, 1188, 1200, 1215, 1225, 1232, 1248, 1250,
	456	1260, 1274, 1280, 1296, 1300, 1320, 1323, 1344, 1350, 1365, 1372, 1375,
	457	1386, 1400, 1404, 1408, 1440, 1456, 1458, 1470, 1485, 1500, 1512, 1536,
	458	1540, 1560, 1568, 1575, 1584, 1600, 1617, 1620, 1625, 1638, 1650, 1664,
	459	1680, 1701, 1715, 1728, 1750, 1755, 1760, 1764, 1782, 1792, 1800, 1820,
	460	1848, 1872, 1875, 1890, 1911, 1920, 1925, 1944, 1950, 1960, 1980, 2000,
	461	2016, 2025, 2048, 2058, 2079, 2080, 2100, 2106, 2112, 2156, 2160, 2184,
	462	2187, 2200, 2205, 2240, 2250, 2268, 2275, 2304, 2310, 2340, 2352, 2376,
	463	2400, 2401, 2430, 2450, 2457, 2464, 2475, 2496, 2500, 2520, 2548, 2560,
	464	2592, 2600, 2625, 2640, 2646, 2673, 2688, 2695, 2700, 2730, 2744, 2750,
	465	2772, 2800, 2808, 2816, 2835, 2880, 2912, 2916, 2925, 2940, 2970, 3000,
	466	3024, 3072, 3080, 3087, 3120, 3125, 3136, 3150, 3159, 3168, 3185, 3200,
	467	3234, 3240, 3250, 3276, 3300, 3328, 3360, 3375, 3402, 3430, 3456, 3465,
	468	3500, 3510, 3520, 3528, 3564, 3584, 3600, 3640, 3645, 3675, 3696, 3744,
	469	3750, 3773, 3780, 3822, 3840, 3850, 3888, 3900, 3920, 3960, 3969, 4000,
	470	4032, 4050, 4095, 4096, 4116, 4125, 4158, 4160, 4200, 4212, 4224, 4312,
	471	4320, 4368, 4374, 4375, 4400, 4410, 4455, 4459, 4480, 4500, 4536, 4550,
	472	4608, 4620, 4680, 4704, 4725, 4752, 4800, 4802, 4851, 4860, 4875, 4900,
	473	4914, 4928, 4950, 4992, 5000, 5040, 5096, 5103, 5120, 5145, 5184, 5200,
	474	5250, 5265, 5280, 5292, 5346, 5376, 5390, 5400, 5460, 5488, 5500, 5544,
	475	5600, 5616, 5625, 5632, 5670, 5733, 5760, 5775, 5824, 5832, 5850, 5880,
	476	5940, 6000, 6048, 6075, 6125, 6144, 6160, 6174, 6237, 6240, 6250, 6272,
	477	6300, 6318, 6336, 6370, 6400, 6468, 6480, 6500, 6552, 6561, 6600, 6615,
	478	6656, 6720, 6750, 6804, 6825, 6860, 6875, 6912, 6930, 7000, 7020, 7040,
	479	7056, 7128, 7168, 7200, 7203, 7280, 7290, 7350, 7371, 7392, 7425, 7488,
	480	7500, 7546, 7560, 7644, 7680, 7700, 7776, 7800, 7840, 7875, 7920, 7938,
	481	8000, 8019, 8064, 8085, 8100, 8125, 8190, 8192, 8232, 8250, 8316, 8320,
	482	8400, 8424, 8448, 8505, 8575, 8624, 8640, 8736, 8748, 8750, 8775, 8800,
	483	8820, 8910, 8918, 8960, 9000, 9072, 9100, 9216, 9240, 9261, 9360, 9375,
	484	9408, 9450, 9477, 9504, 9555, 9600, 9604, 9625, 9702, 9720, 9750, 9800,
	485	9828, 9856, 9900, 9984, 10000, 10080, 10125, 10192, 10206, 10240, 10290,
	486	10368, 10395, 10400, 10500, 10530, 10560, 10584, 10692, 10752, 10780,
	487	10800, 10920, 10935, 10976, 11000, 11025, 11088, 11200, 11232, 11250,
	488	11264, 11319, 11340, 11375, 11466, 11520, 11550, 11648, 11664, 11700,
	489	11760, 11880, 11907, 12000, 12005, 12096, 12150, 12250, 12285, 12288,
	490	12320, 12348, 12375, 12474, 12480, 12500, 12544, 12600, 12636, 12672,
	491	12740, 12800, 12936, 12960, 13000, 13104, 13122, 13125, 13200, 13230,
	492	13312, 13365, 13377, 13440, 13475, 13500, 13608, 13650, 13720, 13750,
	493	13824, 13860, 14000, 14040, 14080, 14112, 14175, 14256, 14336, 14400,
	494	14406, 14553, 14560, 14580, 14625, 14700, 14742, 14784, 14850, 14976,
	495	15000, 15092, 15120, 15288, 15309, 15360, 15400, 15435, 15552, 15600,
	496	15625, 15680, 15750, 15795, 15840, 15876, 15925, 16000, 16038, 16128,
	497	16170, 16200, 16250, 16380, 16384, 16464, 16500, 16632, 16640, 16800,
	498	16807, 16848, 16875, 16896, 17010, 17150, 17199, 17248, 17280, 17325,
	499	17472, 17496, 17500, 17550, 17600, 17640, 17820, 17836, 17920, 18000,
	500	18144, 18200, 18225, 18375, 18432, 18480, 18522, 18711, 18720, 18750,
	501	18816, 18865, 18900, 18954, 19008, 19110, 19200, 19208, 19250, 19404,
	502	19440, 19500, 19600, 19656, 19683, 19712, 19800, 19845, 19968, 20000,
	503	20160, 20250, 20384, 20412, 20475, 20480, 20580, 20625, 20736, 20790,
	504	20800, 21000, 21060, 21120, 21168, 21384, 21504, 21560, 21600, 21609,
	505	21840, 21870, 21875, 21952, 22000, 22050, 22113, 22176, 22275, 22295,
	506	22400, 22464, 22500, 22528, 22638, 22680, 22750, 22932, 23040, 23100,
	507	23296, 23328, 23400, 23520, 23625, 23760, 23814, 24000, 24010, 24057,
	508	24192, 24255, 24300, 24375, 24500, 24570, 24576, 24640, 24696, 24750,
	509	24948, 24960, 25000, 25088, 25200, 25272, 25344, 25480, 25515, 25600,
	510	25725, 25872, 25920, 26000, 26208, 26244, 26250, 26325, 26400, 26411,
	511	26460, 26624, 26730, 26754, 26880, 26950, 27000, 27216, 27300, 27440,
	512	27500, 27648, 27720, 27783, 28000, 28080, 28125, 28160, 28224, 28350,
	513	28431, 28512, 28665, 28672, 28800, 28812, 28875, 29106, 29120, 29160,
	514	29250, 29400, 29484, 29568, 29700, 29952, 30000, 30184, 30240, 30375,
	515	30576, 30618, 30625, 30720, 30800, 30870, 31104, 31185, 31200, 31213,
	516	31250, 31360, 31500, 31590, 31680, 31752, 31850, 32000, 32076, 32256,
	517	32340, 32400, 32500, 32760, 32768, 32805, 32928, 33000, 33075, 33264,
	518	33280, 33600, 33614, 33696, 33750, 33792, 33957, 34020, 34125, 34300,
	519	34375, 34398, 34496, 34560, 34650, 34944, 34992, 35000, 35100, 35200,
	520	35280, 35640, 35672, 35721, 35840, 36000, 36015, 36288, 36400, 36450,
	521	36750, 36855, 36864, 36960, 37044, 37125, 37422, 37440, 37500, 37632,
	522	37730, 37800, 37908, 38016, 38220, 38400, 38416, 38500, 38808, 38880,
	523	39000, 39200, 39312, 39366, 39375, 39424, 39600, 39690, 39936, 40000,
	524	40095, 40131, 40320, 40425, 40500, 40625, 40768, 40824, 40950, 40960,
	525	41160, 41250, 41472, 41580, 41600, 42000, 42120, 42240, 42336, 42525,
	526	42768, 42875, 43008, 43120, 43200, 43218, 43659, 43680, 43740, 43750,
	527	43875, 43904, 44000, 44100, 44226, 44352, 44550, 44590, 44800, 44928,
	528	45000, 45056, 45276, 45360, 45500, 45864, 45927, 46080, 46200, 46305,
	529	46592, 46656, 46800, 46875, 47040, 47250, 47385, 47520, 47628, 47775,
	530	48000, 48020, 48114, 48125, 48384, 48510, 48600, 48750, 49000, 49140,
	531	49152, 49280, 49392, 49500, 49896, 49920, 50000, 50176, 50400, 50421,
	532	50544, 50625, 50688, 50960, 51030, 51200, 51450, 51597, 51744, 51840,
	533	51975, 52000, 52416, 52488, 52500, 52650, 52800, 52822, 52920, 53248,
	534	53460, 53508, 53760, 53900, 54000, 54432, 54600, 54675, 54880, 55000,
	535	55125, 55296, 55440, 55566, 56000, 56133, 56160, 56250, 56320, 56448,
	536	56595, 56700, 56862, 56875, 57024, 57330, 57344, 57600, 57624, 57750,
	537	58212, 58240, 58320, 58500, 58800, 58968, 59049, 59136, 59400, 59535,
	538	59904, 60000, 60025, 60368, 60480, 60750, 61152, 61236, 61250, 61425,
	539	61440, 61600, 61740, 61875, 62208, 62370, 62400, 62426, 62500, 62720,
	540	63000, 63180, 63360, 63504, 63700, 64000, 64152, 64512, 64680, 64800,
	541	64827, 65000, 65520, 65536, 65610, 65625, 65856, 66000, 66150, 66339,
	542	66528, 66560, 66825, 66885, 67200, 67228, 67375, 67392, 67500, 67584,
	543	67914, 68040, 68250, 68600, 68750, 68796, 68992, 69120, 69300, 69888,
	544	69984, 70000, 70200, 70400, 70560, 70875, 71280, 71344, 71442, 71680,
	545	72000, 72030, 72171, 72576, 72765, 72800, 72900, 73125, 73500, 73710,
	546	73728, 73920, 74088, 74250, 74844, 74880, 75000, 75264, 75460, 75600,
	547	75816, 76032, 76440, 76545, 76800, 76832, 77000, 77175, 77616, 77760,
	548	78000, 78125, 78400, 78624, 78732, 78750, 78848, 78975, 79200, 79233,
	549	79380, 79625, 79872, 80000, 80190, 80262, 80640, 80850, 81000, 81250,
	550	81536, 81648, 81900, 81920, 82320, 82500, 82944, 83160, 83200, 83349,
	551	84000, 84035, 84240, 84375, 84480, 84672, 85050, 85293, 85536, 85750,
	552	85995, 86016, 86240, 86400, 86436, 86625, 87318, 87360, 87480, 87500,
	553	87750, 87808, 88000, 88200, 88452, 88704, 89100, 89180, 89600, 89856,
	554	90000, 90112, 90552, 90720, 91000, 91125, 91728, 91854, 91875, 92160,
	555	92400, 92610, 93184, 93312, 93555, 93600, 93639, 93750, 94080, 94325,
	556	94500, 94770, 95040, 95256, 95550, 96000, 96040, 96228, 96250, 96768,
	557	97020, 97200, 97500, 98000, 98280, 98304, 98415, 98560, 98784, 99000,
	558	99225, 99792, 99840
	559	};
559	560
560	561	template <int DUMMY>
561		int FFTWPaddingSize<DUMMY>::goodEvenSizes[evenSize] = {
562		2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22,
563		24, 26, 28, 30, 32, 36, 40, 42, 44, 48, 50, 52, 54, 56, 60, 64, 66, 70,
564		72, 78, 80, 84, 88, 90, 96, 98, 100, 104, 108, 110, 112, 120, 126, 128,
565		130, 132, 140, 144, 150, 154, 156, 160, 162, 168, 176, 180, 182, 192,
566		196, 198, 200, 208, 210, 216, 220, 224, 234, 240, 250, 252, 256, 260,
567		264, 270, 280, 288, 294, 300, 308, 312, 320, 324, 330, 336, 350, 352,
568		360, 364, 378, 384, 390, 392, 396, 400, 416, 420, 432, 440, 448, 450,
569		462, 468, 480, 486, 490, 500, 504, 512, 520, 528, 540, 546, 550, 560,
570		576, 588, 594, 600, 616, 624, 630, 640, 648, 650, 660, 672, 686, 700,
571		702, 704, 720, 728, 750, 756, 768, 770, 780, 784, 792, 800, 810, 832,
572		840, 864, 880, 882, 896, 900, 910, 924, 936, 960, 972, 980, 990, 1000,
573		1008, 1024, 1040, 1050, 1056, 1078, 1080, 1092, 1100, 1120, 1134, 1152,
574		1170, 1176, 1188, 1200, 1232, 1248, 1250, 1260, 1274, 1280, 1296, 1300,
575		1320, 1344, 1350, 1372, 1386, 1400, 1404, 1408, 1440, 1456, 1458, 1470,
576		1500, 1512, 1536, 1540, 1560, 1568, 1584, 1600, 1620, 1638, 1650, 1664,
577		1680, 1728, 1750, 1760, 1764, 1782, 1792, 1800, 1820, 1848, 1872, 1890,
578		1920, 1944, 1950, 1960, 1980, 2000, 2016, 2048, 2058, 2080, 2100, 2106,
579		2112, 2156, 2160, 2184, 2200, 2240, 2250, 2268, 2304, 2310, 2340, 2352,
580		2376, 2400, 2430, 2450, 2464, 2496, 2500, 2520, 2548, 2560, 2592, 2600,
581		2640, 2646, 2688, 2700, 2730, 2744, 2750, 2772, 2800, 2808, 2816, 2880,
582		2912, 2916, 2940, 2970, 3000, 3024, 3072, 3080, 3120, 3136, 3150, 3168,
583		3200, 3234, 3240, 3250, 3276, 3300, 3328, 3360, 3402, 3430, 3456, 3500,
584		3510, 3520, 3528, 3564, 3584, 3600, 3640, 3696, 3744, 3750, 3780, 3822,
585		3840, 3850, 3888, 3900, 3920, 3960, 4000, 4032, 4050, 4096, 4116, 4158,
586		4160, 4200, 4212, 4224, 4312, 4320, 4368, 4374, 4400, 4410, 4480, 4500,
587		4536, 4550, 4608, 4620, 4680, 4704, 4752, 4800, 4802, 4860, 4900, 4914,
588		4928, 4950, 4992, 5000, 5040, 5096, 5120, 5184, 5200, 5250, 5280, 5292,
589		5346, 5376, 5390, 5400, 5460, 5488, 5500, 5544, 5600, 5616, 5632, 5670,
590		5760, 5824, 5832, 5850, 5880, 5940, 6000, 6048, 6144, 6160, 6174, 6240,
591		6250, 6272, 6300, 6318, 6336, 6370, 6400, 6468, 6480, 6500, 6552, 6600,
592		6656, 6720, 6750, 6804, 6860, 6912, 6930, 7000, 7020, 7040, 7056, 7128,
593		7168, 7200, 7280, 7290, 7350, 7392, 7488, 7500, 7546, 7560, 7644, 7680,
594		7700, 7776, 7800, 7840, 7920, 7938, 8000, 8064, 8100, 8190, 8192, 8232,
595		8250, 8316, 8320, 8400, 8424, 8448, 8624, 8640, 8736, 8748, 8750, 8800,
596		8820, 8910, 8918, 8960, 9000, 9072, 9100, 9216, 9240, 9360, 9408, 9450,
597		9504, 9600, 9604, 9702, 9720, 9750, 9800, 9828, 9856, 9900, 9984, 10000,
598		10080, 10192, 10206, 10240, 10290, 10368, 10400, 10500, 10530, 10560,
599		10584, 10692, 10752, 10780, 10800, 10920, 10976, 11000, 11088, 11200,
600		11232, 11250, 11264, 11340, 11466, 11520, 11550, 11648, 11664, 11700,
601		11760, 11880, 12000, 12096, 12150, 12250, 12288, 12320, 12348, 12474,
602		12480, 12500, 12544, 12600, 12636, 12672, 12740, 12800, 12936, 12960,
603		13000, 13104, 13122, 13200, 13230, 13312, 13440, 13500, 13608, 13650,
604		13720, 13750, 13824, 13860, 14000, 14040, 14080, 14112, 14256, 14336,
605		14400, 14406, 14560, 14580, 14700, 14742, 14784, 14850, 14976, 15000,
606		15092, 15120, 15288, 15360, 15400, 15552, 15600, 15680, 15750, 15840,
607		15876, 16000, 16038, 16128, 16170, 16200, 16250, 16380, 16384, 16464,
608		16500, 16632, 16640, 16800, 16848, 16896, 17010, 17150, 17248, 17280,
609		17472, 17496, 17500, 17550, 17600, 17640, 17820, 17836, 17920, 18000,
610		18144, 18200, 18432, 18480, 18522, 18720, 18750, 18816, 18900, 18954,
611		19008, 19110, 19200, 19208, 19250, 19404, 19440, 19500, 19600, 19656,
612		19712, 19800, 19968, 20000, 20160, 20250, 20384, 20412, 20480, 20580,
613		20736, 20790, 20800, 21000, 21060, 21120, 21168, 21384, 21504, 21560,
614		21600, 21840, 21870, 21952, 22000, 22050, 22176, 22400, 22464, 22500,
615		22528, 22638, 22680, 22750, 22932, 23040, 23100, 23296, 23328, 23400,
616		23520, 23760, 23814, 24000, 24010, 24192, 24300, 24500, 24570, 24576,
617		24640, 24696, 24750, 24948, 24960, 25000, 25088, 25200, 25272, 25344,
618		25480, 25600, 25872, 25920, 26000, 26208, 26244, 26250, 26400, 26460,
619		26624, 26730, 26754, 26880, 26950, 27000, 27216, 27300, 27440, 27500,
620		27648, 27720, 28000, 28080, 28160, 28224, 28350, 28512, 28672, 28800,
621		28812, 29106, 29120, 29160, 29250, 29400, 29484, 29568, 29700, 29952,
622		30000, 30184, 30240, 30576, 30618, 30720, 30800, 30870, 31104, 31200,
623		31250, 31360, 31500, 31590, 31680, 31752, 31850, 32000, 32076, 32256,
624		32340, 32400, 32500, 32760, 32768, 32928, 33000, 33264, 33280, 33600,
625		33614, 33696, 33750, 33792, 34020, 34300, 34398, 34496, 34560, 34650,
626		34944, 34992, 35000, 35100, 35200, 35280, 35640, 35672, 35840, 36000,
627		36288, 36400, 36450, 36750, 36864, 36960, 37044, 37422, 37440, 37500,
628		37632, 37730, 37800, 37908, 38016, 38220, 38400, 38416, 38500, 38808,
629		38880, 39000, 39200, 39312, 39366, 39424, 39600, 39690, 39936, 40000,
630		40320, 40500, 40768, 40824, 40950, 40960, 41160, 41250, 41472, 41580,
631		41600, 42000, 42120, 42240, 42336, 42768, 43008, 43120, 43200, 43218,
632		43680, 43740, 43750, 43904, 44000, 44100, 44226, 44352, 44550, 44590,
633		44800, 44928, 45000, 45056, 45276, 45360, 45500, 45864, 46080, 46200,
634		46592, 46656, 46800, 47040, 47250, 47520, 47628, 48000, 48020, 48114,
635		48384, 48510, 48600, 48750, 49000, 49140, 49152, 49280, 49392, 49500,
636		49896, 49920, 50000, 50176, 50400, 50544, 50688, 50960, 51030, 51200,
637		51450, 51744, 51840, 52000, 52416, 52488, 52500, 52650, 52800, 52822,
638		52920, 53248, 53460, 53508, 53760, 53900, 54000, 54432, 54600, 54880,
639		55000, 55296, 55440, 55566, 56000, 56160, 56250, 56320, 56448, 56700,
640		56862, 57024, 57330, 57344, 57600, 57624, 57750, 58212, 58240, 58320,
641		58500, 58800, 58968, 59136, 59400, 59904, 60000, 60368, 60480, 60750,
642		61152, 61236, 61250, 61440, 61600, 61740, 62208, 62370, 62400, 62426,
643		62500, 62720, 63000, 63180, 63360, 63504, 63700, 64000, 64152, 64512,
644		64680, 64800, 65000, 65520, 65536, 65610, 65856, 66000, 66150, 66528,
645		66560, 67200, 67228, 67392, 67500, 67584, 67914, 68040, 68250, 68600,
646		68750, 68796, 68992, 69120, 69300, 69888, 69984, 70000, 70200, 70400,
647		70560, 71280, 71344, 71442, 71680, 72000, 72030, 72576, 72800, 72900,
648		73500, 73710, 73728, 73920, 74088, 74250, 74844, 74880, 75000, 75264,
649		75460, 75600, 75816, 76032, 76440, 76800, 76832, 77000, 77616, 77760,
650		78000, 78400, 78624, 78732, 78750, 78848, 79200, 79380, 79872, 80000,
651		80190, 80262, 80640, 80850, 81000, 81250, 81536, 81648, 81900, 81920,
652		82320, 82500, 82944, 83160, 83200, 84000, 84240, 84480, 84672, 85050,
653		85536, 85750, 86016, 86240, 86400, 86436, 87318, 87360, 87480, 87500,
654		87750, 87808, 88000, 88200, 88452, 88704, 89100, 89180, 89600, 89856,
655		90000, 90112, 90552, 90720, 91000, 91728, 91854, 92160, 92400, 92610,
656		93184, 93312, 93600, 93750, 94080, 94500, 94770, 95040, 95256, 95550,
657		96000, 96040, 96228, 96250, 96768, 97020, 97200, 97500, 98000, 98280,
658		98304, 98560, 98784, 99000, 99792, 99840
659		};
	562	int FFTWPaddingSize<DUMMY>::goodEvenSizes[evenSize] = {
	563	2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22,
	564	24, 26, 28, 30, 32, 36, 40, 42, 44, 48, 50, 52, 54, 56, 60, 64, 66, 70,
	565	72, 78, 80, 84, 88, 90, 96, 98, 100, 104, 108, 110, 112, 120, 126, 128,
	566	130, 132, 140, 144, 150, 154, 156, 160, 162, 168, 176, 180, 182, 192,
	567	196, 198, 200, 208, 210, 216, 220, 224, 234, 240, 250, 252, 256, 260,
	568	264, 270, 280, 288, 294, 300, 308, 312, 320, 324, 330, 336, 350, 352,
	569	360, 364, 378, 384, 390, 392, 396, 400, 416, 420, 432, 440, 448, 450,
	570	462, 468, 480, 486, 490, 500, 504, 512, 520, 528, 540, 546, 550, 560,
	571	576, 588, 594, 600, 616, 624, 630, 640, 648, 650, 660, 672, 686, 700,
	572	702, 704, 720, 728, 750, 756, 768, 770, 780, 784, 792, 800, 810, 832,
	573	840, 864, 880, 882, 896, 900, 910, 924, 936, 960, 972, 980, 990, 1000,
	574	1008, 1024, 1040, 1050, 1056, 1078, 1080, 1092, 1100, 1120, 1134, 1152,
	575	1170, 1176, 1188, 1200, 1232, 1248, 1250, 1260, 1274, 1280, 1296, 1300,
	576	1320, 1344, 1350, 1372, 1386, 1400, 1404, 1408, 1440, 1456, 1458, 1470,
	577	1500, 1512, 1536, 1540, 1560, 1568, 1584, 1600, 1620, 1638, 1650, 1664,
	578	1680, 1728, 1750, 1760, 1764, 1782, 1792, 1800, 1820, 1848, 1872, 1890,
	579	1920, 1944, 1950, 1960, 1980, 2000, 2016, 2048, 2058, 2080, 2100, 2106,
	580	2112, 2156, 2160, 2184, 2200, 2240, 2250, 2268, 2304, 2310, 2340, 2352,
	581	2376, 2400, 2430, 2450, 2464, 2496, 2500, 2520, 2548, 2560, 2592, 2600,
	582	2640, 2646, 2688, 2700, 2730, 2744, 2750, 2772, 2800, 2808, 2816, 2880,
	583	2912, 2916, 2940, 2970, 3000, 3024, 3072, 3080, 3120, 3136, 3150, 3168,
	584	3200, 3234, 3240, 3250, 3276, 3300, 3328, 3360, 3402, 3430, 3456, 3500,
	585	3510, 3520, 3528, 3564, 3584, 3600, 3640, 3696, 3744, 3750, 3780, 3822,
	586	3840, 3850, 3888, 3900, 3920, 3960, 4000, 4032, 4050, 4096, 4116, 4158,
	587	4160, 4200, 4212, 4224, 4312, 4320, 4368, 4374, 4400, 4410, 4480, 4500,
	588	4536, 4550, 4608, 4620, 4680, 4704, 4752, 4800, 4802, 4860, 4900, 4914,
	589	4928, 4950, 4992, 5000, 5040, 5096, 5120, 5184, 5200, 5250, 5280, 5292,
	590	5346, 5376, 5390, 5400, 5460, 5488, 5500, 5544, 5600, 5616, 5632, 5670,
	591	5760, 5824, 5832, 5850, 5880, 5940, 6000, 6048, 6144, 6160, 6174, 6240,
	592	6250, 6272, 6300, 6318, 6336, 6370, 6400, 6468, 6480, 6500, 6552, 6600,
	593	6656, 6720, 6750, 6804, 6860, 6912, 6930, 7000, 7020, 7040, 7056, 7128,
	594	7168, 7200, 7280, 7290, 7350, 7392, 7488, 7500, 7546, 7560, 7644, 7680,
	595	7700, 7776, 7800, 7840, 7920, 7938, 8000, 8064, 8100, 8190, 8192, 8232,
	596	8250, 8316, 8320, 8400, 8424, 8448, 8624, 8640, 8736, 8748, 8750, 8800,
	597	8820, 8910, 8918, 8960, 9000, 9072, 9100, 9216, 9240, 9360, 9408, 9450,
	598	9504, 9600, 9604, 9702, 9720, 9750, 9800, 9828, 9856, 9900, 9984, 10000,
	599	10080, 10192, 10206, 10240, 10290, 10368, 10400, 10500, 10530, 10560,
	600	10584, 10692, 10752, 10780, 10800, 10920, 10976, 11000, 11088, 11200,
	601	11232, 11250, 11264, 11340, 11466, 11520, 11550, 11648, 11664, 11700,
	602	11760, 11880, 12000, 12096, 12150, 12250, 12288, 12320, 12348, 12474,
	603	12480, 12500, 12544, 12600, 12636, 12672, 12740, 12800, 12936, 12960,
	604	13000, 13104, 13122, 13200, 13230, 13312, 13440, 13500, 13608, 13650,
	605	13720, 13750, 13824, 13860, 14000, 14040, 14080, 14112, 14256, 14336,
	606	14400, 14406, 14560, 14580, 14700, 14742, 14784, 14850, 14976, 15000,
	607	15092, 15120, 15288, 15360, 15400, 15552, 15600, 15680, 15750, 15840,
	608	15876, 16000, 16038, 16128, 16170, 16200, 16250, 16380, 16384, 16464,
	609	16500, 16632, 16640, 16800, 16848, 16896, 17010, 17150, 17248, 17280,
	610	17472, 17496, 17500, 17550, 17600, 17640, 17820, 17836, 17920, 18000,
	611	18144, 18200, 18432, 18480, 18522, 18720, 18750, 18816, 18900, 18954,
	612	19008, 19110, 19200, 19208, 19250, 19404, 19440, 19500, 19600, 19656,
	613	19712, 19800, 19968, 20000, 20160, 20250, 20384, 20412, 20480, 20580,
	614	20736, 20790, 20800, 21000, 21060, 21120, 21168, 21384, 21504, 21560,
	615	21600, 21840, 21870, 21952, 22000, 22050, 22176, 22400, 22464, 22500,
	616	22528, 22638, 22680, 22750, 22932, 23040, 23100, 23296, 23328, 23400,
	617	23520, 23760, 23814, 24000, 24010, 24192, 24300, 24500, 24570, 24576,
	618	24640, 24696, 24750, 24948, 24960, 25000, 25088, 25200, 25272, 25344,
	619	25480, 25600, 25872, 25920, 26000, 26208, 26244, 26250, 26400, 26460,
	620	26624, 26730, 26754, 26880, 26950, 27000, 27216, 27300, 27440, 27500,
	621	27648, 27720, 28000, 28080, 28160, 28224, 28350, 28512, 28672, 28800,
	622	28812, 29106, 29120, 29160, 29250, 29400, 29484, 29568, 29700, 29952,
	623	30000, 30184, 30240, 30576, 30618, 30720, 30800, 30870, 31104, 31200,
	624	31250, 31360, 31500, 31590, 31680, 31752, 31850, 32000, 32076, 32256,
	625	32340, 32400, 32500, 32760, 32768, 32928, 33000, 33264, 33280, 33600,
	626	33614, 33696, 33750, 33792, 34020, 34300, 34398, 34496, 34560, 34650,
	627	34944, 34992, 35000, 35100, 35200, 35280, 35640, 35672, 35840, 36000,
	628	36288, 36400, 36450, 36750, 36864, 36960, 37044, 37422, 37440, 37500,
	629	37632, 37730, 37800, 37908, 38016, 38220, 38400, 38416, 38500, 38808,
	630	38880, 39000, 39200, 39312, 39366, 39424, 39600, 39690, 39936, 40000,
	631	40320, 40500, 40768, 40824, 40950, 40960, 41160, 41250, 41472, 41580,
	632	41600, 42000, 42120, 42240, 42336, 42768, 43008, 43120, 43200, 43218,
	633	43680, 43740, 43750, 43904, 44000, 44100, 44226, 44352, 44550, 44590,
	634	44800, 44928, 45000, 45056, 45276, 45360, 45500, 45864, 46080, 46200,
	635	46592, 46656, 46800, 47040, 47250, 47520, 47628, 48000, 48020, 48114,
	636	48384, 48510, 48600, 48750, 49000, 49140, 49152, 49280, 49392, 49500,
	637	49896, 49920, 50000, 50176, 50400, 50544, 50688, 50960, 51030, 51200,
	638	51450, 51744, 51840, 52000, 52416, 52488, 52500, 52650, 52800, 52822,
	639	52920, 53248, 53460, 53508, 53760, 53900, 54000, 54432, 54600, 54880,
	640	55000, 55296, 55440, 55566, 56000, 56160, 56250, 56320, 56448, 56700,
	641	56862, 57024, 57330, 57344, 57600, 57624, 57750, 58212, 58240, 58320,
	642	58500, 58800, 58968, 59136, 59400, 59904, 60000, 60368, 60480, 60750,
	643	61152, 61236, 61250, 61440, 61600, 61740, 62208, 62370, 62400, 62426,
	644	62500, 62720, 63000, 63180, 63360, 63504, 63700, 64000, 64152, 64512,
	645	64680, 64800, 65000, 65520, 65536, 65610, 65856, 66000, 66150, 66528,
	646	66560, 67200, 67228, 67392, 67500, 67584, 67914, 68040, 68250, 68600,
	647	68750, 68796, 68992, 69120, 69300, 69888, 69984, 70000, 70200, 70400,
	648	70560, 71280, 71344, 71442, 71680, 72000, 72030, 72576, 72800, 72900,
	649	73500, 73710, 73728, 73920, 74088, 74250, 74844, 74880, 75000, 75264,
	650	75460, 75600, 75816, 76032, 76440, 76800, 76832, 77000, 77616, 77760,
	651	78000, 78400, 78624, 78732, 78750, 78848, 79200, 79380, 79872, 80000,
	652	80190, 80262, 80640, 80850, 81000, 81250, 81536, 81648, 81900, 81920,
	653	82320, 82500, 82944, 83160, 83200, 84000, 84240, 84480, 84672, 85050,
	654	85536, 85750, 86016, 86240, 86400, 86436, 87318, 87360, 87480, 87500,
	655	87750, 87808, 88000, 88200, 88452, 88704, 89100, 89180, 89600, 89856,
	656	90000, 90112, 90552, 90720, 91000, 91728, 91854, 92160, 92400, 92610,
	657	93184, 93312, 93600, 93750, 94080, 94500, 94770, 95040, 95256, 95550,
	658	96000, 96040, 96228, 96250, 96768, 97020, 97200, 97500, 98000, 98280,
	659	98304, 98560, 98784, 99000, 99792, 99840
	660	};
660	661
661	662	template <int M>
662	663	struct FFTEmbedKernel
663	664	{
664	665	template <unsigned int N, class Real, class C, class Shape>
665		static void
666		exec(MultiArrayView<N, Real, C> & out, Shape const & kernelShape,
	666	static void
	667	exec(MultiArrayView<N, Real, C> & out, Shape const & kernelShape,
667	668	Shape & srcPoint, Shape & destPoint, bool copyIt)
668	669	{
669	670	for(srcPoint[M]=0; srcPoint[M]<kernelShape[M]; ++srcPoint[M])

686	687	struct FFTEmbedKernel<0>
687	688	{
688	689	template <unsigned int N, class Real, class C, class Shape>
689		static void
690		exec(MultiArrayView<N, Real, C> & out, Shape const & kernelShape,
	690	static void
	691	exec(MultiArrayView<N, Real, C> & out, Shape const & kernelShape,
691	692	Shape & srcPoint, Shape & destPoint, bool copyIt)
692	693	{
693	694	for(srcPoint[0]=0; srcPoint[0]<kernelShape[0]; ++srcPoint[0])

711	712	};
712	713
713	714	template <unsigned int N, class Real, class C1, class C2>
714		void
	715	void
715	716	fftEmbedKernel(MultiArrayView<N, Real, C1> kernel,
716	717	MultiArrayView<N, Real, C2> out,
717	718	Real norm = 1.0)

719	720	typedef typename MultiArrayShape<N>::type Shape;
720	721
721	722	MultiArrayView<N, Real, C2> kout = out.subarray(Shape(), kernel.shape());
722
	723
723	724	out.init(0.0);
724	725	kout = kernel;
725	726	if (norm != 1.0)
726	727	kout *= norm;
727	728	moveDCToUpperLeft(kout);
728
729		Shape srcPoint, destPoint;
	729
	730	Shape srcPoint, destPoint;
730	731	FFTEmbedKernel<(int)N-1>::exec(out, kernel.shape(), srcPoint, destPoint, false);
731	732	}
732	733
733	734	template <unsigned int N, class Real, class C1, class C2>
734		void
	735	void
735	736	fftEmbedArray(MultiArrayView<N, Real, C1> in,
736	737	MultiArrayView<N, Real, C2> out)
737	738	{
738	739	typedef typename MultiArrayShape<N>::type Shape;
739
740		Shape diff = out.shape() - in.shape(),
	740
	741	Shape diff = out.shape() - in.shape(),
741	742	leftDiff = div(diff, MultiArrayIndex(2)),
742	743	rightDiff = diff - leftDiff,
743		right = in.shape() + leftDiff;
744
	744	right = in.shape() + leftDiff;
	745
745	746	out.subarray(leftDiff, right) = in;
746
	747
747	748	typedef typename MultiArrayView<N, Real, C2>::traverser Traverser;
748	749	typedef MultiArrayNavigator<Traverser, N> Navigator;
749	750	typedef typename Navigator::iterator Iterator;
750
	751
751	752	for(unsigned int d = 0; d < N; ++d)
752	753	{
753	754	Navigator nav(out.traverser_begin(), out.shape(), d);

786	787
787	788	/** \brief Find frequency domain shape for a R2C Fourier transform.
788	789
789		When a real valued array is transformed to the frequency domain, about half of the
790		Fourier coefficients are redundant. The transform can be optimized as a <a href="http://www.fftw.org/doc/Multi_002dDimensional-DFTs-of-Real-Data.html">R2C
	790	When a real valued array is transformed to the frequency domain, about half of the
	791	Fourier coefficients are redundant. The transform can be optimized as a <a href="http://www.fftw.org/doc/Multi_002dDimensional-DFTs-of-Real-Data.html">R2C
791	792	transform</a> that doesn't compute and store the redundant coefficients. This function
792	793	computes the appropriate frequency domain shape for a given shape in the spatial domain.
793	794	It simply replaces <tt>shape[0]</tt> with <tt>shape[0] / 2 + 1</tt>.
794
	795
795	796	<b>\#include</b> \<vigra/multi_fft.hxx\><br/>
796	797	Namespace: vigra
797	798	*/

825	826	<tt>fftw_destroy_plan</tt> (and their <tt>float</tt> and <tt>long double</tt> counterparts)
826	827	in an easy-to-use interface.
827	828
828		Usually, you use this class only indirectly via \ref fourierTransform()
	829	Usually, you use this class only indirectly via \ref fourierTransform()
829	830	and \ref fourierTransformInverse(). You only need this class if you want to have more control
830	831	about FFTW's planning process (by providing non-default planning flags) and/or want to re-use
831	832	plans for several transformations.
832
	833
833	834	<b> Usage:</b>
834	835
835	836	<b>\#include</b> \<vigra/multi_fft.hxx\><br>

839	840	// compute complex Fourier transform of a real image
840	841	MultiArray<2, double> src(Shape2(w, h));
841	842	MultiArray<2, FFTWComplex<double> > fourier(Shape2(w, h));
842
	843
843	844	// create an optimized plan by measuring the speed of several algorithm variants
844	845	FFTWPlan<2, double> plan(src, fourier, FFTW_MEASURE);
845
846		plan.execute(src, fourier);
	846
	847	plan.execute(src, fourier);
847	848	\endcode
848	849	*/
849	850	template <unsigned int N, class Real = double>

852	853	typedef ArrayVector<int> Shape;
853	854	typedef typename FFTWReal2Complex<Real>::plan_type PlanType;
854	855	typedef typename FFTWComplex<Real>::complex_type Complex;
855
	856
856	857	PlanType plan;
857	858	Shape shape, instrides, outstrides;
858	859	int sign;
859
	860
860	861	public:
861	862	/** \brief Create an empty plan.
862
	863
863	864	The plan can be initialized later by one of the init() functions.
864	865	*/
865	866	FFTWPlan()
866	867	: plan(0)
867	868	{}
868
	869
869	870	/** \brief Create a plan for a complex-to-complex transform.
870
	871
871	872	\arg SIGN must be <tt>FFTW_FORWARD</tt> or <tt>FFTW_BACKWARD</tt> according to the
872	873	desired transformation direction.
873		\arg planner_flags must be a combination of the <a href="http://www.fftw.org/doc/Planner-Flags.html">planner
	874	\arg planner_flags must be a combination of the <a href="http://www.fftw.org/doc/Planner-Flags.html">planner
874	875	flags</a> defined by the FFTW library. The default <tt>FFTW_ESTIMATE</tt> will guess
875	876	optimal algorithm settings or read them from pre-loaded <a href="http://www.fftw.org/doc/Wisdom.html">"wisdom"</a>.
876	877	*/
877	878	template <class C1, class C2>
878		FFTWPlan(MultiArrayView<N, FFTWComplex<Real>, C1> in,
	879	FFTWPlan(MultiArrayView<N, FFTWComplex<Real>, C1> in,
879	880	MultiArrayView<N, FFTWComplex<Real>, C2> out,
880	881	int SIGN, unsigned int planner_flags = FFTW_ESTIMATE)
881	882	: plan(0)
882	883	{
883	884	init(in, out, SIGN, planner_flags);
884	885	}
885
	886
886	887	/** \brief Create a plan for a real-to-complex transform.
887
	888
888	889	This always refers to a forward transform. The shape of the output determines
889		if a standard transform (when <tt>out.shape() == in.shape()</tt>) or an
890		<a href="http://www.fftw.org/doc/Multi_002dDimensional-DFTs-of-Real-Data.html">R2C
891		transform</a> (when <tt>out.shape() == fftwCorrespondingShapeR2C(in.shape())</tt>) will be executed.
892
893		\arg planner_flags must be a combination of the <a href="http://www.fftw.org/doc/Planner-Flags.html">planner
	890	if a standard transform (when <tt>out.shape() == in.shape()</tt>) or an
	891	<a href="http://www.fftw.org/doc/Multi_002dDimensional-DFTs-of-Real-Data.html">R2C
	892	transform</a> (when <tt>out.shape() == fftwCorrespondingShapeR2C(in.shape())</tt>) will be executed.
	893
	894	\arg planner_flags must be a combination of the <a href="http://www.fftw.org/doc/Planner-Flags.html">planner
894	895	flags</a> defined by the FFTW library. The default <tt>FFTW_ESTIMATE</tt> will guess
895	896	optimal algorithm settings or read them from pre-loaded <a href="http://www.fftw.org/doc/Wisdom.html">"wisdom"</a>.
896	897	*/
897	898	template <class C1, class C2>
898		FFTWPlan(MultiArrayView<N, Real, C1> in,
	899	FFTWPlan(MultiArrayView<N, Real, C1> in,
899	900	MultiArrayView<N, FFTWComplex<Real>, C2> out,
900	901	unsigned int planner_flags = FFTW_ESTIMATE)
901	902	: plan(0)

904	905	}
905	906
906	907	/** \brief Create a plan for a complex-to-real transform.
907
	908
908	909	This always refers to a inverse transform. The shape of the input determines
909		if a standard transform (when <tt>in.shape() == out.shape()</tt>) or a
910		<a href="http://www.fftw.org/doc/Multi_002dDimensional-DFTs-of-Real-Data.html">C2R
911		transform</a> (when <tt>in.shape() == fftwCorrespondingShapeR2C(out.shape())</tt>) will be executed.
912
913		\arg planner_flags must be a combination of the <a href="http://www.fftw.org/doc/Planner-Flags.html">planner
	910	if a standard transform (when <tt>in.shape() == out.shape()</tt>) or a
	911	<a href="http://www.fftw.org/doc/Multi_002dDimensional-DFTs-of-Real-Data.html">C2R
	912	transform</a> (when <tt>in.shape() == fftwCorrespondingShapeR2C(out.shape())</tt>) will be executed.
	913
	914	\arg planner_flags must be a combination of the <a href="http://www.fftw.org/doc/Planner-Flags.html">planner
914	915	flags</a> defined by the FFTW library. The default <tt>FFTW_ESTIMATE</tt> will guess
915	916	optimal algorithm settings or read them from pre-loaded <a href="http://www.fftw.org/doc/Wisdom.html">"wisdom"</a>.
916	917	*/
917	918	template <class C1, class C2>
918		FFTWPlan(MultiArrayView<N, FFTWComplex<Real>, C1> in,
	919	FFTWPlan(MultiArrayView<N, FFTWComplex<Real>, C1> in,
919	920	MultiArrayView<N, Real, C2> out,
920	921	unsigned int planner_flags = FFTW_ESTIMATE)
921	922	: plan(0)
922	923	{
923	924	init(in, out, planner_flags);
924	925	}
925
	926
926	927	/** \brief Copy constructor.
927	928	*/
928	929	FFTWPlan(FFTWPlan const & other)

935	936	outstrides.swap(o.outstrides);
936	937	o.plan = 0; // act like std::auto_ptr
937	938	}
938
	939
939	940	/** \brief Copy assigment.
940	941	*/
941	942	FFTWPlan & operator=(FFTWPlan const & other)

962	963	}
963	964
964	965	/** \brief Init a complex-to-complex transform.
965
	966
966	967	See the constructor with the same signature for details.
967	968	*/
968	969	template <class C1, class C2>
969		void init(MultiArrayView<N, FFTWComplex<Real>, C1> in,
	970	void init(MultiArrayView<N, FFTWComplex<Real>, C1> in,
970	971	MultiArrayView<N, FFTWComplex<Real>, C2> out,
971	972	int SIGN, unsigned int planner_flags = FFTW_ESTIMATE)
972	973	{
973	974	vigra_precondition(in.strideOrdering() == out.strideOrdering(),
974	975	"FFTWPlan.init(): input and output must have the same stride ordering.");
975
976		initImpl(in.permuteStridesDescending(), out.permuteStridesDescending(),
	976
	977	initImpl(in.permuteStridesDescending(), out.permuteStridesDescending(),
977	978	SIGN, planner_flags);
978	979	}
979
	980
980	981	/** \brief Init a real-to-complex transform.
981
	982
982	983	See the constructor with the same signature for details.
983	984	*/
984	985	template <class C1, class C2>
985		void init(MultiArrayView<N, Real, C1> in,
	986	void init(MultiArrayView<N, Real, C1> in,
986	987	MultiArrayView<N, FFTWComplex<Real>, C2> out,
987	988	unsigned int planner_flags = FFTW_ESTIMATE)
988	989	{
989	990	vigra_precondition(in.strideOrdering() == out.strideOrdering(),
990	991	"FFTWPlan.init(): input and output must have the same stride ordering.");
991	992
992		initImpl(in.permuteStridesDescending(), out.permuteStridesDescending(),
	993	initImpl(in.permuteStridesDescending(), out.permuteStridesDescending(),
993	994	FFTW_FORWARD, planner_flags);
994	995	}
995
	996
996	997	/** \brief Init a complex-to-real transform.
997
	998
998	999	See the constructor with the same signature for details.
999	1000	*/
1000	1001	template <class C1, class C2>
1001		void init(MultiArrayView<N, FFTWComplex<Real>, C1> in,
	1002	void init(MultiArrayView<N, FFTWComplex<Real>, C1> in,
1002	1003	MultiArrayView<N, Real, C2> out,
1003	1004	unsigned int planner_flags = FFTW_ESTIMATE)
1004	1005	{
1005	1006	vigra_precondition(in.strideOrdering() == out.strideOrdering(),
1006	1007	"FFTWPlan.init(): input and output must have the same stride ordering.");
1007	1008
1008		initImpl(in.permuteStridesDescending(), out.permuteStridesDescending(),
	1009	initImpl(in.permuteStridesDescending(), out.permuteStridesDescending(),
1009	1010	FFTW_BACKWARD, planner_flags);
1010	1011	}
1011
	1012
1012	1013	/** \brief Execute a complex-to-complex transform.
1013
	1014
1014	1015	The array shapes must be the same as in the corresponding init function
1015	1016	or constructor. However, execute() can be called several times on
1016		the same plan, even with different arrays, as long as they have the appropriate
	1017	the same plan, even with different arrays, as long as they have the appropriate
1017	1018	shapes.
1018	1019	*/
1019	1020	template <class C1, class C2>
1020		void execute(MultiArrayView<N, FFTWComplex<Real>, C1> in,
	1021	void execute(MultiArrayView<N, FFTWComplex<Real>, C1> in,
1021	1022	MultiArrayView<N, FFTWComplex<Real>, C2> out) const
1022	1023	{
1023	1024	executeImpl(in.permuteStridesDescending(), out.permuteStridesDescending());
1024	1025	}
1025
	1026
1026	1027	/** \brief Execute a real-to-complex transform.
1027
	1028
1028	1029	The array shapes must be the same as in the corresponding init function
1029	1030	or constructor. However, execute() can be called several times on
1030		the same plan, even with different arrays, as long as they have the appropriate
	1031	the same plan, even with different arrays, as long as they have the appropriate
1031	1032	shapes.
1032	1033	*/
1033	1034	template <class C1, class C2>
1034		void execute(MultiArrayView<N, Real, C1> in,
	1035	void execute(MultiArrayView<N, Real, C1> in,
1035	1036	MultiArrayView<N, FFTWComplex<Real>, C2> out) const
1036	1037	{
1037	1038	executeImpl(in.permuteStridesDescending(), out.permuteStridesDescending());
1038	1039	}
1039
	1040
1040	1041	/** \brief Execute a complex-to-real transform.
1041
	1042
1042	1043	The array shapes must be the same as in the corresponding init function
1043	1044	or constructor. However, execute() can be called several times on
1044		the same plan, even with different arrays, as long as they have the appropriate
	1045	the same plan, even with different arrays, as long as they have the appropriate
1045	1046	shapes.
1046	1047	*/
1047	1048	template <class C1, class C2>
1048		void execute(MultiArrayView<N, FFTWComplex<Real>, C1> in,
	1049	void execute(MultiArrayView<N, FFTWComplex<Real>, C1> in,
1049	1050	MultiArrayView<N, Real, C2> out) const
1050	1051	{
1051	1052	executeImpl(in.permuteStridesDescending(), out.permuteStridesDescending());
1052	1053	}
1053
	1054
1054	1055	private:
1055
	1056
1056	1057	template <class MI, class MO>
1057	1058	void initImpl(MI ins, MO outs, int SIGN, unsigned int planner_flags);
1058
	1059
1059	1060	template <class MI, class MO>
1060	1061	void executeImpl(MI ins, MO outs) const;
1061
1062		void checkShapes(MultiArrayView<N, FFTWComplex<Real>, StridedArrayTag> in,
	1062
	1063	void checkShapes(MultiArrayView<N, FFTWComplex<Real>, StridedArrayTag> in,
1063	1064	MultiArrayView<N, FFTWComplex<Real>, StridedArrayTag> out) const
1064	1065	{
1065	1066	vigra_precondition(in.shape() == out.shape(),
1066	1067	"FFTWPlan.init(): input and output must have the same shape.");
1067	1068	}
1068
1069		void checkShapes(MultiArrayView<N, Real, StridedArrayTag> ins,
	1069
	1070	void checkShapes(MultiArrayView<N, Real, StridedArrayTag> ins,
1070	1071	MultiArrayView<N, FFTWComplex<Real>, StridedArrayTag> outs) const
1071	1072	{
1072	1073	for(int k=0; k<(int)N-1; ++k)

1075	1076	vigra_precondition(ins.shape(N-1) / 2 + 1 == outs.shape(N-1),
1076	1077	"FFTWPlan.init(): input and output must have matching shapes.");
1077	1078	}
1078
1079		void checkShapes(MultiArrayView<N, FFTWComplex<Real>, StridedArrayTag> ins,
	1079
	1080	void checkShapes(MultiArrayView<N, FFTWComplex<Real>, StridedArrayTag> ins,
1080	1081	MultiArrayView<N, Real, StridedArrayTag> outs) const
1081	1082	{
1082	1083	for(int k=0; k<(int)N-1; ++k)

1093	1094	FFTWPlan<N, Real>::initImpl(MI ins, MO outs, int SIGN, unsigned int planner_flags)
1094	1095	{
1095	1096	checkShapes(ins, outs);
1096
	1097
1097	1098	typename MultiArrayShape<N>::type logicalShape(SIGN == FFTW_FORWARD
1098	1099	? ins.shape()
1099	1100	: outs.shape());
1100
	1101
1101	1102	Shape newShape(logicalShape.begin(), logicalShape.end()),
1102	1103	newIStrides(ins.stride().begin(), ins.stride().end()),
1103	1104	newOStrides(outs.stride().begin(), outs.stride().end()),
1104		itotal(ins.shape().begin(), ins.shape().end()),
	1105	itotal(ins.shape().begin(), ins.shape().end()),
1105	1106	ototal(outs.shape().begin(), outs.shape().end());
1106	1107
1107	1108	for(unsigned int j=1; j<N; ++j)

1109	1110	itotal[j] = ins.stride(j-1) / ins.stride(j);
1110	1111	ototal[j] = outs.stride(j-1) / outs.stride(j);
1111	1112	}
1112
	1113
1113	1114	{
1114	1115	detail::FFTWLock<> lock;
1115		PlanType newPlan = detail::fftwPlanCreate(N, newShape.begin(),
	1116	PlanType newPlan = detail::fftwPlanCreate(N, newShape.begin(),
1116	1117	ins.data(), itotal.begin(), ins.stride(N-1),
1117	1118	outs.data(), ototal.begin(), outs.stride(N-1),
1118	1119	SIGN, planner_flags);
1119	1120	detail::fftwPlanDestroy(plan);
1120	1121	plan = newPlan;
1121	1122	}
1122
	1123
1123	1124	shape.swap(newShape);
1124	1125	instrides.swap(newIStrides);
1125	1126	outstrides.swap(newOStrides);

1135	1136	typename MultiArrayShape<N>::type lshape(sign == FFTW_FORWARD
1136	1137	? ins.shape()
1137	1138	: outs.shape());
1138
	1139
1139	1140	vigra_precondition((lshape == TinyVectorView<int, N>(shape.data())),
1140	1141	"FFTWPlan::execute(): shape mismatch between plan and data.");
1141	1142	vigra_precondition((ins.stride() == TinyVectorView<int, N>(instrides.data())),

1144	1145	"FFTWPlan::execute(): strides mismatch between plan and output data.");
1145	1146
1146	1147	detail::fftwPlanExecute(plan, ins.data(), outs.data());
1147
	1148
1148	1149	typedef typename MO::value_type V;
1149	1150	if(sign == FFTW_BACKWARD)
1150	1151	outs *= V(1.0) / Real(outs.size());

1163	1164	in an easy-to-use interface. It always creates a pair of plans, one for the forward and one
1164	1165	for the inverse transform required for convolution.
1165	1166
1166		Usually, you use this class only indirectly via \ref convolveFFT() and its variants.
1167		You only need this class if you want to have more control about FFTW's planning process
	1167	Usually, you use this class only indirectly via \ref convolveFFT() and its variants.
	1168	You only need this class if you want to have more control about FFTW's planning process
1168	1169	(by providing non-default planning flags) and/or want to re-use plans for several convolutions.
1169
	1170
1170	1171	<b> Usage:</b>
1171	1172
1172	1173	<b>\#include</b> \<vigra/multi_fft.hxx\><br>

1175	1176	\code
1176	1177	// convolve a real array with a real kernel
1177	1178	MultiArray<2, double> src(Shape2(w, h)), dest(Shape2(w, h));
1178
	1179
1179	1180	MultiArray<2, double> spatial_kernel(Shape2(9, 9));
1180	1181	Gaussian<double> gauss(1.0);
1181
	1182
1182	1183	for(int y=0; y<9; ++y)
1183	1184	for(int x=0; x<9; ++x)
1184	1185	spatial_kernel(x, y) = gauss(x-4.0)*gauss(y-4.0);
1185
	1186
1186	1187	// create an optimized plan by measuring the speed of several algorithm variants
1187	1188	FFTWConvolvePlan<2, double> plan(src, spatial_kernel, dest, FFTW_MEASURE);
1188
1189		plan.execute(src, spatial_kernel, dest);
	1189
	1190	plan.execute(src, spatial_kernel, dest);
1190	1191	\endcode
1191	1192	*/
1192	1193	template <unsigned int N, class Real>

1195	1196	typedef FFTWComplex<Real> Complex;
1196	1197	typedef MultiArrayView<N, Real, UnstridedArrayTag > RArray;
1197	1198	typedef MultiArray<N, Complex, FFTWAllocator<Complex> > CArray;
1198
	1199
1199	1200	FFTWPlan<N, Real> forward_plan, backward_plan;
1200	1201	RArray realArray, realKernel;
1201	1202	CArray fourierArray, fourierKernel;
1202	1203	bool useFourierKernel;
1203	1204
1204	1205	public:
1205
	1206
1206	1207	typedef typename MultiArrayShape<N>::type Shape;
1207	1208
1208	1209	/** \brief Create an empty plan.
1209
	1210
1210	1211	The plan can be initialized later by one of the init() functions.
1211	1212	*/
1212	1213	FFTWConvolvePlan()
1213	1214	: useFourierKernel(false)
1214	1215	{}
1215
	1216
1216	1217	/** \brief Create a plan to convolve a real array with a real kernel.
1217
	1218
1218	1219	The kernel must be defined in the spatial domain.
1219	1220	See \ref convolveFFT() for detailed information on required shapes and internal padding.
1220
1221		\arg planner_flags must be a combination of the
1222		<a href="http://www.fftw.org/doc/Planner-Flags.html">planner
	1221
	1222	\arg planner_flags must be a combination of the
	1223	<a href="http://www.fftw.org/doc/Planner-Flags.html">planner
1223	1224	flags</a> defined by the FFTW library. The default <tt>FFTW_ESTIMATE</tt> will guess
1224		optimal algorithm settings or read them from pre-loaded
	1225	optimal algorithm settings or read them from pre-loaded
1225	1226	<a href="http://www.fftw.org/doc/Wisdom.html">"wisdom"</a>.
1226	1227	*/
1227	1228	template <class C1, class C2, class C3>
1228		FFTWConvolvePlan(MultiArrayView<N, Real, C1> in,
	1229	FFTWConvolvePlan(MultiArrayView<N, Real, C1> in,
1229	1230	MultiArrayView<N, Real, C2> kernel,
1230	1231	MultiArrayView<N, Real, C3> out,
1231	1232	unsigned int planner_flags = FFTW_ESTIMATE)

1233	1234	{
1234	1235	init(in, kernel, out, planner_flags);
1235	1236	}
1236
	1237
1237	1238	/** \brief Create a plan to convolve a real array with a complex kernel.
1238
1239		The kernel must be defined in the Fourier domain, using the half-space format.
	1239
	1240	The kernel must be defined in the Fourier domain, using the half-space format.
1240	1241	See \ref convolveFFT() for detailed information on required shapes and internal padding.
1241
1242		\arg planner_flags must be a combination of the
1243		<a href="http://www.fftw.org/doc/Planner-Flags.html">planner
	1242
	1243	\arg planner_flags must be a combination of the
	1244	<a href="http://www.fftw.org/doc/Planner-Flags.html">planner
1244	1245	flags</a> defined by the FFTW library. The default <tt>FFTW_ESTIMATE</tt> will guess
1245		optimal algorithm settings or read them from pre-loaded
	1246	optimal algorithm settings or read them from pre-loaded
1246	1247	<a href="http://www.fftw.org/doc/Wisdom.html">"wisdom"</a>.
1247	1248	*/
1248	1249	template <class C1, class C2, class C3>
1249		FFTWConvolvePlan(MultiArrayView<N, Real, C1> in,
	1250	FFTWConvolvePlan(MultiArrayView<N, Real, C1> in,
1250	1251	MultiArrayView<N, FFTWComplex<Real>, C2> kernel,
1251	1252	MultiArrayView<N, Real, C3> out,
1252	1253	unsigned int planner_flags = FFTW_ESTIMATE)

1254	1255	{
1255	1256	init(in, kernel, out, planner_flags);
1256	1257	}
1257
	1258
1258	1259	/** \brief Create a plan to convolve a complex array with a complex kernel.
1259
	1260
1260	1261	See \ref convolveFFT() for detailed information on required shapes and internal padding.
1261
	1262
1262	1263	\arg fourierDomainKernel determines if the kernel is defined in the spatial or
1263	1264	Fourier domain.
1264		\arg planner_flags must be a combination of the
1265		<a href="http://www.fftw.org/doc/Planner-Flags.html">planner
	1265	\arg planner_flags must be a combination of the
	1266	<a href="http://www.fftw.org/doc/Planner-Flags.html">planner
1266	1267	flags</a> defined by the FFTW library. The default <tt>FFTW_ESTIMATE</tt> will guess
1267		optimal algorithm settings or read them from pre-loaded
	1268	optimal algorithm settings or read them from pre-loaded
1268	1269	<a href="http://www.fftw.org/doc/Wisdom.html">"wisdom"</a>.
1269	1270	*/
1270	1271	template <class C1, class C2, class C3>
1271	1272	FFTWConvolvePlan(MultiArrayView<N, FFTWComplex<Real>, C1> in,
1272	1273	MultiArrayView<N, FFTWComplex<Real>, C2> kernel,
1273		MultiArrayView<N, FFTWComplex<Real>, C3> out,
	1274	MultiArrayView<N, FFTWComplex<Real>, C3> out,
1274	1275	bool fourierDomainKernel,
1275	1276	unsigned int planner_flags = FFTW_ESTIMATE)
1276	1277	{
1277	1278	init(in, kernel, out, fourierDomainKernel, planner_flags);
1278	1279	}
1279	1280
1280
	1281
1281	1282	/** \brief Create a plan from just the shape information.
1282
	1283
1283	1284	See \ref convolveFFT() for detailed information on required shapes and internal padding.
1284
	1285
1285	1286	\arg fourierDomainKernel determines if the kernel is defined in the spatial or
1286	1287	Fourier domain.
1287		\arg planner_flags must be a combination of the
1288		<a href="http://www.fftw.org/doc/Planner-Flags.html">planner
	1288	\arg planner_flags must be a combination of the
	1289	<a href="http://www.fftw.org/doc/Planner-Flags.html">planner
1289	1290	flags</a> defined by the FFTW library. The default <tt>FFTW_ESTIMATE</tt> will guess
1290		optimal algorithm settings or read them from pre-loaded
	1291	optimal algorithm settings or read them from pre-loaded
1291	1292	<a href="http://www.fftw.org/doc/Wisdom.html">"wisdom"</a>.
1292	1293	*/
1293	1294	template <class C1, class C2, class C3>
1294		FFTWConvolvePlan(Shape inOut, Shape kernel,
	1295	FFTWConvolvePlan(Shape inOut, Shape kernel,
1295	1296	bool useFourierKernel = false,
1296	1297	unsigned int planner_flags = FFTW_ESTIMATE)
1297	1298	{

1300	1301	else
1301	1302	initFourierKernel(inOut, kernel, planner_flags);
1302	1303	}
1303
	1304
1304	1305	/** \brief Init a plan to convolve a real array with a real kernel.
1305
	1306
1306	1307	See the constructor with the same signature for details.
1307	1308	*/
1308	1309	template <class C1, class C2, class C3>
1309		void init(MultiArrayView<N, Real, C1> in,
	1310	void init(MultiArrayView<N, Real, C1> in,
1310	1311	MultiArrayView<N, Real, C2> kernel,
1311	1312	MultiArrayView<N, Real, C3> out,
1312	1313	unsigned int planner_flags = FFTW_ESTIMATE)

1315	1316	"FFTWConvolvePlan::init(): input and output must have the same shape.");
1316	1317	init(in.shape(), kernel.shape(), planner_flags);
1317	1318	}
1318
	1319
1319	1320	/** \brief Init a plan to convolve a real array with a complex kernel.
1320
	1321
1321	1322	See the constructor with the same signature for details.
1322	1323	*/
1323	1324	template <class C1, class C2, class C3>
1324		void init(MultiArrayView<N, Real, C1> in,
	1325	void init(MultiArrayView<N, Real, C1> in,
1325	1326	MultiArrayView<N, FFTWComplex<Real>, C2> kernel,
1326	1327	MultiArrayView<N, Real, C3> out,
1327	1328	unsigned int planner_flags = FFTW_ESTIMATE)

1330	1331	"FFTWConvolvePlan::init(): input and output must have the same shape.");
1331	1332	initFourierKernel(in.shape(), kernel.shape(), planner_flags);
1332	1333	}
1333
	1334
1334	1335	/** \brief Init a plan to convolve a complex array with a complex kernel.
1335
	1336
1336	1337	See the constructor with the same signature for details.
1337	1338	*/
1338	1339	template <class C1, class C2, class C3>
1339		void init(MultiArrayView<N, FFTWComplex<Real>, C1> in,
	1340	void init(MultiArrayView<N, FFTWComplex<Real>, C1> in,
1340	1341	MultiArrayView<N, FFTWComplex<Real>, C2> kernel,
1341		MultiArrayView<N, FFTWComplex<Real>, C3> out,
	1342	MultiArrayView<N, FFTWComplex<Real>, C3> out,
1342	1343	bool fourierDomainKernel,
1343	1344	unsigned int planner_flags = FFTW_ESTIMATE)
1344	1345	{

1347	1348	useFourierKernel = fourierDomainKernel;
1348	1349	initComplex(in.shape(), kernel.shape(), planner_flags);
1349	1350	}
1350
	1351
1351	1352	/** \brief Init a plan to convolve a real array with a sequence of kernels.
1352
	1353
1353	1354	The kernels can be either real or complex. The sequences \a kernels and \a outs
1354		must have the same length. See the corresponding constructors
	1355	must have the same length. See the corresponding constructors
1355	1356	for single kernels for details.
1356	1357	*/
1357	1358	template <class C1, class KernelIterator, class OutIterator>
1358		void initMany(MultiArrayView<N, Real, C1> in,
	1359	void initMany(MultiArrayView<N, Real, C1> in,
1359	1360	KernelIterator kernels, KernelIterator kernelsEnd,
1360	1361	OutIterator outs, unsigned int planner_flags = FFTW_ESTIMATE)
1361	1362	{

1379	1380	}
1380	1381	else
1381	1382	{
1382		initFourierKernelMany(in.shape(),
	1383	initFourierKernelMany(in.shape(),
1383	1384	checkShapesFourier(in.shape(), kernels, kernelsEnd, outs),
1384	1385	planner_flags);
1385	1386	}
1386	1387	}
1387
	1388
1388	1389	/** \brief Init a plan to convolve a complex array with a sequence of kernels.
1389
	1390
1390	1391	The kernels must be complex as well. The sequences \a kernels and \a outs
1391		must have the same length. See the corresponding constructors
	1392	must have the same length. See the corresponding constructors
1392	1393	for single kernels for details.
1393	1394	*/
1394	1395	template <class C1, class KernelIterator, class OutIterator>
1395		void initMany(MultiArrayView<N, FFTWComplex<Real>, C1> in,
	1396	void initMany(MultiArrayView<N, FFTWComplex<Real>, C1> in,
1396	1397	KernelIterator kernels, KernelIterator kernelsEnd,
1397	1398	OutIterator outs,
1398	1399	bool fourierDomainKernels,

1409	1410	"FFTWConvolvePlan::initMany(): outputs have unsuitable value_type.");
1410	1411
1411	1412	useFourierKernel = fourierDomainKernels;
1412
	1413
1413	1414	Shape paddedShape = checkShapesComplex(in.shape(), kernels, kernelsEnd, outs);
1414
	1415
1415	1416	CArray newFourierArray(paddedShape), newFourierKernel(paddedShape);
1416
	1417
1417	1418	FFTWPlan<N, Real> fplan(newFourierArray, newFourierArray, FFTW_FORWARD, planner_flags);
1418	1419	FFTWPlan<N, Real> bplan(newFourierArray, newFourierArray, FFTW_BACKWARD, planner_flags);
1419
	1420
1420	1421	forward_plan = fplan;
1421	1422	backward_plan = bplan;
1422	1423	fourierArray.swap(newFourierArray);
1423	1424	fourierKernel.swap(newFourierKernel);
1424	1425	}
1425
	1426
1426	1427	void init(Shape inOut, Shape kernel,
1427	1428	unsigned int planner_flags = FFTW_ESTIMATE);
1428
	1429
1429	1430	void initFourierKernel(Shape inOut, Shape kernel,
1430	1431	unsigned int planner_flags = FFTW_ESTIMATE);
1431
	1432
1432	1433	void initComplex(Shape inOut, Shape kernel,
1433	1434	unsigned int planner_flags = FFTW_ESTIMATE);
1434
	1435
1435	1436	void initMany(Shape inOut, Shape maxKernel,
1436	1437	unsigned int planner_flags = FFTW_ESTIMATE)
1437	1438	{
1438	1439	init(inOut, maxKernel, planner_flags);
1439	1440	}
1440
	1441
1441	1442	void initFourierKernelMany(Shape inOut, Shape kernels,
1442	1443	unsigned int planner_flags = FFTW_ESTIMATE)
1443	1444	{
1444	1445	initFourierKernel(inOut, kernels, planner_flags);
1445	1446	}
1446
	1447
1447	1448	/** \brief Execute a plan to convolve a real array with a real kernel.
1448
	1449
1449	1450	The array shapes must be the same as in the corresponding init function
1450	1451	or constructor. However, execute() can be called several times on
1451		the same plan, even with different arrays, as long as they have the appropriate
	1452	the same plan, even with different arrays, as long as they have the appropriate
1452	1453	shapes.
1453	1454	*/
1454	1455	template <class C1, class C2, class C3>
1455		void execute(MultiArrayView<N, Real, C1> in,
	1456	void execute(MultiArrayView<N, Real, C1> in,
1456	1457	MultiArrayView<N, Real, C2> kernel,
1457	1458	MultiArrayView<N, Real, C3> out)
1458	1459	{
1459	1460	executeImpl(in, kernel, out);
1460	1461	}
1461
	1462
1462	1463	/** \brief Execute a plan to convolve a real array with a complex kernel.
1463
	1464
1464	1465	The array shapes must be the same as in the corresponding init function
1465	1466	or constructor. However, execute() can be called several times on
1466		the same plan, even with different arrays, as long as they have the appropriate
	1467	the same plan, even with different arrays, as long as they have the appropriate
1467	1468	shapes.
1468	1469	*/
1469	1470	template <class C1, class C2, class C3>
1470		void execute(MultiArrayView<N, Real, C1> in,
	1471	void execute(MultiArrayView<N, Real, C1> in,
1471	1472	MultiArrayView<N, FFTWComplex<Real>, C2> kernel,
1472	1473	MultiArrayView<N, Real, C3> out);
1473	1474
1474	1475	/** \brief Execute a plan to convolve a complex array with a complex kernel.
1475
	1476
1476	1477	The array shapes must be the same as in the corresponding init function
1477	1478	or constructor. However, execute() can be called several times on
1478		the same plan, even with different arrays, as long as they have the appropriate
	1479	the same plan, even with different arrays, as long as they have the appropriate
1479	1480	shapes.
1480	1481	*/
1481	1482	template <class C1, class C2, class C3>

1485	1486
1486	1487
1487	1488	/** \brief Execute a plan to convolve a complex array with a sequence of kernels.
1488
	1489
1489	1490	The array shapes must be the same as in the corresponding init function
1490	1491	or constructor. However, executeMany() can be called several times on
1491		the same plan, even with different arrays, as long as they have the appropriate
	1492	the same plan, even with different arrays, as long as they have the appropriate
1492	1493	shapes.
1493	1494	*/
1494	1495	template <class C1, class KernelIterator, class OutIterator>
1495		void executeMany(MultiArrayView<N, FFTWComplex<Real>, C1> in,
	1496	void executeMany(MultiArrayView<N, FFTWComplex<Real>, C1> in,
1496	1497	KernelIterator kernels, KernelIterator kernelsEnd,
1497	1498	OutIterator outs);
1498
	1499
1499	1500	/** \brief Execute a plan to convolve a real array with a sequence of kernels.
1500
	1501
1501	1502	The array shapes must be the same as in the corresponding init function
1502	1503	or constructor. However, executeMany() can be called several times on
1503		the same plan, even with different arrays, as long as they have the appropriate
	1504	the same plan, even with different arrays, as long as they have the appropriate
1504	1505	shapes.
1505	1506	*/
1506	1507	template <class C1, class KernelIterator, class OutIterator>
1507		void executeMany(MultiArrayView<N, Real, C1> in,
	1508	void executeMany(MultiArrayView<N, Real, C1> in,
1508	1509	KernelIterator kernels, KernelIterator kernelsEnd,
1509	1510	OutIterator outs)
1510	1511	{

1526	1527	}
1527	1528
1528	1529	protected:
1529
	1530
1530	1531	template <class KernelIterator, class OutIterator>
1531		Shape checkShapes(Shape in,
	1532	Shape checkShapes(Shape in,
1532	1533	KernelIterator kernels, KernelIterator kernelsEnd,
1533	1534	OutIterator outs);
1534
	1535
1535	1536	template <class KernelIterator, class OutIterator>
1536		Shape checkShapesFourier(Shape in,
	1537	Shape checkShapesFourier(Shape in,
1537	1538	KernelIterator kernels, KernelIterator kernelsEnd,
1538	1539	OutIterator outs);
1539
	1540
1540	1541	template <class KernelIterator, class OutIterator>
1541		Shape checkShapesComplex(Shape in,
	1542	Shape checkShapesComplex(Shape in,
1542	1543	KernelIterator kernels, KernelIterator kernelsEnd,
1543	1544	OutIterator outs);
1544
	1545
1545	1546	template <class C1, class C2, class C3>
1546		void executeImpl(MultiArrayView<N, Real, C1> in,
	1547	void executeImpl(MultiArrayView<N, Real, C1> in,
1547	1548	MultiArrayView<N, Real, C2> kernel,
1548	1549	MultiArrayView<N, Real, C3> out,
1549	1550	bool do_correlation=false);
1550
	1551
1551	1552	template <class C1, class KernelIterator, class OutIterator>
1552		void
1553		executeManyImpl(MultiArrayView<N, Real, C1> in,
	1553	void
	1554	executeManyImpl(MultiArrayView<N, Real, C1> in,
1554	1555	KernelIterator kernels, KernelIterator kernelsEnd,
1555	1556	OutIterator outs, VigraFalseType /* useFourierKernel*/);
1556
	1557
1557	1558	template <class C1, class KernelIterator, class OutIterator>
1558		void
1559		executeManyImpl(MultiArrayView<N, Real, C1> in,
	1559	void
	1560	executeManyImpl(MultiArrayView<N, Real, C1> in,
1560	1561	KernelIterator kernels, KernelIterator kernelsEnd,
1561	1562	OutIterator outs, VigraTrueType /* useFourierKernel*/);
1562
1563		};
1564
	1563
	1564	};
	1565
1565	1566	template <unsigned int N, class Real>
1566		void
	1567	void
1567	1568	FFTWConvolvePlan<N, Real>::init(Shape in, Shape kernel,
1568	1569	unsigned int planner_flags)
1569	1570	{
1570	1571	Shape paddedShape = fftwBestPaddedShapeR2C(in + kernel - Shape(1)),
1571	1572	complexShape = fftwCorrespondingShapeR2C(paddedShape);
1572
	1573
1573	1574	CArray newFourierArray(complexShape), newFourierKernel(complexShape);
1574
	1575
1575	1576	Shape realStrides = 2*newFourierArray.stride();
1576	1577	realStrides[0] = 1;
1577	1578	RArray newRealArray(paddedShape, realStrides, (Real*)newFourierArray.data());
1578	1579	RArray newRealKernel(paddedShape, realStrides, (Real*)newFourierKernel.data());
1579
	1580
1580	1581	FFTWPlan<N, Real> fplan(newRealArray, newFourierArray, planner_flags);
1581	1582	FFTWPlan<N, Real> bplan(newFourierArray, newRealArray, planner_flags);
1582
	1583
1583	1584	forward_plan = fplan;
1584	1585	backward_plan = bplan;
1585	1586	realArray = newRealArray;

1590	1591	}
1591	1592
1592	1593	template <unsigned int N, class Real>
1593		void
	1594	void
1594	1595	FFTWConvolvePlan<N, Real>::initFourierKernel(Shape in, Shape kernel,
1595	1596	unsigned int planner_flags)
1596	1597	{
1597	1598	Shape complexShape = kernel,
1598	1599	paddedShape = fftwCorrespondingShapeC2R(complexShape);
1599
	1600
1600	1601	for(unsigned int k=0; k<N; ++k)
1601	1602	vigra_precondition(in[k] <= paddedShape[k],
1602	1603	"FFTWConvolvePlan::init(): kernel too small for given input.");
1603	1604
1604	1605	CArray newFourierArray(complexShape), newFourierKernel(complexShape);
1605
	1606
1606	1607	Shape realStrides = 2*newFourierArray.stride();
1607	1608	realStrides[0] = 1;
1608	1609	RArray newRealArray(paddedShape, realStrides, (Real*)newFourierArray.data());
1609	1610	RArray newRealKernel(paddedShape, realStrides, (Real*)newFourierKernel.data());
1610
	1611
1611	1612	FFTWPlan<N, Real> fplan(newRealArray, newFourierArray, planner_flags);
1612	1613	FFTWPlan<N, Real> bplan(newFourierArray, newRealArray, planner_flags);
1613
	1614
1614	1615	forward_plan = fplan;
1615	1616	backward_plan = bplan;
1616	1617	realArray = newRealArray;

1621	1622	}
1622	1623
1623	1624	template <unsigned int N, class Real>
1624		void
	1625	void
1625	1626	FFTWConvolvePlan<N, Real>::initComplex(Shape in, Shape kernel,
1626	1627	unsigned int planner_flags)
1627	1628	{
1628	1629	Shape paddedShape;
1629
	1630
1630	1631	if(useFourierKernel)
1631	1632	{
1632	1633	for(unsigned int k=0; k<N; ++k)

1639	1640	{
1640	1641	paddedShape = fftwBestPaddedShape(in + kernel - Shape(1));
1641	1642	}
1642
	1643
1643	1644	CArray newFourierArray(paddedShape), newFourierKernel(paddedShape);
1644
	1645
1645	1646	FFTWPlan<N, Real> fplan(newFourierArray, newFourierArray, FFTW_FORWARD, planner_flags);
1646	1647	FFTWPlan<N, Real> bplan(newFourierArray, newFourierArray, FFTW_BACKWARD, planner_flags);
1647
	1648
1648	1649	forward_plan = fplan;
1649	1650	backward_plan = bplan;
1650	1651	fourierArray.swap(newFourierArray);

1655	1656
1656	1657	template <unsigned int N, class Real>
1657	1658	template <class C1, class C2, class C3>
1658		void
1659		FFTWConvolvePlan<N, Real>::executeImpl(MultiArrayView<N, Real, C1> in,
	1659	void
	1660	FFTWConvolvePlan<N, Real>::executeImpl(MultiArrayView<N, Real, C1> in,
1660	1661	MultiArrayView<N, Real, C2> kernel,
1661	1662	MultiArrayView<N, Real, C3> out,
1662	1663	bool do_correlation)

1666	1667
1667	1668	vigra_precondition(in.shape() == out.shape(),
1668	1669	"FFTWConvolvePlan::execute(): input and output must have the same shape.");
1669
	1670
1670	1671	Shape paddedShape = fftwBestPaddedShapeR2C(in.shape() + kernel.shape() - Shape(1)),
1671		diff = paddedShape - in.shape(),
	1672	diff = paddedShape - in.shape(),
1672	1673	left = div(diff, MultiArrayIndex(2)),
1673	1674	right = in.shape() + left;
1674
	1675
1675	1676	vigra_precondition(paddedShape == realArray.shape(),
1676	1677	"FFTWConvolvePlan::execute(): shape mismatch between input and plan.");
1677	1678

1680	1681
1681	1682	detail::fftEmbedKernel(kernel, realKernel);
1682	1683	forward_plan.execute(realKernel, fourierKernel);
1683
	1684
1684	1685	if(do_correlation)
1685	1686	{
1686	1687	using namespace multi_math;

1690	1691	{
1691	1692	fourierArray *= fourierKernel;
1692	1693	}
1693
	1694
1694	1695	backward_plan.execute(fourierArray, realArray);
1695
	1696
1696	1697	out = realArray.subarray(left, right);
1697	1698	}
1698	1699
1699	1700	template <unsigned int N, class Real>
1700	1701	template <class C1, class C2, class C3>
1701		void
1702		FFTWConvolvePlan<N, Real>::execute(MultiArrayView<N, Real, C1> in,
	1702	void
	1703	FFTWConvolvePlan<N, Real>::execute(MultiArrayView<N, Real, C1> in,
1703	1704	MultiArrayView<N, FFTWComplex<Real>, C2> kernel,
1704	1705	MultiArrayView<N, Real, C3> out)
1705	1706	{

1708	1709
1709	1710	vigra_precondition(in.shape() == out.shape(),
1710	1711	"FFTWConvolvePlan::execute(): input and output must have the same shape.");
1711
	1712
1712	1713	vigra_precondition(kernel.shape() == fourierArray.shape(),
1713	1714	"FFTWConvolvePlan::execute(): shape mismatch between kernel and plan.");
1714	1715
1715	1716	Shape paddedShape = fftwCorrespondingShapeC2R(kernel.shape(), odd(in.shape(0))),
1716		diff = paddedShape - in.shape(),
	1717	diff = paddedShape - in.shape(),
1717	1718	left = div(diff, MultiArrayIndex(2)),
1718	1719	right = in.shape() + left;
1719
	1720
1720	1721	vigra_precondition(paddedShape == realArray.shape(),
1721	1722	"FFTWConvolvePlan::execute(): shape mismatch between input and plan.");
1722	1723

1727	1728	moveDCToHalfspaceUpperLeft(fourierKernel);
1728	1729
1729	1730	fourierArray *= fourierKernel;
1730
	1731
1731	1732	backward_plan.execute(fourierArray, realArray);
1732
	1733
1733	1734	out = realArray.subarray(left, right);
1734	1735	}
1735	1736
1736	1737	template <unsigned int N, class Real>
1737	1738	template <class C1, class C2, class C3>
1738		void
1739		FFTWConvolvePlan<N, Real>::execute(MultiArrayView<N, FFTWComplex<Real>, C1> in,
	1739	void
	1740	FFTWConvolvePlan<N, Real>::execute(MultiArrayView<N, FFTWComplex<Real>, C1> in,
1740	1741	MultiArrayView<N, FFTWComplex<Real>, C2> kernel,
1741	1742	MultiArrayView<N, FFTWComplex<Real>, C3> out)
1742	1743	{
1743	1744	vigra_precondition(in.shape() == out.shape(),
1744	1745	"FFTWConvolvePlan::execute(): input and output must have the same shape.");
1745
	1746
1746	1747	Shape paddedShape = fourierArray.shape(),
1747		diff = paddedShape - in.shape(),
	1748	diff = paddedShape - in.shape(),
1748	1749	left = div(diff, MultiArrayIndex(2)),
1749	1750	right = in.shape() + left;
1750
	1751
1751	1752	if(useFourierKernel)
1752	1753	{
1753	1754	vigra_precondition(kernel.shape() == fourierArray.shape(),
1754	1755	"FFTWConvolvePlan::execute(): shape mismatch between kernel and plan.");
1755
	1756
1756	1757	fourierKernel = kernel;
1757	1758	moveDCToUpperLeft(fourierKernel);
1758	1759	}

1766	1767	forward_plan.execute(fourierArray, fourierArray);
1767	1768
1768	1769	fourierArray *= fourierKernel;
1769
	1770
1770	1771	backward_plan.execute(fourierArray, fourierArray);
1771
	1772
1772	1773	out = fourierArray.subarray(left, right);
1773	1774	}
1774	1775
1775	1776	template <unsigned int N, class Real>
1776	1777	template <class C1, class KernelIterator, class OutIterator>
1777		void
1778		FFTWConvolvePlan<N, Real>::executeManyImpl(MultiArrayView<N, Real, C1> in,
	1778	void
	1779	FFTWConvolvePlan<N, Real>::executeManyImpl(MultiArrayView<N, Real, C1> in,
1779	1780	KernelIterator kernels, KernelIterator kernelsEnd,
1780	1781	OutIterator outs, VigraFalseType /useFourierKernel/)
1781	1782	{

1784	1785
1785	1786	Shape kernelMax = checkShapes(in.shape(), kernels, kernelsEnd, outs),
1786	1787	paddedShape = fftwBestPaddedShapeR2C(in.shape() + kernelMax - Shape(1)),
1787		diff = paddedShape - in.shape(),
	1788	diff = paddedShape - in.shape(),
1788	1789	left = div(diff, MultiArrayIndex(2)),
1789	1790	right = in.shape() + left;
1790
	1791
1791	1792	vigra_precondition(paddedShape == realArray.shape(),
1792	1793	"FFTWConvolvePlan::executeMany(): shape mismatch between input and plan.");
1793	1794

1798	1799	{
1799	1800	detail::fftEmbedKernel(*kernels, realKernel);
1800	1801	forward_plan.execute(realKernel, fourierKernel);
1801
	1802
1802	1803	fourierKernel *= fourierArray;
1803
	1804
1804	1805	backward_plan.execute(fourierKernel, realKernel);
1805
	1806
1806	1807	*outs = realKernel.subarray(left, right);
1807	1808	}
1808	1809	}
1809	1810
1810	1811	template <unsigned int N, class Real>
1811	1812	template <class C1, class KernelIterator, class OutIterator>
1812		void
1813		FFTWConvolvePlan<N, Real>::executeManyImpl(MultiArrayView<N, Real, C1> in,
	1813	void
	1814	FFTWConvolvePlan<N, Real>::executeManyImpl(MultiArrayView<N, Real, C1> in,
1814	1815	KernelIterator kernels, KernelIterator kernelsEnd,
1815	1816	OutIterator outs, VigraTrueType /useFourierKernel/)
1816	1817	{

1819	1820
1820	1821	Shape complexShape = checkShapesFourier(in.shape(), kernels, kernelsEnd, outs),
1821	1822	paddedShape = fftwCorrespondingShapeC2R(complexShape, odd(in.shape(0))),
1822		diff = paddedShape - in.shape(),
	1823	diff = paddedShape - in.shape(),
1823	1824	left = div(diff, MultiArrayIndex(2)),
1824	1825	right = in.shape() + left;
1825
	1826
1826	1827	vigra_precondition(complexShape == fourierArray.shape(),
1827	1828	"FFTWConvolvePlan::executeFourierKernelMany(): shape mismatch between kernels and plan.");
1828	1829

1837	1838	fourierKernel = *kernels;
1838	1839	moveDCToHalfspaceUpperLeft(fourierKernel);
1839	1840	fourierKernel *= fourierArray;
1840
	1841
1841	1842	backward_plan.execute(fourierKernel, realKernel);
1842
	1843
1843	1844	*outs = realKernel.subarray(left, right);
1844	1845	}
1845	1846	}
1846	1847
1847	1848	template <unsigned int N, class Real>
1848	1849	template <class C1, class KernelIterator, class OutIterator>
1849		void
1850		FFTWConvolvePlan<N, Real>::executeMany(MultiArrayView<N, FFTWComplex<Real>, C1> in,
	1850	void
	1851	FFTWConvolvePlan<N, Real>::executeMany(MultiArrayView<N, FFTWComplex<Real>, C1> in,
1851	1852	KernelIterator kernels, KernelIterator kernelsEnd,
1852	1853	OutIterator outs)
1853	1854	{

1862	1863	"FFTWConvolvePlan::executeMany(): outputs have unsuitable value_type.");
1863	1864
1864	1865	Shape paddedShape = checkShapesComplex(in.shape(), kernels, kernelsEnd, outs),
1865		diff = paddedShape - in.shape(),
	1866	diff = paddedShape - in.shape(),
1866	1867	left = div(diff, MultiArrayIndex(2)),
1867	1868	right = in.shape() + left;
1868
	1869
1869	1870	detail::fftEmbedArray(in, fourierArray);
1870	1871	forward_plan.execute(fourierArray, fourierArray);
1871	1872

1883	1884	}
1884	1885
1885	1886	fourierKernel *= fourierArray;
1886
	1887
1887	1888	backward_plan.execute(fourierKernel, fourierKernel);
1888
	1889
1889	1890	*outs = fourierKernel.subarray(left, right);
1890	1891	}
1891	1892	}

1894	1895
1895	1896	template <unsigned int N, class Real>
1896	1897	template <class KernelIterator, class OutIterator>
1897		typename FFTWConvolvePlan<N, Real>::Shape
1898		FFTWConvolvePlan<N, Real>::checkShapes(Shape in,
	1898	typename FFTWConvolvePlan<N, Real>::Shape
	1899	FFTWConvolvePlan<N, Real>::checkShapes(Shape in,
1899	1900	KernelIterator kernels, KernelIterator kernelsEnd,
1900	1901	OutIterator outs)
1901	1902	{
1902	1903	vigra_precondition(kernels != kernelsEnd,
1903	1904	"FFTWConvolvePlan::checkShapes(): empty kernel sequence.");
1904	1905
1905		Shape kernelMax;
	1906	Shape kernelMax;
1906	1907	for(; kernels != kernelsEnd; ++kernels, ++outs)
1907	1908	{
1908	1909	vigra_precondition(in == outs->shape(),

1913	1914	"FFTWConvolvePlan::checkShapes(): all kernels have size 0.");
1914	1915	return kernelMax;
1915	1916	}
1916
	1917
1917	1918	template <unsigned int N, class Real>
1918	1919	template <class KernelIterator, class OutIterator>
1919		typename FFTWConvolvePlan<N, Real>::Shape
1920		FFTWConvolvePlan<N, Real>::checkShapesFourier(Shape in,
	1920	typename FFTWConvolvePlan<N, Real>::Shape
	1921	FFTWConvolvePlan<N, Real>::checkShapesFourier(Shape in,
1921	1922	KernelIterator kernels, KernelIterator kernelsEnd,
1922	1923	OutIterator outs)
1923	1924	{

1943	1944
1944	1945	template <unsigned int N, class Real>
1945	1946	template <class KernelIterator, class OutIterator>
1946		typename FFTWConvolvePlan<N, Real>::Shape
1947		FFTWConvolvePlan<N, Real>::checkShapesComplex(Shape in,
	1947	typename FFTWConvolvePlan<N, Real>::Shape
	1948	FFTWConvolvePlan<N, Real>::checkShapesComplex(Shape in,
1948	1949	KernelIterator kernels, KernelIterator kernelsEnd,
1949	1950	OutIterator outs)
1950	1951	{
1951	1952	vigra_precondition(kernels != kernelsEnd,
1952	1953	"FFTWConvolvePlan::checkShapesComplex(): empty kernel sequence.");
1953	1954
1954		Shape kernelShape = kernels->shape();
	1955	Shape kernelShape = kernels->shape();
1955	1956	for(; kernels != kernelsEnd; ++kernels, ++outs)
1956	1957	{
1957	1958	vigra_precondition(in == outs->shape(),

1968	1969	}
1969	1970	vigra_precondition(prod(kernelShape) > 0,
1970	1971	"FFTWConvolvePlan::checkShapesComplex(): all kernels have size 0.");
1971
	1972
1972	1973	if(useFourierKernel)
1973	1974	{
1974	1975	for(unsigned int k=0; k<N; ++k)

1981	1982	return fftwBestPaddedShape(in + kernelShape - Shape(1));
1982	1983	}
1983	1984	}
1984
	1985
1985	1986	/********************************************************/
1986	1987	/* */
1987	1988	/* FFTWCorrelatePlan */

1989	1990	/********************************************************/
1990	1991
1991	1992	/** Like FFTWConvolvePlan, but performs correlation rather than convolution.
1992
	1993
1993	1994	See \ref vigra::FFTWConvolvePlan for details.
1994
	1995
1995	1996	<b> Usage:</b>
1996
	1997
1997	1998	<b>\#include</b> \<vigra/multi_fft.hxx\><br>
1998	1999	Namespace: vigra
1999
	2000
2000	2001	\code
2001	2002	// convolve a real array with a real kernel
2002	2003	MultiArray<2, double> src(Shape2(w, h)), dest(Shape2(w, h));
2003
	2004
2004	2005	MultiArray<2, double> spatial_kernel(Shape2(9, 9));
2005	2006	Gaussian<double> gauss(1.0);
2006
	2007
2007	2008	for(int y=0; y<9; ++y)
2008	2009	for(int x=0; x<9; ++x)
2009	2010	spatial_kernel(x, y) = gauss(x-4.0)*gauss(y-4.0);
2010
	2011
2011	2012	// create an optimized plan by measuring the speed of several algorithm variants
2012	2013	FFTWCorrelatePlan<2, double> plan(src, spatial_kernel, dest, FFTW_MEASURE);
2013
	2014
2014	2015	plan.execute(src, spatial_kernel, dest);
2015	2016	\endcode
2016	2017	*/

2020	2021	{
2021	2022	typedef FFTWConvolvePlan<N, Real> BaseType;
2022	2023	public:
2023
	2024
2024	2025	typedef typename MultiArrayShape<N>::type Shape;
2025
	2026
2026	2027	/** \brief Create an empty plan.
2027
	2028
2028	2029	The plan can be initialized later by one of the init() functions.
2029	2030	*/
2030	2031	FFTWCorrelatePlan()
2031	2032	: BaseType()
2032	2033	{}
2033
	2034
2034	2035	/** \brief Create a plan to correlate a real array with a real kernel.
2035
	2036
2036	2037	The kernel must be defined in the spatial domain.
2037	2038	See \ref correlateFFT() for detailed information on required shapes and internal padding.
2038
	2039
2039	2040	\arg planner_flags must be a combination of the
2040	2041	<a href="http://www.fftw.org/doc/Planner-Flags.html">planner
2041	2042	flags</a> defined by the FFTW library. The default <tt>FFTW_ESTIMATE</tt> will guess

2049	2050	unsigned int planner_flags = FFTW_ESTIMATE)
2050	2051	: BaseType(in, kernel, out, planner_flags)
2051	2052	{}
2052
	2053
2053	2054	/** \brief Create a plan from just the shape information.
2054
	2055
2055	2056	See \ref convolveFFT() for detailed information on required shapes and internal padding.
2056
	2057
2057	2058	\arg fourierDomainKernel determines if the kernel is defined in the spatial or
2058	2059	Fourier domain.
2059	2060	\arg planner_flags must be a combination of the

2067	2068	bool useFourierKernel = false,
2068	2069	unsigned int planner_flags = FFTW_ESTIMATE)
2069	2070	: BaseType(inOut, kernel, false, planner_flags)
2070		{}
2071
	2071	{
	2072	ignore_argument(useFourierKernel);
	2073	}
	2074
2072	2075	/** \brief Init a plan to convolve a real array with a real kernel.
2073
	2076
2074	2077	See the constructor with the same signature for details.
2075	2078	*/
2076	2079	template <class C1, class C2, class C3>

2083	2086	"FFTWCorrelatePlan::init(): input and output must have the same shape.");
2084	2087	BaseType::init(in.shape(), kernel.shape(), planner_flags);
2085	2088	}
2086
	2089
2087	2090	/** \brief Execute a plan to correlate a real array with a real kernel.
2088
	2091
2089	2092	The array shapes must be the same as in the corresponding init function
2090	2093	or constructor. However, execute() can be called several times on
2091	2094	the same plan, even with different arrays, as long as they have the appropriate

2107	2110	/********************************************************/
2108	2111
2109	2112	template <unsigned int N, class Real, class C1, class C2>
2110		inline void
2111		fourierTransform(MultiArrayView<N, FFTWComplex<Real>, C1> in,
	2113	inline void
	2114	fourierTransform(MultiArrayView<N, FFTWComplex<Real>, C1> in,
2112	2115	MultiArrayView<N, FFTWComplex<Real>, C2> out)
2113	2116	{
2114	2117	FFTWPlan<N, Real>(in, out, FFTW_FORWARD).execute(in, out);
2115	2118	}
2116	2119
2117	2120	template <unsigned int N, class Real, class C1, class C2>
2118		inline void
2119		fourierTransformInverse(MultiArrayView<N, FFTWComplex<Real>, C1> in,
	2121	inline void
	2122	fourierTransformInverse(MultiArrayView<N, FFTWComplex<Real>, C1> in,
2120	2123	MultiArrayView<N, FFTWComplex<Real>, C2> out)
2121	2124	{
2122	2125	FFTWPlan<N, Real>(in, out, FFTW_BACKWARD).execute(in, out);
2123	2126	}
2124	2127
2125	2128	template <unsigned int N, class Real, class C1, class C2>
2126		void
2127		fourierTransform(MultiArrayView<N, Real, C1> in,
	2129	void
	2130	fourierTransform(MultiArrayView<N, Real, C1> in,
2128	2131	MultiArrayView<N, FFTWComplex<Real>, C2> out)
2129	2132	{
2130	2133	if(in.shape() == out.shape())

2143	2146	}
2144	2147
2145	2148	template <unsigned int N, class Real, class C1, class C2>
2146		void
2147		fourierTransformInverse(MultiArrayView<N, FFTWComplex<Real>, C1> in,
	2149	void
	2150	fourierTransformInverse(MultiArrayView<N, FFTWComplex<Real>, C1> in,
2148	2151	MultiArrayView<N, Real, C2> out)
2149	2152	{
2150	2153	vigra_precondition(in.shape() == fftwCorrespondingShapeR2C(out.shape()),

2154	2157
2155	2158	//@}
2156	2159
2157		/** \addtogroup MultiArrayConvolutionFilters
	2160	/** \addtogroup ConvolutionFilters
2158	2161	*/
2159	2162	//@{
2160	2163

2169	2172	Thanks to the convolution theorem of Fourier theory, a convolution in the spatial domain
2170	2173	is equivalent to a multiplication in the frequency domain. Thus, for certain kernels
2171	2174	(especially large, non-separable ones), it is advantageous to perform the convolution by first
2172		transforming both array and kernel to the frequency domain, multiplying the frequency
2173		representations, and transforming the result back into the spatial domain.
2174		Some kernels have a much simpler definition in the frequency domain, so that they are readily
2175		computed there directly, avoiding Fourier transformation of those kernels.
2176
	2175	transforming both array and kernel to the frequency domain, multiplying the frequency
	2176	representations, and transforming the result back into the spatial domain.
	2177	Some kernels have a much simpler definition in the frequency domain, so that they are readily
	2178	computed there directly, avoiding Fourier transformation of those kernels.
	2179
2177	2180	The following functions implement various variants of FFT-based convolution:
2178
	2181
2179	2182	<DL>
2180		<DT><b>convolveFFT</b><DD> Convolve a real-valued input array with a kernel such that the
	2183	<DT><b>convolveFFT</b><DD> Convolve a real-valued input array with a kernel such that the
2181	2184	result is also real-valued. That is, the kernel is either provided
2182		as a real-valued array in the spatial domain, or as a
2183		complex-valued array in the Fourier domain, using the half-space format
	2185	as a real-valued array in the spatial domain, or as a
	2186	complex-valued array in the Fourier domain, using the half-space format
2184	2187	of the R2C Fourier transform (see below).
2185		<DT><b>convolveFFTMany</b><DD> Like <tt>convolveFFT</tt>, but you may provide many kernels at once
2186		(using an iterator pair specifying the kernel sequence).
2187		This has the advantage that the forward transform of the input array needs
	2188	<DT><b>convolveFFTMany</b><DD> Like <tt>convolveFFT</tt>, but you may provide many kernels at once
	2189	(using an iterator pair specifying the kernel sequence).
	2190	This has the advantage that the forward transform of the input array needs
2188	2191	to be executed only once.
2189		<DT><b>convolveFFTComplex</b><DD> Convolve a complex-valued input array with a complex-valued kernel,
2190		resulting in a complex-valued output array. An additional flag is used to
	2192	<DT><b>convolveFFTComplex</b><DD> Convolve a complex-valued input array with a complex-valued kernel,
	2193	resulting in a complex-valued output array. An additional flag is used to
2191	2194	specify whether the kernel is defined in the spatial or frequency domain.
2192		<DT><b>convolveFFTComplexMany</b><DD> Like <tt>convolveFFTComplex</tt>, but you may provide many
2193		kernels at once (using an iterator pair specifying the kernel sequence).
2194		This has the advantage that the forward transform of the input array needs
	2195	<DT><b>convolveFFTComplexMany</b><DD> Like <tt>convolveFFTComplex</tt>, but you may provide many
	2196	kernels at once (using an iterator pair specifying the kernel sequence).
	2197	This has the advantage that the forward transform of the input array needs
2195	2198	to be executed only once.
2196	2199	</DL>
2197
	2200
2198	2201	The output arrays must have the same shape as the input arrays. In the "Many" variants of the
2199	2202	convolution functions, the kernels must all have the same shape.
2200
	2203
2201	2204	The origin of the kernel is always assumed to be in the center of the kernel array (precisely,
2202		at the point <tt>floor(kernel.shape() / 2.0)</tt>, except when the half-space format is used, see below).
2203		The function \ref moveDCToUpperLeft() will be called internally to align the kernel with the transformed
	2205	at the point <tt>floor(kernel.shape() / 2.0)</tt>, except when the half-space format is used, see below).
	2206	The function \ref moveDCToUpperLeft() will be called internally to align the kernel with the transformed
2204	2207	input as appropriate.
2205
	2208
2206	2209	If a real input is combined with a real kernel, the kernel is automatically assumed to be defined
2207		in the spatial domain. If a real input is combined with a complex kernel, the kernel is assumed
2208		to be defined in the Fourier domain in half-space format. If the input array is complex, a flag
	2210	in the spatial domain. If a real input is combined with a complex kernel, the kernel is assumed
	2211	to be defined in the Fourier domain in half-space format. If the input array is complex, a flag
2209	2212	<tt>fourierDomainKernel</tt> determines where the kernel is defined.
2210
	2213
2211	2214	When the kernel is defined in the spatial domain, the convolution functions will automatically pad
2212	2215	(enlarge) the input array by at least the kernel radius in each direction. The newly added space is
2213		filled according to reflective boundary conditions in order to minimize border artifacts during
2214		convolution. It is thus ensured that convolution in the Fourier domain yields the same results as
2215		convolution in the spatial domain (e.g. when \ref separableConvolveMultiArray() is called with the
	2216	filled according to reflective boundary conditions in order to minimize border artifacts during
	2217	convolution. It is thus ensured that convolution in the Fourier domain yields the same results as
	2218	convolution in the spatial domain (e.g. when \ref separableConvolveMultiArray() is called with the
2216	2219	same kernel). A little further padding may be added to make sure that the padded array shape
2217	2220	uses integers which have only small prime factors, because FFTW is then able to use the fastest
2218	2221	possible algorithms. Any padding is automatically removed from the result arrays before the function
2219	2222	returns.
2220
	2223
2221	2224	When the kernel is defined in the frequency domain, it must be complex-valued, and its shape determines
2222	2225	the shape of the Fourier representation (i.e. the input is padded according to the shape of the kernel).
2223		If we are going to perform a complex-valued convolution, the kernel must be defined for the entire
2224		frequency domain, and its shape directly determines the size of the FFT.
2225
	2226	If we are going to perform a complex-valued convolution, the kernel must be defined for the entire
	2227	frequency domain, and its shape directly determines the size of the FFT.
	2228
2226	2229	In contrast, a frequency domain kernel for a real-valued convolution must have symmetry properties
2227		that allow to drop half of the kernel coefficients, as in the
2228		<a href="http://www.fftw.org/doc/Multi_002dDimensional-DFTs-of-Real-Data.html">R2C transform</a>.
2229		That is, the kernel must have the <i>half-space format</i>, that is the shape returned by <tt>fftwCorrespondingShapeR2C(fourier_shape)</tt>, where <tt>fourier_shape</tt> is the desired
2230		logical shape of the frequency representation (and thus the size of the padded input). The origin
2231		of the kernel must be at the point
2232		<tt>(0, floor(fourier_shape[0] / 2.0), ..., floor(fourier_shape[N-1] / 2.0))</tt>
	2230	that allow to drop half of the kernel coefficients, as in the
	2231	<a href="http://www.fftw.org/doc/Multi_002dDimensional-DFTs-of-Real-Data.html">R2C transform</a>.
	2232	That is, the kernel must have the <i>half-space format</i>, that is the shape returned by <tt>fftwCorrespondingShapeR2C(fourier_shape)</tt>, where <tt>fourier_shape</tt> is the desired
	2233	logical shape of the frequency representation (and thus the size of the padded input). The origin
	2234	of the kernel must be at the point
	2235	<tt>(0, floor(fourier_shape[0] / 2.0), ..., floor(fourier_shape[N-1] / 2.0))</tt>
2233	2236	(i.e. as in a regular kernel except for the first dimension).
2234
2235		The <tt>Real</tt> type in the declarations can be <tt>double</tt>, <tt>float</tt>, and
	2237
	2238	The <tt>Real</tt> type in the declarations can be <tt>double</tt>, <tt>float</tt>, and
2236	2239	<tt>long double</tt>. Your program must always link against <tt>libfftw3</tt>. If you use
2237		<tt>float</tt> or <tt>long double</tt> arrays, you must <i>additionally</i> link against
	2240	<tt>float</tt> or <tt>long double</tt> arrays, you must <i>additionally</i> link against
2238	2241	<tt>libfftw3f</tt> and <tt>libfftw3l</tt> respectively.
2239
	2242
2240	2243	The Fourier transform functions internally create <a href="http://www.fftw.org/doc/Using-Plans.html">FFTW plans</a>
2241	2244	which control the algorithm details. The plans are created with the flag <tt>FFTW_ESTIMATE</tt>, i.e.
2242	2245	optimal settings are guessed or read from saved "wisdom" files. If you need more control over planning,
2243	2246	you can use the class \ref FFTWConvolvePlan.
2244
	2247
2245	2248	See also \ref applyFourierFilter() for corresponding functionality on the basis of the
2246	2249	old image iterator interface.
2247
	2250
2248	2251	<b> Declarations:</b>
2249	2252
2250	2253	Real-valued convolution with kernel in the spatial domain:
2251	2254	\code
2252	2255	namespace vigra {
2253	2256	template <unsigned int N, class Real, class C1, class C2, class C3>
2254		void
2255		convolveFFT(MultiArrayView<N, Real, C1> in,
	2257	void
	2258	convolveFFT(MultiArrayView<N, Real, C1> in,
2256	2259	MultiArrayView<N, Real, C2> kernel,
2257	2260	MultiArrayView<N, Real, C3> out);
2258	2261	}

2262	2265	\code
2263	2266	namespace vigra {
2264	2267	template <unsigned int N, class Real, class C1, class C2, class C3>
2265		void
2266		convolveFFT(MultiArrayView<N, Real, C1> in,
	2268	void
	2269	convolveFFT(MultiArrayView<N, Real, C1> in,
2267	2270	MultiArrayView<N, FFTWComplex<Real>, C2> kernel,
2268	2271	MultiArrayView<N, Real, C3> out);
2269	2272	}
2270	2273	\endcode
2271	2274
2272		Series of real-valued convolutions with kernels in the spatial or Fourier domain
	2275	Series of real-valued convolutions with kernels in the spatial or Fourier domain
2273	2276	(the kernel and out sequences must have the same length):
2274	2277	\code
2275	2278	namespace vigra {
2276		template <unsigned int N, class Real, class C1,
	2279	template <unsigned int N, class Real, class C1,
2277	2280	class KernelIterator, class OutIterator>
2278		void
2279		convolveFFTMany(MultiArrayView<N, Real, C1> in,
	2281	void
	2282	convolveFFTMany(MultiArrayView<N, Real, C1> in,
2280	2283	KernelIterator kernels, KernelIterator kernelsEnd,
2281	2284	OutIterator outs);
2282	2285	}

2295	2298	}
2296	2299	\endcode
2297	2300
2298		Series of complex-valued convolutions (parameter <tt>fourierDomainKernel</tt>
2299		determines if the kernels are defined in the spatial or Fourier domain,
	2301	Series of complex-valued convolutions (parameter <tt>fourierDomainKernel</tt>
	2302	determines if the kernels are defined in the spatial or Fourier domain,
2300	2303	the kernel and out sequences must have the same length):
2301	2304	\code
2302	2305	namespace vigra {
2303		template <unsigned int N, class Real, class C1,
	2306	template <unsigned int N, class Real, class C1,
2304	2307	class KernelIterator, class OutIterator>
2305		void
2306		convolveFFTComplexMany(MultiArrayView<N, FFTWComplex<Real>, C1> in,
	2308	void
	2309	convolveFFTComplexMany(MultiArrayView<N, FFTWComplex<Real>, C1> in,
2307	2310	KernelIterator kernels, KernelIterator kernelsEnd,
2308	2311	OutIterator outs,
2309	2312	bool fourierDomainKernel);

2319	2322	// convolve real array with a Gaussian (sigma=1) defined in the spatial domain
2320	2323	// (implicitly uses padding by at least 4 pixels)
2321	2324	MultiArray<2, double> src(Shape2(w, h)), dest(Shape2(w,h));
2322
	2325
2323	2326	MultiArray<2, double> spatial_kernel(Shape2(9, 9));
2324	2327	Gaussian<double> gauss(1.0);
2325
	2328
2326	2329	for(int y=0; y<9; ++y)
2327	2330	for(int x=0; x<9; ++x)
2328	2331	spatial_kernel(x, y) = gauss(x-4.0)*gauss(y-4.0);
2329	2332
2330	2333	convolveFFT(src, spatial_kernel, dest);
2331
	2334
2332	2335	// convolve real array with a Gaussian (sigma=1) defined in the Fourier domain
2333	2336	// (uses no padding, because the kernel size corresponds to the input size)
2334	2337	MultiArray<2, FFTWComplex<double> > fourier_kernel(fftwCorrespondingShapeR2C(src.shape()));
2335	2338	int y0 = h / 2;
2336
	2339
2337	2340	for(int y=0; y<fourier_kernel.shape(1); ++y)
2338	2341	for(int x=0; x<fourier_kernel.shape(0); ++x)
2339	2342	fourier_kernel(x, y) = exp(-0.5sq(x / double(w))) exp(-0.5*sq((y-y0)/double(h)));

2344	2347	doxygen_overloaded_function(template <...> void convolveFFT)
2345	2348
2346	2349	template <unsigned int N, class Real, class C1, class C2, class C3>
2347		void
2348		convolveFFT(MultiArrayView<N, Real, C1> in,
	2350	void
	2351	convolveFFT(MultiArrayView<N, Real, C1> in,
2349	2352	MultiArrayView<N, Real, C2> kernel,
2350	2353	MultiArrayView<N, Real, C3> out)
2351	2354	{

2353	2356	}
2354	2357
2355	2358	template <unsigned int N, class Real, class C1, class C2, class C3>
2356		void
2357		convolveFFT(MultiArrayView<N, Real, C1> in,
	2359	void
	2360	convolveFFT(MultiArrayView<N, Real, C1> in,
2358	2361	MultiArrayView<N, FFTWComplex<Real>, C2> kernel,
2359	2362	MultiArrayView<N, Real, C3> out)
2360	2363	{

2383	2386	*/
2384	2387	doxygen_overloaded_function(template <...> void convolveFFTMany)
2385	2388
2386		template <unsigned int N, class Real, class C1,
	2389	template <unsigned int N, class Real, class C1,
2387	2390	class KernelIterator, class OutIterator>
2388		void
2389		convolveFFTMany(MultiArrayView<N, Real, C1> in,
	2391	void
	2392	convolveFFTMany(MultiArrayView<N, Real, C1> in,
2390	2393	KernelIterator kernels, KernelIterator kernelsEnd,
2391	2394	OutIterator outs)
2392	2395	{

2401	2404	*/
2402	2405	doxygen_overloaded_function(template <...> void convolveFFTComplexMany)
2403	2406
2404		template <unsigned int N, class Real, class C1,
	2407	template <unsigned int N, class Real, class C1,
2405	2408	class KernelIterator, class OutIterator>
2406		void
2407		convolveFFTComplexMany(MultiArrayView<N, FFTWComplex<Real>, C1> in,
	2409	void
	2410	convolveFFTComplexMany(MultiArrayView<N, FFTWComplex<Real>, C1> in,
2408	2411	KernelIterator kernels, KernelIterator kernelsEnd,
2409	2412	OutIterator outs,
2410	2413	bool fourierDomainKernel)

2413	2416	plan.initMany(in, kernels, kernelsEnd, outs, fourierDomainKernel);
2414	2417	plan.executeMany(in, kernels, kernelsEnd, outs);
2415	2418	}
2416
	2419
2417	2420	/********************************************************/
2418	2421	/* */
2419	2422	/* correlateFFT */

2421	2424	/********************************************************/
2422	2425
2423	2426	/** \brief Correlate an array with a kernel by means of the Fourier transform.
2424
2425		This function correlates a real-valued input array with a real-valued kernel
2426		such that the result is also real-valued. Thanks to the correlation theorem of
2427		Fourier theory, a correlation in the spatial domain is equivalent to a multiplication
	2427
	2428	This function correlates a real-valued input array with a real-valued kernel
	2429	such that the result is also real-valued. Thanks to the correlation theorem of
	2430	Fourier theory, a correlation in the spatial domain is equivalent to a multiplication
2428	2431	with the complex conjugate in the frequency domain. Thus, for
2429		certain kernels (especially large, non-separable ones), it is advantageous to perform the
	2432	certain kernels (especially large, non-separable ones), it is advantageous to perform the
2430	2433	correlation by first transforming both array and kernel to the frequency domain, multiplying
2431	2434	the frequency representations, and transforming the result back into the spatial domain.
2432
	2435
2433	2436	The output arrays must have the same shape as the input arrays.
2434
	2437
2435	2438	See also \ref convolveFFT() for corresponding functionality.
2436
	2439
2437	2440	<b> Declarations:</b>
2438
	2441
2439	2442	\code
2440	2443	namespace vigra {
2441	2444	template <unsigned int N, class Real, class C1, class C2, class C3>

2445	2448	MultiArrayView<N, Real, C3> out);
2446	2449	}
2447	2450	\endcode
2448
	2451
2449	2452	<b> Usage:</b>
2450
	2453
2451	2454	<b>\#include</b> \<vigra/multi_fft.hxx\><br>
2452	2455	Namespace: vigra
2453
	2456
2454	2457	\code
2455	2458	// correlate real array with a template to find best matches
2456	2459	// (implicitly uses padding by at least 4 pixels)
2457	2460	MultiArray<2, double> src(Shape2(w, h)), dest(Shape2(w, h));
2458
	2461
2459	2462	MultiArray<2, double> template(Shape2(9, 9));
2460		template = ...;
	2463	template = ...;
2461	2464
2462	2465	correlateFFT(src, template, dest);
2463	2466	\endcode

+16

-0

include/vigra/multi_gridgraph.hxx less more

3080	3080
3081	3081	} // namespace std
3082	3082
	3083	#ifdef WITH_BOOST_GRAPH
	3084	namespace boost {
	3085	using vigra::boost_graph::out_edges;
	3086	using vigra::boost_graph::out_degree;
	3087	using vigra::boost_graph::source;
	3088	using vigra::boost_graph::target;
	3089	using vigra::boost_graph::in_edges;
	3090	using vigra::boost_graph::in_degree;
	3091	using vigra::boost_graph::adjacent_vertices;
	3092	using vigra::boost_graph::vertices;
	3093	using vigra::boost_graph::edges;
	3094	using vigra::boost_graph::edge;
	3095	using vigra::boost_graph::num_vertices;
	3096	using vigra::boost_graph::num_edges;
	3097	}
	3098	#endif /* WITH_BOOST_GRAPH */
3083	3099
3084	3100
3085	3101	#endif /* VIGRA_MULTI_GRIDGRAPH_HXX */

+2

-2

include/vigra/multi_handle.hxx less more

570	570	}
571	571
572	572	template <class U>
573		void internal_reset(U const & p)
	573	void internal_reset(U const &)
574	574	{
575	575	vigra_fail("CoupledHandle<Multiband<T>>::internal_reset(): not implemented.");
576	576	}

852	852	}
853	853
854	854	template <class V>
855		void internal_reset(V const & p)
	855	void internal_reset(V const &)
856	856	{
857	857	vigra_fail("CoupledHandle<ChunkedMemory<T>>::internal_reset(): not implemented.");
858	858	}

+2

-3

include/vigra/multi_histogram.hxx less more

108	108	template< unsigned int DIM , class T_DATA, class T_HIST >
109	109	void multiGaussianCoHistogram(
110	110	const MultiArrayView<DIM, T_DATA > & imageA,
111		const MultiArrayView<DIM, T_DATA > & imageB,
	111	const MultiArrayView<DIM, T_DATA > & /imageB/,
112	112	const TinyVector<T_DATA,2> & minVals,
113	113	const TinyVector<T_DATA,2> & maxVals,
114	114	const TinyVector<int,2> & nBins,

145	145
146	146	const float fiA = binIndexA;
147	147	const unsigned int biA = std::floor(fiA+0.5);
148		const float fiB = binIndexB;
149	148	const unsigned int biB = std::floor(fiA+0.5);
150	149	histCoord[DIM]=std::min(biA,static_cast<unsigned int>(nBins[0]-1));
151	150	histCoord[DIM+1]=std::min(biB,static_cast<unsigned int>(nBins[1]-1));

209	208	typedef MultiArray<DIM+1, U> OutType;
210	209	typedef typename OutType::difference_type OutCoord;
211	210
212		// FIXME: crashes on Python3
	211	// FIXME: crashes on Python3
213	212
214	213	HistCoord histShape;
215	214	std::copy(image.shape().begin(), image.shape().end(), histShape.begin());

+1

-1

include/vigra/multi_impex.hxx less more

462	462	inline void
463	463	readVolumeImpl(DestIterator d, Shape const & shape, std::ifstream & s, ArrayVector<T> & buffer, MetaInt<0>)
464	464	{
465		s.read((char)buffer.begin(), shape[0]sizeof(T));
	465	s.read(reinterpret_cast<char>(buffer.begin()), shape[0]sizeof(T));
466	466
467	467	DestIterator dend = d + shape[0];
468	468	int k = 0;

+107

-105

include/vigra/multi_iterator.hxx less more

49	49
50	50	/** \brief Iterate over a virtual array where each element contains its coordinate.
51	51
52		MultiCoordinateIterator behaves like a read-only random access iterator.
	52	MultiCoordinateIterator behaves like a read-only random access iterator.
53	53	It moves accross the given region of interest in scan-order (with the first
54		index changing most rapidly), and dereferencing the iterator returns the
55		coordinate (i.e. multi-dimensional index) of the current array element.
56		The functionality is thus similar to a meshgrid in Matlab or numpy.
57
	54	index changing most rapidly), and dereferencing the iterator returns the
	55	coordinate (i.e. multi-dimensional index) of the current array element.
	56	The functionality is thus similar to a meshgrid in Matlab or numpy.
	57
58	58	Internally, it is just a wrapper of a \ref CoupledScanOrderIterator that
59		has been created without any array and whose reference type is not a
	59	has been created without any array and whose reference type is not a
60	60	\ref CoupledHandle, but the coordinate itself.
61
62		The iterator supports all functions listed in the STL documentation for
	61
	62	The iterator supports all functions listed in the STL documentation for
63	63	<a href="http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random Access Iterators</a>.
64	64
65	65	<b>Usage:</b>
66	66
67	67	<b>\#include</b> \<vigra/multi_iterator.hxx\><br/>
68	68	Namespace: vigra
69
	69
70	70	\code
71	71	MultiCoordinateIterator<3> i(Shape3(3,2,1)), end = i.getEndIterator();
72
	72
73	73	for(; i != end; ++i)
74	74	std::cout << *i << "\n";
75
	75
76	76	// Output:
77	77	// (0, 0, 0)
78	78	// (1, 0, 0)

101	101	typedef typename handle_type::pointer pointer;
102	102	typedef typename handle_type::const_pointer const_pointer;
103	103
104		MultiCoordinateIterator()
	104	MultiCoordinateIterator()
105	105	: base_type(handle_type())
106	106	{}
107	107
108		explicit MultiCoordinateIterator(shape_type const & shape)
	108	explicit MultiCoordinateIterator(shape_type const & shape)
109	109	: base_type(handle_type(shape))
110	110	{}
111	111
112		explicit MultiCoordinateIterator(shape_type const & start, shape_type const & end)
	112	explicit MultiCoordinateIterator(shape_type const & start, shape_type const & end)
113	113	: base_type(handle_type(end))
114	114	{
115	115	this->restrictToSubarray(start, end);
116	116	}
117	117
118	118	template<class DirectedTag>
119		explicit MultiCoordinateIterator(GridGraph<N, DirectedTag> const & g)
	119	explicit MultiCoordinateIterator(GridGraph<N, DirectedTag> const & g)
120	120	: base_type(handle_type(g.shape()))
121	121	{}
122	122
123	123
124	124	template<class DirectedTag>
125		explicit MultiCoordinateIterator(GridGraph<N, DirectedTag> const & g, const typename GridGraph<N, DirectedTag>::Node & node)
	125	explicit MultiCoordinateIterator(GridGraph<N, DirectedTag> const & g, const typename GridGraph<N, DirectedTag>::Node & node)
126	126	: base_type(handle_type(g.shape()))
127	127	{
128	128	if( isInside(g,node))

139	139	{
140	140	return this->template get<0>();
141	141	}
142
	142
143	143	const_reference operator*() const
144	144	{
145	145	return this->template get<0>();
146	146	}
147
	147
148	148	operator value_type() const
149	149	{
150	150	return (this);

154	154	{
155	155	return &this->template get<0>();
156	156	}
157
	157
158	158	const_pointer operator->() const
159	159	{
160	160	return &this->template get<0>();

170	170	base_type::operator++();
171	171	return *this;
172	172	}
173
	173
174	174	MultiCoordinateIterator operator++(int)
175	175	{
176	176	MultiCoordinateIterator res(*this);

242	242	{
243	243	return base_type::operator-(other);
244	244	}
245
	245
246	246	protected:
247		MultiCoordinateIterator(base_type const & base)
	247	MultiCoordinateIterator(base_type const & base)
248	248	: base_type(base)
249	249	{}
250	250	};
251	251
252	252	/** \brief Sequential iterator for MultiArrayView.
253
254		This iterator provides STL-compatible random access iterator functionality for arbitrary
	253
	254	This iterator provides STL-compatible random access iterator functionality for arbitrary
255	255	\ref MultiArrayView instances, regardless of their shapes and strides. The
256		class uses an implementation that minimizes speed penalties that could result from
257		non-trivial strides. The <i>scan-order</i> is defined such that dimensions are iterated
	256	class uses an implementation that minimizes speed penalties that could result from
	257	non-trivial strides. The <i>scan-order</i> is defined such that dimensions are iterated
258	258	from front to back (first to last).
259
260		You normally construct instances of this class by calling \ref MultiArrayView::begin()
261		and \ref MultiArrayView::end().
262
263		The iterator supports all functions listed in the STL documentation for
	259
	260	You normally construct instances of this class by calling \ref MultiArrayView::begin()
	261	and \ref MultiArrayView::end().
	262
	263	The iterator supports all functions listed in the STL documentation for
264	264	<a href="http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random Access Iterators</a>.
265
	265
266	266	<b>\#include</b> \<vigra/multi_iterator.hxx\><br/>
267	267	Namespace: vigra
268	268	*/

286	286	typedef POINTER pointer;
287	287	typedef T const * const_pointer;
288	288
289		StridedScanOrderIterator()
	289	StridedScanOrderIterator()
290	290	: base_type()
291	291	{}
292	292
293	293	template <class S>
294		explicit StridedScanOrderIterator(MultiArrayView<N, T, S> const & view)
	294	explicit StridedScanOrderIterator(MultiArrayView<N, T, S> const & view)
295	295	: base_type(createCoupledIterator(view))
296	296	{}
297	297
298		StridedScanOrderIterator(POINTER p, shape_type const & shape, shape_type const & strides)
	298	StridedScanOrderIterator(POINTER p, shape_type const & shape, shape_type const & strides)
299	299	: base_type(createCoupledIterator(MultiArrayView<N, T, StridedArrayTag>(shape, strides, const_cast<T *>(p))))
300	300	{}
301	301
302		StridedScanOrderIterator(handle_type const & handle)
	302	StridedScanOrderIterator(handle_type const & handle)
303	303	: base_type(handle)
304	304	{}
305	305

307	307	{
308	308	return this->template get<1>();
309	309	}
310
	310
311	311	const_reference operator*() const
312	312	{
313	313	return this->template get<1>();

317	317	{
318	318	return &this->template get<1>();
319	319	}
320
	320
321	321	const_pointer operator->() const
322	322	{
323	323	return &this->template get<1>();

348	348	base_type::operator++();
349	349	return *this;
350	350	}
351
	351
352	352	StridedScanOrderIterator operator++(int)
353	353	{
354	354	StridedScanOrderIterator res(*this);

420	420	{
421	421	return StridedScanOrderIterator(*this) -= coordOffset;
422	422	}
423
	423
424	424	MultiArrayIndex index() const
425	425	{
426	426	return this->scanOrderIndex();
427	427	}
428	428
429		StridedScanOrderIterator &
	429	StridedScanOrderIterator &
430	430	restrictToSubarray(shape_type const & start, shape_type const & stop)
431	431	{
432	432	base_type::restrictToSubarray(start, stop);
433	433	return *this;
434	434	}
435
	435
436	436	protected:
437		StridedScanOrderIterator(base_type const & base)
	437	StridedScanOrderIterator(base_type const & base)
438	438	: base_type(base)
439	439	{}
440	440	};

462	462
463	463	<p>
464	464	The Multidimensional Iterator concept allows navigation on arrays
465		of arbitrary dimension. It provides two modes of iteration:
	465	of arbitrary dimension. It provides two modes of iteration:
466	466	<em>direct traversal</em>, and <em>hierarchical traversal</em>.
467		In general, hierarchical traversal will be faster, while only
	467	In general, hierarchical traversal will be faster, while only
468	468	direct traversal allows for true random access in all dimensions.
469	469	Via the <tt>dim<K>()</tt> function, operations applying to a particular
470	470	dimension can be used in the direct traversal mode. In contrast,

584	584	navigation functions referring to a particular dimension.<br>
585	585	Example (assuming <tt>i, j</tt> are 3-dimensional):<br>
586	586	\code
587		i.dim<0>()++; // increment dimension 0
588		i.dim<1>()++; // increment dimension 1
589		i.dim<2>()++; // increment dimension 2
590
	587	i.dim<0>()++; // increment dimension 0
	588	i.dim<1>()++; // increment dimension 1
	589	i.dim<2>()++; // increment dimension 2
	590
591	591	j += MultiIterator::multi_difference_type(1,1,1); // same effect
592	592	\endcode
593	593	</td>

604	604	Note that it is impossible to support an <tt>operator-</tt> between two iterators which returns
605	605	a <tt>MultiIterator::multi_difference_type</tt> because it is impossible to decide to which
606	606	dimension a difference applies. Consider for example, a 2-dimensional iterator <tt>i</tt>, and
607		let <tt>j = i + multi_difference_type(width, 0)</tt>, <tt>k = i + multi_difference_type(0,1)</tt>,
608		where <tt>width</tt> is the array's total width. In general, <tt>j</tt> and <tt>k</tt> point to
	607	let <tt>j = i + multi_difference_type(width, 0)</tt>, <tt>k = i + multi_difference_type(0,1)</tt>,
	608	where <tt>width</tt> is the array's total width. In general, <tt>j</tt> and <tt>k</tt> point to
609	609	the same memory location, so that the two cases cannot easily be distinguished (it is possible,
610		but iterator performance will suffer significantly, as is experienced with
	610	but iterator performance will suffer significantly, as is experienced with
611	611	\ref vigra::ImageIterator where differencing is allowed).
612	612	</p>
613	613

686	686	</tr>
687	687	<tr>
688	688	<td><tt>i.begin()</tt></td><td><tt>next_type</tt></td>
689		<td>create the hierarchical iterator pointing to the first element in the
	689	<td>create the hierarchical iterator pointing to the first element in the
690	690	next lower dimension.<br>
691	691	<em>Note:</em> The result of this operation is undefined if the iterator
692	692	doesn't point to element 0 in all dimensions below its current dimension.<br>

705	705	}
706	706	}
707	707	}
708
	708
709	709	\endcode
710	710	</td>
711	711	</tr>
712	712	<tr>
713	713	<td><tt>i.end()</tt></td><td><tt>next_type</tt></td>
714		<td>create the hierarchical iterator pointing to the past-the-end location in the
	714	<td>create the hierarchical iterator pointing to the past-the-end location in the
715	715	next lower dimension.<br>
716	716	<em>Note:</em> The result of this operation is undefined if the iterator
717	717	doesn't point to element 0 in all dimensions below its current dimension.</td>

726	726
727	727	*/
728	728
729		/** \addtogroup MultiIteratorGroup
	729	/** \addtogroup MultiIteratorGroup
730	730	*/
731	731	//@{
732	732

943	943
944	944	protected:
945	945
946		difference_type
	946	difference_type
947	947	total_stride(typename multi_difference_type::const_iterator d) const
948	948	{
949	949	return d[level];

1124	1124
1125	1125	protected:
1126	1126
1127		difference_type
	1127	difference_type
1128	1128	total_stride(typename multi_difference_type::const_iterator d) const
1129	1129	{
1130	1130	return d[level]*m_stride[level] + base_type::total_stride(d);

1137	1137	/* */
1138	1138	/********************************************************/
1139	1139
1140		/** \brief A multi-dimensional hierarchical iterator to be used with
	1140	/** \brief A multi-dimensional hierarchical iterator to be used with
1141	1141	\ref vigra::MultiArrayView if it is not strided.
1142	1142
1143	1143	See \ref MultiIteratorPage for further documentation.

1146	1146	Namespace: vigra
1147	1147	*/
1148	1148	template <unsigned int N, class T, class REFERENCE, class POINTER>
1149		class MultiIterator
	1149	class MultiIterator
1150	1150	#ifndef DOXYGEN // doxygen doesn't understand this inheritance
1151	1151	: public MultiIterator<N-1, T, REFERENCE, POINTER>
1152	1152	#endif

1156	1156	/** the type of the parent in the inheritance hierarchy.
1157	1157	*/
1158	1158	typedef MultiIterator<N-1, T, REFERENCE, POINTER> base_type;
1159
	1159
1160	1160	/** the iterator's level in the dimension hierarchy
1161	1161	*/
1162	1162	enum { level = N-1 };

1181	1181	*/
1182	1182	typedef const value_type *const_pointer;
1183	1183
1184		/** multi difference type
	1184	/** multi difference type
1185	1185	(used for offsetting along all axes simultaneously)
1186	1186	*/
1187	1187	typedef typename MultiArrayShape<N>::type multi_difference_type;
1188
	1188
1189	1189	/** difference type (used for offsetting)
1190	1190	*/
1191	1191	#ifndef DOXYGEN

1209	1209	/** the iterator tag (image traverser)
1210	1210	*/
1211	1211	typedef multi_dimensional_traverser_tag iterator_category;
1212
	1212
1213	1213	/* use default copy constructor and assignment operator */
1214	1214
1215	1215	/** default constructor.

1372	1372	/** greater than.
1373	1373	*/
1374	1374	bool operator> (const MultiIterator &rhs) const;
1375
	1375
1376	1376	/** greater or equal.
1377	1377	*/
1378	1378	bool operator>= (const MultiIterator &rhs) const;
1379	1379	#endif
1380	1380
1381		/** access the array element at the given offset in
	1381	/** access the array element at the given offset in
1382	1382	the current dimension.
1383	1383	*/
1384	1384	reference operator[] (difference_type n) const

1393	1393	return this->m_ptr [total_stride(d.begin())];
1394	1394	}
1395	1395
1396		/** Return the (N-1)-dimensional multi-iterator that points to
1397		the first (N-1)-dimensional subarray of the
	1396	/** Return the (N-1)-dimensional multi-iterator that points to
	1397	the first (N-1)-dimensional subarray of the
1398	1398	N-dimensional array this iterator is referring to.
1399	1399	The result is only valid if this iterator refers to location
1400	1400	0 in <em>all</em> dimensions below its current dimension N,

1416	1416	return *this;
1417	1417	}
1418	1418
1419		/** Return the (N-1)-dimensional multi-iterator that points beyond
1420		the last (N-1)-dimensional subarray of the
	1419	/** Return the (N-1)-dimensional multi-iterator that points beyond
	1420	the last (N-1)-dimensional subarray of the
1421	1421	N-dimensional array this iterator is referring to.
1422	1422	The result is only valid if this iterator refers to location
1423	1423	0 in <em>all</em> dimensions below its current dimension N,

1444	1444	{
1445	1445	// go down the current column starting at the location of 'outer'
1446	1446	}
1447		\endcode
	1447	\endcode
1448	1448	*/
1449	1449	iterator iteratorForDimension(unsigned int d) const
1450	1450	{

1454	1454	}
1455	1455	/** Return the multi-iterator that operates on dimension K in order
1456	1456	to manipulate this dimension directly. Usage:
1457
	1457
1458	1458	\code
1459
	1459
1460	1460	MultiIterator<3, int> i3 = ...;
1461
	1461
1462	1462	i3.template dim<2>()++; // increment outer dimension
1463	1463	i3.template dim<0>()++; // increment inner dimension
1464	1464	\endcode
1465
	1465
1466	1466	For convenience, the same functionality is also available
1467	1467	as <tt>dim0()</tt>, <tt>dim1()</tt> etc. up to <tt>dim4()</tt>:
1468
	1468
1469	1469	\code
1470
	1470
1471	1471	MultiIterator<3, int> i3 = ...;
1472
	1472
1473	1473	i3.dim2()++; // increment outer dimension
1474	1474	i3.dim0()++; // increment inner dimension
1475		\endcode
	1475	\endcode
1476	1476	*/
1477	1477	template <unsigned int K>
1478	1478	MultiIterator<K+1, T, REFERENCE, POINTER> &

1494	1494
1495	1495	protected:
1496	1496
1497		difference_type
	1497	difference_type
1498	1498	total_stride(typename multi_difference_type::const_iterator d) const
1499	1499	{
1500	1500	return d[level]*this->m_stride[level] + base_type::total_stride(d);

1706	1706
1707	1707	protected:
1708	1708
1709		difference_type
	1709	difference_type
1710	1710	total_stride(typename multi_difference_type::const_iterator d) const
1711	1711	{
1712	1712	return d[level] * m_stride;

1887	1887
1888	1888	protected:
1889	1889
1890		difference_type
	1890	difference_type
1891	1891	total_stride(typename multi_difference_type::const_iterator d) const
1892	1892	{
1893	1893	return d[level]*m_stride[level] + base_type::total_stride(d);

1900	1900	/* */
1901	1901	/********************************************************/
1902	1902
1903		/** \brief A multi-dimensional hierarchical iterator to be used with
	1903	/** \brief A multi-dimensional hierarchical iterator to be used with
1904	1904	\ref vigra::MultiArrayView if it is not strided.
1905	1905
1906	1906	See \ref MultiIteratorPage for further documentation.

1909	1909	Namespace: vigra
1910	1910	*/
1911	1911	template <unsigned int N, class T, class REFERENCE, class POINTER>
1912		class StridedMultiIterator
	1912	class StridedMultiIterator
1913	1913	#ifndef DOXYGEN // doxygen doesn't understand this inheritance
1914	1914	: public StridedMultiIterator<N-1, T, REFERENCE, POINTER>
1915	1915	#endif

1919	1919	/** the type of the parent in the inheritance hierarchy.
1920	1920	*/
1921	1921	typedef StridedMultiIterator<N-1, T, REFERENCE, POINTER> base_type;
1922
	1922
1923	1923	/** the iterator's level in the dimension hierarchy
1924	1924	*/
1925	1925	enum { level = N-1 };

1944	1944	*/
1945	1945	typedef const value_type *const_pointer;
1946	1946
1947		/** multi difference type
	1947	/** multi difference type
1948	1948	(used for offsetting along all axes simultaneously)
1949	1949	*/
1950	1950	typedef typename MultiArrayShape<N>::type multi_difference_type;

1958	1958	#else
1959	1959	typedef MultiArrayIndex difference_type;
1960	1960	#endif
1961
	1961
1962	1962	/** the StridedMultiIterator for the next lower dimension.
1963	1963	*/
1964	1964	typedef base_type next_type;

1971	1971	/** the iterator tag (image traverser)
1972	1972	*/
1973	1973	typedef multi_dimensional_traverser_tag iterator_category;
1974
	1974
1975	1975	/* use default copy constructor and assignment operator */
1976	1976
1977	1977	/** default constructor.

2134	2134	/** greater than.
2135	2135	*/
2136	2136	bool operator> (const StridedMultiIterator &rhs) const;
2137
	2137
2138	2138	/** greater or equal.
2139	2139	*/
2140	2140	bool operator>= (const StridedMultiIterator &rhs) const;
2141	2141	#endif
2142	2142
2143		/** access the array element at the given offset in
	2143	/** access the array element at the given offset in
2144	2144	the current dimension.
2145	2145	*/
2146	2146	reference operator[] (difference_type n) const

2155	2155	return this->m_ptr [total_stride(d.begin())];
2156	2156	}
2157	2157
2158		/** Return the (N-1)-dimensional multi-iterator that points to
2159		the first (N-1)-dimensional subarray of the
	2158	/** Return the (N-1)-dimensional multi-iterator that points to
	2159	the first (N-1)-dimensional subarray of the
2160	2160	N-dimensional array this iterator is referring to.
2161	2161	The result is only valid if this iterator refers to location
2162	2162	0 in <em>all</em> dimensions below its current dimension N,

2178	2178	return *this;
2179	2179	}
2180	2180
2181		/** Return the (N-1)-dimensional multi-iterator that points beyond
2182		the last (N-1)-dimensional subarray of the
	2181	/** Return the (N-1)-dimensional multi-iterator that points beyond
	2182	the last (N-1)-dimensional subarray of the
2183	2183	N-dimensional array this iterator is referring to.
2184	2184	The result is only valid if this iterator refers to location
2185	2185	0 in <em>all</em> dimensions below its current dimension N,

2206	2206	{
2207	2207	// go down the current column starting at the location of 'outer'
2208	2208	}
2209		\endcode
	2209	\endcode
2210	2210	*/
2211	2211	iterator iteratorForDimension(unsigned int d) const
2212	2212	{

2216	2216	}
2217	2217	/** Return the multi-iterator that operates on dimension K in order
2218	2218	to manipulate this dimension directly. Usage:
2219
	2219
2220	2220	\code
2221
	2221
2222	2222	StridedMultiIterator<3, int> i3 = ...;
2223
	2223
2224	2224	i3.template dim<2>()++; // increment outer dimension
2225	2225	i3.template dim<0>()++; // increment inner dimension
2226	2226	\endcode
2227
	2227
2228	2228	For convenience, the same functionality is also available
2229	2229	as <tt>dim0()</tt>, <tt>dim1()</tt> etc. up to <tt>dim4()</tt>:
2230
	2230
2231	2231	\code
2232
	2232
2233	2233	StridedMultiIterator<3, int> i3 = ...;
2234
	2234
2235	2235	i3.dim2()++; // increment outer dimension
2236	2236	i3.dim0()++; // increment inner dimension
2237		\endcode
	2237	\endcode
2238	2238	*/
2239	2239	template <unsigned int K>
2240	2240	StridedMultiIterator<K+1, T, REFERENCE, POINTER> &

2256	2256
2257	2257	protected:
2258	2258
2259		difference_type
	2259	difference_type
2260	2260	total_stride(typename multi_difference_type::const_iterator d) const
2261	2261	{
2262	2262	return d[level]*this->m_stride[level] + base_type::total_stride(d);

2270	2270
2271	2271	namespace std {
2272	2272
	2273	// output the current coordinate of the iterator
	2274	// (note: this also works when the iterator is an end-iterator)
2273	2275	template <unsigned int N, class T, class REFERENCE, class POINTER>
2274	2276	ostream & operator<<(ostream & o, vigra::StridedScanOrderIterator<N, T, REFERENCE, POINTER> const & i)
2275	2277	{
2276		o << *i;
	2278	o << i.point();
2277	2279	return o;
2278	2280	}
2279	2281

+1

-1

include/vigra/multi_labeling.hxx less more

85	85	return equal(u_data, v_data, diff);
86	86	}
87	87	template <class Equal, class Data, class Shape>
88		bool callEqualImpl(Equal& equal, const Data& u_data, const Data& v_data, const Shape& diff, VigraFalseType)
	88	bool callEqualImpl(Equal& equal, const Data& u_data, const Data& v_data, const Shape&, VigraFalseType)
89	89	{
90	90	return equal(u_data, v_data);
91	91	}

+1

-1

include/vigra/multi_localminmax.hxx less more

51	51	template<class G>
52	52	struct NodeAtBorder{
53	53	template<class NODE_ITER>
54		static bool atBorder(const NODE_ITER & node ){
	54	static bool atBorder(const NODE_ITER &){
55	55	return false;
56	56	}
57	57	};

+65

-112

include/vigra/multi_math.hxx less more

43	43
44	44	namespace vigra {
45	45
46		/** \defgroup MultiMathModule vigra::multi_math
47
48		Namespace <tt>vigra::multi_math</tt> holds VIGRA's support for efficient arithmetic and algebraic functions on multi-dimensional arrays (that is, \ref MultiArrayView and its subclasses). All <tt>multi_math</tt> functions operate element-wise. If you need matrix multiplication, use \ref LinearAlgebraModule instead.
49
50		In order to avoid overload ambiguities, multi-array arithmetic must be explicitly activated by
51		\code
52		using namespace vigra::multi_math;
53		\endcode
54		(this should not be done globally, but only in the scope where the functionality is actually used).
55
56		You can then use the standard operators in the expected way:
57		\code
58		MultiArray<2, float> i(Shape2(100, 100)), j(Shape2(100, 100));
59
60		MultiArray<2, float> h = i + 4.0 * j;
61		h += (i.transpose() - j) / 2.0;
62		\endcode
63		etc. (supported operators are <tt>+ - * / ! ~ % && \|\| == != < <= > >= << >> & \| ^ = += -= *= /=</tt>, with both scalar and array arguments).
64
65		Algebraic functions are available as well:
66		\code
67		h = exp(-(sq(i) + sq(j)));
68		h *= atan2(-i, j);
69		\endcode
70		The following functions are implemented: <tt>abs, erf, even, odd, sign, signi, round, roundi, sqrt, sqrti, sq,
71		norm, squaredNorm, gamma, loggamma, exp, log, log10, sin, sin_pi, cos, cos_pi, asin, acos, tan, atan,
72		floor, ceil, conj, real, imag, arg, atan2, pow, fmod, min, max</tt>,
73		provided the array's element type supports the respective function.
74
75		Supported element types currently include the built-in numeric types, \ref TinyVector, \ref RGBValue,
76		<tt>std::complex</tt>, and \ref FFTWComplex.
77
78		In addition, <tt>multi_math</tt> supports a number of functions that reduce arrays to scalars:
79		\code
80		double s = sum<double>(i); // compute the sum of the elements, using 'double' as accumulator type
81		double p = product<double>(abs(i)); // compute the product of the elements' absolute values
82
83		bool a = any(i < 0.0); // check if any element of i is negative
84		bool b = all(i > 0.0); // check if all elements of i are positive
85		\endcode
86
87		Expressions are expanded so that no temporary arrays have to be created. To optimize cache locality,
88		loops are executed in the stride ordering of the left-hand-side array.
89
90		<b>\#include</b> \<vigra/multi_math.hxx\>
91
92		Namespace: vigra::multi_math
93		*/
	46	// namespace documentation is in multi_array.hxx
94	47	namespace multi_math {
95	48
96	49	template <class ARG>
97	50	struct MultiMathOperand
98	51	{
99	52	typedef typename ARG::result_type result_type;
100
	53
101	54	static const int ndim = ARG::ndim;
102
	55
103	56	MultiMathOperand(ARG const & a)
104	57	: arg_(a)
105	58	{}
106
	59
107	60	// Check if all arrays involved in the expression have compatible shapes
108	61	// (including transparent expansion of singleton axes).
109		// 's' is the shape of the LHS array. If 's' is zero (i.e. the LHS is
	62	// 's' is the shape of the LHS array. If 's' is zero (i.e. the LHS is
110	63	// not yet initialized), it is set to the maximal RHS shape.
111	64	//
112	65	template <class SHAPE>

114	67	{
115	68	return arg_.checkShape(s);
116	69	}
117
	70
118	71	// increment the pointer of all RHS arrays along the given 'axis'
119	72	void inc(unsigned int axis) const
120	73	{
121	74	arg_.inc(axis);
122	75	}
123
	76
124	77	// reset the pointer of all RHS arrays along the given 'axis'
125	78	void reset(unsigned int axis) const
126	79	{
127	80	arg_.reset(axis);
128	81	}
129
	82
130	83	// get the value of the expression at the current pointer location
131	84	result_type operator*() const
132	85	{
133	86	return *arg_;
134	87	}
135
	88
136	89	// get the value of the expression at an offset of the current pointer location
137	90	template <class SHAPE>
138	91	result_type operator[](SHAPE const & s) const
139	92	{
140	93	return arg_[s];
141	94	}
142
	95
143	96	ARG arg_;
144	97	};
145	98
146	99	template <unsigned int N, class T, class C>
147	100	struct MultiMathOperand<MultiArrayView<N, T, C> >
148	101	{
149		typedef MultiMathOperand AllowOverload;
	102	typedef MultiMathOperand AllowOverload;
150	103	typedef typename MultiArrayShape<N>::type Shape;
151	104
152	105	typedef T result_type;
153
	106
154	107	static const int ndim = (int)N;
155
	108
156	109	MultiMathOperand(MultiArrayView<N, T, C> const & a)
157	110	: p_(a.data()),
158	111	shape_(a.shape()),

163	116	if(shape_[k] == 1)
164	117	strides_[k] = 0;
165	118	}
166
	119
167	120	bool checkShape(Shape & s) const
168	121	{
169	122	// support:

186	139	}
187	140	return true;
188	141	}
189
	142
190	143	T const & operator[](Shape const & s) const
191	144	{
192	145	return p_[dot(s, strides_)];
193	146	}
194
	147
195	148	void inc(unsigned int axis) const
196	149	{
197	150	p_ += strides_[axis];
198	151	}
199
	152
200	153	void reset(unsigned int axis) const
201	154	{
202	155	p_ -= shape_[axis]*strides_[axis];
203	156	}
204
	157
205	158	result_type operator*() const
206	159	{
207	160	return *p_;
208	161	}
209
	162
210	163	mutable T const * p_;
211	164	Shape shape_, strides_;
212	165	};

216	169	: public MultiMathOperand<MultiArrayView<N, T, UnstridedArrayTag> >
217	170	{
218	171	typedef MultiMathOperand AllowOverload;
219
	172
220	173	MultiMathOperand(MultiArray<N, T, A> const & a)
221	174	: MultiMathOperand<MultiArrayView<N, T, UnstridedArrayTag> >(a)
222	175	{}

227	180	{
228	181	typedef MultiMathOperand<T> AllowOverload;
229	182	typedef T result_type;
230
	183
231	184	static const int ndim = 0;
232
	185
233	186	MultiMathScalarOperand(T const & v)
234	187	: v_(v)
235	188	{}
236
	189
237	190	template <class SHAPE>
238	191	bool checkShape(SHAPE const &) const
239	192	{
240	193	return true;
241	194	}
242
	195
243	196	template <class SHAPE>
244	197	T const & operator[](SHAPE const &) const
245	198	{
246	199	return v_;
247	200	}
248
	201
249	202	void inc(unsigned int /* axis */) const
250	203	{}
251
	204
252	205	void reset(unsigned int /* axis */) const
253	206	{}
254
	207
255	208	T const & operator*() const
256	209	{
257	210	return v_;
258	211	}
259
	212
260	213	T v_;
261	214	};
262	215

303	256	struct MultiMathUnaryOperator
304	257	{
305	258	typedef typename F::template Result<typename O::result_type>::type result_type;
306
	259
307	260	static const int ndim = O::ndim;
308
	261
309	262	MultiMathUnaryOperator(O const & o)
310	263	: o_(o)
311	264	{}
312
	265
313	266	template <class SHAPE>
314	267	bool checkShape(SHAPE & s) const
315	268	{
316	269	return o_.checkShape(s);
317	270	}
318
	271
319	272	//
320	273	void inc(unsigned int axis) const
321	274	{
322	275	o_.inc(axis);
323	276	}
324
	277
325	278	void reset(unsigned int axis) const
326	279	{
327	280	o_.reset(axis);
328	281	}
329
	282
330	283	template <class POINT>
331	284	result_type operator[](POINT const & p) const
332	285	{
333	286	return f_(o_[p]);
334	287	}
335
	288
336	289	result_type operator*() const
337	290	{
338	291	return f_(*o_);
339	292	}
340
	293
341	294	O o_;
342	295	F f_;
343	296	};

416	369	VIGRA_MULTIMATH_UNARY_OPERATOR(Sqrti, vigra::sqrti, sqrti, T)
417	370	VIGRA_MULTIMATH_UNARY_OPERATOR(Sq, vigra::sq, sq, typename NumericTraits<T>::Promote)
418	371	VIGRA_MULTIMATH_UNARY_OPERATOR(Norm, vigra::norm, norm, typename NormTraits<T>::NormType)
419		VIGRA_MULTIMATH_UNARY_OPERATOR(SquaredNorm, vigra::squaredNorm, squaredNorm,
	372	VIGRA_MULTIMATH_UNARY_OPERATOR(SquaredNorm, vigra::squaredNorm, squaredNorm,
420	373	typename NormTraits<T>::SquaredNormType)
421	374	VIGRA_MULTIMATH_UNARY_OPERATOR(Sin_pi, vigra::sin_pi, sin_pi, VIGRA_REALPROMOTE)
422	375	VIGRA_MULTIMATH_UNARY_OPERATOR(Cos_pi, vigra::cos_pi, cos_pi, VIGRA_REALPROMOTE)

456	409	{
457	410	typedef typename F::template Result<typename O1::result_type,
458	411	typename O2::result_type>::type result_type;
459
	412
460	413	static const int ndim = O1::ndim > O2::ndim ? O1::ndim : O2::ndim;
461
	414
462	415	MultiMathBinaryOperator(O1 const & o1, O2 const & o2)
463	416	: o1_(o1),
464	417	o2_(o2)
465	418	{}
466
	419
467	420	template <class SHAPE>
468	421	bool checkShape(SHAPE & s) const
469	422	{
470	423	return o1_.checkShape(s) && o2_.checkShape(s);
471	424	}
472
	425
473	426	template <class POINT>
474	427	result_type operator[](POINT const & p) const
475	428	{
476	429	return f_(o1_[p], o2_[p]);
477	430	}
478
	431
479	432	void inc(unsigned int axis) const
480	433	{
481	434	o1_.inc(axis);
482	435	o2_.inc(axis);
483	436	}
484
	437
485	438	void reset(unsigned int axis) const
486	439	{
487	440	o1_.reset(axis);
488	441	o2_.reset(axis);
489	442	}
490
	443
491	444	result_type operator*() const
492	445	{
493	446	return f_(o1_, o2_);
494	447	}
495
	448
496	449	O1 o1_;
497	450	O2 o2_;
498	451	F f_;

501	454
502	455	// In the sequel, the nested type 'MultiMathOperand<T>::AllowOverload'
503	456	// ensures that template functions only participate in overload
504		// resolution when this type is defined, i.e. when T is a number
	457	// resolution when this type is defined, i.e. when T is a number
505	458	// or array type. It thus prevents 'ambiguous overload' errors.
506	459	//
507	460	#define VIGRA_MULTIMATH_BINARY_OPERATOR(NAME, FCT, OPNAME, SEP, RESTYPE) \

675	628
676	629	// We pass 'strideOrder' to the recursion in order to make sure
677	630	// that the inner loop iterates over the output's major axis.
678		// Of course, this does not help when the RHS arrays are ordered
	631	// Of course, this does not help when the RHS arrays are ordered
679	632	// differently -- maybe it is better to find the most common order
680	633	// among all arguments (both RHS and LHS)?
681	634	//

683	636	struct MultiMathExec
684	637	{
685	638	enum { LEVEL = N-1 };
686
	639
687	640	template <class T, class Shape, class Expression>
688		static void exec(T * data, Shape const & shape, Shape const & strides,
	641	static void exec(T * data, Shape const & shape, Shape const & strides,
689	642	Shape const & strideOrder, Expression const & e)
690	643	{
691	644	MultiArrayIndex axis = strideOrder[LEVEL];

702	655	struct MultiMathExec<1, Assign>
703	656	{
704	657	enum { LEVEL = 0 };
705
	658
706	659	template <class T, class Shape, class Expression>
707		static void exec(T * data, Shape const & shape, Shape const & strides,
	660	static void exec(T * data, Shape const & shape, Shape const & strides,
708	661	Shape const & strideOrder, Expression const & e)
709	662	{
710	663	MultiArrayIndex axis = strideOrder[LEVEL];

766	719	struct MultiMathReduce
767	720	{
768	721	enum { LEVEL = N-1 };
769
	722
770	723	template <class T, class Shape, class Expression>
771	724	static void exec(T & t, Shape const & shape, Expression const & e)
772	725	{

782	735	struct MultiMathReduce<1, Assign>
783	736	{
784	737	enum { LEVEL = 0 };
785
	738
786	739	template <class T, class Shape, class Expression>
787	740	static void exec(T & t, Shape const & shape, Expression const & e)
788	741	{

817	770
818	771	template <class U, class T>
819	772	U
820		sum(MultiMathOperand<T> const & v, U res = NumericTraits<U>::zero())
821		{
	773	sum(MultiMathOperand<T> const & v, U res = NumericTraits<U>::zero())
	774	{
822	775	static const int ndim = MultiMathOperand<T>::ndim;
823	776	typename MultiArrayShape<ndim>::type shape;
824	777	v.checkShape(shape);

828	781
829	782	template <class U, unsigned int N, class T, class S>
830	783	U
831		sum(MultiArrayView<N, T, S> const & v, U res = NumericTraits<U>::zero())
832		{
	784	sum(MultiArrayView<N, T, S> const & v, U res = NumericTraits<U>::zero())
	785	{
833	786	return v.template sum<U>() + res;
834	787	}
835	788
836	789	template <class U, class T>
837	790	U
838		product(MultiMathOperand<T> const & v, U res = NumericTraits<U>::one())
839		{
	791	product(MultiMathOperand<T> const & v, U res = NumericTraits<U>::one())
	792	{
840	793	static const int ndim = MultiMathOperand<T>::ndim;
841	794	typename MultiArrayShape<ndim>::type shape;
842	795	v.checkShape(shape);

846	799
847	800	template <class U, unsigned int N, class T, class S>
848	801	U
849		product(MultiArrayView<N, T, S> const & v, U res = NumericTraits<U>::one())
850		{
	802	product(MultiArrayView<N, T, S> const & v, U res = NumericTraits<U>::one())
	803	{
851	804	return v.template product<U>() * res;
852	805	}
853	806
854	807	template <class T>
855	808	bool
856		all(MultiMathOperand<T> const & v)
857		{
	809	all(MultiMathOperand<T> const & v)
	810	{
858	811	static const int ndim = MultiMathOperand<T>::ndim;
859	812	typename MultiArrayShape<ndim>::type shape;
860	813	v.checkShape(shape);

865	818
866	819	template <class T>
867	820	bool
868		any(MultiMathOperand<T> const & v)
869		{
	821	any(MultiMathOperand<T> const & v)
	822	{
870	823	static const int ndim = MultiMathOperand<T>::ndim;
871	824	typename MultiArrayShape<ndim>::type shape;
872	825	v.checkShape(shape);

+2

-2

include/vigra/multi_morphology.hxx less more

123	123	template <class SrcIterator, class SrcShape, class SrcAccessor,
124	124	class DestIterator, class DestAccessor>
125	125	static void
126		exec( SrcIterator s, SrcShape const & shape, SrcAccessor src,
127		DestIterator d, DestAccessor dest, double radius, bool dilation)
	126	exec( SrcIterator /s/, SrcShape const & /shape/, SrcAccessor /src/,
	127	DestIterator /d/, DestAccessor /dest/, double /radius/, bool /dilation/)
128	128	{
129	129	vigra_fail("multiBinaryMorphology(): Internal error (this function should never be called).");
130	130	}

+1

-1

include/vigra/multi_pointoperators.hxx less more

614	614	copyMultiArray(MultiArrayView<N, T1, S1> const & source,
615	615	MultiArrayView<N, T2, S2> dest)
616	616	{
617		for(int k=0; k<N; ++k)
	617	for(unsigned k=0; k<N; ++k)
618	618	vigra_precondition(source.shape(k) == dest.shape(k) \|\| source.shape(k) == 1 \|\| 1 == dest.shape(k),
619	619	"copyMultiArray(): shape mismatch between input and output.");
620	620	if(source.shape() == dest.shape())

+17

-17

include/vigra/multi_resize.hxx less more

50	50	void
51	51	internalResizeMultiArrayOneDimension(
52	52	SrcIterator si, Shape const & sshape, SrcAccessor src,
53		DestIterator di, Shape const & dshape, DestAccessor dest,
	53	DestIterator di, Shape const & dshape, DestAccessor dest,
54	54	Kernel const & spline, unsigned int d)
55	55	{
56	56	enum { N = 1 + SrcIterator::level };

62	62
63	63	SNavigator snav( si, sshape, d );
64	64	DNavigator dnav( di, dshape, d );
65
	65
66	66	int ssize = sshape[d];
67	67	int dsize = dshape[d];
68	68

74	74	Rational<int> offset(0);
75	75	resampling_detail::MapTargetToSourceCoordinate mapCoordinate(ratio, offset);
76	76	int period = lcm(ratio.numerator(), ratio.denominator());
77
	77
78	78	ArrayVector<double> const & prefilterCoeffs = spline.prefilterCoefficients();
79	79	ArrayVector<Kernel1D<double> > kernels(period);
80	80	createResamplingKernels(spline, mapCoordinate, kernels);

83	83	ArrayVector<TmpType> tmp( ssize );
84	84	typename ArrayVector<TmpType>::iterator t = tmp.begin(), tend = tmp.end();
85	85	typename AccessorTraits<TmpType>::default_accessor ta;
86
	86
87	87	for( ; snav.hasMore(); snav++, dnav++ )
88	88	{
89	89	// first copy source to temp for maximum cache efficiency

102	102
103	103	} // namespace detail
104	104
105		/** \addtogroup GeometricTransformations Geometric Transformations
	105	/** \addtogroup GeometricTransformations
106	106	*/
107	107	//@{
108	108

121	121	\code
122	122	namespace vigra {
123	123	template <unsigned int N, class T1, class S1,
124		class T2, class S2,
	124	class T2, class S2,
125	125	class Kernel = BSpline<3, double> >
126	126	void
127	127	resizeMultiArraySplineInterpolation(MultiArrayView<N, T1, S1> const & source,

224	224	doxygen_overloaded_function(template <...> void resizeMultiArraySplineInterpolation)
225	225
226	226	template <class SrcIterator, class Shape, class SrcAccessor,
227		class DestIterator, class DestAccessor,
	227	class DestIterator, class DestAccessor,
228	228	class Kernel>
229	229	void
230	230	resizeMultiArraySplineInterpolation(
231	231	SrcIterator si, Shape const & sshape, SrcAccessor src,
232		DestIterator di, Shape const & dshape, DestAccessor dest,
	232	DestIterator di, Shape const & dshape, DestAccessor dest,
233	233	Kernel const & spline)
234	234	{
235	235	enum { N = 1 + SrcIterator::level };
236	236	typedef typename NumericTraits<typename DestAccessor::value_type>::RealPromote TmpType;
237	237	typedef typename AccessorTraits<TmpType>::default_accessor TmpAccessor;
238
	238
239	239	if(N==1)
240	240	{
241		detail::internalResizeMultiArrayOneDimension(si, sshape, src,
	241	detail::internalResizeMultiArrayOneDimension(si, sshape, src,
242	242	di, dshape, dest, spline, 0);
243	243	}
244	244	else

248	248	tmpShape[d] = dshape[d];
249	249	MultiArray<N, TmpType> tmp(tmpShape);
250	250	TmpAccessor ta;
251
252		detail::internalResizeMultiArrayOneDimension(si, sshape, src,
	251
	252	detail::internalResizeMultiArrayOneDimension(si, sshape, src,
253	253	tmp.traverser_begin(), tmpShape, ta, spline, d);
254	254	d = 1;
255	255	for(; d<N-1; ++d)
256	256	{
257	257	tmpShape[d] = dshape[d];
258	258	MultiArray<N, TmpType> dtmp(tmpShape);
259
260		detail::internalResizeMultiArrayOneDimension(tmp.traverser_begin(), tmp.shape(), ta,
	259
	260	detail::internalResizeMultiArrayOneDimension(tmp.traverser_begin(), tmp.shape(), ta,
261	261	dtmp.traverser_begin(), tmpShape, ta, spline, d);
262	262	dtmp.swap(tmp);
263	263	}
264		detail::internalResizeMultiArrayOneDimension(tmp.traverser_begin(), tmp.shape(), ta,
	264	detail::internalResizeMultiArrayOneDimension(tmp.traverser_begin(), tmp.shape(), ta,
265	265	di, dshape, dest, spline, d);
266	266	}
267	267	}

277	277	}
278	278
279	279	template <class SrcIterator, class Shape, class SrcAccessor,
280		class DestIterator, class DestAccessor,
	280	class DestIterator, class DestAccessor,
281	281	class Kernel>
282	282	inline void
283	283	resizeMultiArraySplineInterpolation(triple<SrcIterator, Shape, SrcAccessor> src,

299	299	}
300	300
301	301	template <unsigned int N, class T1, class S1,
302		class T2, class S2,
	302	class T2, class S2,
303	303	class Kernel>
304	304	inline void
305	305	resizeMultiArraySplineInterpolation(MultiArrayView<N, T1, S1> const & source,

+50

-28

include/vigra/multi_shape.hxx less more

43	43
44	44	namespace vigra {
45	45
46		/** \addtogroup MultiIteratorGroup
	46	/** \addtogroup RangesAndPoints
47	47	*/
48	48	//@{
49	49

54	54	/********************************************************/
55	55
56	56	template <class T>
57		struct Singleband // the resulting MultiArray has no explicit channel axis
	57	struct Singleband // the resulting MultiArray has no explicit channel axis
58	58	// (i.e. the number of channels is implicitly one)
59	59	{
60	60	typedef T value_type;

236	236
237	237	} // namespace detail
238	238
239		/** Traits class for the difference type of all MultiIterator, MultiArrayView, and
	239	/** Metafucntion to obtain the difference type of all MultiIterator, MultiArrayView, and
240	240	MultiArray variants.
	241
	242	<b>Usage:</b>
	243
	244	This metafunction is mainly used in functions weren the array dimension <tt>N</tt> is
	245	provided as a templat parameter, and we need a shape object of the corresponding length.
	246	Then, a typedef like this is typically placed at the beginning of the function:
	247
	248	\code
	249	typedef typename MultiArrayShape<N>::type Shape;
	250
	251	Shape shape(1); // all ones of dimension N
	252	\endcode
	253
	254	The following typedefs are provided for convenience:
	255
	256	\code
	257	typedef MultiArrayShape<1>::type Shape1;
	258	typedef MultiArrayShape<2>::type Shape2;
	259	typedef MultiArrayShape<3>::type Shape3;
	260	typedef MultiArrayShape<4>::type Shape4;
	261	typedef MultiArrayShape<5>::type Shape5;
	262	\endcode
241	263	*/
242	264	template <unsigned int N>
243	265	class MultiArrayShape

249	271	typedef TinyVector<MultiArrayIndex, N> type;
250	272	};
251	273
252		typedef MultiArrayShape<1>::type Shape1; ///< shape type for MultiArray<1, T>
253		typedef MultiArrayShape<2>::type Shape2; ///< shape type for MultiArray<2, T>
254		typedef MultiArrayShape<3>::type Shape3; ///< shape type for MultiArray<3, T>
255		typedef MultiArrayShape<4>::type Shape4; ///< shape type for MultiArray<4, T>
256		typedef MultiArrayShape<5>::type Shape5; ///< shape type for MultiArray<5, T>
	274	typedef MultiArrayShape<1>::type Shape1;
	275	typedef MultiArrayShape<2>::type Shape2;
	276	typedef MultiArrayShape<3>::type Shape3;
	277	typedef MultiArrayShape<4>::type Shape4;
	278	typedef MultiArrayShape<5>::type Shape5;
257	279
258	280	namespace detail
259	281	{

484	506	/* */
485	507	/********************************************************/
486	508
487		/* transforms a coordinate object with negative indices into the corresponding
	509	/* transforms a coordinate object with negative indices into the corresponding
488	510	'shape - abs(index)'.
489	511	*/
490	512	template <int M>

518	540	/* */
519	541	/********************************************************/
520	542
521		// a border type is a compact bit-wise encoding of the fact that a
	543	// a border type is a compact bit-wise encoding of the fact that a
522	544	// given coordinate is at the border of the ROI. Each border corresponds
523	545	// to one bit in the encoding, e.g. the left, right, top, bottom borders
524		// of a 2D image are represented by bits 0 to 3 respectively.
	546	// of a 2D image are represented by bits 0 to 3 respectively.
525	547	// If a bit is set, the point in question is at the corresponding border.
526	548	// A code of all zeros therefore means that the point is in the interior
527	549	// of the ROI

529	551	struct BorderTypeImpl
530	552	{
531	553	typedef TinyVectorView<MultiArrayIndex, N> shape_type;
532
	554
533	555	static unsigned int exec(shape_type const & point, shape_type const & shape)
534	556	{
535	557	unsigned int res = BorderTypeImpl<N, DIMENSION-1>::exec(point, shape);

546	568	{
547	569	typedef TinyVectorView<MultiArrayIndex, N> shape_type;
548	570	static const unsigned int DIMENSION = 0;
549
	571
550	572	static unsigned int exec(shape_type const & point, shape_type const & shape)
551	573	{
552	574	unsigned int res = 0;

565	587	/********************************************************/
566	588
567	589	// Create the offsets to all direct neighbors, starting from the given Level (=dimension)
568		// and append them to the given array. The algorithm is designed so that the offsets are
	590	// and append them to the given array. The algorithm is designed so that the offsets are
569	591	// sorted by ascending strides. This has two important consequences:
570	592	// * The first half of the array contains the causal neighbors (negative strides),
571	593	// the second half the anti-causal ones (positive strides), where 'causal' refers
572	594	// to all scan-order predecessors of the center pixel, and 'anticausal' to its successors.
573	595	// * For any neighbor k, its opposite (=point-reflected) neighbor is located at index
574	596	// 'N-1-k', where N is the total number of neighbors.
575		// The function 'exists' returns an array of flags that contains 'true' when the corresponding
576		// neighbor is inside the ROI for the given borderType, 'false' otherwise.
	597	// The function 'exists' returns an array of flags that contains 'true' when the corresponding
	598	// neighbor is inside the ROI for the given borderType, 'false' otherwise.
577	599	template <unsigned int Level>
578	600	struct MakeDirectArrayNeighborhood
579	601	{

581	603	static void offsets(Array & a)
582	604	{
583	605	typedef typename Array::value_type Shape;
584
	606
585	607	Shape point;
586	608	point[Level] = -1;
587	609	a.push_back(point);

589	611	point[Level] = 1;
590	612	a.push_back(point);
591	613	}
592
	614
593	615	template <class Array>
594	616	static void exists(Array & a, unsigned int borderType)
595	617	{

606	628	static void offsets(Array & a)
607	629	{
608	630	typedef typename Array::value_type Shape;
609
	631
610	632	Shape point;
611	633	point[0] = -1;
612	634	a.push_back(point);
613	635	point[0] = 1;
614	636	a.push_back(point);
615	637	}
616
	638
617	639	template <class Array>
618	640	static void exists(Array & a, unsigned int borderType)
619	641	{

636	658	point[Level] = 1;
637	659	MakeIndirectArrayNeighborhood<Level-1>::offsets(a, point, false);
638	660	}
639
	661
640	662	template <class Array>
641	663	static void exists(Array & a, unsigned int borderType, bool isCenter = true)
642	664	{
643	665	if((borderType & (1 << 2*Level)) == 0)
644	666	MakeIndirectArrayNeighborhood<Level-1>::exists(a, borderType, false);
645		else
	667	else
646	668	MakeIndirectArrayNeighborhood<Level-1>::markOutside(a);
647	669
648	670	MakeIndirectArrayNeighborhood<Level-1>::exists(a, borderType, isCenter);

680	702	point[0] = 1;
681	703	a.push_back(point);
682	704	}
683
	705
684	706	template <class Array>
685	707	static void exists(Array & a, unsigned int borderType, bool isCenter = true)
686	708	{

695	717	template <class Array>
696	718	static void markOutside(Array & a)
697	719	{
698		// Push 'false' three times, for each possible offset at level 0, whenever the point was
	720	// Push 'false' three times, for each possible offset at level 0, whenever the point was
699	721	// outside the ROI in one of the higher levels.
700	722	a.push_back(false);
701	723	a.push_back(false);

703	725	}
704	726	};
705	727
706		// Create the list of neighbor offsets for the given neighborhood type
	728	// Create the list of neighbor offsets for the given neighborhood type
707	729	// and dimension (the dimension is implicitly defined by the Shape type)
708	730	// an return it in 'neighborOffsets'. Moreover, create a list of flags
709	731	// for each BorderType that is 'true' when the corresponding neighbor exists
710	732	// in this border situation and return the result in 'neighborExists'.
711	733	template <class Shape>
712	734	void
713		makeArrayNeighborhood(ArrayVector<Shape> & neighborOffsets,
	735	makeArrayNeighborhood(ArrayVector<Shape> & neighborOffsets,
714	736	ArrayVector<ArrayVector<bool> > & neighborExists,
715	737	NeighborhoodType neighborhoodType = DirectNeighborhood)
716	738	{
717	739	enum { N = Shape::static_size };
718
	740
719	741	neighborOffsets.clear();
720	742	if(neighborhoodType == DirectNeighborhood)
721	743	{

726	748	Shape point; // represents the center
727	749	MakeIndirectArrayNeighborhood<N-1>::offsets(neighborOffsets, point);
728	750	}
729
	751
730	752	unsigned int borderTypeCount = 1 << 2*N;
731	753	neighborExists.resize(borderTypeCount);
732	754

+3

-3

include/vigra/multi_tensorutilities.hxx less more

92	92	}
93	93
94	94	template <int N2>
95		void exec(argument_type const & v, result_type & r, MetaInt<N2>) const
	95	void exec(argument_type const &, result_type &, MetaInt<N2>) const
96	96	{
97	97	vigra_fail("tensorTraceMultiArray(): Sorry, can only handle dimensions up to 3.");
98	98	}

127	127	}
128	128
129	129	template <int N2>
130		void exec(argument_type const & v, result_type & r, MetaInt<N2>) const
	130	void exec(argument_type const &, result_type &, MetaInt<N2>) const
131	131	{
132	132	vigra_fail("tensorEigenvaluesMultiArray(): Sorry, can only handle dimensions up to 3.");
133	133	}

167	167	}
168	168
169	169	template <int N2>
170		void exec(argument_type const & v, result_type & r, MetaInt<N2>) const
	170	void exec(argument_type const &, result_type &, MetaInt<N2>) const
171	171	{
172	172	vigra_fail("tensorDeterminantMultiArray(): Sorry, can only handle dimensions up to 3.");
173	173	}

+13

-5

include/vigra/multi_watersheds.hxx less more

49	49
50	50	namespace vigra {
51	51
52		/** \addtogroup SeededRegionGrowing
	52	/** \addtogroup Superpixels
53	53	*/
54	54	//@{
55	55	namespace lemon_graph {

75	75	return g.id(*n);
76	76	}
77	77
78		static index_type invalidIndex(Graph const & g)
	78	static index_type invalidIndex(Graph const &)
79	79	{
80	80	return std::numeric_limits<index_type>::max();
81	81	}

90	90	typedef UInt16 index_type;
91	91
92	92	template <class NodeIter, class ArcIter>
93		static index_type get(Graph const & g, NodeIter const &, ArcIter const & a)
	93	static index_type get(Graph const &, NodeIter const &, ArcIter const & a)
94	94	{
95	95	return a.neighborIndex();
96	96	}

100	100	{
101	101	return g.oppositeIndex(a.neighborIndex());
102	102	}
103		static index_type invalidIndex(Graph const & g)
	103	static index_type invalidIndex(Graph const &)
104	104	{
105	105	return std::numeric_limits<index_type>::max();
106	106	}

137	137	template <class Graph, class T1Map, class T2Map, class T3Map>
138	138	typename T2Map::value_type
139	139	unionFindWatersheds(Graph const & g,
140		T1Map const & data,
	140	T1Map const &,
141	141	T2Map const & lowestNeighborIndex,
142	142	T3Map & labels)
143	143	{

218	218	return labelGraphWithBackground(g, minima, seeds, MarkerType(0), std::equal_to<MarkerType>());
219	219	}
220	220
	221	#ifdef __GNUC__
	222	#pragma GCC diagnostic push
	223	#pragma GCC diagnostic ignored "-Wsign-compare"
	224	#endif
221	225
222	226	template <class Graph, class T1Map, class T2Map>
223	227	typename T2Map::value_type

322	326	return maxRegionLabel;
323	327	}
324	328
	329	#ifdef __GNUC__
	330	#pragma GCC diagnostic pop
	331	#endif
	332
325	333	} // namespace graph_detail
326	334
327	335	template <class Graph, class T1Map, class T2Map>

+5

-6

include/vigra/non_local_mean.hxx less more

40	40	/************************************************************************/
41	41	/* The ONLM filter is described in: */
42	42	/* */
43		/* P. Coup��, P. Yger, S. Prima, P. Hellier, C. Kervrann, C. Barillot. */
	43	/* P. Coupe, P. Yger, S. Prima, P. Hellier, C. Kervrann, C. Barillot. */
44	44	/* An Optimized Blockwise Non Local Means Denoising Filter */
45	45	/* for 3D Magnetic Resonance Images */
46	46	/* . IEEE Transactions on Medical Imaging, 27(4):425-441, */

151	151	return (m > meanRatio_ && m < (1.0 / meanRatio_) && v > varRatio_ && v < (1.0 / varRatio_));
152	152	}
153	153
154		ValueType distanceToWeight(const PixelType & meanA, const PixelType & varA, const ValueType distance){
	154	ValueType distanceToWeight(const PixelType & /meanA/, const PixelType & /varA/, const ValueType distance){
155	155	return exp(-distance /sigmaSquared_);
156	156	}
157	157

262	262
263	263	}
264	264
265		bool usePixel(const PixelType & meanA, const PixelType & varA)const{
	265	bool usePixel(const PixelType & /meanA/, const PixelType & varA)const{
266	266	return sum(varA)>epsilon_;
267	267	}
268	268

278	278	return (m < meanDist_ && v > varRatio_ && v < (1.0 / varRatio_));
279	279	}
280	280
281		ValueType distanceToWeight(const PixelType & meanA, const PixelType & varA, const ValueType distance){
	281	ValueType distanceToWeight(const PixelType & /meanA/, const PixelType & /varA/, const ValueType distance){
282	282	return exp(-distance /sigmaSquared_);
283	283	}
284	284

549	549	const Coordinate & xyz
550	550	){
551	551	Coordinate nxyz(SkipInitialization);
552		const int searchRadius = param_.searchRadius_;
553	552	std::fill(average_.begin(),average_.end(),RealPromotePixelType(0.0));
554	553	RealPromoteScalarType totalweight = 0.0;
555	554

935	934	if(param.iterations_>1){
936	935
937	936	vigra::MultiArray<DIM,PIXEL_TYPE_OUT> tmp(outImage.shape());
938		for(size_t i=0;i<param.iterations_-1;++i){
	937	for(size_t i=0;i<static_cast<size_t>(param.iterations_-1);++i){
939	938	tmp=outImage;
940	939	detail_non_local_means::nonLocalMean1Run<DIM,PIXEL_TYPE_OUT,PIXEL_TYPE_OUT,SMOOTH_POLICY>(tmp,smoothPolicy,param,outImage);
941	940	}

+11

-0

include/vigra/numpy_array.hxx less more

1259	1259	}
1260	1260
1261	1261	this->m_stride /= sizeof(value_type);
	1262	// make sure that singleton axes have non-zero stride
	1263	for(int k=0; k<actual_dimension; ++k)
	1264	{
	1265	if(this->m_stride[k] == 0)
	1266	{
	1267	vigra_precondition(this->m_shape[k] == 1,
	1268	"NumpyArray::setupArrayView(): only singleton axes may have zero stride.");
	1269	this->m_stride[k] = 1;
	1270	}
	1271	}
	1272
1262	1273	this->m_ptr = reinterpret_cast<pointer>(PyArray_DATA(pyArray()));
1263	1274	vigra_precondition(this->checkInnerStride(Stride()),
1264	1275	"NumpyArray<..., UnstridedArrayTag>::setupArrayView(): First dimension of given array is not unstrided (should never happen).");

+9

-10

include/vigra/numpy_array_converters.hxx less more

89	89
90	90	converter::registration const * reg = converter::registry::query(type_id<ArrayType>());
91	91
92		// register the to_python_converter only once
93		// FIXME: I'm not sure if this is correct.
	92	// register the converters only once
94	93	if(!reg \|\| !reg->rvalue_chain)
95	94	{
96	95	to_python_converter<ArrayType, NumpyArrayConverter>();
97		}
98		converter::registry::insert(&convertible, &construct, type_id<ArrayType>());
	96	converter::registry::insert(&convertible, &construct, type_id<ArrayType>());
	97	}
99	98	}
100	99
101	100	template <unsigned int N, class T, class Stride>

807	806	template <class Functor>
808	807	inline typename std::enable_if<std::is_base_of<PythonMultidefFunctor, Functor>::value,
809	808	void>::type
810		def(char const* python_name, Functor const & f)
811		{
812		static_assert(!std::is_base_of<PythonMultidefFunctor, Functor>::value,
	809	def(char const*, Functor const &)
	810	{
	811	static_assert(!std::is_base_of<PythonMultidefFunctor, Functor>::value,
813	812	"def(): use multidef() to export multiple overloads.");
814	813	}
815	814
816	815	template <class Functor, class Args>
817	816	inline typename std::enable_if<std::is_base_of<PythonMultidefFunctor, Functor>::value,
818	817	void>::type
819		def(char const* python_name, Functor const & f, Args const& args)
	818	def(char const*, Functor const &, Args const& )
820	819	{
821	820	static_assert(!std::is_base_of<PythonMultidefFunctor, Functor>::value,
822	821	"def(): use multidef() to export multiple overloads.");

825	824	template <class Functor>
826	825	inline typename std::enable_if<std::is_base_of<PythonMultidefFunctor, Functor>::value,
827	826	void>::type
828		def(char const* python_name, Functor const & f, const char * help)
	827	def(char const, Functor const &, const char )
829	828	{
830	829	static_assert(!std::is_base_of<PythonMultidefFunctor, Functor>::value,
831	830	"def(): use multidef() to export multiple overloads.");

834	833	template <class Functor, class Args>
835	834	inline typename std::enable_if<std::is_base_of<PythonMultidefFunctor, Functor>::value,
836	835	void>::type
837		def(char const* python_name, Functor const & f, Args const& args, const char * help)
	836	def(char const, Functor const &, Args const&, const char )
838	837	{
839	838	static_assert(!std::is_base_of<PythonMultidefFunctor, Functor>::value,
840	839	"def(): use multidef() to export multiple overloads.");

+36

-36

include/vigra/numpy_array_taggedshape.hxx less more

71	71	if(order == "")
72	72	order = defaultOrder();
73	73	python_ptr arraytype = getArrayTypeObject();
74		python_ptr func(pythonFromData("defaultAxistags"));
75		python_ptr d(pythonFromData(ndim));
76		python_ptr o(pythonFromData(order));
77		python_ptr axistags(PyObject_CallMethodObjArgs(arraytype, func.get(), d.get(), o.get(), NULL),
	74	python_ptr func(pythonFromData("defaultAxistags"));
	75	python_ptr d(pythonFromData(ndim));
	76	python_ptr o(pythonFromData(order));
	77	python_ptr axistags(PyObject_CallMethodObjArgs(arraytype, func.get(), d.get(), o.get(), NULL),
78	78	python_ptr::keep_count);
79	79	if(axistags)
80	80	return axistags;

86	86	python_ptr emptyAxistags(int ndim)
87	87	{
88	88	python_ptr arraytype = getArrayTypeObject();
89		python_ptr func(pythonFromData("_empty_axistags"));
90		python_ptr d(pythonFromData(ndim));
91		python_ptr axistags(PyObject_CallMethodObjArgs(arraytype, func.get(), d.get(), NULL),
	89	python_ptr func(pythonFromData("_empty_axistags"));
	90	python_ptr d(pythonFromData(ndim));
	91	python_ptr axistags(PyObject_CallMethodObjArgs(arraytype, func.get(), d.get(), NULL),
92	92	python_ptr::keep_count);
93	93	if(axistags)
94	94	return axistags;

102	102	python_ptr object, const char * name,
103	103	AxisInfo::AxisType type, bool ignoreErrors)
104	104	{
105		python_ptr func(pythonFromData(name));
106		python_ptr t(pythonFromData((long)type));
107		python_ptr permutation(PyObject_CallMethodObjArgs(object, func.get(), t.get(), NULL),
	105	python_ptr func(pythonFromData(name));
	106	python_ptr t(pythonFromData((long)type));
	107	python_ptr permutation(PyObject_CallMethodObjArgs(object, func.get(), t.get(), NULL),
108	108	python_ptr::keep_count);
109	109	if(!permutation && ignoreErrors)
110	110	{

127	127	{
128	128	python_ptr i(PySequence_GetItem(permutation, k), python_ptr::keep_count);
129	129	#if PY_MAJOR_VERSION < 3
130		if(!PyInt_Check(i))
	130	if(!PyInt_Check(i))
131	131	#else
132		if (!PyLong_Check(i))
	132	if (!PyLong_Check(i))
133	133	#endif
134		{
	134	{
135	135	if(ignoreErrors)
136	136	return;
137	137	std::string message = std::string(name) + "() did not return a sequence of int.";

139	139	pythonToCppException(false);
140	140	}
141	141	#if PY_MAJOR_VERSION < 3
142		res[k] = PyInt_AsLong(i);
	142	res[k] = PyInt_AsLong(i);
143	143	#else
144		res[k] = PyLong_AsLong(i);
	144	res[k] = PyLong_AsLong(i);
145	145	#endif
146		}
	146	}
147	147	res.swap(permute);
148	148	}
149	149

193	193
194	194	if(createCopy)
195	195	{
196		python_ptr func(pythonFromData("__copy__"));
197		axistags = python_ptr(PyObject_CallMethodObjArgs(tags, func.get(), NULL),
	196	python_ptr func(pythonFromData("__copy__"));
	197	axistags = python_ptr(PyObject_CallMethodObjArgs(tags, func.get(), NULL),
198	198	python_ptr::keep_count);
199	199	}
200	200	else

209	209	return;
210	210	if(createCopy)
211	211	{
212		python_ptr func(pythonFromData("__copy__"));
213		axistags = python_ptr(PyObject_CallMethodObjArgs(other.axistags, func.get(), NULL),
	212	python_ptr func(pythonFromData("__copy__"));
	213	axistags = python_ptr(PyObject_CallMethodObjArgs(other.axistags, func.get(), NULL),
214	214	python_ptr::keep_count);
215	215	}
216	216	else

263	263	{
264	264	if(!axistags)
265	265	return;
266		python_ptr d(pythonFromData(description));
267		python_ptr func(pythonFromData("setChannelDescription"));
268		python_ptr res(PyObject_CallMethodObjArgs(axistags, func.get(), d.get(), NULL),
	266	python_ptr d(pythonFromData(description));
	267	python_ptr func(pythonFromData("setChannelDescription"));
	268	python_ptr res(PyObject_CallMethodObjArgs(axistags, func.get(), d.get(), NULL),
269	269	python_ptr::keep_count);
270	270	pythonToCppException(res);
271	271	}

274	274	{
275	275	if(!axistags)
276	276	return 0.0;
277		python_ptr func(pythonFromData("resolution"));
278		python_ptr i(pythonFromData(index));
279		python_ptr res(PyObject_CallMethodObjArgs(axistags, func.get(), i.get(), NULL),
	277	python_ptr func(pythonFromData("resolution"));
	278	python_ptr i(pythonFromData(index));
	279	python_ptr res(PyObject_CallMethodObjArgs(axistags, func.get(), i.get(), NULL),
280	280	python_ptr::keep_count);
281	281	pythonToCppException(res);
282	282	if(!PyFloat_Check(res))

291	291	{
292	292	if(!axistags)
293	293	return;
294		python_ptr func(pythonFromData("setResolution"));
295		python_ptr i(pythonFromData(index));
296		python_ptr r(PyFloat_FromDouble(resolution), python_ptr::keep_count);
	294	python_ptr func(pythonFromData("setResolution"));
	295	python_ptr i(pythonFromData(index));
	296	python_ptr r(PyFloat_FromDouble(resolution), python_ptr::keep_count);
297	297	python_ptr res(PyObject_CallMethodObjArgs(axistags, func.get(), i.get(), r.get(), NULL),
298	298	python_ptr::keep_count);
299	299	pythonToCppException(res);

303	303	{
304	304	if(!axistags)
305	305	return;
306		python_ptr func(pythonFromData("scaleResolution"));
307		python_ptr i(pythonFromData(index));
308		python_ptr f(PyFloat_FromDouble(factor), python_ptr::keep_count);
	306	python_ptr func(pythonFromData("scaleResolution"));
	307	python_ptr i(pythonFromData(index));
	308	python_ptr f(PyFloat_FromDouble(factor), python_ptr::keep_count);
309	309	python_ptr res(PyObject_CallMethodObjArgs(axistags, func.get(), i.get(), f.get(), NULL),
310	310	python_ptr::keep_count);
311	311	pythonToCppException(res);

316	316	if(!axistags)
317	317	return;
318	318	python_ptr func(sign == 1
319		? pythonFromData("toFrequencyDomain")
320		: pythonFromData("fromFrequencyDomain"));
	319	? pythonFromData("toFrequencyDomain")
	320	: pythonFromData("fromFrequencyDomain"));
321	321	python_ptr i(pythonFromData(index));
322	322	python_ptr s(pythonFromData(size));
323		python_ptr res(PyObject_CallMethodObjArgs(axistags, func.get(), i.get(), s.get(), NULL),
	323	python_ptr res(PyObject_CallMethodObjArgs(axistags, func.get(), i.get(), s.get(), NULL),
324	324	python_ptr::keep_count);
325	325	pythonToCppException(res);
326	326	}

371	371	return;
372	372	python_ptr func(pythonFromData("dropChannelAxis"));
373	373	python_ptr res(PyObject_CallMethodObjArgs(axistags, func.get(), NULL),
374		python_ptr::keep_count);
	374	python_ptr::keep_count);
375	375	pythonToCppException(res);
376	376	}
377	377

+79

-60

include/vigra/numpy_array_traits.hxx less more

37	37
38	38	#ifndef NPY_NO_DEPRECATED_API
39	39	# define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
40		#endif
	40	#endif
41	41
42	42	#include "numerictraits.hxx"
43	43	#include "multi_array.hxx"

56	56	template<class ValueType>
57	57	struct NumpyArrayValuetypeTraits
58	58	{
59		static bool isValuetypeCompatible(PyArrayObject const * obj)
	59	static bool isValuetypeCompatible(PyArrayObject const *)
60	60	{
61	61	return ERROR_NumpyArrayValuetypeTraits_not_specialized_for_<ValueType>();
62	62	}

203	203	{
204	204	return isShapeCompatible(obj) && isValuetypeCompatible(obj);
205	205	}
206
207		// Construct a tagged shape from a 'shape - axistags' pair (called in
	206
	207	// Construct a tagged shape from a 'shape - axistags' pair (called in
208	208	// NumpyArray::taggedShape()).
209	209	template <class U>
210	210	static TaggedShape taggedShape(TinyVector<U, N> const & shape, PyAxisTags axistags)

233	233	vigra_precondition(tagged_shape.size() == N,
234	234	"reshapeIfEmpty(): tagged_shape has wrong size.");
235	235	}
236
	236
237	237	// This function is used to synchronize the axis re-ordering of 'data'
238	238	// with that of 'array'. For example, when we want to apply Gaussian smoothing
239	239	// with a different scale for each axis, 'data' would contains those scales,

244	244	{
245	245	vigra_precondition((int)data.size() == N,
246	246	"NumpyArray::permuteLikewise(): size mismatch.");
247
	247
248	248	ArrayVector<npy_intp> permute;
249		detail::getAxisPermutationImpl(permute, array, "permutationToNormalOrder",
	249	detail::getAxisPermutationImpl(permute, array, "permutationToNormalOrder",
250	250	AxisInfo::AllAxes, true);
251	251
252	252	if(permute.size() != 0)

254	254	applyPermutation(permute.begin(), permute.end(), data.begin(), res.begin());
255	255	}
256	256	}
257
	257
258	258	// This function is called in NumpyArray::setupArrayView() to determine the
259	259	// desired axis re-ordering.
260	260	template <class U>
261	261	static void permutationToSetupOrder(python_ptr array, ArrayVector<U> & permute)
262	262	{
263		detail::getAxisPermutationImpl(permute, array, "permutationToNormalOrder",
	263	detail::getAxisPermutationImpl(permute, array, "permutationToNormalOrder",
264	264	AxisInfo::AllAxes, true);
265	265
266	266	if(permute.size() == 0)

279	279	T *data, TinyVector<U, N> const & stride)
280	280	{
281	281	TinyVector<npy_intp, N> npyStride(stride * sizeof(T));
282		return constructNumpyArrayFromData(shape, npyStride.begin(),
	282	return constructNumpyArrayFromData(shape, npyStride.begin(),
283	283	ValuetypeTraits::typeCode, data);
284	284	}
285	285	};

300	300	long channelIndex = pythonGetAttr(obj, "channelIndex", ndim);
301	301	long majorIndex = pythonGetAttr(obj, "innerNonchannelIndex", ndim);
302	302	npy_intp * strides = PyArray_STRIDES(array);
303
	303
304	304	if(channelIndex < ndim)
305	305	{
306	306	// When we have a channel axis, it will become the innermost dimension

312	312	// axis will be the innermost dimension
313	313	return (ndim == N && strides[majorIndex] == sizeof(T));
314	314	}
315		else
	315	else
316	316	{
317	317	// When we have no axistags, the first axis will be the innermost dimension
318	318	return (ndim == N && strides[0] == sizeof(T));

339	339	PyObject * obj = (PyObject *)array;
340	340	int ndim = PyArray_NDIM(array);
341	341	long channelIndex = pythonGetAttr(obj, "channelIndex", ndim);
342
343		// If we have no channel axis (because either we don't have axistags,
	342
	343	// If we have no channel axis (because either we don't have axistags,
344	344	// or the tags do not contain a channel axis), ndim must match.
345	345	if(channelIndex == ndim)
346	346	return ndim == N;
347
	347
348	348	// Otherwise, the channel axis must be a singleton axis that we can drop.
349	349	return ndim == N+1 && PyArray_DIM(array, channelIndex) == 1;
350	350	}

363	363	template <class U>
364	364	static TaggedShape taggedShape(TinyVector<U, N> const & shape, std::string const & order = "")
365	365	{
366		return TaggedShape(shape,
	366	return TaggedShape(shape,
367	367	PyAxisTags(detail::defaultAxistags(shape.size()+1, order))).setChannelCount(1);
368	368	}
369	369

382	382	"reshapeIfEmpty(): tagged_shape has wrong size.");
383	383	}
384	384	}
385
	385
386	386	template <class ARRAY>
387	387	static void permuteLikewise(python_ptr array, ARRAY const & data, ARRAY & res)
388	388	{
389	389	vigra_precondition((int)data.size() == N,
390	390	"NumpyArray::permuteLikewise(): size mismatch.");
391
	391
392	392	ArrayVector<npy_intp> permute;
393		detail::getAxisPermutationImpl(permute, array, "permutationToNormalOrder",
	393	detail::getAxisPermutationImpl(permute, array, "permutationToNormalOrder",
394	394	AxisInfo::NonChannel, true);
395	395
396	396	if(permute.size() == 0)

398	398	permute.resize(N);
399	399	linearSequence(permute.begin(), permute.end());
400	400	}
401
	401
402	402	applyPermutation(permute.begin(), permute.end(), data.begin(), res.begin());
403	403	}
404
	404
405	405	template <class U>
406	406	static void permutationToSetupOrder(python_ptr array, ArrayVector<U> & permute)
407	407	{
408		detail::getAxisPermutationImpl(permute, array, "permutationToNormalOrder",
	408	detail::getAxisPermutationImpl(permute, array, "permutationToNormalOrder",
409	409	AxisInfo::AllAxes, true);
410	410	if(permute.size() == 0)
411	411	{

436	436	long channelIndex = pythonGetAttr(obj, "channelIndex", ndim);
437	437	long majorIndex = pythonGetAttr(obj, "innerNonchannelIndex", ndim);
438	438	npy_intp * strides = PyArray_STRIDES(array);
439
	439
440	440	// If we have no axistags, ndim must match, and axis 0 must be unstrided.
441		if(majorIndex == ndim)
	441	if(majorIndex == ndim)
442	442	return N == ndim && strides[0] == sizeof(T);
443
444		// If we have axistags, but no channel axis, ndim must match,
	443
	444	// If we have axistags, but no channel axis, ndim must match,
445	445	// and the major non-channel axis must be unstrided.
446		if(channelIndex == ndim)
	446	if(channelIndex == ndim)
447	447	return N == ndim && strides[majorIndex] == sizeof(T);
448
	448
449	449	// Otherwise, the channel axis must be a singleton axis that we can drop,
450	450	// and the major non-channel axis must be unstrided.
451		return ndim == N+1 && PyArray_DIM(array, channelIndex) == 1 &&
	451	return ndim == N+1 && PyArray_DIM(array, channelIndex) == 1 &&
452	452	strides[majorIndex] == sizeof(T);
453	453	}
454	454

473	473	int ndim = PyArray_NDIM(array);
474	474	long channelIndex = pythonGetAttr(obj, "channelIndex", ndim);
475	475	long majorIndex = pythonGetAttr(obj, "innerNonchannelIndex", ndim);
476
	476
477	477	if(channelIndex < ndim)
478	478	{
479	479	// When we have a channel axis, ndim must match.

505	505	template <class U>
506	506	static TaggedShape taggedShape(TinyVector<U, N> const & shape, std::string const & order = "")
507	507	{
508		return TaggedShape(shape,
	508	return TaggedShape(shape,
509	509	PyAxisTags(detail::defaultAxistags(shape.size(), order))).setChannelIndexLast();
510	510	}
511	511

530	530	static void permuteLikewise(python_ptr array, ARRAY const & data, ARRAY & res)
531	531	{
532	532	ArrayVector<npy_intp> permute;
533
	533
534	534	if((int)data.size() == N)
535	535	{
536	536	vigra_precondition(PyArray_NDIM((PyArrayObject*)array.get()) == N,
537	537	"NumpyArray::permuteLikewise(): input array has no channel axis.");
538	538
539		detail::getAxisPermutationImpl(permute, array, "permutationToNormalOrder",
	539	detail::getAxisPermutationImpl(permute, array, "permutationToNormalOrder",
540	540	AxisInfo::AllAxes, true);
541	541
542	542	if(permute.size() == 0)

548	548	{
549	549	// rotate channel axis to last position
550	550	int channelIndex = permute[0];
551		for(int k=1; k<N; ++k)
	551	for(unsigned k=1; k<N; ++k)
552	552	permute[k-1] = permute[k];
553	553	permute[N-1] = channelIndex;
554	554	}

558	558	vigra_precondition((int)data.size() == N-1,
559	559	"NumpyArray::permuteLikewise(): size mismatch.");
560	560
561		detail::getAxisPermutationImpl(permute, array, "permutationToNormalOrder",
	561	detail::getAxisPermutationImpl(permute, array, "permutationToNormalOrder",
562	562	AxisInfo::NonChannel, true);
563	563
564	564	if(permute.size() == 0)

567	567	linearSequence(permute.begin(), permute.end());
568	568	}
569	569	}
570
	570
571	571	applyPermutation(permute.begin(), permute.end(), data.begin(), res.begin());
572	572	}
573
	573
574	574	template <class U>
575	575	static void permutationToSetupOrder(python_ptr array, ArrayVector<U> & permute)
576	576	{
577		detail::getAxisPermutationImpl(permute, array, "permutationToNormalOrder",
	577	detail::getAxisPermutationImpl(permute, array, "permutationToNormalOrder",
578	578	AxisInfo::AllAxes, true);
579	579
580	580	if(permute.size() == 0)

586	586	{
587	587	// if we have a channel axis, rotate it to last position
588	588	int channelIndex = permute[0];
589		for(int k=1; k<N; ++k)
	589	for(decltype(permute.size()) k=1; k<N; ++k)
590	590	permute[k-1] = permute[k];
591	591	permute[N-1] = channelIndex;
592	592	}

659	659	static bool isShapeCompatible(PyArrayObject * array) /* array must not be NULL */
660	660	{
661	661	PyObject * obj = (PyObject *)array;
662
	662
663	663	// We need an extra channel axis.
664	664	if(PyArray_NDIM(array) != N+1)
665	665	return false;
666
	666
667	667	// When there are no axistags, we assume that the last axis represents the channels.
668	668	long channelIndex = pythonGetAttr(obj, "channelIndex", N);
669	669	npy_intp * strides = PyArray_STRIDES(array);
670
671		return PyArray_DIM(array, channelIndex) == M && strides[channelIndex] == sizeof(T);
	670
	671	// find the non-channel axis with smallest stride
	672	long majorIndex = pythonGetAttr(obj, "innerNonchannelIndex", N+1);
	673	if(majorIndex >= N+1)
	674	{
	675	npy_intp smallest = NumericTraits<npy_intp>::max();
	676	for(unsigned int k=0; k<N+1; ++k)
	677	{
	678	if(k == channelIndex)
	679	continue;
	680	if(strides[k] < smallest)
	681	{
	682	smallest = strides[k];
	683	majorIndex = k;
	684	}
	685	}
	686	}
	687
	688	return PyArray_DIM(array, channelIndex) == M &&
	689	strides[channelIndex] == sizeof(T) &&
	690	strides[majorIndex] % (M*sizeof(T)) == 0;
672	691	}
673	692
674	693	static bool isPropertyCompatible(PyArrayObject * obj) /* obj must not be NULL */

685	704	template <class U>
686	705	static TaggedShape taggedShape(TinyVector<U, N> const & shape, std::string const & order = "")
687	706	{
688		return TaggedShape(shape,
	707	return TaggedShape(shape,
689	708	PyAxisTags(detail::defaultAxistags(shape.size()+1, order))).setChannelCount(M);
690	709	}
691	710

701	720	{
702	721	vigra_precondition((int)data.size() == N,
703	722	"NumpyArray::permuteLikewise(): size mismatch.");
704
	723
705	724	ArrayVector<npy_intp> permute;
706		detail::getAxisPermutationImpl(permute, array, "permutationToNormalOrder",
	725	detail::getAxisPermutationImpl(permute, array, "permutationToNormalOrder",
707	726	AxisInfo::NonChannel, true);
708	727
709	728	if(permute.size() == 0)

711	730	permute.resize(N);
712	731	linearSequence(permute.begin(), permute.end());
713	732	}
714
	733
715	734	applyPermutation(permute.begin(), permute.end(), data.begin(), res.begin());
716	735	}
717
	736
718	737	template <class U>
719	738	static void permutationToSetupOrder(python_ptr array, ArrayVector<U> & permute)
720	739	{
721		detail::getAxisPermutationImpl(permute, array, "permutationToNormalOrder",
	740	detail::getAxisPermutationImpl(permute, array, "permutationToNormalOrder",
722	741	AxisInfo::AllAxes, true);
723	742	if(permute.size() == 0)
724	743	{

730	749	permute.erase(permute.begin());
731	750	}
732	751	}
733
	752
734	753	template <class U>
735	754	static python_ptr unsafeConstructorFromData(TinyVector<U, N> const & shape,
736	755	value_type *data, TinyVector<U, N> const & stride)

745	764	std::bind2nd(std::multiplies<npy_intp>(), sizeof(value_type)));
746	765	npyStride[N] = sizeof(T);
747	766
748		return constructNumpyArrayFromData(npyShape, npyStride.begin(),
	767	return constructNumpyArrayFromData(npyShape, npyStride.begin(),
749	768	ValuetypeTraits::typeCode, data);
750	769	}
751	770	};

764	783	{
765	784	PyObject * obj = (PyObject *)array;
766	785	int ndim = PyArray_NDIM(array);
767
768		// We need an extra channel axis.
	786
	787	// We need an extra channel axis.
769	788	if(ndim != N+1)
770	789	return false;
771
	790
772	791	long channelIndex = pythonGetAttr(obj, "channelIndex", ndim);
773	792	long majorIndex = pythonGetAttr(obj, "innerNonchannelIndex", ndim);
774	793	npy_intp * strides = PyArray_STRIDES(array);
775
	794
776	795	if(majorIndex < ndim)
777	796	{
778	797	// We have axistags, but no channel axis => cannot be a TinyVector image
779	798	if(channelIndex == ndim)
780	799	return false;
781
	800
782	801	// We have an explicit channel axis => shapes and strides must match
783		return PyArray_DIM(array, channelIndex) == M &&
	802	return PyArray_DIM(array, channelIndex) == M &&
784	803	strides[channelIndex] == sizeof(T) &&
785	804	strides[majorIndex] == sizeof(TinyVector<T, M>);
786
787
	805
	806
788	807	}
789	808	else
790	809	{
791	810	// we have no axistags => we assume that the channel axis is last
792		return PyArray_DIM(array, N) == M &&
	811	return PyArray_DIM(array, N) == M &&
793	812	strides[N] == sizeof(T) &&
794	813	strides[0] == sizeof(TinyVector<T, M>);
795	814	}

+1

-1

include/vigra/orientedtensorfilters.hxx less more

362	362	}
363	363	}
364	364
365		ResultType operator()(int x, int y, VectorType const &) const
	365	ResultType operator()(int /x/, int /y/, VectorType const &) const
366	366	{
367	367	// isotropic filtering
368	368	return weights_(radius_, radius_);

+172

-0

include/vigra/permutation.hxx less more

	0	#ifndef VIGRA_PERMUTATION_HXX
	1	#define VIGRA_PERMUTATION_HXX
	2
	3	#include "config.hxx"
	4	#include "error.hxx"
	5	#include "array_vector.hxx"
	6	#include "tinyvector.hxx"
	7
	8	namespace vigra {
	9
	10	template <unsigned int N>
	11	class Permutation : public TinyVector<unsigned int, N>
	12	{
	13	public:
	14	typedef TinyVector<unsigned int, N> base_type;
	15	typedef typename base_type::size_type size_type;
	16	typedef typename base_type::value_type value_type;
	17	typedef typename base_type::iterator iterator;
	18	typedef typename base_type::const_iterator const_iterator;
	19	typedef typename base_type::reference reference;
	20	typedef typename base_type::const_reference const_reference;
	21	typedef typename base_type::pointer pointer;
	22	typedef typename base_type::const_pointer const_pointer;
	23	typedef int integral_type;
	24
	25	Permutation() : base_type() {}
	26
	27	Permutation(const Permutation<N-1> & other, const size_type index)
	28	: base_type()
	29	{
	30	vigra_precondition(
	31	index < N,
	32	"Permutation::Permutation(): Invalid index");
	33	for (size_type n = 0; n < N; n++)
	34	{
	35	if (n < index)
	36	{
	37	(*this)[n] = other[n];
	38	}
	39	else if (n == index)
	40	{
	41	(*this)[n] = N - 1;
	42	}
	43	else
	44	{
	45	(*this)[n] = other[n-1];
	46	}
	47	}
	48	if ((N - 1 - index) % 2 == 0)
	49	{
	50	sign_ = (other.sign() == 1);
	51	}
	52	else
	53	{
	54	sign_ = (other.sign() == -1);
	55	}
	56	}
	57
	58	integral_type sign() const
	59	{
	60	if (sign_)
	61	{
	62	return +1;
	63	}
	64	else
	65	{
	66	return -1;
	67	}
	68	}
	69
	70	private:
	71	bool sign_;
	72
	73	};
	74
	75	template <>
	76	class Permutation<1> : public TinyVector<unsigned int, 1>
	77	{
	78	public:
	79	typedef TinyVector<unsigned int, 1> base_type;
	80	typedef base_type::size_type size_type;
	81	typedef base_type::value_type value_type;
	82	typedef base_type::iterator iterator;
	83	typedef base_type::const_iterator const_iterator;
	84	typedef base_type::reference reference;
	85	typedef base_type::const_reference const_reference;
	86	typedef base_type::pointer pointer;
	87	typedef base_type::const_pointer const_pointer;
	88	typedef int integral_type;
	89
	90	Permutation() : base_type()
	91	{
	92	(*this)[0] = 0;
	93	(*this).sign_ = true;
	94	}
	95
	96	integral_type sign() const
	97	{
	98	if (sign_)
	99	{
	100	return +1;
	101	}
	102	else
	103	{
	104	return -1;
	105	}
	106	}
	107
	108	private:
	109	bool sign_;
	110	};
	111
	112	template <unsigned int N>
	113	class PlainChangesPermutations : public ArrayVector<Permutation<N> >
	114	{
	115	public:
	116	typedef ArrayVector<Permutation<N> > base_type;
	117	typedef typename base_type::size_type size_type;
	118	typedef typename base_type::value_type value_type;
	119	typedef typename base_type::iterator iterator;
	120	typedef typename base_type::const_iterator const_iterator;
	121	typedef typename base_type::reference reference;
	122	typedef typename base_type::const_reference const_reference;
	123	typedef typename base_type::pointer pointer;
	124	typedef typename base_type::const_pointer const_pointer;
	125
	126	PlainChangesPermutations() : base_type()
	127	{
	128	PlainChangesPermutations<N-1> permutations;
	129	for (auto permutation : permutations)
	130	{
	131	if (permutation.sign() == -1)
	132	{
	133	for (unsigned int n = 0; n < N; n++)
	134	{
	135	this->push_back(Permutation<N>(permutation, n));
	136	}
	137	}
	138	else
	139	{
	140	for (unsigned int n = N; n > 0; n--)
	141	{
	142	this->push_back(Permutation<N>(permutation, n - 1));
	143	}
	144	}
	145	}
	146	}
	147	};
	148
	149	template <>
	150	class PlainChangesPermutations<1> : public ArrayVector<Permutation<1> >
	151	{
	152	public:
	153	typedef ArrayVector<Permutation<1> > base_type;
	154	typedef base_type::size_type size_type;
	155	typedef base_type::value_type value_type;
	156	typedef base_type::iterator iterator;
	157	typedef base_type::const_iterator const_iterator;
	158	typedef base_type::reference reference;
	159	typedef base_type::const_reference const_reference;
	160	typedef base_type::pointer pointer;
	161	typedef base_type::const_pointer const_pointer;
	162
	163	PlainChangesPermutations() : base_type()
	164	{
	165	this->push_back(Permutation<1>());
	166	}
	167	};
	168
	169	} /* namespace vigra */
	170
	171	#endif

+1049

-0

include/vigra/polytope.hxx less more

	0	#ifndef VIGRA_POLYTOPE_HXX
	1	#define VIGRA_POLYTOPE_HXX
	2
	3	#ifndef WITH_LEMON
	4	#error "Should only be included with flag \"WITH_LEMON\""
	5	#endif
	6
	7	#include <set>
	8	#include <lemon/list_graph.h>
	9	#include <lemon/maps.h>
	10
	11	#include "config.hxx"
	12	#include "error.hxx"
	13	#include "tinyvector.hxx"
	14	#include "array_vector.hxx"
	15	#include "linear_algebra.hxx"
	16	#include "numerictraits.hxx"
	17	#include "permutation.hxx"
	18
	19	namespace vigra {
	20
	21	/** \brief Represent an n-dimensional polytope.
	22
	23	\tparam N Dimension the polytope.
	24	\tparam T Type of the vector components of the polytope vertices.
	25	*/
	26	template <unsigned int N, class T>
	27	class Polytope
	28	{
	29	public:
	30
	31	enum Dimension {dimension = N};
	32	enum node_enum {INVALID, FACET, VERTEX};
	33
	34	template <node_enum NodeType>
	35	struct node_type_iterator;
	36
	37	typedef T coordinate_type;
	38	typedef typename NumericTraits<T>::RealPromote real_type;
	39	typedef TinyVector<T, N> point_type;
	40	typedef TinyVectorView<T, N> point_view_type;
	41	typedef typename point_type::difference_type difference_type;
	42	typedef typename lemon::ListDigraph graph_type;
	43	typedef typename graph_type::Node node_type;
	44	typedef typename graph_type::Arc arc_type;
	45	typedef typename graph_type::NodeIt node_iterator;
	46	typedef typename graph_type::OutArcIt out_arc_iterator;
	47	typedef typename graph_type::InArcIt in_arc_iterator;
	48	typedef node_type_iterator<FACET> facet_iterator;
	49	typedef node_type_iterator<VERTEX> vertex_iterator;
	50
	51	/** Default constructor creates an empty polytope class.
	52	*/
	53	Polytope()
	54	: graph_()
	55	, type_map_(graph_)
	56	, vec_map_(graph_)
	57	, aligns_map_(graph_)
	58	{}
	59
	60	/** Copy constructor.
	61	*/
	62	Polytope(const Polytope<N, T> & other)
	63	: graph_()
	64	, type_map_(graph_)
	65	, vec_map_(graph_)
	66	, aligns_map_(graph_)
	67	{
	68	*this = other;
	69	}
	70
	71	/** Copy from another polytope.
	72	*/
	73	virtual void operator=(const Polytope<N, T> & other)
	74	{
	75	lemon::digraphCopy(other.graph_, graph_);
	76	lemon::mapCopy(other.graph_, other.type_map_, type_map_);
	77	lemon::mapCopy(other.graph_, other.vec_map_, vec_map_);
	78	lemon::mapCopy(other.graph_, other.aligns_map_, aligns_map_);
	79	}
	80
	81	virtual bool contains(const point_view_type & p) const = 0;
	82
	83	virtual real_type nVolume() const = 0;
	84
	85	virtual real_type nSurface() const = 0;
	86
	87	/** Check if the facet aligns with other facets at each of its ridges.
	88	*/
	89	virtual bool closed(const node_type n) const
	90	{
	91	vigra_assert(
	92	type_map_[n] == FACET,
	93	"Polytope::closed(): Node needs do be a facet");
	94	return std::find(
	95	aligns_map_[n].begin(),
	96	aligns_map_[n].end(),
	97	lemon::INVALID) == aligns_map_[n].end();
	98	}
	99
	100	/** Check if the polytope has a closed surface
	101	*/
	102	virtual bool closed() const
	103	{
	104	for (facet_iterator n(graph_, type_map_); n != lemon::INVALID; ++n)
	105	{
	106	if (!(this->closed(n)))
	107	{
	108	return false;
	109	}
	110	}
	111	return true;
	112	}
	113
	114
	115	/** Add a vertex to the polytope.
	116	*/
	117	virtual node_type addVertex(const point_view_type & p)
	118	{
	119	node_type ret = graph_.addNode();
	120	type_map_[ret] = VERTEX;
	121	vec_map_[ret] = p;
	122	for (int i = 0; i < N; i++)
	123	{
	124	aligns_map_[ret][i] = lemon::INVALID;
	125	}
	126	return ret;
	127	}
	128
	129	/** Erase a facet.
	130	*/
	131	virtual void eraseFacet(const node_type u)
	132	{
	133	vigra_assert(
	134	type_map_[u] == FACET,
	135	"Polytope::eraseFacet(): Node needs to be a facet");
	136	for (auto neighbor : aligns_map_[u])
	137	{
	138	if (neighbor != lemon::INVALID)
	139	{
	140	auto it = std::find(
	141	aligns_map_[neighbor].begin(),
	142	aligns_map_[neighbor].end(),
	143	u);
	144	vigra_assert(
	145	it != aligns_map_[neighbor].end(),
	146	"Polytope::eraseFacet(): Inconsistent aligns map");
	147	*it = lemon::INVALID;
	148	}
	149	}
	150	graph_.erase(u);
	151	}
	152
	153	/** Get the connected elements in the graph that represents the polytope.
	154	If a facet node is inserted, all of its vertices will be returned, if
	155	a vertex node is inserted, all facets having this vertex will be
	156	returned.
	157	*/
	158	virtual std::set<node_type> getConnected(const node_type u) const
	159	{
	160	std::set<node_type> ret;
	161	if (type_map_[u] == FACET)
	162	{
	163	for (out_arc_iterator a(graph_, u); a != lemon::INVALID; ++a)
	164	{
	165	ret.insert(graph_.target(a));
	166	}
	167	}
	168	else
	169	{
	170	for (in_arc_iterator a(graph_, u); a != lemon::INVALID; ++a)
	171	{
	172	ret.insert(graph_.source(a));
	173	}
	174	}
	175	return ret;
	176	}
	177
	178	// TODO remove
	179	virtual ArrayVector<point_view_type> getVertices(const node_type u) const
	180	{
	181	vigra_assert(
	182	type_map_[u] == FACET,
	183	"Polytope::getVertices(): Node must be a facet");
	184	ArrayVector<point_view_type> ret;
	185	for (out_arc_iterator a(graph_, u); a != lemon::INVALID; ++a)
	186	{
	187	ret.push_back(vec_map_[graph_.target(a)]);
	188	}
	189	return ret;
	190	}
	191
	192	/** Get all facets whose normal has a positive scalar product with the
	193	vector to the given vertex.
	194	*/
	195	virtual ArrayVector<node_type> litFacets(const point_view_type & p) const
	196	{
	197	ArrayVector<node_type> ret;
	198	for (facet_iterator n(graph_, type_map_); n != lemon::INVALID; ++n)
	199	{
	200	if (distance(n, p) > 0)
	201	{
	202	ret.push_back(n);
	203	}
	204	}
	205	return ret;
	206	}
	207
	208	/** Remove all vertices that are not part of the polytope mesh.
	209	*/
	210	virtual void tidyUp()
	211	{
	212	std::set<node_type> to_erase;
	213	for (vertex_iterator v(graph_, type_map_); v != lemon::INVALID; ++v)
	214	{
	215	vigra_assert(
	216	type_map_[v] == VERTEX,
	217	"Polytope::tidyUp(): vertex not a vertex");
	218	in_arc_iterator a(graph_, v);
	219	if (a == lemon::INVALID)
	220	{
	221	to_erase.insert(v);
	222	}
	223	}
	224	for (node_type v : to_erase)
	225	{
	226	graph_.erase(v);
	227	}
	228	}
	229
	230	/** Get the distance between a facet and a vertex */
	231	virtual real_type distance(const node_type u, const point_view_type & p) const
	232	{
	233	vigra_assert(
	234	type_map_[u] == FACET,
	235	"Polytope::distance(): Node must be a facet");
	236	out_arc_iterator a(graph_, u);
	237	vigra_assert(
	238	a != lemon::INVALID,
	239	"Polytope::distance(): Invalid facet");
	240
	241	return dot(p - vec_map_[graph_.target(a)], vec_map_[u]);
	242	}
	243
	244	/** Label all elements in the array which are inside the polytope.
	245	*/
	246	virtual unsigned int fill(
	247	MultiArrayView<N, unsigned int> & array,
	248	const unsigned int label,
	249	const point_view_type offset,
	250	const point_view_type scale) const
	251	{
	252	typedef MultiArrayView<N, unsigned int> array_type;
	253
	254	unsigned int ret = 0;
	255	typename array_type::iterator it = array.begin();
	256	for (it = array.begin(); it != array.end(); it++)
	257	{
	258	const typename array_type::difference_type coord = it.template get<0>();
	259	point_type vec;
	260	for (unsigned int i = 0; i < vec.size(); i++)
	261	{
	262	vec[i] = coord[i]*scale[i] + offset[i];
	263	}
	264	if (this->contains(vec))
	265	{
	266	ret++;
	267	*it = label;
	268	}
	269	}
	270	return ret;
	271	}
	272
	273	/** Label all elements in the array which are inside the polytope.
	274	*/
	275	virtual unsigned int fill(
	276	MultiArrayView<N, unsigned int> & array,
	277	const unsigned int label,
	278	const point_view_type offset) const
	279	{
	280	vigra_assert(
	281	closed(),
	282	"Polytope::fill(): Polytope not closed.");
	283	typedef MultiArrayView<N, unsigned int> array_type;
	284
	285	unsigned int ret = 0;
	286	typename array_type::iterator it = array.begin();
	287	for (it = array.begin(); it != array.end(); it++)
	288	{
	289	const typename array_type::difference_type coord = it.template get<0>();
	290	point_type vec;
	291	for (unsigned int i = 0; i < vec.size(); i++)
	292	{
	293	vec[i] = coord[i] + offset[i];
	294	}
	295	if (this->contains(vec))
	296	{
	297	ret++;
	298	*it = label;
	299	}
	300	}
	301	return ret;
	302	}
	303
	304	protected:
	305
	306	virtual bool isConnected(
	307	const node_type vertex,
	308	const node_type facet) const
	309	{
	310	vigra_assert(
	311	type_map_[vertex] == VERTEX,
	312	"Polytope::isConnected(): First node must be a vertex");
	313	vigra_assert(
	314	type_map_[facet] == FACET,
	315	"Polytope::isConnected(): Second node must be a facet");
	316	for (out_arc_iterator a(graph_, facet); a != lemon::INVALID; ++a)
	317	{
	318	if (graph_.target(a) == vertex)
	319	{
	320	return true;
	321	}
	322	}
	323	return false;
	324	}
	325
	326	virtual node_type findNeighbor(
	327	const node_type u,
	328	const difference_type index) const
	329	{
	330	vigra_assert(
	331	type_map_[u] == FACET,
	332	"Polytope::findNeighbor(): Node must be a facet");
	333	vigra_assert(
	334	index < dimension,
	335	"Polytope::findNeighbor(): Invalid index");
	336	vigra_assert(
	337	countOutArcs(graph_, u) == dimension,
	338	"Polytope::findNeighbor(): Bad facet");
	339	out_skip_iterator a(graph_, u, index);
	340	const node_type first_vertex = graph_.target(a);
	341	for (node_type candidate : getConnected(first_vertex))
	342	{
	343	if (candidate != u)
	344	{
	345	out_skip_iterator b(a);
	346	do
	347	{
	348	++b;
	349	if (b == lemon::INVALID)
	350	{
	351	return candidate;
	352	}
	353	} while (isConnected(graph_.target(b), candidate));
	354	}
	355	}
	356	return lemon::INVALID;
	357	}
	358
	359	void assignNeighbors(const node_type u)
	360	{
	361	vigra_assert(
	362	type_map_[u] == FACET,
	363	"Polytope::assignNeighbors(): Node must be facet");
	364	for (int i = 0; i < dimension; i++)
	365	{
	366	aligns_map_[u][i] = this->findNeighbor(u, i);
	367	}
	368	}
	369
	370	void updateInvalidNeighbors(const node_type u)
	371	{
	372	vigra_assert(
	373	type_map_[u] == FACET,
	374	"Polytope::assignNeighbors(): Node must be facet");
	375	for (int i = 0; i < dimension; i++)
	376	{
	377	if (aligns_map_[u][i] == lemon::INVALID)
	378	{
	379	aligns_map_[u][i] = this->findNeighbor(u, i);
	380	}
	381	}
	382	}
	383
	384	ArrayVector<node_type> openEdge(const node_type u)
	385	{
	386	vigra_assert(
	387	type_map_[u] == FACET,
	388	"Polytope::openEdge(): Node must be facet");
	389	vigra_assert(
	390	lemon::countOutArcs(graph_, u) == dimension,
	391	"Polytope::openEdge(): Got invalid facet");
	392	ArrayVector<node_type> ret;
	393	for (int i = 0; i < dimension; i++)
	394	{
	395	if (aligns_map_[u][i] == lemon::INVALID)
	396	{
	397	for (out_skip_iterator a(graph_, u, i); a != lemon::INVALID; ++a)
	398	{
	399	ret.push_back(graph_.target(a));
	400	}
	401	return ret;
	402	}
	403	}
	404	return ret;
	405	}
	406
	407	public:
	408
	409	template <node_enum NodeType>
	410	struct node_type_iterator : public node_type
	411	{
	412	node_type_iterator()
	413	{}
	414
	415	explicit node_type_iterator(
	416	const graph_type & graph,
	417	const typename graph_type::NodeMap<node_enum> & type_map)
	418	: graph_(graph)
	419	, type_map_(type_map)
	420	{
	421	graph_.first(static_cast<node_type &>(*this));
	422	while (this != lemon::INVALID && type_map_[this] != NodeType)
	423	{
	424	graph_.next(*this);
	425	}
	426	}
	427
	428	node_type_iterator<NodeType> & operator++()
	429	{
	430	while (*this != lemon::INVALID)
	431	{
	432	graph_.next(*this);
	433	if (type_map_[*this] == NodeType)
	434	{
	435	return *this;
	436	}
	437	}
	438	return *this;
	439	}
	440
	441	bool operator==(lemon::Invalid i) const
	442	{
	443	return (static_cast<node_type>(*this) == i);
	444	}
	445
	446	bool operator!=(lemon::Invalid i) const
	447	{
	448	return (static_cast<node_type>(*this) != i);
	449	}
	450
	451	const graph_type & graph_;
	452	const typename graph_type::NodeMap<node_enum> & type_map_;
	453	};
	454
	455	struct out_skip_iterator : public arc_type
	456	{
	457	out_skip_iterator()
	458	{}
	459
	460	explicit out_skip_iterator(
	461	const graph_type & graph,
	462	const node_type & node,
	463	const difference_type skip)
	464	: graph_(graph)
	465	, skip_(skip)
	466	, index_(0)
	467	{
	468	graph_.firstOut(*this, node);
	469	if (skip_ == 0)
	470	{
	471	graph_.nextOut(*this);
	472	}
	473	}
	474
	475	out_skip_iterator & operator++()
	476	{
	477	++index_;
	478	graph_.nextOut(*this);
	479	if (index_ == skip_)
	480	{
	481	graph_.nextOut(*this);
	482	}
	483	return *this;
	484	}
	485
	486	bool operator==(lemon::Invalid i) const
	487	{
	488	return (static_cast<arc_type>(*this) == i);
	489	}
	490
	491	bool operator!=(lemon::Invalid i) const
	492	{
	493	return (static_cast<arc_type>(*this) != i);
	494	}
	495
	496	difference_type index() const
	497	{
	498	return index_;
	499	}
	500
	501	const graph_type & graph_;
	502	const difference_type skip_;
	503	difference_type index_;
	504	};
	505
	506	graph_type graph_;
	507	typename graph_type::NodeMap<node_enum> type_map_;
	508	typename graph_type::NodeMap<point_type> vec_map_;
	509	typename graph_type::NodeMap<TinyVector<node_type, N> > aligns_map_;
	510	};
	511
	512	/** \brief Specialization of the polytope to polytopes which forms a star
	513	domain.
	514	*/
	515	template <unsigned int N, class T>
	516	class StarPolytope : public Polytope<N, T>
	517	{
	518	public:
	519
	520	typedef Polytope<N, T> base_type;
	521	typedef typename base_type::coordinate_type coordinate_type;
	522	typedef typename base_type::real_type real_type;
	523	typedef typename base_type::point_type point_type;
	524	typedef typename base_type::point_view_type point_view_type;
	525	typedef typename base_type::difference_type difference_type;
	526	typedef typename base_type::graph_type graph_type;
	527	typedef typename base_type::node_type node_type;
	528	typedef typename base_type::arc_type arc_type;
	529	typedef typename base_type::node_iterator node_iterator;
	530	typedef typename base_type::in_arc_iterator in_arc_iterator;
	531	typedef typename base_type::out_arc_iterator out_arc_iterator;
	532	typedef typename base_type::out_skip_iterator out_skip_iterator;
	533	typedef typename base_type::facet_iterator facet_iterator;
	534	typedef typename base_type::vertex_iterator vertex_iterator;
	535
	536	using base_type::dimension;
	537	using base_type::graph_;
	538	using base_type::vec_map_;
	539	using base_type::type_map_;
	540	using base_type::aligns_map_;
	541	using base_type::INVALID;
	542	using base_type::FACET;
	543	using base_type::VERTEX;
	544
	545	public:
	546
	547	/** Constructor creates an empty StarPolytope with its center a the orign.
	548	*/
	549	StarPolytope()
	550	: base_type()
	551	, center_(point_type())
	552	{}
	553
	554	/** Copy constructor.
	555	*/
	556	StarPolytope(const point_view_type & center)
	557	: base_type()
	558	, center_(center)
	559	{}
	560
	561	/** Constructor for the 2-dimensional case taking three vertices and the
	562	center.
	563	*/
	564	StarPolytope(
	565	const point_view_type & a,
	566	const point_view_type & b,
	567	const point_view_type & c,
	568	const point_view_type & center)
	569	: base_type()
	570	, center_(center)
	571	{
	572	vigra_precondition(
	573	dimension == 2,
	574	"StarPolytope::StarPolytope(): Signature only for use in 2D");
	575	node_type na = this->addVertex(a);
	576	node_type nb = this->addVertex(b);
	577	node_type nc = this->addVertex(c);
	578	this->addFacet(nb, nc);
	579	this->addFacet(na, nc);
	580	this->addFacet(na, nb);
	581	}
	582
	583	/** Constructor for the 3-dimensional case taking four vertices and the
	584	center.
	585	*/
	586	StarPolytope(
	587	const point_view_type & a,
	588	const point_view_type & b,
	589	const point_view_type & c,
	590	const point_view_type & d,
	591	const point_view_type & center)
	592	: base_type()
	593	, center_(center)
	594	{
	595	vigra_precondition(
	596	dimension == 3,
	597	"StarPolytope::StarPolytope(): Signature only for use in 3D");
	598	node_type na = this->addVertex(a);
	599	node_type nb = this->addVertex(b);
	600	node_type nc = this->addVertex(c);
	601	node_type nd = this->addVertex(d);
	602	this->addFacet(nb, nc, nd);
	603	this->addFacet(na, nc, nd);
	604	this->addFacet(na, nb, nd);
	605	this->addFacet(na, nb, nc);
	606	}
	607
	608	/** Get the center of the star domain.
	609	*/
	610	virtual point_type getCenter() const
	611	{
	612	return center_;
	613	}
	614
	615	virtual void assignNormal(const node_type & u)
	616	{
	617	vigra_assert(
	618	type_map_[u] == FACET,
	619	"StarPolytope::assignNormal(): Node needs to be a facet node");
	620	MultiArray<2, real_type> mat(dimension-1, dimension);
	621	out_arc_iterator a(graph_, u);
	622	point_view_type vertex = vec_map_[graph_.target(a)];
	623	++a;
	624	for (int i = 0; a != lemon::INVALID; ++a, ++i)
	625	{
	626	const point_type vec = vec_map_[graph_.target(a)] - vertex;
	627	std::copy(vec.begin(), vec.end(), rowVector(mat, i).begin());
	628	}
	629	point_view_type normal = vec_map_[u];
	630	for (int i = 0; i < dimension; i++)
	631	{
	632	normal[i] = 0;
	633	}
	634	for (auto permutation : permutations_)
	635	{
	636	coordinate_type val = 1;
	637	for (int i = 0; i < dimension - 1; i++)
	638	{
	639	val *= mat(i, permutation[i]);
	640	}
	641	val *= permutation.sign();
	642	normal[permutation[dimension - 1]] += val;
	643	}
	644	if (dot(normal, vertex - center_) < 0)
	645	{
	646	normal *= -1;
	647	}
	648	}
	649
	650	/** Add a facet to a 2-dimensional polytope.
	651	*/
	652	virtual node_type addFacet(const node_type & a, const node_type & b)
	653	{
	654	vigra_precondition(
	655	dimension == 2,
	656	"StarPolytope::addFacet(): Signature only for use in 2D");
	657	node_type ret = graph_.addNode();
	658	type_map_[ret] = FACET;
	659	graph_.addArc(ret, a);
	660	graph_.addArc(ret, b);
	661	vigra_assert(
	662	lemon::countOutArcs(graph_, ret) == dimension,
	663	"StarPolytope::addFacet(): Invalid facet created");
	664	this->assignNormal(ret);
	665	this->assignNeighbors(ret);
	666	for (auto facet : aligns_map_[ret])
	667	{
	668	if (facet != lemon::INVALID)
	669	{
	670	vigra_assert(
	671	type_map_[facet] == FACET,
	672	"StarPolytope::addFacet(): Node must be facet");
	673	this->updateInvalidNeighbors(facet);
	674	}
	675	}
	676	return ret;
	677	}
	678
	679	/** Add a facet to a 3-dimensional polytope.
	680	*/
	681	virtual node_type addFacet(
	682	const node_type & a,
	683	const node_type & b,
	684	const node_type & c)
	685	{
	686	vigra_precondition(
	687	dimension == 3,
	688	"StarPolytope::addFacet(): Signature only for use in 3D");
	689	node_type ret = graph_.addNode();
	690	type_map_[ret] = FACET;
	691	graph_.addArc(ret, a);
	692	graph_.addArc(ret, b);
	693	graph_.addArc(ret, c);
	694	vigra_assert(
	695	lemon::countOutArcs(graph_, ret) == dimension,
	696	"StarPolytope::addFacet(): Invalid facet created");
	697	this->assignNormal(ret);
	698	this->assignNeighbors(ret);
	699	for (auto facet : aligns_map_[ret])
	700	{
	701	if (facet != lemon::INVALID)
	702	{
	703	vigra_assert(
	704	type_map_[facet] == FACET,
	705	"StarPolytope::addFacet(): Node must be facet");
	706	this->updateInvalidNeighbors(facet);
	707	}
	708	}
	709	return ret;
	710	}
	711
	712	virtual void close()
	713	{
	714	vigra_precondition(
	715	lemon::countNodes(graph_) == dimension + 1,
	716	"StarPolytope::close(): Can only close for dim+1 vertices");
	717	// Set center of polytope
	718	{
	719	vertex_iterator v(graph_, type_map_);
	720	center_ = vec_map_[v];
	721	for (++v; v != lemon::INVALID; ++v)
	722	{
	723	center_ += vec_map_[v];
	724	}
	725	center_ /= static_cast<real_type>(dimension + 1);
	726	}
	727	// Create facets
	728	for (int i = 0; i < dimension + 1; i++)
	729	{
	730	node_type facet = graph_.addNode();
	731	type_map_[facet] = FACET;
	732	vertex_iterator v(graph_, type_map_);
	733	for (int j = 0; j < dimension; ++j, ++v)
	734	{
	735	if (i == j)
	736	{
	737	++v;
	738	}
	739	graph_.addArc(facet, v);
	740	}
	741	vigra_assert(
	742	lemon::countOutArcs(graph_, facet) == dimension,
	743	"StarPolytope::close(): Invalid facet created");
	744	this->assignNormal(facet);
	745	this->assignNeighbors(facet);
	746	for (auto neighbor : aligns_map_[facet])
	747	{
	748	if (neighbor != lemon::INVALID)
	749	{
	750	vigra_assert(
	751	type_map_[neighbor] == FACET,
	752	"StarPolytope::close(): Node must be facet");
	753	this->updateInvalidNeighbors(neighbor);
	754	}
	755	}
	756	}
	757	}
	758
	759	virtual bool contains(const node_type & n, const point_view_type & p) const
	760	{
	761	vigra_assert(
	762	type_map_[n] == FACET,
	763	"StarPolytope::contains(): Node needs do be a facet");
	764	ArrayVector<point_view_type> vertices = this->getVertices(n);
	765	vertices.push_back(center_);
	766	MultiArray<2, coordinate_type> jp_mat(dimension, dimension);
	767	MultiArray<2, coordinate_type> jj_mat(dimension, dimension);
	768	for (int j = 0; j < dimension + 1; j++)
	769	{
	770	for (int i = 0, ii = 0; i < dimension; i++, ii++)
	771	{
	772	if (i == j)
	773	{
	774	ii++;
	775	}
	776	{
	777	const point_type vec = vertices[ii] - p;
	778	std::copy(vec.begin(), vec.end(), rowVector(jp_mat, i).begin());
	779	}
	780	{
	781	const point_type vec = vertices[ii] - vertices[j];
	782	std::copy(vec.begin(), vec.end(), rowVector(jj_mat, i).begin());
	783	}
	784	}
	785	const coordinate_type jj_det = linalg::determinant(jj_mat);
	786	const coordinate_type jp_det = linalg::determinant(jp_mat);
	787	const coordinate_type eps = std::numeric_limits<T>::epsilon() * 2;
	788	if (((jj_det > 0) != (jp_det > 0)) && abs(jp_det) > eps)
	789	{
	790	return false;
	791	}
	792	}
	793	return true;
	794	}
	795
	796	/** Check if a point is inside the polytope.
	797	*/
	798	virtual bool contains(const point_view_type & p) const
	799	{
	800	for (facet_iterator n(graph_, type_map_); n != lemon::INVALID; ++n)
	801	{
	802	if (contains(n, p))
	803	{
	804	return true;
	805	}
	806	}
	807	return false;
	808	}
	809
	810	virtual real_type nVolume(const node_type & n) const
	811	{
	812	vigra_assert(
	813	type_map_[n] == FACET,
	814	"StarPolytope::nVolume(): Node needs do be a facet");
	815	MultiArray<2, coordinate_type> mat(dimension, dimension);
	816	real_type fac = 1;
	817	out_arc_iterator a(graph_, n);
	818	for (int i = 0; i < dimension; ++i, ++a)
	819	{
	820	fac *= (i+1);
	821	const point_type vec = vec_map_[graph_.target(a)] - center_;
	822	std::copy(vec.begin(), vec.end(), rowVector(mat, i).begin());
	823	}
	824	return abs(linalg::determinant(mat) / fac);
	825	}
	826
	827	/** Calculate the volume of the polytope.
	828	*/
	829	virtual real_type nVolume() const
	830	{
	831	real_type ret = 0;
	832	for (facet_iterator n(graph_, type_map_); n != lemon::INVALID; ++n)
	833	{
	834	ret += this->nVolume(n);
	835	}
	836	return ret;
	837	}
	838
	839	virtual real_type nSurface(const node_type & n) const
	840	{
	841	vigra_assert(
	842	type_map_[n] == FACET,
	843	"StarPolytope::nVolume(): Node needs do be a facet");
	844	MultiArray<2, coordinate_type> mat(dimension, dimension);
	845	real_type factor = vec_map_[n].magnitude();
	846	out_arc_iterator a(graph_, n);
	847	const point_view_type vec = vec_map_[graph_.target(a)];
	848	++a;
	849	for (int i = 1; i < dimension; ++i, ++a)
	850	{
	851	factor *= i;
	852	const point_type tmp = vec_map_[graph_.target(a)] - vec;
	853	std::copy(tmp.begin(), tmp.end(), rowVector(mat, i).begin());
	854	}
	855	const point_type tmp = vec_map_[n];
	856	std::copy(tmp.begin(), tmp.end(), rowVector(mat, 0).begin());
	857	return abs(linalg::determinant(mat)) / factor;
	858	}
	859
	860	/** Calculate the surface of the polytope.
	861	*/
	862	virtual real_type nSurface() const
	863	{
	864	real_type ret = 0;
	865	for (facet_iterator n(graph_, type_map_); n != lemon::INVALID; ++n)
	866	{
	867	ret += this->nSurface(n);
	868	}
	869	return ret;
	870	}
	871
	872	protected:
	873
	874	PlainChangesPermutations<N> permutations_;
	875	point_type center_;
	876	};
	877
	878	/** Specialization of the StarPolytope to polytopes which have a convex domain.
	879	*/
	880	template <unsigned int N, class T>
	881	class ConvexPolytope : public StarPolytope<N, T>
	882	{
	883	public:
	884
	885	typedef StarPolytope<N, T> base_type;
	886	typedef typename base_type::coordinate_type coordinate_type;
	887	typedef typename base_type::real_type real_type;
	888	typedef typename base_type::point_type point_type;
	889	typedef typename base_type::point_view_type point_view_type;
	890	typedef typename base_type::difference_type difference_type;
	891	typedef typename base_type::graph_type graph_type;
	892	typedef typename base_type::node_type node_type;
	893	typedef typename base_type::arc_type arc_type;
	894	typedef typename base_type::node_iterator node_iterator;
	895	typedef typename base_type::in_arc_iterator in_arc_iterator;
	896	typedef typename base_type::out_arc_iterator out_arc_iterator;
	897	typedef typename base_type::out_skip_iterator out_skip_iterator;
	898	typedef typename base_type::facet_iterator facet_iterator;
	899	typedef typename base_type::vertex_iterator vertex_iterator;
	900
	901	using base_type::dimension;
	902	using base_type::graph_;
	903	using base_type::vec_map_;
	904	using base_type::type_map_;
	905	using base_type::aligns_map_;
	906	using base_type::INVALID;
	907	using base_type::FACET;
	908	using base_type::VERTEX;
	909
	910	public:
	911
	912	ConvexPolytope()
	913	: base_type()
	914	{}
	915
	916	ConvexPolytope(const point_view_type & center)
	917	: base_type(center)
	918	{}
	919
	920	ConvexPolytope(
	921	const point_view_type & a,
	922	const point_view_type & b,
	923	const point_view_type & c)
	924	: base_type(a, b, c, (a + b + c) / 3)
	925	{}
	926
	927	ConvexPolytope(
	928	const point_view_type & a,
	929	const point_view_type & b,
	930	const point_view_type & c,
	931	const point_view_type & d)
	932	: base_type(a, b, c, d, (a + b + c + d) / 4)
	933	{}
	934
	935	protected:
	936
	937	virtual void closeFacet(
	938	const node_type & vertex,
	939	const node_type & facet)
	940	{
	941	vigra_assert(
	942	type_map_[vertex] == VERTEX,
	943	"ConvexPolytope::closeFacet(): Vertex needs to be a vertex node");
	944	vigra_assert(
	945	type_map_[facet] == FACET,
	946	"ConvexPolytope::closeFacet(): Facet needs to be a facet node");
	947	vigra_assert(
	948	(this->getConnected(facet)).count(vertex) == 0,
	949	"ConvexPolytope::closeFacet(): Cannot close facet with vertex");
	950
	951	while (!(this->closed(facet)))
	952	{
	953	ArrayVector<node_type> vertices = this->openEdge(facet);
	954	vigra_assert(
	955	vertices.size() == (dimension - 1),
	956	"StarPolytope::closeFacet(): Invalid facet");
	957	node_type new_facet = graph_.addNode();
	958	type_map_[new_facet] = FACET;
	959	graph_.addArc(new_facet, vertex);
	960	for (auto n : vertices)
	961	{
	962	graph_.addArc(new_facet, n);
	963	}
	964	vigra_assert(
	965	lemon::countOutArcs(graph_, new_facet) == dimension,
	966	"ConvexPolytope::closeFacet(): Invalid facet created");
	967	this->assignNormal(new_facet);
	968	this->assignNeighbors(new_facet);
	969	for (auto neighbor : aligns_map_[new_facet])
	970	{
	971	if (neighbor != lemon::INVALID)
	972	{
	973	vigra_assert(
	974	type_map_[facet] == FACET,
	975	"StarPolytope::addFacet(): Node must be facet");
	976	this->updateInvalidNeighbors(neighbor);
	977	}
	978	}
	979	}
	980	}
	981
	982	public:
	983
	984	virtual bool contains(const node_type & n, const point_view_type & p) const
	985	{
	986	vigra_assert(
	987	type_map_[n] == FACET,
	988	"ConvexPolytope::contains(): Node needs do be a facet");
	989	const out_arc_iterator a(graph_, n);
	990	const point_view_type vertex = vec_map_[graph_.target(a)];
	991	const point_view_type normal = vec_map_[n];
	992	const real_type scalar = dot(p - vertex, normal);
	993	return (scalar < std::numeric_limits<T>::epsilon() * 2);
	994	}
	995
	996	virtual bool contains(const point_view_type & p) const
	997	{
	998	for (facet_iterator n(graph_, type_map_); n != lemon::INVALID; ++n)
	999	{
	1000	if (!contains(n, p))
	1001	{
	1002	return false;
	1003	}
	1004	}
	1005	return true;
	1006	}
	1007
	1008	/** Expand the polytope to the given point if it's outside of the current
	1009	polytope, such that the new polytope is still convex.
	1010	*/
	1011	virtual void addExtremeVertex(const point_view_type & p)
	1012	{
	1013	vigra_assert(
	1014	this->closed(),
	1015	"ConvexPolytope::addExtremeVertex(): Polytope needs to be closed");
	1016	ArrayVector<node_type> lit_facets = this->litFacets(p);
	1017	if (lit_facets.size() > 0)
	1018	{
	1019	std::set<node_type> open_facets;
	1020	for (node_type lit_facet : lit_facets)
	1021	{
	1022	for (auto con : aligns_map_[lit_facet])
	1023	{
	1024	if (con != lemon::INVALID)
	1025	{
	1026	vigra_assert(
	1027	type_map_[con] == FACET,
	1028	"ConvexPolytope::addExtremeVertex(): "
	1029	"facet not a facet");
	1030	open_facets.insert(con);
	1031	}
	1032	}
	1033	open_facets.erase(lit_facet);
	1034	this->eraseFacet(lit_facet);
	1035	}
	1036	this->tidyUp();
	1037	node_type new_vertex = this->addVertex(p);
	1038	for (auto open_facet : open_facets)
	1039	{
	1040	this->closeFacet(new_vertex, open_facet);
	1041	}
	1042	}
	1043	}
	1044	};
	1045
	1046	} /* namespace vigra */
	1047
	1048	#endif /* VIGRA_POLYTOPE_HXX */

+2

-2

include/vigra/print_backtrace.hxx less more

52	52	signal(SIGSEGV, &vigra_print_backtrace); // catch the desired signal
53	53
54	54	run_buggy_code();
55		}
	55	}
56	56	*/
57	57
58	58	#include <execinfo.h>
59	59	#include <stdio.h>
60	60	#include <stdlib.h>
61
	61
62	62
63	63	static char * program_name;
64	64

+3

-3

include/vigra/priority_queue.hxx less more

429	429	indices_(maxSize_+1, -1),
430	430	priorities_(maxSize_+1)
431	431	{
432		for(int i = 0; i <= maxSize_; i++)
	432	for(unsigned i = 0; i <= maxSize_; i++)
433	433	indices_[i] = -1;
434	434	}
435	435

551	551
552	552	void bubbleDown(int k) {
553	553	int j;
554		while(2*k <= currentSize_) {
	554	while(static_cast<unsigned>(2*k) <= currentSize_) {
555	555	j = 2*k;
556		if(j < currentSize_ && _gt(priorities_[heap_[j]] , priorities_[heap_[j+1]]) )
	556	if(static_cast<unsigned>(j) < currentSize_ && _gt(priorities_[heap_[j]] , priorities_[heap_[j+1]]) )
557	557	j++;
558	558	if( _leqt(priorities_[heap_[k]] , priorities_[heap_[j]]))
559	559	break;

+4

-1

include/vigra/projective_registration.hxx less more

85	85
86	86	}
87	87
88		vigra_assert(linearSolve(A, b, res),
	88	bool solvable = linearSolve(A, b, res);
	89	// silence unused variable warning in release mode
	90	static_cast<void>(solvable);
	91	vigra_assert(solvable,
89	92	"projectiveMatrix2DFromCorrespondingPoints(): singular solution matrix.");
90	93
91	94	linalg::TemporaryMatrix<double> projectiveMat(3,3);

+9

-9

include/vigra/python_graph.hxx less more

77	77	struct NodeHolder : GRAPH::Node
78	78	{
79	79	typedef typename GRAPH::Node Node;
80		NodeHolder(const lemon::Invalid & iv = lemon::INVALID)
	80	NodeHolder(const lemon::Invalid & /iv/ = lemon::INVALID)
81	81	: Node(lemon::INVALID),
82	82	graph_(NULL)
83	83	{}

105	105	{
106	106
107	107	typedef typename GRAPH::Edge Edge;
108		EdgeHolder(const lemon::Invalid & iv = lemon::INVALID)
	108	EdgeHolder(const lemon::Invalid & /iv/ = lemon::INVALID)
109	109	: Edge(lemon::INVALID),
110	110	graph_(NULL)
111	111	{}

138	138	template<class GRAPH>
139	139	struct ArcHolder: GRAPH::Arc {
140	140	typedef typename GRAPH::Arc Arc;
141		ArcHolder(const lemon::Invalid & iv = lemon::INVALID)
	141	ArcHolder(const lemon::Invalid & /iv/ = lemon::INVALID)
142	142	: Arc(lemon::INVALID),
143	143	graph_(NULL)
144	144	{}

530	530	return NumpyArray<AD,int>::ArrayTraits::taggedShape(IntrinsicGraphShape<Graph>::intrinsicArcMapShape(graph),"e");
531	531	}
532	532
533		static AxisInfo axistagsNodeMap(const Graph & graph){
	533	static AxisInfo axistagsNodeMap(const Graph & /graph/){
534	534	return AxisInfo("n");
535	535	}
536		static AxisInfo axistagsEdgeMap(const Graph & graph){
	536	static AxisInfo axistagsEdgeMap(const Graph & /graph/){
537	537	return AxisInfo("e");
538	538	}
539		static AxisTags axistagsArcMap(const Graph & graph){
	539	static AxisTags axistagsArcMap(const Graph & /graph/){
540	540	return AxisInfo("e");
541	541	}
542	542	};

560	560	static TaggedShape taggedArcMapShape(const Graph & graph){ \
561	561	return NumpyArray<AD,int>::ArrayTraits::taggedShape(IntrinsicGraphShape<Graph>::intrinsicArcMapShape(graph),ta); \
562	562	} \
563		static AxisInfo axistagsNodeMap(const Graph & graph){ \
	563	static AxisInfo axistagsNodeMap(const Graph & /graph/){ \
564	564	return AxisInfo(tn); \
565	565	} \
566		static AxisInfo axistagsEdgeMap(const Graph & graph){ \
	566	static AxisInfo axistagsEdgeMap(const Graph & /graph/){ \
567	567	return AxisInfo(te); \
568	568	} \
569		static AxisTags axistagsArcMap(const Graph & graph){ \
	569	static AxisTags axistagsArcMap(const Graph & /graph/){ \
570	570	return AxisInfo(ta); \
571	571	} \
572	572	};

+7

-7

include/vigra/python_utility.hxx less more

234	234	inline python_ptr pythonFromData(char const * str)
235	235	{
236	236	#if PY_MAJOR_VERSION < 3
237		return python_ptr(PyString_FromString(str), python_ptr::new_nonzero_reference);
	237	return python_ptr(PyString_FromString(str), python_ptr::new_nonzero_reference);
238	238	#else
239		return python_ptr(PyUnicode_FromString(str), python_ptr::new_nonzero_reference);
	239	return python_ptr(PyUnicode_FromString(str), python_ptr::new_nonzero_reference);
240	240	#endif
241	241	}
242	242
243	243	inline python_ptr pythonFromData(std::string const & str)
244	244	{
245		return pythonFromData(str.c_str());
	245	return pythonFromData(str.c_str());
246	246	}
247	247
248	248	#define VIGRA_PYTHON_FROM_DATA(type, fct, cast_type) \

338	338	return data && PyString_Check(data)
339	339	? std::string(PyString_AsString(data))
340	340	#else
341		python_ptr ascii(PyUnicode_AsASCIIString(data), python_ptr::keep_count);
	341	python_ptr ascii(PyUnicode_AsASCIIString(data), python_ptr::keep_count);
342	342	return data && PyBytes_Check(ascii)
343	343	? std::string(PyBytes_AsString(ascii))
344	344	#endif

351	351	return data && PyString_Check(data)
352	352	? std::string(PyString_AsString(data))
353	353	#else
354		python_ptr ascii(PyUnicode_AsASCIIString(data), python_ptr::keep_count);
355		return data && PyBytes_Check(ascii)
356		? std::string(PyBytes_AsString(ascii))
	354	python_ptr ascii(PyUnicode_AsASCIIString(data), python_ptr::keep_count);
	355	return data && PyBytes_Check(ascii)
	356	? std::string(PyBytes_AsString(ascii))
357	357	#endif
358	358	: defaultVal;
359	359	}

+5

-5

include/vigra/random_forest/rf_algorithm.hxx less more

996	996	{
997	997	public:
998	998	template<class Nde>
999		bool operator()(Nde & cur, int level, Nde parent, bool infm)
	999	bool operator()(Nde & cur, int /level/, Nde parent, bool /infm/)
1000	1000	{
1001	1001	if(parent.hasData_)
1002	1002	cur.status() = std::min(parent.status(), cur.status());

1044	1044	}
1045	1045
1046	1046	template<class Nde>
1047		bool operator()(Nde & cur, int level, Nde parent, bool infm)
	1047	bool operator()(Nde & cur, int /level/, Nde parent, bool /infm/)
1048	1048	{
1049	1049	graphviz << "node" << cur.index() << " [style=\"filled\"][label = \" #Feats: "<< cur.columns_size() << "\\n";
1050	1050	graphviz << " status: " << cur.status() << "\\n";

1103	1103	/** Allocate enough memory
1104	1104	*/
1105	1105	template<class RF, class PR>
1106		void visit_at_beginning(RF const & rf, PR const & pr)
	1106	void visit_at_beginning(RF const & rf, PR const & /pr/)
1107	1107	{
1108	1108	Int32 const class_count = rf.ext_param_.class_count_;
1109	1109	Int32 const column_count = rf.ext_param_.column_count_+1;

1128	1128	* \sa FieldProxy
1129	1129	*/
1130	1130	template<class RF, class PR, class SM, class ST>
1131		void after_tree_ip_impl(RF& rf, PR & pr, SM & sm, ST & st, int index)
	1131	void after_tree_ip_impl(RF& rf, PR & pr, SM & sm, ST & /st/, int index)
1132	1132	{
1133	1133	typedef MultiArrayShape<2>::type Shp_t;
1134	1134	Int32 column_count = rf.ext_param_.column_count_ +1;

1228	1228	/** Normalise variable importance after the number of trees is known.
1229	1229	*/
1230	1230	template<class RF, class PR>
1231		void visit_at_end(RF & rf, PR & pr)
	1231	void visit_at_end(RF & rf, PR & /pr/)
1232	1232	{
1233	1233	NormalizeStatus nrm(rf.tree_count());
1234	1234	clustering.iterate(nrm);

+59

-54

include/vigra/random_forest/rf_common.hxx less more

73	73	};
74	74
75	75	/* \brief chooses between default type and type supplied
76		*
	76	*
77	77	* This is an internal class and you shouldn't really care about it.
78	78	* Just pass on used in RandomForest.learn()
79	79	* Usage:
80	80	*\code
81		* // example: use container type supplied by user or ArrayVector if
	81	* // example: use container type supplied by user or ArrayVector if
82	82	* // rf_default() was specified as argument;
83	83	* template<class Container_t>
84	84	* void do_some_foo(Container_t in)
85	85	* {
86	86	* typedef ArrayVector<int> Default_Container_t;
87	87	* Default_Container_t default_value;
88		* Value_Chooser<Container_t, Default_Container_t>
	88	* Value_Chooser<Container_t, Default_Container_t>
89	89	* choose(in, default_value);
90	90	*
91		* // if the user didn't care and the in was of type
	91	* // if the user didn't care and the in was of type
92	92	* // RF_DEFAULT then default_value is used.
93	93	* do_some_more_foo(choose.value());
94	94	* }

102	102	typedef T type;
103	103	static T & choose(T & t, C &)
104	104	{
105		return t;
	105	return t;
106	106	}
107	107	};
108	108

111	111	{
112	112	public:
113	113	typedef C type;
114
	114
115	115	static C & choose(detail::RF_DEFAULT &, C & c)
116	116	{
117		return c;
	117	return c;
118	118	}
119	119	};
120	120

147	147	RF_ALL};
148	148
149	149
150		/** \addtogroup MachineLearning
	150	/** \addtogroup MachineLearning
151	151	**/
152	152	//@{
153	153

193	193	int mtry_;
194	194	int (*mtry_func_)(int) ;
195	195
196		bool predict_weighted_;
	196	bool predict_weighted_;
197	197	int tree_count_;
198	198	int min_split_node_size_;
199	199	bool prepare_online_learning_;

206	206	{
207	207	return 12;
208	208	}
209
	209
210	210
211	211	bool operator==(RandomForestOptions & rhs) const
212	212	{
213	213	bool result = true;
214		#define COMPARE(field) result = result && (this->field == rhs.field);
	214	#define COMPARE(field) result = result && (this->field == rhs.field);
215	215	COMPARE(training_set_proportion_);
216	216	COMPARE(training_set_size_);
217	217	COMPARE(training_set_calc_switch_);

234	234	void unserialize(Iter const & begin, Iter const & end)
235	235	{
236	236	Iter iter = begin;
237		vigra_precondition(static_cast<int>(end - begin) == serialized_size(),
	237	vigra_precondition(static_cast<int>(end - begin) == serialized_size(),
238	238	"RandomForestOptions::unserialize():"
239	239	"wrong number of parameters");
240	240	#define PULL(item_, type_) item_ = type_(*iter); ++iter;

256	256	void serialize(Iter const & begin, Iter const & end) const
257	257	{
258	258	Iter iter = begin;
259		vigra_precondition(static_cast<int>(end - begin) == serialized_size(),
	259	vigra_precondition(static_cast<int>(end - begin) == serialized_size(),
260	260	"RandomForestOptions::serialize():"
261	261	"wrong number of parameters");
262	262	#define PUSH(item_) *iter = double(item_); ++iter;

288	288	PUSH(predict_weighted_);
289	289	#undef PUSH
290	290	}
291
	291
292	292	void make_from_map(map_type & in) // -> const: .operator[] -> .find
293	293	{
294		#define PULL(item_, type_) item_ = type_(in[#item_][0]);
295		#define PULLBOOL(item_, type_) item_ = type_(in[#item_][0] > 0);
	294	#define PULL(item_, type_) item_ = type_(in[#item_][0]);
	295	#define PULLBOOL(item_, type_) item_ = type_(in[#item_][0] > 0);
296	296	PULL(training_set_proportion_,double);
297	297	PULL(training_set_size_, int);
298	298	PULL(mtry_, int);

301	301	PULLBOOL(sample_with_replacement_, bool);
302	302	PULLBOOL(prepare_online_learning_, bool);
303	303	PULLBOOL(predict_weighted_, bool);
304
	304
305	305	PULL(training_set_calc_switch_, (RF_OptionTag)(int));
306	306
307	307	PULL(stratification_method_, (RF_OptionTag)(int));
308	308	PULL(mtry_switch_, (RF_OptionTag)(int));
309
	309
310	310	/don't pull/
311	311	//PULL(mtry_func_!=0, int);
312	312	//PULL(training_set_func,int);

325	325	PUSH(sample_with_replacement_, bool);
326	326	PUSH(prepare_online_learning_, bool);
327	327	PUSH(predict_weighted_, bool);
328
	328
329	329	PUSH(training_set_calc_switch_, RF_OptionTag);
330	330	PUSH(stratification_method_, RF_OptionTag);
331	331	PUSH(mtry_switch_, RF_OptionTag);
332
	332
333	333	PUSHFUNC(mtry_func_, int);
334	334	PUSHFUNC(training_set_func_,int);
335	335	#undef PUSH

354	354	mtry_(0),
355	355	mtry_func_(0),
356	356	predict_weighted_(false),
357		tree_count_(256),
	357	tree_count_(255),
358	358	min_split_node_size_(1),
359	359	prepare_online_learning_(false)
360	360	{}

399	399	return *this;
400	400	}
401	401
402		/**\brief specify the fraction of the total number of samples
403		* used per tree for learning.
	402	/**\brief specify the fraction of the total number of samples
	403	* used per tree for learning.
404	404	*
405	405	* This value should be in [0.0 1.0] if sampling without
406	406	* replacement has been specified.

415	415	}
416	416
417	417	/**\brief directly specify the number of samples per tree
	418	*
	419	* This value should not be higher than the total number of
	420	* samples if sampling without replacement has been specified.
418	421	*/
419	422	RandomForestOptions & samples_per_tree(int in)
420	423	{

435	438	training_set_calc_switch_ = RF_FUNCTION;
436	439	return *this;
437	440	}
438
	441
439	442	/**\brief weight each tree with number of samples in that node
440	443	*/
441	444	RandomForestOptions & predict_weighted()

448	451	*
449	452	* Use one of the built in mappings to calculate mtry from the number
450	453	* of columns in the input feature data.
451		* \param in possible values: RF_LOG, RF_SQRT or RF_ALL
452		* <br> default: RF_SQRT.
	454	* \param in possible values:
	455	* - RF_LOG (the number of features considered for each split is \f$ 1+\lfloor \log(n_f)/\log(2) \rfloor \f$ as in Breiman's original paper),
	456	* - RF_SQRT (default, the number of features considered for each split is \f$ \lfloor \sqrt{n_f} + 0.5 \rfloor \f$)
	457	* - RF_ALL (all features are considered for each split)
453	458	*/
454	459	RandomForestOptions & features_per_node(RF_OptionTag in)
455	460	{

491	496	*
492	497	* <br> Default: 255.
493	498	*/
494		RandomForestOptions & tree_count(int in)
	499	RandomForestOptions & tree_count(unsigned int in)
495	500	{
496	501	tree_count_ = in;
497	502	return *this;

513	518	};
514	519
515	520
516		/** \brief problem types
	521	/* \brief problem types
517	522	*/
518	523	enum Problem_t{REGRESSION, CLASSIFICATION, CHECKLATER};
519	524

551	556	int actual_msample_; // number if in-bag samples per tree
552	557
553	558	Problem_t problem_type_; // classification or regression
554
	559
555	560	int used_; // this ProblemSpec is valid
556	561	ArrayVector<double> class_weights_; // if classes have different importance
557	562	int is_weighted_; // class_weights_ are used
558	563	double precision_; // termination criterion for regression loss
559		int response_size_;
560
561		template<class T>
	564	int response_size_;
	565
	566	template<class T>
562	567	void to_classlabel(int index, T & out) const
563	568	{
564	569	out = T(classes[index]);
565	570	}
566		template<class T>
	571	template<class T>
567	572	int to_classIndex(T index) const
568	573	{
569	574	return std::find(classes.begin(), classes.end(), index) - classes.begin();

571	576
572	577	#define EQUALS(field) field(rhs.field)
573	578	ProblemSpec(ProblemSpec const & rhs)
574		:
	579	:
575	580	EQUALS(column_count_),
576	581	EQUALS(class_count_),
577	582	EQUALS(row_count_),

586	591	{
587	592	std::back_insert_iterator<ArrayVector<Label_t> >
588	593	iter(classes);
589		std::copy(rhs.classes.begin(), rhs.classes.end(), iter);
	594	std::copy(rhs.classes.begin(), rhs.classes.end(), iter);
590	595	}
591	596	#undef EQUALS
592	597	#define EQUALS(field) field(rhs.field)
593	598	template<class T>
594	599	ProblemSpec(ProblemSpec<T> const & rhs)
595		:
	600	:
596	601	EQUALS(column_count_),
597	602	EQUALS(class_count_),
598	603	EQUALS(row_count_),

607	612	{
608	613	std::back_insert_iterator<ArrayVector<Label_t> >
609	614	iter(classes);
610		std::copy(rhs.classes.begin(), rhs.classes.end(), iter);
	615	std::copy(rhs.classes.begin(), rhs.classes.end(), iter);
611	616	}
612	617	#undef EQUALS
613	618

627	632	class_weights_.clear();
628	633	std::back_insert_iterator<ArrayVector<double> >
629	634	iter2(class_weights_);
630		std::copy(rhs.class_weights_.begin(), rhs.class_weights_.end(), iter2);
	635	std::copy(rhs.class_weights_.begin(), rhs.class_weights_.end(), iter2);
631	636	classes.clear();
632	637	std::back_insert_iterator<ArrayVector<Label_t> >
633	638	iter(classes);
634		std::copy(rhs.classes.begin(), rhs.classes.end(), iter);
	639	std::copy(rhs.classes.begin(), rhs.classes.end(), iter);
635	640	return *this;
636	641	}
637	642

651	656	class_weights_.clear();
652	657	std::back_insert_iterator<ArrayVector<double> >
653	658	iter2(class_weights_);
654		std::copy(rhs.class_weights_.begin(), rhs.class_weights_.end(), iter2);
	659	std::copy(rhs.class_weights_.begin(), rhs.class_weights_.end(), iter2);
655	660	classes.clear();
656	661	std::back_insert_iterator<ArrayVector<Label_t> >
657	662	iter(classes);
658		std::copy(rhs.classes.begin(), rhs.classes.end(), iter);
	663	std::copy(rhs.classes.begin(), rhs.classes.end(), iter);
659	664	return *this;
660	665	}
661	666	#undef EQUALS

697	702	void unserialize(Iter const & begin, Iter const & end)
698	703	{
699	704	Iter iter = begin;
700		vigra_precondition(end - begin >= 10,
	705	vigra_precondition(end - begin >= 10,
701	706	"ProblemSpec::unserialize():"
702	707	"wrong number of parameters");
703	708	#define PULL(item_, type_) item_ = type_(*iter); ++iter;
704	709	PULL(column_count_,int);
705	710	PULL(class_count_, int);
706	711
707		vigra_precondition(end - begin >= 10 + class_count_,
	712	vigra_precondition(end - begin >= 10 + class_count_,
708	713	"ProblemSpec::unserialize(): 1");
709	714	PULL(row_count_, int);
710	715	PULL(actual_mtry_,int);

716	721	PULL(response_size_, int);
717	722	if(is_weighted_)
718	723	{
719		vigra_precondition(end - begin == 10 + 2*class_count_,
	724	vigra_precondition(end - begin == 10 + 2*class_count_,
720	725	"ProblemSpec::unserialize(): 2");
721	726	class_weights_.insert(class_weights_.end(),
722		iter,
	727	iter,
723	728	iter + class_count_);
724		iter += class_count_;
	729	iter += class_count_;
725	730	}
726	731	classes.insert(classes.end(), iter, end);
727	732	#undef PULL

732	737	void serialize(Iter const & begin, Iter const & end) const
733	738	{
734	739	Iter iter = begin;
735		vigra_precondition(end - begin == serialized_size(),
	740	vigra_precondition(end - begin == serialized_size(),
736	741	"RandomForestOptions::serialize():"
737	742	"wrong number of parameters");
738	743	#define PUSH(item_) *iter = double(item_); ++iter;

751	756	std::copy(class_weights_.begin(),
752	757	class_weights_.end(),
753	758	iter);
754		iter += class_count_;
	759	iter += class_count_;
755	760	}
756	761	std::copy(classes.begin(),
757	762	classes.end(),

761	766
762	767	void make_from_map(map_type & in) // -> const: .operator[] -> .find
763	768	{
764		#define PULL(item_, type_) item_ = type_(in[#item_][0]);
	769	#define PULL(item_, type_) item_ = type_(in[#item_][0]);
765	770	PULL(column_count_,int);
766	771	PULL(class_count_, int);
767	772	PULL(row_count_, int);

791	796	in["class_weights_"] = class_weights_;
792	797	#undef PUSH
793	798	}
794
	799
795	800	/**\brief set default values (-> values not set)
796	801	*/
797	802	ProblemSpec()

815	820	}
816	821
817	822	/**\brief supply with class labels -
818		*
	823	*
819	824	* the preprocessor will not calculate the labels needed in this case.
820	825	*/
821	826	template<class C_Iter>

831	836
832	837	/** \brief supply with class weights -
833	838	*
834		* this is the only case where you would really have to
	839	* this is the only case where you would really have to
835	840	* create a ProblemSpec object.
836	841	*/
837	842	template<class W_Iter>

847	852
848	853	void clear()
849	854	{
850		used_ = false;
	855	used_ = false;
851	856	classes.clear();
852	857	class_weights_.clear();
853	858	column_count_ = 0 ;

899	904	template<class WeightIter, class T, class C>
900	905	bool after_prediction(WeightIter, int /* k /, MultiArrayView<2, T, C> / prob /, double / totalCt */)
901	906	{
902		return false;
	907	return false;
903	908	}
904	909	};
905	910

+4

-3

include/vigra/random_forest/rf_decisionTree.hxx less more

40	40	#include <numeric>
41	41	#include "vigra/multi_array.hxx"
42	42	#include "vigra/mathutil.hxx"
	43	#include "vigra/metaprogramming.hxx"
43	44	#include "vigra/array_vector.hxx"
44	45	#include "vigra/sized_int.hxx"
45	46	#include "vigra/matrix.hxx"

215	216	template<class Visitor_t>
216	217	void traverse_mem_order(Visitor_t visitor) const
217	218	{
218		TreeInt index = 2;
219		Int32 ii = 0;
	219	UInt32 index = 2;
220	220	while(index < topology_.size())
221	221	{
222	222	if(isLeafNode(topology_[index]))

233	233	}
234	234
235	235	template<class Visitor_t>
236		void traverse_post_order(Visitor_t visitor, TreeInt start = 2) const
	236	void traverse_post_order(Visitor_t visitor, TreeInt /start/ = 2) const
237	237	{
238	238	typedef TinyVector<double, 2> Entry;
239	239	std::vector<Entry > stack;

450	450	//copy the newly created node form the split functor to the
451	451	//decision tree.
452	452	NodeBase node(split.createNode(), topology_, parameters_ );
	453	ignore_argument(node);
453	454	}
454	455	if(garbaged_child!=-1)
455	456	{

+5

-5

include/vigra/random_forest/rf_earlystopping.hxx less more

178	178	SB::set_external_parameters(prob, tree_count, is_weighted);
179	179	}
180	180	template<class WeightIter, class T, class C>
181		bool after_prediction(WeightIter iter, int k, MultiArrayView<2, T, C> const & prob, double totalCt)
	181	bool after_prediction(WeightIter, int k, MultiArrayView<2, T, C> const & prob, double)
182	182	{
183	183	if(k == SB::tree_count_ -1)
184	184	{

303	303	}
304	304
305	305	template<class WeightIter, class T, class C>
306		bool after_prediction(WeightIter iter, int k,
307		MultiArrayView<2, T, C> const &prob, double totalCt)
	306	bool after_prediction(WeightIter, int k,
	307	MultiArrayView<2, T, C> const &prob, double)
308	308	{
309	309	if(k == SB::tree_count_ -1)
310	310	{

384	384	}
385	385
386	386	template<class WeightIter, class T, class C>
387		bool after_prediction(WeightIter iter, int k, MultiArrayView<2, T, C> prob, double totalCt)
	387	bool after_prediction(WeightIter, int k, MultiArrayView<2, T, C> prob, double)
388	388	{
389	389	if(k == SB::tree_count_ -1)
390	390	{

442	442
443	443	template<class T>
444	444	void set_external_parameters(ProblemSpec<T> const &,
445		int tree_count = 0, bool /* is_weighted_ */= false)
	445	int /tree_count/ = 0, bool /* is_weighted_ */= false)
446	446	{}
447	447
448	448	template<class Region>

+9

-9

include/vigra/random_forest/rf_split.hxx less more

65	65	{
66	66	public:
67	67	template<class Iter>
68		static void exec(Iter begin, Iter end)
	68	static void exec(Iter /begin/, Iter /end/)
69	69	{}
70	70	};
71	71

146	146	**/
147	147
148	148	template<class T, class C, class T2, class C2, class Region, class Random>
149		int findBestSplit(MultiArrayView<2, T, C> features,
150		MultiArrayView<2, T2, C2> labels,
151		Region region,
152		ArrayVector<Region> childs,
153		Random randint)
	149	int findBestSplit(MultiArrayView<2, T, C> /features/,
	150	MultiArrayView<2, T2, C2> /labels/,
	151	Region /region/,
	152	ArrayVector<Region> /childs/,
	153	Random /randint/)
154	154	{
155	155	#ifndef __clang__
156	156	// FIXME: This compile-time checking trick does not work for clang.

546	546	}
547	547
548	548	template<class Iter, class Resp_t>
549		double init (Iter begin, Iter end, Resp_t resp)
	549	double init (Iter /begin/, Iter /end/, Resp_t resp)
550	550	{
551	551	reset();
552	552	std::copy(resp.begin(), resp.end(), counts_.begin());

644	644
645	645
646	646	template<class Iter, class Resp_t>
647		double init (Iter begin, Iter end, Resp_t resp)
	647	double init (Iter begin, Iter end, Resp_t /resp/)
648	648	{
649	649	reset();
650	650	return this->increment(begin, end);

962	962	struct Correction
963	963	{
964	964	template<class Region, class LabelT>
965		static void exec(Region & in, LabelT & labels)
	965	static void exec(Region & /in/, LabelT & /labels/)
966	966	{}
967	967	};
968	968

+241

-231

include/vigra/random_forest/rf_visitors.hxx less more

41	41	#include <iostream>
42	42	#include <iomanip>
43	43
	44	#include <vigra/metaprogramming.hxx>
44	45	#include <vigra/multi_pointoperators.hxx>
45	46	#include <vigra/timing.hxx>
46	47

48	49	{
49	50	namespace rf
50	51	{
51		/** \addtogroup MachineLearning Machine Learning
52		**/
53		//@{
54
55		/**
56		This namespace contains all classes and methods related to extracting information during
57		learning of the random forest. All Visitors share the same interface defined in
58		visitors::VisitorBase. The member methods are invoked at certain points of the main code in
	52	/** \brief Visitors to extract information during training of \ref vigra::RandomForest version 2.
	53
	54	\ingroup MachineLearning
	55
	56	This namespace contains all classes and methods related to extracting information during
	57	learning of the random forest. All Visitors share the same interface defined in
	58	visitors::VisitorBase. The member methods are invoked at certain points of the main code in
59	59	the order they were supplied.
60
61		For the Random Forest the Visitor concept is implemented as a statically linked list
62		(Using templates). Each Visitor object is encapsulated in a detail::VisitorNode object. The
	60
	61	For the Random Forest the Visitor concept is implemented as a statically linked list
	62	(Using templates). Each Visitor object is encapsulated in a detail::VisitorNode object. The
63	63	VisitorNode object calls the Next Visitor after one of its visit() methods have terminated.
64
	64
65	65	To simplify usage create_visitor() factory methods are supplied.
66	66	Use the create_visitor() method to supply visitor objects to the RandomForest::learn() method.
67	67	It is possible to supply more than one visitor. They will then be invoked in serial order.
68	68
69	69	The calculated information are stored as public data members of the class. - see documentation
70	70	of the individual visitors
71
72		While creating a new visitor the new class should therefore publicly inherit from this class
	71
	72	While creating a new visitor the new class should therefore publicly inherit from this class
73	73	(i.e.: see visitors::OOB_Error).
74	74
75	75	\code
76	76
77	77	typedef xxx feature_t \\ replace xxx with whichever type
78		typedef yyy label_t \\ meme chose.
	78	typedef yyy label_t \\ meme chose.
79	79	MultiArrayView<2, feature_t> f = get_some_features();
80	80	MultiArrayView<2, label_t> l = get_some_labels();
81	81	RandomForest<> rf()
82
	82
83	83	//calculate OOB Error
84	84	visitors::OOB_Error oob_v;
85	85	//calculate Variable Importance

87	87
88	88	double oob_error = rf.learn(f, l, visitors::create_visitor(oob_v, varimp_v);
89	89	//the data can be found in the attributes of oob_v and varimp_v now
90
	90
91	91	\endcode
92	92	*/
93	93	namespace visitors
94	94	{
95
96
97		/** Base Class from which all Visitors derive. Can be used as a template to create new
	95
	96
	97	/** Base Class from which all Visitors derive. Can be used as a template to create new
98	98	* Visitors.
99	99	*/
100	100	class VisitorBase
101	101	{
102	102	public:
103		bool active_;
	103	bool active_;
104	104	bool is_active()
105	105	{
106	106	return active_;

123	123	{
124	124	active_ = true;
125	125	}
126
	126
127	127	/** do something after the the Split has decided how to process the Region
128	128	* (Stack entry)
129	129	*

138	138	* \sa RF_Traits::StackEntry_t
139	139	*/
140	140	template<class Tree, class Split, class Region, class Feature_t, class Label_t>
141		void visit_after_split( Tree & tree,
	141	void visit_after_split( Tree & tree,
142	142	Split & split,
143	143	Region & parent,
144	144	Region & leftChild,
145	145	Region & rightChild,
146	146	Feature_t & features,
147	147	Label_t & labels)
148		{}
149
	148	{
	149	ignore_argument(tree,split,parent,leftChild,rightChild,features,labels);
	150	}
	151
150	152	/** do something after each tree has been learned
151	153	*
152	154	* \param rf reference to the random forest object that called this

158	160	*/
159	161	template<class RF, class PR, class SM, class ST>
160	162	void visit_after_tree(RF & rf, PR & pr, SM & sm, ST & st, int index)
161		{}
162
	163	{
	164	ignore_argument(rf,pr,sm,st,index);
	165	}
	166
163	167	/** do something after all trees have been learned
164	168	*
165	169	* \param rf reference to the random forest object that called this

168	172	*/
169	173	template<class RF, class PR>
170	174	void visit_at_end(RF const & rf, PR const & pr)
171		{}
172
173		/** do something before learning starts
	175	{
	176	ignore_argument(rf,pr);
	177	}
	178
	179	/** do something before learning starts
174	180	*
175	181	* \param rf reference to the random forest object that called this
176	182	* visitor

178	184	*/
179	185	template<class RF, class PR>
180	186	void visit_at_beginning(RF const & rf, PR const & pr)
181		{}
182		/** do some thing while traversing tree after it has been learned
	187	{
	188	ignore_argument(rf,pr);
	189	}
	190	/** do some thing while traversing tree after it has been learned
183	191	* (external nodes)
184	192	*
185	193	* \param tr reference to the tree object that called this visitor

188	196	* \param features feature matrix
189	197	* \sa NodeTags;
190	198	*
191		* you can create the node by using a switch on node_tag and using the
192		* corresponding Node objects. Or - if you do not care about the type
	199	* you can create the node by using a switch on node_tag and using the
	200	* corresponding Node objects. Or - if you do not care about the type
193	201	* use the NodeBase class.
194	202	*/
195	203	template<class TR, class IntT, class TopT,class Feat>
196	204	void visit_external_node(TR & tr, IntT index, TopT node_t, Feat & features)
197		{}
198
	205	{
	206	ignore_argument(tr,index,node_t,features);
	207	}
	208
199	209	/** do something when visiting a internal node after it has been learned
200	210	*
201	211	* \sa visit_external_node

204	214	void visit_internal_node(TR & /* tr /, IntT / index /, TopT / node_t /, Feat & / features */)
205	215	{}
206	216
207		/** return a double value. The value of the first
	217	/** return a double value. The value of the first
208	218	* visitor encountered that has a return value is returned with the
209	219	* RandomForest::learn() method - or -1.0 if no return value visitor
210		* existed. This functionality basically only exists so that the
211		* OOB - visitor can return the oob error rate like in the old version
	220	* existed. This functionality basically only exists so that the
	221	* OOB - visitor can return the oob error rate like in the old version
212	222	* of the random forest.
213	223	*/
214	224	double return_val()

243	253	class VisitorNode
244	254	{
245	255	public:
246
	256
247	257	StopVisiting stop_;
248	258	Next next_;
249		Visitor & visitor_;
250		VisitorNode(Visitor & visitor, Next & next)
251		:
	259	Visitor & visitor_;
	260	VisitorNode(Visitor & visitor, Next & next)
	261	:
252	262	next_(next), visitor_(visitor)
253	263	{}
254	264
255		VisitorNode(Visitor & visitor)
256		:
	265	VisitorNode(Visitor & visitor)
	266	:
257	267	next_(stop_), visitor_(visitor)
258	268	{}
259	269
260	270	template<class Tree, class Split, class Region, class Feature_t, class Label_t>
261		void visit_after_split( Tree & tree,
	271	void visit_after_split( Tree & tree,
262	272	Split & split,
263	273	Region & parent,
264	274	Region & leftChild,

267	277	Label_t & labels)
268	278	{
269	279	if(visitor_.is_active())
270		visitor_.visit_after_split(tree, split,
	280	visitor_.visit_after_split(tree, split,
271	281	parent, leftChild, rightChild,
272	282	features, labels);
273	283	next_.visit_after_split(tree, split, parent, leftChild, rightChild,

296	306	visitor_.visit_at_end(rf, pr);
297	307	next_.visit_at_end(rf, pr);
298	308	}
299
	309
300	310	template<class TR, class IntT, class TopT,class Feat>
301	311	void visit_external_node(TR & tr, IntT & index, TopT & node_t,Feat & features)
302	312	{

371	381	/** factory method to to be used with RandomForest::learn()
372	382	*/
373	383	template<class A, class B, class C, class D>
374		detail::VisitorNode<A, detail::VisitorNode<B, detail::VisitorNode<C,
	384	detail::VisitorNode<A, detail::VisitorNode<B, detail::VisitorNode<C,
375	385	detail::VisitorNode<D> > > >
376	386	create_visitor(A & a, B & b, C & c, D & d)
377	387	{

390	400	/** factory method to to be used with RandomForest::learn()
391	401	*/
392	402	template<class A, class B, class C, class D, class E>
393		detail::VisitorNode<A, detail::VisitorNode<B, detail::VisitorNode<C,
	403	detail::VisitorNode<A, detail::VisitorNode<B, detail::VisitorNode<C,
394	404	detail::VisitorNode<D, detail::VisitorNode<E> > > > >
395		create_visitor(A & a, B & b, C & c,
	405	create_visitor(A & a, B & b, C & c,
396	406	D & d, E & e)
397	407	{
398	408	typedef detail::VisitorNode<E> _4_t;

413	423	*/
414	424	template<class A, class B, class C, class D, class E,
415	425	class F>
416		detail::VisitorNode<A, detail::VisitorNode<B, detail::VisitorNode<C,
	426	detail::VisitorNode<A, detail::VisitorNode<B, detail::VisitorNode<C,
417	427	detail::VisitorNode<D, detail::VisitorNode<E, detail::VisitorNode<F> > > > > >
418		create_visitor(A & a, B & b, C & c,
	428	create_visitor(A & a, B & b, C & c,
419	429	D & d, E & e, F & f)
420	430	{
421	431	typedef detail::VisitorNode<F> _5_t;

438	448	*/
439	449	template<class A, class B, class C, class D, class E,
440	450	class F, class G>
441		detail::VisitorNode<A, detail::VisitorNode<B, detail::VisitorNode<C,
442		detail::VisitorNode<D, detail::VisitorNode<E, detail::VisitorNode<F,
	451	detail::VisitorNode<A, detail::VisitorNode<B, detail::VisitorNode<C,
	452	detail::VisitorNode<D, detail::VisitorNode<E, detail::VisitorNode<F,
443	453	detail::VisitorNode<G> > > > > > >
444		create_visitor(A & a, B & b, C & c,
	454	create_visitor(A & a, B & b, C & c,
445	455	D & d, E & e, F & f, G & g)
446	456	{
447	457	typedef detail::VisitorNode<G> _6_t;

466	476	*/
467	477	template<class A, class B, class C, class D, class E,
468	478	class F, class G, class H>
469		detail::VisitorNode<A, detail::VisitorNode<B, detail::VisitorNode<C,
470		detail::VisitorNode<D, detail::VisitorNode<E, detail::VisitorNode<F,
	479	detail::VisitorNode<A, detail::VisitorNode<B, detail::VisitorNode<C,
	480	detail::VisitorNode<D, detail::VisitorNode<E, detail::VisitorNode<F,
471	481	detail::VisitorNode<G, detail::VisitorNode<H> > > > > > > >
472		create_visitor(A & a, B & b, C & c,
473		D & d, E & e, F & f,
	482	create_visitor(A & a, B & b, C & c,
	483	D & d, E & e, F & f,
474	484	G & g, H & h)
475	485	{
476	486	typedef detail::VisitorNode<H> _7_t;

497	507	*/
498	508	template<class A, class B, class C, class D, class E,
499	509	class F, class G, class H, class I>
500		detail::VisitorNode<A, detail::VisitorNode<B, detail::VisitorNode<C,
501		detail::VisitorNode<D, detail::VisitorNode<E, detail::VisitorNode<F,
	510	detail::VisitorNode<A, detail::VisitorNode<B, detail::VisitorNode<C,
	511	detail::VisitorNode<D, detail::VisitorNode<E, detail::VisitorNode<F,
502	512	detail::VisitorNode<G, detail::VisitorNode<H, detail::VisitorNode<I> > > > > > > > >
503		create_visitor(A & a, B & b, C & c,
504		D & d, E & e, F & f,
	513	create_visitor(A & a, B & b, C & c,
	514	D & d, E & e, F & f,
505	515	G & g, H & h, I & i)
506	516	{
507	517	typedef detail::VisitorNode<I> _8_t;

529	539	*/
530	540	template<class A, class B, class C, class D, class E,
531	541	class F, class G, class H, class I, class J>
532		detail::VisitorNode<A, detail::VisitorNode<B, detail::VisitorNode<C,
533		detail::VisitorNode<D, detail::VisitorNode<E, detail::VisitorNode<F,
	542	detail::VisitorNode<A, detail::VisitorNode<B, detail::VisitorNode<C,
	543	detail::VisitorNode<D, detail::VisitorNode<E, detail::VisitorNode<F,
534	544	detail::VisitorNode<G, detail::VisitorNode<H, detail::VisitorNode<I,
535	545	detail::VisitorNode<J> > > > > > > > > >
536		create_visitor(A & a, B & b, C & c,
537		D & d, E & e, F & f,
	546	create_visitor(A & a, B & b, C & c,
	547	D & d, E & e, F & f,
538	548	G & g, H & h, I & i,
539	549	J & j)
540	550	{

636	646	{
637	647	tree_id++;
638	648	}
639
	649
640	650	template<class Tree, class Split, class Region, class Feature_t, class Label_t>
641		void visit_after_split( Tree & tree,
	651	void visit_after_split( Tree & tree,
642	652	Split & split,
643	653	Region & parent,
644	654	Region & leftChild,

748	758	}
749	759	}
750	760	/** do something when visiting a extern node during getToLeaf
751		*
	761	*
752	762	* Store the new index!
753	763	*/
754	764	};

759	769
760	770
761	771	/** Visitor that calculates the oob error of each individual randomized
762		* decision tree.
	772	* decision tree.
763	773	*
764	774	* After training a tree, all those samples that are OOB for this particular tree
765		* are put down the tree and the error estimated.
766		* the per tree oob error is the average of the individual error estimates.
	775	* are put down the tree and the error estimated.
	776	* the per tree oob error is the average of the individual error estimates.
767	777	* (oobError = average error of one randomized tree)
768		* Note: This is Not the OOB - Error estimate suggested by Breiman (See OOB_Error
	778	* Note: This is Not the OOB - Error estimate suggested by Breiman (See OOB_Error
769	779	* visitor)
770	780	*/
771	781	class OOB_PerTreeError:public VisitorBase

792	802
793	803	/** does the basic calculation per tree*/
794	804	template<class RF, class PR, class SM, class ST>
795		void visit_after_tree(RF & rf, PR & pr, SM & sm, ST & st, int index)
	805	void visit_after_tree(RF & rf, PR & pr, SM & sm, ST &, int index)
796	806	{
797	807	//do the first time called.
798	808	if(int(oobCount.size()) != rf.ext_param_.row_count_)

808	818	{
809	819	++oobCount[l];
810	820	if( rf.tree(index)
811		.predictLabel(rowVector(pr.features(), l))
	821	.predictLabel(rowVector(pr.features(), l))
812	822	!= pr.response()(l,0))
813	823	{
814	824	++oobErrorCount[l];

821	831	/** Does the normalisation
822	832	*/
823	833	template<class RF, class PR>
824		void visit_at_end(RF & rf, PR & pr)
	834	void visit_at_end(RF & rf, PR &)
825	835	{
826	836	// do some normalisation
827	837	for(int l=0; l < static_cast<int>(rf.ext_param_.row_count_); ++l)

831	841	oobError += double(oobErrorCount[l]) / oobCount[l];
832	842	++totalOobCount;
833	843	}
834		}
	844	}
835	845	oobError/=totalOobCount;
836	846	}
837
	847
838	848	};
839	849
840	850	/** Visitor that calculates the oob error of the ensemble
841		* This rate should be used to estimate the crossvalidation
	851	*
	852	* This rate serves as a quick estimate for the crossvalidation
842	853	* error rate.
843		* Here each sample is put down those trees, for which this sample
844		* is OOB i.e. if sample #1 is OOB for trees 1, 3 and 5 we calculate
845		* the output using the ensemble consisting only of trees 1 3 and 5.
	854	* Here, each sample is put down the trees for which this sample
	855	* is OOB, i.e., if sample #1 is OOB for trees 1, 3 and 5, we calculate
	856	* the output using the ensemble consisting only of trees 1 3 and 5.
846	857	*
847		* Using normal bagged sampling each sample is OOB for approx. 33% of trees
848		* The error rate obtained as such therefore corresponds to crossvalidation
	858	* Using normal bagged sampling each sample is OOB for approx. 33% of trees.
	859	* The error rate obtained as such therefore corresponds to a crossvalidation
849	860	* rate obtained using a ensemble containing 33% of the trees.
850	861	*/
851	862	class OOB_Error : public VisitorBase

856	867	MultiArray<2,double> tmp_prob;
857	868	public:
858	869
859		MultiArray<2, double> prob_oob;
	870	MultiArray<2, double> prob_oob;
860	871	/** Ensemble oob error rate
861	872	*/
862	873	double oob_breiman;
863	874
864	875	MultiArray<2, double> oobCount;
865		ArrayVector< int> indices;
	876	ArrayVector< int> indices;
866	877	OOB_Error() : VisitorBase(), oob_breiman(0.0) {}
867	878	#ifdef HasHDF5
868	879	void save(std::string filen, std::string pathn)

870	881	if(*(pathn.end()-1) != '/')
871	882	pathn += "/";
872	883	const char* filename = filen.c_str();
873		MultiArray<2, double> temp(Shp(1,1), 0.0);
	884	MultiArray<2, double> temp(Shp(1,1), 0.0);
874	885	temp[0] = oob_breiman;
875	886	writeHDF5(filename, (pathn + "breiman_error").c_str(), temp);
876	887	}

879	890	// value >=0 if sample was oob, 0 means fail 1, correct
880	891
881	892	template<class RF, class PR>
882		void visit_at_beginning(RF & rf, PR & pr)
	893	void visit_at_beginning(RF & rf, PR &)
883	894	{
884	895	class_count = rf.class_count();
885		tmp_prob.reshape(Shp(1, class_count), 0);
	896	tmp_prob.reshape(Shp(1, class_count), 0);
886	897	prob_oob.reshape(Shp(rf.ext_param().row_count_,class_count), 0);
887	898	is_weighted = rf.options().predict_weighted_;
888	899	indices.resize(rf.ext_param().row_count_);

897	908	}
898	909
899	910	template<class RF, class PR, class SM, class ST>
900		void visit_after_tree(RF& rf, PR & pr, SM & sm, ST & st, int index)
	911	void visit_after_tree(RF& rf, PR & pr, SM & sm, ST &, int index)
901	912	{
902	913	// go through the samples
903	914	int total_oob =0;
904	915	// FIXME: magic number 10000: invoke special treatment when when msample << sample_count
905	916	// (i.e. the OOB sample ist very large)
906		// 40000: use at most 40000 OOB samples per class for OOB error estimate
	917	// 40000: use at most 40000 OOB samples per class for OOB error estimate
907	918	if(rf.ext_param_.actual_msample_ < pr.features().shape(0) - 10000)
908	919	{
909	920	ArrayVector<int> oob_indices;

923	934	++oobCount[oob_indices[ll]];
924	935
925	936	// update number of oob samples in this tree.
926		++total_oob;
	937	++total_oob;
927	938	// get the predicted votes ---> tmp_prob;
928	939	int pos = rf.tree(index).getToLeaf(rowVector(pr.features(),oob_indices[ll]));
929		Node<e_ConstProbNode> node ( rf.tree(index).topology_,
	940	Node<e_ConstProbNode> node ( rf.tree(index).topology_,
930	941	rf.tree(index).parameters_,
931	942	pos);
932		tmp_prob.init(0);
	943	tmp_prob.init(0);
933	944	for(int ii = 0; ii < class_count; ++ii)
934	945	{
935	946	tmp_prob[ii] = node.prob_begin()[ii];

940	951	tmp_prob[ii] = tmp_prob[ii] * (*(node.prob_begin()-1));
941	952	}
942	953	rowVector(prob_oob, oob_indices[ll]) += tmp_prob;
943
	954
944	955	}
945	956	}else
946	957	{

953	964	++oobCount[ll];
954	965
955	966	// update number of oob samples in this tree.
956		++total_oob;
	967	++total_oob;
957	968	// get the predicted votes ---> tmp_prob;
958	969	int pos = rf.tree(index).getToLeaf(rowVector(pr.features(),ll));
959		Node<e_ConstProbNode> node ( rf.tree(index).topology_,
	970	Node<e_ConstProbNode> node ( rf.tree(index).topology_,
960	971	rf.tree(index).parameters_,
961	972	pos);
962		tmp_prob.init(0);
	973	tmp_prob.init(0);
963	974	for(int ii = 0; ii < class_count; ++ii)
964	975	{
965	976	tmp_prob[ii] = node.prob_begin()[ii];

973	984	}
974	985	}
975	986	}
976		// go through the ib samples;
	987	// go through the ib samples;
977	988	}
978	989
979	990	/** Normalise variable importance after the number of trees is known.

993	1004	++totalOobCount;
994	1005	}
995	1006	}
996		oob_breiman = double(breimanstyle)/totalOobCount;
	1007	oob_breiman = double(breimanstyle)/totalOobCount;
997	1008	}
998	1009	};
999	1010

1017	1028	/**Standard deviation of oob_per_tree
1018	1029	*/
1019	1030	double oob_std;
1020
1021		MultiArray<2, double> prob_oob;
	1031
	1032	MultiArray<2, double> prob_oob;
1022	1033	/** Ensemble OOB error
1023	1034	*
1024	1035	* \sa OOB_Error

1036	1047	* error rate with increasing number of trees
1037	1048	*/
1038	1049	MultiArray<2, double> breiman_per_tree;
1039		/** 4 dimensional array containing the development of confusion matrices
	1050	/** 4 dimensional array containing the development of confusion matrices
1040	1051	* with number of trees - can be used to estimate ROC curves etc.
1041	1052	*
1042		* oobroc_per_tree(ii,jj,kk,ll)
1043		* corresponds true label = ii
	1053	* oobroc_per_tree(ii,jj,kk,ll)
	1054	* corresponds true label = ii
1044	1055	* predicted label = jj
1045	1056	* confusion matrix after ll trees
1046	1057	*

1053	1064	* kk = 0. Threshold on probability set by argMax of the probability array.
1054	1065	*/
1055	1066	MultiArray<4, double> oobroc_per_tree;
1056
	1067
1057	1068	CompleteOOBInfo() : VisitorBase(), oob_mean(0), oob_std(0), oob_per_tree2(0) {}
1058	1069
1059	1070	#ifdef HasHDF5

1064	1075	if(*(pathn.end()-1) != '/')
1065	1076	pathn += "/";
1066	1077	const char* filename = filen.c_str();
1067		MultiArray<2, double> temp(Shp(1,1), 0.0);
	1078	MultiArray<2, double> temp(Shp(1,1), 0.0);
1068	1079	writeHDF5(filename, (pathn + "oob_per_tree").c_str(), oob_per_tree);
1069	1080	writeHDF5(filename, (pathn + "oobroc_per_tree").c_str(), oobroc_per_tree);
1070	1081	writeHDF5(filename, (pathn + "breiman_per_tree").c_str(), breiman_per_tree);

1082	1093	// value >=0 if sample was oob, 0 means fail 1, correct
1083	1094
1084	1095	template<class RF, class PR>
1085		void visit_at_beginning(RF & rf, PR & pr)
	1096	void visit_at_beginning(RF & rf, PR &)
1086	1097	{
1087	1098	class_count = rf.class_count();
1088	1099	if(class_count == 2)
1089	1100	oobroc_per_tree.reshape(MultiArrayShape<4>::type(2,2,rf.tree_count(), rf.tree_count()));
1090	1101	else
1091	1102	oobroc_per_tree.reshape(MultiArrayShape<4>::type(rf.class_count(),rf.class_count(),1, rf.tree_count()));
1092		tmp_prob.reshape(Shp(1, class_count), 0);
	1103	tmp_prob.reshape(Shp(1, class_count), 0);
1093	1104	prob_oob.reshape(Shp(rf.ext_param().row_count_,class_count), 0);
1094	1105	is_weighted = rf.options().predict_weighted_;
1095	1106	oob_per_tree.reshape(Shp(1, rf.tree_count()), 0);

1103	1114	}
1104	1115
1105	1116	template<class RF, class PR, class SM, class ST>
1106		void visit_after_tree(RF& rf, PR & pr, SM & sm, ST & st, int index)
	1117	void visit_after_tree(RF& rf, PR & pr, SM & sm, ST &, int index)
1107	1118	{
1108	1119	// go through the samples
1109	1120	int total_oob =0;

1117	1128	++oobCount[ll];
1118	1129
1119	1130	// update number of oob samples in this tree.
1120		++total_oob;
	1131	++total_oob;
1121	1132	// get the predicted votes ---> tmp_prob;
1122	1133	int pos = rf.tree(index).getToLeaf(rowVector(pr.features(),ll));
1123		Node<e_ConstProbNode> node ( rf.tree(index).topology_,
	1134	Node<e_ConstProbNode> node ( rf.tree(index).topology_,
1124	1135	rf.tree(index).parameters_,
1125	1136	pos);
1126		tmp_prob.init(0);
	1137	tmp_prob.init(0);
1127	1138	for(int ii = 0; ii < class_count; ++ii)
1128	1139	{
1129	1140	tmp_prob[ii] = node.prob_begin()[ii];

1134	1145	tmp_prob[ii] = tmp_prob[ii] * (*(node.prob_begin()-1));
1135	1146	}
1136	1147	rowVector(prob_oob, ll) += tmp_prob;
1137		int label = argMax(tmp_prob);
1138
	1148	int label = argMax(tmp_prob);
	1149
1139	1150	if(label != pr.response()(ll, 0))
1140	1151	{
1141	1152	// update number of wrong oob samples in this tree.

1164	1175	oobroc_per_tree.bindOuter(index)/=totalOobCount;
1165	1176	if(oobroc_per_tree.shape(2) > 1)
1166	1177	{
1167		MultiArrayView<3, double> current_roc
	1178	MultiArrayView<3, double> current_roc
1168	1179	= oobroc_per_tree.bindOuter(index);
1169	1180	for(int gg = 0; gg < current_roc.shape(2); ++gg)
1170	1181	{

1173	1184	if(oobCount[ll])
1174	1185	{
1175	1186	int pred = prob_oob(ll, 1) > (double(gg)/double(current_roc.shape(2)))?
1176		1 : 0;
1177		current_roc(pr.response()(ll, 0), pred, gg)+= 1;
	1187	1 : 0;
	1188	current_roc(pr.response()(ll, 0), pred, gg)+= 1;
1178	1189	}
1179	1190	}
1180	1191	current_roc.bindOuter(gg)/= totalOobCount;

1182	1193	}
1183	1194	breiman_per_tree[index] = double(breimanstyle)/double(totalOobCount);
1184	1195	oob_per_tree[index] = double(wrong_oob)/double(total_oob);
1185		// go through the ib samples;
	1196	// go through the ib samples;
1186	1197	}
1187	1198
1188	1199	/** Normalise variable importance after the number of trees is known.

1191	1202	void visit_at_end(RF & rf, PR & pr)
1192	1203	{
1193	1204	// ullis original metric and breiman style stuff
1194		oob_per_tree2 = 0;
	1205	oob_per_tree2 = 0;
1195	1206	int totalOobCount =0;
1196	1207	int breimanstyle = 0;
1197	1208	for(int ll=0; ll < static_cast<int>(rf.ext_param_.row_count_); ++ll)

1204	1215	++totalOobCount;
1205	1216	}
1206	1217	}
1207		oob_per_tree2 /= totalOobCount;
1208		oob_breiman = double(breimanstyle)/totalOobCount;
	1218	oob_per_tree2 /= totalOobCount;
	1219	oob_breiman = double(breimanstyle)/totalOobCount;
1209	1220	// mean error of each tree
1210	1221	MultiArrayView<2, double> mean(Shp(1,1), &oob_mean);
1211	1222	MultiArrayView<2, double> stdDev(Shp(1,1), &oob_std);

1222	1233	/** This Array has the same entries as the R - random forest variable
1223	1234	* importance.
1224	1235	* Matrix is featureCount by (classCount +2)
1225		* variable_importance_(ii,jj) is the variable importance measure of
	1236	* variable_importance_(ii,jj) is the variable importance measure of
1226	1237	* the ii-th variable according to:
1227	1238	* jj = 0 - (classCount-1)
1228		* classwise permutation importance
	1239	* classwise permutation importance
1229	1240	* jj = rowCount(variable_importance_) -2
1230	1241	* permutation importance
1231	1242	* jj = rowCount(variable_importance_) -1

1237	1248	* The ii-th column is permuted rep_cnt times.
1238	1249	*
1239	1250	* class wise permutation importance:
1240		* same as permutation importance. We only look at those OOB samples whose
	1251	* same as permutation importance. We only look at those OOB samples whose
1241	1252	* response corresponds to class jj.
1242	1253	*
1243	1254	* gini decrease importance:
1244		* row ii corresponds to the sum of all gini decreases induced by variable ii
	1255	* row ii corresponds to the sum of all gini decreases induced by variable ii
1245	1256	* in each node of the random forest.
1246	1257	*/
1247	1258	MultiArray<2, double> variable_importance_;

1252	1263	void save(std::string filename, std::string prefix)
1253	1264	{
1254	1265	prefix = "variable_importance_" + prefix;
1255		writeHDF5(filename.c_str(),
1256		prefix.c_str(),
	1266	writeHDF5(filename.c_str(),
	1267	prefix.c_str(),
1257	1268	variable_importance_);
1258	1269	}
1259	1270	#endif
1260	1271
1261	1272	/* Constructor
1262		* \param rep_cnt (defautl: 10) how often should
	1273	* \param rep_cnt (defautl: 10) how often should
1263	1274	* the permutation take place. Set to 1 to make calculation faster (but
1264	1275	* possibly more instable)
1265	1276	*/
1266		VariableImportanceVisitor(int rep_cnt = 10)
	1277	VariableImportanceVisitor(int rep_cnt = 10)
1267	1278	: repetition_count_(rep_cnt)
1268	1279
1269	1280	{}
1270	1281
1271	1282	/** calculates impurity decrease based variable importance after every
1272		* split.
	1283	* split.
1273	1284	*/
1274	1285	template<class Tree, class Split, class Region, class Feature_t, class Label_t>
1275		void visit_after_split( Tree & tree,
	1286	void visit_after_split( Tree & tree,
1276	1287	Split & split,
1277	1288	Region & /* parent */,
1278	1289	Region & /* leftChild */,

1281	1292	Label_t & /* labels */)
1282	1293	{
1283	1294	//resize to right size when called the first time
1284
	1295
1285	1296	Int32 const class_count = tree.ext_param_.class_count_;
1286	1297	Int32 const column_count = tree.ext_param_.column_count_;
1287	1298	if(variable_importance_.size() == 0)
1288	1299	{
1289
	1300
1290	1301	variable_importance_
1291		.reshape(MultiArrayShape<2>::type(column_count,
	1302	.reshape(MultiArrayShape<2>::type(column_count,
1292	1303	class_count+2));
1293	1304	}
1294	1305
1295	1306	if(split.createNode().typeID() == i_ThresholdNode)
1296	1307	{
1297	1308	Node<i_ThresholdNode> node(split.createNode());
1298		variable_importance_(node.column(),class_count+1)
	1309	variable_importance_(node.column(),class_count+1)
1299	1310	+= split.region_gini_ - split.minGini();
1300	1311	}
1301	1312	}
1302	1313
1303		/**compute permutation based var imp.
	1314	/**compute permutation based var imp.
1304	1315	* (Only an Array of size oob_sample_count x 1 is created.
1305	1316	* - apposed to oob_sample_count x feature_count in the other method.
1306		*
	1317	*
1307	1318	* \sa FieldProxy
1308	1319	*/
1309	1320	template<class RF, class PR, class SM, class ST>

1311	1322	{
1312	1323	typedef MultiArrayShape<2>::type Shp_t;
1313	1324	Int32 column_count = rf.ext_param_.column_count_;
1314		Int32 class_count = rf.ext_param_.class_count_;
1315
	1325	Int32 class_count = rf.ext_param_.class_count_;
	1326
1316	1327	/* This solution saves memory uptake but not multithreading
1317	1328	* compatible
1318	1329	*/
1319		// remove the const cast on the features (yep , I know what I am
	1330	// remove the const cast on the features (yep , I know what I am
1320	1331	// doing here.) data is not destroyed.
1321		//typename PR::Feature_t & features
	1332	//typename PR::Feature_t & features
1322	1333	// = const_cast<typename PR::Feature_t &>(pr.features());
1323	1334
1324	1335	typedef typename PR::FeatureWithMemory_t FeatureArray;

1326	1337
1327	1338	FeatureArray features = pr.features();
1328	1339
1329		//find the oob indices of current tree.
	1340	//find the oob indices of current tree.
1330	1341	ArrayVector<Int32> oob_indices;
1331	1342	ArrayVector<Int32>::iterator
1332	1343	iter;

1334	1345	if(!sm.is_used()[ii])
1335	1346	oob_indices.push_back(ii);
1336	1347
1337		//create space to back up a column
	1348	//create space to back up a column
1338	1349	ArrayVector<FeatureValue> backup_column;
1339	1350
1340	1351	// Random foo
1341	1352	#ifdef CLASSIFIER_TEST
1342	1353	RandomMT19937 random(1);
1343		#else
	1354	#else
1344	1355	RandomMT19937 random(RandomSeed);
1345	1356	#endif
1346		UniformIntRandomFunctor<RandomMT19937>
	1357	UniformIntRandomFunctor<RandomMT19937>
1347	1358	randint(random);
1348	1359
1349	1360
1350	1361	//make some space for the results
1351	1362	MultiArray<2, double>
1352		oob_right(Shp_t(1, class_count + 1));
	1363	oob_right(Shp_t(1, class_count + 1));
1353	1364	MultiArray<2, double>
1354		perm_oob_right (Shp_t(1, class_count + 1));
1355
1356
	1365	perm_oob_right (Shp_t(1, class_count + 1));
	1366
	1367
1357	1368	// get the oob success rate with the original samples
1358		for(iter = oob_indices.begin();
1359		iter != oob_indices.end();
	1369	for(iter = oob_indices.begin();
	1370	iter != oob_indices.end();
1360	1371	++iter)
1361	1372	{
1362	1373	if(rf.tree(index)
1363		.predictLabel(rowVector(features, *iter))
	1374	.predictLabel(rowVector(features, *iter))
1364	1375	== pr.response()(*iter, 0))
1365	1376	{
1366	1377	//per class

1372	1383	//get the oob rate after permuting the ii'th dimension.
1373	1384	for(int ii = 0; ii < column_count; ++ii)
1374	1385	{
1375		perm_oob_right.init(0.0);
	1386	perm_oob_right.init(0.0);
1376	1387	//make backup of original column
1377	1388	backup_column.clear();
1378		for(iter = oob_indices.begin();
1379		iter != oob_indices.end();
	1389	for(iter = oob_indices.begin();
	1390	iter != oob_indices.end();
1380	1391	++iter)
1381	1392	{
1382	1393	backup_column.push_back(features(*iter,ii));
1383	1394	}
1384
	1395
1385	1396	//get the oob rate after permuting the ii'th dimension.
1386	1397	for(int rr = 0; rr < repetition_count_; ++rr)
1387		{
1388		//permute dimension.
	1398	{
	1399	//permute dimension.
1389	1400	int n = oob_indices.size();
1390	1401	for(int jj = n-1; jj >= 1; --jj)
1391		std::swap(features(oob_indices[jj], ii),
	1402	std::swap(features(oob_indices[jj], ii),
1392	1403	features(oob_indices[randint(jj+1)], ii));
1393	1404
1394	1405	//get the oob success rate after permuting
1395		for(iter = oob_indices.begin();
1396		iter != oob_indices.end();
	1406	for(iter = oob_indices.begin();
	1407	iter != oob_indices.end();
1397	1408	++iter)
1398	1409	{
1399	1410	if(rf.tree(index)
1400		.predictLabel(rowVector(features, *iter))
	1411	.predictLabel(rowVector(features, *iter))
1401	1412	== pr.response()(*iter, 0))
1402	1413	{
1403	1414	//per class

1407	1418	}
1408	1419	}
1409	1420	}
1410
1411
	1421
	1422
1412	1423	//normalise and add to the variable_importance array.
1413	1424	perm_oob_right /= repetition_count_;
1414	1425	perm_oob_right -=oob_right;
1415	1426	perm_oob_right *= -1;
1416	1427	perm_oob_right /= oob_indices.size();
1417	1428	variable_importance_
1418		.subarray(Shp_t(ii,0),
	1429	.subarray(Shp_t(ii,0),
1419	1430	Shp_t(ii+1,class_count+1)) += perm_oob_right;
1420	1431	//copy back permuted dimension
1421	1432	for(int jj = 0; jj < int(oob_indices.size()); ++jj)

1423	1434	}
1424	1435	}
1425	1436
1426		/** calculate permutation based impurity after every tree has been
	1437	/** calculate permutation based impurity after every tree has been
1427	1438	* learned default behaviour is that this happens out of place.
1428		* If you have very big data sets and want to avoid copying of data
1429		* set the in_place_ flag to true.
	1439	* If you have very big data sets and want to avoid copying of data
	1440	* set the in_place_ flag to true.
1430	1441	*/
1431	1442	template<class RF, class PR, class SM, class ST>
1432	1443	void visit_after_tree(RF& rf, PR & pr, SM & sm, ST & st, int index)

1450	1461	RandomForestProgressVisitor() : VisitorBase() {}
1451	1462
1452	1463	template<class RF, class PR, class SM, class ST>
1453		void visit_after_tree(RF& rf, PR & pr, SM & sm, ST & st, int index){
	1464	void visit_after_tree(RF& rf, PR &, SM &, ST &, int index){
1454	1465	if(index != rf.options().tree_count_-1) {
1455	1466	std::cout << "\r[" << std::setw(10) << (index+1)/static_cast<double>(rf.options().tree_count_)*100 << "%]"
1456	1467	<< " (" << index+1 << " of " << rf.options().tree_count_ << ") done" << std::flush;

1459	1470	std::cout << "\r[" << std::setw(10) << 100.0 << "%]" << std::endl;
1460	1471	}
1461	1472	}
1462
	1473
1463	1474	template<class RF, class PR>
1464		void visit_at_end(RF const & rf, PR const & pr) {
	1475	void visit_at_end(RF const & rf, PR const &) {
1465	1476	std::string a = TOCS;
1466	1477	std::cout << "all " << rf.options().tree_count_ << " trees have been learned in " << a << std::endl;
1467	1478	}
1468
	1479
1469	1480	template<class RF, class PR>
1470		void visit_at_beginning(RF const & rf, PR const & pr) {
	1481	void visit_at_beginning(RF const & rf, PR const &) {
1471	1482	TIC;
1472	1483	std::cout << "growing random forest, which will have " << rf.options().tree_count_ << " trees" << std::endl;
1473	1484	}
1474
	1485
1475	1486	private:
1476	1487	USETICTOC;
1477	1488	};

1485	1496	public:
1486	1497	/** gini_missc(ii, jj) describes how well variable jj can describe a partition
1487	1498	* created on variable ii(when variable ii was chosen)
1488		*/
	1499	*/
1489	1500	MultiArray<2, double> gini_missc;
1490	1501	MultiArray<2, int> tmp_labels;
1491		/** additional noise features.
	1502	/** additional noise features.
1492	1503	*/
1493	1504	MultiArray<2, double> noise;
1494	1505	MultiArray<2, double> noise_l;

1498	1509	MultiArray<2, double> corr_l;
1499	1510
1500	1511	/** Similarity Matrix
1501		*
	1512	*
1502	1513	* (numberOfFeatures + 1) by (number Of Features + 1) Matrix
1503		* gini_missc
	1514	* gini_missc
1504	1515	* - row normalized by the number of times the column was chosen
1505	1516	* - mean of corr_noise subtracted
1506		* - and symmetrised.
1507		*
	1517	* - and symmetrised.
	1518	*
1508	1519	*/
1509	1520	MultiArray<2, double> similarity;
1510	1521	/** Distance Matrix 1-similarity
1511	1522	*/
1512	1523	MultiArray<2, double> distance;
1513	1524	ArrayVector<int> tmp_cc;
1514
	1525
1515	1526	/** How often was variable ii chosen
1516	1527	*/
1517	1528	ArrayVector<int> numChoices;
1518	1529	typedef BestGiniOfColumn<GiniCriterion> ColumnDecisionFunctor;
1519	1530	BestGiniOfColumn<GiniCriterion> bgfunc;
1520		void save(std::string file, std::string prefix)
	1531	void save(std::string, std::string)
1521	1532	{
1522	1533	/*
1523	1534	std::string tmp;

1553	1564	noise_l[ii] = random.uniform53() > 0.5;
1554	1565	}
1555	1566	bgfunc = ColumnDecisionFunctor( rf.ext_param_);
1556		tmp_labels.reshape(pr.response().shape());
	1567	tmp_labels.reshape(pr.response().shape());
1557	1568	tmp_cc.resize(2);
1558	1569	numChoices.resize(n+1);
1559	1570	// look at all axes
1560	1571	}
1561	1572	template<class RF, class PR>
1562		void visit_at_end(RF const & rf, PR const & pr)
	1573	void visit_at_end(RF const &, PR const &)
1563	1574	{
1564	1575	typedef MultiArrayShape<2>::type Shp;
1565	1576	similarity.reshape(gini_missc.shape());
1566	1577	similarity = gini_missc;;
1567	1578	MultiArray<2, double> mean_noise(Shp(corr_noise.shape(0), 1));
1568	1579	rowStatistics(corr_noise, mean_noise);
1569		mean_noise/= MultiArrayView<2, int>(mean_noise.shape(), numChoices.data());
	1580	mean_noise/= MultiArrayView<2, int>(mean_noise.shape(), numChoices.data());
1570	1581	int rC = similarity.shape(0);
1571	1582	for(int jj = 0; jj < rC-1; ++jj)
1572	1583	{

1581	1592	similarity = abs(similarity);
1582	1593	FindMinMax<double> minmax;
1583	1594	inspectMultiArray(srcMultiArrayRange(similarity), minmax);
1584
	1595
1585	1596	for(int jj = 0; jj < rC; ++jj)
1586	1597	similarity(jj, jj) = minmax.max;
1587
1588		similarity.subarray(Shp(0,0), Shp(rC-1, rC-1))
	1598
	1599	similarity.subarray(Shp(0,0), Shp(rC-1, rC-1))
1589	1600	+= similarity.subarray(Shp(0,0), Shp(rC-1, rC-1)).transpose();
1590		similarity.subarray(Shp(0,0), Shp(rC-1, rC-1))/= 2;
	1601	similarity.subarray(Shp(0,0), Shp(rC-1, rC-1))/= 2;
1591	1602	columnVector(similarity, rC-1) = rowVector(similarity, rC-1).transpose();
1592	1603	for(int jj = 0; jj < rC; ++jj)
1593	1604	similarity(jj, jj) = 0;
1594
	1605
1595	1606	FindMinMax<double> minmax2;
1596	1607	inspectMultiArray(srcMultiArrayRange(similarity), minmax2);
1597	1608	for(int jj = 0; jj < rC; ++jj)
1598	1609	similarity(jj, jj) = minmax2.max;
1599	1610	distance.reshape(gini_missc.shape(), minmax2.max);
1600		distance -= similarity;
	1611	distance -= similarity;
1601	1612	}
1602	1613
1603	1614	template<class Tree, class Split, class Region, class Feature_t, class Label_t>
1604		void visit_after_split( Tree & tree,
	1615	void visit_after_split( Tree &,
1605	1616	Split & split,
1606	1617	Region & parent,
1607		Region & leftChild,
1608		Region & rightChild,
	1618	Region &,
	1619	Region &,
1609	1620	Feature_t & features,
1610	1621	Label_t & labels)
1611	1622	{
1612	1623	if(split.createNode().typeID() == i_ThresholdNode)
1613	1624	{
1614	1625	double wgini;
1615		tmp_cc.init(0);
	1626	tmp_cc.init(0);
1616	1627	for(int ii = 0; ii < parent.size(); ++ii)
1617	1628	{
1618		tmp_labels[parent[ii]]
	1629	tmp_labels[parent[ii]]
1619	1630	= (features(parent[ii], split.bestSplitColumn()) < split.bestSplitThreshold());
1620	1631	++tmp_cc[tmp_labels[parent[ii]]];
1621	1632	}
1622		double region_gini = bgfunc.loss_of_region(tmp_labels,
	1633	double region_gini = bgfunc.loss_of_region(tmp_labels,
1623	1634	parent.begin(),
1624	1635	parent.end(),
1625	1636	tmp_cc);
1626	1637
1627		int n = split.bestSplitColumn();
	1638	int n = split.bestSplitColumn();
1628	1639	++numChoices[n];
1629	1640	++(*(numChoices.end()-1));
1630	1641	//this functor does all the work
1631	1642	for(int k = 0; k < features.shape(1); ++k)
1632	1643	{
1633	1644	bgfunc(columnVector(features, k),
1634		tmp_labels,
1635		parent.begin(), parent.end(),
	1645	tmp_labels,
	1646	parent.begin(), parent.end(),
1636	1647	tmp_cc);
1637	1648	wgini = (region_gini - bgfunc.min_gini_);
1638		gini_missc(n, k)
	1649	gini_missc(n, k)
1639	1650	+= wgini;
1640	1651	}
1641	1652	for(int k = 0; k < 10; ++k)
1642	1653	{
1643	1654	bgfunc(columnVector(noise, k),
1644		tmp_labels,
1645		parent.begin(), parent.end(),
	1655	tmp_labels,
	1656	parent.begin(), parent.end(),
1646	1657	tmp_cc);
1647	1658	wgini = (region_gini - bgfunc.min_gini_);
1648		corr_noise(n, k)
	1659	corr_noise(n, k)
1649	1660	+= wgini;
1650	1661	}
1651
	1662
1652	1663	for(int k = 0; k < 10; ++k)
1653	1664	{
1654	1665	bgfunc(columnVector(noise_l, k),
1655		tmp_labels,
1656		parent.begin(), parent.end(),
	1666	tmp_labels,
	1667	parent.begin(), parent.end(),
1657	1668	tmp_cc);
1658	1669	wgini = (region_gini - bgfunc.min_gini_);
1659		corr_l(n, k)
	1670	corr_l(n, k)
1660	1671	+= wgini;
1661	1672	}
1662	1673	bgfunc(labels, tmp_labels, parent.begin(), parent.end(),tmp_cc);
1663	1674	wgini = (region_gini - bgfunc.min_gini_);
1664		gini_missc(n, columnCount(gini_missc)-1)
	1675	gini_missc(n, columnCount(gini_missc)-1)
1665	1676	+= wgini;
1666
	1677
1667	1678	region_gini = split.region_gini_;
1668		#if 1
	1679	#if 1
1669	1680	Node<i_ThresholdNode> node(split.createNode());
1670		gini_missc(rowCount(gini_missc)-1,
1671		node.column())
	1681	gini_missc(rowCount(gini_missc)-1,
	1682	node.column())
1672	1683	+=split.region_gini_ - split.minGini();
1673	1684	#endif
1674	1685	for(int k = 0; k < 10; ++k)
1675	1686	{
1676	1687	split.bgfunc(columnVector(noise, k),
1677		labels,
1678		parent.begin(), parent.end(),
	1688	labels,
	1689	parent.begin(), parent.end(),
1679	1690	parent.classCounts());
1680		corr_noise(rowCount(gini_missc)-1,
1681		k)
	1691	corr_noise(rowCount(gini_missc)-1,
	1692	k)
1682	1693	+= wgini;
1683	1694	}
1684	1695	#if 0
1685	1696	for(int k = 0; k < tree.ext_param_.actual_mtry_; ++k)
1686	1697	{
1687	1698	wgini = region_gini - split.min_gini_[k];
1688
1689		gini_missc(rowCount(gini_missc)-1,
1690		split.splitColumns[k])
	1699
	1700	gini_missc(rowCount(gini_missc)-1,
	1701	split.splitColumns[k])
1691	1702	+= wgini;
1692	1703	}
1693
	1704
1694	1705	for(int k=tree.ext_param_.actual_mtry_; k<features.shape(1); ++k)
1695	1706	{
1696	1707	split.bgfunc(columnVector(features, split.splitColumns[k]),
1697		labels,
1698		parent.begin(), parent.end(),
	1708	labels,
	1709	parent.begin(), parent.end(),
1699	1710	parent.classCounts());
1700	1711	wgini = region_gini - split.bgfunc.min_gini_;
1701		gini_missc(rowCount(gini_missc)-1,
	1712	gini_missc(rowCount(gini_missc)-1,
1702	1713	split.splitColumns[k]) += wgini;
1703	1714	}
1704	1715	#endif
1705	1716	// remember to partition the data according to the best.
1706		gini_missc(rowCount(gini_missc)-1,
1707		columnCount(gini_missc)-1)
	1717	gini_missc(rowCount(gini_missc)-1,
	1718	columnCount(gini_missc)-1)
1708	1719	+= region_gini;
1709		SortSamplesByDimensions<Feature_t>
	1720	SortSamplesByDimensions<Feature_t>
1710	1721	sorter(features, split.bestSplitColumn(), split.bestSplitThreshold());
1711	1722	std::partition(parent.begin(), parent.end(), sorter);
1712	1723	}

1718	1729	} // namespace rf
1719	1730	} // namespace vigra
1720	1731
1721		//@}
1722	1732	#endif // RF_VISITORS_HXX

+236

-230

include/vigra/random_forest.hxx less more

46	46	#include "array_vector.hxx"
47	47	#include "sized_int.hxx"
48	48	#include "matrix.hxx"
	49	#include "metaprogramming.hxx"
49	50	#include "random.hxx"
50	51	#include "functorexpression.hxx"
51	52	#include "random_forest/rf_common.hxx"

64	65
65	66	/** \addtogroup MachineLearning Machine Learning
66	67
67		This module provides classification algorithms that map
	68	This module provides classification algorithms that map
68	69	features to labels or label probabilities.
69		Look at the RandomForest class first for a overview of most of the
70		functionality provided as well as use cases.
	70	Look at the \ref vigra::RandomForest class (for implementation version 2) or the
	71	\ref vigra::rf3::random_forest() factory function (for implementation version 3)
	72	for an overview of the functionality as well as use cases.
71	73	**/
72		//@{
73	74
74	75	namespace detail
75	76	{

87	88	}
88	89	}//namespace detail
89	90
90		/** Random Forest class
	91	/** \brief Random forest version 2 (see also \ref vigra::rf3::RandomForest for version 3)
	92	*
	93	* \ingroup MachineLearning
91	94	*
92	95	* \tparam <LabelType = double> Type used for predicted labels.
93	96	* \tparam <PreprocessorTag = ClassificationTag> Class used to preprocess
94	97	* the input while learning and predicting. Currently Available:
95	98	* ClassificationTag and RegressionTag. It is recommended to use
96	99	* Splitfunctor::Preprocessor_t while using custom splitfunctors
97		* as they may need the data to be in a different format.
	100	* as they may need the data to be in a different format.
98	101	* \sa Preprocessor
99		*
	102	*
100	103	* Simple usage for classification (regression is not yet supported):
101	104	* look at RandomForest::learn() as well as RandomForestOptions() for additional
102		* options.
	105	* options.
103	106	*
104	107	* \code
105	108	* using namespace vigra;
106	109	* using namespace rf;
107	110	* typedef xxx feature_t; \\ replace xxx with whichever type
108		* typedef yyy label_t; \\ likewise
109		*
	111	* typedef yyy label_t; \\ likewise
	112	*
110	113	* // allocate the training data
111	114	* MultiArrayView<2, feature_t> f = get_training_features();
112	115	* MultiArrayView<2, label_t> l = get_training_labels();
113		*
	116	*
114	117	* RandomForest<label_t> rf;
115	118	*
116	119	* // construct visitor to calculate out-of-bag error

120	123	* rf.learn(f, l, visitors::create_visitor(oob_v));
121	124	*
122	125	* std::cout << "the out-of-bag error is: " << oob_v.oob_breiman << "\n";
123		*
	126	*
124	127	* // get features for new data to be used for prediction
125	128	* MultiArrayView<2, feature_t> pf = get_features();
126	129	*
127	130	* // allocate space for the response (pf.shape(0) is the number of samples)
128	131	* MultiArrayView<2, label_t> prediction(pf.shape(0), 1);
129	132	* MultiArrayView<2, double> prob(pf.shape(0), rf.class_count());
130		*
	133	*
131	134	* // perform prediction on new data
132	135	* rf.predictLabels(pf, prediction);
133	136	* rf.predictProbabilities(pf, prob);

135	138	* \endcode
136	139	*
137	140	* Additional information such as Variable Importance measures are accessed
138		* via Visitors defined in rf::visitors.
	141	* via Visitors defined in rf::visitors.
139	142	* Have a look at rf::split for other splitting methods.
140	143	*
141	144	*/

153	156	typedef rf::visitors::StopVisiting Default_Visitor_t;
154	157	typedef DT_StackEntry<ArrayVectorView<Int32>::iterator>
155	158	StackEntry_t;
156		typedef LabelType LabelT;
	159	typedef LabelType LabelT;
157	160
158	161	//problem independent data.
159	162	Options_t options_;

175	178	public:
176	179
177	180	/** \name Constructors
178		* Note: No copy Constructor specified as no pointers are manipulated
	181	* Note: No copy constructor specified as no pointers are manipulated
179	182	* in this class
180		*/
181		/\{/
182		/**\brief default constructor
	183
	184	* @{
	185	*/
	186
	187	/**\brief default constructor
183	188	*
184	189	* \param options general options to the Random Forest. Must be of Type
185	190	* Options_t
186		* \param ext_param problem specific values that can be supplied
	191	* \param ext_param problem specific values that can be supplied
187	192	* additionally. (class weights , labels etc)
188	193	* \sa RandomForestOptions, ProblemSpec
189	194	*
190	195	*/
191		RandomForest(Options_t const & options = Options_t(),
	196	RandomForest(Options_t const & options = Options_t(),
192	197	ProblemSpec_t const & ext_param = ProblemSpec_t())
193	198	:
194	199	options_(options),

201	206
202	207	/**\brief Create RF from external source
203	208	* \param treeCount Number of trees to add.
204		* \param topology_begin
	209	* \param topology_begin
205	210	* Iterator to a Container where the topology_ data
206	211	* of the trees are stored.
207		* Iterator should support at least treeCount forward
	212	* Iterator should support at least treeCount forward
208	213	* iterations. (i.e. topology_end - topology_begin >= treeCount
209		* \param parameter_begin
	214	* \param parameter_begin
210	215	* iterator to a Container where the parameters_ data
211		* of the trees are stored. Iterator should support at
	216	* of the trees are stored. Iterator should support at
212	217	* least treeCount forward iterations.
213		* \param problem_spec
	218	* \param problem_spec
214	219	* Extrinsic parameters that specify the problem e.g.
215	220	* ClassCount, featureCount etc.
216	221	* \param options (optional) specify options used to train the original
217	222	* Random forest. This parameter is not used anywhere
218	223	* during prediction and thus is optional.
219	224	*
220		*/
221		/* TODO: This constructor may be replaced by a Constructor using
222		* NodeProxy iterators to encapsulate the underlying data type.
223	225	*/
224	226	template<class TopologyIterator, class ParameterIterator>
225	227	RandomForest(int treeCount,

232	234	ext_param_(problem_spec),
233	235	options_(options)
234	236	{
235		for(unsigned int k=0; k<treeCount; ++k, ++topology_begin, ++parameter_begin)
	237	/* TODO: This constructor may be replaced by a Constructor using
	238	* NodeProxy iterators to encapsulate the underlying data type.
	239	*/
	240	for(int k=0; k<treeCount; ++k, ++topology_begin, ++parameter_begin)
236	241	{
237	242	trees_[k].topology_ = *topology_begin;
238	243	trees_[k].parameters_ = *parameter_begin;
239	244	}
240	245	}
241	246
242		/\}/
	247	/** @} */
243	248
244	249
245	250	/** \name Data Access
246	251	* data access interface - usage of member variables is deprecated
247		*/
248
249		/\{/
250
	252	*
	253	* @{
	254	*/
251	255
252	256	/**\brief return external parameters for viewing
253	257	* \return ProblemSpec_t

264	268	*
265	269	* \param in external parameters to be set
266	270	*
267		* set external parameters explicitly.
268		* If Random Forest has not been trained the preprocessor will
269		* either ignore filling values set this way or will throw an exception
270		* if values specified manually do not match the value calculated
	271	* set external parameters explicitly.
	272	* If Random Forest has not been trained the preprocessor will
	273	* either ignore filling values set this way or will throw an exception
	274	* if values specified manually do not match the value calculated
271	275	& during the preparation step.
272	276	*/
273	277	void set_ext_param(ProblemSpec_t const & in)
274	278	{
	279	ignore_argument(in);
275	280	vigra_precondition(ext_param_.used() == false,
276	281	"RandomForest::set_ext_param():"
277	282	"Random forest has been trained! Call reset()"

311	316	return trees_[index];
312	317	}
313	318
314		/\}/
315
316		/**\brief return number of features used while
	319	/**\brief return number of features used while
317	320	* training.
318	321	*/
319	322	int feature_count() const
320	323	{
321	324	return ext_param_.column_count_;
322	325	}
323
324
325		/**\brief return number of features used while
	326
	327
	328	/**\brief return number of features used while
326	329	* training.
327	330	*
328	331	* deprecated. Use feature_count() instead.

332	335	return ext_param_.column_count_;
333	336	}
334	337
335		/**\brief return number of classes used while
	338	/**\brief return number of classes used while
336	339	* training.
337	340	*/
338	341	int class_count() const

347	350	return options_.tree_count_;
348	351	}
349	352
350
351
	353	/** @} */
	354
	355	/**\name Learning
	356	* Following functions differ in the degree of customization
	357	* allowed
	358	*
	359	* @{
	360	*/
	361
	362	/**\brief learn on data with custom config and random number generator
	363	*
	364	* \param features a N x M matrix containing N samples with M
	365	* features
	366	* \param response a N x D matrix containing the corresponding
	367	* response. Current split functors assume D to
	368	* be 1 and ignore any additional columns.
	369	* This is not enforced to allow future support
	370	* for uncertain labels, label independent strata etc.
	371	* The Preprocessor specified during construction
	372	* should be able to handle features and labels
	373	* features and the labels.
	374	* see also: SplitFunctor, Preprocessing
	375	*
	376	* \param visitor visitor which is to be applied after each split,
	377	* tree and at the end. Use rf_default() for using
	378	* default value. (No Visitors)
	379	* see also: rf::visitors
	380	* \param split split functor to be used to calculate each split
	381	* use rf_default() for using default value. (GiniSplit)
	382	* see also: rf::split
	383	* \param stop
	384	* predicate to be used to calculate each split
	385	* use rf_default() for using default value. (EarlyStoppStd)
	386	* \param random RandomNumberGenerator to be used. Use
	387	* rf_default() to use default value.(RandomMT19337)
	388	*
	389	*
	390	*/
	391	template <class U, class C1,
	392	class U2,class C2,
	393	class Split_t,
	394	class Stop_t,
	395	class Visitor_t,
	396	class Random_t>
	397	void learn( MultiArrayView<2, U, C1> const & features,
	398	MultiArrayView<2, U2,C2> const & response,
	399	Visitor_t visitor,
	400	Split_t split,
	401	Stop_t stop,
	402	Random_t const & random);
	403
	404	template <class U, class C1,
	405	class U2,class C2,
	406	class Split_t,
	407	class Stop_t,
	408	class Visitor_t>
	409	void learn( MultiArrayView<2, U, C1> const & features,
	410	MultiArrayView<2, U2,C2> const & response,
	411	Visitor_t visitor,
	412	Split_t split,
	413	Stop_t stop)
	414
	415	{
	416	RandomNumberGenerator<> rnd = RandomNumberGenerator<>(RandomSeed);
	417	learn( features,
	418	response,
	419	visitor,
	420	split,
	421	stop,
	422	rnd);
	423	}
	424
	425	template <class U, class C1, class U2,class C2, class Visitor_t>
	426	void learn( MultiArrayView<2, U, C1> const & features,
	427	MultiArrayView<2, U2,C2> const & labels,
	428	Visitor_t visitor)
	429	{
	430	learn( features,
	431	labels,
	432	visitor,
	433	rf_default(),
	434	rf_default());
	435	}
	436
	437	template <class U, class C1, class U2,class C2,
	438	class Visitor_t, class Split_t>
	439	void learn( MultiArrayView<2, U, C1> const & features,
	440	MultiArrayView<2, U2,C2> const & labels,
	441	Visitor_t visitor,
	442	Split_t split)
	443	{
	444	learn( features,
	445	labels,
	446	visitor,
	447	split,
	448	rf_default());
	449	}
	450
	451	/**\brief learn on data with default configuration
	452	*
	453	* \param features a N x M matrix containing N samples with M
	454	* features
	455	* \param labels a N x D matrix containing the corresponding
	456	* N labels. Current split functors assume D to
	457	* be 1 and ignore any additional columns.
	458	* this is not enforced to allow future support
	459	* for uncertain labels.
	460	*
	461	* learning is done with:
	462	*
	463	* \sa rf::split, EarlyStoppStd
	464	*
	465	* - Randomly seeded random number generator
	466	* - default gini split functor as described by Breiman
	467	* - default The standard early stopping criterion
	468	*/
	469	template <class U, class C1, class U2,class C2>
	470	void learn( MultiArrayView<2, U, C1> const & features,
	471	MultiArrayView<2, U2,C2> const & labels)
	472	{
	473	learn( features,
	474	labels,
	475	rf_default(),
	476	rf_default(),
	477	rf_default());
	478	}
	479
	480
352	481	template<class U,class C1,
353	482	class U2, class C2,
354	483	class Split_t,

369	498	MultiArrayView<2, U2,C2> const & labels,int new_start_index,bool adjust_thresholds=false)
370	499	{
371	500	RandomNumberGenerator<> rnd = RandomNumberGenerator<>(RandomSeed);
372		onlineLearn(features,
373		labels,
	501	onlineLearn(features,
	502	labels,
374	503	new_start_index,
375		rf_default(),
376		rf_default(),
	504	rf_default(),
	505	rf_default(),
377	506	rf_default(),
378	507	rnd,
379	508	adjust_thresholds);

408	537	rnd);
409	538	}
410	539
411
412		/**\name Learning
413		* Following functions differ in the degree of customization
414		* allowed
415		*/
416		/\{/
417		/**\brief learn on data with custom config and random number generator
418		*
419		* \param features a N x M matrix containing N samples with M
420		* features
421		* \param response a N x D matrix containing the corresponding
422		* response. Current split functors assume D to
423		* be 1 and ignore any additional columns.
424		* This is not enforced to allow future support
425		* for uncertain labels, label independent strata etc.
426		* The Preprocessor specified during construction
427		* should be able to handle features and labels
428		* features and the labels.
429		* see also: SplitFunctor, Preprocessing
430		*
431		* \param visitor visitor which is to be applied after each split,
432		* tree and at the end. Use rf_default() for using
433		* default value. (No Visitors)
434		* see also: rf::visitors
435		* \param split split functor to be used to calculate each split
436		* use rf_default() for using default value. (GiniSplit)
437		* see also: rf::split
438		* \param stop
439		* predicate to be used to calculate each split
440		* use rf_default() for using default value. (EarlyStoppStd)
441		* \param random RandomNumberGenerator to be used. Use
442		* rf_default() to use default value.(RandomMT19337)
443		*
444		*
445		*/
446		template <class U, class C1,
447		class U2,class C2,
448		class Split_t,
449		class Stop_t,
450		class Visitor_t,
451		class Random_t>
452		void learn( MultiArrayView<2, U, C1> const & features,
453		MultiArrayView<2, U2,C2> const & response,
454		Visitor_t visitor,
455		Split_t split,
456		Stop_t stop,
457		Random_t const & random);
458
459		template <class U, class C1,
460		class U2,class C2,
461		class Split_t,
462		class Stop_t,
463		class Visitor_t>
464		void learn( MultiArrayView<2, U, C1> const & features,
465		MultiArrayView<2, U2,C2> const & response,
466		Visitor_t visitor,
467		Split_t split,
468		Stop_t stop)
469
470		{
471		RandomNumberGenerator<> rnd = RandomNumberGenerator<>(RandomSeed);
472		learn( features,
473		response,
474		visitor,
475		split,
476		stop,
477		rnd);
478		}
479
480		template <class U, class C1, class U2,class C2, class Visitor_t>
481		void learn( MultiArrayView<2, U, C1> const & features,
482		MultiArrayView<2, U2,C2> const & labels,
483		Visitor_t visitor)
484		{
485		learn( features,
486		labels,
487		visitor,
488		rf_default(),
489		rf_default());
490		}
491
492		template <class U, class C1, class U2,class C2,
493		class Visitor_t, class Split_t>
494		void learn( MultiArrayView<2, U, C1> const & features,
495		MultiArrayView<2, U2,C2> const & labels,
496		Visitor_t visitor,
497		Split_t split)
498		{
499		learn( features,
500		labels,
501		visitor,
502		split,
503		rf_default());
504		}
505
506		/**\brief learn on data with default configuration
507		*
508		* \param features a N x M matrix containing N samples with M
509		* features
510		* \param labels a N x D matrix containing the corresponding
511		* N labels. Current split functors assume D to
512		* be 1 and ignore any additional columns.
513		* this is not enforced to allow future support
514		* for uncertain labels.
515		*
516		* learning is done with:
517		*
518		* \sa rf::split, EarlyStoppStd
519		*
520		* - Randomly seeded random number generator
521		* - default gini split functor as described by Breiman
522		* - default The standard early stopping criterion
523		*/
524		template <class U, class C1, class U2,class C2>
525		void learn( MultiArrayView<2, U, C1> const & features,
526		MultiArrayView<2, U2,C2> const & labels)
527		{
528		learn( features,
529		labels,
530		rf_default(),
531		rf_default(),
532		rf_default());
533		}
534		/\}/
535
536
537
538		/**\name prediction
539		*/
540		/\{/
	540	/** @} */
	541
	542
	543
	544	/**\name Prediction
	545	*
	546	* @{
	547	*/
	548
541	549	/** \brief predict a label given a feature.
542	550	*
543	551	* \param features: a 1 by featureCount matrix containing

547	555	* \return double value representing class. You can use the
548	556	* predictLabels() function together with the
549	557	* rf.external_parameter().class_type_ attribute
550		* to get back the same type used during learning.
	558	* to get back the same type used during learning.
551	559	*/
552	560	template <class U, class C, class Stop>
553	561	LabelType predictLabel(MultiArrayView<2, U, C>const & features, Stop & stop) const;

555	563	template <class U, class C>
556	564	LabelType predictLabel(MultiArrayView<2, U, C>const & features)
557	565	{
558		return predictLabel(features, rf_default());
559		}
	566	return predictLabel(features, rf_default());
	567	}
560	568	/** \brief predict a label with features and class priors
561	569	*
562	570	* \param features: same as above.

643	651	* save class probabilities
644	652	* \param stop earlystopping criterion
645	653	* \sa EarlyStopping
646
	654
647	655	When a row of the feature array contains an NaN, the corresponding instance
648		cannot belong to any of the classes. The corresponding row in the probability
	656	cannot belong to any of the classes. The corresponding row in the probability
649	657	array will therefore contain all zeros.
650	658	*/
651	659	template <class U, class C1, class T, class C2, class Stop>

666	674	void predictProbabilities(MultiArrayView<2, U, C1>const & features,
667	675	MultiArrayView<2, T, C2> & prob) const
668	676	{
669		predictProbabilities(features, prob, rf_default());
670		}
	677	predictProbabilities(features, prob, rf_default());
	678	}
671	679
672	680	template <class U, class C1, class T, class C2>
673	681	void predictRaw(MultiArrayView<2, U, C1>const & features,
674	682	MultiArrayView<2, T, C2> & prob) const;
675	683
676	684
677		/\}/
	685	/** @} */
678	686
679	687	};
680	688

707	715	// Value Chooser chooses second argument as value if first argument
708	716	// is of type RF_DEFAULT. (thanks to template magic - don't care about
709	717	// it - just smile and wave.
710
711		#define RF_CHOOSER(type_) detail::Value_Chooser<type_, Default_##type_>
	718
	719	#define RF_CHOOSER(type_) detail::Value_Chooser<type_, Default_##type_>
712	720	Default_Stop_t default_stop(options_);
713	721	typename RF_CHOOSER(Stop_t)::type stop
714		= RF_CHOOSER(Stop_t)::choose(stop_, default_stop);
	722	= RF_CHOOSER(Stop_t)::choose(stop_, default_stop);
715	723	Default_Split_t default_split;
716		typename RF_CHOOSER(Split_t)::type split
717		= RF_CHOOSER(Split_t)::choose(split_, default_split);
	724	typename RF_CHOOSER(Split_t)::type split
	725	= RF_CHOOSER(Split_t)::choose(split_, default_split);
718	726	rf::visitors::StopVisiting stopvisiting;
719	727	typedef rf::visitors::detail::VisitorNode
720		<rf::visitors::OnlineLearnVisitor,
721		typename RF_CHOOSER(Visitor_t)::type>
722		IntermedVis;
	728	<rf::visitors::OnlineLearnVisitor,
	729	typename RF_CHOOSER(Visitor_t)::type>
	730	IntermedVis;
723	731	IntermedVis
724	732	visitor(online_visitor_, RF_CHOOSER(Visitor_t)::choose(visitor_, stopvisiting));
725	733	#undef RF_CHOOSER

835	843	Random_t & random)
836	844	{
837	845	using namespace rf;
838
839
	846
	847
840	848	typedef UniformIntRandomFunctor<Random_t>
841	849	RandFunctor_t;
842	850
843	851	// See rf_preprocessing.hxx for more info on this
844	852	ext_param_.class_count_=0;
845	853	typedef Processor<PreprocessorTag,LabelType, U, C1, U2, C2> Preprocessor_t;
846
	854
847	855	// default values and initialization
848	856	// Value Chooser chooses second argument as value if first argument
849	857	// is of type RF_DEFAULT. (thanks to template magic - don't care about
850	858	// it - just smile and wave.
851
852		#define RF_CHOOSER(type_) detail::Value_Chooser<type_, Default_##type_>
	859
	860	#define RF_CHOOSER(type_) detail::Value_Chooser<type_, Default_##type_>
853	861	Default_Stop_t default_stop(options_);
854	862	typename RF_CHOOSER(Stop_t)::type stop
855		= RF_CHOOSER(Stop_t)::choose(stop_, default_stop);
	863	= RF_CHOOSER(Stop_t)::choose(stop_, default_stop);
856	864	Default_Split_t default_split;
857		typename RF_CHOOSER(Split_t)::type split
858		= RF_CHOOSER(Split_t)::choose(split_, default_split);
	865	typename RF_CHOOSER(Split_t)::type split
	866	= RF_CHOOSER(Split_t)::choose(split_, default_split);
859	867	rf::visitors::StopVisiting stopvisiting;
860	868	typedef rf::visitors::detail::VisitorNode
861		<rf::visitors::OnlineLearnVisitor,
862		typename RF_CHOOSER(Visitor_t)::type> IntermedVis;
	869	<rf::visitors::OnlineLearnVisitor,
	870	typename RF_CHOOSER(Visitor_t)::type> IntermedVis;
863	871	IntermedVis
864	872	visitor(online_visitor_, RF_CHOOSER(Visitor_t)::choose(visitor_, stopvisiting));
865	873	#undef RF_CHOOSER

947	955
948	956	vigra_precondition(features.shape(0) == response.shape(0),
949	957	"RandomForest::learn(): shape mismatch between features and response.");
950
	958
951	959	// default values and initialization
952	960	// Value Chooser chooses second argument as value if first argument
953	961	// is of type RF_DEFAULT. (thanks to template magic - don't care about
954	962	// it - just smile and wave).
955
956		#define RF_CHOOSER(type_) detail::Value_Chooser<type_, Default_##type_>
	963
	964	#define RF_CHOOSER(type_) detail::Value_Chooser<type_, Default_##type_>
957	965	Default_Stop_t default_stop(options_);
958	966	typename RF_CHOOSER(Stop_t)::type stop
959		= RF_CHOOSER(Stop_t)::choose(stop_, default_stop);
	967	= RF_CHOOSER(Stop_t)::choose(stop_, default_stop);
960	968	Default_Split_t default_split;
961		typename RF_CHOOSER(Split_t)::type split
962		= RF_CHOOSER(Split_t)::choose(split_, default_split);
	969	typename RF_CHOOSER(Split_t)::type split
	970	= RF_CHOOSER(Split_t)::choose(split_, default_split);
963	971	rf::visitors::StopVisiting stopvisiting;
964	972	typedef rf::visitors::detail::VisitorNode<
965		rf::visitors::OnlineLearnVisitor,
966		typename RF_CHOOSER(Visitor_t)::type> IntermedVis;
	973	rf::visitors::OnlineLearnVisitor,
	974	typename RF_CHOOSER(Visitor_t)::type> IntermedVis;
967	975	IntermedVis
968	976	visitor(online_visitor_, RF_CHOOSER(Visitor_t)::choose(visitor_, stopvisiting));
969	977	#undef RF_CHOOSER

1000	1008
1001	1009	visitor.visit_at_beginning(*this, preprocessor);
1002	1010	// THE MAIN EFFING RF LOOP - YEAY DUDE!
1003
	1011
1004	1012	for(int ii = 0; ii < static_cast<int>(trees_.size()); ++ii)
1005	1013	{
1006	1014	//initialize First region/node/stack entry
1007	1015	sampler
1008		.sample();
	1016	.sample();
1009	1017	StackEntry_t
1010	1018	first_stack_entry( sampler.sampledIndices().begin(),
1011	1019	sampler.sampledIndices().end(),

1087	1095	{
1088	1096	//Features are n xp
1089	1097	//prob is n x NumOfLabel probability for each feature in each class
1090
	1098
1091	1099	vigra_precondition(rowCount(predictionSet.features) == rowCount(prob),
1092	1100	"RandomFroest::predictProbabilities():"
1093	1101	" Feature matrix and probability matrix size mismatch.");

1244	1252	"RandomForestn::predictProbabilities():"
1245	1253	" Probability matrix must have as many columns as there are classes.");
1246	1254
1247		#define RF_CHOOSER(type_) detail::Value_Chooser<type_, Default_##type_>
	1255	#define RF_CHOOSER(type_) detail::Value_Chooser<type_, Default_##type_>
1248	1256	Default_Stop_t default_stop(options_);
1249	1257	typename RF_CHOOSER(Stop_t)::type & stop
1250		= RF_CHOOSER(Stop_t)::choose(stop_, default_stop);
1251		#undef RF_CHOOSER
	1258	= RF_CHOOSER(Stop_t)::choose(stop_, default_stop);
	1259	#undef RF_CHOOSER
1252	1260	stop.set_external_parameters(ext_param_, tree_count());
1253	1261	prob.init(NumericTraits<T>::zero());
1254	1262	/* This code was originally there for testing early stopping

1256	1264	if(tree_indices_.size() != 0)
1257	1265	{
1258	1266	std::random_shuffle(tree_indices_.begin(),
1259		tree_indices_.end());
	1267	tree_indices_.end());
1260	1268	}
1261	1269	*/
1262	1270	//Classify for each row.
1263	1271	for(int row=0; row < rowCount(features); ++row)
1264	1272	{
1265	1273	MultiArrayView<2, U, StridedArrayTag> currentRow(rowVector(features, row));
1266
	1274
1267	1275	// when the features contain an NaN, the instance doesn't belong to any class
1268	1276	// => indicate this by returning a zero probability array.
1269	1277	if(detail::contains_nan(currentRow))

1271	1279	rowVector(prob, row).init(0.0);
1272	1280	continue;
1273	1281	}
1274
	1282
1275	1283	ArrayVector<double>::const_iterator weights;
1276	1284
1277	1285	//totalWeight == totalVoteCount!

1293	1301	//every weight in totalWeight.
1294	1302	totalWeight += cur_w;
1295	1303	}
1296		if(stop.after_prediction(weights,
	1304	if(stop.after_prediction(weights,
1297	1305	k,
1298	1306	rowVector(prob, row),
1299	1307	totalWeight))

1334	1342	"RandomForestn::predictProbabilities():"
1335	1343	" Probability matrix must have as many columns as there are classes.");
1336	1344
1337		#define RF_CHOOSER(type_) detail::Value_Chooser<type_, Default_##type_>
	1345	#define RF_CHOOSER(type_) detail::Value_Chooser<type_, Default_##type_>
1338	1346	prob.init(NumericTraits<T>::zero());
1339	1347	/* This code was originally there for testing early stopping
1340	1348	* - we wanted the order of the trees to be randomized
1341	1349	if(tree_indices_.size() != 0)
1342	1350	{
1343	1351	std::random_shuffle(tree_indices_.begin(),
1344		tree_indices_.end());
	1352	tree_indices_.end());
1345	1353	}
1346	1354	*/
1347	1355	//Classify for each row.

1374	1382
1375	1383	}
1376	1384
1377		//@}
1378
1379	1385	} // namespace vigra
1380	1386
1381	1387	#include "random_forest/rf_algorithm.hxx"

+443

-0

include/vigra/random_forest_3/random_forest.hxx less more

	0	/************************************************************************/
	1	/* */
	2	/* Copyright 2014-2015 by Ullrich Koethe and Philip Schill */
	3	/* */
	4	/* This file is part of the VIGRA computer vision library. */
	5	/* The VIGRA Website is */
	6	/* http://hci.iwr.uni-heidelberg.de/vigra/ */
	7	/* Please direct questions, bug reports, and contributions to */
	8	/* ullrich.koethe@iwr.uni-heidelberg.de or */
	9	/* vigra@informatik.uni-hamburg.de */
	10	/* */
	11	/* Permission is hereby granted, free of charge, to any person */
	12	/* obtaining a copy of this software and associated documentation */
	13	/* files (the "Software"), to deal in the Software without */
	14	/* restriction, including without limitation the rights to use, */
	15	/* copy, modify, merge, publish, distribute, sublicense, and/or */
	16	/* sell copies of the Software, and to permit persons to whom the */
	17	/* Software is furnished to do so, subject to the following */
	18	/* conditions: */
	19	/* */
	20	/* The above copyright notice and this permission notice shall be */
	21	/* included in all copies or substantial portions of the */
	22	/* Software. */
	23	/* */
	24	/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND */
	25	/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES */
	26	/* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND */
	27	/* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT */
	28	/* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, */
	29	/* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING */
	30	/* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR */
	31	/* OTHER DEALINGS IN THE SOFTWARE. */
	32	/* */
	33	/************************************************************************/
	34	#ifndef VIGRA_RF3_RANDOM_FOREST_HXX
	35	#define VIGRA_RF3_RANDOM_FOREST_HXX
	36
	37	#include <type_traits>
	38	#include <thread>
	39
	40	#include "../multi_shape.hxx"
	41	#include "../binary_forest.hxx"
	42	#include "../threadpool.hxx"
	43	#include "random_forest_common.hxx"
	44
	45
	46
	47	namespace vigra
	48	{
	49
	50	namespace rf3
	51	{
	52
	53	/********************************************************/
	54	/* */
	55	/* rf3::RandomForest */
	56	/* */
	57	/********************************************************/
	58
	59	/** \brief Random forest version 3.
	60
	61	vigra::rf3::RandomForest is typicall constructed via the factory function \ref vigra::rf3::random_forest().
	62	*/
	63	template <typename FEATURES,
	64	typename LABELS,
	65	typename SPLITTESTS = LessEqualSplitTest<typename FEATURES::value_type>,
	66	typename ACCTYPE = ArgMaxVectorAcc<double>>
	67	class RandomForest
	68	{
	69	public:
	70
	71	typedef FEATURES Features;
	72	typedef typename Features::value_type FeatureType;
	73	typedef LABELS Labels;
	74	typedef typename Labels::value_type LabelType;
	75	typedef SPLITTESTS SplitTests;
	76	typedef ACCTYPE ACC;
	77	typedef typename ACC::input_type AccInputType;
	78	typedef BinaryForest Graph;
	79	typedef Graph::Node Node;
	80
	81	static ContainerTag const container_tag = VectorTag;
	82
	83	// FIXME:
	84	// Once the support for Visual Studio 2012 is dropped, replace this struct with
	85	// template <typename T>
	86	// using NodeMap = PropertyMap<Node, T, container_tag>;
	87	// Then the verbose typename NodeMap<T>::type, which typically shows up on NodeMap usages,
	88	// can be replace with NodeMap<T>.
	89	template <typename T>
	90	struct NodeMap
	91	{
	92	typedef PropertyMap<Node, T, container_tag> type;
	93	};
	94
	95	// Default (empty) constructor.
	96	RandomForest();
	97
	98	// Default constructor (copy all of the given stuff).
	99	RandomForest(
	100	Graph const & graph,
	101	typename NodeMap<SplitTests>::type const & split_tests,
	102	typename NodeMap<AccInputType>::type const & node_responses,
	103	ProblemSpec<LabelType> const & problem_spec
	104	);
	105
	106	/// \brief Grow this forest by incorporating the other.
	107	void merge(
	108	RandomForest const & other
	109	);
	110
	111	/// \brief Predict the given data and return the average number of split comparisons.
	112	/// \note labels must be a 1-D array with size <tt>features.shape(0)</tt>.
	113	void predict(
	114	FEATURES const & features,
	115	LABELS & labels,
	116	int n_threads = -1,
	117	const std::vector<size_t> & tree_indices = std::vector<size_t>()
	118	) const;
	119
	120	/// \brief Predict the probabilities of the given data and return the average number of split comparisons.
	121	/// \note probs should have the shape (features.shape()[0], num_classes).
	122	template <typename PROBS>
	123	void predict_probabilities(
	124	FEATURES const & features,
	125	PROBS & probs,
	126	int n_threads = -1,
	127	const std::vector<size_t> & tree_indices = std::vector<size_t>()
	128	) const;
	129
	130	/// \brief For each data point in features, compute the corresponding leaf ids and return the average number of split comparisons.
	131	/// \note ids should have the shape (features.shape()[0], num_trees).
	132	template <typename IDS>
	133	double leaf_ids(
	134	FEATURES const & features,
	135	IDS & ids,
	136	int n_threads = -1,
	137	const std::vector<size_t> tree_indices = std::vector<size_t>()
	138	) const;
	139
	140	/// \brief Return the number of nodes.
	141	size_t num_nodes() const
	142	{
	143	return graph_.numNodes();
	144	}
	145
	146	/// \brief Return the number of trees.
	147	size_t num_trees() const
	148	{
	149	return graph_.numRoots();
	150	}
	151
	152	/// \brief Return the number of classes.
	153	size_t num_classes() const
	154	{
	155	return problem_spec_.num_classes_;
	156	}
	157
	158	/// \brief Return the number of classes.
	159	size_t num_features() const
	160	{
	161	return problem_spec_.num_features_;
	162	}
	163
	164	/// \brief The graph structure.
	165	Graph graph_;
	166
	167	/// \brief Contains a test for each internal node, that is used to determine whether given data goes to the left or the right child.
	168	typename NodeMap<SplitTests>::type split_tests_;
	169
	170	/// \brief Contains the responses of each node (for example the most frequent label).
	171	typename NodeMap<AccInputType>::type node_responses_;
	172
	173	/// \brief The specifications.
	174	ProblemSpec<LabelType> problem_spec_;
	175
	176	/// \brief The options that were used for training.
	177	RandomForestOptions options_;
	178
	179	private:
	180
	181	/// \brief Compute the leaf ids of the instances in [from, to).
	182	template <typename IDS, typename INDICES>
	183	double leaf_ids_impl(
	184	FEATURES const & features,
	185	IDS & ids,
	186	size_t from,
	187	size_t to,
	188	INDICES const & tree_indices
	189	) const;
	190
	191	template<typename PROBS>
	192	void predict_probabilities_impl(
	193	FEATURES const & features,
	194	PROBS & probs,
	195	const size_t i,
	196	const std::vector<size_t> & tree_indices) const;
	197
	198	};
	199
	200	template <typename FEATURES, typename LABELS, typename SPLITTESTS, typename ACC>
	201	RandomForest<FEATURES, LABELS, SPLITTESTS, ACC>::RandomForest()
	202	:
	203	graph_(),
	204	split_tests_(),
	205	node_responses_(),
	206	problem_spec_()
	207	{}
	208
	209	template <typename FEATURES, typename LABELS, typename SPLITTESTS, typename ACC>
	210	RandomForest<FEATURES, LABELS, SPLITTESTS, ACC>::RandomForest(
	211	Graph const & graph,
	212	typename NodeMap<SplitTests>::type const & split_tests,
	213	typename NodeMap<AccInputType>::type const & node_responses,
	214	ProblemSpec<LabelType> const & problem_spec
	215	) :
	216	graph_(graph),
	217	split_tests_(split_tests),
	218	node_responses_(node_responses),
	219	problem_spec_(problem_spec)
	220	{}
	221
	222	template <typename FEATURES, typename LABELS, typename SPLITTESTS, typename ACC>
	223	void RandomForest<FEATURES, LABELS, SPLITTESTS, ACC>::merge(
	224	RandomForest const & other
	225	){
	226	vigra_precondition(problem_spec_ == other.problem_spec_,
	227	"RandomForest::merge(): You cannot merge with different problem specs.");
	228
	229	// FIXME: Eventually compare the options and only fix if the forests are compatible.
	230
	231	size_t const offset = num_nodes();
	232	graph_.merge(other.graph_);
	233	for (auto const & p : other.split_tests_)
	234	{
	235	split_tests_.insert(Node(p.first.id()+offset), p.second);
	236	}
	237	for (auto const & p : other.node_responses_)
	238	{
	239	node_responses_.insert(Node(p.first.id()+offset), p.second);
	240	}
	241	}
	242
	243	// FIXME TODO we don't support the selection of tree indices any more in predict_probabilities, might be a good idea
	244	// to re-enable this.
	245	template <typename FEATURES, typename LABELS, typename SPLITTESTS, typename ACC>
	246	void RandomForest<FEATURES, LABELS, SPLITTESTS, ACC>::predict(
	247	FEATURES const & features,
	248	LABELS & labels,
	249	int n_threads,
	250	const std::vector<size_t> & tree_indices
	251	) const {
	252	vigra_precondition(features.shape()[0] == labels.shape()[0],
	253	"RandomForest::predict(): Shape mismatch between features and labels.");
	254	vigra_precondition((size_t)features.shape()[1] == problem_spec_.num_features_,
	255	"RandomForest::predict(): Number of features in prediction differs from training.");
	256
	257	MultiArray<2, double> probs(Shape2(features.shape()[0], problem_spec_.num_classes_));
	258	predict_probabilities(features, probs, n_threads, tree_indices);
	259	for (size_t i = 0; i < (size_t)features.shape()[0]; ++i)
	260	{
	261	auto const sub_probs = probs.template bind<0>(i);
	262	auto it = std::max_element(sub_probs.begin(), sub_probs.end());
	263	size_t const label = std::distance(sub_probs.begin(), it);
	264	labels(i) = problem_spec_.distinct_classes_[label];
	265	}
	266	}
	267
	268
	269	// FIXME TODO we don't support the selection of tree indices any more in predict_probabilities, might be a good idea
	270	// to re-enable this.
	271	template <typename FEATURES, typename LABELS, typename SPLITTESTS, typename ACC>
	272	template <typename PROBS>
	273	void RandomForest<FEATURES, LABELS, SPLITTESTS, ACC>::predict_probabilities(
	274	FEATURES const & features,
	275	PROBS & probs,
	276	int n_threads,
	277	const std::vector<size_t> & tree_indices
	278	) const {
	279	vigra_precondition(features.shape()[0] == probs.shape()[0],
	280	"RandomForest::predict_probabilities(): Shape mismatch between features and probabilities.");
	281	vigra_precondition((size_t)features.shape()[1] == problem_spec_.num_features_,
	282	"RandomForest::predict_probabilities(): Number of features in prediction differs from training.");
	283	vigra_precondition((size_t)probs.shape()[1] == problem_spec_.num_classes_,
	284	"RandomForest::predict_probabilities(): Number of labels in probabilities differs from training.");
	285
	286	// By default, actual_tree_indices is empty. In that case we want to use all trees.
	287	// We need to make a copy. I really don't know how the old code did compile...
	288	std::vector<size_t> tree_indices_cpy(tree_indices);
	289	if (tree_indices_cpy.size() == 0)
	290	{
	291	tree_indices_cpy.resize(graph_.numRoots());
	292	std::iota(tree_indices_cpy.begin(), tree_indices_cpy.end(), 0);
	293	}
	294	else {
	295	// Check the tree indices.
	296	std::sort(tree_indices_cpy.begin(), tree_indices_cpy.end());
	297	tree_indices_cpy.erase(std::unique(tree_indices_cpy.begin(), tree_indices_cpy.end()), tree_indices_cpy.end());
	298	for (auto i : tree_indices_cpy)
	299	vigra_precondition(i < graph_.numRoots(), "RandomForest::leaf_ids(): Tree index out of range.");
	300	}
	301
	302	size_t const num_instances = features.shape()[0];
	303
	304	if (n_threads == -1)
	305	n_threads = std::thread::hardware_concurrency();
	306	if (n_threads < 1)
	307	n_threads = 1;
	308
	309	parallel_foreach(
	310	n_threads,
	311	num_instances,
	312	[&features,&probs,&tree_indices_cpy,this](size_t, size_t i) {
	313	this->predict_probabilities_impl(features, probs, i, tree_indices_cpy);
	314	}
	315	);
	316	}
	317
	318	template <typename FEATURES, typename LABELS, typename SPLITTESTS, typename ACC>
	319	template <typename PROBS>
	320	void RandomForest<FEATURES, LABELS, SPLITTESTS, ACC>::predict_probabilities_impl(
	321	FEATURES const & features,
	322	PROBS & probs,
	323	const size_t i,
	324	const std::vector<size_t> & tree_indices
	325	) const {
	326
	327	// instantiate the accumulation function and the vector to store the tree node results
	328	ACC acc;
	329	std::vector<AccInputType> tree_results;
	330	tree_results.reserve(tree_indices.size());
	331	auto const sub_features = features.template bind<0>(i);
	332
	333	// loop over the trees
	334	for (auto k : tree_indices)
	335	{
	336	Node node = graph_.getRoot(k);
	337	while (graph_.outDegree(node) > 0)
	338	{
	339	size_t const child_index = split_tests_.at(node)(sub_features);
	340	node = graph_.getChild(node, child_index);
	341	}
	342	tree_results.emplace_back(node_responses_.at(node));
	343	}
	344
	345	// write the tree results into the probabilities
	346	auto sub_probs = probs.template bind<0>(i);
	347	acc(tree_results.begin(), tree_results.end(), sub_probs.begin());
	348	}
	349
	350	template <typename FEATURES, typename LABELS, typename SPLITTESTS, typename ACC>
	351	template <typename IDS>
	352	double RandomForest<FEATURES, LABELS, SPLITTESTS, ACC>::leaf_ids(
	353	FEATURES const & features,
	354	IDS & ids,
	355	int n_threads,
	356	std::vector<size_t> tree_indices
	357	) const {
	358	vigra_precondition(features.shape()[0] == ids.shape()[0],
	359	"RandomForest::leaf_ids(): Shape mismatch between features and probabilities.");
	360	vigra_precondition((size_t)features.shape()[1] == problem_spec_.num_features_,
	361	"RandomForest::leaf_ids(): Number of features in prediction differs from training.");
	362	vigra_precondition(ids.shape()[1] == graph_.numRoots(),
	363	"RandomForest::leaf_ids(): Leaf array has wrong shape.");
	364
	365	// Check the tree indices.
	366	std::sort(tree_indices.begin(), tree_indices.end());
	367	tree_indices.erase(std::unique(tree_indices.begin(), tree_indices.end()), tree_indices.end());
	368	for (auto i : tree_indices)
	369	vigra_precondition(i < graph_.numRoots(), "RandomForest::leaf_ids(): Tree index out of range.");
	370
	371	// By default, actual_tree_indices is empty. In that case we want to use all trees.
	372	if (tree_indices.size() == 0)
	373	{
	374	tree_indices.resize(graph_.numRoots());
	375	std::iota(tree_indices.begin(), tree_indices.end(), 0);
	376	}
	377
	378	size_t const num_instances = features.shape()[0];
	379	if (n_threads == -1)
	380	n_threads = std::thread::hardware_concurrency();
	381	if (n_threads < 1)
	382	n_threads = 1;
	383	std::vector<double> split_comparisons(n_threads, 0.0);
	384	std::vector<size_t> indices(num_instances);
	385	std::iota(indices.begin(), indices.end(), 0);
	386	std::fill(ids.begin(), ids.end(), -1);
	387	parallel_foreach(
	388	n_threads,
	389	indices.begin(),
	390	indices.end(),
	391	[this, &features, &ids, &split_comparisons, &tree_indices](size_t thread_id, size_t i) {
	392	split_comparisons[thread_id] += this->leaf_ids_impl(features, ids, i, i+1, tree_indices);
	393	}
	394	);
	395
	396	double const sum_split_comparisons = std::accumulate(split_comparisons.begin(), split_comparisons.end(), 0.0);
	397	return sum_split_comparisons / features.shape()[0];
	398	}
	399
	400	template <typename FEATURES, typename LABELS, typename SPLITTESTS, typename ACC>
	401	template <typename IDS, typename INDICES>
	402	double RandomForest<FEATURES, LABELS, SPLITTESTS, ACC>::leaf_ids_impl(
	403	FEATURES const & features,
	404	IDS & ids,
	405	size_t from,
	406	size_t to,
	407	INDICES const & tree_indices
	408	) const {
	409	vigra_precondition(features.shape()[0] == ids.shape()[0],
	410	"RandomForest::leaf_ids_impl(): Shape mismatch between features and labels.");
	411	vigra_precondition(features.shape()[1] == problem_spec_.num_features_,
	412	"RandomForest::leaf_ids_impl(): Number of Features in prediction differs from training.");
	413	vigra_precondition(from >= 0 && from <= to && to <= (size_t)features.shape()[0],
	414	"RandomForest::leaf_ids_impl(): Indices out of range.");
	415	vigra_precondition(ids.shape()[1] == graph_.numRoots(),
	416	"RandomForest::leaf_ids_impl(): Leaf array has wrong shape.");
	417
	418	double split_comparisons = 0.0;
	419	for (size_t i = from; i < to; ++i)
	420	{
	421	auto const sub_features = features.template bind<0>(i);
	422	for (auto k : tree_indices)
	423	{
	424	Node node = graph_.getRoot(k);
	425	while (graph_.outDegree(node) > 0)
	426	{
	427	size_t const child_index = split_tests_.at(node)(sub_features);
	428	node = graph_.getChild(node, child_index);
	429	split_comparisons += 1.0;
	430	}
	431	ids(i, k) = node.id();
	432	}
	433	}
	434	return split_comparisons;
	435	}
	436
	437
	438
	439	} // namespace rf3
	440	} // namespace vigra
	441
	442	#endif

+884

-0

include/vigra/random_forest_3/random_forest_common.hxx less more

	0	/************************************************************************/
	1	/* */
	2	/* Copyright 2014-2015 by Ullrich Koethe and Philip Schill */
	3	/* */
	4	/* This file is part of the VIGRA computer vision library. */
	5	/* The VIGRA Website is */
	6	/* http://hci.iwr.uni-heidelberg.de/vigra/ */
	7	/* Please direct questions, bug reports, and contributions to */
	8	/* ullrich.koethe@iwr.uni-heidelberg.de or */
	9	/* vigra@informatik.uni-hamburg.de */
	10	/* */
	11	/* Permission is hereby granted, free of charge, to any person */
	12	/* obtaining a copy of this software and associated documentation */
	13	/* files (the "Software"), to deal in the Software without */
	14	/* restriction, including without limitation the rights to use, */
	15	/* copy, modify, merge, publish, distribute, sublicense, and/or */
	16	/* sell copies of the Software, and to permit persons to whom the */
	17	/* Software is furnished to do so, subject to the following */
	18	/* conditions: */
	19	/* */
	20	/* The above copyright notice and this permission notice shall be */
	21	/* included in all copies or substantial portions of the */
	22	/* Software. */
	23	/* */
	24	/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND */
	25	/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES */
	26	/* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND */
	27	/* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT */
	28	/* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, */
	29	/* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING */
	30	/* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR */
	31	/* OTHER DEALINGS IN THE SOFTWARE. */
	32	/* */
	33	/************************************************************************/
	34	#ifndef VIGRA_RF3_COMMON_HXX
	35	#define VIGRA_RF3_COMMON_HXX
	36
	37	#include <iterator>
	38	#include <type_traits>
	39	#include <cmath>
	40	#include <numeric>
	41
	42	#include "../multi_array.hxx"
	43	#include "../mathutil.hxx"
	44
	45	namespace vigra
	46	{
	47
	48	namespace rf3
	49	{
	50
	51	/** \addtogroup MachineLearning
	52	**/
	53	//@{
	54
	55	template <typename T>
	56	struct LessEqualSplitTest
	57	{
	58	public:
	59	LessEqualSplitTest(size_t dim = 0, T const & val = 0)
	60	:
	61	dim_(dim),
	62	val_(val)
	63	{}
	64
	65	template<typename FEATURES>
	66	size_t operator()(FEATURES const & features) const
	67	{
	68	return features(dim_) <= val_ ? 0 : 1;
	69	}
	70
	71	size_t dim_;
	72	T val_;
	73	};
	74
	75
	76
	77	struct ArgMaxAcc
	78	{
	79	public:
	80	typedef size_t input_type;
	81
	82	template <typename ITER, typename OUTITER>
	83	void operator()(ITER begin, ITER end, OUTITER out)
	84	{
	85	std::fill(buffer_.begin(), buffer_.end(), 0);
	86	size_t max_v = 0;
	87	size_t n = 0;
	88	for (ITER it = begin; it != end; ++it)
	89	{
	90	size_t const v = *it;
	91	if (v >= buffer_.size())
	92	{
	93	buffer_.resize(v+1, 0);
	94	}
	95	++buffer_[v];
	96	++n;
	97	max_v = std::max(max_v, v);
	98	}
	99	for (size_t i = 0; i <= max_v; ++i)
	100	{
	101	*out = buffer_[i] / static_cast<double>(n);
	102	++out;
	103	}
	104	}
	105	private:
	106	std::vector<size_t> buffer_;
	107	};
	108
	109
	110
	111	template <typename VALUETYPE>
	112	struct ArgMaxVectorAcc
	113	{
	114	public:
	115	typedef VALUETYPE value_type;
	116	typedef std::vector<value_type> input_type;
	117	template <typename ITER, typename OUTITER>
	118	void operator()(ITER begin, ITER end, OUTITER out)
	119	{
	120	std::fill(buffer_.begin(), buffer_.end(), 0);
	121	size_t max_v = 0;
	122	for (ITER it = begin; it != end; ++it)
	123	{
	124	input_type const & vec = *it;
	125	if (vec.size() >= buffer_.size())
	126	{
	127	buffer_.resize(vec.size(), 0);
	128	}
	129	value_type const n = std::accumulate(vec.begin(), vec.end(), static_cast<value_type>(0));
	130	for (size_t i = 0; i < vec.size(); ++i)
	131	{
	132	buffer_[i] += vec[i] / static_cast<double>(n);
	133	}
	134	max_v = std::max(vec.size()-1, max_v);
	135	}
	136	for (size_t i = 0; i <= max_v; ++i)
	137	{
	138	*out = buffer_[i];
	139	++out;
	140	}
	141	}
	142	private:
	143	std::vector<double> buffer_;
	144	};
	145
	146
	147
	148	// struct LargestSumAcc
	149	// {
	150	// public:
	151	// typedef std::vector<size_t> input_type;
	152	// template <typename ITER>
	153	// size_t operator()(ITER begin, ITER end)
	154	// {
	155	// std::fill(buffer_.begin(), buffer_.end(), 0);
	156	// for (ITER it = begin; it != end; ++it)
	157	// {
	158	// auto const & v = *it;
	159	// if (v.size() > buffer_.size())
	160	// {
	161	// buffer_.resize(v.size(), 0);
	162	// }
	163	// for (size_t i = 0; i < v.size(); ++i)
	164	// {
	165	// buffer_[i] += v[i];
	166	// }
	167	// }
	168	// size_t max_label = 0;
	169	// size_t max_count = 0;
	170	// for (size_t i = 0; i < buffer_.size(); ++i)
	171	// {
	172	// if (buffer_[i] > max_count)
	173	// {
	174	// max_count = buffer_[i];
	175	// max_label = i;
	176	// }
	177	// }
	178	// return max_label;
	179	// }
	180	// private:
	181	// std::vector<size_t> buffer_;
	182	// };
	183
	184
	185
	186	// struct ForestGarroteAcc
	187	// {
	188	// public:
	189	// typedef double input_type;
	190	// template <typename ITER, typename OUTITER>
	191	// void operator()(ITER begin, ITER end, OUTITER out)
	192	// {
	193	// double s = 0.0;
	194	// for (ITER it = begin; it != end; ++it)
	195	// {
	196	// s += *it;
	197	// }
	198	// if (s < 0.0)
	199	// s = 0.0;
	200	// else if (s > 1.0)
	201	// s = 1.0;
	202	// *out = 1.0-s;
	203	// ++out;
	204	// *out = s;
	205	// }
	206	// };
	207
	208
	209
	210	namespace detail
	211	{
	212
	213	/// Abstract scorer that iterates over all split candidates, uses FUNCTOR to compute a score,
	214	/// and saves the split with the minimum score.
	215	template <typename FUNCTOR>
	216	class GeneralScorer
	217	{
	218	public:
	219
	220	typedef FUNCTOR Functor;
	221
	222	GeneralScorer(std::vector<double> const & priors)
	223	:
	224	split_found_(false),
	225	best_split_(0),
	226	best_dim_(0),
	227	best_score_(std::numeric_limits<double>::max()),
	228	priors_(priors),
	229	n_total_(std::accumulate(priors.begin(), priors.end(), 0.0))
	230	{}
	231
	232	template <typename FEATURES, typename LABELS, typename WEIGHTS, typename ITER>
	233	void operator()(
	234	FEATURES const & features,
	235	LABELS const & labels,
	236	WEIGHTS const & weights,
	237	ITER begin,
	238	ITER end,
	239	size_t dim
	240	){
	241	if (begin == end)
	242	return;
	243
	244	Functor score;
	245
	246	std::vector<double> counts(priors_.size(), 0.0);
	247	double n_left = 0;
	248	ITER next = begin;
	249	++next;
	250	for (; next != end; ++begin, ++next)
	251	{
	252	// Move the label from the right side to the left side.
	253	size_t const left_index = *begin;
	254	size_t const right_index = *next;
	255	size_t const label = static_cast<size_t>(labels(left_index));
	256	counts[label] += weights[left_index];
	257	n_left += weights[left_index];
	258
	259	// Skip if there is no new split.
	260	auto const left = features(left_index, dim);
	261	auto const right = features(right_index, dim);
	262	if (left == right)
	263	continue;
	264
	265	// Update the score.
	266	split_found_ = true;
	267	double const s = score(priors_, counts, n_total_, n_left);
	268	bool const better_score = s < best_score_;
	269	if (better_score)
	270	{
	271	best_score_ = s;
	272	best_split_ = 0.5*(left+right);
	273	best_dim_ = dim;
	274	}
	275	}
	276	}
	277
	278	bool split_found_; // whether a split was found at all
	279	double best_split_; // the threshold of the best split
	280	size_t best_dim_; // the dimension of the best split
	281	double best_score_; // the score of the best split
	282
	283	private:
	284
	285	std::vector<double> const priors_; // the weighted number of datapoints per class
	286	double const n_total_; // the weighted number of datapoints
	287	};
	288
	289	} // namespace detail
	290
	291	/// \brief Functor that computes the gini score.
	292	///
	293	/// This functor is typically selected indirectly by passing the value <tt>RF_GINI</tt>
	294	/// to vigra::rf3::RandomForestOptions::split().
	295	class GiniScore
	296	{
	297	public:
	298	double operator()(std::vector<double> const & priors,
	299	std::vector<double> const & counts, double n_total, double n_left) const
	300	{
	301	double const n_right = n_total - n_left;
	302	double gini_left = 1.0;
	303	double gini_right = 1.0;
	304	for (size_t i = 0; i < counts.size(); ++i)
	305	{
	306	double const p_left = counts[i] / n_left;
	307	double const p_right = (priors[i] - counts[i]) / n_right;
	308	gini_left -= (p_left*p_left);
	309	gini_right -= (p_right*p_right);
	310	}
	311	return n_leftgini_left + n_rightgini_right;
	312	}
	313
	314	// needed for Gini-based variable importance calculation
	315	template <typename LABELS, typename WEIGHTS, typename ITER>
	316	static double region_score(LABELS const & labels, WEIGHTS const & weights, ITER begin, ITER end)
	317	{
	318	// Count the occurences.
	319	std::vector<double> counts;
	320	double total = 0.0;
	321	for (auto it = begin; it != end; ++it)
	322	{
	323	auto const d = *it;
	324	auto const lbl = labels[d];
	325	if (counts.size() <= lbl)
	326	{
	327	counts.resize(lbl+1, 0.0);
	328	}
	329	counts[lbl] += weights[d];
	330	total += weights[d];
	331	}
	332
	333	// Compute the gini.
	334	double gini = total;
	335	for (auto x : counts)
	336	{
	337	gini -= x*x/total;
	338	}
	339	return gini;
	340	}
	341	};
	342
	343	/// \brief Functor that computes the entropy score.
	344	///
	345	/// This functor is typically selected indirectly by passing the value <tt>RF_ENTROPY</tt>
	346	/// to vigra::rf3::RandomForestOptions::split().
	347	class EntropyScore
	348	{
	349	public:
	350	double operator()(std::vector<double> const & priors, std::vector<double> const & counts, double n_total, double n_left) const
	351	{
	352	double const n_right = n_total - n_left;
	353	double ig = 0;
	354	for (size_t i = 0; i < counts.size(); ++i)
	355	{
	356	double c = counts[i];
	357	if (c != 0)
	358	ig -= c * std::log(c / n_left);
	359
	360	c = priors[i] - c;
	361	if (c != 0)
	362	ig -= c * std::log(c / n_right);
	363	}
	364	return ig;
	365	}
	366
	367	template <typename LABELS, typename WEIGHTS, typename ITER>
	368	double region_score(LABELS const & /labels/, WEIGHTS const & /weights/, ITER /begin/, ITER /end/) const
	369	{
	370	vigra_fail("EntropyScore::region_score(): Not implemented yet.");
	371	return 0.0; // FIXME
	372	}
	373	};
	374
	375	/// \brief Functor that computes the Kolmogorov-Smirnov score.
	376	///
	377	/// Actually, it reutrns the negated KSD score, because we want to minimize.
	378	///
	379	/// This functor is typically selected indirectly by passing the value <tt>RF_KSD</tt>
	380	/// to vigra::rf3::RandomForestOptions::split().
	381	class KolmogorovSmirnovScore
	382	{
	383	public:
	384	double operator()(std::vector<double> const & priors, std::vector<double> const & counts, double /n_total/, double /n_left/) const // Fix unused parameter warning, but leave in to not break compatibility with overall API
	385	{
	386	double const eps = 1e-10;
	387	double nnz = 0;
	388	std::vector<double> norm_counts(counts.size(), 0.0);
	389	for (size_t i = 0; i < counts.size(); ++i)
	390	{
	391	if (priors[i] > eps)
	392	{
	393	norm_counts[i] = counts[i] / priors[i];
	394	++nnz;
	395	}
	396	}
	397	if (nnz < eps)
	398	return 0.0;
	399
	400	// NOTE to future self:
	401	// In std::accumulate, it makes a huge difference whether you use 0 or 0.0 as init. Think about that before making changes.
	402	double const mean = std::accumulate(norm_counts.begin(), norm_counts.end(), 0.0) / nnz;
	403
	404	// Compute the sum of the squared distances.
	405	double ksd = 0.0;
	406	for (size_t i = 0; i < norm_counts.size(); ++i)
	407	{
	408	if (priors[i] != 0)
	409	{
	410	double const v = (mean-norm_counts[i]);
	411	ksd += v*v;
	412	}
	413	}
	414	return -ksd;
	415	}
	416
	417	template <typename LABELS, typename WEIGHTS, typename ITER>
	418	double region_score(LABELS const & /labels/, WEIGHTS const & /weights/, ITER /begin/, ITER /end/) const
	419	{
	420	vigra_fail("KolmogorovSmirnovScore::region_score(): Region score not available for the Kolmogorov-Smirnov split.");
	421	return 0.0;
	422	}
	423	};
	424
	425	// This struct holds the depth and the weighted number of datapoints per class of a single node.
	426	template <typename ARR>
	427	struct RFNodeDescription
	428	{
	429	public:
	430	RFNodeDescription(size_t depth, ARR const & priors)
	431	:
	432	depth_(depth),
	433	priors_(priors)
	434	{}
	435	size_t depth_;
	436	ARR const & priors_;
	437	};
	438
	439
	440
	441	// Return true if the given node is pure.
	442	template <typename LABELS, typename ITER>
	443	bool is_pure(LABELS const & /labels/, RFNodeDescription<ITER> const & desc)
	444	{
	445	bool found = false;
	446	for (auto n : desc.priors_)
	447	{
	448	if (n > 0)
	449	{
	450	if (found)
	451	return false;
	452	else
	453	found = true;
	454	}
	455	}
	456	return true;
	457	}
	458
	459	/// @brief Random forest 'node purity' stop criterion.
	460	///
	461	/// Stop splitting a node when it contains only instanes of a single class.
	462	class PurityStop
	463	{
	464	public:
	465	template <typename LABELS, typename ITER>
	466	bool operator()(LABELS const & labels, RFNodeDescription<ITER> const & desc) const
	467	{
	468	return is_pure(labels, desc);
	469	}
	470	};
	471
	472	/// @brief Random forest 'maximum depth' stop criterion.
	473	///
	474	/// Stop splitting a node when the its depth reaches a given value or when it is pure.
	475	class DepthStop
	476	{
	477	public:
	478	/// @brief Constructor: terminate tree construction at \a max_depth.
	479	DepthStop(size_t max_depth)
	480	:
	481	max_depth_(max_depth)
	482	{}
	483
	484	template <typename LABELS, typename ITER>
	485	bool operator()(LABELS const & labels, RFNodeDescription<ITER> const & desc) const
	486	{
	487	if (desc.depth_ >= max_depth_)
	488	return true;
	489	else
	490	return is_pure(labels, desc);
	491	}
	492	size_t max_depth_;
	493	};
	494
	495	/// @brief Random forest 'number of datapoints' stop criterion.
	496	///
	497	/// Stop splitting a node when it contains too few instances or when it is pure.
	498	class NumInstancesStop
	499	{
	500	public:
	501	/// @brief Constructor: terminate tree construction when node contains less than \a min_n instances.
	502	NumInstancesStop(size_t min_n)
	503	:
	504	min_n_(min_n)
	505	{}
	506
	507	template <typename LABELS, typename ARR>
	508	bool operator()(LABELS const & labels, RFNodeDescription<ARR> const & desc) const
	509	{
	510	typedef typename ARR::value_type value_type;
	511	if (std::accumulate(desc.priors_.begin(), desc.priors_.end(), static_cast<value_type>(0)) <= min_n_)
	512	return true;
	513	else
	514	return is_pure(labels, desc);
	515	}
	516	size_t min_n_;
	517	};
	518
	519	/// @brief Random forest 'node complexity' stop criterion.
	520	///
	521	/// Stop splitting a node when it allows for too few different data arrangements.
	522	/// This includes purity, which offers only a sinlge data arrangement.
	523	class NodeComplexityStop
	524	{
	525	public:
	526	/// @brief Constructor: stop when fewer than <tt>1/tau</tt> label arrangements are possible.
	527	NodeComplexityStop(double tau = 0.001)
	528	:
	529	logtau_(std::log(tau))
	530	{
	531	vigra_precondition(tau > 0 && tau < 1, "NodeComplexityStop(): Tau must be in the open interval (0, 1).");
	532	}
	533
	534	template <typename LABELS, typename ARR>
	535	bool operator()(LABELS const & /labels/, RFNodeDescription<ARR> const & desc) // Fix unused parameter, but leave in for API compatability
	536	{
	537	typedef typename ARR::value_type value_type;
	538
	539	// Count the labels.
	540	size_t const total = std::accumulate(desc.priors_.begin(), desc.priors_.end(), static_cast<value_type>(0));
	541
	542	// Compute log(prod_k(n_k!)).
	543	size_t nnz = 0;
	544	double lg = 0.0;
	545	for (auto v : desc.priors_)
	546	{
	547	if (v > 0)
	548	{
	549	++nnz;
	550	lg += loggamma(static_cast<double>(v+1));
	551	}
	552	}
	553	lg += loggamma(static_cast<double>(nnz+1));
	554	lg -= loggamma(static_cast<double>(total+1));
	555	if (nnz <= 1)
	556	return true;
	557
	558	return lg >= logtau_;
	559	}
	560
	561	double logtau_;
	562	};
	563
	564	enum RandomForestOptionTags
	565	{
	566	RF_SQRT,
	567	RF_LOG,
	568	RF_CONST,
	569	RF_ALL,
	570	RF_GINI,
	571	RF_ENTROPY,
	572	RF_KSD
	573	};
	574
	575
	576	/** \brief Options class for \ref vigra::rf3::RandomForest version 3.
	577
	578	<b>\#include</b> \<vigra/random_forest_3.hxx\><br/>
	579	Namespace: vigra::rf3
	580	*/
	581	class RandomForestOptions
	582	{
	583	public:
	584
	585	RandomForestOptions()
	586	:
	587	tree_count_(255),
	588	features_per_node_(0),
	589	features_per_node_switch_(RF_SQRT),
	590	bootstrap_sampling_(true),
	591	resample_count_(0),
	592	split_(RF_GINI),
	593	max_depth_(0),
	594	node_complexity_tau_(-1),
	595	min_num_instances_(1),
	596	use_stratification_(false),
	597	n_threads_(-1),
	598	class_weights_()
	599	{}
	600
	601	/**
	602	* @brief The number of trees.
	603	*
	604	* Default: 255
	605	*/
	606	RandomForestOptions & tree_count(int p_tree_count)
	607	{
	608	tree_count_ = p_tree_count;
	609	return *this;
	610	}
	611
	612	/**
	613	* @brief The number of features that are considered when computing the split.
	614	*
	615	* @param p_features_per_node the number of features
	616	*
	617	* Default: use sqrt of the total number of features.
	618	*/
	619	RandomForestOptions & features_per_node(int p_features_per_node)
	620	{
	621	features_per_node_switch_ = RF_CONST;
	622	features_per_node_ = p_features_per_node;
	623	return *this;
	624	}
	625
	626	/**
	627	* @brief The number of features that are considered when computing the split.
	628	*
	629	* @param p_features_per_node_switch possible values: <br/>
	630	<tt>vigra::rf3::RF_SQRT</tt> (use square root of total number of features, recommended for classification), <br/>
	631	<tt>vigra::rf3::RF_LOG</tt> (use logarithm of total number of features, recommended for regression), <br/>
	632	<tt>vigra::rf3::RF_ALL</tt> (use all features).
	633	*
	634	* Default: <tt>vigra::rf3::RF_SQRT</tt>
	635	*/
	636	RandomForestOptions & features_per_node(RandomForestOptionTags p_features_per_node_switch)
	637	{
	638	vigra_precondition(p_features_per_node_switch == RF_SQRT \|\|
	639	p_features_per_node_switch == RF_LOG \|\|
	640	p_features_per_node_switch == RF_ALL,
	641	"RandomForestOptions::features_per_node(): Input must be RF_SQRT, RF_LOG or RF_ALL.");
	642	features_per_node_switch_ = p_features_per_node_switch;
	643	return *this;
	644	}
	645
	646	/**
	647	* @brief Use bootstrap sampling.
	648	*
	649	* Default: true
	650	*/
	651	RandomForestOptions & bootstrap_sampling(bool b)
	652	{
	653	bootstrap_sampling_ = b;
	654	return *this;
	655	}
	656
	657	/**
	658	* @brief If resample_count is greater than zero, the split in each node is computed using only resample_count data points.
	659	*
	660	* Default: \a n = 0 (don't resample in every node)
	661	*/
	662	RandomForestOptions & resample_count(size_t n)
	663	{
	664	resample_count_ = n;
	665	bootstrap_sampling_ = false;
	666	return *this;
	667	}
	668
	669	/**
	670	* @brief The split criterion.
	671	*
	672	* @param p_split possible values: <br/>
	673	<tt>vigra::rf3::RF_GINI</tt> (use Gini criterion, \ref vigra::rf3::GiniScorer), <br/>
	674	<tt>vigra::rf3::RF_ENTROPY</tt> (use entropy criterion, \ref vigra::rf3::EntropyScorer), <br/>
	675	<tt>vigra::rf3::RF_KSD</tt> (use Kolmogorov-Smirnov criterion, \ref vigra::rf3::KSDScorer).
	676	*
	677	* Default: <tt>vigra::rf3::RF_GINI</tt>
	678	*/
	679	RandomForestOptions & split(RandomForestOptionTags p_split)
	680	{
	681	vigra_precondition(p_split == RF_GINI \|\|
	682	p_split == RF_ENTROPY \|\|
	683	p_split == RF_KSD,
	684	"RandomForestOptions::split(): Input must be RF_GINI, RF_ENTROPY or RF_KSD.");
	685	split_ = p_split;
	686	return *this;
	687	}
	688
	689	/**
	690	* @brief Do not split a node if its depth is greater or equal to max_depth.
	691	*
	692	* Default: \a d = 0 (don't use depth as a termination criterion)
	693	*/
	694	RandomForestOptions & max_depth(size_t d)
	695	{
	696	max_depth_ = d;
	697	return *this;
	698	}
	699
	700	/**
	701	* @brief Value of the node complexity termination criterion.
	702	*
	703	* Default: \a tau = -1 (don't use complexity as a termination criterion)
	704	*/
	705	RandomForestOptions & node_complexity_tau(double tau)
	706	{
	707	node_complexity_tau_ = tau;
	708	return *this;
	709	}
	710
	711	/**
	712	* @brief Do not split a node if it contains less than min_num_instances data points.
	713	*
	714	* Default: \a n = 1 (don't use instance count as a termination criterion)
	715	*/
	716	RandomForestOptions & min_num_instances(size_t n)
	717	{
	718	min_num_instances_ = n;
	719	return *this;
	720	}
	721
	722	/**
	723	* @brief Use stratification when creating the bootstrap samples.
	724	*
	725	* That is, preserve the proportion between the number of class instances exactly
	726	* rather than on average.
	727	*
	728	* Default: false
	729	*/
	730	RandomForestOptions & use_stratification(bool b)
	731	{
	732	use_stratification_ = b;
	733	return *this;
	734	}
	735
	736	/**
	737	* @brief The number of threads that are used in training.
	738	*
	739	* \a n = -1 means use number of cores, \a n = 0 means single-threaded training.
	740	*
	741	* Default: \a n = -1 (use as many threads as there are cores in the machine).
	742	*/
	743	RandomForestOptions & n_threads(int n)
	744	{
	745	n_threads_ = n;
	746	return *this;
	747	}
	748
	749	/**
	750	* @brief Each datapoint is weighted by its class weight. By default, each class has weight 1.
	751	* @details
	752	* The classes in the random forest training have to follow a strict ordering. The weights must be given in that order.
	753	* Example:
	754	* You have the classes 3, 8 and 5 and use the vector {0.2, 0.3, 0.4} for the class weights.
	755	* The ordering of the classes is 3, 5, 8, so class 3 will get weight 0.2, class 5 will get weight 0.3
	756	* and class 8 will get weight 0.4.
	757	*/
	758	RandomForestOptions & class_weights(std::vector<double> const & v)
	759	{
	760	class_weights_ = v;
	761	return *this;
	762	}
	763
	764	/**
	765	* @brief Get the actual number of features per node.
	766	*
	767	* @param total the total number of features
	768	*
	769	* This function is normally only called internally before training is started.
	770	*/
	771	size_t get_features_per_node(size_t total) const
	772	{
	773	if (features_per_node_switch_ == RF_SQRT)
	774	return std::ceil(std::sqrt(total));
	775	else if (features_per_node_switch_ == RF_LOG)
	776	return std::ceil(std::log(total));
	777	else if (features_per_node_switch_ == RF_CONST)
	778	return features_per_node_;
	779	else if (features_per_node_switch_ == RF_ALL)
	780	return total;
	781	vigra_fail("RandomForestOptions::get_features_per_node(): Unknown switch.");
	782	return 0;
	783	}
	784
	785	int tree_count_;
	786	int features_per_node_;
	787	RandomForestOptionTags features_per_node_switch_;
	788	bool bootstrap_sampling_;
	789	size_t resample_count_;
	790	RandomForestOptionTags split_;
	791	size_t max_depth_;
	792	double node_complexity_tau_;
	793	size_t min_num_instances_;
	794	bool use_stratification_;
	795	int n_threads_;
	796	std::vector<double> class_weights_;
	797
	798	};
	799
	800
	801
	802	template <typename LabelType>
	803	class ProblemSpec
	804	{
	805	public:
	806
	807	ProblemSpec()
	808	:
	809	num_features_(0),
	810	num_instances_(0),
	811	num_classes_(0),
	812	distinct_classes_(),
	813	actual_mtry_(0),
	814	actual_msample_(0)
	815	{}
	816
	817	ProblemSpec & num_features(size_t n)
	818	{
	819	num_features_ = n;
	820	return *this;
	821	}
	822
	823	ProblemSpec & num_instances(size_t n)
	824	{
	825	num_instances_ = n;
	826	return *this;
	827	}
	828
	829	ProblemSpec & num_classes(size_t n)
	830	{
	831	num_classes_ = n;
	832	return *this;
	833	}
	834
	835	ProblemSpec & distinct_classes(std::vector<LabelType> v)
	836	{
	837	distinct_classes_ = v;
	838	num_classes_ = v.size();
	839	return *this;
	840	}
	841
	842	ProblemSpec & actual_mtry(size_t m)
	843	{
	844	actual_mtry_ = m;
	845	return *this;
	846	}
	847
	848	ProblemSpec & actual_msample(size_t m)
	849	{
	850	actual_msample_ = m;
	851	return *this;
	852	}
	853
	854	bool operator==(ProblemSpec const & other) const
	855	{
	856	#define COMPARE(field) if (field != other.field) return false;
	857	COMPARE(num_features_);
	858	COMPARE(num_instances_);
	859	COMPARE(num_classes_);
	860	COMPARE(distinct_classes_);
	861	COMPARE(actual_mtry_);
	862	COMPARE(actual_msample_);
	863	#undef COMPARE
	864	return true;
	865	}
	866
	867	size_t num_features_;
	868	size_t num_instances_;
	869	size_t num_classes_;
	870	std::vector<LabelType> distinct_classes_;
	871	size_t actual_mtry_;
	872	size_t actual_msample_;
	873
	874	};
	875
	876	//@}
	877
	878	} // namespace rf3
	879
	880	} // namespace vigra
	881
	882	#endif
	883

+856

-0

include/vigra/random_forest_3/random_forest_visitors.hxx less more

	0	/************************************************************************/
	1	/* */
	2	/* Copyright 2014-2015 by Ullrich Koethe and Philip Schill */
	3	/* */
	4	/* This file is part of the VIGRA computer vision library. */
	5	/* The VIGRA Website is */
	6	/* http://hci.iwr.uni-heidelberg.de/vigra/ */
	7	/* Please direct questions, bug reports, and contributions to */
	8	/* ullrich.koethe@iwr.uni-heidelberg.de or */
	9	/* vigra@informatik.uni-hamburg.de */
	10	/* */
	11	/* Permission is hereby granted, free of charge, to any person */
	12	/* obtaining a copy of this software and associated documentation */
	13	/* files (the "Software"), to deal in the Software without */
	14	/* restriction, including without limitation the rights to use, */
	15	/* copy, modify, merge, publish, distribute, sublicense, and/or */
	16	/* sell copies of the Software, and to permit persons to whom the */
	17	/* Software is furnished to do so, subject to the following */
	18	/* conditions: */
	19	/* */
	20	/* The above copyright notice and this permission notice shall be */
	21	/* included in all copies or substantial portions of the */
	22	/* Software. */
	23	/* */
	24	/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND */
	25	/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES */
	26	/* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND */
	27	/* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT */
	28	/* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, */
	29	/* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING */
	30	/* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR */
	31	/* OTHER DEALINGS IN THE SOFTWARE. */
	32	/* */
	33	/************************************************************************/
	34	#ifndef VIGRA_RF3_VISITORS_HXX
	35	#define VIGRA_RF3_VISITORS_HXX
	36
	37	#include <vector>
	38	#include <memory>
	39	#include "../multi_array.hxx"
	40	#include "../multi_shape.hxx"
	41	#include <typeinfo>
	42
	43
	44	namespace vigra
	45	{
	46	namespace rf3
	47	{
	48
	49	/**
	50	* @brief Base class from which all random forest visitors derive.
	51	*
	52	* @details
	53	* Due to the parallel training, we cannot simply use a single visitor for all trees.
	54	* Instead, each tree gets a copy of the original visitor.
	55	*
	56	* The random forest training with visitors looks as follows:
	57	* - Do the random forest preprocessing (translate labels to 0, 1, 2, ...).
	58	* - Call visit_at_beginning() on the original visitor.
	59	* - For each tree:
	60	* - - Copy the original visitor and give the copy to the tree.
	61	* - - Do the preprocessing (create the bootstrap sample, assign weights to the data points, ...).
	62	* - - Call visit_before_tree() on the visitor copy.
	63	* - - Do the node splitting until the tree is fully trained.
	64	* - - Call visit_after_tree() on the visitor copy.
	65	* - Call visit_at_end (which gets a vector with pointers to the visitor copies) on the original visitor.
	66	*/
	67	class RFVisitorBase
	68	{
	69	public:
	70
	71	RFVisitorBase()
	72	:
	73	active_(true)
	74	{}
	75
	76	/**
	77	* @brief Do something before training starts.
	78	*/
	79	void visit_before_training()
	80	{}
	81
	82	/**
	83	* @brief Do something after all trees have been learned.
	84	*
	85	* @param v vector with pointers to the visitor copies
	86	* @param rf the trained random forest
	87	*/
	88	template <typename VISITORS, typename RF, typename FEATURES, typename LABELS>
	89	void visit_after_training(VISITORS &, RF &, const FEATURES &, const LABELS &)
	90	{}
	91
	92	/**
	93	* @brief Do something before a tree has been learned.
	94	*
	95	* @param weights the actual instance weights (after bootstrap sampling and class weights)
	96	*/
	97	template <typename TREE, typename FEATURES, typename LABELS, typename WEIGHTS>
	98	void visit_before_tree(TREE &, FEATURES &, LABELS &, WEIGHTS &)
	99	{}
	100
	101	/**
	102	* @brief Do something after a tree has been learned.
	103	*/
	104	template <typename RF, typename FEATURES, typename LABELS, typename WEIGHTS>
	105	void visit_after_tree(RF &,
	106	FEATURES &,
	107	LABELS &,
	108	WEIGHTS &)
	109	{}
	110
	111	/**
	112	* @brief Do something after the split was made.
	113	*/
	114	template <typename TREE,
	115	typename FEATURES,
	116	typename LABELS,
	117	typename WEIGHTS,
	118	typename SCORER,
	119	typename ITER>
	120	void visit_after_split(TREE &,
	121	FEATURES &,
	122	LABELS &,
	123	WEIGHTS &,
	124	SCORER &,
	125	ITER,
	126	ITER,
	127	ITER)
	128	{}
	129
	130	/**
	131	* @brief Return whether the visitor is active or not.
	132	*/
	133	bool is_active() const
	134	{
	135	return active_;
	136	}
	137
	138	/**
	139	* @brief Activate the visitor.
	140	*/
	141	void activate()
	142	{
	143	active_ = true;
	144	}
	145
	146	/**
	147	* @brief Deactivate the visitor.
	148	*/
	149	void deactivate()
	150	{
	151	active_ = false;
	152	}
	153
	154	private:
	155
	156	bool active_;
	157
	158	};
	159
	160	/////////////////////////////////////////////
	161	// The concrete visitors //
	162	/////////////////////////////////////////////
	163
	164	/**
	165	* @brief Compute the out of bag error.
	166	*
	167	* After training, each data point is put down those trees for which it is OOB.
	168	* Using bootstrap sampling, each data point is OOB for approximately 37% of
	169	* the trees.
	170	*/
	171	class OOBError : public RFVisitorBase
	172	{
	173	public:
	174
	175	/**
	176	* Save whether a data point is in-bag (weight > 0) or out-of-bag (weight == 0).
	177	*/
	178	template <typename TREE, typename FEATURES, typename LABELS, typename WEIGHTS>
	179	void visit_before_tree(
	180	TREE & /tree/,
	181	FEATURES & /features/,
	182	LABELS & /labels/,
	183	WEIGHTS & weights
	184	){
	185	double const EPS = 1e-20;
	186	bool found = false;
	187
	188	// Save the in-bags.
	189	is_in_bag_.resize(weights.size(), true);
	190	for (size_t i = 0; i < weights.size(); ++i)
	191	{
	192	if (std::abs(weights[i]) < EPS)
	193	{
	194	is_in_bag_[i] = false;
	195	found = true;
	196	}
	197	}
	198
	199	if (!found)
	200	throw std::runtime_error("OOBError::visit_before_tree(): The tree has no out-of-bags.");
	201	}
	202
	203	/**
	204	* Compute the out-of-bag error.
	205	*/
	206	template <typename VISITORS, typename RF, typename FEATURES, typename LABELS>
	207	void visit_after_training(
	208	VISITORS & visitors,
	209	RF & rf,
	210	const FEATURES & features,
	211	const LABELS & labels
	212	){
	213	// Check the input sizes.
	214	vigra_precondition(rf.num_trees() > 0, "OOBError::visit_after_training(): Number of trees must be greater than zero after training.");
	215	vigra_precondition(visitors.size() == rf.num_trees(), "OOBError::visit_after_training(): Number of visitors must be equal to number of trees.");
	216	size_t const num_instances = features.shape()[0];
	217	auto const num_features = features.shape()[1];
	218	for (auto vptr : visitors)
	219	vigra_precondition(vptr->is_in_bag_.size() == num_instances, "OOBError::visit_after_training(): Some visitors have the wrong number of data points.");
	220
	221	// Get a prediction for each data point using only the trees where it is out of bag.
	222	typedef typename std::remove_const<LABELS>::type Labels;
	223	Labels pred(Shape1(1));
	224	oob_err_ = 0.0;
	225	for (size_t i = 0; i < (size_t)num_instances; ++i)
	226	{
	227	// Get the indices of the trees where the data points is out of bag.
	228	std::vector<size_t> tree_indices;
	229	for (size_t k = 0; k < visitors.size(); ++k)
	230	if (!visitors[k]->is_in_bag_[i])
	231	tree_indices.push_back(k);
	232
	233	// Get the prediction using the above trees.
	234	auto const sub_features = features.subarray(Shape2(i, 0), Shape2(i+1, num_features));
	235	rf.predict(sub_features, pred, 1, tree_indices);
	236	if (pred(0) != labels(i))
	237	oob_err_ += 1.0;
	238	}
	239	oob_err_ /= num_instances;
	240	}
	241
	242	/**
	243	* the out-of-bag error
	244	*/
	245	double oob_err_;
	246
	247	private:
	248	std::vector<bool> is_in_bag_; // whether a data point is in-bag or out-of-bag
	249	};
	250
	251
	252
	253	/**
	254	* @brief Compute the variable importance.
	255	*/
	256	class VariableImportance : public RFVisitorBase
	257	{
	258	public:
	259
	260	VariableImportance(size_t repetition_count = 10)
	261	:
	262	repetition_count_(repetition_count)
	263	{}
	264
	265	/**
	266	* Resize the variable importance array and store in-bag / out-of-bag information.
	267	*/
	268	template <typename TREE, typename FEATURES, typename LABELS, typename WEIGHTS>
	269	void visit_before_tree(
	270	TREE & tree,
	271	FEATURES & features,
	272	LABELS & /labels/,
	273	WEIGHTS & weights
	274	){
	275	// Resize the variable importance array.
	276	// The shape differs from the shape of the actual output, since the single trees
	277	// only store the impurity decrease without the permutation importances.
	278	auto const num_features = features.shape()[1];
	279	variable_importance_.reshape(Shape2(num_features, tree.num_classes()+2), 0.0);
	280
	281	// Save the in-bags.
	282	double const EPS = 1e-20;
	283	bool found = false;
	284	is_in_bag_.resize(weights.size(), true);
	285	for (size_t i = 0; i < weights.size(); ++i)
	286	{
	287	if (std::abs(weights[i]) < EPS)
	288	{
	289	is_in_bag_[i] = false;
	290	found = true;
	291	}
	292	}
	293	if (!found)
	294	throw std::runtime_error("VariableImportance::visit_before_tree(): The tree has no out-of-bags.");
	295	}
	296
	297	/**
	298	* Calculate the impurity decrease based variable importance after every split.
	299	*/
	300	template <typename TREE,
	301	typename FEATURES,
	302	typename LABELS,
	303	typename WEIGHTS,
	304	typename SCORER,
	305	typename ITER>
	306	void visit_after_split(TREE & tree,
	307	FEATURES & /features/,
	308	LABELS & labels,
	309	WEIGHTS & weights,
	310	SCORER & scorer,
	311	ITER begin,
	312	ITER /split/,
	313	ITER end)
	314	{
	315	// Update the impurity decrease.
	316	typename SCORER::Functor functor;
	317	auto const region_impurity = functor.region_score(labels, weights, begin, end);
	318	auto const split_impurity = scorer.best_score_;
	319	variable_importance_(scorer.best_dim_, tree.num_classes()+1) += region_impurity - split_impurity;
	320	}
	321
	322	/**
	323	* Compute the permutation importance.
	324	*/
	325	template <typename RF, typename FEATURES, typename LABELS, typename WEIGHTS>
	326	void visit_after_tree(RF & rf,
	327	const FEATURES & features,
	328	const LABELS & labels,
	329	WEIGHTS & /weights/)
	330	{
	331	// Non-const types of features and labels.
	332	typedef typename std::remove_const<FEATURES>::type Features;
	333	typedef typename std::remove_const<LABELS>::type Labels;
	334
	335	typedef typename Features::value_type FeatureType;
	336
	337	auto const num_features = features.shape()[1];
	338
	339	// For the permutation importance, the features must be permuted (obviously).
	340	// This cannot be done on the original feature matrix, since it would interfere
	341	// with other threads in concurrent training. Therefore, we have to make a copy.
	342	Features feats;
	343	Labels labs;
	344	copy_out_of_bags(features, labels, feats, labs);
	345	auto const num_oobs = feats.shape()[0];
	346
	347	// Compute (standard and class-wise) out-of-bag success rate with the original sample.
	348	MultiArray<1, double> oob_right(Shape1(rf.num_classes()+1), 0.0);
	349	vigra::MultiArray<1,int> pred( (Shape1(num_oobs)) );
	350	rf.predict(feats, pred, 1);
	351	for (size_t i = 0; i < (size_t)labs.size(); ++i)
	352	{
	353	if (labs(i) == pred(i))
	354	{
	355	oob_right(labs(i)) += 1.0; // per class
	356	oob_right(rf.num_classes()) += 1.0; // total
	357	}
	358	}
	359
	360	// Get out-of-bag success rate after permuting the j'th dimension.
	361	UniformIntRandomFunctor<MersenneTwister> randint;
	362	for (size_t j = 0; j < (size_t)num_features; ++j)
	363	{
	364	MultiArray<1, FeatureType> backup(( Shape1(num_oobs) ));
	365	backup = feats.template bind<1>(j);
	366	MultiArray<2, double> perm_oob_right(Shape2(1, rf.num_classes()+1), 0.0);
	367
	368	for (size_t k = 0; k < repetition_count_; ++k)
	369	{
	370	// Permute the current dimension.
	371	for (int ii = num_oobs-1; ii >= 1; --ii)
	372	std::swap(feats(ii, j), feats(randint(ii+1), j));
	373
	374	// Get the out-of-bag success rate after permuting.
	375	rf.predict(feats, pred, 1);
	376	for (size_t i = 0; i < (size_t)labs.size(); ++i)
	377	{
	378	if (labs(i) == pred(i))
	379	{
	380	perm_oob_right(0, labs(i)) += 1.0; // per class
	381	perm_oob_right(0, rf.num_classes()) += 1.0; // total
	382	}
	383	}
	384	}
	385
	386	// Normalize and add to the importance matrix.
	387	perm_oob_right /= repetition_count_;
	388	perm_oob_right.bind<0>(0) -= oob_right;
	389	perm_oob_right *= -1;
	390	perm_oob_right /= num_oobs;
	391	variable_importance_.subarray(Shape2(j, 0), Shape2(j+1, rf.num_classes()+1)) += perm_oob_right;
	392
	393	// Copy back the permuted dimension.
	394	feats.template bind<1>(j) = backup;
	395	}
	396	}
	397
	398	/**
	399	* Accumulate the variable importances from the single trees.
	400	*/
	401	template <typename VISITORS, typename RF, typename FEATURES, typename LABELS>
	402	void visit_after_training(
	403	VISITORS & visitors,
	404	RF & rf,
	405	const FEATURES & features,
	406	const LABELS & /labels/
	407	){
	408	vigra_precondition(rf.num_trees() > 0, "VariableImportance::visit_after_training(): Number of trees must be greater than zero after training.");
	409	vigra_precondition(visitors.size() == rf.num_trees(), "VariableImportance::visit_after_training(): Number of visitors must be equal to number of trees.");
	410
	411	// Sum the variable importances from the single trees.
	412	auto const num_features = features.shape()[1];
	413	variable_importance_.reshape(Shape2(num_features, rf.num_classes()+2), 0.0);
	414	for (auto vptr : visitors)
	415	{
	416	vigra_precondition(vptr->variable_importance_.shape() == variable_importance_.shape(),
	417	"VariableImportance::visit_after_training(): Shape mismatch.");
	418	variable_importance_ += vptr->variable_importance_;
	419	}
	420
	421	// Normalize the variable importance.
	422	variable_importance_ /= rf.num_trees();
	423	}
	424
	425	/**
	426	* This Array has the same entries as the R - random forest variable
	427	* importance.
	428	* Matrix is featureCount by (classCount +2)
	429	* variable_importance_(ii,jj) is the variable importance measure of
	430	* the ii-th variable according to:
	431	* jj = 0 - (classCount-1)
	432	* classwise permutation importance
	433	* jj = rowCount(variable_importance_) -2
	434	* permutation importance
	435	* jj = rowCount(variable_importance_) -1
	436	* gini decrease importance.
	437	*
	438	* permutation importance:
	439	* The difference between the fraction of OOB samples classified correctly
	440	* before and after permuting (randomizing) the ii-th column is calculated.
	441	* The ii-th column is permuted rep_cnt times.
	442	*
	443	* class wise permutation importance:
	444	* same as permutation importance. We only look at those OOB samples whose
	445	* response corresponds to class jj.
	446	*
	447	* gini decrease importance:
	448	* row ii corresponds to the sum of all gini decreases induced by variable ii
	449	* in each node of the random forest.
	450	*/
	451	MultiArray<2, double> variable_importance_;
	452
	453	/**
	454	* how often the permutation takes place
	455	*/
	456	size_t repetition_count_;
	457
	458	private:
	459
	460	/**
	461	* Copy the out-of-bag features and labels.
	462	*/
	463	template <typename F0, typename L0, typename F1, typename L1>
	464	void copy_out_of_bags(
	465	F0 const & features_in,
	466	L0 const & labels_in,
	467	F1 & features_out,
	468	L1 & labels_out
	469	) const {
	470	auto const num_instances = features_in.shape()[0];
	471	auto const num_features = features_in.shape()[1];
	472
	473	// Count the out-of-bags.
	474	size_t num_oobs = 0;
	475	for (auto x : is_in_bag_)
	476	if (!x)
	477	++num_oobs;
	478
	479	// Copy the out-of-bags.
	480	features_out.reshape(Shape2(num_oobs, num_features));
	481	labels_out.reshape(Shape1(num_oobs));
	482	size_t current = 0;
	483	for (size_t i = 0; i < (size_t)num_instances; ++i)
	484	{
	485	if (!is_in_bag_[i])
	486	{
	487	auto const src = features_in.template bind<0>(i);
	488	auto out = features_out.template bind<0>(current);
	489	out = src;
	490	labels_out(current) = labels_in(i);
	491	++current;
	492	}
	493	}
	494	}
	495
	496	std::vector<bool> is_in_bag_; // whether a data point is in-bag or out-of-bag
	497	};
	498
	499
	500
	501	/////////////////////////////////////////////
	502	// The visitor chain //
	503	/////////////////////////////////////////////
	504
	505	/**
	506	* @brief The default visitor node (= "do nothing").
	507	*/
	508	class RFStopVisiting : public RFVisitorBase
	509	{};
	510
	511	namespace detail
	512	{
	513
	514	/**
	515	* @brief Container elements of the statically linked visitor list. Use the create_visitor() functions to create visitors up to size 10.
	516	*/
	517	template <typename VISITOR, typename NEXT = RFStopVisiting, bool CPY = false>
	518	class RFVisitorNode
	519	{
	520	public:
	521
	522	typedef VISITOR Visitor;
	523	typedef NEXT Next;
	524
	525	typename std::conditional<CPY, Visitor, Visitor &>::type visitor_;
	526	Next next_;
	527
	528	RFVisitorNode(Visitor & visitor, Next next)
	529	:
	530	visitor_(visitor),
	531	next_(next)
	532	{}
	533
	534	explicit RFVisitorNode(Visitor & visitor)
	535	:
	536	visitor_(visitor),
	537	next_(RFStopVisiting())
	538	{}
	539
	540	explicit RFVisitorNode(RFVisitorNode<Visitor, Next, !CPY> & other)
	541	:
	542	visitor_(other.visitor_),
	543	next_(other.next_)
	544	{}
	545
	546	explicit RFVisitorNode(RFVisitorNode<Visitor, Next, !CPY> const & other)
	547	:
	548	visitor_(other.visitor_),
	549	next_(other.next_)
	550	{}
	551
	552	void visit_before_training()
	553	{
	554	if (visitor_.is_active())
	555	visitor_.visit_before_training();
	556	next_.visit_before_training();
	557	}
	558
	559	template <typename VISITORS, typename RF, typename FEATURES, typename LABELS>
	560	void visit_after_training(VISITORS & v, RF & rf, const FEATURES & features, const LABELS & labels)
	561	{
	562	typedef typename VISITORS::value_type VisitorNodeType;
	563	typedef typename VisitorNodeType::Visitor VisitorType;
	564	typedef typename VisitorNodeType::Next NextType;
	565
	566	// We want to call the visit_after_training function of the concrete visitor (e. g. OOBError).
	567	// Since v is a vector of visitor nodes (and not a vector of concrete visitors), we have to
	568	// extract the concrete visitors.
	569	// A vector cannot hold references, so we use pointers instead.
	570	if (visitor_.is_active())
	571	{
	572	std::vector<VisitorType*> visitors;
	573	for (auto & x : v)
	574	visitors.push_back(&x.visitor_);
	575	visitor_.visit_after_training(visitors, rf, features, labels);
	576	}
	577
	578	// Remove the concrete visitors that we just visited.
	579	std::vector<NextType> nexts;
	580	for (auto & x : v)
	581	nexts.push_back(x.next_);
	582
	583	// Call the next visitor node in the chain.
	584	next_.visit_after_training(nexts, rf, features, labels);
	585	}
	586
	587	template <typename TREE, typename FEATURES, typename LABELS, typename WEIGHTS>
	588	void visit_before_tree(TREE & tree, FEATURES & features, LABELS & labels, WEIGHTS & weights)
	589	{
	590	if (visitor_.is_active())
	591	visitor_.visit_before_tree(tree, features, labels, weights);
	592	next_.visit_before_tree(tree, features, labels, weights);
	593	}
	594
	595	template <typename RF, typename FEATURES, typename LABELS, typename WEIGHTS>
	596	void visit_after_tree(RF & rf,
	597	FEATURES & features,
	598	LABELS & labels,
	599	WEIGHTS & weights)
	600	{
	601	if (visitor_.is_active())
	602	visitor_.visit_after_tree(rf, features, labels, weights);
	603	next_.visit_after_tree(rf, features, labels, weights);
	604	}
	605
	606	template <typename TREE,
	607	typename FEATURES,
	608	typename LABELS,
	609	typename WEIGHTS,
	610	typename SCORER,
	611	typename ITER>
	612	void visit_after_split(TREE & tree,
	613	FEATURES & features,
	614	LABELS & labels,
	615	WEIGHTS & weights,
	616	SCORER & scorer,
	617	ITER begin,
	618	ITER split,
	619	ITER end)
	620	{
	621	if (visitor_.is_active())
	622	visitor_.visit_after_split(tree, features, labels, weights, scorer, begin, split, end);
	623	next_.visit_after_split(tree, features, labels, weights, scorer, begin, split, end);
	624	}
	625
	626	};
	627
	628	} // namespace detail
	629
	630	/**
	631	* The VisitorCopy can be used to set the copy argument of the given visitor chain to true.
	632	*/
	633	template <typename VISITOR>
	634	struct VisitorCopy
	635	{
	636	typedef detail::RFVisitorNode<typename VISITOR::Visitor, typename VisitorCopy<typename VISITOR::Next>::type, true> type;
	637	};
	638
	639	template <>
	640	struct VisitorCopy<RFStopVisiting>
	641	{
	642	typedef RFStopVisiting type;
	643	};
	644
	645
	646
	647	//////////////////////////////////////////////////////////
	648	// Visitor factory functions for up to 10 visitors. //
	649	// FIXME: This should be a variadic template. //
	650	//////////////////////////////////////////////////////////
	651
	652	template<typename A>
	653	detail::RFVisitorNode<A>
	654	create_visitor(A & a)
	655	{
	656	typedef detail::RFVisitorNode<A> _0_t;
	657	_0_t _0(a);
	658	return _0;
	659	}
	660
	661	template<typename A, typename B>
	662	detail::RFVisitorNode<A, detail::RFVisitorNode<B> >
	663	create_visitor(A & a, B & b)
	664	{
	665	typedef detail::RFVisitorNode<B> _1_t;
	666	_1_t _1(b);
	667	typedef detail::RFVisitorNode<A, _1_t> _0_t;
	668	_0_t _0(a, _1);
	669	return _0;
	670	}
	671
	672	template<typename A, typename B, typename C>
	673	detail::RFVisitorNode<A, detail::RFVisitorNode<B, detail::RFVisitorNode<C> > >
	674	create_visitor(A & a, B & b, C & c)
	675	{
	676	typedef detail::RFVisitorNode<C> _2_t;
	677	_2_t _2(c);
	678	typedef detail::RFVisitorNode<B, _2_t> _1_t;
	679	_1_t _1(b, _2);
	680	typedef detail::RFVisitorNode<A, _1_t> _0_t;
	681	_0_t _0(a, _1);
	682	return _0;
	683	}
	684
	685	template<typename A, typename B, typename C, typename D>
	686	detail::RFVisitorNode<A, detail::RFVisitorNode<B, detail::RFVisitorNode<C,
	687	detail::RFVisitorNode<D> > > >
	688	create_visitor(A & a, B & b, C & c, D & d)
	689	{
	690	typedef detail::RFVisitorNode<D> _3_t;
	691	_3_t _3(d);
	692	typedef detail::RFVisitorNode<C, _3_t> _2_t;
	693	_2_t _2(c, _3);
	694	typedef detail::RFVisitorNode<B, _2_t> _1_t;
	695	_1_t _1(b, _2);
	696	typedef detail::RFVisitorNode<A, _1_t> _0_t;
	697	_0_t _0(a, _1);
	698	return _0;
	699	}
	700
	701	template<typename A, typename B, typename C, typename D, typename E>
	702	detail::RFVisitorNode<A, detail::RFVisitorNode<B, detail::RFVisitorNode<C,
	703	detail::RFVisitorNode<D, detail::RFVisitorNode<E> > > > >
	704	create_visitor(A & a, B & b, C & c, D & d, E & e)
	705	{
	706	typedef detail::RFVisitorNode<E> _4_t;
	707	_4_t _4(e);
	708	typedef detail::RFVisitorNode<D, _4_t> _3_t;
	709	_3_t _3(d, _4);
	710	typedef detail::RFVisitorNode<C, _3_t> _2_t;
	711	_2_t _2(c, _3);
	712	typedef detail::RFVisitorNode<B, _2_t> _1_t;
	713	_1_t _1(b, _2);
	714	typedef detail::RFVisitorNode<A, _1_t> _0_t;
	715	_0_t _0(a, _1);
	716	return _0;
	717	}
	718
	719	template<typename A, typename B, typename C, typename D, typename E,
	720	typename F>
	721	detail::RFVisitorNode<A, detail::RFVisitorNode<B, detail::RFVisitorNode<C,
	722	detail::RFVisitorNode<D, detail::RFVisitorNode<E, detail::RFVisitorNode<F> > > > > >
	723	create_visitor(A & a, B & b, C & c, D & d, E & e, F & f)
	724	{
	725	typedef detail::RFVisitorNode<F> _5_t;
	726	_5_t _5(f);
	727	typedef detail::RFVisitorNode<E, _5_t> _4_t;
	728	_4_t _4(e, _5);
	729	typedef detail::RFVisitorNode<D, _4_t> _3_t;
	730	_3_t _3(d, _4);
	731	typedef detail::RFVisitorNode<C, _3_t> _2_t;
	732	_2_t _2(c, _3);
	733	typedef detail::RFVisitorNode<B, _2_t> _1_t;
	734	_1_t _1(b, _2);
	735	typedef detail::RFVisitorNode<A, _1_t> _0_t;
	736	_0_t _0(a, _1);
	737	return _0;
	738	}
	739
	740	template<typename A, typename B, typename C, typename D, typename E,
	741	typename F, typename G>
	742	detail::RFVisitorNode<A, detail::RFVisitorNode<B, detail::RFVisitorNode<C,
	743	detail::RFVisitorNode<D, detail::RFVisitorNode<E, detail::RFVisitorNode<F,
	744	detail::RFVisitorNode<G> > > > > > >
	745	create_visitor(A & a, B & b, C & c, D & d, E & e, F & f, G & g)
	746	{
	747	typedef detail::RFVisitorNode<G> _6_t;
	748	_6_t _6(g);
	749	typedef detail::RFVisitorNode<F, _6_t> _5_t;
	750	_5_t _5(f, _6);
	751	typedef detail::RFVisitorNode<E, _5_t> _4_t;
	752	_4_t _4(e, _5);
	753	typedef detail::RFVisitorNode<D, _4_t> _3_t;
	754	_3_t _3(d, _4);
	755	typedef detail::RFVisitorNode<C, _3_t> _2_t;
	756	_2_t _2(c, _3);
	757	typedef detail::RFVisitorNode<B, _2_t> _1_t;
	758	_1_t _1(b, _2);
	759	typedef detail::RFVisitorNode<A, _1_t> _0_t;
	760	_0_t _0(a, _1);
	761	return _0;
	762	}
	763
	764	template<typename A, typename B, typename C, typename D, typename E,
	765	typename F, typename G, typename H>
	766	detail::RFVisitorNode<A, detail::RFVisitorNode<B, detail::RFVisitorNode<C,
	767	detail::RFVisitorNode<D, detail::RFVisitorNode<E, detail::RFVisitorNode<F,
	768	detail::RFVisitorNode<G, detail::RFVisitorNode<H> > > > > > > >
	769	create_visitor(A & a, B & b, C & c, D & d, E & e, F & f, G & g, H & h)
	770	{
	771	typedef detail::RFVisitorNode<H> _7_t;
	772	_7_t _7(h);
	773	typedef detail::RFVisitorNode<G, _7_t> _6_t;
	774	_6_t _6(g, _7);
	775	typedef detail::RFVisitorNode<F, _6_t> _5_t;
	776	_5_t _5(f, _6);
	777	typedef detail::RFVisitorNode<E, _5_t> _4_t;
	778	_4_t _4(e, _5);
	779	typedef detail::RFVisitorNode<D, _4_t> _3_t;
	780	_3_t _3(d, _4);
	781	typedef detail::RFVisitorNode<C, _3_t> _2_t;
	782	_2_t _2(c, _3);
	783	typedef detail::RFVisitorNode<B, _2_t> _1_t;
	784	_1_t _1(b, _2);
	785	typedef detail::RFVisitorNode<A, _1_t> _0_t;
	786	_0_t _0(a, _1);
	787	return _0;
	788	}
	789
	790	template<typename A, typename B, typename C, typename D, typename E,
	791	typename F, typename G, typename H, typename I>
	792	detail::RFVisitorNode<A, detail::RFVisitorNode<B, detail::RFVisitorNode<C,
	793	detail::RFVisitorNode<D, detail::RFVisitorNode<E, detail::RFVisitorNode<F,
	794	detail::RFVisitorNode<G, detail::RFVisitorNode<H, detail::RFVisitorNode<I> > > > > > > > >
	795	create_visitor(A & a, B & b, C & c, D & d, E & e, F & f, G & g, H & h, I & i)
	796	{
	797	typedef detail::RFVisitorNode<I> _8_t;
	798	_8_t _8(i);
	799	typedef detail::RFVisitorNode<H, _8_t> _7_t;
	800	_7_t _7(h, _8);
	801	typedef detail::RFVisitorNode<G, _7_t> _6_t;
	802	_6_t _6(g, _7);
	803	typedef detail::RFVisitorNode<F, _6_t> _5_t;
	804	_5_t _5(f, _6);
	805	typedef detail::RFVisitorNode<E, _5_t> _4_t;
	806	_4_t _4(e, _5);
	807	typedef detail::RFVisitorNode<D, _4_t> _3_t;
	808	_3_t _3(d, _4);
	809	typedef detail::RFVisitorNode<C, _3_t> _2_t;
	810	_2_t _2(c, _3);
	811	typedef detail::RFVisitorNode<B, _2_t> _1_t;
	812	_1_t _1(b, _2);
	813	typedef detail::RFVisitorNode<A, _1_t> _0_t;
	814	_0_t _0(a, _1);
	815	return _0;
	816	}
	817
	818	template<typename A, typename B, typename C, typename D, typename E,
	819	typename F, typename G, typename H, typename I, typename J>
	820	detail::RFVisitorNode<A, detail::RFVisitorNode<B, detail::RFVisitorNode<C,
	821	detail::RFVisitorNode<D, detail::RFVisitorNode<E, detail::RFVisitorNode<F,
	822	detail::RFVisitorNode<G, detail::RFVisitorNode<H, detail::RFVisitorNode<I,
	823	detail::RFVisitorNode<J> > > > > > > > > >
	824	create_visitor(A & a, B & b, C & c, D & d, E & e, F & f, G & g, H & h, I & i,
	825	J & j)
	826	{
	827	typedef detail::RFVisitorNode<J> _9_t;
	828	_9_t _9(j);
	829	typedef detail::RFVisitorNode<I, _9_t> _8_t;
	830	_8_t _8(i, _9);
	831	typedef detail::RFVisitorNode<H, _8_t> _7_t;
	832	_7_t _7(h, _8);
	833	typedef detail::RFVisitorNode<G, _7_t> _6_t;
	834	_6_t _6(g, _7);
	835	typedef detail::RFVisitorNode<F, _6_t> _5_t;
	836	_5_t _5(f, _6);
	837	typedef detail::RFVisitorNode<E, _5_t> _4_t;
	838	_4_t _4(e, _5);
	839	typedef detail::RFVisitorNode<D, _4_t> _3_t;
	840	_3_t _3(d, _4);
	841	typedef detail::RFVisitorNode<C, _3_t> _2_t;
	842	_2_t _2(c, _3);
	843	typedef detail::RFVisitorNode<B, _2_t> _1_t;
	844	_1_t _1(b, _2);
	845	typedef detail::RFVisitorNode<A, _1_t> _0_t;
	846	_0_t _0(a, _1);
	847	return _0;
	848	}
	849
	850
	851
	852	} // namespace rf3
	853	} // namespace vigra
	854
	855	#endif

+643

-0

include/vigra/random_forest_3.hxx less more

	0	/************************************************************************/
	1	/* */
	2	/* Copyright 2014-2015 by Ullrich Koethe and Philip Schill */
	3	/* */
	4	/* This file is part of the VIGRA computer vision library. */
	5	/* The VIGRA Website is */
	6	/* http://hci.iwr.uni-heidelberg.de/vigra/ */
	7	/* Please direct questions, bug reports, and contributions to */
	8	/* ullrich.koethe@iwr.uni-heidelberg.de or */
	9	/* vigra@informatik.uni-hamburg.de */
	10	/* */
	11	/* Permission is hereby granted, free of charge, to any person */
	12	/* obtaining a copy of this software and associated documentation */
	13	/* files (the "Software"), to deal in the Software without */
	14	/* restriction, including without limitation the rights to use, */
	15	/* copy, modify, merge, publish, distribute, sublicense, and/or */
	16	/* sell copies of the Software, and to permit persons to whom the */
	17	/* Software is furnished to do so, subject to the following */
	18	/* conditions: */
	19	/* */
	20	/* The above copyright notice and this permission notice shall be */
	21	/* included in all copies or substantial portions of the */
	22	/* Software. */
	23	/* */
	24	/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND */
	25	/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES */
	26	/* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND */
	27	/* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT */
	28	/* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, */
	29	/* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING */
	30	/* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR */
	31	/* OTHER DEALINGS IN THE SOFTWARE. */
	32	/* */
	33	/************************************************************************/
	34	#ifndef VIGRA_RF3_HXX
	35	#define VIGRA_RF3_HXX
	36
	37	#include <vector>
	38	#include <set>
	39	#include <map>
	40	#include <stack>
	41	#include <algorithm>
	42
	43	#include "multi_array.hxx"
	44	#include "sampling.hxx"
	45	#include "threading.hxx"
	46	#include "threadpool.hxx"
	47	#include "random_forest_3/random_forest.hxx"
	48	#include "random_forest_3/random_forest_common.hxx"
	49	#include "random_forest_3/random_forest_visitors.hxx"
	50
	51	namespace vigra
	52	{
	53
	54	/** \addtogroup MachineLearning
	55	**/
	56	//@{
	57
	58	/** \brief Random forest version 3.
	59
	60	This namespace contains VIGRA's 3rd version of the random forest classification/regression algorithm.
	61	This version is much easier to customize than previous versions because it consequently separates
	62	algorithms from the forest representation, following the design of the LEMON graph library.
	63	*/
	64	namespace rf3
	65	{
	66
	67	template <typename FEATURES, typename LABELS>
	68	struct DefaultRF
	69	{
	70	typedef RandomForest<FEATURES,
	71	LABELS,
	72	LessEqualSplitTest<typename FEATURES::value_type>,
	73	ArgMaxVectorAcc<double> > type;
	74	};
	75
	76	namespace detail
	77	{
	78
	79	// In random forest training, you can store different items in the leaves,
	80	// depending on the accumulator. Typically, you want to store the class
	81	// distributions, but the ArgMaxAcc does not need this. The RFMapUpdater is
	82	// used to store only the necessary information.
	83
	84	template <typename ACC>
	85	struct RFMapUpdater
	86	{
	87	template <typename A, typename B>
	88	void operator()(A & a, B const & b) const
	89	{
	90	a = b;
	91	}
	92	};
	93
	94
	95
	96	template <>
	97	struct RFMapUpdater<ArgMaxAcc>
	98	{
	99	template <typename A, typename B>
	100	void operator()(A & a, B const & b) const
	101	{
	102	auto it = std::max_element(b.begin(), b.end());
	103	a = std::distance(b.begin(), it);
	104	}
	105	};
	106
	107
	108
	109	/// Loop over the split dimensions and compute the score of all considered splits.
	110	template <typename FEATURES, typename LABELS, typename SAMPLER, typename SCORER>
	111	void split_score(
	112	FEATURES const & features,
	113	LABELS const & labels,
	114	std::vector<double> const & instance_weights,
	115	std::vector<size_t> const & instances,
	116	SAMPLER const & dim_sampler,
	117	SCORER & score
	118	){
	119	typedef typename FEATURES::value_type FeatureType;
	120
	121	auto feats = std::vector<FeatureType>(instances.size()); // storage for the features
	122	auto sorted_indices = std::vector<size_t>(feats.size()); // storage for the index sort result
	123	auto tosort_instances = std::vector<size_t>(feats.size()); // storage for the sorted instances
	124
	125	for (int i = 0; i < dim_sampler.sampleSize(); ++i)
	126	{
	127	size_t const d = dim_sampler[i];
	128
	129	// Copy the features to a vector with the correct size (so the sort is faster because of data locality).
	130	for (size_t kk = 0; kk < instances.size(); ++kk)
	131	feats[kk] = features(instances[kk], d);
	132
	133	// Sort the features.
	134	indexSort(feats.begin(), feats.end(), sorted_indices.begin());
	135	std::copy(instances.begin(), instances.end(), tosort_instances.begin());
	136	applyPermutation(sorted_indices.begin(), sorted_indices.end(), instances.begin(), tosort_instances.begin());
	137
	138	// Get the score of the splits.
	139	score(features, labels, instance_weights, tosort_instances.begin(), tosort_instances.end(), d);
	140	}
	141	}
	142
	143
	144
	145	/**
	146	* @brief Train a single randomized decision tree.
	147	*/
	148	template <typename RF, typename SCORER, typename VISITOR, typename STOP, typename RANDENGINE>
	149	void random_forest_single_tree(
	150	typename RF::Features const & features,
	151	MultiArray<1, size_t> const & labels,
	152	RandomForestOptions const & options,
	153	VISITOR & visitor,
	154	STOP stop,
	155	RF & tree,
	156	RANDENGINE const & randengine
	157	){
	158	typedef typename RF::Features Features;
	159	typedef typename Features::value_type FeatureType;
	160	typedef LessEqualSplitTest<FeatureType> SplitTests;
	161	typedef typename RF::Node Node;
	162	typedef typename RF::ACC ACC;
	163	typedef typename ACC::input_type ACCInputType;
	164
	165	static_assert(std::is_same<SplitTests, typename RF::SplitTests>::value,
	166	"random_forest_single_tree(): Wrong Random Forest class.");
	167
	168	// the api is seriously broke...
	169	int const num_instances = features.shape()[0];
	170	size_t const num_features = features.shape()[1];
	171	auto const & spec = tree.problem_spec_;
	172
	173	vigra_precondition(num_instances == labels.size(),
	174	"random_forest_single_tree(): Shape mismatch between features and labels.");
	175	vigra_precondition(num_features == spec.num_features_,
	176	"random_forest_single_tree(): Wrong number of features.");
	177
	178	// Create the index vector for bookkeeping.
	179	std::vector<size_t> instance_indices(num_instances);
	180	std::iota(instance_indices.begin(), instance_indices.end(), 0);
	181	typedef std::vector<size_t>::iterator InstanceIter;
	182
	183	// Create the weights for the bootstrap sample.
	184	std::vector<double> instance_weights(num_instances, 1.0);
	185	if (options.bootstrap_sampling_)
	186	{
	187	std::fill(instance_weights.begin(), instance_weights.end(), 0.0);
	188	Sampler<MersenneTwister> sampler(num_instances,
	189	SamplerOptions().withReplacement().stratified(options.use_stratification_),
	190	&randengine);
	191	sampler.sample();
	192	for (int i = 0; i < sampler.sampleSize(); ++i)
	193	{
	194	int const index = sampler[i];
	195	++instance_weights[index];
	196	}
	197	}
	198
	199	// Multiply the instance weights by the class weights.
	200	if (options.class_weights_.size() > 0)
	201	{
	202	for (size_t i = 0; i < instance_weights.size(); ++i)
	203	instance_weights[i] *= options.class_weights_.at(labels(i));
	204	}
	205
	206	// Create the sampler for the split dimensions.
	207	auto const mtry = spec.actual_mtry_;
	208	Sampler<MersenneTwister> dim_sampler(num_features, SamplerOptions().withoutReplacement().sampleSize(mtry), &randengine);
	209
	210	// Create the node stack and place the root node inside.
	211	std::stack<Node> node_stack;
	212	typedef std::pair<InstanceIter, InstanceIter> IterPair;
	213	PropertyMap<Node, IterPair> instance_range; // begin and end of the instances of a node in the bookkeeping vector
	214	PropertyMap<Node, std::vector<double> > node_distributions; // the class distributions in the nodes
	215	PropertyMap<Node, size_t> node_depths; // the depth of each node
	216	{
	217	auto const rootnode = tree.graph_.addNode();
	218	node_stack.push(rootnode);
	219
	220	instance_range.insert(rootnode, IterPair(instance_indices.begin(), instance_indices.end()));
	221
	222	std::vector<double> priors(spec.num_classes_, 0.0);
	223	for (auto i : instance_indices)
	224	priors[labels(i)] += instance_weights[i];
	225	node_distributions.insert(rootnode, priors);
	226
	227	node_depths.insert(rootnode, 0);
	228	}
	229
	230	// Call the visitor.
	231	visitor.visit_before_tree(tree, features, labels, instance_weights);
	232
	233	// Split the nodes.
	234	detail::RFMapUpdater<ACC> node_map_updater;
	235	while (!node_stack.empty())
	236	{
	237	// Get the data of the current node.
	238	auto const node = node_stack.top();
	239	node_stack.pop();
	240	auto const begin = instance_range.at(node).first;
	241	auto const end = instance_range.at(node).second;
	242	auto const & priors = node_distributions.at(node);
	243	auto const depth = node_depths.at(node);
	244
	245	// Get the instances with weight > 0.
	246	std::vector<size_t> used_instances;
	247	for (auto it = begin; it != end; ++it)
	248	if (instance_weights[*it] > 1e-10)
	249	used_instances.push_back(*it);
	250
	251	// Find the best split.
	252	dim_sampler.sample();
	253	SCORER score(priors);
	254	if (options.resample_count_ == 0 \|\| used_instances.size() <= options.resample_count_)
	255	{
	256	// Find the split using all instances.
	257	detail::split_score(
	258	features,
	259	labels,
	260	instance_weights,
	261	used_instances,
	262	dim_sampler,
	263	score
	264	);
	265	}
	266	else
	267	{
	268	// Generate a random subset of the instances.
	269	Sampler<MersenneTwister> resampler(used_instances.begin(), used_instances.end(), SamplerOptions().withoutReplacement().sampleSize(options.resample_count_), &randengine);
	270	resampler.sample();
	271	auto indices = std::vector<size_t>(options.resample_count_);
	272	for (size_t i = 0; i < options.resample_count_; ++i)
	273	indices[i] = used_instances[resampler[i]];
	274
	275	// Find the split using the subset.
	276	detail::split_score(
	277	features,
	278	labels,
	279	instance_weights,
	280	indices,
	281	dim_sampler,
	282	score
	283	);
	284	}
	285
	286	// If no split was found, the node is terminal.
	287	if (!score.split_found_)
	288	{
	289	tree.node_responses_.insert(node, ACCInputType());
	290	node_map_updater(tree.node_responses_.at(node), node_distributions.at(node));
	291	continue;
	292	}
	293
	294	// Create the child nodes and split the instances accordingly.
	295	auto const n_left = tree.graph_.addNode();
	296	auto const n_right = tree.graph_.addNode();
	297	tree.graph_.addArc(node, n_left);
	298	tree.graph_.addArc(node, n_right);
	299	auto const best_split = score.best_split_;
	300	auto const best_dim = score.best_dim_;
	301	auto const split_iter = std::partition(begin, end,
	302	[&](size_t i)
	303	{
	304	return features(i, best_dim) <= best_split;
	305	}
	306	);
	307
	308	// Call the visitor.
	309	visitor.visit_after_split(tree, features, labels, instance_weights, score, begin, split_iter, end);
	310
	311	instance_range.insert(n_left, IterPair(begin, split_iter));
	312	instance_range.insert(n_right, IterPair(split_iter, end));
	313	tree.split_tests_.insert(node, SplitTests(best_dim, best_split));
	314	node_depths.insert(n_left, depth+1);
	315	node_depths.insert(n_right, depth+1);
	316
	317	// Compute the class distribution for the left child.
	318	auto priors_left = std::vector<double>(spec.num_classes_, 0.0);
	319	for (auto it = begin; it != split_iter; ++it)
	320	priors_left[labels(it)] += instance_weights[it];
	321	node_distributions.insert(n_left, priors_left);
	322
	323	// Check if the left child is terminal.
	324	if (stop(labels, RFNodeDescription<decltype(priors_left)>(depth+1, priors_left)))
	325	{
	326	tree.node_responses_.insert(n_left, ACCInputType());
	327	node_map_updater(tree.node_responses_.at(n_left), node_distributions.at(n_left));
	328	}
	329	else
	330	{
	331	node_stack.push(n_left);
	332	}
	333
	334	// Compute the class distribution for the right child.
	335	auto priors_right = std::vector<double>(spec.num_classes_, 0.0);
	336	for (auto it = split_iter; it != end; ++it)
	337	priors_right[labels(it)] += instance_weights[it];
	338	node_distributions.insert(n_right, priors_right);
	339
	340	// Check if the right child is terminal.
	341	if (stop(labels, RFNodeDescription<decltype(priors_right)>(depth+1, priors_right)))
	342	{
	343	tree.node_responses_.insert(n_right, ACCInputType());
	344	node_map_updater(tree.node_responses_.at(n_right), node_distributions.at(n_right));
	345	}
	346	else
	347	{
	348	node_stack.push(n_right);
	349	}
	350	}
	351
	352	// Call the visitor.
	353	visitor.visit_after_tree(tree, features, labels, instance_weights);
	354	}
	355
	356
	357
	358	/// \brief Preprocess the labels and call the train functions on the single trees.
	359	template <typename FEATURES,
	360	typename LABELS,
	361	typename VISITOR,
	362	typename SCORER,
	363	typename STOP,
	364	typename RANDENGINE>
	365	RandomForest<FEATURES, LABELS>
	366	random_forest_impl(
	367	FEATURES const & features,
	368	LABELS const & labels,
	369	RandomForestOptions const & options,
	370	VISITOR visitor,
	371	STOP const & stop,
	372	RANDENGINE & randengine
	373	){
	374	// typedef FEATURES Features;
	375	typedef LABELS Labels;
	376	// typedef typename Features::value_type FeatureType;
	377	typedef typename Labels::value_type LabelType;
	378	typedef RandomForest<FEATURES, LABELS> RF;
	379
	380	ProblemSpec<LabelType> pspec;
	381	pspec.num_instances(features.shape()[0])
	382	.num_features(features.shape()[1])
	383	.actual_mtry(options.get_features_per_node(features.shape()[1]))
	384	.actual_msample(labels.size());
	385
	386	// Check the number of trees.
	387	size_t const tree_count = options.tree_count_;
	388	vigra_precondition(tree_count > 0, "random_forest_impl(): tree_count must not be zero.");
	389	std::vector<RF> trees(tree_count);
	390
	391	// Transform the labels to 0, 1, 2, ...
	392	std::set<LabelType> const dlabels(labels.begin(), labels.end());
	393	std::vector<LabelType> const distinct_labels(dlabels.begin(), dlabels.end());
	394	pspec.distinct_classes(distinct_labels);
	395	std::map<LabelType, size_t> label_map;
	396	for (size_t i = 0; i < distinct_labels.size(); ++i)
	397	{
	398	label_map[distinct_labels[i]] = i;
	399	}
	400
	401	MultiArray<1, LabelType> transformed_labels(Shape1(labels.size()));
	402	for (size_t i = 0; i < (size_t)labels.size(); ++i)
	403	{
	404	transformed_labels(i) = label_map[labels(i)];
	405	}
	406
	407	// Check the vector with the class weights.
	408	vigra_precondition(options.class_weights_.size() == 0 \|\| options.class_weights_.size() == distinct_labels.size(),
	409	"random_forest_impl(): The number of class weights must be 0 or equal to the number of classes.");
	410
	411	// Write the problem specification into the trees.
	412	for (auto & t : trees)
	413	t.problem_spec_ = pspec;
	414
	415	// Find the correct number of threads.
	416	size_t n_threads = 1;
	417	if (options.n_threads_ >= 1)
	418	n_threads = options.n_threads_;
	419	else if (options.n_threads_ == -1)
	420	n_threads = std::thread::hardware_concurrency();
	421
	422	// Use the global random engine to create seeds for the random engines that run in the threads.
	423	UniformIntRandomFunctor<RANDENGINE> rand_functor(randengine);
	424	std::set<UInt32> seeds;
	425	while (seeds.size() < n_threads)
	426	{
	427	seeds.insert(rand_functor());
	428	}
	429	vigra_assert(seeds.size() == n_threads, "random_forest_impl(): Could not create random seeds.");
	430
	431	// Create the random engines that run in the threads.
	432	std::vector<RANDENGINE> rand_engines;
	433	for (auto seed : seeds)
	434	{
	435	rand_engines.push_back(RANDENGINE(seed));
	436	}
	437
	438	// Call the visitor.
	439	visitor.visit_before_training();
	440
	441	// Copy the visitor for each tree.
	442	// We must change the type, since the original visitor chain holds references and therefore a default copy would be useless.
	443	typedef typename VisitorCopy<VISITOR>::type VisitorCopyType;
	444	std::vector<VisitorCopyType> tree_visitors;
	445	for (size_t i = 0; i < tree_count; ++i)
	446	{
	447	tree_visitors.emplace_back(visitor);
	448	}
	449
	450	// Train the trees.
	451	ThreadPool pool((size_t)n_threads);
	452	std::vector<threading::future<void> > futures;
	453	for (size_t i = 0; i < tree_count; ++i)
	454	{
	455	futures.emplace_back(
	456	pool.enqueue([&features, &transformed_labels, &options, &tree_visitors, &stop, &trees, i, &rand_engines](size_t thread_id)
	457	{
	458	random_forest_single_tree<RF, SCORER, VisitorCopyType, STOP>(features, transformed_labels, options, tree_visitors[i], stop, trees[i], rand_engines[thread_id]);
	459	}
	460	)
	461	);
	462	}
	463	for (auto & fut : futures)
	464	fut.get();
	465
	466	// Merge the trees together.
	467	RF rf(trees[0]);
	468	rf.options_ = options;
	469	for (size_t i = 1; i < trees.size(); ++i)
	470	{
	471	rf.merge(trees[i]);
	472	}
	473
	474	// Call the visitor.
	475	visitor.visit_after_training(tree_visitors, rf, features, labels);
	476
	477	return rf;
	478	}
	479
	480
	481
	482	/// \brief Get the stop criterion from the option object and pass it as template argument.
	483	template <typename FEATURES, typename LABELS, typename VISITOR, typename SCORER, typename RANDENGINE>
	484	inline
	485	RandomForest<FEATURES, LABELS>
	486	random_forest_impl0(
	487	FEATURES const & features,
	488	LABELS const & labels,
	489	RandomForestOptions const & options,
	490	VISITOR visitor,
	491	RANDENGINE & randengine
	492	){
	493	if (options.max_depth_ > 0)
	494	return random_forest_impl<FEATURES, LABELS, VISITOR, SCORER, DepthStop, RANDENGINE>(features, labels, options, visitor, DepthStop(options.max_depth_), randengine);
	495	else if (options.min_num_instances_ > 1)
	496	return random_forest_impl<FEATURES, LABELS, VISITOR, SCORER, NumInstancesStop, RANDENGINE>(features, labels, options, visitor, NumInstancesStop(options.min_num_instances_), randengine);
	497	else if (options.node_complexity_tau_ > 0)
	498	return random_forest_impl<FEATURES, LABELS, VISITOR, SCORER, NodeComplexityStop, RANDENGINE>(features, labels, options, visitor, NodeComplexityStop(options.node_complexity_tau_), randengine);
	499	else
	500	return random_forest_impl<FEATURES, LABELS, VISITOR, SCORER, PurityStop, RANDENGINE>(features, labels, options, visitor, PurityStop(), randengine);
	501	}
	502
	503	} // namespace detail
	504
	505	/********************************************************/
	506	/* */
	507	/* random_forest */
	508	/* */
	509	/********************************************************/
	510
	511	/** \brief Train a \ref vigra::rf3::RandomForest classifier.
	512
	513	This factory function constructs a \ref vigra::rf3::RandomForest classifier and trains
	514	it for the given features and labels. They must be given as a matrix with shape
	515	<tt>num_instances x num_features</tt> and an array with length <tt>num_instances</tt> respectively.
	516	Most training options (such as number of trees in the forest, termination and split criteria,
	517	and number of threads for parallel training) are specified via an option object of type \ref vigra::rf3::RandomForestOptions. Optional visitors are typically used to compute the
	518	out-of-bag error of the classifier (use \ref vigra::rf3::OOBError) and estimate variable importance
	519	on the basis of the Gini gain (use \ref vigra::rf3::VariableImportance). You can also provide
	520	a specific random number generator instance, which is especially useful when you want to
	521	enforce deterministic algorithm behavior during debugging.
	522
	523	<b> Declaration:</b>
	524
	525	\code
	526	namespace vigra { namespace rf3 {
	527	template <typename FEATURES,
	528	typename LABELS,
	529	typename VISITOR = vigra::rf3::RFStopVisiting,
	530	typename RANDENGINE = vigra::MersenneTwister>
	531	vigra::rf3::RandomForest<FEATURES, LABELS>
	532	random_forest(
	533	FEATURES const & features,
	534	LABELS const & labels,
	535	vigra::rf3::RandomForestOptions const & options = vigra::rf3::RandomForestOptions(),
	536	VISITOR visitor = vigra::rf3::RFStopVisiting(),
	537	RANDENGINE & randengine = vigra::MersenneTwister::global()
	538	);
	539	}}
	540	\endcode
	541
	542	<b> Usage:</b>
	543
	544	<b>\#include</b> \<vigra/random_forest_3.hxx\><br>
	545	Namespace: vigra::rf3
	546
	547	\code
	548	using namespace vigra;
	549
	550	int num_instances = ...;
	551	int num_features = ...;
	552	MultiArray<2, double> train_features(Shape2(num_instances, num_features));
	553	MultiArray<1, int> train_labels(Shape1(num_instances));
	554	... // fill training data matrices
	555
	556	rf3::OOBError oob; // visitor to compute the out-of-bag error
	557	auto rf = random_forest(train_features, train_labels,
	558	rf3::RandomForestOptions().tree_count(100)
	559	.features_per_node(rf3::RF_SQRT)
	560	.n_threads(4)
	561	rf3::create_visitor(oob));
	562
	563	std::cout << "Random forest training finished with out-of-bag error " << oob.oob_err_ << "\n";
	564
	565	int num_test_instances = ...;
	566	MultiArray<2, double> test_features(Shape2(num_test_instances, num_features));
	567	MultiArray<1, int> test_labels(Shape1(num_test_instances));
	568	... // fill feature matrix for test data
	569
	570	rf.predict(test_features, test_labels);
	571
	572	for(int i=0; i<num_test_instances; ++i)
	573	std::cerr << "Prediction for test instance " << i << ": " << test_labels(i) << "\n";
	574	\endcode
	575	*/
	576	doxygen_overloaded_function(template <...> void random_forest)
	577
	578	template <typename FEATURES, typename LABELS, typename VISITOR, typename RANDENGINE>
	579	inline
	580	RandomForest<FEATURES, LABELS>
	581	random_forest(
	582	FEATURES const & features,
	583	LABELS const & labels,
	584	RandomForestOptions const & options,
	585	VISITOR visitor,
	586	RANDENGINE & randengine
	587	){
	588	typedef detail::GeneralScorer<GiniScore> GiniScorer;
	589	typedef detail::GeneralScorer<EntropyScore> EntropyScorer;
	590	typedef detail::GeneralScorer<KolmogorovSmirnovScore> KSDScorer;
	591	if (options.split_ == RF_GINI)
	592	return detail::random_forest_impl0<FEATURES, LABELS, VISITOR, GiniScorer, RANDENGINE>(features, labels, options, visitor, randengine);
	593	else if (options.split_ == RF_ENTROPY)
	594	return detail::random_forest_impl0<FEATURES, LABELS, VISITOR, EntropyScorer, RANDENGINE>(features, labels, options, visitor, randengine);
	595	else if (options.split_ == RF_KSD)
	596	return detail::random_forest_impl0<FEATURES, LABELS, VISITOR, KSDScorer, RANDENGINE>(features, labels, options, visitor, randengine);
	597	else
	598	throw std::runtime_error("random_forest(): Unknown split criterion.");
	599	}
	600
	601	template <typename FEATURES, typename LABELS, typename VISITOR>
	602	inline
	603	RandomForest<FEATURES, LABELS>
	604	random_forest(
	605	FEATURES const & features,
	606	LABELS const & labels,
	607	RandomForestOptions const & options,
	608	VISITOR visitor
	609	){
	610	auto randengine = MersenneTwister::global();
	611	return random_forest(features, labels, options, visitor, randengine);
	612	}
	613
	614	template <typename FEATURES, typename LABELS>
	615	inline
	616	RandomForest<FEATURES, LABELS>
	617	random_forest(
	618	FEATURES const & features,
	619	LABELS const & labels,
	620	RandomForestOptions const & options
	621	){
	622	RFStopVisiting stop;
	623	return random_forest(features, labels, options, stop);
	624	}
	625
	626	template <typename FEATURES, typename LABELS>
	627	inline
	628	RandomForest<FEATURES, LABELS>
	629	random_forest(
	630	FEATURES const & features,
	631	LABELS const & labels
	632	){
	633	return random_forest(features, labels, RandomForestOptions());
	634	}
	635
	636	} // namespace rf3
	637
	638	//@}
	639
	640	} // namespace vigra
	641
	642	#endif

+424

-0

include/vigra/random_forest_3_hdf5_impex.hxx less more

	0	/************************************************************************/
	1	/* */
	2	/* Copyright 2009,2014, 2015 by Sven Peter, Philip Schill, */
	3	/* Rahul Nair and Ullrich Koethe */
	4	/* */
	5	/* This file is part of the VIGRA computer vision library. */
	6	/* The VIGRA Website is */
	7	/* http://hci.iwr.uni-heidelberg.de/vigra/ */
	8	/* Please direct questions, bug reports, and contributions to */
	9	/* ullrich.koethe@iwr.uni-heidelberg.de or */
	10	/* vigra@informatik.uni-hamburg.de */
	11	/* */
	12	/* Permission is hereby granted, free of charge, to any person */
	13	/* obtaining a copy of this software and associated documentation */
	14	/* files (the "Software"), to deal in the Software without */
	15	/* restriction, including without limitation the rights to use, */
	16	/* copy, modify, merge, publish, distribute, sublicense, and/or */
	17	/* sell copies of the Software, and to permit persons to whom the */
	18	/* Software is furnished to do so, subject to the following */
	19	/* conditions: */
	20	/* */
	21	/* The above copyright notice and this permission notice shall be */
	22	/* included in all copies or substantial portions of the */
	23	/* Software. */
	24	/* */
	25	/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND */
	26	/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES */
	27	/* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND */
	28	/* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT */
	29	/* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, */
	30	/* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING */
	31	/* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR */
	32	/* OTHER DEALINGS IN THE SOFTWARE. */
	33	/* */
	34	/************************************************************************/
	35
	36	#ifndef VIGRA_RF3_IMPEX_HDF5_HXX
	37	#define VIGRA_RF3_IMPEX_HDF5_HXX
	38
	39	#include <string>
	40	#include <sstream>
	41	#include <iomanip>
	42	#include <stack>
	43
	44	#include "config.hxx"
	45	#include "random_forest_3/random_forest.hxx"
	46	#include "random_forest_3/random_forest_common.hxx"
	47	#include "random_forest_3/random_forest_visitors.hxx"
	48	#include "hdf5impex.hxx"
	49
	50	namespace vigra
	51	{
	52	namespace rf3
	53	{
	54
	55	// needs to be in sync with random_forest_hdf5_impex for backwards compatibility
	56	static const char *const rf_hdf5_ext_param = "_ext_param";
	57	static const char *const rf_hdf5_options = "_options";
	58	static const char *const rf_hdf5_topology = "topology";
	59	static const char *const rf_hdf5_parameters = "parameters";
	60	static const char *const rf_hdf5_tree = "Tree_";
	61	static const char *const rf_hdf5_version_group = ".";
	62	static const char *const rf_hdf5_version_tag = "vigra_random_forest_version";
	63	static const double rf_hdf5_version = 0.1;
	64
	65	// keep in sync with include/vigra/random_forest/rf_nodeproxy.hxx
	66	enum NodeTags
	67	{
	68	rf_UnFilledNode = 42,
	69	rf_AllColumns = 0x00000000,
	70	rf_ToBePrunedTag = 0x80000000,
	71	rf_LeafNodeTag = 0x40000000,
	72
	73	rf_i_ThresholdNode = 0,
	74	rf_i_HyperplaneNode = 1,
	75	rf_i_HypersphereNode = 2,
	76	rf_e_ConstProbNode = 0 \| rf_LeafNodeTag,
	77	rf_e_LogRegProbNode = 1 \| rf_LeafNodeTag
	78	};
	79
	80	static const unsigned int rf_tag_mask = 0xf0000000;
	81	static const unsigned int rf_type_mask = 0x00000003;
	82	static const unsigned int rf_zero_mask = 0xffffffff & ~rf_tag_mask & ~rf_type_mask;
	83
	84	namespace detail
	85	{
	86	inline std::string get_cwd(HDF5File & h5context)
	87	{
	88	return h5context.get_absolute_path(h5context.pwd());
	89	}
	90	}
	91
	92	template <typename FEATURES, typename LABELS>
	93	typename DefaultRF<FEATURES, LABELS>::type
	94	random_forest_import_HDF5(HDF5File & h5ctx, std::string const & pathname = "")
	95	{
	96	typedef typename DefaultRF<FEATURES, LABELS>::type RF;
	97	typedef typename RF::Graph Graph;
	98	typedef typename RF::Node Node;
	99	typedef typename RF::SplitTests SplitTest;
	100	typedef typename LABELS::value_type LabelType;
	101	typedef typename RF::AccInputType AccInputType;
	102	typedef typename AccInputType::value_type AccValueType;
	103
	104	std::string cwd;
	105
	106	if (pathname.size()) {
	107	cwd = detail::get_cwd(h5ctx);
	108	h5ctx.cd(pathname);
	109	}
	110
	111	if (h5ctx.existsAttribute(rf_hdf5_version_group, rf_hdf5_version_tag)) {
	112	double version;
	113	h5ctx.readAttribute(rf_hdf5_version_group, rf_hdf5_version_tag, version);
	114	vigra_precondition(version <= rf_hdf5_version, "random_forest_import_HDF5(): unexpected file format version.");
	115	}
	116
	117	// Read ext params.
	118	size_t actual_mtry;
	119	size_t num_instances;
	120	size_t num_features;
	121	size_t num_classes;
	122	size_t msample;
	123	int is_weighted_int;
	124	MultiArray<1, LabelType> distinct_labels_marray;
	125	MultiArray<1, double> class_weights_marray;
	126
	127	h5ctx.cd(rf_hdf5_ext_param);
	128	h5ctx.read("actual_msample_", msample);
	129	h5ctx.read("actual_mtry_", actual_mtry);
	130	h5ctx.read("class_count_", num_classes);
	131	h5ctx.readAndResize("class_weights_", class_weights_marray);
	132	h5ctx.read("column_count_", num_features);
	133	h5ctx.read("is_weighted_", is_weighted_int);
	134	h5ctx.readAndResize("labels", distinct_labels_marray);
	135	h5ctx.read("row_count_", num_instances);
	136	h5ctx.cd_up();
	137
	138	bool is_weighted = is_weighted_int == 1 ? true : false;
	139
	140	// Read options.
	141	size_t min_num_instances;
	142	int mtry;
	143	int mtry_switch_int;
	144	int bootstrap_sampling_int;
	145	int tree_count;
	146	h5ctx.cd(rf_hdf5_options);
	147	h5ctx.read("min_split_node_size_", min_num_instances);
	148	h5ctx.read("mtry_", mtry);
	149	h5ctx.read("mtry_switch_", mtry_switch_int);
	150	h5ctx.read("sample_with_replacement_", bootstrap_sampling_int);
	151	h5ctx.read("tree_count_", tree_count);
	152	h5ctx.cd_up();
	153
	154	RandomForestOptionTags mtry_switch = (RandomForestOptionTags)mtry_switch_int;
	155	bool bootstrap_sampling = bootstrap_sampling_int == 1 ? true : false;
	156
	157	std::vector<LabelType> const distinct_labels(distinct_labels_marray.begin(), distinct_labels_marray.end());
	158	std::vector<double> const class_weights(class_weights_marray.begin(), class_weights_marray.end());
	159
	160	auto const pspec = ProblemSpec<LabelType>()
	161	.num_features(num_features)
	162	.num_instances(num_instances)
	163	.num_classes(num_classes)
	164	.distinct_classes(distinct_labels)
	165	.actual_mtry(actual_mtry)
	166	.actual_msample(msample);
	167
	168	auto options = RandomForestOptions()
	169	.min_num_instances(min_num_instances)
	170	.bootstrap_sampling(bootstrap_sampling)
	171	.tree_count(tree_count);
	172	options.features_per_node_switch_ = mtry_switch;
	173	options.features_per_node_ = mtry;
	174	if (is_weighted)
	175	options.class_weights(class_weights);
	176
	177	Graph gr;
	178	typename RF::template NodeMap<SplitTest>::type split_tests;
	179	typename RF::template NodeMap<AccInputType>::type leaf_responses;
	180
	181	auto const groups = h5ctx.ls();
	182	for (auto const & groupname : groups) {
	183	if (groupname.substr(0, std::char_traits<char>::length(rf_hdf5_tree)).compare(rf_hdf5_tree) != 0) {
	184	continue;
	185	}
	186
	187	MultiArray<1, unsigned int> topology;
	188	MultiArray<1, double> parameters;
	189	h5ctx.cd(groupname);
	190	h5ctx.readAndResize(rf_hdf5_topology, topology);
	191	h5ctx.readAndResize(rf_hdf5_parameters, parameters);
	192	h5ctx.cd_up();
	193
	194	vigra_precondition(topology[0] == num_features, "random_forest_import_HDF5(): number of features mismatch.");
	195	vigra_precondition(topology[1] == num_classes, "random_forest_import_HDF5(): number of classes mismatch.");
	196
	197	Node const n = gr.addNode();
	198
	199	std::queue<std::pair<unsigned int, Node> > q;
	200	q.emplace(2, n);
	201	while (!q.empty()) {
	202	auto const el = q.front();
	203
	204	unsigned int const index = el.first;
	205	Node const parent = el.second;
	206
	207	vigra_precondition((topology[index] & rf_zero_mask) == 0, "random_forest_import_HDF5(): unexpected node type: type & zero_mask > 0");
	208
	209	if (topology[index] & rf_LeafNodeTag) {
	210	unsigned int const probs_start = topology[index+1] + 1;
	211
	212	vigra_precondition((topology[index] & rf_tag_mask) == rf_LeafNodeTag, "random_forest_import_HDF5(): unexpected node type: additional tags in leaf node");
	213
	214	std::vector<AccValueType> node_response;
	215
	216	for (unsigned int i = 0; i < num_classes; ++i) {
	217	node_response.push_back(parameters[probs_start + i]);
	218	}
	219
	220	leaf_responses.insert(parent, node_response);
	221
	222	} else {
	223	vigra_precondition(topology[index] == rf_i_ThresholdNode, "random_forest_import_HDF5(): unexpected node type.");
	224
	225	Node const left = gr.addNode();
	226	Node const right = gr.addNode();
	227
	228	gr.addArc(parent, left);
	229	gr.addArc(parent, right);
	230
	231	split_tests.insert(parent, SplitTest(topology[index+4], parameters[topology[index+1]+1]));
	232
	233	q.push(std::make_pair(topology[index+2], left));
	234	q.push(std::make_pair(topology[index+3], right));
	235	}
	236
	237	q.pop();
	238	}
	239	}
	240
	241	if (cwd.size()) {
	242	h5ctx.cd(cwd);
	243	}
	244
	245	RF rf(gr, split_tests, leaf_responses, pspec);
	246	rf.options_ = options;
	247	return rf;
	248	}
	249
	250	namespace detail
	251	{
	252	class PaddedNumberString
	253	{
	254	public:
	255
	256	PaddedNumberString(int n)
	257	{
	258	ss_ << (n-1);
	259	width_ = ss_.str().size();
	260	}
	261
	262	std::string operator()(int k) const
	263	{
	264	ss_.str("");
	265	ss_ << std::setw(width_) << std::setfill('0') << k;
	266	return ss_.str();
	267	}
	268
	269	private:
	270
	271	mutable std::ostringstream ss_;
	272	unsigned int width_;
	273	};
	274	}
	275
	276	template <typename RF>
	277	void random_forest_export_HDF5(
	278	RF const & rf,
	279	HDF5File & h5context,
	280	std::string const & pathname = ""
	281	){
	282	typedef typename RF::LabelType LabelType;
	283	typedef typename RF::Node Node;
	284
	285	std::string cwd;
	286	if (pathname.size()) {
	287	cwd = detail::get_cwd(h5context);
	288	h5context.cd_mk(pathname);
	289	}
	290
	291	// version attribute
	292	h5context.writeAttribute(rf_hdf5_version_group, rf_hdf5_version_tag,
	293	rf_hdf5_version);
	294
	295
	296	auto const & p = rf.problem_spec_;
	297	auto const & opts = rf.options_;
	298	MultiArray<1, LabelType> distinct_classes(Shape1(p.distinct_classes_.size()), p.distinct_classes_.data());
	299	MultiArray<1, double> class_weights(Shape1(p.num_classes_), 1.0);
	300	int is_weighted = 0;
	301	if (opts.class_weights_.size() > 0)
	302	{
	303	is_weighted = 1;
	304	for (size_t i = 0; i < opts.class_weights_.size(); ++i)
	305	class_weights(i) = opts.class_weights_[i];
	306	}
	307
	308	// Save external parameters.
	309	h5context.cd_mk(rf_hdf5_ext_param);
	310	h5context.write("column_count_", p.num_features_);
	311	h5context.write("row_count_", p.num_instances_);
	312	h5context.write("class_count_", p.num_classes_);
	313	h5context.write("actual_mtry_", p.actual_mtry_);
	314	h5context.write("actual_msample_", p.actual_msample_);
	315	h5context.write("labels", distinct_classes);
	316	h5context.write("is_weighted_", is_weighted);
	317	h5context.write("class_weights_", class_weights);
	318	h5context.write("precision_", 0.0);
	319	h5context.write("problem_type_", 1.0);
	320	h5context.write("response_size_", 1.0);
	321	h5context.write("used_", 1.0);
	322	h5context.cd_up();
	323
	324	// Save the options.
	325	h5context.cd_mk(rf_hdf5_options);
	326	h5context.write("min_split_node_size_", opts.min_num_instances_);
	327	h5context.write("mtry_", opts.features_per_node_);
	328	h5context.write("mtry_func_", 0.0);
	329	h5context.write("mtry_switch_", opts.features_per_node_switch_);
	330	h5context.write("predict_weighted_", 0.0);
	331	h5context.write("prepare_online_learning_", 0.0);
	332	h5context.write("sample_with_replacement_", opts.bootstrap_sampling_ ? 1 : 0);
	333	h5context.write("stratification_method_", 3.0);
	334	h5context.write("training_set_calc_switch_", 1.0);
	335	h5context.write("training_set_func_", 0.0);
	336	h5context.write("training_set_proportion_", 1.0);
	337	h5context.write("training_set_size_", 0.0);
	338	h5context.write("tree_count_", opts.tree_count_);
	339	h5context.cd_up();
	340
	341	// Save the trees.
	342	detail::PaddedNumberString tree_number(rf.num_trees());
	343	for (size_t i = 0; i < rf.num_trees(); ++i)
	344	{
	345	// Create the topology and parameters arrays.
	346	std::vector<UInt32> topology;
	347	std::vector<double> parameters;
	348	topology.push_back(p.num_features_);
	349	topology.push_back(p.num_classes_);
	350
	351	auto const & probs = rf.node_responses_;
	352	auto const & splits = rf.split_tests_;
	353	auto const & gr = rf.graph_;
	354	auto const root = gr.getRoot(i);
	355
	356	// Write the tree nodes using a depth-first search.
	357	// When a node is created, the indices of the child nodes are unknown.
	358	// Therefore, they have to be updated once the child nodes are created.
	359	// The stack holds the node and the topology-index that must be updated.
	360	std::stack<std::pair<Node, std::ptrdiff_t> > stack;
	361	stack.emplace(root, -1);
	362	while (!stack.empty())
	363	{
	364	auto const n = stack.top().first; // the node descriptor
	365	auto const i = stack.top().second; // index from the parent node that must be updated
	366	stack.pop();
	367
	368	// Update the index in the parent node.
	369	if (i != -1)
	370	topology[i] = topology.size();
	371
	372	if (gr.numChildren(n) == 0)
	373	{
	374	// The node is a leaf.
	375	// Topology: leaf node tag, index of weight in parameters array.
	376	// Parameters: node weight, class probabilities.
	377	topology.push_back(rf_LeafNodeTag);
	378	topology.push_back(parameters.size());
	379	auto const & prob = probs.at(n);
	380	auto const weight = std::accumulate(prob.begin(), prob.end(), 0.0);
	381	parameters.push_back(weight);
	382	parameters.insert(parameters.end(), prob.begin(), prob.end());
	383	}
	384	else
	385	{
	386	// The node is an inner node.
	387	// Topology: threshold tag, index of weight in parameters array, index of left child, index of right child, split dimension.
	388	// Parameters: node weight, split value.
	389	topology.push_back(rf_i_ThresholdNode);
	390	topology.push_back(parameters.size());
	391	topology.push_back(-1); // index of left children (currently unknown, will be updated when the child node is taken from the stack)
	392	topology.push_back(-1); // index of right children (see above)
	393	topology.push_back(splits.at(n).dim_);
	394	parameters.push_back(1.0); // inner nodes have the weight 1.
	395	parameters.push_back(splits.at(n).val_);
	396
	397	// Place the children on the stack.
	398	stack.emplace(gr.getChild(n, 0), topology.size()-3);
	399	stack.emplace(gr.getChild(n, 1), topology.size()-2);
	400	}
	401	}
	402
	403	// Convert the vectors to multi arrays.
	404	MultiArray<1, UInt32> topo(Shape1(topology.size()), topology.data());
	405	MultiArray<1, double> para(Shape1(parameters.size()), parameters.data());
	406
	407	auto const name = rf_hdf5_tree + tree_number(i);
	408	h5context.cd_mk(name);
	409	h5context.write(rf_hdf5_topology, topo);
	410	h5context.write(rf_hdf5_parameters, para);
	411	h5context.cd_up();
	412	}
	413
	414	if (pathname.size())
	415	h5context.cd(cwd);
	416	}
	417
	418
	419
	420	} // namespace rf3
	421	} // namespace vigra
	422
	423	#endif // VIGRA_NEW_RANDOM_FOREST_IMPEX_HDF5_HXX

+4

-4

include/vigra/resampling_convolution.hxx less more

874	874	This function implements the reduction by one resolution level (first signature)
875	875	or across several pyramid levels (last signature) of a Gaussian pyramid as described in
876	876
877		P. Burt, E. Adelson: <i>"The Laplacian Pyramid as a Compact Image Code"</i>, IEEE Trans. Communications, 9(4):532–540, 1983
	877	P. Burt, E. Adelson: <i>"The Laplacian Pyramid as a Compact Image Code"</i>, IEEE Trans. Communications, 9(4):532-540, 1983
878	878
879	879	That is, it applies the smoothing filter
880	880	\code

1025	1025	This function implements the expansion by one resolution level (first signature)
1026	1026	or across several pyramid levels (last signature) of a Gaussian pyramid as described in
1027	1027
1028		P. Burt, E. Adelson: <i>"The Laplacian Pyramid as a Compact Image Code"</i>, IEEE Trans. Communications, 9(4):532–540, 1983
	1028	P. Burt, E. Adelson: <i>"The Laplacian Pyramid as a Compact Image Code"</i>, IEEE Trans. Communications, 9(4):532-540, 1983
1029	1029
1030	1030	That is, the function first places the pixel values of the low-resolution
1031	1031	image at the even pixel coordinates of the high-resolution image (pixels with

1180	1180	This function implements the reduction across several resolution levels of
1181	1181	a Laplacian pyramid as described in
1182	1182
1183		P. Burt, E. Adelson: <i>"The Laplacian Pyramid as a Compact Image Code"</i>, IEEE Trans. Communications, 9(4):532–540, 1983
	1183	P. Burt, E. Adelson: <i>"The Laplacian Pyramid as a Compact Image Code"</i>, IEEE Trans. Communications, 9(4):532-540, 1983
1184	1184
1185	1185	It first creates a Gaussian pyramid using \ref pyramidReduceBurtFilter(), then
1186	1186	upsamples each level once using \ref pyramidExpandBurtFilter(), and finally

1214	1214	This function implements the reconstruction of a Gaussian pyramid
1215	1215	across several resolution levels of a Laplacian pyramid as described in
1216	1216
1217		P. Burt, E. Adelson: <i>"The Laplacian Pyramid as a Compact Image Code"</i>, IEEE Trans. Communications, 9(4):532–540, 1983
	1217	P. Burt, E. Adelson: <i>"The Laplacian Pyramid as a Compact Image Code"</i>, IEEE Trans. Communications, 9(4):532-540, 1983
1218	1218
1219	1219	At each level starting from <tt>fromLevel</tt>, this function calls
1220	1220	\ref pyramidExpandBurtFilter() to interpolate the image to the next highest

+11

-23

include/vigra/resizeimage.hxx less more

132	132	{
133	133	return prefilterCoefficients_;
134	134	}
135
	135
136	136	protected:
137	137	static ArrayVector<double> prefilterCoefficients_;
138	138	unsigned int m_;

144	144
145	145
146	146
147		/** \addtogroup GeometricTransformations Geometric Transformations
148		Zoom up and down by repeating pixels, or using various interpolation schemes.
149
150		See also:
151		<ul>
152		<li> \ref ResamplingConvolutionFilters to resize by means of pyramids or smoothing filters</li>
153		<li> \ref resampleImage() to just drop or repeat pixels</li>
154		<li> \ref resizeMultiArraySplineInterpolation() for multi-dimensional interpolation</li>
155		</ul>
156
157		<b>\#include</b> \<vigra/stdimagefunctions.hxx\><br>
158		<b>or</b><br>
159		<b>\#include</b> \<vigra/resizeimage.hxx\><br>
	147	/** \addtogroup GeometricTransformations
160	148	*/
161	149	//@{
162	150

180	168	ad.set(as(i1), id);
181	169	return;
182	170	}
183
	171
184	172	double dx = (double)(wold - 1) / (wnew - 1);
185	173	double x = 0.5;
186	174	for(; id != idend; ++id, x += dx)

252	240	\code
253	241	MultiArray<2, unsigned char> src(w, h);
254	242	MultiArray<2, float> dest(w_new, h_new);
255
	243
256	244	resizeImageNoInterpolation(src, dest);
257	245	\endcode
258	246

457	445	\code
458	446	MultiArray<2, unsigned char> src(w, h);
459	447	MultiArray<2, float> dest(w_new, h_new);
460
	448
461	449	resizeImageLinearInterpolation(src, dest);
462	450	\endcode
463	451

680	668	\code
681	669	MultiArray<2, unsigned char> src(w, h);
682	670	MultiArray<2, float> dest(w_new, h_new);
683
	671
684	672	// use default cubic spline interpolator
685	673	resizeImageSplineInterpolation(src, dest);
686
	674
687	675	// use 5th-order spline interpolator
688	676	resizeImageSplineInterpolation(src, dest, BSpline<5, double>());
689	677	\endcode

980	968
981	969	<b>\#include</b> \<vigra/resizeimage.hxx\><br>
982	970	Namespace: vigra
983
	971
984	972	\code
985	973	MultiArray<2, unsigned char> src(w, h);
986	974	MultiArray<2, float> dest(w_new, h_new);
987
	975
988	976	resizeImageCatmullRomInterpolation(src, dest);
989	977	\endcode
990	978	*/

1072	1060
1073	1061	<b>\#include</b> \<vigra/resizeimage.hxx\><br>
1074	1062	Namespace: vigra
1075
	1063
1076	1064	\code
1077	1065	MultiArray<2, unsigned char> src(w, h);
1078	1066	MultiArray<2, float> dest(w_new, h_new);
1079
	1067
1080	1068	resizeImageCoscotInterpolation(src, dest);
1081	1069	\endcode
1082	1070	*/

+60

-63

include/vigra/sampling.hxx less more

44	44	namespace vigra
45	45	{
46	46
47		/** \addtogroup MachineLearning Machine Learning
48		**/
49		//@{
50
51
52	47	/**\brief Options object for the Sampler class.
53
54		<b>usage:</b>
55
	48
	49	\ingroup MachineLearning
	50
	51	<b>Usage:</b>
	52
56	53	\code
57	54	SamplerOptions opt = SamplerOptions()
58	55	.withReplacement()
59	56	.sampleProportion(0.5);
60	57	\endcode
61
	58
62	59	Note that the return value of all methods is <tt>*this</tt> which makes
63	60	concatenating of options as above possible.
64	61	*/

70	67	unsigned int sample_size;
71	68	bool sample_with_replacement;
72	69	bool stratified_sampling;
73
	70
74	71	SamplerOptions()
75	72	: sample_proportion(1.0),
76		sample_size(0),
	73	sample_size(0),
77	74	sample_with_replacement(true),
78	75	stratified_sampling(false)
79	76	{}

100	97
101	98	/**\brief Draw the given number of samples.
102	99	* If stratifiedSampling is true, the \a size is equally distributed
103		* across all strata (e.g. <tt>size / strataCount</tt> samples are taken
	100	* across all strata (e.g. <tt>size / strataCount</tt> samples are taken
104	101	* from each stratum, subject to rounding).
105	102	*
106	103	* <br> Default: 0 (i.e. determine the count by means of sampleProportion())

113	110
114	111
115	112	/**\brief Determine the number of samples to draw as a proportion of the total
116		* number. That is, we draw <tt>count = totalCount * proportion</tt> samples.
	113	* number. That is, we draw <tt>count = totalCount * proportion</tt> samples.
117	114	* This option is overridden when an absolute count is specified by sampleSize().
118		*
	115	*
119	116	* If stratifiedSampling is true, the count is equally distributed
120		* across all strata (e.g. <tt>totalCount * proportion / strataCount</tt> samples are taken
	117	* across all strata (e.g. <tt>totalCount * proportion / strataCount</tt> samples are taken
121	118	* from each stratum).
122	119	*
123	120	* <br> Default: 1.0

130	127	return *this;
131	128	}
132	129
133		/**\brief Draw equally many samples from each "stratum".
134		* A stratum is a group of like entities, e.g. pixels belonging
135		* to the same object class. This is useful to create balanced samples
	130	/**\brief Draw equally many samples from each "stratum".
	131	* A stratum is a group of like entities, e.g. pixels belonging
	132	* to the same object class. This is useful to create balanced samples
136	133	* when the class probabilities are very unbalanced (e.g.
137	134	* when there are many background and few foreground pixels).
138		* Stratified sampling thus avoids that a trained classifier is biased
139		* towards the majority class.
	135	* Stratified sampling thus avoids that a trained classifier is biased
	136	* towards the majority class.
140	137	*
141	138	* <br> Default (if you don't call this function): false
142	139	*/

155	152
156	153	/** \brief Create random samples from a sequence of indices.
157	154
	155	\ingroup MachineLearning
	156
158	157	Selecting data items at random is a basic task of machine learning,
159	158	for example in boostrapping, RandomForest training, and cross validation.
160		This class implements various ways to select random samples via their indices.
	159	This class implements various ways to select random samples via their indices.
161	160	Indices are assumed to be consecutive in
162	161	the range <tt>0 <= index < total_sample_count</tt>.
163
164		The class always contains a current sample which can be accessed by
	162
	163	The class always contains a current sample which can be accessed by
165	164	the index operator or by the function sampledIndices(). The indices
166	165	that are not in the current sample (out-of-bag indices) can be accessed
167	166	via the function oobIndices().
168
	167
169	168	The sampling method (with/without replacement, stratified or not) and the
170		number of samples to draw are determined by the option object
	169	number of samples to draw are determined by the option object
171	170	SamplerOptions.
172
	171
173	172	<b>Usage:</b>
174
	173
175	174	<b>\#include</b> \<vigra/sampling.hxx\><br>
176	175	Namespace: vigra
177
178		Create a Sampler with default options, i.e. sample as many indices as there
179		are data elements, with replacement. On average, the sample will contain
	176
	177	Create a Sampler with default options, i.e. sample as many indices as there
	178	are data elements, with replacement. On average, the sample will contain
180	179	<tt>0.63*totalCount</tt> distinct indices.
181
	180
182	181	\code
183	182	int totalCount = 10000; // total number of data elements
184		int numberOfSamples = 20; // repeat experiment 20 times
	183	int numberOfSamples = 20; // repeat experiment 20 times
185	184	Sampler<> sampler(totalCount);
186	185	for(int k=0; k<numberOfSamples; ++k)
187	186	{

195	194	sampler.sample();
196	195	}
197	196	\endcode
198
	197
199	198	Create a Sampler for stratified sampling, without replacement.
200
	199
201	200	\code
202	201	// prepare the strata (i.e. specify which stratum each element belongs to)
203	202	int stratumSize1 = 2000, stratumSize2 = 8000,

207	206	strata[i] = 1;
208	207	for(int i=stratumSize1; i<stratumSize2; ++i)
209	208	strata[i] = 2;
210
	209
211	210	int sampleSize = 200; // i.e. sample 100 elements from each of the two strata
212		int numberOfSamples = 20; // repeat experiment 20 times
	211	int numberOfSamples = 20; // repeat experiment 20 times
213	212	Sampler<> stratifiedSampler(strata.begin(), strata.end(),
214	213	SamplerOptions().withoutReplacement().stratified().sampleSize(sampleSize));
215	214	// create first sample

237	236	requires extension of the random number generator classes.
238	237	*/
239	238	typedef Int32 IndexType;
240
	239
241	240	typedef ArrayVector<IndexType> IndexArrayType;
242
243		/** Type of the array view object that is returned by
	241
	242	/** Type of the array view object that is returned by
244	243	sampledIndices() and oobIndices().
245	244	*/
246	245	typedef ArrayVectorView <IndexType> IndexArrayViewType;

250	249	typedef std::map<IndexType, int> StrataSizesType;
251	250	typedef ArrayVector<bool> IsUsedArrayType;
252	251	typedef ArrayVectorView<bool> IsUsedArrayViewType;
253
	252
254	253	static const int oobInvalid = -1;
255	254
256	255	int total_count_, sample_size_;

271	270	int strata_sample_size = static_cast<int>(std::ceil(double(sample_size_) / strataCount()));
272	271	int strata_total_count = strata_sample_size * strataCount();
273	272
274		for(StrataIndicesType::iterator i = strata_indices_.begin();
	273	for(StrataIndicesType::iterator i = strata_indices_.begin();
275	274	i != strata_indices_.end(); ++i)
276	275	{
277	276	if(strata_total_count > sample_size_)

287	286	}
288	287
289	288	public:
290
	289
291	290	/** Create a sampler for \a totalCount data objects.
292
	291
293	292	In each invocation of <tt>sample()</tt> below, it will sample
294		indices according to the options passed. If no options are given,
	293	indices according to the options passed. If no options are given,
295	294	<tt>totalCount</tt> indices will be drawn with replacement.
296	295	*/
297		Sampler(UInt32 totalCount, SamplerOptions const & opt = SamplerOptions(),
	296	Sampler(UInt32 totalCount, SamplerOptions const & opt = SamplerOptions(),
298	297	Random const * rnd = 0)
299	298	: total_count_(totalCount),
300	299	sample_size_(opt.sample_size == 0

310	309	{
311	310	vigra_precondition(opt.sample_with_replacement \|\| sample_size_ <= total_count_,
312	311	"Sampler(): Cannot draw without replacement when data size is smaller than sample count.");
313
	312
314	313	vigra_precondition(!opt.stratified_sampling,
315	314	"Sampler(): Stratified sampling requested, but no strata given.");
316
	315
317	316	// initialize a single stratum containing all data
318	317	strata_indices_[0].resize(total_count_);
319	318	for(int i=0; i<total_count_; ++i)

323	322	//this is screwing up the random forest tests.
324	323	//sample();
325	324	}
326
	325
327	326	/** Create a sampler for stratified sampling.
328
329		<tt>strataBegin</tt> and <tt>strataEnd</tt> must refer to a sequence
	327
	328	<tt>strataBegin</tt> and <tt>strataEnd</tt> must refer to a sequence
330	329	which specifies for each sample the stratum it belongs to. The
331	330	total number of data objects will be set to <tt>strataEnd - strataBegin</tt>.
332		Equally many samples (subject to rounding) will be drawn from each stratum,
333		unless the option object explicitly requests unstratified sampling,
	331	Equally many samples (subject to rounding) will be drawn from each stratum,
	332	unless the option object explicitly requests unstratified sampling,
334	333	in which case the strata are ignored.
335	334	*/
336	335	template <class Iterator>
337		Sampler(Iterator strataBegin, Iterator strataEnd, SamplerOptions const & opt = SamplerOptions(),
	336	Sampler(Iterator strataBegin, Iterator strataEnd, SamplerOptions const & opt = SamplerOptions(),
338	337	Random const * rnd = 0)
339	338	: total_count_(strataEnd - strataBegin),
340	339	sample_size_(opt.sample_size == 0

350	349	{
351	350	vigra_precondition(opt.sample_with_replacement \|\| sample_size_ <= total_count_,
352	351	"Sampler(): Cannot draw without replacement when data size is smaller than sample count.");
353
	352
354	353	// copy the strata indices
355	354	if(opt.stratified_sampling)
356	355	{

365	364	for(int i=0; i<total_count_; ++i)
366	365	strata_indices_[0][i] = i;
367	366	}
368
	367
369	368	vigra_precondition(sample_size_ >= static_cast<int>(strata_indices_.size()),
370	369	"Sampler(): Requested sample count must be at least as large as the number of strata.");
371	370

422	421	{
423	422	return options_.stratified_sampling;
424	423	}
425
	424
426	425	/** Whether sampling should be performed with replacement.
427	426	*/
428	427	bool withReplacement() const
429	428	{
430	429	return options_.sample_with_replacement;
431	430	}
432
	431
433	432	/** Return an array view containing the indices in the current sample.
434	433	*/
435	434	IndexArrayViewType sampledIndices() const
436	435	{
437	436	return current_sample_;
438	437	}
439
	438
440	439	/** Return an array view containing the out-of-bag indices.
441	440	(i.e. the indices that are not in the current sample)
442	441	*/

468	467	{
469	468	current_oob_count_ = oobInvalid;
470	469	is_used_.init(false);
471
	470
472	471	if(options_.sample_with_replacement)
473	472	{
474	473	//Go thru all strata

515	514	double lambda;
516	515	int minIndex;
517	516	int maxIndex;
518
	517
519	518	PoissonSampler(double lambda,IndexType minIndex,IndexType maxIndex)
520	519	: lambda(lambda),
521	520	minIndex(minIndex),

552	551	{
553	552	return used_indices_[in];
554	553	}
555
	554
556	555	int numOfSamples() const
557	556	{
558	557	return used_indices_.size();
559	558	}
560	559	};
561	560
562		//@}
563
564	561	} // namespace vigra
565	562
566	563	#endif /VIGRA_SAMPLING_HXX/

+44

-45

include/vigra/seededregiongrowing.hxx less more

161	161
162	162	} // namespace detail
163	163
164		/** \addtogroup SeededRegionGrowing Region Segmentation Algorithms
165		Region growing, watersheds, and voronoi tesselation
	164	/** \addtogroup Superpixels
166	165	*/
167	166	//@{
168	167

173	172	/********************************************************/
174	173
175	174	/** Choose between different types of Region Growing */
176		enum SRGType {
177		CompleteGrow = 0,
178		KeepContours = 1,
179		StopAtThreshold = 2,
180		SRGWatershedLabel = -1
	175	enum SRGType {
	176	CompleteGrow = 0,
	177	KeepContours = 1,
	178	StopAtThreshold = 2,
	179	SRGWatershedLabel = -1
181	180	};
182	181
183	182	/** \brief Region Segmentation by means of Seeded Region Growing.

196	195	The seed image is a partly segmented image which contains uniquely
197	196	labeled regions (the seeds) and unlabeled pixels (the candidates, label 0).
198	197	The highest seed label found in the seed image is returned by the algorithm.
199
	198
200	199	Seed regions can be as large as you wish and as small as one pixel. If
201	200	there are no candidates, the algorithm will simply copy the seed image
202	201	into the output image. Otherwise it will aggregate the candidates into
203		the existing regions so that a cost function is minimized.
204		Candidates are taken from the neighborhood of the already assigned pixels,
	202	the existing regions so that a cost function is minimized.
	203	Candidates are taken from the neighborhood of the already assigned pixels,
205	204	where the type of neighborhood is determined by parameter <tt>neighborhood</tt>
206		which can take the values <tt>FourNeighborCode()</tt> (the default)
207		or <tt>EightNeighborCode()</tt>. The algorithm basically works as follows
	205	which can take the values <tt>FourNeighborCode()</tt> (the default)
	206	or <tt>EightNeighborCode()</tt>. The algorithm basically works as follows
208	207	(illustrated for 4-neighborhood, but 8-neighborhood works in the same way):
209	208
210	209	<ol>

228	227	</ol>
229	228
230	229	<tt>SRGType</tt> can take the following values:
231
	230
232	231	<DL>
233	232	<DT><tt>CompleteGrow</tt> <DD> produce a complete tesselation of the volume (default).
234	233	<DT><tt>KeepContours</tt> <DD> keep a 1-voxel wide unlabeled contour between all regions.
235		<DT><tt>StopAtThreshold</tt> <DD> stop when the boundary indicator values exceed the
	234	<DT><tt>StopAtThreshold</tt> <DD> stop when the boundary indicator values exceed the
236	235	threshold given by parameter <tt>max_cost</tt>.
237	236	<DT><tt>KeepContours \| StopAtThreshold</tt> <DD> keep 1-voxel wide contour and stop at given <tt>max_cost</tt>.
238	237	</DL>

258	257	the original statistics.
259	258
260	259	If a candidate could be merged into more than one regions with identical
261		cost, the algorithm will favour the nearest region. If <tt>StopAtThreshold</tt> is active,
262		and the cost of the current candidate at any point in the algorithm exceeds the optional
263		<tt>max_cost</tt> value (which defaults to <tt>NumericTraits<double>::max()</tt>),
	260	cost, the algorithm will favour the nearest region. If <tt>StopAtThreshold</tt> is active,
	261	and the cost of the current candidate at any point in the algorithm exceeds the optional
	262	<tt>max_cost</tt> value (which defaults to <tt>NumericTraits<double>::max()</tt>),
264	263	region growing is aborted, and all voxels not yet assigned to a region remain unlabeled.
265	264
266	265	In some cases, the cost only depends on the feature value of the current

283	282	MultiArrayView<2, TS, AS> const & seeds,
284	283	MultiArrayView<2, T2, S2> labels,
285	284	RegionStatisticsArray & stats,
286		SRGType srgType = CompleteGrow,
	285	SRGType srgType = CompleteGrow,
287	286	Neighborhood n = FourNeighborCode(),
288	287	double max_cost = NumericTraits<double>::max());
289	288	}

297	296	class SeedImageIterator, class SeedAccessor,
298	297	class DestIterator, class DestAccessor,
299	298	class RegionStatisticsArray, class Neighborhood>
300		typename SeedAccessor::value_type
	299	typename SeedAccessor::value_type
301	300	seededRegionGrowing(SrcIterator srcul, SrcIterator srclr, SrcAccessor as,
302	301	SeedImageIterator seedsul, SeedAccessor aseeds,
303	302	DestIterator destul, DestAccessor ad,

349	348	// init statistics functor
350	349	ArrayOfRegionStatistics<SeedRgDirectValueFunctor<float> > stats(max_region_label);
351	350
352		// find voronoi region of each point (the point image is overwritten with the
	351	// find voronoi region of each point (the point image is overwritten with the
353	352	// voronoi region labels)
354	353	seededRegionGrowing(dist, points, points, stats);
355	354	\endcode

453	452
454	453	SeedRgPixelHeap pheap;
455	454	int cneighbor, maxRegionLabel = 0;
456
	455
457	456	typedef typename Neighborhood::Direction Direction;
458	457	int directionCount = Neighborhood::DirectionCount;
459
	458
460	459	Point2D pos(0,0);
461	460	for(isy=srcul, iry=ir, pos.y=0; pos.y<h;
462	461	++pos.y, ++isy.y, ++iry.y)

490	489	}
491	490	}
492	491	}
493
	492
494	493	// perform region growing
495	494	while(pheap.size() != 0)
496	495	{

548	547	}
549	548	}
550	549	}
551
	550
552	551	// free temporary memory
553	552	while(pheap.size() != 0)
554	553	{

628	627	pair<SeedImageIterator, SeedAccessor> img3,
629	628	pair<DestIterator, DestAccessor> img4,
630	629	RegionStatisticsArray & stats,
631		SRGType srgType,
	630	SRGType srgType,
632	631	Neighborhood n,
633	632	double max_cost = NumericTraits<double>::max())
634	633	{

680	679	MultiArrayView<2, TS, AS> const & img3,
681	680	MultiArrayView<2, T2, S2> img4,
682	681	RegionStatisticsArray & stats,
683		SRGType srgType,
	682	SRGType srgType,
684	683	Neighborhood n,
685	684	double max_cost = NumericTraits<double>::max())
686	685	{

738	737	template <class SrcIterator, class SrcAccessor,
739	738	class DestIterator, class DestAccessor,
740	739	class RegionStatisticsArray, class Neighborhood>
741		typename DestAccessor::value_type
	740	typename DestAccessor::value_type
742	741	fastSeededRegionGrowing(SrcIterator srcul, SrcIterator srclr, SrcAccessor as,
743	742	DestIterator destul, DestAccessor ad,
744	743	RegionStatisticsArray & stats,

751	750
752	751	vigra_precondition((srgType & KeepContours) == 0,
753	752	"fastSeededRegionGrowing(): the turbo algorithm doesn't support 'KeepContours', sorry.");
754
	753
755	754	int w = srclr.x - srcul.x;
756	755	int h = srclr.y - srcul.y;
757	756

760	759
761	760	BucketQueue<Point2D, true> pqueue(bucket_count);
762	761	LabelType maxRegionLabel = 0;
763
	762
764	763	Point2D pos(0,0);
765	764	for(isy=srcul, idy = destul, pos.y=0; pos.y<h; ++pos.y, ++isy.y, ++idy.y)
766	765	{

774	773
775	774	if(maxRegionLabel < label)
776	775	maxRegionLabel = label;
777
	776
778	777	AtImageBorder atBorder = isAtImageBorder(pos.x, pos.y, w, h);
779	778	if(atBorder == NotAtBorder)
780	779	{

792	791	}
793	792	else
794	793	{
795		RestrictedNeighborhoodCirculator<DestIterator, Neighborhood>
	794	RestrictedNeighborhoodCirculator<DestIterator, Neighborhood>
796	795	c(idx, atBorder), cend(c);
797	796	do
798	797	{

808	807	}
809	808	}
810	809	}
811
	810
812	811	// perform region growing
813	812	while(!pqueue.empty())
814	813	{
815	814	Point2D pos = pqueue.top();
816	815	std::ptrdiff_t cost = pqueue.topPriority();
817	816	pqueue.pop();
818
	817
819	818	if((srgType & StopAtThreshold) != 0 && cost > max_cost)
820	819	break;
821	820
822	821	idx = destul + pos;
823	822	isx = srcul + pos;
824
	823
825	824	std::ptrdiff_t label = ad(idx);
826	825
827	826	AtImageBorder atBorder = isAtImageBorder(pos.x, pos.y, w, h);
828	827	if(atBorder == NotAtBorder)
829	828	{
830	829	NeighborhoodCirculator<DestIterator, Neighborhood> c(idx), cend(c);
831
	830
832	831	do
833	832	{
834	833	std::ptrdiff_t nlabel = ad(c);
835	834	if(nlabel == 0)
836	835	{
837	836	ad.set(label, idx, c.diff());
838		std::ptrdiff_t priority =
	837	std::ptrdiff_t priority =
839	838	std::max((std::ptrdiff_t)stats[label].cost(as(isx, c.diff())), cost);
840	839	pqueue.push(pos+c.diff(), priority);
841	840	}

844	843	}
845	844	else
846	845	{
847		RestrictedNeighborhoodCirculator<DestIterator, Neighborhood>
	846	RestrictedNeighborhoodCirculator<DestIterator, Neighborhood>
848	847	c(idx, atBorder), cend(c);
849	848	do
850	849	{

852	851	if(nlabel == 0)
853	852	{
854	853	ad.set(label, idx, c.diff());
855		std::ptrdiff_t priority =
	854	std::ptrdiff_t priority =
856	855	std::max((std::ptrdiff_t)stats[label].cost(as(isx, c.diff())), cost);
857	856	pqueue.push(pos+c.diff(), priority);
858	857	}

860	859	while(++c != cend);
861	860	}
862	861	}
863
	862
864	863	return maxRegionLabel;
865	864	}
866	865
867	866	template <class SrcIterator, class SrcAccessor,
868	867	class DestIterator, class DestAccessor,
869	868	class RegionStatisticsArray, class Neighborhood>
870		inline typename DestAccessor::value_type
	869	inline typename DestAccessor::value_type
871	870	fastSeededRegionGrowing(SrcIterator srcul, SrcIterator srclr, SrcAccessor as,
872	871	DestIterator destul, DestAccessor ad,
873	872	RegionStatisticsArray & stats,

882	881	template <class SrcIterator, class SrcAccessor,
883	882	class DestIterator, class DestAccessor,
884	883	class RegionStatisticsArray>
885		inline typename DestAccessor::value_type
	884	inline typename DestAccessor::value_type
886	885	fastSeededRegionGrowing(SrcIterator srcul, SrcIterator srclr, SrcAccessor as,
887	886	DestIterator destul, DestAccessor ad,
888	887	RegionStatisticsArray & stats,

896	895	template <class SrcIterator, class SrcAccessor,
897	896	class DestIterator, class DestAccessor,
898	897	class RegionStatisticsArray>
899		inline typename DestAccessor::value_type
	898	inline typename DestAccessor::value_type
900	899	fastSeededRegionGrowing(SrcIterator srcul, SrcIterator srclr, SrcAccessor as,
901	900	DestIterator destul, DestAccessor ad,
902	901	RegionStatisticsArray & stats)

909	908	template <class SrcIterator, class SrcAccessor,
910	909	class DestIterator, class DestAccessor,
911	910	class RegionStatisticsArray, class Neighborhood>
912		inline typename DestAccessor::value_type
	911	inline typename DestAccessor::value_type
913	912	fastSeededRegionGrowing(triple<SrcIterator, SrcIterator, SrcAccessor> src,
914	913	pair<DestIterator, DestAccessor> dest,
915	914	RegionStatisticsArray & stats,
916		SRGType srgType,
	915	SRGType srgType,
917	916	Neighborhood n,
918	917	double max_cost,
919	918	std::ptrdiff_t bucket_count = 256)

930	929	fastSeededRegionGrowing(MultiArrayView<2, T1, S1> const & src,
931	930	MultiArrayView<2, T2, S2> dest,
932	931	RegionStatisticsArray & stats,
933		SRGType srgType,
	932	SRGType srgType,
934	933	Neighborhood n,
935	934	double max_cost,
936	935	std::ptrdiff_t bucket_count = 256)

+33

-33

include/vigra/seededregiongrowing3d.hxx less more

162	162
163	163	} // namespace detail
164	164
165		/** \addtogroup SeededRegionGrowing
	165	/** \addtogroup Superpixels
166	166	*/
167	167	//@{
168	168

182	182	there are no candidates, the algorithm will simply copy the seed array
183	183	into the output array. Otherwise it will aggregate the candidates into
184	184	the existing regions so that a cost function is minimized.
185		Candidates are taken from the neighborhood of the already assigned pixels,
	185	Candidates are taken from the neighborhood of the already assigned pixels,
186	186	where the type of neighborhood is determined by parameter <tt>neighborhood</tt>
187		which can take the values <tt>NeighborCode3DSix()</tt> (the default)
188		or <tt>NeighborCode3DTwentySix()</tt>. The algorithm basically works as follows
	187	which can take the values <tt>NeighborCode3DSix()</tt> (the default)
	188	or <tt>NeighborCode3DTwentySix()</tt>. The algorithm basically works as follows
189	189	(illustrated for 6-neighborhood, but 26-neighborhood works in the same way):
190	190
191	191	<ol>

209	209	</ol>
210	210
211	211	<tt>SRGType</tt> can take the following values:
212
	212
213	213	<DL>
214	214	<DT><tt>CompleteGrow</tt> <DD> produce a complete tesselation of the volume (default).
215	215	<DT><tt>KeepContours</tt> <DD> keep a 1-voxel wide unlabeled contour between all regions.
216		<DT><tt>StopAtThreshold</tt> <DD> stop when the boundary indicator values exceed the
	216	<DT><tt>StopAtThreshold</tt> <DD> stop when the boundary indicator values exceed the
217	217	threshold given by parameter <tt>max_cost</tt>.
218	218	<DT><tt>KeepContours \| StopAtThreshold</tt> <DD> keep 1-voxel wide contour and stop at given <tt>max_cost</tt>.
219	219	</DL>

238	238	the original statistics.
239	239
240	240	If a candidate could be merged into more than one regions with identical
241		cost, the algorithm will favour the nearest region. If <tt>StopAtThreshold</tt> is active,
242		and the cost of the current candidate at any point in the algorithm exceeds the optional
243		<tt>max_cost</tt> value (which defaults to <tt>NumericTraits<double>::max()</tt>),
	241	cost, the algorithm will favour the nearest region. If <tt>StopAtThreshold</tt> is active,
	242	and the cost of the current candidate at any point in the algorithm exceeds the optional
	243	<tt>max_cost</tt> value (which defaults to <tt>NumericTraits<double>::max()</tt>),
244	244	region growing is aborted, and all voxels not yet assigned to a region remain unlabeled.
245	245
246	246	In some cases, the cost only depends on the feature value of the current

261	261	seededRegionGrowing3D(MultiArrayView<3, T1, S1> const & src,
262	262	MultiArrayView<3, TS, AS> const & seeds,
263	263	MultiArrayView<3, T2, S2> labels,
264		RegionStatisticsArray & stats,
	264	RegionStatisticsArray & stats,
265	265	SRGType srgType = CompleteGrow,
266	266	Neighborhood neighborhood = NeighborCode3DSix(),
267	267	double max_cost = NumericTraits<double>::max());

276	276	class SeedImageIterator, class SeedAccessor,
277	277	class DestImageIterator, class DestAccessor,
278	278	class RegionStatisticsArray, class Neighborhood>
279		void
	279	void
280	280	seededRegionGrowing3D(SrcImageIterator srcul, Shape shape, SrcAccessor as,
281	281	SeedImageIterator seedsul, SeedAccessor aseeds,
282	282	DestImageIterator destul, DestAccessor ad,
283		RegionStatisticsArray & stats,
	283	RegionStatisticsArray & stats,
284	284	SRGType srgType = CompleteGrow,
285	285	Neighborhood neighborhood = NeighborCode3DSix(),
286	286	double max_cost = NumericTraits<double>::max());

297	297	seededRegionGrowing3D(triple<SrcImageIterator, Shape, SrcAccessor> src,
298	298	pair<SeedImageIterator, SeedAccessor> seeds,
299	299	pair<DestImageIterator, DestAccessor> dest,
300		RegionStatisticsArray & stats,
	300	RegionStatisticsArray & stats,
301	301	SRGType srgType = CompleteGrow,
302		Neighborhood neighborhood = NeighborCode3DSix(),
	302	Neighborhood neighborhood = NeighborCode3DSix(),
303	303	double max_cost = NumericTraits<double>::max());
304	304	}
305	305	\endcode
306	306	\deprecatedEnd
307	307
308	308	<b> Usage:</b>
309
	309
310	310	<b>\#include</b> \<vigra/seededregiongrowing3d.hxx\><br>
311	311	Namespace: vigra
312
	312
313	313	See \ref seededRegionGrowing() for an example
314	314	*/
315	315	doxygen_overloaded_function(template <...> void seededRegionGrowing3D)

318	318	class SeedImageIterator, class SeedAccessor,
319	319	class DestImageIterator, class DestAccessor,
320	320	class RegionStatisticsArray, class Neighborhood>
321		void
	321	void
322	322	seededRegionGrowing3D(SrcImageIterator srcul, Diff_type shape, SrcAccessor as,
323	323	SeedImageIterator seedsul, SeedAccessor aseeds,
324	324	DestImageIterator destul, DestAccessor ad,
325		RegionStatisticsArray & stats,
	325	RegionStatisticsArray & stats,
326	326	SRGType srgType,
327	327	Neighborhood,
328	328	double max_cost)

355	355	IVolume regions(regionshape);
356	356	Traverser ir = regions.traverser_begin();
357	357	ir = ir + Diff_type(1,1,1);
358
	358
359	359	//IVolume::Iterator iry, irx, irz;
360	360	Traverser iry, irx, irz;
361	361
362	362	//initImageBorder(destImageRange(regions), 1, SRGWatershedLabel);
363		initMultiArrayBorder(destMultiArrayRange(regions), 1, SRGWatershedLabel);
364
	363	initMultiArrayBorder(destMultiArrayRange(regions), 1, SRGWatershedLabel);
	364
365	365	copyMultiArray(seedsul, Diff_type(w,h,d), aseeds, ir, AccessorTraits<int>::default_accessor());
366	366
367	367	// allocate and init memory for the results

383	383	pos[1]++, isy.dim1()++, iry.dim1()++)
384	384	{
385	385	//std::cerr << "Y = " << pos[1] << std::endl;
386
	386
387	387	for(isx=isy, irx=iry, pos[0]=0; pos[0]<w;
388	388	pos[0]++, isx.dim0()++, irx.dim0()++)
389	389	{
390	390	//std::cerr << "X = " << pos[0] << std::endl;
391
	391
392	392	if(*irx == 0)
393	393	{
394	394	// find candidate pixels for growing and fill heap

408	408	}
409	409	}
410	410	}
411
	411
412	412	// perform region growing
413	413	while(pheap.size() != 0)
414	414	{

466	466	}
467	467	}
468	468	}
469
	469
470	470	// free temporary memory
471	471	while(pheap.size() != 0)
472	472	{

475	475	}
476	476
477	477	// write result
478		transformMultiArray(ir, Diff_type(w,h,d), AccessorTraits<int>::default_accessor(),
	478	transformMultiArray(ir, Diff_type(w,h,d), AccessorTraits<int>::default_accessor(),
479	479	destul, ad, detail::UnlabelWatersheds());
480	480	}
481	481

489	489	DestImageIterator destul, DestAccessor ad,
490	490	RegionStatisticsArray & stats, SRGType srgType, Neighborhood n)
491	491	{
492		seededRegionGrowing3D( srcul, shape, as, seedsul, aseeds,
	492	seededRegionGrowing3D( srcul, shape, as, seedsul, aseeds,
493	493	destul, ad, stats, srgType, n, NumericTraits<double>::max());
494	494	}
495	495

503	503	DestImageIterator destul, DestAccessor ad,
504	504	RegionStatisticsArray & stats, SRGType srgType)
505	505	{
506		seededRegionGrowing3D( srcul, shape, as, seedsul, aseeds,
	506	seededRegionGrowing3D( srcul, shape, as, seedsul, aseeds,
507	507	destul, ad, stats, srgType, NeighborCode3DSix());
508	508	}
509	509

517	517	DestImageIterator destul, DestAccessor ad,
518	518	RegionStatisticsArray & stats)
519	519	{
520		seededRegionGrowing3D( srcul, shape, as, seedsul, aseeds, destul, ad,
	520	seededRegionGrowing3D( srcul, shape, as, seedsul, aseeds, destul, ad,
521	521	stats, CompleteGrow);
522	522	}
523	523

529	529	seededRegionGrowing3D(triple<SrcImageIterator, Shape, SrcAccessor> img1,
530	530	pair<SeedImageIterator, SeedAccessor> img3,
531	531	pair<DestImageIterator, DestAccessor> img4,
532		RegionStatisticsArray & stats,
	532	RegionStatisticsArray & stats,
533	533	SRGType srgType, Neighborhood n, double max_cost)
534	534	{
535	535	seededRegionGrowing3D(img1.first, img1.second, img1.third,

546	546	seededRegionGrowing3D(triple<SrcImageIterator, Shape, SrcAccessor> img1,
547	547	pair<SeedImageIterator, SeedAccessor> img3,
548	548	pair<DestImageIterator, DestAccessor> img4,
549		RegionStatisticsArray & stats,
	549	RegionStatisticsArray & stats,
550	550	SRGType srgType, Neighborhood n)
551	551	{
552	552	seededRegionGrowing3D(img1.first, img1.second, img1.third,

595	595	seededRegionGrowing3D(MultiArrayView<3, T1, S1> const & img1,
596	596	MultiArrayView<3, TS, AS> const & img3,
597	597	MultiArrayView<3, T2, S2> img4,
598		RegionStatisticsArray & stats,
	598	RegionStatisticsArray & stats,
599	599	SRGType srgType, Neighborhood n, double max_cost)
600	600	{
601	601	vigra_precondition(img1.shape() == img3.shape(),

614	614	seededRegionGrowing3D(MultiArrayView<3, T1, S1> const & img1,
615	615	MultiArrayView<3, TS, AS> const & img3,
616	616	MultiArrayView<3, T2, S2> img4,
617		RegionStatisticsArray & stats,
	617	RegionStatisticsArray & stats,
618	618	SRGType srgType, Neighborhood n)
619	619	{
620	620	vigra_precondition(img1.shape() == img3.shape(),

+1

-1

include/vigra/separableconvolution.hxx less more

2399	2399	// first calculate required kernel sizes
2400	2400	int radius;
2401	2401	if(windowRatio == 0.0)
2402		radius = (int)(3.0 * std_dev + 0.5 * order + 0.5);
	2402	radius = (int)((3.0 + 0.5 * order) * std_dev + 0.5);
2403	2403	else
2404	2404	radius = (int)(windowRatio * std_dev + 0.5);
2405	2405	if(radius == 0)

+2

-2

include/vigra/sifImport.hxx less more

201	201	VIGRA_EXPORT void readSIF(const SIFImportInfo &info, MultiArrayView<3, float> array);
202	202
203	203	template <unsigned int N, class T, class S>
204		void readSIF(const SIFImportInfo &info, MultiArrayView<N, T, S> array)
	204	void readSIF(const SIFImportInfo &, MultiArrayView<N, T, S>)
205	205	{
206	206	vigra_precondition(false, "readSIF(): Destination array must be MultiArrayView<3, float>.");
207	207	}

228	228	VIGRA_EXPORT void readSIFBlock(const SIFImportInfo &info, Shape3 offset, Shape3 shape, MultiArrayView<3, float> array);
229	229
230	230	template <unsigned int N, class T, class S>
231		void readSIFBlock(const SIFImportInfo &info, Shape3 offset, Shape3 shape, MultiArrayView<N, T, S> array)
	231	void readSIFBlock(const SIFImportInfo &, Shape3, Shape3, MultiArrayView<N, T, S>)
232	232	{
233	233	vigra_precondition(false, "readSIFBlock(): Destination array must be MultiArrayView<3, float>.");
234	234	}

+134

-136

include/vigra/skeleton.hxx less more

55	55	double length, salience;
56	56	MultiArrayIndex partial_area;
57	57	bool is_loop;
58
	58
59	59	SkeletonNode()
60	60	: parent(lemon::INVALID)
61	61	, principal_child(lemon::INVALID)

64	64	, partial_area(0)
65	65	, is_loop(false)
66	66	{}
67
	67
68	68	SkeletonNode(Node const & s)
69	69	: parent(s)
70	70	, principal_child(lemon::INVALID)

80	80	{
81	81	typedef SkeletonNode<Node> SNode;
82	82	typedef std::map<Node, SNode> Skeleton;
83
	83
84	84	Node anchor, lower, upper;
85	85	Skeleton skeleton;
86
	86
87	87	SkeletonRegion()
88	88	: anchor(lemon::INVALID)
89	89	, lower(NumericTraits<MultiArrayIndex>::max())
90	90	, upper(NumericTraits<MultiArrayIndex>::min())
91	91	{}
92
	92
93	93	void addNode(Node const & n)
94	94	{
95	95	skeleton[n] = SNode(n);

100	100	};
101	101
102	102	template <class Graph, class Node, class NodeMap>
103		inline unsigned int
	103	inline unsigned int
104	104	neighborhoodConfiguration(Graph const & g, Node const & n, NodeMap const & labels)
105	105	{
106	106	typedef typename Graph::OutArcIt ArcIt;
107	107	typedef typename NodeMap::value_type LabelType;
108
	108
109	109	LabelType label = labels[n];
110	110	unsigned int v = 0;
111	111	for(ArcIt arc(g, n); arc != lemon::INVALID; ++arc)

151	151	// use std::greater because we need the smallest distances at the top of the queue
152	152	// (std::priority_queue is a max queue by default)
153	153	std::priority_queue<SP, std::vector<SP>, std::greater<SP> > pqueue;
154
	154
155	155	bool isSimpleStrong[256] = {
156		0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1,
157		0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1,
158		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0,
159		1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0,
160		1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1,
161		1, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
162		1, 0, 1, 1, 1, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
163		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1,
164		1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1,
165		1, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1,
166		1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0,
	156	0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1,
	157	0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1,
	158	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0,
	159	1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0,
	160	1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1,
	161	1, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	162	1, 0, 1, 1, 1, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
	163	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1,
	164	1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1,
	165	1, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1,
	166	1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0,
167	167	};
168
	168
169	169	bool isSimplePreserveEndPoints[256] = {
170		0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1,
171		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1,
172		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
173		1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
174		0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0,
175		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
176		0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
177		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
178		0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0,
179		0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0,
	170	0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1,
	171	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1,
	172	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	173	1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	174	0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0,
	175	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	176	0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	177	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	178	0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0,
	179	0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0,
180	180	1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
181	181	};
182
	182
183	183	bool * isSimplePoint = preserve_endpoints
184	184	? isSimplePreserveEndPoints
185	185	: isSimpleStrong;
186
	186
187	187	int max_degree = g.maxDegree();
188	188	double epsilon = 0.5/labels.size(), offset = 0;
189	189	for (NodeIt node(g); node != lemon::INVALID; ++node)

209	209	{
210	210	continue; // point already deleted or no longer simple
211	211	}
212
	212
213	213	labels[p] = 0; // delete simple point
214	214
215	215	for (ArcIt arc(g, p); arc != lemon::INVALID; ++arc)

231	231	{
232	232	Label label;
233	233	Labels const & labels;
234
	234
235	235	CheckForHole(Label l, Labels const & ls)
236	236	: label(l)
237	237	, labels(ls)
238	238	{}
239
	239
240	240	template <class Node>
241	241	bool operator()(Node const & n) const
242	242	{

244	244	}
245	245	};
246	246
247		} // namespace detail
248
249		/** \addtogroup MultiArrayDistanceTransform
	247	} // namespace detail
	248
	249	/** \addtogroup DistanceTransform
250	250	*/
251	251	//@{
252	252

268	268	PruneSalienceRelative = PruneSalience + Relative,
269	269	PruneTopology = PreserveTopology + Prune
270	270	};
271
	271
272	272	SkeletonMode mode;
273	273	double pruning_threshold;
274
	274
275	275	/** \brief construct with default settings
276
	276
277	277	(default: <tt>pruneSalienceRelative(0.2, true)</tt>)
278	278	*/
279	279	SkeletonOptions()
280	280	: mode(SkeletonMode(PruneSalienceRelative \| PreserveTopology))
281	281	, pruning_threshold(0.2)
282	282	{}
283
	283
284	284	/** \brief return the un-pruned skeletong
285	285	*/
286	286	SkeletonOptions & dontPrune()

288	288	mode = DontPrune;
289	289	return *this;
290	290	}
291
	291
292	292	/** \brief return only the region's center line (i.e. skeleton graph diameter)
293	293	*/
294	294	SkeletonOptions & pruneCenterLine()

296	296	mode = PruneCenterLine;
297	297	return *this;
298	298	}
299
	299
300	300	/** \brief Don't prune and return the length of each skeleton segment.
301	301	*/
302	302	SkeletonOptions & returnLength()

304	304	mode = Length;
305	305	return *this;
306	306	}
307
	307
308	308	/** \brief prune skeleton segments whose length is below the given threshold
309
	309
310	310	If \a preserve_topology is <tt>true</tt> (default), skeleton loops
311		(i.e. parts enclosing a hole in the region) are preserved even if their
	311	(i.e. parts enclosing a hole in the region) are preserved even if their
312	312	length is below the threshold. Otherwise, loops are pruned as well.
313	313	*/
314	314	SkeletonOptions & pruneLength(double threshold, bool preserve_topology=true)

319	319	pruning_threshold = threshold;
320	320	return *this;
321	321	}
322
	322
323	323	/** \brief prune skeleton segments whose relative length is below the given threshold
324
325		This works like <tt>pruneLength()</tt>, but the threshold is specified as a
	324
	325	This works like <tt>pruneLength()</tt>, but the threshold is specified as a
326	326	fraction of the maximum segment length in the skeleton.
327	327	*/
328	328	SkeletonOptions & pruneLengthRelative(double threshold, bool preserve_topology=true)

333	333	pruning_threshold = threshold;
334	334	return *this;
335	335	}
336
	336
337	337	/** \brief Don't prune and return the salience of each skeleton segment.
338	338	*/
339	339	SkeletonOptions & returnSalience()

341	341	mode = Salience;
342	342	return *this;
343	343	}
344
	344
345	345	/** \brief prune skeleton segments whose salience is below the given threshold
346
	346
347	347	If \a preserve_topology is <tt>true</tt> (default), skeleton loops
348		(i.e. parts enclosing a hole in the region) are preserved even if their
	348	(i.e. parts enclosing a hole in the region) are preserved even if their
349	349	salience is below the threshold. Otherwise, loops are pruned as well.
350	350	*/
351	351	SkeletonOptions & pruneSalience(double threshold, bool preserve_topology=true)

356	356	pruning_threshold = threshold;
357	357	return *this;
358	358	}
359
	359
360	360	/** \brief prune skeleton segments whose relative salience is below the given threshold
361
362		This works like <tt>pruneSalience()</tt>, but the threshold is specified as a
	361
	362	This works like <tt>pruneSalience()</tt>, but the threshold is specified as a
363	363	fraction of the maximum segment salience in the skeleton.
364	364	*/
365	365	SkeletonOptions & pruneSalienceRelative(double threshold, bool preserve_topology=true)

370	370	pruning_threshold = threshold;
371	371	return *this;
372	372	}
373
	373
374	374	/** \brief prune such that only the topology is preserved
375
	375
376	376	If \a preserve_center is <tt>true</tt> (default), the eccentricity center
377	377	of the skeleton will not be pruned, even if it is not essential for the topology.
378		Otherwise, the center is only preserved if it is essential. The center is always
	378	Otherwise, the center is only preserved if it is essential. The center is always
379	379	preserved (and is the only remaining point) when the region has no holes.
380	380	*/
381	381	SkeletonOptions & pruneTopology(bool preserve_center=true)

408	408	typedef double WeightType;
409	409	typedef detail::SkeletonNode<Node> SNode;
410	410	typedef std::map<Node, SNode> Skeleton;
411
	411
412	412	vigra_precondition(labels.shape() == dest.shape(),
413	413	"skeleton(): shape mismatch between input and output.");
414
	414
415	415	MultiArray<N, MultiArrayIndex> squared_distance;
416	416	dest = 0;
417	417	T1 maxLabel = 0;
418	418	// find skeleton points
419	419	{
420	420	using namespace multi_math;
421
	421
422	422	MultiArray<N, Shape> vectors(labels.shape());
423	423	boundaryVectorDistance(labels, vectors, false, OuterBoundary);
424	424	squared_distance = squaredNorm(vectors);
425
	425
426	426	ArrayVector<Node> ends_to_be_checked;
427	427	Graph g(labels.shape());
428	428	for (EdgeIt edge(g); edge != lemon::INVALID; ++edge)
429	429	{
430	430	Node p1 = g.u(*edge),
431	431	p2 = g.v(*edge);
432		T1 l1 = labels[p1],
	432	T1 l1 = labels[p1],
433	433	l2 = labels[p2];
434	434	maxLabel = max(maxLabel, max(l1, l2));
435	435	if(l1 == l2)
436	436	{
437	437	if(l1 <= 0) // only consider positive labels
438	438	continue;
439
	439
440	440	const Node v1 = vectors[p1],
441	441	v2 = vectors[p2],
442	442	dp = p2 - p1,
443	443	dv = v2 - v1 + dp;
444	444	if(max(abs(dv)) <= 1) // points whose support points coincide or are adjacent
445	445	continue; // don't belong to the skeleton
446
447		// among p1 and p2, the point which is closer to the bisector
	446
	447	// among p1 and p2, the point which is closer to the bisector
448	448	// of the support points p1 + v1 and p2 + v2 belongs to the skeleton
449	449	const MultiArrayIndex d1 = dot(dv, dp),
450	450	d2 = dot(dv, v1+v2);

469	469	dest[p2] = l2;
470	470	}
471	471	}
472
473
	472
	473
474	474	// add a point when a skeleton line stops short of the shape boundary
475	475	// FIXME: can this be solved during the initial detection above?
476	476	Graph g8(labels.shape(), IndirectNeighborhood);
477	477	for (unsigned k=0; k<ends_to_be_checked.size(); ++k)
478	478	{
479	479	// The phenomenon only occurs at points whose distance from the background is 2.
480		// We've put these points into ends_to_be_checked.
	480	// We've put these points into ends_to_be_checked.
481	481	Node p1 = ends_to_be_checked[k];
482	482	T2 label = dest[p1];
483	483	int count = 0;

493	493
494	494	// from here on, we only need the squared DT, not the vector DT
495	495	}
496
	496
497	497	// The true skeleton is defined by the interpixel edges between the
498	498	// Voronoi regions of the DT. Our skeleton detection algorithm affectively
499	499	// rounds the interpixel edges to the nearest pixel such that the result
500		// is mainly 8-connected and thin. However, thick skeleton pieces may still
	500	// is mainly 8-connected and thin. However, thick skeleton pieces may still
501	501	// arise when two interpixel contours are only one pixel apart, i.e. a
502		// Voronoi region is only one pixel wide. Since this happens rarely, we
	502	// Voronoi region is only one pixel wide. Since this happens rarely, we
503	503	// can simply remove these cases by thinning.
504	504	detail::skeletonThinning(squared_distance, dest);
505
	505
506	506	if(options.mode == SkeletonOptions::PruneCenterLine)
507	507	dest = 0;
508
	508
509	509	// Reduce the full grid graph to a skeleton graph by inserting infinite
510	510	// edge weights between skeleton pixels and non-skeleton pixels.
511	511	if(features)

521	521	T2 label = dest[p1];
522	522	if(label <= 0)
523	523	continue;
524
	524
525	525	// FIXME: consider using an AdjacencyListGraph from here on
526	526	regions[(size_t)label].addNode(p1);
527	527

534	534	weights[*arc] = infiniteWeight;
535	535	}
536	536	}
537
	537
538	538	ShortestPathDijkstra<Graph, WeightType> pathFinder(g);
539	539	// Handle the skeleton of each region individually.
540	540	for(std::size_t label=1; label < regions.size(); ++label)

542	542	Skeleton & skeleton = regions[label].skeleton;
543	543	if(skeleton.size() == 0) // label doesn't exist
544	544	continue;
545
	545
546	546	// Find a diameter (longest path) in the skeleton.
547	547	Node anchor = regions[label].anchor,
548	548	lower = regions[label].lower,
549	549	upper = regions[label].upper + Shape(1);
550
	550
551	551	pathFinder.run(lower, upper, weights, anchor, lemon::INVALID, maxWeight);
552	552	anchor = pathFinder.target();
553	553	pathFinder.reRun(weights, anchor, lemon::INVALID, maxWeight);
554	554	anchor = pathFinder.target();
555
	555
556	556	Polygon<Shape> center_line;
557	557	center_line.push_back_unsafe(anchor);
558	558	while(pathFinder.predecessors()[center_line.back()] != center_line.back())
559	559	center_line.push_back_unsafe(pathFinder.predecessors()[center_line.back()]);
560
	560
561	561	if(options.mode == SkeletonOptions::PruneCenterLine)
562	562	{
563	563	for(unsigned int k=0; k<center_line.size(); ++k)
564	564	dest[center_line[k]] = (T2)label;
565	565	continue; // to next label
566	566	}
567
	567
568	568	// Perform the eccentricity transform of the skeleton
569	569	Node center = center_line[roundi(center_line.arcLengthQuantile(0.5))];
570	570	pathFinder.reRun(weights, center, lemon::INVALID, maxWeight);
571
	571
572	572	bool compute_salience = (options.mode & SkeletonOptions::Salience) != 0;
573	573	ArrayVector<Node> raw_skeleton(pathFinder.discoveryOrder());
574	574	// from periphery to center: create skeleton tree and compute salience

579	579	SNode & n1 = skeleton[p1];
580	580	SNode & n2 = skeleton[p2];
581	581	n1.parent = p2;
582
	582
583	583
584	584	// remove non-skeleton edges (i.e. set weight = infiniteWeight)
585	585	for (BackArcIt arc(g, p1); arc != lemon::INVALID; ++arc)

591	591	continue; // edge belongs to the skeleton
592	592	if(pathFinder.predecessors()[p] == p1)
593	593	continue; // edge belongs to the skeleton
594		if(n1.principal_child == lemon::INVALID \|\|
	594	if(n1.principal_child == lemon::INVALID \|\|
595	595	skeleton[p].principal_child == lemon::INVALID)
596	596	continue; // edge may belong to a loop => test later
597	597	weights[*arc] = infiniteWeight;

604	604	n2.length = l;
605	605	n2.principal_child = p1;
606	606	}
607
	607
608	608	if(compute_salience)
609	609	{
610	610	const double min_length = 4.0; // salience is meaningless for shorter segments due

612	612	if(n1.length >= min_length)
613	613	{
614	614	n1.salience = max(n1.salience, (n1.length + 0.5) / sqrt(squared_distance[p1]));
615
	615
616	616	// propagate salience to parent if this is the most salient subtree
617	617	if(n2.salience < n1.salience)
618	618	n2.salience = n1.salience;

623	623	else
624	624	n1.salience = n1.length;
625	625	}
626
	626
627	627	// from center to periphery: propagate salience and compute twice the partial area
628	628	for(int k=0; k < (int)raw_skeleton.size(); ++k)
629	629	{

631	631	SNode & n1 = skeleton[p1];
632	632	Node p2 = n1.parent;
633	633	SNode & n2 = skeleton[p2];
634
	634
635	635	if(p1 == n2.principal_child)
636	636	{
637	637	n1.length = n2.length;

644	644	n1.partial_area = n2.partial_area + (p1[0]p2[1] - p1[1]p2[0]);
645	645	}
646	646
647		// always treat eccentricity center as a loop, so that it cannot be pruned
	647	// always treat eccentricity center as a loop, so that it cannot be pruned
648	648	// away unless (options.mode & PreserveTopology) is false.
649	649	skeleton[center].is_loop = true;
650
	650
651	651	// from periphery to center: * find and propagate loops
652	652	// * delete branches not reaching the boundary
653	653	detail::CheckForHole<std::size_t, MultiArrayView<2, T1, S1> > hasNoHole(label, labels);

664	664	{
665	665	Node p2 = g.target(*arc);
666	666	SNode * n2 = &skeleton[p2];
667
	667
668	668	if(n1.parent == p2)
669	669	continue; // going back to the parent can't result in a loop
670	670	if(weights[*arc] == infiniteWeight)

673	673	MultiArrayIndex area2 = abs(n1.partial_area - (p1[0]p2[1] - p1[1]p2[0]) - n2->partial_area);
674	674	if(area2 <= 3) // area is too small to enclose a hole => loop is a discretization artifact
675	675	continue;
676
	676
677	677	// use Dijkstra to find the loop
678		WeightType edge_length = weights[*arc];
679	678	weights[*arc] = infiniteWeight;
680	679	pathFinder.reRun(weights, p1, p2);
681	680	Polygon<Shape2> poly;

683	682	poly.push_back_unsafe(p1);
684	683	poly.push_back_unsafe(p2);
685	684	Node p = p2;
686		do
	685	do
687	686	{
688	687	p = pathFinder.predecessors()[p];
689	688	poly.push_back_unsafe(p);

697	696	++hole_count;
698	697	total_length += n1.length + n2->length;
699	698	double max_salience = max(n1.salience, n2->salience);
700		for(int p=1; p<poly.size(); ++p)
	699	for(decltype(poly.size()) p=1; p<poly.size(); ++p)
701	700	{
702	701	SNode & n = skeleton[poly[p]];
703	702	n.is_loop = true;

725	724	}
726	725	}
727	726	}
728
	727
729	728	if(n1.is_loop)
730	729	skeleton[n1.parent].is_loop = true;
731	730	}
732
	731
733	732	bool dont_prune = (options.mode & SkeletonOptions::Prune) == 0;
734	733	bool preserve_topology = (options.mode & SkeletonOptions::PreserveTopology) != 0 \|\|
735	734	options.mode == SkeletonOptions::Prune;

748	747	Node p1 = raw_skeleton[k];
749	748	SNode & n1 = skeleton[p1];
750	749	Node p2 = n1.parent;
751		SNode & n2 = skeleton[p2];
752		if(n1.principal_child == lemon::INVALID &&
753		n1.salience >= threshold &&
	750	if(n1.principal_child == lemon::INVALID &&
	751	n1.salience >= threshold &&
754	752	!n1.is_loop)
755	753	{
756	754	++branch_count;

769	767	}
770	768	if(branch_count > 0)
771	769	average_length /= branch_count;
772
	770
773	771	if(features)
774	772	{
775	773	(*features)[label].diameter = center_line.length();

783	781	(*features)[label].euclidean_diameter = norm(center_line.back()-center_line.front());
784	782	}
785	783	}
786
	784
787	785	if(options.mode == SkeletonOptions::Prune)
788	786	detail::skeletonThinning(squared_distance, dest, false);
789	787	}

794	792	double diameter, total_length, average_length, euclidean_diameter;
795	793	UInt32 branch_count, hole_count;
796	794	Shape2 center, terminal1, terminal2;
797
	795
798	796	SkeletonFeatures()
799	797	: diameter(0)
800	798	, total_length(0)

812	810	/********************************************************/
813	811
814	812	/*
815		To compute the skeleton reliably in higher dimensions, we have to work on
816		a topological grid. The tricks to work with rounded skeletons on the
	813	To compute the skeleton reliably in higher dimensions, we have to work on
	814	a topological grid. The tricks to work with rounded skeletons on the
817	815	pixel grid probably don't generalize from 2D to 3D and higher. Specifically:
818
	816
819	817	* Compute Voronoi regions of the vector distance transformation according to
820	818	identical support point to make sure that disconnected Voronoi regions
821	819	still get only a single label.
822	820	* Merge Voronoi regions whose support points are adjacent.
823	821	* Mark skeleton candidates on the interpixel grid after the basic merge.
824	822	* Detect skeleton segments simply by connected components labeling in the interpixel grid.
825		* Skeleton segments form hyperplanes => use this property to compute segment
	823	* Skeleton segments form hyperplanes => use this property to compute segment
826	824	attributes.
827	825	* Detect holes (and therefore, skeleton segments that are critical for topology)
828	826	by computing the depth of each region/surface in the homotopy tree.
829		* Add a pruning mode where holes are only preserved if their size exceeds a threshold.
830
	827	* Add a pruning mode where holes are only preserved if their size exceeds a threshold.
	828
831	829	To implement this cleanly, we first need a good implementation of the topological grid graph.
832	830	*/
833	831	// template <unsigned int N, class T1, class S1,

853	851	}
854	852	\endcode
855	853
856		This function computes the skeleton for each region in the 2D label image \a labels
857		and paints the results into the result image \a dest. Input label
858		<tt>0</tt> is interpreted as background and always ignored. Skeletons will be
859		marked with the same label as the corresponding region (unless options
860		<tt>returnLength()</tt> or <tt>returnSalience()</tt> are selected, see below).
	854	This function computes the skeleton for each region in the 2D label image \a labels
	855	and paints the results into the result image \a dest. Input label
	856	<tt>0</tt> is interpreted as background and always ignored. Skeletons will be
	857	marked with the same label as the corresponding region (unless options
	858	<tt>returnLength()</tt> or <tt>returnSalience()</tt> are selected, see below).
861	859	Non-skeleton pixels will receive label <tt>0</tt>.
862	860
863	861	For each region, the algorithm proceeds in the following steps:
864	862	<ol>
865	863	<li>Compute the \ref boundaryVectorDistance() relative to the \ref OuterBoundary of the region.</li>
866		<li>Mark the raw skeleton: find 4-adjacent pixel pairs whose nearest boundary points are neither equal
	864	<li>Mark the raw skeleton: find 4-adjacent pixel pairs whose nearest boundary points are neither equal
867	865	nor adjacent and mark one pixel of the pair as a skeleton candidate. The resulting raw skeleton
868	866	is 8-connected and thin. Skip the remaining steps when option <tt>dontPrune()</tt> is selected.</li>
869		<li>Compute the eccentricity transform of the raw skeleton and turn the skeleton into a tree
	867	<li>Compute the eccentricity transform of the raw skeleton and turn the skeleton into a tree
870	868	whose root is the eccentricity center. When option <tt>pruneCenterLine()</tt> is selected,
871		delete all skeleton points that do not belong to the two longest tree branches and
	869	delete all skeleton points that do not belong to the two longest tree branches and
872	870	skip the remaining steps.</li>
873	871	<li>For each pixel on the skeleton, compute its <tt>length</tt> attribute as the depth of the
874		pixel's longest subtree. Compute its <tt>salience</tt> attribute as the ratio between
875		<tt>length</tt> and <tt>distance</tt>, where <tt>distance</tt> is the pixel's distance to
	872	pixel's longest subtree. Compute its <tt>salience</tt> attribute as the ratio between
	873	<tt>length</tt> and <tt>distance</tt>, where <tt>distance</tt> is the pixel's distance to
876	874	the nearest boundary point according to the distance transform. It holds that <tt>length >= 0.5</tt>
877	875	and <tt>salience >= 1.0</tt>.</li>
878		<li>Detect skeleton branching points and define <i>skeleton segments</i> as maximal connected pieces
	876	<li>Detect skeleton branching points and define <i>skeleton segments</i> as maximal connected pieces
879	877	without branching points.</li>
880	878	<li>Compute <tt>length</tt> and <tt>salience</tt> of each segment as the maximum of these
881		attributes among the pixels in the segment. When options <tt>returnLength()</tt> or
882		<tt>returnSalience()</tt> are selected, skip the remaining steps and return the
883		requested segment attribute in <tt>dest</tt>. In this case, <tt>dest</tt>'s
884		<tt>value_type</tt> should be a floating point type to exactly accomodate the
	879	attributes among the pixels in the segment. When options <tt>returnLength()</tt> or
	880	<tt>returnSalience()</tt> are selected, skip the remaining steps and return the
	881	requested segment attribute in <tt>dest</tt>. In this case, <tt>dest</tt>'s
	882	<tt>value_type</tt> should be a floating point type to exactly accomodate the
885	883	attribute values.</li>
886	884	<li>Detect minimal cycles in the raw skeleton that enclose holes in the region (if any) and mark
887	885	the corresponding pixels as critical for skeleton topology.</li>
888		<li>Prune skeleton segments according to the selected pruning strategy and return the result.
	886	<li>Prune skeleton segments according to the selected pruning strategy and return the result.
889	887	The following pruning strategies are available:
890	888	<ul>
891	889	<li><tt>pruneLength(threshold, preserve_topology)</tt>: Retain only segments whose length attribute

893	891	(the defult), cycles around holes are preserved regardless of their length.
894	892	Otherwise, they are pruned as well.</li>
895	893	<li><tt>pruneLengthRelative(threshold, preserve_topology)</tt>: Like <tt>pruneLength()</tt>,
896		but the threshold is specified as a fraction of the maximum segment length in
	894	but the threshold is specified as a fraction of the maximum segment length in
897	895	the present region.</li>
898	896	<li><tt>pruneSalience(threshold, preserve_topology)</tt>: Retain only segments whose salience attribute
899	897	exceeds the given <tt>threshold</tt>. When <tt>preserve_topology</tt> is true
900	898	(the defult), cycles around holes are preserved regardless of their salience.
901	899	Otherwise, they are pruned as well.</li>
902	900	<li><tt>pruneSalienceRelative(threshold, preserve_topology)</tt>: Like <tt>pruneSalience()</tt>,
903		but the threshold is specified as a fraction of the maximum segment salience in
	901	but the threshold is specified as a fraction of the maximum segment salience in
904	902	the present region.</li>
905	903	<li><tt>pruneTopology(preserve_center)</tt>: Retain only segments that are essential for the region's
906	904	topology. If <tt>preserve_center</tt> is true (the default), the eccentricity
907		center is also preserved, even if it is not essential. Otherwise, it might be
	905	center is also preserved, even if it is not essential. Otherwise, it might be
908	906	removed. The eccentricity center is always the only remaining point when
909	907	the region has no holes.</li>
910	908	</ul></li>
911	909	</ol>
912
	910
913	911	The skeleton has the following properties:
914	912	<ul>
915		<li>It is 8-connected and thin (except when two independent branches happen to run alongside
	913	<li>It is 8-connected and thin (except when two independent branches happen to run alongside
916	914	before they divert). Skeleton points are defined by rounding the exact Euclidean skeleton
917	915	locations to the nearest pixel.</li>
918		<li>Skeleton branches terminate either at the region boundary or at a cycle. There are no branch
	916	<li>Skeleton branches terminate either at the region boundary or at a cycle. There are no branch
919	917	end points in the region interior.</li>
920		<li>The salience threshold acts as a scale parameter: Large thresholds only retain skeleton
	918	<li>The salience threshold acts as a scale parameter: Large thresholds only retain skeleton
921	919	branches characterizing the general region shape. When the threshold gets smaller, ever
922	920	more detailed boundary bulges will be represented by a skeleton branch.</li>
923	921	</ul>
924
	922
925	923	Remark: If you have an application where a skeleton graph would be more useful
926	924	than a skeleton image, function <tt>skeletonizeImage()</tt> can be changed/extended easily.
927	925

958	956
959	957	template <class T, class S>
960	958	void
961		extractSkeletonFeatures(MultiArrayView<2, T, S> const & labels,
	959	extractSkeletonFeatures(MultiArrayView<2, T, S> const & labels,
962	960	ArrayVector<SkeletonFeatures> & features,
963	961	SkeletonOptions const & options = SkeletonOptions())
964	962	{

+87

-92

include/vigra/slic.hxx less more

44	44
45	45	namespace vigra {
46	46
47		/** \addtogroup SeededRegionGrowing
	47	/** \addtogroup Superpixels
48	48	*/
49	49	//@{
50	50

56	56
57	57	/** \brief Generate seeds for SLIC superpixel computation in arbitrary dimensions.
58	58
59		The source array \a src must be a scalar boundary indicator such as the gradient
	59	The source array \a src must be a scalar boundary indicator such as the gradient
60	60	magnitude. Seeds are initially placed on a regular Cartesian grid with spacing
61	61	\a seedDist und then moved to the point with smallest boundary indicator within
62	62	a search region of radius \a searchRadius around the initial position. The resulting
63	63	points are then marked in the output array \a seeds by consecutive labels.
64
65		The function returns the number of selected seeds, which equals the largest seed label
	64
	65	The function returns the number of selected seeds, which equals the largest seed label
66	66	because labeling starts at 1.
67	67
68	68	<b> Declaration:</b>

72	72	namespace vigra {
73	73	template <unsigned int N, class T, class S1,
74	74	class Label, class S2>
75		unsigned int
	75	unsigned int
76	76	generateSlicSeeds(MultiArrayView<N, T, S1> const & src,
77	77	MultiArrayView<N, Label, S2> seeds,
78	78	unsigned int seedDist,

88	88	\code
89	89	MultiArray<2, RGBValue<float> > src(Shape2(w, h));
90	90	... // fill src image
91
	91
92	92	// transform image to Lab color space
93	93	transformImage(srcImageRange(src), destImage(src), RGBPrime2LabFunctor<float>());
94
	94
95	95	// compute image gradient magnitude at scale 1.0 as a boundary indicator
96	96	MultiArray<2, float> grad(src.shape());
97	97	gaussianGradientMagnitude(srcImageRange(src), destImage(grad), 1.0);
98
	98
99	99	MultiArray<2, unsigned int> seeds(src.shape());
100	100	int seedDistance = 15;
101
	101
102	102	// place seeds on a grid with distance 15, but then move it to the lowest gradient
103	103	// poistion in a 3x3 window
104	104	generateSlicSeeds(grad, seeds, seedDistance);

110	110
111	111	template <unsigned int N, class T, class S1,
112	112	class Label, class S2>
113		unsigned int
	113	unsigned int
114	114	generateSlicSeeds(MultiArrayView<N, T, S1> const & boundaryIndicatorImage,
115	115	MultiArrayView<N, Label, S2> seeds,
116	116	unsigned int seedDist,

122	122	Shape shape(boundaryIndicatorImage.shape()),
123	123	seedShape(floor(shape / double(seedDist))),
124	124	offset((shape - (seedShape - Shape(1))*seedDist) / 2);
125
	125
126	126	unsigned int label = 0;
127	127	MultiCoordinateIterator<N> iter(seedShape),
128	128	end = iter.getEndIterator();

132	132	Shape center = (iter)seedDist + offset;
133	133	Shape startCoord = max(Shape(0), center-Shape(searchRadius));
134	134	Shape endCoord = min(center+Shape(searchRadius+1), shape);
135
	135
136	136	// find the coordinate of minimum boundary indicator in window
137	137	using namespace acc;
138	138	AccumulatorChain<CoupledArrays<N, T>,

163	163	: iter(10),
164	164	sizeLimit(0)
165	165	{}
166
	166
167	167	/** \brief Number of iterations.
168	168
169	169	Default: 10

173	173	iter = i;
174	174	return *this;
175	175	}
176
	176
177	177	/** \brief Minimum superpixel size.
178
	178
179	179	If you set this to 1, no size filtering will be performed.
180	180
181	181	Default: 0 (determine size limit automatically as <tt>average size / 4</tt>)

185	185	sizeLimit = s;
186	186	return *this;
187	187	}
188
	188
189	189	unsigned int iter;
190	190	unsigned int sizeLimit;
191	191	};

195	195	template <unsigned int N, class T, class Label>
196	196	class Slic
197	197	{
198		public:
199		//
	198	public:
	199	//
200	200	typedef MultiArrayView<N, T> DataImageType;
201		typedef MultiArrayView<N, Label> LabelImageType;
	201	typedef MultiArrayView<N, Label> LabelImageType;
202	202	typedef typename DataImageType::difference_type ShapeType;
203	203	typedef typename PromoteTraits<
204	204	typename NormTraits<T>::NormType,
205	205	typename NormTraits<MultiArrayIndex>::NormType
206	206	>::Promote DistanceType;
207	207
208		Slic(DataImageType dataImage,
209		LabelImageType labelImage,
210		DistanceType intensityScaling,
211		int maxRadius,
	208	Slic(DataImageType dataImage,
	209	LabelImageType labelImage,
	210	DistanceType intensityScaling,
	211	int maxRadius,
212	212	SlicOptions const & options = SlicOptions());
213
	213
214	214	unsigned int execute();
215	215
216	216	private:
217	217	void updateAssigments();
218	218	unsigned int postProcessing();
219
	219
220	220	typedef MultiArray<N,DistanceType> DistanceImageType;
221	221
222	222	ShapeType shape_;

226	226	int max_radius_;
227	227	DistanceType normalization_;
228	228	SlicOptions options_;
229
	229
230	230	typedef acc::Select<acc::DataArg<1>, acc::LabelArg<2>, acc::Mean, acc::RegionCenter> Statistics;
231	231	typedef acc::AccumulatorChainArray<CoupledArrays<N, T, Label>, Statistics> RegionFeatures;
232	232	RegionFeatures clusters_;

236	236
237	237	template <unsigned int N, class T, class Label>
238	238	Slic<N, T, Label>::Slic(
239		DataImageType dataImage,
	239	DataImageType dataImage,
240	240	LabelImageType labelImage,
241	241	DistanceType intensityScaling,
242	242	int maxRadius,

261	261	// update mean for each cluster
262	262	clusters_.reset();
263	263	extractFeatures(dataImage_, labelImage_, clusters_);
264
	264
265	265	// update which pixels get assigned to which cluster
266	266	updateAssigments();
267	267	}

279	279	{
280	280	if(get<Count>(clusters_, c) == 0) // label doesn't exist
281	281	continue;
282
	282
283	283	typedef typename LookupTag<RegionCenter, RegionFeatures>::value_type CenterType;
284	284	CenterType center = get<RegionCenter>(clusters_, c);
285	285
286	286	// get ROI limits around region center
287		ShapeType pixelCenter(round(center)),
288		startCoord(max(ShapeType(0), pixelCenter - ShapeType(max_radius_))),
	287	ShapeType pixelCenter(round(center)),
	288	startCoord(max(ShapeType(0), pixelCenter - ShapeType(max_radius_))),
289	289	endCoord(min(shape_, pixelCenter + ShapeType(max_radius_+1)));
290	290	center -= startCoord; // need center relative to ROI
291
	291
292	292	// setup iterators for ROI
293	293	typedef typename CoupledArrays<N, T, Label, DistanceType>::IteratorType Iterator;
294	294	Iterator iter = createCoupledIterator(dataImage_, labelImage_, distance_).
295	295	restrictToSubarray(startCoord, endCoord),
296	296	end = iter.getEndIterator();
297
	297
298	298	// only pixels within the ROI can be assigned to a cluster
299	299	for(; iter != end; ++iter)
300	300	{

313	313	}
314	314
315	315	template <unsigned int N, class T, class Label>
316		unsigned int
	316	unsigned int
317	317	Slic<N, T, Label>::postProcessing()
318	318	{
319	319	// get rid of regions below a size limit
320	320	MultiArray<N,Label> tmpLabelImage(labelImage_);
321	321	unsigned int maxLabel = labelMultiArray(tmpLabelImage, labelImage_, DirectNeighborhood);
322
	322
323	323	unsigned int sizeLimit = options_.sizeLimit == 0
324	324	? (unsigned int)(0.25 * labelImage_.size() / maxLabel)
325	325	: options_.sizeLimit;
326	326	if(sizeLimit == 1)
327	327	return maxLabel;
328
	328
329	329	// determine region size
330	330	using namespace acc;
331	331	AccumulatorChainArray<CoupledArrays<N, Label>, Select<LabelArg<1>, Count> > sizes;
332	332	extractFeatures(labelImage_, sizes);
333
	333
334	334	typedef GridGraph<N, undirected_tag> Graph;
335	335	Graph graph(labelImage_.shape(), DirectNeighborhood);
336
	336
337	337	typedef typename Graph::NodeIt graph_scanner;
338	338	typedef typename Graph::OutBackArcIt neighbor_iterator;
339	339
340		ArrayVector<Label> regions(maxLabel+1);
	340	vigra::UnionFindArray<Label> regions(maxLabel+1);
	341	ArrayVector<unsigned char> done(maxLabel+1, false);
341	342
342	343	// make sure that all regions exceed the sizeLimit
343		for (graph_scanner node(graph); node != lemon::INVALID; ++node)
	344	for (graph_scanner node(graph); node != lemon::INVALID; ++node)
344	345	{
345	346	Label label = labelImage_[*node];
346
347		if(regions[label] > 0)
	347
	348	if(done[label])
348	349	continue; // already processed
349
350		regions[label] = label;
351
	350
352	351	if(get<Count>(sizes, label) < sizeLimit)
353	352	{
354		// region is too small => merge into an existing neighbor
	353	// region is too small => merge into a neighbor
355	354	for (neighbor_iterator arc(graph, node); arc != lemon::INVALID; ++arc)
356	355	{
357		regions[label] = regions[labelImage_[graph.target(*arc)]];
358		break;
	356	Label other = labelImage_[graph.target(*arc)];
	357	if(label != other)
	358	{
	359	regions.makeUnion(label, other);
	360	done[label] = true;
	361	break;
	362	}
359	363	}
360		}
361		}
362
363		// make labels contiguous after possible merging
364		unsigned int newMaxLabel = 0;
365		for(unsigned int i=1; i<=maxLabel; ++i)
366		{
367		if(regions[i] == i)
368		{
369		regions[i] = (Label)++newMaxLabel;
370	364	}
371	365	else
372	366	{
373		regions[i] = regions[regions[i]];
	367	done[label] = true;
374	368	}
375	369	}
376	370
377		// update labels
378		for (graph_scanner node(graph); node != lemon::INVALID; ++node)
379		{
380		labelImage_[node] = regions[labelImage_[node]];
381		}
382
383		return newMaxLabel;
	371	// make labels contiguous after possible merging
	372	Label newMaxLabel = regions.makeContiguous();
	373	for (graph_scanner node(graph); node != lemon::INVALID; ++node)
	374	{
	375	labelImage_[node] = regions.findLabel(labelImage_[node]);
	376	}
	377
	378	return (unsigned int)newMaxLabel;
384	379	}
385	380
386	381	} // namespace detail

388	383
389	384	/** \brief Compute SLIC superpixels in arbitrary dimensions.
390	385
391		This function implements the algorithm described in
392
393		R. Achanta et al.: <em>"SLIC Superpixels Compared to State-of-the-Art
	386	This function implements the algorithm described in
	387
	388	R. Achanta et al.: <em>"SLIC Superpixels Compared to State-of-the-Art
394	389	Superpixel Methods"</em>, IEEE Trans. Patt. Analysis Mach. Intell. 34(11):2274-2281, 2012
395
396		The value type <tt>T</tt> of the source array \a src must provide the necessary functionality
397		to compute averages and squared distances (i.e. it must fulfill the requirements of a
	390
	391	The value type <tt>T</tt> of the source array \a src must provide the necessary functionality
	392	to compute averages and squared distances (i.e. it must fulfill the requirements of a
398	393	\ref LinearSpace and support squaredNorm(T const &)). This is true for all scalar types as well as
399	394	\ref vigra::TinyVector and \ref vigra::RGBValue. The output array \a labels will be filled
400	395	with labels designating membership of each point in one of the superpixel regions.
401
402		The output array can optionally contain seeds (which will be overwritten by the output)
	396
	397	The output array can optionally contain seeds (which will be overwritten by the output)
403	398	to give you full control over seed placement. If \a labels is empty, seeds will be created
404		automatically by an internal call to generateSlicSeeds().
405
	399	automatically by an internal call to generateSlicSeeds().
	400
406	401	The parameter \a seedDistance specifies the radius of the window around each seed (or, more
407		precisely, around the present regions centers) where the algorithm looks for potential members
	402	precisely, around the present regions centers) where the algorithm looks for potential members
408	403	of the corresponding superpixel. It thus places an upper limit on the superpixel size. When seeds
409	404	are computed automatically, this parameter also determines the grid spacing for seed placement.
410
411		The parameter \a intensityScaling is used to normalize (i.e. divide) the color/intensity difference
	405
	406	The parameter \a intensityScaling is used to normalize (i.e. divide) the color/intensity difference
412	407	before it is compared with the spatial distance. This corresponds to parameter <i>m</i> in equation
413	408	(2) of the paper.
414
	409
415	410	The options object can be used to specify the number of iterations (<tt>SlicOptions::iterations()</tt>)
416		and an explicit minimal superpixel size (<tt>SlicOptions::minSize()</tt>). By default, the algorithm
	411	and an explicit minimal superpixel size (<tt>SlicOptions::minSize()</tt>). By default, the algorithm
417	412	merges all regions that are smaller than 1/4 of the average superpixel size.
418
419		The function returns the number of superpixels, which equals the largest label
	413
	414	The function returns the number of superpixels, which equals the largest label
420	415	because labeling starts at 1.
421	416
422	417	<b> Declaration:</b>

427	422	template <unsigned int N, class T, class S1,
428	423	class Label, class S2,
429	424	class DistanceType>
430		unsigned int
	425	unsigned int
431	426	slicSuperpixels(MultiArrayView<N, T, S1> const & src,
432	427	MultiArrayView<N, Label, S2> labels,
433	428	DistanceType intensityScaling,
434		unsigned int seedDistance,
	429	unsigned int seedDistance,
435	430	SlicOptions const & options = SlicOptions());
436	431	}
437	432	\endcode

444	439	\code
445	440	MultiArray<2, RGBValue<float> > src(Shape2(w, h));
446	441	... // fill src image
447
	442
448	443	// transform image to Lab color space
449		transformMultiArray(srcMultiArrayRange(src), destMultiArray(src), RGBPrime2LabFunctor<float>());
450
	444	transformMultiArray(srcMultiArrayRange(src), destMultiArray(src), RGBPrime2LabFunctor<float>());
	445
451	446	MultiArray<2, unsigned int> labels(src.shape());
452	447	int seedDistance = 15;
453	448	double intensityScaling = 20.0;
454
	449
455	450	// compute seeds automatically, perform 40 iterations, and scale intensity differences
456	451	// down to 1/20 before comparing with spatial distances
457	452	slicSuperpixels(src, labels, intensityScaling, seedDistance, SlicOptions().iterations(40));
458	453	\endcode
459
	454
460	455	This works for arbitrary-dimensional arrays.
461	456	*/
462	457	doxygen_overloaded_function(template <...> unsigned int slicSuperpixels)

464	459	template <unsigned int N, class T, class S1,
465	460	class Label, class S2,
466	461	class DistanceType>
467		unsigned int
	462	unsigned int
468	463	slicSuperpixels(MultiArrayView<N, T, S1> const & src,
469	464	MultiArrayView<N, Label, S2> labels,
470	465	DistanceType intensityScaling,
471		unsigned int seedDistance,
	466	unsigned int seedDistance,
472	467	SlicOptions const & options = SlicOptions())
473	468	{
474	469	if(!labels.any())

+3

-3

include/vigra/specklefilters.hxx less more

163	163	sum_m = 0.0,
164	164	sum_pm = 0.0,
165	165	m = 0.0,
166		dist = 0.0,
	166	// dist = 0.0,
167	167	p = 0.0;
168	168
169	169	SrcIterator ys = s_ul;

371	371	sum_m = 0.0,
372	372	sum_pm = 0.0,
373	373	m = 0.0,
374		dist = 0.0,
	374	// dist = 0.0,
375	375	p = 0.0;
376	376
377	377	SrcIterator ys = s_ul;

1193	1193
1194	1194	} //end of namespace vigra
1195	1195
1196		#endif //VIGRA_SPECKLEFILTERS_HXX⏎
	1196	#endif //VIGRA_SPECKLEFILTERS_HXX

+144

-144

include/vigra/splineimageview.hxx less more

880	880	return operator()(x, y);
881	881	}
882	882
883		value_type dx(double x, double y) const
884		{ return NumericTraits<VALUETYPE>::zero(); }
885
886		value_type dy(double x, double y) const
887		{ return NumericTraits<VALUETYPE>::zero(); }
888
889		value_type dxx(double x, double y) const
890		{ return NumericTraits<VALUETYPE>::zero(); }
891
892		value_type dxy(double x, double y) const
893		{ return NumericTraits<VALUETYPE>::zero(); }
894
895		value_type dyy(double x, double y) const
896		{ return NumericTraits<VALUETYPE>::zero(); }
897
898		value_type dx3(double x, double y) const
899		{ return NumericTraits<VALUETYPE>::zero(); }
900
901		value_type dy3(double x, double y) const
902		{ return NumericTraits<VALUETYPE>::zero(); }
903
904		value_type dxxy(double x, double y) const
905		{ return NumericTraits<VALUETYPE>::zero(); }
906
907		value_type dxyy(double x, double y) const
	883	value_type dx(double /x/, double /y/) const
	884	{ return NumericTraits<VALUETYPE>::zero(); }
	885
	886	value_type dy(double /x/, double /y/) const
	887	{ return NumericTraits<VALUETYPE>::zero(); }
	888
	889	value_type dxx(double /x/, double /y/) const
	890	{ return NumericTraits<VALUETYPE>::zero(); }
	891
	892	value_type dxy(double /x/, double /y/) const
	893	{ return NumericTraits<VALUETYPE>::zero(); }
	894
	895	value_type dyy(double /x/, double /y/) const
	896	{ return NumericTraits<VALUETYPE>::zero(); }
	897
	898	value_type dx3(double /x/, double /y/) const
	899	{ return NumericTraits<VALUETYPE>::zero(); }
	900
	901	value_type dy3(double /x/, double /y/) const
	902	{ return NumericTraits<VALUETYPE>::zero(); }
	903
	904	value_type dxxy(double /x/, double /y/) const
	905	{ return NumericTraits<VALUETYPE>::zero(); }
	906
	907	value_type dxyy(double /x/, double /y/) const
908	908	{ return NumericTraits<VALUETYPE>::zero(); }
909	909
910	910	value_type operator()(difference_type const & d) const

913	913	value_type operator()(difference_type const & d, unsigned int dx, unsigned int dy) const
914	914	{ return operator()(d[0], d[1], dx, dy); }
915	915
916		value_type dx(difference_type const & d) const
917		{ return NumericTraits<VALUETYPE>::zero(); }
918
919		value_type dy(difference_type const & d) const
920		{ return NumericTraits<VALUETYPE>::zero(); }
921
922		value_type dxx(difference_type const & d) const
923		{ return NumericTraits<VALUETYPE>::zero(); }
924
925		value_type dxy(difference_type const & d) const
926		{ return NumericTraits<VALUETYPE>::zero(); }
927
928		value_type dyy(difference_type const & d) const
929		{ return NumericTraits<VALUETYPE>::zero(); }
930
931		value_type dx3(difference_type const & d) const
932		{ return NumericTraits<VALUETYPE>::zero(); }
933
934		value_type dy3(difference_type const & d) const
935		{ return NumericTraits<VALUETYPE>::zero(); }
936
937		value_type dxxy(difference_type const & d) const
938		{ return NumericTraits<VALUETYPE>::zero(); }
939
940		value_type dxyy(difference_type const & d) const
941		{ return NumericTraits<VALUETYPE>::zero(); }
942
943		SquaredNormType g2(double x, double y) const
944		{ return NumericTraits<SquaredNormType>::zero(); }
945
946		SquaredNormType g2x(double x, double y) const
947		{ return NumericTraits<SquaredNormType>::zero(); }
948
949		SquaredNormType g2y(double x, double y) const
950		{ return NumericTraits<SquaredNormType>::zero(); }
951
952		SquaredNormType g2xx(double x, double y) const
953		{ return NumericTraits<SquaredNormType>::zero(); }
954
955		SquaredNormType g2xy(double x, double y) const
956		{ return NumericTraits<SquaredNormType>::zero(); }
957
958		SquaredNormType g2yy(double x, double y) const
959		{ return NumericTraits<SquaredNormType>::zero(); }
960
961		SquaredNormType g2(difference_type const & d) const
962		{ return NumericTraits<SquaredNormType>::zero(); }
963
964		SquaredNormType g2x(difference_type const & d) const
965		{ return NumericTraits<SquaredNormType>::zero(); }
966
967		SquaredNormType g2y(difference_type const & d) const
968		{ return NumericTraits<SquaredNormType>::zero(); }
969
970		SquaredNormType g2xx(difference_type const & d) const
971		{ return NumericTraits<SquaredNormType>::zero(); }
972
973		SquaredNormType g2xy(difference_type const & d) const
974		{ return NumericTraits<SquaredNormType>::zero(); }
975
976		SquaredNormType g2yy(difference_type const & d) const
	916	value_type dx(difference_type const & /d/) const
	917	{ return NumericTraits<VALUETYPE>::zero(); }
	918
	919	value_type dy(difference_type const & /d/) const
	920	{ return NumericTraits<VALUETYPE>::zero(); }
	921
	922	value_type dxx(difference_type const & /d/) const
	923	{ return NumericTraits<VALUETYPE>::zero(); }
	924
	925	value_type dxy(difference_type const & /d/) const
	926	{ return NumericTraits<VALUETYPE>::zero(); }
	927
	928	value_type dyy(difference_type const & /d/) const
	929	{ return NumericTraits<VALUETYPE>::zero(); }
	930
	931	value_type dx3(difference_type const & /d/) const
	932	{ return NumericTraits<VALUETYPE>::zero(); }
	933
	934	value_type dy3(difference_type const & /d/) const
	935	{ return NumericTraits<VALUETYPE>::zero(); }
	936
	937	value_type dxxy(difference_type const & /d/) const
	938	{ return NumericTraits<VALUETYPE>::zero(); }
	939
	940	value_type dxyy(difference_type const & /d/) const
	941	{ return NumericTraits<VALUETYPE>::zero(); }
	942
	943	SquaredNormType g2(double /x/, double /y/) const
	944	{ return NumericTraits<SquaredNormType>::zero(); }
	945
	946	SquaredNormType g2x(double /x/, double /y/) const
	947	{ return NumericTraits<SquaredNormType>::zero(); }
	948
	949	SquaredNormType g2y(double /x/, double /y/) const
	950	{ return NumericTraits<SquaredNormType>::zero(); }
	951
	952	SquaredNormType g2xx(double /x/, double /y/) const
	953	{ return NumericTraits<SquaredNormType>::zero(); }
	954
	955	SquaredNormType g2xy(double /x/, double /y/) const
	956	{ return NumericTraits<SquaredNormType>::zero(); }
	957
	958	SquaredNormType g2yy(double /x/, double /y/) const
	959	{ return NumericTraits<SquaredNormType>::zero(); }
	960
	961	SquaredNormType g2(difference_type const & /d/) const
	962	{ return NumericTraits<SquaredNormType>::zero(); }
	963
	964	SquaredNormType g2x(difference_type const & /d/) const
	965	{ return NumericTraits<SquaredNormType>::zero(); }
	966
	967	SquaredNormType g2y(difference_type const & /d/) const
	968	{ return NumericTraits<SquaredNormType>::zero(); }
	969
	970	SquaredNormType g2xx(difference_type const & /d/) const
	971	{ return NumericTraits<SquaredNormType>::zero(); }
	972
	973	SquaredNormType g2xy(difference_type const & /d/) const
	974	{ return NumericTraits<SquaredNormType>::zero(); }
	975
	976	SquaredNormType g2yy(difference_type const & /d/) const
977	977	{ return NumericTraits<SquaredNormType>::zero(); }
978	978
979	979	unsigned int width() const

1061	1061	/* when traverser and accessor types passed to the constructor are the same as the corresponding
1062	1062	internal types, we need not copy the image (speed up)
1063	1063	*/
1064		SplineImageView0(InternalTraverser is, InternalTraverser iend, InternalAccessor sa)
	1064	SplineImageView0(InternalTraverser is, InternalTraverser iend, InternalAccessor /sa/)
1065	1065	: Base(iend.x - is.x, iend.y - is.y, is)
1066	1066	{}
1067	1067

1069	1069	: Base(s.second.x - s.first.x, s.second.y - s.first.y, s.first)
1070	1070	{}
1071	1071
1072		SplineImageView0(InternalConstTraverser is, InternalConstTraverser iend, InternalConstAccessor sa)
	1072	SplineImageView0(InternalConstTraverser is, InternalConstTraverser iend, InternalConstAccessor /sa/)
1073	1073	: Base(iend.x - is.x, iend.y - is.y, is)
1074	1074	{}
1075	1075

1458	1458	value_type dy(double x, double y) const
1459	1459	{ return operator()(x, y, 0, 1); }
1460	1460
1461		value_type dxx(double x, double y) const
	1461	value_type dxx(double /x/, double /y/) const
1462	1462	{ return NumericTraits<VALUETYPE>::zero(); }
1463	1463
1464	1464	value_type dxy(double x, double y) const
1465	1465	{ return operator()(x, y, 1, 1); }
1466	1466
1467		value_type dyy(double x, double y) const
1468		{ return NumericTraits<VALUETYPE>::zero(); }
1469
1470		value_type dx3(double x, double y) const
1471		{ return NumericTraits<VALUETYPE>::zero(); }
1472
1473		value_type dy3(double x, double y) const
1474		{ return NumericTraits<VALUETYPE>::zero(); }
1475
1476		value_type dxxy(double x, double y) const
1477		{ return NumericTraits<VALUETYPE>::zero(); }
1478
1479		value_type dxyy(double x, double y) const
	1467	value_type dyy(double /x/, double /y/) const
	1468	{ return NumericTraits<VALUETYPE>::zero(); }
	1469
	1470	value_type dx3(double /x/, double /y/) const
	1471	{ return NumericTraits<VALUETYPE>::zero(); }
	1472
	1473	value_type dy3(double /x/, double /y/) const
	1474	{ return NumericTraits<VALUETYPE>::zero(); }
	1475
	1476	value_type dxxy(double /x/, double /y/) const
	1477	{ return NumericTraits<VALUETYPE>::zero(); }
	1478
	1479	value_type dxyy(double /x/, double /y/) const
1480	1480	{ return NumericTraits<VALUETYPE>::zero(); }
1481	1481
1482	1482	value_type operator()(difference_type const & d) const

1491	1491	value_type dy(difference_type const & d) const
1492	1492	{ return operator()(d[0], d[1], 0, 1); }
1493	1493
1494		value_type dxx(difference_type const & d) const
	1494	value_type dxx(difference_type const & /d/) const
1495	1495	{ return NumericTraits<VALUETYPE>::zero(); }
1496	1496
1497	1497	value_type dxy(difference_type const & d) const
1498	1498	{ return operator()(d[0], d[1], 1, 1); }
1499	1499
1500		value_type dyy(difference_type const & d) const
1501		{ return NumericTraits<VALUETYPE>::zero(); }
1502
1503		value_type dx3(difference_type const & d) const
1504		{ return NumericTraits<VALUETYPE>::zero(); }
1505
1506		value_type dy3(difference_type const & d) const
1507		{ return NumericTraits<VALUETYPE>::zero(); }
1508
1509		value_type dxxy(difference_type const & d) const
1510		{ return NumericTraits<VALUETYPE>::zero(); }
1511
1512		value_type dxyy(difference_type const & d) const
	1500	value_type dyy(difference_type const & /d/) const
	1501	{ return NumericTraits<VALUETYPE>::zero(); }
	1502
	1503	value_type dx3(difference_type const & /d/) const
	1504	{ return NumericTraits<VALUETYPE>::zero(); }
	1505
	1506	value_type dy3(difference_type const & /d/) const
	1507	{ return NumericTraits<VALUETYPE>::zero(); }
	1508
	1509	value_type dxxy(difference_type const & /d/) const
	1510	{ return NumericTraits<VALUETYPE>::zero(); }
	1511
	1512	value_type dxyy(difference_type const & /d/) const
1513	1513	{ return NumericTraits<VALUETYPE>::zero(); }
1514	1514
1515	1515	SquaredNormType g2(double x, double y) const
1516	1516	{ return squaredNorm(dx(x,y)) + squaredNorm(dy(x,y)); }
1517	1517
1518		SquaredNormType g2x(double x, double y) const
1519		{ return NumericTraits<SquaredNormType>::zero(); }
1520
1521		SquaredNormType g2y(double x, double y) const
1522		{ return NumericTraits<SquaredNormType>::zero(); }
1523
1524		SquaredNormType g2xx(double x, double y) const
1525		{ return NumericTraits<SquaredNormType>::zero(); }
1526
1527		SquaredNormType g2xy(double x, double y) const
1528		{ return NumericTraits<SquaredNormType>::zero(); }
1529
1530		SquaredNormType g2yy(double x, double y) const
	1518	SquaredNormType g2x(double /x/, double /y/) const
	1519	{ return NumericTraits<SquaredNormType>::zero(); }
	1520
	1521	SquaredNormType g2y(double /x/, double /y/) const
	1522	{ return NumericTraits<SquaredNormType>::zero(); }
	1523
	1524	SquaredNormType g2xx(double /x/, double /y/) const
	1525	{ return NumericTraits<SquaredNormType>::zero(); }
	1526
	1527	SquaredNormType g2xy(double /x/, double /y/) const
	1528	{ return NumericTraits<SquaredNormType>::zero(); }
	1529
	1530	SquaredNormType g2yy(double /x/, double /y/) const
1531	1531	{ return NumericTraits<SquaredNormType>::zero(); }
1532	1532
1533	1533	SquaredNormType g2(difference_type const & d) const
1534	1534	{ return g2(d[0], d[1]); }
1535	1535
1536		SquaredNormType g2x(difference_type const & d) const
1537		{ return NumericTraits<SquaredNormType>::zero(); }
1538
1539		SquaredNormType g2y(difference_type const & d) const
1540		{ return NumericTraits<SquaredNormType>::zero(); }
1541
1542		SquaredNormType g2xx(difference_type const & d) const
1543		{ return NumericTraits<SquaredNormType>::zero(); }
1544
1545		SquaredNormType g2xy(difference_type const & d) const
1546		{ return NumericTraits<SquaredNormType>::zero(); }
1547
1548		SquaredNormType g2yy(difference_type const & d) const
	1536	SquaredNormType g2x(difference_type const & /d/) const
	1537	{ return NumericTraits<SquaredNormType>::zero(); }
	1538
	1539	SquaredNormType g2y(difference_type const & /d/) const
	1540	{ return NumericTraits<SquaredNormType>::zero(); }
	1541
	1542	SquaredNormType g2xx(difference_type const & /d/) const
	1543	{ return NumericTraits<SquaredNormType>::zero(); }
	1544
	1545	SquaredNormType g2xy(difference_type const & /d/) const
	1546	{ return NumericTraits<SquaredNormType>::zero(); }
	1547
	1548	SquaredNormType g2yy(difference_type const & /d/) const
1549	1549	{ return NumericTraits<SquaredNormType>::zero(); }
1550	1550
1551	1551	unsigned int width() const

1698	1698	/* when traverser and accessor types passed to the constructor are the same as the corresponding
1699	1699	internal types, we need not copy the image (speed up)
1700	1700	*/
1701		SplineImageView1(InternalTraverser is, InternalTraverser iend, InternalAccessor sa)
	1701	SplineImageView1(InternalTraverser is, InternalTraverser iend, InternalAccessor /sa/)
1702	1702	: Base(iend.x - is.x, iend.y - is.y, is)
1703	1703	{}
1704	1704

1706	1706	: Base(s.second.x - s.first.x, s.second.y - s.first.y, s.first)
1707	1707	{}
1708	1708
1709		SplineImageView1(InternalConstTraverser is, InternalConstTraverser iend, InternalConstAccessor sa)
	1709	SplineImageView1(InternalConstTraverser is, InternalConstTraverser iend, InternalConstAccessor /sa/)
1710	1710	: Base(iend.x - is.x, iend.y - is.y, is)
1711	1711	{}
1712	1712

+48

-62

include/vigra/splines.hxx less more

38	38	#include <cmath>
39	39	#include "config.hxx"
40	40	#include "mathutil.hxx"
41		#include "polynomial.hxx"
42	41	#include "array_vector.hxx"
43	42	#include "fixedpoint.hxx"
44	43

76	75	\f[ B_n(x) = B_0(x) * B_{n-1}(x)
77	76	\f]
78	77
79		where * denotes convolution, and <i>n</i> is the spline order given by the
80		template parameter <tt>ORDER</tt>. These spline classes can be used as
	78	where * denotes convolution, and <i>n</i> is the spline order given by the template
	79	parameter <tt>ORDER</tt> with <tt>ORDER < 18</tt>. These spline classes can be used as
81	80	unary and binary functors, as kernels for \ref resamplingConvolveImage(),
82	81	and as arguments for \ref vigra::SplineImageView. Note that the spline order
83	82	is given as a template argument.

89	88	class BSplineBase
90	89	{
91	90	public:
	91
	92	static_assert (ORDER < 18 , "BSpline: ORDER must be less than 18." );
92	93
93	94	/** the value type if used as a kernel in \ref resamplingConvolveImage().
94	95	*/

177	178	return weightMatrix_;
178	179	}
179	180
	181	static ArrayVector<double> getPrefilterCoefficients();
	182
180	183	protected:
181	184	result_type exec(first_argument_type x, second_argument_type derivative_order) const;
182
183		// factory function for the prefilter coefficients array
184		static ArrayVector<double> calculatePrefilterCoefficients();
185	185
186	186	// factory function for the weight matrix
187	187	static WeightMatrix calculateWeightMatrix();

192	192	};
193	193
194	194	template <int ORDER, class T>
195		ArrayVector<double> BSplineBase<ORDER, T>::prefilterCoefficients_(BSplineBase<ORDER, T>::calculatePrefilterCoefficients());
	195	ArrayVector<double> BSplineBase<ORDER, T>::prefilterCoefficients_(getPrefilterCoefficients());
196	196
197	197	template <int ORDER, class T>
198	198	typename BSplineBase<ORDER, T>::WeightMatrix BSplineBase<ORDER, T>::weightMatrix_(calculateWeightMatrix());

214	214	}
215	215
216	216	template <int ORDER, class T>
217		ArrayVector<double>
218		BSplineBase<ORDER, T>::calculatePrefilterCoefficients()
219		{
220		ArrayVector<double> res;
221		if(ORDER > 1)
222		{
223		const int r = ORDER / 2;
224		StaticPolynomial<2r, double> p(2r);
225		BSplineBase spline;
226		for(int i = 0; i <= 2*r; ++i)
227		p[i] = spline(T(i-r));
228		ArrayVector<double> roots;
229		polynomialRealRoots(p, roots);
230		for(unsigned int i = 0; i < roots.size(); ++i)
231		if(VIGRA_CSTD::fabs(roots[i]) < 1.0)
232		res.push_back(roots[i]);
233		}
234		return res;
	217	ArrayVector<double>
	218	BSplineBase<ORDER, T>::getPrefilterCoefficients()
	219	{
	220	static const double coeffs[18][8] = {
	221	{ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 },
	222	{ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 },
	223	{ -0.17157287525380971, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 },
	224	{ -0.26794919243112281, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 },
	225	{ -0.36134122590022018, -0.01372542929733912, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 },
	226	{ -0.43057534709997379, -0.04309628820326465, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 },
	227	{ -0.48829458930304398, -0.081679271076237972, -0.0014141518083258175, 0.0, 0.0, 0.0, 0.0, 0.0 },
	228	{ -0.53528043079643672, -0.1225546151923274, -0.0091486948096082786, 0.0, 0.0, 0.0, 0.0, 0.0 },
	229	{ -0.57468690924876631, -0.16303526929728085, -0.023632294694844857, -0.00015382131064169087, 0.0, 0.0, 0.0, 0.0 },
	230	{ -0.60799738916862989, -0.20175052019315337, -0.043222608540481752, -0.0021213069031808186, 0.0, 0.0, 0.0, 0.0 },
	231	{ -0.63655066396942439, -0.2381827983775629, -0.065727033228308585, -0.0075281946755486927, -1.6982762823274658e-5, 0.0, 0.0, 0.0 },
	232	{ -0.66126606890072925, -0.27218034929478602, -0.089759599793713341, -0.016669627366234657, -0.00051055753444650205, 0.0, 0.0, 0.0 },
	233	{ -0.68286488419772362, -0.30378079328825425, -0.11435052002713579, -0.028836190198663809, -0.0025161662172613372, -1.8833056450639017e-6, 0.0, 0.0 },
	234	{ -0.70189425181681642, -0.33310723293062366, -0.13890111319431958, -0.043213866740363663, -0.0067380314152449142, -0.00012510011321441875, 0.0, 0.0 },
	235	{ -0.71878378723997516, -0.3603190719169625, -0.1630335147992984, -0.059089482194831018, -0.013246756734847919, -0.00086402404095333829, -2.0913096775275374e-7, 0.0 },
	236	{ -0.73387257168487741, -0.38558573427843323, -0.18652010845096478, -0.075907592047668185, -0.02175206579654047, -0.0028011514820764556, -3.093568045147443e-5, 0.0 },
	237	{ -0.747432387772212103, -0.409073604757528353, -0.29228719338953817, -9.32547189803214355e-2 -3.18677061204386616e-2, -6.25840678512839046e-3, -3.01565363306955866e-4, -2.32324863642097035e-8 },
	238	{ -0.75968322407189071, -0.43093965318039579, -0.23108984359927232, -0.1108289933162471, -0.043213911456684129, -0.011258183689471605, -0.0011859331251521767, -7.6875625812546846e-6 }
	239	};
	240	return ArrayVector<double>(coeffs[ORDER], coeffs[ORDER]+ORDER/2);
235	241	}
236	242
237	243	template <int ORDER, class T>

314	320	template <class U, int N>
315	321	autodiff::DualVector<U, N> operator()(autodiff::DualVector<U, N> const & x) const
316	322	{
317		return x < 0.5 && -0.5 <= x
	323	return x < 0.5 && -0.5 <= x
318	324	? autodiff::DualVector<U, N>(1.0)
319	325	: autodiff::DualVector<U, N>(0.0);
320	326	}

339	345	}
340	346
341	347	typedef T WeightMatrix[1][1];
342
	348
343	349	static WeightMatrix const & weights()
344	350	{
345	351	return weightMatrix_;

408	414	autodiff::DualVector<U, N> operator()(autodiff::DualVector<U, N> x) const
409	415	{
410	416	x = abs(x);
411		return x < 1.0
	417	return x < 1.0
412	418	? 1.0 - x
413	419	: autodiff::DualVector<U, N>(0.0);
414	420	}

531	537	autodiff::DualVector<U, N> operator()(autodiff::DualVector<U, N> x) const
532	538	{
533	539	x = abs(x);
534		return x < 0.5
	540	return x < 0.5
535	541	? 0.75 - x*x
536		: x < 1.5
	542	: x < 1.5
537	543	? 0.5 * sq(1.5 - x)
538	544	: autodiff::DualVector<U, N>(0.0);
539	545	}

579	585	ArrayVector<double> BSpline<2, T>::prefilterCoefficients_(1, 2.0*M_SQRT2 - 3.0);
580	586
581	587	template <class T>
582		typename BSpline<2, T>::WeightMatrix BSpline<2, T>::weightMatrix_ =
	588	typename BSpline<2, T>::WeightMatrix BSpline<2, T>::weightMatrix_ =
583	589	{{ 0.125, 0.75, 0.125},
584	590	{-0.5, 0.0, 0.5},
585	591	{ 0.5, -1.0, 0.5}};

736	742	ArrayVector<double> BSpline<3, T>::prefilterCoefficients_(1, VIGRA_CSTD::sqrt(3.0) - 2.0);
737	743
738	744	template <class T>
739		typename BSpline<3, T>::WeightMatrix BSpline<3, T>::weightMatrix_ =
	745	typename BSpline<3, T>::WeightMatrix BSpline<3, T>::weightMatrix_ =
740	746	{{ 1.0 / 6.0, 2.0 / 3.0, 1.0 / 6.0, 0.0},
741	747	{-0.5, 0.0, 0.5, 0.0},
742	748	{ 0.5, -1.0, 0.5, 0.0},

891	897	protected:
892	898	result_type exec(first_argument_type x, second_argument_type derivative_order) const;
893	899
894		static ArrayVector<double> calculatePrefilterCoefficients()
895		{
896		ArrayVector<double> b(2);
897		// -19 + 4sqrt(19) + 2sqrt(2(83 - 19sqrt(19)))
898		b[0] = -0.361341225900220177092212841325;
899		// -19 - 4sqrt(19) + 2sqrt(2(83 + 19sqrt(19)))
900		b[1] = -0.013725429297339121360331226939;
901		return b;
902		}
903
904	900	unsigned int derivativeOrder_;
905	901	static ArrayVector<double> prefilterCoefficients_;
906	902	static WeightMatrix weightMatrix_;
907	903	};
908	904
909	905	template <class T>
910		ArrayVector<double> BSpline<4, T>::prefilterCoefficients_(calculatePrefilterCoefficients());
911
912		template <class T>
913		typename BSpline<4, T>::WeightMatrix BSpline<4, T>::weightMatrix_ =
	906	ArrayVector<double> BSpline<4, T>::prefilterCoefficients_(BSplineBase<4, T>::getPrefilterCoefficients());
	907
	908	template <class T>
	909	typename BSpline<4, T>::WeightMatrix BSpline<4, T>::weightMatrix_ =
914	910	{{ 1.0/384.0, 19.0/96.0, 115.0/192.0, 19.0/96.0, 1.0/384.0},
915	911	{-1.0/48.0, -11.0/24.0, 0.0, 11.0/24.0, 1.0/48.0},
916	912	{ 1.0/16.0, 1.0/4.0, -5.0/8.0, 1.0/4.0, 1.0/16.0},

1014	1010	: x < -0.5
1015	1011	? -4.0
1016	1012	: 6.0
1017		: x < 0.5
	1013	: x < 0.5
1018	1014	? 6.0
1019	1015	: x < 1.5
1020	1016	? -4.0

1118	1114	protected:
1119	1115	result_type exec(first_argument_type x, second_argument_type derivative_order) const;
1120	1116
1121		static ArrayVector<double> calculatePrefilterCoefficients()
1122		{
1123		ArrayVector<double> b(2);
1124		// -(13/2) + sqrt(105)/2 + sqrt(1/2((135 - 13sqrt(105))))
1125		b[0] = -0.430575347099973791851434783493;
1126		// (1/2)((-13) - sqrt(105) + sqrt(2((135 + 13*sqrt(105)))))
1127		b[1] = -0.043096288203264653822712376822;
1128		return b;
1129		}
1130
1131	1117	unsigned int derivativeOrder_;
1132	1118	static ArrayVector<double> prefilterCoefficients_;
1133	1119	static WeightMatrix weightMatrix_;
1134	1120	};
1135	1121
1136	1122	template <class T>
1137		ArrayVector<double> BSpline<5, T>::prefilterCoefficients_(calculatePrefilterCoefficients());
1138
1139		template <class T>
1140		typename BSpline<5, T>::WeightMatrix BSpline<5, T>::weightMatrix_ =
	1123	ArrayVector<double> BSpline<5, T>::prefilterCoefficients_(BSplineBase<5, T>::getPrefilterCoefficients());
	1124
	1125	template <class T>
	1126	typename BSpline<5, T>::WeightMatrix BSpline<5, T>::weightMatrix_ =
1141	1127	{{ 1.0/120.0, 13.0/60.0, 11.0/20.0, 13.0/60.0, 1.0/120.0, 0.0},
1142	1128	{-1.0/24.0, -5.0/12.0, 0.0, 5.0/12.0, 1.0/24.0, 0.0},
1143	1129	{ 1.0/12.0, 1.0/6.0, -0.5, 1.0/6.0, 1.0/12.0, 0.0},

1348	1334	{
1349	1335	return prefilterCoefficients_;
1350	1336	}
1351
	1337
1352	1338	protected:
1353	1339	static ArrayVector<double> prefilterCoefficients_;
1354	1340	};

+31

-3

include/vigra/stdconvolution.hxx less more

50	50	template <class ARITHTYPE>
51	51	class Kernel2D;
52	52
53		/** \addtogroup CommonConvolutionFilters
	53	/** \addtogroup ConvolutionFilters
54	54	*/
55	55	//@{
56	56

854	854	{
855	855	if(this != &k)
856	856	{
857		kernel_ = k.kernel_;
	857	kernel_ = k.kernel_;
858	858	left_ = k.left_;
859	859	right_ = k.right_;
860	860	norm_ = k.norm_;
861		border_treatment_ = k.border_treatment_;
	861	border_treatment_ = k.border_treatment_;
862	862	}
863	863	return *this;
864	864	}

1146	1146	Kernel2D & initExplicitly(Diff2D const & upperleft, Diff2D const & lowerright)
1147	1147	{
1148	1148	return initExplicitly(Shape2(upperleft), Shape2(lowerright));
	1149	}
	1150
	1151	/** Init the kernel by providing a BasicImage with the kernel values.
	1152
	1153	The kernel's origin is placed at the center of the given image.
	1154	The norm is set to the sum of the image values.
	1155
	1156	<b> Preconditions:</b>
	1157
	1158	odd image width and height;
	1159	*/
	1160	Kernel2D & initExplicitly(BasicImage<value_type> const & image)
	1161	{
	1162	vigra_precondition(image.width() % 2 != 0 && image.height() % 2 != 0,
	1163	"Kernel2D::initExplicitly(): kernel sizes must be odd.");
	1164
	1165	left_ = Point2D((image.width() - 1) / -2, (image.height() - 1) / -2);
	1166	right_ = Point2D((image.width() - 1) / 2, (image.height() - 1) / 2);
	1167
	1168	norm_ = 0;
	1169	for (auto iter = image.begin(); iter != image.end(); ++iter)
	1170	{
	1171	norm_ += *iter;
	1172	}
	1173
	1174	kernel_ = image;
	1175
	1176	return *this;
1149	1177	}
1150	1178
1151	1179	/** Coordinates of the upper left corner of the kernel.

+26

-23

include/vigra/threadpool.hxx less more

47	47	namespace vigra
48	48	{
49	49
50		/** \addtogroup ParallelProcessing Functions and classes for parallel processing.
	50	/** \addtogroup ParallelProcessing
51	51	*/
52	52
53	53	//@{

381	381	/********************************************************/
382	382
383	383	// nItems must be either zero or std::distance(iter, end).
	384	// NOTE: the redundancy of nItems and iter,end here is due to the fact that, for forward iterators,
	385	// computing the distance from iterators is costly, and, for input iterators, we might not know in advance
	386	// how many items there are (e.g., stream iterators).
384	387	template<class ITER, class F>
385	388	inline void parallel_foreach_impl(
386	389	ThreadPool & pool,

482	485	F && f,
483	486	std::input_iterator_tag
484	487	){
485		size_t num_items = 0;
	488	std::ptrdiff_t num_items = 0;
486	489	std::vector<threading::future<void> > futures;
487	490	for (; iter != end; ++iter)
488	491	{

510	513	F && f,
511	514	const std::ptrdiff_t nItems = 0
512	515	){
513		size_t n = 0;
	516	std::ptrdiff_t n = 0;
514	517	for (; begin != end; ++begin)
515	518	{
516	519	f(0, *begin);

520	523	}
521	524
522	525	/** \brief Apply a functor to all items in a range in parallel.
523
524		Create a thread pool (or use an existing one) to apply the functor \arg f
525		to all items in the range <tt>[begin, end)</tt> in parallel. \arg f must
526		be callable with two arguments of type <tt>size_t</tt> and <tt>T</tt>, where
527		the first argument is the thread index (starting at 0) and T is convertible
528		from the iterator's <tt>reference_type</tt> (i.e. the result of <tt>*begin</tt>).
529
530		If the iterators are forward iterators (<tt>std::forward_iterator_tag</tt>), you
531		can provide the optional argument <tt>nItems</tt> to avoid the a
532		<tt>std::distance(begin, end)</tt> call to compute the range's length.
533
534		Parameter <tt>nThreads</tt> controls the number of threads. <tt>parallel_foreach</tt>
535		will split the work into about three times as many parallel tasks.
536		If <tt>nThreads = ParallelOptions::Auto</tt>, the number of threads is set to
537		the machine default (<tt>std::thread::hardware_concurrency()</tt>).
538
539		If <tt>nThreads = 0</tt>, the function will not use threads,
540		but will call the functor sequentially. This can also be enforced by setting the
541		preprocessor flag <tt>VIGRA_SINGLE_THREADED</tt>, ignoring the value of
542		<tt>nThreads</tt> (useful for debugging).
543	526
544	527	<b> Declarations:</b>
545	528

574	557	F && f);
575	558	}
576	559	\endcode
	560
	561	Create a thread pool (or use an existing one) to apply the functor \arg f
	562	to all items in the range <tt>[begin, end)</tt> in parallel. \arg f must
	563	be callable with two arguments of type <tt>size_t</tt> and <tt>T</tt>, where
	564	the first argument is the thread index (starting at 0) and T is convertible
	565	from the iterator's <tt>reference_type</tt> (i.e. the result of <tt>*begin</tt>).
	566
	567	If the iterators are forward iterators (<tt>std::forward_iterator_tag</tt>), you
	568	can provide the optional argument <tt>nItems</tt> to avoid the a
	569	<tt>std::distance(begin, end)</tt> call to compute the range's length.
	570
	571	Parameter <tt>nThreads</tt> controls the number of threads. <tt>parallel_foreach</tt>
	572	will split the work into about three times as many parallel tasks.
	573	If <tt>nThreads = ParallelOptions::Auto</tt>, the number of threads is set to
	574	the machine default (<tt>std::thread::hardware_concurrency()</tt>).
	575
	576	If <tt>nThreads = 0</tt>, the function will not use threads,
	577	but will call the functor sequentially. This can also be enforced by setting the
	578	preprocessor flag <tt>VIGRA_SINGLE_THREADED</tt>, ignoring the value of
	579	<tt>nThreads</tt> (useful for debugging).
577	580
578	581	<b>Usage:</b>
579	582

+24

-0

include/vigra/tinyvector.hxx less more

2336	2336	}
2337	2337	return res;
2338	2338	}
	2339
	2340	/** \brief Round up values to the nearest power of 2.
	2341	Implemented only for UInt32
	2342	*/
	2343	template<int SIZE>
	2344	inline TinyVector<UInt32,SIZE> ceilPower2(vigra::TinyVector<UInt32,SIZE> const & t)
	2345	{
	2346	TinyVector<UInt32,SIZE> res(SkipInitialization);
	2347	for( size_t k = 0; k < SIZE; k++)
	2348	res[k] = ceilPower2(t[k]);
	2349	return res;
	2350	}
	2351
	2352	/** \brief Round down values to the nearest power of 2.
	2353	Implemented only for UInt32
	2354	*/
	2355	template<int SIZE>
	2356	inline TinyVector<UInt32,SIZE> floorPower2(vigra::TinyVector<UInt32,SIZE> const & t)
	2357	{
	2358	TinyVector<UInt32, SIZE> res(SkipInitialization);
	2359	for( size_t k = 0; k < SIZE; k++)
	2360	res[k] = floorPower2(t[k]);
	2361	return res;
	2362	}
2339	2363
2340	2364	template<class V,int SIZE>
2341	2365	inline

+15

-12

include/vigra/transformimage.hxx less more

95	95	/** \brief Apply unary point transformation to each pixel.
96	96
97	97	After the introduction of arithmetic and algebraic \ref MultiMathModule "array expressions",
98		this function is rarely needed. Moreover, \ref transformMultiArray() provides the
	98	this function is rarely needed. Moreover, \ref transformMultiArray() provides the
99	99	same functionality for arbitrary dimensional arrays.
100	100
101	101	The transformation given by the functor is applied to every source

154	154	MultiArray<2, float> src(100, 200),
155	155	dest(100, 200);
156	156	...
157
	157
158	158	transformImage(src, dest, &std::sqrt );
159	159	\endcode
160	160

185	185
186	186	\endcode
187	187	\deprecatedEnd
188
	188
189	189	\see TransformFunctor, MultiMathModule, \ref FunctorExpressions
190	190	*/
191	191	doxygen_overloaded_function(template <...> void transformImage)

242	242	(i.e., where the mask is non-zero).
243	243
244	244	After the introduction of arithmetic and algebraic \ref MultiMathModule "array expressions",
245		this function is rarely needed. Moreover, \ref combineTwoMultiArrays() provides the
	245	this function is rarely needed. Moreover, \ref combineTwoMultiArrays() provides the
246	246	same functionality for arbitrary dimensional arrays.
247	247
248	248	The transformation given by the functor is applied to every source

310	310
311	311	\code
312	312	#include <cmath> // for sqrt()
313
	313
314	314	MultiArray<2, unsigned char> mask(100, 200),
315	315	MultiArray<2, float> src(100, 200),
316	316	dest(100, 200);
317	317	... // fill src and mask
318
	318
319	319	transformImageIf(src, mask, dest, &std::sqrt );
320	320	\endcode
321	321

348	348
349	349	\endcode
350	350	\deprecatedEnd
351
	351
352	352	\see TransformFunctor, MultiMathModule, \ref FunctorExpressions
353	353	*/
354	354	doxygen_overloaded_function(template <...> void transformImageIf)

430	430	\code
431	431	namespace vigra {
432	432	template <class T1, class S1,
433		class T2, class S2,
	433	class T2, class S2,
434	434	class Functor>
435	435	void
436	436	gradientBasedTransform(MultiArrayView<2, T1, S1> const & src,
437		MultiArrayView<2, T2, S2> dest,
	437	MultiArrayView<2, T2, S2> dest,
438	438	Functor const & grad);
439	439	}
440	440	\endcode

503	503
504	504	\endcode
505	505	\deprecatedEnd
506
	506
507	507	\see TransformFunctor, MultiMathModule, \ref FunctorExpressions
508	508	*/
509	509	doxygen_overloaded_function(template <...> void gradientBasedTransform)

823	823	and <tt>offset = dest_min / scale - src_min</tt>. As a result,
824	824	the pixel values <tt>src_max</tt>, <tt>src_min</tt> in the source image
825	825	are mapped onto <tt>dest_max</tt>, <tt>dest_min</tt> respectively.
826		This works for scalar as well as vector pixel types. Instead of
	826	This works for scalar as well as vector pixel types. Instead of
827	827	<tt>src_min</tt> and <tt>src_max</tt>, you may also pass a functor
828		\ref FindMinMax.
	828	\ref FindMinMax.
829	829
830	830	<b> Declaration:</b>
831	831

938	938	/********************************************************/
939	939
940	940	/** \brief Threshold an image.
	941
	942	<b>Note:</b> Nowadays, it is probably easier to perform thresholding by means of
	943	C++ 11 lambda functions or \ref MultiMathModule "array expressions".
941	944
942	945	If a source pixel is above or equal the lower and below
943	946	or equal the higher threshold (i.e. within the closed interval

+1

-2

include/vigra/tv_filter.hxx less more

342	342	double alpha_par, double beta_par, double sigma_par, double rho_par, double K_par){
343	343
344	344	using namespace multi_math;
345		int width=data.shape(0),height=data.shape(1);
346	345
347	346	MultiArray<2,double> smooth(data.shape()),tmp(data.shape());
348	347	vigra::Kernel1D<double> gauss;

763	762	//@}
764	763	} // closing namespace vigra
765	764
766		#endif // VIGRA_TV_FILTER_HXX⏎
	765	#endif // VIGRA_TV_FILTER_HXX

+72

-42

include/vigra/unittest.hxx less more

44	44	#include <exception> // for exception, bad_exception
45	45	#include <stdexcept>
46	46	#include <iostream>
	47	#include <iomanip>
47	48	#include <limits>
48	49	#include <cfloat>
49	50	#include <cmath>

146	147
147	148	#define failTest VIGRA_ERROR
148	149
	150	#ifdef __GNUC__
	151	#pragma GCC diagnostic push
	152	#pragma GCC diagnostic ignored "-Wsign-compare"
	153	#endif
	154
149	155	namespace vigra {
150	156
151	157	class test_suite;
152	158
153	159	namespace detail {
	160
	161	typedef std::pair<std::string, int> CheckpointType;
154	162
155	163	struct errstream
156	164	{

160	168	errstream & operator<<(T t) { buf << t; return *this; }
161	169	};
162	170
163		inline std::string & exception_checkpoint()
164		{
165		static std::string test_checkpoint_;
	171	inline CheckpointType & exception_checkpoint()
	172	{
	173	static CheckpointType test_checkpoint_;
166	174	return test_checkpoint_;
167	175	}
168	176

171	179	const char * name, const char * info )
172	180	{
173	181	os << "Unexpected " << name << " " << info << "\n";
174		if(exception_checkpoint().size() > 0)
175		{
176		os << "Last checkpoint: " << exception_checkpoint() << "\n";
	182	if(exception_checkpoint().first.size() > 0)
	183	{
	184	os << " (occured after line " << exception_checkpoint().second << " in file '" << exception_checkpoint().first << "')\n";
177	185	}
178	186	}
179	187

446	454	};
447	455
448	456	inline void
449		checkpoint_impl(const char * message, const char * file, int line)
450		{
451		detail::errstream buf;
452		buf << message << " (" << file <<":" << line << ")";
453		exception_checkpoint() = buf.str();
	457	checkpoint_impl(const char * file, int line)
	458	{
	459	exception_checkpoint().first = file;
	460	exception_checkpoint().second = line;
454	461	}
455	462
456	463	inline void
457	464	should_impl(bool predicate, const char * message, const char * file, int line)
458	465	{
459		checkpoint_impl(message, file, line);
	466	checkpoint_impl(file, line);
460	467	if(!predicate)
461	468	{
462	469	detail::errstream buf;

475	482	void
476	483	sequence_equal_impl(Iter1 i1, Iter1 end1, Iter2 i2, const char * file, int line)
477	484	{
	485	checkpoint_impl(file, line);
478	486	for(int counter = 0; i1 != end1; ++i1, ++i2, ++counter)
479	487	{
480	488	if(i1 != i2)
481	489	{
482	490	detail::errstream buf;
483		buf << "Sequence items differ at index " << counter <<
	491	buf << "Sequences differ at index " << counter <<
484	492	" ["<< i1 << " != " << i2 << "]";
485	493	should_impl(false, buf.str().c_str(), file, line);
486	494	}

605	613	template <class T1, class T2, class T3>
606	614	void
607	615	tolerance_equal_impl(T1 left, T2 right, T3 epsilon,
608		const char * message, const char * file, int line, ScalarType)
609		{
610		detail::errstream buf;
611		buf << message << " [" << left << " != " << right << "]";
612
	616	const char * message, const char * file, int line, ScalarType, std::ptrdiff_t index = -1)
	617	{
	618	checkpoint_impl(file, line);
613	619	close_at_tolerance<T3> fcomparator( epsilon );
614		bool compare = fcomparator ( (T3)left , (T3)right );
615		should_impl(compare, buf.str().c_str(), file, line);
616
	620	if (!fcomparator((T3)left, (T3)right))
	621	{
	622	detail::errstream buf;
	623	if(index >= 0)
	624	buf << "Sequences differ at index " << index;
	625	buf << message << " [" << std::setprecision(17) << left << " != " << right << " at tolerance " << epsilon << "]";
	626	should_impl(false, buf.str().c_str(), file, line);
	627	}
617	628	}
618	629
619	630	template <class T1, class T2, class T3>
620	631	void
621	632	tolerance_equal_impl(T1 left, T2 right, T3 epsilon,
622		const char * message, const char * file, int line, VectorType)
623		{
624		detail::errstream buf;
625		buf << message << " [" << left << " != " << right << "]";
626
627		bool compare = true;
	633	const char * message, const char * file, int line, VectorType, std::ptrdiff_t index = -1)
	634	{
	635	checkpoint_impl(file, line);
628	636	for(unsigned int i=0; i<epsilon.size(); ++i)
629	637	{
630	638	close_at_tolerance<typename T3::value_type> fcomparator( epsilon[i] );
631		compare = compare && fcomparator ( left[i] , right[i] );
632		}
633		should_impl(compare, buf.str().c_str(), file, line);
	639	if (!fcomparator(left[i], right[i]))
	640	{
	641	detail::errstream buf;
	642	if(index >= 0)
	643	{
	644	buf << "Sequences differ at index " << index << ", element " << i;
	645	}
	646	else
	647	{
	648	buf << "Vectors differ at element " << i;
	649	}
	650	buf << message << " [" << std::setprecision(17) << left << " != " << right << " at tolerance " << epsilon << "]";
	651	should_impl(false, buf.str().c_str(), file, line);
	652	}
	653	}
634	654	}
635	655
636	656	template <class T1, class T2, class T3>

647	667	{
648	668	for(int counter = 0; i1 != end1; ++i1, ++i2, ++counter)
649	669	{
650		detail::errstream buf;
651		buf << "Sequence items differ at index " << counter;
652		tolerance_equal_impl(i1, i2, epsilon, buf.str().c_str(), file, line, typename FloatTraits<T>::ScalarOrVector());
	670	tolerance_equal_impl(i1, i2, epsilon, "", file, line, typename FloatTraits<T>::ScalarOrVector(), counter);
653	671	}
654	672	}
655	673

657	675	void
658	676	equal_impl(Left left, Right right, const char * message, const char * file, int line)
659	677	{
660		detail::errstream buf;
661		buf << message << " [" << left << " != " << right << "]";
662		should_impl(left == right, buf.str().c_str(), file, line);
	678	checkpoint_impl(file, line);
	679	if (left != right)
	680	{
	681	detail::errstream buf;
	682	buf << message << " [" << left << " != " << right << "]";
	683	should_impl(false, buf.str().c_str(), file, line);
	684	}
663	685	}
664	686
665	687	template <class Left, class Right>
666	688	void
667	689	equal_impl(Left * left, Right * right, const char * message, const char * file, int line)
668	690	{
669		detail::errstream buf;
670		buf << message << " [" << (void)left << " != " << (void)right << "]";
671		should_impl(left == right, buf.str().c_str(), file, line);
	691	checkpoint_impl(file, line);
	692	if (left != right)
	693	{
	694	detail::errstream buf;
	695	buf << message << " [" << (void)left << " != " << (void)right << "]";
	696	should_impl(false, buf.str().c_str(), file, line);
	697	}
672	698	}
673	699
674	700	inline void

928	954
929	955	int init()
930	956	{
931		exception_checkpoint() = "";
	957	exception_checkpoint().first = "";
932	958	report_ = "";
933	959	int failed = 0;
934	960

1037	1063	return 0;
1038	1064
1039	1065	report_ = "";
1040		exception_checkpoint() = "";
	1066	exception_checkpoint().first = "";
1041	1067
1042	1068	detail::errstream buf;
1043	1069	buf << "\nFailure in " << name() << "\n";

1088	1114	return 0;
1089	1115
1090	1116	report_ = "";
1091		exception_checkpoint() = "";
	1117	exception_checkpoint().first = "";
1092	1118
1093	1119	detail::errstream buf;
1094	1120	buf << "\nFailure in " << name() << "\n";

1174	1200
1175	1201	#endif
1176	1202
	1203	#ifdef __GNUC__
	1204	#pragma GCC diagnostic pop
	1205	#endif
	1206
1177	1207
1178	1208	#endif /* VIGRA_UNIT_TEST_HPP */

+76

-4

include/vigra/utilities.hxx less more

45	45	#include <string>
46	46	#include <sstream>
47	47	#include <cctype>
	48	#include <tuple>
48	49
49	50	/! \file /
50	51

155	156	/** Emulate the 'finally' keyword as known from Python and other languages.
156	157
157	158	This macro improves upon the famous
158		<a href="http://en.wikipedia.org/wiki/Resource_Acquisition_Is_Initialization">Resource Acquisition Is Initialization</a> idiom, where a resource (e.g. heap memory or a mutex) is automatically free'ed when program execution leaves the current scope. Normally, this is implemented by calling a suitable function in the destructor of a dedicated helper class (e.g. <tt>std::unique_ptr</tt> or <tt>std::lock_guard<std::mutex></tt>).
159
160		Traditionally, a separate helper class has to be implemented for each kind of resource to be handled. In contrast, the macro <tt>VIGRA_FINALLY</tt> creates such a class on the fly by means of an embedded lambda expression.
	159	<a href="http://en.wikipedia.org/wiki/Resource_Acquisition_Is_Initialization">Resource Acquisition Is Initialization</a> idiom, where a resource (e.g. heap memory or a mutex) is automatically free'ed when program execution leaves the current scope. This is normally achieved by placing a call which releases the resource into the destructor of a dedicated helper class (e.g. <tt>std::unique_ptr</tt> or <tt>std::lock_guard<std::mutex></tt>).
	160
	161	Traditionally, a separate helper class is needed for every type of resource to be handled. In contrast, the macro <tt>VIGRA_FINALLY</tt> creates such a class on the fly by means of an embedded lambda expression.
161	162
162	163	<b>Usage:</b>
163	164

200	201	assert(i == 5); // 'finally' code was executed in reversed order at end-of-scope
201	202	\endcode
202	203
203		This idea was popularized by Marko Tintor in "<a href="http://blog.memsql.com/c-error-handling-with-auto/">The Auto Macro: A Clean Approach to C++ Error Handling</a>".
	204	This idea was popularized by Marko Tintor in <a href="http://blog.memsql.com/c-error-handling-with-auto/">The Auto Macro: A Clean Approach to C++ Error Handling</a>.
204	205	*/
205	206	#define VIGRA_FINALLY(destructor) \
206	207	VIGRA_FINALLY_IMPL(destructor, __COUNTER__)

215	216	}
216	217
217	218	}
	219
	220	namespace vigra
	221	{
	222	namespace detail
	223	{
	224	template <typename TPL, size_t N, typename FUNCTOR>
	225	struct for_each_in_tuple_impl
	226	{
	227	typedef for_each_in_tuple_impl<TPL, N-1, FUNCTOR> ForEachRecursion;
	228
	229	void operator()(TPL && t, FUNCTOR && f) const
	230	{
	231	ForEachRecursion()(std::forward<TPL>(t), std::forward<FUNCTOR>(f));
	232	f(std::get<N-1>(std::forward<TPL>(t)));
	233	}
	234	};
	235
	236	template <typename TPL, typename FUNCTOR>
	237	struct for_each_in_tuple_impl<TPL, 0, FUNCTOR>
	238	{
	239	void operator()(TPL && t, FUNCTOR && f) const
	240	{}
	241	};
	242	} // namespace detail
	243
	244	/**
	245	* The for_each_in_tuple function calls the functor f on all elements of the tuple t.
	246	* For each element type in the tuple, the functor must have an appropriate overload of operator().
	247	*
	248	* Example:
	249	* \code
	250	* #include <iostream>
	251	* #include <tuple>
	252	* #include <vigra/utilities.hxx>
	253	*
	254	* struct print
	255	* {
	256	* template <typename T>
	257	* void operator()(T const & t) const
	258	* {
	259	* std::cout << t << std::endl;
	260	* }
	261	* };
	262	*
	263	* struct add_one
	264	* {
	265	* template <typename T>
	266	* void operator()(T & t) const
	267	* {
	268	* t += 1;
	269	* }
	270	* };
	271	*
	272	* int main()
	273	* {
	274	* std::tuple<int, double, size_t> tpl(-5, 0.4, 10);
	275	* vigra::for_each_in_tuple(tpl, add_one());
	276	* vigra::for_each_in_tuple(tpl, print());
	277	* }
	278	* \endcode
	279	*/
	280	template <typename TPL, typename FUNCTOR>
	281	void for_each_in_tuple(TPL && t, FUNCTOR && f)
	282	{
	283	typedef typename std::decay<TPL>::type UNQUALIFIED_TPL;
	284	typedef detail::for_each_in_tuple_impl<TPL, std::tuple_size<UNQUALIFIED_TPL>::value, FUNCTOR> ForEachImpl;
	285
	286	ForEachImpl()(std::forward<TPL>(t), std::forward<FUNCTOR>(f));
	287	}
	288
	289	} // namespace vigra
218	290
219	291	/** \page Utilities Utilities
220	292	Basic helper functionality needed throughout.

+3

-3

include/vigra/vector_distance.hxx less more

307	307
308	308	} // namespace detail
309	309
310		/** \addtogroup MultiArrayDistanceTransform
	310	/** \addtogroup DistanceTransform
311	311	*/
312	312	//@{
313	313

386	386	transformMultiArray( source, dest,
387	387	ifThenElse( Arg1() != Param(0), Param(maxDist), Param(rzero) ));
388	388
389		for(int d = 0; d < N; ++d )
	389	for(unsigned d = 0; d < N; ++d )
390	390	{
391	391	Navigator nav( dest.traverser_begin(), dest.shape(), d);
392	392	for( ; nav.hasMore(); nav++ )

495	495
496	496	T2 maxDist(2sum(labels.shape()pixelPitch));
497	497	dest = maxDist;
498		for( int d = 0; d < N; ++d )
	498	for( unsigned d = 0; d < N; ++d )
499	499	{
500	500	LabelNavigator lnav( labels.traverser_begin(), labels.shape(), d );
501	501	DNavigator dnav( dest.traverser_begin(), dest.shape(), d );

+1

-1

include/vigra/visit_border.hxx less more

89	89	class Shape, class Visitor>
90	90	static void exec(const MultiArrayView<0, Data, S1>& u_data, MultiArrayView<0, Label, S2> u_labels,
91	91	const MultiArrayView<0, Data, S1>& v_data, MultiArrayView<0, Label, S2> v_labels,
92		const Shape& block_difference, NeighborhoodType neighborhood, Visitor visitor)
	92	const Shape& block_difference, NeighborhoodType, Visitor visitor)
93	93	{
94	94	visitor(u_data(0), u_labels(0), v_data(0), v_labels(0), block_difference);
95	95	}

+45

-45

include/vigra/voxelneighborhood.hxx less more

193	193	static unsigned int b[];
194	194	static unsigned int c[];
195	195	static Direction bd[43][6];
196		static Direction bc[43][3];
	196	static Direction bc[43][4];
197	197	static Diff3D d[];
198	198	static Diff3D rd[][6];
199	199	};

415	415	};
416	416
417	417	template <int DUMMY>
418		Direction NeighborCode3D::StaticData<DUMMY>::bc[43][3] = {
419		{ InFront, North, West}, // 0 - NotAtBorder
420		{ InFront, North, West}, // 1 - AtRightBorder
421		{ InFront, North, Error}, // 2 - AtLeftBorder
422		{ Error, Error, Error},
423		{ InFront, West, Error}, // 4 - AtTopBorder
424		{ InFront, West, Error}, // 5 - AtTopRightBorder
425		{ InFront, Error,Error}, // 6 - AtTopLeftBorder
426		{ Error, Error, Error},
427		{ InFront, North, West}, // 8 - AtBottomBorder
428		{ InFront, North, West}, // 9 - AtBottomRightBorder
429		{ InFront, North, Error}, //10- AtBottomLeftBorder
430		{ Error, Error, Error},
431		{ Error, Error, Error},
432		{ Error, Error, Error},
433		{ Error, Error, Error},
434		{ Error, Error, Error},
435		{ North, West, Error}, //16 - AtFrontBorder
436		{ North, West, Error}, //17 - AtFrontRightBorder
437		{ North, Error, Error}, //18 - AtFrontLeftBorder
438		{ Error, Error, Error},
439		{ West, Error, Error}, //20 - AtTopFrontBorder
440		{ West, Error, Error}, //21 - AtTopRightFrontBorder
441		{ Error, Error, Error}, //22 - AtTopLeftFrontBorder
442		{ Error, Error, Error},
443		{ North, West, Error}, //24 - AtBottomFrontBorder
444		{ North, West, Error}, //25 - AtBottomRightFrontBorder
445		{ North, Error, Error}, //26 - AtBottomLeftFrontBorder
446		{ Error, Error, Error},
447		{ Error, Error, Error},
448		{ Error, Error, Error},
449		{ Error, Error, Error},
450		{ Error, Error, Error},
451		{ InFront, North, West}, //32 - AtRearBorder
452		{ InFront, North, West}, //33 - AtRearRightBorder
453		{ InFront, North, Error}, //34 - AtRearLeftBorder
454		{ Error, Error, Error},
455		{ InFront, West, Error}, //36 - AtTopRearBorder
456		{ InFront, West, Error}, //37 - AtTopRightRearBorder
457		{ InFront, Error, Error}, //38 - AtTopLeftRearBorder
458		{ Error, Error, Error},
459		{ InFront, North, West}, //40 - AtBottomRearBorder
460		{ InFront, North, West}, //41 - AtBottomRightRearBorder
461		{ InFront, North, Error} //42 - AtBottomLeftRearBorder
	418	Direction NeighborCode3D::StaticData<DUMMY>::bc[43][4] = {
	419	{ InFront, North, West, Error}, // 0 - NotAtBorder
	420	{ InFront, North, West, Error}, // 1 - AtRightBorder
	421	{ InFront, North, Error, Error}, // 2 - AtLeftBorder
	422	{ Error, Error, Error, Error},
	423	{ InFront, West, Error, Error}, // 4 - AtTopBorder
	424	{ InFront, West, Error, Error}, // 5 - AtTopRightBorder
	425	{ InFront, Error,Error, Error}, // 6 - AtTopLeftBorder
	426	{ Error, Error, Error, Error},
	427	{ InFront, North, West, Error}, // 8 - AtBottomBorder
	428	{ InFront, North, West, Error}, // 9 - AtBottomRightBorder
	429	{ InFront, North, Error, Error}, //10- AtBottomLeftBorder
	430	{ Error, Error, Error, Error},
	431	{ Error, Error, Error, Error},
	432	{ Error, Error, Error, Error},
	433	{ Error, Error, Error, Error},
	434	{ Error, Error, Error, Error},
	435	{ North, West, Error, Error}, //16 - AtFrontBorder
	436	{ North, West, Error, Error}, //17 - AtFrontRightBorder
	437	{ North, Error, Error, Error}, //18 - AtFrontLeftBorder
	438	{ Error, Error, Error, Error},
	439	{ West, Error, Error, Error}, //20 - AtTopFrontBorder
	440	{ West, Error, Error, Error}, //21 - AtTopRightFrontBorder
	441	{ Error, Error, Error, Error}, //22 - AtTopLeftFrontBorder
	442	{ Error, Error, Error, Error},
	443	{ North, West, Error, Error}, //24 - AtBottomFrontBorder
	444	{ North, West, Error, Error}, //25 - AtBottomRightFrontBorder
	445	{ North, Error, Error, Error}, //26 - AtBottomLeftFrontBorder
	446	{ Error, Error, Error, Error},
	447	{ Error, Error, Error, Error},
	448	{ Error, Error, Error, Error},
	449	{ Error, Error, Error, Error},
	450	{ Error, Error, Error, Error},
	451	{ InFront, North, West, Error}, //32 - AtRearBorder
	452	{ InFront, North, West, Error}, //33 - AtRearRightBorder
	453	{ InFront, North, Error, Error}, //34 - AtRearLeftBorder
	454	{ Error, Error, Error, Error},
	455	{ InFront, West, Error, Error}, //36 - AtTopRearBorder
	456	{ InFront, West, Error, Error}, //37 - AtTopRightRearBorder
	457	{ InFront, Error, Error, Error}, //38 - AtTopLeftRearBorder
	458	{ Error, Error, Error, Error},
	459	{ InFront, North, West, Error}, //40 - AtBottomRearBorder
	460	{ InFront, North, West, Error}, //41 - AtBottomRightRearBorder
	461	{ InFront, North, Error, Error} //42 - AtBottomLeftRearBorder
462	462	};
463	463
464	464	template <int DUMMY>

+178

-178

include/vigra/watersheds.hxx less more

305	305	}
306	306	}
307	307
308		/** \addtogroup SeededRegionGrowing Region Segmentation Algorithms
309		Region growing, watersheds, and voronoi tesselation
	308	/** \addtogroup Superpixels
310	309	*/
311	310	//@{
312	311

316	315
317	316	<b>\#include</b> \<vigra/watersheds.hxx\><br>
318	317	Namespace: vigra
319
	318
320	319	\code
321	320	MultiArray<2, float> boundary_indicator(w, h);
322	321	MultiArray<2, int> seeds(boundary_indicator.shape());
323
	322
324	323	// detect all minima in 'boundary_indicator' that are below gray level 22
325	324	generateWatershedSeeds(boundary_indicator, seeds,
326	325	SeedOptions().minima().threshold(22.0));

330	329	{
331	330	public:
332	331	enum DetectMinima { LevelSets, Minima, ExtendedMinima, Unspecified };
333
	332
334	333	double thresh;
335	334	DetectMinima mini;
336
	335
337	336	/**\brief Construct default options object.
338	337	*
339	338	Defaults are: detect minima without thresholding (i.e. all minima).

342	341	: thresh(NumericTraits<double>::max()),
343	342	mini(Minima)
344	343	{}
345
	344
346	345	/** Generate seeds at minima.
347
	346
348	347	Default: true
349	348	*/
350	349	SeedOptions & minima()

352	351	mini = Minima;
353	352	return *this;
354	353	}
355
	354
356	355	/** Generate seeds at minima and minimal plateaus.
357
	356
358	357	Default: false
359	358	*/
360	359	SeedOptions & extendedMinima()

362	361	mini = ExtendedMinima;
363	362	return *this;
364	363	}
365
	364
366	365	/** Generate seeds as level sets.
367
	366
368	367	Note that you must also set a threshold to define which level set is to be used.<br>
369	368	Default: false
370	369	*/

373	372	mini = LevelSets;
374	373	return *this;
375	374	}
376
	375
377	376	/** Generate seeds as level sets at given threshold.
378
	377
379	378	Equivalent to <tt>SeedOptions().levelSet().threshold(threshold)</tt><br>
380	379	Default: false
381	380	*/

385	384	thresh = threshold;
386	385	return *this;
387	386	}
388
	387
389	388	/** Set threshold.
390
	389
391	390	The threshold will be used by both the minima and level set variants
392	391	of seed generation.<br>
393	392	Default: no thresholding

397	396	thresh = threshold;
398	397	return *this;
399	398	}
400
	399
401	400	// check whether the threshold has been set for the target type T
402	401	template <class T>
403	402	bool thresholdIsValid() const
404	403	{
405	404	return thresh < double(NumericTraits<T>::max());
406	405	}
407
	406
408	407	// indicate that this option object is invalid (for internal use in watersheds)
409	408	SeedOptions & unspecified()
410	409	{

422	421	looking for local minima (possibly including minimal plateaus) of the boundaryness,
423	422	of by looking at level sets (i.e. regions where the boundaryness is below a threshold).
424	423	Both methods can also be combined, so that only minima below a threshold are returned.
425		The particular seeding strategy is specified by the <tt>options</tt> object
	424	The particular seeding strategy is specified by the <tt>options</tt> object
426	425	(see \ref SeedOptions).
427
	426
428	427	The pixel type of the input image must be <tt>LessThanComparable</tt>.
429	428	The pixel type of the output image must be large enough to hold the labels for all seeds.
430	429	(typically, you will use <tt>UInt32</tt>). The function will label seeds by consecutive integers
431	430	(starting from 1) and returns the largest label it used.
432
433		Pass \ref vigra::NeighborhoodType "IndirectNeighborhood" or \ref vigra::NeighborhoodType "DirectNeighborhood"
434		(first form of the function)
435		or \ref vigra::EightNeighborCode or \ref vigra::FourNeighborCode (second and third forms) to determine the
436		neighborhood where pixel values are compared.
	431
	432	Pass \ref vigra::NeighborhoodType "IndirectNeighborhood" or \ref vigra::NeighborhoodType "DirectNeighborhood"
	433	(first form of the function)
	434	or \ref vigra::EightNeighborCode or \ref vigra::FourNeighborCode (second and third forms) to determine the
	435	neighborhood where pixel values are compared.
437	436
438	437	<b> Declarations:</b>
439	438

459	458	class Neighborhood = EightNeighborCode>
460	459	unsigned int
461	460	generateWatershedSeeds(SrcIterator upperlefts, SrcIterator lowerrights, SrcAccessor sa,
462		DestIterator upperleftd, DestAccessor da,
	461	DestIterator upperleftd, DestAccessor da,
463	462	Neighborhood neighborhood = EightNeighborCode(),
464	463	SeedOptions const & options = SeedOptions());
465	464	}

472	471	class Neighborhood = EightNeighborCode>
473	472	unsigned int
474	473	generateWatershedSeeds(triple<SrcIterator, SrcIterator, SrcAccessor> src,
475		pair<DestIterator, DestAccessor> dest,
	474	pair<DestIterator, DestAccessor> dest,
476	475	Neighborhood neighborhood = EightNeighborCode(),
477	476	SeedOptions const & options = SeedOptions());
478	477	}

494	493	class Neighborhood>
495	494	unsigned int
496	495	generateWatershedSeeds(SrcIterator upperlefts, SrcIterator lowerrights, SrcAccessor sa,
497		DestIterator upperleftd, DestAccessor da,
498		Neighborhood neighborhood,
	496	DestIterator upperleftd, DestAccessor da,
	497	Neighborhood,
499	498	SeedOptions const & options = SeedOptions())
500	499	{
501	500	using namespace functor;
502	501	typedef typename SrcAccessor::value_type SrcType;
503
504		vigra_precondition(options.mini != SeedOptions::LevelSets \|\|
	502
	503	vigra_precondition(options.mini != SeedOptions::LevelSets \|\|
505	504	options.thresholdIsValid<SrcType>(),
506	505	"generateWatershedSeeds(): SeedOptions.levelSets() must be specified with threshold.");
507
	506
508	507	Diff2D shape = lowerrights - upperlefts;
509	508	BImage seeds(shape);
510
	509
511	510	if(options.mini == SeedOptions::LevelSets)
512	511	{
513	512	transformImage(srcIterRange(upperlefts, lowerrights, sa),

523	522	.allowPlateaus(options.mini == SeedOptions::ExtendedMinima);
524	523	if(options.thresholdIsValid<SrcType>())
525	524	lm_options.threshold(options.thresh);
526
	525
527	526	localMinima(srcIterRange(upperlefts, lowerrights, sa), destImage(seeds),
528	527	lm_options);
529	528	}
530
531		return labelImageWithBackground(srcImageRange(seeds), destIter(upperleftd, da),
	529
	530	return labelImageWithBackground(srcImageRange(seeds), destIter(upperleftd, da),
532	531	Neighborhood::DirectionCount == 8, 0);
533	532	}
534	533

536	535	class DestIterator, class DestAccessor>
537	536	inline unsigned int
538	537	generateWatershedSeeds(SrcIterator upperlefts, SrcIterator lowerrights, SrcAccessor sa,
539		DestIterator upperleftd, DestAccessor da,
	538	DestIterator upperleftd, DestAccessor da,
540	539	SeedOptions const & options = SeedOptions())
541	540	{
542		return generateWatershedSeeds(upperlefts, lowerrights, sa, upperleftd, da,
	541	return generateWatershedSeeds(upperlefts, lowerrights, sa, upperleftd, da,
543	542	EightNeighborCode(), options);
544	543	}
545	544

548	547	class Neighborhood>
549	548	inline unsigned int
550	549	generateWatershedSeeds(triple<SrcIterator, SrcIterator, SrcAccessor> src,
551		pair<DestIterator, DestAccessor> dest,
	550	pair<DestIterator, DestAccessor> dest,
552	551	Neighborhood neighborhood,
553	552	SeedOptions const & options = SeedOptions())
554	553	{
555	554	return generateWatershedSeeds(src.first, src.second, src.third,
556		dest.first, dest.second,
	555	dest.first, dest.second,
557	556	neighborhood, options);
558	557	}
559	558

561	560	class DestIterator, class DestAccessor>
562	561	inline unsigned int
563	562	generateWatershedSeeds(triple<SrcIterator, SrcIterator, SrcAccessor> src,
564		pair<DestIterator, DestAccessor> dest,
	563	pair<DestIterator, DestAccessor> dest,
565	564	SeedOptions const & options = SeedOptions())
566	565	{
567	566	return generateWatershedSeeds(src.first, src.second, src.third,
568		dest.first, dest.second,
	567	dest.first, dest.second,
569	568	EightNeighborCode(), options);
570	569	}
571	570

579	578
580	579	Note: This function is largely obsolete, \ref watershedsMultiArray() should be
581	580	preferred unless top speed is required.
582
	581
583	582	This function implements the union-find version of the watershed algorithms
584	583	described as algorithm 4.7 in
585	584

607	606	class Neighborhood>
608	607	unsigned int
609	608	watershedsUnionFind(MultiArrayView<2, T1, S1> const & src,
610		MultiArrayView<2, T2, S2> dest,
	609	MultiArrayView<2, T2, S2> dest,
611	610	Neighborhood neighborhood = EightNeighborCode());
612	611	}
613	612	\endcode

701	700	class Neighborhood>
702	701	unsigned int
703	702	watershedsUnionFind(SrcIterator upperlefts, SrcIterator lowerrights, SrcAccessor sa,
704		DestIterator upperleftd, DestAccessor da,
	703	DestIterator upperleftd, DestAccessor da,
705	704	Neighborhood neighborhood)
706	705	{
707	706	SImage orientationImage(lowerrights - upperlefts);

728	727	watershedsUnionFind(triple<SrcIterator, SrcIterator, SrcAccessor> src,
729	728	pair<DestIterator, DestAccessor> dest, Neighborhood neighborhood)
730	729	{
731		return watershedsUnionFind(src.first, src.second, src.third,
	730	return watershedsUnionFind(src.first, src.second, src.third,
732	731	dest.first, dest.second, neighborhood);
733	732	}
734	733

738	737	watershedsUnionFind(triple<SrcIterator, SrcIterator, SrcAccessor> src,
739	738	pair<DestIterator, DestAccessor> dest)
740	739	{
741		return watershedsUnionFind(src.first, src.second, src.third,
	740	return watershedsUnionFind(src.first, src.second, src.third,
742	741	dest.first, dest.second);
743	742	}
744	743

749	748	watershedsUnionFind(MultiArrayView<2, T1, S1> const & src,
750	749	MultiArrayView<2, T2, S2> dest, Neighborhood neighborhood)
751	750	{
752		return watershedsUnionFind(srcImageRange(src),
	751	return watershedsUnionFind(srcImageRange(src),
753	752	destImage(dest), neighborhood);
754	753	}
755	754

761	760	{
762	761	vigra_precondition(src.shape() == dest.shape(),
763	762	"watershedsUnionFind(): shape mismatch between input and output.");
764		return watershedsUnionFind(srcImageRange(src),
	763	return watershedsUnionFind(srcImageRange(src),
765	764	destImage(dest));
766	765	}
767	766

775	774	{
776	775	public:
777	776	enum Method { RegionGrowing, UnionFind };
778
	777
779	778	double max_cost, bias;
780	779	SRGType terminate;
781	780	Method method;
782	781	unsigned int biased_label, bucket_count;
783	782	SeedOptions seed_options;
784
785
786
	783
	784
	785
787	786	/** \brief Create options object with default settings.
788	787
789	788	Defaults are: perform complete grow (all pixels are assigned to regions),
790		use standard algorithm, assume that the destination image already contains
	789	use standard algorithm, assume that the destination image already contains
791	790	region seeds.
792	791	*/
793	792	WatershedOptions()

798	797	biased_label(0),
799	798	bucket_count(0),
800	799	seed_options(SeedOptions().unspecified())
801		{}
802
	800	{}
	801
803	802	/** \brief Perform complete grow.
804	803
805	804	That is, all pixels are assigned to regions, without explicit contours
806	805	in between.
807
	806
808	807	Default: true
809	808	*/
810	809	WatershedOptions & completeGrow()

812	811	terminate = SRGType(CompleteGrow \| (terminate & StopAtThreshold));
813	812	return *this;
814	813	}
815
	814
816	815	/** \brief Keep one-pixel wide contour between regions.
817
	816
818	817	Note that this option is unsupported by the turbo algorithm.
819	818
820	819	Default: false

824	823	terminate = SRGType(KeepContours \| (terminate & StopAtThreshold));
825	824	return *this;
826	825	}
827
	826
828	827	/** \brief Set \ref SRGType explicitly.
829
	828
830	829	Default: CompleteGrow
831	830	*/
832	831	WatershedOptions & srgType(SRGType type)

834	833	terminate = type;
835	834	return *this;
836	835	}
837
	836
838	837	/** \brief Stop region growing when the boundaryness exceeds the threshold.
839
	838
840	839	This option may be combined with completeGrow() and keepContours().
841
	840
842	841	Default: no early stopping
843	842	*/
844	843	WatershedOptions & stopAtThreshold(double threshold)

847	846	max_cost = threshold;
848	847	return *this;
849	848	}
850
	849
851	850	/** \brief Use a simpler, but faster region growing algorithm.
852
	851
853	852	The algorithm internally uses a \ref BucketQueue to determine
854	853	the processing order of the pixels. This is only useful,
855	854	when the input boundary indicator image contains integers
856	855	in the range <tt>[0, ..., bucket_count-1]</tt>. Since
857	856	these boundary indicators are typically represented as
858	857	UInt8 images, the default <tt>bucket_count</tt> is 256.
859
	858
860	859	Default: don't use the turbo algorithm
861	860	*/
862	861	WatershedOptions & turboAlgorithm(unsigned int bucket_count = 256)

865	864	method = RegionGrowing;
866	865	return *this;
867	866	}
868
	867
869	868	/** \brief Specify seed options.
870
	869
871	870	In this case, watershedsRegionGrowing() assumes that the destination
872		image does not yet contain seeds. It will therefore call
	871	image does not yet contain seeds. It will therefore call
873	872	generateWatershedSeeds() and pass on the seed options.
874
	873
875	874	Default: don't compute seeds (i.e. assume that destination image already
876	875	contains seeds).
877	876	*/

880	879	seed_options = s;
881	880	return *this;
882	881	}
883
	882
884	883	/** \brief Bias the cost of the specified region by the given factor.
885
	884
886	885	In certain applications, one region (typically the background) should
887	886	be preferred in region growing. This is most easily achieved
888	887	by adjusting the assignment cost for that region as <tt>factor*cost</tt>,
889		with a factor slightly below 1.
890
	888	with a factor slightly below 1. (Accordingly, factors above 1 would
	889	correspond to a discouragement of the bias label.)
	890
891	891	Default: don't bias any region.
892	892	*/
893	893	WatershedOptions & biasLabel(unsigned int label, double factor)

896	896	bias = factor;
897	897	return *this;
898	898	}
899
	899
900	900	/** \brief Specify the algorithm to be used.
901
	901
902	902	Possible values are <tt>WatershedOptions::RegionGrowing</tt> and
903	903	<tt>WatershedOptions::UnionFind</tt>. The latter algorithm is fastest
904	904	but doesn't support seeds and any of the other options.
905
	905
906	906	Default: RegionGrowing.
907	907	*/
908	908	WatershedOptions & useMethod(Method method)

910	910	this->method = method;
911	911	return *this;
912	912	}
913
	913
914	914	/** \brief Use region-growing watershed.
915
916		Use this method when you want to specify seeds explicitly (seeded watersheds)
	915
	916	Use this method when you want to specify seeds explicitly (seeded watersheds)
917	917	or use any of the other options.
918
	918
919	919	Default: true.
920	920	*/
921	921	WatershedOptions & regionGrowing()

923	923	method = RegionGrowing;
924	924	return *this;
925	925	}
926
	926
927	927	/** \brief Use union-find watershed.
928
929		This is the fasted method, but it doesn't support seeds and any of the other
	928
	929	This is the fasted method, but it doesn't support seeds and any of the other
930	930	options (they will be silently ignored).
931
	931
932	932	Default: false.
933	933	*/
934	934	WatershedOptions & unionFind()

944	944	class WatershedStatistics
945	945	{
946	946	public:
947
	947
948	948	typedef SeedRgDirectValueFunctor<CostType> value_type;
949	949	typedef value_type & reference;
950	950	typedef value_type const & const_reference;
951
	951
952	952	typedef CostType first_argument_type;
953	953	typedef LabelType second_argument_type;
954	954	typedef LabelType argument_type;
955
	955
956	956	WatershedStatistics()
957	957	{}
958	958

965	965	/** update regions statistics (do nothing in the watershed algorithm)
966	966	*/
967	967	template <class T1, class T2>
968		void operator()(first_argument_type const &, second_argument_type const &)
	968	void operator()(first_argument_type const &, second_argument_type const &)
969	969	{}
970	970
971	971	/** ask for maximal index (label) allowed

980	980
981	981	/** read the statistics functor for a region via its label
982	982	*/
983		const_reference operator[](argument_type label) const
	983	const_reference operator[](argument_type) const
984	984	{ return stats; }
985	985
986	986	/** access the statistics functor for a region via its label
987	987	*/
988		reference operator[](argument_type label)
	988	reference operator[](argument_type)
989	989	{ return stats; }
990	990
991	991	value_type stats;

1009	1009	/* the return type of the cost() function
1010	1010	*/
1011	1011	typedef Value cost_type;
1012
	1012
1013	1013	SeedRgBiasedValueFunctor(double b = 1.0)
1014	1014	: bias(b)
1015	1015	{}

1030	1030	class BiasedWatershedStatistics
1031	1031	{
1032	1032	public:
1033
	1033
1034	1034	typedef SeedRgBiasedValueFunctor<CostType> value_type;
1035	1035	typedef value_type & reference;
1036	1036	typedef value_type const & const_reference;
1037
	1037
1038	1038	typedef CostType first_argument_type;
1039	1039	typedef LabelType second_argument_type;
1040	1040	typedef LabelType argument_type;
1041
	1041
1042	1042	BiasedWatershedStatistics(LabelType biasedLabel, double bias)
1043	1043	: biased_label(biasedLabel),
1044	1044	biased_stats(bias)

1053	1053	/** update regions statistics (do nothing in the watershed algorithm)
1054	1054	*/
1055	1055	template <class T1, class T2>
1056		void operator()(first_argument_type const &, second_argument_type const &)
	1056	void operator()(first_argument_type const &, second_argument_type const &)
1057	1057	{}
1058	1058
1059	1059	/** ask for maximal index (label) allowed

1069	1069	/** read the statistics functor for a region via its label
1070	1070	*/
1071	1071	const_reference operator[](argument_type label) const
1072		{
	1072	{
1073	1073	return (label == biased_label)
1074	1074	? biased_stats
1075		: stats;
	1075	: stats;
1076	1076	}
1077	1077
1078	1078	/** access the statistics functor for a region via its label
1079	1079	*/
1080	1080	reference operator[](argument_type label)
1081		{
	1081	{
1082	1082	return (label == biased_label)
1083	1083	? biased_stats
1084		: stats;
	1084	: stats;
1085	1085	}
1086	1086
1087	1087	LabelType biased_label;

1094	1094
1095	1095	Note: This function is largely obsolete, \ref watershedsMultiArray() should be
1096	1096	preferred unless top speed is required.
1097
	1097
1098	1098	This function implements variants of the watershed algorithm
1099	1099	described in
1100	1100

1106	1106	designating membership of each point in one of the regions. Plateaus in the boundary
1107	1107	indicator (i.e. regions of constant gray value) are handled via a Euclidean distance
1108	1108	transform by default.
1109
1110		By default, the destination image is assumed to hold seeds for a seeded watershed
1111		transform. Seeds may, for example, be created by means of generateWatershedSeeds().
	1109
	1110	By default, the destination image is assumed to hold seeds for a seeded watershed
	1111	transform. Seeds may, for example, be created by means of generateWatershedSeeds().
1112	1112	Note that the seeds will be overridden with the final watershed segmentation.
1113
1114		Alternatively, you may provide \ref SeedOptions in order to instruct
	1113
	1114	Alternatively, you may provide \ref SeedOptions in order to instruct
1115	1115	watershedsRegionGrowing() to generate its own seeds (it will call generateWatershedSeeds()
1116	1116	internally). In that case, the destination image should be zero-initialized.
1117
1118		You can specify the neighborhood system to be used by passing \ref FourNeighborCode
	1117
	1118	You can specify the neighborhood system to be used by passing \ref FourNeighborCode
1119	1119	or \ref EightNeighborCode (default).
1120
	1120
1121	1121	Further options to be specified via \ref WatershedOptions are:
1122
	1122
1123	1123	<ul>
1124		<li> Whether to keep a 1-pixel-wide contour (with label 0) between regions or
	1124	<li> Whether to keep a 1-pixel-wide contour (with label 0) between regions or
1125	1125	perform complete grow (i.e. all pixels are assigned to a region).
1126	1126	<li> Whether to stop growing when the boundaryness exceeds a threshold (remaining
1127	1127	pixels keep label 0).
1128	1128	<li> Whether to use a faster, but less powerful algorithm ("turbo algorithm"). It
1129	1129	is faster because it orders pixels by means of a \ref BucketQueue (therefore,
1130		the boundary indicator must contain integers in the range
	1130	the boundary indicator must contain integers in the range
1131	1131	<tt>[0, ..., bucket_count-1]</tt>, where <tt>bucket_count</tt> is specified in
1132	1132	the options object), it only supports complete growing (no contour between regions
1133	1133	is possible), and it handles plateaus in a simplistic way. It also saves some
1134	1134	memory because it allocates less temporary storage.
1135		<li> Whether one region (label) is to be preferred or discouraged by biasing its cost
	1135	<li> Whether one region (label) is to be preferred or discouraged by biasing its cost
1136	1136	with a given factor (smaller than 1 for preference, larger than 1 for discouragement).
1137	1137	</ul>
1138	1138
1139	1139	Note that VIGRA provides an alternative implementation of the watershed transform via
1140		\ref watershedsUnionFind().
	1140	\ref watershedsUnionFind().
1141	1141
1142	1142	<b> Declarations:</b>
1143	1143

1149	1149	class Neighborhood = EightNeighborCode>
1150	1150	unsigned int
1151	1151	watershedsRegionGrowing(MultiArrayView<2, T1, S1> const & src,
1152		MultiArrayView<2, T2, S2> dest,
	1152	MultiArrayView<2, T2, S2> dest,
1153	1153	Neighborhood neighborhood = EightNeighborCode(),
1154	1154	WatershedOptions const & options = WatershedOptions());
1155	1155

1157	1157	class T2, class S2>
1158	1158	unsigned int
1159	1159	watershedsRegionGrowing(MultiArrayView<2, T1, S1> const & src,
1160		MultiArrayView<2, T2, S2> dest,
	1160	MultiArrayView<2, T2, S2> dest,
1161	1161	WatershedOptions const & options = WatershedOptions());
1162	1162	}
1163	1163	\endcode

1171	1171	class Neighborhood = EightNeighborCode>
1172	1172	unsigned int
1173	1173	watershedsRegionGrowing(SrcIterator upperlefts, SrcIterator lowerrights, SrcAccessor sa,
1174		DestIterator upperleftd, DestAccessor da,
	1174	DestIterator upperleftd, DestAccessor da,
1175	1175	Neighborhood neighborhood = EightNeighborCode(),
1176	1176	WatershedOptions const & options = WatershedOptions());
1177	1177

1179	1179	class DestIterator, class DestAccessor>
1180	1180	unsigned int
1181	1181	watershedsRegionGrowing(SrcIterator upperlefts, SrcIterator lowerrights, SrcAccessor sa,
1182		DestIterator upperleftd, DestAccessor da,
	1182	DestIterator upperleftd, DestAccessor da,
1183	1183	WatershedOptions const & options = WatershedOptions());
1184	1184	}
1185	1185	\endcode

1191	1191	class Neighborhood = EightNeighborCode>
1192	1192	unsigned int
1193	1193	watershedsRegionGrowing(triple<SrcIterator, SrcIterator, SrcAccessor> src,
1194		pair<DestIterator, DestAccessor> dest,
	1194	pair<DestIterator, DestAccessor> dest,
1195	1195	Neighborhood neighborhood = EightNeighborCode(),
1196	1196	WatershedOptions const & options = WatershedOptions());
1197
	1197
1198	1198	template <class SrcIterator, class SrcAccessor,
1199	1199	class DestIterator, class DestAccessor>
1200	1200	unsigned int
1201	1201	watershedsRegionGrowing(triple<SrcIterator, SrcIterator, SrcAccessor> src,
1202		pair<DestIterator, DestAccessor> dest,
	1202	pair<DestIterator, DestAccessor> dest,
1203	1203	WatershedOptions const & options = WatershedOptions());
1204	1204	}
1205	1205	\endcode
1206	1206	\deprecatedEnd
1207
	1207
1208	1208	<b> Usage:</b>
1209	1209
1210	1210	<b>\#include</b> \<vigra/watersheds.hxx\><br>

1215	1215	\code
1216	1216	MultiArray<2, float> src(w, h);
1217	1217	... // read input data
1218
	1218
1219	1219	// compute gradient magnitude at scale 1.0 as a boundary indicator
1220	1220	MultiArray<2, float> gradMag(w, h);
1221	1221	gaussianGradientMagnitude(src, gradMag, 1.0);

1225	1225	// the pixel type of the destination image must be large enough to hold
1226	1226	// numbers up to 'max_region_label' to prevent overflow
1227	1227	MultiArray<2, unsigned int> labeling(w, h);
1228
	1228
1229	1229	// call watershed algorithm for 4-neighborhood, leave a 1-pixel boundary between regions,
1230	1230	// and autogenerate seeds from all gradient minima where the magnitude is below 2.0
1231		unsigned int max_region_label =
	1231	unsigned int max_region_label =
1232	1232	watershedsRegionGrowing(gradMag, labeling,
1233	1233	FourNeighborCode(),
1234	1234	WatershedOptions().keepContours()
1235	1235	.seedOptions(SeedOptions().minima().threshold(2.0)));
1236	1236	}
1237
	1237
1238	1238	// example 2
1239	1239	{
1240	1240	MultiArray<2, unsigned int> labeling(w, h);
1241
1242		// compute seeds beforehand (use connected components of all pixels
	1241
	1242	// compute seeds beforehand (use connected components of all pixels
1243	1243	// where the gradient is below 4.0)
1244		unsigned int max_region_label =
	1244	unsigned int max_region_label =
1245	1245	generateWatershedSeeds(gradMag, labeling,
1246	1246	SeedOptions().levelSets(4.0));
1247
	1247
1248	1248	// quantize the gradient image to 256 gray levels
1249	1249	MultiArray<2, unsigned char> gradMag256(w, h);
1250		FindMinMax<float> minmax;
	1250	FindMinMax<float> minmax;
1251	1251	inspectImage(gradMag, minmax); // find original range
1252	1252	transformImage(gradMag, gradMag256,
1253	1253	linearRangeMapping(minmax, 0, 255));
1254
	1254
1255	1255	// call the turbo algorithm with 256 bins, using 8-neighborhood
1256	1256	watershedsRegionGrowing(gradMag256, labeling,
1257	1257	WatershedOptions().turboAlgorithm(256));
1258	1258	}
1259
	1259
1260	1260	// example 3
1261	1261	{
1262	1262	MultiArray<2, unsigned int> labeling(w, h);
1263
	1263
1264	1264	.. // get seeds from somewhere, e.g. an interactive labeling program,
1265	1265	// make sure that label 1 corresponds to the background
1266
	1266
1267	1267	// bias the watershed algorithm so that the background is preferred
1268	1268	// by reducing the cost for label 1 to 90%
1269	1269	watershedsRegionGrowing(gradMag, labeling,

1275	1275	\code
1276	1276	vigra::BImage src(w, h);
1277	1277	... // read input data
1278
	1278
1279	1279	// compute gradient magnitude at scale 1.0 as a boundary indicator
1280	1280	vigra::FImage gradMag(w, h);
1281	1281	gaussianGradientMagnitude(srcImageRange(src), destImage(gradMag), 1.0);

1285	1285	// the pixel type of the destination image must be large enough to hold
1286	1286	// numbers up to 'max_region_label' to prevent overflow
1287	1287	vigra::IImage labeling(w, h);
1288
	1288
1289	1289	// call watershed algorithm for 4-neighborhood, leave a 1-pixel boundary between regions,
1290	1290	// and autogenerate seeds from all gradient minima where the magnitude is below 2.0
1291		unsigned int max_region_label =
	1291	unsigned int max_region_label =
1292	1292	watershedsRegionGrowing(srcImageRange(gradMag), destImage(labeling),
1293	1293	FourNeighborCode(),
1294	1294	WatershedOptions().keepContours()
1295	1295	.seedOptions(SeedOptions().minima().threshold(2.0)));
1296	1296	}
1297
	1297
1298	1298	// example 2
1299	1299	{
1300	1300	vigra::IImage labeling(w, h);
1301
1302		// compute seeds beforehand (use connected components of all pixels
	1301
	1302	// compute seeds beforehand (use connected components of all pixels
1303	1303	// where the gradient is below 4.0)
1304		unsigned int max_region_label =
	1304	unsigned int max_region_label =
1305	1305	generateWatershedSeeds(srcImageRange(gradMag), destImage(labeling),
1306	1306	SeedOptions().levelSets(4.0));
1307
	1307
1308	1308	// quantize the gradient image to 256 gray levels
1309	1309	vigra::BImage gradMag256(w, h);
1310		vigra::FindMinMax<float> minmax;
	1310	vigra::FindMinMax<float> minmax;
1311	1311	inspectImage(srcImageRange(gradMag), minmax); // find original range
1312	1312	transformImage(srcImageRange(gradMag), destImage(gradMag256),
1313	1313	linearRangeMapping(minmax, 0, 255));
1314
	1314
1315	1315	// call the turbo algorithm with 256 bins, using 8-neighborhood
1316	1316	watershedsRegionGrowing(srcImageRange(gradMag256), destImage(labeling),
1317	1317	WatershedOptions().turboAlgorithm(256));
1318	1318	}
1319
	1319
1320	1320	// example 3
1321	1321	{
1322	1322	vigra::IImage labeling(w, h);
1323
	1323
1324	1324	.. // get seeds from somewhere, e.g. an interactive labeling program,
1325	1325	// make sure that label 1 corresponds to the background
1326
	1326
1327	1327	// bias the watershed algorithm so that the background is preferred
1328	1328	// by reducing the cost for label 1 to 90%
1329	1329	watershedsRegionGrowing(srcImageRange(gradMag), destImage(labeling),

1354	1354	class Neighborhood>
1355	1355	unsigned int
1356	1356	watershedsRegionGrowing(SrcIterator upperlefts, SrcIterator lowerrights, SrcAccessor sa,
1357		DestIterator upperleftd, DestAccessor da,
	1357	DestIterator upperleftd, DestAccessor da,
1358	1358	Neighborhood neighborhood,
1359	1359	WatershedOptions const & options = WatershedOptions())
1360	1360	{
1361		typedef typename SrcAccessor::value_type ValueType;
1362		typedef typename DestAccessor::value_type LabelType;
1363
	1361	typedef typename SrcAccessor::value_type ValueType;
	1362	typedef typename DestAccessor::value_type LabelType;
	1363
1364	1364	unsigned int max_region_label = 0;
1365
	1365
1366	1366	if(options.seed_options.mini != SeedOptions::Unspecified)
1367	1367	{
1368	1368	// we are supposed to compute seeds
1369		max_region_label =
1370		generateWatershedSeeds(srcIterRange(upperlefts, lowerrights, sa),
	1369	max_region_label =
	1370	generateWatershedSeeds(srcIterRange(upperlefts, lowerrights, sa),
1371	1371	destIter(upperleftd, da),
1372	1372	neighborhood, options.seed_options);
1373	1373	}
1374
	1374
1375	1375	if(options.biased_label != 0)
1376	1376	{
1377	1377	// create a statistics functor for biased region growing
1378		detail::BiasedWatershedStatistics<ValueType, LabelType>
	1378	detail::BiasedWatershedStatistics<ValueType, LabelType>
1379	1379	regionstats(options.biased_label, options.bias);
1380	1380
1381	1381	// perform region growing, starting from the seeds computed above
1382	1382	if(options.bucket_count == 0)
1383	1383	{
1384		max_region_label =
	1384	max_region_label =
1385	1385	seededRegionGrowing(srcIterRange(upperlefts, lowerrights, sa),
1386	1386	srcIter(upperleftd, da),
1387		destIter(upperleftd, da),
	1387	destIter(upperleftd, da),
1388	1388	regionstats, options.terminate, neighborhood, options.max_cost);
1389	1389	}
1390	1390	else
1391	1391	{
1392		max_region_label =
	1392	max_region_label =
1393	1393	fastSeededRegionGrowing(srcIterRange(upperlefts, lowerrights, sa),
1394		destIter(upperleftd, da),
1395		regionstats, options.terminate,
	1394	destIter(upperleftd, da),
	1395	regionstats, options.terminate,
1396	1396	neighborhood, options.max_cost, options.bucket_count);
1397	1397	}
1398	1398	}

1404	1404	// perform region growing, starting from the seeds computed above
1405	1405	if(options.bucket_count == 0)
1406	1406	{
1407		max_region_label =
	1407	max_region_label =
1408	1408	seededRegionGrowing(srcIterRange(upperlefts, lowerrights, sa),
1409	1409	srcIter(upperleftd, da),
1410		destIter(upperleftd, da),
	1410	destIter(upperleftd, da),
1411	1411	regionstats, options.terminate, neighborhood, options.max_cost);
1412	1412	}
1413	1413	else
1414	1414	{
1415		max_region_label =
	1415	max_region_label =
1416	1416	fastSeededRegionGrowing(srcIterRange(upperlefts, lowerrights, sa),
1417		destIter(upperleftd, da),
1418		regionstats, options.terminate,
	1417	destIter(upperleftd, da),
	1418	regionstats, options.terminate,
1419	1419	neighborhood, options.max_cost, options.bucket_count);
1420	1420	}
1421	1421	}
1422
	1422
1423	1423	return max_region_label;
1424	1424	}
1425	1425

1427	1427	class DestIterator, class DestAccessor>
1428	1428	inline unsigned int
1429	1429	watershedsRegionGrowing(SrcIterator upperlefts, SrcIterator lowerrights, SrcAccessor sa,
1430		DestIterator upperleftd, DestAccessor da,
	1430	DestIterator upperleftd, DestAccessor da,
1431	1431	WatershedOptions const & options = WatershedOptions())
1432	1432	{
1433	1433	return watershedsRegionGrowing(upperlefts, lowerrights, sa, upperleftd, da,

1439	1439	class Neighborhood>
1440	1440	inline unsigned int
1441	1441	watershedsRegionGrowing(triple<SrcIterator, SrcIterator, SrcAccessor> src,
1442		pair<DestIterator, DestAccessor> dest,
	1442	pair<DestIterator, DestAccessor> dest,
1443	1443	Neighborhood neighborhood,
1444	1444	WatershedOptions const & options = WatershedOptions())
1445	1445	{
1446	1446	return watershedsRegionGrowing(src.first, src.second, src.third,
1447		dest.first, dest.second,
	1447	dest.first, dest.second,
1448	1448	neighborhood, options);
1449	1449	}
1450	1450

1452	1452	class DestIterator, class DestAccessor>
1453	1453	inline unsigned int
1454	1454	watershedsRegionGrowing(triple<SrcIterator, SrcIterator, SrcAccessor> src,
1455		pair<DestIterator, DestAccessor> dest,
	1455	pair<DestIterator, DestAccessor> dest,
1456	1456	WatershedOptions const & options = WatershedOptions())
1457	1457	{
1458	1458	return watershedsRegionGrowing(src.first, src.second, src.third,
1459		dest.first, dest.second,
	1459	dest.first, dest.second,
1460	1460	EightNeighborCode(), options);
1461	1461	}
1462	1462

1465	1465	class Neighborhood>
1466	1466	inline unsigned int
1467	1467	watershedsRegionGrowing(MultiArrayView<2, T1, S1> const & src,
1468		MultiArrayView<2, T2, S2> dest,
	1468	MultiArrayView<2, T2, S2> dest,
1469	1469	Neighborhood neighborhood,
1470	1470	WatershedOptions const & options = WatershedOptions())
1471	1471	{
1472	1472	vigra_precondition(src.shape() == dest.shape(),
1473	1473	"watershedsRegionGrowing(): shape mismatch between input and output.");
1474	1474	return watershedsRegionGrowing(srcImageRange(src),
1475		destImage(dest),
	1475	destImage(dest),
1476	1476	neighborhood, options);
1477	1477	}
1478	1478

1480	1480	class T2, class S2>
1481	1481	inline unsigned int
1482	1482	watershedsRegionGrowing(MultiArrayView<2, T1, S1> const & src,
1483		MultiArrayView<2, T2, S2> dest,
	1483	MultiArrayView<2, T2, S2> dest,
1484	1484	WatershedOptions const & options = WatershedOptions())
1485	1485	{
1486	1486	vigra_precondition(src.shape() == dest.shape(),
1487	1487	"watershedsRegionGrowing(): shape mismatch between input and output.");
1488	1488	return watershedsRegionGrowing(srcImageRange(src),
1489		destImage(dest),
	1489	destImage(dest),
1490	1490	EightNeighborCode(), options);
1491	1491	}
1492	1492

+49

-54

include/vigra/watersheds3d.hxx less more

28	28	/* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, */
29	29	/* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING */
30	30	/* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR */
31		/* OTHER DEALINGS IN THE SOFTWARE. */
	31	/* OTHER DEALINGS IN THE SOFTWARE. */
32	32	/* */
33	33	/************************************************************************/
34	34

53	53	//basically needed for iteration and border-checks
54	54	int w = srcShape[0], h = srcShape[1], d = srcShape[2];
55	55	int x,y,z, local_min_count=0;
56
	56
57	57	//declare and define Iterators for all three dims at src
58	58	SrcIterator zs = s_Iter;
59	59	SrcIterator ys(zs);
60	60	SrcIterator xs(ys);
61
	61
62	62	//Declare Iterators for all three dims at dest
63	63	DestIterator zd = d_Iter;
64
	64
65	65	for(z = 0; z != d; ++z, ++zs.dim2(), ++zd.dim2())
66	66	{
67	67	ys = zs;
68	68	DestIterator yd(zd);
69
	69
70	70	for(y = 0; y != h; ++y, ++ys.dim1(), ++yd.dim1())
71	71	{
72	72	xs = ys;

84	84	if(atBorder == NotAtBorder)
85	85	{
86	86	NeighborhoodCirculator<SrcIterator, Neighborhood3D> c(xs), cend(c);
87
	87
88	88	do {
89	89	if(sa(c) < v)
90		{
	90	{
91	91	v = sa(c);
92	92	o = c.directionBit();
93	93	}

103	103	RestrictedNeighborhoodCirculator<SrcIterator, Neighborhood3D> c(xs, atBorder), cend(c);
104	104	do {
105	105	if(sa(c) < v)
106		{
	106	{
107	107	v = sa(c);
108	108	o = c.directionBit();
109	109	}

114	114	}
115	115	while(++c != cend);
116	116	}
117		if (o==0) local_min_count++;
	117	if (o==0) local_min_count++;
118	118	da.set(o, xd);
119	119	}//end x-iteration
120	120	}//end y-iteration

130	130	Neighborhood3D)
131	131	{
132	132	typedef typename DestAccessor::value_type LabelType;
133
	133
134	134	//basically needed for iteration and border-checks
135	135	int w = srcShape[0], h = srcShape[1], d = srcShape[2];
136	136	int x,y,z;
137
	137
138	138	//declare and define Iterators for all three dims at src
139	139	SrcIterator zs = s_Iter;
140	140	DestIterator zd = d_Iter;
141
	141
142	142	// temporary image to store region labels
143	143	UnionFindArray<LabelType> labels;
144
	144
145	145	// initialize the neighborhood traversers
146	146	NeighborOffsetCirculator<Neighborhood3D> nc(Neighborhood3D::CausalFirst);
147	147	NeighborOffsetCirculator<Neighborhood3D> nce(Neighborhood3D::CausalLast);

171	171
172	172	for(x = 0; x != w; ++x, ++xs.dim0(), ++xd.dim0())
173	173	{
174		LabelType currentIndex = labels.nextFreeIndex(); // default: new region
	174	LabelType currentIndex = labels.nextFreeIndex(); // default: new region
175	175
176	176	//check whether there is a special border treatment to be used or not
177	177	AtVolumeBorder atBorder = isAtVolumeBorderCausal(x,y,z,w,h,d);
178
	178
179	179	//We are not at the border!
180	180	if(atBorder == NotAtBorder)
181	181	{
182	182
183	183	nc = NeighborOffsetCirculator<Neighborhood3D>(Neighborhood3D::CausalFirst);
184
	184
185	185	do
186		{
	186	{
187	187	// Direction of NTraversr Neighbor's direction bit is pointing
188	188	// = Direction of voxel towards us?
189	189	if((sa(xs) & nc.directionBit()) \|\| (sa(xs,*nc) & nc.oppositeDirectionBit()))

200	200	int j=0;
201	201	while(nc.direction() != Neighborhood3D::Error)
202	202	{
203		int dummy = x+(*nc)[0]; // prevents an apparently incorrect optimization in gcc 4.8
204		if (dummy<0)
205		{
206		std::cerr << "internal error " << dummy << std::endl;
207		}
208	203	// Direction of NTraversr Neighbor's direction bit is pointing
209	204	// = Direction of voxel towards us?
210	205	if((sa(xs) & nc.directionBit()) \|\| (sa(xs,*nc) & nc.oppositeDirectionBit()))

220	215	}
221	216
222	217	unsigned int count = labels.makeContiguous();
223
	218
224	219	// pass 2: assign one label to each region (tree)
225	220	// so that labels form a consecutive sequence 1, 2, ...
226	221	zd = d_Iter;

242	237	}
243	238
244	239
245		/** \addtogroup SeededRegionGrowing
	240	/** \addtogroup Superpixels
246	241	*/
247	242	//@{
248	243

255	250	/** \brief Region Segmentation by means of the watershed algorithm.
256	251
257	252	This function is deprecated, use \ref watershedsMultiArray() instead.
258
	253
259	254	<b> Declarations:</b>
260	255
261	256	\deprecatedAPI{watersheds3D}

284	279
285	280	use with 3D-Six-Neighborhood:
286	281	\code
287		namespace vigra {
288
	282	namespace vigra {
	283
289	284	template <class SrcIterator, class SrcAccessor,class SrcShape,
290	285	class DestIterator, class DestAccessor>
291	286	unsigned int watersheds3DSix(triple<SrcIterator, SrcShape, SrcAccessor> src,
292	287	pair<DestIterator, DestAccessor> dest);
293
	288
294	289	}
295	290	\endcode
296	291
297	292	use with 3D-TwentySix-Neighborhood:
298	293	\code
299		namespace vigra {
300
	294	namespace vigra {
	295
301	296	template <class SrcIterator, class SrcAccessor,class SrcShape,
302	297	class DestIterator, class DestAccessor>
303	298	unsigned int watersheds3DTwentySix(triple<SrcIterator, SrcShape, SrcAccessor> src,
304	299	pair<DestIterator, DestAccessor> dest);
305
	300
306	301	}
307	302	\endcode
308	303	\deprecatedEnd
309
	304
310	305	This function implements the union-find version of the watershed algorithms
311	306	as described in
312	307

315	310
316	311	The source volume is a boundary indicator such as the gradient magnitude
317	312	of the trace of the \ref boundaryTensor(). Local minima of the boundary indicator
318		are used as region seeds, and all other voxels are recursively assigned to the same
319		region as their lowest neighbor. Pass \ref vigra::NeighborCode3DSix or
320		\ref vigra::NeighborCode3DTwentySix to determine the neighborhood where voxel values
	313	are used as region seeds, and all other voxels are recursively assigned to the same
	314	region as their lowest neighbor. Pass \ref vigra::NeighborCode3DSix or
	315	\ref vigra::NeighborCode3DTwentySix to determine the neighborhood where voxel values
321	316	are compared. The voxel type of the input volume must be <tt>LessThanComparable</tt>.
322
	317
323	318	<b> Usage:</b>
324	319
325	320	<b>\#include</b> \<vigra/watersheds3D.hxx\><br>

329	324
330	325	\code
331	326	Shape3 shape(w, h, d);
332
	327
333	328	MultiArray<3, float> src(shape), grad(shape);
334	329	...
335
	330
336	331	double scale = 1;
337	332	gaussianGradientMagnitude(src, grad, scale);
338
	333
339	334	MultiArray<3, int> labels(shape);
340
	335
341	336	// find 6-connected regions
342	337	int max_region_label = watersheds3DSix(grad, labels);
343	338

360	355	IntVolume::iterator temp_iter=temp.begin();
361	356	for(DVolume::iterator iter=src.begin(); iter!=src.end(); ++iter, ++temp_iter)
362	357	iter = norm(temp_iter);
363
	358
364	359	// find 6-connected regions
365	360	int max_region_label = vigra::watersheds3DSix(srcMultiArrayRange(src), destMultiArray(dest));
366	361
367	362	// find 26-connected regions
368	363	max_region_label = vigra::watersheds3DTwentySix(srcMultiArrayRange(src), destMultiArray(dest));
369
	364
370	365	\endcode
371	366	<b> Required Interface:</b>
372	367	\code

376	371
377	372	SrcAccessor src_accessor;
378	373	DestAccessor dest_accessor;
379
	374
380	375	// compare src values
381	376	src_accessor(src_begin) <= src_accessor(src_begin)
382	377

396	391	{
397	392	//create temporary volume to store the DAG of directions to minima
398	393	if ((int)Neighborhood3D::DirectionCount>7){ //If we have 3D-TwentySix Neighborhood
399
	394
400	395	vigra::MultiArray<3,int> orientationVolume(srcShape);
401	396
402		preparewatersheds3D( s_Iter, srcShape, sa,
	397	preparewatersheds3D( s_Iter, srcShape, sa,
403	398	destMultiArray(orientationVolume).first, destMultiArray(orientationVolume).second,
404	399	neighborhood3D);
405
	400
406	401	return watershedLabeling3D( srcMultiArray(orientationVolume).first, srcShape, srcMultiArray(orientationVolume).second,
407	402	d_Iter, da,
408	403	neighborhood3D);
409	404	}
410	405	else{
411
	406
412	407	vigra::MultiArray<3,unsigned char> orientationVolume(srcShape);
413	408
414		preparewatersheds3D( s_Iter, srcShape, sa,
	409	preparewatersheds3D( s_Iter, srcShape, sa,
415	410	destMultiArray(orientationVolume).first, destMultiArray(orientationVolume).second,
416	411	neighborhood3D);
417
	412
418	413	return watershedLabeling3D( srcMultiArray(orientationVolume).first, srcShape, srcMultiArray(orientationVolume).second,
419	414	d_Iter, da,
420	415	neighborhood3D);

423	418
424	419	template <class SrcIterator, class SrcShape, class SrcAccessor,
425	420	class DestIterator, class DestAccessor>
426		inline unsigned int watersheds3DSix( triple<SrcIterator, SrcShape, SrcAccessor> src,
	421	inline unsigned int watersheds3DSix( triple<SrcIterator, SrcShape, SrcAccessor> src,
427	422	pair<DestIterator, DestAccessor> dest)
428	423	{
429	424	return watersheds3D(src.first, src.second, src.third, dest.first, dest.second, NeighborCode3DSix());

431	426
432	427	template <class SrcIterator, class SrcShape, class SrcAccessor,
433	428	class DestIterator, class DestAccessor>
434		inline unsigned int watersheds3DTwentySix( triple<SrcIterator, SrcShape, SrcAccessor> src,
	429	inline unsigned int watersheds3DTwentySix( triple<SrcIterator, SrcShape, SrcAccessor> src,
435	430	pair<DestIterator, DestAccessor> dest)
436	431	{
437	432	return watersheds3D(src.first, src.second, src.third, dest.first, dest.second, NeighborCode3DTwentySix());

439	434
440	435	template <unsigned int N, class T1, class S1,
441	436	class T2, class S2>
442		inline unsigned int
443		watersheds3DSix(MultiArrayView<N, T1, S1> const & source,
	437	inline unsigned int
	438	watersheds3DSix(MultiArrayView<N, T1, S1> const & source,
444	439	MultiArrayView<N, T2, S2> dest)
445	440	{
446	441	vigra_precondition(source.shape() == dest.shape(),

451	446	template <unsigned int N, class T1, class S1,
452	447	class T2, class S2>
453	448	inline unsigned int
454		watersheds3DTwentySix(MultiArrayView<N, T1, S1> const & source,
	449	watersheds3DTwentySix(MultiArrayView<N, T1, S1> const & source,
455	450	MultiArrayView<N, T2, S2> dest)
456	451	{
457	452	vigra_precondition(source.shape() == dest.shape(),

+3

-1

src/examples/CMakeLists.txt less more

0		SET(TARGETS
	0	SET(TARGETS
1	1	convert
2	2	subimage
3	3	invert

22	22	ADD_DEPENDENCIES(examples example_${TARGET})
23	23	TARGET_LINK_LIBRARIES(example_${TARGET} vigraimpex)
24	24	ENDFOREACH(TARGET)
	25
	26	ADD_SUBDIRECTORY(tutorial)

+26

-0

src/examples/tutorial/CMakeLists.txt less more

	0	# SET(TARGETS
	1	# composite
	2	# dissolve
	3	# graph_agglomerative_clustering
	4	# imageExportInfo_tutorial
	5	# imageIO_tutorial
	6	# imageImportInfo_tutorial
	7	# invert_tutorial
	8	# mirror_tutorial
	9	# smooth_blockwise
	10	# smooth_convolve
	11	# smooth_explicitly
	12	# subimage_tutorial
	13	# transpose
	14	# transpose_image_tutorial)
	15
	16	SET(TARGETS
	17	smooth_blockwise
	18	graph_agglomerative_clustering
	19	)
	20
	21	FOREACH(TARGET ${TARGETS})
	22	ADD_EXECUTABLE(example_${TARGET} EXCLUDE_FROM_ALL ${TARGET})
	23	ADD_DEPENDENCIES(examples example_${TARGET})
	24	TARGET_LINK_LIBRARIES(example_${TARGET} vigraimpex)
	25	ENDFOREACH(TARGET)

+162

-0

src/examples/tutorial/graph_agglomerative_clustering.cxx less more

	0	#include <iostream>
	1
	2	#include <vigra/multi_array.hxx>
	3	#include <vigra/impex.hxx>
	4	#include <vigra/multi_resize.hxx>
	5	#include <vigra/colorconversions.hxx>
	6	#include <vigra/multi_convolution.hxx>
	7	#include <vigra/multi_watersheds.hxx>
	8	#include <vigra/multi_gridgraph.hxx>
	9	#include <vigra/accumulator.hxx>
	10	#include <vigra/adjacency_list_graph.hxx>
	11	#include <vigra/graph_algorithms.hxx>
	12	#include <vigra/hierarchical_clustering.hxx>
	13	#include <vigra/metrics.hxx>
	14
	15	using namespace vigra;
	16
	17	int main (int argc, char ** argv)
	18	{
	19	// parameters of the hierarchical clustering algorithm
	20	float sigmaGradMag = 3.0f; // scale of the Gaussian gradient
	21	float beta = 0.5f; // importance of node features relative to edge weights
	22	float wardness = 0.8f; // importance of cluster size
	23	int numClusters = 30; // desired number of resulting regions (clusters)
	24
	25	if(argc != 3)
	26	{
	27	std::cout << "Usage: " << argv[0] << " infile outfile" << std::endl;
	28	std::cout << "(supported formats: " << impexListFormats() << ")" << std::endl;
	29	std::cout << "(only color images)" << std::endl;
	30
	31	return 1;
	32	}
	33	try
	34	{
	35	// read metadata of image file given in argv[1]
	36	ImageImportInfo info(argv[1]);
	37
	38	vigra_precondition(info.numBands() == 3, "an RGB image is required.");
	39
	40	// instantiate image arrays of appropriate size
	41	MultiArray<2, TinyVector<float, 3> > imageArrayRGB(info.shape()),
	42	imageArrayLab(info.shape());
	43
	44	// read image data
	45	importImage(info, imageArrayRGB);
	46
	47	// convert to Lab color space for better color similarity estimates
	48	transformMultiArray(imageArrayRGB, imageArrayLab, RGB2LabFunctor<float>());
	49
	50	// compute gradient magnitude as an indicator of edge strength
	51	MultiArray<2, float> gradMag(imageArrayLab.shape());
	52	gaussianGradientMagnitude(imageArrayLab, gradMag, sigmaGradMag);
	53
	54	// create watershed superpixels with the fast union-find algorithm;
	55	// we use a NodeMap (a subclass of MultiArray) to store the labels so
	56	// that they can be passed to hierarchicalClustering() directly
	57	MultiArray<2, unsigned int> labelArray(gradMag.shape());
	58	unsigned int max_label =
	59	watershedsMultiArray(gradMag, labelArray, DirectNeighborhood,
	60	WatershedOptions().unionFind());
	61
	62	// double the image resolution for better visualization of the results
	63	MultiArray<2, TinyVector<float, 3> > imageArrayBig(info.shape()*2-Shape2(1));
	64	resizeMultiArraySplineInterpolation(imageArrayRGB, imageArrayBig);
	65
	66	// visualize the watersheds as a red overlay over the enlarged image
	67	regionImageToCrackEdgeImage(labelArray, imageArrayBig,
	68	RGBValue<float>( 255, 0, 0 ), EdgeOverlayOnly);
	69
	70	// create grid-graph of appropriate size
	71	typedef GridGraph<2, undirected_tag > ImageGraph;
	72	ImageGraph imageGraph(labelArray.shape());
	73
	74	// construct empty region adjacency graph (RAG) for the superpixels
	75	typedef AdjacencyListGraph RAG;
	76	RAG rag;
	77
	78	// create mapping 'affiliatedEdges' from edges in the RAG to
	79	// corresponding edges in imageGraph and build the RAG
	80	RAG::EdgeMap<std::vector<ImageGraph::Edge>> affiliatedEdges(rag);
	81	makeRegionAdjacencyGraph(imageGraph, labelArray, rag, affiliatedEdges);
	82
	83	// create edge maps for weights and lengths of the RAG edges (zero initialized)
	84	RAG::EdgeMap<float> edgeWeights(rag),
	85	edgeLengths(rag);
	86
	87	// iterate over all RAG edges (this loop follows a standard LEMON idiom)
	88	for(RAG::EdgeIt rag_edge(rag); rag_edge != lemon::INVALID; ++rag_edge)
	89	{
	90	// iterate over all grid edges that constitute the present RAG edge
	91	for(unsigned int k = 0; k < affiliatedEdges[*rag_edge].size(); ++k)
	92	{
	93	// look up the current grid edge and its end points
	94	auto const & grid_edge = affiliatedEdges[*rag_edge][k];
	95	auto start = imageGraph.u(grid_edge),
	96	end = imageGraph.v(grid_edge);
	97
	98	// compute gradient by linear interpolation between end points
	99	double grid_edge_gradient = 0.5 * (gradMag[start] + gradMag[end]);
	100	// aggregate the total
	101	edgeWeights[*rag_edge] += grid_edge_gradient;
	102	}
	103
	104	// the length of the RAG edge equals the number of constituent grid edges
	105	edgeLengths[rag_edge] = affiliatedEdges[rag_edge].size();
	106	// define edge weight by the average gradient
	107	edgeWeights[rag_edge] /= edgeLengths[rag_edge];
	108	}
	109
	110	// determine size and average color of each superpixel
	111	using namespace acc;
	112	AccumulatorChainArray<CoupledArrays<2, TinyVector<float, 3>, unsigned int>,
	113	Select<DataArg<1>, LabelArg<2>, // where to look for data and region labels
	114	Count, Mean> > // what statistics to compute
	115	features;
	116	extractFeatures(imageArrayLab, labelArray, features);
	117
	118	// copy superpixel features into NodeMaps to be passed to hierarchicalClustering()
	119	RAG::NodeMap<TinyVector<float, 3>> meanColor(rag);
	120	RAG::NodeMap<unsigned int> regionSize(rag);
	121	for(unsigned int k=0; k<=max_label; ++k)
	122	{
	123	meanColor[k] = get<Mean>(features, k);
	124	regionSize[k] = get<Count>(features, k);
	125	}
	126
	127	// create a node map for the new (clustered) region labels and perform
	128	// clustering to remove unimportant watershed edges
	129	RAG::NodeMap<unsigned int> nodeLabels(rag);
	130	hierarchicalClustering(rag, // input: the superpixel adjacency graph
	131	edgeWeights, edgeLengths, meanColor, regionSize, // features
	132	nodeLabels, // output: a cluster labeling of the RAG
	133	ClusteringOptions().minRegionCount(numClusters)
	134	.nodeFeatureImportance(beta)
	135	.sizeImportance(wardness)
	136	.nodeFeatureMetric(metrics::L2Norm)
	137	);
	138
	139	// create label image with the new labels
	140	transformMultiArray(labelArray, labelArray,
	141	[&nodeLabels](unsigned int oldlabel)
	142	{
	143	return nodeLabels[oldlabel];
	144	});
	145
	146	// visualize the salient edges as a green overlay
	147	regionImageToCrackEdgeImage(labelArray, imageArrayBig,
	148	RGBValue<float>( 0, 255, 0), EdgeOverlayOnly);
	149
	150	// write result into image file given by argv[2]
	151	exportImage(imageArrayBig, argv[2]);
	152
	153	}
	154	catch (std::exception & e)
	155	{
	156	// catch any errors that might have occurred and print their reason
	157	std::cout << e.what() << std::endl;
	158	return 1;
	159	}
	160	return 0;
	161	}⏎

+98

-0

src/examples/tutorial/smooth_blockwise.cxx less more

	0	/************************************************************************/
	1	/* */
	2	/* Copyright 1998-2002 by Ullrich Koethe */
	3	/* */
	4	/* This file is part of the VIGRA computer vision library. */
	5	/* The VIGRA Website is */
	6	/* http://hci.iwr.uni-heidelberg.de/vigra/ */
	7	/* Please direct questions, bug reports, and contributions to */
	8	/* ullrich.koethe@iwr.uni-heidelberg.de or */
	9	/* vigra@informatik.uni-hamburg.de */
	10	/* */
	11	/* Permission is hereby granted, free of charge, to any person */
	12	/* obtaining a copy of this software and associated documentation */
	13	/* files (the "Software"), to deal in the Software without */
	14	/* restriction, including without limitation the rights to use, */
	15	/* copy, modify, merge, publish, distribute, sublicense, and/or */
	16	/* sell copies of the Software, and to permit persons to whom the */
	17	/* Software is furnished to do so, subject to the following */
	18	/* conditions: */
	19	/* */
	20	/* The above copyright notice and this permission notice shall be */
	21	/* included in all copies or substantial portions of the */
	22	/* Software. */
	23	/* */
	24	/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND */
	25	/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES */
	26	/* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND */
	27	/* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT */
	28	/* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, */
	29	/* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING */
	30	/* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR */
	31	/* OTHER DEALINGS IN THE SOFTWARE. */
	32	/* */
	33	/************************************************************************/
	34
	35	#include <vigra/multi_array.hxx>
	36	#include <vigra/impex.hxx>
	37	#include <vigra/convolution.hxx>
	38	#include <vigra/multi_blockwise.hxx>
	39	#include <iostream>
	40
	41	using namespace vigra;
	42
	43	int main (int argc, char ** argv)
	44	{
	45	if(argc != 3)
	46	{
	47	std::cout << "Usage: " << argv[0] << " infile outfile" << std::endl;
	48	std::cout << "(supported formats: " << impexListFormats() << ")" << std::endl;
	49
	50	return 1;
	51	}
	52	try
	53	{
	54	// read image given as first argument
	55	ImageImportInfo info(argv[1]);
	56
	57	// instantiate arrays for image data and for smoothed image of appropriate size
	58	if (info.isGrayscale())
	59	{
	60	MultiArray<2, float> imageArray(info.shape()),
	61	exportArray(info.shape());
	62
	63	// copy image data into array
	64	importImage(info, imageArray);
	65
	66	gaussianSmoothMultiArray(imageArray, exportArray,
	67	BlockwiseConvolutionOptions<2>().stdDev(2.0));
	68
	69	// write image data to the file given as second argument
	70	exportImage(exportArray, ImageExportInfo(argv[2]));
	71
	72	}
	73	else
	74	{
	75	MultiArray<2, RGBValue<float> > imageArray(info.shape()),
	76	exportArray(info.shape());
	77
	78	// copy image data into array
	79	importImage(info, imageArray);
	80
	81	gaussianSmoothMultiArray(imageArray, exportArray,
	82	BlockwiseConvolutionOptions<2>().stdDev(2.0));
	83
	84	// write image data to the file given as second argument
	85	exportImage(exportArray, ImageExportInfo(argv[2]));
	86	}
	87
	88
	89	}
	90	catch (std::exception & e)
	91	{
	92	// catch any errors that might have occurred and print their reason
	93	std::cout << e.what() << std::endl;
	94	return 1;
	95	}
	96	return 0;
	97	}⏎

src/images/bears.jpg less more

Binary diff not shown

src/images/bears_gradient.png less more

Binary diff not shown

src/images/bears_segmentation.png less more

Binary diff not shown

src/images/bears_superpixels.png less more

Binary diff not shown

+10

-10

src/impex/CMakeLists.txt less more

0	0	IF(ZLIB_FOUND)
1	1	ADD_DEFINITIONS(-DHasZLIB)
2		INCLUDE_DIRECTORIES(${ZLIB_INCLUDE_DIR})
	2	INCLUDE_DIRECTORIES(${SUPPRESS_WARNINGS} ${ZLIB_INCLUDE_DIR})
3	3	ENDIF(ZLIB_FOUND)
4	4
5	5	IF(PNG_FOUND)
6	6	ADD_DEFINITIONS(-DHasPNG)
7		INCLUDE_DIRECTORIES(${PNG_INCLUDE_DIR})
	7	INCLUDE_DIRECTORIES(${SUPPRESS_WARNINGS} ${PNG_INCLUDE_DIR})
8	8	ENDIF(PNG_FOUND)
9	9
10	10	IF(JPEG_FOUND)
11	11	ADD_DEFINITIONS(-DHasJPEG)
12		INCLUDE_DIRECTORIES(${JPEG_INCLUDE_DIR})
	12	INCLUDE_DIRECTORIES(${SUPPRESS_WARNINGS} ${JPEG_INCLUDE_DIR})
13	13	ENDIF(JPEG_FOUND)
14	14
15	15	IF(TIFF_FOUND)
16	16	ADD_DEFINITIONS(-DHasTIFF)
17		INCLUDE_DIRECTORIES(${TIFF_INCLUDE_DIR})
	17	INCLUDE_DIRECTORIES(${SUPPRESS_WARNINGS} ${TIFF_INCLUDE_DIR})
18	18	ENDIF(TIFF_FOUND)
19	19
20		IF(OPENEXR_FOUND)
21		ADD_DEFINITIONS(-DHasEXR)
22		INCLUDE_DIRECTORIES(${OPENEXR_INCLUDE_DIR})
23		ENDIF(OPENEXR_FOUND)
	20	IF(OpenEXR_FOUND)
	21	ADD_DEFINITIONS(-DHasEXR ${OPENEXR_CPPFLAGS})
	22	INCLUDE_DIRECTORIES(${SUPPRESS_WARNINGS} ${OPENEXR_INCLUDE_DIR})
	23	ENDIF(OpenEXR_FOUND)
24	24
25	25	IF(HDF5_FOUND)
26	26	ADD_DEFINITIONS(-DHasHDF5 ${HDF5_CPPFLAGS})
27		INCLUDE_DIRECTORIES(${HDF5_INCLUDE_DIR})
	27	INCLUDE_DIRECTORIES(${SUPPRESS_WARNINGS} ${HDF5_INCLUDE_DIR})
28	28	ENDIF(HDF5_FOUND)
29	29
30	30	IF (MSVC OR MINGW)

63	63	viff.cxx
64	64	void_vector.cxx)
65	65
66		set(SOVERSION 6) # increment this after changing the vigraimpex library
	66	set(SOVERSION 11) # increment this after changing the vigraimpex library
67	67	IF(MACOSX)
68	68	SET_TARGET_PROPERTIES(vigraimpex PROPERTIES VERSION ${SOVERSION}.${vigra_version}
69	69	SOVERSION ${SOVERSION} INSTALL_NAME_DIR "${CMAKE_INSTALL_PREFIX}/lib${LIB_SUFFIX}")

+1

-1

src/impex/codecmanager.cxx less more

255	255	std::string
256	256	CodecManager::getEncoderType( const std::string & filename,
257	257	const std::string & fType,
258		const std::string & mode ) const
	258	const std::string & ) const
259	259	{
260	260	std::string fileType = fType;
261	261

+1

-1

src/impex/compression.cxx less more

160	160	case LZ4:
161	161	{
162	162	int sourceLen = ::LZ4_decompress_fast(source, dest, destSize);
163		vigra_postcondition(sourceLen == srcSize, "uncompress(): lz4 decompression failed.");
	163	vigra_postcondition(sourceLen >= 0 && static_cast<unsigned>(sourceLen) == srcSize, "uncompress(): lz4 decompression failed.");
164	164	break;
165	165	}
166	166

+36

-31

src/impex/hdf5impex.cxx less more

59	59	&H5Sclose, "HDF5ImportInfo(): could not access dataset dataspace.");
60	60	m_dimensions = H5Sget_simple_extent_ndims(dataspace_handle);
61	61	//m_dimensions = dset.getSpace().getSimpleExtentNdims();
62
	62
63	63	//why?
64	64	//vigra_precondition( m_dimensions>=2, "HDF5ImportInfo(): Number of dimensions is lower than 2. Not an image!" );
65	65

75	75	else if(datasize == 8)
76	76	m_pixeltype = "DOUBLE";
77	77	}
78		else if(dataclass == H5T_INTEGER)
	78	else if(dataclass == H5T_INTEGER)
79	79	{
80	80	if(datasign == H5T_SGN_NONE)
81	81	{

150	150	return m_pixeltype.c_str();
151	151	}
152	152
153		MultiArrayIndex HDF5ImportInfo::shapeOfDimension(const int dim) const
154		{
155		return MultiArrayIndex(m_dims[dim]);
156		}
157
158		MultiArrayIndex HDF5ImportInfo::numDimensions() const
159		{
160		return MultiArrayIndex(m_dimensions);
161		}
162
163		const std::string & HDF5ImportInfo::getPathInFile() const
164		{
165		return m_path;
166		}
167
168		const std::string & HDF5ImportInfo::getFilePath() const
169		{
170		return m_filename;
171		}
172
173		hid_t HDF5ImportInfo::getH5FileHandle() const
174		{
175		return m_file_handle;
176		}
177
178		hid_t HDF5ImportInfo::getDatasetHandle() const
179		{
180		return m_dataset_handle;
	153	ArrayVector<hsize_t> const & HDF5ImportInfo::shape() const
	154	{
	155	return m_dims;
	156	}
	157
	158	MultiArrayIndex HDF5ImportInfo::shapeOfDimension(const int dim) const
	159	{
	160	return MultiArrayIndex(m_dims[dim]);
	161	}
	162
	163	MultiArrayIndex HDF5ImportInfo::numDimensions() const
	164	{
	165	return MultiArrayIndex(m_dimensions);
	166	}
	167
	168	const std::string & HDF5ImportInfo::getPathInFile() const
	169	{
	170	return m_path;
	171	}
	172
	173	const std::string & HDF5ImportInfo::getFilePath() const
	174	{
	175	return m_filename;
	176	}
	177
	178	hid_t HDF5ImportInfo::getH5FileHandle() const
	179	{
	180	return m_file_handle;
	181	}
	182
	183	hid_t HDF5ImportInfo::getDatasetHandle() const
	184	{
	185	return m_dataset_handle;
181	186	}
182	187
183	188	H5O_type_t HDF5_get_type(hid_t loc_id, const char* name)

214	219
215	220	// callback function for listAttributes(), called via HDF5File::ls_H5Literate()
216	221	extern "C"
217		herr_t HDF5_listAttributes_inserter_callback(hid_t loc_id, const char* name,
	222	herr_t HDF5_listAttributes_inserter_callback(hid_t, const char* name,
218	223	const H5A_info_t, void operator_data)
219	224	{
220	225	HDF5_ls_insert(operator_data, name);

+1320

-669

src/impex/lz4.c less more

0	0	/*
1	1	LZ4 - Fast LZ compression algorithm
2		Copyright (C) 2011-2013, Yann Collet.
	2	Copyright (C) 2011-2015, Yann Collet.
	3
3	4	BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
4	5
5	6	Redistribution and use in source and binary forms, with or without

26	27	OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27	28
28	29	You can contact the author at :
29		- LZ4 source repository : http://code.google.com/p/lz4/
	30	- LZ4 source repository : https://github.com/Cyan4973/lz4
30	31	- LZ4 public forum : https://groups.google.com/forum/#!forum/lz4c
31	32	*/
32	33
33		//**************************************
34		// Tuning parameters
35		//**************************************
36		// MEMORY_USAGE :
37		// Memory usage formula : N->2^N Bytes (examples : 10 -> 1KB; 12 -> 4KB ; 16 -> 64KB; 20 -> 1MB; etc.)
38		// Increasing memory usage improves compression ratio
39		// Reduced memory usage can improve speed, due to cache effect
40		// Default value is 14, for 16KB, which nicely fits into Intel x86 L1 cache
41		#define MEMORY_USAGE 14
42
43		// HEAPMODE :
44		// Select how default compression functions will allocate memory for their hash table,
45		// in memory stack (0:default, fastest), or in memory heap (1:requires memory allocation (malloc)).
	34
	35	/**************************************
	36	* Tuning parameters
	37	**************************************/
	38	/*
	39	* HEAPMODE :
	40	* Select how default compression functions will allocate memory for their hash table,
	41	* in memory stack (0:default, fastest), or in memory heap (1:requires malloc()).
	42	*/
46	43	#define HEAPMODE 0
47	44
48
49		//**************************************
50		// CPU Feature Detection
51		//**************************************
52		// 32 or 64 bits ?
53		#if (defined(__x86_64__) \|\| defined(_M_X64) \|\| defined(_WIN64) \
54		\|\| defined(__powerpc64__) \|\| defined(__ppc64__) \|\| defined(__PPC64__) \
55		\|\| defined(__64BIT__) \|\| defined(_LP64) \|\| defined(__LP64__) \
56		\|\| defined(__ia64) \|\| defined(__itanium__) \|\| defined(_M_IA64) ) // Detects 64 bits mode
57		# define LZ4_ARCH64 1
58		#else
59		# define LZ4_ARCH64 0
60		#endif
61
62		// Little Endian or Big Endian ?
63		// Overwrite the #define below if you know your architecture endianess
64		#if defined (__GLIBC__)
65		# include <endian.h>
66		# if (__BYTE_ORDER == __BIG_ENDIAN)
67		# define LZ4_BIG_ENDIAN 1
68		# endif
69		#elif (defined(__BIG_ENDIAN__) \|\| defined(__BIG_ENDIAN) \|\| defined(_BIG_ENDIAN)) && !(defined(__LITTLE_ENDIAN__) \|\| defined(__LITTLE_ENDIAN) \|\| defined(_LITTLE_ENDIAN))
70		# define LZ4_BIG_ENDIAN 1
71		#elif defined(__sparc) \|\| defined(__sparc__) \
72		\|\| defined(__powerpc__) \|\| defined(__ppc__) \|\| defined(__PPC__) \
73		\|\| defined(__hpux) \|\| defined(__hppa) \
74		\|\| defined(_MIPSEB) \|\| defined(__s390__)
75		# define LZ4_BIG_ENDIAN 1
76		#else
77		// Little Endian assumed. PDP Endian and other very rare endian format are unsupported.
78		#endif
79
80		// Unaligned memory access is automatically enabled for "common" CPU, such as x86.
81		// For others CPU, such as ARM, the compiler may be more cautious, inserting unnecessary extra code to ensure aligned access property
82		// If you know your target CPU supports unaligned memory access, you want to force this option manually to improve performance
83		#if defined(__ARM_FEATURE_UNALIGNED)
84		# define LZ4_FORCE_UNALIGNED_ACCESS 1
85		#endif
86
87		// Define this parameter if your target system or compiler does not support hardware bit count
88		#if defined(_MSC_VER) && defined(_WIN32_WCE) // Visual Studio for Windows CE does not support Hardware bit count
	45	/*
	46	* ACCELERATION_DEFAULT :
	47	* Select "acceleration" for LZ4_compress_fast() when parameter value <= 0
	48	*/
	49	#define ACCELERATION_DEFAULT 1
	50
	51
	52	/**************************************
	53	* CPU Feature Detection
	54	**************************************/
	55	/*
	56	* LZ4_FORCE_SW_BITCOUNT
	57	* Define this parameter if your target system or compiler does not support hardware bit count
	58	*/
	59	#if defined(_MSC_VER) && defined(_WIN32_WCE) /* Visual Studio for Windows CE does not support Hardware bit count */
89	60	# define LZ4_FORCE_SW_BITCOUNT
90	61	#endif
91	62
92		// BIG_ENDIAN_NATIVE_BUT_INCOMPATIBLE :
93		// This option may provide a small boost to performance for some big endian cpu, although probably modest.
94		// You may set this option to 1 if data will remain within closed environment.
95		// This option is useless on Little_Endian CPU (such as x86)
96		//#define BIG_ENDIAN_NATIVE_BUT_INCOMPATIBLE 1
97
98
99		//**************************************
100		// Compiler Options
101		//**************************************
102		#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) // C99
103		/* "restrict" is a known keyword */
	63
	64	/**************************************
	65	* Includes
	66	**************************************/
	67	#include "lz4.h"
	68
	69
	70	/**************************************
	71	* Compiler Options
	72	**************************************/
	73	#ifdef _MSC_VER /* Visual Studio */
	74	# define FORCE_INLINE static __forceinline
	75	# include <intrin.h>
	76	# pragma warning(disable : 4127) /* disable: C4127: conditional expression is constant */
	77	# pragma warning(disable : 4293) /* disable: C4293: too large shift (32-bits) */
104	78	#else
105		# define restrict // Disable restrict
106		#endif
107
108		#ifdef _MSC_VER // Visual Studio
109		# define FORCE_INLINE static __forceinline
110		# include <intrin.h> // For Visual 2005
111		# if LZ4_ARCH64 // 64-bits
112		# pragma intrinsic(_BitScanForward64) // For Visual 2005
113		# pragma intrinsic(_BitScanReverse64) // For Visual 2005
114		# else // 32-bits
115		# pragma intrinsic(_BitScanForward) // For Visual 2005
116		# pragma intrinsic(_BitScanReverse) // For Visual 2005
117		# endif
118		# pragma warning(disable : 4127) // disable: C4127: conditional expression is constant
119		#else
120		# ifdef __GNUC__
121		# define FORCE_INLINE static inline __attribute__((always_inline))
	79	# if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */
	80	# if defined(__GNUC__) \|\| defined(__clang__)
	81	# define FORCE_INLINE static inline __attribute__((always_inline))
	82	# else
	83	# define FORCE_INLINE static inline
	84	# endif
122	85	# else
123		# define FORCE_INLINE static inline
124		# endif
125		#endif
126
127		#ifdef _MSC_VER
128		# define lz4_bswap16(x) _byteswap_ushort(x)
129		#else
130		# define lz4_bswap16(x) ((unsigned short int) ((((x) >> 8) & 0xffu) \| (((x) & 0xffu) << 8)))
131		#endif
132
133		#define GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
134
135		#if (GCC_VERSION >= 302) \|\| (__INTEL_COMPILER >= 800) \|\| defined(__clang__)
	86	# define FORCE_INLINE static
	87	# endif /* __STDC_VERSION__ */
	88	#endif /* _MSC_VER */
	89
	90	/* LZ4_GCC_VERSION is defined into lz4.h */
	91	#if (LZ4_GCC_VERSION >= 302) \|\| (__INTEL_COMPILER >= 800) \|\| defined(__clang__)
136	92	# define expect(expr,value) (__builtin_expect ((expr),(value)) )
137	93	#else
138	94	# define expect(expr,value) (expr)

142	98	#define unlikely(expr) expect((expr) != 0, 0)
143	99
144	100
145		//**************************************
146		// Memory routines
147		//**************************************
148		#include <stdlib.h> // malloc, calloc, free
	101	/**************************************
	102	* Memory routines
	103	**************************************/
	104	#include <stdlib.h> /* malloc, calloc, free */
149	105	#define ALLOCATOR(n,s) calloc(n,s)
150	106	#define FREEMEM free
151		#include <string.h> // memset, memcpy
	107	#include <string.h> /* memset, memcpy */
152	108	#define MEM_INIT memset
153	109
154	110
155		//**************************************
156		// Includes
157		//**************************************
158		#include "lz4.h"
159
160
161		//**************************************
162		// Basic Types
163		//**************************************
164		#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L // C99
	111	/**************************************
	112	* Basic Types
	113	**************************************/
	114	#if defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */
165	115	# include <stdint.h>
166	116	typedef uint8_t BYTE;
167	117	typedef uint16_t U16;

176	126	typedef unsigned long long U64;
177	127	#endif
178	128
179		#if defined(__GNUC__) && !defined(LZ4_FORCE_UNALIGNED_ACCESS)
180		# define _PACKED __attribute__ ((packed))
181		#else
182		# define _PACKED
183		#endif
184
185		#if !defined(LZ4_FORCE_UNALIGNED_ACCESS) && !defined(__GNUC__)
186		# if defined(__IBMC__) \|\| defined(__SUNPRO_C) \|\| defined(__SUNPRO_CC)
187		# pragma pack(1)
188		# else
189		# pragma pack(push, 1)
190		# endif
191		#endif
192
193		typedef struct { U16 v; } _PACKED U16_S;
194		typedef struct { U32 v; } _PACKED U32_S;
195		typedef struct { U64 v; } _PACKED U64_S;
196		typedef struct {size_t v;} _PACKED size_t_S;
197
198		#if !defined(LZ4_FORCE_UNALIGNED_ACCESS) && !defined(__GNUC__)
199		# if defined(__SUNPRO_C) \|\| defined(__SUNPRO_CC)
200		# pragma pack(0)
201		# else
202		# pragma pack(pop)
203		# endif
204		#endif
205
206		#define A16(x) (((U16_S *)(x))->v)
207		#define A32(x) (((U32_S *)(x))->v)
208		#define A64(x) (((U64_S *)(x))->v)
209		#define AARCH(x) (((size_t_S *)(x))->v)
210
211
212		//**************************************
213		// Constants
214		//**************************************
215		#define LZ4_HASHLOG (MEMORY_USAGE-2)
216		#define HASHTABLESIZE (1 << MEMORY_USAGE)
217		#define HASHNBCELLS4 (1 << LZ4_HASHLOG)
218
	129
	130	/**************************************
	131	* Reading and writing into memory
	132	**************************************/
	133	#define STEPSIZE sizeof(size_t)
	134
	135	static unsigned LZ4_64bits(void) { return sizeof(void*)==8; }
	136
	137	static unsigned LZ4_isLittleEndian(void)
	138	{
	139	const union { U32 i; BYTE c[4]; } one = { 1 }; /* don't use static : performance detrimental */
	140	return one.c[0];
	141	}
	142
	143
	144	static U16 LZ4_read16(const void* memPtr)
	145	{
	146	U16 val16;
	147	memcpy(&val16, memPtr, 2);
	148	return val16;
	149	}
	150
	151	static U16 LZ4_readLE16(const void* memPtr)
	152	{
	153	if (LZ4_isLittleEndian())
	154	{
	155	return LZ4_read16(memPtr);
	156	}
	157	else
	158	{
	159	const BYTE* p = (const BYTE*)memPtr;
	160	return (U16)((U16)p[0] + (p[1]<<8));
	161	}
	162	}
	163
	164	static void LZ4_writeLE16(void* memPtr, U16 value)
	165	{
	166	if (LZ4_isLittleEndian())
	167	{
	168	memcpy(memPtr, &value, 2);
	169	}
	170	else
	171	{
	172	BYTE* p = (BYTE*)memPtr;
	173	p[0] = (BYTE) value;
	174	p[1] = (BYTE)(value>>8);
	175	}
	176	}
	177
	178	static U32 LZ4_read32(const void* memPtr)
	179	{
	180	U32 val32;
	181	memcpy(&val32, memPtr, 4);
	182	return val32;
	183	}
	184
	185	static U64 LZ4_read64(const void* memPtr)
	186	{
	187	U64 val64;
	188	memcpy(&val64, memPtr, 8);
	189	return val64;
	190	}
	191
	192	static size_t LZ4_read_ARCH(const void* p)
	193	{
	194	if (LZ4_64bits())
	195	return (size_t)LZ4_read64(p);
	196	else
	197	return (size_t)LZ4_read32(p);
	198	}
	199
	200
	201	static void LZ4_copy4(void* dstPtr, const void* srcPtr) { memcpy(dstPtr, srcPtr, 4); }
	202
	203	static void LZ4_copy8(void* dstPtr, const void* srcPtr) { memcpy(dstPtr, srcPtr, 8); }
	204
	205	/* customized version of memcpy, which may overwrite up to 7 bytes beyond dstEnd */
	206	static void LZ4_wildCopy(void* dstPtr, const void* srcPtr, void* dstEnd)
	207	{
	208	BYTE* d = (BYTE*)dstPtr;
	209	const BYTE* s = (const BYTE*)srcPtr;
	210	BYTE* e = (BYTE*)dstEnd;
	211	do { LZ4_copy8(d,s); d+=8; s+=8; } while (d<e);
	212	}
	213
	214
	215	/**************************************
	216	* Common Constants
	217	**************************************/
219	218	#define MINMATCH 4
220	219
221	220	#define COPYLENGTH 8
222	221	#define LASTLITERALS 5
223	222	#define MFLIMIT (COPYLENGTH+MINMATCH)
224		const int LZ4_minLength = (MFLIMIT+1);
225
226		#define LZ4_64KLIMIT ((1<<16) + (MFLIMIT-1))
227		#define SKIPSTRENGTH 6 // Increasing this value will make the compression run slower on incompressible data
	223	static const int LZ4_minLength = (MFLIMIT+1);
	224
	225	#define KB *(1 <<10)
	226	#define MB *(1 <<20)
	227	#define GB *(1U<<30)
228	228
229	229	#define MAXD_LOG 16
230	230	#define MAX_DISTANCE ((1 << MAXD_LOG) - 1)

234	234	#define RUN_BITS (8-ML_BITS)
235	235	#define RUN_MASK ((1U<<RUN_BITS)-1)
236	236
237		#define KB *(1U<<10)
238		#define MB *(1U<<20)
239		#define GB *(1U<<30)
240
241
242		//**************************************
243		// Structures and local types
244		//**************************************
245
	237
	238	/**************************************
	239	* Common Utils
	240	**************************************/
	241	#define LZ4_STATIC_ASSERT(c) { enum { LZ4_static_assert = 1/(int)(!!(c)) }; } /* use only after variable declarations */
	242
	243
	244	/**************************************
	245	* Common functions
	246	**************************************/
	247	static unsigned LZ4_NbCommonBytes (register size_t val)
	248	{
	249	if (LZ4_isLittleEndian())
	250	{
	251	if (LZ4_64bits())
	252	{
	253	# if defined(_MSC_VER) && defined(_WIN64) && !defined(LZ4_FORCE_SW_BITCOUNT)
	254	unsigned long r = 0;
	255	_BitScanForward64( &r, (U64)val );
	256	return (int)(r>>3);
	257	# elif (defined(__clang__) \|\| (LZ4_GCC_VERSION >= 304)) && !defined(LZ4_FORCE_SW_BITCOUNT)
	258	return (__builtin_ctzll((U64)val) >> 3);
	259	# else
	260	static const int DeBruijnBytePos[64] = { 0, 0, 0, 0, 0, 1, 1, 2, 0, 3, 1, 3, 1, 4, 2, 7, 0, 2, 3, 6, 1, 5, 3, 5, 1, 3, 4, 4, 2, 5, 6, 7, 7, 0, 1, 2, 3, 3, 4, 6, 2, 6, 5, 5, 3, 4, 5, 6, 7, 1, 2, 4, 6, 4, 4, 5, 7, 2, 6, 5, 7, 6, 7, 7 };
	261	return DeBruijnBytePos[((U64)((val & -(long long)val) * 0x0218A392CDABBD3FULL)) >> 58];
	262	# endif
	263	}
	264	else /* 32 bits */
	265	{
	266	# if defined(_MSC_VER) && !defined(LZ4_FORCE_SW_BITCOUNT)
	267	unsigned long r;
	268	_BitScanForward( &r, (U32)val );
	269	return (int)(r>>3);
	270	# elif (defined(__clang__) \|\| (LZ4_GCC_VERSION >= 304)) && !defined(LZ4_FORCE_SW_BITCOUNT)
	271	return (__builtin_ctz((U32)val) >> 3);
	272	# else
	273	static const int DeBruijnBytePos[32] = { 0, 0, 3, 0, 3, 1, 3, 0, 3, 2, 2, 1, 3, 2, 0, 1, 3, 3, 1, 2, 2, 2, 2, 0, 3, 1, 2, 0, 1, 0, 1, 1 };
	274	return DeBruijnBytePos[((U32)((val & -(S32)val) * 0x077CB531U)) >> 27];
	275	# endif
	276	}
	277	}
	278	else /* Big Endian CPU */
	279	{
	280	if (LZ4_64bits())
	281	{
	282	# if defined(_MSC_VER) && defined(_WIN64) && !defined(LZ4_FORCE_SW_BITCOUNT)
	283	unsigned long r = 0;
	284	_BitScanReverse64( &r, val );
	285	return (unsigned)(r>>3);
	286	# elif (defined(__clang__) \|\| (LZ4_GCC_VERSION >= 304)) && !defined(LZ4_FORCE_SW_BITCOUNT)
	287	return (__builtin_clzll((U64)val) >> 3);
	288	# else
	289	unsigned r;
	290	if (!(val>>32)) { r=4; } else { r=0; val>>=32; }
	291	if (!(val>>16)) { r+=2; val>>=8; } else { val>>=24; }
	292	r += (!val);
	293	return r;
	294	# endif
	295	}
	296	else /* 32 bits */
	297	{
	298	# if defined(_MSC_VER) && !defined(LZ4_FORCE_SW_BITCOUNT)
	299	unsigned long r = 0;
	300	_BitScanReverse( &r, (unsigned long)val );
	301	return (unsigned)(r>>3);
	302	# elif (defined(__clang__) \|\| (LZ4_GCC_VERSION >= 304)) && !defined(LZ4_FORCE_SW_BITCOUNT)
	303	return (__builtin_clz((U32)val) >> 3);
	304	# else
	305	unsigned r;
	306	if (!(val>>16)) { r=2; val>>=8; } else { r=0; val>>=24; }
	307	r += (!val);
	308	return r;
	309	# endif
	310	}
	311	}
	312	}
	313
	314	static unsigned LZ4_count(const BYTE* pIn, const BYTE* pMatch, const BYTE* pInLimit)
	315	{
	316	const BYTE* const pStart = pIn;
	317
	318	while (likely(pIn<pInLimit-(STEPSIZE-1)))
	319	{
	320	size_t diff = LZ4_read_ARCH(pMatch) ^ LZ4_read_ARCH(pIn);
	321	if (!diff) { pIn+=STEPSIZE; pMatch+=STEPSIZE; continue; }
	322	pIn += LZ4_NbCommonBytes(diff);
	323	return (unsigned)(pIn - pStart);
	324	}
	325
	326	if (LZ4_64bits()) if ((pIn<(pInLimit-3)) && (LZ4_read32(pMatch) == LZ4_read32(pIn))) { pIn+=4; pMatch+=4; }
	327	if ((pIn<(pInLimit-1)) && (LZ4_read16(pMatch) == LZ4_read16(pIn))) { pIn+=2; pMatch+=2; }
	328	if ((pIn<pInLimit) && (pMatch == pIn)) pIn++;
	329	return (unsigned)(pIn - pStart);
	330	}
	331
	332
	333	#ifndef LZ4_COMMONDEFS_ONLY
	334	/**************************************
	335	* Local Constants
	336	**************************************/
	337	#define LZ4_HASHLOG (LZ4_MEMORY_USAGE-2)
	338	#define HASHTABLESIZE (1 << LZ4_MEMORY_USAGE)
	339	#define HASH_SIZE_U32 (1 << LZ4_HASHLOG) /* required as macro for static allocation */
	340
	341	static const int LZ4_64Klimit = ((64 KB) + (MFLIMIT-1));
	342	static const U32 LZ4_skipTrigger = 6; /* Increase this value ==> compression run slower on incompressible data */
	343
	344
	345	/**************************************
	346	* Local Structures and types
	347	**************************************/
246	348	typedef struct {
247		U32 hashTable[HASHNBCELLS4];
248		const BYTE* bufferStart;
249		const BYTE* base;
250		const BYTE* nextBlock;
251		} LZ4_Data_Structure;
252
253		typedef enum { notLimited = 0, limited = 1 } limitedOutput_directive;
	349	U32 hashTable[HASH_SIZE_U32];
	350	U32 currentOffset;
	351	U32 initCheck;
	352	const BYTE* dictionary;
	353	BYTE* bufferStart; /* obsolete, used for slideInputBuffer */
	354	U32 dictSize;
	355	} LZ4_stream_t_internal;
	356
	357	typedef enum { notLimited = 0, limitedOutput = 1 } limitedOutput_directive;
254	358	typedef enum { byPtr, byU32, byU16 } tableType_t;
255	359
256		typedef enum { noPrefix = 0, withPrefix = 1 } prefix64k_directive;
	360	typedef enum { noDict = 0, withPrefix64k, usingExtDict } dict_directive;
	361	typedef enum { noDictIssue = 0, dictSmall } dictIssue_directive;
257	362
258	363	typedef enum { endOnOutputSize = 0, endOnInputSize = 1 } endCondition_directive;
259	364	typedef enum { full = 0, partial = 1 } earlyEnd_directive;
260	365
261	366
262		//**************************************
263		// Architecture-specific macros
264		//**************************************
265		#define STEPSIZE sizeof(size_t)
266		#define LZ4_COPYSTEP(d,s) { AARCH(d) = AARCH(s); d+=STEPSIZE; s+=STEPSIZE; }
267		#define LZ4_COPY8(d,s) { LZ4_COPYSTEP(d,s); if (STEPSIZE<8) LZ4_COPYSTEP(d,s); }
268		#define LZ4_SECURECOPY(d,s,e) { if ((STEPSIZE==4)\|\|(d<e)) LZ4_WILDCOPY(d,s,e); }
269
270		#if LZ4_ARCH64 // 64-bit
271		# define HTYPE U32
272		# define INITBASE(base) const BYTE* const base = ip
273		#else // 32-bit
274		# define HTYPE const BYTE*
275		# define INITBASE(base) const int base = 0
276		#endif
277
278		#if (defined(LZ4_BIG_ENDIAN) && !defined(BIG_ENDIAN_NATIVE_BUT_INCOMPATIBLE))
279		# define LZ4_READ_LITTLEENDIAN_16(d,s,p) { U16 v = A16(p); v = lz4_bswap16(v); d = (s) - v; }
280		# define LZ4_WRITE_LITTLEENDIAN_16(p,i) { U16 v = (U16)(i); v = lz4_bswap16(v); A16(p) = v; p+=2; }
281		#else // Little Endian
282		# define LZ4_READ_LITTLEENDIAN_16(d,s,p) { d = (s) - A16(p); }
283		# define LZ4_WRITE_LITTLEENDIAN_16(p,v) { A16(p) = v; p+=2; }
284		#endif
285
286
287		//**************************************
288		// Macros
289		//**************************************
290		#define LZ4_WILDCOPY(d,s,e) { do { LZ4_COPY8(d,s) } while (d<e); } // at the end, d>=e;
291
292
293		//****************************
294		// Private functions
295		//****************************
296		#if LZ4_ARCH64
297
298		FORCE_INLINE int LZ4_NbCommonBytes (register U64 val)
299		{
300		# if defined(LZ4_BIG_ENDIAN)
301		# if defined(_MSC_VER) && !defined(LZ4_FORCE_SW_BITCOUNT)
302		unsigned long r = 0;
303		_BitScanReverse64( &r, val );
304		return (int)(r>>3);
305		# elif defined(__GNUC__) && (GCC_VERSION >= 304) && !defined(LZ4_FORCE_SW_BITCOUNT)
306		return (__builtin_clzll(val) >> 3);
307		# else
308		int r;
309		if (!(val>>32)) { r=4; } else { r=0; val>>=32; }
310		if (!(val>>16)) { r+=2; val>>=8; } else { val>>=24; }
311		r += (!val);
312		return r;
313		# endif
314		# else
315		# if defined(_MSC_VER) && !defined(LZ4_FORCE_SW_BITCOUNT)
316		unsigned long r = 0;
317		_BitScanForward64( &r, val );
318		return (int)(r>>3);
319		# elif defined(__GNUC__) && (GCC_VERSION >= 304) && !defined(LZ4_FORCE_SW_BITCOUNT)
320		return (__builtin_ctzll(val) >> 3);
321		# else
322		static const int DeBruijnBytePos[64] = { 0, 0, 0, 0, 0, 1, 1, 2, 0, 3, 1, 3, 1, 4, 2, 7, 0, 2, 3, 6, 1, 5, 3, 5, 1, 3, 4, 4, 2, 5, 6, 7, 7, 0, 1, 2, 3, 3, 4, 6, 2, 6, 5, 5, 3, 4, 5, 6, 7, 1, 2, 4, 6, 4, 4, 5, 7, 2, 6, 5, 7, 6, 7, 7 };
323		return DeBruijnBytePos[((U64)((val & -(long long)val) * 0x0218A392CDABBD3FULL)) >> 58];
324		# endif
325		# endif
326		}
327
328		#else
329
330		FORCE_INLINE int LZ4_NbCommonBytes (register U32 val)
331		{
332		# if defined(LZ4_BIG_ENDIAN)
333		# if defined(_MSC_VER) && !defined(LZ4_FORCE_SW_BITCOUNT)
334		unsigned long r = 0;
335		_BitScanReverse( &r, val );
336		return (int)(r>>3);
337		# elif defined(__GNUC__) && (GCC_VERSION >= 304) && !defined(LZ4_FORCE_SW_BITCOUNT)
338		return (__builtin_clz(val) >> 3);
339		# else
340		int r;
341		if (!(val>>16)) { r=2; val>>=8; } else { r=0; val>>=24; }
342		r += (!val);
343		return r;
344		# endif
345		# else
346		# if defined(_MSC_VER) && !defined(LZ4_FORCE_SW_BITCOUNT)
347		unsigned long r;
348		_BitScanForward( &r, val );
349		return (int)(r>>3);
350		# elif defined(__GNUC__) && (GCC_VERSION >= 304) && !defined(LZ4_FORCE_SW_BITCOUNT)
351		return (__builtin_ctz(val) >> 3);
352		# else
353		static const int DeBruijnBytePos[32] = { 0, 0, 3, 0, 3, 1, 3, 0, 3, 2, 2, 1, 3, 2, 0, 1, 3, 3, 1, 2, 2, 2, 2, 0, 3, 1, 2, 0, 1, 0, 1, 1 };
354		return DeBruijnBytePos[((U32)((val & -(S32)val) * 0x077CB531U)) >> 27];
355		# endif
356		# endif
357		}
358
359		#endif
360
361
362		//****************************
363		// Compression functions
364		//****************************
365		FORCE_INLINE int LZ4_hashSequence(U32 sequence, tableType_t tableType)
	367	/**************************************
	368	* Local Utils
	369	**************************************/
	370	int LZ4_versionNumber (void) { return LZ4_VERSION_NUMBER; }
	371	int LZ4_compressBound(int isize) { return LZ4_COMPRESSBOUND(isize); }
	372	int LZ4_sizeofState() { return LZ4_STREAMSIZE; }
	373
	374
	375
	376	/********************************
	377	* Compression functions
	378	********************************/
	379
	380	static U32 LZ4_hashSequence(U32 sequence, tableType_t const tableType)
366	381	{
367	382	if (tableType == byU16)
368	383	return (((sequence) * 2654435761U) >> ((MINMATCH*8)-(LZ4_HASHLOG+1)));

370	385	return (((sequence) * 2654435761U) >> ((MINMATCH*8)-LZ4_HASHLOG));
371	386	}
372	387
373		FORCE_INLINE int LZ4_hashPosition(const BYTE* p, tableType_t tableType) { return LZ4_hashSequence(A32(p), tableType); }
374
375		FORCE_INLINE void LZ4_putPositionOnHash(const BYTE* p, U32 h, void* tableBase, tableType_t tableType, const BYTE* srcBase)
	388	static const U64 prime5bytes = 889523592379ULL;
	389	static U32 LZ4_hashSequence64(size_t sequence, tableType_t const tableType)
	390	{
	391	const U32 hashLog = (tableType == byU16) ? LZ4_HASHLOG+1 : LZ4_HASHLOG;
	392	const U32 hashMask = (1<<hashLog) - 1;
	393	return ((sequence * prime5bytes) >> (40 - hashLog)) & hashMask;
	394	}
	395
	396	static U32 LZ4_hashSequenceT(size_t sequence, tableType_t const tableType)
	397	{
	398	if (LZ4_64bits())
	399	return LZ4_hashSequence64(sequence, tableType);
	400	return LZ4_hashSequence((U32)sequence, tableType);
	401	}
	402
	403	static U32 LZ4_hashPosition(const void* p, tableType_t tableType) { return LZ4_hashSequenceT(LZ4_read_ARCH(p), tableType); }
	404
	405	static void LZ4_putPositionOnHash(const BYTE* p, U32 h, void* tableBase, tableType_t const tableType, const BYTE* srcBase)
376	406	{
377	407	switch (tableType)
378	408	{
379		case byPtr: { const BYTE hashTable = (const BYTE) tableBase; hashTable[h] = p; break; }
380		case byU32: { U32* hashTable = (U32*) tableBase; hashTable[h] = (U32)(p-srcBase); break; }
381		case byU16: { U16* hashTable = (U16*) tableBase; hashTable[h] = (U16)(p-srcBase); break; }
382		}
383		}
384
385		FORCE_INLINE void LZ4_putPosition(const BYTE* p, void* tableBase, tableType_t tableType, const BYTE* srcBase)
	409	case byPtr: { const BYTE hashTable = (const BYTE)tableBase; hashTable[h] = p; return; }
	410	case byU32: { U32* hashTable = (U32*) tableBase; hashTable[h] = (U32)(p-srcBase); return; }
	411	case byU16: { U16* hashTable = (U16*) tableBase; hashTable[h] = (U16)(p-srcBase); return; }
	412	}
	413	}
	414
	415	static void LZ4_putPosition(const BYTE* p, void* tableBase, tableType_t tableType, const BYTE* srcBase)
386	416	{
387	417	U32 h = LZ4_hashPosition(p, tableType);
388	418	LZ4_putPositionOnHash(p, h, tableBase, tableType, srcBase);
389	419	}
390	420
391		FORCE_INLINE const BYTE* LZ4_getPositionOnHash(U32 h, void* tableBase, tableType_t tableType, const BYTE* srcBase)
	421	static const BYTE* LZ4_getPositionOnHash(U32 h, void* tableBase, tableType_t tableType, const BYTE* srcBase)
392	422	{
393	423	if (tableType == byPtr) { const BYTE hashTable = (const BYTE) tableBase; return hashTable[h]; }
394	424	if (tableType == byU32) { U32* hashTable = (U32*) tableBase; return hashTable[h] + srcBase; }
395		{ U16* hashTable = (U16*) tableBase; return hashTable[h] + srcBase; } // default, to ensure a return
396		}
397
398		FORCE_INLINE const BYTE* LZ4_getPosition(const BYTE* p, void* tableBase, tableType_t tableType, const BYTE* srcBase)
	425	{ U16* hashTable = (U16) tableBase; return hashTable[h] + srcBase; } / default, to ensure a return */
	426	}
	427
	428	static const BYTE* LZ4_getPosition(const BYTE* p, void* tableBase, tableType_t tableType, const BYTE* srcBase)
399	429	{
400	430	U32 h = LZ4_hashPosition(p, tableType);
401	431	return LZ4_getPositionOnHash(h, tableBase, tableType, srcBase);
402	432	}
403	433
404
405	434	FORCE_INLINE int LZ4_compress_generic(
406		void* ctx,
407		const char* source,
408		char* dest,
409		int inputSize,
410		int maxOutputSize,
411
412		limitedOutput_directive limitedOutput,
413		tableType_t tableType,
414		prefix64k_directive prefix)
415		{
	435	void* const ctx,
	436	const char* const source,
	437	char* const dest,
	438	const int inputSize,
	439	const int maxOutputSize,
	440	const limitedOutput_directive outputLimited,
	441	const tableType_t tableType,
	442	const dict_directive dict,
	443	const dictIssue_directive dictIssue,
	444	const U32 acceleration)
	445	{
	446	LZ4_stream_t_internal* const dictPtr = (LZ4_stream_t_internal*)ctx;
	447
416	448	const BYTE* ip = (const BYTE*) source;
417		const BYTE* const base = (prefix==withPrefix) ? ((LZ4_Data_Structure)ctx)->base : (const BYTE) source;
418		const BYTE* const lowLimit = ((prefix==withPrefix) ? ((LZ4_Data_Structure)ctx)->bufferStart : (const BYTE)source);
	449	const BYTE* base;
	450	const BYTE* lowLimit;
	451	const BYTE* const lowRefLimit = ip - dictPtr->dictSize;
	452	const BYTE* const dictionary = dictPtr->dictionary;
	453	const BYTE* const dictEnd = dictionary + dictPtr->dictSize;
	454	const size_t dictDelta = dictEnd - (const BYTE*)source;
419	455	const BYTE* anchor = (const BYTE*) source;
420	456	const BYTE* const iend = ip + inputSize;
421	457	const BYTE* const mflimit = iend - MFLIMIT;
422	458	const BYTE* const matchlimit = iend - LASTLITERALS;
423	459
424	460	BYTE* op = (BYTE*) dest;
425		BYTE* const oend = op + maxOutputSize;
426
427		int length;
428		const int skipStrength = SKIPSTRENGTH;
	461	BYTE* const olimit = op + maxOutputSize;
	462
429	463	U32 forwardH;
430
431		// Init conditions
432		if ((U32)inputSize > (U32)LZ4_MAX_INPUT_SIZE) return 0; // Unsupported input size, too large (or negative)
433		if ((prefix==withPrefix) && (ip != ((LZ4_Data_Structure*)ctx)->nextBlock)) return 0; // must continue from end of previous block
434		if (prefix==withPrefix) ((LZ4_Data_Structure*)ctx)->nextBlock=iend; // do it now, due to potential early exit
435		if ((tableType == byU16) && (inputSize>=LZ4_64KLIMIT)) return 0; // Size too large (not within 64K limit)
436		if (inputSize<LZ4_minLength) goto _last_literals; // Input too small, no compression (all literals)
437
438		// First Byte
	464	size_t refDelta=0;
	465
	466	/* Init conditions */
	467	if ((U32)inputSize > (U32)LZ4_MAX_INPUT_SIZE) return 0; /* Unsupported input size, too large (or negative) */
	468	switch(dict)
	469	{
	470	case noDict:
	471	default:
	472	base = (const BYTE*)source;
	473	lowLimit = (const BYTE*)source;
	474	break;
	475	case withPrefix64k:
	476	base = (const BYTE*)source - dictPtr->currentOffset;
	477	lowLimit = (const BYTE*)source - dictPtr->dictSize;
	478	break;
	479	case usingExtDict:
	480	base = (const BYTE*)source - dictPtr->currentOffset;
	481	lowLimit = (const BYTE*)source;
	482	break;
	483	}
	484	if ((tableType == byU16) && (inputSize>=LZ4_64Klimit)) return 0; /* Size too large (not within 64K limit) */
	485	if (inputSize<LZ4_minLength) goto _last_literals; /* Input too small, no compression (all literals) */
	486
	487	/* First Byte */
439	488	LZ4_putPosition(ip, ctx, tableType, base);
440	489	ip++; forwardH = LZ4_hashPosition(ip, tableType);
441	490
442		// Main Loop
	491	/* Main Loop */
443	492	for ( ; ; )
444	493	{
445		int findMatchAttempts = (1U << skipStrength) + 3;
446		const BYTE* forwardIp = ip;
447		const BYTE* ref;
	494	const BYTE* match;
448	495	BYTE* token;
449
450		// Find a match
451		do {
452		U32 h = forwardH;
453		int step = findMatchAttempts++ >> skipStrength;
454		ip = forwardIp;
455		forwardIp = ip + step;
456
457		if unlikely(forwardIp > mflimit) { goto _last_literals; }
458
459		forwardH = LZ4_hashPosition(forwardIp, tableType);
460		ref = LZ4_getPositionOnHash(h, ctx, tableType, base);
461		LZ4_putPositionOnHash(ip, h, ctx, tableType, base);
462
463		} while ((ref + MAX_DISTANCE < ip) \|\| (A32(ref) != A32(ip)));
464
465		// Catch up
466		while ((ip>anchor) && (ref > lowLimit) && unlikely(ip[-1]==ref[-1])) { ip--; ref--; }
467
468		// Encode Literal length
469		length = (int)(ip - anchor);
470		token = op++;
471		if ((limitedOutput) && unlikely(op + length + (2 + 1 + LASTLITERALS) + (length/255) > oend)) return 0; // Check output limit
472		if (length>=(int)RUN_MASK)
473		{
474		int len = length-RUN_MASK;
475		*token=(RUN_MASK<<ML_BITS);
476		for(; len >= 255 ; len-=255) *op++ = 255;
477		*op++ = (BYTE)len;
478		}
479		else *token = (BYTE)(length<<ML_BITS);
480
481		// Copy Literals
482		{ BYTE* end=(op)+(length); LZ4_WILDCOPY(op,anchor,end); op=end; }
	496	{
	497	const BYTE* forwardIp = ip;
	498	unsigned step = 1;
	499	unsigned searchMatchNb = acceleration << LZ4_skipTrigger;
	500
	501	/* Find a match */
	502	do {
	503	U32 h = forwardH;
	504	ip = forwardIp;
	505	forwardIp += step;
	506	step = (searchMatchNb++ >> LZ4_skipTrigger);
	507
	508	if (unlikely(forwardIp > mflimit)) goto _last_literals;
	509
	510	match = LZ4_getPositionOnHash(h, ctx, tableType, base);
	511	if (dict==usingExtDict)
	512	{
	513	if (match<(const BYTE*)source)
	514	{
	515	refDelta = dictDelta;
	516	lowLimit = dictionary;
	517	}
	518	else
	519	{
	520	refDelta = 0;
	521	lowLimit = (const BYTE*)source;
	522	}
	523	}
	524	forwardH = LZ4_hashPosition(forwardIp, tableType);
	525	LZ4_putPositionOnHash(ip, h, ctx, tableType, base);
	526
	527	} while ( ((dictIssue==dictSmall) ? (match < lowRefLimit) : 0)
	528	\|\| ((tableType==byU16) ? 0 : (match + MAX_DISTANCE < ip))
	529	\|\| (LZ4_read32(match+refDelta) != LZ4_read32(ip)) );
	530	}
	531
	532	/* Catch up */
	533	while ((ip>anchor) && (match+refDelta > lowLimit) && (unlikely(ip[-1]==match[refDelta-1]))) { ip--; match--; }
	534
	535	{
	536	/* Encode Literal length */
	537	unsigned litLength = (unsigned)(ip - anchor);
	538	token = op++;
	539	if ((outputLimited) && (unlikely(op + litLength + (2 + 1 + LASTLITERALS) + (litLength/255) > olimit)))
	540	return 0; /* Check output limit */
	541	if (litLength>=RUN_MASK)
	542	{
	543	int len = (int)litLength-RUN_MASK;
	544	*token=(RUN_MASK<<ML_BITS);
	545	for(; len >= 255 ; len-=255) *op++ = 255;
	546	*op++ = (BYTE)len;
	547	}
	548	else *token = (BYTE)(litLength<<ML_BITS);
	549
	550	/* Copy Literals */
	551	LZ4_wildCopy(op, anchor, op+litLength);
	552	op+=litLength;
	553	}
483	554
484	555	_next_match:
485		// Encode Offset
486		LZ4_WRITE_LITTLEENDIAN_16(op,(U16)(ip-ref));
487
488		// Start Counting
489		ip+=MINMATCH; ref+=MINMATCH; // MinMatch already verified
	556	/* Encode Offset */
	557	LZ4_writeLE16(op, (U16)(ip-match)); op+=2;
	558
	559	/* Encode MatchLength */
	560	{
	561	unsigned matchLength;
	562
	563	if ((dict==usingExtDict) && (lowLimit==dictionary))
	564	{
	565	const BYTE* limit;
	566	match += refDelta;
	567	limit = ip + (dictEnd-match);
	568	if (limit > matchlimit) limit = matchlimit;
	569	matchLength = LZ4_count(ip+MINMATCH, match+MINMATCH, limit);
	570	ip += MINMATCH + matchLength;
	571	if (ip==limit)
	572	{
	573	unsigned more = LZ4_count(ip, (const BYTE*)source, matchlimit);
	574	matchLength += more;
	575	ip += more;
	576	}
	577	}
	578	else
	579	{
	580	matchLength = LZ4_count(ip+MINMATCH, match+MINMATCH, matchlimit);
	581	ip += MINMATCH + matchLength;
	582	}
	583
	584	if ((outputLimited) && (unlikely(op + (1 + LASTLITERALS) + (matchLength>>8) > olimit)))
	585	return 0; /* Check output limit */
	586	if (matchLength>=ML_MASK)
	587	{
	588	*token += ML_MASK;
	589	matchLength -= ML_MASK;
	590	for (; matchLength >= 510 ; matchLength-=510) { op++ = 255; op++ = 255; }
	591	if (matchLength >= 255) { matchLength-=255; *op++ = 255; }
	592	*op++ = (BYTE)matchLength;
	593	}
	594	else *token += (BYTE)(matchLength);
	595	}
	596
490	597	anchor = ip;
491		while likely(ip<matchlimit-(STEPSIZE-1))
492		{
493		size_t diff = AARCH(ref) ^ AARCH(ip);
494		if (!diff) { ip+=STEPSIZE; ref+=STEPSIZE; continue; }
495		ip += LZ4_NbCommonBytes(diff);
496		goto _endCount;
497		}
498		if (LZ4_ARCH64) if ((ip<(matchlimit-3)) && (A32(ref) == A32(ip))) { ip+=4; ref+=4; }
499		if ((ip<(matchlimit-1)) && (A16(ref) == A16(ip))) { ip+=2; ref+=2; }
500		if ((ip<matchlimit) && (ref == ip)) ip++;
501		_endCount:
502
503		// Encode MatchLength
504		length = (int)(ip - anchor);
505		if ((limitedOutput) && unlikely(op + (1 + LASTLITERALS) + (length>>8) > oend)) return 0; // Check output limit
506		if (length>=(int)ML_MASK)
507		{
508		*token += ML_MASK;
509		length -= ML_MASK;
510		for (; length > 509 ; length-=510) { op++ = 255; op++ = 255; }
511		if (length >= 255) { length-=255; *op++ = 255; }
512		*op++ = (BYTE)length;
513		}
514		else *token += (BYTE)(length);
515
516		// Test end of chunk
517		if (ip > mflimit) { anchor = ip; break; }
518
519		// Fill table
	598
	599	/* Test end of chunk */
	600	if (ip > mflimit) break;
	601
	602	/* Fill table */
520	603	LZ4_putPosition(ip-2, ctx, tableType, base);
521	604
522		// Test next position
523		ref = LZ4_getPosition(ip, ctx, tableType, base);
	605	/* Test next position */
	606	match = LZ4_getPosition(ip, ctx, tableType, base);
	607	if (dict==usingExtDict)
	608	{
	609	if (match<(const BYTE*)source)
	610	{
	611	refDelta = dictDelta;
	612	lowLimit = dictionary;
	613	}
	614	else
	615	{
	616	refDelta = 0;
	617	lowLimit = (const BYTE*)source;
	618	}
	619	}
524	620	LZ4_putPosition(ip, ctx, tableType, base);
525		if ((ref + MAX_DISTANCE >= ip) && (A32(ref) == A32(ip))) { token = op++; *token=0; goto _next_match; }
526
527		// Prepare next loop
528		anchor = ip++;
529		forwardH = LZ4_hashPosition(ip, tableType);
	621	if ( ((dictIssue==dictSmall) ? (match>=lowRefLimit) : 1)
	622	&& (match+MAX_DISTANCE>=ip)
	623	&& (LZ4_read32(match+refDelta)==LZ4_read32(ip)) )
	624	{ token=op++; *token=0; goto _next_match; }
	625
	626	/* Prepare next loop */
	627	forwardH = LZ4_hashPosition(++ip, tableType);
530	628	}
531	629
532	630	_last_literals:
533		// Encode Last Literals
534		{
535		int lastRun = (int)(iend - anchor);
536		if ((limitedOutput) && (((char*)op - dest) + lastRun + 1 + ((lastRun+255-RUN_MASK)/255) > (U32)maxOutputSize)) return 0; // Check output limit
537		if (lastRun>=(int)RUN_MASK) { op++=(RUN_MASK<<ML_BITS); lastRun-=RUN_MASK; for(; lastRun >= 255 ; lastRun-=255) op++ = 255; *op++ = (BYTE) lastRun; }
538		else *op++ = (BYTE)(lastRun<<ML_BITS);
539		memcpy(op, anchor, iend - anchor);
540		op += iend-anchor;
541		}
542
543		// End
	631	/* Encode Last Literals */
	632	{
	633	const size_t lastRun = (size_t)(iend - anchor);
	634	if ((outputLimited) && ((op - (BYTE*)dest) + lastRun + 1 + ((lastRun+255-RUN_MASK)/255) > (U32)maxOutputSize))
	635	return 0; /* Check output limit */
	636	if (lastRun >= RUN_MASK)
	637	{
	638	size_t accumulator = lastRun - RUN_MASK;
	639	*op++ = RUN_MASK << ML_BITS;
	640	for(; accumulator >= 255 ; accumulator-=255) *op++ = 255;
	641	*op++ = (BYTE) accumulator;
	642	}
	643	else
	644	{
	645	*op++ = (BYTE)(lastRun<<ML_BITS);
	646	}
	647	memcpy(op, anchor, lastRun);
	648	op += lastRun;
	649	}
	650
	651	/* End */
544	652	return (int) (((char*)op)-dest);
545	653	}
546	654
547	655
548		int LZ4_compress(const char* source, char* dest, int inputSize)
	656	int LZ4_compress_fast_extState(void* state, const char* source, char* dest, int inputSize, int maxOutputSize, int acceleration)
	657	{
	658	LZ4_resetStream((LZ4_stream_t*)state);
	659	if (acceleration < 1) acceleration = ACCELERATION_DEFAULT;
	660
	661	if (maxOutputSize >= LZ4_compressBound(inputSize))
	662	{
	663	if (inputSize < LZ4_64Klimit)
	664	return LZ4_compress_generic(state, source, dest, inputSize, 0, notLimited, byU16, noDict, noDictIssue, acceleration);
	665	else
	666	return LZ4_compress_generic(state, source, dest, inputSize, 0, notLimited, LZ4_64bits() ? byU32 : byPtr, noDict, noDictIssue, acceleration);
	667	}
	668	else
	669	{
	670	if (inputSize < LZ4_64Klimit)
	671	return LZ4_compress_generic(state, source, dest, inputSize, maxOutputSize, limitedOutput, byU16, noDict, noDictIssue, acceleration);
	672	else
	673	return LZ4_compress_generic(state, source, dest, inputSize, maxOutputSize, limitedOutput, LZ4_64bits() ? byU32 : byPtr, noDict, noDictIssue, acceleration);
	674	}
	675	}
	676
	677
	678	int LZ4_compress_fast(const char* source, char* dest, int inputSize, int maxOutputSize, int acceleration)
549	679	{
550	680	#if (HEAPMODE)
551		void* ctx = ALLOCATOR(HASHNBCELLS4, 4); // Aligned on 4-bytes boundaries
	681	void* ctxPtr = ALLOCATOR(1, sizeof(LZ4_stream_t)); /* malloc-calloc always properly aligned */
552	682	#else
553		U32 ctx[1U<<(MEMORY_USAGE-2)] = {0}; // Ensure data is aligned on 4-bytes boundaries
	683	LZ4_stream_t ctx;
	684	void* ctxPtr = &ctx;
554	685	#endif
555		int result;
556
557		if (inputSize < (int)LZ4_64KLIMIT)
558		result = LZ4_compress_generic((void*)ctx, source, dest, inputSize, 0, notLimited, byU16, noPrefix);
	686
	687	int result = LZ4_compress_fast_extState(ctxPtr, source, dest, inputSize, maxOutputSize, acceleration);
	688
	689	#if (HEAPMODE)
	690	FREEMEM(ctxPtr);
	691	#endif
	692	return result;
	693	}
	694
	695
	696	int LZ4_compress_default(const char* source, char* dest, int inputSize, int maxOutputSize)
	697	{
	698	return LZ4_compress_fast(source, dest, inputSize, maxOutputSize, 1);
	699	}
	700
	701
	702	/* hidden debug function */
	703	/* strangely enough, gcc generates faster code when this function is uncommented, even if unused */
	704	int LZ4_compress_fast_force(const char* source, char* dest, int inputSize, int maxOutputSize, int acceleration)
	705	{
	706	LZ4_stream_t ctx;
	707
	708	LZ4_resetStream(&ctx);
	709
	710	if (inputSize < LZ4_64Klimit)
	711	return LZ4_compress_generic(&ctx, source, dest, inputSize, maxOutputSize, limitedOutput, byU16, noDict, noDictIssue, acceleration);
559	712	else
560		result = LZ4_compress_generic((void)ctx, source, dest, inputSize, 0, notLimited, (sizeof(void)==8) ? byU32 : byPtr, noPrefix);
	713	return LZ4_compress_generic(&ctx, source, dest, inputSize, maxOutputSize, limitedOutput, LZ4_64bits() ? byU32 : byPtr, noDict, noDictIssue, acceleration);
	714	}
	715
	716
	717	/********************************
	718	* destSize variant
	719	********************************/
	720
	721	static int LZ4_compress_destSize_generic(
	722	void* const ctx,
	723	const char* const src,
	724	char* const dst,
	725	int* const srcSizePtr,
	726	const int targetDstSize,
	727	const tableType_t tableType)
	728	{
	729	const BYTE* ip = (const BYTE*) src;
	730	const BYTE* base = (const BYTE*) src;
	731	const BYTE* lowLimit = (const BYTE*) src;
	732	const BYTE* anchor = ip;
	733	const BYTE* const iend = ip + *srcSizePtr;
	734	const BYTE* const mflimit = iend - MFLIMIT;
	735	const BYTE* const matchlimit = iend - LASTLITERALS;
	736
	737	BYTE* op = (BYTE*) dst;
	738	BYTE* const oend = op + targetDstSize;
	739	BYTE* const oMaxLit = op + targetDstSize - 2 /* offset / - 8 / because 8+MINMATCH==MFLIMIT / - 1 / token */;
	740	BYTE* const oMaxMatch = op + targetDstSize - (LASTLITERALS + 1 /* token */);
	741	BYTE* const oMaxSeq = oMaxLit - 1 /* token */;
	742
	743	U32 forwardH;
	744
	745
	746	/* Init conditions */
	747	if (targetDstSize < 1) return 0; /* Impossible to store anything */
	748	if ((U32)srcSizePtr > (U32)LZ4_MAX_INPUT_SIZE) return 0; / Unsupported input size, too large (or negative) */
	749	if ((tableType == byU16) && (srcSizePtr>=LZ4_64Klimit)) return 0; / Size too large (not within 64K limit) */
	750	if (srcSizePtr<LZ4_minLength) goto _last_literals; / Input too small, no compression (all literals) */
	751
	752	/* First Byte */
	753	*srcSizePtr = 0;
	754	LZ4_putPosition(ip, ctx, tableType, base);
	755	ip++; forwardH = LZ4_hashPosition(ip, tableType);
	756
	757	/* Main Loop */
	758	for ( ; ; )
	759	{
	760	const BYTE* match;
	761	BYTE* token;
	762	{
	763	const BYTE* forwardIp = ip;
	764	unsigned step = 1;
	765	unsigned searchMatchNb = 1 << LZ4_skipTrigger;
	766
	767	/* Find a match */
	768	do {
	769	U32 h = forwardH;
	770	ip = forwardIp;
	771	forwardIp += step;
	772	step = (searchMatchNb++ >> LZ4_skipTrigger);
	773
	774	if (unlikely(forwardIp > mflimit))
	775	goto _last_literals;
	776
	777	match = LZ4_getPositionOnHash(h, ctx, tableType, base);
	778	forwardH = LZ4_hashPosition(forwardIp, tableType);
	779	LZ4_putPositionOnHash(ip, h, ctx, tableType, base);
	780
	781	} while ( ((tableType==byU16) ? 0 : (match + MAX_DISTANCE < ip))
	782	\|\| (LZ4_read32(match) != LZ4_read32(ip)) );
	783	}
	784
	785	/* Catch up */
	786	while ((ip>anchor) && (match > lowLimit) && (unlikely(ip[-1]==match[-1]))) { ip--; match--; }
	787
	788	{
	789	/* Encode Literal length */
	790	unsigned litLength = (unsigned)(ip - anchor);
	791	token = op++;
	792	if (op + ((litLength+240)/255) + litLength > oMaxLit)
	793	{
	794	/* Not enough space for a last match */
	795	op--;
	796	goto _last_literals;
	797	}
	798	if (litLength>=RUN_MASK)
	799	{
	800	unsigned len = litLength - RUN_MASK;
	801	*token=(RUN_MASK<<ML_BITS);
	802	for(; len >= 255 ; len-=255) *op++ = 255;
	803	*op++ = (BYTE)len;
	804	}
	805	else *token = (BYTE)(litLength<<ML_BITS);
	806
	807	/* Copy Literals */
	808	LZ4_wildCopy(op, anchor, op+litLength);
	809	op += litLength;
	810	}
	811
	812	_next_match:
	813	/* Encode Offset */
	814	LZ4_writeLE16(op, (U16)(ip-match)); op+=2;
	815
	816	/* Encode MatchLength */
	817	{
	818	size_t matchLength;
	819
	820	matchLength = LZ4_count(ip+MINMATCH, match+MINMATCH, matchlimit);
	821
	822	if (op + ((matchLength+240)/255) > oMaxMatch)
	823	{
	824	/* Match description too long : reduce it */
	825	matchLength = (15-1) + (oMaxMatch-op) * 255;
	826	}
	827	//printf("offset %5i, matchLength%5i \n", (int)(ip-match), matchLength + MINMATCH);
	828	ip += MINMATCH + matchLength;
	829
	830	if (matchLength>=ML_MASK)
	831	{
	832	*token += ML_MASK;
	833	matchLength -= ML_MASK;
	834	while (matchLength >= 255) { matchLength-=255; *op++ = 255; }
	835	*op++ = (BYTE)matchLength;
	836	}
	837	else *token += (BYTE)(matchLength);
	838	}
	839
	840	anchor = ip;
	841
	842	/* Test end of block */
	843	if (ip > mflimit) break;
	844	if (op > oMaxSeq) break;
	845
	846	/* Fill table */
	847	LZ4_putPosition(ip-2, ctx, tableType, base);
	848
	849	/* Test next position */
	850	match = LZ4_getPosition(ip, ctx, tableType, base);
	851	LZ4_putPosition(ip, ctx, tableType, base);
	852	if ( (match+MAX_DISTANCE>=ip)
	853	&& (LZ4_read32(match)==LZ4_read32(ip)) )
	854	{ token=op++; *token=0; goto _next_match; }
	855
	856	/* Prepare next loop */
	857	forwardH = LZ4_hashPosition(++ip, tableType);
	858	}
	859
	860	_last_literals:
	861	/* Encode Last Literals */
	862	{
	863	size_t lastRunSize = (size_t)(iend - anchor);
	864	if (op + 1 /* token / + ((lastRunSize+240)/255) / litLength / + lastRunSize / literals */ > oend)
	865	{
	866	/* adapt lastRunSize to fill 'dst' */
	867	lastRunSize = (oend-op) - 1;
	868	lastRunSize -= (lastRunSize+240)/255;
	869	}
	870	ip = anchor + lastRunSize;
	871
	872	if (lastRunSize >= RUN_MASK)
	873	{
	874	size_t accumulator = lastRunSize - RUN_MASK;
	875	*op++ = RUN_MASK << ML_BITS;
	876	for(; accumulator >= 255 ; accumulator-=255) *op++ = 255;
	877	*op++ = (BYTE) accumulator;
	878	}
	879	else
	880	{
	881	*op++ = (BYTE)(lastRunSize<<ML_BITS);
	882	}
	883	memcpy(op, anchor, lastRunSize);
	884	op += lastRunSize;
	885	}
	886
	887	/* End */
	888	srcSizePtr = (int) (((const char)ip)-src);
	889	return (int) (((char*)op)-dst);
	890	}
	891
	892
	893	static int LZ4_compress_destSize_extState (void* state, const char* src, char* dst, int* srcSizePtr, int targetDstSize)
	894	{
	895	LZ4_resetStream((LZ4_stream_t*)state);
	896
	897	if (targetDstSize >= LZ4_compressBound(srcSizePtr)) / compression success is guaranteed */
	898	{
	899	return LZ4_compress_fast_extState(state, src, dst, *srcSizePtr, targetDstSize, 1);
	900	}
	901	else
	902	{
	903	if (*srcSizePtr < LZ4_64Klimit)
	904	return LZ4_compress_destSize_generic(state, src, dst, srcSizePtr, targetDstSize, byU16);
	905	else
	906	return LZ4_compress_destSize_generic(state, src, dst, srcSizePtr, targetDstSize, LZ4_64bits() ? byU32 : byPtr);
	907	}
	908	}
	909
	910
	911	int LZ4_compress_destSize(const char* src, char* dst, int* srcSizePtr, int targetDstSize)
	912	{
	913	#if (HEAPMODE)
	914	void* ctx = ALLOCATOR(1, sizeof(LZ4_stream_t)); /* malloc-calloc always properly aligned */
	915	#else
	916	LZ4_stream_t ctxBody;
	917	void* ctx = &ctxBody;
	918	#endif
	919
	920	int result = LZ4_compress_destSize_extState(ctx, src, dst, srcSizePtr, targetDstSize);
561	921
562	922	#if (HEAPMODE)
563	923	FREEMEM(ctx);

565	925	return result;
566	926	}
567	927
568		int LZ4_compress_limitedOutput(const char* source, char* dest, int inputSize, int maxOutputSize)
569		{
570		#if (HEAPMODE)
571		void* ctx = ALLOCATOR(HASHNBCELLS4, 4); // Aligned on 4-bytes boundaries
572		#else
573		U32 ctx[1U<<(MEMORY_USAGE-2)] = {0}; // Ensure data is aligned on 4-bytes boundaries
574		#endif
	928
	929
	930	/********************************
	931	* Streaming functions
	932	********************************/
	933
	934	LZ4_stream_t* LZ4_createStream(void)
	935	{
	936	LZ4_stream_t* lz4s = (LZ4_stream_t*)ALLOCATOR(8, LZ4_STREAMSIZE_U64);
	937	LZ4_STATIC_ASSERT(LZ4_STREAMSIZE >= sizeof(LZ4_stream_t_internal)); /* A compilation error here means LZ4_STREAMSIZE is not large enough */
	938	LZ4_resetStream(lz4s);
	939	return lz4s;
	940	}
	941
	942	void LZ4_resetStream (LZ4_stream_t* LZ4_stream)
	943	{
	944	MEM_INIT(LZ4_stream, 0, sizeof(LZ4_stream_t));
	945	}
	946
	947	int LZ4_freeStream (LZ4_stream_t* LZ4_stream)
	948	{
	949	FREEMEM(LZ4_stream);
	950	return (0);
	951	}
	952
	953
	954	#define HASH_UNIT sizeof(size_t)
	955	int LZ4_loadDict (LZ4_stream_t* LZ4_dict, const char* dictionary, int dictSize)
	956	{
	957	LZ4_stream_t_internal* dict = (LZ4_stream_t_internal*) LZ4_dict;
	958	const BYTE* p = (const BYTE*)dictionary;
	959	const BYTE* const dictEnd = p + dictSize;
	960	const BYTE* base;
	961
	962	if ((dict->initCheck) \|\| (dict->currentOffset > 1 GB)) /* Uninitialized structure, or reuse overflow */
	963	LZ4_resetStream(LZ4_dict);
	964
	965	if (dictSize < (int)HASH_UNIT)
	966	{
	967	dict->dictionary = NULL;
	968	dict->dictSize = 0;
	969	return 0;
	970	}
	971
	972	if ((dictEnd - p) > 64 KB) p = dictEnd - 64 KB;
	973	dict->currentOffset += 64 KB;
	974	base = p - dict->currentOffset;
	975	dict->dictionary = p;
	976	dict->dictSize = (U32)(dictEnd - p);
	977	dict->currentOffset += dict->dictSize;
	978
	979	while (p <= dictEnd-HASH_UNIT)
	980	{
	981	LZ4_putPosition(p, dict->hashTable, byU32, base);
	982	p+=3;
	983	}
	984
	985	return dict->dictSize;
	986	}
	987
	988
	989	static void LZ4_renormDictT(LZ4_stream_t_internal* LZ4_dict, const BYTE* src)
	990	{
	991	if ((LZ4_dict->currentOffset > 0x80000000) \|\|
	992	((size_t)LZ4_dict->currentOffset > (size_t)src)) /* address space overflow */
	993	{
	994	/* rescale hash table */
	995	U32 delta = LZ4_dict->currentOffset - 64 KB;
	996	const BYTE* dictEnd = LZ4_dict->dictionary + LZ4_dict->dictSize;
	997	int i;
	998	for (i=0; i<HASH_SIZE_U32; i++)
	999	{
	1000	if (LZ4_dict->hashTable[i] < delta) LZ4_dict->hashTable[i]=0;
	1001	else LZ4_dict->hashTable[i] -= delta;
	1002	}
	1003	LZ4_dict->currentOffset = 64 KB;
	1004	if (LZ4_dict->dictSize > 64 KB) LZ4_dict->dictSize = 64 KB;
	1005	LZ4_dict->dictionary = dictEnd - LZ4_dict->dictSize;
	1006	}
	1007	}
	1008
	1009
	1010	int LZ4_compress_fast_continue (LZ4_stream_t* LZ4_stream, const char* source, char* dest, int inputSize, int maxOutputSize, int acceleration)
	1011	{
	1012	LZ4_stream_t_internal* streamPtr = (LZ4_stream_t_internal*)LZ4_stream;
	1013	const BYTE* const dictEnd = streamPtr->dictionary + streamPtr->dictSize;
	1014
	1015	const BYTE* smallest = (const BYTE*) source;
	1016	if (streamPtr->initCheck) return 0; /* Uninitialized structure detected */
	1017	if ((streamPtr->dictSize>0) && (smallest>dictEnd)) smallest = dictEnd;
	1018	LZ4_renormDictT(streamPtr, smallest);
	1019	if (acceleration < 1) acceleration = ACCELERATION_DEFAULT;
	1020
	1021	/* Check overlapping input/dictionary space */
	1022	{
	1023	const BYTE* sourceEnd = (const BYTE*) source + inputSize;
	1024	if ((sourceEnd > streamPtr->dictionary) && (sourceEnd < dictEnd))
	1025	{
	1026	streamPtr->dictSize = (U32)(dictEnd - sourceEnd);
	1027	if (streamPtr->dictSize > 64 KB) streamPtr->dictSize = 64 KB;
	1028	if (streamPtr->dictSize < 4) streamPtr->dictSize = 0;
	1029	streamPtr->dictionary = dictEnd - streamPtr->dictSize;
	1030	}
	1031	}
	1032
	1033	/* prefix mode : source data follows dictionary */
	1034	if (dictEnd == (const BYTE*)source)
	1035	{
	1036	int result;
	1037	if ((streamPtr->dictSize < 64 KB) && (streamPtr->dictSize < streamPtr->currentOffset))
	1038	result = LZ4_compress_generic(LZ4_stream, source, dest, inputSize, maxOutputSize, limitedOutput, byU32, withPrefix64k, dictSmall, acceleration);
	1039	else
	1040	result = LZ4_compress_generic(LZ4_stream, source, dest, inputSize, maxOutputSize, limitedOutput, byU32, withPrefix64k, noDictIssue, acceleration);
	1041	streamPtr->dictSize += (U32)inputSize;
	1042	streamPtr->currentOffset += (U32)inputSize;
	1043	return result;
	1044	}
	1045
	1046	/* external dictionary mode */
	1047	{
	1048	int result;
	1049	if ((streamPtr->dictSize < 64 KB) && (streamPtr->dictSize < streamPtr->currentOffset))
	1050	result = LZ4_compress_generic(LZ4_stream, source, dest, inputSize, maxOutputSize, limitedOutput, byU32, usingExtDict, dictSmall, acceleration);
	1051	else
	1052	result = LZ4_compress_generic(LZ4_stream, source, dest, inputSize, maxOutputSize, limitedOutput, byU32, usingExtDict, noDictIssue, acceleration);
	1053	streamPtr->dictionary = (const BYTE*)source;
	1054	streamPtr->dictSize = (U32)inputSize;
	1055	streamPtr->currentOffset += (U32)inputSize;
	1056	return result;
	1057	}
	1058	}
	1059
	1060
	1061	/* Hidden debug function, to force external dictionary mode */
	1062	int LZ4_compress_forceExtDict (LZ4_stream_t* LZ4_dict, const char* source, char* dest, int inputSize)
	1063	{
	1064	LZ4_stream_t_internal* streamPtr = (LZ4_stream_t_internal*)LZ4_dict;
575	1065	int result;
576
577		if (inputSize < (int)LZ4_64KLIMIT)
578		result = LZ4_compress_generic((void*)ctx, source, dest, inputSize, maxOutputSize, limited, byU16, noPrefix);
579		else
580		result = LZ4_compress_generic((void)ctx, source, dest, inputSize, maxOutputSize, limited, (sizeof(void)==8) ? byU32 : byPtr, noPrefix);
581
582		#if (HEAPMODE)
583		FREEMEM(ctx);
584		#endif
	1066	const BYTE* const dictEnd = streamPtr->dictionary + streamPtr->dictSize;
	1067
	1068	const BYTE* smallest = dictEnd;
	1069	if (smallest > (const BYTE) source) smallest = (const BYTE) source;
	1070	LZ4_renormDictT((LZ4_stream_t_internal*)LZ4_dict, smallest);
	1071
	1072	result = LZ4_compress_generic(LZ4_dict, source, dest, inputSize, 0, notLimited, byU32, usingExtDict, noDictIssue, 1);
	1073
	1074	streamPtr->dictionary = (const BYTE*)source;
	1075	streamPtr->dictSize = (U32)inputSize;
	1076	streamPtr->currentOffset += (U32)inputSize;
	1077
585	1078	return result;
586	1079	}
587	1080
588	1081
589		//*****************************
590		// Using an external allocation
591		//*****************************
592
593		int LZ4_sizeofState() { return 1 << MEMORY_USAGE; }
594
595
596		int LZ4_compress_withState (void* state, const char* source, char* dest, int inputSize)
597		{
598		if (((size_t)(state)&3) != 0) return 0; // Error : state is not aligned on 4-bytes boundary
599		MEM_INIT(state, 0, LZ4_sizeofState());
600
601		if (inputSize < (int)LZ4_64KLIMIT)
602		return LZ4_compress_generic(state, source, dest, inputSize, 0, notLimited, byU16, noPrefix);
603		else
604		return LZ4_compress_generic(state, source, dest, inputSize, 0, notLimited, (sizeof(void*)==8) ? byU32 : byPtr, noPrefix);
605		}
606
607
608		int LZ4_compress_limitedOutput_withState (void* state, const char* source, char* dest, int inputSize, int maxOutputSize)
609		{
610		if (((size_t)(state)&3) != 0) return 0; // Error : state is not aligned on 4-bytes boundary
611		MEM_INIT(state, 0, LZ4_sizeofState());
612
613		if (inputSize < (int)LZ4_64KLIMIT)
614		return LZ4_compress_generic(state, source, dest, inputSize, maxOutputSize, limited, byU16, noPrefix);
615		else
616		return LZ4_compress_generic(state, source, dest, inputSize, maxOutputSize, limited, (sizeof(void*)==8) ? byU32 : byPtr, noPrefix);
617		}
618
619
620		//****************************
621		// Stream functions
622		//****************************
623
624		int LZ4_sizeofStreamState()
625		{
626		return sizeof(LZ4_Data_Structure);
627		}
628
629		FORCE_INLINE void LZ4_init(LZ4_Data_Structure* lz4ds, const BYTE* base)
630		{
631		MEM_INIT(lz4ds->hashTable, 0, sizeof(lz4ds->hashTable));
632		lz4ds->bufferStart = base;
633		lz4ds->base = base;
634		lz4ds->nextBlock = base;
635		}
636
637		int LZ4_resetStreamState(void* state, const char* inputBuffer)
638		{
639		if ((((size_t)state) & 3) != 0) return 1; // Error : pointer is not aligned on 4-bytes boundary
640		LZ4_init((LZ4_Data_Structure)state, (const BYTE)inputBuffer);
641		return 0;
642		}
643
644		void* LZ4_create (const char* inputBuffer)
645		{
646		void* lz4ds = ALLOCATOR(1, sizeof(LZ4_Data_Structure));
647		LZ4_init ((LZ4_Data_Structure)lz4ds, (const BYTE)inputBuffer);
648		return lz4ds;
649		}
650
651
652		int LZ4_free (void* LZ4_Data)
653		{
654		FREEMEM(LZ4_Data);
655		return (0);
656		}
657
658
659		char* LZ4_slideInputBuffer (void* LZ4_Data)
660		{
661		LZ4_Data_Structure* lz4ds = (LZ4_Data_Structure*)LZ4_Data;
662		size_t delta = lz4ds->nextBlock - (lz4ds->bufferStart + 64 KB);
663
664		if ( (lz4ds->base - delta > lz4ds->base) // underflow control
665		\|\| ((size_t)(lz4ds->nextBlock - lz4ds->base) > 0xE0000000) ) // close to 32-bits limit
666		{
667		size_t deltaLimit = (lz4ds->nextBlock - 64 KB) - lz4ds->base;
668		int nH;
669
670		for (nH=0; nH < HASHNBCELLS4; nH++)
671		{
672		if ((size_t)(lz4ds->hashTable[nH]) < deltaLimit) lz4ds->hashTable[nH] = 0;
673		else lz4ds->hashTable[nH] -= (U32)deltaLimit;
674		}
675		memcpy((void)(lz4ds->bufferStart), (const void)(lz4ds->nextBlock - 64 KB), 64 KB);
676		lz4ds->base = lz4ds->bufferStart;
677		lz4ds->nextBlock = lz4ds->base + 64 KB;
678		}
679		else
680		{
681		memcpy((void)(lz4ds->bufferStart), (const void)(lz4ds->nextBlock - 64 KB), 64 KB);
682		lz4ds->nextBlock -= delta;
683		lz4ds->base -= delta;
684		}
685
686		return (char*)(lz4ds->nextBlock);
687		}
688
689
690		int LZ4_compress_continue (void* LZ4_Data, const char* source, char* dest, int inputSize)
691		{
692		return LZ4_compress_generic(LZ4_Data, source, dest, inputSize, 0, notLimited, byU32, withPrefix);
693		}
694
695
696		int LZ4_compress_limitedOutput_continue (void* LZ4_Data, const char* source, char* dest, int inputSize, int maxOutputSize)
697		{
698		return LZ4_compress_generic(LZ4_Data, source, dest, inputSize, maxOutputSize, limited, byU32, withPrefix);
699		}
700
701
702		//****************************
703		// Decompression functions
704		//****************************
705
706		// This generic decompression function cover all use cases.
707		// It shall be instanciated several times, using different sets of directives
708		// Note that it is essential this generic function is really inlined,
709		// in order to remove useless branches during compilation optimisation.
	1082	int LZ4_saveDict (LZ4_stream_t* LZ4_dict, char* safeBuffer, int dictSize)
	1083	{
	1084	LZ4_stream_t_internal* dict = (LZ4_stream_t_internal*) LZ4_dict;
	1085	const BYTE* previousDictEnd = dict->dictionary + dict->dictSize;
	1086
	1087	if ((U32)dictSize > 64 KB) dictSize = 64 KB; /* useless to define a dictionary > 64 KB */
	1088	if ((U32)dictSize > dict->dictSize) dictSize = dict->dictSize;
	1089
	1090	memmove(safeBuffer, previousDictEnd - dictSize, dictSize);
	1091
	1092	dict->dictionary = (const BYTE*)safeBuffer;
	1093	dict->dictSize = (U32)dictSize;
	1094
	1095	return dictSize;
	1096	}
	1097
	1098
	1099
	1100	/*******************************
	1101	* Decompression functions
	1102	*******************************/
	1103	/*
	1104	* This generic decompression function cover all use cases.
	1105	* It shall be instantiated several times, using different sets of directives
	1106	* Note that it is essential this generic function is really inlined,
	1107	* in order to remove useless branches during compilation optimization.
	1108	*/
710	1109	FORCE_INLINE int LZ4_decompress_generic(
711		const char* source,
712		char* dest,
713		int inputSize, //
714		int outputSize, // If endOnInput==endOnInputSize, this value is the max size of Output Buffer.
715
716		int endOnInput, // endOnOutputSize, endOnInputSize
717		int prefix64k, // noPrefix, withPrefix
718		int partialDecoding, // full, partial
719		int targetOutputSize // only used if partialDecoding==partial
	1110	const char* const source,
	1111	char* const dest,
	1112	int inputSize,
	1113	int outputSize, /* If endOnInput==endOnInputSize, this value is the max size of Output Buffer. */
	1114
	1115	int endOnInput, /* endOnOutputSize, endOnInputSize */
	1116	int partialDecoding, /* full, partial */
	1117	int targetOutputSize, /* only used if partialDecoding==partial */
	1118	int dict, /* noDict, withPrefix64k, usingExtDict */
	1119	const BYTE* const lowPrefix, /* == dest if dict == noDict */
	1120	const BYTE* const dictStart, /* only if dict==usingExtDict */
	1121	const size_t dictSize /* note : = 0 if noDict */
720	1122	)
721	1123	{
722		// Local Variables
723		const BYTE* restrict ip = (const BYTE*) source;
724		const BYTE* ref;
	1124	/* Local Variables */
	1125	const BYTE* ip = (const BYTE*) source;
725	1126	const BYTE* const iend = ip + inputSize;
726	1127
727	1128	BYTE* op = (BYTE*) dest;
728	1129	BYTE* const oend = op + outputSize;
729	1130	BYTE* cpy;
730	1131	BYTE* oexit = op + targetOutputSize;
731
732		const size_t dec32table[] = {0, 3, 2, 3, 0, 0, 0, 0}; // static reduces speed for LZ4_decompress_safe() on GCC64
733		static const size_t dec64table[] = {0, 0, 0, (size_t)-1, 0, 1, 2, 3};
734
735
736		// Special cases
737		if ((partialDecoding) && (oexit> oend-MFLIMIT)) oexit = oend-MFLIMIT; // targetOutputSize too high => decode everything
738		if ((endOnInput) && unlikely(outputSize==0)) return ((inputSize==1) && (*ip==0)) ? 0 : -1; // Empty output buffer
739		if ((!endOnInput) && unlikely(outputSize==0)) return (*ip==0?1:-1);
740
741
742		// Main Loop
	1132	const BYTE* const lowLimit = lowPrefix - dictSize;
	1133
	1134	const BYTE* const dictEnd = (const BYTE*)dictStart + dictSize;
	1135	const size_t dec32table[] = {4, 1, 2, 1, 4, 4, 4, 4};
	1136	const size_t dec64table[] = {0, 0, 0, (size_t)-1, 0, 1, 2, 3};
	1137
	1138	const int safeDecode = (endOnInput==endOnInputSize);
	1139	const int checkOffset = ((safeDecode) && (dictSize < (int)(64 KB)));
	1140
	1141
	1142	/* Special cases */
	1143	if ((partialDecoding) && (oexit> oend-MFLIMIT)) oexit = oend-MFLIMIT; /* targetOutputSize too high => decode everything */
	1144	if ((endOnInput) && (unlikely(outputSize==0))) return ((inputSize==1) && (ip==0)) ? 0 : -1; / Empty output buffer */
	1145	if ((!endOnInput) && (unlikely(outputSize==0))) return (*ip==0?1:-1);
	1146
	1147
	1148	/* Main Loop */
743	1149	while (1)
744	1150	{
745	1151	unsigned token;
746	1152	size_t length;
747
748		// get runlength
	1153	const BYTE* match;
	1154
	1155	/* get literal length */
749	1156	token = *ip++;
750	1157	if ((length=(token>>ML_BITS)) == RUN_MASK)
751	1158	{
752		unsigned s=255;
753		while (((endOnInput)?ip<iend:1) && (s==255))
	1159	unsigned s;
	1160	do
754	1161	{
755	1162	s = *ip++;
756	1163	length += s;
757	1164	}
758		}
759
760		// copy literals
	1165	while (likely((endOnInput)?ip<iend-RUN_MASK:1) && (s==255));
	1166	if ((safeDecode) && unlikely((size_t)(op+length)<(size_t)(op))) goto _output_error; /* overflow detection */
	1167	if ((safeDecode) && unlikely((size_t)(ip+length)<(size_t)(ip))) goto _output_error; /* overflow detection */
	1168	}
	1169
	1170	/* copy literals */
761	1171	cpy = op+length;
762	1172	if (((endOnInput) && ((cpy>(partialDecoding?oexit:oend-MFLIMIT)) \|\| (ip+length>iend-(2+1+LASTLITERALS))) )
763	1173	\|\| ((!endOnInput) && (cpy>oend-COPYLENGTH)))
764	1174	{
765	1175	if (partialDecoding)
766	1176	{
767		if (cpy > oend) goto _output_error; // Error : write attempt beyond end of output buffer
768		if ((endOnInput) && (ip+length > iend)) goto _output_error; // Error : read attempt beyond end of input buffer
	1177	if (cpy > oend) goto _output_error; /* Error : write attempt beyond end of output buffer */
	1178	if ((endOnInput) && (ip+length > iend)) goto _output_error; /* Error : read attempt beyond end of input buffer */
769	1179	}
770	1180	else
771	1181	{
772		if ((!endOnInput) && (cpy != oend)) goto _output_error; // Error : block decoding must stop exactly there
773		if ((endOnInput) && ((ip+length != iend) \|\| (cpy > oend))) goto _output_error; // Error : input must be consumed
	1182	if ((!endOnInput) && (cpy != oend)) goto _output_error; /* Error : block decoding must stop exactly there */
	1183	if ((endOnInput) && ((ip+length != iend) \|\| (cpy > oend))) goto _output_error; /* Error : input must be consumed */
774	1184	}
775	1185	memcpy(op, ip, length);
776	1186	ip += length;
777	1187	op += length;
778		break; // Necessarily EOF, due to parsing restrictions
779		}
780		LZ4_WILDCOPY(op, ip, cpy); ip -= (op-cpy); op = cpy;
781
782		// get offset
783		LZ4_READ_LITTLEENDIAN_16(ref,cpy,ip); ip+=2;
784		if ((prefix64k==noPrefix) && unlikely(ref < (BYTE* const)dest)) goto _output_error; // Error : offset outside destination buffer
785
786		// get matchlength
787		if ((length=(token&ML_MASK)) == ML_MASK)
788		{
789		while ((!endOnInput) \|\| (ip<iend-(LASTLITERALS+1))) // Ensure enough bytes remain for LASTLITERALS + token
790		{
791		unsigned s = *ip++;
	1188	break; /* Necessarily EOF, due to parsing restrictions */
	1189	}
	1190	LZ4_wildCopy(op, ip, cpy);
	1191	ip += length; op = cpy;
	1192
	1193	/* get offset */
	1194	match = cpy - LZ4_readLE16(ip); ip+=2;
	1195	if ((checkOffset) && (unlikely(match < lowLimit))) goto _output_error; /* Error : offset outside destination buffer */
	1196
	1197	/* get matchlength */
	1198	length = token & ML_MASK;
	1199	if (length == ML_MASK)
	1200	{
	1201	unsigned s;
	1202	do
	1203	{
	1204	if ((endOnInput) && (ip > iend-LASTLITERALS)) goto _output_error;
	1205	s = *ip++;
792	1206	length += s;
793		if (s==255) continue;
794		break;
	1207	} while (s==255);
	1208	if ((safeDecode) && unlikely((size_t)(op+length)<(size_t)op)) goto _output_error; /* overflow detection */
	1209	}
	1210	length += MINMATCH;
	1211
	1212	/* check external dictionary */
	1213	if ((dict==usingExtDict) && (match < lowPrefix))
	1214	{
	1215	if (unlikely(op+length > oend-LASTLITERALS)) goto _output_error; /* doesn't respect parsing restriction */
	1216
	1217	if (length <= (size_t)(lowPrefix-match))
	1218	{
	1219	/* match can be copied as a single segment from external dictionary */
	1220	match = dictEnd - (lowPrefix-match);
	1221	memmove(op, match, length); op += length;
795	1222	}
796		}
797
798		// copy repeated sequence
799		if unlikely((op-ref)<(int)STEPSIZE)
800		{
801		const size_t dec64 = dec64table[(sizeof(void*)==4) ? 0 : op-ref];
802		op[0] = ref[0];
803		op[1] = ref[1];
804		op[2] = ref[2];
805		op[3] = ref[3];
806		op += 4, ref += 4; ref -= dec32table[op-ref];
807		A32(op) = A32(ref);
808		op += STEPSIZE-4; ref -= dec64;
809		} else { LZ4_COPYSTEP(op,ref); }
810		cpy = op + length - (STEPSIZE-4);
811
812		if unlikely(cpy>oend-COPYLENGTH-(STEPSIZE-4))
813		{
814		if (cpy > oend-LASTLITERALS) goto _output_error; // Error : last 5 bytes must be literals
815		LZ4_SECURECOPY(op, ref, (oend-COPYLENGTH));
816		while(op<cpy) op++=ref++;
817		op=cpy;
	1223	else
	1224	{
	1225	/* match encompass external dictionary and current segment */
	1226	size_t copySize = (size_t)(lowPrefix-match);
	1227	memcpy(op, dictEnd - copySize, copySize);
	1228	op += copySize;
	1229	copySize = length - copySize;
	1230	if (copySize > (size_t)(op-lowPrefix)) /* overlap within current segment */
	1231	{
	1232	BYTE* const endOfMatch = op + copySize;
	1233	const BYTE* copyFrom = lowPrefix;
	1234	while (op < endOfMatch) op++ = copyFrom++;
	1235	}
	1236	else
	1237	{
	1238	memcpy(op, lowPrefix, copySize);
	1239	op += copySize;
	1240	}
	1241	}
818	1242	continue;
819	1243	}
820		LZ4_WILDCOPY(op, ref, cpy);
821		op=cpy; // correction
822		}
823
824		// end of decoding
	1244
	1245	/* copy repeated sequence */
	1246	cpy = op + length;
	1247	if (unlikely((op-match)<8))
	1248	{
	1249	const size_t dec64 = dec64table[op-match];
	1250	op[0] = match[0];
	1251	op[1] = match[1];
	1252	op[2] = match[2];
	1253	op[3] = match[3];
	1254	match += dec32table[op-match];
	1255	LZ4_copy4(op+4, match);
	1256	op += 8; match -= dec64;
	1257	} else { LZ4_copy8(op, match); op+=8; match+=8; }
	1258
	1259	if (unlikely(cpy>oend-12))
	1260	{
	1261	if (cpy > oend-LASTLITERALS) goto _output_error; /* Error : last LASTLITERALS bytes must be literals */
	1262	if (op < oend-8)
	1263	{
	1264	LZ4_wildCopy(op, match, oend-8);
	1265	match += (oend-8) - op;
	1266	op = oend-8;
	1267	}
	1268	while (op<cpy) op++ = match++;
	1269	}
	1270	else
	1271	LZ4_wildCopy(op, match, cpy);
	1272	op=cpy; /* correction */
	1273	}
	1274
	1275	/* end of decoding */
825	1276	if (endOnInput)
826		return (int) (((char*)op)-dest); // Nb of output bytes decoded
	1277	return (int) (((char)op)-dest); / Nb of output bytes decoded */
827	1278	else
828		return (int) (((char*)ip)-source); // Nb of input bytes read
829
830		// Overflow error detected
	1279	return (int) (((const char)ip)-source); / Nb of input bytes read */
	1280
	1281	/* Overflow error detected */
831	1282	_output_error:
832		return (int) (-(((char*)ip)-source))-1;
833		}
834
835
836		int LZ4_decompress_safe(const char* source, char* dest, int inputSize, int maxOutputSize)
837		{
838		return LZ4_decompress_generic(source, dest, inputSize, maxOutputSize, endOnInputSize, noPrefix, full, 0);
839		}
840
841		int LZ4_decompress_safe_withPrefix64k(const char* source, char* dest, int inputSize, int maxOutputSize)
842		{
843		return LZ4_decompress_generic(source, dest, inputSize, maxOutputSize, endOnInputSize, withPrefix, full, 0);
844		}
845
846		int LZ4_decompress_safe_partial(const char* source, char* dest, int inputSize, int targetOutputSize, int maxOutputSize)
847		{
848		return LZ4_decompress_generic(source, dest, inputSize, maxOutputSize, endOnInputSize, noPrefix, partial, targetOutputSize);
849		}
850
851		int LZ4_decompress_fast_withPrefix64k(const char* source, char* dest, int outputSize)
852		{
853		return LZ4_decompress_generic(source, dest, 0, outputSize, endOnOutputSize, withPrefix, full, 0);
854		}
855
856		int LZ4_decompress_fast(const char* source, char* dest, int outputSize)
857		{
858		#ifdef _MSC_VER // This version is faster with Visual
859		return LZ4_decompress_generic(source, dest, 0, outputSize, endOnOutputSize, noPrefix, full, 0);
860		#else
861		return LZ4_decompress_generic(source, dest, 0, outputSize, endOnOutputSize, withPrefix, full, 0);
862		#endif
863		}
864
	1283	return (int) (-(((const char*)ip)-source))-1;
	1284	}
	1285
	1286
	1287	int LZ4_decompress_safe(const char* source, char* dest, int compressedSize, int maxDecompressedSize)
	1288	{
	1289	return LZ4_decompress_generic(source, dest, compressedSize, maxDecompressedSize, endOnInputSize, full, 0, noDict, (BYTE*)dest, NULL, 0);
	1290	}
	1291
	1292	int LZ4_decompress_safe_partial(const char* source, char* dest, int compressedSize, int targetOutputSize, int maxDecompressedSize)
	1293	{
	1294	return LZ4_decompress_generic(source, dest, compressedSize, maxDecompressedSize, endOnInputSize, partial, targetOutputSize, noDict, (BYTE*)dest, NULL, 0);
	1295	}
	1296
	1297	int LZ4_decompress_fast(const char* source, char* dest, int originalSize)
	1298	{
	1299	return LZ4_decompress_generic(source, dest, 0, originalSize, endOnOutputSize, full, 0, withPrefix64k, (BYTE*)(dest - 64 KB), NULL, 64 KB);
	1300	}
	1301
	1302
	1303	/* streaming decompression functions */
	1304
	1305	typedef struct
	1306	{
	1307	const BYTE* externalDict;
	1308	size_t extDictSize;
	1309	const BYTE* prefixEnd;
	1310	size_t prefixSize;
	1311	} LZ4_streamDecode_t_internal;
	1312
	1313	/*
	1314	* If you prefer dynamic allocation methods,
	1315	* LZ4_createStreamDecode()
	1316	* provides a pointer (void*) towards an initialized LZ4_streamDecode_t structure.
	1317	*/
	1318	LZ4_streamDecode_t* LZ4_createStreamDecode(void)
	1319	{
	1320	LZ4_streamDecode_t* lz4s = (LZ4_streamDecode_t*) ALLOCATOR(1, sizeof(LZ4_streamDecode_t));
	1321	return lz4s;
	1322	}
	1323
	1324	int LZ4_freeStreamDecode (LZ4_streamDecode_t* LZ4_stream)
	1325	{
	1326	FREEMEM(LZ4_stream);
	1327	return 0;
	1328	}
	1329
	1330	/*
	1331	* LZ4_setStreamDecode
	1332	* Use this function to instruct where to find the dictionary
	1333	* This function is not necessary if previous data is still available where it was decoded.
	1334	* Loading a size of 0 is allowed (same effect as no dictionary).
	1335	* Return : 1 if OK, 0 if error
	1336	*/
	1337	int LZ4_setStreamDecode (LZ4_streamDecode_t* LZ4_streamDecode, const char* dictionary, int dictSize)
	1338	{
	1339	LZ4_streamDecode_t_internal* lz4sd = (LZ4_streamDecode_t_internal*) LZ4_streamDecode;
	1340	lz4sd->prefixSize = (size_t) dictSize;
	1341	lz4sd->prefixEnd = (const BYTE*) dictionary + dictSize;
	1342	lz4sd->externalDict = NULL;
	1343	lz4sd->extDictSize = 0;
	1344	return 1;
	1345	}
	1346
	1347	/*
	1348	*_continue() :
	1349	These decoding functions allow decompression of multiple blocks in "streaming" mode.
	1350	Previously decoded blocks must still be available at the memory position where they were decoded.
	1351	If it's not possible, save the relevant part of decoded data into a safe buffer,
	1352	and indicate where it stands using LZ4_setStreamDecode()
	1353	*/
	1354	int LZ4_decompress_safe_continue (LZ4_streamDecode_t* LZ4_streamDecode, const char* source, char* dest, int compressedSize, int maxOutputSize)
	1355	{
	1356	LZ4_streamDecode_t_internal* lz4sd = (LZ4_streamDecode_t_internal*) LZ4_streamDecode;
	1357	int result;
	1358
	1359	if (lz4sd->prefixEnd == (BYTE*)dest)
	1360	{
	1361	result = LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize,
	1362	endOnInputSize, full, 0,
	1363	usingExtDict, lz4sd->prefixEnd - lz4sd->prefixSize, lz4sd->externalDict, lz4sd->extDictSize);
	1364	if (result <= 0) return result;
	1365	lz4sd->prefixSize += result;
	1366	lz4sd->prefixEnd += result;
	1367	}
	1368	else
	1369	{
	1370	lz4sd->extDictSize = lz4sd->prefixSize;
	1371	lz4sd->externalDict = lz4sd->prefixEnd - lz4sd->extDictSize;
	1372	result = LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize,
	1373	endOnInputSize, full, 0,
	1374	usingExtDict, (BYTE*)dest, lz4sd->externalDict, lz4sd->extDictSize);
	1375	if (result <= 0) return result;
	1376	lz4sd->prefixSize = result;
	1377	lz4sd->prefixEnd = (BYTE*)dest + result;
	1378	}
	1379
	1380	return result;
	1381	}
	1382
	1383	int LZ4_decompress_fast_continue (LZ4_streamDecode_t* LZ4_streamDecode, const char* source, char* dest, int originalSize)
	1384	{
	1385	LZ4_streamDecode_t_internal* lz4sd = (LZ4_streamDecode_t_internal*) LZ4_streamDecode;
	1386	int result;
	1387
	1388	if (lz4sd->prefixEnd == (BYTE*)dest)
	1389	{
	1390	result = LZ4_decompress_generic(source, dest, 0, originalSize,
	1391	endOnOutputSize, full, 0,
	1392	usingExtDict, lz4sd->prefixEnd - lz4sd->prefixSize, lz4sd->externalDict, lz4sd->extDictSize);
	1393	if (result <= 0) return result;
	1394	lz4sd->prefixSize += originalSize;
	1395	lz4sd->prefixEnd += originalSize;
	1396	}
	1397	else
	1398	{
	1399	lz4sd->extDictSize = lz4sd->prefixSize;
	1400	lz4sd->externalDict = (BYTE*)dest - lz4sd->extDictSize;
	1401	result = LZ4_decompress_generic(source, dest, 0, originalSize,
	1402	endOnOutputSize, full, 0,
	1403	usingExtDict, (BYTE*)dest, lz4sd->externalDict, lz4sd->extDictSize);
	1404	if (result <= 0) return result;
	1405	lz4sd->prefixSize = originalSize;
	1406	lz4sd->prefixEnd = (BYTE*)dest + originalSize;
	1407	}
	1408
	1409	return result;
	1410	}
	1411
	1412
	1413	/*
	1414	Advanced decoding functions :
	1415	*_usingDict() :
	1416	These decoding functions work the same as "_continue" ones,
	1417	the dictionary must be explicitly provided within parameters
	1418	*/
	1419
	1420	FORCE_INLINE int LZ4_decompress_usingDict_generic(const char* source, char* dest, int compressedSize, int maxOutputSize, int safe, const char* dictStart, int dictSize)
	1421	{
	1422	if (dictSize==0)
	1423	return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize, safe, full, 0, noDict, (BYTE*)dest, NULL, 0);
	1424	if (dictStart+dictSize == dest)
	1425	{
	1426	if (dictSize >= (int)(64 KB - 1))
	1427	return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize, safe, full, 0, withPrefix64k, (BYTE*)dest-64 KB, NULL, 0);
	1428	return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize, safe, full, 0, noDict, (BYTE*)dest-dictSize, NULL, 0);
	1429	}
	1430	return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize, safe, full, 0, usingExtDict, (BYTE)dest, (const BYTE)dictStart, dictSize);
	1431	}
	1432
	1433	int LZ4_decompress_safe_usingDict(const char* source, char* dest, int compressedSize, int maxOutputSize, const char* dictStart, int dictSize)
	1434	{
	1435	return LZ4_decompress_usingDict_generic(source, dest, compressedSize, maxOutputSize, 1, dictStart, dictSize);
	1436	}
	1437
	1438	int LZ4_decompress_fast_usingDict(const char* source, char* dest, int originalSize, const char* dictStart, int dictSize)
	1439	{
	1440	return LZ4_decompress_usingDict_generic(source, dest, 0, originalSize, 0, dictStart, dictSize);
	1441	}
	1442
	1443	/* debug function */
	1444	int LZ4_decompress_safe_forceExtDict(const char* source, char* dest, int compressedSize, int maxOutputSize, const char* dictStart, int dictSize)
	1445	{
	1446	return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize, endOnInputSize, full, 0, usingExtDict, (BYTE)dest, (const BYTE)dictStart, dictSize);
	1447	}
	1448
	1449
	1450	/***************************************************
	1451	* Obsolete Functions
	1452	***************************************************/
	1453	/* obsolete compression functions */
	1454	int LZ4_compress_limitedOutput(const char* source, char* dest, int inputSize, int maxOutputSize) { return LZ4_compress_default(source, dest, inputSize, maxOutputSize); }
	1455	int LZ4_compress(const char* source, char* dest, int inputSize) { return LZ4_compress_default(source, dest, inputSize, LZ4_compressBound(inputSize)); }
	1456	int LZ4_compress_limitedOutput_withState (void* state, const char* src, char* dst, int srcSize, int dstSize) { return LZ4_compress_fast_extState(state, src, dst, srcSize, dstSize, 1); }
	1457	int LZ4_compress_withState (void* state, const char* src, char* dst, int srcSize) { return LZ4_compress_fast_extState(state, src, dst, srcSize, LZ4_compressBound(srcSize), 1); }
	1458	int LZ4_compress_limitedOutput_continue (LZ4_stream_t* LZ4_stream, const char* src, char* dst, int srcSize, int maxDstSize) { return LZ4_compress_fast_continue(LZ4_stream, src, dst, srcSize, maxDstSize, 1); }
	1459	int LZ4_compress_continue (LZ4_stream_t* LZ4_stream, const char* source, char* dest, int inputSize) { return LZ4_compress_fast_continue(LZ4_stream, source, dest, inputSize, LZ4_compressBound(inputSize), 1); }
	1460
	1461	/*
	1462	These function names are deprecated and should no longer be used.
	1463	They are only provided here for compatibility with older user programs.
	1464	- LZ4_uncompress is totally equivalent to LZ4_decompress_fast
	1465	- LZ4_uncompress_unknownOutputSize is totally equivalent to LZ4_decompress_safe
	1466	*/
	1467	int LZ4_uncompress (const char* source, char* dest, int outputSize) { return LZ4_decompress_fast(source, dest, outputSize); }
	1468	int LZ4_uncompress_unknownOutputSize (const char* source, char* dest, int isize, int maxOutputSize) { return LZ4_decompress_safe(source, dest, isize, maxOutputSize); }
	1469
	1470
	1471	/* Obsolete Streaming functions */
	1472
	1473	int LZ4_sizeofStreamState() { return LZ4_STREAMSIZE; }
	1474
	1475	static void LZ4_init(LZ4_stream_t_internal* lz4ds, BYTE* base)
	1476	{
	1477	MEM_INIT(lz4ds, 0, LZ4_STREAMSIZE);
	1478	lz4ds->bufferStart = base;
	1479	}
	1480
	1481	int LZ4_resetStreamState(void* state, char* inputBuffer)
	1482	{
	1483	if ((((size_t)state) & 3) != 0) return 1; /* Error : pointer is not aligned on 4-bytes boundary */
	1484	LZ4_init((LZ4_stream_t_internal)state, (BYTE)inputBuffer);
	1485	return 0;
	1486	}
	1487
	1488	void* LZ4_create (char* inputBuffer)
	1489	{
	1490	void* lz4ds = ALLOCATOR(8, LZ4_STREAMSIZE_U64);
	1491	LZ4_init ((LZ4_stream_t_internal)lz4ds, (BYTE)inputBuffer);
	1492	return lz4ds;
	1493	}
	1494
	1495	char* LZ4_slideInputBuffer (void* LZ4_Data)
	1496	{
	1497	LZ4_stream_t_internal* ctx = (LZ4_stream_t_internal*)LZ4_Data;
	1498	int dictSize = LZ4_saveDict((LZ4_stream_t)LZ4_Data, (char)ctx->bufferStart, 64 KB);
	1499	return (char*)(ctx->bufferStart + dictSize);
	1500	}
	1501
	1502	/* Obsolete streaming decompression functions */
	1503
	1504	int LZ4_decompress_safe_withPrefix64k(const char* source, char* dest, int compressedSize, int maxOutputSize)
	1505	{
	1506	return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize, endOnInputSize, full, 0, withPrefix64k, (BYTE*)dest - 64 KB, NULL, 64 KB);
	1507	}
	1508
	1509	int LZ4_decompress_fast_withPrefix64k(const char* source, char* dest, int originalSize)
	1510	{
	1511	return LZ4_decompress_generic(source, dest, 0, originalSize, endOnOutputSize, full, 0, withPrefix64k, (BYTE*)dest - 64 KB, NULL, 64 KB);
	1512	}
	1513
	1514	#endif /* LZ4_COMMONDEFS_ONLY */
	1515

+297

-186

src/impex/lz4.h less more

0	0	/*
1	1	LZ4 - Fast LZ compression algorithm
2	2	Header File
3		Copyright (C) 2011-2013, Yann Collet.
	3	Copyright (C) 2011-2015, Yann Collet.
	4
4	5	BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
5	6
6	7	Redistribution and use in source and binary forms, with or without

27	28	OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28	29
29	30	You can contact the author at :
30		- LZ4 homepage : http://fastcompression.blogspot.com/p/lz4.html
31		- LZ4 source repository : http://code.google.com/p/lz4/
	31	- LZ4 source repository : https://github.com/Cyan4973/lz4
	32	- LZ4 public forum : https://groups.google.com/forum/#!forum/lz4c
32	33	*/
33	34	#pragma once
34	35

36	37	extern "C" {
37	38	#endif
38	39
39
40		//**************************************
41		// Compiler Options
42		//**************************************
43		#if defined(_MSC_VER) && !defined(__cplusplus) // Visual Studio
44		# define inline __inline // Visual C is not C99, but supports some kind of inline
45		#endif
46
47
48		//****************************
49		// Simple Functions
50		//****************************
51
52		int LZ4_compress (const char* source, char* dest, int inputSize);
53		int LZ4_decompress_safe (const char* source, char* dest, int inputSize, int maxOutputSize);
54
55		/*
56		LZ4_compress() :
57		Compresses 'inputSize' bytes from 'source' into 'dest'.
58		Destination buffer must be already allocated,
59		and must be sized to handle worst cases situations (input data not compressible)
60		Worst case size evaluation is provided by function LZ4_compressBound()
61		inputSize : Max supported value is LZ4_MAX_INPUT_VALUE
62		return : the number of bytes written in buffer dest
63		or 0 if the compression fails
	40	/*
	41	* lz4.h provides block compression functions, and gives full buffer control to programmer.
	42	* If you need to generate inter-operable compressed data (respecting LZ4 frame specification),
	43	* and can let the library handle its own memory, please use lz4frame.h instead.
	44	*/
	45
	46	/**************************************
	47	* Version
	48	**************************************/
	49	#define LZ4_VERSION_MAJOR 1 /* for breaking interface changes */
	50	#define LZ4_VERSION_MINOR 7 /* for new (non-breaking) interface capabilities */
	51	#define LZ4_VERSION_RELEASE 1 /* for tweaks, bug-fixes, or development */
	52	#define LZ4_VERSION_NUMBER (LZ4_VERSION_MAJOR 100100 + LZ4_VERSION_MINOR *100 + LZ4_VERSION_RELEASE)
	53	int LZ4_versionNumber (void);
	54
	55	/**************************************
	56	* Tuning parameter
	57	**************************************/
	58	/*
	59	* LZ4_MEMORY_USAGE :
	60	* Memory usage formula : N->2^N Bytes (examples : 10 -> 1KB; 12 -> 4KB ; 16 -> 64KB; 20 -> 1MB; etc.)
	61	* Increasing memory usage improves compression ratio
	62	* Reduced memory usage can improve speed, due to cache effect
	63	* Default value is 14, for 16KB, which nicely fits into Intel x86 L1 cache
	64	*/
	65	#define LZ4_MEMORY_USAGE 14
	66
	67
	68	/**************************************
	69	* Simple Functions
	70	**************************************/
	71
	72	int LZ4_compress_default(const char* source, char* dest, int sourceSize, int maxDestSize);
	73	int LZ4_decompress_safe (const char* source, char* dest, int compressedSize, int maxDecompressedSize);
	74
	75	/*
	76	LZ4_compress_default() :
	77	Compresses 'sourceSize' bytes from buffer 'source'
	78	into already allocated 'dest' buffer of size 'maxDestSize'.
	79	Compression is guaranteed to succeed if 'maxDestSize' >= LZ4_compressBound(sourceSize).
	80	It also runs faster, so it's a recommended setting.
	81	If the function cannot compress 'source' into a more limited 'dest' budget,
	82	compression stops immediately, and the function result is zero.
	83	As a consequence, 'dest' content is not valid.
	84	This function never writes outside 'dest' buffer, nor read outside 'source' buffer.
	85	sourceSize : Max supported value is LZ4_MAX_INPUT_VALUE
	86	maxDestSize : full or partial size of buffer 'dest' (which must be already allocated)
	87	return : the number of bytes written into buffer 'dest' (necessarily <= maxOutputSize)
	88	or 0 if compression fails
64	89
65	90	LZ4_decompress_safe() :
66		maxOutputSize : is the size of the destination buffer (which must be already allocated)
67		return : the number of bytes decoded in the destination buffer (necessarily <= maxOutputSize)
	91	compressedSize : is the precise full size of the compressed block.
	92	maxDecompressedSize : is the size of destination buffer, which must be already allocated.
	93	return : the number of bytes decompressed into destination buffer (necessarily <= maxDecompressedSize)
	94	If destination buffer is not large enough, decoding will stop and output an error code (<0).
68	95	If the source stream is detected malformed, the function will stop decoding and return a negative result.
69		This function is protected against buffer overflow exploits (never writes outside of output buffer, and never reads outside of input buffer). Therefore, it is protected against malicious data packets
70		*/
71
72
73		//****************************
74		// Advanced Functions
75		//****************************
76		#define LZ4_MAX_INPUT_SIZE 0x7E000000 // 2 113 929 216 bytes
77		#define LZ4_COMPRESSBOUND(isize) ((unsigned int)(isize) > (unsigned int)LZ4_MAX_INPUT_SIZE ? 0 : (isize) + ((isize)/255) + 16)
78		static inline int LZ4_compressBound(int isize) { return LZ4_COMPRESSBOUND(isize); }
	96	This function is protected against buffer overflow exploits, including malicious data packets.
	97	It never writes outside output buffer, nor reads outside input buffer.
	98	*/
	99
	100
	101	/**************************************
	102	* Advanced Functions
	103	**************************************/
	104	#define LZ4_MAX_INPUT_SIZE 0x7E000000 /* 2 113 929 216 bytes */
	105	#define LZ4_COMPRESSBOUND(isize) ((unsigned)(isize) > (unsigned)LZ4_MAX_INPUT_SIZE ? 0 : (isize) + ((isize)/255) + 16)
79	106
80	107	/*
81	108	LZ4_compressBound() :
82		Provides the maximum size that LZ4 may output in a "worst case" scenario (input data not compressible)
83		primarily useful for memory allocation of output buffer.
84		inline function is recommended for the general case,
85		macro is also provided when result needs to be evaluated at compilation (such as stack memory allocation).
86
87		isize : is the input size. Max supported value is LZ4_MAX_INPUT_SIZE
88		return : maximum output size in a "worst case" scenario
89		or 0, if input size is too large ( > LZ4_MAX_INPUT_SIZE)
90		*/
91
92
93		int LZ4_compress_limitedOutput (const char* source, char* dest, int inputSize, int maxOutputSize);
94
95		/*
96		LZ4_compress_limitedOutput() :
97		Compress 'inputSize' bytes from 'source' into an output buffer 'dest' of maximum size 'maxOutputSize'.
98		If it cannot achieve it, compression will stop, and result of the function will be zero.
99		This function never writes outside of provided output buffer.
100
101		inputSize : Max supported value is LZ4_MAX_INPUT_VALUE
102		maxOutputSize : is the size of the destination buffer (which must be already allocated)
103		return : the number of bytes written in buffer 'dest'
104		or 0 if the compression fails
105		*/
106
107
108		int LZ4_decompress_fast (const char* source, char* dest, int outputSize);
	109	Provides the maximum size that LZ4 compression may output in a "worst case" scenario (input data not compressible)
	110	This function is primarily useful for memory allocation purposes (destination buffer size).
	111	Macro LZ4_COMPRESSBOUND() is also provided for compilation-time evaluation (stack memory allocation for example).
	112	Note that LZ4_compress_default() compress faster when dest buffer size is >= LZ4_compressBound(srcSize)
	113	inputSize : max supported value is LZ4_MAX_INPUT_SIZE
	114	return : maximum output size in a "worst case" scenario
	115	or 0, if input size is too large ( > LZ4_MAX_INPUT_SIZE)
	116	*/
	117	int LZ4_compressBound(int inputSize);
	118
	119	/*
	120	LZ4_compress_fast() :
	121	Same as LZ4_compress_default(), but allows to select an "acceleration" factor.
	122	The larger the acceleration value, the faster the algorithm, but also the lesser the compression.
	123	It's a trade-off. It can be fine tuned, with each successive value providing roughly +~3% to speed.
	124	An acceleration value of "1" is the same as regular LZ4_compress_default()
	125	Values <= 0 will be replaced by ACCELERATION_DEFAULT (see lz4.c), which is 1.
	126	*/
	127	int LZ4_compress_fast (const char* source, char* dest, int sourceSize, int maxDestSize, int acceleration);
	128
	129
	130	/*
	131	LZ4_compress_fast_extState() :
	132	Same compression function, just using an externally allocated memory space to store compression state.
	133	Use LZ4_sizeofState() to know how much memory must be allocated,
	134	and allocate it on 8-bytes boundaries (using malloc() typically).
	135	Then, provide it as 'void* state' to compression function.
	136	*/
	137	int LZ4_sizeofState(void);
	138	int LZ4_compress_fast_extState (void* state, const char* source, char* dest, int inputSize, int maxDestSize, int acceleration);
	139
	140
	141	/*
	142	LZ4_compress_destSize() :
	143	Reverse the logic, by compressing as much data as possible from 'source' buffer
	144	into already allocated buffer 'dest' of size 'targetDestSize'.
	145	This function either compresses the entire 'source' content into 'dest' if it's large enough,
	146	or fill 'dest' buffer completely with as much data as possible from 'source'.
	147	*sourceSizePtr : will be modified to indicate how many bytes where read from 'source' to fill 'dest'.
	148	New value is necessarily <= old value.
	149	return : Nb bytes written into 'dest' (necessarily <= targetDestSize)
	150	or 0 if compression fails
	151	*/
	152	int LZ4_compress_destSize (const char* source, char* dest, int* sourceSizePtr, int targetDestSize);
	153
109	154
110	155	/*
111	156	LZ4_decompress_fast() :
112		outputSize : is the original (uncompressed) size
	157	originalSize : is the original and therefore uncompressed size
113	158	return : the number of bytes read from the source buffer (in other words, the compressed size)
114		If the source stream is malformed, the function will stop decoding and return a negative result.
115		note : This function is a bit faster than LZ4_decompress_safe()
116		This function never writes outside of output buffers, but may read beyond input buffer in case of malicious data packet.
117		Use this function preferably into a trusted environment (data to decode comes from a trusted source).
118		Destination buffer must be already allocated. Its size must be a minimum of 'outputSize' bytes.
119		*/
120
121		int LZ4_decompress_safe_partial (const char* source, char* dest, int inputSize, int targetOutputSize, int maxOutputSize);
	159	If the source stream is detected malformed, the function will stop decoding and return a negative result.
	160	Destination buffer must be already allocated. Its size must be a minimum of 'originalSize' bytes.
	161	note : This function fully respect memory boundaries for properly formed compressed data.
	162	It is a bit faster than LZ4_decompress_safe().
	163	However, it does not provide any protection against intentionally modified data stream (malicious input).
	164	Use this function in trusted environment only (data to decode comes from a trusted source).
	165	*/
	166	int LZ4_decompress_fast (const char* source, char* dest, int originalSize);
122	167
123	168	/*
124	169	LZ4_decompress_safe_partial() :
125		This function decompress a compressed block of size 'inputSize' at position 'source'
126		into output buffer 'dest' of size 'maxOutputSize'.
	170	This function decompress a compressed block of size 'compressedSize' at position 'source'
	171	into destination buffer 'dest' of size 'maxDecompressedSize'.
127	172	The function tries to stop decompressing operation as soon as 'targetOutputSize' has been reached,
128	173	reducing decompression time.
129		return : the number of bytes decoded in the destination buffer (necessarily <= maxOutputSize)
	174	return : the number of bytes decoded in the destination buffer (necessarily <= maxDecompressedSize)
130	175	Note : this number can be < 'targetOutputSize' should the compressed block to decode be smaller.
131	176	Always control how many bytes were decoded.
132	177	If the source stream is detected malformed, the function will stop decoding and return a negative result.
133	178	This function never writes outside of output buffer, and never reads outside of input buffer. It is therefore protected against malicious data packets
134	179	*/
135
136
137		//*****************************
138		// Using an external allocation
139		//*****************************
140		int LZ4_sizeofState();
	180	int LZ4_decompress_safe_partial (const char* source, char* dest, int compressedSize, int targetOutputSize, int maxDecompressedSize);
	181
	182
	183	/***********************************************
	184	* Streaming Compression Functions
	185	***********************************************/
	186	#define LZ4_STREAMSIZE_U64 ((1 << (LZ4_MEMORY_USAGE-3)) + 4)
	187	#define LZ4_STREAMSIZE (LZ4_STREAMSIZE_U64 * sizeof(long long))
	188	/*
	189	* LZ4_stream_t
	190	* information structure to track an LZ4 stream.
	191	* important : init this structure content before first use !
	192	* note : only allocated directly the structure if you are statically linking LZ4
	193	* If you are using liblz4 as a DLL, please use below construction methods instead.
	194	*/
	195	typedef struct { long long table[LZ4_STREAMSIZE_U64]; } LZ4_stream_t;
	196
	197	/*
	198	* LZ4_resetStream
	199	* Use this function to init an allocated LZ4_stream_t structure
	200	*/
	201	void LZ4_resetStream (LZ4_stream_t* streamPtr);
	202
	203	/*
	204	* LZ4_createStream will allocate and initialize an LZ4_stream_t structure
	205	* LZ4_freeStream releases its memory.
	206	* In the context of a DLL (liblz4), please use these methods rather than the static struct.
	207	* They are more future proof, in case of a change of LZ4_stream_t size.
	208	*/
	209	LZ4_stream_t* LZ4_createStream(void);
	210	int LZ4_freeStream (LZ4_stream_t* streamPtr);
	211
	212	/*
	213	* LZ4_loadDict
	214	* Use this function to load a static dictionary into LZ4_stream.
	215	* Any previous data will be forgotten, only 'dictionary' will remain in memory.
	216	* Loading a size of 0 is allowed.
	217	* Return : dictionary size, in bytes (necessarily <= 64 KB)
	218	*/
	219	int LZ4_loadDict (LZ4_stream_t* streamPtr, const char* dictionary, int dictSize);
	220
	221	/*
	222	* LZ4_compress_fast_continue
	223	* Compress buffer content 'src', using data from previously compressed blocks as dictionary to improve compression ratio.
	224	* Important : Previous data blocks are assumed to still be present and unmodified !
	225	* 'dst' buffer must be already allocated.
	226	* If maxDstSize >= LZ4_compressBound(srcSize), compression is guaranteed to succeed, and runs faster.
	227	* If not, and if compressed data cannot fit into 'dst' buffer size, compression stops, and function returns a zero.
	228	*/
	229	int LZ4_compress_fast_continue (LZ4_stream_t* streamPtr, const char* src, char* dst, int srcSize, int maxDstSize, int acceleration);
	230
	231	/*
	232	* LZ4_saveDict
	233	* If previously compressed data block is not guaranteed to remain available at its memory location
	234	* save it into a safer place (char* safeBuffer)
	235	* Note : you don't need to call LZ4_loadDict() afterwards,
	236	* dictionary is immediately usable, you can therefore call LZ4_compress_fast_continue()
	237	* Return : saved dictionary size in bytes (necessarily <= dictSize), or 0 if error
	238	*/
	239	int LZ4_saveDict (LZ4_stream_t* streamPtr, char* safeBuffer, int dictSize);
	240
	241
	242	/************************************************
	243	* Streaming Decompression Functions
	244	************************************************/
	245
	246	#define LZ4_STREAMDECODESIZE_U64 4
	247	#define LZ4_STREAMDECODESIZE (LZ4_STREAMDECODESIZE_U64 * sizeof(unsigned long long))
	248	typedef struct { unsigned long long table[LZ4_STREAMDECODESIZE_U64]; } LZ4_streamDecode_t;
	249	/*
	250	* LZ4_streamDecode_t
	251	* information structure to track an LZ4 stream.
	252	* init this structure content using LZ4_setStreamDecode or memset() before first use !
	253	*
	254	* In the context of a DLL (liblz4) please prefer usage of construction methods below.
	255	* They are more future proof, in case of a change of LZ4_streamDecode_t size in the future.
	256	* LZ4_createStreamDecode will allocate and initialize an LZ4_streamDecode_t structure
	257	* LZ4_freeStreamDecode releases its memory.
	258	*/
	259	LZ4_streamDecode_t* LZ4_createStreamDecode(void);
	260	int LZ4_freeStreamDecode (LZ4_streamDecode_t* LZ4_stream);
	261
	262	/*
	263	* LZ4_setStreamDecode
	264	* Use this function to instruct where to find the dictionary.
	265	* Setting a size of 0 is allowed (same effect as reset).
	266	* Return : 1 if OK, 0 if error
	267	*/
	268	int LZ4_setStreamDecode (LZ4_streamDecode_t* LZ4_streamDecode, const char* dictionary, int dictSize);
	269
	270	/*
	271	*_continue() :
	272	These decoding functions allow decompression of multiple blocks in "streaming" mode.
	273	Previously decoded blocks must remain available at the memory position where they were decoded (up to 64 KB)
	274	In the case of a ring buffers, decoding buffer must be either :
	275	- Exactly same size as encoding buffer, with same update rule (block boundaries at same positions)
	276	In which case, the decoding & encoding ring buffer can have any size, including very small ones ( < 64 KB).
	277	- Larger than encoding buffer, by a minimum of maxBlockSize more bytes.
	278	maxBlockSize is implementation dependent. It's the maximum size you intend to compress into a single block.
	279	In which case, encoding and decoding buffers do not need to be synchronized,
	280	and encoding ring buffer can have any size, including small ones ( < 64 KB).
	281	- _At least_ 64 KB + 8 bytes + maxBlockSize.
	282	In which case, encoding and decoding buffers do not need to be synchronized,
	283	and encoding ring buffer can have any size, including larger than decoding buffer.
	284	Whenever these conditions are not possible, save the last 64KB of decoded data into a safe buffer,
	285	and indicate where it is saved using LZ4_setStreamDecode()
	286	*/
	287	int LZ4_decompress_safe_continue (LZ4_streamDecode_t* LZ4_streamDecode, const char* source, char* dest, int compressedSize, int maxDecompressedSize);
	288	int LZ4_decompress_fast_continue (LZ4_streamDecode_t* LZ4_streamDecode, const char* source, char* dest, int originalSize);
	289
	290
	291	/*
	292	Advanced decoding functions :
	293	*_usingDict() :
	294	These decoding functions work the same as
	295	a combination of LZ4_setStreamDecode() followed by LZ4_decompress_x_continue()
	296	They are stand-alone. They don't need nor update an LZ4_streamDecode_t structure.
	297	*/
	298	int LZ4_decompress_safe_usingDict (const char* source, char* dest, int compressedSize, int maxDecompressedSize, const char* dictStart, int dictSize);
	299	int LZ4_decompress_fast_usingDict (const char* source, char* dest, int originalSize, const char* dictStart, int dictSize);
	300
	301
	302
	303	/**************************************
	304	* Obsolete Functions
	305	**************************************/
	306	/* Deprecate Warnings */
	307	/* Should these warnings messages be a problem,
	308	it is generally possible to disable them,
	309	with -Wno-deprecated-declarations for gcc
	310	or _CRT_SECURE_NO_WARNINGS in Visual for example.
	311	You can also define LZ4_DEPRECATE_WARNING_DEFBLOCK. */
	312	#ifndef LZ4_DEPRECATE_WARNING_DEFBLOCK
	313	# define LZ4_DEPRECATE_WARNING_DEFBLOCK
	314	# define LZ4_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
	315	# if (LZ4_GCC_VERSION >= 405) \|\| defined(__clang__)
	316	# define LZ4_DEPRECATED(message) __attribute__((deprecated(message)))
	317	# elif (LZ4_GCC_VERSION >= 301)
	318	# define LZ4_DEPRECATED(message) __attribute__((deprecated))
	319	# elif defined(_MSC_VER)
	320	# define LZ4_DEPRECATED(message) __declspec(deprecated(message))
	321	# else
	322	# pragma message("WARNING: You need to implement LZ4_DEPRECATED for this compiler")
	323	# define LZ4_DEPRECATED(message)
	324	# endif
	325	#endif /* LZ4_DEPRECATE_WARNING_DEFBLOCK */
	326
	327	/* Obsolete compression functions */
	328	/* These functions are planned to start generate warnings by r131 approximately */
	329	int LZ4_compress (const char* source, char* dest, int sourceSize);
	330	int LZ4_compress_limitedOutput (const char* source, char* dest, int sourceSize, int maxOutputSize);
141	331	int LZ4_compress_withState (void* state, const char* source, char* dest, int inputSize);
142	332	int LZ4_compress_limitedOutput_withState (void* state, const char* source, char* dest, int inputSize, int maxOutputSize);
143
144		/*
145		These functions are provided should you prefer to allocate memory for compression tables with your own allocation methods.
146		To know how much memory must be allocated for the compression tables, use :
147		int LZ4_sizeofState();
148
149		Note that tables must be aligned on 4-bytes boundaries, otherwise compression will fail (return code 0).
150
151		The allocated memory can be provided to the compressions functions using 'void* state' parameter.
152		LZ4_compress_withState() and LZ4_compress_limitedOutput_withState() are equivalent to previously described functions.
153		They just use the externally allocated memory area instead of allocating their own (on stack, or on heap).
154		*/
155
156
157		//****************************
158		// Streaming Functions
159		//****************************
160
161		void* LZ4_create (const char* inputBuffer);
162		int LZ4_compress_continue (void* LZ4_Data, const char* source, char* dest, int inputSize);
163		int LZ4_compress_limitedOutput_continue (void* LZ4_Data, const char* source, char* dest, int inputSize, int maxOutputSize);
164		char* LZ4_slideInputBuffer (void* LZ4_Data);
165		int LZ4_free (void* LZ4_Data);
166
167		/*
168		These functions allow the compression of dependent blocks, where each block benefits from prior 64 KB within preceding blocks.
169		In order to achieve this, it is necessary to start creating the LZ4 Data Structure, thanks to the function :
170
171		void* LZ4_create (const char* inputBuffer);
172		The result of the function is the (void*) pointer on the LZ4 Data Structure.
173		This pointer will be needed in all other functions.
174		If the pointer returned is NULL, then the allocation has failed, and compression must be aborted.
175		The only parameter 'const char* inputBuffer' must, obviously, point at the beginning of input buffer.
176		The input buffer must be already allocated, and size at least 192KB.
177		'inputBuffer' will also be the 'const char* source' of the first block.
178
179		All blocks are expected to lay next to each other within the input buffer, starting from 'inputBuffer'.
180		To compress each block, use either LZ4_compress_continue() or LZ4_compress_limitedOutput_continue().
181		Their behavior are identical to LZ4_compress() or LZ4_compress_limitedOutput(),
182		but require the LZ4 Data Structure as their first argument, and check that each block starts right after the previous one.
183		If next block does not begin immediately after the previous one, the compression will fail (return 0).
184
185		When it's no longer possible to lay the next block after the previous one (not enough space left into input buffer), a call to :
186		char* LZ4_slideInputBuffer(void* LZ4_Data);
187		must be performed. It will typically copy the latest 64KB of input at the beginning of input buffer.
188		Note that, for this function to work properly, minimum size of an input buffer must be 192KB.
189		==> The memory position where the next input data block must start is provided as the result of the function.
190
191		Compression can then resume, using LZ4_compress_continue() or LZ4_compress_limitedOutput_continue(), as usual.
192
193		When compression is completed, a call to LZ4_free() will release the memory used by the LZ4 Data Structure.
194		*/
195
196		int LZ4_sizeofStreamState();
197		int LZ4_resetStreamState(void* state, const char* inputBuffer);
198
199		/*
200		These functions achieve the same result as :
201		void* LZ4_create (const char* inputBuffer);
202
203		They are provided here to allow the user program to allocate memory using its own routines.
204
205		To know how much space must be allocated, use LZ4_sizeofStreamState();
206		Note also that space must be 4-bytes aligned.
207
208		Once space is allocated, you must initialize it using : LZ4_resetStreamState(void* state, const char* inputBuffer);
209		void* state is a pointer to the space allocated.
210		It must be aligned on 4-bytes boundaries, and be large enough.
211		The parameter 'const char* inputBuffer' must, obviously, point at the beginning of input buffer.
212		The input buffer must be already allocated, and size at least 192KB.
213		'inputBuffer' will also be the 'const char* source' of the first block.
214
215		The same space can be re-used multiple times, just by initializing it each time with LZ4_resetStreamState().
216		return value of LZ4_resetStreamState() must be 0 is OK.
217		Any other value means there was an error (typically, pointer is not aligned on 4-bytes boundaries).
218		*/
219
220
221		int LZ4_decompress_safe_withPrefix64k (const char* source, char* dest, int inputSize, int maxOutputSize);
222		int LZ4_decompress_fast_withPrefix64k (const char* source, char* dest, int outputSize);
223
224		/*
225		*_withPrefix64k() :
226		These decoding functions work the same as their "normal name" versions,
227		but can use up to 64KB of data in front of 'char* dest'.
228		These functions are necessary to decode inter-dependant blocks.
229		*/
230
231
232		//****************************
233		// Obsolete Functions
234		//****************************
235
236		static inline int LZ4_uncompress (const char* source, char* dest, int outputSize) { return LZ4_decompress_fast(source, dest, outputSize); }
237		static inline int LZ4_uncompress_unknownOutputSize (const char* source, char* dest, int isize, int maxOutputSize) { return LZ4_decompress_safe(source, dest, isize, maxOutputSize); }
238
239		/*
240		These functions are deprecated and should no longer be used.
241		They are provided here for compatibility with existing user programs.
242		*/
243
	333	int LZ4_compress_continue (LZ4_stream_t* LZ4_streamPtr, const char* source, char* dest, int inputSize);
	334	int LZ4_compress_limitedOutput_continue (LZ4_stream_t* LZ4_streamPtr, const char* source, char* dest, int inputSize, int maxOutputSize);
	335
	336	/* Obsolete decompression functions */
	337	/* These function names are completely deprecated and must no longer be used.
	338	They are only provided here for compatibility with older programs.
	339	- LZ4_uncompress is the same as LZ4_decompress_fast
	340	- LZ4_uncompress_unknownOutputSize is the same as LZ4_decompress_safe
	341	These function prototypes are now disabled; uncomment them only if you really need them.
	342	It is highly recommended to stop using these prototypes and migrate to maintained ones */
	343	/* int LZ4_uncompress (const char* source, char* dest, int outputSize); */
	344	/* int LZ4_uncompress_unknownOutputSize (const char* source, char* dest, int isize, int maxOutputSize); */
	345
	346	/* Obsolete streaming functions; use new streaming interface whenever possible */
	347	LZ4_DEPRECATED("use LZ4_createStream() instead") void* LZ4_create (char* inputBuffer);
	348	LZ4_DEPRECATED("use LZ4_createStream() instead") int LZ4_sizeofStreamState(void);
	349	LZ4_DEPRECATED("use LZ4_resetStream() instead") int LZ4_resetStreamState(void* state, char* inputBuffer);
	350	LZ4_DEPRECATED("use LZ4_saveDict() instead") char* LZ4_slideInputBuffer (void* state);
	351
	352	/* Obsolete streaming decoding functions */
	353	LZ4_DEPRECATED("use LZ4_decompress_safe_usingDict() instead") int LZ4_decompress_safe_withPrefix64k (const char* src, char* dst, int compressedSize, int maxDstSize);
	354	LZ4_DEPRECATED("use LZ4_decompress_fast_usingDict() instead") int LZ4_decompress_fast_withPrefix64k (const char* src, char* dst, int originalSize);
244	355
245	356
246	357	#if defined (__cplusplus)

+4

-1

src/impex/tiff.cxx less more

641	641	{
642	642	*bitpointer = ((currentByte & (1 << bit)) ? photometric : 1 - photometric);
643	643	++bitpointer;
644		if (byte * 8 + 7 - bit == width - 1) break;
	644	// NOTE: byte * 8 + 7 - bit is promoted to int by C++'s promotion rules.
	645	// The cast to unsigned should be safe given the bounds of the looping
	646	// variables bit and bytes.
	647	if (static_cast<unsigned>(byte * 8 + 7 - bit) == width - 1) break;
645	648	}
646	649	}
647	650	// XXX probably right

+5

-0

test/CMakeLists.txt less more

2	2	INCLUDE(VigraAddTest)
3	3
4	4	ADD_SUBDIRECTORY(adjacency_list_graph)
	5	ADD_SUBDIRECTORY(binary_forest)
5	6	ADD_SUBDIRECTORY(blockwisealgorithms)
6	7	ADD_SUBDIRECTORY(classifier)
7	8	ADD_SUBDIRECTORY(colorspaces)

12	13	ADD_SUBDIRECTORY(delegates)
13	14	ADD_SUBDIRECTORY(error)
14	15	ADD_SUBDIRECTORY(features)
	16	ADD_SUBDIRECTORY(filter_iterator)
15	17	ADD_SUBDIRECTORY(filters)
16	18	ADD_SUBDIRECTORY(fourier)
17	19	ADD_SUBDIRECTORY(functorexpression)

31	33	ADD_SUBDIRECTORY(multimorphology)
32	34	ADD_SUBDIRECTORY(objectfeatures)
33	35	ADD_SUBDIRECTORY(optimization)
	36	ADD_SUBDIREcTORY(permutation)
34	37	ADD_SUBDIRECTORY(pixeltypes)
35	38	ADD_SUBDIRECTORY(polygon)
	39	ADD_SUBDIRECTORY(polytope)
	40	ADD_SUBDIRECTORY(random_forest_3)
36	41	ADD_SUBDIRECTORY(registration)
37	42	ADD_SUBDIRECTORY(sampler)
38	43	ADD_SUBDIRECTORY(seededRegionGrowing3d)

+34

-34

test/adjacency_list_graph/test.cxx less more

406	406
407	407
408	408	std::vector<Edge> edgeVec(begin,invalid);
409		shouldEqual(4,edgeVec.size());
	409	shouldEqual(4u,edgeVec.size());
410	410	shouldEqual(0,g.id(edgeVec[0]));
411	411	shouldEqual(1,g.id(edgeVec[1]));
412	412	shouldEqual(2,g.id(edgeVec[2]));

418	418
419	419	EdgeIt empty;
420	420	std::vector<Edge> edgeVec(begin,empty);
421		shouldEqual(4,edgeVec.size());
	421	shouldEqual(4u,edgeVec.size());
422	422	shouldEqual(0,g.id(edgeVec[0]));
423	423	shouldEqual(1,g.id(edgeVec[1]));
424	424	shouldEqual(2,g.id(edgeVec[2]));

430	430
431	431	EdgeIt empty;
432	432	std::vector<Edge> edgeVec(begin,empty);
433		shouldEqual(3,edgeVec.size());
	433	shouldEqual(3u,edgeVec.size());
434	434	shouldEqual(1,g.id(edgeVec[0]));
435	435	shouldEqual(2,g.id(edgeVec[1]));
436	436	shouldEqual(3,g.id(edgeVec[2]));

445	445
446	446	shouldEqual(std::distance(begin,end),1);
447	447	std::vector<Edge> edgeVec(begin,end);
448		shouldEqual(1,edgeVec.size());
	448	shouldEqual(1u,edgeVec.size());
449	449	shouldEqual(1,g.id(edgeVec[0]));
450	450	}
451	451

457	457	should(end!=lemon::INVALID);
458	458
459	459	std::vector<Edge> edgeVec(begin,end);
460		shouldEqual(2,edgeVec.size());
	460	shouldEqual(2u,edgeVec.size());
461	461	shouldEqual(1,g.id(edgeVec[0]));
462	462	shouldEqual(2,g.id(edgeVec[1]));
463	463	}

490	490
491	491
492	492	std::vector<Edge> edgeVec(begin,invalid);
493		shouldEqual(4,edgeVec.size());
	493	shouldEqual(4u,edgeVec.size());
494	494	shouldEqual(0,g.id(edgeVec[0]));
495	495	shouldEqual(1,g.id(edgeVec[1]));
496	496	shouldEqual(2,g.id(edgeVec[2]));

502	502
503	503	EdgeIt empty;
504	504	std::vector<Edge> edgeVec(begin,empty);
505		shouldEqual(4,edgeVec.size());
	505	shouldEqual(4u,edgeVec.size());
506	506	shouldEqual(0,g.id(edgeVec[0]));
507	507	shouldEqual(1,g.id(edgeVec[1]));
508	508	shouldEqual(2,g.id(edgeVec[2]));

514	514
515	515	EdgeIt empty;
516	516	std::vector<Edge> edgeVec(begin,empty);
517		shouldEqual(3,edgeVec.size());
	517	shouldEqual(3u,edgeVec.size());
518	518	shouldEqual(1,g.id(edgeVec[0]));
519	519	shouldEqual(2,g.id(edgeVec[1]));
520	520	shouldEqual(3,g.id(edgeVec[2]));

529	529
530	530	shouldEqual(std::distance(begin,end),1);
531	531	std::vector<Edge> edgeVec(begin,end);
532		shouldEqual(1,edgeVec.size());
	532	shouldEqual(1u,edgeVec.size());
533	533	shouldEqual(1,g.id(edgeVec[0]));
534	534	}
535	535

541	541	should(end!=lemon::INVALID);
542	542
543	543	std::vector<Edge> edgeVec(begin,end);
544		shouldEqual(2,edgeVec.size());
	544	shouldEqual(2u,edgeVec.size());
545	545	shouldEqual(1,g.id(edgeVec[0]));
546	546	shouldEqual(2,g.id(edgeVec[1]));
547	547	}

572	572
573	573	should(begin!=lemon::INVALID);
574	574	std::vector<Node> nodeVec(begin,invalid);
575		shouldEqual(4,nodeVec.size());
	575	shouldEqual(4u,nodeVec.size());
576	576	shouldEqual(0,g.id(nodeVec[0]));
577	577	shouldEqual(1,g.id(nodeVec[1]));
578	578	shouldEqual(2,g.id(nodeVec[2]));

584	584
585	585	NodeIt empty;
586	586	std::vector<Node> nodeVec(begin,empty);
587		shouldEqual(4,nodeVec.size());
	587	shouldEqual(4u,nodeVec.size());
588	588	shouldEqual(0,g.id(nodeVec[0]));
589	589	shouldEqual(1,g.id(nodeVec[1]));
590	590	shouldEqual(2,g.id(nodeVec[2]));

596	596
597	597	NodeIt empty;
598	598	std::vector<Node> nodeVec(begin,empty);
599		shouldEqual(3,nodeVec.size());
	599	shouldEqual(3u,nodeVec.size());
600	600	shouldEqual(1,g.id(nodeVec[0]));
601	601	shouldEqual(2,g.id(nodeVec[1]));
602	602	shouldEqual(3,g.id(nodeVec[2]));

611	611
612	612	shouldEqual(std::distance(begin,end),1);
613	613	std::vector<Node> nodeVec(begin,end);
614		shouldEqual(1,nodeVec.size());
	614	shouldEqual(1u,nodeVec.size());
615	615	shouldEqual(1,g.id(nodeVec[0]));
616	616	}
617	617

623	623	should(end!=lemon::INVALID);
624	624
625	625	std::vector<Node> nodeVec(begin,end);
626		shouldEqual(2,nodeVec.size());
	626	shouldEqual(2u,nodeVec.size());
627	627	shouldEqual(1,g.id(nodeVec[0]));
628	628	shouldEqual(2,g.id(nodeVec[1]));
629	629	}

660	660
661	661	should(begin!=lemon::INVALID);
662	662	std::vector<Node> nodeVec(begin,invalid);
663		shouldEqual(4,nodeVec.size());
	663	shouldEqual(4u,nodeVec.size());
664	664	shouldEqual(1,g.id(nodeVec[0]));
665	665	shouldEqual(2,g.id(nodeVec[1]));
666	666	shouldEqual(3,g.id(nodeVec[2]));

672	672
673	673	NodeIt empty;
674	674	std::vector<Node> nodeVec(begin,empty);
675		shouldEqual(4,nodeVec.size());
	675	shouldEqual(4u,nodeVec.size());
676	676	shouldEqual(1,g.id(nodeVec[0]));
677	677	shouldEqual(2,g.id(nodeVec[1]));
678	678	shouldEqual(3,g.id(nodeVec[2]));

684	684
685	685	NodeIt empty;
686	686	std::vector<Node> nodeVec(begin,empty);
687		shouldEqual(3,nodeVec.size());
	687	shouldEqual(3u,nodeVec.size());
688	688	shouldEqual(2,g.id(nodeVec[0]));
689	689	shouldEqual(3,g.id(nodeVec[1]));
690	690	shouldEqual(4,g.id(nodeVec[2]));

699	699
700	700	shouldEqual(std::distance(begin,end),1);
701	701	std::vector<Node> nodeVec(begin,end);
702		shouldEqual(1,nodeVec.size());
	702	shouldEqual(1u,nodeVec.size());
703	703	shouldEqual(2,g.id(nodeVec[0]));
704	704	}
705	705

711	711	should(end!=lemon::INVALID);
712	712
713	713	std::vector<Node> nodeVec(begin,end);
714		shouldEqual(2,nodeVec.size());
	714	shouldEqual(2u,nodeVec.size());
715	715	shouldEqual(2,g.id(nodeVec[0]));
716	716	shouldEqual(3,g.id(nodeVec[1]));
717	717	}

1030	1030	should(begin!=lemon::INVALID);
1031	1031	shouldEqual(std::distance(begin,invalid),8);
1032	1032	std::vector<Arc> arcVec(begin,invalid);
1033		shouldEqual(8,arcVec.size());
	1033	shouldEqual(8u,arcVec.size());
1034	1034	shouldEqual(0,g.id(arcVec[0]));
1035	1035	shouldEqual(1,g.id(arcVec[1]));
1036	1036	shouldEqual(2,g.id(arcVec[2]));

1046	1046
1047	1047	ArcIt empty;
1048	1048	std::vector<Arc> arcVec(begin,empty);
1049		shouldEqual(8,arcVec.size());
	1049	shouldEqual(8u,arcVec.size());
1050	1050	shouldEqual(0,g.id(arcVec[0]));
1051	1051	shouldEqual(1,g.id(arcVec[1]));
1052	1052	shouldEqual(2,g.id(arcVec[2]));

1062	1062
1063	1063	ArcIt empty;
1064	1064	std::vector<Arc> arcVec(begin,empty);
1065		shouldEqual(7,arcVec.size());
	1065	shouldEqual(7u,arcVec.size());
1066	1066	shouldEqual(1,g.id(arcVec[0]));
1067	1067	shouldEqual(2,g.id(arcVec[1]));
1068	1068	shouldEqual(3,g.id(arcVec[2]));

1081	1081
1082	1082	shouldEqual(std::distance(begin,end),1);
1083	1083	std::vector<Arc> arcVec(begin,end);
1084		shouldEqual(1,arcVec.size());
	1084	shouldEqual(1u,arcVec.size());
1085	1085	shouldEqual(1,g.id(arcVec[0]));
1086	1086	}
1087	1087

1093	1093	should(end!=lemon::INVALID);
1094	1094
1095	1095	std::vector<Arc> arcVec(begin,end);
1096		shouldEqual(2,arcVec.size());
	1096	shouldEqual(2u,arcVec.size());
1097	1097	shouldEqual(1,g.id(arcVec[0]));
1098	1098	shouldEqual(2,g.id(arcVec[1]));
1099	1099	}

1202	1202	shouldEqual(std::distance(a,b),2);
1203	1203
1204	1204	std::set<Edge> eSet(a,b);
1205		shouldEqual(eSet.size(),2);
	1205	shouldEqual(eSet.size(),2u);
1206	1206	should(eSet.find(e13)!=eSet.end());
1207	1207	should(eSet.find(e12)!=eSet.end());
1208	1208	should(eSet.find(e34)==eSet.end());

1217	1217	shouldEqual(std::distance(a,b),2);
1218	1218
1219	1219	std::set<Edge> eSet(a,b);
1220		shouldEqual(eSet.size(),2);
	1220	shouldEqual(eSet.size(),2u);
1221	1221	should(eSet.find(e12)!=eSet.end());
1222	1222	should(eSet.find(e24)!=eSet.end());
1223	1223	should(eSet.find(e34)==eSet.end());

1232	1232	shouldEqual(std::distance(a,b),2);
1233	1233
1234	1234	std::set<Edge> eSet(a,b);
1235		shouldEqual(eSet.size(),2);
	1235	shouldEqual(eSet.size(),2u);
1236	1236	should(eSet.find(e13)!=eSet.end());
1237	1237	should(eSet.find(e34)!=eSet.end());
1238	1238	should(eSet.find(e12)==eSet.end());

1247	1247	shouldEqual(std::distance(a,b),2);
1248	1248
1249	1249	std::set<Edge> eSet(a,b);
1250		shouldEqual(eSet.size(),2);
	1250	shouldEqual(eSet.size(),2u);
1251	1251	should(eSet.find(e24)!=eSet.end());
1252	1252	should(eSet.find(e34)!=eSet.end());
1253	1253	should(eSet.find(e12)==eSet.end());

1281	1281	should(a!=b);
1282	1282	should(b==lemon::INVALID);
1283	1283	should(a!=lemon::INVALID);
1284		shouldEqual(std::distance(a,b),2);
	1284	shouldEqual(std::distance(a,b),2u);
1285	1285
1286	1286	std::set<Edge> eSet(a,b);
1287		shouldEqual(eSet.size(),2);
	1287	shouldEqual(eSet.size(),2u);
1288	1288	should(eSet.find(e13)!=eSet.end());
1289	1289	should(eSet.find(e12)!=eSet.end());
1290	1290	should(eSet.find(e34)==eSet.end());

1299	1299	shouldEqual(std::distance(a,b),2);
1300	1300
1301	1301	std::set<Edge> eSet(a,b);
1302		shouldEqual(eSet.size(),2);
	1302	shouldEqual(eSet.size(),2u);
1303	1303	should(eSet.find(e12)!=eSet.end());
1304	1304	should(eSet.find(e24)!=eSet.end());
1305	1305	should(eSet.find(e34)==eSet.end());

1314	1314	shouldEqual(std::distance(a,b),2);
1315	1315
1316	1316	std::set<Edge> eSet(a,b);
1317		shouldEqual(eSet.size(),2);
	1317	shouldEqual(eSet.size(),2u);
1318	1318	should(eSet.find(e13)!=eSet.end());
1319	1319	should(eSet.find(e34)!=eSet.end());
1320	1320	should(eSet.find(e12)==eSet.end());

1329	1329	shouldEqual(std::distance(a,b),2);
1330	1330
1331	1331	std::set<Edge> eSet(a,b);
1332		shouldEqual(eSet.size(),2);
	1332	shouldEqual(eSet.size(),2u);
1333	1333	should(eSet.find(e24)!=eSet.end());
1334	1334	should(eSet.find(e34)!=eSet.end());
1335	1335	should(eSet.find(e12)==eSet.end());

+1

-0

test/binary_forest/CMakeLists.txt less more

0

VIGRA_ADD_TEST(test_binary_forest test.cxx)

+308

-0

test/binary_forest/test.cxx less more

	0	/************************************************************************/
	1	/* */
	2	/* Copyright 2014-2015 by Ullrich Koethe and Philip Schill */
	3	/* */
	4	/* This file is part of the VIGRA computer vision library. */
	5	/* The VIGRA Website is */
	6	/* http://hci.iwr.uni-heidelberg.de/vigra/ */
	7	/* Please direct questions, bug reports, and contributions to */
	8	/* ullrich.koethe@iwr.uni-heidelberg.de or */
	9	/* vigra@informatik.uni-hamburg.de */
	10	/* */
	11	/* Permission is hereby granted, free of charge, to any person */
	12	/* obtaining a copy of this software and associated documentation */
	13	/* files (the "Software"), to deal in the Software without */
	14	/* restriction, including without limitation the rights to use, */
	15	/* copy, modify, merge, publish, distribute, sublicense, and/or */
	16	/* sell copies of the Software, and to permit persons to whom the */
	17	/* Software is furnished to do so, subject to the following */
	18	/* conditions: */
	19	/* */
	20	/* The above copyright notice and this permission notice shall be */
	21	/* included in all copies or substantial portions of the */
	22	/* Software. */
	23	/* */
	24	/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND */
	25	/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES */
	26	/* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND */
	27	/* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT */
	28	/* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, */
	29	/* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING */
	30	/* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR */
	31	/* OTHER DEALINGS IN THE SOFTWARE. */
	32	/* */
	33	/************************************************************************/
	34	#include <vigra/binary_forest.hxx>
	35	#include <vigra/unittest.hxx>
	36
	37	using namespace vigra;
	38
	39	struct BinaryForestTests
	40	{
	41	typedef BinaryForest Graph;
	42	typedef Graph::Node Node;
	43	typedef Graph::Arc Arc;
	44
	45	void test_basic_attributes()
	46	{
	47	Graph gr;
	48	Node n0 = gr.addNode();
	49	Node n1 = gr.addNode();
	50	Node n2 = gr.addNode();
	51	Node n3 = gr.addNode();
	52	Node n4 = gr.addNode();
	53	Node n5 = gr.addNode();
	54	Arc a01 = gr.addArc(n0, n1);
	55	Arc a02 = gr.addArc(n0, n2);
	56	Arc a13 = gr.addArc(n1, n3);
	57	Arc a14 = gr.addArc(n1, n4);
	58	Arc a25 = gr.addArc(n2, n5);
	59
	60	should(n0 != n1);
	61	should(n0 != n2);
	62	should(n0 != n3);
	63	should(n0 != n4);
	64	should(n0 != n5);
	65	should(n1 != n2);
	66	should(n1 != n3);
	67	should(n1 != n4);
	68	should(n1 != n5);
	69	should(n2 != n3);
	70	should(n2 != n4);
	71	should(n2 != n5);
	72	should(n3 != n4);
	73	should(n3 != n5);
	74	should(n4 != n5);
	75
	76	should(a01 != a02);
	77	should(a01 != a13);
	78	should(a01 != a14);
	79	should(a01 != a25);
	80	should(a02 != a13);
	81	should(a02 != a14);
	82	should(a02 != a25);
	83	should(a13 != a14);
	84	should(a13 != a25);
	85	should(a14 != a25);
	86
	87	should(gr.numNodes() == 6);
	88	should(gr.numArcs() == 5);
	89	should(gr.maxNodeId() == 5);
	90	should(gr.maxArcId() == 11);
	91
	92	should(gr.source(a01) == n0);
	93	should(gr.source(a02) == n0);
	94	should(gr.source(a13) == n1);
	95	should(gr.source(a14) == n1);
	96	should(gr.source(a25) == n2);
	97
	98	should(gr.target(a01) == n1);
	99	should(gr.target(a02) == n2);
	100	should(gr.target(a13) == n3);
	101	should(gr.target(a14) == n4);
	102	should(gr.target(a25) == n5);
	103
	104	should(gr.valid(n0));
	105	should(gr.valid(n1));
	106	should(gr.valid(n2));
	107	should(gr.valid(n3));
	108	should(gr.valid(n4));
	109	should(gr.valid(n5));
	110	should(!gr.valid(Node(lemon::INVALID)));
	111	should(!gr.valid(Node(123)));
	112
	113	should(gr.valid(a01));
	114	should(gr.valid(a02));
	115	should(gr.valid(a13));
	116	should(gr.valid(a14));
	117	should(gr.valid(a25));
	118	should(!gr.valid(Arc(lemon::INVALID)));
	119	should(!gr.valid(Arc(123)));
	120
	121	should(gr.inDegree(n0) == 0);
	122	should(gr.inDegree(n1) == 1);
	123	should(gr.inDegree(n2) == 1);
	124	should(gr.inDegree(n3) == 1);
	125	should(gr.inDegree(n4) == 1);
	126	should(gr.inDegree(n5) == 1);
	127
	128	should(gr.outDegree(n0) == 2);
	129	should(gr.outDegree(n1) == 2);
	130	should(gr.outDegree(n2) == 1);
	131	should(gr.outDegree(n3) == 0);
	132	should(gr.outDegree(n4) == 0);
	133	should(gr.outDegree(n5) == 0);
	134
	135	should(gr.numRoots() == 1);
	136	should(gr.getRoot() == n0);
	137	should(!gr.valid(gr.getRoot(1)));
	138	}
	139
	140	void test_merge()
	141	{
	142	Graph gr;
	143	Node n0 = gr.addNode();
	144	Node n1 = gr.addNode();
	145	Node n2 = gr.addNode();
	146	Node n3 = gr.addNode();
	147	Arc a01 = gr.addArc(n0, n1);
	148	Arc a02 = gr.addArc(n0, n2);
	149	Arc a13 = gr.addArc(n1, n3);
	150
	151	Graph gr2;
	152	{
	153	Node n0 = gr2.addNode();
	154	Node n1 = gr2.addNode();
	155	Node n2 = gr2.addNode();
	156	Node n3 = gr2.addNode();
	157	gr2.addArc(n0, n1);
	158	gr2.addArc(n1, n2);
	159	gr2.addArc(n1, n3);
	160	gr.merge(gr2);
	161	}
	162
	163	should(gr.numNodes() == 8);
	164	should(gr.numArcs() == 6);
	165	should(gr.numRoots() == 2);
	166
	167	// Get the new nodes.
	168	Node n4 = gr.nodeFromId(4);
	169	Node n5 = gr.nodeFromId(5);
	170	Node n6 = gr.nodeFromId(6);
	171	Node n7 = gr.nodeFromId(7);
	172
	173	// Check the roots.
	174	should(gr.getRoot(0) == n0);
	175	should(gr.getRoot(1) == n4);
	176
	177	// Check that the old nodes and arcs are still correct.
	178	should(gr.valid(n0));
	179	should(gr.valid(n1));
	180	should(gr.valid(n2));
	181	should(gr.valid(n3));
	182	should(gr.valid(a01));
	183	should(gr.valid(a02));
	184	should(gr.valid(a13));
	185	should(gr.getChild(n0, 0) == n1);
	186	should(gr.getChild(n0, 1) == n2);
	187	should(gr.getChild(n1, 0) == n3);
	188	should(gr.numChildren(n1) == 1);
	189	should(gr.numChildren(n2) == 0);
	190	should(gr.numChildren(n3) == 0);
	191	should(gr.numParents(n0) == 0);
	192
	193	// Check the new nodes and arcs are still correct.
	194	should(gr.getChild(n4, 0) == n5);
	195	should(gr.getChild(n5, 0) == n6);
	196	should(gr.getChild(n5, 1) == n7);
	197	should(gr.numChildren(n4) == 1);
	198	should(gr.numChildren(n5) == 2);
	199	should(gr.numChildren(n6) == 0);
	200	should(gr.numChildren(n7) == 0);
	201	should(gr.numParents(n4) == 0);
	202	}
	203
	204	template <ContainerTag CTag>
	205	void test_property_map()
	206	{
	207	PropertyMap<Node, int, CTag> m;
	208	Node n0(2);
	209	Node n1(5);
	210	Node n2(10);
	211	Node n3(27);
	212	m.insert(n0, 27);
	213	m.insert(n1, 12);
	214	m.insert(n2, 73);
	215
	216	should(m.size() == 3);
	217	should(m.at(n0) == 27);
	218	should(m.at(n1) == 12);
	219	should(m.at(n2) == 73);
	220	should(m[n0] == 27);
	221	should(m[n1] == 12);
	222	should(m[n2] == 73);
	223
	224	{
	225	auto it = m.find(n0);
	226	should(it != m.end());
	227	should(it->first == n0);
	228	should(it->second == 27);
	229	should(m.find(n3) == m.end());
	230	}
	231
	232	{
	233	PropertyMap<Node, int, CTag> m2;
	234	m2 = m;
	235	should(m2.size() == 3);
	236	should(m[n0] == 27);
	237	should(m[n1] == 12);
	238	should(m[n2] == 73);
	239	}
	240
	241	{
	242	std::vector<Node> keys, keys_expected;// = {n0, n1, n2};
	243	keys_expected.push_back(n0);
	244	keys_expected.push_back(n1);
	245	keys_expected.push_back(n2);
	246	std::vector<int> values, values_expected;// = {27, 12, 73};
	247	values_expected.push_back(27);
	248	values_expected.push_back(12);
	249	values_expected.push_back(73);
	250	for (auto const & p : m)
	251	{
	252	keys.push_back(p.first);
	253	values.push_back(p.second);
	254	}
	255	shouldEqualSequence(keys.begin(), keys.end(), keys_expected.begin());
	256	shouldEqualSequence(values.begin(), values.end(), values_expected.begin());
	257	}
	258
	259	m.erase(n1);
	260	should(m.size() == 2);
	261	should(m.at(n0) == 27);
	262	should(m.at(n2) == 73);
	263	should(m[n0] == 27);
	264	should(m[n2] == 73);
	265
	266	{
	267	std::vector<Node> keys, keys_expected;// = {n0, n2};
	268	keys_expected.push_back(n0);
	269	keys_expected.push_back(n2);
	270	std::vector<int> values, values_expected;// = {27, 73};
	271	values_expected.push_back(27);
	272	values_expected.push_back(73);
	273	for (auto const & p : m)
	274	{
	275	keys.push_back(p.first);
	276	values.push_back(p.second);
	277	}
	278	shouldEqualSequence(keys.begin(), keys.end(), keys_expected.begin());
	279	shouldEqualSequence(values.begin(), values.end(), values_expected.begin());
	280	}
	281
	282	m.clear();
	283	should(m.size() == 0);
	284	}
	285	};
	286
	287	struct BinaryForestTestSuite : public test_suite
	288	{
	289	BinaryForestTestSuite()
	290	:
	291	test_suite("BinaryForest test")
	292	{
	293	add(testCase(&BinaryForestTests::test_basic_attributes));
	294	add(testCase(&BinaryForestTests::test_merge));
	295	add(testCase(&BinaryForestTests::test_property_map<MapTag>));
	296	add(testCase(&BinaryForestTests::test_property_map<IndexVectorTag>));
	297	add(testCase(&BinaryForestTests::test_property_map<VectorTag>));
	298	}
	299	};
	300
	301	int main(int argc, char** argv)
	302	{
	303	BinaryForestTestSuite forest_test;
	304	int failed = forest_test.run(testsToBeExecuted(argc, argv));
	305	std::cout << forest_test.report() << std::endl;
	306	return (failed != 0);
	307	}

+3

-3

test/blockwisealgorithms/test_labeling.cxx less more

157	157	array_fives.push_back(Array5(Shape5(1)));
158	158	array_fives.push_back(Array5(Shape5(2,2,3,4,3)));
159	159	array_fives.push_back(Array5(Shape5(5,6,2,2,3)));
160		for(int i = 0; i != array_fives.size(); ++i)
	160	for(decltype(array_fives.size()) i = 0; i != array_fives.size(); ++i)
161	161	{
162	162	fillRandom(array_fives[i].begin(), array_fives[i].end(), 3);
163	163	}

168	168	array_twos.push_back(Array2(Shape2(4,4)));
169	169	array_twos.push_back(Array2(Shape2(6,10)));
170	170	array_twos.push_back(Array2(Shape2(19,25)));
171		for(int i = 0; i != array_twos.size(); ++i)
	171	for(decltype(array_twos.size()) i = 0; i != array_twos.size(); ++i)
172	172	{
173	173	fillRandom(array_twos[i].begin(), array_twos[i].end(), 3);
174	174	}

178	178	array_ones.push_back(Array1(Shape1(47)));
179	179	array_ones.push_back(Array1(Shape1(81)));
180	180	array_ones.push_back(Array1(Shape1(997)));
181		for(int i = 0; i != array_ones.size(); ++i)
	181	for(decltype(array_ones.size()) i = 0; i != array_ones.size(); ++i)
182	182	{
183	183	fillRandom(array_ones[i].begin(), array_ones[i].end(), 3);
184	184	}

+6

-6

test/blockwisealgorithms/test_watersheds.cxx less more

61	61	data_sets.push_back(Array(Shape(5)));
62	62	data_sets.push_back(Array(Shape(997)));
63	63	data_sets.push_back(Array(Shape(10000)));
64		for(int i = 0; i != data_sets.size(); ++i)
	64	for(decltype(data_sets.size()) i = 0; i != data_sets.size(); ++i)
65	65	{
66	66	fillRandom(data_sets[i].begin(), data_sets[i].end(), 3);
67	67	}
68	68
69		for(int i = 0; i != data_sets.size(); ++i)
	69	for(decltype(data_sets.size()) i = 0; i != data_sets.size(); ++i)
70	70	{
71	71	const Array& data = data_sets[i];
72	72

109	109	data_sets.push_back(Array(Shape(6)));
110	110	data_sets.push_back(Array(Shape(1, 10, 100, 1)));
111	111
112		for(int i = 0; i != data_sets.size(); ++i)
	112	for(decltype(data_sets.size()) i = 0; i != data_sets.size(); ++i)
113	113	{
114	114	fillRandom(data_sets[i].begin(), data_sets[i].end(), 3);
115	115	}

125	125	neighborhoods.push_back(DirectNeighborhood);
126	126	neighborhoods.push_back(IndirectNeighborhood);
127	127
128		for(int i = 0; i != data_sets.size(); ++i)
	128	for(decltype(data_sets.size()) i = 0; i != data_sets.size(); ++i)
129	129	{
130	130	const Array& data = data_sets[i];
131		for(int j = 0; j != block_shapes.size(); ++j)
	131	for(decltype(block_shapes.size()) j = 0; j != block_shapes.size(); ++j)
132	132	{
133	133	const Shape& block_shape = block_shapes[j];
134		for(int k = 0; k != neighborhoods.size(); ++k)
	134	for(decltype(neighborhoods.size()) k = 0; k != neighborhoods.size(); ++k)
135	135	{
136	136	NeighborhoodType neighborhood = neighborhoods[k];
137	137

+10

-0

test/blockwisealgorithms/utils.hxx less more

37	37
38	38	#include <cstdlib>
39	39	#include <vector>
	40
	41	#ifdef __GNUC__
	42	#pragma GCC diagnostic push
	43	#pragma GCC diagnostic ignored "-Wsign-compare"
	44	#endif
40	45
41	46	template <class Iterator1,class Iterator2>
42	47	bool equivalentLabels(Iterator1 begin1, Iterator1 end1,

80	85	*begin = rand() % maximum;
81	86	}
82	87
	88	#ifdef __GNUC__
	89	#pragma GCC diagnostic pop
	90	#endif
	91
	92
83	93	#endif // VIGRA_BLOCKWISE_ALGORITHMS_TEST_UTILS_HXX

+5

-4

test/classifier/CMakeLists.txt less more

0	0	if(HDF5_FOUND)
1		INCLUDE_DIRECTORIES(${HDF5_INCLUDE_DIR})
2
	1	INCLUDE_DIRECTORIES(${SUPPRESS_WARNINGS} ${HDF5_INCLUDE_DIR})
3	2	ADD_DEFINITIONS(${HDF5_CPPFLAGS} -DHasHDF5)
	3
4	4	VIGRA_ADD_TEST(test_classifier test.cxx LIBRARIES vigraimpex ${HDF5_LIBRARIES})
	5	VIGRA_ADD_TEST(classifier_speed_comparison speed_comparison.cxx LIBRARIES ${HDF5_LIBRARIES})
5	6	else()
6	7	MESSAGE(STATUS "** WARNING: test_classifier::RFHDF5Test() will not be executed")
	8
7	9	VIGRA_ADD_TEST(test_classifier test.cxx )
	10	VIGRA_ADD_TEST(classifier_speed_comparison speed_comparison.cxx)
8	11	endif()
9
10		VIGRA_ADD_TEST(classifier_speed_comparison speed_comparison.cxx)
11	12
12	13	add_subdirectory(data)
13	14

+1

-1

test/classifier/speed_comparison.cxx less more

9	9
10	10
11	11
12		int main(int argc, char ** argv)
	12	int main(int /argc/, char ** /argv/)
13	13	{
14	14	typedef MultiArrayShape<2>::type Shp;
15	15	MultiArray<2, double> features(Shp(1000, 50), 0.0);

+11

-11

test/classifier/test_visitors.hxx less more

53	53
54	54	//TODO split must be const
55	55	template<class Tree, class Split, class Region, class Feature_t, class Label_t>
56		void visit_after_split( Tree & tree,
	56	void visit_after_split( Tree & /tree/,
57	57	Split & split,
58	58	Region & parent,
59	59	Region & leftChild,
60	60	Region & rightChild,
61		Feature_t & features,
62		Label_t & labels)
	61	Feature_t & /features/,
	62	Label_t & /labels/)
63	63	{
64	64	if(split.createNode().typeID() == i_ThresholdNode)
65	65	{

85	85	}
86	86
87	87	template<class RF, class PR, class SM, class ST>
88		void visit_after_tree( RF& rf, PR & pr, SM & sm, ST & st, int index)
	88	void visit_after_tree( RF& /rf/, PR & /pr/, SM & /sm/, ST & /st/, int index)
89	89	{
90	90	fout << std::endl << std::endl << "Tree Number: " << index << " finished." << std::endl << std::endl;
91	91	}

105	105
106	106
107	107	template<class Tree, class Split, class Region, class Feature_t, class Label_t>
108		void visit_after_split( Tree & tree,
	108	void visit_after_split( Tree & /tree/,
109	109	Split & split,
110	110	Region & parent,
111	111	Region & leftChild,
112	112	Region & rightChild,
113		Feature_t & features,
114		Label_t & labels)
	113	Feature_t & /features/,
	114	Label_t & /labels/)
115	115	{
116	116	if(split.createNode().typeID() == i_ThresholdNode)
117	117	{

132	132	}
133	133
134	134	template<class RF, class PR, class SM, class ST>
135		void visit_after_tree( RF& rf, PR & pr, SM & sm, ST & st, int index)
	135	void visit_after_tree( RF& /rf/, PR & /pr/, SM & /sm/, ST & /st/, int /index/)
136	136	{
137	137	treesset.insert(sout.str());
138	138	sout.str(std::string());
139	139	}
140	140
141	141	template<class RF, class PR>
142		void visit_at_end(RF & rf, PR & pr)
	142	void visit_at_end(RF & /rf/, PR & /pr/)
143	143	{
144	144	std::ofstream fout("setTest.log");
145	145	std::set<std::string>::iterator iter;

171	171
172	172	//TODO split must be const
173	173	template<class Tree, class Split, class Region, class Feature_t, class Label_t>
174		void visit_after_split( Tree & tree,
	174	void visit_after_split( Tree & /tree/,
175	175	Split & split,
176	176	Region & parent,
177	177	Region & leftChild,

216	216	}
217	217
218	218	template<class RF, class PR, class SM, class ST>
219		void visit_after_tree( RF& rf, PR & pr, SM & sm, ST & st, int index)
	219	void visit_after_tree( RF& /rf/, PR & /pr/, SM & /sm/, ST & /st/, int index)
220	220	{
221	221	fout << std::endl << std::endl << "Tree Number: " << index << " finished." << std::endl << std::endl;
222	222	}

+284

-271

test/convolution/test.cxx less more

28	28	/* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, */
29	29	/* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING */
30	30	/* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR */
31		/* OTHER DEALINGS IN THE SOFTWARE. */
	31	/* OTHER DEALINGS IN THE SOFTWARE. */
32	32	/* */
33	33	/************************************************************************/
34	34

50	50
51	51	vigra::DImage getSymmetricLine(bool transposed = false){
52	52	vigra::DImage src;
53
	53
54	54	if(transposed)
55	55	src.resize(1, 40);
56	56	else

113	113	typedef vigra::DRGBImage RGBImage;
114	114
115	115	ConvolutionTest()
116		: constimg(5,5),
117		rampimg(5,1),
118		sym_image(getSymmetricImage()),
	116	: constimg(5,5),
	117	rampimg(5,1),
	118	sym_image(getSymmetricImage()),
119	119	unsym_image(getUnsymmetricImage())
120	120	{
121	121	constimg.init(1.0);
122
	122
123	123	vigra::Kernel1D<double> binom1;
124	124	binom1.initBinomial(1);
125	125	sym_kernel.initSeparable(binom1, binom1);

131	131
132	132	line_kernel.initExplicitly(Diff2D(-2,0), Diff2D(2,0)) = 1, 4, 12, 4, 1 ;
133	133	line_kernel.normalize(1);
134
	134
135	135	ImageImportInfo info("lenna128.xv");
136	136
137	137	lenna.resize(info.width(), info.height());

140	140	Image::ScanOrderIterator i = rampimg.begin();
141	141	Image::ScanOrderIterator end = rampimg.end();
142	142	Image::Accessor acc = rampimg.accessor();
143
	143
144	144	for(int k=0; i != end; ++i, ++k)
145	145	{
146	146	acc.set(k, i);

254	254	shouldEqualSequence(out, out+outsize-ksize, r);
255	255	}
256	256	}
257
	257
258	258	void initExplicitlyTest()
259	259	{
260	260	vigra::Kernel1D<double> k;
261	261	k.initExplicitly(-1,2) = 1,2,3,4;
262
	262
263	263	shouldEqual(k.left(), -1);
264	264	shouldEqual(k.right(), 2);
265	265	shouldEqual(k[-1], 1);
266	266	shouldEqual(k[0], 2);
267	267	shouldEqual(k[1], 3);
268	268	shouldEqual(k[2], 4);
269
	269
270	270	k.initExplicitly(-2,1) = -2;
271	271	shouldEqual(k.left(), -2);
272	272	shouldEqual(k.right(), 1);

320	320	std::string message(c.what());
321	321	should(0 == expected.compare(message.substr(0,expected.size())));
322	322	}
	323
	324	double data[] = { 1, 2, 4,
	325	5, 11, 3,
	326	6, 8, 7 };
	327	BasicImage<double> kernel_image(3,3, data);
	328	Kernel2D<double> kernel_from_image;
	329	kernel_from_image.initExplicitly(kernel_image);
	330	unsym_kernel.normalize(kernel_from_image.norm());
	331
	332	for(int y=-1; y<=1; ++y)
	333	for(int x=-1; x<=1; ++x)
	334	shouldEqualTolerance(unsym_kernel(x,y), kernel_from_image(x,y), 1e-14);
	335
323	336	}
324	337
325	338	void simpleSharpeningTest()

378	391	}
379	392
380	393	void stdConvolutionTestOnConstImage()
381		{
	394	{
382	395	Image tmp_clip(constimg);
383	396	tmp_clip = 0.0;
384	397	Image tmp_wrap(constimg);

395	408
396	409	sym_kernel.setBorderTreatment(BORDER_TREATMENT_AVOID);
397	410	convolveImage(View(constimg), View(tmp_avoid), sym_kernel);
398
	411
399	412	sym_kernel.setBorderTreatment(BORDER_TREATMENT_WRAP);
400	413	convolveImage(View(constimg), View(tmp_wrap), sym_kernel);
401	414

404	417
405	418	sym_kernel.setBorderTreatment(BORDER_TREATMENT_REFLECT);
406	419	convolveImage(View(constimg), View(tmp_reflect), sym_kernel);
407
	420
408	421	Image::ScanOrderIterator i_src = constimg.begin();
409	422	Image::ScanOrderIterator i_src_end = constimg.end();
410	423	Image::ScanOrderIterator i_clip = tmp_clip.begin();

413	426	Image::ScanOrderIterator i_repeat = tmp_repeat.begin();
414	427	Image::ScanOrderIterator i_reflect = tmp_reflect.begin();
415	428	Image::Accessor acc = constimg.accessor();
416
	429
417	430	for(int y = 0; i_src != i_src_end; y++){
418	431	for(int x = 0; x < constimg.size().x; x++, ++i_src, ++i_clip, ++i_wrap, ++i_repeat, ++i_reflect, ++i_avoid){
419	432	should(acc(i_src) == acc(i_clip));

421	434	should(acc(i_src) == acc(i_repeat));
422	435	should(acc(i_src) == acc(i_reflect));
423	436	if(x != 0 && y != 0 && x != 4 && y != 4){
424		should(acc(i_src) == acc(i_avoid));
	437	should(acc(i_src) == acc(i_avoid));
425	438	}else{
426	439	should(acc(i_avoid) == 0);
427	440	}

435	448	// exportImage(srcImageRange(dest_lenna), ImageExportInfo("lenna_convolve_128x120.xv"));
436	449
437	450	}
438
	451
439	452
440	453	void stdConvolutionTestWithAvoid()
441	454	{

462	475	}
463	476
464	477	}
465
	478
466	479
467	480	void stdConvolutionTestWithZeropad()
468	481	{

470	483	dest.init(42.1);
471	484	ref.init(33.2);
472	485
473		convolveImage(srcImageRange(sym_image, Rect2D(Point2D(1,1), sym_image.size()-Size2D(2,2))),
	486	convolveImage(srcImageRange(sym_image, Rect2D(Point2D(1,1), sym_image.size()-Size2D(2,2))),
474	487	destImage(dest), kernel2d(sym_kernel, BORDER_TREATMENT_ZEROPAD));
475	488
476	489	initImageBorder(destImageRange(sym_image), 1, 0);

491	504	}
492	505	}
493	506	}
494
	507
495	508	void stdConvolutionTestWithClip()
496	509	{
497	510	Image dest(sym_image);

516	529	shouldEqualTolerance (acc(i_dest_2D + Diff2D(3,2)), 6.05852, 1E-4);
517	530	shouldEqualTolerance (acc(i_dest_2D + Diff2D(6,4)), 9.14363, 1E-4);
518	531	}
519
	532
520	533	void stdConvolutionTestWithWrap()
521	534	{
522	535	Image dest(unsym_image);

541	554	shouldEqualTolerance (acc(i_dest_2D + Diff2D(2,3)), 33.0798, 1E-5);
542	555	shouldEqualTolerance (acc(i_dest_2D + Diff2D(6,4)), 48.4841, 1E-5);
543	556	}
544
	557
545	558	void stdConvolutionTestWithReflect()
546	559	{
547	560	Image dest(unsym_image);

566	579	shouldEqualTolerance (acc(i_dest_2D + Diff2D(2,3)), 33.0798, 1E-5);
567	580	shouldEqualTolerance (acc(i_dest_2D + Diff2D(6,4)), 48.4841, 1E-5);
568	581	}
569
	582
570	583	void stdConvolutionTestWithRepeat()
571	584	{
572	585	Image dest(unsym_image);

594	607
595	608	void stdConvolutionTestFromWrapWithReflect()
596	609	{
597
	610
598	611	Image src_wrap(78, 1);
599	612	Image src_reflect(40, 1);
600	613	Image dest_wrap(src_wrap);

612	625	for (int j = 38 ; j >= 1 ; j--, iter_src_wrap++){
613	626	acc_src_wrap.set( j + 0.25, iter_src_wrap);
614	627	}
615
	628
616	629	convolveImage(srcImageRange(src_wrap), destImage(dest_wrap), kernel2d(line_kernel, BORDER_TREATMENT_WRAP));
617	630	convolveImage(srcImageRange(src_reflect), destImage(dest_reflect), kernel2d(line_kernel, BORDER_TREATMENT_REFLECT));
618	631

628	641	iter_dest_reflect++;
629	642	}
630	643	}
631
	644
632	645	void stdConvolutionTestFromRepeatWithAvoid()
633	646	{
634	647	Image src_avoid(40, 1);
635	648	src_avoid.init(2.47);
636	649	Image src_repeat(36, 1);
637
	650
638	651	Image dest_repeat(src_repeat);
639	652	Image dest_avoid(src_avoid);
640	653

679	692	}
680	693	}
681	694	}
682
	695
683	696	/**
684		* Es wird die Positionierung der einzelnen
	697	* Es wird die Positionierung der einzelnen
685	698	* Punkte relativ zueinander getestet.
686	699	*/
687	700	void stdConvolutionTestOfAllTreatmentsRelatively(){

743	756	{
744	757	vigra::Kernel1D<double> binom;
745	758	binom.initBinomial(2);
746
	759
747	760	vigra::Kernel1D<double>::Iterator center = binom.center();
748
	761
749	762	should(center[0] == 0.375);
750	763	should(center[-1] == 0.25);
751	764	should(center[1] == 0.25);
752	765	should(center[-2] == 0.0625);
753	766	should(center[2] == 0.0625);
754
	767
755	768	binom.initBinomial(1);
756
	769
757	770	center = binom.center();
758
	771
759	772	should(center[0] == 0.5);
760	773	should(center[-1] == 0.25);
761	774	should(center[1] == 0.25);
762
	775
763	776	Image tmp1(constimg);
764	777	Image tmp2(constimg);
765	778	tmp2 = 0.0;
766
	779
767	780	separableConvolveX(srcImageRange(constimg), destImage(tmp1), kernel1d(binom));
768	781	separableConvolveY(srcImageRange(tmp1), destImage(tmp2), kernel1d(binom));
769
	782
770	783	Image::ScanOrderIterator i1 = constimg.begin();
771	784	Image::ScanOrderIterator i1end = constimg.end();
772	785	Image::ScanOrderIterator i2 = tmp2.begin();
773	786	Image::Accessor acc = constimg.accessor();
774
	787
775	788	for(; i1 != i1end; ++i1, ++i2)
776	789	{
777	790	should(acc(i1) == acc(i2));
778	791	}
779	792	}
780
	793
781	794	void separableDerivativeRepeatTest()
782	795	{
783	796	vigra::Kernel1D<double> grad;
784	797	grad.initSymmetricGradient();
785
	798
786	799	Image tmp1(rampimg);
787	800	tmp1 = 0.0;
788	801	Image tmp2(constimg);
789
	802
790	803	separableConvolveX(srcImageRange(rampimg), destImage(tmp1), kernel1d(grad));
791	804	separableConvolveX(srcImageRange(constimg), destImage(tmp2), kernel1d(grad));
792
	805
793	806	Image::ScanOrderIterator i1 = tmp1.begin();
794	807	Image::ScanOrderIterator i2 = tmp2.begin();
795	808	Image::Accessor acc = tmp1.accessor();
796
	809
797	810	should(acc(i1) == 0.5);
798	811	should(acc(i2) == 0.0);
799	812	++i1;

813	826	should(acc(i1) == 0.5);
814	827	should(acc(i2) == 0.0);
815	828	}
816
	829
817	830	void separableDerivativeReflectTest()
818	831	{
819	832	vigra::Kernel1D<double> grad;
820	833	grad.initSymmetricGradient();
821	834	grad.setBorderTreatment(vigra::BORDER_TREATMENT_REFLECT);
822
	835
823	836	Image tmp1(rampimg);
824	837	tmp1 = 1000.0;
825
	838
826	839	separableConvolveX(srcImageRange(rampimg), destImage(tmp1), kernel1d(grad));
827
	840
828	841	Image::ScanOrderIterator i1 = tmp1.begin();
829	842	Image::Accessor acc = tmp1.accessor();
830
	843
831	844	should(acc(i1) == 0.0);
832	845	++i1;
833	846	should(acc(i1) == 1.0);

838	851	++i1;
839	852	should(acc(i1) == 0.0);
840	853	}
841
	854
842	855	void separableDerivativeAvoidTest()
843	856	{
844	857	vigra::Kernel1D<double> grad;
845	858	grad.initSymmetricGradient();
846	859	grad.setBorderTreatment(vigra::BORDER_TREATMENT_AVOID);
847
	860
848	861	Image tmp1(rampimg);
849	862	tmp1 = 1000.0;
850
	863
851	864	separableConvolveX(srcImageRange(rampimg), destImage(tmp1), kernel1d(grad));
852
	865
853	866	Image::ScanOrderIterator i1 = tmp1.begin();
854	867	Image::Accessor acc = tmp1.accessor();
855
	868
856	869	should(acc(i1) == 1000.0);
857	870	++i1;
858	871	should(acc(i1) == 1.0);

863	876	++i1;
864	877	should(acc(i1) == 1000.0);
865	878	}
866
	879
867	880	void separableSmoothClipTest()
868	881	{
869	882	vigra::Kernel1D<double> binom;
870	883	binom.initBinomial(1);
871	884	binom.setBorderTreatment(vigra::BORDER_TREATMENT_CLIP);
872
	885
873	886	Image tmp1(rampimg);
874	887	tmp1 = 1000.0;
875
	888
876	889	separableConvolveX(srcImageRange(rampimg), destImage(tmp1), kernel1d(binom));
877
	890
878	891	Image::ScanOrderIterator i1 = tmp1.begin();
879	892	Image::Accessor acc = tmp1.accessor();
880
	893
881	894	should(acc(i1) == 1.0/3.0);
882	895	++i1;
883	896	should(acc(i1) == 1.0);

888	901	++i1;
889	902	should(acc(i1) == 11.0/3.0);
890	903	}
891
	904
892	905	void separableSmoothZeropadTest()
893	906	{
894	907	vigra::Kernel1D<double> binom;

897	910
898	911	Image tmp1(rampimg);
899	912	tmp1 = 1000.0;
900
	913
901	914	separableConvolveX(srcImageRange(rampimg), destImage(tmp1), kernel1d(binom));
902
	915
903	916	Image::ScanOrderIterator i1 = tmp1.begin();
904	917	Image::Accessor acc = tmp1.accessor();
905	918

913	926	++i1;
914	927	shouldEqual(acc(i1), 2.75);
915	928	}
916
	929
917	930	void separableSmoothWrapTest()
918	931	{
919	932	vigra::Kernel1D<double> binom;
920	933	binom.initBinomial(1);
921	934	binom.setBorderTreatment(vigra::BORDER_TREATMENT_WRAP);
922
	935
923	936	Image tmp1(rampimg);
924	937	tmp1 = 1000.0;
925
	938
926	939	separableConvolveX(srcImageRange(rampimg), destImage(tmp1), kernel1d(binom));
927
	940
928	941	Image::ScanOrderIterator i1 = tmp1.begin();
929	942	Image::Accessor acc = tmp1.accessor();
930
	943
931	944	should(acc(i1) == 1.25);
932	945	++i1;
933	946	should(acc(i1) == 1.0);

938	951	++i1;
939	952	should(acc(i1) == 2.75);
940	953	}
941
	954
942	955	void gaussianSmoothingTest()
943	956	{
944	957	double scale = 1.0;

950	963
951	964	separableConvolveX(srcImageRange(lenna), destImage(tmp1), kernel1d(gauss));
952	965	separableConvolveY(srcImageRange(tmp1), destImage(tmp2), kernel1d(gauss));
953
	966
954	967	gaussianSmoothing(srcImageRange(lenna), destImage(tmp1), scale);
955
	968
956	969	Image::ScanOrderIterator i1 = tmp1.begin();
957	970	Image::ScanOrderIterator i1end = tmp1.end();
958	971	Image::ScanOrderIterator i2 = tmp2.begin();
959	972	Image::Accessor acc = constimg.accessor();
960
	973
961	974	for(; i1 != i1end; ++i1, ++i2)
962	975	{
963	976	should(acc(i1) == acc(i2));

978	991	i1 = tmp1.begin();
979	992	i1end = tmp1.end();
980	993	i2 = recursive.begin();
981
	994
982	995	double sum = 0.0;
983	996	for(; i1 != i1end; ++i1, ++i2)
984	997	{

992	1005	recursiveGaussianFilterY(View(tmp1), View(tmp2), scale);
993	1006	should(View(recursive) == View(tmp2));
994	1007	}
995
	1008
996	1009	void optimalSmoothing3Test()
997	1010	{
998	1011	vigra::Kernel1D<double> smooth3;

1003	1016
1004	1017	separableConvolveX(srcImageRange(lenna), destImage(tmp1), kernel1d(smooth3));
1005	1018	separableConvolveY(srcImageRange(tmp1), destImage(tmp2), kernel1d(smooth3));
1006
	1019
1007	1020	gaussianSmoothing(srcImageRange(lenna), destImage(tmp1), 0.68);
1008
	1021
1009	1022	Image::ScanOrderIterator i1 = tmp1.begin();
1010	1023	Image::ScanOrderIterator i1end = tmp1.end();
1011	1024	Image::ScanOrderIterator i2 = tmp2.begin();
1012	1025	Image::Accessor acc = constimg.accessor();
1013
	1026
1014	1027	for(; i1 != i1end; ++i1, ++i2)
1015	1028	{
1016	1029	shouldEqualTolerance(acc(i1), acc(i2), 1e-2);
1017	1030	}
1018	1031	}
1019
	1032
1020	1033	void optimalSmoothing5Test()
1021	1034	{
1022	1035	vigra::Kernel1D<double> smooth5;

1027	1040
1028	1041	separableConvolveX(srcImageRange(lenna), destImage(tmp1), kernel1d(smooth5));
1029	1042	separableConvolveY(srcImageRange(tmp1), destImage(tmp2), kernel1d(smooth5));
1030
	1043
1031	1044	gaussianSmoothing(srcImageRange(lenna), destImage(tmp1), 0.867);
1032
	1045
1033	1046	Image::ScanOrderIterator i1 = tmp1.begin();
1034	1047	Image::ScanOrderIterator i1end = tmp1.end();
1035	1048	Image::ScanOrderIterator i2 = tmp2.begin();
1036	1049	Image::Accessor acc = constimg.accessor();
1037
	1050
1038	1051	for(; i1 != i1end; ++i1, ++i2)
1039	1052	{
1040	1053	shouldEqualTolerance(acc(i1), acc(i2), 1e-2);
1041	1054	}
1042	1055	}
1043
	1056
1044	1057	void separableGradientTest()
1045	1058	{
1046	1059	Image sepgrad(lenna.size());
1047	1060	importImage(vigra::ImageImportInfo("lenna128sepgrad.xv"), destImage(sepgrad));
1048
	1061
1049	1062	vigra::Kernel1D<double> gauss;
1050	1063	gauss.initGaussian(1.0);
1051	1064	vigra::Kernel1D<double> grad;

1059	1072
1060	1073	separableConvolveX(srcImageRange(lenna), destImage(tmp3), kernel1d(grad));
1061	1074	separableConvolveY(srcImageRange(tmp3), destImage(tmp1), kernel1d(gauss));
1062
	1075
1063	1076	separableConvolveX(srcImageRange(lenna), destImage(tmp3), kernel1d(gauss));
1064	1077	separableConvolveY(srcImageRange(tmp3), destImage(tmp2), kernel1d(grad));
1065
	1078
1066	1079	Image::ScanOrderIterator i1 = tmp1.begin();
1067	1080	Image::ScanOrderIterator i1end = tmp1.end();
1068	1081	Image::ScanOrderIterator i2 = tmp2.begin();
1069	1082	Image::ScanOrderIterator i = sepgrad.begin();
1070	1083	Image::Accessor acc = constimg.accessor();
1071
	1084
1072	1085	for(; i1 != i1end; ++i1, ++i2, ++i)
1073	1086	{
1074	1087	double grad = VIGRA_CSTD::sqrt(acc(i1)acc(i1)+acc(i2)acc(i2));

1086	1099
1087	1100	combineTwoImages(srcImageRange(nsgrad), srcImage(tmp1), destImage(nsgrad), Arg1() - Arg2());
1088	1101	Image zero(lenna.size(), 0.0);
1089		shouldEqualSequenceTolerance(nsgrad.data(), nsgrad.data()+nsgrad.width()*nsgrad.height(),
	1102	shouldEqualSequenceTolerance(nsgrad.data(), nsgrad.data()+nsgrad.width()*nsgrad.height(),
1090	1103	zero.data(), 1e-12);
1091	1104	}
1092
	1105
1093	1106	void gradientTest()
1094	1107	{
1095	1108	Image sepgrad(lenna.size());
1096	1109	importImage(vigra::ImageImportInfo("lenna128sepgrad.xv"), destImage(sepgrad));
1097
1098
	1110
	1111
1099	1112	Image tmpx(lenna.size());
1100	1113	Image tmpy(lenna.size());
1101	1114	Image mag(lenna.size());

1109	1122	Image::ScanOrderIterator ig = mag.begin();
1110	1123	Image::ScanOrderIterator i = sepgrad.begin();
1111	1124	Image::Accessor acc = constimg.accessor();
1112
	1125
1113	1126	for(; i1 != i1end; ++i1, ++i2, ++ig, ++i)
1114	1127	{
1115	1128	double grad = VIGRA_CSTD::sqrt(acc(i1)acc(i1)+acc(i2)acc(i2));

1117	1130	shouldEqualTolerance(acc(ig)-acc(i), 0.0, 1e-12);
1118	1131	}
1119	1132	}
1120
	1133
1121	1134	void optimalGradient3Test()
1122	1135	{
1123	1136	Image tmp(lenna.size());

1131	1144
1132	1145	separableConvolveX(srcImageRange(lenna), destImage(tmp), kernel1d(diff));
1133	1146	separableConvolveY(srcImageRange(tmp), destImage(tmpx), kernel1d(smooth3));
1134
	1147
1135	1148	separableConvolveX(srcImageRange(lenna), destImage(tmp), kernel1d(smooth3));
1136	1149	separableConvolveY(srcImageRange(tmp), destImage(tmpy), kernel1d(diff));
1137	1150

1153	1166	shouldEqual(mi, 0.0);
1154	1167	should(std::fabs(ma - 68.0) < 1.0);
1155	1168	}
1156
	1169
1157	1170	void optimalLaplacian3Test()
1158	1171	{
1159	1172	Image tmp(lenna.size());

1164	1177	diff.initSecondDifference3();
1165	1178	vigra::Kernel1D<double> smooth3;
1166	1179	smooth3.initOptimalSecondDerivativeSmoothing3();
1167
	1180
1168	1181	separableConvolveX(srcImageRange(lenna), destImage(tmp), kernel1d(diff));
1169	1182	separableConvolveY(srcImageRange(tmp), destImage(tmpx), kernel1d(smooth3));
1170
	1183
1171	1184	separableConvolveX(srcImageRange(lenna), destImage(tmp), kernel1d(smooth3));
1172	1185	separableConvolveY(srcImageRange(tmp), destImage(tmpy), kernel1d(diff));
1173	1186

1189	1202	should(std::fabs(mi + 120.0) < 1.0);
1190	1203	should(std::fabs(ma - 117.0) < 1.0);
1191	1204	}
1192
	1205
1193	1206	void optimalGradient5Test()
1194	1207	{
1195	1208	Image tmp(lenna.size());

1201	1214	diff.initOptimalFirstDerivative5();
1202	1215	vigra::Kernel1D<double> smooth5;
1203	1216	smooth5.initOptimalFirstDerivativeSmoothing5();
1204
	1217
1205	1218	separableConvolveX(srcImageRange(lenna), destImage(tmp), kernel1d(diff));
1206	1219	separableConvolveY(srcImageRange(tmp), destImage(tmpx), kernel1d(smooth5));
1207
	1220
1208	1221	separableConvolveX(srcImageRange(lenna), destImage(tmp), kernel1d(smooth5));
1209	1222	separableConvolveY(srcImageRange(tmp), destImage(tmpy), kernel1d(diff));
1210	1223

1219	1232	}
1220	1233	}
1221	1234	}
1222
	1235
1223	1236	void optimalLaplacian5Test()
1224	1237	{
1225	1238	Image tmp(lenna.size());

1232	1245	diff.initOptimalSecondDerivative5();
1233	1246	vigra::Kernel1D<double> smooth5;
1234	1247	smooth5.initOptimalSecondDerivativeSmoothing5();
1235
	1248
1236	1249	separableConvolveX(srcImageRange(lenna), destImage(tmp), kernel1d(diff));
1237	1250	separableConvolveY(srcImageRange(tmp), destImage(tmpx), kernel1d(smooth5));
1238
	1251
1239	1252	separableConvolveX(View(lenna), View(tmp), smooth5);
1240	1253	separableConvolveY(View(tmp), View(tmpy), diff);
1241	1254

1252	1265	}
1253	1266	}
1254	1267	}
1255
	1268
1256	1269	void gradientRGBTest()
1257	1270	{
1258	1271	RGBImage input(lenna.size());
1259	1272	importImage(vigra::ImageImportInfo("lenna128rgb.xv"), destImage(input));
1260
	1273
1261	1274	Image sepgrad(lenna.size());
1262	1275	importImage(vigra::ImageImportInfo("lenna128rgbsepgrad.xv"), destImage(sepgrad));
1263
1264
	1276
	1277
1265	1278	RGBImage tmpx(lenna.size());
1266	1279	RGBImage tmpy(lenna.size());
1267	1280	Image mag(lenna.size());

1269	1282
1270	1283	gaussianGradient(srcImageRange(input), destImage(tmpx), destImage(tmpy), 1.0);
1271	1284	gaussianGradientMagnitude(srcImageRange(input), destImage(mag), 1.0);
1272
	1285
1273	1286	RGBImage::ScanOrderIterator i1 = tmpx.begin();
1274	1287	RGBImage::ScanOrderIterator i1end = tmpx.end();
1275	1288	RGBImage::ScanOrderIterator i2 = tmpy.begin();

1277	1290	Image::ScanOrderIterator i = sepgrad.begin();
1278	1291	RGBImage::Accessor rgb = tmpx.accessor();
1279	1292	Image::Accessor acc = constimg.accessor();
1280
	1293
1281	1294	for(; i1 != i1end; ++i1, ++i2, ++ig, ++i)
1282	1295	{
1283	1296	double grad = VIGRA_CSTD::sqrt(squaredNorm(rgb(i1))+squaredNorm(rgb(i2)));

1286	1299	}
1287	1300
1288	1301	}
1289
	1302
1290	1303	void hessianTest()
1291	1304	{
1292	1305	Image refxx(lenna.size());

1301	1314	Image resxy(lenna.size());
1302	1315	Image resyy(lenna.size());
1303	1316
1304		hessianMatrixOfGaussian(srcImageRange(lenna),
	1317	hessianMatrixOfGaussian(srcImageRange(lenna),
1305	1318	destImage(resxx), destImage(resxy), destImage(resyy), 1.0);
1306
	1319
1307	1320	Image::ScanOrderIterator i1 = resxx.begin();
1308	1321	Image::ScanOrderIterator i1end = resxx.end();
1309	1322	Image::ScanOrderIterator i2 = resyy.begin();

1312	1325	Image::ScanOrderIterator r2 = refyy.begin();
1313	1326	Image::ScanOrderIterator r3 = refxy.begin();
1314	1327	Image::Accessor acc = constimg.accessor();
1315
1316
	1328
	1329
1317	1330	for(; i1 != i1end; ++i1, ++i2, ++i3, ++r1, ++r2, ++r3)
1318	1331	{
1319	1332	shouldEqualTolerance(acc(i1)-acc(r1), 0.0, 1e-12);

1326	1339	Image resxy(lenna.size());
1327	1340	Image resyy(lenna.size());
1328	1341
1329		hessianMatrixOfGaussian(View(lenna),
	1342	hessianMatrixOfGaussian(View(lenna),
1330	1343	View(resxx), View(resxy), View(resyy), 1.0);
1331
	1344
1332	1345	Image::ScanOrderIterator i1 = resxx.begin();
1333	1346	Image::ScanOrderIterator i1end = resxx.end();
1334	1347	Image::ScanOrderIterator i2 = resyy.begin();

1337	1350	Image::ScanOrderIterator r2 = refyy.begin();
1338	1351	Image::ScanOrderIterator r3 = refxy.begin();
1339	1352	Image::Accessor acc = constimg.accessor();
1340
1341
	1353
	1354
1342	1355	for(; i1 != i1end; ++i1, ++i2, ++i3, ++r1, ++r2, ++r3)
1343	1356	{
1344	1357	shouldEqualTolerance(acc(i1)-acc(r1), 0.0, 1e-12);

1347	1360	}
1348	1361	}
1349	1362	}
1350
	1363
1351	1364	void structureTensorTest()
1352	1365	{
1353	1366	Image resxx(lenna.size());

1356	1369	Image refxx(lenna.size());
1357	1370	Image refxy(lenna.size());
1358	1371	Image refyy(lenna.size());
1359
	1372
1360	1373	typedef BasicImage<TinyVector<double, 3> > VectorImage;
1361	1374	VectorImage resst(lenna.size());
1362	1375
1363		structureTensor(View(lenna),
	1376	structureTensor(View(lenna),
1364	1377	View(resxx), View(resxy), View(resyy), 1.0, 2.0);
1365	1378
1366	1379	structureTensor(View(lenna), MultiArrayView<2, TinyVector<double, 3> >(resst), 1.0, 2.0);
1367
	1380
1368	1381	importImage(vigra::ImageImportInfo("lennastxx.xv"), destImage(refxx));
1369	1382	importImage(vigra::ImageImportInfo("lennastyy.xv"), destImage(refyy));
1370	1383	importImage(vigra::ImageImportInfo("lennastxy.xv"), destImage(refxy));
1371
	1384
1372	1385	Image::ScanOrderIterator i1 = resxx.begin();
1373	1386	Image::ScanOrderIterator i1end = resxx.end();
1374	1387	Image::ScanOrderIterator i2 = resxy.begin();

1390	1403	shouldEqualTolerance(vacc(i4)[2], acc(r3), 1e-7);
1391	1404	}
1392	1405	}
1393
	1406
1394	1407	void structureTensorRGBTest()
1395	1408	{
1396	1409	RGBImage input(lenna.size());

1400	1413	VectorImage resst(lenna.size()), refst(lenna.size());
1401	1414
1402	1415	structureTensor(srcImageRange(lenna), destImage(resst), 1.0, 2.0);
1403
	1416
1404	1417	importImage(vigra::ImageImportInfo("lennargbst.xv"), destImage(refst));
1405
	1418
1406	1419	VectorImage::ScanOrderIterator i1 = resst.begin();
1407	1420	VectorImage::ScanOrderIterator i1end = resst.end();
1408	1421	VectorImage::ScanOrderIterator r1 = refst.begin();

1415	1428	shouldEqualTolerance(vacc(i1)[2], vacc(r1)[2], 1e-7);
1416	1429	}
1417	1430	}
1418
	1431
1419	1432	void stdConvolutionTest()
1420	1433	{
1421	1434	vigra::Kernel1D<double> binom1;
1422	1435	binom1.initBinomial(1);
1423
	1436
1424	1437	vigra::Kernel2D<double> binom2;
1425	1438	binom2.initSeparable(binom1, binom1);
1426
	1439
1427	1440	Image tmp1(constimg);
1428	1441	tmp1 = 0.0;
1429	1442
1430	1443	convolveImage(srcImageRange(constimg), destImage(tmp1), kernel2d(binom2));
1431
	1444
1432	1445	Image::ScanOrderIterator i1 = constimg.begin();
1433	1446	Image::ScanOrderIterator i1end = constimg.end();
1434	1447	Image::ScanOrderIterator i2 = tmp1.begin();
1435	1448	Image::Accessor acc = constimg.accessor();
1436
	1449
1437	1450	for(; i1 != i1end; ++i1, ++i2)
1438	1451	{
1439	1452	should(acc(i1) == acc(i2));
1440	1453	}
1441	1454	}
1442
	1455
1443	1456	void stdVersusSeparableConvolutionTest()
1444	1457	{
1445
	1458
1446	1459	vigra::Kernel1D<double> gauss1;
1447	1460	gauss1.initGaussian(2.0);
1448
	1461
1449	1462	vigra::Kernel2D<double> gauss2;
1450	1463	gauss2.initSeparable(gauss1, gauss1);
1451
	1464
1452	1465	Image tmp1(lenna);
1453	1466	tmp1 = 0.0;
1454	1467
1455	1468	convolveImage(srcImageRange(lenna), destImage(tmp1), kernel2d(gauss2));
1456
	1469
1457	1470	Image tmp2(lenna);
1458	1471	Image tmp3(lenna);
1459	1472	tmp3 = 0.0;
1460
	1473
1461	1474	separableConvolveX(srcImageRange(lenna), destImage(tmp2), kernel1d(gauss1));
1462	1475	separableConvolveY(srcImageRange(tmp2), destImage(tmp3), kernel1d(gauss1));
1463
	1476
1464	1477	Image::Iterator y1 = tmp1.upperLeft() - gauss2.upperLeft();
1465	1478	Image::Iterator end = tmp1.lowerRight() - gauss2.lowerRight();
1466	1479	Image::Iterator y2 = tmp3.upperLeft() - gauss2.upperLeft();
1467	1480	Image::Accessor acc = tmp1.accessor();
1468
	1481
1469	1482	for(; y1.y != end.y; ++y1.y, ++y2.y)
1470	1483	{
1471	1484	Image::Iterator x1 = y1;

1476	1489	}
1477	1490	}
1478	1491	}
1479
	1492
1480	1493	void recursiveFilterTestWithAvoid()
1481	1494	{
1482	1495	Image src_const(25, 25);

1510	1523	id.x = tmp_dest.x;
1511	1524	}
1512	1525
1513		recursiveFilterY(srcImageRange(src_const), destImage(dest),
	1526	recursiveFilterY(srcImageRange(src_const), destImage(dest),
1514	1527	VIGRA_CSTD::exp(-1.0), BORDER_TREATMENT_AVOID);
1515	1528
1516	1529	is = src_const.upperLeft();

1537	1550	id.x = tmp_dest.x;
1538	1551	}
1539	1552
1540		// Hier wird an einem symmetrischen Bild /\ getestet
	1553	// Hier wird an einem symmetrischen Bild /\ getestet
1541	1554	// ob die korrekten Daten eingehalten wurden.
1542	1555
1543	1556	Image src(getSymmetricLine()), srct(getSymmetricLine(true));
1544	1557	dest = src;
1545	1558	Image destt(srct);
1546	1559
1547		Image::value_type correct_data[40] =
1548		{0.25, 1.25, 2.25, 3.25, 4.25, 5.25, 6.25, 7.25, 8.25, 9.25,
1549		10.25, 11.249812, 12.249472, 13.248558, 14.246079, 15.239341,
1550		16.221025, 17.171238, 18.035903, 18.668023,
1551		18.668023, 18.035903, 17.171238, 16.221025, 15.239341,
1552		14.246079, 13.248558, 12.249472, 11.249812, 10.25, 9.25,
	1560	Image::value_type correct_data[40] =
	1561	{0.25, 1.25, 2.25, 3.25, 4.25, 5.25, 6.25, 7.25, 8.25, 9.25,
	1562	10.25, 11.249812, 12.249472, 13.248558, 14.246079, 15.239341,
	1563	16.221025, 17.171238, 18.035903, 18.668023,
	1564	18.668023, 18.035903, 17.171238, 16.221025, 15.239341,
	1565	14.246079, 13.248558, 12.249472, 11.249812, 10.25, 9.25,
1553	1566	8.25, 7.25, 6.25, 5.25, 4.25, 3.25, 2.25, 1.25, 0.25};
1554	1567
1555		recursiveFilterX(View(src), View(dest),
	1568	recursiveFilterX(View(src), View(dest),
1556	1569	VIGRA_CSTD::exp(-1.0), BORDER_TREATMENT_AVOID);
1557		recursiveFilterY(View(srct), View(destt),
	1570	recursiveFilterY(View(srct), View(destt),
1558	1571	VIGRA_CSTD::exp(-1.0), BORDER_TREATMENT_AVOID);
1559	1572	Image::iterator dest_iter = dest.begin();
1560	1573	Image::iterator destt_iter = destt.begin();

1574	1587	src_const.init(42.1);
1575	1588	dest.init(1.12);
1576	1589
1577		recursiveFilterX(srcImageRange(src_const), destImage(dest),
	1590	recursiveFilterX(srcImageRange(src_const), destImage(dest),
1578	1591	VIGRA_CSTD::exp(-1.0), BORDER_TREATMENT_REFLECT);
1579	1592
1580	1593	Image::Iterator is = src_const.upperLeft();

1594	1607	id.x = tmp_dest.x;
1595	1608	}
1596	1609
1597		recursiveFilterY(srcImageRange(dest), destImage(dest),
	1610	recursiveFilterY(srcImageRange(dest), destImage(dest),
1598	1611	VIGRA_CSTD::exp(-1.0), BORDER_TREATMENT_REFLECT);
1599	1612
1600	1613	is = src_const.upperLeft();

1614	1627	id.x = tmp_dest.x;
1615	1628	}
1616	1629
1617		// Hier wird an einem symmetrischen Bild /\ (Groesse 40x1) getestet
	1630	// Hier wird an einem symmetrischen Bild /\ (Groesse 40x1) getestet
1618	1631	// ob die korrekten Daten eingehalten wurden.
1619	1632
1620	1633	Image src(getSymmetricLine());
1621	1634	dest = src;
1622		recursiveFilterX(srcImageRange(src), destImage(dest),
	1635	recursiveFilterX(srcImageRange(src), destImage(dest),
1623	1636	VIGRA_CSTD::exp(-1.0), BORDER_TREATMENT_REFLECT);
1624		Image::value_type correct_data[40] =
1625		{1.10091101909, 1.56303266253, 2.36515826013, 3.29236429975, 4.26558480098,
1626		5.25573290944, 6.25210788209, 7.25077235463, 8.25027572885, 9.25007858906,
1627		10.2499668097, 11.2498189802, 12.2494745341, 13.2485593473, 14.2460793794,
1628		15.2393409851, 16.2210251818, 17.171238053, 18.0359027479, 18.6680232997,
1629		18.6680232997, 18.0359027479, 17.171238053, 16.2210251818, 15.2393409851,
1630		14.2460793794, 13.2485593473, 12.2494745342, 11.2498189803, 10.24996681,
1631		9.25007858994, 8.25027573123, 7.2507723611, 6.2521078997, 5.2557329573,
	1637	Image::value_type correct_data[40] =
	1638	{1.10091101909, 1.56303266253, 2.36515826013, 3.29236429975, 4.26558480098,
	1639	5.25573290944, 6.25210788209, 7.25077235463, 8.25027572885, 9.25007858906,
	1640	10.2499668097, 11.2498189802, 12.2494745341, 13.2485593473, 14.2460793794,
	1641	15.2393409851, 16.2210251818, 17.171238053, 18.0359027479, 18.6680232997,
	1642	18.6680232997, 18.0359027479, 17.171238053, 16.2210251818, 15.2393409851,
	1643	14.2460793794, 13.2485593473, 12.2494745342, 11.2498189803, 10.24996681,
	1644	9.25007858994, 8.25027573123, 7.2507723611, 6.2521078997, 5.2557329573,
1632	1645	4.26558493107, 3.29236465337, 2.36515922136, 1.56303527544, 1.10091812172};
1633	1646
1634	1647	Image::iterator dest_iter = dest.begin();

1645	1658	Image dest(src_const);
1646	1659	src_const.init(42.1);
1647	1660	dest.init(1.12);
1648		recursiveFilterX(srcImageRange(src_const), destImage(dest),
	1661	recursiveFilterX(srcImageRange(src_const), destImage(dest),
1649	1662	VIGRA_CSTD::exp(-1.0), BORDER_TREATMENT_CLIP);
1650	1663
1651	1664	Image::Iterator is = src_const.upperLeft();

1665	1678	id.x = tmp_dest.x;
1666	1679	}
1667	1680
1668		recursiveFilterY(srcImageRange(src_const), destImage(dest),
	1681	recursiveFilterY(srcImageRange(src_const), destImage(dest),
1669	1682	VIGRA_CSTD::exp(-1.0), BORDER_TREATMENT_CLIP);
1670	1683
1671	1684	is = src_const.upperLeft();

1689	1702	void recursiveFilterTestWithClipOnNonConstImage(){
1690	1703	Image src(40, 1);
1691	1704	Image dest(src);
1692		Image::value_type correct_data[40] =
1693		{0.831977, 1.53351, 2.3853, 3.31218, 4.27763, 5.26195,
1694		6.25506, 7.25211, 8.25086, 9.25035, 10.2501, 11.2501,
1695		12.25, 13.25, 14.25, 15.25, 16.25, 17.25, 18.25, 19.25,
1696		20.25, 21.25, 22.25, 23.25, 24.25, 25.25, 26.25, 27.25,
1697		28.2499, 29.2499, 30.2496, 31.2491, 32.2479, 33.2449,
	1705	Image::value_type correct_data[40] =
	1706	{0.831977, 1.53351, 2.3853, 3.31218, 4.27763, 5.26195,
	1707	6.25506, 7.25211, 8.25086, 9.25035, 10.2501, 11.2501,
	1708	12.25, 13.25, 14.25, 15.25, 16.25, 17.25, 18.25, 19.25,
	1709	20.25, 21.25, 22.25, 23.25, 24.25, 25.25, 26.25, 27.25,
	1710	28.2499, 29.2499, 30.2496, 31.2491, 32.2479, 33.2449,
1698	1711	34.2381, 35.2224, 36.1878, 37.1147, 37.9665, 38.668};
1699	1712
1700	1713	Image::Accessor acc_src = src.accessor();

1705	1718	acc_src.set(i + 0.25, iter_src);
1706	1719	}
1707	1720
1708		recursiveFilterX(srcImageRange(src), destImage(dest),
	1721	recursiveFilterX(srcImageRange(src), destImage(dest),
1709	1722	VIGRA_CSTD::exp(-1.0), BORDER_TREATMENT_CLIP);
1710	1723
1711	1724	Image::iterator idest = dest.begin();

1726	1739	src_const.init(42.1);
1727	1740	dest.init(1.12);
1728	1741
1729		recursiveFilterX(srcImageRange(src_const), destImage(dest),
	1742	recursiveFilterX(srcImageRange(src_const), destImage(dest),
1730	1743	VIGRA_CSTD::exp(-1.0), BORDER_TREATMENT_WRAP);
1731	1744
1732	1745	Image::Iterator is = src_const.upperLeft();

1746	1759	id.x = tmp_dest.x;
1747	1760	}
1748	1761
1749		recursiveFilterY(srcImageRange(src_const), destImage(dest),
	1762	recursiveFilterY(srcImageRange(src_const), destImage(dest),
1750	1763	VIGRA_CSTD::exp(-1.0), BORDER_TREATMENT_WRAP);
1751	1764
1752	1765	is = src_const.upperLeft();

1767	1780	}
1768	1781
1769	1782
1770		// Hier wird an einem symmetrischen Bild /\ (Groesse 40x1) getestet
	1783	// Hier wird an einem symmetrischen Bild /\ (Groesse 40x1) getestet
1771	1784	// ob die korrekten Daten eingehalten wurden.
1772	1785
1773	1786	Image src(getSymmetricLine());
1774	1787	dest = src;
1775		recursiveFilterX(srcImageRange(src), destImage(dest),
	1788	recursiveFilterX(srcImageRange(src), destImage(dest),
1776	1789	VIGRA_CSTD::exp(-1.0), BORDER_TREATMENT_WRAP);
1777		Image::value_type correct_data[40] =
	1790	Image::value_type correct_data[40] =
1778	1791	{0.8319696, 1.4640946, 2.328761, 3.2789745, 4.260659,
1779	1792	5.2539208, 6.2514412, 7.2505271, 8.2501855, 9.2500454,
1780	1793	10.249955, 11.249814, 12.249473, 13.248559, 14.246079,

1800	1813	src_const.init(42.1);
1801	1814	dest.init(1.12);
1802	1815
1803		recursiveFilterX(srcImageRange(src_const), destImage(dest),
	1816	recursiveFilterX(srcImageRange(src_const), destImage(dest),
1804	1817	VIGRA_CSTD::exp(-1.0), BORDER_TREATMENT_REPEAT);
1805	1818
1806	1819	Image::Iterator is = src_const.upperLeft();

1819	1832	is.x = tmp_src.x;
1820	1833	id.x = tmp_dest.x;
1821	1834	}
1822		recursiveFilterY(srcImageRange(src_const), destImage(dest),
	1835	recursiveFilterY(srcImageRange(src_const), destImage(dest),
1823	1836	VIGRA_CSTD::exp(-1.0), BORDER_TREATMENT_REPEAT);
1824	1837
1825	1838	is = src_const.upperLeft();

1839	1852	id.x = tmp_dest.x;
1840	1853	}
1841	1854
1842		// Hier wird an einem symmetrischen Bild /\ (Groesse 40x1) getestet
	1855	// Hier wird an einem symmetrischen Bild /\ (Groesse 40x1) getestet
1843	1856	// ob die korrekten Daten eingehalten wurden.
1844	1857
1845	1858	Image src(getSymmetricLine());
1846	1859	dest = src;
1847		recursiveFilterX(srcImageRange(src), destImage(dest),
	1860	recursiveFilterX(srcImageRange(src), destImage(dest),
1848	1861	VIGRA_CSTD::exp(-1.0), BORDER_TREATMENT_REPEAT);
1849		Image::value_type correct_data[40] =
1850		{0.67545906, 1.4065176, 2.3075796, 3.2711823, 4.2577924,
1851		5.2528662, 6.2510533, 7.2503844, 8.250133, 9.2500261,
1852		10.249947, 11.249812, 12.249472, 13.248558, 14.246079,
1853		15.239341, 16.221025, 17.171238, 18.035903, 18.668023,
1854		18.668023, 18.035903, 17.171238, 16.221025, 15.239341,
1855		14.246079, 13.248558, 12.249472, 11.249812, 10.249947,
1856		9.2500261, 8.250133, 7.2503844, 6.2510533, 5.2528662,
	1862	Image::value_type correct_data[40] =
	1863	{0.67545906, 1.4065176, 2.3075796, 3.2711823, 4.2577924,
	1864	5.2528662, 6.2510533, 7.2503844, 8.250133, 9.2500261,
	1865	10.249947, 11.249812, 12.249472, 13.248558, 14.246079,
	1866	15.239341, 16.221025, 17.171238, 18.035903, 18.668023,
	1867	18.668023, 18.035903, 17.171238, 16.221025, 15.239341,
	1868	14.246079, 13.248558, 12.249472, 11.249812, 10.249947,
	1869	9.2500261, 8.250133, 7.2503844, 6.2510533, 5.2528662,
1857	1870	4.2577924, 3.2711823, 2.3075796, 1.4065176, 0.67545906};
1858	1871
1859	1872	Image::iterator dest_iter = dest.begin();

1888	1901	acc_src_wrap.set( j + 0.25, iter_src_wrap);
1889	1902	}
1890	1903
1891		recursiveFilterX(srcImageRange(src_wrap), destImage(dest_wrap),
	1904	recursiveFilterX(srcImageRange(src_wrap), destImage(dest_wrap),
1892	1905	VIGRA_CSTD::exp(-1.0), BORDER_TREATMENT_WRAP);
1893	1906
1894		recursiveFilterX(srcImageRange(src_reflect), destImage(dest_reflect),
	1907	recursiveFilterX(srcImageRange(src_reflect), destImage(dest_reflect),
1895	1908	VIGRA_CSTD::exp(-1.0), BORDER_TREATMENT_REFLECT);
1896	1909
1897	1910	Image::iterator iter_dest_wrap = dest_wrap.begin();

1902	1915
1903	1916	while(iter_dest_reflect != end_dest_reflect)
1904	1917	{
1905		shouldEqualTolerance(acc_dest_wrap(iter_dest_wrap),
	1918	shouldEqualTolerance(acc_dest_wrap(iter_dest_wrap),
1906	1919	acc_dest_reflect(iter_dest_reflect), 1e-6);
1907	1920	iter_dest_wrap++;
1908	1921	iter_dest_reflect++;

1969	1982	}
1970	1983
1971	1984	/**
1972		* Es wird die Positionierung der einzelnen
	1985	* Es wird die Positionierung der einzelnen
1973	1986	* Punkte relativ zueinander getestet.
1974	1987	*/
1975	1988	void recursiveFilterTestOfAllTreatmentsRelatively()

1996	2009	Image dest_wrap(src);
1997	2010	Image dest_clip(src);
1998	2011
1999		recursiveFilterX(srcImageRange(src), destImage(dest_avoid),
	2012	recursiveFilterX(srcImageRange(src), destImage(dest_avoid),
2000	2013	VIGRA_CSTD::exp(-1.0), BORDER_TREATMENT_AVOID);
2001		recursiveFilterX(srcImageRange(src), destImage(dest_repeat),
	2014	recursiveFilterX(srcImageRange(src), destImage(dest_repeat),
2002	2015	VIGRA_CSTD::exp(-1.0), BORDER_TREATMENT_REPEAT);
2003		recursiveFilterX(srcImageRange(src), destImage(dest_reflect),
	2016	recursiveFilterX(srcImageRange(src), destImage(dest_reflect),
2004	2017	VIGRA_CSTD::exp(-1.0), BORDER_TREATMENT_REFLECT);
2005		recursiveFilterX(srcImageRange(src), destImage(dest_wrap),
	2018	recursiveFilterX(srcImageRange(src), destImage(dest_wrap),
2006	2019	VIGRA_CSTD::exp(-1.0), BORDER_TREATMENT_WRAP);
2007		recursiveFilterX(srcImageRange(src), destImage(dest_clip),
	2020	recursiveFilterX(srcImageRange(src), destImage(dest_clip),
2008	2021	VIGRA_CSTD::exp(-1.0), BORDER_TREATMENT_CLIP);
2009
	2022
2010	2023	iter_src = src.begin();
2011	2024	Image::iterator iter_dest_avoid = dest_avoid.begin();
2012	2025	Image::iterator iter_dest_repeat = dest_repeat.begin();

2039	2052	}
2040	2053	}
2041	2054	}
2042
	2055
2043	2056	void recursiveSmoothTest()
2044	2057	{
2045	2058	Image tmp1(constimg);

2047	2060
2048	2061	recursiveSmoothX(View(constimg), View(tmp1), 1.0);
2049	2062	recursiveSmoothY(View(tmp1), View(tmp1), 1.0);
2050
	2063
2051	2064	Image::ScanOrderIterator i1 = constimg.begin();
2052	2065	Image::ScanOrderIterator i1end = constimg.end();
2053	2066	Image::ScanOrderIterator i2 = tmp1.begin();
2054	2067	Image::Accessor acc = constimg.accessor();
2055
	2068
2056	2069	for(; i1 != i1end; ++i1, ++i2)
2057	2070	{
2058	2071	should(acc(i1) == acc(i2));
2059	2072	}
2060	2073	}
2061
	2074
2062	2075	void recursiveGradientTest()
2063	2076	{
2064	2077	ImageImportInfo info("lenna128recgrad.xv");
2065	2078
2066	2079	Image recgrad(info.width(), info.height());
2067	2080	importImage(info, destImage(recgrad));
2068
	2081
2069	2082	Image tmp1(lenna);
2070	2083	tmp1 = 0.0;
2071	2084	Image tmp2(lenna);

2073	2086
2074	2087	recursiveFirstDerivativeX(View(lenna), View(tmp1), 1.0);
2075	2088	recursiveSmoothY(View(tmp1), View(tmp1), 1.0);
2076
	2089
2077	2090	recursiveSmoothX(View(lenna), View(tmp2), 1.0);
2078	2091	recursiveFirstDerivativeY(View(tmp2), View(tmp2), 1.0);
2079
	2092
2080	2093	Image::ScanOrderIterator i1 = tmp1.begin();
2081	2094	Image::ScanOrderIterator i1end = tmp1.end();
2082	2095	Image::ScanOrderIterator i2 = tmp2.begin();
2083	2096	Image::ScanOrderIterator i = recgrad.begin();
2084	2097	Image::Accessor acc = constimg.accessor();
2085
	2098
2086	2099	for(; i1 != i1end; ++i1, ++i2, ++i)
2087	2100	{
2088	2101	double grad = sqrt(acc(i1)acc(i1)+acc(i2)acc(i2));
2089
	2102
2090	2103	shouldEqualTolerance(grad, acc(i), 1e-7);
2091	2104	}
2092	2105	}
2093
	2106
2094	2107	void recursiveSecondDerivativeTest()
2095	2108	{
2096	2109	double b = VIGRA_CSTD::exp(-1.0);
2097	2110	double factor = (1.0 - b) * (1.0 - b) / b;
2098
	2111
2099	2112	Image tmp1(rampimg);
2100	2113	tmp1 = 0.0;
2101	2114	Image tmp2(rampimg);

2103	2116
2104	2117	recursiveSmoothX(View(rampimg), View(tmp1), 1.0);
2105	2118	recursiveSecondDerivativeX(View(rampimg), View(tmp2), 1.0);
2106
	2119
2107	2120	Image::ScanOrderIterator i1 = rampimg.begin();
2108	2121	Image::ScanOrderIterator i1end = i1 + rampimg.width();
2109	2122	Image::ScanOrderIterator i2 = tmp1.begin();
2110	2123	Image::ScanOrderIterator i3 = tmp2.begin();
2111	2124	Image::Accessor acc = constimg.accessor();
2112
	2125
2113	2126	for(; i1 != i1end; ++i1, ++i2, ++i3)
2114	2127	{
2115	2128	double diff = factor * (acc(i2) - acc(i1));
2116	2129	shouldEqualTolerance(diff, acc(i3), 1e-7);
2117	2130	}
2118	2131	}
2119
	2132
2120	2133	void nonlinearDiffusionTest()
2121	2134	{
2122
	2135
2123	2136	Image res(lenna.size());
2124
	2137
2125	2138	Image comp(lenna.size());
2126	2139	importImage(vigra::ImageImportInfo("lenna128nonlinear.xv"), destImage(comp));
2127	2140

2134	2147	vigra::DiffusivityFunctor<double>(4.0), 4.0);
2135	2148	shouldEqualSequenceTolerance(res.begin(), res.end(), comp.begin(), 1e-7);
2136	2149	}
2137
	2150
2138	2151	Image constimg, lenna, rampimg, sym_image, unsym_image;
2139	2152	vigra::Kernel2D<double> sym_kernel, unsym_kernel, line_kernel;
2140
	2153
2141	2154	};
2142	2155
2143	2156	struct ResamplingConvolutionTest

2149	2162	BSpline<3, double> spline, dspline(1);
2150	2163	ArrayVector<Kernel1D<double> > kernels(4);
2151	2164	Rational<int> samplingRatio(4), offset(1,8);
2152		resampling_detail::MapTargetToSourceCoordinate
	2165	resampling_detail::MapTargetToSourceCoordinate
2153	2166	mapCoordinate(samplingRatio, offset);
2154	2167	createResamplingKernels(spline, mapCoordinate, kernels);
2155
	2168
2156	2169	for(unsigned int i = 0; i<kernels.size(); ++i)
2157	2170	{
2158	2171	double sum = 0.0;

2166	2179	}
2167	2180
2168	2181	createResamplingKernels(dspline, mapCoordinate, kernels);
2169
	2182
2170	2183	for(unsigned int i = 0; i<kernels.size(); ++i)
2171	2184	{
2172	2185	double sum = 0.0;

2179	2192	shouldEqualTolerance(sum, 1.0, 1e-14);
2180	2193	}
2181	2194	}
2182
	2195
2183	2196	void testKernelsGauss()
2184	2197	{
2185	2198	Gaussian<double> gauss(0.7), dgauss(0.7, 1);
2186	2199	ArrayVector<Kernel1D<double> > kernels(4);
2187	2200	Rational<int> samplingRatio(4), offset(1,8);
2188		resampling_detail::MapTargetToSourceCoordinate
	2201	resampling_detail::MapTargetToSourceCoordinate
2189	2202	mapCoordinate(samplingRatio, offset);
2190	2203	createResamplingKernels(gauss, mapCoordinate, kernels);
2191
	2204
2192	2205	for(unsigned int i = 0; i<kernels.size(); ++i)
2193	2206	{
2194	2207	double sum = 0.0;

2202	2215	}
2203	2216
2204	2217	createResamplingKernels(dgauss, mapCoordinate, kernels);
2205
	2218
2206	2219	for(unsigned int i = 0; i<kernels.size(); ++i)
2207	2220	{
2208	2221	double sum = 0.0;

2216	2229	shouldEqualTolerance(sum, 1.0, 1e-14);
2217	2230	}
2218	2231	}
2219
	2232
2220	2233	void testOversamplingConstant()
2221	2234	{
2222	2235	BSpline<3, double> spline, dspline(1);
2223	2236	Rational<int> samplingRatio(4,1), offset(1,8);
2224
	2237
2225	2238	FImage img(100, 100);
2226	2239	img.init(1.0);
2227
	2240
2228	2241	int wnew = rational_cast<int>((img.width() - 1 - offset) * samplingRatio + 1);
2229	2242	int hnew = rational_cast<int>((img.height() - 1 - offset) * samplingRatio + 1);
2230
	2243
2231	2244	FImage res(wnew, hnew);
2232
	2245
2233	2246	resamplingConvolveImage(srcImageRange(img), destImageRange(res),
2234	2247	spline, samplingRatio, offset, spline, samplingRatio, offset);
2235	2248	for(FImage::iterator i = res.begin(); i < res.end(); ++i)
2236	2249	shouldEqual(*i, 1.0);
2237
	2250
2238	2251	resamplingConvolveImage(View(img), View(res),
2239	2252	dspline, samplingRatio, offset, spline, samplingRatio, offset);
2240	2253	for(FImage::iterator i = res.begin(); i < res.end(); ++i)

2245	2258	{
2246	2259	Gaussian<double> gauss(0.7);
2247	2260	Rational<int> samplingRatio(2,1), offset(1,4);
2248
	2261
2249	2262	ImageImportInfo info("lenna128.xv");
2250	2263	FImage img(info.size());
2251	2264	importImage(info, destImage(img));
2252
	2265
2253	2266	int wnew = rational_cast<int>((info.width() - 1 - offset) * samplingRatio + 1);
2254	2267	int hnew = rational_cast<int>((info.height() - 1 - offset) * samplingRatio + 1);
2255
2256		FImage res(wnew, hnew);
	2268
	2269	FImage res(wnew, hnew);
2257	2270	resamplingConvolveImage(View(img), View(res),
2258	2271	gauss, samplingRatio, offset, gauss, samplingRatio, offset);
2259
	2272
2260	2273	ImageImportInfo rinfo("resampling.xv");
2261	2274	shouldEqual(rinfo.width(), wnew);
2262	2275	shouldEqual(rinfo.height(), hnew);
2263		FImage ref(wnew, hnew);
	2276	FImage ref(wnew, hnew);
2264	2277	importImage(rinfo, destImage(ref));
2265	2278
2266	2279	for(FImage::iterator i = res.begin(), j = ref.begin(); i < res.end(); ++i, ++j)

2286	2299	void testPyramidConstruction()
2287	2300	{
2288	2301	vigra::ImagePyramid<Image> pyramid(-2, 2, img);
2289
	2302
2290	2303	shouldEqual(pyramid[-2].size(), Size2D(509, 477));
2291	2304	shouldEqual(pyramid[-1].size(), Size2D(255, 239));
2292	2305	shouldEqual(pyramid[0].size(), Size2D(128, 120));

2297	2310	void testBurtReduceExpand()
2298	2311	{
2299	2312	vigra::ImagePyramid<Image> pyramid(-2, 3, img), laplacian(-2,3, img);
2300
	2313
2301	2314	pyramidExpandBurtFilter(pyramid, 0, -2);
2302	2315	pyramidReduceBurtFilter(pyramid, 0, 3);
2303
	2316
2304	2317	pyramidReduceBurtLaplacian(laplacian, 0, 3);
2305	2318
2306	2319	char buf[100];

2313	2326	std::sprintf(buf, "lenna_level%d.xv", i);
2314	2327	ImageImportInfo info(buf);
2315	2328	shouldEqual(info.size(), pyramid[i].size());
2316
	2329
2317	2330	Image ref(info.size());
2318	2331	importImage(info, destImage(ref));
2319	2332	shouldEqualSequenceTolerance(ref.begin(), ref.end(), pyramid[i].begin(), 1e-12);
2320	2333	}
2321
	2334
2322	2335	for(int i=0; i<=2; ++i)
2323	2336	{
2324	2337	std::sprintf(buf, "lenna_levellap%d.xv", i);
2325	2338	ImageImportInfo info(buf);
2326	2339	shouldEqual(info.size(), laplacian[i].size());
2327
	2340
2328	2341	Image ref(info.size());
2329	2342	importImage(info, destImage(ref));
2330	2343	for(int k=0; k<info.width()*info.height(); ++k)
2331	2344	shouldEqualTolerance(ref.data()[k]-laplacian[i].data()[k], 0.0, 1e-12);
2332	2345	}
2333
	2346
2334	2347	shouldEqualSequenceTolerance(pyramid[3].begin(), pyramid[3].end(), laplacian[3].begin(), 1e-14);
2335
	2348
2336	2349	pyramidExpandBurtLaplacian(laplacian, 3, -2);
2337	2350
2338	2351	for(int i=3; i>=-2; --i)

2340	2353	shouldEqualSequenceTolerance(pyramid[i].begin(), pyramid[i].end(), laplacian[i].begin(), 1e-14);
2341	2354	}
2342	2355	}
2343
	2356
2344	2357	};
2345	2358
2346	2359	struct TotalVariationTest{
2347
	2360
2348	2361	const int width,height;
2349	2362	MultiArray<2,double> data;
2350	2363	MultiArray<2,double> out;

2357	2370	}
2358	2371	}
2359	2372	}
2360
	2373
2361	2374	void testTotalVariation(){
2362
	2375
2363	2376	totalVariationFilter(data,out,0.5,1000,0.01);
2364	2377	//exportImage(srcImageRange(out), vigra::ImageExportInfo("test_tv.pgm"));
2365		shouldEqualSequenceTolerance(out.begin(), out.end(), result_std_tv, 1e-12);
	2378	shouldEqualSequenceTolerance(out.begin(), out.end(), result_std_tv, 1e-12);
2366	2379	}
2367	2380	void testWeightedTotalVariation(){
2368
	2381
2369	2382	totalVariationFilter(data,weight,out,.5,1000,0.01);
2370	2383	//exportImage(srcImageRange(out), vigra::ImageExportInfo("test_tvw.pgm"));
2371		shouldEqualSequenceTolerance(out.begin(), out.end(), result_std_tv_weight, 1e-12);
	2384	shouldEqualSequenceTolerance(out.begin(), out.end(), result_std_tv_weight, 1e-12);
2372	2385	}
2373
	2386
2374	2387	void testAnisotropicTotalVariation(){
2375
	2388
2376	2389	double alpha0=0.05,beta0=0.5,sigma=0.1,rho=.5,K=10;
2377	2390	int inner_steps=200,outer_steps=5;
2378
	2391
2379	2392	MultiArray<2,double> phi(Shape2(width,height));
2380	2393	MultiArray<2,double> alpha(Shape2(width,height));
2381		MultiArray<2,double> beta(Shape2(width,height));
2382		MultiArray<2,double> xedges(Shape2(width,height));
2383		MultiArray<2,double> yedges(Shape2(width,height));
2384
	2394	MultiArray<2,double> beta(Shape2(width,height));
	2395	MultiArray<2,double> xedges(Shape2(width,height));
	2396	MultiArray<2,double> yedges(Shape2(width,height));
	2397
2385	2398	for (int y=0;y<height;y++){
2386	2399	for (int x=0;x<width;x++){
2387	2400	alpha(x,y)=alpha0;

2390	2403	yedges(x,y)=1;
2391	2404	}
2392	2405	}
2393		out=data;
2394		for (int i=0;i<outer_steps;i++){
	2406	out=data;
	2407	for (int i=0;i<outer_steps;i++){
2395	2408	getAnisotropy(out,phi,alpha,beta,alpha0,beta0,sigma,rho,K);
2396		anisotropicTotalVariationFilter(data,weight,phi,alpha,beta,out,inner_steps);
	2409	anisotropicTotalVariationFilter(data,weight,phi,alpha,beta,out,inner_steps);
2397	2410	}
2398	2411	//exportImage(srcImageRange(out), vigra::ImageExportInfo("test_aniso.pgm"));
2399		shouldEqualSequenceTolerance(out.begin(), out.end(), result_aniso_tv, 1e-8);
	2412	shouldEqualSequenceTolerance(out.begin(), out.end(), result_aniso_tv, 1e-8);
2400	2413	}
2401
	2414
2402	2415	void testSecondOrderTotalVariation(){
2403
	2416
2404	2417	double alpha0=0.05,beta0=0.5,sigma=0.1,rho=.5,K=10,gamma0=0.1;
2405	2418	int inner_steps=200,outer_steps=5;
2406
	2419
2407	2420	MultiArray<2,double> phi(Shape2(width,height));
2408	2421	MultiArray<2,double> alpha(Shape2(width,height));
2409		MultiArray<2,double> beta(Shape2(width,height));
2410		MultiArray<2,double> gamma(Shape2(width,height));
2411		MultiArray<2,double> xedges(Shape2(width,height));
2412		MultiArray<2,double> yedges(Shape2(width,height));
2413
	2422	MultiArray<2,double> beta(Shape2(width,height));
	2423	MultiArray<2,double> gamma(Shape2(width,height));
	2424	MultiArray<2,double> xedges(Shape2(width,height));
	2425	MultiArray<2,double> yedges(Shape2(width,height));
	2426
2414	2427	for (int y=0;y<height;y++){
2415	2428	for (int x=0;x<width;x++){
2416	2429	alpha(x,y)=alpha0;

2420	2433	yedges(x,y)=1;
2421	2434	}
2422	2435	}
2423		out=data;
	2436	out=data;
2424	2437	for (int i=0;i<outer_steps;i++){
2425	2438	getAnisotropy(out,phi,alpha,beta,alpha0,beta0,sigma,rho,K);
2426	2439	secondOrderTotalVariationFilter(data,weight,phi,alpha,beta,gamma,xedges,yedges,out,inner_steps);
2427	2440	}
2428	2441	//exportImage(srcImageRange(out), vigra::ImageExportInfo("test_htv.pgm"));
2429		shouldEqualSequenceTolerance(out.begin(), out.end(), result_higher_order_tv,1e-12);
	2442	shouldEqualSequenceTolerance(out.begin(), out.end(), result_higher_order_tv,1e-12);
2430	2443	}
2431	2444	};
2432	2445

2442	2455	#if 1
2443	2456	add( testCase( &ConvolutionTest::initExplicitlyTest));
2444	2457
2445		add( testCase( &ConvolutionTest::simpleSharpeningTest));
2446		add( testCase( &ConvolutionTest::gaussianSharpeningTest));
	2458	add( testCase( &ConvolutionTest::simpleSharpeningTest));
	2459	add( testCase( &ConvolutionTest::gaussianSharpeningTest));
2447	2460	add( testCase( &ConvolutionTest::stdConvolutionTestOnConstImage));
2448	2461	add( testCase( &ConvolutionTest::stdConvolutionTestWithAvoid));
2449	2462	add( testCase( &ConvolutionTest::stdConvolutionTestWithZeropad));

2498	2511
2499	2512	add( testCase( &ImagePyramidTest::testPyramidConstruction));
2500	2513	add( testCase( &ImagePyramidTest::testBurtReduceExpand));
2501
	2514
2502	2515	add( testCase( &TotalVariationTest::testTotalVariation));
2503	2516	add( testCase( &TotalVariationTest::testWeightedTotalVariation));
2504	2517	add( testCase( &TotalVariationTest::testAnisotropicTotalVariation));

+1

-1

test/correlation/CMakeLists.txt less more

0	0	if(FFTW3_FOUND)
1		INCLUDE_DIRECTORIES(${FFTW3_INCLUDE_DIR})
	1	INCLUDE_DIRECTORIES(${SUPPRESS_WARNINGS} ${FFTW3_INCLUDE_DIR})
2	2
3	3	VIGRA_CONFIGURE_THREADING()
4	4

+1

-1

test/features/CMakeLists.txt less more

0	0	if(FFTW3_FOUND)
1		INCLUDE_DIRECTORIES(${FFTW3_INCLUDE_DIR})
	1	INCLUDE_DIRECTORIES(${SUPPRESS_WARNINGS} ${FFTW3_INCLUDE_DIR})
2	2
3	3	VIGRA_ADD_TEST(test_features test.cxx LIBRARIES vigraimpex ${FFTW3_LIBRARIES})
4	4

+1

-0

test/filter_iterator/CMakeLists.txt less more

0

VIGRA_ADD_TEST(test_filter_iterator test.cxx)

+143

-0

test/filter_iterator/test.cxx less more

	0	/************************************************************************/
	1	/* */
	2	/* Copyright 2014-2015 by Ullrich Koethe and Philip Schill */
	3	/* */
	4	/* This file is part of the VIGRA computer vision library. */
	5	/* The VIGRA Website is */
	6	/* http://hci.iwr.uni-heidelberg.de/vigra/ */
	7	/* Please direct questions, bug reports, and contributions to */
	8	/* ullrich.koethe@iwr.uni-heidelberg.de or */
	9	/* vigra@informatik.uni-hamburg.de */
	10	/* */
	11	/* Permission is hereby granted, free of charge, to any person */
	12	/* obtaining a copy of this software and associated documentation */
	13	/* files (the "Software"), to deal in the Software without */
	14	/* restriction, including without limitation the rights to use, */
	15	/* copy, modify, merge, publish, distribute, sublicense, and/or */
	16	/* sell copies of the Software, and to permit persons to whom the */
	17	/* Software is furnished to do so, subject to the following */
	18	/* conditions: */
	19	/* */
	20	/* The above copyright notice and this permission notice shall be */
	21	/* included in all copies or substantial portions of the */
	22	/* Software. */
	23	/* */
	24	/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND */
	25	/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES */
	26	/* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND */
	27	/* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT */
	28	/* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, */
	29	/* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING */
	30	/* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR */
	31	/* OTHER DEALINGS IN THE SOFTWARE. */
	32	/* */
	33	/************************************************************************/
	34	#include <vigra/filter_iterator.hxx>
	35	#include <vigra/unittest.hxx>
	36	#include <vector>
	37	#include <numeric>
	38	#include <iterator>
	39
	40	using namespace vigra;
	41
	42	struct FilterIteratorTests
	43	{
	44	template <typename ITER0, typename ITER1>
	45	void test_filter_read_mod2(ITER0 in_begin, ITER0 in_end, ITER1 expected_begin)
	46	{
	47	typedef typename std::iterator_traits<ITER0>::value_type value_type;
	48	std::vector<value_type> out;
	49	auto filter = [](int x) { return x % 2 == 0; };
	50	auto begin = make_filter_iterator(filter, in_begin, in_end);
	51	auto end = make_filter_iterator(filter, in_end, in_end);
	52	for (auto it = begin; it != end; ++it)
	53	{
	54	out.push_back(*it);
	55	}
	56	shouldEqualSequence(out.begin(), out.end(), expected_begin);
	57	}
	58
	59	template <typename ITER0, typename ITER1>
	60	void test_filter_write_mod2(ITER0 in_begin, ITER0 in_end, ITER1 expected_begin)
	61	{
	62	typedef typename std::iterator_traits<ITER0>::value_type value_type;
	63	std::vector<value_type> out(in_begin, in_end);
	64	auto filter = [](int x) { return x % 2 == 0; };
	65	auto begin = make_filter_iterator(filter, out.begin(), out.end());
	66	auto end = make_filter_iterator(filter, out.end(), out.end());
	67	for (auto it = begin; it != end; ++it)
	68	{
	69	*it += 100;
	70	}
	71	shouldEqualSequence(out.begin(), out.end(), expected_begin);
	72	}
	73
	74	void test_filter_iterator_read()
	75	{
	76	{
	77	int in[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
	78	int out_expected[] = {0, 2, 4, 6, 8};
	79	test_filter_read_mod2(in, in+10, out_expected);
	80	}
	81	{
	82	int in[] = {0, 1, 2, 3, 4, 5, 6, 7, 8};
	83	int out_expected[] = {0, 2, 4, 6, 8};
	84	std::vector<int> v_in(in, in+9);
	85	test_filter_read_mod2(v_in.begin(), v_in.end(), out_expected);
	86	}
	87	{
	88	int in[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
	89	int out_expected[] = {2, 4, 6, 8};
	90	std::vector<int> v_in(in, in+9);
	91	test_filter_read_mod2(v_in.cbegin(), v_in.cend(), out_expected);
	92	}
	93	{
	94	int in[] = {1, 2, 3, 4, 5, 6, 7, 8};
	95	int out_expected[] = {2, 4, 6, 8};
	96	test_filter_read_mod2(in, in+8, out_expected);
	97	}
	98	}
	99
	100	void test_filter_iterator_write()
	101	{
	102	{
	103	int in[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
	104	int out_expected[] = {100, 1, 102, 3, 104, 5, 106, 7, 108, 9};
	105	test_filter_write_mod2(in, in+10, out_expected);
	106	}
	107	{
	108	int in[] = {0, 1, 2, 3, 4, 5, 6, 7, 8};
	109	int out_expected[] = {100, 1, 102, 3, 104, 5, 106, 7, 108};
	110	test_filter_write_mod2(in, in+9, out_expected);
	111	}
	112	{
	113	int in[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
	114	int out_expected[] = {1, 102, 3, 104, 5, 106, 7, 108, 9};
	115	test_filter_write_mod2(in, in+9, out_expected);
	116	}
	117	{
	118	int in[] = {1, 2, 3, 4, 5, 6, 7, 8};
	119	int out_expected[] = {1, 102, 3, 104, 5, 106, 7, 108};
	120	test_filter_write_mod2(in, in+8, out_expected);
	121	}
	122	}
	123	};
	124
	125	struct FilterIteratorTestSuite : public test_suite
	126	{
	127	FilterIteratorTestSuite()
	128	:
	129	test_suite("FilterIterator test")
	130	{
	131	add(testCase(&FilterIteratorTests::test_filter_iterator_read));
	132	add(testCase(&FilterIteratorTests::test_filter_iterator_write));
	133	}
	134	};
	135
	136	int main(int argc, char** argv)
	137	{
	138	FilterIteratorTestSuite filter_iterator_test;
	139	int failed = filter_iterator_test.run(testsToBeExecuted(argc, argv));
	140	std::cout << filter_iterator_test.report() << std::endl;
	141	return (failed != 0);
	142	}

+2

-2

test/fourier/CMakeLists.txt less more

0	0	if(FFTW3_FOUND)
1		INCLUDE_DIRECTORIES(${FFTW3_INCLUDE_DIR})
	1	INCLUDE_DIRECTORIES(${SUPPRESS_WARNINGS} ${FFTW3_INCLUDE_DIR})
2	2
3	3	VIGRA_CONFIGURE_THREADING()
4
	4
5	5	VIGRA_ADD_TEST(test_fourier test.cxx LIBRARIES vigraimpex ${FFTW3_LIBRARIES} ${THREADING_LIBRARIES})
6	6
7	7	VIGRA_COPY_TEST_DATA(ghouse.gif filter.xv gaborresult.xv)

+2

-2

test/gridgraph/CMakeLists.txt less more

1	1
2	2	if(WITH_BOOST_GRAPH)
3	3	VIGRA_ADD_TEST(test_gridgraph_BGL test.cxx LIBRARIES ${Boost_GRAPH_LIBRARY})
4		INCLUDE_DIRECTORIES(${Boost_INCLUDE_DIR})
	4	INCLUDE_DIRECTORIES(${SUPPRESS_WARNINGS} ${Boost_INCLUDE_DIR})
5	5	SET_TARGET_PROPERTIES(test_gridgraph_BGL PROPERTIES COMPILE_FLAGS "-DWITH_BOOST_GRAPH")
6	6	endif()
7	7
8	8	if(WITH_LEMON)
9	9	VIGRA_ADD_TEST(test_gridgraph_LEMON test.cxx LIBRARIES ${LEMON_LIBRARY})
10		INCLUDE_DIRECTORIES(${LEMON_INCLUDE_DIR})
	10	INCLUDE_DIRECTORIES(${SUPPRESS_WARNINGS} ${LEMON_INCLUDE_DIR})
11	11	SET_TARGET_PROPERTIES(test_gridgraph_LEMON PROPERTIES COMPILE_FLAGS "-DWITH_LEMON")
12	12	endif()

+12

-3

test/gridgraph/test.cxx less more

48	48
49	49	using namespace vigra;
50	50
	51	#ifdef __GNUC__
	52	#pragma GCC diagnostic push
	53	#pragma GCC diagnostic ignored "-Wsign-compare"
	54	#endif
	55
51	56	template <unsigned int N>
52	57	struct NeighborhoodTests
53	58	{

103	108	shouldEqual(gridGraphMaxDegree(N, DirectNeighborhood), neighborCount);
104	109
105	110	Shape pos, neg, strides = cumprod(Shape(3)) / 3;
106		for(int k=0; k<neighborCount; ++k)
	111	for(unsigned k=0; k<neighborCount; ++k)
107	112	{
108	113	shouldEqual(sum(abs(neighborOffsets[k])), 1); // test that it is a direct neighbor
109	114

146	151	shouldEqual(neighborExists[borderType].size(), neighborCount);
147	152	checkNeighborCodes[borderType] = 1;
148	153
149		for(int k=0; k<neighborCount; ++k)
	154	for(unsigned k=0; k<neighborCount; ++k)
150	155	{
151	156	// check that neighbors are correctly marked as inside or outside in neighborExists
152	157	shouldEqual(va.isInside(vi.point()+neighborOffsets[k]), neighborExists[borderType][k]);

170	175	shouldEqual((GridGraphMaxDegree<N, IndirectNeighborhood>::value), neighborCount);
171	176	shouldEqual(gridGraphMaxDegree(N, IndirectNeighborhood), neighborCount);
172	177
173		for(int k=0; k<neighborCount; ++k)
	178	for(unsigned k=0; k<neighborCount; ++k)
174	179	{
175	180	shouldEqual(abs(neighborOffsets[k]).maximum(), 1); // check that offset is at most 1 in any direction
176	181

1299	1304
1300	1305	return (failed != 0);
1301	1306	}
	1307
	1308	#ifdef __GNUC__
	1309	#pragma GCC diagnostic pop
	1310	#endif

+2

-2

test/hdf5impex/CMakeLists.txt less more

0	0	if(HDF5_FOUND)
1		INCLUDE_DIRECTORIES(${HDF5_INCLUDE_DIR})
2
	1	INCLUDE_DIRECTORIES(${SUPPRESS_WARNINGS} ${HDF5_INCLUDE_DIR})
	2
3	3	ADD_DEFINITIONS(${HDF5_CPPFLAGS})
4	4
5	5	VIGRA_ADD_TEST(test_hdf5impex test.cxx LIBRARIES vigraimpex ${HDF5_LIBRARIES})

+1

-1

test/impex/CMakeLists.txt less more

7	7
8	8	IF(TIFF_FOUND)
9	9	ADD_DEFINITIONS(-DHasTIFF)
10		INCLUDE_DIRECTORIES(${TIFF_INCLUDE_DIR})
	10	INCLUDE_DIRECTORIES(${SUPPRESS_WARNINGS} ${TIFF_INCLUDE_DIR})
11	11	ENDIF(TIFF_FOUND)
12	12
13	13	IF(OPENEXR_FOUND)

+1

-2

test/impex/test.cxx less more

14	14	/* restriction, including without limitation the rights to use, */
15	15	/* copy, modify, merge, publish, distribute, sublicense, and/or */
16	16	/* sell copies of the Software, and to permit persons to whom the */
17		/* Software is furnished to do so, subject to the following */
18	17	/* conditions: */
19	18	/* */
20	19	/* The above copyright notice and this permission notice shall be */

681	680	void testFile(const char* filename)
682	681	{
683	682	ImageExportInfo exportinfo(filename);
684		FRGBImage img(1, 1);
	683	FVector4Image img(1, 1);
685	684	img(0, 0) = 1;
686	685
687	686	const Diff2D position(0, 100);

+56

-20

test/math/test.cxx less more

2675	2675
2676	2676	void testDeterminant()
2677	2677	{
2678		double ds2[] = {1, 2, 2, 1};
2679		double dns2[] = {1, 2, 3, 1};
2680		Matrix ms2(Shape(2,2), ds2);
2681		Matrix mns2(Shape(2,2), dns2);
2682		double eps = 1e-12;
2683		shouldEqualTolerance(determinant(ms2), -3.0, eps);
2684		shouldEqualTolerance(determinant(mns2), -5.0, eps);
2685		shouldEqualTolerance(logDeterminant(transpose(ms2)*ms2), std::log(9.0), eps);
2686		shouldEqualTolerance(logDeterminant(transpose(mns2)*mns2), std::log(25.0), eps);
2687
2688		double ds3[] = {1, 2, 3, 2, 3, 1, 3, 1, 2};
2689		double dns3[] = {1, 2, 3, 5, 3, 1, 3, 1, 2};
2690		Matrix ms3(Shape(3,3), ds3);
2691		Matrix mns3(Shape(3,3), dns3);
2692		shouldEqualTolerance(determinant(ms3), -18.0, eps);
2693		shouldEqualTolerance(determinant(mns3), -21.0, eps);
2694		shouldEqualTolerance(determinant(transpose(ms3)*ms3, "Cholesky"), 324.0, eps);
2695		shouldEqualTolerance(determinant(transpose(mns3)*mns3, "Cholesky"), 441.0, eps);
2696		shouldEqualTolerance(logDeterminant(transpose(ms3)*ms3), std::log(324.0), eps);
2697		shouldEqualTolerance(logDeterminant(transpose(mns3)*mns3), std::log(441.0), eps);
	2678	{
	2679	double eps = 1e-12;
	2680	double ds2[] = {1, 2, 2, 1};
	2681	double dns2[] = {1, 2, 3, 1};
	2682	Matrix ms2(Shape(2,2), ds2);
	2683	Matrix mns2(Shape(2,2), dns2);
	2684	shouldEqualTolerance(determinant(ms2), -3.0, eps);
	2685	shouldEqualTolerance(determinant(mns2), -5.0, eps);
	2686	shouldEqualTolerance(logDeterminant(transpose(ms2)*ms2), std::log(9.0), eps);
	2687	shouldEqualTolerance(logDeterminant(transpose(mns2)*mns2), std::log(25.0), eps);
	2688	}
	2689	{
	2690	double eps = 1e-12;
	2691	double ds3[] = {1, 2, 3, 2, 3, 1, 3, 1, 2};
	2692	double dns3[] = {1, 2, 3, 5, 3, 1, 3, 1, 2};
	2693	Matrix ms3(Shape(3,3), ds3);
	2694	Matrix mns3(Shape(3,3), dns3);
	2695	shouldEqualTolerance(determinant(ms3), -18.0, eps);
	2696	shouldEqualTolerance(determinant(mns3), -21.0, eps);
	2697	shouldEqualTolerance(determinant(transpose(ms3)*ms3, "Cholesky"), 324.0, eps);
	2698	shouldEqualTolerance(determinant(transpose(mns3)*mns3, "Cholesky"), 441.0, eps);
	2699	shouldEqualTolerance(logDeterminant(transpose(ms3)*ms3), std::log(324.0), eps);
	2700	shouldEqualTolerance(logDeterminant(transpose(mns3)*mns3), std::log(441.0), eps);
	2701	}
	2702	{
	2703	int ds2[] = {1, 2, 2, 1};
	2704	int dns2[] = {1, 2, 3, 1};
	2705	vigra::Matrix<int> ms2(Shape(2,2), ds2);
	2706	vigra::Matrix<int> mns2(Shape(2,2), dns2);
	2707	shouldEqual(determinant(ms2), -3);
	2708	shouldEqual(determinant(mns2), -5);
	2709	}
	2710	{
	2711	int ds3[] = {1, 2, 3, 2, 3, 1, 3, 1, 2};
	2712	int dns3[] = {1, 2, 3, 5, 3, 1, 3, 1, 2};
	2713	vigra::Matrix<int> ms3(Shape(3,3), ds3);
	2714	vigra::Matrix<int> mns3(Shape(3,3), dns3);
	2715	shouldEqual(determinant(ms3), -18);
	2716	shouldEqual(determinant(mns3), -21);
	2717	}
	2718	{
	2719	unsigned short ds2[] = {1, 2, 2, 1};
	2720	unsigned short dns2[] = {1, 2, 3, 1};
	2721	vigra::Matrix<unsigned short> ms2(Shape(2,2), ds2);
	2722	vigra::Matrix<unsigned short> mns2(Shape(2,2), dns2);
	2723	shouldEqual(determinant(ms2), -3);
	2724	shouldEqual(determinant(mns2), -5);
	2725	}
	2726	{
	2727	unsigned short ds3[] = {1, 2, 3, 2, 3, 1, 3, 1, 2};
	2728	unsigned short dns3[] = {1, 2, 3, 5, 3, 1, 3, 1, 2};
	2729	vigra::Matrix<unsigned short> ms3(Shape(3,3), ds3);
	2730	vigra::Matrix<unsigned short> mns3(Shape(3,3), dns3);
	2731	shouldEqual(determinant(ms3), -18);
	2732	shouldEqual(determinant(mns3), -21);
	2733	}
2698	2734	}
2699	2735
2700	2736	void testSVD()

+3

-0

test/merge_graph_adaptor/test.cxx less more

773	773	Edge e13 = g.findEdge(n1,n3);
774	774	Edge e24 = g.findEdge(n2,n4);
775	775	Edge e34 = g.findEdge(n3,n4);
	776	ignore_argument(e12,e13,e24,e34);
776	777
777	778	// get incoming arcs
778	779	{

844	845	Edge e13 = g.findEdge(n1,n3);
845	846	Edge e24 = g.findEdge(n2,n4);
846	847	Edge e34 = g.findEdge(n3,n4);
	848	ignore_argument(e12,e13,e24,e34);
	849
847	850
848	851
849	852	{

+5

-5

test/multiarray/CMakeLists.txt less more

13	13
14	14	# Check cpp version
15	15	if(NOT ${VIGRA_CPP_VERSION})
16		message(FATAL_ERROR
	16	message(FATAL_ERROR
17	17	"cmake error: VIGRA_CPP_VERSION not defined yet. "
18	18	"Call VIGRA_DETECT_CPP_VERSION() from the main CMakeLists file." )
19	19	endif()
20	20
21	21	# multiarray/test.cxx uses 'auto' from c++11.
22	22	string(COMPARE LESS ${VIGRA_CPP_VERSION} "201103" NO_CXX11)
23		if(NO_CXX11 AND NOT MSVC) # Visual Studio 2010 and 2012 supports enough c++11 features that we can still use it
	23	if(NO_CXX11 AND NOT MSVC) # Visual Studio 2010 and 2012 supports enough c++11 features that we can still use it
24	24	MESSAGE(STATUS "** WARNING: You are compiling in C++98 mode.")
25	25	MESSAGE(STATUS "** Multiarray tests will be skipped.")
26	26	MESSAGE(STATUS "** Add -std=c++11 to CMAKE_CXX_FLAGS to enable multiarray tests.")
27	27	else()
28	28	VIGRA_ADD_TEST(test_multiarray test.cxx LIBRARIES vigraimpex)
29		endif()
	29	endif()
30	30
31	31	# Even with C++11, a working threading implementation is needed for running multiarray_chunked tests.
32	32	VIGRA_CONFIGURE_THREADING()

42	42
43	43	IF(HDF5_FOUND)
44	44	ADD_DEFINITIONS(-DHasHDF5 ${HDF5_CPPFLAGS})
45		INCLUDE_DIRECTORIES(${HDF5_INCLUDE_DIR})
	45	INCLUDE_DIRECTORIES(${SUPPRESS_WARNINGS} ${HDF5_INCLUDE_DIR})
46	46	SET(MULTIARRAY_CHUNKED_LIBRARIES vigraimpex ${HDF5_LIBRARIES} ${MULTIARRAY_CHUNKED_LIBRARIES})
47	47	ELSE(TIFF_FOUND)
48	48	SET(MULTIARRAY_CHUNKED_LIBRARIES vigraimpex ${MULTIARRAY_CHUNKED_LIBRARIES})
49	49	ENDIF()
50	50
51		VIGRA_ADD_TEST(test_multiarray_chunked test_chunked.cxx
	51	VIGRA_ADD_TEST(test_multiarray_chunked test_chunked.cxx
52	52	LIBRARIES ${MULTIARRAY_CHUNKED_LIBRARIES})
53	53	endif()
54	54

+5

-6

test/multiarray/test.cxx less more

1192	1192	shouldEqual (countx, 30);
1193	1193	shouldEqual (county, 15);
1194	1194	shouldEqual (countz, 5);
1195		shouldEqual (seqi, a3.end());
	1195	should (seqi == a3.end());
1196	1196
1197	1197	// test direct navigation
1198	1198	traverser3_t i3 = a3.traverser_begin();

1327	1327	shouldEqual (countx, 30);
1328	1328	shouldEqual (county, 15);
1329	1329	shouldEqual (countz, 5);
1330		shouldEqual (seqi, a3.end());
	1330	should (seqi == a3.end());
1331	1331	//
1332	1332	//// test direct navigation
1333	1333	//traverser3_t i3 = a3.traverser_begin();

1735	1735	static typename Image::value_type data[];
1736	1736
1737	1737	ImageViewTest()
1738		: ma(TinyVector<int, 2>(3,3)),
	1738	: ma(Shape2(3,3)),
1739	1739	img(makeBasicImageView(ma))
1740	1740	{
1741	1741	typename Image::Accessor acc = img.accessor();

1867	1867	void testStridedImageView()
1868	1868	{
1869	1869	// create stride MultiArrayView
1870		typename MA::difference_type
1871		start(0,0), end(2,2);
1872		MA roi = ma.subarray(start, end);
	1870	Shape2 start(0,0), end(2, 2);
	1871	typename MA::view_type roi = ma.subarray(start, end);
1873	1872
1874	1873	// inspect both the MultiArrayView and the corresponding BasicImageView
1875	1874	vigra::FindSum<typename Image::value_type> sum1, sum2;

+2

-2

test/multiarray/test_chunked.cxx less more

94	94	}
95	95
96	96	static ArrayPtr createArray(Shape3 const & shape,
97		Shape3 const & chunk_shape,
	97	Shape3 const & /chunk_shape/,
98	98	ChunkedArrayFull<3, T> *,
99	99	std::string const & = "chunked_test.h5")
100	100	{

198	198	int dataBytesBefore = array->dataBytes();
199	199	array->releaseChunks(Shape3(5, 0, 3), Shape3(shape[0], shape[1], shape[2]-3), true);
200	200	if(!isFullArray)
201		should(array->dataBytes() < dataBytesBefore);
	201	should(array->dataBytes() < (unsigned)dataBytesBefore);
202	202
203	203	if(IsSameType<Array, ChunkedArrayLazy<3, T> >::value \|\|
204	204	IsSameType<Array, ChunkedArrayCompressed<3, T> >::value)

+6

-1

test/objectfeatures/CMakeLists.txt less more

0		VIGRA_ADD_TEST(test_objectfeatures test.cxx LIBRARIES vigraimpex)
	0	VIGRA_ADD_TEST(test_objectfeatures test.cxx)
	1	IF(WITH_LEMON)
	2	VIGRA_ADD_TEST(test_objectfeatures_lemon test_lemon.cxx LIBRARIES ${LEMON_LIBRARY})
	3	INCLUDE_DIRECTORIES(${LEMON_INCLUDE_DIR})
	4	SET_TARGET_PROPERTIES(test_objectfeatures_lemon PROPERTIES COMPILE_FLAGS "-DWITH_LEMON")
	5	ENDIF(WITH_LEMON)
1	6	VIGRA_ADD_TEST(test_stand_alone_acc_chain stand_alone_acc_chain.cxx)
2	7	VIGRA_COPY_TEST_DATA(of.gif)
3	8

+0

-60

test/objectfeatures/test.cxx less more

1489	1489	shouldEqual(W(3, 0, 1), get<AutoRangeHistogram<3> >(c,3));
1490	1490	}
1491	1491	}
1492
1493		void testConvexHullFeatures()
1494		{
1495		using namespace vigra::acc;
1496
1497		int size = 6;
1498		MultiArray<2, int> mask(vigra::Shape2(size, size));
1499
1500		mask(1, 1) = 1;
1501		mask(2, 1) = 1;
1502		mask(2, 2) = 1;
1503		mask(2, 3) = 1;
1504		mask(1, 3) = 1;
1505		mask(3, 1) = 1;
1506		mask(3, 3) = 1;
1507		mask(4, 1) = 1;
1508		mask(4, 3) = 1;
1509
1510		//for(auto i = mask.begin(); i != mask.end(); ++i)
1511		//{
1512		// std::cerr << (i ? "" : " ");
1513		// if(i.point()[0] == mask.shape(0)-1)
1514		// std::cerr << "\n";
1515		//}
1516
1517		AccumulatorChainArray<CoupledArrays<2, int>,
1518		Select<LabelArg<1>, ConvexHull> > chf;
1519		chf.ignoreLabel(0);
1520		extractFeatures(mask, chf);
1521
1522		shouldEqual(getAccumulator<ConvexHull>(chf, 1).inputArea(), 8.5);
1523		shouldEqualTolerance(getAccumulator<ConvexHull>(chf, 1).inputPerimeter(), 8.0 + 6.0*M_SQRT2, 1e-15);
1524
1525		typedef TinyVector<double, 2> P;
1526		P ref[] = { P(1.0, 0.5), P(0.5, 1.0), P(0.5, 3.0), P(1.0, 3.5), P(4.0, 3.5),
1527		P(4.5, 3.0), P(4.5, 1.0), P(4.0, 0.5), P(1.0, 0.5) };
1528		shouldEqual(get<ConvexHull>(chf, 1).hull().size(), 9);
1529		shouldEqualSequence(ref, ref+9, get<ConvexHull>(chf, 1).hull().begin());
1530		shouldEqual(get<ConvexHull>(chf, 1).hullArea(), 11.5);
1531		shouldEqualTolerance(get<ConvexHull>(chf, 1).hullPerimeter(), 10.0 + 2.0*M_SQRT2, 1e-15);
1532
1533		shouldEqualTolerance(get<ConvexHull>(chf, 1).convexity(), 8.5 / 11.5, 1e-15);
1534		shouldEqualTolerance(get<ConvexHull>(chf, 1).rugosity(), 1.2850586602653933, 1e-15);
1535
1536		shouldEqual(get<ConvexHull>(chf, 1).convexityDefectCount(), 2);
1537		shouldEqual(get<ConvexHull>(chf, 1).defectAreaList().size(), 2);
1538		shouldEqual(get<ConvexHull>(chf, 1).defectAreaList()[0], 2);
1539		shouldEqual(get<ConvexHull>(chf, 1).defectAreaList()[1], 1);
1540
1541		shouldEqualTolerance(get<ConvexHull>(chf, 1).convexityDefectAreaMean(), 1.5, 1e-15);
1542		shouldEqualTolerance(get<ConvexHull>(chf, 1).convexityDefectAreaVariance(), 0.5, 1e-15);
1543		shouldEqualTolerance(get<ConvexHull>(chf, 1).convexityDefectAreaSkewness(), 0.0, 1e-15);
1544		shouldEqualTolerance(get<ConvexHull>(chf, 1).convexityDefectAreaKurtosis(), 0.0, 1e-15);
1545		shouldEqualTolerance(get<ConvexHull>(chf, 1).meanDefectDisplacement(), 1.185185185185185, 1e-15);
1546
1547		shouldEqualTolerance(P(2.4444444444444444, 2.0), get<ConvexHull>(chf, 1).inputCenter(), P(1e-15));
1548		shouldEqualTolerance(P(2.5, 2.0), get<ConvexHull>(chf, 1).hullCenter(), P(1e-15));
1549		shouldEqualTolerance(P(2.6666666666666667, 2.0), get<ConvexHull>(chf, 1).convexityDefectCenter(), P(1e-15));
1550		}
1551	1492	};
1552	1493
1553	1494	struct FeaturesTestSuite : public vigra::test_suite

1564	1505	add(testCase(&AccumulatorTest::testHistogram));
1565	1506	add(testCase(&AccumulatorTest::testRegionAccumulators));
1566	1507	add(testCase(&AccumulatorTest::testIndexSpecifiers));
1567		add(testCase(&AccumulatorTest::testConvexHullFeatures));
1568	1508	}
1569	1509	};
1570	1510

+249

-0

test/objectfeatures/test_lemon.cxx less more

	0	/************************************************************************/
	1	/* */
	2	/* Copyright 2011-2012 by Ullrich Koethe */
	3	/* */
	4	/* This file is part of the VIGRA computer vision library. */
	5	/* The VIGRA Website is */
	6	/* http://hci.iwr.uni-heidelberg.de/vigra/ */
	7	/* Please direct questions, bug reports, and contributions to */
	8	/* ullrich.koethe@iwr.uni-heidelberg.de or */
	9	/* vigra@informatik.uni-hamburg.de */
	10	/* */
	11	/* Permission is hereby granted, free of charge, to any person */
	12	/* obtaining a copy of this software and associated documentation */
	13	/* files (the "Software"), to deal in the Software without */
	14	/* restriction, including without limitation the rights to use, */
	15	/* copy, modify, merge, publish, distribute, sublicense, and/or */
	16	/* sell copies of the Software, and to permit persons to whom the */
	17	/* Software is furnished to do so, subject to the following */
	18	/* conditions: */
	19	/* */
	20	/* The above copyright notice and this permission notice shall be */
	21	/* included in all copies or substantial portions of the */
	22	/* Software. */
	23	/* */
	24	/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND */
	25	/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES */
	26	/* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND */
	27	/* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT */
	28	/* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, */
	29	/* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING */
	30	/* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR */
	31	/* OTHER DEALINGS IN THE SOFTWARE. */
	32	/* */
	33	/************************************************************************/
	34
	35	#include <iostream>
	36	#include <sstream>
	37	#include <map>
	38	#include <set>
	39
	40	#include <vigra/unittest.hxx>
	41	#include <vigra/multi_array.hxx>
	42	#include <vigra/accumulator.hxx>
	43
	44	namespace std {
	45
	46	template <unsigned int N, class T, class Stride>
	47	ostream & operator<<(ostream & o, vigra::MultiArrayView<N, T, Stride> const & m)
	48	{
	49	for(vigra::MultiArrayIndex k=0; k<m.size(); ++k)
	50	o << m[k] << " ";
	51	return o;
	52	}
	53
	54	} // namespace std
	55
	56	using namespace vigra;
	57
	58	// mask cl.exe shortcomings
	59	#if defined(_MSC_VER)
	60	#pragma warning( disable : 4503 )
	61	#endif
	62
	63	struct AccumulatorTest
	64	{
	65	void testConvexHullFeatures2D()
	66	{
	67	using namespace vigra::acc;
	68	std::string prefix("testConvexHullFeatures2D(): ");
	69
	70	int size = 6;
	71	MultiArray<2, int> mask(vigra::Shape2(size, size));
	72
	73	mask(1, 1) = 1;
	74	mask(2, 1) = 1;
	75	mask(2, 2) = 1;
	76	mask(2, 3) = 1;
	77	mask(1, 3) = 1;
	78	mask(3, 1) = 1;
	79	mask(3, 3) = 1;
	80	mask(4, 1) = 1;
	81	mask(4, 3) = 1;
	82
	83	AccumulatorChainArray<
	84	CoupledArrays<2, int>,
	85	Select<LabelArg<1>, ConvexHullFeatures> > chf;
	86	chf.ignoreLabel(0);
	87	extractFeatures(mask, chf);
	88
	89	getAccumulator<ConvexHullFeatures>(chf, 1).finalize();
	90
	91	{
	92	TinyVector<double, 2> ref(2.5 - 1./18., 2.);
	93	shouldEqualSequenceTolerance(
	94	get<ConvexHullFeatures>(chf, 1).inputCenter().begin(),
	95	get<ConvexHullFeatures>(chf, 1).inputCenter().end(),
	96	ref.begin(),
	97	(std::numeric_limits<double>::epsilon() * 2));
	98	}
	99	{
	100	TinyVector<double, 2> ref(2.5, 2.);
	101	shouldEqualSequenceTolerance(
	102	get<ConvexHullFeatures>(chf, 1).hullCenter().begin(),
	103	get<ConvexHullFeatures>(chf, 1).hullCenter().end(),
	104	ref.begin(),
	105	(std::numeric_limits<double>::epsilon() * 2));
	106	}
	107	shouldEqual(get<ConvexHullFeatures>(chf, 1).inputVolume(), 9);
	108	shouldEqual(get<ConvexHullFeatures>(chf, 1).hullVolume(), 12);
	109	{
	110	TinyVector<double, 2> ref(8. / 3., 2.);
	111	shouldEqualSequenceTolerance(
	112	get<ConvexHullFeatures>(chf, 1).defectCenter().begin(),
	113	get<ConvexHullFeatures>(chf, 1).defectCenter().end(),
	114	ref.begin(),
	115	(std::numeric_limits<double>::epsilon() * 2));
	116	}
	117	shouldEqual(get<ConvexHullFeatures>(chf, 1).defectCount(), 2);
	118	shouldEqualTolerance(
	119	get<ConvexHullFeatures>(chf, 1).defectVolumeMean(),
	120	1.5,
	121	(std::numeric_limits<double>::epsilon() * 2));
	122	shouldEqualTolerance(
	123	get<ConvexHullFeatures>(chf, 1).defectVolumeVariance(),
	124	0.5,
	125	(std::numeric_limits<double>::epsilon() * 2));
	126	shouldEqualTolerance(
	127	get<ConvexHullFeatures>(chf, 1).defectVolumeSkewness(),
	128	0.0,
	129	(std::numeric_limits<double>::epsilon() * 2));
	130	shouldEqualTolerance(
	131	get<ConvexHullFeatures>(chf, 1).defectVolumeKurtosis(),
	132	0.0,
	133	(std::numeric_limits<double>::epsilon() * 2));
	134	shouldEqualTolerance(
	135	get<ConvexHullFeatures>(chf, 1).defectDisplacementMean(),
	136	((2.5 - 1./18. - 1.) + 2*(3.5 - 2.5 + 1./18.))/3.,
	137	(std::numeric_limits<double>::epsilon() * 2));
	138	shouldEqualTolerance(
	139	get<ConvexHullFeatures>(chf, 1).convexity(),
	140	9. / 12.,
	141	(std::numeric_limits<double>::epsilon() * 2));
	142	}
	143
	144	void testConvexHullFeatures3D()
	145	{
	146	using namespace vigra::acc;
	147	std::string prefix("testConvexHullFeatures3D(): ");
	148
	149	int size = 5;
	150	MultiArray<3, int> mask(vigra::Shape3(size, size, size), 0);
	151	for (int i = 0; i < 9; i++)
	152	{
	153	mask(i / 3 + 1, i % 3 + 1, 1) = 1;
	154	mask(i / 3 + 1, i % 3 + 1, 3) = 1;
	155	}
	156	mask(3, 1, 2) = 1; mask(3, 2, 2) = 1;
	157	mask(1, 3, 2) = 1; mask(2, 3, 2) = 1;
	158
	159	// z = 0 \| z = 1 \| z = 2 \| z = 3
	160	// --------+---------+---------+--------
	161	// 0 0 0 0 \| 0 0 0 0 \| 0 0 0 0 \| 0 0 0 0
	162	// 0 0 0 0 \| 0 x x x \| 0 0 0 x \| 0 x x x
	163	// 0 0 0 0 \| 0 x x x \| 0 0 0 x \| 0 x x x
	164	// 0 0 0 0 \| 0 x x x \| 0 x x 0 \| 0 x x x
	165
	166	AccumulatorChainArray<
	167	CoupledArrays<3, int>,
	168	Select<LabelArg<1>, ConvexHullFeatures> > chf;
	169	chf.ignoreLabel(0);
	170	extractFeatures(mask, chf);
	171
	172	getAccumulator<ConvexHullFeatures>(chf, 1).finalize();
	173	{
	174	// x and y coordinate: (71 + 72 + 8*3) / 22 = 45 / 22
	175	TinyVector<double, 3> ref(45. / 22., 45. / 22., 2.);
	176	shouldEqualSequenceTolerance(
	177	get<ConvexHullFeatures>(chf, 1).inputCenter().begin(),
	178	get<ConvexHullFeatures>(chf, 1).inputCenter().end(),
	179	ref.begin(),
	180	(std::numeric_limits<double>::epsilon() * 2));
	181	}
	182	{
	183	TinyVector<double, 3> ref(2., 2., 2.);
	184	shouldEqualSequenceTolerance(
	185	get<ConvexHullFeatures>(chf, 1).hullCenter().begin(),
	186	get<ConvexHullFeatures>(chf, 1).hullCenter().end(),
	187	ref.begin(),
	188	(std::numeric_limits<double>::epsilon() * 2));
	189	}
	190	shouldEqual(get<ConvexHullFeatures>(chf, 1).inputVolume(), 22);
	191	shouldEqual(get<ConvexHullFeatures>(chf, 1).hullVolume(), 27);
	192	{
	193	// x and y coordinate: (21 + 22 + 1*3) / 5 = 9 / 5
	194	TinyVector<double, 3> ref(9. / 5., 9. / 5., 2.);
	195	shouldEqualSequenceTolerance(
	196	get<ConvexHullFeatures>(chf, 1).defectCenter().begin(),
	197	get<ConvexHullFeatures>(chf, 1).defectCenter().end(),
	198	ref.begin(),
	199	(std::numeric_limits<double>::epsilon() * 2));
	200	}
	201	shouldEqual(get<ConvexHullFeatures>(chf, 1).defectCount(), 2);
	202	shouldEqualTolerance(
	203	get<ConvexHullFeatures>(chf, 1).defectVolumeMean(),
	204	2.5,
	205	(std::numeric_limits<double>::epsilon() * 2));
	206	shouldEqualTolerance(
	207	get<ConvexHullFeatures>(chf, 1).defectVolumeVariance(),
	208	9. / 2.,
	209	(std::numeric_limits<double>::epsilon() * 2));
	210	shouldEqualTolerance(
	211	get<ConvexHullFeatures>(chf, 1).defectVolumeSkewness(),
	212	0.0,
	213	(std::numeric_limits<double>::epsilon() * 2));
	214	shouldEqualTolerance(
	215	get<ConvexHullFeatures>(chf, 1).defectVolumeKurtosis(),
	216	0.0,
	217	(std::numeric_limits<double>::epsilon() * 2));
	218	// (sqrt(2) * 4 * (45 / 22 - 3 / 2) + sqrt(2) * 1 * (3 - 45 / 22)) / 5
	219	// = sqrt(2) / 5 * (90 / 11 - 3 - 45 / 22)
	220	shouldEqualTolerance(
	221	get<ConvexHullFeatures>(chf, 1).defectDisplacementMean(),
	222	sqrt(2.) / 5. * (90. / 11. - 3. - 45. / 22.),
	223	(std::numeric_limits<double>::epsilon() * 2));
	224	shouldEqualTolerance(
	225	get<ConvexHullFeatures>(chf, 1).convexity(),
	226	22. / 27.,
	227	(std::numeric_limits<double>::epsilon() * 2));
	228	}
	229	};
	230
	231	struct FeaturesTestSuite : public vigra::test_suite
	232	{
	233	FeaturesTestSuite()
	234	: vigra::test_suite("FeaturesTestSuite")
	235	{
	236	add(testCase(&AccumulatorTest::testConvexHullFeatures2D));
	237	add(testCase(&AccumulatorTest::testConvexHullFeatures3D));
	238	}
	239	};
	240
	241	int main(int argc, char** argv)
	242	{
	243	FeaturesTestSuite test;
	244	const int failed = test.run(vigra::testsToBeExecuted(argc, argv));
	245	std::cout << test.report() << std::endl;
	246
	247	return failed != 0;
	248	}

+2

-0

test/permutation/CMakeLists.txt less more

	0	VIGRA_ADD_TEST(test_permutation test.cxx LIBRARIES)
	1

+122

-0

test/permutation/test.cxx less more

	0	/************************************************************************/
	1	/* */
	2	/* Copyright 1998-2014 by */
	3	/* Ullrich Koethe, */
	4	/* Esteban Pardo */
	5	/* */
	6	/* This file is part of the VIGRA computer vision library. */
	7	/* The VIGRA Website is */
	8	/* http://hci.iwr.uni-heidelberg.de/vigra/ */
	9	/* Please direct questions, bug reports, and contributions to */
	10	/* ullrich.koethe@iwr.uni-heidelberg.de or */
	11	/* vigra@informatik.uni-hamburg.de */
	12	/* */
	13	/* Permission is hereby granted, free of charge, to any person */
	14	/* obtaining a copy of this software and associated documentation */
	15	/* files (the "Software"), to deal in the Software without */
	16	/* restriction, including without limitation the rights to use, */
	17	/* copy, modify, merge, publish, distribute, sublicense, and/or */
	18	/* sell copies of the Software, and to permit persons to whom the */
	19	/* Software is furnished to do so, subject to the following */
	20	/* conditions: */
	21	/* */
	22	/* The above copyright notice and this permission notice shall be */
	23	/* included in all copies or substantial portions of the */
	24	/* Software. */
	25	/* */
	26	/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND */
	27	/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES */
	28	/* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND */
	29	/* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT */
	30	/* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, */
	31	/* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING */
	32	/* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR */
	33	/* OTHER DEALINGS IN THE SOFTWARE. */
	34	/* */
	35	/************************************************************************/
	36
	37	#define VIGRA_CHECK_BOUNDS
	38
	39	#include <limits>
	40	#include <algorithm>
	41	#include <vigra/unittest.hxx>
	42	#include <vigra/permutation.hxx>
	43
	44
	45	namespace vigra
	46	{
	47
	48	struct PermutationTest
	49	{
	50	void testN1()
	51	{
	52	PlainChangesPermutations<1> permutations;
	53	shouldEqual(permutations.size(), 1);
	54	shouldEqual(permutations[0][0], 0);
	55	shouldEqual(permutations[0].sign(), 1);
	56	}
	57
	58	void testN2()
	59	{
	60	PlainChangesPermutations<2> permutations;
	61	shouldEqual(permutations.size(), 2);
	62	shouldEqual(permutations[0][0], 0);
	63	shouldEqual(permutations[0][1], 1);
	64	shouldEqual(permutations[0].sign(), 1);
	65	shouldEqual(permutations[1][0], 1);
	66	shouldEqual(permutations[1][1], 0);
	67	shouldEqual(permutations[1].sign(), -1);
	68	}
	69
	70	void testN3()
	71	{
	72	PlainChangesPermutations<3> permutations;
	73	shouldEqual(permutations.size(), 6);
	74	shouldEqual(permutations[0][0], 0);
	75	shouldEqual(permutations[0][1], 1);
	76	shouldEqual(permutations[0][2], 2);
	77	shouldEqual(permutations[0].sign(), 1);
	78	shouldEqual(permutations[1][0], 0);
	79	shouldEqual(permutations[1][1], 2);
	80	shouldEqual(permutations[1][2], 1);
	81	shouldEqual(permutations[1].sign(), -1);
	82	shouldEqual(permutations[2][0], 2);
	83	shouldEqual(permutations[2][1], 0);
	84	shouldEqual(permutations[2][2], 1);
	85	shouldEqual(permutations[2].sign(), 1);
	86	shouldEqual(permutations[3][0], 2);
	87	shouldEqual(permutations[3][1], 1);
	88	shouldEqual(permutations[3][2], 0);
	89	shouldEqual(permutations[3].sign(), -1);
	90	shouldEqual(permutations[4][0], 1);
	91	shouldEqual(permutations[4][1], 2);
	92	shouldEqual(permutations[4][2], 0);
	93	shouldEqual(permutations[4].sign(), 1);
	94	shouldEqual(permutations[5][0], 1);
	95	shouldEqual(permutations[5][1], 0);
	96	shouldEqual(permutations[5][2], 2);
	97	shouldEqual(permutations[5].sign(), -1);
	98	}
	99	};
	100
	101	struct PermutationTestSuite : public vigra::test_suite
	102	{
	103	PermutationTestSuite() : vigra::test_suite("PermutationTestSuite")
	104	{
	105	add(testCase(&PermutationTest::testN1));
	106	add(testCase(&PermutationTest::testN2));
	107	add(testCase(&PermutationTest::testN3));
	108	}
	109	};
	110
	111	} // namespace vigra
	112
	113	int main(int argc, char** argv)
	114	{
	115	vigra::PermutationTestSuite test;
	116	const int failed = test.run(vigra::testsToBeExecuted(argc, argv));
	117	std::cerr << test.report() << std::endl;
	118
	119	return failed != 0;
	120	}
	121

+6

-0

test/polytope/CMakeLists.txt less more

	0	IF(WITH_LEMON)
	1	VIGRA_ADD_TEST(test_polytope test.cxx LIBRARIES ${LEMON_LIBRARY})
	2	INCLUDE_DIRECTORIES(${LEMON_INCLUDE_DIR})
	3	SET_TARGET_PROPERTIES(test_polytope PROPERTIES COMPILE_FLAGS "-DWITH_LEMON")
	4	ENDIF(WITH_LEMON)
	5

+215

-0

test/polytope/convex_hull_benchmark.cxx less more

	0	/************************************************************************/
	1	/* */
	2	/* Copyright 2011-2012 by Ullrich Koethe */
	3	/* */
	4	/* This file is part of the VIGRA computer vision library. */
	5	/* The VIGRA Website is */
	6	/* http://hci.iwr.uni-heidelberg.de/vigra/ */
	7	/* Please direct questions, bug reports, and contributions to */
	8	/* ullrich.koethe@iwr.uni-heidelberg.de or */
	9	/* vigra@informatik.uni-hamburg.de */
	10	/* */
	11	/* Permission is hereby granted, free of charge, to any person */
	12	/* obtaining a copy of this software and associated documentation */
	13	/* files (the "Software"), to deal in the Software without */
	14	/* restriction, including without limitation the rights to use, */
	15	/* copy, modify, merge, publish, distribute, sublicense, and/or */
	16	/* sell copies of the Software, and to permit persons to whom the */
	17	/* Software is furnished to do so, subject to the following */
	18	/* conditions: */
	19	/* */
	20	/* The above copyright notice and this permission notice shall be */
	21	/* included in all copies or substantial portions of the */
	22	/* Software. */
	23	/* */
	24	/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND */
	25	/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES */
	26	/* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND */
	27	/* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT */
	28	/* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, */
	29	/* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING */
	30	/* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR */
	31	/* OTHER DEALINGS IN THE SOFTWARE. */
	32	/* */
	33	/************************************************************************/
	34
	35	#include <iostream>
	36	#include <chrono>
	37
	38	#include <vigra/unittest.hxx>
	39	#include <vigra/multi_array.hxx>
	40	#include <vigra/polytope.hxx>
	41	#include <vigra/accumulator.hxx>
	42
	43	namespace chrono = std::chrono;
	44
	45	namespace vigra
	46	{
	47
	48	using namespace acc;
	49
	50	struct ConvexHullBenchmark
	51	{
	52
	53	typedef chrono::steady_clock clock_type;
	54
	55	template <unsigned int N>
	56	void testTypical()
	57	{
	58	std::cout << "# Benchmark for typical case with dim = " << N << ". ";
	59	std::cout << "All time measures in ms." << std::endl;
	60	std::cout << "# size, min, mean, max, std" << std::endl;
	61	for (int size = 1; size < 10000; size *= 2)
	62	{
	63	ArrayVector<double> times = constructPolytopeTypical<N>(size, 32);
	64	AccumulatorChain<
	65	MultiArrayIndex,
	66	Select<Minimum, Maximum, Mean, StdDev> > acc_chain;
	67	extractFeatures(times.begin(), times.end(), acc_chain);
	68	std::cout
	69	<< size << ", "
	70	<< get<Minimum>(acc_chain) << ", "
	71	<< get<Mean >(acc_chain) << ", "
	72	<< get<Maximum>(acc_chain) << ", "
	73	<< get<StdDev >(acc_chain) << std::endl;
	74	}
	75	}
	76
	77	template <unsigned int N>
	78	void testWorst()
	79	{
	80	std::cout << "# Benchmark for worst case with dim = " << N << ". ";
	81	std::cout << "All time measures in ms." << std::endl;
	82	std::cout << "# size, min, mean, max, std" << std::endl;
	83	for (int size = 1; size < 10000; size *= 2)
	84	{
	85	ArrayVector<double> times = constructPolytopeWorst<N>(size, 32);
	86	AccumulatorChain<
	87	MultiArrayIndex,
	88	Select<Minimum, Maximum, Mean, StdDev> > acc_chain;
	89	extractFeatures(times.begin(), times.end(), acc_chain);
	90	std::cout
	91	<< size << ", "
	92	<< get<Minimum>(acc_chain) << ", "
	93	<< get<Mean >(acc_chain) << ", "
	94	<< get<Maximum>(acc_chain) << ", "
	95	<< get<StdDev >(acc_chain) << std::endl;
	96	}
	97	}
	98
	99	template <unsigned int N>
	100	ArrayVector<double> constructPolytopeTypical(int size, int iterations) const
	101	{
	102	ArrayVector<double> ret;
	103	for (int iteration = 0; iteration < iterations; iteration++)
	104	{
	105	ret.push_back(constructPolytopeTypical<N>(size));
	106	}
	107	return ret;
	108	}
	109
	110	template <unsigned int N>
	111	double constructPolytopeTypical(int size) const
	112	{
	113	clock_type::time_point start = clock_type::now();
	114	// Construct the base polytope
	115	ConvexPolytope<N, double> poly;
	116	TinyVector<double, N> vec;
	117	poly.addVertex(vec);
	118	for (int n = 0; n < N; n++)
	119	{
	120	vec[n] = 1.;
	121	if (n > 0)
	122	{
	123	vec[n-1] = 0.;
	124	}
	125	poly.addVertex(vec);
	126	}
	127	poly.close();
	128
	129	// Add the vertices
	130	for (int n = 0; n < size; n++)
	131	{
	132	do
	133	{
	134	for (int dim = 0; dim < N; dim++)
	135	{
	136	vec[dim] = (2*rand() - 1)/static_cast<double>(RAND_MAX);
	137	}
	138	}
	139	while (vec.magnitude() > 1.);
	140	poly.addExtremeVertex(vec);
	141	}
	142	clock_type::time_point stop = clock_type::now();
	143	return chrono::duration_cast<chrono::microseconds>(stop - start).count();
	144	}
	145
	146	template <unsigned int N>
	147	ArrayVector<double> constructPolytopeWorst(int size, int iterations) const
	148	{
	149	ArrayVector<double> ret;
	150	for (int iteration = 0; iteration < iterations; iteration++)
	151	{
	152	ret.push_back(constructPolytopeWorst<N>(size));
	153	}
	154	return ret;
	155	}
	156
	157	template <unsigned int N>
	158	double constructPolytopeWorst(int size) const
	159	{
	160	clock_type::time_point start = clock_type::now();
	161	// Construct the base polytope
	162	ConvexPolytope<N, double> poly;
	163	TinyVector<double, N> vec;
	164	poly.addVertex(vec);
	165	for (int n = 0; n < N; n++)
	166	{
	167	vec[n] = 1.;
	168	if (n > 0)
	169	{
	170	vec[n-1] = 0.;
	171	}
	172	poly.addVertex(vec);
	173	}
	174	poly.close();
	175
	176	// Add the vertices
	177	for (int n = 0; n < size; n++)
	178	{
	179	for (int dim = 0; dim < N; dim++)
	180	{
	181	vec[dim] = (2*rand() - 1)/static_cast<double>(RAND_MAX);
	182	}
	183	vec /= norm(vec);
	184	poly.addExtremeVertex(vec);
	185	}
	186	clock_type::time_point stop = clock_type::now();
	187	return chrono::duration_cast<chrono::microseconds>(stop - start).count();
	188	}
	189	};
	190
	191	struct ConvexHullBenchmarkSuite : public test_suite
	192	{
	193	ConvexHullBenchmarkSuite()
	194	: test_suite("ConvexHullBenchmarkSuite")
	195	{
	196	// add(testCase(&ConvexHullBenchmark::testTypical<2>));
	197	// add(testCase(&ConvexHullBenchmark::testTypical<3>));
	198	// add(testCase(&ConvexHullBenchmark::testTypical<4>));
	199	add(testCase(&ConvexHullBenchmark::testWorst<2>));
	200	add(testCase(&ConvexHullBenchmark::testWorst<3>));
	201	add(testCase(&ConvexHullBenchmark::testWorst<4>));
	202	}
	203	};
	204
	205	} // namespace vigra
	206
	207	int main(int argc, char** argv)
	208	{
	209	vigra::ConvexHullBenchmarkSuite benchmark;
	210	const int failed = benchmark.run(vigra::testsToBeExecuted(argc, argv));
	211	std::cout << benchmark.report() << std::endl;
	212
	213	return failed != 0;
	214	}

+862

-0

test/polytope/test.cxx less more

	0	#define VIGRA_CHECK_BOUNDS
	1
	2	#include <limits>
	3	#include <algorithm>
	4	#include <cmath>
	5	#include <vigra/unittest.hxx>
	6	#include <vigra/multi_array.hxx>
	7	#include <vigra/polytope.hxx>
	8
	9
	10	namespace vigra
	11	{
	12
	13	template <class Iterable, class T>
	14	unsigned int count(const Iterable & vec, const T & value)
	15	{
	16	return std::count(
	17	vec.begin(),
	18	vec.end(),
	19	value);
	20	}
	21
	22	struct FloatStarPolytopeTest
	23	{
	24	typedef TinyVector<double, 2> Vector2;
	25	typedef TinyVector<double, 3> Vector3;
	26	typedef StarPolytope<2, double> Polytope2;
	27	typedef StarPolytope<3, double> Polytope3;
	28
	29	FloatStarPolytopeTest()
	30	: eps_(std::numeric_limits<double>::epsilon() * 3)
	31	{}
	32
	33	void testContains2D()
	34	{
	35	Polytope2 poly(
	36	Vector2(0. , 0. ),
	37	Vector2(1. , 0. ),
	38	Vector2(0. , 1. ),
	39	Vector2(0.25, 0.25));
	40	// Internal
	41	shouldEqual(poly.contains(Vector2(0.25, 0.25)), true);
	42	// External
	43	shouldEqual(poly.contains(Vector2(1. , 1. )), false);
	44	// Edge
	45	shouldEqual(poly.contains(Vector2(0.5 , 0. )), true);
	46	shouldEqual(poly.contains(Vector2(0. , 0.5 )), true);
	47	shouldEqual(poly.contains(Vector2(0.5 , 0.5 )), true);
	48	// Vertex
	49	shouldEqual(poly.contains(Vector2(0. , 0. )), true);
	50	shouldEqual(poly.contains(Vector2(1. , 0. )), true);
	51	shouldEqual(poly.contains(Vector2(0. , 1. )), true);
	52	}
	53
	54	void testContains3D()
	55	{
	56	Polytope3 poly(
	57	Vector3(0. , 0. , 0. ),
	58	Vector3(1. , 0. , 0. ),
	59	Vector3(0. , 1. , 0. ),
	60	Vector3(0. , 0. , 1. ),
	61	Vector3(0.25, 0.25, 0.25));
	62	// Internal
	63	shouldEqual(poly.contains(Vector3(0.25, 0.25, 0.25)), true);
	64	// External
	65	shouldEqual(poly.contains(Vector3(1. , 1. , 1. )), false);
	66	// Facet
	67	shouldEqual(poly.contains(Vector3(0. , 0.2 , 0.2)), true);
	68	shouldEqual(poly.contains(Vector3(0.2 , 0. , 0.2)), true);
	69	shouldEqual(poly.contains(Vector3(0.2 , 0.2 , 0. )), true);
	70	shouldEqual(poly.contains(Vector3(0.25, 0.25, 0.5)), true);
	71	// Edge
	72	shouldEqual(poly.contains(Vector3(0.5 , 0. , 0. )), true);
	73	shouldEqual(poly.contains(Vector3(0. , 0.5 , 0. )), true);
	74	shouldEqual(poly.contains(Vector3(0. , 0. , 0.5)), true);
	75	shouldEqual(poly.contains(Vector3(0. , 0.5 , 0.5)), true);
	76	shouldEqual(poly.contains(Vector3(0.5 , 0. , 0.5)), true);
	77	shouldEqual(poly.contains(Vector3(0.5 , 0.5 , 0.0)), true);
	78	// Vertex
	79	shouldEqual(poly.contains(Vector3(0. , 0. , 0. )), true);
	80	shouldEqual(poly.contains(Vector3(1. , 0. , 0. )), true);
	81	shouldEqual(poly.contains(Vector3(0. , 1. , 0. )), true);
	82	shouldEqual(poly.contains(Vector3(0. , 0. , 1. )), true);
	83	}
	84
	85	void testNVolume2D()
	86	{
	87	{
	88	Polytope2 poly(
	89	Vector2(0. , 0. ),
	90	Vector2(1. , 0. ),
	91	Vector2(0. , 1. ),
	92	Vector2(0.25, 0.25));
	93	shouldEqual(abs(poly.nVolume() - .5) < eps_, true);
	94	}
	95	{
	96	Polytope2 poly(
	97	Vector2(0.5 , 0.5 ),
	98	Vector2(0.5 , 1. ),
	99	Vector2(1. , 0.5 ),
	100	Vector2(0.6 , 0.6 ));
	101	shouldEqual(abs(poly.nVolume() - .125) < eps_, true);
	102	}
	103	}
	104
	105	void testNVolume3D()
	106	{
	107	{
	108	Polytope3 poly(
	109	Vector3(0. , 0. , 0. ),
	110	Vector3(1. , 0. , 0. ),
	111	Vector3(0. , 1. , 0. ),
	112	Vector3(0. , 0. , 1. ),
	113	Vector3(0.25, 0.25, 0.25));
	114	shouldEqual(abs(poly.nVolume() - 1./6.) < eps_, true);
	115	}
	116	{
	117	Polytope3 poly(
	118	Vector3(0.5 , 0.5 , 0.5 ),
	119	Vector3(1. , 0.5 , 0.5 ),
	120	Vector3(0.5 , 1. , 0.5 ),
	121	Vector3(0.5 , 0.5 , 1. ),
	122	Vector3(0.6 , 0.6 , 0.6 ));
	123	shouldEqual(abs(poly.nVolume() - 1./(6.*8.)) < eps_, true);
	124	}
	125	}
	126
	127	void testNSurface2D()
	128	{
	129	Polytope2 poly(
	130	Vector2(0. , 0. ),
	131	Vector2(1. , 0. ),
	132	Vector2(0. , 1. ),
	133	Vector2(0.25, 0.25));
	134	shouldEqual(abs(poly.nSurface() - (2. + sqrt(2.))) < eps_, true);
	135	}
	136
	137	void testNSurface3D()
	138	{
	139	Polytope3 poly(
	140	Vector3(0. , 0. , 0. ),
	141	Vector3(1. , 0. , 0. ),
	142	Vector3(0. , 1. , 0. ),
	143	Vector3(0. , 0. , 1. ),
	144	Vector3(0.25, 0.25, 0.25));
	145	const double surf = (3. + sqrt(3.)) / 2.;
	146	shouldEqual(abs(poly.nSurface() - surf) < eps_, true);
	147	}
	148
	149	void testClosed2D()
	150	{
	151	Polytope2 poly_closed(
	152	Vector2(0. , 0. ),
	153	Vector2(1. , 0. ),
	154	Vector2(0. , 1. ),
	155	Vector2(0.25, 0.25));
	156	shouldEqual(poly_closed.closed(), true);
	157
	158	Polytope2 poly_open(Vector2(0.25, 0.25));
	159	Polytope2::node_type n1 = poly_open.addVertex(Vector2(0, 0));
	160	Polytope2::node_type n2 = poly_open.addVertex(Vector2(1, 0));
	161	Polytope2::node_type n3 = poly_open.addVertex(Vector2(0, 1));
	162	Polytope2::node_type f1 = poly_open.addFacet(n1, n2);
	163	Polytope2::node_type f2 = poly_open.addFacet(n1, n3);
	164	shouldEqual(poly_open.closed(), false);
	165	shouldEqual(poly_open.closed(f1), false);
	166	shouldEqual(poly_open.closed(f2), false);
	167	}
	168
	169	void testClosed3D()
	170	{
	171	Polytope3 poly(Vector3(0.1, 0.1, 0.1));
	172	Polytope3::node_type n1 = poly.addVertex(Vector3(0, 0, 0));
	173	Polytope3::node_type n2 = poly.addVertex(Vector3(1, 0, 0));
	174	Polytope3::node_type n3 = poly.addVertex(Vector3(0, 1, 0));
	175	Polytope3::node_type n4 = poly.addVertex(Vector3(0, 0, 1));
	176	Polytope3::node_type f1 = poly.addFacet(n2, n3, n4);
	177	shouldEqual(poly.closed(), false);
	178	Polytope3::node_type f2 = poly.addFacet(n1, n3, n4);
	179	shouldEqual(poly.closed(), false);
	180	Polytope3::node_type f3 = poly.addFacet(n1, n2, n4);
	181	shouldEqual(poly.closed(), false);
	182	Polytope3::node_type f4 = poly.addFacet(n1, n2, n3);
	183	shouldEqual(poly.closed(), true);
	184	}
	185
	186	void testFill2D()
	187	{
	188	Polytope2 poly(
	189	Vector2(0. , 0. ),
	190	Vector2(1. , 0. ),
	191	Vector2(0. , 1. ),
	192	Vector2(0.25, 0.25));
	193	MultiArray<2, unsigned int> label_image(vigra::Shape2(5, 5));
	194	for (auto it = label_image.begin(); it != label_image.end(); it++)
	195	{
	196	*it = 0;
	197	}
	198	unsigned int ref[25] = {
	199	0, 0, 0, 0, 0,
	200	0, 0, 0, 0, 0,
	201	0, 0, 1, 1, 1,
	202	0, 0, 1, 1, 0,
	203	0, 0, 1, 0, 0};
	204	Vector2 offset(-1., -1.);
	205	Vector2 scale(0.5, 0.5);
	206	poly.fill(label_image, 1, offset, scale);
	207	shouldEqualSequence(label_image.begin(), label_image.end(), ref);
	208	}
	209
	210	void testLitFacets2D()
	211	{
	212	Polytope2 poly(Vector2(0.25, 0.25));
	213	Polytope2::node_type n1 = poly.addVertex(Vector2(0, 0));
	214	Polytope2::node_type n2 = poly.addVertex(Vector2(1, 0));
	215	Polytope2::node_type n3 = poly.addVertex(Vector2(0, 1));
	216	Polytope2::node_type f1 = poly.addFacet(n2, n3);
	217	Polytope2::node_type f2 = poly.addFacet(n1, n3);
	218	Polytope2::node_type f3 = poly.addFacet(n1, n2);
	219	auto lit_v1 = poly.litFacets(Vector2(-1. , -1. ));
	220	auto lit_v2 = poly.litFacets(Vector2( 2. , -0.5));
	221	auto lit_v3 = poly.litFacets(Vector2(-0.5, 2. ));
	222	auto lit_e1 = poly.litFacets(Vector2( 1. , 1. ));
	223	auto lit_e2 = poly.litFacets(Vector2(-2. , 0.5));
	224	auto lit_e3 = poly.litFacets(Vector2( 0.5, -2. ));
	225	auto lit0 = poly.litFacets(Vector2( 0.2, 0.2));
	226	shouldEqual(lit0.size(), 0);
	227	shouldEqual(lit_v1.size(), 2);
	228	shouldEqual(lit_v2.size(), 2);
	229	shouldEqual(lit_v3.size(), 2);
	230	shouldEqual(lit_e1.size(), 1);
	231	shouldEqual(lit_e2.size(), 1);
	232	shouldEqual(lit_e3.size(), 1);
	233	shouldEqual(count(lit_v1, f2), 1);
	234	shouldEqual(count(lit_v1, f3), 1);
	235	shouldEqual(count(lit_v2, f1), 1);
	236	shouldEqual(count(lit_v2, f3), 1);
	237	shouldEqual(count(lit_v3, f1), 1);
	238	shouldEqual(count(lit_v3, f2), 1);
	239	shouldEqual(count(lit_e1, f1), 1);
	240	shouldEqual(count(lit_e2, f2), 1);
	241	shouldEqual(count(lit_e3, f3), 1);
	242	}
	243
	244	void testFindNeighbor2D()
	245	{
	246	Polytope2 poly(Vector2(0.25, 0.25));
	247	Polytope2::node_type n1 = poly.addVertex(Vector2(0, 0));
	248	Polytope2::node_type n2 = poly.addVertex(Vector2(1, 0));
	249	Polytope2::node_type n3 = poly.addVertex(Vector2(0, 1));
	250	Polytope2::node_type f1 = poly.addFacet(n2, n3);
	251	{
	252	auto aligns1 = poly.aligns_map_[f1];
	253	shouldEqual(count(aligns1, lemon::INVALID), 2);
	254	}
	255	Polytope2::node_type f2 = poly.addFacet(n1, n3);
	256	{
	257	auto aligns1 = poly.aligns_map_[f1];
	258	auto aligns2 = poly.aligns_map_[f2];
	259	shouldEqual(count(aligns1, f2), 1);
	260	shouldEqual(count(aligns1, lemon::INVALID), 1);
	261	shouldEqual(count(aligns2, f1), 1);
	262	shouldEqual(count(aligns2, lemon::INVALID), 1);
	263	}
	264	Polytope2::node_type f3 = poly.addFacet(n1, n2);
	265	{
	266	auto aligns1 = poly.aligns_map_[f1];
	267	auto aligns2 = poly.aligns_map_[f2];
	268	auto aligns3 = poly.aligns_map_[f3];
	269	shouldEqual(count(aligns1, f2), 1);
	270	shouldEqual(count(aligns1, f3), 1);
	271	shouldEqual(count(aligns2, f1), 1);
	272	shouldEqual(count(aligns2, f3), 1);
	273	shouldEqual(count(aligns3, f2), 1);
	274	shouldEqual(count(aligns3, f1), 1);
	275	}
	276	}
	277
	278	void testFindNeighbor3D()
	279	{
	280	Polytope3 poly(Vector3(0.1, 0.1, 0.1));
	281	Polytope3::node_type n1 = poly.addVertex(Vector3(0, 0, 0));
	282	Polytope3::node_type n2 = poly.addVertex(Vector3(1, 0, 0));
	283	Polytope3::node_type n3 = poly.addVertex(Vector3(0, 1, 0));
	284	Polytope3::node_type n4 = poly.addVertex(Vector3(0, 0, 1));
	285	Polytope3::node_type f1 = poly.addFacet(n2, n3, n4);
	286	{
	287	auto aligns1 = poly.aligns_map_[f1];
	288	shouldEqual(count(aligns1, lemon::INVALID), 3);
	289	}
	290	Polytope3::node_type f2 = poly.addFacet(n1, n3, n4);
	291	{
	292	auto aligns1 = poly.aligns_map_[f1];
	293	auto aligns2 = poly.aligns_map_[f2];
	294	shouldEqual(count(aligns1, f2), 1);
	295	shouldEqual(count(aligns1, lemon::INVALID), 2);
	296	shouldEqual(count(aligns2, f1), 1);
	297	shouldEqual(count(aligns2, lemon::INVALID), 2);
	298	}
	299	Polytope3::node_type f3 = poly.addFacet(n1, n2, n4);
	300	{
	301	auto aligns1 = poly.aligns_map_[f1];
	302	auto aligns2 = poly.aligns_map_[f2];
	303	auto aligns3 = poly.aligns_map_[f3];
	304
	305	shouldEqual(count(aligns1, f2), 1);
	306	shouldEqual(count(aligns1, f3), 1);
	307	shouldEqual(count(aligns1, lemon::INVALID), 1);
	308	shouldEqual(count(aligns2, f1), 1);
	309	shouldEqual(count(aligns2, f3), 1);
	310	shouldEqual(count(aligns2, lemon::INVALID), 1);
	311	shouldEqual(count(aligns3, f1), 1);
	312	shouldEqual(count(aligns3, f2), 1);
	313	shouldEqual(count(aligns3, lemon::INVALID), 1);
	314	}
	315	Polytope3::node_type f4 = poly.addFacet(n1, n2, n3);
	316	{
	317	auto aligns1 = poly.aligns_map_[f1];
	318	auto aligns2 = poly.aligns_map_[f2];
	319	auto aligns3 = poly.aligns_map_[f3];
	320	auto aligns4 = poly.aligns_map_[f4];
	321	shouldEqual(count(aligns1, f2), 1);
	322	shouldEqual(count(aligns1, f3), 1);
	323	shouldEqual(count(aligns1, f4), 1);
	324	shouldEqual(count(aligns2, f1), 1);
	325	shouldEqual(count(aligns2, f3), 1);
	326	shouldEqual(count(aligns2, f4), 1);
	327	shouldEqual(count(aligns3, f1), 1);
	328	shouldEqual(count(aligns3, f2), 1);
	329	shouldEqual(count(aligns3, f4), 1);
	330	shouldEqual(count(aligns4, f1), 1);
	331	shouldEqual(count(aligns4, f2), 1);
	332	shouldEqual(count(aligns4, f3), 1);
	333	}
	334	}
	335
	336	double eps_;
	337	};
	338
	339	struct IntStarPolytopeTest
	340	{
	341	typedef TinyVector<int, 2> Vector2;
	342	typedef TinyVector<int, 3> Vector3;
	343	typedef StarPolytope<2, int> Polytope2;
	344	typedef StarPolytope<3, int> Polytope3;
	345	typedef NumericTraits<int>::RealPromote RealPromote;
	346
	347	IntStarPolytopeTest()
	348	: eps_(std::numeric_limits<RealPromote>::epsilon() * 2)
	349	{}
	350
	351	void testContains2D()
	352	{
	353	Polytope2 poly(
	354	Vector2(0, 0),
	355	Vector2(4, 0),
	356	Vector2(0, 2),
	357	Vector2(1, 1));
	358	// Internal
	359	shouldEqual(poly.contains(Vector2( 1, 1)), true);
	360	// External
	361	shouldEqual(poly.contains(Vector2( 3, 1)), false);
	362	shouldEqual(poly.contains(Vector2(-1, 1)), false);
	363	shouldEqual(poly.contains(Vector2( 2, -1)), false);
	364	// Edge
	365	shouldEqual(poly.contains(Vector2( 2, 1)), true);
	366	shouldEqual(poly.contains(Vector2( 0, 1)), true);
	367	shouldEqual(poly.contains(Vector2( 2, 0)), true);
	368	// Vertex
	369	shouldEqual(poly.contains(Vector2( 0, 0)), true);
	370	shouldEqual(poly.contains(Vector2( 4, 0)), true);
	371	shouldEqual(poly.contains(Vector2( 0, 2)), true);
	372	}
	373
	374	void testContains3D()
	375	{
	376	Polytope3 poly(
	377	Vector3( 0, 0, 0),
	378	Vector3( 6, 0, 0),
	379	Vector3( 0, 6, 0),
	380	Vector3( 0, 0, 6),
	381	Vector3( 1, 1, 1));
	382	// Internal
	383	shouldEqual(poly.contains(Vector3( 1, 1, 1)), true);
	384	// External
	385	shouldEqual(poly.contains(Vector3( 6, 6, 6)), false);
	386	// Facet
	387	shouldEqual(poly.contains(Vector3( 2, 2, 2)), true);
	388	shouldEqual(poly.contains(Vector3( 0, 1, 1)), true);
	389	shouldEqual(poly.contains(Vector3( 1, 0, 1)), true);
	390	shouldEqual(poly.contains(Vector3( 1, 1, 0)), true);
	391	// Edge
	392	shouldEqual(poly.contains(Vector3( 1, 0, 0)), true);
	393	shouldEqual(poly.contains(Vector3( 0, 1, 0)), true);
	394	shouldEqual(poly.contains(Vector3( 0, 0, 1)), true);
	395	shouldEqual(poly.contains(Vector3( 0, 3, 3)), true);
	396	shouldEqual(poly.contains(Vector3( 3, 0, 3)), true);
	397	shouldEqual(poly.contains(Vector3( 3, 3, 0)), true);
	398	// Vertex
	399	shouldEqual(poly.contains(Vector3( 0, 0, 0)), true);
	400	shouldEqual(poly.contains(Vector3( 6, 0, 0)), true);
	401	shouldEqual(poly.contains(Vector3( 0, 6, 0)), true);
	402	shouldEqual(poly.contains(Vector3( 0, 0, 6)), true);
	403	}
	404
	405	void testNVolume2D()
	406	{
	407	{
	408	Polytope2 poly(
	409	Vector2( 0, 0),
	410	Vector2( 3, 0),
	411	Vector2( 0, 3),
	412	Vector2( 1, 1));
	413	RealPromote n_volume = poly.nVolume();
	414	shouldEqualTolerance(n_volume, 4.5, eps_);
	415	}
	416	{
	417	Polytope2 poly(
	418	Vector2( 1, 1),
	419	Vector2( 4, 1),
	420	Vector2( 1, 4),
	421	Vector2( 2, 2));
	422	shouldEqualTolerance(poly.nVolume(), 4.5, eps_);
	423	}
	424	}
	425
	426	void testNVolume3D()
	427	{
	428	{
	429	Polytope3 poly(
	430	Vector3(0, 0, 0),
	431	Vector3(6, 0, 0),
	432	Vector3(0, 6, 0),
	433	Vector3(0, 0, 6),
	434	Vector3(1, 1, 1));
	435	shouldEqualTolerance(poly.nVolume(), 36., eps_);
	436	}
	437	{
	438	Polytope3 poly(
	439	Vector3(1, 1, 1),
	440	Vector3(7, 1, 1),
	441	Vector3(1, 7, 1),
	442	Vector3(1, 1, 7),
	443	Vector3(2, 2, 2));
	444	shouldEqualTolerance(poly.nVolume(), 36., eps_);
	445	}
	446	}
	447
	448	void testNSurface2D()
	449	{
	450	Polytope2 poly(
	451	Vector2(0, 0),
	452	Vector2(3, 0),
	453	Vector2(0, 3),
	454	Vector2(1, 1));
	455	const RealPromote surf = 2 * 3 + 3 * sqrt(2);
	456	shouldEqualTolerance(poly.nSurface(), surf, eps_);
	457	}
	458
	459	void testNSurface3D()
	460	{
	461	Polytope3 poly(
	462	Vector3(0, 0, 0),
	463	Vector3(6, 0, 0),
	464	Vector3(0, 6, 0),
	465	Vector3(0, 0, 6),
	466	Vector3(1, 1, 1));
	467	const RealPromote surf = 6 * 6 * (3. + sqrt(3.)) / 2.;
	468	shouldEqualTolerance(poly.nSurface(), surf, eps_);
	469	}
	470
	471	void testClosed2D()
	472	{
	473	Polytope2 poly_closed(
	474	Vector2(0, 0),
	475	Vector2(3, 0),
	476	Vector2(0, 3),
	477	Vector2(1, 1));
	478	shouldEqual(poly_closed.closed(), true);
	479
	480	Polytope2 poly_open(Vector2(1, 1));
	481	Polytope2::node_type n1 = poly_open.addVertex(Vector2(0, 0));
	482	Polytope2::node_type n2 = poly_open.addVertex(Vector2(3, 0));
	483	Polytope2::node_type n3 = poly_open.addVertex(Vector2(0, 3));
	484	Polytope2::node_type f1 = poly_open.addFacet(n1, n2);
	485	Polytope2::node_type f2 = poly_open.addFacet(n1, n3);
	486	shouldEqual(poly_open.closed(), false);
	487	shouldEqual(poly_open.closed(f1), false);
	488	shouldEqual(poly_open.closed(f2), false);
	489	}
	490
	491	void testClosed3D()
	492	{
	493	Polytope3 poly(Vector3(1, 1, 1));
	494	Polytope3::node_type n1 = poly.addVertex(Vector3(0, 0, 0));
	495	Polytope3::node_type n2 = poly.addVertex(Vector3(6, 0, 0));
	496	Polytope3::node_type n3 = poly.addVertex(Vector3(0, 6, 0));
	497	Polytope3::node_type n4 = poly.addVertex(Vector3(0, 0, 6));
	498	Polytope3::node_type f1 = poly.addFacet(n2, n3, n4);
	499	shouldEqual(poly.closed(), false);
	500	Polytope3::node_type f2 = poly.addFacet(n1, n3, n4);
	501	shouldEqual(poly.closed(), false);
	502	Polytope3::node_type f3 = poly.addFacet(n1, n2, n4);
	503	shouldEqual(poly.closed(), false);
	504	Polytope3::node_type f4 = poly.addFacet(n1, n2, n3);
	505	shouldEqual(poly.closed(), true);
	506	}
	507
	508	// void testLitFacets2D()
	509	// {
	510	// Polytope2 poly(Vector2(0.25, 0.25));
	511	// Polytope2::node_type n1 = poly.addVertex(Vector2(0, 0));
	512	// Polytope2::node_type n2 = poly.addVertex(Vector2(1, 0));
	513	// Polytope2::node_type n3 = poly.addVertex(Vector2(0, 1));
	514	// Polytope2::node_type f1 = poly.addFacet(n2, n3);
	515	// Polytope2::node_type f2 = poly.addFacet(n1, n3);
	516	// Polytope2::node_type f3 = poly.addFacet(n1, n2);
	517	// auto lit_v1 = poly.litFacets(Vector2(-1. , -1. ));
	518	// auto lit_v2 = poly.litFacets(Vector2( 2. , -0.5));
	519	// auto lit_v3 = poly.litFacets(Vector2(-0.5, 2. ));
	520	// auto lit_e1 = poly.litFacets(Vector2( 1. , 1. ));
	521	// auto lit_e2 = poly.litFacets(Vector2(-2. , 0.5));
	522	// auto lit_e3 = poly.litFacets(Vector2( 0.5, -2. ));
	523	// auto lit0 = poly.litFacets(Vector2( 0.2, 0.2));
	524	// shouldEqual(lit0.size(), 0);
	525	// shouldEqual(lit_v1.size(), 2);
	526	// shouldEqual(lit_v2.size(), 2);
	527	// shouldEqual(lit_v3.size(), 2);
	528	// shouldEqual(lit_e1.size(), 1);
	529	// shouldEqual(lit_e2.size(), 1);
	530	// shouldEqual(lit_e3.size(), 1);
	531	// shouldEqual(std::count(lit_v1.begin(), lit_v1.end(), f2), 1);
	532	// shouldEqual(std::count(lit_v1.begin(), lit_v1.end(), f3), 1);
	533	// shouldEqual(std::count(lit_v2.begin(), lit_v2.end(), f1), 1);
	534	// shouldEqual(std::count(lit_v2.begin(), lit_v2.end(), f3), 1);
	535	// shouldEqual(std::count(lit_v3.begin(), lit_v3.end(), f1), 1);
	536	// shouldEqual(std::count(lit_v3.begin(), lit_v3.end(), f2), 1);
	537	// shouldEqual(std::count(lit_e1.begin(), lit_e1.end(), f1), 1);
	538	// shouldEqual(std::count(lit_e2.begin(), lit_e2.end(), f2), 1);
	539	// shouldEqual(std::count(lit_e3.begin(), lit_e3.end(), f3), 1);
	540	// }
	541
	542	// void testFindNeighbor2D()
	543	// {
	544	// Polytope2 poly(Vector2(0.25, 0.25));
	545	// Polytope2::node_type n1 = poly.addVertex(Vector2(0, 0));
	546	// Polytope2::node_type n2 = poly.addVertex(Vector2(1, 0));
	547	// Polytope2::node_type n3 = poly.addVertex(Vector2(0, 1));
	548	// Polytope2::node_type f1 = poly.addFacet(n2, n3);
	549	// {
	550	// auto aligns1 = poly.aligns_map_[f1];
	551	// shouldEqual(aligns1.size(), 0);
	552	// }
	553	// Polytope2::node_type f2 = poly.addFacet(n1, n3);
	554	// {
	555	// auto aligns1 = poly.aligns_map_[f1];
	556	// auto aligns2 = poly.aligns_map_[f2];
	557	// shouldEqual(aligns1.size(), 1);
	558	// shouldEqual(aligns1.count(f2), 1);
	559	// shouldEqual(aligns2.size(), 1);
	560	// shouldEqual(aligns2.count(f1), 1);
	561	// }
	562	// Polytope2::node_type f3 = poly.addFacet(n1, n2);
	563	// {
	564	// auto aligns1 = poly.aligns_map_[f1];
	565	// auto aligns2 = poly.aligns_map_[f2];
	566	// auto aligns3 = poly.aligns_map_[f3];
	567	// shouldEqual(aligns1.size(), 2);
	568	// shouldEqual(aligns1.count(f2), 1);
	569	// shouldEqual(aligns1.count(f3), 1);
	570	// shouldEqual(aligns2.size(), 2);
	571	// shouldEqual(aligns2.count(f1), 1);
	572	// shouldEqual(aligns2.count(f3), 1);
	573	// shouldEqual(aligns3.size(), 2);
	574	// shouldEqual(aligns3.count(f2), 1);
	575	// shouldEqual(aligns3.count(f1), 1);
	576	// }
	577	// }
	578
	579	// void testFindNeighbor3D()
	580	// {
	581	// Polytope3 poly(Vector3(0.1, 0.1, 0.1));
	582	// Polytope3::node_type n1 = poly.addVertex(Vector3(0, 0, 0));
	583	// Polytope3::node_type n2 = poly.addVertex(Vector3(1, 0, 0));
	584	// Polytope3::node_type n3 = poly.addVertex(Vector3(0, 1, 0));
	585	// Polytope3::node_type n4 = poly.addVertex(Vector3(0, 0, 1));
	586	// Polytope3::node_type f1 = poly.addFacet(n2, n3, n4);
	587	// {
	588	// auto aligns1 = poly.aligns_map_[f1];
	589	// shouldEqual(aligns1.size(), 0);
	590	// }
	591	// Polytope3::node_type f2 = poly.addFacet(n1, n3, n4);
	592	// {
	593	// auto aligns1 = poly.aligns_map_[f1];
	594	// auto aligns2 = poly.aligns_map_[f2];
	595	// shouldEqual(aligns1.size(), 1);
	596	// shouldEqual(aligns1.count(f2), 1);
	597	// shouldEqual(aligns2.size(), 1);
	598	// shouldEqual(aligns2.count(f1), 1);
	599	// }
	600	// Polytope3::node_type f3 = poly.addFacet(n1, n2, n4);
	601	// {
	602	// auto aligns1 = poly.aligns_map_[f1];
	603	// auto aligns2 = poly.aligns_map_[f2];
	604	// auto aligns3 = poly.aligns_map_[f3];
	605
	606	// shouldEqual(aligns1.size(), 2);
	607	// shouldEqual(aligns1.count(f2), 1);
	608	// shouldEqual(aligns1.count(f3), 1);
	609	// shouldEqual(aligns2.size(), 2);
	610	// shouldEqual(aligns2.count(f1), 1);
	611	// shouldEqual(aligns2.count(f3), 1);
	612	// shouldEqual(aligns3.size(), 2);
	613	// shouldEqual(aligns3.count(f1), 1);
	614	// shouldEqual(aligns3.count(f2), 1);
	615	// }
	616	// Polytope3::node_type f4 = poly.addFacet(n1, n2, n3);
	617	// {
	618	// auto aligns1 = poly.aligns_map_[f1];
	619	// auto aligns2 = poly.aligns_map_[f2];
	620	// auto aligns3 = poly.aligns_map_[f3];
	621	// auto aligns4 = poly.aligns_map_[f4];
	622	// shouldEqual(aligns1.size(), 3);
	623	// shouldEqual(aligns1.count(f2), 1);
	624	// shouldEqual(aligns1.count(f3), 1);
	625	// shouldEqual(aligns1.count(f4), 1);
	626	// shouldEqual(aligns2.size(), 3);
	627	// shouldEqual(aligns2.count(f1), 1);
	628	// shouldEqual(aligns2.count(f3), 1);
	629	// shouldEqual(aligns2.count(f4), 1);
	630	// shouldEqual(aligns3.size(), 3);
	631	// shouldEqual(aligns3.count(f1), 1);
	632	// shouldEqual(aligns3.count(f2), 1);
	633	// shouldEqual(aligns3.count(f4), 1);
	634	// shouldEqual(aligns4.size(), 3);
	635	// shouldEqual(aligns4.count(f1), 1);
	636	// shouldEqual(aligns4.count(f2), 1);
	637	// shouldEqual(aligns4.count(f3), 1);
	638	// }
	639	// }
	640
	641	RealPromote eps_;
	642	};
	643
	644	struct FloatConvexPolytopeTest
	645	{
	646	typedef TinyVector<double, 2> Vector2;
	647	typedef TinyVector<double, 3> Vector3;
	648	typedef ConvexPolytope<2, double> Polytope2;
	649	typedef ConvexPolytope<3, double> Polytope3;
	650
	651	FloatConvexPolytopeTest()
	652	: eps_(std::numeric_limits<double>::epsilon() * 3)
	653	{}
	654
	655	void testAddExtremeVertex2D()
	656	{
	657	const int N = 100;
	658	Polytope2 poly(
	659	Vector2( 1., 0.),
	660	Vector2(-1., 0.),
	661	Vector2( 0., 1.));
	662	poly.addExtremeVertex(Vector2( 0., -1.));
	663	shouldEqualTolerance(poly.nVolume(), 2., eps_);
	664	shouldEqualTolerance(poly.nSurface(), 4. * std::sqrt(2.), eps_);
	665	for (int n = 0; n < N; n++)
	666	{
	667	Vector2 vec(
	668	std::cos(2M_PIn/N),
	669	std::sin(2M_PIn/N));
	670	shouldEqualTolerance(vec.magnitude(), 1., eps_);
	671	poly.addExtremeVertex(vec);
	672	shouldEqual(poly.closed(), true);
	673	}
	674	const double sur_tgt = 2.Nstd::sin(M_PI / N);
	675	shouldEqualTolerance(poly.nSurface(), sur_tgt, eps_);
	676	const double vol_tgt = 1.Nstd::sin(M_PI / N) * std::cos(M_PI / N);
	677	shouldEqualTolerance(poly.nVolume(), vol_tgt, eps_);
	678	for (int n = 0; n < 100; n++)
	679	{
	680	Vector2 vec(
	681	(2*rand() - 1)/static_cast<double>(RAND_MAX),
	682	(2*rand() - 1)/static_cast<double>(RAND_MAX));
	683	if (vec.magnitude() > 1)
	684	{
	685	shouldEqual(poly.contains(vec), false);
	686	}
	687	else if (vec.magnitude() < std::cos(M_PI / N))
	688	{
	689	shouldEqual(poly.contains(vec), true);
	690	}
	691	}
	692	}
	693
	694	void testAddExtremeVertex3D()
	695	{
	696	const int N = 100;
	697	Polytope3 poly(
	698	Vector3( 1., 0., 1.),
	699	Vector3(-1., 0., 1.),
	700	Vector3( 0., 1., 1.),
	701	Vector3( 0., 0., 0.));
	702	for (int n = 0; n < N; n++)
	703	{
	704	Vector3 vec(
	705	std::cos(2M_PIn/N),
	706	std::sin(2M_PIn/N),
	707	1.);
	708	poly.addExtremeVertex(vec);
	709	shouldEqual(poly.closed(), true);
	710	}
	711	const double sur_tgt = N * std::sin(M_PI / N) * (
	712	std::cos(M_PI / N) + std::sqrt(
	713	std::cos(M_PI / N) * std::cos(M_PI / N) + 1.));
	714	shouldEqualTolerance(poly.nSurface(), sur_tgt, eps_ * N);
	715	const double vol_tgt = N * std::sin(M_PI / N) * std::cos(M_PI / N) / 3.;
	716	shouldEqualTolerance(poly.nVolume(), vol_tgt, eps_ * N);
	717	for (int n = 0; n < 100; n++)
	718	{
	719	Vector3 vec(
	720	(2*rand() - 1)/static_cast<double>(RAND_MAX),
	721	(2*rand() - 1)/static_cast<double>(RAND_MAX),
	722	rand()/static_cast<double>(RAND_MAX));
	723	double dist = std::sqrt(vec[0] * vec[0] + vec[1] * vec[1]);
	724	if (dist > vec[2])
	725	{
	726	shouldEqual(poly.contains(vec), false);
	727	}
	728	else if (dist < (vec[2] * std::cos(M_PI / N)))
	729	{
	730	shouldEqual(poly.contains(vec), true);
	731	}
	732	}
	733	}
	734
	735	void testAddNonExtremeVertex2D()
	736	{
	737	const int N = 1000;
	738	const double eps = 4. / sqrt(N);
	739	Polytope2 poly(
	740	Vector2( 1., 0.),
	741	Vector2(-1., 0.),
	742	Vector2( 0., 1.));
	743	poly.addExtremeVertex(Vector2(0., -1.));
	744	shouldEqual(abs(poly.nVolume() - 2.) < eps_, true);
	745	shouldEqual(abs(poly.nSurface() - 4. * sqrt(2.)) < eps, true);
	746	for (int n = 0; n < N; n++)
	747	{
	748	Vector2 vec(
	749	(2*rand() - 1)/static_cast<double>(RAND_MAX),
	750	(2*rand() - 1)/static_cast<double>(RAND_MAX));
	751	if (vec.magnitude() <= 1.)
	752	{
	753	poly.addExtremeVertex(vec);
	754	shouldEqual(poly.closed(), true);
	755	}
	756	}
	757	const double sur_err = (2M_PI - poly.nSurface()) / (2.M_PI);
	758	shouldEqual(sur_err < eps, true);
	759	shouldEqual(sur_err > 0, true);
	760	const double vol_err = (M_PI - poly.nVolume()) / (M_PI);
	761	shouldEqualTolerance(vol_err, 0, eps);
	762	shouldEqual(vol_err > 0, true);
	763	for (int n = 0; n < 100; n++)
	764	{
	765	Vector2 vec(
	766	(2*rand() - 1)/static_cast<double>(RAND_MAX),
	767	(2*rand() - 1)/static_cast<double>(RAND_MAX));
	768	if (abs(vec.magnitude() - 1) > eps)
	769	{
	770	shouldEqual(poly.contains(vec), vec.magnitude() < 1.);
	771	}
	772	}
	773	}
	774
	775	void testAddNonExtremeVertex3D()
	776	{
	777	const int N = 1000;
	778	const double eps = 9. / sqrt(N);
	779	Polytope3 poly(
	780	Vector3( 1., 0., 0.),
	781	Vector3(-1., 0., 0.),
	782	Vector3( 0., 1., 0.),
	783	Vector3( 0., 0., 1.));
	784	for (int n = 0; n < N; n++)
	785	{
	786	Vector3 vec(
	787	(2*rand() - 1)/static_cast<double>(RAND_MAX),
	788	(2*rand() - 1)/static_cast<double>(RAND_MAX),
	789	(2*rand() - 1)/static_cast<double>(RAND_MAX));
	790	if (vec.magnitude() <= 1.)
	791	{
	792	poly.addExtremeVertex(vec);
	793	shouldEqual(poly.closed(), true);
	794	}
	795	}
	796	const double sur_err = (4.M_PI - poly.nSurface()) / (4.M_PI);
	797	shouldEqualTolerance(sur_err, 0, eps);
	798	shouldEqual(sur_err > 0, true);
	799	const double vol_err = (4./3.M_PI - poly.nVolume()) / (4./3.M_PI);
	800	shouldEqualTolerance(vol_err, 0, eps);
	801	shouldEqual(vol_err > 0, true);
	802	for (int n = 0; n < 100; n++)
	803	{
	804	Vector3 vec(
	805	(2*rand() - 1)/static_cast<double>(RAND_MAX),
	806	(2*rand() - 1)/static_cast<double>(RAND_MAX),
	807	(2*rand() - 1)/static_cast<double>(RAND_MAX));
	808	if (abs(vec.magnitude() - 1) > eps)
	809	{
	810	shouldEqual(poly.contains(vec), vec.magnitude() < 1.);
	811	}
	812	}
	813	}
	814
	815	double eps_;
	816	};
	817
	818	struct PolytopeTestSuite : public vigra::test_suite
	819	{
	820	PolytopeTestSuite() : vigra::test_suite("PolytopeTestSuite")
	821	{
	822	add(testCase(&FloatStarPolytopeTest::testClosed2D));
	823	add(testCase(&FloatStarPolytopeTest::testClosed3D));
	824	add(testCase(&FloatStarPolytopeTest::testContains2D));
	825	add(testCase(&FloatStarPolytopeTest::testContains3D));
	826	add(testCase(&FloatStarPolytopeTest::testFill2D));
	827	add(testCase(&FloatStarPolytopeTest::testFindNeighbor2D));
	828	add(testCase(&FloatStarPolytopeTest::testFindNeighbor3D));
	829	add(testCase(&FloatStarPolytopeTest::testLitFacets2D));
	830	add(testCase(&FloatStarPolytopeTest::testNSurface2D));
	831	add(testCase(&FloatStarPolytopeTest::testNSurface3D));
	832	add(testCase(&FloatStarPolytopeTest::testNVolume2D));
	833	add(testCase(&FloatStarPolytopeTest::testNVolume3D));
	834	add(testCase(&FloatConvexPolytopeTest::testAddExtremeVertex2D));
	835	add(testCase(&FloatConvexPolytopeTest::testAddExtremeVertex3D));
	836	/*
	837	add(testCase(&FloatConvexPolytopeTest::testAddNonExtremeVertex2D));
	838	add(testCase(&FloatConvexPolytopeTest::testAddNonExtremeVertex3D));
	839	*/
	840	add(testCase(&IntStarPolytopeTest::testClosed2D));
	841	add(testCase(&IntStarPolytopeTest::testClosed3D));
	842	add(testCase(&IntStarPolytopeTest::testContains2D));
	843	add(testCase(&IntStarPolytopeTest::testContains3D));
	844	add(testCase(&IntStarPolytopeTest::testNSurface2D));
	845	add(testCase(&IntStarPolytopeTest::testNSurface3D));
	846	add(testCase(&IntStarPolytopeTest::testNVolume2D));
	847	add(testCase(&IntStarPolytopeTest::testNVolume3D));
	848	}
	849	};
	850
	851	} // namespace vigra
	852
	853	int main(int argc, char** argv)
	854	{
	855	vigra::PolytopeTestSuite test;
	856	const int failed = test.run(vigra::testsToBeExecuted(argc, argv));
	857	std::cerr << test.report() << std::endl;
	858
	859	return failed != 0;
	860	}
	861

+16

-0

test/random_forest_3/CMakeLists.txt less more

	0	VIGRA_CONFIGURE_THREADING()
	1
	2	if(THREADING_FOUND)
	3	if(HDF5_FOUND)
	4	INCLUDE_DIRECTORIES(${HDF5_INCLUDE_DIR})
	5	ADD_DEFINITIONS(${HDF5_CPPFLAGS} -DHasHDF5)
	6	VIGRA_ADD_TEST(test_random_forest_new test.cxx LIBRARIES ${THREADING_LIBRARIES} vigraimpex ${HDF5_LIBRARIES})
	7	else()
	8	VIGRA_ADD_TEST(test_random_forest_new test.cxx)
	9	endif()
	10	else()
	11	MESSAGE(STATUS "** WARNING: No threading implementation found.")
	12	MESSAGE(STATUS "** test_random_forest_new will not be executed on this platform.")
	13	endif()
	14
	15	add_subdirectory(data)

+1

-0

test/random_forest_3/data/CMakeLists.txt less more

0

VIGRA_COPY_TEST_DATA(rf.h5)

test/random_forest_3/data/rf.h5 less more

Binary diff not shown

+284

-0

test/random_forest_3/test.cxx less more

	0	/************************************************************************/
	1	/* */
	2	/* Copyright 2014-2015 by Ullrich Koethe and Philip Schill */
	3	/* */
	4	/* This file is part of the VIGRA computer vision library. */
	5	/* The VIGRA Website is */
	6	/* http://hci.iwr.uni-heidelberg.de/vigra/ */
	7	/* Please direct questions, bug reports, and contributions to */
	8	/* ullrich.koethe@iwr.uni-heidelberg.de or */
	9	/* vigra@informatik.uni-hamburg.de */
	10	/* */
	11	/* Permission is hereby granted, free of charge, to any person */
	12	/* obtaining a copy of this software and associated documentation */
	13	/* files (the "Software"), to deal in the Software without */
	14	/* restriction, including without limitation the rights to use, */
	15	/* copy, modify, merge, publish, distribute, sublicense, and/or */
	16	/* sell copies of the Software, and to permit persons to whom the */
	17	/* Software is furnished to do so, subject to the following */
	18	/* conditions: */
	19	/* */
	20	/* The above copyright notice and this permission notice shall be */
	21	/* included in all copies or substantial portions of the */
	22	/* Software. */
	23	/* */
	24	/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND */
	25	/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES */
	26	/* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND */
	27	/* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT */
	28	/* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, */
	29	/* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING */
	30	/* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR */
	31	/* OTHER DEALINGS IN THE SOFTWARE. */
	32	/* */
	33	/************************************************************************/
	34	#include <vigra/unittest.hxx>
	35	#include <vigra/random_forest_3.hxx>
	36	#include <vigra/random.hxx>
	37	#ifdef HasHDF5
	38	#include <vigra/random_forest_3_hdf5_impex.hxx>
	39	#endif
	40
	41	using namespace vigra;
	42	using namespace vigra::rf3;
	43
	44	struct RandomForestTests
	45	{
	46	void test_base_class()
	47	{
	48	typedef BinaryForest Graph;
	49	typedef Graph::Node Node;
	50	typedef LessEqualSplitTest<double> SplitTest;
	51	typedef ArgMaxAcc Acc;
	52	typedef RandomForest<MultiArray<2, double>, MultiArray<1, int>, SplitTest, Acc> RF;
	53
	54	// Build a forest from scratch.
	55	Graph gr;
	56	RF::NodeMap<SplitTest>::type split_tests;
	57	RF::NodeMap<size_t>::type leaf_responses;
	58	{
	59	Node n0 = gr.addNode();
	60	Node n1 = gr.addNode();
	61	Node n2 = gr.addNode();
	62	Node n3 = gr.addNode();
	63	Node n4 = gr.addNode();
	64	Node n5 = gr.addNode();
	65	Node n6 = gr.addNode();
	66	gr.addArc(n0, n1);
	67	gr.addArc(n0, n2);
	68	gr.addArc(n1, n3);
	69	gr.addArc(n1, n4);
	70	gr.addArc(n2, n5);
	71	gr.addArc(n2, n6);
	72
	73	split_tests.insert(n0, SplitTest(0, 0.6));
	74	split_tests.insert(n1, SplitTest(1, 0.25));
	75	split_tests.insert(n2, SplitTest(1, 0.75));
	76	leaf_responses.insert(n3, 0);
	77	leaf_responses.insert(n3, 0);
	78	leaf_responses.insert(n4, 1);
	79	leaf_responses.insert(n5, 2);
	80	leaf_responses.insert(n6, 3);
	81	}
	82	std::vector<int> distinct_labels;
	83	distinct_labels.push_back(0);
	84	distinct_labels.push_back(1);
	85	distinct_labels.push_back(-7);
	86	distinct_labels.push_back(3);
	87	auto const pspec = ProblemSpec<int>().num_features(2).distinct_classes(distinct_labels);
	88	RF rf = RF(gr, split_tests, leaf_responses, pspec);
	89
	90	// Check if the given points are predicted correctly.
	91	double test_x_values[] = {
	92	0.2, 0.4, 0.2, 0.4, 0.7, 0.8, 0.7, 0.8,
	93	0.2, 0.2, 0.7, 0.7, 0.2, 0.2, 0.8, 0.8
	94	};
	95	MultiArray<2, double> test_x(Shape2(8, 2), test_x_values);
	96	int test_y_values[] = {
	97	0, 0, 1, 1, -7, -7, 3, 3
	98	};
	99	MultiArray<1, int> test_y(Shape1(8), test_y_values);
	100	MultiArray<1, int> pred_y(Shape1(8));
	101	rf.predict(test_x, pred_y, 1);
	102	shouldEqualSequence(pred_y.begin(), pred_y.end(), test_y.begin());
	103	}
	104
	105	void test_default_rf()
	106	{
	107	typedef MultiArray<2, double> Features;
	108	typedef MultiArray<1, int> Labels;
	109
	110	double train_x_values[] = {
	111	0.2, 0.4, 0.2, 0.4, 0.7, 0.8, 0.7, 0.8,
	112	0.2, 0.2, 0.7, 0.7, 0.2, 0.2, 0.8, 0.8
	113	};
	114	Features train_x(Shape2(8, 2), train_x_values);
	115	int train_y_values[] = {
	116	0, 0, 1, 1, -7, -7, 3, 3
	117	};
	118	Labels train_y(Shape1(8), train_y_values);
	119	Features test_x(train_x);
	120	Labels test_y(train_y);
	121
	122	std::vector<RandomForestOptionTags> splits;
	123	splits.push_back(RF_GINI);
	124	splits.push_back(RF_ENTROPY);
	125	splits.push_back(RF_KSD);
	126	for (auto split : splits)
	127	{
	128	RandomForestOptions const options = RandomForestOptions()
	129	.tree_count(1)
	130	.bootstrap_sampling(false)
	131	.split(split)
	132	.n_threads(1);
	133	auto rf = random_forest(train_x, train_y, options);
	134	Labels pred_y(test_y.shape());
	135	rf.predict(test_x, pred_y, 1);
	136	shouldEqualSequence(pred_y.begin(), pred_y.end(), test_y.begin());
	137	}
	138	}
	139
	140	void test_oob_visitor()
	141	{
	142	// Create a (noisy) grid with datapoints and assign classes as in a 4x4 chessboard.
	143	size_t const nx = 100;
	144	size_t const ny = 100;
	145
	146	RandomNumberGenerator<MersenneTwister> rand;
	147	MultiArray<2, double> train_x(Shape2(nx*ny, 2));
	148	MultiArray<1, int> train_y(Shape1(nx*ny));
	149	for (size_t y = 0; y < ny; ++y)
	150	{
	151	for (size_t x = 0; x < nx; ++x)
	152	{
	153	train_x(ynx+x, 0) = x + 2rand.uniform()-1;
	154	train_x(ynx+x, 1) = y + 2rand.uniform()-1;
	155	if ((x/25+y/25) % 2 == 0)
	156	train_y(y*nx+x) = 0;
	157	else
	158	train_y(y*nx+x) = 1;
	159	}
	160	}
	161
	162	RandomForestOptions const options = RandomForestOptions()
	163	.tree_count(10)
	164	.bootstrap_sampling(true)
	165	.n_threads(1);
	166	OOBError oob;
	167	auto rf = random_forest(train_x, train_y, options, create_visitor(oob));
	168	should(oob.oob_err_ > 0.02 && oob.oob_err_ < 0.04); // FIXME: Use a statistical approach here.
	169	}
	170
	171	void test_var_importance_visitor()
	172	{
	173	// Create a (noisy) grid with datapoints and split the classes according to an oblique line.
	174	size_t const nx = 20;
	175	size_t const ny = 20;
	176
	177	RandomNumberGenerator<MersenneTwister> rand;
	178	MultiArray<2, double> train_x(Shape2(nx*ny, 2));
	179	MultiArray<1, int> train_y(Shape1(nx*ny));
	180	for (size_t y = 0; y < ny; ++y)
	181	{
	182	for (size_t x = 0; x < nx; ++x)
	183	{
	184	train_x(ynx+x, 0) = x + 2rand.uniform()-1;
	185	train_x(ynx+x, 1) = y + 2rand.uniform()-1;
	186	if (x - nx/2.0 + 4y - 4ny/2.0 < 0)
	187	train_y(y*nx+x) = 0;
	188	else
	189	train_y(y*nx+x) = 1;
	190	}
	191	}
	192
	193	RandomForestOptions const options = RandomForestOptions()
	194	.tree_count(10)
	195	.bootstrap_sampling(true)
	196	.n_threads(1);
	197	VariableImportance var_imp;
	198	auto rf = random_forest(train_x, train_y, options, create_visitor(var_imp));
	199
	200	// The permutation importances of feature 1 should be about
	201	// 10 times as big as the importances of feature 0.
	202	for (size_t i = 0; i < 4; ++i)
	203	{
	204	should(var_imp.variable_importance_(1, i) > 5 * var_imp.variable_importance_(0, i));
	205	}
	206	}
	207
	208	#ifdef HasHDF5
	209	void test_import()
	210	{
	211	typedef float FeatureType;
	212	typedef UInt32 LabelType;
	213	typedef MultiArray<2, FeatureType> Features;
	214	typedef MultiArray<1, LabelType> Labels;
	215
	216	// Load the dummy random forest. This RF was trained on 500
	217	// 2-dimensional points in [0, 1]^2. All points with x<0.5
	218	// and y<0.5 have class 0, points with x<0.5 and y>=0.5 have
	219	// class 1, points with x>0.5 and y>=0.5 have class 2, and
	220	// points with x>=0.5 and y<0.5 have class 3.
	221	HDF5File hfile("data/rf.h5", HDF5File::ReadOnly);
	222	auto rf = random_forest_import_HDF5<Features, Labels>(hfile);
	223
	224	// Create some test data.
	225	FeatureType test_x_data[] = {
	226	0.2f, 0.4f, 0.6f, 0.8f, 0.2f, 0.4f, 0.6f, 0.8f, 0.2f, 0.4f, 0.6f, 0.8f, 0.2f, 0.4f, 0.6f, 0.8f,
	227	0.2f, 0.2f, 0.2f, 0.2f, 0.4f, 0.4f, 0.4f, 0.4f, 0.6f, 0.6f, 0.6f, 0.6f, 0.8f, 0.8f, 0.8f, 0.8f
	228	};
	229	Features test_x(Shape2(16, 2), test_x_data);
	230	LabelType test_y_data[] = {
	231	0, 0, 3, 3, 0, 0, 3, 3, 1, 1, 2, 2, 1, 1, 2, 2
	232	};
	233	Labels test_y(Shape1(16), test_y_data);
	234	Labels pred_y(Shape1(16));
	235
	236	// Use the RF to predict the data.
	237	rf.predict(test_x, pred_y);
	238	for (size_t i = 0; i < (size_t)test_y.size(); ++i)
	239	should(test_y(i) == pred_y(i));
	240	}
	241
	242	void test_export()
	243	{
	244	typedef float FeatureType;
	245	typedef UInt32 LabelType;
	246	typedef MultiArray<2, FeatureType> Features;
	247	typedef MultiArray<1, LabelType> Labels;
	248
	249	// Load the dummy random forest.
	250	HDF5File infile("data/rf.h5", HDF5File::ReadOnly);
	251	auto rf = random_forest_import_HDF5<Features, Labels>(infile);
	252
	253	// Save the dummy random forest.
	254	HDF5File outfile("data/rf_out.h5", HDF5File::New);
	255	random_forest_export_HDF5(rf, outfile);
	256	}
	257	#endif
	258	};
	259
	260	struct RandomForestTestSuite : public test_suite
	261	{
	262	RandomForestTestSuite()
	263	:
	264	test_suite("RandomForest test")
	265	{
	266	add(testCase(&RandomForestTests::test_base_class));
	267	add(testCase(&RandomForestTests::test_default_rf));
	268	add(testCase(&RandomForestTests::test_oob_visitor));
	269	add(testCase(&RandomForestTests::test_var_importance_visitor));
	270	#ifdef HasHDF5
	271	add(testCase(&RandomForestTests::test_import));
	272	add(testCase(&RandomForestTests::test_export));
	273	#endif
	274	}
	275	};
	276
	277	int main(int argc, char** argv)
	278	{
	279	RandomForestTestSuite forest_test;
	280	int failed = forest_test.run(testsToBeExecuted(argc, argv));
	281	std::cout << forest_test.report() << std::endl;
	282	return (failed != 0);
	283	}

+1

-1

test/registration/CMakeLists.txt less more

0	0	VIGRA_CONFIGURE_THREADING()
1	1
2	2	if(FFTW3_FOUND)
3		INCLUDE_DIRECTORIES(${FFTW3_INCLUDE_DIR})
	3	INCLUDE_DIRECTORIES(${SUPPRESS_WARNINGS} ${FFTW3_INCLUDE_DIR})
4	4	ADD_DEFINITIONS(-DHasFFTW3)
5	5
6	6	VIGRA_ADD_TEST(test_registration test.cxx LIBRARIES ${FFTW3_LIBRARIES} ${FFTW3F_LIBRARIES} ${THREADING_LIBRARIES} vigraimpex)

+2

-2

test/registration/test.cxx less more

651	651	RadialBasisFunctor rbf;
652	652	Matrix<double> weight_matrix = rbfMatrix2DFromCorrespondingPoints(s_points.begin(), s_points.end(), d_points.begin(),rbf);
653	653
654		for(int j=0; j< d_points.size(); j++)
	654	for(decltype(d_points.size()) j=0; j< d_points.size(); j++)
655	655	{
656	656	double x = d_points[j][0];
657	657	double y = d_points[j][1];

660	660	sy = weight_matrix(point_count,1)+weight_matrix(point_count+1,1)x+ weight_matrix(point_count+2,1)y;
661	661
662	662	//RBS part
663		for(int i=0; i<d_points.size(); i++)
	663	for(decltype(d_points.size()) i=0; i<d_points.size(); i++)
664	664	{
665	665	double weight = rbf(d_points[i], d_points[j]);
666	666	sx += weight_matrix(i,0)*weight;

+2

-2

test/sifImport/CMakeLists.txt less more

0	0	if(HDF5_FOUND)
1		INCLUDE_DIRECTORIES(${HDF5_INCLUDE_DIR})
2
	1	INCLUDE_DIRECTORIES(${SUPPRESS_WARNINGS} ${HDF5_INCLUDE_DIR})
	2
3	3	ADD_DEFINITIONS(-DHasHDF5 ${HDF5_CPPFLAGS})
4	4	endif()
5	5

+4

-4

test/sifImport/test.cxx less more

143	143	SIFImportInfo infoSIF(sifFile);
144	144
145	145	// compare
146		should (infoSIF.shape()[0] == infoSIF.width());
147		should (infoSIF.shape()[1] == infoSIF.height());
148		should (infoSIF.shape()[2] == infoSIF.stacksize());
	146	should (infoSIF.shape()[0] == (unsigned)infoSIF.width());
	147	should (infoSIF.shape()[1] == (unsigned)infoSIF.height());
	148	should (infoSIF.shape()[2] == (unsigned)infoSIF.stacksize());
149	149	for (int i = 0; i < 3; ++i) {
150		should (infoSIF.shape()[i] == infoSIF.shapeOfDimension(i));
	150	should (infoSIF.shape()[i] == (unsigned)infoSIF.shapeOfDimension(i));
151	151	}
152	152	}
153	153

+2

-2

test/simpleanalysis/CMakeLists.txt less more

0	0	if(FFTW3_FOUND)
1		INCLUDE_DIRECTORIES(${FFTW3_INCLUDE_DIR})
	1	INCLUDE_DIRECTORIES(${SUPPRESS_WARNINGS} ${FFTW3_INCLUDE_DIR})
2	2	ADD_DEFINITIONS(-DHasFFTW3)
3
	3
4	4	VIGRA_ADD_TEST(test_simpleanalysis test.cxx LIBRARIES vigraimpex ${FFTW3_LIBRARIES})
5	5	else()
6	6	VIGRA_ADD_TEST(test_simpleanalysis test.cxx LIBRARIES vigraimpex)

+2

-2

test/slic2d/test.cxx less more

54	54	{
55	55	typedef MultiArray<N, float> FArray;
56	56	typedef MultiArray<N, RGBValue<float> > FRGBArray;
57		typedef MultiArray<N, int> IArray;
	57	typedef MultiArray<N, unsigned int> IArray;
58	58	typedef typename MultiArrayShape<N>::type Shape;
59	59
60	60	ImageImportInfo info;

65	65	lennaImage(info.shape())
66	66	{
67	67	importImage(info, destImage(lennaImage));
68		transformMultiArray(srcMultiArrayRange(lennaImage), destMultiArray(lennaImage), RGBPrime2LabFunctor<float>());
	68	transformMultiArray(srcMultiArrayRange(lennaImage), destMultiArray(lennaImage), RGBPrime2LabFunctor<float>());
69	69	}
70	70
71	71	void test_seeding()

test/tensorimaging/l2_hourglass.xv less more

Binary diff not shown

+5

-5

test/threadpool/test.cxx less more

50	50	for (size_t i = 0; i < v.size(); ++i)
51	51	{
52	52	pool.enqueue(
53		[&v, i](size_t thread_id)
	53	[&v, i](size_t /thread_id/)
54	54	{
55	55	v[i] = 0;
56	56	for (size_t k = 0; k < i+1; ++k)

80	80	{
81	81	futures.emplace_back(
82	82	pool.enqueue(
83		[&v, &exception_string, i](size_t thread_id)
	83	[&v, &exception_string, i](size_t /thread_id/)
84	84	{
85	85	v[i] = 1;
86	86	if (i == 5000)

109	109	std::iota(v_in.begin(), v_in.end(), 0);
110	110	std::vector<int> v_out(n);
111	111	parallel_foreach(4, v_in.begin(), v_in.end(),
112		[&v_out](size_t thread_id, int x)
	112	[&v_out](size_t /thread_id/, int x)
113	113	{
114	114	v_out[x] = x*(x+1)/2;
115	115	}

133	133	try
134	134	{
135	135	parallel_foreach(4, v_in.begin(), v_in.end(),
136		[&v_out, &exception_string](size_t thread_id, int x)
	136	[&v_out, &exception_string](size_t /thread_id/, int x)
137	137	{
138	138	if (x == 5000)
139	139	throw std::runtime_error(exception_string);

220	220	std::vector<size_t> results(n_threads, 0);
221	221	TIC;
222	222	parallel_foreach(n_threads, input.begin(), input.end(),
223		[&results](size_t thread_id, size_t x)
	223	[&results](size_t thread_id, size_t /x/)
224	224	{
225	225	results[thread_id] += 1;
226	226	}

+3

-3

test/unsupervised/CMakeLists.txt less more

2	2	# the data from 'example_data.h5' are now in 'test_data.hxx', so HDF5 is
3	3	# no longer needed for this test
4	4	# if(HDF5_FOUND)
5		# INCLUDE_DIRECTORIES(${HDF5_INCLUDE_DIR})
6
	5	# INCLUDE_DIRECTORIES(${SUPPRESS_WARNINGS} ${HDF5_INCLUDE_DIR})
	6
7	7	# ADD_DEFINITIONS(${HDF5_CPPFLAGS})
8	8
9	9	# VIGRA_ADD_TEST(test_unsupervised test.cxx LIBRARIES vigraimpex ${HDF5_LIBRARIES})
10
	10
11	11	# VIGRA_COPY_TEST_DATA(example_data.h5)
12	12	# else()
13	13	# MESSAGE(STATUS "** WARNING: test_unsupervised will not be executed")

+5

-9

test/utilities/test.cxx less more

226	226	shouldEqualSequence(vector_.begin(), vector_.end(), data);
227	227	}
228	228
229		void testBackInsertion_failedOnVC14()
	229	void testBackInsertionUntilReallocation()
230	230	{
231	231	// regression test for bug appearing with VC14,
232	232	// see https://github.com/ukoethe/vigra/issues/256

1155	1155	should(typeid(UnqualifiedType<const int*&>::type) == typeid(int));
1156	1156	}
1157	1157
1158		#if 0
1159	1158	struct FinallyTester
1160	1159	{
1161		mutable int & v_;
	1160	int & v_;
1162	1161
1163	1162	FinallyTester(int & v)
1164	1163	: v_(v)

1166	1165
1167	1166	void sq() const
1168	1167	{
1169		v_ = v_*v_;
	1168	const_cast<int &>(v_) = v_*v_;
1170	1169	}
1171	1170	};
1172		#endif
1173	1171
1174	1172	void testFinally()
1175	1173	{
1176		std::cout << "testFinally() is disabled because many compilers do not yet support it." << std::endl;
1177		#if 0
1178	1174	int v = 0;
1179	1175	{
1180	1176	FinallyTester finally_tester(v);

1196	1192	}
1197	1193	catch(std::runtime_error &) {}
1198	1194	shouldEqual(v, 2);
1199		#endif
1200	1195	}
1201	1196	};
1202	1197

1448	1443	shouldEqual(a.get<int>(), 10);
1449	1444	shouldEqual(b.get<int>(), 10);
1450	1445
1451		b.release();
	1446	b.destroy();
1452	1447	shouldNot(bool(b));
1453	1448	should(b.empty());
1454	1449

1532	1527
1533	1528	add( testCase( &ArrayVectorTest::testAccessor));
1534	1529	add( testCase( &ArrayVectorTest::testBackInsertion));
	1530	add( testCase( &ArrayVectorTest::testBackInsertionUntilReallocation));
1535	1531	add( testCase( &ArrayVectorTest::testAmbiguousConstructor));
1536	1532	add( testCase( &BucketQueueTest::testDescending));
1537	1533	add( testCase( &BucketQueueTest::testAscending));

+2

-2

vigranumpy/CMakeLists.txt less more

4	4	SET(vigranumpy_tmp_dir "${CMAKE_BINARY_DIR}/vigranumpy/vigra")
5	5	FILE(MAKE_DIRECTORY ${vigranumpy_tmp_dir})
6	6
7		INCLUDE_DIRECTORIES(${VIGRANUMPY_INCLUDE_DIRS})
	7	INCLUDE_DIRECTORIES(${SUPPRESS_WARNINGS} ${VIGRANUMPY_INCLUDE_DIRS})
8	8
9	9	IF(HDF5_FOUND)
10	10	ADD_DEFINITIONS(-DHasHDF5 ${HDF5_CPPFLAGS})
11		INCLUDE_DIRECTORIES(${HDF5_INCLUDE_DIR})
	11	INCLUDE_DIRECTORIES(${SUPPRESS_WARNINGS} ${HDF5_INCLUDE_DIR})
12	12	SET(VIGRANUMPY_IMPEX_LIBRARIES vigraimpex ${HDF5_LIBRARIES})
13	13	ELSE()
14	14	SET(VIGRANUMPY_IMPEX_LIBRARIES vigraimpex)

+36

-8

vigranumpy/lib/__init__.py less more

610	610	hessian = filters.hessianOfGaussian(image, scale,
611	611	sigma_d=sigma_d, step_size=step_size,
612	612	window_size=window_size, roi=roi)
613		return filters.tensorEigenvalues(hessian, out=out)
	613	if out is None:
	614	return filters.tensorEigenvalues(hessian)
	615
	616	try:
	617	return filters.tensorEigenvalues(hessian, out=out)
	618	except ValueError:
	619	pass
	620	# retry without 'out', since its strides might not match
	621	out[...] = filters.tensorEigenvalues(hessian)
	622	return out
614	623
615	624	hessianOfGaussianEigenvalues.__module__ = 'vigra.filters'
616	625	filters.hessianOfGaussianEigenvalues = hessianOfGaussianEigenvalues

626	635	st = filters.structureTensor(image, innerScale, outerScale,
627	636	sigma_d=sigma_d, step_size=step_size,
628	637	window_size=window_size, roi=roi)
629		return filters.tensorEigenvalues(st, out=out)
	638	if out is None:
	639	return filters.tensorEigenvalues(st)
	640
	641	try:
	642	return filters.tensorEigenvalues(st, out=out)
	643	except ValueError:
	644	pass
	645	# retry without 'out', since its strides might not match
	646	out[...] = filters.tensorEigenvalues(st)
	647	return out
630	648
631	649	structureTensorEigenvalues.__module__ = 'vigra.filters'
632	650	filters.structureTensorEigenvalues = structureTensorEigenvalues

668	686	analysis.supportedRegionFeatures = supportedRegionFeatures
669	687
670	688	def supportedConvexHullFeatures(labels):
671		'''Return a list of Convex Hull feature names that are available for the given 2D label array.
672		These Convex Hull feature names are the valid inputs to a call of
673		:func:`extractConvexHullFeatures`. E.g., to compute just the first two features in the
	689	'''Return a list of Convex Hull feature names that are available for the given label array.
	690	These Convex Hull feature names are the valid inputs to a call with
	691	:func:`extract2DConvexHullFeatures` or `extract3DConvexHullFeatures`. E.g., to compute just the first two features in the
674	692	list, use::
675	693
676	694	f = vigra.analysis.supportedConvexHullFeatures(labels)
677	695	print("Computing Convex Hull features:", f[:2])
678		r = vigra.analysis.extractConvexHullFeatures(labels, features=f[:2])
	696	r = vigra.analysis.extract2DConvexHullFeatures(labels, features=f[:2])
679	697	'''
680	698	try:
681		return analysis.extractConvexHullFeatures(labels, list_features_only=True)
	699	return analysis.extract2DConvexHullFeatures(labels, list_features_only=True)
682	700	except:
683		return []
	701	try:
	702	return analysis.extract3DConvexHullFeatures(labels, list_features_only=True)
	703	except:
	704	return []
684	705
685	706	supportedConvexHullFeatures.__module__ = 'vigra.analysis'
686	707	analysis.supportedConvexHullFeatures = supportedConvexHullFeatures

1222	1243	else:
1223	1244	return graphs._ragEdgeFeatures(self,graph,affiliatedEdges,edgeFeatures,weights,acc,out)
1224	1245
	1246	def accumulateEdgeStatistics(self, edgeFeatures, out=None):
	1247	if not isinstance(self, RegionAdjacencyGraph):
	1248	raise AttributeError("accumulateEdgeFeaturesNew not implemented for " + type(self))
	1249	graph = self.baseGraph
	1250	affiliatedEdges = self.affiliatedEdges
	1251	out = graphs._ragEdgeStatistics(self, graph, affiliatedEdges, edgeFeatures, out)
	1252	return out
1225	1253
1226	1254	def accumulateNodeFeatures(self,nodeFeatures,acc='mean',out=None):
1227	1255	""" accumulate edge features from base graphs edges features

+10

-4

vigranumpy/lib/arraytypes.py less more

168	168	``taggedView()`` depends on whether ``array`` already has axistags or not.
169	169
170	170	1. If ``array`` has no axistags or ``force=True`` (i.e. existing axistags
	171	shall be ignored) and neither the ``axistags`` nor the ``order`` parameters
	172	are given, the function acts as if ``order="C"`` was specified (case 2 below).
	173
	174	2. If ``array`` has no axistags or ``force=True`` (i.e. existing axistags
171	175	shall be ignored) and the ``order`` parameter is given, the function
172	176	constructs appropriate axistags via :meth:`~vigra.VigraArray.defaultAxistags`::
173	177
174	178	>>> view = array.view(VigraArray)
175	179	>>> view.axistags = VigraArray.defaultAxistags(view.ndim, order, noChannels)
176	180
177		2. If ``array`` has no axistags (or ``force=True``) and the ``axistags`` parameter
	181	3. If ``array`` has no axistags (or ``force=True``) and the ``axistags`` parameter
178	182	is given, the function transforms this specification into an object of type
179	183	:class:`~vigra.AxisTags` and attaches the result to the view::
180	184
181	185	>>> view = array.view(VigraArray)
182	186	>>> view.axistags = makeAxistags(axistags)
183	187
184		3. If ``array`` has axistags (and ``force=False``) and the ``order`` parameter is
	188	4. If ``array`` has axistags (and ``force=False``) and the ``order`` parameter is
185	189	given, the function transposes the array into the desired order::
186	190
187	191	>>> view = array.transposeToOrder(order)
188	192	>>> if noChannels:
189	193	... view = view.dropChannelAxis()
190	194
191		4. If ``array`` has axistags (and ``force=False``) and the ``axistags`` parameter
	195	5. If ``array`` has axistags (and ``force=False``) and the ``axistags`` parameter
192	196	is given, the function calls :meth:`~vigra.VigraArray.withAxes` to transforms
193	197	the present axistags into the desired ones::
194	198

208	212	array = array.withAxes(axistags)
209	213	else:
210	214	if not axistags:
	215	if not order:
	216	order = 'C'
211	217	axistags = VigraArray.defaultAxistags(array.ndim, order, noChannels)
212	218	else:
213	219	axistags = makeAxistags(axistags)

775	781	clip = False
776	782	if m == M:
777	783	return res
778		f = 255.0 // (M - m)
	784	f = 255.0 / (M - m)
779	785	img = f * (img - m)
780	786	if clip:
781	787	img = numpy.minimum(255.0, numpy.maximum(0.0, img))

+28

-11

vigranumpy/src/core/CMakeLists.txt less more

36	36	${VIGRANUMPY_THREAD_LIBRARIES}
37	37	VIGRANUMPY)
38	38
39		VIGRA_ADD_NUMPY_MODULE(analysis SOURCES
40		segmentation.cxx
41		edgedetection.cxx
42		interestpoints.cxx
43		accumulator.cxx
44		accumulator-region-singleband.cxx
45		accumulator-region-multiband.cxx
46		LIBRARIES
47		${VIGRANUMPY_THREAD_LIBRARIES}
48		VIGRANUMPY)
	39	IF(WITH_LEMON)
	40	VIGRA_ADD_NUMPY_MODULE(analysis SOURCES
	41	segmentation.cxx
	42	edgedetection.cxx
	43	interestpoints.cxx
	44	accumulator.cxx
	45	accumulator-region-singleband.cxx
	46	accumulator-region-multiband.cxx
	47	LIBRARIES
	48	${VIGRANUMPY_THREAD_LIBRARIES}
	49	${LEMON_LIBRARY}
	50	VIGRANUMPY)
	51	INCLUDE_DIRECTORIES(${LEMON_INCLUDE_DIR})
	52	SET_TARGET_PROPERTIES(vigranumpy_analysis PROPERTIES COMPILE_FLAGS "-DWITH_LEMON")
	53	ELSE(WITH_LEMON)
	54	VIGRA_ADD_NUMPY_MODULE(analysis SOURCES
	55	segmentation.cxx
	56	edgedetection.cxx
	57	interestpoints.cxx
	58	accumulator.cxx
	59	accumulator-region-singleband.cxx
	60	accumulator-region-multiband.cxx
	61	LIBRARIES
	62	${VIGRANUMPY_THREAD_LIBRARIES}
	63	VIGRANUMPY)
	64	ENDIF(WITH_LEMON)
49	65
50	66	VIGRA_ADD_NUMPY_MODULE(learning SOURCES
51	67	random_forest_old.cxx
52	68	random_forest.cxx
	69	random_forest_3.cxx
53	70	learning.cxx
54	71	LIBRARIES
55		${VIGRANUMPY_IMPEX_LIBRARIES}
	72	${VIGRANUMPY_IMPEX_LIBRARIES} ${VIGRANUMPY_THREAD_LIBRARIES}
56	73	VIGRANUMPY)
57	74
58	75	VIGRA_ADD_NUMPY_MODULE(colors SOURCES

+123

-172

vigranumpy/src/core/accumulator-region-singleband.cxx less more

47	47	#define STR(s) #s
48	48	#define XSTR(s) s
49	49
	50	#ifdef WITH_LEMON
	51
50	52	template <unsigned int N, class T>
51	53	python::object
52	54	extractConvexHullFeatures(NumpyArray<N, Singleband<T> > const & labels,

55	57	{
56	58	using namespace vigra::acc;
57	59
58		#define VIGRA_CONVEX_HULL_FEATURE_INPUT_COUNT "Input Count"
59		#define VIGRA_CONVEX_HULL_FEATURE_INPUT_PERIMETER "Input Perimeter"
60		#define VIGRA_CONVEX_HULL_FEATURE_INPUT_AREA "Input Area"
61		#define VIGRA_CONVEX_HULL_FEATURE_AREA "Area"
62		#define VIGRA_CONVEX_HULL_FEATURE_PERIMETER "Perimeter"
63		#define VIGRA_CONVEX_HULL_FEATURE_RUGOSITY "Rugosity"
	60	#define VIGRA_CONVEX_HULL_FEATURE_INPUT_VOLUME "InputVolume"
	61	#define VIGRA_CONVEX_HULL_FEATURE_HULL_VOLUME "HullVolume"
64	62	#define VIGRA_CONVEX_HULL_FEATURE_CONVEXITY "Convexity"
65		#define VIGRA_CONVEX_HULL_FEATURE_DEFECT_COUNT "Defect Count"
66		#define VIGRA_CONVEX_HULL_FEATURE_DEFECT_MEAN_DISPLACEMENT "Defect Mean Displacement"
67		#define VIGRA_CONVEX_HULL_FEATURE_DEFECT_AREA_LIST "Defect Area List"
68		#define VIGRA_CONVEX_HULL_FEATURE_DEFECT_AREA_MEAN "Defect Area Mean"
69		#define VIGRA_CONVEX_HULL_FEATURE_DEFECT_AREA_VARIANCE "Defect Area Variance"
70		#define VIGRA_CONVEX_HULL_FEATURE_DEFECT_AREA_SKEWNESS "Defect Area Skewness"
71		#define VIGRA_CONVEX_HULL_FEATURE_DEFECT_AREA_KURTOSIS "Defect Area Kurtosis"
72		#define VIGRA_CONVEX_HULL_FEATURE_POLYGON "Polygon"
73
74		#define VIGRA_CONVEX_HULL_VECTOR_FEATURE_INPUT_CENTER "Input Center"
75		#define VIGRA_CONVEX_HULL_VECTOR_FEATURE_CENTER "Center"
76		#define VIGRA_CONVEX_HULL_VECTOR_FEATURE_DEFECT_CENTER "Defect Center"
	63	#define VIGRA_CONVEX_HULL_FEATURE_DEFECT_VOLUME_MEAN "DefectVolumeMean"
	64	#define VIGRA_CONVEX_HULL_FEATURE_DEFECT_VOLUME_VARIANCE "DefectVolumeVariance"
	65	#define VIGRA_CONVEX_HULL_FEATURE_DEFECT_VOLUME_SKEWNESS "DefectVolumeSkewness"
	66	#define VIGRA_CONVEX_HULL_FEATURE_DEFECT_VOLUME_KURTOSIS "DefectVolumeKurtosis"
	67	#define VIGRA_CONVEX_HULL_FEATURE_DEFECT_COUNT "DefectCount"
	68	#define VIGRA_CONVEX_HULL_FEATURE_DEFECT_DISPLACEMENT_MEAN "DefectDisplacementMean"
	69
	70	#define VIGRA_CONVEX_HULL_VECTOR_FEATURE_INPUT_CENTER "InputCenter"
	71	#define VIGRA_CONVEX_HULL_VECTOR_FEATURE_HULL_CENTER "HullCenter"
	72	#define VIGRA_CONVEX_HULL_VECTOR_FEATURE_DEFECT_CENTER "DefectCenter"
77	73
78	74	if(list_features_only)
79	75	{
80
81	76	python::list res;
82		res.append(XSTR(VIGRA_CONVEX_HULL_FEATURE_INPUT_COUNT));
83		res.append(XSTR(VIGRA_CONVEX_HULL_FEATURE_INPUT_PERIMETER));
84		res.append(XSTR(VIGRA_CONVEX_HULL_FEATURE_INPUT_AREA));
85		res.append(XSTR(VIGRA_CONVEX_HULL_FEATURE_AREA));
86		res.append(XSTR(VIGRA_CONVEX_HULL_FEATURE_PERIMETER));
87		res.append(XSTR(VIGRA_CONVEX_HULL_FEATURE_RUGOSITY));
	77	res.append(XSTR(VIGRA_CONVEX_HULL_FEATURE_INPUT_VOLUME));
	78	res.append(XSTR(VIGRA_CONVEX_HULL_FEATURE_HULL_VOLUME));
88	79	res.append(XSTR(VIGRA_CONVEX_HULL_FEATURE_CONVEXITY));
89		res.append(XSTR(VIGRA_CONVEX_HULL_FEATURE_POLYGON));
90
	80	res.append(XSTR(VIGRA_CONVEX_HULL_FEATURE_DEFECT_VOLUME_MEAN));
	81	res.append(XSTR(VIGRA_CONVEX_HULL_FEATURE_DEFECT_VOLUME_VARIANCE));
	82	res.append(XSTR(VIGRA_CONVEX_HULL_FEATURE_DEFECT_VOLUME_SKEWNESS));
	83	res.append(XSTR(VIGRA_CONVEX_HULL_FEATURE_DEFECT_VOLUME_KURTOSIS));
91	84	res.append(XSTR(VIGRA_CONVEX_HULL_FEATURE_DEFECT_COUNT));
92		res.append(XSTR(VIGRA_CONVEX_HULL_FEATURE_DEFECT_MEAN_DISPLACEMENT));
93		res.append(XSTR(VIGRA_CONVEX_HULL_FEATURE_DEFECT_AREA_LIST));
94		res.append(XSTR(VIGRA_CONVEX_HULL_FEATURE_DEFECT_AREA_MEAN));
95		res.append(XSTR(VIGRA_CONVEX_HULL_FEATURE_DEFECT_AREA_VARIANCE));
96		res.append(XSTR(VIGRA_CONVEX_HULL_FEATURE_DEFECT_AREA_SKEWNESS));
97		res.append(XSTR(VIGRA_CONVEX_HULL_FEATURE_DEFECT_AREA_KURTOSIS));
	85	res.append(XSTR(VIGRA_CONVEX_HULL_FEATURE_DEFECT_DISPLACEMENT_MEAN));
98	86
99	87	res.append(XSTR(VIGRA_CONVEX_HULL_VECTOR_FEATURE_INPUT_CENTER));
100		res.append(XSTR(VIGRA_CONVEX_HULL_VECTOR_FEATURE_CENTER));
101
	88	res.append(XSTR(VIGRA_CONVEX_HULL_VECTOR_FEATURE_HULL_CENTER));
102	89	res.append(XSTR(VIGRA_CONVEX_HULL_VECTOR_FEATURE_DEFECT_CENTER));
103	90
104	91	return res;

106	93
107	94	TinyVector<npy_intp, N> permutation = labels.template permuteLikewise<N>();
108	95
109		AccumulatorChainArray<CoupledArrays<N, T>,
110		Select<ConvexHull, DataArg<1>, LabelArg<1> >
111		> acc;
	96	AccumulatorChainArray<
	97	CoupledArrays<N, T>,
	98	Select<ConvexHullFeatures, DataArg<1>, LabelArg<1> > > acc;
112	99
113	100	MultiArrayIndex ignored_label = -1;
114	101	if(ignore_label != python::object())

119	106
120	107	{
121	108	PyAllowThreads _pythread;
122
123	109	extractFeatures(labels, acc);
124	110	}
125
	111
126	112	int size = acc.maxRegionLabel()+1;
	113
	114	// finalize the calculations
	115	for (int k = 0; k < size; ++k)
	116	{
	117	if (k != ignored_label && get<Count>(acc, k) != 0)
	118	{
	119	getAccumulator<ConvexHullFeatures>(acc, k).finalize();
	120	}
	121	}
	122
	123	// initialize return dict
127	124	python::dict res;
128		{
129		NumpyArray<1, npy_uint32> array((Shape1(size)));
130		for(int k=0; k<size; ++k)
131		{
132		if(k == ignored_label)
133		continue;
134		array(k) = get<Count>(acc, k);
135		}
136		res[XSTR(VIGRA_CONVEX_HULL_FEATURE_INPUT_COUNT)] = array;
137		}
138
	125
139	126	#define VIGRA_CONVEX_HULL_FEATURE(TYPE, NAME, FUNCTION) \
140	127	{ \
141	128	NumpyArray<1, TYPE> array((Shape1(size))); \

143	130	{ \
144	131	if(k == ignored_label \|\| get<Count>(acc, k) == 0) \
145	132	continue; \
146		array(k) = get<ConvexHull>(acc, k).FUNCTION(); \
	133	array(k) = get<ConvexHullFeatures>(acc, k).FUNCTION(); \
147	134	} \
148	135	res[XSTR(NAME)] = array; \
149	136	}
150
151		#define VIGRA_CONVEX_HULL_FEATURE_DEFECT(TYPE, NAME, FUNCTION) \
152		{ \
153		NumpyArray<1, double> array((Shape1(size))); \
154		for(int k=0; k<size; ++k) \
155		{ \
156		if(k == ignored_label \|\| get<Count>(acc, k) == 0) \
157		continue; \
158		array(k) = get<ConvexHull>(acc, k).meanDefectDisplacement(); \
159		} \
160		res[XSTR(NAME)] = array; \
161		}
162
163		VIGRA_CONVEX_HULL_FEATURE(double, VIGRA_CONVEX_HULL_FEATURE_INPUT_PERIMETER, inputPerimeter)
164		VIGRA_CONVEX_HULL_FEATURE(double, VIGRA_CONVEX_HULL_FEATURE_INPUT_AREA, inputArea)
165		VIGRA_CONVEX_HULL_FEATURE(double, VIGRA_CONVEX_HULL_FEATURE_PERIMETER, hullPerimeter)
166		VIGRA_CONVEX_HULL_FEATURE(double, VIGRA_CONVEX_HULL_FEATURE_AREA, hullArea)
	137
	138	VIGRA_CONVEX_HULL_FEATURE(npy_uint32, VIGRA_CONVEX_HULL_FEATURE_INPUT_VOLUME, inputVolume)
	139	VIGRA_CONVEX_HULL_FEATURE(npy_uint32, VIGRA_CONVEX_HULL_FEATURE_HULL_VOLUME, hullVolume)
167	140	VIGRA_CONVEX_HULL_FEATURE(double, VIGRA_CONVEX_HULL_FEATURE_CONVEXITY, convexity)
168		VIGRA_CONVEX_HULL_FEATURE(double, VIGRA_CONVEX_HULL_FEATURE_RUGOSITY, rugosity)
169		VIGRA_CONVEX_HULL_FEATURE(npy_uint32, VIGRA_CONVEX_HULL_FEATURE_DEFECT_COUNT, convexityDefectCount)
170
171		VIGRA_CONVEX_HULL_FEATURE_DEFECT(double, VIGRA_CONVEX_HULL_FEATURE_DEFECT_AREA_MEAN, convexityDefectAreaMean)
172		VIGRA_CONVEX_HULL_FEATURE_DEFECT(double, VIGRA_CONVEX_HULL_FEATURE_DEFECT_MEAN_DISPLACEMENT, meanDefectDisplacement)
173		VIGRA_CONVEX_HULL_FEATURE_DEFECT(double, VIGRA_CONVEX_HULL_FEATURE_DEFECT_AREA_VARIANCE, convexityDefectAreaVariance)
174		VIGRA_CONVEX_HULL_FEATURE_DEFECT(double, VIGRA_CONVEX_HULL_FEATURE_DEFECT_AREA_SKEWNESS, convexityDefectAreaSkewness)
175		VIGRA_CONVEX_HULL_FEATURE_DEFECT(double, VIGRA_CONVEX_HULL_FEATURE_DEFECT_AREA_KURTOSIS, convexityDefectAreaKurtosis)
176
	141	VIGRA_CONVEX_HULL_FEATURE(double, VIGRA_CONVEX_HULL_FEATURE_DEFECT_VOLUME_MEAN, defectVolumeMean)
	142	VIGRA_CONVEX_HULL_FEATURE(double, VIGRA_CONVEX_HULL_FEATURE_DEFECT_VOLUME_VARIANCE, defectVolumeVariance)
	143	VIGRA_CONVEX_HULL_FEATURE(double, VIGRA_CONVEX_HULL_FEATURE_DEFECT_VOLUME_SKEWNESS, defectVolumeSkewness)
	144	VIGRA_CONVEX_HULL_FEATURE(double, VIGRA_CONVEX_HULL_FEATURE_DEFECT_VOLUME_KURTOSIS, defectVolumeKurtosis)
	145	VIGRA_CONVEX_HULL_FEATURE(npy_uint32, VIGRA_CONVEX_HULL_FEATURE_DEFECT_COUNT, defectCount)
	146	VIGRA_CONVEX_HULL_FEATURE(double, VIGRA_CONVEX_HULL_FEATURE_DEFECT_DISPLACEMENT_MEAN, defectDisplacementMean)
	147
177	148	#undef VIGRA_CONVEX_HULL_FEATURE
178
179		{
180		python::list hulls;
181		for(int k=0; k<size; ++k)
182		{
183		if(k == ignored_label \|\| get<Count>(acc, k) == 0)
184		{
185		hulls.append(python::object());
186		continue;
187		}
188		int hull_size = get<ConvexHull>(acc, k).hull().size();
189		NumpyArray<2, double> array(Shape2(hull_size, N));
190		Polygon<TinyVector<double, 2> > poly = (permutation == Shape2(0,1))
191		? get<ConvexHull>(acc, k).hull()
192		: reverse(transpose(get<ConvexHull>(acc, k).hull()));
193		for(int p=0; p<hull_size; ++p)
194		{
195		for(int j=0; j<N; ++j)
196		array(p, j) = poly[p][j];
197		}
198		hulls.append(array);
199		}
200		res[XSTR(VIGRA_CONVEX_HULL_FEATURE_POLYGON)] = hulls;
201		}
202
203		{
204		NumpyArray<2, double> array(Shape2(size, 3));
205		for(int k=0; k<size; ++k)
206		{
207		if(k == ignored_label \|\| get<Count>(acc, k) == 0)
208		continue;
209		int defects = min<int>(3, get<ConvexHull>(acc, k).convexityDefectCount());
210		for(int j=0; j<defects; ++j)
211		array(k, j) = get<ConvexHull>(acc, k).defectAreaList()[j];
212		}
213		res[XSTR(VIGRA_CONVEX_HULL_FEATURE_DEFECT_AREA_LIST)] = array;
214		}
215
	149
216	150	#define VIGRA_CONVEX_HULL_VECTOR_FEATURE(NAME, FUNCTION) \
217	151	{ \
218	152	NumpyArray<2, double> array(Shape2(size, N)); \

220	154	{ \
221	155	if(k == ignored_label \|\| get<Count>(acc, k) == 0) \
222	156	continue; \
223		for(int j=0; j<N; ++j) \
224		array(k, permutation[j]) = get<ConvexHull>(acc, k).FUNCTION()[j]; \
	157	for(unsigned j=0; j<N; ++j) \
	158	array(k, permutation[j]) = get<ConvexHullFeatures>(acc, k).FUNCTION()[j]; \
225	159	} \
226	160	res[XSTR(NAME)] = array; \
227	161	}
228
229		#define VIGRA_CONVEX_HULL_VECTOR_FEATURE_DEFECT(NAME, FUNCTION) \
230		{ \
231		NumpyArray<2, double> array(Shape2(size, N)); \
232		for(int k=0; k<size; ++k) \
233		{ \
234		if(k == ignored_label \|\| get<Count>(acc, k) == 0) \
235		continue; \
236		for(int j=0; j<N; ++j) \
237		array(k, permutation[j]) = get<ConvexHull>(acc, k).FUNCTION()[j]; \
238		} \
239		res[XSTR(NAME)] = array; \
240		}
241
	162
242	163	VIGRA_CONVEX_HULL_VECTOR_FEATURE(VIGRA_CONVEX_HULL_VECTOR_FEATURE_INPUT_CENTER, inputCenter)
243		VIGRA_CONVEX_HULL_VECTOR_FEATURE(VIGRA_CONVEX_HULL_VECTOR_FEATURE_CENTER, hullCenter)
244
245		VIGRA_CONVEX_HULL_VECTOR_FEATURE_DEFECT(VIGRA_CONVEX_HULL_VECTOR_FEATURE_DEFECT_CENTER, convexityDefectCenter)
	164	VIGRA_CONVEX_HULL_VECTOR_FEATURE(VIGRA_CONVEX_HULL_VECTOR_FEATURE_HULL_CENTER, hullCenter)
	165	VIGRA_CONVEX_HULL_VECTOR_FEATURE(VIGRA_CONVEX_HULL_VECTOR_FEATURE_DEFECT_CENTER, defectCenter)
246	166
247	167	#undef VIGRA_CONVEX_HULL_VECTOR_FEATURE
248	168
249	169	return res;
250	170	}
	171
	172	#endif // WITH_LEMON
251	173
252	174	template <unsigned int N, class T>
253	175	python::object

263	185	#define VIGRA_SKELETON_FEATURE_AVERAGE_LENGTH "Average Length"
264	186	#define VIGRA_SKELETON_FEATURE_BRANCH_COUNT "Branch Count"
265	187	#define VIGRA_SKELETON_FEATURE_HOLE_COUNT "Hole Count"
266		#define VIGRA_SKELETON_VECTOR_FEATURE_CENTER "Center"
	188	#define VIGRA_SKELETON_VECTOR_FEATURE_CENTER "Skeleton Center"
267	189	#define VIGRA_SKELETON_VECTOR_FEATURE_TERMINAL_1 "Terminal 1"
268	190	#define VIGRA_SKELETON_VECTOR_FEATURE_TERMINAL_2 "Terminal 2"
269	191

321	243	NumpyArray<2, double> array(Shape2(size, N)); \
322	244	for(int k=0; k<size; ++k) \
323	245	{ \
324		for(int j=0; j<N; ++j) \
	246	for(unsigned j=0; j<N; ++j) \
325	247	array(k, permutation[j]) = features[k].ATTRIBUTE[j]; \
326	248	} \
327	249	res[XSTR(NAME)] = array; \

354	276	definePythonAccumulatorArraySingleband<2, float, ScalarRegionAccumulators>();
355	277	definePythonAccumulatorArraySingleband<3, float, ScalarRegionAccumulators>();
356	278
357		def("extractConvexHullFeatures",
358		registerConverters(&extractConvexHullFeatures<2, npy_uint32>),
359		(arg("labels"),
360		arg("ignoreLabel")=python::object(),
361		arg("list_features_only")=false),
362		"\nExtract convex hull features for each region of a labeled 2D image\n"
363		"(with dtype=numpy.uint32) and return a dictionary holding the\n"
364		"resulting feature arrays. Argument 'ignoreLabel' can be used to specify\n"
365		"an optional background label that is to be skipped. Note that the\n"
366		"convex hull itself and its features are computed from the interpixel\n"
367		"contour around each region. In the following, 'convexity defects'\n"
368		"are defined as the connected components of the set difference\n"
369		"between the convex hull and the original region.\n\n"
370		"The result dictionary holds the following keys:\n\n"
371		" - 'InputCount': the number of pixels in the original region\n\n"
372		" - 'InputPerimeter': the perimeter of the original interpixel contour\n\n"
373		" - 'InputArea': the areay enclosed by the original interpixel contour\n\n"
374		" - 'InputCenter': the centroid of the original interpixel contour polygon\n\n"
375		" - 'Perimeter': the perimeter of the convex hull polygon\n\n"
376		" - 'Area': the area enclosed by the convex hull polygon\n\n"
377		" - 'Center': the centroid of the convex hull polygon\n\n"
378		" - 'Rugosity': ratio between original perimeter and hull perimeter (>= 1)\n\n"
379		" - 'Convexity': the ratio between hull area and original area (<= 1)\n\n"
380		" - 'DefectCount': the number of convexity defects\n\n"
381		" - 'DefectCenter': the combined centroid of the defects\n\n"
382		" - 'MeanDefectDisplacement': mean distance between the centroids of the\n"
383		" original object and the centroids of the defects,\n"
384		" weighted by defect area\n\n"
385		" - 'DefectAreaList': the area of the three largest convexity defects\n\n"
386		" - 'DefectAreaMean': mean of the convexity defect areas\n\n"
387		" - 'DefectAreaVariance': variance of the convexity defect areas\n\n"
388		" - 'DefectAreaSkewness': skewness of the convexity defect areas\n\n"
389		" - 'DefectAreaKurtosis': kurtosis of the convexity defect areas\n\n"
390		" - 'Polygon': the convex hull polygon\n\n");
391
	279	#ifdef WITH_LEMON
	280	def("extract2DConvexHullFeatures",
	281	registerConverters(&extractConvexHullFeatures<2, npy_uint32>),
	282	( arg("labels"),
	283	arg("ignoreLabel")=python::object(),
	284	arg("list_features_only")=false),
	285	"\nExtract convex hull features for each region of a labeled 2D image (with\n"
	286	"dtype=numpy.uint32) and return a dictionary holding the resulting feature\n"
	287	"arrays. The argument 'ignoreLabel' can be used to specify an optional\n"
	288	"background label that is to be skipped. Note that the convex hull itself and\n"
	289	"its features are computed from the interpixel contour around each region. In\n"
	290	"the following, 'convexity defects' are the connected components of the set\n"
	291	"difference between the convex hull and the original region.\n"
	292	"The result dictionary holds the following keys:\n\n"
	293	" - InputVolume : the number of pixels in the original region\n\n"
	294	" - HullVolume : the number of pixels in the convex hull\n\n"
	295	" - Convexity : the ratio between the convex hull volume and the input\n"
	296	" volume\n\n"
	297	" - DefectVolumeMean : mean of the volumes of the convexity defects\n\n"
	298	" - DefectVolumeVariance : variance of the volumes of the convexity\n"
	299	" defects\n\n"
	300	" - DefectVolumeSkewness : skewness of the volumes of the convexity\n"
	301	" defects\n\n"
	302	" - DefectVolumeKurtosis : kurtosis of the volumes of the convexity\n"
	303	" defects\n\n"
	304	" - DefectCount : number of convexity defects\n\n"
	305	" - DefectDisplacementMean : mean distance between the center of the input\n"
	306	" region and the center of the defects, weighted by the defect volumes\n\n"
	307	" - InputCenter : center of the input region\n\n"
	308	" - HullCenter : center of the convex hull\n\n"
	309	" - DefectCenter : center of the defects\n\n");
	310
	311	def("extract3DConvexHullFeatures",
	312	registerConverters(&extractConvexHullFeatures<3, npy_uint32>),
	313	( arg("labels"),
	314	arg("ignoreLabel")=python::object(),
	315	arg("list_features_only")=false),
	316	"\nExtract convex hull features for each region of a labeled 3D image (with\n"
	317	"dtype=numpy.uint32) and return a dictionary holding the resulting feature\n"
	318	"arrays. The argument 'ignoreLabel' can be used to specify an optional\n"
	319	"background label that is to be skipped. Note that the convex hull itself and\n"
	320	"its features are computed from the interpixel contour around each region. In\n"
	321	"the following, 'convexity defects' are the connected components of the set\n"
	322	"difference between the convex hull and the original region.\n"
	323	"The result dictionary holds the following keys:\n\n"
	324	" - InputVolume : the number of pixels in the original region\n\n"
	325	" - HullVolume : the number of pixels in the convex hull\n\n"
	326	" - Convexity : the ratio between the convex hull volume and the input\n"
	327	" volume\n\n"
	328	" - DefectVolumeMean : mean of the volumes of the convexity defects\n\n"
	329	" - DefectVolumeVariance : variance of the volumes of the convexity\n"
	330	" defects\n\n"
	331	" - DefectVolumeSkewness : skewness of the volumes of the convexity\n"
	332	" defects\n\n"
	333	" - DefectVolumeKurtosis : kurtosis of the volumes of the convexity\n"
	334	" defects\n\n"
	335	" - DefectCount : number of convexity defects\n\n"
	336	" - DefectDisplacementMean : mean distance between the center of the input\n"
	337	" region and the center of the defects, weighted by the defect volumes\n\n"
	338	" - InputCenter : center of the input region\n\n"
	339	" - HullCenter : center of the convex hull\n\n"
	340	" - DefectCenter : center of the defects\n\n");
	341	#endif // WITH_LEMON
	342
392	343	def("extractSkeletonFeatures",
393	344	registerConverters(&pyExtractSkeletonFeatures<2, npy_uint32>),
394	345	(arg("labels"),

+2

-2

vigranumpy/src/core/colors.cxx less more

367	367	void pythonGray2QImage_ARGB32Premultiplied(
368	368	const NumpyArray<2, Singleband<T> >& image,
369	369	NumpyArray<3, Multiband<npy_uint8> > qimageView,
370		NumpyArray<1, T> normalize = boost::python::object()
	370	NumpyArray<1, float> normalize
371	371	)
372	372	{
373	373	vigra_precondition(image.isUnstrided() \|\| image.transpose().isUnstrided(),

438	438	const NumpyArray<2, Singleband<T> >& image,
439	439	NumpyArray<3, Multiband<npy_uint8> > qimageView,
440	440	NumpyArray<1, float> tintColor,
441		NumpyArray<1, T> normalize
	441	NumpyArray<1, float> normalize
442	442	)
443	443	{
444	444	vigra_precondition(image.isUnstrided() \|\| image.transpose().isUnstrided(),

+115

-36

vigranumpy/src/core/converters.cxx less more

41	41	#include <vigra/numpy_array_converters.hxx>
42	42	#include <boost/python.hpp>
43	43	#include <boost/python/to_python_converter.hpp>
	44	#include <numpy/arrayscalars.h>
44	45
45	46	namespace python = boost::python;
46	47

49	50	#define VIGRA_NUMPY_TYPECHECKER(type) \
50	51	if(python::object((python::detail::new_reference)PyArray_TypeObjectFromType(type)).ptr() == obj) \
51	52	return obj;
52
	53
53	54	#define VIGRA_NUMPY_TYPECONVERTER(type) \
54	55	if(python::object((python::detail::new_reference)PyArray_TypeObjectFromType(type)).ptr() == obj) \
55	56	typeID = type;
56
	57
57	58	struct NumpyTypenumConverter
58	59	{
59	60	NumpyTypenumConverter()
60	61	{
61		python::converter::registry::insert(&convertible, &construct,
	62	python::converter::registry::insert(&convertible, &construct,
62	63	python::type_id<NPY_TYPES>());
63	64	python::to_python_converter<NPY_TYPES, NumpyTypenumConverter>();
64	65	}
65
	66
66	67	static void* convertible(PyObject* obj)
67	68	{
68	69	// FIXME: there should be a more elegant way to program this...

81	82	VIGRA_NUMPY_TYPECHECKER(NPY_UINT32)
82	83	VIGRA_NUMPY_TYPECHECKER(NPY_INT)
83	84	VIGRA_NUMPY_TYPECHECKER(NPY_UINT)
84		VIGRA_NUMPY_TYPECHECKER(NPY_INT64)
	85	VIGRA_NUMPY_TYPECHECKER(NPY_INT64)
85	86	VIGRA_NUMPY_TYPECHECKER(NPY_UINT64)
86	87	VIGRA_NUMPY_TYPECHECKER(NPY_FLOAT32)
87	88	VIGRA_NUMPY_TYPECHECKER(NPY_FLOAT64)

93	94	}
94	95
95	96	// from Python
96		static void construct(PyObject* obj,
	97	static void construct(PyObject* obj,
97	98	python::converter::rvalue_from_python_stage1_data* data)
98	99	{
99		void* const storage =
	100	void* const storage =
100	101	((python::converter::rvalue_from_python_storage<NumpyAnyArray>* ) data)->storage.bytes;
101	102
102	103	// FIXME: there should be a more elegant way to program this...

112	113	VIGRA_NUMPY_TYPECONVERTER(NPY_UINT32)
113	114	VIGRA_NUMPY_TYPECONVERTER(NPY_INT)
114	115	VIGRA_NUMPY_TYPECONVERTER(NPY_UINT)
115		VIGRA_NUMPY_TYPECONVERTER(NPY_INT64)
	116	VIGRA_NUMPY_TYPECONVERTER(NPY_INT64)
116	117	VIGRA_NUMPY_TYPECONVERTER(NPY_UINT64)
117	118	VIGRA_NUMPY_TYPECONVERTER(NPY_FLOAT32)
118	119	VIGRA_NUMPY_TYPECONVERTER(NPY_FLOAT64)

140	141	{
141	142	NumpyAnyArrayConverter()
142	143	{
143		python::converter::registry::insert(&convertible, &construct,
	144	python::converter::registry::insert(&convertible, &construct,
144	145	python::type_id<NumpyAnyArray>());
145	146	python::to_python_converter<NumpyAnyArray, NumpyAnyArrayConverter>();
146	147	}
147
	148
148	149	static void* convertible(PyObject* obj)
149	150	{
150	151	return obj && (obj == Py_None \|\| PyArray_Check(obj))

153	154	}
154	155
155	156	// from Python
156		static void construct(PyObject* obj,
	157	static void construct(PyObject* obj,
157	158	python::converter::rvalue_from_python_stage1_data* data)
158	159	{
159		void* const storage =
	160	void* const storage =
160	161	((python::converter::rvalue_from_python_storage<NumpyAnyArray>* ) data)->storage.bytes;
161	162
162	163	if(obj == Py_None)
163	164	obj = 0;
164
	165
165	166	new (storage) NumpyAnyArray(obj);
166	167
167	168	data->convertible = storage;
168	169	}
169
	170
170	171	static PyObject* convert(NumpyAnyArray const& a)
171	172	{
172	173	return returnNumpyArray(a);

212	213	{
213	214
214	215	typedef typename detail::MultiArrayShapeConverterTraits<M, T>::ShapeType ShapeType;
215
	216
216	217	MultiArrayShapeConverter()
217	218	{
218		python::converter::registry::insert(&convertible, &construct,
	219	python::converter::registry::insert(&convertible, &construct,
219	220	python::type_id<ShapeType>());
220	221	python::to_python_converter<ShapeType, MultiArrayShapeConverter>();
221	222	}
222
	223
223	224	static void* convertible(PyObject* obj)
224	225	{
225	226	if(obj == 0)

235	236	}
236	237
237	238	// from Python
238		static void construct(PyObject* obj,
	239	static void construct(PyObject* obj,
239	240	python::converter::rvalue_from_python_stage1_data* data)
240	241	{
241		void* const storage =
	242	void* const storage =
242	243	((python::converter::rvalue_from_python_storage<ShapeType>* ) data)->storage.bytes;
243	244
244	245	detail::MultiArrayShapeConverterTraits<M, T>::construct(storage, obj);

284	285	//from python
285	286	static void construct(PyObject* obj, python::converter::rvalue_from_python_stage1_data* data)
286	287	{
287		void* const storage =
	288	void* const storage =
288	289	((python::converter::rvalue_from_python_storage<Point2D>*) data)->storage.bytes;
289	290	new (storage) Point2D(python::extract<int>(PySequence_Fast_GET_ITEM(obj,0)),
290	291	python::extract<int>(PySequence_Fast_GET_ITEM(obj,1)));

333	334	}
334	335
335	336	#if 0 // FIXME: reimplement to replace the Python versions for consistence?
336		PyObject *
337		constructNumpyArrayFromShape(python::object type, ArrayVector<npy_intp> const & shape,
	337	PyObject *
	338	constructNumpyArrayFromShape(python::object type, ArrayVector<npy_intp> const & shape,
338	339	unsigned int spatialDimensions, unsigned int channels,
339	340	NPY_TYPES typeCode, std::string order, bool init)
340	341	{

344	345	return detail::constructNumpyArrayImpl((PyTypeObject *)obj, shape, spatialDimensions, channels, typeCode, order, init).release();
345	346	}
346	347
347		PyObject *
348		constructNumpyArrayFromArray(python::object type, NumpyAnyArray array,
	348	PyObject *
	349	constructNumpyArrayFromArray(python::object type, NumpyAnyArray array,
349	350	unsigned int spatialDimensions, unsigned int channels,
350	351	NPY_TYPES typeCode, std::string order, bool init)
351	352	{
352	353	PyObject * obj = type.ptr();
353	354	vigra_precondition(obj && PyType_Check(obj) && PyType_IsSubtype((PyTypeObject *)obj, &PyArray_Type),
354	355	"constructNumpyArray(type, ...): first argument was not an array type.");
355		PyObject * res = detail::constructNumpyArrayImpl((PyTypeObject *)obj, array.shape(), spatialDimensions, channels,
	356	PyObject * res = detail::constructNumpyArrayImpl((PyTypeObject *)obj, array.shape(), spatialDimensions, channels,
356	357	typeCode, order, false, array.strideOrdering()).release();
357	358	if(init)
358	359	{

363	364	}
364	365	#endif
365	366
366		PyObject *
367		constructArrayFromAxistags(python::object type, ArrayVector<npy_intp> const & shape,
	367	PyObject *
	368	constructArrayFromAxistags(python::object type, ArrayVector<npy_intp> const & shape,
368	369	NPY_TYPES typeCode, AxisTags const & axistags, bool init)
369	370	{
370	371	PyAxisTags pyaxistags(python_ptr(python::object(axistags).ptr()));
371
	372
372	373	ArrayVector<npy_intp> norm_shape(shape);
373	374	if(pyaxistags.size() > 0)
374	375	{
375	376	ArrayVector<npy_intp> permutation(pyaxistags.permutationToNormalOrder());
376	377	applyPermutation(permutation.begin(), permutation.end(), shape.begin(), norm_shape.begin());
377	378	}
378
	379
379	380	TaggedShape tagged_shape(norm_shape, pyaxistags);
380
	381
381	382	// FIXME: check that type is an array class?
382	383	return constructArray(tagged_shape, typeCode, init, python_ptr(type.ptr()));
383	384	}

386	387	struct MatrixConverter
387	388	{
388	389	typedef linalg::Matrix<T> ArrayType;
389
	390
390	391	MatrixConverter();
391
	392
392	393	// to Python
393	394	static PyObject* convert(ArrayType const& a)
394	395	{

400	401	MatrixConverter<T>::MatrixConverter()
401	402	{
402	403	using namespace boost::python;
403
	404
404	405	converter::registration const * reg = converter::registry::query(type_id<ArrayType>());
405
	406
406	407	// register the to_python_converter only once
407	408	if(!reg \|\| !reg->rvalue_chain)
408	409	{
409	410	to_python_converter<ArrayType, MatrixConverter>();
410	411	}
411	412	}
	413
	414	template <typename ScalarType>
	415	struct NumpyScalarConverter
	416	{
	417	NumpyScalarConverter()
	418	{
	419	using namespace boost::python;
	420	converter::registry::push_back( &convertible, &construct, type_id<ScalarType>());
	421	}
	422
	423	// Determine if obj_ptr is a supported numpy.number
	424	static void* convertible(PyObject* obj_ptr)
	425	{
	426	if (PyArray_IsScalar(obj_ptr, Float32) \|\|
	427	PyArray_IsScalar(obj_ptr, Float64) \|\|
	428	PyArray_IsScalar(obj_ptr, Int8) \|\|
	429	PyArray_IsScalar(obj_ptr, Int16) \|\|
	430	PyArray_IsScalar(obj_ptr, Int32) \|\|
	431	PyArray_IsScalar(obj_ptr, Int64) \|\|
	432	PyArray_IsScalar(obj_ptr, UInt8) \|\|
	433	PyArray_IsScalar(obj_ptr, UInt16) \|\|
	434	PyArray_IsScalar(obj_ptr, UInt32) \|\|
	435	PyArray_IsScalar(obj_ptr, UInt64))
	436	{
	437	return obj_ptr;
	438	}
	439	return 0;
	440	}
	441
	442	static void construct( PyObject* obj_ptr, boost::python::converter::rvalue_from_python_stage1_data* data)
	443	{
	444	using namespace boost::python;
	445
	446	// Grab pointer to memory into which to construct the C++ scalar
	447	void* storage = ((converter::rvalue_from_python_storage<ScalarType>*) data)->storage.bytes;
	448
	449	// in-place construct the new scalar value
	450	ScalarType * scalar = new (storage) ScalarType;
	451
	452	if (PyArray_IsScalar(obj_ptr, Float32))
	453	(*scalar) = PyArrayScalar_VAL(obj_ptr, Float32);
	454	else if (PyArray_IsScalar(obj_ptr, Float64))
	455	(*scalar) = PyArrayScalar_VAL(obj_ptr, Float64);
	456	else if (PyArray_IsScalar(obj_ptr, Int8))
	457	(*scalar) = PyArrayScalar_VAL(obj_ptr, Int8);
	458	else if (PyArray_IsScalar(obj_ptr, Int16))
	459	(*scalar) = PyArrayScalar_VAL(obj_ptr, Int16);
	460	else if (PyArray_IsScalar(obj_ptr, Int32))
	461	(*scalar) = PyArrayScalar_VAL(obj_ptr, Int32);
	462	else if (PyArray_IsScalar(obj_ptr, Int64))
	463	(*scalar) = PyArrayScalar_VAL(obj_ptr, Int64);
	464	else if (PyArray_IsScalar(obj_ptr, UInt8))
	465	(*scalar) = PyArrayScalar_VAL(obj_ptr, UInt8);
	466	else if (PyArray_IsScalar(obj_ptr, UInt16))
	467	(*scalar) = PyArrayScalar_VAL(obj_ptr, UInt16);
	468	else if (PyArray_IsScalar(obj_ptr, UInt32))
	469	(*scalar) = PyArrayScalar_VAL(obj_ptr, UInt32);
	470	else if (PyArray_IsScalar(obj_ptr, UInt64))
	471	(*scalar) = PyArrayScalar_VAL(obj_ptr, UInt64);
	472
	473	// Stash the memory chunk pointer for later use by boost.python
	474	data->convertible = storage;
	475	}
	476	};
	477
412	478
413	479	void registerNumpyArrayConverters()
414	480	{

418	484	NumpyAnyArrayConverter();
419	485	MatrixConverter<float>();
420	486	MatrixConverter<double>();
421
	487
	488	NumpyScalarConverter<signed char>();
	489	NumpyScalarConverter<short>();
	490	NumpyScalarConverter<int>();
	491	NumpyScalarConverter<long>();
	492	NumpyScalarConverter<long long>();
	493	NumpyScalarConverter<unsigned char>();
	494	NumpyScalarConverter<unsigned short>();
	495	NumpyScalarConverter<unsigned int>();
	496	NumpyScalarConverter<unsigned long>();
	497	NumpyScalarConverter<unsigned long long>();
	498	NumpyScalarConverter<float>();
	499	NumpyScalarConverter<double>();
	500
422	501	python::docstring_options doc_options(true, true, false);
423
	502
424	503	doc_options.disable_all();
425	504	python::def("constructArrayFromAxistags", &constructArrayFromAxistags);
426	505	// python::def("constructNumpyArray", &constructNumpyArrayFromArray);

+43

-1

vigranumpy/src/core/edgedetection.cxx less more

38	38	#include <vigra/numpy_array.hxx>
39	39	#include <vigra/numpy_array_converters.hxx>
40	40	#include <vigra/edgedetection.hxx>
	41	#include <vigra/multi_convolution.hxx>
	42	#include <vigra/tensorutilities.hxx>
41	43
42	44	namespace python = boost::python;
43	45

69	71	e.y = Edgel::value_type(v);
70	72	}
71	73
72		unsigned int Edgel__len__(Edgel const & e)
	74	unsigned int Edgel__len__(Edgel const &)
73	75	{
74	76	return 2;
75	77	}

177	179	PyAllowThreads _pythread;
178	180	cannyEdgeImage(srcImageRange(image), destImage(res),
179	181	scale, threshold, edgeMarker);
	182	}
	183
	184	return res;
	185	}
	186
	187	template < class SrcPixelType, typename DestPixelType >
	188	NumpyAnyArray
	189	pythonCannyEdgeImageColor(NumpyArray<2, RGBValue<SrcPixelType> > image,
	190	double scale, double threshold, DestPixelType edgeMarker,
	191	NumpyArray<2, Singleband<DestPixelType> > res = python::object())
	192	{
	193	std::string description("Canny edges, scale=");
	194	description += asString(scale) + ", threshold=" + asString(threshold);
	195
	196	res.reshapeIfEmpty(image.taggedShape().setChannelDescription(description),
	197	"cannyEdgeImage(): Output array has wrong shape.");
	198
	199	{
	200	PyAllowThreads _pythread;
	201	MultiArray<2, TinyVector<float, 2>> gradient(image.shape());
	202	MultiArray<2, TinyVector<float, 3>> tmp(image.shape()),
	203	gradient_tensor(image.shape());
	204	for(int k=0; k<3; ++k)
	205	{
	206	gaussianGradientMultiArray(image.bindElementChannel(k), gradient, scale);
	207	vectorToTensor(gradient, tmp);
	208	gradient_tensor += tmp;
	209	}
	210	tensorEigenRepresentation(gradient_tensor, tmp);
	211	transformMultiArray(tmp, gradient, [](TinyVector<float, 3> const & v) {
	212	return TinyVector<float, 2>(std::cos(v[2])sqrt(v[0]), std::sin(v[2])sqrt(v[0]));
	213	});
	214	cannyEdgeImageFromGradWithThinning(gradient, res,
	215	threshold, edgeMarker, false);
180	216	}
181	217
182	218	return res;

400	436	"Detect and mark edges in an edge image using Canny's algorithm.\n\n"
401	437	"For details see cannyEdgeImage_ in the vigra C++ documentation.\n");
402	438
	439	def("cannyEdgeImage",
	440	registerConverters(&pythonCannyEdgeImageColor<float, UInt8>),
	441	(arg("image"), arg("scale"), arg("threshold"), arg("edgeMarker"),arg("out")=python::object()),
	442	"Detect and mark edges in an edge image using Canny's algorithm.\n\n"
	443	"For details see cannyEdgeImage_ in the vigra C++ documentation.\n");
	444
403	445	def("cannyEdgeImageWithThinning",
404	446	registerConverters(&pythonCannyEdgeImageWithThinning<float, UInt8>),
405	447	(arg("image"), arg("scale"), arg("threshold"), arg("edgeMarker"),

+35

-35

vigranumpy/src/core/export_graph_algorithm_visitor.hxx less more

25	25
26	26
27	27	template<class GRAPH>
28		class LemonGraphAlgorithmVisitor
	28	class LemonGraphAlgorithmVisitor
29	29	: public boost::python::def_visitor<LemonGraphAlgorithmVisitor<GRAPH> >
30	30	{
31	31	public:

36	36
37	37	typedef LemonGraphAlgorithmVisitor<GRAPH> VisitorType;
38	38	// Lemon Graph Typedefs
39
	39
40	40	typedef typename Graph::index_type index_type;
41	41	typedef typename Graph::Edge Edge;
42	42	typedef typename Graph::Node Node;

183	183	)
184	184	);
185	185
186
	186
187	187
188	188	python::def("nodeGtToEdgeGt",registerConverters(&pyNodeGtToEdgeGt),
189	189	(

243	243
244	244	std::string clsName_;
245	245	template <class classT>
246		void visit(classT& c) const
247		{
	246	void visit(classT& /c/) const
	247	{
248	248	// - watersheds-segmentation
249	249	// - carving-segmentation
250	250	// - felzenwalb-segmentation

282	282
283	283	find3Cycles(graph, cyclesNodes);
284	284	cyclesEdges.reshapeIfEmpty(cyclesNodes.shape());
285
	285
286	286	Node nodes[3];
287	287	Edge edges[3];
288	288

304	304	static NumpyAnyArray pyCyclesEdges(
305	305	const GRAPH & graph,
306	306	NumpyArray<1, vigra::TinyVector<Int32, 3> > cycles,
307		NumpyArray<1, vigra::TinyVector<Int32, 3> > edgesOut
	307	NumpyArray<1, vigra::TinyVector<Int32, 3> > edgesOut
308	308	){
309	309
310	310	Node nodes[3];

321	321	for(size_t j=0; j<3; ++j){
322	322	edgesOut(i)[j] = graph.id(edges[j]);
323	323	}
324		}
	324	}
325	325	return edgesOut;
326	326	}
327	327
328
	328
329	329
330	330	static NumpyAnyArray pyWardCorrection(
331	331	const Graph & g,

368	368
369	369	NumpyArray<2,UInt32> vis (( typename NumpyArray<2,UInt64>::difference_type(g.edgeNum(),2)));
370	370	NumpyArray<1,float > weights (( typename NumpyArray<1,double>::difference_type(g.edgeNum() )));
371
	371
372	372	size_t denseIndex = 0 ;
373	373	for(NodeIt iter(g);iter!=lemon::INVALID;++iter){
374	374	toDenseArrayMap[*iter]=denseIndex;

436	436	out(i)=nodeLabelArrayMap[g.nodeFromId(nodeIds(i))];
437	437	return out;
438	438	}
439
	439
440	440	static NumpyAnyArray pyNodeIdsFeatures(
441	441	const GRAPH & g,
442	442	NumpyArray<1,Singleband<UInt32> > nodeIds,

509	509	// numpy arrays => lemon maps
510	510	FloatNodeArrayMap nodeFeatureArrayMap(g,nodeFeaturesArray);
511	511	FloatEdgeArrayMap edgeWeightsArrayMap(g,edgeWeightsArray);
512
	512
513	513	for(EdgeIt e(g);e!=lemon::INVALID;++e){
514	514	const Edge edge(*e);
515	515	const Node u=g.u(edge);

532	532	// numpy arrays => lemon maps
533	533	MultiFloatNodeArrayMap nodeFeatureArrayMap(g,nodeFeaturesArray);
534	534	FloatEdgeArrayMap edgeWeightsArrayMap(g,edgeWeightsArray);
535
	535
536	536	for(EdgeIt e(g);e!=lemon::INVALID;++e){
537	537	const Edge edge(*e);
538	538	const Node u=g.u(edge);

548	548	UInt32NodeArray seedsArray,
549	549	UInt32NodeArray labelsArray
550	550	){
551		// resize output ?
	551	// resize output ?
552	552	labelsArray.reshapeIfEmpty( IntrinsicGraphShape<Graph>::intrinsicNodeMapShape(g) );
553	553
554	554	// numpy arrays => lemon maps

571	571	UInt32NodeArray labelsArray
572	572	){
573	573
574		// resize output ?
	574	// resize output ?
575	575	labelsArray.reshapeIfEmpty( IntrinsicGraphShape<Graph>::intrinsicNodeMapShape(g) );
576	576
577	577

590	590	//lemon_graph::graph_detail::generateWatershedSeeds(g, nodeWeightsArrayMap, labelsArrayMap, watershedsOption.seed_options);
591	591	lemon_graph::watershedsGraph(g, nodeWeightsArrayMap, labelsArrayMap, watershedsOption);
592	592	//lemon_graph::graph_detail::seededWatersheds(g, nodeWeightsArrayMap, seedsArrayMap, watershedsOption);
593
	593
594	594	return labelsArray;
595	595	}
596	596

604	604	UInt32NodeArray seedsArray
605	605	){
606	606	const std::string method="regionGrowing";
607		// resize output ?
	607	// resize output ?
608	608	seedsArray.reshapeIfEmpty( IntrinsicGraphShape<Graph>::intrinsicNodeMapShape(g) );
609	609
610	610	WatershedOptions watershedsOption;

629	629	const float noBiasBelow,
630	630	UInt32NodeArray labelsArray
631	631	){
632		// resize output ?
	632	// resize output ?
633	633	labelsArray.reshapeIfEmpty( IntrinsicGraphShape<Graph>::intrinsicNodeMapShape(g) );
634	634
635	635	// numpy arrays => lemon maps

652	652	UInt32NodeArray labelsArray
653	653	){
654	654
655		// resize output ?
	655	// resize output ?
656	656	labelsArray.reshapeIfEmpty( IntrinsicGraphShape<Graph>::intrinsicNodeMapShape(g) );
657	657
658	658	// numpy arrays => lemon maps

667	667	shortestPathSegmentation<
668	668	Graph,FloatEdgeArrayMap, FloatNodeArrayMap, UInt32NodeArrayMap, float
669	669	>(g, edgeWeightsArrayMap, nodeWeightsArrayMap, labelsArrayMap);
670
671
	670
	671
672	672	return labelsArray;
673	673	}
674	674

681	681	const int nodeNumStop,
682	682	UInt32NodeArray labelsArray
683	683	){
684		// resize output ?
	684	// resize output ?
685	685	labelsArray.reshapeIfEmpty( IntrinsicGraphShape<Graph>::intrinsicNodeMapShape(g) );
686	686
687	687	// numpy arrays => lemon maps

732	732
733	733
734	734	template<class GRAPH>
735		class LemonGridGraphAlgorithmAddonVisitor
	735	class LemonGridGraphAlgorithmAddonVisitor
736	736	: public boost::python::def_visitor<LemonGridGraphAlgorithmAddonVisitor<GRAPH> >
737	737	{
738	738	public:

743	743
744	744	typedef LemonGraphAlgorithmVisitor<GRAPH> VisitorType;
745	745	// Lemon Graph Typedefs
746
	746
747	747	typedef typename Graph::index_type index_type;
748	748	typedef typename Graph::Edge Edge;
749	749	typedef typename Graph::Node Node;

784	784	typedef typename GraphDescriptorToMultiArrayIndex<Graph>::IntrinsicNodeMapShape NodeCoordinate;
785	785	typedef NumpyArray<1,NodeCoordinate> NodeCoorinateArray;
786	786
787		LemonGridGraphAlgorithmAddonVisitor(const std::string & clsName){}
	787	LemonGridGraphAlgorithmAddonVisitor(const std::string & /clsName/){}
788	788
789	789
790	790	template <class classT>
791	791	void visit(classT& c) const
792		{
	792	{
793	793
794	794	// - edge weights from interpolated image
795	795	exportMiscAlgorithms(c);

798	798
799	799	template <class classT>
800	800	void exportMiscAlgorithms(classT & c)const{
801
	801
802	802
803	803
804	804	python::def("edgeFeaturesFromInterpolatedImage",registerConverters(&pyEdgeWeightsFromInterpolatedImage),

807	807	python::arg("image"),
808	808	python::arg("out")=python::object()
809	809	),
810		"convert an image with with ``shape = graph.shape*2 - 1`` to an edge weight array"
	810	"convert an image with ``shape = graph.shape*2 - 1`` to an edge weight array"
811	811	);
812	812
813	813	python::def("edgeFeaturesFromImage",registerConverters(&pyEdgeWeightsFromImage),

816	816	python::arg("image"),
817	817	python::arg("out")=python::object()
818	818	),
819		"convert an image with with shape = graph.shape OR shape = graph.shape *2 -1 to an edge weight array"
	819	"convert an image with shape = graph.shape OR shape = graph.shape *2 -1 to an edge weight array"
820	820	);
821	821
822	822	python::def("edgeFeaturesFromImage",registerConverters(&pyEdgeWeightsFromImageMb),

825	825	python::arg("image"),
826	826	python::arg("out")=python::object()
827	827	),
828		"convert an image with with shape = graph.shape OR shape = graph.shape *2 -1 to an edge weight array"
	828	"convert an image with shape = graph.shape OR shape = graph.shape *2 -1 to an edge weight array"
829	829	);
830	830
831	831

844	844	//' python::arg("image"),
845	845	//' python::arg("out")=python::object()
846	846	//' ),
847		//' "convert an image with with shape = graph.shape *2 -1 to an edge weight array"
	847	//' "convert an image with shape = graph.shape *2 -1 to an edge weight array"
848	848	//' ""
849	849	//');
850	850

852	852	}
853	853
854	854
855
	855
856	856
857	857
858	858	static size_t pyAffiliatedEdgesSerializationSize(

881	881	topologicalShape=false;
882	882	}
883	883	}
884
	884
885	885	if(regularShape)
886	886	return pyEdgeWeightsFromOrginalSizeImage(g,image,edgeWeightsArray);
887	887	else if(topologicalShape)

911	911	topologicalShape=false;
912	912	}
913	913	}
914
	914
915	915	if(regularShape)
916	916	return pyEdgeWeightsFromOrginalSizeImageMb(g,image,edgeWeightsArray);
917	917	else if(topologicalShape)

997	997
998	998	edgeWeightsArray.reshapeIfEmpty( MultiFloatEdgeArray::ArrayTraits::taggedShape(outShape,"nc") );
999	999
1000
	1000
1001	1001	// numpy arrays => lemon maps
1002	1002	MultiFloatEdgeArrayMap edgeWeightsArrayMap(g,edgeWeightsArray);
1003	1003	typedef typename FloatNodeArray::difference_type CoordType;

+52

-33

vigranumpy/src/core/export_graph_hierarchical_clustering_visitor.hxx less more

28	28
29	29
30	30	template<class GRAPH>
31		class LemonGraphHierachicalClusteringVisitor
	31	class LemonGraphHierachicalClusteringVisitor
32	32	: public boost::python::def_visitor<LemonGraphHierachicalClusteringVisitor<GRAPH> >
33	33	{
34	34	public:

40	40
41	41	typedef LemonGraphHierachicalClusteringVisitor<GRAPH> VisitorType;
42	42	// Lemon Graph Typedefs
43
	43
44	44	typedef typename Graph::index_type index_type;
45	45	typedef typename Graph::Edge Edge;
46	46	typedef typename Graph::Node Node;

94	94
95	95	typedef cluster_operators::PythonOperator<MergeGraph> PythonClusterOperator;
96	96
97
	97
98	98
99	99
100	100	LemonGraphHierachicalClusteringVisitor(const std::string clsName)

124	124
125	125	;
126	126
127		python::def("__mergeGraph",&pyMergeGraphConstructor ,
	127	python::def("__mergeGraph",&pyMergeGraphConstructor ,
128	128	python::with_custodian_and_ward_postcall< 0,1 ,
129		python::return_value_policy< python::manage_new_object > >()
	129	python::return_value_policy< python::manage_new_object > >()
130	130	)
131	131	;
132	132	}
133	133
	134	static void setLiftedEdges(DefaultClusterOperator & op,
	135	NumpyArray<1, uint32_t> liftedEdgeIds
	136	){
	137	op.setLiftedEdges(liftedEdgeIds.begin(), liftedEdgeIds.end());
	138	}
	139
134	140	void exportHierarchicalClusteringOperators()const{
135		{
	141	{
136	142	const std::string operatorName = clsName_ + std::string("MergeGraph") + std::string("MinEdgeWeightNodeDistOperator");
137	143	python::class_<DefaultClusterOperator >(operatorName.c_str(),python::no_init)
138	144	.def("__init__", python::make_constructor(&pyEdgeWeightNodeFeaturesConstructor))
	145	.def("setLiftedEdges",registerConverters(&setLiftedEdges))
	146	.def("enableStopWeight",&DefaultClusterOperator::enableStopWeight)
139	147	;
140	148	python::def("__minEdgeWeightNodeDistOperator",registerConverters(&pyEdgeWeightNodeFeaturesConstructor),
141	149	python::with_custodian_and_ward_postcall< 0,1 ,

145	153	python::with_custodian_and_ward_postcall< 0 ,5,
146	154	python::with_custodian_and_ward_postcall< 0 ,6,
147	155	python::with_custodian_and_ward_postcall< 0 ,7,
148		python::return_value_policy< python::manage_new_object
149		> > > > > > > >()
	156	python::return_value_policy< python::manage_new_object
	157	> > > > > > > >()
150	158	);
151	159
152	160	}
153		//{
	161	//{
154	162	// const std::string operatorName = clsName_ + std::string("MergeGraph") + std::string("NeuroOperator");
155	163	// python::class_<NeuroClusterOperator >(operatorName.c_str(),python::no_init)
156	164	// .def("__init__", python::make_constructor(&pyNeuroConstructor))

162	170	// python::with_custodian_and_ward_postcall< 0 ,4,
163	171	// python::with_custodian_and_ward_postcall< 0 ,5,
164	172	// python::with_custodian_and_ward_postcall< 0 ,6,
165		// python::return_value_policy< python::manage_new_object
166		// > > > > > > >()
	173	// python::return_value_policy< python::manage_new_object
	174	// > > > > > > >()
167	175	// );
168	176	//}
169	177	{

176	184	python::def("__pythonClusterOperator",registerConverters(&pyPythonOperatorConstructor),
177	185	python::with_custodian_and_ward_postcall< 0,1 ,
178	186	python::with_custodian_and_ward_postcall< 0,2 ,
179		python::return_value_policy< python::manage_new_object > > >()
	187	python::return_value_policy< python::manage_new_object > > >()
180	188	);
181	189	}
182	190	}

184	192	template<class CLUSTER_OPERATOR>
185	193	void exportHierarchicalClustering(const std::string & opClsName)const{
186	194	typedef CLUSTER_OPERATOR ClusterOperator;
187		typedef HierarchicalClustering<ClusterOperator> HCluster;
	195	typedef HierarchicalClusteringImpl<ClusterOperator> HCluster;
188	196
189	197	const std::string clsName = std::string("HierarchicalClustering")+ opClsName;
190	198	python::class_<HCluster,boost::noncopyable>(

192	200	)
193	201	.def("cluster",&HCluster::cluster)
194	202	.def("reprNodeIds",registerConverters(&pyReprNodeIds<HCluster>))
	203	.def("ucmTransform",registerConverters(&pyUcmTransform<HCluster>))
195	204	.def("resultLabels",registerConverters(&pyResultLabels<HCluster>),
196	205	(
197	206	python::arg("out")=python::object()

202	211	// free function
203	212	python::def("__hierarchicalClustering",registerConverters(&pyHierarchicalClusteringConstructor<ClusterOperator>),
204	213	python::with_custodian_and_ward_postcall< 0,1 ,
205		python::return_value_policy< python::manage_new_object > >()
	214	python::return_value_policy< python::manage_new_object > >()
206	215	);
207	216	}
208	217

238	247
239	248
240	249	template <class classT>
241		void visit(classT& c) const
242		{
	250	void visit(classT& /c/) const
	251	{
243	252	// the merge graph itself and factory functions to get a merge graph
244	253	exportMergeGraph();
245	254

277	286	){
278	287	return EdgeHolder<MergeGraph>(mg,mg.reprEdge(edge));
279	288	}
280
	289
281	290
282	291	static void pyContractEdgeA(
283	292	MergeGraph & mg,

303	312
304	313
305	314	template<class CLUSTER_OP>
306		static HierarchicalClustering<CLUSTER_OP> * pyHierarchicalClusteringConstructor(
	315	static HierarchicalClusteringImpl<CLUSTER_OP> * pyHierarchicalClusteringConstructor(
307	316	CLUSTER_OP & clusterOp,
308	317	const size_t nodeNumStopCond,
309	318	const bool buildMergeTreeEncoding
310	319
311	320
312	321	){
313		typename HierarchicalClustering<CLUSTER_OP>::Parameter param;
	322	typename HierarchicalClusteringImpl<CLUSTER_OP>::Parameter param;
314	323	param.nodeNumStopCond_=nodeNumStopCond;
315	324	param.buildMergeTreeEncoding_=buildMergeTreeEncoding;
316	325	param.verbose_=true;
317		return new HierarchicalClustering<CLUSTER_OP>(clusterOp,param);
318		}
319
320
321
322
323		static DefaultClusterOperator *
	326	return new HierarchicalClusteringImpl<CLUSTER_OP>(clusterOp,param);
	327	}
	328
	329
	330
	331
	332	static DefaultClusterOperator *
324	333	pyEdgeWeightNodeFeaturesConstructor(
325	334	MergeGraph & mergeGraph,
326	335	FloatEdgeArray edgeIndicatorMapArray,

336	345	){
337	346
338	347	FloatEdgeArrayMap edgeIndicatorMap(mergeGraph.graph(),edgeIndicatorMapArray);
339		FloatEdgeArrayMap edgeSizeMap(mergeGraph.graph(),edgeSizeMapArray);
	348	FloatEdgeArrayMap edgeSizeMap(mergeGraph.graph(),edgeSizeMapArray);
340	349	MultiFloatNodeArrayMap nodeFeatureMap(mergeGraph.graph(),nodeFeatureMapArray);
341	350	FloatNodeArrayMap nodeSizeMap(mergeGraph.graph(),nodeSizeMapArray);
342	351	FloatEdgeArrayMap edgeMinWeightMap(mergeGraph.graph(),edgeMinWeightMapArray);

356	365
357	366
358	367
359		static PythonClusterOperator *
	368	static PythonClusterOperator *
360	369	pyPythonOperatorConstructor(
361	370	MergeGraph & mergeGraph,
362	371	python::object object,

365	374	const bool useEraseEdgeCallback
366	375	){
367	376	return new PythonClusterOperator(mergeGraph,object,useMergeNodeCallback,useMergeEdgesCallback,useEraseEdgeCallback);
368		}
	377	}
369	378
370	379
371	380

398	407	//TOC;
399	408	return resultArray;
400	409	}
	410
	411	template<class HCLUSTER>
	412	static void pyUcmTransform(
	413	const HCLUSTER & hcluster,
	414	FloatEdgeArray inputArray
	415	){
	416	FloatEdgeArrayMap inputArrayMap(hcluster.graph(),inputArray);
	417	hcluster.ucmTransform(inputArrayMap);
	418	}
	419
401	420
402	421	template<class HCLUSTER>
403	422	static python::tuple mergeTreeEncodingAsNumpyArray(const HCLUSTER & hcluster) {

416	435	indices(m,2)=encoding[m].r_;
417	436	}
418	437	return python::make_tuple(indices,w);
419		}
	438	}
420	439
421	440
422	441	template<class HCLUSTER>

424	443	const HCLUSTER & hcluster,
425	444	const typename HCLUSTER::MergeGraphIndexType treeNodeId,
426	445	NumpyArray<1,UInt32> leafes = (NumpyArray<1,UInt32>())
427		) {
	446	) {
428	447	leafes.reshapeIfEmpty( typename NumpyArray<1,UInt32>::difference_type( hcluster.graph().nodeNum()) );
429	448	if(leafes.shape(0)!=hcluster.graph().nodeNum()){
430	449	throw std::runtime_error("out.shape(0) must be equal nodeNum");

433	452	// todo make leafes size check
434	453	const size_t leafNum=hcluster.leafNodeIds(treeNodeId,leafes.begin());
435	454	return python::make_tuple(leafes,leafNum);
436		}
	455	}
437	456
438	457	/*
439	458

448	467	){
449	468	// reshape out ( last argument (out) will be reshaped if empty, and #channels is taken from second argument)
450	469	reshapeNodeMapIfEmpty(graph,ragNodeFeaturesArray,graphNodeFeaturesArray);
451		// numpy arrays => lemon maps
	470	// numpy arrays => lemon maps
452	471	typename PyNodeMapTraits<Graph, UInt32>::Map labelsWhichGeneratedRagArrayMap(graph, labelsWhichGeneratedRagArray);
453	472	typename PyNodeMapTraits<RagGraph,T >::Map ragNodeFeaturesArrayMap(rag,ragNodeFeaturesArray);
454	473	typename PyNodeMapTraits<Graph, T >::Map graphNodeFeaturesArrayMap(graph,graphNodeFeaturesArray);

+94

-3

vigranumpy/src/core/export_graph_rag_visitor.hxx less more

20	20	#include <vigra/multi_gridgraph.hxx>
21	21	#include <vigra/error.hxx>
22	22	#include <vigra/graph_rag_project_back.hxx>
	23	#include <vigra/threadpool.hxx>
	24
	25	#include <vigra/accumulator.hxx>
	26
23	27	namespace python = boost::python;
24	28
25	29	namespace vigra{

121	125
122	126
123	127	template <class classT>
124		void visit(classT& c) const
	128	void visit(classT& /c/) const
125	129	{
126	130
127	131	// something like RagEdgeMap< std::vector< Edge > >

157	161	python::arg("out")=python::object()
158	162	)
159	163	);
	164	python::def("_ragEdgeStatistics",
	165	registerConverters(
	166	&pyRagEdgeFeaturesFromImplicit< float, float, ImplicitEdgeMap >
	167	),
	168	(
	169	python::arg("rag"),
	170	python::arg("graph"),
	171	python::arg("affiliatedEdges"),
	172	python::arg("edgeFeatures"),
	173	python::arg("out")=python::object()
	174	)
	175	);
	176
160	177
161	178	}
162	179

563	580	template<class T_PIXEL, class T, class OTF_EDGES>
564	581	static NumpyAnyArray pyRagEdgeMeanFromImplicit(
565	582	const RagGraph & rag,
566		const Graph & graph,
	583	const Graph & /graph/,
567	584	const RagAffiliatedEdges & affiliatedEdges,
568	585	const OTF_EDGES & otfEdgeMap,
569	586	const std::string & accumulator,

622	639
623	640	}
624	641
625
	642
	643	template<class T_PIXEL, class T, class OTF_EDGES>
	644	static NumpyAnyArray pyRagEdgeFeaturesFromImplicit(
	645	const RagGraph & rag,
	646	const Graph & /graph/,
	647	const RagAffiliatedEdges & affiliatedEdges,
	648	const OTF_EDGES & otfEdgeMap,
	649	NumpyArray<RagEdgeMapDim+1, T> ragEdgeFeaturesArray
	650	){
	651
	652	// preconditions
	653	vigra_precondition(rag.edgeNum()>=1,"rag.edgeNum()>=1 is violated");
	654
	655	using namespace vigra::acc;
	656
	657	const size_t NFeatures = 12;
	658
	659	// resize out
	660	typename MultiArray<RagEdgeMapDim+1,int>::difference_type outShape;
	661	for(size_t d=0;d<RagEdgeMapDim;++d){
	662	outShape[d]=IntrinsicGraphShape<RagGraph>::intrinsicEdgeMapShape(rag)[d];
	663	}
	664	outShape[RagEdgeMapDim]= NFeatures;
	665
	666	ragEdgeFeaturesArray.reshapeIfEmpty(outShape);
	667
	668	// define histogram for quantiles
	669	typedef StandardQuantiles<AutoRangeHistogram<0> > Quantiles;
	670	size_t n_bins_min = 2;
	671	size_t n_bins_max = 64;
	672
	673	//in parallel with threadpool
	674	// -1 = use all cores
	675	parallel_foreach( -1, rag.edgeNum(),
	676	[&](size_t /thread_id/, int id)
	677	{
	678	auto feat = ragEdgeFeaturesArray.bindInner(id);
	679	// init the accumulator chain with the appropriate statistics
	680	AccumulatorChain<double,
	681	Select<Mean, Sum, Minimum, Maximum, Variance, Skewness, Kurtosis, Quantiles> > a;
	682	const std::vector<Edge> & affEdges = affiliatedEdges[id];
	683
	684	// set n_bins = ceil( n_values**1./2.5 ) , clipped to [2,64]
	685	// turned out to be suitable empirically
	686	// see https://github.com/consti123/quantile_tests
	687	size_t n_bins = std::pow( affiliatedEdges.size(), 1. / 2.5);
	688	n_bins = std::max( n_bins_min, std::min(n_bins, n_bins_max) );
	689	a.setHistogramOptions(HistogramOptions().setBinCount(n_bins));
	690
	691	// accumulate the values of this edge
	692	for(unsigned int k=1; k <= a.passesRequired(); ++k)
	693	for(size_t i=0;i<affEdges.size();++i)
	694	a.updatePassN( otfEdgeMap[affEdges[i]], k );
	695
	696	feat[0] = get<Mean>(a);
	697	feat[1] = get<Sum>(a);
	698	feat[2] = get<Minimum>(a);
	699	feat[3] = get<Maximum>(a);
	700	feat[4] = get<Variance>(a);
	701	feat[5] = get<Skewness>(a);
	702	feat[6] = get<Kurtosis>(a);
	703	// get quantiles, keep only the ones we care for
	704	TinyVector<double, 7> quant = get<Quantiles>(a);
	705	// we keep: 0.1, 0.25, 05 (median), 0.75 and 0.9 quantile
	706	feat[7] = quant[1];
	707	feat[8] = quant[2];
	708	feat[9] = quant[3];
	709	feat[10] = quant[4];
	710	feat[11] = quant[5];
	711	}
	712	);
	713
	714	return ragEdgeFeaturesArray;
	715
	716	}
626	717
627	718
628	719	template<class T>

+37

-21

vigranumpy/src/core/export_graph_shortest_path_visitor.hxx less more

205	205
206	206	std::string clsName_;
207	207	template <class classT>
208		void visit(classT& c) const
	208	void visit(classT& /c/) const
209	209	{
210	210	// - Dijkstra
211	211	exportShortestPathAlgorithms();
212	212	}
213	213
214		static ShortestPathDijkstraType * pyShortestPathDijkstraTypeFactory(const Graph & g){
	214	static ShortestPathDijkstraType * pyShortestPathDijkstraTypeFactory(const Graph & g){
215	215	return new ShortestPathDijkstraType(g);
216	216	}
217	217

267	267	// comput length of the path
268	268	const size_t length = pathLength(Node(source),Node(target),predMap);
269	269	nodeIdPath.reshapeIfEmpty(typename NumpyArray<1,Singleband<UInt32> >::difference_type(length));
270		pathIds(sp.graph(),source,target,predMap,nodeIdPath);
	270	{
	271	PyAllowThreads _pythread;
	272	pathIds(sp.graph(),source,target,predMap,nodeIdPath);
	273	}
271	274	return nodeIdPath;
272	275
273	276	}

282	285	// comput length of the path
283	286	const size_t length = pathLength(Node(source),Node(target),predMap);
284	287	nodeCoordinates.reshapeIfEmpty(typename NumpyArray<1,Singleband<UInt32> >::difference_type(length));
285		pathCoordinates(sp.graph(),source,target,predMap,nodeCoordinates);
	288	{
	289	PyAllowThreads _pythread;
	290	pathCoordinates(sp.graph(),source,target,predMap,nodeCoordinates);
	291	}
286	292	return nodeCoordinates;
287	293	}
288	294

292	298	PyNode source,
293	299	PyNode target
294	300	){
295		// numpy arrays => lemon maps
296		FloatEdgeArrayMap edgeWeightsArrayMap(sp.graph(),edgeWeightsArray);
297
298		// run algorithm itself
299		sp.run(edgeWeightsArrayMap,source,target);
	301	{
	302	PyAllowThreads _pythread;
	303	// numpy arrays => lemon maps
	304	FloatEdgeArrayMap edgeWeightsArrayMap(sp.graph(),edgeWeightsArray);
	305	// run algorithm itself
	306	sp.run(edgeWeightsArrayMap,source,target);
	307	}
300	308	}
301	309
302	310	static void runShortestPathNoTarget(

304	312	FloatEdgeArray edgeWeightsArray,
305	313	PyNode source
306	314	){
307		// numpy arrays => lemon maps
308		FloatEdgeArrayMap edgeWeightsArrayMap(sp.graph(),edgeWeightsArray);
309
310		// run algorithm itself
311		sp.run(edgeWeightsArrayMap,source);
312		}
313
314
315		static void runShortestPathImplicit(
	315	{
	316	PyAllowThreads _pythread;
	317	// numpy arrays => lemon maps
	318	FloatEdgeArrayMap edgeWeightsArrayMap(sp.graph(),edgeWeightsArray);
	319	// run algorithm itself
	320	sp.run(edgeWeightsArrayMap,source);
	321	}
	322	}
	323
	324
	325	static void runShortestPathImplicit(
316	326	ShortestPathDijkstraType & sp,
317	327	const ImplicitEdgeMap & edgeWeights,
318	328	PyNode source,

321	331	// numpy arrays => lemon maps
322	332	//FloatEdgeArrayMap edgeWeightsArrayMap(sp.graph(),edgeWeightsArray);
323	333
324		// run algorithm itself
325		sp.run(edgeWeights,source,target);
	334	{
	335	PyAllowThreads _pythread;
	336	// run algorithm itself
	337	sp.run(edgeWeights,source,target);
	338	}
326	339	}
327	340
328	341	static void runShortestPathNoTargetImplicit(

334	347	//FloatEdgeArrayMap edgeWeightsArrayMap(sp.graph(),edgeWeightsArray);
335	348
336	349	// run algorithm itself
337		sp.run(edgeWeights,source);
	350	{
	351	PyAllowThreads _pythread;
	352	sp.run(edgeWeights,source);
	353	}
338	354	}
339	355
340	356	};

+2

-2

vigranumpy/src/core/export_graph_visitor.hxx less more

451	451	}
452	452
453	453	template<class ITEM>
454		static bool eqToInvalid(const ITEM & item,const lemon::Invalid iv){
	454	static bool eqToInvalid(const ITEM & item,const lemon::Invalid /iv/){
455	455	return item.graph_==NULL \|\| item==lemon::INVALID;
456	456	}
457	457
458	458	template<class ITEM>
459		static bool neqToInvalid(const ITEM & item,const lemon::Invalid iv){
	459	static bool neqToInvalid(const ITEM & item,const lemon::Invalid /iv/){
460	460	return item.graph_!=NULL && item!=lemon::INVALID;
461	461	}
462	462

+1

-1

vigranumpy/src/core/impex.cxx less more

355	355	}
356	356
357	357	AxisTags
358		pythonGetAxisTags(const ImageImportInfo& info)
	358	pythonGetAxisTags(const ImageImportInfo& /info/)
359	359	{
360	360	return AxisTags(AxisInfo::x(), AxisInfo::y(), AxisInfo::c());
361	361	}

+5

-0

vigranumpy/src/core/learning.cxx less more

132	132	void defineRandomForest();
133	133	void defineRandomForestOld();
134	134
	135	namespace rf3 {
	136	void exportRandomForest3();
	137	}
	138
135	139	} // namespace vigra
136	140
137	141

144	148	defineUnsupervised();
145	149	defineRandomForest();
146	150	defineRandomForestOld();
	151	rf3::exportRandomForest3();
147	152	}
148	153
149	154

+14

-5

vigranumpy/src/core/morphology.cxx less more

563	563	{
564	564	res.reshapeIfEmpty(image.taggedShape(),
565	565	"eccentricityTransform(): Output array has wrong shape.");
566		eccentricityTransformOnLabels(image, res);
	566	{
	567	PyAllowThreads _pythread;
	568	eccentricityTransformOnLabels(image, res);
	569	}
567	570	return res;
568	571	}
569	572

575	578	{
576	579	typedef typename MultiArrayShape<N>::type Point;
577	580	ArrayVector<Point> centers;
578		eccentricityCenters(image, centers);
	581	{
	582	PyAllowThreads _pythread;
	583	eccentricityCenters(image, centers);
	584	}
579	585
580	586	python::list centerlist = python::list();
581		for (int i=0; i<centers.size(); ++i) {
	587	for (decltype(centers.size()) i=0; i<centers.size(); ++i) {
582	588	centerlist.append(centers[i]);
583	589	}
584	590	return centerlist;

595	601	res.reshapeIfEmpty(image.taggedShape(),
596	602	"eccentricityTransformWithCenters(): Output array has wrong shape.");
597	603	ArrayVector<Point> centers;
598		eccentricityTransformOnLabels(image, res, centers);
	604	{
	605	PyAllowThreads _pythread;
	606	eccentricityTransformOnLabels(image, res, centers);
	607	}
599	608
600	609	python::list centerlist = python::list();
601		for (int i=0; i<centers.size(); ++i) {
	610	for (decltype(centers.size()) i=0; i<centers.size(); ++i) {
602	611	centerlist.append(centers[i]);
603	612	}
604	613	return python::make_tuple(res, centerlist);

+2

-2

vigranumpy/src/core/multi_array_chunked.cxx less more

260	260	else
261	261	at = AxisTags(python::extract<AxisTags const &>(axistags)());
262	262	int N = Array::shape_type::static_size;
263		vigra_precondition(at.size() == 0 \|\| at.size() == N,
	263	vigra_precondition(at.size() == 0 \|\| at.size() == unsigned(N),
264	264	"ChunkedArray(): axistags have invalid length.");
265		if(at.size() == N)
	265	if(at.size() == unsigned(N))
266	266	{
267	267	int res = PyObject_SetAttrString(py_array, "axistags", python::object(at).ptr());
268	268	pythonToCppException(res != 0);

+2

-2

vigranumpy/src/core/noise.cxx less more

68	68	double averagingQuantile=0.8,
69	69	double noiseEstimationQuantile=1.5,
70	70	double noiseVarianceInitialGuess=10.0,
71		NumpyArray<3, Multiband<PixelType> > res=python::object())
	71	NumpyArray<3, Multiband<PixelType> > /res/=python::object())
72	72	{
73	73	NoiseNormalizationOptions noiseNormalizationOptions;
74	74	noiseNormalizationOptions

98	98	double averagingQuantile=0.8,
99	99	double noiseEstimationQuantile=1.5,
100	100	double noiseVarianceInitialGuess=10.0,
101		NumpyArray<3, Multiband<PixelType> > res=python::object())
	101	NumpyArray<3, Multiband<PixelType> > /res/=python::object())
102	102	{
103	103	NoiseNormalizationOptions noiseNormalizationOptions;
104	104	noiseNormalizationOptions

+11

-11

vigranumpy/src/core/pythonaccumulator.hxx less more

61	61	{}
62	62
63	63	template <class Permutation>
64		GetTag_Visitor(Permutation const & p)
	64	GetTag_Visitor(Permutation const &)
65	65	{}
66	66
67	67	python::object to_python(signed char t) const { return python::object(t); }

190	190	struct ToPythonArray<TAG, Error__Attempt_to_access_inactive_statistic<T>, Accu>
191	191	{
192	192	template <class Permutation>
193		static python::object exec(Accu & a, Permutation const & p)
	193	static python::object exec(Accu &, Permutation const &)
194	194	{
195	195	vigra_precondition(false, "PythonAccumulator::get(): Attempt to access inactive statistic.");
196	196	return python::object();

201	201	struct ToPythonArray<TAG, std::pair<T1, T2>, Accu>
202	202	{
203	203	template <class Permutation>
204		static python::object exec(Accu & a, Permutation const & p)
	204	static python::object exec(Accu &, Permutation const &)
205	205	{
206	206	vigra_precondition(false, "PythonAccumulator::get(): Export for this statistic is not implemented, sorry.");
207	207	return python::object();

282	282
283	283	struct PythonFeatureAccumulator
284	284	{
285		virtual void activate(std::string const & tag) { throw std::runtime_error("abstract function called."); }
286		virtual bool isActive(std::string const & tag) const { throw std::runtime_error("abstract function called."); return false; }
	285	virtual void activate(std::string const &) { throw std::runtime_error("abstract function called."); }
	286	virtual bool isActive(std::string const &) const { throw std::runtime_error("abstract function called."); return false; }
287	287	virtual python::list activeNames() const { throw std::runtime_error("abstract function called."); return python::list(); }
288	288	virtual python::list names() const { throw std::runtime_error("abstract function called."); return python::list(); }
289		virtual python::object get(std::string const & tag) { throw std::runtime_error("abstract function called."); return python::object(); }
290		virtual void merge(PythonFeatureAccumulator const & o) { throw std::runtime_error("abstract function called."); }
	289	virtual python::object get(std::string const &) { throw std::runtime_error("abstract function called."); return python::object(); }
	290	virtual void merge(PythonFeatureAccumulator const &) { throw std::runtime_error("abstract function called."); }
291	291	virtual PythonFeatureAccumulator * create() const { throw std::runtime_error("abstract function called."); return 0; }
292	292	virtual ~PythonFeatureAccumulator() {}
293	293

329	329	: public PythonFeatureAccumulator
330	330	{
331	331	virtual MultiArrayIndex maxRegionLabel() { throw std::runtime_error("abstract function called."); }
332		virtual void mergeAll(PythonRegionFeatureAccumulator const & o) { throw std::runtime_error("abstract function called."); }
333		virtual void remappingMerge(PythonFeatureAccumulator const & o, NumpyArray<1, npy_uint32> labelMapping) { throw std::runtime_error("abstract function called."); }
334		virtual void mergeRegions(npy_uint32 i, npy_uint32 j) { throw std::runtime_error("abstract function called."); }
	332	virtual void mergeAll(PythonRegionFeatureAccumulator const &) { throw std::runtime_error("abstract function called."); }
	333	virtual void remappingMerge(PythonRegionFeatureAccumulator const &, NumpyArray<1, npy_uint32>) { throw std::runtime_error("abstract function called."); }
	334	virtual void mergeRegions(npy_uint32, npy_uint32) { throw std::runtime_error("abstract function called."); }
335	335	virtual PythonRegionFeatureAccumulator * create() const { throw std::runtime_error("abstract function called."); return 0; }
336	336
337	337	static void definePythonClass()

454	454	merge(o);
455	455	}
456	456
457		void remappingMerge(PythonFeatureAccumulator const & o, NumpyArray<1, npy_uint32> labelMapping)
	457	void remappingMerge(PythonRegionFeatureAccumulator const & o, NumpyArray<1, npy_uint32> labelMapping)
458	458	{
459	459	PythonAccumulator const * p = dynamic_cast<PythonAccumulator const *>(&o);
460	460	if(p == 0)

+2

-2

vigranumpy/src/core/random_forest.cxx less more

17	17	/* Software is furnished to do so, subject to the following */
18	18	/* conditions: */
19	19	/* */
20		/* The above copyrigfht notice and this permission notice shall be */
	20	/* The above copyright notice and this permission notice shall be */
21	21	/* included in all copies or substantial portions of the */
22	22	/* Software. */
23	23	/* */

167	167	double
168	168	pythonLearnRandomForest(RandomForest<LabelType> & rf,
169	169	NumpyArray<2,FeatureType> trainData,
170		NumpyArray<2,LabelType> trainLabels,
	170	NumpyArray<2,LabelType> trainLabels, // FIXME why are the labels 2d ?!
171	171	UInt32 randomSeed=0,
172	172	int maxdepth=-1,
173	173	int minsize=0)

+263

-0

vigranumpy/src/core/random_forest_3.cxx less more

	0	/************************************************************************/
	1	/* */
	2	/* Copyright 2009 by Ullrich Koethe */
	3	/* */
	4	/* This file is part of the VIGRA computer vision library. */
	5	/* The VIGRA Website is */
	6	/* http://hci.iwr.uni-heidelberg.de/vigra/ */
	7	/* Please direct questions, bug reports, and contributions to */
	8	/* ullrich.koethe@iwr.uni-heidelberg.de or */
	9	/* vigra@informatik.uni-hamburg.de */
	10	/* */
	11	/* Permission is hereby granted, free of charge, to any person */
	12	/* obtaining a copy of this software and associated documentation */
	13	/* files (the "Software"), to deal in the Software without */
	14	/* restriction, including without limitation the rights to use, */
	15	/* copy, modify, merge, publish, distribute, sublicense, and/or */
	16	/* sell copies of the Software, and to permit persons to whom the */
	17	/* Software is furnished to do so, subject to the following */
	18	/* conditions: */
	19	/* */
	20	/* The above copyright notice and this permission notice shall be */
	21	/* included in all copies or substantial portions of the */
	22	/* Software. */
	23	/* */
	24	/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND */
	25	/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES */
	26	/* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND */
	27	/* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT */
	28	/* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, */
	29	/* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING */
	30	/* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR */
	31	/* OTHER DEALINGS IN THE SOFTWARE. */
	32	/* */
	33	/************************************************************************/
	34
	35	#define PY_ARRAY_UNIQUE_SYMBOL vigranumpylearning_PyArray_API
	36	#define NO_IMPORT_ARRAY
	37
	38	#include <vigra/numpy_array.hxx>
	39	#include <vigra/numpy_array_converters.hxx>
	40	#include <vigra/random_forest_3.hxx>
	41
	42	#ifdef HasHDF5
	43	# include <vigra/random_forest_3_hdf5_impex.hxx>
	44	#endif
	45
	46	#include <boost/python.hpp>
	47
	48	//#include <vigra/timing.hxx>
	49	//#include <vigra/random.hxx>
	50	//#include <set>
	51	//#include <cmath>
	52	//#include <memory>
	53
	54	namespace python = boost::python;
	55
	56	namespace vigra
	57	{
	58	namespace rf3
	59	{
	60
	61	typedef float FeatureType;
	62	typedef uint32_t LabelType;
	63	typedef NumpyArray<2,FeatureType> FeatureArrayType;
	64	typedef NumpyArray<1,LabelType> LabelArrayType; // FIXME TODO dunno if this needs to be 1 or 2d
	65	typedef DefaultRF<FeatureArrayType,LabelArrayType>::type RandomForestType;
	66
	67	// random forest constructor
	68	RandomForestType *
	69	pythonConstructRandomForest3(
	70	FeatureArrayType features,
	71	LabelArrayType labels,
	72	int treeCount,
	73	int mtry,
	74	int min_split_node_size,
	75	bool sample_with_replacement,
	76	bool sample_classes_individually,
	77	size_t resample_count,
	78	size_t max_depth,
	79	double tau,
	80	size_t n_threads
	81	)
	82	{
	83
	84	RandomForestOptions rf_opts;
	85
	86	rf_opts.tree_count(treeCount);
	87
	88	if(mtry > 0)
	89	rf_opts.features_per_node(mtry);
	90
	91	// TODO training_set_size -> can't find the corresponding parameter, afaik this is the number of bootstrap samples used
	92
	93	rf_opts.bootstrap_sampling(sample_with_replacement);
	94	rf_opts.min_num_instances(min_split_node_size);
	95	rf_opts.use_stratification(sample_classes_individually);
	96
	97	// this is the number of instances that is resampled in each split / this disables bootstrap sampling and
	98	rf_opts.resample_count(resample_count);
	99
	100	// expose the max tree depth, not in old rf afaik
	101	rf_opts.max_depth(max_depth);
	102
	103	//expose node complexity, not in okd rf afaik
	104	rf_opts.node_complexity_tau(tau);
	105
	106	// expose n_threads for multithreading
	107	rf_opts.n_threads(n_threads);
	108
	109	// TODO expose class_weights
	110	// class_weights(std::vector<double> const & v)
	111
	112	// TODO expose the split criterion (GINI, ENTTROPY, KSD), not in old rf afaik
	113	// split(RandomForestOptionTags p_split)
	114
	115	// return pointer to the random forest
	116	PyAllowThreads _pythread;
	117	RandomForestType rf_tmp = random_forest(features, labels, rf_opts);
	118	RandomForestType * rf = new RandomForestType(rf_tmp);
	119	return rf;
	120	}
	121
	122	// prediction
	123	NumpyAnyArray
	124	pythonPredictProbabilities(const RandomForestType & rf,
	125	FeatureArrayType features,
	126	size_t n_threads,
	127	NumpyArray<2,float> res) {
	128
	129	res.reshapeIfEmpty(MultiArrayShape<2>::type(features.shape(0), rf.num_classes()),
	130	"RandomForest.predictProbabilities(): Output array has wrong dimensions.");
	131	{
	132	PyAllowThreads _pythread;
	133	rf.predict_probabilities(features, res, n_threads);
	134	}
	135	return res;
	136	}
	137
	138	NumpyAnyArray
	139	pythonPredictLabels(const RandomForestType & rf,
	140	FeatureArrayType features,
	141	size_t n_threads,
	142	NumpyArray<1,LabelType> res) {
	143
	144	res.reshapeIfEmpty(MultiArrayShape<1>::type(features.shape(0)),
	145	"RandomForest.predictProbabilities(): Output array has wrong dimensions.");
	146	{
	147	PyAllowThreads _pythread;
	148	rf.predict(features, res, n_threads);
	149	}
	150	return res;
	151	}
	152
	153	#ifdef HasHDF5
	154	RandomForestType *
	155	pythonImportFromHDF5(const std::string & filename, const std::string & pathname )
	156	{
	157	HDF5File h5ctx(filename);
	158	RandomForestType rf_tmp = random_forest_import_HDF5<FeatureArrayType,LabelArrayType>(h5ctx, pathname);
	159	RandomForestType * rf = new RandomForestType(rf_tmp);
	160	return rf;
	161	}
	162
	163	void pythonExportHDF5(const RandomForestType & rf,
	164	const std::string & filename,
	165	const std::string & pathname)
	166	{
	167	HDF5File h5ctx(filename, HDF5File::ReadWrite );
	168	random_forest_export_HDF5(rf, h5ctx, pathname);
	169	}
	170	#endif // HasHDF5
	171
	172	// expose the rf 3 to python
	173	// expose the rf 3 as a python class + basic API
	174	void exportRandomForest3()
	175	{
	176	using namespace python;
	177
	178	docstring_options doc_options(true, true, false);
	179
	180	enum_<RandomForestOptionTags>("RF3_MTRY_SWITCH")
	181	.value("RF3_MTRY_LOG", vigra::rf3::RF_LOG)
	182	.value("RF3_MTRY_SQRT",vigra::rf3::RF_SQRT)
	183	.value("RF3_MTRY_ALL", vigra::rf3::RF_ALL);
	184
	185	class_<RandomForestType> rfclass3("RandomForest3",python::no_init);
	186	//class_<RandomForestType> rfclass3("RandomForest3");
	187
	188	rfclass3
	189	.def("__init__",
	190	python::make_constructor(registerConverters(&pythonConstructRandomForest3),
	191	boost::python::default_call_policies(),
	192	(arg("features"),
	193	arg("labels"),
	194	arg("treeCount")=255,
	195	arg("mtry")= -1,
	196	arg("min_split_node_size")=1,
	197	arg("sample_with_replacement")=true,
	198	arg("sample_classes_individually")=false,
	199	arg("resample_count")=0,
	200	arg("max_depth")=0,
	201	arg("tau")=-1,
	202	arg("n_threads")=1)
	203	),
	204	"\nConstruct a new random forest::\n\n"
	205	" RandomForest(features, labels, treeCount = 255, mtry=RF_SQRT, min_split_node_size=1,\n"
	206	" training_set_size=0, training_set_proportions=1.0,\n"
	207	" sample_with_replacement=True, sample_classes_individually=False,\n"
	208	" )\n\n"
	209	"treeCount:\n"
	210	" controls the number of trees that are created.\n"
	211	"See RandomForest_ and RandomForestOptions_ in the C++ documentation "
	212	"for the meaning of the other parameters.\n")
	213	#ifdef HasHDF5
	214	.def("__init__",python::make_constructor(&pythonImportFromHDF5,
	215	boost::python::default_call_policies(),
	216	( arg("filename"),
	217	arg("pathInFile"))),
	218	"\nLoad from HDF5 file::\n\n"
	219	" RandomForest(filename, pathInFile)\n\n")
	220	.def("writeHDF5", &pythonExportHDF5,
	221	boost::python::default_call_policies(),
	222	( arg("filename"),
	223	arg("pathInFile")),
	224	"Store the random forest in the given HDF5 file 'filename' under the internal\n"
	225	"path 'pathInFile'.\n")
	226	#endif // HasHDF5
	227	.def("featureCount",
	228	&RandomForestType::num_features,
	229	"Returns the number of features the RandomForest works with.\n")
	230	.def("labelCount",
	231	&RandomForestType::num_classes,
	232	"Returns the number of labels, the RandomForest knows.\n")
	233	.def("treeCount",
	234	&RandomForestType::num_trees,
	235	"Returns the 'treeCount', that was set when constructing the RandomForest.\n")
	236	.def("predictProbabilities",
	237	registerConverters(&pythonPredictProbabilities),
	238	(
	239	arg("features"),
	240	arg("n_threads")=1,
	241	arg("out")=object()
	242	),
	243	"Predict probabilities for different classes on 'testData'.\n\n"
	244	"The output is an array containing a probability for every test sample and class.\n")
	245	.def("predictLabels",
	246	registerConverters(&pythonPredictLabels),
	247	(
	248	arg("features"),
	249	arg("n_threads")=1,
	250	arg("out")=object()),
	251	"Predict labels on 'features'.\n\n"
	252	"The output is an array containing a label for every test samples.\n")
	253	;
	254	}
	255
	256
	257
	258
	259	} // end namespace rf3
	260	} // end namepace vigra
	261
	262

+283

-1

vigranumpy/src/core/segmentation.cxx less more

50	50	#include <vigra/multi_convolution.hxx>
51	51	#include <vigra/slic.hxx>
52	52	#include <vigra/seg_to_seeds.hxx>
53
	53	#include <vigra/multi_pointoperators.hxx>
54	54
55	55	#include <string>
56	56	#include <cmath>
	57	#include <unordered_set>
	58	#include <unordered_map>
	59	#include <algorithm>
	60
	61	#include <boost/python/stl_iterator.hpp>
57	62
58	63	#include "tws.hxx"
59	64

1076	1081	.blockShape(blockShape));
1077	1082	return python::make_tuple(out, nSeg);
1078	1083	}
	1084
	1085	/** \brief Map all values in src to new values using the given mapping (a dict).
	1086	* See python docstring for details.
	1087	*/
	1088	template <unsigned int NDIM, class SrcVoxelType, class DestVoxelType>
	1089	NumpyAnyArray
	1090	pythonApplyMapping(NumpyArray<NDIM, Singleband<SrcVoxelType> > src,
	1091	python::dict mapping,
	1092	bool allow_incomplete_mapping = false,
	1093	NumpyArray<NDIM, Singleband<DestVoxelType> > res = NumpyArray<NDIM, Singleband<SrcVoxelType> >())
	1094	{
	1095	using namespace boost::python;
	1096
	1097	res.reshapeIfEmpty(src.taggedShape(), "applyMapping(): Output array has wrong shape.");
	1098
	1099	// Copy dict into a c++ unordered_map of ints,
	1100	// which is ~10x faster than using a Python dict
	1101	typedef std::unordered_map<SrcVoxelType, DestVoxelType> labelmap_t;
	1102	labelmap_t labelmap(2len(mapping)); // Using 2N buckets seems to speed things up by 10%
	1103
	1104	typedef stl_input_iterator<tuple> dict_iter_t;
	1105
	1106	#if PY_MAJOR_VERSION < 3
	1107	dict_iter_t map_iter = mapping.iteritems();
	1108	#else
	1109	dict_iter_t map_iter = mapping.items();
	1110	#endif
	1111
	1112	for (; map_iter != dict_iter_t(); ++map_iter)
	1113	{
	1114	object key = (*map_iter)[0];
	1115	object value = (*map_iter)[1];
	1116	labelmap[extract<SrcVoxelType>(key)] = extract<DestVoxelType>(value);
	1117	}
	1118
	1119	// Enforce const capture in the lambda below.
	1120	labelmap_t const & _labelmap = labelmap;
	1121
	1122	{
	1123	std::unique_ptr<PyAllowThreads> pythread_ptr(new PyAllowThreads);
	1124
	1125	transformMultiArray(src, res,
	1126	[&_labelmap, allow_incomplete_mapping, &pythread_ptr](SrcVoxelType px) -> DestVoxelType {
	1127	typename labelmap_t::const_iterator iter = _labelmap.find(px);
	1128
	1129	if (iter != _labelmap.end())
	1130	{
	1131	return iter->second;
	1132	}
	1133
	1134	if (allow_incomplete_mapping)
	1135	{
	1136	// Key is missing. Return the original value.
	1137	return static_cast<DestVoxelType>(px);
	1138	}
	1139
	1140	// Reclaim the GIL before setting the error string.
	1141	pythread_ptr.reset();
	1142
	1143	std::ostringstream err_msg;
	1144	err_msg << "Key not found in mapping: " << +px;
	1145	PyErr_SetString( PyExc_KeyError, err_msg.str().c_str() );
	1146	python::throw_error_already_set();
	1147
	1148	return 0; // unreachable line
	1149	});
	1150	}
	1151
	1152	return res;
	1153	}
	1154
	1155	// Unfortunately, can't use this macro because the template args uses TWO dtypes
	1156	//VIGRA_PYTHON_MULTITYPE_FUNCTOR_NDIM(pyApplyMapping, pythonApplyMapping)
	1157
	1158
	1159	/** \brief Find unique values in the given array.
	1160	*/
	1161	template <class VoxelType, unsigned int NDIM>
	1162	NumpyAnyArray
	1163	pythonUnique(NumpyArray<NDIM, Singleband<VoxelType> > src, bool sort=true)
	1164	{
	1165	std::unordered_set<VoxelType> labelset;
	1166	auto f = [&labelset](VoxelType px) { labelset.insert(px); };
	1167	inspectMultiArray(src, f);
	1168
	1169	NumpyArray<1, VoxelType> result;
	1170	result.reshape( Shape1(labelset.size()) );
	1171	std::copy( labelset.begin(), labelset.end(), result.begin() );
	1172
	1173	if (sort)
	1174	{
	1175	std::sort( result.begin(), result.end() );
	1176	}
	1177	return result;
	1178	}
	1179
	1180	VIGRA_PYTHON_MULTITYPE_FUNCTOR_NDIM(pyUnique, pythonUnique)
	1181
	1182
	1183	/** \brief Relabel an array such that all labels are consecutive
	1184	* (i.e. there are no gaps in the label values used by the array)
	1185	* See python docstring below for details.
	1186	*/
	1187	template <unsigned int NDIM, class SrcVoxelType, class DestVoxelType>
	1188	boost::python::tuple
	1189	pythonRelabelConsecutive(NumpyArray<NDIM, Singleband<SrcVoxelType> > src,
	1190	DestVoxelType start_label = 1,
	1191	bool keep_zeros = true,
	1192	NumpyArray<NDIM, Singleband<DestVoxelType> > res = NumpyArray<NDIM, Singleband<SrcVoxelType> >())
	1193	{
	1194	using namespace boost::python;
	1195	res.reshapeIfEmpty(src.taggedShape(), "relabelConsecutive(): Output array has wrong shape.");
	1196
	1197	std::unordered_map<SrcVoxelType, DestVoxelType> labelmap;
	1198	if (keep_zeros)
	1199	{
	1200	vigra_precondition(!keep_zeros \|\| start_label > 0,
	1201	"relabelConsecutive(): start_label must be non-zero if using keep_zeros=True");
	1202
	1203	// pre-initialize the mapping to keep zeros unchanged
	1204	labelmap[0] = 0;
	1205	}
	1206
	1207	{
	1208	PyAllowThreads _pythread;
	1209
	1210	transformMultiArray(src, res,
	1211	[&](SrcVoxelType px) -> DestVoxelType {
	1212	auto iter = labelmap.find(px);
	1213	if (iter != labelmap.end())
	1214	{
	1215	return iter->second;
	1216	}
	1217	// We haven't seen this label yet.
	1218	// Create a new entry in the hash table.
	1219	DestVoxelType newlabel = labelmap.size() - int(keep_zeros) + start_label;
	1220	labelmap[px] = newlabel;
	1221	return newlabel;
	1222	});
	1223	}
	1224
	1225	// Convert labelmap to dict
	1226	dict labelmap_dict;
	1227	for (auto old_new_pair : labelmap)
	1228	{
	1229	labelmap_dict[old_new_pair.first] = old_new_pair.second;
	1230	}
	1231
	1232	DestVoxelType max_label = labelmap.size() - int(keep_zeros) - 1 + start_label;
	1233	return make_tuple(res, max_label, labelmap_dict);
	1234	}
	1235
	1236	// Unfortunately, can't use this macro because the template args uses TWO dtypes
	1237	//VIGRA_PYTHON_MULTITYPE_FUNCTOR_NDIM(pyRelabelConsecutive, pythonRelabelConsecutive)
	1238
1079	1239
1080	1240	void defineSegmentation()
1081	1241	{

1451	1611	"\n"
1452	1612	"The function returns a Python tuple (labelImage, maxRegionLabel)\n"
1453	1613	"\n");
	1614
	1615	multidef("unique",
	1616	pyUnique<1,5,npy_uint8, npy_uint32, npy_uint64, npy_int64>(),
	1617	(arg("arr"), arg("sort")=true),
	1618	"Find unique values in the given label array.\n"
	1619	"If ``sort`` is True, then the output is sorted.\n"
	1620	"Much faster then ``numpy.unique()``.\n");
	1621
	1622	//-- 3D relabelConsecutive
	1623	def("relabelConsecutive", registerConverters(&pythonRelabelConsecutive<3, npy_uint64, npy_uint32>),
	1624	(arg("labels"), arg("start_label")=1, arg("keep_zeros")=true, arg("out")=python::object()),
	1625	"Relabel the given label image to have consecutive label values.\n"
	1626	"Note: The relative order between label values will not necessarily be preserved.\n"
	1627	"\n"
	1628	"Parameters\n"
	1629	"----------\n"
	1630	"labels: ndarray\n"
	1631	"start_label: The lowest label of the output array.\n"
	1632	"keep_zeros: Don't relabel zero-valued items.\n"
	1633	"out: ndarray to hold the data. If None, it will be allocated for you.\n"
	1634	" A combination of uint64 labels and uint32 'out' is permitted.\n"
	1635	"\n"
	1636	"Returns a tuple of ``(newlabels, maxlabel, mapping)``, where:\n"
	1637	"``maxlabel`` is the maximum label of the new labels, and\n"
	1638	"``mapping`` is a dict showing how the old labels were converted to the new label values.\n"
	1639	"\n"
	1640	"Note: As with other vigra functions, you should provide accurate axistags for optimal performance.\n");
	1641	def("relabelConsecutive", registerConverters(&pythonRelabelConsecutive<3, npy_uint64, npy_uint64>), (arg("labels"), arg("start_label")=1, arg("keep_zeros")=true, arg("out")=python::object()));
	1642	def("relabelConsecutive", registerConverters(&pythonRelabelConsecutive<3, npy_uint32, npy_uint32>), (arg("labels"), arg("start_label")=1, arg("keep_zeros")=true, arg("out")=python::object()));
	1643	def("relabelConsecutive", registerConverters(&pythonRelabelConsecutive<3, npy_uint8, npy_uint8>), (arg("labels"), arg("start_label")=1, arg("keep_zeros")=true, arg("out")=python::object()));
	1644
	1645	//-- 2D relabelConsecutive
	1646	def("relabelConsecutive", registerConverters(&pythonRelabelConsecutive<2, npy_uint64, npy_uint32>), (arg("labels"), arg("start_label")=1, arg("keep_zeros")=true, arg("out")=python::object()));
	1647	def("relabelConsecutive", registerConverters(&pythonRelabelConsecutive<2, npy_uint64, npy_uint64>), (arg("labels"), arg("start_label")=1, arg("keep_zeros")=true, arg("out")=python::object()));
	1648	def("relabelConsecutive", registerConverters(&pythonRelabelConsecutive<2, npy_uint32, npy_uint32>), (arg("labels"), arg("start_label")=1, arg("keep_zeros")=true, arg("out")=python::object()));
	1649	def("relabelConsecutive", registerConverters(&pythonRelabelConsecutive<2, npy_uint8, npy_uint8>), (arg("labels"), arg("start_label")=1, arg("keep_zeros")=true, arg("out")=python::object()));
	1650
	1651	//-- 1D relabelConsecutive
	1652	def("relabelConsecutive", registerConverters(&pythonRelabelConsecutive<1, npy_uint64, npy_uint32>), (arg("labels"), arg("start_label")=1, arg("keep_zeros")=true, arg("out")=python::object()));
	1653	def("relabelConsecutive", registerConverters(&pythonRelabelConsecutive<1, npy_uint64, npy_uint64>), (arg("labels"), arg("start_label")=1, arg("keep_zeros")=true, arg("out")=python::object()));
	1654	def("relabelConsecutive", registerConverters(&pythonRelabelConsecutive<1, npy_uint32, npy_uint32>), (arg("labels"), arg("start_label")=1, arg("keep_zeros")=true, arg("out")=python::object()));
	1655	def("relabelConsecutive", registerConverters(&pythonRelabelConsecutive<1, npy_uint8, npy_uint8>), (arg("labels"), arg("start_label")=1, arg("keep_zeros")=true, arg("out")=python::object()));
	1656
	1657
	1658	// Lots of overloads here to allow mapping between arrays of different dtypes.
	1659	// -- 3D
	1660	// 64 --> 32
	1661	def("applyMapping", registerConverters(&pythonApplyMapping<3, npy_uint64, npy_uint32>),
	1662	(arg("labels"), arg("mapping"), arg("allow_incomplete_mapping")=false, arg("out")=python::object()),
	1663	"Map all values in `labels` to new values using the given mapping (a dict).\n"
	1664	"Useful for maps with large values, for which a numpy index array would need too much RAM.\n"
	1665	"To relabel in-place, set `out=labels`.\n"
	1666	"\n"
	1667	"Parameters\n"
	1668	"----------\n"
	1669	"labels: ndarray\n"
	1670	"mapping: dict of ``{old_label : new_label}``\n"
	1671	"allow_incomplete_mapping: If True, then any voxel values in the original data that are missing\n"
	1672	" from the mapping dict will be copied (and casted) into the output.\n"
	1673	" Otherwise, an ``IndexError`` will be raised if the map is incomplete\n"
	1674	" for the input data.\n"
	1675	"out: ndarray to hold the data. If None, it will be allocated for you.\n"
	1676	" The dtype of ``out`` is allowed to be smaller (or bigger) than the dtype of ``labels``.\n"
	1677	"\n"
	1678	"Note: As with other vigra functions, you should provide accurate axistags for optimal performance.\n");
	1679
	1680	// 8 <--> 32
	1681	def("applyMapping", registerConverters(&pythonApplyMapping<3, npy_uint8, npy_uint32>), (arg("src"), arg("mapping"), arg("allow_incomplete_mapping")=false, arg("out")=python::object()));
	1682	def("applyMapping", registerConverters(&pythonApplyMapping<3, npy_uint32, npy_uint8>), (arg("src"), arg("mapping"), arg("allow_incomplete_mapping")=false, arg("out")=python::object()));
	1683
	1684	// 32 <--> 64
	1685	def("applyMapping", registerConverters(&pythonApplyMapping<3, npy_uint32, npy_uint64>), (arg("src"), arg("mapping"), arg("allow_incomplete_mapping")=false, arg("out")=python::object()));
	1686	//def("applyMapping", registerConverters(&pythonApplyMapping<3, npy_uint64, npy_uint32>), (arg("src"), arg("mapping"), arg("allow_incomplete_mapping")=false, arg("out")=python::object()));
	1687
	1688	// 8 <--> 64
	1689	def("applyMapping", registerConverters(&pythonApplyMapping<3, npy_uint8, npy_uint64>), (arg("src"), arg("mapping"), arg("allow_incomplete_mapping")=false, arg("out")=python::object()));
	1690	def("applyMapping", registerConverters(&pythonApplyMapping<3, npy_uint64, npy_uint8>), (arg("src"), arg("mapping"), arg("allow_incomplete_mapping")=false, arg("out")=python::object()));
	1691
	1692	// Cases for same input/output dtypes must come last, so they are chosen by default!
	1693	// 8 <--> 8, 32 <--> 32, 64 <--> 64
	1694	def("applyMapping", registerConverters(&pythonApplyMapping<3, npy_uint64, npy_uint64>), (arg("src"), arg("mapping"), arg("allow_incomplete_mapping")=false, arg("out")=python::object()));
	1695	def("applyMapping", registerConverters(&pythonApplyMapping<3, npy_uint32, npy_uint32>), (arg("src"), arg("mapping"), arg("allow_incomplete_mapping")=false, arg("out")=python::object()));
	1696	def("applyMapping", registerConverters(&pythonApplyMapping<3, npy_uint8, npy_uint8>), (arg("src"), arg("mapping"), arg("allow_incomplete_mapping")=false, arg("out")=python::object()));
	1697
	1698	// -- 2D
	1699	// 8 <--> 32
	1700	def("applyMapping", registerConverters(&pythonApplyMapping<2, npy_uint8, npy_uint32>), (arg("src"), arg("mapping"), arg("allow_incomplete_mapping")=false, arg("out")=python::object()));
	1701	def("applyMapping", registerConverters(&pythonApplyMapping<2, npy_uint32, npy_uint8>), (arg("src"), arg("mapping"), arg("allow_incomplete_mapping")=false, arg("out")=python::object()));
	1702
	1703	// 32 <--> 64
	1704	def("applyMapping", registerConverters(&pythonApplyMapping<2, npy_uint32, npy_uint64>), (arg("src"), arg("mapping"), arg("allow_incomplete_mapping")=false, arg("out")=python::object()));
	1705	def("applyMapping", registerConverters(&pythonApplyMapping<2, npy_uint64, npy_uint32>), (arg("src"), arg("mapping"), arg("allow_incomplete_mapping")=false, arg("out")=python::object()));
	1706
	1707	// 8 <--> 64
	1708	def("applyMapping", registerConverters(&pythonApplyMapping<2, npy_uint8, npy_uint64>), (arg("src"), arg("mapping"), arg("allow_incomplete_mapping")=false, arg("out")=python::object()));
	1709	def("applyMapping", registerConverters(&pythonApplyMapping<2, npy_uint64, npy_uint8>), (arg("src"), arg("mapping"), arg("allow_incomplete_mapping")=false, arg("out")=python::object()));
	1710
	1711	// Cases for same input/output dtypes must come last, so they are chosen by default!
	1712	// 8 <--> 8, 32 <--> 32, 64 <--> 64
	1713	def("applyMapping", registerConverters(&pythonApplyMapping<2, npy_uint32, npy_uint32>), (arg("src"), arg("mapping"), arg("allow_incomplete_mapping")=false, arg("out")=python::object()));
	1714	def("applyMapping", registerConverters(&pythonApplyMapping<2, npy_uint64, npy_uint64>), (arg("src"), arg("mapping"), arg("allow_incomplete_mapping")=false, arg("out")=python::object()));
	1715	def("applyMapping", registerConverters(&pythonApplyMapping<2, npy_uint8, npy_uint8>), (arg("src"), arg("mapping"), arg("allow_incomplete_mapping")=false, arg("out")=python::object()));
	1716
	1717	// -- 1D
	1718
	1719	// 8 <--> 32
	1720	def("applyMapping", registerConverters(&pythonApplyMapping<1, npy_uint8, npy_uint32>), (arg("src"), arg("mapping"), arg("allow_incomplete_mapping")=false, arg("out")=python::object()));
	1721	def("applyMapping", registerConverters(&pythonApplyMapping<1, npy_uint32, npy_uint8>), (arg("src"), arg("mapping"), arg("allow_incomplete_mapping")=false, arg("out")=python::object()));
	1722
	1723	// 32 <--> 64
	1724	def("applyMapping", registerConverters(&pythonApplyMapping<1, npy_uint32, npy_uint64>), (arg("src"), arg("mapping"), arg("allow_incomplete_mapping")=false, arg("out")=python::object()));
	1725	def("applyMapping", registerConverters(&pythonApplyMapping<1, npy_uint64, npy_uint32>), (arg("src"), arg("mapping"), arg("allow_incomplete_mapping")=false, arg("out")=python::object()));
	1726
	1727	// 8 <--> 64
	1728	def("applyMapping", registerConverters(&pythonApplyMapping<1, npy_uint8, npy_uint64>), (arg("src"), arg("mapping"), arg("allow_incomplete_mapping")=false, arg("out")=python::object()));
	1729	def("applyMapping", registerConverters(&pythonApplyMapping<1, npy_uint64, npy_uint8>), (arg("src"), arg("mapping"), arg("allow_incomplete_mapping")=false, arg("out")=python::object()));
	1730
	1731	// Cases for same input/output dtypes must come last, so they are chosen by default!
	1732	// 8 <--> 8, 32 <--> 32, 64 <--> 64
	1733	def("applyMapping", registerConverters(&pythonApplyMapping<1, npy_uint32, npy_uint32>), (arg("src"), arg("mapping"), arg("allow_incomplete_mapping")=false, arg("out")=python::object()));
	1734	def("applyMapping", registerConverters(&pythonApplyMapping<1, npy_uint64, npy_uint64>), (arg("src"), arg("mapping"), arg("allow_incomplete_mapping")=false, arg("out")=python::object()));
	1735	def("applyMapping", registerConverters(&pythonApplyMapping<1, npy_uint8, npy_uint8>), (arg("src"), arg("mapping"), arg("allow_incomplete_mapping")=false, arg("out")=python::object()));
1454	1736	}
1455	1737
1456	1738	void defineEdgedetection();

+1

-1

vigranumpy/src/fourier/CMakeLists.txt less more

0		INCLUDE_DIRECTORIES(${VIGRANUMPY_INCLUDE_DIRS} ${FFTW3_INCLUDE_DIR})
	0	INCLUDE_DIRECTORIES(${SUPPRESS_WARNINGS} ${VIGRANUMPY_INCLUDE_DIRS} ${FFTW3_INCLUDE_DIR})
1	1
2	2	VIGRA_ADD_NUMPY_MODULE(fourier
3	3	SOURCES

+1

-1

vigranumpy/test/CMakeLists.txt less more

0		INCLUDE_DIRECTORIES(${VIGRANUMPY_INCLUDE_DIRS})
	0	INCLUDE_DIRECTORIES(${SUPPRESS_WARNINGS} ${VIGRANUMPY_INCLUDE_DIRS})
1	1
2	2	SET(TEST_SCRIPTS
3	3	test_arraytypes.py

+115

-0

vigranumpy/test/test_segmentation.py less more

32	32	_impl_test_labelMultiArray(numpy.uint8)
33	33	_impl_test_labelMultiArray(numpy.uint32)
34	34	_impl_test_labelMultiArray(numpy.float32)
	35
	36
	37	def _impl_test_applyMapping(dtype):
	38	original = numpy.arange(100, dtype=dtype ).reshape(10,10)
	39	mapping = dict( zip( original.flat[:], original.flat[:] + 100 ) )
	40
	41	# Not in-place
	42	remapped = vigra.analysis.applyMapping(original, mapping)
	43	assert remapped.dtype == original.dtype, "Default output dtype did not match input dtype!"
	44	assert (remapped == original+100).all()
	45
	46	# in-place
	47	original_copy = original.copy()
	48	vigra.analysis.applyMapping(original_copy, mapping, out=original_copy)
	49	assert (original_copy == original+100).all()
	50
	51	# Different dtypes
	52	mapping = dict( zip( original.flat[:], (original.flat[:] + 100).astype(numpy.uint64) ) )
	53
	54	result = numpy.zeros_like( original, dtype=numpy.uint64 )
	55	vigra.analysis.applyMapping(original, mapping, out=result)
	56	assert (result == original+100).all()
	57
	58	mapping = dict( zip( original.flat[:], (original.flat[:] + 100).astype(numpy.uint8) ) )
	59
	60	result = numpy.zeros_like( original, dtype=numpy.uint8 )
	61	vigra.analysis.applyMapping(original, mapping, out=result)
	62	assert (result == original+100).all()
	63
	64	# Incomplete mapping
	65	for i in range(10):
	66	del mapping[i]
	67
	68	remapped = vigra.analysis.applyMapping(original, mapping, allow_incomplete_mapping=True)
	69	assert (remapped[0] == original[0]).all()
	70	assert (remapped[1:] == original[1:]+100).all()
35	71
	72	try:
	73	remapped = vigra.analysis.applyMapping(original, mapping, allow_incomplete_mapping=False)
	74	except KeyError:
	75	pass
	76	else:
	77	assert False, "Expected to get an exception due to the incomplete mapping!"
	78
	79	def test_applyMapping():
	80	_impl_test_applyMapping(numpy.uint8)
	81	_impl_test_applyMapping(numpy.uint32)
	82	_impl_test_applyMapping(numpy.uint64)
	83
	84	def _impl_test_unique(dtype):
	85	a = numpy.array([2,3,5,7,11,13,17,19,23,29] + [2,3,5,7,11,13,17,19,23,29], dtype=dtype)
	86	u = vigra.analysis.unique(a, sort=True)
	87	assert (u == [2,3,5,7,11,13,17,19,23,29]).all()
	88
	89	def test_unique():
	90	_impl_test_unique(numpy.uint8)
	91	_impl_test_unique(numpy.uint32)
	92	_impl_test_unique(numpy.uint64)
	93
	94	def _impl_relabelConsecutive(dtype):
	95	start = 17
	96	a = numpy.random.randint(start,start+100, size=(100,100) ).astype(dtype)
	97	a[-1] = numpy.arange(start,start+100, dtype=dtype) # Make sure every number is used
	98	a[:] *= 3
	99	consecutive, maxlabel, mapping = vigra.analysis.relabelConsecutive(a, start)
	100
	101	assert consecutive.dtype == a.dtype, "Default output dtype did not match input dtype!"
	102	assert maxlabel == consecutive.max()
	103	assert (vigra.analysis.applyMapping(a, mapping) == consecutive).all()
	104
	105	assert (numpy.unique(consecutive) == numpy.arange(start,start+100)).all(), \
	106	"relabeled array does not have consecutive labels"
	107
	108	first_label_a = a[0,0]
	109	first_label_c = consecutive[0,0]
	110	assert ((a == first_label_a) == (consecutive == first_label_c)).all()
	111
	112	# Now in-place
	113	orig = a.copy()
	114	consecutive, maxlabel, mapping = vigra.analysis.relabelConsecutive(a, start, out=a)
	115	assert consecutive is a
	116	assert maxlabel == consecutive.max()
	117	assert (vigra.analysis.applyMapping(orig, mapping) == consecutive).all()
	118
	119	assert (numpy.unique(a) == numpy.arange(start,start+100)).all(), \
	120	"relabeled array does not have consecutive labels"
	121
	122	first_label_orig = orig[0,0]
	123	first_label_a = a[0,0]
	124	assert ((orig == first_label_orig) == (a == first_label_a)).all()
	125
	126	def test_relabelConsecutive():
	127	_impl_relabelConsecutive(numpy.uint8)
	128	_impl_relabelConsecutive(numpy.uint32)
	129	_impl_relabelConsecutive(numpy.uint64)
	130
	131	def test_relabelConsecutive_keep_zeros():
	132	a = numpy.arange(1,10, dtype=numpy.uint8)
	133	a[1::2] = 0 # replace even numbers with zeros
	134
	135	# Check keep_zeros=True
	136	consecutive, maxlabel, mapping = vigra.analysis.relabelConsecutive(a, start_label=100, keep_zeros=True)
	137	assert (consecutive[1::2] == 0).all(), \
	138	"Zeros were not left untouched!"
	139	assert set(consecutive[0::2]) == set(range(100,100+len(consecutive[0::2]))), \
	140	"Non-zero items were not correctly consecutivized!"
	141	assert maxlabel == consecutive.max()
	142	assert (vigra.analysis.applyMapping(a, mapping) == consecutive).all()
	143
	144	# Check keep_zeros=False
	145	consecutive, maxlabel, mapping = vigra.analysis.relabelConsecutive(a, start_label=100, keep_zeros=False)
	146	assert (numpy.unique(consecutive) == numpy.arange(100, 100+1+len(a[::2]))).all(), \
	147	"relabeled array does not have consecutive labels: {}".format(consecutive)
	148	assert maxlabel == consecutive.max()
	149	assert (vigra.analysis.applyMapping(a, mapping) == consecutive).all()
	150
36	151	def ok_():
37	152	print(".", file=sys.stderr)