Graph.h

Go to the documentation of this file.

/*
Copyright 2007-2025. Algoryx Simulation AB.
 
All AGX source code, intellectual property, documentation, sample code,
tutorials, scene files and technical white papers, are copyrighted, proprietary
and confidential material of Algoryx Simulation AB. You may not download, read,
store, distribute, publish, copy or otherwise disseminate, use or expose this
material unless having a written signed agreement with Algoryx Simulation AB, or having been
advised so by Algoryx Simulation AB for a time limited evaluation, or having purchased a
valid commercial license from Algoryx Simulation AB.
 
Algoryx Simulation AB disclaims all responsibilities for loss or damage caused
from using this software, unless otherwise stated in written agreements with
Algoryx Simulation AB.
*/
 
#pragma once
 
 
#include <agx/Vector.h>
#include <agx/Vec3.h>
#include <agx/Vec4.h>
#include <agx/List.h>
 
namespace agxRender
{
 
 
  AGX_DECLARE_POINTER_TYPES( Graph );
 
  class AGXPHYSICS_EXPORT Graph : public agx::Referenced
  {
    public:
 
      typedef agx::Vector<agx::Vec2> DataVector;
 
    AGX_DECLARE_POINTER_TYPES( GraphRenderer );
 
    class AGXPHYSICS_EXPORT GraphRenderer : public agx::Referenced
      {
        public:
          GraphRenderer() {}
 
          virtual void drawText( const agx::Vec2& pos, const agx::String& str ) = 0;
 
          virtual void setColor( const agx::Vec4& color ) = 0;
 
          virtual void drawLine( const agx::Vec2& p1, const agx::Vec2& p2 ) const = 0;
 
          virtual void preDraw() = 0;
 
          virtual void postDraw() = 0;
 
          virtual void clear() = 0;
 
          virtual void setEnable( bool flag ) = 0;
 
          virtual void addChannel() = 0;
 
          virtual size_t getNumChannels() const = 0;
 
          virtual void removeChannel() = 0;
 
          virtual void drawData( size_t channelIndex, const Graph::DataVector& data ) = 0;
 
 
        protected:
 
          friend class Graph;
          agx::observer_ptr<Graph> m_graph;
          virtual ~GraphRenderer() {}
      };
 
 
    class AGXPHYSICS_EXPORT Channel : public agx::Referenced
      {
        public:
 
          Channel( const agx::String& title , const agx::Vec4& color,
                   float minVal, float maxVal,
                   float scaleX = 1.0f,  float scaleY = 1.0f );
 
          void setResolution( size_t r ) {
            m_cacheSize = r;
          }
          void update( float data );
 
          void setEnableMA( bool flag ) {
            m_maEnabled = flag;
          }
          bool getEnableMA( ) const {
            return m_maEnabled;
          }
 
          const agx::Vec4& getColor() const {
            return m_color;
          }
        protected:
 
          float mapToLimits( float val ) const;
 
          agx::String m_title;
 
          void drawTitle( const agx::Vec2& pos );
          void drawData() ;
          void drawMovingAverage() ;
 
          friend class Graph;
 
          virtual ~Channel() {}
 
        private:
 
          agx::observer_ptr<Graph> m_parent;
 
          bool m_maEnabled;
          float m_scaleX;
          float m_scaleY;
 
          agx::Vec4 m_color;
 
          float m_limits[2];
 
          size_t m_cacheSize;
 
          agx::List<float> m_data;
          agx::List<float> m_movingAverage;
      };
 
      Graph( float width = float( 0.9 ), float height = float( 0.2 ), const agx::Vec2& offset = agx::Vec2( agx::Real( 0.01 ), agx::Real( 0.01 ) ) );
      void setSize( float width, float height ) {
        m_width = width;
        m_height = height;
      }
      void setOffset( const agx::Vec2& offset ) {
        m_offset = offset;
      }
 
      bool validate() const;
 
      void addChannel( Channel *channel );
      size_t numChannels() const {
        return m_channels.size();
      }
      void clearChannels();
 
      void setEnable( bool flag );
      bool getEnable(  ) const {
        return m_enable;
      }
 
      Channel *getChannel( size_t idx ) {
        if ( idx >= m_channels.size() ) return nullptr;
        return m_channels[idx];
      }
 
      void setRenderer( GraphRenderer *renderer ) {
        m_renderer = renderer;
        renderer->m_graph = this;
      }
      GraphRenderer *getRenderer(  ) {
        return m_renderer;
      }
      const GraphRenderer *getRenderer(  ) const {
        return m_renderer;
      }
 
      const agx::Vec2& getOffset() const {
        return m_offset;
      }
 
      float getWidth() {
        return m_width;
      }
      float getHeight() {
        return m_height;
      }
      void draw();
 
      void clearPoints() {
        m_dataVector.clear();
      }
      void reserve( size_t size ) {
        m_dataVector.reserve( size );
      }
      void addPoint( const agx::Vec2& point );
      void addText( const agx::Vec2& point, const agx::String& str );
 
      void preDraw();
      void postDraw();
 
    protected:
 
      void drawData( size_t channelIndex ) const;
 
      virtual ~Graph();
 
    private:
 
      typedef agx::Vector< agx::ref_ptr<Channel> > ChannelVector;
      ChannelVector m_channels;
 
      agx::ref_ptr<GraphRenderer> m_renderer;
 
 
      float m_width, m_height;
      agx::Vec2 m_offset;
      DataVector m_dataVector;
 
      bool m_enable;
  };
 
}