Commit 07a65080 authored by Bruno Thomazi Zanette's avatar Bruno Thomazi Zanette 🎱
Browse files

Update BlenderVisu/Script_C/.gitkeep, BlenderVisu/Script_C/mesma.exe,...

Update BlenderVisu/Script_C/.gitkeep, BlenderVisu/Script_C/mesma.exe, BlenderVisu/Script_C/CP_withC.py, BlenderVisu/Script_C/mesmalinha.c
parent cc747f74
import bpy
import time
from math import cos
import ast
import os
import ctypes
'''
Código rodado em background que transforama dados do corsika modelos 3d de curvas,
a animação das curvas são salvar em formato png utilizando o comando:
para transformar em mp4 pode-se usar (no linux) ffmpeg:
blender -b -P blender_visu_script.py -o /home/bruno/Desktop/rend/img###.png -a
cat *.png | ffmpeg -f image2pipe -r 30 -i - output.mp4 -y
rm *.png
'''
# ARGUMENTOS
arquivos_nome = ["EDrezultate2",] # nome txt com dados
limite = -1
# limite = (4 + 1) * 100 # -1 para ler todos os dados dos arquivos
## cc -fPIC -shared -o mesma.exe mesmalinha.c
_file = "mesma.exe"
_path = os.path.join(*(os.path.split(os.getcwd()) + (_file, )))
_mod = ctypes.cdll.LoadLibrary(_path)
_mesma = _mod.mesmalinhac
_mesma.argtypes = (ctypes.c_int,)
_mesma.restype = ctypes.c_double
def mesmalinhac(values1):
return (_mesma(len(values1)))
def make_curve(points,loop2):
'''
Funcao que cria curva no blender
'''
# create the Curve Datablock
curveData = bpy.data.curves.new(f'myCurve{loop2}', type='CURVE')
curveData.dimensions = '3D'
curveData.resolution_u = 4
# map coords to spline
polyline = curveData.splines.new('POLY')
polyline.points.add(len(points)-1)
for i, coord in enumerate(points):
x,y,z = coord
polyline.points[i].co = (x, y, z, 1)
# create Object
curveOB = bpy.data.objects.new(f'myCurve{loop2}', curveData)
curveData.bevel_resolution = 6
curveData.bevel_depth = 0.001667
# attach to scene and validate context
scn = bpy.context.scene
scn.collection.objects.link(curveOB)
bpy.ops.object.shade_smooth()
def remove_materials_objects():
'''
Função que remove todos materiais, objetos e curvas
'''
for material in bpy.data.materials: #remove materiais existentes
bpy.data.materials.remove(material)
for object in bpy.data.objects: # remove todos objetos
bpy.data.objects.remove(object)
for curva in bpy.data.curves: # remove todas curvas
bpy.data.curves.remove(curva)
def create_material(loop):
'''
Função que cria novo material
Argumento loop representa o arquivo que está sendo usado
'''
bpy.data.materials.new(name="base"+f'{loop}') # cria material
mat = bpy.data.materials[f'base{loop}'] # seleciona material criado
mat.use_nodes = True
Princi = mat.node_tree.nodes['Principled BSDF'] # nodo Principled BSDF
if loop == 0: # primeiro arquivo cor vermelha
Princi.inputs['Base Color'].default_value = (1.0, 0.028571, 0.021429, 0.4) # R G B Alpha
elif loop == 1: # segundo arquivo cor verde
Princi.inputs['Base Color'].default_value = (0.028571, 1, 0.021429, 0.4) # R G B Alpha
elif loop == 2: # terceiro arquivo cor azul
Princi.inputs['Base Color'].default_value = (0.028571, 0.021429, 1, 0.4) # R G B Alpha
else: # mais arquivos tem a cor decidida por cos()
Princi.inputs['Base Color'].default_value = (cos(loop*3.14), 1/cos(loop*3.14), cos(loop*3.14*2), 0.4) # R G B Alpha
Princi.inputs['Roughness'].default_value = 0.445455
Princi.inputs['Specular'].default_value = 0.08636365830898285
def insert_material(loop,loop2):
'''
Função que insere o material loop na curva loop2
'''
mat = bpy.data.materials['base'+f'{loop}']
curva = bpy.data.objects[f'myCurve{loop2}']
curva.data.materials.append(mat)
def anima(t_i,t_f,loop2):
'''
Função responsável pela animação da curva, utiliza somente o tempo final e inicial da curva
'''
if(t_i>t_f): #caso esteja trocado
d= t_f
t_f= t_i
t_i= d
scene = bpy.context.scene
curva = bpy.data.curves[f'myCurve{loop2}']
scene.frame_set(t_f)
curva.keyframe_insert(data_path='bevel_factor_end')
scene.frame_set(t_i)
curva.bevel_factor_end = 0
curva.keyframe_insert(data_path='bevel_factor_end')
curva.animation_data.action.fcurves[0].keyframe_points[0].interpolation = 'LINEAR'
curva.bevel_factor_mapping_end = 'SPLINE'
def curva(dados):
'''
Funcao que retorna os dados separados em diferentes curvas.
'''
x=[]
y=[]
xend=[]
yend=[]
dados_new=[]
for linha in dados:
ligne=linha.replace('\n','')
l=ligne.split(' ')
# print(l)
dados_new.append(l)
x.append(float(l[2])/1000000)
xend.append(float(l[6])/1000000)
y.append(float(l[3])/1000000)
yend.append(float(l[7])/1000000)
xif = inif(x,xend) # [inicial,final]
yif = inif(y,yend) # [inicial,final]
mesmax = mesmalinha(xif)
mesmay = mesmalinha(yif)
print(mesmax)
mesma = (mesmax, mesmay)
todas_curvas_x = []
todas_curvas_y = []
for loop,dado in enumerate(mesma):
for linha in dado: #colocar em função
indexes = []
for j in range (0,len(linha)):
if loop == 0:
indexes.append(x.index(linha[j][0]))
else:
indexes.append(y.index(linha[j][0]))
dados_salvar=[]
for g in range (0,len(linha)):
dados_salvar.append(dados_new[indexes[g]])
if loop ==0:
todas_curvas_x.append(dados_salvar)
else:
todas_curvas_y.append(dados_salvar)
if todas_curvas_x < todas_curvas_y:
maior_curva = todas_curvas_y.copy()
menor_curva = todas_curvas_x.copy()
else:
maior_curva = todas_curvas_x.copy()
menor_curva = todas_curvas_y.copy()
todas_curvas = []
for dado in maior_curva:
if dado in menor_curva:
todas_curvas.append(dado)
return(todas_curvas)
def mesmalinha(inicial_final):
'''
Função que encontra pontos iguais nos dados para serem
classificados como sendo da mesma curva. Também detecta
bifurcação da linha, fazendo as duas linhas serem curvas
diferentes, evitando erros.
inicial_final = [x,xend]
'''
print(f"\n\n\nOIII\n\n\n")
iniciais =[f[0] for f in inicial_final]
finais = [f[1] for f in inicial_final]
# SALVAR EM UM ARQUIVO PARA O C LER
fl = open("data.txt","w")
for i in range(len(iniciais)):
fl.writelines(f"{str(iniciais[i])} {str(finais[i])}\n")
fl.close()
# n = 200
# iniciais = list(range(1,n+1))
# finais = list(range(2,n+2))
print("try")
mesmalinhac(iniciais)
print("\nFOI\n")
file = open("dados_out.txt")
tr= file.read()
file.close()
tr= tr.replace("],]","]]")
tr= tr.replace("],]","]]")
# Converting string to list
linhas = ast.literal_eval(tr)
return(linhas)
def inif(li,lf):
'''
Funcao que organiza os dados em [inicial,final]
'''
tu=[]
for i in range(0,len(li)):
tu.append([li[i],lf[i]])
return(tu)
##
## CODIGO PRINCIPAL
##
start_time= time.time()
remove_materials_objects()
loop2 = 0
last_frame = 0 #para encontrar o ultimo frame
for loop,arquivo_nome in enumerate(arquivos_nome):
arquivo = open(arquivo_nome,'r')
tabraw = arquivo.readlines(limite)
arquivo.close()
dados_curvas = curva(tabraw)
create_material(loop)
# LOOP PRINCIPAL
for curve in dados_curvas:
loop2 += 1
pontos =[]
for count,l in enumerate(curve):
# print(f"{count/len(curve)*100}% linha: {l}") # O quanto foi feito
x=float(l[2])/1000000
y=float(l[3])/1000000
z=float(l[4])/1000000
tini=float(l[5])*1000000
xend=float(l[6])/1000000
yend=float(l[7])/1000000
zend=float(l[8])/1000000
tend=float(l[9])*1000000
pontos.append((x,y,z))
if count == 0:
tempo_inicial = int(tini)
tempo_final = int(tend)
if tempo_inicial == tempo_final:
tempo_final = tempo_inicial + 1
make_curve(pontos,loop2)
# manejo materiais
insert_material(loop,loop2)
anima(tempo_inicial, tempo_final,loop2)
if tempo_final > last_frame: #encontrando ultimo frame
last_frame = tempo_final
bpy.context.scene.frame_current = 0 # retorna para frame inicial
# luz
bpy.ops.object.light_add(type='SUN', align='WORLD', location=(0, -5.04, 4.6), rotation=(1.05418, 0, 0), scale=(1, 1, 1))
##camera
bpy.ops.object.camera_add(enter_editmode=False, align='VIEW', location=(-1.7681, -5.40785, 1.12727), rotation=(87.3975/57.3, 0, -12.974/57.3))
bpy.context.scene.render.resolution_x = 1080
bpy.context.scene.render.resolution_y = 1920
bpy.data.objects['Camera'].select_set(True)
bpy.data.scenes[0].camera = bpy.data.objects['Camera']
# render
bpy.data.worlds["World"].node_tree.nodes["Background"].inputs[0].default_value = (0.8, 0.8, 0.8, 1) #background escuro
bpy.context.scene.frame_end = last_frame + 10
bpy.context.scene.eevee.use_bloom = True
bpy.context.scene.eevee.use_gtao = True
bpy.context.scene.eevee.use_ssr = True
bpy.context.scene.eevee.use_motion_blur = True
#save
bpy.ops.wm.save_mainfile() # salva como untitled.blend
print(f"frame final: {last_frame}")
print('Levou {} minutos'.format((time.time() - start_time)/60))
#include <stdio.h>
double mesmalinhac(int len)
{
FILE* dados;
double inicial[len];
double final[len];
int k1 = 8000;
int k2 = 100;
double linha[k1][k2][2];
double parametro = 0.00000000000002;
int n=0;
int check=0;
int count_bif;
int found;
FILE *flog = fopen("log.txt", "w");
dados = fopen("data.txt", "r");
for (int i = 0; i < len; ++i)
{
fscanf(dados,"%lf %lf",&inicial[i],&final[i]);
//armazena os dados na Matriz point
}
for (int loop = 0; loop < len; ++loop)
{
fprintf(flog,"começo %1.15f", inicial[loop]);
if (0.04252306640625 == inicial[loop])
{
fprintf(flog," OLHA ELEE");
}
// LINHA NOVA
found = 0;
check = n;
for (int c = 0; c < len; ++c)
{
if (inicial[loop] == final[c]) // if found == 0 nao tem inicial em finais
{
found ++;
break;
}
}
for (int i = 0; i < len; ++i) // nova linha
{
if (final[loop] == inicial[i] && found <1)
{
linha[n][0][0] = inicial[loop];
linha[n][0][1] = final[loop];
++n;
break;
}
}
if (n> check)
{
fprintf(flog," Nova\n");
continue;
}
// BIFURCAÇÃO:
count_bif = 0;
for (int i = 0; i < k1; ++i)
{
for (int j = 0; j < k2; ++j)
{
if (inicial[loop] == linha[i][j][0])
count_bif ++;
}
}
if (count_bif > 0)
{
fprintf(flog," bif %1.15f\n", inicial[loop]);
linha[n][0][0] = inicial[loop];
linha[n][0][1] = final[loop];
++n;
continue;
}
// LINHA JÁ EXISTENTE
int flag =0;
for (int i = 0; i < k1; ++i)
{
for (int j = 0; j < k2; ++j)
{
if (inicial[loop] == linha[i][j][1])
{
linha[i][j+1][0] = inicial[loop];
linha[i][j+1][1] = final[loop];
flag ++;
fprintf(flog," ENTRO em %1.15f\n",linha[i][0][0]);
break;
}
}
if (flag>0) break;
}
}
fclose(flog);
//saida
FILE *fp = fopen("dados_out.txt", "w");
fprintf(fp, "[");
for (int i = 0; i < len; ++i)
{
if (linha[i][0][1] > parametro && linha[i][0][0] > parametro)
fprintf(fp, "[");
for (int j = 0; j < len; ++j)
{
if (linha[i][j][1] > parametro && linha[i][j][0] > parametro)
fprintf(fp, "[%1.15f, %1.15f],", linha[i][j][0],linha[i][j][1]);
}
if (linha[i][0][1] > parametro && linha[i][0][0] > parametro)
fprintf(fp, "],");
}
fprintf(fp, "]");
fclose(fp);
return 0;
}
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment