आधुनिक लिनक्स टेक्स्ट रेंडरिंग के पहले भाग में आपका स्वागत है। इस श्रृंखला के प्रत्येक लेख में, हम एक चरित्र या वर्णों के अनुक्रम की कल्पना करने के लिए एक स्व-निहित सी कार्यक्रम विकसित करेंगे। इनमें से प्रत्येक कार्यक्रम एक फ़ंक्शन को लागू करेगा जिसे मैं आधुनिक पाठ प्रतिपादन के लिए आवश्यक मानता हूं।

पहले भाग में हम FreeType को कॉन्फ़िगर करेंगे और कंसोल में एक साधारण प्रतीक रेंडरर लिखेंगे।



यह वही है जो हम लिखेंगे। और यहाँ कोड है।

सिस्टम सेटअप

• मेरा ऑपरेटिंग सिस्टम: Ubuntu 18.04.2 LTS (bionic)
  
• सी कंपाइलर: clang version 6.0.0-1ubuntu2

फ्री टाइप स्थापित करें

Ubuntu पर, आपको FreeType और libpng इंस्टॉल करने की आवश्यकता है।

 $ sudo apt install libfreetype6 libfreetype6-dev $ sudo apt install libpng16-16 libpng-dev 

• मेरे पास FreeType संस्करण 2.8.1-2ubuntu2 , हालांकि लेखन के समय, FreeType-2.10.1 नवीनतम संस्करण FreeType-2.10.1 , यह भी काम करता है।
  
• libpng संस्करण (1.6.34-1ubuntu0.18.04.2)

कंसोल रेंडरर

C फ़ाइल बनाएँ (मेरे मामले में main.c )

 #include <stdio.h> int main() { printf("Hello, world\n"); return 0; } 

 $ clang -Wall -Werror -o main main.c $ ./main Hello, world 

हम फ्री टाइप के पुस्तकालयों को जोड़ते हैं

शामिल पथ के लिए खोज करने के लिए (यानी, निर्देशिका जो कंपाइलर के माध्यम से जाता है जब FreeType के लिए #include में फ़ाइलें खोजते हैं), चलाएँ:

 $ pkg-config --cflags freetype2 -I/usr/include/freetype2 -I/usr/include/libpng16 

लाइन -I/usr/include/freetype2 -I/usr/include/libpng16 में C कार्यक्रम में -I/usr/include/freetype2 -I/usr/include/libpng16 को सक्षम करने के लिए आवश्यक संकलन झंडे शामिल हैं।

 #include <stdio.h> #include <freetype2/ft2build.h> #include FT_FREETYPE_H int main() { printf("Hello, world\n"); return 0; } 

 $ clang -I/usr/include/freetype2 \ -I/usr/include/libpng16 \ -Wall -Werror \ -o main \ main.c $ ./main Hello, world 

हम FreeType का संस्करण प्रिंट करते हैं

main() अंदर main() FreeType को FT_Init_FreeType(&ft) प्रारंभ करें और त्रुटियों के लिए जांच करें (यदि सफल हो तो FreeType फ़ंक्शन 0 लौटाते हैं)।

(अब से, मेरे द्वारा उपयोग किए जाने वाले सभी फ़ंक्शंस FreeType API की मदद से लिए जाएंगे)।

 FT_Library ft; FT_Error err = FT_Init_FreeType(&ft); if (err != 0) { printf("Failed to initialize FreeType\n"); exit(EXIT_FAILURE); } 

फिर FT_Library_Version का उपयोग करके हम संस्करण संख्या प्राप्त करते हैं।

 FT_Int major, minor, patch; FT_Library_Version(ft, &major, &minor, &patch); printf("FreeType's version is %d.%d.%d\n", major, minor, patch); 

यदि अंतिम आदेश का उपयोग करके संकलित किया जाता है, तो एक लिंकर त्रुटि पॉप अप होगी:

 /tmp/main-d41304.o: In function `main': main.c:(.text+0x14): undefined reference to `FT_Init_FreeType' main.c:(.text+0x54): undefined reference to `FT_Library_Version' clang: error: linker command failed with exit code 1 (use -v to see invocation) 

इसे ठीक करने के लिए, -lfreetype जोड़ें।

 $ clang -I/usr/include/freetype2 \ -I/usr/include/libpng16 \ -Wall -Werror \ -o main \ -lfreetype \ main.c $ ./main FreeType's version is 2.8.1 

फ़ॉन्ट डाउनलोड

एक चरित्र को प्रस्तुत करने के लिए पहला चरण एक फ़ॉन्ट फ़ाइल डाउनलोड करना है। मैं ubuntu मोनो का उपयोग कर रहा हूं।

एक फ़ॉन्ट चेहरे के निर्माण, एक फ़ॉन्ट परिवार और अलग-अलग फ़ॉन्ट के बीच सटीक अंतर को समझने के लिए, फ्री टाइप प्रलेखन देखें ।

तीसरे तर्क को फेस इंडेक्स कहा जाता है। यह फ़ॉन्ट रचनाकारों को एक ही फ़ॉन्ट आकार में कई चेहरे सम्मिलित करने की अनुमति देने के लिए डिज़ाइन किया गया है। चूंकि प्रत्येक फ़ॉन्ट में कम से कम एक चेहरा होता है, इसलिए 0 का मान हमेशा काम करेगा, पहला विकल्प चुनना।

  FT_Face face; err = FT_New_Face(ft, "./UbuntuMono.ttf", 0, &face); if (err != 0) { printf("Failed to load face\n"); exit(EXIT_FAILURE); } 

चेहरे के लिए पिक्सेल आकार सेट करें

इस निर्देश का उपयोग करते हुए, हम FreeType को प्रदर्शित वर्णों के लिए वांछित चौड़ाई और ऊँचाई बताते हैं।

यदि आप चौड़ाई के लिए शून्य पास करते हैं, तो FreeType इस मामले में "दूसरों के समान," इस मामले में 32px की व्याख्या करता है। इसका उपयोग किसी वर्ण को प्रदर्शित करने के लिए किया जा सकता है, उदाहरण के लिए, 10px की चौड़ाई और 16px की ऊँचाई के साथ।

यह ऑपरेशन एक निश्चित आकार के फ़ॉन्ट पर विफल हो सकता है, जैसा कि इमोजी के मामले में है।

 err = FT_Set_Pixel_Sizes(face, 0, 32); if (err != 0) { printf("Failed to set pixel size\n"); exit(EXIT_FAILURE); } 

चरित्र के लिए सूचकांक प्राप्त करना

सबसे पहले, फ्रीटाइप प्रलेखन पर वापस जाएं और एक नामकरण सम्मेलन की स्थापना करें। एक प्रतीक एक ग्लिफ़ के समान नहीं है। एक चरित्र वह है जो char कहता है, और एक ग्लिफ़ एक छवि है जो किसी तरह उस चरित्र से जुड़ी होती है। यह संबंध बल्कि जटिल है क्योंकि चार कई ग्लिफ़ के अनुरूप हो सकते हैं: अर्थात् उच्चारण। एक ग्लिफ़ कई वर्णों के अनुरूप हो सकता है: वह है, लिगुरिंग्स, जहां -> को एकल छवि के रूप में दर्शाया गया है।

चरित्र के अनुरूप ग्लिफ़ सूचकांक प्राप्त करने के लिए, हम FT_Get_Char_Index उपयोग FT_Get_Char_Index । जैसा कि आप समझ सकते हैं, इसमें मिलान वर्ण और ग्लिफ़ केवल एक से एक शामिल हैं। इस श्रृंखला में एक भविष्य के लेख में, हम हर्फ़बज़ लाइब्रेरी का उपयोग करके समस्या का समाधान करेंगे।

  FT_UInt glyph_index = FT_Get_Char_Index(face, 'a'); 

चेहरे से एक ग्लिफ़ लोड हो रहा है

ग्लिफ़_इंडेक्स प्राप्त करने के बाद, हम अपने चेहरे से संबंधित ग्लिफ़ को लोड कर सकते हैं।

भविष्य की किस्त में, हम विभिन्न डाउनलोड फ्लैग के बारे में विस्तार से चर्चा करेंगे और वे आपको हिन्टिंग और बिटमैप फोंट जैसी सुविधाओं का उपयोग करने की अनुमति कैसे देंगे।

 FT_Int32 load_flags = FT_LOAD_DEFAULT; err = FT_Load_Glyph(face, glyph_index, load_flags); if (err != 0) { printf("Failed to load glyph\n"); exit(EXIT_FAILURE); } 

अपने कंटेनर में एक ग्लिफ़ प्रदर्शित करें (ग्लिफ़ स्लॉट)

अब हम अंत में अपने ग्लिफ़ को उसके कंटेनर (स्लॉट) में प्रदर्शित कर सकते हैं, जो face->glyph में निर्दिष्ट है।

हम भविष्य में रेंडरिंग फ्लैग पर भी चर्चा करेंगे, क्योंकि वे एलसीडी- (या सब-पिक्सल) रेंडरिंग और ग्रेस्केल एंटीलिएजिंग के उपयोग की अनुमति देते हैं।

 FT_Int32 render_flags = FT_RENDER_MODE_NORMAL; err = FT_Render_Glyph(face->glyph, render_flags); if (err != 0) { printf("Failed to render the glyph\n"); exit(EXIT_FAILURE); } 

कंसोल के लिए वर्ण आउटपुट

प्रदान किए गए ग्लिफ़ का बिटमैप face->glyph->bitmap.buffer से प्राप्त किया जा सकता face->glyph->bitmap.buffer , जहां इसे अहस्ताक्षरित चार मूल्यों की एक सरणी के रूप में प्रस्तुत किया जाता है, इसलिए इसका मान 0 से 255 तक होता है।

बफर को एक आयामी आयाम के रूप में लौटाया जाता है, लेकिन एक 2D छवि है। J-th कॉलम की i-th पंक्ति को एक्सेस करने के लिए, हम column * row_width + row गणना करते हैं, जैसा कि bitmap.buffer[i * face->glyph->bitmap.pitch + j] में है। bitmap.buffer[i * face->glyph->bitmap.pitch + j] ।

आप देख सकते हैं कि ऐरे को एक्सेस करते समय हमने एक लूप और bitmap.width में bitmap.width का उपयोग किया है, क्योंकि पिक्सल की प्रत्येक लाइन की लंबाई bitmap.width बराबर है, लेकिन बफर की "चौड़ाई" bitmap.pitch ।

निम्नलिखित कोड में, सभी पंक्तियों और स्तंभों को क्रमबद्ध किया जाता है, और पिक्सेल की चमक के आधार पर विभिन्न वर्णों को खींचा जाता है।

 for (size_t i = 0; i < face->glyph->bitmap.rows; i++) { for (size_t j = 0; j < face->glyph->bitmap.width; j++) { unsigned char pixel_brightness = face->glyph->bitmap.buffer[i * face->glyph->bitmap.pitch + j]; if (pixel_brightness > 169) { printf("*"); } else if (pixel_brightness > 84) { printf("."); } else { printf(" "); } } printf("\n"); } 

कंसोल आउटपुट।

 $ clang -I/usr/include/freetype2 \ -I/usr/include/libpng16 \ -Wall -Werror \ -o main \ -lfreetype \ main.c && ./main FreeType's version is 2.8.1 .*****. .********. .********* . ***. *** *** .******** *********** .**. *** *** *** *** *** ***. *** .*********** *********** .*******.. 

→ यहाँ पूरा कोड देखा जा सकता है

निष्कर्ष

हमने कंसोल में एक बेसिक कैरेक्टर रेंडर बनाया है। इस उदाहरण को इमोजी, सब-पिक्सेल रेंडरिंग, लिगचर और अन्य का समर्थन करने के लिए ओपनजीएल टेक्सचर में पात्रों को प्रस्तुत करने के लिए (और) बढ़ाया जा सकता है। अगले भाग में, हम एलसीडी सबपिक्सल स्मूदिंग के बारे में बात करेंगे, जो कि ग्रे, उनके पेशेवरों और विपक्ष के रंगों की तुलना में है।

जल्द मिलते हैं।