#1 Code en Vrac : Créer des formes aléatoires sous Python

Dans cet article, je vous expose un code « qui ne sert à rien ». L’idée est de créer des formes aléatoires sous Python. Pour cela nous créerons un nuage de points aléatoires et, à partir de cette base, nous déformerons l’image pour afficher une forme.

Voici un exemple de résultat obtenu :

Exemple formes aléatoires sous Python

Avec ce code Python, vous pourrez maîtriser les outils suivants:

  • Décomposition en nombres premiers
  • Afficher des images l’une derrière l’autre
  • Modifier la valeur d’un pixel et notamment lui donner la valeur moyenne des pixels qui l’entourent

Voici le code Python :


In [1]:
#Importation des packages nécessaires pour notre code
import numpy as np
import matplotlib.pyplot as plt
import random 
import time
from datetime import timedelta
import math
from math import *

# Image manipulation.
import PIL.Image
In [5]:
def decompose(n): 
    decompo = np.array([])
    
    i=2 
    while n>1: 
        while n%i==0: 
            decompo = np.concatenate((decompo, np.array([i])))
            n=n/i 
        i=i+1 
    return decompo
 
def axes_x_y(decompo):
    
    x=1
    y=1

    #loop with a while
    i=0
    while i < (len(decompo)//2):
        x = x * decompo[i]
        i += 1
    
    #loop with a for (but for the same kind of result as previously)
    for i in range(len(decompo)//2,len(decompo)):
        y = y * decompo[i]
        
    return int(x), int(y)

print("Exemple - fonction decompose : {}".format(decompose(12)))
print("Exemple - fonction axes_x_y : {}".format(axes_x_y(decompose(12))))
Exemple - fonction decompose : [ 2.  2.  3.]
Exemple - fonction axes_x_y : (2, 6)
In [6]:
def plot_cloud(images):

    x, y = axes_x_y(decompose(len(images)))

    fig, axes = plt.subplots(x , y)
    fig.subplots_adjust(hspace = 0.3, wspace = 0.3)
    
    for i, ax in enumerate(axes.flat):
        ax.imshow(images[i].reshape([int(sqrt(len(images[i]))), int(sqrt(len(images[i])))]),interpolation='nearest',cmap='binary')
        
        xlabel = "Layer {0}".format(i)
        ax.set_xlabel(xlabel)
            
        ax.set_xticks([])
        ax.set_yticks([])
            
    plt.show()
In [7]:
#Fonction : Création de nuage aléatoire

def cloud_creator(img_size, layer):
    
    #we use squared image, the number of row pixels is equal the number of column pixels = img_size
    #if my image is 28x28 pixels, then there is a total of img_size_flat = 28x28 = 784 pixels
    img_size_flat = img_size * img_size
    
    #fill in a array with random value between 0 and 1
    Array_random = np.random.rand(1, img_size_flat).astype(np.float32)
    #fill in a array with random value equal to 0 or 1
    Indicatrice_random = np.random.binomial(1, random.uniform(0, 0.2), img_size_flat).astype(np.float32)
    
    #Cloud random servira à stocker les images avec leurs modifications layer après layer
    #layer 0 correspond au 1er nuage de point, layer 1 correspond au nuage de points 1 modifié
    #etc... layer i correspond au nuage de points i-1 modifié
    Cloud_random = np.zeros((layer, img_size_flat)).astype(np.float32)
    
    #Our 1st layer of the cloud image is the multiplication of Array_random x Indicatrice_random
    #example :
    #Array_random = [0.1, 0.5, 0.3, 0.6]
    #Indicatrice_random = [0, 0, 1, 1]
    #Then the layer 1 of Cloud_random = [0., 0., 0.3, 0.6]
    Cloud_random[0] = Array_random * Indicatrice_random
    
    for l in range(1,layer):
        Cloud_random_layer_l_previous = Cloud_random[l-1].reshape([img_size, img_size])
        Cloud_random_layer_l = Cloud_random[l].reshape([img_size, img_size])
    
        for r in range(img_size):
            rlower=max(0,r-1)
            rupper=min(r+1,img_size) + 1

            for c in range(img_size):
                clower=max(0,c-1)
                cupper=min(c+1,img_size) + 1

                if random.randint(0, 1) == 0:
                    #we take the mean of the pixel on the top, bottom, left and right (not the diagonal)
                    Cloud_random_layer_l[r,c] = np.mean(Cloud_random_layer_l_previous[rlower:rupper, c]) + np.mean(Cloud_random_layer_l_previous[r, clower:cupper])
                else :
                    #we take the mean of all the pixel around
                    Cloud_random_layer_l[r,c] = np.mean(Cloud_random_layer_l_previous[rlower:rupper, clower:cupper])
        
    
        Cloud_random[l] = Cloud_random_layer_l.reshape([1, img_size_flat]) 
    
    return Cloud_random
In [13]:
a = cloud_creator(img_size = 28, layer = 9)
plot_cloud(a)




Et voilà le travail ! A vous de copier les parties du code qui vous intéresse !