CDisplayWindowPlots.h

Go to the documentation of this file.

/* +------------------------------------------------------------------------+
   |                     Mobile Robot Programming Toolkit (MRPT)            |
   |                          http://www.mrpt.org/                          |
   |                                                                        |
   | Copyright (c) 2005-2018, Individual contributors, see AUTHORS file     |
   | See: http://www.mrpt.org/Authors - All rights reserved.                |
   | Released under BSD License. See details in http://www.mrpt.org/License |
   +------------------------------------------------------------------------+ */
#ifndef CDisplayWindowPlots_H
#define CDisplayWindowPlots_H
 
#include <mrpt/gui/CBaseGUIWindow.h>
#include <mrpt/math/CMatrixTemplateNumeric.h>
#include <mrpt/math/lightweight_geom_data.h>
#include <mrpt/img/CImage.h>
#include <mrpt/gui/gui_frwds.h>
 
namespace mrpt::gui
{
/** Create a GUI window and display plots with MATLAB-like interfaces and
 * commands.
 *
 *  For a list of supported events with the observer/observable pattern, see the
 * discussion in mrpt::gui::CBaseGUIWindow.
 *
 *   See CDisplayWindowPlots::plot
 * \ingroup mrpt_gui_grp
 */
class CDisplayWindowPlots : public mrpt::gui::CBaseGUIWindow
{
   public:
    using Ptr = std::shared_ptr<CDisplayWindowPlots>;
 
    /** Type for the callback function used in setMenuCallback */
    using TCallbackMenu =
        void (*)(int menuID, float cursor_x, float cursor_y, void* userParam);
 
   protected:
    friend class CWindowDialogPlots;
 
    /** Whether hold_on is enabled */
    bool m_holdon;
    bool m_holdon_just_disabled;
    /** Counter for hold_on */
    uint32_t m_holdon_cnt;
    TCallbackMenu m_callback;
    void* m_callback_param;
 
    void internal_plot(
        mrpt::math::CVectorFloat& x, mrpt::math::CVectorFloat& y,
        const std::string& lineFormat, const std::string& plotName);
    template <typename VECTOR1, typename VECTOR2>
    void internal_plot_interface(
        const VECTOR1& x, const VECTOR2& y, const std::string& lineFormat,
        const std::string& plotName)
    {
        mrpt::math::CVectorFloat x1(x.size()), y1(y.size());
        const size_t N1 = size_t(x.size());
        for (size_t i = 0; i < N1; i++) x1[i] = x[i];
        const size_t N2 = size_t(y.size());
        for (size_t i = 0; i < N2; i++) y1[i] = y[i];
        this->internal_plot(x1, y1, lineFormat, plotName);
    }
    template <typename VECTOR1>
    void internal_plot_interface(
        const VECTOR1& y, const std::string& lineFormat,
        const std::string& plotName)
    {
        const size_t N = size_t(y.size());
        mrpt::math::CVectorFloat x1(N), y1(N);
        for (size_t i = 0; i < N; i++)
        {
            x1[i] = i;
            y1[i] = y[i];
        }
        this->internal_plot(x1, y1, lineFormat, plotName);
    }
 
   public:
    /** Constructor
     */
    CDisplayWindowPlots(
        const std::string& windowCaption = std::string(),
        unsigned int initialWidth = 350, unsigned int initialHeight = 300);
 
    /** Class factory returning a smart pointer */
    static CDisplayWindowPlots::Ptr Create(
        const std::string& windowCaption, unsigned int initialWindowWidth = 400,
        unsigned int initialWindowHeight = 300);
 
    /** Destructor
     */
    virtual ~CDisplayWindowPlots();
 
    /** Gets the last x,y pixel coordinates of the mouse. \return False if the
     * window is closed. */
    virtual bool getLastMousePosition(int& x, int& y) const override;
 
    /** Set cursor style to default (cursorIsCross=false) or to a cross
     * (cursorIsCross=true) */
    virtual void setCursorCross(bool cursorIsCross) override;
 
    /** Resizes the window, stretching the image to fit into the display area.
     */
    void resize(unsigned int width, unsigned int height) override;
 
    /** Changes the position of the window on the screen.
     */
    void setPos(int x, int y) override;
 
    /** Changes the window title text.
     */
    void setWindowTitle(const std::string& str) override;
 
    /** Enable/disable the feature of pan/zoom with the mouse (default=enabled)
     */
    void enableMousePanZoom(bool enabled);
 
    /** Adds a new layer with a 2D plot based on two vectors of X and Y points,
     *using a MATLAB-like syntax.
     *  Each call to this function creates a new plot, unless the plot name
     *coincides with an already existing plot: in this case the X & Y points
     *are used to update this existing layer (this also applies to using the
     *default plot name).
     *  If "hold_on" is enabled, then every call will always create a new plot,
     *even if no "plotName" is provided.
     *
     *  The lineFormat string is a combination of the following characters:
     * - Line styles:
     *      - '.': One point for each data point
     *      - '-': A continuous line
     *      - ':': A dashed line
     * - Colors:
     *      - k: black
     *      - r: red
     *      - g: green
     *      - b: blue
     *      - m: magenta
     *      - c: cyan
     * - Line width:
     *      - '1' to '9': The line width (default=1)
     *
     *  Examples:
     *   - 'r.' -> red points.
     *   - 'k3' or 'k-3' -> A black line with a line width of 3 pixels.
     * \note The vectors x & y can be of types: float or double.
     * \sa axis, axis_equal, axis_fit, clear, hold_on, hold_off
     * \tparam VECTOR Can be std::vector<float/double> or
     *mrpt::dynamicsize_vector<float/double> or a column/row Eigen::Matrix<>
     */
    template <typename T1, typename T2>
    inline void plot(
        const std::vector<T1>& x, const std::vector<T2>& y,
        const std::string& lineFormat = std::string("b-"),
        const std::string& plotName = std::string("plotXY"))
    {
        this->internal_plot_interface(x, y, lineFormat, plotName);
    }
    //! \overload
    template <typename T1, typename Derived2>
    inline void plot(
        const std::vector<T1>& x, const Eigen::MatrixBase<Derived2>& y,
        const std::string& lineFormat = std::string("b-"),
        const std::string& plotName = std::string("plotXY"))
    {
        this->internal_plot_interface(x, y, lineFormat, plotName);
    }
    //! \overload
    template <typename Derived1, typename T2>
    inline void plot(
        const Eigen::MatrixBase<Derived1>& x, const std::vector<T2>& y,
        const std::string& lineFormat = std::string("b-"),
        const std::string& plotName = std::string("plotXY"))
    {
        this->internal_plot_interface(x, y, lineFormat, plotName);
    }
    //! \overload
    template <typename Derived1, typename Derived2>
    inline void plot(
        const Eigen::MatrixBase<Derived1>& x,
        const Eigen::MatrixBase<Derived2>& y,
        const std::string& lineFormat = std::string("b-"),
        const std::string& plotName = std::string("plotXY"))
    {
        this->internal_plot_interface(x, y, lineFormat, plotName);
    }
 
    //! \overload
    template <typename T>
    void plot(
        const std::vector<T>& y,
        const std::string& lineFormat = std::string("b-"),
        const std::string& plotName = std::string("plotXY"))
    {
        this->internal_plot_interface(y, lineFormat, plotName);
    }
    //! \overload
    template <typename Derived>
    void plot(
        const Eigen::MatrixBase<Derived>& y,
        const std::string& lineFormat = std::string("b-"),
        const std::string& plotName = std::string("plotXY"))
    {
        this->internal_plot_interface(y, lineFormat, plotName);
    }
 
    /** Set the view area according to the passed coordinated. */
    void axis(
        float x_min, float x_max, float y_min, float y_max,
        bool aspectRatioFix = false);
 
    /** Enable/disable the fixed X/Y aspect ratio fix feature
     * (default=disabled). */
    void axis_equal(bool enable = true);
 
    /** Fix automatically the view area according to existing graphs. */
    void axis_fit(bool aspectRatioFix = false);
 
    /** Plots a 2D ellipse given its mean, covariance matrix, and
     *  Each call to this function creates a new plot, unless the plot name
     * coincides with an already existing plot: in this case the new values are
     * used to update this existing layer (this also applies to using the
     * default plot name).
     *  If "hold_on" is enabled, then every call will always create a new plot,
     * even if no "plotName" is provided.
     *
     *  For a description of lineFormat see CDisplayWindowPlots::plot.
     *  The "quantiles" value determines the confidence interval for the
     * ellipse:
     *     - 1 : 68.27% confidence interval
     *     - 2 : 95.45%
     *     - 3 : 99.73%
     *     - 4 : 99.994%
     * \note This method can be called with 2x2 fixed-sized or dynamic-size
     * matrices of types: float or double.
     * \sa axis, axis_equal, axis_fit, hold_on, hold_off
     */
    template <typename T>
    void plotEllipse(
        const T mean_x, const T mean_y,
        const mrpt::math::CMatrixTemplateNumeric<T>& cov22,
        const float quantiles,
        const std::string& lineFormat = std::string("b-"),
        const std::string& plotName = std::string("plotEllipse"),
        bool showName = false);
 
    //! \overload
    template <typename T>
    void plotEllipse(
        const T mean_x, const T mean_y,
        const mrpt::math::CMatrixFixedNumeric<T, 2, 2>& cov22,
        const float quantiles,
        const std::string& lineFormat = std::string("b-"),
        const std::string& plotName = std::string("plotEllipse"),
        bool showName = false);
 
    /** Adds a bitmap image layer.
     *  Each call to this function creates a new layer, unless the plot name
     * coincides with an already existing plot: in this case the new values are
     * used to update this existing layer (this also applies to using the
     * default plot name).
     *
     * \sa axis, axis_equal, axis_fit, hold_on, hold_off
     */
    void image(
        const mrpt::img::CImage& img, const float& x_left,
        const float& y_bottom, const float& x_width, const float& y_height,
        const std::string& plotName = std::string("image"));
 
    /** Remove all plot objects in the display.
     * \sa plot
     */
    void clear();
 
    /** Remove all plot objects in the display (clear and clf do exactly the
     * same).
     * \sa plot, hold_on, hold_off
     */
    inline void clf() { clear(); }
    /** Enables keeping all the graphs, instead of overwritting them.
     * \sa hold_off, plot
     */
    void hold_on();
 
    /** Disables keeping all the graphs (this is the default behavior).
     * \sa hold_on, plot
     */
    void hold_off();
 
    /** Disables keeping all the graphs (this is the default behavior).
     * \param label The text that appears in the new popup menu item.
     * \param menuID Any positive number (0,1,..). Used to tell which menu was
     * selected in the user callback.
     * \sa setMenuCallback
     */
    void addPopupMenuEntry(const std::string& label, int menuID);
 
    /** Must be called to have a callback when the user selects one of the
     * user-defined entries in the popup menu.
     * \sa addPopupMenuEntry
     */
    void setMenuCallback(TCallbackMenu userFunction, void* userParam = nullptr);
 
};  // End of class def.
}
#endif