#include <print_utils.h>

Collaboration diagram for PrintUtils:

Public Member Functions
	PrintUtils ()

void	vector (string prefix, rvector v, double scale, string suffix, int precision, int fieldwidth)

void	vector (rvector v)

void	vector (string prefix, rvector v)

void	vector (string vector_name, rvector v, string suffix)

void	vector (string prefix, rvector v, string suffix, int precision)

void	vectorAndMag (string vector_name, rvector v)

void	vectorAndMag (string vector_name, rvector v, string suffix)

void	vector_endl (rvector v, double factor, string units, int precision)

void	vector2 (string name_v1, rvector v1, string name_v2, rvector v2)

void	vector2 (string name_v1, rvector v1, string name_v2, rvector v2, int precision)

void	endline ()

string	quat (string prefix, quaternion q, string suffix, int precision, int fieldwidth)

string	quat (quaternion q)

void	quat (quaternion q, int precision)

void	quat (string prefix, quaternion q)

void	quat (string prefix, quaternion q, int precision)

void	quat (string prefix, quaternion q, string suffix)

void	quat (string prefix, quaternion q, string suffix, int precision)

void	reset ()

void	text (string text)

void	scalar (string prefix, double s, string suffix)

void	scalar (string prefix, double s, double scale, string suffix, int precision, int fieldwidth)

void	scalar (double s, string suffix)

void	scalar (string prefix, double s)

void	scalar (double s)

Public Attributes
bool	printOn

int	precision

int	fieldwidth

double	scale

string	prefix

string	suffix

string	delimiter

bool	delimiter_flag

bool	use_brackets

string	fullMessage

Constructor & Destructor Documentation

PrintUtils::PrintUtils ( )

 {
     reset();
 }

Member Function Documentation

void PrintUtils::vector	(	string	prefix,
		rvector	v,
		double	scale,
		string	suffix,
		int	precision,
		int	fieldwidth
	)

 {
 
     std::ostringstream out;
 
     out << prefix;
 
     //    if (delimiter_flag)
     //    {
     //        out << delimiter;
     //    }
 
     if (use_brackets)
     {
         out << "[";
     }
 
     // in case we don't want to print the vector with fixed width
     if (precision != -1)
     {
         // with set precision
         //std::cout.precision(precision);
         out << std::fixed;
         out << std::setprecision(precision);
     }
 
     if (fieldwidth != -1)
     {
         // print with fixed width
         // std::cout.width(filedwidth);
 
         out << std::setw(fieldwidth) << v.col[0]*scale << ","
             << std::setw(fieldwidth) << v.col[1]*scale <<  ","
             << std::setw(fieldwidth) << v.col[2]*scale;
 
     }
     else
     {
         // simple print, no fixed width
         out << v.col[0]*scale << ","
                               << v.col[1]*scale <<  ","
                               << v.col[2]*scale;
     }
 
     if (use_brackets)
     {
         out << "]";
     }
 
     out << suffix;
 
     if (delimiter_flag)
     {
         out << delimiter;
     }
 
     if (printOn) {
         std::cout << out.str();
     }
 
     fullMessage += out.str();
 }

void PrintUtils::vector ( rvector v )

 {
     // simple print
     vector(prefix, v, scale, suffix, precision, fieldwidth);
 }

void PrintUtils::vector	(	string	prefix,
		rvector	v
	)

 {
     vector(prefix, v, scale, suffix, precision, fieldwidth);
 }

void PrintUtils::vector	(	string	vector_name,
		rvector	v,
		string	suffix
	)

 {
     vector(vector_name, v, scale, suffix, precision, fieldwidth);
 }

void PrintUtils::vector	(	string	prefix,
		rvector	v,
		string	suffix,
		int	precision
	)

 {
     vector(prefix, v, scale, suffix, precision, fieldwidth);
 }

void PrintUtils::vectorAndMag	(	string	vector_name,
		rvector	v
	)

 {
     vectorAndMag(vector_name, v, "");
 }

void PrintUtils::vectorAndMag	(	string	vector_name,
		rvector	v,
		string	suffix
	)

 {
     vector(vector_name, v, scale, "", precision, fieldwidth);
 
     double magnitude = length_rv(v)*scale;
 
     std::ostringstream out;
 
     if (delimiter_flag)
     {
         out << " M,";
     }
     else
     {
         out << ", M,";
     }
 
     if (use_brackets)
     {
         out << "[";
     }
 
     if (precision != -1)
     {
         out << std::fixed;
         out << std::setprecision(precision);
     }
 
     if (fieldwidth != -1)
     {
         out << std::fixed;
         out << std::setw(fieldwidth) << magnitude;
     }
     else
     {
         out << magnitude;
     }
 
 
     out << suffix;
 
     if (use_brackets)
     {
         out << "]";
     }
 
     if (delimiter_flag)
     {
         out << ",";
     }
     else
     {
         out << "";
     }
 
     // reset scale so that the next prints are not affected
     scale = 1;
 
     if (printOn) {
         std::cout << out.str();
     }
 
     fullMessage += out.str();
 
 }

void PrintUtils::vector_endl	(	rvector	v,
		double	factor,
		string	units,
		int	precision
	)

void PrintUtils::vector2	(	string	name_v1,
		rvector	v1,
		string	name_v2,
		rvector	v2
	)

 {
     std::cout << name_v1 << ": " << v1 << " | " << name_v2 << ": " << v2 << std::endl;
 }

void PrintUtils::vector2	(	string	name_v1,
		rvector	v1,
		string	name_v2,
		rvector	v2,
		int	precision
	)

 {
     std::cout.precision(precision);
     std::cout << name_v1 << std::fixed << "[" << v1.col[0] << ", " << v1.col[1] <<  ", " << v1.col[2] << "]" << " | " << name_v2 << "[" << v2.col[0] << ", " << v2.col[1] <<  ", " << v2.col[2] << "]" << std::endl;
 }

void PrintUtils::endline ( )

 {
     std::cout << std::endl;
 }

string PrintUtils::quat	(	string	prefix,
		quaternion	q,
		string	suffix,
		int	precision,
		int	fieldwidth = `6`
	)

 {
 
     std::ostringstream out;
 
     out << prefix;
 
     //    if (delimiter_flag)
     //    {
     //        out << delimiter;
     //    }
 
     if (use_brackets)
     {
         out << "[";
     }
 
     if (precision != -1){
         // with set precision
         out << std::fixed;
         out << std::setprecision(precision);
     }
 
     if (use_brackets)
     {
         out << "[xyzw],";
     }
 
     if (fieldwidth != -1)
     {
         // print with fixed width
         if (use_brackets)
         {
             out << "(";
         }
         out << std::setw(fieldwidth) << q.d.x << ","
             << std::setw(fieldwidth) << q.d.y << ","
             << std::setw(fieldwidth) << q.d.z << ",";
 
         if (use_brackets)
         {
             out << ")";
         }
         out << std::setw(fieldwidth) << q.w;
 
     }
     else
     {
         // simple print, no fixed width
 
         if (use_brackets)
         {
             out << "(";
         }
         out << q.d.x << ","
             << q.d.y << ","
             << q.d.z << ",";
 
         if (use_brackets)
         {
             out << ")";
         }
         out << q.w;
     }
 
 
     if (use_brackets)
     {
         out << "]";
     }
 
     out << suffix;
 
     if (delimiter_flag)
     {
         out << delimiter;
     }
 
     if (printOn) {
         std::cout << out.str();
     }
 
     // add to the message so it can be printed later
     fullMessage += out.str();
 
     //std::cout << prefix << "[[" << q.d.x*scale << "," << q.d.y*scale <<  "," << q.d.z*scale << "] " << q.w*scale << "]" << text_suffix;
 
     // return the string produced
     return out.str();
 }

string PrintUtils::quat ( quaternion q )

 {
     // this prints the quaternion q enclosed in brackets like this: [[x,y,z] w]
     //std::cout << q;
     return quat(prefix, q, suffix, -1, fieldwidth);
 }

void PrintUtils::quat	(	quaternion	q,
		int	precision
	)

 {
     quat(prefix, q, suffix, precision, fieldwidth);
 }

void PrintUtils::quat	(	string	prefix,
		quaternion	q
	)

 {
     quat(prefix, q, suffix, precision, fieldwidth);
 }

void PrintUtils::quat	(	string	prefix,
		quaternion	q,
		int	precision
	)

 {
     quat(prefix, q, suffix, precision, fieldwidth);
 }

void PrintUtils::quat	(	string	prefix,
		quaternion	q,
		string	suffix
	)

 {
     quat(prefix, q, suffix, precision, fieldwidth);
 }

void PrintUtils::quat	(	string	prefix,
		quaternion	q,
		string	suffix,
		int	precision
	)

 {
     quat(prefix, q, suffix, precision, fieldwidth);
 }

void PrintUtils::reset ( )

 {
     // default values
     printOn = true; // start with a default printing behaviour
     precision = -1; // start with no set precision
     fieldwidth = -1; // start with no set fieldwidth
     scale = 1;  // start with no scale factor
     prefix = ""; // start with no prefix text
     suffix = ""; // start with no suffix text
     use_brackets = false; // start with no brackets around text
     delimiter = ","; // start with coma delimiter
     delimiter_flag = false; // start with no delimiter flags, user has to turn on this flag for use
     fullMessage = ""; // clear the full message
 }

void PrintUtils::text ( string text )

 {
     string out;
 
     if (delimiter_flag)
     {
         out = text + delimiter;
     }
     else
     {
         out = text;
     }
 
     if (printOn) {
         std::cout << out;
     }
 
     // add to full message
     fullMessage += out;
 
 }

void PrintUtils::scalar	(	string	prefix,
		double	s,
		string	suffix
	)

 {
     scalar(prefix, s, scale, suffix, precision, fieldwidth);
 }

void PrintUtils::scalar	(	string	prefix,
		double	s,
		double	scale,
		string	suffix,
		int	precision,
		int	fieldwidth
	)

 {
 
     std::ostringstream out;
 
     out << prefix;
 
     if (prefix == "")
     {
         // don't print delimiter
     }
     else
     {
         if (delimiter_flag)
         {
             out << delimiter;
         }
     }
 
     if (use_brackets)
     {
         out << "[";
     }
 
     // in case we don't want to print the vector with fixed width
     if (precision != -1)
     {
         out << std::fixed;
         out << std::setprecision(precision);
     }
 
     if (fieldwidth != -1)
     {
         out << std::setw(fieldwidth);
     }
 
     out << s*scale;
 
     if (suffix == "")
     {
         // don't print delimiter
     }
     else
     {
         if (delimiter_flag)
         {
             out << delimiter;
         }
     }
 
     out << suffix;
 
     if (use_brackets)
     {
         out << "]";
     }
 
     if (delimiter_flag)
     {
         out << delimiter;
     }
 
     if (printOn) {
         std::cout << out.str();
     }
 
     fullMessage += out.str();
 }

void PrintUtils::scalar	(	double	s,
		string	suffix
	)

 {
     scalar("", s, scale, suffix, precision, fieldwidth);
 }

void PrintUtils::scalar	(	string	prefix,
		double	s
	)

 {
     //    if (delimiter_flag)
     //    {
     //        scalar(prefix + delimiter, s, scale, suffix, precision, fieldwidth);
     //    }
     //    else
     //    {
     //        scalar(prefix, s, scale, suffix, precision, fieldwidth);
     //    }
 
     scalar(prefix, s, scale, suffix, precision, fieldwidth);
 }

void PrintUtils::scalar ( double s )

 {
     scalar(prefix, s, scale, suffix, precision, fieldwidth);
 }

Member Data Documentation

bool PrintUtils::printOn

int PrintUtils::precision

int PrintUtils::fieldwidth

double PrintUtils::scale

string PrintUtils::prefix

string PrintUtils::suffix

string PrintUtils::delimiter

bool PrintUtils::delimiter_flag

bool PrintUtils::use_brackets

string PrintUtils::fullMessage

The documentation for this class was generated from the following files:

Public Member Functions

Public Attributes

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation