abstractpipeline.cpp 10.3 KB
Newer Older
1

2
3
// ================================================================================================
// 
schultezub's avatar
schultezub committed
4
// This file is part of the CAMPVis Software Framework.
5
// 
6
// If not explicitly stated otherwise: Copyright (C) 2012-2014, all rights reserved,
schultezub's avatar
schultezub committed
7
//      Christian Schulte zu Berge <christian.szb@in.tum.de>
8
//      Chair for Computer Aided Medical Procedures
9
10
//      Technische Universitaet Muenchen
//      Boltzmannstr. 3, 85748 Garching b. Muenchen, Germany
11
// 
schultezub's avatar
schultezub committed
12
// For a full list of authors and contributors, please refer to the file "AUTHORS.txt".
13
// 
14
15
16
17
// Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file 
// except in compliance with the License. You may obtain a copy of the License at
// 
// http://www.apache.org/licenses/LICENSE-2.0
18
// 
19
20
21
22
// Unless required by applicable law or agreed to in writing, software distributed under the 
// License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, 
// either express or implied. See the License for the specific language governing permissions 
// and limitations under the License.
23
24
25
// 
// ================================================================================================

26
#include "abstractpipeline.h"
schultezub's avatar
schultezub committed
27

28
29
#include <tbb/tick_count.h>

schultezub's avatar
schultezub committed
30
#include "tgt/exception.h"
31
32
33
34
#include "tgt/glcanvas.h"
#include "tgt/tgt_gl.h"

#include "core/pipeline/visualizationprocessor.h"
35
#include "core/pipeline/abstractprocessor.h"
36
#include "core/tools/job.h"
37
#include "core/tools/opengljobprocessor.h"
38
#include "core/tools/simplejobprocessor.h"
39

40
41

#ifdef CAMPVIS_DEBUG
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
// Anonymous OpenGL helper functions
namespace {
    GLboolean getGlBool(GLenum param) {
        GLboolean toReturn;
        glGetBooleanv(param, &toReturn);
        return toReturn;
    };

    GLint getGlInt(GLenum param) {
        GLint toReturn;
        glGetIntegerv(param, &toReturn);
        return toReturn;
    };

    GLfloat getGlFloat(GLenum param) {
        GLfloat toReturn;
        glGetFloatv(param, &toReturn);
        return toReturn;
    }
}
62
#endif
63

64

schultezub's avatar
schultezub committed
65
66
namespace campvis {
    const std::string AbstractPipeline::loggerCat_ = "CAMPVis.core.datastructures.AbstractPipeline";
67

68
    AbstractPipeline::AbstractPipeline(DataContainer* dc) 
69
        : HasPropertyCollection()
70
71
        , tgt::EventHandler()
        , tgt::EventListener()
72
        , _data(dc)
73
74
75
76
        , _canvas(0)
        , _canvasSize("CanvasSize", "Canvas Size", tgt::ivec2(128, 128), tgt::ivec2(1, 1), tgt::ivec2(4096, 4096))
        , _ignoreCanvasSizeUpdate(false)
        , _renderTargetID("renderTargetID", "Render Target ID", "AbstractPipeline.renderTarget", DataNameProperty::READ)
schultezub's avatar
   
schultezub committed
77
    {
78
79
        tgtAssert(_data != 0, "Pointer to the DataContainer for this pipeline must not be 0!");

80
        _enabled = false;
81

82
83
        addProperty(_renderTargetID);
        addProperty(_canvasSize);
schultezub's avatar
   
schultezub committed
84
85
86
87
88
    }

    AbstractPipeline::~AbstractPipeline() {
    }

89
    void AbstractPipeline::init() {
90
        _renderTargetID.s_changed.connect<AbstractPipeline>(this, &AbstractPipeline::onPropertyChanged);
91
        _data->s_dataAdded.connect(this, &AbstractPipeline::onDataContainerDataAdded);
92

schultezub's avatar
schultezub committed
93
94
        initAllProperties();

95
        // initialize all processors:
schultezub's avatar
schultezub committed
96
97
98
99
100
101
102
103
        for (std::vector<AbstractProcessor*>::iterator it = _processors.begin(); it != _processors.end(); ++it) {
            try {
                (*it)->init();
            }
            catch (tgt::Exception& e) {
                LERROR("Caught Exception during initialization of processor: " << e.what());
            }
        }
104
    }
schultezub's avatar
schultezub committed
105

106
    void AbstractPipeline::deinit() {
schultezub's avatar
schultezub committed
107
108
        deinitAllProperties();

109
110
111
        // deinitialize all processors:
        for (std::vector<AbstractProcessor*>::iterator it = _processors.begin(); it != _processors.end(); ++it) {
            try {
schultezub's avatar
schultezub committed
112
                (*it)->s_invalidated.disconnect(this);
113
114
115
116
117
118
                (*it)->deinit();
            }
            catch (tgt::Exception& e) {
                LERROR("Caught Exception during deinitialization of processor: " << e.what());
            }
        }
119

120
        _data->s_dataAdded.disconnect(this);
121
122
        _renderTargetID.s_changed.disconnect(this);

123
        // clear DataContainer
124
        _data->clear();
125
126
    }

schultezub's avatar
schultezub committed
127
    void AbstractPipeline::onPropertyChanged(const AbstractProperty* prop) {
128
        if (prop == &_renderTargetID) {
129
            s_renderTargetChanged.emitSignal();
130
131
132
133
134
135
136
137
        }
        else if (prop == &_canvasSize && _canvas != 0 && !_ignoreCanvasSizeUpdate) {
            if (_canvasSize.getValue() != _canvas->getSize()) {
                _ignoreCanvasSizeUpdate = true;
                _canvas->setSize(_canvasSize.getValue());
                _ignoreCanvasSizeUpdate = false;
            }
        }
schultezub's avatar
schultezub committed
138
139
140
    }

    const DataContainer& AbstractPipeline::getDataContainer() const {
141
        return *_data;
schultezub's avatar
schultezub committed
142
143
    }

144
    DataContainer& AbstractPipeline::getDataContainer() {
145
        return *_data;
146
147
    }

148
    void AbstractPipeline::executeProcessor(AbstractProcessor* processor) {
149
150
        tgtAssert(processor != 0, "Processor must not be 0.");

151
        // execute processor if needed
152
        if (processor->getEnabled() && !processor->isLocked()) {
153
            if (! processor->isValid()) {
154
155
156
                tbb::tick_count startTime;
                if (processor->getClockExecutionTime())
                    startTime = tbb::tick_count::now();
157
158

                try {
159
                    processor->process(*_data);
160
161
162
163
164
165
166
167
168
                }
                catch (std::exception& e) {
                    LERROR("Caught unhandled exception while executing processor " << processor->getName() << ": " << e.what());
                }
                catch (...) {
                    LERROR("Caught unhandled exception while executing processor " << processor->getName() << ": unknown exception");
                }

                if (processor->getClockExecutionTime()) {
169
170
                    tbb::tick_count endTime = tbb::tick_count::now();
                    LINFO("Executed processor " << processor->getName() << " duration: " << (endTime - startTime).seconds());
171
                }
172
            }
173
        }
174
175
    }

176
177
178
179
    const std::vector<AbstractProcessor*>& AbstractPipeline::getProcessors() const {
        return _processors;
    }

180
181
182
183
184
185
186
187
    bool AbstractPipeline::getEnabled() const {
        return _enabled;
    }

    void AbstractPipeline::setEnabled(bool enabled) {
        _enabled = enabled;
    }

188
189
190
    void AbstractPipeline::onEvent(tgt::Event* e) {
        // copy and paste from tgt::EventHandler::onEvent() but without deleting e
        for (size_t i = 0 ; i < listeners_.size() ; ++i) {
Christian Schulte zu Berge's avatar
Christian Schulte zu Berge committed
191
192
193
194
            // don't forward this event to ourselves - otherwise we'll end up with an endless loop.
            if (listeners_[i] == this) {
                tgt::EventListener::onEvent(e);
            }
195
            // check if current listener listens to the eventType of e
Christian Schulte zu Berge's avatar
Christian Schulte zu Berge committed
196
            else if (listeners_[i]->getEventTypes() & e->getEventType() ){
197
198
                listeners_[i]->onEvent(e);
            }
Christian Schulte zu Berge's avatar
Christian Schulte zu Berge committed
199
200
201

            if (e->isAccepted())
                break;
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
        }
    }

    void AbstractPipeline::setCanvas(tgt::GLCanvas* canvas) {
        _canvas = canvas;
    }

    void AbstractPipeline::setRenderTargetSize(const tgt::ivec2& size) {
        if (_canvasSize.getValue() != size && !_ignoreCanvasSizeUpdate) {
            _canvasSize.setValue(size);
        }
    }

    const tgt::ivec2& AbstractPipeline::getRenderTargetSize() const {
        return _canvasSize.getValue();
    }

    const std::string& AbstractPipeline::getRenderTargetID() const {
        return _renderTargetID.getValue();
    }

223
    void AbstractPipeline::addProcessor(AbstractProcessor* processor) {
schultezub's avatar
schultezub committed
224
        tgtAssert(processor != 0, "Processor must not be 0.")
225
226
        _processors.push_back(processor);
    }
227

228
229
230
231
    void AbstractPipeline::lockGLContextAndExecuteProcessor(AbstractProcessor* processor) {
        tgtAssert(_canvas != 0, "Set a valid canvas before calling this method!");
        GLJobProc.enqueueJob(
            _canvas, 
232
            makeJobOnHeap<AbstractPipeline, AbstractProcessor*>(this, &AbstractPipeline::executeProcessor, processor),
233
234
235
236
            OpenGLJobProcessor::SerialJob);
    }

    void AbstractPipeline::executeProcessorAndCheckOpenGLState(AbstractProcessor* processor) {
237
        AbstractPipeline::executeProcessor(processor);
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259

#ifdef CAMPVIS_DEBUG
        tgtAssert(getGlBool(GL_DEPTH_TEST) == false, "Invalid OpenGL state after processor execution, GL_DEPTH_TEST != false.");
        tgtAssert(getGlBool(GL_SCISSOR_TEST) == false, "Invalid OpenGL state after processor execution, GL_SCISSOR_TEST != false.");

        tgtAssert(getGlInt(GL_CULL_FACE_MODE) == GL_BACK, "Invalid OpenGL state after processor execution, GL_CULL_FACE_MODE != GL_BACk.");
        tgtAssert(getGlInt(GL_DEPTH_FUNC) == GL_LESS, "Invalid OpenGL state after processor execution, GL_DEPTH_FUNC != GL_LESS.");

        tgtAssert(getGlFloat(GL_DEPTH_CLEAR_VALUE) == 1.f, "Invalid OpenGL state after processor execution, GL_DEPTH_CLEAR_VALUE != 1.f.");

        tgtAssert(getGlFloat(GL_RED_SCALE) == 1.f, "Invalid OpenGL state after processor execution, GL_RED_SCALE != 1.f.");
        tgtAssert(getGlFloat(GL_GREEN_SCALE) == 1.f, "Invalid OpenGL state after processor execution, GL_GREEN_SCALE != 1.f.");
        tgtAssert(getGlFloat(GL_BLUE_SCALE) == 1.f, "Invalid OpenGL state after processor execution, GL_BLUE_SCALE != 1.f.");
        tgtAssert(getGlFloat(GL_ALPHA_SCALE) == 1.f, "Invalid OpenGL state after processor execution, GL_ALPHA_SCALE != 1.f.");

        tgtAssert(getGlFloat(GL_RED_BIAS) == 0.f, "Invalid OpenGL state after processor execution, GL_RED_BIAS != 0.f.");
        tgtAssert(getGlFloat(GL_GREEN_BIAS) == 0.f, "Invalid OpenGL state after processor execution, GL_GREEN_BIAS != 0.f.");
        tgtAssert(getGlFloat(GL_BLUE_BIAS) == 0.f, "Invalid OpenGL state after processor execution, GL_BLUE_BIAS != 0.f.");
        tgtAssert(getGlFloat(GL_ALPHA_BIAS) == 0.f, "Invalid OpenGL state after processor execution, GL_ALPHA_BIAS != 0.f.");
#endif
    }

260
    void AbstractPipeline::onDataContainerDataAdded(std::string name, DataHandle dh) {
261
        if (name == _renderTargetID.getValue()) {
262
            s_renderTargetChanged.emitSignal();
263
264
265
266
        }
    }


267

268
}