def emulate_high_query(self,
vid_name,
low_images_direc,
req_regions,
iter=None):
images_direc = f"{vid_name}-cropped" #-{iter}"
# self.logger.info(f"images_direc: {images_direc}")
# Extract images from encoded video
extract_images_from_video(images_direc, req_regions)
if not os.path.isdir(images_direc):
self.logger.error("Images directory was not found but the "
"second iteration was called anyway")
return Results()
fnames = sorted([f for f in os.listdir(images_direc) if "png" in f])
# Make seperate directory and copy all images to that directory
merged_images_direc = os.path.join(images_direc, "merged")
os.makedirs(merged_images_direc, exist_ok=True)
for img in fnames:
shutil.copy(os.path.join(images_direc, img), merged_images_direc)
# self.logger.info(f"{merged_images_direc}, {low_images_direc}")
merged_images = merge_images(merged_images_direc, low_images_direc,
req_regions)
results, _ = self.perform_detection(merged_images_direc,
self.config.high_resolution,
fnames, merged_images)
results_with_detections_only = Results()
for r in results.regions:
if r.label == "no obj":
continue
results_with_detections_only.add_single_result(
r, self.config.intersection_threshold)
high_only_results = Results()
area_dict = {}
for r in results_with_detections_only.regions:
frame_regions = req_regions.regions_dict[r.fid]
regions_area = 0
if r.fid in area_dict:
regions_area = area_dict[r.fid]
else:
regions_area = compute_area_of_frame(frame_regions)
area_dict[r.fid] = regions_area
regions_with_result = frame_regions + [r]
total_area = compute_area_of_frame(regions_with_result)
extra_area = total_area - regions_area
if extra_area < 0.05 * calc_area(r):
r.origin = "high-res"
high_only_results.append(r)
# shutil.rmtree(merged_images_direc)
return results_with_detections_only
def analyze_video_mpeg(self, video_name, raw_images_path, enforce_iframes):
number_of_frames = len(
[f for f in os.listdir(raw_images_path) if ".png" in f])
final_results = Results()
final_rpn_results = Results()
total_size = 0
for i in range(0, number_of_frames, self.config.batch_size):
start_frame = i
end_frame = min(number_of_frames, i + self.config.batch_size)
batch_fnames = sorted([
f"{str(idx).zfill(10)}.png"
for idx in range(start_frame, end_frame)
])
req_regions = Results()
for fid in range(start_frame, end_frame):
req_regions.append(
Region(fid, 0, 0, 1, 1, 1.0, 2,
self.config.low_resolution))
batch_video_size, _ = compute_regions_size(
req_regions, f"{video_name}-base-phase", raw_images_path,
self.config.low_resolution, self.config.low_qp,
enforce_iframes, True)
self.logger.info(f"{batch_video_size / 1024}KB sent "
f"in base phase using {self.config.low_qp}QP")
extract_images_from_video(f"{video_name}-base-phase-cropped",
req_regions)
results, rpn_results = (self.server.perform_detection(
f"{video_name}-base-phase-cropped", self.config.low_resolution,
batch_fnames))
self.logger.info(f"Detection {len(results)} regions for "
f"batch {start_frame} to {end_frame} with a "
f"total size of {batch_video_size / 1024}KB")
final_results.combine_results(results,
self.config.intersection_threshold)
final_rpn_results.combine_results(
rpn_results, self.config.intersection_threshold)
# Remove encoded video manually
shutil.rmtree(f"{video_name}-base-phase-cropped")
total_size += batch_video_size
final_results = merge_boxes_in_results(final_results.regions_dict, 0.3,
0.3)
final_results.fill_gaps(number_of_frames)
# Add RPN regions
final_results.combine_results(final_rpn_results,
self.config.intersection_threshold)
final_results.write(video_name)
return final_results, [total_size, 0]
def perform_low_query(self, vid_data):
# Write video to file
with open(os.path.join("server_temp", "temp.mp4"), "wb") as f:
f.write(vid_data.read())
# Extract images
# Make req regions for extraction
start_fid = self.curr_fid
end_fid = min(self.curr_fid + self.config.batch_size, self.nframes)
self.logger.info(f"Processing frames from {start_fid} to {end_fid}")
req_regions = Results()
for fid in range(start_fid, end_fid):
req_regions.append(
Region(fid, 0, 0, 1, 1, 1.0, 2, self.config.low_resolution))
extract_images_from_video("server_temp", req_regions)
fnames = [f for f in os.listdir("server_temp") if "png" in f]
results, rpn = self.perform_detection("server_temp",
self.config.low_resolution,
fnames)
batch_results = Results()
batch_results.combine_results(results,
self.config.intersection_threshold)
# need to merge this because all previous experiments assumed
# that low (mpeg) results are already merged
batch_results = merge_boxes_in_results(batch_results.regions_dict, 0.3,
0.3)
batch_results.combine_results(rpn, self.config.intersection_threshold)
detections, regions_to_query = self.simulate_low_query(
start_fid, end_fid, "server_temp", batch_results.regions_dict,
False, self.config.rpn_enlarge_ratio, False)
self.last_requested_regions = regions_to_query
self.curr_fid = end_fid
# Make dictionary to be sent back
detections_list = []
for r in detections.regions:
detections_list.append(
[r.fid, r.x, r.y, r.w, r.h, r.conf, r.label])
req_regions_list = []
for r in regions_to_query.regions:
req_regions_list.append(
[r.fid, r.x, r.y, r.w, r.h, r.conf, r.label])
return {"results": detections_list, "req_regions": req_regions_list}
def simulate_low_query(self,
start_fid,
end_fid,
images_direc,
results_dict,
simulation=True,
rpn_enlarge_ratio=0.0,
extract_regions=True):
if extract_regions:
# If called from actual implementation
# This will not run
base_req_regions = Results()
for fid in range(start_fid, end_fid):
base_req_regions.append(
Region(fid, 0, 0, 1, 1, 1.0, 2,
self.config.high_resolution))
extract_images_from_video(images_direc, base_req_regions)
batch_results = Results()
self.logger.info(f"Getting results with threshold "
f"{self.config.low_threshold} and "
f"{self.config.high_threshold}")
# Extract relevant results
for fid in range(start_fid, end_fid):
fid_results = results_dict[fid]
for single_result in fid_results:
single_result.origin = "low-res"
batch_results.add_single_result(
single_result, self.config.intersection_threshold)
detections = Results()
# rpn_regions = Results()
# Divide RPN results into detections and RPN regions
for single_result in batch_results.regions:
if (single_result.conf > self.config.prune_score
and single_result.label == "vehicle"):
detections.add_single_result(
single_result, self.config.intersection_threshold)
# else:
# rpn_regions.add_single_result(
# single_result, self.config.intersection_threshold)
#regions_to_query = self.get_regions_to_query(rpn_regions, detections)
regions_to_query = self.get_regions_to_query_new(
start_fid, end_fid, self.low_configuration_results,
self.high_configuration_results)
return detections, regions_to_query