00001 #include "vuSimpleFVRCanvas.h"
00002 #include <GL/gl.h>
00003 #include <GL/glu.h>
00004 #include "vuSimpleFVRDialog.h"
00005
00006 #define ODD(x) ((x)&1)
00007
00008
00009 vuSimpleFVRCanvas::vuSimpleFVRCanvas(vuBasicSubViewer *parent,wxWindowID id) :
00010 vuBasicSubViewerCanvas(parent, id)
00011 {
00012 m_Image = NULL;
00013 m_ImageRGB = NULL;
00014 m_FVR = NULL;
00015 m_FourierVolume = NULL;
00016 m_ImageScale = 255.0f;
00017
00018 m_RenderMethod = 0;
00019 }
00020
00021
00022 vuSimpleFVRCanvas::~vuSimpleFVRCanvas()
00023 {
00024 CHECKNDELETE(m_Image);
00025 CHECKNDELETE(m_ImageRGB);
00026
00027 m_FVR = NULL;
00028 m_FourierVolume = NULL;
00029 }
00030
00031
00032 void vuSimpleFVRCanvas::setFVR(vu1112119 *fvr)
00033 {
00034 m_FVR = fvr;
00035 }
00036
00037 void vuSimpleFVRCanvas::setFourierVolume(vuFourierVolume1 *volume)
00038 {
00039 m_FourierVolume = volume;
00040 }
00041
00042
00043 void vuSimpleFVRCanvas::setRenderMethod(dword method)
00044 {
00045 m_RenderMethod = method;
00046 if (m_RenderMethod > 9) m_RenderMethod = 0;
00047 }
00048
00049 void vuSimpleFVRCanvas::setImageScale(float scale)
00050 {
00051 m_ImageScale = scale;
00052 }
00053
00054
00055
00056
00057
00058 bool vuSimpleFVRCanvas::glInit(void)
00059 {
00060 glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
00061 return true;
00062 };
00063
00064
00065
00066
00067
00068 void vuSimpleFVRCanvas::resize()
00069 {
00070 }
00071
00072
00073
00074
00075
00076 void vuSimpleFVRCanvas::render()
00077 {
00078 if (m_FVR)
00079 _renderImage();
00080 else
00081 _clearCanvas();
00082 }
00083
00084
00085
00086
00087
00088 void vuSimpleFVRCanvas::postEvent(wxEventType ev)
00089 {
00090 wxCommandEvent commandEvent(ev, GetId());
00091 commandEvent.SetEventObject(this);
00092
00093 GetEventHandler()->ProcessEvent(commandEvent);
00094 }
00095
00096 void vuSimpleFVRCanvas::_clearCanvas()
00097 {
00098 static byte *black = NULL;
00099
00100 if (black == NULL) {
00101 black = new byte[16];
00102 for (dword i=0; i<16; i++) black[i] = 0;
00103 }
00104 glPixelZoom((float)getWidth()/4, (float)getHeight()/4);
00105 glDrawPixels(4,4, GL_LUMINANCE, GL_UNSIGNED_BYTE, black);
00106 }
00107
00108 void vuSimpleFVRCanvas::_renderImage()
00109 {
00110 dword method = m_RenderMethod / 2;
00111 bool isDelta = (m_RenderMethod % 2);
00112 float minVal;
00113 float maxVal;
00114
00115 m_FVR->updateCamera();
00116 m_FVR->computeUnscaledImage(m_Image, minVal, maxVal, method);
00117
00118 if (isDelta && m_FourierVolume) {
00119 float minVal2;
00120 float maxVal2;
00121 vuFixelMap1F *img = NULL;
00122
00123 m_FourierVolume->computeUnscaledImage(img, minVal2, maxVal2, method);
00124 cerr << "minVal" << minVal << " maxVal" << maxVal << endl;
00125 cerr << "minVal2" << minVal2 << " maxVal2" << maxVal2 << endl;
00126
00127 dword width = m_Image->getWidth();
00128 dword height = m_Image->getHeight();
00129
00130 if (m_ImageRGB == NULL)
00131 m_ImageRGB = new vuFixelMap3F(width, height);
00132 else if (m_ImageRGB->getWidth() != width ||
00133 m_ImageRGB->getHeight() != height) {
00134 m_ImageRGB->setWidthAndHeight(width, height);
00135 }
00136 *m_Image /= maxVal;
00137 *img /= maxVal2;
00138
00139 *m_ImageRGB = vuFixel3F(0.0f);
00140 if (_substract(img, m_Image)) {
00141 CHECKNDELETE(img);
00142 img = m_Image;
00143 }
00144 else {
00145 _substract(m_Image, img);
00146 CHECKNDELETE(m_Image);
00147 m_Image = img;
00148 }
00149
00150 img->getMinAndMaxValue(minVal, maxVal);
00151
00152 cerr << "delta.minVal" << minVal << " delta.maxVal" << maxVal << endl;
00153
00154 _copyDeltaImageToRGB(img, m_ImageRGB);
00155
00156 *m_ImageRGB /= m_ImageScale;
00157
00158
00159 m_ImageRGB->glResize(getWidth(), getHeight());
00160 m_ImageRGB->glRender();
00161 }
00162 else {
00163 *m_Image /= m_ImageScale;
00164
00165 m_Image->glResize(getWidth(), getHeight());
00166 m_Image->glRender();
00167 }
00168 }
00169
00170 void vuSimpleFVRCanvas::_copyDeltaImageToRGB(vuFixelMap1F *errorMap,
00171 vuFixelMap3F *rgbMap)
00172 {
00173 dword count = errorMap->getWidth() * errorMap->getHeight();
00174 float *src = errorMap->getBuffer();
00175 float *dest = rgbMap->getBuffer();
00176
00177 for (dword i=0; i<count; i++) {
00178 if (*src < 0.0)
00179 dest[0] = -(*src);
00180 else
00181 dest[2] = *src;
00182
00183 dest += 3;
00184 src += 1;
00185 }
00186 }
00187
00188 void vuSimpleFVRCanvas::_renderImageOld()
00189 {
00190 dword method = m_RenderMethod / 2;
00191 bool isDelta = (m_RenderMethod % 2);
00192 float minVal;
00193 float maxVal;
00194
00195 m_FVR->updateCamera();
00196 m_FVR->computeUnscaledImage(m_Image, minVal, maxVal, method);
00197
00198 if (isDelta && m_FourierVolume) {
00199 float minVal2;
00200 float maxVal2;
00201 vuFixelMap1F *img = NULL;
00202
00203 m_FourierVolume->computeUnscaledImage(img, minVal2, maxVal2, method);
00204 _substract(img,m_Image);
00205
00206 }
00207
00208
00209
00210
00211 m_Image->glResize(getWidth(), getHeight());
00212 m_Image->glRender();
00213 }
00214
00215 bool vuSimpleFVRCanvas::_substract(vuFixelMap1F *srcImg, vuFixelMap1F* destImg)
00216 {
00217 float *dest = destImg->getBuffer();
00218 float *src = srcImg->getBuffer();
00219 dword rowStep = destImg->getWidth();
00220 int deltaX = destImg->getWidth() - srcImg->getWidth();
00221 int deltaY = destImg->getHeight() - srcImg->getHeight();
00222
00223 if (deltaX < 0 || deltaY < 0) {
00224 cerr << "vuSimpleFVRCanvas::_substract(): ";
00225 cerr << "this case is not implemented! (case 1)" << endl;
00226 return false;
00227 }
00228
00229 dword lowX = abs(deltaX / 2);
00230 dword lowY = abs(deltaY / 2);
00231 dword highX = lowX + srcImg->getWidth();
00232 dword highY = lowY + srcImg->getHeight();
00233
00234 dest+= lowY * rowStep;
00235 float *ptr = dest;
00236 for (dword j=lowY; j<highY; j++) {
00237 dest = ptr + lowX;
00238 for (dword i=lowX; i<highX; i++, dest++, src++) {
00239 *dest -= *src;
00240 }
00241 ptr += rowStep;
00242 }
00243 return true;
00244 }