HoughSeedFinderAlg.h

Go to the documentation of this file.

#ifndef HoughSeedFinderAlg_h
#define HoughSeedFinderAlg_h

#include "larreco/RecoAlg/Cluster3DAlgs/SeedFinderAlgBase.h"
#include "larreco/RecoAlg/Cluster3DAlgs/PrincipalComponentsAlg.h"

// LArSoft includes
#include "larcore/Geometry/Geometry.h"
#include "lardataobj/RecoBase/Seed.h"

// Algorithm includes
#include "larreco/RecoAlg/Cluster3DAlgs/Cluster3D.h"

// ROOT includes
#include "TCanvas.h"
#include "TFrame.h"
#include "TH2D.h"

//------------------------------------------------------------------------------------------------------------------------------------------

namespace lar_cluster3d
{

class HoughSeedFinderAlg : virtual public SeedFinderAlgBase
{
public:
    HoughSeedFinderAlg(fhicl::ParameterSet const &pset);

    virtual ~HoughSeedFinderAlg();
    
    virtual void reconfigure(fhicl::ParameterSet const &pset);
    
    virtual bool findTrackSeeds(reco::HitPairListPtr&      hitPairListPtr,
                                reco::PrincipalComponents& inputPCA,
                                SeedHitPairListPairVec&    seedHitPairVec) const;
    
    virtual bool findTrackHits(reco::HitPairListPtr&      hitPairListPtr,
                               reco::PrincipalComponents& inputPCA,
                               reco::HitPairListPtrList&  hitPairListPtrList) const;

private:
    
    void findHitGaps(reco::HitPairListPtr& inputHitList, reco::HitPairListPtr& outputList) const;
    
    class  AccumulatorBin;
    class  SortHoughClusterList;
    struct SortBinIndexList;
    
    // Basic structure for holding our accumlator bins (to avoid a full array)
    // structure will be rho bin for first key, theta bin for second key
    typedef std::pair<int, int>                BinIndex;
    typedef std::map<BinIndex, AccumulatorBin> RhoThetaAccumulatorBinMap;
    typedef std::list<BinIndex>                HoughCluster;
    typedef std::list<HoughCluster >           HoughClusterList;
    
    void HoughRegionQuery(BinIndex& curBin, RhoThetaAccumulatorBinMap& rhoThetaAccumulatorBinMap, HoughCluster& neighborPts, size_t threshold) const;
    
    void expandHoughCluster(BinIndex&                  curBin,
                            HoughCluster&              neighborPts,
                            HoughCluster&              houghCluster,
                            RhoThetaAccumulatorBinMap& rhoThetaAccumulatorBinMap,
                            size_t                     threshold) const;
    
    void findHoughClusters(const reco::HitPairListPtr& inputHits,
                           reco::PrincipalComponents&  pca,
                           int&                        nLoops,
                           RhoThetaAccumulatorBinMap&  rhoThetaMap,
                           HoughClusterList&           clusterList) const;
    
    bool buildSeed(reco::HitPairListPtr& seed3DHits, SeedHitPairListPair& seedHitPair) const;

    void LineFit2DHits(std::set<const reco::ClusterHit2D*>& hitList, double XOrigin, TVector3& Pos, TVector3& Dir, double& ChiDOF) const;
    
    size_t                                         m_minimum3DHits;      
    int                                            m_thetaBins;          
    int                                            m_rhoBins;            
    size_t                                         m_hiThresholdMin;     
    double                                         m_hiThresholdFrac;    
    double                                         m_loThresholdFrac;    
    size_t                                         m_numSeed2DHits;      
    double                                         m_numAveDocas;        
    int                                            m_numSkippedHits;     
    int                                            m_maxLoopsPerCluster; 
    double                                         m_maximumGap;         

    geo::Geometry*                                 m_geometry;           // pointer to the Geometry service
    //    const detinfo::DetectorProperties*            m_detector;           // Pointer to the detector properties
    
    PrincipalComponentsAlg                         m_pcaAlg;             // For running Principal Components Analysis
    
    bool                                           m_displayHist;
    mutable std::vector<std::unique_ptr<TCanvas> > m_Canvases;           
    mutable std::vector<TVirtualPad*>              m_Pads;               
};

} // namespace lar_cluster3d
#endif