Index: /trunk/archive/pslib/include/psAstrom.h =================================================================== --- /trunk/archive/pslib/include/psAstrom.h (revision 343) +++ /trunk/archive/pslib/include/psAstrom.h (revision 344) @@ -40,23 +40,23 @@ typedef struct { // Telescope longitude, latitude and height are stored separately, since they don't change with pointing - double ra, dec; //!< Telescope boresight - double ha; //!< Hour angle - double zd; //!< Zenith distance - double az; //!< Azimuth - double lst; //!< Local Sidereal Time - float mjd; //!< MJD of observation - float rotAngle; //!< Rotator position angle - float temp; //!< Air temperature, for estimating refraction - float pressure; //!< Air pressure, for calculating refraction - float humidity; //!< Relative humidity, for calculating refraction - float exptime; //!< Exposure time + double ra, dec; ///< Telescope boresight + double ha; ///< Hour angle + double zd; ///< Zenith distance + double az; ///< Azimuth + double lst; ///< Local Sidereal Time + float mjd; ///< MJD of observation + float rotAngle; ///< Rotator position angle + float temp; ///< Air temperature, for estimating refraction + float pressure; ///< Air pressure, for calculating refraction + float humidity; ///< Relative humidity, for calculating refraction + float exptime; ///< Exposure time /* Derived quantities */ - float posAngle; //!< Position angle - float parallactic; //!< Parallactic angle - float airmass; //!< Airmass, calculated from zenith distance - float pf; //!< Parallactic factor + float posAngle; ///< Position angle + float parallactic; ///< Parallactic angle + float airmass; ///< Airmass, calculated from zenith distance + float pf; ///< Parallactic factor char *cameraName; ///< name of camera which provided exposure char *telescopeName; ///< name of telescope which provided exposure - psGrommit *grommit; //!< Data needed to convert from the sky to the tangent plane + psGrommit *grommit; ///< Data needed to convert from the sky to the tangent plane } psExposure; @@ -64,8 +64,8 @@ /** The fixed pattern residual offsets. These are specified via a coarse grid of x and y offsets. */ typedef struct { - int nX, nY; //!< Number of elements in x and y - double x0, y0; //!< Position of the lower-left corner of the grid on the focal plane - double xScale, yScale; //!< Scale of the grid - double **x, **y; //!< The grid of offsets in x and y + int nX, nY; ///< Number of elements in x and y + double x0, y0; ///< Position of the lower-left corner of the grid on the focal plane + double xScale, yScale; ///< Scale of the grid + double **x, **y; ///< The grid of offsets in x and y } psFixedPattern; @@ -82,9 +82,9 @@ psDistortion *TPtoFP; ///< Transformation term from psDistortion *FPtoTP; ///< Transformation term from - psFixedPattern *pattern; //!< Fixed pattern residual offsets + psFixedPattern *pattern; ///< Fixed pattern residual offsets psExposure *exp; ///< information about this exposure psPhotSystem colorPlus, colorMinus; ///< Colour reference - float rmsX, rmsY; //!< Dispersion in astrometric solution - float chi2; //!< chi^2 of astrometric solution + float rmsX, rmsY; ///< Dispersion in astrometric solution + float chi2; ///< chi^2 of astrometric solution } psFPA; @@ -98,5 +98,5 @@ psMetaDataSet *md; ///< Chip-level metadata psCoordXform *chipToFPA; ///< Transformations from chip coordinates to FPA coordinates - psCoordXform *FPAtoChip; //!< Transformations from FPA coordinates to chip + psCoordXform *FPAtoChip; ///< Transformations from FPA coordinates to chip struct psFPA *parentFPA; ///< FPA which contains this chip @@ -108,5 +108,5 @@ int nReadouts; ///< number of readouts in this cell realization; each may have its ///< own image, objects and overscan. - psReadout *readouts; //!< Readouts from the cell + psReadout *readouts; ///< Readouts from the cell psMetaDataSet *md; ///< Cell-level metadata @@ -120,10 +120,10 @@ /** a Readout: a collection of pixels */ typedef struct { - const int x0, y0; //!< Offset from the lower-left corner - const int nx, ny; //!< Image binning + const int x0, y0; ///< Offset from the lower-left corner + const int nx, ny; ///< Image binning psImage *image; ///< imaging area of cell psDlist *objects; ///< objects derived from cell psImage *overscan; ///< bias region (subimage) of cell - psMetaDataSet *md; //!< Readout-level metadata + psMetaDataSet *md; ///< Readout-level metadata } psReadout; @@ -138,5 +138,5 @@ /** returns Chip in FPA which contains the given FPA coordinate */ psChip * -psChipInFPA (psChip *out, //!< Chip to return, or NULL +psChipInFPA (psChip *out, ///< Chip to return, or NULL const psFPA *fpa, ///< FPA description const psCoord *coord ///< coordinate in FPA @@ -145,5 +145,5 @@ /** returns Cell in Chip which contains the given chip coordinate */ psCell * -psCellInChip(psCell *out, //!< Cell to return, or NULL +psCellInChip(psCell *out, ///< Cell to return, or NULL const psChip *chip, ///< chip description const psCoord *coord ///< coordinate in chip @@ -152,7 +152,7 @@ /** Return the cell in FPA which contains the given FPA coordinates */ psCell * -psCellInFPA(psCell *out, //!< Cell to return, or NULL - const psFPA *fpa, //!< FPA description - const psCoord *coord //!< Coordinate in FPA +psCellInFPA(psCell *out, ///< Cell to return, or NULL + const psFPA *fpa, ///< FPA description + const psCoord *coord ///< Coordinate in FPA ); @@ -160,40 +160,40 @@ /** Convert (RA,Dec) to cell and cell coordinates */ psCoord * -psCoordSkyToCell(psCoord *out, //!< Coordinates to return, or NULL - psCell *cell, //!< Cell to return - const psFPA *fpa //!< FPA description +psCoordSkyToCell(psCoord *out, ///< Coordinates to return, or NULL + psCell *cell, ///< Cell to return + const psFPA *fpa ///< FPA description ); /** Convert cell and cell coordinate to (RA,Dec) */ psCoord * -psCoordCellToSky(psCoord *out, //!< Coordinates to return, or NULL - const psCell *cell, //!< Cell to get coordinates for - const psCoord *coord //!< cell coordinates to transform +psCoordCellToSky(psCoord *out, ///< Coordinates to return, or NULL + const psCell *cell, ///< Cell to get coordinates for + const psCoord *coord ///< cell coordinates to transform ); /** Quick and dirty cell to (RA,Dec) --- employs cellToSky transformation */ psCoord * -psCoordCellToSkyQuick(psCoord *out, //!< Coordinates to return, or NULL - const psCell *cell, //!< Cell description - const psCoord *coord //!< cell coordinates to transform +psCoordCellToSkyQuick(psCoord *out, ///< Coordinates to return, or NULL + const psCell *cell, ///< Cell description + const psCoord *coord ///< cell coordinates to transform ); /** Convert (RA,Dec) to tangent plane coords */ psCoord * -psCoordSkyToTP(psCoord *out, //!< Coordinates to return, or NULL - const psExposure *exp, //!< Exposure description - const psCoord *coord //!< input Sky coordinate +psCoordSkyToTP(psCoord *out, ///< Coordinates to return, or NULL + const psExposure *exp, ///< Exposure description + const psCoord *coord ///< input Sky coordinate ); /** Convert tangent plane coords to focal plane coordinates */ psCoord * -psCoordTPtoFPA(psCoord *out, //!< Coordinates to return, or NULL - const psFPA *fpa, //!< FPA description - const psCoord *coord //!< input TP coordinate +psCoordTPtoFPA(psCoord *out, ///< Coordinates to return, or NULL + const psFPA *fpa, ///< FPA description + const psCoord *coord ///< input TP coordinate ); /** converts the specified FPA coord to the coord on the given Chip */ psCoord * -psCoordFPAtoChip (psCoord *out, //!< Coordinates to return, or NULL +psCoordFPAtoChip (psCoord *out, ///< Coordinates to return, or NULL const psChip *chip, ///< Chip of interest const psCoord *coord ///< input FPA coordinate @@ -202,5 +202,5 @@ /** converts the specified Chip coord to the coord on the given Cell */ psCoord * -psCoordChiptoCell (psCoord *out, //!< Coordinates to return, or NULL +psCoordChiptoCell (psCoord *out, ///< Coordinates to return, or NULL const psCell *cell, ///< Cell of interest const psCoord *coord ///< input Chip coordinate @@ -209,5 +209,5 @@ /** converts the specified Cell coord to the coord on the parent Chip */ psCoord * -psCoordCelltoChip (psCoord *out, //!< Coordinates to return, or NULL +psCoordCelltoChip (psCoord *out, ///< Coordinates to return, or NULL const psCell *cell, ///< Cell description const psCoord *coord ///< input Cell coordinate @@ -216,5 +216,5 @@ /** converts the specified Chip coord to the coord on the parent FPA */ psCoord * -psCoordChiptoFPA (psCoord *out, //!< Coordinates to return, or NULL +psCoordChiptoFPA (psCoord *out, ///< Coordinates to return, or NULL const psChip *chip, ///< Chip description const psCoord *coord ///< input Chip coordinate @@ -223,47 +223,47 @@ /** Convert focal plane coords to tangent plane coordinates */ psCoord * -psCoordFPAToTP(psCoord *out, //!< Coordinates to return, or NULL - const psFPA *fpa, //!< FPA description - const psCoord *coord //!< input FPA coordinate +psCoordFPAToTP(psCoord *out, ///< Coordinates to return, or NULL + const psFPA *fpa, ///< FPA description + const psCoord *coord ///< input FPA coordinate ); /** Convert tangent plane coords to (RA,Dec) */ psCoord * -psCoordTPtoSky(psCoord *out, //!< Coordinates to return, or NULL - const psExposure *exp, //!< Exposure description - const psCoord *coord //!< input TP coordinate +psCoordTPtoSky(psCoord *out, ///< Coordinates to return, or NULL + const psExposure *exp, ///< Exposure description + const psCoord *coord ///< input TP coordinate ); /** Convert Cell coords to FPA coordinates */ psCoord * -psCoordCellToFPA(psCoord *out, //!< Coordinates to return, or NULL - const psCell *cell, //!< Cell description - const psCoord *coord //!< Input cell coordinates +psCoordCellToFPA(psCoord *out, ///< Coordinates to return, or NULL + const psCell *cell, ///< Cell description + const psCoord *coord ///< Input cell coordinates ); /** Get the airmass for a given position and sidereal time */ float -psGetAirmass(const psCoord *coord, //!< Position on the sky - double siderealTime, //!< Sidereal time - float height //!< Height above sea level +psGetAirmass(const psCoord *coord, ///< Position on the sky + double siderealTime, ///< Sidereal time + float height ///< Height above sea level ); /** Get the parallactic angle for a given position and sidereal time */ float -psGetParallactic(const psCoord *coord, //!< Position on the sky - double siderealTime //!< Sidereal time +psGetParallactic(const psCoord *coord, ///< Position on the sky + double siderealTime ///< Sidereal time ); /** Estimate atmospheric refraction, along the parallactic */ float -psGetRefraction(float colour, //!< Colour of object +psGetRefraction(float colour, ///< Colour of object psPhotSystem colorPlus, ///< Colour reference psPhotSystem colorMinus, ///< Colour reference - const psExposure *exp //!< Telescope pointing information, for airmass, temp and pressure + const psExposure *exp ///< Telescope pointing information, for airmass, temp and pressure ); /** Calculate the parallax factor */ psCoord * -psGetParallaxFactor(const psExposure *exp //!< Exposure details +psGetParallaxFactor(const psExposure *exp ///< Exposure details ); @@ -272,20 +272,20 @@ /** Constructor */ psExposure * -psExposureAlloc(double ra, double dec, //!< Telescope boresight - double ha, //!< Hour angle - double zd, //!< Zenith distance - double az, //!< Azimuth - double lst, //!< Local Sidereal Time - float mjd, //!< MJD - float rotAngle, //!< Rotator position angle - float temp, //!< Temperature - float pressure, //!< Pressure - float humidity, //!< Relative humidity - float exptime //!< Exposure time +psExposureAlloc(double ra, double dec, ///< Telescope boresight + double ha, ///< Hour angle + double zd, ///< Zenith distance + double az, ///< Azimuth + double lst, ///< Local Sidereal Time + float mjd, ///< MJD + float rotAngle, ///< Rotator position angle + float temp, ///< Temperature + float pressure, ///< Pressure + float humidity, ///< Relative humidity + float exptime ///< Exposure time ); /** Destructor */ void -psExposureFree(psExposure *restrict myExp //!< Object to destroy +psExposureFree(psExposure *restrict myExp ///< Object to destroy ); /* \} */ // End of AstroGroup Functions Index: /trunk/archive/pslib/include/psBitMask.h =================================================================== --- /trunk/archive/pslib/include/psBitMask.h (revision 343) +++ /trunk/archive/pslib/include/psBitMask.h (revision 344) @@ -9,6 +9,6 @@ /** A bitmask of arbitrary length. */ typedef struct { - int n; //!< Number of chars that form the mask - char *bits; //!< The bits + int n; ///< Number of chars that form the mask + char *bits; ///< The bits } psBitMask; @@ -19,9 +19,9 @@ /** Constructor */ -psBitMask *psBitMaskAlloc(int n //!< Number of bits required +psBitMask *psBitMaskAlloc(int n ///< Number of bits required ); /** Destructor */ -void psBitMaskFree(psBitMask *restrict myMask //!< Bit mask to destroy +void psBitMaskFree(psBitMask *restrict myMask ///< Bit mask to destroy ); @@ -30,21 +30,21 @@ /** Set a bit mask */ psBitMask * -psBitMaskSet(psBitMask *outMask, //!< Output bit mask or NULL - const psBitMask *myMask, //!< Input bit mask - int bit //!< Bit to set +psBitMaskSet(psBitMask *outMask, ///< Output bit mask or NULL + const psBitMask *myMask, ///< Input bit mask + int bit ///< Bit to set ); /** Check a bit mask. Returns true or false */ int -psBitMaskTest(const psBitMask *checkMask, //!< Bit mask to check - int bit //!< Bit to check +psBitMaskTest(const psBitMask *checkMask, ///< Bit mask to check + int bit ///< Bit to check ); /** apply the given operator to two bit masks */ psBitMask * -psBitMaskOp(psBitMask *outMask, //!< Output bit mask or NULL - const psBitMask *restrict inMask1, //!< Input bit mask 1 - char *operator, //!< bit mask operator (AND, OR, XOR) - const psBitMask *restrict inMask2 //!< Input bit mask 2 +psBitMaskOp(psBitMask *outMask, ///< Output bit mask or NULL + const psBitMask *restrict inMask1, ///< Input bit mask 1 + char *operator, ///< bit mask operator (AND, OR, XOR) + const psBitMask *restrict inMask2 ///< Input bit mask 2 ); Index: /trunk/archive/pslib/include/psDateTime.h =================================================================== --- /trunk/archive/pslib/include/psDateTime.h (revision 343) +++ /trunk/archive/pslib/include/psDateTime.h (revision 344) @@ -21,6 +21,6 @@ /** Get current sidereal time at longitude \ingroup AstroGroup */ double -psGetSidereal(float mjd, //!< MJD - float longitude) //!< Longitude +psGetSidereal(float mjd, ///< MJD + float longitude) ///< Longitude ; @@ -28,30 +28,30 @@ /** Convert psTime to ISOTime (Human-readable date/time string YYYY/MM/DD,HH:MM:SS.SSS) */ char * -psTimeToISOTime (psTime time) //!< Input psTime time +psTimeToISOTime (psTime time) ///< Input psTime time ; /** Convert psTime to UTC */ double -psTimeToUTC (psTime time) //!< Input psTime time +psTimeToUTC (psTime time) ///< Input psTime time ; /** Convert psTime to MJD */ double -psTimeToMJD (psTime time) //!< Input psTime time +psTimeToMJD (psTime time) ///< Input psTime time ; /** Convert psTime to JD */ double -psTimeToJD (psTime time) //!< Input psTime time +psTimeToJD (psTime time) ///< Input psTime time ; /** Convert psTime to timeval (struct timeval) */ struct timeval * -psTimeToTimeval (psTime time) //!< Input psTime time +psTimeToTimeval (psTime time) ///< Input psTime time ; /** Convert psTime to broken-down time (struct tm) */ struct tm * -psTimeToTm (psTime time) //!< Input psTime time +psTimeToTm (psTime time) ///< Input psTime time ; @@ -59,30 +59,30 @@ /** Convert ISOTime (Human-readable date/time string YYYY/MM/DD,HH:MM:SS.SSS) to psTime \ingroup AstroGroup */ psTime * -psISOTimeToTime (char *input) //!< Input ISOTime time +psISOTimeToTime (char *input) ///< Input ISOTime time ; /** Convert UTC to psTime */ psTime * -psUTCToTime (double input) //!< Input UTC time +psUTCToTime (double input) ///< Input UTC time ; /** Convert MJD to psTime */ psTime * -psMJDToTime (double input) //!< Input MJD time +psMJDToTime (double input) ///< Input MJD time ; /** Convert JD to psTime */ psTime * -psJDToTime (double input) //!< Input JD time +psJDToTime (double input) ///< Input JD time ; /** Convert timeval to psTime (struct timeval) */ psTime * -psTimevalToTime (struct timeval *input) //!< Input timeval time +psTimevalToTime (struct timeval *input) ///< Input timeval time ; /** Convert broken-to psTime down time (struct tm) */ psTime * -psTMtoTime (struct tm *input) //!< Input tm time +psTMtoTime (struct tm *input) ///< Input tm time ; Index: /trunk/archive/pslib/include/psDlist.h =================================================================== --- /trunk/archive/pslib/include/psDlist.h (revision 343) +++ /trunk/archive/pslib/include/psDlist.h (revision 344) @@ -9,24 +9,24 @@ /** Doubly-linked list element */ typedef struct psDlistElem { - struct psDlistElem *prev; //!< previous link in list - struct psDlistElem *next; //!< next link in list - void *data; //!< real data item + struct psDlistElem *prev; ///< previous link in list + struct psDlistElem *next; ///< next link in list + void *data; ///< real data item } psDlistElem; /** Doubly-linked list */ typedef struct { - int n; //!< number of elements on list - psDlistElem *head; //!< first element on list (may be NULL) - psDlistElem *tail; //!< last element on list (may be NULL) - psDlistElem *iter; //!< iteration cursor + int n; ///< number of elements on list + psDlistElem *head; ///< first element on list (may be NULL) + psDlistElem *tail; ///< last element on list (may be NULL) + psDlistElem *iter; ///< iteration cursor } psDlist; /** Special values of index into list */ enum { - PS_DLIST_HEAD = 0, //!< at head - PS_DLIST_TAIL = -1, //!< at tail - PS_DLIST_UNKNOWN = -2, //!< unknown position - PS_DLIST_PREV = -3, //!< previous element - PS_DLIST_NEXT = -4 //!< next element + PS_DLIST_HEAD = 0, ///< at head + PS_DLIST_TAIL = -1, ///< at tail + PS_DLIST_UNKNOWN = -2, ///< unknown position + PS_DLIST_PREV = -3, ///< previous element + PS_DLIST_NEXT = -4 ///< next element }; @@ -37,10 +37,10 @@ /** Constructor */ -psDlist *psDlistAlloc(void *data //!< initial data item; may be NULL +psDlist *psDlistAlloc(void *data ///< initial data item; may be NULL ); /** Destructor */ -void psDlistFree(psDlist *list, //!< list to destroy - void (*elemFree)(void *) //!< destructor for data on list +void psDlistFree(psDlist *list, ///< list to destroy + void (*elemFree)(void *) ///< destructor for data on list ); @@ -48,23 +48,23 @@ /** Add to list */ -psDlist *psDlistAdd(psDlist *list, //!< list to add to (may be NULL) - void *data, //!< data item to add - int where //!< index, PS_DLIST_HEAD, or PS_DLIST_TAIL +psDlist *psDlistAdd(psDlist *list, ///< list to add to (may be NULL) + void *data, ///< data item to add + int where ///< index, PS_DLIST_HEAD, or PS_DLIST_TAIL ); /** Append to a list */ -psDlist *psDlistAppend(psDlist *list, //!< list to append to (may be NULL) - void *data //!< data item to add +psDlist *psDlistAppend(psDlist *list, ///< list to append to (may be NULL) + void *data ///< data item to add ); /** Remove from a list */ -void *psDlistRemove(psDlist *list, //!< list to remove element from - void *data, //!< data item to remove - int which //!< index of item, or PS_DLIST_UNKNOWN, or PS_DLIST_NEXT, or - //!< PS_DLIST_PREV +void *psDlistRemove(psDlist *list, ///< list to remove element from + void *data, ///< data item to remove + int which ///< index of item, or PS_DLIST_UNKNOWN, or PS_DLIST_NEXT, or + ///< PS_DLIST_PREV ); /** Retrieve from a list */ -void *psDlistGet(const psDlist *list, //!< list to retrieve element from - int which //!< index of item, or PS_DLIST_NEXT, or PS_DLIST_PREV +void *psDlistGet(const psDlist *list, ///< list to retrieve element from + int which ///< index of item, or PS_DLIST_NEXT, or PS_DLIST_PREV ); @@ -72,28 +72,28 @@ /** Set the iterator */ -void psDlistSetIterator(psDlist *list, //!< list to retrieve element from - int where, //!< index, PS_DLIST_HEAD, or PS_DLIST_TAIL - int which //!< index of item, or PS_DLIST_UNKNOWN, or PS_DLIST_NEXT, or - //!< PS_DLIST_PREV +void psDlistSetIterator(psDlist *list, ///< list to retrieve element from + int where, ///< index, PS_DLIST_HEAD, or PS_DLIST_TAIL + int which ///< index of item, or PS_DLIST_UNKNOWN, or PS_DLIST_NEXT, or + ///< PS_DLIST_PREV ); /** Get next element */ -void *psDlistGetNext(psDlist *list, //!< list to retrieve element from - int which //!< index of item, or PS_DLIST_UNKNOWN, or PS_DLIST_NEXT, or - //!< PS_DLIST_PREV +void *psDlistGetNext(psDlist *list, ///< list to retrieve element from + int which ///< index of item, or PS_DLIST_UNKNOWN, or PS_DLIST_NEXT, or + ///< PS_DLIST_PREV ); /** Get previous element */ -void *psDlistGetPrev(psDlist *list, //!< list to retrieve element from - int which //!< index of item, or PS_DLIST_UNKNOWN, or PS_DLIST_NEXT, or - //!< PS_DLIST_PREV +void *psDlistGetPrev(psDlist *list, ///< list to retrieve element from + int which ///< index of item, or PS_DLIST_UNKNOWN, or PS_DLIST_NEXT, or + ///< PS_DLIST_PREV ); /** Convert doubly-linked list to an array */ -psVoidPtrArray *psDlistToArray(psDlist *dlist //!< List to convert +psVoidPtrArray *psDlistToArray(psDlist *dlist ///< List to convert ); /** Convert array to a doubly-linked list */ -psDlist *psArrayToDlist(psVoidPtrArray *arr //!< Array to convert +psDlist *psArrayToDlist(psVoidPtrArray *arr ///< Array to convert ); Index: /trunk/archive/pslib/include/psFFT.h =================================================================== --- /trunk/archive/pslib/include/psFFT.h (revision 343) +++ /trunk/archive/pslib/include/psFFT.h (revision 344) @@ -16,53 +16,53 @@ /** Details on FFT implementation (private). Example shown is for FFTW */ typedef struct { - fftw_plan plan; //!< FFTW plan on how to do the FFT - char *filename; //!< File name for FFTW plan + fftw_plan plan; ///< FFTW plan on how to do the FFT + char *filename; ///< File name for FFTW plan } p_psFFTDetails; /** Fast Fourier Transform */ typedef struct { - p_psFFTDetails *details; //!< Details on FFT implementation (private) - int nx, ny; //!< Size in x and y - float *real; //!< Data in real space: a 2D array using the [nx*y + x] stuff - void *fourier; //!< Data in fourier space; implementation dependent + p_psFFTDetails *details; ///< Details on FFT implementation (private) + int nx, ny; ///< Size in x and y + float *real; ///< Data in real space: a 2D array using the [nx*y + x] stuff + void *fourier; ///< Data in fourier space; implementation dependent } psFFT; /** Constructor */ psFFT * -psFFTAlloc(psImage *image //!< Image to transform +psFFTAlloc(psImage *image ///< Image to transform ); /** Constructor for 1D case */ psFFT * -psFFTAlloc1D(const psFloatArray *arr //!< Array to transform +psFFTAlloc1D(const psFloatArray *arr ///< Array to transform ); /** Destructor. Returns the data in the real space as an image. */ psImage * -psFFTFree(psImage *out, //!< Image to write the data to, or NULL - psFFT *restrict fft //!< FFT to destroy +psFFTFree(psImage *out, ///< Image to write the data to, or NULL + psFFT *restrict fft ///< FFT to destroy ); /** Forward FFT: from real to fourier space */ psFFT * -psFFTForward(psFFT *fft //!< FFT to apply (input and output) +psFFTForward(psFFT *fft ///< FFT to apply (input and output) ); /** Reverse FFT: from fourier to real space */ psFFT * -psFFTReverse(psFFT *fft //!< FFT to apply (input and output) +psFFTReverse(psFFT *fft ///< FFT to apply (input and output) ); /** Apply filter function in fourier space */ psFFT * -psFFTFilter(psFFT *fft, //!< FFT to use (input and output) - float (*filterFunc)(int kx, int ky) //!< External filter function +psFFTFilter(psFFT *fft, ///< FFT to use (input and output) + float (*filterFunc)(int kx, int ky) ///< External filter function ); /** Apply complex filter function */ psFFT * -psFFTFilterComplex(psFFT *fft, //!< FFT to use (input and output) - float (*realFilterFunc)(int kx, int ky), //!< External filter function, real part - float (*imagFilterFunc)(int kx, int ky) //!< External filter function, imaginary part +psFFTFilterComplex(psFFT *fft, ///< FFT to use (input and output) + float (*realFilterFunc)(int kx, int ky), ///< External filter function, real part + float (*imagFilterFunc)(int kx, int ky) ///< External filter function, imaginary part ); @@ -71,29 +71,29 @@ */ psFFT * -psFFTCrossCorrelate(psFFT *out //!< Output FFT (or NULL) - const psFFT *fft1, const psFFT *fft2 //!< FFTs to use in cross-correlation +psFFTCrossCorrelate(psFFT *out ///< Output FFT (or NULL) + const psFFT *fft1, const psFFT *fft2 ///< FFTs to use in cross-correlation ); /** Calculate FFT of the convolution. Straight multiplication of the FFTs */ psFFT * -psFFTConvolve(psFFT *out, //!< Output FFT (or NULL) - const psFFT *fft1, const psFFT *fft2 //!< FFTs to multiply +psFFTConvolve(psFFT *out, ///< Output FFT (or NULL) + const psFFT *fft1, const psFFT *fft2 ///< FFTs to multiply ); /** Calculate power spectrum */ psFloatArray * -psFFTPowerSpec(psFFT *fft //!< FFT to use (input and output) +psFFTPowerSpec(psFFT *fft ///< FFT to use (input and output) ); /* Convert the real data in the FFT struct to an image again */ psImage * -psFFTGetImage(psImage *out, //!< Image to write to (or NULL) - const psFFT *fft //!< FFT to get image from +psFFTGetImage(psImage *out, ///< Image to write to (or NULL) + const psFFT *fft ///< FFT to get image from ); /** Convert the Fourier transform data in the FFT struct to an image of complex numbers */ psImage * -psFFTGetFT(psImage *out, //!< Image to write to (or NULL) - const psFFT *fft //!< FFT to get Fourier transform from +psFFTGetFT(psImage *out, ///< Image to write to (or NULL) + const psFFT *fft ///< FFT to get Fourier transform from ); Index: /trunk/archive/pslib/include/psFunctions.h =================================================================== --- /trunk/archive/pslib/include/psFunctions.h (revision 343) +++ /trunk/archive/pslib/include/psFunctions.h (revision 344) @@ -10,7 +10,7 @@ is not a Gaussian deviate. The evaluated Gaussian is: \f[ exp(-\frac{(x-mean)^2}{2\sigma^2}) \f] */ float -psGaussian(float x, //!< Value at which to evaluate - float mean, //!< Mean for the Gaussian - float stddev //!< Standard deviation for the Gaussian +psGaussian(float x, ///< Value at which to evaluate + float mean, ///< Mean for the Gaussian + float stddev ///< Standard deviation for the Gaussian ); @@ -19,32 +19,32 @@ /** One-dimensional polynomial */ typedef struct { - int n; //!< Number of terms - float *restrict coeff; //!< Coefficients - float *restrict coeffErr; //!< Error in coefficients - char *restrict mask; //!< Coefficient mask + int n; ///< Number of terms + float *restrict coeff; ///< Coefficients + float *restrict coeffErr; ///< Error in coefficients + char *restrict mask; ///< Coefficient mask } psPolynomial1D; /** Two-dimensional polynomial */ typedef struct { - int nX, nY; //!< Number of terms in x and y - float *restrict *restrict coeff; //!< Coefficients - float *restrict *restrict coeffErr; //!< Error in coefficients - char *restrict *restrict mask; //!< Coefficients mask + int nX, nY; ///< Number of terms in x and y + float *restrict *restrict coeff; ///< Coefficients + float *restrict *restrict coeffErr; ///< Error in coefficients + char *restrict *restrict mask; ///< Coefficients mask } psPolynomial2D; /** Three-dimensional polynomial */ typedef struct { - int nX, nY, nZ; //!< Number of terms in x, y and z - float *restrict *restrict *restrict coeff; //!< Coefficients - float *restrict *restrict *restrict coeffErr; //!< Error in coefficients - char *restrict *restrict *restrict mask; //!< Coefficients mask + int nX, nY, nZ; ///< Number of terms in x, y and z + float *restrict *restrict *restrict coeff; ///< Coefficients + float *restrict *restrict *restrict coeffErr; ///< Error in coefficients + char *restrict *restrict *restrict mask; ///< Coefficients mask } psPolynomial3D; /** Four-dimensional polynomial */ typedef struct { - int nW, nX, nY, nZ; //!< Number of terms in w, x, y and z - float *restrict *restrict *restrict *restrict coeff; //!< Coefficients - float *restrict *restrict *restrict *restrict coeffErr; //!< Error in coefficients - char *restrict *restrict *restrict *restrict mask; //!< Coefficients mask + int nW, nX, nY, nZ; ///< Number of terms in w, x, y and z + float *restrict *restrict *restrict *restrict coeff; ///< Coefficients + float *restrict *restrict *restrict *restrict coeffErr; ///< Error in coefficients + char *restrict *restrict *restrict *restrict mask; ///< Coefficients mask } psPolynomial4D; @@ -56,58 +56,58 @@ /** Constructor */ -psPolynomial1D *psPolynomial1DAlloc(int n //!< Number of terms - ); -/** Constructor */ -psPolynomial2D *psPolynomial2DAlloc(int nX, int nY //!< Number of terms in x and y - ); -/** Constructor */ -psPolynomial3D *psPolynomial3DAlloc(int nX, int nY, int nZ //!< Number of terms in x, y and z - ); -/** Constructor */ -psPolynomial4D *psPolynomial4DAlloc(int nW, int nX, int nY, int nZ //!< Number of terms in w, x, y and z - ); - -/** Destructor */ -void psPolynomial1DFree(psPolynomial1D *restrict myPoly //!< Polynomial to destroy +psPolynomial1D *psPolynomial1DAlloc(int n ///< Number of terms + ); +/** Constructor */ +psPolynomial2D *psPolynomial2DAlloc(int nX, int nY ///< Number of terms in x and y + ); +/** Constructor */ +psPolynomial3D *psPolynomial3DAlloc(int nX, int nY, int nZ ///< Number of terms in x, y and z + ); +/** Constructor */ +psPolynomial4D *psPolynomial4DAlloc(int nW, int nX, int nY, int nZ ///< Number of terms in w, x, y and z + ); + +/** Destructor */ +void psPolynomial1DFree(psPolynomial1D *restrict myPoly ///< Polynomial to destroy ); /** Destructor */ -void psPolynomial2DFree(psPolynomial2D *restrict myPoly //!< Polynomial to destroy - ); -/** Destructor */ -void psPolynomial3DFree(psPolynomial3D *restrict myPoly //!< Polynomial to destroy - ); -/** Destructor */ -void psPolynomial4DFree(psPolynomial4D *restrict myPoly //!< Polynomial to destroy +void psPolynomial2DFree(psPolynomial2D *restrict myPoly ///< Polynomial to destroy + ); +/** Destructor */ +void psPolynomial3DFree(psPolynomial3D *restrict myPoly ///< Polynomial to destroy + ); +/** Destructor */ +void psPolynomial4DFree(psPolynomial4D *restrict myPoly ///< Polynomial to destroy ); /** Evaluate 1D polynomial */ float -psEvalPolynomial1D(float x, //!< Value at which to evaluate - const psPolynomial1D *restrict myPoly //!< Coefficients for the polynomial +psEvalPolynomial1D(float x, ///< Value at which to evaluate + const psPolynomial1D *restrict myPoly ///< Coefficients for the polynomial ); /** Evaluate 2D polynomial */ float -psEvalPolynomial2D(float x, //!< Value x at which to evaluate - float y, //!< Value y at which to evaluate - const psPolynomial2D *restrict myPoly //!< Coefficients for the polynomial +psEvalPolynomial2D(float x, ///< Value x at which to evaluate + float y, ///< Value y at which to evaluate + const psPolynomial2D *restrict myPoly ///< Coefficients for the polynomial ); /** Evaluate 3D polynomial */ float -psEvalPolynomial3D(float x, //!< Value x at which to evaluate - float y, //!< Value y at which to evaluate - float z, //!< Value z at which to evaluate - const psPolynomial3D *restrict myPoly //!< Coefficients for the polynomial +psEvalPolynomial3D(float x, ///< Value x at which to evaluate + float y, ///< Value y at which to evaluate + float z, ///< Value z at which to evaluate + const psPolynomial3D *restrict myPoly ///< Coefficients for the polynomial ); /** Evaluate 4D polynomial */ float -psEvalPolynomial4D(float w, //!< Value w at which to evaluate - float x, //!< Value x at which to evaluate - float y, //!< Value y at which to evaluate - float z, //!< Value z at which to evaluate - const psPolynomial4D *restrict myPoly //!< Coefficients for the polynomial +psEvalPolynomial4D(float w, ///< Value w at which to evaluate + float x, ///< Value x at which to evaluate + float y, ///< Value y at which to evaluate + float z, ///< Value z at which to evaluate + const psPolynomial4D *restrict myPoly ///< Coefficients for the polynomial ); @@ -120,32 +120,32 @@ /** Double-precision one-dimensional polynomial */ typedef struct { - int n; //!< Number of terms - double *restrict coeff; //!< Coefficients - double *restrict coeffErr; //!< Error in coefficients - char *restrict mask; //!< Coefficient mask + int n; ///< Number of terms + double *restrict coeff; ///< Coefficients + double *restrict coeffErr; ///< Error in coefficients + char *restrict mask; ///< Coefficient mask } psDPolynomial1D; /** Double-precision two-dimensional polynomial */ typedef struct { - int nX, nY; //!< Number of terms in x and y - double *restrict *restrict coeff; //!< Coefficients - double *restrict *restrict coeffErr; //!< Error in coefficients - char *restrict *restrict mask; //!< Coefficients mask + int nX, nY; ///< Number of terms in x and y + double *restrict *restrict coeff; ///< Coefficients + double *restrict *restrict coeffErr; ///< Error in coefficients + char *restrict *restrict mask; ///< Coefficients mask } psDPolynomial2D; /** Double-precision three-dimensional polynomial */ typedef struct { - int nX, nY, nZ; //!< Number of terms in x, y and z - double *restrict *restrict *restrict coeff; //!< Coefficients - double *restrict *restrict *restrict coeffErr; //!< Error in coefficients - char *restrict *restrict *restrict mask; //!< Coefficient mask + int nX, nY, nZ; ///< Number of terms in x, y and z + double *restrict *restrict *restrict coeff; ///< Coefficients + double *restrict *restrict *restrict coeffErr; ///< Error in coefficients + char *restrict *restrict *restrict mask; ///< Coefficient mask } psDPolynomial3D; /** Double-precision four-dimensional polynomial */ typedef struct { - int nW, nX, nY, nZ; //!< Number of terms in w, x, y and z - double *restrict *restrict *restrict *restrict coeff; //!< Coefficients - double *restrict *restrict *restrict *restrict coeffErr; //!< Error in coefficients - char *restrict *restrict *restrict *restrict mask; //!< Coefficients mask + int nW, nX, nY, nZ; ///< Number of terms in w, x, y and z + double *restrict *restrict *restrict *restrict coeff; ///< Coefficients + double *restrict *restrict *restrict *restrict coeffErr; ///< Error in coefficients + char *restrict *restrict *restrict *restrict mask; ///< Coefficients mask } psDPolynomial4D; @@ -156,28 +156,28 @@ /** Constructor */ -psDPolynomial1D *psDPolynomial1DAlloc(int n //!< Number of terms - ); -/** Constructor */ -psDPolynomial2D *psDPolynomial2DAlloc(int nX, int nY //!< Number of terms in x and y - ); -/** Constructor */ -psDPolynomial3D *psDPolynomial3DAlloc(int nX, int nY, int nZ //!< Number of terms in x, y and z - ); -/** Constructor */ -psDPolynomial4D *psDPolynomial4DAlloc(int nW, int nX, int nY, int nZ //!< Number of terms in w, x, y and z - ); - - -/** Destructor */ -void psDPolynomial1DFree(psDPolynomial1D *restrict myPoly //!< Polynomial to destroy - ); -/** Destructor */ -void psDPolynomial2DFree(psDPolynomial2D *restrict myPoly //!< Polynomial to destroy - ); -/** Destructor */ -void psDPolynomial3DFree(psDPolynomial3D *restrict myPoly //!< Polynomial to destroy - ); -/** Destructor */ -void psDPolynomial4DFree(psDPolynomial4D *restrict myPoly //!< Polynomial to destroy +psDPolynomial1D *psDPolynomial1DAlloc(int n ///< Number of terms + ); +/** Constructor */ +psDPolynomial2D *psDPolynomial2DAlloc(int nX, int nY ///< Number of terms in x and y + ); +/** Constructor */ +psDPolynomial3D *psDPolynomial3DAlloc(int nX, int nY, int nZ ///< Number of terms in x, y and z + ); +/** Constructor */ +psDPolynomial4D *psDPolynomial4DAlloc(int nW, int nX, int nY, int nZ ///< Number of terms in w, x, y and z + ); + + +/** Destructor */ +void psDPolynomial1DFree(psDPolynomial1D *restrict myPoly ///< Polynomial to destroy + ); +/** Destructor */ +void psDPolynomial2DFree(psDPolynomial2D *restrict myPoly ///< Polynomial to destroy + ); +/** Destructor */ +void psDPolynomial3DFree(psDPolynomial3D *restrict myPoly ///< Polynomial to destroy + ); +/** Destructor */ +void psDPolynomial4DFree(psDPolynomial4D *restrict myPoly ///< Polynomial to destroy ); @@ -185,30 +185,30 @@ /** Evaluate 1D polynomial (double precision) */ double -psEvalDPolynomial1D(double x, //!< Value at which to evaluate - const psDPolynomial1D *restrict myPoly //!< Coefficients for the polynomial +psEvalDPolynomial1D(double x, ///< Value at which to evaluate + const psDPolynomial1D *restrict myPoly ///< Coefficients for the polynomial ); /** Evaluate 2D polynomial (double precision) */ double -psEvalDPolynomial2D(double x, //!< Value x at which to evaluate - double y, //!< Value y at which to evaluate - const psDPolynomial2D *restrict myPoly //!< Coefficients for the polynomial +psEvalDPolynomial2D(double x, ///< Value x at which to evaluate + double y, ///< Value y at which to evaluate + const psDPolynomial2D *restrict myPoly ///< Coefficients for the polynomial ); /** Evaluate 3D polynomial (double precision) */ double -psEvalDPolynomial3D(double x, //!< Value x at which to evaluate - double y, //!< Value y at which to evaluate - double z, //!< Value z at which to evaluate - const psDPolynomial3D *restrict myPoly //!< Coefficients for the polynomial +psEvalDPolynomial3D(double x, ///< Value x at which to evaluate + double y, ///< Value y at which to evaluate + double z, ///< Value z at which to evaluate + const psDPolynomial3D *restrict myPoly ///< Coefficients for the polynomial ); /** Evaluate 4D polynomial (double precision) */ double -psEvalDPolynomial4D(double w, //!< Value w at which to evaluate - double x, //!< Value x at which to evaluate - double y, //!< Value y at which to evaluate - double z, //!< Value z at which to evaluate - const psDPolynomial4D *restrict myPoly //!< Coefficients for the polynomial +psEvalDPolynomial4D(double w, ///< Value w at which to evaluate + double x, ///< Value x at which to evaluate + double y, ///< Value y at which to evaluate + double z, ///< Value z at which to evaluate + const psDPolynomial4D *restrict myPoly ///< Coefficients for the polynomial ); Index: /trunk/archive/pslib/include/psImage.h =================================================================== --- /trunk/archive/pslib/include/psImage.h (revision 343) +++ /trunk/archive/pslib/include/psImage.h (revision 344) @@ -22,5 +22,5 @@ psF32 **rows_f32; ///< pointers to psF32 data psF64 **rows_f64; ///< pointers to psF64 data - psComplex **rows_complex; //!< pointers to psComplex data + psComplex **rows_complex; ///< pointers to psComplex data } rows; psImage *parent; ///< parent, if a subimage @@ -45,5 +45,5 @@ /// Create a subimage of the specified area. psImage * -psImageSubset(psImage *out, //!< Subimage to return, or NULL +psImageSubset(psImage *out, ///< Subimage to return, or NULL const psImage *image, ///< parent image int nx, ///< subimage width (<= image.nx - x0) @@ -60,5 +60,5 @@ /** Destroy the pixels of the specified image */ psImage * -psImageFreePixels(psImage *restrict image //!< Image whose pixels are to be freed +psImageFreePixels(psImage *restrict image ///< Image whose pixels are to be freed ); @@ -78,5 +78,5 @@ /// Extract pixels from rectlinear region to a vector. psFloatArray * -psImageSlice(psFloatArray *out, //!< Vector to output, or NULL +psImageSlice(psFloatArray *out, ///< Vector to output, or NULL const psImage *input, ///< extract slice from this image int x, ///< starting x coord of region to slice @@ -90,5 +90,5 @@ /// Extract pixels along a line to a vector. psFloatArray * -psImageCut(psFloatArray *out, //!< Vector to output, or NULL +psImageCut(psFloatArray *out, ///< Vector to output, or NULL const psImage *input, ///< extract cut from this image float xs, ///< starting x coord of cut @@ -102,5 +102,5 @@ /// Extract radial annulii data to a vector. psFloatArray * -psImageRadialCut(psFloatArray *out, //!< Vector to output, or NULL +psImageRadialCut(psFloatArray *out, ///< Vector to output, or NULL const psImage *input, ///< extract profile from this image float x, ///< center x coord of annulii @@ -115,5 +115,5 @@ /// Extract a 2-d contour from an image at the given threshold. psFloatArray * -psImageContour(psFloatArray *out, //!< Vector to output, or NULL +psImageContour(psFloatArray *out, ///< Vector to output, or NULL const psImage *input, ///< create contour for this image float threshold, ///< contour image at this threshold @@ -125,5 +125,5 @@ /// Rebin image to new scale. psImage * -psImageRebin(psImage *out, //!< Image to output, or NULL +psImageRebin(psImage *out, ///< Image to output, or NULL const psImage *input, ///< rebin this image float scale, ///< rebinning scale: doutput = scale*dinput @@ -133,5 +133,5 @@ /// Rotate image by given angle. psImage * -psImageRotate(psImage *out, //!< Image to output, or NULL +psImageRotate(psImage *out, ///< Image to output, or NULL const psImage *input, ///< rotate this image float angle ///< rotate by this amount anti-clockwise (degrees) @@ -141,5 +141,5 @@ /// Drop edge pixels, and set newly exposed pixels to 'exposed'. psImage * -psImageShift(psImage *out, //!< Image to output, or NULL +psImageShift(psImage *out, ///< Image to output, or NULL const psImage *input, ///< shift this image float dx, ///< shift by this amount in x @@ -151,5 +151,5 @@ /// Edge pixels wrap to the other side (no values are lost). psImage * -psImageRoll(psImage *out, //!< Image to output, or NULL +psImageRoll(psImage *out, ///< Image to output, or NULL const psImage *input, ///< roll this image int dx, ///< roll this amount in x @@ -249,5 +249,5 @@ /// Perform an FFT on the image. The output image type is psComplex. psImage * -psImageFFT(psImage *output, //!< Output image +psImageFFT(psImage *output, ///< Output image const psImage *input, ///< image to FFT int direction ///< FFT direction Index: /trunk/archive/pslib/include/psLogMsg.h =================================================================== --- /trunk/archive/pslib/include/psLogMsg.h (revision 343) +++ /trunk/archive/pslib/include/psLogMsg.h (revision 344) @@ -31,7 +31,7 @@ /* \} */ // End of SystemGroup Functions -enum { PS_LOG_ABORT = 0, PS_LOG_ERROR, PS_LOG_WARN, PS_LOG_INFO }; //!< Status codes for log messages +enum { PS_LOG_ABORT = 0, PS_LOG_ERROR, PS_LOG_WARN, PS_LOG_INFO }; ///< Status codes for log messages -enum { PS_LOG_NONE, PS_LOG_TO_STDERR, PS_LOG_TO_STDOUT }; //!< Destinations for log messages +enum { PS_LOG_NONE, PS_LOG_TO_STDERR, PS_LOG_TO_STDOUT }; ///< Destinations for log messages #endif Index: /trunk/archive/pslib/include/psMatrix.h =================================================================== --- /trunk/archive/pslib/include/psMatrix.h (revision 343) +++ /trunk/archive/pslib/include/psMatrix.h (revision 344) @@ -17,25 +17,25 @@ /** Invert matrix. Not using restrict, to allow inversion to be done in-place */ psImage * -psMatrixInvert(psImage *out, //!< Matrix to return, or NULL - const psImage *myMatrix, //!< Matrix to be inverted - float *restrict determinant //!< Determinant to return, or NULL +psMatrixInvert(psImage *out, ///< Matrix to return, or NULL + const psImage *myMatrix, ///< Matrix to be inverted + float *restrict determinant ///< Determinant to return, or NULL ); /** Matrix determinant */ float -psMatrixDeterminant(const psImage *restrict myMatrix //!< Matrix to get determinant for +psMatrixDeterminant(const psImage *restrict myMatrix ///< Matrix to get determinant for ); /** Matrix operation: addition, subtraction, multiplication */ psImage * -psMatrixOp(psImage *out, //!< Matrix to return, or NULL - const psImage *matrix1, //!< Matrix 1 - const psImage *matrix2 //!< Matrix 2 +psMatrixOp(psImage *out, ///< Matrix to return, or NULL + const psImage *matrix1, ///< Matrix 1 + const psImage *matrix2 ///< Matrix 2 ); /** Transpose Matrix */ psImage * -psMatrixTranspose(psImage *out, //!< Matrix to return, or NULL - const psImage *myMatrix //!< Matrix to transpose +psMatrixTranspose(psImage *out, ///< Matrix to return, or NULL + const psImage *myMatrix ///< Matrix to transpose ); @@ -46,12 +46,12 @@ /** Convert matrix to vector. Intended for a 1-d matrix. */ psVector * -psMatrixToVector(psVector *out, //!< Vector to return, or NULL - psImage *myMatrix //!< Matrix to convert +psMatrixToVector(psVector *out, ///< Vector to return, or NULL + psImage *myMatrix ///< Matrix to convert ); /** Convert vector to matrix. */ psImage * -psVectorToMatrix(psImage *out, //!< Matrix to return, or NULL - psVector *myVector //!< Vector to convert +psVectorToMatrix(psImage *out, ///< Matrix to return, or NULL + psVector *myVector ///< Vector to convert ); Index: /trunk/archive/pslib/include/psMemory.h =================================================================== --- /trunk/archive/pslib/include/psMemory.h (revision 343) +++ /trunk/archive/pslib/include/psMemory.h (revision 344) @@ -16,10 +16,10 @@ */ typedef struct { - const void *magic0; //!< initialised to p_psMEMMAGIC - const unsigned long id; //!< a unique ID for this allocation - const char *file; //!< set from __FILE__ in e.g. p_psAlloc - const int lineno; //!< set from __LINE__ in e.g. p_psAlloc - int refCounter; //!< how many times pointer is referenced - const void *magic; //!< initialised to p_psMEMMAGIC + const void *magic0; ///< initialised to p_psMEMMAGIC + const unsigned long id; ///< a unique ID for this allocation + const char *file; ///< set from __FILE__ in e.g. p_psAlloc + const int lineno; ///< set from __LINE__ in e.g. p_psAlloc + int refCounter; ///< how many times pointer is referenced + const void *magic; ///< initialised to p_psMEMMAGIC } psMemBlock; @@ -39,54 +39,54 @@ /// Memory allocation. Underlying private function called by macro psAlloc. -void *p_psAlloc(size_t size, //!< Size required - const char *file, //!< File of call - int lineno //!< Line number of call +void *p_psAlloc(size_t size, ///< Size required + const char *file, ///< File of call + int lineno ///< Line number of call ); /// Memory re-allocation. Underlying private function called by macro psRealloc. -void *p_psRealloc(void *ptr, //!< Pointer to re-allocate - size_t size, //!< Size required - const char *file, //!< File of call - int lineno //!< Line number of call +void *p_psRealloc(void *ptr, ///< Pointer to re-allocate + size_t size, ///< Size required + const char *file, ///< File of call + int lineno ///< Line number of call ); /// Free memory. Underlying private function called by macro psFree. -void p_psFree(void *ptr, //!< Pointer to free - const char *file, //!< File of call - int lineno //!< Line number of call +void p_psFree(void *ptr, ///< Pointer to free + const char *file, ///< File of call + int lineno ///< Line number of call ); /// Check for memory leaks -int psMemCheckLeaks(int id0, //!< don't list blocks with id < id0 - psMemBlock ***arr, //!< pointer to array of pointers to leaked blocks, or NULL - FILE *fd //!< print list of leaks to fd (or NULL) +int psMemCheckLeaks(int id0, ///< don't list blocks with id < id0 + psMemBlock ***arr, ///< pointer to array of pointers to leaked blocks, or NULL + FILE *fd ///< print list of leaks to fd (or NULL) ); /// Check for memory corruption -int psMemCheckCorruption(int abort_on_error //!< Abort on detecting corruption? +int psMemCheckCorruption(int abort_on_error ///< Abort on detecting corruption? ); /// Return reference counter -int psMemGetRefCounter(void *vptr //!< Pointer to get refCounter for +int psMemGetRefCounter(void *vptr ///< Pointer to get refCounter for ); /// Increment reference counter and return the pointer -void *psMemIncrRefCounter(void *vptr //!< Pointer to increment refCounter, and return +void *psMemIncrRefCounter(void *vptr ///< Pointer to increment refCounter, and return ); /// Decrement reference counter and return the pointer -void *psMemDecrRefCounter(void *vptr //!< Pointer to decrement refCounter, and return +void *psMemDecrRefCounter(void *vptr ///< Pointer to decrement refCounter, and return ); /// Set callback for problems -psMemProblemCallback psMemProblemSetCB(psMemProblemCallback func //!< Function to run +psMemProblemCallback psMemProblemSetCB(psMemProblemCallback func ///< Function to run ); /// Set callback for out-of-memory -psMemExhaustedCallback psMemExhaustedSetCB(psMemExhaustedCallback func //!< Function to run +psMemExhaustedCallback psMemExhaustedSetCB(psMemExhaustedCallback func ///< Function to run ); /// Set call back for when a particular memory block is allocated -psMemCallback psMemAllocateSetCB(psMemCallback func //!< Function to run +psMemCallback psMemAllocateSetCB(psMemCallback func ///< Function to run ); @@ -99,9 +99,9 @@ /// set p_psMemAllocateID to id -long psMemSetAllocateID(long id //!< ID to set +long psMemSetAllocateID(long id ///< ID to set ); /// set p_psMemFreeID to id -long psMemSetFreeID(long id //!< ID to set +long psMemSetFreeID(long id ///< ID to set ); Index: /trunk/archive/pslib/include/psMetaData.h =================================================================== --- /trunk/archive/pslib/include/psMetaData.h (revision 343) +++ /trunk/archive/pslib/include/psMetaData.h (revision 344) @@ -8,43 +8,43 @@ /** Possible types of metadata. */ -typedef enum { //!< type of val is: - PS_META_ITEM_SET = 0, //!< NULL; metadata is in psMetaDataType.items - PS_META_FLOAT, //!< float (.f) - PS_META_INT, //!< int (.i) - PS_META_STR, //!< string (.v) - PS_META_IMG, //!< image (.v) - PS_META_JPEG, //!< JPEG (.v) - PS_META_PNG, //!< PNG (.v) - PS_META_ASTROM, //!< astrometric coefficients (.v) - PS_META_UNKNOWN, //!< other (.v) - PS_META_NTYPE //!< Number of types; must be last +typedef enum { ///< type of val is: + PS_META_ITEM_SET = 0, ///< NULL; metadata is in psMetaDataType.items + PS_META_FLOAT, ///< float (.f) + PS_META_INT, ///< int (.i) + PS_META_STR, ///< string (.v) + PS_META_IMG, ///< image (.v) + PS_META_JPEG, ///< JPEG (.v) + PS_META_PNG, ///< PNG (.v) + PS_META_ASTROM, ///< astrometric coefficients (.v) + PS_META_UNKNOWN, ///< other (.v) + PS_META_NTYPE ///< Number of types; must be last } psMetaDataType; /** Metadata flags (not exclusive with psMetaDataType). */ typedef enum { - PS_META_TYPE_MASK = 0xffff, //!< the type enum must fit in this mask - PS_META_UNIQUE = 0x10000, //!< the name must be unique (default) - PS_META_NON_UNIQUE = 0x20000, //!< the name may be repeated, and should be disambiguated for us + PS_META_TYPE_MASK = 0xffff, ///< the type enum must fit in this mask + PS_META_UNIQUE = 0x10000, ///< the name must be unique (default) + PS_META_NON_UNIQUE = 0x20000, ///< the name may be repeated, and should be disambiguated for us } psMetaDataFlags; /** A struct to define a single item of metadata */ typedef struct { - const int id; //!< unique ID for this item - char *restrict name; //!< Name of item - psMetaDataType type; //!< type of this item - psMetaDataFlags flags; //!< flags associated with this item + const int id; ///< unique ID for this item + char *restrict name; ///< Name of item + psMetaDataType type; ///< type of this item + psMetaDataFlags flags; ///< flags associated with this item const union { - float f; //!< floating value - int i; //!< integer value - void *v; //!< other type - } val; //!< value of metadata - char *comment; //!< optional comment ("", not NULL) - psDlist *restrict items; //!< list of psMetaDataItems with the same name + float f; ///< floating value + int i; ///< integer value + void *v; ///< other type + } val; ///< value of metadata + char *comment; ///< optional comment ("", not NULL) + psDlist *restrict items; ///< list of psMetaDataItems with the same name } psMetaDataItem; /** A set of metadata */ typedef struct { - psDlist *restrict list; //!< list of psMetaDataItem - psHash *restrict table; //!< hash table of the same metadata + psDlist *restrict list; ///< list of psMetaDataItem + psHash *restrict table; ///< hash table of the same metadata } psMetaDataSet; @@ -55,21 +55,21 @@ /** Constructor */ -psMetaDataItem *psMetaDataItemAlloc(int typeFlags, //!< type of this piece of metadata + flags - const void *val, //!< value of new item N.b. a pointer even if the item - //!< is of type e.g. int - const char *comment, //!< comment associated with item - const char *name, //!< name of new item of metadata (may be in sprintf - //!< format) - ... //!< possible arguments for name format +psMetaDataItem *psMetaDataItemAlloc(int typeFlags, ///< type of this piece of metadata + flags + const void *val, ///< value of new item N.b. a pointer even if the item + ///< is of type e.g. int + const char *comment, ///< comment associated with item + const char *name, ///< name of new item of metadata (may be in sprintf + ///< format) + ... ///< possible arguments for name format ); /** Destructor */ -void psMetaDataItemFree(psMetaDataItem *ms //!< piece of metadata to destroy +void psMetaDataItemFree(psMetaDataItem *ms ///< piece of metadata to destroy ); /** Constructor */ -psMetaDataSet *psMetaDataSetAlloc(void); //!< make a new set of metadata +psMetaDataSet *psMetaDataSetAlloc(void); ///< make a new set of metadata /** Destructor */ -void psMetaDataSetFree(psMetaDataSet *ms //!< destroy a set of metadata +void psMetaDataSetFree(psMetaDataSet *ms ///< destroy a set of metadata ); @@ -77,31 +77,31 @@ /// Add entry to the end of the metadata set -psMetaDataItem *psMetaDataAppend(psMetaDataSet *restrict ms, //!< Metadata set to add to - psMetaDataItem *restrict item //!< Metatdata to add +psMetaDataItem *psMetaDataAppend(psMetaDataSet *restrict ms, ///< Metadata set to add to + psMetaDataItem *restrict item ///< Metatdata to add ); /// delete entry from the metadata set -psMetaDataItem *psMetaDataRemove(psMetaDataSet *restrict ms, //!< Metadata set to delete from - const char *restrict key //!< Key to delete +psMetaDataItem *psMetaDataRemove(psMetaDataSet *restrict ms, ///< Metadata set to delete from + const char *restrict key ///< Key to delete ); /// reset the iterator to the start of the list -void psMetaDataSetIterator(psMetaDataSet *ms //!< Metadata set to set iterator for +void psMetaDataSetIterator(psMetaDataSet *ms ///< Metadata set to set iterator for ); /// get the next entry in the sequence -psMetaDataItem *psMetaDataGetNext(psMetaDataSet *restrict ms, //!< Metadata set to get from - const char *restrict match //!< Match this +psMetaDataItem *psMetaDataGetNext(psMetaDataSet *restrict ms, ///< Metadata set to get from + const char *restrict match ///< Match this ); /// find the metadata with the specified key -psMetaDataItem *psMetaDataLookup(const psMetaDataSet *restrict ms, //!< Metadata set to look up - const char *restrict key //!< Key to find +psMetaDataItem *psMetaDataLookup(const psMetaDataSet *restrict ms, ///< Metadata set to look up + const char *restrict key ///< Key to find ); /// print metadata item to the specified stream -void psMetaDataItemPrint(FILE *fd, //!< file descriptor to write to - const psMetaDataItem *restrict ms, //!< item of metadata to print - const char *prefix //!< print this at the beginning of each line +void psMetaDataItemPrint(FILE *fd, ///< file descriptor to write to + const psMetaDataItem *restrict ms, ///< item of metadata to print + const char *prefix ///< print this at the beginning of each line ); /* \} */ // End of AstroGroup Functions Index: /trunk/archive/pslib/include/psMinimize.h =================================================================== --- /trunk/archive/pslib/include/psMinimize.h (revision 343) +++ /trunk/archive/pslib/include/psMinimize.h (revision 344) @@ -14,6 +14,6 @@ /** Minimize a particular non-linear function */ psFloatArray * -psMinimize(float (*myFunction)(const psFloatArray *restrict), //!< Function to minimize - psFloatArray *restrict initialGuess //!< Initial guess +psMinimize(float (*myFunction)(const psFloatArray *restrict), ///< Function to minimize + psFloatArray *restrict initialGuess ///< Initial guess ); @@ -22,18 +22,18 @@ psFloatArray * psMinimizeChi2(float (*evalModel)(const psFloatArray *restrict, - const psFloatArray *restrict), //!< Model to fit; (domain and params) - const psFloatArray *restrict domain, //!< The domain values for the corresponding measurements - const psFloatArray *restrict data, //!< Data to fit - const psFloatArray *restrict errors, //!< Errors in the data - psFloatArray *restrict initialGuess, //!< Initial guess - const psIntArray *restrict guessMask //!< 1 = fit for parameter, 0 = hold parameter constant + const psFloatArray *restrict), ///< Model to fit; (domain and params) + const psFloatArray *restrict domain, ///< The domain values for the corresponding measurements + const psFloatArray *restrict data, ///< Data to fit + const psFloatArray *restrict errors, ///< Errors in the data + psFloatArray *restrict initialGuess, ///< Initial guess + const psIntArray *restrict guessMask ///< 1 = fit for parameter, 0 = hold parameter constant ); /** Derive a polynomial fit by chi^2 minimisation --- can be done analytically */ psPolynomial1D * -psGetArrayPolynomial(psPolynomial1D myPoly, //!< Polynomial to fit - const psFloatArray *restrict x, //!< Ordinates (or NULL to just use the indices) - const psFloatArray *restrict y, //!< Coordinates - const psFloatArray *restrict yErr //!< Errors in coordinates, or NULL +psGetArrayPolynomial(psPolynomial1D myPoly, ///< Polynomial to fit + const psFloatArray *restrict x, ///< Ordinates (or NULL to just use the indices) + const psFloatArray *restrict y, ///< Coordinates + const psFloatArray *restrict yErr ///< Errors in coordinates, or NULL ); Index: /trunk/archive/pslib/include/psMisc.h =================================================================== --- /trunk/archive/pslib/include/psMisc.h (revision 343) +++ /trunk/archive/pslib/include/psMisc.h (revision 344) @@ -24,5 +24,5 @@ /// Allocates nChar and returns a copy of the string or segment char *psStringNCopy(const char *str, ///< string to copy - int nChar //!< Number of characters (including \0 ) + int nChar ///< Number of characters (including \0 ) ); Index: /trunk/archive/pslib/include/psObject.h =================================================================== --- /trunk/archive/pslib/include/psObject.h (revision 343) +++ /trunk/archive/pslib/include/psObject.h (revision 344) @@ -11,15 +11,15 @@ /** Object definition, to handle both objects we detect, and catalogues */ typedef struct { - psCoord *cell; //!< Centre position on Cell, with associated error - psCoord *sky; //!< Position on the sky, with associated error - float mag, magErr; //!< Magnitude and associated error - float isoMag, isoMagErr; //!< Isophotal magnitude and associated error - float fwhm, fwhmErr; //!< FWHM and associated error - float ellipA, ellipB; //!< Elliptical semi-major (A) and semi-minor (B) axes - float ellipAngle; //!< Ellipse position angle - float sky, skyErr; //!< Local sky level, and associated error - float colour, colourErr; //!< Colour and associated error, if known - psPhotSysrem colorPlus, colorMinus; //!< Colour reference - psBitMask *quality; //!< Bit mask for quality information + psCoord *cell; ///< Centre position on Cell, with associated error + psCoord *sky; ///< Position on the sky, with associated error + float mag, magErr; ///< Magnitude and associated error + float isoMag, isoMagErr; ///< Isophotal magnitude and associated error + float fwhm, fwhmErr; ///< FWHM and associated error + float ellipA, ellipB; ///< Elliptical semi-major (A) and semi-minor (B) axes + float ellipAngle; ///< Ellipse position angle + float sky, skyErr; ///< Local sky level, and associated error + float colour, colourErr; ///< Colour and associated error, if known + psPhotSysrem colorPlus, colorMinus; ///< Colour reference + psBitMask *quality; ///< Bit mask for quality information psCell *parentCell; ///< Cell this measurement came from } psObject; @@ -37,20 +37,20 @@ /** An assembly of objects */ typedef struct { - psType type; //!< Type of data. THIS STRUCT ELEMENT MUST BE FIRST IN THE STRUCT! - int size; //!< Total number of elements available - int n; //!< Number of elements in use - psObject *arr; //!< The array data + psType type; ///< Type of data. THIS STRUCT ELEMENT MUST BE FIRST IN THE STRUCT! + int size; ///< Total number of elements available + int n; ///< Number of elements in use + psObject *arr; ///< The array data } psObjectArray; /** Constructor */ -psObjectArray *psObjectArrayAlloc(int s, //!< Total number of elements to make available - int n //!< Number of elements that will be used +psObjectArray *psObjectArrayAlloc(int s, ///< Total number of elements to make available + int n ///< Number of elements that will be used ); /** Reallocator */ -psObjectArray *psObjectArrayRealloc(psObjectArray *myArray, //!< Array to reallocate - int s //!< Total number of elements to make available +psObjectArray *psObjectArrayRealloc(psObjectArray *myArray, ///< Array to reallocate + int s ///< Total number of elements to make available ); /** Destructor */ -void psObjectArrayFree(psObjectArray *restrict myArray //!< Array to free +void psObjectArrayFree(psObjectArray *restrict myArray ///< Array to free ); @@ -59,17 +59,17 @@ /** Associates objects on an image with the image */ typedef struct { - const struct psImage *image; //!< Image that produced the objects, which has metadata we need - psObjectArray *objects; //!< The objects + const struct psImage *image; ///< Image that produced the objects, which has metadata we need + psObjectArray *objects; ///< The objects } psImageObjects; /** Constructor */ psImageObjects * -psImageObjectsAlloc(const struct psImage *image, //!< Image that produced the objects, with needed metadata - psObjectArray *objects //!< The objects +psImageObjectsAlloc(const struct psImage *image, ///< Image that produced the objects, with needed metadata + psObjectArray *objects ///< The objects ); /** Destructor */ void -psImageObjectsFree(psImageObjects *restrict myImageObjects //!< Object to destroy +psImageObjectsFree(psImageObjects *restrict myImageObjects ///< Object to destroy ); @@ -78,17 +78,17 @@ /** Objects from a catalogue */ typedef struct { - psCatalogue catalogue; //!< Source catalogue from which objects come - psObjectArray *object; //!< The objects + psCatalogue catalogue; ///< Source catalogue from which objects come + psObjectArray *object; ///< The objects } psCatalogueObjects; /** Constructor */ psCatalogueObjects * -psCatalogueObjectsAlloc(enum psCatalogue *catalogue, //!< Source catalogue - psObjectArray *objects //!< The objects +psCatalogueObjectsAlloc(enum psCatalogue *catalogue, ///< Source catalogue + psObjectArray *objects ///< The objects ); /** Destructor */ void -psCatalogueObjectsFree(psCatalogueObjects *restrict myCatalogueObjects //!< Object to destroy +psCatalogueObjectsFree(psCatalogueObjects *restrict myCatalogueObjects ///< Object to destroy ); @@ -97,23 +97,23 @@ /** A "super" object --- an object with multiple detections in different images */ typedef struct { - const struct psImageArray *images; //!< Images that provided the different measurements - const psObjectArray *objects; //!< Individual object measurements + const struct psImageArray *images; ///< Images that provided the different measurements + const psObjectArray *objects; ///< Individual object measurements /* Derived quantities */ - psSkyPos *meanSkyPos; //!< Mean position on the sky - double pmRA, pmDec; //!< Proper motion in RA and Dec - double pmRAErr, pmDecErr; //!< Errors in proper motion - float posChi2; //!< chi^2 for position + psSkyPos *meanSkyPos; ///< Mean position on the sky + double pmRA, pmDec; ///< Proper motion in RA and Dec + double pmRAErr, pmDecErr; ///< Errors in proper motion + float posChi2; ///< chi^2 for position } psSuperObject; /** Constructor */ psSuperObject * -psSuperObjectAlloc(const struct psImageArray *images, //!< The images with the measurements - const psObjectArray *objects //!< Object measurements +psSuperObjectAlloc(const struct psImageArray *images, ///< The images with the measurements + const psObjectArray *objects ///< Object measurements ); /** Destructor */ void -psSuperObjectFree(psSuperObject *restrict mySuperObject //!< Object to destroy +psSuperObjectFree(psSuperObject *restrict mySuperObject ///< Object to destroy ); @@ -129,10 +129,10 @@ */ psIntArray * -psCorrelateObjects(const psObjectArray *restrict myObjects1, //!< First bunch of objects - const psObjectArray *restrict myObjects2, //!< Second bunch of objects - const psOTADescription *myOTA1, //!< OTA description for first bunch of objects, or NULL for - //!< sky - const psOTADescription *myOTA2 //!< OTA description for second bunch of objects, or NULL for - //!< sky +psCorrelateObjects(const psObjectArray *restrict myObjects1, ///< First bunch of objects + const psObjectArray *restrict myObjects2, ///< Second bunch of objects + const psOTADescription *myOTA1, ///< OTA description for first bunch of objects, or NULL for + ///< sky + const psOTADescription *myOTA2 ///< OTA description for second bunch of objects, or NULL for + ///< sky ); @@ -142,9 +142,9 @@ */ int -psGetCorrelatedMatches(const psIntArray matches, //!< Index array specifying matches */ - const psObjectArray *restrict myObjects1, //!< First bunch of objects - const psObjectArray *restrict myObjects2, //!< Second bunch of objects - psObjectArray *matched1, //!< Matched objects in first bunch - psObjectArray *matched2 //!< Matched objects in second bunch +psGetCorrelatedMatches(const psIntArray matches, ///< Index array specifying matches */ + const psObjectArray *restrict myObjects1, ///< First bunch of objects + const psObjectArray *restrict myObjects2, ///< Second bunch of objects + psObjectArray *matched1, ///< Matched objects in first bunch + psObjectArray *matched2 ///< Matched objects in second bunch ); @@ -155,23 +155,23 @@ /** Get objects within a particular magnitude range */ psObjectArray * -psSelectObjectMag(psObjectArray *restrict myArray, //!< Bunch of objects to select from - float magLower, //!< Lower bound for magnitude - float magUpper //!< Upper bound for magnitude +psSelectObjectMag(psObjectArray *restrict myArray, ///< Bunch of objects to select from + float magLower, ///< Lower bound for magnitude + float magUpper ///< Upper bound for magnitude ); /** Get objects within a radius on the sky */ psObjectArray * -psSelectObjectSkyDist(psObjectArray *restrict myArray, //!< Bunch of objects to select from - psSkyPos *skyPos, //!< Position on the sky - float radius, //!< Radius of search - int circleOrSquare //!< Circle = 1, Square = 2 +psSelectObjectSkyDist(psObjectArray *restrict myArray, ///< Bunch of objects to select from + psSkyPos *skyPos, ///< Position on the sky + float radius, ///< Radius of search + int circleOrSquare ///< Circle = 1, Square = 2 ); /** Get objects within a particular colour range */ psObjectArray * -psSelectObjectColour(psObjectArray *restrict myArray, //!< Bunch of objects to select from - float magLower, //!< Lower bound for colour - float magUpper, //!< Upper bound for colour - psColourRef colourRef //!< Only select those with this colour reference +psSelectObjectColour(psObjectArray *restrict myArray, ///< Bunch of objects to select from + float magLower, ///< Lower bound for colour + float magUpper, ///< Upper bound for colour + psColourRef colourRef ///< Only select those with this colour reference ); Index: /trunk/archive/pslib/include/psPhotom.h =================================================================== --- /trunk/archive/pslib/include/psPhotom.h (revision 343) +++ /trunk/archive/pslib/include/psPhotom.h (revision 344) @@ -15,19 +15,19 @@ /** photometry system definition */ typedef struct { - int ID; //!< ID number for this photometric system - char *name; //!< Name of photometric system - char *camera; //!< Camera for photometric system - char *filter; //!< Filter used for photometric system - char *detector; //!< Detector used for photometric system + int ID; ///< ID number for this photometric system + char *name; ///< Name of photometric system + char *camera; ///< Camera for photometric system + char *filter; ///< Filter used for photometric system + char *detector; ///< Detector used for photometric system } psPhotSystem; /** photometry transformations */ typedef struct { - psPhotSystem src; //!< Source photometric system - psPhotSystem dst; //!< Destination photometric system + psPhotSystem src; ///< Source photometric system + psPhotSystem dst; ///< Destination photometric system psPhotSystem pP, pM; ///< Primary colour reference psPhotSystem sP, sM; ///< Secondary colour reference float pA, sA; ///< Colour offset for primary and secondary references - psPolynomial3D transform; //!< Transformation from source to destination + psPolynomial3D transform; ///< Transformation from source to destination } psPhotTransform; Index: /trunk/archive/pslib/include/psPosition.h =================================================================== --- /trunk/archive/pslib/include/psPosition.h (revision 343) +++ /trunk/archive/pslib/include/psPosition.h (revision 344) @@ -13,14 +13,14 @@ typedef union { struct { - double x; //!< x position - double y; //!< y position - double xErr; //!< Error in x position - double yErr; //!< Error in y position + double x; ///< x position + double y; ///< y position + double xErr; ///< Error in x position + double yErr; ///< Error in y position } xy; struct { - double r; //!< RA - double d; //!< Dec - double rErr; //!< Error in RA - double dErr; //!< Error in Dec + double r; ///< RA + double d; ///< Dec + double rErr; ///< Error in RA + double dErr; ///< Error in Dec } rd; } psCoord; @@ -48,5 +48,5 @@ /** apply the coordinate transformation to the given coordinate */ -psCoord *psCoordXformApply (psCoord *out, //!< Output coordinates, or NULL +psCoord *psCoordXformApply (psCoord *out, ///< Output coordinates, or NULL const psCoordXform *frame, ///< coordinate transformation const psCoord *coords ///< input coordiate @@ -54,5 +54,5 @@ /** apply the optical distortion to the given coordinate, magnitude, color */ -psCoord *psDistortionApply (psCoord *out, //!< Output coordinates, or NULL +psCoord *psDistortionApply (psCoord *out, ///< Output coordinates, or NULL const psdistortion *pattern, ///< optical distortion pattern const psCoord *coords, ///< input coordinate @@ -63,14 +63,14 @@ /** Get offset (RA,Dec) on the sky between two positions position1 and position2 may not be identical */ psCoord * -psGetOffset(const psCoord *restrict position1, //!< Position 1 - const psCoord *restrict position2, //!< Position 2 - const char *type //!< Type of offset: Linear, Spherical/Arcsec, Spherical/Degreees etc +psGetOffset(const psCoord *restrict position1, ///< Position 1 + const psCoord *restrict position2, ///< Position 2 + const char *type ///< Type of offset: Linear, Spherical/Arcsec, Spherical/Degreees etc ); /** Apply an offset to a position */ psCoord * -psApplyOffset(const psCoord *restrict position, //!< Position - const psCoord *restrict offset, //!< Offset - const char *type //!< Type of offset: Linear, Spherical/Arcsec, Spherical/Degreees etc +psApplyOffset(const psCoord *restrict position, ///< Position + const psCoord *restrict offset, ///< Offset + const char *type ///< Type of offset: Linear, Spherical/Arcsec, Spherical/Degreees etc ); @@ -79,23 +79,23 @@ /** Get Sun Position */ psCoord * -psGetSunPos(float mjd //!< MJD to get position for +psGetSunPos(float mjd ///< MJD to get position for ); /** Get Moon position */ psCoord * -psGetMoonPos(float mjd, //!< MJD to get position for - double latitude, //!< Latitude for apparent position - double longitude //!< Longitude for apparent position +psGetMoonPos(float mjd, ///< MJD to get position for + double latitude, ///< Latitude for apparent position + double longitude ///< Longitude for apparent position ); /** Get Moon phase */ float -psGetMoonPhase(float mjd //!< MJD to get phase for +psGetMoonPhase(float mjd ///< MJD to get phase for ); /** Get Planet positions */ psCoord * -psGetSolarSystemPos(const char *solarSystemObject, //!< Named S.S. object - float mjd //!< MJD to get position for +psGetSolarSystemPos(const char *solarSystemObject, ///< Named S.S. object + float mjd ///< MJD to get position for ); @@ -106,20 +106,20 @@ /** Convert ICRS to Ecliptic */ psCoord * -psCoordinatesItoE(const psCoord *restrict coordinates //!< ICRS coordinates to convert +psCoordinatesItoE(const psCoord *restrict coordinates ///< ICRS coordinates to convert ); /** Convert Ecliptic to ICRS */ psCoord * -psCoordinatesEtoI(const psCoord *restrict coordinates //!< Ecliptic coordinates to convert +psCoordinatesEtoI(const psCoord *restrict coordinates ///< Ecliptic coordinates to convert ); /** Convert ICRS to Galactic */ psCoord * -psCoordinatesItoG(const psCoord *restrict coordinates //!< ICRS coordinates to convert +psCoordinatesItoG(const psCoord *restrict coordinates ///< ICRS coordinates to convert ); /** Convert Galactic to ICRS */ psCoord * -psCoordinatesGtoI(const psCoord *restrict coordinates //!< Galactic coordinates to convert +psCoordinatesGtoI(const psCoord *restrict coordinates ///< Galactic coordinates to convert ); Index: /trunk/archive/pslib/include/psSort.h =================================================================== --- /trunk/archive/pslib/include/psSort.h (revision 343) +++ /trunk/archive/pslib/include/psSort.h (revision 344) @@ -14,12 +14,12 @@ /** Sort an array. Inputs not restrict-ed to allow sort in place */ psFloatArray * -psSort(psFloatArray *out, //!< Sorted array to return. May be NULL - const psFloatArray *myArray //!< Array to sort +psSort(psFloatArray *out, ///< Sorted array to return. May be NULL + const psFloatArray *myArray ///< Array to sort ); /** Sort an array, along with some other stuff. Returns an index array */ psIntArray * -psSortIndex(psIntArray *restrict out, //!< Output index array (may be NULL) - const psFloatArray *restrict myArray //!< Array to sort +psSortIndex(psIntArray *restrict out, ///< Output index array (may be NULL) + const psFloatArray *restrict myArray ///< Array to sort ); Index: /trunk/archive/pslib/include/psStats.h =================================================================== --- /trunk/archive/pslib/include/psStats.h (revision 343) +++ /trunk/archive/pslib/include/psStats.h (revision 344) @@ -39,32 +39,32 @@ /** generic statistics structure */ typedef struct { - double sampleMean; //