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); } }