Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | RSS feed

  1. /*
  2.  * Copyright (c) 2001-2003, David Janssens
  3.  * Copyright (c) 2002-2003, Yannick Verschueren
  4.  * Copyright (c) 2003-2005, Francois Devaux and Antonin Descampe
  5.  * Copyright (c) 2005, Hervé Drolon, FreeImage Team
  6.  * Copyright (c) 2002-2005, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
  7.  * Copyright (c) 2006, Mónica Díez García, Image Processing Laboratory, University of Valladolid, Spain
  8.  * All rights reserved.
  9.  *
  10.  * Redistribution and use in source and binary forms, with or without
  11.  * modification, are permitted provided that the following conditions
  12.  * are met:
  13.  * 1. Redistributions of source code must retain the above copyright
  14.  *    notice, this list of conditions and the following disclaimer.
  15.  * 2. Redistributions in binary form must reproduce the above copyright
  16.  *    notice, this list of conditions and the following disclaimer in the
  17.  *    documentation and/or other materials provided with the distribution.
  18.  *
  19.  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
  20.  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  22.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  23.  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  24.  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  25.  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  26.  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  27.  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  28.  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  29.  * POSSIBILITY OF SUCH DAMAGE.
  30.  */
  31. #include <stdio.h>
  32. #include <stdlib.h>
  33. #include <string.h>
  34. #include "../libjp3dvm/openjpeg3d.h"
  35. #ifdef _WIN32
  36. #include "windirent.h"
  37. #else
  38. #include <dirent.h>
  39. #endif /* _WIN32 */
  40.  
  41.  
  42.  
  43. void dump_volume(FILE *fd, opj_volume_t * vol) {
  44.         int compno;
  45.         fprintf(fd, "volume {\n");
  46.         fprintf(fd, "  x0=%d, y0=%d, z0=%d, x1=%d, y1=%d, z1=%d\n", vol->x0, vol->y0, vol->z0,vol->x1, vol->y1,  vol->z1);
  47.         fprintf(fd, "  numcomps=%d\n", vol->numcomps);
  48.         for (compno = 0; compno < vol->numcomps; compno++) {
  49.                 opj_volume_comp_t *comp = &vol->comps[compno];
  50.                 fprintf(fd, "  comp %d {\n", compno);
  51.                 fprintf(fd, "    dx=%d, dy=%d, dz=%d\n", comp->dx, comp->dy, comp->dz);
  52.                 fprintf(fd, "    prec=%d\n", comp->prec);
  53.                 fprintf(fd, "    sgnd=%d\n", comp->sgnd);
  54.                 fprintf(fd, "  }\n");
  55.         }
  56.         fprintf(fd, "}\n");
  57. }
  58.  
  59. /*
  60.  * Get logarithm of an integer and round downwards.
  61.  *
  62.  * log2(a)
  63.  */
  64. static int int_floorlog2(int a) {
  65.         int l;
  66.         for (l = 0; a > 1; l++) {
  67.                 a >>= 1;
  68.         }
  69.         return l;
  70. }
  71.  
  72. /*
  73.  * Divide an integer by a power of 2 and round upwards.
  74.  *
  75.  * a divided by 2^b
  76.  */
  77. static int int_ceildivpow2(int a, int b) {
  78.         return (a + (1 << b) - 1) >> b;
  79. }
  80.  
  81. /*
  82.  * Divide an integer and round upwards.
  83.  *
  84.  * a divided by b
  85.  */
  86. static int int_ceildiv(int a, int b) {
  87.         return (a + b - 1) / b;
  88. }
  89.  
  90.  
  91. /* -->> -->> -->> -->>
  92.  
  93. PGX IMAGE FORMAT
  94.  
  95. <<-- <<-- <<-- <<-- */
  96.  
  97.  
  98. unsigned char readuchar(FILE * f)
  99. {
  100.   unsigned char c1;
  101.   fread(&c1, 1, 1, f);
  102.   return c1;
  103. }
  104.  
  105. unsigned short readushort(FILE * f, int bigendian)
  106. {
  107.   unsigned char c1, c2;
  108.   fread(&c1, 1, 1, f);
  109.   fread(&c2, 1, 1, f);
  110.   if (bigendian)
  111.     return (c1 << 8) + c2;
  112.   else
  113.     return (c2 << 8) + c1;
  114. }
  115.  
  116. unsigned int readuint(FILE * f, int bigendian)
  117. {
  118.   unsigned char c1, c2, c3, c4;
  119.   fread(&c1, 1, 1, f);
  120.   fread(&c2, 1, 1, f);
  121.   fread(&c3, 1, 1, f);
  122.   fread(&c4, 1, 1, f);
  123.   if (bigendian)
  124.     return (c1 << 24) + (c2 << 16) + (c3 << 8) + c4;
  125.   else
  126.     return (c4 << 24) + (c3 << 16) + (c2 << 8) + c1;
  127. }
  128. /*****************************************/
  129. static unsigned short ShortSwap(unsigned short v)
  130. {
  131.   unsigned char c1, c2;
  132.   c1 = v & 0xff;
  133.   c2 = (v >> 8) & 0xff;
  134.   return (c1 << 8) + c2;
  135. }
  136.  
  137. static unsigned int LongSwap (unsigned int i)
  138. {
  139.   unsigned char b1, b2, b3, b4;
  140.   b1 = i & 255;
  141.   b2 = ( i >> 8 ) & 255;
  142.   b3 = ( i>>16 ) & 255;
  143.   b4 = ( i>>24 ) & 255;
  144.   return ((int)b1 << 24) + ((int)b2 << 16) + ((int)b3 << 8) + b4;
  145. }
  146. /*****************************************/
  147.  
  148. opj_volume_t* pgxtovolume(char *relpath, opj_cparameters_t *parameters) {
  149.        
  150.         FILE *f = NULL;
  151.         int w, h, prec;
  152.         unsigned long offset;
  153.         int i, s, numcomps, maxvalue, sliceno, slicepos, maxslice = 0;
  154.        
  155.         OPJ_COLOR_SPACE color_space;
  156.         opj_volume_cmptparm_t cmptparm; // maximum of 1 component
  157.         opj_volume_t * volume = NULL;
  158.  
  159.         char endian1,endian2,sign;
  160.         char signtmp[32];
  161.         char temp[32];
  162.         opj_volume_comp_t *comp = NULL;
  163.  
  164.                 DIR *dirp;
  165.     struct dirent *direntp;
  166.        
  167.         char *tmp = NULL, *tmp2 = NULL,
  168.                 *point = NULL, *pgx = NULL;
  169.         char tmpdirpath[MAX_PATH];
  170.         char dirpath[MAX_PATH];
  171.         char pattern[MAX_PATH];
  172.         char pgxfiles[MAX_SLICES][MAX_PATH];
  173.         int pgxslicepos[MAX_SLICES];
  174.         char tmpno[3];
  175.        
  176.         numcomps = 1;
  177.         color_space = CLRSPC_GRAY;
  178.         sliceno = 0;
  179.         maxvalue = 0;
  180.         memset(pgxfiles, 0, MAX_SLICES * MAX_PATH * sizeof(char));
  181.         memset(&cmptparm, 0, sizeof(opj_volume_cmptparm_t));
  182.        
  183.         /* Separación del caso de un único slice frente al de muchos */
  184.         if ((tmp = strrchr(relpath,'-')) == NULL){
  185.                 //fprintf(stdout,"[INFO] A volume of only one slice....\n");
  186.                 sliceno = 1;
  187.                 maxslice = 1;
  188.                 strcpy(pgxfiles[0],relpath);
  189.        
  190.         } else {
  191.                 //Fetch only the path
  192.                 strcpy(tmpdirpath,relpath);
  193.                 if ((tmp = strrchr(tmpdirpath,'/')) != NULL){
  194.                         tmp++; *tmp='\0';
  195.                         strcpy(dirpath,tmpdirpath);
  196.                 } else {
  197.                         strcpy(dirpath,"./");
  198.                 }
  199.  
  200.                 //Fetch the pattern of the volume slices
  201.                 if ((tmp = strrchr (relpath,'/')) != NULL)
  202.                         tmp++; 
  203.                 else
  204.                         tmp = relpath;
  205.         if ((tmp2 = strrchr(tmp,'-')) != NULL)
  206.             *tmp2='\0';
  207.                 else{
  208.                         fprintf(stdout, "[ERROR] tmp2 ha dado null. no ha encontrado el * %s %s",tmp,relpath);
  209.                         return NULL;
  210.                 }
  211.         strcpy(pattern,tmp);
  212.  
  213.                 dirp = opendir( dirpath );
  214.                 if (dirp == NULL){
  215.                         fprintf(stdout, "[ERROR] Infile must be a .pgx file or a directory that contain pgx files");
  216.                         return NULL;
  217.                 }
  218.  
  219.                 /*Read all .pgx files of directory */
  220.                 while ( (direntp = readdir( dirp )) != NULL )
  221.                 {
  222.                         /* Found a directory, but ignore . and .. */
  223.                         if(strcmp(".",direntp->d_name) == 0 || strcmp("..",direntp->d_name) == 0)
  224.                                         continue;
  225.                        
  226.                         if( ((pgx = strstr(direntp->d_name,pattern)) != NULL) && ((tmp2 = strstr(direntp->d_name,".pgx")) != NULL) ){
  227.                        
  228.                                 strcpy(tmp,dirpath);
  229.                                 tmp = strcat(tmp,direntp->d_name);
  230.                                                
  231.                                 //Obtenemos el index de la secuencia de slices
  232.                                 if ((tmp2 = strpbrk (direntp->d_name, "0123456789")) == NULL)
  233.                                         continue;
  234.                                 i = 0;
  235.                                 while (tmp2 != NULL) {                                 
  236.                                         tmpno[i++] = *tmp2;
  237.                                         point = tmp2;
  238.                                         tmp2 = strpbrk (tmp2+1,"0123456789");
  239.                                 }tmpno[i]='\0';
  240.  
  241.                                 //Comprobamos que no estamos leyendo algo raro como pattern.jp3d
  242.                                 if ((point = strpbrk (point,".")) == NULL){
  243.                                         break;
  244.                                 }
  245.                                 //Slicepos --> index de slice; Sliceno --> no de slices hasta el momento
  246.                                 slicepos = atoi(tmpno);
  247.                                 pgxslicepos[sliceno] = slicepos - 1;
  248.                                 sliceno++;
  249.                                 if (slicepos>maxslice)
  250.                                         maxslice = slicepos;
  251.                                
  252.                                 //Colocamos el slices en su posicion correspondiente
  253.                                 strcpy(pgxfiles[slicepos-1],tmp);
  254.                         }
  255.                 }
  256.        
  257.         }/* else if pattern*.pgx */
  258.  
  259.         if (!sliceno) {
  260.                 fprintf(stdout,"[ERROR] No slices with this pattern founded !! Please check input volume name\n");
  261.                 return NULL;
  262.         }
  263.         /*if ( maxslice != sliceno) {
  264.                 fprintf(stdout,"[ERROR] Slices are not sequentially numbered !! Please rename them accordingly\n");
  265.                 return NULL;
  266.         }*/
  267.        
  268.         for (s=0;s<sliceno;s++)
  269.         {
  270.                         int pos = maxslice == sliceno ? s: pgxslicepos[s];
  271.                         f = fopen(pgxfiles[pos], "rb");
  272.                         if (!f) {
  273.                                 fprintf(stdout, "[ERROR] Failed to open %s for reading !\n", pgxfiles[s]);
  274.                                 return NULL;
  275.                         }
  276.                         fprintf(stdout, "[INFO] Loading %s \n",pgxfiles[pos]);
  277.  
  278.                         fseek(f, 0, SEEK_SET);
  279.                         fscanf(f, "PG%[ \t]%c%c%[ \t+-]%d%[ \t]%d%[ \t]%d",temp,&endian1,&endian2,signtmp,&prec,temp,&w,temp,&h);
  280.  
  281.                         i=0;
  282.                         sign='+';              
  283.                         while (signtmp[i]!='\0') {
  284.                                 if (signtmp[i]=='-') sign='-';
  285.                                 i++;
  286.                         }
  287.                
  288.                         fgetc(f);
  289.                         if (endian1=='M' && endian2=='L') {
  290.                                 cmptparm.bigendian = 1;
  291.                         } else if (endian2=='M' && endian1=='L') {
  292.                                 cmptparm.bigendian = 0;
  293.                         } else {
  294.                                 fprintf(stdout, "[ERROR] Bad pgx header, please check input file\n");
  295.                                 return NULL;
  296.                         }
  297.  
  298.                         if (s==0){
  299.                                 /* initialize volume component */
  300.  
  301.                                 cmptparm.x0 = parameters->volume_offset_x0;
  302.                                 cmptparm.y0 = parameters->volume_offset_y0;
  303.                                 cmptparm.z0 = parameters->volume_offset_z0;
  304.                                 cmptparm.w = !cmptparm.x0 ? (w - 1) * parameters->subsampling_dx + 1 : cmptparm.x0 + (w - 1) * parameters->subsampling_dx + 1;
  305.                                 cmptparm.h = !cmptparm.y0 ? (h - 1) * parameters->subsampling_dy + 1 : cmptparm.y0 + (h - 1) * parameters->subsampling_dy + 1;
  306.                                 cmptparm.l = !cmptparm.z0 ? (sliceno - 1) * parameters->subsampling_dz + 1 : cmptparm.z0 + (sliceno - 1) * parameters->subsampling_dz + 1;
  307.                                
  308.                                 if (sign == '-') {
  309.                                         cmptparm.sgnd = 1;
  310.                                 } else {
  311.                                         cmptparm.sgnd = 0;
  312.                                 }
  313.                                 cmptparm.prec = prec;
  314.                                 cmptparm.bpp = prec;
  315.                                 cmptparm.dcoffset = parameters->dcoffset;
  316.                                 cmptparm.dx = parameters->subsampling_dx;
  317.                                 cmptparm.dy = parameters->subsampling_dy;
  318.                                 cmptparm.dz = parameters->subsampling_dz;
  319.                                
  320.                                 /* create the volume */
  321.                                 volume = opj_volume_create(numcomps, &cmptparm, color_space);
  322.                                 if(!volume) {
  323.                                         fclose(f);
  324.                                         return NULL;
  325.                                 }
  326.                                 /* set volume offset and reference grid */
  327.                                 volume->x0 = cmptparm.x0;
  328.                                 volume->y0 = cmptparm.y0;
  329.                                 volume->z0 = cmptparm.z0;
  330.                                 volume->x1 = cmptparm.w;
  331.                                 volume->y1 = cmptparm.h;
  332.                                 volume->z1 = cmptparm.l;
  333.                                
  334.                                 /* set volume data :only one component, that is a volume*/
  335.                                 comp = &volume->comps[0];
  336.                        
  337.                         }//if sliceno==1
  338.                        
  339.                         offset = w * h * s;
  340.                        
  341.                         for (i = 0; i < w * h; i++) {
  342.                                 int v;
  343.                                 if (comp->prec <= 8) {
  344.                                         if (!comp->sgnd) {
  345.                                                 v = readuchar(f);
  346.                                         } else {
  347.                                                 v = (char) readuchar(f);
  348.                                         }
  349.                                 } else if (comp->prec <= 16) {
  350.                                         if (!comp->sgnd) {
  351.                                                 v = readushort(f, cmptparm.bigendian);
  352.                                         } else {
  353.                                                 v = (short) readushort(f, cmptparm.bigendian);
  354.                                         }
  355.                                 } else {
  356.                                         if (!comp->sgnd) {
  357.                                                 v = readuint(f, cmptparm.bigendian);
  358.                                         } else {
  359.                                                 v = (int) readuint(f, cmptparm.bigendian);
  360.                                         }
  361.                                 }                              
  362.                                 if (v > maxvalue)
  363.                                         maxvalue = v;
  364.                                 comp->data[i + offset] = v;
  365.                                
  366.                         }
  367.                         fclose(f);
  368.         } // for s --> sliceno
  369.         comp->bpp = int_floorlog2(maxvalue) + 1;
  370.         if (sliceno != 1)
  371.                 closedir( dirp );
  372.         //dump_volume(stdout, volume);
  373.         return volume;
  374. }
  375.  
  376.  
  377. int volumetopgx(opj_volume_t * volume, char *outfile) {
  378.         int w, wr, wrr, h, hr, hrr, l, lr, lrr;
  379.         int i, j, compno, offset, sliceno;
  380.         FILE *fdest = NULL;
  381.  
  382.         for (compno = 0; compno < volume->numcomps; compno++) {
  383.                 opj_volume_comp_t *comp = &volume->comps[compno];
  384.                 char name[256];
  385.                 int nbytes = 0;
  386.                 char *tmp = outfile;
  387.                 while (*tmp) {
  388.                         tmp++;
  389.                 }
  390.                 while (*tmp!='.') {
  391.                         tmp--;
  392.                 }
  393.                 *tmp='\0';
  394.                 for(sliceno = 0; sliceno < volume->z1 - volume->z0; sliceno++) {
  395.  
  396.                         if (volume->numcomps > 1) {
  397.                                 sprintf(name, "%s%d-%d.pgx", outfile, sliceno+1, compno);
  398.                         } else if ((volume->z1 - volume->z0) > 1) {
  399.                                 sprintf(name, "%s%d.pgx", outfile, sliceno+1);
  400.                         } else {
  401.                                 sprintf(name, "%s.pgx", outfile);
  402.                         }
  403.  
  404.                         fdest = fopen(name, "wb");
  405.                         if (!fdest) {
  406.                                 fprintf(stdout, "[ERROR] Failed to open %s for writing \n", name);
  407.                                 return 1;
  408.                         }
  409.  
  410.                         fprintf(stdout,"[INFO] Writing in %s (%s)\n",name,volume->comps[0].bigendian ? "Bigendian" : "Little-endian");
  411.  
  412.                         w = int_ceildiv(volume->x1 - volume->x0, volume->comps[compno].dx);
  413.                         wr = volume->comps[compno].w;
  414.                         wrr = int_ceildivpow2(volume->comps[compno].w, volume->comps[compno].factor[0]);
  415.                        
  416.                         h = int_ceildiv(volume->y1 - volume->y0, volume->comps[compno].dy);
  417.                         hr = volume->comps[compno].h;
  418.                         hrr = int_ceildivpow2(volume->comps[compno].h, volume->comps[compno].factor[1]);
  419.                        
  420.                         l = int_ceildiv(volume->z1 - volume->z0, volume->comps[compno].dz);
  421.                         lr = volume->comps[compno].l;
  422.                         lrr = int_ceildivpow2(volume->comps[compno].l, volume->comps[compno].factor[2]);
  423.  
  424.                         fprintf(fdest, "PG %c%c %c%d %d %d\n", comp->bigendian ? 'M':'L', comp->bigendian ? 'L':'M',comp->sgnd ? '-' : '+', comp->prec, wr, hr);
  425.                         if (comp->prec <= 8) {
  426.                                 nbytes = 1;
  427.                         } else if (comp->prec <= 16) {
  428.                                 nbytes = 2;
  429.                         } else {
  430.                                 nbytes = 4;
  431.                         }
  432.  
  433.                         offset = (sliceno / lrr * l) + (sliceno % lrr);
  434.                         offset = wrr * hrr * offset;
  435.                         //fprintf(stdout,"%d %d %d %d\n",offset,wrr*hrr,wrr,w);
  436.                         for (i = 0; i < wrr * hrr; i++) {
  437.                                 int v = volume->comps[0].data[(i / wrr * w) + (i % wrr) + offset];
  438.                                 if (volume->comps[0].bigendian) {
  439.                                         for (j = nbytes - 1; j >= 0; j--) {
  440.                         char byte = (char) ((v >> (j * 8)) & 0xff);
  441.                         fwrite(&byte, 1, 1, fdest);
  442.                                         }
  443.                                 } else {
  444.                                         for (j = 0; j <= nbytes - 1; j++) {
  445.                         char byte = (char) ((v >> (j * 8)) & 0xff);
  446.                                                 fwrite(&byte, 1, 1, fdest);
  447.                                         }
  448.                                 }
  449.                         }
  450.  
  451.                         fclose(fdest);
  452.                 }//for sliceno
  453.         }//for compno
  454.  
  455.         return 0;
  456. }
  457.  
  458. /* -->> -->> -->> -->>
  459.  
  460. BIN IMAGE FORMAT
  461.  
  462. <<-- <<-- <<-- <<-- */
  463.  
  464. opj_volume_t* bintovolume(char *filename, char *fileimg, opj_cparameters_t *parameters) {
  465.         int subsampling_dx =  parameters->subsampling_dx;
  466.         int subsampling_dy =  parameters->subsampling_dy;
  467.         int subsampling_dz =  parameters->subsampling_dz;
  468.        
  469.         int i, compno, w, h, l, numcomps = 1;
  470.         int prec, max = 0;
  471.  
  472. //      char temp[32];
  473.         char line[100];
  474.         int bigendian;
  475.        
  476.         FILE *f = NULL;
  477.         FILE *fimg = NULL;
  478.         OPJ_COLOR_SPACE color_space;
  479.         opj_volume_cmptparm_t cmptparm; /* maximum of 1 component */
  480.         opj_volume_t * volume = NULL;
  481.         opj_volume_comp_t *comp = NULL;
  482.  
  483.         bigendian = 0;
  484.         color_space = CLRSPC_GRAY;
  485.  
  486.         fimg = fopen(fileimg,"r");
  487.         if (!fimg) {
  488.                 fprintf(stdout, "[ERROR] Failed to open %s for reading !!\n", fileimg);
  489.                 return 0;
  490.         }
  491.  
  492.         fseek(fimg, 0, SEEK_SET);
  493.         while (!feof(fimg)) {
  494.         fgets(line,100,fimg);
  495.                 //fprintf(stdout,"%s %d \n",line,feof(fimg));
  496.                 if (strncmp(line,"Bpp",3) == 0){
  497.                         sscanf(line,"%*s%*[ \t]%d",&prec);
  498.                 } else if (strncmp(line,"Color",5) == 0){
  499.                         sscanf(line, "%*s%*[ \t]%d",&color_space);
  500.                 } else if (strncmp(line,"Dim",3) == 0){
  501.                         sscanf(line, "%*s%*[ \t]%d%*[ \t]%d%*[ \t]%d",&w,&h,&l);
  502.                 }
  503.         }
  504.         //fscanf(fimg, "Bpp%[ \t]%d%[ \t\n]",temp,&prec,temp);
  505.         //fscanf(fimg, "Color Map%[ \t]%d%[ \n\t]Dimensions%[ \t]%d%[ \t]%d%[ \t]%d%[ \n\t]",temp,&color_space,temp,temp,&w,temp,&h,temp,&l,temp);
  506.         //fscanf(fimg, "Resolution(mm)%[ \t]%d%[ \t]%d%[ \t]%d%[ \n\t]",temp,&subsampling_dx,temp,&subsampling_dy,temp,&subsampling_dz,temp);
  507.  
  508.         #ifdef VERBOSE
  509.                 fprintf(stdout, "[INFO] %d \t %d %d %d \t %3.2f %2.2f %2.2f \t %d \n",color_space,w,h,l,subsampling_dx,subsampling_dy,subsampling_dz,prec);
  510.         #endif
  511.         fclose(fimg);
  512.        
  513.         /* initialize volume components */
  514.         memset(&cmptparm, 0, sizeof(opj_volume_cmptparm_t));
  515.        
  516.         cmptparm.prec = prec;
  517.         cmptparm.bpp = prec;
  518.         cmptparm.sgnd = 0;
  519.         cmptparm.bigendian = bigendian;
  520.         cmptparm.dcoffset = parameters->dcoffset;
  521.         cmptparm.dx = subsampling_dx;
  522.         cmptparm.dy = subsampling_dy;
  523.         cmptparm.dz = subsampling_dz;
  524.         cmptparm.w = w;
  525.         cmptparm.h = h;
  526.         cmptparm.l = l;
  527.        
  528.         /* create the volume */
  529.         volume = opj_volume_create(numcomps, &cmptparm, color_space);
  530.         if(!volume) {
  531.                 fprintf(stdout,"[ERROR] Unable to create volume");     
  532.                 fclose(f);
  533.                 return NULL;
  534.         }
  535.        
  536.         /* set volume offset and reference grid */
  537.         volume->x0 = parameters->volume_offset_x0;
  538.         volume->y0 = parameters->volume_offset_y0;
  539.         volume->z0 = parameters->volume_offset_z0;
  540.         volume->x1 = parameters->volume_offset_x0 + (w - 1) *   subsampling_dx + 1;
  541.         volume->y1 = parameters->volume_offset_y0 + (h - 1) *   subsampling_dy + 1;
  542.         volume->z1 = parameters->volume_offset_z0 + (l - 1) *   subsampling_dz + 1;
  543.        
  544.         /* set volume data */
  545.         f = fopen(filename, "rb");
  546.         if (!f) {
  547.                 fprintf(stdout, "[ERROR] Failed to open %s for reading !!\n", filename);
  548.                 return 0;
  549.         }
  550.        
  551.         /* BINARY */
  552.         for (compno = 0; compno < volume->numcomps; compno++) {
  553.                 int whl = w * h * l;
  554.                 /* set volume data */
  555.                 comp = &volume->comps[compno];
  556.                
  557.                 /*if (comp->prec <= 8) {
  558.                         if (!comp->sgnd) {
  559.                 unsigned char *data = (unsigned char *) malloc(whl * sizeof(unsigned char));
  560.                                 fread(data, 1, whl, f);
  561.                                 for (i = 0; i < whl; i++) {
  562.                                         comp->data[i] = data[i];
  563.                                         if (comp->data[i] > max)
  564.                                                 max = comp->data[i];
  565.                                 }
  566.                                 free(data);
  567.                         } else {
  568.                                 char *data = (char *) malloc(whl);
  569.                                 fread(data, 1, whl, f);
  570.                                 for (i = 0; i < whl; i++) {
  571.                                         comp->data[i] = data[i];
  572.                                         if (comp->data[i] > max)
  573.                                                 max = comp->data[i];
  574.                                 }
  575.                                 free(data);
  576.                         }
  577.                 } else if (comp->prec <= 16) {
  578.                         if (!comp->sgnd) {
  579.                 unsigned short *data = (unsigned short *) malloc(whl * sizeof(unsigned short));
  580.                                 int leido = fread(data, 2, whl, f);
  581.                                 if (!leido)     {
  582.                                         free(data);     fclose(f);
  583.                                         return NULL;
  584.                                 }
  585.                                
  586.                                 for (i = 0; i < whl; i++) {
  587.                                         if (bigendian)  //(c1 << 8) + c2;
  588.                                                 comp->data[i] = data[i];
  589.                                         else{                   //(c2 << 8) + c1;
  590.                                                 comp->data[i] = ShortSwap(data[i]);
  591.                                         }
  592.                                         if (comp->data[i] > max)
  593.                                                 max = comp->data[i];
  594.                                 }
  595.                                 free(data);
  596.                         } else {
  597.                                 short *data = (short *) malloc(whl);
  598.                                 int leido = fread(data, 2, whl, f);
  599.                                 if (!leido)     {
  600.                                         free(data);     fclose(f);
  601.                                         return NULL;
  602.                                 }
  603.                                 for (i = 0; i < whl; i++) {
  604.                                         if (bigendian){ //(c1 << 8) + c2;
  605.                                                 comp->data[i] = data[i];
  606.                                         }else{                  //(c2 << 8) + c1;
  607.                                                 comp->data[i] = (short) ShortSwap((unsigned short) data[i]);
  608.                                         }
  609.                                         if (comp->data[i] > max)
  610.                                                 max = comp->data[i];
  611.                                 }
  612.                                 free(data);
  613.                         }
  614.                 } else {
  615.                         if (!comp->sgnd) {
  616.                 unsigned int *data = (unsigned int *) malloc(whl * sizeof(unsigned int));
  617.                                 int leido = fread(data, 4, whl, f);
  618.                                 if (!leido)     {
  619.                                         free(data);     fclose(f);
  620.                                         return NULL;
  621.                                 }                               for (i = 0; i < whl; i++) {
  622.                                         if (!bigendian)
  623.                                                 comp->data[i] = LongSwap(data[i]);
  624.                                         else
  625.                                                 comp->data[i] = data[i];
  626.                                         if (comp->data[i] > max)
  627.                                                 max = comp->data[i];
  628.                                 }
  629.                                 free(data);
  630.                         } else {
  631.                                 int leido = fread(comp->data, 4, whl, f);
  632.                                 if (!leido)     {
  633.                                         fclose(f);
  634.                                         return NULL;
  635.                                 }                              
  636.                                 for (i = 0; i < whl; i++) {
  637.                                         if (!bigendian)
  638.                                                 comp->data[i] = (int) LongSwap((unsigned int) comp->data[i]);
  639.                                         if (comp->data[i] > max)
  640.                                                 max = comp->data[i];
  641.                                 }
  642.                         }
  643.                 }*/
  644.                
  645.                 for (i = 0; i < whl; i++) {
  646.                         int v;
  647.                         if (comp->prec <= 8) {
  648.                                 if (!comp->sgnd) {
  649.                                         v = readuchar(f);
  650.                                 } else {
  651.                                         v = (char) readuchar(f);
  652.                                 }
  653.                         } else if (comp->prec <= 16) {
  654.                                 if (!comp->sgnd) {
  655.                                         v = readushort(f, bigendian);
  656.                                 } else {
  657.                                         v = (short) readushort(f, bigendian);
  658.                                 }
  659.                         } else {
  660.                                 if (!comp->sgnd) {
  661.                                         v = readuint(f, bigendian);
  662.                                 } else {
  663.                                         v = (int) readuint(f, bigendian);
  664.                                 }
  665.                         }
  666.                         if (v > max)
  667.                                 max = v;
  668.                         comp->data[i] = v;
  669.                 }
  670.                 comp->bpp = int_floorlog2(max) + 1;
  671.         }
  672.         fclose(f);
  673.         return volume;
  674. }
  675.  
  676. int volumetobin(opj_volume_t * volume, char *outfile) {
  677.         int w, wr, wrr, h, hr, hrr, l, lr, lrr, max;
  678.         int i,j, compno, nbytes;
  679.         int offset, sliceno;
  680.         FILE *fdest = NULL;
  681.         FILE *fimgdest = NULL;
  682. //      char *imgtemp;
  683.         char name[256];
  684.  
  685.         for (compno = 0; compno < 1; compno++) { //Only one component
  686.                
  687.                 fdest = fopen(outfile, "wb");
  688.                 if (!fdest) {
  689.                         fprintf(stdout, "[ERROR] Failed to open %s for writing\n", outfile);
  690.                         return 1;
  691.                 }
  692.         fprintf(stdout,"[INFO] Writing outfile %s (%s) \n",outfile, volume->comps[0].bigendian ? "Bigendian" : "Little-endian");
  693.  
  694.                 w = int_ceildiv(volume->x1 - volume->x0, volume->comps[compno].dx);
  695.                 wr = volume->comps[compno].w;
  696.                 wrr = int_ceildivpow2(volume->comps[compno].w, volume->comps[compno].factor[0]);
  697.                
  698.                 h = int_ceildiv(volume->y1 - volume->y0, volume->comps[compno].dy);
  699.                 hr = volume->comps[compno].h;
  700.                 hrr = int_ceildivpow2(volume->comps[compno].h, volume->comps[compno].factor[1]);
  701.                
  702.                 l = int_ceildiv(volume->z1 - volume->z0, volume->comps[compno].dz);
  703.                 lr = volume->comps[compno].l;
  704.                 lrr = int_ceildivpow2(volume->comps[compno].l, volume->comps[compno].factor[2]);
  705.  
  706.                 max = (volume->comps[compno].prec <= 8) ? 255 : (1 << volume->comps[compno].prec) - 1;
  707.                
  708.                 volume->comps[compno].x0 = int_ceildivpow2(volume->comps[compno].x0 - int_ceildiv(volume->x0, volume->comps[compno].dx), volume->comps[compno].factor[0]);
  709.                 volume->comps[compno].y0 = int_ceildivpow2(volume->comps[compno].y0 - int_ceildiv(volume->y0, volume->comps[compno].dy), volume->comps[compno].factor[1]);
  710.                 volume->comps[compno].z0 = int_ceildivpow2(volume->comps[compno].z0 - int_ceildiv(volume->z0, volume->comps[compno].dz), volume->comps[compno].factor[2]);
  711.                
  712.                 if (volume->comps[0].prec <= 8) {
  713.                         nbytes = 1;
  714.                 } else if (volume->comps[0].prec <= 16) {
  715.                         nbytes = 2;
  716.                 } else {
  717.                         nbytes = 4;
  718.                 }
  719.  
  720.                 //fprintf(stdout,"w %d wr %d wrr %d h %d hr %d hrr %d l %d lr %d lrr %d max %d nbytes %d\n Factor %d %d %d",w,wr,wrr,h,hr,hrr,l,lr,lrr,max,nbytes,volume->comps[compno].factor[0],volume->comps[compno].factor[1],volume->comps[compno].factor[2]);
  721.  
  722.                 for(sliceno = 0; sliceno < lrr; sliceno++) {
  723.                         offset = (sliceno / lrr * l) + (sliceno % lrr);
  724.             offset = wrr * hrr * offset;
  725.                         for (i = 0; i < wrr * hrr; i++) {
  726.                                 int v = volume->comps[0].data[(i / wrr * w) + (i % wrr) + offset];
  727.                                 if (volume->comps[0].bigendian) {
  728.                                         for (j = nbytes - 1; j >= 0; j--) {
  729.                         char byte = (char) ((v >> (j * 8)) & 0xff);
  730.                         fwrite(&byte, 1, 1, fdest);
  731.                                         }
  732.                                 } else {
  733.                                         for (j = 0; j <= nbytes - 1; j++) {
  734.                         char byte = (char) ((v >> (j * 8)) & 0xff);
  735.                                                 fwrite(&byte, 1, 1, fdest);
  736.                                         }
  737.                                 }
  738.                         }
  739.                 }
  740.        
  741.         }
  742.        
  743.         fclose(fdest);
  744.  
  745.         sprintf(name,"%s.img",outfile);
  746.         fimgdest = fopen(name, "w");
  747.                 if (!fimgdest) {
  748.                         fprintf(stdout, "[ERROR] Failed to open %s for writing\n", name);
  749.                         return 1;
  750.                 }
  751.         fprintf(fimgdest, "Bpp\t%d\nColor Map\t2\nDimensions\t%d\t%d\t%d\nResolution(mm)\t%d\t%d\t%d\t\n",
  752.                 volume->comps[0].prec,wrr,hrr,lrr,volume->comps[0].dx,volume->comps[0].dy,volume->comps[0].dz);
  753.  
  754.         fclose(fimgdest);
  755.         return 0;
  756. }
  757. /* -->> -->> -->> -->>
  758.  
  759. IMG IMAGE FORMAT
  760.  
  761. <<-- <<-- <<-- <<-- */
  762. opj_volume_t* imgtovolume(char *fileimg, opj_cparameters_t *parameters) {
  763.         int subsampling_dx =  parameters->subsampling_dx;
  764.         int subsampling_dy =  parameters->subsampling_dy;
  765.         int subsampling_dz =  parameters->subsampling_dz;
  766.        
  767.         int i, compno, w, h, l, numcomps = 1;
  768.         int prec, max = 0, min = 0;
  769.         float dx, dy, dz;
  770.         char filename[100], tmpdirpath[100], dirpath[100], *tmp;
  771.         char line[100], datatype[100];
  772.         int bigendian;
  773.        
  774.         FILE *f = NULL;
  775.         FILE *fimg = NULL;
  776.         OPJ_COLOR_SPACE color_space;
  777.         opj_volume_cmptparm_t cmptparm; /* maximum of 1 component */
  778.         opj_volume_t * volume = NULL;
  779.         opj_volume_comp_t *comp = NULL;
  780.  
  781.         bigendian = 0;
  782.         color_space = CLRSPC_GRAY;
  783.  
  784.         fimg = fopen(fileimg,"r");
  785.         if (!fimg) {
  786.                 fprintf(stderr, "[ERROR] Failed to open %s for reading !!\n", fileimg);
  787.                 return 0;
  788.         }
  789.  
  790.         //Fetch only the path
  791.         strcpy(tmpdirpath,fileimg);
  792.         if ((tmp = strrchr(tmpdirpath,'/')) != NULL){
  793.                 tmp++; *tmp='\0';
  794.                 strcpy(dirpath,tmpdirpath);
  795.         } else {
  796.                 strcpy(dirpath,"./");
  797.         }
  798.  
  799.         fseek(fimg, 0, SEEK_SET);
  800.         while (!feof(fimg)) {
  801.         fgets(line,100,fimg);
  802.                 //fprintf(stdout,"%s %d \n",line,feof(fimg));
  803.                 if (strncmp(line,"Image",5) == 0){
  804.                         sscanf(line,"%*s%*[ \t]%s",datatype);
  805.                 } else if (strncmp(line,"File",4) == 0){
  806.                         sscanf(line,"%*s %*s%*[ \t]%s",filename);
  807.                         strcat(dirpath, filename);
  808.                         strcpy(filename,dirpath);
  809.                 } else if (strncmp(line,"Min",3) == 0){
  810.                         sscanf(line,"%*s %*s%*[ \t]%d%*[ \t]%d",&min,&max);
  811.                         prec = int_floorlog2(max - min + 1);
  812.                 } else if (strncmp(line,"Bpp",3) == 0){
  813.                         sscanf(line,"%*s%*[ \t]%d",&prec);
  814.                 } else if (strncmp(line,"Color",5) == 0){
  815.                         sscanf(line, "%*s %*s%*[ \t]%d",&color_space);
  816.                 } else if (strncmp(line,"Dim",3) == 0){
  817.                         sscanf(line, "%*s%*[ \t]%d%*[ \t]%d%*[ \t]%d",&w,&h,&l);
  818.                 } else if (strncmp(line,"Res",3) == 0){
  819.                         sscanf(line,"%*s%*[ \t]%f%*[ \t]%f%*[ \t]%f",&dx,&dy,&dz);
  820.                 }
  821.  
  822.         }
  823.         #ifdef VERBOSE
  824.                 fprintf(stdout, "[INFO] %s %d \t %d %d %d \t %f %f %f \t %d %d %d \n",filename,color_space,w,h,l,dx,dy,dz,max,min,prec);
  825.         #endif
  826.         fclose(fimg);
  827.  
  828.         /* error control */
  829.         if ( !prec || !w || !h || !l ){
  830.                 fprintf(stderr,"[ERROR] Unable to read IMG file correctly. Found some null values.");  
  831.                 return NULL;
  832.         }
  833.  
  834.         /* initialize volume components */
  835.         memset(&cmptparm, 0, sizeof(opj_volume_cmptparm_t));
  836.        
  837.         cmptparm.prec = prec;
  838.         cmptparm.bpp = prec;
  839.         cmptparm.sgnd = 0;
  840.         cmptparm.bigendian = bigendian;
  841.         cmptparm.dcoffset = parameters->dcoffset;
  842.         cmptparm.dx = subsampling_dx;
  843.         cmptparm.dy = subsampling_dy;
  844.         cmptparm.dz = subsampling_dz;
  845.         cmptparm.w = w;
  846.         cmptparm.h = h;
  847.         cmptparm.l = l;
  848.        
  849.         /* create the volume */
  850.         volume = opj_volume_create(numcomps, &cmptparm, color_space);
  851.         if(!volume) {
  852.                 fprintf(stdout,"[ERROR] Unable to create volume");     
  853.                 return NULL;
  854.         }
  855.        
  856.         /* set volume offset and reference grid */
  857.         volume->x0 = parameters->volume_offset_x0;
  858.         volume->y0 = parameters->volume_offset_y0;
  859.         volume->z0 = parameters->volume_offset_z0;
  860.         volume->x1 = parameters->volume_offset_x0 + (w - 1) *   subsampling_dx + 1;
  861.         volume->y1 = parameters->volume_offset_y0 + (h - 1) *   subsampling_dy + 1;
  862.         volume->z1 = parameters->volume_offset_z0 + (l - 1) *   subsampling_dz + 1;
  863.        
  864.         max = 0;
  865.         /* set volume data */
  866.         f = fopen(filename, "rb");
  867.         if (!f) {
  868.                 fprintf(stderr, "[ERROR] Failed to open %s for reading !!\n", filename);
  869.                 fclose(f);
  870.                 return 0;
  871.         }
  872.        
  873.         /* BINARY */
  874.         for (compno = 0; compno < volume->numcomps; compno++) {
  875.                 int whl = w * h * l;
  876.                 /* set volume data */
  877.                 comp = &volume->comps[compno];
  878.                
  879.                 /*if (comp->prec <= 8) {
  880.                         if (!comp->sgnd) {
  881.                 unsigned char *data = (unsigned char *) malloc(whl * sizeof(unsigned char));
  882.                                 fread(data, 1, whl, f);
  883.                                 for (i = 0; i < whl; i++) {
  884.                                         comp->data[i] = data[i];
  885.                                         if (comp->data[i] > max)
  886.                                                 max = comp->data[i];
  887.                                 }
  888.                                 free(data);
  889.                         } else {
  890.                                 char *data = (char *) malloc(whl);
  891.                                 fread(data, 1, whl, f);
  892.                                 for (i = 0; i < whl; i++) {
  893.                                         comp->data[i] = data[i];
  894.                                         if (comp->data[i] > max)
  895.                                                 max = comp->data[i];
  896.                                 }
  897.                                 free(data);
  898.                         }
  899.                 } else if (comp->prec <= 16) {
  900.                         if (!comp->sgnd) {
  901.                 unsigned short *data = (unsigned short *) malloc(whl * sizeof(unsigned short));
  902.                                 int leido = fread(data, 2, whl, f);
  903.                                 if (!leido)     {
  904.                                         free(data);     fclose(f);
  905.                                         return NULL;
  906.                                 }
  907.                                
  908.                                 for (i = 0; i < whl; i++) {
  909.                                         if (bigendian)  //(c1 << 8) + c2;
  910.                                                 comp->data[i] = data[i];
  911.                                         else{                   //(c2 << 8) + c1;
  912.                                                 comp->data[i] = ShortSwap(data[i]);
  913.                                         }
  914.                                         if (comp->data[i] > max)
  915.                                                 max = comp->data[i];
  916.                                 }
  917.                                 free(data);
  918.                         } else {
  919.                                 short *data = (short *) malloc(whl);
  920.                                 int leido = fread(data, 2, whl, f);
  921.                                 if (!leido)     {
  922.                                         free(data);     fclose(f);
  923.                                         return NULL;
  924.                                 }
  925.                                 for (i = 0; i < whl; i++) {
  926.                                         if (bigendian){ //(c1 << 8) + c2;
  927.                                                 comp->data[i] = data[i];
  928.                                         }else{                  //(c2 << 8) + c1;
  929.                                                 comp->data[i] = (short) ShortSwap((unsigned short) data[i]);
  930.                                         }
  931.                                         if (comp->data[i] > max)
  932.                                                 max = comp->data[i];
  933.                                 }
  934.                                 free(data);
  935.                         }
  936.                 } else {
  937.                         if (!comp->sgnd) {
  938.                 unsigned int *data = (unsigned int *) malloc(whl * sizeof(unsigned int));
  939.                                 int leido = fread(data, 4, whl, f);
  940.                                 if (!leido)     {
  941.                                         free(data);     fclose(f);
  942.                                         return NULL;
  943.                                 }                               for (i = 0; i < whl; i++) {
  944.                                         if (!bigendian)
  945.                                                 comp->data[i] = LongSwap(data[i]);
  946.                                         else
  947.                                                 comp->data[i] = data[i];
  948.                                         if (comp->data[i] > max)
  949.                                                 max = comp->data[i];
  950.                                 }
  951.                                 free(data);
  952.                         } else {
  953.                                 int leido = fread(comp->data, 4, whl, f);
  954.                                 if (!leido)     {
  955.                                         fclose(f);
  956.                                         return NULL;
  957.                                 }                              
  958.                                 for (i = 0; i < whl; i++) {
  959.                                         if (!bigendian)
  960.                                                 comp->data[i] = (int) LongSwap((unsigned int) comp->data[i]);
  961.                                         if (comp->data[i] > max)
  962.                                                 max = comp->data[i];
  963.                                 }
  964.                         }
  965.                 }*/
  966.                
  967.                 for (i = 0; i < whl; i++) {
  968.                         int v;
  969.                         if (comp->prec <= 8) {
  970.                                 if (!comp->sgnd) {
  971.                                         v = readuchar(f);
  972.                                 } else {
  973.                                         v = (char) readuchar(f);
  974.                                 }
  975.                         } else if (comp->prec <= 16) {
  976.                                 if (!comp->sgnd) {
  977.                                         v = readushort(f, bigendian);
  978.                                 } else {
  979.                                         v = (short) readushort(f, bigendian);
  980.                                 }
  981.                         } else {
  982.                                 if (!comp->sgnd) {
  983.                                         v = readuint(f, bigendian);
  984.                                 } else {
  985.                                         v = (int) readuint(f, bigendian);
  986.                                 }
  987.                         }
  988.                         if (v > max)
  989.                                 max = v;
  990.                         comp->data[i] = v;
  991.                 }
  992.                 comp->bpp = int_floorlog2(max) + 1;
  993.         }
  994.         fclose(f);
  995.         return volume;
  996. }
  997.  
  998.