AppletParticleKinematicImpl.h

Go to the documentation of this file.

#ifndef _APPLET_PARTICLE_KINEMATIC_IMPL
#define _APPLET_PARTICLE_KINEMATIC_IMPL

#include "AppletParticleKinematic.h"
#include "Particle.h"

#include <vlVolume/RaycastVolume.hpp>
#include <vlVolume/VolumeUtils.hpp>
#include <vlGraphics/Applet.hpp>
#include <vlGraphics/Rendering.hpp>
#include <vlGraphics/Text.hpp>
#include <vlGraphics/FontManager.hpp>
#include <vlGraphics/GLSL.hpp>
#include <vlGraphics/GeometryPrimitives.hpp>
#include <vlCore/VisualizationLibrary.hpp>
#include <vlCore/ResourceDatabase.hpp>
#include <vlCore/Time.hpp>
#include <vlGraphics/Geometry.hpp>
#include <vlGraphics/FramebufferObject.hpp>
#include <vlGraphics/FrameBuffer.hpp>
#include <vlGraphics/Texture.hpp>

#include <vector>
#include <algorithm>
#include <memory>


class AppletParticleKinematicImpl : public AppletParticleKinematic
{
public:
        AppletParticleKinematicImpl();

        virtual ~AppletParticleKinematicImpl(void);

        virtual vl::String appletInfo();

        virtual void initEvent();

        void fileDroppedEvent(const std::vector<vl::String>& files);

        void updateText();

        virtual void updateScene();

        virtual void keyPressEvent(unsigned short, vl::EKey key);

        void initialize();

        vl::Rendering* volumeRendering()
        { 
                return _volumeRendering.get(); 
        }
        
        vl::Rendering* particleRendering() 
        { 
                return _particleRendering.get(); 
        }

        // change runtime config
        void setStickParticleToDensityLevel(bool stick);
        void setParticleCurvatureK(float k);
        void setParticleFlockingK(float k);
        void setParticleRepulsionK(float k);
        void setParticleFlockingSigma(float s);
        void setParticleRepulsionSigma(float s);
        void setUserPreferredDirection(const vl::vec3 &direction);
        void setUserPreferredDirectionK(float k);
        void setCrowdedThreshold(float mu);
        void setCrowdedSigma(float sigma);
        void enableDying(bool d);

        // change preprocessing/initialization config
        void setPreprocessingSigma(float k);
        void setDensityLevel(float d);
        void enableGaussianPreprocessing(bool doGaussian);
        void setGradientMagnitudeThreshold(float threshold);
        void setMaxNumParticles(int maxParticles);
        void setNeighbourRadius(int radius);

        // change rendering config
        void setSampleStep(float step);
        void setShadingIntensity(float intensity);
        void setGradientIntensity(float intensity);
        void setOpacityIntensity(float intensity);
        void setParticleSize(float size);
        void setRenderSmoothedImage(bool render);
        void setParticlesEnabled(bool particles_enabled);
        void setParticleShadingEnabled(bool particle_shading_enabled);
        void setRenderModeByIndex(int mode);

        // sets the transfer function
        void setTransferFunction(vl::ref<vl::Image> img);
        
        // returns the volumetric image
        vl::Image* getImage() 
        { 
                return _volumeImage.get(); 
        }

        void addAppletParticleKinematicListener(AppletParticleKinematicListener *l) 
        { 
                _listeners.push_back(l); 
        }
        
        void removeAppletParticleKinematicListener(AppletParticleKinematicListener *l) 
        { 
                _listeners.erase(std::find(_listeners.begin(), _listeners.end(), l)); 
        }

        void setVolumeFilename(const std::string& filename)
        {
                _volumeFilename = filename;
        }

        vl::String getVolumeFilename()
        {
                return _volumeFilename;
        }

private:
        void setupScene();

        void setupVolume();

        void setupParticles();

        void initParticleCandidatePositions();
        
        void updateParticles();

        void fireListeners();

        void computeGradientNormalization();

        // runtime constants
        bool PARTICLE_STICK_DENSITY_LEVEL;
        float PARTICLE_CURVATURE_K;
        float PARTICLE_FLOCKING_K;
        float PARTICLE_FLOCKING_SIGMA;
        float PARTICLE_REPULSION_K;
        float PARTICLE_REPULSION_SIGMA;
        float PARTICLE_USER_PREFERRED_DIRECTION_K;
        vl::vec3 PARTICLE_USER_PREFERRED_DIRECTION;
        float PARTICLE_CROWDED_THRESHOLD;
        float PARTICLE_CROWDED_SIGMA;
        bool ENABLE_PARTICLE_DYING;
        bool RENDER_SMOOTHED_IMAGE;
        float SAMPLE_STEP;
        float SHADING_INTENSITY;
        float GRADIENT_INTENSITY;
        float OPACITY_INTENSITY;
        float PARTICLE_SIZE;
        bool PARTICLES_ENABLED;
        bool PARTICLE_SHADING_ENABLED;

        enum RaycastMode 
        { 
                DVR_Mode
        } 
        MODE;

        // initialization constants
        float DENSITY_LEVEL;
        int NEIGHBOUR_RADIUS;
        int MAX_NUM_PARTICLES;
        float GRADIENT_MAGNITUDE_THRESHOLD;
        float PREPROCESSING_SIGMA;
        bool PREPROCESSING_GAUSSIAN;

        bool _reloadParticles;

        vl::String _volumeFilename;

        vl::ref<vl::Transform> _volumeTr;

        vl::ref<vl::Transform> _light0Tr;

        vl::ref<vl::Light> _light0;

        // some uniforms used in rendering
        vl::ref<vl::Uniform> _shadingIntensityUniform;
        vl::ref<vl::Uniform> _sampleStepUniform;
        vl::ref<vl::Uniform> _gradientIntensityUniform;
        vl::ref<vl::Uniform> _opacityIntensityUniform;
        vl::ref<vl::Uniform> _particleSizeUniform;
        vl::ref<vl::Uniform> _particlesEnabledUniform;

        vl::ref<vl::Uniform> _particlesShadingEnabledUniform;

        // displayed text
        vl::ref<vl::Text> _valThresholdText;

        vl::ref<vl::GLSLProgram> _GLSL;
        vl::ref<vl::GLSLProgram> _particleProgram;

        vl::ref<vl::Actor> _volumeAct;

        vl::ref<vl::RaycastVolume> _raycastVolume;

        vl::ref<vl::Image> _volumeImage;
        vl::ref<vl::Image> _volumeSmoothedImage;
        vl::ref<vl::Image> _volumeGradient;
        vl::ref<vl::Image> _volumeNormalizedGradient;
        vl::ref<vl::Image> _volumeCurvature;
        // min-max normalization for gradient used for shaders...
        vl::vec3 _gradientMin;
        vl::vec3 _gradientMax;

        std::vector<std::shared_ptr<Particle>> _particles;
        std::shared_ptr<ParticleMap> _particleMap;
        std::vector<vl::vec3> _particleCandidatePositions;

        vl::ref<vl::Geometry> _glParticles;

        vl::ref<vl::Texture> _particleTexture;
        vl::ref<vl::Texture> _particleDepthTexture;
        vl::ref<vl::Texture> _particleColorTexture;
        vl::ref<vl::Texture> _normalizedGradientTexture;

        // FBOs Texture Attachments for the particle rendering pass
        vl::ref<vl::FBOTexture2DAttachment> _particleDepthAttachment;
        vl::ref<vl::FBOTexture2DAttachment> _particleColorAttachment;

        // the fbo for the particle rendering pass
        vl::ref<vl::FramebufferObject> _fboParticles;

        vl::ref<vl::Rendering> _volumeRendering;
        vl::ref<vl::Rendering> _particleRendering;

        vl::ref<vl::Image> _transferFunction;

        std::vector<AppletParticleKinematicListener*> _listeners;
};

#endif // _APPLET_PARTICLE_KINEMATIC_IMPL