Changeset 9537
- Timestamp:
- Oct 13, 2006, 10:46:29 AM (20 years ago)
- File:
-
- 1 edited
-
trunk/doc/pslib/psLibSDRS.tex (modified) (77 diffs)
Legend:
- Unmodified
- Added
- Removed
-
trunk/doc/pslib/psLibSDRS.tex
r9525 r9537 1 %%% $Id: psLibSDRS.tex,v 1.43 1 2006-10-13 00:30:38price Exp $1 %%% $Id: psLibSDRS.tex,v 1.432 2006-10-13 20:46:29 price Exp $ 2 2 \documentclass[panstarrs,spec]{panstarrs} 3 3 … … 276 276 277 277 \begin{prototype} 278 const char *psLibVersion(void);278 psString psLibVersion(void); 279 279 \end{prototype} 280 280 … … 735 735 psMemFreeCallback psMemFreeCallbackSet(psMemFreeCallback func); 736 736 psMemId psMemGetId(void); 737 psMemId psMemGetLastId(void); 737 738 \end{prototype} 738 739 % 739 740 The callback functions are called with a pointer to the corresponding 740 741 memory block. The routines \code{psMemFreeCallbackIDSet} and 741 \code{psMemAllocCallbackIDSet} accept the desired ID value and return the 742 old value to the user. The return values of the handlers installed by 743 \code{psMemAllocCallbackSet} and \code{psMemFreeCallbackSet} are 744 used to increment the values of \code{p_psMemAllocID} and 745 \code{p_psMemFreeID} respectively. For example, a return value of 746 \code{0} implies that the value is unchanged; if the value is \code{2} 747 the callback will be called again when the memory ID counter has 748 increased by two. This functionality may be useful to check, for 749 example, every 100th block allocated. The function \code{psMemGetId} 750 returns the next identification number to be assigned to a memory 751 block. This function can be used to guide the choice of ID set with 752 the functions above. 742 \code{psMemAllocCallbackIDSet} accept the desired ID value and return 743 the old value to the user. The return values of the handlers 744 installed by \code{psMemAllocCallbackSet} and 745 \code{psMemFreeCallbackSet} are used to increment the values of 746 \code{p_psMemAllocID} and \code{p_psMemFreeID} respectively. For 747 example, a return value of \code{0} implies that the value is 748 unchanged; if the value is \code{2} the callback will be called again 749 when the memory ID counter has increased by two. This functionality 750 may be useful to check, for example, every 100th block allocated. The 751 function \code{psMemGetId} returns the next identification number to 752 be assigned to a memory block, while \code{psMemGetLastId} returns the 753 last identification number to be assigned. These functions can be 754 used to guide the choice of ID set with the functions above. 753 755 754 756 \subsubsection{Memory Tracing and Corruption Checks} … … 794 796 argument \code{abort_on_error} is true, \code{psMemCheckCorruption} 795 797 must call \code{psAbort} as soon as memory corruption is detected. 798 799 \begin{prototype} 800 size_t psMemStats(const bool print, size_t *allocated, size_t *persistent, size_t *freelist); 801 \end{prototype} 802 803 \code{psMemStats} returns the total amount of memory consumed by 804 psLib. If \code{print} is \code{true}, also prints a summary of the 805 memory usage. If \code{allocated}, \code{persistent} or 806 \code{freelist} are non-\code{NULL}, the function returns in those 807 variables the amount of memory that's allocated and non-persistent, 808 allocated and persistent, or waiting to be recycled, respectively. 809 796 810 797 811 \subsubsection{Reference Counting} … … 818 832 psPtr psMemIncrRefCounter(const psPtr ptr); 819 833 psPtr psMemDecrRefCounter(psPtr ptr); 834 psPtr psMemSetRefCounter(psPtr ptr, psReferenceCount count); 820 835 \end{prototype} 821 836 % … … 824 839 If \code{vptr} is \code{NULL}, this function must return a value of 825 840 NULL. The next two functions increment or decrement the reference 826 counter, returning the pointer which was passed in. These functions 827 must validate the memory pointer by determining the corresponding 841 counter, returning the pointer which was passed in. The final 842 function explicitly sets the value of the reference counter (and 843 should therefore be used sparingly, if ever!). These functions must 844 validate the memory pointer by determining the corresponding 828 845 \code{psMemBlock.id} and checking for consistency in the internal 829 846 memory block table (the table pointer for \code{psMemBlock.id} must be … … 922 939 a string into \code{psAlloc}-ed memory: 923 940 \begin{prototype} 941 psString psStringAlloc(long nChar); 924 942 psString psStringCopy(const char *string); 925 943 psString psStringNCopy(const char *string, unsigned int nChar); 926 944 \end{prototype} 927 945 928 \code{psStringCopy} shall perform a deep copy of the \code{string} into 929 \code{psAlloc}-ed memory. \code{psStringNCopy} shall do the same, up to a 930 maximum of \code{nChar} characters. Both copy functions shall ``pass through'' 931 \code{NULL} values without generating an error. 946 \code{psStringAlloc} shall allocate a \code{psString} of length 947 \code{nChar}. \code{psStringCopy} shall perform a deep copy of the 948 \code{string} into a new \code{psString}. \code{psStringNCopy} shall 949 do the same, up to a maximum of \code{nChar} characters. Both copy 950 functions shall ``pass through'' \code{NULL} values without generating 951 an error. 932 952 933 953 We also specify two useful functions: 934 954 935 955 \begin{prototype} 936 ssize_t psStringAppend(char **dest, const char *format, ...) 937 ssize_t psStringPrepend(char **dest, const char *format, ...) 956 ssize_t psStringAppend(char **dest, const char *format, ...); 957 ssize_t psStringPrepend(char **dest, const char *format, ...); 958 ssize_t psStringAppendV(char **dest, const char *format, va_list va); 959 ssize_t psStringPrependV(char **dest, const char *format, va_list va); 938 960 \end{prototype} 939 961 … … 943 965 terminator) shall be returned. \code{psStringPrepend} shall do 944 966 similarly, except it shall prepend to the \code{dest} string. 967 \code{psStringAppendV} and \code{psStringPrependV} are the var-args 968 versions of these functions. 945 969 946 970 Other string manipulation functions are listed below. … … 948 972 \begin{prototype} 949 973 psList *psStringSplit(const char *string, const char *splitters, bool multipleAreSignificant); 974 psArray *psStringSplitArray(const char *string, const char *splitters, bool multipleAreSignificant); 950 975 \end{prototype} 951 976 … … 955 980 length should not be included in the output list if 956 981 \code{multipleAreSignificant} is \code{true}. 982 \code{psStringSplitArray} does the same, but returns the result as a 983 \code{psArray}. 957 984 958 985 String whitespace from head and tail of string: … … 1002 1029 bool psLineAdd(psLine *line, const char *format, ...); 1003 1030 \end{prototype} 1031 1032 \subsubsection{File Input} 1033 1034 To simplify the process of reading a file, we define: 1035 \begin{prototype} 1036 psString psSlurpFD(int fd); 1037 psString psSlurpFile(FILE *stream); 1038 \end{prototype} 1039 1040 \code{psSlurpFD} shall read the nominated file descriptor, \code{fd}, 1041 and return the contents as a \code{psString}. \code{psSlurpFile} does 1042 similarly, but based on a file \code{stream}. 1004 1043 1005 1044 \subsubsection{Type information} … … 1120 1159 bool psMemCheckImage(psPtr ptr); 1121 1160 bool psMemCheckKernel(psPtr ptr); 1161 bool psMemCheckLine(psPtr ptr); 1122 1162 bool psMemCheckList(psPtr ptr); 1123 1163 bool psMemCheckLookupTable(psPtr ptr); … … 1134 1174 bool psMemCheckPolynomial4D(psPtr ptr); 1135 1175 bool psMemCheckProjection(psPtr ptr); 1176 bool psMemCheckRegion(psPtr ptr); 1136 1177 bool psMemCheckScalar(psPtr ptr); 1137 1178 bool psMemCheckSphere(psPtr ptr); … … 1139 1180 bool psMemCheckSpline1D(psPtr ptr); 1140 1181 bool psMemCheckStats(psPtr ptr); 1182 bool psMemCheckString(psPtr ptr); 1141 1183 bool psMemCheckTime(psPtr ptr); 1142 1184 bool psMemCheckVector(psPtr ptr); … … 1351 1393 of the code is compiled. This can be implemented via macro front-ends 1352 1394 to private versions of the user APIs. In addition, a function 1353 \code{void psTraceReset(void)} will free memory used by \code{psTrace} 1354 functions, effectively resetting all trace levels to 0. 1395 \code{psTraceReset} will free memory used by \code{psTrace} 1396 functions, effectively resetting all trace levels to 0: 1397 \begin{prototype} 1398 void psTraceReset(void); 1399 \end{prototype} 1355 1400 1356 1401 The trace may optionally be written to a file or other output … … 1659 1704 \code{psErrorCodeLast} returns the last error code: 1660 1705 \begin{prototype} 1661 psErrorCode psErrorCodeLast(void) 1706 psErrorCode psErrorCodeLast(void); 1662 1707 \end{prototype} 1663 1708 … … 2027 2072 2028 2073 \begin{prototype} 2029 bool psArrayRemove(psArray *array, const psPtr data); 2030 \end{prototype} 2031 2032 This function removes all entries of \code{value} in the \code{array}, 2033 reducing the total number of elements of \code{array} as needed. 2074 bool psArrayRemoveData(psArray *array, const psPtr data); 2075 \end{prototype} 2076 2077 This function removes all entries of \code{data} in the \code{array},. 2034 2078 Returns \code{TRUE} if any elements were removed, otherwise 2035 2079 \code{FALSE}. 2080 2081 \begin{prototype} 2082 bool psArrayRemoveIndex(psArray *array, long index); 2083 \end{prototype} 2084 2085 This function removes the \code{array} element at the specified 2086 \code{index}, returning \code{true} upon success. 2036 2087 2037 2088 \begin{prototype} … … 2285 2336 2286 2337 \begin{prototype} 2287 bool psListRemove(psList *list, long location) 2338 bool psListRemove(psList *list, long location); 2288 2339 bool psListRemoveData(psList *list, psPtr data); 2289 2340 \end{prototype} … … 2533 2584 psBitSet *psBitSetSet(psBitSet *bitSet, long bit); 2534 2585 psBitSet* psBitSetClear(psBitSet *bitSet, long bit); 2535 psBitSet *psBitSetOp(psBitSet *outBitSet, const psBitSet *inBitSet1, const char *operator, const psBitSet *inBitSet2); 2586 psBitSet *psBitSetOp(psBitSet *outBitSet, const psBitSet *inBitSet1, 2587 const char *operator, const psBitSet *inBitSet2); 2536 2588 psBitSet *psBitSetNot(psBitSet *outBitSet, const psBitSet *inBitSet); 2537 2589 bool psBitSetTest(const psBitSet *bitSet, long bit); … … 2756 2808 psMetadataItem* psMetadataItemAllocF32(const char* name, const char* comment, psF32 value); 2757 2809 psMetadataItem* psMetadataItemAllocF64(const char* name, const char* comment, psF64 value); 2810 psMetadataItem* psMetadataItemAllocS8(const char* name, const char* comment, psS8 value); 2811 psMetadataItem* psMetadataItemAllocS16(const char* name, const char* comment, psS16 value); 2758 2812 psMetadataItem* psMetadataItemAllocS32(const char* name, const char* comment, psS32 value); 2813 psMetadataItem* psMetadataItemAllocS64(const char* name, const char* comment, psS64 value); 2814 psMetadataItem* psMetadataItemAllocU8(const char* name, const char* comment, psU8 value); 2815 psMetadataItem* psMetadataItemAllocU16(const char* name, const char* comment, psU16 value); 2816 psMetadataItem* psMetadataItemAllocU32(const char* name, const char* comment, psU32 value); 2817 psMetadataItem* psMetadataItemAllocU64(const char* name, const char* comment, psU64 value); 2759 2818 psMetadataItem* psMetadataItemAllocBool(const char* name, const char* comment, bool value); 2760 2819 psMetadataItem* psMetadataItemAllocPtr(const char* name, psDataType type, const char* comment, psPtr value); … … 2913 2972 are specified: 2914 2973 \begin{prototype} 2974 bool psMetadataAddPtr(psMetadata* md, long location, const char* name, psDataType type, 2975 const char* comment, psPtr value); 2915 2976 bool psMetadataAddStr(psMetadata* md, long location, const char* name, int format, 2916 2977 const char* comment, const char* value); … … 2923 2984 bool psMetadataAddBool(psMetadata* md, long location, const char* name, int format, 2924 2985 const char* comment, bool value); 2925 bool psMetadataAddPtr(psMetadata* md, long location, const char* name, psDataType type, 2926 const char* comment, psPtr value); 2986 bool psMetadataAddList(psMetadata* md, long location, const char* name, int format, 2987 const char* comment, psList *value); 2988 bool psMetadataAddVector(psMetadata* md, long location, const char* name, int format, 2989 const char* comment, psVector *value); 2990 bool psMetadataAddArray(psMetadata* md, long location, const char* name, int format, 2991 const char* comment, psArray *value); 2992 bool psMetadataAddImage(psMetadata* md, long location, const char* name, int format, 2993 const char* comment, psImage *value); 2994 bool psMetadataAddTime(psMetadata* md, long location, const char* name, int format, 2995 const char* comment, psTime *value); 2996 bool psMetadataAddHash(psMetadata* md, long location, const char* name, int format, 2997 const char* comment, psHash *value); 2998 bool psMetadataAddLookupTable(psMetadata* md, long location, const char* name, int format, 2999 const char* comment, psLookupTable *value); 3000 bool psMetadataAddMetadata(psMetadata* md, long location, const char* name, int format, 3001 const char* comment, psMetadata *value); 3002 bool psMetadataAddUnknown(psMetadata* md, long location, const char* name, int format, 3003 const char* comment, psPtr value); 2927 3004 \end{prototype} 2928 3005 … … 2955 3032 is set to reflect the success or failure of the lookup. 2956 3033 \begin{prototype} 2957 psString psMetadataLookupStr(bool *status, const psMetadata *md, const char *key); 3034 bool psMetadataLookupBool(bool *status, const psMetadata *md, const char *key); 3035 psS8 psMetadataLookupS8(bool *status, const psMetadata *md, const char *key); 3036 psS16 psMetadataLookupS16(bool *status, const psMetadata *md, const char *key); 2958 3037 psS32 psMetadataLookupS32(bool *status, const psMetadata *md, const char *key); 3038 psS64 psMetadataLookupS64(bool *status, const psMetadata *md, const char *key); 3039 psU8 psMetadataLookupU8(bool *status, const psMetadata *md, const char *key); 3040 psU16 psMetadataLookupU16(bool *status, const psMetadata *md, const char *key); 3041 psU32 psMetadataLookupU32(bool *status, const psMetadata *md, const char *key); 3042 psU64 psMetadataLookupU64(bool *status, const psMetadata *md, const char *key); 2959 3043 psF32 psMetadataLookupF32(bool *status, const psMetadata *md, const char *key); 2960 3044 psF64 psMetadataLookupF64(bool *status, const psMetadata *md, const char *key); 2961 bool psMetadataLookupBool(bool *status, const psMetadata *md, const char *key);2962 3045 psPtr psMetadataLookupPtr(bool *status, const psMetadata *md, const char *key); 3046 psString psMetadataLookupStr(bool *status, const psMetadata *md, const char *key); 3047 psMetadata *psMetadataLookupMetadata(bool *status, const psMetadata *md, const char *key); 2963 3048 \end{prototype} 2964 3049 … … 3079 3164 3080 3165 \begin{prototype} 3081 psMetadata *psMetadataConfigParse(psMetadata *md, unsigned int *nFail, const char *str, bool overwrite); 3082 psMetadata *psMetadataConfigRead(psMetadata *md, unsigned int *nFail, const char *filename, bool overwrite); 3166 psMetadata *psMetadataConfigParse(psMetadata *md, unsigned int *nFail, 3167 const char *str, bool overwrite); 3168 psMetadata *psMetadataConfigRead(psMetadata *md, unsigned int *nFail, 3169 const char *filename, bool overwrite); 3083 3170 \end{prototype} 3084 3171 … … 3378 3465 The constructor shall be: 3379 3466 \begin{prototype} 3380 psLookupTable *psLookupTableAlloc(const char *filename, ///< File from which to read 3381 const char *format, ///< scanf-like format string 3382 long indexCol ///< Column of the index vector (starting at zero) 3383 ); 3467 psLookupTable *psLookupTableAlloc(const char *filename, const char *format, 3468 long indexCol); 3384 3469 \end{prototype} 3385 3470 This function shall allocate a \code{psLookupTable}, and set the … … 3391 3476 3392 3477 \begin{prototype} 3393 psLookupTable *psLookupTableImport(psLookupTable *table, ///< Lookup table into which to import 3394 const psArray *vectors, ///< Array of vectors 3395 long indexCol ///< Index of the index vector in the array of vectors 3396 ); 3478 psLookupTable *psLookupTableImport(psLookupTable *table, const psArray *vectors, 3479 long indexCol); 3397 3480 \end{prototype} 3398 3481 \code{psLookupTableImport} shall import an array of vectors into a … … 3681 3764 the data range starting at \code{lower}, running to \code{upper}, in 3682 3765 steps of \code{delta}. The upper-end value is {\em exclusive}; the 3683 sequence is equivalent to \code{for (x = lower; x < upper; x += 3684 delta)}. 3766 sequence is equivalent to \code{for (x = lower; x < upper; x += delta)}. 3767 3768 \begin{prototype} 3769 psString psVectorToString(const psVector *vector); 3770 \end{prototype} 3771 3772 This function returns a string containing the values in the \code{vector}, 3773 separated by whitespace. This function is useful for testing and output. 3685 3774 3686 3775 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% … … 3755 3844 3756 3845 \begin{prototype} 3757 psImage* psImageRecycle( 3758 psImage* old, ///< the psImage to recycle by resizing image buffer 3759 int numCols, ///< the desired number of columns in image 3760 int numRows, ///< the desired number of rows in image 3761 const psElemType type ///< the desired datatype of the image 3762 ); 3846 psImage* psImageRecycle(psImage* old, int numCols, int numRows, const psElemType type); 3763 3847 \end{prototype} 3764 3848 \code{psImageRecycle} shall recycle the input \code{old} image, such … … 3906 3990 \subsection{XML Functions} 3907 3991 3992 \tbd{The XML code is currently disabled in psLib. Instead, we use the 3993 metadata config files as a transport mechanism.} 3994 3908 3995 Within Pan-STARRS, we will use XML documents as a transport mechanism 3909 3996 to carry data between programs and between IPP and other subsystems. … … 4091 4178 4092 4179 \begin{prototype} 4093 psArray *psDBSelectRows(psDB *dbh, const char *tableName, const psMetadata *where, unsigned long long limit); 4180 psArray *psDBSelectRows(psDB *dbh, const char *tableName, const psMetadata *where, 4181 unsigned long long limit); 4094 4182 \end{prototype} 4095 4183 … … 4145 4233 4146 4234 \begin{prototype} 4147 long psDBDeleteRows(psDB *dbh, const char *tableName, const psMetadata *where, unsigned long long limit); 4235 long psDBDeleteRows(psDB *dbh, const char *tableName, const psMetadata *where, 4236 unsigned long long limit); 4148 4237 \end{prototype} 4149 4238 … … 4154 4243 4155 4244 \begin{prototype} 4156 long psDBLastInsertID( 4157 psDB *dbh ///< Database handle 4158 ); 4245 long psDBLastInsertID(psDB *dbh); 4159 4246 \end{prototype} 4160 4247 4161 4248 Returns the last value created in an ``auto-increment'' field. 4249 4250 4251 \begin{prototype} 4252 psString psDBGenerateWhereConditionSQL(const psMetadata *where, const char *tableName); 4253 psString psDBGenerateWhereSQL(const psMetadata *where, const char *tableName); 4254 \end{prototype} 4255 4256 \code{psDBGenerateWhereConditionSQL} shall generate a SQL fragment 4257 consisting of the \code{WHERE} condition, based on the \code{where} 4258 metadata format. 4259 4260 \code{psDBGenerateWhereSQL} shall append ``where'' to the front of 4261 the SQL fragment returned by \code{psDBGenerateWhereConditionSQL}. 4162 4262 4163 4263 … … 4170 4270 4171 4271 \begin{prototype} 4172 bool psDBExplicitTrans( 4173 psDB *dbh, ///< Database handle 4174 bool mode ///< transactions enable/disable 4175 ); 4176 \end{prototype} 4177 4178 Enable/Disable explicit transactions. When enabled \code{psDBCommit()} must 4179 be called to make changes to the database's state persistent. 4180 4181 \begin{prototype} 4182 bool psDBTransaction( 4183 psDB *dbh ///< Database handle 4184 ); 4272 bool psDBExplicitTrans(psDB *dbh, bool mode); 4273 \end{prototype} 4274 4275 Enable/Disable explicit transactions (accordinte to \code{mode}). 4276 When enabled \code{psDBCommit()} must be called to make changes to the 4277 database's state persistent. 4278 4279 \begin{prototype} 4280 bool psDBTransaction(psDB *dbh); 4185 4281 \end{prototype} 4186 4282 … … 4188 4284 4189 4285 \begin{prototype} 4190 bool psDBCommit( 4191 psDB *dbh ///< Database handle 4192 ); 4286 bool psDBCommit(psDB *dbh); 4193 4287 \end{prototype} 4194 4288 … … 4196 4290 4197 4291 \begin{prototype} 4198 bool psDBRollback( 4199 psDB *dbh ///< Database handle 4200 ); 4292 bool psDBRollback(psDB *dbh); 4201 4293 \end{prototype} 4202 4294 … … 4212 4304 4213 4305 \begin{prototype} 4214 long p_psDBRunQueryPrepared( 4215 psDB *dbh, ///< Database handle 4216 const psArray *rowSet, ///< row data as psArray of psMetadata 4217 const char *format, ///< SQL string to execute 4218 ... 4219 ); 4306 long p_psDBRunQueryPrepared(psDB *dbh, const psArray *rowSet, 4307 const char *format, ...); 4220 4308 \end{prototype} 4221 4309 … … 4226 4314 4227 4315 \begin{prototype} 4228 psArray *p_psDBFetchResult( 4229 psDB *dbh ///< Database handle 4230 ); 4316 psArray *p_psDBFetchResult(psDB *dbh); 4231 4317 \end{prototype} 4232 4318 … … 4449 4535 \code{psF32}, \code{psF64}). The user is expected to convert the data 4450 4536 type as needed with \code{psImageCopy}. 4537 4538 \begin{prototype} 4539 psImage *psFitsReadImageBuffer(psImage *output, const psFits *fits, 4540 psRegion region, int z); 4541 \end{prototype} 4542 As for \code{psFitsReadImage}, but read into the extant 4543 \code{output} image. 4451 4544 4452 4545 \begin{prototype} … … 4502 4595 psArray *psFitsReadImageCube(const psFits *fits, psRegion region); 4503 4596 bool psFitsUpdateImageCube(psFits *fits, const psArray *input, int x0, int y0); 4504 bool psFitsWriteImageCube(psFits *fits, psMetadata *header, const psArray 4505 *input,const char *extname);4506 bool psFitsInsertImageCube(psFits *fits, psMetadata *header, const psArray 4507 *input,const char *extname, bool after);4597 bool psFitsWriteImageCube(psFits *fits, psMetadata *header, const psArray *input, 4598 const char *extname); 4599 bool psFitsInsertImageCube(psFits *fits, psMetadata *header, const psArray *input, 4600 const char *extname, bool after); 4508 4601 \end{prototype} 4509 4602 … … 4723 4816 4724 4817 \begin{prototype} 4725 psStats *psVectorStats(psStats *stats, 4726 const psVector *in, 4727 const psVector *errors, 4728 const psVector *mask, 4729 psMaskType maskVal); 4818 psStats *psVectorStats(psStats *stats, const psVector *in, const psVector *errors, 4819 const psVector *mask, psMaskType maskVal); 4730 4820 \end{prototype} 4731 4821 % … … 4914 5004 values. It alters and returns the histogram \code{out} structure. 4915 5005 \begin{prototype} 4916 psHistogram *psVectorHistogram(psHistogram *out, 4917 const psVector *values, 4918 const psVector *errors, 4919 const psVector *mask, 5006 psHistogram *psVectorHistogram(psHistogram *out, const psVector *values, 5007 const psVector *errors, const psVector *mask, 4920 5008 psMaskType maskVal); 4921 5009 \end{prototype} … … 4997 5085 To evaluate the polynomials at specific coordinates, we define: 4998 5086 \begin{prototype} 4999 psF64 psPolynomial1DEval(const psPolynomial1D *poly, 5000 psF64 x); 5001 psF64 psPolynomial2DEval(const psPolynomial2D *poly, 5002 psF64 x, 5003 psF64 y); 5004 psF64 psPolynomial3DEval(const psPolynomial3D *poly, 5005 psF64 x, 5006 psF64 y, 5007 psF64 z); 5008 psF64 psPolynomial4DEval(const psPolynomial4D *poly, 5009 psF64 x, 5010 psF64 y, 5011 psF64 z, 5012 psF64 t); 5087 psF64 psPolynomial1DEval(const psPolynomial1D *poly, psF64 x); 5088 psF64 psPolynomial2DEval(const psPolynomial2D *poly, psF64 x, psF64 y); 5089 psF64 psPolynomial3DEval(const psPolynomial3D *poly, psF64 x, psF64 y, psF64 z); 5090 psF64 psPolynomial4DEval(const psPolynomial4D *poly, psF64 x, psF64 y, psF64 z, psF64 t); 5013 5091 \end{prototype} 5014 5092 5015 5093 In the event that several evaluations are required, we also define: 5016 5094 \begin{prototype} 5017 psVector *psPolynomial1DEvalVector(const psPolynomial1D *poly, 5018 const psVector *x); 5019 psVector *psPolynomial2DEvalVector(const psPolynomial2D *poly, 5020 const psVector *x, 5095 psVector *psPolynomial1DEvalVector(const psPolynomial1D *poly, const psVector *x); 5096 psVector *psPolynomial2DEvalVector(const psPolynomial2D *poly, const psVector *x, 5021 5097 const psVector *y); 5022 psVector *psPolynomial3DEvalVector(const psPolynomial3D *poly, 5023 const psVector *x, 5024 const psVector *y, 5025 const psVector *z); 5026 psVector *psPolynomial4DEvalVector(const psPolynomial4D *poly, 5027 const psVector *x, 5028 const psVector *y, 5029 const psVector *z, 5098 psVector *psPolynomial3DEvalVector(const psPolynomial3D *poly, const psVector *x, 5099 const psVector *y, const psVector *z); 5100 psVector *psPolynomial4DEvalVector(const psPolynomial4D *poly, const psVector *x, 5101 const psVector *y, const psVector *z, 5030 5102 const psVector *t); 5031 5103 \end{prototype} … … 5037 5109 evaluation, those coefficients that have the corresponding \code{mask} 5038 5110 element non-zero shall not be evaluated. 5111 5112 \subsubsubsection{Conversion to Metadata} 5113 5114 In order to facilitate storing polynomials in metadata configuration 5115 files, we supply functions to convert between polynomials and 5116 metadata containers. 5117 5118 \begin{prototype} 5119 psPOlynomial2D *psPolynomial2DfromMetadata(psMetadata *folder); 5120 psPOlynomial3D *psPolynomial3DfromMetadata(psMetadata *folder); 5121 psPOlynomial4D *psPolynomial4DfromMetadata(psMetadata *folder); 5122 psPOlynomial2D *psPolynomial2DtoMetadata(psMetadata *md, 5123 const psPolynomial2D *poly, 5124 const char *format, ...); 5125 psPOlynomial3D *psPolynomial3DtoMetadata(psMetadata *md, 5126 const psPolynomial3D *poly, 5127 const char *format, ...); 5128 psPOlynomial4D *psPolynomial4DtoMetadata(psMetadata *md, 5129 const psPolynomial4D *poly, 5130 const char *format, ...); 5131 \end{prototype} 5132 5133 The \code{psPolynomial?DfromMetadata} functions shall create a 5134 \code{psMetadata} folder with \code{psPolynomial?D} information. The 5135 first two elements of the metadata folder shall specify the order of 5136 the x and y variables, \code{NORDER_X}, \code{NORDER_Y}, etc. The 5137 following elements shall be the values of the coefficients and the 5138 coefficient errors (i.e., \code{VAL_X00_Y00}, \code{ERR_X00_Y00}, 5139 etc.). The input polynomial must be of ordinary type and have a valid 5140 name format. \code{false} is returned if any inputs are \code{NULL}. 5141 If a particular mask element is non-zero, that polynomial coefficient 5142 (and error) are skipped. 5143 5144 The \code{psPolynomial?DtoMetadata} functions shall parse a psMetadata 5145 container with \code{psPolynomial?D} information. The first three 5146 elements of the metadata folder specify the order of the x, y, & z 5147 variables. (i.e., \code{NORDER_X}, \code{NORDER_Y}, etc.). The 5148 following elements are the values of the coefficients and the 5149 coefficient errors. (i.e., \code{VAL_X00_Y00}, \code{ERR_X00_Y00}, 5150 etc.). If the orders or any coefficients are missing or have 5151 incorrect syntax, \code{NULL} is returned. 5039 5152 5040 5153 \subsubsection{Splines} … … 5193 5306 5194 5307 \begin{prototype} 5195 bool psMinimizeLMChi2(psMinimization *min, 5196 psImage *covar, 5197 psVector *params, 5198 psMinConstrain *constrain, 5199 const psArray *x, 5200 const psVector *y, 5201 const psVector *yWt, 5308 bool psMinimizeLMChi2(psMinimization *min, psImage *covar, psVector *params, 5309 psMinConstrain *constrain, const psArray *x, 5310 const psVector *y, const psVector *yWt, 5202 5311 psMinimizeLMChi2Func func); 5203 5312 \end{prototype} … … 5242 5351 5243 5352 \begin{prototype} 5244 bool psMinimizeGaussNewtonDelta(psVector *delta, 5245 const psVector *params, 5246 const psVector *paramMask, 5247 const psArray *x, 5248 const psVector *y, 5249 const psVector *yErr, 5353 bool psMinimizeGaussNewtonDelta(psVector *delta, const psVector *params, 5354 const psVector *paramMask, const psArray *x, 5355 const psVector *y, const psVector *yErr, 5250 5356 psMinimizeLMChi2Func func); 5251 5357 \end{prototype} … … 5275 5381 5276 5382 \begin{prototype} 5277 bool psMinimizePowell(psMinimization *min, 5278 psVector *params, 5279 const psVector *paramMask, 5280 const psArray *coords, 5281 psMinimizePowellFunc func); 5383 bool psMinimizePowell(psMinimization *min, psVector *params, const psVector *paramMask, 5384 const psArray *coords, psMinimizePowellFunc func); 5282 5385 \end{prototype} 5283 5386 … … 5296 5399 5297 5400 \begin{prototype} 5298 bool psMinimizeChi2Powell(psMinimization *min, 5299 psVector *params, 5300 psMinConstrain *constrain, 5301 const psArray *coords, 5302 const psVector *value, 5303 const psVector *error, 5401 bool psMinimizeChi2Powell(psMinimization *min, psVector *params, 5402 psMinConstrain *constrain, const psArray *coords, 5403 const psVector *value, const psVector *error, 5304 5404 psMinimizeChi2PowellFunc model); 5305 5405 \end{prototype} … … 5333 5433 5334 5434 \begin{prototype} 5335 psPolynomial1D *psVectorFitPolynomial1D(psPolynomial1D *poly, 5336 const psVector *mask, 5337 psMaskType maskValue, 5338 const psVector *f, 5339 const psVector *fErr, 5340 const psVector *x); 5341 psPolynomial2D *psVectorFitPolynomial2D(psPolynomial2D *poly, 5342 const psVector *mask, 5343 psMaskType maskValue, 5344 const psVector *f, 5345 const psVector *fErr, 5346 const psVector *x, 5435 psPolynomial1D *psVectorFitPolynomial1D(psPolynomial1D *poly, const psVector *mask, 5436 psMaskType maskValue, const psVector *f, 5437 const psVector *fErr, const psVector *x); 5438 psPolynomial2D *psVectorFitPolynomial2D(psPolynomial2D *poly, const psVector *mask, 5439 psMaskType maskValue, const psVector *f, 5440 const psVector *fErr, const psVector *x, 5347 5441 const psVector *y); 5348 psPolynomial3D *psVectorFitPolynomial3D(psPolynomial3D *poly, 5349 const psVector *mask, 5350 psMaskType maskValue, 5351 const psVector *f, 5352 const psVector *fErr, 5353 const psVector *x, 5354 const psVector *y, 5355 const psVector *z); 5356 psPolynomial4D *psVectorFitPolynomial4D(psPolynomial4D *poly, 5357 const psVector *mask, 5358 psMaskType maskValue, 5359 const psVector *f, 5360 const psVector *fErr, 5361 const psVector *x, 5362 const psVector *y, 5363 const psVector *z, 5442 psPolynomial3D *psVectorFitPolynomial3D(psPolynomial3D *poly, const psVector *mask, 5443 psMaskType maskValue, const psVector *f, 5444 const psVector *fErr, const psVector *x, 5445 const psVector *y, const psVector *z); 5446 psPolynomial4D *psVectorFitPolynomial4D(psPolynomial4D *poly, const psVector *mask, 5447 psMaskType maskValue, const psVector *f, 5448 const psVector *fErr, const psVector *x, 5449 const psVector *y, const psVector *z, 5364 5450 const psVector *t); 5365 5451 \end{prototype} … … 5380 5466 5381 5467 \begin{prototype} 5382 psPolynomial1D *psVectorClipFitPolynomial1D(psPolynomial1D *poly, 5383 psStats *stats, 5384 const psVector *mask, 5385 psMaskType maskValue, 5386 const psVector *f, 5387 const psVector *fErr, 5388 const psVector *x); 5389 psPolynomial2D *psVectorClipFitPolynomial2D(psPolynomial2D *poly, 5390 psStats *stats, 5391 const psVector *mask, 5392 psMaskType maskValue, 5393 const psVector *f, 5394 const psVector *fErr, 5395 const psVector *x, 5396 const psVector *y); 5468 psPolynomial1D *psVectorClipFitPolynomial1D(psPolynomial1D *poly, psStats *stats, 5469 const psVector *mask, psMaskType maskValue, 5470 const psVector *f, const psVector *fErr, 5471 const psVector *x); 5472 psPolynomial2D *psVectorClipFitPolynomial2D(psPolynomial2D *poly, psStats *stats, 5473 const psVector *mask, psMaskType maskValue, 5474 const psVector *f, const psVector *fErr, 5475 const psVector *x, const psVector *y); 5397 5476 psPolynomial3D *psVectorClipFitPolynomial3D(psPolynomial3D *poly, 5398 psStats *stats, 5399 const psVector *mask, 5400 psMaskType maskValue, 5401 const psVector *f, 5402 const psVector *fErr, 5403 const psVector *x, 5404 const psVector *y, 5405 const psVector *z); 5406 psPolynomial4D *psVectorClipFitPolynomial4D(psPolynomial4D *poly, 5407 psStats *stats, 5408 const psVector *mask, 5409 psMaskType maskValue, 5410 const psVector *f, 5411 const psVector *fErr, 5412 const psVector *x, 5413 const psVector *y, 5414 const psVector *z, 5415 const psVector *t); 5477 psStats *stats, const psVector *mask, 5478 psMaskType maskValue, const psVector *f, 5479 const psVector *fErr, const psVector *x, 5480 const psVector *y, const psVector *z); 5481 psPolynomial4D *psVectorClipFitPolynomial4D(psPolynomial4D *poly, psStats *stats, 5482 const psVector *mask, psMaskType maskValue, 5483 const psVector *f, const psVector *fErr, 5484 const psVector *x, const psVector *y, 5485 const psVector *z, const psVector *t); 5416 5486 \end{prototype} 5417 5487 These functions replicate the capability of the vector fitting … … 5443 5513 5444 5514 \begin{prototype} 5445 psPolynomial4D *psVectorChiClipFitPolynomial4D( 5446 psPolynomial4D *poly, 5447 psStats *stats, 5448 const psVector *mask, 5449 psMaskType maskValue, 5450 const psVector *f, 5451 const psVector *fErr, 5452 const psVector *x, 5453 const psVector *y, 5454 const psVector *z, 5455 const psVector *t); 5515 psPolynomial4D *psVectorChiClipFitPolynomial4D(psPolynomial4D *poly, psStats *stats, 5516 const psVector *mask, psMaskType maskValue, 5517 const psVector *f, const psVector *fErr, 5518 const psVector *x, const psVector *y, 5519 const psVector *z, const psVector *t); 5456 5520 \end{prototype} 5457 5521 … … 5546 5610 5547 5611 \begin{prototype} 5548 psVector *psImageRow(psVector *out, 5549 const psImage *input, 5550 int row); 5551 psVector *psImageCol(psVector *out, 5552 const psImage *input, 5553 int column); 5612 psVector *psImageRow(psVector *out, const psImage *input, int row); 5613 psVector *psImageCol(psVector *out, const psImage *input, int column); 5554 5614 \end{prototype} 5555 5615 … … 5563 5623 5564 5624 \begin{prototype} 5565 psVector *psImageSlice(psVector *out, 5566 psPixels *coords, 5567 const psImage *input, 5568 const psImage *mask, 5569 psMaskType maskVal, 5570 psRegion region, 5571 psImageCutDirection direction, 5572 const psStats *stats); 5625 psVector *psImageSlice(psVector *out, psPixels *coords, const psImage *input, 5626 const psImage *mask, psMaskType maskVal, psRegion region, 5627 psImageCutDirection direction, const psStats *stats); 5573 5628 \end{prototype} 5574 5629 Extract pixels from a rectilinear region to a vector (array of … … 5600 5655 5601 5656 \begin{prototype} 5602 psVector *psImageCut(psVector *out, 5603 psVector *cutCols, 5604 psVector *cutRows, 5605 const psImage *input, 5606 const psImage *mask, 5607 psMaskType maskVal, 5608 psPlane *start, 5609 psPlane *stop, 5610 unsigned int nSamples, 5657 psVector *psImageCut(psVector *out, psVector *cutCols, psVector *cutRows, 5658 const psImage *input, const psImage *mask, psMaskType maskVal, 5659 psPlane *start, psPlane *stop, unsigned int nSamples, 5611 5660 psImageInterpolateMode mode); 5612 5661 \end{prototype} … … 5627 5676 5628 5677 \begin{prototype} 5629 psVector *psImageRadialCut(psVector *out, 5630 const psImage *input, 5631 const psImage *mask, 5632 psMaskType maskVal, 5633 float x, 5634 float y, 5635 const psVector *radii, 5678 psVector *psImageRadialCut(psVector *out, const psImage *input, const psImage *mask, 5679 psMaskType maskVal, float x, float y, const psVector *radii, 5636 5680 const psStats *stats); 5637 5681 \end{prototype} … … 5680 5724 5681 5725 \begin{prototype} 5682 psImage *psImageRebin(psImage *out, const psImage *in, 5683 const psImage *mask, 5684 psMaskType maskVal, 5685 int scale, const psStats *stats); 5726 psImage *psImageRebin(psImage *out, const psImage *in, const psImage *mask, 5727 psMaskType maskVal, int scale, const psStats *stats); 5686 5728 \end{prototype} 5687 5729 Rebin image to new scale. A new image is constructed in which the … … 5728 5770 5729 5771 \begin{prototype} 5730 psImage *psImageShift(psImage *out, const psImage *input, 5731 float dx, float dy,double complex exposed, psImageInterpolateMode mode);5772 psImage *psImageShift(psImage *out, const psImage *input, float dx, float dy, 5773 double complex exposed, psImageInterpolateMode mode); 5732 5774 \end{prototype} 5733 5775 Shift image by an arbitrary number of pixels (\code{dx,dy}) in either … … 5752 5794 5753 5795 \begin{prototype} 5754 psImage *psImageTransform(psImage *output, 5755 psPixels **blankPixels, 5756 const psImage *input, 5757 const psImage *inputMask, 5758 psMaskType inputMaskVal, 5759 const psPlaneTransform *outToIn, 5760 psRegion region, 5761 const psPixels *pixels, 5762 psImageInterpolateMode mode, 5796 psImage *psImageTransform(psImage *output, psPixels **blankPixels, const psImage *input, 5797 const psImage *inputMask, psMaskType inputMaskVal, 5798 const psPlaneTransform *outToIn, psRegion region, 5799 const psPixels *pixels, psImageInterpolateMode mode, 5763 5800 double exposedValue); 5764 5801 \end{prototype} … … 5803 5840 5804 5841 \begin{prototype} 5805 psStats *psImageStats(psStats *stats, 5806 const psImage *in, 5807 const psImage *mask, 5808 psMaskType maskVal); 5842 psStats *psImageStats(psStats *stats, const psImage *in, 5843 const psImage *mask, psMaskType maskVal); 5809 5844 \end{prototype} 5810 5845 Determine statistics for image (or subimage). The statistics to be … … 5816 5851 5817 5852 \begin{prototype} 5818 psHistogram *psImageHistogram(psHistogram *out, 5819 const psImage *in, 5820 const psImage *mask, 5821 psMaskType maskVal); 5853 psHistogram *psImageHistogram(psHistogram *out, const psImage *in, 5854 const psImage *mask, psMaskType maskVal); 5822 5855 \end{prototype} 5823 5856 Construct a histogram from an image (or subimage). The histogram to … … 5870 5903 5871 5904 \begin{prototype} 5872 psStats *psImageBackground(const psImage *image, // Image for which to get the background 5873 const psImage *mask, // Mask image 5874 psMaskType maskValue, // Mask pixels which this mask value 5875 double fmin, // Fraction to return in the lower quartile field (0.25 for LQ) 5876 double fmax, // Fraction to return in the upper quartile field (0.75 for LQ) 5877 long nMax, // Maximum number of pixels to subsample 5878 psRandom *rng // Random number generator (for pixel selection) 5879 ); 5905 psStats *psImageBackground(const psImage *image, const psImage *mask, 5906 psMaskType maskValue, double fmin, double fmax, 5907 long nMax, psRandom *rng); 5880 5908 \end{prototype} 5881 5909 \code{psImageBackground} shall measure the median background level for … … 6038 6066 6039 6067 \begin{prototype} 6040 psImage *psPixelsToMask(psImage *out, const psPixels *pixels, psRegion region, psMaskType maskVal); 6068 psImage *psPixelsToMask(psImage *out, const psPixels *pixels, psRegion region, 6069 psMaskType maskVal); 6041 6070 psPixels *psPixelsFromMask(psPixels *out, const psImage *mask, psMaskType maskVal); 6042 6071 \end{prototype} … … 6213 6242 \begin{prototype} 6214 6243 psImage *psMatrixLUD(psImage *out, psVector **perm, const psImage *in); 6215 psVector *psMatrixLUSolve(psVector *out, const psImage *LU, const psVector *RHS, const psVector *perm); 6244 psVector *psMatrixLUSolve(psVector *out, const psImage *LU, const psVector *RHS, 6245 const psVector *perm); 6216 6246 \end{prototype} 6217 6247 The above functions decompose a matrix, \code{in}, into its $LU$ … … 6229 6259 standard manner. In order to avoid memory leaks, \code{perm} must be 6230 6260 \code{NULL} on calling \code{psMatrixLUD}. 6261 6262 \begin{prototype} 6263 bool psMatrixGJSolve(psImage *A, psVector *b); 6264 \end{prototype} 6265 This function solves the matrix equation $Ax = b$ for $x$ using the 6266 Gauss-Jordan method. On completion, the input matrix has been 6267 inverted, and the input vector contains the solution, $x$. The 6268 function is specified for data type \code{F64} only. 6231 6269 6232 6270 \begin{prototype} … … 6547 6585 image, \code{out}. The API shall be the following: 6548 6586 \begin{prototype} 6549 psImage *psImageConvolve(psImage *out, const psImage *in, const psKernel *kernel, bool direct); 6587 psImage *psImageConvolve(psImage *out, const psImage *in, 6588 const psKernel *kernel, bool direct); 6550 6589 \end{prototype} 6551 6590 … … 7201 7240 % 7202 7241 \begin{prototype} 7203 psPlane *psPlaneTransformApply(psPlane *out, 7204 const psPlaneTransform *transform, 7242 psPlane *psPlaneTransformApply(psPlane *out, const psPlaneTransform *transform, 7205 7243 const psPlane *coords); 7206 psPlane *psPlaneDistortApply(psPlane *out, 7207 const psPlaneDistort *distort, 7208 const psPlane *coords, 7209 float mag, float color); 7244 psPlane *psPlaneDistortApply(psPlane *out, const psPlaneDistort *distort, 7245 const psPlane *coords, float mag, float color); 7210 7246 \end{prototype} 7211 7247 … … 7268 7304 7269 7305 \begin{prototype} 7270 psPlane *psPlaneTransformDeriv(psPlane *out, const psPlaneTransform *transformation, const psPlane *coord); 7306 psPlane *psPlaneTransformDeriv(psPlane *out, const psPlaneTransform *transformation, 7307 const psPlane *coord); 7271 7308 \end{prototype} 7272 7309 … … 7281 7318 7282 7319 \begin{prototype} 7283 psPixels *psPixelsTransform(psPixels *out, const psPixels *input, const psPlaneTransform *inToOut); 7320 psPixels *psPixelsTransform(psPixels *out, const psPixels *input, 7321 const psPlaneTransform *inToOut); 7284 7322 \end{prototype} 7285 7323 … … 7348 7386 not be normalized. 7349 7387 7388 \begin{prototype} 7389 psSphereRot *psSphereRotConjugate(psSphereRot *out, const psSphereRot *in); 7390 \end{prototype} 7391 This function shall return the conjugate of the \code{in} rotation, 7392 and store it in the \code{out} rotation, if non-\code{NULL}. 7393 7350 7394 Spherical coordinates may be transformed by providing the 7351 7395 transformation and the coordinate in the input system to … … 7354 7398 7355 7399 \begin{prototype} 7356 psSphere *psSphereRotApply(psSphere *out, const psSphereRot *transform, const psSphere *coord); 7400 psSphere *psSphereRotApply(psSphere *out, const psSphereRot *transform, 7401 const psSphere *coord); 7357 7402 \end{prototype} 7358 7403 … … 7363 7408 7364 7409 \begin{prototype} 7365 psSphereRot *psSphereRotCombine(psSphereRot *out, const psSphereRot *rot1, const psSphereRot *rot2) 7410 psSphereRot *psSphereRotCombine(psSphereRot *out, const psSphereRot *rot1, 7411 const psSphereRot *rot2); 7366 7412 \end{prototype} 7367 7413 … … 7369 7415 7370 7416 \begin{prototype} 7371 psSphereRot *psSphereRotInvert(psSphereRot *rot) 7417 psSphereRot *psSphereRotInvert(psSphereRot *rot); 7372 7418 \end{prototype} 7373 7419 … … 7395 7441 7396 7442 \begin{prototype} 7397 psSphere *psSphereGetOffset(const psSphere *position1, 7398 const psSphere *position2, 7399 psSphereOffsetMode mode, 7400 psSphereOffsetUnit unit); 7401 7402 psSphere *psSphereSetOffset(const psSphere *position, 7403 const psSphere *offset, 7404 psSphereOffsetMode mode, 7405 psSphereOffsetUnit unit); 7443 psSphere *psSphereGetOffset(const psSphere *position1, const psSphere *position2, 7444 psSphereOffsetMode mode, psSphereOffsetUnit unit); 7445 psSphere *psSphereSetOffset(const psSphere *position, const psSphere *offset, 7446 psSphereOffsetMode mode, psSphereOffsetUnit unit); 7406 7447 \end{prototype} 7407 7448 … … 7497 7538 observer, represented as a speed and a direction: 7498 7539 \begin{prototype} 7499 psSphere *psAberration(psSphere *apparent, const psSphere *actual, const psSphere *direction, double speed); 7540 psSphere *psAberration(psSphere *apparent, const psSphere *actual, 7541 const psSphere *direction, double speed); 7500 7542 \end{prototype} 7501 7543 The \code{actual} and \code{apparent} positions are represented as … … 7556 7598 % 7557 7599 \begin{prototype} 7558 psEarthPole *psEOC_PrecessionModel(const psTime *time) 7600 psEarthPole *psEOC_PrecessionModel(const psTime *time); 7559 7601 \end{prototype} 7560 7602 % … … 7576 7618 generated by providing the polar coordinate to the following function: 7577 7619 \begin{prototype} 7578 psSphereRot *psSphereRot_CEOtoGCRS(const psEarthPole *pole) 7620 psSphereRot *psSphereRot_CEOtoGCRS(const psEarthPole *pole); 7579 7621 \end{prototype} 7580 7622 This function constructs the rotation element as described in the ADD ( … … 7587 7629 The following routine calculates the rotation of the Earth about the CIP: 7588 7630 \begin{prototype} 7589 psSphereRot *psSphereRot_TEOtoCEO(const psTime *time, psEarthPole *tidalCorr) 7631 psSphereRot *psSphereRot_TEOtoCEO(const psTime *time, psEarthPole *tidalCorr); 7590 7632 \end{prototype} 7591 7633 The IERS code to create the comparable rotation is embedded in … … 7769 7811 The constructor is straight-forward: 7770 7812 \begin{prototype} 7771 psProjection *psProjectionAlloc(double R, double D, double Xs, double Ys, psProjectionType type); 7772 \end{prototype} 7773 where the units of \code{R} and \code{D} are radians, while \code{Xs} and \code{Ys} are in radians per pixel. 7813 psProjection *psProjectionAlloc(double R, double D, double Xs, double Ys, 7814 psProjectionType type); 7815 \end{prototype} 7816 where the units of \code{R} and \code{D} are radians, while \code{Xs} 7817 and \code{Ys} are in radians per pixel. 7774 7818 7775 7819 The following functions will project and deproject (respectively)
Note:
See TracChangeset
for help on using the changeset viewer.
