> For the complete documentation index, see [llms.txt](https://docs.roboflow.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.roboflow.com/roboflow/roboflow-hi/deploy/serverless/keypoint-detection.md).
# Keypoint Detection
{% tabs %}
{% tab title="Python" %}
Python का उपयोग करके हमारे hosted API के माध्यम से inference चलाने के लिए, इसका उपयोग करें `roboflow` Python पैकेज:
```python
from roboflow import Roboflow
rf = Roboflow(api_key="API_KEY")
project = rf.workspace().project("MODEL_ENDPOINT")
model = project.version(VERSION).models()[0]
# एक स्थानीय छवि पर inference करें
print(model.predict("your_image.jpg", confidence=40, overlap=30).json())
# अपनी prediction देखें
# model.predict("your_image.jpg", confidence=40, overlap=30).save("prediction.jpg")
# कहीं और होस्ट की गई छवि पर inference करें
# print(model.predict("URL_OF_YOUR_IMAGE", hosted=True, confidence=40, overlap=30).json())
```
{% endtab %}
{% tab title="cURL" %}
**Linux या MacOS**
नाम वाली एक स्थानीय फ़ाइल के लिए JSON predictions प्राप्त करना `YOUR_IMAGE.jpg`:
```bash
base64 YOUR_IMAGE.jpg | curl -d @- \\
"https://serverless.roboflow.com/your-model/42?api_key=YOUR_KEY"
```
वेब पर कहीं और होस्ट की गई छवि पर उसके URL के माध्यम से inference करना (यह न भूलें कि [इसे URL encode करें](https://www.urlencoder.org/)):
```bash
curl -X POST "https://serverless.roboflow.com/your-model/42?\\
api_key=YOUR_KEY&\\
image=https%3A%2F%2Fi.imgur.com%2FPEEvqPN.png"
```
**Windows**
आपको इंस्टॉल करना होगा [Windows के लिए curl](https://curl.se/windows/) और [Windows के लिए GNU का base64 टूल](http://gnuwin32.sourceforge.net/packages/coreutils.htm). ऐसा करने का सबसे आसान तरीका है उपयोग करना [Windows के लिए git installer](https://git-scm.com/downloads) जिसमें यह भी शामिल है `curl` और `base64` इंस्टॉलेशन के दौरान "Use Git and optional Unix tools from the Command Prompt" चुनने पर command line tools भी शामिल होते हैं।
फिर आप ऊपर दिए गए समान commands का उपयोग कर सकते हैं।
{% endtab %}
{% tab title="Javascript" %}
**Node.js**
हम उपयोग कर रहे हैं [axios](https://github.com/axios/axios) इस उदाहरण में POST request करने के लिए, इसलिए पहले चलाएँ `npm install axios` dependency इंस्टॉल करने के लिए।
**एक स्थानीय छवि पर inference करना**
```javascript
const axios = require("axios");
const fs = require("fs");
const image = fs.readFileSync("YOUR_IMAGE.jpg", {
encoding: "base64"
});
axios({
method: "POST",
url: "https://serverless.roboflow.com/your-model/42",
params: {
api_key: "YOUR_KEY"
},
data: image,
headers: {
"Content-Type": "application/x-www-form-urlencoded"
}
})
.then(function(response) {
console.log(response.data);
})
.catch(function(error) {
console.log(error.message);
});
```
**URL के माध्यम से कहीं और होस्ट की गई छवि पर inference करना**
```javascript
const axios = require("axios");
axios({
method: "POST",
url: "https://serverless.roboflow.com/your-model/42",
params: {
api_key: "YOUR_KEY",
image: "https://i.imgur.com/PEEvqPN.png"
}
})
.then(function(response) {
console.log(response.data);
})
.catch(function(error) {
console.log(error.message);
});
```
**वेब**
हमारे पास realtime on-device inference उपलब्ध है via `roboflow.js`; देखें [दस्तावेज़ यहाँ देखें](/roboflow/roboflow-hi/deploy/sdks/web-browser.md).
{% endtab %}
{% tab title="Swift/iOS" %}
**Swift**
**एक स्थानीय छवि पर inference करना**
```swift
import UIKit
// छवि लोड करें और Base64 में परिवर्तित करें
let image = UIImage(named: "your-image-path") // अपलोड करने के लिए छवि का पथ, उदाहरण: image.jpg
let imageData = image?.jpegData(compressionQuality: 1)
let fileContent = imageData?.base64EncodedString()
let postData = fileContent!.data(using: .utf8)
// API_KEY, मॉडल, और मॉडल संस्करण के साथ Inference Server Request प्रारंभ करें
var request = URLRequest(url: URL(string: "https://serverless.roboflow.com/your-model/your-model-version?api_key=YOUR_APIKEY&name=YOUR_IMAGE.jpg")!,timeoutInterval: Double.infinity)
request.addValue("application/x-www-form-urlencoded", forHTTPHeaderField: "Content-Type")
request.httpMethod = "POST"
request.httpBody = postData
// Post Request निष्पादित करें
URLSession.shared.dataTask(with: request, completionHandler: { data, response, error in
// Response को String में parse करें
guard let data = data else {
print(String(describing: error))
return
}
// Response String को Dictionary में परिवर्तित करें
do {
let dict = try JSONSerialization.jsonObject(with: data, options: []) as? [String: Any]
} catch {
print(error.localizedDescription)
}
// String Response प्रिंट करें
print(String(data: data, encoding: .utf8)!)
}).resume()
```
**Objective C**
[Objective-C snippet का अनुरोध करने के लिए यहाँ क्लिक करें।](https://app.roboflow.com/request/snippet.inference-objc)
{% endtab %}
{% tab title="Android" %}
**Kotlin**
**एक स्थानीय छवि पर inference करना**
```kotlin
import java.io.*
import java.net.HttpURLConnection
import java.net.URL
import java.nio.charset.StandardCharsets
import java.util.*
fun main() {
// छवि का पथ प्राप्त करें
val filePath = System.getProperty("user.dir") + System.getProperty("file.separator") + "YOUR_IMAGE.jpg"
val file = File(filePath)
// Base 64 Encode करें
val encodedFile: String
val fileInputStreamReader = FileInputStream(file)
val bytes = ByteArray(file.length().toInt())
fileInputStreamReader.read(bytes)
encodedFile = String(Base64.getEncoder().encode(bytes), StandardCharsets.US_ASCII)
val API_KEY = "" // आपकी API Key
val MODEL_ENDPOINT = "dataset/v" // model endpoint सेट करें (Dataset URL में मिला)
// URL बनाएं
val uploadURL ="https://serverless.roboflow.com/" + MODEL_ENDPOINT + "?api_key=" + API_KEY + "&name=YOUR_IMAGE.jpg";
// Http Request
var connection: HttpURLConnection? = null
try {
// URL के लिए connection कॉन्फ़िगर करें
val url = URL(uploadURL)
connection = url.openConnection() as HttpURLConnection
connection.requestMethod = "POST"
connection.setRequestProperty("Content-Type",
"application/x-www-form-urlencoded")
connection.setRequestProperty("Content-Length",
Integer.toString(encodedFile.toByteArray().size))
connection.setRequestProperty("Content-Language", "en-US")
connection.useCaches = false
connection.doOutput = true
// अनुरोध भेजें
val wr = DataOutputStream(
connection.outputStream)
wr.writeBytes(encodedFile)
wr.close()
// Response प्राप्त करें
val stream = connection.inputStream
val reader = BufferedReader(InputStreamReader(stream))
var line: String?
while (reader.readLine().also { line = it } != null) {
println(line)
}
reader.close()
} catch (e: Exception) {
e.printStackTrace()
} finally {
connection?.disconnect()
}
}
main()
```
**URL के माध्यम से कहीं और होस्ट की गई छवि पर inference करना**
```kotlin
import java.io.BufferedReader
import java.io.DataOutputStream
import java.io.InputStreamReader
import java.net.HttpURLConnection
import java.net.URL
import java.net.URLEncoder
fun main() {
val imageURL = "https://i.imgur.com/PEEvqPN.png" // Image URL बदलें
val API_KEY = "" // आपकी API Key
val MODEL_ENDPOINT = "dataset/v" // model endpoint सेट करें
// Upload URL
val uploadURL = "https://serverless.roboflow.com/" + MODEL_ENDPOINT + "?api_key=" + API_KEY + "&image=" + URLEncoder.encode(imageURL, "utf-8");
// Http Request
var connection: HttpURLConnection? = null
try {
// URL के लिए connection कॉन्फ़िगर करें
val url = URL(uploadURL)
connection = url.openConnection() as HttpURLConnection
connection.requestMethod = "POST"
connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded")
connection.setRequestProperty("Content-Length", Integer.toString(uploadURL.toByteArray().size))
connection.setRequestProperty("Content-Language", "en-US")
connection.useCaches = false
connection.doOutput = true
// अनुरोध भेजें
val wr = DataOutputStream(connection.outputStream)
wr.writeBytes(uploadURL)
wr.close()
// Response प्राप्त करें
val stream = URL(uploadURL).openStream()
val reader = BufferedReader(InputStreamReader(stream))
var line: String?
while (reader.readLine().also { line = it } != null) {
println(line)
}
reader.close()
} catch (e: Exception) {
e.printStackTrace()
} finally {
connection?.disconnect()
}
}
main()
```
**Java**
**एक स्थानीय छवि पर inference करना**
```java
import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
import java.nio.charset.StandardCharsets;
import java.util.Base64;
public class InferenceLocal {
public static void main(String[] args) throws IOException {
// छवि का पथ प्राप्त करें
String filePath = System.getProperty("user.dir") + System.getProperty("file.separator") + "YOUR_IMAGE.jpg";
File file = new File(filePath);
// Base 64 Encode करें
String encodedFile;
FileInputStream fileInputStreamReader = new FileInputStream(file);
byte[] bytes = new byte[(int) file.length()];
fileInputStreamReader.read(bytes);
encodedFile = new String(Base64.getEncoder().encode(bytes), StandardCharsets.US_ASCII);
String API_KEY = ""; // आपकी API Key
String MODEL_ENDPOINT = "dataset/v"; // model endpoint
// URL बनाएं
String uploadURL = "https://serverless.roboflow.com/" + MODEL_ENDPOINT + "?api_key=" + API_KEY
+ "&name=YOUR_IMAGE.jpg";
// Http Request
HttpURLConnection connection = null;
try {
// URL के लिए connection कॉन्फ़िगर करें
URL url = new URL(uploadURL);
connection = (HttpURLConnection) url.openConnection();
connection.setRequestMethod("POST");
connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
connection.setRequestProperty("Content-Length", Integer.toString(encodedFile.getBytes().length));
connection.setRequestProperty("Content-Language", "en-US");
connection.setUseCaches(false);
connection.setDoOutput(true);
// अनुरोध भेजें
DataOutputStream wr = new DataOutputStream(connection.getOutputStream());
wr.writeBytes(encodedFile);
wr.close();
// Response प्राप्त करें
InputStream stream = connection.getInputStream();
BufferedReader reader = new BufferedReader(new InputStreamReader(stream));
String line;
while ((line = reader.readLine()) != null) {
System.out.println(line);
}
reader.close();
} catch (Exception e) {
e.printStackTrace();
} finally {
if (connection != null) {
connection.disconnect();
}
}
}
}
```
**URL के माध्यम से कहीं और होस्ट की गई छवि पर inference करना**
```java
import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;
public class InferenceHosted {
public static void main(String[] args) {
String imageURL = "https://i.imgur.com/PEEvqPN.png"; // Image URL बदलें
String API_KEY = ""; // आपकी API Key
String MODEL_ENDPOINT = "dataset/v"; // model endpoint
// Upload URL
String uploadURL = "https://serverless.roboflow.com/" + MODEL_ENDPOINT + "?api_key=" + API_KEY + "&image="
+ URLEncoder.encode(imageURL, StandardCharsets.UTF_8);
// Http Request
HttpURLConnection connection = null;
try {
// URL के लिए connection कॉन्फ़िगर करें
URL url = new URL(uploadURL);
connection = (HttpURLConnection) url.openConnection();
connection.setRequestMethod("POST");
connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
connection.setRequestProperty("Content-Length", Integer.toString(uploadURL.getBytes().length));
connection.setRequestProperty("Content-Language", "en-US");
connection.setUseCaches(false);
connection.setDoOutput(true);
// अनुरोध भेजें
DataOutputStream wr = new DataOutputStream(connection.getOutputStream());
wr.writeBytes(uploadURL);
wr.close();
// Response प्राप्त करें
InputStream stream = new URL(uploadURL).openStream();
BufferedReader reader = new BufferedReader(new InputStreamReader(stream));
String line;
while ((line = reader.readLine()) != null) {
System.out.println(line);
}
reader.close();
} catch (Exception e) {
e.printStackTrace();
} finally {
if (connection != null) {
connection.disconnect();
}
}
}
}
```
{% endtab %}
{% tab title="Ruby" %}
**Gemfile**
{% code title="Gemfile" %}
```ruby
source "https://rubygems.org"
gem "httparty", "~> 0.18.1"
gem "base64", "~> 0.1.0"
gem "cgi", "~> 0.2.1"
```
{% endcode %}
**Gemfile.lock**
{% code title="Gemfile.lock" %}
```ruby
GEM
remote: https://rubygems.org/
specs:
base64 (0.1.0)
cgi (0.2.1)
httparty (0.18.1)
mime-types (~> 3.0)
multi_xml (>= 0.5.2)
mime-types (3.3.1)
mime-types-data (~> 3.2015)
mime-types-data (3.2021.0225)
multi_xml (0.6.0)
PLATFORMS
x64-mingw32
x86_64-linux
DEPENDENCIES
base64 (~> 0.1.0)
cgi (~> 0.2.1)
httparty (~> 0.18.1)
BUNDLED WITH
2.2.15
```
{% endcode %}
**एक स्थानीय छवि पर inference करना**
```ruby
require 'base64'
require 'httparty'
encoded = Base64.encode64(File.open("YOUR_IMAGE.jpg", "rb").read)
model_endpoint = "dataset/v" # model endpoint सेट करें
api_key = "" # आपकी API KEY यहाँ
params = "?api_key=" + api_key
+ "&name=YOUR_IMAGE.jpg"
response = HTTParty.post(
"https://serverless.roboflow.com/" + model_endpoint + params,
body: encoded,
headers: {
'Content-Type' => 'application/x-www-form-urlencoded',
'charset' => 'utf-8'
})
puts response
```
**URL के माध्यम से कहीं और होस्ट की गई छवि पर inference करना**
```ruby
require 'httparty'
require 'cgi'
model_endpoint = "dataset/v" # model endpoint सेट करें
api_key = "" # आपकी API KEY यहाँ
img_url = "https://i.imgur.com/PEEvqPN.png" # URL बनाएं
img_url = CGI::escape(img_url)
params = "?api_key=" + api_key + "&image=" + img_url
response = HTTParty.post(
"https://serverless.roboflow.com/" + model_endpoint + params,
headers: {
'Content-Type' => 'application/x-www-form-urlencoded',
'charset' => 'utf-8'
})
puts response
```
{% endtab %}
{% tab title="PHP" %}
**एक स्थानीय छवि पर inference करना**
```php
array (
'header' => "Content-type: application/x-www-form-urlencoded\r\n",
'method' => 'POST',
'content' => $data
));
$context = stream_context_create($options);
$result = file_get_contents($url, false, $context);
echo $result;
?>
```
**URL के माध्यम से कहीं और होस्ट की गई छवि पर inference करना**
```php
array (
'header' => "Content-type: application/x-www-form-urlencoded\r\n",
'method' => 'POST'
));
$context = stream_context_create($options);
$result = file_get_contents($url, false, $context);
echo $result;
?>
```
{% endtab %}
{% tab title="Go" %}
**एक स्थानीय छवि पर inference करना**
```go
package main
import (
"bufio"
"encoding/base64"
"fmt"
"io/ioutil"
"os"
"net/http"
"strings"
)
func main() {
api_key := "" // आपकी API Key
model_endpoint := "dataset/v" // model endpoint सेट करें
// डिस्क पर फ़ाइल खोलें।
f, _ := os.Open("YOUR_IMAGE.jpg")
// संपूर्ण JPG को byte slice में पढ़ें.
reader := bufio.NewReader(f)
content, _ := ioutil.ReadAll(reader)
// base64 में एन्कोड करें.
data := base64.StdEncoding.EncodeToString(content)
uploadURL := "https://serverless.roboflow.com/" + model_endpoint + "?api_key=" + api_key + "&name=YOUR_IMAGE.jpg"
req, _ := http.NewRequest("POST", uploadURL, strings.NewReader(data))
req.Header.Set("Accept", "application/json")
client := &http.Client{}
resp, _ := client.Do(req)
defer resp.Body.Close()
bytes, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(bytes))
}
```
**URL के माध्यम से कहीं और होस्ट की गई छवि पर inference करना**
```go
package main
import (
"fmt"
"net/http"
"net/url"
"io/ioutil"
)
func main() {
api_key := "" // आपकी API Key
model_endpoint := "dataset/v" // model endpoint सेट करें
img_url := "https://i.ibb.co/jzr27x0/YOUR-IMAGE.jpg"
uploadURL := "https://serverless.roboflow.com/" + model_endpoint + "?api_key=" + api_key + "&image=" + url.QueryEscape(img_url)
req, _ := http.NewRequest("POST", uploadURL, nil)
req.Header.Set("Accept", "application/json")
client := &http.Client{}
resp, _ := client.Do(req)
defer resp.Body.Close()
bytes, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(bytes))
}
```
{% endtab %}
{% tab title=".NET" %}
**एक स्थानीय छवि पर inference करना**
```csharp
using System;
using System.IO;
using System.Net;
using System.Text;
namespace InferenceLocal
{
class InferenceLocal
{
static void Main(string[] args)
{
byte[] imageArray = System.IO.File.ReadAllBytes(@"YOUR_IMAGE.jpg");
string encoded = Convert.ToBase64String(imageArray);
byte[] data = Encoding.ASCII.GetBytes(encoded);
string API_KEY = ""; // आपकी API key
string MODEL_ENDPOINT = "dataset/v"; // model endpoint सेट करें
// URL बनाएं
string uploadURL =
"https://serverless.roboflow.com/" + MODEL_ENDPOINT + "?api_key=" + API_KEY
+ "&name=YOUR_IMAGE.jpg";
// Service Request कॉन्फ़िगरेशन
ServicePointManager.Expect100Continue = true;
ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;
// Request कॉन्फ़िगर करें
WebRequest request = WebRequest.Create(uploadURL);
request.Method = "POST";
request.ContentType = "application/x-www-form-urlencoded";
request.ContentLength = data.Length;
// डेटा लिखें
using (Stream stream = request.GetRequestStream())
{
stream.Write(data, 0, data.Length);
}
// Response प्राप्त करें
string responseContent = null;
using (WebResponse response = request.GetResponse())
{
using (Stream stream = response.GetResponseStream())
{
using (StreamReader sr99 = new StreamReader(stream))
{
responseContent = sr99.ReadToEnd();
}
}
}
Console.WriteLine(responseContent);
}
}
}
```
**URL के माध्यम से कहीं और होस्ट की गई छवि पर inference करना**
```csharp
using System;
using System.IO;
using System.Net;
using System.Web;
namespace InferenceHosted
{
class InferenceHosted
{
static void Main(string[] args)
{
string API_KEY = ""; // आपकी API key
string imageURL = "https://i.ibb.co/jzr27x0/YOUR-IMAGE.jpg";
string MODEL_ENDPOINT = "dataset/v"; // model endpoint सेट करें
// URL बनाएं
string uploadURL =
"https://serverless.roboflow.com/" + MODEL_ENDPOINT
+ "?api_key=" + API_KEY
+ "&image=" + HttpUtility.UrlEncode(imageURL);
// Service Point कॉन्फ़िगरेशन
ServicePointManager.Expect100Continue = true;
ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;
// Http Request कॉन्फ़िगर करें
WebRequest request = WebRequest.Create(uploadURL);
request.Method = "POST";
request.ContentType = "application/x-www-form-urlencoded";
request.ContentLength = 0;
// Response प्राप्त करें
string responseContent = null;
using (WebResponse response = request.GetResponse())
{
using (Stream stream = response.GetResponseStream())
{
using (StreamReader sr99 = new StreamReader(stream))
{
responseContent = sr99.ReadToEnd();
}
}
}
Console.WriteLine(responseContent);
}
}
}
```
{% endtab %}
{% tab title="Elixir" %}
हम उपयोगकर्ताओं द्वारा अनुरोध किए जाने पर code snippets जोड़ रहे हैं। यदि आप inference API को अपने Elixir app में integrate करना चाहते हैं, तो कृपया [अपना upvote रिकॉर्ड करने के लिए यहाँ क्लिक करें](https://app.roboflow.com/request/snippet.upload-elixir).
{% endtab %}
{% endtabs %}
### प्रतिक्रिया ऑब्जेक्ट प्रारूप
होस्टेड API inference route एक `JSON` predictions की एक array वाला object. प्रत्येक prediction में निम्नलिखित properties होती हैं:
* `x` = पहचानी गई वस्तु का क्षैतिज केंद्र बिंदु
* `y` = पहचानी गई वस्तु का ऊर्ध्वाधर केंद्र बिंदु
* `width` = bounding box की चौड़ाई
* `height` = bounding box की ऊँचाई
* `class` = पहचानी गई वस्तु का class label
* `confidence` = इस बात पर model का confidence कि पहचानी गई वस्तु के पास सही label और position coordinates हैं
* `keypoints` = keypoint predictions की एक array
* `x` = keypoint का क्षैतिज केंद्र (image के top-left corner के सापेक्ष)
* `y` = keypoint का ऊर्ध्वाधर केंद्र (image के top-left corner के सापेक्ष)
* `class_name` = keypoint का नाम
* `class_id` = keypoint का ID, skeleton से मैप होता है `vertices` version record में, vertex color और skeleton edges को map करने के लिए, [अपना Project Version देखें](/developer/rest-api/versions/view-a-version.md)
* `confidence` = इस बात पर confidence कि keypoint की स्थिति सही है, और वह दिखाई दे रहा है (occluded या deleted नहीं)
REST API से प्राप्त response object का एक उदाहरण यहाँ है:
```json
{
"predictions": [
{
"x": 189.5,
"y": 100,
"width": 163,
"height": 186,
"class": "helmet",
"confidence": 0.544,
"keypoints": [
{
"x": 189,
"y": 20,
"class_name": "top",
"class_id": 0,
"confidence": 0.91
},
{
"x": 188,
"y": 180,
"class_name": "bottom",
"class_id": 1,
"confidence": 0.93
}
]
}
],
"image": {
"width": 2048,
"height": 1371
}
}
```
यह `छवि` attribute में inference के लिए भेजी गई image की height और width शामिल हैं। bounding box calculations के लिए आपको इन values का उपयोग करने की आवश्यकता हो सकती है.
### Inference API पैरामीटर
## Inference API का उपयोग
`POST` `https://serverless.roboflow.com/:datasetSlug/:versionNumber`
आप base64 encoded image को सीधे अपने model endpoint पर POST कर सकते हैं। या यदि आपकी image पहले से कहीं और hosted है, तो आप URL को query string में as the `छवि` parameter के रूप में पास कर सकते हैं यदि आपकी image पहले से कहीं और hosted है.
#### पाथ पैरामीटर
| नाम | प्रकार | विवरण |
| ----------- | ------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| datasetSlug | string | dataset name का URL-safe version. आप इसे web UI में main project view पर URL देखकर या model training के बाद अपनी dataset version के train results section में "Get curl command" button पर क्लिक करके पा सकते हैं. |
| version | number | आपके dataset के संस्करण की पहचान करने वाला version number |
#### क्वेरी पैरामीटर
| नाम | प्रकार | विवरण |
| ---------- | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| छवि | string | जोड़ने के लिए image का URL. यदि आपकी image कहीं और hosted है, तो इसका उपयोग करें। (जब आप request body में base64 encoded image POST नहीं करते, तब आवश्यक.)
ध्यान दें: इसे URL-encode करना न भूलें.
|
| classes | string | पूर्वानुमानों को केवल कुछ निश्चित classes तक सीमित करें। अल्पविराम से अलग की गई string के रूप में प्रदान करें.
उदाहरण: dog,cat
डिफ़ॉल्ट: उपस्थित नहीं (सभी classes दिखाएँ)
|
| overlap | number | एक ही class के bounding box predictions को एक single box में संयोजित किए जाने से पहले उनके overlap की अनुमति वाला अधिकतम प्रतिशत (0-100 के पैमाने पर).
डिफ़ॉल्ट: 30
|
| confidence | number | returned predictions के लिए 0-100 के पैमाने पर एक threshold. कम संख्या अधिक predictions लौटाएगी। अधिक संख्या कम, उच्च-विश्वास वाली predictions लौटाएगी.
डिफ़ॉल्ट: 40
|
| stroke | number | predictions के चारों ओर प्रदर्शित bounding box की चौड़ाई (pixels में) (केवल तब प्रभावी होती है जब format is छवि).
डिफ़ॉल्ट: 1
|
| labels | boolean | predictions पर text labels दिखाने हैं या नहीं (केवल तब प्रभावी होती है जब format is छवि).
डिफ़ॉल्ट: false
|
| format | string | json - JSON predictions की एक array लौटाता है. (response format tab देखें).
छवि - annotated predictions वाली image को एक binary blob के रूप में लौटाता है, एक Content-Type का image/jpeg. image\_and\_json - JSON predictions की एक array लौटाता है, जिसमें base64 में एक visualization field शामिल है.
डिफ़ॉल्ट: json
|
| api\_key | string | आपकी API key (आपके workspace API settings page से प्राप्त) |
#### Request Body
| नाम | प्रकार | विवरण |
| --- | ------ | ------------------------------------------------------------------------------------- |
| | string | एक base64-encoded image. (जब आप query parameters में image URL नहीं देते, तब आवश्यक.) |
{% tabs %}
{% tab title="200 JSON format predictions. (x,y) बॉक्स के हैं" %}
```
{
"predictions": [{
"x": 234.0,
"y": 363.5,
"width": 160,
"height": 197,
"class": "hand",
"confidence": 0.943
}, {
"x": 504.5,
"y": 363.0,
"width": 215,
"height": 172,
"class": "hand",
"confidence": 0.917
}, {
"x": 1112.5,
"y": 691.0,
"width": 139,
"height": 52,
"class": "hand",
"confidence": 0.87
}, {
"x": 78.5,
"y": 700.0,
"width": 139,
"height": 34,
"class": "hand",
"confidence": 0.404
}]
}
```
{% endtab %}
{% tab title="403 यदि आपकी api\_key model तक पहुँचने के लिए अधिकृत नहीं है." %}
```
{
"Message": "User is not authorized to access this resource"
}
```
{% endtab %}
{% endtabs %}
---
# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.
## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.
Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:
```
GET https://docs.roboflow.com/roboflow/roboflow-hi/deploy/serverless/keypoint-detection.md?ask=&goal=
```
`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.