4 point cropping

import java.awt.Point;
import java.awt.image.BufferedImage;
import java.util.ArrayList;

import si.matej.piracerx.pathfinding.Place_2D;

public class BufferedImageUtils {
    public static BufferedImage getSubImage(BufferedImage buf, Point p1, Point p2, Point p3, Point p4, Point p5) {
        BufferedImage cleared = new BufferedImage(buf.getWidth(), buf.getHeight(), BufferedImage.TYPE_INT_ARGB);
        boolean[][] pixels = new boolean[buf.getWidth()][buf.getHeight()];
        ArrayList<Point> p00 = Place_2D.line(p1, p2);
        for (int i = 0; i < p00.size(); i++) {
            pixels[p00.get(i).x][p00.get(i).y] = true;
        }
        ArrayList<Point> p01 = Place_2D.line(p2, p3);
        for (int i = 0; i < p01.size(); i++) {
            pixels[p01.get(i).x][p01.get(i).y] = true;
        }
        ArrayList<Point> p02 = Place_2D.line(p3, p4);
        for (int i = 0; i < p02.size(); i++) {
            pixels[p02.get(i).x][p02.get(i).y] = true;
        }
        ArrayList<Point> p03 = Place_2D.line(p4, p1);
        for (int i = 0; i < p03.size(); i++) {
            pixels[p03.get(i).x][p03.get(i).y] = true;
        }
        fillArea(p5.x, p5.y, pixels);

        for (int i = 0; i < buf.getWidth(); i++)
            for (int j = 0; j < buf.getHeight(); j++)
                if (pixels[i][j])
                    cleared.setRGB(i, j, buf.getRGB(i, j));
                else
                    cleared.setRGB(i, j, 0x00000000);

        return crop(cleared, p1, p2, p3, p4);
    }

    public static BufferedImage crop(BufferedImage buf, Point p1, Point p2, Point p3, Point p4) {
        int[] xs = new int[4];
        xs[0] = p1.x;
        xs[1] = p2.x;
        xs[2] = p3.x;
        xs[3] = p4.x;
        int[] ys = new int[4];
        ys[0] = p1.y;
        ys[1] = p2.y;
        ys[2] = p3.y;
        ys[3] = p4.y;

        return buf.getSubimage(getMinValue(xs), getMinValue(ys),getMaxValue(xs) - getMinValue(xs), getMaxValue(ys) - getMinValue(ys));
    }

    public static int getMaxValue(int[] array) {
        int maxValue = array[0];
        for (int i = 1; i < array.length; i++) {
            if (array[i] > maxValue) {
                maxValue = array[i];

            }
        }
        return maxValue;
    }

    public static int getMinValue(int[] array) {
        int minValue = array[0];
        for (int i = 1; i < array.length; i++) {
            if (array[i] < minValue) {
                minValue = array[i];
            }
        }
        return minValue;
    }

    public static boolean[][] fillArea(int x, int y, boolean[][] arr) {
        int maxX = arr.length - 1;
        int maxY = arr[0].length - 1;
        int[][] stack = new int[(maxX + 1) * (maxY + 1)][2];
        int index = 0;

        stack[0][0] = x;
        stack[0][1] = y;
        arr[x][y] = true;

        while (index >= 0) {
            x = stack[index][0];
            y = stack[index][1];
            index--;

            if ((x > 0) && (arr[x - 1][y] == false)) {
                arr[x - 1][y] = true;
                index++;
                stack[index][0] = x - 1;
                stack[index][1] = y;
            }

            if ((x < maxX) && (arr[x + 1][y] == false)) {
                arr[x + 1][y] = true;
                index++;
                stack[index][0] = x + 1;
                stack[index][1] = y;
            }

            if ((y > 0) && (arr[x][y - 1] == false)) {
                arr[x][y - 1] = true;
                index++;
                stack[index][0] = x;
                stack[index][1] = y - 1;
            }

            if ((y < maxY) && (arr[x][y + 1] == false)) {
                arr[x][y + 1] = true;
                index++;
                stack[index][0] = x;
                stack[index][1] = y + 1;
            }
        }
        return arr;
    }
}