def _track_process(self, group_number): data_name = (str(group_number) + '.hdf5' if self.multiprocess else self.dataname) with dataframes.DataStore(data_name, load=False) as data: data.add_metadata('num_frames', self.num_frames) data.add_metadata('video_filename', self.vidname) data.add_metadata('crop', self.manager.preprocessor.crop) start = self.frame_div * group_number vid = video.ReadVideo(self.vidname) vid.set_frame(start) if group_number == 3: missing = self.num_frames - self.num_processes * ( self.frame_div) frame_div = self.frame_div + missing else: frame_div = self.frame_div # Iterate over frames for f in tqdm(range(frame_div), 'Tracking'): frame = vid.read_next_frame() info, boundary, info_headings = self.manager.analyse_frame( frame) data.add_tracking_data(start + f, info, col_names=info_headings) if f == 0: data.add_metadata('boundary', boundary)
def extra_steps(self, filename): vid_name = filename + ".MP4" data_name = filename + ".hdf5" with dataframes.DataStore(data_name, True) as d: f = d.metadata['num_frames'] duty_cycle = read_audio_file(vid_name, f) d.add_frame_property('Duty', duty_cycle)
def calculate_and_save_data(files): for file in tqdm(files): filename = os.path.splitext(os.path.split(file)[1])[0] rate, direction, trial = filename.split('_') trial = int(trial) df = dataframes.DataStore(file).df df.Duty = df.Duty.round() df = filter_box(df, 750, 1250, 750, 1250) result = df.groupby('frame')[PARAMETER].mean() result.to_csv(f'{save_direc}/{rate}_{direction}_{trial}')
def create_csv(file): filename = os.path.splitext(os.path.split(file)[1])[0] rate, direction, trial = filename.split('_') trial = int(trial) with dataframes.DataStore(file) as data: df = data.df df.Duty = df.Duty.round() df = filter_hexagon(df, data.metadata['boundary'], 0.8) df = df.groupby('Duty')[PARAMETER].mean() df.to_csv(f'{save_direc}/{rate}_{direction}_{trial}')
def check(filename): core_name = os.path.splitext(filename)[0] vid_name = core_name + '.MP4' data_name = core_name + '.hdf5' out_name = core_name + '_check.png' data = dataframes.DataStore(data_name) crop = data.metadata['crop'] vid = video.ReadVideo(vid_name) print(vid_name) frames = np.arange(4)*vid.num_frames//4 ims = [images.crop(vid.read_frame(f), crop) for f in frames] circles = [data.get_info(f, ['x', 'y', 'r']) for f in frames] new_ims = [images.draw_circles(im, c) for im, c in zip(ims, circles)] out = images.vstack(images.hstack(new_ims[0], new_ims[1]), images.hstack(new_ims[2], new_ims[3])) images.save(out, out_name)
import filehandling from particletracking import dataframes import numpy as np import pandas as pd import os import matplotlib.pyplot as plt directory = filehandling.open_directory('/media/data/Data') files = filehandling.get_directory_filenames(directory + '/*.hdf5') duties = np.arange(750, 525, 25) numbers = np.arange(1700, 2400, 50) counts = {n: {d: 0 for d in duties} for n in numbers} for file in files: filename = os.path.splitext(os.path.split(file)[1])[0] number, duty = filename.split('_') number = int(number) duty = int(duty) data = dataframes.DataStore(file) order = data.df.order count = np.count_nonzero(order > 0.95) / len(order) counts[number][duty] = count # print(count) counts = pd.DataFrame(counts) counts.plot() plt.show()
def run(): direc = "/media/data/Data/FirstOrder/Interfaces/RecordFluctuatingInterfaceJanuary2020/Quick/first_frames" savename = f"{direc}/data_new.hdf5" files = filehandling.get_directory_filenames(direc + '/*.png') ims = [images.load(f, 0) for f in tqdm(files, 'Loading images')] ims = [images.bgr_to_gray(im) for im in ims] circles = [images.find_circles(im, 27, 200, 7, 16, 16) for im in tqdm(ims, 'Finding Circles')] data = dataframes.DataStore(savename, load=False) for f, info in tqdm(enumerate(circles), 'Adding Circles'): data.add_tracking_data(f, info, ['x', 'y', 'r']) calc = statistics.PropertyCalculator(data) calc.order() lattice_spacing = 10 x = np.arange(0, ims[0].shape[1], lattice_spacing) y = np.arange(0, ims[0].shape[0], lattice_spacing) x, y = np.meshgrid(x, y) # cgw = get_cgw(data.df.loc[0], 1.85) # k=1.85 looked the best cgw = get_cgw(data.df.loc[0], 1.85) fields = [coarse_order_field(data.df.loc[f], cgw, x, y) for f in tqdm(range(len(ims)), 'Calculating Fields')] field_threshold = get_field_threshold(fields, lattice_spacing, ims[0]) contours = [find_contours(f, field_threshold) for f in tqdm(fields, 'Calculating contours')] # Multiply the contours by the lattice spacing and squeeze contours = [c.squeeze() * lattice_spacing for c in contours] # Close contours contours = [close_contour(c) for c in contours] # Convert to LineString contours = [LineString(c) for c in contours] # Select the line to query the points across print("Select the line to query points") ls = LineSelector(ims[0]) p1, p2 = ls.points centre_line = get_extended_centre_line(p1, p2) # Distance between query points that determines one end of the frequency dL = data.df.loc[0].r.mean() / 10 L = np.sqrt((p1[0]-p2[0])**2+(p1[1]-p2[1])**2) N_query = int(L/dL) xq, yq = np.linspace(p1[0], p2[0], N_query), np.linspace(p1[1], p2[1], N_query) dL = np.sqrt((xq[1] - xq[0]) ** 2 + (yq[1] - yq[0]) ** 2) dists, crosses = zip( *[get_dists(xq, yq, c, centre_line) for c in tqdm(contours)]) # plot_crosses(crosses, ims) # Select points from inside red edge to inside red edge across the centre # of the tray which is 200mm to convert pixels to mm PIX_2_mm = get_pix_2_mm(ims[0]) plot_fft(dists, dL, PIX_2_mm, data.df.loc[0].r.mean(), cgw)
'0.6': ['16870001', '16870002'], '0.2': ['16870005', '16870006'], '0.1': ['16870007', '16870008'], '0.05': ['16870009', '16870010'], '0.8': ['16870011', '16870012'], '1': ['16870013', '16870014'], '2': ['16870015', '16870016'] } files = {r: [direc + d, direc + u] for r, (d, u) in files.items()} for i, (rate, (down, up)) in enumerate(files.items()): print(i) print(rate) fig, ax = plt.subplots() ax.set_title(rate) down_data = dataframes.DataStore(down + '.hdf5') up_data = dataframes.DataStore(up + '.hdf5') if i == 0: up_video = video.ReadVideo(up + '.MP4') frame = up_video.read_next_frame() frame = images.crop(frame, up_data.metadata['crop']) result = images.crop_polygon(frame) bbox = result.bbox with open(save_direc + 'bbox.txt', 'w') as f: f.writelines([ 'BBOX xmin, xmax, ymin, ymax', str(bbox.xmin), str(bbox.xmax), str(bbox.ymin), str(bbox.ymax)
def run(direc, lattice_spacing=5): files = filehandling.get_directory_filenames(direc + '/*.png') print(files) savename = direc + '/data.hdf5' N = len(files) # load images ims = [images.load(f, 0) for f in tqdm(files, 'Loading images')] images.display(ims[0]) # Find Circles ims = [images.bgr_to_gray(im) for im in ims] circles = [ images.find_circles(im, 27, 200, 7, 16, 16) for im in tqdm(ims, 'Finding Circles') ] # Save data data = dataframes.DataStore(savename, load=False) for f, info in tqdm(enumerate(circles), 'Adding Circles'): data.add_tracking_data(f, info, ['x', 'y', 'r']) # Calculate order parameter calc = statistics.PropertyCalculator(data) calc.order() # Get the course graining width cgw = get_cgw(data.df.loc[0]) / 2 # Create the lattice points x = np.arange(0, max(data.df.x), lattice_spacing) y = np.arange(0, max(data.df.y), lattice_spacing) x, y = np.meshgrid(x, y) # Calculate the coarse order fields fields = [ coarse_order_field(data.df.loc[f], cgw, x, y) for f in tqdm(range(N), 'Calculating Fields') ] # Calculate the field threshold field_threshold = get_field_threshold(fields, lattice_spacing, ims[0]) # Find the contours representing the boundary in each frame contours = [ find_contours(f, field_threshold) for f in tqdm(fields, 'Calculating contours') ] # Multiply the contours by the lattice spacing contours = [c * lattice_spacing for c in contours] # Find the angle of the image to rotate the boundary to the x-axis a, c, p1, p2 = get_angle(ims[0]) print(p1) print(p2) # Rotate the selection points and the contours by the angle p1 = rotate_points(np.array(p1), c, a) p2 = rotate_points(np.array(p2), c, a) contours = [rotate_points(contour.squeeze(), c, a) for contour in contours] xmin = int(p1[0]) xmax = int(p2[0]) h = int(p1[1]) # Get the heights of the fluctuations from the straight boundary hs = [ get_h(contour, ims[0].shape, xmin, xmax, h) for contour in tqdm(contours, 'Calculating heights') ] # Calculate the fourier transforms for all the frames L = xmax - xmin pixels_to_mms = 195 / L print("pixels_to_mms = ", pixels_to_mms) # convert to mm hs = [h * pixels_to_mms for h in hs] L = L * pixels_to_mms x = np.linspace(0, L, len(hs[0])) np.savetxt(direc + '/x.txt', x) np.savetxt(direc + '/hs.txt', hs) # k, yplot = get_fourier(hs, L) return k, yplot
from particletracking import dataframes data = dataframes.DataStore("/media/NAS/share/James/HighSpeed/test.hdf5") print(data.df.head())
import filehandling from particletracking import dataframes import trackpy as tp # direc1 = filehandling.open_directory(initialdir='/media/data/Data') # files1 = filehandling.get_directory_filenames(direc1+'/*.hdf5') # # direc2 = filehandling.open_directory(initialdir='/media/data/Data') # files2 = filehandling.get_directory_filenames(direc1+'/*.hdf5') # # files = files1 + files2 files = ["/media/data/Data/FirstOrder/PhaseDiagram/FlatPlate2Feb2021/2000.hdf5",] for file in files: with dataframes.DataStore(file) as data: d = data.df.copy() print(d.head()) d = d.reset_index() print(d.head()) d = tp.link(d, d.r.mean())