//Interpolation
private static double fonctionsInterp(double x, TypeInterpolation Interp)
{
//Renvoie le coefficient d'interpolation k [0,1] en fonction du parcours x
double result;
switch (Interp)
{
case TypeInterpolation.Lineaire:
result = x;
break;
case TypeInterpolation.Cosinus:
result = 0.5 * (1.0 - Math.Cos(x * Math.PI));
break;
case TypeInterpolation.Hermite:
result = 3.0 * x * x - 2.0 * x * x * x;
break;
case TypeInterpolation.C2:
result = 6.0 * x * x * x * x * x - 15.0 * x * x * x * x + 10.0 * x * x * x;
break;
default:
result = 0.0;
break;
}
return(result);
}
public static double perlin(double[] Position, int seed, TypeInterpolation TI, int nbOctaves, double f0, double Attenuation, double Decalage, double puissance, int nbPlateaux, double k_plateaux)
{
//Renvoie un bruit de perlin a n dim pour l'interpolation specifiee, lissage par la puisssance "puissance"
//nbPlateaux, nombre de plages de valeurs prises possibles. mettre à 0 pour toutes les valeurs possibles
//k_plateaux est la pente des plateaux [0,1]
double Resultat = 0.0;
double Amplitude = 1.0;
double f = f0;
double[] shift = new double[Position.Length];
double[] Pos = new double[Position.Length];
double sommeAmp = 0;
for (int i = 0; i < nbOctaves; i++)
{
shift = vect_pseudo_Alea(i * 452237 + 700849, Position.Length, seed);
multiplierVect(ref shift, Decalage * pseudo_Alea(i * 89746 + 6577, seed));
Pos = copie(Position);
shifter(ref Pos, ref shift);
multiplierVect(ref Pos, f);
Resultat += perlinSimple(ref Pos, seed, TI) * Amplitude;
sommeAmp += Amplitude;
Amplitude *= Attenuation;
f *= 2;
}
Resultat = Resultat / sommeAmp;
Resultat = Math.Sign(Resultat) * Math.Pow(Math.Abs(Resultat), puissance);
if (nbPlateaux > 0)
{
double s = 0;
if (k_plateaux != 0)
{
s = k_plateaux * (1.0 / (float)nbPlateaux) * ((float)nbPlateaux * Resultat - Math.Floor((float)nbPlateaux * Resultat));
}
Resultat = (1.0 / (float)nbPlateaux) * Math.Floor((float)nbPlateaux * Resultat);
Resultat += s;
}
return(Resultat);
}
public static double perlin(double[] Position, int seed, TypeInterpolation TI, int nbOctaves, double f0, double Attenuation, double Decalage)
{
//Renvoie un bruit de perlin a n dim pour l'interpolation specifiee
return(perlin(Position, seed, TI, nbOctaves, f0, Attenuation, Decalage, 1.0, 0, 0));
}
public static double perlin(double[] Position, int seed, TypeInterpolation TI, int nbOctaves, double f0, double Attenuation, double Decalage, double puissance, int nbPlateaux)
{
//Renvoie un bruit de perlin a n dim pour l'interpolation specifiee, lissage par la puisssance "puissance"
//nbPlateaux, nombre de valeurs prises possibles
return(perlin(Position, seed, TI, nbOctaves, f0, Attenuation, Decalage, puissance, nbPlateaux, 0.0));
}
private static double perlinSimple(ref double[] Position, int seed, TypeInterpolation TI)
{
//Obtient un bruit de perlin itere une fois et de frequence 1
return(Math.Min(Math.Max(interpolerEspace(Position, new int[Position.Length], Position.Length - 1, seed, TI), -1.0), 1.0));
}
private static double interpolerEspace(double[] Position, int[] PosGrille, int N0, int seed, TypeInterpolation TI)
{
//Permet d'obtenir une interpolation pour une sous dim, a partir d'une selection des coordonees du point de ref pour les dim superieures
if (N0 < 0)
{
//La valeur voulue pour un point de la grille est le produit scalaire entre le gradient a la position de la grille voulue, et la distance a cette position
double[] dist = recentrer(PosGrille, Position);
return(produitScalaire(dist, vect_pseudo_Alea_Rn(PosGrille, seed)));
}
else
{
//On choisit la dim N0 (2 choix) et on interpole les deux options entre elles
double x = Position[N0];
//projection sur la dim N0 et recuperation du coeff d'interpolation
double k = fonctionsInterp(x - Math.Floor(x), TI);
int[] P1 = copie(PosGrille);
int[] P2 = copie(PosGrille);
//fixer la valeur pour la dim N0
P1[N0] = (int)Math.Floor(Position[N0]);
P2[N0] = (int)Math.Floor(Position[N0]) + 1;
//interpolation
double b1 = interpolerEspace(Position, P1, N0 - 1, seed, TI);
double b2 = interpolerEspace(Position, P2, N0 - 1, seed, TI);
double inter = ((1.0 - k) * b1 + k * b2);
return(inter);
}
}
public static Application perlin(int seed, TypeInterpolation TI, int nbOctaves, double f0, double Attenuation, double Decalage, double puissance, int nbPlateaux, double k_plateaux)
{
return(x => (1.0 + perlin(x, seed, TI, nbOctaves, f0, Attenuation, Decalage, puissance, nbPlateaux, k_plateaux)) / 2.0);
}
public TypeInterpolationChangedEventArgs(TypeInterpolation oldType, TypeInterpolation newType)
{
_oldType = oldType;
_newType = newType;
}
