CUCubicSplineApproximator.h

//
//  CUCubicSplineApproximator.h
//  Cornell University Game Library (CUGL)
//
//  This module is a factory for producing Poly2 objects from CubicSpline.
//  In previous interations, this functionality was embedded in the CubicSpline
//  class.  That made that class much more heavyweight than we wanted for a
//  a simple math class.  By separating this out as a factory, we allow ourselves
//  the option of moving these calculations to a worker thread if necessary.
//
//  Because math objects are intended to be on the stack, we do not provide
//  any shared pointer support in this class.
//
//  CUGL zlib License:
//      This software is provided 'as-is', without any express or implied
//      warranty.  In no event will the authors be held liable for any damages
//      arising from the use of this software.
//
//      Permission is granted to anyone to use this software for any purpose,
//      including commercial applications, and to alter it and redistribute it
//      freely, subject to the following restrictions:
//
//      1. The origin of this software must not be misrepresented; you must not
//      claim that you wrote the original software. If you use this software
//      in a product, an acknowledgment in the product documentation would be
//      appreciated but is not required.
//
//      2. Altered source versions must be plainly marked as such, and must not
//      be misrepresented as being the original software.
//
//      3. This notice may not be removed or altered from any source distribution.
//
//  Author: Walker White
//  Version: 6/22/16

#ifndef __CU_CUBIC_SPLINE_APPROXIMATOR_H__
#define __CU_CUBIC_SPLINE_APPROXIMATOR_H__

#include "../CUPoly2.h"
#include "../CUCubicSpline.h"
#include "../CUVec2.h"
#include <vector>

#define DEFAULT_TOLERANCE   0.25

namespace cugl {

class CubicSplineApproximator {
#pragma mark Values
private:
    const CubicSpline* _spline;
    std::vector<Vec2>  _pointbuff;
    std::vector<float> _parambuff;
    bool _closed;
    bool _calculated;
    
public:
    enum Criterion {
        FLAT,
        
        DISTANCE,
        
        SPACING
    };

#pragma mark -
#pragma mark Constructors

    CubicSplineApproximator() : _spline(nullptr), _calculated(false) { }

    CubicSplineApproximator(const CubicSpline* spline) : _spline(spline), _calculated(false) { }

    ~CubicSplineApproximator();
    

#pragma mark -
#pragma mark Initialization

    void set(const CubicSpline* spline) {
        reset();
        _spline = spline;
    }

    void reset() {
        _calculated = false;
        _pointbuff.clear(); _parambuff.clear();
    }

    void clear() {
        _calculated = false;
        _spline = nullptr;
        _pointbuff.clear(); _parambuff.clear();
    }


#pragma mark -
#pragma mark Calculation

    void calculate(Criterion criterion=Criterion::DISTANCE, float tolerance=DEFAULT_TOLERANCE);
    

#pragma mark -
#pragma mark Materialization

    Poly2 getPath() const;

    Poly2* getPath(Poly2* buffer) const;

    std::vector<float> getParameters() const;
    
    size_t getParameters(std::vector<float> buffer);
    
    std::vector<Vec2> getTangents() const;
    
    size_t getTangents(std::vector<Vec2> buffer);

    Poly2* getTangents(Poly2* buffer);

    std::vector<Vec2> getNormals() const;

    size_t getNormals(std::vector<Vec2> buffer);

    Poly2* getNormals(Poly2* buffer);
    
    Poly2 getAnchors(float radius, int segments=4) const;
    
    Poly2* getAnchors(Poly2* buffer, float radius, int segments=4) const;
    
    Poly2 getHandles(float radius, int segments=4) const;

    Poly2* getHandles(Poly2* buffer, float radius, int segments=4) const;

    CubicSpline getRefinement() const;
    
    CubicSpline* getRefinement(CubicSpline* buffer) const;

#pragma mark -
#pragma mark Internal Data Generation
private:
    int generate(const std::vector<Vec2>& src, int soff, float tp,
                 float tolerance, Criterion criterion, int depth);

    const std::vector<Vec2>* getActivePoints() const {
        return (_calculated ? &_pointbuff : (_spline ? &(_spline->_points) : nullptr));
    }
    
    bool isClosed() const {
        return (_calculated ? _closed : (_spline ? _spline->_closed : false));
    }
};

}
#endif /* __CU_CUBIC_SPLINE_APPROXIMATOR_H__ */