Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members | Related Pages

FVR/Image_io.cpp

Go to the documentation of this file.
00001 #include "Image_io.h"
00002 #include <stdio.h>
00003 #include <string.h>
00004 #include <iostream.h>
00005 
00006 namespace FVR_NS
00007 {
00008 
00009 // complex pad n spaces
00010 static t_data* pad(t_data* v, dword n)
00011 {
00012         for (dword i = 0; i < n; ++i) {
00013                 *(v++) = 0.0f;
00014                 *(v++) = 0.0f;
00015         }
00016         return v;
00017 }
00018 
00019 // pad n spaces
00020 static byte* pad_r(byte* v, dword n)
00021 {
00022         for (dword i = 0; i < n; ++i) {
00023                 *(v++) = 0;
00024         }
00025         return v;
00026 }
00027 
00028 static dword readNumber(ifstream& fin)
00029 {
00030         dword n = 0;
00031         int c;
00032 
00033         c = fin.get();
00034         while((c!=' ') && (c!=10) && (c!=13))
00035         {
00036                 n = n*10 + ((dword)c-'0');
00037                 c = fin.get();
00038         }
00039         return n;
00040 }
00041 
00042 static void writeNumber(ofstream& fout, dword n)
00043 {
00044         char number[16];
00045 
00046         sprintf(number, "%ld", n);
00047         fout.write(number, strlen(number));
00048         fout.put(' ');
00049 }
00050 
00051 void read_raw(ifstream& fin, t_data* vol, dword X, dword Y, dword Z, dword XSize, dword YSize, dword ZSize, dword d_size)
00052 {
00053         if (!fin.is_open()) return;
00054 
00055         t_data* v_ptr = vol;
00056 
00057         dword lowX = (X - XSize) / 2;
00058         dword lowY = (Y - YSize) / 2;
00059         dword lowZ = (Z - ZSize) / 2;
00060 
00061         dword hiX = X - lowX - XSize;
00062         dword hiY = Y - lowY - YSize;
00063         dword hiZ = Z - lowZ - ZSize;
00064 
00065         v_ptr = pad(v_ptr, lowZ * X * Y);
00066         for (dword k = 0; k < ZSize; ++k) {
00067 
00068                 v_ptr = pad(v_ptr, lowY * X);
00069                 for (dword j = 0; j < YSize; ++j) {
00070 
00071                         v_ptr = pad(v_ptr, lowX);
00072                         for (dword i = 0; i < XSize; ++i) {
00073 
00074                                 // convert d_size bytes to floating point
00075                                 t_data tmp = 0.0f;
00076                                 for (dword d = 0; d < d_size; ++d) {
00077                                         tmp *= 256.0f;
00078                                         int c = fin.get();
00079                                         if (c < 0) cerr << "huh??\n";
00080                                         tmp += (t_data) c;
00081                                 }
00082                                 *(v_ptr++) = tmp;
00083                                 *(v_ptr++) = 0.0f;
00084 
00085                         }
00086                         v_ptr = pad(v_ptr, hiX);
00087 
00088                 }
00089                 v_ptr = pad(v_ptr, hiY * X);
00090 
00091         }
00092         v_ptr = pad(v_ptr, hiZ * X * Y);
00093 }
00094 
00095 void read_raw(byte *data, float* vol, dword X, dword Y, dword Z, 
00096               dword XSize, dword YSize, dword ZSize, dword d_size)
00097 {
00098   if (!data) return;
00099 
00100   float* v_ptr = vol;
00101 
00102   dword lowX = (X - XSize) / 2;
00103   dword lowY = (Y - YSize) / 2;
00104   dword lowZ = (Z - ZSize) / 2;
00105 
00106   dword hiX = X - lowX - XSize;
00107   dword hiY = Y - lowY - YSize;
00108   dword hiZ = Z - lowZ - ZSize;
00109 
00110   v_ptr = pad(v_ptr, lowZ * X * Y);
00111   for (dword k = 0; k < ZSize; ++k) {
00112 
00113     v_ptr = pad(v_ptr, lowY * X);
00114     for (dword j = 0; j < YSize; ++j) {
00115 
00116       v_ptr = pad(v_ptr, lowX);
00117       for (dword i = 0; i < XSize; ++i) {
00118 
00119         // convert d_size bytes to floating point
00120         float tmp = 0.0f;
00121         for (dword d = 0; d < d_size; ++d) {
00122           tmp *= 256.0f;
00123           byte c = *(data++);
00124           tmp += (float) c;
00125         }
00126         *(v_ptr++) = tmp;
00127         *(v_ptr++) = 0.0f;
00128 
00129       }
00130       v_ptr = pad(v_ptr, hiX);
00131 
00132     }
00133     v_ptr = pad(v_ptr, hiY * X);
00134 
00135   }
00136   v_ptr = pad(v_ptr, hiZ * X * Y);
00137 }
00138 
00139 void read_raw_r(ifstream& fin, byte* vol, dword X, dword Y, dword Z, dword XSize, dword YSize, dword ZSize, dword d_size)
00140 {
00141         if (!fin.is_open()) return;
00142 
00143         byte* v_ptr = vol;
00144 
00145         dword lowX = (X - XSize) / 2;
00146         dword lowY = (Y - YSize) / 2;
00147         dword lowZ = (Z - ZSize) / 2;
00148 
00149         dword hiX = X - lowX - XSize;
00150         dword hiY = Y - lowY - YSize;
00151         dword hiZ = Z - lowZ - ZSize;
00152 
00153         v_ptr = pad_r(v_ptr, lowZ * X * Y * d_size);
00154         for (dword k = 0; k < ZSize; ++k) {
00155 
00156                 v_ptr = pad_r(v_ptr, lowY * X * d_size);
00157                 for (dword j = 0; j < YSize; ++j) {
00158 
00159                         v_ptr = pad_r(v_ptr, lowX * d_size);
00160                         for (dword i = 0; i < XSize; ++i) {
00161 
00162                                 for (dword d = 0; d < d_size; ++d) {
00163                                         int c = fin.get();
00164                                         if (c < 0) cerr << "huh??\n";
00165                                         *(v_ptr++) = (byte) c;
00166                                 }
00167 
00168                         }
00169                         v_ptr = pad_r(v_ptr, hiX * d_size);
00170 
00171                 }
00172                 v_ptr = pad_r(v_ptr, hiY * X * d_size);
00173 
00174         }
00175         v_ptr = pad_r(v_ptr, hiZ * X * Y * d_size);
00176 }
00177 
00178 void read_raw_fast(ifstream& fin, byte* vol, dword X, dword Y, dword Z, dword XSize, dword YSize, dword ZSize, dword d_size)
00179 {
00180   if (!fin.is_open()) return;
00181 
00182   byte* v_ptr = vol;
00183 
00184   dword lowX = (X - XSize) / 2;
00185   dword lowY = (Y - YSize) / 2;
00186   dword lowZ = (Z - ZSize) / 2;
00187 
00188   dword hiX = X - lowX - XSize;
00189   dword hiY = Y - lowY - YSize;
00190   dword hiZ = Z - lowZ - ZSize;
00191 
00192   int  length;
00193   char *buffer;
00194 
00195   length = XSize*YSize*ZSize*d_size;
00196   buffer = new char[length];
00197 
00198   fin.read(buffer, length);
00199   
00200   dword idx = 0;
00201 
00202   v_ptr = pad_r(v_ptr, lowZ * X * Y * d_size);
00203   for (dword k = 0; k < ZSize; ++k) {
00204 
00205     v_ptr = pad_r(v_ptr, lowY * X * d_size);
00206     for (dword j = 0; j < YSize; ++j) {
00207 
00208       v_ptr = pad_r(v_ptr, lowX * d_size);
00209       for (dword i = 0; i < XSize; ++i) {
00210 
00211         for (dword d = 0; d < d_size; ++d) {
00212           *(v_ptr++) = (byte)buffer[idx++];
00213         }
00214 
00215       }
00216       v_ptr = pad_r(v_ptr, hiX * d_size);
00217 
00218     }
00219     v_ptr = pad_r(v_ptr, hiY * X * d_size);
00220 
00221   }
00222   v_ptr = pad_r(v_ptr, hiZ * X * Y * d_size);
00223 
00224   delete buffer;
00225 }
00226 
00227 int read_head(ifstream& fin, dword& XSize, dword& YSize, dword& ZSize, dword& b_size)
00228 {
00229         if (!fin.is_open()) return 0;
00230 
00231         char head[MAGIC_NUM_LEN];
00232 
00233         int i = 0;
00234         int c = fin.get();
00235         for (; (c!=' ') && (c!=10) && (c!=13); i++) {
00236                 head[i] = c;
00237                 c = fin.get();
00238         }
00239         head[i] = '\0';
00240 
00241         int ret = 0;
00242         if (strcmp(head, "PVP") == 0)
00243                 ret = 1;
00244         else if (strcmp(head, "FVR") == 0)
00245                 ret = 2;
00246         else
00247                 return 0;
00248 
00249         XSize = readNumber(fin);
00250         YSize = readNumber(fin);
00251         ZSize = readNumber(fin);
00252         b_size = readNumber(fin);
00253         char ccc = fin.get();
00254         if(ccc != '\n')
00255           cout <<"Badly formed header file: " << ccc << endl;
00256         return ret;
00257 }
00258 
00259 bool write_pvp_head(ofstream& fout, dword XSize, dword YSize, dword ZSize, dword b_size)
00260 {
00261         if (!fout.is_open()) return false;
00262         fout.write("PVP\n", 4);
00263         writeNumber(fout, XSize);
00264         writeNumber(fout, YSize);
00265         writeNumber(fout, ZSize);
00266         writeNumber(fout, b_size);
00267         return true;
00268 }
00269 
00270 bool write_fvr_head(ofstream& fout, dword XSize, dword YSize, dword ZSize, dword b_size)
00271 {
00272         if (!fout.is_open()) return false;
00273         fout.write("FVR\n", 4);
00274         writeNumber(fout, XSize);
00275         writeNumber(fout, YSize);
00276         writeNumber(fout, ZSize);
00277         writeNumber(fout, b_size);
00278         fout.write("\n", 1);
00279         
00280         return true;
00281 }
00282 
00283 
00284 void spitData(float *data, dword len, const char* fileName)
00285 {
00286   FILE* outf = fopen(fileName, "wb+");
00287   dword itemsWrote = 0;
00288   while(true)
00289     {
00290       int itemsWritten = fwrite(&data[itemsWrote], sizeof(float), len, outf);
00291       if(itemsWritten <= 0)
00292         {
00293           cout << "Error writing " << flush << endl;
00294           return;
00295         }
00296       itemsWrote += itemsWritten;
00297       if(itemsWrote == len)
00298         break;
00299     }
00300   fflush(outf);
00301   fclose(outf);
00302 }
00303 
00304 
00305 void spitVec3d(vuVector* vec, dword len, const char* fileName)
00306 {
00307   FILE* outf = fopen(fileName, "wb+");
00308   for(dword i = 0; i < len; i++)
00309     {
00310       float v[3];
00311       v[0] = vec[i][0];
00312       v[1] = vec[i][1];
00313       v[2] = vec[i][2];
00314 
00315       int ret = fwrite(&v[0], sizeof(float), 3, outf);
00316       if(ret <= 0)
00317         {
00318           cout <<"Error writing the vector to file"<< endl << flush;
00319         }
00320     }
00321   
00322   fflush(outf);
00323   fclose(outf);
00324 }
00325 
00326 } // END_NS

Generated on Wed Dec 15 21:20:29 2004 for vuVolume by  doxygen 1.3.9.1