mirror of
https://github.com/riegera2412/UVtools.git
synced 2026-07-11 11:02:32 +02:00
Tiago Conceição
95020ce2f1
- **File formats:** - Add and remove some image types that can be open - (Add) `CanProcess` method to know if a file can be read under a format and to allow diferent formats with same extension - (Fix) `LiftHeightTotal` and `RetractHeight` was rounding to no decimals and returning wrong values - (Improvement) Round all float setters on `Layer` class - (Improvement) Decode/encode RAM usage and performance by processing in batch groups - **Pixel Dimming:** (#262) - (Add) Option "Lightening pixels" to add brightness/lightening instead of dimming/subtract pixels - (Fix) "Dim walls only" would reset body brightness by increase pixel brightness two times it value - **Pixel Arithmetic:** - (Change) Transpose "Pixel Dimming" to "Pixel Arithmetic" - (Improvement) New options and manipulations - **(Fix) Exposure time finder:** - Generate top staircase based on selected measure (px or mm) - Zebra bars when used in mm measures, it was using X density instead Y to calculate the thickness - Move 'Unit of measure' to 'Object configuration' - Custom text with wrong Y position when using out of portion resolutions/LCDs - **CTBv4:** - (Fix) More Unknown fields discovered and implemented - (Fix) Reserved table is 384 bytes instead of 420 - (Fix) When full encoding it was forcing to change to version 3. This also affected convertions. (#263) - (Fix) `BottomRetractHeight2` was being set to `BottomRetractSpeed2` - (Fix) `RetractHeight2` was being set to `RetracSpeed2` - (Fix) The PrintParametersV4 table address - (Fix) Generates invalid files to open with Chitubox and printers (#263) - (Fix) Better progress report - **(Add) PrusaSlicer printer notes variables:** - BottomLiftHeight2 - BottomLiftSpeed2 - LiftHeight2 - LiftSpeed2 - BottomRetractSpeed - BottomRetractSpeed2 - BottomRetractHeight2 - BottomRetractSpeed2 - RetractHeight2 - RetractSpeed2 - **UI:** - (Add) File - Open current file folder (Ctrl+Shift+L): Locate and open the folder that contain the current loaded file - (Improvement) Hide some virtual extensions from file open dialog filters - (Improvement) UI: Refresh active thumbnail when changed - (Change) Icon for File - Open and Open in a new file - (Change) Rename File - Extract to: Extract file contents - (Upgrade) AvaloniaUI from 0.10.6 to 0.10.7 - (Fix) PW0, PWM, PWMX, PWMO, PWMS: Unable to decode some files with AntiAliasing (#143)
993 lines
38 KiB
C#
993 lines
38 KiB
C#
/*
|
|
* GNU AFFERO GENERAL PUBLIC LICENSE
|
|
* Version 3, 19 November 2007
|
|
* Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
|
|
* Everyone is permitted to copy and distribute verbatim copies
|
|
* of this license document, but changing it is not allowed.
|
|
*/
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.Drawing;
|
|
using System.Globalization;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
using BinarySerialization;
|
|
using Emgu.CV;
|
|
using Emgu.CV.CvEnum;
|
|
using Emgu.CV.Structure;
|
|
using MoreLinq;
|
|
using UVtools.Core.Extensions;
|
|
using UVtools.Core.Operations;
|
|
|
|
namespace UVtools.Core.FileFormats
|
|
{
|
|
public class CXDLPFile : FileFormat
|
|
{
|
|
#region Constants
|
|
private const byte HEADER_SIZE = 9; // CXSW3DV2
|
|
private const string HEADER_VALUE = "CXSW3DV2";
|
|
#endregion
|
|
|
|
#region Sub Classes
|
|
#region Header
|
|
public sealed class Header
|
|
{
|
|
//private string _printerModel = "CL-89";
|
|
|
|
/// <summary>
|
|
/// Gets the size of the header
|
|
/// </summary>
|
|
[FieldOrder(0)]
|
|
[FieldEndianness(Endianness.Big)]
|
|
public uint HeaderSize { get; set; } = HEADER_SIZE;
|
|
|
|
/// <summary>
|
|
/// Gets the header name
|
|
/// </summary>
|
|
[FieldOrder(1)]
|
|
[FieldLength(HEADER_SIZE)]
|
|
[SerializeAs(SerializedType.TerminatedString)]
|
|
public string HeaderValue { get; set; } = HEADER_VALUE;
|
|
|
|
[FieldOrder(2)]
|
|
[FieldEndianness(Endianness.Big)]
|
|
public ushort Version { get; set; } = 2;
|
|
|
|
/// <summary>
|
|
/// Gets the size of the printer model
|
|
/// </summary>
|
|
[FieldOrder(3)]
|
|
[FieldEndianness(Endianness.Big)]
|
|
public uint PrinterModelSize { get; set; } = 6;
|
|
|
|
/// <summary>
|
|
/// Gets the printer model
|
|
/// </summary>
|
|
/*[FieldOrder(4)]
|
|
[FieldLength(nameof(PrinterModelSize), BindingMode = BindingMode.OneWay)]
|
|
[SerializeAs(SerializedType.TerminatedString)]
|
|
public string PrinterModel
|
|
{
|
|
get => _printerModel;
|
|
set
|
|
{
|
|
_printerModel = value;
|
|
PrinterModelSize = string.IsNullOrEmpty(value) ? 0 : (uint)value.Length+1;
|
|
}
|
|
}*/
|
|
|
|
[FieldOrder(4)]
|
|
[FieldLength(nameof(PrinterModelSize))]
|
|
public byte[] PrinterModelArray { get; set; } = { 0x43, 0x4C, 0x2D, 0x38, 0x39, 0x0 }; // CL-89
|
|
|
|
[Ignore]
|
|
public string PrinterModel
|
|
{
|
|
get => Encoding.ASCII.GetString(PrinterModelArray).TrimEnd(char.MinValue);
|
|
set
|
|
{
|
|
PrinterModelArray = Encoding.ASCII.GetBytes(value + char.MinValue);
|
|
PrinterModelSize = (uint) PrinterModelArray.Length;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the number of records in the layer table
|
|
/// </summary>
|
|
[FieldOrder(5)]
|
|
[FieldEndianness(Endianness.Big)]
|
|
public ushort LayerCount { get; set; }
|
|
|
|
/// <summary>
|
|
/// Gets the printer resolution along X axis, in pixels. This information is critical to correctly decoding layer images.
|
|
/// </summary>
|
|
[FieldOrder(6)]
|
|
[FieldEndianness(Endianness.Big)]
|
|
public ushort ResolutionX { get; set; }
|
|
|
|
/// <summary>
|
|
/// Gets the printer resolution along Y axis, in pixels. This information is critical to correctly decoding layer images.
|
|
/// </summary>
|
|
[FieldOrder(7)]
|
|
[FieldEndianness(Endianness.Big)]
|
|
public ushort ResolutionY { get; set; }
|
|
|
|
[FieldOrder(8)]
|
|
[FieldLength(64)]
|
|
public byte[] Offset { get; set; } = new byte[64];
|
|
|
|
public void Validate()
|
|
{
|
|
if (HeaderSize != HEADER_SIZE || HeaderValue != HEADER_VALUE)
|
|
{
|
|
throw new FileLoadException("Not a valid CXDLP file!");
|
|
}
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
return $"{nameof(HeaderSize)}: {HeaderSize}, {nameof(HeaderValue)}: {HeaderValue}, {nameof(Version)}: {Version}, {nameof(PrinterModelSize)}: {PrinterModelSize}, {nameof(PrinterModelArray)}: {PrinterModelArray}, {nameof(PrinterModel)}: {PrinterModel}, {nameof(LayerCount)}: {LayerCount}, {nameof(ResolutionX)}: {ResolutionX}, {nameof(ResolutionY)}: {ResolutionY}, {nameof(Offset)}: {Offset}";
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region SlicerInfo
|
|
// Address: 363407
|
|
public sealed class SlicerInfo
|
|
{
|
|
[FieldOrder(0)]
|
|
[FieldEndianness(Endianness.Big)]
|
|
public uint DisplayWidthDataSize { get; set; } = 20;
|
|
|
|
[FieldOrder(1)]
|
|
[FieldLength(nameof(DisplayWidthDataSize))]
|
|
public byte[] DisplayWidthBytes { get; set; }
|
|
|
|
[FieldOrder(2)]
|
|
[FieldEndianness(Endianness.Big)]
|
|
public uint DisplayHeightDataSize { get; set; } = 20;
|
|
|
|
[FieldOrder(3)]
|
|
[FieldLength(nameof(DisplayHeightDataSize))]
|
|
public byte[] DisplayHeightBytes { get; set; }
|
|
|
|
[FieldOrder(4)]
|
|
[FieldEndianness(Endianness.Big)]
|
|
public uint LayerHeightDataSize { get; set; } = 16;
|
|
|
|
[FieldOrder(5)]
|
|
[FieldLength(nameof(LayerHeightDataSize))]
|
|
public byte[] LayerHeightBytes { get; set; }
|
|
|
|
[FieldOrder(6)]
|
|
[FieldEndianness(Endianness.Big)]
|
|
public ushort ExposureTime { get; set; }
|
|
|
|
[FieldOrder(7)]
|
|
[FieldEndianness(Endianness.Big)]
|
|
public ushort LightOffDelay { get; set; }
|
|
|
|
[FieldOrder(8)]
|
|
[FieldEndianness(Endianness.Big)]
|
|
public ushort BottomExposureTime { get; set; }
|
|
|
|
[FieldOrder(9)]
|
|
[FieldEndianness(Endianness.Big)]
|
|
public ushort BottomLayers { get; set; }
|
|
|
|
[FieldOrder(10)]
|
|
[FieldEndianness(Endianness.Big)]
|
|
public ushort BottomLiftHeight { get; set; }
|
|
|
|
[FieldOrder(11)]
|
|
[FieldEndianness(Endianness.Big)]
|
|
public ushort BottomLiftSpeed { get; set; }
|
|
|
|
[FieldOrder(12)]
|
|
[FieldEndianness(Endianness.Big)]
|
|
public ushort LiftHeight { get; set; }
|
|
|
|
[FieldOrder(13)]
|
|
[FieldEndianness(Endianness.Big)]
|
|
public ushort LiftSpeed { get; set; }
|
|
|
|
[FieldOrder(14)]
|
|
[FieldEndianness(Endianness.Big)]
|
|
public ushort RetractSpeed { get; set; }
|
|
|
|
[FieldOrder(15)]
|
|
[FieldEndianness(Endianness.Big)]
|
|
public ushort BottomLightPWM { get; set; } = 255;
|
|
|
|
[FieldOrder(16)]
|
|
[FieldEndianness(Endianness.Big)]
|
|
public ushort LightPWM { get; set; } = 255;
|
|
|
|
public override string ToString()
|
|
{
|
|
return $"{nameof(DisplayWidthDataSize)}: {DisplayWidthDataSize}, {nameof(DisplayWidthBytes)}: {DisplayWidthBytes}, {nameof(DisplayHeightDataSize)}: {DisplayHeightDataSize}, {nameof(DisplayHeightBytes)}: {DisplayHeightBytes}, {nameof(LayerHeightDataSize)}: {LayerHeightDataSize}, {nameof(LayerHeightBytes)}: {LayerHeightBytes}, {nameof(ExposureTime)}: {ExposureTime}, {nameof(LightOffDelay)}: {LightOffDelay}, {nameof(BottomExposureTime)}: {BottomExposureTime}, {nameof(BottomLayers)}: {BottomLayers}, {nameof(BottomLiftHeight)}: {BottomLiftHeight}, {nameof(BottomLiftSpeed)}: {BottomLiftSpeed}, {nameof(LiftHeight)}: {LiftHeight}, {nameof(LiftSpeed)}: {LiftSpeed}, {nameof(RetractSpeed)}: {RetractSpeed}, {nameof(BottomLightPWM)}: {BottomLightPWM}, {nameof(LightPWM)}: {LightPWM}";
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region Layer Def
|
|
|
|
public sealed class PreLayer
|
|
{
|
|
[FieldOrder(0)]
|
|
[FieldEndianness(Endianness.Big)]
|
|
public uint LayerArea { get; set; }
|
|
|
|
public PreLayer()
|
|
{
|
|
}
|
|
|
|
public PreLayer(uint layerArea)
|
|
{
|
|
LayerArea = layerArea;
|
|
}
|
|
}
|
|
|
|
public sealed class LayerDef
|
|
{
|
|
[FieldOrder(0)] [FieldEndianness(Endianness.Big)] public uint LayerArea { get; set; }
|
|
[FieldOrder(1)] [FieldEndianness(Endianness.Big)] public uint LineCount { get; set; }
|
|
[FieldOrder(2)] [FieldCount(nameof(LineCount))] public LayerLine[] Lines { get; set; }
|
|
[FieldOrder(3)] public PageBreak PageBreak { get; set; } = new();
|
|
|
|
public static byte[] GetHeaderBytes(uint layerArea, uint lineCount)
|
|
{
|
|
var bytes = new byte[8];
|
|
BitExtensions.ToBytesBigEndian(layerArea, bytes);
|
|
BitExtensions.ToBytesBigEndian(lineCount, bytes, 4);
|
|
return bytes;
|
|
}
|
|
|
|
public LayerDef() { }
|
|
|
|
public LayerDef(uint layerArea, uint lineCount, LayerLine[] lines)
|
|
{
|
|
LayerArea = layerArea;
|
|
LineCount = lineCount;
|
|
Lines = lines;
|
|
}
|
|
}
|
|
|
|
public sealed class LayerLine
|
|
{
|
|
public const byte CoordinateCount = 5;
|
|
[FieldOrder(0)] [FieldCount(CoordinateCount)] public byte[] Coordinates { get; set; } = new byte[CoordinateCount];
|
|
//[FieldOrder(0)] [FieldEndianness(Endianness.Big)] [FieldBitLength(13)] public ushort StartY { get; set; }
|
|
//[FieldOrder(1)] [FieldEndianness(Endianness.Big)] [FieldBitLength(13)] public ushort EndY { get; set; }
|
|
//[FieldOrder(2)] [FieldEndianness(Endianness.Big)] [FieldBitLength(14)] public ushort StartX { get; set; }
|
|
[FieldOrder(1)] public byte Gray { get; set; }
|
|
|
|
[Ignore] public ushort StartY => (ushort) ((((Coordinates[0] << 8) + Coordinates[1]) >> 3) & 0x1FFF); // 13 bits
|
|
|
|
[Ignore] public ushort EndY => (ushort)((((Coordinates[1] << 16) + (Coordinates[2] << 8) + Coordinates[3]) >> 6) & 0x1FFF); // 13 bits
|
|
|
|
[Ignore] public ushort StartX => (ushort)(((Coordinates[3] << 8) + Coordinates[4]) & 0x3FFF); // 14 bits
|
|
[Ignore] public ushort Length => (ushort) (EndY - StartY);
|
|
|
|
public static byte[] GetBytes(ushort startY, ushort endY, ushort startX, byte gray)
|
|
{
|
|
var bytes = new byte[CoordinateCount + 1];
|
|
bytes[0] = (byte)((startY >> 5) & 0xFF);
|
|
bytes[1] = (byte)(((startY << 3) + (endY >> 10)) & 0xFF);
|
|
bytes[2] = (byte)((endY >> 2) & 0xFF);
|
|
bytes[3] = (byte)(((endY << 6) + (startX >> 8)) & 0xFF);
|
|
bytes[4] = (byte)startX;
|
|
bytes[5] = gray;
|
|
return bytes;
|
|
}
|
|
|
|
public LayerLine() { }
|
|
|
|
public LayerLine(ushort startY, ushort endY, ushort startX, byte gray)
|
|
{
|
|
Coordinates[0] = (byte) ((startY >> 5) & 0xFF);
|
|
Coordinates[1] = (byte) (((startY << 3) + (endY >> 10)) & 0xFF);
|
|
Coordinates[2] = (byte) ((endY >> 2) & 0xFF);
|
|
Coordinates[3] = (byte)(((endY << 6) + (startX >> 8)) & 0xFF);
|
|
Coordinates[4] = (byte) startX;
|
|
/*StartY = startY;
|
|
EndY = endY;
|
|
StartX = startX;*/
|
|
Gray = gray;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
return $"{nameof(Gray)}: {Gray}, {nameof(StartY)}: {StartY}, {nameof(EndY)}: {EndY}, {nameof(StartX)}: {StartX}, {nameof(Length)}: {Length}";
|
|
}
|
|
}
|
|
|
|
public sealed class PageBreak
|
|
{
|
|
public static byte[] Bytes => new byte[] {0x0D, 0x0A};
|
|
|
|
[FieldOrder(0)] public byte Line { get; set; } = 0x0D;
|
|
[FieldOrder(1)] public byte Break { get; set; } = 0x0A;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Footer
|
|
public sealed class Footer
|
|
{
|
|
/// <summary>
|
|
/// Gets the size of the header
|
|
/// </summary>
|
|
[FieldOrder(0)]
|
|
[FieldEndianness(Endianness.Big)]
|
|
public uint FooterSize { get; set; } = HEADER_SIZE;
|
|
|
|
/// <summary>
|
|
/// Gets the header name
|
|
/// </summary>
|
|
[FieldOrder(1)]
|
|
[FieldLength(HEADER_SIZE)]
|
|
[SerializeAs(SerializedType.TerminatedString)]
|
|
public string FooterValue { get; set; } = HEADER_VALUE;
|
|
|
|
/*[FieldOrder(2)]
|
|
[FieldEndianness(Endianness.Big)]
|
|
public uint CheckSum { get; set; }*/
|
|
|
|
public void Validate()
|
|
{
|
|
if (FooterSize != HEADER_SIZE || FooterValue != HEADER_VALUE)
|
|
{
|
|
throw new FileLoadException("Not a valid CXDLP file!");
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region Properties
|
|
|
|
public Header HeaderSettings { get; protected internal set; } = new();
|
|
public SlicerInfo SlicerInfoSettings { get; protected internal set; } = new();
|
|
public Footer FooterSettings { get; protected internal set; } = new();
|
|
|
|
public override FileFormatType FileType => FileFormatType.Binary;
|
|
|
|
public override FileExtension[] FileExtensions { get; } = {
|
|
new(typeof(CXDLPFile), "cxdlp", "Creality CXDLP"),
|
|
};
|
|
|
|
public override PrintParameterModifier[] PrintParameterModifiers { get; } =
|
|
{
|
|
PrintParameterModifier.BottomLayerCount,
|
|
|
|
PrintParameterModifier.LightOffDelay,
|
|
|
|
PrintParameterModifier.BottomExposureTime,
|
|
PrintParameterModifier.ExposureTime,
|
|
|
|
PrintParameterModifier.BottomLiftHeight,
|
|
PrintParameterModifier.BottomLiftSpeed,
|
|
PrintParameterModifier.LiftHeight,
|
|
PrintParameterModifier.LiftSpeed,
|
|
PrintParameterModifier.RetractSpeed,
|
|
|
|
PrintParameterModifier.BottomLightPWM,
|
|
PrintParameterModifier.LightPWM,
|
|
};
|
|
|
|
public override Size[] ThumbnailsOriginalSize { get; } =
|
|
{
|
|
new(116, 116),
|
|
new(290, 290),
|
|
new(290, 290)
|
|
};
|
|
|
|
public override uint ResolutionX
|
|
{
|
|
get => HeaderSettings.ResolutionX;
|
|
set
|
|
{
|
|
HeaderSettings.ResolutionX = (ushort) value;
|
|
RaisePropertyChanged();
|
|
}
|
|
}
|
|
|
|
public override uint ResolutionY
|
|
{
|
|
get => HeaderSettings.ResolutionY;
|
|
set
|
|
{
|
|
HeaderSettings.ResolutionY = (ushort) value;
|
|
RaisePropertyChanged();
|
|
}
|
|
}
|
|
|
|
public override float DisplayWidth
|
|
{
|
|
get => float.Parse(Encoding.ASCII.GetString(SlicerInfoSettings.DisplayWidthBytes.Where(b => b != 0).ToArray()));
|
|
set
|
|
{
|
|
string str = Math.Round(value, 2).ToString(CultureInfo.InvariantCulture);
|
|
//string str = Math.Round(value, 2).ToString("0.000000");
|
|
SlicerInfoSettings.DisplayWidthDataSize = (uint)(str.Length * 2);
|
|
var data = new byte[SlicerInfoSettings.DisplayWidthDataSize];
|
|
for (var i = 0; i < str.Length; i++)
|
|
{
|
|
data[i * 2 + 1] = System.Convert.ToByte(str[i]);
|
|
}
|
|
|
|
SlicerInfoSettings.DisplayWidthBytes = data;
|
|
RaisePropertyChanged();
|
|
}
|
|
}
|
|
|
|
public override float DisplayHeight
|
|
{
|
|
get => float.Parse(Encoding.ASCII.GetString(SlicerInfoSettings.DisplayHeightBytes.Where(b => b != 0).ToArray()));
|
|
set
|
|
{
|
|
string str = Math.Round(value, 2).ToString(CultureInfo.InvariantCulture);
|
|
//string str = Math.Round(value, 2).ToString("0.000000");
|
|
SlicerInfoSettings.DisplayHeightDataSize = (uint)(str.Length * 2);
|
|
var data = new byte[SlicerInfoSettings.DisplayHeightDataSize];
|
|
for (var i = 0; i < str.Length; i++)
|
|
{
|
|
data[i * 2 + 1] = System.Convert.ToByte(str[i]);
|
|
}
|
|
|
|
SlicerInfoSettings.DisplayHeightBytes = data;
|
|
RaisePropertyChanged();
|
|
}
|
|
}
|
|
|
|
public override float LayerHeight
|
|
{
|
|
get => float.Parse(Encoding.ASCII.GetString(SlicerInfoSettings.LayerHeightBytes.Where(b => b != 0).ToArray()));
|
|
set
|
|
{
|
|
string str = Layer.RoundHeight(value).ToString(CultureInfo.InvariantCulture);
|
|
//string str = Layer.RoundHeight(value).ToString("0.000000");
|
|
SlicerInfoSettings.LayerHeightDataSize = (uint)(str.Length * 2);
|
|
var data = new byte[SlicerInfoSettings.LayerHeightDataSize];
|
|
for (var i = 0; i < str.Length; i++)
|
|
{
|
|
data[i * 2 + 1] = System.Convert.ToByte(str[i]);
|
|
}
|
|
|
|
SlicerInfoSettings.LayerHeightBytes = data;
|
|
RaisePropertyChanged();
|
|
}
|
|
}
|
|
|
|
public override uint LayerCount
|
|
{
|
|
get => base.LayerCount;
|
|
set => base.LayerCount = HeaderSettings.LayerCount = (ushort) base.LayerCount;
|
|
}
|
|
|
|
public override ushort BottomLayerCount
|
|
{
|
|
get => SlicerInfoSettings.BottomLayers;
|
|
set => base.BottomLayerCount = SlicerInfoSettings.BottomLayers = value;
|
|
}
|
|
|
|
public override float BottomLightOffDelay => SlicerInfoSettings.LightOffDelay;
|
|
|
|
public override float LightOffDelay
|
|
{
|
|
get => SlicerInfoSettings.LightOffDelay;
|
|
set => base.LightOffDelay = SlicerInfoSettings.LightOffDelay = (ushort)value;
|
|
}
|
|
|
|
public override float BottomWaitTimeBeforeCure
|
|
{
|
|
get => base.BottomWaitTimeBeforeCure;
|
|
set
|
|
{
|
|
SetBottomLightOffDelay(value);
|
|
base.BottomWaitTimeBeforeCure = value;
|
|
}
|
|
}
|
|
|
|
public override float WaitTimeBeforeCure
|
|
{
|
|
get => base.WaitTimeBeforeCure;
|
|
set
|
|
{
|
|
SetNormalLightOffDelay(value);
|
|
base.WaitTimeBeforeCure = value;
|
|
}
|
|
}
|
|
|
|
public override float BottomExposureTime
|
|
{
|
|
get => SlicerInfoSettings.BottomExposureTime;
|
|
set => base.BottomExposureTime = SlicerInfoSettings.BottomExposureTime = (ushort) value;
|
|
}
|
|
|
|
public override float ExposureTime
|
|
{
|
|
get => SlicerInfoSettings.ExposureTime;
|
|
set => base.ExposureTime = SlicerInfoSettings.ExposureTime = (ushort) value;
|
|
}
|
|
|
|
public override float BottomLiftHeight
|
|
{
|
|
get => SlicerInfoSettings.BottomLiftHeight;
|
|
set => base.BottomLiftHeight = SlicerInfoSettings.BottomLiftHeight = (ushort) value;
|
|
}
|
|
|
|
public override float LiftHeight
|
|
{
|
|
get => SlicerInfoSettings.LiftHeight;
|
|
set => base.LiftHeight = SlicerInfoSettings.LiftHeight = (ushort)value;
|
|
}
|
|
|
|
public override float BottomLiftSpeed
|
|
{
|
|
get => SlicerInfoSettings.BottomLiftSpeed;
|
|
set => base.BottomLiftSpeed = SlicerInfoSettings.BottomLiftSpeed = (ushort)value;
|
|
}
|
|
|
|
public override float LiftSpeed
|
|
{
|
|
get => SlicerInfoSettings.LiftSpeed;
|
|
set => base.LiftSpeed = SlicerInfoSettings.LiftSpeed = (ushort)value;
|
|
}
|
|
|
|
public override float BottomRetractSpeed => RetractSpeed;
|
|
|
|
public override float RetractSpeed
|
|
{
|
|
get => SlicerInfoSettings.RetractSpeed;
|
|
set => base.RetractSpeed = SlicerInfoSettings.RetractSpeed = (ushort)value;
|
|
}
|
|
|
|
public override byte BottomLightPWM
|
|
{
|
|
get => (byte) SlicerInfoSettings.BottomLightPWM;
|
|
set => base.BottomLightPWM = (byte) (SlicerInfoSettings.BottomLightPWM = value);
|
|
}
|
|
|
|
public override byte LightPWM
|
|
{
|
|
get => (byte)SlicerInfoSettings.LightPWM;
|
|
set => base.LightPWM = (byte) (SlicerInfoSettings.LightPWM = value);
|
|
}
|
|
|
|
public override string MachineName
|
|
{
|
|
get => HeaderSettings.PrinterModel;
|
|
set => base.MachineName = HeaderSettings.PrinterModel = value;
|
|
}
|
|
|
|
public override object[] Configs => new object[] { HeaderSettings, SlicerInfoSettings, FooterSettings };
|
|
|
|
#endregion
|
|
|
|
#region Constructors
|
|
#endregion
|
|
|
|
#region Methods
|
|
|
|
protected override void EncodeInternally(string fileFullPath, OperationProgress progress)
|
|
{
|
|
using var outputFile = new FileStream(fileFullPath, FileMode.Create, FileAccess.ReadWrite);
|
|
|
|
if (ResolutionX == 1620 && ResolutionY == 2560)
|
|
{
|
|
MachineName = "CL-60";
|
|
}
|
|
else if (ResolutionX == 3840 && ResolutionY == 2400)
|
|
{
|
|
MachineName = "CL-89";
|
|
}
|
|
else if (ResolutionX == 3840 && ResolutionY == 2160)
|
|
{
|
|
MachineName = "CL-133";
|
|
}
|
|
else if (!MachineName.StartsWith("CL-"))
|
|
{
|
|
throw new Exception("Unable to detect the printer model from resolution, check if resolution is well defined on slicer for your printer model.");
|
|
}
|
|
|
|
var pageBreak = PageBreak.Bytes;
|
|
|
|
Helpers.SerializeWriteFileStream(outputFile, HeaderSettings);
|
|
|
|
var previews = new byte[ThumbnailsOriginalSize.Length][];
|
|
|
|
// Previews
|
|
Parallel.For(0, previews.Length, previewIndex =>
|
|
{
|
|
if (progress.Token.IsCancellationRequested) return;
|
|
var encodeLength = ThumbnailsOriginalSize[previewIndex].Area() * 2;
|
|
if (Thumbnails[previewIndex] is null)
|
|
{
|
|
previews[previewIndex] = new byte[encodeLength];
|
|
return;
|
|
}
|
|
|
|
previews[previewIndex] = EncodeImage(DATATYPE_RGB565_BE, Thumbnails[previewIndex]);
|
|
|
|
if (encodeLength != previews[previewIndex].Length)
|
|
{
|
|
throw new FileLoadException($"Preview encode incomplete encode, expected: {previews[previewIndex].Length}, encoded: {encodeLength}");
|
|
}
|
|
});
|
|
|
|
for (int i = 0; i < ThumbnailsOriginalSize.Length; i++)
|
|
{
|
|
Helpers.SerializeWriteFileStream(outputFile, previews[i]);
|
|
outputFile.WriteBytes(pageBreak);
|
|
previews[i] = null;
|
|
}
|
|
Helpers.SerializeWriteFileStream(outputFile, SlicerInfoSettings);
|
|
|
|
progress.Reset(OperationProgress.StatusEncodeLayers, LayerCount);
|
|
//var preLayers = new PreLayer[LayerCount];
|
|
//var layerDefs = new LayerDef[LayerCount];
|
|
//var layersStreams = new MemoryStream[LayerCount];
|
|
|
|
|
|
for (int layerIndex = 0; layerIndex < LayerCount; layerIndex++)
|
|
{
|
|
//var layer = this[layerIndex];
|
|
outputFile.WriteBytes(BitExtensions.ToBytesBigEndian((uint)Math.Round(this[layerIndex].BoundingRectangleMillimeters.Area()*1000)));
|
|
//preLayers[layerIndex] = new(layer.NonZeroPixelCount);
|
|
}
|
|
//Helpers.SerializeWriteFileStream(outputFile, preLayers);
|
|
//Helpers.SerializeWriteFileStream(outputFile, pageBreak);
|
|
outputFile.WriteBytes(pageBreak);
|
|
|
|
var layerBytes = new List<byte>[LayerCount];
|
|
foreach (var batch in BatchLayersIndexes())
|
|
{
|
|
progress.Token.ThrowIfCancellationRequested();
|
|
|
|
Parallel.ForEach(batch, layerIndex =>
|
|
{
|
|
if (progress.Token.IsCancellationRequested) return;
|
|
var layer = this[layerIndex];
|
|
using (var mat = layer.LayerMat)
|
|
{
|
|
var span = mat.GetDataByteSpan();
|
|
|
|
layerBytes[layerIndex] = new();
|
|
|
|
uint lineCount = 0;
|
|
|
|
for (int x = layer.BoundingRectangle.X; x < layer.BoundingRectangle.Right; x++)
|
|
{
|
|
int y = layer.BoundingRectangle.Y;
|
|
int startY = -1;
|
|
byte lastColor = 0;
|
|
for (; y < layer.BoundingRectangle.Bottom; y++)
|
|
{
|
|
int pos = mat.GetPixelPos(x, y);
|
|
byte color = span[pos];
|
|
|
|
if (lastColor == color && color != 0) continue;
|
|
|
|
if (startY >= 0)
|
|
{
|
|
layerBytes[layerIndex].AddRange(LayerLine.GetBytes((ushort)startY, (ushort)(y - 1),
|
|
(ushort)x, lastColor));
|
|
lineCount++;
|
|
}
|
|
|
|
startY = color == 0 ? -1 : y;
|
|
|
|
lastColor = color;
|
|
}
|
|
|
|
if (startY >= 0)
|
|
{
|
|
layerBytes[layerIndex].AddRange(LayerLine.GetBytes((ushort)startY, (ushort)(y - 1),
|
|
(ushort)x, lastColor));
|
|
lineCount++;
|
|
}
|
|
}
|
|
|
|
layerBytes[layerIndex].InsertRange(0, LayerDef.GetHeaderBytes(
|
|
(uint)Math.Round(layer.BoundingRectangleMillimeters.Area() * 1000),
|
|
lineCount));
|
|
layerBytes[layerIndex].AddRange(pageBreak);
|
|
}
|
|
|
|
progress.LockAndIncrement();
|
|
});
|
|
|
|
progress.Token.ThrowIfCancellationRequested();
|
|
|
|
foreach (var layerIndex in batch)
|
|
{
|
|
outputFile.WriteBytes(layerBytes[layerIndex].ToArray());
|
|
layerBytes[layerIndex] = null;
|
|
}
|
|
}
|
|
|
|
|
|
/*Parallel.For(0, LayerCount,
|
|
//new ParallelOptions{MaxDegreeOfParallelism = 1},
|
|
layerIndex =>
|
|
{
|
|
if (progress.Token.IsCancellationRequested) return;
|
|
//List<LayerLine> layerLines = new();
|
|
var layer = this[layerIndex];
|
|
using var mat = layer.LayerMat;
|
|
var span = mat.GetDataByteSpan();
|
|
|
|
layerBytes[layerIndex] = new();
|
|
|
|
for (int x = layer.BoundingRectangle.X; x < layer.BoundingRectangle.Right; x++)
|
|
{
|
|
int y = layer.BoundingRectangle.Y;
|
|
int startY = -1;
|
|
byte lastColor = 0;
|
|
for (; y < layer.BoundingRectangle.Bottom; y++)
|
|
{
|
|
int pos = mat.GetPixelPos(x, y);
|
|
byte color = span[pos];
|
|
|
|
if (lastColor == color && color != 0) continue;
|
|
|
|
if (startY >= 0)
|
|
{
|
|
layerBytes[layerIndex].AddRange(LayerLine.GetBytes((ushort)startY, (ushort)(y - 1), (ushort)x, lastColor));
|
|
//layerLines.Add(new LayerLine((ushort)startY, (ushort)(y - 1), (ushort)x, lastColor));
|
|
//Debug.WriteLine(layerLines[^1]);
|
|
}
|
|
|
|
startY = color == 0 ? -1 : y;
|
|
|
|
lastColor = color;
|
|
}
|
|
|
|
if (startY >= 0)
|
|
{
|
|
layerBytes[layerIndex].AddRange(LayerLine.GetBytes((ushort)startY, (ushort)(y - 1), (ushort)x, lastColor));
|
|
//layerLines.Add(new LayerLine((ushort)startY, (ushort)(y - 1), (ushort)x, lastColor));
|
|
//Debug.WriteLine(layerLines[^1]);
|
|
}
|
|
}
|
|
|
|
//layerDefs[layerIndex] = new LayerDef(layer.NonZeroPixelCount, (uint)layerLines.Count, layerLines.ToArray());
|
|
//var layerDef = new LayerDef(layer.NonZeroPixelCount, (uint)layerLines.Count, layerLines.ToArray());
|
|
//layersStreams[layerIndex] = new MemoryStream();
|
|
//Helpers.Serializer.Serialize(layersStreams[layerIndex], layerDef);
|
|
|
|
//layerBytes[layerIndex].InsertRange(0, LayerDef.GetHeaderBytes(layer.NonZeroPixelCount, (uint) layerBytes[layerIndex].Count));
|
|
//layerBytes[layerIndex].AddRange(PageBreak.Bytes);
|
|
|
|
progress.LockAndIncrement();
|
|
});
|
|
|
|
progress.Reset(OperationProgress.StatusWritingFile, LayerCount);
|
|
for (int layerIndex = 0; layerIndex < LayerCount; layerIndex++)
|
|
{
|
|
progress.Token.ThrowIfCancellationRequested();
|
|
//Helpers.SerializeWriteFileStream(outputFile, layerDefs[layerIndex]);
|
|
//outputFile.WriteStream(layersStreams[layerIndex]);
|
|
//layersStreams[layerIndex].Dispose();
|
|
outputFile.WriteBytes(LayerDef.GetHeaderBytes(this[layerIndex].NonZeroPixelCount, (uint)layerBytes[layerIndex].Count));
|
|
outputFile.WriteBytes(layerBytes[layerIndex].ToArray());
|
|
outputFile.WriteBytes(pageBreak);
|
|
progress++;
|
|
}*/
|
|
|
|
Helpers.SerializeWriteFileStream(outputFile, FooterSettings);
|
|
|
|
uint checkSum = CalculateCheckSum(outputFile, false);
|
|
|
|
outputFile.Write(BitExtensions.ToBytesBigEndian(checkSum));
|
|
|
|
Debug.WriteLine("Encode Results:");
|
|
Debug.WriteLine(HeaderSettings);
|
|
Debug.WriteLine("-End-");
|
|
}
|
|
|
|
protected override void DecodeInternally(string fileFullPath, OperationProgress progress)
|
|
{
|
|
using var inputFile = new FileStream(fileFullPath, FileMode.Open, FileAccess.Read);
|
|
|
|
inputFile.Seek(0, SeekOrigin.Begin);
|
|
|
|
HeaderSettings = Helpers.Deserialize<Header>(inputFile);
|
|
Debug.WriteLine(HeaderSettings);
|
|
HeaderSettings.Validate();
|
|
|
|
var position = inputFile.Position;
|
|
|
|
var expectedCheckSum = CalculateCheckSum(inputFile, false, -4);
|
|
inputFile.Seek(3, SeekOrigin.Current);
|
|
byte checkSum = (byte) inputFile.ReadByte();
|
|
|
|
inputFile.Seek(position, SeekOrigin.Begin);
|
|
|
|
|
|
if (expectedCheckSum != checkSum)
|
|
{
|
|
throw new FileLoadException($"Checksum fails, expecting: {expectedCheckSum} but got: {checkSum}.\n" +
|
|
$"Try to reslice the file.", fileFullPath);
|
|
}
|
|
|
|
byte[][] previews = new byte[ThumbnailsOriginalSize.Length][];
|
|
for (int i = 0; i < ThumbnailsOriginalSize.Length; i++)
|
|
{
|
|
previews[i] = new byte[ThumbnailsOriginalSize[i].Area() * 2];
|
|
inputFile.ReadBytes(previews[i]);
|
|
inputFile.Seek(2, SeekOrigin.Current);
|
|
}
|
|
|
|
Parallel.For(0, previews.Length, previewIndex =>
|
|
{
|
|
Thumbnails[previewIndex] = DecodeImage(DATATYPE_RGB565_BE, previews[previewIndex], ThumbnailsOriginalSize[previewIndex]);
|
|
previews[previewIndex] = null;
|
|
});
|
|
|
|
|
|
SlicerInfoSettings = Helpers.Deserialize<SlicerInfo>(inputFile);
|
|
Debug.WriteLine(SlicerInfoSettings);
|
|
|
|
LayerManager.Init(HeaderSettings.LayerCount);
|
|
inputFile.Seek(LayerCount * 4 + 2, SeekOrigin.Current); // Skip pre layers
|
|
progress.Reset(OperationProgress.StatusDecodeLayers, LayerCount);
|
|
/*var preLayers = new PreLayer[LayerCount];
|
|
for (int layerIndex = 0; layerIndex < LayerCount; layerIndex++)
|
|
{
|
|
progress.Token.ThrowIfCancellationRequested();
|
|
preLayers[layerIndex] = Helpers.Deserialize<PreLayer>(inputFile);
|
|
progress++;
|
|
}*/
|
|
|
|
//inputFile.Seek(2, SeekOrigin.Current);
|
|
|
|
var linesBytes = new byte[LayerCount][];
|
|
foreach (var batch in BatchLayersIndexes())
|
|
{
|
|
progress.Token.ThrowIfCancellationRequested();
|
|
|
|
foreach (var layerIndex in batch)
|
|
{
|
|
inputFile.Seek(4, SeekOrigin.Current);
|
|
var lineCount = BitExtensions.ToUIntBigEndian(inputFile.ReadBytes(4));
|
|
|
|
linesBytes[layerIndex] = new byte[lineCount * 6];
|
|
inputFile.ReadBytes(linesBytes[layerIndex]);
|
|
inputFile.Seek(2, SeekOrigin.Current);
|
|
|
|
progress.Token.ThrowIfCancellationRequested();
|
|
}
|
|
|
|
Parallel.ForEach(batch, layerIndex =>
|
|
{
|
|
if (progress.Token.IsCancellationRequested) return;
|
|
using (var mat = EmguExtensions.InitMat(Resolution))
|
|
{
|
|
|
|
for (int i = 0; i < linesBytes[layerIndex].Length; i++)
|
|
{
|
|
LayerLine line = new()
|
|
{
|
|
Coordinates =
|
|
{
|
|
[0] = linesBytes[layerIndex][i++],
|
|
[1] = linesBytes[layerIndex][i++],
|
|
[2] = linesBytes[layerIndex][i++],
|
|
[3] = linesBytes[layerIndex][i++],
|
|
[4] = linesBytes[layerIndex][i++]
|
|
},
|
|
Gray = linesBytes[layerIndex][i]
|
|
};
|
|
|
|
CvInvoke.Line(mat, new Point(line.StartX, line.StartY), new Point(line.StartX, line.EndY),
|
|
new MCvScalar(line.Gray));
|
|
}
|
|
|
|
linesBytes[layerIndex] = null;
|
|
|
|
this[layerIndex] = new Layer((uint)layerIndex, mat, this);
|
|
}
|
|
|
|
progress.LockAndIncrement();
|
|
});
|
|
}
|
|
|
|
progress.Token.ThrowIfCancellationRequested();
|
|
|
|
/*var layerDefs = new LayerDef[LayerCount];
|
|
for (int layerIndex = 0; layerIndex < LayerCount; layerIndex++)
|
|
{
|
|
progress.Token.ThrowIfCancellationRequested();
|
|
layerDefs[layerIndex] = Helpers.Deserialize<LayerDef>(inputFile);
|
|
progress++;
|
|
}
|
|
|
|
progress.Reset(OperationProgress.StatusDecodeLayers, LayerCount);
|
|
Parallel.For(0, LayerCount, layerIndex =>
|
|
{
|
|
if (progress.Token.IsCancellationRequested) return;
|
|
using var mat = EmguExtensions.InitMat(Resolution);
|
|
foreach (var line in layerDefs[layerIndex].Lines)
|
|
{
|
|
CvInvoke.Line(mat, new Point(line.StartX, line.StartY), new Point(line.StartX, line.EndY), new MCvScalar(line.Gray));
|
|
}
|
|
|
|
this[layerIndex] = new Layer((uint)layerIndex, mat, this);
|
|
progress.LockAndIncrement();
|
|
});*/
|
|
|
|
FooterSettings = Helpers.Deserialize<Footer>(inputFile);
|
|
FooterSettings.Validate();
|
|
}
|
|
|
|
public override void SaveAs(string filePath = null, OperationProgress progress = null)
|
|
{
|
|
if (RequireFullEncode)
|
|
{
|
|
if (!string.IsNullOrEmpty(filePath))
|
|
{
|
|
FileFullPath = filePath;
|
|
}
|
|
Encode(FileFullPath, progress);
|
|
return;
|
|
}
|
|
|
|
if (!string.IsNullOrEmpty(filePath))
|
|
{
|
|
File.Copy(FileFullPath, filePath, true);
|
|
FileFullPath = filePath;
|
|
}
|
|
|
|
var offset = Helpers.Serializer.SizeOf(HeaderSettings);
|
|
foreach (var size in ThumbnailsOriginalSize)
|
|
{
|
|
offset += size.Area() * 2 + 2; // + page break
|
|
}
|
|
|
|
using var outputFile = new FileStream(FileFullPath, FileMode.Open, FileAccess.ReadWrite);
|
|
outputFile.Seek(offset, SeekOrigin.Begin);
|
|
Helpers.SerializeWriteFileStream(outputFile, SlicerInfoSettings);
|
|
|
|
uint checkSum = CalculateCheckSum(outputFile, false, -4);
|
|
outputFile.WriteBytes(BitExtensions.ToBytesBigEndian(checkSum));
|
|
}
|
|
|
|
private byte CalculateCheckSum(FileStream fs, bool restorePosition = true, int offsetSize = 0)
|
|
{
|
|
byte checkSum = 0;
|
|
var position = fs.Position;
|
|
var dataSize = fs.Length + offsetSize;
|
|
const int bufferSize = 50 * 1024 * 1024;
|
|
|
|
fs.Seek(0, SeekOrigin.Begin);
|
|
|
|
for (
|
|
int chunkSize = (int)Math.Min(bufferSize, dataSize - fs.Position);
|
|
chunkSize > 0;
|
|
chunkSize = (int)Math.Min(chunkSize, dataSize - fs.Position))
|
|
{
|
|
var bytes = fs.ReadBytes(chunkSize);
|
|
for (int i = 0; i < bytes.Length; i++)
|
|
{
|
|
checkSum ^= bytes[i];
|
|
}
|
|
}
|
|
|
|
if (restorePosition) fs.Seek(position, SeekOrigin.Begin);
|
|
|
|
return checkSum;
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
}
|