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

Volume.cpp

Go to the documentation of this file.
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     //cout << "destroying\n";
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 // read file.
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         //raw data, needs to be mapped with tfunc and transformed
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 //apply transfer function
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         // FVR file
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         // don't allow undersampling
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     //cam.setRightVector(m_XAxis);
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 // fill in zeroed wrap-arounds
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 // and may the gods of good-style forgive me ...
00442 // inner convolution loop, should be fast!
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 }

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