1use std::fmt::{self, Debug};
2
3use anyhow::{ensure, Result};
4
5use crate::{
6 preview_image::PreviewImage,
7 serde::{Deserializer, Serializer, SizedString},
8 DELIMITER, MAGIC_TAG,
9};
10
11pub struct HeaderInfo {
15 pub version: SizedString<4>,
16 pub software_info: SizedString<32>,
17 pub software_version: SizedString<24>,
18 pub file_time: SizedString<24>,
19 pub printer_name: SizedString<32>,
20 pub printer_type: SizedString<32>,
21 pub profile_name: SizedString<32>,
22 pub anti_aliasing_level: u16,
23 pub grey_level: u16,
24 pub blur_level: u16,
25 pub small_preview: PreviewImage<116, 116>,
26 pub big_preview: PreviewImage<290, 290>,
27 pub layer_count: u32,
28 pub x_resolution: u16,
29 pub y_resolution: u16,
30 pub x_mirror: bool,
31 pub y_mirror: bool,
32 pub x_size: f32,
33 pub y_size: f32,
34 pub z_size: f32,
35 pub layer_thickness: f32,
36 pub exposure_time: f32,
37 pub exposure_delay_mode: bool,
38 pub turn_off_time: f32,
39 pub bottom_before_lift_time: f32,
40 pub bottom_after_lift_time: f32,
41 pub bottom_after_retract_time: f32,
42 pub before_lift_time: f32,
43 pub after_lift_time: f32,
44 pub after_retract_time: f32,
45 pub bottom_exposure_time: f32,
46 pub bottom_layers: u32,
47 pub bottom_lift_distance: f32,
48 pub bottom_lift_speed: f32,
49 pub lift_distance: f32,
50 pub lift_speed: f32,
51 pub bottom_retract_distance: f32,
52 pub bottom_retract_speed: f32,
53 pub retract_distance: f32,
54 pub retract_speed: f32,
55 pub bottom_second_lift_distance: f32,
56 pub bottom_second_lift_speed: f32,
57 pub second_lift_distance: f32,
58 pub second_lift_speed: f32,
59 pub bottom_second_retract_distance: f32,
60 pub bottom_second_retract_speed: f32,
61 pub second_retract_distance: f32,
62 pub second_retract_speed: f32,
63 pub bottom_light_pwm: u16,
64 pub light_pwm: u16,
65 pub advance_mode: bool,
66 pub printing_time: u32,
67 pub total_volume: f32,
68 pub total_weight: f32,
69 pub total_price: f32,
70 pub price_unit: SizedString<8>,
71 pub grey_scale_level: bool,
72 pub transition_layers: u16,
73}
74
75impl HeaderInfo {
76 pub const SIZE: usize = 0x2FB95;
77}
78
79impl HeaderInfo {
81 pub fn serialize<T: Serializer>(&self, ser: &mut T) {
82 ser.write_sized_string(&self.version);
83 ser.write_bytes(MAGIC_TAG);
84 ser.write_sized_string(&self.software_info);
85 ser.write_sized_string(&self.software_version);
86 ser.write_sized_string(&self.file_time);
87 ser.write_sized_string(&self.printer_name);
88 ser.write_sized_string(&self.printer_type);
89 ser.write_sized_string(&self.profile_name);
90 ser.write_u16(self.anti_aliasing_level);
91 ser.write_u16(self.grey_level);
92 ser.write_u16(self.blur_level);
93 self.small_preview.serializes(ser);
94 ser.write_bytes(DELIMITER);
95 self.big_preview.serializes(ser);
96 ser.write_bytes(DELIMITER);
97 ser.write_u32(self.layer_count);
98 ser.write_u16(self.x_resolution);
99 ser.write_u16(self.y_resolution);
100 ser.write_bool(self.x_mirror);
101 ser.write_bool(self.y_mirror);
102 ser.write_f32(self.x_size);
103 ser.write_f32(self.y_size);
104 ser.write_f32(self.z_size);
105 ser.write_f32(self.layer_thickness);
106 ser.write_f32(self.exposure_time);
107 ser.write_bool(self.exposure_delay_mode);
108 ser.write_f32(self.turn_off_time);
109 ser.write_f32(self.bottom_before_lift_time);
110 ser.write_f32(self.bottom_after_lift_time);
111 ser.write_f32(self.bottom_after_retract_time);
112 ser.write_f32(self.before_lift_time);
113 ser.write_f32(self.after_lift_time);
114 ser.write_f32(self.after_retract_time);
115 ser.write_f32(self.bottom_exposure_time);
116 ser.write_u32(self.bottom_layers);
117 ser.write_f32(self.bottom_lift_distance);
118 ser.write_f32(self.bottom_lift_speed);
119 ser.write_f32(self.lift_distance);
120 ser.write_f32(self.lift_speed);
121 ser.write_f32(self.bottom_retract_distance);
122 ser.write_f32(self.bottom_retract_speed);
123 ser.write_f32(self.retract_distance);
124 ser.write_f32(self.retract_speed);
125 ser.write_f32(self.bottom_second_lift_distance);
126 ser.write_f32(self.bottom_second_lift_speed);
127 ser.write_f32(self.second_lift_distance);
128 ser.write_f32(self.second_lift_speed);
129 ser.write_f32(self.bottom_second_retract_distance);
130 ser.write_f32(self.bottom_second_retract_speed);
131 ser.write_f32(self.second_retract_distance);
132 ser.write_f32(self.second_retract_speed);
133 ser.write_u16(self.bottom_light_pwm);
134 ser.write_u16(self.light_pwm);
135 ser.write_bool(self.advance_mode);
136 ser.write_u32(self.printing_time);
137 ser.write_f32(self.total_volume);
138 ser.write_f32(self.total_weight);
139 ser.write_f32(self.total_price);
140 ser.write_sized_string(&self.price_unit);
141 ser.write_u32(Self::SIZE as u32);
142 ser.write_bool(self.grey_scale_level);
143 ser.write_u16(self.transition_layers);
144 }
145
146 pub fn deserialize(des: &mut Deserializer) -> Result<Self> {
147 let version = des.read_sized_string();
148 ensure!(des.read_bytes(8) == [0x07, 0x00, 0x00, 0x00, 0x44, 0x4C, 0x50, 0x00]);
149 let software_info = des.read_sized_string();
150 let software_version = des.read_sized_string();
151 let file_time = des.read_sized_string();
152 let printer_name = des.read_sized_string();
153 let printer_type = des.read_sized_string();
154 let profile_name = des.read_sized_string();
155 let anti_aliasing_level = des.read_u16();
156 let grey_level = des.read_u16();
157 let blur_level = des.read_u16();
158 let small_preview = PreviewImage::deserializes(des);
159 ensure!(des.read_bytes(2) == [0xd, 0xa]);
160 let big_preview = PreviewImage::deserializes(des);
161 ensure!(des.read_bytes(2) == [0xd, 0xa]);
162 let layer_count = des.read_u32();
163 let x_resolution = des.read_u16();
164 let y_resolution = des.read_u16();
165 let x_mirror = des.read_bool();
166 let y_mirror = des.read_bool();
167 let x_size = des.read_f32();
168 let y_size = des.read_f32();
169 let z_size = des.read_f32();
170 let layer_thickness = des.read_f32();
171 let exposure_time = des.read_f32();
172 let exposure_delay_mode = des.read_bool();
173 let turn_off_time = des.read_f32();
174 let bottom_before_lift_time = des.read_f32();
175 let bottom_after_lift_time = des.read_f32();
176 let bottom_after_retract_time = des.read_f32();
177 let before_lift_time = des.read_f32();
178 let after_lift_time = des.read_f32();
179 let after_retract_time = des.read_f32();
180 let bottom_exposure_time = des.read_f32();
181 let bottom_layers = des.read_u32();
182 let bottom_lift_distance = des.read_f32();
183 let bottom_lift_speed = des.read_f32();
184 let lift_distance = des.read_f32();
185 let lift_speed = des.read_f32();
186 let bottom_retract_distance = des.read_f32();
187 let bottom_retract_speed = des.read_f32();
188 let retract_distance = des.read_f32();
189 let retract_speed = des.read_f32();
190 let bottom_second_lift_distance = des.read_f32();
191 let bottom_second_lift_speed = des.read_f32();
192 let second_lift_distance = des.read_f32();
193 let second_lift_speed = des.read_f32();
194 let bottom_second_retract_distance = des.read_f32();
195 let bottom_second_retract_speed = des.read_f32();
196 let second_retract_distance = des.read_f32();
197 let second_retract_speed = des.read_f32();
198 let bottom_light_pwm = des.read_u16();
199 let light_pwm = des.read_u16();
200 let advance_mode = des.read_bool();
201 let printing_time = des.read_u32();
202 let total_volume = des.read_f32();
203 let total_weight = des.read_f32();
204 let total_price = des.read_f32();
205 let price_unit = des.read_sized_string();
206 ensure!(des.read_u32() == Self::SIZE as u32);
207 let grey_scale_level = des.read_bool();
208 let transition_layers = des.read_u16();
209
210 Ok(Self {
211 version,
212 software_info,
213 software_version,
214 file_time,
215 printer_name,
216 printer_type,
217 profile_name,
218 anti_aliasing_level,
219 grey_level,
220 blur_level,
221 small_preview,
222 big_preview,
223 layer_count,
224 x_resolution,
225 y_resolution,
226 x_mirror,
227 y_mirror,
228 x_size,
229 y_size,
230 z_size,
231 layer_thickness,
232 exposure_time,
233 exposure_delay_mode,
234 turn_off_time,
235 bottom_before_lift_time,
236 bottom_after_lift_time,
237 bottom_after_retract_time,
238 before_lift_time,
239 after_lift_time,
240 after_retract_time,
241 bottom_exposure_time,
242 bottom_layers,
243 bottom_lift_distance,
244 bottom_lift_speed,
245 lift_distance,
246 lift_speed,
247 bottom_retract_distance,
248 bottom_retract_speed,
249 retract_distance,
250 retract_speed,
251 bottom_second_lift_distance,
252 bottom_second_lift_speed,
253 second_lift_distance,
254 second_lift_speed,
255 bottom_second_retract_distance,
256 bottom_second_retract_speed,
257 second_retract_distance,
258 second_retract_speed,
259 bottom_light_pwm,
260 light_pwm,
261 advance_mode,
262 printing_time,
263 total_volume,
264 total_weight,
265 total_price,
266 price_unit,
267 grey_scale_level,
268 transition_layers,
269 })
270 }
271}
272
273impl Debug for HeaderInfo {
274 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
275 f.debug_struct("HeaderInfo")
276 .field("version", &self.version)
277 .field("software_info", &self.software_info)
278 .field("software_version", &self.software_version)
279 .field("file_time", &self.file_time)
280 .field("printer_name", &self.printer_name)
281 .field("printer_type", &self.printer_type)
282 .field("profile_name", &self.profile_name)
283 .field("anti_aliasing_level", &self.anti_aliasing_level)
284 .field("grey_level", &self.grey_level)
285 .field("blur_level", &self.blur_level)
286 .field("layer_count", &self.layer_count)
287 .field("x_resolution", &self.x_resolution)
288 .field("y_resolution", &self.y_resolution)
289 .field("x_mirror", &self.x_mirror)
290 .field("y_mirror", &self.y_mirror)
291 .field("x_size", &self.x_size)
292 .field("y_size", &self.y_size)
293 .field("z_size", &self.z_size)
294 .field("layer_thickness", &self.layer_thickness)
295 .field("exposure_time", &self.exposure_time)
296 .field("exposure_delay_mode", &self.exposure_delay_mode)
297 .field("turn_off_time", &self.turn_off_time)
298 .field("bottom_before_lift_time", &self.bottom_before_lift_time)
299 .field("bottom_after_lift_time", &self.bottom_after_lift_time)
300 .field("bottom_after_retract_time", &self.bottom_after_retract_time)
301 .field("before_lift_time", &self.before_lift_time)
302 .field("after_lift_time", &self.after_lift_time)
303 .field("after_retract_time", &self.after_retract_time)
304 .field("bottom_exposure_time", &self.bottom_exposure_time)
305 .field("bottom_layers", &self.bottom_layers)
306 .field("bottom_lift_distance", &self.bottom_lift_distance)
307 .field("bottom_lift_speed", &self.bottom_lift_speed)
308 .field("lift_distance", &self.lift_distance)
309 .field("lift_speed", &self.lift_speed)
310 .field("bottom_retract_distance", &self.bottom_retract_distance)
311 .field("bottom_retract_speed", &self.bottom_retract_speed)
312 .field("retract_distance", &self.retract_distance)
313 .field("retract_speed", &self.retract_speed)
314 .field(
315 "bottom_second_lift_distance",
316 &self.bottom_second_lift_distance,
317 )
318 .field("bottom_second_lift_speed", &self.bottom_second_lift_speed)
319 .field("second_lift_distance", &self.second_lift_distance)
320 .field("second_lift_speed", &self.second_lift_speed)
321 .field(
322 "bottom_second_retract_distance",
323 &self.bottom_second_retract_distance,
324 )
325 .field(
326 "bottom_second_retract_speed",
327 &self.bottom_second_retract_speed,
328 )
329 .field("second_retract_distance", &self.second_retract_distance)
330 .field("second_retract_speed", &self.second_retract_speed)
331 .field("bottom_light_pwm", &self.bottom_light_pwm)
332 .field("light_pwm", &self.light_pwm)
333 .field("advance_mode", &self.advance_mode)
334 .field("printing_time", &self.printing_time)
335 .field("total_volume", &self.total_volume)
336 .field("total_weight", &self.total_weight)
337 .field("total_price", &self.total_price)
338 .field("price_unit", &self.price_unit)
339 .field("grey_scale_level", &self.grey_scale_level)
340 .field("transition_layers", &self.transition_layers)
341 .finish()
342 }
343}