[JAVA] Logique pour dessiner un cercle sur la console avec l'art ASCII

↓ Dessinez quelque chose comme ça (Qiita fait une ellipse et c'est difficile à voir ...)

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

La solution par le théorème des trois carrés et J'ai essayé de l'implémenter par la méthode de la solution par fonction triangulaire + recherche de 2 minutes.

• La sortie de la méthode de résolution utilisant la fonction triangulaire + recherche de 2 minutes est un peu étrange, mais je suis épuisé ...

Il semble que l'analyse différentielle numérique ne puisse être établie que par addition / soustraction et décalage. Dessin d'un cercle (1) Algorithme de dessin d'arc

Parmi ceux-ci, je pense que le théorème des trois carrés est probablement le plus facile à comprendre.

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

public abstract class Draw {
	//Point d'accès
	public static void main(String... args) {
		Integer size = 31;//Taille à dessiner

		//Résolution par le théorème des trois carrés
		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();

		//Fonction triangulaire + solution de recherche en 2 minutes
		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 ) {//Je ne l'ai pas bien étudié, mais lorsque x atteint la valeur maximale, cela devient une boucle infinie, alors jugez par l'angle et la garde
						return 0;
					}else {
						return threshold(r, x, _angle, nextIncAngle);
					}
				}
				return Double.valueOf(r * Math.sin(Math.toRadians(angle))).intValue();
			}
		}.drow();

	}

	//Cours de dessin en cercle
	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;
		};

		/**
		 *Obtenez le seuil de savoir s'il est à l'intérieur ou à l'extérieur du cercle dans la direction verticale
		 * @rayon param r
		 * @param x échelle horizontale
		 * @retour Seuil vertical
		 */
		abstract Integer threshold(Integer r, Integer x);

		/**
		 *Calculer la position du cercle à calculer à partir des coordonnées(C'est une explication subtile ...)。
		 * @rayon param r
		 * @coordonnées param x
		 * @return
		 */
		Integer fixPostion(Integer r, Integer x){
			if(r < x) {
				x -= r;//Calcul de la moitié droite
			}else {
				x = r - x + 1;//15 parce que 1 commence->1, 14->2... 1->Convertir en 15
			}
			return x;
		}
	}

	//Contenu de la classe Draw
	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();
		});
	}
}