void main(int argc, char **argv)
{
int row, col, row_size, col_size;
char input_image[512], qimage[512];
unsigned char **imgin;
int *bound, *reco, input, label, output, numlev, numbits, c;
int minvalue, maxvalue, range, level, stepsize, temp, end_flag;
FILE *ofp;
extern int optind;
extern char *optarg;
fprintf(stderr,"\n\n\t\tUniform Quantization of Images - Encoder\n");
ofp = stdout;
strcpy(qimage,"standard out");
numlev = -1;
numbits = -1;
minvalue = 0;
maxvalue = 255;
while((c=getopt(argc,argv,"i:o:l:b:m:t:h"))!=EOF)
{
switch (c){
case 'i':
strcpy(input_image,optarg);
break;
case 'o':
strcpy(qimage,optarg);
ofp = fopen(optarg,"wb");
break;
case 'l':
sscanf(optarg,"%d", &numlev);
break;
case 'b':
sscanf(optarg,"%d", &numbits);
break;
case 'm':
sscanf(optarg,"%d", &maxvalue);
break;
case 't':
sscanf(optarg,"%d", &minvalue);
break;
case 'x':
sscanf(optarg,"%d", &row_size);
break;
case 'y':
sscanf(optarg,"%d", &col_size);
break;
case 'h':
usage();
exit(1);
}
}
if(numlev > 0 && numbits > 0)
{
temp = (int) pow((double) 2,(double) numbits);
if(temp != numlev)
{
fprintf(stderr,"\n You have entered values for the number of levels and\n");
fprintf(stderr,"number of bits that are not compatible. The number of\n");
fprintf(stderr,"levels should be 2^(number of bits). If you want to use\n");
fprintf(stderr,"a number of levels which is not a power of 2 then only\n");
fprintf(stderr,"enter a value for the number of levels.\n");
exit(1);
}
}
if(numlev < 0 && numbits < 0)
{
fprintf(stderr,"\n Enter number of bits per pixel: ");
scanf("%d",&numbits);
numlev = (int) pow((double) 2,(double) numbits);
}
if (numbits <= 0 || numbits >= 8) {
fprintf(stderr,"\n You have entered values for the number of bits that\n");
fprintf(stderr,"are not compatible. The number of bits should between\n");
fprintf(stderr,"1 (one) - 7 (seven).\n");
exit(1);
}
if(numlev < 0 && numbits > 0)
numlev = (int) pow((double) 2,(double) numbits);
if(numlev > 0 && numbits < 0)
numbits = (int) (log((double)numlev)/log((double) 2.) + 0.99999);
/* Determine range, and stepsize for the quantizer
*/
range = maxvalue - minvalue + 1;
stepsize = range/(numlev);
/* Allocate space for the boundary values */
bound = (int *) calloc((numlev+1),sizeof(int));
/* Construct the boundary tables */
bound[0] = minvalue;
for(level=1; level<=numlev; level++)
{
bound[level] = bound[level-1] + stepsize;
}
/* Find out how large the image is */
image_size(input_image, &row_size, &col_size);
/* Allocate space for input image */
imgin = (unsigned char **) calloc(row_size,sizeof(char *));
for(row=0; row<row_size; row++)
imgin[row] = (unsigned char *) calloc((col_size),sizeof(char));
/* Read the input image */
readimage(input_image, imgin, row_size, col_size);
/* Store coding parameters in the output file */
fwrite(&numlev,1,sizeof(int),ofp);
fwrite(&numbits,1,sizeof(int),ofp);
fwrite(&maxvalue,1,sizeof(int),ofp);
fwrite(&minvalue,1,sizeof(int),ofp);
fwrite(&row_size,1,sizeof(int),ofp);
fwrite(&col_size,1,sizeof(int),ofp);
struct Queue* code_write;
code_write = (struct Queue*) malloc(sizeof(struct Queue));
code_write->front = NULL;
code_write->rear = NULL;
code_write->size = 0;
// Print(&(code_write)->front);
/* encode each pixel into an integer label and store */
end_flag = 0;
for(row=0; row<row_size; row++)
for(col=0; col<col_size; col++)
{
if(row == row_size-1 && col == col_size - 1)
end_flag = 1;
input = imgin[row][col];
label = encuqi(input,bound,numlev);
// printf("%d %d, ", input, label);
// printf("%d ", &ofp);
// stuffit(label,numbits,&ofp,end_flag);
stuffit(label,numbits,&code_write,end_flag);
}
// Print(&code_write->front);
while(code_write->size >= 8) {
write_to_file(&ofp, &code_write);
}
// printf("%d", code_write->size);
FILE *fp;
fp = fopen(input_image, "rb");
double ratio_com = get_ratio(&fp, &ofp);
printf("\n Ratio compression := %lf %%\n", ratio_com);
fclose(fp);
fclose(ofp);
}
main(int argc, char **argv)
{
FILE *ifp, *ofp, *cb;
int **codebook;
int *input, dimension, index, codebook_size ;
int c, i, j, iteration, numvecs, numbits, *count, end_flag, name_length;
int k,l, blockr, blockc, cp_row, cp_col, row_size, col_size;
float measure, total_distortion, distortion;
char input_image[50], outfile[50];
unsigned char **inimg;
char *cbfile;
extern int optind;
extern char *optarg;
blockr = -1;
blockc = -1;
/* Obtain the filename for the input image */
ifp = stdin;
ofp = stdout;
cb = NULL;
row_size = -1;
col_size = -1;
strcpy(input_image,"standard in");
strcpy(outfile,"standard out");
while((c=getopt(argc,argv,"i:o:c:x:y:h"))!=EOF)
{
switch (c){
case 'i':
strcpy(input_image,optarg);
ifp = fopen(optarg,"rb");
break;
case 'o':
strcpy(outfile,optarg);
ofp = fopen(optarg,"wb");
break;
case 'c':
name_length = strlen(optarg);
cbfile = (char *) malloc((name_length+1)*sizeof(char));
strcpy(cbfile,optarg);
if((cb = fopen(optarg,"rb")) == NULL)
fprintf(stderr,"Codebook file %s not found\n",cbfile);
break;
case 'x':
sscanf(optarg,"%d", &row_size);
break;
case 'y':
sscanf(optarg,"%d", &col_size);
break;
case 'h':
usage();
exit(1);
}
}
if(ifp == stdin )
fprintf(stderr,"Input will be read from standard in\n");
if(ofp == stdout)
fprintf(stderr,"Output will be written to standard out\n");
/* Make sure you have the filename for the codebook */
if(cb ==NULL)
{
fprintf(stderr,"You *have* to enter a file name for the codebook\n");
fprintf(stderr,"A codebook can be created by using trvqsp_img. Remember\n");
fprintf(stderr,"this codebook will be needed to reconstruct the image.\n\n");
usage();
exit(1);
}
/* Write the name of the codebook file to the output file */
fwrite(&name_length,1,sizeof(int),ofp);
fwrite(cbfile,name_length+1,sizeof(char),ofp);
fprintf(stderr,"Codebook file is %s\n",cbfile);
/* If the image dimensions have not been provided get image size */
if(row_size < 0 || col_size < 0)
image_size(input_image, &row_size, &col_size);
printf("Image: %s, Number of rows: %d, Number of columns: %d\n",input_image,row_size,col_size);
/* Write image parameters to the output file */
fwrite(&row_size,1,sizeof(int),ofp);
fwrite(&col_size,1,sizeof(int),ofp);
/* Assign space for input image */
inimg = (unsigned char **) calloc(row_size,sizeof(char *));
for(i=0; i< row_size; i++)
inimg[i] = (unsigned char *) calloc(col_size,sizeof(char));
/* Read the image to be compressed */
readimage(input_image, inimg, row_size, col_size);
/* Read coding parameters from the codebook file */
fread(&blockr,1,sizeof(int),cb);
fread(&blockc,1,sizeof(int),cb);
fread(&codebook_size,1,sizeof(int),cb);
numbits = (int) (log((double) codebook_size)/log((double) 2.) + 0.999);
dimension = blockr*blockc;
numvecs = (row_size*col_size)/dimension;
printf("Codebook size = %d, dimensions = %d %d\n", codebook_size, blockr, blockc);
fprintf(stderr,"Number of bits per vector = %d\n",numbits);
/* Allocate space for the codebook */
codebook = (int **) calloc(codebook_size,sizeof(int *));
for(i=0; i< codebook_size; i++)
codebook[i] = (int *) calloc(dimension,sizeof(int));
/* Read in the codebook */
for(i=0; i< codebook_size; i++)
for(j=0; j< dimension; j++)
{
c=getc(cb);
codebook[i][j] = (int) 0xff & c;
}
/* Allocate space for input and work arrays */
input = (int *) calloc(dimension,sizeof(int));
count = (int *) calloc(codebook_size,sizeof(int));
distortion = 0.0;
total_distortion = 0.0;
cp_row = 0;
cp_col = 0;
for(i=0; i< numvecs; i++)
{
l = 0;
for(j=0; j < blockr; j++)
for(k=0; k < blockc; k++)
{
input[l]=inimg[cp_row+j][cp_col+k];
l++;
}
index = vqencode(input,codebook,codebook_size,dimension,&distortion);
/* Store index */
end_flag = 0;
if(i == (numvecs-1))
end_flag = 1;
stuffit(index,numbits,ofp,end_flag);
total_distortion += distortion;
count[index]++;
cp_col += blockc;
if(cp_col+blockc-1 > col_size)
{
cp_col = 0;
cp_row += blockr;
}
}
total_distortion = total_distortion/(float) numvecs;
printf("distortion is %f\n",total_distortion);
}
void write_fits(string name,imageptr iptr)
{
FLOAT tmpr,xmin[3],xref[3],dx[3],mapmin,mapmax; /* fitsio FLOAT !!! */
FITS *fitsfile;
char *cp, origin[80];
string *hitem, axname[3];
float *buffer, *bp;
int i, j, k, axistype, bitpix, keepaxis[3], nx[3], p[3], nx_out[3], ndim=3;
double bscale, bzero;
if (hasvalue("ndim")) ndim = getiparam("ndim");
nx[0] = Nx(iptr);
nx[1] = Ny(iptr);
nx[2] = Nz(iptr); if (nx[2] <= 0) nx[2] = 1;
xmin[0] = Xmin(iptr)*scale[0];
xmin[1] = Ymin(iptr)*scale[1];
xmin[2] = Zmin(iptr)*scale[2];
dx[0] = Dx(iptr)*scale[0];
dx[1] = Dy(iptr)*scale[1];
dx[2] = Dz(iptr)*scale[2];
xref[0] = Xref(iptr)+1.0;
xref[1] = Yref(iptr)+1.0;
xref[2] = Zref(iptr)+1.0;
axistype = Axis(iptr);
axname[0] = (Namex(iptr) ? Namex(iptr) : xyz[0]);
axname[1] = (Namey(iptr) ? Namey(iptr) : xyz[1]);
axname[2] = (Namez(iptr) ? Namez(iptr) : xyz[2]);
mapmin = MapMin(iptr);
mapmax = MapMax(iptr);
if (Qdummy)
for (i=0; i<3; i++) p[i] = i;
else {
if (Qrefmap) warning("dummy=f and usage of refmap will result in bad headers");
permute(nx,p,3);
dprintf(0,"Reordering axes: %d %d %d\n",p[0],p[1],p[2]);
}
#if 1
for (i=0; i<3; i++) nx_out[i] = nx[p[i]];
/* fix this so CubeValue works */
Nx(iptr) = nx_out[0];
Ny(iptr) = nx_out[1];
Nz(iptr) = nx_out[2];
#else
for (i=0; i<3; i++) nx_out[i] = nx[i];
#endif
sprintf(origin,"NEMO ccdfits %s",getparam("VERSION"));
dprintf(1,"NEMO Image file written to FITS disk file\n");
dprintf(1,"%d %d %d %f %f %f %f %f %f %f %f %f %f %f \n",
nx[0],nx[1],nx[2],xmin[0],xmin[1],xmin[2],dx[0],dx[1],dx[2],xref[0],xref[1],xref[2],
mapmin,mapmax);
dprintf(1,"keepaxis(%d,%d,%d)\n",keepaxis[0],keepaxis[1],keepaxis[2]);
fit_setblocksize(2880*getiparam("blocking"));
bitpix = getiparam("bitpix");
fit_setbitpix(bitpix);
if (bitpix == 16) { /* scale from -2^(bitpix-1) .. 2^(bitpix-1)-1 */
bscale = (mapmax - mapmin) / (2.0*32768.0 - 1.0);
bzero = mapmax - bscale*32767.0;
fit_setscale(bscale,bzero);
} else if (bitpix == 32) {
bscale = (mapmax - mapmin) / (2.0*2147483648.0 - 1.0);
bzero = mapmax - bscale*2147483647.0;
fit_setscale(bscale,bzero);
} else if (bitpix == 8) {
bscale = (mapmax - mapmin) / (2.0*128.0 - 1.0);
bzero = mapmin;
fit_setscale(bscale,bzero);
}
dprintf(1,"bscale,bzero=%g %g\n",bscale,bzero);
fitsfile = fitopen(name,"new",ndim,nx_out);
if (fitsfile==NULL) error("Could not open fitsfile %s for writing\n",name);
if (Qrefmap || Qcrpix) {
fitwrhdr(fitsfile,"CRPIX1",ref_crpix[0]);
fitwrhdr(fitsfile,"CRPIX2",ref_crpix[1]);
if (ndim>2) fitwrhdr(fitsfile,"CRPIX3",ref_crpix[2]);
} else {
if (axistype==1) {
fitwrhdr(fitsfile,"CRPIX1",xref[0]);
fitwrhdr(fitsfile,"CRPIX2",xref[1]);
if (ndim>2) fitwrhdr(fitsfile,"CRPIX3",xref[2]);
} else {
fitwrhdr(fitsfile,"CRPIX1",1.0); /* CRPIX = 1 by Nemo definition */
fitwrhdr(fitsfile,"CRPIX2",1.0);
if (ndim>2) fitwrhdr(fitsfile,"CRPIX3",1.0);
}
}
if (Qrefmap || Qcrval) {
fitwrhdr(fitsfile,"CRVAL1",ref_crval[0]);
fitwrhdr(fitsfile,"CRVAL2",ref_crval[1]);
if (ndim>2) fitwrhdr(fitsfile,"CRVAL3",ref_crval[2]);
} else {
fitwrhdr(fitsfile,"CRVAL1",xmin[p[0]]);
fitwrhdr(fitsfile,"CRVAL2",xmin[p[1]]);
if (ndim>2) fitwrhdr(fitsfile,"CRVAL3",xmin[p[2]]);
}
if (Qcdmatrix) {
fitwrhdr(fitsfile,"CD1_1",dx[p[0]]);
fitwrhdr(fitsfile,"CD2_2",dx[p[1]]);
if (ndim>2) fitwrhdr(fitsfile,"CD3_3",dx[p[2]]);
} else {
if (Qrefmap || Qcdelt) {
fitwrhdr(fitsfile,"CDELT1",ref_cdelt[0]*scale[0]);
fitwrhdr(fitsfile,"CDELT2",ref_cdelt[1]*scale[1]);
if (ndim>2) fitwrhdr(fitsfile,"CDELT3",ref_cdelt[2]*scale[2]);
} else {
fitwrhdr(fitsfile,"CDELT1",dx[p[0]]);
fitwrhdr(fitsfile,"CDELT2",dx[p[1]]);
if (ndim>2) fitwrhdr(fitsfile,"CDELT3",dx[p[2]]);
}
}
if (Qradecvel) {
dprintf(0,"[Axes names written as %s, %s, %s\n",
radeve[p[0]],radeve[p[1]],radeve[p[2]]);
fitwrhda(fitsfile,"CTYPE1",radeve[p[0]]);
fitwrhda(fitsfile,"CTYPE2",radeve[p[1]]);
if (ndim>2) fitwrhda(fitsfile,"CTYPE3",radeve[p[2]]);
} else {
if (Qrefmap) {
fitwrhda(fitsfile,"CTYPE1",ref_ctype[0]);
fitwrhda(fitsfile,"CTYPE2",ref_ctype[1]);
if (ndim>2) fitwrhda(fitsfile,"CTYPE3",ref_ctype[2]);
} else {
fitwrhda(fitsfile,"CTYPE1",axname[p[0]]);
fitwrhda(fitsfile,"CTYPE2",axname[p[1]]);
if (ndim>2) fitwrhda(fitsfile,"CTYPE3",axname[p[2]]);
}
}
fitwrhdr(fitsfile,"DATAMIN",mapmin);
fitwrhdr(fitsfile,"DATAMAX",mapmax);
fitwrhda(fitsfile,"ORIGIN",origin);
cp = getenv("USER"); /* AUTHOR */
if (cp)
fitwrhda(fitsfile,"AUTHOR",cp);
else
fitwrhda(fitsfile,"AUTHOR","NEMO");
if (object) /* OBJECT */
fitwrhda(fitsfile,"OBJECT",object);
if (comment) /* COMMENT */
stuffit(fitsfile,"COMMENT",comment);
if (headline)
stuffit(fitsfile,"COMMENT",headline);
hitem = ask_history(); /* HISTORY */
fitwra(fitsfile,"HISTORY","NEMO: History in reversed order");
for (i=0, cp=hitem[0]; cp != NULL; i++) {
stuffit(fitsfile,"HISTORY",cp);
cp = hitem[i+1];
}
for(i=0; i<nfill; i++) /* debugging header I/O */
fitwra(fitsfile,"COMMENT","Dummy filler space");
buffer = (float *) allocate(nx[p[0]]*sizeof(float));
for (k=0; k<nx_out[2]; k++) { /* loop over all planes */
fitsetpl(fitsfile,1,&k);
for (j=0; j<nx_out[1]; j++) { /* loop over all rows */
for (i=0, bp=buffer; i<nx_out[0]; i++, bp++)
*bp = iscale[0] * CubeValue(iptr,i,j,k) + iscale[1];
fitwrite(fitsfile,j,buffer);
}
}
free(buffer);
fitclose(fitsfile);
}
void nemo_main()
{
stream instr, outstr;
int i, n, naxis1, naxis2, naxis[2], moment;
double edges[2];
struct fits_header fh;
struct my_table_header r;
char *record, *cp, mesg[80];
string *hitem;
FITS *map;
/* Setup */
instr = stropen(getparam("in"),"r"); /* open input */
moment = getiparam("moment");
if (moment < 1 || moment > 2) error("moment must be 1 or 2");
band = getiparam("band");
if (band < 1 || band > 10) {
band = band_id(getdparam("band"));
if (band < 1) error("Invalid DIRBE band");
}
naxis[0] = nlon = getiparam("nlong");
naxis[1] = nlat = getiparam("nlat");
grid = (entryptr *) allocate(nlat*nlon*sizeof(entryptr));
for (i=0; i<nlat*nlon; i++)
grid[i] = NULL;
cp = getparam("coord");
switch (*cp) {
case 'g': gal_coord = TRUE; break;
case 'e': gal_coord = FALSE; break;
default: error("Bad coordinate system choosen; try gal or ecl");
}
if (nemoinpd(getparam("long"),edges,2) != 2) error("long= needs 2 values");
if (edges[0] <= edges[1]) error("long= needs left edge to be largest");
lonmin = edges[0];
lonmax = edges[1];
dlon = (lonmax-lonmin)/(float)nlon;
if (nemoinpd(getparam("lat"),edges,2) != 2) error("lat= needs 2 values");
if (edges[0] >= edges[1]) error("lat= needs right edge to be largest");
latmin = edges[0];
latmax = edges[1];
dlat = (latmax-latmin)/(float)nlat;
dprintf(1,"GridSize: %d * %d Pixels: %g * %g\n",nlon,nlat,dlon,dlat);
gc_middle = (lonmax < 0.0 && lonmin > 0.0); /* see if to use SYM_ANGLE */
ncell = getiparam("ncell");
sigma2 = 2*sqr(getdparam("sigma"));
/* Open output FITS file, and write a small yet descriptive enough header */
map = fitopen(getparam("out"),"new",2,naxis);
fitwrhda(map,"CTYPE1", gal_coord ? "GLON" : "ELON");
fitwrhdr(map,"CRPIX1",(float) 1.0); /* should use center */
fitwrhdr(map,"CRVAL1",(float) (lonmin + 0.5 * dlon));
fitwrhdr(map,"CDELT1",(float) dlon);
fitwrhda(map,"CTYPE2", gal_coord ? "GLAT" : "ELAT");
fitwrhdr(map,"CRPIX2",(float) 1.0); /* should use center */
fitwrhdr(map,"CRVAL2",(float) (latmin + 0.5 * dlat));
fitwrhdr(map,"CDELT2",(float) dlat);
fitwrhda(map,"TELESCOP","COBE");
fitwrhda(map,"INSTRUME","DIRBE");
fitwrhda(map,"ORIGIN","NEMO processing on CDAC data");
fitwrhda(map,"BUNIT","MJy/sr");
sprintf(mesg,"NEMO: %s VERSION=%s",getargv0(),getparam("VERSION"));
fitwra(map,"HISTORY", mesg);
hitem = ask_history();
fitwra(map,"HISTORY","NEMO: History in reversed order");
for (i=0, cp=hitem[0]; cp != NULL; i++) {
fitwral(map,"HISTORY",cp);
cp = hitem[i+1]; /* point to next history item */
}
/* Open input file, and process all rows */
fts_zero(&fh); /* clean out header */
n = fts_rhead(&fh,instr); /* read primary header */
if (n<0) error("Error reading primary HDU");
fts_sdata(&fh,instr); /* and skip data .. */
fts_zero(&fh); /* clean out header */
n = fts_rhead(&fh,instr); /* read primary header */
if (n<0) error("Error reading second HDU");
naxis1 = fh.naxisn[0]; /* size of one row */
naxis2 = fh.naxisn[1]; /* number of rows */
record = allocate(naxis1);
for (i=0; i<naxis2; i++) { /* loop reading rows */
n = fread(record,1,naxis1,instr);
if (n != naxis1) error("Early EOF on record %d",i+1);
stuffit(&fh,record,&r);
}
printf("Used %d/%d points in gridding\n",nused,naxis2);
/* map the data on a grid */
mapit(map,moment);
/* finish off */
fitclose(map);
strclose(instr);
}
