h2d::svg::svgp Namespace Reference

Private functions related to the SVG import code. More...

Classes
struct	SvgPathCommand
	Holds the current SVG "path" command, and the number of required numerical values. More...
struct	SvgValuesBuffer
	This will hold the values read from the SVG Path parsing code, before they are converted to points. More...

Enumerations
enum	PathMode { PathMode::Absolute, PathMode::Relative }

Functions
Point2d_< double >	generateNewPoint (SvgPathCommand mode, Point2d_< double > prevPt, const std::vector< double > &val)
	Generate new point from current mode and previous point, handles absolute/relative coordinates. More...
const char *	getAttribString (const char *attribName, const tinyxml2::XMLElement &e)
	Helper function for SVG import. More...
double	getAttribValue (const tinyxml2::XMLElement &e, const char *str, std::string e_name)
	Fetch attribute from XML element. Tag e_name is there just in case of trouble. More...
SvgPathCommand	getCommand (char c)
std::pair< Point2d_< HOMOG2D_INUMTYPE >, HOMOG2D_INUMTYPE >	getEllipseRotateAttr (const char *rot_str)
	Importing rotated ellipse from SVG data. More...
std::string	getNextElem (const std::string &str, std::string::const_iterator &it)
	Get next element in svg path string. More...
std::vector< Point2d >	importSvgPoints (const tinyxml2::XMLElement &e)
	Helper function called by Visitor::VisitExit() to process Polyline/Polygons. More...
bool	isDigit (char c)
std::map< char, int > &	numberValues ()
	Returns nb of expected values for a given SVG path command. Ref: https://www.w3.org/TR/SVG2/paths.html. More...
auto	parsePath (const char *s)
	Parse a SVG "path" string and convert it to a vector holding a set (vector) of points. More...
std::vector< Point2d >	parsePoints (const char *pts)
	Svg import: Basic parsing of points that are in the format "10,20 30,40 50,60". More...
template<typename FPT >
std::vector< Point2d_< FPT > >	purgeSetDupes (const std::vector< Point2d_< FPT >> &pts)
	Removes dupes in set of points. Needed when importing SVG files using a "path" command, because sometimes they hold duplicates points, and that can't be in polylines. More...
bool	svgPathCommandIsAllowed (char c)
std::vector< std::string >	tokenize (const std::string &s, char delim)
	General string tokenizer, taken from http://stackoverflow.com/a/236803/193789. More...

Detailed Description

Private functions related to the SVG import code.

Enumeration Type Documentation

PathMode

enum h2d::svg::svgp::PathMode

strong

Enumerator
Absolute
Relative

{ Absolute, Relative };

Function Documentation

generateNewPoint()

Point2d_<double> h2d::svg::svgp::generateNewPoint ( SvgPathCommand  mode, Point2d_< double >  prevPt, const std::vector< double > &  val  )

inline

Generate new point from current mode and previous point, handles absolute/relative coordinates.

Parameters

mode	SVG path command
prevPt	previous point, is needed if relative mode
val	numerical values that have been stored

{
//  std::cout << "generateNewPoint(): command=" << mode._command
//      << std::hex << " hex=" << (int)mode._command << std::dec << '\n';
    auto nb = val.size();
//  priv::printVector( val,"generateNewPoint()" );
    HOMOG2D_LOG( "abs/rel=" << (mode.isAbsolute()?"ABS":"REL") );
// some checking to lighten up the following code, maybe can be removed afterwards
    switch( mode._command )
    {
        case 'M':
        case 'L':
            assert( nb == 2 );
        break;
        case 'H':
        case 'V':
            assert( nb == 1 );
        break;
        case 'Z':
            assert( nb == 0 );
        break;
        default: assert(0);
    }

    Point2d_<double> out;
    switch( mode._command )
    {
        case 'M':
        case 'L':
            if( mode.isAbsolute() )
                out.set( val[0], val[1] );
            else
                out.set( prevPt.getX() + val[0], prevPt.getY() + val[1] );
        break;

        case 'H':   // Horizontal
            if( mode.isAbsolute() )
                out.set( val[0],                  prevPt.getY() );
            else
                out.set( val[0] + prevPt.getX() , prevPt.getY() );
        break;

        case 'V':    // Vertical
            if( mode.isAbsolute() )
                out.set( prevPt.getX(), val[0]                 );
            else
                out.set( prevPt.getX(), val[0] + prevPt.getY() );
        break;

        default: assert(0);
    }
    return out;
}

Here is the call graph for this function:

Here is the caller graph for this function:

getAttribString()

const char* h2d::svg::svgp::getAttribString ( const char *  attribName, const tinyxml2::XMLElement &  e  )

inline

Helper function for SVG import.

Todo:

Who owns the data? Should we return a string and/or release the memory?

{
    const char *pts = e.Attribute( attribName );
    if( !pts )
        throw std::string("h2d::img::svg Error: unable to find attribute '") + attribName + "' in tag " + e.Name();
    return pts;
}

Here is the caller graph for this function:

getAttribValue()

double h2d::svg::svgp::getAttribValue ( const tinyxml2::XMLElement &  e, const char *  str, std::string  e_name  )

inline

Fetch attribute from XML element. Tag e_name is there just in case of trouble.

{
    double value=0.;
    if( tinyxml2::XML_SUCCESS != e.QueryDoubleAttribute( str, &value ) )
        HOMOG2D_THROW_ERROR_1( "h2d::svg::import error, failed to read attribute '"
            << std::string{str} << "' while reading element '" << e_name << "'" );
    return value;
}

Here is the caller graph for this function:

getCommand()

SvgPathCommand h2d::svg::svgp::getCommand ( char  c )

inline

{
    HOMOG2D_LOG( "search command for " << c );

    static std::string commands( "MLHVCSQTAZ" ); // allowed SVG path commands (and their counterparts relative)
    SvgPathCommand out;
    std::string str( 1, c );
    HOMOG2D_LOG( " str=" << str << " #=" << str.size() );
    auto pos = commands.find( str );
//  HOMOG2D_LOG( "pos=" << pos << " str=" << str );
    bool invalid = false;
    if( pos == std::string::npos )
    {
        if( c>='a' && c <= 'z' ) // check if lowercase
        {
            c = (char)((int)c+'A'-'a');
//          std::cout << "lowercase, new c=" << c << '\n';
            str[0] = c;
//          HOMOG2D_LOG( " str2=" << str << "#=" << str.size() );
            pos = commands.find( str );
            if( pos != std::string::npos )
                out._absRel = PathMode::Relative;
            else
                invalid = true;
        }
        else
            invalid = true;
    }
    if( invalid )
        HOMOG2D_THROW_ERROR_1(
                "Illegal character in SVG path element:-" << str
                << "- ascii=" << std::hex << str[0] << std::dec
        );

    out.setCommand( commands[pos] );

//  std::cout << "pos=" << pos << " _command=" << out._command << " _nbValues=" << (int)out._nbValues << '\n';
    return out;
}

Here is the call graph for this function:

Here is the caller graph for this function:

getEllipseRotateAttr()

std::pair<Point2d_<HOMOG2D_INUMTYPE>,HOMOG2D_INUMTYPE> h2d::svg::svgp::getEllipseRotateAttr ( const char *  rot_str )

inline

Importing rotated ellipse from SVG data.

{
    std::string s(rot_str);
//  std::cout << __FUNCTION__ << "(): " << s << "\n";
    auto v1 = tokenize( s, '(' );
    if( v1.size() == 2 )
        if( v1[0] == "rotate" )
        {
            auto v2 = v1[1].substr(0, v1[1].size() - 1 );
//          std::cout << __FUNCTION__ << "(): v2=" << v2 << "\n";
            auto v3 = tokenize( v2, ',' );
            if( v3.size() == 3 )
            {
                try  // in case of an incorrect numerical string
                {
                    auto angle = std::stod( v3[0] );
                    auto x0    = std::stod( v3[1] );
                    auto y0    = std::stod( v3[2] );
                    return std::make_pair( Point2d_<HOMOG2D_INUMTYPE>(x0,y0),angle*M_PI/180. );
                }
                catch( std::exception& err )
                {
                    HOMOG2D_THROW_ERROR_2( "invalid 'transform' attribute for svg ellipse import",  err.what() );
                }
            }
        }
    HOMOG2D_THROW_ERROR_1( "invalid 'transform' attribute for svg ellipse import" );
}

Here is the call graph for this function:

Here is the caller graph for this function:

getNextElem()

std::string h2d::svg::svgp::getNextElem ( const std::string &  str, std::string::const_iterator &  it  )

inline

Get next element in svg path string.

{
    std::string out;
    while( *it == ' ' || *it == ',' ) // skip spaces and commas
        it++;

    if( it >= str.cend() )
        return out;         // return empty string

    if( !isDigit(*it) )        // alpha character
    {
        out.push_back( *it );
        it++;
    }
    else
    {
        while( isDigit(*it) && it < str.cend() )
        {
            out.push_back( *it );
            it++;
        }
//      std::cout << "getNextElem() DIGITS:-" << out << "- #=" << out.size() << '\n';
//      return out;
    }
    return out;
}

Here is the call graph for this function:

Here is the caller graph for this function:

importSvgPoints()

std::vector<Point2d> h2d::svg::svgp::importSvgPoints ( const tinyxml2::XMLElement &  e )

inline

Helper function called by Visitor::VisitExit() to process Polyline/Polygons.

{
    auto pts_str = svgp::getAttribString( "points", e );
    auto vec_pts = svgp::parsePoints( pts_str );

    if( vec_pts.front() == vec_pts.back() ) // if first point equal to last
        vec_pts.pop_back();                  //  point, remove last point

    return vec_pts;
}

Here is the call graph for this function:

Here is the caller graph for this function:

isDigit()

bool h2d::svg::svgp::isDigit ( char  c )

inline

{
    return ( (c >= '0' && c <= '9') || c == '.' || c == '-' );
}

Here is the caller graph for this function:

numberValues()

std::map<char,int>& h2d::svg::svgp::numberValues ( )

inline

Returns nb of expected values for a given SVG path command. Ref: https://www.w3.org/TR/SVG2/paths.html.

{
    static std::map<char,int> nbval;
    nbval['M'] = 2; // M-m
    nbval['L'] = 2; // L-l
    nbval['H'] = 1; // H-h
    nbval['V'] = 1; // V-v
    nbval['C'] = 6; // C-c !NOT HANDLED!
    nbval['S'] = 4; // S-s !NOT HANDLED!
    nbval['Q'] = 4; // Q-q !NOT HANDLED!
    nbval['T'] = 2; // T t !NOT HANDLED!
    nbval['A'] = 7; // A-a !NOT HANDLED!
    nbval['Z'] = 0; // Z-z
    return nbval;
}

Here is the caller graph for this function:

parsePath()

auto h2d::svg::svgp::parsePath ( const char *  s )

inline

Parse a SVG "path" string and convert it to a vector holding a set (vector) of points.

Input string example:

m 261.68497,138.79393 2.57,3.15 -0.72,1.27 2.18,1.94 -0.7,4.93 1.88,0.9

The return value holds as 'second' a bool value, will be true if closed polyline

{
    SvgPathCommand mode;
    std::vector<std::vector<Point2d>> vout(1);
    SvgValuesBuffer values;
    std::string str(s);
    size_t idx = 0;
    HOMOG2D_LOG( "parsing string -" << str << "- #=" << str.size() );
    if( str.size() == 0 )
        HOMOG2D_THROW_ERROR_1( "SVG path string is empty" );

    auto it = str.cbegin();
    Point2d previousPt;
    do
    {
        auto e = getNextElem( str, it );
//      HOMOG2D_LOG( "parsing element -" << e << "- #=" << e.size() );

        if( e.size() == 1 && !isDigit(e[0]) ) // we have a command !
        {
            if( values.size() != 0 )              // if we have some values stored,
                values.storeValues( vout[idx], mode );  //  first process them and add new point

            mode = getCommand( e[0] );
            HOMOG2D_LOG( "command=" << e[0] );
            if( !svgPathCommandIsAllowed(mode._command) )
                HOMOG2D_THROW_ERROR_1( "SVG path command -" << mode._command << "- not handled" );

            if( mode.isNewPolyline() && !vout[idx].empty() )
            {
                vout.push_back( std::vector<Point2d>() );
                idx++;
                HOMOG2D_LOG( "NEW vector idx=" << idx );
            }
        }
        else // not a command, but a value
        {
//          HOMOG2D_LOG( "process value, values size=" << values.size() );
            if( values.size() == (size_t)mode._nbValues ) // already got enough values
                values.storeValues( vout[idx], mode );
            values.addValue( e );
        }
    }
    while( it < str.cend() );

    if( values.size() )                  // process remaining values that have been stored
        values.storeValues( vout[idx], mode );

    HOMOG2D_LOG( "Nb vectors=" << vout.size() );
    for( auto& v: vout )
        if( v.size() )
            v = purgeSetDupes( v );
    if( vout.back().empty() )
        vout.pop_back();

    return std::make_pair(
        vout,
        mode._command == 'Z' ? true : false
    );
}

Here is the call graph for this function:

Here is the caller graph for this function:

parsePoints()

std::vector<Point2d> h2d::svg::svgp::parsePoints ( const char *  pts )

inline

Svg import: Basic parsing of points that are in the format "10,20 30,40 50,60".

Todo:

20240326: this is used to import SVG polygon type. Maybe this can be replaced by the "path" import code?

{
    std::vector<Point2d> out;
    std::string s(pts);
//  std::cout << "processing " << s << '\n';
//  trimString( s );
    auto v1 = tokenize( s, ' ' );
    for( const auto& pt: v1 )
    {
        auto v2 = tokenize( pt, ',' );
        if( v2.size() != 2 )
            throw "h2d:img::svg: invalid point format in importing svg element: " + s;
        auto x = std::stod( v2[0] );
        auto y = std::stod( v2[1] );
        out.emplace_back( Point2d(x,y) );
    }
    return out;
}

Here is the call graph for this function:

Here is the caller graph for this function:

purgeSetDupes()

template<typename FPT >

std::vector<Point2d_<FPT> > h2d::svg::svgp::purgeSetDupes

(

const std::vector< Point2d_< FPT >> &

pts

)

Removes dupes in set of points. Needed when importing SVG files using a "path" command, because sometimes they hold duplicates points, and that can't be in polylines.

{
    std::vector<Point2d_<FPT>> out;
    out.reserve( pts.size() );
    for( auto it=pts.begin(); it!=std::prev(pts.end()); it++ )
    {
        const auto& elem = *it;
        const auto& next = *std::next(it);
        if( elem != next )
            out.push_back( elem );
    }
    out.push_back( pts.back() ); // add last one
    return out;
}

Here is the caller graph for this function:

svgPathCommandIsAllowed()

bool h2d::svg::svgp::svgPathCommandIsAllowed ( char  c )

inline

{
    if( c == 'M' || c == 'L' || c == 'H'|| c == 'V' || c == 'Z' )
        return true;
    return false;
}

Here is the caller graph for this function:

tokenize()

std::vector<std::string> h2d::svg::svgp::tokenize ( const std::string &  s, char  delim  )

inline

General string tokenizer, taken from http://stackoverflow.com/a/236803/193789.

• see also this one: http://stackoverflow.com/a/53878/193789

{
    std::vector<std::string> velems;
//    std::stringstream ss( TrimSpaces(s) );
    std::stringstream ss( s );
    std::string item;
    while( std::getline( ss, item, delim ) )
        velems.push_back(item);

    return velems;
}

Here is the caller graph for this function: