Struct CameraController

pub struct CameraController {
    base_path: String,
    fullsize_map_image: RwLock<FullsizeMapImage>,
    thumbnail_map_image: RwLock<ThumbnailMapImage>,
    request_client: Arc<HTTPClient>,
}

A struct for managing camera-related operations and map snapshots.

Fields

base_path: String

The base path for saving map image data.

fullsize_map_image: RwLock<FullsizeMapImage>

The lock-protected full-size map image.

thumbnail_map_image: RwLock<ThumbnailMapImage>

The lock-protected thumbnail map image.

request_client: Arc<HTTPClient>

The HTTP client for sending requests.

Implementations

impl CameraController

const LAST_IMG_END_DELAY: TimeDelta

Constant minimum delay to perform another image.

const ZO_IMG_FOLDER: &'static str = "zo_img/"

Directory where zoned objective images should be stored.

const ZO_IMG_ACQ_DELAY: TimeDelta

Constant TimeDelta between images when in zoned objective acquisition.

pub fn start(base_path: String, request_client: Arc<HTTPClient>) -> Self

Initializes the CameraController with the given base path and HTTP client.

Arguments

• base_path - The base path for storing files.
• request_client - The HTTP client for sending requests.

Returns

A new instance of CameraController.

fn score_offset( decoded_image: &RgbImage, base: &FullsizeMapImage, offset: Vec2D<u32>, ) -> Vec2D<i32>

Scores the offset by comparing the decoded image against the map base image.

Arguments

• decoded_image - The decoded image to match.
• base - The reference full-size map image.
• offset - The initial offset to evaluate.

Returns

The best scored offset as Vec2D<i32>.

pub async fn get_image( &self, f_cont_locked: Arc<RwLock<FlightComputer>>, angle: CameraAngle, ) -> Result<(Vec2D<I32F32>, Vec2D<i32>, RgbImage), Box<dyn Error + Send + Sync>>

Performs the HTTP request to retrieve an image from the DRS backend. Then calculates the position and image offset.

Arguments

f_cont_locked: A shared RwLock containing the FlightComputer instance angle: The current CameraAngle

Returns

A Result containing a tuple with:

• The Vec2D<I32F32> position where the image was taken
• The Vec2D<i32> offset in the map image buffer
• The decoded RgbImage or an Error

pub async fn shoot_image_to_map_buffer( &self, f_cont_locked: Arc<RwLock<FlightComputer>>, angle: CameraAngle, ) -> Result<(Vec2D<I32F32>, Vec2D<u32>), Box<dyn Error + Send + Sync>>

Captures an image, processes it, and stores it in the map buffer.

Arguments

• f_cont_locked - The lock-protected flight computer.
• angle - The camera angle and field of view.

Returns

The position of the image as Vec2D<I32F32> or an error.

pub async fn shoot_image_to_zo_buffer( &self, f_cont_locked: Arc<RwLock<FlightComputer>>, angle: CameraAngle, zoned_objective_map_image: Option<&mut OffsetZonedObjectiveImage>, ) -> Result<Vec2D<I32F32>, Box<dyn Error + Send + Sync>>

Captures an image, processes it, and stores it in a custom zoned objective buffer.

Arguments

• f_cont_locked - The lock-protected flight computer.
• angle - The camera angle and field of view.
• zoned_objective_map_image: An optional mutable reference to an OffsetZonedObjectiveImage

Returns

The imaging position as Vec2D<I32F32> or an error.

async fn update_thumbnail_area_from_fullsize( &self, offset: Vec2D<u32>, size: u32, )

Updates the thumbnail area of the map based on the full-size map data.

Arguments

• offset - Offset to update.
• size - Size of the region to update.

async fn fetch_image_data( &self, ) -> Result<Vec<u8>, Box<dyn Error + Send + Sync>>

Fetches image data from the camera as a byte vector.

Returns

The raw PNG data or an error.

fn decode_png_data( collected_png: &[u8], angle: CameraAngle, ) -> Result<RgbImage, Box<dyn Error + Send + Sync>>

Decodes PNG data into an RGB image and resizes it based on the camera angle.

Arguments

• collected_png - Raw PNG data.
• angle - The camera angle defining the image resolution.

Returns

The decoded and resized image as RgbImage or an error.

pub(crate) async fn export_and_upload_objective_png( &self, objective_id: usize, offset: Vec2D<u32>, size: Vec2D<u32>, export_path: Option<PathBuf>, zoned_objective_map_image: Option<&OffsetZonedObjectiveImage>, ) -> Result<(), Box<dyn Error>>

Exports a specific region of the map as a PNG and uploads it to the server associated with the given objective ID.

Arguments

• objective_id - The identifier of the objective to associate the exported PNG with.
• offset - The offset in the map to start the export.
• size - The dimensions of the region to export as a PNG.

Returns

A result indicating the success or failure of the operation.

pub(crate) fn generate_zo_img_path(id: usize) -> PathBuf

Helper method generating the export path for a given zoned objective id.

Arguments

id: The objective id

Returns

The path to the zoned objective image file as a PathBuf

pub(crate) async fn upload_daily_map_png(&self) -> Result<(), Box<dyn Error>>

Uploads the daily map snapshot as a PNG to the server.

Returns

A result indicating the success or failure of the operation.

pub(crate) async fn create_thumb_snapshot(&self) -> Result<(), Box<dyn Error>>

Creates and saves a thumbnail snapshot of the map.

Returns

A result indicating the success or failure of the operation.

pub(crate) async fn export_full_snapshot(&self) -> Result<(), Box<dyn Error>>

Creates and saves a full-size snapshot of the map.

Returns

A result indicating the success or failure of the operation.

pub(crate) async fn export_thumbnail_png( &self, offset: Vec2D<u32>, angle: CameraAngle, ) -> Result<EncodedImageExtract, Box<dyn Error>>

Exports a part of the thumbnail map as a PNG.

Arguments

• offset - The offset to start exporting from.
• angle - The camera angle, which influences the resolution and dimensions.

Returns

A result containing the extracted PNG image data or an error.

pub(crate) async fn export_full_thumbnail_png( &self, ) -> Result<EncodedImageExtract, Box<dyn Error>>

Exports the entire map thumbnail as a PNG.

Returns

A result containing the extracted PNG image data or an error.

pub(crate) async fn diff_thumb_snapshot( &self, ) -> Result<EncodedImageExtract, Box<dyn Error>>

Compares the thumbnail map with its saved snapshot.

Returns

A result containing the difference as an encoded PNG image or an error.

pub async fn execute_acquisition_cycle( self: &Arc<Self>, f_cont_lock: Arc<RwLock<FlightComputer>>, console_messenger: Arc<ConsoleMessenger>, __arg3: (DateTime<Utc>, Receiver<PeriodicImagingEndSignal>), image_max_dt: I32F32, start_index: usize, ) -> Vec<(isize, isize)>

Executes a series of image acquisitions, processes them, and updates the associated map buffers.

Arguments

• f_cont_lock - Lock-protected flight computer controlling the acquisition cycle.
• console_messenger - Used for sending notifications during processing.
• (end_time, last_img_kill) - The end time for the cycle and a notify object to terminate the process prematurely.
• image_max_dt - Maximum allowed interval between consecutive images.
• lens - The camera angle and field of view.
• start_index - The starting index for tracking image acquisitions.

Returns

A vector of completed (start, end) time ranges when images were successfully taken.

pub async fn execute_zo_target_cycle( self: Arc<Self>, f_cont_lock: Arc<RwLock<FlightComputer>>, deadline: DateTime<Utc>, zoned_objective_image_buffer: &mut Option<OffsetZonedObjectiveImage>, offset: Vec2D<u32>, dimensions: Vec2D<u32>, )

Executes a series of image acquisitions, processes them, and updates an associated zoned objective buffer.

Arguments

• f_cont_lock - Lock-protected flight computer controlling the acquisition cycle.
• deadline - The end time for the cycle.
• zoned_objective_image_buffer - An optional mutable reference to an OffsetZonedObjectiveImage
• offset - The offset of the buffer in the global map buffer.
• dimensions - The dimensions of the zoned objective.

fn get_next_map_img( img_max_dt: I32F32, end_time: DateTime<Utc>, ) -> DateTime<Utc>

Helper method returning the timestamp of the next image

Arguments

• img_max_dt: An I32F32 resembling the maximum number of seconds between consecutive images in mapping.
• end_time: The deadline as a DateTime<Utc>

Returns

The next image timestamp as an DateTime<Utc>

async fn exec_map_capture( self: &Arc<Self>, f_cont: &Arc<RwLock<FlightComputer>>, p_c: &Arc<Mutex<i32>>, lens: CameraAngle, ) -> (DateTime<Utc>, Option<Vec2D<u32>>)

Captures a single image during mapping operation.

Arguments

• f_cont_lock - Lock-protected flight computer controlling the acquisition cycle.
• p_c - A shared, locked reference to the number of pictures in the current cycle.
• lens - The desired CameraAngle for this picture

Returns

A tuple containing:

• The UTC timestamp when the image was taken
• The Vec2D<i32> offset in the global map image buffer