[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[freetype2] arv-work 78e74cf: Add HTML generating code
|
From: |
Arvinder Bhathal |
|
Subject: |
[freetype2] arv-work 78e74cf: Add HTML generating code |
|
Date: |
Sat, 8 Jul 2017 02:27:10 -0400 (EDT) |
branch: arv-work
commit 78e74cf349d0b415d876f7d83284af6928247867
Author: Arvinder Bhathal <address@hidden>
Commit: Arvinder Bhathal <address@hidden>
Add HTML generating code
---
tests/web_interface/README | 5 +
tests/web_interface/bitmap.c | 439 +++++++++++++++---------------
tests/web_interface/bitmap.h | 107 +++-----
tests/web_interface/compare-new-to-old.c | 103 -------
tests/web_interface/gen.c | 14 -
tests/web_interface/generate-old-hashes.c | 64 -----
tests/web_interface/index.html | 48 ----
tests/web_interface/main.c | 230 ++++++++++++++++
tests/web_interface/readme.txt | 9 -
9 files changed, 505 insertions(+), 514 deletions(-)
diff --git a/tests/web_interface/README b/tests/web_interface/README
new file mode 100644
index 0000000..274af8e
--- /dev/null
+++ b/tests/web_interface/README
@@ -0,0 +1,5 @@
+Compile with current ft folder:
+gcc main.c bitmap.c murmur3.c -Wall -I /usr/local/include/freetype2/
-lfreetype -ldl -lpng -lm -o main
+
+Run
+./main <base libfreetype.so> <test libfreetype.so> <size> <font file>
diff --git a/tests/web_interface/bitmap.c b/tests/web_interface/bitmap.c
index 5d7e3c3..d542155 100644
--- a/tests/web_interface/bitmap.c
+++ b/tests/web_interface/bitmap.c
@@ -1,269 +1,282 @@
#include "bitmap.h"
-HASH_128 * Generate_Hash_x64_128(FT_Bitmap * bitmap, HASH_128 * murmur)
+HASH_128 * Generate_Hash_x64_128( FT_Bitmap * bitmap,
+ HASH_128 * murmur)
{
- int seed = 99; // Dont change
+ int seed = 99; // Dont change
- MurmurHash3_x64_128(bitmap->buffer, (bitmap->pitch * bitmap->rows), seed,
murmur->hash);
+ MurmurHash3_x64_128(bitmap->buffer,
+ (bitmap->pitch * bitmap->rows),
+ seed,
+ murmur->hash);
- return murmur;
+ return murmur;
}
-HASH_128 * Generate_Hash_x86_128(FT_Bitmap * bitmap, HASH_128 * murmur)
+HASH_128 * Generate_Hash_x86_128( FT_Bitmap * bitmap,
+ HASH_128 * murmur)
{
- int seed = 99; // Dont change
+ int seed = 99; // Dont change
- MurmurHash3_x86_128(bitmap->buffer, (bitmap->pitch * bitmap->rows), seed,
murmur->hash);
+ MurmurHash3_x86_128(bitmap->buffer,
+ (bitmap->pitch * bitmap->rows),
+ seed,
+ murmur->hash);
- return murmur;
+ return murmur;
}
-HASH_32 * Generate_Hash_x86_32(FT_Bitmap * bitmap, HASH_32 * murmur)
+HASH_32 * Generate_Hash_x86_32( FT_Bitmap * bitmap,
+ HASH_32 * murmur)
{
- int seed = 99; // Dont change
+ int seed = 99; // Dont change
- MurmurHash3_x86_32(bitmap->buffer, (bitmap->pitch * bitmap->rows), seed,
murmur->hash);
+ MurmurHash3_x86_32( bitmap->buffer,
+ (bitmap->pitch * bitmap->rows),
+ seed,
+ murmur->hash);
- return murmur;
+ return murmur;
}
-int Get_Padding( FT_Bitmap* bitmap ){
-
- int rem;
- if (bitmap->pixel_mode == 6)
- {
- rem = ( 3 * bitmap->width ) % 4;
- }else{
- rem = ( bitmap->width ) % 4;
- }
-
- if (!rem )
- {
- return rem;
- }
- return (4 - rem);
-}
-
-int Get_Bits_Per_Pixel ( unsigned char PIXEL_MODE) {
- if (PIXEL_MODE < 5)
- {
- return BITS_PER_PIXEL_GRAY;
- }else{
- return BITS_PER_PIXEL_LCD;
- }
+PIXEL * Pixel_At (IMAGE * bitmap, int x, int y)
+{
+ return bitmap->pixels + bitmap->width * y + x;
}
-
-void Write_Bitmap_Header (FT_Bitmap * bitmap, char * fname ) {
- FILE *fp = fopen(fname,"w"); // Bitmap File
- HEADER *header = ( HEADER* ) calloc( 1 , sizeof( HEADER ));
-
- unsigned char pixel_mode = ( bitmap->pixel_mode );
- FT_UInt image_width;
- FT_UInt image_rows;
- FT_UInt color_table_size = 0;
-
- switch(pixel_mode){
-
- case 5 : image_width = bitmap->width / 3; // LCD
- image_rows = bitmap->rows;
- break;
-
- case 6 : image_width = bitmap->width; // LCD_V
- image_rows = bitmap->rows / 3;
- break;
+int Generate_PNG (IMAGE *bitmap,
+ const char *path,
+ int render_mode)
+{
+ FILE * fp;
+ png_structp png_ptr = NULL;
+ png_infop info_ptr = NULL;
+
+ size_t x, y;
+ png_byte ** row_pointers = NULL;
+
+ int status = -1;
+
+ int pixel_size = 4;
+ int depth = 8;
+
+ fp = fopen (path, "wb");
+ if (! fp) {
+ goto fopen_failed;
+ }
+
+ png_ptr = png_create_write_struct ( PNG_LIBPNG_VER_STRING,
+ NULL,
+ NULL,
+ NULL);
+ if (png_ptr == NULL) {
+ goto png_create_write_struct_failed;
+ }
+
+ info_ptr = png_create_info_struct (png_ptr);
+ if (info_ptr == NULL) {
+ goto png_create_info_struct_failed;
+ }
+
+ if (setjmp (png_jmpbuf (png_ptr))) {
+ goto png_failure;
+ }
+
+ png_set_IHDR (png_ptr,
+ info_ptr,
+ bitmap->width,
+ bitmap->height,
+ depth,
+ PNG_COLOR_TYPE_RGBA,
+ PNG_INTERLACE_NONE,
+ PNG_COMPRESSION_TYPE_DEFAULT,
+ PNG_FILTER_TYPE_DEFAULT);
+
+ row_pointers = png_malloc ( png_ptr,
+ bitmap->height * sizeof (png_byte *));
+
+ for (y = 0; y < bitmap->height; y++) {
+
+ png_byte *row = png_malloc (png_ptr,
+ sizeof (uint8_t) * bitmap->width * pixel_size);
+ row_pointers[y] = row;
+
+ for (x = 0; x < bitmap->width; x++) {
+
+ PIXEL * pixel = Pixel_At (bitmap, x, y);
+
+ if (render_mode == 3 || render_mode == 5)
+ {
+ *row++ = pixel->blue;
+ *row++ = pixel->green;
+ *row++ = pixel->red;
+ *row++ = pixel->alpha;
+ continue;
+ }
- default : image_width = bitmap->width; // MONO
and GRAY
- image_rows = bitmap->rows;
- color_table_size = 4* 256;
- break;
+ *row++ = pixel->red;
+ *row++ = pixel->green;
+ *row++ = pixel->blue;
+ *row++ = pixel->alpha;
}
-
- FT_Int image_size;
- image_size = (image_rows * image_width );
-
- header->file_header.type = 0x4D42;
- header->file_header.file_size = sizeof(HEADER) +
color_table_size + image_size;
- header->file_header.file_offset = sizeof(HEADER) +
color_table_size;
-
- header->info_header.info_header_size = sizeof(BMP_INFO_HEADER);
- header->info_header.width = image_width ;
- header->info_header.height = - image_rows;
- header->info_header.planes = PLANES;
- header->info_header.bits_per_pixel = Get_Bits_Per_Pixel(
bitmap->pixel_mode );
- header->info_header.compression = COMPRESSION;
- header->info_header.image_size = image_size;
- header->info_header.y_pixels_per_meter = Y_PIXELS_PER_METER ;
- header->info_header.x_pixels_per_meter = X_PIXELS_PER_METER ;
- header->info_header.used_colors = USED_COLORS;
- header->info_header.important_colors = IMPORTANT_COLORS;
-
- fwrite (header, 1, sizeof(HEADER),fp);
- free(header);
- fclose(fp);
+ }
+
+ png_init_io ( png_ptr,
+ fp);
+
+ png_set_rows (png_ptr,
+ info_ptr,
+ row_pointers);
+
+ png_write_png ( png_ptr,
+ info_ptr,
+ PNG_TRANSFORM_IDENTITY,
+ NULL);
+
+ status = 0;
+
+ for (y = 0; y < bitmap->height; y++) {
+ png_free (png_ptr, row_pointers[y]);
+ }
+ png_free (png_ptr, row_pointers);
+
+ png_failure:
+ png_create_info_struct_failed:
+ png_destroy_write_struct (&png_ptr, &info_ptr);
+ png_create_write_struct_failed:
+ fclose (fp);
+ fopen_failed:
+ return status;
}
-void Write_Bitmap_Data_LCD_RGB( FT_Bitmap * bitmap, char * fname ){
+void Make_PNG(FT_Bitmap* bitmap,char* name,int i,int render_mode){
- char value;
- int i,j,k;
+ IMAGE fruit;
+ int x;
+ int y;
- FILE *fp = fopen(fname,"a");
+ unsigned char value;
+ int p;
- for (i = 0; i < bitmap->rows ; ++i)
- {
- for ( j = 2; j < bitmap->width; j = j+3)
- {
- for ( k = 0; k < 3; ++k)
- {
- value = 0xff - bitmap->buffer[( i * bitmap->pitch) + j
- k];
- fwrite (&value, 1, 1,fp);
- }
- }
- for ( k = 0; k < Get_Padding(bitmap); ++k)
- {
- value = 0xff;
- fwrite (&value, 1, 1,fp);
- }
- }
+ switch(render_mode){
- fclose(fp);
-}
+ case 0 : fruit.width = bitmap->width; // MONO and GRAY
+ fruit.height = bitmap->rows;
-void Write_Bitmap_Data_LCD_BGR( FT_Bitmap * bitmap, char * fname ){
+ fruit.pixels = calloc ( fruit.width * fruit.height,
+ sizeof (PIXEL));
- char value;
- int i,j,k;
+ for (y = 0; y < fruit.height; y++) {
+ for (x = 0; x < fruit.width; x++) {
- FILE *fp = fopen(fname,"a");
+ PIXEL * pixel = Pixel_At (& fruit, x, y);
+ p = (y * bitmap->pitch ) + x;
- for ( i = 0; i < bitmap->rows ; ++i)
- {
- for ( j = 0; j < bitmap->width; j++)
- {
- value = 0xff - bitmap->buffer[( i * bitmap->pitch) + j];
- fwrite (&value, 1, 1,fp);
- }
- for ( k = 0; k < Get_Padding(bitmap); ++k)
- {
- value = 0xff;
- fwrite (&value, 1, 1,fp);
- }
- }
+ value = bitmap->buffer[p];
+
+ if ( value != 0x00 ){
+ value = 0xff;
+ }else{
+ value = 0x00;
+ }
- fclose(fp);
-}
+ pixel->red = 255- value;
+ pixel->green = 255- value;
+ pixel->blue = 255- value;
+ pixel->alpha = 255;
+ }
+ }
+ break;
+ case 1 : fruit.width = bitmap->width; // MONO and GRAY
+ fruit.height = bitmap->rows;
-void Write_Bitmap_Data_LCD_V_BGR (FT_Bitmap * bitmap, char * fname) {
+ fruit.pixels = calloc ( fruit.width * fruit.height,
+ sizeof (PIXEL));
- FILE *fp = fopen(fname,"a");
+ for (y = 0; y < fruit.height; y++) {
+ for (x = 0; x < fruit.width; x++) {
- int i,j,k,step;
- char value;
- step = 0;
+ PIXEL * pixel = Pixel_At (& fruit, x, y);
+ p = (y * bitmap->pitch ) + x;
- while ( step < bitmap->rows ){
+ value = bitmap->buffer[p];
+
+ pixel->red = 255- value;
+ pixel->green = 255- value;
+ pixel->blue = 255- value;
+ pixel->alpha = 255;
+ }
+ }
+ break;
- for (i = 0; i < bitmap->width; i++)
- {
- for (j = step ; j < step + 3; ++j)
- {
- value = 0xff - bitmap->buffer[(j * bitmap->pitch) + i];
- fwrite (&value, 1, 1,fp);
- }
- }
- for (k = 0; k < Get_Padding(bitmap); ++k)
- {
- value = 0xff;
- fwrite (&value, 1, 1,fp);
- }
- step = step + 3; // Jumping 3 rows up
- }
+ case 2 :
+ case 3 : fruit.width = bitmap->width / 3; // LCD
+ fruit.height = bitmap->rows;
- fclose(fp);
-}
+ fruit.pixels = calloc ( fruit.width * fruit.height,
+ sizeof (PIXEL));
-void Write_Bitmap_Data_LCD_V_RGB (FT_Bitmap * bitmap, char * fname) {
+ for (y = 0; y < fruit.height; y++) {
+ for (x = 0; x < fruit.width; x++) {
- FILE *fp = fopen(fname,"a");
+ PIXEL * pixel = Pixel_At (& fruit, x, y);
+ p = (y * bitmap->pitch ) + (x)*3;
- int i,j,k,step;
- char value;
- step = 0;
+ value = bitmap->buffer[p];
+ pixel->red = 255- value;
+ p++;
- while ( step < bitmap->rows ){
+ value = bitmap->buffer[p];
+ pixel->green = 255- value;
+ p++;
- for (i = 0; i < bitmap->width; i++)
- {
- for (j = step + 2 ; j >= step; --j)
- {
- value = 0xff - bitmap->buffer[(j * bitmap->pitch) + i];
- fwrite (&value, 1, 1,fp);
- }
- }
- for (k = 0; k < Get_Padding(bitmap); ++k)
- {
- value = 0xff;
- fwrite (&value, 1, 1,fp);
- }
- step = step + 3; // Jumping 3 rows up
- }
+ value = bitmap->buffer[p];
+ pixel->blue = 255- value;
- fclose(fp);
-}
+ pixel->alpha = 255;
+ }
+ }
+ break;
-void Write_Bitmap_Data_MONO (FT_Bitmap * bitmap, char * fname) {
+ case 4 :
+ case 5 : fruit.width = bitmap->width; // LCD_V
+ fruit.height = bitmap->rows / 3;
- FILE *fp = fopen(fname,"a");
+ fruit.pixels = calloc ( fruit.width * fruit.height,
+ sizeof (PIXEL));
- int i;
- unsigned char value;
- for ( i = 0; i < 256; ++i)
- {
- value = i;
- fwrite (&value,1,1,fp);
- fwrite (&value,1,1,fp);
- fwrite (&value,1,1,fp);
- value = 0;
- fwrite (&value,1,1,fp);
- }
+ for (y = 0; y < fruit.height; y++) {
+ for (x = 0; x < fruit.width; x++) {
+ PIXEL * pixel = Pixel_At (& fruit, x, y);
+ p = ((y*3) * bitmap->pitch ) + x;
- for (int i = 0; i < bitmap->pitch * bitmap->rows; ++i)
- {
- if ( bitmap->buffer[i] != 0x00 ){
- value = 0x00; // remember taking reverse
- fwrite (&value, 1, 1,fp);
- }else{
- value = 0xff;
- fwrite (&value, 1, 1,fp);
- }
- }
+ value = bitmap->buffer[p];
+ pixel->red = 255- value;
+ p += bitmap->pitch;
- fclose(fp);
-}
+ value = bitmap->buffer[p];
+ pixel->green = 255- value;
+ p += bitmap->pitch;
-void Write_Bitmap_Data_GRAY(FT_Bitmap * bitmap, char * fname) {
+ value = bitmap->buffer[p];
+ pixel->blue = 255- value;
- FILE *fp = fopen(fname,"a");
- int i;
+ pixel->alpha = 255;
+ }
+ }
+ break;
- unsigned char value;
- for ( i = 0; i < 256; ++i)
- {
- value = i;
- fwrite (&value,1,1,fp);
- fwrite (&value,1,1,fp);
- fwrite (&value,1,1,fp);
- value = 0;
- fwrite (&value,1,1,fp);
- }
+ default : fruit.width = bitmap->width;
+ fruit.height = bitmap->rows;
+ break;
+ }
- for (int i = 0; i < bitmap->pitch * bitmap->rows; ++i)
- {
- value = 255 - bitmap->buffer[i];
- fwrite(&value,1,1,fp);
- }
+ char * file_name = ( char * )calloc(150,sizeof(char));
+
+ sprintf(file_name, "%s_%d.png", name, i);
+
+ Generate_PNG (& fruit, file_name, render_mode);
- fclose(fp);
+ free (fruit.pixels);
}
\ No newline at end of file
diff --git a/tests/web_interface/bitmap.h b/tests/web_interface/bitmap.h
index e8945de..426d622 100644
--- a/tests/web_interface/bitmap.h
+++ b/tests/web_interface/bitmap.h
@@ -1,86 +1,67 @@
#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <unistd.h>
+
+#include <sys/types.h>
+#include <sys/stat.h>
+
#include <ft2build.h>
-#include <string.h>
+
#include "murmur3.h" // MurmurHash3_x64_128 header file
+#include <png.h>
+
+
#include FT_FREETYPE_H
#include FT_MODULE_H
#include FT_LCD_FILTER_H
#include FT_BITMAP_H
-#define BITS_PER_PIXEL_MONO 1 // Constants for the Bitmap Header
-#define BITS_PER_PIXEL_GRAY 8
-#define BITS_PER_PIXEL_LCD 24
-
-#define PLANES 1 // Constants for the Bitmap Header
-#define COMPRESSION 0
-#define X_PIXELS_PER_METER 0
-#define Y_PIXELS_PER_METER 0
-#define USED_COLORS 0
-#define IMPORTANT_COLORS 0
-//-------------------------------------------------------------------------------
-#pragma pack(push,1)
-
-typedef struct{ // Bitmap FILE Header
-
- FT_UInt16 type;
- FT_UInt32 file_size;
- FT_UInt32 reserved;
- FT_UInt32 file_offset;
-
-} BMP_FILE_HEADER;
-
-typedef struct{ // Bitmap INFO Header
-
- FT_UInt32 info_header_size;
- FT_UInt32 width;
- FT_Int height;
- FT_UInt16 planes;
- FT_UInt16 bits_per_pixel;
- FT_UInt32 compression;
- FT_UInt32 image_size;
- FT_UInt32 y_pixels_per_meter;
- FT_UInt32 x_pixels_per_meter;
- FT_UInt32 used_colors;
- FT_UInt32 important_colors;
+#define BITS_PER_PIXEL_RGBA 32
-} BMP_INFO_HEADER;
-
-typedef struct { // Bitmap Header
-
- BMP_FILE_HEADER file_header;
- BMP_INFO_HEADER info_header;
-
-} HEADER;
-
-//------------------------------------------------------------------------------
typedef struct { // To store 32bit Hash
- FT_UInt32 hash[1];
+ FT_UInt32 hash[1];
}HASH_32;
typedef struct { // To store 128bit Hash
- FT_UInt32 hash[4];
+ FT_UInt32 hash[4];
}HASH_128;
-#pragma pack(pop)
-
-//-------------------------------------------------------------------------------
+typedef struct {
+ unsigned char red;
+ unsigned char green;
+ unsigned char blue;
+ unsigned char alpha;
+} PIXEL;
+
+typedef struct {
+ unsigned char red;
+ unsigned char green;
+ unsigned char blue;
+ unsigned char alpha;
+} PIXEL_BGRA;
+
+/* A picture. */
+
+typedef struct {
+ PIXEL *pixels;
+ size_t width;
+ size_t height;
+} IMAGE;
+
+//------------------------------------------------------------------------------
HASH_32 * Generate_Hash_x86_32(FT_Bitmap * bitmap, HASH_32 * murmur);
HASH_128 * Generate_Hash_x86_128(FT_Bitmap * bitmap, HASH_128 * murmur);
HASH_128 * Generate_Hash_x64_128(FT_Bitmap * bitmap, HASH_128 * murmur);
-//-------------------------------------------------------------------------------
-
-int Get_Padding (FT_Bitmap * bitmap);
-
-int Get_Bits_Per_Pixel ( unsigned char PIXEL_MODE );
+//------------------------------------------------------------------------------
-void Write_Bitmap_Header (FT_Bitmap * bitmap, char * fname);
+PIXEL * Pixel_At (IMAGE * bitmap, int x, int y); // Returns a pointer to pixel
+ // at (x,y) co-ordinate
+// buffer to image
+void Make_PNG(FT_Bitmap* bitmap,char* name,int i,int render_mode);
+// Image to file
+int Generate_PNG (IMAGE *bitmap, const char *path,int render_mode);
-void Write_Bitmap_Data_MONO (FT_Bitmap * bitmap, char * fname);
-void Write_Bitmap_Data_GRAY (FT_Bitmap * bitmap, char * fname);
-void Write_Bitmap_Data_LCD_BGR (FT_Bitmap * bitmap, char * fname);
-void Write_Bitmap_Data_LCD_RGB (FT_Bitmap * bitmap, char * fname);
-void Write_Bitmap_Data_LCD_V_RGB (FT_Bitmap * bitmap, char * fname);
-void Write_Bitmap_Data_LCD_V_BGR (FT_Bitmap * bitmap, char * fname);
diff --git a/tests/web_interface/compare-new-to-old.c
b/tests/web_interface/compare-new-to-old.c
deleted file mode 100644
index 52942a7..0000000
--- a/tests/web_interface/compare-new-to-old.c
+++ /dev/null
@@ -1,103 +0,0 @@
-#include "bitmap.h"
-
-int main(int argc, char const * argv[])
-{
- FT_Library library;
- FT_Face face;
- FT_GlyphSlot slot;
- FT_Bitmap * bitmap;
- FT_UInt32 size;
-
- const char * filename;
-
- int i, j;
-
- char mmhash[40];
- unsigned int lines;
- int line_len = 40;
- char ** hashes;
- char fname[20];
-
- FILE * fp = fopen("old-hashes.txt", "r");
-
- filename = argv[1];
- size = atoi(argv[2]);
-
- if (FT_Init_FreeType(&library))
- {
- printf("Error: library init.\n");
- }
-
- if (FT_New_Face(library, filename, 0, &face))
- {
- printf("Error: loading face.\n");
- }
-
- lines = face->num_glyphs;
- hashes = (char **)malloc(sizeof(char*)*lines);
-
- for (i = 0; i < lines; i++)
- {
- hashes[i] = malloc(line_len);
- if (hashes[i]==NULL)
- {
- fprintf(stderr,"Out of memory (3).\n");
- exit(4);
- }
- if (fgets(hashes[i],line_len-1,fp)==NULL)
- break;
-
- /* Get rid of CR or LF at end of line */
- for (j=strlen(hashes[i])-1;j>=0 && (hashes[i][j]=='\n' ||
hashes[i][j]=='\r');j--)
- ;
- hashes[i][j+1]='\0';
- }
- fclose(fp);
-
- if (FT_Set_Char_Size(face, size * 64, 0, 96, 0))
- {
- printf("Error: setting char size.\n");
- }
-
- slot = face->glyph;
-
- for (i = 0; i < face->num_glyphs; ++i)
- {
- if (FT_Load_Glyph(face, i, FT_LOAD_DEFAULT))
- {
- printf("Error: loading glyph.\n");
- }
-
- if (FT_Render_Glyph(slot, FT_RENDER_MODE_NORMAL))
- {
- printf("Error: rendering glyph.\n");
- }
-
- bitmap = &slot->bitmap;
-
- HASH_128 * murmur = (HASH_128 *)malloc(sizeof(HASH_128));
- murmur = Generate_Hash_x64_128(bitmap,murmur);
-
- sprintf(mmhash, "%08x%08x%08x%08x", murmur->hash[0], murmur->hash[1],
murmur->hash[2], murmur->hash[3]);
-
- printf("%s\n", hashes[i]);
- printf("%s\n", mmhash);
- if (strcmp(mmhash, hashes[i]) == 0)
- {
- if (bitmap->width != 0 && bitmap->rows !=0)
- {
- printf("Glyph %d differs.\n", i);
- sprintf(fname, "%d-new.bmp", i);
- Write_Bitmap_Header(bitmap, fname);
- Write_Bitmap_Data_GRAY(bitmap, fname);
- }
- }
-
- }
-
- FT_Done_Face(face);
- FT_Done_FreeType(library);
-
- return 0;
-
-}
\ No newline at end of file
diff --git a/tests/web_interface/gen.c b/tests/web_interface/gen.c
deleted file mode 100644
index 2f015d6..0000000
--- a/tests/web_interface/gen.c
+++ /dev/null
@@ -1,14 +0,0 @@
-// consolidate code into this file
-
-#include "bitmap.h"
-#include <dlfcn.h>
-
-int main(int argc, char const *argv[])
-{
- if(argc != 5)
- {
- printf("Usage: %s <base ft.so dir> <test ft.so dir> <font dir> <char
size>", argv[0]);
- }
- return 0;
-
-}
diff --git a/tests/web_interface/generate-old-hashes.c
b/tests/web_interface/generate-old-hashes.c
deleted file mode 100644
index 13b6304..0000000
--- a/tests/web_interface/generate-old-hashes.c
+++ /dev/null
@@ -1,64 +0,0 @@
-#include "bitmap.h"
-
-int main(int argc, char const * argv[])
-{
- FT_Library library;
- FT_Face face;
- FT_GlyphSlot slot;
- FT_Bitmap * bitmap;
- FT_UInt32 size;
-
- const char * filename;
-
- int i;
-
- FILE * fp = fopen("old-hashes.txt", "w");
-
- filename = argv[1];
- size = atoi(argv[2]);
-
- if (FT_Init_FreeType(&library))
- {
- printf("Error: library init.\n");
- }
-
- if (FT_New_Face(library, filename, 0, &face))
- {
- printf("Error: loading face.\n");
- }
-
- if (FT_Set_Char_Size(face, size * 64, 0, 96, 0))
- {
- printf("Error: setting char size.\n");
- }
-
- slot = face->glyph;
-
- for (i = 0; i < face->num_glyphs; ++i)
- {
- if (FT_Load_Glyph(face, i, FT_LOAD_DEFAULT))
- {
- printf("Error: loading glyph.\n");
- }
-
- if (FT_Render_Glyph(slot, FT_RENDER_MODE_NORMAL))
- {
- printf("Error: rendering glyph.\n");
- }
-
- bitmap = &slot->bitmap;
-
- HASH_128 * murmur = (HASH_128 *)malloc(sizeof(HASH_128));
- murmur = Generate_Hash_x64_128(bitmap, murmur);
-
- fprintf(fp, "%08x%08x%08x%08x\n", murmur->hash[0], murmur->hash[1],
murmur->hash[2], murmur->hash[3]);
- }
-
- fclose(fp);
-
- FT_Done_Face(face);
- FT_Done_FreeType(library);
-
- return 0;
-
-}
\ No newline at end of file
diff --git a/tests/web_interface/index.html b/tests/web_interface/index.html
deleted file mode 100644
index 388cd52..0000000
--- a/tests/web_interface/index.html
+++ /dev/null
@@ -1,48 +0,0 @@
- <!DOCTYPE html>
-<html>
- <head>
- <meta charset="UTF-8">
- <title>tests/web_interface-test</title>
- <style>
- img {
- display: none;
- }
-
- table {
- margin: 0 auto;
- }
- </style>
- </head>
- <body onload="draw();">
- <table>
- <tr>
- <td><img src="65"></td>
- <td><img src="65-2"></td>
- </tr>
- <tr>
- <td><img src="66"></td>
- <td><img src="66-2"></td>
- </tr>
- </table>
-
- <script>
- function draw() {
- for (var i = 0; i < document.images.length; i++) {
-
- canvas = document.createElement('canvas');
- canvas.setAttribute('width', 300);
- canvas.setAttribute('height', 300);
-
-
document.images[i].parentNode.insertBefore(canvas,document.images[i]);
-
- ctx = canvas.getContext('2d');
-
- ctx.imageSmoothingEnabled = false;
-
- ctx.drawImage(document.images[i], 0, 0, 60, 60);
- }
- }
- </script>
-
- </body>
-</html>
diff --git a/tests/web_interface/main.c b/tests/web_interface/main.c
new file mode 100644
index 0000000..95fbcf1
--- /dev/null
+++ b/tests/web_interface/main.c
@@ -0,0 +1,230 @@
+#include "bitmap.h"
+#include <dlfcn.h>
+#include <math.h>
+
+struct entry
+{
+ int code;
+ char base_img[256];
+ char test_img[256];
+ char base_hash[33];
+ char test_hash[33];
+ double base_value;
+ double test_value;
+ double difference;
+};
+
+void render(const char*, const char*, FT_UInt32, int, struct entry
(*entries)[], int*, int*);
+
+int compare(const void* e1, const void* e2);
+
+void make_html(struct entry (*entries)[], int* num, const char*);
+
+int main(int argc, char const *argv[])
+{
+ const char* base_ft;
+ const char* test_ft;
+ FT_UInt32 size;
+ const char* font;
+ int num = 0;
+ int max = 0;
+ int mode;
+ struct entry entries[2000];
+ for (int i = 0; i < 2000; ++i)
+ {
+ entries[i].difference = 0.0;
+ }
+
+ if(argc != 5)
+ {
+ printf("Usage: %s <base ft.so> <test ft.so> <char size> <font>\n",
argv[0]);
+ return 0;
+ }
+
+ base_ft = argv[1];
+ test_ft = argv[2];
+ size = atoi(argv[3]);
+ font = argv[4];
+
+ mode = 0; // base hashes
+ render(base_ft, font, size, mode, &entries, &num, &max);
+
+ mode = 1; // test hashes
+ render(test_ft, font, size, mode, &entries, &num, &max);
+
+ mode = 2; // base images for differing glyphs
+ render(test_ft, font, size, mode, &entries, &num, &max);
+
+ mode = 3; // test images for differing glyphs
+ render(test_ft, font, size, mode, &entries, &num, &max);
+
+ qsort(entries, 2000, sizeof(struct entry), compare);
+ make_html(&entries, &num, font);
+}
+
+void make_html(struct entry (*entries)[], int* num, const char* font)
+{
+ FILE *fp = fopen("index.html", "w");
+ if (fp == NULL)
+ {
+ printf("Error opening file.\n");
+ exit(1);
+ }
+ fprintf(fp, "<!DOCTYPE html>\n<html>\n<head>\n<style>\nimg{image-rendering:
optimizeSpeed;image-rendering: -moz-crisp-edges;image-rendering:
-o-crisp-edges;image-rendering: -webkit-optimize-contrast;image-rendering:
pixelated;image-rendering: optimize-contrast;-ms-interpolation-mode:
nearest-neighbor;min-width:10%%}\ntable, th, td{\nborder: 1px solid
black;\n}\n</style>\n</head>\n\n<body>\n");
+ fprintf(fp, "<p>%s</p>\n<table style=\"width:100%%\">", font);
+ fprintf(fp, "<tr><th>ID</th><th>Difference</th><th>Base glyph | Test
glyph</th></tr>\n");
+ for (int i = 0; i < *num; ++i)
+ {
+ fprintf(fp, "<tr><td>%d</td><td>%.2f</td><td><img src=\"%s\"</img> <img
src=\"%s\"</img></td></tr>\n", (*entries)[i].code, (*entries)[i].difference,
(*entries)[i].base_img, (*entries)[i].test_img);
+ }
+ fprintf(fp, "</table>\n</body>\n</html>");
+ fclose(fp);
+
+}
+
+int compare (const void* e1, const void* e2)
+{
+ struct entry *s1 = (struct entry *)e1;
+ struct entry *s2 = (struct entry *)e2;
+ int comp = (int)(s1->difference) - (int)(s2->difference);
+ return -comp;
+}
+
+// mode 0: hash base
+// mode 1: hash test
+// mode 2: image base
+// mode 3: image test
+void render(const char* ft_dir, const char* font, FT_UInt32 size, int mode,
struct entry (*entries)[], int* num, int* max)
+{
+ FT_Library library;
+ FT_Face face;
+ FT_GlyphSlot slot;
+ FT_Bitmap *bitmap;
+ FT_Error error;
+ int i;
+
+ FT_Error (*ft_init_fun)(FT_Library*);
+ FT_Error (*ft_newface_fun)(FT_Library, const char*, FT_Long, FT_Face*);
+ FT_Error (*ft_setcharsize_fun)(FT_Face, FT_F26Dot6, FT_F26Dot6, FT_UInt,
+ FT_UInt);
+ FT_Error (*ft_loadglyph_fun)(FT_Face, FT_UInt, FT_Int32);
+ FT_Error (*ft_renderglyph_fun)(FT_GlyphSlot, FT_Render_Mode);
+ FT_Error (*ft_doneface_fun)(FT_Face);
+ FT_Error (*ft_donefreetype_fun)(FT_Library);
+ void (*ft_bitmapinit_fun)(FT_Bitmap*);
+ FT_Error (*ft_bitmapconvert_fun)(FT_Library, const FT_Bitmap*, FT_Bitmap,
+ FT_Int);
+
+ void* handle = dlopen(ft_dir, RTLD_LAZY | RTLD_LOCAL | RTLD_DEEPBIND);
+ if (!handle) {
+ fputs(dlerror(), stderr);
+ exit(1);
+ }
+
+ dlerror();
+
+ *(void**)(&ft_init_fun) = dlsym(handle,"FT_Init_FreeType");
+ *(void**)(&ft_newface_fun) = dlsym(handle,"FT_New_Face");
+ *(void**)(&ft_setcharsize_fun) = dlsym(handle,"FT_Set_Char_Size");
+ *(void**)(&ft_loadglyph_fun) = dlsym(handle,"FT_Load_Glyph");
+ *(void**)(&ft_renderglyph_fun) = dlsym(handle,"FT_Render_Glyph");
+ *(void**)(&ft_doneface_fun) = dlsym(handle,"FT_Done_Face");
+ *(void**)(&ft_donefreetype_fun) = dlsym(handle,"FT_Done_FreeType");
+ *(void**)(&ft_bitmapinit_fun) = dlsym(handle,"FT_Bitmap_Init");
+ *(void**)(&ft_bitmapconvert_fun) = dlsym(handle,"FT_Bitmap_Convert");
+
+ dlerror();
+
+ error = ft_init_fun(&library);
+ if (error)
+ {
+ printf("Error: library init");
+ }
+
+ error = ft_newface_fun(library, font, 0, &face);
+ if (error)
+ {
+ printf("Error: loading face");
+ }
+
+ error = ft_setcharsize_fun(face, size * 64, 0, 96, 0);
+ if (error)
+ {
+ printf("Error: setting char size");
+ }
+
+ slot = face->glyph;
+
+ for (i = 0; i < face->num_glyphs; ++i)
+ {
+ (*entries)[i].code = i;
+ if (((mode == 2) || (mode == 3)) &&
+ (strcmp((*entries)[i].base_hash, (*entries)[i].test_hash) == 0))
+ {
+ continue;
+ }
+
+ error = ft_loadglyph_fun(face, i, FT_LOAD_DEFAULT);
+ if (error)
+ {
+ printf("Error: loading glyph");
+ }
+
+ error = ft_renderglyph_fun(slot, FT_RENDER_MODE_NORMAL);
+ if (error)
+ {
+ printf("Error: rendering glyph");
+ }
+
+ bitmap = &slot->bitmap;
+
+ if ((mode == 0) || (mode == 1))
+ {
+ HASH_128 * murmur = (HASH_128 *)malloc(sizeof(HASH_128));
+ murmur = Generate_Hash_x64_128(bitmap, murmur);
+ if (mode == 0)
+ {
+ sprintf((*entries)[i].base_hash, "%08x%08x%08x%08x", murmur->hash[0],
murmur->hash[1],
+ murmur->hash[2], murmur->hash[3]);
+ }
+ else
+ {
+ sprintf((*entries)[i].test_hash, "%08x%08x%08x%08x", murmur->hash[0],
murmur->hash[1],
+ murmur->hash[2], murmur->hash[3]);
+
+ }
+
+ } else {
+ *max = i;
+ if (bitmap->width == 0 || bitmap->rows == 0)
+ {
+ continue;
+ }
+ if (mode == 2)
+ {
+ *num = *num + 1;
+ Make_PNG(bitmap, "base", i, 1);
+ sprintf((*entries)[i].base_img, "base_%d.png", i);
+ (*entries)[i].base_value = (double)(rand() % 1000);
+ } else if (mode == 3){
+ Make_PNG(bitmap, "test", i, 1);
+ sprintf((*entries)[i].test_img, "test_%d.png", i);
+ (*entries)[i].test_value = (double)(rand() % 1000);
+ (*entries)[i].difference = fabs((*entries)[i].base_value-
(*entries)[i].test_value);
+ }
+ }
+ }
+
+ error = ft_doneface_fun(face);
+ if (error)
+ {
+ printf("Error: freeing face");
+ }
+
+ error = ft_donefreetype_fun(library);
+ if (error)
+ {
+ printf("Error: freeing library");
+ }
+ dlclose(handle);
+}
diff --git a/tests/web_interface/readme.txt b/tests/web_interface/readme.txt
deleted file mode 100644
index ec22f3b..0000000
--- a/tests/web_interface/readme.txt
+++ /dev/null
@@ -1,9 +0,0 @@
-Compile with old:
-gcc generate-old-hashes.c bitmap.c murmur3.c -I <old ft dir>/include -L <old
ft dir>/objs -lfreetype -o generate-old-hashes
-
-Compile with new:
-gcc compare-new-to-old.c bitmap.c murmur3.c -I <new ft dir>/include -L <new ft
dir>/objs -lfreetype -o compare-new-to-old
-
-For consolidated gen.c:
-gcc gen.c bitmap.c murmur3.c -I/usr/local/include/freetype2/ -lfreetype -o gen
-./genc <base ft.so dir> <test ft.so dir> <font dir> <char size>
| [Prev in Thread] |
Current Thread |
[Next in Thread] |
- [freetype2] arv-work 78e74cf: Add HTML generating code,
Arvinder Bhathal <=