[Boost-commit] svn:boost r4342

From: jakevoytko_at_[hidden]
Date: 2007-05-28 20:19:42

Author: jakevoytko
Date: 2007-05-28 20:19:41 EDT (Mon, 28 May 2007)
New Revision: 4342
URL: http://svn.boost.org/trac/boost/changeset/4342

Log:
Prototype code with name change as suggested by Paul Bristow. Compiles with Visual Studio 2005.

Added:
   sandbox/SOC/2007/visualization/boost/svg_plot/svg.hpp
   sandbox/SOC/2007/visualization/boost/svg_plot/svg_instruction.hpp
   sandbox/SOC/2007/visualization/boost/svg_plot/svg_plot.hpp
   sandbox/SOC/2007/visualization/boost/svg_plot/svg_plot_instruction.hpp

Added: sandbox/SOC/2007/visualization/boost/svg_plot/svg.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2007/visualization/boost/svg_plot/svg.hpp	2007-05-28 20:19:41 EDT (Mon, 28 May 2007)
@@ -0,0 +1,321 @@
+// svg.hpp
+
+// Copyright (C) Jacob Voytko 2007
+//
+// Distributed under the Boost Software License, Version 1.0.
+// For more information, see http://www.boost.org
+
+// ----------------------------------------------------------------- 
+
+#ifndef _SVG_HPP
+#define _SVG_HPP
+
+
+#include <vector>
+#include <ostream>
+#include <sstream>
+#include <iostream>
+#include <fstream>
+
+#include "svg_instruction.hpp"
+
+namespace boost {
+namespace svg {
+
+/*The lines in the beginning of document store the xml document in 
+the following format:
+
+<?xml version=...
+<!Doctype svg...
+<svg width="...
+<g
+	Style line.. optional
+>
+
+*/
+
+enum {SVG_XML_HEADER, SVG_XML_DOCTYPE, SVG_OPEN, SVG_G_OPEN, SVG_G_STROKE,
+	  SVG_G_FILL, SVG_G_CLOSE};
+
+class svg
+{
+private:
+	std::vector<std::string> document;
+
+	std::ostream *s_out;
+	
+	void _write_header();
+
+	//Don't let people initialize this class
+	//without specifying the stream. I can't think
+	//of a reasonable default.
+	svg();
+
+protected:
+	unsigned int x_size;
+	unsigned int y_size;
+	void _check_size();
+	void _size(unsigned int, unsigned int);
+	
+	void _write();
+	void _point(double, double);
+	void _line(double, double, double, double);
+	void _text(double, double, std::string);
+	void _line_color(svg_color);
+
+public:
+	svg(const std::string&);
+	
+	virtual ~svg();
+	svg(const svg&);
+	svg& operator=(const svg&);
+
+	void operator<<(const svg_instruction&);
+
+	void operator<<(const svg_point&);
+
+	void operator<<(const svg_line&);
+	void operator<<(const svg_text&);
+
+	void operator<<(const svg_line_color&);
+
+	friend std::ostream& operator<<(std::ostream&, const svg&);
+};
+
+// -----------------------------------------------------------------
+// Constructors will be added so that the user can specify
+// a stream instead of a filename
+// -----------------------------------------------------------------
+svg::svg(const std::string& fname)
+			:s_out(new std::ofstream(fname.c_str())) 
+{ 
+	_write_header();
+}
+
+svg::~svg()
+{ 
+	delete s_out;
+}
+
+//specify a new stream after the copy
+svg::svg(const svg& rhs)
+{
+	x_size = rhs.x_size;
+	y_size = rhs.y_size;
+	document = rhs.document;
+
+}
+
+// -----------------------------------------------------------------
+// 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 
+// -----------------------------------------------------------------
+void svg::operator<<(const svg_instruction& rhs)
+{
+	switch(rhs.i_type)
+	{
+	case SVG_WRITE:
+		_check_size();
+		_write();
+		break;
+	}
+}
+
+// -----------------------------------------------------------------
+// Stream operator to eventually stick data together in a stream-
+// like interface
+// -----------------------------------------------------------------
+void svg::operator<<(const svg_point &rhs)
+{
+	switch(rhs.i_type)
+	{
+	case SVG_SIZE:
+		_size((unsigned int)rhs.x, (unsigned int)rhs.y);
+		break;
+	case SVG_POINT:
+		_point(rhs.x, rhs.y);
+	}
+}
+
+void svg::operator<<(const svg_line &rhs)
+{
+	_line(rhs.x1, rhs.y1, rhs.x2, rhs.y2);
+}
+
+void svg::operator<<(const svg_text &rhs)
+{
+	_text(rhs.x, rhs.y, rhs.text);
+}
+
+void svg::operator<<(const svg_line_color &rhs)
+{
+	_line_color(rhs.col);
+}
+
+// -----------------------------------------------------------------
+// Internal function to write the data to a specified stream
+// TODO: allow other streams than a file stream
+// -----------------------------------------------------------------
+void svg::_write()
+{
+	document.push_back("</g>");
+	document.push_back("</svg>");
+
+	std::copy(document.begin(), document.end(), 
+		std::ostream_iterator<std::string>(*s_out, "\n"));
+}
+
+// -----------------------------------------------------------------
+// This prints the svg header into the document
+// -----------------------------------------------------------------
+void svg::_write_header()
+{
+	document.push_back("<?xml version=\"1.0\" standalone=\"no\"?>");
+	document.push_back((std::string)"<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\" "+
+					   "\"http://www.w3.org/graphics/svg/1.1/dtd/svg11.dtd\">");
+}
+
+// -----------------------------------------------------------------
+// Writes the information about the size of the file to the document
+// TODO: allow other unit identifiers
+// -----------------------------------------------------------------
+void svg::_size(unsigned int x, unsigned int y)
+{
+	x_size = x;
+	y_size = y;
+
+	std::stringstream fmt;
+	std::string to_write;
+	
+	fmt<<"<svg width=\""<<x<<"\" height =\"" 
+					<<y<<"\" version=\"1.1\""
+					<<" xmlns=\"http://www.w3.org/2000/svg\">";
+	
+	std::getline(fmt, to_write);
+
+	//if nothing has been written to the document yet, append
+	if(document.size() == 2)
+	{
+		document.push_back(to_write);
+
+		document.push_back("<g ");
+		document.push_back("");
+		document.push_back("");
+		document.push_back(">");
+	}
+
+	//otherwise, we are changing existing information
+	else
+		document[2] = to_write;
+}
+
+// -----------------------------------------------------------------
+// This makes sure that the size of the svg image has been written
+// before we do any other kind of work building the image
+// -----------------------------------------------------------------
+void svg::_check_size()
+{
+	if(document.size() < 3)
+	{
+		std::string to_write = "<svg width=\"100\" height =\"100\" version=\"1.1\" xmlns=\"http://www.w3.org/2000/svg\">";
+
+		document.push_back(to_write);
+
+		document.push_back("<g ");
+
+		//optional style line
+		document.push_back("");
+		document.push_back("");
+		document.push_back(">");
+	}
+}
+
+// -----------------------------------------------------------------
+// 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
+// -----------------------------------------------------------------
+void svg::_point(double x, double y)
+{
+	std::stringstream fmt;
+	std::string to_write;
+	
+	fmt<<"<circle cx=\""<<x<<"\" cy =\"" 
+					<<y<<"\" r=\"5\" "
+					<<"fill=\"red\"/>";
+	
+	std::getline(fmt, to_write);
+
+	document.push_back(to_write);
+}
+
+// -----------------------------------------------------------------
+// Writes the information about lines to the document
+// TODO: allow other unit identifiers
+// TODO: Allow other line thicknesses
+// TODO: Allow other line colors
+// -----------------------------------------------------------------
+void svg::_line(double x1, double y1, double x2, double y2)
+{
+	std::stringstream fmt;
+	std::string to_write;
+	//<line x1="000" y1="000" x2="000" y2="000" stroke="black"/>	
+	fmt<< "<line x1=\""<<x1<<"\""
+					<<" y1 =\""<<y1<<"\" "
+					<<" x2 =\""<<x2<<"\" "
+					<<" y2 =\""<<y2<<"\"/>";
+
+	getline(fmt, to_write);
+
+	document.push_back(to_write);
+}
+
+// -----------------------------------------------------------------
+// Writes the information about lines to the document
+// TODO: allow different fonts and font sizes
+// -----------------------------------------------------------------
+void svg::_text(double x, double y, std::string text)
+{
+	std::stringstream fmt;
+	std::string to_write;
+
+	fmt<<"<text x=\""<<x<<"\""
+				<<" y=\""<<y<<"\" "
+				<<" font-family=\"Veranda\" font-size=\"12\" fill=\"black\">"
+				<< text
+				<<" </text>";
+
+	getline(fmt, to_write);
+
+	document.push_back(to_write);
+}
+
+// -----------------------------------------------------------------
+// TODO: Add all of the colors that are supported by the SVG format
+// -----------------------------------------------------------------
+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;
+	}
+}
+
+
+}
+}
+
+#endif

Added: sandbox/SOC/2007/visualization/boost/svg_plot/svg_instruction.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2007/visualization/boost/svg_plot/svg_instruction.hpp	2007-05-28 20:19:41 EDT (Mon, 28 May 2007)
@@ -0,0 +1,119 @@
+// svg_instruction.hpp
+
+// Copyright (C) Jacob Voytko 2007
+//
+// Distributed under the Boost Software License, Version 1.0.
+// For more information, see http://www.boost.org
+
+// ----------------------------------------------------------------- 
+
+#ifndef _SVG_INSTRUCTION_HPP
+#define _SVG_INSTRUCTION_HPP
+
+namespace boost {
+namespace svg {
+
+enum instruction_type{SVG_POINT, SVG_WRITE, SVG_SIZE};
+enum svg_color{BLACK, GRAY, RED};
+
+// -----------------------------------------------------------------
+// The svg_instruction struct is what we are using to pass the svg
+// class arguments through the << operator interface.
+// -----------------------------------------------------------------
+struct svg_instruction
+{
+	instruction_type i_type;
+
+	svg_instruction(instruction_type i):i_type(i)
+	{
+	}
+};
+
+struct svg_point
+{
+	double x, y;
+
+	instruction_type i_type;
+
+	svg_point(double _x, double _y, instruction_type _it): x(_x), y(_y), i_type(_it)
+	{
+
+	}
+};
+
+struct svg_line
+{
+	double x1, y1, x2, y2;
+
+	svg_line(double _x1, double _y1, double _x2, double _y2):
+				x1(_x1), x2(_x2), y1(_y1), y2(_y2)
+	{
+
+	}
+};
+
+struct svg_text
+{
+	double x, y;
+	std::string text;
+
+	svg_text(double _x, double _y, std::string _t):x(_x), y(_y), text(_t)
+	{
+
+	}
+};
+
+struct svg_line_color
+{
+	svg_color col;
+
+	svg_line_color(svg_color _c):col(_c)
+	{
+
+	}
+};
+
+// -----------------------------------------------------------------
+// This allows the user to set the size of the image in centimeters
+// TODO: allow other unit identifiers
+// -----------------------------------------------------------------
+svg_point image_size(unsigned int width, unsigned int height)
+{
+	if(height<=0 || width<=0)
+		throw "Invalid image size";
+	
+	return svg_point(width, height, SVG_SIZE);
+}
+
+svg_instruction write()
+{
+	return svg_instruction(SVG_WRITE);
+}
+
+svg_point draw_point(double x, double y)
+{
+	return svg_point(x, y, SVG_POINT);
+}
+
+svg_line draw_line(double x1, double y1, double x2, double y2)
+{
+	svg_line to_ret(x1, y1, x2, y2);
+
+	return to_ret;
+}
+
+svg_text draw_text(double x, double y, 
+						  const std::string& text)
+{
+	return svg_text(x, y, text);
+}
+
+svg_line_color line_color(svg_color c)
+{
+	return svg_line_color(c);
+}
+
+}
+}
+
+#endif

Added: sandbox/SOC/2007/visualization/boost/svg_plot/svg_plot.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2007/visualization/boost/svg_plot/svg_plot.hpp	2007-05-28 20:19:41 EDT (Mon, 28 May 2007)
@@ -0,0 +1,302 @@
+// svg_plot.hpp
+
+// Copyright (C) Jacob Voytko 2007
+//
+// Distributed under the Boost Software License, Version 1.0.
+// For more information, see http://www.boost.org
+
+// ----------------------------------------------------------------- 
+
+#ifndef _SVG_PLOT_HPP
+#define _SVG_PLOT_HPP
+
+
+#include <vector>
+#include <ostream>
+#include <sstream>
+#include <iterator>
+#include <limits>
+
+#include "svg_plot_instruction.hpp"
+#include "svg.hpp"
+
+namespace boost {
+namespace svg {
+
+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;
+	
+	//Don't let the user use this without specifying a stream.
+	//I can't think of a reasonable default, and I don't think
+	//they'd want the svg formatted output spit to the console
+	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);
+	void _draw_axis();
+	void _set_stroke_color(svg_color);
+
+public:
+	using svg::operator<<;
+
+	svg_plot(const std::string& file);
+	void operator<<(const plot_single_val&);
+	void operator<<(const plot_scale&);
+	void operator<<(const plot_draw_range&);
+	void operator<<(const plot_command&);
+};
+
+// -----------------------------------------------------------------
+// Constructors will be added so that the user can specify
+// a stream instead of a filename
+//
+// This performs work for default values so that if the user starts
+// adding data right away, we won't get abnormal results
+// -----------------------------------------------------------------
+svg_plot::svg_plot(const std::string& file):svg(file)
+{
+	for(int i=0; i<3; ++i)
+		for(int j=0; j<3; ++j)
+			transform_matrix[i][j] = 0;
+	
+	_size(100, 100);
+	x_min = y_min = 0;
+	x_max = y_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
+	
+
+	plot_interval = 1;
+	plot_start = 1;
+}
+
+void svg_plot::operator<<(const plot_scale& rhs)
+{
+	switch(rhs.i_type)
+	{
+	case PLOT_SCALE_X:
+		_check_size();
+		_x_scale(rhs.x1, rhs.x2);
+		break;
+
+	case PLOT_SCALE_Y:
+		_check_size();
+		_y_scale(rhs.x1, rhs.x2);
+		break;
+	
+	case PLOT_SIZE:
+		_plot_image_size((unsigned int)rhs.x1, (unsigned int)rhs.x2);
+		break;
+	}
+}
+
+void svg_plot::operator <<(const plot_single_val& rhs)
+{
+	switch(rhs.i_type)
+	{
+	case PLOT_INTERVAL:
+		_set_interval(rhs.x);
+		break;
+
+	case PLOT_START:
+		_set_start(rhs.x);
+		break;
+	}
+}
+
+void svg_plot::operator<<(const plot_command& rhs)
+{
+	_draw_axis();
+}
+
+void svg_plot::operator<<(const plot_draw_range& rhs)
+{
+	_plot_range(rhs.begin, rhs.end);
+}
+
+void svg_plot::_x_scale(double x1, double x2)
+{
+	x_min = x1;
+	x_max = x2;
+
+	if(x2 <= x1)
+		throw "Illegal Argument: X scale: x2 < x1";
+
+	transform_matrix[0][0] = x_size/(x2-x1);
+	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));
+}
+
+void svg_plot::_plot_image_size(unsigned int x, unsigned int y)
+{
+	_size(x, 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
+// -----------------------------------------------------------------
+void svg_plot::_set_start(double x)
+{
+	plot_start = x;
+}
+
+// -----------------------------------------------------------------
+// The user needs to set the interval to make each subsequent
+// node of the plot render in the right place
+// -----------------------------------------------------------------
+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)
+{
+	double x, y, x2, y2;
+
+	double i=0;
+
+	if(begin+1 == end)
+	{
+		x = plot_start;
+		y = *begin;
+
+		_transform_point(x, y);
+
+		_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);
+
+			_transform_point(x, y);
+			_transform_point(x2, y2);
+
+			_line(x, y, x2, y2);
+
+			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;
+		}
+	}
+}
+
+// -----------------------------------------------------------------
+// This transforms a Cartesian point into a svg point. We don't
+// use the svg 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)
+{
+	x = transform_matrix[0][0]*x+transform_matrix[0][2];
+	y = (transform_matrix[1][1]*y+transform_matrix[1][2]);
+}
+
+
+// -----------------------------------------------------------------
+// TODO: Refactor
+// -----------------------------------------------------------------
+void svg_plot::_draw_axis()
+{
+	//two major axes
+	double x1,y1,x2,y2;
+	
+	x1 = x2 = 0;
+	y1 = y_min;
+	y2 = y_max;
+
+	_transform_point(x1,y1);
+	_transform_point(x2,y2);
+
+	_line(x1, y1, x2, y2);
+
+	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)
+	{
+		y1 = .2;
+		y2 = -.2;
+	
+		x1=x2=i;
+
+		_transform_point(x1,y1);
+		_transform_point(x2,y2);
+
+		_line(x1,y1,x2,y2);
+	}
+
+	for(double i=y_min; i<=y_max; i+=plot_interval)
+	{
+		x1 = .2;
+		x2 = -.2;
+	
+		y1=y2=i;
+
+		_transform_point(x1,y1);
+		_transform_point(x2,y2);
+
+		_line(x1,y1,x2,y2);
+	}
+}
+
+}
+}
+
+#endif
+

Added: sandbox/SOC/2007/visualization/boost/svg_plot/svg_plot_instruction.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2007/visualization/boost/svg_plot/svg_plot_instruction.hpp	2007-05-28 20:19:41 EDT (Mon, 28 May 2007)
@@ -0,0 +1,108 @@
+// svg_plot_instruction.hpp
+
+// Copyright (C) Jacob Voytko 2007
+//
+// Distributed under the Boost Software License, Version 1.0.
+// For more information, see http://www.boost.org
+
+// ----------------------------------------------------------------- 
+
+#ifndef _SVG_PLOT_INSTRUCTION_HPP
+#define _SVG_PLOT_INSTRUCTION_HPP
+
+#include <iterator>
+
+namespace boost {
+namespace svg {
+
+
+enum plot_inst_type{PLOT_SCALE_X, PLOT_SCALE_Y, PLOT_START, PLOT_SIZE,
+					 PLOT_INTERVAL, PLOT_DRAW_AXIS};
+
+struct plot_command
+{
+	plot_inst_type i_type;
+
+	plot_command(plot_inst_type _i): i_type(_i)
+	{
+
+	}
+};
+
+struct plot_single_val
+{
+	double x;
+
+	plot_inst_type i_type;
+
+	plot_single_val(double _x, plot_inst_type _i): x(_x), i_type(_i)
+	{
+	}
+};
+
+struct plot_scale
+{
+	double x1, x2;
+
+	plot_inst_type i_type;
+
+	plot_scale(double _x1, double _x2, plot_inst_type _i)
+		:x1(_x1), x2(_x2), i_type(_i)
+	{
+
+	}
+};
+
+struct plot_draw_range
+{
+	std::vector<double>::iterator begin;
+	std::vector<double>::iterator end;
+
+	plot_draw_range(std::vector<double>::iterator _b,
+					 std::vector<double>::iterator _e)
+	{
+		begin = _b;
+		end = _e;
+	}
+};
+
+
+plot_scale x_scale(double x1, double x2)
+{
+	return plot_scale(x1, x2, PLOT_SCALE_X);
+}
+
+plot_scale y_scale(double y1, double y2)
+{
+	return plot_scale(y1, y2, PLOT_SCALE_Y);
+}
+
+plot_scale image_size(int x, int y)
+{
+	return plot_scale(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_command draw_axis()
+{
+	return plot_command(PLOT_DRAW_AXIS);
+}
+
+}
+}
+#endif