h2d::svg::Visitor Class Reference

Visitor class, derived from the tinyxml2 visitor class. Used to import SVG data. More...

#include <homog2d.hpp>

Inheritance diagram for h2d::svg::Visitor:

Collaboration diagram for h2d::svg::Visitor:

Public Member Functions
const std::vector< CommonType_< double > > &	get () const
	Used to access the data once the file has been read. More...
SvgType	getSvgType (std::string s) const
	Returns the type as a member of enum SvgType, so the type can be used in a switch. More...
bool	VisitExit (const tinyxml2::XMLElement &) override
	This is the place where actual SVG data is converted and stored into vector. More...
	Visitor ()
	Constructor, populates the table giving type from svg string. More...

Detailed Description

Visitor class, derived from the tinyxml2 visitor class. Used to import SVG data.

Holds the imported data through std::variant

Constructor & Destructor Documentation

Visitor()

h2d::svg::Visitor::Visitor ( )

inline

Constructor, populates the table giving type from svg string.

    { //               svg name      local type id
        _svgTypesTable["circle"]   = T_circle;
        _svgTypesTable["rect"]     = T_rect;
        _svgTypesTable["line"]     = T_line;
        _svgTypesTable["polyline"] = T_polyline;
        _svgTypesTable["polygon"]  = T_polygon;
        _svgTypesTable["ellipse"]  = T_ellipse;
        _svgTypesTable["path"]     = T_path;
    }

Member Function Documentation

get()

const std::vector<CommonType_<double> >& h2d::svg::Visitor::get ( ) const

inline

Used to access the data once the file has been read.

    {
        return _vecVar;
    }

Here is the caller graph for this function:

getSvgType()

SvgType h2d::svg::Visitor::getSvgType ( std::string  s ) const

inline

Returns the type as a member of enum SvgType, so the type can be used in a switch.

    {
        auto it = _svgTypesTable.find( s );
        if( it == std::cend(_svgTypesTable) )
            return T_other;
        return it->second;
    }

VisitExit()

bool h2d::svg::Visitor::VisitExit ( const tinyxml2::XMLElement &  e )

inlineoverride

This is the place where actual SVG data is converted and stored into vector.

(see manual, section "SVG import")

Overload of the root class VisitExit() member function

{
    std::string n = e.Name();
//  std::cout << "element name:" << n << '\n';
    try
    {
        switch( getSvgType( n ) )
        {
            case T_circle:
                _vecVar.emplace_back(
                    CircleD(
                        svgp::getAttribValue( e, "cx", n ),
                        svgp::getAttribValue( e, "cy", n ),
                        svgp::getAttribValue( e, "r", n )
                    )
                );
            break;

            case T_rect:
            {
                auto x1 = svgp::getAttribValue( e, "x", n );
                auto y1 = svgp::getAttribValue( e, "y", n );
                auto w  = svgp::getAttribValue( e, "width", n );
                auto h  = svgp::getAttribValue( e, "height", n );
                _vecVar.emplace_back( FRectD( x1, y1, x1+w, y1+h ) );
            }
            break;

            case T_line:
                _vecVar.emplace_back(
                    SegmentD(
                        svgp::getAttribValue( e, "x1", n ),
                        svgp::getAttribValue( e, "y1", n ),
                        svgp::getAttribValue( e, "x2", n ),
                        svgp::getAttribValue( e, "y2", n )
                    )
                );
            break;

            case T_polygon:
            {
                auto vpts = svgp::importSvgPoints( e );
                _vecVar.emplace_back( CPolylineD(vpts) );
            }
            break;

            case T_polyline:
            {
                auto vpts = svgp::importSvgPoints( e );
                _vecVar.emplace_back( OPolylineD(vpts) );
            }
            break;

            case T_path: // a path can hold multiple polygons (because of the 'L' command)
            {
                auto pts_str = svgp::getAttribString( "d", e );
                try
                {
                    auto parse_res = svgp::parsePath( pts_str );
                    const auto& vec_vec_pts = parse_res.first;  //
                    for( auto vec_pts: vec_vec_pts ) // we need a copy so we may remove last point if equal to first
//                  for( const auto& vec_pts: vec_vec_pts ) // we need a copy so we may remove last point if equal to first
                    {
                        if( vec_pts.front() == vec_pts.back() ) // if first point equal to last
                            vec_pts.pop_back();                  //  point, remove last point

                        if( parse_res.second == true )
                            _vecVar.emplace_back( CPolylineD(vec_pts) );
                        else
                            _vecVar.emplace_back( OPolylineD(vec_pts) );
                    }
                }
                catch( std::exception& err )    // an unhandled path command will just get the whole path command ignored
                {
                    HOMOG2D_LOG_WARNING( "Unable to import SVG path command\n -msg="
                        << err.what() << "\n -input string=" << pts_str
                    );
                }
            }
            break;

            case T_ellipse:
            {
                auto x  = svgp::getAttribValue( e, "cx", n );
                auto y  = svgp::getAttribValue( e, "cy", n );
                auto rx = svgp::getAttribValue( e, "rx", n );
                auto ry = svgp::getAttribValue( e, "ry", n );
                auto rot = svgp::getEllipseRotateAttr( svgp::getAttribString( "transform", e ) );
                auto ell = EllipseD( x, y, rx, ry );

                auto H = Homogr().addTranslation(-x,-y).addRotation(rot.second).addTranslation(x,y);
                _vecVar.push_back( H * ell );
            }
            break;

            default:  // for T_other elements
                if( n != "svg" ) // because that one will be always there, so no need to show a warning
                    HOMOG2D_LOG_WARNING( "found SVG element '" << n << "' in SVG file, left unprocessed" );
            break;
        }
    }
    catch( std::string& msg )
    {
        HOMOG2D_THROW_ERROR_1( "h2d: Tinyxml read error: " << msg );
        return false; // to avoid a compile warning
    }
    return true;
}

Here is the call graph for this function:

---

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

• homog2d.hpp