maker/UVtools
1
0
Fork 0
mirror of https://github.com/riegera2412/UVtools.git synced 2026-07-11 19:12:31 +02:00
Code Issues Packages Projects Releases Wiki Activity
Files
29c485458ce300e0085d9af01ce2ecc87fd0cbd5
UVtools/UVtools.Core/FileFormats/PhotonSFile.cs
T
Tiago Conceição 74b6335f64 v2.13.4 
- (Fix) ZCode: lcd.gcode was blank / not generating when converting from any file format
- (Fix) Zcodex: Change MaterialId from `uint` to `string` (#223, #224)
- (Fix) CXDLP: Set the default printer name to `CL-89` when creating new instance, was `null` before
- (Fix) Some tools were unable to pull certain settings from profiles and imported settings:
   - Elephant foot
   - Exposure finder
   - Grayscale
   - Stress tower
   - Tolerance
   - XYZ Accuracy
   - Change resolution
   - Dynamic lifts
- (Change) `Layer repair` icon at Issues tab and `Outline` icon on preview toolbar (#227)
- (Developers) Created `UVtools.AvaloniaControls` project with `AdvancedImageBox` control for AvaloniaUI
2021-06-25 21:43:30 +01:00

550 lines
21 KiB
C#
Raw Blame History

/*
* 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.IO;
using System.Threading.Tasks;
using BinarySerialization;
using Emgu.CV;
using Emgu.CV.CvEnum;
using UVtools.Core.Extensions;
using UVtools.Core.Operations;
namespace UVtools.Core.FileFormats
{
public class PhotonSFile : FileFormat
{
public const byte RLEEncodingLimit = 128;
#region Sub Classes
#region Header
public class Header
{
public const uint ResolutionX = 1440;
public const uint ResolutionY = 2560;
public const float DisplayWidth = 68.04f;
public const float DisplayHeight = 120.96f;
public const float BuildZ = 165f;
public const uint TAG1 = 2;
public const ushort TAG2 = 49;
[FieldOrder(0)] [FieldEndianness(Endianness.Big)] public uint Tag1 { get; set; } = TAG1; // 2
[FieldOrder(1)] [FieldEndianness(Endianness.Big)] public ushort Tag2 { get; set; } = TAG2; // 49
[FieldOrder(2)] [FieldEndianness(Endianness.Big)] public double XYPixelSize { get; set; } = 0.04725; // 0.04725
[FieldOrder(3)] [FieldEndianness(Endianness.Big)] public double LayerHeight { get; set; }
[FieldOrder(4)] [FieldEndianness(Endianness.Big)] public double ExposureSeconds { get; set; }
[FieldOrder(5)] [FieldEndianness(Endianness.Big)] public double LightOffDelay { get; set; }
[FieldOrder(6)] [FieldEndianness(Endianness.Big)] public double BottomExposureSeconds { get; set; }
[FieldOrder(7)] [FieldEndianness(Endianness.Big)] public uint BottomLayerCount { get; set; }
[FieldOrder(8)] [FieldEndianness(Endianness.Big)] public double LiftHeight { get; set; } // mm
[FieldOrder(9)] [FieldEndianness(Endianness.Big)] public double LiftSpeed { get; set; } // mm/s
[FieldOrder(10)] [FieldEndianness(Endianness.Big)] public double RetractSpeed { get; set; } // mm/s
[FieldOrder(11)] [FieldEndianness(Endianness.Big)] public double VolumeMl { get; set; } // ml
[FieldOrder(12)] [FieldEndianness(Endianness.Big)] public uint PreviewResolutionX { get; set; } = 224;
[FieldOrder(13)] [FieldEndianness(Endianness.Big)] public uint Unknown2 { get; set; } = 42;
[FieldOrder(14)] [FieldEndianness(Endianness.Big)] public uint PreviewResolutionY { get; set; } = 168;
[FieldOrder(15)] [FieldEndianness(Endianness.Big)] public uint Unknown4 { get; set; } = 10;
public override string ToString()
{
return $"{nameof(Tag1)}: {Tag1}, {nameof(Tag2)}: {Tag2}, {nameof(XYPixelSize)}: {XYPixelSize}, {nameof(LayerHeight)}: {LayerHeight}, {nameof(ExposureSeconds)}: {ExposureSeconds}, {nameof(LightOffDelay)}: {LightOffDelay}, {nameof(BottomExposureSeconds)}: {BottomExposureSeconds}, {nameof(BottomLayerCount)}: {BottomLayerCount}, {nameof(LiftHeight)}: {LiftHeight}, {nameof(LiftSpeed)}: {LiftSpeed}, {nameof(RetractSpeed)}: {RetractSpeed}, {nameof(VolumeMl)}: {VolumeMl}, {nameof(PreviewResolutionX)}: {PreviewResolutionX}, {nameof(Unknown2)}: {Unknown2}, {nameof(PreviewResolutionY)}: {PreviewResolutionY}, {nameof(Unknown4)}: {Unknown4}";
}
}
public class LayerHeader
{
[FieldOrder(0)] [FieldEndianness(Endianness.Big)] public uint LayerCount { get; set; }
public override string ToString()
{
return $"{nameof(LayerCount)}: {LayerCount}";
}
}
#endregion
#region LayerDef
public class LayerData
{
[FieldOrder(0)] [FieldEndianness(Endianness.Big)] public uint Unknown1 { get; set; } = 44944;
[FieldOrder(1)] [FieldEndianness(Endianness.Big)] public uint Unknown2 { get; set; } = 0;
[FieldOrder(2)] [FieldEndianness(Endianness.Big)] public uint Unknown3 { get; set; } = 0;
[FieldOrder(3)] [FieldEndianness(Endianness.Big)] public uint ResolutionX { get; set; } = 1440;
[FieldOrder(4)] [FieldEndianness(Endianness.Big)] public uint ResolutionY { get; set; } = 2560;
[FieldOrder(5)] [FieldEndianness(Endianness.Big)] public uint DataSize { get; set; }
[Ignore] public uint RleDataSize
{
get => (DataSize >> 3) - 4;
set => DataSize = (value + 4) << 3;
//get => DataSize / 8 - 4;
//set => DataSize = (value + 4) * 8;
}
[FieldOrder(6)] [FieldEndianness(Endianness.Big)] public uint Unknown5 { get; set; } = 2684702720;
[Ignore] public byte[] EncodedRle { get; set; }
public override string ToString()
{
return $"{nameof(Unknown1)}: {Unknown1}, {nameof(Unknown2)}: {Unknown2}, {nameof(Unknown3)}: {Unknown3}, {nameof(ResolutionX)}: {ResolutionX}, {nameof(ResolutionY)}: {ResolutionY}, {nameof(DataSize)}: {DataSize}, {nameof(RleDataSize)}: {RleDataSize}, {nameof(Unknown5)}: {Unknown5}, {nameof(EncodedRle)}: {EncodedRle.Length}";
}
public unsafe byte[] Encode(Mat mat)
{
List<byte> rawData = new();
var spanMat = mat.GetBytePointer();
var imageLength = mat.GetLength();
int rep = 0;
byte color = 0;
int totalPixels = 0;
void AddRep()
{
if (rep <= 0) return;
totalPixels += rep;
rep--;
byte rle = (byte) (((rep & 1) > 0 ? 128 : 0) |
((rep & 2) > 0 ? 64 : 0) |
((rep & 4) > 0 ? 32 : 0) |
((rep & 8) > 0 ? 16 : 0) |
((rep & 16) > 0 ? 8 : 0) |
((rep & 32) > 0 ? 4 : 0) |
((rep & 64) > 0 ? 2 : 0) | color);
rawData.Add(rle);
}
for (int i = 0; i < imageLength; i++)
{
byte thisColor = spanMat[i] <= 127 ? (byte)0 : (byte)1; // Sanitize no AA
if (thisColor != color)
{
AddRep();
color = thisColor; // Sanitize no AA
rep = 1;
}
else
{
rep++;
if (rep == RLEEncodingLimit)
{
AddRep();
rep = 0;
}
}
}
AddRep();
if (totalPixels != imageLength)
{
throw new FileLoadException($"Error image ran shortly or off the end, expecting {imageLength} pixels, got {totalPixels} pixels.");
}
EncodedRle = rawData.ToArray();
RleDataSize = (uint) EncodedRle.Length;
return EncodedRle;
}
public unsafe Mat Decode(bool consumeRle = true)
{
var mat = EmguExtensions.InitMat(new Size((int) ResolutionX, (int) ResolutionY));
var matSpan = mat.GetBytePointer();
var imageLength = mat.GetLength();
uint pixel = 0;
foreach (var run in EncodedRle)
{
byte brightness = (byte) ((run & 0x01) * 255);
uint numPixelsInRun =
(uint) ((((run & 128) > 0 ? 1 : 0) |
((run & 64) > 0 ? 2 : 0) |
((run & 32) > 0 ? 4 : 0) |
((run & 16) > 0 ? 8 : 0) |
((run & 8) > 0 ? 16 : 0) |
((run & 4) > 0 ? 32 : 0) |
((run & 2) > 0 ? 64 : 0)) + 1);
if (brightness == 0) // Don't fill black pixels
{
pixel += numPixelsInRun;
continue;
}
for (; numPixelsInRun > 0; numPixelsInRun--)
{
if (pixel > imageLength)
{
mat.Dispose();
throw new FileLoadException($"Error image ran off the end, expecting {imageLength} pixels.");
}
matSpan[pixel++] = brightness;
}
}
if (pixel != imageLength && pixel-1 != imageLength)
{
mat.Dispose();
throw new FileLoadException($"Error image ran shortly or off the end, expecting {imageLength} pixels, got {pixel} pixels.");
}
// Not required as mat is all black by default
//for (;pixel < imageLength; pixel++) matSpan[pixel] = 0;
if (consumeRle)
EncodedRle = null;
return mat;
}
}
#endregion
#endregion
#region Properties
public Header HeaderSettings { get; protected internal set; } = new();
public LayerHeader LayerSettings { get; protected internal set; } = new();
public override FileFormatType FileType => FileFormatType.Binary;
public override FileExtension[] FileExtensions { get; } = {
new("photons", "Chitubox PhotonS"),
};
public override PrintParameterModifier[] PrintParameterModifiers { get; } =
{
PrintParameterModifier.BottomLayerCount,
PrintParameterModifier.BottomExposureSeconds,
PrintParameterModifier.ExposureSeconds,
//PrintParameterModifier.BottomLightOffDelay,
PrintParameterModifier.LightOffDelay,
//PrintParameterModifier.BottomLiftHeight,
//PrintParameterModifier.BottomLiftSpeed,
PrintParameterModifier.LiftHeight,
PrintParameterModifier.LiftSpeed,
PrintParameterModifier.RetractSpeed,
};
public override Size[] ThumbnailsOriginalSize { get; } = {new(224, 168) };
public override uint ResolutionX
{
get => Header.ResolutionX;
set { }
}
public override uint ResolutionY
{
get => Header.ResolutionY;
set { }
}
public override float DisplayWidth
{
get => Header.DisplayWidth;
set { }
}
public override float DisplayHeight
{
get => Header.DisplayHeight;
set { }
}
public override bool MirrorDisplay
{
get => true;
set { }
}
public override byte AntiAliasing
{
get => 1;
set { }
}
public override float LayerHeight
{
get => (float) Layer.RoundHeight(HeaderSettings.LayerHeight);
set
{
HeaderSettings.LayerHeight = Layer.RoundHeight(value);
RaisePropertyChanged();
}
}
public override float MachineZ
{
get => Header.BuildZ;
set { }
}
public override uint LayerCount
{
get => base.LayerCount;
set => base.LayerCount = LayerSettings.LayerCount = LayerCount;
}
public override ushort BottomLayerCount
{
get => (ushort) HeaderSettings.BottomLayerCount;
set => base.BottomLayerCount = (ushort) (HeaderSettings.BottomLayerCount = value);
}
public override float BottomExposureTime
{
get => (float) HeaderSettings.BottomExposureSeconds;
set => base.BottomExposureTime = (float) (HeaderSettings.BottomExposureSeconds = value);
}
public override float ExposureTime
{
get => (float) HeaderSettings.ExposureSeconds;
set => base.ExposureTime = (float) (HeaderSettings.ExposureSeconds = Math.Round(value, 2));
}
public override float BottomLiftHeight => LiftHeight;
public override float LiftHeight
{
get => (float) HeaderSettings.LiftHeight;
set => base.LiftHeight = (float) (HeaderSettings.LiftHeight = Math.Round(value, 2));
}
public override float BottomLiftSpeed => LiftSpeed;
public override float LiftSpeed
{
get => (float) Math.Round(HeaderSettings.LiftSpeed * 60.0, 2);
set => base.LiftSpeed = (float) (HeaderSettings.LiftSpeed = Math.Round(value / 60.0, 2));
}
public override float RetractSpeed
{
get => (float)Math.Round(HeaderSettings.RetractSpeed * 60.0, 2);
set => base.RetractSpeed = (float) (HeaderSettings.RetractSpeed = (float) Math.Round(value / 60.0, 2));
}
public override float BottomLightOffDelay => LightOffDelay;
public override float LightOffDelay
{
get => (float)HeaderSettings.LightOffDelay;
set => base.LightOffDelay = (float)(HeaderSettings.LightOffDelay = Math.Round(value, 2));
}
public override float MaterialMilliliters
{
get => base.MaterialMilliliters;
set
{
base.MaterialMilliliters = value;
HeaderSettings.VolumeMl = base.MaterialMilliliters;
}
}
public override string MachineName => "Anycubic Photon S";
public override object[] Configs => new object[] { HeaderSettings };
#endregion
#region Constructors
public PhotonSFile()
{
}
#endregion
#region Methods
public unsafe byte[] PreviewEncode(Mat mat)
{
byte[] bytes = new byte[mat.Width * mat.Height * 2];
var span = mat.GetBytePointer();
var imageLength = mat.GetLength();
int index = 0;
for (int i = 0; i < imageLength; i+=3)
{
byte r = span[i + 2]; // 60
byte g = span[i + 1];
byte b = span[i];
ushort color = (ushort)(((b & 0xF8) << 8) | ((g & 0xFC) << 3) | (r >> 3));
bytes[index++] = (byte)color;
bytes[index++] = (byte)(color >> 8);
}
if (index != bytes.Length)
{
throw new FileLoadException($"Preview encode incomplete encode, expected: {bytes.Length}, encoded: {index}");
}
return bytes;
}
public unsafe Mat PreviewDecode(byte[] data)
{
Mat mat = new((int)HeaderSettings.PreviewResolutionY, (int)HeaderSettings.PreviewResolutionX, DepthType.Cv8U, 3);
var span = mat.GetBytePointer();
int spanIndex = 0;
for (int i = 0; i < data.Length; i += 2)
{
ushort color16 = BitExtensions.ToUShortLittleEndian(data[i], data[i + 1]);
//var r = (byte)((color16 & 0x1F) << 3);
//var g = (byte)(((color16 >> 5) & 0x3F) << 2);
//var b = (byte)(((color16 >> 11) & 0x1f) << 3);
var r = (byte)((color16 << 3) & 0xF8); // Mask: 11111000
var g = (byte)((color16 >> 3) & 0xFC); // Mask: 11111100
var b = (byte)((color16 >> 8) & 0xF8); // Mask: 11111000
span[spanIndex++] = b;
span[spanIndex++] = g;
span[spanIndex++] = r;
}
return mat;
}
protected override void EncodeInternally(string fileFullPath, OperationProgress progress)
{
//throw new NotSupportedException("PhotonS is read-only format, please use pws instead!");
//uint currentOffset = (uint)Helpers.Serializer.SizeOf(HeaderSettings);
using var outputFile = new FileStream(fileFullPath, FileMode.Create, FileAccess.Write);
outputFile.WriteSerialize(HeaderSettings);
outputFile.WriteBytes(PreviewEncode(Thumbnails[0]));
outputFile.WriteSerialize(LayerSettings);
var layerData = new LayerData[LayerCount];
Parallel.For(0, LayerCount, layerIndex =>
{
if (progress.Token.IsCancellationRequested) return;
using (var mat = this[layerIndex].LayerMat)
{
layerData[layerIndex] = new LayerData();
layerData[layerIndex].Encode(mat);
}
progress.LockAndIncrement();
});
progress.ItemName = "Saving layers";
progress.ProcessedItems = 0;
for (uint layerIndex = 0; layerIndex < LayerCount; layerIndex++)
{
progress.Token.ThrowIfCancellationRequested();
outputFile.WriteSerialize(layerData[layerIndex]);
outputFile.WriteBytes(layerData[layerIndex].EncodedRle);
progress++;
}
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);
HeaderSettings = Helpers.Deserialize<Header>(inputFile);
if (HeaderSettings.Tag1 != Header.TAG1 || HeaderSettings.Tag2 != Header.TAG2)
{
throw new FileLoadException("Not a valid PHOTONS file! TAGs doesn't match", fileFullPath);
}
int previewSize = (int) (HeaderSettings.PreviewResolutionX * HeaderSettings.PreviewResolutionY * 2);
byte[] previewData = new byte[previewSize];
uint currentOffset = (uint) Helpers.Serializer.SizeOf(HeaderSettings);
currentOffset += inputFile.ReadBytes(previewData);
Thumbnails[0] = PreviewDecode(previewData);
LayerSettings = Helpers.Deserialize<LayerHeader>(inputFile);
currentOffset += (uint)Helpers.Serializer.SizeOf(LayerSettings);
Debug.WriteLine(HeaderSettings);
Debug.WriteLine(LayerSettings);
var layerData = new LayerData[LayerSettings.LayerCount];
progress.Reset(OperationProgress.StatusGatherLayers, LayerSettings.LayerCount);
for (int layerIndex = 0; layerIndex < LayerSettings.LayerCount; layerIndex++)
{
progress.Token.ThrowIfCancellationRequested();
layerData[layerIndex] = Helpers.Deserialize<LayerData>(inputFile);
layerData[layerIndex].EncodedRle = new byte[layerData[layerIndex].RleDataSize];
currentOffset += inputFile.ReadBytes(layerData[layerIndex].EncodedRle);
Debug.WriteLine($"Layer {layerIndex} -> {layerData[layerIndex]}");
}
LayerManager.Init(LayerSettings.LayerCount);
progress.Reset(OperationProgress.StatusDecodeLayers, LayerCount);
Parallel.For(0, LayerCount,
//new ParallelOptions{MaxDegreeOfParallelism = 1},
layerIndex =>
{
if (progress.Token.IsCancellationRequested) return;
using var image = layerData[layerIndex].Decode();
this[layerIndex] = new Layer((uint) layerIndex, image, this);
progress.LockAndIncrement();
});
LayerManager.RebuildLayersProperties();
}
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;
}
using var outputFile = new FileStream(FileFullPath, FileMode.Open, FileAccess.Write);
outputFile.Seek(0, SeekOrigin.Begin);
Helpers.SerializeWriteFileStream(outputFile, HeaderSettings);
}
#endregion
}
}
Reference in New Issue View Git Blame Copy Permalink