public void Bind(string input, double start, double step, double stop, string ex)
{
var actual = new RangeParameter(input, ((decimal)start, (decimal)step, (decimal)stop));
var expect = new RangeParameter(ex);
Assert.Equal(JsonConvert.SerializeObject(expect), JsonConvert.SerializeObject(actual));
}
public override async IAsyncEnumerable <AlgorithmResultElement> RemoveWatermark([EnumeratorCancellation] CancellationToken ct)
{
ct.ThrowIfCancellationRequested();
var tasks = new List <(Algorithm, IAsyncEnumerable <AlgorithmResultElement>)>();
var lsbParams = new RangeParameter <int>(1, 7, 1).Values();
foreach (var p in lsbParams)
{
var algorithm = new Lsb(new LsbParameters(parameters.Original, parameters.Watermark, parameters.Watermarked, p));
tasks.Add((algorithm, algorithm.RemoveWatermark(ct)));
}
ct.ThrowIfCancellationRequested();
var pixelAveragingParams = new RangeParameter <decimal>(0, 1, 0.1M).Values();
foreach (var p in pixelAveragingParams)
{
var algorithm = new PixelAveraging(new PixelAveragingParameters(parameters.Original, parameters.Watermark, parameters.Watermarked, p));
tasks.Add((algorithm, algorithm.RemoveWatermark(ct)));
}
ct.ThrowIfCancellationRequested();
foreach (var t in tasks)
{
await foreach (var r in t.Item2)
{
r.Description = new ResultDescription(t.Item1.Description);
yield return(r);
}
}
}
public void ConstructorTest()
{
var data = new[] {
new { start = 1, step = 2, stop = 100 },
new { start = 5, step = 3, stop = 100 }
};
foreach (var d in data)
{
var first = new RangeParameter(d.start, d.step, d.stop);
Assert.Equal(d.start, first.Start);
Assert.Equal(d.step, first.Step);
Assert.Equal(d.stop, first.Stop);
var expected = new List <decimal>();
for (var i = d.start; i <= d.stop; i += d.step)
{
expected.Add(i);
}
Microsoft.VisualStudio.TestTools.UnitTesting.CollectionAssert.AreEquivalent(
expected,
first.ToEnumerable().ToList()
);
var second = new RangeParameter((d.start, d.step, d.stop));
Assert.Equal(d.start, second.Start);
Assert.Equal(d.step, second.Step);
Assert.Equal(d.stop, second.Stop);
Microsoft.VisualStudio.TestTools.UnitTesting.CollectionAssert.AreEquivalent(
expected,
second.ToEnumerable().ToList()
);
var third = new RangeParameter($"{d.start},{d.step},{d.stop}");
Assert.Equal(d.start, third.Start);
Assert.Equal(d.step, third.Step);
Assert.Equal(d.stop, third.Stop);
Microsoft.VisualStudio.TestTools.UnitTesting.CollectionAssert.AreEquivalent(
expected,
second.ToEnumerable().ToList()
);
var fourth = new RangeParameter($"{d.start},{d.stop}");
Assert.Equal(d.start, fourth.Start);
Assert.Equal(1, fourth.Step);
Assert.Equal(d.stop, fourth.Stop);
var fifth = new RangeParameter($"{d.start}");
Assert.Equal(d.start, fifth.Start);
Assert.Equal(1, fifth.Step);
Assert.Equal(d.start, fifth.Stop);
}
}
private (List <LsbParameters>, List <PixelAveragingParameters>) PrepareParameters()
{
var(original, watermark, watermarked) = ReadInputBitmaps();
var lsbParams = new RangeParameter <int>(1, 7, 1).Values();
var pixelAveragingParams = new RangeParameter <decimal>(0, 1, 0.1M).Values();
return(lsbParams.Select(x => new LsbParameters(original, watermark, watermarked, x)).ToList(),
pixelAveragingParams.Select(x => new PixelAveragingParameters(original, watermark, watermarked, x)).ToList());
}
/// <summary>
/// InstanceからArgoRequestを作る
/// </summary>
/// <returns></returns>
public ArgoRequest BuildRequest()
{
var hspice = string.IsNullOrEmpty(HspicePath)
? Environment.GetEnvironmentVariable(Argo.EnvArgoHspice)
: HspicePath;
if (string.IsNullOrEmpty(hspice))
{
throw new ArgoException("HspicePath must be set");
}
if (!File.Exists(hspice))
{
throw new ArgoException($"cannot find {hspice}");
}
if (string.IsNullOrEmpty(TargetNetList))
{
throw new ArgoException($"TargetNetList netlist not set");
}
var time = new RangeParameter(TimeString, (0, 100E-12M, 20E-9M));
return(new ArgoRequest {
GroupId = Guid.Empty,
HspicePath = FilePath.FilePath.Expand(hspice),
HspiceOptions = Options.ToList(),
Seed = Seed,
Sweep = Sweep,
SweepStart = SweepStart,
Temperature = (decimal)Temperature,
Transistors = this.Bind(null),
Time = time,
NetList = FilePath.FilePath.Expand(TargetNetList),
Includes = Includes.ToList(),
Vdd = (decimal)Vdd,
Gnd = (decimal)Gnd,
Signals = Signals.ToList(),
ResultFile = FilePath.FilePath.Expand(ResultFile),
IcCommands = IcCommands.ToList(),
PlotTimeList = time.ToEnumerable().ToList()
});
}
/// <summary>
/// Iterates over the given data, which has to match the allocated size, to check whether data points are inside the segment or not.
/// </summary>
/// <param name="segment">The segment this segmentation is going to be applied to.</param>
/// <param name="data">Base data volume</param>
/// <param name="parameters">Range Parameters for the segmentation</param>
/// <returns>The ThreadGroupState to enable progress monitoring and callback on finish. May return null if previous work has not yet been finished.</returns>
public override ThreadGroupState Fit(Segment segment, int[] data, RangeParameter parameters)
{
if (segment._currentWorkload.Working > 0)
{
return(null);
}
segment._currentWorkload.Reset();
segment._currentWorkload.TotalProgress = segment.Slices;
StartFittingRange(segment, data, parameters, parameters.ThreadCount);
return(segment._currentWorkload);
}
protected override void Initialize()
{
base.Initialize ();
if(this.Parameter.GetType() != typeof(RangeParameter)) {
throw new System.ApplicationException("Mismatch Widget and Parameter Type");
}
rangeParameter = (RangeParameter) this.Parameter;
if(rangeParameter.Tick != 1f) {
rangeSlider.wholeNumbers = false;
}
rangeSlider.minValue = rangeParameter.Min;
rangeSlider.maxValue = rangeParameter.Max;
StartCoroutine(WaitAndUpdate(rangeParameter.Value));
}
public void SetUpGameParameters()
{
RangeParameter vol = (RangeParameter)ParameterHandler.Instance.AllParameters[0].GetParameter("SFX Volume");
sfx.volume = vol.Value;
RangeParameter speed = (RangeParameter)ParameterHandler.Instance.AllParameters[0].GetParameter("Bird Speed");
XSpeed = speed.Value;
RangeParameter timemin = (RangeParameter)ParameterHandler.Instance.AllParameters[0].GetParameter("Pipe Spawn Minimum");
pipe.timeMin = timemin.Value;
RangeParameter timemax = (RangeParameter)ParameterHandler.Instance.AllParameters[0].GetParameter("Pipe Spawn Maximum");
pipe.timeMax = timemax.Value;
}
protected override void Initialize()
{
base.Initialize();
if (this.Parameter.GetType() != typeof(RangeParameter))
{
throw new System.ApplicationException("Mismatch Widget and Parameter Type");
}
rangeParameter = (RangeParameter)this.Parameter;
if (rangeParameter.Tick != 1f)
{
rangeSlider.wholeNumbers = false;
}
rangeSlider.minValue = rangeParameter.Min;
rangeSlider.maxValue = rangeParameter.Max;
StartCoroutine(WaitAndUpdate(rangeParameter.Value));
}
/// <summary>
/// This method will update all the variables binded to the Game Parameter "subject"
/// </summary>
/// <param name="subject">Game Parameters inherit Subject class</param>
public void UpdateRoutine(Subject subject)
{
// creating a generic variable egVar and instantiating the correct type
// the eg types are the same implemented as parameters (string, int, bool, double)
egVar var;
GameParameter gp = (GameParameter)subject;
if (subject.GetType() == typeof(IntParameter))
{
IntParameter iP = (IntParameter)subject;
egInt i = iP.Value;
var = i;
}
else if (subject.GetType() == typeof(BoolParameter))
{
BoolParameter bP = (BoolParameter)subject;
egBool b = bP.Value;
var = b;
}
else if (subject.GetType() == typeof(StringListParameter))
{
StringListParameter sP = (StringListParameter)subject;
egString s = sP.Value;
var = s;
}
else if (subject.GetType() == typeof(StringParameter))
{
StringParameter sP = (StringParameter)subject;
egString s = sP.Value;
Debug.Log((string)s + " variable Handler test");
var = s;
}
else if (subject.GetType() == typeof(RangeParameter))
{
RangeParameter fP = (RangeParameter)subject;
egFloat s = fP.Value;
var = s;
}
else
{
// if the type is not registered something went wrong
Debug.Log("ERROR, type: " + subject.GetType() + " not defined as a parameter type. Check parameter types.");
return;
}
//then we will update the variables
UpdateVariables(var, gp.Name);
}
/// <summary>
/// Work portion for one of the worker threads.
/// </summary>
/// <param name="segment">The segment this segmentation is going to be applied to.</param>
/// <param name="data">Base data volume</param>
/// <param name="rangeParameter">Range Parameters for the segmentation</param>
/// <param name="startIndex">Slice Index this thread starts working on</param>
/// <param name="endIndex">Index after the last slice to be worked on</param>
private void FitRangePartially(Segment segment, IReadOnlyList <int> data, RangeParameter rangeParameter, int startIndex, int endIndex)
{
for (var i = startIndex; i < endIndex; ++i)
{
var idxPartId = i * segment.Width * segment.Height;
for (var y = 0; y < segment.Height; ++y)
{
var idxPart = idxPartId + y * segment.Width;
for (var x = 0; x < segment.Width; ++x)
{
var value = data[idxPart + x];
segment.Set(x, y, i, value >= rangeParameter.Lower && value <= rangeParameter.Upper);
}
}
segment._currentWorkload.IncrementProgress();
}
segment._currentWorkload.Done();
}
/// <summary>
/// Starts the worker threads
/// </summary>
/// <param name="segment">The segment this segmentation is going to be applied to.</param>
/// <param name="data">Base data volume</param>
/// <param name="rangeParameter">Range Parameters for the segmentation</param>
/// <param name="threadCount">Number of threads to use</param>
private void StartFittingRange(Segment segment, IReadOnlyList <int> data, RangeParameter rangeParameter, int threadCount)
{
int spacing = segment.Slices / threadCount;
for (var i = 0; i < threadCount; ++i)
{
var startIndex = i * spacing;
var endIndex = startIndex + spacing;
if (i + 1 == threadCount)
{
endIndex = segment.Slices;
}
segment._currentWorkload.Register();
var t = new Thread(() => FitRangePartially(segment, data, rangeParameter, startIndex, endIndex))
{
IsBackground = true
};
t.Start();
}
}
protected override void Initialize()
{
base.Initialize();
if (this.Parameter.GetType() != typeof(RangeParameter))
{
throw new System.ApplicationException("Mismatch Widget and Parameter Type");
}
rangeParameter = (RangeParameter)this.Parameter;
//if (rangeParameter.Tick != 1f)
if (rangeParameter.Tick != (int)rangeParameter.Tick)
{
rangeSlider.wholeNumbers = false;
}
else
{
rangeSlider.wholeNumbers = true;
}
float temp = rangeParameter.Value; //The value gets overwritten by SliderUpdate if min/max changes, so save now to set later.
rangeSlider.minValue = rangeParameter.Min;
rangeSlider.maxValue = rangeParameter.Max;
StartCoroutine(WaitAndUpdate(temp));
}
