Russian Qt Forum

C++ (Qt)
struct Curve {
// общие данные для всех типов кривых
 int dataType;  // тип значения кривой
 union {
   DoubleCurve * doubleCurve;
   VectorCurve * vectorCurve;
   СolorCurve * colorCurve;
 };
};
 

C++ (Qt)
struct VectorCurve { 
  ...
  Container<Key> xList;
  Container<Key> yList;
  Container<Key> zList;
};
 
struct Key {
  double time;
  double val;
  union {
     // опции сплайна
  };
};

C++ (Qt)
double	inRatioVector;	// Incoming Vector
double	outRatioVector;	// Outgoing Vector
double	inRatioAngle;	// Incoming Angle
double	outRatioAngle;	// Outgoing Angle
double	inWeight;	// Incoming Weight
double	outWeight;	// Outgoing Weight
int	ratioFlags;	// Flags governing the interpolation
 

C++ (Qt)
struct XYColorCurve
{
    vector<double> x;
    vector<double> y;
    vector<Color> c;
}
 

C++ (Qt)
struct XYColor
{
    double x;
    double y;
    Color c;
}
 
using XYColorCurve = vector<XYColor>;
 

C++ (Qt)
double	inRatioVector;	// Incoming Vector
double	outRatioVector;	// Outgoing Vector
double	inRatioAngle;	// Incoming Angle
double	outRatioAngle;	// Outgoing Angle
double	inWeight;	// Incoming Weight
double	outWeight;	// Outgoing Weight
int	ratioFlags;	// Flags governing the interpolation
 

C++ (Qt)
struct RatioWeight
{
    double inRatioVector;	// Incoming Vector
    double outRatioVector;	// Outgoing Vector
    double inRatioAngle;	// Incoming Angle
    double outRatioAngle;	// Outgoing Angle
    double inWeight;	// Incoming Weight
    double outWeight;	// Outgoing Weight
    int ratioFlags;	// Flags governing the interpolation
}
 
using RatioWeightCurve = map<Key, RatioWeight>;
 

C++ (Qt)
struct Key {
  double time;  // время  
  Vector vec;    // данные
 
  int splineOption1;   // параметры сплайна
  ...
  double splineOptionN; 
};

template<class T> Curve 
{
  QMap<Key, T> data;
public:
  void getData(&T, QDateTime t)
}

C++ (Qt)
Curve<QVector3D> c1;
Curve<QColor> c2;
Curve<double> c3;
 

C++ (Qt)
struct Curve {
  ...
  ??? GetData( double time ) const;   // возвращает значение для времени time
  void SetData( double time. const ??? & value );   // устанавливает значение для времени time
  ...
}; 
 

C++ (Qt)
struct Key {
    double time;
    Vector vec;
 
    int splineOption1;
    ...
    double splineOptionN; 
};

C++ (Qt)
template <class Key, class Data, class Option>
struct CurvePoint
{
    Key key;
    Data data;
    Option option;
};
 
enum class SplineType
{
    Type_1,
    Type_2;
    ...
};
 
template <class Point, SplineType _SplineType>
struct Curve
{
    vector<Point> points;
};
 

C++ (Qt)
using QuadraticBezierPoint = CurvePoint<DateTimeKey, Vector3D, QuadraticBezierOption>;
using CubicBezierPoint = CurvePoint<DateTimeKey, Vector3D, CubicBezierOption>;
using OneMorePoint = CurvePoint<DateTimeKey, Vector3D, OneMoreOption>;
 
using QuadraticBezierCurve = Curve<QuadraticBezierPoint, SplineType::QuadraticBezier>
using CubicBezierCurve = Curve<CubicBezierPoint, SplineType::CubicBezier>
using OneMoreCurve = Curve<OneMorePoint, SplineType::OneMoreCurve>
 

C++ (Qt)
void Curve::SetSplineType( SplineType type );

C++ (Qt)
int GetIntValue( const QWidget * widget );
 

C++ (Qt)
double Curve::GetDoubleValue( double time ) const;
 

C++ (Qt)
template <class Data, class Key>
struct Curve : AbstractCurve 
{
    map<Key, Data> data;
}
 

C++ (Qt)
void doSomething( AbstractCurve * curve )
{
   if (dynamic_cast<Curve<double, DateTime>*>(curve))
   { ... }
   else if (dynamic_cast<Curve<Vector3D, DateTime>*>(curve))
   { ... }
   else if (dynamic_cast<Curve<Color, DateTime>*>(curve))
   { ... }
}
 

C++ (Qt)
struct CurveDouble {
..
  void AddKey      ( double time, double value );  // добавить контрольную точку  
  void DelNthKey  ( int keyIndex );  // удалить контрольную точку  
 
  double GetNthKeyTime( int keyIndex ) const;   // получить время 
  double SetNthKeyValue( int keyIndex, double value ) const;  // получить значение
 
  void SetNthKeyTime( int keyIndex, double time );   // установить время 
  void SetNthKeyValue( int keyIndex, double value );  // установить значение
 
  double GetInterpolatedValue( double time ) const;   // получить интерполированное значение   
 
  const SplineOptions & GetNthSplineOptions( int keyIndex ) const;  // получить параметры сплайна
  void  SetNthSplineOptions( int keyIndex, const SplineOptions & opt ) const;  // установить параметры сплайна
...
};
 

C++ (Qt)
Curve<double>
Curve<Vector>
Curve<Color>
 

C++ (Qt)
QImage<format_ARGB32> 
QImage<format_GrayScale>
... // еще десяток таких 

C++ (Qt)
union {
  double value;
  double coordinate[3];
  float color[4];
};
 

template<typename T> Curve 
{ template <typename T>struct Value<T>{T data, in, out; float someOptions[];}
 QMap<double,Value>  }

C++ (Qt)
Зачем, зачем ты торопился?
Зачем свою лошадку гнал?
Али урядника боялся
Али в контору задолжал?

C++ (Qt)
#include <iostream>
#include <any>
#include <variant>
#include <vector>
#include <array>
#include <chrono>
 
using namespace std;
 
using Vector3D = array<double, 3>;
using Color = array<int, 4>;
using TimePoint = chrono::system_clock::time_point;
 
struct RatioOption
{
    double inRatioVector;
    double outRatioVector;
};
 
struct WeightOption
{
    int inWeight;
    int outWeight;
};
 
struct Curve
{
    using Key = variant<double, TimePoint>;
    using Point = variant<double, Vector3D, Color>;
    using Option = any;
    struct Data
    {
        Key key;
        Point point;
        Option option;
    };
    using Container = vector<Data>;
 
    Container data;
};
 
int main()
{
    Curve curve;
 
    curve.data.push_back( { 1.5, Color{24,32,64,128}, RatioOption{5.4, 8.7} } );
    curve.data.push_back( { TimePoint::clock::now(), Vector3D{1.2, 3.4, 5.6}, WeightOption{2,6} } );
 
    for (const auto & data : curve.data)
    {
        cout << "key = " << data.key // ??
             << "point = " << data.point // ??
             << "option = " << data.option // ??
             << endl;
    }
 
    return 0;
}
 

C++ (Qt)
struct RatioOption
{
    double inRatioVector;
    double outRatioVector;
};
 

C++ (Qt)
template <T>
struct RatioOption
{
    T inRatioVector;
    T outRatioVector;
};
 

C++ (Qt)
#include <iostream>
#include <vector>
#include <array>
#include <chrono>
#include <memory>
 
using namespace std;
 
using Vector3D = array<double, 3>;
using Color = array<int, 4>;
using TimePoint = chrono::system_clock::time_point;
 
struct EmptyOption
{};
 
template <class T>
struct RatioOption
{
    T inRatioVector;
    T outRatioVector;
};
 
template <class T>
struct WeightOption
{
    T inWeight;
    T outWeight;
};
 
struct AbstractCurve
{
public:
    virtual ~AbstractCurve(){}
 
    virtual void printTo(ostream & stream) const = 0;
};
 
template <class Key, class Point, class Option = EmptyOption>
struct Curve final : public AbstractCurve
{
    struct Data
    {
        Key key;
        Point point;
        Option option;
    };
 
    using Container = vector<Data>;
    Container data;
 
    void printTo(ostream & stream) const override
    {
        stream << "Generic curve [" << endl;
        for (const auto & i : data)
        {
            stream << "    ["
                   << " key = " << i.key
                   << ", point = " << i.point
                   << ", option = " << i.option
                   << " ]" << endl;
        }
        stream << "]" << endl;
    }
};
 
int main()
{
    auto coord_curve = make_unique<Curve<TimePoint, Vector3D>>();
    coord_curve->data.push_back({TimePoint(1s), Vector3D{1.2, 3.4, 5.6}, EmptyOption()});
    coord_curve->data.push_back({TimePoint(2s), {5.6, 3.4, 1.2}, {}});
 
    auto color_curve = make_unique<Curve<double, Color>>();
    color_curve->data.push_back({1.7, Color{1, 2, 3, 4}, {}});
    color_curve->data.push_back({2.5, {5, 6, 7, 8}});
 
    auto coord_ratio_curve = make_unique<Curve<TimePoint, Vector3D, RatioOption<double>>>();
    coord_ratio_curve->data.push_back({TimePoint(1h), {1.2, 3.4, 5.6}, {1.4, 4.1}});
    coord_ratio_curve->data.push_back({TimePoint(2h), {5.6, 3.4, 1.2}, {2.3, 5.7}});
 
    auto color_weight_curve = make_unique<Curve<double, Color, WeightOption<int>>>();
    color_weight_curve->data.push_back({5.8, Color{1, 2, 3, 4}, {1, 2}});
    color_weight_curve->data.push_back({7.2, {5, 6, 7, 8}, {3, 4}});
 
    vector<unique_ptr<AbstractCurve>> curves;
    curves.push_back(move(coord_curve));
    curves.push_back(move(color_curve));
    curves.push_back(move(coord_ratio_curve));
    curves.push_back(move(color_weight_curve));
 
    for (const auto & curve : curves)
        curve->printTo(cout);
 
    return 0;
}

C++ (Qt)
struct Curve {
...
 QVector<Key *> mKeys;   
... 
};
 
struct Key {
  ...
  virtual MyVariant GetValue( void );
  virtual void SetValue( const MyVariant & );
  ...
};
 
template <class DataType, class SplineType>
struct CTypedKey : public Key {
...
  virtual MyVariant GetValue( void )  { return mData; }
  virtual void SetValue( const MyVariant & v ) { mData = v; }
...
  DataType mData;
  SplineType mSpline;
}; 

C++ (Qt)
double InterpolateValue( Curve * curve, double t )
{
// проверяем частные случаи
  if (t >= MaxTime(curve)) ... 
  if (t <= MinTime(curve)) ... 
 
  switch (curve->splineType) {
    case SPLINE_LINEAR:
      return InterpolateLinear(curve, t);
 
    case SPLINE_RATIO:
      return InterpolateRatio(curve, t);
 
    .....
  }
}

C++ (Qt)
double InterpolateLinear( Curve * curve, double t )
{
   Key * key1 = FindUpperKey(curve, t);  // находим первый ключ с временем больше t
   Key * key0 = GetPreviousKey(key1);   // и предыдущий 
 
// интерполируем
   double relativeT = (t - key0->keyTime) / (key1->keyTime - key0->keyTime);
   return key0->keyData * (1 - relativeT) + key1->keyData * relativeT;
}
 

C++ (Qt)
// спец случай - постоянное значение до след ключа
   if (TestFlag(key0->spline.ratio.flag, BIT_HOLD)) return key0->keyData;
 
// спец случай - линейное значение до след ключа
   if (TestFlag(key0->spline.ratio.flag, BIT_LINEAR)) return ...
 
// интерполируем
   double relativeT = (t - key0->keyTime) / (key1->keyTime - key0->keyTime);
   double k[4];
   CalcCoefficients(t, k);
   return key0->keyData * k[0] +
             key1->keyData * k[1] +
             key0->spline.ratio.outRatioVector * k[2] +
             key1->spline.ratio.inRatioVector * k[3];
 

C++ (Qt)
    QImage * image = new QImage(100, 100, QImage::Format_ARGB32);

C++ (Qt)
    QImage * image = new QFormattedImage<Format_ARGB32>(100, 100);

C++ (Qt)
double InterpolateValue( Curve * curve, double t )
{
  if (t >= MaxTime(curve)) ... 
  if (t <= MinTime(curve)) ... 
 
  switch (curve->splineType) {
    case SPLINE_LINEAR:
      return InterpolateLinear(curve, t);
 
    case SPLINE_RATIO:
      return InterpolateRatio(curve, t);
 
    .....
  }
}

C++ (Qt)
struct Key {
  Key * prev, * next;
  ...
};

C++ (Qt)
typedef double CurveTime;
 

C++ (Qt)
typedef float btReal;

C++ (Qt)
class PointGenerator
{
    virtual double generate(Time time) = 0;
};
 
class EditableCurve
{
    virtual void addKey(Time time, Key key) = 0;
    virtual void removeKey(Time time, Key key) = 0;
    virtual Key & keyAt(Time time) = 0;
};
 

C++ (Qt)
class CurveGenerator : public PointGenerator, public EditableCurve
{
    double generate(Time time) override;
 
    void addKey(Time time, Key key) override;
    void removeKey(Time time, Key key) override;
    Key & keyAt(Time time) override;
};
 

C++ (Qt)
class Interpolator
{
    virtual double interpolate(Time time) = 0;
    virtual Time keyTime() const = 0;
};

C++ (Qt)
template <class CurvePoint, class T>
class RatioInterpolator : public Interpolator
{
    RatioInterpolator(Time keyTime, Key & key_1, Key & key_2, Key & key_3)
       : m_keyTime(keyTime), m_key_1(key_1), m_key_2(key_2), m_key_3(key_3)
    {}
 
    CurvePoint interpolate(Time time) override;
    Time keyTime() const override { return m_keyTime; }
 
    T inRatioVector;
    T outRatioVector;
 
    Time m_keyTime;
    Key & m_key_1;
    Key & m_key_2;
    Key & m_key_3;
};

C++ (Qt)
void DrawCurve( Curve * curve )
{
   Key * key = GetFirstKey(curve);
   while (key) {
    Key * next = GetNextKey(key);
    if (!next) break;
    DrawSegment(curve, key, next);
    key = next;
  }
}
 
void DrawSegment( Curve * curve, Key * key0, Key * key1 )
{
  Coordinate pos;
 
  double tStep = (GetKeyTime(key1) - GetKeyTime(key0)) / drawSteps;
  for (size_t i = 0; i < drawSteps; ++i) {
    InterpolateCurve(i * tStep, key0, key1, &pos);
    AddOpenGLVertex(pos);
  }  
}
 

C++ (Qt)
void DrawCurve(PointGenerator * generator, Time from, Time to, Time step)
{
    for (Time time = from; time <= to; time += step )
        AddOpenGLVertex(generator->generate(time));
}

C++ (Qt)
class PointGenerator
{
    virtual double generate(Time time) = 0;
};

C++ (Qt)
void DrawCurve( Curve * curve )
{
   Key * key = GetFirstKey(curve);
   while (key) {
    Key * next = GetNextKey(key);
    if (!next) break;
    DrawSegment(curve, key, next);
    key = next;
  }
}
 
void DrawSegment( Curve * curve, Key * key0, Key * key1 )
{
  Coordinate pos;
 
  double tStep = (GetKeyTime(key1) - GetKeyTime(key0)) / drawSteps;
  for (size_t i = 0; i < drawSteps; ++i) {
    InterpolateCurve(i * tStep, key0, key1, &pos);
    AddOpenGLVertex(pos);
  }  
}

C++ (Qt)
void DrawCurve(PointGenerator * generator, Time from, Time to, Time step)
{
    for (Time time = from; time <= to; time += step )
        AddOpenGLVertex(generator->generate(time));
}