c++ - চিত্রটি ASCII শিল্প রূপান্তর করতে



image-processing bitmap (1)

এএসসিআইআই আর্ট রূপান্তরটির জন্য চিত্রের আরও পন্থা রয়েছে যা বেশিরভাগ ক্ষেত্রে সরলতার জন্য মনো-স্পেস ফন্টগুলি ব্যবহারের উপর ভিত্তি করে আমি কেবল বুনিয়াদিগুলিতেই আটকে থাকি:

পিক্সেল / অঞ্চল তীব্রতা ভিত্তিক (শেডিং)

এই পদ্ধতির প্রতিটি পিক্সেল ক্ষেত্রের পিক্সেল একক ডট হিসাবে পরিচালনা করে। ধারণাটি হ'ল এই বিন্দুর গড় ধূসর স্কেল তীব্রতা গণনা করা এবং তারপরে এটির সাথে এটির সাথে ঘনিষ্ঠ পর্যাপ্ত ঘনত্বের সাথে চরিত্রটি প্রতিস্থাপন করা হবে। এর জন্য আমাদের প্রাক্পম্পিউটেড ইনটেনসিটি সহ প্রতিটি ব্যবহারযোগ্য চরিত্রের কয়েকটি তালিকার দরকার যা একে চরিত্রের map বলুক। কোন চরিত্রটি সর্বোত্তম যার তীব্রতার জন্য দুটি উপায় রয়েছে তা আরও দ্রুত চয়ন করা:

  1. রৈখিকভাবে বিতরণ তীব্রতা অক্ষর মানচিত্র

    সুতরাং আমরা একই অক্ষরের সাথে একই পদক্ষেপের সাথে তাত্পর্যপূর্ণ পার্থক্য রাখি। অন্য কথায় যখন তখন আরোহণের বাছাই করা হয়:

    intensity_of(map[i])=intensity_of(map[i-1])+constant;

    এছাড়াও যখন আমাদের চরিত্রের map সাজানো হয় তখন আমরা তীব্রতা থেকে সরাসরি চরিত্রটি গণনা করতে পারি (অনুসন্ধানের প্রয়োজন নেই)

    character=map[intensity_of(dot)/constant];
  2. নির্বিচারে বিতরণ তীব্রতা অক্ষর মানচিত্র

    সুতরাং আমরা ব্যবহারযোগ্য অক্ষর এবং তাদের তীব্রতা অ্যারে আছে। আমাদের intensity_of(dot) নিকটতম সন্ধান করতে হবে সুতরাং আমরা যদি map[] বাছাই করি map[] আমরা বাইনারি অনুসন্ধান ব্যবহার করতে পারি অন্যথায় আমাদের O(n) অনুসন্ধান নূন্যতম দূরত্বের লুপ বা O(1) অভিধান প্রয়োজন। কখনও কখনও সরলতার জন্য চরিত্রের map[] পরিচালনা করা যায় লাইনারি বিতরণ হিসাবে যার ফলে সামান্য গামা বিকৃতি সাধারনত ফলাফলটিতে অদৃশ্য হয়ে থাকে যদি না আপনি কী সন্ধান করতে চান তবে।

তীব্রতা ভিত্তিক রূপান্তর ধূসর-স্কেল চিত্রগুলির জন্যও দুর্দান্ত (কেবল কালো এবং সাদা নয়)। আপনি যদি বিন্দুটিকে একটি একক পিক্সেল হিসাবে নির্বাচন করেন তবে ফলাফলটি বৃহত্তর (1 পিক্সেল -> একক অক্ষর) পায় তাই বৃহত্তর চিত্রগুলির জন্য দিক অনুপাত সংরক্ষণ করার জন্য একটি অঞ্চল (ফন্টের আকারের গুণ) নির্বাচন করা হয় এবং খুব বেশি বড় করা হবে না।

এটা কিভাবে করতে হবে:

  1. সুতরাং সমানভাবে চিত্রটিকে (ধূসর-স্কেল) পিক্সেল বা (আয়তক্ষেত্রাকার) অঞ্চলে বিন্দুর আকারে ভাগ করুন
  2. প্রতিটি পিক্সেল / ক্ষেত্রের তীব্রতা গণনা করুন
  3. কাছের তীব্রতার সাথে চরিত্রের মানচিত্র থেকে চরিত্র অনুসারে এটিকে প্রতিস্থাপন করুন

চরিত্রের map হিসাবে আপনি যে কোনও অক্ষর ব্যবহার করতে পারেন তবে চরিত্রটি ক্ষেত্রের ক্ষেত্রের সাথে একইভাবে পিক্সেল ছড়িয়ে ছড়িয়ে থাকলে ফলাফল আরও ভাল হয়। প্রারম্ভিকদের জন্য আপনি ব্যবহার করতে পারেন:

  • char map[10]=" .,:;ox%#@";

সাজানো উতরে সাজানো এবং রৈখিকভাবে বিতরণ করার ভান করা।

সুতরাং যদি পিক্সেল / ক্ষেত্রের তীব্রতা i = <0-255> তবে প্রতিস্থাপনের অক্ষরটি হবে

  • map[(255-i)*10/256];

যদি i==0 তবে পিক্সেল / ক্ষেত্রটি কালো, যদি i==127 তবে পিক্সেল / ক্ষেত্র ধূসর এবং যদি i==255 তবে পিক্সেল / অঞ্চলটি সাদা। আপনি map[] ভিতরে বিভিন্ন অক্ষর নিয়ে পরীক্ষা করতে পারেন map[] ...

সি ++ এবং ভিসিএলে আমার প্রাচীন উদাহরণ:

AnsiString m=" .,:;ox%#@";
Graphics::TBitmap *bmp=new Graphics::TBitmap;
bmp->LoadFromFile("pic.bmp");
bmp->HandleType=bmDIB;
bmp->PixelFormat=pf24bit;

int x,y,i,c,l;
BYTE *p;
AnsiString s,endl;
endl=char(13); endl+=char(10);
l=m.Length();
s="";
for (y=0;y<bmp->Height;y++)
    {
    p=(BYTE*)bmp->ScanLine[y];
    for (x=0;x<bmp->Width;x++)
        {
        i =p[x+x+x+0];
        i+=p[x+x+x+1];
        i+=p[x+x+x+2];
        i=(i*l)/768;
        s+=m[l-i];
        }
    s+=endl;
    }
mm_log->Lines->Text=s;
mm_log->Lines->SaveToFile("pic.txt");
delete bmp;

আপনি বোরল্যান্ড / এম্বারকাডেরো পরিবেশ ব্যবহার না করে আপনাকে ভিসিএল স্টাফগুলি প্রতিস্থাপন / উপেক্ষা করতে হবে

  • mm_log হ'ল মেমো যেখানে পাঠ্য mm_log হয়
  • bmp হ'ল ইনপুট বিটম্যাপ
  • AnsiString হ'ল ভিসিএল টাইপ স্ট্রিং ইনডেক্সড ফর্ম 1 থেকে char* হিসাবে নয় char* !

এটি ফলাফল: সামান্য NSFW তীব্রতা উদাহরণ চিত্র

বামদিকে ASCII আর্ট আউটপুট (হরফ আকার 5px), এবং ডান ইনপুট চিত্রটিতে কয়েকবার জুম করা হয়েছে। আপনি দেখতে পাচ্ছেন আউটপুটটি বড় পিক্সেল -> অক্ষর। আপনি যদি পিক্সেলের পরিবর্তে বৃহত্তর অঞ্চল ব্যবহার করেন তবে জুমটি ছোট তবে অবশ্যই আউটপুটটি চাক্ষুষভাবে কম খুশি হবে। এই পদ্ধতির কোড / প্রক্রিয়া খুব সহজ এবং দ্রুত।

আপনি যখন আরও উন্নত জিনিস যুক্ত করেন:

  • স্বয়ংক্রিয় মানচিত্রের গণনা
  • স্বয়ংক্রিয় পিক্সেল / অঞ্চল আকার নির্বাচন
  • দিক অনুপাত সংশোধন

তারপরে আপনি আরও ভাল ফলাফল সহ আরও জটিল চিত্রগুলি প্রক্রিয়া করতে পারেন:

এখানে ফলাফল 1: 1 অনুপাত (অক্ষরগুলি দেখতে জুম):

অবশ্যই অঞ্চল স্যাম্পলিংয়ের জন্য আপনি ছোট বিশদটি হারাবেন। অঞ্চলগুলির সাথে নমুনাযুক্ত প্রথম উদাহরণ হিসাবে এটি একই আকারের চিত্র:

সামান্য NSFW তীব্রতা উন্নত উদাহরণ চিত্র

আপনি দেখতে পাচ্ছেন এটি বড় চিত্রগুলির জন্য আরও উপযুক্ত

ক্যারেক্টার ফিটিং (শেডিং এবং সলিড এএসসিআইআই আর্টের মধ্যে সংকর)

এই পদ্ধতির ক্ষেত্রটি (আর একক পিক্সেল বিন্দুগুলি) অনুরূপ তীব্রতা এবং আকারের সাথে অক্ষরের সাথে প্রতিস্থাপন করার চেষ্টা করে। এটি অন্যদিকে পূর্ববর্তী পদ্ধতির সাথে তুলনায় ব্যবহৃত বড় ফন্টগুলির সাথে আরও ভাল ফলাফলের দিকে নিয়ে যায় এই পদ্ধতিরটি অবশ্যই কিছুটা ধীর। এটি করার আরও অনেকগুলি উপায় রয়েছে তবে মূল ধারণাটি হ'ল চিত্রের ক্ষেত্র ( dot ) এবং রেন্ডার চরিত্রের মধ্যে পার্থক্য (দূরত্ব) গণনা করা। আপনি পিক্সেলের মধ্যে অ্যাবস পার্থক্যগুলির নিষ্পাপ যোগ দিয়ে শুরু করতে পারেন তবে এটি খুব ভাল ফলাফলের দিকে নিয়ে যাবে না কারণ 1 পিক্সেলের শিফটও দূরত্বকে আরও বড় করে তুলবে, পরিবর্তে আপনি পরস্পর সম্পর্ক বা বিভিন্ন মেট্রিক ব্যবহার করতে পারেন। সামগ্রিক অ্যালগোরিদম পূর্ববর্তী পদ্ধতির মতো প্রায়:

  1. সুতরাং সমানভাবে চিত্রটিকে (ধূসর-স্কেল) আয়তক্ষেত্রাকার অঞ্চলগুলি বিন্দুতে ভাগ করুন
    • আদর্শভাবে রেন্ডার করা ফন্টের অক্ষরগুলির মতো একই অনুপাতের অনুপাতের সাথে (এটি অনুপাতের রেশিও সংরক্ষণ করবে, ভুলে যাবেন না যে অক্ষরগুলি সাধারণত এক্স অক্ষরে কিছুটা ওভারল্যাপ করে)
  2. প্রতিটি অঞ্চলের তীব্রতা গণনা ( dot )
  3. কাছের তীব্রতা / আকারের সাথে অক্ষর map থেকে অক্ষর দ্বারা এটি প্রতিস্থাপন করুন

চরিত্র এবং বিন্দুর মধ্যে কীভাবে দূরত্ব গণনা করা যায়? এটি এই পদ্ধতির সবচেয়ে শক্ত অংশ। পরীক্ষা করার সময় আমি গতি, গুণমান এবং সরলতার মধ্যে এই সমঝোতা বিকাশ করি:

  1. অঞ্চলগুলিতে চরিত্রের অঞ্চল ভাগ করুন

    • আপনার রূপান্তর বর্ণমালা ( map ) থেকে প্রতিটি অক্ষরের বাম, ডান, উপরে, নীচে এবং কেন্দ্রের অঞ্চলের জন্য পৃথক তীব্রতা গণনা করুন
    • সমস্ত তীব্রতা স্বাভাবিক করুন যাতে তারা ক্ষেত্রের আকারে স্বতন্ত্র হয় i=(i*256)/(xs*ys)
  2. আয়তক্ষেত্র অঞ্চলগুলিতে উত্স উত্স চিত্র

    • (লক্ষ্য হরফ হিসাবে একই দিক অনুপাত সহ)
    • প্রতিটি ক্ষেত্রের জন্য বুলেট 1 এর মতো একই পদ্ধতিতে গণনা তীব্রতা
    • রূপান্তর বর্ণমালায় তীব্রতা থেকে নিকটতম ম্যাচটি সন্ধান করুন
    • আউটপুট লাগানো অক্ষর

এটি ফন্টের আকার = 7px এর ফলাফল

আপনি দেখতে পাচ্ছেন আউটপুটটি আরও বড় আকারের ফন্টের আকারের সাথে দৃষ্টিভঙ্গি করছে (পূর্ববর্তী পদ্ধতির উদাহরণটি 5px ফন্টের আকারের সাথে ছিল)। আউটপুট মোটামুটি ইনপুট চিত্রের সমান আকার (জুম নেই)। আরও ভাল ফলাফল অর্জন করা হয়েছে কারণ অক্ষরগুলি কেবলমাত্র তীব্রতার দ্বারা নয় সামগ্রিক আকারের সাথেও মূল চিত্রের আরও কাছাকাছি থাকে এবং তাই আপনি বৃহত্তর ফন্টগুলি ব্যবহার করতে পারেন এবং এখনও বিশদ সংরক্ষণ করতে পারেন (মোটা বিন্দু অবধি)।

ভিসিএল ভিত্তিক রূপান্তর অ্যাপ্লিকেশনটির জন্য এখানে সম্পূর্ণ কোড:

//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop

#include "win_main.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
Graphics::TBitmap *bmp=new Graphics::TBitmap;
//---------------------------------------------------------------------------
class intensity
    {
public:
    char c;                 // character
    int il,ir,iu,id,ic;     // intensity of part: left,right,up,down,center
    intensity() { c=0; reset(); }
    void reset() { il=0; ir=0; iu=0; id=0; ic=0; }
    void compute(DWORD **p,int xs,int ys,int xx,int yy) // p source image, (xs,ys) area size, (xx,yy) area position
        {
        int x0=xs>>2,y0=ys>>2;
        int x1=xs-x0,y1=ys-y0;
        int x,y,i;
        reset();
        for (y=0;y<ys;y++)
         for (x=0;x<xs;x++)
            {
            i=(p[yy+y][xx+x]&255);
            if (x<=x0) il+=i;
            if (x>=x1) ir+=i;
            if (y<=x0) iu+=i;
            if (y>=x1) id+=i;
            if ((x>=x0)&&(x<=x1)
              &&(y>=y0)&&(y<=y1)) ic+=i;
            }
        // normalize
        i=xs*ys;
        il=(il<<8)/i;
        ir=(ir<<8)/i;
        iu=(iu<<8)/i;
        id=(id<<8)/i;
        ic=(ic<<8)/i;
        }
    };
//---------------------------------------------------------------------------
AnsiString bmp2txt_big(Graphics::TBitmap *bmp,TFont *font) // charcter sized areas
    {
    int i,i0,d,d0;
    int xs,ys,xf,yf,x,xx,y,yy;
    DWORD **p=NULL,**q=NULL;    // bitmap direct pixel access
    Graphics::TBitmap *tmp;     // temp bitmap for single character
    AnsiString txt="";          // output ASCII art text
    AnsiString eol="\r\n";      // end of line sequence
    intensity map[97];          // character map
    intensity gfx;

    // input image size
    xs=bmp->Width;
    ys=bmp->Height;
    // output font size
    xf=font->Size;   if (xf<0) xf=-xf;
    yf=font->Height; if (yf<0) yf=-yf;
    for (;;) // loop to simplify the dynamic allocation error handling
        {
        // allocate and init buffers
        tmp=new Graphics::TBitmap; if (tmp==NULL) break;
            // allow 32bit pixel access as DWORD/int pointer
            tmp->HandleType=bmDIB;    bmp->HandleType=bmDIB;
            tmp->PixelFormat=pf32bit; bmp->PixelFormat=pf32bit;
            // copy target font properties to tmp
            tmp->Canvas->Font->Assign(font);
            tmp->SetSize(xf,yf);
            tmp->Canvas->Font ->Color=clBlack;
            tmp->Canvas->Pen  ->Color=clWhite;
            tmp->Canvas->Brush->Color=clWhite;
            xf=tmp->Width;
            yf=tmp->Height;
        // direct pixel access to bitmaps
        p  =new DWORD*[ys];        if (p  ==NULL) break; for (y=0;y<ys;y++) p[y]=(DWORD*)bmp->ScanLine[y];
        q  =new DWORD*[yf];        if (q  ==NULL) break; for (y=0;y<yf;y++) q[y]=(DWORD*)tmp->ScanLine[y];
        // create character map
        for (x=0,d=32;d<128;d++,x++)
            {
            map[x].c=char(DWORD(d));
            // clear tmp
            tmp->Canvas->FillRect(TRect(0,0,xf,yf));
            // render tested character to tmp
            tmp->Canvas->TextOutA(0,0,map[x].c);
            // compute intensity
            map[x].compute(q,xf,yf,0,0);
            } map[x].c=0;
        // loop through image by zoomed character size step
        xf-=xf/3; // characters are usually overlaping by 1/3
        xs-=xs%xf;
        ys-=ys%yf;
        for (y=0;y<ys;y+=yf,txt+=eol)
         for (x=0;x<xs;x+=xf)
            {
            // compute intensity
            gfx.compute(p,xf,yf,x,y);
            // find closest match in map[]
            i0=0; d0=-1;
            for (i=0;map[i].c;i++)
                {
                d=abs(map[i].il-gfx.il)
                 +abs(map[i].ir-gfx.ir)
                 +abs(map[i].iu-gfx.iu)
                 +abs(map[i].id-gfx.id)
                 +abs(map[i].ic-gfx.ic);
                if ((d0<0)||(d0>d)) { d0=d; i0=i; }
                }
            // add fitted character to output
            txt+=map[i0].c;
            }
        break;
        }
    // free buffers
    if (tmp) delete tmp;
    if (p  ) delete[] p;
    return txt;
    }
//---------------------------------------------------------------------------
AnsiString bmp2txt_small(Graphics::TBitmap *bmp)    // pixel sized areas
    {
    AnsiString m=" `'.,:;i+o*%&$#@"; // constant character map
    int x,y,i,c,l;
    BYTE *p;
    AnsiString txt="",eol="\r\n";
    l=m.Length();
    bmp->HandleType=bmDIB;
    bmp->PixelFormat=pf32bit;
    for (y=0;y<bmp->Height;y++)
        {
        p=(BYTE*)bmp->ScanLine[y];
        for (x=0;x<bmp->Width;x++)
            {
            i =p[(x<<2)+0];
            i+=p[(x<<2)+1];
            i+=p[(x<<2)+2];
            i=(i*l)/768;
            txt+=m[l-i];
            }
        txt+=eol;
        }
    return txt;
    }
//---------------------------------------------------------------------------
void update()
    {
    int x0,x1,y0,y1,i,l;
    x0=bmp->Width;
    y0=bmp->Height;
    if ((x0<64)||(y0<64)) Form1->mm_txt->Text=bmp2txt_small(bmp);
     else                 Form1->mm_txt->Text=bmp2txt_big  (bmp,Form1->mm_txt->Font);
    Form1->mm_txt->Lines->SaveToFile("pic.txt");
    for (x1=0,i=1,l=Form1->mm_txt->Text.Length();i<=l;i++) if (Form1->mm_txt->Text[i]==13) { x1=i-1; break; }
    for (y1=0,i=1,l=Form1->mm_txt->Text.Length();i<=l;i++) if (Form1->mm_txt->Text[i]==13) y1++;
    x1*=abs(Form1->mm_txt->Font->Size);
    y1*=abs(Form1->mm_txt->Font->Height);
    if (y0<y1) y0=y1; x0+=x1+48;
    Form1->ClientWidth=x0;
    Form1->ClientHeight=y0;
    Form1->Caption=AnsiString().sprintf("Picture -> Text ( Font %ix%i )",abs(Form1->mm_txt->Font->Size),abs(Form1->mm_txt->Font->Height));
    }
//---------------------------------------------------------------------------
void draw()
    {
    Form1->ptb_gfx->Canvas->Draw(0,0,bmp);
    }
//---------------------------------------------------------------------------
void load(AnsiString name)
    {
    bmp->LoadFromFile(name);
    bmp->HandleType=bmDIB;
    bmp->PixelFormat=pf32bit;
    Form1->ptb_gfx->Width=bmp->Width;
    Form1->ClientHeight=bmp->Height;
    Form1->ClientWidth=(bmp->Width<<1)+32;
    }
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner):TForm(Owner)
    {
    load("pic.bmp");
    update();
    }
//---------------------------------------------------------------------------
void __fastcall TForm1::FormDestroy(TObject *Sender)
    {
    delete bmp;
    }
//---------------------------------------------------------------------------
void __fastcall TForm1::FormPaint(TObject *Sender)
    {
    draw();
    }
//---------------------------------------------------------------------------
void __fastcall TForm1::FormMouseWheel(TObject *Sender, TShiftState Shift,int WheelDelta, TPoint &MousePos, bool &Handled)
    {
    int s=abs(mm_txt->Font->Size);
    if (WheelDelta<0) s--;
    if (WheelDelta>0) s++;
    mm_txt->Font->Size=s;
    update();
    }
//---------------------------------------------------------------------------

TMemo mm_txt একক TMemo mm_txt সহ এটি সাধারণ ফর্ম অ্যাপ (ফর্ম 1)। এটি চিত্র "pic.bmp" লোড করে, তারপরে রেজোলিউশন অনুসারে কোন "pic.bmp" টেক্সট "pic.txt" সংরক্ষণ করা হয় এবং ভিজ্যুয়ালাইজ করার জন্য মেমোতে প্রেরণ করা হয় সেই পাঠ্যে রূপান্তর করতে কোন পদ্ধতির ব্যবহার করতে হবে তা চয়ন করুন। ভিসিএল ছাড়া তাদের জন্য ভিসিএল স্টাফ উপেক্ষা করুন এবং আপনার যে কোনও স্ট্রিং টাইপের সাথে AnsiString প্রতিস্থাপন করুন, এবং পিক্সেল অ্যাক্সেস ক্ষমতা সহ আপনার যে কোনও বিটম্যাপ বা চিত্র শ্রেণীর সাথে Graphics::TBitmap

খুব গুরুত্বপূর্ণ নোটটি হ'ল এটি mm_txt->Font সেটিংস ব্যবহার করে তাই আপনার সেটটি নিশ্চিত করে নিন:

  • Font->Pitch=fpFixed
  • Font->Charset=OEM_CHARSET
  • Font->Name="System"

এই কাজটি সঠিকভাবে করাতে অন্যথায় ফন্টটি মনো-স্পেস ব্যবধান হিসাবে পরিচালিত হবে না। মাউস হুইল বিভিন্ন ফন্টের আকারের ফলাফল দেখতে স্রেফ উপরে / নীচে ফন্টের আকার পরিবর্তন করে

[নোট]

  • ওয়ার্ড প্রতিকৃতি দেখুন
  • বিটম্যাপ / ফাইল অ্যাক্সেস এবং পাঠ্য আউটপুট ক্ষমতা সহ ভাষা ব্যবহার করুন
  • দৃ approach়ভাবে প্রথম পদ্ধতির সাথে শুরু করার পরামর্শ দিন কারণ এটি খুব সহজ স্ট্রেইট সামনের এবং সহজ, এবং কেবল তখন দ্বিতীয়টিতে চলে যান (যা প্রথম সংশোধন হিসাবে সম্পন্ন করা যায় তাই বেশিরভাগ কোড যেমন হয় তেমন থাকে)
  • বিপরীত তীব্রতার সাথে গণনা করা ভাল ধারণা (কালো পিক্সেল সর্বাধিক মান) কারণ স্ট্যান্ডার্ড পাঠ্য পূর্বরূপ সাদা ব্যাকগ্রাউন্ডে রয়েছে সুতরাং আরও ভাল ফলাফলের দিকে নিয়ে যায়।
  • আপনি মহকুমা অঞ্চলগুলির আকার, গণনা এবং বিন্যাসের সাথে পরীক্ষা করতে পারেন বা এর পরিবর্তে 3x3 মতো কিছু গ্রিড ব্যবহার করতে পারেন।

[সম্পাদনা 1] তুলনা

অবশেষে এখানে একই ইনপুটটিতে দুটি পদ্ধতির মধ্যে একটি তুলনা করা হয়েছে:

সবুজ ডট চিহ্নিত চিত্রগুলি # 2 পদ্ধতির সাথে সম্পন্ন হয় এবং 6 পিক্সেল ফন্টের আকারের সাথে # 1 দিয়ে লাল রঙের হয়। আপনি যেমন লাইট বাল্বের চিত্রটিতে দেখতে পাচ্ছেন আকারটি সংবেদনশীল পদ্ধতিটি আরও ভাল (এমনকি যদি 2x জুমেড উত্স চিত্রটিতে # 1 করা হয়ে থাকে)।

[সম্পাদনা 2] দুর্দান্ত অ্যাপ্লিকেশন

আজকের নতুন প্রশ্নগুলি পড়ার সময় আমি একটি দুর্দান্ত অ্যাপের আইডিয়া পেয়েছি যা ডেস্কটপের নির্বাচিত অঞ্চলটিকে ধরে ফেলে এবং অবিচ্ছিন্নভাবে এটি এএসসিআইআরটি রূপান্তরকারীকে খাওয়ায় এবং ফলাফলটি দেখে। কোডিংয়ের এক ঘন্টা পরে এটি হয়ে গেছে এবং আমি ফলাফলটি নিয়ে এতটাই সন্তুষ্ট যে আমাকে অবশ্যই এটি এখানে যুক্ত করতে হবে।

ঠিক আছে অ্যাপটিতে মাত্র 2 টি উইন্ডো রয়েছে। চিত্রের নির্বাচন এবং পূর্বরূপ ছাড়াই প্রথম মাস্টার উইন্ডোটি মূলত আমার পুরানো কনভার্টর উইন্ডো (উপরের সমস্ত জিনিস এতে রয়েছে)। এটিতে কেবল ASCII পূর্বরূপ এবং রূপান্তর সেটিংস রয়েছে। দ্বিতীয় উইন্ডোটি দখল ক্ষেত্র নির্বাচনের জন্য স্বচ্ছ ভিতরে ভিতরে খালি ফর্ম (কোনও কার্যকারিতা নেই)।

এখন টাইমারে আমি কেবল নির্বাচিত অঞ্চলটি বাছাই করে ফর্মটি দ্বারা রূপান্তর করতে পারি এবং এএসসিআইআরটি পূর্বরূপ দেখতে পারি

সুতরাং আপনি নির্বাচনটি উইন্ডোটি সংযুক্ত করুন যা আপনি নির্বাচন উইন্ডো দ্বারা রূপান্তর করতে চান এবং ফলাফলটি মাস্টার উইন্ডোতে দেখতে চান। এটি একটি খেলা, দর্শক হতে পারে ... ... এটির মতো দেখাচ্ছে:

তাই এখন আমি মজাদার জন্য ASCIIart এ এমনকি ভিডিও দেখতে পারি। কিছু সত্যিই চমৎকার :)।

[Edit3]

আপনি যদি GLSL এ এটি প্রয়োগ করার চেষ্টা করতে চান তবে এটি একবার দেখুন:

  • ভাসমান-পয়েন্ট নম্বরগুলিকে জিএলএসএলে দশমিক সংখ্যায় রূপান্তর করবেন?

প্রস্তাবনা

এই সাবজেক্টটি এখানে সময়ে সময়ে এসও- তে পপ আপ হয় তবে সাধারণত একটি খারাপ লেখার প্রশ্ন হওয়ায় তা সরানো হয়। আমি এই জাতীয় অনেকগুলি প্রশ্ন দেখেছি এবং তারপরে অতিরিক্ত তথ্যের জন্য অনুরোধ করা হলে ওপি (স্বাভাবিক নিম্ন প্রতিনিধি) থেকে নীরবতা রেখেছি। সময়ে সময়ে যদি ইনপুটটি আমার পক্ষে যথেষ্ট ভাল হয় তবে আমি একটি উত্তর দিয়ে সাড়া দেওয়ার সিদ্ধান্ত নিয়েছি এবং এটি সচল থাকাকালীন প্রতিদিন প্রতিদিন কয়েকটি আপ-ভোট পায় তবে কয়েক সপ্তাহ পরে প্রশ্নটি মুছে ফেলা / মুছে ফেলা হয় এবং সমস্ত শুরু থেকেই শুরু হয় । তাই আমি এই প্রশ্নোত্তর লিখতে সিদ্ধান্ত নিয়েছি তাই উত্তরগুলি বারবার লিখে না করে সরাসরি এই জাতীয় প্রশ্নগুলি উল্লেখ করতে পারি…

আর একটি কারণও এই মেটা থ্রেডটি আমাকে লক্ষ্য করে লক্ষ্য করা যায় তাই যদি আপনি অতিরিক্ত ইনপুট পেয়ে থাকেন তবে বিনা দ্বিধায় মন্তব্য করতে পারেন।

প্রশ্ন

সি ++ ব্যবহার করে কীভাবে বিটম্যাপ চিত্রকে ASCII আর্টে রূপান্তর করবেন?

কিছু বাধা:

  • ধূসর স্কেল ইমেজ
  • মনো-ফাঁক ফন্ট ব্যবহার করে
  • এটিকে সহজ করে তোলা (প্রাথমিক স্তরের প্রোগ্রামারদের জন্য খুব উন্নত জিনিস ব্যবহার না করা)

এখানে সম্পর্কিত উইকি পৃষ্ঠার ASCII শিল্প (@ রোজাররোল্যান্ডকে ধন্যবাদ)





ascii-art