kSpot.h

Go to the documentation of this file.

#ifndef K_FIRESYNC_SPOT_H
#define K_FIRESYNC_SPOT_H

#include <kFireSync/kFsDef.h>
#include <kFireSync/kNodeDef.h>
#include <kApi/Data/kArrayList.h>
#include <kApi/Data/kArray1.h>
#include <kApi/Data/kImage.h>
#include <kFireSync/Data/kSpot.x.h>

#define kSPOT_CENTRE_SHIFT      (8)                         // centre shift
#define kSPOT_CENTRE_SCALE      (1 << kSPOT_CENTRE_SHIFT)   // centre scale

/* 
 * kSpot
 */

typedef struct kSpot  
{
    k32u centre;             /* scaled centre of the spot (along slice) */
    k16u slice;              /* slice index */
    k16u strength;           /* spot strength metric (e.g. sum, peak) */
    k16u width;              /* spot width */
} kSpot;

/* 
 * kSpot2
 */

typedef struct kSpot2 
{
    k32u centre[2];          /* scaled centre of the spot in each dimension */
    k32u strength;           /* spot strength metric (e.g. sum, peak) */
} kSpot2;

/* 
 * kFpgaCSum
 */

typedef struct kFpgaCSum  
{
    k16u sum;                   /* sum of pixel intensities along slice */
    k16u wsum;                  /* weighted sum of pixel intensities along slice */
} kFpgaCSum;

/* 
 * kFpgaCSum3
 */

typedef struct kFpgaCSum3
{
    k32u csum3;
} kFpgaCSum3;

kInlineFx(k32u) kFpgaCSum3_Overflow(const kFpgaCSum3* cs)
{
    return cs->csum3 & kFPGA_CSUM3_OVERFLOW_MASK; 
}

kInlineFx(k32u) kFpgaCSum3_Sum(const kFpgaCSum3* cs)
{
    return (cs->csum3 & kFPGA_CSUM3_SUM_MASK) >> kFPGA_CSUM3_SUM_SHIFT; 
}

kInlineFx(k32u) kFpgaCSum3_WSum(const kFpgaCSum3* cs)
{
    return (cs->csum3 & kFPGA_CSUM3_WSUM_MASK) >> kFPGA_CSUM3_WSUM_SHIFT; 
}

typedef struct kCSum4
{
    k32u csum;      
} kCSum4;

kInlineFx(k32u) kCSum4_MaxSum()
{
    return (kCSUM4_SUM_MASK >> kCSUM4_SUM_SHIFT) - 1; 
}

kInlineFx(k32u) kCSum4_MaxWSum()
{
    return (kCSUM4_WSUM_MASK >> kCSUM4_WSUM_SHIFT) - 1;
}

kInlineFx(void) kCSum4_Init(kCSum4* cs, k32u sum, k32u wsum)
{
    cs->csum = kField_CreateNamed_(kCSUM4_SUM, sum) | kField_CreateNamed_(kCSUM4_WSUM, wsum);
}

kInlineFx(void) kCSum4_InitOverflow(kCSum4* cs)
{
    cs->csum = kCSUM4_OVERFLOW; 
}

kInlineFx(kBool) kCSum4_IsOverflow(const kCSum4* cs)
{
    return cs->csum == kCSUM4_OVERFLOW; 
}

kInlineFx(void) kCSum4_SetSum(kCSum4* cs, k32u sum)
{
    kField_InsertNamed_(&cs->csum, kCSUM4_SUM, sum);
}

kInlineFx(k32u) kCSum4_Sum(const kCSum4* cs)
{
    return kField_ExtractNamed_(cs->csum, kCSUM4_SUM);
}

kInlineFx(void) kCSum4_SetWSum(kCSum4* cs, k32u wsum)
{
    kField_InsertNamed_(&cs->csum, kCSUM4_WSUM, wsum);
}

kInlineFx(k32u) kCSum4_WSum(const kCSum4* cs)
{
    return kField_ExtractNamed_(cs->csum, kCSUM4_WSUM);
}

typedef struct kPhasePixel
{
    k8u contrast;
    k8u intensity;
    k16s phase;
} kPhasePixel;

typedef struct kPhasePixel2
{
    k32u content;             //packed bitfields
} kPhasePixel2;

#define kPHASE_PIXEL_2_NULL_PHASE           (0xFFFFFF)      


kInlineFx(void) kPhasePixel2_Init(kPhasePixel2* phasePixel, k32u phase, k8u intensity)
{
    kField_InsertNamed_(&phasePixel->content, kPHASE_PIXEL2_INTENSITY, intensity); 
    kField_InsertNamed_(&phasePixel->content, kPHASE_PIXEL2_PHASE, phase); 
}

kInlineFx(k8u) kPhasePixel2_Intensity(kPhasePixel2 phasePixel)
{
    return (k8u) kField_ExtractNamed_(phasePixel.content, kPHASE_PIXEL2_INTENSITY); 
}

kInlineFx(void) kPhasePixel2_SetIntensity(kPhasePixel2* phasePixel, k8u intensity)
{
    kField_InsertNamed_(&phasePixel->content, kPHASE_PIXEL2_INTENSITY, intensity); 
}

kInlineFx(k32u) kPhasePixel2_Phase(kPhasePixel2 phasePixel)
{
    return kField_ExtractNamed_(phasePixel.content, kPHASE_PIXEL2_PHASE);  
}

kInlineFx(void) kPhasePixel2_SetPhase(kPhasePixel2* phasePixel, k32u phase)
{
    kField_InsertNamed_(&phasePixel->content, kPHASE_PIXEL2_PHASE, phase); 
}

/* 
 * kFpgaSpot
 */

typedef struct kFpgaSpot 
{
    k32u center_width;        /* end in 16.8 fixed point format, and width */
    k16u slice;               /* slice index */
    k16u sum_misc;            /* pixel intensity sum and misc info */
} kFpgaSpot;

kInlineFx(k32u) kFpgaSpot_Center(const kFpgaSpot* cg)
{
    return (((cg->center_width & kxFPGA_SPOT_CENTER_MASK2) >> kxFPGA_SPOT_CENTER_SHIFT2) << kxFPGA_SPOT_CENTER_SIZE1) | 
           (cg->center_width & kxFPGA_SPOT_CENTER_MASK1);
}

kInlineFx(k16u) kFpgaSpot_SpotWidth(const kFpgaSpot* cg)
{
    return (cg->center_width & kxFPGA_SPOT_SPOT_WIDTH_MASK) >> kxFPGA_SPOT_SPOT_WIDTH_SHIFT;
}

kInlineFx(k16u) kFpgaSpot_Slice(const kFpgaSpot* cg)
{
    return (((cg->sum_misc & kxFPGA_SPOT_SLICE_MASK2) >> kxFPGA_SPOT_SLICE_SHIFT2) << kxFPGA_SPOT_SLICE_SIZE1) | 
           (cg->slice & kxFPGA_SPOT_SLICE_MASK1);
}

kInlineFx(k16u) kFpgaSpot_Empty(const kFpgaSpot* cg)
{
    return cg->sum_misc & kxFPGA_SPOT_MISC_EMPTY_MASK;
}

kInlineFx(k16u) kFpgaSpot_Sum(const kFpgaSpot* cg)
{
    return (cg->sum_misc & kxFPGA_SPOT_MISC_SUM_MASK) >> kxFPGA_SPOT_MISC_SUM_SHIFT; 
}

kInlineFx(k32u) kFpgaSpot_EntryValue(const kFpgaSpot* cg)
{
    return ((cg->center_width & kxFPGA_SPOT_SOBEL_ENTRY_VALUE_MASK2) >> kxFPGA_SPOT_SOBEL_ENTRY_VALUE_SHIFT2) + 
           ((cg->slice        & kxFPGA_SPOT_SOBEL_ENTRY_VALUE_MASK1) >> kxFPGA_SPOT_SOBEL_ENTRY_VALUE_SHIFT1); 
}

kInlineFx(k32u) kFpgaSpot_EntryOffset(const kFpgaSpot* cg)
{
    k32u value = ((cg->center_width & kxFPGA_SPOT_SOBEL_ENTRY_VALUE_MASK2) >> kxFPGA_SPOT_SOBEL_ENTRY_VALUE_SHIFT2) + 
                 ((cg->slice        & kxFPGA_SPOT_SOBEL_ENTRY_VALUE_MASK1) >> kxFPGA_SPOT_SOBEL_ENTRY_VALUE_SHIFT1); 

    return value << (kSPOT_CENTRE_SHIFT - kxFPGA_WIDE_SPOT_SOBEL_ENTRY_OFFSET_FRACTIONAL_BITS);
}

kInlineFx(k32u) kFpgaSpot_ExitOffset(const kFpgaSpot* cg)
{
    k32u value = ((cg->center_width & kxFPGA_SPOT_SOBEL_ENTRY_VALUE_MASK2) >> kxFPGA_SPOT_SOBEL_ENTRY_VALUE_SHIFT2) + 
                 ((cg->slice        & kxFPGA_SPOT_SOBEL_ENTRY_VALUE_MASK1) >> kxFPGA_SPOT_SOBEL_ENTRY_VALUE_SHIFT1); 

    return value << (kSPOT_CENTRE_SHIFT - kxFPGA_WIDE_SPOT_SOBEL_EXIT_OFFSET_FRACTIONAL_BITS);
}

kInlineFx(kBool) kFpgaSpot_IsColumn(const kFpgaSpot* cg)
{
    return (cg->sum_misc & kxFPGA_SPOT_MISC_ORIENT_MASK) == 0; 
}

kInlineFx(kBool) kFpgaSpot_IsRow(const kFpgaSpot* cg)
{
    return (cg->sum_misc & kxFPGA_SPOT_MISC_ORIENT_MASK) != 0;
}

typedef struct kFpgaWideSpot 
{
    k32u center_width;        
    k16u slice;               
    k16u sum_misc;            
} kFpgaWideSpot;

kInlineFx(k32u) kFpgaWideSpot_Centre(const kFpgaWideSpot* cg)
{
    return (((cg->center_width & kxFPGA_WIDE_SPOT_CENTER_MASK2) >> kxFPGA_WIDE_SPOT_CENTER_SHIFT2) << kxFPGA_WIDE_SPOT_CENTER_SIZE1) | 
           (cg->center_width & kxFPGA_WIDE_SPOT_CENTER_MASK1);
}

kInlineFx(k16u) kFpgaWideSpot_Width(const kFpgaWideSpot* cg)
{
    return ((cg->center_width & kxFPGA_WIDE_SPOT_SPOT_WIDTH_MASK) >> kxFPGA_WIDE_SPOT_SPOT_WIDTH_SHIFT) << kxFPGA_WIDE_SPOT_MULTIPLIER_SHIFT;
}

kInlineFx(k16u) kFpgaWideSpot_Slice(const kFpgaWideSpot* cg)
{
    return (((cg->sum_misc & kxFPGA_WIDE_SPOT_SLICE_MASK2) >> kxFPGA_WIDE_SPOT_SLICE_SHIFT2) << kxFPGA_WIDE_SPOT_SLICE_SIZE1) | 
           (cg->slice & kxFPGA_WIDE_SPOT_SLICE_MASK1);
}

kInlineFx(k16u) kFpgaWideSpot_IsEmpty(const kFpgaWideSpot* cg)
{
    return (cg->sum_misc & kxFPGA_WIDE_SPOT_MISC_EMPTY_MASK) != 0; 
}

kInlineFx(k16u) kFpgaWideSpot_Sum(const kFpgaWideSpot* cg)
{
    return ((cg->sum_misc & kxFPGA_WIDE_SPOT_MISC_SUM_MASK) >> kxFPGA_WIDE_SPOT_MISC_SUM_SHIFT) << kxFPGA_WIDE_SPOT_MULTIPLIER_SHIFT;
}

kInlineFx(k32u) kFpgaWideSpot_EntryValue(const kFpgaWideSpot* cg)
{
    return ((cg->center_width & kxFPGA_WIDE_SPOT_SOBEL_SPARE_MASK2) >> kxFPGA_WIDE_SPOT_SOBEL_SPARE_SHIFT2) + 
           ((cg->slice        & kxFPGA_WIDE_SPOT_SOBEL_SPARE_MASK1) >> kxFPGA_WIDE_SPOT_SOBEL_SPARE_SHIFT1); 
}

kInlineFx(k32u) kFpgaWideSpot_EntryOffset(const kFpgaWideSpot* cg)
{
    k32u value = ((cg->center_width & kxFPGA_WIDE_SPOT_SOBEL_SPARE_MASK2) >> kxFPGA_WIDE_SPOT_SOBEL_SPARE_SHIFT2) + 
                 ((cg->slice        & kxFPGA_WIDE_SPOT_SOBEL_SPARE_MASK1) >> kxFPGA_WIDE_SPOT_SOBEL_SPARE_SHIFT1); 

    return value << (kSPOT_CENTRE_SHIFT - kxFPGA_WIDE_SPOT_SOBEL_ENTRY_OFFSET_FRACTIONAL_BITS);
}

kInlineFx(k32u) kFpgaWideSpot_ExitOffset(const kFpgaWideSpot* cg)
{
    k32u value = ((cg->center_width & kxFPGA_WIDE_SPOT_SOBEL_SPARE_MASK2) >> kxFPGA_WIDE_SPOT_SOBEL_SPARE_SHIFT2) + 
                 ((cg->slice        & kxFPGA_WIDE_SPOT_SOBEL_SPARE_MASK1) >> kxFPGA_WIDE_SPOT_SOBEL_SPARE_SHIFT1); 

    return value << (kSPOT_CENTRE_SHIFT - kxFPGA_WIDE_SPOT_SOBEL_EXIT_OFFSET_FRACTIONAL_BITS);
}

//Deprecated: no longer supported
kInlineFx(kBool) kFpgaWideSpot_IsColumn(const kFpgaWideSpot* cg)
{
    return (cg->sum_misc & kxFPGA_WIDE_SPOT_MISC_ORIENT_MASK) == 0; 
}
kDeprecate(kFpgaWideSpot_IsColumn)

//Deprecated: no longer supported
kInlineFx(kBool) kFpgaWideSpot_IsRow(const kFpgaWideSpot* cg)
{
    return (cg->sum_misc & kxFPGA_WIDE_SPOT_MISC_ORIENT_MASK) != 0;
}
kDeprecate(kFpgaWideSpot_IsRow)

/*
* TODO: Sort out the naming conventions for the spot algorithms below. Some of these are type-specific, 
* others are generic (work with more than one spot type).
*/


// input expects an array list of kTypeOf(kFpgaSpot), kTYPE_FPGA_CG or kTYPE_FPGA_CG2
// output expects an initialized array list of kSpot
kFsFx(kStatus) kSpot_Unpack(kArrayList input, kArrayList output);
 
// spots expects an initialized array list of kSpot
kFsFx(kStatus) kSpot_ARCG(kImage img, k32u minSpotWidth, k32u maxSpotWidth, k32u threshold, kArrayList spots);

// FPGA ACCG implementation
kFsFx(kStatus) kFpgaSpot_ACCG(kImage image, k32u minSpotWidth, k32u maxSpotWidth, k32u threshold, kArrayList spots);

// spots expects an initialized array list of kSpot
kFsFx(kStatus) kSpot_ACCG(kImage img, k32u minSpotWidth, k32u maxSpotWidth, k32u threshold, kArrayList spots);

kFsFx(kStatus) kSpot_CSUM(kImage image, k32u threshold, kArrayList *sums);

// spots expects an initialized array list of kFpgaCSum3
kFsFx(kStatus) kSpot_CSum3(kImage image, k32u threshold, kArrayList csum3);

// spots expects an initialized array list of k64u
kFsFx(kStatus) kSpot_Binarize(kImage image, k32u threshold, kArrayList binarize);

//  kSpot_SobelArcg
//
//  Description:
//      Performs Sobel-filtered ARCG spot detection.  This is the old implementation.  It is currently being used as this version matches the FPGA version.
//  Inputs:
//      image - input kImage data to be processed, expects pixel type kTypeOf(k8s)
//      averageWindow - Sobel filter height in pixels
//      edgeWindow - Sobel filter width in pixels, expects odd number (counts center pixel)
//      threshold - Rising and falling edge threshold
//      widthThreshold - Used for width calculation, only pixels with an intensity greater than baseIntensity + widthThreshold are accepted.
//      minWidth - minimum spot width
//      maxWidth - maximum spot width
//      minSum - minimum spot sum
//  Outputs:
//      spots - returns detected spot objects, expects an initialized array of type kTYPE_SPOT, kTypeOf(kFpgaSpot), or kTypeOf(kFpgaWideSpot) 
//              with capacity equal to maximum expected number of spots
//      bounds - returns x coordinates of rising and falling edge spot boundaries, expects an initialized array of type kTYPE_POINT_32S or kNIL
//      edgeImage - returns the gradient image, expects an initialized image of pixel type kTypeOf(k8s) of size equal to the input image or kNIL

kFsFx(kStatus) kSpot_SobelArcg(kImage image, k32u averageWindow, k32u edgeWindow, k32u threshold, k32u widthThreshold, k32u minWidth,
                                      k32u maxWidth, k32u minSum, kArrayList spots, kArrayList bounds, kImage edgeImage);

//  kSpot_SobelArcg
//
//  Description:
//      Performs Sobel-filtered ARCG spot detection.  This is the new implementation of kSpot_SobelArcg.
//  Inputs:
//      image - input kImage data to be processed, expects pixel type kTypeOf(k8s)
//      averageWindow - Sobel filter height in pixels
//      edgeWindow - Sobel filter width in pixels, expects odd number (counts center pixel)
//      threshold - Rising and falling edge threshold
//      widthThreshold - Used for width calculation, only pixels with an intensity greater than baseIntensity + widthThreshold are accepted.
//      minWidth - minimum spot width
//      maxWidth - maximum spot width
//      minSum - minimum spot sum
//  Outputs:
//      spots - returns detected spot objects, expects an initialized array of type kTYPE_SPOT, kTypeOf(kFpgaSpot), or kTypeOf(kFpgaWideSpot) 
//              with capacity equal to maximum expected number of spots
//      bounds - returns x coordinates of rising and falling edge spot boundaries, expects an initialized array of type kTYPE_POINT_32S or kNIL
//      edgeImage - returns the gradient image, expects an initialized image of pixel type kTypeOf(k8s) of size equal to the input image or kNIL

kFsFx(kStatus) kSpot_SobelArcgV1(kImage image, k32u averageWindow, k32u edgeWindow, k32u threshold, k32u widthThreshold, k32u minWidth,
    k32u maxWidth, k32u minSum, kArrayList spots, kArrayList bounds, kImage edgeImage);

//  kSpot_SobelAccg
//
//  Description:
//      Performs Sobel-filtered ACCG spot detection
//  Input:
//      image - input kImage data to be processed, expects pixel type kTypeOf(k8s)
//  Output:
//      spots - returns detected spot objects, expects an initialized array of type kTYPE_SPOT, kTypeOf(kFpgaSpot), or kTypeOf(kFpgaWideSpot) 
//              with capacity equal to maximum expected number of spots
//      bounds - returns centroid coordinates of rising and falling edge spot boundaries, expects an initialized array of type kTYPE_POINT_32S or kNIL
//      edgeImage - returns the gradient image, expects an initialized image of pixel type kTypeOf(k8s) of size equal to the input image or kNIL
//  Parameters:
//      averageWindow - Sobel filter width in pixels
//      edgeWindow - Sobel filter height in pixels, expects odd number (counts center pixel)
//      threshold - Rising and falling edge threshold
//      widthThreshold - Used for width calculation, only pixels with an intensity greater than baseIntensity + widthThreshold are accepted.
//      minWidth - minimum spot width
//      maxWidth - maximum spot width
//      minSum - minimum spot sum
//      spotFormat - Choice of spot format: entry value, offset from entry to centroid, or offset from centroid to exit.
//      entryDebounceEnabled - If enabled, spot entry will be first one considered and no re-entry may occur. Otherwise, most recent spot entry will be used.
//      exitIntensityThreshold - Used for determining spot exit. Exit intensity must be less than or equal to baseIntensity + exitIntensityThreshold. Not used if set to 0.

kFsFx(kStatus) kSpot_SobelAccg(kImage image, k32u averageWindow, k32u edgeWindow, k32u threshold, k32u widthThreshold, k32u minWidth,
                                      k32u maxWidth, k32u minSum, kArrayList spots, kArrayList bounds, kImage edgeImage);

kFsFx(kStatus) kSpot_SobelAccgEx(kImage image, kArrayList spots, kArrayList bounds, kImage edgeImage, k32u averageWindow, k32u edgeWindow, k32u threshold, k32u widthThreshold, k32u minWidth,
    k32u maxWidth, k32u minSum, kAcgSpotFormat spotFormat, kBool entryDebounceEnabled, k32u exitIntensityThreshold);

kFsFx(kStatus) kSpot_YGradient(kImage input, k32u averageWindow, k32u edgeWindow, kImage output);
kFsFx(kStatus) kSpot_XGradient(kImage input, k32u averageWindow, k32u edgeWindow, kImage output);

kFsFx(k32u) kSpot_NoiseBackground(kImage image);

kFsFx(kStatus) kSpot_Sort(kArrayList spots, kArrayList sortedSpots, kSize sortedSpotCount, kCameraSpotSort sortType, kBool inverted);


// Constants used for moving average zero crossing integer math interpolation calculation
#define kSPOT_FPGA_2I_CENTRE_SHIFT              (kSPOT_CENTRE_SHIFT)  // Focalspec FPGA uses 9; we use 8 to match kSPOT
#define kSPOT_FPGA_2I_CENTRE_SCALE              (1 << kSPOT_FPGA_2I_CENTRE_SHIFT)
#define kSPOT_FPGA_2I_FRACTIONAL_SHIFT          (10)
#define kSPOT_FPGA_2I_FRACTIONAL_DISCARD_SHIFT  (kSPOT_FPGA_2I_FRACTIONAL_SHIFT - kSPOT_FPGA_2I_CENTRE_SHIFT)

#define kSPOT_FPGA_2I_SHIFT                     (4)
#define kSPOT_FPGA_2I_SCALE                     (1 << kSPOT_FPGA_2I_SHIFT)

// Constants used for moving average zero crossing filter calculation
#define kSPOT_FPGA_2I_MAX_FILTER_SIZE           (16)
#define kSPOT_FPGA_2I_FILTER_SHIFT              (kSPOT_FPGA_2I_MAX_FILTER_SIZE / 2)


struct kFpgaSpot2i
{
    k64u data; /* Data member holding spot information */
};

#define kSPOT_FPGA_2I_CENTRE_LSB     ((k64u) 0)
#define kSPOT_FPGA_2I_CENTRE_MSB     ((k64u) 21)

#define kSPOT_FPGA_2I_DETECTION_LSB  ((k64u) 24)
#define kSPOT_FPGA_2I_DETECTION_MSB  ((k64u) 35)
#define kSPOT_FPGA_2I_INTENSITY_LSB  ((k64u) 36)
#define kSPOT_FPGA_2I_INTENSITY_MSB  ((k64u) 47)

#define kSPOT_FPGA_2I_SLICE_LSB      ((k64u) 48)
#define kSPOT_FPGA_2I_SLICE_MSB      ((k64u) 61)

#define kSPOT_FPGA_2I_PATCH_LSB      ((k64u) 63)
#define kSPOT_FPGA_2I_PATCH_MSB      ((k64u) 63)

// Macro to get # of bits for a given field
#define kFpgaSpot2i_BitCount_(FIELD) (kSPOT_FPGA_2I_##FIELD##_MSB - kSPOT_FPGA_2I_##FIELD##_LSB + 1)

kInlineFx(void) kFpgaSpot2i_SetCentre(kFpgaSpot2i *spot, k64u const centre)
{
    kField_InsertNamedRange_(&spot->data, kSPOT_FPGA_2I_CENTRE, centre);
}

kInlineFx(void) kFpgaSpot2i_SetDetection(kFpgaSpot2i *spot, k64u const detection)
{
    kField_InsertNamedRange_(&spot->data, kSPOT_FPGA_2I_DETECTION, detection);
}

kInlineFx(void) kFpgaSpot2i_SetIntensity(kFpgaSpot2i *spot, k64u const intensity)
{
    kField_InsertNamedRange_(&spot->data, kSPOT_FPGA_2I_INTENSITY, intensity);
}

kInlineFx(void) kFpgaSpot2i_SetSlice(kFpgaSpot2i *spot, k64u const slice)
{
    kField_InsertNamedRange_(&spot->data, kSPOT_FPGA_2I_SLICE, slice);
}

kInlineFx(void) kFpgaSpot2i_SetPatch(kFpgaSpot2i *spot, kBool isPatch)
{
    kField_InsertNamedRange_(&spot->data, kSPOT_FPGA_2I_PATCH, (k64u) (isPatch == kTRUE));
}

kInlineFx(void) kFpgaSpot2i_Zero(kFpgaSpot2i *spot)
{
    spot->data = 0;
}

kInlineFx(k32u) kFpgaSpot2i_Centre(const kFpgaSpot2i *spot)
{
    return (k32u) kField_ExtractNamedRange_(spot->data, kSPOT_FPGA_2I_CENTRE);
}

kInlineFx(k16u) kFpgaSpot2i_Detection(kFpgaSpot2i const *spot)
{
    return (k16u)kField_ExtractNamedRange_(spot->data, kSPOT_FPGA_2I_DETECTION);
}

kInlineFx(k16u) kFpgaSpot2i_Intensity(kFpgaSpot2i const *spot)
{
    return (k16u)kField_ExtractNamedRange_(spot->data, kSPOT_FPGA_2I_INTENSITY);
}

kInlineFx(k16u) kFpgaSpot2i_Slice(kFpgaSpot2i const *spot)
{
    return (k16u)kField_ExtractNamedRange_(spot->data, kSPOT_FPGA_2I_SLICE);
}

kInlineFx(kBool) kFpgaSpot2i_Patch(kFpgaSpot2i const *spot)
{
    return (kBool)kField_ExtractNamedRange_(spot->data, kSPOT_FPGA_2I_PATCH);
}

kFsFx(kStatus) kFpgaSpot2i_ConvertFrom(kFpgaSpot2i *outSpots, kSpot const *inSpots, kSize count = 1);

kFsFx(kStatus) kFpgaSpot2i_ConvertTo(kFpgaSpot2i const *inSpots, kSpot *outSpots, kSize count = 1);

kFsFx(kStatus) kSpot_SobelvZc(kImage image, kArrayList spots,
    kSize edgeWindow, kSize averageWindow, kSize intensityWindow, k16u threshold,
    kImage edgeImage=kNULL, kImage averageImage=kNULL, kImage intensityImage=kNULL, kSize const *roi=kNULL);

kInlineFx(k32u) kSpot_InterpolateSobelvZcSpotCentre(
    kSize lastPositiveIndex, k16s lastPositiveGradient, kSize firstNegativeIndex, k16s firstNegativeGradient)
{
    // Convert inputs to k32u
    const k32u lastPositiveIndex32u = (k32u) lastPositiveIndex;
    const k32u firstNegativeIndex32u = (k32u) firstNegativeIndex;
    const k32u absPositiveGradient32u = (k32u) lastPositiveGradient;
    const k32u absNegativeGradient32u = (k32u) (-firstNegativeGradient);

    const k32u scaledPosition = firstNegativeIndex32u << kSPOT_FPGA_2I_CENTRE_SHIFT;

    // Note left shift by (CENTRE_SHIFT - 1) is effectively division by 2
    const k32u saturationOffset = firstNegativeIndex32u - lastPositiveIndex32u - 1;
    const k32u scaledSaturationOffset = saturationOffset << (kSPOT_FPGA_2I_CENTRE_SHIFT - 1);

    // Note that fractional value is computed with 10 bit precision and LSB is discarded
    const k32u deltaGrad = absPositiveGradient32u + absNegativeGradient32u;
    const k32u scaledNegativeGrad = absNegativeGradient32u << kSPOT_FPGA_2I_FRACTIONAL_SHIFT;
    const k32u scaledSubpixelShift = (scaledNegativeGrad / deltaGrad) >> kSPOT_FPGA_2I_FRACTIONAL_DISCARD_SHIFT;

    const k32u interpolatedCentre = scaledPosition - scaledSaturationOffset - scaledSubpixelShift;

    return interpolatedCentre;
}

#endif