DBScanAlg.h

Go to the documentation of this file.

//  \fileDBScanAlg.h
//  kinga.partyka@yale.edu
#ifndef DBSCANALG_H
#define DBSCANALG_H

#include <vector>
#include <cmath>
#include <iostream>
#include <stdint.h>

#include "fhiclcpp/ParameterSet.h" 
#include "canvas/Persistency/Common/Ptr.h"
#include "canvas/Persistency/Common/PtrVector.h"
#include "larreco/ClusterFinder/RStarTree/RStarTree.h"
#include "larcore/Geometry/Geometry.h"

class TH1F;

namespace recob { class Hit; }

// RStarTree related infrastructure
//
// Our core objects have a physical extent (I.e. there are not
// points), but a R*-tree should be able to deal with that.
class dbsPoint; // forward declaration
typedef RStarTree< uint32_t, 2, 32, 64 > RTree; // payload is just an index
typedef RTree::BoundingBox BoundingBox;

namespace cluster{

  //--------------------------------------------------------------- 
  class DBScanAlg {
  public:
    
    
    DBScanAlg(fhicl::ParameterSet const& pset);
    virtual ~DBScanAlg();
    
    void reconfigure(fhicl::ParameterSet const& p);
    void InitScan(const std::vector< art::Ptr<recob::Hit> >& allhits, 
                  std::set<uint32_t> badChannels,
                  const std::vector<geo::WireID> & wireids = std::vector< geo::WireID>()); //wireids is optional
    double getSimilarity(const std::vector<double> v1, 
                         const std::vector<double> v2); 
    std::vector<unsigned int> findNeighbors( unsigned int pid, 
                                             double threshold, 
                                             double threshold2);
    void computeSimilarity();
    void run_cluster();     
    double getSimilarity2(const std::vector<double> v1, 
                          const std::vector<double> v2); 
    void computeSimilarity2();
    double getWidthFactor(const std::vector<double> v1, 
                          const std::vector<double> v2); 
    void computeWidthFactor();
    
    
    std::vector<std::vector<unsigned int> > fclusters;               
    std::vector<std::vector<double> >       fps;                     
    std::vector<unsigned int>               fpointId_to_clusterId;   
    std::vector<std::vector<double> >       fsim;                    
    std::vector<std::vector<double> >       fsim2;                   
    std::vector<std::vector<double> >       fsim3;                   
    double fMaxWidth;

    RTree fRTree;
    std::vector< dbsPoint > fRect;
    
  private:
    
    // eps radius
    // Two points are neighbors if the distance 
    // between them does not exceed threshold value.
    double fEps;
    double fEps2;
    //minimum number of points
    unsigned int fMinPts;
    // Which clustering to run
    unsigned int fClusterMethod;  
    unsigned int fDistanceMetric; 
      
    // noise vector
    std::vector<bool>      fnoise;      
    std::vector<bool>      fvisited;                                         
    std::vector<double>    fWirePitch;     
    std::set<uint32_t>     fBadChannels;   
    std::vector<uint32_t>  fBadWireSum;    
    
    // Three differnt version of the clustering code
    void run_dbscan_cluster();     
    void run_FN_cluster();     
    void run_FN_naive_cluster();     

    // Helper routined for run_dbscan_cluster() names and
    // responsibilities taken directly from the paper
    bool ExpandCluster(unsigned int point /* to be added */, 
                       unsigned int clusterID /* which is being expanded */);
    std::set<unsigned int> RegionQuery(unsigned int point);
    // Helper for the accelerated run_FN_cluster()
    std::vector<unsigned int> RegionQuery_vector(unsigned int point);


  }; // class DBScanAlg
} // namespace

#endif // ifndef DBSCANALG_H