WCSLIB: dis.h Source File

WCSLIB 6.2

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