LArCanvasHelper class. More...

#include "LArCanvasHelper.h"

Static Public Member Functions
static void	DrawRing (float **canvas, const int row, const int col, const int inner, const int outer, const float weight)
	Add a filled ring to the specified canvas. The ring has an inner radius based on the minimum predicted distance to the vertex and an outer radius based on the maximum predicted distance to the vertex. The centre of the ring is the location of the hit used to predict the distance to the vertex. Each pixel to be filled is augmented by the specified weight. In this way, once all hits have been considered, a consensus view emerges of the likely vertex location based on the overlap of various rings centred at different locations. More...

static void	Update (const int radius, int &col, int &row)
	Update the coordinates along the loci of a circle. When drawing the ring we need an efficient means to determine the next pixel defining the inner and outer loci of the ring. This update function uses the Bresenham midpoint circle update function to determine this location. The row position is always incremented by 1 pixel, the column position is left unchanged, or decremented by 1 pixel to best follow the arc of the true underlying circle. More...

Detailed Description

LArCanvasHelper class.

Definition at line 17 of file LArCanvasHelper.h.

Member Function Documentation

void lar_dl_content::LArCanvasHelper::DrawRing	(	float **	canvas,
		const int	row,
		const int	col,
		const int	inner,
		const int	outer,
		const float	weight
	)

static

Add a filled ring to the specified canvas. The ring has an inner radius based on the minimum predicted distance to the vertex and an outer radius based on the maximum predicted distance to the vertex. The centre of the ring is the location of the hit used to predict the distance to the vertex. Each pixel to be filled is augmented by the specified weight. In this way, once all hits have been considered, a consensus view emerges of the likely vertex location based on the overlap of various rings centred at different locations.

The underlying implementation is a variant of the Bresenham midpoint circle algorithm and therefore only computes pixel coordinates for one octant of each circle (one of radius 'inner', one of radius 'outer') and interpolates the fill between points using integer arithmetic, guaranteeing each pixel of the ring is filled once and only once, and then mirrored to the remaining seven octants.

Parameters

networkOutput	The TorchOutput object populated by the network inference step
pixelVector	The vector of populated pixels
thresholds	The fractional distance thresholds representing the classes predicted by the network
columnOffset	The output column offset for the canvas
rowOffset	The output row offset for the canvas
width	The output width for the canvas
height	The output height for the canvas

Definition at line 14 of file LArCanvasHelper.cc.

References c1, c2, Update(), and weight.

Referenced by lar_dl_content::DlVertexingAlgorithm::Infer(), and lar_dl_content::DlSecondaryVertexingAlgorithm::Infer().

 {
     // Set the starting position for each circle bounding the ring
     int c1{inner}, r1{0}, c2{outer}, r2{0};
     int inner2{inner * inner}, outer2{outer * outer};
     while (c2 >= r2)
     {
         // Set the output pixel location
         int rp2{r2}, cp2{c2};
         // We're still within the octant for the inner ring, so use the inner pixel location (see Update comment below)
         // Note also that the inner row is always the same as the outer row, so no need to define rp1
         int cp1{c1};
         if (c1 <= r1)
         { // We've completed the arc of the inner ring already, so just move radially out from here (see Update comment below)
             cp1 = r2;
         }
         // Fill the pixels from inner to outer in the current row and their mirror pixels in the other octants
         for (int c = cp1; c <= cp2; ++c)
         {
             canvas[row + rp2][col + c] += weight;
             if (rp2 != c)
                 canvas[row + c][col + rp2] += weight;
             if (rp2 != 0 && cp2 != 0)
             {
                 canvas[row - rp2][col - c] += weight;
                 if (rp2 != c)
                     canvas[row - c][col - rp2] += weight;
             }
             if (rp2 != 0)
             {
                 canvas[row - rp2][col + c] += weight;
                 if (rp2 != c)
                     canvas[row + c][col - rp2] += weight;
             }
             if (cp2 != 0)
             {
                 canvas[row + rp2][col - c] += weight;
                 if (rp2 != c)
                     canvas[row - c][col + rp2] += weight;
             }
         }
         // Only update the inner location while it remains in the octant (outer ring also remains in the octant of course, but the logic of
         // the update means that the inner ring can leave its octant before the outer ring is complete, so we need to stop that)
         if (c1 > r1)
             LArCanvasHelper::Update(inner2, c1, r1);
         // Update the outer location - increase the row position with every step, decrease the column position if conditions are met
         LArCanvasHelper::Update(outer2, c2, r2);
     }
 }

void lar_dl_content::LArCanvasHelper::Update	(	const int	radius,
		int &	col,
		int &	row
	)

static

Update the coordinates along the loci of a circle. When drawing the ring we need an efficient means to determine the next pixel defining the inner and outer loci of the ring. This update function uses the Bresenham midpoint circle update function to determine this location. The row position is always incremented by 1 pixel, the column position is left unchanged, or decremented by 1 pixel to best follow the arc of the true underlying circle.

Parameters

radius2	The squared radius of the circle under consideration
col	The input/output column position to (potentially) update
row	The input/output row position to update

Definition at line 66 of file LArCanvasHelper.cc.

References col.

Referenced by DrawRing().

 {
     // Bresenham midpoint circle algorithm to determine if we should update the column position
     // This obscure looking block of code uses bit shifts and integer arithmetic to perform this check as efficiently as possible
     const int a{1 - (col << 2)};
     const int b{col * col + row * row - radius2 + (row << 2) + 1};
     const int c{(a << 2) * b + a * a};
     if (c < 0)
     {
         --col;
         ++row;
     }
     else
         ++row;
 }

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

larpandoracontent/v04_14_00/source/larpandoradlcontent/LArHelpers/LArCanvasHelper.h
larpandoracontent/v04_14_00/source/larpandoradlcontent/LArHelpers/LArCanvasHelper.cc

Static Public Member Functions

Detailed Description

Member Function Documentation