def process_video(self, input_path, masks_path=None, video_path=None):
'''Detect edges using self.detector.
Args:
input_path: the input video path
masks_path: an optional path to write the per-frame edge masks (as
boolean arrays) in .npy files
video_path: an optional path to write the edges video
'''
# Ensure output directories exist
if masks_path:
etau.ensure_basedir(masks_path)
# VideoProcessor ensures that the output video directory exists
self.reset()
with etav.VideoProcessor(input_path, out_video_path=video_path) as p:
for img in p:
# Compute edges
edges = self.process_frame(img)
if masks_path:
# Write edges mask
edges_bool = edges.astype(np.bool)
np.save(masks_path % p.frame_number, edges_bool)
if video_path:
# Write edges video
p.write(cv2.cvtColor(edges, cv2.COLOR_GRAY2RGB))
def write(self, path, url, params=None):
'''Writes the URL content to the given local path.
The download is performed in chunks, so arbitrarily large files can
be downloaded. The output directory is created, if necessary.
Args:
path: the output path
url: the URL to get
params: optional dictionary of parameters for the URL
Raises:
WebSessionError: if the download failed
'''
r = self._get_streaming_response(url, params=params)
etau.ensure_basedir(path)
num_bytes = 0
start_time = time.time()
with open(path, "wb") as f:
for chunk in r.iter_content(None):
num_bytes += len(chunk)
f.write(chunk)
time_elapsed = time.time() - start_time
_log_download_stats(num_bytes, time_elapsed)
def write(self, path):
'''Writes the block diagram to disk, creating the output directory if
necessary.
'''
etau.ensure_basedir(path)
with open(path, "wb") as f:
f.write(self._file.render())
def __enter__(self):
self._idx = -1
etau.ensure_basedir(self.tf_records_path)
if self.num_shards:
self._num_shards = self.num_shards
tf_records_patt = self.tf_records_path + "-%05d-%05d"
tf_records_paths = [
tf_records_patt % (i, self.num_shards)
for i in range(1, self.num_shards + 1)
]
else:
self._num_shards = 1
tf_records_paths = [self.tf_records_path]
self._writers_context = contextlib.ExitStack()
c = self._writers_context.__enter__()
self._writers = [
c.enter_context(tf.io.TFRecordWriter(path))
for path in tf_records_paths
]
return self
def process_video(self, input_path, coords_path=None, video_path=None):
'''Detect feature points using self.detector.
Args:
input_path: the input video path
masks_path: an optional path to write the per-frame feature points
as .npy files
video_path: an optional path to write the feature points video
'''
# Ensure output directories exist
if coords_path:
etau.ensure_basedir(coords_path)
# VideoProcessor ensures that the output video directory exists
self.reset()
with etav.VideoProcessor(input_path, out_video_path=video_path) as p:
for img in p:
# Compute feature points
keypoints = self.process_frame(img)
if coords_path:
# Write feature points to disk
pts = _unpack_keypoints(keypoints)
np.save(coords_path % p.frame_number, pts)
if video_path:
# Write feature points video
# We pass in an RGB image b/c this function is invariant to
# channel order
img = cv2.drawKeypoints(
img, keypoints, None, color=self.KEYPOINT_RGB_COLOR)
p.write(img)
def write(img, path):
'''Writes image to file. The output directory is created if necessary.
Args:
img: a numpy array
path: the output path
'''
etau.ensure_basedir(path)
cv2.imwrite(path, _exchange_rb(img))
def download(self, file_id, local_path):
'''Downloads the file from Google Drive.
Args:
file_id: the ID of the file to download
local_path: the path to the storage location
'''
etau.ensure_basedir(local_path)
with open(local_path, "wb") as f:
self._do_download(file_id, f)
def download(self, cloud_path, local_path):
'''Downloads the file from Google Cloud Storage.
Args:
cloud_path: the path to the Google Cloud object to download
local_path: the local disk path to store the downloaded file
'''
blob = self._get_blob(cloud_path)
etau.ensure_basedir(local_path)
blob.download_to_filename(local_path)
def upload_bytes(self, bytes_str, storage_path):
'''Uploads the given bytes to storage.
Args:
bytes_str: the bytes string to upload
storage_path: the path to the storage location
'''
etau.ensure_basedir(storage_path)
with open(storage_path, "wb") as f:
f.write(bytes_str)
def upload_stream(self, file_obj, storage_path):
'''Uploads the contents of the given file-like object to storage.
Args:
file_obj: the file-like object to upload, which must be open for
reading
storage_path: the path to the storage location
'''
etau.ensure_basedir(storage_path)
with open(storage_path, "wb") as f:
for chunk in _read_file_in_chunks(file_obj, self.chunk_size):
f.write(chunk)
def download(self, url, local_path):
'''Downloads the file from the given URL via a GET request.
Args:
url: the URL from which to GET the file
local_path: the path to which to write the downloaded file
Raises:
`requests.exceptions.HTTPError`: if the request resulted in an HTTP
error
'''
etau.ensure_basedir(local_path)
with open(local_path, "wb") as f:
self._do_download(url, f)
def execute(parser, args):
if args.destination:
if sys.platform.startswith("win"):
raise RuntimeError(
"This command is currently not supported on Windows."
)
control_path = os.path.join(
foc.FIFTYONE_CONFIG_DIR, "tmp", "ssh.sock"
)
etau.ensure_basedir(control_path)
# Port forwarding
ret = subprocess.call(
[
"ssh",
"-f",
"-N",
"-M",
"-S",
control_path,
"-L",
"5151:127.0.0.1:%d" % args.port,
args.destination,
]
)
if ret != 0:
print("ssh failed with exit code %r" % ret)
return
def stop_port_forward():
subprocess.call(
[
"ssh",
"-S",
control_path,
"-O",
"exit",
args.destination,
],
stdout=subprocess.DEVNULL,
stderr=subprocess.DEVNULL,
)
fou.call_on_exit(stop_port_forward)
session = fos.launch_app()
_watch_session(session)
def process_video(
self, input_path, fgmask_path=None, fgvideo_path=None,
bgvideo_path=None):
'''Performs background subtraction on the given video.
Args:
input_path: the input video path
fgmask_path: an optional path to write the per-frame foreground
masks (as boolean arrays) in .npy files
fgvideo_path: an optional path to write the foreground-only video
bgvideo_path: an optional path to write the background video
'''
# Ensure output directories exist
if fgmask_path:
etau.ensure_basedir(fgmask_path)
# VideoWriters ensure that the output video directories exist
r = etav.FFmpegVideoReader(input_path)
try:
if fgvideo_path:
fgw = etav.FFmpegVideoWriter(
fgvideo_path, r.frame_rate, r.frame_size)
if bgvideo_path:
bgw = etav.FFmpegVideoWriter(
bgvideo_path, r.frame_rate, r.frame_size)
self.reset()
for img in r:
fgmask, bgimg = self.process_frame(img)
if fgmask_path:
# Write foreground mask
fgmask_bool = fgmask.astype(np.bool)
np.save(fgmask_path % r.frame_number, fgmask_bool)
if fgvideo_path:
# Write foreground-only video
fgw.write(apply_mask(img, fgmask))
if bgvideo_path:
# Write background video
bgw.write(bgimg)
finally:
if fgvideo_path:
fgw.close()
if bgvideo_path:
bgw.close()
def process_video(
self, input_path, cart_path=None, polar_path=None,
video_path=None):
'''Performs dense optical flow on the given video.
Args:
input_path: the input video path
cart_path: an optional path to write the per-frame arrays as .npy
files describing the flow fields in Cartesian (x, y)
coordinates
polar_path: an optional path to write the per-frame arrays as .npy
files describing the flow fields in polar (magnitude, angle)
coordinates
video_path: an optional path to write a video that visualizes the
magnitude and angle of the flow fields as the value (V) and
hue (H), respectively, of per-frame HSV images
'''
# Ensure output directories exist
if cart_path:
etau.ensure_basedir(cart_path)
if polar_path:
etau.ensure_basedir(polar_path)
# VideoProcessor ensures that the output video directory exists
self.reset()
with etav.VideoProcessor(input_path, out_video_path=video_path) as p:
for img in p:
# Compute optical flow
flow_cart = self.process_frame(img)
if cart_path:
# Write Cartesian fields
np.save(cart_path % p.frame_number, flow_cart)
if not polar_path and not video_path:
continue
# Convert to polar coordinates
flow_polar = cart_to_polar(flow_cart)
if polar_path:
# Write polar fields
np.save(polar_path % p.frame_number, flow_polar)
if video_path:
# Write flow visualization frame
p.write(polar_to_img(flow_polar))
def custom_setup(lc, rotate=False):
'''Sets up custom logging.
Args:
lc: a LoggingConfig instance
rotate: True/False. If True, any existing logs are rotated and
new messages are written to a new logfile. If False, new messages
are appended to the existing log (if any). The default is False
'''
# Messages to log after setup
msgs = []
# Reset logging
msgs.append("Resetting logging")
reset()
# Stdout logging
if lc.stream_to_stdout:
stream_handler = logging.StreamHandler(stream=sys.stdout)
stream_handler.setFormatter(
logging.Formatter(fmt=lc.stdout_format, datefmt=lc.datefmt))
stream_handler.setLevel(getattr(logging, lc.stdout_level))
root_logger.addHandler(stream_handler)
msgs.append("Logging to stdout at level %s" % lc.stdout_level)
# File logging
if lc.filename:
etau.ensure_basedir(lc.filename)
if rotate:
msgs += _rotate_logs(lc.filename)
file_handler = logging.FileHandler(
lc.filename, mode="at", encoding=lc.encoding)
file_handler.setFormatter(
logging.Formatter(fmt=lc.file_format, datefmt=lc.datefmt))
file_handler.setLevel(getattr(logging, lc.file_level))
root_logger.addHandler(file_handler)
msgs.append("Logging to %s at level %s" % (lc.filename, lc.file_level))
msgs.append("Logging initialized")
# Initial logging output
eta.startup_message()
for msg in msgs:
logger.info(msg)
def write_json(obj, path, pretty_print=True):
'''Writes JSON object to file, creating the output directory if necessary.
Args:
obj: is either an object that can be directly dumped to a JSON file or
an instance of a subclass of Serializable
path: the output path
pretty_print: when True (default), the resulting JSON will be outputted
to be human readable; when False, it will be compact with no
extra spaces or newline characters
'''
if is_serializable(obj):
obj = obj.serialize()
s = json_to_str(obj, pretty_print=pretty_print)
etau.ensure_basedir(path)
with open(path, "wt") as f:
f.write(s)
def _perform_convolution(convolution_config):
'''Performs convolution of an input image with a kernel specified
by the configuration parameters, and writes the result to the
path specified by "filtered_image".
Args:
convolution_config: the configuration file for the module
'''
kernel_type = convolution_config.parameters.kernel_type
if kernel_type == "x_derivative":
kernel = _create_x_derivative_kernel()
elif kernel_type == "y_derivative":
kernel = _create_y_derivative_kernel()
elif kernel_type == "sobel_vertical":
kernel = _create_sobel_vertical_kernel()
elif kernel_type == "sobel_horizontal":
kernel = _create_sobel_horizontal_kernel()
else:
# this will be the Gaussian kernel
# (make sure to remove this comment!)
kernel = _create_gaussian_kernel(
convolution_config.parameters.gaussian_sigma)
for data in convolution_config.data:
in_img = etai.read(data.input_image)
if convolution_config.parameters.image_type == "grayscale":
in_img = etai.rgb_to_gray(in_img)
else:
# if the image should be a color image, convert the grayscale
# image to color (simply converts the image into a 3-channel
# image)
if etai.is_gray(in_img):
in_img = etai.gray_to_rgb(in_img)
if convolution_config.parameters.image_max_range == 1:
in_img = (in_img.astype(float)) / 255.0
filtered_image = _convolve(kernel, in_img)
if data.filtered_matrix:
etau.ensure_basedir(data.filtered_matrix)
np.savez(data.filtered_matrix, filtered_matrix=filtered_image)
if data.filtered_image:
etau.ensure_basedir(data.filtered_image)
etai.write(filtered_image, data.filtered_image)
def embed_image(impath):
'''Embeds the image using VGG-16 and stores the embeddeding as an .npz file
on disk.
Args:
impath: path to an image to embed
'''
img = etai.read(impath)
rimg = etai.resize(img, 224, 224)
vgg16 = etav.VGG16()
embedded_vector = vgg16.evaluate([rimg], layer=vgg16.fc2l)[0]
logger.info("Image embedded to vector of length %d", len(embedded_vector))
logger.info("%s", embedded_vector)
outpath = _abspath("out/result_embed_image.npz")
etau.ensure_basedir(outpath)
np.savez_compressed(outpath, v=embedded_vector)
logger.info("Result saved to '%s'", outpath)
def embed_image(impath):
'''Embeds the image using VGG-16 and stores the embeddeding as an .npz file
on disk, using VideoFeaturizer to handle I/O.
Args:
impath: path to an image to embed
'''
img = etai.read(impath)
# Invoke the Featurizer using the "with" syntax to automatically handle
# calling the start() and stop() methods
with VGG16Featurizer() as vfeaturizer:
embedding = vfeaturizer.featurize(img)
logger.info("Image embedded to vector of length %d", len(embedding))
logger.info("%s", embedding)
outpath = _abspath("out/result_embed_image.npz")
etau.ensure_basedir(outpath)
np.savez_compressed(outpath, v=embedding)
logger.info("Result saved to '%s'", outpath)
def download_model(self, model_path, force=False):
'''Downloads the model to the given local path.
If the download is forced, any existing model is overwritten. If the
download is not forced, the model will only be downloaded if it does
not already exist locally.
Args:
model_path: the path to which to download the model
force: whether to force download the model. If True, the model is
always downloaded. If False, the model is only downloaded if
necessary. The default is False
Raises:
ModelError: if model downloading is not currently allowed
'''
if force or not os.path.isfile(model_path):
if not eta.config.allow_model_downloads:
raise ModelError(
"Model downloading is currently disabled. Modify your ETA "
"config to change this setting.")
etau.ensure_basedir(model_path)
self._download_model(model_path)
def _find_corners(harris_corner_config):
for data in harris_corner_config.data:
sobel_horiz = np.load(data.sobel_horizontal_result)["filtered_matrix"]
sobel_vert = np.load(data.sobel_vertical_result)["filtered_matrix"]
corner_response, corner_locations = _get_harris_corner(
sobel_horiz, sobel_vert,
harris_corner_config.parameters.window_half_size,
harris_corner_config.parameters.threshold)
corner_locs_after_sup = non_max_suppression(
corner_response, harris_corner_config.parameters.non_max_radius)
if data.corner_locations:
etau.ensure_basedir(data.corner_locations)
np.savez(data.corner_locations,
corner_locations=corner_locs_after_sup)
if data.corners_img_before_sup or data.corners_img_after_sup:
in_img = etai.read(data.input_image)
if data.corners_img_before_sup:
corners_viz_before_sup = _visualize_corners(
in_img, corner_locations)
etai.write(corners_viz_before_sup, data.corners_img_before_sup)
if data.corners_img_after_sup:
corners_viz_after_sup = _visualize_corners(
in_img, corner_locs_after_sup)
etai.write(corners_viz_after_sup, data.corners_img_after_sup)
def pickle(self, path):
'''Saves the instance to disk in a pickle. '''
etau.ensure_basedir(path)
with open(path, "wb") as f:
pickle.dump(self, f)
}
},
{
"$project": {
"name": k,
"type": v.__class__.__name__[
: -len("Field") # grab field type from the class
].lower(),
"data": "$data",
}
},
]
socketio.on_namespace(StateController("/state"))
if __name__ == "__main__":
log_path = os.path.join(
foc.FIFTYONE_CONFIG_DIR, "var", "log", "server.log"
)
etau.ensure_basedir(log_path)
# pylint: disable=no-member
app.logger.addHandler(logging.FileHandler(log_path, mode="w"))
parser = argparse.ArgumentParser()
parser.add_argument("--port", type=int, default=5151)
args = parser.parse_args()
socketio.run(app, port=args.port, debug=foc.DEV_INSTALL)
