35 #include "floatmath.h"
39 static int **hist = NULL;
40 static int *nnp = NULL;
43 static void tidy(
void);
44 static void sortit (
float [],
int);
82 float fracx,fracy,skymed,sigma,skymedc,sigmac,avsky,fnbsize,dely,delx;
83 float t1,t2,dsky,*map,**bvals,*work;
84 int ifracx,ifracy,nbsizx,nbsizy,nbx,nby,npixstripe,l,i,ll;
85 int isquare,ilev,j,iclip,mcpix,iloop,irej,nbsizo2,kk,k,iby,ibyp1,ibx,ibxp1;
100 fracx = ((float)nx)/((float)nbsize);
101 fracy = ((float)ny)/((float)nbsize);
102 ifracx = (int)(fracx + 0.1);
103 ifracy = (int)(fracy + 0.1);
106 nbsize = MAX(NINT(0.9*nbsize), MIN(nbsize, MIN(nbsizx,nbsizy)));
107 nbsize = MIN(nx,MIN(ny,nbsize));
113 npixstripe = nbsize*nx;
119 hist = cpl_malloc(nbx*
sizeof(
int *));
120 for (l = 0; l < nbx; l++)
121 hist[l] = cpl_malloc(MAXHIST*
sizeof(
int));
125 bvals = cpl_malloc(nby*
sizeof(
float *));
126 for (l = 0; l < nby; l++)
127 bvals[l] = cpl_malloc(nbx*
sizeof(
float));
131 ap->backmap.nbx = nbx;
132 ap->backmap.nby = nby;
133 ap->backmap.nbsize = nbsize;
134 ap->backmap.bvals = bvals;
138 nnp = cpl_malloc(nbx*
sizeof(
int));
143 for (l = 0; l < nby; l++) {
144 memset((
char *)nnp,0,nbx*
sizeof(*nnp));
145 for (i = 0; i < nbx; i++)
146 memset((
char *)hist[i],0,MAXHIST*
sizeof(
int));
152 for (i = 0; i < npixstripe; i++) {
153 if (map[ll+i] != nullval && mflag[ll+i] != MF_ZEROCONF &&
154 mflag[ll+i] != MF_STUPID_VALUE) {
155 isquare = (int)((
float)(i % nx)/(
float)nbsize);
156 isquare = MIN(nbx-1,MAX(0,isquare));
157 ilev = MIN(MAXHISTVAL,MAX(MINHISTVAL,NINT(map[i+ll])));
158 hist[isquare][ilev-MINHISTVAL] += 1;
165 for (j = 0; j < nbx; j++) {
166 if (nnp[j] > 0.25*nbsize*nbsize){
168 imcore_medsig(shist,MAXHIST,MINHISTVAL-1,nnp[j],&skymed,&sigma);
177 for (iloop = 0; iloop < 3; iloop++) {
179 for(i = NINT(skymedc+3.0*sigmac); i <= iclip; i++)
180 irej += shist[i-MINHISTVAL];
183 iclip = NINT(skymedc+3.0*sigmac) - 1;
184 mcpix = mcpix - irej;
188 bvals[l][j] = skymedc;
190 bvals[l][j] = -1000.0;
197 bfilt(bvals,nbx,nby);
201 work = cpl_malloc(nbx*nby*
sizeof(*work));
203 for(l = 0; l < nby; l++)
204 for(j = 0; j < nbx; j++)
205 work[k++] = bvals[l][j];
206 sortit(work,nbx*nby);
207 avsky = work[(nbx*nby)/2];
213 fnbsize = 1.0/((float)nbsize);
214 for (k = 0; k < ny; k++) {
219 iby = (k + 1 + nbsizo2)/nbsize;
221 iby = MIN(nby,MAX(1,iby));
222 ibyp1 = MIN(nby,ibyp1);
223 dely = (k + 1 - nbsize*iby + nbsizo2)*fnbsize;
225 for (j = 0; j < nx; j++) {
226 if (map[kk+j] == nullval)
231 ibx = (j + 1 + nbsizo2)/nbsize;
233 ibx = MIN(nbx,MAX(1,ibx));
234 ibxp1 = MIN(nbx,ibxp1);
235 delx = (j + 1 - nbsize*ibx + nbsizo2)*fnbsize;
239 t1 = (1.0 - dely)*bvals[iby-1][ibx-1] + dely*bvals[ibyp1-1][ibx-1];
240 t2 = (1.0 - dely)*bvals[iby-1][ibxp1-1] + dely*bvals[ibyp1-1][ibxp1-1];
241 dsky = avsky - (1.0 - delx)*t1 - delx*t2;
292 float *skymed,
float *skysig,
float *sat) {
293 int ilev,iclip,iloop,i,*ihist,isat,iter;
294 long mpix,npix,k,mcpix,irej,lpix,nx,ny;
295 float skymedc,sigmac,*map,sata,fac,skyref;
296 unsigned char *mflag;
308 for (i = 0; i < nx*ny; i++) {
309 if (map[i] != nullval && mflag[i] != MF_ZEROCONF &&
310 mflag[i] != MF_STUPID_VALUE) {
324 ihist = cpl_calloc(MAXHIST,
sizeof(*ihist));
332 for (iter = 0; iter <= 9; iter++) {
336 for (k = 0; k < MAXHIST; k++)
344 for (k = 0; k < npix; k++) {
345 if (map[k] != nullval && mflag[k] != MF_ZEROCONF &&
346 mflag[k] != MF_STUPID_VALUE) {
347 ilev = MIN(MAXHISTVAL,MAX(MINHISTVAL,NINT(fac*(map[k]-skyref))));
348 ihist[ilev - MINHISTVAL] += 1;
349 isat = MAX(isat,ilev);
353 sata = MIN(MAXHISTVAL,MAX(MINSATURATE,0.9*((
float)isat))/fac);
354 lpix = ihist[isat - MINHISTVAL];
355 while (lpix < mpix/1000 && isat > MINHISTVAL) {
357 lpix += ihist[isat - MINHISTVAL];
359 *sat = ((float)isat)/fac + skyref;
360 *sat = MIN(MAXHISTVAL,MAX(MINSATURATE,MAX(0.95*(*sat),sata)));
371 imcore_medsig(ihist,MAXHIST,MINHISTVAL-1,mpix,skymed,skysig);
380 for (iloop = 0; iloop < 3; iloop++) {
382 for (i = NINT(skymedc+3.0*sigmac); i <= iclip; i++)
383 irej += ihist[i - MINHISTVAL];
386 iclip = NINT(skymedc+3.0*sigmac)-1;
388 imcore_medsig(ihist,MAXHIST,MINHISTVAL-1,mcpix,&skymedc,&sigmac);
396 *skymed = skymedc/fac + skyref;
397 *skysig = sigmac/fac;
440 int i,j,nbx,nby,nbsize,nbsizo2,iby,ibyp1,ibx,ibxp1;
441 float **bvals,fnbsize,dely,delx,t1,t2;
445 nbx = ap->backmap.nbx;
446 nby = ap->backmap.nby;
447 nbsize = ap->backmap.nbsize;
448 bvals = ap->backmap.bvals;
458 fnbsize = 1.0/((float)nbsize);
459 iby = (j + nbsizo2)/nbsize;
461 iby = MIN(nby,MAX(1,iby));
462 ibyp1 = MIN(nby,ibyp1);
463 dely = (j - nbsize*iby + nbsizo2)*fnbsize;
464 ibx = (i + nbsizo2)/nbsize;
466 ibx = MIN(nbx,MAX(1,ibx));
467 ibxp1 = MIN(nbx,ibxp1);
468 delx = (i - nbsize*ibx + nbsizo2)*fnbsize;
473 t1 = (1.0 - dely)*bvals[iby-1][ibx-1] + dely*bvals[ibyp1-1][ibx-1];
474 t2 = (1.0 - dely)*bvals[iby-1][ibxp1-1] + dely*bvals[ibyp1-1][ibxp1-1];
475 *skylev = (1.0 - delx)*t1 + delx*t2;
476 *skyrms = 0.25*(fabsf(bvals[iby-1][ibx-1] - *skylev) +
477 fabsf(bvals[ibyp1-1][ibx-1] - *skylev) +
478 fabsf(bvals[iby-1][ibxp1-1] - *skylev) +
479 fabsf(bvals[ibyp1-1][ibxp1-1] - *skylev));
521 extern void imcore_medsig(
int *shist,
int nh,
int ist,
int itarg,
float *med,
530 while (isum <= (itarg+1)/2 && (medata-MINHISTVAL) < nh) {
532 isum += shist[medata-MINHISTVAL];
534 if (shist[medata-MINHISTVAL] == 0) {
537 ffrac = (float)(isum - (itarg+1)/2)/(
float)shist[medata-MINHISTVAL];
539 *med = (float)medata - ffrac + 0.5;
545 while (isum <= (itarg+3)/4 && (medata-MINHISTVAL) < nh) {
547 isum += shist[medata-MINHISTVAL];
549 if (shist[medata-MINHISTVAL] == 0) {
552 ffrac = (float)(isum - (itarg+3)/4)/(
float)shist[medata-MINHISTVAL];
554 sigmed = (float)medata - ffrac + 0.5;
555 *sig = 1.48*(*med - sigmed);
556 *sig = MAX(0.5,*sig);
580 static void sortit (
float ia[],
int n) {
581 int i, j, ii, jj, ifin;
587 jj = MIN(n,(3 * jj)/4 - 1);
591 for (ii = 0; ii < ifin; ii++) {
603 }
while (ia[i] > it);
611 static void tidy(
void) {
616 for (i = 0; i < npvx; i++)
void imcore_backest(ap_t *ap, float x, float y, float *skylev, float *skyrms)
Work out estimated sky for a pixel position.
int imcore_backstats(ap_t *ap, float nullval, int satonly, float *skymed, float *skysig, float *sat)
Work out robust background estimate over a whole input image.
void bfilt(float **xbuf, int nx, int ny)
Do bilinear median and linear filtering on background values.
void imcore_medsig(int *shist, int nh, int ist, int itarg, float *med, float *sig)
Analyse histogram to work out median and sigma.
int imcore_background(ap_t *ap, int nbsize, float nullval)
Model and create background map.