 |
|
|
|
Namespaces | |
| image | |
| Namespace for images and image processing tools. | |
Classes | |
| struct | TypeName< rack::DataType< T, TI, D > > |
| class | Castable |
| class | CastableIterator |
| class | Caster |
| class | Convert |
| Utility class with static conversions. More... | |
| class | Convert2 |
| Utility class with static conversions. More... | |
| class | Kernel |
| class | NodeSLD |
| class | NeuralVector |
| class | Neuron |
| class | Layer |
| class | Bidirectional |
| class | ImageCodeMap |
| class | LegendEntry |
| class | Legend |
| struct | TypeName< image::Window< P, R > > |
| struct | Notification |
| class | Log |
| Handler for notifications sent by a Logger. More... | |
| class | DrainException |
| class | Logger |
| LogSourc e is the means for a function or any program segment to "connect" to a Log. More... | |
| class | Command |
| Base class for commands: typically actions taking parameters but also plain variable assignments and parameterless actions. More... | |
| class | BeanCommand |
| Retrieves bean dynamically for each call. More... | |
| class | BeanRefCommand |
| class | BasicCommand |
Simple implementation of Command: adds name , description and parameters . More... | |
| class | SimpleCommand |
| A single-parameter command. More... | |
| class | CommandBank |
| Container and execution tools for commands derived from Command. More... | |
| class | CmdVerbosity |
| class | CmdDebug |
| class | CmdLog |
| class | CmdStatus |
| class | CmdExpandVariables |
| class | CmdScript |
| Load script file and executes the commands immediately. More... | |
| class | CmdExecScript |
| Executes the defined script. More... | |
| class | CmdExecFile |
| Load script file and execute the commands immediately using current Context. More... | |
| class | HelpCmd |
| CommandBank-dependent. More... | |
| class | CmdFormat |
| class | CmdNotFound |
| Special command for handling undefined commands. More... | |
| class | CmdFormatFile |
| class | CommandInstaller |
| Creates an instance of command class C. More... | |
| class | CommandModule |
| Combines command installation and sectioning. More... | |
| class | CmdOpticalFlowBase |
| Utility for creating a Command that runs FastOpticalFlowOp operator. More... | |
| class | CommandSection |
| struct | HiddenSection |
| struct | GeneralSection |
| struct | TriggerSection |
| class | Context |
| class | ContextKit |
| Utilities. More... | |
| class | SmartContext |
| class | Contextual |
| class | SuperContextual |
| Adds class-specific convenience functions. More... | |
| class | CommandSequence |
| A base class for Script and Program. More... | |
| class | Script |
| 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 | PseudoTuple |
| struct | TypeName< PseudoTuple< C, T, N > > |
| class | ReferenceT |
| Intermediate class supporting link() in various forms. More... | |
| class | RegExp |
| class | MapTools |
| General purpose tools for handling values and keys of std::map<> More... | |
| class | SmartMapTools |
| A base class for smart maps providing methods for importing and exporting values, among others. More... | |
| class | TypeLayoutBase |
| Small container for printing style for putting of structured objects (array, maps, pairs). More... | |
| struct | TypeLayout |
| struct | SprinterLayout |
| class | Sprinter |
| class | Sprintlet |
| class | StreamBuilder |
| class | StringTools |
| class | StringBuilder |
| class | TextStyle |
| Utility for scanning text segments. More... | |
| class | TextStyleVT100 |
| class | TupleBase |
| struct | TypeName< TupleBase< S, N > > |
| class | Type |
| Utilities related to std::type_info. More... | |
| struct | TypeName |
| struct | TypeName< std::initializer_list< T > > |
| struct | TypeName< std::vector< T > > |
| class | simpleName |
| Returns the basic type (integer, float, bool, string, void) as a string. More... | |
| struct | TypeUtils |
| class | typesetter |
| Utility for implementing setType(const std::type_info &t) in classes supporting setType<T>(). More... | |
| class | sizeGetter |
Returns the sizeof() of a type. Accepts void (and returns size 0), which is not supported by std::numeric_limits. More... | |
| class | compactName |
| Returns the basic type (integer, float, bool, string, void) as a string. More... | |
| class | complexName |
| class | nameGetter |
| Returns the compiler specific ie. non-standard name of the type. More... | |
| class | typeIsFundamental |
| class | isSigned |
| class | typeIsScalar |
| Checks if type is numeric. More... | |
| class | typeIsInteger |
| class | typeIsFloat |
| class | typeIsSmallInt |
| The maximum value of a type given as type_info, char or std::string. More... | |
| struct | typeLimits |
| class | typeMin |
| The minimum value of a type given as type_info, char or std::string. More... | |
| class | typeMax |
| The maximum value of a type given as type_info, char or std::string. More... | |
| class | typeNaturalMax |
| The maximum value of a. More... | |
| class | typeLimiter |
| Class for ensuring that variable of type D remains within limits of type S. More... | |
| class | UniTuple |
| Tuple of N elements of type T. More... | |
| struct | TypeName< UniTuple< T, N > > |
| class | Bank |
| class | BankSuper |
| A Bank with additional support for brief, single char keys. More... | |
| class | UniCloner |
| Creates an entry of desired type and destroys it upon exit. More... | |
| class | BeanLike |
| Something which has a name, a description and possibly some parameters of varying type. More... | |
| class | BBox |
| Container for geographical extent spanned by lowerLeft(x,y) and upperRight(x,y). Assumes longitude=x and latitude=y . More... | |
| struct | ClonerBase |
| struct | Cloner |
| Wrapper for derived class S, returning base class T. More... | |
| class | Dictionary |
| Two-way mapping between strings and objects of template class T. More... | |
| class | DictionaryPtr |
| Associates type info. More... | |
| class | DotLayout |
| class | DotEntity |
| class | DotNode |
| class | DotBullit |
| class | DotRankNode |
| class | DotHeader |
| class | DotComment |
| class | DotLink |
| class | DotRank |
| class | FileInfo |
| class | FileHandler |
| class | FilePath |
| Extracts and stores directory path, base filename and extension. More... | |
| 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 | FlaggerBase |
| class | SingleFlagger |
| class | MultiFlagger |
| struct | EnumDict |
| class | EnumFlagger |
| Flagger accepting values of enum type E. More... | |
| class | Flagger2 |
| Flagger with referenced/external dictionary accepting values of (integer) type T. More... | |
| class | Flags2 |
| Flagger with own dictionary, and accepting values of (integer) type T. More... | |
| class | Flagger |
| A bit vector with external Dictionary mapping from strings to bits and vice versa. More... | |
| class | Flags |
| Self-contained Flagger – with an own dictionary and value. More... | |
| class | Frame2D |
| struct | Box |
| Something that has coordinates (x,y) and dimensions (width, height). More... | |
| class | Functor |
| Base class for sequential computations. Optional scaling utilities. More... | |
| struct | UnaryFunctor |
| struct | IdentityFunctor |
| class | BinaryFunctor |
| class | ScalingFunctor |
| Rescales intensities linearly: f' = scale*f + offset. More... | |
| class | NegateFunctor |
| Inverts intensities: f' = f_max - f. More... | |
| class | RemappingFunctor |
| Maps a single intensity value to another value. More... | |
| class | ThresholdFunctor |
| Thresholds intensity values. More... | |
| class | BinaryThresholdFunctor |
| Thresholds intensity values. More... | |
| class | AdditionFunctor |
| Adds a intensity values . More... | |
| class | SubtractionFunctor |
| Subtracts image from another image. More... | |
| class | MultiplicationFunctor |
| Multiplies two images, with optional post scaling and offset. More... | |
| class | DivisionFunctor |
| Divides image by another image. More... | |
| class | MixerFunctor |
| Blends an image to another with given proportion. More... | |
| class | MaximumFunctor |
| class | MinimumFunctor |
| Minimum intensity. Prescaled input. More... | |
| class | Fuzzifier |
| A base class for fuzzy functions; also an unary functor. More... | |
| class | FuzzyStep |
A basic, linear transition from 0 to scale between | |
| class | FuzzyTriangle |
| A basic triangular peak function with linear around the peak. 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 | FuzzySigmoid |
| A smooth step function, by default from -1.0 to +1.0. More... | |
| class | FuzzyStepsoid |
| A smooth step function between 0.0 and 1.0. Increasing (decreasing) with positive (negative) width. Otherwise like FuzzySigmoid. More... | |
| class | FuzzyTwinPeaks |
| A function taking shape of two peaks, with a zero in the middle . More... | |
| class | GlobalFlags |
| Flags using a global dictionary. More... | |
| class | Histogram |
| Class for computing a histogram and some statistics: average, min, max, mean, std.dev, sum. More... | |
| class | Input |
| Input utility. Opens stdIn with "-". Closes upon destruction. More... | |
| class | IosFormat |
| Stores precision, fillChar and fieldWidth applied by STD streams. More... | |
| class | JSON |
| Utility for extracting JSON-compatible strings, numbers or arrays of numbers in text data. More... | |
| class | LookUp |
| Look-up tables. More... | |
| class | LookUp2 |
| Look-up tables. More... | |
| class | FunctorLookUp |
| Values are available from [0,2PI]. More... | |
| class | MapReader |
| General utility for reading text entries of type KEY=VALUE into a map. More... | |
| class | MapWrapper |
| class | MapWriter |
| class | Matrix |
| class | Vector |
| class | Output |
| Output utility. Opens stdout with "-". Closes upon destruction. More... | |
| struct | PathSeparatorPolicy |
| Determines if separators will be stored in the path. More... | |
| class | Path |
| struct | Point2D |
| struct | Point3D |
| class | Projector |
| class | Proj6 |
| class | Projection |
| class | Range |
| struct | Rectangle |
| Rectange defined through lower left and upper right coordinates. More... | |
| class | ReferenceMap2 |
| A map of references to base type scalars, arrays or std::string; changing values in either are equivalent operations. More... | |
| class | ReferenceMap |
| class | Registry |
| A container for storing global objects like functors, operators or commands. Supports aliases. More... | |
| 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 | Som |
| class | Static |
| class | BiStatic |
| struct | status_flag_id |
| class | StatusFlags |
| 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 | TextDecorator |
| Utility for ... More... | |
| class | TextDecoratorVt100 |
| class | TextReader |
| Utility for scanning text segments. More... | |
| class | Time |
| Utility for handling time. Internally, uses tm (C time structure). More... | |
| class | DRAIN_TREE_NAME |
| A templated class for directed rooted trees. More... | |
| struct | TypeName< DRAIN_TREE_NAME< T, EXCLUSIVE, P > > |
| struct | BaseHTML |
| class | NodeHTML |
| class | TreeUtilsHTML |
| class | TreeUtils |
| Collection of functions for investigating and processing trees. More... | |
| class | StyleXML |
| class | ClassListXML |
| Container for style classes. Essentially a set of strings, with space-separated output support. More... | |
| class | NodeXML |
| struct | TypeName< drain::UnorderedMultiTree< NodeXML< E >, EX, P > > |
| class | ValueScaling |
| Linear scaling and physical range for image intensities. More... | |
| class | VariableFormatter |
| Formats variables to output stream. More... | |
| class | VariableMap |
| A map of Variables. More... | |
| class | FlexVariableMap |
| A map of FlexVariable:s. More... | |
| class | WeightedVector |
| class | VariableBase |
| Base class for variables: Variable, Reference and FlexibleVariable. More... | |
| class | VariableInitializer |
| class | VariableT |
| VariableT is a final class applied through typedefs Variable, Reference and FlexibleVariable. More... | |
Typedefs | |
| typedef VariableT< VariableInitializer< ReferenceT< VariableBase > > > | FlexibleVariable |
| Value container supporting dynamic type with own memory and optional linking (referencing) of external variables. More... | |
| 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. More... | |
| 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 |
| typedef drain::UnorderedMultiTree< drain::Variable, true > | JSONtree2 |
| typedef std::vector< double > | SomVector |
| typedef StringMatcherList< StringMatcher > | KeySelector |
| typedef NodeHTML::xml_tree_t | TreeHTML |
| The HTML data structure. | |
| typedef drain::UnorderedMultiTree< NodeXML<>, false, NodeXML<>::path_t > | TreeXML |
| typedef DRAIN_VARIABLE | Variable |
| Value container supporting dynamic type. More... | |
Functions | |
| DRAIN_TYPENAME_DEF (rack::DataSelector) | |
| DRAIN_TYPENAME (rack::DataSelector) | |
| DRAIN_TYPENAME_DEF (rack::PolarODIM) | |
| DRAIN_TYPENAME (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::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 * ! | |
| template<class T > | |
| ostream & | operator<< (ostream &ostr, const vector< T > &n) |
| Risk of conflicts? | |
| template<class T > | |
| ostream & | operator<< (ostream &ostr, const Kernel< T > &n) |
| DRAIN_TYPENAME_DEF (Crit) | |
| DRAIN_TYPENAME_DEF (Oper) | |
| DRAIN_TYPENAME_DEF (CritFlagger) | |
| DRAIN_TYPENAME_DEF (OperFlagger) | |
| template<class T > | |
| ostream & | operator<< (ostream &ostr, const Neuron< T > &n) |
| template<class T > | |
| ostream & | operator<< (ostream &ostr, const Layer< T > &n) |
| DRAIN_TYPENAME_DEF (FlexibleVariable) | |
| DRAIN_TYPENAME (FlexibleVariable) | |
| 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) | |
| DRAIN_TYPENAME (drain::image::ImageFrame) | |
| std::ostream & | operator<< (const LegendEntry &entry, std::ostream &ostr) |
| DRAIN_TYPENAME_DEF (image::NodeSVG) | |
| DRAIN_TYPENAME (image::NodeSVG) | |
| 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. More... | |
| 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()) |
| 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) | |
| template<class T > | |
| std::ostream & | operator<< (std::ostream &ostr, const Bank< T > &bank) |
| std::ostream & | operator<< (std::ostream &ostr, const BeanLike &bean) |
| 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 > | |
| std::ostream & | operator<< (std::ostream &ostr, const drain::FlaggerBase< E > &flagger) |
| template<typename E > | |
| std::ostream & | operator<< (std::ostream &ostr, const drain::SingleFlagger< E > &flagger) |
| template<typename E > | |
| std::ostream & | operator<< (std::ostream &ostr, const drain::MultiFlagger< E > &flagger) |
| std::ostream & | operator<< (std::ostream &ostr, const drain::Flagger &flags) |
| DRAIN_TYPENAME_T (Frame2D, 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. More... | |
| 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. More... | |
| 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_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 > | |
| std::ostream & | operator<< (std::ostream &ostr, const SmartMapFoo< 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. More... | |
| 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 (BaseHTML::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 (BaseHTML::tag_t) | |
| std::ostream & | operator<< (std::ostream &ostr, const StyleXML &style) |
| std::ostream & | operator<< (std::ostream &ostr, const ClassListXML &cls) |
| 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) |
| std::ostream & | operator<< (std::ostream &ostr, const drain::ValueScaling &s) |
| template<class T > | |
| std::ostream & | operator<< (std::ostream &ostr, const WeightedVector< T > &WeightedVector) |
| DRAIN_TYPENAME_DEF (Variable) | |
| DRAIN_TYPENAME (Variable) | |
| 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 |
See also radar::Compositor
See also radar::Composite
Part of Rack development has been done in the BALTRAD projects part-financed by the European Union (European Regional Development Fund and European Neighbourhood Partnership Instrument, Baltic Sea Region Programme 2007-2013)
Copyright 2001 - 2010 Markus Peura, Finnish Meteorological Institute (First.Last@fmi.fi)
This file is part of Rack for C++.
Rack is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser Public License as published by the Free Software Foundation, either version 3 of the License, or any later version.
Rack is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser Public License for more details.
You should have received a copy of the GNU General Public License along with Rack. If not, see http://www.gnu.org/licenses/.
| 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 | ||
|---|---|---|
| Default constructor | ||
| 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); | 12,34 |
| UniTuple3d uni3d(INIT_3d); V var(uni3d); | V variable(var); | 5.6,7.8,9 |
| 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); | 5.6,7.8,9 |
| UniTuple3d uni3d(INIT_3d); FlexibleVariable var(uni3d); | V variable(var); | 5.6,7.8,9 |
| UniTuple3d uni3d(INIT_3d); FlexibleVariable var; var.link(uni3d); | V variable(var); | 5.6,7.8,9 ® |
| UniTuple3d uni3d(INIT_3d); Reference var(uni3d); | V variable(var); | 5.6,7.8,9 ® |
| 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); | 12,34 |
| UniTuple3d uni3d(INIT_3d) | V variable(uni3d); | 5.6,7.8,9 |
| 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)); | 12,34 | |
| V variable(UniTuple3d(INIT_3d)); | 5.6,7.8,9 | |
| 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); | 12,34 |
| UniTuple3d ut(INIT_3d); | V variable(ut); | 5.6,7.8,9 |
| 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; | 12,34 | |
| V variable = UniTuple3d(INIT_3d); | 5.6,7.8,9 | |
| 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 | 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 | ," | ," | 12,34 | 12,34 | 12,34 | 12,34 | 12,34 | "12,34" © |
| UniTuple<3,double> | uni3d | true,true,true | ,, | ,, | 5,7,9 | 5,7,9 | 5,7,9 | 5.6,7.8,9 | 5.6,7.8,9 | "5.6,7.8,9" © |
| 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("test") | Variable(s) | false | t | 0 | 0 | 0 | 0 | 0 | "test" © | |
| std::string s("test") | FlexibleVariable(s) | false | t | 0 | 0 | 0 | 0 | 0 | "test" © | |
| std::string s("test") | Reference(s) | false | t | 0 | 0 | 0 | 0 | 0 | "test" © | |
| UniTuple | Variable(uni3d) | true,true,true | ,, | ,, | 5,7,9 | 5,7,9 | 5,7,9 | 5.6,7.8,9 | 5.6,7.8,9 | "5.6,7.8,9" © |
| UniTuple | FlexibleVariable(uni3d) | true,true,true | ,, | ,, | 5,7,9 | 5,7,9 | 5,7,9 | 5.6,7.8,9 | 5.6,7.8,9 | "5.6,7.8,9" © |
| UniTuple | Reference(uni3d) | true,true,true | ,, | ,, | 5,7,9 | 5,7,9 | 5,7,9 | 5.6,7.8,9 | 5.6,7.8,9 | "5.6,7.8,9" © |
See the combined review of drain::Variable, drain::Reference and drain::FlexibleVariable in the documentation of template drain::VariableT .
| 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 | ||
|---|---|---|
| Default constructor | ||
| 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); | 12,34 ® |
| UniTuple3d uni3d(INIT_3d); V var(uni3d); | V variable(var); | 5.6,7.8,9 ® |
| 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); | 5.6,7.8,9 ® |
| UniTuple3d uni3d(INIT_3d); Reference var(uni3d); | V variable(var); | 5.6,7.8,9 ® |
| 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); | 12,34 ® |
| UniTuple3d uni3d(INIT_3d) | V variable(uni3d); | 5.6,7.8,9 ® |
| 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 | 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 ® | ® | ® | 12 ® | 12 ® | 12 ® | 12 ® | 12 ® | "12,34" ® |
| UniTuple<3,double> | uni3d | true ® | ® | ® | 5 ® | 5 ® | 5 ® | 5.6 ® | 5.6 ® | "5.6,7.8,9" ® |
| 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("test") | Variable(s) | false ® | ® | t ® | 0 ® | 0 ® | 0 ® | 0 ® | 0 ® | "test" ® |
| std::string s("test") | FlexibleVariable(s) | false ® | ® | t ® | 0 ® | 0 ® | 0 ® | 0 ® | 0 ® | "test" ® |
| std::string s("test") | Reference(s) | false ® | ® | t ® | 0 ® | 0 ® | 0 ® | 0 ® | 0 ® | "test" ® |
| UniTuple | Variable(uni3d) | true ® | ® | ® | 5 ® | 5 ® | 5 ® | 5.6 ® | 5.6 ® | "5.6,7.8,9" ® |
| UniTuple | FlexibleVariable(uni3d) | true ® | ® | ® | 5 ® | 5 ® | 5 ® | 5.6 ® | 5.6 ® | "5.6,7.8,9" ® |
| UniTuple | Reference(uni3d) | true ® | ® | ® | 5 ® | 5 ® | 5 ® | 5.6 ® | 5.6 ® | "5.6,7.8,9" ® |
See the documentation of drain::VariableT template specialized by drain::Variable, drain::Reference and drain::FlexibleVariable .
| 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 .
| Variable | ||
|---|---|---|
| Default constructor | ||
| 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); | 12,34 |
| UniTuple3d uni3d(INIT_3d); V var(uni3d); | V variable(var); | 5.6,7.8,9 |
| 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); | 5.6,7.8,9 |
| UniTuple3d uni3d(INIT_3d); FlexibleVariable var(uni3d); | V variable(var); | 5.6,7.8,9 |
| UniTuple3d uni3d(INIT_3d); FlexibleVariable var; var.link(uni3d); | V variable(var); | 5.6,7.8,9 |
| UniTuple3d uni3d(INIT_3d); Reference var(uni3d); | V variable(var); | 5.6,7.8,9 |
| 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); | 12,34 |
| UniTuple3d uni3d(INIT_3d) | V variable(uni3d); | 5.6,7.8,9 |
| 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)); | 12,34 | |
| V variable(UniTuple3d(INIT_3d)); | 5.6,7.8,9 | |
| 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); | 12,34 |
| UniTuple3d ut(INIT_3d); | V variable(ut); | 5.6,7.8,9 |
| 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; | 12,34 | |
| V variable = UniTuple3d(INIT_3d); | 5.6,7.8,9 | |
| 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 | 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 | ," | ," | 12,34 | 12,34 | 12,34 | 12,34 | 12,34 | "12,34" © |
| UniTuple<3,double> | uni3d | true,true,true | ,, | ,, | 5,7,9 | 5,7,9 | 5,7,9 | 5.6,7.8,9 | 5.6,7.8,9 | "5.6,7.8,9" © |
| 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("test") | Variable(s) | false | t | 0 | 0 | 0 | 0 | 0 | "test" © | |
| std::string s("test") | FlexibleVariable(s) | false | t | 0 | 0 | 0 | 0 | 0 | "test" © | |
| std::string s("test") | Reference(s) | false | t | 0 | 0 | 0 | 0 | 0 | "test" © | |
| UniTuple | Variable(uni3d) | true,true,true | ,, | ,, | 5,7,9 | 5,7,9 | 5,7,9 | 5.6,7.8,9 | 5.6,7.8,9 | "5.6,7.8,9" © |
| UniTuple | FlexibleVariable(uni3d) | true,true,true | ,, | ,, | 5,7,9 | 5,7,9 | 5,7,9 | 5.6,7.8,9 | 5.6,7.8,9 | "5.6,7.8,9" © |
| UniTuple | Reference(uni3d) | true,true,true | ,, | ,, | 5,7,9 | 5,7,9 | 5,7,9 | 5.6,7.8,9 | 5.6,7.8,9 | "5.6,7.8,9" © |
See the documentation of drain::VariableT template specialized by drain::Variable, drain::Reference and drain::FlexibleVariable .
| drain::DRAIN_TYPENAME_DEF | ( | KeySelector | ) |
In future, the recommended way to define desired/accepted quantities is a comma-separated list of keys.
| drain::DRAIN_TYPENAME_DEF | ( | rack::RadarDataPicker< rack::PolarODIM > | ) |
This policy suggests typedef + spacialization for the actual classes, as well.
| UnaryFunctor & getFunctor | ( | const std::string & | nameAndParams, |
| char | separator = ',' |
||
| ) |
Returns functor the parameters of which have been set.
| separator | - |
| FunctorBank & getFunctorBank | ( | ) |
Shared functor bank
|
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?)
|
inline |
Write tree using XML notation.
This function does not write the XML header containing document type info.
| void drain::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.
| void drain::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.
1.9.1