股票涨跌分布热力图算法

public class Main {

    //问题抽象 假设数组已排序 1、给定宽高 2、宽高Max 区分横向或者竖向分配 3、分配一个阈值 大于1/3时直接以当前最小宽度作为宽计算， 小于BORDER的面基的时候加上下一个值再次判断，是否大于BORDER重复 第3条 动态阈值每一次分配计算一个合适的阈值

    public static float BORDER = 0.25f;
    public static int H = 0;
    public static int V = 1;
    private static List<Float> ratios = new ArrayList<>();
    private static List<Bean> beans = new ArrayList<>();
    private static final float originWidth = 196;
    private static final float originHeight = 97;
    private static final float area = originWidth * originHeight;
    private static float sumRatio = 0;

    public static class Bean {
        private float width;
        private float height;
        private float startX;
        private float startY;
        private float endX;
        private float endY;

        public float getStartX() {
            return startX;
        }

        public void setStartX(float startX) {
            this.startX = startX;
        }

        public float getStartY() {
            return startY;
        }

        public void setStartY(float startY) {
            this.startY = startY;
        }

        public float getEndX() {
            return endX;
        }

        public void setEndX(float endX) {
            this.endX = endX;
        }

        public float getEndY() {
            return endY;
        }

        public void setEndY(float endY) {
            this.endY = endY;
        }

        public float getWidth() {
            return width;
        }

        public void setWidth(float width) {
            this.width = width;
        }

        public float getHeight() {
            return height;
        }

        public void setHeight(float height) {
            this.height = height;
        }
    }

    public static void main(String[] args) {
//        float width = 50;
//        float height = 100;
//        float area = width * height;
//        float sumRatio = 170f;


//        ratios.add(40f);
//        ratios.add(35f);
//        ratios.add(30f);
//        ratios.add(25f);
//        ratios.add(20f);
//        ratios.add(15f);
//        ratios.add(10f);
//        ratios.add(5f);

//        ratios.add(40f);
//        ratios.add(38f);
//        ratios.add(35f);
//        ratios.add(30f);
//        ratios.add(28f);
//        ratios.add(26f);
//        ratios.add(25f);
//        ratios.add(20f);
//        ratios.add(18f);
//        ratios.add(17f);
//        ratios.add(15f);
//        ratios.add(12f);
//        ratios.add(10f);
//        ratios.add(7f);
//        ratios.add(1f);
//
//        for (Float f :
//                ratios) {
//            sumRatio += f;
//        }
//
//        Dynamic(originWidth, originHeight, 0, area, sumRatio, ratios);
//
//        for (Bean b : beans) {
//            System.out.println("W: " + b.getWidth() + ", H: " + b.getHeight());
//            System.out.println("Start(x,y): " + b.getStartX() + "," + b.getStartY() + ", End(x,y): " + b.getEndX() + "," + b.getEndY());
//        }
    }

    public static void Dynamic(float width, float height, int index, float area, float sumRatio, List<Float> ratios) {
        System.out.println("width: " + width + ", " + "height: " + height + ", " + "index: " + index + ", " + "area: " + area + ", " + "sumRatio: " + sumRatio + ", ");

        float minSide = Math.min(width, height);
        int orientation = width > height ? H : V;
        int i = index;
        float usedRatio = 0;

        while (i < ratios.size()) {
            usedRatio = usedRatio + ratios.get(i);
            float usedRatioRatio = usedRatio / sumRatio;
            float usedArea = usedRatioRatio * area;
            float value = usedArea / minSide;
            if (usedRatioRatio < BORDER) {
                i++;
                System.out.println(usedRatioRatio + " 小于" + BORDER + " i: " + i);
                if (i == ratios.size() - 1) {
                    System.out.println("剩下的全部分配掉");
                    if (i == index) {
                        Bean bean = new Bean();
                        bean.setWidth(orientation == H ? value : width);
                        bean.setHeight(orientation == H ? height : value);

                        bean.setStartX(originWidth - width);
                        bean.setStartY(originHeight - height);

                        bean.setEndX(originWidth - width + bean.getWidth());
                        bean.setEndY(originHeight - height + bean.getHeight());

                        beans.add(bean);
                        System.out.println("只有一个直接分配");
                    } else {
                        float lastEndX = originWidth - width;
                        float lastEndY = originHeight - height;
                        for (int j = index; j <= i; j++) {
                            float segValue = ratios.get(j) / usedRatio * minSide;
                            Bean bean = new Bean();
                            bean.setWidth(orientation == H ? value : segValue);
                            bean.setHeight(orientation == H ? segValue : value);
                            bean.setStartX(lastEndX);
                            bean.setStartY(lastEndY);

                            lastEndX = lastEndX + bean.getWidth();
                            lastEndY = lastEndY + bean.getHeight();
                            bean.setEndX(lastEndX);
                            bean.setEndY(lastEndY);

                            beans.add(bean);
                            System.out.println("多个循环分配" + j);
                        }
                    }
                }
            } else {
                System.out.println(usedRatioRatio + " 大于" + BORDER);

                if (i == index) {
                    Bean bean = new Bean();
                    bean.setWidth(orientation == H ? value : width);
                    bean.setHeight(orientation == H ? height : value);

                    bean.setStartX(originWidth - width);
                    bean.setStartY(originHeight - height);

                    bean.setEndX(originWidth - width + bean.getWidth());
                    bean.setEndY(originHeight - height + bean.getHeight());

                    beans.add(bean);
                    System.out.println("只有一个直接分配");
                } else {

                    float nextStartX = originWidth - width;
                    float nextStartY = originHeight - height;

                    float lastEndX = originWidth - width;
                    float lastEndY = originHeight - height;


                    for (int j = index; j <= i; j++) {
                        float segValue = ratios.get(j) / usedRatio * minSide;
                        Bean bean = new Bean();
                        bean.setWidth(orientation == H ? value : segValue);
                        bean.setHeight(orientation == H ? segValue : value);

                        bean.setStartX(nextStartX);
                        bean.setStartY(nextStartY);

                        nextStartX = orientation == H ? originWidth - width : nextStartX + bean.getWidth();
                        nextStartY = orientation == H ? nextStartY + bean.getHeight() : originWidth - width;

                        lastEndX = orientation == H ? bean.getWidth() : lastEndX + bean.getWidth();
                        lastEndY = orientation == H ? lastEndY + bean.getHeight() : bean.getHeight();
                        bean.setEndX(lastEndX);
                        bean.setEndY(lastEndY);

                        beans.add(bean);
                        System.out.println("多个循环分配" + j);
                    }
                }

                area = area - usedArea;
                sumRatio = sumRatio - usedRatio;
                i++;
                if (i < ratios.size()) {
                    Dynamic(orientation == H ? width - value : width, orientation == H ? height : height - value, i, area, sumRatio, ratios);
                }
                System.out.println("一轮完成");
                break;
            }
        }
    }
}