#include "Segmentation2D.h"

Public Member Functions
	Segmentation2D (const fhicl::ParameterSet &p)

void	reconfigure (const fhicl::ParameterSet &p)

std::vector< tss::Cluster2D >	run (tss::Cluster2D &inp) const

void	splitHits (const std::vector< tss::Cluster2D > &inp, std::vector< const tss::Hit2D * > &trackHits, std::vector< const tss::Hit2D * > &emHits) const

void	splitHitsNaive (const tss::Cluster2D &inp, std::vector< const tss::Hit2D * > &trackHits, std::vector< const tss::Hit2D * > &emHits) const

void	splitHitsNaive (const std::vector< tss::Cluster2D > &inp, std::vector< const tss::Hit2D * > &trackHits, std::vector< const tss::Hit2D * > &emHits) const

int	mergeClusters (std::vector< tss::Cluster2D > &group, const std::vector< size_t > &idxs) const

Private Member Functions
void	run (tss::Cluster2D &inp, std::vector< tss::Cluster2D > &result, std::vector< TVector2 > &centers) const

tss::Cluster2D	buildSegment (tss::Cluster2D &inp, TVector2 center, TVector2 end) const

tss::Cluster2D	selectRing (const tss::Cluster2D &inp, TVector2 center) const

void	tagDenseEnds (std::vector< tss::Cluster2D > &group) const

void	mergeDenseParts (std::vector< tss::Cluster2D > &group) const

bool	Cl2InsideCl1 (tss::Cluster2D &cl1, tss::Cluster2D &cl2) const

Private Attributes
tss::SimpleClustering	fSimpleClustering

double	fRadiusMin

double	fRadiusMax

double	fMaxLineDist

double	fDenseVtxRadius

double	fDenseHitRadius

size_t	fDenseMinN

size_t	fDenseMinH

Detailed Description

Definition at line 19 of file Segmentation2D.h.

Constructor & Destructor Documentation

tss::Segmentation2D::Segmentation2D ( const fhicl::ParameterSet & p )

inline

Definition at line 23 of file Segmentation2D.h.

References buildSegment(), Cl2InsideCl1(), evd::details::end(), mergeClusters(), mergeDenseParts(), reconfigure(), run(), selectRing(), splitHits(), splitHitsNaive(), and tagDenseEnds().

                                                    :
                 fRadiusMin(0.5), fRadiusMax(1.0),
                 fMaxLineDist(0.2),
                 fDenseVtxRadius(1.0), fDenseHitRadius(5.0),
                 fDenseMinN(5), fDenseMinH(100)
         { reconfigure(p); }

Member Function Documentation

tss::Cluster2D tss::Segmentation2D::buildSegment	(	tss::Cluster2D &	inp,
		TVector2	center,
		TVector2	end
	)		const

private

Definition at line 106 of file Segmentation2D.cxx.

References pma::Dist2(), tss::Cluster2D::end(), evd::details::end(), fMaxLineDist, fSimpleClustering, pma::GetProjectionToSegment(), tss::Cluster2D::hits(), tss::SimpleClustering::hitsTouching(), proj, tss::Cluster2D::push_back(), tss::Cluster2D::release(), tss::Cluster2D::size(), tss::Cluster2D::sort(), and tss::Cluster2D::start().

Referenced by run(), and Segmentation2D().

 {
         const double max_d2 = fMaxLineDist * fMaxLineDist;
         TVector2 segDir = end - center;
 
         double dc, min_dc = 1.0e9;
         size_t firstIdx = 0;
 
         tss::Cluster2D candidates;
         for (auto h : inp.hits())
         {
                 TVector2 proj = pma::GetProjectionToSegment(h->Point2D(), center, end);
                 if (pma::Dist2(h->Point2D(), proj) < max_d2)
                 {
                         TVector2 hDir = h->Point2D() - center;
                         dc = hDir.Mod();
                         if ((hDir * segDir >= 0.0) || (dc < 0.1))
                         {
                                 candidates.push_back(h);
                                 if (dc < min_dc)
                                 {
                                         min_dc = dc; firstIdx = candidates.size() - 1;
                                 }
                         }
                 }
         }
         if (candidates.size() > 1)
         {
                 const tss::Hit2D* hFirst = candidates.hits()[firstIdx];
                 candidates.hits()[firstIdx] = candidates.hits()[0];
                 candidates.hits()[0] = hFirst;
                 candidates.sort();
         }
 
         tss::Cluster2D segment;
         if (candidates.size())
         {
                 segment.push_back(candidates.start());
                 if (!inp.release(segment.start()))
                 {
                         mf::LogError("Segmentation2D") << "Hit not found in the input cluster.";
                 }
 
                 size_t i = 1;
                 while ((i < candidates.size()) &&
                        fSimpleClustering.hitsTouching(segment, candidates[i]))
                 {
                         segment.push_back(candidates.hits()[i++]);
                         if (!inp.release(segment.end()))
                         {
                                 mf::LogError("Segmentation2D") << "Hit not found in the input cluster.";
                         }
                 }
         }
 
         return segment;
 }

bool tss::Segmentation2D::Cl2InsideCl1	(	tss::Cluster2D &	cl1,
		tss::Cluster2D &	cl2
	)		const

private

Definition at line 461 of file Segmentation2D.cxx.

References tss::Cluster2D::isEM(), tss::Cluster2D::max(), tss::Cluster2D::min(), tss::Cluster2D::size(), X, and Y.

Referenced by Segmentation2D().

 {
         bool clover = false; bool clunder = false;
         bool clleft = false; bool clright = false;
 
         if (cl2.isEM()) return false;
 
         float shift = 5; // shift!
 
         TVector2 point((cl2.max()).X(), (cl2.min()).Y());
         float width = (cl2.max()).X() - (cl2.min()).X();
         float height = (cl2.max()).Y() - (cl2.min()).Y();       
                 
         for (unsigned int h = 0; h < cl1.size(); h++)
         {
                 float wire = cl1[h].Point2D().X(); float drift = cl1[h].Point2D().Y();
                         
                 if ( (wire <= (point.X() + shift)) && (wire >= (point.X() - width - shift)) )
                 {
                         if (drift < point.Y())
                         {
                                 clover = true;
                         }
                         else if (drift > (point.Y() + height))
                         {
                                 clunder = true;
                         }
 
                         if (wire > point.X())
                         {
                                 clleft = true;
                         }
                         else if (wire < (point.X() - width))
                         {
                                 clright = true;
                         }
                 }
         }
 
         if (clover && clunder && clleft && clright) return true;
         else return false;      
 }

int tss::Segmentation2D::mergeClusters	(	std::vector< tss::Cluster2D > &	group,
		const std::vector< size_t > &	idxs
	)		const

Definition at line 329 of file Segmentation2D.cxx.

Referenced by mergeDenseParts(), and Segmentation2D().

 {
         if (idxs.size() < 2) return 0;
 
         for (const auto i : idxs)
         {
                 if (i < group.size()) group[i].setTag(true);
                 else
                 {
                         mf::LogError("Segmentation2D") << "Merging index out of group range.";
                         return -1;
                 }
         }
 
         size_t k = idxs.front(), i = idxs.front() + 1;
         while (i < group.size())
         {
                 if (group[i].isTagged())
                 {
                         group[k].merge(group[i]);
                         group.erase(group.begin() + i);
                 }
                 else ++i;
         }
         group[k].setTag(false);
 
         return k;
 }

void tss::Segmentation2D::mergeDenseParts ( std::vector< tss::Cluster2D > & group ) const

private

Definition at line 233 of file Segmentation2D.cxx.

References pma::Dist2(), evd::details::end(), fDenseMinN, fDenseVtxRadius, maxE, and mergeClusters().

Referenced by run(), and Segmentation2D().

 {
         const double rad2 = fDenseVtxRadius * fDenseVtxRadius;
 
         bool merged = true;
         while (merged)
         {
                 merged = false;
 
                 size_t maxS = fDenseMinN, maxE = fDenseMinN;
                 std::vector< size_t > toMergeS, toMergeE;
                 int idxMaxS = -1, idxMaxE = -1;
 
                 for (size_t i = 0; i < group.size(); i++)
                 {
                         
                         if (group[i].isEM()) continue;
 
                         if (group[i].isDenseStart())
                         {
 
                                 size_t ns = 0;
                                 std::vector< size_t > toMerge;
                                 TVector2 start0(group[i].start()->Point2D());
                                 for (size_t j = 0; j < group.size(); j++)
                                 {
                                         if (group[j].isEM()) continue;
 
                                         if (i == j)
                                         {
                                                 if ((group[j].size() > 1) &&
                                                     (group[j].length2() < rad2)) ns++;
                                         }
                                         else
                                         {
                                                 bool tagged = false;
                                                 if (pma::Dist2(start0, group[j].start()->Point2D()) < rad2)
                                                 {
                                                         ns++; toMerge.push_back(j); tagged = true;
                                                 }
                                                 if ((group[j].size() > 1) && (pma::Dist2(start0, group[j].end()->Point2D()) < rad2))
                                                 {
                                                         ns++; if (!tagged) toMerge.push_back(j);
                                                 }
                                         }
                                 }
                                 if (ns > maxS) { maxS = ns; idxMaxS = i; toMergeS = toMerge; }
                         }
 
                         if ((group[i].size() > 1) && group[i].isDenseEnd())
                         {
                                 size_t ne = 0;
                                 std::vector< size_t > toMerge;
                                 TVector2 end0(group[i].end()->Point2D());
                                 for (size_t j = 0; j < group.size(); j++)
                                 {
                                         if (group[j].isEM()) continue;
 
                                         if (i == j)
                                         {
                                                 if ((group[j].size() > 1) &&
                                                     (group[j].length2() < rad2)) ne++;
                                         }
                                         else
                                         {
                                                 bool tagged = false;
                                                 if (pma::Dist2(end0, group[j].start()->Point2D()) < rad2)
                                                 {
                                                         ne++; toMerge.push_back(j); tagged = true;
                                                 }
                                                 if ((group[j].size() > 1) && (pma::Dist2(end0, group[j].end()->Point2D()) < rad2))
                                                 {
                                                         ne++; if (!tagged) toMerge.push_back(j);
                                                 }
                                         }
                                 }
                                 if (ne > maxE) { maxE = ne; idxMaxE = i; toMergeE = toMerge; }
                         }
                 }
                 
                 int idx = idxMaxS;
                 std::vector< size_t > toMergeIdxs = toMergeS;
                 if (idxMaxE > idx) { idx = idxMaxE; toMergeIdxs = toMergeE; }
                 if (idx > -1)
                 {
                         toMergeIdxs.push_back(idx);
                         idx = mergeClusters(group, toMergeIdxs);
 
                         if (idx > -1) group[idx].tagEM(true);
 
                         merged = true;
                 }
         }
 }

void tss::Segmentation2D::reconfigure ( const fhicl::ParameterSet & p )

Definition at line 14 of file Segmentation2D.cxx.

References fDenseHitRadius, fDenseMinH, fDenseMinN, fDenseVtxRadius, fMaxLineDist, fRadiusMax, fRadiusMin, and fhicl::ParameterSet::get().

Referenced by tss::TrackShowerHits::reconfigure(), and Segmentation2D().

 {
         fRadiusMin = p.get< double >("RadiusMin");
         fRadiusMax = p.get< double >("RadiusMax");
         fMaxLineDist = p.get< double >("MaxLineDist");
 
         fDenseVtxRadius = p.get< double >("DenseVtxRadius");
         fDenseMinN = p.get< unsigned int >("DenseMinNVtx");
 
         fDenseHitRadius = p.get< double >("DenseHitRadius");
         fDenseMinH = p.get< unsigned int >("DenseMinNHits");
 }

std::vector< tss::Cluster2D > tss::Segmentation2D::run ( tss::Cluster2D & inp ) const

Definition at line 27 of file Segmentation2D.cxx.

References mergeDenseParts(), tss::Cluster2D::outermost(), tss::Hit2D::Point2D(), tss::Cluster2D::size(), and tagDenseEnds().

Referenced by tss::TrackShowerHits::produce(), and Segmentation2D().

 {
         std::vector< tss::Cluster2D > result;
         while (inp.size() > 1)
         {
                 size_t idx;
                 const tss::Hit2D* hFirst = inp.outermost(idx);
                 if (!hFirst) break;
 
                 std::vector< TVector2 > centers;
                 centers.emplace_back(hFirst->Point2D());
 
                 while (centers.size())
                 {
                         run(inp, result, centers);
                 }
         }
 
         tagDenseEnds(result);
         mergeDenseParts(result);
 
         return result;
 }

void tss::Segmentation2D::run	(	tss::Cluster2D &	inp,
		std::vector< tss::Cluster2D > &	result,
		std::vector< TVector2 > &	centers
	)		const

private

Definition at line 52 of file Segmentation2D.cxx.

References buildSegment(), tss::Cluster2D::closest(), pma::Dist2(), tss::Cluster2D::end(), fSimpleClustering, tss::Hit2D::Point2D(), tss::Cluster2D::release(), tss::SimpleClustering::run(), tca::seeds, selectRing(), and tss::Cluster2D::size().

 {
         if (!centers.size()) return;
 
         TVector2 center(centers.front());
         centers.erase(centers.begin());
 
         size_t idx;
         const tss::Hit2D* hFirst = inp.closest(center, idx);
 
         const double dmax2 = 0.5 * 0.5; // does not look like startpoint selected before
         if (!hFirst || (pma::Dist2(hFirst->Point2D(), center) > dmax2)) return;
         center = hFirst->Point2D();
 
         tss::Cluster2D ring = selectRing(inp, center);
         if (ring.size())
         {
                 std::vector< tss::Cluster2D > seeds = fSimpleClustering.run(ring);
                 while (seeds.size())
                 {
                         size_t seedIdx = 0, hitIdx, h;
                         double d2, min_d2 = seeds.front().dist2(center, hitIdx);
                         for (size_t i = 1; i < seeds.size(); i++)
                         {
                                 d2 = seeds[i].dist2(center, h);
                                 if (d2 < min_d2) { min_d2 = d2; seedIdx = i; hitIdx = h; }
                         }
 
                         tss::Cluster2D segment = buildSegment(inp, center, seeds[seedIdx][hitIdx].Point2D());
                         if (segment.size())
                         {
                                 result.emplace_back(segment);
                                 if (segment.size() > 1)
                                 {
                                         const tss::Hit2D* hEnd = segment.end();
                                         if (hEnd) centers.emplace_back(hEnd->Point2D());
                                 }
                         }
 
                         seeds.erase(seeds.begin() + seedIdx);
                 }
         }
         else
         {
                 result.emplace_back(tss::Cluster2D());
                 result.back().push_back(hFirst);
                 inp.release(hFirst);
         }
 }

tss::Cluster2D tss::Segmentation2D::selectRing	(	const tss::Cluster2D &	inp,
		TVector2	center
	)		const

private

Definition at line 165 of file Segmentation2D.cxx.

References pma::Dist2(), fRadiusMax, fRadiusMin, tss::Cluster2D::hits(), tss::Cluster2D::push_back(), and tss::Cluster2D::size().

Referenced by run(), and Segmentation2D().

 {
         double d2_min = fRadiusMin * fRadiusMin;
         double d2_max = fRadiusMax * fRadiusMax;
 
         tss::Cluster2D ring;
         for (size_t h = 0; h < inp.size(); h++)
         {
                 double d2 = pma::Dist2(center, inp[h].Point2D());
                 if ((d2 >= d2_min) && (d2 <= d2_max))
                         ring.push_back(inp.hits()[h]);
         }
         return ring;
 }

void tss::Segmentation2D::splitHits	(	const std::vector< tss::Cluster2D > &	inp,
		std::vector< const tss::Hit2D * > &	trackHits,
		std::vector< const tss::Hit2D * > &	emHits
	)		const

Definition at line 359 of file Segmentation2D.cxx.

Referenced by Segmentation2D().

 {
         
         trackHits.clear();
         emHits.clear();
 
         for (const auto & cx : inp)
         {
                 if (!cx.size()) continue;
 
                 if (cx.isEM())
                 {
                         for (auto h : cx.hits()) emHits.push_back(h);
                 }
                 else
                 {
                         for (auto h : cx.hits()) trackHits.push_back(h);
                 }
         }
 
 }

void tss::Segmentation2D::splitHitsNaive	(	const tss::Cluster2D &	inp,
		std::vector< const tss::Hit2D * > &	trackHits,
		std::vector< const tss::Hit2D * > &	emHits
	)		const

Definition at line 385 of file Segmentation2D.cxx.

References pma::Dist2(), fDenseHitRadius, fDenseMinH, tss::Cluster2D::hits(), and n.

Referenced by tss::TrackShowerHits::produce(), and Segmentation2D().

 {
         const double rad2 = fDenseHitRadius * fDenseHitRadius;
 
         trackHits.clear();
         emHits.clear();
 
         for (const auto hx : inp.hits())
         {
                 size_t n = 0;
                 for (const auto hy : inp.hits())
                 {
                         if (hx->Hit2DPtr() == hy->Hit2DPtr()) continue;
 
                         if (pma::Dist2(hx->Point2D(), hy->Point2D()) < rad2) n++;
                 }
 
                 if (n > fDenseMinH)
                 {
                         emHits.push_back(hx);
                 }
                 else
                 {
                         trackHits.push_back(hx);
                 }
         }
 }

void tss::Segmentation2D::splitHitsNaive	(	const std::vector< tss::Cluster2D > &	inp,
		std::vector< const tss::Hit2D * > &	trackHits,
		std::vector< const tss::Hit2D * > &	emHits
	)		const

Definition at line 417 of file Segmentation2D.cxx.

References pma::Dist2(), fDenseHitRadius, fDenseMinH, and n.

 {
         const double rad2 = fDenseHitRadius * fDenseHitRadius;
 
         trackHits.clear();
         emHits.clear();
 
         for (const auto & cx : inp)
         {
                 if (!cx.size()) continue;
 
                 for (const auto hx : cx.hits())
                 {
                         size_t n = 0;
                         for (const auto & cy : inp)
                         {
                                 if (!cy.size()) continue;
 
                                 for (const auto hy : cy.hits())
                                 {
                                         if (hx->Hit2DPtr() == hy->Hit2DPtr()) continue;
 
                                         if (pma::Dist2(hx->Point2D(), hy->Point2D()) < rad2) n++;
                                 }
                         }
 
                         if (n > fDenseMinH)
                         {
                                 emHits.push_back(hx);
                         }
                         else
                         {
                                 trackHits.push_back(hx);
                         }
                 }
         }
 }

void tss::Segmentation2D::tagDenseEnds ( std::vector< tss::Cluster2D > & group ) const

private

Definition at line 181 of file Segmentation2D.cxx.

References pma::Dist2(), evd::details::end(), and fDenseVtxRadius.

Referenced by run(), and Segmentation2D().

 {
         const double rad2 = fDenseVtxRadius * fDenseVtxRadius;
 
         for (size_t i = 0; i < group.size(); i++)
         {
                 bool denseStart = false, denseEnd = false;
                 TVector2 start0(group[i].start()->Point2D()), end0(group[i].end()->Point2D());
 
                 for (size_t j = 0; j < group.size(); j++)
                 {
                         if (i == j) continue;
 
                         TVector2 start1(group[j].start()->Point2D()), end1(group[j].end()->Point2D());
 
                         if (!group[j].isDenseStart())
                         {
                                 
                                 if (pma::Dist2(start1, start0) < rad2)
                                 {
                                         group[j].tagDenseStart(true);
                                         denseStart = true;
                                 }
                                 if (pma::Dist2(start1, end0) < rad2)
                                 {
                                         group[j].tagDenseStart(true);
                                         denseEnd = true;
                                 }
                         }
 
                         if (!group[j].isDenseEnd())
                         {
                                 if (pma::Dist2(end1, start0) < rad2)
                                 {
                                         group[j].tagDenseEnd(true);
                                         denseStart = true;
                                 }
                                 if (pma::Dist2(end1, end0) < rad2)
                                 {
                                         group[j].tagDenseEnd(true);
                                         denseEnd = true;
                                 }
                         }
                 }
                                         
                 if (denseStart) group[i].tagDenseStart(true);
                 if (denseEnd) group[i].tagDenseEnd(true);
 
         }
 }

Member Data Documentation

double tss::Segmentation2D::fDenseHitRadius

private

Definition at line 73 of file Segmentation2D.h.

Referenced by reconfigure(), and splitHitsNaive().

size_t tss::Segmentation2D::fDenseMinH

private

Definition at line 74 of file Segmentation2D.h.

Referenced by reconfigure(), and splitHitsNaive().

size_t tss::Segmentation2D::fDenseMinN

private

Definition at line 74 of file Segmentation2D.h.

Referenced by mergeDenseParts(), and reconfigure().

double tss::Segmentation2D::fDenseVtxRadius

private

Definition at line 73 of file Segmentation2D.h.

Referenced by mergeDenseParts(), reconfigure(), and tagDenseEnds().

double tss::Segmentation2D::fMaxLineDist

private

Definition at line 71 of file Segmentation2D.h.

Referenced by buildSegment(), and reconfigure().

double tss::Segmentation2D::fRadiusMax

private

Definition at line 70 of file Segmentation2D.h.

Referenced by reconfigure(), and selectRing().

double tss::Segmentation2D::fRadiusMin

private

Definition at line 70 of file Segmentation2D.h.

Referenced by reconfigure(), and selectRing().

tss::SimpleClustering tss::Segmentation2D::fSimpleClustering

private

Definition at line 68 of file Segmentation2D.h.

Referenced by buildSegment(), and run().

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

/cvmfs/larsoft.opensciencegrid.org/products/larreco/v07_10_02/source/larreco/ClusterFinder/TrackShowerSplitter/Segmentation2D/Segmentation2D.h
/cvmfs/larsoft.opensciencegrid.org/products/larreco/v07_10_02/source/larreco/ClusterFinder/TrackShowerSplitter/Segmentation2D/Segmentation2D.cxx

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation