Namespaces
namespace	image
	Namespace for images and image processing tools.

Classes
class	AdditionFunctor
	Adds a intensity values . More...

class	Bank

class	BankSuper
	A Bank with additional support for brief, single char keys. More...

class	BasicCommand
	Simple implementation of Command: adds `name` , `description` and `parameters` . More...

class	BBox
	Container for geographical extent spanned by lowerLeft(x,y) and upperRight(x,y). Assumes longitude=x and latitude=y . More...

class	BeanCommand
	Retrieves bean dynamically for each call. More...

class	BeanLike
	Something which has a name, a description and possibly some parameters of varying type. More...

class	BeanRefCommand

class	Bidirectional

class	BinaryFunctor

class	BinaryThresholdFunctor
	Thresholds intensity values. More...

class	BiStatic

struct	Box
	Something that has coordinates (x,y) and dimensions (width, height). More...

class	Castable

class	CastableIterator

class	Caster

class	ClassListXML
	Container for style classes. Essentially a set of strings, with space-separated output support. More...

struct	Cloner
	Wrapper for derived class S, returning base class T. More...

struct	ClonerBase

class	CmdDebug

class	CmdExecFile
	Load script file and execute the commands immediately using current Context. More...

class	CmdExecScript
	Executes the defined script. More...

class	CmdExpandVariables

class	CmdFormat

class	CmdFormatFile

class	CmdHelp
	CommandBank-dependent. More...

class	CmdLog

class	CmdNotFound
	Special command for handling undefined commands. More...

class	CmdOpticalFlowBase
	Utility for creating a Command that runs FastOpticalFlowOp operator. More...

class	CmdScript
	Define a script. More...

class	CmdStatus

class	CmdVerbosity

class	Command
	Base class for commands: typically actions taking parameters but also plain variable assignments and parameterless actions. More...

class	CommandBank
	Container and execution tools for commands derived from Command. More...

class	CommandInstaller
	Creates an instance of command class C. More...

class	CommandModule
	Combines command installation and sectioning. More...

class	CommandSection

class	CommandSequence
	A base class for Script and Program. More...

class	compactName
	Returns the basic type (integer, float, bool, string, void) as a string. More...

class	complexName

class	Context

class	ContextKit
	Utilities. More...

class	Contextual

class	Convert
	Utility class with static conversions. More...

class	Convert2
	Utility class with static conversions. More...

struct	DeprecatingSection

class	Dictionary
	Two-way mapping between strings and objects of template class T. More...

class	DictionaryPtr
	Associates type info. More...

class	DivisionFunctor
	Divides image by another image. More...

class	DotBullit

class	DotComment

class	DotEntity

class	DotHeader

class	DotLayout

class	DotLink

class	DotNode

class	DotRank

class	DotRankNode

class	DRAIN_TREE_NAME
	A templated class for directed rooted trees. More...

class	DrainException

class	ElemPrinter

struct	EnumDict
	A container for a static dictionary of enumeration values. More...

class	EnumFlagger
	Default default value... More...

class	FavaBean
	BeanLike-like, based on FlexMap. More...

class	FileHandler

class	FileInfo

class	FilePath
	Extracts and stores directory path, base filename and extension. More...

class	fitsIn

class	FlaggerBase

class	FlagResolver
	Referencing a dictionary of binary values: {"A",1: "B":2, "C": 4, "D": 8, ...} resolves two-way mappings "A,C" <=> 5 . More...

class	Flags2
	Flagger with own dictionary, and accepting values of (integer) type T. More...

class	FlexVariableMap
	A map of FlexVariable:s. More...

class	Frame2D
	Something that has `width` and `height`. More...

class	Functor
	Base class for sequential computations. Optional scaling utilities. More...

class	FunctorLookUp
	Values are available from [0,2PI]. More...

class	Fuzzifier
	A base class for fuzzy functions; also an unary functor. More...

class	FuzzyBell
	A smooth symmetric peak function that resembles the Gaussian bell curve. More...

class	FuzzyBell2
	A smooth symmetric peak function that resembles the Gaussian bell curve. Diminishes quicker than FuzzyPeak. More...

class	FuzzyIdentity
	Identity function - returns the input value. More...

class	FuzzySigmoid
	A smooth step function, by default from -1.0 to +1.0. More...

class	FuzzyStep
	A simple linear transition from 0 to 1 . More...

class	FuzzyStepsoid
	A smooth step function between 0.0 and 1.0. Increasing (decreasing) with positive (negative) width. Otherwise like FuzzySigmoid. More...

class	FuzzyTriangle
	A basic triangular peak function with linear around the peak. More...

class	FuzzyTwinPeaks
	A function taking shape of two peaks, with a zero in the middle . More...

class	GammaFunctor
	Gamma correction. Intensity is mapped as f' = f^(gamma) More...

struct	GeneralSection

class	GlobalFlags
	Flags using a global dictionary. More...

struct	HiddenSection

class	Histogram
	Class for computing a histogram and some statistics: average, min, max, mean, std.dev, sum. More...

struct	Html

struct	IdentityFunctor

class	ImageCodeMap

class	Input
	Input utility. Opens stdIn with "-". Closes upon destruction. More...

class	IosFormat
	Stores precision, fillChar and fieldWidth applied by STD streams. More...

class	isSigned

class	JSON
	Utility for extracting JSON-compatible strings, numbers or arrays of numbers in text data. More...

class	Legend

class	LegendEntry

class	LocalCloner
	Creates an entries offered by a bank and destroys them upon exit. More...

class	Log
	Handler for notifications sent by a Logger. More...

class	Logger
	LogSourc e is the means for a function or any program segment to "connect" to a Log. More...

class	LookUp
	Look-up tables. More...

class	LookUp2
	Look-up tables. More...

class	MapReader
	General utility for reading text entries of type KEY=VALUE into a map. More...

class	MapTools
	General purpose tools for handling values and keys of std::map<> More...

class	MapWrapper

class	MapWriter

class	Matrix

class	MaximumFunctor

class	MinimumFunctor
	Minimum intensity. Prescaled input. More...

class	MixerFunctor
	Blends an image to another with given proportion. More...

class	MultiFlagger

class	MultiplicationFunctor
	Multiplies two images, with optional post scaling and offset. More...

class	nameGetter
	Returns the compiler specific ie. non-standard name of the type. More...

class	NegateFunctor
	Inverts intensities: f' = f_max - f. More...

class	NodeHTML

class	NodeXML

struct	Notification

class	Output
	Output utility. Opens stdout with "-". Closes upon destruction. More...

class	Path

struct	PathSeparatorPolicy
	Determines if separators will be stored in the path. More...

struct	Point2D

struct	Point3D

class	Program
	Sequence consisting of Command:s retrieved from a CommandBank. More...

class	ProgramVector
	Structure for implementing threads in parallelized OpenMP `for` loop. More...

class	Proj6

class	Projection

class	Projector

class	PseudoTuple

class	Range

struct	Rectangle
	Rectange defined through lower left and upper right coordinates. More...

class	ReferenceMap

class	ReferenceMap2
	A map of references to base type scalars, arrays or std::string; changing values in either are equivalent operations. More...

class	ReferenceT
	Intermediate class supporting link() in various forms. More...

class	RegExp

class	Registry
	A container for storing global objects like functors, operators or commands. Supports aliases. More...

class	RemappingFunctor
	Maps a single intensity value to another value. More...

class	ScalingFunctor
	Rescales intensities linearly: f' = scale*f + offset. More...

class	Script

class	SearchXML

class	SelectorXML
	Currently used only as CSS element selector. More...

class	SelectorXMLcls

class	SelectorXMLid

class	SimpleCommand
	A single-parameter command. More...

class	simpleName
	Returns the basic type (integer, float, bool, string, void) as a string. More...

class	SingleFlagger

class	sizeGetter
	Returns the sizeof() of a type. Accepts `void` (and returns size 0), which is not supported by std::numeric_limits. More...

class	SmartContext

class	SmartMap
	A base class for smart maps providing methods for importing and exporting values, among others. More...

class	SmartMapFoo
	A base class for smart maps providing methods for importing and exporting values, among others. More...

class	SmartMapTools
	A base class for smart maps providing methods for importing and exporting values, among others. More...

class	Som

class	Sprinter

struct	SprinterLayout

class	Sprintlet

class	Static

class	StreamBuilder

class	StringBuilder

class	Stringlet
	A helper class for StringMapper. More...

class	StringMapper
	A tool for expanding variables embedded in a std::string to literals. More...

class	StringMatcher
	General-purpose key matcher: tests string equality, or regExp, if defined as such. More...

class	StringMatcherList
	Utility for selecting a quantity label Applied by DataSelector. More...

class	StringTools

struct	Stub

class	StyleXML

class	SubtractionFunctor
	Subtracts image from another image. More...

class	SuperContextual
	Adds class-specific convenience functions. More...

class	TextDecorator
	Utility for ... More...

class	TextDecoratorVt100

class	TextReader
	Utility for scanning text segments. More...

class	TextStyle
	Utility for scanning text segments. More...

class	TextStyleVT100

class	ThresholdFunctor
	Thresholds intensity values. More...

class	Time
	Utility for handling time. Internally, uses tm (C time structure). More...

class	TreePruner

class	TreeUtils
	Collection of functions for investigating and processing trees. More...

class	TreeUtilsHTML

class	TreeVisitor
	Default implementation of a tree visitor (concept) compatible TreeUtils::traverser() More...

struct	TriggerSection

class	TupleBase

struct	TupleType

class	Type
	Utilities related to std::type_info. More...

class	typeIsFloat

class	typeIsFundamental

class	typeIsInteger

class	typeIsScalar
	Checks if type is numeric. More...

class	typeIsSmallInt
	The maximum value of a type given as type_info, char or std::string. More...

struct	TypeLayout

class	TypeLayoutBase
	Small container for printing style for putting of structured objects (array, maps, pairs). More...

class	typeLimiter
	Class for ensuring that variable of type D remains within limits of type S. More...

struct	typeLimits

class	typeMax
	The maximum value of a type given as type_info, char or std::string. More...

class	typeMin
	The minimum value of a type given as type_info, char or std::string. More...

struct	TypeName
	Default implementation. More...

struct	TypeName< drain::UnorderedMultiTree< NodeXML< E >, EX, P > >

struct	TypeName< DRAIN_TREE_NAME< T, EXCLUSIVE, P > >

struct	TypeName< image::SlidingWindowOp< W > >

struct	TypeName< image::Window< P, R > >

struct	TypeName< image::WindowOp< W > >

struct	TypeName< PseudoTuple< C, T, N > >

struct	TypeName< TupleBase< S, N > >

struct	TypeName< UniTuple< T, N > >

class	typeNaturalMax
	The maximum value of a. More...

class	typesetter
	Utility for implementing setType(const std::type_info &t) in classes supporting setType<T>(). More...

struct	TypeUtils

struct	UnaryFunctor

class	UniTuple
	Tuple of N elements of type T. More...

class	ValueScaling
	Linear scaling and physical range for image intensities. More...

class	VariableBase
	Base class for variables: Variable, Reference and FlexibleVariable. More...

class	VariableFormatter
	Formats variables to output stream. More...

class	VariableInitializer

class	VariableMap
	A map of Variables. More...

class	VariableT
	VariableT is a final class applied through typedefs Variable, Reference and FlexibleVariable. More...

class	Vector

struct	Version

class	WeightedVector

class	XML
	Base class for XML "nodes", to be data elements T for drain::Tree<T> More...

Typedefs
typedef drain::UnorderedMultiTree< NodeXML<>, false, NodeXML<>::path_t >	TreeXML

typedef VariableT< VariableInitializer< ReferenceT< VariableBase > > >	FlexibleVariable
	Value container supporting dynamic type with own memory and optional linking (referencing) of external variables.

typedef int	bank_section_t

typedef ClonerBase< Context >	ContextClonerBase

typedef VariableT< ReferenceT< Castable > >	Reference
	Variable-like that is linked to a standard variable: double, int, std::string . Supports multi-element arrays through drain::UniTuple.

typedef drain::Sprintlet< drain::VariableMap, DotLayout >	attrSprintlet

typedef std::map< std::string, std::string >	amap_t

typedef drain::Sprintlet< amap_t, DotLayout >	AttrSprintlet

typedef BankSuper< UnaryFunctor >	FunctorBank
	Prepared set of fuzzy functors.

typedef drain::UnorderedMultiTree< drain::Variable, true >	JSONtree

typedef std::vector< double >	SomVector

typedef drain::EnumFlagger< drain::MultiFlagger< Status > >	StatusFlags

typedef StringMatcherList< StringMatcher >	KeySelector

typedef drain::UnorderedMultiTree< NodeHTML, false, NodeXML<>::path_t >	TreeHTML
	The HTML data structure.

typedef drain::EnumDict< XML::entity_t >	xml_entity

typedef DRAIN_VARIABLE	Variable
	Value container supporting dynamic type.

Enumerations
enum	Status { UNKNOWN_ERROR =0 , INPUT_ERROR =1 , DATA_ERROR =2 , METADATA_ERROR =4 , OUTPUT_ERROR =8 , COMMAND_ERROR =16 , PARAMETER_ERROR =32 }

enum	XmlEmptiness { CHILDREN = 1 , TEXT = 2 , ATTRIBUTES = 4 , ALL = CHILDREN\|TEXT\|ATTRIBUTES , ANY = 128 }

Functions
	DRAIN_TYPENAME_DEF (rack::DataSelector)

	DRAIN_TYPENAME (rack::DataSelector)

template<class T >
std::ostream &	operator<< (std::ostream &ostr, const SmartMapFoo< T > &m)

std::ostream &	operator<< (std::ostream &ostr, const StyleXML &style)

template<class N >
std::ostream &	operator<< (std::ostream &ostr, const NodeXML< N > &node)
	Note: Not designed for XML output, this is more for debugging (in tree dumps),.

std::ostream &	operator<< (std::ostream &ostr, const TreeXML &t)

	DRAIN_TYPENAME_DEF (rack::PolarODIM)

std::ostream &	operator<< (std::ostream &ostr, const Castable &c)

template<class T >
T &	operator+= (T &x, const Castable &c)
	Arithmetics: addition.

template<class T >
T &	operator-= (T &x, const Castable &c)
	Arithmetics: subtraction.

template<class T >
T &	*operator=** (T &x, const Castable &c)
	Arithmetics: addition.

template<class T >
T &	operator/= (T &x, const Castable &c)
	Arithmetics: subtraction.

std::ostream &	operator<< (std::ostream &ostr, const CastableIterator &it)

template<>
void	Caster::updateType< std::string > ()

template<>
void	Caster::updateType< std::string > ()

template<>
void	Caster::put< std::string > (void *p, const std::string &x) const

template<>
std::string	Caster::get< std::string > (const void *p) const
	Note: there is no conversion for const char * !

	DRAIN_TYPENAME_DEF (FlexibleVariable)

	DRAIN_TYPENAME (FlexibleVariable)

	DRAIN_ENUM_DICT (drain::image::AnchorElem::Anchor)

	DRAIN_ENUM_OSTREAM (image::AnchorElem::Anchor)

template<>
std::ostream &	drain::Sprinter::toStream< drain::image::ImageFrame > (std::ostream &ostr, const drain::image::ImageFrame &src, const SprinterLayout &layout)

	DRAIN_TYPENAME_DEF (drain::image::ImageFrame)

template<>
std::ostream &	drain::Sprinter::toStream< drain::image::ImageFrame > (std::ostream &ostr, const drain::image::ImageFrame &src, const SprinterLayout &layout)

	DRAIN_TYPENAME (drain::image::ImageFrame)

	DRAIN_ENUM_DICT (image::LayoutSVG::GroupType)

	DRAIN_ENUM_DICT (image::LayoutSVG::Direction)

std::ostream &	operator<< (const LegendEntry &entry, std::ostream &ostr)

	DRAIN_TYPENAME_DEF (image::NodeSLD)

	DRAIN_TYPENAME_DEF (image::SLD::tag_t)

std::ostream &	operator<< (std::ostream &ostr, const image::NodeSLD &node)

std::ostream &	operator<< (std::ostream &ostr, const image::TreeSLD &tree)

	DRAIN_TYPENAME (image::NodeSLD)

	DRAIN_TYPENAME (image::SLD::tag_t)

	DRAIN_TYPENAME_DEF (image::NodeSVG)

	DRAIN_TYPENAME_DEF (image::svg::tag_t)

	DRAIN_ENUM_DICT (image::svg::tag_t)

const drain::EnumDict< image::svg::tag_t >::dict_t &	getDict ()

	DRAIN_TYPENAME (image::NodeSVG)

	DRAIN_TYPENAME (image::svg::tag_t)

	DRAIN_TYPENAME_DEF (image::NodeGDAL)

	DRAIN_TYPENAME_DEF (image::NodeGDAL::tag_t)

std::ostream &	operator<< (std::ostream &ostr, const image::TreeGDAL &tree)
	Write tree using XML notation.

	DRAIN_TYPENAME (image::NodeGDAL)

	DRAIN_TYPENAME (image::NodeGDAL::tag_t)

Log &	getLog ()

Notification &	getNotif (Logger::level_t level)

std::ostream &	operator<< (std::ostream &ostr, const Command &cmd)

CommandBank &	getCommandBank ()
	Global program command registry. Optional utility.

template<class T >
std::ostream &	operator<< (std::ostream &ostr, const CommandSequence< T > &commands)

std::ostream &	operator<< (std::ostream &ostr, const drain::RegExp &r)

std::ostream &	operator<< (std::ostream &ostr, const SprinterLayout &layout)

template<class T , class L >
std::ostream &	operator<< (std::ostream &ostr, const Sprintlet< T, L > &sp)

template<class T >
Sprintlet< T >	sprinter (const T &x, const char arrayCaps, const char mapCaps="{,}", const char pairCaps="(:)", const char stringCaps="\"")

template<class T >
Sprintlet< T >	sprinter (const T &x, const SprinterLayout &layout=SprinterLayout())

template<char SEP>
std::ostream &	operator<< (std::ostream &ostr, const StringBuilder< SEP > &strb)

	DRAIN_TYPENAME_DEF (TextStyle)

	DRAIN_TYPENAME_DEF (TextStyle::Colour)

	DRAIN_TYPENAME_DEF (TextStyle::Line)

	DRAIN_TYPENAME_DEF (TextStyle::Style)

	DRAIN_TYPENAME (TextStyle)

	DRAIN_TYPENAME (TextStyle::Colour)

	DRAIN_TYPENAME (TextStyle::Line)

	DRAIN_TYPENAME (TextStyle::Style)

std::ostream &	operator<< (std::ostream &ostr, const TextStyle &t)

	DRAIN_TYPENAME_DEF (TextStyleVT100)

std::ostream &	operator<< (std::ostream &ostr, const TextStyleVT100 &t)

	DRAIN_TYPENAME (TextStyleVT100)

template<class S , size_t N>
std::ostream &	operator<< (std::ostream &ostr, const TupleBase< S, N > &tuple)

	DRAIN_TYPENAME_DEF (void)

	DRAIN_TYPENAME_DEF (bool)

	DRAIN_TYPENAME_DEF (char)

	DRAIN_TYPENAME_DEF (unsigned char)

	DRAIN_TYPENAME_DEF (short)

	DRAIN_TYPENAME_DEF (unsigned short)

	DRAIN_TYPENAME_DEF (int)

	DRAIN_TYPENAME_DEF (unsigned int)

	DRAIN_TYPENAME_DEF (long)

	DRAIN_TYPENAME_DEF (unsigned long)

	DRAIN_TYPENAME_DEF (float)

	DRAIN_TYPENAME_DEF (double)

	DRAIN_TYPENAME_DEF (char *)

	DRAIN_TYPENAME_DEF (const char *)

	DRAIN_TYPENAME_DEF (std::string)

std::ostream &	operator<< (std::ostream &ostr, const Type &t)
	Dumps information.

	DRAIN_TYPENAME (void)
	Add a specialization for each type of those you want to support.

	DRAIN_TYPENAME (bool)

	DRAIN_TYPENAME (char)

	DRAIN_TYPENAME (unsigned char)

	DRAIN_TYPENAME (short)

	DRAIN_TYPENAME (unsigned short)

	DRAIN_TYPENAME (int)

	DRAIN_TYPENAME (unsigned int)

	DRAIN_TYPENAME (long)

	DRAIN_TYPENAME (unsigned long)

	DRAIN_TYPENAME (float)

	DRAIN_TYPENAME (double)

	DRAIN_TYPENAME (char *)

	DRAIN_TYPENAME (const char *)

	DRAIN_TYPENAME (std::string)

	DRAIN_TYPENAME_T0 (std::initializer_list, T)

	DRAIN_TYPENAME_T0 (std::vector, T)

template<class T >
std::ostream &	operator<< (std::ostream &ostr, const Bank< T > &bank)

std::ostream &	operator<< (std::ostream &ostr, const BeanLike &bean)

std::ostream &	operator<< (std::ostream &ostr, const ClassListXML &cls)

template<class K , class V >
std::ostream &	operator<< (std::ostream &ostr, const Dictionary< K, V > &dict)

std::ostream &	operator<< (std::ostream &ostr, const DotNode &node)

std::ostream &	operator<< (std::ostream &ostr, const DotHeader &header)

std::ostream &	operator<< (std::ostream &ostr, const DotComment &comment)

std::ostream &	operator<< (std::ostream &ostr, const DotLink &link)

std::ostream &	operator<< (std::ostream &ostr, const DotRank &rank)

Registry< FileInfo > &	getFileInfoRegistry ()

std::ostream &	operator<< (std::ostream &ostr, const FilePath &p)

template<typename E , typename T >
std::ostream &	operator<< (std::ostream &ostr, const drain::FlaggerBase< E, T > &flagger)

template<typename E >
std::ostream &	operator<< (std::ostream &ostr, const drain::SingleFlagger< E > &flagger)

template<typename E , typename T >
std::ostream &	operator<< (std::ostream &ostr, const drain::MultiFlagger< E, T > &flagger)

	DRAIN_TYPENAME_T (Frame2D, T)

	DRAIN_TYPENAME_T0 (Stub, T)

	DRAIN_TYPENAME_T (Box, T)

template<class T >
std::ostream &	operator<< (std::ostream &ostr, const drain::Box< T > &box)

FunctorBank &	getFunctorBank ()

UnaryFunctor &	getFunctor (const std::string &nameAndParams, char separator=',')
	Returns functor the parameters of which have been set.

const double	DEG2RAD (M_PI/180.0)

const double	RAD2DEG (180.0/M_PI)

const int	EARTH_RADIUSi (6371000)

const double	EARTH_RADIUS (6371000.0)

std::ostream &	operator<< (std::ostream &ostr, const Histogram &h)

std::ostream &	operator<< (std::ostream &ostr, const IosFormat &iosformat)

template<class T >
void	polynomialFit2nd (const T &src, const T &weight, std::vector< double > &coeff)
	Fits a 2nd order polynomial to a curve.

template<class T >
std::ostream &	operator<< (std::ostream &ostr, const Matrix< T > &m)

template<class T >
Output &	operator<< (Output &output, const T &value)

std::ostream &	operator<< (std::ostream &ostr, const PathSeparatorPolicy &policy)

template<class T , char SEP = '/', bool ALEAD = true, bool AREPEAT = false, bool ATRAIL = true>
std::ostream &	operator<< (std::ostream &ostr, const Path< T, SEP, ALEAD, AREPEAT, ATRAIL > &p)

template<class T , char SEP = '/', bool ALEAD = true, bool AREPEAT = false, bool ATRAIL = true>
std::istream &	operator>> (std::istream &istr, Path< T, SEP, ALEAD, AREPEAT, ATRAIL > &p)

	DRAIN_TYPENAME_T (Point2D, T)

	DRAIN_TYPENAME_T (Point3D, T)

std::ostream &	operator<< (std::ostream &ostr, const Proj6 &p)

	DRAIN_TYPENAME_DEF (Proj6)

	DRAIN_TYPENAME (Proj6)

	DRAIN_ENUM_OSTREAM (Projector::PROJDEF_variant)

	DRAIN_TYPENAME_T (Range, T)

template<class T >
std::ostream &	operator<< (std::ostream &ostr, const drain::Rectangle< T > &r)

	DRAIN_TYPENAME_T (Rectangle, T)

template<class T >
std::ostream &	operator<< (std::ostream &ostr, const SmartMap< T > &m)

template<class T >
double	euclideanDistance2 (const T &x1, const T &x2)

template<class T >
void	vectorMix (const T &x1, const T &x2, double coeff, T &m)

template<class T >
void	uniformRandomVector256 (std::vector< T > &x)
	For initialising vector Soms.

template<class T >
std::ostream &	operator<< (std::ostream &ostr, const std::vector< T > &n)
	Risk of conflicts?

template<class T >
std::ostream &	operator<< (std::ostream &ostr, const Som< T > &som)

template<class T >
void	somToImage (const Som< T > &som, drain::image::Image &image, int width=0, int height=0, const std::vector< int > &channels=std::vector< int >())
	Squared Euclidean distance for vectors and similar.

std::ostream &	operator<< (std::ostream &ostr, const Stringlet &s)

std::ostream &	operator<< (std::ostream &ostr, const StringMapper &strmap)

	DRAIN_TYPENAME_DEF (StringMatcher)

std::ostream &	operator<< (std::ostream &ostr, const StringMatcher &m)

	DRAIN_TYPENAME (StringMatcher)

	DRAIN_TYPENAME_DEF (KeySelector)

template<class T >
std::ostream &	operator<< (std::ostream &ostr, const StringMatcherList< T > &selector)

	DRAIN_TYPENAME (KeySelector)

std::ostream &	operator<< (std::ostream &ostr, const TextDecorator &decorator)

	DRAIN_TYPENAME_DEF (NodeHTML)

	DRAIN_TYPENAME_DEF (Html)

	DRAIN_TYPENAME_DEF (Html::tag_t)

std::ostream &	operator<< (std::ostream &ostr, const NodeHTML &node)

std::ostream &	operator<< (std::ostream &ostr, const TreeHTML &tree)

	DRAIN_TYPENAME (NodeHTML)

	DRAIN_TYPENAME (Html)

	DRAIN_TYPENAME (Html::tag_t)

template<class E , bool EX, class P >
std::ostream &	operator<< (std::ostream &ostr, const UnorderedMultiTree< NodeXML< E >, EX, P > &tree)

std::ostream &	operator<< (std::ostream &ostr, const drain::ValueScaling &s)

std::ostream &	operator<< (std::ostream &ostr, const FlexVariableMap &vmap)

template<class T >
std::ostream &	operator<< (std::ostream &ostr, const WeightedVector< T > &WeightedVector)

	DRAIN_ENUM_OSTREAM (XML::entity_t)

	DRAIN_TYPENAME_DEF (Variable)

	DRAIN_TYPENAME (Variable)

template<typename V >
std::ostream &	operator<< (std::ostream &ostr, const Version< V > &version)

template<>
class	DRAIN_SVG_ELEM_CLS (PATH)

template<>
void	svgPATH::appendArgs< svgPATH::CLOSE > ()

template<>
void	svgPATH::appendArgs< svgPATH::MOVE > (double x, double y)

template<>
void	svgPATH::appendArgs< svgPATH::LINE > (double x, double y)

template<>
void	svgPATH::appendArgs< svgPATH::CURVE > (double x1, double y1, double x2, double y2, double x3, double y3)

	DRAIN_ENUM_OSTREAM (rack::SvgInclude)

	DRAIN_ENUM_OSTREAM (rack::PanelConfSVG::ElemClass)

	DRAIN_ENUM_OSTREAM (rack::PanelConfSVG::PathPolicy)

	DRAIN_TYPENAME (rack::DopplerWindow)

	DRAIN_TYPENAME (rack::DopplerAverageWindow)

	DRAIN_TYPENAME (rack::DopplerAverageWindow2)

	DRAIN_TYPENAME (rack::DopplerDevWindow)

	DRAIN_TYPENAME_DEF (rack::DopplerWindow)

	DRAIN_TYPENAME_DEF (rack::DopplerAverageWindow)

	DRAIN_TYPENAME_DEF (rack::DopplerAverageWindow2)

	DRAIN_TYPENAME_DEF (rack::DopplerDevWindow)

	DRAIN_TYPENAME_DEF (rack::RadarDataPicker< rack::PolarODIM >)

	DRAIN_TYPENAME_DEF (rack::RadarDataPicker< rack::CartesianODIM >)

	DRAIN_TYPENAME (rack::RadarDataPicker< rack::PolarODIM >)

	DRAIN_TYPENAME (rack::RadarDataPicker< rack::CartesianODIM >)

Variables
const double	DEG2RAD

const double	RAD2DEG

const int	EARTH_RADIUSi

const double	EARTH_RADIUS

Detailed Description

Typedef Documentation

◆ FlexibleVariable

typedef VariableT<VariableInitializer<ReferenceT<VariableBase> > > FlexibleVariable

Value container supporting dynamic type with own memory and optional linking (referencing) of external variables.

 drain::FlexibleVariable combines properties of drain::Variable and drain::Reference : it has memory of its own but
 can also be linked to external variables.

FlexibleVariable constructors

FlexibleVariable

Default constructor
		FlexibleVariable
	V variable;	null
Copy constructor
bool b=true; V var(b);	V variable(var);	true
char c='Y'; V var(c);	V variable(var);	Y
int i=123; V var(i);	V variable(var);	123
double d=45.678; V var(d);	V variable(var);	45.678
std::string str("Test"); V var(str);	V variable(var);	"Test" ©
UniTuple2i uni2i(INIT_2i); V var(uni2i);	V variable(var);	67,89
UniTuple3d uni3d(INIT_3d); V var(uni3d);	V variable(var);	65.6,77.8,89
Copy constructor variants
int i=123; Variable var(i);	V variable(var);	123
int i=123; FlexibleVariable var(i);	V variable(var);	123
int i=123; FlexibleVariable var; var.link(i);	V variable(var);	123 ®
int i=123; Reference var(i);	V variable(var);	123 ®
std::string str("Test"); Variable var(str);	V variable(var);	"Test" ©
std::string str("Test"); FlexibleVariable var(str);	V variable(var);	"Test" ©
std::string str("Test"); FlexibleVariable var; var.link(str);	V variable(var);	"Test" ®
std::string str("Test"); Reference var(str);	V variable(var);	"Test" ®
UniTuple3d uni3d(INIT_3d); Variable var(uni3d);	V variable(var);	65.6,77.8,89
UniTuple3d uni3d(INIT_3d); FlexibleVariable var(uni3d);	V variable(var);	65.6,77.8,89
UniTuple3d uni3d(INIT_3d); FlexibleVariable var; var.link(uni3d);	V variable(var);	65.6,77.8,89 ®
UniTuple3d uni3d(INIT_3d); Reference var(uni3d);	V variable(var);	65.6,77.8,89 ®
Non-const variable arg
bool b=true;	V variable(b);	true
char c='Y';	V variable(c);	Y
int i=123;	V variable(i);	123
double d=45.678;	V variable(d);	45.678
std::string str("Test");	V variable(str);	"Test" ©
UniTuple2i uni2i(INIT_2i)	V variable(uni2i);	67,89
UniTuple3d uni3d(INIT_3d)	V variable(uni3d);	65.6,77.8,89
Type initialisation
	V variable(typeid(bool));	null
	V variable(typeid(char));	null
	V variable(typeid(int));	null
	V variable(typeid(double));	null
Initial value
	V variable(false);	false
	V variable('X');	X
	V variable(12345);	12345
	V variable(56.789);	56.789
	V variable("Hello!");	"Hello!" ©
	V variable(std::string("Test"));	"Test" ©
	V variable(UniTuple2i(INIT_2i));	67,89
	V variable(UniTuple3d(INIT_3d));	65.6,77.8,89
Const variable
const bool b=true;	V variable(b);	true
const char c='Y';	V variable(c);	Y
const int i=123;	V variable(i);	123
const double d=45.678;	V variable(d);	45.678
const std::string str("Test");	V variable(str);	"Test" ©
const char *s="123abc";	V variable(s);	"123abc" ©
UniTuple2i ut(INIT_2i);	V variable(ut);	67,89
UniTuple3d ut(INIT_3d);	V variable(ut);	65.6,77.8,89
Constructor with assignment
	V variable = true;	true
	V variable = 'Z';	Z
	V variable = 1234;	1234
	V variable = 345.67;	345.67
	V variable = "12.34567";	"12.34567" ©
	V variable = INIT_2i;	67,89
	V variable = UniTuple3d(INIT_3d);	65.6,77.8,89

Created by: src/Variables-example.cpp: testConstructors

FlexibleVariable assignments

FlexibleVariable - assignments

input		FlexibleVariable
type	value	bool	unsigned char	char	short	int	unsigned long	float	double	char-array
bool	false	false			0	0	0	0	0	"0" ©
bool	true	true			1	1	1	1	1	"1" ©
int	0	false			0	0	0	0	0	"0" ©
int	123	true	{	{	123	123	123	123	123	"123" ©
float	12.345f	true			12	12	12	12.345	12.345	"12.345" ©
double	3.14159265358979323846	true			3	3	3	3.14159	3.14159	"3.14159" ©
double	314.15926E-02	true			3	3	3	3.14159	3.14159	"3.14159" ©
std::string	"Hello!"	false		H	0	0	0	0	0	"Hello!" ©
std::string	"true"	true		t	0	0	0	0	0	"true" ©
std::string	"false"	false		f	0	0	0	0	0	"false" ©
std::string	"3141592E-6"	true	�	3	-4136	3141592	3141592	3.14159	3.14159	"3141592E-6" ©
const char *	"Test"	false		T	0	0	0	0	0	"Test" ©
const char *	"true"	true		t	0	0	0	0	0	"true" ©
const char *	"false"	false		f	0	0	0	0	0	"false" ©
UniTuple<2,int>	uni2i	true,true	C,Y	C,Y	67,89	67,89	67,89	67,89	67,89	"67,89" ©
UniTuple<3,double>	uni3d	true,true,true	A,M,Y	A,M,Y	65,77,89	65,77,89	65,77,89	65.6,77.8,89	65.6,77.8,89	"65.6,77.8,89" ©
void *	nullptr	false		n	0	0	0	0	0	"nullptr" ©
Variables...
int i=123	Variable(i)	true	{	{	123	123	123	123	123	"123" ©
int i=123	FlexibleVariable(i)	true	{	{	123	123	123	123	123	"123" ©
int i=123	Reference(i)	true	{	{	123	123	123	123	123	"123" ©
std::string s("abc")	Variable(s)	false		t	0	0	0	0	0	"test" ©
std::string s("abc")	FlexibleVariable(s)	false		t	0	0	0	0	0	"test" ©
std::string s("abc")	Reference(s)	false		t	0	0	0	0	0	"test" ©
std::string s("true")	Variable(s)	true		t	0	0	0	0	0	"true" ©
std::string s("true")	FlexibleVariable(s)	true		t	0	0	0	0	0	"true" ©
std::string s("true")	Reference(s)	true		t	0	0	0	0	0	"true" ©
UniTuple	Variable(uni3d)	true,true,true	A,M,Y	A,M,Y	65,77,89	65,77,89	65,77,89	65.6,77.8,89	65.6,77.8,89	"65.6,77.8,89" ©
UniTuple	FlexibleVariable(uni3d)	true,true,true	A,M,Y	A,M,Y	65,77,89	65,77,89	65,77,89	65.6,77.8,89	65.6,77.8,89	"65.6,77.8,89" ©
UniTuple	Reference(uni3d)	true,true,true	A,M,Y	A,M,Y	65,77,89	65,77,89	65,77,89	65.6,77.8,89	65.6,77.8,89	"65.6,77.8,89" ©

Created by: src/Variables-example.cpp: testAssignments

Variable

See the combined review of drain::Variable, drain::Reference and drain::FlexibleVariable in the documentation of template drain::VariableT .

See also: VariableT; Reference; Variable

◆ Reference

typedef VariableT<ReferenceT<Castable> > Reference

Variable-like that is linked to a standard variable: double, int, std::string . Supports multi-element arrays through drain::UniTuple.

drain::Reference does not have memory of its own. The type of reference cannot be changed – it is that of the referenced variable.

The only character string type supported is std::string .

Currently, the only multi-element structure supported is drain::UniTuple<>, which has a fixed start address for its elements. In future, STL Sequences like std::vectors may be supported.

Reference does not support STL containers.

This class is best illustrated together with its counterparts supporting own memory, Variable and FlexibleVariable

Reference constructors

Reference

Default constructor
		Reference
	V variable;	null
Copy constructor
bool b=true; V var(b);	V variable(var);	true ®
char c='Y'; V var(c);	V variable(var);	Y ®
int i=123; V var(i);	V variable(var);	123 ®
double d=45.678; V var(d);	V variable(var);	45.678 ®
std::string str("Test"); V var(str);	V variable(var);	"Test" ®
UniTuple2i uni2i(INIT_2i); V var(uni2i);	V variable(var);	67,89 ®
UniTuple3d uni3d(INIT_3d); V var(uni3d);	V variable(var);	65.6,77.8,89 ®
Copy constructor variants
int i=123; Variable var(i);	V variable(var);	null
int i=123; FlexibleVariable var(i);	V variable(var);	null
int i=123; FlexibleVariable var; var.link(i);	V variable(var);	123 ®
int i=123; Reference var(i);	V variable(var);	123 ®
std::string str("Test"); Variable var(str);	V variable(var);	null
std::string str("Test"); FlexibleVariable var(str);	V variable(var);	null
std::string str("Test"); FlexibleVariable var; var.link(str);	V variable(var);	"Test" ®
std::string str("Test"); Reference var(str);	V variable(var);	"Test" ®
UniTuple3d uni3d(INIT_3d); Variable var(uni3d);	V variable(var);	null
UniTuple3d uni3d(INIT_3d); FlexibleVariable var(uni3d);	V variable(var);	null
UniTuple3d uni3d(INIT_3d); FlexibleVariable var; var.link(uni3d);	V variable(var);	65.6,77.8,89 ®
UniTuple3d uni3d(INIT_3d); Reference var(uni3d);	V variable(var);	65.6,77.8,89 ®
Non-const variable arg
bool b=true;	V variable(b);	true ®
char c='Y';	V variable(c);	Y ®
int i=123;	V variable(i);	123 ®
double d=45.678;	V variable(d);	45.678 ®
std::string str("Test");	V variable(str);	"Test" ®
UniTuple2i uni2i(INIT_2i)	V variable(uni2i);	67,89 ®
UniTuple3d uni3d(INIT_3d)	V variable(uni3d);	65.6,77.8,89 ®

Created by: src/Variables-example.cpp: testConstructors

Reference assignments

Reference - assignments

input		Reference
type	value	bool	unsigned char	char	short	int	unsigned long	float	double	std::string
bool	false	false ®	®	®	0 ®	0 ®	0 ®	0 ®	0 ®	"0" ®
bool	true	true ®	®	®	1 ®	1 ®	1 ®	1 ®	1 ®	"1" ®
int	0	false ®	®	®	0 ®	0 ®	0 ®	0 ®	0 ®	"0" ®
int	123	true ®	{ ®	{ ®	123 ®	123 ®	123 ®	123 ®	123 ®	"123" ®
float	12.345f	true ®	®	®	12 ®	12 ®	12 ®	12.345 ®	12.345 ®	"12.345" ®
double	3.14159265358979323846	true ®	®	®	3 ®	3 ®	3 ®	3.14159 ®	3.14159 ®	"3.14159" ®
double	314.15926E-02	true ®	®	®	3 ®	3 ®	3 ®	3.14159 ®	3.14159 ®	"3.14159" ®
std::string	"Hello!"	false ®	®	H ®	0 ®	0 ®	0 ®	0 ®	0 ®	"Hello!" ®
std::string	"true"	true ®	®	t ®	0 ®	0 ®	0 ®	0 ®	0 ®	"true" ®
std::string	"false"	false ®	®	f ®	0 ®	0 ®	0 ®	0 ®	0 ®	"false" ®
std::string	"3141592E-6"	true ®	� ®	3 ®	-4136 ®	3141592 ®	3141592 ®	3.14159 ®	3.14159 ®	"3141592E-6" ®
const char *	"Test"	false ®	®	T ®	0 ®	0 ®	0 ®	0 ®	0 ®	"Test" ®
const char *	"true"	true ®	®	t ®	0 ®	0 ®	0 ®	0 ®	0 ®	"true" ®
const char *	"false"	false ®	®	f ®	0 ®	0 ®	0 ®	0 ®	0 ®	"false" ®
UniTuple<2,int>	uni2i	true ®	C ®	C ®	67 ®	67 ®	67 ®	67 ®	67 ®	"67,89" ®
UniTuple<3,double>	uni3d	true ®	A ®	A ®	65 ®	65 ®	65 ®	65.6 ®	65.6 ®	"65.6,77.8,89" ®
void *	nullptr	false ®	®	n ®	0 ®	0 ®	0 ®	0 ®	0 ®	"nullptr" ®
Variables...
int i=123	Variable(i)	true ®	{ ®	{ ®	123 ®	123 ®	123 ®	123 ®	123 ®	"123" ®
int i=123	FlexibleVariable(i)	true ®	{ ®	{ ®	123 ®	123 ®	123 ®	123 ®	123 ®	"123" ®
int i=123	Reference(i)	true ®	{ ®	{ ®	123 ®	123 ®	123 ®	123 ®	123 ®	"123" ®
std::string s("abc")	Variable(s)	false ®	®	t ®	0 ®	0 ®	0 ®	0 ®	0 ®	"test" ®
std::string s("abc")	FlexibleVariable(s)	false ®	®	t ®	0 ®	0 ®	0 ®	0 ®	0 ®	"test" ®
std::string s("abc")	Reference(s)	false ®	®	t ®	0 ®	0 ®	0 ®	0 ®	0 ®	"test" ®
std::string s("true")	Variable(s)	true ®	®	t ®	0 ®	0 ®	0 ®	0 ®	0 ®	"true" ®
std::string s("true")	FlexibleVariable(s)	true ®	®	t ®	0 ®	0 ®	0 ®	0 ®	0 ®	"true" ®
std::string s("true")	Reference(s)	true ®	®	t ®	0 ®	0 ®	0 ®	0 ®	0 ®	"true" ®
UniTuple	Variable(uni3d)	true ®	A ®	A ®	65 ®	65 ®	65 ®	65.6 ®	65.6 ®	"65.6,77.8,89" ®
UniTuple	FlexibleVariable(uni3d)	true ®	A ®	A ®	65 ®	65 ®	65 ®	65.6 ®	65.6 ®	"65.6,77.8,89" ®
UniTuple	Reference(uni3d)	true ®	A ®	A ®	65 ®	65 ®	65 ®	65.6 ®	65.6 ®	"65.6,77.8,89" ®

Created by: src/Variables-example.cpp: testAssignments

See the documentation of drain::VariableT template specialized by drain::Variable, drain::Reference and drain::FlexibleVariable .

See also: VariableT; Variable; FlexibleVariable

◆ Variable

typedef DRAIN_VARIABLE Variable

Value container supporting dynamic type.

drain::Variable has memory of its own, and cannot be linked to external variables like drain::Reference and drain::FlexibleVariable .

Reference constructors

Variable

Default constructor
		Variable
	V variable;	null
Copy constructor
bool b=true; V var(b);	V variable(var);	true
char c='Y'; V var(c);	V variable(var);	Y
int i=123; V var(i);	V variable(var);	123
double d=45.678; V var(d);	V variable(var);	45.678
std::string str("Test"); V var(str);	V variable(var);	"Test" ©
UniTuple2i uni2i(INIT_2i); V var(uni2i);	V variable(var);	67,89
UniTuple3d uni3d(INIT_3d); V var(uni3d);	V variable(var);	65.6,77.8,89
Copy constructor variants
int i=123; Variable var(i);	V variable(var);	123
int i=123; FlexibleVariable var(i);	V variable(var);	123
int i=123; FlexibleVariable var; var.link(i);	V variable(var);	123
int i=123; Reference var(i);	V variable(var);	123
std::string str("Test"); Variable var(str);	V variable(var);	"Test" ©
std::string str("Test"); FlexibleVariable var(str);	V variable(var);	"Test" ©
std::string str("Test"); FlexibleVariable var; var.link(str);	V variable(var);	"Test" ©
std::string str("Test"); Reference var(str);	V variable(var);	"Test" ©
UniTuple3d uni3d(INIT_3d); Variable var(uni3d);	V variable(var);	65.6,77.8,89
UniTuple3d uni3d(INIT_3d); FlexibleVariable var(uni3d);	V variable(var);	65.6,77.8,89
UniTuple3d uni3d(INIT_3d); FlexibleVariable var; var.link(uni3d);	V variable(var);	65.6,77.8,89
UniTuple3d uni3d(INIT_3d); Reference var(uni3d);	V variable(var);	65.6,77.8,89
Non-const variable arg
bool b=true;	V variable(b);	true
char c='Y';	V variable(c);	Y
int i=123;	V variable(i);	123
double d=45.678;	V variable(d);	45.678
std::string str("Test");	V variable(str);	"Test" ©
UniTuple2i uni2i(INIT_2i)	V variable(uni2i);	67,89
UniTuple3d uni3d(INIT_3d)	V variable(uni3d);	65.6,77.8,89
Type initialisation
	V variable(typeid(bool));	null
	V variable(typeid(char));	null
	V variable(typeid(int));	null
	V variable(typeid(double));	null
Initial value
	V variable(false);	false
	V variable('X');	X
	V variable(12345);	12345
	V variable(56.789);	56.789
	V variable("Hello!");	"Hello!" ©
	V variable(std::string("Test"));	"Test" ©
	V variable(UniTuple2i(INIT_2i));	67,89
	V variable(UniTuple3d(INIT_3d));	65.6,77.8,89
Const variable
const bool b=true;	V variable(b);	true
const char c='Y';	V variable(c);	Y
const int i=123;	V variable(i);	123
const double d=45.678;	V variable(d);	45.678
const std::string str("Test");	V variable(str);	"Test" ©
const char *s="123abc";	V variable(s);	"123abc" ©
UniTuple2i ut(INIT_2i);	V variable(ut);	67,89
UniTuple3d ut(INIT_3d);	V variable(ut);	65.6,77.8,89
Constructor with assignment
	V variable = true;	true
	V variable = 'Z';	Z
	V variable = 1234;	1234
	V variable = 345.67;	345.67
	V variable = "12.34567";	"12.34567" ©
	V variable = INIT_2i;	67,89
	V variable = UniTuple3d(INIT_3d);	65.6,77.8,89

Created by: src/Variables-example.cpp: testConstructors

Reference assignments

Variable - assignments

input		Variable
type	value	bool	unsigned char	char	short	int	unsigned long	float	double	char-array
bool	false	false			0	0	0	0	0	"0" ©
bool	true	true			1	1	1	1	1	"1" ©
int	0	false			0	0	0	0	0	"0" ©
int	123	true	{	{	123	123	123	123	123	"123" ©
float	12.345f	true			12	12	12	12.345	12.345	"12.345" ©
double	3.14159265358979323846	true			3	3	3	3.14159	3.14159	"3.14159" ©
double	314.15926E-02	true			3	3	3	3.14159	3.14159	"3.14159" ©
std::string	"Hello!"	false		H	0	0	0	0	0	"Hello!" ©
std::string	"true"	true		t	0	0	0	0	0	"true" ©
std::string	"false"	false		f	0	0	0	0	0	"false" ©
std::string	"3141592E-6"	true	�	3	-4136	3141592	3141592	3.14159	3.14159	"3141592E-6" ©
const char *	"Test"	false		T	0	0	0	0	0	"Test" ©
const char *	"true"	true		t	0	0	0	0	0	"true" ©
const char *	"false"	false		f	0	0	0	0	0	"false" ©
UniTuple<2,int>	uni2i	true,true	C,Y	C,Y	67,89	67,89	67,89	67,89	67,89	"67,89" ©
UniTuple<3,double>	uni3d	true,true,true	A,M,Y	A,M,Y	65,77,89	65,77,89	65,77,89	65.6,77.8,89	65.6,77.8,89	"65.6,77.8,89" ©
void *	nullptr	false		n	0	0	0	0	0	"nullptr" ©
Variables...
int i=123	Variable(i)	true	{	{	123	123	123	123	123	"123" ©
int i=123	FlexibleVariable(i)	true	{	{	123	123	123	123	123	"123" ©
int i=123	Reference(i)	true	{	{	123	123	123	123	123	"123" ©
std::string s("abc")	Variable(s)	false		t	0	0	0	0	0	"test" ©
std::string s("abc")	FlexibleVariable(s)	false		t	0	0	0	0	0	"test" ©
std::string s("abc")	Reference(s)	false		t	0	0	0	0	0	"test" ©
std::string s("true")	Variable(s)	true		t	0	0	0	0	0	"true" ©
std::string s("true")	FlexibleVariable(s)	true		t	0	0	0	0	0	"true" ©
std::string s("true")	Reference(s)	true		t	0	0	0	0	0	"true" ©
UniTuple	Variable(uni3d)	true,true,true	A,M,Y	A,M,Y	65,77,89	65,77,89	65,77,89	65.6,77.8,89	65.6,77.8,89	"65.6,77.8,89" ©
UniTuple	FlexibleVariable(uni3d)	true,true,true	A,M,Y	A,M,Y	65,77,89	65,77,89	65,77,89	65.6,77.8,89	65.6,77.8,89	"65.6,77.8,89" ©
UniTuple	Reference(uni3d)	true,true,true	A,M,Y	A,M,Y	65,77,89	65,77,89	65,77,89	65.6,77.8,89	65.6,77.8,89	"65.6,77.8,89" ©

Created by: src/Variables-example.cpp: testAssignments

See the documentation of drain::VariableT template specialized by drain::Variable, drain::Reference and drain::FlexibleVariable .

See also: VariableT; Reference; FlexibleVariable

Function Documentation

◆ DRAIN_TYPENAME_DEF()

DRAIN_TYPENAME_DEF ( rack::RadarDataPicker< rack::PolarODIM > )

This policy suggests typedef + spacialization for the actual classes, as well.

◆ getFunctor()

UnaryFunctor & getFunctor	(	const std::string &	nameAndParams,
		char	separator = `','`
	)

Returns functor the parameters of which have been set.

Parameters

separator -

◆ getFunctorBank()

FunctorBank & getFunctorBank ( )

Shared functor bank

◆ operator<<() [1/2]

template<class T >

std::ostream & operator<<	(	std::ostream &	ostr,
		const CommandSequence< T > &	commands
	)

inline

Array layout: elements (of the Sequence) will be separated by newline. Map layout {,}: unused - or something is going wrong. Pair layout : key=value String layout: plain, because keys are strings but not desired to be hyphenated. (Future extensions of Sprinter will separate keys and values?)

◆ operator<<() [2/2]

std::ostream & operator<<	(	std::ostream &	ostr,
		const image::TreeGDAL &	tree
	)

inline

Write tree using XML notation.

This function does not write the XML header containing document type info.

See also: NodeXML::toStream(); NodeXML::docToStream()

◆ polynomialFit2nd()

template<class T >

void polynomialFit2nd	(	const T &	src,
		const T &	weight,
		std::vector< double > &	coeff
	)

Fits a 2nd order polynomial to a curve.

If matrix inversion fails (probablt due to undetectValue determinant), the std::runtime_error thrown by inverse() is passed through.

◆ somToImage()

template<class T >

void somToImage	(	const Som< T > &	som,
		drain::image::Image &	image,
		int	width = `0`,
		int	height = `0`,
		const std::vector< int > &	channels = `std::vector<int>()`
	)

Squared Euclidean distance for vectors and similar.

The Self-Organising Map by Teuvo Kohonen.

The template

The coordinates of the map apply matrix convention ie. map[i][j] refers to element j on row i. The map is implemented a std::vector<vector<T> > . Generates a vector with values 0...255 sampled from uniform distribution. Utility to write contents of a vector SOM to a graylevel or RGB image.

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Detailed Description

Typedef Documentation

◆ FlexibleVariable

FlexibleVariable constructors

FlexibleVariable assignments

Variable

◆ Reference

Reference constructors

Reference assignments

◆ Variable

Reference constructors

Reference assignments

Function Documentation

◆ DRAIN_TYPENAME_DEF()

◆ getFunctor()

◆ getFunctorBank()

◆ operator<<() [1/2]

◆ operator<<() [2/2]

◆ polynomialFit2nd()

◆ somToImage()