00001 #include <string.h>
00002 #include <stdio.h>
00003 #include <iostream.h>
00004 #include "SimpleDefs.h"
00005 #include "Volume.h"
00006 #include "vuVector.h"
00007 #include "vuMatrix.h"
00008 #include "Image_io.h"
00009 #include "Transform.h"
00010
00011 #define ODD(x) ((x)&1)
00012
00013 using namespace SpecFVRNS;
00014
00015
00016 Volume::Volume() : m_XStep(1.0f, 0.0f, 0.0f),
00017 m_YStep(0.0f, 1.0f, 0.0f),
00018 m_XAxis(1.0f, 0.0f, 0.0f),
00019 m_YAxis(0.0f, 1.0f, 0.0f),
00020 m_ZAxis(0.0f, 0.0f, 1.0f)
00021 {
00022 m_Volume = 0;
00023 m_Slice = 0;
00024 m_Image = 0;
00025 m_Scale = 1.0f;
00026 m_Bias = 0.0f;
00027
00028 m_Wrap = 0;
00029
00030 m_CurImage = 0;
00031
00032 m_ImageStep = 0;
00033 m_SlicePtr = 0;
00034
00035 SpecFVRNS::initTransforms();
00036
00037 #ifndef FVR_NO_SLICE_COPY
00038 m_SSlice = 0;
00039 #endif
00040 }
00041
00042 Volume::Volume(Volume& inst)
00043 {
00044 }
00045
00046 Volume::~Volume()
00047 {
00048
00049 SpecFVRNS::destroyTransform2D();
00050 SpecFVRNS::destroyTransforms();
00051 if (m_Volume) {
00052 delete [] m_Volume;
00053 m_Volume = NULL;
00054 }
00055 if (m_Slice) {
00056 delete [] m_Slice;
00057 m_Slice = NULL;
00058 }
00059 if (m_Image) {
00060 delete [] m_Image;
00061 m_Image = NULL;
00062 }
00063
00064 #ifndef FVR_NO_SLICE_COPY
00065 if (m_SSlice) {
00066 delete [] m_SSlice;
00067 m_SSlice=NULL;
00068 }
00069 #endif
00070 }
00071
00072 Volume& Volume::operator=(Volume& rhs)
00073 {
00074 if (this != &rhs)
00075 {
00076 }
00077 return *this;
00078 }
00079
00080 void Volume::write_fvr(char* out) const
00081 {
00082 cout << "now writing " << out << endl;
00083
00084 ofstream fout;
00085 fout.open(out, ios::out|ios::binary);
00086 if(!fout.good()) cout <<" couldn't open file" << endl;
00087
00088
00089 write_fvr_head(fout, m_XSize, m_YSize, m_ZSize, sizeof(float));
00090 fout.write((char*)m_Volume, m_XSize * m_YSize * m_ZSize * 2 * sizeof(float));
00091
00092 fout.close();
00093 }
00094
00095 void Volume::preprocess(void)
00096 {
00097 cout << "shifting volume ... " << flush;
00098 SpecFVRNS::shift3D(m_Volume, m_XSize, m_YSize, m_ZSize);
00099
00100 cout << "done\ntransforming volume ... " << flush;
00101 SpecFVRNS::initTransform3D(m_XSize, m_YSize, m_ZSize);
00102 SpecFVRNS::transform3D(m_Volume);
00103 SpecFVRNS::destroyTransform3D();
00104
00105 cout << "done\nshifting volume ... " << flush;
00106 SpecFVRNS::shift3D(m_Volume, m_XSize, m_YSize, m_ZSize);
00107 cout << "done\n" << flush;
00108 }
00109
00110 bool Volume::read_fvr(ifstream& fin, dword XSize, dword YSize, dword ZSize, dword d_size)
00111 {
00112 if (d_size != sizeof(float)) return false;
00113
00114 m_XSize = XSize + m_Wrap * 2;
00115 m_YSize = YSize + m_Wrap * 2;
00116 m_ZSize = ZSize + m_Wrap * 2;
00117
00118 m_Volume = new float[m_XSize * m_YSize * m_ZSize * 2];
00119
00120 read_raw_r(fin, (byte*)m_Volume, m_XSize, m_YSize, m_ZSize, XSize, YSize, ZSize, d_size * 2);
00121
00122 return true;
00123 }
00124
00125 static dword find_dim(dword XSize, dword YSize, dword ZSize, float m_pad, dword a_pad)
00126 {
00127 dword dim = (XSize > YSize) ? XSize : YSize;
00128 dim = (dim > ZSize) ? dim : ZSize;
00129 dim = (dword) ceil((float)dim * m_pad) + a_pad;
00130 dim = (ODD(dim)) ? dim + 1 : dim;
00131
00132 cout << "dimension = " << dim << endl;
00133
00134 return dim;
00135 }
00136
00137
00138 bool Volume::convert(byte* data, dword XSize, dword YSize, dword ZSize,
00139 dword d_size, const vuTFIntensity &tfunc, dword component,
00140 float osamp, float m_pad, dword a_pad)
00141 {
00142 if (!data) return 0;
00143
00144
00145 {
00146 dword dim = find_dim(XSize, YSize, ZSize, m_pad, a_pad);
00147 m_XSize = m_YSize = m_ZSize = dim;
00148
00149 m_Volume = new float[m_XSize * m_YSize * m_ZSize * 2];
00150
00151 read_raw(data, &m_Volume[0], m_XSize, m_YSize, m_ZSize,
00152 XSize, YSize, ZSize, d_size);
00153
00154 dword c;
00155 float *fp = m_Volume;
00156 for(c=m_XSize * m_YSize * m_ZSize; c>0; c--) {
00157 *fp = tfunc[(dword)(*fp)][component];
00158 fp+=2;
00159 }
00160
00161 preprocess();
00162 }
00163
00164
00165 cout <<"frequency transform done"<<endl;
00166
00167 setWrap(m_Filter->getWidth() / 2);
00168 wrapVolume();
00169
00170 m_Origin[0] = (float)(XSize / 2) * -1.0f;
00171 m_Origin[1] = (float)(YSize / 2) * -1.0f;
00172 m_Origin[2] = 0.0f;
00173
00174 m_ImageXSize = XSize;
00175 m_ImageYSize = YSize;
00176
00177 m_Image = new float[m_ImageXSize * m_ImageYSize];
00178
00179 setOversampling(osamp);
00180
00181 cout << "initializing transforms ... " << flush;
00182 SpecFVRNS::initTransform2D(m_SliceXSize, m_SliceYSize);
00183 cout << "done\n" << flush;
00184
00185 return true;
00186 }
00187
00188 void Volume::setOversampling(float s) {
00189
00190 if (s < 1.0) s = 1.0;
00191
00192 m_SliceXSize = (dword) ceil(m_ImageXSize * s);
00193 m_SliceYSize = (dword) ceil(m_ImageYSize * s);
00194 m_SliceXSize = (ODD(m_SliceXSize)) ? m_SliceXSize + 1 : m_SliceXSize;
00195 m_SliceYSize = (ODD(m_SliceYSize)) ? m_SliceYSize + 1 : m_SliceYSize;
00196
00197 m_XStep = m_XAxis * (m_ImageXSize / (float)m_SliceXSize);
00198 m_YStep = m_YAxis * (m_ImageYSize / (float)m_SliceYSize);
00199
00200 m_ImageStep = (m_SliceXSize - m_ImageXSize) * 2;
00201
00202 cout << "Slice size: " << m_SliceXSize << ' ' << m_SliceYSize << endl;
00203
00204 if (m_Slice) delete [] m_Slice;
00205 m_Slice = new float[m_SliceXSize * m_SliceYSize * 2];
00206
00207 #ifndef FVR_NO_SLICE_COPY
00208 if (m_SSlice) delete [] m_Slice;
00209 m_SSlice = new float[m_SliceXSize * m_SliceYSize * 2];
00210
00211 m_SlicePtr = &m_SSlice[scoord( (m_SliceXSize - m_ImageXSize) / 2,
00212 (m_SliceYSize - m_ImageYSize) / 2)];
00213 #else
00214 m_SlicePtr = &m_Slice[scoord( (m_SliceXSize - m_ImageXSize) / 2,
00215 (m_SliceYSize - m_ImageYSize) / 2)];
00216 #endif
00217
00218 m_InnerXSize = (dword) floor((float) m_SliceXSize / ROOT_TWO);
00219 m_InnerYSize = (dword) floor((float) m_SliceYSize / ROOT_TWO);
00220 m_InnerXSize = (ODD(m_InnerXSize)) ? m_InnerXSize + 1 : m_InnerXSize;
00221 m_InnerYSize = (ODD(m_InnerYSize)) ? m_InnerYSize + 1 : m_InnerYSize;
00222 }
00223
00224 void Volume::writeImage(void)
00225 {
00226 char name[32];
00227 float v;
00228 ofstream fout;
00229 dword i;
00230 byte* img;
00231
00232 img = new byte[m_SliceXSize*m_SliceYSize];
00233 for(i=0;i<m_SliceXSize*m_SliceYSize;i++)
00234 {
00235 v = m_Image[i]*255.0f + 0.5f;
00236 if (v > 255.0f)
00237 img[i] = 255;
00238 else if (v < 0.0f)
00239 img[i] = 0;
00240 else
00241 img[i] = (byte)v;
00242 }
00243
00244 sprintf(name, "%i.pgm", m_CurImage++);
00245 fout.open(name, ios::out|ios::binary);
00246 if (fout.is_open())
00247 {
00248 sprintf(name, "P5%c%ld %ld%c%d%c", 0x0A, m_SliceXSize, m_SliceYSize, 0x0A, 255, 0x0A);
00249
00250 fout.write(name, strlen(name));
00251 fout.write((char*)img, m_XSize*m_YSize);
00252
00253 fout.close();
00254 }
00255
00256 delete [] img;
00257 }
00258
00259 void Volume::setWrap(dword wrap)
00260 {
00261 m_Wrap = wrap;
00262 }
00263
00264 void Volume::setFilter(Filter* filter)
00265 {
00266 m_Filter = filter;
00267 }
00268
00269 void Volume::setSliceScale(float scale)
00270 {
00271 m_Scale = scale;
00272 }
00273
00274 void Volume::setSliceBias(float bias)
00275 {
00276 m_Bias = bias;
00277 }
00278
00279 void Volume::rotateSliceX(float alpha)
00280 {
00281 vuMatrix rot;
00282
00283 rot.makeRotate(m_XAxis, alpha);
00284
00285 m_YAxis = rot * m_YAxis;
00286 m_ZAxis = rot * m_ZAxis;
00287 m_XStep = rot * m_XStep;
00288 m_YStep = rot * m_YStep;
00289 m_Origin = rot * m_Origin;
00290 }
00291
00292 void Volume::rotateSliceY(float alpha)
00293 {
00294 vuMatrix rot;
00295
00296 rot.makeRotate(m_YAxis, alpha);
00297
00298 m_XAxis = rot * m_XAxis;
00299 m_ZAxis = rot * m_ZAxis;
00300 m_XStep = rot * m_XStep;
00301 m_YStep = rot * m_YStep;
00302 m_Origin = rot * m_Origin;
00303 }
00304
00305 void Volume::rotateSliceZ(float alpha)
00306 {
00307 vuMatrix rot;
00308
00309 rot.makeRotate(m_ZAxis, alpha);
00310
00311 m_XAxis = rot * m_XAxis;
00312 m_YAxis = rot * m_YAxis;
00313 m_XStep = rot * m_XStep;
00314 m_YStep = rot * m_YStep;
00315 m_Origin = rot * m_Origin;
00316 }
00317
00318 void Volume::setViewMatrix(const vuMatrix& mat)
00319 {
00320 m_XAxis = mat*vuVector(1,0,0);
00321 m_YAxis = mat*vuVector(0,1,0);
00322 m_ZAxis = mat*vuVector(0,0,1);
00323 m_XStep = m_XAxis;
00324 m_YStep = m_YAxis;
00325 m_XStep *= (float)(m_ImageXSize / m_SliceXSize);
00326 m_YStep *= (float)(m_ImageYSize / m_SliceYSize);
00327 m_Origin = m_XAxis*(m_SliceXSize*-0.5f);
00328 m_Origin += m_YAxis*(m_SliceYSize*-0.5f);
00329 }
00330
00331 void Volume::setCamera(const vuCamera& cam)
00332 {
00333 m_XAxis = cam.getRightVector();
00334 m_XAxis.makeUnit();
00335 m_YAxis = cam.getUpVector();
00336 m_YAxis.makeUnit();
00337 m_ZAxis = cam.getLookAtVector();
00338 m_XStep = m_XAxis;
00339 m_YStep = m_YAxis;
00340 m_XStep *= (float)(m_ImageXSize / m_SliceXSize);
00341 m_YStep *= (float)(m_ImageYSize / m_SliceYSize);
00342 m_Origin = m_XAxis*(m_SliceXSize*-0.5f);
00343 m_Origin += m_YAxis*(m_SliceYSize*-0.5f);
00344 }
00345
00346 void Volume::getCamera(vuCamera& cam) const
00347 {
00348 cam.setLookAtVector(m_ZAxis);
00349 cam.setUpVector(m_YAxis);
00350
00351 }
00352
00353 dword Volume::getSliceWidth(void) const
00354 {
00355 return m_ImageXSize;
00356 }
00357
00358 dword Volume::getSliceHeight(void) const
00359 {
00360 return m_ImageYSize;
00361 }
00362
00363 dword Volume::getInternalSliceWidth(void) const
00364 {
00365 return m_SliceXSize;
00366 }
00367
00368 dword Volume::getInternalSliceHeight(void) const
00369 {
00370 return m_SliceYSize;
00371 }
00372
00373
00374 void Volume::wrapVolume(void)
00375 {
00376 dword index;
00377 dword ii, jj ,kk;
00378
00379 dword hiX = m_XSize - m_Wrap - 1;
00380 dword hiY = m_YSize - m_Wrap - 1;
00381 dword hiZ = m_ZSize - m_Wrap - 1;
00382
00383 dword XSize = m_XSize - m_Wrap * 2;
00384 dword YSize = m_YSize - m_Wrap * 2;
00385 dword ZSize = m_ZSize - m_Wrap * 2;
00386
00387 index = 0;
00388 for(dword k = 0; k < m_ZSize; ++k) {
00389 for(dword j = 0; j < m_YSize; ++j) {
00390 for(dword i = 0; i < m_XSize; ++i) {
00391 if (i < m_Wrap)
00392 ii = i + XSize;
00393 else if (i > hiX)
00394 ii = i - XSize;
00395 else {
00396 index += 2;
00397 continue;
00398 }
00399
00400 if (j < m_Wrap)
00401 jj = j + YSize;
00402 else if (j > hiY)
00403 jj = j - YSize;
00404 else {
00405 index += 2;
00406 continue;
00407 }
00408
00409 if (k < m_Wrap)
00410 kk = k + ZSize;
00411 else if (k > hiZ)
00412 kk = k - ZSize;
00413 else {
00414 index += 2;
00415 continue;
00416 }
00417
00418 ii = vcoord(ii, jj, kk);
00419
00420 m_Volume[index++] = m_Volume[ii];
00421 m_Volume[index++] = m_Volume[ii+1];
00422 }
00423 }
00424 }
00425 }
00426
00427 void Volume::clearSlice(void)
00428 {
00429 float* s_ptr = m_Slice;
00430 for (dword i = 0; i < m_SliceXSize * m_SliceYSize * 2; i++)
00431 *(s_ptr++) = 0.0f;
00432 }
00433
00434 float* Volume::getSliceData(void)
00435 {
00436 scaleAndBias();
00437
00438 return m_Image;
00439 }
00440
00441
00442
00443 #define CONVOLVE_NO_MOD \
00444 int x = (int) p[0]; \
00445 int y = (int) p[1]; \
00446 int z = (int) p[2]; \
00447 \
00448 t[0] = p[0] - x; \
00449 t[1] = p[1] - y; \
00450 t[2] = p[2] - z; \
00451 \
00452 x = x - XSize + m_Wrap; \
00453 y = y - YSize + m_Wrap; \
00454 z = z - ZSize + m_Wrap; \
00455 \
00456 register float* fweight = m_Filter->getWeights(t); \
00457 \
00458 register float real = 0.0f; \
00459 register float imag = 0.0f; \
00460 \
00461 register float* v_ptr = &m_Volume[vcoord(x + f2, y + f2, z + f2)]; \
00462 \
00463 for (dword l = 0; l < f_len; l++) { \
00464 for (dword m = 0; m < f_len; m++) { \
00465 for (dword n = 0; n < f_len; n++) { \
00466 float tmp = *(fweight++); \
00467 real += *(v_ptr) * tmp; \
00468 imag += *(v_ptr + 1) * tmp; \
00469 v_ptr -= 2; \
00470 } \
00471 v_ptr += fXStep; \
00472 } \
00473 v_ptr += fYStep; \
00474 } \
00475 \
00476 *(s_ptr++) = real; \
00477 *(s_ptr++) = imag; \
00478 \
00479 p += m_XStep;
00480
00481 #define CONVOLVE \
00482 int x = (int) p[0]; \
00483 int y = (int) p[1]; \
00484 int z = (int) p[2]; \
00485 \
00486 t[0] = p[0] - x; \
00487 t[1] = p[1] - y; \
00488 t[2] = p[2] - z; \
00489 \
00490 x = x % XSize + m_Wrap; \
00491 y = y % YSize + m_Wrap; \
00492 z = z % ZSize + m_Wrap; \
00493 \
00494 register float* fweight = m_Filter->getWeights(t); \
00495 \
00496 register float real = 0.0f; \
00497 register float imag = 0.0f; \
00498 \
00499 register float* v_ptr = &m_Volume[vcoord(x + f2, y + f2, z + f2)]; \
00500 \
00501 for (dword l = 0; l < f_len; l++) { \
00502 for (dword m = 0; m < f_len; m++) { \
00503 for (dword n = 0; n < f_len; n++) { \
00504 float tmp = *(fweight++); \
00505 real += *(v_ptr) * tmp; \
00506 imag += *(v_ptr + 1) * tmp; \
00507 v_ptr -= 2; \
00508 } \
00509 v_ptr += fXStep; \
00510 } \
00511 v_ptr += fYStep; \
00512 } \
00513 \
00514 *(s_ptr++) = real; \
00515 *(s_ptr++) = imag; \
00516 \
00517 p += m_XStep;
00518
00519 void Volume::interpolateSlice(dword x_stop, dword y_stop, dword x_pass, dword y_pass)
00520 {
00521 vuVector t;
00522 dword f_len = m_Filter->getWidth();
00523 int f2 = f_len / 2;
00524
00525 x_stop *= 2;
00526 y_stop *= 2;
00527 dword stop_l = (m_SliceXSize - x_stop - 2 * x_pass) / 2;
00528 dword stop_r = m_SliceXSize - x_stop - 2 * x_pass - stop_l;
00529 dword stop_b = (m_SliceYSize - y_stop - 2 * y_pass) / 2;
00530 dword x_hi = x_stop + 2 * x_pass;
00531 dword s_step = stop_l + stop_r;
00532
00533 dword XSize = m_XSize - m_Wrap * 2;
00534 dword YSize = m_YSize - m_Wrap * 2;
00535 dword ZSize = m_ZSize - m_Wrap * 2;
00536
00537 dword fXStep = (f_len - m_XSize) * 2;
00538 dword fYStep = (f_len - m_YSize) * m_XSize * 2;
00539
00540 vuVector q = m_Origin;
00541 q[0] += XSize / 2 + XSize + stop_l * m_XStep[0] + stop_b * m_YStep[0];
00542 q[1] += YSize / 2 + YSize + stop_l * m_XStep[1] + stop_b * m_YStep[1];
00543 q[2] += ZSize / 2 + ZSize + stop_l * m_XStep[2] + stop_b * m_YStep[2];
00544
00545 float* s_ptr = &m_Slice[scoord(stop_l, stop_b)];
00546
00547 for (dword j = 0; j < y_pass; ++j) {
00548 vuVector p = q;
00549 for (dword i = 0; i < x_hi; ++i) {
00550 CONVOLVE;
00551 }
00552 s_ptr += s_step * 2;
00553 q += m_YStep;
00554 }
00555
00556 for (dword j = 0; j < y_stop; ++j) {
00557 vuVector p = q;
00558 for (dword i = 0; i < x_pass; ++i) {
00559 CONVOLVE;
00560 }
00561
00562 s_ptr += x_stop * 2;
00563 p[0] += x_stop * m_XStep[0];
00564 p[1] += x_stop * m_XStep[1];
00565 p[2] += x_stop * m_XStep[2];
00566
00567 for (dword i = 0; i < x_pass; ++i) {
00568 CONVOLVE;
00569 }
00570 s_ptr += s_step * 2;
00571 q += m_YStep;
00572 }
00573
00574 for (dword j = 0; j < y_pass; ++j) {
00575 vuVector p = q;
00576 for (dword i = 0; i < x_hi; ++i) {
00577 CONVOLVE;
00578 }
00579 s_ptr += s_step * 2;
00580 q += m_YStep;
00581 }
00582 }
00583
00584 void Volume::interpolateSlice(void)
00585 {
00586 dword i, j;
00587 vuVector t;
00588 dword f_len = m_Filter->getWidth();
00589 int f2 = f_len / 2;
00590
00591 dword x_pass = (m_SliceXSize - m_InnerXSize) / 2;
00592 dword y_pass = (m_SliceYSize - m_InnerYSize) / 2;
00593
00594 dword XSize = m_XSize - m_Wrap * 2;
00595 dword YSize = m_YSize - m_Wrap * 2;
00596 dword ZSize = m_ZSize - m_Wrap * 2;
00597
00598 dword fXStep = (f_len - m_XSize) * 2;
00599 dword fYStep = (f_len - m_YSize) * m_XSize * 2;
00600
00601 vuVector q = m_Origin;
00602 q[0] += XSize / 2 + XSize;
00603 q[1] += YSize / 2 + YSize;
00604 q[2] += ZSize / 2 + ZSize;
00605
00606 float* s_ptr = m_Slice;
00607
00608 for (j = 0; j < y_pass; ++j) {
00609 vuVector p = q;
00610 for (i = 0; i < m_SliceXSize; ++i) {
00611 CONVOLVE;
00612 }
00613 q += m_YStep;
00614 }
00615
00616 for (j = 0; j < m_InnerYSize; ++j) {
00617 vuVector p = q;
00618 for (i = 0; i < x_pass; ++i) {
00619 CONVOLVE;
00620 }
00621
00622 for (i = 0; i < m_InnerXSize; ++i) {
00623 CONVOLVE_NO_MOD;
00624 }
00625
00626 for (i = 0; i < x_pass; ++i) {
00627 CONVOLVE;
00628 }
00629 q += m_YStep;
00630 }
00631
00632 for (j = 0; j < y_pass; ++j) {
00633 vuVector p = q;
00634 for (i = 0; i < m_SliceXSize; ++i) {
00635 CONVOLVE;
00636 }
00637 q += m_YStep;
00638 }
00639 }
00640
00641 #ifndef FVR_NO_SLICE_COPY
00642
00643 void Volume::computeSlice(void)
00644 {
00645 interpolateSlice();
00646 SpecFVRNS::shift_copy2D(m_SSlice, m_Slice, m_SliceXSize, m_SliceYSize);
00647 SpecFVRNS::transform2D(m_SSlice);
00648 SpecFVRNS::shift2D(m_SSlice, m_SliceXSize, m_SliceYSize);
00649 }
00650
00651 void Volume::computeSlice(dword x_stop, dword y_stop, dword x_pass, dword y_pass)
00652 {
00653 interpolateSlice(x_stop, y_stop, x_pass, y_pass);
00654 SpecFVRNS::shift_copy2D(m_SSlice, m_Slice, m_SliceXSize, m_SliceYSize);
00655 SpecFVRNS::transform2D(m_SSlice);
00656 SpecFVRNS::shift2D(m_SSlice, m_SliceXSize, m_SliceYSize);
00657 }
00658
00659 #else
00660
00661 void Volume::computeSlice(void)
00662 {
00663 interpolateSlice();
00664 shift2D(m_Slice, m_SliceXSize, m_SliceYSize);
00665 transform2D(m_Slice);
00666 shift2D(m_Slice, m_SliceXSize, m_SliceYSize);
00667 }
00668
00669 void Volume::computeSlice(dword x_stop, dword y_stop, dword x_pass, dword y_pass)
00670 {
00671 interpolateSlice(x_stop, y_stop, x_pass, y_pass);
00672 shift2D(m_Slice, m_SliceXSize, m_SliceYSize);
00673 transform2D(m_Slice);
00674 shift2D(m_Slice, m_SliceXSize, m_SliceYSize);
00675 }
00676
00677 #endif
00678
00679 void Volume::scaleAndBias(void)
00680 {
00681 float* i_ptr = m_Image;
00682 float* s_ptr = m_SlicePtr;
00683 for (dword j = 0; j < m_ImageYSize; j++) {
00684 for (dword i = 0; i < m_ImageXSize; i++) {
00685 *(i_ptr++) = *s_ptr * m_Scale + m_Bias;
00686 s_ptr += 2;
00687 }
00688 s_ptr += m_ImageStep;
00689 }
00690 }