The Dot Factory: An LCD Font and Image Generator
- At July 23, 2009
- By Eran Duchan
- In Microcontrollers, Software tools
60
The Dot Factory is a small, GPL, open source tool intended to generate the required C language information to store many fonts and images, as efficiently as possible, on a microcontroller. These fonts are then uploaded via the LCD driver (see the Drivers and Modules page for a few) to the actual dot matrix LCD. It is written in C# for Visual Studio 2008 and has been tested on Windows XP, 2003, Vista and 7.
While there are software graphic libraries that allow us to generate a character “on the fly” using vector graphics (the character is described as a series of drawing commands that allow scaling and decoration) – these are much too complex and large to integrate in a microcontroller environment. Consequently, we must store the exact appearance of a character as a series of 1s and 0s, equivalent to a “dot on” “dot off” on the LCD, and upload this as a bitmap when we want to display text. While it is possible to generate this manually, it is desired to have a tool to do our grunt work by converting windows fonts (given a size and decoration) into a series of bitmaps.
Using The Dot Factory
Once you have completed setting up what it is you’d like to generate (be it an image or font), select the output method in the output pane. If you are using the LCD drivers on this website, you want it to generate an MSb first output, otherwise images will come out wrong. If you have a compiler that supports the “0b” binary specifier, you can select “binary” rather than “hex”. This will allow you to visually see the pixels you will set and allow for manual touch up by the user without having to calculate hex and experimentation. Click generate and your C code will be outputted to the text box below. Copy paste this into your application (it is recommended to put this in a separate module, not your LCD driver module, for organizational reasons).
Note that 5×7 and 5×8 fonts cannot be generated using this tool. While some TTF fonts can render characters this small they are usually distorted to the point of uselessness. You can download a ready made five by seven font here. I ripped this font from text file a while ago, so apologies to the uncredited author.
What does it generate?
For font generation, three entities are generated.
- The character bitmap array: This holds the actual characters as a bitmap (only the characters selected in the input pane). Each byte represents a single vertical page sent to the LCD. All vertical padding is removed from the characters
- The character descriptor array: Allows O(1) mapping between a character’s ASCII value and required meta information about the character – namely its width in bits and its offset into the character bitmap array. When the LCD driver needs to find where character X is located in the bitmap array, it will jump to index [X - font.startCharacter] in the descriptor array. The startCharacter is the first character (that is, the character with the lowest ASCII value) used for this font. By defining a startCharacter we can reduce the number of elements in the descriptor array.
- The font information: This element is essentially the font descriptor for this font. It holds information regarding this font like the name of the character bitmap and descriptor arrays, the font start character and how many pixels wide a space character is for this font. The LCD driver will replace the space character with empty pixels (this saves both processing time, space in the character bitmap array and space in the character descriptor array – since the space is the first ASCII character and is commonly used).
The generated structures are generated with documentation, but you may want to see a sample bitmapDb header file for detailed info on the character descriptor array and font information structures.
For image generation, only the image’s bitmap array and size descriptors are generated. Note that the height value is pixels (bits) and width values are in pages.
Revision history
I usually release versions according to user demand. If you think TDF can use whatever feature, drop me a line. When enough users request something I invest the time to add it.
- Version 0.1.2 (29may11): Fixed width/height being swapped. Added support for configuring image descriptor format (bits/bytes). Thanks geo for the heads up and suggestion
- Version 0.1.1 (25may11): Added support for multiple descriptor arrays with a double lookup. Before this version TheDotFactory could generate Unicode characters but the lookup tables were usually too huge to be of any use. Using this feature, a double lookup is employed, allowing for fast lookups for characters residing at disparate ranges. See the video for an explanation (will be posted in the next few days). In addition to this, added support for specifying character ranges instead of inputing the actual characters. For example, <<100-120>> will generate characters for ASCII characters 100 to 120. Thanks a bunch to Archis Bhave for inputs and testing. Source is now distributed via github.
- Version 0.1.0 (15dec10): Added support to format the generated variable names (thanks SpiralBrain), added end character indication to font information (thanks Nick Jensen), added the ability to save to clipboard from File menu and added the ability to save the source/header to file via file menu (don’t remember who, but someone wondered why this wasn’t in. I personally think all fonts should be in a single module and so I opted for copy/paste, but to each his own)
- Version 0.0.9 (06jun10): Fixed a bug that prevents the space character from being generated (broken in 0.0.8 – thanks Thomas Kibalo)
- Version 0.0.8 (29may10): Fixed two unreported crashes (clicking generate without entering any text and when a newline existed in generated text), added the ability to copy the outputted text by using a context menu
- Version 0.0.7 (28may10): Added ability to select whether character descriptor array is to be created and which character will be used to visualize the font (thanks Christian Treczoks), syntax coloring automatically disabled when generating large amounts of text (will be fixed properly next version), properly handled bitmaps with no black pixels in them (displays error instead of a crash), some minor cosmetics
- Version 0.0.6 (03mar10): Bug fix for image generation (tried to save a temporary file for debugging in a custom directory) – thanks to Nir Shemeshfor pointhing this out!
- Version 0.0.5 (23dec09): Added support for rotation (90 degree increments), space character generation, width (bit/byte) selection of character width and font height, optional generation of character height/width and font height, structures are now generated with documention, input text and font is persisted throughout invokations of the application, persistent preset management – add, edit, delete output configuration presets
- Version 0.0.4 (31jul09): Added a space to end of comments in the char descriptor array to prevent preprocessor misinterpreting ‘\’ as a newline
- Version 0.0.3 (30jul09): Added output configuration: hex/binary, MSb First/LSb first, configurable padding removal, comment control, flip X/Y and more
- Version 0.0.2 (28jul09): Vista support
- Version 0.0.1 (25jul09): Initial release (flip not supported, output format not supported, not tested on Vista)
Future features
I’m trying to get TDF to a point where it will be flexible enough to generate most of the formats people need (this will, of course, take time). Since I am not familiar with all possible formats, I will need your help. If you’d like to suggest an output format, drop me a line and I will try to make sense of it.
- Select between generating pages from rows or columns (to allow more efficient 0/180 degree encoding) – as suggested by Darcy
Download
To run this executable, you must have the .NET framework installed. The stable binary has been in the wild for a month at least with no major bugs reported. Non stable binary contains new features and bug fixes (see revision history). Please mail me with any bugs and feature requests (admin@ this domain).
- Latest binary (0.1.2): Windows 7/Vista/XP/2003, requires .NET framework 3.5
- Previous binary (0.1.0): Windows 7/Vista/XP/2003, requires .NET framework 3.5
- Previous source (0.1.0): C#, Visual Studio 2008 project [express supported]
Up to date source can be found at the gitub repository.
Robert
I was wondering if you might add a feature to rotate the fonts in the future? For my application I need the font data to be output so that the commented representation would be right side up so to speak. I might be able to do it on the MCU but I suspect it would take quite a few cycles to do and would slow down output conciderable (and my code is already slow as is *sigh*)
Eran Duchan
Version 0.0.3 and up supports flipping the characters both on the X axis and Y axis (clicking the little wrench thingie opens up a configuration dialogue) – that should allow you to rotate the character in 90 degree increments. Finer resolution (15, 24, 59 degrees etc) is possible to implement, but would probably open a pandora’s box.
Robert
Unfortunately those options doesn’t allow me to rotate the character as I need. Unless I’m completely blind I can’t manage to do this: http://files.badlysprained.net/out/504/privat/LCD/needed_dotfactory_output.png Fortunately my limited experience allowed me to alter the code myself to make it rotate 270 degrees and get the result above. Now I need to figure out how to make the “Tightest” option work without making the output look garbled (say you have a [.] and an [M] that you want to output it will then put linebreaks that matches the width of the [.] thus making the [M] look garbled up). Also, I need to see if I can make it output how many bytes are needed per row of pixels of each character. I’m finding it hard going to follow the flow of the code though, it’s all over the place hehe.
Hanno
Yes, great prog – thanks! Two things, would also like a rotate feature, have 2x large multiplexed LED displays that are addressed by row rather than column… Option to include the space character 0×20 in the array… I have ample room on this micro and don’t like having to make exceptions for the space char. Will the C# source compile on the Express version? (Visual C# 2008 Express Edition). Thanks again!
Christian Treczoks
I tried TheDotFactory, and basically it is great, BUT: When I feed characters >127 to it, e.g. ISO8859-15 special characters (¡¢£€¥Š§š©ª«¬®¯°±²³Žµ¶·ž¹º»ŒœŸÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑ
ÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñ
òóôõö÷øùúûüýþÿ), the factory dies… Any chance for a quick fix? I’d do it myself, but this windows stuff is not my home turf…
Eran Duchan
Christian, it seems that TDF does not die on this sequence – it chokes. The problem is that TDF generates a direct lookup array for each character according to its ASCII value (offsetted by the first character in the sequence). When you generate 16bit Unicode characters, this array can grow to be insanely large – almost 9000 lines in your case (because you have a Unicode character whose value is almost 9000). To be even more precise, TDF generates this just fine – its just that the syntax coloring mechanism i use is very simplistic and slow. If i override it, the 10,000 line text outputs just fine. To summarize: 1) If you want a quick fix to generate unicode, simply comment out line outputSyntaxColoredString(resultStringSource, ref txtOutputTextSource); and replace it with txtOutputTextSource.Text = resultStringSource; This outputs the text with no coloring 2) Since obviously unicode will use a proprietary associative [character value] to [offset into character array] container, i will need to think how to format this to have people shove this into their proprietary associative container. I will do this in the following week or so. If anyone has any input on this matter, feel free to comment or mail.
Darcy
I just wanted to say thanks for such a fantastic program! I’ve been mucking around with LCDs for many years and have done numerous searches for software such as this. Brilliant It doesn’t quite output in the structure I use so maybe I could just use different methods. The format I use has LSB first (topmost), and then lists columns from left to right. As a lot of LCDs work in rows and columns it makes for faster output if you can write to the LCD from a sequential area (since each write moves the address across one column/pixel) For example, the ‘!’ character is stored as two pixels wide 0xFF,0xFF, (top left, top right) 0x0D,0x0D, (btm left, btm right) That format is a left over from when I didn’t have enough RAM for screen buffers though… which I now use. Maybe it’s time to change my structs :) On the downside, it would mean having to convert my 5×3 font set over. It only has numerals and capital letters but it’s quite handy for some things. Anyway, great program and thanks for making it available to everyone
jmg
If you are looking for formats to support, I’d suggest BDF, as fontforge and others can read/write that, and it is also easy to script-massage to custom ASM formats.
[eg we are going to store Fonts as array-strips, for faster readout. Not as readable, but the same size tables, and smaller/faster runtime code ]
http://en.wikipedia.org/wiki/Glyph_Bitmap_Distribution_Format
Eran Duchan
Seems like an interesting and easy to output format, but I am wondering who would use it and in which scenario? I’m guessing that most, if not all, use cases of TDF are to generate information so that text can be written on dot matrix LCDs with no second step or processing on the outputted data – just directly work on the outputted arrays in the LCD driver.
If TDF were to generate BDF, how would this contribute to said scenario? I would be happy to understand this further.
I also fixed the split links – thanks a bunch for the input and heads up!
jmg
The link to source above, is strangely split.
Some places it is
http://www.pavius.net/bin/TheDotFactory-src-0.0.5.7z
but under ‘stable’ it says
http://www.pavius.net/bin/TheDotFactory-0.0.5.7z
Jochem
Crashes on certain JPG files, error is in dutch, sorry.. Basically it says the rectangle cannot have a width or height of 0. (And I guess the height can’t be negative as well..)
System.ArgumentExcepti on: Rechthoek {X=0,Y=720,Width=0,Height=-720} kan geen breedte of hoogte van 0 hebben.
bij System.Drawing.Bitmap.Clone(Rectangle rect, PixelFormat format)
bij TheDotFactory.MainForm.manipulateBitma p(Bitmap bitmapOriginal, BitmapBorder tightestCommonB order, Bitmap& bitmapManipulat ed, Int32 minWidth, Int32 minHeight)
bij TheDotFactory.MainForm.generateOutputF orImage(Bitmap& bitmapOriginal, String& resultTextSourc e, String& resultTextHeade r)
[...] etcetera (comment too long for this box)
Jochem
Among others, this jpeg generates the error:
http://www.broodjesexpress.nl/shop_2006/media/blikje-chocomel.jpg
Eran Duchan
Thanks for the report – I’ll look at it once i return home in a few days [Update: fixed in 0.0.7]
canosso
Hello,
is it possible to switch of the Character descriptors?
If you want to convert single Chinese chars, the whole unicode table of chines chars will be loaded and the programm hangs up.
Eran Duchan
This is a known issue with 0.0.6 and will be addressed in 0.0.7. The problem is with the syntax coloring (the lookup table is huge and takes time to color code the outputted text).
If you’d like, you can replace the call to outputSyntaxCol oredString to simply set the text directly to the text box; this overrides this issue
canosso
Sorry, the FONT_CHAR_INFO is a problem. If I only input e.g. ?????? in the text field, the whole table of Cyrillic chars will be generated in FONT_CHAR_INFO. If is possible to generate only a table of the chars, it would be nice.
It is great piece of software you made. Thank you.
Eran Duchan
The “hanging” problem is the syntax coloring but there still remains an issue with what to generate in the FONT_CHAR_INFO lookup array.
I still need to look at what exactly can be generated to allow effective lookup for Unicode characters. Since they are not sequential in their value, an array is not acceptable.
SpiralBrain
Brilliant piece of software. Thanks Eran!
wonder if there is a way to add custom c syntax.
http://sunbizhosting.co.uk/~spiral/
Steennami
I enjoyed reading your blog. Keep it that way.
Nick Jensen
It would be useful if the FONTINFO block could indicate the number of bits that the font had hanging below the text line. As it is there is no info indicating how to lay down the font so the hanging bits are properly positioned. Also it would be good to have an option to include the HIGHEST character in the font also indicated in the FONTINFO block. Then it would be possible to tell if a character was within the range of the index.
Thanks! A job well done and a very important tool!
Nick
Eran Duchan
Will just have to find some time to implement them. Thanks!
[edit]: Would be happy if you could clarify your comment regarding the hanging bits. What exactly do you mean by this and what is the problem lining up the characters?
In my applications there were no issues with vertical alignment (everything lined up naturally, including characters like ‘g’ and ‘y’) – you can see this in the “Nokia example” image on this page.
Nick Jensen
In my application I write the font bits in columns to a monochrome LCD. So I choose the font bits to be rotated 90 degrees. Consecutive byte in the BitMap are a vertical slice through the font. When I generate fonts that have hanging tails (like the “g” and “y” characters”) the font is shifted to the right because the lowest bits are in the high bit of the first byte slice. There isn’t any obvious indication of just how many bits of the font are below the typical font bottom.
Dave
What does ‘Character Height’ in FONT_INFO have to do with anything? I can’t figure any relation between it and the number of bytes used by a character (height, width, or total number of bytes).
I guess what I’m wondering is, how do we know how many bytes to write before we run into the next character? I can pull the index number from the next char in the array, but that doesn’t work for the last char.
Dave
For anyone else with the same issue, in the settings (little gear icon next to the Generate button), change the Font Height Descriptor to be in Bits, not bytes. That will give the actual height of the characters. Then it’s (bit width rounded up to the nearest byte) * (Font Height) = total bytes per character.
Eran Duchan
Hey Dave,
The character height is in pages of 8 bits. I modeled this on the very popular SED1565 controller which maps a byte of data to a _vertical_ 8 bit pixel line (called a page). When you write a character to the LCD you want to know how many vertical pages you need to shove (character height in pages) and for how many horizontal repetitions (character width, in pixels).
Dave
Interesting. I’m writing the data to a 24bit LCD, so it’s a bit different than originally intended by the program ;)
Thanks for a very handy program :)
Aurélien
I used this software in my own project which consists into create a GUI on an ARM7TDMI. It has been very helpful and easy to implement. I thank you very much for this program.
Aurel
PS: sry for my poor english ! ;) i try to improve it every day
mehdi
hi
i want to add the persian character to this project.
please help me.
thanks
Eran Duchan
Persian support is just a subset of supporting unicode characters. The problem with Persian or whatever is in generating the lookup array, not in generating the glyphs. Unicode characters are 16 bit, so you will need tens of thousands of entries into the lookup array, most of them just wasted. There are 2 options here:
1) Don’t generate the lookup array (Deselect “Generate descriptor lookup array in the configuration) and somehow manage lookups yourself. For example, generate the lookup array but manually shove this into an associative array of your choice (keyed by the unicode character value)
2) I have a design for Unicode (see above) which supplies fast lookup and uses very little memory. I simply don’t have the time to implement this right now but you can go ahead and do it :)
Dennis
Hi Eran,
I had to write to say THANK YOU! Your DotFactory application is so COOL. I’m doing an FPGA design and needed to display LEFT and RIGHT in a 3D test pattern. Your app made it real easy to generate the bit map table. It even allowed me to change the HEX prefix from 0x to 8′h to embed in my verilog code.
Best regards,
Dennis
Oregon, USA
Archis Bhave
Hi Eran
That’s an amazing software you have released. I used to use Fontgen till a few of years ago, but they went exorbitantly commercial.
I am currently working on a project involving a GLCD and wish to display Chinese (Simplified) characters on it. I am using UnicodeView to copy and paste glyphs to TDF and generate the lookups.
However, the CJK Unified character block has 20,000+ character glyphs. I am interested in knowing if it is possible to copy paste all glyphs in a given font by directly entering a Unicode code range (or by specifying a character block to copy) to TDF?
Thank you in advance.
Eran Duchan
Hi Archis
Thanks :) I worked with FontGen about 7 years ago when I released an LCD simulator (it was free)… One of the reasons I wrote TDF was that it is too simple of a tool not to be distributed freely.
I’m trying to wrap my head around what you want to do. Do you want to specify Unicode ranges instead of pasting the characters to the input pane? How would you manage lookups to these characters (as I have yet to implement my dual-lookup Unicode solution)?
Archis Bhave
Hi Eran
I am currently using UnicodeView. A small, free application that allows me select a font, a character block inside the font, and displays glyphs within the fonts as well as indicates the unicode code associated with a glyph in the current context. So I can find out the current unicode values for a given range of glyphs and then paste the range directly. This would probably require TDF to take into consideration the code page (or the current character block) associated with the font?
TDF already allows me to select the font and it’s size.I am also able to set the codepage. Is it possible to directly insert all Unicode indices from within the selected codepage?
Sincerely
Eran Duchan
I understand what you’re trying to do but TDF has no concept of Unicode, unfortunately. The reason for this is that I have no concept of Unicode :) I’m sure what you want to do is simple once you understand .NET Unicode facilities; I just don’t have the time to dive into this right now.
Archis Bhave
Hi Eran
Thanks for the reply. I guess I’ll just have to manage with TDF and adapt the output for Unicode. Because I have no concept of .NET and Visual Programming on Windows.
I mostly work on Linux (not a zealot, though).
Loved your version control tutorial as well. Cool
geo
Hi Eran,
Your software really helped my team big time! This tool really superb! More power to you :)
Btw, i just notice something on the generated descriptor array? According to the comment it is arranged as:
width, height offest. But on the data inside the array is it arranged as height, width, offest hmm did i miss something?
Eran Duchan
Thanks! I am looking at TDF 0.1.1 and 0.1.0 outputs but I don’t see that the height/width are swapped. For example, I start by generating output without displaying height and I see that the width value is first and the offset second. I then enable outputting height and see that it is added as the second member of the descriptor array both in the values and in the comments. Do you see something different?
geo
Hmmm ok i paste some generated part
// @30 ‘B’ (13 pixels wide)
0xF8, 0×01, // ##### #
0xF8, 0×03, // ##### ##
0xF8, 0×07, // ##### ###
0×38, 0×07, // ### ###
0×38, 0×07, // ### ###
0×38, 0×07, // ### ###
0xF8, 0×03, // ##### ##
0xF8, 0×03, // ##### ##
0xF8, 0×07, // ##### ###
0×38, 0x0F, // ### ####
0×38, 0x0E, // ### ###
0×38, 0x0E, // ### ###
0xF8, 0x0F, // ##### ####
0xF8, 0×07, // ##### ###
0xF8, 0×03, // ##### ##
};
// Character descriptors for Century Gothic 16pt
// { [Char width in bits], [Char height in bits], [Offset into centuryGothic16ptCharBitmaps in bytes] }
const FONT_CHAR_INFO centuryGothic16ptDescriptors[] =
{
{15, 13, 0}, // A
{15, 13, 30}, // B
};
geo
please correct me but as what i see, inside bitmap array it shows 13 pixels wide, but inside descriptor 13 is on the 2nd element? which should be the height right? hmm
Eran Duchan
You’re right. There’s definitely some confusion between the comment on the character and the comment above the descriptor array. I’ll fix this in the next release. Thanks!
geo
ah ok thanks too! looking forward for the next release.
btw i’m also using the image conversion? and it seems the width info is in no. of pages right? hmm is ok to add in pixels too on the next release? i know its should be in pages coz LCDs are in bytes, but currently our system here needs the width in pixels, but due to this wonderful tool we will make your generated code as our official font code. but still would be nice to be able to get the image width in pixels too for backward compatible :)
Eran Duchan
Odd that this feature didn’t exist in the first place. Will add it and drop you a line once its released. Thanks again for the input!
AndyC
Great tool, has saved me a load of time and effort!
I have one small feature request: when converting images which aren’t a multiple of 8 bits in size, please could we have the option to change their justification when they’re padded out to a whole number of bytes?
My LCD controller defines the screen in pages (ie. horizontal rows, where each byte written is a vertical strip of 8 pixels). So to convert each image, I rotate it 90 degrees, and TDF automatically left justifies the result – so, for example, a 9 pixel row comes out as {0xFF, 0×80}. My driver requires it to be right justified (ie. {0×01, 0xFF}), which I can force by ensuring the original .bmp is a multiple of 8 bits high, but it would be nice to have the option.
Thanks :)
Eran Duchan
Hi Andy.
I’ll definitely add this feature for the next release (whenever that may be, seeing how busy these days are).
Thanks for the input!
Eran
AndyC
Cool – ta :)
Eddy
Just wanted to say thanks for the awesome app, i’ve been using it since late 2009, and it works great!
Thanks again!
Eran Duchan
:)
Archis Bhave
Hey Eran
I did that unicode project. TDF worked great. Will email you some publishable photos, if the client allows me to take them!
The reason I’m here is, I just tested TDF on a
FEDORA 15, 64 bit system using Mono. And it ran with only one small crash. The crash is NOT a showstopper and anyway that ain’t your head-ache. I only tested it to generate standard ascii characters as of now.
I will be filing the crash with Mono people.
And of course, you rock!
Eran Duchan
Really great to hear that it works well. Would really be cool to see the pics :)
Tony
Fantastic application. I have a question regarding the “padding removal” option. It appears if I select “tightest” for the width all padding is removed.
I’m using a GLCD display and it would be nice to select the padding size in bits.
Eran Duchan
Hey Tony. As you can probably tell, that’s not supported. However, seeing how we are talking about a constant padding width, it’s something that can easily be done in your LCD driver (just plot the next character at an offset of your choosing).
Tony
Hi Eran,
Thanks for your reply. Modifying the driver is one option however it’s cleaner if it’s encapsulated in the font data.
I made a small modification to your application to accomplish this.
Am I allowed to use the font data generated by this tool in my project? If so, what credits/comments do I add?
Thanks!
Eran Duchan
TDF itself (that is, the application that generates the output) is released under the GPL. The outputted data is entirely your property and you can do whatever you want with it with absolutely no limitations. Credits and links are appreciated, but not mandatory :)
Tony
Thanks for the clarification Eran!
Archis Bhave
Was testing the image (bitmap) generation using TDF. Observed the following behavior:
1) Opened a simple gif image (black and white) from the desktop.
2) Generated the bitmap.
3) Then selected a different image from the desktop.
When I attempted to delete the first selected image, at this point of time (OCD for clean desktop), Windows declared that the image was in use by TDF, even though I had selected a different image.
Is the image file lock not released (Or the file handle not closed, whatever windows needs) upon selection of a different image? This is not problematic per se, but why keep loose ends dangling?
Eran Duchan
I’ll take a look at it once I get some time. Thanks for the report!
AndyB
Hello, good program, thanks :) A few comments that are comming into my mind after the experience – it should be helpful, if there would be a note in the above description, that the character descriptors map to Unicode char codes, and that a particular ASCII set can be converted to Unicode using tables like those on http://orwell.ru/test/ . The article talks about O(1) ASCII->char descriptor list mapping, which I think can confuse a bit. Next, the 0.1.2 seems to have a bug there – the generated FONT_INFO was wrong for the fonts I tried, the character height should be 13 (or 17) but it was 2 (or 3), more like a character spacing info. And I had to add character spacing value and also width of space char to the font info manually, in order to use the font in application. Yet an idea i got while playing with Monotype Corsiva – some characters seem to have a stepping differrent from their width (sry not sure if ‘stepping’ is the correct term), for example the curly ‘k’ can be some 13px wide, but the character following it should be rendered yet in the ‘k’ space and not those 13px (+ space) away, i.e. maybe the character descriptors could hold such information too, if that’s possible, that would be cool :) that’s just an idea. cheers
Blog J.Schweiss | LCD Charset Creation
[...] Charset Creation Januar 22, 2012 21:17 by Administrator Font + Image Generator Tags: Categories: Actions: E-mail | Kick it! | Permalink | Kommentare (0) | Comment RSS [...]
Eduardo Theves Lourenço
This program is amazing!! I’ve been looking for something like this for a week and now i found it. It’s much more than I could ever expect. Congratulations!!
Eran Duchan
Thanks, Eduardo :) I’m curious to know how you tried to look for an application that serves this purpose. I’ll try to tweak my google visibility accordingly.