public void ConstructorSetsName()
{
var name = "newParam";
var parameter = new BooleanParameter(name);
Assert.AreEqual(name, parameter.Name);
}
private static void addParameter(Instruction instruction, int childIndex, ParameterReader paramData, GameObject parent)
{
string type = paramData.readWord().ToLower();
if (type.Equals("boolean"))
{
BooleanParameter boolean = (BooleanParameter)instruction.addBooleanChild();
boolean.Valeur = paramData.readBoolean();
}
else if (type.Equals("integer"))
{
IntegerParameter integer = (IntegerParameter)instruction.addIntegerChild();
integer.Valeur = paramData.readInt();
if (paramData.hasNextWord())
{
addIntegerMethod(integer, paramData.readWord(), instruction.gameObject);
}
if (paramData.hasNextWord())
{
integer.autoCompile = paramData.readBoolean();
}
}
else
{
Debug.LogError("MAPLOADER - ERROR : Unknown parameter type for " + type);
}
}
public override void InitParameters()
{
Parameters = new List<AlgorithmParameter>();
AlgorithmParameter logSize = new IntParameter(
"LoG Filter Size", "LFR", 9, 3, 101);
Parameters.Add(logSize);
AlgorithmParameter logSigma = new DoubleParameter(
"LoG Filter Sigma (Dev)", "LFD", 1.6f, 0.5f, 10.0f);
Parameters.Add(logSigma);
AlgorithmParameter matchPatchSize = new IntParameter(
"Correlation Matching Patch Size", "CMPS", 5, 3, 101);
Parameters.Add(matchPatchSize);
AlgorithmParameter useSmoothCorrelation = new BooleanParameter(
"Use Smoothed Correlation", "USC", false);
Parameters.Add(useSmoothCorrelation);
AlgorithmParameter correlationThreshold = new DoubleParameter(
"Correlation Matching Threshold", "CMT", 0.90f, 0.0f, 1.0f);
Parameters.Add(correlationThreshold);
AlgorithmParameter maxDisp = new IntParameter(
"Max Expected Disparity Along Epiline", "MD", 30, 0, 30000);
Parameters.Add(maxDisp);
}
private static void TestParameterIs(BooleanParameter p, bool val, string valueAsString = null)
{
Assert.That(p.Value, Is.EqualTo(val));
bool result;
bool isBool;
if (valueAsString == null)
{
Assert.That(p.Corrupted, Is.False);
Assert.That(p.ValueAsString(), Is.EqualTo(val.ToString())); //Tempting to simply verify it will parse as the correct value but we need to be consistent with existing files
}
else
{
Assert.That(p.Corrupted, Is.True);
Assert.That(p.ValueAsString(), Is.EqualTo(valueAsString));
}
using (TemporaryCulture.English())
{
isBool = bool.TryParse(p.DisplayValue((a, b) => ""), out result);
Assert.That(isBool);
if (isBool)
{
Assert.That(result, Is.EqualTo(val));
}
}
using (TemporaryCulture.European())
{
isBool = bool.TryParse(p.DisplayValue((a, b) => ""), out result);
Assert.That(isBool);
if (isBool)
{
Assert.That(result, Is.EqualTo(val));
}
}
}
public void Clones_Have_Same_Value()
{
BooleanParameter p0 = new BooleanParameter("id", null, true);
BooleanParameter p1 = p0.Clone() as BooleanParameter;
Assert.AreEqual((bool)p0.GetValue(), (bool)p1.GetValue());
}
public PolarTrig2D() : base()
{
parameterMap = new ParameterMap();
emission = new FloatParameter("Emission", new float[] { }, new ParameterRange(0, 60), 10, ParameterDictionary.EmissionKey);
XRadius = new FloatParameter("X Radius", new float[] { 1f, 2f, 3f, 4f }, new ParameterRange(0, 5f), 1, ParameterDictionary.X_RadiusKey);
YRadius = new FloatParameter("Y Radius", new float[] { 1f, 2f, 3f, 4f }, new ParameterRange(0, 5f), 1, ParameterDictionary.Y_RadiusKey);
SyncRadius = new BooleanParameter("Synch Radius", ParameterDictionary.SyncRadiusKey, true);
SineCoefficient = new FloatParameter("Sine Coeffecient", new float[] { }, new ParameterRange(0, 50), 5, ParameterDictionary.SineCoefKey);
CosineCoefficient = new FloatParameter("Cosine Coeffecient", new float[] { }, new ParameterRange(0, 50), 19, ParameterDictionary.CosCoefKey);
SineExponent = new FloatParameter("Sine Exponent", new float[] { 0.5f, 1f, 2f, 3f, 4f }, new ParameterRange(0.25f, 4f), 2, ParameterDictionary.SineExponentKey);
CosineExponent = new FloatParameter("Cosine Exponent", new float[] { 0.5f, 1f, 2f, 3f, 4f }, new ParameterRange(0.25f, 4f), 2, ParameterDictionary.CosExponentKey);
Hue = new FloatParameter("Hue", new float[] { }, new ParameterRange(0, 360), 0, ParameterDictionary.HueKey);
Saturation = new FloatParameter("Saturation", new float[] { }, new ParameterRange(0, 1), 0.8f, ParameterDictionary.SaturationKey);
Brightness = new FloatParameter("Brightness", new float[] { }, new ParameterRange(0, 1), 0.8f, ParameterDictionary.BrightnessKey);
Alpha = new FloatParameter("Alpha", new float[] { }, new ParameterRange(0, 1f), 0.5f, ParameterDictionary.AlphaKey);
Theta = new FloatParameter("Theta", new float[] { Mathf.PI / 2, Mathf.PI, 3 * Mathf.PI / 2 }, new ParameterRange(0, 2 * Mathf.PI), 3.14f, ParameterDictionary.ThetaKey);
parameterMap.AddFloatParameter(emission, ParameterDictionary.EmissionKey);
parameterMap.AddFloatParameter(XRadius, ParameterDictionary.X_RadiusKey);
parameterMap.AddFloatParameter(YRadius, ParameterDictionary.Y_RadiusKey);
parameterMap.AddBoolParameter(SyncRadius, ParameterDictionary.SyncRadiusKey);
parameterMap.AddFloatParameter(SineCoefficient, ParameterDictionary.SineCoefKey);
parameterMap.AddFloatParameter(CosineCoefficient, ParameterDictionary.CosCoefKey);
parameterMap.AddFloatParameter(SineExponent, ParameterDictionary.SineExponentKey);
parameterMap.AddFloatParameter(CosineExponent, ParameterDictionary.CosExponentKey);
parameterMap.AddFloatParameter(Hue, ParameterDictionary.HueKey);
parameterMap.AddFloatParameter(Saturation, ParameterDictionary.SaturationKey);
parameterMap.AddFloatParameter(Brightness, ParameterDictionary.BrightnessKey);
parameterMap.AddFloatParameter(Alpha, ParameterDictionary.AlphaKey);
parameterMap.AddFloatParameter(Theta, ParameterDictionary.ThetaKey);
}
public void PressiusTestObject_ShouldPermutate()
{
var pressiusTestObjectList = Permutor.Generate <PressiusTestObject>();
pressiusTestObjectList.ShouldNotBeNull();
var objectList = pressiusTestObjectList.ToList();
objectList.Count.ShouldBeGreaterThan(0);
var integerParams = new IntegerParameter();
var stringParams = new StringParameter();
var booleanParams = new BooleanParameter();
var decimalParams = new DecimalParameter();
var id = 1;
objectList.ForEach(obj =>
{
_output.WriteLine("Obj: {0} {1} {2} {3} {4} {5} {6}",
obj.Id, obj.Name, obj.Address,
obj.NullableInteger, obj.DecimalValue, obj.BooleanValue, obj.Created);
obj.Id.ShouldBe(id);
integerParams.InputCatalogues.ShouldContain(obj.NullableInteger);
stringParams.InputCatalogues.ShouldContain(obj.Name);
stringParams.InputCatalogues.ShouldContain(obj.Address);
booleanParams.InputCatalogues.ShouldContain(obj.BooleanValue);
decimalParams.InputCatalogues.ShouldContain(obj.DecimalValue);
id++;
});
}
public BooleanParameter addBooleanChild()
{
GameObject go = createChild();
BooleanParameter parameter = go.AddComponent <BooleanParameter>();
return(parameter);
}
public void SetGetProperties()
{
var parameter = new BooleanParameter();
var trueValue = new NameValuePair("TrueName", "TrueValue");
var falseValue = new NameValuePair("FalseName", "FalseValue");
parameter.TrueValue = trueValue;
parameter.FalseValue = falseValue;
Assert.AreEqual(typeof(string), parameter.DataType, "DataType does not match");
Assert.AreSame(trueValue, parameter.TrueValue);
Assert.AreSame(falseValue, parameter.FalseValue);
Assert.IsNotNull(parameter.AllowedValues);
Assert.AreEqual(2, parameter.AllowedValues.Length);
Assert.AreEqual(trueValue.Name, parameter.AllowedValues[0]);
Assert.AreEqual(falseValue.Name, parameter.AllowedValues[1]);
parameter.IsRequired = false;
Assert.AreEqual(false, parameter.IsRequired, "IsRequired does not match");
parameter.IsRequired = true;
Assert.AreEqual(true, parameter.IsRequired, "IsRequired does not match");
parameter.Description = "Some description goes here";
Assert.AreEqual("Some description goes here", parameter.Description, "Description does not match");
parameter.Name = "Some name";
Assert.AreEqual("Some name", parameter.Name, "Name does not match");
Assert.AreEqual("Some name", parameter.DisplayName, "DisplayName does not match");
parameter.DisplayName = "Another name";
Assert.AreEqual("Another name", parameter.DisplayName, "DisplayName does not match");
}
public void Get_NotFoundParameter_ThrowsArgumentException()
{
BooleanParameter b = new BooleanParameter("id", "caption", true);
ParameterContainer collection = new ParameterContainer(new[] { b });
collection.Get <bool>("none");
}
private static BooleanParameter GenerateParameter()
{
var parameter = new BooleanParameter();
parameter.TrueValue = new NameValuePair("trueName", "trueValue");
parameter.FalseValue = new NameValuePair("falseName", "falseValue");
return(parameter);
}
public void Get_InvalidTypeParameter_ThrowsInvalidCastException()
{
BooleanParameter b = new BooleanParameter("id", "caption", true);
ParameterContainer collection = new ParameterContainer(new[] { b });
collection.Get <String>("id");
}
public IList <ProcParam <SequenceProcEnv> > GetParameters()
{
// 仮引数作成
var label = new SequenceSingleSelectParameter("Target", viewer => (viewer.Type & SequenceType.Label) != 0);
var append = new BooleanParameter("Append Title to label");
return(new ProcParam <SequenceProcEnv>[] { label, append });
}
public override async UniTask ExecuteAsync(CancellationToken cancellationToken = default)
{
var actorId = IdAndAppearance.Name;
var manager = Engine.GetAllServices <IActorManager>(c => c.ActorExists(actorId)).FirstOrDefault();
if (manager is null)
{
LogErrorWithPosition($"Can't find a manager with `{actorId}` actor.");
return;
}
var tasks = new List <UniTask>();
var cameraConfig = Engine.GetConfiguration <CameraConfiguration>();
var actor = manager.GetActor(actorId);
var fromPos = new Vector3(
FromPosition?.ElementAtOrNull(0)?.HasValue ?? false ? cameraConfig.SceneToWorldSpace(new Vector2(FromPosition[0] / 100f, 0)).x :
actor.Visible ? actor.Position.x : cameraConfig.SceneToWorldSpace(new Vector2(Random.value > .5f ? -.1f : 1.1f, 0)).x,
FromPosition?.ElementAtOrNull(1)?.HasValue ?? false ? cameraConfig.SceneToWorldSpace(new Vector2(0, FromPosition[1] / 100f)).y : actor.Position.y,
FromPosition?.ElementAtOrNull(2) ?? actor.Position.z);
var toPos = new Vector3(
ToPosition.ElementAtOrNull(0)?.HasValue ?? false ? cameraConfig.SceneToWorldSpace(new Vector2(ToPosition[0] / 100f, 0)).x : actor.Position.x,
ToPosition.ElementAtOrNull(1)?.HasValue ?? false ? cameraConfig.SceneToWorldSpace(new Vector2(0, ToPosition[1] / 100f)).y : actor.Position.y,
ToPosition.ElementAtOrNull(2) ?? actor.Position.z);
var easingType = manager.ActorManagerConfiguration.DefaultEasing;
if (Assigned(EasingTypeName) && !System.Enum.TryParse(EasingTypeName, true, out easingType))
{
LogWarningWithPosition($"Failed to parse `{EasingTypeName}` easing.");
}
actor.Position = fromPos;
if (!actor.Visible)
{
if (IdAndAppearance.NamedValue.HasValue)
{
actor.Appearance = IdAndAppearance.NamedValue;
}
Visible = true;
}
else if (IdAndAppearance.NamedValue.HasValue)
{
tasks.Add(actor.ChangeAppearanceAsync(IdAndAppearance.NamedValue, Duration, easingType, null, cancellationToken));
}
if (Assigned(Visible))
{
tasks.Add(actor.ChangeVisibilityAsync(Visible, Duration, easingType, cancellationToken));
}
tasks.Add(actor.ChangePositionAsync(toPos, Duration, easingType, cancellationToken));
await UniTask.WhenAll(tasks);
}
public IList <ProcParam <SequenceProcEnv> > GetParameters()
{
var target = new LabelSelectParameter("対象のラベル", true);
var length = new NumberParameter("秒数", 0, 10000, 3);
var action = new SingleSelectParameter("大小", new[] { "「秒数」より短いものを置換", "「秒数」より長いものを置換" });
var border = new BooleanParameter("「秒数」に一致するものを置換");
var glue = new SingleSelectParameter("置換結果", new[] { "空ラベル", "前後のラベルが等しければそのラベル", "直前のラベル", "直後のラベル" });
return(new ProcParam <SequenceProcEnv>[] { target, length, action, border, glue });
}
public IList <ProcParam <SequenceProcEnv> > GetParameters()
{
LabelSelectParameter border = new LabelSelectParameter("Target Label", true);
NumberParameter left = new NumberParameter("Extend second before Begin", -1000, 1000, 3);
NumberParameter right = new NumberParameter("Extend second after End", -1000, 1000, 3);
BooleanParameter percent = new BooleanParameter("Values as Percentage of Label length");
BooleanParameter withEmpty = new BooleanParameter("Fill with Empty label when shrink");
return(new ProcParam <SequenceProcEnv>[] { border, left, right, percent, withEmpty });
}
public IList <ProcParam <SequenceProcEnv> > GetParameters()
{
var operand = new SequenceMultiSelectParameter("Other operands", (v) => v.Type != SequenceType.Numeric);
var sep = new StringParameter("Separator");
sep.Value = "+";
var useEmpty = new BooleanParameter("Use Empty Label");
return(new ProcParam <SequenceProcEnv>[] { operand, sep, useEmpty });
}
public IList <ProcParam <SequenceProcEnv> > GetParameters()
{
BooleanParameter useAvg = new BooleanParameter("平均を引く");
useAvg.Value = true;
BooleanParameter useStddev = new BooleanParameter("標準偏差で割る");
useStddev.Value = true;
return(new ProcParam <SequenceProcEnv>[] { useAvg, useStddev });
}
public IList <ProcParam <SequenceProcEnv> > GetParameters()
{
var glue = new StringParameter("Text to Concat");
glue.Value = "-TO-";
var type = new SingleSelectParameter("Type", new[] { "Previous-Current", "Current-Next" });
var skip = new BooleanParameter("Skip Empty Label");
return(new ProcParam <SequenceProcEnv>[] { glue, type, skip });
}
public static void TestNullDefault()
{
string name = "name";
Id <Parameter> id = Id <Parameter> .Parse("7BE05FD5-B8FC-4E07-A1F0-4228678AD055");
BooleanParameter p = new BooleanParameter(name, id, null);
Assert.That(p.Corrupted, Is.True);
p.TryDeserialiseValue("true");
TestParameterIs(p, true);
}
public IList <ProcParam <SequenceProcEnv> > GetParameters()
{
var row = new SequenceMultiSelectParameter("Sequence for Target Label", x => x.Type != SequenceType.Numeric);
var sep = new StringParameter("Separator");
sep.Value = "+";
var multi = new BooleanParameter("Allow Multi-Label per one row");
var useEmpty = new BooleanParameter("Use Empty Label");
return(new ProcParam <SequenceProcEnv>[] { row, sep, multi, useEmpty });
}
public void IsRequiredWithBlank()
{
var parameter = new BooleanParameter();
parameter.Name = "Test";
parameter.IsRequired = true;
var results = parameter.Validate(string.Empty);
Assert.AreEqual(1, results.Length, "Number of exceptions does not match");
Assert.AreEqual("Value of 'Test' is required", results[0].Message, "Exception message does not match");
}
public void ImplicitOperator_ReturnsValue()
{
BooleanParameter p = new BooleanParameter("id", null, true);
if (p)
{
Assert.Pass();
}
Assert.Fail();
}
public IList <ProcParam <SequenceProcEnv> > GetParameters()
{
List <ProcParam <SequenceProcEnv> > ret = new List <ProcParam <SequenceProcEnv> >();
var label = new SequenceSingleSelectParameter("Target");
ret.Add(label);
var sameOnly = new BooleanParameter("Same Label Text Only");
sameOnly.Value = true;
ret.Add(sameOnly);
return(ret);
}
public override void InitParameters()
{
base.InitParameters();
AlgorithmParameter tresh = new DoubleParameter(
"Treshold", "TH", 0.5, 0.0, 1.0);
Parameters.Add(tresh);
AlgorithmParameter inversed = new BooleanParameter(
"Inverse Brightness", "IB", false);
Parameters.Add(inversed);
}
public override void swapWith(Parameter otherParameter)
{
if (otherParameter is BooleanParameter)
{
BooleanParameter other = (BooleanParameter)otherParameter;
var tmp = this.Valeur;
this.Valeur = other.Valeur;
other.Valeur = tmp;
this.transform.parent.GetComponent <Instruction> ().refresh();
other.transform.parent.GetComponent <Instruction> ().refresh();
}
}
public override IEnumerable <Parameter> CreateParameters(string parameterPrefix)
{
OscillatorType = new EnumParameter <EOscillatorType>(parameterPrefix + "Osc", "LFO Type", "Osc", false);
Frequency = new FrequencyParameter(parameterPrefix + "Frq", "LFO Frequency", "Frq", 0.01, 1000);
MatchKey = new BooleanParameter(parameterPrefix + "Mtch", "LFO Phase Key Link", "Match", false);
Gain = new RealParameter(parameterPrefix + "Gain", "LFO Gain", "Gain", 0, 1, 0.01, false);
TargetParameter = new ParameterName(parameterPrefix, Processor.PluginController.ParametersManager);
TargetParameter.OnValueChange += TargetParameterNumberOnValueChange;
return(new List <Parameter> {
OscillatorType, Frequency, MatchKey, Gain, TargetParameter
});
}
public static void Test()
{
string name = "name";
Id <Parameter> id = Id <Parameter> .Parse("7BE05FD5-B8FC-4E07-A1F0-4228678AD055");
BooleanParameter p = new BooleanParameter(name, id, "false");
Assert.That(p.Id, Is.EqualTo(id));
Assert.That(p.Name, Is.EqualTo(name));
Assert.That(p.TypeId, Is.EqualTo(BooleanParameter.ParameterType));
Assert.That(p.Corrupted, Is.False);
TestParameterIs(p, false);
p.TryDeserialiseValue("shane");
TestCorrupt(p, "shane");
//Test what happens if we undo back to an invalid state
var actions = p.SetValueAction(true);
actions.Value.Redo();
TestParameterIs(p, true);
actions.Value.Undo();
TestCorrupt(p, "shane");
p.TryDeserialiseValue("true");
TestParameterIs(p, true);
Assert.Throws <ArgumentNullException>(() => { p.TryDeserialiseValue(null); });
TestParameterIs(p, true);
//Get into a known state where Value==true
if (p.Value == false)
{
p.SetValueAction(true).Value.Redo();
}
Assert.That(p.SetValueAction(true), Is.Null);
var set = p.SetValueAction(false);
TestParameterIs(p, true);
set.Value.Redo();
TestParameterIs(p, false);
set.Value.Undo();
TestParameterIs(p, true);
}
public BooleanParameter CreateBooleanParameter(string parameterName)
{
if (string.IsNullOrEmpty(parameterName))
{
throw new ArgumentException("Invalid parameter name");
}
if (_Parameters.ContainsKey(parameterName))
{
throw new ArgumentException("parameter name already exist");
}
BooleanParameter parameter = new BooleanParameter(parameterName, this);
_Parameters.Add(parameterName, parameter);
return(parameter);
}
public void PressiusTestObject_UsingXunitTheory_ShouldCreateMultiple(int id, string name, string address,
int?nullableInteger, decimal decimalValues, bool booleanValues, DateTime created)
{
var integerParams = new IntegerParameter();
var stringParams = new StringParameter();
var booleanParams = new BooleanParameter();
var decimalParams = new DecimalParameter();
_output.WriteLine("Obj: {0} {1} {2} {3} {4} {5} {6}", id, name, address, nullableInteger,
decimalValues, booleanValues, created);
//integerParams.InputCatalogues.ShouldContain(id);
integerParams.InputCatalogues.ShouldContain(nullableInteger);
stringParams.InputCatalogues.ShouldContain(name);
stringParams.InputCatalogues.ShouldContain(address);
booleanParams.InputCatalogues.ShouldContain(booleanValues);
decimalParams.InputCatalogues.ShouldContain(decimalValues);
}
public override void InitParameters()
{
base.InitParameters();
AlgorithmParameter windowRadiusParam = new IntParameter(
"Patch Radius", "WRAD", 4, 1, 20);
Parameters.Add(windowRadiusParam);
AlgorithmParameter mahalParam = new BooleanParameter(
"Use Mahalanobis Distance", "MAHAL", true);
Parameters.Add(mahalParam);
AlgorithmParameter centerParam = new BooleanParameter(
"Use Centered Moments", "CENTER", false);
Parameters.Add(centerParam);
AlgorithmParameter scaleParam = new BooleanParameter(
"Use Scaled Moments", "SCALE", true);
Parameters.Add(scaleParam);
}
public void TestBooleanParameter()
{
var xml = @"<parameterDefinition>
<defaultParameterValue>
<value>true</value>
</defaultParameterValue>
<description>Select a checkbox option</description>
<name>BOOLEAN.1</name>
<type>BooleanParameterDefinition</type>
</parameterDefinition>";
var xDoc = XDocument.Parse(xml).Descendants().First();
var boolean = new BooleanParameter(xDoc);
Assert.AreEqual(boolean.Name, "BOOLEAN.1");
Assert.AreEqual(boolean.Description, "Select a checkbox option");
Assert.AreEqual(boolean.ParameterType, BuildParameterType.BooleanParameterDefinition);
Assert.AreEqual(boolean.DefaultValue, "true");
// Check the ParameterBase values
var ccNetBooleanParameter = boolean.ToParameterBase();
}
private KeyValuePair <string, string> ParseParameter(IDocumentGeneratorParameter visitable)
{
if (visitable is BooleanParameter)
{
BooleanParameter b = visitable as BooleanParameter;
return(new KeyValuePair <string, string>(b.LookingTag, Convert.ToString(b.Value)));
}
if (visitable is CharParameter)
{
CharParameter ch = visitable as CharParameter;
return(new KeyValuePair <string, string>(ch.LookingTag, ch.Value.ToString()));
}
if (visitable is FloatParameter)
{
FloatParameter f = visitable as FloatParameter;
return(new KeyValuePair <string, string>(f.LookingTag, f.Value.ToString("00.000")));
}
if (visitable is GuidParameter)
{
GuidParameter g = visitable as GuidParameter;
return(new KeyValuePair <string, string>(g.LookingTag, g.Value.ToString()));
}
if (visitable is IntParameter)
{
IntParameter i = visitable as IntParameter;
return(new KeyValuePair <string, string>(i.LookingTag, i.Value.ToString()));
}
if (visitable is StringParameter)
{
StringParameter s = visitable as StringParameter;
return(new KeyValuePair <string, string>(s.LookingTag, HttpUtility.HtmlDecode(s.Value)));
}
if (visitable is DateTimeParameter)
{
DateTimeParameter d = visitable as DateTimeParameter;
return(new KeyValuePair <string, string>(d.LookingTag, d.Value.ToShortDateString()));
}
throw new DSWException($"Parameter '{visitable.GetType().Name}' is not correct", null, DSWExceptionCode.Invalid);
}
public override void InitParameters()
{
base.InitParameters();
AlgorithmParameter treshLow = new DoubleParameter(
"Size Elimination Threshold Low", "SETL", 0.1, 0.0001, 1.0);
Parameters.Add(treshLow);
AlgorithmParameter treshHigh = new DoubleParameter(
"Size Elimination Threshold High", "SETH", 10.0, 1.0, 1000.0);
Parameters.Add(treshHigh);
AlgorithmParameter useMedianFilter = new BooleanParameter(
"Use Median Prefiltering", "UMF", false);
Parameters.Add(useMedianFilter);
AlgorithmParameter medianFilterRadous = new IntParameter(
"Median Filter Radius (opt)", "MFR", 3, 1, 9);
Parameters.Add(medianFilterRadous);
AlgorithmParameter doStretch = new BooleanParameter(
"Stretch/Saturate histogram", "SSH", false);
Parameters.Add(doStretch);
AlgorithmParameter saturateDark = new DoubleParameter(
"Dark saturation treshold", "DSH", 0.2, 0.0, 1.0);
Parameters.Add(saturateDark);
AlgorithmParameter saturateLight = new DoubleParameter(
"Light saturation treshold", "LSH", 0.8, 0.0, 1.0);
Parameters.Add(saturateLight);
}
public override void InitParameters()
{
Parameters = new List<AlgorithmParameter>();
AlgorithmParameter winRadius = new IntParameter(
"Filter Window Size", "FWS", 3, 1, 99);
Parameters.Add(winRadius);
AlgorithmParameter filterBorder = new BooleanParameter(
"Filter Border", "FB", true);
Parameters.Add(filterBorder);
}
public override void InitParameters()
{
base.InitParameters();
DoubleParameter maxDiffParam = new DoubleParameter(
"Max Disparity Difference", "DIFF", 2.0, 0.0, 10000.0);
Parameters.Add(maxDiffParam);
IntParameter minSegmentParam = new IntParameter(
"Min Segment Size", "SEG", 6, 1, 10000);
Parameters.Add(minSegmentParam);
BooleanParameter interpolateParam = new BooleanParameter(
"Interpolate Invalidated Segments", "INT", false);
Parameters.Add(interpolateParam);
}
public void InitParameters()
{
Parameters = new List<AlgorithmParameter>();
AlgorithmParameter linOnly = new BooleanParameter(
"Perform only linear estimation", "LIN", false);
Parameters.Add(linOnly);
AlgorithmParameter normLin = new BooleanParameter(
"Normalize points for linear estimation", "NPL", true);
Parameters.Add(normLin);
AlgorithmParameter normIt = new BooleanParameter(
"Normalize points for iterative estimation", "NPI", true);
Parameters.Add(normIt);
AlgorithmParameter cov = new BooleanParameter(
"Use covariance matrix", "COV", true);
Parameters.Add(cov);
AlgorithmParameter skew = new BooleanParameter(
"Minimalise skew", "SKEW", true);
Parameters.Add(skew);
AlgorithmParameter varImgX = new DoubleParameter(
"Image Measurements Variance X", "VIX", 0.25, 0.0, 100.0);
Parameters.Add(varImgX);
AlgorithmParameter varImgY = new DoubleParameter(
"Image Measurements Variance Y", "VIY", 0.25, 0.0, 100.0);
Parameters.Add(varImgY);
AlgorithmParameter varRealX = new DoubleParameter(
"Real Measurements Variance X", "VRX", 1.0, 0.0, 1000.0);
Parameters.Add(varRealX);
AlgorithmParameter varRealY = new DoubleParameter(
"Real Measurements Variance Y", "VRY", 1.0, 0.0, 1000.0);
Parameters.Add(varRealY);
AlgorithmParameter varRealZ = new DoubleParameter(
"Real Measurements Variance Z", "VRZ", 1.0, 0.0, 1000.0);
Parameters.Add(varRealZ);
AlgorithmParameter iters = new IntParameter(
"Max Iterations", "MI", 100, 1, 10000);
Parameters.Add(iters);
AlgorithmParameter eliminate = new BooleanParameter(
"Outliers elimination after linear estimation", "ELIM", false);
Parameters.Add(eliminate);
AlgorithmParameter outCoeff = new DoubleParameter(
"Elimination coeff (elim if e >= m * c)", "ECOEFF", 1.5, 0.0, 1000.0);
Parameters.Add(outCoeff);
AlgorithmParameter overGrids = new BooleanParameter(
"Overwrite grids with estimated", "OVERG", false);
Parameters.Add(overGrids);
}
public override void InitParameters()
{
base.InitParameters();
AlgorithmParameter maskW = new IntParameter(
"Mask Width Radius", "MWR", 3, 1, 6);
_parameters.Add(maskW);
AlgorithmParameter maskH = new IntParameter(
"Mask Height Radius", "MHR", 3, 1, 6);
_parameters.Add(maskH);
AlgorithmParameter useSmooth = new BooleanParameter(
"Use gaussian smoothing", "UGS", false);
_parameters.Add(useSmooth);
AlgorithmParameter smootSgm = new DoubleParameter(
"Smoothing Deviation", "SD", 1.2, 0.01, 10.0);
_parameters.Add(smootSgm);
}
public override void InitParameters()
{
Parameters = new List<AlgorithmParameter>();
AlgorithmParameter intensityThreshold = new DoubleParameter(
"Intensity Difference Threshold", "TI", 0.05f, 0.0f, 1.0f);
Parameters.Add(intensityThreshold);
AlgorithmParameter susanTreshold = new DoubleParameter(
"SUSAN Factor Threshold", "TS", 0.5f, 0.0f, 1.0f);
Parameters.Add(susanTreshold);
AlgorithmParameter performNonmaxSupression = new BooleanParameter(
"Perform NonMax Supression (Corners)", "PS", false);
Parameters.Add(performNonmaxSupression);
AlgorithmParameter checkCenterDistance = new BooleanParameter(
"Check Center Distance (Corners)", "CDist", false);
Parameters.Add(checkCenterDistance);
AlgorithmParameter checkCenterDirection = new BooleanParameter(
"Check Center Direction (Corners)", "CDir", false);
Parameters.Add(checkCenterDirection);
}
