00001 #include "Image_io.h"
00002 #include <stdio.h>
00003 #include <string.h>
00004 #include <iostream.h>
00005
00006 namespace SpecFVRNS
00007 {
00008
00009
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
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
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
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 }