vctPlot2DBase.h

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-    */
/* ex: set filetype=cpp softtabstop=4 shiftwidth=4 tabstop=4 cindent expandtab: */

/*

  Author(s):  Anton Deguet
  Created on: 2010-05-05

  (C) Copyright 2010-2013 Johns Hopkins University (JHU), All Rights Reserved.

--- begin cisst license - do not edit ---

This software is provided "as is" under an open source license, with
no warranty.  The complete license can be found in license.txt and
http://www.cisst.org/cisst/license.txt.

--- end cisst license ---
*/

#ifndef _vctPlot2DBase_h
#define _vctPlot2DBase_h

#include <map>
#include <string>

#include <cisstVector/vctDynamicVector.h>
#include <cisstVector/vctDynamicVectorTypes.h>
#include <cisstVector/vctFixedSizeVectorTypes.h>

// Always include last
#include <cisstVector/vctExport.h>

class CISST_EXPORT vctPlot2DBase
{

 public:

    class Scale;

    class CISST_EXPORT Signal
    {
        friend class vctPlot2DBase;
        friend class vctPlot2DBase::Scale;
        friend class vctPlot2DOpenGL;
        friend class vctPlot2DVTK;
    public:
        Signal(const std::string & name, size_t numberOfPoints, size_t pointDimension = 2);
        ~Signal();

        // see AppendPoint
        void CISST_DEPRECATED AddPoint(const vctDouble2 & point);

        void AppendPoint(const vctDouble2 & point);

        vctDouble2 GetPointAt(size_t index) throw (std::runtime_error);

        void SetPointAt(size_t index, const vctDouble2 & point) throw (std::runtime_error);

        void SetArrayAt(size_t index, const double * pointArray, size_t arraySize, size_t pointDimension = 2) throw (std::runtime_error);

        bool PrependArray(const double * pointArray, size_t arraySize, size_t pointDimension = 2) throw (std::runtime_error);

        bool AppendArray(const double * pointArray, size_t arraySize, size_t pointDimension = 2) throw (std::runtime_error);

        void Freeze(bool freeze);
        bool GetFreeze(void) const;

        void ComputeDataRangeX(double & min, double & max, bool assumesDataSorted = false) const;
        void ComputeDataRangeY(double & min, double & max) const;
        void ComputeDataRangeXY(vctDouble2 & min, vctDouble2 & max) const;

        void CISST_DEPRECATED SetNumberOfPoints(size_t numberOfPoints);
        void CISST_DEPRECATED GetNumberOfPoints(size_t & numberOfPoints, size_t & bufferSize) const;

        size_t GetSize(void) const;

        size_t GetNumberOfPoints(void) const;

        void SetColor(const vctDouble3 & colorInRange0To1);

        void SetSize(size_t numberOfPoints);

        bool IsVisible(void) const;
        void SetVisible(const bool visible);

        void Resize(size_t numberOfPoints, bool trimOlder = true);

        /* Helper Function */
        vctPlot2DBase::Signal * AddSignal(const std::string & name);
        vctPlot2DBase::Scale * GetParent(void);
        const std::string & GetName(void) const;

    protected:
        Scale * Parent;
        std::string Name;
        bool Empty;
        bool Visible;
        bool Frozen;
        double * Buffer;
        size_t PointSize;
        typedef vctFixedSizeVectorRef<double, 2, 1> PointRef;
        vctDynamicVector<PointRef> Data;
        size_t IndexFirst;
        size_t IndexLast;
        vctDouble3 Color;
        double LineWidth;
    };

    class CISST_EXPORT VerticalLine
    {
        friend class vctPlot2DBase;
        friend class vctPlot2DOpenGL;
        friend class vctPlot2DVTK;
    public:
        VerticalLine(const std::string & name, const double x = 0.0);
        ~VerticalLine();

        void SetX(const double x);
        void SetColor(const vctDouble3 & colorInRange0To1);

    protected:
        std::string Name;
        double X;
        bool Visible;
        vctDouble3 Color;
        double LineWidth;
    };

    class CISST_EXPORT Scale
    {
        friend class vctPlot2DBase;
        friend class vctPlot2DOpenGL;
        friend class vctPlot2DVTK;
    public:

        // keep signals in a std::map
        typedef std::map<std::string, Signal *> SignalsType;
        SignalsType Signals;

        // keep vertical lines in a std::map
        typedef std::map<std::string, VerticalLine *> VerticalLinesType;
        VerticalLinesType VerticalLines;

        Scale(const std::string & name, size_t pointDimension = 2);
        ~Scale();

        const std::string & GetName(void) const;

        vctPlot2DBase::Signal * AddSignal(const std::string & name);
        bool RemoveSignal(const std::string & name);
        bool RemoveSignal(const Signal * signal);

        inline const SignalsType & GetSignals(void) const {
            return Signals;
        }

        vctPlot2DBase::VerticalLine * AddVerticalLine(const std::string & name);

        void SetColor(const vctDouble3 & colorInRange0To1);

        void Freeze(bool freeze);
        bool GetFreeze(void) const;

        void ContinuousUpdate(void);
        void SetContinuousFitX(bool fit);
        void SetContinuousFitY(bool fit);
        void SetContinuousExpandY(bool expand);

        inline bool GetContinuousFitX(void) const {
            return ContinuousFitX;
        }
        inline bool GetContinuousFitY(void) const {
            return ContinuousFitY;
        }
        inline bool GetContinuousExpandY(void) const {
            return ContinuousExpandY;
        }
        const vctDouble2 & GetViewingRangeX(void) {
            return this->ViewingRangeX;
        }
        const vctDouble2 & GetViewingRangeY(void) {
            return this->ViewingRangeY;
        }

        bool ComputeDataRangeX(double & min, double & max, bool assumesDataSorted = false) const;
        bool ComputeDataRangeY(double & min, double & max);
        bool ComputeDataRangeXY(vctDouble2 & min, vctDouble2 & max);

        void AutoFitX(double padding = 0.0);
        void FitX(double min, double max, double padding = 0.0);
        void AutoFitY(double padding = 0.1);
        void AutoExpandY(double padding = 0.1);
        void FitY(double min, double max, double padding = 0.1);
        void AutoFitXY(const vctDouble2 & padding = vctDouble2(0.0, 0.1));
        void AutoFitXExpandY(const vctDouble2 & padding = vctDouble2(0.0, 0.1));
        void FitXY(vctDouble2 min, vctDouble2 max, const vctDouble2 & padding = vctDouble2(0.0, 0.1));

    protected:
        bool ContinuousFitX;
        bool ContinuousFitY;
        bool ContinuousExpandY;
        double ExpandYMin, ExpandYMax;

        // viewport sizes
        vctDouble2 Viewport;
        // stores the min and max corresponding to the viewport
        vctDouble2 ViewingRangeX, ViewingRangeY;
        vctDouble2 Translation;
        vctDouble2 ScaleValue;


    private:
        std::string Name;
        size_t PointSize;
        vctDouble3 Color;
        double LineWidth;
    };

    typedef std::map<std::string, Scale *> ScalesType;
    ScalesType Scales;

    vctPlot2DBase::Scale * AddScale(const std::string & name);

    vctPlot2DBase::Scale * FindScale(const std::string & name);

    bool RemoveScale(const std::string & name);

    bool RemoveScale(const vctPlot2DBase::Scale * scale);

    inline ScalesType & GetScales(void) {
        return Scales;
    }

    vctPlot2DBase(size_t PointSize = 2);
    virtual ~vctPlot2DBase();

    void SetNumberOfPoints(size_t numberOfPoints);

    Signal CISST_DEPRECATED * AddSignal(const std::string & name);

    VerticalLine CISST_DEPRECATED * AddVerticalLine(const std::string & name);

    void AutoFitX(double padding = 0.0);
    void FitX(double min, double max, double padding = 0.0);
    void AutoFitY(double padding = 0.1);
    void FitY(double min, double max, double padding = 0.1);

    void Freeze(bool freeze);

    bool GetFreeze(void) const;

    void SetContinuousFitX(bool fit);
    void SetContinuousFitY(bool fit);
    void SetContinuousExpandY(bool expand);

    bool GetContinuousFitX(void) const;

    bool GetContinuousFitY(void) const;

    bool GetContinuousExpandY(void) const;

    //*! Get currently used viewing range */
    inline const vctDouble2 & GetViewingRangeX(void) const {
        return this->ViewingRangeX;
    }
    inline const vctDouble2 & GetViewingRangeY(void) const {
        return this->ViewingRangeY;
    }

    void SetBackgroundColor(const vctDouble3 & colorInRange0To1);

 protected:

    virtual void RenderInitialize(void) = 0;
    virtual void RenderResize(double width, double height) = 0;
    virtual void Render(void) = 0;

 protected:
    size_t PointSize;

    // default number of points for all signals
    size_t NumberOfPoints;

    // viewport sizes
    vctDouble2 Viewport;
    // stores the min and max corresponding to the viewport
    vctDouble2 ViewingRangeX, ViewingRangeY;

    void ContinuousUpdate(void);

    // background color
    vctDouble3 BackgroundColor;
};

#endif  // _vctPlot2DBase_h