def graficoPCF_concentracion(Archivos,pCF_distance,Concentraciones,R0,Size,Frames,Clock,movil=0,Tipo_movil=False):
Tiempo_pixel=1/Clock
spri=[]
taus=[]
for i in Archivos:
Matriz=FCS.read_B64(i,Size=[Frames,Size,Size])
if R0[1]+pCF_distance>Size:
return print('La pCF distance %s es mayor que el Size. Se sugiere cambiar R0' %(i))
a,b=sprite.PCF(Matriz=Matriz,R0=R0,R1=np.array([R0[0]+pCF_distance,R0[1]]),Tiempo_pixel=Tiempo_pixel)
spri.append(a)
taus.append(b)
plt.figure('PSF individual')
if movil ==0:
for i in range(len(Archivos)):
plt.plot(taus[i],spri[i],'-',label='Conc.=%s nM' %(Concentraciones[i]))
else:
for i in range(len(Archivos)):
plt.plot(sprite.moving_average(taus[i],n=movil,Especial=Tipo_movil),sprite.moving_average(spri[i], n=movil,Especial=Tipo_movil),'-',label='Conc.=%s nM' %(Concentraciones[i]))
plt.xscale('log')
plt.grid()
plt.title('pCF distancia= %s' %(pCF_distance))
plt.ylabel('Correlación')
plt.xlabel('Tiempo de Correlación (s)')
# plt.ylim([0,0.04])
plt.legend()
plt.savefig(Archivos[0] +' pcf=%s movil=%s especial=%s.jpg' %(pCF_distance,movil,Tipo_movil), dpi=250)
plt.show()
plt.close()
def graficoPCF_distance(Archivo,pCF_distances,R0,Size,Frames,Clock,movil=0,Tipo_movil=False,D=0):
Tiempo_pixel=1/Clock
Matriz=FCS.read_B64(Archivo,Size=[Frames,Size,Size])
spri=[]
taus=[]
for i in pCF_distances:
# if R0[1]+i>Size:
# return print('La pCF distance %s es mayor que el Size. Se sugiere cambiar R0' %(i))
a,b=sprite.PCF(Matriz=Matriz,R0=R0,R1=np.array([R0[0],R0[1]+i]),Tiempo_pixel=Tiempo_pixel)
spri.append(a)
taus.append(b)
plt.figure('PSF individual')
if movil ==0:
for i in range(len(pCF_distances)):
plt.plot(taus[i],spri[i],'-',label='PCF=%s' %(pCF_distances[i]))
else:
for i in range(len(pCF_distances)):
plt.plot(sprite.moving_average(taus[i],n=movil,Especial=Tipo_movil),sprite.moving_average(spri[i], n=movil,Especial=Tipo_movil),'-',label='PCF=%s' %(pCF_distances[i]))
if D!=0:
plt.title('D=%s' %(D))
plt.xscale('log')
plt.grid()
plt.ylabel('Correlación')
plt.xlabel('Tiempo de Correlación (s)')
# plt.ylim([0,0.22])
# plt.xlim([10**(-4),0.1])
plt.legend()
plt.savefig(Archivo +' D=%s pcf individual movil=%s especial=%s,5.jpg' %(D,movil,Tipo_movil), dpi=250)
plt.show()
plt.close()
def pCF_linea(Matriz,
R0,
R1,
Tiempo_pixel,
Tiempo_retorno_linea=0,
Tiempo_imagen=0,
logtime=False,
Movil_log=0,
Quitar0=True):
Frames = len(Matriz[:, 0, 0])
# Size=len(Matriz[0,:,0])
# P0=Matriz[:,R0,0]
# P1=Matriz[:,R1,0]
Size = len(Matriz[0, 0, :])
P0 = Matriz[:, 0, R0]
P1 = Matriz[:, 0, R1]
if Tiempo_imagen == 0:
Tiempo_imagen = Tiempo_pixel * Size + Tiempo_retorno_linea
if Quitar0 == True:
G = FCS.corrlineal_fft(P0, P1)[1:]
else:
G = FCS.corrlineal_fft(P0, P1)
if max(G) > 100:
G = G * 0
Tiempo_retrazo = (R1 - R0) * Tiempo_pixel
if Quitar0 == True:
Tau = np.linspace(1, int(Frames / 2),
int(Frames / 2) - 1) * Tiempo_imagen + Tiempo_retrazo
else:
Tau = np.linspace(0,
int(Frames / 2) - 1, int(
Frames / 2)) * Tiempo_imagen + Tiempo_retrazo
if Movil_log == 0:
if logtime == False:
return np.array(G), np.array(Tau)
if logtime == True:
Tau = np.log10(Tau)
return np.array(G), np.array(Tau)
else:
G = FCS.moving_average(G, Movil_log, Especial=True)
if logtime == False:
Tau = FCS.moving_average(Tau, Movil_log, Especial=True)
if logtime == True:
Tau = np.log10(FCS.moving_average(Tau, Movil_log, Especial=True))
return np.array(G), np.array(Tau)
def smoot_horizontal(Matriz, Movil):
if Movil != 0:
N_Matriz = []
for i in range(len(Matriz[0, :])):
N_Matriz.append(FCS.moving_average(Matriz[:, i], Movil))
return np.transpose(np.array(N_Matriz))
else:
return Matriz
def PCF(Matriz,R0,R1,Tiempo_pixel,Tiempo_retorno_linea=0,Tiempo_retorno_final=0,Tiempo_imagen=0):
Frames=len(Matriz)
Size=len(Matriz[0])
P0=Matriz[:,R0[0],R0[1]]
if Tiempo_imagen==0:
Tiempo_imagen=Tiempo_pixel*Size**2+Tiempo_retorno_linea*Size+Tiempo_retorno_final
G=FCS.corrlineal_fft(P0,Matriz[:,R1[0],R1[1]])
Tiempo_retrazo=(R1[0]-R0[0])*Tiempo_pixel+(R1[1]-R0[1])*(Tiempo_retorno_linea+Size*Tiempo_pixel)
Tau=np.linspace(0,int(Frames/2)-1,int(Frames/2))*Tiempo_imagen+Tiempo_retrazo
return np.array(G),np.array(Tau)
def sprite(Matriz,R0,R1,Tiempo_pixel,Tiempo_retorno_linea=0,Tiempo_retorno_final=0,Tiempo_imagen=0):
Frames=len(Matriz)
Size=len(Matriz[0])
P0=Matriz[:,R0[0],R0[1]]
G=[]
if Tiempo_imagen==0:
Tiempo_imagen=Tiempo_pixel*Size**2+Tiempo_retorno_linea*Size+Tiempo_retorno_final
Tau=[]
for i in range(len(R1[0])):
G.append(FCS.corrlineal_fft(P0,Matriz[:,R1[0][i],R1[1][i]]))
Tiempo_retrazo=(R1[0][i]-R0[0])*Tiempo_pixel+(R1[1][i]-R0[1])*(Tiempo_retorno_linea+Size*Tiempo_pixel)
Tau.append(np.linspace(0,int(Frames/2)-1,int(Frames/2))*Tiempo_imagen+Tiempo_retrazo)
return np.array(G),np.array(Tau)
def spriteseparada(Matriz,R0,R1):
P0=Matriz[:,R0[0],R0[1]]
G=[]
for i in range(len(R1[0])):
G.append(FCS.corrlineal_fft(P0,Matriz[:,R1[0][i],R1[1][i]]))
return np.array(G)
for i in range(len(Matriz[0, :])):
N_Matriz.append(FCS.moving_average(Matriz[:, i], Movil))
return np.transpose(np.array(N_Matriz))
else:
return Matriz
# Archivo=r'C:\Users\admin\Desktop\imagenes\inicio lineas\Line Scan difusion isotropica 2D sin barreras tp_1us - 100 ciclos1.b64'
# Archivo=r'C:\Users\admin\Desktop\imagenes\inicio lineas\line scan usando mascara1.b64' #256
# Archivo=r'C:\Users\admin\Desktop\Line Scan41.b64' #64
Archivo = r'C:\Users\admin\Desktop\tesis de licenciatura\back up manu\2018-11-27\mcherry_6hs_cell2_line_2cells.lsm' #64
Tipo_archivo = 'lsm' #lsm o b64
Cantidad_lineas = 60000
if Tipo_archivo == 'lsm':
Matriz = FCS.read_LSM(Archivo)[:Cantidad_lineas]
else:
Matriz = FCS.read_B64(Archivo, Size=64, Voltear=False, Line=True)
Tiempo_pixel = 3.07 * 10**(-6)
PCF = 8 #distancia de la PCF
movil = 3 #cuanto promediamos al comienzo, tratar de no usar
especial = True #para aplicar el promedio logaritmico
horizontal_movil = 3 #usar numeros impares, es el smoot horizontal
G, T = pCF_lineasgrid(Matriz=Matriz,
PCF=PCF,
Tiempo_pixel=Tiempo_pixel,
logtime=especial,
Movil_log=movil)
G = smoot_horizontal(G, horizontal_movil)
num = num + Matriz[i, R0[0], R0[1]] * Matriz[i + j, R1[0], R1[1]]
denominador = np.mean(
Matriz[:(len(Matriz[:, 0, 0]) - j), R0[0], R0[1]]) * np.mean(
Matriz[:(len(Matriz[:, 0, 0]) - j), R1[0], R1[1]])
G.append(num / (denominador * (len(Matriz[:, 0, 0]) - j)) - 1)
return np.array(G)
#==============================================================================
# Defino variables
#==============================================================================
Archivo = Archivo4
pCF_distance = 4
R0 = np.array([14, 14])
# x1,y1=np.array(sprite.puntos_correlacion(pCF_distance))
Matriz = FCS.read_B64(Archivo, Size=32)
Frames = len(Matriz)
Size = len(Matriz[0])
Tiempo_pixel = 1 / 10000000
movil = 0
Tipo_movil = True
#==============================================================================
# Grafico la pCF
#==============================================================================
Matriz = FCS.read_B64(Archivo, Size=32)
Matriz = Matriz[:50000, :, :]
sprits = []
R00 = []
i = 0
rules_outh = rulesh[['Colors']]
rules_outs = ruless[['Colors']]
###### Grid Wellbeing#####
n=0
grid_wellbeing = pd.DataFrame(columns=['Visits','Mind Exercise','FamilyInt','Color MCGDM','Weight MCGDM','Color FCS','MV FCS'])
for nvisits in range(0,30,2):
for texercise in range(0,120,6):
for temp in range(0,30,2):
in_values_wellbeing = {"num_visits": nvisits/30,"t_exercise": texercise/120,"ext_temp": temp/30}
in_valueswb = Wellbeing(in_values_wellbeing["num_visits"],
in_values_wellbeing["t_exercise"],
in_values_wellbeing["ext_temp"])
wellbeingm= MCGDM(inputs_wellbeing, rules_inpw, in_valueswb.mv_wellbeing(), rules_outw)
wellbeingf= FCS(inputs_wellbeing, rules_inpw, in_valueswb.mv_wellbeing(), rules_outw)
grid_wellbeing.loc[len(grid_wellbeing)] = [nvisits,texercise, temp, wellbeingm.weight()[0],wellbeingm.weight()[1],wellbeingf.color(),wellbeingf.defuzzification()]
n+=1
print(n)
# i+=1
grid_wellbeing.to_csv('grid_finalwb.csv')
###### Grid Health #####
n=0
grid_health= pd.DataFrame(columns=['Medicine','Physical Exercise','Ext Temperature','Color MCGDM','Weight MCGDM','Color FCS','MV FCS'])
for meds in range(0,100,5):
print(meds)
for pressure in range(0,120,6):
print(pressure)
Movil_log=Movil_log)
G.append(Lineas[0])
T.append(Lineas[1])
return np.array(G), np.array(T)
def smoot_horizontal(Matriz, Movil):
N_Matriz = []
for i in range(len(Matriz[0, :])):
N_Matriz.append(FCS.moving_average(Matriz[:, i], Movil))
return np.transpose(np.array(N_Matriz))
# Archivo=r'C:\Users\admin\Desktop\inicio lineas\Line Scan difusion isotropica 2D sin barreras tp_1us - 100 ciclos1.b64'
Archivo = r'C:\Users\admin\Desktop\inicio lineas\line scan usando mascara1.b64'
Matriz = FCS.read_B64(Archivo, Size=256, Voltear=False, Line=True)
Tiempo_pixel = 10**(-6)
PCF = 0
lineas = pCF_lineas(Matriz=Matriz, PCF=PCF, Tiempo_pixel=Tiempo_pixel)
movil = 3
horizontal_movil = 25
especial = True
colores = True #para hacer los colores a mano
fig = plt.figure('Alfombra')
ax = Axes3D(fig)
plt.ion()
mz = 2