datacontainerinspectorcanvas.cpp 29.1 KB
Newer Older
1
2
// ================================================================================================
// 
schultezub's avatar
schultezub committed
3
// This file is part of the CAMPVis Software Framework.
4
5
// 
// If not explicitly stated otherwise: Copyright (C) 2012, all rights reserved,
schultezub's avatar
schultezub committed
6
//      Christian Schulte zu Berge <christian.szb@in.tum.de>
7
//      Chair for Computer Aided Medical Procedures
8
9
//      Technische Universität München
//      Boltzmannstr. 3, 85748 Garching b. München, Germany
schultezub's avatar
schultezub committed
10
// For a full list of authors and contributors, please refer to the file "AUTHORS.txt".
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
// 
// The licensing of this softare is not yet resolved. Until then, redistribution in source or
// binary forms outside the CAMP chair is not permitted, unless explicitly stated in legal form.
// However, the names of the original authors and the above copyright notice must retain in its
// original state in any case.
// 
// Legal disclaimer provided by the BSD license:
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY 
// AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR 
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 
// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 
// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
// 
// ================================================================================================

#include "datacontainerinspectorcanvas.h"

#include "tgt/assert.h"
#include "tgt/shadermanager.h"
34
35
#include "tgt/textureunit.h"

36
37
#include "core/datastructures/datacontainer.h"
#include "core/datastructures/datahandle.h"
38
#include "core/datastructures/renderdata.h"
39
#include "core/datastructures/imagerepresentationgl.h"
40
#include "core/datastructures/facegeometry.h"
41
#include "core/tools/job.h"
42
43
#include "core/classification/tfgeometry1d.h"
#include "core/classification/geometry1dtransferfunction.h"
44

45
46
#include "datacontainerinspectorwidget.h"

47
48
#include "ext/tgt/navigation/trackball.h"

49

schultezub's avatar
schultezub committed
50
namespace campvis {
51
52
53

    DataContainerInspectorCanvas::DataContainerInspectorCanvas(QWidget* parent /*= 0*/) 
        : tgt::QtThreadedCanvas("DataContainer Inspector", tgt::ivec2(640, 480), tgt::GLCanvas::RGBA_BUFFER, parent, true)
54
        , p_currentSlice("CurrentSlice", "Slice", -1, -1, -1)
55
        , p_meshSolidColor("MeshSolidColor", "Mesh Solid Color", tgt::vec4(1.f), tgt::vec4(0.f), tgt::vec4(255.f))
56
        , p_transferFunction("TransferFunction", "Transfer Function", new Geometry1DTransferFunction(256, tgt::vec2(0.f, 1.f)))
57
58
        , _dataContainer(0)
        , _paintShader(0)
59
        , _quad(0)
60
61
62
63
        , _numTiles(0, 0)
        , _quadSize(0, 0)
        , _selectedTexture(0)
        , _renderFullscreen(false)
64
        , _currentSlice(-1)
65
        , _color(0.0f, 0.0f, 0.0f, 0.0f)
66
67
		, _meshGeomTexturesDirty(false)
		, _renderingWndSize(tgt::ivec2(400, 100))
68
    {
69
		static_cast<Geometry1DTransferFunction*>(p_transferFunction.getTF())->addGeometry(TFGeometry1D::createQuad(tgt::vec2(0.f, 1.f), tgt::col4(0, 0, 0, 255), tgt::col4(255, 255, 255, 255)));
70
71
72
73
74
75
76
77
78
79

        makeCurrent();
        // Init GLEW for this context
        GLenum err = glewInit();
        if (err != GLEW_OK) {
            // Problem: glewInit failed, something is seriously wrong.
            tgtAssert(false, "glewInit failed");
            std::cerr << "glewInit failed, error: " << glewGetErrorString(err) << std::endl;
            exit(EXIT_FAILURE);
        }
80
        
81
82
        addProperty(&p_currentSlice);
        addProperty(&p_transferFunction);
83
84
        addProperty(&p_meshSolidColor);
        //addProperty(&_camera);
85
86
87
88
89
90
    }

    DataContainerInspectorCanvas::~DataContainerInspectorCanvas() {

    }

91
    void DataContainerInspectorCanvas::init(DataContainerInspectorWidget* _pWidget) {
schultezub's avatar
schultezub committed
92
93
        initAllProperties();

94
        _widget = _pWidget;
95

96
97
        GLJobProc.registerContext(this);
        _paintShader = ShdrMgr.loadSeparate("core/glsl/passthrough.vert", "application/glsl/datacontainerinspector.frag", "", false);
98
		_geomteryRenderingShader = ShdrMgr.loadSeparate("core/glsl/meshgeomteryrenderer.vert", "modules/vis/glsl/meshgeometryrenderer.frag", "", false);
99

100
101
        _paintShader->setAttributeLocation(0, "in_Position");
        _paintShader->setAttributeLocation(1, "in_TexCoords");
102

103
104
        createQuad();

105
        // set this as painter to get notified when window size changes
106
        setPainter(this, false);
107
        getEventHandler()->addEventListenerToFront(this);
108
109
110
    }

    void DataContainerInspectorCanvas::deinit() {
schultezub's avatar
schultezub committed
111
112
        deinitAllProperties();

113
114
115
116
        if (_dataContainer != 0) {
            _dataContainer->s_dataAdded.disconnect(this);
        }

117
        _handles.clear();
118
        GLJobProc.deregisterContext(this);
119
        ShdrMgr.dispose(_paintShader);
120
        delete _quad;
121
122
123
124
125
126
127
128
    }

    QSize DataContainerInspectorCanvas::sizeHint() const {
        return QSize(640, 480);
    }


    void DataContainerInspectorCanvas::paint() {
129
        LGL_ERROR;
130
        tbb::mutex::scoped_lock lock(_localMutex);
131
132
133
        if (_texturesDirty)
            updateTextures();

134
135
        if (_textures.empty())
            return;
136
137

        glPushAttrib(GL_ALL_ATTRIB_BITS);
138
        glViewport(0, 0, size_.x, size_.y);
139
140
141
142
143
        glClearColor(0.7f, 0.7f, 0.7f, 1.f);
        glClear(GL_COLOR_BUFFER_BIT);
        LGL_ERROR;

        // update layout dimensions
144
145
        _numTiles.x = ceil(sqrt(static_cast<float>(_textures.size())));
        _numTiles.y = ceil(static_cast<float>(_textures.size()) / _numTiles.x);
146
        _quadSize = size_ / _numTiles;
147
148
149
150
151
152

        _paintShader->activate();

        tgt::mat4 projection = tgt::mat4::createOrtho(0, size_.x, 0, size_.y, -1, 1);
        _paintShader->setUniform("_projectionMatrix", projection);

153
154
        tgt::TextureUnit tfUnit, unit2d, unit3d;
        p_transferFunction.getTF()->bind(_paintShader, tfUnit);
155
156
        _paintShader->setUniform("_texture2d", unit2d.getUnitNumber());
        _paintShader->setUniform("_texture3d", unit3d.getUnitNumber());
157

158
159
160
161
162
163
164
165
166
167
        for (int y = 0; y < _numTiles.y; ++y) {
            for (int x = 0; x < _numTiles.x; ++x) {
                int index = (_numTiles.x * y) + x;
                if (index >= static_cast<int>(_textures.size()))
                    break;

                tgt::mat4 scaleMatrix = tgt::mat4::createScale(tgt::vec3(_quadSize, 1.f));
                tgt::mat4 translation = tgt::mat4::createTranslation(tgt::vec3(_quadSize.x * x, _quadSize.y * y, 0.f));
                _paintShader->setUniform("_modelMatrix", translation * scaleMatrix);
                paintTexture(_textures[index], unit2d, unit3d);
168
169
170
            }
        }

171
        _paintShader->deactivate();
172
173
174
175
        LGL_ERROR;
        glPopAttrib();
    }

176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
	void DataContainerInspectorCanvas::paintMeshGeomTextures() {
        LGL_ERROR;
        tbb::mutex::scoped_lock lock(_localMutex);
        if (_meshGeomTexturesDirty)
			updateMeshGeomRenderedTextures();

        if (_textures.empty())
            return;

        glPushAttrib(GL_ALL_ATTRIB_BITS);
        glViewport(0, 0, size_.x, size_.y);
        glClearColor(0.7f, 0.7f, 0.7f, 1.f);
        glClear(GL_COLOR_BUFFER_BIT);
        LGL_ERROR;

        // update layout dimensions
        _numTiles.x = ceil(sqrt(static_cast<float>(_textures.size())));
        _numTiles.y = ceil(static_cast<float>(_textures.size()) / _numTiles.x);
        _quadSize = size_ / _numTiles;

        _paintShader->activate();

        tgt::mat4 projection = tgt::mat4::createOrtho(0, size_.x, 0, size_.y, -1, 1);
        _paintShader->setUniform("_projectionMatrix", projection);

        tgt::TextureUnit tfUnit, unit2d, unit3d;
        p_transferFunction.getTF()->bind(_paintShader, tfUnit);
        _paintShader->setUniform("_texture2d", unit2d.getUnitNumber());
        _paintShader->setUniform("_texture3d", unit3d.getUnitNumber());

        for (int y = 0; y < _numTiles.y; ++y) {
            for (int x = 0; x < _numTiles.x; ++x) {
                int index = (_numTiles.x * y) + x;
                if (index >= static_cast<int>(_textures.size()))
                    break;

                tgt::mat4 scaleMatrix = tgt::mat4::createScale(tgt::vec3(_quadSize, 1.f));
                tgt::mat4 translation = tgt::mat4::createTranslation(tgt::vec3(_quadSize.x * x, _quadSize.y * y, 0.f));
                _paintShader->setUniform("_modelMatrix", translation * scaleMatrix);
                paintTexture(_textures[index], unit2d, unit3d);
            }
        }

        _paintShader->deactivate();
        LGL_ERROR;
        glPopAttrib();
    }

224
    void DataContainerInspectorCanvas::paintTexture(const tgt::Texture* texture, const tgt::TextureUnit& unit2d, const tgt::TextureUnit& unit3d) {
225
226

        _paintShader->setIgnoreUniformLocationError(true);
227
228
229
230
        if (texture->getDimensions().z == 1) {
            unit2d.activate();
            texture->bind();
            _paintShader->setUniform("_is3d", false);
231
            _paintShader->setUniform("_isDepthTexture", texture->isDepthTexture());
232
233
234
            _paintShader->setUniform("_2dTextureParams._size", tgt::vec2(texture->getDimensions().xy()));
            _paintShader->setUniform("_2dTextureParams._sizeRCP", tgt::vec2(1.f) / tgt::vec2(texture->getDimensions().xy()));
            _paintShader->setUniform("_2dTextureParams._numChannels", static_cast<int>(texture->getNumChannels()));
235
236
        }
        else {
237
238
239
            // clamp current slice to texture size, since this can't be done in event handler:
            _currentSlice = tgt::clamp(_currentSlice, -1, texture->getDimensions().z);

240
241
242
            unit3d.activate();
            texture->bind();
            _paintShader->setUniform("_is3d", true);
243
            _paintShader->setUniform("_sliceNumber", p_currentSlice.getValue());
244
245
246
            _paintShader->setUniform("_3dTextureParams._size", tgt::vec3(texture->getDimensions()));
            _paintShader->setUniform("_3dTextureParams._sizeRCP", tgt::vec3(1.f) / tgt::vec3(texture->getDimensions()));
            _paintShader->setUniform("_3dTextureParams._numChannels", static_cast<int>(texture->getNumChannels()));
247
        }
248
249
        _paintShader->setIgnoreUniformLocationError(false);

250
        _quad->render(GL_POLYGON);
251
252
253
        LGL_ERROR;
    }

254
	void DataContainerInspectorCanvas::drawMeshGeomtery(const campvis::MeshGeometry* mg, tgt::Texture* colorBuffer, tgt::Texture* depthBuffer, const unsigned int& meshIndex)
255
256
257
258
259
260
    {
        LGL_ERROR;
        // Here the object will be rendered into a texture and the texture will be shown on the output buffer
		glPushAttrib(GL_ALL_ATTRIB_BITS);
		_geomteryRenderingShader->activate();
		LGL_ERROR;
261
		// _geomteryRenderingShader->setIgnoreUniformLocationError(true);
262
263
264
265
266
267
268
		LGL_ERROR;
		//decorateRenderProlog(data, _shader);
				
        //_trackballCamera->setPosition(tgt::vec3(0.0f, 0.0f, dist));
        //_trackballCamera->setFocus(tgt::vec3(0, 0, -1));
        //_trackballCamera->setFarDist(1000.0f);

269
        _trackballEHs[meshIndex]->setSceneBounds(mg->getWorldBounds());
270
271
				
		campvis::IVec4Property* p_color = new campvis::IVec4Property("myColor", "MyRenderingColor", tgt::vec4(1.f), tgt::vec4(0.f), tgt::vec4(1.f));
272
273
274
		
		tgt::mat4 myMat = _trackballEHs[meshIndex]->_trackball->getCamera()->getProjectionMatrix();
		myMat = _trackballEHs[meshIndex]->_trackball->getCamera()->getViewMatrix();
275

276
277
278
279
        _geomteryRenderingShader->setUniform("_projectionMatrix", _trackballEHs[meshIndex]->_trackball->getCamera()->getProjectionMatrix()/*_trackballCameraProperty->getValue().getProjectionMatrix()*/);
        _geomteryRenderingShader->setUniform("_viewMatrix", _trackballEHs[meshIndex]->_trackball->getCamera()->getViewMatrix());
		//_geomteryRenderingShader->setUniform("_colormory", p_color->getValue());
        //_geomteryRenderingShader->setUniform("_cameraPosition", _trackballEHs[meshIndex]->_trackball->getCamera()->getPosition());
280
281
282
283
284
285
286
287
288
289
290
291
292
293
		_geomteryRenderingShader->setIgnoreUniformLocationError(false);
						LGL_ERROR;
		tgt::FramebufferObject* frameBuffer = new tgt::FramebufferObject();
						LGL_ERROR;
		frameBuffer->activate();
		LGL_ERROR;

		// acqiure a new TextureUnit, so that we don't mess with other currently bound textures during texture upload...
		//tgt::TextureUnit rtUnit;
		//rtUnit.activate();

		// Set OpenGL pixel alignment to 1 to avoid problems with NPOT textures
		glPixelStorei(GL_UNPACK_ALIGNMENT, 1);

294
295
        colorBuffer->uploadTexture();
		colorBuffer->setWrapping(tgt::Texture::CLAMP_TO_EDGE);
296

297
298
		depthBuffer->uploadTexture();
		depthBuffer->setWrapping(tgt::Texture::CLAMP_TO_EDGE);
299
		LGL_ERROR;
300
301
		frameBuffer->attachTexture(colorBuffer, GL_COLOR_ATTACHMENT0);
		frameBuffer->attachTexture(depthBuffer, GL_DEPTH_ATTACHMENT);
302
303
304
		frameBuffer->isComplete();
		LGL_ERROR;

305
		glViewport(0, 0, _renderingWndSize.x, _renderingWndSize.y);
306
307
308
309
310
311
312
313
		glEnable(GL_DEPTH_TEST);
		glDepthFunc(GL_LESS);
		glClearDepth(1.0f);
		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
		LGL_ERROR;

        //for (std::map<QString, QtDataHandle>::iterator it = _handles.begin(); it != _handles.end(); ++it) {
        //    if (const campvis::MeshGeometry* mg = dynamic_cast<const campvis::MeshGeometry*>(it->second.getData())) {
314
315
316
        
		glPolygonMode(GL_FRONT, GL_POLYGON);
        //mg->render(GL_POLYGON);
317

318
        // Render wireframe around the object
319
320
321
322
323
324
325
326
327
        glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
        mg->render(GL_POLYGON);
       //     }
      //  }
		
		
        
        LGL_ERROR;

328
329
330
		colorBuffer->downloadTexture();
		depthBuffer->downloadTexture();

331
332
333
334
335
336
337
338
		frameBuffer->deactivate();
		LGL_ERROR;

		_geomteryRenderingShader->deactivate();

        glPopAttrib();

        //delete frameBuffer;
339
340
341
    }

    void DataContainerInspectorCanvas::invalidate() {
Christian Schulte zu Berge's avatar
Christian Schulte zu Berge committed
342
343
344
        // only if inited
        if (_quad != 0 && _paintShader != 0)
            GLJobProc.enqueueJob(this, makeJobOnHeap(this, &DataContainerInspectorCanvas::paint), OpenGLJobProcessor::PaintJob);
345
346
    }

347
348
349
350
351
352
353
	void DataContainerInspectorCanvas::invalidateMeshGeomTextures() {
        // only if inited
        if (_quad != 0 && _paintShader != 0)
			GLJobProc.enqueueJob(this, makeJobOnHeap(this, &DataContainerInspectorCanvas::paintMeshGeomTextures), OpenGLJobProcessor::PaintJob);
		//paintMeshGeomTextures();
    }

354
    void DataContainerInspectorCanvas::createQuad() {
355
356
        std::vector<tgt::vec3> vertices, texCorods;

357
        vertices.push_back(tgt::vec3(0.f,  0.f, 0.f));
358
359
        vertices.push_back(tgt::vec3(1.f, 0.f, 0.f));
        vertices.push_back(tgt::vec3(1.f, 1.f, 0.f));
360
        vertices.push_back(tgt::vec3(0.f,  1.f, 0.f));
361
362
363
364
365
366
367
368
369
370
        texCorods.push_back(tgt::vec3(0.f, 1.f, 0.f));
        texCorods.push_back(tgt::vec3(1.f, 1.f, 0.f));
        texCorods.push_back(tgt::vec3(1.f, 0.f, 0.f));
        texCorods.push_back(tgt::vec3(0.f, 0.f, 0.f));

        delete _quad;
        _quad = new FaceGeometry(vertices, texCorods);
        _quad->createGLBuffers();
    }

371
372
373
374
    void DataContainerInspectorCanvas::repaint() {
        invalidate();
    }

375
376
377
378
    void DataContainerInspectorCanvas::sizeChanged(const tgt::ivec2&) {
        invalidate();
    }

379
380
381
382
383
384
385
386
387
    void DataContainerInspectorCanvas::mouseDoubleClickEvent(tgt::MouseEvent* e) {
        if (_renderFullscreen) {
            _renderFullscreen = false;
        }
        else {
            tgt::ivec2 selectedIndex(e->x() / _quadSize.x, e->y() / _quadSize.y);
            _selectedTexture = (selectedIndex.y * _numTiles.x) + selectedIndex.x;
            _renderFullscreen = true;
        }
388
        e->ignore();
389
390
391
        invalidate();
    }

392
393
    void DataContainerInspectorCanvas::mouseMoveEvent(tgt::MouseEvent* e)
    {
394
        LGL_ERROR;
395
396
397
398
399
400
401
402
403
404
        /*if (_renderFullscreen) {
            _renderFullscreen = false;
        }
        else {
            tgt::ivec2 selectedIndex(e->x() / _quadSize.x, e->y() / _quadSize.y);
            _selectedTexture = (selectedIndex.y * _numTiles.x) + selectedIndex.x;
            _renderFullscreen = true;
        }
        e->ignore();
        invalidate();*/
405
        if(e->button() == tgt::MouseEvent::MOUSE_BUTTON_LEFT)
406
        {
407
408
409
410
411
412
413
414
415
416
            tgt::MouseEvent* me = static_cast<tgt::MouseEvent*>(e);

            tgt::MouseEvent adjustedMe(
                me->x(),
                me->y(),
                me->action(),
                me->modifiers(),
                me->button(),
                me->viewport() 
                );
417

418
419
420
421
422
423
424
425
426
			
			if(_selectedTrackball >= 0)
			{
				_trackballEHs[_selectedTrackball]->onEvent(&adjustedMe);

				_meshGeomTexturesDirty = true;
				invalidateMeshGeomTextures();
			}
            
427
428
429
        }
        else if(e->button() == tgt::MouseEvent::MOUSE_BUTTON_RIGHT)
        {
430
431
432
433
434
435
436
437
438
439
            tgt::ivec2 dimCanvas = tgt::ivec2(_quadSize.x * _numTiles.x, _quadSize.y * _numTiles.y);    
            if(e->x() >= dimCanvas.x || e->y() >= dimCanvas.y || e->x() < 0 || e->y() < 0)
                return;

            int texIndx = (e->y() / _quadSize.y) * _numTiles.x + (e->x() / _quadSize.x);
            const tgt::Texture* texturePtr = _textures[texIndx];
            const int texWidth  = texturePtr->getWidth();
            const int texHeight = texturePtr->getHeight();
            int cursorPosX = static_cast<int>(static_cast<float>(e->x() % _quadSize.x) / _quadSize.x * texWidth);
            int cursorPosY = static_cast<int>(static_cast<float>(e->y() % _quadSize.y) / _quadSize.y * texHeight);
440
441
442
443
444
445
446
447
448
449
450
451

			float f = 0.0;
			if(_textures[texIndx]->isDepthTexture())
			{
				_depth = _textures[texIndx]->depthAsFloat(cursorPosX, texHeight - cursorPosY - 1);
				_widget->updateDepth();
			}
			else
			{
				_color = _textures[texIndx]->texelAsFloat(cursorPosX, texHeight - cursorPosY - 1);
				_widget->updateColor();
			}      
452
        }
453
454
    }

455
456
457
458
459
460
461
462
463
464
465
466
    void DataContainerInspectorCanvas::wheelEvent(tgt::MouseEvent* e) {
        if (_renderFullscreen) {
            switch (e->button()) {
                case tgt::MouseEvent::MOUSE_WHEEL_UP:
                    ++_currentSlice; // we cant clamp the value here to the number of slices - we do this during rendering
                    e->ignore();
                    break;
                case tgt::MouseEvent::MOUSE_WHEEL_DOWN:
                    if (_currentSlice >= -1)
                        --_currentSlice;
                    e->ignore();
                    break;
467
468
                default:
                    break;
469
470
471
472
473
            }
            invalidate();
        }
    }

474
475
476
    void DataContainerInspectorCanvas::mousePressEvent(tgt::MouseEvent* e) {
        LGL_ERROR;
        //if (_renderFullscreen) {
477
478
479
480
481

			tgt::ivec2 selectedIndex(e->x() / _quadSize.x, e->y() / _quadSize.y);
			_selectedTrackball = -1;
			int geomTextureIndex = 0;

482
483
484
            switch (e->button()) {
            case tgt::MouseEvent::MOUSE_BUTTON_LEFT:
                    //++_currentSlice; // we cant clamp the value here to the number of slices - we do this during rendering
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500

				_selectedTexture = (selectedIndex.y * _numTiles.x) + selectedIndex.x;

				while(geomTextureIndex < _geomTextureIndices.size() && _geomTextureIndices[geomTextureIndex] <= _selectedTexture)
				{
					if(_geomTextureIndices[geomTextureIndex] == _selectedTexture)
					{
						_selectedTrackball = geomTextureIndex;
						break;
					}

					geomTextureIndex++;
				}

				if(_selectedTrackball >= 0)
					_trackballEHs[_selectedTrackball]->_trackball->startMouseDrag(e);
501
502
503
504
505
506
507
508
509
510
511
512
513
514
                   // e->ignore();
                    break;
                
                default:
                    break;
            }
        //}
    }

    void DataContainerInspectorCanvas::mouseReleaseEvent(tgt::MouseEvent* e) {
        if (_renderFullscreen) {
            switch (e->button()) {
            case tgt::MouseEvent::MOUSE_BUTTON_LEFT:
                    //++_currentSlice; // we cant clamp the value here to the number of slices - we do this during rendering
515
516
				if(_selectedTrackball >= 0)
                _trackballEHs[_selectedTrackball]->_trackball->endMouseDrag(e);
517
518
519
520
521
522
                   // e->ignore();
                    break;
                
                default:
                    break;
            }
523
            //invalidate();
524
525
526
        }
    }

527
528
529
530
531
532
533
534
535
536
537
538
539
    void DataContainerInspectorCanvas::onDataContainerChanged(const QString& key, QtDataHandle dh) {
        {
            tbb::mutex::scoped_lock lock(_localMutex);

            // check whether DataHandle is already existing
            std::map<QString, QtDataHandle>::iterator lb = _handles.lower_bound(key);
            if (lb == _handles.end() || lb->first != key) {
                // not existant -> do nothing
            }
            else {
                // existant -> replace
                lb->second = QtDataHandle(dh);
                // update _textures array
540
                _texturesDirty = true;
541
542
            }
        }
543
544
545

        if (_texturesDirty)
            invalidate();
546
547
548
549
550
551
552
553
554
    }

    void DataContainerInspectorCanvas::setDataHandles(const std::vector< std::pair<QString, QtDataHandle> >& handles) {
        {
            tbb::mutex::scoped_lock lock(_localMutex);
            _handles.clear();
            for (std::vector< std::pair<QString, QtDataHandle> >::const_iterator it = handles.begin(); it != handles.end(); ++it)
                _handles.insert(*it);

555
            _texturesDirty = true;
556
557
558
559
560
        }

        invalidate();
    }

561
562
563
564
    const tgt::Color& DataContainerInspectorCanvas::getCapturedColor()
    {
        return _color;
    }
565

566
567
568
569
570
	const float& DataContainerInspectorCanvas::getCapturedDepth()
    {
        return _depth;
    }

571
    void DataContainerInspectorCanvas::updateTextures() {
572
        /// Clear the textures Array
573
        _textures.clear();
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
		_geomTextureIndices.clear();

		/// Clear the geomtery rendered textures Array
		std::vector<TrackballNavigationEventListener*>::iterator trackballNavEHIterator = _trackballEHs.begin();
		for(; trackballNavEHIterator != _trackballEHs.end(); trackballNavEHIterator++)
		{
			delete (*trackballNavEHIterator);
		}
		_trackballEHs.clear();

        std::vector<campvis::CameraProperty*>::iterator camPropertyIterator = _trackballCameraProperties.begin();
		for(; camPropertyIterator != _trackballCameraProperties.end(); camPropertyIterator++)
		{
			delete (*camPropertyIterator);
		}
        _trackballCameraProperties.clear();
590

591
        /// Calculate the maximum slices of the textures and fill the textures array
592
        int maxSlices = 1;
593
		unsigned int nMeshGeometry = 0;
594
595
        for (std::map<QString, QtDataHandle>::iterator it = _handles.begin(); it != _handles.end(); ++it) {
            if (const ImageData* img = dynamic_cast<const ImageData*>(it->second.getData())) {
596
                if (const ImageRepresentationGL* imgGL = img->getRepresentation<ImageRepresentationGL>()) {
597
                    _textures.push_back(imgGL->getTexture());
598
                    maxSlices = std::max(maxSlices, imgGL->getTexture()->getDimensions().z);
599
600
                }
            }
601
602
603
604
            else if (const RenderData* rd = dynamic_cast<const RenderData*>(it->second.getData())) {
                for (size_t i = 0; i < rd->getNumColorTextures(); ++i) {
                    const ImageRepresentationGL* imgGL = rd->getColorTexture(i)->getRepresentation<ImageRepresentationGL>();
                    if (imgGL)
605
606
                    {
                        imgGL->downloadTexture();
607
                        _textures.push_back(imgGL->getTexture());
608
                    }
609
610
611
612
                }
                if (rd->hasDepthTexture()) {
                    const ImageRepresentationGL* imgGL = rd->getDepthTexture()->getRepresentation<ImageRepresentationGL>();
                    if (imgGL)
613
614
                    {
                        imgGL->downloadTexture();
615
                        _textures.push_back(imgGL->getTexture());
616
                    }
617
618
619

                }
            }
620
            else if(const campvis::MeshGeometry* mg = dynamic_cast<const campvis::MeshGeometry*>(it->second.getData())){
621
				
622
623
624
625
                LGL_ERROR;
                
                static bool flag = false;

626
627
628
629
630
631
				campvis::CameraProperty* cameraProperty = new CameraProperty("camera", "Camera");
				_trackballCameraProperties.push_back(cameraProperty);

                TrackballNavigationEventListener* trackballEH = new TrackballNavigationEventListener(cameraProperty, new IVec2Property("QuadSize", "Size", _renderingWndSize, tgt::ivec2(0), tgt::ivec2(1024)) );
                //if(!flag)
                //{
632
                    float dist = 3 * fabs(mg->getWorldBounds().getLLF().z - mg->getWorldBounds().getURB().z);
633
634
                    trackballEH->reinitializeCamera(mg->getWorldBounds());
                    trackballEH->_trackball->moveCameraBackward(dist);
635
                    flag = true;
636
637
638
639
640
641
642
643
644
645
646
647
                //}
				_trackballEHs.push_back(trackballEH);
				
				tgt::Texture* colorBuffer = new tgt::Texture(0, tgt::ivec3(_renderingWndSize.x, _renderingWndSize.y, 1), GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE, tgt::Texture::LINEAR);
				tgt::Texture* depthBuffer  = new tgt::Texture(0, tgt::ivec3(_renderingWndSize.x, _renderingWndSize.y, 1), GL_DEPTH_COMPONENT, GL_DEPTH_COMPONENT24, GL_FLOAT, tgt::Texture::LINEAR);

                drawMeshGeomtery(mg, colorBuffer, depthBuffer, nMeshGeometry++);
                
                _geomteryRendering_ColorBuffers.push_back(colorBuffer);
                _geomteryRendering_DepthBuffers.push_back(depthBuffer);
				_textures.push_back(colorBuffer);
				_geomTextureIndices.push_back(_textures.size() - 1);
648

649
            }else if(const campvis::FaceGeometry* fg = dynamic_cast<const campvis::FaceGeometry*>(it->second.getData())){
650
651


652
653
654
655
656
657
658
659
			}
        }

        if (maxSlices == 1)
            maxSlices = -1;
        p_currentSlice.setMaxValue(maxSlices);
        _texturesDirty = false;
    }
660

661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
	void DataContainerInspectorCanvas::updateMeshGeomRenderedTextures() {
        
		/// Calculate the maximum slices of the textures and fill the textures array
        int maxSlices = 1;
		unsigned int nMeshGeometry = 0;
		unsigned int nElement = 0;
        for (std::map<QString, QtDataHandle>::iterator it = _handles.begin(); it != _handles.end(); ++it) {
            if (const ImageData* img = dynamic_cast<const ImageData*>(it->second.getData())) {
                if (const ImageRepresentationGL* imgGL = img->getRepresentation<ImageRepresentationGL>()) {
                    nElement++;
                }
            }
            else if (const RenderData* rd = dynamic_cast<const RenderData*>(it->second.getData())) {
                for (size_t i = 0; i < rd->getNumColorTextures(); ++i) {
                    const ImageRepresentationGL* imgGL = rd->getColorTexture(i)->getRepresentation<ImageRepresentationGL>();
                    if (imgGL)
                    {
						nElement++;
                    }
                }
                if (rd->hasDepthTexture()) {
                    const ImageRepresentationGL* imgGL = rd->getDepthTexture()->getRepresentation<ImageRepresentationGL>();
                    if (imgGL)
                    {
                        nElement++;
                    }
                }
            }
            else if(const campvis::MeshGeometry* mg = dynamic_cast<const campvis::MeshGeometry*>(it->second.getData())){
				
                LGL_ERROR;
692
                
693
694
				tgt::Texture* colorBuffer = new tgt::Texture(0, tgt::ivec3(_renderingWndSize.x, _renderingWndSize.y, 1), GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE, tgt::Texture::LINEAR);
				tgt::Texture* depthBuffer  = new tgt::Texture(0, tgt::ivec3(_renderingWndSize.x, _renderingWndSize.y, 1), GL_DEPTH_COMPONENT, GL_DEPTH_COMPONENT24, GL_FLOAT, tgt::Texture::LINEAR);
695

696
697
698
699
700
701
702
703
704
705
                //_meshGeomteryPtr = mg;
				delete *(_textures.begin() + nElement);
				std::vector<const tgt::Texture*>::iterator erased = _textures.erase(_textures.begin() + nElement);

				_trackballCameraProperties[nMeshGeometry]->getValue();
				
                //drawMeshGeomtery(mg, _geomteryRendering_ColorBuffers[nMeshGeometry], _geomteryRendering_DepthBuffers[nMeshGeometry], nMeshGeometry);
                drawMeshGeomtery(mg, colorBuffer, depthBuffer, nMeshGeometry);
                nMeshGeometry++;
				_textures.insert(_textures.begin() + nElement, colorBuffer);
706

707
				nElement++;
708

709
710
711
            }else if(const campvis::FaceGeometry* fg = dynamic_cast<const campvis::FaceGeometry*>(it->second.getData())){

				
712
			}
713
        }
714
715
716
717

        if (maxSlices == 1)
            maxSlices = -1;
        p_currentSlice.setMaxValue(maxSlices);
718
        _texturesDirty = false;
719
720
721
722
723
724
725
    }

    void DataContainerInspectorCanvas::onPropertyChanged(const AbstractProperty* prop) {
        HasPropertyCollection::onPropertyChanged(prop);
        invalidate();
    }

726
}