31#include "imcore_radii.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_HALLFLUX 53
88#define COL_HALLFLUXERR 54
90#define COL_SKYLEVEL 56
91#define COL_SKYSIGMA 57
92#define COL_CHLDPARENT 58
102static const char *ttype[NCOLS]={
"Sequence_number",
"Isophotal_flux",
103 "X_coordinate",
"X_coordinate_err",
104 "Y_coordinate",
"Y_coordinate_err",
105 "Gaussian_sigma",
"Ellipticity",
"Position_angle",
106 "Areal_1_profile",
"Areal_2_profile",
"Areal_3_profile",
107 "Areal_4_profile",
"Areal_5_profile",
"Areal_6_profile",
108 "Areal_7_profile",
"Areal_8_profile",
109 "Peak_height",
"Peak_height_err",
110 "Aper_flux_1",
"Aper_flux_1_err",
111 "Aper_flux_2",
"Aper_flux_2_err",
112 "Aper_flux_3",
"Aper_flux_3_err",
113 "Aper_flux_4",
"Aper_flux_4_err",
114 "Aper_flux_5",
"Aper_flux_5_err",
115 "Aper_flux_6",
"Aper_flux_6_err",
116 "Aper_flux_7",
"Aper_flux_7_err",
117 "Aper_flux_8",
"Aper_flux_8_err",
118 "Aper_flux_9",
"Aper_flux_9_err",
119 "Aper_flux_10",
"Aper_flux_10_err",
120 "Aper_flux_11",
"Aper_flux_11_err",
121 "Aper_flux_12",
"Aper_flux_12_err",
122 "Aper_flux_13",
"Aper_flux_13_err",
123 "Petr_radius",
"Kron_radius",
"Hall_radius",
124 "Petr_flux",
"Petr_flux_err",
125 "Kron_flux",
"Kron_flux_err",
"Hall_flux",
"Hall_flux_err",
126 "Error_bit_flag",
"Sky_level",
"Sky_rms",
128 "RA",
"DEC",
"Classification",
"Statistic",
129 "Blank63",
"Blank64",
"Blank65",
"Blank66",
"Blank67",
130 "Blank68",
"Blank69",
"Blank70",
"Blank71",
"Blank72",
131 "Blank73",
"Blank74",
"Blank75",
"Blank76",
"Blank77",
132 "Blank78",
"Blank79",
"Blank80"};
134static const char *tunit[NCOLS]={
"Number",
"ADU",
137 "Pixels",
"Number",
"Degrees",
138 "Pixels",
"Pixels",
"Pixels",
139 "Pixels",
"Pixels",
"Pixels",
155 "Pixels",
"Pixels",
"Pixels",
157 "ADU",
"ADU",
"ADU",
"ADU",
158 "Number",
"ADU",
"ADU",
"Number",
159 "Degrees",
"Degrees",
"Flag",
"N-sigma",
160 "Blank63",
"Blank64",
"Blank65",
"Blank66",
"Blank67",
161 "Blank68",
"Blank69",
"Blank70",
"Blank71",
"Blank72",
162 "Blank73",
"Blank74",
"Blank75",
"Blank76",
"Blank77",
163 "Blank78",
"Blank79",
"Blank80"};
165static cpl_type tform[NCOLS]={CPL_TYPE_INT,CPL_TYPE_FLOAT,
166 CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
167 CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
168 CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
169 CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
170 CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
171 CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
172 CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
173 CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
174 CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
175 CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
176 CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
177 CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
178 CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
179 CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
180 CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
181 CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
182 CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
183 CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
184 CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
185 CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
186 CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
187 CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
188 CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
190 CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
192 CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
193 CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
194 CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
195 CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
196 CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
197 CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
198 CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
202static float rmults[] = {0.5,1.0/CPL_MATH_SQRT2,1.0,CPL_MATH_SQRT2,2.0,
203 2.0*CPL_MATH_SQRT2,4.0,5.0,6.0,7.0,8.0,10,12.0};
204static int nrcore = 2;
205static float apertures[NRADS];
207static int areal_cols[NAREAL] = {COL_AREAL1,COL_AREAL2,COL_AREAL3,COL_AREAL4,
208 COL_AREAL5,COL_AREAL6,COL_AREAL7,COL_AREAL8};
244 *imcore_xcol = COL_X;
245 *imcore_ycol = COL_Y;
278 char *areal_colnames[NAREAL];
282 for (i = 0; i < NAREAL; i++)
283 areal_colnames[i] = (
char *)ttype[areal_cols[i]-1];
288 areal_colnames,nobjects,tab);
326 float momresults[8],ttotal,parmall[IMNUM][NPAR],cflux[NRADS*IMNUM];
327 float sxx,syy,srr,sxy,ecc,temp,xx,theta,radeg,ell,iso_flux;
328 float apflux1,apflux2,apflux3,apflux4,apflux5,yy,sigma,peak,areal1,apflux6;
329 float apflux7,apflux8,apflux9,apflux10,apflux11,apflux12,apflux13,zero;
330 float areal2,areal3,areal4,areal5,areal6,areal7,areal8;
331 float skylev,skyrms,exp_rad[IMNUM],exp_flux[IMNUM],kron_flux[IMNUM];
332 float petr_flux[IMNUM],kron_rad[IMNUM],petr_rad[IMNUM],badpix[IMNUM];
333 float theta_ra,skyvar[IMNUM],cc,dd,sigsq,xxe,yye,peake,kron_fluxe;
334 float apflux1e,apflux2e,apflux3e,apflux4e,apflux5e,apflux6e,apflux7e;
335 float apflux8e,apflux9e,apflux10e,apflux11e,apflux12e,apflux13e,exp_fluxe;
336 float petr_fluxe,avconf[IMNUM];
337 int iareal[NAREAL],nbit,i,k,nr,mbit,j;
343 if (momresults[0] < 0)
350 if (iareal[0] < ap->ipnop || momresults[3] < ap->xintmin)
356 momresults[4],momresults[5],momresults[6],
357 (
float)iareal[0],momresults[7],&ttotal);
361 if (iareal[0] >= ap->mulpix && ap->icrowd)
363 momresults[3],iareal[0],momresults[7]);
367 parmall[0][0] = momresults[3];
368 parmall[0][1] = momresults[1];
369 parmall[0][2] = momresults[2];
370 parmall[0][3] = ap->thresh;
371 for (i = 4; i < 8; i++)
372 parmall[0][i] = momresults[i];
373 for (i = 0; i < NAREAL; i++)
374 parmall[0][i+8] = (
float)iareal[i];
377 for (i = 0; i < nbit; i++) {
378 if (parmall[i][1] > 1.0 && parmall[i][1] < ap->lsiz &&
379 parmall[i][2] > 1.0 && parmall[i][2] < ap->csiz) {
380 for (j = 0; j < NPAR; j++)
381 parmall[mbit][j] = parmall[i][j];
392 for (i = 0; i < NRADS; i++) {
393 apertures[i] = rmults[i]*(ap->rcore);
394 skyvar[i] = CPL_MATH_PI*apertures[i]*apertures[i];
399 for (i = 0; i < nbit; i++) {
406 imcore_phopt(ap,parmall,nbit,NRADS,apertures,cflux,badpix,nrcore,avconf);
410 for (k = 0; k < nbit; k++) {
411 peak = parmall[k][7];
412 areal1 = parmall[k][8];
413 exp_rad[k] =
imcore_exprad(parmall[k][3],peak,areal1,apertures,NRADS);
415 imcore_flux(ap,parmall,nbit,exp_rad,exp_flux,NRADS,apertures,cflux);
419 for (k = 0; k < nbit; k++) {
420 areal1 = parmall[k][8];
421 kron_rad[k] =
imcore_kronrad(areal1,apertures,cflux+k*NRADS,NRADS);
423 imcore_flux(ap,parmall,nbit,kron_rad,kron_flux,NRADS,apertures,cflux);
427 for (k = 0; k < nbit; k++) {
428 areal1 = parmall[k][8];
429 petr_rad[k] =
imcore_petrad(areal1,apertures,cflux+k*NRADS,NRADS);
431 imcore_flux(ap,parmall,nbit,petr_rad,petr_flux,NRADS,apertures,cflux);
435 sigsq = powf(ap->sigma,2.0);
436 radeg = 180.0/CPL_MATH_PI;
437 for (k = 0; k < nbit; k++) {
442 sxy = MAX(1.0e-4,MIN(sxy,sqrtf(sxx*syy)));
444 sxy = MIN(-1.0e-4,MAX(sxy,-sqrtf(sxx*syy)));
445 srr = MAX(0.5,sxx+syy);
446 ecc = sqrtf((syy-sxx)*(syy-sxx)+4.0*sxy*sxy)/srr;
447 temp = MAX((1.0-ecc)/(1.0+ecc),0.0);
448 ell = 1.0 - sqrtf(temp);
449 ell = MIN(0.99,MAX(0.0,ell));
450 xx = 0.5*(1.0+ecc)*srr-sxx;
454 theta = 90.0 - radeg*atanf(sxy/xx);
455 theta_ra = theta/radeg;
456 cc = (1.0 + ecc)*pow(cos(theta_ra),2.0) + (1.0 - ecc)*pow(sin(theta_ra),2.0);
457 dd = (1.0 + ecc)*pow(sin(theta_ra),2.0) + (1.0 - ecc)*pow(cos(theta_ra),2.0);
461 nrows = cpl_table_get_nrow(tab);
463 if (*nobjects > nrows)
464 (void)cpl_table_set_size(tab,nrows+INITROWS);
466 iso_flux = parmall[k][0];
467 apflux1 = cflux[k*NRADS + 0];
468 apflux2 = cflux[k*NRADS + 1];
469 apflux3 = cflux[k*NRADS + 2];
470 apflux4 = cflux[k*NRADS + 3];
471 apflux5 = cflux[k*NRADS + 4];
472 apflux6 = cflux[k*NRADS + 5];
473 apflux7 = cflux[k*NRADS + 6];
474 apflux8 = cflux[k*NRADS + 7];
475 apflux9 = cflux[k*NRADS + 8];
476 apflux10 = cflux[k*NRADS + 9];
477 apflux11 = cflux[k*NRADS + 10];
478 apflux12 = cflux[k*NRADS + 11];
479 apflux13 = cflux[k*NRADS + 12];
480 peak = parmall[k][7];
482 xxe = sqrtf((2.0*sigsq/(CPL_MATH_PI*peak*peak)) + cc/(2.0*CPL_MATH_PI*gain*peak) +
485 yye = sqrtf((2.0*sigsq/(CPL_MATH_PI*peak*peak)) + dd/(2.0*CPL_MATH_PI*gain*peak) +
488 areal1 = parmall[k][8];
489 areal2 = parmall[k][9];
490 areal3 = parmall[k][10];
491 areal4 = parmall[k][11];
492 areal5 = parmall[k][12];
493 areal6 = parmall[k][13];
494 areal7 = parmall[k][14];
495 if (nbit > 1 && k == 0)
498 areal8 = parmall[k][15];
500 peake = sqrtf(peak/gain + sigsq + skyrms*skyrms);
501 kron_fluxe = sqrt(kron_flux[k]/gain +
502 (sigsq + skyrms*skyrms)*CPL_MATH_PI*powf(kron_rad[k],2.0));
503 exp_fluxe = sqrt(exp_flux[k]/gain +
504 (sigsq + skyrms*skyrms)*CPL_MATH_PI*powf(exp_rad[k],2.0));
505 petr_fluxe = sqrt(petr_flux[k]/gain +
506 (sigsq + skyrms*skyrms)*CPL_MATH_PI*powf(petr_rad[k],2.0));
507 apflux1e = sqrt(MAX(0.0,apflux1/gain) + skyvar[0]*(sigsq + skyrms*skyrms));
508 apflux2e = sqrt(MAX(0.0,apflux2/gain) + skyvar[1]*(sigsq + skyrms*skyrms));
509 apflux3e = sqrt(MAX(0.0,apflux3/gain) + skyvar[2]*(sigsq + skyrms*skyrms));
510 apflux4e = sqrt(MAX(0.0,apflux4/gain) + skyvar[3]*(sigsq + skyrms*skyrms));
511 apflux5e = sqrt(MAX(0.0,apflux5/gain) + skyvar[4]*(sigsq + skyrms*skyrms));
512 apflux6e = sqrt(MAX(0.0,apflux6/gain) + skyvar[5]*(sigsq + skyrms*skyrms));
513 apflux7e = sqrt(MAX(0.0,apflux7/gain) + skyvar[6]*(sigsq + skyrms*skyrms));
514 apflux8e = sqrt(MAX(0.0,apflux8/gain) + skyvar[7]*(sigsq + skyrms*skyrms));
515 apflux9e = sqrt(MAX(0.0,apflux9/gain) + skyvar[8]*(sigsq + skyrms*skyrms));
516 apflux10e = sqrt(MAX(0.0,apflux10/gain) + skyvar[9]*(sigsq + skyrms*skyrms));
517 apflux11e = sqrt(MAX(0.0,apflux11/gain) + skyvar[10]*(sigsq + skyrms*skyrms));
518 apflux12e = sqrt(MAX(0.0,apflux12/gain) + skyvar[11]*(sigsq + skyrms*skyrms));
519 apflux13e = sqrt(MAX(0.0,apflux13/gain) + skyvar[12]*(sigsq + skyrms*skyrms));
524 cpl_table_set_int(tab,ttype[COL_NUMBER-1],nr,*nobjects);
525 cpl_table_set_float(tab,ttype[COL_FLUXISO-1],nr,iso_flux);
526 cpl_table_set_float(tab,ttype[COL_X-1],nr,xx);
527 cpl_table_set_float(tab,ttype[COL_XERR-1],nr,xxe);
528 cpl_table_set_float(tab,ttype[COL_Y-1],nr,yy);
529 cpl_table_set_float(tab,ttype[COL_YERR-1],nr,yye);
530 cpl_table_set_float(tab,ttype[COL_SIGMA-1],nr,sigma);
531 cpl_table_set_float(tab,ttype[COL_ELLIPT-1],nr,ell);
532 cpl_table_set_float(tab,ttype[COL_PA-1],nr,theta);
533 cpl_table_set_float(tab,ttype[COL_AREAL1-1],nr,areal1);
534 cpl_table_set_float(tab,ttype[COL_AREAL2-1],nr,areal2);
535 cpl_table_set_float(tab,ttype[COL_AREAL3-1],nr,areal3);
536 cpl_table_set_float(tab,ttype[COL_AREAL4-1],nr,areal4);
537 cpl_table_set_float(tab,ttype[COL_AREAL5-1],nr,areal5);
538 cpl_table_set_float(tab,ttype[COL_AREAL6-1],nr,areal6);
539 cpl_table_set_float(tab,ttype[COL_AREAL7-1],nr,areal7);
540 cpl_table_set_float(tab,ttype[COL_AREAL8-1],nr,areal8);
541 cpl_table_set_float(tab,ttype[COL_PEAKHEIGHT-1],nr,peak);
542 cpl_table_set_float(tab,ttype[COL_PKHTERR-1],nr,peake);
543 cpl_table_set_float(tab,ttype[COL_APFLUX1-1],nr,apflux1);
544 cpl_table_set_float(tab,ttype[COL_APFLUX1ERR-1],nr,apflux1e);
545 cpl_table_set_float(tab,ttype[COL_APFLUX2-1],nr,apflux2);
546 cpl_table_set_float(tab,ttype[COL_APFLUX2ERR-1],nr,apflux2e);
547 cpl_table_set_float(tab,ttype[COL_APFLUX3-1],nr,apflux3);
548 cpl_table_set_float(tab,ttype[COL_APFLUX3ERR-1],nr,apflux3e);
549 cpl_table_set_float(tab,ttype[COL_APFLUX4-1],nr,apflux4);
550 cpl_table_set_float(tab,ttype[COL_APFLUX4ERR-1],nr,apflux4e);
551 cpl_table_set_float(tab,ttype[COL_APFLUX5-1],nr,apflux5);
552 cpl_table_set_float(tab,ttype[COL_APFLUX5ERR-1],nr,apflux5e);
553 cpl_table_set_float(tab,ttype[COL_APFLUX6-1],nr,apflux6);
554 cpl_table_set_float(tab,ttype[COL_APFLUX6ERR-1],nr,apflux6e);
555 cpl_table_set_float(tab,ttype[COL_APFLUX7-1],nr,apflux7);
556 cpl_table_set_float(tab,ttype[COL_APFLUX7ERR-1],nr,apflux7e);
557 cpl_table_set_float(tab,ttype[COL_APFLUX8-1],nr,apflux8);
558 cpl_table_set_float(tab,ttype[COL_APFLUX8ERR-1],nr,apflux8e);
559 cpl_table_set_float(tab,ttype[COL_APFLUX9-1],nr,apflux9);
560 cpl_table_set_float(tab,ttype[COL_APFLUX9ERR-1],nr,apflux9e);
561 cpl_table_set_float(tab,ttype[COL_APFLUX10-1],nr,apflux10);
562 cpl_table_set_float(tab,ttype[COL_APFLUX10ERR-1],nr,apflux10e);
563 cpl_table_set_float(tab,ttype[COL_APFLUX11-1],nr,apflux11);
564 cpl_table_set_float(tab,ttype[COL_APFLUX11ERR-1],nr,apflux11e);
565 cpl_table_set_float(tab,ttype[COL_APFLUX12-1],nr,apflux12);
566 cpl_table_set_float(tab,ttype[COL_APFLUX12ERR-1],nr,apflux12e);
567 cpl_table_set_float(tab,ttype[COL_APFLUX13-1],nr,apflux13);
568 cpl_table_set_float(tab,ttype[COL_APFLUX13ERR-1],nr,apflux13e);
569 cpl_table_set_float(tab,ttype[COL_PETRAD-1],nr,0.5*petr_rad[k]);
570 cpl_table_set_float(tab,ttype[COL_KRONRAD-1],nr,0.5*kron_rad[k]);
571 cpl_table_set_float(tab,ttype[COL_HALLRAD-1],nr,exp_rad[k]);
572 cpl_table_set_float(tab,ttype[COL_PETFLUX-1],nr,petr_flux[k]);
573 cpl_table_set_float(tab,ttype[COL_PETFLUXERR-1],nr,petr_fluxe);
574 cpl_table_set_float(tab,ttype[COL_KRONFLUX-1],nr,kron_flux[k]);
575 cpl_table_set_float(tab,ttype[COL_KRONFLUXERR-1],nr,kron_fluxe);
576 cpl_table_set_float(tab,ttype[COL_HALLFLUX-1],nr,exp_flux[k]);
577 cpl_table_set_float(tab,ttype[COL_HALLFLUXERR-1],nr,exp_fluxe);
578 cpl_table_set_float(tab,ttype[COL_ERRFLAG-1],nr,badpix[k]);
579 cpl_table_set_float(tab,ttype[COL_SKYLEVEL-1],nr,skylev);
580 cpl_table_set_float(tab,ttype[COL_SKYSIGMA-1],nr,skyrms);
581 cpl_table_set_float(tab,ttype[COL_CHLDPARENT-1],nr,zero);
585 cpl_table_set_float(tab,ttype[COL_RA-1],nr,zero);
586 cpl_table_set_float(tab,ttype[COL_DEC-1],nr,zero);
587 cpl_table_set_float(tab,ttype[COL_CLASS-1],nr,100.0);
588 cpl_table_set_float(tab,ttype[COL_STAT-1],nr,zero);
void imcore_areals(ap_t *ap, int iareal[NAREAL])
Work out the areal profiles for an object.
float imcore_exprad(float thresh, float peak, float areal0, float rcores[], int naper)
Work out the exponential radius for an object.
void imcore_flux(ap_t *ap, float parm[IMNUM][NPAR], int nbit, float apers[], float fluxes[], int nr, float rcores[], float rfluxes[])
Work out the fluxes for special radii.
void imcore_backest(ap_t *ap, float x, float y, float *skylev, float *skyrms)
Work out estimated sky for a pixel position.
void imcore_moments(ap_t *ap, float results[])
Do moments analysis on an object.
int imcore_do_seeing_2(ap_t *ap, int nobjects, cpl_table *tab)
Do seeing estimate for type 2 catalogue.
int imcore_do_seeing_gen(ap_t *ap, const char *col_ellipt, const char *col_pkht, char *col_areals[NAREAL], int nobjects, cpl_table *tab)
Do seeing estimate (generic)
int imcore_process_results_2(ap_t *ap, float gain, int *nobjects, cpl_table *tab)
Process results for type 2 catalogue.
void imcore_tabinit_gen(int ncols, const char *ttype[], const char *tunit[], cpl_type tform[], cpl_table **tab)
Initialise tables (generic)
float imcore_kronrad(float areal0, float rcores[], float cflux[], int naper)
Work out the Kron radius for an object.
float imcore_petrad(float areal0, float rcores[], float cflux[], int naper)
Work out the Petrosian.
void imcore_phopt(ap_t *ap, float parm[IMNUM][NPAR], int nbit, int naper, float apertures[], float cflux[], float badpix[], int nrcore, float avconf[])
Do multiple profile fitting.
void imcore_overlp(ap_t *ap, float parm[IMNUM][NPAR], int *nbit, float xbar, float ybar, float total, int npix, float tmax)
Deblend overlapping images.
int imcore_extend(ap_t *ap, float xniso, float xbar, float ybar, float sxx, float sxy, float syy, float areal0, float tmax, float *ttotal)
Do aperture integration.
void imcore_tabinit_2(int *imcore_xcol, int *imcore_ycol, cpl_table **tab)
Initialise type 2 catalogue.