Improved renderer to produce even more realistic results.

layergen.py

@@ -66,6 +66,10 @@ class mstr_layergen:
     def set_latlng_folder(self, latlngfld):
         self._latlngfld = latlngfld
 
+    # Set the resource to use
+    def set_resource(self, res):
+        self._resource = res
+
     # Tile info object
     def open_tile_info(self):
         self._tileinfo = mstr_tileinfo(self._latitude, self._longitude, self._lat_number, self._lng_number, self._latlngfld)
@@ -259,6 +263,36 @@ class mstr_layergen:
         return tree
 
 
+    def _alphaBorderPixels(self):
+        pix = []
+        r1 = []
+        r2 = []
+        r3 = []
+
+        for p in range(0, self._imgsize):
+            r1.append((p, 0))
+            r1.append((self._imgsize-1, p))
+            r1.append((p, self._imgsize-1))
+            r1.append((0, p))
+
+        for p in range(1, self._imgsize-1):
+            r2.append((p, 1))
+            r2.append((self._imgsize-1, p))
+            r2.append((p, self._imgsize-1))
+            r2.append((1, p))
+
+        for p in range(2, self._imgsize-2):
+            r3.append((p, 2))
+            r3.append((self._imgsize-2, p))
+            r3.append((p, self._imgsize-2))
+            r3.append((2, p))
+
+        pix.append(r1)
+        pix.append(r2)
+        pix.append(r3)
+        return pix
+
+
     # This generates the layer from the defined mask
     def genlayer(self, mask, xml):
 
@@ -376,11 +410,12 @@ class mstr_layergen:
             if self._zoomlevel == 18: samples = 250
             if self._zoomlevel == 16: samples = 2000
 
-            txts = glob.glob(mstr_datafolder + "textures/" + self._tag + "/" + self._value + "/*.png")
+            #txts = glob.glob(mstr_datafolder + "textures/" + self._tag + "/" + self._value + "/*.png")
-            ptc_name = txts[randrange(0, len(txts))]
+            #ptc_name = txts[randrange(0, len(txts))]
-            while "brd" in ptc_name:
+            #while "brd" in ptc_name:
-                ptc_name = txts[randrange(0, len(txts))]
+            #    ptc_name = txts[randrange(0, len(txts))]
-            ptc_src = Image.open(ptc_name)
+            #ptc_src = Image.open(ptc_name)
+            ptc_src = Image.open(mstr_datafolder + "textures/" + self._tag + "/" + self._value + "/" + str(self._resource) + ".png")
             if self._zoomlevel == 16: ptc_src = ptc_src.resize((250,250), resample=Image.Resampling.BILINEAR)
             clrz = mstr_colorizer(ptc_src)
 
@@ -391,49 +426,28 @@ class mstr_layergen:
                 yp = randrange(-125, 1924)
 
                 ptc = clrz._grs.rotate(randrange(0, 360), expand=True)
-                if self._value == "golf_course":
-                    ptc = clrz._baseimg.rotate(randrange(0, 360), expand=True)
                 tmp_layer.alpha_composite(ptc, (xp,yp))
 
-            # Add the seamless border
+            if (self._tag == "landuse" and self._value == "forest") or (self._tag == "leisure" and self._value == "nature_reserve") or (self._tag == "landuse" and self._value == "farmland") or (self._tag == "landuse" and self._value == "farmyard"):
-            brd = Image.open(mstr_datafolder + "textures/" + self._tag + "/" + self._value + "/brd.png")
+                #tmp_layer = ImageEnhance.Contrast(tmp_layer).enhance(0.5)
-            brd_clrz = mstr_colorizer(brd)
+                enhancer = ImageEnhance.Brightness(tmp_layer)
-            if self._value != "golf_course":
+                tmp_layer = enhancer.enhance(4)
-                tmp_layer.alpha_composite(brd_clrz._baseimg)
+                tmp_layer = ImageEnhance.Contrast(tmp_layer).enhance(0.8)
-            else:
-                tmp_layer.alpha_composite(brd_clrz._grs)
                 
-            if self._value != "golf_course":
+            tmp_pix = tmp_layer.load()
-                tmp_layer.putalpha(51)
+            for y in range(0, self._imgsize):
+                for x in range(0, self._imgsize):
+                    tp = tmp_pix[x,y]
+                    c = (tp[0], tp[1], tp[2], 255-tp[0])
+                    if (self._tag == "landuse" and self._value == "forest") or (self._tag == "leisure" and self._value == "nature_reserve") or (self._tag == "landuse" and self._value == "farmland") or (self._tag == "landuse" and self._value == "farmyard"):
+                        c = (0,0,0, 255-tp[0])
+                    tmp_pix[x,y] = c
+
+            #if self._value != "golf_course":
+                #tmp_layer.putalpha(51)
             
             layer.alpha_composite(tmp_layer)
 
-            # Let's make some noise to give forests some better look
-            if (self._tag == "landuse" and self._value == "forest") or (self._tag == "leisure" and self._value == "nature_reserve"):
-                frst_noise = Image.new("RGBA", (self._imgsize, self._imgsize))
-                frst_pix = frst_noise.load()
-                for n in range(0, 1500000):
-                    nx = randrange(0, self._imgsize)
-                    ny = randrange(0, self._imgsize)
-                    na = randrange(65, 241)
-                    nc = (0,0,0,na)
-                    frst_pix[nx,ny] = nc
-                frst_noise = frst_noise.filter(ImageFilter.GaussianBlur(radius=1))
-                layer.alpha_composite(frst_noise)
-            
-            # Same for farmlands... but not as intensive
-            if (self._tag == "landuse" and self._value == "farmland") or (self._tag == "landuse" and self._value == "farmyard"):
-                frst_noise = Image.new("RGBA", (self._imgsize, self._imgsize))
-                frst_pix = frst_noise.load()
-                for n in range(0, 1500000):
-                    nx = randrange(0, self._imgsize)
-                    ny = randrange(0, self._imgsize)
-                    na = randrange(25, 65)
-                    nc = (0,0,0,na)
-                    frst_pix[nx,ny] = nc
-                frst_noise = frst_noise.filter(ImageFilter.GaussianBlur(radius=1))
-                layer.alpha_composite(frst_noise)
-
             mstr_msg("layergen", "Layer image generated")
             
             #---------------------------------------------

orthographic.py

@@ -41,6 +41,8 @@ class mstr_orthographic:
         self._latlngfld = self.latlng_folder([lat,lng])
         self._prep = prep
         self._tiles_visited = []
+        self._tile_resources = []
+        self._findTileResources()
         mstr_msg("orthographic", "Initiated with LAT: " + str(lat) + ", LNG: " + str(lng))
 
 
@@ -66,6 +68,13 @@ class mstr_orthographic:
         return a
     
 
+    # Find tile resources
+    def _findTileResources(self):
+        for l in mstr_ortho_layers:
+            rs = [ l[0], l[1], randrange(1, 16) ]
+            self._tile_resources.append(rs)
+
+
     # This will determine the vertical stepping in degrees in order to generate
     # masks with a 1:1 square ratio. This is important as X-Plane textures for
     # orthos can only be a power of 2, such as 2048x2048
@@ -85,6 +94,10 @@ class mstr_orthographic:
         return round(dm * 1000, 3)
     
 
+    # Define a contour resource to use for this tile
+
+
+
     # In this case we only want to acquire PBF for a latitude and longitude. Normally
     # not needed for standard ortho generation.
     def _generateData(self):
@@ -356,6 +369,15 @@ class mstr_orthographic:
                     lg.set_max_latlng_tile(maxlatlng)
                     lg.set_latlng_folder(self._latlngfld)
                     lg.set_zoomlevel(self._zoomlevelfactor)
+
+                    # Find resource to use
+                    rs = -1
+                    for r in self._tile_resources:
+                        if r[0] == layer[0] and r[1] == layer[1]:
+                            rs = r[2]
+                            break
+                    lg.set_resource(rs)
+
                     #lg.open_tile_info()
                     lyr = lg.genlayer(mask, osmxml)
                     photolayers.append(lyr)