Beispiel #1
0
        private static SizePossibleSlice GetPossibleSliceDimensions(int minCells, int maxCells)
        {
            Console.WriteLine("Getting possible dimnesions of the slices..");
            var attempsPossible = new SizePossibleSlice();

            //finding all possible slices dimensions
            for (var cellsInSlice = minCells; cellsInSlice <= maxCells; cellsInSlice++)
            {
                for (var rowsInSlice = 1; rowsInSlice <= cellsInSlice; rowsInSlice++)
                {
                    //checking for valid rows x columns combination
                    if ((cellsInSlice % rowsInSlice) != 0)
                    {
                        continue;
                    }
                    //columns count
                    var colsInSlice = cellsInSlice / rowsInSlice;
                    //reaching this far means the combination is acceptable
                    attempsPossible.Push(rowsInSlice, colsInSlice);
                }
            }

            Console.WriteLine($"Possible dimensions of slices had been calculated: {attempsPossible.Count}");
            return(attempsPossible);
        }
Beispiel #2
0
        private static List <Point> GetPossibleQuadDirectionalEndPoints(
            int row,
            int column,
            int rowsCount,
            int colsCount,
            SizePossibleSlice possibleSliceSize)
        {
            //only negative coordinations are rejected
            var quadDirectionsEndPoints = new List <Point>();

            var maxRow = rowsCount - 1;
            var maxCol = colsCount - 1;

            var forwardSliceX = row + possibleSliceSize.RowsCount - 1;
            var forwardSliceY = column + possibleSliceSize.ColumnsCount - 1;

            var backwrdSliceX = row + possibleSliceSize.RowsCount - 1;
            var backwrdSliceY = column - possibleSliceSize.ColumnsCount + 1;

            var upMrrorSliceX = row - possibleSliceSize.RowsCount + 1;
            var upMrrorSliceY = column + possibleSliceSize.ColumnsCount - 1;

            var diagnalSliceX = row - possibleSliceSize.RowsCount + 1;
            var diagnalSliceY = column - possibleSliceSize.ColumnsCount + 1;


            if (forwardSliceX >= 0 && forwardSliceY >= 0)
            {
                if (forwardSliceX <= maxRow && forwardSliceY <= maxCol)
                {
                    quadDirectionsEndPoints.Add(new Point(forwardSliceX, forwardSliceY));
                }
            }

            if (backwrdSliceX >= 0 && backwrdSliceY >= 0)
            {
                if (backwrdSliceX <= maxRow && backwrdSliceY <= maxCol)
                {
                    quadDirectionsEndPoints.Add(new Point(backwrdSliceX, backwrdSliceY));
                }
            }

            if (upMrrorSliceX >= 0 && upMrrorSliceY >= 0)
            {
                if (upMrrorSliceX <= maxRow && upMrrorSliceY <= maxCol)
                {
                    quadDirectionsEndPoints.Add(new Point(upMrrorSliceX, upMrrorSliceY));
                }
            }

            if (diagnalSliceX >= 0 && diagnalSliceY >= 0)
            {
                if (diagnalSliceX <= maxRow && diagnalSliceY <= maxCol)
                {
                    quadDirectionsEndPoints.Add(new Point(diagnalSliceX, diagnalSliceY));
                }
            }

            return(quadDirectionsEndPoints);
        }