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

vuFourier_IO.cpp

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

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