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
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
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
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
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 }