public static ObservableCollection <Layer> ToLayers(this SerializableDocument serializableDocument)
{
ObservableCollection <Layer> layers = new ObservableCollection <Layer>();
for (int i = 0; i < serializableDocument.Layers.Count; i++)
{
SerializableLayer serLayer = serializableDocument.Layers[i];
Layer layer =
new Layer(serLayer.Name, BitmapUtils.BytesToWriteableBitmap(serLayer.Width, serLayer.Height, serLayer.BitmapBytes))
{
IsVisible = serLayer.IsVisible,
Offset = new Thickness(serLayer.OffsetX, serLayer.OffsetY, 0, 0),
Opacity = serLayer.Opacity,
MaxHeight = serializableDocument.Height,
MaxWidth = serializableDocument.Width,
};
if (serLayer.LayerGuid != Guid.Empty)
{
layer.ChangeGuid(serLayer.LayerGuid);
}
layers.Add(layer);
}
return(layers);
}
public static void ClearGroupLayerIndexes(this SerializableDocument document)
{
foreach (SerializableGroup group in document.Groups)
{
group.SerializedStartLayer = group.SerializedEndLayer = -1;
}
}
public static SerializableDocument Deserialize(Stream stream, LoadOptions loadOptions = null)
{
var doc = new SerializableDocument {
Options = loadOptions
};
stream.ReadBFast(doc.ReadBuffer).Count();
return(doc);
}
public void TestThatWriteToBinaryFileCreatesFile()
{
SerializableDocument doc = new SerializableDocument(new Document(10, 10));
BinarySerialization.WriteToBinaryFile(Path, doc);
Assert.True(File.Exists(Path));
File.Delete(Path);
}
public void CanCreateSKImageFromLayer()
{
SerializableDocument document = PixiParser.Deserialize("./Files/16x16,PPD-3.pixi");
SerializableLayer layer = document.Layers[0];
using SKImage image = layer.ToSKImage();
Assert.Equal(layer.Width, image.Width);
}
public static WpfObservableRangeCollection <Layer> ToLayers(this SerializableDocument document)
{
WpfObservableRangeCollection <Layer> layers = new();
foreach (SerializableLayer slayer in document)
{
layers.Add(slayer.ToLayer(document.Width, document.Height));
}
return(layers);
}
public ZoneTree DoZoning()
{
this.ApplyDomModifications();
var msdocument = _documentFactory.Create(_msDoc, _url);
string html, text;
var sDocument = SerializableDocument.Create(msdocument, out html, out text);
_elementClassifier.Execute(sDocument);
var zoneTree = _zoneTreeBuilder.Build(sDocument);
return(zoneTree);
}
public static SerializableEntityTable FindEntityTable(this SerializableDocument doc, string name)
{
// Not very efficient ... but there are not very many entity tables
foreach (var et in doc.EntityTables)
{
if (et.Name == name)
{
return(et);
}
}
return(null);
}
public Document(SerializableDocument document)
{
_Document = document;
Header = _Document.Header;
Nodes = _Document.Nodes.ToIArray();
Geometry = _Document.Geometry;
StringTable = _Document.StringTable.ToIArray();
EntityTables = _Document.EntityTables.ToLookup(
et => DocumentExtensions.GetTableKeyFromTableName(et.Name),
et => et.ToEntityTable(this));
Assets = _Document.Assets.ToLookup(et => et.Name, et => et);
}
public byte[] SerializeAndCreate()
{
SerializableDocument document = Helper.CreateDocument(Size, Layers, false);
for (int i = 0; i < Layers; i++)
{
SKData encoded = bitmaps[i].Encode(SKEncodedImageFormat.Png, 100);
document.Layers[i].PngBytes = encoded.AsSpan().ToArray();
}
return(PixiParser.Serialize(benchmarkDocument));
}
public static void Serialize(this SerializableDocument doc, Stream stream)
{
var bldr = new BFastBuilder();
var headerBuffer = doc.Header.ToString().ToBytesUtf8();
bldr.Add(BufferNames.Header, headerBuffer.ToBuffer());
bldr.Add(BufferNames.Assets, doc.Assets);
bldr.Add(BufferNames.Entities, doc.EntityTables.ToBFastBuilder());
bldr.Add(BufferNames.Strings, doc.StringTable.PackStrings().ToBuffer());
bldr.Add(BufferNames.Geometry, doc.Geometry.ToG3DWriter());
bldr.Add(BufferNames.Nodes, doc.Nodes.ToBuffer());
bldr.Write(stream);
}
public void TestThatToDocumentConvertsCorrectly()
{
Document document = GenerateSampleDocument();
SerializableDocument doc = new SerializableDocument(document);
Document convertedDocument = doc.ToDocument();
Assert.Equal(document.Height, convertedDocument.Height);
Assert.Equal(document.Width, convertedDocument.Width);
Assert.Equal(document.Swatches, convertedDocument.Swatches);
Assert.Equal(document.Layers.Select(x => x.LayerBitmap.ToByteArray()),
convertedDocument.Layers.Select(x => x.LayerBitmap.ToByteArray()));
}
public static SerializableDocument ToSerializable(this Document document)
{
SerializableDocument serializable = new SerializableDocument
{
Width = document.Width,
Height = document.Height,
Layers = document.Layers.Select(x => x.ToSerializable()).ToList(),
Groups = document.LayerStructure.Groups.Select(x => x.ToSerializable()).ToArray(),
Swatches = document.Swatches.Select(x => SDColor.FromArgb(x.A, x.R, x.G, x.B)).ToList()
};
return(serializable);
}
public static void IncreaseGroupLayerIndexes(this SerializableDocument document, int start)
{
foreach (SerializableGroup group in document.Groups)
{
if (group.SerializedStartLayer >= start)
{
group.SerializedStartLayer++;
}
if (group.SerializedEndLayer >= start)
{
group.SerializedStartLayer++;
}
}
}
public static void DecreaseGroupLayerIndexes(this SerializableDocument document, int start)
{
foreach (SerializableGroup group in document.Groups)
{
if (group.SerializedStartLayer > start)
{
group.SerializedStartLayer = Max(group.SerializedStartLayer - 1, -1);
}
if (group.SerializedEndLayer > start)
{
group.SerializedEndLayer = Max(group.SerializedEndLayer - 1, -1);
}
}
}
/// <summary>
/// Serializes a <see cref="SerializableDocument"/> into bytes and saves them into a stream.
/// </summary>
/// <param name="document">The document to serialize.</param>
/// <returns>The total number of bytes written to the stream.</returns>
public static int Serialize(SerializableDocument document, Stream stream)
{
document.FileVersion = FileVersion;
byte[] messagePack = MessagePackSerializer.Serialize(document, MessagePack.Resolvers.StandardResolverAllowPrivate.Options);
#if NET5_0_OR_GREATER
stream.Write(BitConverter.GetBytes(messagePack.Length));
stream.Write(messagePack);
#else
stream.Write(BitConverter.GetBytes(messagePack.Length), 0, 4);
stream.Write(messagePack, 0, messagePack.Length);
#endif
return(messagePack.Length + 4);
}
private static unsafe SerializableDocument GetSerializable(DataObject data, out CropData cropData)
{
MemoryStream pixiStream = data.GetData("PIXI") as MemoryStream;
SerializableDocument document = PixiParser.Deserialize(pixiStream);
if (data.GetDataPresent(typeof(CropData)))
{
cropData = CropData.FromStream(data.GetData(typeof(CropData)) as MemoryStream);
}
else
{
cropData = new CropData(document.Width, document.Height, 0, 0);
}
return(document);
}
public void SerializeAndDeserializeEmptyLayer()
{
SerializableDocument document = new()
{
Width = 1,
Height = 1
};
document.Layers.Add("Base Layer");
var serialized = PixiParser.Serialize(document);
SerializableDocument deserialized = PixiParser.Deserialize(serialized);
AssertEqual(document, deserialized);
}
public static Document ToDocument(this SerializableDocument serializableDocument)
{
Document document = new Document(serializableDocument.Width, serializableDocument.Height)
{
Layers = serializableDocument.ToLayers(),
Swatches = new ObservableCollection <SKColor>(serializableDocument.Swatches.ToSKColors())
};
document.LayerStructure.Groups = serializableDocument.ToGroups(document);
if (document.Layers.Count > 0)
{
document.SetMainActiveLayer(0);
}
document.Renderer.ForceRerender();
return(document);
}
public static Document ToDocument(this SerializableDocument serializableDocument)
{
Document document = new Document(serializableDocument.Width, serializableDocument.Height)
{
Layers = serializableDocument.ToLayers(),
Swatches = new ObservableCollection <Color>(serializableDocument.Swatches.Select(x =>
Color.FromArgb(x.A, x.R, x.G, x.B)))
};
document.LayerStructure.Groups = serializableDocument.ToGroups();
if (document.Layers.Count > 0)
{
document.SetMainActiveLayer(0);
}
return(document);
}
/// <summary>
/// Serializes a <see cref="SerializableDocument"/> into bytes.
/// </summary>
/// <param name="document">The document to serialize.</param>
/// <returns>The serialized bytes.</returns>
public static byte[] Serialize(SerializableDocument document)
{
MemoryStream stream = new();
Serialize(document, stream);
stream.Seek(0, SeekOrigin.Begin);
byte[] buffer = new byte[stream.Length];
#if NET5_0_OR_GREATER
stream.Read(buffer);
#else
stream.Read(buffer, 0, buffer.Length);
#endif
return(buffer);
}
public void TestThatReadFromBinaryFileReadsCorrectly()
{
Document document = new Document(10, 10);
document.Layers.Add(new Layer("yeet"));
document.Swatches.Add(Colors.Green);
SerializableDocument doc = new SerializableDocument(document);
BinarySerialization.WriteToBinaryFile(Path, doc);
SerializableDocument file = BinarySerialization.ReadFromBinaryFile <SerializableDocument>(Path);
Assert.Equal(doc.Layers, file.Layers);
Assert.Equal(doc.Height, file.Height);
Assert.Equal(doc.Width, file.Width);
Assert.Equal(doc.Swatches, file.Swatches);
}
public void TestThatToLayersConvertsCorrectly()
{
Document document = GenerateSampleDocument();
SerializableDocument doc = new SerializableDocument(document);
System.Collections.ObjectModel.ObservableCollection <Layer> layers = doc.ToLayers();
for (int i = 0; i < layers.Count; i++)
{
Assert.Equal(document.Layers[i].LayerBitmap.ToByteArray(), layers[i].ConvertBitmapToBytes());
Assert.Equal(document.Layers[i].Height, layers[i].Height);
Assert.Equal(document.Layers[i].Width, layers[i].Width);
Assert.Equal(document.Layers[i].MaxHeight, layers[i].MaxHeight);
Assert.Equal(document.Layers[i].MaxWidth, layers[i].MaxWidth);
Assert.Equal(document.Layers[i].Offset, layers[i].Offset);
Assert.Equal(document.Layers[i].Opacity, layers[i].Opacity);
Assert.Equal(document.Layers[i].IsVisible, layers[i].IsVisible);
}
}
/// <summary>
/// Draws all layers on top of a <see cref="SKBitmap"/>
/// </summary>
/// <param name="document"></param>
/// <returns>The <see cref="SKBitmap"/> instance</returns>
public static SKBitmap LayersToSKBitmap(this SerializableDocument document)
{
SKImageInfo info = new(document.Width, document.Height, SKColorType.RgbaF32, SKAlphaType.Unpremul, SKColorSpace.CreateSrgb());
using SKSurface surface = SKSurface.Create(info);
SKCanvas canvas = surface.Canvas;
using SKPaint paint = new();
foreach (SerializableLayer layer in document)
{
if (layer.PngBytes == null || layer.PngBytes.Length == 0)
{
continue;
}
bool visible = document.Layers.GetFinalLayerVisibilty(layer);
if (!visible)
{
continue;
}
double opacity = document.Layers.GetFinalLayerOpacity(layer);
if (opacity == 0)
{
continue;
}
using SKColorFilter filter = SKColorFilter.CreateBlendMode(SKColors.White.WithAlpha((byte)(opacity * 255)), SKBlendMode.DstIn);
paint.ColorFilter = filter;
canvas.DrawImage(layer.ToSKImage(), layer.OffsetX, layer.OffsetY, paint);
}
SKBitmap bitmap = new(info);
surface.ReadPixels(info, bitmap.GetPixels(), info.RowBytes, 0, 0);
return(bitmap);
}
public void SerializingAndDeserialzingWorks()
{
SerializableDocument document = new()
{
Height = 1,
Width = 1
};
document.Swatches.Add(255, 255, 255);
SerializableLayer layer = document.Layers.Add("Base Layer", 1, 1, false, 0.5f, 1, 1);
layer.PngBytes = new byte[] { 0xFF, 0xFF, 0xFF, 0xFF };
document.Groups.Add(new SerializableGroup("Base Group"));
byte[] serialized = PixiParser.Serialize(document);
SerializableDocument deserializedDocument = PixiParser.Deserialize(serialized);
AssertEqual(document, deserializedDocument);
}
/// <summary>
/// Builds the zone tree
/// </summary>
/// <param name="classifiedDoc">The classified html document</param>
/// <returns>
/// a zone tree
/// </returns>
public ZoneTree Build(SerializableDocument classifiedDoc)
{
try
{
_currentId = 0;
var bodyZone = new Zone(_currentId, null);
var bodyElement = (SerializableElement)classifiedDoc.Body;
bodyZone.AddElement(bodyElement);
this.Build(bodyZone);
this.CropZoneText(bodyZone, classifiedDoc.Text);
this.SetDisplayOrder(bodyZone);
var tree = new ZoneTree(bodyZone, classifiedDoc);
this.RunPostProcessingSteps(tree);
return(tree);
}
catch (Exception ex)
{
throw new Exception("Error building zone tree", ex);
}
}
public static void AssertEquals(SerializableDocument d1, SerializableDocument d2, bool compareStringTables = true)
{
Assert.AreEqual(d1.EntityTables.Count, d2.EntityTables.Count);
Assert.AreEqual(d1.Header, d2.Header);
Assert.AreEqual(d1.Nodes, d2.Nodes);
if (compareStringTables)
{
var strings1 = d1.StringTable.OrderBy(x => x).ToArray();
var strings2 = d2.StringTable.OrderBy(x => x).ToArray();
Assert.AreEqual(strings1, strings2);
}
// TODO: upgrade to a proper Geometry comparer
//Assert.AreEqual(d1.Geometry.FaceCount(), d2.Geometry.FaceCount());
//Assert.AreEqual(d1.Geometry.VertexCount(), d2.Geometry.VertexCount());
Assert.AreEqual(d1.Assets.Length, d2.Assets.Length);
for (var i = 0; i < d1.EntityTables.Count; ++i)
{
AssertEquals(d1.EntityTables[i], d2.EntityTables[i]);
}
}
public static SerializableDocument CreateDocument(int size, int layers, bool encodePng = true)
{
var benchmarkDocument = new SerializableDocument()
{
Width = size,
Height = size
};
benchmarkDocument.Swatches.Add(255, 255, 255, 255);
for (int i = 0; i < layers; i++)
{
var layer = new SerializableLayer(size, size);
if (encodePng)
{
layer.FromSKBitmap(CreateSKBitmap(size));
}
benchmarkDocument.Layers.Add(layer);
}
return(benchmarkDocument);
}
private static void AssertEqual(SerializableDocument document, SerializableDocument otherDocument)
{
Assert.Equal(document.FileVersion, otherDocument.FileVersion);
Assert.Equal(document.Height, otherDocument.Height);
Assert.Equal(document.Width, otherDocument.Width);
Assert.Equal(document.Swatches.Count, otherDocument.Swatches.Count);
Assert.Equal(document.Layers.Count, document.Layers.Count);
Assert.Equal(document.Groups.Count, document.Groups.Count);
for (int i = 0; i < document.Swatches.Count; i++)
{
Assert.Equal(document.Swatches[i], otherDocument.Swatches[i]);
}
for (int i = 0; i < document.Layers.Count; i++)
{
Assert.Equal(document.Layers[i], otherDocument.Layers[i]);
}
for (int i = 0; i < document.Groups.Count; i++)
{
Assert.Equal(document.Groups[i], otherDocument.Groups[i]);
}
}
public void TestThatSerializableDocumentCreatesCorrectly()
{
Document document = GenerateSampleDocument();
SerializableDocument doc = new SerializableDocument(document);
Color swatch = document.Swatches.First();
Tuple <byte, byte, byte, byte> color = Tuple.Create(swatch.A, swatch.R, swatch.G, swatch.B);
Assert.Equal(document.Width, doc.Width);
Assert.Equal(document.Height, doc.Height);
Assert.Equal(color, doc.Swatches.First());
for (int i = 0; i < doc.Layers.Length; i++)
{
Assert.Equal(document.Layers[i].ConvertBitmapToBytes(), doc.Layers[i].BitmapBytes);
Assert.Equal(document.Layers[i].OffsetX, doc.Layers[i].OffsetX);
Assert.Equal(document.Layers[i].OffsetY, doc.Layers[i].OffsetY);
Assert.Equal(document.Layers[i].Width, doc.Layers[i].Width);
Assert.Equal(document.Layers[i].Height, doc.Layers[i].Height);
Assert.Equal(document.Layers[i].MaxWidth, doc.Layers[i].MaxWidth);
Assert.Equal(document.Layers[i].MaxHeight, doc.Layers[i].MaxHeight);
Assert.Equal(document.Layers[i].IsVisible, doc.Layers[i].IsVisible);
Assert.Equal(document.Layers[i].Opacity, doc.Layers[i].Opacity);
}
}
