IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Apr 17, 2006, 8:01:05 AM (20 years ago)
Author:
magnier
Message:

updates relative to rel10_ifa_1

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/psModules/src/objects/pmObjects.h

    r5844 r6872  
    1010 *  @author GLG, MHPCC
    1111 *
    12  *  @version $Revision: 1.5 $ $Name: not supported by cvs2svn $
    13  *  @date $Date: 2005-12-24 01:24:32 $
     12 *  @version $Revision: 1.6 $ $Name: not supported by cvs2svn $
     13 *  @date $Date: 2006-04-17 18:01:05 $
    1414 *
    1515 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    2727#include <math.h>
    2828#include "pslib.h"
    29 #include "pmAstrometry.h"
    30 /**
    31  * In the object analysis process, we will use specific mask values to mark the
    32  * image pixels. The following structure defines the relevant mask values.
    33  *
    34  * XXX: This is probably a bad solution: we will want to set mask values
    35  * outside of the PSPHOT code.  Perhaps we can set up a registered set of mask
    36  * values with specific meanings that other functions can add to or define?
    37  */
    38 typedef enum {
    39     PSPHOT_MASK_CLEAR     = 0x00,
    40     PSPHOT_MASK_INVALID   = 0x01,
    41     PSPHOT_MASK_SATURATED = 0x02,
    42     PSPHOT_MASK_MARKED    = 0x08,
    43 } psphotMaskValues;
    44 
    45 
    46 /** pmPeakType
    47  *
    48  *  A peak pixel may have several features which may be determined when the
    49  *  peak is found or measured. These are specified by the pmPeakType enum.
    50  *  PM_PEAK_LONE represents a single pixel which is higher than its 8 immediate
    51  *  neighbors.  The PM_PEAK_EDGE represents a peak pixel which touching the image
    52  *  edge. The PM_PEAK_FLAT represents a peak pixel which has more than a specific
    53  *  number of neighbors at the same value, within some tolarence:
    54  *
    55  */
    56 typedef enum {
    57     PM_PEAK_LONE,                       ///< Isolated peak.
    58     PM_PEAK_EDGE,                       ///< Peak on edge.
    59     PM_PEAK_FLAT,                       ///< Peak has equal-value neighbors.
    60     PM_PEAK_UNDEF                       ///< Undefined.
    61 } pmPeakType;
    62 
    63 
    64 /** pmPeak data structure
    65  *
    66  *  A source has the capacity for several types of measurements. The
    67  *  simplest measurement of a source is the location and flux of the peak pixel
    68  *  associated with the source:
    69  *
    70  */
    71 typedef struct
    72 {
    73     int x;                              ///< X-coordinate of peak pixel.
    74     int y;                              ///< Y-coordinate of peak pixel.
    75     float counts;                       ///< Value of peak pixel (above sky?).
    76     pmPeakType class;                   ///< Description of peak.
    77 }
    78 pmPeak;
    79 
    80 
    81 /** pmMoments data structure
    82  *
    83  * One of the simplest measurements which can be made quickly for an object
    84  * are the object moments. We specify a structure to carry the moment information
    85  * for a specific source:
    86  *
    87  */
    88 typedef struct
    89 {
    90     float x;    ///< X-coord of centroid.
    91     float y;    ///< Y-coord of centroid.
    92     float Sx;    ///< x-second moment.
    93     float Sy;    ///< y-second moment.
    94     float Sxy;    ///< xy cross moment.
    95     float Sum;    ///< Pixel sum above sky (background).
    96     float Peak;    ///< Peak counts above sky.
    97     float Sky;    ///< Sky level (background).
    98     float SN;    ///< approx signal-to-noise
    99     int nPixels;   ///< Number of pixels used.
    100 }
    101 pmMoments;
    102 
    103 
    104 /** pmPSFClump data structure
    105  *
    106  * A collection of object moment measurements can be used to determine
    107  * approximate object classes. The key to this analysis is the location and
    108  * statistics (in the second-moment plane,
    109  *
    110  */
    111 typedef struct
    112 {
    113     float X;
    114     float dX;
    115     float Y;
    116     float dY;
    117 }
    118 pmPSFClump;
    119 
    120 // type of model carried by the pmModel structure
    121 typedef int pmModelType;
    122 
    123 typedef enum {
    124     PM_MODEL_UNTRIED,               ///< model fit not yet attempted
    125     PM_MODEL_SUCCESS,               ///< model fit succeeded
    126     PM_MODEL_NONCONVERGE,           ///< model fit did not converge
    127     PM_MODEL_OFFIMAGE,              ///< model fit drove out of range
    128     PM_MODEL_BADARGS                ///< model fit called with invalid args
    129 } pmModelStatus;
    130 
    131 /** pmModel data structure
    132  *
    133  * Every source may have two types of models: a PSF model and a FLT (floating)
    134  * model. The PSF model represents the best fit of the image PSF to the specific
    135  * object. In this case, the PSF-dependent parameters are specified for the
    136  * object by the PSF, not by the fit. The FLT model represents the best fit of
    137  * the given model to the object, with all parameters floating in the fit.
    138  *
    139  */
    140 typedef struct
    141 {
    142     pmModelType type;   ///< Model to be used.
    143     psVector *params;   ///< Paramater values.
    144     psVector *dparams;   ///< Parameter errors.
    145     float chisq;   ///< Fit chi-squared.
    146     int nDOF;    ///< number of degrees of freedom
    147     int nIter;    ///< number of iterations to reach min
    148     int status;         ///< fit status
    149     float radius;   ///< fit radius actually used
    150 }
    151 pmModel;
    152 
    153 /** pmSourceType enumeration
    154  *
    155  * A given source may be identified as most-likely to be one of several source
    156  * types. The pmSource entry pmSourceType defines the current best-guess for this
    157  * source.
    158  *
    159  * XXX: The values given below are currently illustrative and will require
    160  * some modification as the source classification code is developed. (TBD)
    161  *
    162  */
    163 typedef enum {
    164     PM_SOURCE_DEFECT,                   ///< a cosmic-ray
    165     PM_SOURCE_SATURATED,                ///< random saturated pixels
    166 
    167     PM_SOURCE_SATSTAR,                  ///< a saturated star
    168     PM_SOURCE_PSFSTAR,                  ///< a PSF star
    169     PM_SOURCE_GOODSTAR,                 ///< a good-quality star
    170 
    171     PM_SOURCE_POOR_FIT_PSF,             ///< poor quality PSF fit
    172     PM_SOURCE_FAIL_FIT_PSF,             ///< failed to get a good PSF fit
    173     PM_SOURCE_FAINTSTAR,                ///< below S/N cutoff
    174 
    175     PM_SOURCE_GALAXY,                   ///< an extended object (galaxy)
    176     PM_SOURCE_FAINT_GALAXY,             ///< a galaxy below S/N cutoff
    177     PM_SOURCE_DROP_GALAXY,              ///< ?
    178     PM_SOURCE_FAIL_FIT_GAL,             ///< failed on the galaxy fit
    179     PM_SOURCE_POOR_FIT_GAL,             ///< poor quality galaxy fit
    180 
    181     PM_SOURCE_OTHER,                    ///< unidentified
    182 } pmSourceType;
    183 
    184 /** pmSource data structure
    185  *
    186  *  This source has the capacity for several types of measurements. The
    187  *  simplest measurement of a source is the location and flux of the peak pixel
    188  *  associated with the source:
    189  *
    190  */
    191 typedef struct
    192 {
    193     pmPeak *peak;   ///< Description of peak pixel.
    194     psImage *pixels;   ///< Rectangular region including object pixels.
    195     psImage *weight;   ///< Image variance.
    196     psImage *mask;   ///< Mask which marks pixels associated with objects.
    197     pmMoments *moments;   ///< Basic moments measure for the object.
    198     pmModel *modelPSF;   ///< PSF Model fit (parameters and type)
    199     pmModel *modelFLT;   ///< FLT (floating) Model fit (parameters and type).
    200     pmSourceType type;   ///< Best identification of object.
    201     float apMag;
    202     float fitMag;
    203 }
    204 pmSource;
    205 
    206 
    207 /** pmPeakAlloc()
    208  *
    209  *  @return pmPeak*    newly allocated pmPeak with all internal pointers set to NULL
    210  */
    211 pmPeak *pmPeakAlloc(
    212     int x,    ///< Row-coordinate in image space
    213     int y,    ///< Col-coordinate in image space
    214     float counts,   ///< The value of the peak pixel
    215     pmPeakType class   ///< The type of peak pixel
    216 );
    217 
    218 
    219 /** pmMomentsAlloc()
    220  *
    221  */
    222 pmMoments *pmMomentsAlloc();
    223 
    224 
    225 /** pmModelAlloc()
    226  *
    227  */
    228 pmModel *pmModelAlloc(pmModelType type);
    229 
    230 
    231 /** pmSourceAlloc()
    232  *
    233  */
    234 pmSource  *pmSourceAlloc();
    235 
    236 
    237 /** pmFindVectorPeaks()
    238  *
    239  * Find all local peaks in the given vector above the given threshold. A peak
    240  * is defined as any element with a value greater than its two neighbors and with
    241  * a value above the threshold. Two types of special cases must be addressed.
    242  * Equal value elements: If an element has the same value as the following
    243  * element, it is not considered a peak. If an element has the same value as the
    244  * preceding element (but not the following), then it is considered a peak. Note
    245  * that this rule (arbitrarily) identifies flat regions by their trailing edge.
    246  * Edge cases: At start of the vector, the element must be higher than its
    247  * neighbor. At the end of the vector, the element must be higher or equal to its
    248  * neighbor. These two rules again places the peak associated with a flat region
    249  * which touches the image edge at the image edge. The result of this function is
    250  * a vector containing the coordinates (element number) of the detected peaks
    251  * (type psU32).
    252  *
    253  */
    254 psVector *pmFindVectorPeaks(
    255     const psVector *vector,  ///< The input vector (float)
    256     float threshold   ///< Threshold above which to find a peak
    257 );
    258 
    259 
    260 /** pmFindImagePeaks()
    261  *
    262  * Find all local peaks in the given image above the given threshold. This
    263  * function should find all row peaks using pmFindVectorPeaks, then test each row
    264  * peak and exclude peaks which are not local peaks. A peak is a local peak if it
    265  * has a higher value than all 8 neighbors. If the peak has the same value as its
    266  * +y neighbor or +x neighbor, it is NOT a local peak. If any other neighbors
    267  * have an equal value, the peak is considered a valid peak. Note two points:
    268  * first, the +x neighbor condition is already enforced by pmFindVectorPeaks.
    269  * Second, these rules have the effect of making flat-topped regions have single
    270  * peaks at the (+x,+y) corner. When selecting the peaks, their type must also be
    271  * set. The result of this function is an array of pmPeak entries.
    272  *
    273  */
    274 psArray *pmFindImagePeaks(
    275     const psImage *image,  ///< The input image where peaks will be found (float)
    276     float threshold   ///< Threshold above which to find a peak
    277 );
    278 
    279 
    280 /** pmCullPeaks()
    281  *
    282  * Eliminate peaks from the psList that have a peak value above the given
    283  * maximum, or fall outside the valid region.
    284  *
    285  */
    286 psList *pmCullPeaks(
    287     psList *peaks,   ///< The psList of peaks to be culled
    288     float maxValue,   ///< Cull peaks above this value
    289     const psRegion valid                ///< Cull peaks otside this psRegion
    290 );
    291 
    292 
    293 /** pmPeaksSubset()
    294  *
    295  * Create a new peaks array, removing certain types of peaks from the input
    296  * array of peaks based on the given criteria. Peaks should be eliminated if they
    297  * have a peak value above the given maximum value limit or if the fall outside
    298  * the valid region.  The result of the function is a new array with a reduced
    299  * number of peaks.
    300  *
    301  */
    302 psArray *pmPeaksSubset(
    303     psArray *peaks,                     ///< Add comment.
    304     float maxvalue,                     ///< Add comment.
    305     const psRegion valid                ///< Add comment.
    306 );
    307 
    308 
    309 /** pmSourceDefinePixels()
    310  *
    311  * Define psImage subarrays for the source located at coordinates x,y on the
    312  * image set defined by readout. The pixels defined by this operation consist of
    313  * a square window (of full width 2Radius+1) centered on the pixel which contains
    314  * the given coordinate, in the frame of the readout. The window is defined to
    315  * have limits which are valid within the boundary of the readout image, thus if
    316  * the radius would fall outside the image pixels, the subimage is truncated to
    317  * only consist of valid pixels. If readout->mask or readout->weight are not
    318  * NULL, matching subimages are defined for those images as well. This function
    319  * fails if no valid pixels can be defined (x or y less than Radius, for
    320  * example). This function should be used to define a region of interest around a
    321  * source, including both source and sky pixels.
    322  *
    323  * XXX: must code this.
    324  *
    325  */
    326 // XXX: Uncommenting the pmReadout causes compile errors.
    327 bool pmSourceDefinePixels(
    328     pmSource *mySource,                 ///< Add comment.
    329     pmReadout *readout,                 ///< Add comment.
    330     psF32 x,                            ///< Add comment.
    331     psF32 y,                            ///< Add comment.
    332     psF32 Radius                        ///< Add comment.
    333 );
    334 
    335 
    336 /** pmSourceLocalSky()
    337  *
    338  * Measure the local sky in the vicinity of the given source. The Radius
    339  * defines the square aperture in which the moments will be measured. This
    340  * function assumes the source pixels have been defined, and that the value of
    341  * Radius here is smaller than the value of Radius used to define the pixels. The
    342  * annular region not contained within the radius defined here is used to measure
    343  * the local background in the vicinity of the source. The local background
    344  * measurement uses the specified statistic passed in via the statsOptions entry.
    345  * This function allocates the pmMoments structure. The resulting sky is used to
    346  * set the value of the pmMoments.sky element of the provided pmSource structure.
    347  *
    348  */
    349 bool pmSourceLocalSky(
    350     pmSource *source,   ///< The input image (float)
    351     psStatsOptions statsOptions, ///< The statistic used in calculating the background sky
    352     float Radius   ///< The inner radius of the square annulus to exclude
    353 );
    354 
    355 
    356 /** pmSourceMoments()
    357  *
    358  * Measure source moments for the given source, using the value of
    359  * source.moments.sky provided as the local background value and the peak
    360  * coordinates as the initial source location. The resulting moment values are
    361  * applied to the source.moments entry, and the source is returned. The moments
    362  * are measured within the given circular radius of the source.peak coordinates.
    363  * The return value indicates the success (TRUE) of the operation.
    364  *
    365  */
    366 bool pmSourceMoments(
    367     pmSource *source,   ///< The input pmSource for which moments will be computed
    368     float radius   ///< Use a circle of pixels around the peak
    369 );
    370 
    371 
    372 /** pmSourcePSFClump()
    373  *
    374  * We use the source moments to make an initial, approximate source
    375  * classification, and as part of the information needed to build a PSF model for
    376  * the image. As long as the PSF shape does not vary excessively across the
    377  * image, the sources which are represented by a PSF (the start) will have very
    378  * similar second moments. The function pmSourcePSFClump searches a collection of
    379  * sources with measured moments for a group with moments which are all very
    380  * similar. The function returns a pmPSFClump structure, representing the
    381  * centroid and size of the clump in the sigma_x, sigma_y second-moment plane.
    382  *
    383  * The goal is to identify and characterize the stellar clump within the
    384  * sigma_x, sigma_y second-moment plane.  To do this, an image is constructed to
    385  * represent this plane.  The units of sigma_x and sigma_y are in image pixels. A
    386  * pixel in this analysis image represents 0.1 pixels in the input image. The
    387  * dimensions of the image need only be 10 pixels. The peak pixel in this image
    388  * (above a threshold of half of the image maximum) is found. The coordinates of
    389  * this peak pixel represent the 2D mode of the sigma_x, sigma_y distribution.
    390  * The sources with sigma_x, sigma_y within 0.2 pixels of this value are then
    391  *  * used to calculate the median and standard deviation of the sigma_x, sigma_y
    392  * values. These resulting values are returned via the pmPSFClump structure.
    393  *
    394  * The return value indicates the success (TRUE) of the operation.
    395  *
    396  * XXX: Limit the S/N of the candidate sources (part of Metadata)? (TBD).
    397  * XXX: Save the clump parameters on the Metadata (TBD)
    398  *
    399  */
    400 pmPSFClump pmSourcePSFClump(
    401     psArray *source,   ///< The input pmSource
    402     psMetadata *metadata  ///< Contains classification parameters
    403 );
    404 
    405 
    406 /** pmSourceRoughClass()
    407  *
    408  * Based on the specified data values, make a guess at the source
    409  * classification. The sources are provides as a psArray of pmSource entries.
    410  * Definable parameters needed to make the classification are provided to the
    411  * routine with the psMetadata structure. The rules (in SDRS) refer to values which
    412  * can be extracted from the metadata using the given keywords. Except as noted,
    413  * the data type for these parameters are psF32.
    414  *
    415  */
    416 bool pmSourceRoughClass(
    417     psArray *source,   ///< The input pmSource
    418     psMetadata *metadata,  ///< Contains classification parameters
    419     pmPSFClump clump   ///< Statistics about the PSF clump
    420 );
    421 
    422 
    423 /** pmSourceModelGuess()
    424  *
    425  * Convert available data to an initial guess for the given model. This
    426  * function allocates a pmModel entry for the pmSource structure based on the
    427  * provided model selection. The method of defining the model parameter guesses
    428  * are specified for each model below. The guess values are placed in the model
    429  * parameters. The function returns TRUE on success or FALSE on failure.
    430  *
    431  */
    432 pmModel *pmSourceModelGuess(
    433     pmSource *source,   ///< The input pmSource
    434     pmModelType model   ///< The type of model to be created.
    435 );
    436 
    437 
    438 /** pmContourType
    439  *
    440  * Only one type is defined at present.
    441  *
    442  */
    443 typedef enum {
    444     PS_CONTOUR_CRUDE,
    445     PS_CONTOUR_UNKNOWN01,
    446     PS_CONTOUR_UNKNOWN02
    447 } pmContourType;
    448 
    449 
    450 /** pmSourceContour()
    451  *
    452  * Find points in a contour for the given source at the given level. If type
    453  * is PM_CONTOUR_CRUDE, the contour is found by starting at the source peak,
    454  * running along each pixel row until the level is crossed, then interpolating to
    455  * the level coordinate for that row. This is done for each row, with the
    456  * starting point determined by the midpoint of the previous row, until the
    457  * starting point has a value below the contour level. The returned contour
    458  * consists of two vectors giving the x and y coordinates of the contour levels.
    459  * This function may be used as part of the model guess inputs.  Other contour
    460  * types may be specified in the future for more refined contours (TBD)
    461  *
    462  */
    463 psArray *pmSourceContour(
    464     pmSource *source,   ///< The input pmSource
    465     const psImage *image,  ///< The input image (float) (this arg should be removed)
    466     float level,   ///< The level of the contour
    467     pmContourType mode   ///< Currently this must be PS_CONTOUR_CRUDE
    468 );
    469 
    470 
    471 /** pmSourceFitModel()
    472  *
    473  * Fit the requested model to the specified source. The starting guess for the
    474  * model is given by the input source.model parameter values. The pixels of
    475  * interest are specified by the source.pixelsand source.maskentries. This
    476  * function calls psMinimizeLMChi2() on the image data. The function returns TRUE
    477  * on success or FALSE on failure.
    478  *
    479  */
    480 bool pmSourceFitModel(
    481     pmSource *source,   ///< The input pmSource
    482     pmModel *model,   ///< model to be fitted
    483     const bool PSF   ///< Treat model as PSF or FLT?
    484 );
    485 
    486 
    487 /** pmModelFitStatus()
    488  *
    489  * This function wraps the call to the model-specific function returned by
    490  * pmModelFitStatusFunc_GetFunction.  The model-specific function examines the
    491  * model parameters, parameter errors, Chisq, S/N, and other parameters available
    492  * from model to decide if the particular fit was successful or not.
    493  *
    494  * XXX: Must code this.
    495  *
    496  */
    497 bool pmModelFitStatus(
    498     pmModel *model                      ///< Add comment.
    499 );
    500 
    501 
    502 /** pmSourceAddModel()
    503  *
    504  * Add the given source model flux to/from the provided image. The boolean
    505  * option center selects if the source is re-centered to the image center or if
    506  * it is placed at its centroid location. The boolean option sky selects if the
    507  * background sky is applied (TRUE) or not. The pixel range in the target image
    508  * is at most the pixel range specified by the source.pixels image. The success
    509  * status is returned.
    510  *
    511  */
    512 bool pmSourceAddModel(
    513     psImage *image,   ///< The output image (float)
    514     psImage *mask,   ///< The image pixel mask (valid == 0)
    515     pmModel *model,   ///< The input pmModel
    516     bool center,    ///< A boolean flag that determines whether pixels are centered
    517     bool sky        ///< A boolean flag that determines if the sky is subtracted
    518 );
    519 
    520 
    521 /** pmSourceSubModel()
    522  *
    523  * Subtract the given source model flux to/from the provided image. The
    524  * boolean option center selects if the source is re-centered to the image center
    525  * or if it is placed at its centroid location. The boolean option sky selects if
    526  * the background sky is applied (TRUE) or not. The pixel range in the target
    527  * image is at most the pixel range specified by the source.pixels image. The
    528  * success status is returned.
    529  *
    530  */
    531 bool pmSourceSubModel(
    532     psImage *image,   ///< The output image (float)
    533     psImage *mask,   ///< The image pixel mask (valid == 0)
    534     pmModel *model,   ///< The input pmModel
    535     bool center,    ///< A boolean flag that determines whether pixels are centered
    536     bool sky        ///< A boolean flag that determines if the sky is subtracted
    537 );
    538 
    539 
    540 /**
    541  *
    542  * The function returns both the magnitude of the fit, defined as -2.5log(flux),
    543  * where the flux is integrated under the model, theoretically from a radius of 0
    544  * to infinity. In practice, we integrate the model beyond 50sigma.  The aperture magnitude is
    545  * defined as -2.5log(flux) , where the flux is summed for all pixels which are
    546  * not excluded by the aperture mask. The model flux is calculated by calling the
    547  * model-specific function provided by pmModelFlux_GetFunction.
    548  *
    549  * XXX: must code this.
    550  *
    551  */
    552 bool pmSourcePhotometry(
    553     float *fitMag,                      ///< integrated fit magnitude
    554     float *obsMag,   ///< aperture flux magnitude
    555     pmModel *model,                     ///< model used for photometry
    556     psImage *image,                     ///< image pixels to be used
    557     psImage *mask                       ///< mask of pixels to ignore
    558 );
    559 
    56029
    56130/**
    … …  
    56332 * This function converts the source classification into the closest available
    56433 * approximation to the Dophot classification scheme:
     34 * XXX EAM : fix this to use current source classification scheme
    56535 *
    56636 * PM_SOURCE_DEFECT: 8
    … …  
    59868);
    59969
    600 /** pmSourceFitModel_v5()
    601  *
    602  * Fit the requested model to the specified source. The starting guess for the
    603  * model is given by the input source.model parameter values. The pixels of
    604  * interest are specified by the source.pixelsand source.maskentries. This
    605  * function calls psMinimizeLMChi2() on the image data. The function returns TRUE
    606  * on success or FALSE on failure.
    607  *
    608  */
    609 bool pmSourceFitModel_v5(
    610     pmSource *source,   ///< The input pmSource
    611     pmModel *model,   ///< model to be fitted
    612     const bool PSF   ///< Treat model as PSF or FLT?
    613 );
    614 
    615 
    616 /** pmSourceFitModel_v7()
    617  *
    618  * Fit the requested model to the specified source. The starting guess for the
    619  * model is given by the input source.model parameter values. The pixels of
    620  * interest are specified by the source.pixelsand source.maskentries. This
    621  * function calls psMinimizeLMChi2() on the image data. The function returns TRUE
    622  * on success or FALSE on failure.
    623  *
    624  */
    625 bool pmSourceFitModel_v7(
    626     pmSource *source,   ///< The input pmSource
    627     pmModel *model,   ///< model to be fitted
    628     const bool PSF   ///< Treat model as PSF or FLT?
    629 );
    630 
    631 
    632 /** pmSourcePhotometry()
    633  *
    634  * XXX: Need descriptions
    635  *
    636  */
    637 bool pmSourcePhotometry(
    638     float *fitMag,
    639     float *obsMag,
    640     pmModel *model,
    641     psImage *image,
    642     psImage *mask
    643 );
    644 
    645 /** pmModelEval()
    646  *
    647  *  XXX: Need descriptions
    648  *
    649  */
    650 psF32 pmModelEval(
    651     pmModel *model,
    652     psImage *image,
    653     psS32 col,
    654     psS32 row
    655 );
    65670
    65771#endif
Note: See TracChangeset for help on using the changeset viewer.