39static int **hist = NULL;
40static int *nnp = NULL;
43static void tidy(
void);
44static 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;
87 unsigned char *mflag,*bbad;
99 fracx = ((float)nx)/((float)nbsize);
100 fracy = ((float)ny)/((float)nbsize);
101 ifracx = (int)(fracx + 0.1);
102 ifracy = (int)(fracy + 0.1);
105 nbsize = MAX(NINT(0.9*nbsize), MIN(nbsize, MIN(nbsizx,nbsizy)));
106 nbsize = MIN(nx,MIN(ny,nbsize));
112 npixstripe = nbsize*nx;
118 hist = cpl_malloc(nbx*
sizeof(
int *));
119 for (l = 0; l < nbx; l++)
120 hist[l] = cpl_malloc(MAXHIST*
sizeof(
int));
124 bvals = cpl_malloc(nby*
sizeof(
float *));
125 for (l = 0; l < nby; l++)
126 bvals[l] = cpl_malloc(nbx*
sizeof(
float));
127 bbad = cpl_calloc(nbx*nby,
sizeof(
unsigned char));
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){
178 for (iloop = 0; iloop < 3; iloop++) {
180 for(i = NINT(skymedc+3.0*sigmac); i <= iclip; i++)
181 irej += shist[i-MINHISTVAL];
184 iclip = NINT(skymedc+3.0*sigmac) - 1;
185 mcpix = mcpix - irej;
189 bvals[l][j] = skymedc;
191 bvals[l][j] = -1000.0;
203 work = cpl_malloc(nbx*nby*
sizeof(*work));
205 for(l = 0; l < nby; l++)
206 for(j = 0; j < nbx; j++)
208 work[k++] = bvals[l][j];
217 fnbsize = 1.0/((float)nbsize);
218 for (k = 0; k < ny; k++) {
223 iby = (k + 1 + nbsizo2)/nbsize;
225 iby = MIN(nby,MAX(1,iby));
226 ibyp1 = MIN(nby,ibyp1);
227 dely = (k + 1 - nbsize*iby + nbsizo2)*fnbsize;
229 for (j = 0; j < nx; j++) {
230 if (map[kk+j] == nullval)
235 ibx = (j + 1 + nbsizo2)/nbsize;
237 ibx = MIN(nbx,MAX(1,ibx));
238 ibxp1 = MIN(nbx,ibxp1);
239 delx = (j + 1 - nbsize*ibx + nbsizo2)*fnbsize;
243 t1 = (1.0 - dely)*bvals[iby-1][ibx-1] + dely*bvals[ibyp1-1][ibx-1];
244 t2 = (1.0 - dely)*bvals[iby-1][ibxp1-1] + dely*bvals[ibyp1-1][ibxp1-1];
245 dsky = avsky - (1.0 - delx)*t1 - delx*t2;
296 float *skymed,
float *skysig,
float *sat) {
297 int ilev,iclip,iloop,i,*ihist,isat,iter;
298 long mpix,npix,k,mcpix,irej,lpix,nx,ny;
299 float skymedc,sigmac,*map,sata,fac,skyref;
300 unsigned char *mflag;
312 for (i = 0; i < nx*ny; i++) {
313 if (map[i] != nullval && mflag[i] != MF_ZEROCONF &&
314 mflag[i] != MF_STUPID_VALUE) {
328 ihist = cpl_calloc(MAXHIST,
sizeof(*ihist));
336 for (iter = 0; iter <= 9; iter++) {
340 for (k = 0; k < MAXHIST; k++)
348 for (k = 0; k < npix; k++) {
349 if (map[k] != nullval && mflag[k] != MF_ZEROCONF &&
350 mflag[k] != MF_STUPID_VALUE) {
351 ilev = MIN(MAXHISTVAL,MAX(MINHISTVAL,NINT(fac*(map[k]-skyref))));
352 ihist[ilev - MINHISTVAL] += 1;
353 isat = MAX(isat,ilev);
357 sata = MIN(MAXHISTVAL,MAX(MINSATURATE,0.9*((
float)isat))/fac);
358 lpix = ihist[isat - MINHISTVAL];
359 while (lpix < mpix/1000 && isat > MINHISTVAL) {
361 lpix += ihist[isat - MINHISTVAL];
363 *sat = ((float)isat)/fac + skyref;
364 *sat = MIN(MAXHISTVAL,MAX(MINSATURATE,MAX(0.95*(*sat),sata)));
375 imcore_medsig(ihist,MAXHIST,MINHISTVAL-1,mpix,skymed,skysig);
384 for (iloop = 0; iloop < 3; iloop++) {
386 for (i = NINT(skymedc+3.0*sigmac); i <= iclip; i++)
387 irej += ihist[i - MINHISTVAL];
390 iclip = NINT(skymedc+3.0*sigmac)-1;
401 *skymed = skymedc/fac + skyref;
402 *skysig = sigmac/fac;
445 int i,j,nbx,nby,nbsize,nbsizo2,iby,ibyp1,ibx,ibxp1;
446 float **bvals,fnbsize,dely,delx,t1,t2;
450 nbx = ap->backmap.nbx;
451 nby = ap->backmap.nby;
452 nbsize = ap->backmap.nbsize;
453 bvals = ap->backmap.bvals;
463 fnbsize = 1.0/((float)nbsize);
464 iby = (j + nbsizo2)/nbsize;
466 iby = MIN(nby,MAX(1,iby));
467 ibyp1 = MIN(nby,ibyp1);
468 dely = (j - nbsize*iby + nbsizo2)*fnbsize;
469 ibx = (i + nbsizo2)/nbsize;
471 ibx = MIN(nbx,MAX(1,ibx));
472 ibxp1 = MIN(nbx,ibxp1);
473 delx = (i - nbsize*ibx + nbsizo2)*fnbsize;
478 t1 = (1.0 - dely)*bvals[iby-1][ibx-1] + dely*bvals[ibyp1-1][ibx-1];
479 t2 = (1.0 - dely)*bvals[iby-1][ibxp1-1] + dely*bvals[ibyp1-1][ibxp1-1];
480 *skylev = (1.0 - delx)*t1 + delx*t2;
481 *skyrms = 0.25*(fabsf(bvals[iby-1][ibx-1] - *skylev) +
482 fabsf(bvals[ibyp1-1][ibx-1] - *skylev) +
483 fabsf(bvals[iby-1][ibxp1-1] - *skylev) +
484 fabsf(bvals[ibyp1-1][ibxp1-1] - *skylev));
527 float *med,
float *sig) {
535 while (isum <= (itarg+1)/2 && (medata-MINHISTVAL) < nh) {
537 isum += shist[medata-MINHISTVAL];
539 if (shist[medata-MINHISTVAL] == 0) {
542 ffrac = (float)(isum - (itarg+1)/2)/(
float)shist[medata-MINHISTVAL];
544 *med = (float)medata - ffrac + 0.5;
550 while (isum <= (itarg+3)/4 && (medata-MINHISTVAL) < nh) {
552 isum += shist[medata-MINHISTVAL];
554 if (shist[medata-MINHISTVAL] == 0) {
557 ffrac = (float)(isum - (itarg+3)/4)/(
float)shist[medata-MINHISTVAL];
559 sigmed = (float)medata - ffrac + 0.5;
560 *sig = 1.48*(*med - sigmed);
561 *sig = MAX(0.5,*sig);
585static void sortit (
float ia[],
int n) {
586 int i, j, ii, jj, ifin;
592 jj = MIN(n,(3 * jj)/4 - 1);
596 for (ii = 0; ii < ifin; ii++) {
608 }
while (ia[i] > it);
616static void tidy(
void) {
621 for (i = 0; i < npvx; i++)
int imcore_background(ap_t *ap, int nbsize, float nullval)
Model and create background map.
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 imcore_medsig(int *shist, int nh, int ist, int itarg, float *med, float *sig)
Analyse histogram to work out median and sigma.
void imcore_backest(ap_t *ap, float x, float y, float *skylev, float *skyrms)
Work out estimated sky for a pixel position.
void imcore_bfilt(float **xbuf, int nx, int ny)
Do bilinear median and linear filtering on background values.