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::algo::bundle_adjust

A class for bundle adjustment of feature tracks using VXL.

Public Functions

PLUGIN_INFO ("vxl", "Use VXL (vpgl) to bundle adjust cameras and landmarks.") bundle_adjust(): Constructor.

virtual ~bundle_adjust(): Destructor.

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

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

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

virtual void optimize(vital::camera_map_sptr &cameras, vital::landmark_map_sptr &landmarks, vital::feature_track_set_sptr tracks, vital::sfm_constraints_sptr constraints = nullptr) const

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

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

Parameters:

cameras – [inout] the cameras to optimize
landmarks – [inout] the landmarks to optimize
tracks – [in] the feature tracks to use as constraints
metadata – [in] the frame metadata to use as constraints

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

inline camera_map(): Default Constructor.

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

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

virtual map_camera_t cameras() const: Return a map from integer IDs to camera shared pointers.

inline 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::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

PLUGIN_INFO ("vxl_homography_guided", "Use VXL to estimate a sequence of ground plane homographies to identify " "frames to match for loop closure.") close_loops_homography_guided(): Default Constructor.

close_loops_homography_guided(const close_loops_homography_guided&): Copy Constructor.

virtual ~close_loops_homography_guided(): Destructor.

virtual 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.

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

virtual void set_configuration(vital::config_block_sptr config)

Set this algorithm’s properties via a config block

Throws:

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

virtual 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.

Parameters:: config – The config block to check configuration of.
Returns:: true if the configuration check passed and false if it didn’t.

virtual vital::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.

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.

Returns:

an updated set of feature tracks after the stitching operation

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

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::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

PLUGIN_INFO ("vxl_plane", "Use VXL (rrel) to robustly estimate a ground plane for a canonical transform.") estimate_canonical_transform(): Constructor.

virtual ~estimate_canonical_transform(): Destructor.

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

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

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

virtual 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

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

Throws:

algorithm_exception – When the data is insufficient or degenerate.

Returns:

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

class priv

Estimate Essential Matrix Algorithm

class estimate_essential_matrix : public kwiver::vital::algo::estimate_essential_matrix

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

Public Functions

PLUGIN_INFO ("vxl", "Use VXL (vpgl) to estimate an essential matrix.") estimate_essential_matrix(): Constructor.

virtual ~estimate_essential_matrix(): Destructor.

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

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

virtual 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 – [in] the vector or corresponding points from the first image
pts2 – [in] the vector of corresponding points from the second image
cal1 – [in] the intrinsic parameters of the first camera
cal2 – [in] the intrinsic parameters of the second camera
inliers – [out] for each point pa:wir, the value is true if this pair is an inlier to the estimate
inlier_scale – [in] error distance tolerated for matches to be inliers

class priv

Private implementation class.

Public Functions

inline priv(): Constructor.

Estimate Fundamental Matrix Algorithm

class estimate_fundamental_matrix : public kwiver::vital::algo::estimate_fundamental_matrix

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

Public Functions

PLUGIN_INFO ("vxl", "Use VXL (vpgl) to estimate a fundamental matrix.") estimate_fundamental_matrix(): Constructor.

virtual ~estimate_fundamental_matrix(): Destructor.

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

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

virtual bool check_configuration(vital::config_block_sptr config) const: Check that the algorithm’s currently 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 – [in] the vector or corresponding points from the first image
pts2 – [in] the vector of corresponding points from the second image
inliers – [out] for each point pair, the value is true if this pair is an inlier to the estimate
inlier_scale – [in] 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 – [in] the fundamental matrix
pts1 – [in] the vector or corresponding points from the first image
pts2 – [in] the vector of corresponding points from the second image
inliers – [out] for each point pair, the value is true if this pair is an inlier to the estimate
inlier_scale – [in] error distance tolerated for matches to be inliers

Estimate Homography Algorithm

class estimate_homography : public kwiver::vital::algo::estimate_homography: A class that uses RREL in VXL to estimate a homography from matching 2D points.

Estimate Similarity Transform Algorithm

class estimate_similarity_transform : public kwiver::vital::algo::estimate_similarity_transform: VXL implementation of similarity transform estimation.

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

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

inline explicit image_container(const vil_image_view_base_sptr d): Constructor - from a vil_image_view_base_sptr.

inline explicit image_container(const vital::image &vital_image): Constructor - convert vital image to vil.

explicit image_container(const vital::image_container &image_cont)

Constructor - convert base image container to vil.

Constructor - convert base image container to cv::Mat.

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

virtual 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.

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

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

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

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

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

Public Static Functions

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

static 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::algo::image_io 

A class for using VXL to read and write images.

Public Functions

PLUGIN_INFO ("vxl", "Use VXL (vil) to load and save image files.") image_io()

Constructor.

Implementation specific load functionality.

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.

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.

Parameters:

filename – the path to the file to load
filename – the path to the file to save
data – the image container refering to the image to write
config – The config_block instance containing the configuration parameters for this algorithm
config – The config block to check configuration of.

Returns:

an image container refering to the loaded image Implementation specific save functionality.

Throws:

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.

Returns:

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

virtual ~image_io(): Destructor.

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

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

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

std::vector<std::string> plane_filenames(std::string const &filename) const: Get plane filenames for a given written file.

Match Features Constrained Algorithm

class match_features_constrained : public kwiver::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

PLUGIN_INFO ("vxl_constrained", "Use VXL to match descriptors under the constraints of similar geometry " "(rotation, scale, position).") match_features_constrained(): Constructor.

virtual ~match_features_constrained(): Destructor.

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

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

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

virtual 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

Parameters:

feat1 – [in] the first set of features to match
desc1 – [in] the descriptors corresponding to feat1
feat2 – [in] the second set fof features to match
desc2 – [in] the descriptors corresponding to feat2

Returns:

a set of matching indices from feat1 to feat2

class priv

Optimize Cameras Algorithm

class optimize_cameras : public kwiver::vital::algo::optimize_cameras

Vital to VXL Algorithm

Warning

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

- std::shared_ptr<vgl_polygon<double>> vital_to_vxl(kwiver::vital::polygon_sptr poly)
- vil_memory_chunk_sptr vital_to_vxl(const vital::image_memory_sptr mem)

VXL to Vital Algorithm

Warning

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

- kwiver::vital::polygon_sptr vxl_to_vital(const vgl_polygon<double> &poly)
- vital::image_memory_sptr vxl_to_vital(const vil_memory_chunk_sptr chunk)

Split Image Algorithm

class split_image : public kwiver::vital::algo::split_image 

A class for drawing various information about feature tracks.

Public Functions

PLUGIN_INFO ("vxl", "Split a larger image into multiple smaller images") split_image(): Constructor.

virtual ~split_image(): Destructor.

virtual 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::algo::triangulate_landmarks

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

Public Functions

PLUGIN_INFO ("vxl", "Use VXL (vpgl) to triangulate 3D landmarks from cameras and tracks.") triangulate_landmarks(): Constructor.

virtual ~triangulate_landmarks(): Destructor.

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

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

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

virtual 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 – [in] the cameras viewing the landmarks
tracks – [in] the feature tracks to use as constraints
landmarks – [inout] the landmarks to triangulate

FFmpeg Video Input Algorithm

class vidl_ffmpeg_video_input : public kwiver::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

PLUGIN_INFO ("vidl_ffmpeg", "Use VXL (vidl with FFMPEG) to read video files as a sequence of images.") vidl_ffmpeg_video_input(): Constructor.

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

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

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

virtual 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.
Throws:: exception – if open failed

virtual 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.

virtual 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.

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

virtual 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().

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

virtual bool seekable() const

Return whether video stream is seekable.

This method returns whether the video stream is seekable.

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

virtual size_t num_frames() const

Get the number of frames in the video stream.

Get the number of frames available in the video stream.

Throws:: video_stream_exception – when there is an error in the video stream.
Returns:: the number of frames in the video stream, or 0 if the video stream is not seekable.

virtual 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.

Parameters:

ts – [out] Time stamp of new frame.
timeout – [in] Number of seconds to wait. 0 = no timeout.

Throws:

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

Returns:

true if frame returned, false if end of video.

virtual 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.

Parameters:

ts – [out] Time stamp of new frame.
frame_number – [in] The frame to seek to.
timeout – [in] Number of seconds to wait. 0 = no timeout.

Throws:

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

Returns:

true if frame returned, false if end of video.

virtual 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.

Returns:: The time stamp of the current frame.

virtual double frame_rate()

Get frame rate from the video.

If frame rate is not supported, return -1.

Returns:: Frame rate.

virtual 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.

Throws:: video_stream_exception – when there is an error in the video stream.
Returns:: Pointer to image container.

virtual 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.

Throws:: video_stream_exception – when there is an error in the video stream.
Returns:: Vector of metadata pointers.

virtual 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.

Throws:: video_stream_exception – when there is an error in the video stream.
Returns:: Map of vectors of metadata pointers.

class priv

Public Functions

inline 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

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

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

inline 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