Exemple #1
0
        public void ImagePatternWithMultipleRegisteredTest()
        {
            // Arrange
            var evaluator = new PatternEvaluator();

            // Act
            evaluator.Add("button").When(Pattern.WideRectangle);
            evaluator.Add("image")
            .When(p => p.MovesRightAndDown())
            .When(p => p.MovesLeftAndDown());

            var result = evaluator.Evaluate(PathsForTesting.Image);

            // Assert
            Assert.True(result.IsValid);
            Assert.Same("image", result.Key);
        }
Exemple #2
0
        public void WideRectanglePatternFailTest2()
        {
            // Arrange
            var evaluator = new PatternEvaluator();

            // Act
            evaluator.Add("button").When(Pattern.WideRectangle);
            var result = evaluator.Evaluate(PathsForTesting.TallRectangle);

            // Assert
            Assert.False(result.IsValid);
        }
Exemple #3
0
        public MainLayer() : base(CCColor4B.AliceBlue)
        {
            _canvasNode           = new CCDrawNode();
            _recognizerCanvasNode = new CCDrawNode();
            _lineRecognizer       = new LineRecognizer();
            _shapeNode            = new CCDrawNode();

            AddChild(_shapeNode);
            AddChild(_canvasNode);
            AddChild(_recognizerCanvasNode);

            if (_drawDebug)
            {
                _lineRecognizer.LineFound = (line) => _recognizerCanvasNode.DrawLine(line.P1.ToCCPoint(), line.P2.ToCCPoint(), 5, CCColor4B.Blue);
            }

            // Register patterns (concept)
            _patternEvaluator = new PatternEvaluator();
            _patternEvaluator.Add("button").When(Pattern.WideRectangle);
            _patternEvaluator.Add("image").When(Pattern.Cross);
            _patternEvaluator.Add("text").When(p => p.Repetitive(ip => ip.MovesRight().MovesLeftAndDown()).MovesRight());
            _patternEvaluator.Add("entry").When(p => p.MovesDown().MovesRight().MovesUp().Bounds(BoundsDescriptor.IsWide));
            _patternEvaluator.Add("lineoftext").When(p => p.MovesRight());
            _patternEvaluator.Add("delete").When(p => p.MovesRightAndUp());
        }
Exemple #4
0
        public void Step_NotEndsNearStart_Test()
        {
            // Arrange
            var evaluator = new PatternEvaluator();
            var path      = Path.Parse("200,200 -> 50,200 -> 197, 290");

            // Act
            evaluator.Add("p").When(e => e.MovesLeft().MovesRight().End(RelativePosition.NearStart));
            var result = evaluator.Evaluate(path);

            // Assert
            Assert.False(result.IsValid);
        }
Exemple #5
0
        public void WideRectanglePatternTest()
        {
            // Arrange
            var evaluator = new PatternEvaluator();

            // Act
            evaluator.Add("button").When(Pattern.WideRectangle);
            var result = evaluator.Evaluate(PathsForTesting.WideRectangle1);

            // Assert
            Assert.True(result.IsValid);
            Assert.Equal("button", result.Key);
        }
Exemple #6
0
        public void EntryTest()
        {
            // Arrange
            var evaluator = new PatternEvaluator();
            var path      = Path.Parse("10,300 -> 10,260 -> 600,260 -> 600,300");

            // Act
            evaluator.Add("entry").When(p => p.MovesDown().MovesRight().MovesUp().Bounds(BoundsDescriptor.IsWide));
            var result = evaluator.Evaluate(path);

            // Assert
            Assert.True(result.IsValid);
        }
Exemple #7
0
        public void CrossPathTest()
        {
            // Arrange
            var evaluator = new PatternEvaluator();
            var path      = Path.Parse("10,300 -> 100,200 | 100,300 -> 10,200");

            // Act
            evaluator.Add("test").When(Pattern.Cross);
            var result = evaluator.Evaluate(path);

            // Assert
            Assert.True(result.IsValid);
        }
Exemple #8
0
        public void JigSawPatternTest()
        {
            // Arrange
            var evaluator = new PatternEvaluator();

            // Act
            evaluator.Add("test").When(p => p.Repetitive(ip => ip.MovesRight().MovesLeftAndDown()).MovesRight());
            var result = evaluator.Evaluate(PathsForTesting.JigSawPath);

            // Assert
            Assert.True(result.IsValid);
            Assert.Equal("test", result.Key);
        }
Exemple #9
0
        public void InverseHorizontalTest()
        {
            // Arrange
            var evaluator = new PatternEvaluator();

            // Act
            evaluator.Add("image").When(p => p.MovesRightAndDown().MovesLeftAndDown()).AllowInverse(InverseDescriptor.Horizontal);
            var result = evaluator.Evaluate(PathsForTesting.InverseImage);

            // Assert
            Assert.True(result.IsValid);
            Assert.Same("image", result.Key);
        }
Exemple #10
0
        public void Step_MovesLeftAndDownStep_Test()
        {
            // Arrange
            var evaluator = new PatternEvaluator();
            var path      = Path.Parse("300,300 -> 200,200");

            // Act
            evaluator.Add("p").When(e => e.MovesLeftAndDown());
            var result = evaluator.Evaluate(path);

            // Assert
            Assert.True(result.IsValid);
            Assert.Equal("p", result.Key);
        }
Exemple #11
0
        public void ImagePatternFailTest()
        {
            // Arrange
            var evaluator = new PatternEvaluator();

            // Act
            evaluator.Add("image").When(Pattern.WideRectangle)
            .When(p => p.MovesRightAndDown())
            .When(p => p.MovesLeftAndDown());
            var results = evaluator.Evaluate(PathsForTesting.WideRectangle1);

            // Assert
            Assert.False(results.IsValid);
        }
        public void LineDownTest()
        {
            // Arrange
            var evaluator = new PatternEvaluator();
            var path      = Path.Parse("10,300 -> 10,200");

            // Act
            evaluator.Add("linedown").When(e => e.MovesDown());
            var result = evaluator.Evaluate(path);

            // Assert
            Assert.True(result.IsValid);
            Assert.Equal("linedown", result.Key);
        }
        public void ShadyRectangleTest2()
        {
            // Arrange
            var evaluator = new PatternEvaluator();
            var path      = Path.Parse("Line 253, 1086 -> 779, 1133\nLine 781, 1133 -> 813, 838\nLine 813, 833 -> 285, 774\nLine 280, 874 -> 277, 1107");

            evaluator.Add("rect").When(Pattern.WideRectangle);

            // Act
            var result = evaluator.Evaluate(path);

            // Assert
            Assert.True(result.IsValid);
        }
Exemple #14
0
        public void BrokenLineTest()
        {
            // Arrange
            var evaluator = new PatternEvaluator();
            var path      = Path.Parse("10,300 -> 20,320 -> 100,310");

            // Act
            evaluator.Add("line").When(e => e.MovesRight());
            var result = evaluator.Evaluate(path);

            // Assert
            Assert.True(result.IsValid);
            Assert.Equal("line", result.Key);
        }
Exemple #15
0
        public void ImagePatternTest()
        {
            // Arrange
            var evaluator = new PatternEvaluator();

            // Act
            evaluator.Add("image").When(p => p.MovesRightAndDown())
            .When(p => p.MovesLeftAndDown());

            var result = evaluator.Evaluate(PathsForTesting.Image);

            // Assert
            Assert.True(result.IsValid);
            Assert.Same("image", result.Key);
        }
        public void ShadyRectangleTest1()
        {
            // Arrange
            var json    = "[{ \"X\":267.042267,\"Y\":921.1268} ,{ \"X\":322.8169,\"Y\":921.1268} ,{ \"X\":365.0704,\"Y\":921.1268} ,{ \"X\":417.4648,\"Y\":921.1268} ,{ \"X\":456.338,\"Y\":921.1268} ,{ \"X\":485.0704,\"Y\":921.1268} ,{ \"X\":498.591553,\"Y\":921.1268} ,{ \"X\":508.7324,\"Y\":921.1268} ,{ \"X\":520.563354,\"Y\":921.1268} ,{ \"X\":523.943665,\"Y\":921.1268} ,{ \"X\":527.324,\"Y\":921.1268} ,{ \"X\":527.324,\"Y\":917.74646} ,{ \"X\":527.324,\"Y\":907.605652} ,{ \"X\":527.324,\"Y\":890.7042} ,{ \"X\":530.7042,\"Y\":868.7324} ,{ \"X\":534.084534,\"Y\":843.3803} ,{ \"X\":537.4648,\"Y\":816.338} ,{ \"X\":537.4648,\"Y\":797.74646} ,{ \"X\":537.4648,\"Y\":774.0845} ,{ \"X\":537.4648,\"Y\":758.8732} ,{ \"X\":537.4648,\"Y\":748.7324} ,{ \"X\":537.4648,\"Y\":745.3521} ,{ \"X\":537.4648,\"Y\":741.971863} ,{ \"X\":537.4648,\"Y\":736.9014} ,{ \"X\":534.084534,\"Y\":736.9014} ,{ \"X\":508.7324,\"Y\":736.9014} ,{ \"X\":488.4507,\"Y\":736.9014} ,{ \"X\":427.605652,\"Y\":736.9014} ,{ \"X\":378.591553,\"Y\":736.9014} ,{ \"X\":329.577454,\"Y\":736.9014} ,{ \"X\":287.323944,\"Y\":736.9014} ,{ \"X\":258.591553,\"Y\":736.9014} ,{ \"X\":241.690155,\"Y\":736.9014} ,{ \"X\":234.929581,\"Y\":736.9014} ,{ \"X\":224.788742,\"Y\":736.9014} ,{ \"X\":221.408447,\"Y\":736.9014} ,{ \"X\":218.028168,\"Y\":736.9014} ,{ \"X\":214.647873,\"Y\":736.9014} ,{ \"X\":212.957748,\"Y\":747.0423} ,{ \"X\":209.577454,\"Y\":767.324} ,{ \"X\":206.197189,\"Y\":799.436646} ,{ \"X\":206.197189,\"Y\":848.450745} ,{ \"X\":206.197189,\"Y\":880.563354} ,{ \"X\":206.197189,\"Y\":905.9155} ,{ \"X\":206.197189,\"Y\":922.8169} ,{ \"X\":206.197189,\"Y\":932.9577} ,{ \"X\":206.197189,\"Y\":939.7183} ,{ \"X\":206.197189,\"Y\":944.788757} ,{ \"X\":206.197189,\"Y\":949.859131} ,{ \"X\":209.577454,\"Y\":949.859131} ]";
            var points  = Newtonsoft.Json.JsonConvert.DeserializeObject <List <Point> >(json);
            var lineRec = new LineRecognizer();

            lineRec.RegisterPoints(points);
            var path = lineRec.End();

            var evaluator = new PatternEvaluator();

            evaluator.Add("rect").When(Pattern.WideRectangle);

            // Act
            var result = evaluator.Evaluate(path);

            // Assert
            Assert.True(result.IsValid);
        }
        public void AllowAnyOrderTest()
        {
            // Arrange
            var evaluator = new PatternEvaluator();
            var path1     = Path.Parse("300,300 -> 400,200 -> 200,200 -> 300,300"); // the same triangle, just drawn in different order
            var path2     = Path.Parse("400,200 -> 200,200 -> 300,300 -> 400,200");

            // Act
            evaluator.Add("allowanyorder-triangle").When(
                p => p.MovesRightAndDown()
                .MovesLeft()
                .MovesRightAndUp()
                .End(RelativePosition.NearStart)).AllowAnyOrder();
            var result1 = evaluator.Evaluate(path1);
            var result2 = evaluator.Evaluate(path2);

            // Assert
            Assert.True(result1.IsValid);
            Assert.True(result2.IsValid);
        }