00001 #include "vuFourier_IO.h"
00002 #include <stdio.h>
00003 #include <string.h>
00004
00005
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
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
00049
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
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 }