15 KiB
15 KiB
API Usage Examples
Python Example:
import requests
# Input variables
x1 = 0
y1 = 0
x2 = 5
y2 = 5
limit = 3
# JSON payload
payload = {
"node0": {"x": x1, "y": y1},
"node1": {"x": x2, "y": y2}
}
# Headers
headers = {
'accept': 'application/json',
'Content-Type': 'application/json'
}
# Make POST request
try:
response = requests.post(
'https://bellanderoboticssensorsresearchinnovationcenterapi-7xm5pkao.b4a.run/Bellande_Step/bellande_step_2d?limit=' + str(limit),
json=payload,
headers=headers
)
response.raise_for_status() # Raise an error for unsuccessful responses
data = response.json()
print("Next Step:", data['next_step'])
except requests.exceptions.RequestException as e:
print("Error:", e)
C Example
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <curl/curl.h>
#include <jansson.h>
// Struct to hold response data
struct MemoryStruct {
char *memory;
size_t size;
};
// Callback function to write response data
static size_t WriteMemoryCallback(void *contents, size_t size, size_t nmemb, void *userp) {
size_t realsize = size * nmemb;
struct MemoryStruct *mem = (struct MemoryStruct *)userp;
mem->memory = realloc(mem->memory, mem->size + realsize + 1);
if (mem->memory == NULL) {
printf("Error: realloc failed\n");
return 0;
}
memcpy(&(mem->memory[mem->size]), contents, realsize);
mem->size += realsize;
mem->memory[mem->size] = 0;
return realsize;
}
int main() {
// Input variables
int x1 = 0;
int y1 = 0;
int x2 = 5;
int y2 = 5;
int limit = 3;
CURL *curl;
CURLcode res;
// Initialize libcurl
curl_global_init(CURL_GLOBAL_ALL);
// Create libcurl handle
curl = curl_easy_init();
if (curl) {
// Construct JSON payload
json_t *root = json_object();
json_object_set_new(root, "node0", json_pack("{s:i, s:i}", "x", x1, "y", y1));
json_object_set_new(root, "node1", json_pack("{s:i, s:i}", "x", x2, "y", y2));
char *payload = json_dumps(root, JSON_COMPACT);
json_decref(root);
// Construct URL with query parameter
char *url;
asprintf(&url, "https://bellanderoboticssensorsresearchinnovationcenterapi-7xm5pkao.b4a.run/Bellande_Step/bellande_step_2d?limit=%d", limit);
// Set libcurl options
curl_easy_setopt(curl, CURLOPT_URL, url);
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, payload);
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteMemoryCallback);
// Response data
struct MemoryStruct chunk;
chunk.memory = malloc(1);
chunk.size = 0;
curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&chunk);
// Perform the request
res = curl_easy_perform(curl);
if (res != CURLE_OK) {
fprintf(stderr, "curl_easy_perform() failed: %s\n", curl_easy_strerror(res));
} else {
// Parse JSON response
json_error_t error;
json_t *root = json_loads(chunk.memory, 0, &error);
if (!root) {
fprintf(stderr, "Error parsing JSON: %s\n", error.text);
} else {
json_t *next_step = json_object_get(root, "next_step");
double x, y;
json_unpack(next_step, "{s:f, s:f}", "x", &x, "y", &y);
printf("Next Step: (%f, %f)\n", x, y);
json_decref(root);
}
}
// Cleanup
free(chunk.memory);
free(payload);
free(url);
curl_easy_cleanup(curl);
}
// Cleanup libcurl
curl_global_cleanup();
return 0;
}
C++ Example
#include <iostream>
#include <string>
#include <curl/curl.h>
#include <nlohmann/json.hpp>
using json = nlohmann::json;
// Struct to hold response data
struct MemoryStruct {
char *memory;
size_t size;
};
// Callback function to write response data
static size_t WriteMemoryCallback(void *contents, size_t size, size_t nmemb, void *userp) {
size_t realsize = size * nmemb;
struct MemoryStruct *mem = (struct MemoryStruct *)userp;
mem->memory = (char *)realloc(mem->memory, mem->size + realsize + 1);
if (mem->memory == NULL) {
std::cerr << "Error: realloc failed" << std::endl;
return 0;
}
memcpy(&(mem->memory[mem->size]), contents, realsize);
mem->size += realsize;
mem->memory[mem->size] = 0;
return realsize;
}
int main() {
// Input variables
int x1 = 0;
int y1 = 0;
int x2 = 5;
int y2 = 5;
int limit = 3;
CURL *curl;
CURLcode res;
// Initialize libcurl
curl_global_init(CURL_GLOBAL_ALL);
// Create libcurl handle
curl = curl_easy_init();
if (curl) {
// Construct JSON payload
std::string payload = "{\"node0\":{\"x\":" + std::to_string(x1) + ",\"y\":" + std::to_string(y1) + "},\"node1\":{\"x\":" + std::to_string(x2) + ",\"y\":" + std::to_string(y2) + "}}";
// Construct URL with query parameter
std::string url = "https://bellanderoboticssensorsresearchinnovationcenterapi-7xm5pkao.b4a.run/Bellande_Step/bellande_step_2d?limit=" + std::to_string(limit);
// Response data
struct MemoryStruct chunk;
chunk.memory = (char *)malloc(1);
chunk.size = 0;
// Set libcurl options
curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, payload.c_str());
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteMemoryCallback);
curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&chunk);
// Perform the request
res = curl_easy_perform(curl);
if (res != CURLE_OK) {
std::cerr << "curl_easy_perform() failed: " << curl_easy_strerror(res) << std::endl;
} else {
// Parse JSON response
json data = json::parse(chunk.memory);
std::cout << "Next Step: (" << data["next_step"]["x"] << ", " << data["next_step"]["y"] << ")" << std::endl;
}
// Cleanup
free(chunk.memory);
curl_easy_cleanup(curl);
}
// Cleanup libcurl
curl_global_cleanup();
return 0;
}
Java Example
import org.json.JSONObject;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
public class Main {
public static void main(String[] args) {
// Input variables
int x1 = 0;
int y1 = 0;
int x2 = 5;
int y2 = 5;
int limit = 3;
// JSON payload
JSONObject payload = new JSONObject()
.put("node0", new JSONObject()
.put("x", x1)
.put("y", y1))
.put("node1", new JSONObject()
.put("x", x2)
.put("y", y2));
// Make POST request
try {
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://bellanderoboticssensorsresearchinnovationcenterapi-7xm5pkao.b4a.run/Bellande_Step/bellande_step_2d?limit=" + limit))
.header("Content-Type", "application/json")
.header("Accept", "application/json")
.POST(HttpRequest.BodyPublishers.ofString(payload.toString()))
.build();
HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
if (response.statusCode() == 200) {
JSONObject data = new JSONObject(response.body());
JSONObject nextStep = data.getJSONObject("next_step");
System.out.println("Next Step: (" + nextStep.getDouble("x") + ", " + nextStep.getDouble("y") + ")");
} else {
System.out.println("Error: " + response.body());
}
} catch (Exception e) {
System.out.println("Error: " + e.getMessage());
}
}
}
Javascript Example
const fetch = require('node-fetch');
// Input variables
const x1 = 0;
const y1 = 0;
const x2 = 5;
const y2 = 5;
const limit = 3;
// JSON payload
const payload = JSON.stringify({
node0: { x: x1, y: y1 },
node1: { x: x2, y: y2 }
});
// Request parameters
const requestOptions = {
method: 'POST',
headers: {
'Accept': 'application/json',
'Content-Type': 'application/json'
},
body: payload
};
// Make POST request
fetch(`https://bellanderoboticssensorsresearchinnovationcenterapi-7xm5pkao.b4a.run/Bellande_Step/bellande_step_2d?limit=${limit}`, requestOptions)
.then(response => {
if (!response.ok) {
throw new Error(`HTTP error! status: ${response.status}`);
}
return response.json();
})
.then(data => {
console.log("Next Step:", data.next_step);
})
.catch(error => {
console.error("Error:", error);
});
Rust Example
use serde_json::json;
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
// Input variables
let x1 = 0;
let y1 = 0;
let x2 = 5;
let y2 = 5;
let limit = 3;
// JSON payload
let payload = json!({
"node0": {"x": x1, "y": y1},
"node1": {"x": x2, "y": y2}
});
// Make POST request
let client = reqwest::Client::new();
let response = client
.post("https://bellanderoboticssensorsresearchinnovationcenterapi-7xm5pkao.b4a.run/Bellande_Step/bellande_step_2d")
.query(&[("limit", &limit.to_string())])
.json(&payload)
.send()
.await?;
// Check if response is successful
if response.status().is_success() {
// Parse response JSON
let data: serde_json::Value = response.json().await?;
// Print next_step
if let Some(next_step) = data.get("next_step") {
println!("Next Step: {}", next_step);
} else {
println!("Next Step not found in response.");
}
} else {
println!("Error: {}", response.status());
}
Ok(())
}
Go Example
package main
import (
"bytes"
"encoding/json"
"fmt"
"net/http"
)
func main() {
// Input variables
x1 := 0
y1 := 0
x2 := 5
y2 := 5
limit := 3
// JSON payload
payload := map[string]interface{}{
"node0": map[string]int{"x": x1, "y": y1},
"node1": map[string]int{"x": x2, "y": y2},
}
// Convert payload to JSON
payloadBytes, err := json.Marshal(payload)
if err != nil {
fmt.Println("Error marshaling JSON:", err)
return
}
// Make POST request
url := fmt.Sprintf("https://bellanderoboticssensorsresearchinnovationcenterapi-7xm5pkao.b4a.run/Bellande_Step/bellande_step_2d?limit=%d", limit)
req, err := http.NewRequest("POST", url, bytes.NewBuffer(payloadBytes))
if err != nil {
fmt.Println("Error creating request:", err)
return
}
// Set headers
req.Header.Set("Accept", "application/json")
req.Header.Set("Content-Type", "application/json")
// Create HTTP client and send request
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
fmt.Println("Error making request:", err)
return
}
defer resp.Body.Close()
// Check if response is successful
if resp.StatusCode != http.StatusOK {
fmt.Println("Error:", resp.Status)
return
}
// Decode response JSON
var data map[string]interface{}
if err := json.NewDecoder(resp.Body).Decode(&data); err != nil {
fmt.Println("Error decoding JSON:", err)
return
}
// Print next_step
nextStep, ok := data["next_step"].(string)
if !ok {
fmt.Println("Next Step not found in response.")
return
}
fmt.Println("Next Step:", nextStep)
}
Swift Example
import Foundation
// Input variables
let x1 = 0
let y1 = 0
let x2 = 5
let y2 = 5
let limit = 3
// JSON payload
let payload = [
"node0": ["x": x1, "y": y1],
"node1": ["x": x2, "y": y2]
]
// Convert payload to Data
guard let payloadData = try? JSONSerialization.data(withJSONObject: payload) else {
print("Error converting payload to Data.")
exit(1)
}
// Request URL
let urlString = "https://bellanderoboticssensorsresearchinnovationcenterapi-7xm5pkao.b4a.run/Bellande_Step/bellande_step_2d?limit=\(limit)"
guard let url = URL(string: urlString) else {
print("Error creating URL.")
exit(1)
}
// Create URLRequest
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.setValue("application/json", forHTTPHeaderField: "Accept")
request.httpBody = payloadData
// Perform the request
let task = URLSession.shared.dataTask(with: request) { data, response, error in
// Check for errors
if let error = error {
print("Error:", error)
return
}
// Check for response
guard let httpResponse = response as? HTTPURLResponse else {
print("Error: No HTTP response")
return
}
// Check for successful response
guard (200...299).contains(httpResponse.statusCode) else {
print("Error: HTTP status code \(httpResponse.statusCode)")
return
}
// Check if there is data
guard let responseData = data else {
print("Error: No response data")
return
}
// Parse JSON response
do {
if let jsonResponse = try JSONSerialization.jsonObject(with: responseData, options: []) as? [String: Any],
let nextStep = jsonResponse["next_step"] as? String {
print("Next Step:", nextStep)
} else {
print("Error: Couldn't find next_step in JSON response")
}
} catch {
print("Error parsing JSON response:", error)
}
}
task.resume()
C# Example
using System;
using System.Net.Http;
using System.Text.Json;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
// Input variables
int x1 = 0;
int y1 = 0;
int x2 = 5;
int y2 = 5;
int limit = 3;
// JSON payload
var payload = new
{
node0 = new { x = x1, y = y1 },
node1 = new { x = x2, y = y2 }
};
// Convert payload to JSON
var payloadJson = JsonSerializer.Serialize(payload);
var content = new StringContent(payloadJson, System.Text.Encoding.UTF8, "application/json");
// Make POST request
using var client = new HttpClient();
var url = $"https://bellanderoboticssensorsresearchinnovationcenterapi-7xm5pkao.b4a.run/Bellande_Step/bellande_step_2d?limit={limit}";
try
{
var response = await client.PostAsync(url, content);
response.EnsureSuccessStatusCode(); // Throws exception for unsuccessful responses
// Parse JSON response
var responseContent = await response.Content.ReadAsStringAsync();
var responseData = JsonSerializer.Deserialize<dynamic>(responseContent);
// Print next_step
Console.WriteLine("Next Step: " + responseData.next_step);
}
catch (HttpRequestException e)
{
Console.WriteLine("Error: " + e.Message);
}
}
}