Freetype 获取宋体(simsun.ttc)12-17号字的位图并打印输出

[523066680]

编辑 523066680
日期 2016-12

打印宋体中的固定尺寸字号的位图（这种位图没有经过 Hint 处理，边界清晰，适合小字体时显示）
对于一个字体包含的位图信息，以及支持多少字号的位图，可以通过
face->num_fixed_sizes 查询支持的字号数目，通过 face->available_sizes[n] 遍历那些包含位图的字号的值。

注意代码保存为 UTF8 格式

Code: [全选] [展开/折叠] [Download] (FixedSize.cpp)

1. // Code By: 523066680
2. //    Date: 2016-12
3. // 提取位图，以终端点阵形式画出
4.  
5. #include <wchar.h>
6. #include <stdio.h>
7. #include <ft2build.h>
8. #include FT_FREETYPE_H
9.  
10. #define FONTSIZE 16
11. #define SLOT_H (FONTSIZE + FONTSIZE/6)
12. #define SLOT_W (FONTSIZE + FONTSIZE/6)
13.  
14. int winID;
15. FT_Library      library;
16. FT_Face         face;
17.  
18. FT_GlyphSlot    slot;
19. FT_Error        error;
20. FT_Outline      outline;
21. FT_Bitmap       bitmap;
22.  
23. wchar_t ustr[] = L"中文ab";
24.  
25. void LoadGlyph(long symbol);
26. void LoadChar(long symbol);
27. void err( char str[] );
28.  
29. void printBinary( unsigned char n )
30. {
31.     unsigned char value;
32.  
33.     for (unsigned char i = 0; i < 8; i++)
34.     {
35.         value = (n >> (7-i) ) & 1;
36.         printf("%d", value );
37.     }
38. }
39.  
40. void display(void)
41. {
42.     int ybegin = 0;
43.     int xbegin = 0;
44.     int yi;
45.     int xi;
46.     int value;
47.  
48.     int n_text = sizeof( ustr )/sizeof( ustr[0] ) - 1;
49.  
50.     unsigned char image[SLOT_H][SLOT_W];
51.  
52.     memset(image, 2, SLOT_H * SLOT_W );
53.  
54.     LoadChar( ustr[0] );
55.     bitmap = slot->bitmap;
56.  
57.     int w_byte = bitmap.width / 8 + !!(bitmap.width % 8);
58.  
59.     //容器高度 - (bearingY + baseline) 作为y起点
60.     ybegin = SLOT_H - (slot->bitmap_top + FONTSIZE/6);
61.     xi = 0;
62.     yi = SLOT_H - ybegin;               //上下反转
63.  
64.     //将1bit深度的位图数据装载到容器（image）中
65.     for (int row = 0; row < bitmap.rows; row++ )
66.     {
67.         yi --;
68.  
69.         if ( ( yi < 0 ) || ( yi >= SLOT_H ) )
70.             continue;
71.  
72.         xi = slot->bitmap_left;
73.  
74.         for (int wi = 0; wi < bitmap.width; wi++ ) //只提取width范围内的bits 多余的0不管
75.         {
76.             value = ( bitmap.buffer[ row*w_byte + wi/8 ] >> ( 7 - wi%8 ) ) & 0b1;
77.             image[yi][xi+wi] = value;
78.         }
79.     }
80.  
81.     //直接输出
82.     for (int i = 0; i < bitmap.rows * w_byte; i++ )
83.     {
84.         printBinary( bitmap.buffer[i] );
85.         if ( i % 2 == 1) printf("\n");
86.     }
87.     printf("\n");
88.  
89.     //处理好的位图数据输出（再次反向）
90.     for (int ny = 0; ny < SLOT_H; ny ++)
91.     {
92.         for (int nx = 0; nx < SLOT_W; nx ++)
93.         {
94.             printf("%d", image[SLOT_H-ny-1][nx] );
95.         }
96.         printf("\n");
97.     }
98. }
99.  
100. void ftinit(void)
101. {
102.     char*   filename;
103.     filename = "C:/windows/fonts/simsun.ttc";
104.  
105.     error = FT_Init_FreeType( &library );
106.     error = FT_New_Face( library, filename, 0, &face );
107.     if (error) err("load font-face error\n");
108.  
109.     error = FT_Set_Char_Size( face, FONTSIZE*64, 0, 0, 0 );
110.     if (error) err("Set Char Size error\n");
111.  
112.     printf("Font fixed sizes:");
113.     for ( int i = 0; i < face->num_fixed_sizes; i++  )
114.     {
115.         printf("%d ", face->available_sizes[i].size /64);
116.     }
117.     printf("\n");
118. }
119.  
120. void LoadChar(long symbol)
121. {
122.     //symbol可以是unicode编码值
123.     //FT_UInt index = FT_Get_Char_Index(face, symbol);
124.     error = FT_Load_Char( face, symbol, FT_LOAD_RENDER    );
125.     slot = face->glyph;
126. }
127.  
128. int main( int argc, char** argv )
129. {
130.     ftinit();
131.     display();
132.  
133.     FT_Done_Face        ( face );
134.     FT_Done_FreeType( library );
135.     return 0;
136. }
137.  
138. void err( char str[] )
139. {
140.     printf("%s", str);
141.     exit(0);
142. }

输出

Code: [全选] [展开/折叠] [Download] (Untitled.txt)

1. Font fixed sizes:12 13 14 15 16 17
2. 0000010000000000
3. 0000010000000000
4. 0000010000000000
5. 0000010000000000
6. 1111111111100000
7. 1000010000100000
8. 1000010000100000
9. 1000010000100000
10. 1000010000100000
11. 1000010000100000
12. 1111111111100000
13. 1000010000100000
14. 0000010000000000
15. 0000010000000000
16. 0000010000000000
17. 0000010000000000
18.  
19. 222222222222222222
20. 222222222222222222
21. 220000010000022222
22. 220000010000022222
23. 220000010000022222
24. 220000010000022222
25. 221111111111122222
26. 221000010000122222
27. 221000010000122222
28. 221000010000122222
29. 221000010000122222
30. 221000010000122222
31. 221111111111122222
32. 221000010000122222
33. 220000010000022222
34. 220000010000022222
35. 220000010000022222
36. 220000010000022222

第一个输出是直接的点阵，在多个不同字符并排显示的时候可能高低不平。以及右边有多余的0是作为填充的。
第二个是装载到一个固定大小的容器中，并且移动到合适的位置上，适合多个字体并排。

在处理过程中将 Y 反过来处理了，因为在一些图形接口中渲染位图，上下是反过来的。