Currently job artifacts in CI/CD pipelines on LRZ GitLab never expire. Starting from Wed 26.1.2022 the default expiration time will be 30 days (GitLab default). Currently existing artifacts in already completed jobs will not be affected by the change. The latest artifacts for all jobs in the latest successful pipelines will be kept. More information: https://gitlab.lrz.de/help/user/admin_area/settings/continuous_integration.html#default-artifacts-expiration

campvis.i 21.9 KB
Newer Older
1
%module campvis
2

3
%include factory.i
4
%include std_pair.i
5
%include std_string.i
6
7
%include std_vector.i

8
%import "ext/cgt/bindings/cgt.i"
9
%include "ext/sigslot/sigslot.i"
10

11
%{
12
#include "core/datastructures/abstractdata.h"
13
#include "core/datastructures/dataseries.h"
14
#include "core/datastructures/imagedata.h"
15
#include "core/datastructures/imagerepresentationlocal.h"
16
#include "core/properties/allproperties.h"
17
#include "core/pipeline/abstractprocessor.h"
18
#include "core/pipeline/abstractworkflow.h"
19
#include "core/pipeline/autoevaluationpipeline.h"
20
21
#include "core/pipeline/pipelinefactory.h"
#include "core/pipeline/processorfactory.h"
22
#include "core/pipeline/visualizationprocessor.h"
23
#include "core/classification/tfgeometry1d.h"
24
#include "core/classification/tfgeometry2d.h"
25
#include "core/classification/geometry1dtransferfunction.h"
26
27
#include "core/classification/simpletransferfunction.h"
#include "core/classification/geometry2dtransferfunction.h"
28
29
30
%}


31
32
33
34
35
36
%inline {
static const char* const SOURCE_DIR = CAMPVIS_SOURCE_DIR;

// Template specialisations and instantiations required to get signals to work in Lua
namespace sigslot {
    template<>
37
    struct LuaConnectionArgTraits<campvis::AbstractProcessor*> { static const char* const typeName; };
38
    const char* const LuaConnectionArgTraits<campvis::AbstractProcessor*>::typeName = "campvis::AbstractProcessor *";
39
40
41
42
43
44
45
46

    template<>
    struct LuaConnectionArgTraits<campvis::DataHandle> { static const char* const typeName; };
    const char* const LuaConnectionArgTraits<campvis::DataHandle>::typeName = "campvis::DataHandle *";

    template<>
    struct LuaConnectionArgTraits<std::string> { static const char* const typeName; };
    const char* const LuaConnectionArgTraits<std::string>::typeName = "std::string *";
47
48
49
50
51
}
}


%template(sigslot_signal1_AbstractProcessor) sigslot::signal1<campvis::AbstractProcessor*>;
52
%template(sigslot_signal2_string_DataHandle) sigslot::signal2<std::string, campvis::DataHandle>;
53

54
55
%template(PairStringDataHandle) std::pair<std::string, campvis::DataHandle>;
%template(VectorOfPairStringDataHandle) std::vector< std::pair< std::string, campvis::DataHandle> >;
56
%template(VectorOfString) std::vector< std::string >;
57

58
namespace campvis {
59
60

    class AbstractProperty {
61
    public:
62
        AbstractProperty(const std::string& name, const std::string& title);
63
        virtual ~AbstractProperty();
64

65
66
        virtual void init();
        virtual void deinit();
67

68
69
        const std::string& getName() const;
        const std::string& getTitle() const;
70

71
72
73
74
        bool isVisible() const;
        void setVisible(bool isVisible);

        virtual void addSharedProperty(AbstractProperty* prop);
75
    };
76

77
78
79
80
81
82
83
84
85
86
    class ButtonProperty : public AbstractProperty {
    public:
        ButtonProperty(const std::string& name, const std::string& title);
        virtual ~ButtonProperty();

        void click();

        sigslot::signal0 s_clicked;
    };

87
88
    template<typename T>
    class GenericProperty : public AbstractProperty {
89
    public:
90
        GenericProperty(const std::string& name, const std::string& title, const T& value);
91
92
93
94
        virtual ~GenericProperty();

        const T& getValue() const;
        virtual void setValue(const T& value);
95
96
    };

97
98
99
    %template(BoolProperty) GenericProperty<bool>;
    typedef GenericProperty<bool> BoolProperty;

100
101
102
    %template(StringProperty) GenericProperty<std::string>;
    typedef GenericProperty<std::string> StringProperty;

103
104
    /* DataNameProperty */

105
106
107
108
109
110
111
112
    class DataNameProperty : public StringProperty {
    public:
        enum DataAccessInfo {
            READ,
            WRITE
        };

        DataNameProperty(const std::string& name, const std::string& title, const std::string& value,
113
                         DataAccessInfo access);
114
115
116
        virtual ~DataNameProperty();
    };

117
    /* NumericProperty */
118
119

    template<typename T>
120
    class NumericProperty : public GenericProperty<T> {
121
122
123
124
125
126
127
    public:
        NumericProperty(
            const std::string& name,
            const std::string& title,
            const T& value,
            const T& minValue,
            const T& maxValue,
128
            const T& stepValue = T(1));
129
130
131
132

        virtual ~NumericProperty();
    };

Hossain Mahmud's avatar
Hossain Mahmud committed
133
    
134
135
136
137
    %template(IntGenericProperty) GenericProperty< int >;
    %template(IntProperty) NumericProperty< int >;
    typedef NumericProperty< int > IntProperty;

138
139
140
    %template(Ivec2GenericProperty) GenericProperty< cgt::Vector2<int> >;
    %template(IVec2Property) NumericProperty< cgt::Vector2<int> >;
    typedef NumericProperty< cgt::Vector2<int> > IVec2Property;
141

142
143
144
145
146
147
148
149
150
151
    %template(Ivec3GenericProperty) GenericProperty< cgt::Vector3<int> >;
    %template(IVec3Property) NumericProperty< cgt::Vector3<int> >;
    typedef NumericProperty< cgt::Vector3<int> > IVec3Property;

    %template(Ivec4GenericProperty) GenericProperty< cgt::Vector4<int> >;
    %template(IVec4Property) NumericProperty< cgt::Vector4<int> >;
    typedef NumericProperty< cgt::Vector4<int> > IVec4Property;



152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
    template<typename T>
    struct FloatingPointPropertyTraits {};

    template<>
    struct FloatingPointPropertyTraits<float> {
        typedef int DecimalsType;
    };

    %template() FloatingPointPropertyTraits<float>;

    template<typename T>
    class FloatingPointProperty : public NumericProperty<T> {
    public:
        typedef typename FloatingPointPropertyTraits<T>::DecimalsType DecimalsType;

        FloatingPointProperty(
            const std::string& name,
            const std::string& title,
            const T& value,
            const T& minValue,
            const T& maxValue,
            const T& stepValue = T(0.01f),
174
            const DecimalsType& decimals = DecimalsType(3));
175
176
177
178
179
180
181
182
183

        virtual ~FloatingPointProperty();
    };

    %template(FloatGenericProperty) GenericProperty<float>;
    %template(FloatNumericProperty) NumericProperty<float>;
    %template(FloatProperty) FloatingPointProperty<float>;
    typedef FloatingPointProperty< float > FloatProperty;

184
185
186
187
188
189
190
191
192
193
194
195
196
197
    %template(Vec2GenericProperty) GenericProperty< cgt::Vector2<float> >;
    %template(Vec2NumericProperty) NumericProperty< cgt::Vector2<float> >;
    %template(Vec2Property) FloatingPointProperty< cgt::Vector2<float> >;
    typedef FloatingPointProperty< cgt::Vector2<float> > Vec2Property;

    %template(Vec3GenericProperty) GenericProperty< cgt::Vector3<float> >;
    %template(Vec3NumericProperty) NumericProperty< cgt::Vector3<float> >;
    %template(Vec3Property) FloatingPointProperty< cgt::Vector3<float> >;
    typedef FloatingPointProperty< cgt::Vector3<float> > Vec3Property;

    %template(Vec4GenericProperty) GenericProperty< cgt::Vector4<float> >;
    %template(Vec4NumericProperty) NumericProperty< cgt::Vector4<float> >;
    %template(Vec4Property) FloatingPointProperty< cgt::Vector4<float> >;
    typedef FloatingPointProperty< cgt::Vector4<float> > Vec4Property;
198

Hossain Mahmud's avatar
Hossain Mahmud committed
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
    /* OptionProperty */
        
    class AbstractOptionProperty : public IntProperty {
    public:
        AbstractOptionProperty(const std::string& name, const std::string& title);
        virtual ~AbstractOptionProperty();
        virtual const std::string& getOptionId() = 0;
        virtual void selectById(const std::string& id) = 0;
    };

    template<typename T>
    class GenericOptionProperty : public AbstractOptionProperty {
    public:		
        GenericOptionProperty(
            const std::string& name, 
            const std::string& title, 
            const GenericOption<T>* options,
            int count);		
        virtual ~GenericOptionProperty();		
        const std::string& getOptionId();
        void selectById(const std::string& id);
    };

222
223
224
225
226
227
228
    /* TFGeometry1D */

    %nodefaultctor TFGeometry1D;

    class TFGeometry1D {
    public:
        virtual ~TFGeometry1D();
229
        static TFGeometry1D* createQuad(const cgt::vec2& interval, const cgt::col4& leftColor, const cgt::col4& rightColor);
230
231
232
    
        void addKeyPoint(float position, float alpha);
        void addKeyPoint(float position, const cgt::col4& color);
233
234
235
236
237
238
239
240
241
242
    };

    /* TFGeometry2D */

    %nodefaultctor TFGeometry2D;

    class TFGeometry2D {
    public:
        virtual ~TFGeometry2D();
        static TFGeometry2D* createQuad(const cgt::vec2& ll, const cgt::vec2& ur, const cgt::col4& color);
243
244
245
246
247
248
    };

    /* AbstractTransferFunction */

    class AbstractTransferFunction {
    public:
249
        AbstractTransferFunction(const cgt::svec3& size, const cgt::vec2& intensityDomain = cgt::vec2(0.f, 1.f));
250
251
252
253
254
        virtual ~AbstractTransferFunction();

        virtual AbstractTransferFunction* clone() const = 0;
    };

255
256
257
258
259
260
    /* SimpleTransferFunction */
    class SimpleTransferFunction : public AbstractTransferFunction {
    public: 
        SimpleTransferFunction(size_t size, const cgt::vec2& intensityDomain = cgt::vec2(0.f, 1.f));
        virtual ~SimpleTransferFunction();
        virtual SimpleTransferFunction* clone() const;
261
262
        void setLeftColor(const cgt::col4& color);
        void setRightColor(const cgt::col4& color);
263
264
265

    };

266
267
268
269
270
    /* GenericGeometryTransferFunction */

    template<class T>
    class GenericGeometryTransferFunction : public AbstractTransferFunction {
    public:
271
        GenericGeometryTransferFunction(const cgt::vec3& size, const cgt::vec2& intensityDomain = cgt::vec2(0.f, 1.f));
272
273
        virtual ~GenericGeometryTransferFunction();

274
        %apply SWIGTYPE *DISOWN {T* geometry};
275
        void addGeometry(T* geometry);
276
        %clear T* geometry;
277
    };
278
    
279
280
281
282
283
284
    /* Geometry1DTransferFunction */

    %template(GenericGeometryTransferFunction_TFGeometry1D) GenericGeometryTransferFunction<TFGeometry1D>;

    class Geometry1DTransferFunction : public GenericGeometryTransferFunction<TFGeometry1D> {
    public:
285
        Geometry1DTransferFunction(size_t size, const cgt::vec2& intensityDomain = cgt::vec2(0.f, 1.f));
286
287
288
289
290
        virtual ~Geometry1DTransferFunction();

        virtual Geometry1DTransferFunction* clone() const;
    };

291
292
293
294
295
296
297
298
299
300
301
302
    /* Geometry2DTransferFunction */

    %template(GenericGeometryTransferFunction_TFGeometry2D) GenericGeometryTransferFunction<TFGeometry2D>;

    class Geometry2DTransferFunction : public GenericGeometryTransferFunction<TFGeometry2D> {
    public:
        Geometry2DTransferFunction(const cgt::svec2& size, const cgt::vec2& intensityDomain = cgt::vec2(0.f, 1.f));
        virtual ~Geometry2DTransferFunction();

        virtual Geometry2DTransferFunction* clone() const;
    };

303
304
305
306
    /* TransferFunctionProperty */

    class TransferFunctionProperty : public AbstractProperty {
    public:
307
        %apply SWIGTYPE *DISOWN {AbstractTransferFunction* tf};
308
        TransferFunctionProperty(const std::string& name, const std::string& title, AbstractTransferFunction* tf);
309
310
311
312
        virtual ~TransferFunctionProperty();

        AbstractTransferFunction* getTF();
        void replaceTF(AbstractTransferFunction* tf);
313
        %clear AbstractTransferFunction* tf;
314
315
    };

316
317
318
319
320
321
322
    /* IHasWorldBounds */

    class IHasWorldBounds {
    public:
        IHasWorldBounds();
        virtual ~IHasWorldBounds();

323
        virtual cgt::Bounds getWorldBounds() const = 0;
324
325
326
327
328
329
330
331
332
    };

    /* AbstractData */

    class AbstractData {
    public:
        AbstractData();
        virtual ~AbstractData();

333
334
        virtual size_t getLocalMemoryFootprint() const = 0;
        virtual size_t getVideoMemoryFootprint() const = 0;
335
336
        virtual AbstractData* clone() const = 0;
    };
337
    
338
339
    /* DataHandle */

340
341
342
    /* Downcast the return value of DataHandle::getData to appropriate subclass */
    %factory(const AbstractData* campvis::DataHandle::getData, const campvis::ImageData);

343
    %apply SWIGTYPE *DISOWN {AbstractData* data};
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
    class DataHandle {
    public:
        explicit DataHandle(AbstractData* data = 0);
        DataHandle(const DataHandle& rhs);
        DataHandle& operator=(const DataHandle& rhs);
        virtual ~DataHandle();

        const AbstractData* getData() const;
    };

    /* DataSeries */

    class DataSeries : public AbstractData {
    public:
        DataSeries();
        virtual ~DataSeries();
        virtual DataSeries* clone() const;
        
        void addData(AbstractData* data);
        void addData(DataHandle dh);

        size_t getNumDatas() const;
        DataHandle getData(size_t index) const;

    protected:
        std::vector<DataHandle> _data;    ///< the images of this series
    };
371
372
373
374
375

    /* ImageData */

    class ImageData : public AbstractData, public IHasWorldBounds {
    public:
376
        ImageData(size_t dimensionality, const cgt::svec3& size, size_t numChannels);
377
378
        virtual ~ImageData();

379
380
381
382
383
384
385
386
387
388
        virtual AbstractData* clone() const;
        virtual size_t getLocalMemoryFootprint() const;
        virtual size_t getVideoMemoryFootprint() const;
        virtual std::string getTypeAsString() const;

        size_t getDimensionality() const;
        const cgt::svec3& getSize() const;
        size_t getNumChannels() const;
        size_t getNumElements() const;

389
        virtual cgt::Bounds getWorldBounds() const;
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
        cgt::Bounds getWorldBounds(const cgt::svec3& llf, const cgt::svec3& urb) const;

        size_t positionToIndex(const cgt::svec3& position) const;
        cgt::svec3 indexToPosition(size_t index) const;

        template<typename T>
        const T* getRepresentation(bool performConversion = true) const;
    };

    %template(getRepresentationLocal) ImageData::getRepresentation<campvis::ImageRepresentationLocal>;

    struct WeaklyTypedPointer {
        enum BaseType {
            UINT8,      ///< unsigned 8 bit integer
            INT8,       ///< signed 8 bit integer
            UINT16,     ///< unsigned 16 bit integer
            INT16,      ///< signed 16 bit integer
            UINT32,     ///< unsigned 32 bit integer
            INT32,      ///< signed 32 bit integer
            FLOAT      ///< float
        };
        static size_t numBytes(BaseType bt, size_t numChannels = 1);

        WeaklyTypedPointer(BaseType pt, size_t numChannels, void* ptr);
        WeaklyTypedPointer();
        virtual ~WeaklyTypedPointer();

        bool operator==(const WeaklyTypedPointer& rhs) const;

        size_t getNumBytesPerElement() const;
        GLint getGlFormat() const;
        GLenum getGlDataType() const;
        GLint getGlInternalFormat() const;
        bool isInteger() const;
        bool isSigned() const;

        BaseType _baseType;         ///< Base data type of the pointer
        size_t _numChannels;        ///< Number of channels, must be in [1, 4]!
        void* _pointer;             ///< Pointer to the data
    };

    /* AbstractImageRepresentation */
    %nodefaultctor AbstractImageRepresentation;
    class AbstractImageRepresentation {
    public:
        virtual ~AbstractImageRepresentation();

        const ImageData* getParent() const;

        size_t getDimensionality() const;
        const cgt::svec3& getSize() const;
        size_t getNumElements() const;

    private:
        explicit AbstractImageRepresentation(const AbstractImageRepresentation& rhs);
        AbstractImageRepresentation& operator=(const AbstractImageRepresentation& rhs);
446
447
    };

448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475

    /* ImageRepresentationLocal */
    %nodefaultctor ImageRepresentationLocal;
    class ImageRepresentationLocal : public AbstractImageRepresentation {
    public:
        virtual ~ImageRepresentationLocal();

        static ImageRepresentationLocal* create(const ImageData* parent, WeaklyTypedPointer wtp);

        virtual const WeaklyTypedPointer getWeaklyTypedPointer() const = 0;
        virtual float getElementNormalized(size_t index, size_t channel) const = 0;

        virtual float getElementNormalized(const cgt::svec3& position, size_t channel) const = 0;
        virtual float getElementNormalizedLinear(const cgt::vec3& position, size_t channel) const = 0;

        virtual void setElementNormalized(size_t index, size_t channel, float value) = 0;
        virtual void setElementNormalized(const cgt::svec3& position, size_t channel, float value) = 0;
        
    protected:
        ImageRepresentationLocal(ImageData* parent, WeaklyTypedPointer::BaseType baseType);

    private:
        explicit ImageRepresentationLocal(const ImageRepresentationLocal& rhs);
        ImageRepresentationLocal& operator=(const ImageRepresentationLocal& rhs);
    };



476
477
478
479
480
481
482
483
484
485
486
487
488
    /* DataContainer */

    class DataContainer {
    public:
        DataContainer(const std::string& name);
        ~DataContainer();

        DataHandle addData(const std::string& name, AbstractData* data);
        void addDataHandle(const std::string& name, const DataHandle& dh);
        bool hasData(const std::string& name) const;
        DataHandle getData(const std::string& name) const;
        void removeData(const std::string& name);
        void clear();
489

490
491
        std::vector< std::pair< std::string, DataHandle> > getDataHandlesCopy() const;

492
493
        %immutable;
        sigslot::signal0 s_changed;
494
        sigslot::signal2<std::string, DataHandle> s_dataAdded;
495
        %mutable;
496
    };
497
498

    %clear AbstractData* data;
Hossain Mahmud's avatar
Hossain Mahmud committed
499
500
501
502
503
    
    /* Down casting or super classes.
     * Down casting follows the order of declaration.
     * Declare the classes as child first according to the class hierarchy.
     */
504
505
506

    /* Downcast the return value of HasPropertyCollection::getProperty to appropriate subclass */
    %factory(AbstractProperty* campvis::HasPropertyCollection::getProperty,
Hossain Mahmud's avatar
Hossain Mahmud committed
507
             campvis::AbstractOptionProperty, campvis::IntProperty, campvis::IVec2Property, campvis::IVec3Property, campvis::IVec4Property,
508
             campvis::FloatProperty, campvis::Vec2Property, campvis::Vec3Property, campvis::Vec4Property,
509
             campvis::TransferFunctionProperty,
510
             campvis::DataNameProperty, campvis::StringProperty, campvis::ButtonProperty, campvis::BoolProperty);
511
512
513

    /* Downcast the return value of HasPropertyCollection::getNestedProperty to appropriate subclass */
    %factory(AbstractProperty* campvis::HasPropertyCollection::getNestedProperty,
Hossain Mahmud's avatar
Hossain Mahmud committed
514
             campvis::AbstractOptionProperty, campvis::IntProperty, campvis::IVec2Property, campvis::IVec3Property, campvis::IVec4Property,
515
             campvis::FloatProperty, campvis::Vec2Property, campvis::Vec3Property, campvis::Vec4Property,
516
             campvis::TransferFunctionProperty,
517
             campvis::DataNameProperty, campvis::StringProperty, campvis::ButtonProperty, campvis::BoolProperty);
518
519
520
521
522
523
524
525

    /* HasPropertyCollection */

    class HasPropertyCollection  {
    public:
        HasPropertyCollection();
        virtual ~HasPropertyCollection() = 0;

526
527
        virtual void addProperty(AbstractProperty& prop);
        void removeProperty(AbstractProperty& prop);
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
        AbstractProperty* getProperty(const std::string& name) const;
        AbstractProperty* getNestedProperty(const std::string& name) const;
    };

    /* AbstractProcessor */

    class AbstractProcessor : public HasPropertyCollection {
    public:
        enum InvalidationLevel {
            VALID               = 0,
            INVALID_RESULT      = 1 << 0,
            INVALID_SHADER      = 1 << 1,
            INVALID_PROPERTIES  = 1 << 2,
            FIRST_FREE_TO_USE_INVALIDATION_LEVEL = 1 << 3
        };

        const std::string getName() const = 0;
545
546
        void addProperty(AbstractProperty& prop, int invalidationLevel);
        void setPropertyInvalidationLevel(AbstractProperty& prop, int invalidationLevel);
547

548
        void process(DataContainer& data);
549

550
551
        %immutable;
        sigslot::signal1<AbstractProcessor*> s_validated;
552
        sigslot::signal1<AbstractProcessor*> s_invalidated;
553
        %mutable;
554
555
556
557
558
559
    };

    /* AbstractPipeline */

    class AbstractPipeline : public HasPropertyCollection {
    public:
560
        AbstractPipeline(DataContainer& dc);
561
562
        virtual ~AbstractPipeline();

563
        virtual std::string getName() const = 0;
564
565
566

        const DataContainer& getDataContainer() const;
        DataContainer& getDataContainer();
Hossain Mahmud's avatar
Hossain Mahmud committed
567
        
568
569
        virtual void addProcessor(AbstractProcessor* processor);
        virtual void executePipeline() = 0;
570
        AbstractProcessor* getProcessor(const std::string& name) const;
571
        AbstractProcessor* getProcessor(size_t index) const;
572

573
        %immutable;
574
575
        sigslot::signal0 s_init;
        sigslot::signal0 s_deinit;
576
        %mutable;
577
578
579
580
581
582
    };

    /* AutoEvaluationPipeline */

    class AutoEvaluationPipeline : public AbstractPipeline {
    public:
583
584
585
586
        AutoEvaluationPipeline(DataContainer& dataContainer, const std::string& pipelineName);
        virtual ~AutoEvaluationPipeline();
        
        std::string getName() const;
587
588
        virtual void addProcessor(AbstractProcessor* processor);

589
        void addEventListenerToBack(cgt::EventListener* e);
590
        virtual void executePipeline();
591
    };
592

593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
    class AbstractWorkflow : public HasPropertyCollection {
    public:
        AbstractWorkflow(const std::string& title);
        virtual ~AbstractWorkflow();

        virtual std::vector<AbstractPipeline*> getPipelines() = 0;
        virtual const std::string getName() const = 0;

        virtual void init();
        virtual void deinit();

        DataContainer* getDataContainer();

        virtual bool isStageAvailable(int stage) const;
        int getCurrentStageId() const;
        void setCurrentStage(int stage);

610
        %immutable;
611
612
        sigslot::signal2<int, int> s_stageChanged;
        sigslot::signal0 s_stageAvailabilityChanged;
613
        %mutable;
614
615
616
    };


617
618
619
620
621
622
    /* VisualizationProcessor */

    class VisualizationProcessor : public AbstractProcessor {
    public:
        explicit VisualizationProcessor(IVec2Property* viewportSizeProp);
        ~VisualizationProcessor();
623
    };
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645



    /* PipelineFactory and ProcessorFactory */

    class PipelineFactory {
    public:
        static PipelineFactory& getRef();

        std::vector<std::string> getRegisteredPipelines() const;
        AbstractPipeline* createPipeline(const std::string& id, DataContainer& dc) const;
        AbstractWorkflow* createWorkflow(const std::string& id) const;
    };

    class ProcessorFactory {
    public:
        static ProcessorFactory& getRef();
    
        std::vector<std::string> getRegisteredProcessors() const;
        std::vector<std::string> getRegisteredRaycastingProcessors() const;
        AbstractProcessor* createProcessor(const std::string& id, IVec2Property* viewPortSizeProp = nullptr) const;
    };
646
}
647
648

%luacode {
649
  print("Module campvis-core loaded")
650
}