Beispiel #1
0
        public void Test_ToString()
        {
            var pointString = new Point(1, 2, 3).ToString();

            Assert.IsTrue(pointString.Contains("1"));
            Assert.IsTrue(pointString.Contains("2"));
            Assert.IsTrue(pointString.Contains("3"));
        }
Beispiel #2
0
        public void TestPointLine2()
        {
            // test when the point being tested in a node on the line
            Coordinate coordLine1  = new Coordinate(5.0, 5.0);
            Coordinate coordLine2  = new Coordinate(10.0, 10.0);
            Coordinate coordPoint1 = new Coordinate(6.0, 6.0);

            Coordinates coordinates = new Coordinates();

            coordinates.Add(coordLine1);
            coordinates.Add(coordLine2);

            Point point1 = _factory.CreatePoint(coordPoint1);

            LineString linestring = _factory.CreateLineString(coordinates);

            Assertion.AssertEquals("intersects", true, point1.Intersects(linestring));
            Assertion.AssertEquals("intersects", true, linestring.Intersects(point1));
            Assertion.AssertEquals("disjoint", false, point1.Disjoint(linestring));
            Assertion.AssertEquals("contains", false, point1.Contains(linestring));
            Assertion.AssertEquals("OppositeContains", true, linestring.Contains(point1));
            Assertion.AssertEquals("within", true, point1.Within(linestring));                          // point1 is within linestring and linestring contains point.

            // always returns false when a point is involves
            Assertion.AssertEquals("crosses", false, point1.Crosses(linestring));

            Assertion.AssertEquals("touches", false, point1.Touches(linestring));                       // false because point is in the interior of linestring and not the boundary. The boundary is the endpoints.

            // always returns false when a point is involved
            Assertion.AssertEquals("overlaps", false, point1.Overlaps(linestring));
        }
Beispiel #3
0
    private Point[] SortCorners(Point[] corners)
    {
        if (corners.Length != 4)
        {
            throw new OpenCvSharpException("\"corners\" must be an array of 4 elements");
        }

        // divide vertically
        System.Array.Sort <Point>(corners, (a, b) => a.Y.CompareTo(b.Y));
        Point[] tops = new Point[] { corners[0], corners[1] }, bottoms = new Point[] { corners[2], corners[3] };

        // divide horizontally
        System.Array.Sort <Point>(corners, (a, b) => a.X.CompareTo(b.X));
        Point[] lefts = new Point[] { corners[0], corners[1] }, rights = new Point[] { corners[2], corners[3] };

        // fetch final array
        Point[] output = new Point[] {
            tops[0],
            tops[1],
            bottoms[0],
            bottoms[1]
        };
        if (!lefts.Contains(tops[0]))
        {
            output.Swap(0, 1);
        }
        if (!rights.Contains(bottoms[0]))
        {
            output.Swap(2, 3);
        }

        // done
        return(output);
    }
Beispiel #4
0
        public void TestPointLine1()
        {
            // test when the point being tested in a node on the line
            Coordinate coordLine1  = new Coordinate(5.0, 5.0);
            Coordinate coordLine2  = new Coordinate(10.0, 10.0);
            Coordinate coordPoint1 = new Coordinate(5.0, 5.0);

            Coordinates coordinates = new Coordinates();

            coordinates.Add(coordLine1);
            coordinates.Add(coordLine2);

            Point point1 = _factory.CreatePoint(coordPoint1);

            LineString linestring = _factory.CreateLineString(coordinates);

            Assertion.AssertEquals("intersects", true, point1.Intersects(linestring));
            Assertion.AssertEquals("disjoint", false, point1.Disjoint(linestring));
            Assertion.AssertEquals("contains", false, point1.Contains(linestring));
            Assertion.AssertEquals("within", false, point1.Within(linestring));

            // always returns false when a point is involves
            Assertion.AssertEquals("crosses", false, point1.Crosses(linestring));

            Assertion.AssertEquals("touches", true, point1.Touches(linestring));

            // always returns false when a point is involved
            Assertion.AssertEquals("overlaps", false, point1.Overlaps(linestring));
        }
Beispiel #5
0
        private Point[] GenerateRandomPoints(int amount)
        {
            Point[] points_arr = new Point[amount];
            Random  random     = new Random();
            int     i          = 0;

            while (i < amount)
            {
                Point newPoint = new Point(random.Next((int)DrawCanvas.ActualWidth), random.Next((int)DrawCanvas.ActualHeight));
                if ((amount > 10000) || !points_arr.Contains(newPoint))
                {
                    points_arr[i++] = newPoint;
                }
            }
            return(points_arr);
        }
Beispiel #6
0
        public void CreateMessageTest()
        {
            //+++++++++++
            //+         +
            //+ Message +
            //+         +
            //+++++++++++
            MessageBox msg = new MessageBox("Message", 11, 5, 11, 5, new Padding(0, 0, 0, 0));

            // Символы сообщения:
            // [расположение] -> символ
            Dictionary <Point, char> chars = new Dictionary <Point, char>();

            msg.ElementContent.Distinct(new DrawableCompare()).ToList().ForEach(x => chars.Add(x.Location, x.Char));

            // Индексы букв сообщения
            Point[] messageLocation = new Point[]
            {
                new Point(2, 2),
                new Point(3, 2),
                new Point(4, 2),
                new Point(5, 2),
                new Point(6, 2),
                new Point(7, 2),
                new Point(8, 2),
            };

            // Проверить что сообщение в нужном месте
            for (int i = 0; i < messageLocation.Length; i++)
            {
                Assert.True(chars[messageLocation[i]] == "Message"[i]);
            }

            // Остальные символы это '+'
            foreach (KeyValuePair <Point, char> pair in chars)
            {
                if (messageLocation.Contains(pair.Key))
                {
                    continue;
                }
                Assert.True(pair.Value == '+');
            }
        }
Beispiel #7
0
        public void TestPointPoint3()
        {
            // test two points that are the same location
            Coordinate coord1 = new Coordinate(5.0, 7.0);
            Coordinate coord2 = new Coordinate();
            Point      pt1    = _factory.CreatePoint(coord1);
            Point      pt2    = _factory.CreatePoint(coord2);

            Assertion.AssertEquals("intersects", false, pt1.Intersects(pt2));
            Assertion.AssertEquals("disjoint", true, pt1.Disjoint(pt2));
            Assertion.AssertEquals("contains", false, pt1.Contains(pt2));
            Assertion.AssertEquals("within", false, pt1.Within(pt2));


            // will always return false because point vs point is not a valid op
            // see comments above.
            Assertion.AssertEquals("crosses", false, pt1.Crosses(pt2));
            Assertion.AssertEquals("touches", false, pt1.Touches(pt2));
            Assertion.AssertEquals("overlaps", false, pt1.Overlaps(pt2));
        }
        public long GetRoadTime(Point[] points)
        {
            DBC.Assert(points.Length == 2, "Can only get the distance between 2 points.");

            if (points.Contains(PointMother.ChannelSt) && points.Contains(PointMother.EthelSt))
                return 840;

            if (points.Contains(PointMother.EthelSt) && points.Contains(PointMother.BurchellSt))
                return 1800;

            if (points.Contains(PointMother.ChannelSt) && points.Contains(PointMother.BurchellSt))
                return 2280;

            throw new Exception("Unknown points");
        }
Beispiel #9
0
        private Point[] AddFarmerPoints(Farmer f)
        {
            Point p = f.getTileLocationPoint();

            Point[] points = new Point[]
            {
                new Point(p.X, p.Y),
                new Point(p.X - 1, p.Y - 2),
                new Point(p.X, p.Y - 2),
                new Point(p.X + 1, p.Y - 2),
                new Point(p.X - 1, p.Y - 1),
                new Point(p.X, p.Y - 1),
                new Point(p.X + 1, p.Y - 1),
                new Point(p.X + 1, p.Y),
                new Point(p.X + 1, p.Y + 1),
                new Point(p.X, p.Y + 1),
                new Point(p.X - 1, p.Y + 1),
                new Point(p.X - 1, p.Y)
            };

            List <Point> outpoints = new List <Point>();

            if (!transparentPoints.ContainsKey(f.UniqueMultiplayerID))
            {
                transparentPoints.Add(f.UniqueMultiplayerID, new Point[0]);
            }

            foreach (Point i in transparentPoints[f.UniqueMultiplayerID])
            {
                if (!points.Contains(i))
                {
                    outpoints.Add(i);
                }
            }
            transparentPoints[f.UniqueMultiplayerID] = points;

            return(outpoints.ToArray());
        }
        public long GetRoadTime(Point[] points)
        {
            DBC.Assert(points.Length == 2, "Can only get the distance between 2 points.");

            if (points.Contains(PointMother.ChannelSt) && points.Contains(PointMother.DelanceySt))
                return 480;

            if (points.Contains(PointMother.ChannelSt) && points.Contains(PointMother.BeckwithSt))
                return 660;

            if (points.Contains(PointMother.ChannelSt) && points.Contains(PointMother.ThornlandsRd))
                return 600;

            if (points.Contains(PointMother.BeckwithSt) && points.Contains(PointMother.DelanceySt))
                return 300;

            if (points.Contains(PointMother.BeckwithSt) && points.Contains(PointMother.ThornlandsRd))
                return 1020;

            if (points.Contains(PointMother.DelanceySt) && points.Contains(PointMother.ThornlandsRd))
                return 820;

            throw new Exception("Unknown points");
        }
Beispiel #11
0
        private void GenerateBoard()
        {
            disableGame      = false;
            shroomsPositions = new Point[shrooms];
            poopsPositions   = new Point[poops];

            Point startPosition = new Point(gridSize.Width / 2, gridSize.Height / 2);

            this[startPosition].PlaceYou();
            yourPosition = startPosition;

            int poopsCount = 0;

            Point[] usedPositions = new Point[shrooms + poops + 1];
            usedPositions[shrooms + poops] = startPosition;

            for (int i = poopsCount; i < poops; i++)
            {
                Point point = new Point(random.Next(gridSize.Width), random.Next(gridSize.Height));
                if (!usedPositions.Contains(point))
                {
                    this[point].PlacePoop();
                    usedPositions[i]  = point;
                    poopsPositions[i] = point;
                }
                else
                {
                    i--;
                }
            }

            // legal positions for shrooms to make board solvable
            Point[]      legalPositionsForShrooms;
            List <Point> NewLegalPositionsForShrooms     = new List <Point>();
            List <Point> CurrentLegalPositionsForShrooms = new List <Point>();
            List <Point> LegalPositionsForShrooms        = new List <Point>();

            NewLegalPositionsForShrooms.Add(startPosition);
            CurrentLegalPositionsForShrooms.Add(startPosition);

            while (NewLegalPositionsForShrooms.ToArray().Length > 0)
            {
                NewLegalPositionsForShrooms.Clear();
                LegalPositionsForShrooms = LegalPositionsForShrooms.Concat(CurrentLegalPositionsForShrooms).ToList();
                foreach (Point currentLegalPosition in CurrentLegalPositionsForShrooms)
                {
                    foreach (int[] legalMovesDirection in LegalMovesDirections)
                    {
                        Point point = new Point(currentLegalPosition.X + legalMovesDirection[0], currentLegalPosition.Y + legalMovesDirection[1]);
                        if (!poopsPositions.Contains(point) && !LegalPositionsForShrooms.Contains(point) && !NewLegalPositionsForShrooms.Contains(point) &&
                            point.X >= 0 && point.X < gridSize.Width && point.Y >= 0 && point.Y < gridSize.Height)
                        {
                            NewLegalPositionsForShrooms.Add(point);
                        }
                    }
                }
                CurrentLegalPositionsForShrooms = NewLegalPositionsForShrooms.ToList();
            }
            LegalPositionsForShrooms = LegalPositionsForShrooms.Concat(CurrentLegalPositionsForShrooms).ToList();
            LegalPositionsForShrooms.RemoveAt(0);
            legalPositionsForShrooms = LegalPositionsForShrooms.ToArray();

            if (legalPositionsForShrooms.Length < shrooms)
            {
                var poopResetCount = 0;
                for (int i = poopResetCount; i < poops; i++)
                {
                    Point point = poopsPositions[i];
                    this[point].ResetTileWithPoop();
                }
                return;
            }

            int shroomsCount = 0;

            for (int i = shroomsCount; i < shrooms; i++)
            {
                Point point = new Point(random.Next(gridSize.Width), random.Next(gridSize.Height));
                if (!usedPositions.Contains(point) && legalPositionsForShrooms.Contains(point))
                {
                    this[point].PlaceShroom();
                    usedPositions[i + poops] = point;
                    shroomsPositions[i]      = point;
                }
                else
                {
                    i--;
                }
            }

            BoardGenerated = true;
            return;
        }
Beispiel #12
0
 //static public List<Point> FindPlaceRadius(Point point, int movementPoints)
 //{
 //    return FindMovementRadius(new Point[] { point }, movementPoints, FieldToPlaceMap());
 //}
 //static public List<Point> FindPlaceRadius(Point[] points, int movementPoints)
 //{
 //    return FindMovementRadius(points, movementPoints, FieldToPlaceMap());
 //}
 public static List<Point> FindPath(Point[] from, Point to, int[,] map)
 {
     List<Point> path = new List<Point>();
     path.Add(to);
     foreach (Point p in from)
         if (Math.Abs(p.Y - to.Y) + Math.Abs(p.X - to.X) == 1)
         {
             return path;
         }
     while (!from.Contains(to))
     {
         if (to.Y - 1 >= 0 && map[to.Y - 1, to.X] == map[to.Y, to.X] - 1)
         {
             to = new Point(to.X, to.Y - 1);
             path.Add(to);
         }
         else if (to.X + 1 < GameLogic.Field.Width && map[to.Y, to.X + 1] == map[to.Y, to.X] - 1)
         {
             to = new Point(to.X + 1, to.Y);
             path.Add(to);
         }
         else if (to.Y + 1 < GameLogic.Field.Height && map[to.Y + 1, to.X] == map[to.Y, to.X] - 1)
         {
             to = new Point(to.X, to.Y + 1);
             path.Add(to);
         }
         else if (to.X - 1 >= 0 && map[to.Y, to.X - 1] == map[to.Y, to.X] - 1)
         {
             to = new Point(to.X - 1, to.Y);
             path.Add(to);
         }
         else break;
     }
     return path;
 }
Beispiel #13
0
        //檢查一群組所有的格網點是否連續(上下左右視為連續,對角與間隔視為不連續))
        public static bool IsContinuous(List<Point> pl)
        {
            if(pl.Count == 0)
            {
                return false;
            }

            Point[] workQueue = new Point[pl.Count];
            workQueue[0] = pl[0];
            for (int i = 1; i < workQueue.Length; ++i)
            {
                workQueue[i].X = -1;
                workQueue[i].Y = -1;
            }
            int ptr = 1;
            for (int i = 0; i < workQueue.Length; ++i)
            {
                Point p0 = workQueue[i];
                if (-1 == p0.X)
                {
                    break;
                }

                Point p1 = new Point(p0.X, p0.Y - 1);
                Point p2 = new Point(p0.X, p0.Y + 1);
                Point p3 = new Point(p0.X - 1, p0.Y);
                Point p4 = new Point(p0.X + 1, p0.Y);

                foreach (Point p in pl)
                {
                    if (p1 == p)
                    {
                        if (!workQueue.Contains(p1))
                        {
                            workQueue[ptr++] = p1;
                        }
                    }
                    if (p2 == p)
                    {
                        if (!workQueue.Contains(p2))
                        {
                            workQueue[ptr++] = p2;
                        }
                    }
                    if (p3 == p)
                    {
                        if (!workQueue.Contains(p3))
                        {
                            workQueue[ptr++] = p3;
                        }
                    }
                    if (p4 == p)
                    {
                        if (!workQueue.Contains(p4))
                        {
                            workQueue[ptr++] = p4;
                        }
                    }
                }
            }
            return (ptr == pl.Count);
        }
Beispiel #14
0
        /// <summary>
        ///
        /// </summary>
        public void Start()
        {
            var pInterior = Factory.CreatePoint(new Coordinate(100, 100));
            var pExterior = Factory.CreatePoint(new Coordinate(100, 101));

            try
            {
                Write(point.Area);
                Write(point.Boundary);
                Write(point.BoundaryDimension);
                Write(point.Centroid);
                Write(point.Coordinate);
                Write(point.Coordinates);
                Write(point.CoordinateSequence);
                Write(point.Dimension);
                Write(point.Envelope);
                Write(point.EnvelopeInternal);
                Write(point.Factory);
                Write(point.InteriorPoint);
                Write(point.IsEmpty);
                Write(point.IsSimple);
                Write(point.IsValid);
                Write(point.Length);
                Write(point.NumPoints);
                Write(point.PrecisionModel);
                Write(point.X);
                Write(point.Y);

                Write(point.Contains(pInterior));
                Write(point.Contains(pExterior));

                Write(point.Buffer(10));
                Write(point.Buffer(10, new BufferParameters {
                    EndCapStyle = EndCapStyle.Square
                }));
                Write(point.Buffer(10, new BufferParameters {
                    EndCapStyle = EndCapStyle.Flat
                }));
                Write(point.Buffer(10, 20));
                Write(point.Buffer(10, new BufferParameters(20)
                {
                    EndCapStyle = EndCapStyle.Square
                }));
                Write(point.Buffer(10, new BufferParameters(20)
                {
                    EndCapStyle = EndCapStyle.Flat
                }));

                Write(point.Crosses(pInterior));
                Write(point.Crosses(pExterior));
                Write(point.Difference(pInterior));
                Write(point.Difference(pExterior));
                Write(point.Disjoint(pInterior));
                Write(point.Disjoint(pExterior));
                Write(point.EqualsTopologically(pInterior));
                Write(point.EqualsTopologically(pExterior));
                Write(point.EqualsExact(pInterior));
                Write(point.EqualsExact(pExterior));
                Write(point.ConvexHull());
                Write(point.Intersection(pInterior));
                Write(point.Intersection(pExterior));
                Write(point.Intersects(pInterior));
                Write(point.Intersects(pExterior));
                Write(point.IsWithinDistance(pInterior, 0.001));
                Write(point.IsWithinDistance(pExterior, 0.001));
                Write(point.Overlaps(pInterior));
                Write(point.Overlaps(pExterior));
                Write(point.SymmetricDifference(pInterior));
                Write(point.SymmetricDifference(pExterior));
                Write(point.ToString());
                Write(point.AsText());
                Write(point.Touches(pInterior));
                Write(point.Touches(pExterior));
                Write(point.Union(pInterior));
                Write(point.Union(pExterior));
                Write(point.Within(pInterior));
                Write(point.Within(pExterior));

                string pointstring        = "POINT (100.22 100.33)";
                string anotherpointstring = "POINT (12345 3654321)";
                var    geom1 = Reader.Read(pointstring);
                Write(geom1.AsText());
                var geom2 = Reader.Read(anotherpointstring);
                Write(geom2.AsText());

                byte[] bytes = point.AsBinary();
                var    test1 = new WKBReader().Read(bytes);
                Write(test1.ToString());

                bytes = Factory.CreatePoint(new Coordinate(double.MinValue, double.MinValue)).AsBinary();
                var testempty = new WKBReader().Read(bytes);
                Write(testempty);

                bytes = new GDBWriter().Write(geom1);
                test1 = new GDBReader().Read(bytes);
                Write(test1.ToString());

                // Test Empty Geometries
                Write(Point.Empty);
                Write(LineString.Empty);
                Write(Polygon.Empty);
                Write(MultiPoint.Empty);
                Write(MultiLineString.Empty);
                Write(MultiPolygon.Empty);
                Write(GeometryCollection.Empty);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Beispiel #15
0
        public int CountNumberOfOpenNeighbors(Point[] cells)
        {
            var open = 0;

            foreach (var cell in cells)
            {
                foreach (var neighbor in GetNeighboringPoints(cell))
                {
                    if (neighbor.X >= 0 && neighbor.X < BoardState.Width && neighbor.Y >= 0 &&
                        neighbor.Y < BoardState.Height &&
                        !BoardState.Cells[neighbor.X, neighbor.Y] && !cells.Contains(neighbor))
                        open++;
                }
            }

            return open;
        }
        public long GetRoadTime(Point[] points)
        {
            DBC.Assert(points.Length == 2, "Can only get the distance between 2 points.");

            if (points.Contains(PointMother.USAPoints.LocustSt) && points.Contains(PointMother.USAPoints.AshworthRd))
                return 660;

            if (points.Contains(PointMother.USAPoints.LocustSt) && points.Contains(PointMother.USAPoints.UniversityAve))
                return 180;

            if (points.Contains(PointMother.USAPoints.LocustSt) && points.Contains(PointMother.USAPoints.RaccoonSt))
                return 480;

            if (points.Contains(PointMother.USAPoints.LocustSt) && points.Contains(PointMother.USAPoints.ShawSt))
                return 360;

            if (points.Contains(PointMother.USAPoints.AshworthRd) && points.Contains(PointMother.USAPoints.UniversityAve))
                return 600;

            if (points.Contains(PointMother.USAPoints.AshworthRd) && points.Contains(PointMother.USAPoints.RaccoonSt))
                return 840;

            if (points.Contains(PointMother.USAPoints.AshworthRd) && points.Contains(PointMother.USAPoints.ShawSt))
                return 780;

            if (points.Contains(PointMother.USAPoints.UniversityAve) && points.Contains(PointMother.USAPoints.RaccoonSt))
                return 480;

            if (points.Contains(PointMother.USAPoints.UniversityAve) && points.Contains(PointMother.USAPoints.ShawSt))
                return 420;

            if (points.Contains(PointMother.USAPoints.RaccoonSt) && points.Contains(PointMother.USAPoints.ShawSt))
                return 120;

            throw new Exception("Unknown points");
        }
Beispiel #17
0
        //檢查一群組所有的格網點是否連續(上下左右視為連續,對角與間隔視為不連續))
        public static bool IsContinuous(List <Point> pl)
        {
            if (pl.Count == 0)
            {
                return(false);
            }

            Point[] workQueue = new Point[pl.Count];
            workQueue[0] = pl[0];
            for (int i = 1; i < workQueue.Length; ++i)
            {
                workQueue[i].X = -1;
                workQueue[i].Y = -1;
            }
            int ptr = 1;

            for (int i = 0; i < workQueue.Length; ++i)
            {
                Point p0 = workQueue[i];
                if (-1 == p0.X)
                {
                    break;
                }

                Point p1 = new Point(p0.X, p0.Y - 1);
                Point p2 = new Point(p0.X, p0.Y + 1);
                Point p3 = new Point(p0.X - 1, p0.Y);
                Point p4 = new Point(p0.X + 1, p0.Y);

                foreach (Point p in pl)
                {
                    if (p1 == p)
                    {
                        if (!workQueue.Contains(p1))
                        {
                            workQueue[ptr++] = p1;
                        }
                    }
                    if (p2 == p)
                    {
                        if (!workQueue.Contains(p2))
                        {
                            workQueue[ptr++] = p2;
                        }
                    }
                    if (p3 == p)
                    {
                        if (!workQueue.Contains(p3))
                        {
                            workQueue[ptr++] = p3;
                        }
                    }
                    if (p4 == p)
                    {
                        if (!workQueue.Contains(p4))
                        {
                            workQueue[ptr++] = p4;
                        }
                    }
                }
            }
            return(ptr == pl.Count);
        }
Beispiel #18
0
        private bool Scan1()
        {
            string str = "";
            int    kol = 0;

            for (int i = 0; i < w; i++)
            {
                for (int j = 0; j < h; j++)
                {
                    if (Matr[i, j])
                    {
                        kol++;
                    }
                }
            }
            Point[] mass = new Point[kol * 2];
            int     k    = 0;
            Point   tmp  = new Point();

            for (int x1 = 0; x1 < w; x1++)
            {
                for (int y1 = 0; y1 < h; y1++)
                {
                    if (Matr[x1, y1])
                    {
                        tmp = new Point(x1, y1);
                        break;
                    }
                }
                if (!tmp.Equals(new Point()))
                {
                    break;
                }
            }
            mass[k++] = tmp;
            int y = tmp.Y;
            int x;

            for (x = tmp.X + 1; x < w; x++)
            {
                if (Matr[x, y + 1])
                {
                    if (!mass.Contains(new Point(x - 1, y)))
                    {
                        mass[k++] = new Point(x, y);
                    }
                    //mass[k++] = new Point(x, y + 1);
                    y = y + 1;
                    continue;
                }
                if (Matr[x, y - 1])
                {
                    if (!mass.Contains(new Point(x - 1, y)))
                    {
                        mass[k++] = new Point(x, y);
                    }
                    //mass[k++] = new Point(x, y - 1);
                    y = y - 1;
                    continue;
                }
                if (Matr[x, y + 2])
                {
                    if (!mass.Contains(new Point(x - 1, y)))
                    {
                        mass[k++] = new Point(x, y);
                    }
                    //mass[k++] = new Point(x, y + 2);
                    y = y + 2;
                    continue;
                }
                if (Matr[x, y - 2])
                {
                    if (!mass.Contains(new Point(x - 1, y)))
                    {
                        mass[k++] = new Point(x, y);
                    }
                    //mass[k++] = new Point(x, y - 2);
                    y = y - 2;
                    continue;
                }
            }
            for (x = mass[k - 1].X; x > tmp.X; x--)
            {
                if (Matr[x, y + 1])
                {
                    if (!mass.Contains(new Point(x - 1, y)))
                    {
                        mass[k++] = new Point(x, y);
                    }
                    //mass[k++] = new Point(x, y + 1);
                    y = y + 1;
                    continue;
                }
                if (Matr[x, y - 1])
                {
                    if (!mass.Contains(new Point(x - 1, y)))
                    {
                        mass[k++] = new Point(x, y);
                    }
                    //mass[k++] = new Point(x, y - 1);
                    y = y - 1;
                    continue;
                }
                if (Matr[x, y + 2])
                {
                    if (!mass.Contains(new Point(x - 1, y)))
                    {
                        mass[k++] = new Point(x, y);
                    }
                    // mass[k++] = new Point(x, y + 2);
                    y = y + 2;
                    continue;
                }
                if (Matr[x, y - 2])
                {
                    if (!mass.Contains(new Point(x - 1, y)))
                    {
                        mass[k++] = new Point(x, y);
                    }
                    //mass[k++] = new Point(x, y - 2);
                    y = y - 2;
                    continue;
                }
            }
            for (int i = 0; i < k; i++)
            {
                str += " (" + mass[i].X.ToString() + ", " + mass[i].Y.ToString() + ") ";
            }
            textBox3.Text = str;
            int re = Convex(mass, k);

            return(re == -1);

            //bool[,] tmpM = (bool[,]) Matr.Clone();
            //int x = 0;
            //for (; x < w; x++)
            //{
            //    Point pp;
            //    for (int y1 = 0; y1 < h; y1++)
            //        if (Matr[x, y1])
            //            pp = new Point(x, y1);
            //    if (pp == null)
            //        continue;

            //    for (int x1 = x + 1; x1 < w; x1++)
            //    {
            //        bool tr = false;
            //        for (int y = 0; y < h; y++)
            //        {
            //            if (Matr[x, y])
            //            {
            //                tr = true;
            //                if (pp.Y == y)
            //                    continue;
            //                double six = Math.Abs(pp.X - x) / Math.Abs(pp.Y - y);
            //                int tmpy = pp.Y;
            //                for (int tmpx = pp.X; tmpx != x; tmpx++)
            //                {

            //                }

            //            }
            //            tr = true;

            //            if (tr)
            //                tmpM[x, y] = true;

            //        }
            //    }


            //}
        }
Beispiel #19
0
        public int CheckRemovedLines(Point[] cells, int minHeight, int maxHeight)
        {
            var removedLines = 0;
            for (var i = minHeight; i <= maxHeight; i++)
            {
                var removed = true;
                for (var j = 0; j < BoardState.Width; j++)
                {
                    if (!BoardState.Cells[j, i] && !cells.Contains(new Point(j, i)))
                    {
                        removed = false;
                        break;
                    }
                }

                if (removed)
                    removedLines++;
            }

            return removedLines;
        }
Beispiel #20
0
        private Point CheckAround(Point toCheck, Point[] lastPoints)
        {
            //Check in a square around the last point for new pixels
            for (int i = 0; i <= 7; i++)
            {
                //Get which point to check next
                Point delta = Delta(i);
                Point check = new Point(toCheck.X + delta.X, toCheck.Y + delta.Y);

                //Check if the vinyl contains the point
                if (!VinylContains(check))
                    continue;

                //Check if the point should not be ignored and isn't in the last points
                if (!IgnoreColor(GetColor(check)) && !lastPoints.Contains(check))
                    return check;
            }

            return Point.Empty;
        }