WCSLIB  5.18
dis.h
Go to the documentation of this file.
1 /*============================================================================
2 
3  WCSLIB 5.18 - an implementation of the FITS WCS standard.
4  Copyright (C) 1995-2018, 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.18 2018/01/10 08:32:14 mcalabre Exp $
26 *=============================================================================
27 *
28 * WCSLIB 5.18 - 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(), disinit(), discpy(), and disfree() are
279 * provided to manage the disprm struct, and another, disprt(), prints its
280 * contents.
281 *
282 * disperr() prints the error message(s) (if any) stored in a disprm struct.
283 *
284 * wcshdo() normally writes SIP and TPV headers in their native form if at all
285 * possible. However, dishdo() may be used to set a flag that tells it to
286 * write the header in the form of the TPD translation used internally.
287 *
288 * A setup routine, disset(), computes intermediate values in the disprm struct
289 * from parameters in it that were supplied by the user. The struct always
290 * needs to be set up by disset(), though disset() need not be called
291 * explicitly - refer to the explanation of disprm::flag.
292 *
293 * disp2x() and disx2p() implement the WCS distortion functions, disp2x() using
294 * separate functions, such as dispoly() and tpd7(), to do the computation.
295 *
296 * An auxiliary routine, diswarp(), computes various measures of the distortion
297 * over a specified range of coordinates.
298 *
299 * PLEASE NOTE: Distortions are not yet handled by wcsbth(), or wcscompare().
300 *
301 *
302 * disndp() - Memory allocation for DPja and DQia
303 * ----------------------------------------------
304 * disndp() sets or gets the value of NDPMAX (default 256). This global
305 * variable controls the maximum number of dpkey structs, for holding DPja or
306 * DQia keyvalues, that disini() should allocate space for. It is also used by
307 * disinit() as the default value of ndpmax.
308 *
309 * PLEASE NOTE: This function is not thread-safe.
310 *
311 * Given:
312 * n int Value of NDPMAX; ignored if < 0. Use a value less
313 * than zero to get the current value.
314 *
315 * Function return value:
316 * int Current value of NDPMAX.
317 *
318 *
319 * dpfill() - Fill the contents of a dpkey struct
320 * ----------------------------------------------
321 * dpfill() is a utility routine to aid in filling the contents of the dpkey
322 * struct. No checks are done on the validity of the inputs.
323 *
324 * WCS Paper IV specifies the syntax of a record-valued keyword as
325 *
326 = keyword = '<field-specifier>: <float>'
327 *
328 * However, some DPja and DQia record values, such as those of DPja.NAXES and
329 * DPja.AXIS.j, are intrinsically integer-valued. While FITS header parsers
330 * are not expected to know in advance which of DPja and DQia are integral and
331 * which are floating point, if the record's value parses as an integer (i.e.
332 * without decimal point or exponent), then preferably enter it into the dpkey
333 * struct as an integer. Either way, it doesn't matter as disset() accepts
334 * either data type for all record values.
335 *
336 * Given and returned:
337 * dp struct dpkey*
338 * Store for DPja and DQia keyvalues.
339 *
340 * Given:
341 * keyword const char *
342 * field const char *
343 * These arguments are concatenated with an intervening
344 * "." to construct the full record field name, i.e.
345 * including the keyword name, DPja or DQia (but
346 * excluding the colon delimiter which is NOT part of the
347 * name). Either may be given as a NULL pointer. Set
348 * both NULL to omit setting this component of the
349 * struct.
350 *
351 * j int Axis number (1-relative), i.e. the j in DPja or
352 * i in DQia. Can be given as 0, in which case the axis
353 * number will be obtained from the keyword component of
354 * the field name which must either have been given or
355 * preset.
356 *
357 * If j is non-zero, and keyword was given, then the
358 * value of j will be used to fill in the axis number.
359 *
360 * type int Data type of the record's value
361 * 0: Integer,
362 * 1: Floating point.
363 *
364 * i int For type == 0, the integer value of the record.
365 *
366 * f double For type == 1, the floating point value of the record.
367 *
368 * Function return value:
369 * int Status return value:
370 * 0: Success.
371 *
372 *
373 * disini() - Default constructor for the disprm struct
374 * ----------------------------------------------------
375 * disini() is a thin wrapper on disinit(). It invokes it with ndpmax set
376 * to -1 which causes it to use the value of the global variable NDPMAX. It
377 * is thereby potentially thread-unsafe if NDPMAX is altered dynamically via
378 * disndp(). Use disinit() for a thread-safe alternative in this case.
379 *
380 *
381 * disinit() - Default constructor for the disprm struct
382 * ----------------------------------------------------
383 * disinit() allocates memory for arrays in a disprm struct and sets all
384 * members of the struct to default values.
385 *
386 * PLEASE NOTE: every disprm struct must be initialized by disinit(), possibly
387 * repeatedly. On the first invokation, and only the first invokation,
388 * disprm::flag must be set to -1 to initialize memory management, regardless
389 * of whether disinit() will actually be used to allocate memory.
390 *
391 * Given:
392 * alloc int If true, allocate memory unconditionally for arrays in
393 * the disprm struct.
394 *
395 * If false, it is assumed that pointers to these arrays
396 * have been set by the user except if they are null
397 * pointers in which case memory will be allocated for
398 * them regardless. (In other words, setting alloc true
399 * saves having to initalize these pointers to zero.)
400 *
401 * naxis int The number of world coordinate axes, used to determine
402 * array sizes.
403 *
404 * Given and returned:
405 * dis struct disprm*
406 * Distortion function parameters. Note that, in order
407 * to initialize memory management disprm::flag must be
408 * set to -1 when dis is initialized for the first time
409 * (memory leaks may result if it had already been
410 * initialized).
411 *
412 * Given:
413 * ndpmax int The number of DPja or DQia keywords to allocate space
414 * for. If set to -1, the value of the global variable
415 * NDPMAX will be used. This is potentially
416 * thread-unsafe if disndp() is being used dynamically to
417 * alter its value.
418 *
419 * Function return value:
420 * int Status return value:
421 * 0: Success.
422 * 1: Null disprm pointer passed.
423 * 2: Memory allocation failed.
424 *
425 * For returns > 1, a detailed error message is set in
426 * disprm::err if enabled, see wcserr_enable().
427 *
428 *
429 * discpy() - Copy routine for the disprm struct
430 * ---------------------------------------------
431 * discpy() does a deep copy of one disprm struct to another, using disinit()
432 * to allocate memory unconditionally for its arrays if required. Only the
433 * "information to be provided" part of the struct is copied; a call to
434 * disset() is required to initialize the remainder.
435 *
436 * Given:
437 * alloc int If true, allocate memory unconditionally for arrays in
438 * the destination. Otherwise, it is assumed that
439 * pointers to these arrays have been set by the user
440 * except if they are null pointers in which case memory
441 * will be allocated for them regardless.
442 *
443 * dissrc const struct disprm*
444 * Struct to copy from.
445 *
446 * Given and returned:
447 * disdst struct disprm*
448 * Struct to copy to. disprm::flag should be set to -1
449 * if disdst was not previously initialized (memory leaks
450 * may result if it was previously initialized).
451 *
452 * Function return value:
453 * int Status return value:
454 * 0: Success.
455 * 1: Null disprm pointer passed.
456 * 2: Memory allocation failed.
457 *
458 * For returns > 1, a detailed error message is set in
459 * disprm::err if enabled, see wcserr_enable().
460 *
461 *
462 * disfree() - Destructor for the disprm struct
463 * --------------------------------------------
464 * disfree() frees memory allocated for the disprm arrays by disinit().
465 * disinit() keeps a record of the memory it allocates and disfree() will only
466 * attempt to free this.
467 *
468 * PLEASE NOTE: disfree() must not be invoked on a disprm struct that was not
469 * initialized by disinit().
470 *
471 * Given:
472 * dis struct disprm*
473 * Distortion function parameters.
474 *
475 * Function return value:
476 * int Status return value:
477 * 0: Success.
478 * 1: Null disprm pointer passed.
479 *
480 *
481 * disprt() - Print routine for the disprm struct
482 * ----------------------------------------------
483 * disprt() prints the contents of a disprm struct using wcsprintf(). Mainly
484 * intended for diagnostic purposes.
485 *
486 * Given:
487 * dis const struct disprm*
488 * Distortion function parameters.
489 *
490 * Function return value:
491 * int Status return value:
492 * 0: Success.
493 * 1: Null disprm pointer passed.
494 *
495 *
496 * disperr() - Print error messages from a disprm struct
497 * -----------------------------------------------------
498 * disperr() prints the error message(s) (if any) stored in a disprm struct.
499 * If there are no errors then nothing is printed. It uses wcserr_prt(), q.v.
500 *
501 * Given:
502 * dis const struct disprm*
503 * Distortion function parameters.
504 *
505 * prefix const char *
506 * If non-NULL, each output line will be prefixed with
507 * this string.
508 *
509 * Function return value:
510 * int Status return value:
511 * 0: Success.
512 * 1: Null disprm pointer passed.
513 *
514 *
515 * dishdo() - write FITS headers using TPD
516 * ---------------------------------------
517 * dishdo() sets a flag that tells wcshdo() to write FITS headers in the form
518 * of the TPD translation used internally. Normally SIP and TPV would be
519 * written in their native form if at all possible.
520 *
521 * Given and returned:
522 * dis struct disprm*
523 * Distortion function parameters.
524 *
525 * Function return value:
526 * int Status return value:
527 * 0: Success.
528 * 1: Null disprm pointer passed.
529 * 3: No TPD translation.
530 *
531 *
532 * disset() - Setup routine for the disprm struct
533 * ----------------------------------------------
534 * disset(), sets up the disprm struct according to information supplied within
535 * it - refer to the explanation of disprm::flag.
536 *
537 * Note that this routine need not be called directly; it will be invoked by
538 * disp2x() and disx2p() if the disprm::flag is anything other than a
539 * predefined magic value.
540 *
541 * Given and returned:
542 * dis struct disprm*
543 * Distortion function parameters.
544 *
545 * Function return value:
546 * int Status return value:
547 * 0: Success.
548 * 1: Null disprm pointer passed.
549 * 2: Memory allocation failed.
550 * 3: Invalid parameter.
551 *
552 * For returns > 1, a detailed error message is set in
553 * disprm::err if enabled, see wcserr_enable().
554 *
555 *
556 * disp2x() - Apply distortion function
557 * ------------------------------------
558 * disp2x() applies the distortion functions. By definition, the distortion
559 * is in the pixel-to-world direction.
560 *
561 * Depending on the point in the algorithm chain at which it is invoked,
562 * disp2x() may transform pixel coordinates to corrected pixel coordinates, or
563 * intermediate pixel coordinates to corrected intermediate pixel coordinates,
564 * or image coordinates to corrected image coordinates.
565 *
566 *
567 * Given and returned:
568 * dis struct disprm*
569 * Distortion function parameters.
570 *
571 * Given:
572 * rawcrd const double[naxis]
573 * Array of coordinates.
574 *
575 * Returned:
576 * discrd double[naxis]
577 * Array of coordinates to which the distortion functions
578 * have been applied.
579 *
580 * Function return value:
581 * int Status return value:
582 * 0: Success.
583 * 1: Null disprm pointer passed.
584 * 2: Memory allocation failed.
585 * 3: Invalid parameter.
586 * 4: Distort error.
587 *
588 * For returns > 1, a detailed error message is set in
589 * disprm::err if enabled, see wcserr_enable().
590 *
591 *
592 * disx2p() - Apply de-distortion function
593 * ---------------------------------------
594 * disx2p() applies the inverse of the distortion functions. By definition,
595 * the de-distortion is in the world-to-pixel direction.
596 *
597 * Depending on the point in the algorithm chain at which it is invoked,
598 * disx2p() may transform corrected pixel coordinates to pixel coordinates, or
599 * corrected intermediate pixel coordinates to intermediate pixel coordinates,
600 * or corrected image coordinates to image coordinates.
601 *
602 * disx2p() iteratively solves for the inverse using disp2x(). It assumes
603 * that the distortion is small and the functions are well-behaved, being
604 * continuous and with continuous derivatives. Also that, to first order
605 * in the neighbourhood of the solution, discrd[j] ~= a + b*rawcrd[j], i.e.
606 * independent of rawcrd[i], where i != j. This is effectively equivalent to
607 * assuming that the distortion functions are separable to first order.
608 * Furthermore, a is assumed to be small, and b close to unity.
609 *
610 * If disprm::disx2p() is defined, then disx2p() uses it to provide an initial
611 * estimate for its more precise iterative inversion.
612 *
613 * Given and returned:
614 * dis struct disprm*
615 * Distortion function parameters.
616 *
617 * Given:
618 * discrd const double[naxis]
619 * Array of coordinates.
620 *
621 * Returned:
622 * rawcrd double[naxis]
623 * Array of coordinates to which the inverse distortion
624 * functions have been applied.
625 *
626 * Function return value:
627 * int Status return value:
628 * 0: Success.
629 * 1: Null disprm pointer passed.
630 * 2: Memory allocation failed.
631 * 3: Invalid parameter.
632 * 5: De-distort error.
633 *
634 * For returns > 1, a detailed error message is set in
635 * disprm::err if enabled, see wcserr_enable().
636 *
637 *
638 * diswarp() - Compute measures of distortion
639 * ------------------------------------------
640 * diswarp() computes various measures of the distortion over a specified range
641 * of coordinates.
642 *
643 * For prior distortions, the measures may be interpreted simply as an offset
644 * in pixel coordinates. For sequent distortions, the interpretation depends
645 * on the nature of the linear transformation matrix (PCi_ja or CDi_ja). If
646 * the latter introduces a scaling, then the measures will also be scaled.
647 * Note also that the image domain, which is rectangular in pixel coordinates,
648 * may be rotated, skewed, and/or stretched in intermediate pixel coordinates,
649 * and in general cannot be defined using pixblc[] and pixtrc[].
650 *
651 * PLEASE NOTE: the measures of total distortion may be essentially meaningless
652 * if there are multiple sequent distortions with different scaling.
653 *
654 * See also linwarp().
655 *
656 * Given and returned:
657 * dis struct disprm*
658 * Distortion function parameters.
659 *
660 * Given:
661 * pixblc const double[naxis]
662 * Start of the range of pixel coordinates (for prior
663 * distortions), or intermediate pixel coordinates (for
664 * sequent distortions). May be specified as a NULL
665 * pointer which is interpreted as (1,1,...).
666 *
667 * pixtrc const double[naxis]
668 * End of the range of pixel coordinates (prior) or
669 * intermediate pixel coordinates (sequent).
670 *
671 * pixsamp const double[naxis]
672 * If positive or zero, the increment on the particular
673 * axis, starting at pixblc[]. Zero is interpreted as a
674 * unit increment. pixsamp may also be specified as a
675 * NULL pointer which is interpreted as all zeroes, i.e.
676 * unit increments on all axes.
677 *
678 * If negative, the grid size on the particular axis (the
679 * absolute value being rounded to the nearest integer).
680 * For example, if pixsamp is (-128.0,-128.0,...) then
681 * each axis will be sampled at 128 points between
682 * pixblc[] and pixtrc[] inclusive. Use caution when
683 * using this option on non-square images.
684 *
685 * Returned:
686 * nsamp int* The number of pixel coordinates sampled.
687 *
688 * Can be specified as a NULL pointer if not required.
689 *
690 * maxdis double[naxis]
691 * For each individual distortion function, the
692 * maximum absolute value of the distortion.
693 *
694 * Can be specified as a NULL pointer if not required.
695 *
696 * maxtot double* For the combination of all distortion functions, the
697 * maximum absolute value of the distortion.
698 *
699 * Can be specified as a NULL pointer if not required.
700 *
701 * avgdis double[naxis]
702 * For each individual distortion function, the
703 * mean value of the distortion.
704 *
705 * Can be specified as a NULL pointer if not required.
706 *
707 * avgtot double* For the combination of all distortion functions, the
708 * mean value of the distortion.
709 *
710 * Can be specified as a NULL pointer if not required.
711 *
712 * rmsdis double[naxis]
713 * For each individual distortion function, the
714 * root mean square deviation of the distortion.
715 *
716 * Can be specified as a NULL pointer if not required.
717 *
718 * rmstot double* For the combination of all distortion functions, the
719 * root mean square deviation of the distortion.
720 *
721 * Can be specified as a NULL pointer if not required.
722 *
723 * Function return value:
724 * int Status return value:
725 * 0: Success.
726 * 1: Null disprm pointer passed.
727 * 2: Memory allocation failed.
728 * 3: Invalid parameter.
729 * 4: Distort error.
730 *
731 *
732 * disprm struct - Distortion parameters
733 * -------------------------------------
734 * The disprm struct contains all of the information required to apply a set of
735 * distortion functions. It consists of certain members that must be set by
736 * the user ("given") and others that are set by the WCSLIB routines
737 * ("returned"). While the addresses of the arrays themselves may be set by
738 * disinit() if it (optionally) allocates memory, their contents must be set by
739 * the user.
740 *
741 * int flag
742 * (Given and returned) This flag must be set to zero whenever any of the
743 * following members of the disprm struct are set or modified:
744 *
745 * - disprm::naxis,
746 * - disprm::dtype,
747 * - disprm::ndp,
748 * - disprm::dp.
749 *
750 * This signals the initialization routine, disset(), to recompute the
751 * returned members of the disprm struct. disset() will reset flag to
752 * indicate that this has been done.
753 *
754 * PLEASE NOTE: flag must be set to -1 when disinit() is called for the
755 * first time for a particular disprm struct in order to initialize memory
756 * management. It must ONLY be used on the first initialization otherwise
757 * memory leaks may result.
758 *
759 * int naxis
760 * (Given or returned) Number of pixel and world coordinate elements.
761 *
762 * If disinit() is used to initialize the disprm struct (as would normally
763 * be the case) then it will set naxis from the value passed to it as a
764 * function argument. The user should not subsequently modify it.
765 *
766 * char (*dtype)[72]
767 * (Given) Pointer to the first element of an array of char[72] containing
768 * the name of the distortion function for each axis.
769 *
770 * int ndp
771 * (Given) The number of entries in the disprm::dp[] array.
772 *
773 * int ndpmax
774 * (Given) The length of the disprm::dp[] array.
775 *
776 * ndpmax will be set by disinit() if it allocates memory for disprm::dp[],
777 * otherwise it must be set by the user. See also disndp().
778 *
779 * struct dpkey dp
780 * (Given) Address of the first element of an array of length ndpmax of
781 * dpkey structs.
782 *
783 * As a FITS header parser encounters each DPja or DQia keyword it should
784 * load it into a dpkey struct in the array and increment ndp. However,
785 * note that a single disprm struct must hold only DPja or DQia keyvalues,
786 * not both. disset() interprets them as required by the particular
787 * distortion function.
788 *
789 * double *maxdis
790 * (Given) Pointer to the first element of an array of double specifying
791 * the maximum absolute value of the distortion for each axis computed over
792 * the whole image.
793 *
794 * It is not necessary to reset the disprm struct (via disset()) when
795 * disprm::maxdis is changed.
796 *
797 * double totdis
798 * (Given) The maximum absolute value of the combination of all distortion
799 * functions specified as an offset in pixel coordinates computed over the
800 * whole image.
801 *
802 * It is not necessary to reset the disprm struct (via disset()) when
803 * disprm::totdis is changed.
804 *
805 * int **axmap
806 * (Returned) Pointer to the first element of an array of int* containing
807 * pointers to the first elements of the axis mapping arrays for each axis.
808 *
809 * An axis mapping associates the independent variables of a distortion
810 * function with the 0-relative image axis number. For example, consider
811 * an image with a spectrum on the first axis (axis 0), followed by RA
812 * (axis 1), Dec (axis2), and time (axis 3) axes. For a distortion in
813 * (RA,Dec) and no distortion on the spectral or time axes, the axis
814 * mapping arrays, axmap[j][], would be
815 *
816 = j=0: [-1, -1, -1, -1] ...no distortion on spectral axis,
817 = 1: [ 1, 2, -1, -1] ...RA distortion depends on RA and Dec,
818 = 2: [ 2, 1, -1, -1] ...Dec distortion depends on Dec and RA,
819 = 3: [-1, -1, -1, -1] ...no distortion on time axis,
820 *
821 * where -1 indicates that there is no corresponding independent
822 * variable.
823 *
824 * int *Nhat
825 * (Returned) Pointer to the first element of an array of int* containing
826 * the number of coordinate axes that form the independent variables of the
827 * distortion function.
828 *
829 * double **offset
830 * (Returned) Pointer to the first element of an array of double*
831 * containing an offset used to renormalize the independent variables of
832 * the distortion function for each axis.
833 *
834 * The offsets are subtracted from the independent variables before
835 * scaling.
836 *
837 * double **scale
838 * (Returned) Pointer to the first element of an array of double*
839 * containing a scale used to renormalize the independent variables of the
840 * distortion function for each axis.
841 *
842 * The scale is applied to the independent variables after the offsets are
843 * subtracted.
844 *
845 * int **iparm
846 * (Returned) Pointer to the first element of an array of int*
847 * containing pointers to the first elements of the arrays of integer
848 * distortion parameters for each axis.
849 *
850 * double **dparm
851 * (Returned) Pointer to the first element of an array of double*
852 * containing pointers to the first elements of the arrays of floating
853 * point distortion parameters for each axis.
854 *
855 * int i_naxis
856 * (Returned) Dimension of the internal arrays (normally equal to naxis).
857 *
858 * int ndis
859 * (Returned) The number of distortion functions.
860 *
861 * struct wcserr *err
862 * (Returned) If enabled, when an error status is returned, this struct
863 * contains detailed information about the error, see wcserr_enable().
864 *
865 * int (**disp2x)(DISP2X_ARGS)
866 * (For internal use only.)
867 * int (**disx2p)(DISX2P_ARGS)
868 * (For internal use only.)
869 * double *tmpmem
870 * (For internal use only.)
871 * int m_flag
872 * (For internal use only.)
873 * int m_naxis
874 * (For internal use only.)
875 * char (*m_dtype)[72]
876 * (For internal use only.)
877 * double **m_dp
878 * (For internal use only.)
879 * double *m_maxdis
880 * (For internal use only.)
881 *
882 *
883 * dpkey struct - Store for DPja and DQia keyvalues
884 * ------------------------------------------------
885 * The dpkey struct is used to pass the parsed contents of DPja or DQia
886 * keyrecords to disset() via the disprm struct. A disprm struct must hold
887 * only DPja or DQia keyvalues, not both.
888 *
889 * All members of this struct are to be set by the user.
890 *
891 * char field[72]
892 * (Given) The full field name of the record, including the keyword name.
893 * Note that the colon delimiter separating the field name and the value in
894 * record-valued keyvalues is not part of the field name. For example, in
895 * the following:
896 *
897 = DP3A = 'AXIS.1: 2'
898 *
899 * the full record field name is "DP3A.AXIS.1", and the record's value
900 * is 2.
901 *
902 * int j
903 * (Given) Axis number (1-relative), i.e. the j in DPja or i in DQia.
904 *
905 * int type
906 * (Given) The data type of the record's value
907 * - 0: Integer (stored as an int),
908 * - 1: Floating point (stored as a double).
909 *
910 * union value
911 * (Given) A union comprised of
912 * - dpkey::i,
913 * - dpkey::f,
914 *
915 * the record's value.
916 *
917 *
918 * Global variable: const char *dis_errmsg[] - Status return messages
919 * ------------------------------------------------------------------
920 * Error messages to match the status value returned from each function.
921 *
922 *===========================================================================*/
923 
924 #ifndef WCSLIB_DIS
925 #define WCSLIB_DIS
926 
927 #ifdef __cplusplus
928 extern "C" {
929 #endif
930 
931 
932 extern const char *dis_errmsg[];
933 
935  DISERR_SUCCESS = 0, /* Success. */
936  DISERR_NULL_POINTER = 1, /* Null disprm pointer passed. */
937  DISERR_MEMORY = 2, /* Memory allocation failed. */
938  DISERR_BAD_PARAM = 3, /* Invalid parameter value. */
939  DISERR_DISTORT = 4, /* Distortion error. */
940  DISERR_DEDISTORT = 5 /* De-distortion error. */
941 };
942 
943 /* For use in declaring distortion function prototypes (= DISX2P_ARGS). */
944 #define DISP2X_ARGS int inverse, const int iparm[], const double dparm[], \
945 int ncrd, const double rawcrd[], double *discrd
946 
947 /* For use in declaring de-distortion function prototypes (= DISP2X_ARGS). */
948 #define DISX2P_ARGS int inverse, const int iparm[], const double dparm[], \
949 int ncrd, const double discrd[], double *rawcrd
950 
951 
952 /* Struct used for storing DPja and DQia keyvalues. */
953 struct dpkey {
954  char field[72]; /* Full record field name (no colon). */
955  int j; /* Axis number, as in DPja (1-relative). */
956  int type; /* Data type of value. */
957  union {
958  int i; /* Integer record value. */
959  double f; /* Floating point record value. */
960  } value; /* Record value. */
961 };
962 
963 /* Size of the dpkey struct in int units, used by the Fortran wrappers. */
964 #define DPLEN (sizeof(struct dpkey)/sizeof(int))
965 
966 
967 struct disprm {
968  /* Initialization flag (see the prologue above). */
969  /*------------------------------------------------------------------------*/
970  int flag; /* Set to zero to force initialization. */
971 
972  /* Parameters to be provided (see the prologue above). */
973  /*------------------------------------------------------------------------*/
974  int naxis; /* The number of pixel coordinate elements, */
975  /* given by NAXIS. */
976  char (*dtype)[72]; /* For each axis, the distortion type. */
977  int ndp; /* Number of DPja or DQia keywords, and the */
978  int ndpmax; /* number for which space was allocated. */
979  struct dpkey *dp; /* DPja or DQia keyvalues (not both). */
980  double *maxdis; /* For each axis, the maximum distortion. */
981  double totdis; /* The maximum combined distortion. */
982 
983  /* Information derived from the parameters supplied. */
984  /*------------------------------------------------------------------------*/
985  int **axmap; /* For each axis, the axis mapping array. */
986  int *Nhat; /* For each axis, the number of coordinate */
987  /* axes that form the independent variables */
988  /* of the distortion function. */
989  double **offset; /* For each axis, renormalization offsets. */
990  double **scale; /* For each axis, renormalization scales. */
991  int **iparm; /* For each axis, the array of integer */
992  /* distortion parameters. */
993  double **dparm; /* For each axis, the array of floating */
994  /* point distortion parameters. */
995  int i_naxis; /* Dimension of the internal arrays. */
996  int ndis; /* The number of distortion functions. */
997 
998  /* Error handling, if enabled. */
999  /*------------------------------------------------------------------------*/
1000  struct wcserr *err;
1001 
1002  /* Private - the remainder are for internal use. */
1003  /*------------------------------------------------------------------------*/
1004  int (**disp2x)(DISP2X_ARGS); /* For each axis, pointers to the */
1005  int (**disx2p)(DISX2P_ARGS); /* distortion function and its inverse. */
1006 
1007  double *tmpmem;
1008 
1009  int m_flag, m_naxis; /* The remainder are for memory management. */
1010  char (*m_dtype)[72];
1011  struct dpkey *m_dp;
1012  double *m_maxdis;
1013 };
1014 
1015 /* Size of the disprm struct in int units, used by the Fortran wrappers. */
1016 #define DISLEN (sizeof(struct disprm)/sizeof(int))
1017 
1018 
1019 int disndp(int n);
1020 
1021 int dpfill(struct dpkey *dp, const char *keyword, const char *field, int j,
1022  int type, int i, double f);
1023 
1024 int disini(int alloc, int naxis, struct disprm *dis);
1025 
1026 int disinit(int alloc, int naxis, struct disprm *dis, int ndpmax);
1027 
1028 int discpy(int alloc, const struct disprm *dissrc, struct disprm *disdst);
1029 
1030 int disfree(struct disprm *dis);
1031 
1032 int disprt(const struct disprm *dis);
1033 
1034 int disperr(const struct disprm *dis, const char *prefix);
1035 
1036 int dishdo(struct disprm *dis);
1037 
1038 int disset(struct disprm *dis);
1039 
1040 int disp2x(struct disprm *dis, const double rawcrd[], double discrd[]);
1041 
1042 int disx2p(struct disprm *dis, const double discrd[], double rawcrd[]);
1043 
1044 int diswarp(struct disprm *dis, const double pixblc[], const double pixtrc[],
1045  const double pixsamp[], int *nsamp,
1046  double maxdis[], double *maxtot,
1047  double avgdis[], double *avgtot,
1048  double rmsdis[], double *rmstot);
1049 
1050 #ifdef __cplusplus
1051 }
1052 #endif
1053 
1054 #endif /* WCSLIB_DIS */
int type
Definition: dis.h:956
int flag
Definition: dis.h:970
Store for DPja and DQia keyvalues.
Definition: dis.h:953
int discpy(int alloc, const struct disprm *dissrc, struct disprm *disdst)
Copy routine for the disprm struct.
int ** iparm
Definition: dis.h:991
Definition: dis.h:939
const char * dis_errmsg[]
Status return messages.
int disperr(const struct disprm *dis, const char *prefix)
Print error messages from a disprm struct.
int ** axmap
Definition: dis.h:985
int dishdo(struct disprm *dis)
write FITS headers using TPD.
int disp2x(struct disprm *dis, const double rawcrd[], double discrd[])
Apply distortion function.
double ** scale
Definition: dis.h:990
Error message handling.
Definition: wcserr.h:225
int disx2p(struct disprm *dis, const double discrd[], double rawcrd[])
Apply de-distortion function.
Definition: dis.h:938
int disset(struct disprm *dis)
Setup routine for the disprm struct.
int naxis
Definition: dis.h:974
struct dpkey * dp
Definition: dis.h:979
int m_flag
Definition: dis.h:1009
Definition: dis.h:940
int ndis
Definition: dis.h:996
Distortion parameters.
Definition: dis.h:967
char field[72]
Definition: dis.h:954
int ndp
Definition: dis.h:977
char(* m_dtype)[72]
Definition: dis.h:1010
int j
Definition: dis.h:955
Definition: dis.h:936
int * Nhat
Definition: dis.h:986
int disfree(struct disprm *dis)
Destructor for the disprm struct.
dis_errmsg_enum
Definition: dis.h:934
int m_naxis
Definition: dis.h:1009
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.
int disprt(const struct disprm *dis)
Print routine for the disprm struct.
double * tmpmem
Definition: dis.h:1007
int i_naxis
Definition: dis.h:995
double * maxdis
Definition: dis.h:980
double totdis
Definition: dis.h:981
int(** disx2p)(DISX2P_ARGS)
Definition: dis.h:1005
Definition: dis.h:935
struct wcserr * err
Definition: dis.h:1000
char(* dtype)[72]
Definition: dis.h:976
int disini(int alloc, int naxis, struct disprm *dis)
Default constructor for the disprm struct.
union dpkey::@0 value
double f
Definition: dis.h:959
Definition: dis.h:937
struct dpkey * m_dp
Definition: dis.h:1011
double * m_maxdis
Definition: dis.h:1012
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.
double ** offset
Definition: dis.h:989
int disinit(int alloc, int naxis, struct disprm *dis, int ndpmax)
Default constructor for the disprm struct.
#define DISX2P_ARGS
Definition: dis.h:948
int(** disp2x)(DISP2X_ARGS)
Definition: dis.h:1004
int ndpmax
Definition: dis.h:978
int disndp(int n)
Memory allocation for DPja and DQia.
int i
Definition: dis.h:958
#define DISP2X_ARGS
Definition: dis.h:944
double ** dparm
Definition: dis.h:993