---

ppm_draw.c

Go to the documentation of this file.

#include "tristate.h"
#include "globals.h"
#include "ppm_draw.h"
#include "neuralregionmap.h"



/******************************************************************************/
/* Defines and typedefs                                                       */
/******************************************************************************/

/* Possible values for cortex plot hue, etc.  (ppm_*_subplot)

   For activity plots, luminance (aka value) encodes activity level, but 
   the hue can encode other information if needed 
*/

//#define PPM_RYW             0    
//#define PPM_GRAYSCALE       1    
//#define PPM_ORIENTATION     2    
//#define PPM_OCULARDOMINANCE 3    
//#define PPM_SINGLEHUE       4    
//#define PPM_NONE            5    
//#define PPM_SELECTIVITY     6    
//#define PPM_MAX_SUBPLOT     6    /*  Maximum number defined above */


/******************************************************************************/
/* Initialization hook                                                        */
/******************************************************************************/

void  NeuralRegionMap::ppm_init_hook( void )
{
  /* Constant values */
//  CONST_I(PPM_RYW,            PPM_RYW,            False,
//          "Subplot type where the primary plot is encoded using a special colormap.\n"
//          "When using this with ppm_paper_based_colors==False, inactive units\n"
//          "are colored black, moderately active units are red, strongly activated\n"
//          "units are colored yellow, and maximally activated units are colored\n"
//          "white.  Such a color scheme emphasizes peaks, particularly on video\n"
//          "terminals.  The colors are reversed when ppm_paper_based_colors is\n"
//          "true, which isn't quite as effective on paper; in that case PPM_Grayscale\n"
//          "is a better choice.");
//  
//  CONST_I(PPM_Grayscale,      PPM_GRAYSCALE,      False,
//          "Subplot type where monochrome luminance encodes value (e.g. activity).\n"
//          "White represents maximum unless ppm_paper_based_colors is true.");
//  
//  CONST_I(PPM_Orientation,    PPM_ORIENTATION,    False,
//          "Subplot type where the primary plot is represented by saturation or luminance\n"
//          "(depending on whether ppm_paper_based_colors is True or False, respectively),\n"
//          "while the hue encodes orientation preference.\n\n"
//          
//          "For retinal plots, each input pixel is colored by the nominal orientation of\n"
//          "the object with the highest intensity value at that pixel.  This value is\n"
//          "not guaranteed to match the actual orientation judgment of a human observer,\n"
//          "since e.g. a composite object will return its own orientation, even though\n"
//          "the local orientation of a subobject may differ.");
//  
//  CONST_I(PPM_OcularDominance,PPM_OCULARDOMINANCE,False,
//          "Subplot type where the primary plot is represented by saturation or luminance\n"
//          "(depending on whether ppm_paper_based_colors is True or False, respectively),\n"
//          "while the hue encodes ocular dominance.");
//
//  CONST_I(PPM_SingleHue,      PPM_SINGLEHUE,      False,
//          "Subplot type where the entire plot uses a hue specified by ppm_subplot_hue.");
//  
//  CONST_I(PPM_None,           PPM_NONE,           False,
//          "Subplot type where, depending upon the type of plot, the primary plot is\n"
//          "represented by hue or luminance at full strength.");
//  
//  CONST_I(PPM_Selectivity,    PPM_SELECTIVITY,    False,
//          "Used for plots consisting of a primary dimension (e.g. orientation or\n"
//          "ocular dominance), a selectivity associated with the primary\n"
//          "dimension, and an optional level (e.g. activity or weight strength;\n"
//          "assumed 1.0 if none).  The primary dimension is represented by hue,\n"
//          "while the other two dimensions are represented using luminance and\n"
//          "saturation.  The level effectively acts as a mask for a plot with the\n"
//          "selectivity as saturation (ppm_paper_based_colors=False) or luminance\n"
//          "(ppm_paper_based_colors=True).  For ppm_paper_based_colors=False, the\n"
//          "mask is implemented simply by using the level as the luminance.  If\n"
//          "ppm_paper_based_colors=True, the mask is implemented by using the\n"
//          "level as the saturation and Max(1-scaled_level,selectivity) as the\n"
//          "luminance.  Both methods should be equivalent; they differ only\n"
//          "because the color-expressing properties of luminance and saturation\n"
//          "are opposites.");

  CONST_I(PPM_WtScale_Fixed,  int(WtScale::Fixed),  False,
          "Scale the weights for all neurons by a constant multiplicative factor\n"
          "'value_scale', regardless of their values or number of connections\n"
          "defined or active.  This makes it simple to compare absolute weight\n"
          "values between different plots.  However, it obscures differences in\n"
          "weight levels between adjacent units except at a single set of parameter\n"
          "values for which the multiplier has been chosen to be optimum.");

//  CONST_I(PPM_WtScale_Inhib,PPM_WTSCALE_INHIB,False,
//          "Scale all weights by the number of inhibitory connections.\n"
//          "This makes obvious the differences in weight strength between excitatory\n"
//          "and inhibitory connections.");

  CONST_I(PPM_WtScale_Count,int(WtScale::Count),False,
          "Scale the weights for a given neuron by the number of connections defined.\n"
          "Depending upon the values of  ppm_weight_scale_init_count and\n"
          "ppm_weight_scale_max_count, this can make obvious the differences in weight\n"
          "value between weights to adjacent neurons or between different neurons or\n"
          "between the same neurons over time.");

  CONST_I(PPM_WtScale_Active, int(WtScale::Active), False,
          "Scale the weights for a given neuron by the number of active (non-dead)\n"
          "connections for that neuron.  This makes obvious the differences in\n"
          "weight levels between adjacent units, even when many units have been\n"
          "pruned, but obscures the increase in weight strength which pruning\n"
          "brings about.");

  CONST_I(PPM_WtScale_PeakRelative,int(WtScale::PeakRelative),  False,
          "Scale the weights for a given neuron so that the actual maximum value\n"
          "present is assigned the maximum value representable in a plot, while\n"
          "the minimum is set at zero.  This makes local differences in value\n"
          "obvious without obscuring the distinction between zero and nonzero values.");

  CONST_I(PPM_WtScale_Relative,int(WtScale::Relative),  False,
          "Scale the weights for a given neuron so that the actual maximum and minimum\n"
          "values present are assigned the minimum and maximum values representable in\n"
          "a plot.  This always makes obvious the differences between weight values to\n"
          "adjacent units, which means that it is easy to use, but it also makes it\n"
          "impossible to compare absolute or relative weight values between different\n"
          "plots.");

  
//  PARAM_A(blackboard,"ppm_activity_subplot",PPM_RYW,.add_lower_bound(0).add_upper_bound(PPM_MAX_SUBPLOT),
//          "Secondary plot (using e.g. the hue value) for activity plots.\n\n"
//          "Possible settings (starting with PPM_):\n"
//          "  RYW,Grayscale,OcularDominance,Orientation,Selectivity,SingleHue,None");
//
//  PARAM_A(blackboard,"ppm_activity_luminance_offset",0.0,.add_lower_bound(0.0).add_upper_bound(1.0),
//          "Amount to add to the computed value for activity plots using luminance.\n"
//          "Normally this is zero, but if set to e.g. 0.25 in combination with a\n"
//          "ppm_activity_subplot of e.g. orientation, the orientation map can be made\n"
//          "out dimly even in areas where there is no activity.  This can help relate\n"
//          "the activity bubbles to their location on the map.");
//  
//  PARAM_A(blackboard,"ppm_always_mark_neuron",False,.add_lower_bound(False).add_upper_bound(True),
//          "If true, always draw an outline around the neuron that is being plotted\n"
//          "in e.g. a weight plot, and also draw an outline around the RF center of\n"
//          "that neuron on the retina.  Ordinarily the neuron is marked only when\n"
//          "ppm_outline_weights is true and only in the inhibitory plots, since the\n"
//          "center is usually clear on the smaller areas of the afferent and lateral\n"
//          "excitatory plots.");
  
  PARAM_A(blackboard,"ppm_master_scale",1.0,.add_lower_bound(double(Uninitialized)),
          "Ordinarily, this parameter will be set to 1.0, which means to automatically\n"
          "compute the minimum plot sizes that will show the full cortex and retina,\n"
          "regardless of the settings of ppm_cortex_scale, ppm_retina_scale,\n"
          "etc.  If higher-resolution plots are desired, it can be\n"
          "set to a larger value, e.g. 2.0 to make all plots twice the normal size.\n"
          "Note that larger plots are not strictly multiples of the smaller ones,\n"
          "since the higher the resolution, the finer a line can be used for details\n"
          "such as outlines.  To handle the scaling yourself, set this parameter to\n"
          "Uninitialized and set the aforementioned parameters as you desire.  Note\n"
          "that like the other scaling parameters, it is of type double but\n"
          "currently only integer multiples are actually used.");
  
//  PARAM_A(blackboard,"ppm_afferent_multiplier",100.0,.add_lower_bound(0.0),
//          "Amount by which to multiply afferent weight value to get luminance value for\n"
//          "plots.");
//  
//  PARAM_A(blackboard,"ppm_afferent_subplot",PPM_RYW,.add_lower_bound(0).add_upper_bound(PPM_MAX_SUBPLOT),
//          "Secondary plot (using e.g. the hue value) for afferent weight plots.\n\n"
//          "Possible settings (starting with PPM_):\n"
//          "  RYW,Grayscale,OcularDominance,Orientation,Selectivity,SingleHue,None");
//  
//  PARAM_A(blackboard,"ppm_always_draw_point",True,.add_lower_bound(False).add_upper_bound(True),
//          "Whether ppm_draw_line_at_angle() always draws at least one point, e.g. when \n"
//          "plotting orientation using lines.");
  
  PARAM_A(blackboard,"ppm_bg_B",double(Uninitialized),.add_lower_bound(double(Uninitialized)).add_upper_bound(1.0),
          "Blue component of color of border areas; default is white or\n"
          "black depending on ppm_paper_based_colors.");
  blackboard.lookup("ppm_bg_B").add_default_expr("(1-ppm_paper_based_colors)*1.0");
  
  PARAM_A(blackboard,"ppm_bg_G",double(Uninitialized),.add_lower_bound(double(Uninitialized)).add_upper_bound(1.0),
          "Green component of color of border areas; default is white\n"
          "or black depending on ppm_paper_based_colors.");
  blackboard.lookup("ppm_bg_G").add_default_expr("(1-ppm_paper_based_colors)*1.0");
  
  PARAM_A(blackboard,"ppm_bg_R",double(Uninitialized),.add_lower_bound(double(Uninitialized)).add_upper_bound(1.0),
          "Red component of color of border areas; default is white or\n"
          "black depending on ppm_paper_based_colors.");
  blackboard.lookup("ppm_bg_R").add_default_expr("(1-ppm_paper_based_colors)*1.0");
  
  PARAM_A(blackboard,"ppm_border",1,.add_lower_bound(0),
          "Number of pixels between subsequent plots in the same image; defaults to 3%\n"
          "of the image size, subject to a minimum of two.");
  
//  PARAM_A(blackboard,"ppm_color_key_num",13,.add_lower_bound(0),
//          "The number of oriented bars to use in a color key when ppm_color_keys is true.");
//  
//  PARAM_A(blackboard,"ppm_color_keys",Uninitialized,.add_lower_bound(Uninitialized).add_upper_bound(True),
//          "Whether or not to draw a color key after a color plot.  By default will draw\n"
//          "one if color-coded orientation was used.");
//  
//  PARAM_A(blackboard,"ppm_combine_alternate_eyes",False,.add_lower_bound(False).add_upper_bound(True),
//          "If there is more than one eye (and an even number total), plot them by twos\n"
//          "where the second half of each pair is subtracted from the first.  This is\n"
//          "useful for e.g. ON and OFF cell layers created using Blur_DoGGoD.  This\n"
//          "option will need more work to be very useful except with a very limited\n"
//          "range of absolute unnormalized weights, since right now weights are\n"
//          "normalized independently between the two subtracted values (which has\n"
//          "poor results.)");
//  
//  PARAM_A(blackboard,"ppm_cortex_scale",double(Uninitialized),.add_lower_bound(double(Uninitialized)),
//          "Scaling factor when plotting cortex.  Defaults to autoscale to match retina.\n"
//          "At the moment only integer values are used, to ensure that plots always devote\n"
//          "the same number of pixels to each neuron (to prevent confusion).  As a result\n"
//          "plots will not be shown if the scale is less than 1.  This restriction may be\n"
//          "relaxed in the future.");
//  
//  PARAM_A(blackboard,"ppm_end_i",int(Uninitialized),.add_lower_bound(int(Uninitialized)),
//          "By default, the entire cortex is plotted, but when ppm_master_scale is\n"
//          "Uninitialized, this parameter is one higher than the last pixel plotted\n"
//          "in the X direction.");
//  
//  PARAM_A(blackboard,"ppm_end_j",int(Uninitialized),.add_lower_bound(int(Uninitialized)),
//          "By default, the entire cortex is plotted, but when ppm_master_scale is\n"
//          "Uninitialized, this parameter is one higher than the last pixel plotted\n"
//          "in the Y direction.");
//  
//  PARAM_A(blackboard,"ppm_end_x",int(Uninitialized),.add_lower_bound(int(Uninitialized)),
//          "By default, the entire retina is plotted, but when ppm_master_scale is\n"
//          "Uninitialized, this parameter is one higher than the last pixel plotted\n"
//          "in the X direction.");
//  
//  PARAM_A(blackboard,"ppm_end_y",int(Uninitialized),.add_lower_bound(int(Uninitialized)),
//          "By default, the entire retina is plotted, but when ppm_master_scale is\n"
//          "Uninitialized, this parameter is one higher than the last pixel plotted\n"
//          "in the Y direction.");
//  
//  PARAM_A(blackboard,"ppm_histo_scale_factor",0.25,.add_lower_bound(0.0),
//          "Ratio applied to the size of a cortex plot to get the width of an accompanying\n"
//          "histogram.");
//  
//  PARAM_A(blackboard,"ppm_histo_percentage_range",25.0,.add_lower_bound(0.0).add_upper_bound(100.0),
//          "Range of an activity histogram, peak to peak, as a percentage.");
  
  PARAM_A(blackboard,"ppm_histograms",True,.add_lower_bound(False).add_upper_bound(True),
          "Whether to include activity histograms with plots, if such data is\n"
          "available, e.g. from a call to measure_stimulus_map.");
  
  PARAM_A(blackboard,"ppm_mainplot",True,.add_lower_bound(False).add_upper_bound(True),
          "Whether to include the primary plot for this plot type.  Primarily useful with\n"
          "ppm_histograms=False, to get a plot of only the histograms, e.g. with\n"
          "plot_unit_range.");
  
  PARAM_A(blackboard,"ppm_interior_border",-0.03,,
          "Number of pixels to skip between internal image features, e.g. orientation\n"
          "lines.  If negative, this value is used as a scaling factor relative to the\n"
          "smaller of the largest width and largest height of a region; scaling with\n"
          "respect to that value gives visually similar borders for regions with\n"
          "different sizes (after bitmap scaling to match).");
  
  PARAM_A(blackboard,"ppm_interior_outline",False,.add_lower_bound(False).add_upper_bound(True),
          "Whether or not to outline smaller maps which appear inside of larger ones,\n"
          "e.g. for plot_afferent_weight_map");
  
  PARAM_A(blackboard,"ppm_image_viewer",string("xv -expand 4 -raw"),,
          "External program to spawn when an image is created, spawn_viewer is\n"
          "true, and running_remotely is false.");
  
//  PARAM_A(blackboard,"ppm_lateral_multiplier",700.0,.add_lower_bound(0.0),
//          "Amount by which to multiply lateral weight value to get luminance value for\n"
//          "plots.");
//  
//  PARAM_A(blackboard,"ppm_lateral_subplot",PPM_RYW,.add_lower_bound(0).add_upper_bound(PPM_MAX_SUBPLOT),
//          "Secondary plot (using e.g. the hue value) for lateral weight plots.\n\n"
//          "Possible settings (starting with PPM_):\n"
//          "  RYW,Grayscale,OcularDominance,Orientation,Selectivity,SingleHue,None");
  
  PARAM_A(blackboard,"ppm_line_B",double(Uninitialized),.add_lower_bound(double(Uninitialized)).add_upper_bound(1.0),
          "Blue component of color of lines to be drawn on an image;\n"
          "default is dynamically chosen to have good contrast with the area of the\n"
          "image being overwritten.");
  blackboard.lookup("ppm_line_B").add_default_expr("ppm_paper_based_colors*1.0");
  
  PARAM_A(blackboard,"ppm_line_G",double(Uninitialized),.add_lower_bound(double(Uninitialized)).add_upper_bound(1.0),
          "Green component of color of lines to be drawn on an image;\n"
          "default is dynamically chosen to have good contrast with the area of the\n"
          "image being overwritten.");
  blackboard.lookup("ppm_line_G").add_default_expr("ppm_paper_based_colors*1.0");
  
  PARAM_A(blackboard,"ppm_line_R",double(Uninitialized),.add_lower_bound(double(Uninitialized)).add_upper_bound(1.0),
          "Red component of color of lines to be drawn on an image; default is dynamically\n"
          "chosen to have good contrast with the area of the image being overwritten.");
  blackboard.lookup("ppm_line_R").add_default_expr("ppm_paper_based_colors*1.0");
  
//  PARAM_A(blackboard,"ppm_line_orientation_subplot",PPM_SELECTIVITY,.add_lower_bound(0).add_upper_bound(PPM_MAX_SUBPLOT),
//          "Secondary plot (using the line length of orientation lines) for orientation\n"
//          "map plots.\n\n"
//          "Possible settings (starting with PPM_): Selectivity,None");
//  
//  PARAM_A(blackboard,"ppm_line_plots",False,.add_lower_bound(False).add_upper_bound(True),
//          "Whether to draw line plots (e.g. for orientation or weights) as opposed to \n"
//          "(or in addition to) shaded plots.");
//  
//  PARAM_A(blackboard,"ppm_line_selectivity_multiplier",50.0,.add_lower_bound(0.0),
//          "Amount by which to multiply orientation selectivity to get line length for\n"
//          "plots.");
//  
//  PARAM_A(blackboard,"ppm_luminance_multiplier",1.0,.add_lower_bound(0.0),
//          "Amount by which to multiply activity to get luminance value for plots.");
//  
//  PARAM_A(blackboard,"ppm_minimal_outline",False,.add_lower_bound(False).add_upper_bound(True),
//          "Whether to outline the active lateral weights only, or all of those\n"
//          "currently allowed.  If true, outlines only those units with weights greater\n"
//          "than ppm_weight_threshold.");
//  
//  PARAM_A(blackboard,"ppm_neuron_ioffset_line",0,.add_lower_bound(0),
//          "Horizontal offset for skipping when ppm_neuron_skip_line is not 1.  This\n"
//          "determines where the cycles start.  It is usually zero but can be set\n"
//          "to some other value X such that (0 < X < ppm_neuron_skip_line) to ensure\n"
//          "that a particular neuron is actually drawn.");
//  
//  PARAM_A(blackboard,"ppm_neuron_joffset_line",0,.add_lower_bound(0),
//          "Vertical offset for skipping when ppm_neuron_skip_line is not 1.  This\n"
//          "determines where the cycles start.  It is usually zero but can be set\n"
//          "to some other value X such that (0 < X < ppm_neuron_skip_line) to ensure\n"
//          "that a particular neuron is actually drawn.");
//  
//  PARAM_A(blackboard,"ppm_neuron_skip_line",1,.add_lower_bound(1),
//          "Draw every nth neuron only, for line plots.");
  
  PARAM_A(blackboard,"ppm_neuron_skip_aff",1,.add_lower_bound(1),
          "Draw every nth neuron only, for afferent weight map plots.");
  
//  PARAM_A(blackboard,"ppm_ocular_dominance_subplot",PPM_RYW,.add_lower_bound(0).add_upper_bound(PPM_MAX_SUBPLOT),
//          "Type of plot for ocular dominance map plots.\n\n"
//          "Possible settings (starting with PPM_):\n"
//          "  RYW,Grayscale,Selectivity,SingleHue,None");
//  
//  PARAM_A(blackboard,"ppm_orientation_subplot",PPM_NONE,.add_lower_bound(0).add_upper_bound(PPM_MAX_SUBPLOT),
//          "Secondary plot (using e.g. the luminance value) for orientation map plots.\n\n"
//          "Possible settings (starting with PPM_): Grayscale,Selectivity,None\n"
//          "See the documentation for those options for more details.");
//  
//  PARAM_A(blackboard,"ppm_outline_retina",True,.add_lower_bound(False).add_upper_bound(True),
//          "Whether to draw a line around the active area of the retina, i.e. the area\n"
//          "not included in the retina_edge_buffer region, when retina_edge_buffer is\n"
//          "nonzero.  See also ppm_retina_edge_buffer_suppress.");
  
  PARAM_A(blackboard,"ppm_outline_weights",True,.add_lower_bound(False).add_upper_bound(True),
          "Whether to draw a line around the active weight area plotted on maps of the\n"
          "cortex.");
  
  PARAM_A(blackboard,"ppm_outline_width",1,.add_lower_bound(0),
          "Number of pixels to use for intra-picture outlines.");
  
  PARAM_A(blackboard,"ppm_page_B",0.5,.add_lower_bound(0.0).add_upper_bound(1.0),
          "Blue component of color of page background.");
  
  PARAM_A(blackboard,"ppm_page_G",0.5,.add_lower_bound(0.0).add_upper_bound(1.0),
          "Green component of color of page background.");
  
  PARAM_A(blackboard,"ppm_page_R",0.5,.add_lower_bound(0.0).add_upper_bound(1.0),
          "Red component of color of page background.");
  
  PARAM_A(blackboard,"ppm_paper_based_colors",False,.add_lower_bound(False).add_upper_bound(True),
          "Usually, the colors are suitable for video, with black backgrounds and \n"
          "luminance encoding the weight or activation level.  For paper plots, this\n"
          "parameter can be set to 1 so that white backgrounds are used and saturation\n"
          "will encode the level.");
  SETFNOBJ_DEFINE2(this,ppm_paper_based_colors,color_param_setfn2);
  
//  PARAM_A(blackboard,"ppm_paper_based_retina",Uninitialized,.add_lower_bound(Uninitialized).add_upper_bound(True),
//          "If set to Boolean value other than Uninitialized, whether to consider\n"
//          "ppm_paper_based_colors true for the retina regardless of its global value.");
//  
//  PARAM_A(blackboard,"ppm_reference_angle",0.0,.add_lower_bound(0.0).add_upper_bound(180.0),
//          "When setting luminance for monochrome orientation plots, this will be the\n"
//          "angle (in degrees) at which luminance is zero.");
  
  PARAM_A(blackboard,"ppm_remote_viewer",string("anytoascii"),,
          "External program to spawn when an image is created, spawn_viewer is\n"
          "true, and running_remotely is true.");
  
//  PARAM_A(blackboard,"ppm_retina_scale",double(Uninitialized),.add_lower_bound(double(Uninitialized)),
//          "Scaling factor when plotting retina.  Defaults to autoscale to match cortex.\n"
//          "At the moment only integer values are used, to ensure that plots always devote\n"
//          "the same number of pixels to each retinal unit (to prevent confusion).  As a\n"
//          "result plots will not be shown if the scale is less than 1.  This restriction\n"
//          "may be relaxed in the future.");
//  
//  PARAM_A(blackboard,"ppm_retina_subplot",PPM_RYW,.add_lower_bound(0).add_upper_bound(PPM_MAX_SUBPLOT),
//          "Secondary plot (using e.g. the hue value) for retinal activation plots.\n\n"
//          "Possible settings (starting with PPM_):\n"
//          "  RYW,Grayscale,Orientation,SingleHue,None");
//  
//  PARAM_A(blackboard,"ppm_retina_edge_buffer_suppress",False,.add_lower_bound(False).add_upper_bound(True),
//          "If true, will only plot the active area of the retina, i.e. the area\n"
//          "not included in the retina_edge_buffer region.  See also ppm_outline_retina.");

  PARAM_A(blackboard,"ppm_selectivity_multiplier",16,.add_lower_bound(0.0),
          "Amount by which to multiply orientation selectivity to get luminance value\n"
          "for plots.  Appropriate value varies, depending on how selectivity is\n"
          "measured.");

//  PARAM_A(blackboard,"ppm_shaded_plots",True,.add_lower_bound(False).add_upper_bound(True),
//          "Whether to draw shaded plots, including color and mono plots (e.g. for \n"
//          "orientation). (Not necessarily exclusive of ppm_line_plots.)");
//
//  PARAM_I(PARAM_3BOOL,  ppm_spawn_viewer,Uninitialized,True,
//          "Alias for spawn_viewer; whether to spawn an external program (specified by\n"
//          "ppm_image_viewer) to view an image when it is created.");
  
  PARAM_A(blackboard,"ppm_spawn_independent_viewers",True,.add_lower_bound(False).add_upper_bound(True),
          "When spawn_viewer is true, whether to spawn for every image, or just the first\n"
          "one.");
  
//  PARAM_A(blackboard,"ppm_start_i",int(Uninitialized),.add_lower_bound(int(Uninitialized)),
//          "By default, the entire cortex is plotted, but when ppm_master_scale is\n"
//          "Uninitialized, this parameter sets the first pixel plotted in the X direction.");
//  
//  PARAM_A(blackboard,"ppm_start_j",int(Uninitialized),.add_lower_bound(int(Uninitialized)),
//          "By default, the entire cortex is plotted, but when ppm_master_scale is\n"
//          "Uninitialized, this parameter sets the first pixel plotted in the Y direction.");
//  
//  PARAM_A(blackboard,"ppm_start_x",int(Uninitialized),.add_lower_bound(int(Uninitialized)),
//          "By default, the entire retina is plotted, but when ppm_master_scale is\n"
//          "Uninitialized, this parameter sets the first pixel plotted in the X direction.");
//  
//  PARAM_A(blackboard,"ppm_start_y",int(Uninitialized),.add_lower_bound(int(Uninitialized)),
//          "By default, the entire retina is plotted, but when ppm_master_scale is\n"
//          "Uninitialized, this parameter sets the first pixel plotted in the Y direction.");

  PARAM_A(blackboard,"ppm_subplot_hue",-1.0,.add_lower_bound(-1.0).add_upper_bound(1.0),
          "The hue (in terms of Hue, Saturation, and Value) to use when a colorspec is\n"
          "set to SpecifiedHue.");
  
//  PARAM_A(blackboard,"ppm_ui",int(Uninitialized),.add_lower_bound(int(Uninitialized)),
//          "Denotes x-coordinate of unit to graph as a secondary plot, e.g. as lateral\n"
//          "weights on top of another plot.");
//  
//  PARAM_A(blackboard,"ppm_uj",int(Uninitialized),.add_lower_bound(int(Uninitialized)),
//          "Denotes y-coordinate of unit to graph as a secondary plot, e.g. as lateral\n"
//          "weights on top of another plot.");
//  
//  PARAM_A(blackboard,"ppm_value_offset",0.1,.add_lower_bound(0.0).add_upper_bound(1.0),
//          "Determines the offset of the range of values used for HSV coordinates.\n"
//          "Not always used; check to make sure for a particular plot.");
//  
//  PARAM_A(blackboard,"ppm_value_range",0.6,.add_lower_bound(0.0).add_upper_bound(1.0),
//          "Determines the range of Values used for HSV coordinates.  Not always used;\n"
//          "check to make sure for a particular plot.");
  
  PARAM_A(blackboard,"ppm_weight_threshold",DEATH_FLAG,,
          "Strength of weight to consider active for weight plots.");

//  PARAM_A(blackboard,"ppm_weight_scale_init_count",True,.add_lower_bound(False).add_upper_bound(True),
//          "When plotting weights on a scale relative to the number of connections\n"
//          "(ppm_weight_scale_type == Count), whether to base the scale on\n"
//          "the number of connections defined at the start of the simulation, as\n"
//          "opposed to the number currently defined.  If set to True, makes obvious\n"
//          "the increase in weight strength when a radius is decreased, but obscures\n"
//          "the differences between the connections of a given unit to adjacent units.\n"
//          "Only important for a connection type whose radius changes over time.");
//  
//  PARAM_A(blackboard,"ppm_weight_scale_max_count",True,.add_lower_bound(False).add_upper_bound(True),
//          "When plotting weights on a scale relative to the number of connections\n"
//          "(ppm_weight_scale_type == Count or Inhib), whether to base the scale on\n"
//          "the maximum number of connections of the given type possible for any\n"
//          "neuron, or else to use the number possible for this particular neuron.\n"
//          "If set to True, makes obvious any differences in weight values from a\n"
//          "given unit to adjacent units, while obscuring the different absolute\n"
//          "weight values between units in the center and those near the border.\n"
//          "Only important for units near the border.");
  
  PARAM_A(blackboard,"ppm_weight_scale_type",int(WtScale::PeakRelative),.add_lower_bound(0).add_upper_bound(int(WtScale::Relative)),
          "Type of scaling to use for weight plots.  Possible settings (starting with\n"
          "PPM_WtScale_):\n\n"
          
          "  Fixed\n"
          "  Inhib\n"
          "  Count\n"
          "  Active\n"
          "  PeakRelative\n"
          "  Relative\n\n"
          
          "The first type uses a fixed scale for each weight type.  This makes it simple\n"
          "to compare different plots, since they will be on the same scale, but often\n"
          "individual plots will fail to show detail in the differences between\n"
          "adjacent units' weight values.  The last type has the opposite virtues and\n"
          "faults: each individual plot shows the maximum possible detail, but the\n"
          "absolute values of the weights are impossible to determine.  Those types in\n"
          "between reflect a different setting of this tradeoff between highlighting\n"
          "differences in a single plot, versus being able to compare plots and\n"
          "determine absolute weight levels.\n\n"
          
          "When using any of these types besides PPM_WtScale_Fixed, be sure to keep in\n"
          "mind that the absolute weight values depend upon the number of connections of\n"
          "that type active for that neuron, which in turn depends upon the connection\n"
          "radius, whether connections are square or circular, how close the neuron is\n"
          "to the border, and the connection death level.  See the parameters\n"
          "ppm_weight_scale_init_count and ppm_weight_scale_max_count to change\n"
          "how the scaling depends on the connection counts.\n\n"

          "The effective values of cortical weights also depend upon the cortical weight\n"
          "scaling factors gamma_exc and gamma_inh; none of the weight plots currently\n"
          "take these parameters' values into account.");
}



cmdstat NeuralRegionMap::color_param_setfn2(const string&, Typeless& existing, const Typeless& requested)
{
  existing.set(requested);
  const CmdParamStringParser p(blackboard);
  blackboard.lookup("ppm_bg_R").update_default_value(p);
  blackboard.lookup("ppm_bg_G").update_default_value(p);
  blackboard.lookup("ppm_bg_B").update_default_value(p);
  blackboard.lookup("ppm_line_R").update_default_value(p);
  blackboard.lookup("ppm_line_G").update_default_value(p);
  blackboard.lookup("ppm_line_B").update_default_value(p);
  
  return CMD_NO_ERROR;
}

---