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 TrackFindingCDC {
 
    class BoundingBox;
 
    class Circle2D;
 
    class CDCWireTopology;
    class CDCWireSuperLayer;
    class CDCWire;
 
    class CDCTrajectory2D;
 
    class CDCWireHit;
    class CDCTangent;
    class CDCRecoHit2D;
    class CDCRecoHit3D;
 
    class CDCWireHitCluster;
    class CDCSegment2D;
    class CDCSegment3D;
 
    class CDCSegmentPair;
    class CDCAxialSegmentPair;
    class CDCSegmentTriple;
 
    class CDCTrack;
 
    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 variuous event data objects.
 
      void draw(const Belle2::TrackFindingCDC::Circle2D& circle,
                AttributeMap attributeMap = AttributeMap());
 
      void draw(const Belle2::TrackFindingCDC::CDCWire& wire,
                const AttributeMap& attributeMap = AttributeMap());
 
      void draw(const Belle2::TrackFindingCDC::CDCWireSuperLayer& wireSuperLayer,
                const AttributeMap& attributeMap = AttributeMap());
 
      void draw(const Belle2::TrackFindingCDC::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 Belle2::TrackFindingCDC::CDCWireHit& wireHit,
                const AttributeMap& attributeMap = AttributeMap());
 
      void draw(const Belle2::TrackFindingCDC::CDCRecoHit2D& recoHit2D,
                const AttributeMap& attributeMap = AttributeMap());
 
      void draw(const Belle2::TrackFindingCDC::CDCRecoHit3D& recoHit3D,
                const AttributeMap& attributeMap = AttributeMap());
 
      void draw(const Belle2::TrackFindingCDC::CDCTangent& tangent,
                const AttributeMap& attributeMap = AttributeMap());
 
      void draw(const CDCTrajectory2D& trajectory2D, AttributeMap attributeMap = AttributeMap());
 
      void draw(const CDCWireHitCluster& wireHitCluster, const AttributeMap& attributeMap = AttributeMap());
 
      void draw(const CDCSegment2D& segment2D, const AttributeMap& attributeMap = AttributeMap());
 
      void draw(const CDCSegment3D& segment3D, const AttributeMap& attributeMap = AttributeMap());
 
      void draw(const CDCAxialSegmentPair& axialSegmentPair, const AttributeMap& attributeMap = AttributeMap());
 
      void draw(const CDCSegmentPair& segmentPair, const AttributeMap& attributeMap = AttributeMap());
 
      void draw(const CDCSegmentTriple& segmentTriple, const AttributeMap& attributeMap = AttributeMap());
 
      void draw(const 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 CDCSegment2D& segment, const AttributeMap& attributeMap = AttributeMap());
 
      void drawTrajectory(const CDCSegmentTriple& segmentTriple, const AttributeMap& attributeMap = AttributeMap());
 
      void drawTrajectory(const 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;
 
    };
  }
}