[JAVA] Simulation de diffusion de l'encre coulant à la surface de l'eau
Je l'ai fait en utilisant l'équation de diffusion suivante.
Depuis que j'essaie de m'impliquer dans des courses passées, je produis un fichier image au format ppm comme pratique.
InkFlow.java
package flow;
import java.io.FileWriter;
import java.io.IOException;
public class InkFlow{
//Simule la diffusion de l'encre tombée à la surface de l'eau
static double INK = 255.; //Valeur RVB maximale
static int mx; //Nombre de mailles horizontales(Nombre de pixels dans l'image? devenir)
static int my; //Verticale
static int fc=0; //Variable de nom de fichier
public static void main(String[] args) throws IOException {
/*******
*Réglage(Changer ici)
*******/
//Réglage de la surface de l'eau
int x = 10; //Longueur latérale[cm]
int y = 10; //Longueur verticale[cm]
//Endroits où l'encre tombe (en haut à gauche, en haut à droite, en haut à droite, à gauche, au centre, à droite, en bas à gauche, en bas, en bas à droite)
boolean CPlace[][] = { // Cyan
{false,false,false},
{true,false,false},
{false,false,false}
};
boolean MPlace[][] = { // Magenta
{false,true,false},
{false,false,false},
{false,false,false}
};
boolean YPlace[][] = { // Yellow
{false,false,false},
{false,false,false},
{false,true,false}
};
//La taille de l'encre à pendre
int InkSize = 13;
//Réglage de l'heure
int t=0; //Heure initiale 0[msec]
int T=10000; //Heure de fin[msec]
int ut = 1000; //Heure de l'unité de sortie du fichier[msec]
int inkt = 5000; //Il est temps de faire couler de l'encre[msec]
//Variables de diffusion
double ul = 0.1; //Distance de l'unité[cm]
mx = (int) (x / ul);
my = (int) (y / ul);
double D = 0.25; //Coefficient de diffusion(<0.25)
LogSettings(x,y,InkSize,T,ut, inkt ,ul,mx,my,D); //Journal de configuration
/*******
*Initialisation
*******/
//Initialisation de la couleur (blanc)
double R[][] = InitialInk();
double G[][] = InitialInk();
double B[][] = InitialInk();
//Encre goutte à goutte
DipInk(CPlace, MPlace, YPlace, InkSize, R, G, B);
Output(R, G, B);
/*******
*Boucle principale
*******/
while(t++ <= T) { //Boucle jusqu'à l'heure de fin T
//la diffusion
R = CalcDiffusion(R, D);
G = CalcDiffusion(G, D);
B = CalcDiffusion(B, D);
//Encre goutte à goutte
if(t < inkt) { //inkt msec pendre
DipInk(CPlace, MPlace, YPlace, InkSize, R, G, B);
}
//production
if(t % ut == 0){
Output(R, G, B);
}
}
System.out.println("done");
}
/*******
*Diverses méthodes
*******/
static double[][] InitialInk(){ //Initialisation de l'encre
double a[][] = new double[mx][my];
for(int i = 0; i < mx; i++) {
for(int j = 0; j < my; j++) {
a[i][j] = INK;
}
}
return a;
}
static double[][] CalcDiffusion(double[][] a, double D){ //Calcul de diffusion
double b[][] = new double[mx][my];
//Calcul intérieur
for(int i=1;i<(mx-1);i++){
for(int j=1;j<(my-1);j++){ //Équation de diffusion
b[i][j] = a[i][j] + D * (a[i+1][j] + a[i-1][j] - 2*a[i][j]) + D * (a[i][j+1] + a[i][j-1] - 2*a[i][j]);
}
}
//Calcul externe
for(int i=0;i<mx;i++){
b[i][my-1] = b[i][my-2];
b[i][0] = b[i][1];
}
for(int j=0;j<my;j++){
b[mx-1][j] = b[mx-2][j];
b[0][j] = b[1][j];
}
return b;
}
static void DipInk(boolean[][] CPlace, boolean[][] MPlace, boolean[][] YPlace, int InkSize, double[][] R, double[][] G, double[][] B) {
for(int i = 0; i < CPlace.length; i++) {
for(int j = 0; j < CPlace[0].length; j++) {
if(CPlace[i][j] || MPlace[i][j] || YPlace[i][j]) {
if(CPlace[i][j]) {
DipWithInkSize(R, InkSize, i, j, 0);
} else {
DipWithInkSize(R, InkSize, i, j, 212);
}
if(MPlace[i][j]) {
DipWithInkSize(G, InkSize, i, j, 0);
} else {
DipWithInkSize(G, InkSize, i, j, 212);
}
if(YPlace[i][j]) {
DipWithInkSize(B, InkSize, i, j, 0);
} else {
DipWithInkSize(B, InkSize, i, j, 212);
}
}
}
}
}
static void DipWithInkSize(double[][] C, int InkSize, int a, int b, double val) {
//Augmentez la quantité d'encre dans une spirale en fonction de la taille de l'encre
C[(int) (mx*(2*a+1)/6)][(int) (my*(2*b+1)/6)] = val; //Première encre
int itr = 1;
int i = 1;
while(true) {
for(int x = itr, y = 0; x > 0; x--,y++) {
C[(int) (mx*(2*a+1)/6)+x][(int) (my*(2*b+1)/6)+y] = val;
i++;
if(i >= InkSize) {
return;
}
}
for(int x = 0, y = itr; y > 0; x--, y--) {
C[(int) (mx*(2*a+1)/6)+x][(int) (my*(2*b+1)/6)+y] = val;
i++;
if(i >= InkSize) {
return;
}
}
for(int x = -itr, y = 0; x < 0; x++,y--) {
C[(int) (mx*(2*a+1)/6)+x][(int) (my*(2*b+1)/6)+y] = val;
i++;
if(i >= InkSize) {
return;
}
}
for(int x = 0, y = -itr; y < 0; x++, y++) {
C[(int) (mx*(2*a+1)/6)+x][(int) (my*(2*b+1)/6)+y] = val;
i++;
if(i >= InkSize) {
return;
}
}
itr++;
}
}
static void Output(double[][] R, double[][] G, double[][] B) throws IOException { //Fichier d'image(format ppm)Sortie de
String fname = "3_" + fc++ + ".ppm";
FileWriter fw = new FileWriter(fname); // Difine file name
// Header
fw.write("P3 \r\n");
fw.write("#The P3 means colors are in ASCII, then columns and rows, then 255 for max color, then RGB triplets \r\n");
fw.write(mx + " " + my + " \r\n");
fw.write("" + (int) INK + " \r\n");
// Body
for(int i = 0; i < mx; i++) {
for(int j = 0; j < my; j++) {
fw.write("" + (int) R[i][j] + " " + (int) G[i][j] + " " + (int) B[i][j]);
fw.write(" \r\n");
}
}
fw.close();
System.out.println("output: " + fname);
}
static void LogSettings(int x, int y, int InkSize, int T, int ut, int inkt, double ul, int mx, int my, double D) {
System.out.println("Surface de l'eau(Horizontal x vertical) : " + x + " cm × " + y + " cm");
System.out.println("Taille de l'encre: " + ul*ul*InkSize + " cm^2");
System.out.println("Temps de pendre:" + inkt + " msec");
System.out.println("heure de fin: " + T + " msec");
System.out.println("Heure de l'unité de sortie: " + ut + " msec");
System.out.println("Distance de l'unité: " + ul + " cm");
System.out.println("Nombre de mailles horizontales: " + mx);
System.out.println("Nombre de mailles verticales: " + my);
System.out.println("Coefficient de diffusion: " + D);
System.out.println("-*-*-*-");
if(mx / 6 < InkSize) {
System.out.println("InkSize est trop grand");
}
}
}
Dans la console, la sortie est la suivante.
Surface de l'eau(Horizontal x vertical) : 10 cm × 10 cm
Taille de l'encre: 0.13000000000000003 cm^2
Temps de pendre:5000 msec
heure de fin: 10000 msec
Heure de l'unité de sortie: 1000 msec
Distance de l'unité: 0.1 cm
Nombre de mailles horizontales: 100
Nombre de mailles verticales: 100
Coefficient de diffusion: 0.25
-*-*-*-
output: 3_0.ppm
output: 3_1.ppm
output: 3_2.ppm
output: 3_3.ppm
output: 3_4.ppm
output: 3_5.ppm
output: 3_6.ppm
output: 3_7.ppm
output: 3_8.ppm
output: 3_9.ppm
output: 3_10.ppm
done
L'image de sortie doit ressembler à celle ci-dessous
Recommended Posts