C++ AddParameter函数代码示例

BOOL CCommand_VCS_Plc::InitCommand_LayerSettingServices(DWORD p_ulCommandId)
{
    switch(p_ulCommandId)
    {
        case PLC_SEND_LSS_FRAME:
            {
                CCommand_VCS::InitCommand("SendLSSFrame", PLC_SEND_LSS_FRAME);
                AddParameter(0, "data", ODT_MEMORY_BLOCK);
                AddReturnParameter(0, "errorCode", ODT_UINT32);
                SetDefaultParameter_SendLSSFrame();
                return TRUE;
            };
        case PLC_READ_LSS_FRAME:
            {
                CCommand_VCS::InitCommand("ReadLSSFrame", PLC_READ_LSS_FRAME);
                AddParameter(0, "timeout", ODT_UINT16);
                AddReturnParameter(0, "errorCode", ODT_UINT32);
                AddReturnParameter(1, "data", ODT_MEMORY_BLOCK);
                SetDefaultParameter_ReadLSSFrame();
                return TRUE;
            };
    }

    return FALSE;
}

void CDrumMachine::Init(const int Index,void* MainWindow)
{
    m_Name=devicename;
    IDevice::Init(Index,MainWindow);
    AddJack("Out",IJack::Wave,IJack::Out,0);
    AddParameter(ParameterType::Numeric,"Tempo","BPM",20,300,0,"",100);
    AddParameter(ParameterType::dB,"Volume","dB",0,200,0,"",100);
    BeatInterval=0;
    PatternLength=0;
    SamplesPerTick=0;
    Playing=false;
    PatternType* DefaultPattern=new PatternType("Default",16,DrumMachine::SoundCount,100,0,0);
    Patterns.append(DefaultPattern);
    PatternListType* DefaultList=new PatternListType();
    DefaultList->Pattern=DefaultPattern;
    DefaultList->Repeats=4;
    PatternsInList.append(DefaultList);
    AddSound("kick02.wav","Kick",&WG[0],&ST[0]);
    AddSound("snr01.wav","Snare",&WG[1],&ST[1]);
    AddSound("hat01.wav","Hi-Hat",&WG[2],&ST[2]);
    AddSound("hat19.wav","Open Hi-Hat",&WG[3],&ST[3]);
    AddSound("cym01.wav","Cymbal",&WG[4],&ST[4]);
    AddSound("tom01.wav","Tom 1",&WG[5],&ST[5]);
    AddSound("tom02.wav","Tom 2",&WG[6],&ST[6]);
    Reset();
    CalcParams();
    m_Form=new CDrumMachineForm(this,(QWidget*)MainWindow);
}

void otb::Wrapper::Aggregate::DoInit()
{
    SetName("Aggregate");
    SetDescription("This application assign a class on each object of a segmentation by majority voting on a pixel-based classification.");

    SetDocName("Aggregate");
    SetDocLongDescription("The aim of this application is to merge the result of a segmentation with a pixel-based image classification in order to produce an object-oriented image classification. The input segmentation is a labeled image, typically the result provided by the OTB application LSMSSegmentation. The output is a vector dataset containing objects and the corresponding class in the attribute table. Connected regions belonging to the same class are merged. This application could be used at the last step of the LSMS pipeline in replacement of the application LSMSVectorization.");
    SetDocLimitations("Input classification and labeled image should have identical resolution and footprint");
    SetDocAuthors("Lucie Bouillot");
    SetDocSeeAlso("MeanShiftSmoothing, LSMSSegmentation, LSMSSmallRegionsMerging, TrainImagesClassifier, ImagesClassification");
    AddDocTag(Tags::Segmentation);
    AddDocTag(Tags::Learning);

    AddParameter(ParameterType_InputImage, "in", "Input classification");
    SetParameterDescription( "in", "Pixel-based image classification." );

    AddParameter(ParameterType_InputImage,  "inseg",    "Labeled image");
    SetParameterDescription( "inseg", "Labeled image representing a segmentation of an image.");

    AddParameter(ParameterType_OutputImage, "outim", "Output raster");
    SetParameterDescription( "outim", "Output raster, object-oriented image classification.");

    AddParameter(ParameterType_OutputFilename, "out", "Output vector dataset");
    SetParameterDescription( "out", "Output vector dataset, object-oriented image classification. The class 0 is considered as background.");

    SetDocExampleParameterValue("in","classification.tif");
    SetDocExampleParameterValue("inseg","labeled_image.tif");
    SetDocExampleParameterValue("outim","image_classification.tif");
    SetDocExampleParameterValue("out","vector_classification.shp");
}

BOOL CCommand_VCS_Plc2::InitCommand_ProcessImageAccess(DWORD p_ulCommandId)
{
    switch(p_ulCommandId)
    {
        case PLC2_SET_PROCESS_INPUT_IMAGE:
            {
                CCommand_VCS::InitCommand("SetProcessInputImage", PLC2_SET_PROCESS_INPUT_IMAGE);
                AddParameter(0, "selectionStart", ODT_UINT32);
                AddParameter(1, "selectionLength", ODT_UINT32);
                AddParameter(2, "data", ODT_MEMORY_BLOCK);
                SetDefaultParameter_SetProcessInputImage();
                return TRUE;
            };
        case PLC2_GET_PROCESS_OUTPUT_IMAGE:
            {
                CCommand_VCS::InitCommand("GetProcessOutputImage", PLC2_GET_PROCESS_OUTPUT_IMAGE);
                AddParameter(0, "selectionStart", ODT_UINT32);
                AddParameter(1, "selectionLength", ODT_UINT32);
                AddReturnParameter(0, "data", ODT_MEMORY_BLOCK);
                SetDefaultParameter_GetProcessOutputImage();
                return TRUE;
            };
    }

    return FALSE;
}

void otb::Wrapper::ObjectsRadiometricStatistics::DoInit()
{
	SetName("ObjectsRadiometricStatistics");
	SetDescription("Compute features attributes of a vector dataset over an image.");

	SetDocName("ObjectsRadiometricStatistics");
	SetDocLongDescription("This application computes radiometric and shapes attributes on a vector dataset, using an image. The results are stored in the attribute table. Shape attributes are : number of pixels, flatness, roundness, elongation, perimeter. Radiometric attributes are for each band of the input image : mean, standard-deviation, median, variance, kurtosis, skewness.");
	SetDocLimitations("None");
	SetDocAuthors("Arnaud Durand");
	SetDocSeeAlso("For now, support of input dataset with multiple layers having different projection reference system is limited.");

	AddParameter(ParameterType_InputFilename,  "in",   "Input vector dataset");
	SetParameterDescription( "in", "Input vector dataset providing segmentation.");

	AddParameter(ParameterType_InputImage,  "im",   "Input reference image");
	SetParameterDescription( "im", "Input image used to compute radiometric attributes.");

	AddParameter(ParameterType_String,"field","ID field");
	SetParameterDescription("field","Name of the field containing object IDs.");
	SetParameterString("field","label");

	AddParameter(ParameterType_Int,"background", "Background value");
	SetParameterDescription("background","Background value. Needs to be different of any object ID.");
	SetDefaultParameterInt("background",0);

	SetDocExampleParameterValue("in","segmentation.shp");
	SetDocExampleParameterValue("im","image_XS.tif");
	SetDocExampleParameterValue("field","label");
	SetDocExampleParameterValue("background","0");
	
	AddParameter(ParameterType_InputFilename, "out", "Output vector dataset");
	SetParameterDescription("out", "Output vector dataset containing features attributes.");
}

//******************************************************************************
// AGain.
//******************************************************************************
AGain::AGain(audioMasterCallback audioMaster):
axVst(audioMaster, 2)
{
    AGain::AGainMutex.lock();
    AddParameter(axParameterInfo("Gain", "dB", 1.0));
    AddParameter(axParameterInfo("Filter", "Hz", 5000.0));
    
    // Default program name
    vst_strncpy(programName, "axTB303", kVstMaxProgNameLen);
    
    double c5 = 220.0 * pow(ST_RATIO, 3);
    c0 = c5 * pow(0.5, 5);
    

    axEventManager* evtManager = axEventManager::GetInstance();
    
//    evtManager->AddConnection(10000000 + getProgram(),
//                              0,
//                              GetOnVstParameterValueChange());
    
    evtManager->AddConnection(10000000 + GetPluginId(),
                              0,
                              GetOnVstParameterValueChange());
    
    AGain::AGainMutex.unlock();
}

 ActorUpdateMessage::ActorUpdateMessage() : Message() 
 {
    AddParameter(new StringMessageParameter(NAME_PARAMETER));
    AddParameter(new StringMessageParameter(ACTOR_TYPE_NAME_PARAMETER));
    AddParameter(new StringMessageParameter(ACTOR_TYPE_CATEGORY_PARAMETER));
    AddParameter(new StringMessageParameter(PROTOTYPE_NAME_PARAMETER));
    mUpdateParameters = new GroupMessageParameter(UPDATE_GROUP_PARAMETER);
    AddParameter(mUpdateParameters);
 }

void CLFO::Init(const int Index, void *MainWindow) {
    m_Name=devicename;
    IDevice::Init(Index,MainWindow);
    AddJack("Out",IJack::Pitch,IJack::Out,jnOutPitch);
    AddJack("Out Amplitude",IJack::Amplitude,IJack::Out,jnOutAmplitude);
    AddParameter(ParameterType::Numeric,"Frequency","Hz",1,10000,100,"",400);
    AddParameter(ParameterType::SelectBox,"WaveForm","",0,5,0,"Sine§Square§Triangle§Sawtooth§Noise§Sample and Hold",0);
    AddParameter(ParameterType::dB,"Volume","dB",0,200,0,"",100);
    CalcParams();
}

void CPhaser::Init(const int Index, void *MainWindow) {
    m_Name=devicename;
    IDevice::Init(Index,MainWindow);
    AddJack("Out",IJack::Wave,IJack::Out,0);
    AddJack("In",IJack::Wave,IJack::In,0);
    AddParameter(ParameterType::Numeric,"Range Min","Hz",20,m_Presets.SampleRate / 2.f,0,"",440);
    AddParameter(ParameterType::Numeric,"Range Max","Hz",20,m_Presets.SampleRate / 2.f,0,"",1600);
    AddParameter(ParameterType::Numeric,"Rate","Sweeps/sec",5,200,100,"",50);
    AddParameter(ParameterType::Numeric,"Feedback","%",0,100,0,"",70);
    AddParameter(ParameterType::Numeric,"Depth","%",0,100,0,"",100);
    CalcParams();
}

/* bind the duck standard library */
void BindStandardLibrary()
{
    VALUE duckStdLib = LinkNamespace("duck");

    VALUE print = CreateFunction(DuckPrint);
    AddParameter(print, "output");
    LinkFunction(duckStdLib, "print", print);

    VALUE println = CreateFunction(DuckPrintLn);
    AddParameter(println, "output");
    LinkFunction(duckStdLib, "println", println);

    VALUE prompt = CreateFunction(DuckPrompt);
    AddParameter(prompt, "message");
    LinkFunction(duckStdLib, "prompt", prompt);

    LinkConstString(duckStdLib, "newline", "\n");

    VALUE root;
    root.type = VAL_REFERENCE;
    root.data.reference = gGlobalContext;

    VALUE int_c = CreateFunction(DuckInt);
    AddParameter(int_c, "value");
    LinkFunction(root, "int", int_c);

    VALUE float_c = CreateFunction(DuckFloat);
    AddParameter(float_c, "value");
    LinkFunction(root, "float", float_c);

    VALUE length = CreateFunction(DuckLength);
    AddParameter(length, "array");
    LinkFunction(root, "len", length);

    VALUE type = CreateFunction(DuckType);
    AddParameter(type, "object");
    LinkFunction(root, "Type", type);

    VALUE evalFunc = CreateFunction(DuckEval);
    AddParameter(evalFunc, "source");
    LinkFunction(root, "eval", evalFunc);

    VALUE parsesFunc = CreateFunction(DuckParses);
    AddParameter(parsesFunc, "source");
    LinkFunction(duckStdLib, "parses", parsesFunc);

    VALUE duckQuit = CreateFunction(DuckQuit);
    LinkFunction(root, "quit", duckQuit);
    BindStringLibrary();

    VALUE time = CreateFunction(DuckTime);
    LinkFunction(root, "time", time);

#ifdef WIN32
    start_t = GetTickCount();
#endif
}

struct Header *BuildRequestViaHeader(MESSAGE *message, struct Dialog *dialog)
{
    URI *uri = CreateUri("", "", GetLocalIpAddr(), LOCAL_PORT);
    VIA_HEADER *via = CreateViaHeader(uri);    
    struct Parameters *ps = ViaHeaderGetParameters(via);
    char branch[32];

    AddParameter(ps, "rport", "");
    GenerateBranch(branch);
    AddParameter(ps, VIA_BRANCH_PARAMETER_NAME, branch); 

    return (struct Header *)via;
}

void CExciter::Init(const int Index, void *MainWindow)
{
    int Maxcutoff=m_Presets.SampleRate * 0.425;
    m_Name="Exciter";
    IDevice::Init(Index,MainWindow);
    AddJack("Out",IJack::Wave,IJack::Out,0);
    AddJack("Effect Out",IJack::Wave,IJack::Out,0);
    AddJack("In",IJack::Wave,IJack::In,0);
    AddParameter(ParameterType::SelectBox,"Type","",0,1,0,"Soft§Clipping",0);
    AddParameter(ParameterType::dB,"In Volume","dB",0,200,0,"",100);
    AddParameter(ParameterType::Numeric,"Amount","%",0,100,0,"",100);
    AddParameter(ParameterType::Numeric,"Cutoff Frequency","Hz",20,Maxcutoff,0,"",Maxcutoff/2);
    AddParameter(ParameterType::Numeric,"Effect","%",0,100,0,"",50);
    CalcParams();
}

bool
ReadMessageDriverSettings(const char *name, BMessage *message)
{
	if(!name || !message)
		return false;
	
	void *handle = load_driver_settings(name);
	if(!handle)
		return false;
	const driver_settings *settings = get_driver_settings(handle);
	if(!settings) {
		unload_driver_settings(handle);
		return false;
	}
	
	for(int32 index = 0; index < settings->parameter_count; index++) {
		BMessage parameter;
		AddParameter(&settings->parameters[index], &parameter);
		message->AddMessage(MDSU_PARAMETERS, &parameter);
	}
	
	unload_driver_settings(handle);
	
	return true;
}

dDAGFunctionNode::dDAGFunctionNode(dList<dDAG*>& allNodes, dDAGTypeNode* const type, const char* const name, const char* const visivility)
	:dDAG(allNodes)
	,m_isStatic(false)
	,m_isPublic(true)
	,m_isConstructor(false)
	,m_loopLayer(0)
	,m_opertatorThis()
	,m_returnType (type)
	,m_body(NULL)
	,m_modifier(NULL)
	,m_functionStart(NULL)
	,m_parameters() 
	,m_blockMap()
{
	m_name = name;

	m_isStatic = strstr (visivility, "static") ? true : false;
	m_isPublic = strstr (visivility, "public") ? true : false;

	if (!m_isStatic) {
		dAssert (0);
		dDAGParameterNode* const operatorThis = new dDAGParameterNode (allNodes, "this", "");
		operatorThis->SetType(new dDAGTypeNode (allNodes, "this"));
		AddParameter(operatorThis);
	}

}

void
VegaParametersWidget::AddBoolean(const char *name, const TCHAR *label,
                                 const TCHAR *help)
{
  AddParameter(name);
  RowFormWidget::AddBoolean(label, help);
}