def directory_to_data(directory, verbose=True):
if verbose:
print("Processing " + directory)
relative_class_dirs = [x for x in next(os.walk(directory))[1]]
class_dirs = [directory + "/" + x for x in next(os.walk(directory))[1]]
class_to_id = {key: value for (value, key) in enumerate(relative_class_dirs)}
if verbose:
print(class_to_id)
id_to_class = {key: value for (key, value) in enumerate(relative_class_dirs)}
X, y, image_names = list(), list(), list()
for class_dir in relative_class_dirs:
class_id = int(class_to_id[class_dir])
class_dir = directory + "/" + class_dir
if verbose:
print("Processing " + class_dir)
image_files = general_utils.get_all_files(class_dir)
for image_file in image_files:
image = cv2.imread(class_dir + "/" + image_file, 0)
_, _, k_number = image_file[:-4].split("_")
image_names.append(id_to_class[class_id] + "_karyotyping_" + k_number)
X.append(image)
y.append(class_id)
X = np.asarray(X)
y = np.asarray(y)
return X, y, id_to_class, image_names
def get_num_data(directory):
count = 0
class_dirs = [directory + "/" + x for x in next(os.walk(directory))[1]]
for class_dir in class_dirs:
image_files = general_utils.get_all_files(class_dir)
count += len(image_files)
return count
def frame_files_to_video(frames_path, video_path, fps=24):
frame_files = general_utils.get_all_files(frames_path,
keep_dir=True,
sort=True)
frame_array = []
for frame_file in frame_files:
# reading each files
img = cv2.imread(frame_file)
height, width, layers = img.shape
size = (width, height)
# inserting the frames into an image array
frame_array.append(img)
out = cv2.VideoWriter(video_path, cv2.VideoWriter_fourcc(*'DIVX'), fps,
size)
for i in range(len(frame_array)):
# writing to a image array
out.write(frame_array[i])
out.release()
def detection_by_tracking(
frame_dir,
json_file,
tracker_model,
detection_threshold=0.9,
tracking_threshold=0.9,
save_json_file="data/demo_tracking/detection_by_tracking.tracking_json",
offset=0,
low=None,
high=None,
step=1,
parallel=False,
multithreading=False):
# Load annotations
data = json.load(open(json_file, "r"))
annotations = dict()
for annotation in data['annotations']:
if annotation['image_id'] in annotations:
annotations[annotation['image_id']] += [annotation]
else:
annotations[annotation['image_id']] = [annotation]
# Load frames
frame_files = general_utils.get_all_files(frame_dir,
keep_dir=True,
sort=True)
num_frame = len(frame_files)
tracking_data = dict()
tracking_data["images"] = data["images"]
tracking_data["categories"] = data["categories"]
tracking_data["annotations"] = list()
if low is None:
low = -int(1e9)
if high is None:
high = int(1e9)
start = time.time()
last_count = 0
# Set up parallel processing
if parallel:
mp.set_start_method('spawn', force=True)
mp.set_sharing_strategy('file_system')
pool = Pool()
else:
pool = None
results = [None for _ in range(num_frame)]
# Set up multithreading processing
if multithreading:
executor = ThreadPoolExecutor()
else:
executor = None
# Loop over frames
for frame_id in range(num_frame):
# Align id
frame_id += offset
num_box = len(annotations[frame_id])
# Count boxes with high confidence
count = 0
for box_id in range(num_box):
score = annotations[frame_id][box_id]["score"]
if score > detection_threshold:
count += 1
# If this frame has more boxes, track from it for certain; else check skip criteria
if count <= last_count:
last_count = count
# Skip frame
if frame_id % step != 0:
continue
else:
last_count = count
print("Process frame ", frame_id)
forward_tracker = build_tracker(tracker_model)
backward_tracker = build_tracker(tracker_model)
# Loop over detection boxes
for box_id in range(num_box):
# print("=> Process box ", box_id)
# Filter by detection score
score = annotations[frame_id][box_id]["score"]
if score < detection_threshold:
# print("==> Skip")
continue
if multithreading:
print(
f"---> Multithread tracking for box {box_id} frame {frame_id}"
)
executor.submit(single_box_in_single_frame_tracking,
(frame_files, frame_id, box_id, annotations,
tracking_threshold, forward_tracker,
backward_tracker, offset, low, high))
if parallel:
print(
f"---> Parallel tracking for box {box_id} frame {frame_id}"
)
results[frame_id - offset] = pool.apply_async(
single_box_in_single_frame_tracking, [
frame_files, frame_id, box_id, annotations,
tracking_threshold, forward_tracker, backward_tracker,
offset, low, high
])
if not multithreading and not parallel:
tracking_data[
"annotations"] += single_box_in_single_frame_tracking(
frame_files, frame_id, box_id, annotations,
tracking_threshold, forward_tracker, backward_tracker,
offset, low, high)
for result in results:
if result is not None:
tracking_data["annotations"] += result.get()
end = time.time()
print(f"Total time: {(end - start)} s")
with open(save_json_file, "w") as outfile:
json.dump(tracking_data, outfile)
# "badWeather/skating": 800,
# "badWeather/snowFall": 800
# }
if to_gif:
from util import general_utils
import imageio
import numpy as np
import cv2
test_dir = args.data_dir
start_idx = args.start_frame
concat_axis = 0
result_files = general_utils.get_all_files("tmp", keep_dir=True)
result_files = sorted(result_files)
if view_train:
num_file = 240
else:
num_file = len(result_files)
frames = list()
for i in range(num_file):
original = imageio.imread(
f"{test_dir}/input/in{'{:06d}'.format(i + start_idx)}.jpg")
original = cv2.resize(original, (128, 128))
if view_train:
foreground = imageio.imread(
import numpy as np
import cv2
from tqdm import tqdm
import argparse
parser = argparse.ArgumentParser(description='tracking demo')
parser.add_argument('--raw_dir', type=str, help='path to frame files')
parser.add_argument('--tracking_dir', type=str, help='path to tracking_json')
parser.add_argument('--result_dir',
type=str,
help='path to save visualized results')
args = parser.parse_args()
raw_detection = general_utils.get_all_files(args.raw_dir,
keep_dir=True,
sort=True)
tracking_detection = general_utils.get_all_files(args.tracking_dir,
keep_dir=True,
sort=True)
general_utils.create_directory(args.result_dir)
num_frame = len(raw_detection)
for i in tqdm(range(num_frame)):
raw = image_utils.read_image(raw_detection[i])
tracking = image_utils.read_image(tracking_detection[i])
combined = np.concatenate([raw, tracking], axis=1)
cv2.imwrite(f"{args.result_dir}/frame_{'{:06d}'.format(i + 1)}.jpg",
U = U + Eta * (X_cat - U)
V = V + Eta * (torch.pow(X_cat, 2) - V)
return U, V, N, prob
if __name__ == '__main__':
eta = 0.01
k = 3
c = 3
"""
baseline/highway
"""
frame_dir = "/Users/lekhang/Desktop/Khang/data/highway/input"
frame_files = general_utils.get_all_files(f"{frame_dir}", keep_dir=True)
frame_files = sorted(frame_files)
frame_0 = cv2.imread(frame_files[0], 0)
h, w = frame_0.shape
U = np.array([np.array(cv2.imread(frame_files[i], 0).flatten()) / 255. for i in range(k)]).T
U = np.random.rand(*U.shape) # TODO: set this make the result look very good - why?
assert U.shape == (h * w, k)
V = U ** 2
N = np.ones((h * w, k))
U2 = torch.from_numpy(np.random.rand(1, c * k, h, w)).float()
V2 = torch.pow(U2, 2)
N2 = torch.ones((1, c * k, h, w)).float()