def __init__(self, port=None):
if port is None:
filedialogs.load_filename('Select a serial device',
directory='/dev/serial/by-id/',
file_filter=None)
super().__init__(port)
self.read_all()
def load_mesh_constraints(op_filename=None,directory='/home/ppzmis/Documents/PythonScripts/FEM'):
if op_filename is None:
op_filename = load_filename(directory=directory, file_filter='*.h5')
hf = h5py.File(op_filename, 'r')
known_displacements = hf.get('displacements')
known_forces = hf.get('forces')
return known_displacements, known_forces
def __init__(self,
filename=None,
mpp=1,
fps=30.0,
rad=None,
max_lag=100,
temp=293):
'''
:param filename: DataStore filename
:param mpp: microns per pixel
:param fps: frames per second of movie
:param rad: radius of particles in microns
:param max_lag: maximum lag time in seconds - NB this is different to trackpy which measures this in frames
:param temp: temperature of experiment
All output quantities such as emsd and creep are in microns and seconds.
Creep in SI.
'''
if filename is None:
filename = load_filename(file_filter='*.hdf5')
self.filename = filename
self.data = dataframes.DataStore(filename)
self.df = self.data.df
self.df_subset = self.df.copy()
self.mpp = mpp
self.fps = fps
self.rad = rad
self.max_lag = int(max_lag * fps)
self.temp = temp
def __init__(self,filename=None):
'''
Initialise video reading object
if filename = None user must select filename with dialogue
'''
if filename == None:
filename = fd.load_filename(caption='select movie filename', file_filter='*.avi;;*.mp4;;*.*')
self.filename = filename
self.open_video()
self.get_vid_props()
def load_config(self, filename=None, parent=None):
if filename is None:
filename = load_filename(directory=self.cam_config_dir,
file_filter='*.ccf',
parent=parent)
self.cam_dict = load_dict_from_file(filename)
self._load_cam_config()
SISO.Fg_loadConfig(self.fg, filename[:-3] + 'mcf')
print('new config loaded')
def calculate_corr_data(file=None, rmin=1, rmax=20, dr=0.02):
if file is None:
file = filedialogs.load_filename()
new_file = file[:-5] + '_corr.hdf5'
if not os.path.exists(new_file):
data = dataframes.DataStore(file)
calc = statistics.PropertyCalculator(data)
res = calc.correlations_all_duties(rmin, rmax, dr)
res = res.reset_index()
res.to_hdf(new_file, 'df')
else:
print('file already exists')
def load_mesh_from_file(filename=None,directory='/home/ppzmis/Documents/PythonScripts/FEM'):
if filename is None:
filename=load_filename(directory=directory,file_filter='*.h5')
hf = h5py.File(filename, 'r')
node_pts = np.array(hf.get('node_pts'))
elements = np.array(hf.get('elements'))
if 'vals' in hf.keys():
values = np.array(hf.get('vals'))
else:
values = np.ones(np.shape(elements)[0])
return (node_pts,elements,values)
def __init__(self, filename=None, grayscale=False, return_function=None):
'''
Initialise video reading object
if filename = None user must select filename with dialogue
'''
if filename is None:
filename = fd.load_filename(
caption='select movie filename',
file_filter='*.avi;;*.MP4;;*.mp4;;*.tif;;*.*')
self.filename = filename
self.grayscale = grayscale
self.return_func = return_function
self._detect_file_type()
self.open_video()
self.get_vid_props()
def load_cam_settings(self, filename=None):
if filename is None:
filename = load_filename(file_filter='*.camlog')
with open(filename, 'r') as settings_file:
settings_list = settings_file.read().splitlines()
self.brightness = settings_list[0]
self.contrast = settings_list[1]
self.gain = settings_list[2]
self.saturation = settings_list[3]
self.hue = settings_list[4]
self.exposure = settings_list[5]
self.set_cam_props('brightness', self.brightness)
self.set_cam_props('contrast', self.contrast)
self.set_cam_props('gain', self.gain)
self.set_cam_props('saturation', self.saturation)
self.set_cam_props('hue', self.hue)
self.set_cam_props('exposure', self.exposure)
-------
ing: annotated image
Same shape and type as input image
"""
voro = sp.Voronoi(points)
ridge_vertices = voro.ridge_vertices
new_ridge_vertices = []
for ridge in ridge_vertices:
if -1 not in ridge:
new_ridge_vertices.append(ridge)
img = draw_polygons(img, voro.vertices[new_ridge_vertices], color=PINK)
return img
if __name__ == "__main__":
filename = fd.load_filename()
img = load_img(filename)
display(img)
#width, height = get_width_and_height(img)
crop_inst = CropShape(img, 1)
mask, crop, boundary, crop_points = crop_inst.begin_crop()
masked_im = mask_img(img, mask)
masked_and_cropped = crop_img(masked_im, crop)
display(masked_and_cropped, 'masked and cropped')
img = ~img
def up_and_down(file1, file2):
data1 = dataframes.DataStore(file1)
data2 = dataframes.DataStore(file2)
duty1, order1 = duty_order(data1)
duty2, order2 = duty_order(data2)
plotter = plotting.Plotter()
plotter.add_plot(duty1, order1, label='up')
plotter.add_plot(duty2, order2, label='down')
plotter.configure_legend()
plotter.show_figure()
def duty_order(data):
fdata = data.frame_data
fdata = fdata.groupby('Duty').mean()
return fdata.index.values, fdata['mean order'].values
if __name__ == "__main__":
from Generic import filedialogs
file1 = filedialogs.load_filename('Select a dataframe',
directory="/media/data/Data",
file_filter='*.hdf5')
file2 = filedialogs.load_filename('Select a dataframe',
directory="/media/data/Data",
file_filter='*.hdf5')
up_and_down(file1, file2)
frame_order(file1)
# order_histogram(filename, np.arange(0, 20000, 1000))
import numpy as np
import Generic.filedialogs as fd
import matplotlib.pyplot as plt
import Generic.plotting as p
if __name__ == '__main__':
scale=3.215E-1 #microm/pixel
fps=2.0
filename = fd.load_filename(directory='/media/ppzmis/data/Cracks/2020_02_14',file_filter='*.txt')
crack_width = np.loadtxt(filename)
#Calculate crack tip trajectory
tip_pos=np.zeros(np.shape(crack_width[:,1]))
rad_tip=np.zeros(np.shape(tip_pos))
for i in range(np.shape(crack_width)[0]-1):
index = np.max(np.where(crack_width[i,:] > 1))
tip_pos[i]=index
rad_tip[i]=np.max(np.sum(crack_width[:,index-50:index]))
time = (1/fps)*np.arange(0,np.size(tip_pos))
tip_pos = scale*tip_pos
rad_tip = scale * rad_tip/2
np.savetxt(filename[:-4] + '_tiptraj.txt',np.c_[time,tip_pos])
%lprun -f ParticleSimulator.evolve benchmark()
%mprun -f benchmark_memory benchmark_memory()
'''
#Define particles
n_particles = 300
particles = [Particle([0 , 0, 0], [0,0,0]) for i in range(n_particles)]
#Define simulation boundary
scene = Scene()
#Data dump every dt
dt = 1
time_step = 0.001
t_sim = 10
filename_sim = load_filename(directory='/home/mike/Documents/particle_sim/init_sim/',
file_filter='*.sim_setup')
filename_scene = load_filename(directory='/home/mike/Documents/particle_sim/init_sim/', file_filter='*.scene')
filename_op = dirname(filename_sim) + '/../sim_output/' + splitext(basename(filename_sim))[0] + '.sim_result'
with open(filename_op, "a+") as f:
# Create simulation
simulator = ParticleSimulator(f,particles,time_step)
simulator.store_particle_data(particles)
for i in range(int(t_sim/dt)):
simulator.evolve(dt)
simulator.store_particle_data(particles)
self.param_dict['window'][0],
self.param_dict['constant'][0],
self.param_dict['invert'][0])
watershed_img = watershed(
self.im0.copy(),
watershed_threshold=self.param_dict['watershed_thresh'][0],
block_size=self.param_dict['window'][0],
constant=self.param_dict['constant'][0],
mode=self.param_dict['invert'][0])
self._display_img(thresh, watershed_img)
if __name__ == "__main__":
"""
Relative import will break when running this file as top-level
Run functions from images as images.function_name
"""
from Generic import video, images, filedialogs
file = filedialogs.load_filename('Load a video')
vid = video.ReadVideo(file)
# frame = images.bgr_2_grayscale(frame)
images.CircleGui(vid)
# images.ThresholdGui(vid)
# images.AdaptiveThresholdGui(vid)
#images.ContoursGui(vid,thickness=-1)
#images.InrangeGui(vid)
#images.DistanceTransformGui(vid)
# images.WatershedGui(vid)
# images.RotatedBoxGui(vid)
import matplotlib.pyplot as plt
import numpy as np
from Generic import filedialogs
from ParticleTracking import dataframes
# %%
file = filedialogs.load_filename(file_filter='*.hdf5')
data = dataframes.DataStore(file)
data.df['order_mag'] = np.abs(data.df.order_i + data.df.order_r)
bins = [400, 450, 500, 550, 600, 650, 700, 750, 800, 850, 900, 950, 1000]
orders = []
for i in range(len(bins) - 1):
orders.append(
data.df.loc[(data.df.Duty >= bins[i]) * (data.df.Duty <= bins[i + 1]),
'order_mag'].values)
fig, ax = plt.subplots()
for i, order in enumerate(orders):
freq, hist_bins = np.histogram(order,
bins=np.arange(0, 1.01, 0.01),
density=True)
ax.plot(hist_bins[:-1],
freq,
label=str(bins[i]) + ' to ' + str(bins[i + 1]))
ax.legend()
ax.set_title(file)
ax.set_xlabel('Order')
def choose_port(self, os='linux'):
if os == 'linux':
self.port.port = fd.load_filename('Choose a comport',
directory='/dev/')
def load_lut(self, filename=None):
if filename is None:
load_filename(directory=self.cam_config_dir, file_filter='*.lut')
self._upload_cam_commands(self.lut_script)
order_edge = df.loc[d, ['order_abs', 'on_edge']]
orders = order_edge.reset_index().set_index('on_edge').loc[
False, 'order_abs'].values
print(orders)
freq, bins = np.histogram(orders, bins=100, density=True)
ax.plot(bins[:-1], freq, label=d)
ax.legend(title='Duty Cycle')
ax.set_xlabel('Order')
ax.set_ylabel('Frequency')
ax.set_title(file)
plt.show()
if __name__ == "__main__":
import matplotlib as mpl
import os
sns.set_context('notebook')
file = filedialogs.load_filename('Load a dataframe', '/media/data/data',
'*.hdf5')
mpl.rcParams["savefig.directory"] = os.path.split(file)[0]
data = dataframes.DataStore(file)
# duty_curve(data.df)
df_up, df_down = split_df(data.df)
# order_duty(df_up, df_down)
duties = list(range(400, 1050, 50))
order_histograms(df_down, duties)
from ParticleTracking.tracking import james_nitrile as jn
from Generic import video, filedialogs
import matplotlib.pyplot as plt
import numpy as np
file = filedialogs.load_filename(directory="/media/data/Data")
vid = video.ReadVideo(file)
frames = vid.num_frames
freqs = jn.read_audio_file(file, frames)
d = np.round((freqs - 1000) / 15)
fig, ax = plt.subplots()
frames = list(range(frames))
ax.plot(frames, d)
ax.set_xlabel('frame')
ax.set_ylabel('Duty Cycle / 1000')
ax2 = ax.twinx()
ax2.plot(frames, d)
ax2.set_ylabel('Frequency (Hz)')
plt.show()
from ParticleTracking import dataframes
from Generic import plotting
import matplotlib.pyplot as plt
import numpy as np
def histogram(file, duty):
data = dataframes.DataStore(file)
print(data.frame_data.head())
df = data.frame_data.merge(data.df.drop('frame', 1).reset_index()).set_index('Duty')
p = plotting.Plotter()
for d in duty:
orders = df.loc[d, 'real order']
n, bins = np.histogram(orders, bins=100, density=True)
p.add_plot(bins[:-1]+(bins[1]-bins[0])/2, n*(bins[1]-bins[0]), label=d)
p.configure_legend()
p.configure_xaxis(xlabel='Order Parameter')
p.configure_yaxis(ylabel='Relative Frequency')
if __name__ == "__main__":
from Generic import filedialogs
file = filedialogs.load_filename()
histogram(file, [600, 620, 640, 660, 680, 700])
# histogram(file, [500, 600, 700, 800, 900])
from Generic.fitting import Fit
from Generic.filedialogs import load_filename
import numpy as np
if __name__ == '__main__':
filename = load_filename(directory='/media/ppzmis/SAMSUNG/crackbranching/CrackHoppingVids', file_filter='*.txt')
time = np.loadtxt(filename, usecols=0)
width = np.loadtxt(filename, usecols=1)
shift_time = 133
shift_width = 40
time=time-shift_time
width = width - shift_width
indices = width > 0
indices2 = time > 0
indices = indices * indices2
time = time[indices]
width = width[indices]
print(time)
print(width)
#f1 = Fit('linear', x=np.log(time), y=np.log(width))
f1 = Fit('flipped_exponential', x=time, y=width)
f2 = Fit('double_flipped_exponential', x=time, y=width)
#logic1 = time > 200
logic2 = time > 200
#f1.plot_data()
