# समय बाकस उपकरण: कंसोल छवि
2026-01-24T12:00
> **आकार का उपयोग करते हुए एक ग्लाइफ-आधारित टर्मिनल रेंडररName**
> [](https://www.nuget.org/packages/mostlylucid.consoleimage/)
> [](https://unlicense.org)
> [](https://github.com/scottgal/mostlylucid.consoleimage/releases)
*लक्ष्य पिक्सेल सटीकता नहीं है*
## परिचय
यह मेरी एक "timeM SK1boxed"tools का एक है। मैं सीमित समय के अभ्यास के रूप में निर्माण की छोटी परियोजनाएँ करता हूँ।
इस विशेष परियोजना शुरू हुई जब मुझे पता चला कि [Alex Harri' को ASCII रेंडरिंग पर उत्कृष्ट लेख](https://alexharri.com/blog/ascii-rendering)आकार के बारे में उनका दृष्टिकोण---साधारण चमकतापन नक्शेचित्रण की बजाय अनुरूप होना आकर्षक था-,-और मैंने सोचा कि मैं इसे सी में बना सकता हूँ-M SK4-जो एक सरल ASCII छवि दर्शक के रूप में शुरू हुआ वह एक टर्मिनल ग्राफिक्स सिस्टम में विकसित हो गया जिसमें कई रेंडरिंग मोडें हैं-MSC5-वीडियो समर्थन-MST6 और यहां तक कि एक एआई एकीकृत परत-MSP7
पूरा स्रोत कोड GitHub पर उपलब्ध है [https://github≥.com/scottgalM SK3mostlylucidMSC4consoleimage](https://github.com/scottgal/mostlylucid.consoleimage)
**नवीनतम संस्करण डाउनलोड करें** [GitHub प्रकाशन](https://github.com/scottgal/mostlylucid.consoleimage/releases)
**नूगेट पैकेज**
- [`mostlylucid.consoleimage`](https://www.nuget.org/packages/mostlylucid.consoleimage/) Core रेंडरिंग लाइब्रेरी
- [`mostlylucid.consoleimage.video`](https://www.nuget.org/packages/mostlylucid.consoleimage.video/) वीडियो समर्थन
- [`mostlylucid.consoleimage.transcription`](https://www.nuget.org/packages/mostlylucid.consoleimage.transcription/) - हिस्पर ट्रांस्क्रिप्शन
- [`mostlylucid.consoleimage.player`](https://www.nuget.org/packages/mostlylucid.consoleimage.player/) दस्तावेज़ प्लेबैक
- [`mostlylucid.consoleimage.player.spectre`](https://www.nuget.org/packages/mostlylucid.consoleimage.player.spectre/) - स्पेक्ट्र
- [`mostlylucid.consoleimage.spectre`](https://www.nuget.org/packages/mostlylucid.consoleimage.spectre/) स्पेक्ट्र
## त्वरित प्रारंभ
कंसोल इमेज एक एकल सीएलआई है जो मीडिया को ग्लाइफ में बदलता है
### संस्थापित करें
आरंभ करने के लिए सबसे आसान तरीका यह है कि से नवीनतम जारी बाइनरी डाउनलोड करें [GitHub प्रकाशन](https://github.com/scottgal/mostlylucid.consoleimage/releases) और सुनिश्चित करें `consoleimage` आपके पर है `PATH`.
```bash
consoleimage photo.jpg
consoleimage "https://youtu.be/dQw4w9WgXcQ" --subs whisper
```
[TOC]
## यूट्यूब में नया v4.0:
कंसोल इमेज शांत रूप से एक पूर्ण टर्मिनल मीडिया प्लेयर में विकसित हो गया है।
### Zero-Setup स्वतः डाउनलोड
dependencies are pulled down on first use and cached locally, so new features work without manual installs
अवयव | प्रथम डाउनलोड ट्रिगर
|-----------|------------------------|----------------|
FFmpeg First video playback `~/.local/share/consoleimage/ffmpeg/` |
पहला यूट्यूब यूआरएल `~/.local/share/consoleimage/ytdlp/` |
| फुसफुसाएँ रनटाइम `--subs whisper` | `~/.local/share/consoleimage/whisper/runtimes/` |
| छिपकाएँ मॉडल | | | पहला ट्रांस्क्रिप्शन `~/.local/share/consoleimage/whisper/` |
विंडोज़ , कैशों के नीचे रहते हैं `%LOCALAPPDATA%\consoleimage\`.
मैकओएस पर कैश आपके उपयोक्ता के नीचे रहते हैं `~/Library/Application Support/consoleimage/`).
उपयोग करें `-y` / `--yes` सभी डाउनलोडों को सत्यापित करें.
### यूट्यूब प्लेबैक
यूट्यूब यूआरएल वाईटी के माध्यम से टर्मिनल में सीधे बजाते हैं
का अर्थ यह है कि वही मोडें लागू होती हैं, चौड़ाईयाँ, और आउटपुट प्रारूप चाहे आप सीधी देख रहे हों या क्लिप को सहेज रहे हों
एक पसंदीदा yt है
### उपशीर्षक और प्रत्यक्ष अनुवाद
उपशीर्षक तीन स्रोतों से आते हैं
15-सेकेंड खंडों में पृष्ठभूमि `.vtt` फ़ाइलें तो पुनरावृत्ति मौज़ूद हैं. यह समर्थन करता है
कई मॉडल आकारों, भाषा चयन, और होस्टेड अंतबिंदुओं के लिए आप सटीकता के लिए गति का व्यापार कर सकते हैं या काम को ऑफलोड
ट्रांस्क्रिप्ट-केवल आउटपुट भी समर्थित है, जो कंसोल इमेज को एक उपशीर्षक जेनेरेटर में परिवर्तित करता है जो अन्य उपकरणों को फ़ीड कर सकता है
वीडियो रेंडरिंग के बिना
### स्लाइड शो मोड
इसे एक फ़ोल्डर पर इंगित करें और यह कुंजीपटल नियंत्रणों के साथ एक छवि स्लाइड शो बन जाता है
अग्रिम
## सरल दृश्यकर्ता से टर्मिनल ग्राफिक्स
एलेक्स हैरी को लागू करने के लिए एक सप्ताहांत परियोजना के रूप में शुरू की जो कुछ अधिक महत्वाकांक्षी हो गया
1. **दिन 1**: आकार का उपयोग करते हुए आधारभूत ASCII रेंडरिंग
2. **दिन 2**: रंग समर्थन और एनिमेटेड GIF प्लेबैक जोड़ा गया
3. **दिन 3**: उच्च विश्वसनीयता के लिए कार्यान्वित ColorBlocks मोड
4. **दिन 4**: एक्स रिजोल्यूशन के लिए ब्रेल मोड जोड़ा गया
5. **बाद में**: वीडियो समर्थन
6. **बहुत बाद में**: गति के लिए अस्थायी स्थिरीकरण
स्कोप क्रीप असली था, लेकिन प्रत्येक जोड़ना स्वाभाविक और उपयोगी महसूस किया गया।
## तीन रेंडरिंग मोड
कंसोल इमेज टर्मिनल में छवि रेंडर करने के तीन अलग तरीके प्रदान करता है
```mermaid
flowchart LR
A[Source Image] --> B{Choose Mode}
B --> C[ASCII]
B --> D[ColorBlocks]
B --> E[Braille]
C --> F[Shape-matched characters]
D --> G[Unicode half-blocks]
E --> H[2×4 dot patterns]
style A stroke:#4a9eff
style B stroke:#ff6600
style C stroke:#00aa00
style D stroke:#00aa00
style E stroke:#00aa00
```
मोड | कमांड
|------|---------|------------|----------|
| **ब्रैल** | `consoleimage photo.jpg` प्रति सेल पिक्सेल **डिफेल्ट** अधिकतम विवरण
| **ASCII** | `consoleimage photo.jpg -a` |
| **रंगखंड** | `consoleimage photo.jpg -b` à¤à¥à¤°à¥à¤
ब्रेल डिफ़ॉल्ट है `-a` ASCII के लिए या `-b` के लिए ColorBlocks
### टर्मिनल प्रोटोकॉल मोड
कुछ टर्मिनल इनलाइन ग्राफिक्स प्रोटोकॉल का समर्थन करते हैं।
एक ही पाइपलाइन और उपकरणिंग बनाए रखने के दौरान सही रेंडरिंग
### मोड तुलना
यहाँ एक ही एनिमेशन GIF हर मोड में रेन्डर किया गया है
ASCII
|-------|---------|----------------|-------------|
|  |  |  |  |
आकार-matched character | 2×4 dot patterns
ASCII आउटपुट आकार दिखाता है `/` और `\`, वक्र उपयोग `(` और `)`, और विभिन्न घनत्वों जैसे अक्षर प्रयोग करें `@`, `#`, `*`, और `.`मोनोक्रोम ब्रेल संस्करण रंग मोडों से छोटा होता है जबकि पूर्ण बिंदु रिजोल्यूशन धारण करता है
### ब्रेल रिजोल्यूशन: द एमिगा बॉईंगबल
उत्कृष्ट अमीगा बाउनिंग गेंद - एक एनिमेशन के साथ रिजोल्यूशन लाभ स्पष्ट हो जाता है जो सुचारू वक्रों और स्वच्छ आयताकारों की मांग करता है
ब्रैल (मोनोक्रोम
|----------------------|------------------|
|  |  |
| 8× रिजोल्यूशन
दोनों ही एक ही बिंदु ग्रिड का उपयोग करते हैं।
### मोनोक्रोम ब्रेल
त्वरित पूर्वावलोकन के लिए`--mono`पूर्ण रूप से रंग गिरता है
```bash
consoleimage animation.gif --mono -w 120
```
परिणाम हैं **3-5x छोटा** रंग मोडों के बजाय पूर्ण रिजोल्यूशन को बनाए रखते हुए। *बेहतर* क्योंकि वहाँ छवि सूचना के साथ प्रतिस्पर्धी रंग शोर नहीं है
## ASCII आकार को कैसे मिलाया जाता है
पारंपरिक ASCII कला चमकीलापन मानचित्रण का उपयोग करता है - गाढा पिक्सेल denser अक्षर जैसे प्राप्त करते हैं `@` या `#`, हल्के पिक्सेल जैसे विरल पिक्सल्स पाते हैं `.` या ` `. यह काम करता है *आकार* अक्षरों का
एलेक्स हारी' दृष्टिकोण स्मार्ट है: प्रत्येक वर्ण के दृश्य आकार का विश्लेषण करता है। `/` या `\`, समान चमकता कोई भी वर्ण नहीं है
एक बार जब आप प्रत्येक वर्ण को एक छोटा आकार के रूप में व्यवहार करते हैं, 2D आकार
### आकार सदिश
प्रत्येक अक्षर का विश्लेषण एक के उपयोग से किया जाता है **6-बिन्दु नमूना ग्रिड** एक 3×2 स्टैगर किए पैटर्न में
```
[0] [1] [2] ← Top row (staggered vertically)
[3] [4] [5] ← Bottom row
```
बायाँ वृत्त नीचे कर दिए जाते हैं और दायें वृत्तों को बढ़ा दिया जाता है ताकि अंतरों को कम किया जा सके तथा साथ ही एक दूसरे के साथ जुड़ने से बचाया जा सके।
यहाँ एक संदर्भ के रूप में फिर से ASCII आउटपुट है जब हम नमूना ग्रिड के बारे में बात करते हैं
```csharp
// Staggered sampling positions (3x2 grid as per Harri's article)
private static readonly (float X, float Y)[] InternalSamplingPositions =
[
(0.17f, 0.30f), // Top-left (lowered)
(0.50f, 0.25f), // Top-center
(0.83f, 0.20f), // Top-right (raised)
(0.17f, 0.80f), // Bottom-left (lowered)
(0.50f, 0.75f), // Bottom-center
(0.83f, 0.70f) // Bottom-right (raised)
];
```
### अक्षर मानचित्र बनाना
जब रेंडरर आरंभ करता है, तो यह प्रत्येक ASCII अक्षर को एक छोटा छवि में रेन्डर करता है और 6 क्षेत्रों को नमूना देता है
```csharp
private void GenerateVectors(string characterSet, string? fontFamily, int cellSize)
{
var font = GetFont(fontFamily, cellSize);
foreach (var c in characterSet.Distinct())
{
var vector = RenderCharacterVector(c, font, cellSize);
_vectors[c] = vector;
}
// Normalise vectors for comparable magnitudes
NormalizeVectors();
}
```
परिणाम एक लुकअप तालिका है जो प्रत्येक अक्षर को उसके आकार हस्ताक्षर के लिए मानचित्रित करता है
### K-D ट्री मिलान
प्रत्येक छवि कोशिका के लिए सर्वोत्तम अक्षर ढूंढने के लिए खोज की आवश्यकता है 6-आयामी अंतरिक्ष **[K-D पेड़](https://en.wikipedia.org/wiki/K-d_tree)** सबसे तेजी से निकट के लिए
```mermaid
flowchart TD
A[Image Cell] --> B[Sample 6 regions]
B --> C[Create shape vector]
C --> D[K-D tree lookup]
D --> E[Nearest character match]
style A stroke:#4a9eff
style C stroke:#ff6600
style D stroke:#00aa00
style E stroke:#00aa00
```
[K-D पेड़](https://en.wikipedia.org/wiki/K-d_tree) के स्थान पर O(log nM SK1 खोज उपलब्ध कराता है और परिणामों को अधिक तेजी से बार-बार खोज के लिए क्वांटिश सदिशों का उपयोग करके कैश किया जाता है
### कंट्रास्ट वृद्धि
कच्चा आकार मिलान समतल दिख सकता है
**वैश्विक कंट्रास्ट** एक पावर फ़ंक्शन जो शून्य की ओर कम मूल्यों को झुकाता है
```
value = (value / max)^power × max
```
**दिशात्मक कंट्रास्ट** बाहरी नमूना घेरे किनारों को पता लगाते हैं जहां सामग्री खाली स्थान से मिलती है
```csharp
// 10 external sampling positions for directional contrast
private static readonly (float X, float Y)[] ExternalSamplingPositions =
[
(0.17f, -0.10f), // Above top-left
(0.50f, -0.10f), // Above top-center
(0.83f, -0.10f), // Above top-right
(-0.15f, 0.30f), // Left of top-left
(1.15f, 0.20f), // Right of top-right
(-0.15f, 0.80f), // Left of bottom-left
(1.15f, 0.70f), // Right of bottom-right
(0.17f, 1.10f), // Below bottom-left
(0.50f, 1.10f), // Below bottom-center
(0.83f, 1.10f) // Below bottom-right
];
```
### निष्पादन अनुकूलन
रेंडरर में कई निष्पादन चालें शामिल हैं
- **पूर्व- संगणित त्रिकोणगणित** - खोजअप तालिका प्रति कोष्ठ ट्रिग को सस्ते एरे सूचकांकन के साथ बदलें
- **सीएमडी अनुकूलन** उपयोग `Vector128`/`Vector256`/`Vector512` दूरी गणना के लिए
- **समांतर प्रक्रमण** अधिक छवियों के लिए -Multi-threaded रेंडरिंग
- **स्टैक आवंटन** - अस्थायी बफर के लिए ढेर दबाव से बचता है
```csharp
// Pre-computed sin/cos lookup tables (major performance optimisation)
private static readonly (float Cos, float Sin)[] InnerRingAngles = PrecomputeAngles(6, 0);
private static readonly (float Cos, float Sin)[] MiddleRingAngles = PrecomputeAngles(12, MathF.PI / 12);
private static readonly (float Cos, float Sin)[] OuterRingAngles = PrecomputeAngles(18, 0);
```
## ब्रेल रेंडरिंग
ब्रैल मोड सबसे बड़ा तकनीकी कदम था। **पिक्सेल** हर कक्ष में , और ConsoleImage उन बिंदुओं को एक के रूप में देखता है *कालानुकूल* संकेत शून्य रूप से एक स्थिर बिटमैप नहीं है
### यूनिकोड ब्रेल ब्लॉक
ब्रैल अक्षर (UM SK1 - U+28FF\) एक ग्रिड में एक |8-dot पैटर्न को एनकोड करते हैं
```
┌─────┬─────┐
│ 1 │ 4 │ ← Row 0
├─────┼─────┤
│ 2 │ 5 │ ← Row 1
├─────┼─────┤
│ 3 │ 6 │ ← Row 2
├─────┼─────┤
│ 7 │ 8 │ ← Row 3
└─────┴─────┘
Col0 Col1
```
प्रत्येक बिंदु एक बिट से मेल खाता है
```csharp
// Dot bit positions in braille character
// Pattern: 1 4
// 2 5
// 3 6
// 7 8
// Listed in 2×4 scan order: 1,4,2,5,3,6,7,8.
private static readonly int[] DotBits = { 0x01, 0x08, 0x02, 0x10, 0x04, 0x20, 0x40, 0x80 };
```
क्यारेक्टर कोड सरल है `0x2800 + (bit pattern)`. एक खाली ब्रेल कोशिका है `⠀` (U+2800), एक पूरा ब्लॉक है `⣿` (U+28FFM SK2
### द ब्रैल पाइपलाइन
```mermaid
flowchart LR
A[Source Image] --> B[Resize to W×2, H×4]
B --> C[Grayscale conversion]
C --> D[Otsu threshold + temporal stabilisation]
D --> E[Atkinson dithering]
E --> F[Build braille codes]
F --> G[Hybrid colours + perceptual compensation]
G --> H[Terminal output]
style A stroke:#4a9eff
style D stroke:#ff6600
style E stroke:#ff6600
style G stroke:#00aa00
```
चूंकि प्रत्येक ब्रेल कोशिका एक बिन्दु ग्रिड 2×4 एनकोड करता है।
### स्वचालित थ्रेसहोल्डिंग
ब्रेल में रूपांतरण के लिए द्विआधारी निर्णयों की आवश्यकता होती है - प्रत्येक बिंदु चालू या बंद है. एक निश्चित थ्रेसहोल्ड (जैसा है | 50% चमकीलापन |) उन छवियों के लिए असफल होता है जो अधिकतर हल्के या अँधेरे होते हैं
**[Otsu's विधि](https://en.wikipedia.org/wiki/Otsu%27s_method)** अग्रभूमि और पृष्ठभूमि के बीच भिन्नता को अधिकतम करके अधिकतम थ्रेसहोल्ड खोजता है
1. पिक्सेल तीव्रताओं का एक हिस्टोग्राम बनाएँ
2. प्रत्येक संभव थ्रेसहोल्ड के लिए (0-255), वर्ग अंतर के बीच गणना करें
3. थ्रेसहोल्ड चुनें जो चर को अधिकतम करता है
यह किसी भी छवि के लिए स्वचालित रूप से अनुकूलन करता है - अंधेरी छवियों को कम थ्रेसहोल्ड्स प्राप्त करता है [ब्रेल रेंडरर स्रोत](https://github.com/scottgal/mostlylucid.consoleimage/blob/master/ConsoleImage.Core/BrailleRenderer.cs).)
व्यवहार में, naive Otsu थ्रेसहोल्डिंग एनिमेशन के लिए अपर्याप्त है।
### एटकिनसन डिथरिंग
द्विआधारी थ्रेसहोल्डिंग कठोर किनारे बनाता है **डिथरिंग** पड़ोसी पिक्सेलों को क्वांटेशन त्रुटि फैलाता है
हम उपयोग करते हैं **[एटकिनसन डिथरिंग](https://beyondloom.com/blog/dither.html)** (बिल एटकिनसन द्वारा मूल मैकिन्टोश के लिए विकसित किया गया [फ्लोइड-स्टेनबर्ग एल्गोरिथ्म](https://en.wikipedia.org/wiki/Floyd%E2%80%93Steinberg_dithering):
```
X 1 1
1 1 1
1
(each "1" receives 1/8 of the error)
```
ब्रैल के लिए why Atkinson बेहतर काम करता है
अभिमुखता | फ्लोइड
|--------|-----------------|----------|
| त्रुटि वितरित की गई
स्प्रेड पैटर्न
परिणाम | समृद्ध ग्राडिएंट्स
के लिए सबसे अच्छा | फोटो | | | लाइन आर्ट |, | पाठ |
Atkinson जानबूझकर त्रुटि का 25% छोड़ देता है, सटीक किनारे उत्पन्न करता है
```csharp
private static void ApplyAtkinsonDithering(Span buffer, int width, int height, byte threshold)
{
for (int y = 0; y < height; y++)
{
for (int x = 0; x < width; x++)
{
int idx = y * width + x;
short oldPixel = buffer[idx];
byte newPixel = oldPixel > threshold ? (byte)255 : (byte)0;
buffer[idx] = newPixel;
short error = (short)(oldPixel - newPixel);
short diffuse = (short)(error / 8); // 1/8 of error
// Diffuse to 6 neighbours (only 6/8 = 75% of error)
if (x + 1 < width)
buffer[idx + 1] += diffuse;
if (x + 2 < width)
buffer[idx + 2] += diffuse;
if (y + 1 < height)
{
if (x > 0)
buffer[idx + width - 1] += diffuse;
buffer[idx + width] += diffuse;
if (x + 1 < width)
buffer[idx + width + 1] += diffuse;
}
if (y + 2 < height)
buffer[idx + width * 2] += diffuse;
}
}
}
```
### हाइब्रिड रंग नमूना
टर्मिनल रंग एक चुनौती प्रस्तुत करते हैं **एक अग्रभूमि रंग** प्रति अक्षर, लेकिन ब्रेल का प्रतिनिधित्व करता है **8 विभिन्न स्रोत पिक्सेल**.
सभी पिक्सेल रंगों को औसतन करने से एक "सोलराइज्ड" दिखता है। **केवल पिक्सेलों से नमूना रंग जहां बिंदुओं को चमकाया जाता है**:
```mermaid
flowchart TD
A[2×4 Pixel Block] --> B{Which pixels are lit?}
B -->|Dots 1,4,7| C[Sample only those 3 pixels]
B -->|Dots 2,3,5,6,8| D[Sample only those 5 pixels]
C --> E[Average lit pixel colours]
D --> E
E --> F[Apply colour boost]
F --> G[Set as foreground colour]
style A stroke:#4a9eff
style B stroke:#ff6600
style E stroke:#00aa00
style F stroke:#00aa00
```
यह सुनिश्चित करता है कि प्रदर्शित रंग वास्तव में क्या उपयोगकर्ता देखता है से मिल जाता है - चमकी हुई बिंदुएँ
### Sparse ग्लाइफ के लिए बोधात्मक रंग क्षतिपूर्ति
ब्रेल अक्षर स्वाभाविक रूप से विरल होते हैं।
perceived chroma restore rather than exaggerate color:
डिफ़ॉल्ट boosts (tunable):
- **संतृप्ति**:
- **चमकीलापन**:
```csharp
// Apply gamma correction and boost saturation/brightness for braille
(r, g, b) = BoostBrailleColor(r, g, b, _options.Gamma);
```
### रिजोल्यूशन तुलना
एक 100×50 अक्षर आउटपुट के लिए
मोड
|------|------------------|
ASCII
रंग ब्लॉक्स
ब्रैल
ब्रेल प्रदान करता है **8x संकल्प** ASCII और **4x संकल्प** रंग खंडों का
### क्रिया में ब्रेल: परिदृश्य विवरण
ब्रैल का सबसे अच्छा प्रदर्शन द्रुत ग्रेडियन्ट और सूक्ष्म विवरण के साथ है
इस बिंदु पर मैंने महसूस किया कि मैं अब नहीं देख रहा हूँ।
ध्यान दें कि आकाश की ग्राडिएंट और टेनिटरी विवरण टर्मिनल रिजोल्यूशन पर भी दिखाई देते हैं।
## मैट्रिक्स मोड
एक भी है `-M` मैट्रिक्स डिजिटल वर्षा अधिलेखन प्रभाव के लिए फ्लैग
## एनिमेशन और वीडियो
### फ्लिकर
टर्मिनल में एनिमेशन कठिन है - naiv approaches cause visible flicker
**[DECSET 2026 समक्रमित आउटपुट](https://gist.github.com/christianparpart/d8a62cc1ab659194337d73e399004036)** एक टर्मिनल विशेषता जो आपको एक बार में पूरे फ्रेम को कमिट करता है
```csharp
// Start synchronised output
Console.Write("\x1b[?2026h");
// Write entire frame
Console.Write(frameContent);
// End synchronised output
Console.Write("\x1b[?2026l");
```
**डेल्टा रेंडरिंग** सिर्फ अद्यतन बदले हुए कोशिकाएँ
```csharp
public (string output, CellData[,] cells) RenderWithDelta(
Image image,
CellData[,]? previousCells,
int colorThreshold = 8)
{
var cells = RenderToCells(image);
var height = cells.GetLength(0);
var width = cells.GetLength(1);
// First frame or dimension change - full redraw
if (previousCells == null)
return (RenderCellsToString(cells), cells);
// Delta render - only output changed cells
var sb = new StringBuilder();
for (var y = 0; y < height; y++)
{
for (var x = 0; x < width; x++)
{
var current = cells[y, x];
var previous = previousCells[y, x];
// Skip if cell hasn't changed
if (current.IsSimilar(previous, colorThreshold))
continue;
// Position cursor and output
sb.Append($"\x1b[{y + 1};{x + 1}H");
sb.Append(current.ToAnsi());
}
}
return (sb.ToString(), cells);
}
```
यह आमतौर पर आउटपुट द्वारा कम करता है **70-90%** वीडियो सामग्री के लिए जहाँ अधिकांश फ्रेम स्थिर है
### अस्थायी स्थिरता (Dejitter
विषयवस्तु को खिसकाने के लिए, per small -frame color changes can shimmer | . | ConsoleImage includes a dejitter pass that smooths
फ्रेमों के बीच रंग परिवर्तन
### वीडियो समर्थन
वीडियो फ़ाइलें और यूट्यूब यूआरएल FFmpeg और yt के माध्यम से संभाले जाते हैं
ट्रिम durations, स्विच रेंडर मोड्सM SK1 उपशीर्षक जोड़ें, और एक ही रेंडरिंग कोर का उपयोग करके GIF या दस्तावेज़ प्रारूपों में निर्यात करें
**वीडियो प्लेबैक नियंत्रण**
कुंजी
|-----|--------|
| `Space` Pause
| `Q` / `Esc` बाहर निकलें
## दस्तावेज़ प्रारूप
कंसोल छवि रेन्डर किए गए आउटपुट को स्वयं के लिए सहेज सकता है -contained दस्तावेज़ जो मूल स्रोत के बिना फिर बजाते हैं `.cidz`
ढाँचा डेल्टा एनकोडिंग के साथ GZip संपीड़न का प्रयोग करता है (सभीtimes ~7:1के विपरीत कच्चे JSON), और लंबे वीडियो NDJSON के रूप में स्ट्रीम किए जा सकते हैं
इस तरह फ्रेमों को स्मृति में बफर के बजाय क्रमशः लिखा जाता है
एक हल्के वजन के खिलाड़ी पैकेज भी है (`ConsoleImage.Player`) जो ImageSharp या FFmpeg के बिना दस्तावेजों को फिर से चला सकता है
जो एनिमेटेड सीएलआई लोगो को भारी निर्भरताओं के बंडिंग किए बिना व्यवहार्य बनाता है
## API & एकीकृत
छवियों को रेंडर करने के लिए एक पूरा सी-एपीआई है।
renderers back the CLI, so you can embed the algorithms in your own tools without re
स्पेक्ट्र.कॉन्सोल एकीकरण दोनों ही जीवित रेंडर और दस्तावेज़ प्लेबैक के लिए उपलब्ध है
लेआउट के भीतर रेंडरबल्स. README और NuGet पैकेज पृष्ठ API सतह को विस्तृत रूप से ढूंढते हैं
## Readmes & Deep Dives
अगर आप पूरा तकनीकी विवरण चाहते हैं
- [कंसोल छवि सीएलआई README](https://github.com/scottgal/mostlylucid.consoleimage/blob/master/ConsoleImage/README.md)
- [कोर लाइब्रेरी README](https://github.com/scottgal/mostlylucid.consoleimage/blob/master/ConsoleImage.Core/README.md)
- [वीडियो कोर README](https://github.com/scottgal/mostlylucid.consoleimage/blob/master/ConsoleImage.Video.Core/README.md)
- [ट्रांस्क्रिप्शन README](https://github.com/scottgal/mostlylucid.consoleimage/blob/master/ConsoleImage.Transcription/README.nuget.md)
- [खिलाड़ी README](https://github.com/scottgal/mostlylucid.consoleimage/blob/master/ConsoleImage.Player/README.md)
- [स्पेक्टर इंटीग्रेशन README](https://github.com/scottgal/mostlylucid.consoleimage/blob/master/ConsoleImage.Spectre/README.nuget.md)
- [खिलाड़ी.स्पेक्ट्र README](https://github.com/scottgal/mostlylucid.consoleimage/blob/master/ConsoleImage.Player.Spectre/README.md)
- [एमसीपी सर्वर README](https://github.com/scottgal/mostlylucid.consoleimage/blob/master/ConsoleImage.Mcp/README.md)
- [ब्रेल रेंडरिंग नोट्स](https://github.com/scottgal/mostlylucid.consoleimage/blob/master/docs/BRAILLE-RENDERING.md)
- [JSON/CIDZ ढाँचा स्पेक्ट](https://github.com/scottgal/mostlylucid.consoleimage/blob/master/docs/JSON-FORMAT.md)
- [ChangelogComment](https://github.com/scottgal/mostlylucid.consoleimage/blob/master/CHANGELOG.md)
## एआई एकीकृत के लिए एमसीपी सर्वर
कंसोल इमेज में एक MCP ( मॉडल संदर्भ प्रोटोकॉल) सर्वर शामिल है जो इसे एक "आभासी प्रौद्योगिकी कार्यप्रवाहों के लिए दृश्य प्रोब में परिवर्तित करता है।
चूंकि कंसोल इमेज संवेदनात्मक रूप से अर्थपूर्ण पूर्वावलोकन प्रदान कर सकता है।
### ठोस एआई कार्य
एमसीपी एकीकरण के साथ
- **रंगीन खण्डों को ढूंढें**कम रिजोल्यूशन में वीडियो स्कैन करें
- **दृश्य परिवर्तनों को पहचानें**: महत्वपूर्ण क्षणों को पहचानने के लिए फ्रेम के डेल्टा ऊर्जा मापें
- **रुचि के विषयों को खोजें**उन फ्रेमों को ढूंढने के लिए हियूरिसिक्स का उपयोग करें जो व्यक्तियों या मानवीय आकृतियों को समाहित करने वाले प्रतीत होते हैं
- **स्टोरिवॉर्ड उत्पन्न करें**: एक एकल रेंडरेड दस्तावेज के रूप में एन कुंजी फ्रेमों का संपर्क शीट बनाएँ
### वास्तविक उदाहरण: इस लेख को बनाना
इस लेख को लिखते समय मैं अच्छा उदाहरण क्लिप ढूंढने के लिए एक MCP उपकरण के रूप में ConsoleImage का प्रयोग किया।
```
→ extract_frames (low-res preview at various timestamps)
→ compare_render_modes (ASCII vs braille at promising scenes)
→ render_to_gif (final export of selected clips)
```
यहाँ एक छोटा ब्रेल पूर्वावलोकन है 30 अक्षरों की चौड़ाई पर
```
⣿⣿⣿⣿⣿⣿⣿⣿⡿⢃⠌⡱⢈⠱⣈⠱⣈⠱⢈⠛⢿⠿⠟⢛⠛⢛⣿⣿⣿⣿⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿
⣿⣿⣿⣿⣿⣿⣿⣿⠇⡌⠒⡄⢃⢲⣾⣷⠶⡉⠤⡀⢆⠢⢉⠢⡘⢄⢂⠉⣺⣽⢿⣞⣷⣻⣞⣷⣻⣞⣷⣿
⣿⣿⣿⣿⣿⣿⣿⣿⠐⡈⢅⠢⡁⣾⣿⡏⠤⠑⡂⢅⠢⣕⢨⣔⠡⠌⣂⠱⠘⠯⠿⣾⣽⣳⠯⣝⡗⢿⣞⣿
```
यह मुझे पूरे रिजोल्यूशन में सब कुछ रेंडर करने के बजाय रोचक फ्रेमों को पहचानने के लिए सामग्री को तेजी से स्कैन करने देता है
### कॉन्फ़िगरेशन
सेटअप एक एकल MCP सर्वर प्रविष्टि है [MCP README](https://github.com/scottgal/mostlylucid.consoleimage/tree/master/ConsoleImage.Mcp) विवरण के लिए.
मुख्य उपकरणों में शामिल हैं `render_image`, `render_to_gif`, `extract_frames`, और `compare_render_modes`.
## वास्तुकला
```mermaid
flowchart TB
subgraph Core["ConsoleImage.Core (NuGet)"]
AR[AsciiRenderer]
BR[BrailleRenderer]
CB[ColorBlockRenderer]
CM[CharacterMap]
AP[AnimationPlayer]
DOC[Document Format]
end
subgraph Video["ConsoleImage.Video.Core"]
FF[FFmpegService]
VP[VideoPlayer]
end
subgraph CLI["ConsoleImage CLI"]
MAIN[Unified CLI]
end
subgraph MCP["ConsoleImage.Mcp"]
TOOLS[AI Tools]
end
MAIN --> Core
MAIN --> Video
TOOLS --> Core
style Core stroke:#4a9eff
style Video stroke:#ff6600
style CLI stroke:#00aa00
style MCP stroke:#9933ff
```
## निष्कर्ष
Alex Harri के त्वरित क्रियान्वयन के रूप में आरंभ हुआ क्या ASCII रेंडरिंग एल्गोरिथ्म एक टर्मिनल ग्राफिक्स सिस्टम में बदल गया
प्रमुख सीखें
- **Shape-matching beats brightness mapping** अक्षर चयन गुणवत्ता के लिए
- **ब्रैल अक्षर** टर्मिनलों में आश्चर्यजनक रिजोल्यूशन प्रदान करें
- **डेल्टा रेंडरिंग** सरल वीडियो प्लेबैक के लिए अनिवार्य है
- **अस्थायी सुसंगतता + बोधात्मक क्षतिपूर्ति** के बीच अंतर है "recognisable
कोड सार्वजनिक डोमेन है। [जिटहब](https://github.com/scottgal/mostlylucid.consoleimage).
## Coming Next: Part 2 - lucidVIEW
एक और समय `-`बाकस उपकरण है [**lucidVIEW**](https://github.com/scottgal/lucidview) एक छोटा Avalonia क्लाइंट जो WebView का उपयोग किए बिना Markdown को अच्छी तरह रेन्डर करता है
भाग 2. में इसके बारे में अधिक जानकारी
## संदर्भ
- [Alex Harri's ASCII रेंडरिंग अनुच्छेद](https://alexharri.com/blog/ascii-rendering) - प्रेरणा
- [यूनिकोड ब्रेल पैटर्न ब्लॉक](https://unicode.org/charts/PDF/U2800.pdf) - ब्रेल एनकोडिंग संदर्भ
- [Otsu's विधि](https://en.wikipedia.org/wiki/Otsu%27s_method) - स्वतः थ्रेसहोल्डिंग
- [एटकिनसन डिथरिंग](https://beyondloom.com/blog/dither.html) - MacPaint एल्गोरिथ्म