/* @file  pmSource.h
 *
 * @author EAM, IfA; GLG, MHPCC
 *
 * @version $Revision: 1.28.4.1 $ $Name: not supported by cvs2svn $
 * @date $Date: 2009-02-19 17:59:50 $
 * Copyright 2004 Maui High Performance Computing Center, University of Hawaii
 */

# ifndef PM_SOURCE_H
# define PM_SOURCE_H

#include <pslib.h>
#include "pmPeaks.h"
#include "pmModel.h"
#include "pmMoments.h"
#include "pmSourceExtendedPars.h"

/// @addtogroup Objects Object Detection / Analysis Functions
/// @{

/** pmSourceType enumeration
 *
 * A given source may be identified as most-likely to be one of several source
 * types. The pmSource entry pmSourceType defines the current best-guess for this
 * source.
 *
 */
typedef enum {
    PM_SOURCE_TYPE_UNKNOWN,             ///< not yet classified
    PM_SOURCE_TYPE_DEFECT,              ///< a cosmic-ray
    PM_SOURCE_TYPE_SATURATED,           ///< random saturated pixels (eg, bleed trails)
    PM_SOURCE_TYPE_STAR,                ///< a good-quality star (subtracted model is PSF)
    PM_SOURCE_TYPE_EXTENDED,            ///< an extended object (eg, galaxy) (subtracted model is EXT)
} pmSourceType;

// bit flags to distinguish analysis results
typedef enum {
    PM_SOURCE_MODE_DEFAULT          = 0x00000000, ///< Initial value: resets all bits
    PM_SOURCE_MODE_PSFMODEL         = 0x00000001, ///< Source fitted with a psf model (linear or non-linear)
    PM_SOURCE_MODE_EXTMODEL         = 0x00000002, ///< Source fitted with an extended-source model
    PM_SOURCE_MODE_FITTED           = 0x00000004, ///< Source fitted with non-linear model (PSF or EXT; good or bad)
    PM_SOURCE_MODE_FAIL             = 0x00000008, ///< Fit (non-linear) failed (non-converge, off-edge, run to zero)
    PM_SOURCE_MODE_POOR             = 0x00000010, ///< Fit succeeds, but low-SN, high-Chisq, or large (for PSF -- drop?)
    PM_SOURCE_MODE_PAIR             = 0x00000020, ///< Source fitted with a double psf
    PM_SOURCE_MODE_PSFSTAR          = 0x00000040, ///< Source used to define PSF model
    PM_SOURCE_MODE_SATSTAR          = 0x00000080, ///< Source model peak is above saturation
    PM_SOURCE_MODE_BLEND            = 0x00000100, ///< Source is a blend with other sourcers
    PM_SOURCE_MODE_EXTERNAL         = 0x00000200, ///< Source based on supplied input position
    PM_SOURCE_MODE_BADPSF           = 0x00000400, ///< Failed to get good estimate of object's PSF
    PM_SOURCE_MODE_DEFECT           = 0x00000800, ///< Source is thought to be a defect
    PM_SOURCE_MODE_SATURATED        = 0x00001000, ///< Source is thought to be saturated pixels (bleed trail)
    PM_SOURCE_MODE_CR_LIMIT         = 0x00002000, ///< Source has crNsigma above limit
    PM_SOURCE_MODE_EXT_LIMIT        = 0x00004000, ///< Source has extNsigma above limit
    PM_SOURCE_MODE_MOMENTS_FAILURE  = 0x00008000, ///< could not measure the moments
    PM_SOURCE_MODE_SKY_FAILURE      = 0x00010000, ///< could not measure the local sky
    PM_SOURCE_MODE_SKYVAR_FAILURE   = 0x00020000, ///< could not measure the local sky variance
    PM_SOURCE_MODE_BELOW_MOMENTS_SN = 0x00040000, ///< moments not measured due to low S/N
    PM_SOURCE_MODE_BIG_RADIUS       = 0x00100000, ///< poor moments for small radius, try large radius
    PM_SOURCE_MODE_AP_MAGS          = 0x00200000, ///< source has an aperture magnitude
    PM_SOURCE_MODE_BLEND_FIT        = 0x00400000, ///< source was fitted as a blend
    PM_SOURCE_MODE_EXTENDED_FIT     = 0x00800000, ///< full extended fit was used
    PM_SOURCE_MODE_EXTENDED_STATS   = 0x01000000, ///< extended aperture stats calculated
    PM_SOURCE_MODE_LINEAR_FIT       = 0x02000000, ///< source fitted with the linear fit
    PM_SOURCE_MODE_NONLINEAR_FIT    = 0x04000000, ///< source fitted with the non-linear fit
    PM_SOURCE_MODE_RADIAL_FLUX      = 0x08000000, ///< radial flux measurements calculated
    PM_SOURCE_MODE_SIZE_SKIPPED     = 0x10000000, ///< size could not be determined
} pmSourceMode;

typedef enum {
    PM_SOURCE_TMPF_MODEL_GUESS = 0x0001,
    PM_SOURCE_TMPF_SUBTRACTED  = 0x0002,
} pmSourceTmpF;

/** pmSource data structure
 *
 *  This source has the capacity for several types of measurements. The
 *  simplest measurement of a source is the location and flux of the peak pixel
 *  associated with the source:
 *
 *  XXX do I have to re-organize this (again!) to allow an arbitrary set of extended model fits??
 *  XXX put the Mag and Err inside the pmModel?
 *  XXX keep the modelEXT or add to the psArray
 *
 *
 */
struct pmSource {
    const int id;                       ///< Unique ID for object (generated on alloc)
    int seq;                            ///< ID for output (generated on write OR set on read)
    pmPeak  *peak;                      ///< Description of peak pixel.
    psImage *pixels;                    ///< Rectangular region including object pixels.
    psImage *variance;                    ///< Image variance.
    psImage *maskObj;                   ///< unique mask for this object which marks included pixels associated with objects.
    psImage *maskView;                  ///< view into global image mask for this object region
    psImage *modelFlux;                 ///< cached copy of the best model for this source
    psImage *psfFlux;                   ///< cached copy of the psf model for this source
    pmMoments *moments;                 ///< Basic moments measured for the object.
    pmModel *modelPSF;                  ///< PSF Model fit (parameters and type)
    pmModel *modelEXT;                  ///< EXT Model fit used for subtraction (parameters and type)
    psArray *modelFits;                 ///< collection of extended source models (best == modelEXT)
    pmSourceType type;                  ///< Best identification of object.
    pmSourceMode mode;                  ///< analysis flags set for object.
    pmSourceTmpF tmpFlags;              ///< internal-only flags
    psArray *blends;                    ///< collection of sources thought to be confused with object
    float psfMag;                       ///< calculated from flux in modelPSF
    float extMag;                       ///< calculated from flux in modelEXT
    float errMag;                       ///< error in psfMag OR extMag (depending on type)
    float apMag;                        ///< apMag corresponding to psfMag or extMag (depending on type)
    float pixWeight;                    ///< model-weighted coverage of valid pixels
    float psfChisq;                     ///< probability of PSF
    float crNsigma;                     ///< Nsigma deviation from PSF to CR
    float extNsigma;                    ///< Nsigma deviation from PSF to EXT
    float sky, skyErr;                  ///< The sky and its error at the center of the object
    psRegion region;                    ///< area on image covered by selected pixels
    pmSourceExtendedPars *extpars;      ///< extended source parameters
};

/** pmPSFClump data structure
 *
 * A collection of object moment measurements can be used to determine
 * approximate object classes. The key to this analysis is the location and
 * statistics (in the second-moment plane,
 *
 */
typedef struct
{
    float X;
    float dX;
    float Y;
    float dY;
}
pmPSFClump;


/** pmSourceAlloc()
 *
 */
pmSource  *pmSourceAlloc();

/** pmSourceCopy()
 *
 */

bool psMemCheckSource(psPtr ptr);

pmSource  *pmSourceCopy(pmSource *source);

// free just the pixels for a source, keeping derived data
void pmSourceFreePixels(pmSource *source);

/** pmSourceDefinePixels()
 *
 * Define psImage subarrays for the source located at coordinates x,y on the
 * image set defined by readout. The pixels defined by this operation consist of
 * a square window (of full width 2Radius+1) centered on the pixel which contains
 * the given coordinate, in the frame of the readout. The window is defined to
 * have limits which are valid within the boundary of the readout image, thus if
 * the radius would fall outside the image pixels, the subimage is truncated to
 * only consist of valid pixels. If readout->mask or readout->weight are not
 * NULL, matching subimages are defined for those images as well. This function
 * fails if no valid pixels can be defined (x or y less than Radius, for
 * example). This function should be used to define a region of interest around a
 * source, including both source and sky pixels.
 *
 */
bool pmSourceDefinePixels(
    pmSource *mySource,                 ///< source to be re-defined
    const pmReadout *readout,  ///< base the source on this readout
    psF32 x,                            ///< center coords of source
    psF32 y,                            ///< center coords of source
    psF32 Radius                        ///< size of box on source
);

bool pmSourceRedefinePixels (
    pmSource *mySource,   ///< source to be re-defined
    const pmReadout *readout,   ///< base the source on this readout
    psF32 x,     ///< center coords of source
    psF32 y,      ///< center coords of source
    psF32 Radius   ///< size of box on source
);

/** pmSourcePSFClump()
 *
 * We use the source moments to make an initial, approximate source
 * classification, and as part of the information needed to build a PSF model for
 * the image. As long as the PSF shape does not vary excessively across the
 * image, the sources which are represented by a PSF (the start) will have very
 * similar second moments. The function pmSourcePSFClump searches a collection of
 * sources with measured moments for a group with moments which are all very
 * similar. The function returns a pmPSFClump structure, representing the
 * centroid and size of the clump in the sigma_x, sigma_y second-moment plane.
 *
 * The goal is to identify and characterize the stellar clump within the
 * sigma_x, sigma_y second-moment plane.  To do this, an image is constructed to
 * represent this plane.  The units of sigma_x and sigma_y are in image pixels. A
 * pixel in this analysis image represents 0.1 pixels in the input image. The
 * dimensions of the image need only be 10 pixels. The peak pixel in this image
 * (above a threshold of half of the image maximum) is found. The coordinates of
 * this peak pixel represent the 2D mode of the sigma_x, sigma_y distribution.
 * The sources with sigma_x, sigma_y within 0.2 pixels of this value are then
 *  * used to calculate the median and standard deviation of the sigma_x, sigma_y
 * values. These resulting values are returned via the pmPSFClump structure.
 *
 * The return value indicates the success (TRUE) of the operation.
 *
 * XXX: Limit the S/N of the candidate sources (part of Metadata)? (TBD).
 * XXX: Save the clump parameters on the Metadata (TBD)
 *
 */
pmPSFClump pmSourcePSFClump(
    psRegion *region,                   ///< restrict measurement to specified region
    psArray *source,                    ///< The input pmSource
    psMetadata *metadata                ///< Contains classification parameters
);

/** pmSourceRoughClass()
 *
 * Based on the specified data values, make a guess at the source
 * classification. The sources are provides as a psArray of pmSource entries.
 * Definable parameters needed to make the classification are provided to the
 * routine with the psMetadata structure. The rules (in SDRS) refer to values which
 * can be extracted from the metadata using the given keywords. Except as noted,
 * the data type for these parameters are psF32.
 *
 */
bool pmSourceRoughClass(
    psRegion *region,                   ///< restrict measurement to specified region
    psArray *sources,                    ///< The input pmSources
    psMetadata *metadata,               ///< Contains classification parameters
    pmPSFClump clump,                   ///< Statistics about the PSF clump
    psImageMaskType maskSat             ///< Mask value for saturated pixels
);


/** pmSourceMoments()
 *
 * Measure source moments for the given source, using the value of
 * source.moments.sky provided as the local background value and the peak
 * coordinates as the initial source location. The resulting moment values are
 * applied to the source.moments entry, and the source is returned. The moments
 * are measured within the given circular radius of the source.peak coordinates.
 * The return value indicates the success (TRUE) of the operation.
 *
 */
bool pmSourceMoments(
    pmSource *source,   ///< The input pmSource for which moments will be computed
    float radius   ///< Use a circle of pixels around the peak
);

pmModel *pmSourceGetModel (bool *isPSF, const pmSource *source);

bool pmSourceAdd (pmSource *source, pmModelOpMode mode, psImageMaskType maskVal);
bool pmSourceSub (pmSource *source, pmModelOpMode mode, psImageMaskType maskVal);
bool pmSourceAddWithOffset (pmSource *source, pmModelOpMode mode, psImageMaskType maskVal, int dx, int dy);
bool pmSourceSubWithOffset (pmSource *source, pmModelOpMode mode, psImageMaskType maskVal, int dx, int dy);

bool pmSourceOp (pmSource *source, pmModelOpMode mode, bool add, psImageMaskType maskVal, int dx, int dy);
bool pmSourceCacheModel (pmSource *source, psImageMaskType maskVal);
bool pmSourceCachePSF (pmSource *source, psImageMaskType maskVal);

int  pmSourceSortBySN (const void **a, const void **b);
int  pmSourceSortByY (const void **a, const void **b);
int  pmSourceSortBySeq (const void **a, const void **b);

pmSourceMode pmSourceModeFromString (const char *name);
char *pmSourceModeToString (const pmSourceMode mode);

/// @}
# endif /* PM_SOURCE_H */
