20#include "hdrl_cat_table.h"
22#include "hdrl_cat_areals.h"
23#include "hdrl_cat_radii.h"
24#include "hdrl_cat_phopt.h"
25#include "hdrl_cat_seeing.h"
26#include "hdrl_cat_overlp.h"
27#include "hdrl_cat_moments.h"
28#include "hdrl_cat_extend.h"
29#include "hdrl_cat_background.h"
52#define COL_PEAKHEIGHT 18
55#define COL_APFLUX1ERR 21
57#define COL_APFLUX2ERR 23
59#define COL_APFLUX3ERR 25
61#define COL_APFLUX4ERR 27
63#define COL_APFLUX5ERR 29
65#define COL_APFLUX6ERR 31
67#define COL_APFLUX7ERR 33
69#define COL_APFLUX8ERR 35
71#define COL_APFLUX9ERR 37
72#define COL_APFLUX10 38
73#define COL_APFLUX10ERR 39
74#define COL_APFLUX11 40
75#define COL_APFLUX11ERR 41
76#define COL_APFLUX12 42
77#define COL_APFLUX12ERR 43
78#define COL_APFLUX13 44
79#define COL_APFLUX13ERR 45
84#define COL_PETFLUXERR 50
85#define COL_KRONFLUX 51
86#define COL_KRONFLUXERR 52
87#define COL_HALFFLUX 53
88#define COL_HALFFLUXERR 54
90#define COL_SKYLEVEL 56
91#define COL_SKYSIGMA 57
100static const char *ttype[NCOLS]={
"Sequence_number",
"Isophotal_flux",
101 "X_coordinate",
"X_coordinate_err",
102 "Y_coordinate",
"Y_coordinate_err",
103 "Gaussian_sigma",
"Ellipticity",
"Position_angle",
104 "Areal_1_profile",
"Areal_2_profile",
"Areal_3_profile",
105 "Areal_4_profile",
"Areal_5_profile",
"Areal_6_profile",
106 "Areal_7_profile",
"Areal_8_profile",
107 "Peak_height",
"Peak_height_err",
108 "Aper_flux_1",
"Aper_flux_1_err",
109 "Aper_flux_2",
"Aper_flux_2_err",
110 "Aper_flux_3",
"Aper_flux_3_err",
111 "Aper_flux_4",
"Aper_flux_4_err",
112 "Aper_flux_5",
"Aper_flux_5_err",
113 "Aper_flux_6",
"Aper_flux_6_err",
114 "Aper_flux_7",
"Aper_flux_7_err",
115 "Aper_flux_8",
"Aper_flux_8_err",
116 "Aper_flux_9",
"Aper_flux_9_err",
117 "Aper_flux_10",
"Aper_flux_10_err",
118 "Aper_flux_11",
"Aper_flux_11_err",
119 "Aper_flux_12",
"Aper_flux_12_err",
120 "Aper_flux_13",
"Aper_flux_13_err",
121 "Petr_radius",
"Kron_radius",
"Half_radius",
122 "Petr_flux",
"Petr_flux_err",
123 "Kron_flux",
"Kron_flux_err",
"Half_flux",
"Half_flux_err",
124 "Error_bit_flag",
"Sky_level",
"Sky_rms",
126 "RA",
"DEC",
"Classification",
"Statistic",
129static const char *tunit[NCOLS]={
"Number",
"ADU",
132 "Pixels",
"Number",
"Degrees",
133 "Pixels",
"Pixels",
"Pixels",
134 "Pixels",
"Pixels",
"Pixels",
150 "Pixels",
"Pixels",
"Pixels",
152 "ADU",
"ADU",
"ADU",
"ADU",
153 "Number",
"ADU",
"ADU",
"Number",
154 "Degrees",
"Degrees",
"Flag",
"N-sigma",
157static cpl_type g_tform[NCOLS]={CPL_TYPE_INT, CPL_TYPE_DOUBLE,
158 CPL_TYPE_DOUBLE, CPL_TYPE_DOUBLE,
159 CPL_TYPE_DOUBLE, CPL_TYPE_DOUBLE,
160 CPL_TYPE_DOUBLE, CPL_TYPE_DOUBLE, CPL_TYPE_DOUBLE,
161 CPL_TYPE_DOUBLE, CPL_TYPE_DOUBLE, CPL_TYPE_DOUBLE,
162 CPL_TYPE_DOUBLE, CPL_TYPE_DOUBLE, CPL_TYPE_DOUBLE,
163 CPL_TYPE_DOUBLE, CPL_TYPE_DOUBLE,
164 CPL_TYPE_DOUBLE, CPL_TYPE_DOUBLE,
165 CPL_TYPE_DOUBLE, CPL_TYPE_DOUBLE,
166 CPL_TYPE_DOUBLE, CPL_TYPE_DOUBLE,
167 CPL_TYPE_DOUBLE, CPL_TYPE_DOUBLE,
168 CPL_TYPE_DOUBLE, CPL_TYPE_DOUBLE,
169 CPL_TYPE_DOUBLE, CPL_TYPE_DOUBLE,
170 CPL_TYPE_DOUBLE, CPL_TYPE_DOUBLE,
171 CPL_TYPE_DOUBLE, CPL_TYPE_DOUBLE,
172 CPL_TYPE_DOUBLE, CPL_TYPE_DOUBLE,
173 CPL_TYPE_DOUBLE, CPL_TYPE_DOUBLE,
174 CPL_TYPE_DOUBLE, CPL_TYPE_DOUBLE,
175 CPL_TYPE_DOUBLE, CPL_TYPE_DOUBLE,
176 CPL_TYPE_DOUBLE, CPL_TYPE_DOUBLE,
177 CPL_TYPE_DOUBLE, CPL_TYPE_DOUBLE,
178 CPL_TYPE_DOUBLE, CPL_TYPE_DOUBLE, CPL_TYPE_DOUBLE,
179 CPL_TYPE_DOUBLE, CPL_TYPE_DOUBLE,
180 CPL_TYPE_DOUBLE, CPL_TYPE_DOUBLE, CPL_TYPE_DOUBLE,
182 CPL_TYPE_DOUBLE, CPL_TYPE_DOUBLE, CPL_TYPE_DOUBLE,
184 CPL_TYPE_DOUBLE, CPL_TYPE_DOUBLE, CPL_TYPE_DOUBLE,
185 CPL_TYPE_DOUBLE, CPL_TYPE_DOUBLE};
188static double g_apertures[NRADS];
190static double g_rmults[] = {0.5,
196 4., 5., 6., 7., 8., 10., 12.0};
198static cpl_size g_nrcore = 2;
199static cpl_size g_n2rcore = 4;
201static cpl_size g_areal_cols[NAREAL] = {COL_AREAL1, COL_AREAL2, COL_AREAL3,
202 COL_AREAL4, COL_AREAL5, COL_AREAL6,
203 COL_AREAL7, COL_AREAL8};
208static cpl_error_code hdrl_do_seeing_gen(
209 ap_t *ap,
const char *col_ellipt,
const char *col_pkht,
210 const char *col_areals[NAREAL], cpl_size nobjects, cpl_table *tab);
212static cpl_error_code hdrl_tabinit_gen(
213 cpl_size ncols, cpl_type tform[], cpl_table **tab);
247 ap_t *ap, cpl_size *xcol, cpl_size *ycol, hdrl_catalogue_options cattype,
248 cpl_table **tab, hdrl_casu_result *res)
255 cpl_error_code e = hdrl_tabinit_gen(NCOLS, g_tform, tab);
256 if (e == CPL_ERROR_NONE){
258 if (cattype & HDRL_CATALOGUE_SEGMAP) {
259 res->segmentation_map = cpl_image_new(ap->lsiz, ap->csiz, CPL_TYPE_INT);
261 res->segmentation_map = NULL;
264 if (cattype & HDRL_CATALOGUE_BKG) {
265 res->background = cpl_image_new(ap->lsiz, ap->csiz, CPL_TYPE_DOUBLE);
267 res->background = NULL;
291 ap_t *ap, cpl_size nobjects, cpl_table *tab)
294 const char *areal_colnames[NAREAL];
295 for (cpl_size i = 0; i < NAREAL; i++) {
296 areal_colnames[i] = (
const char *)ttype[g_areal_cols[i] - 1];
300 return hdrl_do_seeing_gen( ap,
301 ttype[COL_ELLIPT - 1],
302 ttype[COL_PEAKHEIGHT - 1],
303 areal_colnames, nobjects, tab);
325 ap_t *ap,
double gain, cpl_size *nobjects, cpl_table *tab, hdrl_casu_result *res)
328 double momresults[8];
330 if (momresults[0] < 0) {
331 return CPL_ERROR_ILLEGAL_INPUT;
334 cpl_size iareal[NAREAL];
338 if (iareal[0] < ap->ipnop || momresults[3] < ap->xintmin) {
339 return CPL_ERROR_NONE;
344 hdrl_extend( ap, momresults[3], momresults[1], momresults[2],
345 momresults[4], momresults[5], momresults[6], (
double)(iareal[0]),
346 momresults[7], &ttotal);
350 double parmall[IMNUM][NPAR];
351 if (iareal[0] >= ap->mulpix && ap->icrowd) {
366 parmall[0][0] = momresults[3];
367 parmall[0][1] = momresults[1];
368 parmall[0][2] = momresults[2];
369 parmall[0][3] = ap->thresh;
371 for (cpl_size i = 4; i < 8; i++) {
372 parmall[0][i] = momresults[i];
375 for (cpl_size i = 0; i < NAREAL; i++) {
376 parmall[0][i + 8] = (double)(iareal[i]);
382 for (cpl_size i = 0; i < nbit; i++) {
384 if ( parmall[i][1] > 1. && parmall[i][1] < ap->lsiz
385 && parmall[i][2] > 1. && parmall[i][2] < ap->csiz) {
387 for (cpl_size j = 0; j < NPAR; j++) {
388 parmall[mbit][j] = parmall[i][j];
397 return CPL_ERROR_NONE;
402 double badpix[IMNUM];
403 double skyvar[IMNUM];
404 double avconf[IMNUM];
405 for (cpl_size i = 0; i < NRADS; i++) {
406 g_apertures[i] = g_rmults[i] * (ap->rcore);
407 skyvar[i] = CPL_MATH_PI * g_apertures[i] * g_apertures[i];
410 double rcore_area = CPL_MATH_PI * pow(ap->rcore, 2.);
413 for (cpl_size i = 0; i < nbit; i++) {
419 double cflux[NRADS * IMNUM];
420 hdrl_phopt(ap, parmall, nbit, NRADS, g_apertures, cflux, badpix, g_nrcore, avconf);
421 for (cpl_size i = 0; i < nbit; i++) {
422 avconf[i] /= rcore_area;
426 double half_flux[IMNUM];
427 double half_rad[ IMNUM];
428 for (cpl_size k = 0; k < nbit; k++) {
430 half_flux[k] = 0.5 * (CPL_MAX(parmall[k][0], cflux[k * NRADS + g_n2rcore]));
441 double kron_flux[IMNUM];
442 double kron_rad[ IMNUM];
443 for (cpl_size k = 0; k < nbit; k++) {
444 areal = parmall[k][8];
445 kron_rad[k] =
hdrl_kronrad(areal, g_apertures, cflux + k * NRADS, NRADS);
447 hdrl_flux(ap, parmall, nbit, kron_rad, kron_flux, NRADS, g_apertures, cflux);
450 double petr_flux[IMNUM];
451 double petr_rad[ IMNUM];
452 for (cpl_size k = 0; k < nbit; k++) {
453 areal = parmall[k][8];
454 petr_rad[k] =
hdrl_petrad(areal, g_apertures, cflux + k * NRADS, NRADS);
456 hdrl_flux(ap, parmall, nbit, petr_rad, petr_flux, NRADS, g_apertures, cflux);
459 double sigsq = pow(ap->sigma, 2.);
460 double radeg = 180. / CPL_MATH_PI;
462 for (cpl_size k = 0; k < nbit; k++) {
464 double sxx = parmall[k][4];
465 double sxy = parmall[k][5];
466 double syy = parmall[k][6];
468 double srr = CPL_MAX(0.5, sxx + syy);
471 sxy = CPL_MAX( 1.e-4, CPL_MIN(sxy, sqrt(sxx * syy)));
473 sxy = CPL_MIN(-1.e-4, CPL_MAX(sxy, -sqrt(sxx * syy)));
476 double ecc = sqrt((syy - sxx) * (syy - sxx) + 4. * sxy * sxy) / srr;
478 double temp = CPL_MAX((1. - ecc) / (1. + ecc), 0.);
479 double ell = CPL_MIN(0.99, CPL_MAX(0., 1. - sqrt(temp)));
481 double xx = 0.5 * (1. + ecc) * srr - sxx;
488 theta = 90. - radeg * atan(sxy / xx);
490 double theta_ra = theta/radeg;
492 double cc = (1. + ecc) * pow(cos(theta_ra), 2.) + (1. - ecc) * pow(sin(theta_ra), 2.);
493 double dd = (1. + ecc) * pow(sin(theta_ra), 2.) + (1. - ecc) * pow(cos(theta_ra), 2.);
496 cpl_size nrows = cpl_table_get_nrow(tab);
499 if (*nobjects > nrows) {
500 cpl_table_set_size(tab, nrows + INITROWS);
502 cpl_size nr = *nobjects - 1;
504 double iso_flux = parmall[k][0];
506 double apflux1 = cflux[k * NRADS + 0];
507 double apflux2 = cflux[k * NRADS + 1];
508 double apflux3 = cflux[k * NRADS + 2];
509 double apflux4 = cflux[k * NRADS + 3];
510 double apflux5 = cflux[k * NRADS + 4];
511 double apflux6 = cflux[k * NRADS + 5];
512 double apflux7 = cflux[k * NRADS + 6];
513 double apflux8 = cflux[k * NRADS + 7];
514 double apflux9 = cflux[k * NRADS + 8];
515 double apflux10 = cflux[k * NRADS + 9];
516 double apflux11 = cflux[k * NRADS + 10];
517 double apflux12 = cflux[k * NRADS + 11];
518 double apflux13 = cflux[k * NRADS + 12];
520 double peak = parmall[k][7];
525 double xxe = sqrt( (2. * sigsq / (CPL_MATH_PI * peak * peak))
526 + cc / (2. * CPL_MATH_PI * gain * peak)
529 double yye = sqrt( (2. * sigsq / (CPL_MATH_PI * peak * peak))
530 + dd / (2. * CPL_MATH_PI * gain * peak)
533 double sigma = sqrt(srr);
534 double fwhm = sqrt(sigma * sigma / 2.) * CPL_MATH_FWHM_SIG;
538 fwhm -= 1. / (4. * fwhm);
540 double areal1 = parmall[k][8];
541 double areal2 = parmall[k][9];
542 double areal3 = parmall[k][10];
543 double areal4 = parmall[k][11];
544 double areal5 = parmall[k][12];
545 double areal6 = parmall[k][13];
546 double areal7 = parmall[k][14];
549 if (nbit > 1 && k == 0) {
552 areal8 = parmall[k][15];
559 double kron_fluxe = sqrt(kron_flux[k] / gain + (sigsq + skyrms * skyrms) * CPL_MATH_PI * pow(kron_rad[k], 2.));
560 double petr_fluxe = sqrt(petr_flux[k] / gain + (sigsq + skyrms * skyrms) * CPL_MATH_PI * pow(petr_rad[k], 2.));
561 double half_fluxe = sqrt(CPL_MAX(0., half_flux[k]) / gain + (sigsq + skyrms * skyrms) * CPL_MATH_PI * pow(half_rad[k], 2.));
563 double apflux1e = sqrt(CPL_MAX(0., apflux1 / gain) + skyvar[0 ] * (sigsq + skyrms * skyrms));
564 double apflux2e = sqrt(CPL_MAX(0., apflux2 / gain) + skyvar[1 ] * (sigsq + skyrms * skyrms));
565 double apflux3e = sqrt(CPL_MAX(0., apflux3 / gain) + skyvar[2 ] * (sigsq + skyrms * skyrms));
566 double apflux4e = sqrt(CPL_MAX(0., apflux4 / gain) + skyvar[3 ] * (sigsq + skyrms * skyrms));
567 double apflux5e = sqrt(CPL_MAX(0., apflux5 / gain) + skyvar[4 ] * (sigsq + skyrms * skyrms));
568 double apflux6e = sqrt(CPL_MAX(0., apflux6 / gain) + skyvar[5 ] * (sigsq + skyrms * skyrms));
569 double apflux7e = sqrt(CPL_MAX(0., apflux7 / gain) + skyvar[6 ] * (sigsq + skyrms * skyrms));
570 double apflux8e = sqrt(CPL_MAX(0., apflux8 / gain) + skyvar[7 ] * (sigsq + skyrms * skyrms));
571 double apflux9e = sqrt(CPL_MAX(0., apflux9 / gain) + skyvar[8 ] * (sigsq + skyrms * skyrms));
572 double apflux10e = sqrt(CPL_MAX(0., apflux10 / gain) + skyvar[9 ] * (sigsq + skyrms * skyrms));
573 double apflux11e = sqrt(CPL_MAX(0., apflux11 / gain) + skyvar[10] * (sigsq + skyrms * skyrms));
574 double apflux12e = sqrt(CPL_MAX(0., apflux12 / gain) + skyvar[11] * (sigsq + skyrms * skyrms));
575 double apflux13e = sqrt(CPL_MAX(0., apflux13 / gain) + skyvar[12] * (sigsq + skyrms * skyrms));
577 double peake = sqrt(peak / gain + sigsq + skyrms * skyrms) ;
580 cpl_table_set_int( tab, ttype[COL_NUMBER - 1], nr, *nobjects);
581 cpl_table_set_double(tab, ttype[COL_FLUXISO - 1], nr, iso_flux);
582 cpl_table_set_double(tab, ttype[COL_X - 1], nr, xx);
583 cpl_table_set_double(tab, ttype[COL_XERR - 1], nr, xxe);
584 cpl_table_set_double(tab, ttype[COL_Y - 1], nr, yy);
585 cpl_table_set_double(tab, ttype[COL_YERR - 1], nr, yye);
586 cpl_table_set_double(tab, ttype[COL_SIGMA - 1], nr, sigma);
587 cpl_table_set_double(tab, ttype[COL_ELLIPT - 1], nr, ell);
588 cpl_table_set_double(tab, ttype[COL_PA - 1], nr, theta);
589 cpl_table_set_double(tab, ttype[COL_AREAL1 - 1], nr, areal1);
590 cpl_table_set_double(tab, ttype[COL_AREAL2 - 1], nr, areal2);
591 cpl_table_set_double(tab, ttype[COL_AREAL3 - 1], nr, areal3);
592 cpl_table_set_double(tab, ttype[COL_AREAL4 - 1], nr, areal4);
593 cpl_table_set_double(tab, ttype[COL_AREAL5 - 1], nr, areal5);
594 cpl_table_set_double(tab, ttype[COL_AREAL6 - 1], nr, areal6);
595 cpl_table_set_double(tab, ttype[COL_AREAL7 - 1], nr, areal7);
596 cpl_table_set_double(tab, ttype[COL_AREAL8 - 1], nr, areal8);
597 cpl_table_set_double(tab, ttype[COL_PEAKHEIGHT - 1], nr, peak);
598 cpl_table_set_double(tab, ttype[COL_PKHTERR - 1], nr, peake);
599 cpl_table_set_double(tab, ttype[COL_APFLUX1 - 1], nr, apflux1);
600 cpl_table_set_double(tab, ttype[COL_APFLUX1ERR - 1], nr, apflux1e);
601 cpl_table_set_double(tab, ttype[COL_APFLUX2 - 1], nr, apflux2);
602 cpl_table_set_double(tab, ttype[COL_APFLUX2ERR - 1], nr, apflux2e);
603 cpl_table_set_double(tab, ttype[COL_APFLUX3 - 1], nr, apflux3);
604 cpl_table_set_double(tab, ttype[COL_APFLUX3ERR - 1], nr, apflux3e);
605 cpl_table_set_double(tab, ttype[COL_APFLUX4 - 1], nr, apflux4);
606 cpl_table_set_double(tab, ttype[COL_APFLUX4ERR - 1], nr, apflux4e);
607 cpl_table_set_double(tab, ttype[COL_APFLUX5 - 1], nr, apflux5);
608 cpl_table_set_double(tab, ttype[COL_APFLUX5ERR - 1], nr, apflux5e);
609 cpl_table_set_double(tab, ttype[COL_APFLUX6 - 1], nr, apflux6);
610 cpl_table_set_double(tab, ttype[COL_APFLUX6ERR - 1], nr, apflux6e);
611 cpl_table_set_double(tab, ttype[COL_APFLUX7 - 1], nr, apflux7);
612 cpl_table_set_double(tab, ttype[COL_APFLUX7ERR - 1], nr, apflux7e);
613 cpl_table_set_double(tab, ttype[COL_APFLUX8 - 1], nr, apflux8);
614 cpl_table_set_double(tab, ttype[COL_APFLUX8ERR - 1], nr, apflux8e);
615 cpl_table_set_double(tab, ttype[COL_APFLUX9 - 1], nr, apflux9);
616 cpl_table_set_double(tab, ttype[COL_APFLUX9ERR - 1], nr, apflux9e);
617 cpl_table_set_double(tab, ttype[COL_APFLUX10 - 1], nr, apflux10);
618 cpl_table_set_double(tab, ttype[COL_APFLUX10ERR - 1], nr, apflux10e);
619 cpl_table_set_double(tab, ttype[COL_APFLUX11 - 1], nr, apflux11);
620 cpl_table_set_double(tab, ttype[COL_APFLUX11ERR - 1], nr, apflux11e);
621 cpl_table_set_double(tab, ttype[COL_APFLUX12 - 1], nr, apflux12);
622 cpl_table_set_double(tab, ttype[COL_APFLUX12ERR - 1], nr, apflux12e);
623 cpl_table_set_double(tab, ttype[COL_APFLUX13 - 1], nr, apflux13);
624 cpl_table_set_double(tab, ttype[COL_APFLUX13ERR - 1], nr, apflux13e);
625 cpl_table_set_double(tab, ttype[COL_PETRAD - 1], nr, 0.5 * petr_rad[k]);
626 cpl_table_set_double(tab, ttype[COL_KRONRAD - 1], nr, 0.5 * kron_rad[k]);
627 cpl_table_set_double(tab, ttype[COL_HALFRAD - 1], nr, half_rad[k]);
628 cpl_table_set_double(tab, ttype[COL_PETFLUX - 1], nr, petr_flux[k]);
629 cpl_table_set_double(tab, ttype[COL_PETFLUXERR - 1], nr, petr_fluxe);
630 cpl_table_set_double(tab, ttype[COL_KRONFLUX - 1], nr, kron_flux[k]);
631 cpl_table_set_double(tab, ttype[COL_KRONFLUXERR - 1], nr, kron_fluxe);
632 cpl_table_set_double(tab, ttype[COL_HALFFLUX - 1], nr, half_flux[k]);
633 cpl_table_set_double(tab, ttype[COL_HALFFLUXERR - 1], nr, half_fluxe);
634 cpl_table_set_double(tab, ttype[COL_ERRFLAG - 1], nr, badpix[k]);
635 cpl_table_set_double(tab, ttype[COL_SKYLEVEL - 1], nr, skylev);
636 cpl_table_set_double(tab, ttype[COL_SKYSIGMA - 1], nr, skyrms);
637 cpl_table_set_double(tab, ttype[COL_AVCONF - 1], nr, avconf[k]);
638 cpl_table_set_double(tab, ttype[COL_FWHM - 1], nr, fwhm);
642 cpl_table_set_double(tab, ttype[COL_RA - 1], nr, zero);
643 cpl_table_set_double(tab, ttype[COL_DEC - 1], nr, zero);
644 cpl_table_set_double(tab, ttype[COL_CLASS - 1], nr, 100.);
645 cpl_table_set_double(tab, ttype[COL_STAT - 1], nr, zero);
649 cpl_msg_info(cpl_func,
"Num objects found in catalogue: %lld", *nobjects);
650 if (res->segmentation_map) {
651 for (cpl_size index = 0; index < ap->npl_pix; index++) {
652 cpl_image_set( res->segmentation_map,
653 ap->plarray[index].x,
654 ap->plarray[index].y,
659 return CPL_ERROR_NONE;
680static cpl_error_code hdrl_tabinit_gen(
681 cpl_size ncols, cpl_type tform[], cpl_table **tab)
684 if ((*tab = cpl_table_new(0)) == NULL) {
686 cpl_error_set_message(cpl_func, CPL_ERROR_ILLEGAL_INPUT,
687 "hdrl_cat_tabinit_gen - Unable to open cpl table!");
688 return CPL_ERROR_ILLEGAL_INPUT;
693 for (cpl_size i = 0; i < ncols; i++) {
695 cpl_table_new_column( *tab, ttype[i], tform[i]);
696 cpl_table_set_column_unit(*tab, ttype[i], tunit[i]);
699 return CPL_ERROR_NONE;
720static cpl_error_code hdrl_do_seeing_gen(
721 ap_t *ap,
const char *col_ellipt,
const char *col_pkht,
722 const char *col_areals[NAREAL], cpl_size nobjects, cpl_table *tab)
728 double *areal[NAREAL];
729 for (cpl_size i = 0; i < NAREAL; i++) {
730 areal[i] = cpl_table_get_data_double(tab, col_areals[i]);
733 double *ellipt = cpl_table_get_data_double(tab, col_ellipt);
734 double *pkht = cpl_table_get_data_double(tab, col_pkht);
737 double *work = cpl_malloc(nobjects *
sizeof(
double));
738 hdrl_seeing(ap, nobjects, ellipt, pkht, areal, work, &fwhm);
747 return CPL_ERROR_NONE;
void hdrl_areals(ap_t *ap, cpl_size iareal[NAREAL])
Work out the areal profiles for an object.
void hdrl_backest(ap_t *ap, double x, double y, double *skylev, double *skyrms)
Work out estimated sky for a pixel position.
cpl_error_code hdrl_process_results(ap_t *ap, double gain, cpl_size *nobjects, cpl_table *tab, hdrl_casu_result *res)
Process the results for each object and store them in the table.
cpl_error_code hdrl_do_seeing(ap_t *ap, cpl_size nobjects, cpl_table *tab)
Do seeing estimate.
cpl_error_code hdrl_tabinit(ap_t *ap, cpl_size *xcol, cpl_size *ycol, hdrl_catalogue_options cattype, cpl_table **tab, hdrl_casu_result *res)
Initialize catalogues.
cpl_error_code hdrl_extend(ap_t *ap, double xniso, double xbar, double ybar, double sxx, double sxy, double syy, double areal0, double tmax, double *ttotal)
Do aperture integration.
void hdrl_moments(ap_t *ap, double results[])
Do moments analysis on an object in a Plessey array.
cpl_error_code hdrl_overlp(ap_t *ap, double parm[IMNUM][NPAR], cpl_size *nbit, double xbar, double ybar, double total, cpl_size npix, double tmax)
Deblend overlapping images.
cpl_error_code hdrl_phopt(ap_t *ap, double parm[IMNUM][NPAR], cpl_size nbit, cpl_size naper, double apertures[], double cflux[], double badpix[], cpl_size nrcore, double avconf[])
Does multiple profile fitting to determine intensities.
void hdrl_flux(ap_t *ap, double parm[IMNUM][NPAR], cpl_size nbit, double apers[], double fluxes[], cpl_size nr, double rcores[], double rfluxes[])
Work out the fluxes for special radii.
double hdrl_petrad(double areal0, double rcores[], double cflux[], cpl_size naper)
Work out the Petrosian radius for an object.
double hdrl_kronrad(double areal0, double rcores[], double cflux[], cpl_size naper)
Work out the Kron radius for an object.
double hdrl_halflight(double rcores[], double cflux[], double halflight, double peak, cpl_size naper)
Work out the half-light radius for an object.
cpl_error_code hdrl_seeing(ap_t *ap, cpl_size nrows, double *ellipt, double *pkht, double **areal, double *work, double *fwhm)
Work out the median seeing.