.. _program_listing_file_larflow_KeyPoints_PrepKeypointData.h:

Program Listing for File PrepKeypointData.h
===========================================

|exhale_lsh| :ref:`Return to documentation for file <file_larflow_KeyPoints_PrepKeypointData.h>` (``larflow/KeyPoints/PrepKeypointData.h``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   #ifndef __PREP_KEYPOINT_DATA_H__
   #define __PREP_KEYPOINT_DATA_H__
   
   #include <Python.h>
   #include "bytesobject.h"
   
   #include <vector>
   #include <string>
   
   #include "larflow/LArFlowConstants/LArFlowConstants.h"
   #include "larflow/PrepFlowMatchData/PrepMatchTriplets.h"
   
   #include "KPdata.h"
   
   class TH1F;
   class TH2D;
   
   namespace larcv {
     class Image2D;
     class IOManager;
   }
   
   namespace larlite {
     class event_mctrack;
     class event_mcshower;
     class event_mctruth;
     class storage_manager;
   }
   
   namespace larutil {
     class SpaceChargeMicroBooNE;
   }
   
   namespace ublarcvapp {
   namespace mctools {
     class MCPixelPGraph;
   }
   }
   
   namespace larflow {
   namespace keypoints {
     
   
     class PrepKeypointData {
     public:
   
       PrepKeypointData();
       virtual ~PrepKeypointData();
   
       void process( larcv::IOManager& iolcv,
                     larlite::storage_manager& ioll );
       
       void process( const std::vector<larcv::Image2D>&    adc_v,
                     const std::vector<larcv::Image2D>&    badch_v,
                     const std::vector<larcv::Image2D>&    segment_v,
                     const std::vector<larcv::Image2D>&    instance_v,
                     const std::vector<larcv::Image2D>&    ancestor_v,
                     const larlite::event_mctrack&  mctrack_v,
                     const larlite::event_mcshower& mcshower_v,
                     const larlite::event_mctruth&  mctruth_v );
   
       void make_proposal_labels( const larflow::prep::PrepMatchTriplets& match_proposals );
       
     protected:
   
       std::string _adc_image_treename; 
       
   
       std::vector<KPdata> _kpd_v; 
       
       std::vector<KPdata>    
         getMuonEndpoints( ublarcvapp::mctools::MCPixelPGraph& mcpg,
                           const std::vector<larcv::Image2D>& adc_v,
                           const larlite::event_mctrack& mctrack_v,
                           larutil::SpaceChargeMicroBooNE* psce );
       
       std::vector<KPdata>
         getShowerStarts( ublarcvapp::mctools::MCPixelPGraph& mcpg,
                          const std::vector<larcv::Image2D>& adc_v,
                          const larlite::event_mcshower& mcshower_v,
                          larutil::SpaceChargeMicroBooNE* psce );
   
       void _label_nu_keypoints( const larlite::event_mctruth& mctruth_v,
                                 const std::vector<larcv::Image2D>& adc_v,
                                 larutil::SpaceChargeMicroBooNE* psce,
                                 std::vector<KPdata>& kpdata_v  );
       
       void filter_duplicates();
   
     public:
   
       void setADCimageTreeName(std::string treename) { _adc_image_treename=treename; };
   
       const std::vector<KPdata>& getKPdata() const { return _kpd_v; };
   
       void printKeypoints() const;
               
     public:
   
       PyObject* get_keypoint_array(int ikpclass ) const;
       PyObject* get_triplet_score_array( float sig ) const;
   
       
     protected:
   
       // PROPOSAL LABELS
       // ----------------
       
       std::vector< std::vector<float> > _match_proposal_labels_v[3]; 
   
       // Ana Tree
       int _run; 
       int _subrun; 
       int _event;  
       TTree* _label_tree; 
       std::vector< std::vector<float> > _kppos_v[3]; 
       //< we need to keep a list of primary pixels to limit the neutrino score field    
       //std::vector< std::set<std::pair<int,int> > >  _primarypixels_v; 
       
     public:
       
       void defineAnaTree();
       void writeAnaTree();
   
       void fillAnaTree() { if (_label_tree) _label_tree->Fill(); };
   
     public:
   
       // statistics variables
       TH1F* hdist[3]; 
       TH1F* hdpix[4]; 
       int _nclose;    
       int _nfar;      
       void writeHists();
   
       std::vector<TH2D> makeScoreImage( const int ikpclass, const float sigma,
                                         const std::string histname,
                                         const larflow::prep::PrepMatchTriplets& tripmaker,
                                         const std::vector<larcv::Image2D>& adc_v ) const;
       
     private:
       
       static bool _setup_numpy; 
       
     };
   
   }
   }
   
   #endif