static GlyphImage ReadGlyphImages(string filename)
{
PixelFarm.CpuBlit.ActualBitmap bmp = StorageService.Provider.ReadPngBitmap(filename);
GlyphImage img = new GlyphImage(bmp.Width, bmp.Height);
int[] buffer = new int[bmp.Width * bmp.Height];
unsafe
{
PixelFarm.CpuBlit.Imaging.TempMemPtr tmp = PixelFarm.CpuBlit.ActualBitmap.GetBufferPtr(bmp);
System.Runtime.InteropServices.Marshal.Copy(tmp.Ptr, buffer, 0, bmp.Width * bmp.Height);
img.SetImageBuffer(buffer, true);
}
return(img);
}
static GlyphImage ReadGlyphImages(System.IO.Stream stream)
{
using (PixelFarm.CpuBlit.MemBitmap bmp = PixelFarm.CpuBlit.MemBitmap.LoadBitmap(stream))
{
GlyphImage img = new GlyphImage(bmp.Width, bmp.Height);
int[] buffer = new int[bmp.Width * bmp.Height];
unsafe
{
PixelFarm.CpuBlit.Imaging.TempMemPtr tmp = PixelFarm.CpuBlit.MemBitmap.GetBufferPtr(bmp);
System.Runtime.InteropServices.Marshal.Copy(tmp.Ptr, buffer, 0, bmp.Width * bmp.Height);
img.SetImageBuffer(buffer, true);
}
return(img);
}
}
/// <summary>
/// test only, shapen org image with Paint.net sharpen filter
/// </summary>
/// <param name="org"></param>
/// <param name="radius"></param>
/// <returns></returns>
static GlyphImage Sharpen(GlyphImage org, int radius)
{
GlyphImage newImg = new GlyphImage(org.Width, org.Height);
PixelFarm.CpuBlit.Imaging.ShapenFilterPdn sharpen1 = new PixelFarm.CpuBlit.Imaging.ShapenFilterPdn();
int[] orgBuffer = org.GetImageBuffer();
unsafe
{
fixed(int *orgHeader = &orgBuffer[0])
{
int[] output = sharpen1.Sharpen(orgHeader, org.Width, org.Height, org.Width * 4, radius);
newImg.SetImageBuffer(output, org.IsBigEndian);
}
}
return(newImg);
}
public static GlyphImage CreateMsdfImage(Msdfgen.Shape shape)
{
double left, bottom, right, top;
shape.findBounds(out left, out bottom, out right, out top);
int w = (int)Math.Ceiling((right - left));
int h = (int)Math.Ceiling((top - bottom));
if (w < 5)
{
w = 5;
}
if (h < 5)
{
h = 5;
}
int borderW = (int)((float)w / 5f);
var translate = new Msdfgen.Vector2(left < 0 ? -left + borderW : borderW, bottom < 0 ? -bottom + borderW : borderW);
w += borderW * 2; //borders,left- right
h += borderW * 2; //borders, top- bottom
Msdfgen.FloatRGBBmp frgbBmp = new Msdfgen.FloatRGBBmp(w, h);
Msdfgen.EdgeColoring.edgeColoringSimple(shape, 3);
Msdfgen.MsdfGenerator.generateMSDF(frgbBmp,
shape,
4,
new Msdfgen.Vector2(1, 1), //scale
translate, //translate to positive quadrant
-1);
//-----------------------------------
int[] buffer = Msdfgen.MsdfGenerator.ConvertToIntBmp(frgbBmp);
GlyphImage img = new GlyphImage(w, h);
img.TextureOffsetX = translate.x;
img.TextureOffsetY = translate.y;
img.SetImageBuffer(buffer, false);
return(img);
}
public GlyphImage BuildSingleImage()
{
//1. add to list
var glyphList = new List <CacheGlyph>(glyphs.Count);
foreach (CacheGlyph glyphImg in glyphs.Values)
{
//sort data
glyphList.Add(glyphImg);
}
int totalMaxLim = MaxAtlasWidth;
int maxRowHeight = 0;
int currentY = 0;
int currentX = 0;
if (CompactGlyphSpace)
{
//2. sort by glyph width
glyphList.Sort((a, b) =>
{
return(a.img.Width.CompareTo(b.img.Width));
});
//3. layout
for (int i = glyphList.Count - 1; i >= 0; --i)
{
CacheGlyph g = glyphList[i];
if (g.img.Height > maxRowHeight)
{
maxRowHeight = g.img.Height;
}
if (currentX + g.img.Width > totalMaxLim)
{
//start new row
currentY += maxRowHeight;
currentX = 0;
}
//-------------------
g.area = new Rectangle(currentX, currentY, g.img.Width, g.img.Height);
currentX += g.img.Width;
}
}
else
{ //3. layout
int glyphCount = glyphList.Count;
for (int i = 0; i < glyphCount; ++i)
{
CacheGlyph g = glyphList[i];
if (g.img.Height > maxRowHeight)
{
maxRowHeight = g.img.Height;
}
if (currentX + g.img.Width > totalMaxLim)
{
//start new row
currentY += maxRowHeight;
currentX = 0;
}
//-------------------
g.area = new Rectangle(currentX, currentY, g.img.Width, g.img.Height);
currentX += g.img.Width;
}
}
currentY += maxRowHeight;
int imgH = currentY;
// -------------------------------
//compact image location
// TODO: review performance here again***
int totalImgWidth = totalMaxLim;
if (CompactGlyphSpace)
{
totalImgWidth = 0;//reset
BinPacker binPacker = new BinPacker(totalMaxLim, currentY);
for (int i = glyphList.Count - 1; i >= 0; --i)
{
CacheGlyph g = glyphList[i];
BinPackRect newRect = binPacker.Insert(g.img.Width, g.img.Height);
g.area = new Rectangle(newRect.X, newRect.Y,
g.img.Width, g.img.Height);
//recalculate proper max midth again, after arrange and compact space
if (newRect.Right > totalImgWidth)
{
totalImgWidth = newRect.Right;
}
}
}
// -------------------------------
//4. create array that can hold data
int[] totalBuffer = new int[totalImgWidth * imgH];
if (CompactGlyphSpace)
{
for (int i = glyphList.Count - 1; i >= 0; --i)
{
CacheGlyph g = glyphList[i];
//copy data to totalBuffer
GlyphImage img = g.img;
CopyToDest(img.GetImageBuffer(), img.Width, img.Height, totalBuffer, g.area.Left, g.area.Top, totalImgWidth);
}
}
else
{
int glyphCount = glyphList.Count;
for (int i = 0; i < glyphCount; ++i)
{
CacheGlyph g = glyphList[i];
//copy data to totalBuffer
GlyphImage img = g.img;
CopyToDest(img.GetImageBuffer(), img.Width, img.Height, totalBuffer, g.area.Left, g.area.Top, totalImgWidth);
}
}
GlyphImage glyphImage = new GlyphImage(totalImgWidth, imgH);
glyphImage.SetImageBuffer(totalBuffer, true);
latestGenGlyphImage = glyphImage;
return(glyphImage);
}
public static GlyphImage CreateMsdfImage(Msdfgen.Shape shape, MsdfGenParams genParams)
{
double left, bottom, right, top;
shape.findBounds(out left, out bottom, out right, out top);
int w = (int)Math.Ceiling((right - left));
int h = (int)Math.Ceiling((top - bottom));
if (w < genParams.minImgWidth)
{
w = genParams.minImgWidth;
}
if (h < genParams.minImgHeight)
{
h = genParams.minImgHeight;
}
//temp, for debug with glyph 'I', tahoma font
//double edgeThreshold = 1.00000001;//default, if edgeThreshold < 0 then set edgeThreshold=1
//Msdfgen.Vector2 scale = new Msdfgen.Vector2(0.98714652956298199, 0.98714652956298199);
//double pxRange = 4;
//translate = new Msdfgen.Vector2(12.552083333333332, 4.0520833333333330);
//double range = pxRange / Math.Min(scale.x, scale.y);
int borderW = (int)((float)w / 5f);
var translate = new Msdfgen.Vector2(left < 0 ? -left + borderW : borderW, bottom < 0 ? -bottom + borderW : borderW);
w += borderW * 2; //borders,left- right
h += borderW * 2; //borders, top- bottom
double edgeThreshold = genParams.edgeThreshold;
if (edgeThreshold < 0)
{
edgeThreshold = 1.00000001; //use default if edgeThreshold <0
}
var scale = new Msdfgen.Vector2(genParams.scaleX, genParams.scaleY); //scale
double range = genParams.pxRange / Math.Min(scale.x, scale.y);
//---------
Msdfgen.FloatRGBBmp frgbBmp = new Msdfgen.FloatRGBBmp(w, h);
Msdfgen.EdgeColoring.edgeColoringSimple(shape, genParams.angleThreshold);
Msdfgen.MsdfGenerator.generateMSDF(frgbBmp,
shape,
range,
scale,
translate,//translate to positive quadrant
edgeThreshold);
//-----------------------------------
int[] buffer = Msdfgen.MsdfGenerator.ConvertToIntBmp(frgbBmp);
GlyphImage img = new GlyphImage(w, h);
img.TextureOffsetX = (short)translate.x;
img.TextureOffsetY = (short)translate.y;
img.SetImageBuffer(buffer, false);
return(img);
}
public GlyphImage BuildSingleImage()
{
//1. add to list
var glyphList = new List <CacheGlyph>(glyphs.Count);
foreach (CacheGlyph glyphImg in glyphs.Values)
{
//sort data
glyphList.Add(glyphImg);
}
//2. sort
glyphList.Sort((a, b) =>
{
return(a.img.Width.CompareTo(b.img.Width));
});
//3. layout
int totalMaxLim = 800;
int maxRowHeight = 0;
int currentY = 0;
int currentX = 0;
for (int i = glyphList.Count - 1; i >= 0; --i)
{
CacheGlyph g = glyphList[i];
if (g.img.Height > maxRowHeight)
{
maxRowHeight = g.img.Height;
}
if (currentX + g.img.Width > totalMaxLim)
{
//start new row
currentY += maxRowHeight;
currentX = 0;
}
//-------------------
g.area = new Rectangle(currentX, currentY, g.img.Width, g.img.Height);
currentX += g.img.Width;
}
currentY += maxRowHeight;
int imgH = currentY;
//-------------------------------
//compact image location
//TODO: review performance here again***
BinPacker binPacker = new BinPacker(totalMaxLim, currentY);
for (int i = glyphList.Count - 1; i >= 0; --i)
{
CacheGlyph g = glyphList[i];
BinPackRect newRect = binPacker.Insert(g.img.Width, g.img.Height);
g.area = new Rectangle(newRect.X, newRect.Y,
g.img.Width, g.img.Height);
}
//-------------------------------
//4. create array that can hold data
int[] totalBuffer = new int[totalMaxLim * imgH];
for (int i = glyphList.Count - 1; i >= 0; --i)
{
CacheGlyph g = glyphList[i];
//copy data to totalBuffer
GlyphImage img = g.img;
CopyToDest(img.GetImageBuffer(), img.Width, img.Height, totalBuffer, g.area.Left, g.area.Top, totalMaxLim);
}
//------------------
GlyphImage glyphImage = new GlyphImage(totalMaxLim, imgH);
glyphImage.SetImageBuffer(totalBuffer, true);
latestGenGlyphImage = glyphImage;
return(glyphImage);
}
public GlyphImage BuildSingleImage()
{
//1. add to list
var glyphList = new List <CacheGlyph>(_glyphs.Count);
foreach (CacheGlyph glyphImg in _glyphs.Values)
{
//sort data
glyphList.Add(glyphImg);
}
int totalMaxLim = MaxAtlasWidth;
int maxRowHeight = 0;
int currentY = 0;
int currentX = 0;
switch (this.SpaceCompactOption)
{
default:
throw new System.NotSupportedException();
case CompactOption.BinPack:
{
//2. sort by glyph width
glyphList.Sort((a, b) =>
{
return(a.img.Width.CompareTo(b.img.Width));
});
//3. layout
for (int i = glyphList.Count - 1; i >= 0; --i)
{
CacheGlyph g = glyphList[i];
if (g.img.Height > maxRowHeight)
{
maxRowHeight = g.img.Height;
}
if (currentX + g.img.Width > totalMaxLim)
{
//start new row
currentY += maxRowHeight;
currentX = 0;
}
//-------------------
g.area = new Rectangle(currentX, currentY, g.img.Width, g.img.Height);
currentX += g.img.Width;
}
}
break;
case CompactOption.ArrangeByHeight:
{
//2. sort by height
glyphList.Sort((a, b) =>
{
return(a.img.Height.CompareTo(b.img.Height));
});
//3. layout
int glyphCount = glyphList.Count;
for (int i = 0; i < glyphCount; ++i)
{
CacheGlyph g = glyphList[i];
if (g.img.Height > maxRowHeight)
{
maxRowHeight = g.img.Height;
}
if (currentX + g.img.Width > totalMaxLim)
{
//start new row
currentY += maxRowHeight;
currentX = 0;
maxRowHeight = g.img.Height; //reset, after start new row
}
//-------------------
g.area = new Rectangle(currentX, currentY, g.img.Width, g.img.Height);
currentX += g.img.Width;
}
}
break;
case CompactOption.None:
{
//3. layout
int glyphCount = glyphList.Count;
for (int i = 0; i < glyphCount; ++i)
{
CacheGlyph g = glyphList[i];
if (g.img.Height > maxRowHeight)
{
maxRowHeight = g.img.Height;
}
if (currentX + g.img.Width > totalMaxLim)
{
//start new row
currentY += maxRowHeight;
currentX = 0;
maxRowHeight = g.img.Height; //reset, after start new row
}
//-------------------
g.area = new Rectangle(currentX, currentY, g.img.Width, g.img.Height);
currentX += g.img.Width;
}
}
break;
}
currentY += maxRowHeight;
int imgH = currentY;
// -------------------------------
//compact image location
// TODO: review performance here again***
int totalImgWidth = totalMaxLim;
if (SpaceCompactOption == CompactOption.BinPack) //again here?
{
totalImgWidth = 0; //reset
//use bin packer
BinPacker binPacker = new BinPacker(totalMaxLim, currentY);
for (int i = glyphList.Count - 1; i >= 0; --i)
{
CacheGlyph g = glyphList[i];
BinPackRect newRect = binPacker.Insert(g.img.Width, g.img.Height);
g.area = new Rectangle(newRect.X, newRect.Y,
g.img.Width, g.img.Height);
//recalculate proper max midth again, after arrange and compact space
if (newRect.Right > totalImgWidth)
{
totalImgWidth = newRect.Right;
}
}
}
// -------------------------------
//4. create array that can hold data
int[] totalBuffer = new int[totalImgWidth * imgH];
if (SpaceCompactOption == CompactOption.BinPack) //again here?
{
for (int i = glyphList.Count - 1; i >= 0; --i)
{
CacheGlyph g = glyphList[i];
//copy data to totalBuffer
GlyphImage img = g.img;
CopyToDest(img.GetImageBuffer(), img.Width, img.Height, totalBuffer, g.area.Left, g.area.Top, totalImgWidth);
}
}
else
{
int glyphCount = glyphList.Count;
for (int i = 0; i < glyphCount; ++i)
{
CacheGlyph g = glyphList[i];
//copy data to totalBuffer
GlyphImage img = g.img;
CopyToDest(img.GetImageBuffer(), img.Width, img.Height, totalBuffer, g.area.Left, g.area.Top, totalImgWidth);
}
}
//new total glyph img
GlyphImage glyphImage = new GlyphImage(totalImgWidth, imgH);
//flip vertical Y
{
int[] totalBufferFlipY = new int[totalBuffer.Length];
int srcRowIndex = imgH - 1;
int strideInBytes = totalImgWidth * 4;
for (int i = 0; i < imgH; ++i)
{
//copy each row from src to dst
System.Buffer.BlockCopy(totalBuffer, strideInBytes * srcRowIndex, totalBufferFlipY, strideInBytes * i, strideInBytes);
srcRowIndex--;
}
totalBuffer = totalBufferFlipY;
}
glyphImage.SetImageBuffer(totalBuffer, true);
_latestGenGlyphImage = glyphImage;
return(glyphImage);
}
public GlyphImage CreateGlyphImage(GlyphPathBuilder builder, float pxscale)
{
//1. create
var txToVxs = new GlyphTranslatorToVxs();
builder.ReadShapes(txToVxs);
//
//create new one
var glyphVxs = new VertexStore();
txToVxs.WriteOutput(glyphVxs, pxscale);
//find bound
//--------------------------------------------
//GlyphImage glyphImg = new GlyphImage()
RectD bounds = new RectD();
BoundingRect.GetBoundingRect(new VertexStoreSnap(glyphVxs), ref bounds);
////--------------------------------------------
int w = (int)System.Math.Ceiling(bounds.Width);
int h = (int)System.Math.Ceiling(bounds.Height);
if (w < 5)
{
w = 5;
}
if (h < 5)
{
h = 5;
}
////translate to positive quadrant
double dx = (bounds.Left < 0) ? -bounds.Left : 0;
double dy = (bounds.Bottom < 0) ? -bounds.Bottom : 0;
//we need some borders
int horizontal_margin = 1; //'margin' 1px
int vertical_margin = 1; //margin 1 px
dx += horizontal_margin; //+ left margin
dy += vertical_margin; //+ top margin
//--------------------------------------------
//create glyph img
w = (int)Math.Ceiling(dx + w + horizontal_margin); //+right margin
h = (int)Math.Ceiling(dy + h + vertical_margin); //+bottom margin
ActualImage img = new ActualImage(w, h, PixelFormat.ARGB32);
AggRenderSurface aggsx = new AggRenderSurface(img);
AggPainter painter = new AggPainter(aggsx);
if (TextureKind == TextureKind.StencilLcdEffect)
{
VertexStore vxs2 = new VertexStore();
glyphVxs.TranslateToNewVxs(dx + 0.33f, dy, vxs2); //offset to proper x of subpixel rendering ***
glyphVxs = vxs2;
//
painter.UseSubPixelLcdEffect = true;
//we use white glyph on black bg for this texture
painter.Clear(Color.Black);
painter.FillColor = Color.White;
painter.Fill(glyphVxs);
//apply sharpen filter
//painter.DoFilter(new RectInt(0, h, w, 0), 2);
//painter.DoFilter(new RectInt(0, h, w, 0), 2); //?
}
else
{
VertexStore vxs2 = new VertexStore();
glyphVxs.TranslateToNewVxs(dx, dy, vxs2);
glyphVxs = vxs2;
painter.UseSubPixelLcdEffect = false;
if (TextureKind == TextureKind.StencilGreyScale)
{
painter.Clear(Color.Empty);
painter.FillColor = Color.Black;
}
else
{
painter.Clear(BackGroundColor);
painter.FillColor = this.GlyphColor;
}
painter.Fill(glyphVxs);
}
//
var glyphImage = new GlyphImage(w, h);
glyphImage.TextureOffsetX = dx;
glyphImage.TextureOffsetY = dy;
glyphImage.SetImageBuffer(ActualImageExtensions.CopyImgBuffer(img, w), false);
//copy data from agg canvas to glyph image
return(glyphImage);
}