Public Member Functions
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 74 of file HoughBaseAlg.cxx.

Member Typedef Documentation

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

private

rho -> # hits (for convenience)

Definition at line 94 of file HoughBaseAlg.cxx.

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

private

Definition at line 95 of file HoughBaseAlg.cxx.

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

private

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

Definition at line 98 of file HoughBaseAlg.cxx.

Member Function Documentation

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

inline

Definition at line 645 of file HoughBaseAlg.cxx.

References DoAddPointReturnMax(), m_dx, and m_dy.

Referenced by cluster::HoughBaseAlg::FastTransform(), cluster::HoughBaseAlg::HoughBaseAlg(), 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 738 of file HoughBaseAlg.cxx.

References cluster::HoughTransformCounters< KEY, COUNTER, SIZE, ALLOC, SUBCOUNTERS >::decrement(), larg4::dist(), cluster::HoughTransformCounters< KEY, COUNTER, SIZE, ALLOC, SUBCOUNTERS >::increment_and_get_max(), m_accum, m_cosTable, m_numAccumulated, m_numAngleCells, m_rhoResolutionFactor, m_rowLength, and m_sinTable.

Referenced by AddPointReturnMax(), and SubtractPoint().

 {
   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;
 
   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;
     }
 
     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 81 of file HoughBaseAlg.cxx.

References m_accum, and m_rowLength.

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

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

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

inline

Definition at line 637 of file HoughBaseAlg.cxx.

References col, and m_accum.

Referenced by cluster::HoughBaseAlg::FastTransform(), cluster::HoughBaseAlg::HoughBaseAlg(), 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 712 of file HoughBaseAlg.cxx.

References m_numAngleCells, m_rhoResolutionFactor, and m_rowLength.

Referenced by cluster::HoughBaseAlg::FastTransform(), cluster::HoughBaseAlg::HoughBaseAlg(), NumAccumulated(), 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 719 of file HoughBaseAlg.cxx.

References m_accum.

Referenced by NumAccumulated(), and 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 664 of file HoughBaseAlg.cxx.

References m_accum, m_cosTable, m_dx, m_dy, m_numAccumulated, m_numAngleCells, m_rhoResolutionFactor, m_rowLength, m_sinTable, and PI.

Referenced by cluster::HoughBaseAlg::FastTransform(), cluster::HoughBaseAlg::HoughBaseAlg(), 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_numAccumulated = 0;
   m_dx = dx;
   m_dy = dy;
   m_rowLength = (unsigned int)(m_rhoResolutionFactor * 2 * std::sqrt(dx * dx + dy * dy));
   m_accum.resize(m_numAngleCells);
 
   // 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 86 of file HoughBaseAlg.cxx.

References GetEquation(), GetMax(), m_numAccumulated, and reconfigure().

86 { return m_numAccumulated; }

cluster::HoughTransform::m_numAccumulated

int m_numAccumulated

Definition: HoughBaseAlg.cxx:109

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

Referenced by NumAccumulated().

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

inline

Definition at line 80 of file HoughBaseAlg.cxx.

References m_accum.

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

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

col

Int_t col[ntarg]

Definition: Style.C:29

value

double value

Definition: spectrum.C:18

cluster::HoughTransform::m_accum

HoughImage_t m_accum

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

Definition: HoughBaseAlg.cxx:108

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

inline

Definition at line 656 of file HoughBaseAlg.cxx.

References DoAddPointReturnMax(), m_dx, and m_dy.

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

 {
   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;
 }