Circular a plano. Algoritmo sin uso práctico conocido.

Este algoritmo no tiene ningún uso práctico, sólo sirve para fines didácticos y apredizaje.
La premisa consiste en dibujar un máximo de dos pixeles por línea horizontal, línea vertical y línea diagonal.


Código 1 (Circular_a_Plano.java):

package circular_a_plano;

import java.awt.Graphics2D;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import javax.imageio.ImageIO;

public class Circular_a_Plano {

    public static void main(String[] args) {

        Boolean[][] map = new Boolean[32][32];

        //inicializar matrix
        for (int i = 0; i < map.length; i++) {
            for (int j = 0; j < map.length; j++) {
                map[j][i] = false;
            }
        }

        map[0][0] = true;
        map[1][1] = true;

        boolean X_libre = true, Y_libre = true;
        boolean Dx_libre = true;
        for (int y = 0; y < map.length; y++) {
            for (int x = 0; x < map.length; x++) {
                X_libre = comprobarX(y, map);
                Y_libre = comprobarY(x, map);
                Dx_libre = comprobarDx(x, y, map);

                if (X_libre && Y_libre && Dx_libre) {
                    map[x][y] = true;
                }
            }
        }
        
        Resultados(map);

        //tamaño lienzo
        int res_x = 1024;
        int res_y = 1024;

        BufferedImage imagen = new BufferedImage(res_x, res_y, BufferedImage.TYPE_INT_RGB);
        Lienzo.Dibujar((Graphics2D) imagen.getGraphics(), res_x, res_y, map);
        try {
            ImageIO.write(imagen, "png", new File("Laberinto.png"));
        } catch (IOException e) {
        }
    }

    private static boolean comprobarX(int y, Boolean[][] map) {
        //comprobación i
        int cont = 0;
        boolean libre = true;
        for (int i = 0; i < map.length; i++) {
            if (map[i][y]) {
                cont++;
            }
            if (cont >= 2) {
                libre = false;
                break;
            }
        }
        return libre;
    }

    private static boolean comprobarY(int x, Boolean[][] map) {
        //comprobación j
        int cont = 0;
        boolean libre = true;
        for (int i = 0; i < map.length; i++) {
            if (map[x][i]) {
                cont++;
            }
            if (cont >= 2) {
                libre = false;
                break;
            }
        }
        return libre;
    }

    private static boolean comprobarDx(int x, int y, Boolean[][] map) {
        //comprobación j
        int cont = 0;
        boolean libre = true;
        int aux = 0;
        if (x <= y) {
            aux = y - x;
            for (int i = 0; i < map.length - aux; i++) {
                if (map[i][aux + i]) {
                    cont++;
                }
            }
            if (cont >= 2) {
                libre = false; //¿funciona?
            }
        }
        if (x >= y) {
            aux = x - y;
            for (int i = 0; i < map.length - aux; i++) {
                if (map[aux + i][i]) {
                    cont++;
                }
            }
            if (cont >= 2) {
                libre = false; //¿funciona?
            }
        }
        return libre;
    }

    private static boolean comprobarDy(int x, int y, Boolean[][] map) {
        int cont = 0;
        int aux = 0;
        boolean libre = true;
        if (x < y) { //if x<y parcial resolve...
            for (int i = x - aux; i < map.length; i++) {
                if (map[i][(y + aux - cont)] || map[y - cont][i]) {
                    cont++;
                }
                if (cont >= 2) {
                    libre = false;
                    break;
                }
            }
        }
        return libre;
    }

    private static void Resultados(Boolean[][] map) {
        System.out.println("Resultado:\n");
        String libre = "";
        for (int i = 0; i < map.length; i++) {
            for (int j = 0; j < map.length; j++) {
                if (map[j][i]) {
                    libre = libre + "█";
                } else {
                    libre = libre + "·";
                }
            }
            libre = libre + ("\n");
        }
        System.out.println(libre);
    }

}


Código 2 (Lienzo.java):

package circular_a_plano;

import java.awt.Color;
import java.awt.Graphics2D;

class Lienzo {

    static void Dibujar(Graphics2D g, int x, int y, Boolean[][] map) {

        //tamaño bloque
        int tCuadroX = x / map.length;

        //fondo blanco
        g.setColor(Color.WHITE);
        g.fillRect(0, 0, x, y);

        //rejilla
        g.setColor(Color.blue);
        for (int i = 0; i < x; i = i + tCuadroX) {
            g.drawLine(0, i, x, i); //horizontal
            g.drawLine(i, 0, i, x); //vertical
        }

        //dibujar bloques muro
        g.setColor(Color.black);
        for (int j = 0; j < map.length; j++) {
            for (int i = 0; i < map.length; i++) {
                if (map[i][j]) {
                    g.fillRect(tCuadroX * i, tCuadroX * j, tCuadroX, tCuadroX);
                }
            }
        }
    }

}


Resultado: