public void TestWeightedAveragedMerge()
{
YuvKA.VideoModel.Size testSize = new YuvKA.VideoModel.Size(5, 5);
Frame[] inputs = { new Frame(testSize), new Frame(testSize), new Frame(testSize) };
for (int x = 0; x < testSize.Width; x++)
{
for (int y = 0; y < testSize.Height; y++)
{
inputs[0][x, y] = new Rgb((byte)(x + y), (byte)(x + y), (byte)(x + y));
inputs[1][x, y] = new Rgb((byte)(x * y), (byte)(x * y), (byte)(x * y));
inputs[2][x, y] = new Rgb((byte)(x ^ y), (byte)(x ^ y), (byte)(x ^ y));
}
}
WeightedAveragedMergeNode node = new WeightedAveragedMergeNode();
Node.Input testInput = new Node.Input();
node.Inputs.Add(testInput);
ObservableCollection <double> testGetWeights = node.Weights;
// node.Weights is null -> create weights with default value 1.0
Assert.Contains(1.0, testGetWeights);
node.Inputs.Add(testInput);
node.Weights[0] = 0;
node.Weights[1] = 0.25;
node.Inputs.Add(testInput);
testGetWeights = node.Weights;
// node.Weights has not enough values -> fill up missing weights with 1.0
Assert.Contains(1.0, testGetWeights);
Frame[] result = node.Process(inputs, 0);
for (int x = 0; x < testSize.Width; x++)
{
for (int y = 0; y < testSize.Height; y++)
{
Assert.Equal((byte)((0.25 * inputs[1][x, y].R + inputs[2][x, y].R) / 1.25), result[0][x, y].R);
Assert.Equal((byte)((0.25 * inputs[1][x, y].G + inputs[2][x, y].G) / 1.25), result[0][x, y].G);
Assert.Equal((byte)((0.25 * inputs[1][x, y].B + inputs[2][x, y].B) / 1.25), result[0][x, y].B);
}
}
WeightedAveragedMergeNode secondNode = new WeightedAveragedMergeNode {
Weights = { 0.75, 0.75, 0.75 }
};
node.Weights[0] = node.Weights[1] = node.Weights[2] = 0.5;
result = node.Process(inputs, 0);
Frame[] secondResult = secondNode.Process(inputs, 0);
for (int x = 0; x < testSize.Width; x++)
{
for (int y = 0; y < testSize.Height; y++)
{
Assert.Equal(result[0][x, y].R, secondResult[0][x, y].R);
Assert.Equal(result[0][x, y].G, secondResult[0][x, y].G);
Assert.Equal(result[0][x, y].B, secondResult[0][x, y].B);
}
}
}
public void GlobalTest10()
{
MainViewModel mvm = MainViewModelTest.GetInstance();
PipelineViewModel pvm = mvm.PipelineViewModel;
// Step 1: The user clicks "New" to create a new pipeline
mvm.Clear();
Assert.Empty(mvm.Model.Graph.Nodes);
var mock = new Mock <IDragEventInfo>();
// Step 2: Create each type of node once by drag-and-drop
VideoInputNode vin = (VideoInputNode)AddNode <VideoInputNode>(pvm, mock, new Point(10, 30));
AdditiveMergeNode amn = (AdditiveMergeNode)AddNode <AdditiveMergeNode>(pvm, mock, new Point(30, 30));
BlurNode bn = (BlurNode)AddNode <BlurNode>(pvm, mock, new Point(50, 30));
BrightnessContrastSaturationNode bcsn =
(BrightnessContrastSaturationNode)AddNode <BrightnessContrastSaturationNode>(pvm, mock, new Point(70, 30));
ColorInputNode cin = (ColorInputNode)AddNode <ColorInputNode>(pvm, mock, new Point(10, 50));
DelayNode dln = (DelayNode)AddNode <DelayNode>(pvm, mock, new Point(90, 30));
DiagramNode dgn = (DiagramNode)AddNode <DiagramNode>(pvm, mock, new Point(110, 30));
DifferenceNode dfn = (DifferenceNode)AddNode <DifferenceNode>(pvm, mock, new Point(30, 50));
HistogramNode hn = (HistogramNode)AddNode <HistogramNode>(pvm, mock, new Point(50, 50));
ImageInputNode imin = (ImageInputNode)AddNode <ImageInputNode>(pvm, mock, new Point(70, 50));
InverterNode invn = (InverterNode)AddNode <InverterNode>(pvm, mock, new Point(90, 50));
NoiseInputNode nin = (NoiseInputNode)AddNode <NoiseInputNode>(pvm, mock, new Point(110, 50));
OverlayNode on = (OverlayNode)AddNode <OverlayNode>(pvm, mock, new Point(10, 70));
RgbSplitNode rgbsn = (RgbSplitNode)AddNode <RgbSplitNode>(pvm, mock, new Point(30, 70));
WeightedAveragedMergeNode wamn =
(WeightedAveragedMergeNode)AddNode <WeightedAveragedMergeNode>(pvm, mock, new Point(50, 70));
// Step 3: Create the edges
mvm.Model.Graph.AddEdge(vin.Outputs[0], bn.Inputs[0]);
Assert.Equal(vin.Outputs[0], bn.Inputs[0].Source);
amn.Inputs.Add(new Node.Input());
mvm.Model.Graph.AddEdge(vin.Outputs[0], amn.Inputs[0]);
Assert.Equal(vin.Outputs[0], amn.Inputs[0].Source);
mvm.Model.Graph.AddEdge(bn.Outputs[0], dln.Inputs[0]);
Assert.Equal(bn.Outputs[0], dln.Inputs[0].Source);
mvm.Model.Graph.AddEdge(dln.Outputs[0], dfn.Inputs[0]);
Assert.Equal(dln.Outputs[0], dfn.Inputs[0].Source);
mvm.Model.Graph.AddEdge(imin.Outputs[0], dfn.Inputs[1]);
Assert.Equal(imin.Outputs[0], dfn.Inputs[1].Source);
mvm.Model.Graph.AddEdge(dfn.Outputs[0], invn.Inputs[0]);
Assert.Equal(dfn.Outputs[0], invn.Inputs[0].Source);
mvm.Model.Graph.AddEdge(invn.Outputs[0], on.Inputs[0]);
Assert.Equal(invn.Outputs[0], on.Inputs[0].Source);
mvm.Model.Graph.AddEdge(vin.Outputs[0], on.Inputs[1]);
Assert.Equal(vin.Outputs[0], on.Inputs[1].Source);
mvm.Model.Graph.AddEdge(vin.Outputs[0], rgbsn.Inputs[0]);
Assert.Equal(vin.Outputs[0], rgbsn.Inputs[0].Source);
mvm.Model.Graph.AddEdge(rgbsn.Outputs[2], hn.Inputs[0]);
Assert.Equal(rgbsn.Outputs[2], hn.Inputs[0].Source);
}
public void ObservableCollectionOfDoublePropertyViewModelTest()
{
WeightedAveragedMergeNode wamn = new WeightedAveragedMergeNode();
PropertyDescriptor pd = TypeDescriptor.GetProperties(wamn).Find("weights", true);
ObservableCollectionOfDoublePropertyViewModel ocodpvm = new ObservableCollectionOfDoublePropertyViewModel();
ocodpvm.Initialize(wamn, pd);
YuvKA.Pipeline.Node.Input input = new YuvKA.Pipeline.Node.Input();
wamn.Inputs.Add(input);
Assert.Equal(wamn.Inputs.Count(), ocodpvm.Values.Count());
wamn.Inputs.Add(input);
Assert.Equal(2, ocodpvm.Values.Count());
wamn.Weights[1] = 10;
Assert.Equal(wamn.Weights[1], ocodpvm.Values.ElementAt(1).Value);
ocodpvm.Values.ElementAt(1).Value = 1337;
Assert.Equal(1337, wamn.Weights[1]);
}
