VXL¶

This arrow is a collection of vital algorithms implemented with the VXL API

This arrow can be built by enabling the KWIVER_ENABLE_VXL CMake flag

This arrow contains the following functionality:

Bundle Adjust Algorithm¶

class bundle_adjust : public kwiver::vital::algorithm_impl<bundle_adjust, vital::algo::bundle_adjust>¶

A class for bundle adjustment of feature tracks using VXL.

Public Functions

bundle_adjust()¶: Constructor.

~bundle_adjust()¶: Destructor.

vital::config_block_sptr get_configuration() const¶: Get this algorithm’s configuration block .

void set_configuration(vital::config_block_sptr config)¶: Set this algorithm’s properties via a config block.

bool check_configuration(vital::config_block_sptr config) const¶: Check that the algorithm’s currently configuration is valid.

void optimize(vital::camera_map_sptr &cameras, vital::landmark_map_sptr &landmarks, vital::feature_track_set_sptr tracks, vital::metadata_map_sptr metadata = nullptr) const¶

Optimize the camera and landmark parameters given a set of feature tracks.

Parameters

cameras: the cameras to optimize
landmarks: the landmarks to optimize
tracks: the feature tracks to use as constraints
metadata: the frame metadata to use as constraints

class priv¶

Private implementation class.

Public Functions

priv()¶: Constructor.

Public Members

vpgl_bundle_adjust ba¶: the vxl sparse bundle adjustor

Camera Map Class¶

class camera_map : public kwiver::vital::camera_map¶

A concrete camera_map that wraps a map of vpgl_perspective_camera.

Public Types

typedef std::map<kwiver::vital::frame_id_t, vpgl_perspective_camera<double>> map_vcam_t¶: typedef for a map of frame numbers to vpgl_perspective_camera

Public Functions

camera_map()¶: Default Constructor.

camera_map(const map_vcam_t &cameras)¶: Constructor from a std::map of vpgl_perspective_camera.

virtual size_t size() const¶: Return the number of cameras in the map.

vital::camera_map::map_camera_t cameras() const¶: Return a map from integer IDs to camera shared pointers.

virtual map_vcam_t vpgl_cameras() const¶: Return underlying map from IDs to vpgl_perspective_camera.

Close Loops Homography Guided Algorithm¶

class close_loops_homography_guided : public kwiver::vital::algorithm_impl<vxl::close_loops_homography_guided, vital::algo::close_loops>¶

Attempts to stitch feature tracks over a long period of time.

This class attempts to make longer-term loop closures by utilizing a variety of techniques, one of which involves using homographies to estimate potential match locations in the past, followed up by additional filtering.

Public Functions

close_loops_homography_guided()¶: Default Constructor.

close_loops_homography_guided(const close_loops_homography_guided&)¶: Copy Constructor.

~close_loops_homography_guided()¶: Destructor.

vital::config_block_sptr get_configuration() const¶

Get this algorithm’s configuration block .

This base virtual function implementation returns an empty configuration block whose name is set to this->type_name.

Return: vital::config_block containing the configuration for this algorithm and any nested components.

void set_configuration(vital::config_block_sptr config)¶

Set this algorithm’s properties via a config block.

Exceptions

no_such_configuration_value_exception: Thrown if an expected configuration value is not present.
algorithm_configuration_exception: Thrown when the algorithm is given an invalid vital::config_block or is’ otherwise unable to configure itself.

Parameters

config: The vital::config_block instance containing the configuration parameters for this algorithm

bool check_configuration(vital::config_block_sptr config) const¶

Check that the algorithm’s currently configuration is valid.

This checks solely within the provided vital::config_block and not against the current state of the instance. This isn’t static for inheritence reasons.

Return

true if the configuration check passed and false if it didn’t.

Parameters

config: The config block to check configuration of.

feature_track_set_sptr stitch(vital::frame_id_t frame_number, vital::feature_track_set_sptr input, vital::image_container_sptr image, vital::image_container_sptr mask = vital::image_container_sptr()) const¶

Perform loop closure operation.

Return

an updated set of feature tracks after the stitching operation

Parameters

frame_number: the frame number of the current frame
input: the input feature track set to stitch
image: image data for the current frame
mask: Optional mask image where positive values indicate regions to consider in the input image.

class priv¶

Private implementation class.

Public Members

bool enabled_¶: Is long term loop closure enabled?

unsigned max_checkpoint_frames_¶: Maximum past search distance in terms of number of checkpoints.

double checkpoint_percent_overlap_¶: Term which controls when we make new loop closure checkpoints.

std::string homography_filename_¶: Output filename for homographies.

checkpoint_buffer_t buffer_¶: Buffer storing past homographies for checkpoint frames.

vital::algo::compute_ref_homography_sptr ref_computer_¶: Reference frame homography computer.

vital::algo::match_features_sptr matcher_¶: The feature matching algorithm to use.

Compute Homography Overlap¶

KWIVER_ALGO_VXL_EXPORT double kwiver::arrows::vxl::overlap(const vnl_double_3x3 & h, const unsigned ni, const unsigned nj)

Return the overlap between two images.

This function assumes that a homography perfectly describes the transformation between these 2 images (in some reference coordinate system). The overlap is returned as a percentage.

Estimate Canonical Transform Algorithm¶

class estimate_canonical_transform : public kwiver::vital::algorithm_impl<estimate_canonical_transform, vital::algo::estimate_canonical_transform>¶

Algorithm for estimating a canonical transform for cameras and landmarks.

A canonical transform is a repeatable transformation that can be recovered from data. In this case we assume at most a similarity transformation. If data sets P1 and P2 are equivalent up to a similarity transformation, then applying a canonical transform to P1 and separately a canonical transform to P2 should bring the data into the same coordinates.

This implementation first fits a “ground” plane to the landmark points using robust estimation methods provided by the rrel library in VXL. It then estimates the remaining degrees of freedom using PCA much like the implementation in the core plugin. The scale is set to normalize the landmarks to unit standard deviation.

Public Functions

estimate_canonical_transform()¶: Constructor.

~estimate_canonical_transform()¶: Destructor.

vital::config_block_sptr get_configuration() const¶: Get this algorithm’s configuration block .

void set_configuration(vital::config_block_sptr config)¶: Set this algorithm’s properties via a config block.

bool check_configuration(vital::config_block_sptr config) const¶: Check that the algorithm’s configuration config_block is valid.

kwiver::vital::similarity_d estimate_transform(kwiver::vital::camera_map_sptr const cameras, kwiver::vital::landmark_map_sptr const landmarks) const¶

Estimate a canonical similarity transform for cameras and points.

Return

An estimated similarity transform mapping the data to the canonical space.

Note

This algorithm does not apply the transformation, it only estimates it.

Parameters

cameras: The camera map containing all the cameras
landmarks: The landmark map containing all the 3D landmarks

Exceptions

algorithm_exception: When the data is insufficient or degenerate.

Estimate Essential Matrix Algorithm¶

class estimate_essential_matrix : public kwiver::vital::algorithm_impl<estimate_essential_matrix, vital::algo::estimate_essential_matrix>¶

A class that uses 5 pt algorithm to estimate an initial xform between 2 pt sets.

Public Functions

estimate_essential_matrix()¶: Constructor.

~estimate_essential_matrix()¶: Destructor.

vital::config_block_sptr get_configuration() const¶: Get this algorithm’s configuration block .

void set_configuration(vital::config_block_sptr config)¶: Set this algorithm’s properties via a config block.

bool check_configuration(vital::config_block_sptr config) const¶: Check that the algorithm’s currently configuration is valid.

virtual vital::essential_matrix_sptr estimate(const std::vector<vital::vector_2d> &pts1, const std::vector<vital::vector_2d> &pts2, const vital::camera_intrinsics_sptr cal1, const vital::camera_intrinsics_sptr cal2, std::vector<bool> &inliers, double inlier_scale = 1.0) const¶

Estimate an essential matrix from corresponding points.

Parameters

pts1: the vector or corresponding points from the first image
pts2: the vector of corresponding points from the second image
cal1: the intrinsic parameters of the first camera
cal2: the intrinsic parameters of the second camera
inliers: for each point pa:wir, the value is true if this pair is an inlier to the estimate
inlier_scale: error distance tolerated for matches to be inliers

class priv¶

Private implementation class.

Public Functions

priv()¶: Constructor.

Estimate Fundamental Matrix Algorithm¶

class estimate_fundamental_matrix : public kwiver::vital::algorithm_impl<estimate_fundamental_matrix, vital::algo::estimate_fundamental_matrix>¶

A class that uses 5 pt algorithm to estimate an initial xform between 2 pt sets.

Public Functions

estimate_fundamental_matrix()¶: Constructor.

~estimate_fundamental_matrix()¶: Destructor.

vital::config_block_sptr get_configuration() const¶: Get this algorithm’s configuration block .

void set_configuration(vital::config_block_sptr config)¶: Set this algorithm’s properties via a config block.

bool check_configuration(vital::config_block_sptr config) const¶

Check that the algorithm’s currently configuration is valid.

Check that the algorithm’s current configuration is valid.

virtual vital::fundamental_matrix_sptr estimate(const std::vector<vital::vector_2d> &pts1, const std::vector<vital::vector_2d> &pts2, std::vector<bool> &inliers, double inlier_scale = 1.0) const¶

Estimate an fundamental matrix from corresponding points.

Parameters

pts1: the vector or corresponding points from the first image
pts2: the vector of corresponding points from the second image
inliers: for each point pair, the value is true if this pair is an inlier to the estimate
inlier_scale: error distance tolerated for matches to be inliers

Public Static Functions

static void mark_inliers(vital::fundamental_matrix_sptr const &fm, std::vector<vital::vector_2d> const &pts1, std::vector<vital::vector_2d> const &pts2, std::vector<bool> &inliers, double inlier_scale = 1.0)¶

Test corresponding points against a fundamental matrix and mark inliers.

Parameters

fm: the fundamental matrix
pts1: the vector or corresponding points from the first image
pts2: the vector of corresponding points from the second image
inliers: for each point pair, the value is true if this pair is an inlier to the estimate
inlier_scale: error distance tolerated for matches to be inliers

Estimate Homography Algorithm¶

class estimate_homography : public kwiver::vital::algorithm_impl<estimate_homography, vital::algo::estimate_homography>¶

A class that uses RREL in VXL to estimate a homography from matching 2D points.

Public Functions

virtual vital::homography_sptr estimate(const std::vector<vital::vector_2d> &pts1, const std::vector<vital::vector_2d> &pts2, std::vector<bool> &inliers, double inlier_scale = 1.0) const¶

Estimate a homography matrix from corresponding points.

If estimation fails, a NULL-containing sptr is returned

Parameters

pts1: the vector or corresponding points from the source image
pts2: the vector of corresponding points from the destination image
inliers: for each point pair, the value is true if this pair is an inlier to the homography estimate
inlier_scale: error distance tolerated for matches to be inliers

Estimate Similarity Transform Algorithm¶

class estimate_similarity_transform : public kwiver::vital::algorithm_impl<estimate_similarity_transform, vital::algo::estimate_similarity_transform>¶

VXL implementation of similarity transform estimation.

Public Functions

virtual vital::similarity_d estimate_transform(std::vector<vital::vector_3d> const &from, std::vector<vital::vector_3d> const &to) const¶

Estimate the similarity transform between two corresponding point sets.

Return

An estimated similarity transform mapping 3D points in the from space to points in the to space (i.e. transforms from into to).

Parameters

from: List of length N of 3D points in the from space.
to: List of length N of 3D points in the to space.

Exceptions

algorithm_exception: When the from and to points sets are misaligned, insufficient or degenerate.

Image Container Class¶

class image_container : public kwiver::vital::image_container ¶

This image container wraps a vil_image_view.

This class represents an image using vil_image_view format to store the image data by extending the basic image_container.

Public Functions

image_container(const vil_image_view_base &d)¶: Constructor - from a vil_image_view_base.

image_container(const vil_image_view_base_sptr d)¶: Constructor - from a vil_image_view_base_sptr.

image_container(const vital::image &vital_image)¶: Constructor - convert vital image to vil.

image_container(const vital::image_container &image_cont)¶: Constructor - convert base image container to vil.

image_container(const arrows::vxl::image_container &other)¶: Copy Constructor.

size_t size() const¶

The size of the image data in bytes.

This size includes all allocated image memory, which could be larger than width*height*depth.

virtual size_t width() const¶: The width of the image in pixels.

virtual size_t height() const¶: The height of the image in pixels.

virtual size_t depth() const¶: The depth (or number of channels) of the image.

virtual vital::image get_image() const¶: Get an in-memory image class to access the data.

vil_image_view_base_sptr get_vil_image_view() const¶: Get image data in this container.

Public Static Functions

vital::image vxl_to_vital(const vil_image_view_base &img)¶: Convert a VXL vil_image_view to a VITAL image.

vil_image_view_base_sptr vital_to_vxl(const vital::image &img)¶: Convert a VITAL image to a VXL vil_image_view.

Image I/O Algorithm¶

class image_io : public kwiver::vital::algorithm_impl<image_io, vital::algo::image_io>¶

A class for using VXL to read and write images.

Public Functions

image_io()¶: Constructor.

~image_io()¶: Destructor.

vital::config_block_sptr get_configuration() const¶: Get this algorithm’s configuration block .

void set_configuration(vital::config_block_sptr config)¶: Set this algorithm’s properties via a config block.

bool check_configuration(vital::config_block_sptr config) const¶: Check that the algorithm’s currently configuration is valid.

Match Features Constrained Algorithm¶

class match_features_constrained : public kwiver::vital::algorithm_impl<match_features_constrained, vital::algo::match_features>¶

A match_feature algorithm that uses feature position, orientation, and scale constraints.

This matching algorithm assumes that the features to be matched are already somewhat well aligned geometrically. The use cases are very similar images (e.g. adjacent frames of video) and features that have been transformed into approximate alignment by a pre-processing step (e.g. image registration)

This algorithm first reduces the search space for each feature using a search radius in the space of location (and optionally orientation and scale) to find only geometrically nearby features. It then looks at the descriptors for the neighbors and finds the best match by appearance.

Public Functions

match_features_constrained()¶: Constructor.

~match_features_constrained()¶: Destructor.

vital::config_block_sptr get_configuration() const¶: Get this algorithm’s configuration block .

void set_configuration(vital::config_block_sptr config)¶: Set this algorithm’s properties via a config block.

bool check_configuration(vital::config_block_sptr config) const¶: Check that the algorithm’s configuration vital::config_block is valid.

vital::match_set_sptr match(vital::feature_set_sptr feat1, vital::descriptor_set_sptr desc1, vital::feature_set_sptr feat2, vital::descriptor_set_sptr desc2) const¶

Match one set of features and corresponding descriptors to another.

Return

a set of matching indices from feat1 to feat2

Parameters

feat1: the first set of features to match
desc1: the descriptors corresponding to feat1
feat2: the second set fof features to match
desc2: the descriptors corresponding to feat2

Optimize Cameras Algorithm¶

class optimize_cameras : public kwiver::vital::algorithm_impl<optimize_cameras, vital::algo::optimize_cameras>¶

Public Functions

void optimize(kwiver::vital::camera_perspective_sptr &camera, const std::vector<vital::feature_sptr> &features, const std::vector<vital::landmark_sptr> &landmarks, kwiver::vital::metadata_vector metadata = kwiver::vital::metadata_vector()) const¶

Optimize a single camera given corresponding features and landmarks.

This function assumes that 2D features viewed by this camera have already been put into correspondence with 3D landmarks by aligning them into two parallel vectors

Parameters

camera: The camera to optimize.
features: The vector of features observed by camera to use as constraints.
landmarks: The vector of landmarks corresponding to features.
metadata: The optional metadata to constrain the optimization.

Vital to VXL Algorithm¶

Warning

doxygenfunction: Unable to resolve multiple matches for function “kwiver::arrows::vxl::vital_to_vxl” with arguments () in doxygen xml output for project “kwiver” from directory: ./_build/xml. Potential matches:

- KWIVER_ALGO_VXL_EXPORT std::shared_ptr< vgl_polygon< double > > kwiver::arrows::vxl::vital_to_vxl(kwiver::vital::polygon_sptr)
- vil_memory_chunk_sptr kwiver::arrows::vxl::vital_to_vxl(const vital::image_memory_sptr)

VXL to Vital Algorithm¶

Warning

doxygenfunction: Unable to resolve multiple matches for function “kwiver::arrows::vxl::vxl_to_vital” with arguments () in doxygen xml output for project “kwiver” from directory: ./_build/xml. Potential matches:

- KWIVER_ALGO_VXL_EXPORT kwiver::vital::polygon_sptr kwiver::arrows::vxl::vxl_to_vital(const vgl_polygon< double > &)
- vital::image_memory_sptr kwiver::arrows::vxl::vxl_to_vital(const vil_memory_chunk_sptr)

Split Image Algorithm¶

class split_image : public kwiver::vital::algorithm_impl<split_image, vital::algo::split_image>¶

A class for drawing various information about feature tracks.

Public Functions

split_image()¶: Constructor.

~split_image()¶: Destructor.

virtual void set_configuration(kwiver::vital::config_block_sptr config)¶

Set this algorithm’s properties via a config block.

This method is called to pass a configuration to the algorithm. The implementation of this method should be light-weight and only save the necessary config values. Defer any substantial processing in another method.

Exceptions

no_such_configuration_value_exception: Thrown if an expected configuration value is not present.
algorithm_configuration_exception: Thrown when the algorithm is given an invalid config_block or is otherwise unable to configure itself.

Parameters

config: The config_block instance containing the configuration parameters for this algorithm

virtual bool check_configuration(kwiver::vital::config_block_sptr config) const¶

Check that the algorithm’s configuration config_block is valid.

This checks solely within the provided config_block and not against the current state of the instance. This isn’t static for inheritance reasons.

Return

true if the configuration check passed and false if it didn’t.

Parameters

config: The config block to check configuration of.

std::vector<kwiver::vital::image_container_sptr> split(kwiver::vital::image_container_sptr img) const¶: Split image.

Triangulate Landmarks Algorithm¶

class triangulate_landmarks : public kwiver::vital::algorithm_impl<triangulate_landmarks, vital::algo::triangulate_landmarks>¶

A class for triangulating landmarks from feature tracks and cameras using VXL.

Public Functions

triangulate_landmarks()¶: Constructor.

~triangulate_landmarks()¶: Destructor.

vital::config_block_sptr get_configuration() const¶: Get this algorithm’s configuration block .

void set_configuration(vital::config_block_sptr config)¶: Set this algorithm’s properties via a config block.

bool check_configuration(vital::config_block_sptr config) const¶: Check that the algorithm’s currently configuration is valid.

void triangulate(vital::camera_map_sptr cameras, vital::feature_track_set_sptr tracks, vital::landmark_map_sptr &landmarks) const¶

Triangulate the landmark locations given sets of cameras and feature tracks.

This function only triangulates the landmarks with indicies in the landmark map and which have support in the tracks and cameras

Parameters

cameras: the cameras viewing the landmarks
tracks: the feature tracks to use as constraints
landmarks: the landmarks to triangulate

FFMPEG Video Input Algorithm¶

class vidl_ffmpeg_video_input : public kwiver::vital::algorithm_impl<vidl_ffmpeg_video_input, vital::algo::video_input>¶

Video input using VXL vidl ffmpeg services.

This class implements a video input algorithm using the VXL vidl ffmpeg video services.

Public Functions

vidl_ffmpeg_video_input()¶: Constructor.

vital::config_block_sptr get_configuration() const¶: Get this algorithm’s configuration block .

void set_configuration(vital::config_block_sptr config)¶: Set this algorithm’s properties via a config block.

bool check_configuration(vital::config_block_sptr config) const¶: Check that the algorithm’s currently configuration is valid.

void open(std::string video_name)¶

Open a video stream.

This method opens the specified video stream for reading. The format of the name depends on the concrete implementation. It could be a file name or it could be a URI.

Capabilities are set in this call, so they are available after.

Note

Once a video is opened, it starts in an invalid state (i.e. before the first frame of video). You must call next_frame() to step to the first frame of video before calling frame_image().

Parameters

video_name: Identifier of the video stream.

Exceptions

exception: if open failed

void close()¶

Close video stream.

Close the currently opened stream and release resources. Closing a stream that is already closed does not cause a problem.

bool end_of_video() const¶

Return end of video status.

This method returns the end-of-video status of the input video. true is returned if the last frame has been returned.

This method will always return false for video streams that have no ability to detect end of video, such as network streams.

Return: true if at end of video, false otherwise.

bool good() const¶

Check whether state of video stream is good.

This method checks the current state of the video stream to see if it is good. A stream is good if it refers to a valid frame such that calls to frame_image() and frame_metadata() are expected to return meaningful data. After calling open() the initial video state is not good until the first call to next_frame().

Return: true if video stream is good, false if not good.

bool seekable() const¶

Return whether video stream is seekable.

This method returns whether the video stream is seekable.

Return: true if video stream is seekable, false otherwise.

size_t num_frames() const¶

Get the number of frames in the video stream.

Get the number of frames available in the video stream.

Return

the number of frames in the video stream, or 0 if the video stream is not seekable.

Exceptions

video_stream_exception: when there is an error in the video stream.

bool next_frame(kwiver::vital::timestamp &ts, uint32_t timeout = 0)¶

Advance to next frame in video stream.

This method advances the video stream to the next frame, making the image and metadata available. The returned timestamp is for new current frame.

The timestamp returned may be missing either frame number or time or both, depending on the actual implementation.

Calling this method will make a new image and metadata packets available. They can be retrieved by calling frame_image() and frame_metadata().

Check the HAS_TIMEOUT capability from the concrete implementation to see if the timeout feature is supported.

If the video input is already an end, then calling this method will return false.

Return

true if frame returned, false if end of video.

Parameters

ts: Time stamp of new frame.
timeout: Number of seconds to wait. 0 = no timeout.

Exceptions

video_input_timeout_exception: when the timeout expires.
video_stream_exception: when there is an error in the video stream.

bool seek_frame(kwiver::vital::timestamp &ts, kwiver::vital::timestamp::frame_t frame_number, uint32_t timeout = 0)¶

Seek to the given frame number in video stream.

This method seeks the video stream to the requested frame, making the image and metadata available. The returned timestamp is for new current frame.

The timestamp returned may be missing the time.

Calling this method will make a new image and metadata packets available. They can be retrieved by calling frame_image() and frame_metadata().

Check the HAS_TIMEOUT capability from the concrete implementation to see if the timeout feature is supported.

If the frame requested does not exist, then calling this method will return false.

If the video input is not seekable then calling this method will return false.

Return

true if frame returned, false if end of video.

Parameters

ts: Time stamp of new frame.
frame_number: The frame to seek to.
timeout: Number of seconds to wait. 0 = no timeout.

Exceptions

video_input_timeout_exception: when the timeout expires.
video_stream_exception: when there is an error in the video stream.

kwiver::vital::timestamp frame_timestamp() const¶

Obtain the time stamp of the current frame.

This method returns the time stamp of the current frame, if any, or an invalid time stamp. The returned time stamp shall have the same value as was set by the most recent call to next_frame().

This method is idempotent. Calling it multiple times without calling next_frame() will return the same time stamp.

Return: The time stamp of the current frame.

double frame_rate()¶

Get frame rate from the video.

If frame rate is not supported, return -1.

Return: Frame rate.

kwiver::vital::image_container_sptr frame_image()¶

Get current frame from video stream.

This method returns the image from the current frame. If the video input is already an end, then calling this method will return a null pointer.

This method is idempotent. Calling it multiple times without calling next_frame() will return the same image.

Return

Pointer to image container.

Exceptions

video_stream_exception: when there is an error in the video stream.

kwiver::vital::metadata_vector frame_metadata()¶

Get metadata collection for current frame.

This method returns the metadata collection for the current frame. It is best to call this after calling next_frame() to make sure the metadata and video are synchronized and that no metadata collections are lost.

Metadata typically occurs less frequently than video frames, so if you call next_frame() and frame_metadata() together while processing a video, there may be times where no metadata is returned. In this case an empty metadata vector will be returned.

Also note that the metadata collection contains a timestamp that can be used to determine where the metadata fits in the video stream.

In video streams without metadata (as determined by the stream capability), this method may return and empty vector, indicating no new metadata has been found.

Calling this method at end of video will return an empty metadata vector.

Metadata is returned as a vector, instead of a single object, to handle cases where there is multiple metadata packets between frames. This can happen in video streams with a fast metadata rate and slow frame rate. Multiple metadata objects can be also returned from video streams that contain metadata in multiple standards, such as MISB-601 and MISB-104.

In cases where there are multiple metadata packets between frames, it is inappropriate for the reader to try to select the best metadata packet. That is why they are all returned.

This method is idempotent. Calling it multiple times without calling next_frame() will return the same metadata.

Return

Vector of metadata pointers.

Exceptions

video_stream_exception: when there is an error in the video stream.

kwiver::vital::metadata_map_sptr metadata_map()¶

Get metadata map for video.

This method returns a metadata map for the video assuming the video is seekable. If the video is not seekable it will return an empty map. Depending on the implementation if the metamap has not been previously requested then the video will have to loop over to create and store the metadata map.

In video streams without metadata (as determined by the stream capability), this method will return an empty map, indicating no metadata has been found.

Return

Map of vectors of metadata pointers.

Exceptions

video_stream_exception: when there is an error in the video stream.

class priv¶

Public Functions

priv()¶: Constructor.

Public Members

bool c_use_metadata¶: If this is set then we ignore any metadata included in the video stream.

size_t d_num_frames¶: This holds the number of frames in the video. If it is set to -2 it means this number still needs to be calculated.

vital::metadata_map::map_metadata_t d_metadata_map¶: Storage for the metadata map.

bool d_have_frame_time¶: This is set to indicate that we can supply a frame time of some form. If this is false, the output timestamp will not have a time set. This also is used to report the HAS_FRAME_TIME capability.

bool d_have_abs_frame_time¶: This is set to indicate that we can supply an absolute frame time rather than a relative frame time. This value is used to report the HAS_ABSOLUTE_FRAME_TIME capability.

bool d_have_metadata¶: This is set to indicate we can supply video metadata and is used to report the HAS_METADATA capability.

bool d_is_seekable¶: This is set to indicate the video stream is seekable by frame and is used to report the IS_SEEKABLE capability.

bool d_have_loop_vars¶: This is set to indicate that any variables that require a pass through the video like the number of frames or the metadata map have already been determined.

Image Memory Class¶

class vil_image_memory : public kwiver::vital::image_memory¶

An image memory class that shares memory with VXL using vil_memory_chunk.

Public Functions

vil_image_memory(vil_memory_chunk_sptr chunk)¶: Constructor - allocates n bytes.

virtual void *data()¶: Return a pointer to the allocated memory.

vil_memory_chunk_sptr memory_chunk() const¶: Return the underlying vil_memory_chunk.

Image Memory Chunk Class¶

Warning

doxygenclass: Cannot find class “kwiver::arrows::vxl::vil_image_memory_chunk” in doxygen xml output for project “kwiver” from directory: ./_build/xml