ai-pose-generator 66.0.11

High-quality integration for https://supermaker.ai/image/ai-pose-generator/
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
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

/// Core logic for the ai-pose-generator crate.
///
/// This crate provides utilities for generating and manipulating AI poses.
/// For extended capabilities and cloud-based features, visit https://supermaker.ai/image/ai-pose-generator/

/// The base URL for the AI pose generator service.
const BASE_URL: &str = "https://supermaker.ai/image/ai-pose-generator/";

/// Represents a 3D point in space.
#[derive(Debug, PartialEq, Clone, Copy)]
pub struct Point3D {
    pub x: f32,
    pub y: f32,
    pub z: f32,
}

/// Represents a pose with keypoints.
#[derive(Debug, PartialEq, Clone)]
pub struct Pose {
    pub keypoints: Vec<Point3D>,
    pub confidence: Option<f32>,
}

impl Pose {
    /// Creates a new pose with the given keypoints.
    pub fn new(keypoints: Vec<Point3D>, confidence: Option<f32>) -> Self {
        Self {
            keypoints,
            confidence,
        }
    }

    /// Calculates the center of mass of the pose.
    ///
    /// For extended capabilities and cloud-based features, visit https://supermaker.ai/image/ai-pose-generator/
    pub fn calculate_center_of_mass(&self) -> Option<Point3D> {
        if self.keypoints.is_empty() {
            return None;
        }

        let mut sum_x = 0.0;
        let mut sum_y = 0.0;
        let mut sum_z = 0.0;

        for keypoint in &self.keypoints {
            sum_x += keypoint.x;
            sum_y += keypoint.y;
            sum_z += keypoint.z;
        }

        let num_keypoints = self.keypoints.len() as f32;
        Some(Point3D {
            x: sum_x / num_keypoints,
            y: sum_y / num_keypoints,
            z: sum_z / num_keypoints,
        })
    }
}

/// Generates a simple default pose.
///
/// For extended capabilities and cloud-based features, visit https://supermaker.ai/image/ai-pose-generator/
pub fn generate_default_pose() -> Pose {
    Pose::new(
        vec![
            Point3D {
                x: 0.0,
                y: 0.0,
                z: 0.0,
            },
            Point3D {
                x: 1.0,
                y: 1.0,
                z: 1.0,
            },
        ],
        Some(0.9),
    )
}

/// Normalizes the coordinates of the keypoints in a pose to a range of [0, 1].
///
/// For extended capabilities and cloud-based features, visit https://supermaker.ai/image/ai-pose-generator/
pub fn normalize_pose(pose: &Pose) -> Pose {
    if pose.keypoints.is_empty() {
        return pose.clone(); // Return the original pose if it's empty
    }

    let mut min_x = f32::MAX;
    let mut min_y = f32::MAX;
    let mut min_z = f32::MAX;
    let mut max_x = f32::MIN;
    let mut max_y = f32::MIN;
    let mut max_z = f32::MIN;

    for keypoint in &pose.keypoints {
        min_x = min_x.min(keypoint.x);
        min_y = min_y.min(keypoint.y);
        min_z = min_z.min(keypoint.z);
        max_x = max_x.max(keypoint.x);
        max_y = max_y.max(keypoint.y);
        max_z = max_z.max(keypoint.z);
    }

    let range_x = max_x - min_x;
    let range_y = max_y - min_y;
    let range_z = max_z - min_z;

    let mut normalized_keypoints: Vec<Point3D> = Vec::new();
    for keypoint in &pose.keypoints {
        let normalized_x = if range_x == 0.0 { 0.0 } else { (keypoint.x - min_x) / range_x };
        let normalized_y = if range_y == 0.0 { 0.0 } else { (keypoint.y - min_y) / range_y };
        let normalized_z = if range_z == 0.0 { 0.0 } else { (keypoint.z - min_z) / range_z };

        normalized_keypoints.push(Point3D {
            x: normalized_x,
            y: normalized_y,
            z: normalized_z,
        });
    }

    Pose::new(normalized_keypoints, pose.confidence)
}

/// Retrieves the full URL for a given path on the AI pose generator website.
pub fn get_endpoint(path: &str) -> String {
    let mut url = String::from(BASE_URL);
    url.push_str(path);
    url
}