34#include <casu_utils.h>
46#define PI 3.14159265358979323846
47#define DEGRAD 57.2957795130823229
49#define COREMAG(A,B,C) 2.5*log10((double)(max(C,A-B)))
50#define MAX(A,B) (A > B ? A : B)
55static float thresh,skylevel,skynoise,rcore;
60static float sigell,fitell,elllim,sigellf,fitellf,sigpa,fitpa;
61static float blim,flim,cmin,cmax;
62static float fit1,fit2,fit3,fit4,fit5,fit6,fit7;
63static float fit_final,sigma_final;
64static float *lower1,*lower2,*lower3,*upper1,*upper2,*upper3,*uppere;
65static float avsig1,avsig2,avsig3,wt1,wt2,wt3;
69static int nstar,ngal,njunk,ncmp;
73static float avsat,corlim,cormin,apcpkht,apcor,apcor1,apcor2,apcor3,apcor4;
74static float apcor5,apcor6,apcor7;
78static float *workspace = NULL;
79static cpl_table *catcopy = NULL;
80static float *areal[NAREAL];
81static float *core_flux,*core1_flux,*core2_flux,*core3_flux,*core4_flux;
82static float *core5_flux,*peak_height,*peak_mag,*ellipticity,*iso_flux;
83static float *total_flux,*cls,*sig,*xpos,*ypos,*pa,*core6_flux,*skylev;
91static const char *cols32[NCOL32] = {
"Core_flux",
"Core1_flux",
"Core2_flux",
92 "Core3_flux",
"Core4_flux",
"Peak_height",
93 "Ellipticity",
"Isophotal_flux",
94 "Total_flux",
"Core5_flux",
"X_coordinate",
95 "Y_coordinate",
"Position_angle",
98static const char *cols80[NCOL80] = {
"Aper_flux_3",
"Aper_flux_1",
"Aper_flux_4",
99 "Aper_flux_5",
"Aper_flux_6",
"Peak_height",
100 "Ellipticity",
"Isophotal_flux",
101 "Isophotal_flux",
"Aper_flux_7",
102 "X_coordinate",
"Y_coordinate",
103 "Position_angle",
"Sky_level",
117static void anhist(
float *,
int,
float *,
float *);
118static void boundaries(
float *,
float *,
float *,
float,
float,
float,
float,
119 int,
float,
float,
float *,
float *,
float *,
float *);
120static void boundpk(
float *,
float *,
float,
float,
float *,
float *,
122static void classify_run(
void);
123static void classstats(
float *,
float *,
int,
float,
float *,
float *);
124static void classstats_ap0(
float *,
float *);
125static void classstats_ap67(
float *,
float *,
float *,
float *);
126static void classstats_el(
void);
127static void classstats_pa(
void);
128static void classstats_ellf(
float);
129static void classstats_final(
void);
130static void medstat(
float *,
int,
float *,
float *);
131static void sort1(
float *,
int);
132static void sort2(
float *,
float *,
int);
204 float fwhm,*work,moff;
205 float pkht,ell,core,ap,delap,area,junk,arg;
206 char *cols[MAX(NCOL32,NCOL80)],colname[32];
207 cpl_propertylist *extra;
209 const char *fctid =
"casu_classify";
210 int i,n,iap,nxout,nyout;
215 thresh = cpl_propertylist_get_float(extra,
"ESO DRS THRESHOL");
216 skylevel = cpl_propertylist_get_float(extra,
"ESO QC MEAN_SKY");
217 skynoise = cpl_propertylist_get_float(extra,
"ESO QC SKY_NOISE");
218 rcore = cpl_propertylist_get_float(extra,
"ESO DRS RCORE");
219 fwhm = cpl_propertylist_get_float(extra,
"ESO DRS SEEING");
220 nxout = cpl_propertylist_get_int(extra,
"ESO DRS NXOUT");
221 nyout = cpl_propertylist_get_int(extra,
"ESO DRS NYOUT");
222 xmin = FRAMECUT*(float)nxout;
223 xmax = (1.0 - FRAMECUT)*(
float)nxout;
224 ymin = FRAMECUT*(float)nyout;
225 ymax = (1.0 - FRAMECUT)*(
float)nyout;
231 ncols = cpl_table_get_ncol(cat);
234 for (i = 0; i < NCOL32; i++)
235 cols[i] = (
char *)cols32[i];
238 for (i = 0; i < NCOL80; i++)
239 cols[i] = (
char *)cols80[i];
242 for (i = 0; i < NCOL80; i++)
243 cols[i] = (
char *)cols80[i];
246 cpl_msg_error(fctid,
"Don't recognise catalogues with %" CPL_SIZE_FORMAT
" columns: cattype == %" CPL_SIZE_FORMAT,(cpl_size)ncols,(cpl_size)cattype);
253 catcopy = cpl_table_duplicate(cat);
254 nrows = cpl_table_get_nrow(cat);
255 core_flux = cpl_table_get_data_float(catcopy,cols[0]);
256 core1_flux = cpl_table_get_data_float(catcopy,cols[1]);
257 core2_flux = cpl_table_get_data_float(catcopy,cols[2]);
258 core3_flux = cpl_table_get_data_float(catcopy,cols[3]);
259 core4_flux = cpl_table_get_data_float(catcopy,cols[4]);
260 peak_height = cpl_table_get_data_float(catcopy,cols[5]);
261 ellipticity = cpl_table_get_data_float(catcopy,cols[6]);
262 iso_flux = cpl_table_get_data_float(catcopy,cols[7]);
263 total_flux = cpl_table_get_data_float(catcopy,cols[8]);
264 core5_flux = cpl_table_get_data_float(catcopy,cols[9]);
265 xpos = cpl_table_get_data_float(catcopy,cols[10]);
266 ypos = cpl_table_get_data_float(catcopy,cols[11]);
267 pa = cpl_table_get_data_float(catcopy,cols[12]);
268 skylev = cpl_table_get_data_float(catcopy,cols[13]);
269 if (cattype == 2 || cattype == 6)
270 core6_flux = cpl_table_get_data_float(catcopy,cols[14]);
273 cls = cpl_table_get_data_float(cat,
"Classification");
274 sig = cpl_table_get_data_float(cat,
"Statistic");
278 workspace = cpl_malloc(2*nrows*
sizeof(
float));
279 peak_mag = workspace;
280 work = workspace + nrows;
284 for (i = 0; i < nrows; i++) {
285 core_flux[i] = COREMAG(core_flux[i],0.0,1.0);
286 core1_flux[i] = COREMAG(core1_flux[i],0.0,1.0);
287 core2_flux[i] = COREMAG(core2_flux[i],0.0,1.0);
288 core3_flux[i] = COREMAG(core3_flux[i],0.0,1.0);
289 core4_flux[i] = COREMAG(core4_flux[i],0.0,1.0);
290 core5_flux[i] = COREMAG(core5_flux[i],0.0,1.0);
291 moff = 1.0/(1.0 - pow((thresh/MAX(peak_height[i],thresh)),0.6));
292 iso_flux[i] = COREMAG(moff*iso_flux[i],0.0,1.0);
293 peak_mag[i] = COREMAG(peak_height[i],skynoise,0.1);
295 if (core6_flux != NULL)
296 for (i = 0; i < nrows; i++)
297 core6_flux[i] = COREMAG(core6_flux[i],0.0,1.0);
299 for (i = 0; i < nrows; i++)
300 total_flux[i] = COREMAG(total_flux[i],0.0,1.0);
304 for (i = 0; i < NAREAL; i++) {
305 sprintf(colname,
"Areal_%d_profile",i+1);
306 areal[i] = cpl_table_get_data_float(catcopy,colname);
312 if (fwhm > max(5.0,rcore*sqrt(2.0)))
322 for (i = 0; i < nrows; i++) {
323 pkht = peak_height[i];
324 ell = ellipticity[i];
326 if (cls[i] == -1.0 && ell < elllim && core < corlim &&
327 pkht > 10.0*thresh) {
328 ap = log(0.5*pkht/thresh)/log(2.0) + 1.0;
330 delap = ap - (float)iap;
331 if (iap > 0 && iap < NAREAL && areal[1][i] > 0.0) {
332 area = areal[iap-1][i]*(1.0 - delap) + areal[iap][i]*delap;
333 work[n++] = 2.0*sqrt(area/PI);
338 medstat(work,n,&fwhm,&junk);
342 arg = 0.25*PI*fwhm*fwhm - 1;
343 fwhm = 2.0*sqrt(max(0.0,arg/PI));
350 freespace(workspace);
355 cpl_propertylist_update_float(extra,
"ESO QC IMAGE_SIZE",fwhm);
356 cpl_propertylist_set_comment(extra,
"ESO QC IMAGE_SIZE",
357 "[pixels] Average FWHM of stellar objects");
358 cpl_propertylist_update_float(extra,
"ESO QC ELLIPTICITY",fitell);
359 cpl_propertylist_set_comment(extra,
"ESO QC ELLIPTICITY",
360 "Average stellar ellipticity (1-b/a)");
361 cpl_propertylist_update_float(extra,
"ESO QC POSANG",fitpa);
362 cpl_propertylist_set_comment(extra,
"ESO QC POSANG",
363 "[degrees] Median position angle");
366 cpl_propertylist_update_float(extra,
"ESO QC APERTURE_CORR",apcor);
367 cpl_propertylist_set_comment(extra,
"ESO QC APERTURE_CORR",
368 "Stellar ap-corr 1x core flux");
371 cpl_propertylist_update_float(extra,
"ESO QC APERTURE_CORR",apcor3);
372 cpl_propertylist_set_comment(extra,
"ESO QC APERTURE_CORR",
373 "Stellar ap-corr 1x core flux");
376 cpl_propertylist_update_float(extra,
"ESO QC APERTURE_CORR",apcor3);
377 cpl_propertylist_set_comment(extra,
"ESO QC APERTURE_CORR",
378 "Stellar ap-corr 1x core flux");
381 cpl_propertylist_update_int(extra,
"ESO QC NOISE_OBJ",njunk);
382 cpl_propertylist_set_comment(extra,
"ESO QC NOISE_OBJ",
383 "Number of noise objects");
384 cpl_propertylist_update_float(extra,
"ESO QC SATURATION",avsat);
388 cpl_propertylist_update_bool(extra,
"ESO DRS CLASSIFD",1);
389 cpl_propertylist_set_comment(extra,
"ESO DRS CLASSIFD",
390 "Catalogue has been classified");
396 cpl_propertylist_update_float(extra,
"APCORPK",apcpkht);
397 cpl_propertylist_set_comment(extra,
"APCORPK",
"Stellar aperture correction - peak height");
398 cpl_propertylist_update_float(extra,
"APCOR1",apcor1);
399 cpl_propertylist_set_comment(extra,
"APCOR1",
"Stellar aperture correction - 1/2x core flux");
400 cpl_propertylist_update_float(extra,
"APCOR",apcor);
401 cpl_propertylist_set_comment(extra,
"APCOR",
"Stellar aperture correction - 1x core flux");
402 cpl_propertylist_update_float(extra,
"APCOR2",apcor2);
403 cpl_propertylist_set_comment(extra,
"APCOR2",
"Stellar aperture correction - sqrt(2)x core flux");
404 cpl_propertylist_update_float(extra,
"APCOR3",apcor3);
405 cpl_propertylist_set_comment(extra,
"APCOR3",
"Stellar aperture correction - 2x core flux");
406 cpl_propertylist_update_float(extra,
"APCOR4",apcor4);
407 cpl_propertylist_set_comment(extra,
"APCOR4",
"Stellar aperture correction - 2*sqrt(2)x core flux");
408 cpl_propertylist_update_float(extra,
"APCOR5",apcor5);
409 cpl_propertylist_set_comment(extra,
"APCOR5",
"Stellar aperture correction - 4x core flux");
412 cpl_propertylist_update_float(extra,
"APCORPK",apcpkht);
413 cpl_propertylist_set_comment(extra,
"APCORPK",
"Stellar aperture correction - peak height");
414 cpl_propertylist_update_float(extra,
"APCOR1",apcor1);
415 cpl_propertylist_set_comment(extra,
"APCOR1",
"Stellar aperture correction - 1/2x core flux");
416 cpl_propertylist_update_float(extra,
"APCOR2",apcor2);
417 cpl_propertylist_set_comment(extra,
"APCOR2",
"Stellar aperture correction - core/sqrt(2) flux");
418 cpl_propertylist_update_float(extra,
"APCOR3",apcor3);
419 cpl_propertylist_set_comment(extra,
"APCOR3",
"Stellar aperture correction - 1x core flux");
420 cpl_propertylist_update_float(extra,
"APCOR4",apcor4);
421 cpl_propertylist_set_comment(extra,
"APCOR4",
"Stellar aperture correction - sqrt(2)x core flux");
422 cpl_propertylist_update_float(extra,
"APCOR5",apcor5);
423 cpl_propertylist_set_comment(extra,
"APCOR5",
"Stellar aperture correction - 2x core flux");
424 cpl_propertylist_update_float(extra,
"APCOR6",apcor6);
425 cpl_propertylist_set_comment(extra,
"APCOR6",
"Stellar aperture correction - 2*sqrt(2)x core flux");
426 cpl_propertylist_update_float(extra,
"APCOR7",apcor7);
427 cpl_propertylist_set_comment(extra,
"APCOR7",
"Stellar aperture correction - 4x core flux");
430 cpl_propertylist_update_float(extra,
"APCORPK",apcpkht);
431 cpl_propertylist_set_comment(extra,
"APCORPK",
"Stellar aperture correction - peak height");
432 cpl_propertylist_update_float(extra,
"APCOR1",apcor1);
433 cpl_propertylist_set_comment(extra,
"APCOR1",
"Stellar aperture correction - 1/2x core flux");
434 cpl_propertylist_update_float(extra,
"APCOR2",apcor2);
435 cpl_propertylist_set_comment(extra,
"APCOR2",
"Stellar aperture correction - core/sqrt(2) flux");
436 cpl_propertylist_update_float(extra,
"APCOR3",apcor3);
437 cpl_propertylist_set_comment(extra,
"APCOR3",
"Stellar aperture correction - 1x core flux");
438 cpl_propertylist_update_float(extra,
"APCOR4",apcor4);
439 cpl_propertylist_set_comment(extra,
"APCOR4",
"Stellar aperture correction - sqrt(2)x core flux");
440 cpl_propertylist_update_float(extra,
"APCOR5",apcor5);
441 cpl_propertylist_set_comment(extra,
"APCOR5",
"Stellar aperture correction - 2x core flux");
442 cpl_propertylist_update_float(extra,
"APCOR6",apcor6);
443 cpl_propertylist_set_comment(extra,
"APCOR6",
"Stellar aperture correction - 2*sqrt(2)x core flux");
444 cpl_propertylist_update_float(extra,
"APCOR7",apcor7);
445 cpl_propertylist_set_comment(extra,
"APCOR7",
"Stellar aperture correction - 4x core flux");
451 cpl_propertylist_update_string(extra,
"SYMBOL1",
"{Ellipticity Position_angle Areal_1_profile Classification} {el");
452 cpl_propertylist_update_string(extra,
"SYMBOL2",
"lipse blue (1.0-$Ellipticity) $Position_angle+90 {} $Classific");
453 cpl_propertylist_update_string(extra,
"SYMBOL3",
"ation==1} {sqrt($Areal_1_profile*(1.0-$Ellipticity)/3.142)} : {");
454 cpl_propertylist_update_string(extra,
"SYMBOL4",
"Ellipticity Position_angle Areal_1_profile Classification} {el");
455 cpl_propertylist_update_string(extra,
"SYMBOL5",
"lipse red (1.0-$Ellipticity) $Position_angle+90 {} $Classific");
456 cpl_propertylist_update_string(extra,
"SYMBOL6",
"ation==-1} {sqrt($Areal_1_profile*(1.0-$Ellipticity)/3.142)} :");
457 cpl_propertylist_update_string(extra,
"SYMBOL7",
"{Ellipticity Position_angle Areal_1_profile Classification} {el");
458 cpl_propertylist_update_string(extra,
"SYMBOL8",
"lipse green (1.0-$Ellipticity) $Position_angle+90 {} $Classifi");
459 cpl_propertylist_update_string(extra,
"SYMBOL9",
"cation==0} {sqrt($Areal_1_profile*(1.0-$Ellipticity)/3.142)}");
494static void anhist(
float *data,
int n,
float *medval,
float *sigma) {
495 int i,*histo,ilev,imax,ismax;
496 float *sval,hmax,smax,hlim,ratio;
500 histo = cpl_calloc(MAXHIST,
sizeof(
int));
501 sval = cpl_calloc(MAXHIST,
sizeof(
float));
505 for (i = 0; i < n; i++) {
506 ilev = casu_nint(data[i]/STEP);
507 if (ilev >= -10 && ilev <= 100) {
517 for (i = 0; i < MAXHIST; i++) {
518 if (histo[i] > hmax) {
519 hmax = (float)histo[i];
528 *medval = data[(n+1)/2-1];
529 *sigma = 1.48*0.5*(data[(3*n+3)/4-1] - data[(n+3)/4-1]);
544 for (i = 1; i < MAXHIST-1; i++) {
545 sval[i] = (histo[i-1] + histo[i] + histo[i+1])/3.0;
546 if (sval[i] > smax) {
553 hmax = (float)histo[imax];
558 for (i = imax-1; i > 0; i--) {
559 if (sval[i] >= sval[i+1] && sval[i] >= sval[i-1]) {
560 if (sval[i] > 0.5*smax)
566 hmax = (float)histo[imax];
571 *medval = min((
float)(imax-10)*STEP,data[(n+1)/2-1]);
572 hlim = casu_nint(0.5*hmax);
574 while (imax-i > 1 && histo[imax-i] > hlim)
578 ratio = hmax/max(1.0,(
float)histo[imax-i]);
579 *sigma = (float)i*STEP/(sqrt(2.0)*max(1.0,log(ratio)));
580 *sigma = max(*sigma,0.5*STEP);
631static void boundaries(
float *core1,
float *core2,
float *core3,
float medval1,
632 float sigma1,
float medval2,
float sigma2,
int small,
633 float area1,
float area2,
float *wt,
float *avsig,
634 float *lower,
float *upper) {
636 float c1,c2,dc,*work,xnoise,xmag,xflux,ratio,asign,junk;
640 work = cpl_malloc(nrows*
sizeof(
float));
646 asign = ((small == 1) ? -1.0 : 1.0);
651 for (i = 0; i < nrows; i++) {
655 dc = asign*(c2 - c1);
656 if (dc > medval1 - 3.0*sigma1 && c1 < blim - 3.0)
657 work[n++] = dc - medval1;
661 if (dc > medval2 - 3.0*sigma2 && c1 < blim - 3.0)
662 work[n++] = dc - medval2;
668 medstat(work,n,avsig,&junk);
674 *wt = min(5.0,max(1.0,*avsig/sigma1));
675 xnoise = sqrt(area1)*skynoise;
677 *wt = min(2.5,max(1.0,*avsig/sigma2));
678 xnoise = sqrt(area2)*skynoise;
683 for (i = 0; i < NSAMPLE; i++) {
684 xmag = 5.0 + (float)(i+1)*0.1;
685 xflux = pow(10.0,(
double)(0.4*xmag));
686 ratio = COREMAG(1.0+xnoise/xflux,0.0,0.0);
688 lower[i] = medval1 - 3.0*sqrt(sigma1*sigma1 + ratio*ratio);
689 upper[i] = medval1 + 3.0*sqrt(sigma1*sigma1 + 0.5*ratio*ratio);
691 lower[i] = medval2 - 3.0*sqrt(sigma2*sigma2 + ratio*ratio);
692 upper[i] = medval2 + 3.0*sqrt(sigma2*sigma2 + 0.5*ratio*ratio);
695 upper[0] = ((poor == 0) ? medval1 : medval2);
732static void boundpk(
float *core,
float *pkht,
float medval,
float sigma,
733 float *wt,
float *avsig,
float *lower,
float *upper) {
735 float c,p,*work,xnoise,xmag,pmag,xflux,pflux,ratio,junk;
739 work = cpl_malloc(nrows*
sizeof(
float));
744 for (i = 0; i < nrows; i++) {
747 if (c - p > medval - 3.0*sigma && c < blim - 3.0)
748 work[n++] = c - p - medval;
753 medstat(work,n,avsig,&junk);
755 *wt = min(5.0,max(1.0,*avsig/sigma));
759 xnoise = sqrt(PI*rcore*rcore)*skynoise;
760 for (i = 0; i < NSAMPLE; i++) {
761 xmag = 5.0 + (float)(i+1)*0.1;
762 pmag = xmag - medval;
763 xflux = pow(10.0,(
double)(0.4*xmag));
764 pflux = pow(10.0,(
double)(0.4*pmag));
765 ratio = 2.5*log10((
double)(1.0+max(xnoise/xflux,skynoise/pflux)));
766 lower[i] = medval - 3.0*sqrt(sigma*sigma + ratio*ratio);
767 upper[i] = medval + 3.0*sqrt(sigma*sigma + 0.5*ratio*ratio);
793static void classify_run(
void) {
794 float fluxlim,ell,pkht,core,sig1,sig2,sig3,denom,w1,w2,w3;
795 float core_small,core_large,core_midd,statistic,statcut,sigtot;
796 float fit0,sigma0,xnoise,xmag,ratio,xflux,ratell,ratscl,ellbound;
797 float *lower,*upper,sigma1,sigma2,sigma3,sigma4,sigma5,sigma6,sigma7;
798 float *work,avsatnew,junk;
805 fluxlim = 2.5*log10((
double)(5.0*sqrt(PI*rcore*rcore)*skynoise));
806 flim = min(flim,max(6.0,fluxlim+3.0));
807 corlim = min(blim,max(12.5,fluxlim+5.0));
808 cormin = min(blim,max(12.5,fluxlim+5.0));
814 for (i = 0; i < nrows; i++) {
815 xflux = core_flux[i];
816 cmin = min(cmin,xflux);
817 cmax = max(cmax,xflux);
819 cmin = max(fluxlim-0.5,cmin);
821 cmax = min(cmax,20.0);
830 classstats(core_flux,core1_flux,1,0.2,&fit1,&sigma1);
834 classstats(core_flux,core3_flux,0,0.1,&fit2,&sigma2);
838 classstats(core_flux,core2_flux,0,0.0,&fit4,&sigma4);
842 classstats(core_flux,core4_flux,0,0.1,&fit5,&sigma5);
846 classstats(core_flux,peak_mag,1,0.2,&fit3,&sigma3);
850 classstats_ellf(fluxlim);
858 lower1 = cpl_malloc(NSAMPLE*
sizeof(
float));
859 lower2 = cpl_malloc(NSAMPLE*
sizeof(
float));
860 lower3 = cpl_malloc(NSAMPLE*
sizeof(
float));
861 upper1 = cpl_malloc(NSAMPLE*
sizeof(
float));
862 upper2 = cpl_malloc(NSAMPLE*
sizeof(
float));
863 upper3 = cpl_malloc(NSAMPLE*
sizeof(
float));
869 boundaries(core_flux,core1_flux,core2_flux,fit1,sigma1,fit4,sigma4,
870 1,PI*rcore*rcore,2.0*PI*rcore*rcore,&wt1,&avsig1,lower1,
875 boundaries(core_flux,core3_flux,core4_flux,fit2,sigma2,fit5,sigma5,
876 0,4.0*PI*rcore*rcore,8.0*PI*rcore*rcore,&wt2,&avsig2,lower2,
881 boundpk(core_flux,peak_mag,fit3,sigma3,&wt3,&avsig3,lower3,upper3);
890 lower = cpl_malloc(NSAMPLE*
sizeof(
float));
891 upper = cpl_malloc(NSAMPLE*
sizeof(
float));
892 uppere = cpl_malloc(NSAMPLE*
sizeof(
float));
893 xnoise = sqrt(PI*rcore*rcore)*skynoise;
894 ratell = xnoise/pow(10.0,0.4*(fluxlim+1.5));
895 ratell = COREMAG(1.0+ratell,0.0,0.0);
896 ratscl = (pow((fitellf + 2.0*sigellf - fitell),2.0) - 4.0*sigell*sigell)/(4.0*ratell*ratell);
897 ratscl = max(0.25,min(10.0,ratscl));
898 for (i = 0; i < NSAMPLE; i++) {
899 xmag = 5.0 + 0.1*(float)(i+1);
900 xflux = pow(10.0,0.4*xmag);
901 ratio = 2.5*log10(1.0+xnoise/xflux);
902 lower[i] = fit_final - 5.0*sqrt(sigma_final*sigma_final + ratio*ratio);
903 upper[i] = fit_final + sqrt(9.0*sigma_final*sigma_final + 0.0*ratio*ratio);
904 uppere[i] = fitell + 2.0*sqrt(sigell*sigell + ratscl*ratio*ratio);
905 uppere[i] = min(0.5,uppere[i]);
907 elllim = min(0.5,max(0.2,fitell+2.0*sigell));
908 fluxlim = 2.5*log10((
double)(2.5*sqrt(PI*rcore*rcore)*skynoise));
916 for (i = 0; i < nrows; i++) {
917 ell = ellipticity[i];
920 iarg = casu_nint(10.0*(core - 5.0));
921 iarg = max(1,min(NSAMPLE,iarg)) - 1;
923 sig1 = max(0.01,(fit1 - lower1[iarg])/3.0);
924 sig2 = max(0.01,(fit2 - lower2[iarg])/3.0);
926 sig1 = max(0.01,(fit4 - lower1[iarg])/3.0);
927 sig2 = max(0.01,(fit5 - lower2[iarg])/3.0);
929 sig3 = max(0.01,(fit3 - lower3[iarg])/3.0);
930 denom = (wt1/sig1 + wt2/sig2 + wt3/sig3);
931 w1 = (wt1/sig1)/denom;
932 w2 = (wt2/sig2)/denom;
933 w3 = (wt3/sig3)/denom;
935 core_small = core1_flux[i];
936 core_large = core3_flux[i];
937 statistic = (core - core_small - fit1)*w1 +
938 (max(-3.0*sig2,core_large - core - fit2))*w2 +
939 (core - pkht - fit3)*w3;
941 core_midd = core2_flux[i];
942 core_large = core4_flux[i];
943 statistic = (core_midd - core - fit4)*w1 +
944 (max(-3.0*sig2,core_large - core - fit5))*w2 +
945 (core - pkht - fit3)*w3;
948 statcut = upper[iarg] + 3.0*sigma_final*(exp(max(0.0,core-corlim+1.0)) - 1.0);
949 if (statistic >= statcut)
951 else if (statistic <= lower[iarg])
956 sigtot = (fit_final - lower[iarg])/5.0;
957 sig[i] = (statistic - fit_final)/sigtot;
962 if (core - pkht - fit3 < -4.0*sig3)
967 ellbound = max(elllim,uppere[iarg]);
968 if (ell > ellbound && cls[i] == -1.0 && core < flim && sig[i] > -2.0)
973 if (core > corlim && statistic >= lower[iarg])
978 if (ell > 0.9 && core < corlim)
990 else if (cls[i] == 1.0)
992 else if (cls[i] == -2.0)
1001 classstats_ap67(core5_flux,core3_flux,&fit6,&sigma6);
1002 classstats_ap67(core_flux,core6_flux,&fit7,&sigma7);
1005 classstats_ap0(&fit0,&sigma0);
1007 fit0 = max(fit6,fit0);
1009 fit0 = max(fit5,fit0);
1010 apcpkht = fit0 + fit3;
1013 apcor1 = fit0 + fit1;
1015 apcor2 = fit0 - fit4;
1016 apcor3 = fit0 - fit2;
1017 apcor4 = fit0 - fit5;
1021 apcor1 = fit0 + fit1;
1022 apcor2 = fit0 + fit7;
1024 apcor4 = fit0 - fit4;
1025 apcor5 = fit0 - fit2;
1026 apcor6 = fit0 - fit5;
1027 apcor7 = fit0 - fit6;
1034 work = cpl_malloc(nrows*
sizeof(
float));
1035 for (i = 0; i < nrows; i++) {
1036 ell = ellipticity[i];
1037 core = core_flux[i];
1038 pkht = max(thresh,peak_height[i]) + skylev[i];
1039 if (((ell < elllim && core > flim && cls[i] == -1 && sig[i] >= 5.0 &&
1040 areal[0][i] >= pixlim) || pkht >= 0.9*avsat) && xpos[i] >= xmin &&
1041 xpos[i] <= xmax && ypos[i] >= ymin && ypos[i] <= ymax) {
1046 medstat(work,ii,&avsatnew,&junk);
1047 avsatnew = max(10000.0+skylevel,avsatnew);
1049 avsatnew = 10000.0 + skylevel;
1098static void classstats(
float *core1,
float *core2,
int small,
float cutlev,
1099 float *medval,
float *sigma) {
1102 float *work,*dc,sigmaold,amult;
1108 amult = (small == 1 ? -1.0 : 1.0);
1112 work = cpl_malloc(nrows*
sizeof(
float));
1113 dc = cpl_malloc(nrows*
sizeof(
float));
1117 for (i = 0; i < nrows; i++)
1118 dc[i] = amult*(core2[i] - core1[i]);
1122 for (iloop = 0; iloop < MAXLOOP; iloop++) {
1128 for (i = 0; i < nrows; i++) {
1132 if (ellipticity[i] < elllim && core1[i] < blim && core1[i] > flim &&
1133 fabs(dc[i] - *medval) < 3.0*(*sigma) &&
1134 xpos[i] >= xmin && xpos[i] <= xmax && ypos[i] >= ymin &&
1135 ypos[i] <= ymax && areal[0][i] >= pixlim) {
1136 if (iloop > 0 || (iloop == 0 && dc[i] >= cutlev))
1146 anhist(work,n,medval,sigma);
1148 medstat(work,n,medval,sigma);
1149 *sigma = min(sigmaold,*sigma);
1158 *sigma = max(*sigma,0.01);
1184static void classstats_el(
void) {
1195 work = cpl_malloc(nrows*
sizeof(
float));
1199 for (iloop = 0; iloop < MAXLOOP; iloop++) {
1201 for (i = 0; i < nrows; i++) {
1202 if (ellipticity[i] < 0.5 && core_flux[i] < blim &&
1203 core_flux[i] > flim &&
1204 fabs(ellipticity[i] - fitell) < 2.0*sigell &&
1205 xpos[i] >= xmin && xpos[i] <= xmax && ypos[i] >= ymin &&
1206 ypos[i] <= ymax && areal[0][i] >= pixlim)
1207 work[n++] = ellipticity[i];
1210 medstat(work,n,&fitell,&sigell);
1216 elllim = min(0.5,max(0.2,fitell+2.0*sigell));
1240static void classstats_pa(
void) {
1251 work = cpl_malloc(nrows*
sizeof(
float));
1255 for (iloop = 0; iloop < MAXLOOP; iloop++) {
1257 for (i = 0; i < nrows; i++) {
1258 if (core_flux[i] < blim && core_flux[i] > flim &&
1259 fabs(pa[i] - fitpa) < 2.0*sigpa &&
1260 xpos[i] >= xmin && xpos[i] <= xmax && ypos[i] >= ymin &&
1261 ypos[i] <= ymax && areal[0][i] >= pixlim)
1265 medstat(work,n,&fitpa,&sigpa);
1297static void classstats_ellf(
float fluxlim) {
1308 work = cpl_malloc(nrows*
sizeof(
float));
1312 for (iloop = 0; iloop < MAXLOOP; iloop++) {
1314 for (i = 0; i < nrows; i++) {
1315 if (ellipticity[i] < 0.75 && core_flux[i] > fluxlim+1.0 &&
1316 core_flux[i] < fluxlim+2.0 &&
1317 fabs(ellipticity[i] - fitellf) < 2.0*sigellf)
1318 work[n++] = ellipticity[i];
1321 medstat(work,n,&fitellf,&sigellf);
1355static void classstats_ap0(
float *medval,
float *sigma) {
1358 float *work,*dc,c2,sigmanew;
1364 elllim = min(0.5,max(0.2,fitell+2.0*sigell));
1368 work = cpl_malloc(nrows*
sizeof(
float));
1369 dc = cpl_malloc(nrows*
sizeof(
float));
1373 for (i = 0; i < nrows; i++) {
1374 c2 = max(0.0,max(iso_flux[i],core5_flux[i]));
1375 dc[i] = c2 - core_flux[i];
1380 for (iloop = 0; iloop < MAXLOOP; iloop++) {
1385 for (i = 0; i < nrows; i++) {
1389 if (ellipticity[i] < elllim && core_flux[i] < blim &&
1390 core_flux[i] > flim &&
1391 fabs(dc[i] - *medval) < 3.0*(*sigma) &&
1392 cls[i] == -1.0 && sig[i] < 5.0 &&
1393 xpos[i] >= xmin && xpos[i] <= xmax && ypos[i] >= ymin &&
1394 ypos[i] <= ymax && areal[0][i] >= pixlim)
1395 if (iloop > 0 || (iloop == 0 && dc[i] >= 0.0)) {
1405 anhist(work,n,medval,sigma);
1406 *sigma = 1.48*(*medval - work[(int)(0.25*(
float)(n+3))-1]);
1407 *sigma = max(0.025,*sigma);
1409 medstat(work,n,medval,&sigmanew);
1410 *sigma = min(*sigma,sigmanew);
1411 *sigma = max(0.01,*sigma);
1420 *sigma = max(*sigma,0.01);
1429static void classstats_ap67(
float *mag1,
float *mag2,
float *medval,
1433 float *work,*dc,sigmanew;
1439 elllim = min(0.5,max(0.2,fitell+2.0*sigell));
1443 work = cpl_malloc(nrows*
sizeof(
float));
1444 dc = cpl_malloc(nrows*
sizeof(
float));
1448 for (i = 0; i < nrows; i++)
1449 dc[i] = mag1[i] - mag2[i];
1453 for (iloop = 0; iloop < MAXLOOP; iloop++) {
1458 for (i = 0; i < nrows; i++) {
1462 if (ellipticity[i] < elllim && core_flux[i] < blim &&
1463 core_flux[i] > flim &&
1464 fabs(dc[i] - *medval) < 3.0*(*sigma) &&
1465 cls[i] == -1.0 && sig[i] < 5.0 &&
1466 xpos[i] >= xmin && xpos[i] <= xmax && ypos[i] >= ymin &&
1467 ypos[i] <= ymax && areal[0][i] >= pixlim) {
1468 if (iloop > 0 || (iloop == 0 && dc[i] >= 0.0)) {
1479 anhist(work,n,medval,sigma);
1480 *sigma = 1.48*(*medval - work[(int)(0.25*(
float)(n+3))-1]);
1481 *sigma = max(0.025,*sigma);
1483 medstat(work,n,medval,&sigmanew);
1484 *sigma = min(*sigma,sigmanew);
1485 *sigma = max(0.01,*sigma);
1494 *sigma = max(*sigma,0.01);
1522static void classstats_final(
void) {
1523 int n,i,iloop,iarg,ii,iend,ncls,kk,k;
1524 float *work,ell,core,sig1,sig2,sig3,denom,w1,w2,w3,core_small;
1525 float core_large,*statistic,core_midd,pkht,xcor,cfit,csig;
1526 float *work1,junk,corlim1,corval1,corlim2,corval2,sigmaold;
1530 sigma_final = 1.0e6;
1536 work = cpl_malloc(nrows*
sizeof(
float));
1537 work1 = cpl_malloc(nrows*
sizeof(
float));
1538 statistic = cpl_malloc(nrows*
sizeof(
float));
1542 for (i = 0; i < nrows; i++) {
1543 ell = ellipticity[i];
1545 core = core_flux[i];
1546 iarg = casu_nint(10.0*(core - 5.0));
1547 iarg = max(1,min(NSAMPLE,iarg)) - 1;
1549 sig1 = max(0.01,(fit1 - lower1[iarg])/3.0);
1550 sig2 = max(0.01,(fit2 - lower2[iarg])/3.0);
1552 sig1 = max(0.01,(fit4 - lower1[iarg])/3.0);
1553 sig2 = max(0.01,(fit5 - lower2[iarg])/3.0);
1555 sig3 = max(0.01,(fit3 - lower3[iarg])/3.0);
1556 denom = (wt1/sig1 + wt2/sig2 + wt3/sig3);
1557 w1 = (wt1/sig1)/denom;
1558 w2 = (wt2/sig2)/denom;
1559 w3 = (wt3/sig3)/denom;
1561 core_small = core1_flux[i];
1562 core_large = core3_flux[i];
1563 statistic[i] = (core - core_small - fit1)*w1 +
1564 (core_large - core - fit2)*w2 + (core - pkht - fit3)*w3;
1566 core_midd = core2_flux[i];
1567 core_large = core4_flux[i];
1568 statistic[i] = (core_midd - core - fit4)*w1 +
1569 (core_large - core - fit5)*w2 + (core - pkht - fit3)*w3;
1576 for (iloop = 0; iloop < MAXLOOP; iloop++) {
1577 sigmaold = sigma_final;
1579 for (i = 0; i < nrows ; i++) {
1581 ell = ellipticity[i];
1582 core = core_flux[i];
1583 if (ell < elllim && core < blim && core > flim &&
1584 fabs((
double)(statistic[i] - fit_final)) < 3.0*sigma_final &&
1585 areal[0][i] >= pixlim)
1586 work[n++] = statistic[i];
1591 if (core > corlim && iloop == MAXLOOP-2) {
1592 cls[ncls] = statistic[i];
1601 if (iloop == 0 && n > 10) {
1602 anhist(work,n,&fit_final,&sigma_final);
1604 medstat(work,n,&fit_final,&sigma_final);
1606 sigma_final = max(0.01,min(sigmaold,sigma_final));
1615 sort2(sig,cls,ncls);
1624 while (iend == 0 && i < ncls-1) {
1626 if (sig[i] > xcor+0.25 && ii >= 3) {
1627 medstat(work,ii,&cfit,&csig);
1628 for (iloop = 0; iloop < 3; iloop++) {
1630 for (k = 0; k < ii; k++) {
1631 if (work[k] <= cfit + 3.0*csig)
1632 work1[kk++] = work[k];
1634 medstat(work1,kk,&cfit,&junk);
1636 if (cfit <= fit_final + 3.0*sigma_final) {
1645 work[ii++] = cls[i];
1652 corlim = corlim2 - 0.5*(corval2 - fit_final - 3.0*sigma_final)/(corval2 - corval1);
1655 corlim = max(cormin,corlim);
1657 for (i = 0; i < nrows; i++) {
1658 core = core_flux[i];
1660 work[kk++] = peak_height[i] + skylevel;
1663 medstat(work,kk,&avsat,&junk);
1664 avsat = max(10000.0+skylevel,avsat);
1666 avsat = 10000.0 + skylevel;
1673 freespace(statistic);
1703static void medstat(
float *array,
int n,
float *medval,
float *sigval) {
1719 *medval = array[lev1-1];
1720 *sigval = 1.48*0.5*(array[lev2-1] - array[lev3-1]);
1744static void sort1(
float *a,
int n) {
1745 int iii,ii,i,ifin,j;
1751 iii = min(n,(3*iii)/4 - 1);
1756 for (ii = 0; ii < ifin; ii++) {
1765 if (i < 0 || a[i] <= b)
1798static void sort2(
float *a1,
float *a2,
int n) {
1799 int iii,ii,i,ifin,j;
1805 iii = min(n,(3*iii)/4 - 1);
1810 for (ii = 0; ii < ifin; ii++) {
1813 if (a1[i] > a1[j]) {
1821 if (i < 0 || a1[i] <= b1)
cpl_propertylist * casu_tfits_get_ehu(casu_tfits *p)
cpl_table * casu_tfits_get_table(casu_tfits *p)
int imcore_classify(casu_tfits *catalogue, float minsize, int cattype)
Do star/galaxy classification.