Ejemplo n.º 1
0
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_);
}
Ejemplo n.º 2
0
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);

}
Ejemplo n.º 4
0
void FrequencyFilter::portSetup() {

    // data port setup

    addPort("ImageOut", &ImageOut);

    addPort("ImageIn", &ImageIn);



    // export variable setup


}
Ejemplo n.º 5
0
void ARToolkitOPRoS::portSetup() {

	// data port setup

	addPort("ImageOut", &ImageOut);

	addPort("ImageIn", &ImageIn);



	// export variable setup


}
Ejemplo n.º 6
0
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);
}
Ejemplo n.º 7
0
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_);
}
Ejemplo n.º 8
0
void HandsMotionTracking::portSetup() {

	// data port setup

	addPort("ImageOut", &ImageOut);

	addPort("PositionOut", &PositionOut);

	addPort("ImageIn", &ImageIn);

	// export variable setup


}
Ejemplo n.º 9
0
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();
}
Ejemplo n.º 12
0
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_);
}
Ejemplo n.º 13
0
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();
}
Ejemplo n.º 15
0
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);});
}
Ejemplo n.º 16
0
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_);
}
Ejemplo n.º 17
0
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_);
}
Ejemplo n.º 18
0
void JoystickComp::portSetup() {
	ProvidedServicePort *pa1;
	pa1=new JoystickServiceProvided(this);
	addPort("JoystickService",pa1);

//data port setup
	addPort("joystickData", &joystickData);




	// export variable setup


}
Ejemplo n.º 19
0
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); });
}
Ejemplo n.º 20
0
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_);

}
Ejemplo n.º 23
0
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_);
}
Ejemplo n.º 24
0
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);
}
Ejemplo n.º 25
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;
}
Ejemplo n.º 26
0
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_);
}
Ejemplo n.º 27
0
void BirdsEyeView::portSetup() {

	// data port setup

	addPort("ImageOut", &ImageOut);

	addPort("ImageOut2", &ImageOut2);

	addPort("ImageIn", &ImageIn);



	// export variable setup


}
Ejemplo n.º 28
0
// 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_);
}
Ejemplo n.º 30
0
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_);
}