void SplinePath::compute(FollowablePath *path)
 {
     ASPC aspc(tol, gamma, path);
     
     for (int i = 0; i < size - 3; i++)
     {
         aspc.segment(&x[i], &y[i]);
     }
     
     if (path->mode == FollowablePath::MODE_LOOP)
     {
         path->add(path->x[0], path->y[0]);
     }
 }
예제 #2
0
void SplinePath::flush(SplineType type, std::vector<glm::vec2>& path, float tol) const {
    std::function<glm::vec2(float, glm::vec2*)> gamma;

    switch (type) {
    case SplineType::bspline:
        gamma = GammaBSpline;
        break;

    case SplineType::catmull_rom:
        gamma = GammaCatmullRom;
        break;

    default:
        return;
    }

    int size = points.size();

    if (size > 2) {
        ASPC aspc(gamma, path, tol);

        if (closed) {
            aspc.segment(points[size - 1], points[0], points[1], points[2]);
        } else {
            if (type == SplineType::bspline) {
                aspc.segment(points[0], points[0], points[0], points[1]);
            }

            aspc.segment(points[0], points[0], points[1], points[2]);
        }

        for (int i = 0; i < size - 3; i++) {
            aspc.segment(points[i], points[i + 1], points[i + 2], points[i + 3]);
        }

        if (closed) {
            aspc.segment(points[size - 3], points[size - 2], points[size - 1], points[0]);
            aspc.segment(points[size - 2], points[size - 1], points[0], points[1]);
        } else {
            aspc.segment(points[size - 3], points[size - 2], points[size - 1], points[size - 1]);
            aspc.segment(points[size - 2], points[size - 1], points[size - 1], points[size - 1]);

            if (type == SplineType::bspline) {
                aspc.segment(points[size - 1], points[size - 1], points[size - 1], points[size - 1]);
            }
        }
    }
}
예제 #3
0
    void SplinePath::flush(Type type, FollowablePath &path, float tol) const
    {
        function<Vec2f (float, Vec2f*)> gamma;
        
        switch (type)
        {
            case TYPE_BSPLINE:
                gamma = GammaBSpline;
                break;
                
            case TYPE_CATMULL_ROM:
                gamma = GammaCatmullRom;
                break;
                
            default:
                return;
        }
        
        int size = points.size();
        
        if (size > 2)
        {
            ASPC aspc(gamma, path, tol);
            
            if (closed)
            {
                aspc.segment(points[size - 1], points[0], points[1], points[2]);
            }
            else
            {
                if (type == TYPE_BSPLINE)
                {
                    aspc.segment(points[0], points[0], points[0], points[1]);
                }
                
                aspc.segment(points[0], points[0], points[1], points[2]);
            }

            for (int i = 0; i < size - 3; i++)
            {
                aspc.segment(points[i], points[i + 1], points[i + 2], points[i + 3]);
            }
            
            if (closed)
            {
                aspc.segment(points[size - 3], points[size - 2], points[size - 1], points[0]);
                aspc.segment(points[size - 2], points[size - 1], points[0], points[1]);
                
                path.close();
                path.setMode(FollowablePath::MODE_LOOP);
            }
            else
            {
                aspc.segment(points[size - 3], points[size - 2], points[size - 1], points[size - 1]);
                aspc.segment(points[size - 2], points[size - 1], points[size - 1], points[size - 1]);
                
                if (type == TYPE_BSPLINE)
                {
                    aspc.segment(points[size - 1], points[size - 1], points[size - 1], points[size - 1]);
                }
            }
        }
    }