bezier.h

Go to the documentation of this file.

/*
 * bezier.h
 *
 * Copyright (c) 2003 Thomas A. Vaughan
 * All rights reserved.
 *
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the <organization> nor the
 *       names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THOMAS A. VAUGHAN ''AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THOMAS A. VAUGHAN BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 *
 * Bezier utilities
 */

#ifndef WAVEPACKET_BEZIER_H__
#define WAVEPACKET_BEZIER_H__


// includes --------------------------------------------------------------------
#include "common/common.h"
#include "threadsafe/smart_ptr.h"

#include "geometry/geometry_2d.h"

/// \ingroup geometric
/*@{*/

////////////////////////////////////////////////////////////////////////////////
///
/// \defgroup bezier Bezier Curves
///
/// Collection of objects and APIs intended to be helpful with bezier curves.
///
////////////////////////////////////////////////////////////////////////////////

/*@{*/


// bezier namespace
namespace bezier {


typedef point2d_t<float> point_t;
typedef rect2d_t<float> rect_t;

/**
 * paramaterized bezier curve
 *
 * A (3rd-order) bezier curve is parameterized on t, 0 <= t <= 1, satisfying:
 *
 *      x(t) = ax * t^3 + bx * t^2 + cx * t + x0
 *      y(t) = ay * t^3 + by * t^2 + cy * t + y0
 */
struct curve_t {
        // manipulators
        void clear(void) throw() {
                ax = ay = bx = by = cx = cy = x0 = y0 = 0.0;
        }
        void getPointAtT(IN float t, OUT point_t& pt) const throw() {
                ASSERT((t + 1.0e-8) >= 0.0 && (t - 1.0e-8) <= 1.0,
                    "Bad parameter value: t=%f", t);
                pt.x = ax * t * t * t + bx * t * t + cx * t + x0;
                pt.y = ay * t * t * t + by * t * t + cy * t + y0;
        }

        // data fields
        float   ax, ay;         // 3rd-order coefficient
        float   bx, by;         // 2nd-order coefficient
        float   cx, cy;         // 1st-order coefficient
        float   x0, y0;         // constant
};



/**
 * bezier curve specified by control points
 *
 * a = (1 - t)
 *
 * p(t) = a^3 p0 + 3 a^2 t p1 + 3 a t^2 p2 + t^3 p3
 */
struct control_points_t {
        void clear(void) throw() {
                        p0 = p1 = p2 = p3 = point_t(0.0, 0.0);
                }

        void setFromPointsAndTangents(IN const point_t& q0,     // initial point
                                IN const point_t& t0,   // tangent at q0
                                IN const point_t& q1,   // final point
                                IN const point_t& t1) throw() {
                        p0 = q0;        // initial point
                        p3 = q1;        // final point
                        float inv3 = 1.0 / 3.0;
                        p1.x = p0.x + inv3 * t0.x;
                        p1.y = p0.y + inv3 * t0.y;
                        p2.x = p3.x - inv3 * t1.x;
                        p2.y = p3.y - inv3 * t1.y;
                }

        void dump(IN const char * title) const throw() {
                        DPRINTF("%s (bezier control points): ", title);
                        p0.dump("p0");
                        p1.dump("p1");
                        p2.dump("p2");
                        p3.dump("p3");
                }

        // data fields
        point_t         p0;
        point_t         p1;
        point_t         p2;
        point_t         p3;
};



////////////////////////////////////////////////////////////////////////////////
//
//      Bezier APIs
//
////////////////////////////////////////////////////////////////////////////////

void getCurveFromControlPoints(IN const control_points_t& cp,
                                OUT curve_t& b) throw();

void getControlPointsFromCurve(IN const curve_t& b,
                                OUT control_points_t& cp) throw();

void getRect(IN const curve_t& curve, OUT rect_t& rect) throw();

void scale(IO curve_t& curve, IN float factor) throw();

void write(IN const curve_t& curve, OUT std::string& value,
                        IN float eps) throw();

void read(IN const char * value, OUT curve_t& curve);


};      // bezier namespace

#endif  // WAVEPACKET_BEZIER_H__