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 MIT 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 <cugl/math/CUPoly2.h>
#include <cugl/math/CUCubicSpline.h>
#include <cugl/math/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__ */