EventDataPlotter.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
#pragma once
 
#include <tracking/trackFindingCDC/display/PrimitivePlotter.h>
 
#include <framework/datastore/StoreArray.h>
 
#include <memory>
 
namespace Belle2 {
  class MCParticle;
  class RecoTrack;
  class CDCHit;
  class CDCSimHit;
 
  namespace CDC {
    class CDCWireTopology;
    class CDCWireSuperLayer;
    class CDCWire;
  }
 
  namespace TrackingUtilities {
    class Circle2D;
    class CDCTrajectory2D;
    class CDCWireHit;
    class CDCTrack;
    class CDCRecoHit3D;
    class CDCRecoHit2D;
    class CDCWireHitCluster;
    class CDCSegment2D;
    class CDCSegment3D;
    class CDCSegmentPair;
    class CDCAxialSegmentPair;
    class CDCSegmentTriple;
    class CDCTangent;
  }
 
  namespace TrackFindingCDC {
    class BoundingBox;
 

    class EventDataPlotter {
 
 
    public:
      using AttributeMap = PrimitivePlotter::AttributeMap;
 
    public:
      explicit EventDataPlotter(bool animate = false, bool forwardFade = false);

      explicit EventDataPlotter(std::unique_ptr<PrimitivePlotter> ptrPrimitivePlotter,
                                bool animate = false,
                                bool forwardFade = false);

      EventDataPlotter(const EventDataPlotter& eventDataPlotter);
 
    public:
      const std::string save(const std::string& fileName);

      void clear();
 
    public:
      BoundingBox getBoundingBox() const;

      void setBoundingBox(const BoundingBox& boundingBox);

      float getCanvasWidth() const;

      float getCanvasHeight() const;

      void setCanvasWidth(float width);

      void setCanvasHeight(float height);

      void startGroup(const AttributeMap& attributeMap = AttributeMap());

      void endGroup();
 
    public:
      std::string getAnimationTimeFromNanoSeconds(float nanoseconds)
      {
        return std::to_string(nanoseconds) + "s";
      }
 
    private:
      void startAnimationGroup(const Belle2::CDCSimHit& simHit);

      void startAnimationGroup(const Belle2::CDCHit* ptrHit);
 
    public:
      void drawInteractionPoint();

      void drawInnerCDCWall(const AttributeMap& attributeMap = AttributeMap());

      void drawOuterCDCWall(const AttributeMap& attributeMap = AttributeMap());

      void drawSuperLayerBoundaries(const AttributeMap& attributeMap = AttributeMap());

      void drawLine(float startX,
                    float startY,
                    float endX,
                    float endY,
                    const AttributeMap& attributeMap = AttributeMap());
 
    public:
      // Drawing methods for the various event data objects.

      void draw(const TrackingUtilities::Circle2D& circle,
                AttributeMap attributeMap = AttributeMap());

      void draw(const CDC::CDCWire& wire,
                const AttributeMap& attributeMap = AttributeMap());

      void draw(const CDC::CDCWireSuperLayer& wireSuperLayer,
                const AttributeMap& attributeMap = AttributeMap());

      void draw(const CDC::CDCWireTopology& wireTopology,
                AttributeMap attributeMap = AttributeMap());

      void draw(const CDCSimHit& simHit,
                const AttributeMap& attributeMap = AttributeMap());

      void draw(const CDCHit& hit,
                const AttributeMap& attributeMap = AttributeMap());

      void draw(const TrackingUtilities::CDCWireHit& wireHit,
                const AttributeMap& attributeMap = AttributeMap());

      void draw(const TrackingUtilities::CDCRecoHit2D& recoHit2D,
                const AttributeMap& attributeMap = AttributeMap());

      void draw(const TrackingUtilities::CDCRecoHit3D& recoHit3D,
                const AttributeMap& attributeMap = AttributeMap());

      void draw(const TrackingUtilities::CDCTangent& tangent,
                const AttributeMap& attributeMap = AttributeMap());

      void draw(const TrackingUtilities::CDCTrajectory2D& trajectory2D, AttributeMap attributeMap = AttributeMap());

      void draw(const TrackingUtilities::CDCWireHitCluster& wireHitCluster, const AttributeMap& attributeMap = AttributeMap());

      void draw(const TrackingUtilities::CDCSegment2D& segment2D, const AttributeMap& attributeMap = AttributeMap());

      void draw(const TrackingUtilities::CDCSegment3D& segment3D, const AttributeMap& attributeMap = AttributeMap());

      void draw(const TrackingUtilities::CDCAxialSegmentPair& axialSegmentPair, const AttributeMap& attributeMap = AttributeMap());

      void draw(const TrackingUtilities::CDCSegmentPair& segmentPair, const AttributeMap& attributeMap = AttributeMap());

      void draw(const TrackingUtilities::CDCSegmentTriple& segmentTriple, const AttributeMap& attributeMap = AttributeMap());

      void draw(const TrackingUtilities::CDCTrack& track, const AttributeMap& attributeMap = AttributeMap());

      void draw(const RecoTrack& recoTrack, const AttributeMap& attributeMap = AttributeMap());

      void drawTrajectory(const MCParticle& mcParticle, const AttributeMap& attributeMap = AttributeMap());

      void drawTrajectory(const TrackingUtilities::CDCSegment2D& segment, const AttributeMap& attributeMap = AttributeMap());

      void drawTrajectory(const TrackingUtilities::CDCSegmentTriple& segmentTriple, const AttributeMap& attributeMap = AttributeMap());

      void drawTrajectory(const TrackingUtilities::CDCTrack& track, const AttributeMap& attributeMap = AttributeMap());

      void drawTrajectory(const RecoTrack& recoTrack, const AttributeMap& attributeMap = AttributeMap());

      template<class T>
      void draw(const T* ptr, const AttributeMap& attributeMap = AttributeMap())
      {
        if (ptr) draw(*ptr, attributeMap);
      }

      template<class T>
      void draw(const StoreArray<T>& storeArray, const AttributeMap& attributeMap = AttributeMap())
      {
        if (not storeArray) return;
        drawRange(storeArray, attributeMap);
      }

      template<class ARange>
      void drawRange(const ARange& range, const AttributeMap& attributeMap = AttributeMap())
      {
        if (not m_ptrPrimitivePlotter) return;
        PrimitivePlotter& primitivePlotter = *m_ptrPrimitivePlotter;
        primitivePlotter.startGroup(attributeMap);
        for (const auto& element : range) {
          draw(element);
        }
        primitivePlotter.endGroup();
      }

      template<class ARange>
      void drawRangeWithFade(const ARange& range, const AttributeMap& attributeMap = AttributeMap())
      {
        if (not m_ptrPrimitivePlotter) return;
        PrimitivePlotter& primitivePlotter = *m_ptrPrimitivePlotter;
        primitivePlotter.startGroup(attributeMap);
        float opacity = 1;
        float endOpacity = 0.5;
        int n = std::distance(std::begin(range), std::end(range));
        if (n == 0) return;
        float opacityFactor = std::pow(endOpacity / opacity, 1.0 / (n - 1));
        for (const auto& element : range) {
          const auto opacity_str = std::to_string(opacity);
          AttributeMap elementAttributeMap{{"opacity", opacity_str}};
          draw(element, elementAttributeMap);
          opacity *= opacityFactor;
        }
        primitivePlotter.endGroup();
      }
 
    private:
      std::unique_ptr<PrimitivePlotter> m_ptrPrimitivePlotter;

      bool m_animate = false;

      bool m_forwardFade = false;
 
    };
  }
}