diff --git a/Package/rust/.gitignore b/Package/rust/.gitignore new file mode 100644 index 0000000..a9d37c5 --- /dev/null +++ b/Package/rust/.gitignore @@ -0,0 +1,2 @@ +target +Cargo.lock diff --git a/Package/rust/Cargo.toml b/Package/rust/Cargo.toml new file mode 100644 index 0000000..f9faa26 --- /dev/null +++ b/Package/rust/Cargo.toml @@ -0,0 +1,24 @@ +[package] +name = "bellande_limit" +version = "0.1.0" +edition = "2021" +authors = ["Bellande Robotics Sensors Research Innovation Center"] +description = "Bellande Adaptive Step Size dynamically adjusts movement increments for optimal robotic path planning and navigation" +license = "GPL-3.0-or-later" +repository = "https://github.com/Robotics-Sensors/bellande_limit" +readme = "README.md" +keywords = ["robotics", "algorithms", "research"] +categories = ["science", "algorithms"] + +[dependencies] +reqwest = { version = "0.11", features = ["json"] } +serde = { version = "1.0", features = ["derive"] } +serde_json = "1.0" +structopt = "0.3" +tokio = { version = "1.0", features = ["full"] } +thiserror = "1.0" +anyhow = "1.0" + +[lib] +name = "bellande_limit" +path = "src/bellande_limit.rs" diff --git a/Package/rust/README.md b/Package/rust/README.md new file mode 100644 index 0000000..18eff46 --- /dev/null +++ b/Package/rust/README.md @@ -0,0 +1,167 @@ +# 📦 Bellande Limit + +## 🧙 Organization Website +- [![Organization Website](https://img.shields.io/badge/Explore%20Our-Website-0099cc?style=for-the-badge)](https://robotics-sensors.github.io) + +## 🧙 Organization Github +- [![Organization Github ](https://img.shields.io/badge/Explore%20Our-Github-0099cc?style=for-the-badge)](https://github.com/Robotics-Sensors) + +# Author, Creator and Maintainer +- **Ronaldson Bellande** + +## Bellande Limit Executables & Models +- [![Bellande Limit Models & Executables ](https://img.shields.io/badge/Bellande%20Step-Models/Executables-0099cc?style=for-the-badge)](https://github.com/Artificial-Intelligence-Computer-Vision/bellande_limit_models_executables) + +# API HTTP Usability (BELLANDE FORMAT) +``` +# Copyright (C) 2024 Bellande Robotics Sensors Research Innovation Center, Ronaldson Bellande +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . +# GNU General Public License v3.0 or later + +url: https://bellande-robotics-sensors-research-innovation-center.org + +endpoint_path: + bellande_limit: /api/Bellande_Limit/bellande_limit + +Bellande_Framework_Access_Key: bellande_web_api_opensource +``` + +# API HTTP Usability (JSON FORMAT) +``` +{ + "license": [ + "Copyright (C) 2024 Bellande Robotics Sensors Research Innovation Center, Ronaldson Bellande", + "This program is free software: you can redistribute it and/or modify", + "it under the terms of the GNU General Public License as published by", + "the Free Software Foundation, either version 3 of the License, or", + "(at your option) any later version.", + "", + "This program is distributed in the hope that it will be useful,", + "but WITHOUT ANY WARRANTY; without even the implied warranty of", + "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the", + "GNU General Public License for more details.", + "", + "You should have received a copy of the GNU General Public License", + "along with this program. If not, see .", + "GNU General Public License v3.0 or later" + ], + "url": "https://bellande-robotics-sensors-research-innovation-center.org", + "endpoint_path": { + "bellande_limit": "/api/Bellande_Limit/bellande_limit" + }, + "Bellande_Framework_Access_Key": "bellande_web_api_opensource" +} +``` + +# API Payload Example +``` +{ + "node0": [0, 0, 0], + "node1": [100, 100, 100], + "environment": [1000, 1000, 1000], + "size": [10, 10, 10], + "goal": [200, 200, 200], + "obstacles": [ + { + "position": [50, 50, 50], + "dimensions": [20, 20, 20] + } + ], + "search_radius": 50, + "sample_points": 20, + "auth": { + "authorization_key": "bellande_web_api_opensource" + } +} +``` + +# 🧙 Website Bellande API Testing +- [![Website API Testing](https://img.shields.io/badge/Bellande%20API-Testing-0099cc?style=for-the-badge)](https://bellande-robotics-sensors-research-innovation-center.org/api/bellande_limit_experiment) + +# Quick Bellande API Testing +``` +curl -X 'POST' \ + 'https://bellande-robotics-sensors-research-innovation-center.org/api/Bellande_Limit/bellande_limit' \ + -H 'accept: application/json' \ + -H 'Content-Type: application/json' \ + -d '{ + "node0": [0, 0, 0], + "node1": [100, 100, 100], + "environment": [1000, 1000, 1000], + "size": [10, 10, 10], + "goal": [100, 100, 100], + "obstacles": [ + { + "position": [50, 50, 50], + "dimensions": [20, 20, 20] + } + ], + "search_radius": 50, + "sample_points": 20, + "auth": { + "authorization_key": "bellande_web_api_opensource" + } + }' +``` + +# Bellande Limit Usage + +## Website Crates +- https://crates.io/crates/bellande_limit + +### Installation +- `cargo add bellande_limit` + +## Website PYPI +- https://pypi.org/project/bellande_limit + +### Installation +- `$ pip install bellande_limit` + +### Usage +``` +bellande_limit_api \ + --node0 "[0,0,0]" \ + --node1 "[100,100,100]" \ + --environment "[1000,1000,1000]" \ + --size "[10,10,10]" \ + --goal "[200,200,200]" \ + --obstacles '[{"position":[50,50,50],"dimensions":[20,20,20]}]' \ + --search-radius 50 \ + --sample-points 20 +``` + +### Upgrade (if not upgraded) +- `$ pip install --upgrade bellande_limit` + +``` +Name: bellande_limit +Summary: Computes the next step towards a target node +Home-page: github.com/RonaldsonBellande/bellande_limit +Author: Ronaldson Bellande +Author-email: ronaldsonbellande@gmail.com +License: GNU General Public License v3.0 +``` + +## Published Paper +``` +Coming Soon +``` + +## Preprint +- [![Preprint](https://img.shields.io/badge/Preprint-Bellande%20Step-0099cc?style=for-the-badge)](https://dapp.orvium.io/deposits/6650ccb8afb407dc8beb0ff2/view) + + +## License +This Algorithm or Models is distributed under the [Creative Commons Attribution-ShareAlike 4.0 International License](http://creativecommons.org/licenses/by-sa/4.0/), see [LICENSE](https://github.com/RonaldsonBellande/bellande_step/blob/main/LICENSE) and [NOTICE](https://github.com/RonaldsonBellande/bellande_step/blob/main/LICENSE) for more information. diff --git a/Package/rust/publish.sh b/Package/rust/publish.sh new file mode 100755 index 0000000..7d4afa0 --- /dev/null +++ b/Package/rust/publish.sh @@ -0,0 +1,4 @@ +cp ../../README.md . +bash ../../git_scripts/push.sh +cargo publish +rm -f README.md diff --git a/Package/rust/src/bellande_limit.rs b/Package/rust/src/bellande_limit.rs new file mode 100644 index 0000000..f233fbe --- /dev/null +++ b/Package/rust/src/bellande_limit.rs @@ -0,0 +1,256 @@ +// Copyright (C) 2024 Bellande Robotics Sensors Research Innovation Center, Ronaldson Bellande + +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. + +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +use reqwest; +use serde_json::{json, Value}; +use std::error::Error; +use std::path::{Path, PathBuf}; +use std::process::{self, Command}; +use structopt::StructOpt; + +#[derive(StructOpt, Debug)] +#[structopt(name = "bellande_limit", about = "Bellande Limit Tool")] +struct Opt { + #[structopt(long, help = "Starting point coordinates as JSON-formatted list")] + node0: String, + + #[structopt(long, help = "Target point coordinates as JSON-formatted list")] + node1: String, + + #[structopt(long, help = "Environment dimensions as JSON-formatted list")] + environment: String, + + #[structopt(long, help = "Step sizes for each dimension as JSON-formatted list")] + size: String, + + #[structopt(long, help = "Goal coordinates as JSON-formatted list")] + goal: String, + + #[structopt(long, help = "List of obstacles as JSON-formatted list")] + obstacles: Option, + + #[structopt( + long, + default_value = "50.0", + help = "Search radius for obstacle detection" + )] + search_radius: f64, + + #[structopt( + long, + default_value = "20", + help = "Number of sample points for obstacle detection" + )] + sample_points: i32, + + #[structopt(long, help = "Use local executable instead of API")] + use_executable: bool, +} + +async fn make_bellande_limit_request( + node0: Value, + node1: Value, + environment: Value, + size: Value, + goal: Value, + obstacles: Option, + search_radius: f64, + sample_points: i32, +) -> Result> { + let client = reqwest::Client::new(); + let url = "https://bellande-robotics-sensors-research-innovation-center.org/api/Bellande_Limit/bellande_limit"; + + let payload = json!({ + "node0": node0, + "node1": node1, + "environment": environment, + "size": size, + "goal": goal, + "obstacles": obstacles.unwrap_or(json!([])), + "search_radius": search_radius, + "sample_points": sample_points, + "auth": { + "authorization_key": "bellande_web_api_opensource" + } + }); + + let response = client + .post(url) + .header("accept", "application/json") + .header("Content-Type", "application/json") + .json(&payload) + .send() + .await? + .json::() + .await?; + + Ok(response) +} + +fn get_executable_path() -> PathBuf { + if cfg!(target_os = "windows") { + Path::new(env!("CARGO_MANIFEST_DIR")).join("Bellande_Limit.exe") + } else { + Path::new(env!("CARGO_MANIFEST_DIR")).join("Bellande_Limit") + } +} + +fn run_bellande_limit_executable( + node0: &str, + node1: &str, + environment: &str, + size: &str, + goal: &str, + obstacles: Option<&str>, + search_radius: f64, + sample_points: i32, +) -> Result<(), Box> { + let executable_path = get_executable_path(); + let passcode = "bellande_limit_executable_access_key"; + + // Parse and validate inputs + let node0_list: Value = serde_json::from_str(node0)?; + let node1_list: Value = serde_json::from_str(node1)?; + let environment_list: Value = serde_json::from_str(environment)?; + let size_list: Value = serde_json::from_str(size)?; + let goal_list: Value = serde_json::from_str(goal)?; + let obstacles_list: Value = obstacles + .map(|o| serde_json::from_str(o)) + .transpose()? + .unwrap_or(json!([])); + + // Validate dimensions + let dimensions = environment_list.as_array().unwrap().len(); + if let (Some(n0), Some(n1), Some(s), Some(g)) = ( + node0_list.as_array(), + node1_list.as_array(), + size_list.as_array(), + goal_list.as_array(), + ) { + if n0.len() != dimensions + || n1.len() != dimensions + || s.len() != dimensions + || g.len() != dimensions + { + return Err(format!("All coordinates must have {} dimensions", dimensions).into()); + } + } + + // Validate obstacles + if let Some(obstacles) = obstacles_list.as_array() { + for obstacle in obstacles { + if let (Some(pos), Some(dims)) = ( + obstacle.get("position").and_then(Value::as_array), + obstacle.get("dimensions").and_then(Value::as_array), + ) { + if pos.len() != dimensions || dims.len() != dimensions { + return Err( + "Obstacle position and dimensions must match environment dimensions".into(), + ); + } + } + } + } + + // Prepare and run command + let mut command = Command::new(executable_path); + command.args(&[ + passcode, + node0, + node1, + environment, + size, + goal, + &serde_json::to_string(&obstacles_list)?, + &search_radius.to_string(), + &sample_points.to_string(), + ]); + + let output = command.output()?; + + if output.status.success() { + println!("{}", String::from_utf8_lossy(&output.stdout)); + Ok(()) + } else { + Err(format!( + "Process failed: {}", + String::from_utf8_lossy(&output.stderr) + ) + .into()) + } +} + +#[tokio::main] +async fn main() -> Result<(), Box> { + let opt = Opt::from_args(); + + // Parse JSON strings to Values for validation + let node0: Value = + serde_json::from_str(&opt.node0).map_err(|e| format!("Error parsing node0: {}", e))?; + let node1: Value = + serde_json::from_str(&opt.node1).map_err(|e| format!("Error parsing node1: {}", e))?; + let environment: Value = serde_json::from_str(&opt.environment) + .map_err(|e| format!("Error parsing environment: {}", e))?; + let size: Value = + serde_json::from_str(&opt.size).map_err(|e| format!("Error parsing size: {}", e))?; + let goal: Value = + serde_json::from_str(&opt.goal).map_err(|e| format!("Error parsing goal: {}", e))?; + let obstacles_ref = opt.obstacles.as_ref(); + let obstacles: Option = obstacles_ref + .map(|o| serde_json::from_str(o)) + .transpose() + .map_err(|e| format!("Error parsing obstacles: {}", e))?; + + if opt.use_executable { + // Run using local executable + if let Err(e) = run_bellande_limit_executable( + &opt.node0, + &opt.node1, + &opt.environment, + &opt.size, + &opt.goal, + obstacles_ref.map(String::as_str), + opt.search_radius, + opt.sample_points, + ) { + eprintln!("Error: {}", e); + process::exit(1); + } + } else { + // Run using API + match make_bellande_limit_request( + node0, + node1, + environment, + size, + goal, + obstacles, + opt.search_radius, + opt.sample_points, + ) + .await + { + Ok(result) => { + println!("{}", serde_json::to_string_pretty(&result)?); + } + Err(e) => { + eprintln!("Error: {}", e); + process::exit(1); + } + } + } + + Ok(()) +} diff --git a/README.md b/README.md index b1e901a..18eff46 100644 --- a/README.md +++ b/README.md @@ -115,6 +115,14 @@ curl -X 'POST' \ }' ``` +# Bellande Limit Usage + +## Website Crates +- https://crates.io/crates/bellande_limit + +### Installation +- `cargo add bellande_limit` + ## Website PYPI - https://pypi.org/project/bellande_limit