659 lines
17 KiB
C++
659 lines
17 KiB
C++
|
|
|
|
#ifndef T_CURVES_INCLUDED
|
|
#define T_CURVES_INCLUDED
|
|
|
|
#include "tgeometry.h"
|
|
|
|
#undef DVAPI
|
|
#undef DVVAR
|
|
#ifdef TGEOMETRY_EXPORTS
|
|
#define DVAPI DV_EXPORT_API
|
|
#define DVVAR DV_EXPORT_VAR
|
|
#else
|
|
#define DVAPI DV_IMPORT_API
|
|
#define DVVAR DV_IMPORT_VAR
|
|
#endif
|
|
|
|
//=============================================================================
|
|
/*!
|
|
TSegment Class to manage a segment
|
|
*/
|
|
class DVAPI TSegment
|
|
{
|
|
protected:
|
|
TPointD m_c0, m_c1;
|
|
|
|
public:
|
|
TSegment()
|
|
: m_c0(), m_c1(){};
|
|
|
|
//! p0,p1 are the two control points
|
|
TSegment(const TPointD &p0, const TPointD &p1)
|
|
: m_c0(p0), m_c1(p1 - p0) {}
|
|
|
|
TSegment(double x0, double y0,
|
|
double x1, double y1)
|
|
: m_c0(x0, y0), m_c1(x1 - x0, y1 - y0) {}
|
|
|
|
TSegment(const TSegment &src)
|
|
: m_c0(src.m_c0), m_c1(src.m_c1) {}
|
|
|
|
//!Return the point of segment at parameter \b t.
|
|
TPointD getPoint(double t) const
|
|
{
|
|
return m_c0 + t * m_c1;
|
|
};
|
|
|
|
//!Return speed of segment.
|
|
TPointD getSpeed(double = 0) const
|
|
{
|
|
return m_c1;
|
|
};
|
|
|
|
//!Return first control point \b P0.
|
|
TPointD getP0() const { return m_c0; }
|
|
//!Return second control point \b P1.
|
|
TPointD getP1() const { return m_c0 + m_c1; }
|
|
|
|
//!Set the value of first control point \b P0 to \b p.
|
|
void setP0(const TPointD &p)
|
|
{
|
|
m_c1 += m_c0 - p;
|
|
m_c0 = p;
|
|
}
|
|
//!Set the value of second control point \b P1 to \b p.
|
|
void setP1(const TPointD &p) { m_c1 = p - m_c0; }
|
|
|
|
bool operator==(const TSegment &c) const
|
|
{
|
|
return m_c0 == c.m_c0 && m_c1 == c.m_c1;
|
|
};
|
|
|
|
bool operator!=(const TSegment &c) const
|
|
{
|
|
return !operator==(c);
|
|
};
|
|
|
|
//!Return rect that contains the segment.
|
|
TRectD getBBox() const
|
|
{
|
|
return TRectD(getP0(), getP1());
|
|
}
|
|
|
|
//!Return the length of segment
|
|
double getLength() const
|
|
{
|
|
return norm(m_c1);
|
|
}
|
|
|
|
//!Return true if segment is a point
|
|
bool isPoint(double err2 = TConsts::epsilon) const
|
|
{
|
|
return norm2(m_c1) < err2;
|
|
}
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
DVAPI ostream &operator<<(ostream &out, const TSegment &segment);
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
//!\relates TAffine, TSegment
|
|
inline TSegment operator*(const TAffine &aff, const TSegment &seg)
|
|
{
|
|
return TSegment(aff * seg.getP0(), aff * seg.getP1());
|
|
}
|
|
|
|
//=============================================================================
|
|
/*!
|
|
TQuadratic class to manage a quadratic
|
|
*/
|
|
class DVAPI TQuadratic
|
|
{
|
|
protected:
|
|
TPointD
|
|
m_p0,
|
|
m_p1,
|
|
m_p2;
|
|
|
|
public:
|
|
TQuadratic()
|
|
: m_p0(), m_p1(), m_p2() {}
|
|
|
|
//! p0,p1,p2 are the three control points
|
|
TQuadratic(const TPointD &p0,
|
|
const TPointD &p1,
|
|
const TPointD &p2)
|
|
: m_p0(p0), m_p1(p1), m_p2(p2) {}
|
|
|
|
TQuadratic(const TQuadratic &src)
|
|
: m_p0(src.m_p0), m_p1(src.m_p1), m_p2(src.m_p2) {}
|
|
|
|
TQuadratic &operator=(const TQuadratic &src)
|
|
{
|
|
m_p0 = src.m_p0;
|
|
m_p1 = src.m_p1;
|
|
m_p2 = src.m_p2;
|
|
return *this;
|
|
}
|
|
|
|
//!Return the point of quadratic at parameter \b t.
|
|
TPointD getPoint(double t) const;
|
|
double getX(double t) const;
|
|
double getY(double t) const;
|
|
|
|
//!Return speed of quadratic at parameter \b t.
|
|
TPointD getSpeed(double t) const
|
|
{
|
|
return 2 * ((t - 1) * m_p0 + (1.0 - 2.0 * t) * m_p1 + t * m_p2);
|
|
}
|
|
|
|
//!Return the y value of quadratic speed at parameter \b t.
|
|
double getSpeedY(double t) const
|
|
{
|
|
return 2 * ((t - 1) * m_p0.y + (1.0 - 2.0 * t) * m_p1.y + t * m_p2.y);
|
|
}
|
|
|
|
//!Return acceleration of quadratic.
|
|
TPointD getAcceleration(double = 0) const
|
|
{
|
|
return 2.0 * (m_p0 + m_p2 - 2.0 * m_p1);
|
|
}
|
|
|
|
//! Return curvature of quadratic at parameter \b t.
|
|
/*! Calcolo della curvatura per una Quadratica.
|
|
Vedi Farin pag.176 per la spiegazione della formula
|
|
usata.
|
|
*/
|
|
double getCurvature(double t) const;
|
|
|
|
//!Return first control point \b P0.
|
|
TPointD getP0() const { return m_p0; }
|
|
//!Return second control point \b P1.
|
|
TPointD getP1() const { return m_p1; }
|
|
//!Return third control point \b P2.
|
|
TPointD getP2() const { return m_p2; }
|
|
|
|
//!Set the value of first control point \b P0 to \b p.
|
|
void setP0(const TPointD &p) { m_p0 = p; }
|
|
//!Set the value of second control point \b P1 to \b p.
|
|
void setP1(const TPointD &p) { m_p1 = p; }
|
|
//!Set the value of third control point \b P2 to \b p.
|
|
void setP2(const TPointD &p) { m_p2 = p; }
|
|
|
|
bool operator==(const TQuadratic &c) const
|
|
{
|
|
return m_p0 == c.m_p0 && m_p1 == c.m_p1 && m_p2 == c.m_p2;
|
|
}
|
|
|
|
bool operator!=(const TQuadratic &c) const
|
|
{
|
|
return !operator==(c);
|
|
}
|
|
|
|
//!Return a parameter that correspond to the point \b p in the quadratic.
|
|
double getT(const TPointD &p) const;
|
|
|
|
int getX(double y, double &x0, double &x1) const;
|
|
|
|
int getY(double x, double &y0, double &y1) const;
|
|
|
|
/*!
|
|
N.B. if t==0 o t==1 return a quadratic with all points equal
|
|
*/
|
|
void split(double t, TQuadratic &first, TQuadratic &second) const;
|
|
|
|
//!Return rect that contains the quadratic.
|
|
TRectD getBBox() const;
|
|
|
|
/*!
|
|
Return length of an arc between parameters t0 t1.
|
|
N.B. Length returned is always positive.
|
|
\note t0 and t1 are clamped to [0,1] interval
|
|
\note if t0>=t1 returns 0
|
|
*/
|
|
double getLength(double t0, double t1) const;
|
|
|
|
double getLength(double t1 = 1) const
|
|
{
|
|
return getLength(0, t1);
|
|
}
|
|
|
|
double getApproximateLength(double t0, double t1, double error) const;
|
|
|
|
void reverse()
|
|
{
|
|
TPointD app;
|
|
app = m_p0;
|
|
m_p0 = m_p2;
|
|
m_p2 = app;
|
|
}
|
|
};
|
|
|
|
//-------------------------------------------------------
|
|
|
|
//!\relates TAffine, TQuadratic
|
|
inline TQuadratic operator*(const TAffine &aff, const TQuadratic &curve)
|
|
{
|
|
TQuadratic quad;
|
|
quad.setP0(aff * curve.getP0());
|
|
quad.setP1(aff * curve.getP1());
|
|
quad.setP2(aff * curve.getP2());
|
|
return quad;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
DVAPI ostream &operator<<(ostream &out, const TQuadratic &curve);
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
inline ostream &operator<<(ostream &out, const TQuadratic *curve)
|
|
{
|
|
assert(curve);
|
|
return out << *curve;
|
|
}
|
|
|
|
//=============================================================================
|
|
/*!
|
|
TCubic class to manage a cubic
|
|
*/
|
|
class DVAPI TCubic
|
|
{
|
|
protected:
|
|
TPointD m_p0, m_p1, m_p2, m_p3;
|
|
|
|
public:
|
|
TCubic()
|
|
: m_p0(), m_p1(), m_p2(), m_p3() {}
|
|
|
|
//! p0,p1,p2,p3 are the four control points
|
|
TCubic(const TPointD &p0,
|
|
const TPointD &p1,
|
|
const TPointD &p2,
|
|
const TPointD &p3)
|
|
: m_p0(p0), m_p1(p1), m_p2(p2), m_p3(p3) {}
|
|
|
|
TCubic(const TCubic &src)
|
|
: m_p0(src.m_p0), m_p1(src.m_p1), m_p2(src.m_p2), m_p3(src.m_p3) {}
|
|
|
|
TCubic &operator=(const TCubic &src)
|
|
{
|
|
m_p0 = src.m_p0;
|
|
m_p1 = src.m_p1;
|
|
m_p2 = src.m_p2;
|
|
m_p3 = src.m_p3;
|
|
return *this;
|
|
}
|
|
|
|
//!Return first control point \b P0.
|
|
TPointD getP0() const { return m_p0; }
|
|
//!Return second control point \b P1.
|
|
TPointD getP1() const { return m_p1; }
|
|
//!Return third control point \b P2.
|
|
TPointD getP2() const { return m_p2; }
|
|
//!Return fourth control point \b P3.
|
|
TPointD getP3() const { return m_p3; }
|
|
|
|
//!Set the value of first control point \b P0 to \b p.
|
|
void setP0(const TPointD &p0) { m_p0 = p0; }
|
|
//!Set the value of second control point \b P1 to \b p.
|
|
void setP1(const TPointD &p1) { m_p1 = p1; }
|
|
//!Set the value of third control point \b P2 to \b p.
|
|
void setP2(const TPointD &p2) { m_p2 = p2; }
|
|
//!Set the value of fourth control point \b P3 to \b p.
|
|
void setP3(const TPointD &p3) { m_p3 = p3; }
|
|
|
|
bool operator==(const TCubic &c) const
|
|
{
|
|
return m_p0 == c.m_p0 && m_p1 == c.m_p1 && m_p2 == c.m_p2 && m_p3 == c.m_p3;
|
|
}
|
|
|
|
bool operator!=(const TCubic &c) const
|
|
{
|
|
return !operator==(c);
|
|
}
|
|
|
|
//!Return rect that contains the cubic.
|
|
TRectD getBBox() const
|
|
{
|
|
return TRectD(tmin(m_p0.x, m_p1.x, m_p2.x, m_p3.x),
|
|
tmin(m_p0.y, m_p1.y, m_p2.y, m_p3.y),
|
|
tmax(m_p0.x, m_p1.x, m_p2.x, m_p3.x),
|
|
tmax(m_p0.y, m_p1.y, m_p2.y, m_p3.y));
|
|
};
|
|
|
|
//!Return the point of cubic at parameter \b t.
|
|
TPointD getPoint(double t) const;
|
|
|
|
//!Return speed of cubic at parameter \b t.
|
|
TPointD getSpeed(double t) const;
|
|
|
|
//!Return acceleration of cubic at parameter \b t.
|
|
TPointD getAcceleration(double t) const
|
|
{
|
|
return 6.0 * ((m_p2 - 2 * m_p1 + m_p0) * (1 - t) + (m_p3 - 2 * m_p2 + m_p1) * t);
|
|
};
|
|
|
|
/*!
|
|
Return length of an arc between parameters t0 t1.
|
|
N.B. Length returned is always positive.
|
|
\note t0 and t1 are clamped to [0,1] interval
|
|
\note if t0>=t1 returns 0
|
|
*/
|
|
double getLength(double t0, double t1) const;
|
|
|
|
inline double getLength(double t1 = 1.0) const
|
|
{
|
|
return getLength(0.0, t1);
|
|
}
|
|
|
|
/*!
|
|
N.B. if t==0 o t==1 return a quadratic with all points equal
|
|
*/
|
|
void split(double t, TCubic &first, TCubic &second) const;
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
//!\relates TAffine, TCubic
|
|
inline TCubic operator*(const TAffine &aff, const TCubic &curve)
|
|
{
|
|
TCubic out;
|
|
out.setP0(aff * curve.getP0());
|
|
out.setP1(aff * curve.getP1());
|
|
out.setP2(aff * curve.getP2());
|
|
out.setP3(aff * curve.getP3());
|
|
return out;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
DVAPI ostream &operator<<(ostream &out, const TCubic &curve);
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
inline ostream &operator<<(ostream &out, const TCubic *curve)
|
|
{
|
|
assert(curve);
|
|
return out << *curve;
|
|
}
|
|
|
|
//=============================================================================
|
|
/*!
|
|
TSegment Class to manage a segment with thickness
|
|
\!relates TSegment
|
|
*/
|
|
class DVAPI TThickSegment : public TSegment
|
|
{
|
|
protected:
|
|
double m_thickP0;
|
|
double m_thickP1;
|
|
|
|
public:
|
|
//! m_thickP0, m_thickP1 are thickness of segment control points
|
|
TThickSegment()
|
|
: TSegment(), m_thickP0(0), m_thickP1(0) {}
|
|
|
|
TThickSegment(const TThickSegment &thickSegment)
|
|
: TSegment(thickSegment), m_thickP0(thickSegment.m_thickP0), m_thickP1(thickSegment.m_thickP1) {}
|
|
|
|
TThickSegment(const TSegment &seg)
|
|
: TSegment(seg), m_thickP0(0), m_thickP1(0) {}
|
|
|
|
TThickSegment(const TPointD &p0, double thickP0,
|
|
const TPointD &p1, double thickP1)
|
|
: TSegment(p0, p1), m_thickP0(thickP0), m_thickP1(thickP1) {}
|
|
|
|
TThickSegment(const TThickPoint &thickP0,
|
|
const TThickPoint &thickP1)
|
|
: TSegment(thickP0, thickP1), m_thickP0(thickP0.thick), m_thickP1(thickP1.thick) {}
|
|
|
|
TThickSegment &operator=(const TThickSegment &other)
|
|
{
|
|
m_c0.x = other.m_c0.x;
|
|
m_c1.x = other.m_c1.x;
|
|
m_c0.y = other.m_c0.y;
|
|
m_c1.y = other.m_c1.y;
|
|
m_thickP0 = other.m_thickP0;
|
|
m_thickP1 = other.m_thickP1;
|
|
return *this;
|
|
}
|
|
|
|
//!Set the value of first control point \b P0 to \b TThickPoint \b p0.
|
|
void setThickP0(const TThickPoint &p0)
|
|
{
|
|
m_c0.x = p0.x;
|
|
m_c0.y = p0.y;
|
|
m_thickP0 = p0.thick;
|
|
}
|
|
//!Set the value of second control point \b P1 to \b TThickPoint \b p1.
|
|
void setThickP1(const TThickPoint &p1)
|
|
{
|
|
m_c1.x = p1.x - m_c0.x;
|
|
m_c1.y = p1.y - m_c0.y;
|
|
m_thickP1 = p1.thick;
|
|
}
|
|
|
|
//!Return first control point \b P0.
|
|
TThickPoint getThickP0() const { return TThickPoint(m_c0, m_thickP0); }
|
|
//!Return second control point \b P1.
|
|
TThickPoint getThickP1() const { return TThickPoint(m_c0 + m_c1, m_thickP1); }
|
|
|
|
//!Return the \b TThickPoint of segment at parameter \b t.
|
|
TThickPoint getThickPoint(double t) const
|
|
{
|
|
return TThickPoint(m_c0 + t * m_c1, (1 - t) * m_thickP0 + t * m_thickP1);
|
|
}
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
inline TThickSegment operator*(const TAffine &aff, const TThickSegment &ts)
|
|
{
|
|
TThickSegment out(ts);
|
|
out.setP0(aff * ts.getP0());
|
|
out.setP1(aff * ts.getP1());
|
|
return out;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
DVAPI ostream &operator<<(ostream &out, const TThickSegment &segment);
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
inline ostream &operator<<(ostream &out, const TThickSegment *segment)
|
|
{
|
|
assert(segment);
|
|
return out << *segment;
|
|
}
|
|
|
|
//=============================================================================
|
|
|
|
/*!
|
|
Class TThickQuadratic: manage a curve with thick
|
|
\!relates TQuadratic
|
|
*/
|
|
class DVAPI TThickQuadratic : public TQuadratic
|
|
{
|
|
protected:
|
|
double m_thickP0;
|
|
double m_thickP1;
|
|
double m_thickP2;
|
|
|
|
public:
|
|
TThickQuadratic();
|
|
|
|
//! thickP0, thickP1, thickP2 are thickness of quadratic control points
|
|
TThickQuadratic(const TPointD &p0, double thickP0,
|
|
const TPointD &p1, double thickP1,
|
|
const TPointD &p2, double thickP2);
|
|
|
|
TThickQuadratic(const TThickPoint &p0,
|
|
const TThickPoint &p1,
|
|
const TThickPoint &p2);
|
|
|
|
TThickQuadratic(const TThickQuadratic &thickQuadratic);
|
|
|
|
TThickQuadratic(const TQuadratic &quadratic);
|
|
|
|
//!Set the value of first control point \b P0 to \b TThickPoint \b p.
|
|
void setThickP0(const TThickPoint &p);
|
|
//!Set the value of second control point \b P1 to \b TThickPoint \b p.
|
|
void setThickP1(const TThickPoint &p);
|
|
//!Set the value of third control point \b P2 to \b TThickPoint \b p.
|
|
void setThickP2(const TThickPoint &p);
|
|
|
|
//!Return the \b TThickPoint of quadratic at parameter \b t.
|
|
TThickPoint getThickPoint(double t) const;
|
|
|
|
//!Return first control point \b P0.
|
|
TThickPoint getThickP0() const { return TThickPoint(m_p0, m_thickP0); }
|
|
//!Return second control point \b P1.
|
|
TThickPoint getThickP1() const { return TThickPoint(m_p1, m_thickP1); }
|
|
//!Return third control point \b P2.
|
|
TThickPoint getThickP2() const { return TThickPoint(m_p2, m_thickP2); }
|
|
|
|
void split(double t, TThickQuadratic &first, TThickQuadratic &second) const;
|
|
|
|
TRectD getBBox() const;
|
|
};
|
|
|
|
//---------------------------------------------------------------------
|
|
|
|
inline TThickQuadratic operator*(const TAffine &aff, const TThickQuadratic &tq)
|
|
{
|
|
TThickQuadratic out(tq);
|
|
out.setP0(aff * tq.getP0());
|
|
out.setP1(aff * tq.getP1());
|
|
out.setP2(aff * tq.getP2());
|
|
|
|
return out;
|
|
}
|
|
|
|
//---------------------------------------------------------------------
|
|
|
|
inline TThickQuadratic transformQuad(const TAffine &aff, const TThickQuadratic &tq, bool doChangeThickness = false)
|
|
{
|
|
if (!doChangeThickness)
|
|
return aff * tq;
|
|
|
|
TThickQuadratic out(tq);
|
|
double det = aff.det();
|
|
det = (det < 0) ? sqrt(-det) : sqrt(det);
|
|
|
|
out.setThickP0(TThickPoint(aff * tq.getP0(), tq.getThickP0().thick * det));
|
|
out.setThickP1(TThickPoint(aff * tq.getP1(), tq.getThickP1().thick * det));
|
|
out.setThickP2(TThickPoint(aff * tq.getP2(), tq.getThickP2().thick * det));
|
|
return out;
|
|
}
|
|
|
|
//---------------------------------------------------------------------
|
|
|
|
DVAPI ostream &operator<<(ostream &out, const TThickQuadratic &tq);
|
|
|
|
//---------------------------------------------------------------------
|
|
|
|
inline ostream &operator<<(ostream &out, const TThickQuadratic *tq)
|
|
{
|
|
assert(tq);
|
|
return out << *tq;
|
|
}
|
|
|
|
//=============================================================================
|
|
|
|
/*!
|
|
Class TThickCubic: manage a cubic with thick
|
|
\!relates TCubic
|
|
*/
|
|
class DVAPI TThickCubic : public TCubic
|
|
{
|
|
protected:
|
|
double m_thickP0;
|
|
double m_thickP1;
|
|
double m_thickP2;
|
|
double m_thickP3;
|
|
|
|
public:
|
|
TThickCubic();
|
|
|
|
//! thickP0, thickP1, thickP2, thickP3 are thickness of cubic control points
|
|
TThickCubic(const TPointD &p0, double thickP0,
|
|
const TPointD &p1, double thickP1,
|
|
const TPointD &p2, double thickP2,
|
|
const TPointD &p3, double thickP3);
|
|
|
|
TThickCubic(const TThickPoint &p0,
|
|
const TThickPoint &p1,
|
|
const TThickPoint &p2,
|
|
const TThickPoint &p3);
|
|
|
|
// tonino ***************************************************************
|
|
TThickCubic(const T3DPointD &p0,
|
|
const T3DPointD &p1,
|
|
const T3DPointD &p2,
|
|
const T3DPointD &p3);
|
|
|
|
// tonino ***************************************************************
|
|
|
|
TThickCubic(const TThickCubic &thickCubic);
|
|
|
|
TThickCubic(const TCubic &cubic);
|
|
|
|
//!Set the value of first control point \b P0 to \b TThickPoint \b p.
|
|
void setThickP0(const TThickPoint &p);
|
|
//!Set the value of second control point \b P1 to \b TThickPoint \b p.
|
|
void setThickP1(const TThickPoint &p);
|
|
//!Set the value of third control point \b P2 to \b TThickPoint \b p.
|
|
void setThickP2(const TThickPoint &p);
|
|
//!Set the value of fourth control point \b P3 to \b TThickPoint \b p.
|
|
void setThickP3(const TThickPoint &p);
|
|
|
|
//!Return the \b TThickPoint of cubic at parameter \b t.
|
|
TThickPoint getThickPoint(double t) const;
|
|
|
|
//!Return first control point \b P0.
|
|
TThickPoint getThickP0() const { return TThickPoint(m_p0, m_thickP0); }
|
|
//!Return second control point \b P1.
|
|
TThickPoint getThickP1() const { return TThickPoint(m_p1, m_thickP1); }
|
|
//!Return third control point \b P2.
|
|
TThickPoint getThickP2() const { return TThickPoint(m_p2, m_thickP2); }
|
|
//!Return fourth control point \b P3.
|
|
TThickPoint getThickP3() const { return TThickPoint(m_p3, m_thickP3); }
|
|
|
|
void split(double t, TThickCubic &first, TThickCubic &second) const;
|
|
};
|
|
|
|
//---------------------------------------------------------------------
|
|
|
|
inline TThickCubic operator*(const TAffine &aff, const TThickCubic &tc)
|
|
{
|
|
TThickCubic out(tc);
|
|
out.setP0(aff * tc.getP0());
|
|
out.setP1(aff * tc.getP1());
|
|
out.setP2(aff * tc.getP2());
|
|
out.setP3(aff * tc.getP3());
|
|
return out;
|
|
}
|
|
|
|
//---------------------------------------------------------------------
|
|
|
|
DVAPI ostream &operator<<(ostream &out, const TThickCubic &tc);
|
|
|
|
//---------------------------------------------------------------------
|
|
|
|
inline ostream &operator<<(ostream &out, const TThickCubic *tc)
|
|
{
|
|
assert(tc);
|
|
return out << *tc;
|
|
}
|
|
|
|
//=====================================================================
|
|
|
|
#endif //__T_CURVES_INCLUDED
|
|
//-----------------------------------------------------------------------------
|
|
// End Of File
|
|
//-----------------------------------------------------------------------------
|