public void Transform1D()
        {
            // Transform forward and inverse and compare with initial values.
              var random = new Random(1234567);

              var s = new Vector2F[16];
              var t = new Vector2F[16];
              for (int i = 0; i < s.Length; i++)
              {
            s[i] = random.NextVector2F(-10, 10);
            t[i] = s[i];
              }

              FastFourierTransformF.Transform1D(t, true);
              FastFourierTransformF.Transform1D(t, false);

              for (int i = 0; i < s.Length; i++)
            Assert.IsTrue(Vector2F.AreNumericallyEqual(s[i], t[i]));
        }
        public void Transform1DAs2DColumn()
        {
            // Result of 2D with one row/column must be the same as 1D.
              var fft = new FastFourierTransformF(16);

              var random = new Random(1234567);

              var s1D = new Vector2F[16];
              var s2D = new Vector2F[16, 1];

              for (int i = 0; i < s1D.Length; i++)
              {
            s1D[i] = random.NextVector2F(-10, 10);
            s2D[i, 0] = s1D[i];
              }

              FastFourierTransformF.Transform1D(s1D, true);
              fft.Transform2D(s2D, true);

              for (int i = 0; i < s1D.Length; i++)
            Assert.AreEqual(s1D[i], s2D[i, 0]);
        }
Exemplo n.º 3
0
    /// <summary>
    /// Initializes a new instance of the <see cref="ProceduralTerrainCreator"/> class.
    /// </summary>
    /// <param name="seed">The seed for the random number generator (e.g. 7777).</param>
    /// <param name="permutationTableSize">
    /// The size of the permutation table (e.g. 256). Must be a power of two.
    /// </param>
    /// <param name="mu">
    /// The constant µ that defines the exponential distribution. Use a value of 1 to get standard
    /// Perlin noise. Use a value greater than 1 (e.g. 1.02) to get Perlin noise with exponentially
    /// distributed gradients. For a <paramref name="permutationTableSize"/> of 256, µ should be in
    /// the range [1, 1.16].
    /// </param>
    public ProceduralTerrainCreator(int seed, int permutationTableSize, float mu)
    {
      if (!MathHelper.IsPowerOf2(permutationTableSize))
        throw new ArgumentException("The permutation table size must be a power of 2 (e.g. 256).");

      _maskB = permutationTableSize - 1;

      var random = new Random(seed);

      // Create table of random gradient vectors (normalized).
      _gradients = new Vector2F[permutationTableSize];
      for (int i = 0; i < _gradients.Length; i++)
      {
        var direction = random.NextVector2F(-1, 1);
        if (!direction.TryNormalize())
          direction = new Vector2F(1, 0);

        _gradients[i] = direction;
      }

      // Create table with a permutation of the values 0 to permutationTableSize.
      _permutations = new int[permutationTableSize];
      for (int i = 0; i < _permutations.Length; i++)
        _permutations[i] = i;
      for (int i = _permutations.Length - 1; i > 0; i--)
        MathHelper.Swap(ref _permutations[i], ref _permutations[random.NextInteger(0, i)]);

      // Create table with gradient magnitudes.
      _magnitudes = new float[permutationTableSize];
      float s = 1; // First magnitude.
      for (int i = 0; i < _magnitudes.Length; i++)
      {
        _magnitudes[i] = s;
        s /= mu;
      }
    }
Exemplo n.º 4
0
 public void NoiseRange2D()
 {
     double min = double.MaxValue;
       double max = double.MinValue;
       var random = new Random(15485863);
       for (int i = 0; i < 10000000; i++)
       {
     var v = random.NextVector2F(0, 255);
     var n = PerlinNoise.Compute(v.X, v.Y);
     min = Math.Min(min, n);
     max = Math.Max(max, n);
       }
       Assert.IsTrue(min < 0 && min >= -1);
       Assert.IsTrue(max > 0 && max <= 1);
 }
        public void Transform2D()
        {
            // Transform forward and inverse and compare with initial values.
              var random = new Random(1234567);

              var s = new Vector2F[16, 8];
              var t = new Vector2F[16, 8];
              for (int i = 0; i < s.GetLength(0); i++)
              {
            for (int j = 0; j < s.GetLength(1); j++)
            {
              s[i, j] = random.NextVector2F(-10, 10);
              t[i, j] = s[i, j];
            }
              }

              var fft = new FastFourierTransformF(16);
              fft.Transform2D(t, true);

              Assert.IsFalse(Vector2F.AreNumericallyEqual(s[0, 0], t[0, 0]));

              fft.Transform2D(t, false);

              for (int i = 0; i < s.GetLength(0); i++)
            for (int j = 0; j < s.GetLength(1); j++)
              Assert.IsTrue(Vector2F.AreNumericallyEqual(s[i, j], t[i, j]));
        }