dash::tools::PatternVisualizer< PatternT > Class Template Reference

Take a generic pattern instance and visualize it as an SVG image. More...

#include <PatternVisualizer.h>

Public Member Functions
	PatternVisualizer (const PatternT &pat, std::string title="", std::string descr="")
	Constructs the Pattern Visualizer with a pattern instance. More...
	PatternVisualizer (const self_t &other)=delete
void	set_description (const std::string &str)
	Sets a description for the pattern. More...
void	set_title (const std::string &str)
	Sets the title displayed above the pattern. More...
void	draw_pattern (std::ostream &os, bool blocked_display=false, std::array< index_t, PatternT::ndim()> coords={}, int dimx=1, int dimy=0)
	Outputs the pattern as a svg over the given output stream. More...
void	draw_pane (std::ostream &os, bool blocked_display, const sizes &sz, std::array< index_t, PatternT::ndim()> coords, int dimx, int dimy)
	Draws a pane (svg group) containing axes, key, tiles/blocks For the non blocked display (tiles) the local blocks and the memory layout gets drawn, too. More...
void	draw_axes (std::ostream &os, const sizes &sz, int dimx, int dimy, int offsx=0, int offsy=0)
	Draws the axes labeled with their dedicated dimension. More...
void	draw_key (std::ostream &os, const sizes &sz, int offsx=0, int offsy=0)
	Draws a list of units with their matching color. More...
void	draw_tiles (std::ostream &os, const sizes &sz, std::array< index_t, PatternT::ndim()> coords, int dimx, int dimy)
	Draws the seperate tiles of the pattern. More...
void	draw_blocks (std::ostream &os, const sizes &sz, int dimx, int dimy)
	Draws the blocks of the pattern. More...
void	draw_local_blocks (std::ostream &os, const sizes &sz, std::array< index_t, PatternT::ndim()> coords, int dimx, int dimy)
	Draws the local blocks of the current unit (usually unit 0) More...
void	draw_local_memlayout (std::ostream &os, const sizes &sz, int dimx, int dimy)
	Draws the memory layout for the current unit (usually unit 0) More...

Detailed Description

template<typename PatternT>
class dash::tools::PatternVisualizer< PatternT >

Take a generic pattern instance and visualize it as an SVG image.

The visualization is limited to two dimensions at the moment, but for higher-dimensional patterns any two dimensions can be specified for visualization.

Examples:

ex.06.pattern-block-visualizer/main.cpp.

Definition at line 30 of file PatternVisualizer.h.

Constructor & Destructor Documentation

PatternVisualizer()

template<typename PatternT>

dash::tools::PatternVisualizer< PatternT >::PatternVisualizer ( const PatternT &  pat, std::string  title = "", std::string  descr = ""  )

inline

Constructs the Pattern Visualizer with a pattern instance.

The pattern instance is constant. For a different pattern a new PatternVisualizer has to be constructed.

Parameters

title	An optional title
descr	An optional describtion, currently not used

Definition at line 83 of file PatternVisualizer.h.

    : _pattern(pat)
    , _title(std::move(title))
    , _descr(std::move(descr))
  {
    _tile_base_size  = 10;
    _block_base_size = 26;
    _fontsz_tiny     =  9;
    _fontsz          = 10;
    _fontsz_title    = 12;
  }

Member Function Documentation

draw_axes()

template<typename PatternT>

void dash::tools::PatternVisualizer< PatternT >::draw_axes ( std::ostream &  os, const sizes &  sz, int  dimx, int  dimy, int  offsx = 0, int  offsy = 0  )

inline

Draws the axes labeled with their dedicated dimension.

Definition at line 208 of file PatternVisualizer.h.

Referenced by dash::tools::PatternVisualizer< PatternT >::draw_pane().

                                               {

    int startx = offsx;
    int starty = offsy;
    int lenx   = sz.grid_width  * sz.gridx + sz.grid_base;
    int leny   = sz.grid_height * sz.gridy + sz.grid_base;

    os << "<defs>\n";
    os << R"(<marker id="arrowhead" orient="auto")";
    os << R"( markerWidth="6" markerHeight="6")";
    os << R"( refX="0" refY="0")";
    os << " viewBox=\"-10 -15 30 30\">\n";
    os << "<path d=\"";
    os << "M " << -10 << " " << -15 << " ";
    os << "L " <<  20 << " " <<   0 << " ";
    os << "L " << -10 << " " <<  15 << " ";
    os << "L " <<   0 << " " <<   0 << " ";
    os << "z ";
    os << "\"";
    os << " style=\"fill:#808080;stroke:#808080;stroke-width:1\"";
    os << "/>";
    os << "</marker>\n";
    os << "</defs>\n";

    os << "<path d=\"";
    os << "M " << startx << " " << starty << " ";
    os << "h " <<   lenx << " ";
    os << "\"";
    os << " style=\"fill:none;stroke:#808080;stroke-width:1\"";
    os << " marker-end=\"url(#arrowhead)\"";
    os << "/>";

    os << "<text x=\"" << startx + lenx/3 << "\" y=\"" << starty - _fontsz/2 << "\" ";
    os << R"( fill="grey" font-size=")" << _fontsz << "\" >";
    os << "Dimension " << dimx << std::endl;
    os << "</text>" << std::endl;

    os << "<path d=\"";
    os << "M " << startx << " " << starty << " ";
    os << "v " <<   leny << " ";
    os << "\"";
    os << " style=\"fill:none;stroke:#808080;stroke-width:1\"";
    os << " marker-end=\"url(#arrowhead)\"";
    os << "/>";

    os << "<text x=\"" << startx - _fontsz/2 << "\" y=\"" << starty + leny/3 << "\" ";
    os << " transform=\"rotate(-90," << startx - _fontsz/2 << "," << starty + leny/3 << ")\" ";
    os << R"( fill="grey" font-size=")" << _fontsz << "\" >";
    os << "Dimension " << dimy << std::endl;
    os << "</text>" << std::endl;
  }

draw_blocks()

template<typename PatternT>

void dash::tools::PatternVisualizer< PatternT >::draw_blocks ( std::ostream &  os, const sizes &  sz, int  dimx, int  dimy  )

inline

Draws the blocks of the pattern.

Definition at line 326 of file PatternVisualizer.h.

References dash::block().

Referenced by dash::tools::PatternVisualizer< PatternT >::draw_pane().

                                       {
    std::array<index_t, PatternT::ndim()> block_coords;
    std::array<index_t, PatternT::ndim()> block_begin_coords;
    auto blockspec = _pattern.blockspec();
    for (int i = 0; i < blockspec.extent(dimx); i++) {
      for (int j = 0; j < blockspec.extent(dimy); j++) {
        block_coords[dimx] = i;
        block_coords[dimy] = j;
        auto block_idx = _pattern.blockspec().at(block_coords);
        auto block     = _pattern.block(block_idx);
        block_begin_coords[dimx] = block.offset(dimx);
        block_begin_coords[dimy] = block.offset(dimy);
        auto unit      = _pattern.unit_at(block_begin_coords);

        int i_grid = i * sz.gridx;
        int j_grid = j * sz.gridy;

        os << "<rect x=\"" << i_grid << "\" y=\"" << j_grid << "\" ";
        os << "height=\"" << sz.blockszy << "\" width=\"" << sz.blockszx << "\" ";
        os << tilestyle(unit);
        os << "> ";
        os << "<!-- i=" << i << " j=" << j << "--> ";
        os << "</rect>" << std::endl;
      }
    }
  }

draw_key()

template<typename PatternT>

void dash::tools::PatternVisualizer< PatternT >::draw_key ( std::ostream &  os, const sizes &  sz, int  offsx = 0, int  offsy = 0  )

inline

Draws a list of units with their matching color.

Definition at line 266 of file PatternVisualizer.h.

Referenced by dash::tools::PatternVisualizer< PatternT >::draw_pane().

                                              {
    int startx, starty;

    startx = offsx;
    for (int unit = 0; unit < _pattern.num_units(); unit++) {
      startx = offsx;
      starty = offsy + (unit * (sz.tileszy + 2));
      os << "<rect x=\"" << startx << "\" y=\"" << starty << "\" ";
      os << "height=\"" << sz.tileszy << "\" width=\"" << sz.tileszx << "\" ";
      os << tilestyle(unit);
      os << "> ";
      os << "</rect>" << std::endl;

      starty += sz.tileszy - 2;
      startx += sz.tileszx + 1;
      os << "<text x=\"" << startx << "\" y=\"" << starty << "\" ";
      os << R"( fill="grey" font-size=")" << _fontsz << "\"";
      os << " >";
      os << "Unit " << unit << std::endl;
      os << "</text>" << std::endl;
    }
  }

draw_local_blocks()

template<typename PatternT>

void dash::tools::PatternVisualizer< PatternT >::draw_local_blocks ( std::ostream &  os, const sizes &  sz, std::array< index_t, PatternT::ndim()>  coords, int  dimx, int  dimy  )

inline

Draws the local blocks of the current unit (usually unit 0)

Definition at line 358 of file PatternVisualizer.h.

References dash::block().

Referenced by dash::tools::PatternVisualizer< PatternT >::draw_pane().

                                             {

    std::array<index_t, PatternT::ndim()> block_coords = coords;
    std::array<index_t, PatternT::ndim()> block_begin_coords = coords;

    auto blockspec = _pattern.blockspec();

    for (int i = 0; i < blockspec.extent(dimx); i++) {
      for (int j = 0; j < blockspec.extent(dimy); j++) {

        block_coords[dimx] = i;
        block_coords[dimy] = j;
        auto block_idx = _pattern.blockspec().at(block_coords);
        auto block     = _pattern.block(block_idx);

        block_begin_coords[dimx] = block.offset(dimx);
        block_begin_coords[dimy] = block.offset(dimy);
        auto unit      = _pattern.unit_at(block_begin_coords);

        if( unit==0 ) {
          int i_grid = block.offset(dimx)*sz.gridx - 1;
          int j_grid = block.offset(dimy)*sz.gridy - 1;

          int width  = (block.extent(dimx)-1)*sz.gridx + sz.tileszx + 2;
          int height = (block.extent(dimy)-1)*sz.gridy + sz.tileszy + 2;

          os << "<rect x=\"" << i_grid << "\" y=\"" << j_grid << "\" ";
          os << "height=\"" << height << "\" width=\"" << width << "\" ";
          os << "style=\"fill:#999999;stroke-width:0\" >";
          os << "</rect>" << std::endl;
        }
      }
    }
  }

draw_local_memlayout()

template<typename PatternT>

void dash::tools::PatternVisualizer< PatternT >::draw_local_memlayout ( std::ostream &  os, const sizes &  sz, int  dimx, int  dimy  )

inline

Draws the memory layout for the current unit (usually unit 0)

Definition at line 399 of file PatternVisualizer.h.

Referenced by dash::tools::PatternVisualizer< PatternT >::draw_pane().

                                                {
    int startx, starty;
    int endx, endy;

    startx = starty = 0;
    for ( auto offset = 0; offset < _pattern.local_size(); offset++ ) {
      auto coords = _pattern.coords(_pattern.global(offset));

      endx = (coords[dimx] * sz.gridx) + sz.tileszx / 2;
      endy = (coords[dimy] * sz.gridy) + sz.tileszy / 2;

      if ( startx > 0 && starty > 0 ) {
        os << "<line x1=\"" << startx << "\" y1=\"" << starty << "\"";
        os << " x2=\"" << endx << "\" y2=\"" << endy << "\"";
        os << " style=\"stroke:#E0E0E0;stroke-width:1\"/>";
        os << " <!-- (" << offset << ") -->";
        os << std::endl;
      }

      os << "<circle cx=\"" << endx << "\" cy=\"" << endy << R"(" r="1.5" )";
      os << " style=\"stroke:#E0E0E0;stroke-width:1;fill:#E0E0E0\" />";
      os << std::endl;

      startx = endx;
      starty = endy;
    }

  }

draw_pane()

template<typename PatternT>

void dash::tools::PatternVisualizer< PatternT >::draw_pane ( std::ostream &  os, bool  blocked_display, const sizes &  sz, std::array< index_t, PatternT::ndim()>  coords, int  dimx, int  dimy  )

inline

Draws a pane (svg group) containing axes, key, tiles/blocks For the non blocked display (tiles) the local blocks and the memory layout gets drawn, too.

Definition at line 184 of file PatternVisualizer.h.

References dash::tools::PatternVisualizer< PatternT >::draw_axes(), dash::tools::PatternVisualizer< PatternT >::draw_blocks(), dash::tools::PatternVisualizer< PatternT >::draw_key(), dash::tools::PatternVisualizer< PatternT >::draw_local_blocks(), dash::tools::PatternVisualizer< PatternT >::draw_local_memlayout(), and dash::tools::PatternVisualizer< PatternT >::draw_tiles().

Referenced by dash::tools::PatternVisualizer< PatternT >::draw_pattern().

                                     {
    os << "<g transform=\"translate(10,10)\">" << std::endl;
    draw_axes(os, sz, dimx, dimy);

    os << "<g transform=\"translate(4,4)\">" << std::endl;
    if(!blocked_display) {
        draw_local_blocks(os, sz, coords, dimx, dimy);
        draw_tiles(os, sz, coords, dimx, dimy);
        draw_local_memlayout(os, sz, dimx, dimy);
    } else {
        draw_blocks(os, sz, dimx, dimy);
    }
    os << "</g>" << std::endl;

    draw_key(os, sz, sz.grid_width * sz.gridx + 2*sz.grid_base, 0);
    os << "</g>" << std::endl;
  }

draw_pattern()

template<typename PatternT>

void dash::tools::PatternVisualizer< PatternT >::draw_pattern ( std::ostream &  os, bool  blocked_display = false, std::array< index_t, PatternT::ndim()>  coords = {}, int  dimx = 1, int  dimy = 0  )

inline

Outputs the pattern as a svg over the given output stream.

This method should only be called by a single unit.

Parameters

blocked_display	If this option is false every tile of the pattern is displayed seperate. If this option is true only the blocks (group of elements) get displayed.
coords	For higher dimensional patterns, defines which slice gets displayed
dimx	Defines which dimension gets displayed in x-direction
dimy	Defines which dimension gets displayed in y-direction

Definition at line 121 of file PatternVisualizer.h.

References dash::tools::PatternVisualizer< PatternT >::draw_pane().

                                                 {},
      int dimx = 1,
      int dimy = 0) {
    sizes sz;
    sz.tileszx   = sz.tileszy = _tile_base_size;
    sz.blockszx  = sz.blockszy = _block_base_size;
    if(!blocked_display) {
        sz.grid_width  = _pattern.extent(dimx);
        sz.grid_height = _pattern.extent(dimy);
        sz.grid_base   = _tile_base_size + 2;
        sz.gridx       = sz.gridy   = sz.grid_base;
    } else {
        sz.grid_width  = _pattern.blockspec().extent(dimx);
        sz.grid_height = _pattern.blockspec().extent(dimy);
        sz.grid_base   = _block_base_size + 2;

        // Adjust tile sizes proportional to block regions:
        float block_format = static_cast<float>(_pattern.blocksize(dimy)) /
                             static_cast<float>(_pattern.blocksize(dimx));
        if (block_format < 1) {
          block_format = 1.0 / block_format;
          sz.blockszx *= block_format;
        } else {
          sz.blockszy *= block_format;
        }
        sz.gridx        = sz.blockszx + 2;
        sz.gridy        = sz.blockszy + 2;
    }

    std::string title = _title;
    replace_all(title, "<", "&lt;");
    replace_all(title, ">", "&gt;");

    os << "<svg xmlns=\"http://www.w3.org/2000/svg\"";
    os << " xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n";

    // typeset title line
    os << R"(<text x="10" y="15" )";
    os << R"( fill="grey" font-size=")" << _fontsz_title << "\">";
    os << title;
    os << "</text>\n";

    // draw the pane, including axes and key
    os << "<g transform=\"translate(10,30)\">\n";
    draw_pane(os, blocked_display, sz, coords, dimx, dimy);
    os << "</g>\n";

    os << "</svg>" << std::endl;
  }

draw_tiles()

template<typename PatternT>

void dash::tools::PatternVisualizer< PatternT >::draw_tiles ( std::ostream &  os, const sizes &  sz, std::array< index_t, PatternT::ndim()>  coords, int  dimx, int  dimy  )

inline

Draws the seperate tiles of the pattern.

Definition at line 294 of file PatternVisualizer.h.

Referenced by dash::tools::PatternVisualizer< PatternT >::draw_pane().

                                      {
    for (int i = 0; i < _pattern.extent(dimx); i++) {
      for (int j = 0; j < _pattern.extent(dimy); j++) {

        os << "<rect x=\"" << (i * sz.gridx) << "\" y=\"" << (j * sz.gridy) << "\" ";
        os << "height=\"" << sz.tileszy << "\" width=\"" << sz.tileszx << "\" ";

        coords[dimx] = i;
        coords[dimy] = j;

        auto unit  = _pattern.unit_at(coords);
        auto loffs = _pattern.at(coords);

        os << tilestyle(unit);
        os << " tooltip=\"enable\" > ";
        os << " <title>Elem: (" << j << "," << i <<"),";
        os << " Unit " << unit;
        os << " Local offs. " << loffs;
        os << "</title>";

          //os << "<!-- i=" << i << " j=" << j << "--> ";
        os << "</rect>" << std::endl;
      }
    }
  }

set_description()

template<typename PatternT>

void dash::tools::PatternVisualizer< PatternT >::set_description ( const std::string &  str )

inline

Sets a description for the pattern.

Currently not used.

Definition at line 107 of file PatternVisualizer.h.

                                              {
    _descr = str;
  }

set_title()

template<typename PatternT>

void dash::tools::PatternVisualizer< PatternT >::set_title ( const std::string &  str )

inline

Sets the title displayed above the pattern.

Definition at line 113 of file PatternVisualizer.h.

                                        {
    _title = str;
  }

---

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

• /tmp/tmporruphar/dash/include/dash/tools/PatternVisualizer.h