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], ¶meter);
message->AddMessage(MDSU_PARAMETERS, ¶meter);
}
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);
}
void CParameterInfo::AddParameter(int paramIndex, CStdString name, EObjectDataType type, DWORD dArraySize)
{
const BOOL editable = TRUE;
const BOOL visible = TRUE;
AddParameter(paramIndex, name, type, dArraySize, editable, visible);
}
TVariablePtr ExpressionParser::ParseVariableDeclaration(StringPtrLen str) const
{
str.TrimRight();
BracketsContent content;
str = content.Parse(str);
str.Trim();
CheckQualifier(str, "Variable name");
if (m_variable_mgr.FindVariable(str) != nullptr)
{
Error("Variable '", str, "' is already declared.");
}
auto variable = std::make_unique<Variable>(str);
StringPtrLen param;
while (content.GetPart(param))
{
param.Trim();
CheckQualifier(param, "Parameter name");
variable->AddParameter(param);
}
return variable;
}
void
VegaParametersWidget::AddEnum(const char *name, const TCHAR *label,
const TCHAR *help, const StaticEnumChoice *list)
{
AddParameter(name);
RowFormWidget::AddEnum(label, help, list);
}
NS_IMETHODIMP
nsJavaObjectInfo::SetDocBase(const char * aDocBase)
{
free(m_docbase);
m_docbase = strdup(aDocBase);
AddParameter("docbase", aDocBase);
return NS_OK;
}
void BindStringLibrary()
{
VALUE stringLib = LinkNamespace("string");
VALUE split = CreateFunction(StringSplit);
AddParameter(split, "string");
LinkFunction(stringLib, "split", split);
}
//------------------------------------------------------------------------------------------
void CSkeletonParameterProvider::CreateParameterMap()
{
CSkeletonParameterProvider& parameterProvider = *((CSkeletonParameterProvider*)(0));
SetProviderName( "CSkeletonParameterProvider" );
AddParameter( parameterProvider.m_boneMatrices, "uBoneMatrices" );
}
// <VariableStore type="varchar" source=column column=CustomerID name=userVarCustID/>
void XMLProcedureCall::StoreDataValue(const char *userVarName, const char *column)
{
ObjQueryParameter *pParam = new ObjQueryParameter("VariableStore");
pParam->AddAttribute("source","column");
pParam->AddAttribute("column",column);
pParam->AddAttribute("name",userVarName);
AddParameter( pParam );
}
void ParameterList::AddParameter(std::shared_ptr<AbsParameter> par)
{
switch(par->type())
{
case ParType::BOOL:{
AddParameter( std::dynamic_pointer_cast<BoolParameter>(par) );
break;}
case ParType::INTEGER:{
AddParameter( std::dynamic_pointer_cast<IntegerParameter>(par) );
break;}
case ParType::DOUBLE:{
AddParameter( std::dynamic_pointer_cast<DoubleParameter>(par) );
break;}
case ParType::COMPLEX:{
AddParameter( std::dynamic_pointer_cast<ComplexParameter>(par) );
break;}
case ParType::MDOUBLE:{
AddParameter( std::dynamic_pointer_cast<MultiDouble>(par) );
break;}
case ParType::MCOMPLEX:{
AddParameter( std::dynamic_pointer_cast<MultiComplex>(par) );
break;}
case ParType::MUNSIGNEDINTEGER:{
AddParameter( std::dynamic_pointer_cast<MultiUnsignedInteger>(par) );
break;}
default:{ break; }
}
}
//
// This function parses configuration options from a text string. Removes any previous
// options stored in the configuration list.
//
void CommandParser::ParseConfigurationOptions(std::string arguments, std::string delimiter)
{
CleanConfigurationOptions();
std::vector<std::string> argumentList;
size_t pos;
size_t nextPos = arguments.find(delimiter.c_str(), 0);
if (nextPos > 0) {
AddParameter("default", arguments.substr(0, nextPos));
}
//
// Break out parameters from command line
//
while (nextPos != std::string::npos) {
pos = nextPos + delimiter.length();
nextPos = arguments.find(delimiter.c_str(), pos);
argumentList.push_back(arguments.substr(pos, nextPos - pos));
}
//
// Remove leading spaces from arguments.
//
for (std::vector<std::string>::iterator it = argumentList.begin(); it != argumentList.end(); it++) {
std::string::size_type pos = it->find_first_not_of(' ');
if (pos != std::string::npos) {
it->erase(0, pos);
}
}
//
// Remove trailing spaces from arguments
//
for (std::vector<std::string>::iterator it = argumentList.begin(); it != argumentList.end(); it++) {
std::string::size_type pos = it->find_last_not_of(' ');
if (pos != std::string::npos) {
it->erase(pos + 1);
}
}
//
// Split the values from the parameter name
//
std::string arg;
for (std::vector<std::string>::iterator it = argumentList.begin(); it != argumentList.end(); it++) {
arg = *it;
pos = arg.find_first_of(":", 0);
if (pos != std::string::npos) {
m_Arguments.insert(std::make_pair(arg.substr(0, pos), arg.substr(pos + 1, std::string::npos)));
} else {
m_Arguments.insert(std::make_pair(arg.substr(0, pos), ""));
}
}
return;
}
void CPanner::Init(const int Index, void *MainWindow)
{
m_Name=devicename;
IDevice::Init(Index,MainWindow);
AddJack("In",IJack::Wave,IJack::In,jnIn);
AddJack("Out",IJack::Stereo,IJack::Out,jnOut);
AddJack("Out Left",IJack::Wave,IJack::Out,jnOutLeft);
AddJack("Out Right",IJack::Wave,IJack::Out,jnOutRight);
AddJack("Modulation In",(IJack::AttachModes)(IJack::Pitch | IJack::Amplitude),IJack::In,jnModulation);
AddParameter(ParameterType::Numeric,"Pan","%",-100,100,0,"",0);
AddParameter(ParameterType::Numeric,"Modulation","%",0,100,0,"",0);
LastMod=0;
CurrentMod=0;
LeftModFactor=1;
RightModFactor=1;
InSignal=NULL;
CalcParams();
}
void
VegaParametersWidget::Prepare(ContainerWindow &parent, const PixelRect &rc)
{
RowFormWidget::Prepare(parent, rc);
if (static_parameters != NULL)
for (auto i = static_parameters; i->name != NULL; ++i)
AddParameter(*i);
}
BOOL CCommand_VCS_Plc::InitCommand_GeneralGateway(DWORD p_ulCommandId)
{
switch(p_ulCommandId)
{
case PLC_REQUEST_CAN_FRAME:
{
CCommand_VCS::InitCommand("RequestCANFrame", PLC_REQUEST_CAN_FRAME);
AddParameter(0, "cobId", ODT_UINT16);
AddParameter(1, "length", ODT_UINT16);
AddReturnParameter(0, "data", ODT_MEMORY_BLOCK);
SetDefaultParameter_RequestCANFrame();
return TRUE;
};
case PLC_SEND_CAN_FRAME:
{
CCommand_VCS::InitCommand("SendCANFrame", PLC_SEND_CAN_FRAME);
AddParameter(0, "cobId", ODT_UINT16);
AddParameter(1, "length", ODT_UINT16);
AddParameter(2, "data", ODT_MEMORY_BLOCK);
SetDefaultParameter_SendCANFrame();
return TRUE;
};
case PLC_READ_CAN_FRAME:
{
CCommand_VCS::InitCommand("ReadCANFrame", PLC_READ_CAN_FRAME);
AddParameter(0, "cobId", ODT_UINT16);
AddParameter(1, "length", ODT_UINT16);
AddParameter(2, "timeout", ODT_UINT32);
AddReturnParameter(0, "data", ODT_MEMORY_BLOCK);
SetDefaultParameter_ReadCANFrame();
return TRUE;
};
case PLC_SEND_NMT_SERVICE:
{
CCommand_VCS::InitCommand("SendNMTService", PLC_SEND_NMT_SERVICE);
AddParameter(0, "nodeIdentifier", ODT_UINT16);
AddParameter(1, "commandSpecifier", ODT_UINT16);
SetDefaultParameter_SendNMTService();
return TRUE;
};
}
return FALSE;
}
MESSAGE *BuildByeMessage(struct Dialog *dialog)
{
MESSAGE *bye = BuildRequest(dialog, SIP_METHOD_BYE);
CONTACT_HEADER *to = (CONTACT_HEADER *)MessageGetHeader(HEADER_NAME_TO, bye);
struct Parameters *ps = ContactHeaderGetParameters(to);
AddParameter(ps, HEADER_PARAMETER_NAME_TAG, DialogGetRemoteTag(dialog));
return bye;
}
iAScalarConnectedComponents::iAScalarConnectedComponents() :
iAFilter("Scalar Connected Component Filter", "Connected Component Filters",
"Labels the objects in an arbitrary image.<br/>"
"Two pixels are similar if they are within <em>Distance Threshold</em> of each other.<br/>"
"For more information, see the "
"<a href=\"https://itk.org/Doxygen/html/classitk_1_1ScalarConnectedComponentImageFilter.html\">"
"Scalar Connected Component Filter</a> in the ITK documentation.")
{
AddParameter("Distance Threshold", Continuous, 1);
}
BOOL CADOCommand::AddParameter(CString strName, int nType, int nDirection, long lSize, COleDateTime time)
{
_variant_t vtValue;
vtValue.vt = VT_DATE;
vtValue.date = time;
return AddParameter(strName, nType, nDirection, lSize, vtValue);
}
