Importare dati in Blender. Conversione in Python

Il controllo di Blender con il linguaggio Python permette di sviluppare idee con potenza e flessibilità. Utilizzando l’interfaccia di Blender si può osservare che ogni pulsante od oggetto presente nel software, è corredato da una tooltip che visualizza il comando in python equivalente. Per far comparire una tendina tooltip basta soffermarsi con il puntatore del mouse sopra un oggetto. In Blender un intero progetto 3d può quindi essere realizzato completamente da riga di comando.
Importare oggetti all’interno di Python. Automazione processi di modellazione e rendering

Importare figure geometriche in Blender

In una matrice chiamata “elenco_quadrati” sono definiti qualche migliaio di quadrati tutti con determinate dimensioni e posizione sul piano cartesiano xy. I quadrati devono essere importati in Blender realizzando per ognuno di essi un parallelepipedo avente la base del quadrato ed un altezza prefissata. Ad ognuno di questi solidi deve successivamente essere assegnato un materiale unico all’interno dell’ambiente Cycles. Ogni parallelepipedo viene gestito in Blender definendo i vertici con coordinate (x,y,z) e le facce rettangolari che formano la mesh superficiale del solido.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
vertici = [(xmax, ymax, zmin),  
           (xmax, ymin, zmin),  
           (xmin, ymin, zmin),  
           (xmin, ymax, zmin), 
           (xmax, ymax, zmax),  
           (xmax, ymin, zmax), 
           (xmin, ymin, zmax),  
           (xmin, ymax, zmax)]  
facce = [(0, 1, 2, 3),         
         (4, 7, 6, 5), 
         (0, 4, 5, 1), 
         (1, 5, 6, 2), 
         (2, 6, 7, 3),  
         (4, 0, 3, 7)]
Una volta definiti vertici e superfici rettangolari, è possibile assemblare qualsiasi solido con poche righe di comando. Assegnato un nome al solido, la fase successiva di modellazione consiste nell’assegnare automaticamente un determinato materiale ad ogni oggetto. Il codice scritto in Matlab genera un altro codice in Python che deve essere lanciato all’interno di Blender. Per utilizzare gli script in python è conveniente passare all’interfaccia “scripting” di Blender.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
function scrivi_py ()
% Autori
% Prof. Danilo Pasquini IPSIA Parodi Delfino, Colleferro (Roma)
% Prof. Paolo Sordi IPSIA A. Pacinotti, Pontedera (Pisa) 
%
load ton39
scala = 10;
[riga,colonna] = size (matrice_contorno);
fattore  = 0;
while (riga * colonna) * fattore * fattore   < 24000000
    %while (r * c) * fattore * fattore   < 4800 * 6400
    fattore = fattore + 1
end
elenco_quadrati (1:end,10) = 0
elenco_quadrati (1:end,11) = 10 
nomefile = ['svg1' num2str(ceil(rand()*100))  '.py']
fid = fopen(nomefile, 'wt');
fprintf(fid, ['import bpy  \n']);
[a,b] = size (elenco_quadrati);
 
minimo_x  = min(elenco_quadrati (1:end,1));
massimo_x = max(elenco_quadrati (1:end,1));
minimo_y  = min(elenco_quadrati (1:end,2));
massimo_y = max(elenco_quadrati (1:end,2));
medio_x = (massimo_x - minimo_x)/2;
medio_y = (massimo_y - minimo_y)/2;
 
elenco_quadrati (end+1,1) = minimo_x - medio_x * 2
elenco_quadrati (end,2)   = minimo_y - medio_y * 2
elenco_quadrati (end,3) = max(medio_y*6,medio_x*6)
elenco_quadrati (end,5) = 255;
elenco_quadrati (end,6) = 255;
elenco_quadrati (end,7) = 255;
elenco_quadrati (end,10) = -5;
elenco_quadrati (end,11) = 0;
[a,b] = size (elenco_quadrati);
numero_inseriti = 0;
vettore = ones(a);
while numero_inseriti < a
    prova = ceil(rand * a); 
    if vettore(prova) == 1
        vettore(prova) = 0;
        numero_inseriti = numero_inseriti + 1;
        i = prova;
        raggio = elenco_quadrati (i,3); 
        coord_x = elenco_quadrati (i,1) - medio_x;
        coord_y = elenco_quadrati (i,2) - medio_y;
        zmin = elenco_quadrati (i,10);
        zmax = elenco_quadrati (i,11);
        colore1 = elenco_quadrati (i,5)/255;
        colore2 = elenco_quadrati (i,6)/255;
        colore3 = elenco_quadrati (i,7)/255;
        fprintf(fid, ['xmin =' num2str(coord_x/scala)  ' \n']);
        fprintf(fid, ['xmax =' num2str((coord_x+raggio)/scala)  ' \n']);
        fprintf(fid, ['ymin =' num2str(coord_y/scala)  ' \n']);
        fprintf(fid, ['ymax =' num2str((coord_y+raggio)/scala)  ' \n']);
        fprintf(fid, ['zmin =' num2str(zmin/scala)  ' \n']);
        fprintf(fid, ['zmax =' num2str(zmax/scala)  ' \n']);
        fprintf(fid, ['vertici = [(xmax, ymax, zmin),  \n']);
        fprintf(fid, ['         (xmax, ymin, zmin),  \n']);
        fprintf(fid, ['         (xmin, ymin, zmin),  \n']);
        fprintf(fid, ['         (xmin, ymax, zmin), \n']);
        fprintf(fid, ['         (xmax, ymax, zmax),  \n']);
        fprintf(fid, ['         (xmax, ymin, zmax), \n']);
        fprintf(fid, ['         (xmin, ymin, zmax),  \n']);
        fprintf(fid, ['         (xmin, ymax, zmax)]  \n']);
        fprintf(fid, ['facce = [(0, 1, 2, 3), \n']);        
        fprintf(fid, ['         (4, 7, 6, 5), \n']);
        fprintf(fid, ['         (0, 4, 5, 1), \n']);
        fprintf(fid, ['         (1, 5, 6, 2), \n']);
        fprintf(fid, ['         (2, 6, 7, 3),  \n']);
        fprintf(fid, ['         (4, 0, 3, 7)]  \n']);        
        fprintf(fid, ['mesh_data = bpy.data.meshes.new("cube_mesh_data")  \n']);        
        fprintf(fid, ['mesh_data.from_pydata(verts, [], faces) \n']);
        fprintf(fid, ['mesh_data.update() # (calc_edges=True) not needed here  \n']);
        fprintf(fid, ['cube_object = bpy.data.objects.new("Cube_Object' num2str(i)   '", mesh_data) \n']);
        fprintf(fid, [' \n']); 
        fprintf(fid, ['scene = bpy.context.scene   \n']);
        fprintf(fid, ['scene.objects.link(cube_object)     \n']);
        fprintf(fid, ['cube_object.select = True  \n']);
        fprintf(fid, [' \n']); 
        fprintf(fid, ['my_object = bpy.data.objects[''Cube_Object' num2str(i) '''].data  \n']);  
        fprintf(fid, ['mat = bpy.data.materials.new(''vertex_material' num2str(i)  ''') \n']);
        fprintf(fid, ['mat.diffuse_color  = (', num2str(colore1), ',', num2str(colore2), ',' , num2str(colore3) ') \n']);        
        fprintf(fid, ['mat.specular_color = (', num2str(colore1), ',', num2str(colore2), ',' , num2str(colore3) ') \n']);        
        fprintf(fid, ['my_object.materials.append(mat)   \n']);
        fprintf(fid, [' \n']);
    end
end
 
fclose(fid)
pause(1)
load chirp;
y1 = y; Fs1 = Fs;
load gong;
wavplay(y1,Fs1,'sync') % The chirp signal finishes before the

Gestire la definizione di un materiale tramite Python

Cycles permette di progettare ogni materiale utilizzando uno schema a blocchi. La definizione di un materiale può essere impostata come se si lavorasse con dei blocchi matematici: l’ambiente di lavoro di cycles assomiglia molto ai programmi di simulazione elettronica o al classico Simulink di Matlab. Anche se il primo approccio può risultare un po’ complicato dopo un po’ di prove, la modellazione della maggior parte dei materiali diventa facilmente gestibile. Ogni blocco definito in Cycles viene chiamato nodo. La comunicazione tra i nodi avviene collegando delle linee tra i pin di input e output di ogni blocco. Anche questa fase di progettazione del materiale, può essere gestita interamente da uno script realizzato in Python. Ogni nodo creato da riga di comando deve essere posizionato fisicamente all’interno dell’area di lavoro attraverso il metodo “node.location”. I vari nodi possono essere collegati con la creazione di un link:
1
2
3
    out = nodes['diff'].outputs[0]
    inp = nodes['mixer'].inputs[2]
    mat.node_tree.links.new(out, inp)
Definizione di un materiale in Blender – Cycles
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
# Autori
# Prof. Danilo Pasquini IPSIA Parodi Delfino, Colleferro (Roma)
# Prof. Paolo Sordi IPSIA A. Pacinotti, Pontedera (Pisa) 
# Codice in Python per realizzare un materiale misto tra comportamento Diffuse e Gloss
#
import bpy  
def creazione_materiale(matname, r=1, g=1, b=1, alpha=0):
 
    scena = bpy.context.scene
    if not scena.render.engine == 'CYCLES':
        scena.render.engine = 'CYCLES'
 
    mat = bpy.data.materials.new(matname)
    mat.use_nodes = True
    mat.diffuse_color = (r, g, b)
    nodes = mat.node_tree.nodes
 
    node=nodes['Diffuse BSDF']
    nodes.remove(node)
 
    node=nodes['Material Output']
    node.location = 400, 160
 
    node1 = nodes.new('ShaderNodeBsdfGlossy')
    node1.name = 'gloss'
    node1.location = 10, 260
    node1.inputs[0].default_value = [r, g, 0.25, alpha]
 
    node2 = nodes.new('ShaderNodeBsdfDiffuse')
    node2.name = 'diff'
    node2.location = 10, 80
    node2.inputs[0].default_value = [r, g, 0.3, alpha]
 
    node3 = nodes.new('ShaderNodeMixShader')
    node3.name = 'mixer'
    node3.location = 200, 160
    node3.inputs[0].default_value = 0.457
    print (' self=')
 
    out = nodes['gloss'].outputs[0]
    inp = nodes['mixer'].inputs[1]
    mat.node_tree.links.new(out, inp)
 
    out = nodes['diff'].outputs[0]
    inp = nodes['mixer'].inputs[2]
    mat.node_tree.links.new(out, inp)
 
    out = nodes['mixer'].outputs[0]
    inp = nodes['Material Output'].inputs[0]
    mat.node_tree.links.new(out, inp)
 
    return mat
 
creazione_materiale (materiale_name = "materiale1",  r=0.6, g=0.6, b=0.4, alpha=0)