MotionTrail.h

Go to the documentation of this file.

#pragma once

#include "BrushStroke.h"

using namespace vrecko;

namespace APDYNAMICART
{



class MotionTrail : public BrushStroke
{
public:

    MotionTrail(Controller* contr, ColorGenAdapter* colorGenAdapter, DiameterGenAdapter* diamGenAdapt, SplineAdapter* crossSectionAdapter);
    ~MotionTrail();

//    /// Add control point to this MotionTrail - at last position in vector of control points
//    /**
//     *
//     * \param pos position of new point
//     * \param list list of control points to witch new point will be added
//     * \param type of point - sampled, interpolated or temporary
//     * \param tvalue interpolation value
//     * \return ref. pointer to new control point
//     */
//    ref_ptr_DAControlPoint addControlPoint(osg::Vec3 pos, std::vector<ref_ptr_DAControlPoint>* list, DAControlPointType type, double tvalue = 0.0);
//
//    /// Add control point to this MotionTrail - at last position in vector of control points
//    ref_ptr_DAControlPoint addControlPoint(DASample *sample, std::vector<ref_ptr_DAControlPoint>* list, DAControlPointType type, double mutliplicator = 1.0);
//
//    /// Add control point - create new object as a copy of the one given
//    ref_ptr_DAControlPoint addControlPoint(DAControlPoint *point, std::vector<ref_ptr_DAControlPoint>* list);
//
//
//    std::string createMenuStructure(void) const;
//
//    /// export the current state of the motion trail to a file
//    /**
//     * \todo use osg function to write Node to file
//     */
//    void exportToFile(std::string file);
//
//  void importControlPoints( const std::vector<osg::Vec3> *importedSamples, const std::vector<osg::Vec4> *importedColours );
//
//    //gets
//    inline std::vector<ref_ptr_DAControlPoint>* getControlPoints() { return this->controlPoints; }
//    inline osg::Vec4 getColour(double value = 0.0) const { return this->brush->getColour(value); }
//    inline MTBrushParameterType getColouringType() const { return this->brush->getColouringType(); }
//    inline MTBrushParameterType getCrossSectionType() const { return this->brush->getcrossSectionType(); }
//    inline double getDiameter(double value = 0.0) const {return this->brush->getDiameter(value); }
//    inline int getInterpolation() const { return this->brush->getInterpolationSteps(); }
//    inline std::vector<DASample>* getSamples() const {return this->samples; }
//    inline double getSmoothness() const { return this->smoothness; }
//
//    int load(XERCES_CPP_NAMESPACE_QUALIFIER DOMNode* MotionTrailNode);
//
//    void menuItemClicked(const char* itemID);
//
//    void menuSliderChanged(const char* sliderID, float sliderPos);
//
//    void pointed(bool pointed);
//
//    void preInicialize();
//
//    /// Create new set of control points from samples based on chosen parameters.
//    /*
//     * "the liver of a poodle" of Motion trail. 
//     * 
//     * phase 0 - clear old data
//     * phase 1 - create control points from "all" samples
//     * phase 2 - compute rotation frame for each control points
//     * phase 3 - compute local characteristics of all control points
//     * phase 4 - smoothing - reduce number of control points
//     * phase 5 - interpolate - compute additional points between existing point to create smoother triangulation
//     * phase 6 - (re)compute rotation frames and characteristics of control points
//     * phase 7 - triangulate
//     *
//     */
//  bool recreateControlPoints(int startingPhase = -1);
//
//
//    /// Save PoA as one node to .xml file
//    void save(XERCES_CPP_NAMESPACE_QUALIFIER DOMDocument* Document, XERCES_CPP_NAMESPACE_QUALIFIER DOMNode* poaNode);
//
//    //sets
//    void setColor(osg::Vec4 newColour);
//    void setColourType(int type);
//    void setColourType(MTBrushParameterType type);
//
//  void setCrossSectionInterpolation(int interpol);
//    void setCrossSectionType(int type);
//    void setCrossSectionType(MTBrushParameterType type);
//    void setCrossSectionShape(int shape);
//  /*
//   * Set new diameter value at given interpolation value
//   *
//   * \param dia new diameter value
//   * \param value of interpolation across curve - 0.0 means at curve start, 1.0 means at curve end
//   */
//    void setDiameter(double dia, double value = 0.0);
//
//    void setInterpolation(int interpol);
//    void setSmoothness(double smooth);
//    void setUpdating(MotionTrailUpdateType p_type);
//
//    /// Create triangle mesh from control points
//    void triangulate();
//
//    void stopSampling();
//
//    /// Switch between polygon = FILL and wireframe = LINE modes
//    void switchRenderingMethod();
//
//    void update(void);
//
//    /// Switch on or off showing box-likes visualization of control points of MotionTrail
//    void visualizeControlPoints(bool show);
//
//
//protected:
//
//    /// All samples tracked during creation of MotionTrail
//    /**
//     * used for compute control points, local and global characteristics
//     */
//    std::vector<DASample>* samples;
//
//    /// All control points of MotionTrail
//    std::vector<ref_ptr_DAControlPoint>* controlPoints;
//
//    /// Type of rotation frame
//    RotationFrameType frame;
//
//    /// Type of update
//    MotionTrailUpdateType updatingType;
//
//    //computing control points from samples
//    unsigned int lastAnalyzedSample;          ///< index of last already analyzed sampe
//    unsigned int lastControlPointsWithChars;  ///< with computed characteristics
//    double segmentLength;                     ///< accumulated length of actual computed segment
//
//    osg::ref_ptr<osg::Group> boxesGroup;      ///< mainly for debug - group of all SimpleBoxes of this MotionTrail
//
//    //Global Characteristics
//    double length;                                ///< sum of length of all segments
//
//    ///\todo - redefined in Brush (for triangulation)
//    double minSpeed;
//    double maxSpeed;
//    double meanSpeed;
//
//    double minCurvature;
//    double maxCurvature;
//    double meanCurvature;
//
//    double minTorsion;
//    double maxTorsion;
//    double meanTorsion;
//    
//
//    osg::ref_ptr<MTBrush> brush;
//
//    double smoothness;
//    osg::ref_ptr<MotionTrailTriangulator> triangulator;
//
//    bool visibleControlPointsGizmo;
//
//    double awaitingColorChangeValue;        ///< value of new color (choosed by Color Chooser)
//
//    //Private functions
//
//    ///computes global and local (at each control point) characteristics of MotionTrail
//    /**
//     * for all, or only specified range of control points, given characteristics are recomputed and store into points.
//     * In different stages of Motion trail life-cycle, different characteristics are necessary or useless
//     * to speed-up, what characteristics will be computed is specified by parameters.
//     *
//     * \param cpoints list of control points
//     * \param[in] first index of first point to be analyzed
//     * \param[in] count number points to be analyzed
//     * \param[in] compute characteristics only from sampled points
//     * \param[in] lengths - compute also lengths of segments
//     * \param[in] speeds - compute also speed of movement in control points
//     * \param[in] priorities - compute also priorities of control points
//     * \param[in] globalChars - compute also global characteristics of MotionTrail
//     * TODO CRITICAL - rethink, rewrite whole function - uses phases from recreateControlPoints()
//     */
//    void computeFrenetFrame(std::vector<ref_ptr_DAControlPoint>* cpoints, int first, int count, bool onlySampled, bool lengths, bool speeds, bool priorities, bool globalChars);
//
//
//    ///Global characteristics computation
//    /**
//     * min, max, mean value of speed, curvature and torsion\
//     */
//    void computeGlobalCharacteristics();
//
//    /// evaluate priority of each control point
//    /// based on segment length and curvature and torsion of poit
//    void computeControlPointsPriorities();
//
//    /// compute speed of all control points
//    /*
//     * based on segments lengths
//     * speed of SAMPLED points is calculated only ONCE and did not change even when some points are deleted or new interpolated points are added.
//     *
//     * \param onlySampled - compute speed only at SAMPLED points (there are probably no other points)
//     */
//    void computeControlPointsSpeeds(bool onlySampled);
//
//    /// computes Frenet Frame for given control point, store data into given point
//    void computePointCharacteristics(DAControlPoint *point, DAControlPoint *prevPoint, osg::Vec3 p0, osg::Vec3 p1, osg::Vec3 p2, osg::Vec3 p3);
//
//    /// computes Frenet Frame for given INTERPOLATED control point
//    void computeInterpolatedPointCharacteristics(DAControlPoint *point, DAControlPoint *spoint0, DAControlPoint *spoint1, DAControlPoint *spoint2, DAControlPoint *spoint3);
//
//
//    /// computes Rotation Minimizing Frame for all points
//    /**
//     *
//     * for more details, see paper at:
//     * http://portal.acm.org/citation.cfm?id=1330513&dl=ACM&coll=DL&CFID=12922836&CFTOKEN=38716133
//     * especialy, page 7
//     *
//     * \param controlPoints set of control points to compute with
//     */
//    void computeRMF(std::vector<ref_ptr_DAControlPoint>* controlPoints);
//
//
//    /// Compute segment lengths of actual set of control points
//    /**
//     * this is necessary for computation of speed and also for better interpolation of control points.
//     */
//    void computeSegmentLengths(std::vector<ref_ptr_DAControlPoint>* controlPoints, std::vector<osg::Vec3> *interpolatedPoints, int interpolationSteps);
//
//    /// Remove some control points and thus smooth and simplify spine curve of trail
//    /*
//     * 
//     *
//     */
//    void optimizeControlPoints(std::vector<ref_ptr_DAControlPoint>** controlPoints, double smoothness);
//
//
//    /// Return distance between two samples
//    inline double sampleDistance(DASample *s1, DASample *s2);

};

}