[Boost-commit] svn:boost r4522

From: jakevoytko_at_[hidden]
Date: 2007-06-10 22:48:57

Author: jakevoytko
Date: 2007-06-10 22:48:56 EDT (Sun, 10 Jun 2007)
New Revision: 4522
URL: http://svn.boost.org/trac/boost/changeset/4522

Log:
Supports an internal document structure for svg_plots, and support for rgb colors and svg constants. Cleaned up some comments.

Text files modified: 
   sandbox/SOC/2007/visualization/boost/svg_plot/svg.hpp                  |    69 +++++----                               
   sandbox/SOC/2007/visualization/boost/svg_plot/svg_instruction.hpp      |     9 +                                       
   sandbox/SOC/2007/visualization/boost/svg_plot/svg_plot.hpp             |   286 +++++++++++++++++++++++---------------- 
   sandbox/SOC/2007/visualization/boost/svg_plot/svg_plot_instruction.hpp |    59 +++++--                                 
   sandbox/SOC/2007/visualization/boost/svg_plot/svg_style.hpp            |   283 ++++++++++++++++++++++++++++++++++++++  
   sandbox/SOC/2007/visualization/boost/svg_plot/svg_tag.hpp              |    91 ++++++-----                             
   6 files changed, 576 insertions(+), 221 deletions(-)

Modified: sandbox/SOC/2007/visualization/boost/svg_plot/svg.hpp
==============================================================================
--- sandbox/SOC/2007/visualization/boost/svg_plot/svg.hpp	(original)
+++ sandbox/SOC/2007/visualization/boost/svg_plot/svg.hpp	2007-06-10 22:48:56 EDT (Sun, 10 Jun 2007)
@@ -10,7 +10,6 @@
 #ifndef _SVG_HPP
 #define _SVG_HPP
 
-
 #include <vector>
 #include <ostream>
 #include <sstream>
@@ -27,8 +26,6 @@
 class svg
 {
 private:
-    g_element document;
-
     std::ostream *s_out;
     
     void _write_header();
@@ -42,15 +39,23 @@
 protected:
     unsigned int x_size;
     unsigned int y_size;
-    void _size(unsigned int, unsigned int);
     
+    g_element document;
+
+    void _size(unsigned int, unsigned int);
+
     void _write();
 
     void _point(double, double);
+    void _point(double, double, g_element&);
+    
     void _line(double, double, double, double);
+    void _line(double, double, double, double, g_element&); 
+    
     void _text(double, double, std::string);
     void _line_color(svg_color);
 
+
 public:
     svg(const std::string&);
     
@@ -84,7 +89,8 @@
     delete s_out;
 }
 
-//specify a new stream after the copy
+//I still need to put more thought into whether I want this class
+//copyable or not
 svg::svg(const svg& rhs)
 {
     x_size = rhs.x_size;
@@ -97,11 +103,8 @@
 
 // -----------------------------------------------------------------
 // Processes the svg_instructions
-// This allows the user to easily enter information:
-//
-// my_image<<color(RED)<<line(x1,y1,x2,y2)<<write(); 
-// 
-// is the eventual goal for the interface to the svg object 
+// This allows the user to easily enter information than ordinary
+// method calls, and is more clear that the method supports chaining
 // -----------------------------------------------------------------
 svg& svg::operator<<(const svg_instruction& rhs)
 {
@@ -115,8 +118,9 @@
 }
 
 // -----------------------------------------------------------------
-// Stream operator to eventually stick data together in a stream-
-// like interface
+// Chained stream operators. Each operator overload below will
+// represent a different instruction type, after I rewrite svg's
+// instructions to be more generic.
 // -----------------------------------------------------------------
 svg& svg::operator<<(const svg_point &rhs)
 {
@@ -126,7 +130,7 @@
         _size((unsigned int)rhs.x, (unsigned int)rhs.y);
         break;
     case SVG_POINT:
-        _point(rhs.x, rhs.y);
+        _point(rhs.x, rhs.y, document);
     }
 
     return *this;
@@ -156,7 +160,6 @@
 // -----------------------------------------------------------------
 // Internal function to write the data to a specified stream
 // TODO: allow other streams than a file stream
-// TODO: Make a traversal of the new document structure
 // -----------------------------------------------------------------
 void svg::_write()
 {
@@ -183,14 +186,14 @@
     //Write all visual elements
     for(size_t i=0; i<document.size(); ++i)
     {
-        *s_out<<document[(unsigned int)i].to_string()<<std::endl;
+        document[ (unsigned int)i ].write(*s_out);
     }
 
     //end g tag
 }
 
 // -----------------------------------------------------------------
-// This prints the svg header into the document
+// This prints the svg 1.1 header into the document
 // -----------------------------------------------------------------
 void svg::_write_header()
 {
@@ -213,8 +216,15 @@
 // Writes the information about points to the document
 // Since a point is not visible, we are actually drawing small
 // circles
-// TODO: allow other unit identifiers
+// TODO: allow other unit identifiers, shapes
 // -----------------------------------------------------------------
+
+// this overload has a pointer to a node in the document tree
+void svg::_point(double x, double y, g_element& location)
+{
+    location.children.push_back(new point_element(x, y));
+}
+
 void svg::_point(double x, double y)
 {
     document.children.push_back(new point_element(x, y));
@@ -222,7 +232,6 @@
 
 // -----------------------------------------------------------------
 // Writes the information about lines to the document
-// TODO: allow other unit identifiers
 // TODO: Allow other line thicknesses
 // TODO: Allow other line colors
 // -----------------------------------------------------------------
@@ -231,8 +240,14 @@
     document.children.push_back(new line_element(x1, y1, x2, y2));
 }
 
+void svg::_line(double x1, double y1, double x2, double y2, 
+                g_element& location)
+{
+    location.children.push_back(new line_element(x1, y1, x2, y2));
+}
+
 // -----------------------------------------------------------------
-// Writes the information about lines to the document
+// Writes the information about text to the document
 // TODO: allow different fonts and font sizes
 // -----------------------------------------------------------------
 void svg::_text(double x, double y, std::string text)
@@ -241,23 +256,11 @@
 }
 
 // -----------------------------------------------------------------
-// TODO: Add all of the colors that are supported by the SVG format
-// TODO: Update to account for the tree structure of the document now
+// Hopefully this one will be filld out next week
 // -----------------------------------------------------------------
 void svg::_line_color(svg_color col)
 {
-    switch(col)
-    {
-    case BLACK:
-//        document[SVG_G_STROKE] = "stroke = \"black\"";
-        break;
-    case GRAY:
-//        document[SVG_G_STROKE] = "stroke = \"gray\"";
-        break;
-    case RED:
-//        document[SVG_G_STROKE] = "stroke = \"red\"";
-        break;
-    }
+
 }
 
 

Modified: sandbox/SOC/2007/visualization/boost/svg_plot/svg_instruction.hpp
==============================================================================
--- sandbox/SOC/2007/visualization/boost/svg_plot/svg_instruction.hpp	(original)
+++ sandbox/SOC/2007/visualization/boost/svg_plot/svg_instruction.hpp	2007-06-10 22:48:56 EDT (Sun, 10 Jun 2007)
@@ -13,6 +13,14 @@
 namespace boost {
 namespace svg {
 
+#include "svg_style.hpp"
+
+// -----------------------------------------------------------------
+// IMPORTANT: the contents of this file will likely be completely
+// rewritten when I redo the public interface for svg::svg. I'm
+// focusing on the interface for svg::svg_plot currently
+// -----------------------------------------------------------------
+
 enum instruction_type{SVG_POINT, SVG_WRITE, SVG_SIZE};
 
 // -----------------------------------------------------------------
@@ -65,7 +73,6 @@
 struct svg_stroke_color
 {
     svg_color col;
-
     svg_stroke_color(svg_color _c):col(_c)
     {
 

Modified: sandbox/SOC/2007/visualization/boost/svg_plot/svg_plot.hpp
==============================================================================
--- sandbox/SOC/2007/visualization/boost/svg_plot/svg_plot.hpp	(original)
+++ sandbox/SOC/2007/visualization/boost/svg_plot/svg_plot.hpp	2007-06-10 22:48:56 EDT (Sun, 10 Jun 2007)
@@ -10,7 +10,6 @@
 #ifndef _SVG_PLOT_HPP
 #define _SVG_PLOT_HPP
 
-
 #include <vector>
 #include <ostream>
 #include <sstream>
@@ -23,13 +22,50 @@
 namespace boost {
 namespace svg {
 
+// -----------------------------------------------------------------
+// The following enums define the tree for the document. The reason
+// that they are defined here is so that I can easily refer to them
+// when I'm building data. It's easier to refer to:
+//      document[SVG_PLOT_BACKGROUND].color()
+//
+// than it is to do it any other way I can think of.
+// -----------------------------------------------------------------
+#define SVG_PLOT_DOC_CHILDREN 3
+
+enum svg_plot_doc_structure{SVG_PLOT_BACKGROUND, SVG_PLOT_LEGEND,
+    SVG_PLOT_PLOT};
+
+// -----------------------------------------------------------------
+// The following enums define the children for the legend. This will be
+// incomplete, as the actual definition of the legend is fuzzy.
+// -----------------------------------------------------------------
+
+#define SVG_PLOT_DOC_LEGEND_CHILDREN 3
+
+enum svg_plot_doc_legend_structure{SVG_PLOT_LEGEND_BACKGROUND,
+    SVG_PLOT_LEGEND_POINTS, SVG_PLOT_LEGEND_TEXT};
+
+// -----------------------------------------------------------------
+// The following enums define the tree for the plot itself.
+// -----------------------------------------------------------------
+
+#define SVG_PLOT_DOC_PLOT_CHILDREN 5
+
+enum svg_plot_doc_plot_structure{SVG_PLOT_PLOT_BACKGROUND, SVG_PLOT_PLOT_AXIS, 
+    SVG_PLOT_PLOT_LABELS, SVG_PLOT_PLOT_LINES, SVG_PLOT_PLOT_POINTS};
+
+
+
 class svg_plot: public svg
 {
 private:
     double transform_matrix[3][3];
-    double plot_start, plot_interval;
 
-    double x_min, x_max, y_min, y_max;
+    double x_min, x_max;
+
+    //Still keep track of this for when we have a view window
+    //for the graph
+    double y_window_min, y_window_max; 
     
     //Don't let the user use this without specifying a stream.
     //I can't think of a reasonable default, and I don't think
@@ -37,14 +73,15 @@
     svg_plot();
 
     void _x_scale(double, double);
-    void _y_scale(double, double);
     void _plot_image_size(unsigned int, unsigned int);
-    void _set_start(double);
-    void _set_interval(double);
+
     void _plot_range(std::vector<double>::iterator,
-                std::vector<double>::iterator);
-    
-    void _transform_point(double &x, double &y);
+        std::vector<double>::iterator);
+    void _plot_range(std::vector<double>::iterator,
+        std::vector<double>::iterator,
+        svg_color);
+
+    void _transform_point(double &x);
     void _draw_axis();
     void _line_color(const svg_color&);
 
@@ -55,6 +92,7 @@
     svg_plot& operator<<(const plot_single_val&);
     svg_plot& operator<<(const plot_two_vals&);
     svg_plot& operator<<(const plot_draw_range&);
+    svg_plot& operator<<(const plot_draw_col_range&);
     svg_plot& operator<<(const plot_command&);
     svg_plot& operator<<(const plot_color&);
 };
@@ -65,6 +103,9 @@
 //
 // This performs work for default values so that if the user starts
 // adding data right away, we won't get abnormal results
+//
+// Note: All of the points are going to be on the same line, so
+// there is no sense calculating any aspect of the y value
 // -----------------------------------------------------------------
 svg_plot::svg_plot(const std::string& file): svg(file)
 {
@@ -76,22 +117,39 @@
         }
     }
     
+    //to determine: reasonable default values
     _size(100, 100);
+    
+    y_window_min = 0;
+    y_window_max = 100;
 
-    x_min = y_min = 0;
-    x_max = y_max = 10;
+    x_min = -10;
+    x_max = 10;
 
     transform_matrix[0][0] = transform_matrix[2][2] = transform_matrix[1][1] = 1;
 
     transform_matrix[0][2] = x_size * (-x_min / (x_min - x_max));
-    transform_matrix[1][2] = y_size - y_size*(-y_min / (y_min - y_max));
 
-    //to determine: reasonable default values
+    //build the document tree
+    for(int i=0; i<SVG_PLOT_DOC_CHILDREN; ++i)
+    {
+        document.children.push_back(new g_element());
+    }
+
+    for(int i=0; i<SVG_PLOT_DOC_PLOT_CHILDREN; ++i)
+    {
+        (static_cast<g_element*>
+            (&(document.children[SVG_PLOT_PLOT])))
+                ->children.push_back(new g_element());
+    }
     
-    plot_interval = 1;
-    plot_start = 1;
 }
 
+// -----------------------------------------------------------------
+// The chained stream operators. Each overload below deals with a
+// different instruction type by cases.
+// -----------------------------------------------------------------
+
 svg_plot& svg_plot::operator<<(const plot_two_vals& rhs)
 {
     switch(rhs.i_type)
@@ -99,10 +157,6 @@
     case PLOT_SCALE_X:
         _x_scale(rhs.x1, rhs.x2);
         break;
-
-    case PLOT_SCALE_Y:
-        _y_scale(rhs.x1, rhs.x2);
-        break;
     
     case PLOT_SIZE:
         _plot_image_size((unsigned int)rhs.x1, (unsigned int)rhs.x2);
@@ -114,16 +168,12 @@
 
 svg_plot& svg_plot::operator <<(const plot_single_val& rhs)
 {
-    switch(rhs.i_type)
+/*    switch(rhs.i_type)
     {
-    case PLOT_INTERVAL:
-        _set_interval(rhs.x);
-        break;
-
-    case PLOT_START:
-        _set_start(rhs.x);
+    default:
         break;
     }
+*/
     return (svg_plot&)*this;
 }
 
@@ -139,6 +189,12 @@
     return (svg_plot&)*this;
 }
 
+svg_plot& svg_plot::operator<<(const plot_draw_col_range& rhs)
+{
+    _plot_range(rhs.begin, rhs.end, rhs.fill_color);
+    return (svg_plot&)*this;
+}
+
 svg_plot& svg_plot::operator<<(const plot_color& rhs)
 {
     switch(rhs.i_type)
@@ -151,6 +207,9 @@
     return (svg_plot&)*this;
 }
 
+// -----------------------------------------------------------------
+// Set the scale for x values
+// -----------------------------------------------------------------
 void svg_plot::_x_scale(double x1, double x2)
 {
     x_min = x1;
@@ -165,103 +224,80 @@
     transform_matrix[0][2] = x_size*(-x1 / (x2 - x1));
 }
 
-void svg_plot::_y_scale(double y1, double y2)
-{
-    y_min = y1;
-    y_max = y2;
-
-    if(y2 <= y1)
-        throw "Illegal Argument: Y scale: y2 < y1";
-
-    transform_matrix[1][1] = -1. * y_size / (y2-y1);
-    transform_matrix[1][2] = y_size - y_size * (-y1 / (y2 - y1) );
-}
-
+// -----------------------------------------------------------------
+// set the size of the svg image produced
+// -----------------------------------------------------------------
 void svg_plot::_plot_image_size(unsigned int x, unsigned int y)
 {
     _size(x, y);
     
+    y_window_max = y;
+
     transform_matrix[0][2] = x_size * (-x_min / (x_min - x_max) );
-    transform_matrix[1][2] = y_size - y_size * (-y_min / (y_min - y_max));
 }
 
 // -----------------------------------------------------------------
-// The user needs to set the start value in order for the first
-// point of the plot to render in the right place
+// Actually draw data to the plot. Default color information
 // -----------------------------------------------------------------
-void svg_plot::_set_start(double x)
+void svg_plot::_plot_range(std::vector<double>::iterator begin,
+                            std::vector<double>::iterator end)
 {
-    plot_start = x;
+    double x;
+
+    double i=0;
+
+    double y_point = (y_window_min + y_window_max) / 2.;
+    
+    for(std::vector<double>::iterator b = begin; b!=end; ++b)
+    {
+        x = *b;
+        _transform_point(x);
+        _point(x, y_point, 
+            document.g_tag(SVG_PLOT_PLOT).g_tag(SVG_PLOT_PLOT_POINTS));
+    }
 }
 
 // -----------------------------------------------------------------
-// The user needs to set the interval to make each subsequent
-// node of the plot render in the right place
+// Actually draw data to the plot. Fill color information provided
 // -----------------------------------------------------------------
-void svg_plot::_set_interval(double x)
-{
-    plot_interval = x;
-}
-
 void svg_plot::_plot_range(std::vector<double>::iterator begin,
-                            std::vector<double>::iterator end)
+                            std::vector<double>::iterator end,
+                            svg_color _col)
 {
-    double x, y, x2, y2;
+    double x;
 
     double i=0;
 
-    if(begin+1 == end)
-    {
-        x = plot_start;
-        y = *begin;
+    double y_point = (y_window_min + y_window_max) / 2.;
 
-        _transform_point(x, y);
+    g_element* g_ptr = &(document.g_tag(SVG_PLOT_PLOT).
+        g_tag(SVG_PLOT_PLOT_POINTS));
 
-        _point(x, y);
-    }
-    else
-    {
-        for(std::vector<double>::iterator b = begin; 
-            (b + 1) != end; ++b)
-        {
-            x = plot_start + i;
-            y = *b;
-        
-            x2 = plot_start + (i + 1);
-            y2 = *(b + 1);
+    g_ptr->children.push_back(new g_element);
 
-            _transform_point(x, y);
-            _transform_point(x2, y2);
+    // this sets the current <g> element to the one that will contain
+    // the data that is being pushed back.
+    g_ptr = &(g_ptr->g_tag((int)(g_ptr->size())-1));
 
-            _line(x, y, x2, y2);
+    g_ptr->set_fill_color(_col);
 
-            i += plot_interval;
-        }
-    
-        i=0;
-
-        for(std::vector<double>::iterator b = begin; b!=end; ++b)
-        {
-            x = plot_start + i;
-            y = *b;
-
-            _transform_point(x, y);
-            _point(x, y);
-            i += plot_interval;
-        }
+    for(std::vector<double>::iterator b = begin; b!=end; ++b)
+    {
+        x = *b;
+        _transform_point(x);
+        _point(x, y_point, 
+            *g_ptr);
     }
 }
-
 // -----------------------------------------------------------------
-// This transforms a Cartesian point into a svg point. We don't
-// use the svg coordinate transform because sizing is a harder
+// This transforms a 1-D Cartesian point into a svg point. We don't
+// use the svg-defined coordinate transform because sizing is a harder
 // problem in the svg coordinate transforms, and text would be
 // flipped if were were to mimic the Cartesian system
 // -----------------------------------------------------------------
-void svg_plot::_transform_point(double &x, double &y)
+void svg_plot::_transform_point(double &x)
 {
     x = transform_matrix[0][0] * x + transform_matrix[0][2];
-    y = transform_matrix[1][1] * y + transform_matrix[1][2];
 }
 
 
@@ -270,57 +306,69 @@
 // -----------------------------------------------------------------
 void svg_plot::_draw_axis()
 {
-    //two major axes
-    double x1, y1, x2, y2;
+    // one major axis. We just need to draw a verticle line through
+    // the origin for now. We will make that an option later.
+
+    double x1, x2, y1, y2;
     
-    x1 = x2 = 0;
-    y1 = y_min;
-    y2 = y_max;
+    x1 = x_min;
+    x2 = x_max;
+
+    _transform_point(x2);
+    _transform_point(x1);
+
+    double y_mean = (y_window_min + y_window_max)/2.;
+    double x_mean = (x1 + x2)/2.;
 
-    _transform_point(x1,y1);
-    _transform_point(x2,y2);
+    _line(x1, y_mean, x2, y_mean, 
+        document.g_tag(SVG_PLOT_PLOT).g_tag(SVG_PLOT_PLOT_AXIS));
 
-    _line(x1, y1, x2, y2);
+    //origin
+    _line(x_mean, y_window_min, x_mean, y_window_max, 
+        document.g_tag(SVG_PLOT_PLOT).g_tag(SVG_PLOT_PLOT_AXIS));
 
     y1 = y2 = 0;
     x1 = x_min;
     x2 = x_max;
 
-    _transform_point(x1,y1);
-    _transform_point(x2,y2);
-
-    _line(x1, y1, x2, y2);
-
-    for(double i = x_min; i <= x_max; i += plot_interval)
+    for(double i = 0; i <= x_max; i += 1)
     {
-        y1 = .2;
-        y2 = -.2;
+        y1 = y_mean+5;
+        y2 = y_mean-5;
     
-        x1=x2=i;
+        x1=i;
 
-        _transform_point(x1, y1);
-        _transform_point(x2, y2);
+        _transform_point(x1);
+        _transform_point(x2);
 
-        _line(x1, y1, x2, y2);
+        _line(x1, y1, x1, y2, 
+            document.g_tag(SVG_PLOT_PLOT).g_tag(SVG_PLOT_PLOT_AXIS));
     }
 
-    for(double i = y_min; i <= y_max; i += plot_interval)
+    for(double i = 0; i >= x_min; i -= 1)
     {
-        x1 = .2;
-        x2 = -.2;
+        y1 = y_mean+5;
+        y2 = y_mean-5;
     
-        y1=y2=i;
+        x1=i;
 
-        _transform_point(x1, y1);
-        _transform_point(x2, y2);
+        _transform_point(x1);
 
-        _line(x1, y1, x2, y2);
+        _line(x1, y1, x1, y2,
+            document.g_tag(SVG_PLOT_PLOT).g_tag(SVG_PLOT_PLOT_AXIS));
     }
 }
 
+// -----------------------------------------------------------------
+// Set the line color. This currently gets overwritten by the
+// default for <g> in _plot_range, so this will be fixed, probably
+// by removing the default for <g> in the constructor (ran out of
+// time this week)
+// -----------------------------------------------------------------
 void svg_plot::_line_color(const svg_color& _col)
 {
-    
+    document.g_tag(SVG_PLOT_PLOT).g_tag(SVG_PLOT_PLOT_AXIS)
+        .set_stroke_color(_col);
 }
 
 }

Modified: sandbox/SOC/2007/visualization/boost/svg_plot/svg_plot_instruction.hpp
==============================================================================
--- sandbox/SOC/2007/visualization/boost/svg_plot/svg_plot_instruction.hpp	(original)
+++ sandbox/SOC/2007/visualization/boost/svg_plot/svg_plot_instruction.hpp	2007-06-10 22:48:56 EDT (Sun, 10 Jun 2007)
@@ -16,7 +16,10 @@
 namespace boost {
 namespace svg {
 
-enum plot_inst_type{PLOT_NONE, PLOT_SCALE_X, PLOT_SCALE_Y, PLOT_START, 
+// -----------------------------------------------------------------
+// This allows us to process operations by case in switch statements
+// -----------------------------------------------------------------
+enum plot_inst_type{PLOT_NONE, PLOT_SCALE_X, PLOT_START, 
                 PLOT_SIZE, PLOT_INTERVAL, PLOT_DRAW_AXIS, PLOT_LINE_COLOR};
 
 // -----------------------------------------------------------------
@@ -66,7 +69,7 @@
 };
 
 // -----------------------------------------------------------------
-// plot_scale is to handle commands that take two arguments
+// plot_scale is to handle commands that take two double arguments
 // -----------------------------------------------------------------
 struct plot_two_vals: public plot_instruction
 {
@@ -96,6 +99,9 @@
     }
 };
 
+// -----------------------------------------------------------------
+// For arguments of a color nature
+// -----------------------------------------------------------------
 struct plot_color: public plot_instruction
 {
     svg_color col;
@@ -107,9 +113,6 @@
     }
 };
 
-// -----------------------------------------------------------------
-// This is the instruction that deals with drawing ranges
-// -----------------------------------------------------------------
 struct plot_draw_range: public plot_instruction
 {
     std::vector<double>::iterator begin;
@@ -123,38 +126,49 @@
     }
 };
 
+// -----------------------------------------------------------------
+// fill_color defines the color of the points that are to be drawn
+// -----------------------------------------------------------------
+struct plot_draw_col_range: public plot_draw_range
+{
+    svg_color fill_color;
+
+    plot_draw_col_range(std::vector<double>::iterator _b,
+        std::vector<double>::iterator _e,
+        svg_color_constant _fill_color): 
+            fill_color(svg_color(_fill_color)), plot_draw_range(_b, _e)
+    {
+ 
+    }
+};
 
+// -----------------------------------------------------------------
+// The following functions return the values from the user
+// interface to values that the svg_plot class can understand
+// -----------------------------------------------------------------
 plot_two_vals x_scale(double x1, double x2)
 {
     return plot_two_vals(x1, x2, PLOT_SCALE_X);
 }
 
-plot_two_vals y_scale(double y1, double y2)
-{
-    return plot_two_vals(y1, y2, PLOT_SCALE_Y);
-}
-
 plot_two_vals image_size(int x, int y)
 {
     return plot_two_vals(x, y, PLOT_SIZE);
 }
 
-plot_single_val set_start(double x)
-{
-    return plot_single_val(x, PLOT_START);
-}
-
-plot_single_val set_interval(double x)
-{
-    return plot_single_val(x, PLOT_INTERVAL);
-}
-
 plot_draw_range plot_range(std::vector<double>::iterator begin,
                     std::vector<double>::iterator end)
 {
     return plot_draw_range(begin, end);
 }
 
+plot_draw_col_range plot_range(std::vector<double>::iterator begin,
+                    std::vector<double>::iterator end,
+                    svg_color_constant col)
+{
+    return plot_draw_col_range(begin, end, col);
+}
+
 plot_command draw_axis()
 {
     return plot_command(PLOT_DRAW_AXIS);
@@ -165,6 +179,11 @@
     return plot_color(c, PLOT_LINE_COLOR);
 }
 
+plot_color line_color(svg_color_constant c)
+{
+    return plot_color(constant_to_rgb(c), PLOT_LINE_COLOR);
+}
+
 }
 }
 

Modified: sandbox/SOC/2007/visualization/boost/svg_plot/svg_style.hpp
==============================================================================
--- sandbox/SOC/2007/visualization/boost/svg_plot/svg_style.hpp	(original)
+++ sandbox/SOC/2007/visualization/boost/svg_plot/svg_style.hpp	2007-06-10 22:48:56 EDT (Sun, 10 Jun 2007)
@@ -1,5 +1,4 @@
-// svg_tag.hpp
-
+// svg_style.hpp 
 // Copyright (C) Jacob Voytko 2007
 //
 // Distributed under the Boost Software License, Version 1.0.
@@ -10,17 +9,262 @@
 #ifndef _SVG_STYLE_HPP
 #define _SVG_STYLE_HPP
 
+#include <map>
+
 namespace boost {
 namespace svg {
 
 // -----------------------------------------------------------------
-// Deals with well-defined colors
+// Deals with colors that have special names. The reason that the
+// underscoring does not match the normal Boost format
+// is that these are the names that are specifically allowed by the
+// SVG standard
 // -----------------------------------------------------------------
-enum svg_color{BLACK, GRAY, RED};
+enum svg_color_constant
+{
+    aliceblue, antiquewhite, aqua, aquamarine, azure, beige, 
+    bisque, black, blanchedalmond, blue, blueviolet, brown, 
+    burlywood, cadetblue, chartreuse, chocolate, coral, 
+    cornflowerblue, cornsilk, crimson, cyan, darkblue, darkcyan, 
+    darkgoldenrod, darkgray, darkgreen, darkgrey, darkkhaki, 
+    darkmagenta, darkolivegreen, darkorange, darkorchid, darkred, 
+    darksalmon, darkseagreen, darkslateblue, darkslategray, 
+    darkslategrey, darkturquoise, darkviolet, deeppink, 
+    deepskyblue, dimgray, dimgrey, dodgerblue, firebrick, 
+    floralwhite, forestgreen, fuchsia, gainsboro, ghostwhite, gold, 
+    goldenrod, gray, grey, green, greenyellow, honeydew, hotpink, 
+    indianred, indigo, ivory, khaki, lavender, lavenderblush, 
+    lawngreen, lemonchiffon, lightblue, lightcoral, lightcyan, 
+    lightgoldenrodyellow, lightgray, lightgreen, lightgrey, 
+    lightpink, lightsalmon, lightseagreen, lightskyblue, 
+    lightslategray, lightslategrey, lightsteelblue, lightyellow, 
+    lime, limegreen, linen, magenta, maroon, mediumaquamarine, 
+    mediumblue, mediumorchid, mediumpurple, mediumseagreen, 
+    mediumslateblue, mediumspringgreen, mediumturquoise, 
+    mediumvioletred, midnightblue, mintcream, mistyrose, moccasin, 
+    navajowhite, navy, oldlace, olive, olivedrab, orange, 
+    orangered, orchid, palegoldenrod, palegreen, paleturquoise, 
+    palevioletred, papayawhip, peachpuff, peru, pink, plum, 
+    powderblue, purple, red, rosybrown, royalblue, saddlebrown, 
+    salmon, sandybrown, seagreen, seashell, sienna, silver, 
+    skyblue, slateblue, slategray, slategrey, snow, springgreen, 
+    steelblue, tan, teal, thistle, tomato, turquoise, violet, 
+    wheat, white, whitesmoke, yellow, yellowgreen
+};
+
 
+void constant_to_rgb(svg_color_constant _c, unsigned char &r, unsigned char &g, 
+            unsigned char &b);
 
 // -----------------------------------------------------------------
-// This is the style information for any <g> tag. 
+// svg_color is the struct that contains information about sRGB
+// colors.
+//
+// For the constructor: the svg standard specifies that numbers
+// outside the normal rgb range are to be accepted, but are rounded
+// to acceptable values.
+// -----------------------------------------------------------------
+struct svg_color
+{
+    unsigned char r, g, b;
+
+    svg_color(int _r, int _g, int _b)
+    {
+        _r = ( _r < 0 ) ? 0 : _r;
+        _g = ( _g < 0 ) ? 0 : _g;
+        _b = ( _b < 0 ) ? 0 : _b;
+
+        r = (unsigned char)(( _r > 255 ) ? 255 : _r);
+        g = (unsigned char)(( _g > 255 ) ? 255 : _g);
+        b = (unsigned char)(( _b > 255 ) ? 255 : _b);
+    }
+
+    svg_color(svg_color_constant _col)
+    {
+        constant_to_rgb(_col, r, g, b);
+    }
+
+    void write(std::ostream& rhs)
+    {
+        rhs << "rgb(" << (unsigned int)r << "," << (unsigned int) g << ","
+            << (unsigned int)b << ")" ;
+    }
+};
+
+// -----------------------------------------------------------------
+// To facilitate quick lookup of the RGB values of constants
+// -----------------------------------------------------------------
+svg_color color_array[] =
+{
+    svg_color(240, 248, 255), // aliceblue
+    svg_color(250, 235, 215), // antiquewhite
+    svg_color(0  , 255, 255), // aqua
+    svg_color(127, 255, 212), // aquamarine
+    svg_color(240, 255, 255), // azure
+    svg_color(245, 245, 220), // beige
+    svg_color(255, 228, 196), // bisque
+    svg_color(0  , 0  , 0  ), // black
+    svg_color(255, 235, 205), // blanchedalmond. Who thinks of these?
+    svg_color(0  , 0  , 255), // blue
+    svg_color(138, 43 , 226), // blueviolet
+    svg_color(165, 42 , 42 ), // brown
+    svg_color(222, 184, 135), // burlywood
+    svg_color(95 , 158, 160), // cadetblue
+    svg_color(127, 255, 0  ), // chartreuse
+    svg_color(210, 105, 30 ), // chocolate
+    svg_color(255, 127, 80 ), // coral
+    svg_color(100, 149, 237), // cornflowerblue
+    svg_color(255, 248, 220), // cornsilk
+    svg_color(220, 20 , 60 ), // crimson
+    svg_color(0  , 255, 255), // cyan
+    svg_color(0  , 0  , 139), // darkblue
+    svg_color(0  , 139, 139), // darkcyan
+    svg_color(184, 134, 11 ), // darkgoldenrod
+    svg_color(169, 169, 169), // darkgray
+    svg_color(0  , 100, 0  ), // darkgreen
+    svg_color(169, 169, 169), // darkgrey
+    svg_color(189, 183, 107), // darkkhaki
+    svg_color(139, 0  , 139), // darkmagenta
+    svg_color(85 , 107, 47 ), // darkolivegreen
+    svg_color(255, 140, 0  ), // darkorange
+    svg_color(153, 50 , 204), // darkorchid
+    svg_color(139, 0  , 0  ), // darkred
+    svg_color(233, 150, 122), // darksalmon
+    svg_color(143, 188, 143), // darkseagreen
+    svg_color(72 , 61 , 139), // darkslateblue
+    svg_color(47 , 79 , 79 ), // darkslategray
+    svg_color(47 , 79 , 79 ), // darkslategrey
+    svg_color(0  , 206, 209), // darkturquoise
+    svg_color(148, 0  , 211), // darkviolet
+    svg_color(255, 20 , 147), // deeppink
+    svg_color(0  , 191, 255), // deepskyblue
+    svg_color(105, 105, 105), // dimgray
+    svg_color(105, 105, 105), // dimgrey
+    svg_color(30 , 144, 255), // dodgerblue
+    svg_color(178, 34 , 34 ), // firebrick
+    svg_color(255, 250, 240), // floralwhite
+    svg_color(34 , 139, 34 ), // forestgreen
+    svg_color(255, 0  , 255), // fuchsia
+    svg_color(220, 220, 220), // gainsboro
+    svg_color(248, 248, 255), // ghostwhite
+    svg_color(255, 215, 0  ), // gold
+    svg_color(218, 165, 32 ), // goldenrod
+    svg_color(128, 128, 128), // gray
+    svg_color(128, 128, 128), // grey
+    svg_color(0  , 128, 0  ), // green
+    svg_color(173, 255, 47 ), // greenyellow
+    svg_color(240, 255, 240), // honeydew
+    svg_color(255, 105, 180), // hotpink
+    svg_color(205, 92 , 92 ), // indianred
+    svg_color(75 , 0  , 130), // indigo
+    svg_color(255, 255, 240), // ivory
+    svg_color(240, 230, 140), // khaki
+    svg_color(230, 230, 250), // lavender
+    svg_color(255, 240, 245), // lavenderblush
+    svg_color(124, 252, 0  ), // lawngreen
+    svg_color(255, 250, 205), // lemonchiffon
+    svg_color(173, 216, 230), // lightblue
+    svg_color(240, 128, 128), // lightcoral
+    svg_color(224, 255, 255), // lightcyan
+    svg_color(250, 250, 210), // lightgoldenrodyellow
+    svg_color(211, 211, 211), // lightgray
+    svg_color(144, 238, 144), // lightgreen
+    svg_color(211, 211, 211), // lightgrey
+    svg_color(255, 182, 193), // lightpink
+    svg_color(255, 160, 122), // lightsalmon
+    svg_color(32 , 178, 170), // lightseagreen
+    svg_color(135, 206, 250), // lightskyblue
+    svg_color(119, 136, 153), // lightslategray
+    svg_color(119, 136, 153), // lightslategrey
+    svg_color(176, 196, 222), // lightsteelblue
+    svg_color(255, 255, 224), // lightyellow
+    svg_color(0  , 255, 0  ), // lime
+    svg_color(50 , 205, 50 ), // limegreen
+    svg_color(250, 240, 230), // linen
+    svg_color(255, 0  , 255), // magenta
+    svg_color(128, 0  , 0  ), // maroon
+    svg_color(102, 205, 170), // mediumaquamarine
+    svg_color(0  , 0  , 205), // mediumblue
+    svg_color(186, 85 , 211), // mediumorchid
+    svg_color(147, 112, 219), // mediumpurple
+    svg_color(60 , 179, 113), // mediumseagreen
+    svg_color(123, 104, 238), // mediumslateblue
+    svg_color(0  , 250, 154), // mediumspringgreen
+    svg_color(72 , 209, 204), // mediumturquoise
+    svg_color(199, 21 , 133), // mediumvioletred
+    svg_color(25 , 25 , 112), // midnightblue
+    svg_color(245, 255, 250), // mintcream
+    svg_color(255, 228, 225), // mistyrose
+    svg_color(255, 228, 181), // moccasin
+    svg_color(255, 222, 173), // navajowhite
+    svg_color(0  , 0  , 128), // navy
+    svg_color(253, 245, 230), // oldlace
+    svg_color(128, 128, 0  ), // olive
+    svg_color(107, 142, 35 ), // olivedrab
+    svg_color(255, 165, 0  ), // orange
+    svg_color(255, 69 , 0  ), // orangered
+    svg_color(218, 122, 214), // orchid
+    svg_color(238, 232, 170), // palegoldenrod
+    svg_color(152, 251, 152), // palegreen
+    svg_color(175, 238, 238), // paleturquose
+    svg_color(219, 112, 147), // palevioletred
+    svg_color(255, 239, 213), // papayawhip
+    svg_color(255, 218, 185), // peachpuff
+    svg_color(205, 133, 63 ), // peru
+    svg_color(255, 192, 203), // pink
+    svg_color(221, 160, 221), // plum
+    svg_color(176, 224, 230), // powderblue
+    svg_color(128, 0  , 128), // purple
+    svg_color(255, 0  , 0  ), // red
+    svg_color(188, 143, 143), // rosybrown
+    svg_color(65 , 105, 225), // royalblue
+    svg_color(139, 69 , 19 ), // saddlebrown
+    svg_color(250, 128, 114), // salmon
+    svg_color(244, 164, 96 ), // sandybrown
+    svg_color(46 , 139, 87 ), // seagreen
+    svg_color(255, 245, 238), // seashell
+    svg_color(160, 82 , 45 ), // sienna
+    svg_color(192, 192, 192), // silver
+    svg_color(135, 206, 235), // skyblue
+    svg_color(106, 90 , 205), // slateblue
+    svg_color(112, 128, 144), // slategray
+    svg_color(112, 128, 144), // slategrey
+    svg_color(255, 250, 250), // snow
+    svg_color(0  , 255, 127), // springgreen
+    svg_color(70 , 130, 180), // steelblue
+    svg_color(210, 180, 140), // tan
+    svg_color(0  , 128, 128), // teal
+    svg_color(216, 191, 216), // thistle
+    svg_color(255, 99 , 71 ), // tomato
+    svg_color(64 , 224, 208), // turquoise
+    svg_color(238, 130, 238), // violet
+    svg_color(245, 222, 179), // wheat
+    svg_color(255, 255, 255), // white
+    svg_color(245, 245, 245), // whitesmoke
+    svg_color(255, 255, 0  ), // yellow
+    svg_color(154, 205, 50 ), // yellowgreen
+};
+
+
+void constant_to_rgb(svg_color_constant _c, unsigned char &r, unsigned char &g, 
+            unsigned char &b)
+{
+    r = color_array[(unsigned int)_c].r;
+    g = color_array[(unsigned int)_c].g;
+    b = color_array[(unsigned int)_c].b;
+}
+
+svg_color constant_to_rgb(svg_color_constant _c)
+{
+    return svg_color(color_array[(unsigned int)_c].r
+        ,color_array[(unsigned int)_c].g
+        ,color_array[(unsigned int)_c].b);
+}
+
+// -----------------------------------------------------------------
+// This is the style information for any <g> tag. This will be
+// expanded to include more data from the SVG standard when the
+// time comes.
 // -----------------------------------------------------------------
 class svg_g_style
 {
@@ -33,17 +277,21 @@
     svg_g_style(const svg_color&, const svg_color&);
     void set_fill_color(const svg_color&);
     void set_stroke_color(const svg_color&);
+    void write(std::ostream&);
 };
 
+
 // -----------------------------------------------------------------
 // These are the defaults that I used in the prototype, and they
 // looked decent enough.
 // -----------------------------------------------------------------
-svg_g_style::svg_g_style():fill_color(svg_color(RED)), stroke_color(svg_color(BLACK))
+svg_g_style::svg_g_style():fill_color(svg_color(255, 0, 0)), 
+    stroke_color(svg_color(0, 0, 0))
 {
 
 }
 
+
 // -----------------------------------------------------------------
 // For changing the defaults for the colors
 // -----------------------------------------------------------------
@@ -53,7 +301,28 @@
 
 }
 
+void svg_g_style::write(std::ostream& rhs)
+{
+    rhs << "stroke=\"";
+    stroke_color.write(rhs);
+    rhs << "\" fill=\"";
+    fill_color.write(rhs);
+    rhs<<"\"";
+}
+
+void svg_g_style::set_stroke_color(const svg_color& rhs)
+{
+    stroke_color = rhs;
+}
+
+void svg_g_style::set_fill_color(const svg_color& rhs)
+{
+    fill_color = rhs;
+}
+
+
 }//svg
 }//boost
 
-#endif
\ No newline at end of file
+
+#endif

Modified: sandbox/SOC/2007/visualization/boost/svg_plot/svg_tag.hpp
==============================================================================
--- sandbox/SOC/2007/visualization/boost/svg_plot/svg_tag.hpp	(original)
+++ sandbox/SOC/2007/visualization/boost/svg_plot/svg_tag.hpp	2007-06-10 22:48:56 EDT (Sun, 10 Jun 2007)
@@ -13,6 +13,7 @@
 #include <sstream>
 #include <string>
 #include <boost/ptr_container/ptr_container.hpp>
+#include <boost/noncopyable.hpp>
 
 #include "svg_style.hpp"
 
@@ -29,32 +30,34 @@
 // -----------------------------------------------------------------
 // The base class for all leaf elements
 // -----------------------------------------------------------------
-
-class svg_element : boost::noncopyable
+    
+class svg_element
 {
 public:
-    virtual std::string to_string()=0;
+    virtual void write(std::ostream&) = 0;
 };
 
 // -----------------------------------------------------------------
 // The node element of our document tree
 // -----------------------------------------------------------------
 
-class g_element
+class g_element: public svg_element
 {
 private: 
-    svg_g_style styleInfo;
+    svg_g_style style_info;
 
 public:
-    //public allows me to skip dozens of add_point, add_line, etc methods
-    //or polymorphic checks. Also allows the root element of the node
-    //to act as a makeshift DOM
-    boost::ptr_vector<svg_element> children;    
+    boost::ptr_vector<svg_element> children;
     
     svg_element& operator[](unsigned int);
     size_t size();
     
-    void set_line_color(const svg_color&);
+    void set_stroke_color(const svg_color&);
+    void set_fill_color(const svg_color&);
+
+    void write(std::ostream&);
+
+    g_element& g_tag(int);
 };
 
 svg_element& g_element::operator[](unsigned int i)
@@ -67,11 +70,37 @@
     return children.size();
 }
 
-void set_line_color(const svg_color& rhs)
+void g_element::write(std::ostream& rhs)
+{
+    rhs << "<g ";
+    style_info.write(rhs);
+    rhs<< " >" << std::endl;
+    
+    for(unsigned int i=0; i<children.size(); ++i)
+    {
+        children[i].write(rhs);
+    }
+
+    rhs << "</g>" << std::endl;
+
+}
+
+g_element& g_element::g_tag(int i)
+{
+    return *(static_cast<g_element*>(&children[i]));
+}
+
+void g_element::set_stroke_color(const svg_color& _col)
 {
+    style_info.set_stroke_color(_col);
+}
 
+void g_element::set_fill_color(const svg_color& _col)
+{
+    style_info.set_fill_color(_col);
 }
 
+
 // -----------------------------------------------------------------
 // Represents a single point
 // -----------------------------------------------------------------
@@ -82,7 +111,7 @@
 
 public:
     point_element(double, double);
-    std::string to_string();
+    void write(std::ostream&);
 };
 
 point_element::point_element(double _x, double _y):x(_x), y(_y)
@@ -90,16 +119,10 @@
     
 }
 
-std::string point_element::to_string()
+void point_element::write(std::ostream& rhs)
 {
-    std::stringstream fmt;
-
-    fmt<<"<circle cx=\""<<x<<"\" cy=\""<<y<<"\" r=\"5\" fill=\"red\" />";
-    
-    std::string to_ret;
-    std::getline(fmt, to_ret);
+    rhs<<"<circle cx=\""<<x<<"\" cy=\""<<y<<"\" r=\"5\"/>";
 
-    return to_ret;
 }
 
 // -----------------------------------------------------------------
@@ -112,7 +135,7 @@
 
 public:
     line_element(double, double, double, double);
-    std::string to_string();
+    void write(std::ostream&);
 };
 
 line_element::line_element(double _x1, double _y1, double _x2,
@@ -122,17 +145,10 @@
     
 }
 
-std::string line_element::to_string()
+void line_element::write(std::ostream& rhs)
 {
-    std::stringstream fmt;
-
-    fmt<<"<line stroke=\"black\" x1=\""<<x1<<"\" y1=\""<<y1<<"\" x2=\""<<x2<<"\" y2=\""
+    rhs<<"<line x1=\""<<x1<<"\" y1=\""<<y1<<"\" x2=\""<<x2<<"\" y2=\""
         <<y2<<"\"/>";
-    
-    std::string to_ret;
-    std::getline(fmt, to_ret);
-
-    return to_ret;
 }
 
 // -----------------------------------------------------------------
@@ -146,7 +162,7 @@
 
 public:
     text_element(double, double, std::string);
-    std::string to_string();
+    void write(std::ostream&);
 };
 
 text_element::text_element(double _x, double _y, std::string _text)
@@ -155,20 +171,13 @@
     
 }
 
-std::string text_element::to_string()
+void text_element::write(std::ostream& rhs)
 {
-    std::stringstream fmt;
-    std::string to_write;
-
-    fmt<<"<text x=\""<<x<<"\""
+    rhs<<"<text x=\""<<x<<"\""
                 <<" y=\""<<y<<"\" "
-                <<" font-family=\"Veranda\" font-size=\"12\" fill=\"black\">"
+                <<" font-family=\"Veranda\" font-size=\"12\" stroke=\"black\">"
                 << text
                 <<" </text>";
-
-    getline(fmt, to_write);
-
-    return to_write;
 }