feat(docs-i18n): translate all documentation into 20 languages

All 181 docs markdown files translated into 20 languages (apps/docs/<locale>/**). Companion to the i18n code PR; admin-merged because the file count exceeds GitHub's per-PR CI trigger limit. Validated by pnpm i18n:check (all surfaces, 0 stale/missing) and a clean all-locale docs build.
This commit is contained in:
SnapOtter
2026-07-11 13:52:47 +08:00
committed by GitHub
parent 00b651c9f8
commit 4963ab3bbd
3620 changed files with 306134 additions and 0 deletions
+71
View File
@@ -0,0 +1,71 @@
---
description: "चमक, कंट्रास्ट, संतृप्ति, तापमान, ह्यू, चैनल समायोजित करें और रंग प्रभाव लागू करें।"
i18n_source_hash: 41b35fe5c2ba
i18n_provenance: human
i18n_output_hash: a439daab9132
---
# Adjust Colors {#adjust-colors}
एक ही एंडपॉइंट में चमक, कंट्रास्ट, एक्सपोज़र, संतृप्ति, तापमान, टिंट, ह्यू रोटेशन, प्रति-चैनल स्तर, और एक-क्लिक प्रभावों (ग्रेस्केल, सेपिया, इनवर्ट) को मिलाने वाला व्यापक रंग समायोजन टूल।
## API Endpoint {#api-endpoint}
`POST /api/v1/tools/image/adjust-colors`
एक छवि फ़ाइल और एक JSON `settings` फ़ील्ड के साथ multipart form data स्वीकार करता है।
## Parameters {#parameters}
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| brightness | number | No | `0` | चमक समायोजन (-100 से 100) |
| contrast | number | No | `0` | कंट्रास्ट समायोजन (-100 से 100) |
| exposure | number | No | `0` | एक्सपोज़र / मिडटोन गामा (-100 से 100) |
| saturation | number | No | `0` | रंग संतृप्ति (-100 से 100) |
| temperature | number | No | `0` | व्हाइट बैलेंस: ठंडा/नीला से गर्म/नारंगी (-100 से 100) |
| tint | number | No | `0` | टिंट शिफ्ट: हरा से मैजेंटा (-100 से 100) |
| hue | number | No | `0` | डिग्री में ह्यू रोटेशन (-180 से 180) |
| sharpness | number | No | `0` | शार्पनिंग की ताकत (0 से 100) |
| red | number | No | `100` | लाल चैनल स्तर (0 से 200, 100 = अपरिवर्तित) |
| green | number | No | `100` | हरा चैनल स्तर (0 से 200, 100 = अपरिवर्तित) |
| blue | number | No | `100` | नीला चैनल स्तर (0 से 200, 100 = अपरिवर्तित) |
| effect | string | No | `"none"` | रंग प्रभाव: `none`, `grayscale`, `sepia`, `invert` |
## Example Request {#example-request}
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/adjust-colors \
-H "Authorization: Bearer si_your-api-key" \
-F "file=@photo.jpg" \
-F 'settings={"brightness": 20, "contrast": 10, "saturation": -30, "effect": "none"}'
```
एक गर्म विंटेज लुक लागू करें:
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/adjust-colors \
-H "Authorization: Bearer si_your-api-key" \
-F "file=@photo.jpg" \
-F 'settings={"temperature": 40, "saturation": -15, "contrast": 10, "effect": "sepia"}'
```
## Example Response {#example-response}
```json
{
"jobId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"downloadUrl": "/api/v1/download/a1b2c3d4-e5f6-7890-abcd-ef1234567890/photo.jpg",
"originalSize": 2450000,
"processedSize": 2380000
}
```
## Notes {#notes}
- सभी पैरामीटर तटस्थ मानों पर डिफ़ॉल्ट होते हैं ताकि आप केवल वही समायोजित कर सकें जिसकी आपको आवश्यकता है।
- समायोजन इस क्रम में लागू किए जाते हैं: चमक, कंट्रास्ट, एक्सपोज़र, संतृप्ति/ह्यू, तापमान/टिंट, शार्पनेस, चैनल, प्रभाव।
- तापमान नीले-नारंगी और हरे-मैजेंटा अक्षों पर एक 3x3 रंग पुनर्संयोजन मैट्रिक्स का उपयोग करता है।
- एक्सपोज़र Sharp के गामा फ़ंक्शन से मैप होता है (धनात्मक मिडटोन को उज्ज्वल करता है, ऋणात्मक उन्हें गहरा करता है)।
- यह एंडपॉइंट लेगेसी पथों `/api/v1/tools/image/brightness-contrast`, `/api/v1/tools/image/saturation`, `/api/v1/tools/image/color-channels`, और `/api/v1/tools/image/color-effects` पर भी प्रतिक्रिया देता है। सभी एक ही स्कीमा का उपयोग करते हैं।
- आउटपुट प्रारूप इनपुट प्रारूप से मेल खाता है। HEIC, RAW, PSD, और SVG इनपुट को प्रोसेसिंग से पहले स्वचालित रूप से डिकोड किया जाता है।
@@ -0,0 +1,84 @@
---
description: "AI आउटपेंटिंग से किसी छवि के कैनवास का विस्तार करें, इसे किसी भी दिशा में बढ़ाएँ और नए क्षेत्रों को मूल से मेल खाने के लिए भरें।"
i18n_source_hash: 1b00db4ed40d
i18n_provenance: human
i18n_output_hash: 4313b48bf882
---
# AI Canvas Expand {#ai-canvas-expand}
AI-संचालित फिल (आउटपेंटिंग) से किसी छवि के कैनवास का विस्तार करें। छवि को किसी भी दिशा में बढ़ाता है और नए क्षेत्रों को मौजूदा छवि से मेल खाने वाली AI-जनित सामग्री से भरता है।
## API Endpoint {#api-endpoint}
`POST /api/v1/tools/image/ai-canvas-expand`
**Processing:** असिंक्रोनस (202 लौटाता है, स्थिति के लिए SSE के ज़रिए `/api/v1/jobs/{jobId}/progress` पोल करें)
**Model bundle:** `object-eraser-colorize` (1-2 GB)
## Parameters {#parameters}
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| file | file | Yes | - | छवि फ़ाइल (multipart) |
| extendTop | integer | No | `0` | शीर्ष पर विस्तार करने के लिए पिक्सेल |
| extendRight | integer | No | `0` | दाईं ओर विस्तार करने के लिए पिक्सेल |
| extendBottom | integer | No | `0` | नीचे विस्तार करने के लिए पिक्सेल |
| extendLeft | integer | No | `0` | बाईं ओर विस्तार करने के लिए पिक्सेल |
| tier | string | No | `"balanced"` | गुणवत्ता श्रेणी: `fast`, `balanced`, `high` |
| format | string | No | `"auto"` | आउटपुट प्रारूप: `auto`, `png`, `jpg`, `jpeg`, `webp`, `tiff`, `gif`, `avif`, `heic`, `heif`, `jxl` |
| quality | integer | No | `95` | आउटपुट गुणवत्ता (1-100) |
कम से कम एक विस्तार दिशा 0 से अधिक होनी चाहिए।
## Example Request {#example-request}
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/ai-canvas-expand \
-F "file=@photo.jpg" \
-F 'settings={"extendTop":200,"extendBottom":200,"extendLeft":100,"extendRight":100,"tier":"balanced"}'
```
## Response {#response}
### Initial Response (202 Accepted) {#initial-response-202-accepted}
```json
{
"jobId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"async": true
}
```
### Progress (SSE at `/api/v1/jobs/{jobId}/progress`) {#progress-sse-at-api-v1-jobs-jobid-progress}
```
event: progress
data: {"phase":"processing","stage":"Expanding canvas...","percent":50}
```
### Final Result (via SSE) {#final-result-via-sse}
```json
{
"phase": "complete",
"percent": 100,
"result": {
"jobId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"downloadUrl": "/api/v1/download/{jobId}/photo_extended.png",
"previewUrl": "/api/v1/download/{jobId}/preview.webp",
"originalSize": 300000,
"processedSize": 520000
}
}
```
## Notes {#notes}
- इसके लिए `object-eraser-colorize` मॉडल बंडल का इंस्टॉल होना आवश्यक है (1-2 GB)।
- विस्तारित क्षेत्रों के लिए सामग्री उत्पन्न करने हेतु LaMa-आधारित आउटपेंटिंग का उपयोग करता है।
- `tier` पैरामीटर गति और गुणवत्ता के बीच समझौता करता है: `fast` संभावित आर्टिफ़ैक्ट के साथ त्वरित परिणाम देता है, `high` अधिक समय लेता है लेकिन अधिक चिकने, अधिक सुसंगत फिल देता है।
- विस्तार मान पिक्सेल में होते हैं। अंतिम छवि आयाम होंगे: मूल चौड़ाई + extendLeft + extendRight गुणा मूल ऊँचाई + extendTop + extendBottom।
- गैर-ब्राउज़र-पूर्वावलोकन योग्य आउटपुट प्रारूपों (HEIC, JXL, TIFF) के लिए, मुख्य आउटपुट के साथ एक WebP पूर्वावलोकन उत्पन्न किया जाता है।
- स्वचालित डिकोडिंग के ज़रिए HEIC/HEIF, RAW, TGA, PSD, EXR, और HDR इनपुट प्रारूपों का समर्थन करता है।
@@ -0,0 +1,55 @@
---
description: "AI का उपयोग करके छवि की पृष्ठभूमि को एक ठोस रंग या ग्रेडिएंट से बदलें।"
i18n_source_hash: 930fe8890e55
i18n_provenance: human
i18n_output_hash: 0eeee903fd14
---
# Background Replace {#background-replace}
किसी छवि की पृष्ठभूमि को एक ठोस रंग या ग्रेडिएंट से बदलें। AI मॉडल विषय का पता लगाता है, मूल पृष्ठभूमि हटाता है, और विषय को आपकी चुनी हुई पृष्ठभूमि पर कंपोज़िट करता है।
## API Endpoint {#api-endpoint}
`POST /api/v1/tools/image/background-replace`
एक छवि फ़ाइल और एक JSON `settings` फ़ील्ड के साथ multipart form data स्वीकार करता है।
## Parameters {#parameters}
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| backgroundType | string | No | `"color"` | पृष्ठभूमि मोड: `color` या `gradient` |
| color | string | No | `"#ffffff"` | पृष्ठभूमि हेक्स रंग (जब backgroundType `color` हो) |
| gradientColor1 | string | No | - | पहला ग्रेडिएंट हेक्स रंग |
| gradientColor2 | string | No | - | दूसरा ग्रेडिएंट हेक्स रंग |
| gradientAngle | integer | No | `180` | डिग्री में ग्रेडिएंट कोण (0-360) |
| feather | integer | No | `0` | एज फ़ेदरिंग त्रिज्या (0-20) |
| format | string | No | `"png"` | आउटपुट प्रारूप: `png` या `webp` |
## Example Request {#example-request}
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/background-replace \
-H "Authorization: Bearer si_your-api-key" \
-F "file=@photo.jpg" \
-F 'settings={"backgroundType": "color", "color": "#2563eb", "feather": 2}'
```
## Example Response {#example-response}
```json
{
"jobId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"async": true
}
```
`GET /api/v1/jobs/{jobId}/progress` पर SSE के ज़रिए प्रगति ट्रैक करें। जब जॉब पूरा होता है, तो SSE स्ट्रीम डाउनलोड URL के साथ एक `completed` इवेंट उत्सर्जित करता है।
## Notes {#notes}
- यह एक AI-संचालित टूल है जो `202 Accepted` लौटाता है और असिंक्रोनस रूप से प्रोसेस करता है। प्रगति अपडेट और अंतिम परिणाम प्राप्त करने के लिए SSE एंडपॉइंट से कनेक्ट करें।
- इसके लिए **background-removal** फ़ीचर बंडल का इंस्टॉल होना आवश्यक है। यदि बंडल उपलब्ध नहीं है तो `501` लौटाता है।
- HEIC, RAW, PSD, और SVG इनपुट को प्रोसेसिंग से पहले स्वचालित रूप से डिकोड किया जाता है।
- विषय के चारों ओर पारदर्शिता संरक्षित करने के लिए आउटपुट PNG पर डिफ़ॉल्ट होता है।
@@ -0,0 +1,52 @@
---
description: "Code 128, EAN-13, UPC-A, Code 39, ITF-14, और Data Matrix प्रारूपों में बारकोड उत्पन्न करें।"
i18n_source_hash: e84b1df40c7e
i18n_provenance: human
i18n_output_hash: 662d4fa71be5
---
# Barcode Generator {#barcode-generator}
टेक्स्ट इनपुट से बारकोड छवियाँ उत्पन्न करें। Code 128, EAN-13, UPC-A, Code 39, ITF-14, और Data Matrix प्रारूपों का समर्थन करता है।
## API Endpoint {#api-endpoint}
`POST /api/v1/tools/image/barcode-generate`
एक `application/json` बॉडी स्वीकार करता है (multipart नहीं)। बारकोड प्रदान किए गए टेक्स्ट से उत्पन्न होता है, अपलोड की गई फ़ाइल से नहीं।
## Parameters {#parameters}
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| text | string | Yes | - | बारकोड में एनकोड करने के लिए टेक्स्ट (1-256 वर्ण) |
| type | string | No | `"code128"` | बारकोड प्रारूप: `code128`, `ean13`, `upca`, `code39`, `itf14`, `datamatrix` |
| scale | integer | No | `3` | छवि स्केल कारक (1-8) |
| includeText | boolean | No | `true` | बारकोड के नीचे टेक्स्ट रेंडर करना है या नहीं |
## Example Request {#example-request}
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/barcode-generate \
-H "Authorization: Bearer si_your-api-key" \
-H "Content-Type: application/json" \
-d '{"text": "5901234123457", "type": "ean13", "scale": 4}'
```
## Example Response {#example-response}
```json
{
"jobId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"downloadUrl": "/api/v1/download/a1b2c3d4-e5f6-7890-abcd-ef1234567890/barcode.png",
"originalSize": 0,
"processedSize": 4520
}
```
## Notes {#notes}
- अधिकांश टूल के विपरीत, यह एंडपॉइंट multipart form data नहीं बल्कि एक JSON बॉडी स्वीकार करता है, क्योंकि बारकोड अपलोड की गई फ़ाइल के बजाय टेक्स्ट से उत्पन्न होते हैं।
- EAN-13 के लिए ठीक 12 या 13 अंक आवश्यक हैं। UPC-A के लिए ठीक 11 या 12 अंक आवश्यक हैं। यदि चेक अंक छोड़ दिया जाता है, तो इसकी गणना स्वचालित रूप से की जाती है।
- Code 128 सबसे लचीला प्रारूप है और पूर्ण ASCII वर्ण सेट का समर्थन करता है।
- Data Matrix एक 2D बारकोड उत्पन्न करता है जो लंबी स्ट्रिंग्स को एक सघन वर्ग में एनकोड करने के लिए उपयुक्त है।
+97
View File
@@ -0,0 +1,97 @@
---
description: "एनोटेट किए गए आउटपुट के साथ QR कोड, बारकोड, और 2D कोड के लिए छवियाँ स्कैन करें।"
i18n_source_hash: 97c9d395c257
i18n_provenance: human
i18n_output_hash: 90b11a4e02c4
---
# Barcode Reader {#barcode-reader}
अपलोड की गई छवियों को सभी प्रकार के बारकोड और QR कोड के लिए स्कैन करें। प्रत्येक पहचाने गए कोड के लिए डिकोड किया गया टेक्स्ट, बारकोड प्रकार, और स्थिति डेटा लौटाता है। पहचाने गए कोड के चारों ओर रंगीन बाउंडिंग बॉक्स के साथ एक एनोटेट की गई छवि भी उत्पन्न करता है।
## API Endpoint {#api-endpoint}
`POST /api/v1/tools/image/barcode-read`
एक छवि फ़ाइल और एक वैकल्पिक JSON `settings` फ़ील्ड के साथ multipart form data स्वीकार करता है।
## Parameters {#parameters}
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| tryHarder | boolean | No | `true` | कठिन-पढ़ने वाले बारकोड के लिए आक्रामक स्कैनिंग मोड सक्षम करें (धीमा लेकिन अधिक गहन) |
## Example Request {#example-request}
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/barcode-read \
-H "Authorization: Bearer si_your-api-key" \
-F "file=@receipt.jpg" \
-F 'settings={"tryHarder": true}'
```
## Example Response {#example-response}
```json
{
"filename": "receipt.jpg",
"barcodes": [
{
"type": "QRCode",
"text": "https://example.com/product/123",
"position": {
"topLeft": { "x": 100, "y": 50 },
"topRight": { "x": 250, "y": 50 },
"bottomLeft": { "x": 100, "y": 200 },
"bottomRight": { "x": 250, "y": 200 }
}
},
{
"type": "EAN-13",
"text": "5901234123457",
"position": {
"topLeft": { "x": 50, "y": 400 },
"topRight": { "x": 300, "y": 400 },
"bottomLeft": { "x": 50, "y": 450 },
"bottomRight": { "x": 300, "y": 450 }
}
}
],
"annotatedUrl": "/api/v1/download/a1b2c3d4-e5f6-7890-abcd-ef1234567890/annotated-receipt.png",
"previewUrl": "/api/v1/download/a1b2c3d4-e5f6-7890-abcd-ef1234567890/annotated-receipt.png"
}
```
## Response Fields {#response-fields}
| Field | Type | Description |
|-------|------|-------------|
| filename | string | मूल फ़ाइल नाम |
| barcodes | array | पहचाने गए बारकोड ऑब्जेक्ट्स की सरणी |
| annotatedUrl | string or null | एनोटेट की गई छवि डाउनलोड करने का URL (कोई बारकोड न मिलने पर null) |
| previewUrl | string or null | annotatedUrl के समान (फ्रंटएंड पूर्वावलोकन संगतता के लिए) |
### Barcode Object {#barcode-object}
| Field | Type | Description |
|-------|------|-------------|
| type | string | बारकोड प्रारूप (QRCode, EAN-13, Code128, DataMatrix, PDF417, आदि) |
| text | string | बारकोड की डिकोड की गई सामग्री |
| position | object | topLeft, topRight, bottomLeft, bottomRight निर्देशांक के साथ बाउंडिंग बॉक्स |
## Supported Barcode Types {#supported-barcode-types}
1D बारकोड: Code128, Code39, Code93, Codabar, EAN-8, EAN-13, ITF, UPC-A, UPC-E
2D बारकोड: QRCode, DataMatrix, PDF417, Aztec, MaxiCode
## Notes {#notes}
- बारकोड पहचान के लिए zxing-wasm लाइब्रेरी का उपयोग करता है।
- एनोटेट की गई छवि प्रत्येक पहचाने गए बारकोड पर रंगीन बहुभुज बाउंडिंग बॉक्स और क्रमांकित लेबल ओवरले करती है।
- एक ही छवि में 255 तक बारकोड पहचाने जा सकते हैं।
- यदि कोई बारकोड नहीं मिलता है, तो `barcodes` एक खाली सरणी होती है और `annotatedUrl` null होता है।
- `tryHarder` मोड प्रोसेसिंग समय की कीमत पर अधिक गहन स्कैनिंग करता है। साफ़, अच्छी तरह संरेखित बारकोड की तेज़ प्रोसेसिंग के लिए इसे अक्षम करें।
- एनोटेट किया गया आउटपुट हमेशा PNG प्रारूप में होता है।
- HEIC, RAW, PSD, और SVG इनपुट को स्कैन करने से पहले स्वचालित रूप से डिकोड किया जाता है।
- प्रोसेसिंग से पहले EXIF ओरिएंटेशन स्वतः लागू किया जाता है।
+85
View File
@@ -0,0 +1,85 @@
---
description: "सादे स्क्रीनशॉट को ग्रेडिएंट पृष्ठभूमि, डिवाइस फ़्रेम, छाया, और सोशल मीडिया साइज़िंग के साथ परिष्कृत छवियों में बदलें।"
i18n_source_hash: 8fd8a930a45e
i18n_provenance: human
i18n_output_hash: fa158e10fa0c
---
# Beautify Screenshot {#beautify-screenshot}
स्क्रीनशॉट में ग्रेडिएंट पृष्ठभूमि, डिवाइस फ़्रेम, छाया, वॉटरमार्क, और सोशल मीडिया साइज़िंग जोड़ें। उत्पाद मार्केटिंग, सोशल मीडिया, और दस्तावेज़ीकरण के लिए परिष्कृत छवियाँ बनाने हेतु आदर्श।
## API Endpoint {#api-endpoint}
`POST /api/v1/tools/image/beautify`
## Parameters {#parameters}
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| backgroundType | string | No | `"linear-gradient"` | पृष्ठभूमि प्रकार: `solid`, `linear-gradient`, `radial-gradient`, `image`, `transparent` |
| backgroundColor | string | No | `"#667eea"` | ठोस पृष्ठभूमि रंग (जब `backgroundType` `solid` हो तब उपयोग किया जाता है) |
| gradientStops | array | No | `[{"color":"#667eea","position":0},{"color":"#764ba2","position":100}]` | ग्रेडिएंट रंग स्टॉप (न्यूनतम 2)। प्रत्येक स्टॉप में `color` (hex) और `position` (0-100) होता है। |
| gradientAngle | number | No | 135 | डिग्री में ग्रेडिएंट कोण (0 से 360) |
| padding | number | No | 64 | पिक्सेल में छवि के चारों ओर पैडिंग (0 से 256) |
| borderRadius | number | No | 12 | स्क्रीनशॉट पर कॉर्नर त्रिज्या (0 से 64) |
| shadowPreset | string | No | `"subtle"` | छाया प्रीसेट: `none`, `subtle`, `medium`, `dramatic`, `custom` |
| shadowBlur | number | No | 20 | कस्टम छाया ब्लर त्रिज्या (0 से 100, जब `shadowPreset` `custom` हो तब उपयोग किया जाता है) |
| shadowOffsetX | number | No | 0 | कस्टम छाया क्षैतिज ऑफसेट (-50 से 50) |
| shadowOffsetY | number | No | 10 | कस्टम छाया ऊर्ध्वाधर ऑफसेट (-50 से 50) |
| shadowColor | string | No | `"#000000"` | hex के रूप में कस्टम छाया रंग |
| shadowOpacity | number | No | 30 | कस्टम छाया अपारदर्शिता (0 से 100) |
| frame | string | No | `"none"` | डिवाइस या विंडो फ़्रेम: `none`, `macos-light`, `macos-dark`, `windows-light`, `windows-dark`, `browser-light`, `browser-dark`, `iphone`, `iphone-dark`, `macbook`, `macbook-dark`, `ipad`, `ipad-dark` |
| frameTitle | string | No | - | विंडो फ़्रेम टाइटल बार में प्रदर्शित टाइटल टेक्स्ट |
| socialPreset | string | No | `"none"` | सोशल मीडिया आयामों में आकार बदलें: `none`, `twitter`, `linkedin`, `instagram-square`, `instagram-story`, `facebook`, `producthunt` |
| watermarkText | string | No | - | वैकल्पिक वॉटरमार्क टेक्स्ट ओवरले |
| watermarkPosition | string | No | `"bottom-right"` | वॉटरमार्क स्थिति: `top-left`, `top-right`, `bottom-left`, `bottom-right`, `center` |
| watermarkOpacity | number | No | 50 | वॉटरमार्क अपारदर्शिता (0 से 100) |
| outputFormat | string | No | `"png"` | आउटपुट प्रारूप: `png`, `jpeg`, `webp` |
## Example Request {#example-request}
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/beautify \
-F "file=@screenshot.png" \
-F 'settings={"backgroundType":"linear-gradient","gradientStops":[{"color":"#667eea","position":0},{"color":"#764ba2","position":100}],"gradientAngle":135,"padding":64,"borderRadius":12,"shadowPreset":"medium","frame":"macos-dark","socialPreset":"twitter"}'
```
### With Background Image {#with-background-image}
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/beautify \
-F "file=@screenshot.png" \
-F "backgroundImage=@bg-texture.jpg" \
-F 'settings={"backgroundType":"image","padding":80,"borderRadius":16,"shadowPreset":"dramatic"}'
```
## Example Response {#example-response}
```json
{
"jobId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"downloadUrl": "/api/v1/download/a1b2c3d4-e5f6-7890-abcd-ef1234567890/screenshot.png",
"originalSize": 234567,
"processedSize": 567890
}
```
## Notes {#notes}
- दो फ़ाइल फ़ील्ड स्वीकार करता है: `file` (आवश्यक, मुख्य स्क्रीनशॉट) और `backgroundImage` (वैकल्पिक, जब `backgroundType` `image` हो तब उपयोग किया जाता है)।
- HEIC, RAW, PSD, और SVG इनपुट प्रारूपों का समर्थन करता है (स्वचालित रूप से डिकोड किए गए)।
- छाया प्रीसेट विशिष्ट मानों से मैप होते हैं:
- `subtle`: blur 20, offsetY 4, opacity 20%
- `medium`: blur 40, offsetY 10, opacity 35%
- `dramatic`: blur 80, offsetY 20, opacity 50%
- सोशल मीडिया प्रीसेट `contain` मोड का उपयोग करके अंतिम आउटपुट को लक्ष्य आयामों में फ़िट करने के लिए आकार बदलते हैं:
- `twitter`: 1600x900
- `linkedin`: 1200x627
- `instagram-square`: 1080x1080
- `instagram-story`: 1080x1920
- `facebook`: 1200x630
- `producthunt`: 1270x760
- डिवाइस फ़्रेम (`iphone`, `macbook`, `ipad`) छवि के चारों ओर एक हार्डवेयर बेज़ल लागू करते हैं और `borderRadius` सेटिंग को छोड़ देते हैं।
- जब पारदर्शिता आवश्यक हो (छाया, बॉर्डर त्रिज्या, डिवाइस फ़्रेम, या पारदर्शी पृष्ठभूमि), तो आउटपुट को PNG पर बाध्य किया जाता है भले ही `jpeg` चुना गया हो।
- पाइपलाइन/बैच मोड में छवि पृष्ठभूमि समर्थित नहीं है।
@@ -0,0 +1,51 @@
---
description: "AI का उपयोग करके विषय को तीक्ष्ण रखते हुए पृष्ठभूमि को धुंधला करें।"
i18n_source_hash: 9073f10e6e9d
i18n_provenance: human
i18n_output_hash: b181511cebd8
---
# Blur Background {#blur-background}
विषय को तीक्ष्ण रखते हुए किसी छवि की पृष्ठभूमि को धुंधला करें। AI मॉडल विषय को अलग करता है, मूल पृष्ठभूमि पर एक ब्लर लागू करता है, और तीक्ष्ण विषय को ऊपर कंपोज़िट करता है।
## API Endpoint {#api-endpoint}
`POST /api/v1/tools/image/blur-background`
एक छवि फ़ाइल और एक JSON `settings` फ़ील्ड के साथ multipart form data स्वीकार करता है।
## Parameters {#parameters}
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| intensity | integer | No | `50` | ब्लर तीव्रता (1-100) |
| feather | integer | No | `0` | एज फ़ेदरिंग त्रिज्या (0-20) |
| format | string | No | `"png"` | आउटपुट प्रारूप: `png` या `webp` |
## Example Request {#example-request}
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/blur-background \
-H "Authorization: Bearer si_your-api-key" \
-F "file=@photo.jpg" \
-F 'settings={"intensity": 75, "feather": 3}'
```
## Example Response {#example-response}
```json
{
"jobId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"async": true
}
```
`GET /api/v1/jobs/{jobId}/progress` पर SSE के ज़रिए प्रगति ट्रैक करें। जब जॉब पूरा होता है, तो SSE स्ट्रीम डाउनलोड URL के साथ एक `completed` इवेंट उत्सर्जित करता है।
## Notes {#notes}
- यह एक AI-संचालित टूल है जो `202 Accepted` लौटाता है और असिंक्रोनस रूप से प्रोसेस करता है। प्रगति अपडेट और अंतिम परिणाम प्राप्त करने के लिए SSE एंडपॉइंट से कनेक्ट करें।
- इसके लिए **background-removal** फ़ीचर बंडल का इंस्टॉल होना आवश्यक है। यदि बंडल उपलब्ध नहीं है तो `501` लौटाता है।
- उच्च तीव्रता मान एक मज़बूत ब्लर प्रभाव उत्पन्न करते हैं। 80 से ऊपर के मान एक स्पष्ट बोकेह जैसा पृथक्करण बनाते हैं।
- HEIC, RAW, PSD, और SVG इनपुट को प्रोसेसिंग से पहले स्वचालित रूप से डिकोड किया जाता है।
+96
View File
@@ -0,0 +1,96 @@
---
description: "गोपनीयता और GDPR-अनुरूप गुमनामीकरण के लिए AI चेहरा पहचान से छवियों में चेहरों को स्वतः पहचानें और धुंधला करें।"
i18n_source_hash: fb861c12aea5
i18n_provenance: human
i18n_output_hash: 34ba52083c4a
---
# Face / PII Blur {#face-pii-blur}
AI-संचालित चेहरा पहचान (MediaPipe) का उपयोग करके छवियों में चेहरों को स्वतः पहचानें और धुंधला करें।
## API Endpoint {#api-endpoint}
`POST /api/v1/tools/image/blur-faces`
**Processing:** असिंक्रोनस (202 लौटाता है, स्थिति के लिए SSE के ज़रिए `/api/v1/jobs/{jobId}/progress` पोल करें)
**Model bundle:** `face-detection` (200-300 MB)
## Parameters {#parameters}
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| file | file | Yes | - | छवि फ़ाइल (multipart) |
| blurRadius | number | No | `30` | पहचाने गए चेहरों पर लागू ब्लर त्रिज्या (1-100) |
| sensitivity | number | No | `0.5` | चेहरा पहचान संवेदनशीलता (0-1)। कम मान अधिक आत्मविश्वास के साथ कम चेहरे पहचानते हैं |
## Example Request {#example-request}
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/blur-faces \
-F "file=@group-photo.jpg" \
-F 'settings={"blurRadius":40,"sensitivity":0.3}'
```
## Response {#response}
### Initial Response (202 Accepted) {#initial-response-202-accepted}
```json
{
"jobId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"async": true
}
```
### Progress (SSE at `/api/v1/jobs/{jobId}/progress`) {#progress-sse-at-api-v1-jobs-jobid-progress}
```
event: progress
data: {"phase":"processing","stage":"Detecting faces...","percent":40}
```
### Final Result (via SSE) {#final-result-via-sse}
```json
{
"phase": "complete",
"percent": 100,
"result": {
"jobId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"downloadUrl": "/api/v1/download/{jobId}/group-photo_blurred.jpg",
"originalSize": 450000,
"processedSize": 420000,
"facesDetected": 3,
"faces": [
{"x": 100, "y": 50, "w": 80, "h": 80},
{"x": 300, "y": 60, "w": 75, "h": 75},
{"x": 500, "y": 55, "w": 85, "h": 85}
]
}
}
```
### No Faces Detected {#no-faces-detected}
यदि कोई चेहरा नहीं मिलता है, तो परिणाम में एक चेतावनी शामिल होती है:
```json
{
"phase": "complete",
"percent": 100,
"result": {
"facesDetected": 0,
"warning": "No faces detected in this image. Try increasing detection sensitivity."
}
}
```
## Notes {#notes}
- इसके लिए `face-detection` मॉडल बंडल का इंस्टॉल होना आवश्यक है (200-300 MB)।
- आउटपुट प्रारूप स्वचालित रूप से इनपुट प्रारूप से मेल खाता है।
- `faces` सरणी में प्रत्येक पहचाने गए चेहरे के लिए बाउंडिंग बॉक्स निर्देशांक (x, y, width, height) होते हैं।
- आंशिक रूप से ढके चेहरों सहित अधिक चेहरे पहचानने के लिए `sensitivity` बढ़ाएँ (1.0 के करीब)।
- स्वचालित डिकोडिंग के ज़रिए HEIC/HEIF, RAW, TGA, PSD, EXR, और HDR इनपुट प्रारूपों का समर्थन करता है।
+58
View File
@@ -0,0 +1,58 @@
---
description: "छवियों में एक पूर्वानुमेय, नियंत्रित क्रम में बॉर्डर, पैडिंग, गोल कोने, और ड्रॉप शैडो जोड़ें।"
i18n_source_hash: 8845150736a9
i18n_provenance: human
i18n_output_hash: a21d8e52d047
---
# Border & Frame {#border-frame}
छवियों में बॉर्डर, पैडिंग, गोल कोने, और ड्रॉप शैडो जोड़ें। यह टूल प्रभावों को क्रम में लागू करता है: पैडिंग, बॉर्डर, कॉर्नर त्रिज्या, फिर छाया।
## API Endpoint {#api-endpoint}
`POST /api/v1/tools/image/border`
## Parameters {#parameters}
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| borderWidth | number | No | 10 | पिक्सेल में बॉर्डर मोटाई (0 से 2000) |
| borderColor | string | No | `"#000000"` | hex के रूप में बॉर्डर रंग (उदा. `#FF0000`) |
| padding | number | No | 0 | पिक्सेल में छवि और बॉर्डर के बीच आंतरिक पैडिंग (0 से 200) |
| paddingColor | string | No | `"#FFFFFF"` | hex के रूप में पैडिंग फिल रंग |
| cornerRadius | number | No | 0 | पिक्सेल में कॉर्नर त्रिज्या (0 से 2000) |
| shadow | boolean | No | `false` | ड्रॉप शैडो जोड़ना है या नहीं |
| shadowBlur | number | No | 15 | छाया ब्लर त्रिज्या (1 से 200) |
| shadowOffsetX | number | No | 0 | छाया क्षैतिज ऑफसेट (-50 से 50) |
| shadowOffsetY | number | No | 5 | छाया ऊर्ध्वाधर ऑफसेट (-50 से 50) |
| shadowColor | string | No | `"#000000"` | hex के रूप में छाया रंग |
| shadowOpacity | number | No | 40 | छाया अपारदर्शिता प्रतिशत (0 से 100) |
## Example Request {#example-request}
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/border \
-F "file=@photo.jpg" \
-F 'settings={"borderWidth":20,"borderColor":"#333333","cornerRadius":16,"shadow":true,"shadowBlur":25,"shadowOpacity":50}'
```
## Example Response {#example-response}
```json
{
"jobId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"downloadUrl": "/api/v1/download/a1b2c3d4-e5f6-7890-abcd-ef1234567890/photo.png",
"originalSize": 456789,
"processedSize": 523456
}
```
## Notes {#notes}
- मानक `createToolRoute` फ़ैक्ट्री का उपयोग करता है। multipart अपलोड के ज़रिए एक ही छवि फ़ाइल स्वीकार करता है।
- HEIC, RAW, PSD, और SVG इनपुट प्रारूपों का समर्थन करता है (स्वचालित रूप से डिकोड किए गए)।
- प्रोसेसिंग क्रम: पहले पैडिंग जोड़ी जाती है, फिर बॉर्डर चारों ओर लपेटता है, फिर कॉर्नर त्रिज्या लागू की जाती है, फिर छाया कंपोज़िट की जाती है।
- जब `cornerRadius` या `shadow` सक्षम होता है, तो पारदर्शिता संरक्षित करने के लिए आउटपुट को PNG पर बाध्य किया जाता है (इनपुट प्रारूप की परवाह किए बिना)। अल्फा का समर्थन करने वाले प्रारूप (PNG, WebP, AVIF) अपना मूल प्रारूप बनाए रखते हैं।
- छाया आकार-जागरूक होती है: यह आयताकार छाया बनाने के बजाय गोल कोनों का अनुसरण करती है।
- `borderWidth` को 0 पर सेट करना और केवल `cornerRadius` + `shadow` का उपयोग करना एक फ़्रेमरहित गोल छाया प्रभाव बनाता है।
+75
View File
@@ -0,0 +1,75 @@
---
description: "पैटर्न टेम्प्लेट का उपयोग करके कई फ़ाइलों का नाम बदलें और ZIP के रूप में डाउनलोड करें।"
i18n_source_hash: 2776dcc2f71c
i18n_provenance: human
i18n_output_hash: f629ea082a40
---
# Bulk Rename {#bulk-rename}
इंडेक्स, पैडेड इंडेक्स, और मूल फ़ाइल नाम के लिए प्लेसहोल्डर वाले पैटर्न टेम्प्लेट का उपयोग करके कई फ़ाइलों का नाम बदलें। सभी नाम-बदली गई फ़ाइलों वाला एक ZIP संग्रह लौटाता है।
## API Endpoint {#api-endpoint}
`POST /api/v1/tools/image/bulk-rename`
कई फ़ाइलों और एक JSON `settings` फ़ील्ड के साथ multipart form data स्वीकार करता है।
## Parameters {#parameters}
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| pattern | string | No | `"image-{{index}}"` | प्लेसहोल्डर के साथ नामकरण पैटर्न (अधिकतम 1000 वर्ण) |
| startIndex | number | No | `1` | प्रारंभिक इंडेक्स संख्या |
### Pattern Placeholders {#pattern-placeholders}
| Placeholder | Description | Example |
|-------------|-------------|---------|
| `{{index}}` | `startIndex` से शुरू होने वाली क्रमिक संख्या | `1`, `2`, `3` |
| `{{padded}}` | शून्य-पैडेड क्रमिक संख्या | `01`, `02`, `03` |
| `{{original}}` | एक्सटेंशन के बिना मूल फ़ाइल नाम | `photo`, `IMG_001` |
मूल फ़ाइल एक्सटेंशन हमेशा संरक्षित रहता है।
## Example Request {#example-request}
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/bulk-rename \
-H "Authorization: Bearer si_your-api-key" \
-F "file=@photo1.jpg" \
-F "file=@photo2.jpg" \
-F "file=@photo3.jpg" \
-F 'settings={"pattern": "vacation-{{padded}}", "startIndex": 1}'
```
यह उत्पन्न करता है: `vacation-1.jpg`, `vacation-2.jpg`, `vacation-3.jpg`
मूल फ़ाइल नाम का उपयोग करते हुए:
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/bulk-rename \
-H "Authorization: Bearer si_your-api-key" \
-F "file=@IMG_001.jpg" \
-F "file=@IMG_002.jpg" \
-F 'settings={"pattern": "2024-trip-{{original}}-{{index}}"}'
```
यह उत्पन्न करता है: `2024-trip-IMG_001-1.jpg`, `2024-trip-IMG_002-2.jpg`
## Example Response {#example-response}
प्रतिक्रिया एक ZIP फ़ाइल है जो सीधे स्ट्रीम की जाती है (JSON प्रतिक्रिया नहीं)। प्रतिक्रिया हेडर हैं:
```
Content-Type: application/zip
Content-Disposition: attachment; filename="renamed-a1b2c3d4.zip"
```
## Notes {#notes}
- यह टूल छवियों को प्रोसेस नहीं करता। यह केवल फ़ाइलों का नाम बदलता है और उन्हें एक ZIP संग्रह में पैकेज करता है।
- `{{padded}}` के लिए शून्य-पैडिंग चौड़ाई फ़ाइलों की कुल संख्या के आधार पर स्वचालित रूप से निर्धारित होती है (उदा. 100 फ़ाइलें 3-अंकीय पैडिंग का उपयोग करेंगी: `001`, `002`, आदि)।
- फ़ाइल एक्सटेंशन मूल फ़ाइल नामों से संरक्षित रहते हैं।
- असुरक्षित वर्णों को हटाने के लिए फ़ाइल नामों को स्वच्छ किया जाता है।
- कम से कम एक फ़ाइल प्रदान की जानी चाहिए।
+55
View File
@@ -0,0 +1,55 @@
---
description: "किसी छवि को पारदर्शी कोनों के साथ एक केंद्रित वृत्त में क्रॉप करें।"
i18n_source_hash: 06c50ccd96b2
i18n_provenance: human
i18n_output_hash: caf5c56d1c6e
---
# Circle Crop {#circle-crop}
किसी छवि को पारदर्शी कोनों के साथ एक केंद्रित वृत्त में क्रॉप करें। समायोज्य ज़ूम, ऑफसेट, बॉर्डर, और आउटपुट आकार का समर्थन करता है।
## API Endpoint {#api-endpoint}
`POST /api/v1/tools/image/circle-crop`
एक छवि फ़ाइल और एक JSON `settings` फ़ील्ड के साथ multipart form data स्वीकार करता है।
## Parameters {#parameters}
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| zoom | number | No | `1` | ज़ूम कारक (1-5); उच्च मान अधिक कसकर क्रॉप करते हैं |
| offsetX | number | No | `0.5` | क्षैतिज केंद्र स्थिति (0-1) |
| offsetY | number | No | `0.5` | ऊर्ध्वाधर केंद्र स्थिति (0-1) |
| borderWidth | integer | No | `0` | पिक्सेल में बॉर्डर चौड़ाई (0-200) |
| borderColor | string | No | `"#ffffff"` | बॉर्डर हेक्स रंग |
| background | string | No | `"transparent"` | कोना फिल: `"transparent"` या एक हेक्स रंग |
| outputSize | integer | No | - | पिक्सेल में अंतिम वर्गाकार आयाम (16-4096) |
## Example Request {#example-request}
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/circle-crop \
-H "Authorization: Bearer si_your-api-key" \
-F "file=@photo.jpg" \
-F 'settings={"zoom": 1.2, "borderWidth": 4, "borderColor": "#333333"}'
```
## Example Response {#example-response}
```json
{
"jobId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"downloadUrl": "/api/v1/download/a1b2c3d4-e5f6-7890-abcd-ef1234567890/photo.png",
"originalSize": 2450000,
"processedSize": 185000
}
```
## Notes {#notes}
- पारदर्शी कोनों को संरक्षित करने के लिए आउटपुट हमेशा PNG होता है (जब तक `background` को एक ठोस रंग पर सेट न किया गया हो)।
- वृत्त छवि के छोटे आयाम के भीतर अंकित होता है। अधिक कसकर क्रॉप करने के लिए `zoom` का उपयोग करें और दृश्य क्षेत्र को स्थानांतरित करने के लिए `offsetX`/`offsetY` का उपयोग करें।
- जब `outputSize` प्रदान किया जाता है, तो क्रॉप करने के बाद परिणाम को उस वर्गाकार आयाम पर आकार बदला जाता है।
- HEIC, RAW, PSD, और SVG इनपुट को प्रोसेसिंग से पहले स्वचालित रूप से डिकोड किया जाता है।
+92
View File
@@ -0,0 +1,92 @@
---
description: "कई छवियों को 25+ टेम्पलेट, समायोज्य गैप और कोने, और प्रति-सेल पैन तथा ज़ूम के साथ ग्रिड कोलाज में संयोजित करें।"
i18n_source_hash: 96f2055717df
i18n_provenance: human
i18n_output_hash: d72696145235
---
# Collage / Grid {#collage-grid}
कई छवियों को 25+ टेम्पलेट के साथ सुंदर ग्रिड कोलाज में संयोजित करें। अनुकूलन योग्य गैप, कोने की त्रिज्या, पृष्ठभूमि रंग, और प्रति-सेल पैन/ज़ूम नियंत्रण के साथ 2-9 छवि लेआउट का समर्थन करता है।
## API Endpoint {#api-endpoint}
`POST /api/v1/tools/image/collage`
## Parameters {#parameters}
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| templateId | string | Yes | - | टेम्पलेट लेआउट ID (उदा. `2-h-equal`, `3-left-large`, `4-grid`, `9-grid`) |
| cells | array | No | - | प्रति-सेल सेटिंग्स सरणी, जिसमें `imageIndex`, `panX`, `panY`, `zoom`, `objectFit` शामिल हैं |
| cells[].imageIndex | integer | Yes | - | इस सेल में रखी जाने वाली छवि का सूचकांक (0-आधारित) |
| cells[].panX | number | No | 0 | क्षैतिज पैन ऑफ़सेट (-100 से 100) |
| cells[].panY | number | No | 0 | ऊर्ध्वाधर पैन ऑफ़सेट (-100 से 100) |
| cells[].zoom | number | No | 1 | ज़ूम स्तर (1 से 10) |
| cells[].objectFit | string | No | `"cover"` | छवि सेल को कैसे भरती है: `cover` या `contain` |
| gap | number | No | 8 | सेलों के बीच का गैप पिक्सेल में (0 से 500) |
| cornerRadius | number | No | 0 | प्रत्येक सेल के लिए कोने की त्रिज्या पिक्सेल में (0 से 500) |
| backgroundColor | string | No | `"#FFFFFF"` | हेक्स के रूप में पृष्ठभूमि रंग या `"transparent"` |
| aspectRatio | string | No | `"free"` | कैनवास पहलू अनुपात: `free`, `1:1`, `4:3`, `3:2`, `16:9`, `9:16`, `4:5` |
| outputFormat | string | No | `"png"` | आउटपुट फ़ॉर्मेट: `png`, `jpeg`, `webp`, `avif`, `jxl` |
| quality | number | No | 90 | आउटपुट गुणवत्ता (1 से 100) |
## Available Templates {#available-templates}
| Template ID | Images | Layout |
|-------------|--------|--------|
| `2-h-equal` | 2 | दो बराबर कॉलम |
| `2-v-equal` | 2 | दो बराबर पंक्तियाँ |
| `2-h-left-large` | 2 | बायाँ 2/3, दायाँ 1/3 |
| `2-h-right-large` | 2 | बायाँ 1/3, दायाँ 2/3 |
| `3-left-large` | 3 | बड़ा बायाँ, दायीं ओर दो ढेर में |
| `3-right-large` | 3 | बायीं ओर दो ढेर में, बड़ा दायाँ |
| `3-top-large` | 3 | बड़ा ऊपर, नीचे दो कॉलम |
| `3-h-equal` | 3 | तीन बराबर कॉलम |
| `3-v-equal` | 3 | तीन बराबर पंक्तियाँ |
| `4-grid` | 4 | 2x2 ग्रिड |
| `4-left-large` | 4 | बड़ा बायाँ, दायीं ओर तीन ढेर में |
| `4-top-large` | 4 | बड़ा ऊपर, नीचे तीन कॉलम |
| `4-bottom-large` | 4 | ऊपर तीन कॉलम, बड़ा नीचे |
| `5-top2-bottom3` | 5 | दो ऊपर, तीन नीचे |
| `5-top3-bottom2` | 5 | तीन ऊपर, दो नीचे |
| `5-left-large` | 5 | बड़ा बायाँ, दायीं ओर चार ढेर में |
| `5-center-large` | 5 | बड़ा केंद्र, चार कोने |
| `6-grid-2x3` | 6 | 2 कॉलम x 3 पंक्तियाँ |
| `6-grid-3x2` | 6 | 3 कॉलम x 2 पंक्तियाँ |
| `6-top-large` | 6 | बड़ा ऊपर, नीचे पाँच कॉलम |
| `7-mosaic` | 7 | मोज़ेक लेआउट |
| `8-mosaic` | 8 | मोज़ेक लेआउट |
| `9-grid` | 9 | 3x3 ग्रिड |
## Example Request {#example-request}
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/collage \
-F "file=@photo1.jpg" \
-F "file=@photo2.jpg" \
-F "file=@photo3.jpg" \
-F "file=@photo4.jpg" \
-F 'settings={"templateId":"4-grid","gap":12,"cornerRadius":8,"backgroundColor":"#F5F5F5","outputFormat":"png","quality":90}'
```
## Example Response {#example-response}
```json
{
"jobId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"downloadUrl": "/api/v1/download/a1b2c3d4-e5f6-7890-abcd-ef1234567890/collage.png",
"originalSize": 2456789,
"processedSize": 1823456
}
```
## Notes {#notes}
- मल्टीपार्ट अनुरोध में कई छवि फ़ाइलें अपलोड करें। छवियाँ अपलोड क्रम में टेम्पलेट सेलों को असाइन की जाती हैं।
- यदि टेम्पलेट के समर्थन से अधिक छवियाँ अपलोड की जाती हैं, तो अतिरिक्त छवियों को अनदेखा कर दिया जाता है।
- HEIC, RAW, PSD, और SVG इनपुट फ़ॉर्मेट का समर्थन करता है (स्वचालित रूप से डिकोड किए जाते हैं)।
- कैनवास का आधार आकार सबसे लंबी भुजा पर 2400px होता है, जो चुने गए पहलू अनुपात के अनुसार स्केल किया जाता है।
- जब `aspectRatio` `"free"` होता है, तो कैनवास डिफ़ॉल्ट रूप से 4:3 (2400x1800) होता है।
- प्रति-सेल `panX`/`panY` मान सेल के भीतर क्रॉप विंडो को स्थानांतरित करते हैं। 100 का मान पूरी तरह एक किनारे की ओर ले जाता है, -100 दूसरे की ओर।
- `"transparent"` पृष्ठभूमि रंग केवल `png`, `webp`, या `avif` आउटपुट फ़ॉर्मेट के साथ संरक्षित रहता है।
@@ -0,0 +1,62 @@
---
description: "अनुकरण करें कि विभिन्न प्रकार की रंग दृष्टि कमी वाले लोगों को छवियाँ कैसी दिखती हैं।"
i18n_source_hash: 0b537628ba79
i18n_provenance: human
i18n_output_hash: d96a668fe7b6
---
# Color Blindness Simulation {#color-blindness-simulation}
रंग दृष्टि कमी (CVD) का अनुकरण करें ताकि यह पूर्वावलोकन किया जा सके कि विभिन्न प्रकार के रंग अंधत्व वाले लोगों को छवियाँ कैसी दिखती हैं। डिज़ाइन, चार्ट, और UI के अभिगम्यता परीक्षण के लिए उपयोगी।
## API Endpoint {#api-endpoint}
`POST /api/v1/tools/image/color-blindness`
एक छवि फ़ाइल और एक JSON `settings` फ़ील्ड के साथ मल्टीपार्ट फ़ॉर्म डेटा स्वीकार करता है।
## Parameters {#parameters}
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| simulationType | string | No | `"deuteranomaly"` | अनुकरण करने के लिए रंग दृष्टि कमी का प्रकार |
### Simulation Types {#simulation-types}
| Value | Condition | Description |
|-------|-----------|-------------|
| `protanopia` | लाल-अंध | लाल शंकु कोशिकाओं की पूर्ण अनुपस्थिति |
| `deuteranopia` | हरा-अंध | हरी शंकु कोशिकाओं की पूर्ण अनुपस्थिति |
| `tritanopia` | नीला-अंध | नीली शंकु कोशिकाओं की पूर्ण अनुपस्थिति |
| `protanomaly` | लाल-कमज़ोर | घटी हुई लाल शंकु संवेदनशीलता |
| `deuteranomaly` | हरा-कमज़ोर | घटी हुई हरी शंकु संवेदनशीलता (सबसे सामान्य) |
| `tritanomaly` | नीला-कमज़ोर | घटी हुई नीली शंकु संवेदनशीलता |
| `achromatopsia` | पूर्ण रंग अंध | रंग दृष्टि की पूर्ण अनुपस्थिति |
| `blueConeMonochromacy` | केवल नीला-शंकु | केवल नीले शंकु कार्यशील |
## Example Request {#example-request}
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/color-blindness \
-H "Authorization: Bearer si_your-api-key" \
-F "file=@design.png" \
-F 'settings={"simulationType": "deuteranopia"}'
```
## Example Response {#example-response}
```json
{
"jobId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"downloadUrl": "/api/v1/download/a1b2c3d4-e5f6-7890-abcd-ef1234567890/design.png",
"originalSize": 1850000,
"processedSize": 1820000
}
```
## Notes {#notes}
- Deuteranomaly (हरा-कमज़ोर) डिफ़ॉल्ट है क्योंकि यह रंग दृष्टि कमी का सबसे सामान्य रूप है, जो लगभग 6% पुरुषों को प्रभावित करता है।
- यह अनुकरण रंग परिवर्तन मैट्रिक्स का उपयोग करता है जो यह मॉडल करते हैं कि घटे हुए या अनुपस्थित शंकु प्रकाशग्राही अनुभव किए गए रंगों को कैसे बदलते हैं।
- यह टूल गैर-विनाशकारी है और केवल एक पूर्वावलोकन उत्पन्न करता है। यह अभिगम्यता के लिए मूल छवि को संशोधित नहीं करता।
- आउटपुट फ़ॉर्मेट इनपुट फ़ॉर्मेट से मेल खाता है। HEIC, RAW, PSD, और SVG इनपुट प्रोसेसिंग से पहले स्वचालित रूप से डिकोड किए जाते हैं।
+75
View File
@@ -0,0 +1,75 @@
---
description: "किसी छवि से प्रमुख रंगों को एक रंग पैलेट के रूप में निकालें।"
i18n_source_hash: 65ab22dd75a9
i18n_provenance: human
i18n_output_hash: f9899b0bd09d
---
# Color Palette {#color-palette}
किसी छवि से प्रमुख रंगों को निकालें और उन्हें हेक्स रंग मानों के रूप में लौटाएँ। सबसे प्रमुख और दृश्य रूप से विशिष्ट रंगों की पहचान के लिए क्वांटाइज़्ड आवृत्ति विश्लेषण का उपयोग करता है।
## API Endpoint {#api-endpoint}
`POST /api/v1/tools/image/color-palette`
एक छवि फ़ाइल और एक वैकल्पिक JSON `settings` फ़ील्ड के साथ मल्टीपार्ट फ़ॉर्म डेटा स्वीकार करता है।
## Parameters {#parameters}
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| count | integer | No | `8` | निकालने के लिए रंगों की संख्या (2-16) |
| format | string | No | `"hex"` | रंग फ़ॉर्मेट: `hex`, `rgb`, `hsl` |
## Example Request {#example-request}
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/color-palette \
-H "Authorization: Bearer si_your-api-key" \
-F "file=@photo.jpg" \
-F 'settings={"count": 6, "format": "hex"}'
```
## Example Response {#example-response}
```json
{
"filename": "photo.jpg",
"colors": [
"#304080",
"#e0a060",
"#f0f0f0",
"#203020",
"#a0c0e0",
"#806040"
],
"hex": [
"#304080",
"#e0a060",
"#f0f0f0",
"#203020",
"#a0c0e0",
"#806040"
],
"count": 6
}
```
## Response Fields {#response-fields}
| Field | Type | Description |
|-------|------|-------------|
| filename | string | स्वच्छ किया गया फ़ाइलनाम |
| colors | array | अनुरोधित फ़ॉर्मेट में रंग स्ट्रिंग्स की सरणी, प्रभुत्व के क्रम में (सबसे अधिक बारंबार पहले) |
| hex | array | हेक्स रंग स्ट्रिंग्स की सरणी (हमेशा हेक्स, `format` सेटिंग की परवाह किए बिना) |
| count | number | निकाले गए रंगों की संख्या |
## Notes {#notes}
- अधिकतम `count` प्रमुख रंग लौटाता है (डिफ़ॉल्ट 8, सीमा 2-16), आवृत्ति के अनुसार क्रमबद्ध (सबसे सामान्य पहले)।
- छवि का आंतरिक रूप से विश्लेषण के लिए 100x100 पिक्सेल में आकार बदला जाता है, इसलिए पैलेट छोटे विवरणों के बजाय समग्र रंग वितरण का प्रतिनिधित्व करता है।
- रंग मीडियन-कट क्वांटाइज़ेशन का उपयोग करके निकाले जाते हैं, जो सबसे व्यापक सीमा वाले चैनल के साथ पिक्सेल समूहों को पुनरावर्ती रूप से विभाजित करता है।
- विश्लेषण से पहले अल्फा चैनल हटा दिया जाता है, इसलिए पारदर्शी क्षेत्रों पर विचार नहीं किया जाता।
- यह एक केवल-पढ़ने योग्य एंडपॉइंट है। यह डाउनलोड करने योग्य आउटपुट फ़ाइल या `jobId` उत्पन्न नहीं करता।
- HEIC, RAW, PSD, और SVG इनपुट विश्लेषण से पहले स्वचालित रूप से डिकोड किए जाते हैं।
+80
View File
@@ -0,0 +1,80 @@
---
description: "DDColor AI मॉडल के साथ श्वेत-श्याम या ग्रेस्केल तस्वीरों को स्वचालित रूप से रंगीन करें।"
i18n_source_hash: 688aa3abbdae
i18n_provenance: human
i18n_output_hash: d52b65484357
---
# AI Colorization {#ai-colorization}
AI (OpenCV DNN फ़ॉलबैक के साथ DDColor मॉडल) का उपयोग करके श्वेत-श्याम या ग्रेस्केल तस्वीरों को पूर्ण रंग में परिवर्तित करें।
## API Endpoint {#api-endpoint}
`POST /api/v1/tools/image/colorize`
**Processing:** अतुल्यकालिक (202 लौटाता है, SSE के माध्यम से स्थिति के लिए `/api/v1/jobs/{jobId}/progress` पर पोल करें)
**Model bundle:** `object-eraser-colorize` (1-2 GB)
## Parameters {#parameters}
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| file | file | Yes | - | छवि फ़ाइल (मल्टीपार्ट) |
| intensity | number | No | `1.0` | रंग तीव्रता (0-1)। कम मान अधिक सूक्ष्म रंगीनीकरण उत्पन्न करते हैं |
| model | string | No | `"auto"` | उपयोग करने के लिए मॉडल: `auto`, `ddcolor`, `opencv` |
## Example Request {#example-request}
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/colorize \
-F "file=@old-bw-photo.jpg" \
-F 'settings={"intensity":0.9,"model":"auto"}'
```
## Response {#response}
### Initial Response (202 Accepted) {#initial-response-202-accepted}
```json
{
"jobId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"async": true
}
```
### Progress (SSE at `/api/v1/jobs/{jobId}/progress`) {#progress-sse-at-api-v1-jobs-jobid-progress}
```
event: progress
data: {"phase":"processing","stage":"Colorizing...","percent":55}
```
### Final Result (via SSE) {#final-result-via-sse}
```json
{
"phase": "complete",
"percent": 100,
"result": {
"jobId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"downloadUrl": "/api/v1/download/{jobId}/old-bw-photo_colorized.jpg",
"previewUrl": "/api/v1/download/{jobId}/preview.webp",
"originalSize": 180000,
"processedSize": 210000,
"width": 1920,
"height": 1080,
"method": "ddcolor"
}
}
```
## Notes {#notes}
- `object-eraser-colorize` मॉडल बंडल का स्थापित होना आवश्यक है (1-2 GB)।
- DDColor उच्च गुणवत्ता वाले परिणाम उत्पन्न करता है लेकिन धीमा है; OpenCV DNN थोड़ी कम गुणवत्ता के साथ तेज़ है। `auto` उपलब्ध होने पर DDColor का उपयोग करता है और OpenCV फ़ॉलबैक के साथ।
- `intensity` पैरामीटर मूल ग्रेस्केल और AI-रंगीन परिणाम के बीच मिश्रण करता है। पूर्ण रंग के लिए 1.0 का उपयोग करें, आंशिक रूप से असंतृप्त विंटेज लुक के लिए कम मान।
- आउटपुट फ़ॉर्मेट स्वचालित रूप से इनपुट फ़ॉर्मेट से मेल खाता है।
- गैर-ब्राउज़र-पूर्वावलोकन योग्य आउटपुट फ़ॉर्मेट के लिए, मुख्य आउटपुट के साथ एक WebP पूर्वावलोकन उत्पन्न किया जाता है।
- स्वचालित डिकोडिंग के माध्यम से HEIC/HEIF, RAW, TGA, PSD, EXR, और HDR इनपुट फ़ॉर्मेट का समर्थन करता है।
+68
View File
@@ -0,0 +1,68 @@
---
description: "पिक्सेल-स्तरीय अंतर दृश्यीकरण और समानता स्कोर के साथ दो छवियों की साथ-साथ तुलना करें।"
i18n_source_hash: cc0a02bd75c6
i18n_provenance: human
i18n_output_hash: b5a6d14888e5
---
# Image Compare {#image-compare}
पिक्सेल-स्तरीय अंतर मानचित्र और एक संख्यात्मक समानता प्रतिशत की गणना के लिए दो छवियाँ अपलोड करें। आउटपुट एक अंतर छवि है जो बदले गए क्षेत्रों को लाल रंग में उजागर करती है।
## API Endpoint {#api-endpoint}
`POST /api/v1/tools/image/compare`
**दो** छवि फ़ाइलों के साथ मल्टीपार्ट फ़ॉर्म डेटा स्वीकार करता है। किसी सेटिंग्स फ़ील्ड की आवश्यकता नहीं है।
## Parameters {#parameters}
इस टूल में कोई विन्यास योग्य पैरामीटर नहीं है। ठीक दो छवि फ़ाइलें अपलोड करें।
| Field | Type | Required | Description |
|-------|------|----------|-------------|
| file (first) | file | Yes | पहली छवि |
| file (second) | file | Yes | दूसरी छवि |
## Example Request {#example-request}
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/compare \
-H "Authorization: Bearer si_your-api-key" \
-F "file=@original.jpg" \
-F "file=@modified.jpg"
```
## Example Response {#example-response}
```json
{
"jobId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"similarity": 94.52,
"dimensions": { "width": 1920, "height": 1080 },
"downloadUrl": "/api/v1/download/a1b2c3d4-e5f6-7890-abcd-ef1234567890/diff.png",
"originalSize": 4900000,
"processedSize": 280000
}
```
## Response Fields {#response-fields}
| Field | Type | Description |
|-------|------|-------------|
| jobId | string | अंतर छवि डाउनलोड करने के लिए जॉब पहचानकर्ता |
| similarity | number | दोनों छवियों के बीच प्रतिशत समानता (0 से 100) |
| dimensions | object | तुलना के लिए उपयोग की गई चौड़ाई और ऊँचाई |
| downloadUrl | string | उत्पन्न अंतर छवि डाउनलोड करने के लिए URL |
| originalSize | number | दोनों इनपुट छवियों का संयुक्त आकार बाइट्स में |
| processedSize | number | अंतर आउटपुट छवि का आकार बाइट्स में |
## Notes {#notes}
- तुलना से पहले दोनों छवियों का समान आयाम (प्रत्येक अक्ष का अधिकतम) में आकार बदला जाता है।
- अंतर छवि लाल रंग में अंतरों को उजागर करती है, जिसकी अपारदर्शिता परिवर्तन की मात्रा के समानुपाती होती है। समान या लगभग-समान पिक्सेल (अंतर < 10) मूल के अर्ध-पारदर्शी संस्करण के रूप में दिखाए जाते हैं।
- समानता की गणना सभी पिक्सेल में औसत पिक्सेल अंतर के व्युत्क्रम के रूप में की जाती है, जिसे प्रतिशत के रूप में व्यक्त किया जाता है।
- 100% की समानता का अर्थ है कि छवियाँ पिक्सेल-समान हैं (तुलना विभेदन पर)।
- अंतर आउटपुट इनपुट फ़ॉर्मेट की परवाह किए बिना हमेशा PNG फ़ॉर्मेट होता है।
- तुलना से पहले दोनों छवियाँ मान्य और डिकोड की जाती हैं (HEIC, RAW, PSD, SVG समर्थित)।
- प्रोसेसिंग से पहले दोनों छवियों पर EXIF अभिविन्यास स्वचालित रूप से लागू किया जाता है।
+87
View File
@@ -0,0 +1,87 @@
---
description: "कंपोज़िटिंग के लिए स्थिति, अपारदर्शिता, और ब्लेंड मोड के साथ छवियों को परत में रखें।"
i18n_source_hash: c5d09eb13fde
i18n_provenance: human
i18n_output_hash: 7d1ab3e67559
---
# Image Composition {#image-composition}
एक ओवरले छवि को आधार छवि के ऊपर विन्यास योग्य स्थिति, अपारदर्शिता, और ब्लेंड मोड के साथ परत में रखें। लोगो, ग्राफ़िक्स, या कई छवियों को संयोजित करने के लिए उपयोगी।
## API Endpoint {#api-endpoint}
`POST /api/v1/tools/image/compose`
**दो** छवि फ़ाइलों और एक JSON `settings` फ़ील्ड के साथ मल्टीपार्ट फ़ॉर्म डेटा स्वीकार करता है।
## Parameters {#parameters}
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| x | number | No | `0` | ऊपर-बायें कोने से ओवरले का क्षैतिज ऑफ़सेट पिक्सेल में (न्यूनतम 0) |
| y | number | No | `0` | ऊपर-बायें कोने से ओवरले का ऊर्ध्वाधर ऑफ़सेट पिक्सेल में (न्यूनतम 0) |
| opacity | number | No | `100` | ओवरले अपारदर्शिता प्रतिशत (0 से 100) |
| blendMode | string | No | `"over"` | कंपोज़िटिंग ब्लेंड मोड |
### Blend Modes {#blend-modes}
| Value | Description |
|-------|-------------|
| `over` | सामान्य ओवरले (डिफ़ॉल्ट) |
| `multiply` | पिक्सेल मानों को गुणा करके गहरा करना |
| `screen` | उलटकर, गुणा करके, और फिर उलटकर हल्का करना |
| `overlay` | आधार चमक के आधार पर multiply और screen को संयोजित करता है |
| `darken` | प्रत्येक परत से गहरे पिक्सेल को रखें |
| `lighten` | प्रत्येक परत से हल्के पिक्सेल को रखें |
| `hard-light` | तीव्र कंट्रास्ट ओवरले |
| `soft-light` | सूक्ष्म कंट्रास्ट ओवरले |
| `difference` | परतों के बीच पूर्ण अंतर |
| `exclusion` | difference के समान लेकिन कम कंट्रास्ट |
### File Fields {#file-fields}
| Field Name | Required | Description |
|------------|----------|-------------|
| file | Yes | आधार/पृष्ठभूमि छवि |
| overlay | Yes | ओवरले/अग्रभूमि छवि |
## Example Request {#example-request}
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/compose \
-H "Authorization: Bearer si_your-api-key" \
-F "file=@background.jpg" \
-F "overlay=@graphic.png" \
-F 'settings={"x": 100, "y": 50, "opacity": 80, "blendMode": "over"}'
```
multiply ब्लेंड मोड का उपयोग करते हुए:
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/compose \
-H "Authorization: Bearer si_your-api-key" \
-F "file=@photo.jpg" \
-F "overlay=@texture.jpg" \
-F 'settings={"x": 0, "y": 0, "opacity": 50, "blendMode": "multiply"}'
```
## Example Response {#example-response}
```json
{
"jobId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"downloadUrl": "/api/v1/download/a1b2c3d4-e5f6-7890-abcd-ef1234567890/background.jpg",
"originalSize": 3200000,
"processedSize": 3450000
}
```
## Notes {#notes}
- कंपोज़िटिंग से पहले दोनों छवियाँ मान्य और डिकोड की जाती हैं (HEIC, RAW, PSD, SVG समर्थित)।
- ओवरले `x` और `y` द्वारा निर्दिष्ट सटीक पिक्सेल निर्देशांक पर रखा जाता है। इसे फ़िट करने के लिए आकार नहीं बदला जाता।
- यदि अपारदर्शिता 100 से कम है, तो ब्लेंडिंग से पहले ओवरले पर एक अल्फा मास्क लागू किया जाता है।
- ओवरले आधार छवि की सीमाओं से आगे बढ़ सकता है (इसे क्लिप कर दिया जाएगा)।
- प्रोसेसिंग से पहले दोनों छवियों पर EXIF अभिविन्यास स्वचालित रूप से लागू किया जाता है।
- आउटपुट आयाम आधार छवि के आयाम से मेल खाते हैं।
+62
View File
@@ -0,0 +1,62 @@
---
description: "गुणवत्ता स्तर के अनुसार या किसी लक्षित फ़ाइल आकार तक छवि फ़ाइल आकार कम करें।"
i18n_source_hash: af4685da7e64
i18n_provenance: human
i18n_output_hash: 1f185a4e5191
---
# Compress {#compress}
गुणवत्ता स्तर या किलोबाइट में लक्षित फ़ाइल आकार निर्दिष्ट करके छवि फ़ाइल आकार कम करें। यह टूल आकार लक्ष्यों को सटीक रूप से प्राप्त करने के लिए पुनरावर्ती द्विआधारी खोज का उपयोग करता है।
## API Endpoint {#api-endpoint}
`POST /api/v1/tools/image/compress`
एक छवि फ़ाइल और एक JSON `settings` फ़ील्ड के साथ मल्टीपार्ट फ़ॉर्म डेटा स्वीकार करता है।
## Parameters {#parameters}
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| mode | string | No | `"quality"` | संपीड़न मोड: `quality` या `targetSize` |
| quality | number | No | `80` | गुणवत्ता स्तर (1-100)। तब उपयोग किया जाता है जब मोड `quality` हो। |
| targetSizeKb | number | No | - | किलोबाइट में लक्षित फ़ाइल आकार। तब उपयोग किया जाता है जब मोड `targetSize` हो। |
## Example Request {#example-request}
गुणवत्ता 60 पर संपीड़ित करें:
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/compress \
-H "Authorization: Bearer si_your-api-key" \
-F "file=@photo.jpg" \
-F 'settings={"mode": "quality", "quality": 60}'
```
200 KB के लक्षित आकार पर संपीड़ित करें:
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/compress \
-H "Authorization: Bearer si_your-api-key" \
-F "file=@photo.jpg" \
-F 'settings={"mode": "targetSize", "targetSizeKb": 200}'
```
## Example Response {#example-response}
```json
{
"jobId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"downloadUrl": "/api/v1/download/a1b2c3d4-e5f6-7890-abcd-ef1234567890/photo.jpg",
"originalSize": 2450000,
"processedSize": 204800
}
```
## Notes {#notes}
- `quality` मोड में, कम मान अधिक संपीड़न कलाकृतियों के साथ छोटी फ़ाइलें उत्पन्न करते हैं। वेब उपयोग के लिए 80 का मान एक अच्छा डिफ़ॉल्ट है।
- `targetSize` मोड में, इंजन लक्ष्य से अधिक हुए बिना उसके यथासंभव निकट पहुँचने के लिए पुनरावर्ती संपीड़न करता है।
- आउटपुट फ़ॉर्मेट इनपुट फ़ॉर्मेट से मेल खाता है। संपीड़न फ़ॉर्मेट की मूल एन्कोडिंग पर लागू होता है (उदा. JPEG फ़ाइलों के लिए JPEG गुणवत्ता, WebP फ़ाइलों के लिए WebP गुणवत्ता)।
- यदि डिफ़ॉल्ट गुणवत्ता (80) स्वीकार्य है, तो आप `quality` पैरामीटर को पूरी तरह छोड़ सकते हैं।
@@ -0,0 +1,64 @@
---
description: "सीम-कार्विंग आकार बदलना जो प्रमुख सामग्री और चेहरों को संरक्षित करने के लिए कम-महत्व वाले पथों के साथ पिक्सेल जोड़ता या हटाता है।"
i18n_source_hash: f383b28ab62a
i18n_provenance: human
i18n_output_hash: e17ef26ea7e2
---
# Content-Aware Resize {#content-aware-resize}
सीम कार्विंग आकार बदलना जो न्यूनतम दृश्य महत्व वाले पथों के साथ बुद्धिमानी से पिक्सेल हटाता या जोड़ता है, महत्वपूर्ण सामग्री को संरक्षित करता है और वैकल्पिक रूप से चेहरों की रक्षा करता है।
## API Endpoint {#api-endpoint}
`POST /api/v1/tools/image/content-aware-resize`
**Processing:** तुल्यकालिक (परिणाम सीधे लौटाता है)
**Model bundle:** बुनियादी संचालन के लिए कोई आवश्यक नहीं। सक्षम होने पर चेहरा सुरक्षा `face-detection` बंडल (200-300 MB) का उपयोग करती है।
## Parameters {#parameters}
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| file | file | Yes | - | छवि फ़ाइल (मल्टीपार्ट) |
| width | number | No | - | पिक्सेल में लक्षित चौड़ाई |
| height | number | No | - | पिक्सेल में लक्षित ऊँचाई |
| protectFaces | boolean | No | `false` | सीम हटाने से चेहरों का पता लगाएँ और उन्हें सुरक्षित रखें |
| blurRadius | number | No | `4` | ऊर्जा गणना के लिए पूर्व-प्रसंस्करण ब्लर त्रिज्या (0-20) |
| sobelThreshold | number | No | `2` | Sobel किनारा पहचान सीमा (1-20)। उच्च मान एल्गोरिथ्म को अधिक आक्रामक बनाते हैं |
| square | boolean | No | `false` | वर्ग में आकार बदलें (छोटे आयाम का उपयोग करता है) |
`width`, `height`, या `square` में से कम से कम एक निर्दिष्ट किया जाना चाहिए।
## Example Request {#example-request}
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/content-aware-resize \
-F "file=@landscape.jpg" \
-F 'settings={"width":800,"protectFaces":true}'
```
## Response (200 OK) {#response-200-ok}
```json
{
"jobId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"downloadUrl": "/api/v1/download/{jobId}/landscape_seam.png",
"originalSize": 450000,
"processedSize": 380000,
"width": 800,
"height": 600
}
```
## Notes {#notes}
- यह कस्टम रूट वर्तमान में एक तुल्यकालिक 200 प्रतिक्रिया लौटाता है।
- सामग्री-जागरूक आकार बदलने के लिए `caire` सीम कार्विंग लाइब्रेरी का उपयोग करता है।
- केवल आयाम घटाता है (सीम हटाता है)। किसी छवि को उसके मूल आकार से आगे विस्तारित नहीं कर सकता।
- `protectFaces` विकल्प चेहरा क्षेत्रों को उच्च-ऊर्जा के रूप में चिह्नित करने के लिए AI चेहरा पहचान का उपयोग करता है, जिससे सीम को चेहरों से गुज़रने से रोका जाता है।
- `blurRadius` ऊर्जा मानचित्र गणना से पहले चौरसाई को नियंत्रित करता है। उच्च मान ऊर्जा मानचित्र को अधिक एकसमान बनाते हैं, जो शोरयुक्त छवियों के साथ मदद कर सकता है।
- `sobelThreshold` प्रभावित करता है कि किनारों का पता कितनी आक्रामकता से लगाया जाता है। कम मान अधिक सूक्ष्म किनारों को संरक्षित करते हैं।
- आउटपुट हमेशा PNG फ़ॉर्मेट होता है।
- स्वचालित डिकोडिंग के माध्यम से HEIC/HEIF, RAW, TGA, PSD, EXR, और HDR इनपुट फ़ॉर्मेट का समर्थन करता है।
+84
View File
@@ -0,0 +1,84 @@
---
description: "AVIF, JXL, और HEIC जैसे आधुनिक फ़ॉर्मेट सहित छवियों को फ़ॉर्मेट के बीच परिवर्तित करें।"
i18n_source_hash: 562f8270e8c3
i18n_provenance: human
i18n_output_hash: d2a3deb5118b
---
# Convert {#convert}
छवियों को फ़ॉर्मेट के बीच परिवर्तित करें। सामान्य वेब फ़ॉर्मेट के साथ-साथ HEIC, JXL, BMP, ICO, JP2, QOI, और PSD जैसे विशेष फ़ॉर्मेट का समर्थन करता है।
## API Endpoint {#api-endpoint}
`POST /api/v1/tools/image/convert`
एक छवि फ़ाइल और एक JSON `settings` फ़ील्ड के साथ मल्टीपार्ट फ़ॉर्म डेटा स्वीकार करता है।
## Parameters {#parameters}
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| format | string | Yes | - | लक्षित फ़ॉर्मेट: `jpg`, `png`, `webp`, `avif`, `tiff`, `gif`, `heic`, `heif`, `jxl`, `bmp`, `ico`, `jp2`, `qoi`, `psd`, `ppm`, `eps`, `tga` |
| quality | number | No | - | आउटपुट गुणवत्ता (1-100)। jpg, webp, avif, heic जैसे हानिकर फ़ॉर्मेट पर लागू होती है। |
## Supported Output Formats {#supported-output-formats}
| Format | Type | Notes |
|--------|------|-------|
| jpg | Lossy | JPEG, सर्वोत्तम संगतता |
| png | Lossless | पारदर्शिता का समर्थन करता है |
| webp | Both | आधुनिक वेब फ़ॉर्मेट, अच्छा संपीड़न |
| avif | Lossy | अगली पीढ़ी का फ़ॉर्मेट, उत्कृष्ट संपीड़न |
| tiff | Both | प्रिंट/प्रकाशन वर्कफ़्लो |
| gif | Lossless | 256 रंगों तक सीमित |
| heic / heif | Lossy | Apple पारिस्थितिकी तंत्र फ़ॉर्मेट |
| jxl | Both | JPEG XL, अगली पीढ़ी का फ़ॉर्मेट |
| bmp | Lossless | असंपीड़ित बिटमैप |
| ico | Lossless | Windows आइकन फ़ॉर्मेट |
| jp2 | Lossy | JPEG 2000 |
| qoi | Lossless | Quite OK Image फ़ॉर्मेट |
| psd | Layered | Adobe Photoshop (ImageMagick आवश्यक) |
| ppm | Lossless | Portable Pixmap (PPM/PGM/PBM) |
| eps | Vector | Encapsulated PostScript |
| tga | Lossless | Targa छवि फ़ॉर्मेट |
## Example Request {#example-request}
WebP में परिवर्तित करें:
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/convert \
-H "Authorization: Bearer si_your-api-key" \
-F "file=@photo.jpg" \
-F 'settings={"format": "webp", "quality": 85}'
```
PNG में परिवर्तित करें (हानिरहित):
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/convert \
-H "Authorization: Bearer si_your-api-key" \
-F "file=@photo.jpg" \
-F 'settings={"format": "png"}'
```
## Example Response {#example-response}
```json
{
"jobId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"downloadUrl": "/api/v1/download/a1b2c3d4-e5f6-7890-abcd-ef1234567890/photo.webp",
"originalSize": 2450000,
"processedSize": 680000
}
```
## Notes {#notes}
- आउटपुट फ़ाइलनाम एक्सटेंशन स्वचालित रूप से लक्षित फ़ॉर्मेट से मेल खाने के लिए अद्यतन किया जाता है।
- SVG इनपुट परिवर्तन से पहले 300 DPI पर रैस्टराइज़ किए जाते हैं।
- PSD परिवर्तन के लिए सर्वर पर ImageMagick स्थापित होना आवश्यक है।
- BMP, EPS, ICO, JP2, JXL, PPM, QOI, और TGA विशेष CLI एन्कोडर का उपयोग करते हैं और Sharp प्रोसेसिंग को बायपास करते हैं।
- HEIC/HEIF एन्कोडिंग सिस्टम HEIC एन्कोडर लाइब्रेरी का उपयोग करती है।
- इनपुट फ़ॉर्मेट व्यापक हैं: JPEG, PNG, WebP, AVIF, TIFF, GIF, HEIC, RAW (CR2, NEF, ARW, आदि), PSD, SVG, BMP, और अधिक।
+62
View File
@@ -0,0 +1,62 @@
---
description: "स्थिति और आयाम के साथ एक क्षेत्र निर्दिष्ट करके छवियों को क्रॉप करें।"
i18n_source_hash: aab38ccd7c53
i18n_provenance: human
i18n_output_hash: dfd5dda786f1
---
# Crop {#crop}
स्थिति और आकार का उपयोग करके एक आयताकार क्षेत्र परिभाषित करके छवियों को क्रॉप करें। पिक्सेल और प्रतिशत दोनों इकाइयों का समर्थन करता है।
## API Endpoint {#api-endpoint}
`POST /api/v1/tools/image/crop`
एक छवि फ़ाइल और एक JSON `settings` फ़ील्ड के साथ मल्टीपार्ट फ़ॉर्म डेटा स्वीकार करता है।
## Parameters {#parameters}
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| left | number | Yes | - | क्रॉप क्षेत्र का X ऑफ़सेट (बायें किनारे से) |
| top | number | Yes | - | क्रॉप क्षेत्र का Y ऑफ़सेट (ऊपरी किनारे से) |
| width | number | Yes | - | क्रॉप क्षेत्र की चौड़ाई |
| height | number | Yes | - | क्रॉप क्षेत्र की ऊँचाई |
| unit | string | No | `"px"` | मानों के लिए इकाई: `px` या `percent` |
## Example Request {#example-request}
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/crop \
-H "Authorization: Bearer si_your-api-key" \
-F "file=@photo.jpg" \
-F 'settings={"left": 100, "top": 50, "width": 800, "height": 600}'
```
प्रतिशत मानों का उपयोग करके क्रॉप करें:
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/crop \
-H "Authorization: Bearer si_your-api-key" \
-F "file=@photo.jpg" \
-F 'settings={"left": 10, "top": 10, "width": 80, "height": 80, "unit": "percent"}'
```
## Example Response {#example-response}
```json
{
"jobId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"downloadUrl": "/api/v1/download/a1b2c3d4-e5f6-7890-abcd-ef1234567890/photo.jpg",
"originalSize": 2450000,
"processedSize": 1200000
}
```
## Notes {#notes}
- क्रॉप क्षेत्र छवि की सीमाओं के भीतर फ़िट होना चाहिए। यदि क्षेत्र छवि से आगे बढ़ता है, तो अनुरोध विफल हो जाएगा।
- `percent` इकाई का उपयोग करते समय, मान छवि आयामों के प्रतिशत का प्रतिनिधित्व करते हैं (उदा. `left: 10` का अर्थ है बायें किनारे से 10%)।
- आउटपुट फ़ॉर्मेट इनपुट फ़ॉर्मेट से मेल खाता है।
- क्रॉपिंग से पहले EXIF अभिविन्यास स्वचालित रूप से लागू किया जाता है, इसलिए निर्देशांक दृश्य रूप से सही अभिविन्यास के अनुरूप होते हैं।
+50
View File
@@ -0,0 +1,50 @@
---
description: "कस्टम शैडो और हाइलाइट रंगों के साथ दो-रंग वाला ड्युओटोन प्रभाव लागू करें।"
i18n_source_hash: ab99c4f0152c
i18n_provenance: human
i18n_output_hash: c8ec17d98c42
---
# Duotone {#duotone}
किसी छवि पर दो-रंग वाला ड्युओटोन प्रभाव लागू करें। छवि को ग्रेस्केल में परिवर्तित किया जाता है, फिर शैडो रंग (गहरे टोन) और हाइलाइट रंग (चमकीले टोन) के बीच एक ग्रेडिएंट में मैप किया जाता है।
## API Endpoint {#api-endpoint}
`POST /api/v1/tools/image/duotone`
एक छवि फ़ाइल और एक JSON `settings` फ़ील्ड के साथ मल्टीपार्ट फ़ॉर्म डेटा स्वीकार करता है।
## Parameters {#parameters}
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| shadow | string | No | `"#1e3a8a"` | शैडो हेक्स रंग (गहरे टोन पर लागू) |
| highlight | string | No | `"#fbbf24"` | हाइलाइट हेक्स रंग (चमकीले टोन पर लागू) |
| intensity | integer | No | `100` | प्रभाव तीव्रता (0-100); 0 मूल लौटाता है, 100 पूर्ण ड्युओटोन लागू करता है |
## Example Request {#example-request}
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/duotone \
-H "Authorization: Bearer si_your-api-key" \
-F "file=@photo.jpg" \
-F 'settings={"shadow": "#0f172a", "highlight": "#f97316", "intensity": 80}'
```
## Example Response {#example-response}
```json
{
"jobId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"downloadUrl": "/api/v1/download/a1b2c3d4-e5f6-7890-abcd-ef1234567890/photo.jpg",
"originalSize": 2450000,
"processedSize": 1870000
}
```
## Notes {#notes}
- आउटपुट फ़ॉर्मेट इनपुट फ़ॉर्मेट से मेल खाता है। HEIC, RAW, PSD, और SVG इनपुट प्रोसेसिंग से पहले स्वचालित रूप से डिकोड किए जाते हैं।
- 100 से कम की `intensity` ड्युओटोन परिणाम को मूल छवि के साथ मिश्रित करती है, जिससे सूक्ष्म प्रभाव संभव होते हैं।
- लोकप्रिय ड्युओटोन संयोजनों में navy/gold, teal/coral, और purple/pink शामिल हैं।
+108
View File
@@ -0,0 +1,108 @@
---
description: "पिक्सेल को पुनः-एन्कोड किए बिना छवियों में EXIF, IPTC, GPS, और XMP मेटाडेटा फ़ील्ड संपादित करें।"
i18n_source_hash: a37746db11c3
i18n_provenance: human
i18n_output_hash: 207a10193804
---
# Edit Metadata {#edit-metadata}
EXIF, IPTC, GPS निर्देशांक, तिथियाँ, और कीवर्ड सहित छवि मेटाडेटा फ़ील्ड संपादित करें। पर्दे के पीछे ExifTool का उपयोग करता है, इसलिए मेटाडेटा पिक्सेल को पुनः-एन्कोड किए बिना यथास्थान लिखा जाता है, जिससे पूर्ण छवि गुणवत्ता संरक्षित रहती है।
## API Endpoints {#api-endpoints}
### Edit Metadata {#edit-metadata-1}
`POST /api/v1/tools/image/edit-metadata`
छवि में मेटाडेटा फ़ील्ड लिखता है और संशोधित फ़ाइल लौटाता है।
### Inspect Metadata {#inspect-metadata}
`POST /api/v1/tools/image/edit-metadata/inspect`
ExifTool के माध्यम से छवि से पूर्ण मेटाडेटा JSON के रूप में लौटाता है। छवि को संशोधित नहीं करता।
## Parameters (Edit) {#parameters-edit}
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| title | string | No | - | छवि शीर्षक (XMP/EXIF) |
| author | string | No | - | लेखक का नाम |
| artist | string | No | - | कलाकार का नाम (EXIF Artist टैग) |
| copyright | string | No | - | कॉपीराइट सूचना |
| imageDescription | string | No | - | छवि विवरण (EXIF) |
| software | string | No | - | Software टैग |
| dateTime | string | No | - | EXIF DateTime मान |
| dateTimeOriginal | string | No | - | EXIF DateTimeOriginal मान |
| setAllDates | string | No | - | सभी तिथि फ़ील्ड एक साथ सेट करें |
| dateShift | string | No | - | सभी तिथियों को ऑफ़सेट से स्थानांतरित करें (फ़ॉर्मेट: `+HH:MM` या `-HH:MM`) |
| clearGps | boolean | No | `false` | सभी GPS डेटा हटाएँ |
| gpsLatitude | number | No | - | GPS अक्षांश सेट करें (-90 से 90) |
| gpsLongitude | number | No | - | GPS देशांतर सेट करें (-180 से 180) |
| gpsAltitude | number | No | - | मीटर में GPS ऊँचाई सेट करें |
| keywords | string[] | No | - | जोड़ने या सेट करने के लिए कीवर्ड/टैग |
| keywordsMode | string | No | `"add"` | कीवर्ड को कैसे संभालें: `add` (जोड़ें) या `set` (प्रतिस्थापित करें) |
| fieldsToRemove | string[] | No | `[]` | हटाने के लिए विशिष्ट मेटाडेटा फ़ील्ड नामों की सूची |
| iptcTitle | string | No | - | IPTC Object Name |
| iptcHeadline | string | No | - | IPTC Headline |
| iptcCity | string | No | - | IPTC City |
| iptcState | string | No | - | IPTC Province/State |
| iptcCountry | string | No | - | IPTC Country |
## Example Request {#example-request}
लेखक और कॉपीराइट सेट करें:
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/edit-metadata \
-H "Authorization: Bearer si_your-api-key" \
-F "file=@photo.jpg" \
-F 'settings={"author": "Jane Smith", "copyright": "2024 Jane Smith"}'
```
GPS निर्देशांक सेट करें:
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/edit-metadata \
-H "Authorization: Bearer si_your-api-key" \
-F "file=@photo.jpg" \
-F 'settings={"gpsLatitude": 48.8566, "gpsLongitude": 2.3522, "gpsAltitude": 35}'
```
GPS हटाएँ और कीवर्ड जोड़ें:
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/edit-metadata \
-H "Authorization: Bearer si_your-api-key" \
-F "file=@photo.jpg" \
-F 'settings={"clearGps": true, "keywords": ["landscape", "sunset"], "keywordsMode": "add"}'
```
मेटाडेटा का निरीक्षण करें:
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/edit-metadata/inspect \
-H "Authorization: Bearer si_your-api-key" \
-F "file=@photo.jpg"
```
## Example Response (Edit) {#example-response-edit}
```json
{
"jobId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"downloadUrl": "/api/v1/download/a1b2c3d4-e5f6-7890-abcd-ef1234567890/photo.jpg",
"originalSize": 2450000,
"processedSize": 2452000
}
```
## Notes {#notes}
- इस टूल के लिए सर्वर पर ExifTool स्थापित होना आवश्यक है। यह Docker छवि में शामिल है।
- मेटाडेटा यथास्थान लिखा जाता है, इसलिए कोई पिक्सेल पुनः-एन्कोडिंग नहीं होती। फ़ाइल आकार में परिवर्तन न्यूनतम है (केवल मेटाडेटा बाइट्स)।
- `dateShift` पैरामीटर सभी तिथि फ़ील्ड को निर्दिष्ट ऑफ़सेट से स्थानांतरित करता है, जो समय क्षेत्र त्रुटियों को सुधारने के लिए उपयोगी है (उदा. `+02:00` या `-05:30`)।
- यदि कोई परिवर्तन अनुरोधित नहीं है (सभी पैरामीटर छोड़ दिए गए या खाली हैं), तो मूल फ़ाइल अपरिवर्तित लौटाई जाती है।
- समर्थित फ़ॉर्मेट: JPEG, PNG, WebP, AVIF, TIFF, GIF, HEIC/HEIF।
- गैर-ब्राउज़र-पूर्वावलोकन योग्य फ़ॉर्मेट (HEIF, TIFF) के लिए, प्रतिक्रिया में WebP पूर्वावलोकन के साथ एक `previewUrl` फ़ील्ड शामिल होता है।
+85
View File
@@ -0,0 +1,85 @@
---
description: "GFPGAN और CodeFormer AI मॉडल के साथ छवियों में धुंधले या निम्न-गुणवत्ता वाले चेहरों को पुनर्स्थापित और तीक्ष्ण करें।"
i18n_source_hash: 7f9f6af8ebda
i18n_provenance: human
i18n_output_hash: c7299bb94d61
---
# Face Enhancement {#face-enhancement}
AI मॉडल (GFPGAN/CodeFormer) का उपयोग करके छवियों में चेहरों को पुनर्स्थापित और उन्नत करें।
## API Endpoint {#api-endpoint}
`POST /api/v1/tools/image/enhance-faces`
**Processing:** अतुल्यकालिक (202 लौटाता है, SSE के माध्यम से स्थिति के लिए `/api/v1/jobs/{jobId}/progress` पर पोल करें)
**Model bundles:** `upscale-enhance` (5-6 GB) और `face-detection` (200-300 MB)
## Parameters {#parameters}
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| file | file | Yes | - | छवि फ़ाइल (मल्टीपार्ट) |
| model | string | No | `"auto"` | उपयोग करने के लिए मॉडल: `auto`, `gfpgan`, `codeformer` |
| strength | number | No | `0.8` | उन्नयन शक्ति (0-1)। उच्च मान अधिक प्रबल उन्नयन उत्पन्न करते हैं |
| onlyCenterFace | boolean | No | `false` | केवल सबसे केंद्रीय/प्रमुख चेहरे को उन्नत करें |
| sensitivity | number | No | `0.5` | चेहरा पहचान संवेदनशीलता (0-1) |
## Example Request {#example-request}
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/enhance-faces \
-F "file=@portrait.jpg" \
-F 'settings={"model":"codeformer","strength":0.7,"onlyCenterFace":false}'
```
## Response {#response}
### Initial Response (202 Accepted) {#initial-response-202-accepted}
```json
{
"jobId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"async": true
}
```
### Progress (SSE at `/api/v1/jobs/{jobId}/progress`) {#progress-sse-at-api-v1-jobs-jobid-progress}
```
event: progress
data: {"phase":"processing","stage":"Enhancing faces...","percent":60}
```
### Final Result (via SSE) {#final-result-via-sse}
```json
{
"phase": "complete",
"percent": 100,
"result": {
"jobId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"downloadUrl": "/api/v1/download/{jobId}/portrait_enhanced.png",
"previewUrl": "/api/v1/download/{jobId}/preview.webp",
"originalSize": 350000,
"processedSize": 600000,
"facesDetected": 2,
"faces": [
{"x": 120, "y": 80, "w": 100, "h": 100},
{"x": 350, "y": 90, "w": 95, "h": 95}
],
"model": "codeformer"
}
}
```
## Notes {#notes}
- `upscale-enhance` मॉडल बंडल (5-6 GB) और `face-detection` मॉडल बंडल (200-300 MB) दोनों आवश्यक हैं।
- GFPGAN अधिक आक्रामक उन्नयन उत्पन्न करता है; CodeFormer पहचान को बेहतर संरक्षित करता है। `auto` इनपुट के लिए सर्वोत्तम मॉडल का चयन करता है।
- अधिकतम गुणवत्ता के लिए आउटपुट हमेशा PNG फ़ॉर्मेट होता है।
- तेज़ फ़्रंटएंड प्रदर्शन के लिए पूर्ण-विभेदन आउटपुट के साथ एक WebP पूर्वावलोकन उत्पन्न किया जाता है।
- `strength` पैरामीटर उन्नत चेहरे को मूल के साथ मिश्रित करता है। सूक्ष्म सुधारों के लिए कम मान (0.3-0.5), प्रबल पुनर्स्थापना के लिए उच्च मान (0.7-1.0) का उपयोग करें।
- स्वचालित डिकोडिंग के माध्यम से HEIC/HEIF, RAW, TGA, PSD, EXR, और HDR इनपुट फ़ॉर्मेट का समर्थन करता है।
+79
View File
@@ -0,0 +1,79 @@
---
description: "AI इनपेंटिंग (LaMa) के साथ छवियों से अवांछित वस्तुओं को हटाएँ, मिटाने वाले क्षेत्र के मास्क द्वारा निर्देशित।"
i18n_source_hash: 8e2e42a5e4f9
i18n_provenance: human
i18n_output_hash: b95f28ea1761
---
# Object Eraser {#object-eraser}
AI इनपेंटिंग (LaMa मॉडल) का उपयोग करके छवियों से अवांछित वस्तुओं को हटाएँ। एक छवि और मिटाने वाले क्षेत्र को इंगित करने वाला एक मास्क स्वीकार करता है।
## API Endpoint {#api-endpoint}
`POST /api/v1/tools/image/erase-object`
**Processing:** अतुल्यकालिक (202 लौटाता है, SSE के माध्यम से स्थिति के लिए `/api/v1/jobs/{jobId}/progress` पर पोल करें)
**Model bundle:** `object-eraser-colorize` (1-2 GB)
## Parameters {#parameters}
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| file | file | Yes | - | स्रोत छवि फ़ाइल (मल्टीपार्ट) |
| mask | file | Yes | - | मास्क छवि (सफ़ेद = मिटाने का क्षेत्र, काला = रखें)। फ़ील्डनाम `mask` के साथ अपलोड किया जाना चाहिए |
| format | string | No | `"auto"` | आउटपुट फ़ॉर्मेट: `auto`, `png`, `jpg`, `jpeg`, `webp`, `tiff`, `gif`, `avif`, `heic`, `heif`, `jxl` |
| quality | integer | No | `95` | आउटपुट गुणवत्ता (1-100) |
## Example Request {#example-request}
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/erase-object \
-F "file=@photo.jpg" \
-F "mask=@mask.png" \
-F "format=png" \
-F "quality=95"
```
## Response {#response}
### Initial Response (202 Accepted) {#initial-response-202-accepted}
```json
{
"jobId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"async": true
}
```
### Progress (SSE at `/api/v1/jobs/{jobId}/progress`) {#progress-sse-at-api-v1-jobs-jobid-progress}
```
event: progress
data: {"phase":"processing","stage":"Inpainting...","percent":70}
```
### Final Result (via SSE) {#final-result-via-sse}
```json
{
"phase": "complete",
"percent": 100,
"result": {
"jobId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"downloadUrl": "/api/v1/download/{jobId}/photo_erased.png",
"previewUrl": "/api/v1/download/{jobId}/preview.webp",
"originalSize": 245000,
"processedSize": 230000
}
}
```
## Notes {#notes}
- `object-eraser-colorize` मॉडल बंडल का स्थापित होना आवश्यक है (1-2 GB)।
- मास्क का स्रोत छवि के समान आयाम होना चाहिए। सफ़ेद पिक्सेल मिटाने वाले क्षेत्रों को इंगित करते हैं; AI उन्हें प्रशंसनीय सामग्री से भरता है।
- उच्च-गुणवत्ता वाली वस्तु हटाने के लिए LaMa (Large Mask Inpainting) का उपयोग करता है।
- गैर-ब्राउज़र-पूर्वावलोकन योग्य आउटपुट फ़ॉर्मेट के लिए, मुख्य आउटपुट के साथ एक WebP पूर्वावलोकन उत्पन्न किया जाता है।
- स्वचालित डिकोडिंग के माध्यम से HEIC/HEIF, RAW, TGA, PSD, EXR, और HDR इनपुट फ़ॉर्मेट का समर्थन करता है।
+93
View File
@@ -0,0 +1,93 @@
---
description: "किसी स्रोत छवि से सभी मानक favicon और app आइकन आकार जनरेट करें।"
i18n_source_hash: 3a6451a94b7a
i18n_provenance: human
i18n_output_hash: eb3a99b7652f
---
# Favicon Generator {#favicon-generator}
किसी स्रोत छवि से favicon और app आइकन फ़ाइलों का पूरा सेट जनरेट करें। ब्राउज़रों, Apple डिवाइसों और Android के लिए आवश्यक सभी मानक आकार बनाता है, साथ ही एक web manifest और एक HTML स्निपेट भी।
## API Endpoint {#api-endpoint}
`POST /api/v1/tools/image/favicon`
एक या अधिक image फ़ाइलों और एक वैकल्पिक JSON `settings` फ़ील्ड के साथ multipart form data स्वीकार करता है।
## Parameters {#parameters}
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| background | string | नहीं | - | Background hex रंग (जैसे `"#ffffff"`)। सेट होने पर, आइकन को इस रंग पर फ़्लैट कर दिया जाता है। |
| padding | integer | नहीं | `0` | आइकन सामग्री के चारों ओर Padding प्रतिशत (0 से 40) |
| radius | integer | नहीं | `0` | गोल आइकनों के लिए Corner radius प्रतिशत (0 से 50) |
| sizes | integer[] | नहीं | - | आउटपुट को विशिष्ट पिक्सेल आकारों तक सीमित करें (जैसे `[16, 32, 180]`)। सभी मानक आकार जनरेट करने के लिए इसे छोड़ दें। |
| themeColor | string | नहीं | `"#ffffff"` | web manifest के लिए Theme रंग hex |
## Generated Files {#generated-files}
प्रत्येक इनपुट छवि के लिए, निम्नलिखित फ़ाइलें बनाई जाती हैं:
| File | Size | Purpose |
|------|------|---------|
| `favicon-16x16.png` | 16x16 | Browser tab आइकन |
| `favicon-32x32.png` | 32x32 | Browser tab आइकन (HiDPI) |
| `favicon-48x48.png` | 48x48 | Desktop शॉर्टकट |
| `apple-touch-icon.png` | 180x180 | iOS होम स्क्रीन |
| `android-chrome-192x192.png` | 192x192 | Android होम स्क्रीन |
| `android-chrome-512x512.png` | 512x512 | Android स्प्लैश स्क्रीन |
| `favicon.ico` | 32x32 | Legacy ICO प्रारूप |
| `manifest.json` | - | आइकन संदर्भों के साथ web app manifest |
| `favicon-snippet.html` | - | उपयोग के लिए तैयार HTML link टैग |
## Example Request {#example-request}
गोल किनारों और padding के साथ एकल स्रोत छवि:
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/favicon \
-H "Authorization: Bearer si_your-api-key" \
-F "file=@logo.png" \
-F 'settings={"padding": 10, "radius": 20, "themeColor": "#0a0a0a"}'
```
एकाधिक स्रोत छवियाँ (प्रत्येक को एक सबफ़ोल्डर में अपना सेट मिलता है):
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/favicon \
-H "Authorization: Bearer si_your-api-key" \
-F "file=@logo-light.png" \
-F "file=@logo-dark.png"
```
## Example Response {#example-response}
प्रतिक्रिया एक ZIP फ़ाइल है जो सीधे स्ट्रीम की जाती है। प्रतिक्रिया हेडर इस प्रकार हैं:
```
Content-Type: application/zip
Content-Disposition: attachment; filename="favicons-a1b2c3d4.zip"
```
## HTML Snippet Included {#html-snippet-included}
ZIP में एक `favicon-snippet.html` फ़ाइल शामिल है जिसे आप अपने HTML `<head>` में पेस्ट कर सकते हैं:
```html
<!-- Favicons -->
<link rel="icon" type="image/png" sizes="16x16" href="/favicon-16x16.png">
<link rel="icon" type="image/png" sizes="32x32" href="/favicon-32x32.png">
<link rel="icon" type="image/png" sizes="48x48" href="/favicon-48x48.png">
<link rel="apple-touch-icon" sizes="180x180" href="/apple-touch-icon.png">
<link rel="manifest" href="/manifest.json">
```
## Notes {#notes}
- स्रोत छवियों का आकार `cover` fit मोड का उपयोग करके बदला जाता है, यानी उन्हें प्रत्येक वर्गाकार आकार को भरने के लिए क्रॉप किया जाता है। सर्वोत्तम परिणामों के लिए, एक वर्गाकार स्रोत छवि का उपयोग करें।
- जब एकाधिक फ़ाइलें अपलोड की जाती हैं, तो प्रत्येक को ZIP में अपना सबफ़ोल्डर मिलता है (स्रोत फ़ाइल के नाम पर)।
- एकल फ़ाइल अपलोड के लिए, सभी आउटपुट बिना किसी सबफ़ोल्डर के ZIP की जड़ में होते हैं।
- जो फ़ाइलें सत्यापन या डिकोडिंग में विफल होती हैं उन्हें छोड़ दिया जाता है, और समस्याओं को समझाने वाला एक `skipped-files.txt` ZIP में शामिल किया जाता है।
- समर्थित इनपुट प्रारूप: JPEG, PNG, WebP, AVIF, TIFF, GIF, HEIC, SVG, RAW, PSD और अन्य।
- आकार बदलने से पहले EXIF orientation स्वतः लागू किया जाता है।
+115
View File
@@ -0,0 +1,115 @@
---
description: "perceptual hashing का उपयोग करके डुप्लिकेट और लगभग-डुप्लिकेट छवियों का पता लगाएँ।"
i18n_source_hash: 4e1f4413f90f
i18n_provenance: human
i18n_output_hash: 01b3ff8dc3b0
---
# Find Duplicates {#find-duplicates}
perceptual hashing (dHash) का उपयोग करके डुप्लिकेट और लगभग-डुप्लिकेट का पता लगाने के लिए कई छवियाँ अपलोड करें। समान छवियों को एक साथ समूहित करता है, प्रत्येक समूह में सर्वोत्तम गुणवत्ता वाले संस्करण की पहचान करता है, और संभावित स्थान बचत की गणना करता है।
## API Endpoint {#api-endpoint}
`POST /api/v1/tools/image/find-duplicates`
एकाधिक image फ़ाइलों और एक वैकल्पिक JSON `settings` फ़ील्ड के साथ multipart form data स्वीकार करता है।
## Parameters {#parameters}
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| threshold | number | नहीं | `8` | छवियों को डुप्लिकेट मानने के लिए अधिकतम Hamming दूरी (0 से 20)। कम = सख़्त मिलान |
### File Fields {#file-fields}
multipart अनुरोध में कम से कम 2 image फ़ाइलें अपलोड करें (सभी `file` फ़ील्ड नाम का उपयोग करते हुए या फ़ाइल भागों के लिए कोई भी फ़ील्ड नाम)।
## Example Request {#example-request}
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/find-duplicates \
-H "Authorization: Bearer si_your-api-key" \
-F "file=@photo1.jpg" \
-F "file=@photo2.jpg" \
-F "file=@photo3.jpg" \
-F "file=@photo4.jpg" \
-F 'settings={"threshold": 8}'
```
## Example Response {#example-response}
```json
{
"totalImages": 4,
"duplicateGroups": [
{
"groupId": 1,
"files": [
{
"filename": "photo1.jpg",
"similarity": 100,
"width": 4032,
"height": 3024,
"fileSize": 2450000,
"format": "jpeg",
"isBest": true,
"thumbnail": "data:image/jpeg;base64,/9j/..."
},
{
"filename": "photo2.jpg",
"similarity": 96.88,
"width": 1920,
"height": 1440,
"fileSize": 850000,
"format": "jpeg",
"isBest": false,
"thumbnail": "data:image/jpeg;base64,/9j/..."
}
]
}
],
"uniqueImages": 2,
"spaceSaveable": 850000,
"skippedFiles": []
}
```
## Response Fields {#response-fields}
| Field | Type | Description |
|-------|------|-------------|
| totalImages | number | सफलतापूर्वक विश्लेषित छवियों की संख्या |
| duplicateGroups | array | डुप्लिकेट छवियों के समूह |
| uniqueImages | number | किसी भी डुप्लिकेट समूह का हिस्सा न होने वाली छवियों की संख्या |
| spaceSaveable | number | गैर-सर्वोत्तम डुप्लिकेट हटाकर बचाए जा सकने वाले कुल बाइट |
| skippedFiles | array | ऐसी फ़ाइलें जिन्हें संसाधित नहीं किया जा सका (फ़ाइलनाम और कारण के साथ) |
### Duplicate Group Object {#duplicate-group-object}
| Field | Type | Description |
|-------|------|-------------|
| groupId | number | समूह पहचानकर्ता |
| files | array | इस डुप्लिकेट समूह की छवियाँ |
### File Object (within a group) {#file-object-within-a-group}
| Field | Type | Description |
|-------|------|-------------|
| filename | string | मूल फ़ाइलनाम |
| similarity | number | संदर्भ छवि (समूह में पहली) के साथ समानता प्रतिशत |
| width | number | छवि चौड़ाई पिक्सेल में |
| height | number | छवि ऊँचाई पिक्सेल में |
| fileSize | number | फ़ाइल आकार बाइट में |
| format | string | छवि प्रारूप |
| isBest | boolean | क्या यह उच्चतम गुणवत्ता वाला संस्करण है (सबसे अधिक पिक्सेल, सबसे बड़ी फ़ाइल) |
| thumbnail | string या null | पूर्वावलोकन के लिए Base64 JPEG थंबनेल (200px चौड़ा) |
## Notes {#notes}
- perceptual समानता का पता लगाने के लिए 128-bit dHash (64-bit पंक्ति + 64-bit स्तंभ) का उपयोग करता है। यह आकार बदलने, पुनः-संपीड़न और छोटे संपादनों के बावजूद भी डुप्लिकेट पकड़ता है।
- threshold, hashes के बीच अधिकतम Hamming दूरी को दर्शाता है। 8 का डिफ़ॉल्ट झूठी सकारात्मकता से बचते हुए लगभग-डुप्लिकेट पकड़ता है। केवल पिक्सेल-समरूप के लिए 0 का उपयोग करें, या बहुत ढीले मिलान के लिए 15-20 का।
- प्रत्येक समूह में "सर्वोत्तम" छवि वह होती है जिसमें सबसे अधिक पिक्सेल (चौड़ाई x ऊँचाई) होते हैं, और फ़ाइल आकार टाईब्रेकर के रूप में होता है।
- कम से कम 2 छवियाँ आवश्यक हैं। जो फ़ाइलें सत्यापन या डिकोडिंग में विफल होती हैं उन्हें पूरे अनुरोध को विफल करने के बजाय `skippedFiles` में रिपोर्ट किया जाता है।
- थंबनेल 200px-चौड़े JPEG पूर्वावलोकन हैं जो data URIs के रूप में एन्कोड किए जाते हैं।
- सभी सामान्य प्रारूप समर्थित हैं (HEIC, RAW, PSD, SVG स्वचालित रूप से डिकोड किए जाते हैं)।
+147
View File
@@ -0,0 +1,147 @@
---
description: "एक ही टूल में animated GIFs का आकार बदलें, अनुकूलित करें, गति बदलें, उलटें, घुमाएँ और फ़्रेम निकालें।"
i18n_source_hash: 5e525e80db92
i18n_provenance: human
i18n_output_hash: 1e304ec45635
---
# GIF Tools {#gif-tools}
animated GIFs का आकार बदलें, अनुकूलित करें, गति बदलें, उलटें, फ़्रेम निकालें और घुमाएँ। एक ही टूल में कई ऑपरेशन मोड प्रदान करता है।
## API Endpoint {#api-endpoint}
`POST /api/v1/tools/image/gif-tools`
## Parameters {#parameters}
### Common Parameters {#common-parameters}
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| mode | string | नहीं | `"resize"` | ऑपरेशन मोड: `resize`, `optimize`, `speed`, `reverse`, `extract`, `rotate` |
| loop | number | नहीं | 0 | आउटपुट GIF के लिए Loop गणना (0 = अनंत, 1-100 = परिमित लूप) |
### Resize Mode Parameters {#resize-mode-parameters}
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| width | integer | नहीं | - | लक्ष्य चौड़ाई पिक्सेल में (1 से 16384) |
| height | integer | नहीं | - | लक्ष्य ऊँचाई पिक्सेल में (1 से 16384) |
| percentage | number | नहीं | - | प्रतिशत के अनुसार स्केल करें (1 से 500)। सेट होने पर width/height को ओवरराइड करता है। |
### Optimize Mode Parameters {#optimize-mode-parameters}
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| colors | number | नहीं | 256 | पैलेट में रंगों की अधिकतम संख्या (2 से 256) |
| dither | number | नहीं | 1.0 | Dithering ताकत (0 से 1, जहाँ 0 dithering को अक्षम करता है) |
| effort | number | नहीं | 7 | अनुकूलन प्रयास स्तर (1 से 10, अधिक = धीमा लेकिन छोटा) |
### Speed Mode Parameters {#speed-mode-parameters}
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| speedFactor | number | नहीं | 1.0 | गति गुणक (0.1 से 10)। 1 से अधिक मान गति बढ़ाते हैं, 1 से कम गति घटाते हैं। |
### Extract Mode Parameters {#extract-mode-parameters}
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| extractMode | string | नहीं | `"single"` | निष्कर्षण मोड: `single`, `range`, `all` |
| frameNumber | number | नहीं | 0 | `single` मोड में निकालने के लिए फ़्रेम अनुक्रमणिका (0-आधारित) |
| frameStart | number | नहीं | 0 | `range` मोड के लिए प्रारंभ फ़्रेम अनुक्रमणिका (0-आधारित) |
| frameEnd | number | नहीं | - | `range` मोड के लिए अंतिम फ़्रेम अनुक्रमणिका (0-आधारित, समावेशी) |
| extractFormat | string | नहीं | `"png"` | निकाले गए फ़्रेमों के लिए प्रारूप: `png`, `webp` |
### Rotate Mode Parameters {#rotate-mode-parameters}
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| angle | number | नहीं | - | घूर्णन कोण: `90`, `180`, या `270` डिग्री |
| flipH | boolean | नहीं | `false` | क्षैतिज रूप से फ़्लिप करें |
| flipV | boolean | नहीं | `false` | लंबवत रूप से फ़्लिप करें |
## Example Requests {#example-requests}
### Resize {#resize}
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/gif-tools \
-F "file=@animation.gif" \
-F 'settings={"mode":"resize","percentage":50}'
```
### Optimize {#optimize}
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/gif-tools \
-F "file=@large.gif" \
-F 'settings={"mode":"optimize","colors":128,"effort":9}'
```
### Speed Up {#speed-up}
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/gif-tools \
-F "file=@animation.gif" \
-F 'settings={"mode":"speed","speedFactor":2.0}'
```
### Extract Single Frame {#extract-single-frame}
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/gif-tools \
-F "file=@animation.gif" \
-F 'settings={"mode":"extract","extractMode":"single","frameNumber":5,"extractFormat":"png"}'
```
## Example Response {#example-response}
```json
{
"jobId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"downloadUrl": "/api/v1/download/a1b2c3d4-e5f6-7890-abcd-ef1234567890/animation.gif",
"originalSize": 2345678,
"processedSize": 1234567
}
```
## Info Sub-Route {#info-sub-route}
`POST /api/v1/tools/image/gif-tools/info`
संसाधित किए बिना किसी animated GIF के बारे में मेटाडेटा लौटाता है।
### Info Request {#info-request}
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/gif-tools/info \
-F "file=@animation.gif"
```
### Info Response {#info-response}
```json
{
"width": 480,
"height": 320,
"pages": 24,
"delay": [100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100],
"loop": 0,
"fileSize": 2345678,
"duration": 2400
}
```
## Notes {#notes}
- मुख्य प्रसंस्करण endpoint के लिए मानक `createToolRoute` factory का उपयोग करता है।
- info endpoint को केवल एक फ़ाइल अपलोड की आवश्यकता होती है (किसी सेटिंग की ज़रूरत नहीं)।
- `resize` मोड में, यदि `percentage` प्रदान किया जाता है तो यह `width`/`height` पर प्राथमिकता लेता है। आकार बदलने के लिए aspect ratio बनाए रखने हेतु `fit: inside` का उपयोग किया जाता है।
- `speed` मोड में, फ़्रेम विलंब को speed factor से विभाजित किया जाता है। प्रति फ़्रेम न्यूनतम विलंब 20ms है (GIF स्पेक सीमा)।
- `reverse` मोड में, उलटते समय गति को एक साथ समायोजित करने के लिए `speedFactor` parameter भी उपलब्ध है।
- `extract` मोड में `range` या `all` के साथ, आउटपुट एक ZIP फ़ाइल होती है जिसमें अलग-अलग फ़्रेम होते हैं।
- `rotate` मोड में, प्रत्येक फ़्रेम को अलग से संसाधित किया जाता है और एक एनिमेशन में पुनः जोड़ा जाता है।
- `loop` parameter नियंत्रित करता है कि आउटपुट GIF कितनी बार लूप करता है। अनंत लूपिंग के लिए 0 का उपयोग करें।
- info प्रतिक्रिया में `duration` फ़ील्ड मिलीसेकंड में कुल एनिमेशन अवधि है।
+51
View File
@@ -0,0 +1,51 @@
---
description: "सभी फ़्रेमों को संरक्षित करते हुए animated GIF को WebP में और इसके विपरीत बदलें।"
i18n_source_hash: 20946e5001cb
i18n_provenance: human
i18n_output_hash: a999ed39e3fa
---
# GIF/WebP Converter {#gif-webp-converter}
सभी फ़्रेमों और एनिमेशन समय को संरक्षित करते हुए animated GIF फ़ाइलों को WebP में और इसके विपरीत बदलें। WebP एनिमेशन आमतौर पर समकक्ष GIFs की तुलना में 25-35% छोटे होते हैं।
## API Endpoint {#api-endpoint}
`POST /api/v1/tools/image/gif-webp`
GIF या WebP फ़ाइल और एक JSON `settings` फ़ील्ड के साथ multipart form data स्वीकार करता है।
## Parameters {#parameters}
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| quality | integer | नहीं | `80` | WebP एन्कोडिंग के लिए आउटपुट गुणवत्ता (1-100) |
| lossless | boolean | नहीं | `false` | lossless WebP संपीड़न का उपयोग करें |
| resizePercent | integer | नहीं | `100` | आउटपुट को प्रतिशत के अनुसार स्केल करें (10-100) |
## Example Request {#example-request}
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/gif-webp \
-H "Authorization: Bearer si_your-api-key" \
-F "file=@animation.gif" \
-F 'settings={"quality": 85, "resizePercent": 50}'
```
## Example Response {#example-response}
```json
{
"jobId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"downloadUrl": "/api/v1/download/a1b2c3d4-e5f6-7890-abcd-ef1234567890/animation.webp",
"originalSize": 3500000,
"processedSize": 2200000
}
```
## Notes {#notes}
- केवल `.gif` और `.webp` फ़ाइलें स्वीकार की जाती हैं। इस टूल द्वारा अन्य छवि प्रारूप समर्थित नहीं हैं।
- रूपांतरण दिशा स्वचालित है: GIF इनपुट WebP आउटपुट उत्पन्न करता है, और WebP इनपुट GIF आउटपुट उत्पन्न करता है।
- `quality` और `lossless` विकल्प केवल WebP में एन्कोड करते समय लागू होते हैं। GIF में बदलते समय, आउटपुट मानक GIF पैलेट का उपयोग करता है।
- बड़े एनिमेशन के आयाम (और फ़ाइल आकार) कम करने के लिए `resizePercent` का उपयोग करें।
+65
View File
@@ -0,0 +1,65 @@
---
description: "किसी छवि से प्रति-चैनल आँकड़ों के साथ एक RGB histogram चार्ट जनरेट करें।"
i18n_source_hash: 57aa610206a5
i18n_provenance: human
i18n_output_hash: adc060a069a5
---
# Histogram {#histogram}
किसी छवि से एक RGB histogram चार्ट जनरेट करें। प्रतिक्रिया JSON में प्रति-चैनल आँकड़ों और कच्चे 256-bin histogram डेटा के साथ एक PNG histogram छवि लौटाता है।
## API Endpoint {#api-endpoint}
`POST /api/v1/tools/image/histogram`
एक image फ़ाइल और एक JSON `settings` फ़ील्ड के साथ multipart form data स्वीकार करता है।
## Parameters {#parameters}
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| scale | string | नहीं | `"linear"` | Y-axis स्केल: `linear` या `log` |
## Example Request {#example-request}
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/histogram \
-H "Authorization: Bearer si_your-api-key" \
-F "file=@photo.jpg" \
-F 'settings={"scale": "linear"}'
```
## Example Response {#example-response}
```json
{
"jobId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"downloadUrl": "/api/v1/download/a1b2c3d4-e5f6-7890-abcd-ef1234567890/histogram.png",
"originalSize": 2450000,
"processedSize": 12000,
"bins": {
"r": [0, 12, 45, "... (256 values)"],
"g": [0, 8, 38, "... (256 values)"],
"b": [2, 15, 52, "... (256 values)"],
"lum": [0, 10, 40, "... (256 values)"]
},
"stats": {
"r": { "mean": 128, "median": 132, "stdev": 48.5 },
"g": { "mean": 119, "median": 121, "stdev": 44.2 },
"b": { "mean": 105, "median": 108, "stdev": 51.3 },
"lum": { "mean": 118, "median": 120, "stdev": 45.1 }
},
"mean": { "r": 128, "g": 119, "b": 105 },
"max": { "r": 4200, "g": 3800, "b": 4100 }
}
```
## Notes {#notes}
- `downloadUrl` एक रेंडर किए गए PNG histogram चार्ट की ओर इंगित करता है जो R, G, B और luminance वितरण दिखाता है।
- `bins` में प्रत्येक चैनल (red, green, blue, luminance) के लिए कच्चे 256-मान arrays होते हैं, जो कस्टम विज़ुअलाइज़ेशन रेंडर करने के लिए उपयुक्त हैं।
- `stats` प्रति चैनल mean, median और मानक विचलन प्रदान करता है।
- `mean` और `max` पश्च-संगत शॉर्टहैंड फ़ील्ड हैं।
- जब histogram पर कुछ शिखर हावी हों और आप निचले bins में विवरण देखना चाहें तो `log` स्केल का उपयोग करें।
- HEIC, RAW, PSD और SVG इनपुट विश्लेषण से पहले स्वचालित रूप से डिकोड किए जाते हैं।
+81
View File
@@ -0,0 +1,81 @@
---
description: "device emulation के साथ वेबपेजों या HTML स्निपेट को उच्च-गुणवत्ता वाली छवियों के रूप में कैप्चर करें।"
i18n_source_hash: 1e49d070ea2e
i18n_provenance: human
i18n_output_hash: 40115a0117ef
---
# HTML to Image {#html-to-image}
किसी वेबपेज URL या कच्ची HTML सामग्री को स्क्रीनशॉट छवि के रूप में कैप्चर करें। device emulation (desktop, tablet, mobile), full-page कैप्चर और कई आउटपुट प्रारूपों का समर्थन करता है।
## API Endpoint {#api-endpoint}
`POST /api/v1/tools/image/html-to-image`
एक **JSON body** स्वीकार करता है (multipart नहीं)। किसी फ़ाइल अपलोड की आवश्यकता नहीं है।
## Parameters {#parameters}
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| url | string | सशर्त | - | कैप्चर करने के लिए URL (एक वैध URL होना चाहिए) |
| html | string | सशर्त | - | रेंडर करने के लिए कच्ची HTML सामग्री (1 से 5,000,000 वर्ण) |
| format | string | नहीं | `"png"` | आउटपुट प्रारूप: `jpg`, `png`, `webp` |
| quality | number | नहीं | `90` | lossy प्रारूपों के लिए आउटपुट गुणवत्ता (1 से 100) |
| fullPage | boolean | नहीं | `false` | केवल viewport नहीं, बल्कि पूरे स्क्रॉल करने योग्य पृष्ठ को कैप्चर करें |
| devicePreset | string | नहीं | `"desktop"` | device emulation: `desktop`, `tablet`, `mobile`, `custom` |
| viewportWidth | number | नहीं | `1280` | कस्टम viewport चौड़ाई पिक्सेल में (320 से 3840, जब devicePreset `custom` हो तब उपयोग होती है) |
| viewportHeight | number | नहीं | `720` | कस्टम viewport ऊँचाई पिक्सेल में (320 से 2160, जब devicePreset `custom` हो तब उपयोग होती है) |
या तो `url` या `html` प्रदान किया जाना चाहिए, लेकिन दोनों नहीं।
### Device Presets {#device-presets}
| Preset | Width | Height | Mobile UA |
|--------|-------|--------|-----------|
| `desktop` | 1280 | 720 | नहीं |
| `tablet` | 768 | 1024 | नहीं |
| `mobile` | 375 | 812 | हाँ |
| `custom` | (उपयोगकर्ता-निर्दिष्ट) | (उपयोगकर्ता-निर्दिष्ट) | नहीं |
## Example Request {#example-request}
किसी वेबपेज को कैप्चर करें:
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/html-to-image \
-H "Authorization: Bearer si_your-api-key" \
-H "Content-Type: application/json" \
-d '{"url": "https://example.com", "format": "png", "fullPage": true, "devicePreset": "desktop"}'
```
HTML सामग्री रेंडर करें:
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/html-to-image \
-H "Authorization: Bearer si_your-api-key" \
-H "Content-Type: application/json" \
-d '{"html": "<div style=\"padding: 20px; background: #f0f0f0;\"><h1>Hello</h1></div>", "format": "png"}'
```
## Example Response {#example-response}
```json
{
"jobId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"downloadUrl": "/api/v1/download/a1b2c3d4-e5f6-7890-abcd-ef1234567890/screenshot.png",
"originalSize": 0,
"processedSize": 145000
}
```
## Notes {#notes}
- सर्वर पर Chromium इंस्टॉल होना आवश्यक है। यदि browser सेवा उपलब्ध नहीं है तो HTTP 503 लौटाता है।
- URLs को SSRF हमलों के विरुद्ध सत्यापित किया जाता है (निजी/आंतरिक नेटवर्क पते अवरुद्ध हैं)।
- यह endpoint प्रति घंटे 120 अनुरोधों तक दर-सीमित है।
- `originalSize` हमेशा 0 होता है क्योंकि यह टूल URLs/HTML से छवियाँ जनरेट करता है।
- आउटपुट फ़ाइलनाम `screenshot.<format>` है।
- यदि पृष्ठ लोड होने में बहुत अधिक समय लेता है, तो अनुरोध HTTP 504 (gateway timeout) लौटाता है।
- यदि browser सेवा बार-बार क्रैश होती है, तो इसे अस्थायी रूप से अक्षम कर दिया जाता है और code `BROWSER_CRASHED` के साथ HTTP 503 लौटाया जाता है।
@@ -0,0 +1,99 @@
---
description: "एक-क्लिक ऑटो-एन्हांस जो किसी छवि का विश्लेषण करता है और exposure, contrast, white balance, saturation और sharpness को ठीक करता है।"
i18n_source_hash: 42b6ab956f91
i18n_provenance: human
i18n_output_hash: 395f33828221
---
# Image Enhancement {#image-enhancement}
स्मार्ट विश्लेषण के साथ एक-क्लिक ऑटो-सुधार। छवि का विश्लेषण करता है और exposure, contrast, white balance, saturation, sharpness और denoising सुधार लागू करता है।
## API Endpoint {#api-endpoint}
`POST /api/v1/tools/image/image-enhancement`
**Processing:** समकालिक (`createToolRoute` factory का उपयोग करता है, परिणाम सीधे लौटाता है)
**Model bundle:** बुनियादी एन्हांसमेंट के लिए कोई आवश्यक नहीं। `upscale-enhance` bundle (5-6 GB) का उपयोग केवल तब किया जाता है जब `deepEnhance` सक्षम हो (SCUNet के माध्यम से AI noise removal के लिए)।
## Parameters {#parameters}
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| file | file | हाँ | - | Image फ़ाइल (multipart) |
| mode | string | नहीं | `"auto"` | एन्हांसमेंट मोड: `auto`, `portrait`, `landscape`, `low-light`, `food`, `document` |
| intensity | number | नहीं | `50` | समग्र एन्हांसमेंट तीव्रता (0-100) |
| corrections | object | नहीं | सभी `true` | लागू करने के लिए चयनात्मक सुधार (नीचे देखें) |
| deepEnhance | boolean | नहीं | `false` | AI-संचालित noise removal सक्षम करें (`noise-removal` टूल इंस्टॉल होना आवश्यक) |
### Corrections Object {#corrections-object}
| Field | Type | Default | Description |
|-------|------|---------|-------------|
| exposure | boolean | `true` | Exposure को स्वतः-सुधारें |
| contrast | boolean | `true` | Contrast को स्वतः-सुधारें |
| whiteBalance | boolean | `true` | White balance को स्वतः-सुधारें |
| saturation | boolean | `true` | Saturation को स्वतः-सुधारें |
| sharpness | boolean | `true` | स्वतः-शार्पन करें |
| denoise | boolean | `true` | हल्का denoising |
## Example Request {#example-request}
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/image-enhancement \
-F "file=@photo.jpg" \
-F 'settings={"mode":"portrait","intensity":70,"corrections":{"exposure":true,"contrast":true,"sharpness":false}}'
```
## Response (200 OK) {#response-200-ok}
```json
{
"jobId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"downloadUrl": "/api/v1/download/{jobId}/photo.jpg",
"originalSize": 300000,
"processedSize": 310000
}
```
## Analyze Endpoint {#analyze-endpoint}
`POST /api/v1/tools/image/image-enhancement/analyze`
किसी छवि का विश्लेषण करता है और उन्हें लागू किए बिना सुधार अनुशंसाएँ लौटाता है।
### Parameters {#parameters-1}
| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| file | file | हाँ | Image फ़ाइल (multipart) |
### Example Request {#example-request-1}
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/image-enhancement/analyze \
-F "file=@photo.jpg"
```
### Response (200 OK) {#response-200-ok-1}
```json
{
"corrections": {
"exposure": { "value": 0.3, "direction": "brighten" },
"contrast": { "value": 0.2, "direction": "increase" },
"whiteBalance": { "value": 200, "direction": "warmer" },
"saturation": { "value": 0.1, "direction": "increase" },
"sharpness": { "value": 0.4, "direction": "sharpen" }
}
}
```
## Notes {#notes}
- यह टूल समकालिक `createToolRoute` factory का उपयोग करता है, इसलिए यह एक मानक प्रतिक्रिया लौटाता है (202 async नहीं)।
- `mode` parameter समायोजित करता है कि सुधारों को कैसे भारित किया जाए (जैसे, portrait मोड त्वचा टोन पर अधिक कोमल होता है, landscape मोड saturation बढ़ाता है)।
- जब `deepEnhance` सक्षम हो और `noise-removal` टूल (SCUNet) इंस्टॉल हो, तो मानक सुधारों के बाद एक अतिरिक्त AI denoising पास लागू किया जाता है।
- analyze endpoint यह पूर्वावलोकन करने के लिए उपयोगी है कि प्रतिबद्ध करने से पहले कौन से सुधार लागू किए जाएँगे।
- स्वचालित डिकोडिंग के माध्यम से HEIC/HEIF, RAW, TGA, PSD, EXR और HDR इनपुट प्रारूपों का समर्थन करता है।
+54
View File
@@ -0,0 +1,54 @@
---
description: "किसी छवि को एक ठोस रंग, पारदर्शी, या धुँधली पृष्ठभूमि के साथ किसी लक्ष्य aspect ratio तक pad करें।"
i18n_source_hash: 796122da3dae
i18n_provenance: human
i18n_output_hash: 744bbfe55c0d
---
# Image Pad {#image-pad}
किसी छवि के चारों ओर एक ठोस रंग, पारदर्शी, या धुँधली पृष्ठभूमि जोड़कर उसे किसी लक्ष्य aspect ratio तक pad करें। सोशल मीडिया या प्रिंट के लिए बिना क्रॉप किए छवियों को निश्चित aspect ratios में फ़िट करने के लिए उपयोगी।
## API Endpoint {#api-endpoint}
`POST /api/v1/tools/image/image-pad`
एक image फ़ाइल और एक JSON `settings` फ़ील्ड के साथ multipart form data स्वीकार करता है।
## Parameters {#parameters}
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| target | string | नहीं | `"1:1"` | लक्ष्य aspect ratio: `16:9`, `9:16`, `1:1`, `4:3`, `3:4`, या `custom` |
| ratioW | integer | नहीं | `1` | कस्टम अनुपात चौड़ाई (1-100, जब target `custom` हो तब उपयोग होती है) |
| ratioH | integer | नहीं | `1` | कस्टम अनुपात ऊँचाई (1-100, जब target `custom` हो तब उपयोग होती है) |
| background | string | नहीं | `"color"` | Background मोड: `color`, `transparent`, या `blur` |
| color | string | नहीं | `"#ffffff"` | Background hex रंग (जब background `color` हो) |
| padding | integer | नहीं | `0` | canvas के प्रतिशत के रूप में अतिरिक्त padding (0-50) |
## Example Request {#example-request}
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/image-pad \
-H "Authorization: Bearer si_your-api-key" \
-F "file=@photo.jpg" \
-F 'settings={"target": "16:9", "background": "blur", "padding": 5}'
```
## Example Response {#example-response}
```json
{
"jobId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"downloadUrl": "/api/v1/download/a1b2c3d4-e5f6-7890-abcd-ef1234567890/photo.jpg",
"originalSize": 2450000,
"processedSize": 3100000
}
```
## Notes {#notes}
- `blur` background मोड pad भराव के रूप में मूल छवि की एक धुँधली प्रति बनाता है, जिससे दृश्य रूप से सुसंगत परिणाम मिलता है।
- `transparent` background का उपयोग करते समय, alpha को संरक्षित करने के लिए आउटपुट को PNG में बदल दिया जाता है।
- जब तक पारदर्शिता शामिल न हो, आउटपुट प्रारूप इनपुट प्रारूप से मेल खाता है। HEIC, RAW, PSD और SVG इनपुट प्रसंस्करण से पहले स्वचालित रूप से डिकोड किए जाते हैं।
- मनमाने aspect ratios के लिए `target` को `custom` पर सेट करें और `ratioW` तथा `ratioH` प्रदान करें (जैसे, 3:2 के लिए `ratioW: 3, ratioH: 2`)।
@@ -0,0 +1,96 @@
---
description: "HTML, CSS और अन्य में एम्बेड करने के लिए छवियों को base64 data URIs में बदलें।"
i18n_source_hash: ba4b8f3b4ece
i18n_provenance: human
i18n_output_hash: d18d54591439
---
# Image to Base64 {#image-to-base64}
एक या अधिक छवियों को base64-एन्कोडेड स्ट्रिंग और data URIs में बदलें। वैकल्पिक प्रारूप रूपांतरण, गुणवत्ता नियंत्रण और आकार बदलने का समर्थन करता है। छवियों को सीधे HTML, CSS, JSON या ईमेल टेम्पलेट्स में एम्बेड करने के लिए उपयोगी।
## API Endpoint {#api-endpoint}
`POST /api/v1/tools/image/image-to-base64`
एक या अधिक image फ़ाइलों और एक वैकल्पिक JSON `settings` फ़ील्ड के साथ multipart form data स्वीकार करता है।
## Parameters {#parameters}
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| outputFormat | string | नहीं | `"original"` | एन्कोडिंग से पहले बदलें: `original`, `jpeg`, `png`, `webp`, `avif`, `jxl` |
| quality | number | नहीं | `80` | lossy प्रारूपों के लिए आउटपुट गुणवत्ता (1 से 100) |
| maxWidth | number | नहीं | `0` | अधिकतम चौड़ाई पिक्सेल में (0 = कोई आकार परिवर्तन नहीं, बड़ा नहीं करेगा) |
| maxHeight | number | नहीं | `0` | अधिकतम ऊँचाई पिक्सेल में (0 = कोई आकार परिवर्तन नहीं, बड़ा नहीं करेगा) |
## Example Request {#example-request}
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/image-to-base64 \
-H "Authorization: Bearer si_your-api-key" \
-F "file=@icon.png" \
-F 'settings={"outputFormat": "webp", "quality": 80, "maxWidth": 200}'
```
एकाधिक फ़ाइलें:
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/image-to-base64 \
-H "Authorization: Bearer si_your-api-key" \
-F "file=@icon1.png" \
-F "file=@icon2.png" \
-F "file=@icon3.png" \
-F 'settings={"outputFormat": "original"}'
```
## Example Response {#example-response}
```json
{
"results": [
{
"filename": "icon.png",
"mimeType": "image/webp",
"width": 200,
"height": 200,
"originalSize": 45000,
"encodedSize": 28800,
"overheadPercent": -36.0,
"base64": "UklGRlYAAABXRUJQ...",
"dataUri": "data:image/webp;base64,UklGRlYAAABXRUJQ..."
}
],
"errors": []
}
```
## Response Fields {#response-fields}
| Field | Type | Description |
|-------|------|-------------|
| results | array | सफलतापूर्वक बदली गई छवियाँ |
| errors | array | ऐसी छवियाँ जो संसाधित नहीं हो सकीं (फ़ाइलनाम और त्रुटि संदेश के साथ) |
### Result Object {#result-object}
| Field | Type | Description |
|-------|------|-------------|
| filename | string | मूल फ़ाइलनाम |
| mimeType | string | एन्कोडेड आउटपुट का MIME प्रकार |
| width | number | अंतिम चौड़ाई पिक्सेल में (किसी भी आकार परिवर्तन के बाद) |
| height | number | अंतिम ऊँचाई पिक्सेल में (किसी भी आकार परिवर्तन के बाद) |
| originalSize | number | मूल फ़ाइल आकार बाइट में |
| encodedSize | number | base64 स्ट्रिंग का आकार बाइट में |
| overheadPercent | number | मूल की तुलना में प्रतिशत आकार अंतर (धनात्मक = बड़ा, ऋणात्मक = छोटा) |
| base64 | string | कच्चा base64-एन्कोडेड छवि डेटा |
| dataUri | string | `src` विशेषताओं में उपयोग के लिए तैयार पूर्ण data URI |
## Notes {#notes}
- Base64 एन्कोडिंग आमतौर पर binary फ़ाइल की तुलना में आकार में लगभग 33% वृद्धि करती है। `overheadPercent` फ़ील्ड वास्तविक अंतर दिखाता है।
- जब `outputFormat` `"original"` हो, तो HEIC/HEIF फ़ाइलें JPEG में बदल दी जाती हैं (क्योंकि browser data URIs में HEIC प्रदर्शित नहीं कर सकते)।
- `maxWidth` और `maxHeight` विकल्प `withoutEnlargement` के साथ `fit: inside` का उपयोग करके आकार बदलते हैं, इसलिए निर्दिष्ट आयामों से छोटी छवियाँ बड़ी नहीं की जातीं।
- एक ही अनुरोध में एकाधिक फ़ाइलें संसाधित की जा सकती हैं। प्रत्येक फ़ाइल स्वतंत्र रूप से संसाधित होती है, और विफलताएँ अन्य फ़ाइलों को सफल होने से नहीं रोकतीं।
- SVG फ़ाइलें बिना पुनः-एन्कोडिंग के `image/svg+xml` के रूप में पास कर दी जाती हैं (जब तक कि प्रारूप रूपांतरण का अनुरोध न किया गया हो)।
- यह एक केवल-पढ़ने योग्य endpoint है। यह कोई डाउनलोड करने योग्य फ़ाइल या `jobId` उत्पन्न नहीं करता। base64 डेटा सीधे प्रतिक्रिया body में लौटाया जाता है।
+119
View File
@@ -0,0 +1,119 @@
---
description: "page size, orientation और लक्ष्य फ़ाइल आकार विकल्पों के साथ एक या अधिक छवियों को एक PDF दस्तावेज़ में संयोजित करें।"
i18n_source_hash: f659c7e7f56b
i18n_provenance: human
i18n_output_hash: 4d0942ce13f6
---
# Image to PDF {#image-to-pdf}
एक या अधिक छवियों को एक PDF दस्तावेज़ में संयोजित करें। कई page size, orientation, margins और गुणवत्ता समायोजन के माध्यम से वैकल्पिक फ़ाइल आकार लक्ष्यीकरण का समर्थन करता है।
## API Endpoint {#api-endpoint}
`POST /api/v1/tools/image/image-to-pdf`
एक या अधिक image फ़ाइलों और एक JSON `settings` फ़ील्ड के साथ multipart form data स्वीकार करता है।
## Parameters {#parameters}
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| pageSize | string | नहीं | `"A4"` | Page size: `A4`, `Letter`, `A3`, `A5` |
| orientation | string | नहीं | `"portrait"` | Page orientation: `portrait` या `landscape` |
| margin | number | नहीं | `20` | Page margin points में (0-500) |
| targetSize | object | नहीं | - | लक्ष्य फ़ाइल आकार बाधा (नीचे देखें) |
| collate | boolean | नहीं | `true` | सभी छवियों को एक PDF में संयोजित करें। यदि `false`, तो प्रति छवि एक PDF बनाता है। |
### Target Size Object {#target-size-object}
| Field | Type | Required | Description |
|-------|------|----------|-------------|
| value | number | हाँ | लक्ष्य आकार मान |
| unit | string | हाँ | इकाई: `KB` या `MB` |
न्यूनतम लक्ष्य आकार 50 KB है।
## Example Request {#example-request}
बुनियादी multi-image PDF:
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/image-to-pdf \
-H "Authorization: Bearer si_your-api-key" \
-F "file=@page1.jpg" \
-F "file=@page2.jpg" \
-F "file=@page3.jpg" \
-F 'settings={"pageSize": "A4", "orientation": "portrait", "margin": 20}'
```
फ़ाइल आकार लक्ष्य के साथ:
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/image-to-pdf \
-H "Authorization: Bearer si_your-api-key" \
-F "file=@scan1.jpg" \
-F "file=@scan2.jpg" \
-F 'settings={"pageSize": "Letter", "targetSize": {"value": 2, "unit": "MB"}}'
```
प्रति छवि एक PDF:
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/image-to-pdf \
-H "Authorization: Bearer si_your-api-key" \
-F "file=@photo1.jpg" \
-F "file=@photo2.jpg" \
-F 'settings={"collate": false}'
```
## Example Response (Collated) {#example-response-collated}
```json
{
"jobId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"downloadUrl": "/api/v1/download/a1b2c3d4-e5f6-7890-abcd-ef1234567890/images.pdf",
"originalSize": 5000000,
"processedSize": 1200000,
"pages": 3
}
```
## Example Response (Non-Collated) {#example-response-non-collated}
```json
{
"jobId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"downloadUrl": "/api/v1/download/a1b2c3d4-e5f6-7890-abcd-ef1234567890/images.zip",
"originalSize": 5000000,
"processedSize": 2400000,
"pages": 2,
"collated": false
}
```
## Example Response (With Target Size) {#example-response-with-target-size}
```json
{
"jobId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"downloadUrl": "/api/v1/download/a1b2c3d4-e5f6-7890-abcd-ef1234567890/images.pdf",
"originalSize": 10000000,
"processedSize": 2000000,
"pages": 5,
"compression": {
"targetRequested": 2097152,
"targetMet": true,
"jpegQuality": 72
}
}
```
## Notes {#notes}
- छवियाँ पृष्ठ पर केंद्रित होती हैं और aspect ratio संरक्षित करते हुए margins के भीतर फ़िट होने के लिए स्केल की जाती हैं। छवियाँ कभी बड़ी नहीं की जातीं।
- जब `collate` `false` हो, तो प्रत्येक छवि एक अलग PDF फ़ाइल बन जाती है, और डाउनलोड एक ZIP archive होता है जिसमें सभी PDFs होते हैं।
- लक्ष्य आकार सुविधा बजट के भीतर फ़िट होने वाली सर्वोत्तम गुणवत्ता खोजने के लिए JPEG गुणवत्ता स्तरों (10-95) पर पुनरावृत्त binary search का उपयोग करती है।
- पारदर्शी छवियों को PDF में एम्बेड करने से पहले सफ़ेद में फ़्लैट कर दिया जाता है।
- समर्थित इनपुट प्रारूप: JPEG, PNG, WebP, AVIF, TIFF, GIF, HEIC, RAW, PSD, SVG और अन्य।
- एम्बेड करने से पहले EXIF orientation स्वतः लागू किया जाता है।
+92
View File
@@ -0,0 +1,92 @@
---
description: "विस्तृत छवि मेटाडेटा, गुण और प्रति-चैनल histogram आँकड़े देखें।"
i18n_source_hash: 8a0f7a0b0153
i18n_provenance: human
i18n_output_hash: f5ff7689f5c8
---
# Image Info {#image-info}
केवल-पढ़ने योग्य विश्लेषण टूल जो आयाम, प्रारूप, color space, EXIF/ICC/XMP उपस्थिति और प्रति-चैनल histogram आँकड़ों सहित व्यापक छवि मेटाडेटा लौटाता है। कोई संसाधित आउटपुट फ़ाइल उत्पन्न नहीं करता।
## API Endpoint {#api-endpoint}
`POST /api/v1/tools/image/info`
एक image फ़ाइल के साथ multipart form data स्वीकार करता है। किसी settings फ़ील्ड की आवश्यकता नहीं है।
## Parameters {#parameters}
इस टूल में कोई कॉन्फ़िगर करने योग्य parameter नहीं है। बस image फ़ाइल अपलोड करें।
| Field | Type | Required | Description |
|-------|------|----------|-------------|
| file | file | हाँ | विश्लेषण करने के लिए छवि |
## Example Request {#example-request}
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/info \
-H "Authorization: Bearer si_your-api-key" \
-F "file=@photo.jpg"
```
## Example Response {#example-response}
```json
{
"filename": "photo.jpg",
"fileSize": 2450000,
"width": 4032,
"height": 3024,
"format": "jpeg",
"channels": 3,
"hasAlpha": false,
"colorSpace": "srgb",
"density": 72,
"isProgressive": false,
"orientation": 1,
"hasProfile": true,
"hasExif": true,
"hasIcc": true,
"hasXmp": false,
"bitDepth": "8",
"pages": 1,
"histogram": [
{ "channel": "red", "min": 0, "max": 255, "mean": 128.45, "stdev": 52.31 },
{ "channel": "green", "min": 2, "max": 253, "mean": 115.22, "stdev": 48.76 },
{ "channel": "blue", "min": 0, "max": 250, "mean": 102.89, "stdev": 55.14 }
]
}
```
## Response Fields {#response-fields}
| Field | Type | Description |
|-------|------|-------------|
| filename | string | स्वच्छ किया गया फ़ाइलनाम |
| fileSize | number | फ़ाइल आकार बाइट में |
| width | number | छवि चौड़ाई पिक्सेल में |
| height | number | छवि ऊँचाई पिक्सेल में |
| format | string | पहचाना गया प्रारूप (jpeg, png, webp, आदि) |
| channels | number | रंग चैनलों की संख्या |
| hasAlpha | boolean | क्या छवि में alpha चैनल है |
| colorSpace | string | Color space (srgb, cmyk, आदि) |
| density | number या null | DPI/PPI रिज़ॉल्यूशन |
| isProgressive | boolean | क्या JPEG progressive एन्कोडिंग का उपयोग करता है |
| orientation | number या null | EXIF orientation मान (1-8) |
| hasProfile | boolean | क्या कोई ICC profile एम्बेडेड है |
| hasExif | boolean | क्या EXIF मेटाडेटा मौजूद है |
| hasIcc | boolean | क्या कोई ICC color profile मौजूद है |
| hasXmp | boolean | क्या XMP मेटाडेटा मौजूद है |
| bitDepth | string या null | प्रति नमूना बिट्स |
| pages | number | पृष्ठों की संख्या (TIFF, GIF जैसे multi-page प्रारूपों के लिए) |
| histogram | array | प्रति-चैनल आँकड़े (min, max, mean, मानक विचलन) |
## Notes {#notes}
- यह एक केवल-पढ़ने योग्य endpoint है। यह कोई डाउनलोड करने योग्य आउटपुट फ़ाइल या `jobId` उत्पन्न नहीं करता।
- RAW प्रारूप की छवियों (DNG, CR2, NEF, ARW, आदि) के लिए, ExifTool का उपयोग वास्तविक सेंसर आयाम और मेटाडेटा फ़्लैग निकालने के लिए किया जाता है जिन्हें Sharp सीधे नहीं पढ़ सकता।
- HEIC/HEIF फ़ाइलें पिक्सेल आँकड़े निकालने के लिए आंतरिक रूप से PNG में डिकोड की जाती हैं, क्योंकि Sharp HEVC पिक्सेल को डिकोड नहीं कर सकता।
- histogram प्रति चैनल min/max/mean/stdev प्रदान करता है, पूर्ण 256-bin वितरण नहीं।
- `density` फ़ील्ड एम्बेडेड DPI मेटाडेटा को दर्शाता है, यदि मौजूद हो।
@@ -0,0 +1,62 @@
---
description: "base64 data URI के साथ एक छोटा low-quality image placeholder जनरेट करें।"
i18n_source_hash: f8a27c8021f5
i18n_provenance: human
i18n_output_hash: c12b5df79b78
---
# LQIP Placeholder {#lqip-placeholder}
किसी स्रोत छवि से एक छोटा low-quality image placeholder (LQIP) जनरेट करें। तत्काल एम्बेडिंग के लिए एक छोटी placeholder फ़ाइल के साथ एक base64 data URI, उपयोग के लिए तैयार HTML `<img>` टैग और CSS `background-image` स्निपेट लौटाता है।
## API Endpoint {#api-endpoint}
`POST /api/v1/tools/image/lqip-placeholder`
एक image फ़ाइल और एक JSON `settings` फ़ील्ड के साथ multipart form data स्वीकार करता है।
## Parameters {#parameters}
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| width | integer | नहीं | `16` | लक्ष्य चौड़ाई पिक्सेल में (4-64) |
| blur | number | नहीं | `2` | blur रणनीति के लिए Blur त्रिज्या (0-20) |
| strategy | string | नहीं | `"blur"` | Placeholder रणनीति: `blur`, `pixelate`, या `solid` |
| format | string | नहीं | `"webp"` | आउटपुट प्रारूप: `webp`, `png`, या `jpeg` |
| quality | integer | नहीं | `50` | आउटपुट गुणवत्ता (1-100) |
## Example Request {#example-request}
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/lqip-placeholder \
-H "Authorization: Bearer si_your-api-key" \
-F "file=@photo.jpg" \
-F 'settings={"width": 20, "strategy": "blur", "format": "webp"}'
```
## Example Response {#example-response}
```json
{
"jobId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"downloadUrl": "/api/v1/download/a1b2c3d4-e5f6-7890-abcd-ef1234567890/photo.webp",
"originalSize": 2450000,
"processedSize": 280,
"dataUri": "data:image/webp;base64,UklGR...",
"width": 20,
"height": 13,
"bytes": 280,
"strategy": "blur",
"html": "<img src=\"data:image/webp;base64,UklGR...\" />",
"css": "background-image:url('data:image/webp;base64,UklGR...');background-size:cover;background-position:center;"
}
```
## Notes {#notes}
- `dataUri` फ़ील्ड में पूर्ण data URI होता है, जो किसी अतिरिक्त अनुरोध के बिना `src` विशेषताओं या CSS में उपयोग के लिए तैयार है।
- `html` और `css` फ़ील्ड सामान्य उपयोग मामलों के लिए कॉपी-पेस्ट स्निपेट प्रदान करते हैं।
- `blur` रणनीति एक नरम, धुँधला थंबनेल उत्पन्न करती है। `pixelate` रणनीति एक ब्लॉकी मोज़ेक बनाती है। `solid` रणनीति एक एकल औसत रंग लौटाती है।
- सामान्य placeholder आकार 200-500 बाइट होते हैं, जो उन्हें सीधे HTML में इनलाइन करने के लिए उपयुक्त बनाता है।
- स्रोत छवि के aspect ratio को संरक्षित करने के लिए ऊँचाई स्वचालित रूप से गणना की जाती है।
- HEIC, RAW, PSD और SVG इनपुट प्रसंस्करण से पहले स्वचालित रूप से डिकोड किए जाते हैं।
@@ -0,0 +1,92 @@
---
description: "टेम्पलेट्स या कस्टम इमेज, स्टाइल किए गए टेक्स्ट बॉक्स और फ़ॉन्ट विकल्पों के साथ मीम बनाएँ।"
i18n_source_hash: 0a4970112ca6
i18n_provenance: human
i18n_output_hash: 08b1cfca4220
---
# Meme Generator {#meme-generator}
बिल्ट-इन टेम्पलेट्स या कस्टम इमेज का उपयोग करके मीम बनाएँ। क्लासिक मीम स्टाइलिंग (बोल्ड, आउटलाइन किया हुआ टेक्स्ट), कई लेआउट प्रीसेट और फ़ॉन्ट विकल्पों के साथ टेक्स्ट जोड़ें।
## API Endpoint {#api-endpoint}
`POST /api/v1/tools/image/meme-generator`
इनमें से किसी को स्वीकार करता है:
- **Multipart form data** एक इमेज फ़ाइल और एक JSON `settings` फ़ील्ड के साथ (कस्टम इमेज मोड)
- **JSON body** एक `templateId` के साथ (टेम्पलेट मोड, किसी फ़ाइल अपलोड की आवश्यकता नहीं)
## Parameters {#parameters}
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| templateId | string | No | - | बिल्ट-इन मीम टेम्पलेट ID। यदि प्रदान किया गया हो, तो किसी इमेज अपलोड की आवश्यकता नहीं |
| textLayout | string | No | `"top-bottom"` | टेक्स्ट बॉक्स लेआउट: `top-bottom`, `top-only`, `bottom-only`, `center`, `side-by-side` |
| textBoxes | array | No | `[]` | `id` और `text` फ़ील्ड वाले टेक्स्ट बॉक्स ऑब्जेक्ट्स की सरणी |
| fontFamily | string | No | `"anton"` | फ़ॉन्ट: `anton`, `arial-black`, `comic-sans`, `montserrat`, `bebas-neue`, `permanent-marker`, `roboto` |
| fontSize | number | No | auto | फ़ॉन्ट का आकार पिक्सेल में (8 से 200)। छोड़ दिए जाने पर स्वतः गणना की जाती है |
| textColor | string | No | `"#ffffff"` | टेक्स्ट फ़िल रंग |
| strokeColor | string | No | `"#000000"` | टेक्स्ट स्ट्रोक/आउटलाइन रंग |
| textAlign | string | No | `"center"` | टेक्स्ट संरेखण: `left`, `center`, `right` |
| allCaps | boolean | No | `true` | टेक्स्ट को अपरकेस में बदलें |
### Text Boxes {#text-boxes}
`textBoxes` सरणी में प्रत्येक प्रविष्टि में होना चाहिए:
| Field | Type | Description |
|-------|------|-------------|
| id | string | लेआउट से मेल खाने वाला बॉक्स पहचानकर्ता (उदा., `"top"`, `"bottom"`, `"left"`, `"right"`, `"center"`) |
| text | string | प्रदर्शित करने के लिए मीम टेक्स्ट |
### Text Layout Box IDs {#text-layout-box-ids}
| Layout | Available Box IDs |
|--------|-------------------|
| `top-bottom` | `top`, `bottom` |
| `top-only` | `top` |
| `bottom-only` | `bottom` |
| `center` | `center` |
| `side-by-side` | `left`, `right` |
## Example Request {#example-request}
टॉप और बॉटम टेक्स्ट के साथ कस्टम इमेज:
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/meme-generator \
-H "Authorization: Bearer si_your-api-key" \
-F "file=@photo.jpg" \
-F 'settings={"textLayout": "top-bottom", "textBoxes": [{"id": "top", "text": "When the code works"}, {"id": "bottom", "text": "On the first try"}], "fontFamily": "anton", "allCaps": true}'
```
बिल्ट-इन टेम्पलेट का उपयोग करते हुए (JSON body, कोई फ़ाइल अपलोड नहीं):
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/meme-generator \
-H "Authorization: Bearer si_your-api-key" \
-H "Content-Type: application/json" \
-d '{"templateId": "drake", "textBoxes": [{"id": "top", "text": "Manual testing"}, {"id": "bottom", "text": "Automated tests"}]}'
```
## Example Response {#example-response}
```json
{
"jobId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"downloadUrl": "/api/v1/download/a1b2c3d4-e5f6-7890-abcd-ef1234567890/meme-drake.png",
"originalSize": 450000,
"processedSize": 520000
}
```
## Notes {#notes}
- या तो `templateId` या एक अपलोड की गई इमेज फ़ाइल आवश्यक है। दोनों प्रदान करने पर टेम्पलेट का उपयोग होता है।
- टेम्पलेट्स अपनी स्वयं की टेक्स्ट बॉक्स स्थितियाँ परिभाषित करते हैं; टेम्पलेट्स का उपयोग करते समय `textLayout` पैरामीटर को अनदेखा कर दिया जाता है।
- क्लासिक मीम लुक के लिए टेक्स्ट को स्ट्रोक आउटलाइन के साथ SVG के रूप में रेंडर किया जाता है।
- यदि स्पष्ट रूप से सेट न किया गया हो, तो फ़ॉन्ट का आकार टेक्स्ट बॉक्स में फ़िट करने के लिए स्वतः गणना किया जाता है।
- खाली टेक्स्ट बॉक्स छोड़ दिए जाते हैं (यदि सभी बॉक्स खाली हों तो कोई रेंडरिंग नहीं होती)।
- टेम्पलेट्स का उपयोग करते समय आउटपुट फ़ाइल नाम में टेम्पलेट ID शामिल होता है (उदा., `meme-drake.png`)।
- HEIC, RAW, PSD और SVG इनपुट प्रोसेसिंग से पहले स्वतः डिकोड किए जाते हैं।
+79
View File
@@ -0,0 +1,79 @@
---
description: "मल्टी-टियर गुणवत्ता विकल्पों के साथ AI-संचालित शोर और ग्रेन हटाना।"
i18n_source_hash: f0dfc876e0e0
i18n_provenance: human
i18n_output_hash: f92fccc3c770
---
# Noise Removal {#noise-removal}
Python sidecar (SCUNet मॉडल) का उपयोग करते हुए, मल्टी-टियर गुणवत्ता विकल्पों के साथ AI-संचालित शोर और ग्रेन हटाना।
## API Endpoint {#api-endpoint}
`POST /api/v1/tools/image/noise-removal`
**Processing:** असिंक्रोनस (202 लौटाता है, SSE के माध्यम से स्थिति के लिए `/api/v1/jobs/{jobId}/progress` पोल करें)
**Model bundle:** `upscale-enhance` (5-6 GB)
## Parameters {#parameters}
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| file | file | Yes | - | इमेज फ़ाइल (multipart) |
| tier | string | No | `"balanced"` | गुणवत्ता टियर: `quick`, `balanced`, `quality`, `maximum` |
| strength | number | No | `50` | डिनॉइज़िंग की तीव्रता (0-100) |
| detailPreservation | number | No | `50` | कितना विवरण संरक्षित करना है (0-100)। उच्च मान अधिक टेक्स्चर बनाए रखते हैं |
| colorNoise | number | No | `30` | रंग शोर घटाने की तीव्रता (0-100) |
| format | string | No | `"original"` | आउटपुट प्रारूप: `original`, `png`, `jpeg`, `webp`, `avif`, `jxl` |
| quality | number | No | `90` | आउटपुट एन्कोडिंग गुणवत्ता (1-100) |
## Example Request {#example-request}
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/noise-removal \
-F "file=@noisy-photo.jpg" \
-F 'settings={"tier":"quality","strength":60,"detailPreservation":70,"colorNoise":40}'
```
## Response {#response}
### Initial Response (202 Accepted) {#initial-response-202-accepted}
```json
{
"jobId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"async": true
}
```
### Progress (SSE at `/api/v1/jobs/{jobId}/progress`) {#progress-sse-at-api-v1-jobs-jobid-progress}
```
event: progress
data: {"phase":"processing","stage":"Denoising...","percent":65}
```
### Final Result (via SSE) {#final-result-via-sse}
```json
{
"phase": "complete",
"percent": 100,
"result": {
"jobId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"downloadUrl": "/api/v1/download/{jobId}/noisy-photo_denoised.jpg",
"originalSize": 500000,
"processedSize": 380000
}
}
```
## Notes {#notes}
- `upscale-enhance` मॉडल बंडल का इंस्टॉल होना आवश्यक है (5-6 GB)।
- गुणवत्ता टियर गति और गुणवत्ता के बीच अदला-बदली करते हैं: `quick` बुनियादी डिनॉइज़िंग के साथ सबसे तेज़ है, `maximum` सबसे गहन मल्टी-पास दृष्टिकोण का उपयोग करता है।
- टेक्स्चर वाले विषयों (कपड़ा, बाल, पत्ते) के लिए `detailPreservation` पैरामीटर महत्वपूर्ण है। उच्च मान डिनॉइज़र को महीन विवरण को चिकना करके हटाने से रोकते हैं।
- जब `format` को `"original"` पर सेट किया जाता है, तो आउटपुट प्रारूप इनपुट फ़ाइल प्रारूप से मेल खाता है।
- स्वचालित डिकोडिंग के माध्यम से HEIC/HEIF, RAW, TGA, PSD, EXR और HDR इनपुट प्रारूपों का समर्थन करता है।
+65
View File
@@ -0,0 +1,65 @@
---
description: "AI-संचालित ऑप्टिकल कैरेक्टर रिकग्निशन का उपयोग करके इमेज से टेक्स्ट निकालें।"
i18n_source_hash: 3d85d423b82c
i18n_provenance: human
i18n_output_hash: 47b6f369cfc3
---
# OCR / Text Extraction {#ocr-text-extraction}
AI-संचालित ऑप्टिकल कैरेक्टर रिकग्निशन का उपयोग करके इमेज से टेक्स्ट निकालें। कई भाषाओं और गुणवत्ता टियर का समर्थन करता है।
## API Endpoint {#api-endpoint}
`POST /api/v1/tools/image/ocr`
**Processing:** सिंक्रोनस JSON प्रतिक्रिया। यदि `clientJobId` प्रदान किया गया हो, तो प्रगति की जानकारी SSE के माध्यम से भी दी जाती है।
**Model bundle:** `ocr` (5-6 GB)
## Parameters {#parameters}
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| file | file | Yes | - | इमेज फ़ाइल (multipart) |
| quality | string | No | `"balanced"` | गुणवत्ता टियर: `fast` (Tesseract), `balanced` (PaddleOCR v5), `best` (PaddleOCR VL) |
| language | string | No | `"auto"` | भाषा संकेत: `auto`, `en`, `de`, `fr`, `es`, `zh`, `ja`, `ko` |
| enhance | boolean | No | `true` | बेहतर OCR सटीकता के लिए इमेज को पूर्व-प्रोसेस करें |
| engine | string | No | - | अप्रचलित। इसके बजाय `quality` का उपयोग करें। `tesseract` को `fast` से, `paddleocr` को `balanced` से मैप करता है |
## Example Request {#example-request}
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/ocr \
-F "file=@document.png" \
-F 'settings={"quality":"best","language":"en","enhance":true}'
```
## Response (200 OK) {#response-200-ok}
```json
{
"jobId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"filename": "document.png",
"text": "Extracted text content from the image...",
"engine": "paddleocr-vl"
}
```
### Progress (SSE, optional) {#progress-sse-optional}
यदि कोई `clientJobId` फ़ॉर्म फ़ील्ड प्रदान किया गया हो, तो प्रगति इवेंट स्ट्रीम किए जाते हैं:
```
event: progress
data: {"phase":"processing","stage":"Recognizing text...","percent":50}
```
## Notes {#notes}
- `ocr` मॉडल बंडल का इंस्टॉल होना आवश्यक है (5-6 GB)।
- OCR इमेज डाउनलोड URL के बजाय सीधे निकाला गया टेक्स्ट लौटाता है।
- एक फ़ॉलबैक श्रृंखला का उपयोग करता है: यदि कोई उच्च-गुणवत्ता टियर क्रैश हो जाता है (उदा., PaddleOCR segfault), तो यह स्वतः अगले निचले टियर के साथ पुनः प्रयास करता है।
- यदि कोई टियर क्रैश हुए बिना खाली टेक्स्ट लौटाता है, तो यह भी अगले टियर पर फ़ॉलबैक करता है।
- गुणवत्ता टियर इंजनों से मैप होते हैं: `fast` = Tesseract, `balanced` = PaddleOCR v5, `best` = PaddleOCR VL।
- स्वचालित डिकोडिंग के माध्यम से HEIC/HEIF, RAW, TGA, PSD, EXR और HDR इनपुट प्रारूपों का समर्थन करता है।
@@ -0,0 +1,74 @@
---
description: "प्रारूप रूपांतरण, गुणवत्ता नियंत्रण, आकार बदलने और मेटाडेटा हटाने के साथ इमेज को वेब डिलीवरी के लिए ऑप्टिमाइज़ करें।"
i18n_source_hash: c327bbbce768
i18n_provenance: human
i18n_output_hash: 76e1bceb8af9
---
# Optimize for Web {#optimize-for-web}
एक ही चरण में इमेज को वेब डिलीवरी के लिए ऑप्टिमाइज़ करें। प्रारूप रूपांतरण, गुणवत्ता समायोजन, वैकल्पिक आकार बदलना, प्रोग्रेसिव एन्कोडिंग और मेटाडेटा हटाने को संयोजित करता है।
## API Endpoint {#api-endpoint}
`POST /api/v1/tools/image/optimize-for-web`
एक इमेज फ़ाइल और एक JSON `settings` फ़ील्ड के साथ multipart form data स्वीकार करता है।
एक लाइव प्रीव्यू एंडपॉइंट भी `POST /api/v1/tools/image/optimize-for-web/preview` पर उपलब्ध है, जो रीयल-टाइम पैरामीटर ट्यूनिंग के लिए प्रोसेस की गई इमेज को सीधे बाइनरी के रूप में लौटाता है (कोई वर्कस्पेस निर्माण नहीं)।
## Parameters {#parameters}
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| format | string | No | `"webp"` | आउटपुट प्रारूप: `webp`, `jpeg`, `avif`, `png`, `jxl` |
| quality | number | No | `80` | आउटपुट गुणवत्ता (1-100) |
| maxWidth | number | No | - | पिक्सेल में अधिकतम चौड़ाई। यदि इमेज अधिक चौड़ी हो तो उसे डाउनस्केल किया जाता है। |
| maxHeight | number | No | - | पिक्सेल में अधिकतम ऊँचाई। यदि इमेज अधिक ऊँची हो तो उसे डाउनस्केल किया जाता है। |
| progressive | boolean | No | `true` | प्रोग्रेसिव/इंटरलेस्ड एन्कोडिंग सक्षम करें |
| stripMetadata | boolean | No | `true` | EXIF, GPS, ICC और XMP मेटाडेटा हटाएँ |
## Example Request {#example-request}
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/optimize-for-web \
-H "Authorization: Bearer si_your-api-key" \
-F "file=@photo.jpg" \
-F 'settings={"format": "webp", "quality": 75, "maxWidth": 1920}'
```
आक्रामक संपीड़न के साथ AVIF के लिए ऑप्टिमाइज़ करें:
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/optimize-for-web \
-H "Authorization: Bearer si_your-api-key" \
-F "file=@photo.jpg" \
-F 'settings={"format": "avif", "quality": 50, "maxWidth": 1200, "maxHeight": 800}'
```
## Example Response {#example-response}
```json
{
"jobId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"downloadUrl": "/api/v1/download/a1b2c3d4-e5f6-7890-abcd-ef1234567890/photo.webp",
"originalSize": 4500000,
"processedSize": 320000
}
```
### Preview Endpoint Response {#preview-endpoint-response}
प्रीव्यू एंडपॉइंट (`/api/v1/tools/image/optimize-for-web/preview`) सूचनात्मक हेडर के साथ बाइनरी इमेज को सीधे लौटाता है:
- `X-Original-Size` - बाइट्स में मूल फ़ाइल का आकार
- `X-Processed-Size` - बाइट्स में प्रोसेस की गई फ़ाइल का आकार
- `X-Output-Filename` - URL-एन्कोडेड आउटपुट फ़ाइल नाम
## Notes {#notes}
- यह टूल वेब एसेट्स के लिए एक वन-स्टॉप ऑप्टिमाइज़ेशन पाइपलाइन के रूप में डिज़ाइन किया गया है। यह एक ही पास में प्रारूप रूपांतरण, गुणवत्ता ट्यूनिंग, अधिकतम आयाम सीमा और मेटाडेटा हटाना संभालता है।
- चुने गए प्रारूप से मेल खाने के लिए आउटपुट फ़ाइल नाम एक्सटेंशन को अपडेट किया जाता है।
- JXL (JPEG XL) एन्कोडिंग एक विशेष CLI एन्कोडर का उपयोग करती है। इमेज को पहले PNG के रूप में प्रोसेस किया जाता है, फिर JXL में एन्कोड किया जाता है।
- प्रोग्रेसिव एन्कोडिंग ब्राउज़र को पूर्ण इमेज लोड होने से पहले एक निम्न-गुणवत्ता प्रीव्यू रेंडर करने की अनुमति देकर JPEG और PNG के लिए अनुभूत लोड समय में सुधार करती है।
- प्रीव्यू एंडपॉइंट हल्का है (कोई वर्कस्पेस/जॉब निर्माण नहीं) और फ्रंटएंड के लाइव पैरामीटर ट्यूनिंग UI के लिए अभिप्रेत है।
+173
View File
@@ -0,0 +1,173 @@
---
description: "फेस डिटेक्शन, बैकग्राउंड हटाने और प्रिंट शीट टाइलिंग के साथ AI-संचालित पासपोर्ट और ID फ़ोटो जनरेटर।"
i18n_source_hash: d4b4f4ced988
i18n_provenance: human
i18n_output_hash: eb0abd3dfc5d
---
# Passport Photo {#passport-photo}
AI-संचालित पासपोर्ट और ID फ़ोटो जनरेटर। दो-चरण वर्कफ़्लो: विश्लेषण (फेस डिटेक्शन + बैकग्राउंड हटाना) फिर जनरेट (क्रॉप, आकार बदलना और प्रिंटिंग के लिए टाइलिंग)।
## API Endpoints {#api-endpoints}
यह टूल विश्लेषण और जनरेशन के लिए अलग-अलग एंडपॉइंट्स के साथ दो-चरण प्रवाह का उपयोग करता है।
**Model bundles:** `background-removal` और `face-detection`
---
### Phase 1: Analyze {#phase-1-analyze}
`POST /api/v1/tools/image/passport-photo/analyze`
फेस लैंडमार्क का पता लगाता है और बैकग्राउंड हटाता है। फ्रंटएंड को क्रॉप प्रीव्यू प्रदर्शित करने के लिए लैंडमार्क डेटा और एक प्रीव्यू लौटाता है।
#### Parameters {#parameters}
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| file | file | Yes | - | इमेज फ़ाइल (multipart) |
| clientJobId | string | No | - | SSE के माध्यम से प्रगति ट्रैकिंग के लिए वैकल्पिक जॉब ID |
#### Example Request {#example-request}
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/passport-photo/analyze \
-F "file=@headshot.jpg"
```
#### Response (200 OK) {#response-200-ok}
```json
{
"jobId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"filename": "headshot.jpg",
"preview": "<base64-encoded PNG>",
"previewWidth": 800,
"previewHeight": 1067,
"landmarks": {
"leftEye": { "x": 0.42, "y": 0.35 },
"rightEye": { "x": 0.58, "y": 0.35 },
"eyeCenter": { "x": 0.50, "y": 0.35 },
"chin": { "x": 0.50, "y": 0.65 },
"forehead": { "x": 0.50, "y": 0.22 },
"crown": { "x": 0.50, "y": 0.18 },
"nose": { "x": 0.50, "y": 0.48 },
"faceCenterX": 0.50
},
"imageWidth": 2400,
"imageHeight": 3200
}
```
#### Progress (SSE, optional) {#progress-sse-optional}
यदि `clientJobId` प्रदान किया गया हो, तो प्रगति स्ट्रीम की जाती है (फेस डिटेक्शन के लिए 0-30%, बैकग्राउंड हटाने के लिए 30-95%)।
#### Error: No Face Detected (422) {#error-no-face-detected-422}
```json
{
"error": "No face detected",
"details": "Could not detect a face in the uploaded image. Please upload a clear, front-facing photo with good lighting."
}
```
---
### Phase 2: Generate {#phase-2-generate}
`POST /api/v1/tools/image/passport-photo/generate`
फ़ोटो को क्रॉप, आकार बदलता है और वैकल्पिक रूप से एक प्रिंट शीट पर टाइल करता है। Phase 1 से कैश की गई इमेज का उपयोग करता है (कोई AI पुनः-रन नहीं)।
#### Parameters (JSON body) {#parameters-json-body}
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| jobId | string | Yes | - | Phase 1 से जॉब ID |
| filename | string | Yes | - | Phase 1 से मूल फ़ाइल नाम |
| countryCode | string | Yes | - | पासपोर्ट स्पेक के लिए देश कोड (उदा., `US`, `GB`, `IN`) |
| documentType | string | No | `"passport"` | दस्तावेज़ प्रकार (देश स्पेक से) |
| bgColor | string | No | `"#FFFFFF"` | बैकग्राउंड रंग hex |
| printLayout | string | No | `"none"` | प्रिंट पेपर लेआउट: `none`, `4x6`, `a4` |
| maxFileSizeKb | number | No | `0` | KB में अधिकतम फ़ाइल आकार सीमा (0 = कोई सीमा नहीं) |
| dpi | number | No | `300` | आउटपुट DPI (72-1200) |
| customWidthMm | number | No | - | mm में कस्टम फ़ोटो चौड़ाई (देश स्पेक को ओवरराइड करता है) |
| customHeightMm | number | No | - | mm में कस्टम फ़ोटो ऊँचाई (देश स्पेक को ओवरराइड करता है) |
| zoom | number | No | `1` | ज़ूम फ़ैक्टर (0.5-3)। 1 से अधिक मान अधिक कसकर क्रॉप करते हैं |
| adjustX | number | No | `0` | क्षैतिज स्थिति समायोजन |
| adjustY | number | No | `0` | ऊर्ध्वाधर स्थिति समायोजन |
| landmarks | object | Yes | - | Phase 1 प्रतिक्रिया से लैंडमार्क ऑब्जेक्ट |
| imageWidth | number | Yes | - | Phase 1 प्रतिक्रिया से इमेज चौड़ाई |
| imageHeight | number | Yes | - | Phase 1 प्रतिक्रिया से इमेज ऊँचाई |
#### Example Request {#example-request-1}
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/passport-photo/generate \
-H "Content-Type: application/json" \
-d '{
"jobId": "a1b2c3d4-...",
"filename": "headshot.jpg",
"countryCode": "US",
"documentType": "passport",
"bgColor": "#FFFFFF",
"printLayout": "4x6",
"dpi": 300,
"zoom": 1,
"adjustX": 0,
"adjustY": 0,
"landmarks": { "leftEye": {"x":0.42,"y":0.35}, "rightEye": {"x":0.58,"y":0.35}, "eyeCenter": {"x":0.50,"y":0.35}, "chin": {"x":0.50,"y":0.65}, "forehead": {"x":0.50,"y":0.22}, "crown": {"x":0.50,"y":0.18}, "nose": {"x":0.50,"y":0.48}, "faceCenterX": 0.50 },
"imageWidth": 2400,
"imageHeight": 3200
}'
```
#### Response (200 OK) {#response-200-ok-1}
```json
{
"jobId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"downloadUrl": "/api/v1/download/{jobId}/headshot_passport.jpg",
"dimensions": {
"widthMm": 51,
"heightMm": 51,
"widthPx": 602,
"heightPx": 602,
"dpi": 300
},
"spec": {
"country": "United States",
"countryCode": "US",
"documentType": "passport",
"documentLabel": "Passport"
},
"printDownloadUrl": "/api/v1/download/{jobId}/headshot_passport_print_4x6.jpg"
}
```
---
### Base Route {#base-route}
`POST /api/v1/tools/image/passport-photo`
सही सब-एंडपॉइंट का उपयोग करने के लिए मार्गदर्शन लौटाता है।
```json
{
"error": "Use /api/v1/tools/image/passport-photo/analyze or /generate"
}
```
## Notes {#notes}
- `background-removal` और `face-detection` मॉडल बंडल का इंस्टॉल होना आवश्यक है।
- Phase 1 AI चलाता है (फेस लैंडमार्क + बैकग्राउंड हटाना) और परिणामों को कैश करता है। Phase 2 शुद्ध Sharp इमेज हेरफेर है (तेज़, कोई AI आवश्यक नहीं)।
- लैंडमार्क सामान्यीकृत निर्देशांक के रूप में लौटाए जाते हैं (इमेज आयामों के सापेक्ष 0-1 रेंज)।
- विश्लेषण प्रतिक्रिया में `preview` फ़ील्ड तेज़ प्रदर्शन के लिए एक base64-एन्कोडेड PNG (अधिकतम 800px चौड़ा) है।
- देश स्पेक में आधिकारिक पासपोर्ट फ़ोटो आवश्यकताओं के आधार पर दस्तावेज़ आयाम, सिर की ऊँचाई अनुपात और आँख-रेखा स्थिति शामिल है।
- `printLayout` विकल्प फ़ोटो के बीच 2mm गटर के साथ 4x6\" या A4 पेपर पर एक टाइल की गई शीट जनरेट करता है।
- जब `maxFileSizeKb` सेट किया जाता है, तो आउटपुट को आकार सीमा के भीतर फ़िट करने के लिए पुनरावृत्त रूप से संपीड़ित किया जाता है।
+69
View File
@@ -0,0 +1,69 @@
---
description: "पूरी इमेज या किसी विशिष्ट क्षेत्र पर पिक्सेलेशन प्रभाव लागू करें।"
i18n_source_hash: a3ad29841f7b
i18n_provenance: human
i18n_output_hash: 068c54ad3f49
---
# Pixelate {#pixelate}
एक पूरी इमेज या किसी विशिष्ट आयताकार क्षेत्र पर पिक्सेलेशन प्रभाव लागू करें। चेहरे, लाइसेंस प्लेट, या व्यक्तिगत जानकारी जैसी संवेदनशील सामग्री को छिपाने के लिए उपयोगी।
## API Endpoint {#api-endpoint}
`POST /api/v1/tools/image/pixelate`
एक इमेज फ़ाइल और एक JSON `settings` फ़ील्ड के साथ multipart form data स्वीकार करता है।
## Parameters {#parameters}
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| blockSize | integer | No | `12` | पिक्सेल ब्लॉक आकार (2-128); बड़े मान अधिक मोटी पिक्सेलेशन उत्पन्न करते हैं |
| region | object | No | - | पिक्सेलेशन को एक आयत तक सीमित करें (नीचे देखें) |
### Region Object {#region-object}
| Field | Type | Required | Description |
|-------|------|----------|-------------|
| left | integer | Yes | पिक्सेल में बायाँ ऑफ़सेट (>= 0) |
| top | integer | Yes | पिक्सेल में शीर्ष ऑफ़सेट (>= 0) |
| width | integer | Yes | पिक्सेल में क्षेत्र चौड़ाई (>= 1) |
| height | integer | Yes | पिक्सेल में क्षेत्र ऊँचाई (>= 1) |
## Example Request {#example-request}
पूरी इमेज को पिक्सेलेट करें:
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/pixelate \
-H "Authorization: Bearer si_your-api-key" \
-F "file=@photo.jpg" \
-F 'settings={"blockSize": 20}'
```
एक विशिष्ट क्षेत्र को पिक्सेलेट करें:
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/pixelate \
-H "Authorization: Bearer si_your-api-key" \
-F "file=@photo.jpg" \
-F 'settings={"blockSize": 16, "region": {"left": 100, "top": 50, "width": 200, "height": 150}}'
```
## Example Response {#example-response}
```json
{
"jobId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"downloadUrl": "/api/v1/download/a1b2c3d4-e5f6-7890-abcd-ef1234567890/photo.jpg",
"originalSize": 2450000,
"processedSize": 2380000
}
```
## Notes {#notes}
- जब `region` को छोड़ दिया जाता है, तो पूरी इमेज को पिक्सेलेट किया जाता है।
- क्षेत्र निर्देशांक इमेज के ऊपरी-बाएँ कोने के सापेक्ष पिक्सेल में होते हैं। क्षेत्र इमेज की सीमाओं के भीतर होना चाहिए।
- आउटपुट प्रारूप इनपुट प्रारूप से मेल खाता है। HEIC, RAW, PSD और SVG इनपुट प्रोसेसिंग से पहले स्वतः डिकोड किए जाते हैं।
+76
View File
@@ -0,0 +1,76 @@
---
description: "कस्टम रंगों और त्रुटि सुधार स्तरों के साथ QR कोड जनरेट करें।"
i18n_source_hash: 096ef4d90da5
i18n_provenance: human
i18n_output_hash: 65fae6246a5e
---
# QR Code Generator {#qr-code-generator}
कॉन्फ़िगर करने योग्य आकार, त्रुटि सुधार स्तर, और कस्टम अग्रभूमि/पृष्ठभूमि रंगों के साथ टेक्स्ट या URL से QR कोड इमेज जनरेट करें।
## API Endpoint {#api-endpoint}
`POST /api/v1/tools/image/qr-generate`
एक **JSON body** स्वीकार करता है (multipart नहीं)। किसी फ़ाइल अपलोड की आवश्यकता नहीं।
## Parameters {#parameters}
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| text | string | Yes | - | QR कोड में एन्कोड करने के लिए सामग्री (1 से 2000 वर्ण) |
| size | number | No | `400` | पिक्सेल में आउटपुट इमेज चौड़ाई/ऊँचाई (100 से 10000) |
| errorCorrection | string | No | `"M"` | त्रुटि सुधार स्तर: `L` (7%), `M` (15%), `Q` (25%), `H` (30%) |
| foreground | string | No | `"#000000"` | QR कोड अग्रभूमि/मॉड्यूल रंग hex में (`#RRGGBB`) |
| background | string | No | `"#FFFFFF"` | QR कोड पृष्ठभूमि रंग hex में (`#RRGGBB`) |
| logoDataUri | string | No | - | लोगो इमेज एक data URI के रूप में (`data:image/png;base64,...` या `data:image/jpeg;base64,...`, अधिकतम 700 KB)। QR आकार के 22% पर QR कोड पर केंद्रित। त्रुटि सुधार को `H` पर बाध्य करता है |
### Error Correction Levels {#error-correction-levels}
| Level | Recovery | Use Case |
|-------|----------|----------|
| `L` | ~7% | अधिकतम डेटा घनत्व |
| `M` | ~15% | संतुलित (डिफ़ॉल्ट) |
| `Q` | ~25% | मुद्रित कोड के लिए अच्छा |
| `H` | ~30% | लोगो ओवरले वाले कोड के लिए सर्वोत्तम |
## Example Request {#example-request}
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/qr-generate \
-H "Authorization: Bearer si_your-api-key" \
-H "Content-Type: application/json" \
-d '{"text": "https://snapotter.com", "size": 500, "errorCorrection": "H"}'
```
कस्टम रंगों के साथ ब्रांडेड QR कोड:
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/qr-generate \
-H "Authorization: Bearer si_your-api-key" \
-H "Content-Type: application/json" \
-d '{"text": "Hello World", "size": 300, "foreground": "#1a365d", "background": "#f7fafc"}'
```
## Example Response {#example-response}
```json
{
"jobId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"downloadUrl": "/api/v1/download/a1b2c3d4-e5f6-7890-abcd-ef1234567890/qrcode.png",
"originalSize": 0,
"processedSize": 4520
}
```
## Notes {#notes}
- यह एंडपॉइंट JSON स्वीकार करता है, multipart form data नहीं, क्योंकि किसी इमेज अपलोड की आवश्यकता नहीं है।
- आउटपुट हमेशा एक PNG इमेज होता है।
- आउटपुट फ़ाइल नाम हमेशा `qrcode.png` होता है।
- `originalSize` हमेशा 0 होता है क्योंकि यह टूल इमेज को शून्य से जनरेट करता है।
- QR कोड के चारों ओर एक 2-मॉड्यूल क्वाइट ज़ोन (मार्जिन) शामिल होता है।
- अधिकतम टेक्स्ट लंबाई 2000 वर्ण है। वास्तविक क्षमता त्रुटि सुधार स्तर और वर्ण एन्कोडिंग पर निर्भर करती है।
- उच्च त्रुटि सुधार स्तर QR कोड को आंशिक रूप से छिपे होने पर भी स्कैन करने योग्य बने रहने की अनुमति देते हैं लेकिन डेटा क्षमता को कम करते हैं।
- जब कोई `logoDataUri` प्रदान किया जाता है, तो त्रुटि सुधार स्वतः `H` (30%) पर बाध्य हो जाता है ताकि लोगो द्वारा केंद्र को ढकने के बावजूद QR कोड स्कैन करने योग्य बना रहे।
@@ -0,0 +1,79 @@
---
description: "कैमरा फ़्लैश के कारण होने वाली रेड आई का AI-संचालित पता लगाना और सुधार।"
i18n_source_hash: 647c6ff1ef7c
i18n_provenance: human
i18n_output_hash: aa5d51717ef7
---
# Red Eye Removal {#red-eye-removal}
कैमरा फ़्लैश के कारण होने वाली रेड आई का AI-संचालित पता लगाना और सुधार।
## API Endpoint {#api-endpoint}
`POST /api/v1/tools/image/red-eye-removal`
**Processing:** असिंक्रोनस (202 लौटाता है, SSE के माध्यम से स्थिति के लिए `/api/v1/jobs/{jobId}/progress` पोल करें)
**Model bundle:** `face-detection` (200-300 MB)
## Parameters {#parameters}
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| file | file | Yes | - | इमेज फ़ाइल (multipart) |
| sensitivity | number | No | `50` | रेड आई डिटेक्शन संवेदनशीलता (0-100)। उच्च मान अधिक सूक्ष्म रेड-आई का पता लगाते हैं |
| strength | number | No | `70` | सुधार की तीव्रता (0-100)। लाल को कितनी आक्रामकता से निष्प्रभावी करना है |
| format | string | No | - | आउटपुट प्रारूप (वैकल्पिक ओवरराइड) |
| quality | number | No | `90` | आउटपुट गुणवत्ता (1-100) |
## Example Request {#example-request}
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/red-eye-removal \
-F "file=@flash-photo.jpg" \
-F 'settings={"sensitivity":60,"strength":80}'
```
## Response {#response}
### Initial Response (202 Accepted) {#initial-response-202-accepted}
```json
{
"jobId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"async": true
}
```
### Progress (SSE at `/api/v1/jobs/{jobId}/progress`) {#progress-sse-at-api-v1-jobs-jobid-progress}
```
event: progress
data: {"phase":"processing","stage":"Detecting red eyes...","percent":40}
```
### Final Result (via SSE) {#final-result-via-sse}
```json
{
"phase": "complete",
"percent": 100,
"result": {
"jobId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"downloadUrl": "/api/v1/download/{jobId}/flash-photo_redeye_fixed.png",
"originalSize": 280000,
"processedSize": 290000,
"facesDetected": 2,
"eyesCorrected": 4
}
}
```
## Notes {#notes}
- `face-detection` मॉडल बंडल का इंस्टॉल होना आवश्यक है (200-300 MB)।
- पहले चेहरों का पता लगाता है, फिर प्रत्येक चेहरे के भीतर आँख के क्षेत्रों का पता लगाता है, और अंत में रेड-आई पिक्सेल की पहचान करके उन्हें सुधारता है।
- `facesDetected` गणना यह दर्शाती है कि कितने चेहरे पाए गए; `eyesCorrected` उन अलग-अलग आँखों की कुल संख्या है जिनकी रेड-आई सुधारी गई।
- अधिकतम गुणवत्ता संरक्षण के लिए आउटपुट हमेशा PNG होता है।
- स्वचालित डिकोडिंग के माध्यम से HEIC/HEIF, RAW, TGA, PSD, EXR और HDR इनपुट प्रारूपों का समर्थन करता है।
@@ -0,0 +1,136 @@
---
description: "वैकल्पिक प्रभावों (ब्लर, शैडो, ग्रेडिएंट, कस्टम बैकग्राउंड) के साथ AI-संचालित बैकग्राउंड हटाना।"
i18n_source_hash: 326a91284529
i18n_provenance: human
i18n_output_hash: 09821276c64d
---
# Remove Background {#remove-background}
वैकल्पिक प्रभावों (ब्लर, शैडो, ग्रेडिएंट, कस्टम बैकग्राउंड) के साथ AI-संचालित बैकग्राउंड हटाना।
## API Endpoint {#api-endpoint}
`POST /api/v1/tools/image/remove-background`
**Processing:** असिंक्रोनस (202 लौटाता है, SSE के माध्यम से स्थिति के लिए `/api/v1/jobs/{jobId}/progress` पोल करें)
**Model bundle:** `background-removal` (4-5 GB)
## Parameters {#parameters}
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| file | file | Yes | - | इमेज फ़ाइल (multipart) |
| model | string | No | - | उपयोग करने के लिए AI मॉडल संस्करण |
| backgroundType | string | No | `"transparent"` | इनमें से एक: `transparent`, `color`, `gradient`, `blur`, `image` |
| backgroundColor | string | No | - | ठोस बैकग्राउंड के लिए Hex रंग |
| gradientColor1 | string | No | - | पहला ग्रेडिएंट रंग |
| gradientColor2 | string | No | - | दूसरा ग्रेडिएंट रंग |
| gradientAngle | number | No | - | डिग्री में ग्रेडिएंट कोण |
| blurEnabled | boolean | No | - | बैकग्राउंड ब्लर प्रभाव सक्षम करें |
| blurIntensity | number | No | - | ब्लर तीव्रता (0-100) |
| shadowEnabled | boolean | No | - | विषय पर ड्रॉप शैडो सक्षम करें |
| shadowOpacity | number | No | - | शैडो अपारदर्शिता (0-100) |
| outputFormat | string | No | - | आउटपुट प्रारूप: `png`, `webp`, या `avif` |
| edgeRefine | integer | No | - | एज परिशोधन स्तर (0-3) |
| decontaminate | boolean | No | - | किनारों से रंग रिसाव हटाएँ |
## Example Request {#example-request}
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/remove-background \
-F "file=@photo.jpg" \
-F 'settings={"backgroundType":"transparent","edgeRefine":2,"outputFormat":"png"}'
```
## Response {#response}
### Initial Response (202 Accepted) {#initial-response-202-accepted}
```json
{
"jobId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"async": true
}
```
### Progress (SSE at `/api/v1/jobs/{jobId}/progress`) {#progress-sse-at-api-v1-jobs-jobid-progress}
```
event: progress
data: {"phase":"processing","stage":"Removing background...","percent":50}
```
### Final Result (via SSE) {#final-result-via-sse}
```json
{
"phase": "complete",
"percent": 100,
"result": {
"jobId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"downloadUrl": "/api/v1/download/{jobId}/photo_mask.png",
"maskUrl": "/api/v1/download/{jobId}/photo_mask.png",
"originalUrl": "/api/v1/download/{jobId}/photo_original.png",
"originalSize": 245000,
"processedSize": 180000,
"filename": "photo.jpg",
"model": "rembg"
}
}
```
## Effects Endpoint (Phase 2) {#effects-endpoint-phase-2}
`POST /api/v1/tools/image/remove-background/effects`
AI मॉडल को पुनः चलाए बिना बैकग्राउंड प्रभावों को फिर से लागू करता है। Phase 1 से कैश किए गए मास्क और मूल का उपयोग करता है।
### Parameters {#parameters-1}
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| settings | JSON | Yes | - | प्रभाव सेटिंग्स के साथ JSON (नीचे देखें) |
| backgroundImage | file | No | - | कस्टम बैकग्राउंड इमेज (जब backgroundType `image` हो) |
#### Settings JSON fields {#settings-json-fields}
| Field | Type | Required | Description |
|-------|------|----------|-------------|
| jobId | string | Yes | Phase 1 से जॉब ID |
| filename | string | Yes | Phase 1 से मूल फ़ाइल नाम |
| backgroundType | string | No | `transparent`, `color`, `gradient`, `blur`, `image` |
| backgroundColor | string | No | ठोस बैकग्राउंड के लिए Hex रंग |
| gradientColor1 | string | No | पहला ग्रेडिएंट रंग |
| gradientColor2 | string | No | दूसरा ग्रेडिएंट रंग |
| gradientAngle | number | No | डिग्री में ग्रेडिएंट कोण |
| blurEnabled | boolean | No | बैकग्राउंड ब्लर सक्षम करें |
| blurIntensity | number | No | ब्लर तीव्रता (0-100) |
| shadowEnabled | boolean | No | ड्रॉप शैडो सक्षम करें |
| shadowOpacity | number | No | शैडो अपारदर्शिता (0-100) |
| outputFormat | string | No | `png`, `webp`, या `avif` |
### Example Request {#example-request-1}
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/remove-background/effects \
-F 'settings={"jobId":"a1b2c3d4-...","filename":"photo.jpg","backgroundType":"color","backgroundColor":"#FF5500","outputFormat":"png"}'
```
### Response (200 OK) {#response-200-ok}
```json
{
"jobId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"downloadUrl": "/api/v1/download/{jobId}/photo_nobg.png",
"processedSize": 195000
}
```
## Notes {#notes}
- `background-removal` मॉडल बंडल का इंस्टॉल होना आवश्यक है (4-5 GB)।
- Phase 1 पारदर्शी मास्क और मूल इमेज को कैश करता है ताकि Phase 2 (प्रभाव) AI मॉडल को पुनः चलाए बिना तुरंत अलग-अलग बैकग्राउंड को फिर से लागू कर सके।
- स्वचालित डिकोडिंग के माध्यम से HEIC/HEIF, RAW, TGA, PSD, EXR और HDR इनपुट प्रारूपों का समर्थन करता है।
- प्रोसेसिंग से पहले EXIF रोटेशन स्वतः सुधारा जाता है।
+62
View File
@@ -0,0 +1,62 @@
---
description: "किसी इमेज में एक विशिष्ट रंग को दूसरे रंग से बदलें या उसे पारदर्शी बनाएँ।"
i18n_source_hash: df55ac451ecb
i18n_provenance: human
i18n_output_hash: 3393829a128e
---
# Replace & Invert Color {#replace-invert-color}
स्रोत रंग से मेल खाने वाले पिक्सेल को लक्ष्य रंग से बदलें, या उन्हें पारदर्शी बनाएँ। रंग सीमाओं पर सहज ब्लेंडिंग के लिए कॉन्फ़िगर करने योग्य सहनशीलता के साथ RGB स्पेस में यूक्लिडियन दूरी का उपयोग करता है।
## API Endpoint {#api-endpoint}
`POST /api/v1/tools/image/replace-color`
एक इमेज फ़ाइल और एक JSON `settings` फ़ील्ड के साथ multipart form data स्वीकार करता है।
## Parameters {#parameters}
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| sourceColor | string | No | `"#FF0000"` | खोजने के लिए Hex रंग (प्रारूप: `#RRGGBB`) |
| targetColor | string | No | `"#00FF00"` | बदलने के लिए Hex रंग (प्रारूप: `#RRGGBB`) |
| makeTransparent | boolean | No | `false` | मेल खाने वाले पिक्सेल को लक्ष्य रंग से बदलने के बजाय पारदर्शी बनाएँ |
| tolerance | number | No | `30` | रंग मिलान सहनशीलता (0 से 255)। उच्च मान समान रंगों की व्यापक रेंज से मेल खाते हैं |
## Example Request {#example-request}
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/replace-color \
-H "Authorization: Bearer si_your-api-key" \
-F "file=@photo.jpg" \
-F 'settings={"sourceColor": "#FF0000", "targetColor": "#0000FF", "tolerance": 40}'
```
एक हरे बैकग्राउंड को पारदर्शी बनाएँ:
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/replace-color \
-H "Authorization: Bearer si_your-api-key" \
-F "file=@greenscreen.png" \
-F 'settings={"sourceColor": "#00FF00", "makeTransparent": true, "tolerance": 50}'
```
## Example Response {#example-response}
```json
{
"jobId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"downloadUrl": "/api/v1/download/a1b2c3d4-e5f6-7890-abcd-ef1234567890/photo.png",
"originalSize": 2450000,
"processedSize": 2100000
}
```
## Notes {#notes}
- रंग मिलान RGB स्पेस में यूक्लिडियन दूरी का उपयोग करता है, जिसे `tolerance * sqrt(3)` द्वारा स्केल किया जाता है।
- प्रतिस्थापन ब्लेंडिंग रंग दूरी के समानुपाती है: स्रोत रंग के करीब पिक्सेल अधिक लक्ष्य रंग प्राप्त करते हैं, जिससे सहज संक्रमण बनते हैं।
- जब `makeTransparent` `true` होता है, तो यदि इनपुट प्रारूप अल्फा चैनल का समर्थन नहीं करता है (उदा., JPEG) तो आउटपुट को PNG (या WebP/AVIF) पर बाध्य किया जाता है।
- 0 की सहनशीलता केवल सटीक स्रोत रंग से मेल खाती है। उच्च मान (50+) समान रंगों की व्यापक रेंज से मेल खाएँगे।
- आउटपुट प्रारूप इनपुट प्रारूप से मेल खाता है, जब तक कि पारदर्शिता की आवश्यकता न हो और इनपुट प्रारूप में अल्फा समर्थन न हो।
+72
View File
@@ -0,0 +1,72 @@
---
description: "इमेज को पिक्सेल, प्रतिशत, या फ़िट मोड के साथ आकार बदलें।"
i18n_source_hash: 00d1bffa4d38
i18n_provenance: human
i18n_output_hash: 8d7a5fb7e21f
---
# Resize {#resize}
सटीक पिक्सेल आयाम, एक प्रतिशत स्केल फ़ैक्टर, या एक फ़िट मोड निर्दिष्ट करके इमेज का आकार बदलें जो नियंत्रित करता है कि इमेज लक्ष्य आयामों के अनुकूल कैसे होती है।
## API Endpoint {#api-endpoint}
`POST /api/v1/tools/image/resize`
एक इमेज फ़ाइल और एक JSON `settings` फ़ील्ड के साथ multipart form data स्वीकार करता है।
## Parameters {#parameters}
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| width | integer | No | - | पिक्सेल में लक्ष्य चौड़ाई (अधिकतम 16383) |
| height | integer | No | - | पिक्सेल में लक्ष्य ऊँचाई (अधिकतम 16383) |
| fit | string | No | `"contain"` | इमेज आयामों में कैसे फ़िट होती है: `contain`, `cover`, `fill`, `inside`, `outside` |
| withoutEnlargement | boolean | No | `false` | यदि इमेज लक्ष्य से छोटी है तो अपस्केलिंग रोकें |
| percentage | number | No | - | प्रतिशत के अनुसार स्केल करें (उदा. आधे आकार के लिए 50) |
`width`, `height`, या `percentage` में से कम से कम एक प्रदान किया जाना चाहिए।
### Fit Modes {#fit-modes}
- **contain** - आस्पेक्ट अनुपात को संरक्षित करते हुए, आयामों के भीतर फ़िट करने के लिए आकार बदलें (खाली स्थान छोड़ सकता है)
- **cover** - आस्पेक्ट अनुपात को संरक्षित करते हुए, आयामों को कवर करने के लिए आकार बदलें (क्रॉप कर सकता है)
- **fill** - आयामों से बिल्कुल मेल खाने के लिए खींचें (आस्पेक्ट अनुपात को अनदेखा करता है)
- **inside** - `contain` की तरह, लेकिन केवल डाउनस्केल करता है, कभी अपस्केल नहीं
- **outside** - `cover` की तरह, लेकिन केवल डाउनस्केल करता है, कभी अपस्केल नहीं
## Example Request {#example-request}
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/resize \
-H "Authorization: Bearer si_your-api-key" \
-F "file=@photo.jpg" \
-F 'settings={"width": 800, "height": 600, "fit": "contain"}'
```
प्रतिशत के अनुसार आकार बदलें:
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/resize \
-H "Authorization: Bearer si_your-api-key" \
-F "file=@photo.jpg" \
-F 'settings={"percentage": 50}'
```
## Example Response {#example-response}
```json
{
"jobId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"downloadUrl": "/api/v1/download/a1b2c3d4-e5f6-7890-abcd-ef1234567890/photo.jpg",
"originalSize": 2450000,
"processedSize": 980000
}
```
## Notes {#notes}
- किसी भी अक्ष पर अधिकतम आयाम 16383 पिक्सेल है (Sharp/libvips सीमा)।
- आउटपुट प्रारूप इनपुट प्रारूप से मेल खाता है। HEIC, RAW, PSD और SVG इनपुट प्रोसेसिंग से पहले स्वतः डिकोड किए जाते हैं।
- आकार बदलने से पहले EXIF अभिविन्यास स्वतः लागू होता है।
- `withoutEnlargement` फ़्लैग बैच प्रोसेसिंग के लिए उपयोगी है जहाँ कुछ इमेज पहले से ही लक्ष्य से छोटी हो सकती हैं।
+96
View File
@@ -0,0 +1,96 @@
---
description: "पुनर्स्थापना, फेस एन्हांसमेंट और रंग के लिए एक AI पाइपलाइन के साथ पुरानी फ़ोटो पर खरोंच, दरार और क्षति की मरम्मत करें।"
i18n_source_hash: 3de13284216c
i18n_provenance: human
i18n_output_hash: ad345e8fad97
---
# Photo Restoration {#photo-restoration}
एक मल्टी-स्टेप AI पाइपलाइन का उपयोग करके पुरानी फ़ोटो पर खरोंच, दरार और क्षति को ठीक करें। स्क्रैच रिपेयर, फेस एन्हांसमेंट, डिनॉइज़िंग और वैकल्पिक कलराइज़ेशन को संयोजित करता है।
## API Endpoint {#api-endpoint}
`POST /api/v1/tools/image/restore-photo`
**Processing:** असिंक्रोनस (202 लौटाता है, SSE के माध्यम से स्थिति के लिए `/api/v1/jobs/{jobId}/progress` पोल करें)
**Model bundle:** `photo-restoration` (4-5 GB)
## Parameters {#parameters}
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| file | file | Yes | - | इमेज फ़ाइल (multipart) |
| scratchRemoval | boolean | No | `true` | खरोंच और सतही क्षति हटाएँ |
| faceEnhancement | boolean | No | `true` | पुनर्स्थापित फ़ोटो में चेहरों को बेहतर बनाएँ |
| fidelity | number | No | `0.7` | फेस एन्हांसमेंट निष्ठा (0-1)। उच्च मान मूल विशेषताओं को अधिक संरक्षित करते हैं |
| denoise | boolean | No | `true` | पुनर्स्थापित परिणाम पर डिनॉइज़िंग लागू करें |
| denoiseStrength | number | No | `25` | डिनॉइज़िंग की तीव्रता (0-100) |
| colorize | boolean | No | `false` | पुनर्स्थापित फ़ोटो को कलराइज़ करें (ग्रेस्केल इमेज के लिए) |
| colorizeStrength | number | No | `85` | कलराइज़ेशन तीव्रता (0-100) |
## Example Request {#example-request}
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/restore-photo \
-F "file=@damaged-old-photo.jpg" \
-F 'settings={"scratchRemoval":true,"faceEnhancement":true,"fidelity":0.6,"colorize":true}'
```
## Response {#response}
### Initial Response (202 Accepted) {#initial-response-202-accepted}
```json
{
"jobId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"async": true
}
```
### Progress (SSE at `/api/v1/jobs/{jobId}/progress`) {#progress-sse-at-api-v1-jobs-jobid-progress}
```
event: progress
data: {"phase":"processing","stage":"Removing scratches...","percent":30}
```
```
event: progress
data: {"phase":"processing","stage":"Enhancing faces...","percent":60}
```
### Final Result (via SSE) {#final-result-via-sse}
```json
{
"phase": "complete",
"percent": 100,
"result": {
"jobId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"downloadUrl": "/api/v1/download/{jobId}/damaged-old-photo_restored.jpg",
"previewUrl": "/api/v1/download/{jobId}/preview.webp",
"originalSize": 200000,
"processedSize": 350000,
"width": 1200,
"height": 900,
"steps": ["scratch_removal", "face_enhancement", "denoise", "colorize"],
"scratchCoverage": 12.5,
"facesEnhanced": 2,
"isGrayscale": true,
"colorized": true
}
}
```
## Notes {#notes}
- `photo-restoration` मॉडल बंडल का इंस्टॉल होना आवश्यक है (4-5 GB)।
- पाइपलाइन कई AI चरणों को क्रमिक रूप से चलाती है: स्क्रैच रिपेयर, फेस एन्हांसमेंट (GFPGAN), डिनॉइज़िंग, और वैकल्पिक रूप से कलराइज़ेशन।
- परिणाम में `steps` सरणी यह दर्शाती है कि कौन से प्रोसेसिंग चरण वास्तव में निष्पादित किए गए।
- `scratchCoverage` इमेज क्षेत्र का अनुमानित प्रतिशत है जिसमें स्क्रैच क्षति थी।
- `fidelity` नियंत्रित करता है कि मूल स्वरूप को संरक्षित करने की तुलना में चेहरों को कितनी दृढ़ता से बेहतर बनाया जाए। निम्न मान अधिक आक्रामक एन्हांसमेंट उत्पन्न करते हैं; उच्च मान अधिक रूढ़िवादी होते हैं।
- `colorize` विकल्प स्वतः पता लगाता है कि इमेज ग्रेस्केल है या नहीं। परिणाम में `isGrayscale` फ़्लैग इस पहचान की पुष्टि करता है।
- आउटपुट प्रारूप स्वतः इनपुट प्रारूप से मेल खाता है।
- स्वचालित डिकोडिंग के माध्यम से HEIC/HEIF, RAW, TGA, PSD, EXR, HDR और AVIF इनपुट प्रारूपों का समर्थन करता है।
+71
View File
@@ -0,0 +1,71 @@
---
description: "इमेज को किसी भी कोण पर घुमाएँ और क्षैतिज या ऊर्ध्वाधर रूप से फ़्लिप करें।"
i18n_source_hash: af2581d7cd8d
i18n_provenance: human
i18n_output_hash: 8321b92c9aab
---
# Rotate & Flip {#rotate-flip}
इमेज को एक मनमाने कोण पर घुमाएँ और/या उन्हें क्षैतिज या ऊर्ध्वाधर रूप से फ़्लिप करें। रोटेशन और फ़्लिप ऑपरेशन को एक ही अनुरोध में संयोजित किया जा सकता है।
## API Endpoint {#api-endpoint}
`POST /api/v1/tools/image/rotate`
एक इमेज फ़ाइल और एक JSON `settings` फ़ील्ड के साथ multipart form data स्वीकार करता है।
## Parameters {#parameters}
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| angle | number | No | `0` | डिग्री में रोटेशन कोण (दक्षिणावर्त)। किसी भी संख्यात्मक मान को स्वीकार करता है। |
| horizontal | boolean | No | `false` | इमेज को क्षैतिज रूप से फ़्लिप करें (मिरर) |
| vertical | boolean | No | `false` | इमेज को ऊर्ध्वाधर रूप से फ़्लिप करें |
## Example Request {#example-request}
90 डिग्री दक्षिणावर्त घुमाएँ:
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/rotate \
-H "Authorization: Bearer si_your-api-key" \
-F "file=@photo.jpg" \
-F 'settings={"angle": 90}'
```
क्षैतिज रूप से फ़्लिप करें:
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/rotate \
-H "Authorization: Bearer si_your-api-key" \
-F "file=@photo.jpg" \
-F 'settings={"horizontal": true}'
```
एक साथ घुमाएँ और फ़्लिप करें:
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/rotate \
-H "Authorization: Bearer si_your-api-key" \
-F "file=@photo.jpg" \
-F 'settings={"angle": 45, "vertical": true}'
```
## Example Response {#example-response}
```json
{
"jobId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"downloadUrl": "/api/v1/download/a1b2c3d4-e5f6-7890-abcd-ef1234567890/photo.jpg",
"originalSize": 2450000,
"processedSize": 2480000
}
```
## Notes {#notes}
- पहले रोटेशन लागू होता है, फिर फ़्लिप ऑपरेशन।
- गैर-90-डिग्री रोटेशन (उदा. 45 डिग्री) घुमाई गई इमेज को फ़िट करने के लिए कैनवास को बड़ा कर देंगे, जिसमें आउटपुट प्रारूप के आधार पर पारदर्शी या काला फ़िल होगा।
- सामान्य मान: क्वार्टर-टर्न रोटेशन के लिए 90, 180, 270।
- प्रोसेसिंग से पहले EXIF अभिविन्यास स्वतः लागू होता है, इसलिए रोटेशन दृश्य अभिविन्यास के सापेक्ष होता है।
+71
View File
@@ -0,0 +1,71 @@
---
description: "वैकल्पिक शोर कमी के साथ एडेप्टिव, अनशार्प मास्क, या हाई-पास विधियों का उपयोग करके छवियों को शार्प करें।"
i18n_source_hash: ccb60af9faae
i18n_provenance: human
i18n_output_hash: a4764dc09c6d
---
# Sharpening {#sharpening}
तीन विधियों वाला उन्नत शार्पनिंग टूल: एडेप्टिव (स्मार्ट एज-अवेयर), अनशार्प मास्क (क्लासिक रेडियस/मात्रा), और हाई-पास (टेक्सचर पर जोर)। शार्पनिंग आर्टिफैक्ट को रोकने के लिए इसमें अंतर्निहित शोर कमी शामिल है।
## API Endpoint {#api-endpoint}
`POST /api/v1/tools/image/sharpening`
एक image फ़ाइल और एक JSON `settings` फ़ील्ड के साथ multipart फ़ॉर्म डेटा स्वीकार करता है।
## Parameters {#parameters}
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| method | string | No | `"adaptive"` | शार्पनिंग एल्गोरिदम: `adaptive`, `unsharp-mask`, `high-pass` |
| sigma | number | No | `1.0` | एडेप्टिव: Gaussian sigma (0.5 से 10) |
| m1 | number | No | `1.0` | एडेप्टिव: सपाट क्षेत्र शार्पनिंग (0 से 10) |
| m2 | number | No | `3.0` | एडेप्टिव: दांतेदार क्षेत्र शार्पनिंग (0 से 20) |
| x1 | number | No | `2.0` | एडेप्टिव: सपाट/दांतेदार थ्रेशोल्ड (0 से 10) |
| y2 | number | No | `12` | एडेप्टिव: अधिकतम सपाट शार्पनिंग (0 से 50) |
| y3 | number | No | `20` | एडेप्टिव: अधिकतम दांतेदार शार्पनिंग (0 से 50) |
| amount | number | No | `100` | अनशार्प मास्क: शार्पनिंग मात्रा (0 से 1000) |
| radius | number | No | `1.0` | अनशार्प मास्क: पिक्सेल में ब्लर रेडियस (0.1 से 5) |
| threshold | number | No | `0` | अनशार्प मास्क: शार्प करने के लिए न्यूनतम चमक अंतर (0 से 255) |
| strength | number | No | `50` | हाई-पास: फ़िल्टर स्ट्रेंथ (0 से 100) |
| kernelSize | number | No | `3` | हाई-पास: कनवोल्यूशन कर्नेल आकार (3 या 5) |
| denoise | string | No | `"off"` | शार्पनिंग से पहले शोर कमी: `off`, `light`, `medium`, `strong` |
## Example Request {#example-request}
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/sharpening \
-H "Authorization: Bearer si_your-api-key" \
-F "file=@photo.jpg" \
-F 'settings={"method": "adaptive", "sigma": 1.5}'
```
समतल क्षेत्रों की रक्षा के लिए थ्रेशोल्ड के साथ अनशार्प मास्क:
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/sharpening \
-H "Authorization: Bearer si_your-api-key" \
-F "file=@photo.jpg" \
-F 'settings={"method": "unsharp-mask", "amount": 150, "radius": 1.5, "threshold": 10}'
```
## Example Response {#example-response}
```json
{
"jobId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"downloadUrl": "/api/v1/download/a1b2c3d4-e5f6-7890-abcd-ef1234567890/photo.jpg",
"originalSize": 2450000,
"processedSize": 2510000
}
```
## Notes {#notes}
- केवल चुनी गई विधि से संबंधित पैरामीटर ही उपयोग किए जाते हैं। उदाहरण के लिए, जब `method` `adaptive` हो तो `amount`, `radius`, और `threshold` को अनदेखा किया जाता है।
- एडेप्टिव विधि Sharp की अंतर्निहित एडेप्टिव शार्पनिंग का उपयोग करती है जिसमें कॉन्फ़िगर करने योग्य सपाट/दांतेदार क्षेत्र व्यवहार होता है।
- `denoise` विकल्प शोर/ग्रेन के प्रवर्धन को रोकने के लिए शार्पनिंग से पहले शोर कमी लागू करता है।
- हाई-पास शार्पनिंग मूल से एक ब्लर किए गए संस्करण को घटाकर बारीक विवरण निकालती है, फिर उसे वापस मिलाती है।
- आउटपुट फ़ॉर्मेट इनपुट फ़ॉर्मेट से मेल खाता है। HEIC, RAW, PSD, और SVG इनपुट प्रोसेसिंग से पहले स्वचालित रूप से डिकोड किए जाते हैं।
+96
View File
@@ -0,0 +1,96 @@
---
description: "सब्जेक्ट-, फ़ेस-, और एन्ट्रॉपी-अवेयर क्रॉपिंग जो Sharp और AI फ़ेस डिटेक्शन का उपयोग करके छवियों को बुद्धिमानी से फ़्रेम करती है।"
i18n_source_hash: acbe1439c6d8
i18n_provenance: human
i18n_output_hash: 1bcc0731dfac
---
# Smart Crop {#smart-crop}
स्मार्ट सब्जेक्ट-अवेयर, फ़ेस-अवेयर, या ट्रिम-आधारित क्रॉपिंग। बुद्धिमान फ़्रेमिंग के लिए Sharp की attention/entropy रणनीतियों और AI फ़ेस डिटेक्शन का उपयोग करती है।
## API Endpoint {#api-endpoint}
`POST /api/v1/tools/image/smart-crop`
**Processing:** असिंक्रोनस (202 लौटाता है, SSE के माध्यम से स्थिति के लिए `/api/v1/jobs/{jobId}/progress` को पोल करें)
**Model bundle:** `face-detection` (200-300 MB) - केवल `face` मोड के लिए आवश्यक
## Parameters {#parameters}
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| file | file | Yes | - | Image फ़ाइल (multipart) |
| mode | string | No | `"subject"` | क्रॉप मोड: `subject`, `face`, `trim`। (लेगेसी मान `attention` और `content` `subject` और `trim` पर मैप होते हैं) |
| strategy | string | No | `"attention"` | सब्जेक्ट मोड के लिए रणनीति: `attention` या `entropy` |
| width | integer | No | - | पिक्सेल में लक्ष्य चौड़ाई |
| height | integer | No | - | पिक्सेल में लक्ष्य ऊँचाई |
| padding | integer | No | `0` | सब्जेक्ट के चारों ओर पैडिंग प्रतिशत (0-50) |
| facePreset | string | No | `"head-shoulders"` | फ़ेस फ़्रेमिंग प्रीसेट: `closeup`, `head-shoulders`, `upper-body`, `half-body` |
| sensitivity | number | No | `0.5` | फ़ेस डिटेक्शन संवेदनशीलता (0-1) |
| threshold | integer | No | `30` | बैकग्राउंड डिटेक्शन के लिए ट्रिम मोड थ्रेशोल्ड (0-255) |
| padToSquare | boolean | No | `false` | ट्रिम किए गए परिणाम को वर्ग में पैड करें |
| padColor | string | No | `"#ffffff"` | पैडिंग के लिए बैकग्राउंड रंग |
| targetSize | integer | No | - | पैड किए गए आउटपुट के लिए लक्ष्य आकार (पिक्सेल) |
| quality | integer | No | - | आउटपुट गुणवत्ता (1-100) |
## Example Request {#example-request}
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/smart-crop \
-F "file=@portrait.jpg" \
-F 'settings={"mode":"face","width":1080,"height":1080,"facePreset":"head-shoulders"}'
```
## Response {#response}
### Initial Response (202 Accepted) {#initial-response-202-accepted}
```json
{
"jobId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"async": true
}
```
### Progress (SSE at `/api/v1/jobs/{jobId}/progress`) {#progress-sse-at-api-v1-jobs-jobid-progress}
```
event: progress
data: {"phase":"processing","percent":50}
```
### Final Result (via SSE) {#final-result-via-sse}
```json
{
"phase": "complete",
"percent": 100,
"result": {
"jobId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"downloadUrl": "/api/v1/download/{jobId}/portrait_smartcrop.jpg",
"originalSize": 500000,
"processedSize": 320000
}
}
```
## Modes {#modes}
### Subject Mode {#subject-mode}
सबसे दृश्य रूप से रोचक क्षेत्र खोजने के लिए Sharp की attention या entropy रणनीति का उपयोग करता है और उसके चारों ओर क्रॉप करता है।
### Face Mode {#face-mode}
AI का उपयोग करके चेहरों का पता लगाता है, फिर निर्दिष्ट `facePreset` का उपयोग करके पहचाने गए चेहरों के चारों ओर क्रॉप को फ़्रेम करता है। यदि कोई चेहरा नहीं मिलता है तो सब्जेक्ट मोड (attention रणनीति) पर वापस चला जाता है।
### Trim Mode {#trim-mode}
छवि से एकसमान बॉर्डर/बैकग्राउंड को हटाता है। वैकल्पिक रूप से परिणाम को निर्दिष्ट बैकग्राउंड रंग और लक्ष्य आकार के साथ एक वर्ग में पैड करता है।
## Notes {#notes}
- यह टूल `executionHint: "long"` के साथ `createToolRoute` फ़ैक्टरी का उपयोग करता है, इसलिए यह SSE प्रगति के साथ 202 लौटाता है।
- फ़ेस मोड के लिए `face-detection` मॉडल बंडल (200-300 MB) आवश्यक है।
- सब्जेक्ट और ट्रिम मोड बिना किसी AI मॉडल बंडल के काम करते हैं।
- `facePreset` यह निर्धारित करता है कि क्रॉप पहचाने गए चेहरों को कितनी कसकर फ़्रेम करता है: `closeup` सबसे कसा हुआ है, `half-body` सबसे चौड़ा है।
- यदि कोई चौड़ाई/ऊँचाई निर्दिष्ट नहीं है, तो डिफ़ॉल्ट 1080x1080 है।
+49
View File
@@ -0,0 +1,49 @@
---
description: "एक छवि को पंक्तियों और स्तंभों द्वारा या पिक्सेल आकार द्वारा ग्रिड टाइलों में विभाजित करें, जिसे ZIP आर्काइव के रूप में लौटाया जाता है।"
i18n_source_hash: 57a2e11e7cce
i18n_provenance: human
i18n_output_hash: 3c6671378498
---
# Image Splitting {#image-splitting}
एक अकेली छवि को स्तंभ/पंक्ति गणना द्वारा या विशिष्ट पिक्सेल आयामों द्वारा ग्रिड टाइलों में विभाजित करें। सभी टाइलों वाला एक ZIP आर्काइव लौटाता है।
## API Endpoint {#api-endpoint}
`POST /api/v1/tools/image/split`
## Parameters {#parameters}
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| columns | integer | No | 3 | विभाजित करने के लिए स्तंभों की संख्या (1 से 100) |
| rows | integer | No | 3 | विभाजित करने के लिए पंक्तियों की संख्या (1 से 100) |
| tileWidth | integer | No | - | पिक्सेल में टाइल चौड़ाई (न्यूनतम 10)। जब `tileWidth` और `tileHeight` दोनों सेट हों तो `columns` को ओवरराइड करता है। |
| tileHeight | integer | No | - | पिक्सेल में टाइल ऊँचाई (न्यूनतम 10)। जब `tileWidth` और `tileHeight` दोनों सेट हों तो `rows` को ओवरराइड करता है। |
| outputFormat | string | No | `"original"` | टाइलों के लिए आउटपुट फ़ॉर्मेट: `original`, `png`, `jpg`, `webp`, `avif`, `jxl` |
| quality | number | No | 90 | लॉसी फ़ॉर्मेट के लिए आउटपुट गुणवत्ता (1 से 100) |
## Example Request {#example-request}
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/split \
-F "file=@large-image.png" \
-F 'settings={"columns":3,"rows":3,"outputFormat":"png"}' \
--output split-tiles.zip
```
## Example Response {#example-response}
प्रतिक्रिया `Content-Type: application/zip` के साथ सीधे एक ZIP फ़ाइल के रूप में स्ट्रीम की जाती है। फ़ाइल नाम `split-<jobId>.zip` पैटर्न का अनुसरण करता है।
ZIP के अंदर प्रत्येक टाइल का नाम `<originalBaseName>_r<row>_c<col>.<ext>` है (उदा. `photo_r1_c1.png`, `photo_r2_c3.webp`)।
## Notes {#notes}
- एक अकेली छवि फ़ाइल स्वीकार करता है।
- HEIC, RAW, PSD, और SVG इनपुट फ़ॉर्मेट का समर्थन करता है (स्वचालित रूप से डिकोड)।
- जब `tileWidth` और `tileHeight` दोनों प्रदान किए जाते हैं, तो वे `columns`/`rows` पर प्राथमिकता लेते हैं। ग्रिड आयामों की गणना `ceil(imageWidth / tileWidth)` और `ceil(imageHeight / tileHeight)` के रूप में की जाती है।
- यदि छवि के आयाम समान रूप से विभाज्य नहीं हैं तो किनारे की टाइलें (सबसे दाहिना स्तंभ, नीचे की पंक्ति) निर्दिष्ट टाइल आकार से छोटी हो सकती हैं।
- अधिकतम ग्रिड आकार 100x100 (10,000 टाइलें) पर सीमित है।
- प्रतिक्रिया सीधे ZIP को स्ट्रीम करती है, इसलिए कोई JSON प्रतिक्रिया बॉडी नहीं है। फ़ाइल सहेजने के लिए curl के साथ `--output` का उपयोग करें।
+69
View File
@@ -0,0 +1,69 @@
---
description: "फ़्रेम मेटाडेटा के साथ कई छवियों को एक अकेली स्प्राइट शीट ग्रिड में संयोजित करें।"
i18n_source_hash: 1938d7fb100d
i18n_provenance: human
i18n_output_hash: 23631f6601fe
---
# Sprite Sheet {#sprite-sheet}
कई छवियों को एक अकेली स्प्राइट शीट ग्रिड में संयोजित करें। प्रत्येक छवि को पहली छवि के आयामों से मिलान करने के लिए आकार बदला जाता है और ग्रिड में रखा जाता है। प्रति-फ़्रेम कोऑर्डिनेट मेटाडेटा के साथ स्प्राइट शीट छवि लौटाता है।
## API Endpoint {#api-endpoint}
`POST /api/v1/tools/image/sprite-sheet`
दो या अधिक image फ़ाइलों और एक JSON `settings` फ़ील्ड के साथ multipart फ़ॉर्म डेटा स्वीकार करता है।
## Parameters {#parameters}
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| columns | integer | No | `4` | ग्रिड में स्तंभों की संख्या (1-16) |
| padding | integer | No | `0` | पिक्सेल में कोशिकाओं के बीच पैडिंग (0-64) |
| background | string | No | `"#ffffff"` | बैकग्राउंड हेक्स रंग |
| format | string | No | `"png"` | आउटपुट फ़ॉर्मेट: `png`, `webp`, या `jpeg` |
| quality | integer | No | `90` | आउटपुट गुणवत्ता (1-100) |
## Example Request {#example-request}
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/sprite-sheet \
-H "Authorization: Bearer si_your-api-key" \
-F "file=@frame1.png" \
-F "file=@frame2.png" \
-F "file=@frame3.png" \
-F "file=@frame4.png" \
-F 'settings={"columns": 2, "padding": 4, "format": "png"}'
```
## Example Response {#example-response}
```json
{
"jobId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"downloadUrl": "/api/v1/download/a1b2c3d4-e5f6-7890-abcd-ef1234567890/sprite-sheet.png",
"originalSize": 120000,
"processedSize": 95000,
"frames": [
{ "index": 0, "left": 0, "top": 0, "width": 128, "height": 128 },
{ "index": 1, "left": 132, "top": 0, "width": 128, "height": 128 },
{ "index": 2, "left": 0, "top": 132, "width": 128, "height": 128 },
{ "index": 3, "left": 132, "top": 132, "width": 128, "height": 128 }
],
"cols": 2,
"rows": 2,
"cellWidth": 128,
"cellHeight": 128,
"canvasWidth": 260,
"canvasHeight": 260
}
```
## Notes {#notes}
- 2 से 64 छवियाँ स्वीकार करता है। सभी छवियों को पहली अपलोड की गई छवि के आयामों से मिलान करने के लिए आकार बदला जाता है।
- `frames` ऐरे आउटपुट में प्रत्येक फ़्रेम के सटीक पिक्सेल कोऑर्डिनेट प्रदान करती है, जो CSS स्प्राइट परिभाषाओं या गेम इंजन फ़्रेम मैप के लिए उपयुक्त है।
- पंक्तियों की संख्या छवि गणना और `columns` मान से स्वचालित रूप से परिकलित होती है।
- कोशिकाओं के बीच स्पेसिंग जोड़ने के लिए `padding` पैरामीटर का उपयोग करें। `background` रंग पैडिंग क्षेत्रों और किसी भी खाली अनुगामी कोशिकाओं में दिखाई देता है।
- HEIC, RAW, PSD, और SVG इनपुट प्रोसेसिंग से पहले स्वचालित रूप से डिकोड किए जाते हैं।
+63
View File
@@ -0,0 +1,63 @@
---
description: "संरेखण, गैप, बॉर्डर, और रीसाइज़ मोड पर नियंत्रण के साथ छवियों को अगल-बगल, स्टैक्ड, या ग्रिड में जोड़ें।"
i18n_source_hash: 39333210505a
i18n_provenance: human
i18n_output_hash: 0b6117e2ecf1
---
# Stitch / Combine {#stitch-combine}
कई छवियों को अगल-बगल, लंबवत रूप से स्टैक्ड, या ग्रिड में व्यवस्थित करके जोड़ें। संरेखण, गैप, बॉर्डर, कॉर्नर रेडियस, और कई रीसाइज़ मोड का समर्थन करता है।
## API Endpoint {#api-endpoint}
`POST /api/v1/tools/image/stitch`
## Parameters {#parameters}
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| direction | string | No | `"horizontal"` | लेआउट दिशा: `horizontal`, `vertical`, `grid` |
| gridColumns | integer | No | 2 | जब दिशा `grid` हो तो स्तंभों की संख्या (2 से 100) |
| resizeMode | string | No | `"fit"` | छवियों का आकार कैसे बदला जाता है: `fit`, `original`, `stretch`, `crop` |
| alignment | string | No | `"center"` | क्रॉस-अक्ष संरेखण: `start`, `center`, `end` |
| gap | number | No | 0 | पिक्सेल में छवियों के बीच गैप (0 से 1000) |
| border | number | No | 0 | पिक्सेल में बाहरी बॉर्डर चौड़ाई (0 से 500) |
| cornerRadius | number | No | 0 | अंतिम आउटपुट पर लागू कॉर्नर रेडियस (0 से 500) |
| backgroundColor | string | No | `"#FFFFFF"` | हेक्स के रूप में बैकग्राउंड/बॉर्डर रंग (उदा. `#FF0000`) |
| format | string | No | `"png"` | आउटपुट फ़ॉर्मेट: `png`, `jpeg`, `webp`, `avif`, `jxl` |
| quality | number | No | 90 | आउटपुट गुणवत्ता (1 से 100) |
## Example Request {#example-request}
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/stitch \
-F "file=@image1.png" \
-F "file=@image2.png" \
-F "file=@image3.png" \
-F 'settings={"direction":"horizontal","resizeMode":"fit","gap":10,"backgroundColor":"#FFFFFF","format":"png"}'
```
## Example Response {#example-response}
```json
{
"jobId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"downloadUrl": "/api/v1/download/a1b2c3d4-e5f6-7890-abcd-ef1234567890/stitch.png",
"originalSize": 1234567,
"processedSize": 987654
}
```
## Notes {#notes}
- कम से कम 2 छवियों की आवश्यकता है। multipart अनुरोध में कई image फ़ाइलें अपलोड करें।
- HEIC, RAW, PSD, और SVG इनपुट फ़ॉर्मेट का समर्थन करता है (स्वचालित रूप से डिकोड)।
- रीसाइज़ मोड:
- `fit` - जोड़ने वाली अक्ष के साथ सबसे छोटे आयाम से मिलान करने के लिए छवियों को स्केल करें।
- `original` - मूल आकार रखें (असमान किनारे उत्पन्न कर सकता है)।
- `stretch` - आस्पेक्ट रेशियो को बनाए रखे बिना छवियों को सबसे छोटे आयाम से मिलान करने के लिए बाध्य करें।
- `crop` - सबसे छोटे आयाम से मिलान करने के लिए छवियों को कवर-क्रॉप करें।
- `grid` मोड में, कोशिकाओं को सभी छवियों के माध्यिका आयामों के अनुसार आकार दिया जाता है।
- `cornerRadius` पूरे अंतिम आउटपुट पर लागू होता है, न कि व्यक्तिगत छवियों पर।
- मेमोरी की थकावट को रोकने के लिए कैनवास आकार `MAX_CANVAS_PIXELS` सर्वर कॉन्फ़िगरेशन द्वारा सीमित है।
+113
View File
@@ -0,0 +1,113 @@
---
description: "गोपनीयता और छोटे फ़ाइल आकार के लिए छवियों से EXIF, GPS, ICC, और XMP मेटाडेटा हटाएँ।"
i18n_source_hash: e89147734fd0
i18n_provenance: human
i18n_output_hash: fec74f7b6c23
---
# Remove Metadata {#remove-metadata}
छवियों से EXIF, GPS, ICC कलर प्रोफ़ाइल, और XMP मेटाडेटा हटाएँ। गोपनीयता (GPS निर्देशांक, कैमरा जानकारी हटाना) और फ़ाइल आकार कम करने के लिए उपयोगी।
## API Endpoints {#api-endpoints}
### Strip Metadata {#strip-metadata}
`POST /api/v1/tools/image/strip-metadata`
छवि को प्रोसेस करता है और चयनित मेटाडेटा हटाए गए एक स्वच्छ संस्करण लौटाता है।
### Inspect Metadata {#inspect-metadata}
`POST /api/v1/tools/image/strip-metadata/inspect`
छवि को संशोधित किए बिना पार्स किए गए मेटाडेटा को JSON के रूप में लौटाता है। स्ट्रिपिंग से पहले कौन सा मेटाडेटा मौजूद है यह पूर्वावलोकन करने के लिए उपयोगी।
## Parameters (Strip) {#parameters-strip}
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| stripExif | boolean | No | `false` | EXIF डेटा हटाएँ (कैमरा सेटिंग्स, तिथियाँ, आदि) |
| stripGps | boolean | No | `false` | केवल GPS/स्थान डेटा हटाएँ |
| stripIcc | boolean | No | `false` | ICC कलर प्रोफ़ाइल हटाएँ |
| stripXmp | boolean | No | `false` | XMP मेटाडेटा हटाएँ (Adobe, IPTC) |
| stripAll | boolean | No | `true` | सारा मेटाडेटा एक साथ हटाएँ |
जब `stripAll` `true` हो, तो यह व्यक्तिगत फ़्लैग को ओवरराइड करता है और सब कुछ हटा देता है।
## Example Request {#example-request}
सारा मेटाडेटा हटाएँ:
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/strip-metadata \
-H "Authorization: Bearer si_your-api-key" \
-F "file=@photo.jpg" \
-F 'settings={"stripAll": true}'
```
केवल GPS डेटा हटाएँ (कैमरा जानकारी और कलर प्रोफ़ाइल रखें):
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/strip-metadata \
-H "Authorization: Bearer si_your-api-key" \
-F "file=@photo.jpg" \
-F 'settings={"stripAll": false, "stripGps": true}'
```
संशोधित किए बिना मेटाडेटा का निरीक्षण करें:
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/strip-metadata/inspect \
-H "Authorization: Bearer si_your-api-key" \
-F "file=@photo.jpg"
```
## Example Response (Strip) {#example-response-strip}
```json
{
"jobId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"downloadUrl": "/api/v1/download/a1b2c3d4-e5f6-7890-abcd-ef1234567890/photo.jpg",
"originalSize": 2450000,
"processedSize": 2380000
}
```
## Example Response (Inspect) {#example-response-inspect}
```json
{
"filename": "photo.jpg",
"fileSize": 2450000,
"exif": {
"Make": "Canon",
"Model": "EOS R5",
"DateTimeOriginal": "2024:03:15 14:30:00",
"ExposureTime": "1/250",
"FNumber": 2.8,
"ISO": 400
},
"gps": {
"GPSLatitudeRef": "N",
"GPSLatitude": [37, 46, 30],
"_latitude": 37.775,
"_longitude": -122.4183
},
"icc": {
"Profile Size": "3144 bytes",
"Color Space": "RGB",
"Description": "sRGB IEC61966-2.1"
},
"xmp": {
"CreatorTool": "Adobe Photoshop 25.0"
}
}
```
## Notes {#notes}
- स्ट्रिपिंग के बाद छवि को उसके मूल फ़ॉर्मेट में फिर से एन्कोड किया जाता है। JPEG गुणवत्ता 90 पर mozjpeg का उपयोग करता है, PNG कम्प्रेशन स्तर 9 का उपयोग करता है, WebP गुणवत्ता 85 का उपयोग करता है।
- यदि छवि को गैर-sRGB प्रोफ़ाइल के साथ टैग किया गया था तो ICC प्रोफ़ाइल हटाने से सूक्ष्म रंग बदलाव हो सकते हैं। यदि रंग सटीकता मायने रखती है तो `stripIcc: false` का उपयोग करें।
- इंस्पेक्ट एंडपॉइंट सुविधा के लिए GPS निर्देशांकों को दशमलव अक्षांश/देशांतर मानों (अंडरस्कोर से उपसर्गित) में पार्स करता है।
- समर्थित इनपुट फ़ॉर्मेट: JPEG, PNG, WebP, AVIF, TIFF, GIF।
+85
View File
@@ -0,0 +1,85 @@
---
description: "बैच समर्थन के साथ, कस्टम रिज़ॉल्यूशन और DPI पर SVG फ़ाइलों को PNG, JPEG, WebP, AVIF, TIFF, GIF, HEIF, या JXL में बदलें।"
i18n_source_hash: cf36830f8797
i18n_provenance: human
i18n_output_hash: 21a3f7b50714
---
# SVG to Raster {#svg-to-raster}
कस्टम रिज़ॉल्यूशन और DPI पर SVG फ़ाइलों को रास्टर छवि फ़ॉर्मेट (PNG, JPEG, WebP, AVIF, TIFF, GIF, HEIF, या JXL) में बदलें। कई SVG के बैच रूपांतरण का भी समर्थन करता है।
## API Endpoint {#api-endpoint}
`POST /api/v1/tools/image/svg-to-raster`
## Parameters {#parameters}
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| width | integer | No | - | पिक्सेल में लक्ष्य चौड़ाई (1 से 65536)। यदि केवल एक आयाम सेट है तो आस्पेक्ट रेशियो बनाए रखता है। |
| height | integer | No | - | पिक्सेल में लक्ष्य ऊँचाई (1 से 65536)। यदि केवल एक आयाम सेट है तो आस्पेक्ट रेशियो बनाए रखता है। |
| dpi | integer | No | 300 | रेंडर DPI, आधार रास्टराइज़ेशन घनत्व को नियंत्रित करता है (36 से 2400) |
| quality | number | No | 90 | लॉसी फ़ॉर्मेट के लिए आउटपुट गुणवत्ता (1 से 100) |
| backgroundColor | string | No | `"#00000000"` | हेक्स के रूप में बैकग्राउंड रंग (6 या 8 वर्ण, 8-वर्ण में अल्फ़ा शामिल है) |
| outputFormat | string | No | `"png"` | आउटपुट फ़ॉर्मेट: `png`, `jpg`, `webp`, `avif`, `tiff`, `gif`, `heif`, `jxl` |
## Example Request {#example-request}
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/svg-to-raster \
-F "file=@logo.svg" \
-F 'settings={"width":1024,"dpi":300,"outputFormat":"png","backgroundColor":"#FFFFFF"}'
```
## Example Response {#example-response}
```json
{
"jobId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"downloadUrl": "/api/v1/download/a1b2c3d4-e5f6-7890-abcd-ef1234567890/logo.png",
"previewUrl": "/api/v1/download/a1b2c3d4-e5f6-7890-abcd-ef1234567890/preview.webp",
"originalSize": 12345,
"processedSize": 67890
}
```
## Batch Endpoint {#batch-endpoint}
`POST /api/v1/tools/image/svg-to-raster/batch`
एक अनुरोध में कई SVG फ़ाइलों को बदलें। एक ZIP आर्काइव लौटाता है।
### Additional Batch Parameters {#additional-batch-parameters}
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| clientJobId | string | No | - | प्रगति ट्रैकिंग के लिए वैकल्पिक क्लाइंट-प्रदत्त जॉब ID (अधिकतम 128 वर्ण) |
### Batch Example Request {#batch-example-request}
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/svg-to-raster/batch \
-F "file=@icon1.svg" \
-F "file=@icon2.svg" \
-F "file=@icon3.svg" \
-F 'settings={"width":512,"outputFormat":"png","dpi":150}'
```
### Batch Response {#batch-response}
बैच एंडपॉइंट हेडर के साथ सीधे एक ZIP फ़ाइल स्ट्रीम करता है:
- `Content-Type: application/zip`
- `X-Job-Id: <jobId>`
- `X-File-Results: <url-encoded JSON mapping of index to filename>`
## Notes {#notes}
- केवल SVG और SVGZ फ़ाइलें स्वीकार करता है (केवल एक्सटेंशन नहीं, बल्कि कंटेंट को मान्य करता है)। SVGZ स्वचालित रूप से डीकम्प्रेस हो जाता है।
- XSS और बाहरी संसाधन लोडिंग को रोकने के लिए रेंडरिंग से पहले SVG कंटेंट को सैनिटाइज़ किया जाता है।
- `dpi` सेटिंग उस घनत्व को नियंत्रित करती है जिस पर SVG को रास्टराइज़ किया जाता है। उच्च DPI उसी SVG व्यूपोर्ट से बड़े पिक्सेल आयाम उत्पन्न करता है।
- जब `width` और `height` दोनों प्रदान किए जाते हैं, तो छवि को `fit: inside` का उपयोग करके आकार बदला जाता है (सीमाओं के भीतर आस्पेक्ट रेशियो बनाए रखता है)।
- उन फ़ॉर्मेट के लिए जिन्हें ब्राउज़र मूल रूप से प्रदर्शित नहीं कर सकते (TIFF, HEIF), प्रतिक्रिया में एक `previewUrl` शामिल किया जाता है। पूर्वावलोकन एक 1200px WebP थंबनेल है।
- डिफ़ॉल्ट बैकग्राउंड `#00000000` पूरी तरह पारदर्शी है। सफ़ेद बैकग्राउंड के लिए `#FFFFFF` पर सेट करें (JPEG आउटपुट के साथ उपयोगी जो पारदर्शिता का समर्थन नहीं करता)।
- बैच प्रोसेसिंग `MAX_BATCH_SIZE` सर्वर कॉन्फ़िगरेशन का सम्मान करती है और प्रदर्शन के लिए समवर्ती वर्कर्स का उपयोग करती है।
- बैच ऑपरेशन की प्रगति को `/api/v1/jobs/:jobId/progress` पर SSE के माध्यम से ट्रैक किया जा सकता है।
+66
View File
@@ -0,0 +1,66 @@
---
description: "ड्रॉप शैडो और बैकग्राउंड बॉक्स के साथ स्टाइल किए गए टेक्स्ट ओवरले जोड़ें।"
i18n_source_hash: 9f8e697188fc
i18n_provenance: human
i18n_output_hash: 54ad7e2be905
---
# Text Overlay {#text-overlay}
वैकल्पिक ड्रॉप शैडो और अर्ध-पारदर्शी बैकग्राउंड बॉक्स के साथ छवियों में स्टाइल किया गया टेक्स्ट जोड़ें। फ़ोटो पर शीर्षकों, कैप्शन, या एनोटेशन के लिए उपयुक्त।
## API Endpoint {#api-endpoint}
`POST /api/v1/tools/image/text-overlay`
एक image फ़ाइल और एक JSON `settings` फ़ील्ड के साथ multipart फ़ॉर्म डेटा स्वीकार करता है।
## Parameters {#parameters}
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| text | string | Yes | - | ओवरले करने के लिए टेक्स्ट (1 से 500 वर्ण) |
| fontSize | number | No | `48` | पिक्सेल में फ़ॉन्ट आकार (8 से 200) |
| color | string | No | `"#FFFFFF"` | हेक्स फ़ॉर्मेट में टेक्स्ट रंग (`#RRGGBB`) |
| position | string | No | `"bottom"` | लंबवत स्थान: `top`, `center`, `bottom` |
| backgroundBox | boolean | No | `false` | टेक्स्ट के पीछे एक अर्ध-पारदर्शी बैकग्राउंड आयत दिखाएँ |
| backgroundColor | string | No | `"#000000"` | हेक्स फ़ॉर्मेट में बैकग्राउंड बॉक्स रंग (`#RRGGBB`) |
| shadow | boolean | No | `true` | टेक्स्ट के पीछे एक ड्रॉप शैडो लागू करें |
## Example Request {#example-request}
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/text-overlay \
-H "Authorization: Bearer si_your-api-key" \
-F "file=@photo.jpg" \
-F 'settings={"text": "Hello World", "fontSize": 64, "color": "#FFFFFF", "position": "bottom", "shadow": true}'
```
बैकग्राउंड बॉक्स के साथ:
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/text-overlay \
-H "Authorization: Bearer si_your-api-key" \
-F "file=@photo.jpg" \
-F 'settings={"text": "Caption", "fontSize": 36, "position": "bottom", "backgroundBox": true, "backgroundColor": "#000000"}'
```
## Example Response {#example-response}
```json
{
"jobId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"downloadUrl": "/api/v1/download/a1b2c3d4-e5f6-7890-abcd-ef1234567890/photo.jpg",
"originalSize": 2450000,
"processedSize": 2470000
}
```
## Notes {#notes}
- टेक्स्ट हमेशा छवि के भीतर क्षैतिज रूप से केंद्रित होता है।
- ड्रॉप शैडो 70% काली अपारदर्शिता पर 3px ब्लर के साथ 2px ऑफ़सेट का उपयोग करता है।
- बैकग्राउंड बॉक्स 70% अपारदर्शिता पर पूरी छवि चौड़ाई में फैला होता है, जिसकी ऊँचाई फ़ॉन्ट आकार के समानुपाती (1.8x) होती है।
- टेक्स्ट को SVG कंपोजिट के माध्यम से रेंडर किया जाता है, इसलिए सिस्टम का डिफ़ॉल्ट sans-serif फ़ॉन्ट उपयोग किया जाता है।
- टेक्स्ट में XML-विशेष वर्णों को सुरक्षित रूप से एस्केप किया जाता है।
- आउटपुट फ़ॉर्मेट इनपुट फ़ॉर्मेट से मेल खाता है। HEIC, RAW, PSD, और SVG इनपुट प्रोसेसिंग से पहले स्वचालित रूप से डिकोड किए जाते हैं।
@@ -0,0 +1,78 @@
---
description: "नकली पारदर्शी PNG को AI मैटिंग (BiRefNet) से ठीक करें ताकि वास्तविक अल्फ़ा उत्पन्न हो, साथ ही डिफ्रिंज एज सफ़ाई।"
i18n_source_hash: 7eb748b80f93
i18n_provenance: human
i18n_output_hash: 20c39a491e3d
---
# PNG Transparency Fixer {#png-transparency-fixer}
एक क्लिक में नकली पारदर्शी PNG को ठीक करें। वास्तविक अल्फ़ा पारदर्शिता उत्पन्न करने के लिए AI मैटिंग (BiRefNet HR Matting मॉडल) का उपयोग करता है, किनारों को साफ़ करने के लिए डिफ्रिंज पोस्ट-प्रोसेसिंग के साथ।
## API Endpoint {#api-endpoint}
`POST /api/v1/tools/image/transparency-fixer`
**Processing:** असिंक्रोनस (202 लौटाता है, SSE के माध्यम से स्थिति के लिए `/api/v1/jobs/{jobId}/progress` को पोल करें)
**Model bundle:** `background-removal` (4-5 GB)
## Parameters {#parameters}
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| file | file | Yes | - | Image फ़ाइल (multipart) |
| defringe | number | No | `30` | डिफ्रिंज तीव्रता (0-100)। किनारों के चारों ओर अर्ध-पारदर्शी फ्रिंज पिक्सेल हटाता है |
| outputFormat | string | No | `"png"` | आउटपुट फ़ॉर्मेट: `png` या `webp` |
| removeWatermark | boolean | No | `false` | वॉटरमार्क हटाने की प्री-प्रोसेसिंग लागू करें (median filter) |
## Example Request {#example-request}
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/transparency-fixer \
-F "file=@fake-transparent.png" \
-F 'settings={"defringe":40,"outputFormat":"png"}'
```
## Response {#response}
### Initial Response (202 Accepted) {#initial-response-202-accepted}
```json
{
"jobId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"async": true
}
```
### Progress (SSE at `/api/v1/jobs/{jobId}/progress`) {#progress-sse-at-api-v1-jobs-jobid-progress}
```
event: progress
data: {"phase":"processing","stage":"Processing transparency...","percent":50}
```
### Final Result (via SSE) {#final-result-via-sse}
```json
{
"phase": "complete",
"percent": 100,
"result": {
"jobId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"downloadUrl": "/api/v1/download/{jobId}/fake-transparent_fixed.png",
"originalSize": 180000,
"processedSize": 150000,
"filename": "fake-transparent.png"
}
}
```
## Notes {#notes}
- `background-removal` मॉडल बंडल (4-5 GB) इंस्टॉल होना आवश्यक है।
- उच्च-गुणवत्ता वाली अल्फ़ा मैटिंग के लिए प्राथमिक मॉडल के रूप में `birefnet-hr-matting` का उपयोग करता है। यदि HR मॉडल की मेमोरी समाप्त हो जाती है तो `birefnet-general` पर वापस चला जाता है।
- `defringe` विकल्प अर्ध-पारदर्शी फ्रिंज पिक्सेल हटाता है जिन्हें AI मैटिंग कभी-कभी बालों, फ़र, और बारीक किनारों के चारों ओर छोड़ देती है। यह अल्फ़ा चैनल को ब्लर करके और कम-कॉन्फ़िडेंस पिक्सेल को शून्य करके काम करता है।
- `removeWatermark` विकल्प एक median filter प्री-प्रोसेसिंग चरण लागू करता है। यह एक बुनियादी वॉटरमार्क कमी है, न कि एक समर्पित वॉटरमार्क हटाने वाला टूल।
- केवल PNG या lossless WebP आउटपुट करता है (दोनों अल्फ़ा पारदर्शिता का समर्थन करते हैं)।
- स्वचालित डिकोडिंग के माध्यम से HEIC/HEIF, RAW, TGA, PSD, EXR, और HDR इनपुट फ़ॉर्मेट का समर्थन करता है।
+83
View File
@@ -0,0 +1,83 @@
---
description: "बारीक विवरण को संरक्षित करते हुए Real-ESRGAN AI सुपर-रिज़ॉल्यूशन के साथ छवियों को 2x से 4x तक अपस्केल करें।"
i18n_source_hash: 150032e99476
i18n_provenance: human
i18n_output_hash: cab014c91ae8
---
# Image Upscaling {#image-upscaling}
Real-ESRGAN का उपयोग करके AI सुपर-रिज़ॉल्यूशन संवर्धन। विवरण को संरक्षित करते हुए छवियों को 2x-4x तक अपस्केल करता है।
## API Endpoint {#api-endpoint}
`POST /api/v1/tools/image/upscale`
**Processing:** असिंक्रोनस (202 लौटाता है, SSE के माध्यम से स्थिति के लिए `/api/v1/jobs/{jobId}/progress` को पोल करें)
**Model bundle:** `upscale-enhance` (5-6 GB)
## Parameters {#parameters}
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| file | file | Yes | - | Image फ़ाइल (multipart) |
| scale | number | No | `2` | अपस्केल फ़ैक्टर (उदा., 2, 3, 4) |
| model | string | No | `"auto"` | उपयोग करने के लिए मॉडल (उदा., `auto`, विशिष्ट मॉडल नाम) |
| faceEnhance | boolean | No | `false` | अपस्केलिंग के दौरान फ़ेस एन्हांसमेंट लागू करें |
| denoise | number | No | `0` | डीनॉइज़िंग स्ट्रेंथ (0 = बंद) |
| format | string | No | `"auto"` | आउटपुट फ़ॉर्मेट: `auto`, `png`, `jpg`, `webp`, `tiff`, `gif`, `avif`, `heic`, `heif`, `jxl` |
| quality | number | No | `95` | आउटपुट गुणवत्ता (1-100) |
## Example Request {#example-request}
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/upscale \
-F "file=@photo.jpg" \
-F 'settings={"scale":4,"model":"auto","faceEnhance":true,"format":"png"}'
```
## Response {#response}
### Initial Response (202 Accepted) {#initial-response-202-accepted}
```json
{
"jobId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"async": true
}
```
### Progress (SSE at `/api/v1/jobs/{jobId}/progress`) {#progress-sse-at-api-v1-jobs-jobid-progress}
```
event: progress
data: {"phase":"processing","stage":"Upscaling...","percent":60}
```
### Final Result (via SSE) {#final-result-via-sse}
```json
{
"phase": "complete",
"percent": 100,
"result": {
"jobId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"downloadUrl": "/api/v1/download/{jobId}/photo_4x.png",
"previewUrl": "/api/v1/download/{jobId}/preview.webp",
"originalSize": 120000,
"processedSize": 2400000,
"width": 4096,
"height": 4096,
"method": "realesrgan-x4plus"
}
}
```
## Notes {#notes}
- `upscale-enhance` मॉडल बंडल (5-6 GB) इंस्टॉल होना आवश्यक है।
- उपलब्ध होने पर Real-ESRGAN का उपयोग करता है; यदि AI मॉडल अनुपलब्ध है तो Lanczos इंटरपोलेशन पर वापस चला जाता है।
- बेहतर फ़ेस गुणवत्ता के लिए `faceEnhance` विकल्प अपस्केलिंग के दौरान GFPGAN फ़ेस रीस्टोरेशन लागू करता है।
- गैर-ब्राउज़र-पूर्वावलोकन योग्य आउटपुट फ़ॉर्मेट (HEIC, JXL, TIFF) के लिए, मुख्य आउटपुट के साथ एक WebP पूर्वावलोकन उत्पन्न किया जाता है।
- स्वचालित डिकोडिंग के माध्यम से HEIC/HEIF, RAW, TGA, PSD, EXR, और HDR इनपुट फ़ॉर्मेट का समर्थन करता है।
+64
View File
@@ -0,0 +1,64 @@
---
description: "श्वेत-श्याम (potrace) और पूर्ण-रंगीन मल्टी-लेयर वेक्टराइज़ेशन के साथ रास्टर छवियों को SVG में बदलें।"
i18n_source_hash: f3e4777188ad
i18n_provenance: human
i18n_output_hash: 9d966cbf2872
---
# Image to SVG {#image-to-svg}
ट्रेसिंग एल्गोरिदम का उपयोग करके रास्टर छवियों को SVG में वेक्टराइज़ करें। श्वेत-श्याम ट्रेसिंग (potrace) और पूर्ण-रंगीन मल्टी-लेयर वेक्टराइज़ेशन का समर्थन करता है।
## API Endpoint {#api-endpoint}
`POST /api/v1/tools/image/vectorize`
## Parameters {#parameters}
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| colorMode | string | No | `"bw"` | ट्रेसिंग मोड: `bw` (श्वेत और श्याम) या `color` (मल्टी-कलर लेयर) |
| threshold | number | No | 128 | B&W मोड के लिए चमक थ्रेशोल्ड (0 से 255)। इससे नीचे के पिक्सेल काले हो जाते हैं। |
| colorPrecision | number | No | 6 | कलर मोड के लिए कलर क्वांटाइज़ेशन परिशुद्धता (1 से 16)। उच्च मान अधिक विशिष्ट कलर लेयर उत्पन्न करते हैं। |
| layerDifference | number | No | 6 | कलर मोड में लेयर के बीच न्यूनतम कलर अंतर (1 से 128) |
| filterSpeckle | number | No | 4 | पिक्सेल में ट्रेस किए गए आकारों के लिए न्यूनतम क्षेत्रफल (1 से 256)। शोर/धब्बे हटाता है। |
| pathMode | string | No | `"spline"` | पथ स्मूदिंग: `none` (दांतेदार), `polygon` (सीधे खंड), `spline` (स्मूद वक्र) |
| cornerThreshold | number | No | 60 | कलर मोड में कॉर्नर डिटेक्शन के लिए कोण थ्रेशोल्ड (0 से 180 डिग्री) |
| invert | boolean | No | `false` | ट्रेसिंग से पहले छवि को उलटें (काला/सफ़ेद अदला-बदली) |
## Example Request {#example-request}
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/vectorize \
-F "file=@logo.png" \
-F 'settings={"colorMode":"bw","threshold":128,"filterSpeckle":4,"pathMode":"spline"}'
```
### Color Vectorization {#color-vectorization}
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/vectorize \
-F "file=@illustration.png" \
-F 'settings={"colorMode":"color","colorPrecision":8,"layerDifference":6,"filterSpeckle":4}'
```
## Example Response {#example-response}
```json
{
"jobId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"downloadUrl": "/api/v1/download/a1b2c3d4-e5f6-7890-abcd-ef1234567890/logo.svg",
"originalSize": 45678,
"processedSize": 12345
}
```
## Notes {#notes}
- इनपुट फ़ॉर्मेट की परवाह किए बिना आउटपुट हमेशा एक SVG फ़ाइल होता है।
- HEIC, RAW, PSD, और SVG इनपुट फ़ॉर्मेट का समर्थन करता है (ट्रेसिंग से पहले स्वचालित रूप से रास्टर में डिकोड किया जाता है)।
- B&W मोड potrace एल्गोरिदम का उपयोग करता है। छवि को पहले ग्रेस्केल में बदला जाता है, फिर ट्रेसिंग से पहले शुद्ध काले/सफ़ेद में थ्रेशोल्ड किया जाता है।
- कलर मोड एक मल्टी-लेयर दृष्टिकोण का उपयोग करता है: छवि को कलर लेयर में क्वांटाइज़ किया जाता है, प्रत्येक को अलग से ट्रेस किया जाता है और SVG आउटपुट में स्टैक किया जाता है।
- कम `filterSpeckle` मान अधिक विवरण संरक्षित करते हैं लेकिन अधिक पथों के साथ बड़ी SVG फ़ाइलें उत्पन्न करते हैं।
- `pathMode` सेटिंग फ़ाइल आकार को महत्वपूर्ण रूप से प्रभावित करती है: `none` सबसे अधिक पथ उत्पन्न करता है, `spline` सबसे स्मूद (और आमतौर पर सबसे छोटा) आउटपुट उत्पन्न करता है।
- लोगो और आइकन के साथ सर्वोत्तम परिणामों के लिए, स्वच्छ हाई-कॉन्ट्रास्ट इनपुट के साथ B&W मोड का उपयोग करें। फ़ोटोग्राफ़ या चित्रण के लिए, उच्च `colorPrecision` के साथ कलर मोड का उपयोग करें।
+55
View File
@@ -0,0 +1,55 @@
---
description: "समायोज्य स्ट्रेंथ, रंग, और स्थिति के साथ एक विग्नेट प्रभाव जोड़ें।"
i18n_source_hash: 0b9795fea2eb
i18n_provenance: human
i18n_output_hash: bae6049a2d7c
---
# Vignette {#vignette}
एक विग्नेट प्रभाव जोड़ें जो छवि के किनारों को गहरा करता है या टिंट करता है। समायोज्य स्ट्रेंथ, रंग, रेडियस, सॉफ़्टनेस, राउंडनेस, और केंद्र स्थिति का समर्थन करता है।
## API Endpoint {#api-endpoint}
`POST /api/v1/tools/image/vignette`
एक image फ़ाइल और एक JSON `settings` फ़ील्ड के साथ multipart फ़ॉर्म डेटा स्वीकार करता है।
## Parameters {#parameters}
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| strength | number | No | `0.5` | विग्नेट अपारदर्शिता (0.1-1) |
| color | string | No | `"#000000"` | विग्नेट हेक्स रंग |
| radius | integer | No | `70` | आधे-विकर्ण के प्रतिशत के रूप में बाहरी रेडियस (0-100) |
| softness | integer | No | `50` | फ़ेदर सॉफ़्टनेस (0-100); उच्च मान अधिक क्रमिक फ़ेड उत्पन्न करते हैं |
| roundness | integer | No | `100` | आकार: 100 = वृत्त, 0 = छवि आस्पेक्ट रेशियो से मेल खाने वाला दीर्घवृत्त |
| centerX | integer | No | `50` | प्रतिशत के रूप में क्षैतिज केंद्र स्थिति (0-100) |
| centerY | integer | No | `50` | प्रतिशत के रूप में लंबवत केंद्र स्थिति (0-100) |
## Example Request {#example-request}
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/vignette \
-H "Authorization: Bearer si_your-api-key" \
-F "file=@photo.jpg" \
-F 'settings={"strength": 0.7, "radius": 60, "softness": 70}'
```
## Example Response {#example-response}
```json
{
"jobId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"downloadUrl": "/api/v1/download/a1b2c3d4-e5f6-7890-abcd-ef1234567890/photo.jpg",
"originalSize": 2450000,
"processedSize": 2410000
}
```
## Notes {#notes}
- छोटा `radius` छवि का अधिक भाग गहरा करता है; बड़ा रेडियस विग्नेट को अत्यधिक किनारों तक सीमित करता है।
- रचनात्मक विग्नेट प्रभावों के लिए गैर-काले `color` (उदा., सफ़ेद या सेपिया टोन) का उपयोग करें।
- `centerX` और `centerY` को समायोजित करने से आप स्पष्ट क्षेत्र को केंद्र से हटकर रख सकते हैं, जो फ़्रेम के बीच में न होने वाले किसी सब्जेक्ट पर फ़ोकस लाने के लिए उपयोगी है।
- आउटपुट फ़ॉर्मेट इनपुट फ़ॉर्मेट से मेल खाता है। HEIC, RAW, PSD, और SVG इनपुट प्रोसेसिंग से पहले स्वचालित रूप से डिकोड किए जाते हैं।
@@ -0,0 +1,61 @@
---
description: "कॉन्फ़िगर करने योग्य स्थिति, अपारदर्शिता, और स्केल के साथ एक लोगो या छवि को वॉटरमार्क के रूप में ओवरले करें।"
i18n_source_hash: c73ab0ef8ab9
i18n_provenance: human
i18n_output_hash: 197b4c889768
---
# Image Watermark {#image-watermark}
एक बेस छवि पर एक लोगो या द्वितीयक छवि को वॉटरमार्क के रूप में ओवरले करें। वॉटरमार्क को बेस छवि की चौड़ाई के सापेक्ष स्केल किया जाता है और किसी कोने या केंद्र पर स्थित किया जाता है।
## API Endpoint {#api-endpoint}
`POST /api/v1/tools/image/watermark-image`
**दो** image फ़ाइलों और एक JSON `settings` फ़ील्ड के साथ multipart फ़ॉर्म डेटा स्वीकार करता है।
## Parameters {#parameters}
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| position | string | No | `"bottom-right"` | वॉटरमार्क स्थान: `center`, `top-left`, `top-right`, `bottom-left`, `bottom-right` |
| opacity | number | No | `50` | वॉटरमार्क अपारदर्शिता प्रतिशत (0 से 100) |
| scale | number | No | `25` | मुख्य छवि चौड़ाई के प्रतिशत के रूप में वॉटरमार्क चौड़ाई (1 से 100) |
### File Fields {#file-fields}
| Field Name | Required | Description |
|------------|----------|-------------|
| file | Yes | मुख्य/बेस छवि |
| watermark | Yes | वॉटरमार्क/लोगो छवि |
## Example Request {#example-request}
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/watermark-image \
-H "Authorization: Bearer si_your-api-key" \
-F "file=@photo.jpg" \
-F "watermark=@logo.png" \
-F 'settings={"position": "bottom-right", "opacity": 60, "scale": 20}'
```
## Example Response {#example-response}
```json
{
"jobId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"downloadUrl": "/api/v1/download/a1b2c3d4-e5f6-7890-abcd-ef1234567890/photo.jpg",
"originalSize": 2450000,
"processedSize": 2520000
}
```
## Notes {#notes}
- दोनों छवियों को मान्य और डिकोड किया जाता है (HEIC, RAW, PSD, SVG समर्थित)।
- वॉटरमार्क को समानुपातिक रूप से आकार बदला जाता है ताकि इसकी चौड़ाई मुख्य छवि चौड़ाई के `scale`% के बराबर हो।
- अपारदर्शिता को `dest-in` ब्लेंडिंग के साथ कंपोजिट किए गए अल्फ़ा मास्क के माध्यम से लागू किया जाता है।
- कोने की स्थितियाँ छवि किनारे से 20px पैडिंग का उपयोग करती हैं।
- यदि वॉटरमार्क छवि में पारदर्शिता है (उदा., एक PNG लोगो), तो कंपोजिटिंग के दौरान इसे संरक्षित किया जाता है।
- प्रोसेसिंग से पहले दोनों छवियों पर EXIF ओरिएंटेशन स्वचालित रूप से लागू होता है।
@@ -0,0 +1,65 @@
---
description: "कॉन्फ़िगर करने योग्य स्थिति, अपारदर्शिता, रोटेशन, और टाइलिंग के साथ टेक्स्ट वॉटरमार्क जोड़ें।"
i18n_source_hash: b80f12f410e4
i18n_provenance: human
i18n_output_hash: 492db576f493
---
# Text Watermark {#text-watermark}
छवियों में एक टेक्स्ट वॉटरमार्क ओवरले जोड़ें। कोनों/केंद्र पर एकल स्थान या पूरी छवि में टाइल की गई पुनरावृत्ति का समर्थन करता है, जिसमें कॉन्फ़िगर करने योग्य फ़ॉन्ट आकार, रंग, अपारदर्शिता, और रोटेशन होता है।
## API Endpoint {#api-endpoint}
`POST /api/v1/tools/image/watermark-text`
एक image फ़ाइल और एक JSON `settings` फ़ील्ड के साथ multipart फ़ॉर्म डेटा स्वीकार करता है।
## Parameters {#parameters}
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| text | string | Yes | - | वॉटरमार्क टेक्स्ट (1 से 500 वर्ण) |
| fontSize | number | No | `48` | पिक्सेल में फ़ॉन्ट आकार (8 से 1000) |
| color | string | No | `"#000000"` | हेक्स फ़ॉर्मेट में टेक्स्ट रंग (`#RRGGBB`) |
| opacity | number | No | `50` | टेक्स्ट अपारदर्शिता प्रतिशत (0 से 100) |
| position | string | No | `"center"` | स्थान: `center`, `top-left`, `top-right`, `bottom-left`, `bottom-right`, `tiled` |
| rotation | number | No | `0` | डिग्री में टेक्स्ट रोटेशन कोण (-360 से 360) |
## Example Request {#example-request}
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/watermark-text \
-H "Authorization: Bearer si_your-api-key" \
-F "file=@photo.jpg" \
-F 'settings={"text": "SAMPLE", "fontSize": 64, "opacity": 30, "position": "center", "rotation": -30}'
```
पूरी छवि में टाइल किया गया वॉटरमार्क:
```bash
curl -X POST http://localhost:1349/api/v1/tools/image/watermark-text \
-H "Authorization: Bearer si_your-api-key" \
-F "file=@photo.jpg" \
-F 'settings={"text": "DRAFT", "fontSize": 36, "opacity": 20, "position": "tiled", "rotation": -45}'
```
## Example Response {#example-response}
```json
{
"jobId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"downloadUrl": "/api/v1/download/a1b2c3d4-e5f6-7890-abcd-ef1234567890/photo.jpg",
"originalSize": 2450000,
"processedSize": 2480000
}
```
## Notes {#notes}
- वॉटरमार्क को SVG टेक्स्ट के रूप में रेंडर किया जाता है और छवि पर कंपोजिट किया जाता है, जिससे आउटपुट गुणवत्ता संरक्षित रहती है।
- टाइल्ड मोड फ़ॉन्ट आकार (6x क्षैतिज, 4x लंबवत स्पेसिंग) के आधार पर टेक्स्ट तत्वों को स्थान देता है, जो अधिकतम 500 तत्वों पर सीमित है।
- कोने की स्थितियों के लिए, किनारे से पैडिंग फ़ॉन्ट आकार के बराबर होती है।
- उपयोग किया गया फ़ॉन्ट सिस्टम का डिफ़ॉल्ट sans-serif फ़ॉन्ट है।
- टेक्स्ट में XML-विशेष वर्णों (`&`, `<`, `>`, `"`, `'`) को सुरक्षित रूप से एस्केप किया जाता है।
- आउटपुट फ़ॉर्मेट इनपुट फ़ॉर्मेट से मेल खाता है। HEIC, RAW, PSD, और SVG इनपुट प्रोसेसिंग से पहले स्वचालित रूप से डिकोड किए जाते हैं।