Merge pull request #5 from ChrisPHP/procedural-textures

Adds procedural brick texture and more wang tile border options.

Author: ChrisPHP

src/app.py

@@ -1,6 +1,5 @@
 from flask import Flask, render_template, request, send_file
-from werkzeug.utils import secure_filename
-from PIL import Image
+from PIL import Image, ImageColor
 from io import BytesIO
 import os
 import json
@@ -22,7 +21,6 @@
 
 pixel_gen = pixel_generator.PixelGenerator()
 proc_tex = procedural_textures.ProceduralTextures()
-wang_tile = wang_tile_generator.WangTilesGenerator()
 
 @app.route('/')
 def home():
@@ -39,7 +37,55 @@ def wang_borders():
     border_size = int(request.form['border_size'])
     border_style = request.form['border_style']
 
-    new_img = wang_tile.generate_wang_borders(width, height, border_size, border_style, avg_colour)
+    if border_style == 'brickborder':
+        brick_border_width = int(request.form['brick_border_width'])
+        brick_border_height = int(request.form['brick_border_height'])
+        mortar_border = int(request.form['mortar_border'])
+
+        wang_tile = wang_tile_generator.WangTilesGenerator(border_dict={
+            'brick_border_width': brick_border_width,   
+            'brick_border_height': brick_border_height,
+            'mortar_border': mortar_border
+        })
+        new_img = wang_tile.generate_wang_borders(width, height, border_size, border_style, avg_colour)
+    elif border_style == 'noise_mask':
+        base_frequency = float(request.form['base_frequency'])
+        cell_size =int(request.form['cell_size'])
+        noise_octaves = int(request.form['noise_octaves'])
+        noise_persistance = float(request.form['noise_persistance'])
+        noise_lacunarity = float(request.form['noise_lacunarity'])
+
+        noise_2d = proc_tex.generate_noise([width,height],base_frequency,cell_size,noise_octaves,noise_persistance,noise_lacunarity)
+
+        #black_image = Image.new('RGBA', (width, height), color='black')
+        wang_tile = wang_tile_generator.WangTilesGenerator(noise_img=noise_2d, border_dict={'border_size': border_size})
+        new_img = wang_tile.generate_mask_border(img)
+    elif border_style == 'noise':
+        colour = request.form['colours']
+        colours_json = json.loads(colour)
+        noise_params = {
+            "base_frequency": float(request.form['base_frequency']),
+            "cell_size": int(request.form['cell_size']),
+            "noise_octaves": int(request.form['noise_octaves']),
+            "noise_persistance": float(request.form['noise_persistance']),
+            "noise_lacunarity": float(request.form['noise_lacunarity'])
+        }
+        thresholds = [
+            float(request.form['threshold_1']),
+            float(request.form['threshold_2']),
+            float(request.form['threshold_3']),
+            float(request.form['threshold_4']),
+            float(request.form['threshold_5'])
+        ]
+
+        new_img = proc_tex.noise_texture([width, height], colours_json, thresholds, noise_params)
+        new_img = new_img.convert('RGBA')
+
+        wang_tile = wang_tile_generator.WangTilesGenerator(input_border_img=new_img.load())
+        new_img = wang_tile.generate_wang_borders(width, height, border_size, border_style, avg_colour)
+    else:
+        wang_tile = wang_tile_generator.WangTilesGenerator()
+        new_img = wang_tile.generate_wang_borders(width, height, border_size, border_style, avg_colour)
     img_io = BytesIO()
     new_img.save(img_io, 'PNG')
     img_io.seek(0)
@@ -50,7 +96,9 @@ def wang_borders():
 def wang_tiles():
     img = verify_file(request)
 
-    new_img = wang_tile.generate_wang_tile(img)
+    wang_tile = wang_tile_generator.WangTilesGenerator()
+
+    new_img = wang_tile.generate_wang_tile(img, False)
     img_io = BytesIO()
     new_img.save(img_io, 'PNG')
     img_io.seek(0)
@@ -75,13 +123,45 @@ def noise_image():
 
 @app.route('/procedural',  methods=['POST'])
 def procedural_texture():
-    base_frequency = float(request.form['base_frequency'])
-    cell_size = int(request.form['cell_size'])
-    noise_octaves = int(request.form['noise_octaves'])
-    noise_persistance = float(request.form['noise_persistance'])
-    noise_lacunarity = float(request.form['noise_lacunarity'])
+    tile_width = int(request.form['tile_width'])
+    tile_height = int(request.form['tile_height'])
+    texture_type = request.form['texture_type']
+
+    colour = request.form['colours']
+    colours_json = json.loads(colour)
 
-    new_img = proc_tex.noise_texture([300, 300], base_frequency, cell_size, noise_octaves, noise_persistance, noise_lacunarity)
+    noise_params = {
+        "base_frequency": float(request.form['base_frequency']),
+        "cell_size": int(request.form['cell_size']),
+        "noise_octaves": int(request.form['noise_octaves']),
+        "noise_persistance": float(request.form['noise_persistance']),
+        "noise_lacunarity": float(request.form['noise_lacunarity'])
+    }
+    if texture_type == 'noise':
+        thresholds = [
+            float(request.form['threshold_1']),
+            float(request.form['threshold_2']),
+            float(request.form['threshold_3']),
+            float(request.form['threshold_4']),
+            float(request.form['threshold_5'])
+        ]
+
+        new_img = proc_tex.noise_texture([tile_width, tile_height], colours_json, thresholds, noise_params)
+    else:
+        mortar_colour = request.form['mortar_colour']
+        brick_width = int(request.form['brick_width'])
+        brick_height = int(request.form['brick_height'])
+        mortar_size = int(request.form['mortar_size'])
+        threshold = float(request.form['threshold'])
+
+        new_img = proc_tex.generate_brick_texture([tile_width, tile_height],
+                                                  colours_json, 
+                                                  noise_params,
+                                                  [brick_width, brick_height],
+                                                  mortar_size,
+                                                  ImageColor.getrgb(mortar_colour),
+                                                  threshold)
+    
     img_io = BytesIO()
     new_img.save(img_io, 'PNG')
     img_io.seek(0)

src/pixel_generator/__init__.py

@@ -92,27 +92,29 @@ def generate_seamless_texture(self, img):
         result_image = image_to_seamless(img, overlap=0.1)
         return result_image
 
-    def process_image(self, img, num_colours, pixel_size):
-        img = img.convert('RGB')
-        width, height = img.size
-
-        new_width = width - (width % pixel_size)
-        new_height = height - (height % pixel_size)
-        img = img.resize((new_width, new_height))
-
-        img_array = np.array(img)
-
+    def get_colour_palette(self, img_array, num_colours=6):
         pixels = img_array.reshape((-1,4))
-
         rand_int = np.random.randint(0, 2**32)
         kmeans = KMeans(n_clusters=num_colours, random_state=rand_int)
         kmeans.fit(pixels)
-
         colours = kmeans.cluster_centers_.astype(int)
 
         labels = kmeans.predict(pixels)
         quantized = colours[labels]
 
+        return quantized, colours
+
+    def process_image(self, img, num_colours, pixel_size):
+        img = img.convert('RGBA')
+        width, height = img.size
+
+        new_width = width - (width % pixel_size)
+        new_height = height - (height % pixel_size)
+        img = img.resize((new_width, new_height))
+
+        img_array = np.array(img)
+        quantized, _ = self.get_colour_palette(img_array, num_colours)
+
         quantized = quantized.reshape(img_array.shape)
         for i in range(0, new_height, pixel_size):
             for j in range(0, new_width, pixel_size):

src/procedural_textures/__init__.py

@@ -2,6 +2,9 @@
 from PIL import Image
 import numpy as np
 
+from . import brick
+
+
 class ProceduralTextures:
     def improved_noise(self, baseFrequency, cellSize, octaves, persistance, lacunarity, coords):
         totalNoise = 0
@@ -29,7 +32,8 @@ def normalize(arr):
         scale = 1
         width = img_size[0]
         height = img_size[1]
-        opensimplex.seed(100)
+        rand_int = np.random.randint(0, 2**32)
+        opensimplex.seed(rand_int)
         result = np.zeros((width, height))
 
         for y in range(width):
@@ -45,38 +49,94 @@ def normalize(arr):
 
         return noise_2d
 
-    def noise_texture(self, img_size, baseFrequency, cellSize, octaves, persistance, lacunarity):
-        noise_array = self.generate_noise(img_size, baseFrequency, cellSize, octaves, persistance, lacunarity)
+    def noise_texture(self, img_size, colours, thresholds, noise_params):
+        noise_array = self.generate_noise(img_size, 
+                                          noise_params['base_frequency'], 
+                                          noise_params['cell_size'],
+                                          noise_params['noise_octaves'], 
+                                          noise_params['noise_persistance'], 
+                                          noise_params['noise_lacunarity'])
 
         width = img_size[0]
         height = img_size[1]
 
-        brown = np.array([165, 42, 42]) / 255.0  # RGB for brown
-        green = np.array([0, 255, 0]) / 255.0    # RGB for green
+        new_colours = np.array(colours) / 255.0
+
+        thresholds = np.sort(np.array(thresholds))
 
         color_noise = np.zeros((*(width, height), 3))
         for i in range(3):
-            color_noise[:,:,i] = noise_array * (green[i] - brown[i]) + brown[i]
+            color_noise[:,:,i] = np.interp(noise_array, thresholds, new_colours[:, i])
 
-        #pic = np.array(noise_2d)
-        #pic = (pic - pic.min()) / (pic.max() - pic.min())
         pic = (color_noise * 255).astype(np.uint8)
 
         return Image.fromarray(pic, mode="RGB")
+    
+    def apply_linear_gradient(self, noise_array, stop_point_x, stop_point_y, direction='horizontal'):
+        rows, cols = noise_array.shape
+        if direction in ['horizontal', 'horizontal_rev']:
+            if direction == 'horizontal':
+                gradient = np.linspace(0, stop_point_x, cols)
+                gradient = np.tile(gradient, (rows, 1))
+            else:
+                gradient = np.linspace(stop_point_x, 0, cols)
+                gradient = np.tile(gradient, (rows, 1))
+        elif direction in ['vertical', 'vertical_rev']:
+            if direction == 'vertical':
+                gradient = np.linspace(0, stop_point_y, rows)
+                gradient = np.tile(gradient, (cols, 1)).T
+            else:
+                gradient = np.linspace(stop_point_y, 0, rows)
+                gradient = np.tile(gradient, (cols, 1)).T
+        elif direction in ['diagonal_tl', 'diagonal_tr', 'diagonal_bl', 'diagonal_br']:
+            x = np.linspace(0, stop_point_x, cols)
+            y = np.linspace(0, stop_point_y, rows)
+            xx, yy = np.meshgrid(x, y)
+            if direction == 'diagonal_tl':
+                gradient = (xx + yy) / 2
+            elif direction == 'diagonal_tr':
+                gradient = (1 - xx + yy) / 2
+            elif direction == 'diagonal_bl':
+                gradient = (xx + 1 - yy) / 2
+            else:  # diagonal_br
+                gradient = (2 - xx - yy) / 2
+        else:    
+            raise ValueError("Direction must be 'horizontal' or 'vertical'")
+        
+        return noise_array * gradient
+
     def noiseify_image(self, img, baseFrequency, cellSize, octaves, persistance, lacunarity):
-        img = img.convert('RGB')
-        width, height = img.size
+        img = img.convert('RGBA')
+        img_array = np.array(img)
 
-        new_width = round(width / 8)
-        new_height = round(height / 8)
+        noise_array = self.generate_noise([200, 200], baseFrequency, cellSize, octaves, persistance, lacunarity)
+        noise_array = self.apply_linear_gradient(noise_array)
 
-        noise_array = self.generate_noise([new_width, new_height], baseFrequency, cellSize, octaves, persistance, lacunarity)
 
-        img_array = np.array(img)
+        scaled_noise = Image.fromarray((noise_array * 255).astype(np.uint8))
+        scaled_noise = scaled_noise.resize(img.size, Image.LANCZOS)
+        scaled_noise = np.array(scaled_noise) / 255.0
+
+        alpha_mask = (scaled_noise > 0.3).astype(float)
+        img_array[:, :, 3] = img_array[:, :, 3] * alpha_mask
+
+
+        return Image.fromarray(img_array.astype('uint8'))
 
-        for i in range(height-1):
-            for j in range(width-1):
-                if noise_array[round(i/8)][round(j/8)] < 0.5:
-                    img_array[i, j] = (0,0,0)
 
-        return Image.fromarray(img_array.astype('uint8'))
+    def generate_brick_texture(self, img_size, colours, noise_params, brick_size, mortar_size, mortar_colour, threshold):
+        colours = np.array(colours)
+        colours = np.append(colours, np.full((colours.shape[0], 1), 255), axis=1)
+        noise_array = self.generate_noise(img_size, 
+                                          noise_params['base_frequency'], 
+                                          noise_params['cell_size'],
+                                          noise_params['noise_octaves'], 
+                                          noise_params['noise_persistance'], 
+                                          noise_params['noise_lacunarity'])
+        return brick.create_brick_texture(img_size, 
+                                          colours, 
+                                          noise_array, 
+                                          brick_size, 
+                                          mortar_size, 
+                                          mortar_colour,
+                                          threshold)