hough::MultiHough2P Class Reference

Hough transform based on 2-point combinations. More...

#include "/cvmfs/nova-development.opensciencegrid.org/novasoft/releases/N21-03-07/HoughTransform/MultiHough2P.h"

Public Member Functions
	MultiHough2P (geo::View_t v, double rhosz, double thetasz, int rhosm, int thetasm, double rsqr, double pco, int loops, double rmdist)
	Construct the 2-point Hough transform. More...
	~MultiHough2P ()
TH2F *	MapToTH2F () const
void	Map (const rb::HitList &h)
void	MultiMap (rb::HitList h)

Public Attributes
geo::View_t	fView
	Which detector view? More...
double	fRhoSz
	Size of rho bins (cm) More...
double	fThetaSz
	Size of theta bins (degrees) More...
int	fXwinSz
	Smoothing size (bins) in x. More...
int	fYwinSz
	Smoothing size (bins) in y. More...
double	fSigma
	Assumed location error on points (cm) More...
double	fRsqr
	Distance^2 cut on points (cm^2) More...
double	fPco
	Number of sigma abouve average peak height to use as cutoff. More...
int	fLoops
	Max number of Multi-Hough loops. More...
double	fRmDst
	Distance cut for removing points from a Hough line. More...
LiteTH2 *	fHspaceW
	Hough transform. More...
rb::HoughResult	fH
	Results of Hough transformation;. More...

Private Member Functions
void	BuildMap (double xlo, double xhi, double ylo, double yhi)
void	RhoTheta (double x1, double y1, double x2, double y2, double *rho, double *theta, double *sigmarho, double *sigmatheta)
void	SmoothMap ()
void	RefinePeak (double &rho, double &theta, int xp, int yp)
void	ReweightHits (double rho, double theta, rb::HitList &h)

Detailed Description

Hough transform based on 2-point combinations.

Definition at line 21 of file MultiHough2P.h.

Constructor & Destructor Documentation

hough::MultiHough2P::MultiHough2P	(	geo::View_t	v,
		double	rhosz,
		double	thetasz,
		int	rhosm,
		int	thetasm,
		double	rsqr,
		double	pco,
		int	loops,
		double	rmdist
	)

Construct the 2-point Hough transform.

The transform proceeds by considering all paris of points that occur within a cut off distance (rsqr) of each other. For each pair an ellipse is filled in Hough space weighted by the quality of the line fit to the two spatial points. The algorithm is largely derived from

"Real-time line detection through an improved Hough transform voting scheme", L.A.F. Fernandes, M.M. Oliveira / Pattern Recognition 41 (2008) 299-314

Parameters

v	- Which detector view? geo::kX or geo::kY
rhosz	- Size of rho bins (cm)
thetasz	- Size of theta bins (degrees)
rhosm	- Number of bins to use in smoothing rho
thetasm	- Number of bins to use in smoothing theta
rsqr	- Cut on distance between two points
pco	- Number of sigma above average peak height for threshold (peak cut-off)
loops	- Max number of multi-Hough loops

Definition at line 109 of file MultiHough2P.cxx.

                                           :
    fView(v),
    fRhoSz(rhosz),
    fThetaSz(thetasz),
    fXwinSz(rhosm),
    fYwinSz(thetasm),
    fSigma(3.0/sqrt(12.)),
    fRsqr(rsqr),
    fPco(pco),
    fLoops(loops),
    fRmDst(rmdst),
    fHspaceW(0),
    fH(v, 0, 0, 0, 0)
  { }

hough::MultiHough2P::~MultiHough2P

(

)

Definition at line 168 of file MultiHough2P.cxx.

References fHspaceW.

  {
    if (fHspaceW) { delete fHspaceW; fHspaceW = 0;}
  }

Member Function Documentation

void hough::MultiHough2P::BuildMap ( double  xlo, double  xhi, double  ylo, double  yhi  )

private

Definition at line 175 of file MultiHough2P.cxx.

References fHspaceW, fRhoSz, fThetaSz, makeTrainCVSamples::int, M_PI, util::pythag(), and r().

Referenced by Map().

  {
    double r;   // Size of hough map in rho
    int    nr;  // Number of bins to use in rho
    int    nth; // Number of bins to use in theta
    
    // 0.55 gives a little buffer beyond the minimum required 0.5
    r  = 0.55*util::pythag((xhi-xlo),(yhi-ylo));
    nr = (int)rint(r/fRhoSz+0.5);
    
    nth = (int)rint(180.0/fThetaSz+0.5);
    
    // Allocate the Hough space histogram
    if (fHspaceW!=0) { delete fHspaceW; fHspaceW=0; }
    fHspaceW = new LiteTH2(nr, -r, r,
                           nth,-0.5*M_PI/180.0,179.5*M_PI/180.0);
  }

void hough::MultiHough2P::Map

(

const rb::HitList &

h

)

Make the Hough map for the hit list h.

Parameters

h	- The list of hits (can be mixed X and Y view hits)

Definition at line 225 of file MultiHough2P.cxx.

References abs(), hough::LiteTH2::AddBinContent(), BuildMap(), fH, fHspaceW, hough::LiteTH2::FindBinX(), hough::LiteTH2::FindBinY(), fRsqr, rb::HoughResult::fTNShi, rb::HoughResult::fTNSlo, fView, fXwinSz, rb::HoughResult::fXY0, fYwinSz, rb::HoughResult::fZ0, hough::Gaus(), hough::LiteTH2::GetBinCenterX(), hough::LiteTH2::GetBinCenterY(), hough::LiteTH2::GetNbinsX(), hough::LiteTH2::GetNbinsY(), MECModelEnuComparisons::i, calib::j, RhoTheta(), SmoothMap(), util::sqr(), chisquared::theta, w, submit_syst::x, xhi, make_syst_table_plots::xlo, submit_syst::y, yhi, and ylo.

Referenced by MultiMap().

  {
    unsigned int i;
    unsigned int j;
    
    //
    // Find a box that completely contains all the hits. A note on
    // coordinates: Since the literature on Hough transforms uses an
    // "x-y" coodinate system I map NOvA z to Hough x and NOvA X/Y to
    // Hough y so that the formalizm matches what one would find in the
    // literature.
    //
    double tlo=9E9, thi=-9e9;
    double xlo=9e9, xhi=-9e9;
    double ylo=9e9, yhi=-9e9;
    for (i=0; i<h.size(); ++i) {
      if (h[i].fView == fView) {
        if (h[i].fZ<xlo)  xlo = h[i].fZ;
        if (h[i].fZ>xhi)  xhi = h[i].fZ;
        if (h[i].fXY<ylo) ylo = h[i].fXY;
        if (h[i].fXY>yhi) yhi = h[i].fXY;
        if (h[i].fT<tlo)  tlo = h[i].fT;
        if (h[i].fT>tlo)  thi = h[i].fT;
      }
    }
    fH.fTNSlo = tlo;
    fH.fTNShi = thi;
    fH.fZ0  = 0.5*(xlo+xhi);
    fH.fXY0 = 0.5*(ylo+yhi);



    //
    // Fill the hough map
    //
    this->BuildMap(xlo,xhi,ylo,yhi);

    for (i=0; i<h.size(); ++i) {
      if (h[i].fView != fView) continue;
      for (j=i+1; j<h.size(); ++j) {
        if (h[j].fView != fView) continue;
        const bool hasweight = h[i].fW != 0.0 && h[j].fW != 0.0;
        if(!hasweight) continue;
        
        // Check distance between hit pair
        double rsqr = util::sqr(h[i].fZ-h[j].fZ) + util::sqr(h[i].fXY-h[j].fXY);

        if (rsqr>fRsqr) continue;
        
        // don't let points in the same column vote unless they are close together
        // if ( abs(h[i].fZ - h[j].fZ) < 5.9 && rsqr > fRsqr/4.0 ) continue;
        
        // don't let points in the same row vote unless they are far apart
        if ( abs(h[i].fXY - h[j].fXY) < 3.9 && rsqr < fRsqr/4.0 ) continue;
        
        double rho,      theta;
        double sigmarho, sigmatheta;
        this->RhoTheta(h[i].fZ-fH.fZ0, h[i].fXY-fH.fXY0,
                       h[j].fZ-fH.fZ0, h[j].fXY-fH.fXY0,
                       &rho,           &theta,
                       &sigmarho,      &sigmatheta);
        //
        // Fill region weighted by errors
        //
        int ixlo = fHspaceW->FindBinX(rho-3.0*sigmarho);
        int ixhi = fHspaceW->FindBinX(rho+3.0*sigmarho);
        int iylo = fHspaceW->FindBinY(theta-3.0*sigmatheta);
        int iyhi = fHspaceW->FindBinY(theta+3.0*sigmatheta);
        
        if (ixlo<1)                 ixlo = 1;
        if (iylo<1)                 iylo = 1;
        if (ixhi>fHspaceW->GetNbinsX()) ixhi = fHspaceW->GetNbinsX();
        if (iyhi>fHspaceW->GetNbinsY()) iyhi = fHspaceW->GetNbinsY();
        
        int ix, iy;

        // Precalcuate gaussian weights since they will be the same every loop
        double yprob[iyhi]; // won't use first elements: use memory to save time
        for (iy=iylo; iy<=iyhi; ++iy) {
          const double y = fHspaceW->GetBinCenterY(iy);
          yprob[iy] = Gaus(y-theta, sigmatheta);
        }

        for (ix=ixlo; ix<=ixhi; ++ix) {
          double x = fHspaceW->GetBinCenterX(ix);
          const double xprob = Gaus(x-rho, sigmarho);
          for (iy=iylo; iy<=iyhi; ++iy) {
            double w = 0.0;

            // if(h[i].fW > 0.1 && h[j].fW > 0.1) w = 2.0*h[i].fW*h[j].fW/(h[i].fW+h[j].fW);
            w = 2.0*h[i].fW*h[j].fW/(h[i].fW+h[j].fW) *
              xprob * yprob[iy];
            fHspaceW->AddBinContent(ix,iy,w);

          }
        }
      }
    }
    if (fXwinSz > 0 || fYwinSz > 0) this->SmoothMap();
    
  }

TH2F * hough::MultiHough2P::MapToTH2F

(

)

const

Definition at line 196 of file MultiHough2P.cxx.

References fHspaceW, fView, geo::kX, geo::kY, runNovaSAM::ret, and hough::LiteTH2::ToTH2F().

Referenced by hough::MultiHoughT::WriteHoughHistos().

  {
    if(!fHspaceW) return 0;
    TH2F* ret = fHspaceW->ToTH2F();
    ret->SetTitle(";rho [cm];theta [radians]");

    const char* tiw = 0;
    if(fView == geo::kX) tiw = "fHough2P_Hx";
    else if (fView == geo::kY) tiw = "fHough2P_Hy";
    else abort(); 
    ret->SetTitle(tiw);

    return ret;
  }

void hough::MultiHough2P::MultiMap

(

rb::HitList

h

)

Definition at line 329 of file MultiHough2P.cxx.

References a, b, stan::math::fabs(), fH, fHspaceW, fLoops, fPco, rb::HoughResult::fPeak, hough::LiteTH2::GetBinContent(), hough::LiteTH2::GetNbinsX(), hough::LiteTH2::GetNbinsY(), MECModelEnuComparisons::i, Map(), genie::units::nb, r(), RefinePeak(), ReweightHits(), rb::HoughResult::SortPeaks(), std::sqrt(), sr, and chisquared::theta.

Referenced by hough::MultiHoughT::produce().

  {
    
    int flag = 0;  // flag to jump out of multi hough loop
    int mh   = 1;  // count of number of multihough loops
    
    // make the initial Hough Map
    this->Map(h);
    
    // calculate the threshold (needs to be done once at the beginning so that it is
    // the same for all subsequent maps)
    double Pave = 0.0;     // average peak height
    double Ps = 0.0;       // standard deviation of average peak height
    double th = 0.0;       // threshold to use for peak cutoff
    int nb = 0;            // number of bins counted for avergae peak height
    
    // calculate average peak height to determine threshold
    // empty bins are currently counted
    for (int a = 1; a <= fHspaceW->GetNbinsX(); ++a) {
      for (int b = 1; b <= fHspaceW->GetNbinsY(); ++b) {
        double hab = fHspaceW->GetBinContent(a, b);
        if (hab != 0) {
          Pave += hab;
          Ps += hab*hab;
        } // end if
        nb++;
      } // end for b
    }   // end for a
    
    Pave = Pave/nb;
    Ps = sqrt(Ps/nb - Pave*Pave);
    th = Pave + fPco*Ps;

    // If the threshold is zero, then the initial Hough map is empty so there
    // is no reason to proceed.
    if(th == 0.0) return;
    
    // find the tallest peak
    int ix, iy;
    int xpeak = 0, ypeak = 0;
    double peak  = 0.0;
    double r     = 0.0;
    double theta = 0.0;
    double p;
    for(ix = 1; ix <= fHspaceW->GetNbinsX(); ++ix) {
      for(iy = 1; iy <= fHspaceW->GetNbinsY(); ++iy) {
        p = fHspaceW->GetBinContent(ix,iy);
        if (p>peak) {
          peak   = p;
          xpeak = ix;
          ypeak = iy;
        } // end if p>peak
      } // loop on y bins
    } // loop on x bins      
    
    // Average bins around the peak to get a better rho and theta value
    this->RefinePeak(r, theta, xpeak, ypeak);
    
    // AS OF RIGHT NOW, SIGMA-RHO AND SIGMA-THETA ARE NOT CALCULATED!!! 
    double sr = 0.0;
    double st = 0.0;

    // put tallest peak into Hough Results
    if(peak > 0.0) fH.fPeak.push_back(rb::HoughPeak(r,theta,peak,th,sr,st));

    // remove hits on the line by reweighting them
    this->ReweightHits(r, theta, h);



    
    //
    // start the MultiHough loop
    //
    
    // if either the number of desired loops is only one or the tallest peak was already below threshold,
    // then skip the multi-hough loop because we are already done
    if(peak < th)   flag = 1;
    if(mh >= fLoops) flag = 1;
    
    while(flag == 0) {
      
      mh++;
      if(mh >= fLoops) flag = 1;
      
      // repeat everything done above EXCEPT: calculating the threshold

      // build the new map
      this->Map(h);

      
      
      // find the tallest peak
      xpeak  = 0;
      ypeak  = 0;
      peak   = 0.0;
      r      = 0.0;
      theta  = 0.0;
      p      = 0.0;

      for (ix=1; ix<=fHspaceW->GetNbinsX(); ++ix) {
        for (iy=1; iy<=fHspaceW->GetNbinsY(); ++iy) {
          p = fHspaceW->GetBinContent(ix,iy);
          if (p>peak) {
            peak   = p;
            xpeak = ix;
            ypeak = iy;
          } // end if p>peak
        } // loop on y bins
      } // loop on x bins      

      this->RefinePeak(r, theta, xpeak, ypeak);

      sr = 0.0;
      st = 0.0;


      
      // Run parallel line test: (If two lines have almost the same rho and theta values,
      // they are assumed to be part of the same line and that line is NOT put into the
      // Hough results.)
      //
      // NOTE:  This is a little sensitive to the numbers 15.0 and 0.02.
      int parflag = 0;
      for(unsigned int i = 0; i < fH.fPeak.size(); ++i) {
        if(fabs(r - fH.fPeak[i].fRho) < 15.0 && fabs(theta - fH.fPeak[i].fTheta) < 0.02) parflag = 1;
      }
          
      // put only the tallest peak into Houghresults
      if(parflag != 1 && peak >= th) fH.fPeak.push_back(rb::HoughPeak(r,theta,peak,th,sr,st));
      if(peak < th) flag = 1;
      
      this->ReweightHits(r, theta, h);

    } // end MultiHough loop
    
    fH.SortPeaks();
    
  }

void hough::MultiHough2P::RefinePeak ( double &  rho, double &  theta, int  xp, int  yp  )

private

Definition at line 532 of file MultiHough2P.cxx.

References dist, stan::math::fabs(), fHspaceW, hough::LiteTH2::GetBinCenterX(), hough::LiteTH2::GetBinCenterY(), hough::LiteTH2::GetBinContent(), hough::LiteTH2::GetNbinsX(), hough::LiteTH2::GetNbinsY(), and util::pythag().

Referenced by MultiMap().

  {
    // make these fcl parameters???
    int nx = 3, ny = 3;      // +/- number of bins around peak to use for averaging
    double peaktotal = 0.0;
    double BinValue  = 0.0;
    int nXbins = fHspaceW->GetNbinsX();
    int nYbins = fHspaceW->GetNbinsY();

  
    // determine if bins to be averaged over will be off the map and constrain nx and ny accordingly
    if((xp+nx) >= nXbins) nx = (nXbins-1) - xp;
    if((xp-nx) < 0)       nx = xp;
    
    if((yp+ny) >= nYbins) ny = (nYbins-1) - yp;
    if((yp-ny) < 0)       ny = yp;



    double xd = 0.0, yd = 0.0;
    double dist = 0.0;

    for(int xi = -nx; xi <= nx; ++xi) {
      xd = fabs(xi);
      for(int yi = -ny; yi <= ny; ++yi) {

        yd = fabs(yi);
        dist = util::pythag(xd,yd);
        if(dist == 0.0) dist = 0.707107;

        BinValue   = (fHspaceW->GetBinContent(xp+xi,yp+yi))/dist;
        peaktotal += BinValue;
        rho       += BinValue*fHspaceW->GetBinCenterX(xp+xi);
        theta     += BinValue*fHspaceW->GetBinCenterY(yp+yi);

      }
    }

    rho   = rho/peaktotal;
    theta = theta/peaktotal;

  }

void hough::MultiHough2P::ReweightHits ( double  rho, double  theta, rb::HitList &  h  )

private

Definition at line 579 of file MultiHough2P.cxx.

References a, b, plot_validation_datamc::c, std::cos(), d, geo::DsqrToLine(), fH, fRmDst, fView, rb::HoughResult::fXY0, rb::HoughResult::fZ0, MECModelEnuComparisons::i, calib::j, m, std::sin(), std::sqrt(), and make_true_q0q3_plots::zmax.

Referenced by MultiMap().

  {
    //
    // This function does several things:
    //   1. It sets the weights of all hits within 6 cm of the line to zero.
    //   2. Then it resets the weights of the end points of the line to one.
    //   3. Then it applies more scrubbing to remove stray hits that have no neighbors.
    //

    // These variable were used in an old scheme in which I used a Fermi distribution function
    // to determine the new hit weights based on their distance to the line.  I left it in for
    // potential future use.
    // double dc   = 4.0;   // distance cutoff
    // double ds   = 1.0;   // distance spread


    // loop over all points, determine which are on that line and set their weights to zero
    double m = 0.0;
    double b = 0.0;
    double s = sin(theta);
    double c = cos(theta);
    
    // calculate slope/intercept in detector coordinates
    if (s == 0.0) s = 1.0E-9;
    m = -c/s;
    b = r/s - m*fH.fZ0 + fH.fXY0;
    
    double d = 0.0; // perpendicular distance of point to line

    // numbers needed for determining which points are end points
    double zmin = 1.0e9, zmax = -1.0e9;
    unsigned int amax  = 999999;
    unsigned int amin  = 999999;
    // amax2 & amin2 are used for the case that there are 2 end points (when there are two points
    // in the same plane within fRmDist (cm) of the line.)
    // NOTE:  There could be three points that fit this, but I only allow for keeping two.
    unsigned int amax2 = 999999;
    unsigned int amin2 = 999999;
    
    for(unsigned int a = 0; a < h.size(); ++a) {
      
      // if a point is on the line, set its weight to zero
      if(h[a].fView == fView) {
        
        d = geo::DsqrToLine(h[a].fZ, h[a].fXY, 0.0, b, 100.0, 100.0*m + b);
        d = sqrt(d);
        // h[a].fW *= 1.0 - 1.0/(exp((d - dc)/ds) + 1.0);   // The Fermi weight function
        if(d < fRmDst) {
          h[a].fW = 0.0;
          
          // determine end points
          if(h[a].fZ == zmax) { amax2 = a; }
          if(h[a].fZ == zmin) { amin2 = a; }
          if(h[a].fZ > zmax)  { zmax = h[a].fZ; amax = a; }
          if(h[a].fZ < zmin)  { zmin = h[a].fZ; amin = a; }
        }

      } // end if fView
    } // end for a
    
    // Reset the weights of the line end points to one.
    if(amax  != 999999) h[amax].fW  = 1.0;
    if(amin  != 999999) h[amin].fW  = 1.0;
    if(amax2 != 999999) h[amax2].fW = 1.0;
    if(amin2 != 999999) h[amin2].fW = 1.0;


    
    // Rescrub the hit list to remove points with no neighbors within sqrt(ScrubDistSq) (cm).
    double dminsq = 0.0, dsq = 0.0;
    double ScrubDistSq = 900.0;

    // We will keep track of which points are within sqrt(ScrubDistSq) (cm) of
    // another point (i.e. - which points have a buddy) to make this more efficient.
    std::vector<int> BuddyList;
    for(unsigned int a = 0; a < h.size(); ++a) BuddyList.push_back(0);

    // For each point, loop over all others to determine if it has a "buddy" within sqrt(ScrubDistSq).
    // If it has no "buddies," scrub it! (Set the weight to zero.)
    for(unsigned int i = 0; i < h.size(); ++i) {
      if(BuddyList[i] > 0)    continue;
      if(h[i].fView != fView) continue;
      if(h[i].fW == 0.0)      continue;
      dminsq = 1.0e9;
      for(unsigned int j = 0; j < h.size(); ++j) {
        if(i == j)              continue;
        if(h[j].fView != fView) continue;
        if(h[j].fW == 0.0)      continue;
        dsq = (h[i].fZ - h[j].fZ)*(h[i].fZ - h[j].fZ) + (h[i].fXY - h[j].fXY)*(h[i].fXY - h[j].fXY);
        if(dsq < ScrubDistSq) {
          BuddyList[i] += 1;
          BuddyList[j] += 1;
        }
        if(dsq < dminsq) dminsq = dsq;
      }
      if(dminsq >= ScrubDistSq) h[i].fW = 0.0;
    }
    
  }

void hough::MultiHough2P::RhoTheta ( double  x1, double  y1, double  x2, double  y2, double *  rho, double *  theta, double *  sigmarho, double *  sigmatheta  )

private

Definition at line 134 of file MultiHough2P.cxx.

References std::atan2(), std::cos(), d, fSigma, M_PI, util::pythag(), std::sin(), submit_syst::x2, and submit_syst::y2.

Referenced by Map().

  {
    *theta = atan2(x1-x2,y2-y1);
    *rho   = 0.5*(cos(*theta)*(x1+x2)+sin(*theta)*(y1+y2));
    //
    // Keep rho and theta within range [0,pi) (-R,+R)
    //
    while (*theta<0) {
      *theta +=  M_PI;
      *rho    = -(*rho);
    }
    while (*theta>=M_PI) {
      *theta -=  M_PI;
      *rho    = -(*rho);
    }
    
    // Compute the error estimates
    double d = util::pythag((x2-x1),(y2-y1));
    *sigmarho   = fSigma;
    *sigmatheta = M_SQRT2*fSigma/d;

    // these were failed attempts at making sigmatheta level off at a fixed value
    //*sigmatheta = M_SQRT2*fSigma/d + 0.1;
    /*
    if(d < 20.0) *sigmatheta = M_SQRT2*fSigma/d;
    else *sigmatheta = M_SQRT2*fSigma/20.0;
    */
  }

void hough::MultiHough2P::SmoothMap ( )

private

Definition at line 471 of file MultiHough2P.cxx.

References a, b, fHspaceW, fXwinSz, fYwinSz, hough::Gaus(), hough::LiteTH2::GetBinContent(), hough::LiteTH2::GetNbinsX(), hough::LiteTH2::GetNbinsY(), MECModelEnuComparisons::i, calib::j, m, getGoodRuns4SAM::n, hough::LiteTH2::SetBinContent(), sum, and w.

Referenced by Map().

  {
    
    // NOTE:  Since most of the Hough space map is empty, we only apply smoothing to the non-zero
    //        bins in order to save lots of calculation time.

    int i, j, m, n;
    int nx, ny;
    int ix, iy;
    double sum;
    int wx, wy;
    
    wx = 2*fXwinSz + 1;
    wy = 2*fYwinSz + 1;
    
    double w[wx][wy];
    
    // fill the smoothing weight map
    for(int a = 0; a < wx; a++) {
      for(int b = 0; b < wy; b++) {
        
        w[a][b] = Gaus(a - fXwinSz, fXwinSz/3.0)*Gaus(b - fYwinSz, fYwinSz/3.0);
        
      } // end for b
    } // end for a
    
    LiteTH2* htmp = new LiteTH2(*fHspaceW);
    
    nx = htmp->GetNbinsX();
    ny = htmp->GetNbinsY();
    for (i=1; i<=nx; ++i) {
      for(j=1; j<=ny; ++j) {
        sum = 0.0;
        // skip smoothing if bin is empty
        if(htmp->GetBinContent(i,j) == 0.0) continue;
        for (m=-fXwinSz; m<=fXwinSz; m++) {
          ix = i+m;
          // Don't wrap around in rho
          if (ix>nx) continue;
          if (ix<1)  continue;
          for (n=-fYwinSz; n<=fYwinSz; ++n) {
            iy = j+n;
            // Wrap in theta
            if (iy>ny) iy = iy%ny;
            if (iy<1)  iy = ny+iy;
            
            sum += w[m + fXwinSz][n + fYwinSz]*htmp->GetBinContent(ix,iy);
          }
        }
        fHspaceW->SetBinContent(i,j,sum);
      }
    }
    delete htmp;
    htmp = 0;
    
  }

Member Data Documentation

rb::HoughResult hough::MultiHough2P::fH

Results of Hough transformation;.

Definition at line 91 of file MultiHough2P.h.

Referenced by Map(), MultiMap(), hough::MultiHoughT::produce(), and ReweightHits().

LiteTH2* hough::MultiHough2P::fHspaceW

Hough transform.

Definition at line 90 of file MultiHough2P.h.

Referenced by BuildMap(), Map(), MapToTH2F(), MultiMap(), RefinePeak(), SmoothMap(), and ~MultiHough2P().

int hough::MultiHough2P::fLoops

Max number of Multi-Hough loops.

Definition at line 86 of file MultiHough2P.h.

Referenced by MultiMap().

double hough::MultiHough2P::fPco

Number of sigma abouve average peak height to use as cutoff.

Definition at line 85 of file MultiHough2P.h.

Referenced by MultiMap().

double hough::MultiHough2P::fRhoSz

Size of rho bins (cm)

Definition at line 79 of file MultiHough2P.h.

Referenced by BuildMap().

double hough::MultiHough2P::fRmDst

Distance cut for removing points from a Hough line.

Definition at line 87 of file MultiHough2P.h.

Referenced by ReweightHits().

double hough::MultiHough2P::fRsqr

Distance^2 cut on points (cm^2)

Definition at line 84 of file MultiHough2P.h.

Referenced by Map().

double hough::MultiHough2P::fSigma

Assumed location error on points (cm)

Definition at line 83 of file MultiHough2P.h.

Referenced by RhoTheta().

double hough::MultiHough2P::fThetaSz

Size of theta bins (degrees)

Definition at line 80 of file MultiHough2P.h.

Referenced by BuildMap().

geo::View_t hough::MultiHough2P::fView

Which detector view?

Definition at line 78 of file MultiHough2P.h.

Referenced by Map(), MapToTH2F(), and ReweightHits().

int hough::MultiHough2P::fXwinSz

Smoothing size (bins) in x.

Definition at line 81 of file MultiHough2P.h.

Referenced by Map(), and SmoothMap().

int hough::MultiHough2P::fYwinSz

Smoothing size (bins) in y.

Definition at line 82 of file MultiHough2P.h.

Referenced by Map(), and SmoothMap().

---

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

• /cvmfs/nova-development.opensciencegrid.org/novasoft/releases/N21-03-07/HoughTransform/MultiHough2P.h
• /cvmfs/nova-development.opensciencegrid.org/novasoft/releases/N21-03-07/HoughTransform/MultiHough2P.cxx