Convolution::Convolution() : ImageProcessorBypassable("image/convolution"), filterSize_("filtersize", "Filter Size (NxN)", 7), inport_(Port::INPORT, "inport", "Image Input"), filterPort_(Port::INPORT, "filterport", "Filter Input"), outport_(Port::OUTPORT, "outport", "Image Output") { // register properties and ports: addProperty(filterSize_); addPort(inport_); addPort(filterPort_); addPort(outport_); }
void Rotate::portSetup() { // data port setup addPort("ImageOut", &ImageOut); addPort("ImageIn", &ImageIn); // export variable setup }
void JoystickComp::portSetup() { // provided service port setup ProvidedServicePort *pa1; pa1=new JoystickServiceProvided(this); addPort("JoystickService",pa1); // data port setup addPort("joystickData", &joystickData); }
void FrequencyFilter::portSetup() { // data port setup addPort("ImageOut", &ImageOut); addPort("ImageIn", &ImageIn); // export variable setup }
void ARToolkitOPRoS::portSetup() { // data port setup addPort("ImageOut", &ImageOut); addPort("ImageIn", &ImageIn); // export variable setup }
Z3DCanvasRenderer::Z3DCanvasRenderer() : Z3DRenderProcessor() , m_textureCopyRenderer(NULL) , m_canvas(NULL) , m_inport("Image", false, InvalidMonoViewResult) , m_leftEyeInport("LeftEyeImage", false, InvalidLeftEyeResult) , m_rightEyeInport("RightEyeImage", false, InvalidRightEyeResult) , m_renderToImage(false) , m_renderToImageFilename("") { addPort(m_inport); addPort(m_leftEyeInport); addPort(m_rightEyeInport); }
VolumeBitScale::VolumeBitScale() : VolumeProcessor(), inport_(Port::INPORT, "volumehandle.input"), outport_(Port::OUTPORT, "volumehandle.output", 0), conversion_("conversion", "Convert To") { addPort(inport_); addPort(outport_); conversion_.addOption("8", "8 bit"); conversion_.addOption("12", "12 bit"); conversion_.addOption("16", "16 bit"); addProperty(conversion_); }
void HandsMotionTracking::portSetup() { // data port setup addPort("ImageOut", &ImageOut); addPort("PositionOut", &PositionOut); addPort("ImageIn", &ImageIn); // export variable setup }
void RGBValueControl::portSetup() { // data port setup addPort("ImageOut", &ImageOut); addPort("ImageIn", &ImageIn); // export variable setup }
void LaserScannerComp::portSetup() { // provided service port setup ProvidedServicePort *pa1; pa1=new LaserScannerServiceProvided(this); addPort("LaserScannerService",pa1); // data port setup addPort("laserScannerData", &laserScannerData); }
OTBMDMDNMFImageFilterProcessor::OTBMDMDNMFImageFilterProcessor() :OTBImageFilterProcessor(), inPort_(Port::INPORT, "IN MultiBand Image", 0), endmembersInPort_(Port::INPORT, "Endmembers Multispectral Image", 0), outPort_(Port::OUTPORT, "OUT MultiBand Image", 0) { addProperty(enableSwitch_); addPort(inPort_); addPort(endmembersInPort_); addPort(outPort_); filter = MDMDNMFUnmixingFilterType::New(); endMember2Matrix = VectorImageToMatrixImageFilterType::New(); }
ImageMasking::ImageMasking() : ImageProcessorDepth("image/mask") , inport_(Port::INPORT, "image.input") , inportMask_(Port::INPORT, "image.mask") , outport_(Port::OUTPORT, "image.output", true) , maskColor_("maskColor", "Mask Color", tgt::Color(0.0f, 0.0f, 0.0f, 0.0f)) { maskColor_.setViews(Property::COLOR); addPort(inport_); addPort(inportMask_); addPort(outport_); addProperty(maskColor_); }
DepthDarkening::DepthDarkening() : ImageProcessorDepth("image/depthdarkening") , sigma_("sigma", "Sigma", 2.0f, 0.1f, 10.0f) , lambda_("lambda", "Lambda", 10.0f, 0.0f, 20.0f) , inport_(Port::INPORT, "image.inport") , outport_(Port::OUTPORT, "image.outport", true) , privatePort_(Port::OUTPORT, "image.privateport") { addProperty(sigma_); addProperty(lambda_); addPort(inport_); addPort(outport_); addPrivateRenderPort(privatePort_); }
OTBRescaleIntensityImageFilterProcessor::OTBRescaleIntensityImageFilterProcessor() :OTBImageFilterProcessor(), OutputMin_("outputmin", "Output Minimum:", 0, -1000, 1000), OutputMax_("outputmax", "Output Maximum:", 255, -1000, 1000), inPort_(Port::INPORT, "OTBImage.inport",0), outPort_(Port::OUTPORT, "OTBImage.outport",0) { addProperty(enableSwitch_); addProperty(OutputMin_); addProperty(OutputMax_); addPort(inPort_); addPort(outPort_); filter = FilterType::New(); }
ImageGLProcessor::ImageGLProcessor(std::string fragmentShader) : Processor() , inport_(fragmentShader + "inport") , outport_(fragmentShader + "outport") , internalInvalid_(false) , fragmentShader_(fragmentShader) , shader_(fragmentShader, false) { addPort(inport_); addPort(outport_); inport_.onChange(this, &ImageGLProcessor::inportChanged); inport_.setOutportDeterminesSize(true); outport_.setHandleResizeEvents(false); shader_.onReload([this](){invalidate(INVALID_RESOURCES);}); }
VolumeMirror::VolumeMirror() : CachingVolumeProcessor(), mirrorX_("mirrorX", "Mirror X", false), mirrorY_("mirrorY", "Mirror Y", false), mirrorZ_("mirrorZ", "Mirror Z", false), inport_(Port::INPORT, "volumehandle.input"), outport_(Port::OUTPORT, "volumehandle.output", 0) { addProperty(mirrorX_); addProperty(mirrorY_); addProperty(mirrorZ_); addPort(inport_); addPort(outport_); }
VolumeComposer::VolumeComposer() : VolumeProcessor(), inportImages_(Port::INPORT, "imagesequence.in"), inportVolumes_(Port::INPORT, "volumecollection.in"), outport_(Port::OUTPORT, "volume.out"), voxelSpacing_("voxelSpacing", "Voxel Spacing", tgt::vec3(1.f), tgt::vec3(0.01f), tgt::vec3(10.f)) { setExpensiveComputationStatus(Processor::COMPUTATION_STATUS_PROGRESSBAR); addPort(inportImages_); addPort(inportVolumes_); addPort(outport_); addProperty(voxelSpacing_); }
void JoystickComp::portSetup() { ProvidedServicePort *pa1; pa1=new JoystickServiceProvided(this); addPort("JoystickService",pa1); //data port setup addPort("joystickData", &joystickData); // export variable setup }
VolumeGLProcessor::VolumeGLProcessor(const std::string &fragmentShader, bool buildShader) : Processor() , inport_(fragmentShader + "inport") , outport_(fragmentShader + "outport") , dataFormat_(nullptr) , internalInvalid_(true) , fragmentShader_(fragmentShader) , shader_("volume_gpu.vert", "volume_gpu.geom", fragmentShader_, buildShader) , fbo_() { addPort(inport_); addPort(outport_); inport_.onChange(this, &VolumeGLProcessor::inportChanged); shader_.onReload([this]() { invalidate(INVALID_RESOURCES); }); }
PlotFunctionDiscret::PlotFunctionDiscret() :Processor() , outPort_(Port::OUTPORT,"PlotData.OutPort") , inPort_(Port::INPORT,"PlotPort.PlotFunction.InPort") , dimensionsList_("DimensionsList_","Dimension List",Processor::VALID) , leftInterval_("leftInterval_","Left Interval",-5,-std::numeric_limits<float>::max(),std::numeric_limits<float>::max(),Processor::VALID) , rightInterval_("rightInterval_","Right Interval",5,-std::numeric_limits<float>::max(),std::numeric_limits<float>::max(),Processor::VALID) , steps_("Steps_","Stepwidth", 0.1f,0.0001f,10,Processor::VALID) , startDiscretization_("startDiscretization_","Discretize again") , numberofCalculations_("NumberofCalculations","Number of Calculations",0,0,std::numeric_limits<float>::max(),Processor::VALID) , pData_(0) , pDataOut_(0) { dimensionsList_.onChange(CallMemberAction<PlotFunctionDiscret>(this, &PlotFunctionDiscret::choiceChange)); leftInterval_.onChange(CallMemberAction<PlotFunctionDiscret>(this, &PlotFunctionDiscret::leftIntervalChange)); rightInterval_.onChange(CallMemberAction<PlotFunctionDiscret>(this, &PlotFunctionDiscret::rightIntervalChange)); steps_.onChange(CallMemberAction<PlotFunctionDiscret>(this, &PlotFunctionDiscret::intervalStepChange)); startDiscretization_.onClick(CallMemberAction<PlotFunctionDiscret>(this,&PlotFunctionDiscret::calculate)); addPort(inPort_); addPort(outPort_); addProperty(dimensionsList_); addProperty(leftInterval_); addProperty(rightInterval_); addProperty(steps_); addProperty(startDiscretization_); addProperty(numberofCalculations_); setPropertyGroupGuiName("Discretization","Discretization"); dimensionsList_.setGroupID("Discretization"); leftInterval_.setGroupID("Discretization"); rightInterval_.setGroupID("Discretization"); steps_.setGroupID("Discretization"); startDiscretization_.setGroupID("Discretization"); steps_.setNumDecimals(4); std::stringstream optionText; std::stringstream keyText; for (int i = 0; i < 26; ++i) { optionText.str(""); optionText.clear(); keyText.str(""); keyText.clear(); optionText << i+1 << " te Dimension"; keyText << i+1 << " Column"; dimensionsList_.addOption(keyText.str(),optionText.str(),i+1); } numberofCalculations_.setWidgetsEnabled(false); numberofCalculations_.setNumDecimals(0); }
void SoftAMR::initPorts() { OMX_PARAM_PORTDEFINITIONTYPE def; InitOMXParams(&def); def.nPortIndex = 0; def.eDir = OMX_DirInput; def.nBufferCountMin = kNumBuffers; def.nBufferCountActual = def.nBufferCountMin; def.nBufferSize = 8192; def.bEnabled = OMX_TRUE; def.bPopulated = OMX_FALSE; def.eDomain = OMX_PortDomainAudio; def.bBuffersContiguous = OMX_FALSE; def.nBufferAlignment = 1; def.format.audio.cMIMEType = mMode == MODE_NARROW ? const_cast<char *>("audio/amr") : const_cast<char *>("audio/amrwb"); def.format.audio.pNativeRender = NULL; def.format.audio.bFlagErrorConcealment = OMX_FALSE; def.format.audio.eEncoding = OMX_AUDIO_CodingAMR; addPort(def); def.nPortIndex = 1; def.eDir = OMX_DirOutput; def.nBufferCountMin = kNumBuffers; def.nBufferCountActual = def.nBufferCountMin; def.nBufferSize = (mMode == MODE_NARROW ? kNumSamplesPerFrameNB : kNumSamplesPerFrameWB) * sizeof(int16_t); def.bEnabled = OMX_TRUE; def.bPopulated = OMX_FALSE; def.eDomain = OMX_PortDomainAudio; def.bBuffersContiguous = OMX_FALSE; def.nBufferAlignment = 2; def.format.audio.cMIMEType = const_cast<char *>("audio/raw"); def.format.audio.pNativeRender = NULL; def.format.audio.bFlagErrorConcealment = OMX_FALSE; def.format.audio.eEncoding = OMX_AUDIO_CodingPCM; addPort(def); }
IsolatedWatershedImageFilterITK::IsolatedWatershedImageFilterITK() : ITKProcessor(), inport1_(Port::INPORT, "InputImage"), outport1_(Port::OUTPORT, "OutputImage"), seedPointPort1_(Port::INPORT, "seedPointInput1"), seedPointPort2_(Port::INPORT, "seedPointInput2"), enableProcessing_("enabled", "Enable", false), numSeedPoint1_("numSeedPoint1", "Take Seed-Point", 0, 0, 0, Processor::VALID), seedPoint1_("SeedPoint1", "Seed-Point1", tgt::vec3(1),tgt::vec3(1),tgt::vec3(500)), numSeedPoint2_("numSeedPoint2", "Take Seed-Point", 0, 0, 0, Processor::VALID), seedPoint2_("SeedPoint2", "Seed-Point2", tgt::vec3(1),tgt::vec3(1),tgt::vec3(500)), threshold_("threshold", "Threshold", 0.0f, 0.0f, 1.0f), isolatedValueTolerance_("isolatedValueTolerance", "IsolatedValueTolerance", 0.001f, 0.0f, 1.0f), upperValueLimit_("upperValueLimit", "UpperValueLimit", 1.0f, 0.0f, 1.0f), replaceValue1_("replaceValue1", "ReplaceValue1"), replaceValue2_("replaceValue2", "ReplaceValue2") { addPort(inport1_); PortConditionLogicalOr* orCondition1 = new PortConditionLogicalOr(); orCondition1->addLinkedCondition(new PortConditionVolumeTypeUInt8()); orCondition1->addLinkedCondition(new PortConditionVolumeTypeInt8()); orCondition1->addLinkedCondition(new PortConditionVolumeTypeUInt16()); orCondition1->addLinkedCondition(new PortConditionVolumeTypeInt16()); orCondition1->addLinkedCondition(new PortConditionVolumeTypeUInt32()); orCondition1->addLinkedCondition(new PortConditionVolumeTypeInt32()); orCondition1->addLinkedCondition(new PortConditionVolumeTypeFloat()); orCondition1->addLinkedCondition(new PortConditionVolumeTypeDouble()); inport1_.addCondition(orCondition1); addPort(outport1_); addPort(seedPointPort1_); addPort(seedPointPort2_); addProperty(enableProcessing_); addProperty(numSeedPoint1_); addProperty(seedPoint1_); numSeedPoint1_.onChange(CallMemberAction<IsolatedWatershedImageFilterITK>(this, &IsolatedWatershedImageFilterITK::process)); seedPoint1_.setWidgetsEnabled(false); addProperty(numSeedPoint2_); addProperty(seedPoint2_); numSeedPoint2_.onChange(CallMemberAction<IsolatedWatershedImageFilterITK>(this, &IsolatedWatershedImageFilterITK::process)); seedPoint2_.setWidgetsEnabled(false); addProperty(threshold_); addProperty(isolatedValueTolerance_); addProperty(upperValueLimit_); addProperty(replaceValue1_); addProperty(replaceValue2_); }
StereoMeshEntryExitPoints::StereoMeshEntryExitPoints() : RenderProcessor() , entryPort_(Port::OUTPORT, "image.entrypoints", "Entry-points Output", true, Processor::INVALID_RESULT, RenderPort::RENDERSIZE_RECEIVER) , exitPort_(Port::OUTPORT, "image.exitpoints", "Exit-points Output", true, Processor::INVALID_RESULT, RenderPort::RENDERSIZE_RECEIVER) , inport_(Port::INPORT, "proxgeometry.geometry", "Proxy Geometry Input") , tmpPort_(Port::OUTPORT, "image.tmp", "image.tmp", false) , supportCameraInsideVolume_("supportCameraInsideVolume", "Support camera in volume", true) , jitterEntryPoints_("jitterEntryPoints", "Jitter entry params", false) , useFloatRenderTargets_("useFloatRenderTargets", "Use float render targets", false) , useCulling_("useCulling", "Use culling", true) , jitterStepLength_("jitterStepLength", "Jitter step length", 0.005f, 0.0005f, 0.025f) , camera_("camera", "Camera", tgt::Camera(vec3(0.f, 0.f, 3.5f), vec3(0.f, 0.f, 0.f), vec3(0.f, 1.f, 0.f))) , cameraLeft_("cameraLeft", "Camera Left", tgt::Camera(vec3(0.f, 0.f, 3.5f), vec3(0.f, 0.f, 0.f), vec3(0.f, 1.f, 0.f))) , cameraRight_("cameraRight", "Camera Right", tgt::Camera(vec3(0.f, 0.f, 3.5f), vec3(0.f, 0.f, 0.f), vec3(0.f, 1.f, 0.f))) , eyeSeparation_("eyeSeparation", "Eye separation", 0.f, 0.f, 1.f) , cameraDistance_("cameraDistance", "Camera distance", 0.f, 0.f, 5.f) , shaderProgram_(0) , shaderProgramJitter_(0) { addProperty(supportCameraInsideVolume_); // jittering addProperty(jitterEntryPoints_); jitterEntryPoints_.onChange(CallMemberAction<StereoMeshEntryExitPoints>(this, &StereoMeshEntryExitPoints::onJitterEntryPointsChanged)); onJitterEntryPointsChanged(); // set initial state jitterStepLength_.setStepping(0.001f); jitterStepLength_.setNumDecimals(3); addProperty(jitterStepLength_); addProperty(useFloatRenderTargets_); addProperty(useCulling_); addProperty(camera_); addProperty(cameraLeft_); addProperty(cameraRight_); addProperty(eyeSeparation_); addProperty(cameraDistance_); cameraHandler_ = new StereoCameraInteractionHandler("cameraHandler", "Camera", &camera_, &cameraLeft_, &cameraRight_, &eyeSeparation_, &cameraDistance_); addInteractionHandler(cameraHandler_); addPort(entryPort_); addPort(exitPort_); addPort(inport_); addPrivateRenderPort(&tmpPort_); }
CubeMeshProxyGeometry::CubeMeshProxyGeometry() : Processor() , inport_(Port::INPORT, "volumehandle.volumehandle") , outport_(Port::OUTPORT, "proxygeometry.geometry") , enableClipping_("useClipping", "Enable Clipping", true) , clipRight_("rightClippingPlane", "Right clipping plane (x)", 0.f, 0.f, 1e5f) , clipLeft_("leftClippingPlane", "Left clipping plane (x)", 1e5f, 0.f, 1e5f) , clipFront_("frontClippingPlane", "Front clipping plane (y)", 0.f, 0.f, 1e5f) , clipBack_("backClippingPlane", "Back clipping plane (y)", 1e5f, 0.f, 1e5f) , clipBottom_("bottomClippingPlane", "Bottom clipping plane (z)", 0.f, 0.f, 1e5f) , clipTop_("topClippingPlane", "Top clipping plane (z)", 1e5f, 0.f, 1e5f) , resetClipPlanes_("resetClipPlanes", "Reset Planes") , geometry_(new MeshListGeometry()) { addPort(inport_); addPort(outport_); clipRight_.onChange(CallMemberAction<CubeMeshProxyGeometry>(this, &CubeMeshProxyGeometry::onClipRightChange)); clipLeft_.onChange(CallMemberAction<CubeMeshProxyGeometry>(this, &CubeMeshProxyGeometry::onClipLeftChange)); clipFront_.onChange(CallMemberAction<CubeMeshProxyGeometry>(this, &CubeMeshProxyGeometry::onClipFrontChange)); clipBack_.onChange(CallMemberAction<CubeMeshProxyGeometry>(this, &CubeMeshProxyGeometry::onClipBackChange)); clipBottom_.onChange(CallMemberAction<CubeMeshProxyGeometry>(this, &CubeMeshProxyGeometry::onClipBottomChange)); clipTop_.onChange(CallMemberAction<CubeMeshProxyGeometry>(this, &CubeMeshProxyGeometry::onClipTopChange)); enableClipping_.onChange(CallMemberAction<CubeMeshProxyGeometry>(this, &CubeMeshProxyGeometry::adjustClipPropertiesVisibility)); resetClipPlanes_.onChange(CallMemberAction<CubeMeshProxyGeometry>(this, &CubeMeshProxyGeometry::resetClipPlanes)); addProperty(enableClipping_); addProperty(clipRight_); addProperty(clipLeft_); addProperty(clipFront_); addProperty(clipBack_); addProperty(clipBottom_); addProperty(clipTop_); addProperty(resetClipPlanes_); clipRight_.setGroupID("clipping"); clipLeft_.setGroupID("clipping"); clipFront_.setGroupID("clipping"); clipBack_.setGroupID("clipping"); clipBottom_.setGroupID("clipping"); clipTop_.setGroupID("clipping"); resetClipPlanes_.setGroupID("clipping"); setPropertyGroupGuiName("clipping", "Clipping Planes"); adjustClipPropertiesVisibility(); oldVolumeDimensions_ = tgt::ivec3(0,0,0); }
RTC::ReturnCode_t DataLogger::onInitialize() { std::cout << m_profile.instance_name << ": onInitialize()" << std::endl; // Registration: InPort/OutPort/Service // <rtc-template block="registration"> // Set InPort buffers addInPort("emergencySignal", m_emergencySignalIn); // Set OutPort buffer // Set service provider to Ports m_DataLoggerServicePort.registerProvider("service0", "DataLoggerService", m_service0); // Set service consumers to Ports // Set CORBA Service Ports addPort(m_DataLoggerServicePort); // </rtc-template> // <rtc-template block="bind_config"> // Bind variables and configuration variable // </rtc-template> return RTC::RTC_OK; }
VolumeSource::VolumeSource() : Processor() , outport_("data") , file_("filename", "File") , reload_("reload", "Reload data") , basis_("Basis", "Basis and offset") , information_("Information", "Data information") , volumeSequence_("Sequence", "Sequence") , isDeserializing_(false) { file_.setContentType("volume"); file_.setDisplayName("Volume file"); file_.onChange([this]() { load(); }); reload_.onChange([this]() { load(); }); volumeSequence_.setVisible(false); addFileNameFilters(); addPort(outport_); addProperty(file_); addProperty(reload_); addProperty(information_); addProperty(basis_); addProperty(volumeSequence_); }
void BirdsEyeView::portSetup() { // data port setup addPort("ImageOut", &ImageOut); addPort("ImageOut2", &ImageOut2); addPort("ImageIn", &ImageIn); // export variable setup }
// populates portlist by reading in a file of ports void PortScanner::addPortsFromFile(char *filename) { FILE *inputfd; char line[MAXLINE + 1]; char *cp; /* nmap */ if (!strcmp(filename, "-")) { inputfd = stdin; } else { inputfd = fopen(filename, "r"); if (!inputfd) { printf("ERROR: Failed to open port input file %s for reading\n", filename); exit(1); } } while (fgets(line, MAXLINE, inputfd)) { for (cp = line; !isspace((unsigned char)*cp) && *cp != '\0'; cp++) ; *cp = '\0'; addPort(atoi(line)); } if (inputfd != stdin) fclose(inputfd); }
RandomNumberGeneratorCL::RandomNumberGeneratorCL() : Processor() , ProcessorKernelOwner(this) , randomNumbersPort_("samples") , nRandomNumbers_("nSamples", "N samples", 256, 1, 100000000) , regenerateNumbers_("genRnd", "Regenerate") , seed_("seed", "Seed number", 0, 0, std::numeric_limits<int>::max()) , workGroupSize_("wgsize", "Work group size", 256, 1, 2048) , useGLSharing_("glsharing", "Use OpenGL sharing", true) , randomNumbersOut_(std::make_shared<Buffer<float>>(nRandomNumbers_.get())) { addPort(randomNumbersPort_); addProperty(nRandomNumbers_); addProperty(regenerateNumbers_); addProperty(seed_); addProperty(workGroupSize_); addProperty(useGLSharing_); nRandomNumbers_.onChange([this]() { randomNumbersOut_->setSize(nRandomNumbers_); }); seed_.onChange([this]() { randomNumberGenerator_.setSeed(seed_); }); workGroupSize_.onChange([this]() { randomNumberGenerator_.setWorkGroupSize(workGroupSize_); }); useGLSharing_.onChange([this]() { randomNumberGenerator_.setUseGLSharing(useGLSharing_); }); regenerateNumbers_.onChange(this, &RandomNumberGeneratorCL::regenerate); randomNumbersPort_.setData(randomNumbersOut_); }
OcclusionSlicer::OcclusionSlicer() : VolumeSlicer() , shaderProp_("slicing.shader", "Slicing shader", "sl_occlusion.frag", "sl_singlevolume.vert") , occlusionbuffer0_(Port::OUTPORT, "image.occlusionbuffer0", "OcclusionBuffer0 Output", false, Processor::INVALID_RESULT, //RenderPort::RENDERSIZE_DEFAULT, GL_RGBA16F_ARB) RenderPort::RENDERSIZE_DEFAULT) , occlusionbuffer1_(Port::OUTPORT, "image.occlusionbuffer1", "OcclusionBuffer1 Output", false, Processor::INVALID_RESULT, /*RenderPort::RENDERSIZE_DEFAULT, GL_RGBA16F_ARB)*/ RenderPort::RENDERSIZE_DEFAULT) , outport_(Port::OUTPORT, "image.eyebuffer", "EyeBuffer Output", true, Processor::INVALID_RESULT, RenderPort::RENDERSIZE_RECEIVER) , cameraHandler_("cameraHandler", "Camera Handler", &camera_) , sigma_("sigma", "Sigma", 100.0f, 0.0f, 1000.0f) , radius_("radius", "Radius", 5, 0, 50) { addInteractionHandler(cameraHandler_); addPrivateRenderPort(occlusionbuffer0_); addPrivateRenderPort(occlusionbuffer1_); addPort(outport_); addProperty(shaderProp_); addProperty(sigma_); addProperty(radius_); addProperty(lightPosition_); }