Где найти код Transformation->Distort?

//   m_outline.tags   --->   char * tags;
//   m_tags   --->   std::vector<char> m_tags;
...
m_outline.tags = m_tags.data();

std::vector<point> m_points;
...
m_points.emplace_back(... , ...);

m_points.push_back(point(..., ...));

//------------------------------------------------------------------------------
// based on AGG library by Maxim Shemanarev
//------------------------------------------------------------------------------
 
#ifndef __TRANS_PERSPECTIVE_H__
#define __TRANS_PERSPECTIVE_H__
 
class trans_perspective {
    bool rect_to_quad( const point & p1, const point & p2, const point * quad ) {
        point r[4];
        r[0].x = r[3].x = p1.x;
        r[1].x = r[2].x = p2.x;
        r[0].y = r[1].y = p1.y;
        r[2].y = r[3].y = p2.y;
        return quad_to_quad( r, quad );
    }
 
    bool quad_to_quad( const point * qs, const point * qd ) {
        if ( !quad_to_square( qs ) ) return false;
        trans_perspective p;
        if ( !p.square_to_quad( qd ) ) return false;
        multiply( p );
        return true;
    }
 
    bool quad_to_square( const point * q ) {
        if ( !square_to_quad( q ) ) return false;
        invert();
        return true;
    }
 
    bool square_to_quad( const point * q ) {
        double dx = q[0].x - q[1].x + q[2].x - q[3].x;
        double dy = q[0].y - q[1].y + q[2].y - q[3].y;
        if ( dx == 0.0 && dy == 0.0 ) {
            // Affine case (parallelogram)
            //---------------
            sx  = q[1].x - q[0].x;
            shy = q[1].y - q[0].y;
            w0  = 0;
            shx = q[2].x - q[1].x;
            sy  = q[2].y - q[1].y;
            w1  = 0;
            tx  = q[0].x;
            ty  = q[0].y;
            w2  = 1;
        } else {
            double dx1 = q[1].x - q[2].x;
            double dy1 = q[1].y - q[2].y;
            double dx2 = q[3].x - q[2].x;
            double dy2 = q[3].y - q[2].y;
            double den = dx1 * dy2 - dx2 * dy1;
            if ( den == 0.0 ) {
                // Singular case
                //---------------
                sx = shy = w0 = shx = sy = w1 = tx = ty = w2 = 0;
                return false;
            }
 
            // General case
            //---------------
            double u = (dx * dy2 - dy * dx2) / den;
            double v = (dy * dx1 - dx * dy1) / den;
            sx  = q[1].x - q[0].x + u * q[1].x;
            shy = q[1].y - q[0].y + u * q[1].y;
            w0  = u;
            shx = q[3].x - q[0].x + v * q[3].x;
            sy  = q[3].y - q[0].y + v * q[3].y;
            w1  = v;
            tx  = q[0].x;
            ty  = q[0].y;
            w2  = 1;
        }
        return true;
    }
 
    const trans_perspective & multiply( const trans_perspective & a ) {
        trans_perspective b = *this;
        sx  = a.sx *b.sx  + a.shx*b.shy + a.tx*b.w0;
        shx = a.sx *b.shx + a.shx*b.sy  + a.tx*b.w1;
        tx  = a.sx *b.tx  + a.shx*b.ty  + a.tx*b.w2;
        shy = a.shy*b.sx  + a.sy *b.shy + a.ty*b.w0;
        sy  = a.shy*b.shx + a.sy *b.sy  + a.ty*b.w1;
        ty  = a.shy*b.tx  + a.sy *b.ty  + a.ty*b.w2;
        w0  = a.w0 *b.sx  + a.w1 *b.shy + a.w2*b.w0;
        w1  = a.w0 *b.shx + a.w1 *b.sy  + a.w2*b.w1;
        w2  = a.w0 *b.tx  + a.w1 *b.ty  + a.w2*b.w2;
        return *this;
    }
 
    // Invert matrix. Returns false in degenerate case
    bool invert() {
        double d0 = sy  * w2 - w1  * ty;
        double d1 = w0  * ty - shy * w2;
        double d2 = shy * w1 - w0  * sy;
        double d  = sx  * d0 + shx * d1 + tx * d2;
        if ( d == 0.0 ) {
            sx = shy = w0 = shx = sy = w1 = tx = ty = w2 = 0.0;
            return false;
        }
        d = 1.0 / d;
        trans_perspective a = *this;
        sx  = d * d0;
        shy = d * d1;
        w0  = d * d2;
        shx = d * (a.w1 *a.tx  - a.shx*a.w2);
        sy  = d * (a.sx *a.w2  - a.w0 *a.tx);
        w1  = d * (a.w0 *a.shx - a.sx *a.w1);
        tx  = d * (a.shx*a.ty  - a.sy *a.tx);
        ty  = d * (a.shy*a.tx  - a.sx *a.ty);
        w2  = d * (a.sx *a.sy  - a.shy*a.shx);
        return true;
    }
 
    double sx, shy, w0, shx, sy, w1, tx, ty, w2;
 
public:
    trans_perspective() :
        sx ( 1 ), shy( 0 ), w0( 0 ),
        shx( 0 ), sy ( 1 ), w1( 0 ),
        tx ( 0 ), ty ( 0 ), w2( 1 ) {}
 
    trans_perspective( const point & p1, const point & p2, const point * quad ) {
        rect_to_quad( p1, p2, quad );
    }
 
    bool is_valid( double epsilon = 1e-14 ) const {
        return fabs( sx ) > epsilon && fabs( sy ) > epsilon && fabs( w2 ) > epsilon;
    }
 
    void transform( point * pt ) const {
        point p = *pt;
        double m = 1. / (p.x * w0 + p.y * w1 + w2);
        pt->x = m * (p.x * sx  + p.y * shx + tx);
        pt->y = m * (p.x * shy + p.y * sy  + ty);
    }
};
 
#endif // __TRANS_PERSPECTIVE_H__