public BitmapInfo(OutputConfiguration outConfig, Bitmap bmp, Color borderColor)
{
OutConfig = outConfig;
Original = bmp;
OriginalBorder = Border.GetBorders(Original, borderColor);
ColorList = MyExtensions.GetColorList(Original).Aggregate(new Dictionary <Color, bool>(), (dic, c) => { dic.Add(c, c.ToArgb() == borderColor.ToArgb()); return(dic); });
}
// get the descriptors
private static string getFontInfoDescriptorsString(bool blockLookupGenerated, OutputConfiguration outConfig, Font font)
{
string descriptorString = "";
// if a lookup arrays are required, point to it
if (outConfig.generateLookupBlocks)
{
// add to string
descriptorString += String.Format("\t{0}, {1} Character block lookup{2}" + outConfig.nl,
blockLookupGenerated ? getCharacterDescriptorArrayLookupDisplayString(font) : "NULL",
outConfig.CommentStart, outConfig.CommentEnd);
// add to string
descriptorString += String.Format("\t{0}, {1} Character descriptor array{2}" + outConfig.nl,
blockLookupGenerated ? "NULL" : MyExtensions.GetVariableNameFromExpression(String.Format(outConfig.varNfCharInfo, getFontName(font, true))),
outConfig.CommentStart, outConfig.CommentEnd);
}
else
{
// add descriptor array
descriptorString += String.Format("\t{0}, {1} Character descriptor array{2}" + outConfig.nl,
MyExtensions.GetVariableNameFromExpression(String.Format(outConfig.varNfCharInfo, getFontName(font, true))),
outConfig.CommentStart, outConfig.CommentEnd);
}
// return the string
return(descriptorString);
}
public BitmapInfo(OutputConfiguration outConfig, Bitmap bmp, Dictionary <Color, bool> colorList)
{
OutConfig = outConfig;
Original = bmp;
OriginalBorder = Border.GetBorders(Original, MyExtensions.GetEnabledKeys <Color>(colorList));
ColorList = colorList;
}
public string GetBlockInfo()
{
Size s = bitmapInfo?.Size ?? new Size();
// get the character descriptor string
Func <OutputConfiguration.DescriptorFormat, int, string> GetCharacterDescString = ((descFormat, valueInBits) =>
{
switch (descFormat)
{
// don't display
case OutputConfiguration.DescriptorFormat.DontDisplay:
return("");
case OutputConfiguration.DescriptorFormat.DisplayInBits:
case OutputConfiguration.DescriptorFormat.DisplayInBytes:
// add comma and return
return(MyExtensions.ConvertValueByDescriptorFormat(descFormat, valueInBits) + ", ");
default:
throw new NotImplementedException();
}
});
return(string.Format("\t{{{0}{1}{2}}},", GetCharacterDescString(OutConfig.descCharWidth, s.Width),
GetCharacterDescString(OutConfig.descCharHeight, s.Height),
OffsetInBytes)
.PadRight(15) +
string.Format("{0}{1}{2}" + OutConfig.nl,
OutConfig.CommentStart,
Character == '\\' ? "\\ (backslash)" : Character.ToString(),
OutConfig.CommentEnd));
}
private void btnBitmapLoad_Click(object sender, EventArgs e)
{
// set filter
dlgOpenFile.Filter = string.Format("Image Files ({0})|{0}", "*.jpg; *.jpeg; *.gif; *.bmp; *.png");
// open the dialog
if (dlgOpenFile.ShowDialog() != DialogResult.Cancel)
{
if (m_currentLoadedBitmap != null)
{
m_currentLoadedBitmap.Dispose();
}
m_currentLoadedBitmap = MyExtensions.ChangePixelFormat(new Bitmap(dlgOpenFile.FileName), PixelFormat.Format32bppArgb);
// set the path
txtImagePath.Text = dlgOpenFile.FileName;
// guess a name
txtImageName.Text = Path.GetFileNameWithoutExtension(dlgOpenFile.FileName);
//
colorList = MyExtensions.GetColorList(m_currentLoadedBitmap).ToDictionary <Color, Color, bool>(x => x, x => false);
colorList[colorList.ElementAt(0).Key] = true;
if (colorList.Count > 16)
{
MessageBox.Show("Convert the image into black/white in a proper image processing program, to get better results.");
}
dataGridViewBackgroundColor.RowCount = colorList.Count;
dataGridViewBackgroundColor.Refresh();
// Set picterbox background
pbxBitmap.BackColor = GetBackColorForPicturbox();
Size sz = DetectTileSize();
updateBitmapAllowed = false;
numericUpDownInputImageTilesPerLine.Value = 16;
numericUpDownInputImageTileSizeX.Value = sz.Width;
numericUpDownInputImageTileSizeY.Value = sz.Height;
updateBitmapAllowed = true;
UpdateInputImageFont(sender, e);
}
}
// get the font name and format it
public static string getFontName(Font font, bool variabelName = false)
{
string space = (variabelName) ? "_" : " ";
string s;
s = string.Format("{0}{2}{1}pt", font.Name, Math.Round(font.Size), space);
if (font.Style != FontStyle.Regular)
{
s += space + font.Style.ToString();
if (variabelName)
{
s = s.Replace(", ", "_");
}
}
return((variabelName) ? MyExtensions.ScrubVariableName(s) : s);
}
private void updateBitmapPreview()
{
if (checkGroupBoxFontImage.Checked && m_currentLoadedBitmap != null)
{
int w = (int)numericUpDownInputImageTileSizeX.Value;
int h = (int)numericUpDownInputImageTileSizeY.Value;
int tilesPerLine = (int)numericUpDownInputImageTilesPerLine.Value;
Point p = new Point(hScrollBarInputImageCharacterPos.Value % tilesPerLine * w, hScrollBarInputImageCharacterPos.Value / tilesPerLine * h);
Rectangle r = new Rectangle(p, new Size(w, h));
Color c;
if (colorList.ContainsValue(true))
{
c = MyExtensions.GetEnabledKeys(colorList)[0];
}
else
{
c = Color.Transparent;
}
Bitmap character = MyExtensions.Clone(m_currentLoadedBitmap, r, PixelFormat.Format32bppArgb, c);;
Size newSize = r.Size;
int faktor = 1;
while (newSize.Height <= 32)
{
newSize.Height *= 2;
newSize.Width *= 2;
faktor *= 2;
}
//convert to black white image
character = MyExtensions.ToBitmap(MyExtensions.ToArgbArray(character).Select(argb =>
{
return(colorList[Color.FromArgb(argb)] ? Color.Black.ToArgb() : Color.White.ToArgb());
}).ToArray(), r.Size);
pictureBoxInputImageFontCharacterPreview.Image = MyExtensions.ResizeImage(character, faktor);
pictureBoxInputImageFontCharacterPreview.Size = newSize;
}
}
// get character descriptor array block name
private string charDescArrayGetBlockName(int currentBlockIndex,
bool includeTypeDefinition,
bool includeBlockIndex)
{
// get block id
string blockIdString = String.Format("Block{0}", currentBlockIndex);
// variable name
string variableName = String.Format(OutConfig.varNfCharInfo, getFontName(Font, true));
// remove type unless required
if (!includeTypeDefinition)
{
variableName = MyExtensions.GetVariableNameFromExpression(variableName);
}
// return the block name
return(String.Format("{0}{1}{2}",
variableName,
includeBlockIndex ? blockIdString : "",
includeTypeDefinition ? "[]" : ""));
}
private void generateOutputForFontImage(OutputConfiguration outConfig,
Dictionary <Color, bool> colorList,
Size tileSize,
int codepage,
Bitmap bitmapOriginal,
StringBuilder textSource,
StringBuilder textHeader)
{
// the name of the bitmap
string imageName;
Color[] backgroundColors;
BitmapInfo bi;
textSource.Clear();
textHeader.Clear();
if (bitmapOriginal == null || txtImageName.Text == "")
{
textSource.Append("No image found ");
return;
}
imageName = MyExtensions.ScrubVariableName(txtImageName.Text);
backgroundColors = MyExtensions.GetEnabledKeys <Color>(colorList);
// check if bitmap is assigned
if (m_currentLoadedBitmap != null)
{
//
// Bitmap manipulation
//
bi = new BitmapInfo(m_outputConfig, m_currentLoadedBitmap, colorList);
// try to manipulate the bitmap
if (!bi.GenerateManipulatetBitmap(bi.OriginalBorder))
{
// show error
MessageBox.Show("No blackground pixels found in bitmap",
"Can't convert bitmap",
MessageBoxButtons.OK,
MessageBoxIcon.Error);
// stop here, failed to manipulate the bitmap for whatever reason
return;
}
// according to config
if (m_outputConfig.addCommentVariableName)
{
// add source file header
textSource.AppendFormat("{0}" + m_outputConfig.nl + "{1} Image data for {2}" + m_outputConfig.nl + "{3}" + m_outputConfig.nl + m_outputConfig.nl,
m_outputConfig.CommentStart,
m_outputConfig.CommentBlockMiddle,
imageName,
m_outputConfig.CommentBlockEnd);
// add header file header
textHeader.AppendFormat("{0}Bitmap info for {1}{2}" + m_outputConfig.nl,
m_outputConfig.CommentStart,
imageName,
m_outputConfig.CommentEnd);
}
// bitmap varname
string bitmapVarName = String.Format(m_outputConfig.varNfImageBitmap, imageName) + "[]";
// add to source
textSource.AppendFormat("{0} =" + m_outputConfig.nl + "{{" + m_outputConfig.nl, bitmapVarName);
//
// Bitmap to string
//
// page array
bi.GeneratePageArray();
// assign pages for fully populated 8 bits
int pagesPerRow = MyExtensions.ConvertValueByDescriptorFormat(OutputConfiguration.DescriptorFormat.DisplayInBytes, bi.BitmapToGenerate.Width);
// now convert to string
bi.GenerateCharacterDataDescriptorAndVisulazer();
textSource.Append(bi.Descriptor);
// close
textSource.AppendFormat("}};" + m_outputConfig.nl + m_outputConfig.nl);
// according to config
if (m_outputConfig.addCommentVariableName)
{
// set sizes comment
textSource.AppendFormat("{0}Bitmap sizes for {1}{2}" + m_outputConfig.nl,
m_outputConfig.CommentStart, imageName, m_outputConfig.CommentEnd);
}
Func <string> getImageWidthString = () =>
{
const string format = "\t{2}, {0} {3}{1}{4}";
// display width in bytes?
switch (m_outputConfig.descImgWidth)
{
case OutputConfiguration.DescriptorFormat.DisplayInBytes:
return(string.Format(format,
m_outputConfig.CommentStart,
m_outputConfig.CommentEnd,
pagesPerRow,
"Image width in bytes (pages)",
m_outputConfig.nl));
case OutputConfiguration.DescriptorFormat.DisplayInBits:
return(string.Format(format,
m_outputConfig.CommentStart,
m_outputConfig.CommentEnd,
bi.BitmapToGenerate.Width,
"Image width in pixels",
m_outputConfig.nl));
case OutputConfiguration.DescriptorFormat.DontDisplay:
return("");
default:
throw new NotImplementedException();
}
};
Func <string> getImageHeigtString = () =>
{
const string format = "\t{2}, {0} {3}{1}{4}";
switch (m_outputConfig.descImgHeight)
{
case OutputConfiguration.DescriptorFormat.DisplayInBytes:
return(string.Format(format,
m_outputConfig.CommentStart,
m_outputConfig.CommentEnd,
MyExtensions.ConvertValueByDescriptorFormat(OutputConfiguration.DescriptorFormat.DisplayInBytes, bi.BitmapToGenerate.Height),
"Image height in bytes (pages)",
m_outputConfig.nl));
case OutputConfiguration.DescriptorFormat.DisplayInBits:
return(string.Format(format,
m_outputConfig.CommentStart,
m_outputConfig.CommentEnd,
bi.BitmapToGenerate.Height,
"Image height in pixels",
m_outputConfig.nl));
case OutputConfiguration.DescriptorFormat.DontDisplay:
return("");
default:
throw new NotImplementedException();
}
};
// get var name
string imageInfoVarName = String.Format(m_outputConfig.varNfImageInfo, imageName);
// image info header
textHeader.AppendFormat("extern {0};" + m_outputConfig.nl, imageInfoVarName);
// image info source
textSource.AppendFormat("{2} =" + m_outputConfig.nl + "{{" + m_outputConfig.nl +
"{3}" +
"{4}" +
"\t{5}, {0} Image bitmap array{1}" + m_outputConfig.nl +
"}};" + m_outputConfig.nl,
m_outputConfig.CommentStart,
m_outputConfig.CommentEnd,
imageInfoVarName,
getImageWidthString(),
getImageHeigtString(),
MyExtensions.GetVariableNameFromExpression(bitmapVarName));
}
}
// generate the strings
private void GenerateStringsFromFontInfo()
{
StringBuilder sourceText = new StringBuilder();
StringBuilder headerText = new StringBuilder();
if (OutConfig.addCommentVariableName)
{
// add source file header
sourceText.AppendFormat("{0}" + OutConfig.nl + "{1} Font data for {2}" + OutConfig.nl + "{3}" + OutConfig.nl + OutConfig.nl,
OutConfig.CommentStart,
OutConfig.CommentBlockMiddle,
getFontName(Font, false),
OutConfig.CommentBlockEnd);
// add source header
sourceText.AppendFormat("{0}Character bitmaps for {1} {2}" + OutConfig.nl,
OutConfig.CommentStart,
getFontName(Font, false),
OutConfig.CommentEnd);
// add header file header
headerText.AppendFormat("{0}Font data for {1} {2}" + OutConfig.nl,
OutConfig.CommentStart,
getFontName(Font, false),
OutConfig.CommentEnd);
}
// get bitmap name
string charBitmapVarName = String.Format(OutConfig.varNfBitmaps, getFontName(Font, true)) + "[]";
// source var
sourceText.AppendFormat("{0} = " + OutConfig.nl + "{{" + OutConfig.nl, charBitmapVarName);
Characters.ToList().ForEach(chi => chi.GenerateCharacterDataDescriptorAndVisulazer());
Characters.Aggregate(sourceText, (sb, chi) =>
{
// skip empty bitmaps
if (chi.BitmapToGenerate == null)
{
return(sb);
}
// now add letter array
sourceText.Append(chi.Descriptor);
// space out
if (OutConfig.addCommentCharDescriptor && chi.Character != chi.ParentFontInfo.LastChar)
{
// space between chars
sb.Append(OutConfig.nl);
}
return(sb);
});
// space out
sourceText.Append("};" + OutConfig.nl + OutConfig.nl);
//
// Charater descriptor
//
// whether or not block lookup was generated
bool blockLookupGenerated = false;
// check if required by configuration
if (OutConfig.generateLookupArray)
{
// generate the lookup array
blockLookupGenerated = generateStringsFromCharacterDescriptorBlockList(sourceText, headerText);
}
//
// Font descriptor
//
// according to config
if (OutConfig.addCommentVariableName)
{
// result string
sourceText.AppendFormat("{0}Font information for {1} {2}" + OutConfig.nl,
OutConfig.CommentStart,
getFontName(Font, false),
OutConfig.CommentEnd);
}
// character name
string fontInfoVarName = String.Format(OutConfig.varNfFontInfo, getFontName(Font, true));
// add character array for header
headerText.AppendFormat("extern {0};" + OutConfig.nl, fontInfoVarName);
// the font character height
string fontCharHeightString = "";
// get character height sstring - displayed according to output configuration
if (OutConfig.descFontHeight != OutputConfiguration.DescriptorFormat.DontDisplay)
{
// convert the value
fontCharHeightString = String.Format("\t{0}, {1} Character height{2}" + OutConfig.nl,
MyExtensions.ConvertValueByDescriptorFormat(OutConfig.descFontHeight, FixedAbsolutCharHeight),
OutConfig.CommentStart,
OutConfig.CommentEnd);
}
string fontCodePage = "";
if (OutConfig.addCodePage)
{
fontCodePage = string.Format("\t{0}, {1} CodePage {3}{2}" + OutConfig.nl,
OutConfig.CodePage,
OutConfig.CommentStart,
OutConfig.CommentEnd,
CodePageInfo.GetCodepageName(OutConfig.CodePage));
}
string spaceCharacterPixelWidthString = "";
// get space char width, if it is up to driver to generate
if (!OutConfig.generateSpaceCharacterBitmap)
{
// convert the value
spaceCharacterPixelWidthString = String.Format("\t{0}, {1} Width, in pixels, of space character{2}" + OutConfig.nl,
OutConfig.spaceGenerationPixels,
OutConfig.CommentStart,
OutConfig.CommentEnd);
}
// font info
sourceText.AppendFormat("{2} =" + OutConfig.nl + "{{" + OutConfig.nl +
"{3}" +
"\t{4}, {0} First character '{9}'{1}" + OutConfig.nl +
"\t{5}, {0} Last character '{10}'{1}" + OutConfig.nl +
"{6}" +
"{7}" +
"\t{8}, {0} Character bitmap array{1}" + OutConfig.nl +
"{11}" +
"}};" + OutConfig.nl,
OutConfig.CommentStart,
OutConfig.CommentEnd,
fontInfoVarName,
fontCharHeightString,
getCharacterDisplayString(CodePageInfo, FirstChar),
getCharacterDisplayString(CodePageInfo, LastChar),
spaceCharacterPixelWidthString,
getFontInfoDescriptorsString(blockLookupGenerated, OutConfig, Font),
MyExtensions.GetVariableNameFromExpression(String.Format(OutConfig.varNfBitmaps, getFontName(Font, true))),
FirstChar,
LastChar,
fontCodePage);
// add the appropriate entity to the header
if (blockLookupGenerated)
{
// add block lookup to header
headerText.AppendFormat("extern const FONT_CHAR_INFO_LOOKUP {0}[];" + OutConfig.nl, getCharacterDescriptorArrayLookupDisplayString(Font));
}
else
{
// add block lookup to header
headerText.AppendFormat("extern {0}[];" + OutConfig.nl, String.Format(OutConfig.varNfCharInfo, getFontName(Font, true)));
}
TextSource = sourceText.ToString();
TextHeader = headerText.ToString();
}
public static Border GetBorders(Bitmap bmp, Color[] borderColorList)
{
int[] pixel = MyExtensions.ToArgbArray(bmp);
Border b = new Border();
int width = bmp.Width, height = bmp.Height;
int[] borderColorListInt = borderColorList.Select <Color, int>(p => p.ToArgb()).ToArray();
Func <int, int, int> getPixel = delegate(int x, int y)
{
return(pixel[y * width + x]);
};
// returns whether a bitmap column is empty (empty means all is border color)
Func <int, bool> columnIsEmpty = delegate(int column)
{
// for each row in the column
for (int row = 0; row < height; ++row)
{
// is the pixel black?
if (!borderColorListInt.Contains(getPixel(column, row)))
{
// found. column is not empty
return(false);
}
}
// column is empty
return(true);
};
// returns whether a bitmap row is empty (empty means all is border color)
Func <int, bool> rowIsEmpty = delegate(int row)
{
// for each column in the row
for (int column = 0; column < width; ++column)
{
// is the pixel black?
if (!borderColorListInt.Contains(getPixel(column, row)))
{
// found. row is not empty
return(false);
}
}
// row is empty
return(true);
};
for (b.Left = 0; b.Left < width; ++b.Left)
{
if (!columnIsEmpty(b.Left))
{
break;
}
}
for (b.Right = width - 1; b.Right >= 0; --b.Right)
{
if (!columnIsEmpty(b.Right))
{
break;
}
}
for (b.Top = 0; b.Top < height; ++b.Top)
{
if (!rowIsEmpty(b.Top))
{
break;
}
}
for (b.Bottom = height - 1; b.Bottom >= 0; --b.Bottom)
{
if (!rowIsEmpty(b.Bottom))
{
break;
}
}
return(b);
}
// create the page array
public void GeneratePageArray()
{
int[] pixels = MyExtensions.ToArgbArray(BitmapToGenerate);
int width = BitmapToGenerate.Width, height = BitmapToGenerate.Height;
int black = Color.Black.ToArgb(), white = Color.White.ToArgb();
Dictionary <int, List <byte> > dpages = new Dictionary <int, List <byte> >();
Dictionary <int, bool> backColorListInt = ColorList.ToDictionary <KeyValuePair <Color, bool>, int, bool>(kvp => kvp.Key.ToArgb(), kvp => kvp.Value);
bool ColumnMajor = OutConfig.bitLayout == OutputConfiguration.BitLayout.ColumnMajor;
// create pages
Pages = new byte[0];
Func <int, int, int> getPixel = delegate(int x, int y)
{
return(pixels[y * width + x]);
};
Action <int> ConvertRow = row =>
{
dpages.Add(row, new List <byte>());
// current byte value
byte currentValue = 0, bitsRead = 0;
// for each column
for (int column = 0; column < width; ++column)
{
// is pixel set?
if (!backColorListInt[getPixel(column, row)])
{
// set the appropriate bit in the page
if (OutConfig.byteOrderMsbFirst)
{
currentValue |= (byte)(1 << (7 - bitsRead));
}
else
{
currentValue |= (byte)(1 << bitsRead);
}
}
// increment number of bits read
// have we filled a page?
if (++bitsRead == 8)
{
// add byte to page array
dpages[row].Add(currentValue);
// zero out current value
currentValue = 0;
// zero out bits read
bitsRead = 0;
}
}
// if we have bits left, add it as is
if (bitsRead != 0)
{
dpages[row].Add(currentValue);
}
};
// for each row
for (int row = 0; row < height; row++)
{
ConvertRow(row);
}
List <byte> tempPages = new List <byte>();
for (int i = 0; i < dpages.Count; i++)
{
tempPages.AddRange(dpages[i]);
}
Pages = tempPages.ToArray();
// transpose the pages if column major data is requested
if (ColumnMajor)
{
Pages = Transpose(Pages, BitmapToGenerate.Width, BitmapToGenerate.Height, OutConfig.byteOrderMsbFirst);
}
}
