WCSLIB: dis.h Source File

WCSLIB 5.17

dis.h
Go to the documentation of this file.
1 /*============================================================================
2
3 WCSLIB 5.17 - an implementation of the FITS WCS standard.
4 Copyright (C) 1995-2017, Mark Calabretta
5
6 This file is part of WCSLIB.
7
8 WCSLIB is free software: you can redistribute it and/or modify it under the
9 terms of the GNU Lesser General Public License as published by the Free
10 Software Foundation, either version 3 of the License, or (at your option)
11 any later version.
12
13 WCSLIB is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
15 FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for
16 more details.
17
18 You should have received a copy of the GNU Lesser General Public License
19 along with WCSLIB. If not, see http://www.gnu.org/licenses.
20
21 Direct correspondence concerning WCSLIB to mark@calabretta.id.au
22
23 Author: Mark Calabretta, Australia Telescope National Facility, CSIRO.
24 http://www.atnf.csiro.au/people/Mark.Calabretta
25 $Id: dis.h,v 5.17 2017/09/18 08:44:23 mcalabre Exp $
26 *=============================================================================
27 *
28 * WCSLIB 5.17 - C routines that implement the FITS World Coordinate System
29 * (WCS) standard. Refer to the README file provided with WCSLIB for an
30 * overview of the library.
31 *
32 *
33 * Summary of the dis routines
34 * ---------------------------
35 * Routines in this suite implement extensions to the FITS World Coordinate
36 * System (WCS) standard proposed by
37 *
38 = "Representations of distortions in FITS world coordinate systems",
39 = Calabretta, M.R. et al. (WCS Paper IV, draft dated 2004/04/22),
40 = available from http://www.atnf.csiro.au/people/Mark.Calabretta
41 *
42 * In brief, a distortion function may occupy one of two positions in the WCS
43 * algorithm chain. Prior distortions precede the linear transformation
44 * matrix, whether it be PCi_ja or CDi_ja, and sequent distortions follow it.
45 * WCS Paper IV defines FITS keywords used to specify parameters for predefined
46 * distortion functions. The following are used for prior distortions:
47 *
48 = CPDISja ...(string-valued, identifies the distortion function)
49 = DPja ...(record-valued, parameters)
50 = CPERRja ...(floating-valued, maximum value)
51 *
52 * Their counterparts for sequent distortions are CQDISia, DQia, and CQERRia.
53 * An additional floating-valued keyword, DVERRa, records the maximum value of
54 * the combined distortions.
55 *
56 * DPja and DQia are "record-valued". Syntactically, the keyvalues are
57 * standard FITS strings, but they are to be interpreted in a special way.
58 * The general form is
59 *
60 = DPja = '<field-specifier>: <float>'
61 *
62 * where the field-specifier consists of a sequence of fields separated by
63 * periods, and the ': ' between the field-specifier and the floating-point
64 * value is part of the record syntax. For example:
65 *
66 = DP1 = 'AXIS.1: 1'
67 *
68 * Certain field-specifiers are defined for all distortion functions, while
69 * others are defined only for particular distortions. Refer to WCS Paper IV
70 * for further details. wcspih() parses all distortion keywords and loads them
71 * into a disprm struct for analysis by disset() which knows (or possibly does
72 * not know) how to interpret them. Of the Paper IV distortion functions, only
73 * the general Polynomial distortion is currently implemented here.
74 *
75 * TPV - the TPV "projection":
76 * ---------------------------
77 * The distortion function component of the TPV celestial "projection" is also
78 * supported. The TPV projection, originally proposed in a draft of WCS Paper
79 * II, consists of a TAN projection with sequent polynomial distortion, the
80 * coefficients of which are encoded in PVi_ma keyrecords. Full details may be
81 * found at the registry of FITS conventions:
82 *
83 = http://fits.gsfc.nasa.gov/registry/tpvwcs/tpv.html
84 *
85 * Internally, wcsset() changes TPV to a TAN projection, translates the PVi_ma
86 * keywords to DQia and loads them into a disprm struct. These DQia keyrecords
87 * have the form
88 *
89 = DQia = 'TPV.m: <value>'
90 *
91 * where i, a, m, and the value for each DQia match each PVi_ma. Consequently,
92 * WCSLIB would handle a FITS header containing these keywords, along with
93 * CQDISia = 'TPV' and the required DQia.NAXES and DQia.AXIS.ihat keywords.
94 *
95 * SIP - Simple Imaging Polynomial:
96 * --------------------------------
97 * These routines also support the Simple Imaging Polynomial (SIP), whose
98 * design was influenced by early drafts of WCS Paper IV. It is described in
99 * detail in
100 *
101 = http://fits.gsfc.nasa.gov/registry/sip.html
102 *
103 * SIP, which is defined only as a prior distortion for 2-D celestial images,
104 * has the interesting feature that it records an approximation to the inverse
105 * polynomial distortion function. This is used by disx2p() to provide an
106 * initial estimate for its more precise iterative inversion. The
107 * special-purpose keywords used by SIP are parsed and translated by wcspih()
108 * as follows:
109 *
110 = A_p_q = <value> -> DP1 = 'SIP.FWD.p_q: <value>'
111 = AP_p_q = <value> -> DP1 = 'SIP.REV.p_q: <value>'
112 = B_p_q = <value> -> DP2 = 'SIP.FWD.p_q: <value>'
113 = BP_p_q = <value> -> DP2 = 'SIP.REV.p_q: <value>'
114 = A_DMAX = <value> -> DPERR1 = <value>
115 = B_DMAX = <value> -> DPERR2 = <value>
116 *
117 * SIP's A_ORDER and B_ORDER keywords are not used. WCSLIB would recognise a
118 * FITS header containing the above keywords, along with CPDISja = 'SIP' and
119 * the required DPja.NAXES keywords.
120 *
121 * DSS - Digitized Sky Survey:
122 * ---------------------------
123 * The Digitized Sky Survey resulted from the production of the Guide Star
124 * Catalogue for the Hubble Space Telescope. Plate solutions based on a
125 * polynomial distortion function were encoded in FITS using non-standard
126 * keywords. Sect. 5.2 of WCS Paper IV describes how DSS coordinates may be
127 * translated to a sequent Polynomial distortion using two auxiliary variables.
128 * That translation is based on optimising the non-distortion component of the
129 * plate solution.
130 *
131 * Following Paper IV, wcspih() translates the non-distortion component of DSS
132 * coordinates to standard WCS keywords (CRPIXja, PCi_ja, CRVALia, etc), and
133 * fills a wcsprm struct with their values. It encodes the DSS polynomial
134 * coefficients as
135 *
136 = AMDXm = <value> -> DQ1 = 'AMD.m: <value>'
137 = AMDYm = <value> -> DQ2 = 'AMD.m: <value>'
138 *
139 * WCSLIB would recognise a FITS header containing the above keywords, along
140 * with CQDISia = 'DSS' and the required DQia.NAXES keywords.
141 *
142 * WAT - the TNX and ZPX "projections":
143 * ------------------------------------
144 * The TNX and ZPX "projections" add a polynomial distortion function to the
145 * standard TAN and ZPN projections respectively. Unusually, the polynomial
146 * may be expressed as the sum of Chebyshev or Legendre polynomials, or as a
147 * simple sum of monomials, as described in
148 *
149 = http://fits.gsfc.nasa.gov/registry/tnx/tnx-doc.html
150 = http://fits.gsfc.nasa.gov/registry/zpxwcs/zpx.html
151 *
152 * The polynomial coefficients are encoded in special-purpose WATi_n keywords
153 * as a set of continued strings, thus providing the name for this distortion
154 * type. WATi_n are parsed and translated by wcspih() into the following set:
155 *
156 = DQi = 'WAT.POLY: <value>'
157 = DQi = 'WAT.XMIN: <value>'
158 = DQi = 'WAT.XMAX: <value>'
159 = DQi = 'WAT.YMIN: <value>'
160 = DQi = 'WAT.YMAX: <value>'
161 = DQi = 'WAT.CHBY.m_n: <value>' or
162 = DQi = 'WAT.LEGR.m_n: <value>' or
163 = DQi = 'WAT.MONO.m_n: <value>'
164 *
165 * along with CQDISia = 'WAT' and the required DPja.NAXES keywords. For ZPX,
166 * the ZPN projection parameters are also encoded in WATi_n, and wcspih()
167 * translates these to standard PVi_ma.
168 *
169 * TPD - Template Polynomial Distortion:
170 * -------------------------------------
171 * The "Template Polynomial Distortion" (TPD) is a superset of the TPV, SIP,
172 * DSS, and WAT (TNX & ZPX) polynomial distortions that also supports 1-D usage
173 * and inversions. Like TPV, SIP, and DSS, the form of the polynomial is fixed
174 * (the "template") and only the coefficients for the required terms are set
175 * non-zero. TPD generalizes TPV in going to 9th degree, SIP by accomodating
176 * TPV's linear and radial terms, and DSS in both respects. While in theory
177 * the degree of the WAT polynomial distortion in unconstrained, in practice it
178 * is limited to values that can be handled by TPD.
179 *
180 * Within WCSLIB, TPV, SIP, DSS, and WAT are all implemented as special cases
181 * of TPD. Indeed, TPD was developed precisely for that purpose. WAT
182 * distortions expressed as the sum of Chebyshev or Legendre polynomials are
183 * expanded for TPD as a simple sum of monomials. Moreover, the general
184 * Polynomial distortion is translated and implemented internally as TPD
185 * whenever possible.
186 *
187 * However, WCSLIB also recognizes 'TPD' as a distortion function in its own
188 * right (i.e. a recognized value of CPDISja or CQDISia), for use as both prior
189 * and sequent distortions. Its DPja and DQia keyrecords have the form
190 *
191 = DPja = 'TPD.FWD.m: <value>'
192 = DPja = 'TPD.REV.m: <value>'
193 *
194 * for the forward and reverse distortion functions. Moreover, like the
195 * general Polynomial distortion, TPD supports auxiliary variables, though only
196 * as a linear transformation of pixel coordinates (p1,p2):
197 *
198 = x = a0 + a1*p1 + a2*p2
199 = y = b0 + b1*p1 + b2*p2
200 *
201 * where the coefficients of the auxiliary variables (x,y) are recorded as
202 *
203 = DPja = 'AUX.1.COEFF.0: a0' ...default 0.0
204 = DPja = 'AUX.1.COEFF.1: a1' ...default 1.0
205 = DPja = 'AUX.1.COEFF.2: a2' ...default 0.0
206 = DPja = 'AUX.2.COEFF.0: b0' ...default 0.0
207 = DPja = 'AUX.2.COEFF.1: b1' ...default 0.0
208 = DPja = 'AUX.2.COEFF.2: b2' ...default 1.0
209 *
210 * Though nowhere near as powerful, in typical applications TPD is considerably
211 * faster than the general Polynomial distortion. As TPD has a finite and not
212 * too large number of possible terms (60), the coefficients for each can be
213 * stored (by disset()) in a fixed location in the disprm::dparm[] array. A
214 * large part of the speedup then arises from evaluating the polynomial using
215 * Horner's scheme.
216 *
217 * Separate implementations for polynomials of each degree, and conditionals
218 * for 1-D polynomials and 2-D polynomials with and without the radial
219 * variable, ensure that unused terms mostly do not impose a significant
220 * computational overhead.
221 *
222 * The TPD terms are as follows
223 *
224 = 0: 1 4: xx 12: xxxx 24: xxxxxx 40: xxxxxxxx
225 = 5: xy 13: xxxy 25: xxxxxy 41: xxxxxxxy
226 = 1: x 6: yy 14: xxyy 26: xxxxyy 42: xxxxxxyy
227 = 2: y 15: xyyy 27: xxxyyy 43: xxxxxyyy
228 = 3: r 7: xxx 16: yyyy 28: xxyyyy 44: xxxxyyyy
229 = 8: xxy 29: xyyyyy 45: xxxyyyyy
230 = 9: xyy 17: xxxxx 30: yyyyyy 46: xxyyyyyy
231 = 10: yyy 18: xxxxy 47: xyyyyyyy
232 = 11: rrr 19: xxxyy 31: xxxxxxx 48: yyyyyyyy
233 = 20: xxyyy 32: xxxxxxy
234 = 21: xyyyy 33: xxxxxyy 49: xxxxxxxxx
235 = 22: yyyyy 34: xxxxyyy 50: xxxxxxxxy
236 = 23: rrrrr 35: xxxyyyy 51: xxxxxxxyy
237 = 36: xxyyyyy 52: xxxxxxyyy
238 = 37: xyyyyyy 53: xxxxxyyyy
239 = 38: yyyyyyy 54: xxxxyyyyy
240 = 39: rrrrrrr 55: xxxyyyyyy
241 = 56: xxyyyyyyy
242 = 57: xyyyyyyyy
243 = 58: yyyyyyyyy
244 = 59: rrrrrrrrr
245 *
246 * where r = sqrt(xx + yy). Note that even powers of r are excluded since they
247 * can be accomodated by powers of (xx + yy).
248 *
249 * TPV uses all terms up to 39. The m in its PVi_ma keywords translates
250 * directly to the TPD coefficient number.
251 *
252 * SIP uses all terms except for 0, 3, 11, 23, 39, and 59, with terms 1 and 2
253 * only used for the inverse. Its A_p_q, etc. keywords must be translated
254 * using a map.
255 *
256 * DSS uses terms 0, 1, 2, 4, 5, 6, 7, 8, 9, 10, 17, 19, and 21. The presence
257 * of a non-zero constant term arises through the use of auxiliary variables
258 * with origin offset from the reference point of the TAN projection. However,
259 * in the translation given by WCS Paper IV, the distortion polynomial is zero,
260 * or very close to zero, at the reference pixel itself. The mapping between
261 * DSS's AMDXm (or AMDYm) keyvalues and TPD coefficients, while still simple,
262 * is not quite as straightforward as for TPV and SIP.
263 *
264 * WAT uses all but the radial terms: 3, 11, 23, 39, and 59. While the mapping
265 * between WAT's monomial coefficients and TPD is fairly simple, for its
266 * expression in terms of a sum of Chebyshev or Legendre polynomials it is much
267 * less so.
268 *
269 * Summary of the dis routines
270 * ---------------------------
271 * These routines apply the distortion functions defined by the extension to
272 * the FITS WCS standard proposed in Paper IV. They are based on the disprm
273 * struct which contains all information needed for the computations. The
274 * struct contains some members that must be set by the user, and others that
275 * are maintained by these routines, somewhat like a C++ class but with no
276 * encapsulation.
277 *
278 * disndp(), dpfill(), disini(), discpy(), and disfree() are provided to manage
279 * the disprm struct, and another, disprt(), prints its contents.
280 *
281 * disperr() prints the error message(s) (if any) stored in a disprm struct.
282 *
283 * wcshdo() normally writes SIP and TPV headers in their native form if at all
284 * possible. However, dishdo() may be used to set a flag that tells it to
285 * write the header in the form of the TPD translation used internally.
286 *
287 * A setup routine, disset(), computes intermediate values in the disprm struct
288 * from parameters in it that were supplied by the user. The struct always
289 * needs to be set up by disset(), though disset() need not be called
290 * explicitly - refer to the explanation of disprm::flag.
291 *
292 * disp2x() and disx2p() implement the WCS distortion functions, disp2x() using
293 * separate functions, such as dispoly() and tpd7(), to do the computation.
294 *
295 * An auxiliary routine, diswarp(), computes various measures of the distortion
296 * over a specified range of coordinates.
297 *
298 * PLEASE NOTE: Distortions are not yet handled by wcsbth(), or wcscompare().
299 *
300 *
301 * disndp() - Memory allocation for DPja and DQia
302 * ----------------------------------------------
303 * disndp() changes the value of NDPMAX (default 256). This global variable
304 * controls the number of dpkey structs, for holding DPja or DQia keyvalues,
305 * that disini() should allocate space for.
306 *
307 * PLEASE NOTE: This function is not thread-safe.
308 *
309 * Given:
310 * n int Value of NDPMAX; ignored if < 0.
311 *
312 * Function return value:
313 * int Current value of NDPMAX.
314 *
315 *
316 * dpfill() - Fill the contents of a dpkey struct
317 * ----------------------------------------------
318 * dpfill() is a utility routine to aid in filling the contents of the dpkey
319 * struct. No checks are done on the validity of the inputs.
320 *
321 * WCS Paper IV specifies the syntax of a record-valued keyword as
322 *
323 = keyword = '<field-specifier>: <float>'
324 *
325 * However, some DPja and DQia record values, such as those of DPja.NAXES and
326 * DPja.AXIS.j, are intrinsically integer-valued. While FITS header parsers
327 * are not expected to know in advance which of DPja and DQia are integral and
328 * which are floating point, if the record's value parses as an integer (i.e.
329 * without decimal point or exponent), then preferably enter it into the dpkey
330 * struct as an integer. Either way, it doesn't matter as disset() accepts
331 * either data type for all record values.
332 *
333 * Given and returned:
334 * dp struct dpkey*
335 * Store for DPja and DQia keyvalues.
336 *
337 * Given:
338 * keyword const char *
339 * field const char *
340 * These arguments are concatenated with an intervening
341 * "." to construct the full record field name, i.e.
342 * including the keyword name, DPja or DQia (but
343 * excluding the colon delimiter which is NOT part of the
344 * name). Either may be given as a NULL pointer. Set
345 * both NULL to omit setting this component of the
346 * struct.
347 *
348 * j int Axis number (1-relative), i.e. the j in DPja or
349 * i in DQia. Can be given as 0, in which case the axis
350 * number will be obtained from the keyword component of
351 * the field name which must either have been given or
352 * preset.
353 *
354 * If j is non-zero, and keyword was given, then the
355 * value of j will be used to fill in the axis number.
356 *
357 * type int Data type of the record's value
358 * 0: Integer,
359 * 1: Floating point.
360 *
361 * i int For type == 0, the integer value of the record.
362 *
363 * f double For type == 1, the floating point value of the record.
364 *
365 * Function return value:
366 * int Status return value:
367 * 0: Success.
368 *
369 *
370 * disini() - Default constructor for the disprm struct
371 * ----------------------------------------------------
372 * disini() allocates memory for arrays in a disprm struct and sets all members
373 * of the struct to default values. Memory is allocated for up to NDPMAX DPja
374 * or DQia keywords per WCS representation. This may be changed via disndp()
375 * before disini() is called.
376 *
377 * PLEASE NOTE: every disprm struct must be initialized by disini(), possibly
378 * repeatedly. On the first invokation, and only the first invokation,
379 * disprm::flag must be set to -1 to initialize memory management, regardless
380 * of whether disini() will actually be used to allocate memory.
381 *
382 * Given:
383 * alloc int If true, allocate memory unconditionally for arrays in
384 * the disprm struct.
385 *
386 * If false, it is assumed that pointers to these arrays
387 * have been set by the user except if they are null
388 * pointers in which case memory will be allocated for
389 * them regardless. (In other words, setting alloc true
390 * saves having to initalize these pointers to zero.)
391 *
392 * naxis int The number of world coordinate axes, used to determine
393 * array sizes.
394 *
395 * Given and returned:
396 * dis struct disprm*
397 * Distortion function parameters. Note that, in order
398 * to initialize memory management disprm::flag must be
399 * set to -1 when dis is initialized for the first time
400 * (memory leaks may result if it had already been
401 * initialized).
402 *
403 * Function return value:
404 * int Status return value:
405 * 0: Success.
406 * 1: Null disprm pointer passed.
407 * 2: Memory allocation failed.
408 *
409 * For returns > 1, a detailed error message is set in
410 * disprm::err if enabled, see wcserr_enable().
411 *
412 *
413 * discpy() - Copy routine for the disprm struct
414 * ---------------------------------------------
415 * discpy() does a deep copy of one disprm struct to another, using disini() to
416 * allocate memory unconditionally for its arrays if required. Only the
417 * "information to be provided" part of the struct is copied; a call to
418 * disset() is required to initialize the remainder.
419 *
420 * Given:
421 * alloc int If true, allocate memory unconditionally for arrays in
422 * the destination. Otherwise, it is assumed that
423 * pointers to these arrays have been set by the user
424 * except if they are null pointers in which case memory
425 * will be allocated for them regardless.
426 *
427 * dissrc const struct disprm*
428 * Struct to copy from.
429 *
430 * Given and returned:
431 * disdst struct disprm*
432 * Struct to copy to. disprm::flag should be set to -1
433 * if disdst was not previously initialized (memory leaks
434 * may result if it was previously initialized).
435 *
436 * Function return value:
437 * int Status return value:
438 * 0: Success.
439 * 1: Null disprm pointer passed.
440 * 2: Memory allocation failed.
441 *
442 * For returns > 1, a detailed error message is set in
443 * disprm::err if enabled, see wcserr_enable().
444 *
445 *
446 * disfree() - Destructor for the disprm struct
447 * --------------------------------------------
448 * disfree() frees memory allocated for the disprm arrays by disini().
449 * disini() keeps a record of the memory it allocates and disfree() will only
450 * attempt to free this.
451 *
452 * PLEASE NOTE: disfree() must not be invoked on a disprm struct that was not
453 * initialized by disini().
454 *
455 * Given:
456 * dis struct disprm*
457 * Distortion function parameters.
458 *
459 * Function return value:
460 * int Status return value:
461 * 0: Success.
462 * 1: Null disprm pointer passed.
463 *
464 *
465 * disprt() - Print routine for the disprm struct
466 * ----------------------------------------------
467 * disprt() prints the contents of a disprm struct using wcsprintf(). Mainly
468 * intended for diagnostic purposes.
469 *
470 * Given:
471 * dis const struct disprm*
472 * Distortion function parameters.
473 *
474 * Function return value:
475 * int Status return value:
476 * 0: Success.
477 * 1: Null disprm pointer passed.
478 *
479 *
480 * disperr() - Print error messages from a disprm struct
481 * -----------------------------------------------------
482 * disperr() prints the error message(s) (if any) stored in a disprm struct.
483 * If there are no errors then nothing is printed. It uses wcserr_prt(), q.v.
484 *
485 * Given:
486 * dis const struct disprm*
487 * Distortion function parameters.
488 *
489 * prefix const char *
490 * If non-NULL, each output line will be prefixed with
491 * this string.
492 *
493 * Function return value:
494 * int Status return value:
495 * 0: Success.
496 * 1: Null disprm pointer passed.
497 *
498 *
499 * dishdo() - write FITS headers using TPD
500 * ---------------------------------------
501 * dishdo() sets a flag that tells wcshdo() to write FITS headers in the form
502 * of the TPD translation used internally. Normally SIP and TPV would be
503 * written in their native form if at all possible.
504 *
505 * Given and returned:
506 * dis struct disprm*
507 * Distortion function parameters.
508 *
509 * Function return value:
510 * int Status return value:
511 * 0: Success.
512 * 1: Null disprm pointer passed.
513 * 3: No TPD translation.
514 *
515 *
516 * disset() - Setup routine for the disprm struct
517 * ----------------------------------------------
518 * disset(), sets up the disprm struct according to information supplied within
519 * it - refer to the explanation of disprm::flag.
520 *
521 * Note that this routine need not be called directly; it will be invoked by
522 * disp2x() and disx2p() if the disprm::flag is anything other than a
523 * predefined magic value.
524 *
525 * Given and returned:
526 * dis struct disprm*
527 * Distortion function parameters.
528 *
529 * Function return value:
530 * int Status return value:
531 * 0: Success.
532 * 1: Null disprm pointer passed.
533 * 2: Memory allocation failed.
534 * 3: Invalid parameter.
535 *
536 * For returns > 1, a detailed error message is set in
537 * disprm::err if enabled, see wcserr_enable().
538 *
539 *
540 * disp2x() - Apply distortion function
541 * ------------------------------------
542 * disp2x() applies the distortion functions. By definition, the distortion
543 * is in the pixel-to-world direction.
544 *
545 * Depending on the point in the algorithm chain at which it is invoked,
546 * disp2x() may transform pixel coordinates to corrected pixel coordinates, or
547 * intermediate pixel coordinates to corrected intermediate pixel coordinates,
548 * or image coordinates to corrected image coordinates.
549 *
550 *
551 * Given and returned:
552 * dis struct disprm*
553 * Distortion function parameters.
554 *
555 * Given:
556 * rawcrd const double[naxis]
557 * Array of coordinates.
558 *
559 * Returned:
560 * discrd double[naxis]
561 * Array of coordinates to which the distortion functions
562 * have been applied.
563 *
564 * Function return value:
565 * int Status return value:
566 * 0: Success.
567 * 1: Null disprm pointer passed.
568 * 2: Memory allocation failed.
569 * 3: Invalid parameter.
570 * 4: Distort error.
571 *
572 * For returns > 1, a detailed error message is set in
573 * disprm::err if enabled, see wcserr_enable().
574 *
575 *
576 * disx2p() - Apply de-distortion function
577 * ---------------------------------------
578 * disx2p() applies the inverse of the distortion functions. By definition,
579 * the de-distortion is in the world-to-pixel direction.
580 *
581 * Depending on the point in the algorithm chain at which it is invoked,
582 * disx2p() may transform corrected pixel coordinates to pixel coordinates, or
583 * corrected intermediate pixel coordinates to intermediate pixel coordinates,
584 * or corrected image coordinates to image coordinates.
585 *
586 * disx2p() iteratively solves for the inverse using disp2x(). It assumes
587 * that the distortion is small and the functions are well-behaved, being
588 * continuous and with continuous derivatives. Also that, to first order
589 * in the neighbourhood of the solution, discrd[j] ~= a + b*rawcrd[j], i.e.
590 * independent of rawcrd[i], where i != j. This is effectively equivalent to
591 * assuming that the distortion functions are separable to first order.
592 * Furthermore, a is assumed to be small, and b close to unity.
593 *
594 * If disprm::disx2p() is defined, then disx2p() uses it to provide an initial
595 * estimate for its more precise iterative inversion.
596 *
597 * Given and returned:
598 * dis struct disprm*
599 * Distortion function parameters.
600 *
601 * Given:
602 * discrd const double[naxis]
603 * Array of coordinates.
604 *
605 * Returned:
606 * rawcrd double[naxis]
607 * Array of coordinates to which the inverse distortion
608 * functions have been applied.
609 *
610 * Function return value:
611 * int Status return value:
612 * 0: Success.
613 * 1: Null disprm pointer passed.
614 * 2: Memory allocation failed.
615 * 3: Invalid parameter.
616 * 5: De-distort error.
617 *
618 * For returns > 1, a detailed error message is set in
619 * disprm::err if enabled, see wcserr_enable().
620 *
621 *
622 * diswarp() - Compute measures of distortion
623 * ------------------------------------------
624 * diswarp() computes various measures of the distortion over a specified range
625 * of coordinates.
626 *
627 * For prior distortions, the measures may be interpreted simply as an offset
628 * in pixel coordinates. For sequent distortions, the interpretation depends
629 * on the nature of the linear transformation matrix (PCi_ja or CDi_ja). If
630 * the latter introduces a scaling, then the measures will also be scaled.
631 * Note also that the image domain, which is rectangular in pixel coordinates,
632 * may be rotated, skewed, and/or stretched in intermediate pixel coordinates,
633 * and in general cannot be defined using pixblc[] and pixtrc[].
634 *
635 * PLEASE NOTE: the measures of total distortion may be essentially meaningless
636 * if there are multiple sequent distortions with different scaling.
637 *
638 * See also linwarp().
639 *
640 * Given and returned:
641 * dis struct disprm*
642 * Distortion function parameters.
643 *
644 * Given:
645 * pixblc const double[naxis]
646 * Start of the range of pixel coordinates (for prior
647 * distortions), or intermediate pixel coordinates (for
648 * sequent distortions). May be specified as a NULL
649 * pointer which is interpreted as (1,1,...).
650 *
651 * pixtrc const double[naxis]
652 * End of the range of pixel coordinates (prior) or
653 * intermediate pixel coordinates (sequent).
654 *
655 * pixsamp const double[naxis]
656 * If positive or zero, the increment on the particular
657 * axis, starting at pixblc[]. Zero is interpreted as a
658 * unit increment. pixsamp may also be specified as a
659 * NULL pointer which is interpreted as all zeroes, i.e.
660 * unit increments on all axes.
661 *
662 * If negative, the grid size on the particular axis (the
663 * absolute value being rounded to the nearest integer).
664 * For example, if pixsamp is (-128.0,-128.0,...) then
665 * each axis will be sampled at 128 points between
666 * pixblc[] and pixtrc[] inclusive. Use caution when
667 * using this option on non-square images.
668 *
669 * Returned:
670 * nsamp int* The number of pixel coordinates sampled.
671 *
672 * Can be specified as a NULL pointer if not required.
673 *
674 * maxdis double[naxis]
675 * For each individual distortion function, the
676 * maximum absolute value of the distortion.
677 *
678 * Can be specified as a NULL pointer if not required.
679 *
680 * maxtot double* For the combination of all distortion functions, the
681 * maximum absolute value of the distortion.
682 *
683 * Can be specified as a NULL pointer if not required.
684 *
685 * avgdis double[naxis]
686 * For each individual distortion function, the
687 * mean value of the distortion.
688 *
689 * Can be specified as a NULL pointer if not required.
690 *
691 * avgtot double* For the combination of all distortion functions, the
692 * mean value of the distortion.
693 *
694 * Can be specified as a NULL pointer if not required.
695 *
696 * rmsdis double[naxis]
697 * For each individual distortion function, the
698 * root mean square deviation of the distortion.
699 *
700 * Can be specified as a NULL pointer if not required.
701 *
702 * rmstot double* For the combination of all distortion functions, the
703 * root mean square deviation of the distortion.
704 *
705 * Can be specified as a NULL pointer if not required.
706 *
707 * Function return value:
708 * int Status return value:
709 * 0: Success.
710 * 1: Null disprm pointer passed.
711 * 2: Memory allocation failed.
712 * 3: Invalid parameter.
713 * 4: Distort error.
714 *
715 *
716 * disprm struct - Distortion parameters
717 * -------------------------------------
718 * The disprm struct contains all of the information required to apply a set of
719 * distortion functions. It consists of certain members that must be set by
720 * the user ("given") and others that are set by the WCSLIB routines
721 * ("returned"). While the addresses of the arrays themselves may be set by
722 * disini() if it (optionally) allocates memory, their contents must be set by
723 * the user.
724 *
725 * int flag
726 * (Given and returned) This flag must be set to zero whenever any of the
727 * following members of the disprm struct are set or modified:
728 *
729 * - disprm::naxis,
730 * - disprm::dtype,
731 * - disprm::ndp,
732 * - disprm::dp.
733 *
734 * This signals the initialization routine, disset(), to recompute the
735 * returned members of the disprm struct. disset() will reset flag to
736 * indicate that this has been done.
737 *
738 * PLEASE NOTE: flag must be set to -1 when disini() is called for the
739 * first time for a particular disprm struct in order to initialize memory
740 * management. It must ONLY be used on the first initialization otherwise
741 * memory leaks may result.
742 *
743 * int naxis
744 * (Given or returned) Number of pixel and world coordinate elements.
745 *
746 * If disini() is used to initialize the disprm struct (as would normally
747 * be the case) then it will set naxis from the value passed to it as a
748 * function argument. The user should not subsequently modify it.
749 *
750 * char (*dtype)[72]
751 * (Given) Pointer to the first element of an array of char[72] containing
752 * the name of the distortion function for each axis.
753 *
754 * int ndp
755 * (Given) The number of entries in the disprm::dp[] array.
756 *
757 * int ndpmax
758 * (Given) The length of the disprm::dp[] array.
759 *
760 * ndpmax will be set by disini() if it allocates memory for disprm::dp[],
761 * otherwise it must be set by the user. See also disndp().
762 *
763 * struct dpkey dp
764 * (Given) Address of the first element of an array of length ndpmax of
765 * dpkey structs.
766 *
767 * As a FITS header parser encounters each DPja or DQia keyword it should
768 * load it into a dpkey struct in the array and increment ndp. However,
769 * note that a single disprm struct must hold only DPja or DQia keyvalues,
770 * not both. disset() interprets them as required by the particular
771 * distortion function.
772 *
773 * double *maxdis
774 * (Given) Pointer to the first element of an array of double specifying
775 * the maximum absolute value of the distortion for each axis computed over
776 * the whole image.
777 *
778 * It is not necessary to reset the disprm struct (via disset()) when
779 * disprm::maxdis is changed.
780 *
781 * double totdis
782 * (Given) The maximum absolute value of the combination of all distortion
783 * functions specified as an offset in pixel coordinates computed over the
784 * whole image.
785 *
786 * It is not necessary to reset the disprm struct (via disset()) when
787 * disprm::totdis is changed.
788 *
789 * int **axmap
790 * (Returned) Pointer to the first element of an array of int* containing
791 * pointers to the first elements of the axis mapping arrays for each axis.
792 *
793 * An axis mapping associates the independent variables of a distortion
794 * function with the 0-relative image axis number. For example, consider
795 * an image with a spectrum on the first axis (axis 0), followed by RA
796 * (axis 1), Dec (axis2), and time (axis 3) axes. For a distortion in
797 * (RA,Dec) and no distortion on the spectral or time axes, the axis
798 * mapping arrays, axmap[j][], would be
799 *
800 = j=0: [-1, -1, -1, -1] ...no distortion on spectral axis,
801 = 1: [ 1, 2, -1, -1] ...RA distortion depends on RA and Dec,
802 = 2: [ 2, 1, -1, -1] ...Dec distortion depends on Dec and RA,
803 = 3: [-1, -1, -1, -1] ...no distortion on time axis,
804 *
805 * where -1 indicates that there is no corresponding independent
806 * variable.
807 *
808 * int *Nhat
809 * (Returned) Pointer to the first element of an array of int* containing
810 * the number of coordinate axes that form the independent variables of the
811 * distortion function.
812 *
813 * double **offset
814 * (Returned) Pointer to the first element of an array of double*
815 * containing an offset used to renormalize the independent variables of
816 * the distortion function for each axis.
817 *
818 * The offsets are subtracted from the independent variables before
819 * scaling.
820 *
821 * double **scale
822 * (Returned) Pointer to the first element of an array of double*
823 * containing a scale used to renormalize the independent variables of the
824 * distortion function for each axis.
825 *
826 * The scale is applied to the independent variables after the offsets are
827 * subtracted.
828 *
829 * int **iparm
830 * (Returned) Pointer to the first element of an array of int*
831 * containing pointers to the first elements of the arrays of integer
832 * distortion parameters for each axis.
833 *
834 * double **dparm
835 * (Returned) Pointer to the first element of an array of double*
836 * containing pointers to the first elements of the arrays of floating
837 * point distortion parameters for each axis.
838 *
839 * int i_naxis
840 * (Returned) Dimension of the internal arrays (normally equal to naxis).
841 *
842 * int ndis
843 * (Returned) The number of distortion functions.
844 *
845 * struct wcserr *err
846 * (Returned) If enabled, when an error status is returned, this struct
847 * contains detailed information about the error, see wcserr_enable().
848 *
849 * int (**disp2x)(DISP2X_ARGS)
850 * (For internal use only.)
851 * int (**disx2p)(DISX2P_ARGS)
852 * (For internal use only.)
853 * double *tmpmem
854 * (For internal use only.)
855 * int m_flag
856 * (For internal use only.)
857 * int m_naxis
858 * (For internal use only.)
859 * char (*m_dtype)[72]
860 * (For internal use only.)
861 * double **m_dp
862 * (For internal use only.)
863 * double *m_maxdis
864 * (For internal use only.)
865 *
866 *
867 * dpkey struct - Store for DPja and DQia keyvalues
868 * ------------------------------------------------
869 * The dpkey struct is used to pass the parsed contents of DPja or DQia
870 * keyrecords to disset() via the disprm struct. A disprm struct must hold
871 * only DPja or DQia keyvalues, not both.
872 *
873 * All members of this struct are to be set by the user.
874 *
875 * char field[72]
876 * (Given) The full field name of the record, including the keyword name.
877 * Note that the colon delimiter separating the field name and the value in
878 * record-valued keyvalues is not part of the field name. For example, in
879 * the following:
880 *
881 = DP3A = 'AXIS.1: 2'
882 *
883 * the full record field name is "DP3A.AXIS.1", and the record's value
884 * is 2.
885 *
886 * int j
887 * (Given) Axis number (1-relative), i.e. the j in DPja or i in DQia.
888 *
889 * int type
890 * (Given) The data type of the record's value
891 * - 0: Integer (stored as an int),
892 * - 1: Floating point (stored as a double).
893 *
894 * union value
895 * (Given) A union comprised of
896 * - dpkey::i,
897 * - dpkey::f,
898 *
899 * the record's value.
900 *
901 *
902 * Global variable: const char *dis_errmsg[] - Status return messages
903 * ------------------------------------------------------------------
904 * Error messages to match the status value returned from each function.
905 *
906 *===========================================================================*/
907
908 #ifndef WCSLIB_DIS
909 #define WCSLIB_DIS
910
911 #ifdef __cplusplus
912 extern "C" {
913 #endif
914
915
916 extern const char *dis_errmsg[];
917
918 enum dis_errmsg_enum {
919 DISERR_SUCCESS = 0, /* Success. */
920 DISERR_NULL_POINTER = 1, /* Null disprm pointer passed. */
921 DISERR_MEMORY = 2, /* Memory allocation failed. */
922 DISERR_BAD_PARAM = 3, /* Invalid parameter value. */
923 DISERR_DISTORT = 4, /* Distortion error. */
924 DISERR_DEDISTORT = 5 /* De-distortion error. */
925 };
926
927 /* For use in declaring distortion function prototypes (= DISX2P_ARGS). */
928 #define DISP2X_ARGS int inverse, const int iparm[], const double dparm[], \
929 int ncrd, const double rawcrd[], double *discrd
930
931 /* For use in declaring de-distortion function prototypes (= DISP2X_ARGS). */
932 #define DISX2P_ARGS int inverse, const int iparm[], const double dparm[], \
933 int ncrd, const double discrd[], double *rawcrd
934
935
936 /* Struct used for storing DPja and DQia keyvalues. */
937 struct dpkey {
938 char field[72]; /* Full record field name (no colon). */
939 int j; /* Axis number, as in DPja (1-relative). */
940 int type; /* Data type of value. */
941 union {
942 int i; /* Integer record value. */
943 double f; /* Floating point record value. */
944 } value; /* Record value. */
945 };
946
947 /* Size of the dpkey struct in int units, used by the Fortran wrappers. */
948 #define DPLEN (sizeof(struct dpkey)/sizeof(int))
949
950
951 struct disprm {
952 /* Initialization flag (see the prologue above). */
953 /*------------------------------------------------------------------------*/
954 int flag; /* Set to zero to force initialization. */
955
956 /* Parameters to be provided (see the prologue above). */
957 /*------------------------------------------------------------------------*/
958 int naxis; /* The number of pixel coordinate elements, */
959 /* given by NAXIS. */
960 char (*dtype)[72]; /* For each axis, the distortion type. */
961 int ndp; /* Number of DPja or DQia keywords, and the */
962 int ndpmax; /* number for which space was allocated. */
963 struct dpkey *dp; /* DPja or DQia keyvalues (not both). */
964 double *maxdis; /* For each axis, the maximum distortion. */
965 double totdis; /* The maximum combined distortion. */
966
967 /* Information derived from the parameters supplied. */
968 /*------------------------------------------------------------------------*/
969 int **axmap; /* For each axis, the axis mapping array. */
970 int *Nhat; /* For each axis, the number of coordinate */
971 /* axes that form the independent variables */
972 /* of the distortion function. */
973 double **offset; /* For each axis, renormalization offsets. */
974 double **scale; /* For each axis, renormalization scales. */
975 int **iparm; /* For each axis, the array of integer */
976 /* distortion parameters. */
977 double **dparm; /* For each axis, the array of floating */
978 /* point distortion parameters. */
979 int i_naxis; /* Dimension of the internal arrays. */
980 int ndis; /* The number of distortion functions. */
981
982 /* Error handling, if enabled. */
983 /*------------------------------------------------------------------------*/
984 struct wcserr *err;
985
986 /* Private - the remainder are for internal use. */
987 /*------------------------------------------------------------------------*/
988 int (**disp2x)(DISP2X_ARGS); /* For each axis, pointers to the */
989 int (**disx2p)(DISX2P_ARGS); /* distortion function and its inverse. */
990
991 double *tmpmem;
992
993 int m_flag, m_naxis; /* The remainder are for memory management. */
994 char (*m_dtype)[72];
995 struct dpkey *m_dp;
996 double *m_maxdis;
997 };
998
999 /* Size of the disprm struct in int units, used by the Fortran wrappers. */
1000 #define DISLEN (sizeof(struct disprm)/sizeof(int))
1001
1002
1003 int disndp(int n);
1004
1005 int dpfill(struct dpkey *dp, const char *keyword, const char *field, int j,
1006 int type, int i, double f);
1007
1008 int disini(int alloc, int naxis, struct disprm *dis);
1009
1010 int discpy(int alloc, const struct disprm *dissrc, struct disprm *disdst);
1011
1012 int disfree(struct disprm *dis);
1013
1014 int disprt(const struct disprm *dis);
1015
1016 int disperr(const struct disprm *dis, const char *prefix);
1017
1018 int dishdo(struct disprm *dis);
1019
1020 int disset(struct disprm *dis);
1021
1022 int disp2x(struct disprm *dis, const double rawcrd[], double discrd[]);
1023
1024 int disx2p(struct disprm *dis, const double discrd[], double rawcrd[]);
1025
1026 int diswarp(struct disprm *dis, const double pixblc[], const double pixtrc[],
1027 const double pixsamp[], int *nsamp,
1028 double maxdis[], double *maxtot,
1029 double avgdis[], double *avgtot,
1030 double rmsdis[], double *rmstot);
1031
1032 #ifdef __cplusplus
1033 }
1034 #endif
1035
1036 #endif /* WCSLIB_DIS */
dpkey::type
int type
Definition: dis.h:940
disprm::flag
int flag
Definition: dis.h:954
dpkey
Store for DPja and DQia keyvalues.
Definition: dis.h:937
discpy
int discpy(int alloc, const struct disprm *dissrc, struct disprm *disdst)
Copy routine for the disprm struct.
disprm::iparm
int ** iparm
Definition: dis.h:975
DISERR_DISTORT
Definition: dis.h:923
dis_errmsg
const char * dis_errmsg[]
Status return messages.
disperr
int disperr(const struct disprm *dis, const char *prefix)
Print error messages from a disprm struct.
disprm::axmap
int ** axmap
Definition: dis.h:969
dishdo
int dishdo(struct disprm *dis)
write FITS headers using TPD.
disp2x
int disp2x(struct disprm *dis, const double rawcrd[], double discrd[])
Apply distortion function.
disprm::scale
double ** scale
Definition: dis.h:974
wcserr
Error message handling.
Definition: wcserr.h:225
disx2p
int disx2p(struct disprm *dis, const double discrd[], double rawcrd[])
Apply de-distortion function.
DISERR_BAD_PARAM
Definition: dis.h:922
disset
int disset(struct disprm *dis)
Setup routine for the disprm struct.
disprm::naxis
int naxis
Definition: dis.h:958
disprm::dp
struct dpkey * dp
Definition: dis.h:963
DISERR_DEDISTORT
Definition: dis.h:924
disprm::ndis
int ndis
Definition: dis.h:980
disprm
Distortion parameters.
Definition: dis.h:951
dpkey::field
char field[72]
Definition: dis.h:938
disprm::ndp
int ndp
Definition: dis.h:961
dpkey::j
int j
Definition: dis.h:939
DISERR_NULL_POINTER
Definition: dis.h:920
disprm::Nhat
int * Nhat
Definition: dis.h:970
disfree
int disfree(struct disprm *dis)
Destructor for the disprm struct.
dis_errmsg_enum
dis_errmsg_enum
Definition: dis.h:918
disprm::m_naxis
int m_naxis
Definition: dis.h:993
dpfill
int dpfill(struct dpkey *dp, const char *keyword, const char *field, int j, int type, int i, double f)
Fill the contents of a dpkey struct.
disprt
int disprt(const struct disprm *dis)
Print routine for the disprm struct.
disprm::tmpmem
double * tmpmem
Definition: dis.h:991
disprm::i_naxis
int i_naxis
Definition: dis.h:979
disprm::maxdis
double * maxdis
Definition: dis.h:964
disprm::totdis
double totdis
Definition: dis.h:965
DISERR_SUCCESS
Definition: dis.h:919
disprm::err
struct wcserr * err
Definition: dis.h:984
disini
int disini(int alloc, int naxis, struct disprm *dis)
Default constructor for the disprm struct.
dpkey::value
union dpkey::@0 value
dpkey::f
double f
Definition: dis.h:943
DISERR_MEMORY
Definition: dis.h:921
disprm::m_dp
struct dpkey * m_dp
Definition: dis.h:995
disprm::m_maxdis
double * m_maxdis
Definition: dis.h:996
diswarp
int diswarp(struct disprm *dis, const double pixblc[], const double pixtrc[], const double pixsamp[], int *nsamp, double maxdis[], double *maxtot, double avgdis[], double *avgtot, double rmsdis[], double *rmstot)
Compute measures of distortion.
disprm::offset
double ** offset
Definition: dis.h:973
DISX2P_ARGS
#define DISX2P_ARGS
Definition: dis.h:932
disprm::ndpmax
int ndpmax
Definition: dis.h:962
disndp
int disndp(int n)
Memory allocation for DPja and DQia.
dpkey::i
int i
Definition: dis.h:942
DISP2X_ARGS
#define DISP2X_ARGS
Definition: dis.h:928
disprm::dparm
double ** dparm
Definition: dis.h:977