ant landscape: code cleanup, fix for marble noise thanks @jimmyhazevoet

1 files changed, 303 insertions, 279 deletions

diff --git a/add_mesh_ant_landscape.py b/add_mesh_ant_landscape.py
index bd528b97..528c551a 100644
--- a/add_mesh_ant_landscape.py
+++ b/add_mesh_ant_landscape.py
@@ -26,8 +26,10 @@ bl_info = {
     "warning": "", # used for warning icon and text in addons panel
     "wiki_url": "http://wiki.blender.org/index.php/Extensions:2.6/Py/"
                 "Scripts/Add_Mesh/ANT_Landscape",
+    "tracker_url": "https://developer.blender.org/maniphest/task/create/?project=3&type=Bug",
     "category": "Add Mesh",
-    }
+}
+
 
 """
 Another Noise Tool: Landscape mesh generator
@@ -94,71 +96,79 @@ def create_mesh_object(context, verts, edges, faces, name):
     from bpy_extras import object_utils
     return object_utils.object_data_add(context, mesh, operator=None)
 
-###------------------------------------------------------------
-###------------------------------------------------------------
+
+# ------------------------------------------------------------
 # some functions for marble_noise
 def sin_bias(a):
     return 0.5 + 0.5 * sin(a)
 
+
 def tri_bias(a):
     b = 2 * pi
-    a = 1 - 2 * abs(floor((a * (1/b))+0.5) - (a*(1/b)))
+    a = 1 - 2 * abs(floor((a * (1 / b)) + 0.5) - (a * (1 / b)))
     return a
 
+
 def saw_bias(a):
     b = 2 * pi
-    n = int(a/b)
+    n = int(a / b)
     a -= n * b
     if a < 0: a += b
     return a / b
 
+
 def soft(a):
     return a
 
+
 def sharp(a):
     return a**0.5
 
+
 def sharper(a):
     return sharp(sharp(a))
 
-def shapes(x,y,shape=0):
+
+def shapes(x, y, shape=0):
     if shape == 1:
         # ring
         x = x*2
         y = y*2
-        s = (-cos(x**2+y**2)/(x**2+y**2+0.5))
+        s = (-cos(x**2 + y**2) / (x**2 + y**2 + 0.5))
     elif shape == 2:
         # swirl
-        x = x*2
-        y = y*2
-        s = ((x*sin( x*x+y*y) + y*cos(x*x+y*y)) / (x**2+y**2+0.5))
+        x = x * 2
+        y = y * 2
+        s = ((x * sin(x * x + y * y) + y * cos(x * x + y * y)) / (x**2 + y**2 + 0.5))
     elif shape == 3:
         # bumps
-        x = x*2
-        y = y*2
-        s = ((cos( x*pi) + cos(y*pi))-0.5)
+        x = x * 2
+        y = y * 2
+        s = ((cos(x * pi) + cos(y * pi)) - 0.5)
     elif shape == 4:
         # y grad.
-        s = (y*pi)
+        s = (y * pi)
     elif shape == 5:
         # x grad.
-        s = (x*pi)
+        s = (x * pi)
     else:
-        # marble
-        s = ((x+y)*5)
+        # marble default
+        s = ((x + y) * 5)
+
     return s
 
+
 # marble_noise
-def marble_noise(x,y,z, origin, size, shape, bias, sharpnes, turb, depth, hard, basis):
+def marble_noise(x, y, z, origin, size, shape, bias, sharpnes, turb, depth, hard, basis):
     x = x / size
     y = y / size
     z = z / size
-    s = shapes(x,y,shape)
+    s = shapes(x, y, shape)
 
     x += origin[0]
     y += origin[1]
     z += origin[2]
-    value = s + turb * turbulence_vector((x,y,z), depth, hard, basis)[0]
+    value = s + turb * turbulence_vector((x, y, z), depth, hard, basis)[0]
 
     if bias == 1:
         value = tri_bias(value)
@@ -176,23 +186,26 @@ def marble_noise(x,y,z, origin, size, shape, bias, sharpnes, turb, depth, hard,
 
     return value
 
-###------------------------------------------------------------
+
+# ------------------------------------------------------------
 # custom noise types
 
 # shattered_hterrain:
-def shattered_hterrain(x,y,z, H, lacunarity, octaves, offset, distort, basis):
-    d = (turbulence_vector((x, y, z), 6, 0, 0)[0] * 0.5 + 0.5)*distort*0.5
-    t1 = (turbulence_vector((x+d, y+d, z), 0, 0, 7)[0] + 0.5)
-    t2 = (hetero_terrain((x*2, y*2, z*2), H, lacunarity, octaves, offset, basis)*0.5)
-    return ((t1*t2)+t2*0.5) * 0.5
+def shattered_hterrain(x, y, z, H, lacunarity, octaves, offset, distort, basis):
+    d = (turbulence_vector((x, y, z), 6, 0, 0)[0] * 0.5 + 0.5) * distort * 0.5
+    t1 = (turbulence_vector((x + d, y + d, z), 0, 0, 7)[0] + 0.5)
+    t2 = (hetero_terrain((x * 2, y * 2, z * 2), H, lacunarity, octaves, offset, basis) * 0.5)
+    return ((t1 * t2) + t2 * 0.5) * 0.5
+
 
 # strata_hterrain
-def strata_hterrain(x,y,z, H, lacunarity, octaves, offset, distort, basis):
-    value = hetero_terrain((x, y, z), H, lacunarity, octaves, offset, basis)*0.5
-    steps = (sin( value*(distort*5)*pi) * (0.1/(distort*5)*pi))
-    return (value * (1.0-0.5) + steps*0.5)
+def strata_hterrain(x, y, z, H, lacunarity, octaves, offset, distort, basis):
+    value = hetero_terrain((x, y, z), H, lacunarity, octaves, offset, basis) * 0.5
+    steps = (sin(value * (distort * 5) * pi) * (0.1 / (distort * 5) * pi))
+    return (value * (1.0 - 0.5) + steps * 0.5)
 
-# planet_noise by Farsthary: https://blenderartists.org/forum/showthread.php?202944-New-quot-Planet-quot-procedural-texture-by-Farsthary
+
+# planet_noise by Farsthary: https://farsthary.com/2010/11/24/new-planet-procedural-texture/
 def planet_noise(coords, oct=6, hard=0, noisebasis=1, nabla=0.001):
     x,y,z = coords
     d = 0.001
@@ -200,49 +213,50 @@ def planet_noise(coords, oct=6, hard=0, noisebasis=1, nabla=0.001):
     x = turbulence((x, y, z), oct, hard, noisebasis)
     y = turbulence((x + offset, y , z), oct, hard, noisebasis)
     z = turbulence((x, y + offset, z), oct, hard, noisebasis)
-    xdy = x - turbulence((x, y + d, z), oct, hard, noisebasis)
-    xdz = x - turbulence((x, y, z + d), oct, hard, noisebasis)
-    ydx = y - turbulence((x + d, y, z), oct, hard, noisebasis)
-    ydz = y - turbulence((x, y, z + d), oct, hard, noisebasis)
-    zdx = z - turbulence((x + d, y, z), oct, hard, noisebasis)
-    zdy = z - turbulence((x, y + d, z), oct, hard, noisebasis)
+    xdy = x-turbulence((x, y + d, z), oct, hard, noisebasis)
+    xdz = x-turbulence((x, y, z + d), oct, hard, noisebasis)
+    ydx = y-turbulence((x + d, y, z), oct, hard, noisebasis)
+    ydz = y-turbulence((x, y, z + d), oct, hard, noisebasis)
+    zdx = z-turbulence((x + d, y, z), oct, hard, noisebasis)
+    zdy = z-turbulence((x, y + d, z), oct, hard, noisebasis)
     return (zdy - ydz), (zdx - xdz), (ydx - xdy)
 
-###------------------------------------------------------------
+
+# ------------------------------------------------------------
 # landscape_gen
-def landscape_gen(x,y,z,falloffsize,options=[0,1.0,'multi_fractal', 0,0,1.0,0,6,1.0,2.0,1.0,2.0,0,0,0, 1.0,0.0,1,0.0,1.0,0,0,0,0.0,0.0]):
-
-    # options
-    rseed    = options[0]
-    nsize    = options[1]
-    ntype      = options[2]
-    nbasis     = int(options[3][0])
-    vlbasis    = int(options[4][0])
+def landscape_gen(x, y, z, falloffsize, options):
+
+    # options = [0, 1.0, 'multi_fractal', 0, 0, 1.0, 0, 6, 1.0, 2.0, 1.0, 2.0, 0, 0, 0, 1.0, 0.0, 1, 0.0, 1.0, 0, 0, 0, 0.0, 0.0]
+    rseed = options[0]
+    nsize = options[1]
+    ntype = options[2]
+    nbasis = int(options[3][0])
+    vlbasis = int(options[4][0])
     distortion = options[5]
-    hardnoise  = options[6]
-    depth      = options[7]
-    dimension  = options[8]
+    hardnoise = options[6]
+    depth = options[7]
+    dimension = options[8]
     lacunarity = options[9]
-    offset     = options[10]
-    gain       = options[11]
-    marblebias     = int(options[12][0])
+    offset = options[10]
+    gain = options[11]
+    marblebias = int(options[12][0])
     marblesharpnes = int(options[13][0])
-    marbleshape    = int(options[14][0])
-    invert       = options[15]
-    height       = options[16]
+    marbleshape = int(options[14][0])
+    invert = options[15]
+    height = options[16]
     heightoffset = options[17]
-    falloff      = int(options[18][0])
-    sealevel     = options[19]
-    platlevel    = options[20]
-    strata       = options[21]
-    stratatype   = options[22]
-    sphere       = options[23]
-    x_offset     = options[24]
-    y_offset     = options[25]
+    falloff = int(options[18][0])
+    sealevel = options[19]
+    platlevel = options[20]
+    strata = options[21]
+    stratatype = options[22]
+    sphere = options[23]
+    x_offset = options[24]
+    y_offset = options[25]
 
     # origin    
     if rseed == 0:
-        origin = 0.0,0.0,0.0
+        origin = 0.0 + x_offset, 0.0 + y_offset, 0.0
         origin_x = x_offset
         origin_y = y_offset
         origin_z = 0.0
@@ -250,6 +264,8 @@ def landscape_gen(x,y,z,falloffsize,options=[0,1.0,'multi_fractal', 0,0,1.0,0,6,
         # randomise origin
         seed_set(rseed)
         origin = random_unit_vector()
+        origin[0] += x_offset
+        origin[1] += y_offset
         origin_x = ((0.5 - origin[0]) * 1000.0) + x_offset
         origin_y = ((0.5 - origin[1]) * 1000.0) + y_offset
         origin_z = (0.5 - origin[2]) * 1000.0
@@ -286,7 +302,7 @@ def landscape_gen(x,y,z,falloffsize,options=[0,1.0,'multi_fractal', 0,0,1.0,0,6,
         value = variable_lacunarity(ncoords, distortion, nbasis, vlbasis) + 0.5
 
     elif ntype == 'marble_noise':
-        value = marble_noise(ncoords[0]*2.0/falloffsize,ncoords[1]*2.0/falloffsize,ncoords[2]*2/falloffsize, origin, nsize, marbleshape, marblebias, marblesharpnes, distortion, depth, hardnoise, nbasis)
+        value = marble_noise(x * 2.0 / falloffsize, y * 2.0 / falloffsize, z * 2 / falloffsize, origin, nsize, marbleshape, marblebias, marblesharpnes, distortion, depth, hardnoise, nbasis)
 
     elif ntype == 'shattered_hterrain':
         value = shattered_hterrain(ncoords[0], ncoords[1], ncoords[2], dimension, lacunarity, depth, offset, distortion, nbasis)
@@ -295,13 +311,13 @@ def landscape_gen(x,y,z,falloffsize,options=[0,1.0,'multi_fractal', 0,0,1.0,0,6,
         value = strata_hterrain(ncoords[0], ncoords[1], ncoords[2], dimension, lacunarity, depth, offset, distortion, nbasis)
 
     elif ntype == 'planet_noise':
-        value = planet_noise(ncoords, depth, hardnoise, nbasis)[2]*0.5+0.5
+        value = planet_noise(ncoords, depth, hardnoise, nbasis)[2] * 0.5 + 0.5
     else:
         value = 0.0
 
     # adjust height
     if invert !=0:
-        value = (1-value) * height + heightoffset
+        value = (1 - value) * height + heightoffset
     else:
         value = value * height + heightoffset
 
@@ -309,16 +325,16 @@ def landscape_gen(x,y,z,falloffsize,options=[0,1.0,'multi_fractal', 0,0,1.0,0,6,
     if sphere == 0: # no edge falloff if spherical
         if falloff != 0:
             fallofftypes = [0, hypot(x * x, y * y), hypot(x, y), abs(y), abs(x)]
-            dist = fallofftypes[ falloff]
+            dist = fallofftypes[falloff]
             if falloff ==1:
-                radius = (falloffsize/2)**2
+                radius = (falloffsize / 2)**2
             else:
-                radius = falloffsize/2
+                radius = falloffsize / 2
 
             value = value - sealevel
             if(dist < radius):
                 dist = dist / radius
-                dist = (dist * dist * (3-2 * dist))
+                dist = (dist * dist * (3 - 2 * dist))
                 value = (value - value * dist) + sealevel
             else:
                 value = sealevel
@@ -329,16 +345,16 @@ def landscape_gen(x,y,z,falloffsize,options=[0,1.0,'multi_fractal', 0,0,1.0,0,6,
 
     if stratatype == '1':
         strata *= 2
-        steps = (sin( value*strata*pi) * (0.1/strata*pi))
-        value = (value * (1.0-0.5) + steps*0.5) * 2.0
+        steps = (sin(value * strata * pi) * (0.1 / strata * pi))
+        value = (value * (1.0 - 0.5) + steps * 0.5) * 2.0
 
     elif stratatype == '2':
-        steps = -abs( sin(value*(strata)*pi) * (0.1/(strata)*pi))
-        value =(value * (1.0-0.5) + steps*0.5) * 2.0
+        steps = -abs(sin(value * strata * pi) * (0.1 / strata * pi))
+        value =(value * (1.0 - 0.5) + steps * 0.5) * 2.0
 
     elif stratatype == '3':
-        steps = abs(sin(value*(strata)*pi) * (0.1/(strata)*pi))
-        value =(value * (1.0-0.5) + steps*0.5) * 2.0
+        steps = abs(sin(value * strata * pi) * (0.1 / strata * pi))
+        value =(value * (1.0 - 0.5) + steps * 0.5) * 2.0
  
     else:
         value = value
@@ -351,7 +367,8 @@ def landscape_gen(x,y,z,falloffsize,options=[0,1.0,'multi_fractal', 0,0,1.0,0,6,
 
     return value
 
-###------------------------------------------------------------
+
+# ------------------------------------------------------------
 # generate grid
 def grid_gen(sub_d, size_me, options):
     # mesh arrays
@@ -360,31 +377,32 @@ def grid_gen(sub_d, size_me, options):
 
     # fill verts array
     for i in range (0, sub_d):
-        for j in range(0,sub_d):
-            u = (i/(sub_d-1)-1/2)
-            v = (j/(sub_d-1)-1/2)
-            x = size_me*u
-            y = size_me*v
-            z = landscape_gen(x,y,0.0,size_me,options)
-            vert = (x,y,z)
+        for j in range(0, sub_d):
+            u = (i / (sub_d - 1) - 1 / 2)
+            v = (j / (sub_d - 1) - 1 / 2)
+            x = size_me * u
+            y = size_me * v
+            z = landscape_gen(x, y, 0.0, size_me, options)
+            vert = (x, y, z)
             verts.append(vert)
 
     # fill faces array
     count = 0
-    for i in range (0, sub_d *(sub_d-1)):
-        if count < sub_d-1:
-            A = i+1
+    for i in range (0, sub_d*(sub_d - 1)):
+        if count < sub_d - 1:
+            A = i + 1
             B = i
-            C = (i+sub_d)
-            D = (i+sub_d)+1
-            face = (A,B,C,D)
+            C = (i + sub_d)
+            D = (i + sub_d) + 1
+            face = (A, B, C, D)
             faces.append(face)
             count = count + 1
         else:
             count = 0
-            
+
     return verts, faces
 
+
 # generate sphere
 def sphere_gen(sub_d, size_me, options):
     # mesh arrays
@@ -393,32 +411,33 @@ def sphere_gen(sub_d, size_me, options):
 
     # fill verts array
     for i in range (0, sub_d):
-        for j in range(0,sub_d):
-            u = sin(j*pi*2/(sub_d-1)) * cos(-pi/2+i*pi/(sub_d-1)) * size_me/2
-            v = cos(j*pi*2/(sub_d-1)) * cos(-pi/2+i*pi/(sub_d-1)) * size_me/2
-            w = sin(-pi/2+i*pi/(sub_d-1)) * size_me/2
-            h = landscape_gen(u,v,w,size_me,options) / size_me
-            u,v,w = u+u*h, v+v*h, w+w*h
-            vert = (u,v,w)
+        for j in range(0, sub_d):
+            u = sin(j * pi * 2 / (sub_d - 1)) * cos(-pi / 2 + i * pi / (sub_d - 1)) * size_me / 2
+            v = cos(j * pi * 2 / (sub_d - 1)) * cos(-pi / 2 + i * pi / (sub_d - 1)) * size_me / 2
+            w = sin(-pi / 2 + i * pi / (sub_d - 1)) * size_me / 2
+            h = landscape_gen(u, v, w, size_me, options) / size_me
+            u,v,w = u + u * h, v + v * h, w + w * h
+            vert = (u, v, w)
             verts.append(vert)
 
     # fill faces array
     count = 0
-    for i in range (0, sub_d *(sub_d-1)):
-        if count < sub_d-1:
-            A = i+1
+    for i in range (0, sub_d * (sub_d - 1)):
+        if count < sub_d - 1:
+            A = i + 1
             B = i
-            C = (i+sub_d)
-            D = (i+sub_d)+1
-            face = (A,B,C,D)
+            C = (i + sub_d)
+            D = (i + sub_d) + 1
+            face = (A, B, C, D)
             faces.append(face)
             count = count + 1
         else:
             count = 0
-            
+
     return verts, faces
 
-###------------------------------------------------------------
+
+# ------------------------------------------------------------
 # Add landscape
 class landscape_add(bpy.types.Operator):
     """Add a landscape mesh"""
@@ -429,219 +448,220 @@ class landscape_add(bpy.types.Operator):
 
     # properties
     AutoUpdate = BoolProperty(name="Mesh update",
-                default=True,
-                description="Update mesh")
+                default = True,
+                description = "Update mesh")
 
     SphereMesh = BoolProperty(name="Sphere",
-                default=False,
-                description="Generate Sphere mesh")
+                default = False,
+                description = "Generate Sphere mesh")
 
     SmoothMesh = BoolProperty(name="Smooth",
-                default=True,
-                description="Shade smooth")
+                default = True,
+                description = "Shade smooth")
 
     Subdivision = IntProperty(name="Subdivisions",
-                min=4,
-                max=6400,
-                default=128,
-                description="Mesh x y subdivisions")
+                min = 4,
+                max = 6400,
+                default = 128,
+                description = "Mesh x y subdivisions")
 
     MeshSize = FloatProperty(name="Mesh Size",
-                min=0.01,
-                max=100000.0,
-                default=2.0,
-                description="Mesh size")
+                min = 0.01,
+                max = 100000.0,
+                default = 2.0,
+                description = "Mesh size")
 
     XOffset = FloatProperty(name="X Offset",
-                default=0.0,
-                description="X Offset")
+                default = 0.0,
+                description = "X Offset")
     
     YOffset = FloatProperty(name="Y Offset",
-                default=0.0,
-                description="Y Offset")
+                default = 0.0,
+                description = "Y Offset")
 
     RandomSeed = IntProperty(name="Random Seed",
-                min=0,
-                max=9999,
-                default=0,
-                description="Randomize noise origin")
+                min = 0,
+                max = 9999,
+                default = 0,
+                description = "Randomize noise origin")
 
     NoiseSize = FloatProperty(name="Noise Size",
-                min=0.01,
-                max=10000.0,
-                default=1.0,
-                description="Noise size")
+                min = 0.01,
+                max = 10000.0,
+                default = 1.0,
+                description = "Noise size")
 
     NoiseTypes = [
-                ('multi_fractal',"multiFractal","multiFractal"),
-                ('ridged_multi_fractal',"ridgedMFractal","ridgedMFractal"),
-                ('hybrid_multi_fractal',"hybridMFractal","hybridMFractal"),
-                ('hetero_terrain',"heteroTerrain","heteroTerrain"),
-                ('fractal',"fBm","fBm"),
-                ('turbulence_vector',"Turbulence","Turbulence"),
-                ('variable_lacunarity',"Distorted Noise","Distorted Noise"),
-                ('marble_noise',"Marble","Marble"),
-                ('shattered_hterrain',"Shattered_hTerrain","Shattered_hTerrain"),
-                ('strata_hterrain',"Strata_hTerrain","Strata_hTerrain"),
-                ('planet_noise',"Planet_Noise","Planet_Noise")]
+                ('multi_fractal', "multiFractal", "multiFractal"),
+                ('ridged_multi_fractal', "ridgedMFractal", "ridgedMFractal"),
+                ('hybrid_multi_fractal', "hybridMFractal", "hybridMFractal"),
+                ('hetero_terrain', "heteroTerrain", "heteroTerrain"),
+                ('fractal', "fBm", "fBm"),
+                ('turbulence_vector', "Turbulence", "Turbulence"),
+                ('variable_lacunarity', "Distorted Noise", "Distorted Noise"),
+                ('marble_noise', "Marble", "Marble"),
+                ('shattered_hterrain', "Shattered_hTerrain", "Shattered_hTerrain"),
+                ('strata_hterrain', "Strata_hTerrain", "Strata_hTerrain"),
+                ('planet_noise', "Planet_Noise", "Planet_Noise")]
 
     NoiseType = EnumProperty(name="Type",
-                description="Noise type",
-                items=NoiseTypes)
+                description = "Noise type",
+                items = NoiseTypes)
 
     BasisTypes = [
-                ("0","Blender","Blender"),
-                ("1","Perlin","Perlin"),
-                ("2","NewPerlin","NewPerlin"),
-                ("3","Voronoi_F1","Voronoi_F1"),
-                ("4","Voronoi_F2","Voronoi_F2"),
-                ("5","Voronoi_F3","Voronoi_F3"),
-                ("6","Voronoi_F4","Voronoi_F4"),
-                ("7","Voronoi_F2-F1","Voronoi_F2-F1"),
-                ("8","Voronoi Crackle","Voronoi Crackle"),
-                ("9","Cellnoise","Cellnoise")]
+                ("0", "Blender", "Blender"),
+                ("1", "Perlin", "Perlin"),
+                ("2", "NewPerlin", "NewPerlin"),
+                ("3", "Voronoi_F1", "Voronoi_F1"),
+                ("4", "Voronoi_F2", "Voronoi_F2"),
+                ("5", "Voronoi_F3", "Voronoi_F3"),
+                ("6", "Voronoi_F4", "Voronoi_F4"),
+                ("7", "Voronoi_F2-F1", "Voronoi_F2-F1"),
+                ("8", "Voronoi Crackle", "Voronoi Crackle"),
+                ("9", "Cellnoise", "Cellnoise")]
     BasisType = EnumProperty(name="Basis",
-                description="Noise basis",
-                items=BasisTypes)
+                description = "Noise basis",
+                items = BasisTypes)
 
     VLBasisTypes = [
-                ("0","Blender","Blender"),
-                ("1","Perlin","Perlin"),
-                ("2","NewPerlin","NewPerlin"),
-                ("3","Voronoi_F1","Voronoi_F1"),
-                ("4","Voronoi_F2","Voronoi_F2"),
-                ("5","Voronoi_F3","Voronoi_F3"),
-                ("6","Voronoi_F4","Voronoi_F4"),
-                ("7","Voronoi_F2-F1","Voronoi_F2-F1"),
-                ("8","Voronoi Crackle","Voronoi Crackle"),
-                ("9","Cellnoise","Cellnoise")]
+                ("0", "Blender", "Blender"),
+                ("1", "Perlin", "Perlin"),
+                ("2", "NewPerlin", "NewPerlin"),
+                ("3", "Voronoi_F1", "Voronoi_F1"),
+                ("4", "Voronoi_F2", "Voronoi_F2"),
+                ("5", "Voronoi_F3", "Voronoi_F3"),
+                ("6", "Voronoi_F4", "Voronoi_F4"),
+                ("7", "Voronoi_F2-F1", "Voronoi_F2-F1"),
+                ("8", "Voronoi Crackle", "Voronoi Crackle"),
+                ("9", "Cellnoise", "Cellnoise")]
     VLBasisType = EnumProperty(name="VLBasis",
-                description="VLNoise basis",
-                items=VLBasisTypes)
+                description = "VLNoise basis",
+                items = VLBasisTypes)
 
     Distortion = FloatProperty(name="Distortion",
-                min=0.01,
-                max=1000.0,
-                default=1.0,
-                description="Distortion amount")
+                min = 0.01,
+                max = 1000.0,
+                default = 1.0,
+                description = "Distortion amount")
 
     HardNoise = BoolProperty(name="Hard",
-                default=False,
-                description="Hard noise")
+                default = False,
+                description = "Hard noise")
 
     NoiseDepth = IntProperty(name="Depth",
-                min=1,
-                max=16,
-                default=8,
+                min = 1,
+                max = 16,
+                default = 8,
                 description="Noise Depth - number of frequencies in the fBm")
 
     mDimension = FloatProperty(name="Dimension",
-                min=0.01,
-                max=2.0,
-                default=1.0,
-                description="H - fractal dimension of the roughest areas")
+                min = 0.01,
+                max = 2.0,
+                default = 1.0,
+                description = "H - fractal dimension of the roughest areas")
 
     mLacunarity = FloatProperty(name="Lacunarity",
-                min=0.01,
-                max=6.0,
-                default=2.0,
-                description="Lacunarity - gap between successive frequencies")
+                min = 0.01,
+                max = 6.0,
+                default = 2.0,
+                description = "Lacunarity - gap between successive frequencies")
 
     mOffset = FloatProperty(name="Offset",
-                min=0.01,
-                max=6.0,
-                default=1.0,
-                description="Offset - raises the terrain from sea level")
+                min = 0.01,
+                max = 6.0,
+                default = 1.0,
+                description = "Offset - raises the terrain from sea level")
 
     mGain = FloatProperty(name="Gain",
-                min=0.01,
-                max=6.0,
-                default=1.0,
-                description="Gain - scale factor")
+                min = 0.01,
+                max = 6.0,
+                default = 1.0,
+                description = "Gain - scale factor")
 
     BiasTypes = [
-                ("0","Sin","Sin"),
-                ("1","Tri","Tri"),
-                ("2","Saw","Saw")]
+                ("0", "Sin", "Sin"),
+                ("1", "Tri", "Tri"),
+                ("2", "Saw", "Saw")]
     MarbleBias = EnumProperty(name="Bias",
-                description="Marble bias",
-                items=BiasTypes)
+                description = "Marble bias",
+                items = BiasTypes)
 
     SharpTypes = [
-                ("0","Soft","Soft"),
-                ("1","Sharp","Sharp"),
-                ("2","Sharper","Sharper")]
+                ("0", "Soft", "Soft"),
+                ("1", "Sharp", "Sharp"),
+                ("2", "Sharper", "Sharper")]
     MarbleSharp = EnumProperty(name="Sharp",
-                description="Marble sharp",
-                items=SharpTypes)
+                description = "Marble sharp",
+                items = SharpTypes)
 
     ShapeTypes = [
-                ("0","Default","Default"),
-                ("1","Ring","Ring"),
-                ("2","Swirl","Swirl"),
-                ("3","Bump","Bump"),
-                ("4","Y","Y"),
-                ("5","X","X")]
+                ("0", "Default", "Default"),
+                ("1", "Ring", "Ring"),
+                ("2", "Swirl", "Swirl"),
+                ("3", "Bump", "Bump"),
+                ("4", "Y", "Y"),
+                ("5", "X", "X")]
     MarbleShape = EnumProperty(name="Shape",
-                description="Marble shape",
-                items=ShapeTypes)
+                description = "Marble shape",
+                items = ShapeTypes)
 
     Invert = BoolProperty(name="Invert",
-                default=False,
-                description="Invert noise input")
+                default = False,
+                description = "Invert noise input")
 
     Height = FloatProperty(name="Height",
-                min=0.01,
-                max=10000.0,
-                default=0.5,
-                description="Height scale")
+                min = 0.01,
+                max = 10000.0,
+                default = 0.5,
+                description = "Height scale")
 
     Offset = FloatProperty(name="Offset",
-                min=-10000.0,
-                max=10000.0,
-                default=0.0,
-                description="Height offset")
+                min = -10000.0,
+                max = 10000.0,
+                default = 0.0,
+                description = "Height offset")
 
     fallTypes = [
-                ("0","None","None"),
-                ("1","Type 1","Type 1"),
-                ("2","Type 2","Type 2"),
-                ("3","Y","Y"),
-                ("4","X","X")]
+                ("0", "None", "None"),
+                ("1", "Type 1", "Type 1"),
+                ("2", "Type 2", "Type 2"),
+                ("3", "Y", "Y"),
+                ("4", "X", "X")]
     Falloff = EnumProperty(name="Falloff",
-                description="Edge falloff",
-                default="1",
-                items=fallTypes)
+                description = "Edge falloff",
+                default = "1",
+                items = fallTypes)
 
     Sealevel = FloatProperty(name="Sealevel",
-                min=-10000.0,
-                max=10000.0,
-                default=0.0,
-                description="Sealevel")
+                min = -10000.0,
+                max = 10000.0,
+                default = 0.0,
+                description = "Sealevel")
 
     Plateaulevel = FloatProperty(name="Plateau",
-                min=-10000.0,
-                max=10000.0,
-                default=1.0,
-                description="Plateau level")
+                min = -10000.0,
+                max = 10000.0,
+                default = 1.0,
+                description = "Plateau level")
 
     Strata = FloatProperty(name="Strata",
-                min=0.01,
-                max=1000.0,
-                default=5.0,
-                description="Strata amount")
+                min = 0.01,
+                max = 1000.0,
+                default = 5.0,
+                description = "Strata amount")
 
     StrataTypes = [
-                ("0","None","None"),
-                ("1","Type 1","Type 1"),
-                ("2","Type 2","Type 2"),
-                ("3","Type 3","Type 3")]
+                ("0", "None", "None"),
+                ("1", "Type 1", "Type 1"),
+                ("2", "Type 2", "Type 2"),
+                ("3", "Type 3", "Type 3")]
     StrataType = EnumProperty(name="Strata",
-                description="Strata type",
-                default="0",
-                items=StrataTypes)
+                description = "Strata type",
+                default = "0",
+                items = StrataTypes)
 
-    ###------------------------------------------------------------
+
+    # ------------------------------------------------------------
     # Draw
     def draw(self, context):
         layout = self.layout
@@ -728,7 +748,8 @@ class landscape_add(bpy.types.Operator):
         if self.StrataType != '0':
             box.prop(self, 'Strata')
 
-    ###------------------------------------------------------------
+
+    # ------------------------------------------------------------
     # Execute
     def execute(self, context):
 
@@ -745,32 +766,32 @@ class landscape_add(bpy.types.Operator):
 
             # options
             options = [
-                self.RandomSeed,    #0
-                self.NoiseSize,     #1
-                self.NoiseType,     #2
-                self.BasisType,     #3
-                self.VLBasisType,   #4
-                self.Distortion,    #5
-                self.HardNoise,     #6
-                self.NoiseDepth,    #7
-                self.mDimension,    #8
-                self.mLacunarity,   #9
-                self.mOffset,       #10
-                self.mGain,         #11
-                self.MarbleBias,    #12
-                self.MarbleSharp,   #13
-                self.MarbleShape,   #14
-                self.Invert,        #15
-                self.Height,        #16
-                self.Offset,        #17
-                self.Falloff,       #18
-                self.Sealevel,      #19
-                self.Plateaulevel,  #20
-                self.Strata,        #21
-                self.StrataType,    #22
-                self.SphereMesh,    #23
-                self.XOffset,       #24
-                self.YOffset        #25
+                self.RandomSeed,
+                self.NoiseSize,
+                self.NoiseType,
+                self.BasisType,
+                self.VLBasisType,
+                self.Distortion,
+                self.HardNoise,
+                self.NoiseDepth,
+                self.mDimension,
+                self.mLacunarity,
+                self.mOffset,
+                self.mGain,
+                self.MarbleBias,
+                self.MarbleSharp,
+                self.MarbleShape,
+                self.Invert,
+                self.Height,
+                self.Offset,
+                self.Falloff,
+                self.Sealevel,
+                self.Plateaulevel,
+                self.Strata,
+                self.StrataType,
+                self.SphereMesh,
+                self.XOffset,
+                self.YOffset
                 ]
 
             # Main function
@@ -805,22 +826,25 @@ class landscape_add(bpy.types.Operator):
             return {'PASS_THROUGH'}
 
 
-###------------------------------------------------------------
+# ------------------------------------------------------------
 # Register
 
     # Define "Landscape" menu
 def menu_func_landscape(self, context):
     self.layout.operator(landscape_add.bl_idname, text="Landscape", icon="RNDCURVE")
 
+
 def register():
     bpy.utils.register_module(__name__)
 
     bpy.types.INFO_MT_mesh_add.append(menu_func_landscape)
 
+
 def unregister():
     bpy.utils.unregister_module(__name__)
 
     bpy.types.INFO_MT_mesh_add.remove(menu_func_landscape)
 
+
 if __name__ == "__main__":
     register()