| Boundary::AAArbitraryRectangle< T, Boolean, Float > | General-purpose axis-aligned rectangle, identical to AARectangle<> except that it also allows boxes to be infinite |
| Boundary::AARBoundingBox< T, Boolean, Float, BoxType > | General-purpose axis-aligned rectangular bounding box |
| Boundary::AARectangle< T, Boolean, Float > | Basic specification for an axis-aligned rectangle determined by (rl,cl), the corner closest to the origin, and (rh,ch), the corner furthest from it |
| Plot::AARImage< PixelType, PixelMatrix > | 2D axis-aligned rectangular pixel-based image |
| ActivityAccumulator | Accumulate activity values from multiple RetinalObjects |
| AllocatingPointer< T, Cloner, default_own > | Version of OwningPointer that adds a default argument to the value constructor, thus making it parameter-less, which allows it to be used in e.g |
| BasicLissomMap | Deprecated abstract base class offering old-style interface to routines in kernel.c, for use only by other deprecated classes |
| BasicLissomMap::Wts | The weights of a single neuron |
| Bounded::BoundedString< N, T > | Simple wrapper for a C array of characters that acts like a regular string, but has a fixed maximum size (silently cropping) and a c_str() pointer that can be passed around safely |
| Boundary::BoundingBox< T, Boolean, Float > | Abstract base class specifying interface suitable for any bounding box |
| Boundary::BoundingCircle< T, Boolean, Float > | Circular bounding box |
| Boundary::BoundingEllipse< T, Boolean, Float, BoxType > | General-purpose ellipsoidal bounding box |
| mat::CArrayMatrixAdapter< T, Array > | Wraps up a C array as a no-frills matrix; wrap this with a MatrixAdapter for more features |
| CmdWrapper | Abstract base class packaging up a command as a function object; this is used to support both global functions and functions with access to a particular object |
| Plot::ColorLookup< PixelType, Scale > | Abstract base class for something returning a color based on a magnitude |
| Plot::ColorLookupFactory< PixelType, Scale > | Wrapper for a single-dimensional ColorLookup specified in a string |
| Plot::ColorLookupTable< PixelType, Scale > | Base class for a finite array of possible colors that can be returned when given a magnitude |
| CopyAsNominalType< T > | Returns a copy of the given object |
| CopyUsingClone< T > | Returns a copy of the given object |
| Bounded::Crop< T > | Function object wrapper (a Boundary) for Generic::crop |
| DefaultActivityAccumulator | This could be combined with ActivityAccumulator, but it is kept separate just in case it might slow down ActivityAccumulator, which needs to be fairly efficient when large numbers of objects are in use |
| DistributedValueGeneratorFactory< T, urf, nrf > | Version of ValueGeneratorFactory that is safe for multiprocessor use |
| ExpressionParser< MapT > | Extends ExprParser with parameter lookup in a map |
| ExprParser< T > | Basic C-like expression parsing |
| Eyes | High-level manager of region definition, connection, and control |
| FixedWtRegion | NeuralRegion with a fixed, shared set of weights for all neurons |
| FixedWtRegion::Input | Record containing all we need to store about a given input region |
| Bounded::Float< T, MaxVal, MinVal, Boundary > | Bounded number with floating-point type |
| HasTable< BaseType, TableType > | Mixin class for something that owns a simple publicly-accessible table of named items |
| Plot::HSVPixel< Component, HComponent > | Hue,Saturation,Value image Pixel |
| Plot::HueColorLookup< PixelType, Scale > | Fixed saturation and value; hue encodes magnitude |
| Scale::Identity< T > | Function object that returns its object as-is |
| Plot::ImageGrid< PixelType, PixelMatrix > | Image composed of a rectangular grid of smaller images with an optional border between them |
| Plot::ImagePointerGrid< PixelType, PixelMatrix > | Image composed of a rectangular grid of smaller images (passed as pointers) with an optional border between them |
| Generic::index_iterator< C, TransformFnType > | Simple iterator adapter class providing element indexes instead of elements |
| Inputs | Class with responsibility for the entire set of network inputs |
| Bounded::Integer< T, MaxVal, MinVal, Boundary > | Bounded number with integral type |
| InternalNeuralRegion | Abstract base class for any NeuralRegion which accepts input from other NeuralRegions (unlike e.g |
| Boundary::Intersection< T, Boolean, Float, BBA, BBB > | BoundingBox consisting of the intersection between two already-defined bounding boxes |
| KernelFactory | Generates two-dimensional matrices of function values as kernels for convolution |
| KernelFactoryWrapper | Wraps a KernelFactory call into a function object taking a size_scale parameter |
| Plot::KRYWColorLookup< PixelType, Scale > | Hot colors on a black backround |
| Scale::Linear< T > | Function object that linearly scales its arguments |
| LISSOMBinaryStateSaver | StateSaver that can save the state of a LISSOM network to a binary file |
| LissomMap | Deprecated class offering old-style interface to routines in kernel.c |
| LissomMap::Input | Record containing all we need to store about a given input region |
| LoopSpec< T > | Loop counter specification |
| mat::MatrixAdapter< M, T, ScaleT, RegionT > | Adapter that allows you to view an existing matrix as another matrix with arbitrary linear value scaling, width and height extension or reduction, spatial offsetting, etc. as needed |
| Plot::MatrixImage< PixelType, PixelMatrix > | Image based on a rectangular matrix with an optional border |
| Plot::MatrixImageFactory< BaseMatrixType, T, ScaleT, Rectangle, PixelType, PixelMatrix > | Generalization of the MatrixImage<> constructors that allows up to three matrices to be combined into an overlaid plot |
| mat::MatrixInterface< T > | Abstract base class providing a simple unified virtual-function interface to matrices of various types |
| mat::MatrixInterfaceAdapter< M, T, ScaleT, RegionT > | Wraps up a MatrixAdapter<> as a MatrixInterface<>, without introducing any virtual function overhead into the actual MatrixAdapter<> class |
| mat::MatrixInterfaceBinaryAdapter< M, BinaryFunction, T > | Adapter that presents as a matrix the result of a scalar two-argument operation on the elements of two identically-sized matrices |
| mat::MatrixInterfaceConstant< T > | Convenience class for packaging a constant scalar value as a matrix of arbitrary size |
| MatrixType< T > | Wrapper to disguise the actual type of matrices while allowing the value type to be templated; simple typedefs wouldn't allow that |
| Generic::max_fnobj< T > | Function object returning the maximum of the two given objects of identical type |
| measure_stimulus_map_iteration< LoopContainer, UpdatableObjectContainer > | Function object for passing to LoopSpecs_ExecuteNested in measure_stimulus_map |
| MemoryReference< T > | Keeps track of at most one pointer, deleting it when this object is destroyed |
| Generic::name_match< T, N > | Predicate object applicable to any container of pointers to objects which have a name() member function |
| NamedValueGenerators | Defines and keeps a set of ValueGenerators as global parameters |
| NeuralRegion | Base class encompassing both sensory and cortical regions (input and hidden layers, in NN terminology) organized as a 2D matrix |
| NeuralRegion::Dimensions | Packages up specification of desired or actual input region |
| NeuralRegionManager | Manages housekeeping such as plotting and analysis for a NeuralRegion |
| NeuralRegionMap | Collection of all NeuralRegions, with global management and plotting routines |
| Distributions::normal | Returns a random number from the Gaussian distribution with the given sigma and mean |
| Plot::normalized_difference_fnobj< T > | Function object returning the difference between two given objects of identical type, scaled such that if each is in the range 0,1.0, the result will also be in the range 0,1.0 |
| SequenceTransform::OneD< InContainer, OutContainer > | Base class for a function that applies itself to a container to create another container with the same number of elements |
| Histo::OneDBinList< Count, Value > | Abstract base class for Histogram-like objects consisting of a finite one-dimensional list of bins with counts and values (possibly identical to the counts) in each bin, plus total counts and values |
| Histo::OneDHistogram< Count, Value > | General-purpose one-dimensional histogram |
| Histo::OneDHistogramDifference< Count, Value > | Difference between two one-dimensional histograms |
| Plot::OneDHistogramImage< PixelType, PixelMatrix > | Image of a histogram, with an optional border |
| OwningPointer< T, Cloner, default_own > | Simple pointer-like class to hide whether the object pointed to is an external object with its own lifetime, or an object allocated and managed by this class |
| ParameterDefinition< T > | Holds a single parameter definition, i.e |
| ParameterizedThreshold< InContainer, OutContainer > | Thresholding and bounding which look up their parameters |
| ParameterMap< ParamT > | Full-featured ParamMap managing documentation and definition as well as lookup |
| ParamMap | Abstract base class providing Typeless-specific functionality for a PointerMap |
| ParamStringParser< MapT, ParserT > | Cleaner interface to the parsing functions |
| PathSpecification | Simple class holding a fully-specified path to an item |
| Plot::Pixel | Abstract base class for a square image pixel, possibly transparent |
| Plot::PixelAverage< HSVPixelType > | Averages a series of pixels in HSV space |
| Plot::PlotSpecification< Matrix, String, ScaleType, MatrixTableType, ParameterMapType > | Complete specification for a particular type of plot, using named matrices chosen from a table of matrices passed in |
| PointerLookup< T, K > | Abstract, lookup-only base class for a PointerMap, i.e |
| PointerMap< T, K, owns_objects > | This is provided for use with objects which want to maintain a simple database of named objects |
| Generic::Polar< T > | Function object for constructing a complex number from a (rho,theta) pair |
| Polymorph< T > | Generic implementation of a polymorphic object; no support for numericvalue() |
| Polymorph< string > | Specialization for string types |
| PolymorphBase< T > | Wrapper to hide the type of an enclosed variable |
| Retina | Basic retina implemented as a transparent window into the world |
| Retinal_AnchoredManagedComposite | Specialized version of Retinal_ManagedComposite which can save some computation for activ() by knowing it is always at center (0,0), angle 0, and size 1.0 |
| Retinal_CircularGaussian | Retinal_Object for radially-symmetric Gaussian function |
| Retinal_Composite | Base class for composite objects, which are Retinal_Objects which may be composed of other Retinal_Objects |
| Retinal_FuzzyDisc | Retinal_Object for a circular disc with Gaussian falloff around a constant-intensity area |
| Retinal_FuzzyLine | Retinal_Object for a line with Gaussian falloff around a constant-intensity area |
| Retinal_FuzzyRing | Retinal_Object for a circular torus with Gaussian falloff around a constant-intensity area |
| Retinal_Gabor | Retinal_Object for Gabor function, which is a sine grating masked by a Gaussian |
| Retinal_Gaussian | Retinal_Object for an ellipsoidal Gaussian function |
| Retinal_ManagedComposite | Same as Retinal_Composite, but can enforce minimum and/or maximum distances between children's centers and do other housekeeping chores |
| Retinal_Obj | Abstract base class for an object which has a discrete state and which can return an activation value for any given floating-point position in the plane |
| Retinal_Object | Semi-abstract base class: Retinal_Obj with a name, intensity scale, intensity offset, center X and Y position, and angle which can be enabled and disabled on command |
| Retinal_PGM | Retinal_Object for a greyscale PGM bitmap read from a file |
| Retinal_RandomNoise< RandomGen > | Retinal_Object for random noise across the entire retina |
| Retinal_Rectangle | Retinal_Object for a single-color square or rectangle |
| Retinal_SineGrating | Retinal_Object for sine-wave or cosine-wave grating |
| RetinalObjectFactory | This class can create most or all of the Retinal_Object types contained in retinalobjs.h from a (fairly) simple string specification |
| RetinalObjectStringArgs | Helper class to handle string constructors for Retinal_Objects |
| Plot::RGBPixel< Component > | Red,Green,Blue image Pixel |
| Plot::SaturationColorLookup< PixelType, Scale > | Fixed saturation and value; hue encodes magnitude |
| ShuffledRandom< T > | Routine inspired by examples in "Numerical Recipes" with an extra shuffling of random numbers to avoid sequential correlations |
| Plot::SingleColorLookup< PixelType, Scale > | Returns a single fixed color |
| Plot::SpecifiedHueLookup< PixelType, Scale > | Accepts a specified hue and confidence, and paper_based_colors |
| StateSaver | Abstract base class for writing a state to a file when that state is directly accessible to this class (e.g. if the class is a friend of the classes to be saved, or if it is in global variables.) |
| StimulusParameterMap< MapBaseType, ValuePointer > | Base class for objects which compute and store the preference of a given region for a stimulus parameter |
| StimulusParameterMap_Combined< MapType, MapBaseType, ValuePointer > | Concrete class implementing both discrete and distribution-based methods for map computation |
| StimulusParameterMapsForRegion< MapType, MapBaseType, ValuePointer > | Holds a set of StimulusParameterMaps for one region |
| String::StreamFormat | Convenience structure to wrap up and pass around a set of arguments for stream output, e.g |
| StringArgs | Simple string-based function argument parser using StringParser |
| StringParser | This class provides a basic way for values of various types to be specified in a string |
| synchronized_distribution< RandomGen > | Multiprocessor-safe wrapper for a random distribution |
| SequenceTransform::Threshold< InContainer, OutContainer > | Example of basic thresholding |
| Boundary::TwoOrderedPoints< T > | Low-level class containing a pair of two-dimensional points in X and Y |
| Typeless | Abstract base class for a pointer to an object of nominally unspecified type |
| Generic::unary_virtual_function< Arg, Result > | Version of unary_function suitable for non-templated functions which must take a specific type of argument |
| Distributions::uniform | Returns a random number from a uniform distribution with a given radius (that is, range/2) and mean |
| Plot::ValueColorLookup< PixelType, Scale > | Fixed hue and saturation (often greyscale); value encodes magnitude |
| ValueGen | Abstract base class for anything that supports a next and a reset |
| ValueGenContainer | Generic bag of ValueGens |
| ValueGenerator< T > | This heads a class hierarchy of objects which primarily contain a variable of the given type, but which also contain operations for automatically generating a new value from a given distribution or by some other means |
| ValueGenerator_Correlate< T, RandomGen, crop > | Distribute value around a master value located elsewhere, using a supplied uncorrelation factor plus upper and lower bounds |
| ValueGenerator_Expression< T > | Evaluate the given expression using a copy of the given parser each time |
| ValueGenerator_Increment< T > | Increment a starting value each time by the given amount |
| ValueGenerator_Opposite< T > | Given a factor f and a master value mv located elsewhere, the value of this object will be f-mv |
| ValueGenerator_Random< T, RandomGen > | Choose value from a given random distribution |
| ValueGeneratorFactory< T, urf, nrf > | This class can create most or all of the ValueGenerator types contained in this file from a (fairly) simple string specification |
| ValueGeneratorMap< T, K > | This is provided for use with objects which want to maintain a simple database of named ValueGenerator objects |
| VGenFactory< T > | Abstract base class for ValueGeneratorFactory independent of all template parameters except the datatype |
| WeightSet< MatrixT, BoundsT, MapBaseType, MapType > | General base class for a set of weights from one unit in a map (e.g |
| WorldViews | Set of Retinal_Objects representing the views seen by a set of eyes |
| Bounded::Wrap< T > | Function object wrapper (a Boundary) for Generic::wrap |
