Exemple #1
0
        public void Test30()
        {
            //Step 1: Construct any Pipeline
            MainViewModel  mvm        = MainViewModelTest.GetInstance();
            ColorInputNode colorInput = new ColorInputNode();

            mvm.Model.Graph.AddNode(colorInput);
            InverterNode inverter = new InverterNode();

            mvm.Model.Graph.AddNode(inverter);
            mvm.Model.Graph.AddEdge(colorInput.Outputs[0], inverter.Inputs[0]);
            Assert.Contains(colorInput, mvm.Model.Graph.Nodes);
            Assert.Contains(inverter, mvm.Model.Graph.Nodes);
            Assert.Equal(colorInput.Outputs[0], inverter.Inputs[0].Source);

            //Step 2: Save Pipeline
            using (var stream = File.Create(@"..\..\..\..\output\test30.yuvka"))
                new NetDataContractSerializer().Serialize(stream, mvm.Model);
            Assert.True(File.Exists(@"..\..\..\..\output\test30.yuvka"));

            //Step 3: Clear Pipeline
            mvm.Clear();
            Assert.Empty(mvm.Model.Graph.Nodes);

            //Step 4: Reload Pipeline
            using (var stream = File.OpenRead(@"..\..\..\..\output\test30.yuvka"))
                mvm.Model = (PipelineState) new NetDataContractSerializer().Deserialize(stream);
            Assert.True(mvm.Model.Graph.Nodes[0] is ColorInputNode);
            Assert.True(mvm.Model.Graph.Nodes[1] is InverterNode);
            Assert.Equal(mvm.Model.Graph.Nodes[0].Outputs[0], mvm.Model.Graph.Nodes[1].Inputs[0].Source);
        }
Exemple #2
0
        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);
        }
Exemple #3
0
        public void Test50()
        {
            // Some necessary initializations.
            MainViewModel mvm           = MainViewModelTest.GetInstance();
            var           windowManMock = new Mock <IWindowManagerEx>();
            var           vm            = MainViewModelTest.GetInstance(cont => cont.ComposeExportedValue <IWindowManagerEx>(windowManMock.Object));
            var           conductorMock = new Mock <IConductor>();


            // Step 1: Create simple pipeline.
            //
            //	[color]---[overlay]
            //		   \ /
            //			X
            //		   / \
            //  [noise]---[diagram]
            NoiseInputNode noise = new NoiseInputNode();

            mvm.Model.Graph.AddNode(noise);
            ColorInputNode color = new ColorInputNode();

            mvm.Model.Graph.AddNode(color);
            DiagramNode diagram = new DiagramNode();

            diagram.Inputs.Add(new Node.Input());
            diagram.Inputs.Add(new Node.Input());
            mvm.Model.Graph.AddNode(diagram);
            OverlayNode overlay = new OverlayNode();

            mvm.Model.Graph.AddNode(overlay);
            Assert.Contains(noise, mvm.Model.Graph.Nodes);
            Assert.Contains(color, mvm.Model.Graph.Nodes);
            Assert.Contains(diagram, mvm.Model.Graph.Nodes);
            Assert.Contains(overlay, mvm.Model.Graph.Nodes);

            mvm.Model.Graph.AddEdge(noise.Outputs[0], overlay.Inputs[0]);
            mvm.Model.Graph.AddEdge(noise.Outputs[0], diagram.Inputs[0]);
            mvm.Model.Graph.AddEdge(color.Outputs[0], overlay.Inputs[1]);
            mvm.Model.Graph.AddEdge(color.Outputs[0], diagram.Inputs[1]);
            Assert.Equal(noise.Outputs[0], overlay.Inputs[0].Source);
            Assert.Equal(noise.Outputs[0], diagram.Inputs[0].Source);
            Assert.Equal(color.Outputs[0], overlay.Inputs[1].Source);
            Assert.Equal(color.Outputs[0], diagram.Inputs[1].Source);

            // Step 2: Disable diagram node and open overlay node.
            diagram.IsEnabled = false;
            IGraphType pixelDiff = new PixelDiff();
            IGraphType psnr      = new PeakSignalNoiseRatio();

            IoC.GetAllInstances = type => new List <IGraphType> {
                pixelDiff, psnr
            };
            var overlayWindow = new OverlayViewModel(overlay)
            {
                Parent = conductorMock.Object
            };
            var diagramWindow = new DiagramViewModel(diagram)
            {
                Parent = conductorMock.Object
            };

            ((IActivate)overlayWindow).Activate();
            conductorMock.Setup(c => c.DeactivateItem(overlayWindow, true))
            .Callback(() => ((IDeactivate)overlayWindow).Deactivate(close: true))
            .Verifiable();

            mvm.OpenWindow(overlayWindow);
            Assert.Contains(overlayWindow, mvm.OpenWindows);

            // Step 3: Start pipeline and add an overlay in the overlay node.
            mvm.Model.Start(mvm.Model.Graph.Nodes);
            overlay.Type = new ArtifactsOverlay();

            // Step 4: Remove selected overlay.
            overlay.Type = new NoOverlay();

            // Step 5: Stop pipeline and close overlay node.
            mvm.Model.Stop();
            mvm.CloseWindows(overlay);
            Assert.DoesNotContain(overlayWindow, mvm.OpenWindows);

            // Step 6: Re-enable diagram node and open it.
            diagram.IsEnabled = true;
            mvm.OpenWindow(diagramWindow);
            Assert.Contains(diagramWindow, mvm.OpenWindows);

            // Step 7: Choose a reference video and add a diagram graph.
            diagramWindow.Reference   = new Tuple <string, Node.Input>(diagramWindow.GetVideoName(diagram.Inputs[0]), diagram.Inputs[0]);
            diagramWindow.ChosenVideo = new Tuple <string, Node.Input>(diagramWindow.GetVideoName(diagram.Inputs[1]), diagram.Inputs[1]);
            diagramWindow.AddGraph();
            diagramWindow.Graphs.ElementAt(0).CurrentType = new GraphTypeViewModel(pixelDiff);

            // Step 8: Start pipeline again and change diagram graph type.
            mvm.Model.Start(mvm.Model.Graph.Nodes);
            diagramWindow.Graphs.ElementAt(0).CurrentType = new GraphTypeViewModel(psnr);

            // Step 9: Remove the diagram graph.
            DiagramGraphViewModel dgvm = diagramWindow.Graphs.ElementAt(0);

            diagramWindow.DeleteGraph(dgvm);
            Assert.DoesNotContain(dgvm, diagramWindow.Graphs);
        }
Exemple #4
0
        public void DiagramNodeDeleteNode()
        {
            IoC.GetAllInstances = type => new IGraphType[] { new PixelDiff() };
            var posMock = new Mock <IGetPosition>();

            posMock.Setup(p => p.GetElementSize(It.IsAny <IViewAware>())).Returns(new Size(4, 4));
            posMock.Setup(p => p.ViewLoaded(It.IsAny <IViewAware>())).Returns(Observable.Never <Unit>());

            var mvm = MainViewModelTest.GetInstance(
                container => container.ComposeExportedValue(posMock.Object)
                );

            var vm = mvm.PipelineViewModel;

            var mock = new Mock <IDragEventInfo>();

            // Add Nodes like so
            // vin0
            //
            //
            // vin1  dn
            //
            //
            // vin2
            var vin0 = AddNodeModel <VideoInputNode>(vm, mock);
            var vin1 = AddNodeModel <VideoInputNode>(vm, mock);
            var vin2 = AddNodeModel <VideoInputNode>(vm, mock);
            var dn   = AddNodeModel <DiagramNode>(vm, mock);
            var dnvm = new DiagramViewModel(dn.Model);

            // Add Edge like so
            // vin0
            //	   \
            //		\
            // vin1  dn
            //
            //
            // vin2
            // Start edge from vin0 output
            Assert.PropertyChanged(vm, "DraggedEdge",
                                   () => vm.InOutputMouseDown(vin0.Outputs.First())
                                   );

            var edge = vm.DraggedEdge;

            Assert.Equal(EdgeStatus.Indeterminate, edge.Status);

            // Drag edge over dn input
            var e = new RoutedEventArgs(Mouse.MouseMoveEvent);

            vm.InOutputMouseMove(dn.Inputs.First(), e);

            Assert.Equal(EdgeStatus.Valid, edge.Status);

            // Drop edge on dn input
            vm.InOutputMouseUp(dn.Inputs.First());

            Assert.Equal(1, vm.Edges.Count());
            Assert.Equal(1, dn.Model.Inputs.Count());
            // DiagramNode has one fake input.
            Assert.Equal(2, dn.Inputs.Count());


            // Add Edge like so
            // vin0
            //	   \
            //		\
            // vin1--dn
            //
            //
            // vin2
            // Start edge from vin1 output
            Assert.PropertyChanged(vm, "DraggedEdge",
                                   () => vm.InOutputMouseDown(vin1.Outputs.First())
                                   );

            edge = vm.DraggedEdge;
            Assert.Equal(EdgeStatus.Indeterminate, edge.Status);

            // Drag edge over dn input
            e = new RoutedEventArgs(Mouse.MouseMoveEvent);
            vm.InOutputMouseMove(dn.Inputs.Last(), e);

            Assert.Equal(EdgeStatus.Valid, edge.Status);

            // Drop edge on dn input
            vm.InOutputMouseUp(dn.Inputs.Last());

            Assert.Equal(2, vm.Edges.Count());
            Assert.Equal(2, dn.Model.Inputs.Count());
            Assert.Equal(3, dn.Inputs.Count());


            // Add PixelDiff-graph of vin1 and set reference to vin0
            Assert.Equal(4, vm.Nodes.Count());
            dnvm.Reference   = dnvm.Videos.First();
            dnvm.ChosenVideo = dnvm.Videos.Last();
            dnvm.AddGraph();
            dnvm.Graphs.Single().CurrentType =
                dnvm.Graphs.Single().AvailableTypes.First();
            Assert.Equal(1, dnvm.Graphs.Count());
            Assert.NotNull(dnvm.Reference);


            // Add Edge like so
            // vin0
            //	   \
            //		\
            // vin1--dn
            //		/
            //	   /
            // vin2
            // Start edge from vin2 output
            Assert.PropertyChanged(vm, "DraggedEdge",
                                   () => vm.InOutputMouseDown(vin2.Outputs.First())
                                   );

            edge = vm.DraggedEdge;
            Assert.Equal(EdgeStatus.Indeterminate, edge.Status);

            // Drag edge over dn input
            e = new RoutedEventArgs(Mouse.MouseMoveEvent);
            vm.InOutputMouseMove(dn.Inputs.Last(), e);

            Assert.Equal(EdgeStatus.Valid, edge.Status);

            // Drop edge on dn input
            vm.InOutputMouseUp(dn.Inputs.Last());

            Assert.Equal(3, vm.Edges.Count());
            Assert.Equal(3, dn.Model.Inputs.Count());
            Assert.Equal(4, dn.Inputs.Count());

            // Add PixelDiff-graph of vin2
            dnvm.ChosenVideo = dnvm.Videos.Last();
            dnvm.AddGraph();
            dnvm.Graphs.Last().CurrentType =
                dnvm.Graphs.Last().AvailableTypes.First();
            Assert.Equal(2, dnvm.Graphs.Count());
            Assert.NotNull(dnvm.Reference);
            Assert.True(dnvm.Graphs.All(graph => graph.CurrentType != null));

            // Delete Node like so
            // vin0
            //	   \
            //		\
            // vin1--dn
            //
            //
            //
            Assert.PropertyChanged(vm, "Edges", vin2.RemoveNode);

            Assert.DoesNotContain(vin2, vm.Nodes);
            Assert.DoesNotContain(vin2.Model, vm.Parent.Model.Graph.Nodes);

            Assert.Equal(2, vm.Edges.Count());
            Assert.Equal(2, dn.Model.Inputs.Count());
            Assert.Equal(3, dn.Inputs.Count());
            Assert.Equal(3, vm.Nodes.Count());

            Assert.NotNull(dnvm.Reference);
            Assert.Equal(1, dnvm.Graphs.Count());

            // Delete Node like so
            //
            //
            //
            // vin1--dn
            //
            //
            //
            Assert.PropertyChanged(vm, "Edges", vin0.RemoveNode);

            Assert.DoesNotContain(vin0, vm.Nodes);
            Assert.DoesNotContain(vin0.Model, vm.Parent.Model.Graph.Nodes);

            Assert.Equal(1, vm.Edges.Count());
            Assert.Equal(1, dn.Model.Inputs.Count());
            Assert.Equal(2, dn.Inputs.Count());
            Assert.Equal(2, vm.Nodes.Count());

            Assert.Null(dnvm.Reference);
            Assert.Equal(1, dnvm.Graphs.Count());
        }
Exemple #5
0
        public void WAMNDeleteNode()
        {
            var posMock = new Mock <IGetPosition>();

            posMock.Setup(p => p.GetElementSize(It.IsAny <IViewAware>())).Returns(new Size(4, 4));
            posMock.Setup(p => p.ViewLoaded(It.IsAny <IViewAware>())).Returns(Observable.Never <Unit>());

            var vm = MainViewModelTest.GetInstance(
                container => container.ComposeExportedValue(posMock.Object)
                ).PipelineViewModel;

            var mock = new Mock <IDragEventInfo>();

            // Add Nodes like so
            // vin0
            //
            //		wamn
            //
            //vin1
            var vin0 = AddNodeModel <VideoInputNode>(vm, mock);
            var vin1 = AddNodeModel <VideoInputNode>(vm, mock);
            var wamn = AddNodeModel <WeightedAveragedMergeNode>(vm, mock);

            // Add Edge like so
            // vin0
            //	   \
            //		wamn
            //
            //vin1
            // Start edge from vin0 output
            Assert.PropertyChanged(vm, "DraggedEdge",
                                   () => vm.InOutputMouseDown(vin0.Outputs.First())
                                   );

            var edge = vm.DraggedEdge;

            Assert.Equal(EdgeStatus.Indeterminate, edge.Status);

            // Drag edge over vin1 input
            var e = new RoutedEventArgs(Mouse.MouseMoveEvent);

            vm.InOutputMouseMove(wamn.Inputs.First(), e);

            Assert.Equal(EdgeStatus.Valid, edge.Status);

            // Drop edge on vin1 input
            vm.InOutputMouseUp(wamn.Inputs.First());

            Assert.Equal(1, vm.Edges.Count());
            Assert.Equal(1, wamn.Model.Inputs.Count());
            // WAMN-ViewModel has one fake input.
            Assert.Equal(2, wamn.Inputs.Count());

            // Add Edge like so
            // vin0
            //	   \
            //		wamn
            //	   /
            //vin1
            // Start edge from vin1 output
            Assert.PropertyChanged(vm, "DraggedEdge",
                                   () => vm.InOutputMouseDown(vin1.Outputs.First())
                                   );

            edge = vm.DraggedEdge;
            Assert.Equal(EdgeStatus.Indeterminate, edge.Status);

            // Drag edge over wamn input
            e = new RoutedEventArgs(Mouse.MouseMoveEvent);
            vm.InOutputMouseMove(wamn.Inputs.Last(), e);

            Assert.Equal(EdgeStatus.Valid, edge.Status);

            // Drop edge on wamn input
            vm.InOutputMouseUp(wamn.Inputs.Last());

            Assert.Equal(2, vm.Edges.Count());
            Assert.Equal(2, wamn.Model.Inputs.Count());
            Assert.Equal(3, wamn.Inputs.Count());

            // Remove Node like so
            //
            //
            //		wamn
            //	   /
            //vin1
            Assert.PropertyChanged(vm, "Edges", vin0.RemoveNode);
            Assert.DoesNotContain(vin0, vm.Nodes);
            Assert.DoesNotContain(vin0.Model, vm.Parent.Model.Graph.Nodes);


            Assert.Equal(1, vm.Edges.Count());
            Assert.Equal(1, wamn.Model.Inputs.Count());
            Assert.Equal(2, wamn.Inputs.Count());
        }
Exemple #6
0
        public void WAMNDeleteEdge()
        {
            var posMock = new Mock <IGetPosition>();

            posMock.Setup(p => p.GetElementSize(It.IsAny <IViewAware>())).Returns(new Size(4, 4));
            posMock.Setup(p => p.ViewLoaded(It.IsAny <IViewAware>())).Returns(Observable.Never <Unit>());

            var vm = MainViewModelTest.GetInstance(
                container => container.ComposeExportedValue(posMock.Object)
                ).PipelineViewModel;

            var mock = new Mock <IDragEventInfo>();

            // Add Nodes like so
            // vin0
            //
            //		wamn
            //
            //vin1
            var vin0 = AddNodeModel <VideoInputNode>(vm, mock);
            var vin1 = AddNodeModel <VideoInputNode>(vm, mock);
            var wamn = AddNodeModel <WeightedAveragedMergeNode>(vm, mock);

            // Add Edge like so
            // vin0
            //	   \
            //		wamn
            //
            //vin1
            // Start edge from vin0 output
            Assert.PropertyChanged(vm, "DraggedEdge",
                                   () => vm.InOutputMouseDown(vin0.Outputs.First())
                                   );

            var edge = vm.DraggedEdge;

            Assert.Equal(EdgeStatus.Indeterminate, edge.Status);

            // Drag edge over wamn input
            var e = new RoutedEventArgs(Mouse.MouseMoveEvent);

            vm.InOutputMouseMove(wamn.Inputs.First(), e);

            Assert.Equal(EdgeStatus.Valid, edge.Status);

            // Drop edge on wamn input
            vm.InOutputMouseUp(wamn.Inputs.First());

            Assert.Equal(1, vm.Edges.Count());
            Assert.Equal(1, wamn.Model.Inputs.Count());
            // WAMN-ViewModel has one fake input.
            Assert.Equal(2, wamn.Inputs.Count());


            // Add Edge like so
            // vin0
            //	   \
            //		wamn
            //	   /
            //vin1
            // Start edge from vin1 output
            Assert.PropertyChanged(vm, "DraggedEdge",
                                   () => vm.InOutputMouseDown(vin1.Outputs.First())
                                   );

            edge = vm.DraggedEdge;
            Assert.Equal(EdgeStatus.Indeterminate, edge.Status);

            // Drag edge over wamn input
            e = new RoutedEventArgs(Mouse.MouseMoveEvent);
            vm.InOutputMouseMove(wamn.Inputs.Last(), e);

            Assert.Equal(EdgeStatus.Valid, edge.Status);

            // Drop edge on wamn input
            vm.InOutputMouseUp(wamn.Inputs.Last());

            Assert.Equal(2, vm.Edges.Count());
            Assert.Equal(2, wamn.Model.Inputs.Count());
            Assert.Equal(3, wamn.Inputs.Count());


            // Delete Edge like so
            // vin0
            //
            //		wamn
            //	   /
            //vin1
            // Pick up edge from wamn input
            Assert.PropertyChanged(vm, "DraggedEdge",
                                   () => vm.InOutputMouseDown(wamn.Inputs.First())
                                   );

            edge = vm.DraggedEdge;

            // drag edge to empty space
            var mouseMock = new Mock <IMouseEventInfo>();

            mouseMock.Setup(m => m.GetPosition(vm)).Returns(new Point(50, 50));
            mouseMock.SetupGet(m => m.LeftButton).Returns(MouseButtonState.Pressed);
            vm.MouseMove(mouseMock.Object);

            Assert.Equal(EdgeStatus.Indeterminate, edge.Status);

            // let go
            vm.MouseUp();

            Assert.Equal(1, vm.Edges.Count());
            Assert.Equal(1, wamn.Model.Inputs.Count());
            Assert.Equal(2, wamn.Inputs.Count());
        }
Exemple #7
0
        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
            }
        }
Exemple #8
0
        public void Test20()
        {
            var posMock = new Mock <IGetPosition>();

            posMock.Setup(p => p.GetElementSize(It.IsAny <IViewAware>())).Returns(new Size(4, 4));
            posMock.Setup(p => p.ViewLoaded(It.IsAny <IViewAware>())).Returns(Observable.Never <Unit>());

            var vm = MainViewModelTest.GetInstance(
                container => container.ComposeExportedValue <IGetPosition>(posMock.Object)
                ).PipelineViewModel;

            // Step 1: User creates a random pipeline with three nodes and one edge connecting them.
            // Add BlurNode
            var mock = new Mock <IDragEventInfo>();

            mock.Setup(info => info.GetData <NodeType>()).Returns(new NodeType {
                Type = typeof(BlurNode)
            });
            mock.Setup(info => info.GetPosition(vm)).Returns(new Point(30, 10));
            mock.SetupProperty(info => info.Effects, DragDropEffects.Copy);

            vm.CheckClearance(mock.Object);
            Assert.Equal(DragDropEffects.Copy, mock.Object.Effects);

            vm.Drop(mock.Object);

            var node0 = vm.Nodes.Single();

            Assert.True(node0.Model is BlurNode);
            Assert.Equal(30, node0.Model.X);
            Assert.Equal(10, node0.Model.Y);

            //Add Second BlurNode
            mock = new Mock <IDragEventInfo>();
            mock.Setup(info => info.GetData <NodeType>()).Returns(new NodeType {
                Type = typeof(BlurNode)
            });
            mock.Setup(info => info.GetPosition(vm)).Returns(new Point(40, 10));
            mock.SetupProperty(info => info.Effects, DragDropEffects.Copy);

            vm.CheckClearance(mock.Object);
            Assert.Equal(DragDropEffects.Copy, mock.Object.Effects);

            vm.Drop(mock.Object);

            var node1 = vm.Nodes.Last();

            Assert.True(node1.Model is BlurNode);
            Assert.Equal(40, node1.Model.X);
            Assert.Equal(10, node1.Model.Y);

            //Add third BlurNode
            mock = new Mock <IDragEventInfo>();
            mock.Setup(info => info.GetData <NodeType>()).Returns(new NodeType {
                Type = typeof(BlurNode)
            });
            mock.Setup(info => info.GetPosition(vm)).Returns(new Point(0, 10));
            mock.SetupProperty(info => info.Effects, DragDropEffects.Copy);

            vm.CheckClearance(mock.Object);
            Assert.Equal(DragDropEffects.Copy, mock.Object.Effects);

            vm.Drop(mock.Object);

            var node2 = vm.Nodes.Last();

            Assert.True(node1.Model is BlurNode);
            Assert.Equal(0, node2.Model.X);
            Assert.Equal(10, node2.Model.Y);

            //Add Edge

            posMock.Setup(p => p.GetElementPosition(node0.Outputs.Single(), vm)).Returns(new Point(10, 10));
            posMock.Setup(p => p.GetElementPosition(node0.Inputs.Single(), vm)).Returns(new Point(30, 10));
            posMock.Setup(p => p.GetElementPosition(node1.Inputs.Single(), vm)).Returns(new Point(40, 10));
            posMock.Setup(p => p.GetElementPosition(node2.Inputs.Single(), vm)).Returns(new Point(0, 10));

            // Start edge from node0 output
            Assert.PropertyChanged(vm, "DraggedEdge", () => vm.InOutputMouseDown(node0.Outputs.First()));

            var edge = vm.DraggedEdge;

            Assert.Equal(new Point(12, 12), edge.StartPoint);
            Assert.Equal(new Point(12, 12), edge.EndPoint);
            Assert.Equal(EdgeStatus.Indeterminate, edge.Status);

            // Drag edge over node1 input
            var e = new RoutedEventArgs(Mouse.MouseMoveEvent);

            vm.InOutputMouseMove(node1.Inputs.Single(), e);

            Assert.Equal(new Point(42, 12), edge.EndPoint);
            Assert.Equal(EdgeStatus.Valid, edge.Status);

            // Drop edge on node1 input

            vm.InOutputMouseUp(node1.Inputs.Single());

            Assert.Equal(new Point(42, 12), vm.Edges.Single().StartPoint);
            Assert.Equal(new Point(12, 12), vm.Edges.Single().EndPoint);
            Assert.NotNull(vm.Edges.Single().Geometry);

            // Step 2: User moves a node via drag-and-drop

            posMock.Setup(p => p.GetElementPosition(node0.Outputs.Single(), vm)).Returns(new Point(20, 10));
            Assert.PropertyChanged(edge, "Geometry",
                                   () => node0.Position = new Point(-1, -1) // Trigger ViewPositionChanged
                                   );
            Assert.Equal(new Point(-1, -1), node0.Position);

            // Step 3: User changes the end of an edge via drag-and-drop

            // Pick up edge from node1 input
            Assert.PropertyChanged(vm, "DraggedEdge", () => vm.InOutputMouseDown(node1.Inputs.First()));

            edge = vm.DraggedEdge;
            Assert.Equal(new Point(22, 12), edge.StartPoint);
            Assert.Equal(new Point(42, 12), edge.EndPoint);
            Assert.Equal(EdgeStatus.Indeterminate, edge.Status);

            // Drag edge over node2 input
            e = new RoutedEventArgs(Mouse.MouseMoveEvent);
            vm.InOutputMouseMove(node2.Inputs.Single(), e);

            Assert.Equal(new Point(2, 12), edge.EndPoint);
            Assert.Equal(EdgeStatus.Valid, edge.Status);

            // Drop edge on node2 input

            vm.InOutputMouseUp(node2.Inputs.Single());

            Assert.Equal(new Point(2, 12), vm.Edges.Single().StartPoint);
            Assert.Equal(new Point(22, 12), vm.Edges.Single().EndPoint);
            Assert.NotNull(vm.Edges.Single().Geometry);

            // Step 4: user removes an edge

            // Pick up edge from node2 input
            Assert.PropertyChanged(vm, "DraggedEdge", () => vm.InOutputMouseDown(node2.Inputs.First()));

            edge = vm.DraggedEdge;
            Assert.Equal(new Point(22, 12), edge.StartPoint);
            Assert.Equal(new Point(2, 12), edge.EndPoint);

            // drag edge to empty space
            var mouseMock = new Mock <IMouseEventInfo>();

            mouseMock.Setup(m => m.GetPosition(vm)).Returns(new Point(50, 50));
            mouseMock.SetupGet(m => m.LeftButton).Returns(MouseButtonState.Pressed);
            vm.MouseMove(mouseMock.Object);

            Assert.Equal(EdgeStatus.Indeterminate, edge.Status);
            Assert.Equal(new Point(50, 50), edge.EndPoint);

            // let go
            vm.MouseUp();

            Assert.Equal(0, vm.Edges.Count());

            // Step 5: user changes the configuration of a manipulation-node
            ((BlurNode)node0.Model).Radius = 2;

            // Step 6: user deletes a node
            Assert.PropertyChanged(vm, "Edges", node0.RemoveNode);

            Assert.DoesNotContain(node0, vm.Nodes);
            Assert.DoesNotContain(node0.Model, vm.Parent.Model.Graph.Nodes);
        }