Added new scatter plot

tests/cli_test.py

@@ -54,7 +54,7 @@ def test_smoke_full(self):
         # everything without it exploding?
         backup_argv = sys.argv
         sys.argv = ["python", "--width", "16", "--height", "16",
-                    "-r", "-v", "--gs", "--temps",
+                    "-r", "-v", "--gs", "--scatter", "--temps",
                     ".126/.235/.406/.561/.634/.876", "--humidity",
                     ".059/.222/.493/.764/.927/.986/.998"]
         try:

tests/draw_test.py

@@ -2,7 +2,7 @@
 import os
 from worldengine.draw import _biome_colors, Image, draw_simple_elevation, elevation_color, \
     draw_elevation, draw_riversmap, draw_grayscale_heightmap, draw_ocean, draw_precipitation, \
-    draw_world, draw_temperature_levels, draw_biome
+    draw_world, draw_temperature_levels, draw_biome, draw_scatter_plot
 from worldengine.biome import Biome
 from worldengine.world import World
 
@@ -162,5 +162,10 @@ def test_draw_biome(self):
         draw_biome(w, target)
         self._assert_img_equal("biome_28070", target)
 
+    def test_draw_scatter_plot(self):
+        w = World.open_protobuf("%s/seed_28070.world" % self.tests_data_dir)
+        target = PixelCollector(16, 16)
+        draw_scatter_plot(w, 16, target)
+
 if __name__ == '__main__':
     unittest.main()

worldengine/cli/main.py

@@ -7,7 +7,7 @@
 from worldengine.common import array_to_matrix, set_verbose, print_verbose
 from worldengine.draw import draw_ancientmap_on_file, draw_biome_on_file, draw_ocean_on_file, \
     draw_precipitation_on_file, draw_grayscale_heightmap_on_file, draw_simple_elevation_on_file, \
-    draw_temperature_levels_on_file, draw_riversmap_on_file
+    draw_temperature_levels_on_file, draw_riversmap_on_file, draw_scatter_plot_on_file
 from worldengine.plates import world_gen, generate_plates_simulation
 from worldengine.imex import export
 from worldengine.step import Step
@@ -78,6 +78,10 @@ def generate_rivers_map(world, filename):
     draw_riversmap_on_file(world, filename)
     print("+ rivers map generated in '%s'" % filename)
 
+def draw_scatter_plot(world, filename):
+    draw_scatter_plot_on_file(world, filename)
+    print("+ scatter plot generated in '%s'" % filename)
+
 
 def generate_plates(seed, world_name, output_dir, width, height,
                     num_plates=10):
@@ -312,6 +316,8 @@ def main():
     g_generate.add_argument('--not-fade-borders', dest='fade_borders', action="store_false",
                                help="Not fade borders",
                                default=True)
+    g_generate.add_argument('--scatter', dest='scatter_plot',
+                            action="store_true", help="generate scatter plot")
 
     # -----------------------------------------------------
     g_ancient_map = parser.add_argument_group(
@@ -452,6 +458,8 @@ def main():
         humids = args.humids.split('/')
         for x in range(0,7):
             humids[x] = 1 - float(humids[x])
+    if args.scatter_plot and not generation_operation:
+        usage(error="Scatter plot can be produced only during world generation")
 
     print('Worldengine - a world generator (v. %s)' % VERSION)
     print('-----------------------')
@@ -467,6 +475,7 @@ def main():
         print(' step                 : %s' % step.name)
         print(' greyscale heightmap  : %s' % args.grayscale_heightmap)
         print(' rivers map           : %s' % args.rivers_map)
+        print(' scatter plot         : %s' % args.scatter_plot)
         print(' fade borders         : %s' % args.fade_borders)
     if args.temps:
         print(' temperature ranges   : %s' % args.temps)
@@ -498,6 +507,9 @@ def main():
         if args.rivers_map:
             generate_rivers_map(world,
             '%s/%s_rivers.png' % (args.output_dir, world_name))
+        if args.scatter_plot:
+            draw_scatter_plot(world,
+            '%s/%s_scatter.png' % (args.output_dir, world_name))    
 
     elif operation == 'plates':
         print('')  # empty line

worldengine/draw.py

@@ -1,5 +1,6 @@
 from PIL import Image
 import numpy
+import numpy.ma as ma
 
 from worldengine.drawing_functions import draw_ancientmap, \
     draw_rivers_on_image, gradient
@@ -406,6 +407,110 @@ def draw_biome(world, target):
             v = biome[y, x]
             target.set_pixel(x, y, _biome_colors[v])
 
+def draw_scatter_plot(world, size, target):
+    """ This function can be used on a generic canvas (either an image to save
+        on disk or a canvas part of a GUI)
+    """
+
+    #Find min and max values of humidity and temperature on land so we can
+    #normalize temperature and humidity to the chart
+    humid = ma.masked_array(world.humidity['data'], mask=world.ocean)
+    temp = ma.masked_array(world.temperature['data'], mask=world.ocean)
+    min_humidity = humid.min()
+    max_humidity = humid.max()
+    min_temperature = temp.min()
+    max_temperature = temp.max()
+    temperature_delta = max_temperature - min_temperature
+    humidity_delta = max_humidity - min_humidity
+
+    #set all pixels white
+    for y in range(0, size):
+        for x in range(0, size):
+            target.set_pixel(x, y, (255, 255, 255, 255))
+
+    #fill in 'bad' boxes with grey
+    h_values = ['62', '50', '37', '25', '12']
+    t_values = [   0,    1,    2,   3,    5 ]
+    for loop in range(0,5):
+        h_min = (size - 1) * ((world.humidity['quantiles'][h_values[loop]] - min_humidity) / humidity_delta)
+        if loop != 4:
+            h_max = (size - 1) * ((world.humidity['quantiles'][h_values[loop + 1]] - min_humidity) / humidity_delta)
+        else:
+            h_max = size
+        v_max = (size - 1) * ((world.temperature['thresholds'][t_values[loop]][1] - min_temperature) / temperature_delta)
+        if h_min < 0:
+            h_min = 0
+        if h_max > size:
+            h_max = size
+        if v_max < 0:
+            v_max = 0
+        if v_max > (size - 1):
+            v_max = size - 1
+
+        if h_max > 0 and h_min < size and v_max > 0:
+            for y in range(int(h_min), int(h_max)):
+                for x in range(0, int(v_max)):
+                    target.set_pixel(x, (size - 1) - y, (128, 128, 128, 255))
+
+    #draw lines based on thresholds
+    for t in range(0, 6):
+        v = (size - 1) * ((world.temperature['thresholds'][t][1] - min_temperature) / temperature_delta)
+        if v > 0 and v < size:
+            for y in range(0, size):
+                target.set_pixel(int(v), (size - 1) - y, (0, 0, 0, 255))
+    ranges = ['87', '75', '62', '50', '37', '25', '12']
+    for p in ranges:
+        h = (size - 1) * ((world.humidity['quantiles'][p] - min_humidity) / humidity_delta)
+        if h > 0 and h < size:
+            for x in range(0, size):
+                target.set_pixel(x, (size - 1) - int(h), (0, 0, 0, 255))
+
+    #examine all cells in the map and if it is land get the temperature and
+    #humidity for the cell.
+    for y in range(world.height):
+        for x in range(world.width):
+            if world.is_land((x, y)):
+                t = world.temperature_at((x, y))
+                p = world.humidity['data'][y, x]
+
+    #get red and blue values depending on temperature and humidity                
+                if world.is_temperature_polar((x, y)):
+                    r = 0
+                elif world.is_temperature_alpine((x, y)):
+                    r = 42
+                elif world.is_temperature_boreal((x, y)):
+                    r = 85
+                elif world.is_temperature_cool((x, y)):
+                    r = 128
+                elif world.is_temperature_warm((x, y)):
+                    r = 170
+                elif world.is_temperature_subtropical((x, y)):
+                    r = 213
+                elif world.is_temperature_tropical((x, y)):
+                    r = 255
+                if world.is_humidity_superarid((x, y)):
+                    b = 32
+                elif world.is_humidity_perarid((x, y)):
+                    b = 64
+                elif world.is_humidity_arid((x, y)):
+                    b = 96
+                elif world.is_humidity_semiarid((x, y)):
+                    b = 128
+                elif world.is_humidity_subhumid((x, y)):
+                    b = 160
+                elif world.is_humidity_humid((x, y)):
+                    b = 192
+                elif world.is_humidity_perhumid((x, y)):
+                    b = 224
+                elif world.is_humidity_superhumid((x, y)):
+                    b = 255
+
+    #calculate x and y position based on normalized temperature and humidity
+                nx = (size - 1) * ((t - min_temperature) / temperature_delta)
+                ny = (size - 1) * ((p - min_humidity) / humidity_delta)
+
+                target.set_pixel(int(nx), (size - 1) - int(ny), (r, 128, b, 255))
+
 
 # -------------
 # Draw on files
@@ -477,3 +582,8 @@ def draw_ancientmap_on_file(world, filename, resize_factor=1,
                     draw_biome, draw_rivers, draw_mountains, draw_outer_land_border, 
                     verbose)
     img.complete()
+
+def draw_scatter_plot_on_file(world, filename):
+    img = ImagePixelSetter(512, 512, filename)
+    draw_scatter_plot(world, 512, img)
+    img.complete()

worldengine/generation.py

@@ -213,6 +213,7 @@ def generate_world(w, step):
                  '':                        sub_seeds[99]
     }
 
+    TemperatureSimulation().execute(w, seed_dict['TemperatureSimulation'])
     # Precipitation with thresholds
     PrecipitationSimulation().execute(w, seed_dict['PrecipitationSimulation'])
 
@@ -226,7 +227,6 @@ def generate_world(w, step):
 
     # FIXME: create setters
     IrrigationSimulation().execute(w, seed_dict['IrrigationSimulation'])  # seed not currently used
-    TemperatureSimulation().execute(w, seed_dict['TemperatureSimulation'])
     HumiditySimulation().execute(w, seed_dict['HumiditySimulation'])  # seed not currently used
 
 

worldengine/simulations/humidity.py

@@ -21,7 +21,7 @@ def _calculate(world):
         irrigationWeight = 3
         humidity['data'] = numpy.zeros((world.height, world.width), dtype=float)
 
-        humidity['data'] = (((world.precipitation['data'] * precipitationWeight - world.irrigation * irrigationWeight) + 1) * ((world.temperature['data'] * temperatureWeight + 1) / (temperatureWeight + 1)))
+        humidity['data'] = (world.precipitation['data'] * precipitationWeight - world.irrigation * irrigationWeight)/(precipitationWeight + irrigationWeight)
 
         # These were originally evenly spaced at 12.5% each but changing them
         # to a bell curve produced better results

worldengine/simulations/precipitation.py

@@ -15,7 +15,7 @@ def is_applicable(world):
     def execute(self, world, seed):
         if get_verbose():
             start_time = time.time()
-        pre_calculated = self._calculate(seed, world.width, world.height)
+        pre_calculated = self._calculate(seed, world)
         ths = [
             ('low', find_threshold_f(pre_calculated, 0.75, world.ocean)),
             ('med', find_threshold_f(pre_calculated, 0.3, world.ocean)),
@@ -29,31 +29,83 @@ def execute(self, world, seed):
                 % elapsed_time)
 
     @staticmethod
-    def _calculate(seed, width, height):
+    def _calculate(seed, world):
         """Precipitation is a value in [-1,1]"""
         rng = numpy.random.RandomState(seed)  # create our own random generator
         base = rng.randint(0, 4096)
 
+        curve_gamma = 1.25
+        curve_bonus = .2
+        height = world.height
+        width = world.width
         border = width / 4
         precipitations = numpy.zeros((height, width), dtype=float)
 
         octaves = 6
         freq = 64.0 * octaves
 
+        n_scale = 1024 / float(height) #This is a variable I am adding. It exists
+                                       #so that worlds sharing a common seed but
+                                       #different sizes will have similar patterns
+
         for y in range(height):#TODO: numpy
             y_scaled = float(y) / height
-            latitude_factor = 1.0 - (abs(y_scaled - 0.5) * 2)
             for x in range(width):
-                n = snoise2(x / freq, y / freq, octaves, base=base)
+                n = snoise2((x * n_scale) / freq, (y * n_scale) / freq, octaves, base=base)
 
                 # Added to allow noise pattern to wrap around right and left.
                 if x < border:
-                    n = (snoise2(x / freq, y / freq, octaves,
+                    n = (snoise2( (x * n_scale) / freq, (y * n_scale) / freq, octaves,
                                  base=base) * x / border) + (
-                        snoise2((x + width) / freq, y / freq, octaves,
+                        snoise2(( (x * n_scale) + width) / freq, (y * n_scale) / freq, octaves,
                                 base=base) * (border - x) / border)
 
-                precipitation = (latitude_factor + n * 4) / 5.0
-                precipitations[y, x] = precipitation
+                precipitations[y, x] = n
+
+        #find ranges
+        min_precip = precipitations.min()
+        max_precip = precipitations.max()
+        min_temp = world.temperature['data'].min()
+        max_temp = world.temperature['data'].max()
+        precip_delta = (max_precip - min_precip)
+        temp_delta = (max_temp - min_temp)
+
+        #normalize temperature and precipitation arrays
+        t = (world.temperature['data'] - min_temp) / temp_delta
+        p = (precipitations - min_precip) / precip_delta
+
+        #modify precipitation based on temperature
+
+        #--------------------------------------------------------------------------------
+        #
+        # Ok, some explanation here because why the formula is doing this may be a
+        # little confusing. We are going to generate a modified gamma curve based on 
+        # normalized temperature and multiply our precipitation amounts by it.
+        #
+        # numpy.power(t,curve_gamma) generates a standard gamma curve. However
+        # we probably don't want to be multiplying precipitation by 0 at the far
+        # side of the curve. To avoid this we multiply the curve by (1 - curve_bonus)
+        # and then add back curve_bonus. Thus, if we have a curve bonus of .2 then
+        # the range of our modified gamma curve goes from 0-1 to 0-.8 after we
+        # multiply and then to .2-1 after we add back the curve_bonus.
+        #
+        # Because we renormalize there is not much point to offsetting the opposite end
+        # of the curve so it is less than or more than 1. We are trying to avoid
+        # setting the start of the curve to 0 because f(t) * p would equal 0 when t equals
+        # 0. However f(t) * p does not automatically equal 1 when t equals 1 and if we
+        # raise or lower the value for f(t) at 1 it would have negligible impact after
+        # renormalizing.
+        #
+        #--------------------------------------------------------------------------------
+
+        curve = (numpy.power(t, curve_gamma) * (1-curve_bonus)) + curve_bonus
+        precipitations = numpy.multiply(p, curve)
 
+        #Renormalize precipitation because the precipitation 
+        #changes will probably not fully extend from -1 to 1.
+        min_precip = precipitations.min()
+        max_precip = precipitations.max()
+        precip_delta = (max_precip - min_precip)
+        precipitations = (((precipitations - min_precip) / precip_delta) * 2) - 1
+
         return precipitations

worldengine/simulations/temperature.py

@@ -39,18 +39,19 @@ def _calculate(world, seed, elevation, mountain_level):
         border = width / 4
         octaves = 8
         freq = 16.0 * octaves
+        n_scale = 1024 / float(height)
 
         for y in range(0, height):#TODO: Check for possible numpy optimizations.
             y_scaled = float(y) / height
             latitude_factor = 1.0 - (abs(y_scaled - 0.5) * 2)
             for x in range(0, width):
-                n = snoise2(x / freq, y / freq, octaves, base=base)
+                n = snoise2((x * n_scale) / freq, (y * n_scale) / freq, octaves, base=base)
 
                 # Added to allow noise pattern to wrap around right and left.
                 if x <= border:
-                    n = (snoise2(x / freq, y / freq, octaves,
+                    n = (snoise2((x * n_scale) / freq, (y * n_scale)/ freq, octaves,
                                  base=base) * x / border) \
-                        + (snoise2((x + width) / freq, y / freq, octaves,
+                        + (snoise2(((x * n_scale) + width) / freq, (y * n_scale) / freq, octaves,
                                    base=base) * (border - x) / border)
 
                 t = (latitude_factor * 12 + n * 1) / 13.0