public bool setValue(string paramName, double[] paramValue, Parameters.Units[] paramUnit)
{
lock (lockParameters) {
iParam param = getParameter(paramName);
if (param == null)
{
logger.Error("Could not find parameter '" + paramName + "' in parameter set '" + paramSetName + "', value not set");
return(false);
}
// check if the parameter is indeed used to store a double array
if (param.GetType() != typeof(ParamDoubleArr))
{
logger.Error("Could not set parameter '" + paramName + "' in parameter set '" + paramSetName + "', trying to set an array of doubles in a '" + param.GetType().Name + "' parameter");
return(false);
}
// set the value
if (!((ParamDoubleArr)param).setValue(paramValue))
{
return(false);
}
if (!((ParamDoubleArr)param).setUnit(paramUnit))
{
return(false);
}
// return success
return(true);
}
}
public bool setValue(string paramName, string[][] paramValue)
{
lock (lockParameters) {
iParam param = getParameter(paramName);
if (param == null)
{
logger.Error("Could not find parameter '" + paramName + "' in parameter set '" + paramSetName + "', value not set");
return(false);
}
// check if the parameter is indeed used to store a string matix
if (param.GetType() != typeof(ParamStringMat))
{
logger.Error("Could not set parameter '" + paramName + "' in parameter set '" + paramSetName + "', trying to set a matrix of strings in a '" + param.GetType().Name + "' parameter");
return(false);
}
// set the value
if (!((ParamStringMat)param).setValue(paramValue))
{
return(false);
}
// return success
return(true);
}
}
public T getValueInSamples <T>(string paramName, int[] ignoreColumns)
{
lock (lockParameters) {
// try to retrieve the parameter
iParam param = getParameter(paramName);
if (param == null)
{
// message and return 0
logger.Error("Could not find parameter '" + paramName + "' in parameter set '" + paramSetName + "', returning 0");
return((T)Convert.ChangeType(Parameters.emptyValue <T>(), typeof(T)));
}
// if int[][] or double[][] matrix then get values in samples while ignoring columns
if (param.GetType() == typeof(ParamDoubleMat) || param.GetType() == typeof(double[][]))
{
return(((ParamDoubleMat)param).getValueInSamples <T>(ignoreColumns));
}
else if (param.GetType() == typeof(ParamIntMat) || param.GetType() == typeof(int[][]))
{
return(((ParamIntMat)param).getValueInSamples <T>(ignoreColumns));
}
else
{
// message and return 0
logger.Error("Could not retrieve the values (in samples) for parameter '" + paramName + "' (parameter set: '" + paramSetName + "'), the getValueInSamples functionality with ignoreColumns can only be used for matrix parameters (int[][] or double[][]). Returning 0");
return((T)Convert.ChangeType(Parameters.emptyValue <T>(), typeof(T)));
}
}
}
public string ToString(string paramName)
{
lock (lockParameters) {
iParam param = getParameter(paramName);
if (param == null)
{
logger.Error("Could not find parameter '" + paramName + "' in parameter set '" + paramSetName + "', returning null");
return(null);
}
return(param.ToString());
}
}
public static void setValue <T>(string paramName, string paramValue)
{
lock (lockParameters) {
// retrieve the parameter
iParam param = getParameter(paramName);
// create the parameter if it does not exist
if (param == null)
{
param = addParameter <T>(paramName);
}
// if not able to create, return
if (param == null)
{
return;
}
// call setter of the parameter for further processing
if (param.setValue(paramValue))
{
// successfully set
// also store certain types as evaluable variables
if (param.GetType() == typeof(ParamBool))
{
evaluableVariables[paramName] = ((ParamBool)param).Value ? 1 : 0;
}
else if (param.GetType() == typeof(ParamInt))
{
evaluableVariables[paramName] = ((ParamInt)param).Value;
}
else if (param.GetType() == typeof(ParamDouble))
{
evaluableVariables[paramName] = ((ParamDouble)param).Value;
}
}
else
{
// failure to set
// message
logger.Error("Could not find parameter '" + paramName + "' in globals, discarded");
}
}
}
public T getUnit <T>(string paramName)
{
lock (lockParameters) {
iParam param = getParameter(paramName);
if (param == null)
{
// message
logger.Error("Could not find parameter '" + paramName + "' in parameter set '" + paramSetName + "', returning 0");
// return 0
return((T)Convert.ChangeType(null, typeof(T)));
}
// return the value
return(param.getUnit <T>());
}
}
public string getType(string paramName)
{
lock (lockParameters) {
iParam param = getParameter(paramName);
if (param == null)
{
// message
logger.Error("Could not find parameter '" + paramName + "' in parameter set '" + paramSetName + "', returning 0");
// return ""
return("");
}
// return the value
return(param.GetType().ToString());
}
}
private void btnPrintParamInfo_Click(object sender, EventArgs e)
{
string paramInfo = "";
// retrieve the parameter sets
Dictionary <string, Parameters> paramSets = ParameterManager.getParameterSets();
// open
paramInfo += Environment.NewLine;
paramInfo += "-----------------------------------------------" + Environment.NewLine;
// loop through each paramset
foreach (KeyValuePair <string, Parameters> entry in paramSets)
{
// module name
paramInfo += Environment.NewLine + "------------- Module " + entry.Value.ParamSetName + " (" + entry.Value.ParamSetType + ") -------------" + Environment.NewLine;
// loop through the parameters
List <iParam> parameters = entry.Value.getParameters();
for (int i = 0; i < parameters.Count; i++)
{
iParam param = parameters[i];
paramInfo += "+++++ " + Environment.NewLine;
paramInfo += "Name: " + param.Name + Environment.NewLine;
paramInfo += "Desc: " + param.Desc + Environment.NewLine;
paramInfo += "MinValue: " + param.MinValue + Environment.NewLine;
paramInfo += "MaxValue: " + param.MaxValue + Environment.NewLine;
paramInfo += "StdValue: " + param.StdValue + Environment.NewLine;
paramInfo += "Options: " + string.Join(", ", param.Options) + Environment.NewLine;
paramInfo += Environment.NewLine;
}
}
// close
paramInfo += "------------------------" + Environment.NewLine;
// write to console
logger.Info(paramInfo);
}
public bool setValue(string paramName, string paramValue)
{
lock (lockParameters) {
iParam param = getParameter(paramName);
if (param == null)
{
logger.Error("Could not find parameter '" + paramName + "' in parameter set '" + paramSetName + "', value not set");
return(false);
}
// call setter of the parameter for further processing
if (!param.setValue(paramValue))
{
return(false);
}
// return success
return(true);
}
}
public static T getValue <T>(string paramName)
{
lock (lockParameters) {
// retrieve the parameter
iParam param = getParameter(paramName);
// create the parameter if it does not exist
if (param == null)
{
param = addParameter <T>(paramName);
}
// if not able to create, return 0
if (param == null)
{
return((T)Convert.ChangeType(null, typeof(T)));
}
// return the value
return(param.getValue <T>());
}
}
public Parameters clone(string[] paramListToClone)
{
// if empty list is provided, clone all parameters
if (paramListToClone.Length == 0)
{
logger.Warn("Provided empty list of parameters for cloning. All parameters will be cloned.");
return(clone());
}
else
{
lock (lockParameters) {
// create new parameter object
Parameters clone = new Parameters(this.paramSetName, this.paramSetType);
// get a reference to the clone's parameter list
List <iParam> cloneParamList = clone.getParameters();
// add desired parameters
for (int i = 0; i < paramListToClone.Length; i++)
{
iParam result = getParameter(paramListToClone[i]);
if (result == null)
{
logger.Error("Could not clone parameter " + paramListToClone[i] + " as it is not present in parameterset " + this.paramSetName);
}
else
{
cloneParamList.Add(result);
}
}
// return the clone
return(clone);
}
}
} // end function
private static iParam addParameter <T>(string paramName)
{
// create a new parameter and transfer the properties
iParam param = null;
Type paramType = typeof(T);
if (paramType == typeof(ParamBool) || paramType == typeof(bool) || paramType == typeof(Boolean))
{
param = new ParamBool(paramName, "", null, "", "", new string[0]);
}
else if (paramType == typeof(ParamInt) || paramType == typeof(int))
{
param = new ParamInt(paramName, "", null, "", "", new string[0]);
}
else if (paramType == typeof(ParamDouble) || paramType == typeof(double))
{
param = new ParamDouble(paramName, "", null, "", "", new string[0]);
}
else if (paramType == typeof(ParamBoolArr) || paramType == typeof(bool[]) || paramType == typeof(Boolean[]))
{
param = new ParamBoolArr(paramName, "", null, "", "", new string[0]);
}
else if (paramType == typeof(ParamIntArr) || paramType == typeof(int[]))
{
param = new ParamIntArr(paramName, "", null, "", "", new string[0]);
}
else if (paramType == typeof(ParamDoubleArr) || paramType == typeof(double[]))
{
param = new ParamDoubleArr(paramName, "", null, "", "", new string[0]);
}
else if (paramType == typeof(ParamBoolMat) || paramType == typeof(bool[][]) || paramType == typeof(Boolean[][]))
{
param = new ParamBoolMat(paramName, "", null, "", "", new string[0]);
}
else if (paramType == typeof(ParamIntMat) || paramType == typeof(int[][]))
{
param = new ParamIntMat(paramName, "", null, "", "", new string[0]);
}
else if (paramType == typeof(ParamDoubleMat) || paramType == typeof(double[][]))
{
param = new ParamDoubleMat(paramName, "", null, "", "", new string[0]);
}
else if (paramType == typeof(ParamStringMat) || paramType == typeof(string[][]) || paramType == typeof(String[][]))
{
param = new ParamStringMat(paramName, "", null, "", "", new string[0]);
}
else if (paramType == typeof(ParamColor) || paramType == typeof(RGBColorFloat))
{
param = new ParamColor(paramName, "", null, "", "", new string[0]);
}
else
{
// message
logger.Error("Unknown parameter (generic) type '" + paramType.Name + "' for parameter paramName '" + paramName + "' in globals, discarded.");
// return without adding parameter
return(null);
}
// add the parameter to the list
paramList.Add(param);
return(param);
}
// TODO: max: toch in ParameterManager (static hier om de source, filter en app references op te halen?)
public static void saveParameterFile(string xmlFile, Dictionary <string, Parameters> parameterSets)
{
if (parameterSets == null)
{
return;
}
// check if the filename is not empty
if (string.IsNullOrEmpty(xmlFile))
{
// message
logger.Error("Save parameter file called with invalid filename");
// return
return;
}
// TODO: indent with tabs
// create parameter XML file with encoding declaration
XmlDocument paramFile = new XmlDocument();
XmlNode paramFileNode = paramFile.CreateXmlDeclaration("1.0", "UTF-8", null);
paramFile.AppendChild(paramFileNode);
// add root node
XmlNode rootNode = paramFile.CreateElement("root");
paramFile.AppendChild(rootNode);
// VERSION NODES
// create versions node and add to root node
XmlNode versionsNode = paramFile.CreateElement("versions");
rootNode.AppendChild(versionsNode);
// get data name and version value, and create data version node
int dataVersionValue = Data.getClassVersion();
string dataVersionName = Data.getClassName();
XmlNode dataVersionNode = paramFile.CreateElement("version");
// add name attribute
XmlAttribute dataNameAttr = paramFile.CreateAttribute("name");
dataNameAttr.Value = dataVersionName;
dataVersionNode.Attributes.Append(dataNameAttr);
// add type attribute
XmlAttribute dataTypeAttr = paramFile.CreateAttribute("type");
dataTypeAttr.Value = "data";
dataVersionNode.Attributes.Append(dataTypeAttr);
// add value attribute
XmlAttribute dataValueAttr = paramFile.CreateAttribute("value");
dataValueAttr.Value = dataVersionValue.ToString();
dataVersionNode.Attributes.Append(dataValueAttr);
// add data version node to versions node
versionsNode.AppendChild(dataVersionNode);
// get source name and version value, and create source version node
ISource source = MainThread.getSource();
int sourceVersionValue = source.getClassVersion();
string sourceVersionName = source.getClassName();
XmlNode sourceVersionNode = paramFile.CreateElement("version");
// add name attribute
XmlAttribute sourceNameAttr = paramFile.CreateAttribute("name");
sourceNameAttr.Value = sourceVersionName;
sourceVersionNode.Attributes.Append(sourceNameAttr);
// add type attribute
XmlAttribute sourceTypeAttr = paramFile.CreateAttribute("type");
sourceTypeAttr.Value = "source";
sourceVersionNode.Attributes.Append(sourceTypeAttr);
// add value attribute
XmlAttribute sourceValueAttr = paramFile.CreateAttribute("value");
sourceValueAttr.Value = sourceVersionValue.ToString();
sourceVersionNode.Attributes.Append(sourceValueAttr);
// add source version node to versions node
versionsNode.AppendChild(sourceVersionNode);
// loop through the filters
List <IFilter> filters = MainThread.getFilters();
for (int i = 0; i < filters.Count; i++)
{
// create filter version node
XmlNode filterVersionNode = paramFile.CreateElement("version");
// add name attribute
XmlAttribute filterNameAttr = paramFile.CreateAttribute("name");
filterNameAttr.Value = filters[i].getName();
filterVersionNode.Attributes.Append(filterNameAttr);
// add type attribute
XmlAttribute filterTypeAttr = paramFile.CreateAttribute("type");
filterTypeAttr.Value = "filter";
filterVersionNode.Attributes.Append(filterTypeAttr);
// add value attribute
XmlAttribute fillterValueAttr = paramFile.CreateAttribute("value");
fillterValueAttr.Value = filters[i].getClassVersion().ToString();
filterVersionNode.Attributes.Append(fillterValueAttr);
// add filter version node to versions node
versionsNode.AppendChild(filterVersionNode);
}
// get application version and create application version node
IApplication application = MainThread.getApplication();
int applicationVersionValue = application.getClassVersion();
string applicationVersionName = application.getClassName();
XmlNode applicationVersionNode = paramFile.CreateElement("version");
// add name attribute
XmlAttribute applicationNameAttr = paramFile.CreateAttribute("name");
applicationNameAttr.Value = applicationVersionName;
applicationVersionNode.Attributes.Append(applicationNameAttr);
// add type attribute
XmlAttribute applicationTypeAttr = paramFile.CreateAttribute("type");
applicationTypeAttr.Value = "application";
applicationVersionNode.Attributes.Append(applicationTypeAttr);
// add value attribute
XmlAttribute applicationValueAttr = paramFile.CreateAttribute("value");
applicationValueAttr.Value = applicationVersionValue.ToString();
applicationVersionNode.Attributes.Append(applicationValueAttr);
// add application version node to versions node
versionsNode.AppendChild(applicationVersionNode);
// cycle through parameter sets
foreach (KeyValuePair <string, Parameters> entry in parameterSets)
{
// create parameterSet node
XmlNode parameterSetNode = paramFile.CreateElement("parameterSet");
// add name attribute to parameterSet node and set equal to set name
XmlAttribute parameterSetName = paramFile.CreateAttribute("name");
parameterSetName.Value = entry.Key;
parameterSetNode.Attributes.Append(parameterSetName);
// add parameterSet node to root node
rootNode.AppendChild(parameterSetNode);
// get Parameter object and iParams contained within
Parameters parameterSet = entry.Value;
List <iParam> parameters = parameterSet.getParameters();
// loop throug the parameters in the set
for (int p = 0; p < parameters.Count; p++)
{
iParam parameter = parameters[p];
// create param node
XmlNode paramNode = paramFile.CreateElement("param");
// add name attribute
XmlAttribute paramNameAttr = paramFile.CreateAttribute("name");
paramNameAttr.Value = parameter.Name;
paramNode.Attributes.Append(paramNameAttr);
// add type attribute
XmlAttribute paramTypeAttr = paramFile.CreateAttribute("type");
paramTypeAttr.Value = parameter.GetType().ToString();
paramNode.Attributes.Append(paramTypeAttr);
// add value attribute
XmlAttribute paramValueAttr = paramFile.CreateAttribute("value");
paramValueAttr.Value = parameter.ToString();
paramNode.Attributes.Append(paramValueAttr);
// add param node to parameterSet node
parameterSetNode.AppendChild(paramNode);
}
}
try {
// save xml string to file
paramFile.Save(xmlFile);
// message
logger.Info("Saved parameter file: " + xmlFile);
} catch (Exception e) {
// message error
logger.Error("Unable to save parameter file (" + xmlFile + "). " + e.Message);
}
}
public iParam addParameter <T>(string name, string group, string desc, string minValue, string maxValue, string stdValue, string[] options, Param.ParamSideButton[] buttons)
{
lock (lockParameters) {
// check if a parameter with that name already exists, return without adding if this is the case
if (getParameter(name) != null)
{
logger.Warn("A parameter with the name '" + name + "' already exists in parameter set '" + paramSetName + "', not added.");
return(null);
}
// retrieve the type of parameter
Type paramType = typeof(T);
// only allow for side buttons on string types
if (buttons != null && buttons.Length != 0)
{
if (!(paramType == typeof(ParamString) || paramType == typeof(string) || paramType == typeof(String)))
{
logger.Warn("Discarding extra buttons for parameter '" + name + "' in parameter set '" + paramSetName + "', extra buttons are only allowed for parameters of the String-type");
buttons = null;
}
else if (paramType == typeof(ParamFileString))
{
logger.Warn("Discarding extra buttons for parameter '" + name + "' in parameter set '" + paramSetName + "', only a browse button will be added for a parameter of the type FileString");
buttons = null;
}
}
// create a new parameter and transfer the properties
iParam param = null;
if (paramType == typeof(ParamBool) || paramType == typeof(bool) || paramType == typeof(Boolean))
{
param = new ParamBool(name, group, this, desc, stdValue, options);
}
else if (paramType == typeof(ParamInt) || paramType == typeof(int))
{
param = new ParamInt(name, group, this, desc, stdValue, options);
}
else if (paramType == typeof(ParamDouble) || paramType == typeof(double))
{
param = new ParamDouble(name, group, this, desc, stdValue, options);
}
else if (paramType == typeof(ParamBoolArr) || paramType == typeof(bool[]) || paramType == typeof(Boolean[]))
{
param = new ParamBoolArr(name, group, this, desc, stdValue, options);
}
else if (paramType == typeof(ParamIntArr) || paramType == typeof(int[]))
{
param = new ParamIntArr(name, group, this, desc, stdValue, options);
}
else if (paramType == typeof(ParamDoubleArr) || paramType == typeof(double[]))
{
param = new ParamDoubleArr(name, group, this, desc, stdValue, options);
}
else if (paramType == typeof(ParamBoolMat) || paramType == typeof(bool[][]) || paramType == typeof(Boolean[][]))
{
param = new ParamBoolMat(name, group, this, desc, stdValue, options);
}
else if (paramType == typeof(ParamIntMat) || paramType == typeof(int[][]))
{
param = new ParamIntMat(name, group, this, desc, stdValue, options);
}
else if (paramType == typeof(ParamDoubleMat) || paramType == typeof(double[][]))
{
param = new ParamDoubleMat(name, group, this, desc, stdValue, options);
}
else if (paramType == typeof(ParamString) || paramType == typeof(string) || paramType == typeof(String))
{
param = new ParamString(name, group, this, desc, stdValue, options, buttons);
}
else if (paramType == typeof(ParamFileString))
{
param = new ParamFileString(name, group, this, desc, stdValue, options);
}
else if (paramType == typeof(ParamStringMat) || paramType == typeof(string[][]) || paramType == typeof(String[][]))
{
param = new ParamStringMat(name, group, this, desc, stdValue, options);
}
else if (paramType == typeof(ParamColor) || paramType == typeof(RGBColorFloat))
{
param = new ParamColor(name, group, this, desc, stdValue, options);
}
else
{
// message
logger.Error("Unknown parameter (generic) type '" + paramType.Name + "' for parameter name '" + name + "' in parameter set '" + paramSetName + "', not added.");
// return without adding parameter
return(null);
}
// check if the parameter is integer based
if (param is ParamIntBase)
{
// check if the minimum value is valid
if (!((ParamIntBase)param).setMinValue(minValue))
{
// message
logger.Error("Could not add parameter '" + name + "' in parameter set '" + paramSetName + "', minimum value '" + minValue + "' could not be parsed as an integer");
// return without adding parameter
return(null);
}
// check if the maximum value is valid
if (!((ParamIntBase)param).setMaxValue(maxValue))
{
// message
logger.Error("Could not add parameter '" + name + "' in parameter set '" + paramSetName + "', maximum value '" + maxValue + "' could not be parsed as an integer");
// return without adding parameter
return(null);
}
}
// check if the parameter is double based
if (param is ParamDoubleBase)
{
// check if the minimum value is valid
if (!((ParamDoubleBase)param).setMinValue(minValue))
{
// message
logger.Error("Could not add parameter '" + name + "' in parameter set '" + paramSetName + "', minimum value '" + minValue + "' could not be parsed as an integer");
// return without adding parameter
return(null);
}
// check if the maximum value is valid
if (!((ParamDoubleBase)param).setMaxValue(maxValue))
{
// message
logger.Error("Could not add parameter '" + name + "' in parameter set '" + paramSetName + "', maximum value '" + maxValue + "' could not be parsed as an integer");
// return without adding parameter
return(null);
}
}
// check if there is a standard value given
if (!String.IsNullOrEmpty(stdValue))
{
// set the standard value as initial value
if (!param.setValue(param.StdValue))
{
// message
logger.Error("Standard value for parameter '" + name + "' in parameter set '" + paramSetName + "' is invalid, parameter not added");
// return without adding parameter
return(null);
}
}
// add the parameter to the list
paramList.Add(param);
return(param);
}
}
