/* @file  pmSource.h
 *
 * @author EAM, IfA; GLG, MHPCC
 *
 * @version $Revision: 1.25 $ $Name: not supported by cvs2svn $
 * @date $Date: 2008-10-06 13:05:13 $
 * Copyright 2004 Maui High Performance Computing Center, University of Hawaii
 */

# ifndef PM_SOURCE_H
# define PM_SOURCE_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;

typedef enum {
    PM_SOURCE_MODE_DEFAULT    = 0x0000, ///<
    PM_SOURCE_MODE_PSFMODEL   = 0x0001, ///< Source fitted with a psf model (linear or non-linear)
    PM_SOURCE_MODE_EXTMODEL   = 0x0002, ///< Source fitted with an extended-source model
    PM_SOURCE_MODE_FITTED     = 0x0004, ///< Source fitted with non-linear model (PSF or EXT; good or bad)
    PM_SOURCE_MODE_FAIL       = 0x0008, ///< Fit (non-linear) failed (non-converge, off-edge, run to zero)
    PM_SOURCE_MODE_POOR       = 0x0010, ///< Fit succeeds, but low-SN, high-Chisq, or large (for PSF -- drop?)
    PM_SOURCE_MODE_PAIR       = 0x0020, ///< Source fitted with a double psf
    PM_SOURCE_MODE_PSFSTAR    = 0x0040, ///< Source used to define PSF model
    PM_SOURCE_MODE_SATSTAR    = 0x0080, ///< Source model peak is above saturation
    PM_SOURCE_MODE_BLEND      = 0x0100, ///< Source is a blend with other sourcers
    PM_SOURCE_MODE_EXTERNAL   = 0x0200, ///< Source based on supplied input position
    PM_SOURCE_MODE_BADPSF     = 0x0400, ///< Failed to get good estimate of object's PSF
    PM_SOURCE_MODE_DEFECT     = 0x0800, ///< Source is thought to be a defect
    PM_SOURCE_MODE_SATURATED  = 0x1000, ///< Source is thought to be saturated pixels (bleed trail)
    PM_SOURCE_MODE_CR_LIMIT   = 0x2000, ///< Source has crNsigma above limit
    PM_SOURCE_MODE_EXT_LIMIT  = 0x4000, ///< Source has extNsigma above limit
    PM_SOURCE_MODE_SUBTRACTED = 0x8000, ///< XXX this flag is actually only used internally (move)
} pmSourceMode;

/** 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
    int seq;				///< ID for output (generated on write)
    pmPeak  *peak;                      ///< Description of peak pixel.
    psImage *pixels;                    ///< Rectangular region including object pixels.
    psImage *weight;                    ///< 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.
    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
    psMaskType 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, psMaskType maskVal);
bool pmSourceSub (pmSource *source, pmModelOpMode mode, psMaskType maskVal);
bool pmSourceAddWithOffset (pmSource *source, pmModelOpMode mode, psMaskType maskVal, int dx, int dy);
bool pmSourceSubWithOffset (pmSource *source, pmModelOpMode mode, psMaskType maskVal, int dx, int dy);

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

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

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

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