test_rayclustering.cxx File Reference

#include "WireCellUtil/RayClustering.h"
#include "WireCellUtil/RayTiling.h"
#include "WireCellUtil/Waveform.h"
#include "WireCellUtil/Testing.h"
#include "WireCellUtil/Logging.h"
#include <math.h>
#include <random>
#include <fstream>
#include <string>
#include "raygrid.h"
#include "raygrid_dump.h"

Go to the source code of this file.

Classes
struct	Chirp

Typedefs
typedef std::vector< Activity::value_t >	measure_t

Functions
static std::vector< Point >	make_points (std::default_random_engine &generator, double x)
static std::vector< measure_t >	make_measures (Coordinates &coords, const std::vector< Point > &points)
static activities_t	make_activities (Coordinates &coords, std::vector< measure_t > &measures)
static void	test_blobs (const blobs_t &blobs)
int	main (int argc, char *argv[])

Variables
const int	ndepos = 10
const int	neles = 10
const double	pitch_magnitude = 5
const double	gaussian = 3
const double	border = 10
const double	width = 100
const double	height = 100

Typedef Documentation

typedef std::vector<Activity::value_t> measure_t

Definition at line 58 of file test_rayclustering.cxx.

Function Documentation

int main	(	int	argc,
		char *	argv[]
	)

Definition at line 244 of file test_rayclustering.cxx.

{
    auto raypairs = make_raypairs(width, height, pitch_magnitude);

    Coordinates coords(raypairs);

    Tiling tiling(coords);

    std::default_random_engine generator;
    std::vector<Point> pts1 = make_points(generator, 10.0);
    std::vector<Point> pts2 = make_points(generator, 20.0);

    std::vector<measure_t> meas1 = make_measures(coords, pts1);
    std::vector<measure_t> meas2 = make_measures(coords, pts2);

    auto act1 = make_activities(coords, meas1);
    auto act2 = make_activities(coords, meas2);

    auto blobs1 = make_blobs(coords, act1);
    auto blobs2 = make_blobs(coords, act2);

    test_blobs(blobs1);
    test_blobs(blobs2);       

    // fixme: blobs are missing these features:
    // - sort corners
    // - apply X offset
    // - assign some value
    // this is maybe best done converting from Blob to another rep

    JsonEvent dumper(coords);
    for (const auto& pt : pts1) { dumper(pt); }
    for (const auto& pt : pts2) { dumper(pt); }
    Chirp chirp(blobs1, blobs2, coords, dumper);
    associator_t chirpf = chirp;
    associate(blobs1, blobs2, chirpf);

    chirp.dump(dumper);

    std::string fout = argv[0];
    fout += ".json";
    dumper.dump(fout);

    return 0;
}

static activities_t make_activities ( Coordinates &  coords, std::vector< measure_t > &  measures  )

static

Definition at line 107 of file test_rayclustering.cxx.

{
    int nlayers = coords.nlayers();
    activities_t activities;
    for (int ilayer = 0; ilayer<nlayers; ++ilayer) {
        auto& m = measures[ilayer];
        info("Make activity for layer: {}: {}", ilayer, m.size());
        Activity activity(ilayer, {m.begin(), m.end()});
        Assert(!activity.empty());
        activities.push_back(activity);
    }
    return activities;
}

static std::vector<measure_t> make_measures ( Coordinates &  coords, const std::vector< Point > &  points  )

static

Definition at line 61 of file test_rayclustering.cxx.

{
    int nlayers = coords.nlayers();
    std::vector<measure_t> measures(nlayers);
    const auto& pitches = coords.pitch_dirs();
    const auto& centers = coords.centers();
    const auto& pitch_mags = coords.pitch_mags();

    for (size_t ipt=0; ipt<points.size(); ++ipt ) {
        const auto& p = points[ipt];
        for (int ilayer = 0; ilayer<nlayers; ++ilayer) {
            const auto& pit = pitches[ilayer];
            const auto& cen = centers[ilayer];
            const auto rel = p-cen;
            const int pit_ind = pit.dot(rel)/pitch_mags[ilayer]; 
            if (pit_ind < 0) {
                warn("Negative pitch indices not allowed, got {} from ilayer {} ipt {} for point {}",
                     pit_ind, ilayer, ipt, p);
                continue;
            }
            if (ilayer <= 1) {
                if (pit_ind >= 1 or pit_ind < 0) {
                    debug("mm: pit_ind={} with ipt={}", pit_ind, ipt);
                    if (pit_ind == 1) {
                        debug("\tpit={} cen={} rel={}", pit, cen, rel);
                    }
                    continue;
                }
            }
            measure_t& m = measures[ilayer];
            if ((int)m.size() <= pit_ind) {
                debug("resize for ipt {} ilayer {} from {} to {}", ipt, ilayer, m.size(), pit_ind+1);
                m.resize(pit_ind+1, 0.0);
                debug("done");
            }

            debug("adding to pit_ind {} ilayer {} ipt {}", pit_ind, ilayer, ipt);
            m[pit_ind] += 1.0;
            debug("valud: {}", m[pit_ind]);
        }
    }

    return measures;
}

static std::vector<Point> make_points ( std::default_random_engine &  generator, double  x  )

static

Definition at line 36 of file test_rayclustering.cxx.

{
    std::vector<Point> points;
    std::uniform_real_distribution<double> position(0,std::max(width,height));
    std::normal_distribution<double> spread(0.0, gaussian);
    for (int idepo=0;idepo<ndepos;++idepo) {
        Point cp(0, position(generator), position(generator));
        for (int iele=0; iele<neles; ++iele) {
            const Point delta(x, spread(generator), spread(generator));
            const Point pt = cp + delta;
            if (pt.y() < -border or pt.y() > height+border or
                pt.z() < -border or pt.z() > width+border) {
                warn("Rejecting far away point: {} + {}" , cp, delta);
                continue;
            }
            points.push_back(cp+delta);
        }
    }
    return points;
}

static void test_blobs ( const blobs_t &  blobs )

static

Definition at line 232 of file test_rayclustering.cxx.

{
    for (const auto& blob : blobs) {
        const auto& strips = blob.strips();
        Assert(strips[0].bounds.first == 0);
        Assert(strips[0].bounds.second == 1);
        Assert(strips[1].bounds.first == 0);
        Assert(strips[1].bounds.second == 1);
    }
}

Variable Documentation

const double border = 10

Definition at line 26 of file test_rayclustering.cxx.

const double gaussian = 3

Definition at line 25 of file test_rayclustering.cxx.

const double height = 100

Definition at line 28 of file test_rayclustering.cxx.

const int ndepos = 10

Definition at line 22 of file test_rayclustering.cxx.

const int neles = 10

Definition at line 23 of file test_rayclustering.cxx.

const double pitch_magnitude = 5

Definition at line 24 of file test_rayclustering.cxx.

const double width = 100

Definition at line 27 of file test_rayclustering.cxx.