CUCubicSpline.h

//
//  CUCubicSpline.h
//  Cornell University Game Library (CUGL)
//
//  This module provides a class that represents a spline of cubic beziers. A
//  bezier spline is just a sequence of beziers joined together, so that the end
//  of one is the beginning of the other. Cubic beziers have four control points,
//  two for the vertex anchors and two for their tangents.
//
//  This class has been purposefully kept lightweight.  If you want to draw a
//  CubicSpline, you will need to allocate a Poly2 value for the spline using
//  the factory CubicSplineApproximator.  We have to turn shapes into polygons
//  to draw them anyway, and this allows us to do all of the cool things we can
//  already do with paths, like extrude them or create wireframes.
//
//  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/21/16
 
#ifndef __CU_CUBIC_SPLINE_H__
#define __CU_CUBIC_SPLINE_H__
 
#include "CUMathBase.h"
#include "CUVec2.h"
#include <vector>
 
namespace cugl {
 
class Polynomial;
 
class CubicSpline {
#pragma mark Values
private:
    int _size;
    
    std::vector<Vec2> _points;
    
    std::vector<bool>  _smooth;
    
    bool _closed;
    
    
#pragma mark -
#pragma mark Constructors
public:
    CubicSpline() : _size(0), _closed(false) {   }
    
    CubicSpline(const Vec2& point) : CubicSpline(point,point)  {    }
    
    CubicSpline(const Vec2& start, const Vec2& end);
    
    CubicSpline(const float* points, int size, int offset=0);
    
    CubicSpline(const std::vector<float>& points);
    
    CubicSpline(const std::vector<Vec2>& points);
    
    CubicSpline(const CubicSpline& spline);
 
    CubicSpline(CubicSpline&& spline) : _size(spline._size), _closed(spline._closed),
        _points(std::move(spline._points)), _smooth(std::move(spline._smooth)) {}
    
    ~CubicSpline() { }
 
#pragma mark -
#pragma mark Assignment Operators
 
    CubicSpline& operator=(const CubicSpline& spline) { return set(spline); }
    
    CubicSpline& operator=(CubicSpline&& spline) {
        _size = spline._size; _closed = spline._closed;
        _points = std::move(spline._points);
        _smooth = std::move(spline._smooth);
        return *this;
    }
    
    CubicSpline& set(const Vec2& point) { return set(point,point); }
    
    CubicSpline& set(const Vec2& start, const Vec2& end);
    
    CubicSpline& set(const float* points, int size, int offset=0);
    
    CubicSpline& set(const std::vector<float>& points);
    
    CubicSpline& set(const std::vector<Vec2>& points);
    
    CubicSpline& set(const CubicSpline& spline);
    
    
#pragma mark -
#pragma mark Attribute Accessors
 
    int getSize() const { return _size; }
    
    bool isClosed() const { return _closed; }
    
    void setClosed(bool flag);
    
    Vec2 getPoint(float tp) const { return getPoint((int)tp,tp-(int)tp); }
    
    void setPoint(float tp, const Vec2& point);
    
    Vec2 getAnchor(int index) const;
    
    void setAnchor(int index, const Vec2& point);
    
    bool getSmooth(int index) const;
    
    void setSmooth(int index, bool flag);
    
    Vec2 getTangent(int index) const;
    
    void setTangent(int index, const Vec2& tang, bool symmetric=false);
    
    Polynomial getPolynomialX(int segment) const;
    
    Polynomial getPolynomialY(int segment) const;
    
    const std::vector<Vec2> getControlPoints() const { return _points; }
    
    
#pragma mark -
#pragma mark Anchor Editting Methods
 
    int addAnchor(const Vec2& point) { return addAnchor(point,point); }
    
    int addAnchor(const Vec2& point, const Vec2& tang);
    
    void deleteAnchor(int index);
    
    void insertAnchor(float param)  { insertAnchor((int)param,param-(int)param); }
    
    void clear() {
        _points.clear(); _smooth.clear();
        _closed = false; _size = 0;
    }
    
#pragma mark -
#pragma mark Nearest Point Methods
 
    Vec2 nearestPoint(const Vec2& point) const { return getPoint(nearestParameter(point)); }
    
    float nearestParameter(const Vec2& point) const;
    
    int nearestAnchor(const Vec2& point, float threshold) const;
    
    int nearestTangent(const Vec2& point, float threshold) const;
    
    
#pragma mark -
#pragma mark Internal Helpers
protected:
    Vec2 getPoint(int segment, float tp) const;
    
    void insertAnchor(int segment, float param);
    
    void subdivide(int segment, float tp, std::vector<Vec2>& left, std::vector<Vec2>& rght) const {
        subdivide(_points,6*segment,tp,left,rght);
    }
    
    static void subdivide(const std::vector<Vec2>& src, int soff, float tp,
                          std::vector<Vec2>& left, std::vector<Vec2>& rght);
    Polynomial getProjectionPolynomial(const Vec2& point, int segment) const;
    
    Vec2 getProjectionSlow(const Vec2& point, int segment) const;
    
    Vec2 getProjectionFast(const Vec2& point, int segment) const;
  
    friend class CubicSplineApproximator;
};
 
}
#endif /* __CU_CUBIC_SPLINE_H__ */