0 people like it.
Like the snippet!

failed perlin noise attempt

 1: 
 2: 
 3: 
 4: 
 5: 
 6: 
 7: 
 8: 
 9: 
10: 
11: 
12: 
13: 
14: 
15: 
16: 
17: 
18: 
19: 
20: 
21: 
22: 
23: 
24: 
25: 
26: 
27: 
28: 
29: 
30: 
31: 
32: 
33: 
34: 
35: 
36: 
37: 
38: 
39: 
40: 
41: 
42: 
43: 
44: 
45: 
46: 
47: 
48: 
49: 
50: 
51: 
52:

module PerlinNoise
open System
open System.Drawing

let perlinNoise width height persistence octaves zoom seed handler =
    let noise x y =
        let n = x + y * 57;
        let n = (n <<< 13) ^^^ n;
        let t = (n * (n * n * 15731 + 789221) + 1376312589) &&& 0x7fffffff;
        1.0 - (double t) * 0.931322574615478515625e-9
    let interpolate x y a =
        let amount = (a * a) * (3.0 - 2.0 * a)
        x + ((y - x) * a)
    let smoothedNoise x y =
        let xi = int x
        let yi = int y
        let corners = ((noise (xi - 1) (yi - 1)) + (noise (xi + 1) (yi - 1)) + (noise (xi - 1) (yi + 1)) + (noise (xi + 1) (yi + 1))) / 16.0
        let sides = ((noise (xi - 1) yi) + (noise (xi + 1) yi) + (noise xi (yi - 1)) + (noise xi (yi + 1))) / 8.0
        let center = (noise xi yi) / 4.0
        corners + sides + center
    let interpolatedNoise x y =
        let xi = int x
        let yi = int y
        let xf = x - (float xi)
        let yf = y - (float yi)
        let v1 = smoothedNoise xi yi
        let v2 = smoothedNoise (xi + 1) yi
        let v3 = smoothedNoise xi (yi + 1)
        let v4 = smoothedNoise (xi + 1) (yi + 1)
        let i1 = interpolate v1 v2 xf
        let i2 = interpolate v3 v4 xf
        interpolate i1 i2 yf
    let pixel x y =
        seq { 0.0 .. float (octaves - 1) }
        |> Seq.sumBy (fun octave -> let frequency = (1.0/16.0) ** octave
                                    let amplitude = persistence ** octave
                                    interpolatedNoise ((float x) * frequency / zoom) ((float y) * frequency / zoom) * amplitude)
    for x in 0 .. width - 1 do
        for y in 0 .. height - 1 do
            pixel x y |> handler x y

let generate () =
    let width = 2000
    let height = 2000
    let bitmap = new Bitmap(width, height)
    let prng = new Random()
    (fun x y v -> let c = (v + 0.5) * 255.0 |> int |> min 255 |> max 0
                  bitmap.SetPixel(x, y, Color.FromArgb(c, c, c)))
    |> perlinNoise width height 0.65 6 37.42 (prng.Next() / 4)
    bitmap.Save(@"c:\users\sthalik\desktop\perlin-noise.jpg")

generate ()

module PerlinNoise

namespace System

namespace System.Drawing

val perlinNoise : width:int -> height:int -> persistence:float -> octaves:int -> zoom:float -> seed:'a -> handler:(int32 -> int32 -> float -> unit) -> unit

Full name: PerlinNoise.perlinNoise

val width : int

val height : int

val persistence : float

val octaves : int

val zoom : float

val seed : 'a

val handler : (int32 -> int32 -> float -> unit)

val noise : (int -> int -> float)

val x : int

val y : int

val n : int

val t : int

Multiple items
val double : value:'T -> float (requires member op_Explicit)

Full name: Microsoft.FSharp.Core.ExtraTopLevelOperators.double

--------------------
type double = Double

Full name: Microsoft.FSharp.Core.double

val interpolate : (float -> float -> float -> float)

val x : float

val y : float

val a : float

val amount : float

val smoothedNoise : (int -> int -> float)

val xi : int

Multiple items
val int : value:'T -> int (requires member op_Explicit)

Full name: Microsoft.FSharp.Core.Operators.int

--------------------
type int = int32

Full name: Microsoft.FSharp.Core.int

--------------------
type int<'Measure> = int

Full name: Microsoft.FSharp.Core.int<_>

val yi : int

val corners : float

val sides : float

val center : float

val interpolatedNoise : (float -> float -> float)

val xf : float

Multiple items
val float : value:'T -> float (requires member op_Explicit)

Full name: Microsoft.FSharp.Core.Operators.float

--------------------
type float = Double

Full name: Microsoft.FSharp.Core.float

--------------------
type float<'Measure> = float

Full name: Microsoft.FSharp.Core.float<_>

val yf : float

val v1 : float

val v2 : float

val v3 : float

val v4 : float

val i1 : float

val i2 : float

val pixel : (int32 -> int32 -> float)

val x : int32

val y : int32

Multiple items
val seq : sequence:seq<'T> -> seq<'T>

Full name: Microsoft.FSharp.Core.Operators.seq

--------------------
type seq<'T> = Collections.Generic.IEnumerable<'T>

Full name: Microsoft.FSharp.Collections.seq<_>

module Seq

from Microsoft.FSharp.Collections

val sumBy : projection:('T -> 'U) -> source:seq<'T> -> 'U (requires member ( + ) and member get_Zero)

Full name: Microsoft.FSharp.Collections.Seq.sumBy

val octave : float

val frequency : float

val amplitude : float

val generate : unit -> unit

Full name: PerlinNoise.generate

val bitmap : Bitmap

Multiple items
type Bitmap =
  inherit Image
  new : filename:string -> Bitmap + 11 overloads
  member Clone : rect:Rectangle * format:PixelFormat -> Bitmap + 1 overload
  member GetHbitmap : unit -> nativeint + 1 overload
  member GetHicon : unit -> nativeint
  member GetPixel : x:int * y:int -> Color
  member LockBits : rect:Rectangle * flags:ImageLockMode * format:PixelFormat -> BitmapData + 1 overload
  member MakeTransparent : unit -> unit + 1 overload
  member SetPixel : x:int * y:int * color:Color -> unit
  member SetResolution : xDpi:float32 * yDpi:float32 -> unit
  member UnlockBits : bitmapdata:BitmapData -> unit
  ...

Full name: System.Drawing.Bitmap

--------------------
Bitmap(filename: string) : unit
   (+0 other overloads)
Bitmap(stream: IO.Stream) : unit
   (+0 other overloads)
Bitmap(original: Image) : unit
   (+0 other overloads)
Bitmap(filename: string, useIcm: bool) : unit
   (+0 other overloads)
Bitmap(type: Type, resource: string) : unit
   (+0 other overloads)
Bitmap(stream: IO.Stream, useIcm: bool) : unit
   (+0 other overloads)
Bitmap(width: int, height: int) : unit
   (+0 other overloads)
Bitmap(original: Image, newSize: Size) : unit
   (+0 other overloads)
Bitmap(width: int, height: int, format: Imaging.PixelFormat) : unit
   (+0 other overloads)
Bitmap(width: int, height: int, g: Graphics) : unit
   (+0 other overloads)

val prng : Random

Multiple items
type Random =
  new : unit -> Random + 1 overload
  member Next : unit -> int + 2 overloads
  member NextBytes : buffer:byte[] -> unit
  member NextDouble : unit -> float

Full name: System.Random

--------------------
Random() : unit
Random(Seed: int) : unit

val v : float

val c : int

val min : e1:'T -> e2:'T -> 'T (requires comparison)

Full name: Microsoft.FSharp.Core.Operators.min

val max : e1:'T -> e2:'T -> 'T (requires comparison)

Full name: Microsoft.FSharp.Core.Operators.max

Bitmap.SetPixel(x: int, y: int, color: Color) : unit

type Color =
  struct
    member A : byte
    member B : byte
    member Equals : obj:obj -> bool
    member G : byte
    member GetBrightness : unit -> float32
    member GetHashCode : unit -> int
    member GetHue : unit -> float32
    member GetSaturation : unit -> float32
    member IsEmpty : bool
    member IsKnownColor : bool
    ...
  end

Full name: System.Drawing.Color

Color.FromArgb(argb: int) : Color
Color.FromArgb(alpha: int, baseColor: Color) : Color
Color.FromArgb(red: int, green: int, blue: int) : Color
Color.FromArgb(alpha: int, red: int, green: int, blue: int) : Color

Random.Next() : int
Random.Next(maxValue: int) : int
Random.Next(minValue: int, maxValue: int) : int

Image.Save(filename: string) : unit
Image.Save(stream: IO.Stream, format: Imaging.ImageFormat) : unit
Image.Save(filename: string, format: Imaging.ImageFormat) : unit
Image.Save(stream: IO.Stream, encoder: Imaging.ImageCodecInfo, encoderParams: Imaging.EncoderParameters) : unit
Image.Save(filename: string, encoder: Imaging.ImageCodecInfo, encoderParams: Imaging.EncoderParameters) : unit

Raw view Test code New version

More information

Link:	http://fssnip.net/9f
Posted:	14 years ago
Author:
Tags: