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

SpecFVR/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 SpecFVRNS
00007 {
00008     
00009 // complex pad n spaces
00010 static float* pad(float* 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, float* 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         float* 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                                 float 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 += (float) 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 int read_head(ifstream& fin, dword& XSize, dword& YSize, dword& ZSize, dword& b_size)
00179 {
00180         if (!fin.is_open()) return 0;
00181 
00182         char head[MAGIC_NUM_LEN];
00183 
00184         int i = 0;
00185         int c = fin.get();
00186         for (; (c!=' ') && (c!=10) && (c!=13); i++) {
00187                 head[i] = c;
00188                 c = fin.get();
00189         }
00190         head[i] = '\0';
00191 
00192         int ret = 0;
00193         if (strcmp(head, "PVP") == 0)
00194                 ret = 1;
00195         else if (strcmp(head, "FVR") == 0)
00196                 ret = 2;
00197         else
00198                 return 0;
00199 
00200         XSize = readNumber(fin);
00201         YSize = readNumber(fin);
00202         ZSize = readNumber(fin);
00203         b_size = readNumber(fin);
00204         return ret;
00205 }
00206 
00207 bool write_pvp_head(ofstream& fout, dword XSize, dword YSize, dword ZSize, dword b_size)
00208 {
00209         if (!fout.is_open()) return false;
00210         fout.write("PVP\n", 4);
00211         writeNumber(fout, XSize);
00212         writeNumber(fout, YSize);
00213         writeNumber(fout, ZSize);
00214         writeNumber(fout, b_size);
00215         return true;
00216 }
00217 
00218 bool write_fvr_head(ofstream& fout, dword XSize, dword YSize, dword ZSize, dword b_size)
00219 {
00220         if (!fout.is_open()) return false;
00221         fout.write("FVR\n", 4);
00222         writeNumber(fout, XSize);
00223         writeNumber(fout, YSize);
00224         writeNumber(fout, ZSize);
00225         writeNumber(fout, b_size);
00226         return true;
00227 }
00228  
00229 } // end of namespace

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