Beispiel #1
0
        protected virtual void Initialize(FloodParameters parameters, int[,] markMatrix)
        {
            MarkMatrix = markMatrix;

            // deconstructing parameters
            NeighbourhoodType              = parameters.NeighbourhoodType;
            StartX                         = parameters.StartX;
            StartY                         = parameters.StartY;
            ProcessStartAsFirstNeighbour   = parameters.ProcessStartAsFirstNeighbour;
            Qualifier                      = parameters.Qualifier;
            NeighbourProcessor             = parameters.NeighbourProcessor;
            NeighbourStopCondition         = parameters.NeighbourStopCondition;
            SpreadingPositionVisitor       = parameters.SpreadingPositionVisitor;
            SpreadingPositionStopCondition = parameters.SpreadingPositionStopCondition;
            PositionsToVisit               = parameters.PositionsToVisitQueue;
            if (PositionsToVisit.Any())
            {
                throw new ArgumentException("Provided PositionsToVisitQueue was not empty at the beginning of flood spilling.", nameof(parameters));
            }
            FloodBounds boundsRestriction = parameters.BoundsRestriction
                                            ?? new FloodBounds(markMatrix.GetLength(0), markMatrix.GetLength(1));

            GuardBounds(boundsRestriction, StartX, StartY);
            OffsetX = -boundsRestriction.MinX;
            OffsetY = -boundsRestriction.MinY;
            MinX    = boundsRestriction.MinX;
            MinY    = boundsRestriction.MinY;
            MaxX    = boundsRestriction.MaxX;
            MaxY    = boundsRestriction.MaxY;

            InitializeMarkMatrix();
        }
Beispiel #2
0
        /// <summary>
        /// Main loop of flood spilling. Takes positions from the queue, visits them and spreads the flood from them,
        /// processing and adding to queue some of their neighbours.
        /// </summary>
        /// <returns>True if execution has been stopped by meeting a stop condition. False if ran out of elements in queue.</returns>
        private bool RunFlood()
        {
            bool startingPositionCausedStop = OperateOnStartingPosition();

            if (startingPositionCausedStop)
            {
                return(true);
            }

            while (PositionsToVisit.Any())
            {
                int currentX, currentY;
                PositionsToVisit.Dequeue(out currentX, out currentY);

                // visiting position that we just got from queue
                SpreadingPositionVisitor?.Invoke(currentX, currentY);
                if (SpreadingPositionStopCondition != null && SpreadingPositionStopCondition(currentX, currentY))
                {
                    return(true);
                }

                // spreading from visited position
                int  markToGive          = CalculateMark(currentX, currentY);
                bool neighbourCausedStop = SpreadToNeighbours(currentX, currentY, markToGive);
                if (neighbourCausedStop)
                {
                    return(true);
                }
            }
            return(false);
        }