rustautogui 2.5.0

Highly optimized GUI automation library for controlling the mouse and keyboard, with template matching support.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

#[cfg(feature = "opencl")]
pub mod opencl;
#[cfg(not(feature = "lite"))]
use crate::MatchMode;
use crate::RustAutoGui;
#[cfg(feature = "opencl")]
pub use opencl::*;
#[cfg(not(feature = "lite"))]
use rustfft::{num_complex::Complex, num_traits::ToPrimitive};

#[cfg(not(feature = "lite"))]
use image::{ImageBuffer, Luma};
#[cfg(not(feature = "lite"))]
use std::collections::HashMap;

#[cfg(not(feature = "lite"))]
pub struct TemplateMatchingData {
    pub template: Option<ImageBuffer<Luma<u8>, Vec<u8>>>,
    pub prepared_data: PreparedData, // used direct load and search
    pub prepared_data_stored: HashMap<String, (PreparedData, (u32, u32, u32, u32), MatchMode)>, //prepared data, region, matchmode
    pub match_mode: Option<MatchMode>,
    pub region: (u32, u32, u32, u32),
    pub alias_used: String,
}

#[cfg(not(feature = "lite"))]
pub struct BackupData {
    pub starting_data: PreparedData,
    pub starting_region: (u32, u32, u32, u32),
    pub starting_match_mode: Option<MatchMode>,
    pub starting_template_height: u32,
    pub starting_template_width: u32,
    pub starting_alias_used: String,
}
#[cfg(not(feature = "lite"))]
impl BackupData {
    pub fn update_rustautogui(self, target: &mut RustAutoGui) {
        target.template_data.prepared_data = self.starting_data.clone();
        target.template_data.region = self.starting_region;
        target.template_data.match_mode = self.starting_match_mode;
        target.screen.screen_data.screen_region_width = self.starting_region.2;
        target.screen.screen_data.screen_region_height = self.starting_region.3;
        target.template_width = self.starting_template_width;
        target.template_height = self.starting_template_height;
        target.template_data.alias_used = self.starting_alias_used;
    }
}

#[cfg(not(feature = "lite"))]
pub enum PreparedData {
    Segmented(SegmentedData),
    FFT(FFTData),
    None,
}
#[cfg(not(feature = "lite"))]
impl Clone for PreparedData {
    fn clone(&self) -> Self {
        match self {
            PreparedData::Segmented(data) => PreparedData::Segmented(data.clone()),
            PreparedData::FFT(data) => PreparedData::FFT(data.clone()),
            PreparedData::None => PreparedData::None,
        }
    }
}

#[cfg(not(feature = "lite"))]
pub struct SegmentedData {
    pub template_segments_fast: Vec<(u32, u32, u32, u32, f32)>,
    pub template_segments_slow: Vec<(u32, u32, u32, u32, f32)>,
    pub template_width: u32,
    pub template_height: u32,
    pub segment_sum_squared_deviations_fast: f32,
    pub segment_sum_squared_deviations_slow: f32,
    pub expected_corr_fast: f32,
    pub expected_corr_slow: f32,
    pub segments_mean_fast: f32,
    pub segments_mean_slow: f32,
}
#[cfg(not(feature = "lite"))]
impl Clone for SegmentedData {
    fn clone(&self) -> Self {
        Self {
            template_segments_fast: self.template_segments_fast.clone(),
            template_segments_slow: self.template_segments_slow.clone(),
            template_width: self.template_width,
            template_height: self.template_height,
            segment_sum_squared_deviations_fast: self.segment_sum_squared_deviations_fast,
            segment_sum_squared_deviations_slow: self.segment_sum_squared_deviations_slow,
            expected_corr_fast: self.expected_corr_fast,
            expected_corr_slow: self.expected_corr_slow,
            segments_mean_fast: self.segments_mean_fast,
            segments_mean_slow: self.segments_mean_slow,
        }
    }
}
#[cfg(not(feature = "lite"))]
pub struct FFTData {
    pub template_conj_freq: Vec<Complex<f32>>,
    pub template_sum_squared_deviations: f32,
    pub template_width: u32,
    pub template_height: u32,
    pub padded_size: u32,
}
#[cfg(not(feature = "lite"))]
impl Clone for FFTData {
    fn clone(&self) -> Self {
        Self {
            template_conj_freq: self.template_conj_freq.clone(),
            template_sum_squared_deviations: self.template_sum_squared_deviations,
            template_width: self.template_width,
            template_height: self.template_height,
            padded_size: self.padded_size,
        }
    }
}