1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
|
/*
* 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.
*/
// https://github.com/cbiffle/catibo/blob/master/doc/cbddlp-ctb.adoc
using System;
using System.Diagnostics;
using System.Drawing;
using System.IO;
using BinarySerialization;
using UVtools.Core.Operations;
namespace UVtools.Core.FileFormats
{
public class MakerbaseFile : FileFormat
{
#region Constants
private const uint MAGIC_CBDDLP = 0x12FD0019;
private const uint MAGIC_CBT = 0x12FD0086;
private const ushort REPEATRGB15MASK = 0x20;
private const byte RLE8EncodingLimit = 0x7d; // 125;
private const ushort RLE16EncodingLimit = 0xFFF;
#endregion
#region Sub Classes
#region Header
public class Header
{
public const string TagValue = "MKSDLP";
//[FieldOrder(0)] public uint Offset1 { get; set; }
/// <summary>
/// Gets the file tag = MKSDLP
/// </summary>
[FieldOrder(0)] [FieldOffset(4)] [FieldLength(6)] public string Tag { get; set; } = TagValue;
[FieldOrder(1)] [FieldOffset(1)] public ushort MaxSize { get; set; }
[FieldOrder(2)] public ushort ResolutionX { get; set; }
[FieldOrder(3)] public ushort ResolutionY { get; set; }
}
#endregion
#endregion
#region Properties
public Header HeaderSettings { get; protected internal set; } = new Header();
private int temp = 0;
public override FileFormatType FileType => FileFormatType.Binary;
public override FileExtension[] FileExtensions { get; } = {
new FileExtension("mdlp", "Makerbase MDLP Files"),
new FileExtension("gr1", "GR1 Workshop GR1 Files"),
};
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,
PrintParameterModifier.BottomLightPWM,
PrintParameterModifier.LightPWM,
};
public override byte ThumbnailsCount { get; } = 0;
public override Size[] ThumbnailsOriginalSize { get; } = {new Size(400, 300), new Size(200, 125)};
public override uint ResolutionX
{
get => 0;
set => temp = 0;
}
public override uint ResolutionY
{
get => 0;
set => temp = 0;
}
public override float DisplayWidth { get; set; }
public override float DisplayHeight { get; set; }
public override bool MirrorDisplay { get; set; }
public override byte AntiAliasing
{
get => 1;
set { }
}
public override float LayerHeight
{
get => 0;
set => temp = 0;
}
public override uint LayerCount
{
set
{
temp = 0;
/*HeaderSettings.LayerCount = LayerCount;
HeaderSettings.OverallHeightMilimeter = TotalHeight;*/
}
}
public override ushort BottomLayerCount => 0;
public override float BottomExposureTime => 0;
public override float ExposureTime => 0;
public override float LiftHeight => 0;
public override float LiftSpeed => 0;
public override float RetractSpeed => 0;
public override float PrintTime => 0;
public override float MaterialMilliliters => 0;
public override float MaterialCost => 0;
public override string MaterialName => "Unknown";
public override string MachineName => null;
public override object[] Configs => new[] { (object)HeaderSettings };
#endregion
#region Constructors
public MakerbaseFile()
{
}
#endregion
#region Methods
protected override void EncodeInternally(string fileFullPath, OperationProgress progress)
{
uint currentOffset = (uint)Helpers.Serializer.SizeOf(HeaderSettings);
using (var outputFile = new FileStream(fileFullPath, FileMode.Create, FileAccess.Write))
{
outputFile.Seek((int) currentOffset, SeekOrigin.Begin);
}
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.ByteToType<CbddlpFile.Header>(InputFile);
//HeaderSettings = Helpers.Serializer.Deserialize<Header>(InputFile.ReadBytes(Helpers.Serializer.SizeOf(typeof(Header))));
HeaderSettings = Helpers.Deserialize<Header>(inputFile);
if (HeaderSettings.Tag != Header.TagValue)
{
throw new FileLoadException("Not a valid Makerfile file!", fileFullPath);
}
}
}
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);
if (HeaderSettings.Version >= 2 && HeaderSettings.PrintParametersOffsetAddress > 0)
{
outputFile.Seek(HeaderSettings.PrintParametersOffsetAddress, SeekOrigin.Begin);
Helpers.SerializeWriteFileStream(outputFile, PrintParametersSettings);
Helpers.SerializeWriteFileStream(outputFile, SlicerInfoSettings);
}
uint layerOffset = HeaderSettings.LayersDefinitionOffsetAddress;
for (byte aaIndex = 0; aaIndex < HeaderSettings.AntiAliasLevel; aaIndex++)
{
for (uint layerIndex = 0; layerIndex < HeaderSettings.LayerCount; layerIndex++)
{
outputFile.Seek(layerOffset, SeekOrigin.Begin);
layerOffset += Helpers.SerializeWriteFileStream(outputFile, LayersDefinitions[aaIndex, layerIndex]);
}
}
}*/
//Decode(FileFullPath, progress);
}
#endregion
}
}
|