int main(void)
{
byte* buffer;
byte* pivots;
size_t i;
comb_init();
buffer = malloc(NUM_COMBS_ITER * COMB_SIZE);
pivots = malloc(NUM_FILES * COMB_SIZE);
for (i = 0; i < NUM_ITERS; i++)
{
printf("\nIteration %d of %d.\n\n", i + 1, NUM_ITERS);
printf("Filling combinations buffer...");
timer_reset();
fill_comb_buffer(buffer);
printf(" DONE in %fs.\n", timer_elapsed());
printf("Sorting combinations buffer...");
timer_reset();
qsort(buffer, NUM_COMBS_ITER, COMB_SIZE, comb_sum_cmp);
printf(" DONE in %fs.\n", timer_elapsed());
if (i == 0)
{
printf("Creating output files...");
create_output_files();
printf(" DONE.\n");
printf("Getting and saving pivots...");
get_pivots(pivots, buffer);
save_pivots(pivots);
printf(" DONE.\n");
}
printf("Saving sorted combinations buffer...");
timer_reset();
save_comb_buffer(buffer, pivots);
printf(" DONE in %fs.\n", timer_elapsed());
}
free(buffer);
free(pivots);
comb_free();
return 0;
}
int mathfunc() {
float Baseline, X;
int pixel, im;
char msg[1024];
if (nbr_infiles<1 || input_sizes_differ || !want_output(0)){
return FALSE;
}
if (nbr_outfiles != in_vec_len[0]) {
sprintf(msg,"%s: The number of output images (%d) must match number of input images (%d)\n",
PGM,nbr_outfiles,in_vec_len[0]);
ib_errmsg(msg);
return FALSE;
}
create_output_files(nbr_infiles, in_object[0]);
/* Loop through every pixel */
for (pixel = 0; pixel < img_size; pixel++){
if (nbr_image_vecs < 2)
Baseline = in_data[0][pixel];
else {
Baseline = 0;
for (im = vecindx[1]; im < vecindx[1]+in_vec_len[1]; im++)
Baseline += in_data[im][pixel];
Baseline /= in_vec_len[1];
}
/* Loop through all images in input vector */
for (im = 0; im < nbr_infiles; im++){
X = in_data[im][pixel];
if (want_output(im)){
out_data[im][pixel] = X - Baseline;
}
} /* end of image loop */
} /* end pixel loop */
return TRUE;
}
int
mathfunc()
{
int i;
double val;
double *xvars; /* Values of the independent variable(s) */
int nvars; /* Nbr of independent variables */
int np = 0; /* Number of numerical parameters found */
double threshold = 0; /* Ignore pixels below this intensity */
double sigLev = 1; // Significance level to set pixel's fit value (1=no significance)
double chisq = 0; // Chi-square -- alternative to sigLev, if set
double snThresh = 0; // min S/N to set value of parameter pixel
int nparams = 0; /* Nbr of parameters in fit */
char *xname = "ti";
char msg[256];
char *str;
int quick = FALSE;
int noderiv = FALSE;
int gotfun = FALSE;
int fit_type = NONLINEAR;
int use_prev_params = FALSE;
int prev = FALSE;
int noprev = FALSE;
int pdone;
void (*function)() = NULL;
void (*jacobian)() = NULL;
int (*guess)() = NULL;
int (*parfix)() = NULL;
int (*method)() = NULL;
double *(*xvarfunc)() = set_xvars;
int arg = 2;
extern double d1mach_();
if (in_vec_len[0]<1){
ib_errmsg("MATH: fit: No input images");
return FALSE;
}
if (input_sizes_differ){
ib_errmsg("MATH: fit: Input image sizes differ");
return FALSE;
}
if (!want_output(0)){
ib_errmsg("MATH: fit: No frame for first output image");
return FALSE;
}
/* Read numerical parameters (nothing to do with params of the fit!) */
pdone = FALSE;
for (i=0; i<nbr_params && !pdone; i++){
val = in_params[i];
switch (i){
case 0:
threshold = val;
pdone = TRUE; /* Last parameter to read */
break;
}
}
nbr_params -= i;
in_params += i;
/* Read string parameters */
gotfun = FALSE;
for (i=0; i<nbr_strings; i++){
str = in_strings[i];
if (!gotfun && getfunction(str, &nparams, &use_prev_params, &fit_type,
&function, &jacobian, &guess, &parfix))
{
/* Got a functional form */
gotfun = TRUE;
}else if (!quick && strcasecmp(str,"quick") == 0){
/* Use "quick" mode */
quick = TRUE;
}else if (!noderiv && strcasecmp(str,"noderiv") == 0){
/* Do not use derivative, even if available */
noderiv = TRUE;
}else if (!prev && strcasecmp(str,"prev") == 0){
/* Use previous parameter values for estimates */
prev = TRUE;
}else if (!noprev && strcasecmp(str,"noprev") == 0){
/* Do not use previous parameter values for estimates */
noprev = TRUE;
} else if (strncasecmp(str, "p=", 2) == 0) {
val = atof(str+2);
if (val != 0) {
val = val < 1e-20 ? 1e-20 : (val > 1 ? 1 : val);
sigLev = val;
}
} else if (strncasecmp(str, "chisq=", 6) == 0) {
val = atof(str+6);
if (val != 0) {
chisq = val;
}
} else if (strncasecmp(str, "snThresh=", 9) == 0) {
val = atof(str+9);
if (val != 0) {
snThresh = val;
}
}else{
/* None of the above--assume independent variable name */
xname = str;
}
}
/* Do not write to more output files than we can usefully use */
if (nparams){
int maxout;
maxout = 2 * nparams + 1;
if (maxout<nbr_outfiles) nbr_outfiles = maxout; /* Change global var */
}
create_output_files(nbr_outfiles, in_object[0]);
/* Check the setup */
if (!gotfun){
ib_errmsg("MATH: fit: No known fit type specified");
return FALSE;
}
if (noderiv){
jacobian = NULL;
}
if (prev){
use_prev_params = TRUE;
}else if (noprev){
use_prev_params = FALSE;
}
if (quick || !function){
method = NULL;
}else{
method = marquardt;
}
/* Set the independent variable */
xvars = (*xvarfunc)(in_object, in_vec_len[0], xname, &nvars);
if (!xvars){
sprintf(msg,"MATH: No values for independent variable \"%.200s\"",
xname);
ib_errmsg(msg);
return FALSE;
}
if (chisq == 0) {
chisq = chisqCompInv(sigLev, in_vec_len[0] - nparams + 1);
}
fit_images(in_object, in_vec_len[0], xvars, nvars,
threshold, chisq, snThresh, img_width, img_height, img_depth,
out_object, nbr_outfiles, want_output, fit_type,
nparams, use_prev_params,
function, jacobian, method, guess, parfix);
write_output_files();
return TRUE;
}
int mathfunc() {
double sum, sum_x2, mean, std, min, max, X, thr;
double av_mean,av_std, av_pp, max_std, min_std, max_pp, min_pp;
float fract;
float **tmp_data;
int pixel, im, N, Nfilter;
int r,c, r0, c0, r1, r2, c1, c2;
int rad, d, do_filter;
int n1, n2, n3, n4;
char msg[1024],pgm[1024];
enum {nstdp, npp, nmean, nstd}; /* output images 0,1,2,3 */
FILE *fp;
if (nbr_infiles<1 || input_sizes_differ || !want_output(0))
return FALSE;
create_output_files(4, in_object[0]);
/*************************************/
/* Get input parameters */
/*************************************/
/* Comment */
strcpy(pgm,"stats");
if (nbr_strings > 0) {
strcpy(pgm,in_strings[0]);
}
/* Filter size */
if ((img_width < 128) || (img_height < 128))
Nfilter = 5; /* for small matrices, default to a 5x5 filter */
else
Nfilter = 11; /* else default to a 11x11 filter */
do_filter = 1;
if (nbr_params > 0)
Nfilter = in_params[0]; /* filter kernel size */
/* How much of the image should we use? */
if (nbr_params > 1)
fract = in_params[1]/100;
else
fract = 0.80; /* default to 80% */
/* Zero center pixels in output images? */
if (nbr_strings > 1) {
if (!strcmp("nodc",in_strings[1])) {
r1 = r2 = c1 = c2 = -1;
n1 = n2 = n3 = n4 = -1; /* default to zero'ing center pixel */
}
}
else {
/* Four pixels in center of image - avoid DC artifact */
r1 = img_height/2-1;
r2 = r1 + 1;
c1 = img_width/2-1;
c2 = c1 + 1;
n1 = (r1-1)*img_width + c1;
n2 = (r1-1)*img_width + c2;
n3 = (r2-1)*img_width + c1;
n4 = (r2-1)*img_width + c2;
}
/* Get threshold for segmenting image */
thr = threshold(in_data[0],img_height,img_width);
/* Find object based on first image */
find_object(in_data[0],thr,img_height,img_width,
&r0,&c0,&r1,&c1,&r2,&c2,&rad);
/* Optional filtering of input images */
if (Nfilter > 0) { /* Filter all images */
do_filter = 1;
if ((tmp_data = (float **) malloc(sizeof(float *)*nbr_infiles)) == NULL)
ib_errmsg("MALLOC ERROR 1");
for (im = 0; im < nbr_infiles; im++)
if ((tmp_data[im] = (float *) malloc(sizeof(float)*img_size)) == NULL)
ib_errmsg("MALLOC ERROR 2");
for (im = 0; im < nbr_infiles; im++)
filter(in_data[im],tmp_data[im],Nfilter,img_height,img_width,thr);
}
/* Initialize output image */
for (r = 0; r < img_height; r++) {
for (c = 0; c < img_width; c++) {
pixel = r*img_width + c;
if (want_output(nmean)) out_data[nmean][pixel] = 0;
if (want_output(nstd)) out_data[nstd][pixel] = 0;
if (want_output(nstdp)) out_data[nstdp][pixel] = 0;
if (want_output(npp)) out_data[npp][pixel] = 0;
}
}
/* Loop through every pixel */
av_std = av_pp = 0;
for (r = r1; r < r2; r++){
for (c = c1; c < c2; c++){
pixel = r*img_width + c;
d = (int) sqrt((double) ((r-r0)*(r-r0) + (c-c0)*(c-c0))); /* distance from center */
sum = sum_x2 = 0.0;
min = 1e6;
max = 0.0;
mean = std = 0;
N = 0;
if ((pixel != n1) && (pixel != n2) && (pixel != n3) && (pixel != n4)) { /* skip center pixels */
if (in_data[0][pixel] > thr) {
/* Loop through all images in input vector */
for (im = 0; im < nbr_infiles; im++) {
if (do_filter)
X = tmp_data[im][pixel];
else
X = in_data[im][pixel];
sum += X;
sum_x2 += (X*X);
if (X < min) min = X;
if (X > max) max = X;
N++;
} /* end of image loop */
mean = sum/N;
std = (double) sqrt((double)((sum_x2/N) - (mean*mean)));
} /* End check threshold */
} /* End check center pixel */
/* DEBUG
if (((r == 37) && (c == 28)) || ((r == 32) && (c == 25))){
printf("At (%d,%d), max, min, mean, pp, std is %f, %f, %f, %f, %f\n",
c,r,max, min, mean, (max - min)/mean*100.0,std);
printf("sum, sumsq, sumsq/N, mean^2, sqr = %f, %f, %f, %f, %f, N = %d\n",
sum,sum_x2*1000,sum_x2/N*1000*1000, mean*mean*1000*1000,(sum_x2/N - mean*mean)*1000*1000,N);
}
/**/
if (want_output(nmean)) out_data[nmean][pixel] = mean;
if (want_output(nstd)) out_data[nstd][pixel] = std;
if (want_output(nstdp)) {
if (mean != 0)
out_data[nstdp][pixel] = std/mean*100;
else
out_data[nstdp][pixel] = 0;
}
if (want_output(npp)) {
if (mean != 0)
out_data[npp][pixel] = (max - min)/mean*100.0;
else
out_data[npp][pixel] = 0;
}
} /* end columns loop */
} /* end rows loop */
/* Get average standard deviation and PP within image */
av_std = av_pp = 0;
max_std = max_pp = 0;
min_std = min_pp = 1e6;
N = 0;
for (r = 0; r < img_height; r++){
for (c = 0; c < img_width; c++){
pixel = r*img_width + c;
d = (int) sqrt((double) ((r-r0)*(r-r0) + (c-c0)*(c-c0))); /* distance from center */
if ((pixel != n1) && (pixel != n2) && (pixel != n3) && (pixel != n4)) { /* skip center pixels */
if ((d < rad) && (in_data[0][pixel] > thr)) {
N++;
X = out_data[nstdp][pixel];
av_std += X;
if (max_std < X) max_std = X;
if (min_std > X) min_std = X;
if (want_output(npp)) {
X = out_data[npp][pixel];
av_pp += X;
if (max_pp < X) max_pp = X;
if (min_pp > X) min_pp = X;
}
}
}
}
}
if (N > 0) {
printf("=========== STATS: %s ===================\n",pgm);
printf("Average standard deviation in %d pixels is %.2f%%\n",N,av_std/N);
printf("Standard deviations range from %.2f%% to %.2f%%\n",min_std,max_std);
if (want_output(npp)) {
printf("Average peak-to-peak is %.2f%%\n",av_pp/N);
printf("Peak-to-peak range from %.2f%% to %.2f%%\n",min_pp,max_pp);
}
if ((fp = fopen("STAB_measurements.txt","a")) == NULL) {
sprintf(msg,"Can't open STAB_measurements.txt for printing results");
ib_errmsg(msg);
return FALSE;
}
fprintf(fp,"=========== STATS: %s ===================\n",pgm);
fprintf(fp,"Average standard deviation in %d pixels is %.2f%%\n",N,av_std/N);
fprintf(fp,"Standard deviations range from %.2f%% to %.2f%%\n",min_std,max_std);
if (want_output(npp)) {
fprintf(fp,"Average peak-to-peak is %.2f%%\n",av_pp/N);
fprintf(fp,"Peak-to-peak range from %.2f%% to %.2f%%\n",min_pp,max_pp);
}
fclose(fp);
}
return TRUE;
}
int mathfunc() {
double meanS, noise, meanG, maxS, minS, sum2, stdS, thr, X, minmax;
int pixel, pixel2, im, n1, n2, r, c, r1, c1, rG, cG, rS1, rS2, cS1, cS2;
int im_r1, im_r2, im_c1, im_c2, r0, c0, rad, d,
Nfilter, NF2, N, skip_pix, pixelG;
double fract;
char msg[1024],pgm[1024];
FILE *fp;
if (nbr_infiles<1 || input_sizes_differ){
return FALSE;
}
if (nbr_outfiles != in_vec_len[0]) {
sprintf(msg,"Math: You must supply as many output images as input images\n");
ib_errmsg(msg);
return FALSE;
}
/**************************/
/* Create output images ***/
/**************************/
if (want_output(1))
create_output_files(nbr_infiles*2, in_object[0]);
else
create_output_files(nbr_infiles, in_object[0]);
/* How large a (mean) filter do we apply to find the ghosting level */
if ((img_width < 128) || (img_height < 128))
Nfilter = 5; /* for small matrices, default to a 5x5 filter */
else
Nfilter = 11; /* else default to a 11x11 filter */
if (nbr_params > 0) Nfilter = (int) in_params[0];
NF2 = (int) (Nfilter/2);
fract = 0.8;
if (nbr_params > 1)
fract = in_params[1]/100;
strcpy(pgm,"SNR");
if (nbr_strings > 0)
strcpy(pgm,in_strings[0]);
/**************************/
/* Calculations ***********/
/**************************/
/* Get threshold for segmenting image */
thr = threshold(in_data[0],img_height,img_width);
/* Find image boundaries (radius) *********/
find_object(in_data[0],thr,img_height,img_width,
&r0,&c0,&im_r1,&im_c1,&im_r2,&im_c2,&rad);
/* rad is the smallest radius; im_r1/c1/r2/c2 gives maximum extent of object */
/* Find noise standard deviation **************/
noise = find_noise(in_data[0],im_r1-3, im_c1-3, im_r2+3, im_c2+3);
for (im = 0; im < nbr_infiles; im++){
/* Apply a NxN mean filter to the image */
filter(in_data[im],out_data[im],Nfilter,img_height,img_width,thr);
/***********************************************/
/* Calculate signal intensity and uniformity ***/
/***********************************************/
meanS = sum2 = n2 = 0;
maxS = 0; minS = 1e6;
for (r = 0; r < img_height; r++) {
for (c = 0; c < img_width; c++) {
pixel = r*img_width + c;
X = in_data[im][pixel];
d = (int) sqrt((double) ((r-r0)*(r-r0) + (c-c0)*(c-c0))); /* distance from center */
if (d <= rad*fract) {
meanS += X;
sum2 += (X*X);
n2++;
minmax = out_data[im][pixel];
/* Find max/min filtered signal intensity */
if (maxS < minmax) {maxS = minmax; rS1=r; cS1 = c;}
if (minS > minmax) {minS = minmax; rS2=r; cS2 = c;}
}
}
}
meanS /= n2;
stdS = (float) sqrt((double)((sum2/n2) - (meanS*meanS)));
/******************************************/
/* Calculate ghost intensity **************/
/******************************************/
/* Assume ghosting is in horizontal direction */
/* Search +/- Nfilter columns beyond maximum extent of object */
meanG = 0;
cG = rG = pixelG = 0;
skip_pix = (Nfilter > 3 ? Nfilter : 3);
for (r = im_r1-1; r <= im_r2; r++) {
/* Check to the left of the image */
for (c = skip_pix; c < im_c1-skip_pix; c++) {
pixel = r*img_width + c;
X = out_data[im][pixel];
if (X > meanG) {
meanG = X;
rG = r; cG = c; pixelG = pixel;
}
}
/* Check to the right of the image */
for (c = im_c2+skip_pix; c < img_width-skip_pix; c++) {
pixel = r*img_width + c;
X = out_data[im][pixel];
if (X > meanG) {
meanG = X;
rG = r; cG = c; pixelG = pixel;
}
}
}
for (r = 0; r < img_height; r++) {
for (c = 0; c < img_width; c++) {
pixel = r*img_width + c;
X = in_data[im][pixel];
d = (int) sqrt((double) ((r-r0)*(r-r0) + (c-c0)*(c-c0))); /* distance from center */
if (!(d <= rad*fract)) {
out_data[im][pixel] = 0;
}
}
}
out_data[im][pixelG] = meanG;
printf("=========== %s: image %d ===================\n",pgm,im+1);
printf("Signal, Noise, Ghosting (x100): %.6f, %.6f, %.6f\n",maxS*100,noise*100, meanG*100);
printf("SNR: %.f (NEMA standard: %.f)\n",maxS/noise, maxS/noise*1.253);
printf("Ghosting: %.2f%% of max signal (in %dx%dROI)\n",(meanG-noise)/maxS*100,Nfilter,Nfilter);
printf("Maximum ghosting is in pixel %d, %d\n",cG,rG);
printf("Percent Image Uniformity is%.2f%%\n",(1-(maxS-minS)/(maxS+minS))*100);
printf("minS, maxS = %f and %f at (%d,%d),(%d,%d)\n",minS*100,maxS*100,cS2,rS2,cS1,rS1);
/* printf("Image variation is %.f%%\n",stdS/meanS*100); */
if ((fp = fopen("SNR_measurements.txt","a")) == NULL) {
sprintf(msg,"Can't open file SNR_measurements.txt for printing results");
ib_errmsg(msg);
return FALSE;
}
fprintf(fp,"=========== %s: image %d ===================\n",pgm,im+1);
fprintf(fp,"Signal, Noise, Ghosting (x100): %.6f, %.6f, %.6f\n",maxS*100,noise*100, meanG*100);
fprintf(fp,"SNR: %.f (NEMA standard: %.f)\n",maxS/noise, maxS/noise*1.253);
fprintf(fp,"Ghosting: %.2f%% of max signal (in %dx%dROI)\n",(meanG-noise)/maxS*100,Nfilter,Nfilter);
fprintf(fp,"Maximum ghosting is in pixel %d, %d\n",cG,rG);
fprintf(fp,"Percent Image Uniformity is%.2f%%\n",(1-(maxS-minS)/(maxS+minS))*100);
fprintf(fp,"minS, maxS = %f and %f at (%d,%d),(%d,%d)\n",minS*100,maxS*100,cS2,rS2,cS1,rS1);
fclose(fp);
} /* end image loop */
return TRUE;
}
