SVGPrimitivePlotter Class Reference

A concrete plotter that can draw primitive objects to standalone SVG files. More...

#include <SVGPrimitivePlotter.h>

Inheritance diagram for SVGPrimitivePlotter:

Public Types
using	AttributeMap = Belle2::TrackFindingCDC::AttributeMap
	A map type for attributes names to values for additional drawing information.

Public Member Functions
	SVGPrimitivePlotter ()
	Default constructor for ROOT compatibility.
	SVGPrimitivePlotter (const AttributeMap &svgAttributes)
	Constructor taking additional attributes that go into the toplevel svg tag.
	SVGPrimitivePlotter (const SVGPrimitivePlotter &plotter)
	Copy constructor.
std::unique_ptr< PrimitivePlotter >	clone () const override
	Returns a newly created plotter instance containing all information of this.
void	drawLine (float startX, float startY, float endX, float endY, const AttributeMap &attributeMap=AttributeMap()) override
	Adds a line to the plot.
void	drawArrow (float startX, float startY, float endX, float endY, const AttributeMap &attributeMap=AttributeMap()) override
	Adds an arrow to the plot.
void	drawCircle (float centerX, float centerY, float radius, const AttributeMap &attributeMap=AttributeMap()) override
	Adds a circle to the plot.
void	drawCircleArc (float startX, float startY, float endX, float endY, float radius, bool longArc, bool sweepFlag, const AttributeMap &attributeMap=AttributeMap()) override
	Adds a circle arc to the plot.
void	drawCurve (const std::vector< std::array< float, 2 > > &points, const std::vector< std::array< float, 2 > > &tangents, const AttributeMap &attributeMap=AttributeMap()) override
	Adds a smooth curve to the plot.
void	startGroup (const AttributeMap &attributeMap=AttributeMap()) override
	Indicates the start of a group of drawn elements.
void	endGroup () override
	Indicates the end of a group of drawn elements.
const std::string	save (const std::string &fileName) override
	Saves the current plot state to a file.
void	clear () override
	Clears all drawn elements from the plotter.
void	clearBoundingBox ()
	Clears the current bounding box. Only following draw calls contribute to the bounding box.
const BoundingBox &	getBoundingBox () const
	Getter for the bounding box of all drawn objects.
void	setBoundingBox (const BoundingBox &boundingBox)
	Setter for the bounding box of all drawn objects.
float	getCanvasWidth ()
	Getter for the canvas width in pixels.
float	getCanvasHeight ()
	Getter for the canvas height in pixels.
void	setCanvasWidth (float width)
	Setter for the canvas width in pixels.
void	setCanvasHeight (float height)
	Setter for the canvas height in pixels The canvas height denotes the size of the image being produced.

Static Public Attributes
static const float	s_defaultCanvasWidth = 1120.0
	The default width of the canvas to be plotted into.
static const float	s_defaultCanvasHeight = 1120.0
	The default height of the canvas to be plotted into.

Private Member Functions
void	indent ()
	Increases the current indentation by one.
void	dedent ()
	Decreases the current indentation by one.
void	writeSVGHeader (std::ostream &outputStream)
	Writes the xml header that indicates that this document will be a SVG document to the given output stream.
void	writeSVGDefs (std::ostream &outputStream)
	Writes a preamble of definitions that define an arrow cap which can be referenced by lines.
void	writeOpeningTag (std::ostream &outputStream, const std::string &tagName, const AttributeMap &geometryAttributeMap=AttributeMap(), const AttributeMap &styleAttributeMap=AttributeMap())
	Writes an opening xml tag to the given output stream taking attributes from two sources.
void	writeStandAloneTag (std::ostream &outputStream, const std::string &tagName, const AttributeMap &geometryAttributeMap=AttributeMap(), const AttributeMap &styleAttributeMap=AttributeMap())
	Writes a stand alone xml tag to the given output stream taking attributes from two sources.
void	writeTagIntern (std::ostream &outputStream, const std::string &tagName, const AttributeMap &geometryAttributeMap=AttributeMap(), const AttributeMap &styleAttributeMap=AttributeMap())
	Writes part that belongs between the <, > brackets.
void	writeAttributes (std::ostream &outputStream, const AttributeMap &attributeMap)
	Writes attribute specification that belongs between the <, > brackets after the tag name.
void	writeClosingTag (std::ostream &outputStream, const std::string &tagName)
	Writes a closing xml tag to the given output stream.

Private Attributes
std::ostringstream	m_svgContentStream
	Memory for the plotted elements. This contains only the fragment that is in-between the svg tags and comes after the global svg definitions.
int	m_nIndentationSpaces
	Memory for the number of spaces that shall be prepended to each line.
AttributeMap	m_svgAttributes
	Memory for additional attributes to the top-level svg element.
BoundingBox	m_boundingBox
	Bounding box of the currently drawn objects.
float	m_canvasWidth
	Memory for the width of the SVG drawing in pixels.
float	m_canvasHeight
	Memory for the height of the SVG drawing in pixels.

Static Private Attributes
static const int	s_defaultNIndentationSpaces = 2
	Constant for the number of indentation space to be used within the svg block.
static const int	s_addtionalNIndentationSpaces = 2
	Constant for the additional number of space to be prepended with each open tag group.

Detailed Description

A concrete plotter that can draw primitive objects to standalone SVG files.

Definition at line 21 of file SVGPrimitivePlotter.h.

Member Typedef Documentation

AttributeMap

using AttributeMap = Belle2::TrackFindingCDC::AttributeMap

inherited

A map type for attributes names to values for additional drawing information.

Definition at line 29 of file PrimitivePlotter.h.

Constructor & Destructor Documentation

SVGPrimitivePlotter() [1/3]

SVGPrimitivePlotter

(

)

Default constructor for ROOT compatibility.

Definition at line 20 of file SVGPrimitivePlotter.cc.

  : PrimitivePlotter()
  , m_svgContentStream()
  , m_nIndentationSpaces(s_defaultNIndentationSpaces)
  , m_svgAttributes()
{
}

SVGPrimitivePlotter() [2/3]

SVGPrimitivePlotter ( const AttributeMap &  svgAttributes )

explicit

Constructor taking additional attributes that go into the toplevel svg tag.

Parameters

svgAttributes

A map of attributes that goes into the toplevel svg tag.

Definition at line 28 of file SVGPrimitivePlotter.cc.

  : PrimitivePlotter()
  , m_svgContentStream()
  , m_nIndentationSpaces(s_defaultNIndentationSpaces)
  , m_svgAttributes(svgAttributes)
{
}

SVGPrimitivePlotter() [3/3]

SVGPrimitivePlotter

(

const SVGPrimitivePlotter &

plotter

)

Copy constructor.

Definition at line 36 of file SVGPrimitivePlotter.cc.

  : PrimitivePlotter(plotter)
  , m_svgContentStream(plotter.m_svgContentStream.str(), std::ostringstream::ate)
  , m_nIndentationSpaces(plotter.m_nIndentationSpaces)
  , m_svgAttributes(plotter.m_svgAttributes)
{
}

Member Function Documentation

clear()

void clear ( )

overridevirtual

Clears all drawn elements from the plotter.

Reimplemented from PrimitivePlotter.

Definition at line 296 of file SVGPrimitivePlotter.cc.

{
  PrimitivePlotter::clear();
  m_svgContentStream.str("");
  m_nIndentationSpaces = s_defaultNIndentationSpaces;
}

clearBoundingBox()

void clearBoundingBox ( )

inherited

Clears the current bounding box. Only following draw calls contribute to the bounding box.

Definition at line 115 of file PrimitivePlotter.cc.

{
  m_boundingBox.clear();
}

clone()

std::unique_ptr< PrimitivePlotter > clone ( ) const

overridevirtual

Returns a newly created plotter instance containing all information of this.

The new object is created on the heap. The ownership is to the caller who has the responsibility to destroy it.

Reimplemented from PrimitivePlotter.

Definition at line 44 of file SVGPrimitivePlotter.cc.

{
  return std::make_unique<SVGPrimitivePlotter>(*this);
}

dedent()

void dedent ( )

private

Decreases the current indentation by one.

Definition at line 308 of file SVGPrimitivePlotter.cc.

{
  m_nIndentationSpaces -= s_addtionalNIndentationSpaces;
}

drawArrow()

void drawArrow ( float  startX, float  startY, float  endX, float  endY, const AttributeMap &  attributeMap = AttributeMap()  )

overridevirtual

Adds an arrow to the plot.

Parameters

startX	x coordinate where the arrow starts.
startY	y coordinate where the arrow starts.
endX	x coordinate where the arrow ends.
endY	y coordinate where the arrow ends.
attributeMap	A map of string keys and values that describe the drawing properties of the line.

Reimplemented from PrimitivePlotter.

Definition at line 69 of file SVGPrimitivePlotter.cc.

{
  PrimitivePlotter::drawArrow(startX, startY, endX, endY, attributeMap);
 
  AttributeMap geometryAttributeMap {
    {"x1", std::to_string(startX)},
    {"x2", std::to_string(endX)},
    {"y1", std::to_string(startY)},
    {"y2", std::to_string(endY)},
    {"marker-end", "url(#endArrow)"}
  };
 
  writeStandAloneTag(m_svgContentStream, "line", geometryAttributeMap, attributeMap);
}

drawCircle()

void drawCircle ( float  centerX, float  centerY, float  radius, const AttributeMap &  attributeMap = AttributeMap()  )

overridevirtual

Adds a circle to the plot.

Parameters

centerX	x coordinate of the circle center.
centerY	y coordinate of the circle center.
radius	radius of the circle
attributeMap	A map of string keys and values that describe the drawing properties of the line.

Reimplemented from PrimitivePlotter.

Definition at line 89 of file SVGPrimitivePlotter.cc.

{
  PrimitivePlotter::drawCircle(centerX, centerY, radius, attributeMap);
 
  AttributeMap geometryAttributeMap {
    {"cx", std::to_string(centerX)},
    {"cy", std::to_string(centerY)},
    {"r", std::to_string(std::fabs(radius))}
  };
 
  writeStandAloneTag(m_svgContentStream, "circle", geometryAttributeMap, attributeMap);
 
}

drawCircleArc()

void drawCircleArc ( float  startX, float  startY, float  endX, float  endY, float  radius, bool  longArc, bool  sweepFlag, const AttributeMap &  attributeMap = AttributeMap()  )

overridevirtual

Adds a circle arc to the plot.

Parameters

startX	x coordinate where the line starts.
startY	y coordinate where the line starts.
endX	x coordinate where the line end.
endY	y coordinate where the line end.
radius	Radius of the circle
longArc	Boolean indicator if the long arc or the short arc is traversed from one point to the other.
sweepFlag	Boolean indicator related to the curvature perceived one the circle arc. False means negative curvature. True mean positive curvature.
attributeMap	A map of string keys and values that describe the drawing properties of the line.

Reimplemented from PrimitivePlotter.

Definition at line 107 of file SVGPrimitivePlotter.cc.

{
  PrimitivePlotter::drawCircleArc(startX,
                                  startY,
                                  endX,
                                  endY,
                                  radius,
                                  longArc,
                                  sweepFlag,
                                  attributeMap);
 
  // Compile the path for a ellipses arc
  // spelling out all the parts in case somebody want adopt
  // although only the simpler circle arc case is needed.
 
  const float radiusX = std::fabs(radius);
  const float radiusY = std::fabs(radius);
  const float rotationAngle = 0;
 
  std::ostringstream pathStream;
 
  pathStream << "M" << ' ';
  pathStream << std::to_string(startX) << ' ';
  pathStream << std::to_string(startY) << ' ';
  pathStream << "A" << ' ';
  pathStream << std::to_string(radiusX) << ' ';
  pathStream << std::to_string(radiusY) << ' ';
  pathStream << std::to_string(rotationAngle) << ' ';
  pathStream << std::to_string(longArc) << ' ';
  pathStream << std::to_string(sweepFlag) << ' ';
  pathStream << std::to_string(endX) << ' ';
  pathStream << std::to_string(endY);
 
  AttributeMap geometryAttributeMap{{"d", pathStream.str()}};
 
  writeStandAloneTag(m_svgContentStream, "path", geometryAttributeMap, attributeMap);
}

drawCurve()

void drawCurve ( const std::vector< std::array< float, 2 > > &  points, const std::vector< std::array< float, 2 > > &  tangents, const AttributeMap &  attributeMap = AttributeMap()  )

overridevirtual

Adds a smooth curve to the plot.

Current implementation approximates circle arcs between the points with cubic splines.

Parameters

points	X,Y points on the curve
tangents	Tangent vector at each point. Length of tangents does not matter.
attributeMap	A map of string keys and values that describe the drawing properties of the line.

Reimplemented from PrimitivePlotter.

Definition at line 152 of file SVGPrimitivePlotter.cc.

{
  // Magic number for circle approximation with splines
  static const double k = 4.0 / 3.0 * (std::sqrt(2.0) - 1.0);
 
  B2ASSERT("Expect number of points and tangents to be the same", points.size() == tangents.size());
  if (points.size() < 2) return;
 
  PrimitivePlotter::drawCurve(points, tangents, attributeMap);
 
  std::ostringstream pathStream;
 
  // Move to point
  float startX = std::get<0>(points[0]);
  float startY = std::get<1>(points[0]);
 
  pathStream << "M";
  pathStream << ' ' << std::to_string(startX);
  pathStream << ' ' << std::to_string(startY);
 
  for (size_t iCurrent = 0, iNext = 1; iNext < points.size(); iCurrent = iNext, ++iNext) {
 
    float currentTX = std::get<0>(tangents[iCurrent]);
    float currentTY = std::get<1>(tangents[iCurrent]);
 
    float nextTX = std::get<0>(tangents[iNext]);
    float nextTY = std::get<1>(tangents[iNext]);
 
    float currentT = std::hypot(currentTX, currentTY);
    float nextT = std::hypot(nextTX, nextTY);
 
    currentTX /= currentT;
    currentTY /= currentT;
    nextTX /= nextT;
    nextTY /= nextT;
 
    float currentX = std::get<0>(points[iCurrent]);
    float currentY = std::get<1>(points[iCurrent]);
 
    float nextX = std::get<0>(points[iNext]);
    float nextY = std::get<1>(points[iNext]);
 
    // Circle arc angle
    float alpha = std::atan2(currentTX * nextTY - currentTY * nextTX,
                             currentTX * nextTX + currentTY * nextTY);
 
    float distance = std::hypot(currentX - nextX, currentY - nextY);
    float controlLength = k * distance / 2 / std::cos(alpha / 2);
 
    float currentControlX = currentX + currentTX * controlLength;
    float currentControlY = currentY + currentTY * controlLength;
 
    float nextControlX = nextX - nextTX * controlLength;
    float nextControlY = nextY - nextTY * controlLength;
 
    pathStream << ' ' << "C";
 
    pathStream << ' ' << std::to_string(currentControlX);
    pathStream << ' ' << std::to_string(currentControlY);
 
    pathStream << ' ' << std::to_string(nextControlX);
    pathStream << ' ' << std::to_string(nextControlY);
 
    pathStream << ' ' << std::to_string(nextX);
    pathStream << ' ' << std::to_string(nextY);
  }
 
  AttributeMap geometryAttributeMap{{"d", pathStream.str()}};
 
  writeStandAloneTag(m_svgContentStream, "path", geometryAttributeMap, attributeMap);
}

drawLine()

void drawLine ( float  startX, float  startY, float  endX, float  endY, const AttributeMap &  attributeMap = AttributeMap()  )

overridevirtual

Adds a line to the plot.

Parameters

startX	x coordinate where the line starts.
startY	y coordinate where the line starts.
endX	x coordinate where the line ends.
endY	y coordinate where the line ends.
attributeMap	A map of string keys and values that describe the drawing properties of the line.

Reimplemented from PrimitivePlotter.

Definition at line 49 of file SVGPrimitivePlotter.cc.

{
  PrimitivePlotter::drawLine(startX, startY, endX, endY, attributeMap);
 
  AttributeMap geometryAttributeMap {
    {"x1", std::to_string(startX)},
    {"x2", std::to_string(endX)},
    {"y1", std::to_string(startY)},
    {"y2", std::to_string(endY)}
  };
 
  writeStandAloneTag(m_svgContentStream, "line", geometryAttributeMap, attributeMap);
 
}

endGroup()

void endGroup ( )

overridevirtual

Indicates the end of a group of drawn elements.

Meaning depends on the actual implementation.

Reimplemented from PrimitivePlotter.

Definition at line 231 of file SVGPrimitivePlotter.cc.

{
  writeClosingTag(m_svgContentStream, "g");
}

getBoundingBox()

const BoundingBox & getBoundingBox ( ) const

inlineinherited

Getter for the bounding box of all drawn objects.

Definition at line 189 of file PrimitivePlotter.h.

      {
        return m_boundingBox;
      }

getCanvasHeight()

float getCanvasHeight ( )

inlineinherited

Getter for the canvas height in pixels.

Definition at line 208 of file PrimitivePlotter.h.

      {
        return m_canvasHeight;
      }

getCanvasWidth()

float getCanvasWidth ( )

inlineinherited

Getter for the canvas width in pixels.

Definition at line 202 of file PrimitivePlotter.h.

      {
        return m_canvasWidth;
      }

indent()

void indent ( )

private

Increases the current indentation by one.

Definition at line 303 of file SVGPrimitivePlotter.cc.

{
  m_nIndentationSpaces += s_addtionalNIndentationSpaces;
}

save()

const std::string save ( const std::string &  fileName )

overridevirtual

Saves the current plot state to a file.

Deriving instances should implement the appropriate thing here and may return a modified string indicating the file name to which the plot as been written. It is allowed to append or change the file extension if the concrete implementation decides to do so.

Parameters

fileName

fileName where the plot shall be saved

Returns

Potentially modified file name where the file has actually been written to.

Reimplemented from PrimitivePlotter.

Definition at line 236 of file SVGPrimitivePlotter.cc.

{
  // Check indentation
  if (m_nIndentationSpaces != s_defaultNIndentationSpaces) {
    B2WARNING("Mismatching calls to startGroup and endGroup detected. "
              << "Proceeding to write the illforamed result.");
  }
 
  int savedNIndentationSpaces = m_nIndentationSpaces;
  m_nIndentationSpaces = 0;
 
  std::ofstream outputFileStream;
  outputFileStream.open(fileName);
 
  writeSVGHeader(outputFileStream);
 
  AttributeMap standardAttributeMap {
    {"baseProfile", "full"},
    {"ev", "http://www.w3.org/2001/xml-events"},
    {"version", "1.1"},
    {"xlink", "http://www.w3.org/1999/xlink"},
    {"xmlns", "http://www.w3.org/2000/svg"}
  };
 
 
  // Combine the viewbox specification from the bounding box
  // Format "{left} {bottom} {width} {height}"
  std::ostringstream viewBoxStringStream;
 
  viewBoxStringStream << getBoundingBox().getLeft();
  viewBoxStringStream << " ";
  viewBoxStringStream << getBoundingBox().getBottom();
  viewBoxStringStream << " ";
  viewBoxStringStream << getBoundingBox().getWidth();
  viewBoxStringStream << " ";
  viewBoxStringStream << getBoundingBox().getHeight();
 
  AttributeMap variableAttributeMap{
    {"height", std::to_string(getCanvasHeight())},
    {"width", std::to_string(getCanvasWidth())},
    {"viewBox", viewBoxStringStream.str()},
  };
 
  variableAttributeMap.insert(m_svgAttributes.begin(), m_svgAttributes.end());
 
  writeOpeningTag(outputFileStream, "svg", standardAttributeMap, variableAttributeMap);
 
  writeSVGDefs(outputFileStream);
 
  // Copy the stream the output and rewind it to its original position.
  outputFileStream << m_svgContentStream.str();
 
  writeClosingTag(outputFileStream, "svg");
 
  outputFileStream.close();
  m_nIndentationSpaces = savedNIndentationSpaces;
 
  return fileName;
}

setBoundingBox()

void setBoundingBox ( const BoundingBox &  boundingBox )

inlineinherited

Setter for the bounding box of all drawn objects.

Definition at line 195 of file PrimitivePlotter.h.

      {
        m_boundingBox = boundingBox;
      }

setCanvasHeight()

void setCanvasHeight ( float  height )

inlineinherited

Setter for the canvas height in pixels The canvas height denotes the size of the image being produced.

The coordinates space that is visible in the picture is a separate concept which is stored in the bounding box (getBoundingBox()).

Definition at line 230 of file PrimitivePlotter.h.

      {
        m_canvasHeight = height;
      }

setCanvasWidth()

void setCanvasWidth ( float  width )

inlineinherited

Setter for the canvas width in pixels.

The canvas height denotes the size of the image being produced. The coordinates space that is visible in the picture is a separate concept which is stored in the bounding box (getBoundingBox()).

Definition at line 219 of file PrimitivePlotter.h.

      {
        m_canvasWidth = width;
      }

startGroup()

void startGroup ( const AttributeMap &  attributeMap = AttributeMap() )

overridevirtual

Indicates the start of a group of drawn elements.

Meaning depends on the actual implementation.

Reimplemented from PrimitivePlotter.

Definition at line 226 of file SVGPrimitivePlotter.cc.

{
  writeOpeningTag(m_svgContentStream, "g", attributeMap);
}

writeAttributes()

void writeAttributes ( std::ostream &  outputStream, const AttributeMap &  attributeMap  )

private

Writes attribute specification that belongs between the <, > brackets after the tag name.

Parameters

[out]	outputStream	The output stream to which the result is written.
[in]	attributeMap	A map of attribute keys to attribute values that shall be attached to the tag.

Definition at line 435 of file SVGPrimitivePlotter.cc.

{
  bool first = true;
  for (const std::pair<std::string, std::string> attribute : attributeMap) {
 
    const std::string& key = attribute.first;
    const std::string& value = attribute.second;
 
    // Skip special attribute
    if ('_' == key[0]) {
      continue;
    }
 
    // Introduce a space between every attribute
    if (first) {
      first = false;
    } else {
      outputStream << ' ';
    }
 
    outputStream << key;
    outputStream << '=' << '"';
    outputStream << value;
    outputStream << '"';
  }
}

writeClosingTag()

void writeClosingTag ( std::ostream &  outputStream, const std::string &  tagName  )

private

Writes a closing xml tag to the given output stream.

Parameters

[out]	outputStream	The output stream to which the result is written.
[in]	tagName	Name of the xml tag to be written

Definition at line 463 of file SVGPrimitivePlotter.cc.

{
  dedent();
 
  // Indentation
  outputStream << std::string(m_nIndentationSpaces, ' ');
 
  // Opening bracket
  outputStream << '<' << '/';
 
  // Tag name
  outputStream << tagName;
 
  // Closing bracket
  outputStream << '>';
 
  // New line
  outputStream << std::endl;
}

writeOpeningTag()

void writeOpeningTag ( std::ostream &  outputStream, const std::string &  tagName, const AttributeMap &  geometryAttributeMap = AttributeMap(), const AttributeMap &  styleAttributeMap = AttributeMap()  )

private

Writes an opening xml tag to the given output stream taking attributes from two sources.

Parameters

[out]	outputStream	The output stream to which the result is written.
[in]	tagName	Name of the xml tag to be written
[in]	geometryAttributeMap	A first map of attribute keys to attribute values that shall be attached to the tag. Usually this gives geometrical information but gets essentially treated the same way as the second attribute map
[in]	styleAttributeMap	A second map of attribute keys to attribute values that shall be attached to the tag. Usually this gives styling information but gets essentially treated the same way as the first attribute map

Definition at line 348 of file SVGPrimitivePlotter.cc.

{
  // Indentation
  outputStream << std::string(m_nIndentationSpaces, ' ');
 
  // Opening bracket
  outputStream << '<';
 
  // Write contained part
  writeTagIntern(outputStream, tagName, geometryAttributeMap, styleAttributeMap);
 
  // Closing bracket
  outputStream << '>';
 
  // New line
  outputStream << std::endl;
 
  indent();
 
  if (geometryAttributeMap.count("_showAt") + styleAttributeMap.count("_showAt")) {
    const std::string showAt = geometryAttributeMap.count("_showAt")
                               ? geometryAttributeMap.at("_showAt")
                               : styleAttributeMap.at("_showAt");
 
    AttributeMap setAttributeMap{
      {"attributeName", "visibility"},
      {"to", "hidden"},
      {"begin", "0s"},
      {"end", showAt}
    };
 
    writeStandAloneTag(outputStream, "set", setAttributeMap);
  }
}

writeStandAloneTag()

void writeStandAloneTag ( std::ostream &  outputStream, const std::string &  tagName, const AttributeMap &  geometryAttributeMap = AttributeMap(), const AttributeMap &  styleAttributeMap = AttributeMap()  )

private

Writes a stand alone xml tag to the given output stream taking attributes from two sources.

Parameters

[out]	outputStream	The output stream to which the result is written.
[in]	tagName	Name of the xml tag to be written
[in]	geometryAttributeMap	A first map of attribute keys to attribute values that shall be attached to the tag. Usually this gives geometrical information but gets essentially treated the same way as the second attribute map
[in]	styleAttributeMap	A second map of attribute keys to attribute values that shall be attached to the tag. Usually this gives styling information but gets essentially treated the same way as the first attribute map

Definition at line 386 of file SVGPrimitivePlotter.cc.

{
  // Special handling for _showAt attribute, which introduces a contained <set> tag
  if (geometryAttributeMap.count("_showAt") + styleAttributeMap.count("_showAt")) {
    writeOpeningTag(outputStream, tagName, geometryAttributeMap, styleAttributeMap);
    writeClosingTag(outputStream, tagName);
  } else {
 
    // Indentation
    outputStream << std::string(m_nIndentationSpaces, ' ');
 
    // Opening bracket
    outputStream << '<';
 
    // Write contained part
    writeTagIntern(outputStream, tagName, geometryAttributeMap, styleAttributeMap);
 
    // Closing bracket
    outputStream << '/' << '>';
 
    // New line
    outputStream << std::endl;
  }
}

writeSVGDefs()

void writeSVGDefs ( std::ostream &  outputStream )

private

Writes a preamble of definitions that define an arrow cap which can be referenced by lines.

Definition at line 319 of file SVGPrimitivePlotter.cc.

{
  writeOpeningTag(outputStream, "defs");
 
  AttributeMap markerAttributes {
    { "id", "endArrow"},
    { "viewBox", "0 0 10 10"},
    { "refX", "1"},
    { "refY", "5"},
    { "markerUnits", "strokeWidth"},
    { "markerWidth", "4"},
    { "markerHeight", "3"},
    {"orient", "auto"}
  };
 
  writeOpeningTag(outputStream, "marker", markerAttributes);
 
 
  AttributeMap polylineAttributes {
    {"points", "0,0 10,5 0,10 1,5"},
    {"fill", "black"}
  };
 
  writeStandAloneTag(outputStream, "polyline", polylineAttributes);
 
  writeClosingTag(outputStream, "marker");
  writeClosingTag(outputStream, "defs");
}

writeSVGHeader()

void writeSVGHeader ( std::ostream &  outputStream )

private

Writes the xml header that indicates that this document will be a SVG document to the given output stream.

Parameters

[out]

outputStream

The output stream to which the result is written.

Definition at line 313 of file SVGPrimitivePlotter.cc.

{
  outputStream << "<?xml version=\"1.0\" ?>" << std::endl;
  outputStream << "<!DOCTYPE svg PUBLIC '-//W3C//DTD SVG 1.1//EN' 'http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd'>" << std::endl;
}

writeTagIntern()

void writeTagIntern ( std::ostream &  outputStream, const std::string &  tagName, const AttributeMap &  geometryAttributeMap = AttributeMap(), const AttributeMap &  styleAttributeMap = AttributeMap()  )

private

Writes part that belongs between the <, > brackets.

Used by writeOpeningTag and writeClosing.

Used by writeOpeningTag and writeClosing. Factored to avoid code duplication.

Parameters

[out]	outputStream	The output stream to which the result is written.
[in]	tagName	Name of the xml tag to be written
[in]	geometryAttributeMap	A first map of attribute keys to attribute values that shall be attached to the tag. Usually this gives geometrical information but gets essentially treated the same way as the second attribute map
[in]	styleAttributeMap	A second map of attribute keys to attribute values that shall be attached to the tag. Usually this gives styling information but gets essentially treated the same way as the first attribute map

Definition at line 414 of file SVGPrimitivePlotter.cc.

{
  // Tag name
  outputStream << tagName;
 
  // First attribute map
  if (not geometryAttributeMap.empty()) {
    outputStream << ' ';
    writeAttributes(outputStream, geometryAttributeMap);
  }
 
  // Second attribute map
  if (not styleAttributeMap.empty()) {
    outputStream << ' ';
    writeAttributes(outputStream, styleAttributeMap);
  }
}

Member Data Documentation

m_boundingBox

BoundingBox m_boundingBox

privateinherited

Bounding box of the currently drawn objects.

Definition at line 237 of file PrimitivePlotter.h.

m_canvasHeight

float m_canvasHeight

privateinherited

Memory for the height of the SVG drawing in pixels.

Definition at line 243 of file PrimitivePlotter.h.

m_canvasWidth

float m_canvasWidth

privateinherited

Memory for the width of the SVG drawing in pixels.

Definition at line 240 of file PrimitivePlotter.h.

m_nIndentationSpaces

int m_nIndentationSpaces

private

Memory for the number of spaces that shall be prepended to each line.

Definition at line 242 of file SVGPrimitivePlotter.h.

m_svgAttributes

AttributeMap m_svgAttributes

private

Memory for additional attributes to the top-level svg element.

Definition at line 245 of file SVGPrimitivePlotter.h.

m_svgContentStream

std::ostringstream m_svgContentStream

private

Memory for the plotted elements. This contains only the fragment that is in-between the svg tags and comes after the global svg definitions.

Definition at line 239 of file SVGPrimitivePlotter.h.

s_addtionalNIndentationSpaces

const int s_addtionalNIndentationSpaces = 2

staticprivate

Constant for the additional number of space to be prepended with each open tag group.

Definition at line 28 of file SVGPrimitivePlotter.h.

s_defaultCanvasHeight

const float s_defaultCanvasHeight = 1120.0

staticinherited

The default height of the canvas to be plotted into.

Definition at line 36 of file PrimitivePlotter.h.

s_defaultCanvasWidth

const float s_defaultCanvasWidth = 1120.0

staticinherited

The default width of the canvas to be plotted into.

Definition at line 33 of file PrimitivePlotter.h.

s_defaultNIndentationSpaces

const int s_defaultNIndentationSpaces = 2

staticprivate

Constant for the number of indentation space to be used within the svg block.

Definition at line 25 of file SVGPrimitivePlotter.h.

---

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

• tracking/trackFindingCDC/display/include/SVGPrimitivePlotter.h
• tracking/trackFindingCDC/display/src/SVGPrimitivePlotter.cc