svn.filsa.org sketches

Rev

Blame | Last modification | View Log | RSS feed

package org.filsa.devfest.patchwork;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.PriorityQueue;
import java.util.Queue;

import org.apache.log4j.Logger;

public class GridProcessor implements Processor {

        static Logger log = Logger.getLogger(GridProcessor.class);

        private final Grid theGrid;

        private List<Area> areaList;
       
        public GridProcessor(Grid theGrid) {
                this.theGrid = theGrid;
        }

        /**
         * Loop through gridCells
         * - foreach
         *   - if (!isProcessed) processArea
         */

        public List<Area> process() {
               
                this.areaList = new ArrayList<Area>();
               
                for (int row=0;row < theGrid.getRowCount(); row++) {
                        for (int col=0;col < theGrid.getColCount(); col++) {
                                GridCell currentCell = theGrid.getCell(row, col);
                                if (!currentCell.isProcessed()) {
                                        //create new area
                                        this.areaList.add(processArea(currentCell));
                                }
                        }
                }

                Collections.sort(areaList);

                log.info("areaList:: size=" + areaList.size());
                return areaList;

        }

        /**
         *     - create new Area.
         *     - add currentCell to workQueue.
         *     - process workQueue:
         *       - find adjacents(adjacent + same color), add to workQueue.
         *       - mark current cell as processed.
         *
         * @param currentCell
         */

        private Area processArea(GridCell currentCell) {
               
                Area currentArea = new Area(currentCell);

                Queue<GridCell> workQueue = new PriorityQueue<GridCell>();
                workQueue.add(currentCell);
               
                while (workQueue.peek() != null) {
                        GridCell cell = workQueue.poll();
                        workQueue.addAll(findAdjacentCells(cell));
                        currentArea.add(cell);
                        cell.finishedProcessing();
                }

                //log.info(currentArea.toString());
                return currentArea;
        }

        private List<GridCell> findAdjacentCells(GridCell cell) {

                List<GridCell> results = new ArrayList<GridCell>();
                GridCell north = theGrid.getCell(cell.getRow() -1, cell.getCol() );
                GridCell south = theGrid.getCell(cell.getRow() +1, cell.getCol() );
                GridCell east = theGrid.getCell(cell.getRow() , cell.getCol() +1);
                GridCell west = theGrid.getCell(cell.getRow() , cell.getCol() -1);

                if (north != null
                                && !north.isProcessed()
                                && (north.getColor() == cell.getColor())) {
                        results.add(north);
                }
               
                if (south != null
                                && !south.isProcessed()
                                && (south.getColor() == cell.getColor())) {
                        results.add(south);
                }
               
                if (east != null
                                && !east.isProcessed()
                                && (east.getColor() == cell.getColor())) {
                        results.add(east);
                }
               
                if (west != null
                                && !west.isProcessed()
                                && (west.getColor() == cell.getColor())) {
                        results.add(west);
                }
               
               
               
                return results;
        }

        public List<Integer> calc(Area biggestArea) {

                this.mark(biggestArea);
               
                List<Integer> result = new ArrayList<Integer>();
               
               
                for (int row=0;row < theGrid.getRowCount(); row++) {
                        int markedCount = 0;
                        for (int col=0;col < theGrid.getColCount(); col++) {
                                GridCell currentCell = theGrid.getCell(row, col);
                                if (currentCell.isMarked()) {
                                        markedCount++;
                                }
                        }
                        result.add(Integer.valueOf(markedCount));
                }
               
                return result;
        }

       
        public void mark(Area biggest) {
               
                for (GridCell cell : biggest.getAllCells()) {
                        cell.setMark();
                }
               
               
               
        }
       
}