package ac.essex.ooechs.imaging.commons.segmentation; 
 
import ac.essex.ooechs.imaging.commons.util.panels.ImagePanel; 
import ac.essex.ooechs.imaging.commons.util.panels.FileTree; 
import ac.essex.ooechs.imaging.commons.util.ImageFilenameFilter; 
import ac.essex.ooechs.imaging.commons.PixelLoader; 
import ac.essex.ooechs.imaging.commons.ConvolutionMatrix; 
 
import javax.swing.*; 
import java.io.File; 
import java.awt.image.BufferedImage; 
import java.awt.*; 
import java.awt.event.MouseAdapter; 
import java.awt.event.MouseEvent; 
 
public class DataCrawlerGUI extends JFrame { 
 
    protected ImagePanel p; 
    protected JButton load, segment; 
 
    private int startX, startY; 
 
    public DataCrawlerGUI(File file) { 
        super("Data Crawler GUI"); 
 
        p = new ImagePanel(); 
 
        p.setCursor(new Cursor(Cursor.CROSSHAIR_CURSOR)); 
 
        p.addMouseListener(new MouseAdapter() { 
            public void mousePressed(MouseEvent e) { 
                startX = p.getX(e); 
                startY = p.getY(e); 
                crawl(); 
            } 
        }); 
 
        FileTree f = new FileTree(file, new ImageFilenameFilter()) { 
 
            /** 
             * Called when a file is selected in the tree 
             */ 
            public void onSelectFile(File f) { 
                loadImage(f); 
            } 
 
        }; 
 
        JSplitPane splitPane = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT, true, new JScrollPane(f), new JScrollPane(p)); 
        getContentPane().add(splitPane); 
        setDefaultCloseOperation(EXIT_ON_CLOSE); 
        setSize(640, 480); 
        setVisible(true); 
    } 
 
    protected void loadImage(File f) { 
        if (f != null) { 
            try { 
                p.setImage(new PixelLoader(f)); 
            } catch (Exception err) { 
                err.printStackTrace(); 
            } 
        } 
    } 
 
 
 
    protected void crawl() { 
        new Thread() { 
            public void run() { 
 
                Graphics g = p.getGraphics(); 
                g.setColor(Color.RED); 
 
                // current grayscale value 
                PixelLoader image = new PixelLoader(p.getImage()); 
                int previous = image.getGreyValue(startX, startY); 
                boolean[][] mask = new boolean[image.getWidth()][image.getHeight()]; 
 
                crawlOneStep(mask, previous, image, startX, startY, g); 
 
            } 
        }.start(); 
    } 
 
    private void crawlOneStep(boolean[][] mask, int previous, PixelLoader image, int x, int y, Graphics g) { 
 
        try { 
 
            // draw the path 
            g.drawRect(x, y, 1, 1); 
 
            // so the crawler cannot go wherever its been already 
            mask[x][y] = true; 
 
 
 
            int closest = Integer.MAX_VALUE; 
            int closestX = 0; 
            int closestY = 0; 
            int closestdX = 0; 
            int closestdY = 0; 
 
            // find the closest value 
            for (int dy = -1; dy <= 1; dy++) { 
                for (int dx = -1; dx <= 1; dx++) { 
 
                    // don't check myself 
                    if (dx == 0 && dy == 0) continue; 
 
                    int nx = x + dx, ny = y + dy; 
 
                    // ignore if its already on my path 
                    if (mask[nx][ny]) continue; 
 
                    int next = image.getGreyValue(nx, ny); 
 
                    int difference = Math.abs(next - previous); 
 
                    if (difference < closest) { 
                        closest = difference; 
                        closestX = nx; 
                        closestY = ny; 
                        closestdX = dx; 
                        closestdY = dy; 
                    } 
                } 
            } 
 
            // stop if its more than 10% different. 
            if ((closest / (double) previous) < 0.2) { 
 
                // add to the mask dependent on dx and dy 
                if (closestdY == 0) { 
                    // moved left or right 
                    mask[x + closestdX][y - 1] = true; 
                    mask[x + closestdX][y + 1] = true; 
                } 
 
                if (closestdX == 0) { 
                    // moved up or down 
                    mask[x - 1][y + closestdY] = true; 
                    mask[x + 1][y + closestdY] = true; 
                } 
 
                if (closestdX != 0 && closestdY != 0) { 
                    // moved diagonally 
                    mask[x + closestdX][y] = true; 
                    mask[x][y + closestdY] = true; 
                } 
 
                crawlOneStep(mask, previous, image, closestX, closestY, g); 
                 
            } 
 
        } catch (ArrayIndexOutOfBoundsException e) { 
            // ignore 
        } 
 
    } 
 
    public static void main(String args[]) { 
        File directory = new File("/home/ooechs/Desktop/Documents/Papers/Pipelines/data"); 
        new DataCrawlerGUI(directory); 
    } 
 
}