[Blender x Python] Maîtrisons au hasard !!

Cette fois, nous allons introduire un mécanisme pour disposer un grand nombre d'objets au hasard.

table des matières

0. Comment obtenir un nombre aléatoire 1.Faites apparaître des cubes à des positions aléatoires
1. Créez une fonction pour organiser le processus
2. Exemple de code
3. Mots anglais Matériel de référence

0. Comment obtenir un nombre aléatoire

Cette fois, nous utiliserons la fonction `` rand () '' dans une bibliothèque (une collection de code utile) appelée ** numpy **.

La fonction rand () renvoie une valeur aléatoire ** de ** 0 à 1. L'argument (paramètre) spécifie le nombre de nombres aléatoires à renvoyer. S'il s'agit de rand (3), il renvoie 3 nombres aléatoires.

import numpy as np

#np.Vous pouvez considérer le hasard comme une flèche pointant vers la droite et l'ignorer.
np.random.rand(3)

Point:import numpy as np La bibliothèque appelée numpy est abrégée en np dans le code.

array([0.90681482, 0.04813658, 0.47969033])

↑ Trois valeurs aléatoires comprises entre 0 et 1 sont émises.

• Array signifie un tableau, mais cette fois, vous n'avez pas à vous en soucier. C'est comme un conteneur avec des nombres dans l'ordre.

1.Faites apparaître des cubes à des positions aléatoires

1-0. Faisons apparaître le cube dans des positions aléatoires !!

Utilisez la bibliothèque `` numpy '' pour le calcul numérique

import bpy
import numpy as np

bpy.ops.mesh.primitive_cube_add(location = np.random.rand(3))

Point:rand( ) Générez une valeur aléatoire de 0 à 1. L'argument détermine le nombre de valeurs à renvoyer. rand (3) renvoie trois valeurs aléatoires.

• Sur la photo, trois valeurs aléatoires → (0,0291909, 0,379929, 0,395483) ont été attribuées à l'emplacement de la variable.

1-1. Pouvons spécifier la plage dans laquelle le cube apparaît

○ Obtient un nombre aléatoire compris entre -10 ou plus et moins de 10. Le code a la structure suivante.

Attribuez des données (informations) à la variable □ et exécutez le traitement en utilisant ces données. Et vous pouvez considérer les points comme des flèches pointant vers la droite (presque négligeables).

□ ← Données numériques aléatoires
===>fonction( □ )

import bpy
import numpy as np

#Variable aléatoire_Créer un emplacement et attribuer une valeur aléatoire
random_location = (10 - (-10)) * np.random.rand(3) + (-10)
bpy.ops.mesh.primitive_cube_add(location = random_location)

Point: ** Valeur numérique dans une certaine plage ** La formule pour obtenir une valeur aléatoire comprise entre min ou plus et moins que max est (max-min) * np.random.rand() + min est.

En d'autres termes ** Plage où les nombres fluctuent * Valeur aléatoire de 0 à 1 + Début de plage ** à propos de ça.

Dans cet exemple, nous obtenons des nombres (aléatoires) compris entre +20 et -10. Plage → (-10, ..- 9, ..0, ..9, ..10)

2. Créez une fonction pour organiser le processus

2-0. Créez une fonction qui renvoie un nombre aléatoire et une fonction qui l'utilise pour faire apparaître un cube.

import bpy
import numpy as np

#Définition d'une fonction pour générer trois valeurs aléatoires
def get_random_location(min,max):
    return (max - min) * np.random.rand(3) + min

#get_random_location()Définition d'une fonction qui fait apparaître un cube à l'aide de la valeur générée par la fonction
def generate_random_cube(min,max):
    random_location = get_random_location(min,max)
    bpy.ops.mesh.primitive_cube_add(location = random_location)

generate_random_cube(-10,10)

Point:Return Il est utilisé sous la forme de `` retour d'informations '' lorsque la fonction sort des informations.

2-1. Créez une fonction qui fait apparaître plusieurs cubes à des positions aléatoires

import bpy
import numpy as np

#Définition d'une fonction pour générer trois valeurs aléatoires
def get_random_location(min,max):
    return (max - min) * np.random.rand(3) + min

#get_random_location()Définition d'une fonction qui fait apparaître un cube à l'aide de la valeur générée par la fonction
def generate_random_cube(min,max):
    random_location = get_random_location(min,max)
    bpy.ops.mesh.primitive_cube_add(location = random_location)

#Définition d'une fonction qui fait apparaître plusieurs cubes à des positions aléatoires
def generate_random_cubes(min,max,num):
    for i in range(0,num):
        generate_random_cube(min,max)

generate_random_cubes(-10,10,200)

2-2. Faire apparaître plusieurs cubes avec des angles aléatoires à des positions aléatoires

import bpy
import math
import numpy as np

#Définition d'une fonction pour générer trois valeurs aléatoires
def get_random_location(min,max):
    return (max - min) * np.random.rand(3) + min

#random_number()Définition d'une fonction qui tourne et fait apparaître un cube en utilisant la valeur générée par la fonction
def generate_random_rotate_cube(min,max):
    random_location = get_random_location(min,max)
    bpy.ops.mesh.primitive_cube_add(location = random_location,rotation = math.pi * np.random.rand(3))

#Définition d'une fonction qui tourne et fait apparaître plusieurs cubes à des positions aléatoires
def generate_random_rotate_cubes(min,max,num):
    for i in range(0,num):
        generate_random_rotate_cube(min,max)

generate_random_rotate_cubes(-10,10,200)

3. Exemple de code

Créer une fonction qui détermine aléatoirement la couleur

○ Placez des cubes colorés à des positions aléatoires et à des angles aléatoires.

import bpy
import math
import numpy as np

#Définition de la fonction qui détermine le matériau
def material(name = 'material'):
    material_glass = bpy.data.materials.new(name)
    #Rendre le nœud disponible
    material_glass.use_nodes = True
    p_BSDF = material_glass.node_tree.nodes["Principled BSDF"]
    #0→BaseColor/7→roughness(=Rugosité)/15→transmission(=propagation)
    #default_value = (R, G, B, A)
    p_BSDF.inputs[0].default_value = np.random.rand(4)
    p_BSDF.inputs[7].default_value = 0
    p_BSDF.inputs[15].default_value = 1
    #Ajouter des éléments matériels à un objet
    bpy.context.object.data.materials.append(material_glass)

#Définition d'une fonction pour générer trois valeurs aléatoires
def get_random_location(min,max):
    return (max - min) * np.random.rand(3) + min

#random_number()Définition d'une fonction qui tourne et fait apparaître un cube en utilisant la valeur générée par la fonction
def generate_random_rotate_cube(min,max):
    random_location = get_random_location(min,max)
    bpy.ops.mesh.primitive_cube_add(location = random_location,rotation = math.pi * np.random.rand(3))

#Définition d'une fonction qui tourne et fait apparaître plusieurs cubes à des positions aléatoires
def generate_random_rotate_colorful_cubes(min,max,num):
    for i in range(0,num):
        generate_random_rotate_cube(min,max)
        material('Random')


generate_random_rotate_colorful_cubes(-10,10,200)

    

Créez une fonction qui organise les cubes tout en les faisant pivoter

import bpy
import math
import numpy as np

#Définition de la fonction qui détermine le matériau
def material(name = 'material'):
    material_glass = bpy.data.materials.new(name)
    #Rendre le nœud disponible
    material_glass.use_nodes = True
    p_BSDF = material_glass.node_tree.nodes["Principled BSDF"]
    #0→BaseColor/7→roughness(=Rugosité)/15→transmission(=propagation)
    #default_value = (R, G, B, A)
    p_BSDF.inputs[0].default_value = np.random.rand(4)
    p_BSDF.inputs[7].default_value = 0
    p_BSDF.inputs[15].default_value = 1
    #Ajouter des éléments matériels à un objet
    bpy.context.object.data.materials.append(material_glass)

#Définition d'une fonction qui arrange des cubes colorés tout en les faisant tourner
def spiral_colorful_cubes():
    #Itérer 100 fois
    for i in range(0,100):
        bpy.ops.mesh.primitive_cube_add(
            #Montez petit à petit
            location=(0, 0, i/50),
            scale=(1, 1, 0.05),
            #180 * i * 36(À chaque fois)Shift un par un
            rotation = (0, 0, math.pi*i*10/360)
            )
        #Ajouter des éléments matériels à un objet
        material('Random')

#Effectuer le traitement
spiral_colorful_cubes()

Créer une fonction qui transforme le tore, le fait pivoter et l'organise

import bpy
import math
import numpy as np

#Définition de la fonction qui détermine le matériau
def material(name = 'material'):
    material_glass = bpy.data.materials.new(name)
    #Rendre le nœud disponible
    material_glass.use_nodes = True
    p_BSDF = material_glass.node_tree.nodes["Principled BSDF"]
    #0→BaseColor/7→roughness(=Rugosité)/15→transmission(=propagation)
    #default_value = (R, G, B, A)
    p_BSDF.inputs[0].default_value = np.random.rand(4)
    p_BSDF.inputs[7].default_value = 0
    p_BSDF.inputs[15].default_value = 1
    #Ajouter des éléments matériels à un objet
    bpy.context.object.data.materials.append(material_glass)

#Définition d'une fonction qui transforme et décale le tore et colore chacun
def colorful_torus_spiral():
    for i in range(0,36):
        bpy.ops.mesh.primitive_torus_add(
            location=(0, 0, 0),
            major_radius=1.0,
            minor_radius=0.01,
            )
        #Rétrécir dans la direction de l'axe Y
        bpy.ops.transform.resize(value=(1, 0.3, 1))
        #Rotation autour de l'axe Z
        bpy.ops.transform.rotate(value=math.pi*i*10/360,orient_axis='Z')
        #Ajouter des éléments matériels à un objet
        material('Random')

colorful_torus_spiral()

4. Mots anglais

Matériel de référence

Référence: Générer automatiquement une grande quantité de particules en direct avec Blender x Python