IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 4041


Ignore:
Timestamp:
May 27, 2005, 11:27:13 AM (21 years ago)
Author:
jhoblitt
Message:

convert verbatim environments that contain function prototypes & datatypes to be either a prototype or a datatype environment

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/doc/modules/ModulesSDRS.tex

    r3975 r4041  
    1 %%% $Id: ModulesSDRS.tex,v 1.41 2005-05-19 02:58:14 price Exp $
     1%%% $Id: ModulesSDRS.tex,v 1.42 2005-05-27 21:27:13 jhoblitt Exp $
    22\documentclass[panstarrs]{panstarrs}
    33
    … …  
    100100standard locations, with optional command-line override values.
    101101
    102 \begin{verbatim}
     102\begin{prototype}
    103103bool pmConfigLoadSite   (psMetadata **site, int *argc, char **argv);
    104104bool pmConfigLoadCamera (psMetadata **camera, psMetadata *site, psMetadata *header, int *argc, char **argv);
    105105bool pmConfigLoadRecipe (psMetadata **recipe, psMetadata *camera, int *argc, char **argv, char *script);
    106 \end{verbatim}
     106\end{prototype}
    107107
    108108\code{pmConfigLoadSite} loads basic configuration information from a
    … …  
    198198before being returned as a \code{psRegion} pointer.
    199199
    200 \begin{verbatim}
     200\begin{prototype}
    201201psSTR     pmConfigLookupSTR    (psMetadata *config, psMetadata *header, char *name);
    202202psS32     pmConfigLookupS32    (psMetadata *config, psMetadata *header, char *name);
    203203psF64     pmConfigLookupF64    (psMetadata *config, psMetadata *header, char *name);
    204204psRegion *pmConfigLookupRegion (psMetadata *config, psMetadata *header, char *name);
    205 \end{verbatim}
     205\end{prototype}
    206206
    207207\section{Camera Data Organization \& Camera Geometry}
    … …  
    291291\subsection{Determine the Camera from the Primary Header}
    292292
    293 \begin{verbatim}
     293\begin{prototype}
    294294char *pmCameraFromHeader (psFitsHeader *header, psMetadata *rules);
    295 \end{verbatim}
     295\end{prototype}
    296296
    297297This function examines a primary header unit (\code{header}) and
    … …  
    340340\subsection{Validate the Header set \& Construct the FPA}
    341341
    342 \begin{verbatim}
     342\begin{prototype}
    343343bool  pmCameraValidateHeaders (psMetadata *headers, psMetadata *camera);
    344344psFPA *pmFPAfromHeader (psMetadata *headers, psMetadata *camera);
    345 \end{verbatim}
     345\end{prototype}
    346346
    347347These funtions examine the collection of \code{headers} and compare
    … …  
    505505offset and/or astrometry parameters.
    506506
    507 \begin{verbatim}
     507\begin{prototype}
    508508bool  pmFPADefineOffsets (psFPA fpa);
    509509bool  pmFPADefineWCS (psFPA fpa);
    510510bool  pmFPADefineWCSfromOffsets (psFPA fpa);
    511 \end{verbatim}
     511\end{prototype}
    512512
    513513The first function takes a \code{psFPA} structure which has been
    … …  
    569569boundaries of the cells within chip-based images.
    570570
    571 \begin{verbatim}
     571\begin{prototype}
    572572psReadout *pmReadoutLoad (psReadout *input, psFits *f, psCell *cell, int plane);
    573 \end{verbatim}
     573\end{prototype}
    574574
    575575\section{Phase 2}
    … …  
    608608\code{pmSubtractBias} shall subtract the bias from the image.
    609609The API shall be the following:
    610 \begin{verbatim}
     610\begin{prototype}
    611611psReadout *pmSubtractBias(psReadout *in, void *fitSpec, const psList *overscans,
    612612                          pmOverscanAxis overscanAxis, const psStats *stat,
    613613                          int nBin, pmFit fit, const psReadout *bias);
    614 \end{verbatim}
     614\end{prototype}
    615615
    616616Two types of bias correction may optionally be performed on the input
    … …  
    638638The \code{overscanAxis} specifies how the prescan/overscan subtraction
    639639is to be performed.  It is an enumerated type:
    640 \begin{verbatim}
     640\begin{datatype}
    641641/** Overscan axis */
    642642typedef enum {
    … …  
    646646    PM_OVERSCAN_ALL                     ///< Subtract the statistic of all pixels in overscan region
    647647} pmOverscanAxis;
    648 \end{verbatim}
     648\end{datatype}
    649649
    650650If the \code{overscanAxis} is \code{PM_OVERSCAN_NONE}, then the
    … …  
    681681
    682682\code{fit} is an enumerated type:
    683 \begin{verbatim}
     683\begin{datatype}
    684684/** Fit types */
    685685typedef enum {
    … …  
    688688    PM_FIT_SPLINE                       ///< Fit cubic splines
    689689} pmFit;
    690 \end{verbatim}
     690\end{datatype}
    691691
    692692If \code{fitSpec} is \code{NULL}, or \code{fit} is \code{PM_FIT_NONE},
    … …  
    738738\code{coeff}, acting on the flux.  The API shall be the following:
    739739
    740 \begin{verbatim}
     740\begin{prototype}
    741741psReadout *pmNonLinearityPolynomial(psReadout *in, const psPolynomial1D *coeff);
    742 \end{verbatim}
     742\end{prototype}
    743743
    744744The polynomial coefficients, \code{coeff}, will be supplied by the
    … …  
    749749shall be the following:
    750750
    751 \begin{verbatim}
     751\begin{prototype}
    752752psReadout *pmNonLinearityLookup(psReadout *in, const psVector *inFlux, const psVector *outFlux);
    753 \end{verbatim}
     753\end{prototype}
    754754
    755755For each pixel in the input image, the function shall find the flux
    … …  
    785785divide the input image by the flat-field image and return it in place,
    786786updating the mask as appropriate.  The API shall be the following:
    787 \begin{verbatim}
     787\begin{prototype}
    788788bool pmFlatField(psReadout *in, psReadout *mask, const psReadout *flat);
    789 \end{verbatim}
     789\end{prototype}
    790790
    791791Note that the input image, \code{in}, and the flat-field image,
    … …  
    827827
    828828We define several mask values for use in the phase 2 processing:
    829 \begin{verbatim}
     829\begin{datatype}
    830830/** Mask values */
    831831typedef enum {
    … …  
    835835    PM_MASK_FLAT       = 0x0008,        ///< The pixel is non-positive in the flat-field
    836836} pmMaskValue;
    837 \end{verbatim}
     837\end{datatype}
    838838
    839839Of these, masks for the charge traps need to be grown by the extent of
    … …  
    850850pixels in the bad pixel mask that match the value to mask.  The API
    851851shall be the following:
    852 \begin{verbatim}
     852\begin{prototype}
    853853psReadout *pmMaskBadPixels(psReadout *in, const psImage *mask, unsigned int maskVal,
    854854                           float sat, unsigned int growVal, int grow);
    855 \end{verbatim}
     855\end{prototype}
    856856
    857857Note that the input image, \code{in}, is modified in-place.  All
    … …  
    882882subtract a model for the background of the image.  The API shall be
    883883the following:
    884 \begin{verbatim}
     884\begin{prototype}
    885885psReadout *pmSubtractSky(psReadout *in, psPolynomial2D *poly, psImage *mask, psU8 maskVal,
    886886                         int binFactor, psStats *stats, float clipSD);
    887 \end{verbatim}
     887\end{prototype}
    888888
    889889Note that the input image, \code{in}, shall be subtracted in-place.
    … …  
    933933and so each input image will have the same noise characteristics.
    934934
    935 \begin{verbatim}
     935\begin{datatype}
    936936typedef struct {
    937937    psStats *stats;                     // Statistics to use in combining pixels
    … …  
    941941    int nKeep;                          // Number of pixels to be sure to keep
    942942} pmCombineParams;
    943 
     943\end{datatype}
     944
     945\begin{prototype}
    944946psImage *
    945947pmReadoutCombine(psImage *output,       // Output image, or NULL
    … …  
    952954                 float readnoise        // Read noise in e
    953955                 );
    954 \end{verbatim}
     956\end{prototype}
    955957
    956958\code{pmReadoutCombine} combines input images pixel by pixel --- for
    … …  
    11041106
    11051107We start by defining a single source detected in a single band:
    1106 \begin{verbatim}
     1108\begin{datatype}
    11071109typedef struct {
    11081110  pmPeak *peak;            // description of peak pixel
    … …  
    11131115  pmSourceType type;       // best identification of object
    11141116} pmSource;
    1115 \end{verbatim}
     1117\end{datatype}
    11161118
    11171119This source has the capacity for several types of measurements.  The
    11181120simplest measurement of a source is the location and flux of the peak
    11191121pixel associated with the source:
    1120 \begin{verbatim}
     1122\begin{datatype}
    11211123typedef struct {
    11221124  int x;                   // x-coordinate of peak pixel
    … …  
    11251127  pmPeakType class;        // description of peak
    11261128} pmPeak;
    1127 \end{verbatim}
     1129\end{datatype}
    11281130
    11291131A peak pixel may have several features which may be determined when
    … …  
    11351137than a specific number of neighbors at the same value, within some
    11361138tolarence:
    1137 \begin{verbatim}
     1139\begin{datatype}
    11381140typedef enum {
    11391141  PM_PEAK_LONE;             // isolated peak
    … …  
    11411143  PM_PEAK_FLAT;             // peak has equal-value neighbors
    11421144} pmPeakType;
    1143 \end{verbatim}
     1145\end{datatype}
    11441146
    11451147The pixels which contain the source may be specified with the
    … …  
    11541156moment information for a specific source:
    11551157
    1156 \begin{verbatim}
     1158\begin{datatype}
    11571159typedef struct {
    11581160  float x;                  // x-coord of centroid
    … …  
    11661168  int   nPixels;            // number of pixels used
    11671169} pmMoments;
    1168 \end{verbatim}
     1170\end{datatype}
    11691171
    11701172An object's flux distribution may be modelled with some analytical
    … …  
    11741176discuss the details of these models in section~\ref{ObjectModels}.
    11751177
    1176 \begin{verbatim}
     1178\begin{datatype}
    11771179typedef struct {
    11781180  pmObjectModel type;       // model to be used
    … …  
    11831185  psS32 nIter;          // number of iterations
    11841186} pmModel;
    1185 \end{verbatim}
    1186 
    1187 \begin{verbatim}
     1187\end{datatype}
     1188
     1189\begin{datatype}
    11881190typedef enum {
    11891191  PM_MODEL_GAUSS;
    … …  
    11941196  PM_MODEL_SERSIC_CORE;
    11951197} pmModelType;
    1196 \end{verbatim}
     1198\end{datatype}
    11971199
    11981200A given source may be identified as most-likely to be one of several
    … …  
    12021204source classification code is developed.}
    12031205
    1204 \begin{verbatim}
     1206\begin{datatype}
    12051207typedef enum {
    12061208  PM_SOURCE_PSFSTAR;
    … …  
    12131215  PM_SOURCE_OTHER;
    12141216} pmSourceType;
    1215 \end{verbatim}
    1216 
    1217 \begin{verbatim}
     1217\end{datatype}
     1218
     1219\begin{datatype}
    12181220typedef enum {
    12191221  PM_CONTOUR_CRUDE;
    12201222} pmContourType;
    1221 \end{verbatim}
     1223\end{datatype}
    12221224
    12231225Allocators for the above structures are defined as follows:
    1224 \begin{verbatim}
     1226\begin{prototype}
    12251227pmSource   *pmSourceAlloc ();
    12261228pmPeak     *pmPeakAlloc (int x, int y, float counts, psPeakType class);
    12271229pmMoments  *pmMomentsAlloc ();
    12281230pmModel    *pmModelAlloc (pmModelType type);
    1229 \end{verbatim}
     1231\end{prototype}
    12301232
    12311233\subsection{Basic Object Detection APIs}
    … …  
    12351237which we expect to use them in a basic object detection process.
    12361238
    1237 \begin{verbatim}
     1239\begin{prototype}
    12381240psVector *pmFindVectorPeaks(const psVector *vector, float threshold);
    1239 \end{verbatim}
     1241\end{prototype}
    12401242
    12411243Find all local peaks in the given vector above the given threshold.  A
    … …  
    12551257\code{psU32}).
    12561258
    1257 \begin{verbatim}
     1259\begin{prototype}
    12581260psArray *pmFindImagePeaks(const psImage *image, float threshold);
    1259 \end{verbatim}
     1261\end{prototype}
    12601262
    12611263Find all local peaks in the given image above the given threshold.
    … …  
    12721274this function is an array of \code{pmPeak} entries.
    12731275
    1274 \begin{verbatim}
     1276\begin{prototype}
    12751277psArray *pmPeaksSubset(psArray *peaks, float maxvalue, const psRegion valid);
    1276 \end{verbatim}
     1278\end{prototype}
    12771279
    12781280Create a new peaks array, removing certain types of peaks from the
    … …  
    12821284function is a new array with a reduced number of peaks.
    12831285
    1284 \begin{verbatim}
     1286\begin{prototype}
    12851287pmSource *pmSourceLocalSky(const psImage *image, const pmPeak *peak, psStatsOptions statsOptions, float innerRadius, float outerRadius);
    1286 \end{verbatim}
     1288\end{prototype}
    12871289
    12881290Measure the local sky in the vicinity of the given \code{peak}.  The
    … …  
    12971299which is then returned.
    12981300
    1299 \begin{verbatim}
     1301\begin{prototype}
    13001302bool pmSourceMoments(pmSource *source, float radius);
    1301 \end{verbatim}
     1303\end{prototype}
    13021304
    13031305Measure source moments for the given \code{source}, using the value of
    … …  
    13091311value indicates the success (TRUE) of the operation.
    13101312
    1311 \begin{verbatim}
     1313\begin{prototype}
    13121314bool pmSourceRoughClass(pmArray *source, psMetadata *metadata);
    1313 \end{verbatim}
     1315\end{prototype}
    13141316
    13151317Based on the specified data values, make a guess at the source
    … …  
    14011403\end{enumerate}
    14021404
    1403 \begin{verbatim}
     1405\begin{prototype}
    14041406bool pmSourceSetPixelsCircle(pmSource *source, const psImage *image, float radius, int maskVal);
    1405 \end{verbatim}
     1407\end{prototype}
    14061408
    14071409Define pixels associated with a source based on a circular aperture.
    … …  
    14131415success or \code{FALSE} on failure.
    14141416
    1415 \begin{verbatim}
     1417\begin{prototype}
    14161418bool pmSourceModelGuess(pmSource *source, const psImage *image, pmModelType model);
    1417 \end{verbatim}
     1419\end{prototype}
    14181420
    14191421Convert available data to an initial guess for the given model.  This
    … …  
    14241426function returns \code{TRUE} on success or \code{FALSE} on failure.
    14251427
    1426 \begin{verbatim}
     1428\begin{prototype}
    14271429psArray *pmSourceContour(const pmSource *source, const psImage *image, float level, pmContourType type);
    1428 \end{verbatim}
     1430\end{prototype}
    14291431
    14301432Find points in a contour for the given source at the given level.  If
    … …  
    14401442\tbd{Other contour types may be specified in the future for more refined contours}
    14411443
    1442 \begin{verbatim}
     1444\begin{prototype}
    14431445bool pmSourceFitModel(pmSource *source, psImage *image);
    1444 \end{verbatim}
     1446\end{prototype}
    14451447
    14461448Fit the requested model to the specified source.  The starting guess
    … …  
    14511453returns \code{TRUE} on success or \code{FALSE} on failure.
    14521454
    1453 \begin{verbatim}
     1455\begin{prototype}
    14541456bool pmSourceAddModel(psImage *image, pmSource *source, bool center, bool sky);
    14551457bool pmSourceSubModel(psImage *image, pmSource *source, bool center, bool sky);
    1456 \end{verbatim}
     1458\end{prototype}
    14571459
    14581460Add or subtract the given source model flux to/from the provided
    … …  
    14731475\subsubsection{Real 2D Gaussian}
    14741476
    1475 \begin{verbatim}
     1477\begin{prototype}
    14761478float pmMinLM_Gauss2D(psVector *deriv, psVector *params, psVector *x);
    1477 \end{verbatim}
     1479\end{prototype}
    14781480
    14791481This function is a two-dimensional Gaussian with an elliptical
    … …  
    14851487\subsubsection{Pseudo-Gaussian}
    14861488
    1487 \begin{verbatim}
     1489\begin{prototype}
    14881490float pmMinLM_PseudoGauss2D(psVector *deriv, psVector *params, psVector *x);
    1489 \end{verbatim}
     1491\end{prototype}
    14901492
    14911493This function is a polynomial approximation of a 2D Gaussian otherwise
    … …  
    14981500\subsubsection{Waussian}
    14991501
    1500 \begin{verbatim}
     1502\begin{prototype}
    15011503float pmMinLM_Wauss2D(psVector *deriv, psVector *params, psVector *x);
    1502 \end{verbatim}
     1504\end{prototype}
    15031505
    15041506The Waussian is a modified polynomial approximation of a 2D Gaussian,
    … …  
    15081510\subsubsection{Twisted Gaussian}
    15091511
    1510 \begin{verbatim}
     1512\begin{prototype}
    15111513float pmMinLM_TwistGauss2D(psVector *deriv, psVector *params, psVector *x);
    1512 \end{verbatim}
     1514\end{prototype}
    15131515
    15141516This function describes an object with power-law wings and a flattened
    … …  
    15221524\subsubsection{Sersic Galaxy Model}
    15231525
    1524 \begin{verbatim}
     1526\begin{prototype}
    15251527float pmMinLM_Sersic(psVector *deriv, psVector *params, psVector *x);
    1526 \end{verbatim}
     1528\end{prototype}
    15271529
    15281530\subsubsection{Sersic with Core Galaxy Model}
    15291531
    1530 \begin{verbatim}
     1532\begin{prototype}
    15311533float pmMinLM_SersicCore(psVector *deriv, psVector *params, psVector *x);
    1532 \end{verbatim}
     1534\end{prototype}
    15331535
    15341536\subsubsection{Pseudo Sersic Galaxy Model}
    15351537
    1536 \begin{verbatim}
     1538\begin{prototype}
    15371539float pmMinLM_PseudoSersic(psVector *deriv, psVector *params, psVector *x);
    1538 \end{verbatim}
     1540\end{prototype}
    15391541
    15401542
    … …  
    15561558\subsection{Combining images}
    15571559
    1558 \begin{verbatim}
     1560\begin{prototype}
    15591561psImage *pmCombineImages(psImage *combined, // Combined image
    15601562                         psArray **questionablePixels, // Array of rejection masks
    … …  
    15681570                         const psStats *stats // Statistics to use in the combination
    15691571                         );
    1570 \end{verbatim}
     1572\end{prototype}
    15711573
    15721574\code{pmCombineImages} shall combine the input \code{images},
    … …  
    16021604\subsection{Rejecting pixels}
    16031605
    1604 \begin{verbatim}
     1606\begin{prototype}
    16051607psArray *pmRejectPixels(const psArray *images, // Array of input images
    16061608                        const psArray *pixels, // These are the pixels which were rejected in the combination
    … …  
    16101612                        float gradLimit // Gradient limit
    16111613                        );
    1612 \end{verbatim}
     1614\end{prototype}
    16131615
    16141616\code{pmRejectPixels} inspects those questionable \code{pixels}
    … …  
    17641766equally useful and faster, though not as tried and proven.
    17651767
    1766 \begin{verbatim}
     1768\begin{datatype}
    17671769typedef enum {
    17681770    PM_SUBTRACTION_KERNEL_POIS,         // POIS kernel --- delta functions
    17691771    PM_SUBTRACTION_KERNEL_ISIS          // ISIS kernel --- gaussians modified by polynomials
    17701772} pmSubtractionKernelsType;
    1771 \end{verbatim}
     1773\end{datatype}
    17721774
    17731775In order to simplify the book-keeping for the kernels, we will define
    … …  
    17751777each of the kernel basis functions:
    17761778
    1777 \begin{verbatim}
     1779\begin{datatype}
    17781780typedef struct {
    17791781    pmSubtractionKernelType type;       // Type of kernels --- allowing the use of multiple kernels
    … …  
    17851787                                        // accelerate ISIS; don't use for POIS)
    17861788} pmSubtractionKernels;
    1787 \end{verbatim}
     1789\end{datatype}
    17881790
    17891791This structure caters for both choices of kernel type.  For a POIS
    … …  
    18111813The \code{pmSubtractionKernels} are generated by the following functions:
    18121814
    1813 \begin{verbatim}
     1815\begin{prototype}
    18141816pmSubtractionKernels *pmSubtractionKernelsAllocPOIS(int size, int spatialOrder);
    18151817pmSubtractionKernels *pmSubtractionKernelsAllocISIS(const psVector *sigmas, const psVector *orders,
    18161818                                                    int size, int spatialOrder);
    1817 \end{verbatim}
     1819\end{prototype}
    18181820
    18191821\code{pmSubtractionKernelsAllocPOIS} shall generate the
    … …  
    18471849convolution kernel are referred to as ``stamps''.
    18481850
    1849 \begin{verbatim}
     1851\begin{datatype}
    18501852typedef struct {
    18511853    int x, y;                           // Position
    … …  
    18541856    psStampStatus status;               // Status of stamp
    18551857} pmStamp;
    1856 \end{verbatim}
     1858\end{datatype}
    18571859
    18581860A stamp is the region around a central pixel, \code{x,y}.  The
    … …  
    18681870\code{status}, an enumerated type:
    18691871
    1870 \begin{verbatim}
     1872\begin{datatype}
    18711873typedef enum {
    18721874    PM_STAMP_USED,                      // Use this stamp
    … …  
    18751877    PM_STAMP_NONE                       // No stamp in this region
    18761878} pmStampStatus;
    1877 \end{verbatim}
    1878 
    1879 \begin{verbatim}
     1879\end{datatype}
     1880
     1881\begin{prototype}
    18801882psArary *pmSubtractionFindStamps(psArray *stamps, // Output stamps, or NULL
    18811883                                 const psImage *image, // Image for which to find stamps
    … …  
    18861888                                 int border // Border around image to ignore (should be size of kernel)
    18871889                                 );
    1888 \end{verbatim}
     1890\end{prototype}
    18891891
    18901892\code{pmSubtractionFindStamps} returns an array of stamps on the
    … …  
    19141916stamps.
    19151917
    1916 \begin{verbatim}
     1918\begin{prototype}
    19171919bool pmSubtractionCalculateEquation(psArray *stamps, // The stamps for which to calculate the equation
    19181920                                    const psImage *reference, // Reference image
    … …  
    19211923                                    int footprint // Half-size of region over which to calculate equation
    19221924                                    );
    1923 \end{verbatim}
     1925\end{prototype}
    19241926
    19251927\code{pmSubtractionCalculateEquation} shall calculate the
    … …  
    19611963subtraction, care should be taken with optimisation.
    19621964
    1963 \begin{verbatim}
     1965\begin{prototype}
    19641966psVector *pmSubtractionSolveEquation(psVector *solution,        // Solution vector, or NULL
    19651967                                     const psArray *stamps // Array of stamps
    19661968                                     );
    1967 \end{verbatim}
     1969\end{prototype}
    19681970
    19691971\code{pmSubtractionSolveEquation} shall solve the matrix equation
    … …  
    19821984\subsection{Rejection of stamps}
    19831985
    1984 \begin{verbatim}
     1986\begin{prototype}
    19851987bool pmSubtractionRejectStamps(psArray *stamps, // Array of stamps to check for rejection
    19861988                               psImage *mask, // Mask image
    … …  
    19931995                               const pmSubtractionKernels *kernels // Array of kernel parameters
    19941996                               );
    1995 \end{verbatim}
     1997\end{prototype}
    19961998
    19971999\code{pmSubtractionRejectStamps} shall apply the \code{solution} to
    … …  
    20142016it.
    20152017
    2016 \begin{verbatim}
     2018\begin{prototype}
    20172019psImage *pmSubtractionKernelImage(psImage *out, const psVector *solution,
    20182020                                  const pmSubtractionKernels *kernels, float x, float y);
    2019 \end{verbatim}
     2021\end{prototype}
    20202022
    20212023\code{pmSubtractionKernelImage} shall create an image of the kernel
    … …  
    22082210corresponding parameters, \code{psPhase2MaskCRs} shall mask cosmic
    22092211rays on the input image on the basis of their morphology.  The API shall be the following:
    2210 \begin{verbatim}
     2212\begin{prototype}
    22112213/** Masks Cosmic Rays on the input image on the basis of morphology. */
    22122214psReadout *psPhase2MaskCRs(psReadout *in, ///< Input image to be masked, and output
    … …  
    22142216                           const void *params ///< Parameters for algorithm
    22152217                           );
    2216 \end{verbatim}
     2218\end{prototype}
    22172219
    22182220This is one case in which the best choice of algorithm is not known,
    … …  
    22292231\code{psPhase2MaskOpticalDefects} shall mask optical defects on the
    22302232image.  The API shall be the following:
    2231 \begin{verbatim}
     2233\begin{prototype}
    22322234/** Masks optical defects in the input image */
    22332235psChip *psPhase2MaskOpticalDefects(psChip *in, ///< Image to be masked (with astrometry), and output
    … …  
    22352237                                   int grow ///< Number of pixels to grow
    22362238                                   );
    2237 \end{verbatim}
     2239\end{prototype}
    22382240
    22392241\tbd{It's not clear to me how this is accomplished apart from an
    … …  
    22512253parameters, \code{psPhase2MeasurePSF} shall return the PSF for the
    22522254image.  The API shall be the following:
    2253 \begin{verbatim}
     2255\begin{prototype}
    22542256/** Measures the PSF on the input image.  Returns the PSF */
    22552257psImage *psPhase2MeasurePSF(const psReadout *in, ///< Input image for which to measure the PSF
    … …  
    22572259                            const void *params ///< Parameters for algorithm
    22582260                            );
    2259 \end{verbatim}
     2261\end{prototype}
    22602262
    22612263This is another case where the algorithm is not currently clear, and
    … …  
    22702272readout with the \code{objects} member set to a list of objects.  The
    22712273API shall be the following:
    2272 \begin{verbatim}
     2274\begin{prototype}
    22732275/** Find and measure objects on the input image.  Fills in the "objects" member of the psReadout. */
    22742276/** THIS NEEDS WORK. */
    … …  
    22772279                               const psVector *levels ///< Threshold levels (std dev.s)
    22782280                               );
    2279 \end{verbatim}
     2281\end{prototype}
    22802282
    22812283Note that the input image shall be modified in-place, only insofar as
    … …  
    22932295clipping parameters, \code{psPhase2Astrometry} shall fit an
    22942296astrometric solution.  The API shall be the following:
    2295 \begin{verbatim}
     2297\begin{prototype}
    22962298/** Corrects astrometry on the input chip */
    22972299psChip *psPhase2Astrometry(psChip *in,  ///< Input chip for which to do astrometry, and output
    … …  
    23002302                           float clipLevel ///< Level at which to clip
    23012303                           );
    2302 \end{verbatim}
     2304\end{prototype}
    23032305
    23042306Note that the input chip shall be modified in-place, only insofar as
    … …  
    23192321coordinates.  We define a \code{psPostageStampSpec} to specify the
    23202322parameters for a postage stamp:
    2321 \begin{verbatim}
     2323\begin{datatype}
    23222324/** Specification of a postage stamp: location on the sky */
    23232325typedef struct {
    … …  
    23252327    psSphereCoord *size;                ///< Size of postage stamp
    23262328} psPostageStampSpec;
    2327 \end{verbatim}
     2329\end{datatype}
    23282330
    23292331The \code{center} shall be specified in ICRS coordinates, which is the
    … …  
    23362338chip, \code{psPhase2PostageStamps} shall output an array of subimages,
    23372339containing each of the regions.  The API shall be the following:
    2338 \begin{verbatim}
     2340\begin{prototype}
    23392341/** Return postage stamps of a set of regions */
    23402342psImageArray *psPhase2PostageStamps(const psChip *in, ///< Chip from which to form postage stamps
    … …  
    23422344                                                           ///< psPostageStampSpec
    23432345                                    );
    2344 \end{verbatim}
     2346\end{prototype}
    23452347
    23462348\code{regions} shall be a linked list of \code{psPostageStampSpec}s,
Note: See TracChangeset for help on using the changeset viewer.