[JAVA] Logik zum Zeichnen eines Kreises auf der Konsole mit ASCII-Grafik

↓ Zeichne so etwas (Qiita macht eine Ellipse und es ist schwer zu sehen ...)

●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●
●●●●●●●●●●○○○○○○○○○○●●●●●●●●●●●
●●●●●●●●○○○○○○○○○○○○○○●●●●●●●●●
●●●●●●○○○○○○○○○○○○○○○○○○●●●●●●●
●●●●●○○○○○○○○○○○○○○○○○○○○●●●●●●
●●●●○○○○○○○○○○○○○○○○○○○○○○●●●●●
●●●○○○○○○○○○○○○○○○○○○○○○○○○●●●●
●●●○○○○○○○○○○○○○○○○○○○○○○○○●●●●
●●○○○○○○○○○○○○○○○○○○○○○○○○○○●●●
●●○○○○○○○○○○○○○○○○○○○○○○○○○○●●●
●○○○○○○○○○○○○○○○○○○○○○○○○○○○○●●
●○○○○○○○○○○○○○○○○○○○○○○○○○○○○●●
●○○○○○○○○○○○○○○○○○○○○○○○○○○○○●●
●○○○○○○○○○○○○○○○○○○○○○○○○○○○○●●
●○○○○○○○○○○○○○○○○○○○○○○○○○○○○●●
●○○○○○○○○○○○○○○○○○○○○○○○○○○○○●●
●○○○○○○○○○○○○○○○○○○○○○○○○○○○○●●
●○○○○○○○○○○○○○○○○○○○○○○○○○○○○●●
●○○○○○○○○○○○○○○○○○○○○○○○○○○○○●●
●○○○○○○○○○○○○○○○○○○○○○○○○○○○○●●
●●○○○○○○○○○○○○○○○○○○○○○○○○○○●●●
●●○○○○○○○○○○○○○○○○○○○○○○○○○○●●●
●●●○○○○○○○○○○○○○○○○○○○○○○○○●●●●
●●●○○○○○○○○○○○○○○○○○○○○○○○○●●●●
●●●●○○○○○○○○○○○○○○○○○○○○○○●●●●●
●●●●●○○○○○○○○○○○○○○○○○○○○●●●●●●
●●●●●●○○○○○○○○○○○○○○○○○○●●●●●●●
●●●●●●●●○○○○○○○○○○○○○○●●●●●●●●●
●●●●●●●●●●○○○○○○○○○○●●●●●●●●●●●
●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●
●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●

Die Lösung nach dem Drei-Quadrat-Theorem und Ich habe versucht, es durch die Lösungsmethode durch Dreiecksfunktion + 2-Minuten-Suche zu implementieren.

• Die Ausgabe der Lösungsmethode durch Dreiecksfunktion + 2-Minuten-Suche ist etwas seltsam, aber ich bin erschöpft ...

Es scheint, dass die digitale Differentialanalyse nur durch Addition / Subtraktion und Verschiebung gezeichnet werden kann. Zeichnen eines Kreises (1) Bogenzeichnungsalgorithmus

Von diesen denke ich, dass der Drei-Quadrat-Satz wahrscheinlich am einfachsten zu verstehen ist.

import static java.lang.System.out;
import java.util.stream.IntStream;

public abstract class Draw {
	//Einstiegspunkt
	public static void main(String... args) {
		Integer size = 31;//Größe zum Zeichnen

		//Lösung nach dem Drei-Quadrat-Theorem
		new DrawCircle(size) {
			@Override
			Integer threshold(Integer r, Integer x) {
				Integer threshold = Double.valueOf(Math.sqrt(r * r - x * x)).intValue();
				return threshold;
			}
		}.drow();

		out.println();

		//Dreiecksfunktion + 2-Minuten-Suchlösung
		new DrawCircle(size) {
			Integer threshold(Integer r, Integer x) {
				return threshold(r, x, new Double(45), new Double(45/2));
			}
			Integer threshold(Integer r, Integer x, Double angle, Double incAngle) {
				Integer _x =  (int)Math.round(Double.valueOf(r * Math.cos(Math.toRadians(angle))));
				double nextIncAngle = incAngle/2 > 1 ? incAngle/2 : 1;
				if( _x.intValue() > x ) {
					return threshold(r, x, angle + incAngle, nextIncAngle);
				}else if( _x.intValue() < x ) {
					double _angle = angle - incAngle;
					if( _angle < 0 ) {//Ich habe es nicht gut untersucht, aber wenn x den Maximalwert erreicht, wird es zu einer Endlosschleife. Beurteilen Sie also nach Winkel und Schutz
						return 0;
					}else {
						return threshold(r, x, _angle, nextIncAngle);
					}
				}
				return Double.valueOf(r * Math.sin(Math.toRadians(angle))).intValue();
			}
		}.drow();

	}

	//Kreis Zeichenklasse
	abstract static class DrawCircle extends Draw{
		DrawCircle(Integer size) {
			super(size);
		}
		@Override
		Boolean algorithm(Integer x, Integer y) {
			Integer r = size / 2;
			x = fixPostion(r, x);
			y = fixPostion(r, y);
			Integer threshold = threshold(r, x);
			return y > threshold;
		};

		/**
		 *Ermitteln Sie den Schwellenwert dafür, ob er sich in vertikaler Richtung innerhalb oder außerhalb des Kreises befindet
		 * @param r Radius
		 * @param x horizontale Skala
		 * @Vertikale Schwelle zurückgeben
		 */
		abstract Integer threshold(Integer r, Integer x);

		/**
		 *Berechnen Sie die Position des zu berechnenden Kreises aus den Koordinaten(Es ist eine subtile Erklärung ...)。
		 * @param r Radius
		 * @param x Koordinaten
		 * @return
		 */
		Integer fixPostion(Integer r, Integer x){
			if(r < x) {
				x -= r;//Berechnung der rechten Hälfte
			}else {
				x = r - x + 1;//15 weil 1 startet->1, 14->2... 1->In 15 konvertieren
			}
			return x;
		}
	}

	//Inhalt der Draw-Klasse
	Integer size;

	Draw(Integer size) {
		this.size = size;
	}

	abstract Boolean algorithm(Integer x, Integer y);

	void drow() {
		IntStream.rangeClosed(1, size).forEach(y -> {
			IntStream.rangeClosed(1, size).forEach(x -> {
				out.print(algorithm(x, y) ? "●" : "○");
			});
			out.println();
		});
	}
}