WireCell::Img::BlobClustering Class Reference

#include <BlobClustering.h>

Inheritance diagram for WireCell::Img::BlobClustering:

Public Member Functions
	BlobClustering ()
virtual	~BlobClustering ()
virtual void	configure (const WireCell::Configuration &cfg)
	Accept a configuration. More...
virtual WireCell::Configuration	default_configuration () const
	Optional, override to return a hard-coded default configuration. More...
virtual bool	operator() (const input_pointer &blobset, output_queue &clusters)
	The calling signature: More...
Public Member Functions inherited from WireCell::IClustering
virtual	~IClustering ()
virtual std::string	signature ()
Public Member Functions inherited from WireCell::IQueuedoutNode< IBlobSet, ICluster >
virtual	~IQueuedoutNode ()
virtual bool	operator() (const boost::any &anyin, queuedany &outanyq)
	The calling signature: More...
virtual std::vector< std::string >	input_types ()
virtual std::vector< std::string >	output_types ()
Public Member Functions inherited from WireCell::IQueuedoutNodeBase
virtual	~IQueuedoutNodeBase ()
virtual NodeCategory	category ()
	Return the behavior category type. More...
virtual int	concurrency ()
	By default assume all subclasses maintain state. More...
Public Member Functions inherited from WireCell::INode
virtual	~INode ()
virtual void	reset ()
Public Member Functions inherited from WireCell::IComponent< INode >
virtual	~IComponent ()
Public Member Functions inherited from WireCell::Interface
virtual	~Interface ()
Public Member Functions inherited from WireCell::IConfigurable
virtual	~IConfigurable ()
Public Member Functions inherited from WireCell::IComponent< IConfigurable >
virtual	~IComponent ()

Private Member Functions
void	add_slice (const ISlice::pointer &islice)
void	add_blobs (const input_pointer &newbs)
void	flush (output_queue &clusters)
bool	graph_bs (const input_pointer &newbs)
bool	judge_gap (const input_pointer &newbs)
void	intern (const input_pointer &newbs)

Private Attributes
double	m_spans
IBlobSet::pointer	m_last_bs
cluster_indexed_graph_t	m_grind
Log::logptr_t	l

Additional Inherited Members
Public Types inherited from WireCell::IClustering
typedef std::shared_ptr< IClustering >	pointer
Public Types inherited from WireCell::IQueuedoutNode< IBlobSet, ICluster >
typedef std::shared_ptr< IQueuedoutNodeBase >	pointer
typedef IBlobSet	input_type
typedef ICluster	output_type
typedef std::shared_ptr< const IBlobSet >	input_pointer
typedef std::shared_ptr< const ICluster >	output_pointer
typedef std::deque< output_pointer >	output_queue
Public Types inherited from WireCell::IQueuedoutNodeBase
typedef std::shared_ptr< IQueuedoutNodeBase >	pointer
typedef std::deque< boost::any >	queuedany
Public Types inherited from WireCell::INode
enum	NodeCategory {   unknown, sourceNode, sinkNode, functionNode,   queuedoutNode, joinNode, splitNode, faninNode,   fanoutNode, multioutNode, hydraNode }
Public Types inherited from WireCell::IComponent< INode >
typedef std::shared_ptr< INode >	pointer
	Access subclass facet by pointer. More...
typedef std::vector< pointer >	vector
	Vector of shared pointers. More...
Public Types inherited from WireCell::Interface
typedef std::shared_ptr< Interface >	pointer
Public Types inherited from WireCell::IComponent< IConfigurable >
typedef std::shared_ptr< IConfigurable >	pointer
	Access subclass facet by pointer. More...
typedef std::vector< pointer >	vector
	Vector of shared pointers. More...

Detailed Description

Definition at line 40 of file BlobClustering.h.

Constructor & Destructor Documentation

Img::BlobClustering::BlobClustering

(

)

Definition at line 14 of file BlobClustering.cxx.

    : m_spans(1.0)
    , m_last_bs(nullptr)
    , l(Log::logger("img"))
{
}

Img::BlobClustering::~BlobClustering ( )

virtual

Definition at line 20 of file BlobClustering.cxx.

{
}

Member Function Documentation

void Img::BlobClustering::add_blobs ( const input_pointer &  newbs )

private

Definition at line 86 of file BlobClustering.cxx.

{
    for (const auto& iblob : newbs->blobs()) {
        auto islice = iblob->slice();
        add_slice(islice);
        m_grind.edge(islice, iblob);

        auto iface = iblob->face();
        auto wire_planes = iface->planes();

        const auto& shape = iblob->shape();
        for (const auto& strip : shape.strips()) {
            // FIXME: need a way to encode this convention!
            // For now, it requires collusion.  Don't impeach me.
            const int num_nonplane_layers = 2;
            int iplane = strip.layer - num_nonplane_layers;
            if (iplane < 0) {
                continue; 
            }
            const auto& wires = wire_planes[iplane]->wires();
            for (int wip=strip.bounds.first; wip < strip.bounds.second and wip < int(wires.size()); ++wip) {
                auto iwire = wires[wip];
                m_grind.edge(iblob, iwire);
            }
        }
    }
}

void Img::BlobClustering::add_slice ( const ISlice::pointer &  islice )

private

Definition at line 69 of file BlobClustering.cxx.

{
    if (m_grind.has(islice)) {
        return;
    }

    for (const auto& ichv : islice->activity()) {
        const IChannel::pointer ich = ichv.first;
        if (m_grind.has(ich)) {
            continue;
        }
        for (const auto& iwire : ich->wires()) {
            m_grind.edge(ich, iwire);
        }
    }
}

void Img::BlobClustering::configure ( const WireCell::Configuration &  config )

virtual

Accept a configuration.

Implements WireCell::IConfigurable.

Definition at line 24 of file BlobClustering.cxx.

{
    m_spans = get(cfg, "spans", m_spans);
}

WireCell::Configuration Img::BlobClustering::default_configuration ( ) const

virtual

Optional, override to return a hard-coded default configuration.

Reimplemented from WireCell::IConfigurable.

Definition at line 29 of file BlobClustering.cxx.

{
    Configuration cfg;
    // A number multiplied to the span of the current slice when
    // determining it a gap exists between the next slice.  Default is
    // 1.0.  Eg, if set to 2.0 then a single missing slice won't be
    // grounds for considering a gap in the cluster.  A number less
    // than 1.0 will cause each "cluster" to consist of only one blob.
    cfg["spans"] = m_spans;
    return cfg;
}

void Img::BlobClustering::flush ( output_queue &  clusters )

private

Definition at line 41 of file BlobClustering.cxx.

{
    clusters.push_back(std::make_shared<SimpleCluster>(m_grind.graph()));
    m_grind.clear();
    m_last_bs = nullptr;
}

bool Img::BlobClustering::graph_bs ( const input_pointer &  newbs )

private

Definition at line 114 of file BlobClustering.cxx.

{
    add_blobs(newbs);

    if (!m_last_bs) {
        // need to wait for next one to do anything.
        // note, caller interns.
        return false;
    }
    if (judge_gap(newbs)) {
        // nothing to do, but pass on that we hit a gap
        return true;
    }

    // handle each face separately faces
    IBlob::vector iblobs1 = newbs->blobs();
    IBlob::vector iblobs2 = m_last_bs->blobs();

    RayGrid::blobs_t blobs1 = newbs->shapes();
    RayGrid::blobs_t blobs2 = m_last_bs->shapes();

    const auto beg1 = blobs1.begin();
    const auto beg2 = blobs2.begin();

    auto assoc = [&](RayGrid::blobref_t& a, RayGrid::blobref_t& b) {
                     int an = a - beg1;
                     int bn = b - beg2;
                     m_grind.edge(iblobs1[an], iblobs2[bn]);
                 };
    RayGrid::associate(blobs1, blobs2, assoc);

    

    return false;
}

void Img::BlobClustering::intern ( const input_pointer &  newbs )

private

Definition at line 48 of file BlobClustering.cxx.

{
    m_last_bs = newbs;
}

bool Img::BlobClustering::judge_gap ( const input_pointer &  newbs )

private

Definition at line 53 of file BlobClustering.cxx.

{
    const double epsilon = 1*units::ns;

    if (m_spans <= epsilon) {
        return false;           // never break on gap.
    }

    auto nslice = newbs->slice();
    auto oslice = m_last_bs->slice();

    const double dt = nslice->start() - oslice->start();
    return std::abs(dt - m_spans*oslice->span()) > epsilon;
}

bool Img::BlobClustering::operator() ( const input_pointer &  in, output_queue &  outq  )

virtual

The calling signature:

Implements WireCell::IQueuedoutNode< IBlobSet, ICluster >.

Definition at line 150 of file BlobClustering.cxx.

{
    if (!blobset) {             // eos
        l->debug("BlobClustering: EOS");
        flush(clusters);
        clusters.push_back(nullptr); // forward eos
        return true;
    }

    SPDLOG_LOGGER_TRACE(l,"BlobClustering: got {} blobs", blobset->blobs().size());

    bool gap = graph_bs(blobset);
    if (gap) {
        flush(clusters);
        l->debug("BlobClustering: sending {} clusters", clusters.size());
        // note: flush fast to keep memory usage in this component
        // down and because in an MT job, downstream components might
        // benefit to start consuming clusters ASAP.  We do NOT want
        // to intern() the new blob set BEFORE a flush if there is a
        // gap because newbs is needed for next time and fush clears
        // the cache.
    }

    intern(blobset);

    SPDLOG_LOGGER_TRACE(l,"BlobClustering: holding {}", boost::num_vertices(m_grind.graph()));

    return true;
}

Member Data Documentation

Log::logptr_t WireCell::Img::BlobClustering::l

private

Definition at line 77 of file BlobClustering.h.

cluster_indexed_graph_t WireCell::Img::BlobClustering::m_grind

private

Definition at line 59 of file BlobClustering.h.

IBlobSet::pointer WireCell::Img::BlobClustering::m_last_bs

private

Definition at line 57 of file BlobClustering.h.

double WireCell::Img::BlobClustering::m_spans

private

Definition at line 54 of file BlobClustering.h.

---

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

• wire-cell-build/img/inc/WireCellImg/BlobClustering.h
• wire-cell-build/img/src/BlobClustering.cxx