#include "HoughBaseAlg.h"

Public Member Functions
	HoughTransform ()

	~HoughTransform ()

void	Init (unsigned int dx, unsigned int dy, float rhores, unsigned int numACells)

std::array< int, 3 >	AddPointReturnMax (int x, int y)

bool	SubtractPoint (int x, int y)

int	GetCell (int row, int col) const

void	SetCell (int row, int col, int value)

void	GetAccumSize (int &numRows, int &numCols)

int	NumAccumulated ()

void	GetEquation (float row, float col, float &rho, float &theta) const

int	GetMax (int &xmax, int &ymax) const

void	reconfigure (fhicl::ParameterSet const &pset)

Private Types
typedef HoughTransformCounters< int, signed char, 64 >	BaseMap_t
	rho -> # hits (for convenience) More...

typedef HoughTransformCounters< int, signed char, 64 >	DistancesMap_t

typedef std::vector< DistancesMap_t >	HoughImage_t
	Type of the Hough transform (angle, distance) map with custom allocator. More...

Private Member Functions
std::array< int, 3 >	DoAddPointReturnMax (int x, int y, bool bSubtract=false)

Private Attributes
unsigned int	m_dx

unsigned int	m_dy

unsigned int	m_rowLength

unsigned int	m_numAngleCells

float	m_rhoResolutionFactor

HoughImage_t	m_accum
	column (map key)=rho, row (vector index)=theta More...

int	m_numAccumulated

std::vector< double >	m_cosTable

std::vector< double >	m_sinTable

Detailed Description

Definition at line 481 of file HoughBaseAlg.h.

Member Typedef Documentation

typedef HoughTransformCounters<int, signed char, 64> cluster::HoughTransform::BaseMap_t

private

rho -> # hits (for convenience)

Definition at line 507 of file HoughBaseAlg.h.

typedef HoughTransformCounters<int, signed char, 64> cluster::HoughTransform::DistancesMap_t

private

Definition at line 520 of file HoughBaseAlg.h.

typedef std::vector<DistancesMap_t> cluster::HoughTransform::HoughImage_t

private

Type of the Hough transform (angle, distance) map with custom allocator.

Definition at line 525 of file HoughBaseAlg.h.

Constructor & Destructor Documentation

cluster::HoughTransform::HoughTransform ( )

Definition at line 241 of file HoughBaseAlg.cxx.

 {  
   //m_accum=NULL;
 }

cluster::HoughTransform::~HoughTransform ( )

Definition at line 787 of file HoughBaseAlg.cxx.

788 {

789 }

Member Function Documentation

std::array< int, 3 > cluster::HoughTransform::AddPointReturnMax	(	int	x,
		int	y
	)

inline

Definition at line 801 of file HoughBaseAlg.cxx.

References max.

Referenced by cluster::HoughBaseAlg::FastTransform(), and cluster::HoughBaseAlg::Transform().

 {
   if ((x > (int) m_dx) || (y > (int) m_dy) || x<0.0 || y<0.0) {
     std::array<int, 3> max;
     max.fill(0);
     return max;
   }
   return DoAddPointReturnMax(x, y, false); // false = add
 }

std::array< int, 3 > cluster::HoughTransform::DoAddPointReturnMax	(	int	x,
		int	y,
		bool	bSubtract = `false`
	)

private

Definition at line 910 of file HoughBaseAlg.cxx.

References cluster::HoughTransformCounters< KEY, COUNTER, SIZE, ALLOC, SUBCOUNTERS >::decrement(), cluster::HoughTransformCounters< KEY, COUNTER, SIZE, ALLOC, SUBCOUNTERS >::increment_and_get_max(), and max.

Referenced by GetMax().

 {
   std::array<int, 3> max;
   max.fill(-1);
   
   // max_val is the current maximum number of hits aligned on a line so far;
   // currently the code ignores all the lines with just two aligned hits
   int max_val = 2;
   //int max_val = minHits-1;
   
   const int distCenter = (int)(m_rowLength/2.);
   
   // prime the lastDist variable so our linear fill works below
   // lastDist represents next distance to be incremented (but see below)
   int lastDist = (int)(distCenter + (m_rhoResolutionFactor*x));
   
  
   // loop through all angles a from 0 to 180 degrees
   // (the value of the angle is established in definition of m_cosTable and
   // m_sinTable in HoughTransform::Init()
   for (size_t iAngleStep = 1; iAngleStep < m_numAngleCells; ++iAngleStep) {
     
     // Calculate the basic line equation dist = cos(a)*x + sin(a)*y.
     // Shift to center of row to cover negative values;
     // this math must also be coherent with the one in GetEquation()
     const int dist = (int) (distCenter + m_rhoResolutionFactor
       * (m_cosTable[iAngleStep]*x + m_sinTable[iAngleStep]*y)
       );
     
     /*
      * For this angle, we are going to increment all the cells starting from the
      * last distance in the previous loop, up to the current one (dist),
      * with the exception that if we are incrementing more than one cell,
      * we do not increment dist cell itself (it will be incremented in the
      * next angle). 
      * The cell of the last distance is always incremented,
      * whether it was also for the previous angle (in case there was only one
      * distance to be incremented) or not (if there was a sequence of distances
      * to increment, and then the last distance was not).
      * First we increment the last cell of our range; this provides us with a
      * hint of where the immediate previous cell should be, which saves us a
      * look up.
      * We collect and return information about the local maximum among the cells
      * we are increasing.
      */
     
     // establish the range of cells to increase: [ first_dist, end_dist [ ;
     // also set lastDist so that it points to the next cell to be incremented,
     // according to the rules described above
     int first_dist;
     int end_dist;
     if(lastDist == dist) {
       // the range is [ dist, dist + 1 [ (that is, [ dist ]
       first_dist = dist;
       end_dist   = dist + 1;
     }
     else {
       // the range is [ lastDist, dist [ or ] dist, lastDist]
       first_dist = dist > lastDist? lastDist: dist + 1;
       end_dist   = dist > lastDist? dist: lastDist + 1;
     }
     
     // sanity check to make sure we stay within our row
   //  if (dist >= 0 && dist<m_rowLength){
     
     // DEBUG
 //    const float a = iAngleStep / m_numAngleCells * PI;
 //    std::cout << "AD " << iAngleStep << " " << dist
 //      << "\n" << a << " [ " << first_dist << " ; " << end_dist << " ["
 //      << std::endl;
     
     DistancesMap_t& distMap = m_accum[iAngleStep];
     if (bSubtract) {
       distMap.decrement(first_dist, end_dist);
     }
     else {
       DistancesMap_t::PairValue_t max_counter
         = distMap.increment_and_get_max(first_dist, end_dist, max_val);
       
       if (max_counter.second > max_val) {
         // DEBUG
       //  std::cout << " <NEW MAX " << max_val << " => " << max_counter.second << " >" << std::endl;
         // BUG the double brace syntax is required to work around clang bug 21629
         // (https://bugs.llvm.org/show_bug.cgi?id=21629)
         max = {{ max_counter.second, max_counter.first.key(), (int) iAngleStep }};
         max_val = max_counter.second;
       }
     }
     lastDist = dist;
     
     // DEBUG
   //  std::cout << "\n (max " << max[1] << " => " << max[0] << ")" << std::endl;
   //  }
   } // for angles
   if (bSubtract) --m_numAccumulated;
   else           ++m_numAccumulated;
   
   //mf::LogVerbatim("HoughBaseAlg") << "Add point says xmax: " << *xmax << " ymax: " << *ymax << std::endl;
 
   return max;
 } // cluster::HoughTransform::DoAddPointReturnMax()

void cluster::HoughTransform::GetAccumSize	(	int &	numRows,
		int &	numCols
	)

inline

Definition at line 493 of file HoughBaseAlg.h.

Referenced by cluster::HoughBaseAlg::Transform().

     { 
       numRows = m_accum.size();
       numCols  = (int) m_rowLength;
     }

int cluster::HoughTransform::GetCell	(	int	row,
		int	col
	)		const

inline

Definition at line 793 of file HoughBaseAlg.cxx.

References col.

Referenced by cluster::HoughBaseAlg::FastTransform(), and cluster::HoughBaseAlg::Transform().

                                                                 {
   return m_accum[row][col];
 } // cluster::HoughTransform::GetCell()

void cluster::HoughTransform::GetEquation	(	float	row,
		float	col,
		float &	rho,
		float &	theta
	)		const

Definition at line 883 of file HoughBaseAlg.cxx.

Referenced by cluster::HoughBaseAlg::FastTransform(), Init(), and cluster::HoughBaseAlg::Transform().

 {
   theta = (TMath::Pi()*row)/m_numAngleCells;
   rho   = (col - (m_rowLength/2.))/m_rhoResolutionFactor;
 } // cluster::HoughTransform::GetEquation()

int cluster::HoughTransform::GetMax	(	int &	xmax,
		int &	ymax
	)		const

Definition at line 890 of file HoughBaseAlg.cxx.

References DoAddPointReturnMax().

Referenced by cluster::HoughBaseAlg::Transform().

 {
   int maxVal = -1;
   for(unsigned int i = 0; i < m_accum.size(); i++){
     
     DistancesMap_t::PairValue_t max_counter = m_accum[i].get_max(maxVal);
     if (max_counter.second > maxVal) {
       maxVal = max_counter.second;
       xmax = i;
       ymax = max_counter.first.key();
     }
   } // for angle
   
   return maxVal;
 }

void cluster::HoughTransform::Init	(	unsigned int	dx,
		unsigned int	dy,
		float	rhores,
		unsigned int	numACells
	)

Definition at line 824 of file HoughBaseAlg.cxx.

References GetEquation(), and PI.

Referenced by cluster::HoughBaseAlg::FastTransform(), and cluster::HoughBaseAlg::Transform().

 {
   m_numAngleCells=numACells;
   m_rhoResolutionFactor = rhores;
   
   m_accum.clear();
   //--- BEGIN issue #19494 -----------------------------------------------------
   // BulkAllocator.h is currently broken; see issue #19494 and comment in header.
 #if 0
   // set the custom allocator for nodes to allocate large chunks of nodes;
   // one node is 40 bytes plus the size of the counters block.
   // The math over there sets a bit less than 10 MiB per chunk.
   // to find out the right type name to put here, comment out this line
   // (it will suppress some noise), set bDebug to true in
   // lardata/Utilities/BulkAllocator.h and run this module;
   // all BulkAllocator instances will advertise that they are being created,
   // mentioning their referring type. You can also simplyfy it by using the
   // available typedefs, like here:
   lar::BulkAllocator<
     std::_Rb_tree_node
       <std::pair<const DistancesMap_t::Key_t, DistancesMap_t::CounterBlock_t>>
     >::SetChunkSize(
     10 * ((1048576 / (40 + sizeof(DistancesMap_t::CounterBlock_t))) & ~0x1FFU)
     );
 #endif // 0
   //--- END issue #19494 -------------------------------------------------------
   
   //m_accum.resize(m_numAngleCells);
   m_numAccumulated = 0;   
   //   m_cosTable.clear();
   //   m_sinTable.clear();
   //m_cosTable.resize(m_numAngleCells);
   //m_sinTable.resize(m_numAngleCells);
   //if (dx == m_dx && dy == m_dy)
   //return;
   m_dx = dx;
   m_dy = dy;
   m_rowLength = (unsigned int)(m_rhoResolutionFactor*2 * std::sqrt(dx*dx + dy*dy));
   m_accum.resize(m_numAngleCells);
   //for(int i = 0; i < m_numAngleCells; i++)
     //m_accum[i].resize((unsigned int)(m_rowLength));
   
   // this math must be coherent with the one in GetEquation()
   double angleStep = PI/m_numAngleCells;
   m_cosTable.resize(m_numAngleCells);
   m_sinTable.resize(m_numAngleCells);
   for (size_t iAngleStep = 0; iAngleStep < m_numAngleCells; ++iAngleStep) {
     double a = iAngleStep * angleStep;
     m_cosTable[iAngleStep] = cos(a);
     m_sinTable[iAngleStep] = sin(a);
   }
 }

int cluster::HoughTransform::NumAccumulated ( )

inline

Definition at line 498 of file HoughBaseAlg.h.

498 { return m_numAccumulated; }

cluster::HoughTransform::m_numAccumulated

int m_numAccumulated

Definition: HoughBaseAlg.h:537

void cluster::HoughTransform::reconfigure ( fhicl::ParameterSet const & pset )

void cluster::HoughTransform::SetCell	(	int	row,
		int	col,
		int	value
	)

inline

Definition at line 492 of file HoughBaseAlg.h.

Referenced by cluster::HoughBaseAlg::FastTransform(), and cluster::HoughBaseAlg::Transform().

492 { m_accum[row].set(col, value); }

col

Int_t col[ntarg]

Definition: Style.C:29

fhicl::detail::atom::value

std::string value(boost::any const &)

Definition: printing_helpers.cc:97

cluster::HoughTransform::m_accum

HoughImage_t m_accum

column (map key)=rho, row (vector index)=theta

Definition: HoughBaseAlg.h:536

bool cluster::HoughTransform::SubtractPoint	(	int	x,
		int	y
	)

inline

Definition at line 814 of file HoughBaseAlg.cxx.

Referenced by cluster::HoughBaseAlg::Transform().

 {
   if ((x > (int) m_dx) || (y > (int) m_dy) || x<0.0 || y<0.0)
     return false;
   DoAddPointReturnMax(x, y, true); // true = subtract
   return true;
 }

Member Data Documentation

HoughImage_t cluster::HoughTransform::m_accum

private

column (map key)=rho, row (vector index)=theta

Definition at line 536 of file HoughBaseAlg.h.

std::vector<double> cluster::HoughTransform::m_cosTable

private

Definition at line 538 of file HoughBaseAlg.h.

unsigned int cluster::HoughTransform::m_dx

private

Definition at line 528 of file HoughBaseAlg.h.

unsigned int cluster::HoughTransform::m_dy

private

Definition at line 529 of file HoughBaseAlg.h.

int cluster::HoughTransform::m_numAccumulated

private

Definition at line 537 of file HoughBaseAlg.h.

unsigned int cluster::HoughTransform::m_numAngleCells

private

Definition at line 531 of file HoughBaseAlg.h.

float cluster::HoughTransform::m_rhoResolutionFactor

private

Definition at line 532 of file HoughBaseAlg.h.

unsigned int cluster::HoughTransform::m_rowLength

private

Definition at line 530 of file HoughBaseAlg.h.

std::vector<double> cluster::HoughTransform::m_sinTable

private

Definition at line 539 of file HoughBaseAlg.h.

The documentation for this class was generated from the following files:

larreco/v06_64_02/source/larreco/RecoAlg/HoughBaseAlg.h
larreco/v06_64_02/source/larreco/RecoAlg/HoughBaseAlg.cxx

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation