public void TestAddNode()
{
// create some nodes and initialize graph
BlurNode blur0 = new BlurNode();
BlurNode blur1 = new BlurNode();
BlurNode blur2 = new BlurNode();
BlurNode blur3 = new BlurNode();
BlurNode blur4 = new BlurNode();
NoiseInputNode noise0 = new NoiseInputNode();
NoiseInputNode noise1 = new NoiseInputNode();
PipelineGraph graph = new PipelineGraph();
graph.AddNode(blur0);
graph.AddNode(blur1);
graph.AddNode(noise0);
graph.AddNode(blur2);
graph.AddNode(noise1);
Assert.Equal("Blur", blur0.Name);
Assert.Equal("Blur 2", blur1.Name);
Assert.Equal("Blur 3", blur2.Name);
Assert.Equal("Noise", noise0.Name);
Assert.Equal("Noise 2", noise1.Name);
graph.RemoveNode(blur1);
graph.AddNode(blur3);
graph.AddNode(blur4);
Assert.Equal("Blur 2", blur3.Name);
Assert.Equal("Blur 4", blur4.Name);
}
public void CantPlayInvalidPipeline()
{
Assert.False(vm.Parent.Model.IsPlaying);
Node graph = new BlurNode();
Assert.False(graph.InputIsValid);
vm.Parent.OpenWindows.Clear();
vm.Parent.OpenWindows.Add(new VideoOutputViewModel(graph.Outputs[0]));
vm.PlayPause();
Assert.False(vm.Parent.Model.IsPlaying);
}
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 TestLinearZeroBlur()
{
Frame[] testFrame = { new Frame(new YuvKA.VideoModel.Size(5, 5)) };
for (int x = 0; x < testFrame[0].Size.Width; x++)
{
for (int y = 0; y < testFrame[0].Size.Height; y++)
{
testFrame[0][x, y] = new Rgb((byte)(10 * x * y), (byte)(10 * x * y), (byte)(10 * x * y));
}
}
BlurNode blur = new BlurNode();
blur.Radius = 0;
Frame[] result = blur.Process(testFrame, 0);
for (int x = 0; x < testFrame[0].Size.Width; x++)
{
for (int y = 0; y < testFrame[0].Size.Height; y++)
{
Assert.Equal(testFrame[0][x, y], result[0][x, y]);
}
}
}
public void EnumerationPropertyViewModelTest()
{
// Since this property viewmodel commits its change as soon as the change is made, the commitChange method
// is executed, which requires a working IoC
IoC.GetInstance = IoCAggregator;
PropertyViewModel en = new EnumerationPropertyViewModel();
BlurNode blur = new BlurNode();
blur.Type = BlurType.Linear;
PropertyDescriptor pd = TypeDescriptor.GetProperties(blur).Find("Type", true);
Assert.NotNull(pd);
en.Initialize(blur, pd);
// Test if binding to property was successful
Assert.Equal("Type", en.DisplayName);
Assert.Equal(((EnumerationPropertyViewModel)en).Choices, new[] { BlurType.Gaussian, BlurType.Linear });
en.Value = BlurType.Gaussian;
Assert.Equal(BlurType.Gaussian, blur.Type);
en.Value = BlurType.Linear;
Assert.Equal(BlurType.Linear, blur.Type);
}
public void TestLinearBlurMonocolor()
{
Frame[] testFrame = { new Frame(new YuvKA.VideoModel.Size(5, 5)) };
for (int i = 0; i < 256; i++)
{
for (int x = 0; x < testFrame[0].Size.Width; x++)
{
for (int y = 0; y < testFrame[0].Size.Height; y++)
{
testFrame[0][x, y] = new Rgb((byte)i, (byte)i, (byte)i);
}
}
BlurNode blur = new BlurNode();
Frame[] result = blur.Process(testFrame, 0);
for (int x = 0; x < testFrame[0].Size.Width; x++)
{
for (int y = 0; y < testFrame[0].Size.Height; y++)
{
Assert.Equal(testFrame[0][x, y], result[0][x, y]);
}
}
}
}
public void EnumerationPropertyViewModelTest()
{
// Since this property viewmodel commits its change as soon as the change is made, the commitChange method
// is executed, which requires a working IoC
IoC.GetInstance = IoCAggregator;
PropertyViewModel en = new EnumerationPropertyViewModel();
BlurNode blur = new BlurNode();
blur.Type = BlurType.Linear;
PropertyDescriptor pd = TypeDescriptor.GetProperties(blur).Find("Type", true);
Assert.NotNull(pd);
en.Initialize(blur, pd);
// Test if binding to property was successful
Assert.Equal("Type", en.DisplayName);
Assert.Equal(((EnumerationPropertyViewModel)en).Choices, new[] { BlurType.Gaussian, BlurType.Linear });
en.Value = BlurType.Gaussian;
Assert.Equal(BlurType.Gaussian, blur.Type);
en.Value = BlurType.Linear;
Assert.Equal(BlurType.Linear, blur.Type);
}
public void Test40()
{
// Step 1: create an arbitrary acyclical pipeline with an input and a manipulation node
MainViewModel mvm = MainViewModelTest.GetInstance();
VideoInputNode video = new VideoInputNode();
BlurNode blur = new BlurNode()
{
Type = BlurType.Gaussian, Radius = 3
};
DisplayNode display = new DisplayNode();
// We'll have to dump this node's output later, so we need a ViewModel
NodeViewModel blurVM = new NodeViewModel(blur, mvm.PipelineViewModel);
mvm.Model.Graph.AddNode(video);
mvm.Model.Graph.AddNode(blur);
mvm.Model.Graph.AddNode(display);
mvm.Model.Graph.AddEdge(video.Outputs[0], blur.Inputs[0]);
mvm.Model.Graph.AddEdge(blur.Outputs[0], display.Inputs[0]);
// Assert that the graph is well-formed
Assert.Contains(video, mvm.Model.Graph.Nodes);
Assert.Contains(blur, mvm.Model.Graph.Nodes);
Assert.Contains(display, mvm.Model.Graph.Nodes);
Assert.Equal(blur.Inputs[0].Source, video.Outputs[0]);
Assert.Equal(display.Inputs[0].Source, blur.Outputs[0]);
// Step 2: change the video input data
Assert.False(display.InputIsValid);
video.FileName = new FilePath(@"..\..\..\..\resources\americanFootball_352x240_125.yuv");
Assert.True(display.InputIsValid);
// Step 3: open the DisplayNode's output and play the video
DisplayViewModel output = display.Window;
Assert.Equal(display, output.NodeModel);
Assert.False(mvm.Model.IsPlaying);
mvm.ReplayStateViewModel.PlayPause();
Assert.True(mvm.Model.IsPlaying);
// Step 4: Change a node's options while the video is playing
blur.Radius = 0;
Assert.True(mvm.Model.IsPlaying);
Assert.True(display.InputIsValid);
// Step 5: change replay speed while video is playing
int oldSpeed = mvm.Model.Speed;
mvm.ReplayStateViewModel.Slower();
Assert.True(oldSpeed > mvm.Model.Speed);
// Step 6: pause the video
mvm.ReplayStateViewModel.PlayPause();
Assert.False(mvm.Model.IsPlaying);
// Step 7: resumes the video
mvm.ReplayStateViewModel.PlayPause();
Assert.True(mvm.Model.IsPlaying);
// Step 8: resets the video playing state
mvm.ReplayStateViewModel.Stop();
Assert.Equal(0, mvm.Model.CurrentTick);
Assert.False(mvm.Model.IsPlaying);
// Step 9: save the video as yuv file
blurVM.SaveNodeOutput(blur.Outputs[0]);
// Since we can't create a FileChooser here, we'll have to invoke the SaveNodeOutputViewModel directly
System.IO.MemoryStream stream = new System.IO.MemoryStream();
SaveNodeOutputViewModel saveVM = new SaveNodeOutputViewModel(blur.Outputs[0], stream, mvm.Model);
Assert.Equal(mvm.Model.Graph.TickCount, saveVM.TickCount);
// I'm sorry for this. I really am. I found no better way of testing this.
System.Threading.Thread.Sleep(1000);
try {
Assert.NotEqual(0, stream.Capacity);
} catch (ObjectDisposedException) {
// This means the SaveNodeOutputViewModel is already done and has disposed of its stream
// That's just another possibility that's just as valid, and signifies proper execution
}
}
public void TestAddNode()
{
// create some nodes and initialize graph
BlurNode blur0 = new BlurNode();
BlurNode blur1 = new BlurNode();
BlurNode blur2 = new BlurNode();
BlurNode blur3 = new BlurNode();
BlurNode blur4 = new BlurNode();
NoiseInputNode noise0 = new NoiseInputNode();
NoiseInputNode noise1 = new NoiseInputNode();
PipelineGraph graph = new PipelineGraph();
graph.AddNode(blur0);
graph.AddNode(blur1);
graph.AddNode(noise0);
graph.AddNode(blur2);
graph.AddNode(noise1);
Assert.Equal("Blur", blur0.Name);
Assert.Equal("Blur 2", blur1.Name);
Assert.Equal("Blur 3", blur2.Name);
Assert.Equal("Noise", noise0.Name);
Assert.Equal("Noise 2", noise1.Name);
graph.RemoveNode(blur1);
graph.AddNode(blur3);
graph.AddNode(blur4);
Assert.Equal("Blur 2", blur3.Name);
Assert.Equal("Blur 4", blur4.Name);
}
