From a7c9e4e127399d579ba526ae0dc36ab63e4b4c68 Mon Sep 17 00:00:00 2001 From: Dave Schuyler Date: Tue, 26 Dec 2000 22:52:06 +0000 Subject: [PATCH] removed hermite stuff --- panda/src/parametrics/curve.cxx | 122 +++++++++++--------------------- panda/src/parametrics/curve.h | 42 +++++------ 2 files changed, 57 insertions(+), 107 deletions(-) diff --git a/panda/src/parametrics/curve.cxx b/panda/src/parametrics/curve.cxx index a91a1ed0ff..9fdf8a9a29 100644 --- a/panda/src/parametrics/curve.cxx +++ b/panda/src/parametrics/curve.cxx @@ -1,9 +1,9 @@ // Filename: curve.C // Created by: drose (14Mar97) -// +// //////////////////////////////////////////////////////////////////// // Copyright (C) 1992,93,94,95,96,97 Walt Disney Imagineering, Inc. -// +// // These coded instructions, statements, data structures and // computer programs contain unpublished proprietary information of // Walt Disney Imagineering and are protected by Federal copyright @@ -18,7 +18,6 @@ #include "curve.h" #include "config_parametrics.h" -#include "hermiteCurve.h" #include "nurbsCurve.h" #include "curveDrawer.h" @@ -101,7 +100,7 @@ set_curve_type(int type) { case PCT_T: _num_dimensions = 1; break; - + default: assert(0); } @@ -204,7 +203,7 @@ calc_length(double from, double to) const { // new value of t. This function is quite expensive. //////////////////////////////////////////////////////////////////// double ParametricCurve:: -compute_t(double start_t, double length_offset, double guess, +compute_t(double start_t, double length_offset, double guess, double threshold) const { if (length_offset > 0.0) { // If the length_offset is positive, we are looking forward. @@ -234,7 +233,7 @@ compute_t(double start_t, double length_offset, double guess, double actual_length = calc_length(start_t, guess); double max_t = get_max_t(); bool clamped = false; - + // Are we close enough yet? cerr << "Got " << actual_length << " wanted " << length_offset << "\n"; while (fabs(actual_length - length_offset) > threshold) { @@ -242,18 +241,18 @@ compute_t(double start_t, double length_offset, double guess, // the t_offset should be if the curve were evenly distributed // across its entire range. guess = (guess - start_t) * length_offset / actual_length + start_t; - + // Clamp it to the end of the curve. if (guess > max_t) { if (clamped) { return max_t; - } + } clamped = true; guess = max_t; } else { clamped = false; } - + actual_length = calc_length(start_t, guess); cerr << "Got " << actual_length << " wanted " << length_offset << "\n"; } @@ -285,7 +284,7 @@ convert_to_nurbs(NurbsCurve &nc) const { nc.append_cv(bz_segs[i]._v[0]); nc.append_cv(bz_segs[i]._v[1]); nc.append_cv(bz_segs[i]._v[2]); - if (i == bz_segs.size()-1 || + if (i == bz_segs.size()-1 || !bz_segs[i]._v[3].almost_equal(bz_segs[i+1]._v[0], 0.0001)) { nc.append_cv(bz_segs[i]._v[3]); } @@ -300,12 +299,12 @@ convert_to_nurbs(NurbsCurve &nc) const { for (i = 0; i_segs.size()) { @@ -758,11 +757,11 @@ insert_curveseg(int ti, ParametricCurve *seg, double tlength) { _segs.push_back(Curveseg(seg, get_max_t() + tlength)); } else if (ti==0) { - _segs.insert(_segs.begin(), + _segs.insert(_segs.begin(), Curveseg(seg, tlength)); } else { - _segs.insert(_segs.begin() + ti, + _segs.insert(_segs.begin() + ti, Curveseg(seg, _segs[ti-1]._tend + tlength)); } @@ -887,7 +886,7 @@ make_nurbs(int order, int num_cvs, for (int i=0; i knots[i+order-1]) { int ti = get_num_segs(); - bool result = + bool result = insert_curveseg(ti, new CubicCurveseg(order, knots+i, cvs+i), knots[i+order] - knots[i+order-1]); assert(result); @@ -1014,7 +1013,7 @@ find_curve(const ParametricCurve *&curve, double &t) const { ti--; t = 1.0; } - + if (ti >= _segs.size()) { if (_segs.empty()) { curve = NULL; @@ -1075,7 +1074,7 @@ current_seg_range(double t) const { //////////////////////////////////////////////////////////////////// // Function: CubicCurveseg::Constructor // Access: Public -// Description: +// Description: //////////////////////////////////////////////////////////////////// CubicCurveseg:: CubicCurveseg() { @@ -1095,18 +1094,7 @@ CubicCurveseg(const LMatrix4f &basis) { Bw = basis.get_col(3); rational = true; } - -//////////////////////////////////////////////////////////////////// -// Function: CubicCurveseg::Constructor -// Access: Public -// Description: Creates the curveseg as a Hermite segment. -//////////////////////////////////////////////////////////////////// -CubicCurveseg:: -CubicCurveseg(const HermiteCurveCV &cv0, - const HermiteCurveCV &cv1) { - hermite_basis(cv0, cv1); -} - + //////////////////////////////////////////////////////////////////// // Function: CubicCurveseg::Constructor @@ -1136,7 +1124,7 @@ CubicCurveseg(int order, const double knots[], const LVector4f cvs[]) { // Function: CubicCurveseg::get_point // Access: Public, Scheme, Virtual // Description: Computes the surface point at a given parametric -// point t. +// point t. //////////////////////////////////////////////////////////////////// bool CubicCurveseg:: get_point(double t, LVector3f &point) const { @@ -1182,36 +1170,6 @@ get_2ndtangent(double t, LVector3f &tangent2) const { } -//////////////////////////////////////////////////////////////////// -// Function: CubicCurveseg::hermite_basis -// Access: Public -// Description: Defines the curve segment as a Hermite. This only -// sets up the basis vectors, so the curve will be -// computed correctly; it does not retain the CV's. -//////////////////////////////////////////////////////////////////// -void CubicCurveseg:: -hermite_basis(const HermiteCurveCV &cv0, - const HermiteCurveCV &cv1, - double tlength) { - static LMatrix4f - Mh(2, -3, 0, 1, - -2, 3, 0, 0, - 1, -2, 1, 0, - 1, -1, 0, 0); - - LVector4f Gx(cv0._p[0], cv1._p[0], - cv0._out[0]*tlength, cv1._in[0]*tlength); - LVector4f Gy(cv0._p[1], cv1._p[1], - cv0._out[1]*tlength, cv1._in[1]*tlength); - LVector4f Gz(cv0._p[2], cv1._p[2], - cv0._out[2]*tlength, cv1._in[2]*tlength); - - Bx = Gx * Mh; - By = Gy * Mh; - Bz = Gz * Mh; - rational = false; -} - //////////////////////////////////////////////////////////////////// // Function: CubicCurveseg::bezier_basis // Access: Public @@ -1221,7 +1179,7 @@ hermite_basis(const HermiteCurveCV &cv0, //////////////////////////////////////////////////////////////////// void CubicCurveseg:: bezier_basis(const BezierSeg &seg) { - static LMatrix4f + static LMatrix4f Mb(-1, 3, -3, 1, 3, -6, 3, 0, -3, 3, 0, 0, @@ -1295,7 +1253,7 @@ nurbs_blending_function(int order, int i, int j, } void -compute_nurbs_basis(int order, +compute_nurbs_basis(int order, const double knots_in[], LMatrix4f &basis) { int i; @@ -1331,7 +1289,7 @@ compute_nurbs_basis(int order, basis.set_row(i, LVector4f::zero()); } } - + //////////////////////////////////////////////////////////////////// @@ -1402,14 +1360,14 @@ GetBezierSeg(BezierSeg &seg) const { // We need this operator since Performer didn't supply it. -inline LVector4f +inline LVector4f operator * (const LMatrix4f &M, const LVector4f &v) { return LVector4f(M(0,0)*v[0] + M(0,1)*v[1] + M(0,2)*v[2] + M(0,3)*v[3], M(1,0)*v[0] + M(1,1)*v[1] + M(1,2)*v[2] + M(1,3)*v[3], M(2,0)*v[0] + M(2,1)*v[1] + M(2,2)*v[2] + M(2,3)*v[3], M(3,0)*v[0] + M(3,1)*v[1] + M(3,2)*v[2] + M(3,3)*v[3]); } - + //////////////////////////////////////////////////////////////////// // Function: compute_seg_col // Description: Interprets the parameters for a particular column of @@ -1419,7 +1377,7 @@ operator * (const LMatrix4f &M, const LVector4f &v) { static bool compute_seg_col(int c, int rtype, double t, const LVector4f &v, - const LMatrix4f &B, + const LMatrix4f &B, const LMatrix4f &Bi, const LMatrix4f &G, const LMatrix4f &GB, @@ -1439,7 +1397,7 @@ compute_seg_col(int c, P.set_col(c, v); } break; - + // RT_tangent defines the tangent to the curve at t. This is // the vector [ 3t^2 2t 1 0 ]. case RT_TANGENT: @@ -1451,7 +1409,7 @@ compute_seg_col(int c, P.set_col(c, v); } break; - + // RT_cv defines the cth control point. This is the cth column // vector from Bi. case RT_CV: @@ -1462,7 +1420,7 @@ compute_seg_col(int c, P.set_col(c, v); } break; - + default: cerr << "Invalid rebuild type in compute_seg\n"; return false; @@ -1527,7 +1485,7 @@ compute_seg(int rtype0, double t0, const LVector4f &v0, int rtype1, double t1, const LVector4f &v1, int rtype2, double t2, const LVector4f &v2, int rtype3, double t3, const LVector4f &v3, - const LMatrix4f &B, + const LMatrix4f &B, const LMatrix4f &Bi, LMatrix4f &G) { @@ -1582,7 +1540,7 @@ compute_seg(int rtype0, double t0, const LVector4f &v0, //////////////////////////////////////////////////////////////////// // Function: CubicCurveseg::Destructor // Access: Protected -// Description: +// Description: //////////////////////////////////////////////////////////////////// CubicCurveseg:: ~CubicCurveseg() { diff --git a/panda/src/parametrics/curve.h b/panda/src/parametrics/curve.h index c076c306fe..4f19d71460 100644 --- a/panda/src/parametrics/curve.h +++ b/panda/src/parametrics/curve.h @@ -1,9 +1,9 @@ // Filename: curve.h // Created by: drose (14Mar97) -// +// //////////////////////////////////////////////////////////////////// // Copyright (C) 1992,93,94,95,96,97 Walt Disney Imagineering, Inc. -// +// // These coded instructions, statements, data structures and // computer programs contain unpublished proprietary information of // Walt Disney Imagineering and are protected by Federal copyright @@ -16,7 +16,7 @@ #define CURVE_H //////////////////////////////////////////////////////////////////// -// Includes +// Includes //////////////////////////////////////////////////////////////////// #include "pandabase.h" @@ -32,7 +32,7 @@ using namespace std; //////////////////////////////////////////////////////////////////// -// Defines +// Defines //////////////////////////////////////////////////////////////////// // Parametric curve semantic types. A parametric curve may have one @@ -71,8 +71,6 @@ END_PUBLISH //] class ParametricCurveDrawer; -class HermiteCurveCV; -class HermiteCurve; class NurbsCurve; @@ -102,10 +100,9 @@ PUBLISHED: float calc_length() const; float calc_length(double from, double to) const; - double compute_t(double start_t, double length_offset, double guess, + double compute_t(double start_t, double length_offset, double guess, double threshold) const; - ////bool convert_to_hermite(HermiteCurve &hc) const; bool convert_to_nurbs(NurbsCurve &nc) const; void ascii_draw() const; @@ -130,7 +127,7 @@ public: ParametricCurve(); - virtual void write_datagram(BamWriter *, Datagram &); + virtual void write_datagram(BamWriter *, Datagram &); virtual bool GetBezierSegs(BezierSegs &) const { return false; @@ -170,7 +167,7 @@ public: return get_class_type(); } virtual TypeHandle force_init_type() {init_type(); return get_class_type();} - + private: static TypeHandle _type_handle; }; @@ -198,11 +195,11 @@ PUBLISHED: virtual bool get_pt(double t, LVector3f &point, LVector3f &tangent) const; virtual bool get_2ndtangent(double t, LVector3f &tangent2) const; - bool adjust_point(double t, + bool adjust_point(double t, float px, float py, float pz); - bool adjust_tangent(double t, + bool adjust_tangent(double t, float tx, float ty, float tz); - bool adjust_pt(double t, + bool adjust_pt(double t, float px, float py, float pz, float tx, float ty, float tz); @@ -219,7 +216,7 @@ public: bool remove_curveseg(int ti); void remove_all_curvesegs(); - + double get_tlength(int ti) const; double get_tstart(int ti) const; double get_tend(int ti) const; @@ -272,13 +269,13 @@ public: return get_class_type(); } virtual TypeHandle force_init_type() {init_type(); return get_class_type();} - + private: static TypeHandle _type_handle; }; - + //////////////////////////////////////////////////////////////////// // Class : CubicCurveseg @@ -322,19 +319,14 @@ PUBLISHED: public: CubicCurveseg(); CubicCurveseg(const LMatrix4f &basis); - CubicCurveseg(const HermiteCurveCV &cv0, - const HermiteCurveCV &cv1); CubicCurveseg(const BezierSeg &seg); CubicCurveseg(int order, const double knots[], const LVector4f cvs[]); - void hermite_basis(const HermiteCurveCV &cv0, - const HermiteCurveCV &cv1, - double tlength = 1.0); void bezier_basis(const BezierSeg &seg); void nurbs_basis(int order, const double knots[], const LVector4f cvs[]); // evaluate_point() and evaluate_vector() both evaluate the curve at - // a given point by applying the basis vector against the vector + // a given point by applying the basis vector against the vector // [t3 t2 t 1] (or some derivative). The difference between the // two is that evaluate_point() is called only with the vector // [t3 t2 t 1] and computes a point in three-space and will scale by @@ -363,7 +355,7 @@ public: int rtype1, double t1, const LVector4f &v1, int rtype2, double t2, const LVector4f &v2, int rtype3, double t3, const LVector4f &v3, - const LMatrix4f &B, + const LMatrix4f &B, const LMatrix4f &Bi, LMatrix4f &G); @@ -387,14 +379,14 @@ public: return get_class_type(); } virtual TypeHandle force_init_type() {init_type(); return get_class_type();} - + private: static TypeHandle _type_handle; }; // This function is used internally to build the NURBS basis matrix // based on a given knot sequence. -void compute_nurbs_basis(int order, +void compute_nurbs_basis(int order, const double knots_in[], LMatrix4f &basis);