.. _program_listing_file_larflow_PrepFlowMatchData_FlowTriples.h:

Program Listing for File FlowTriples.h
======================================

|exhale_lsh| :ref:`Return to documentation for file <file_larflow_PrepFlowMatchData_FlowTriples.h>` (``larflow/PrepFlowMatchData/FlowTriples.h``)

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

.. code-block:: cpp

   #ifndef __FLOW_TRIPLES_H__
   #define __FLOW_TRIPLES_H__
   
   
   #include <map>
   #include <vector>
   
   #include "larflow/LArFlowConstants/LArFlowConstants.h"
   #include "larcv/core/DataFormat/Image2D.h"
   #include "TH2D.h"
   
   namespace larflow {
   namespace prep {
   
     class FlowTriples {
   
     public:
   
       struct PixData_t {
         int row; 
         int col; 
         float val; 
         int idx;   
         
         PixData_t()
         : row(0),col(0),val(0.0),idx(0)
         {};
   
         PixData_t( int r, int c, float v)
         : row(r),col(c),val(v),idx(0) {};
   
         bool operator<( const PixData_t& rhs ) const {
           if (row<rhs.row) return true;
           if ( row==rhs.row ) {
             if ( col<rhs.col ) return true;
             if ( col==rhs.col ) {
               if ( val<rhs.val ) return true;
             }
           }
           return false;
         };
       };
       
       FlowTriples()
         : _source_plane(-1),
         _target_plane(-1),
         _other_plane(-1) {
       };
       
       FlowTriples( int source_plane, int target_plane,
                    const std::vector<larcv::Image2D>& adc_v,
                    const std::vector<larcv::Image2D>& badch_v,
                    float threshold, bool save_index );
   
       FlowTriples( int source, int target,
                    const std::vector<larcv::Image2D>& adc_v,
                    const std::vector<larcv::Image2D>& badch_v,
                    const std::vector< std::vector<PixData_t> >& sparseimg_vv,
                    float threshold, bool save_index );
       
       
       virtual ~FlowTriples() {};
   
       int nsourceIndices() const {
         if ( _source_plane==-1 ) return 0;
         return (int)_sparseimg_vv[_source_plane].size();
       };
   
       // retrieve candidate matches to source pixel via index
       //const std::vector<int>& getTargetIndices( int src_index ) const;
       //const std::vector<int>& getTruthVector( int src_index )   const;
   
       // retrieve candidate matches to source image via target index
       //const std::vector<int>& getTargetIndicesFromSourcePixel( int col, int row ) const;
       //const std::vector<int>& getTruthVectorFromSourcePixel( int col, int row ) const;
   
       static std::vector< std::vector<FlowTriples::PixData_t> >
         make_initial_sparse_image( const std::vector<larcv::Image2D>& adc_v, float threshold );
   
       int get_source_plane_index() { return _source_plane; };
   
       int get_target_plane_index() { return _target_plane; };
   
       int get_other_plane_index()  { return _other_plane; };
   
       std::vector<TH2D> plot_triple_data( const std::vector<larcv::Image2D>& adc_v,
                                           const std::vector< std::vector<PixData_t> >& sparseimg_vv,                                        
                                           std::string hist_stem_name );
       
       std::vector<TH2D> plot_sparse_data( const std::vector<larcv::Image2D>& adc_v,
                                           const std::vector< std::vector<PixData_t> >& sparseimg_vv,
                                           std::string hist_stem_name );
   
       std::vector< std::vector<PixData_t> >& getDeadChToAdd() { return _deadch_to_add; };
   
       std::vector< std::vector<int> >&       getTriples() { return _triple_v; };
                                                               
     protected:
   
       int _source_plane; 
       int _target_plane; 
       int _other_plane;  
   
       std::vector< std::vector< PixData_t > > _sparseimg_vv;  
       std::vector< std::vector<int> >         _triple_v;      
       std::vector< std::vector<PixData_t> >   _deadch_to_add; 
   
       void _makeTriples( int source, int target,
                          const std::vector<larcv::Image2D>& adc_v,
                          const std::vector<larcv::Image2D>& badch_v,
                          const std::vector< std::vector<PixData_t> >& sparseimg_vv,                                  
                          float threshold, bool save_index );
       
         
     };
   
   }
   }
   
   #endif