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

BlenderVisu/Script_C/CP_withC.py

+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))

BlenderVisu/Script_C/mesmalinha.c

+#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;
+}