253 lines
6.5 KiB
C++
253 lines
6.5 KiB
C++
/*
|
|
Copyright (C) 2001-2006, William Joseph.
|
|
All Rights Reserved.
|
|
|
|
This file is part of GtkRadiant.
|
|
|
|
GtkRadiant is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2 of the License, or
|
|
(at your option) any later version.
|
|
|
|
GtkRadiant is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with GtkRadiant; if not, write to the Free Software
|
|
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*/
|
|
|
|
#if !defined( INCLUDED_MATH_CURVE_H )
|
|
#define INCLUDED_MATH_CURVE_H
|
|
|
|
/// \file
|
|
/// \brief Curve data types and related operations.
|
|
|
|
#include "debugging/debugging.h"
|
|
#include "container/array.h"
|
|
#include <math/matrix.h>
|
|
|
|
|
|
template<typename I, typename Degree>
|
|
struct BernsteinPolynomial
|
|
{
|
|
static double apply( double t ){
|
|
return 1; // general case not implemented
|
|
}
|
|
};
|
|
|
|
typedef IntegralConstant<0> Zero;
|
|
typedef IntegralConstant<1> One;
|
|
typedef IntegralConstant<2> Two;
|
|
typedef IntegralConstant<3> Three;
|
|
typedef IntegralConstant<4> Four;
|
|
|
|
template<>
|
|
struct BernsteinPolynomial<Zero, Zero>
|
|
{
|
|
static double apply( double t ){
|
|
return 1;
|
|
}
|
|
};
|
|
|
|
template<>
|
|
struct BernsteinPolynomial<Zero, One>
|
|
{
|
|
static double apply( double t ){
|
|
return 1 - t;
|
|
}
|
|
};
|
|
|
|
template<>
|
|
struct BernsteinPolynomial<One, One>
|
|
{
|
|
static double apply( double t ){
|
|
return t;
|
|
}
|
|
};
|
|
|
|
template<>
|
|
struct BernsteinPolynomial<Zero, Two>
|
|
{
|
|
static double apply( double t ){
|
|
return ( 1 - t ) * ( 1 - t );
|
|
}
|
|
};
|
|
|
|
template<>
|
|
struct BernsteinPolynomial<One, Two>
|
|
{
|
|
static double apply( double t ){
|
|
return 2 * ( 1 - t ) * t;
|
|
}
|
|
};
|
|
|
|
template<>
|
|
struct BernsteinPolynomial<Two, Two>
|
|
{
|
|
static double apply( double t ){
|
|
return t * t;
|
|
}
|
|
};
|
|
|
|
template<>
|
|
struct BernsteinPolynomial<Zero, Three>
|
|
{
|
|
static double apply( double t ){
|
|
return ( 1 - t ) * ( 1 - t ) * ( 1 - t );
|
|
}
|
|
};
|
|
|
|
template<>
|
|
struct BernsteinPolynomial<One, Three>
|
|
{
|
|
static double apply( double t ){
|
|
return 3 * ( 1 - t ) * ( 1 - t ) * t;
|
|
}
|
|
};
|
|
|
|
template<>
|
|
struct BernsteinPolynomial<Two, Three>
|
|
{
|
|
static double apply( double t ){
|
|
return 3 * ( 1 - t ) * t * t;
|
|
}
|
|
};
|
|
|
|
template<>
|
|
struct BernsteinPolynomial<Three, Three>
|
|
{
|
|
static double apply( double t ){
|
|
return t * t * t;
|
|
}
|
|
};
|
|
|
|
typedef Array<Vector3> ControlPoints;
|
|
|
|
inline Vector3 CubicBezier_evaluate( const Vector3* firstPoint, double t ){
|
|
Vector3 result( 0, 0, 0 );
|
|
double denominator = 0;
|
|
|
|
{
|
|
double weight = BernsteinPolynomial<Zero, Three>::apply( t );
|
|
result += vector3_scaled( *firstPoint++, weight );
|
|
denominator += weight;
|
|
}
|
|
{
|
|
double weight = BernsteinPolynomial<One, Three>::apply( t );
|
|
result += vector3_scaled( *firstPoint++, weight );
|
|
denominator += weight;
|
|
}
|
|
{
|
|
double weight = BernsteinPolynomial<Two, Three>::apply( t );
|
|
result += vector3_scaled( *firstPoint++, weight );
|
|
denominator += weight;
|
|
}
|
|
{
|
|
double weight = BernsteinPolynomial<Three, Three>::apply( t );
|
|
result += vector3_scaled( *firstPoint++, weight );
|
|
denominator += weight;
|
|
}
|
|
|
|
return result / denominator;
|
|
}
|
|
|
|
inline Vector3 CubicBezier_evaluateMid( const Vector3* firstPoint ){
|
|
return vector3_scaled( firstPoint[0], 0.125 )
|
|
+ vector3_scaled( firstPoint[1], 0.375 )
|
|
+ vector3_scaled( firstPoint[2], 0.375 )
|
|
+ vector3_scaled( firstPoint[3], 0.125 );
|
|
}
|
|
|
|
inline Vector3 CatmullRom_evaluate( const ControlPoints& controlPoints, double t ){
|
|
// scale t to be segment-relative
|
|
t *= double(controlPoints.size() - 1);
|
|
|
|
// subtract segment index;
|
|
std::size_t segment = 0;
|
|
for ( std::size_t i = 0; i < controlPoints.size() - 1; ++i )
|
|
{
|
|
if ( t <= double(i + 1) ) {
|
|
segment = i;
|
|
break;
|
|
}
|
|
}
|
|
t -= segment;
|
|
|
|
const double reciprocal_alpha = 1.0 / 3.0;
|
|
|
|
Vector3 bezierPoints[4];
|
|
bezierPoints[0] = controlPoints[segment];
|
|
bezierPoints[1] = ( segment > 0 )
|
|
? controlPoints[segment] + vector3_scaled( controlPoints[segment + 1] - controlPoints[segment - 1], reciprocal_alpha * 0.5 )
|
|
: controlPoints[segment] + vector3_scaled( controlPoints[segment + 1] - controlPoints[segment], reciprocal_alpha );
|
|
bezierPoints[2] = ( segment < controlPoints.size() - 2 )
|
|
? controlPoints[segment + 1] + vector3_scaled( controlPoints[segment] - controlPoints[segment + 2], reciprocal_alpha * 0.5 )
|
|
: controlPoints[segment + 1] + vector3_scaled( controlPoints[segment] - controlPoints[segment + 1], reciprocal_alpha );
|
|
bezierPoints[3] = controlPoints[segment + 1];
|
|
return CubicBezier_evaluate( bezierPoints, t );
|
|
}
|
|
|
|
typedef Array<float> Knots;
|
|
|
|
inline double BSpline_basis( const Knots& knots, std::size_t i, std::size_t degree, double t ){
|
|
if ( degree == 0 ) {
|
|
if ( knots[i] <= t
|
|
&& t < knots[i + 1]
|
|
&& knots[i] < knots[i + 1] ) {
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
double leftDenom = knots[i + degree] - knots[i];
|
|
double left = ( leftDenom == 0 ) ? 0 : ( ( t - knots[i] ) / leftDenom ) * BSpline_basis( knots, i, degree - 1, t );
|
|
double rightDenom = knots[i + degree + 1] - knots[i + 1];
|
|
double right = ( rightDenom == 0 ) ? 0 : ( ( knots[i + degree + 1] - t ) / rightDenom ) * BSpline_basis( knots, i + 1, degree - 1, t );
|
|
return left + right;
|
|
}
|
|
|
|
inline Vector3 BSpline_evaluate( const ControlPoints& controlPoints, const Knots& knots, std::size_t degree, double t ){
|
|
Vector3 result( 0, 0, 0 );
|
|
for ( std::size_t i = 0; i < controlPoints.size(); ++i )
|
|
{
|
|
result += vector3_scaled( controlPoints[i], BSpline_basis( knots, i, degree, t ) );
|
|
}
|
|
return result;
|
|
}
|
|
|
|
typedef Array<float> NURBSWeights;
|
|
|
|
inline Vector3 NURBS_evaluate( const ControlPoints& controlPoints, const NURBSWeights& weights, const Knots& knots, std::size_t degree, double t ){
|
|
Vector3 result( 0, 0, 0 );
|
|
double denominator = 0;
|
|
for ( std::size_t i = 0; i < controlPoints.size(); ++i )
|
|
{
|
|
double weight = weights[i] * BSpline_basis( knots, i, degree, t );
|
|
result += vector3_scaled( controlPoints[i], weight );
|
|
denominator += weight;
|
|
}
|
|
return result / denominator;
|
|
}
|
|
|
|
inline void KnotVector_openUniform( Knots& knots, std::size_t count, std::size_t degree ){
|
|
knots.resize( count + degree + 1 );
|
|
|
|
std::size_t equalKnots = 1;
|
|
|
|
for ( std::size_t i = 0; i < equalKnots; ++i )
|
|
{
|
|
knots[i] = 0;
|
|
knots[knots.size() - ( i + 1 )] = 1;
|
|
}
|
|
|
|
std::size_t difference = knots.size() - 2 * ( equalKnots );
|
|
for ( std::size_t i = 0; i < difference; ++i )
|
|
{
|
|
knots[i + equalKnots] = Knots::value_type( double(i + 1) * 1.0 / double(difference + 1) );
|
|
}
|
|
}
|
|
|
|
#endif
|