cluster::HoughTransform Class Reference

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 103 of file HoughBaseAlg.cxx.

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

private

Definition at line 104 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 107 of file HoughBaseAlg.cxx.

Member Function Documentation

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

inline

Definition at line 660 of file HoughBaseAlg.cxx.

{
  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 758 of file HoughBaseAlg.cxx.

{
  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 86 of file HoughBaseAlg.cxx.

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

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

inline

Definition at line 651 of file HoughBaseAlg.cxx.

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

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

Definition at line 730 of file HoughBaseAlg.cxx.

{
  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 738 of file HoughBaseAlg.cxx.

{
  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 681 of file HoughBaseAlg.cxx.

{
  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 92 of file HoughBaseAlg.cxx.

    {
      return m_numAccumulated;
    }

void cluster::HoughTransform::reconfigure

(

fhicl::ParameterSet const &

pset

)

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

inline

Definition at line 81 of file HoughBaseAlg.cxx.

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

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

inline

Definition at line 672 of file HoughBaseAlg.cxx.

{
  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 117 of file HoughBaseAlg.cxx.

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

private

Definition at line 119 of file HoughBaseAlg.cxx.

unsigned int cluster::HoughTransform::m_dx

private

Definition at line 109 of file HoughBaseAlg.cxx.

unsigned int cluster::HoughTransform::m_dy

private

Definition at line 110 of file HoughBaseAlg.cxx.

int cluster::HoughTransform::m_numAccumulated

private

Definition at line 118 of file HoughBaseAlg.cxx.

unsigned int cluster::HoughTransform::m_numAngleCells

private

Definition at line 112 of file HoughBaseAlg.cxx.

float cluster::HoughTransform::m_rhoResolutionFactor

private

Definition at line 113 of file HoughBaseAlg.cxx.

unsigned int cluster::HoughTransform::m_rowLength

private

Definition at line 111 of file HoughBaseAlg.cxx.

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

private

Definition at line 120 of file HoughBaseAlg.cxx.

---

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

• HoughBaseAlg.cxx