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
|
/*
* 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.ComponentModel;
using System.Text;
using UVtools.Core.FileFormats;
namespace UVtools.Core.Operations
{
[Serializable]
public class OperationFadeExposureTime : Operation
{
#region Members
private uint _layerCount = 10;
private decimal _fromExposureTime;
private decimal _toExposureTime;
#endregion
#region Overrides
public override bool CanRunInPartialMode => true;
public override Enumerations.LayerRangeSelection StartLayerRangeSelection => Enumerations.LayerRangeSelection.Normal;
public override bool LayerIndexEndEnabled => false;
public override string Title => "Fade exposure time";
public override string Description =>
"Fade the exposure time in increments from a start to a end value on the selected layer range.";
public override string ConfirmationText =>
$"fade exposure time model layers {LayerIndexStart} through {LayerIndexEnd} with increments of {IncrementValue}s";
public override string ProgressTitle =>
$"Fading exposure time from layers {LayerIndexStart} to {LayerIndexEnd} with increments of {IncrementValue}s";
public override string ProgressAction => "Faded layers";
public override string ValidateSpawn()
{
if (!SlicerFile.CanUseLayerExposureTime)
{
return NotSupportedMessage;
}
return null;
}
public override string ValidateInternally()
{
var sb = new StringBuilder();
if (_layerCount == 0) sb.AppendLine("The layer count must be higher than 0.");
if(_fromExposureTime == _toExposureTime) sb.AppendLine("The starting exposure time can't be the same as the ending exposure time.");
return sb.ToString();
}
public override string ToString()
{
var result = $"[Layers: {LayerRangeCount} From: {_fromExposureTime}s To: {_toExposureTime}s @ {IncrementValue}s] " + LayerRangeString;
if (!string.IsNullOrEmpty(ProfileName)) result = $"{ProfileName}: {result}";
return result;
}
protected override void OnPropertyChanged(PropertyChangedEventArgs e)
{
if (e.PropertyName == nameof(LayerIndexStart))
{
LayerCount = _layerCount; // Sanitize
LayerIndexEnd = LayerIndexStart + _layerCount - 1 ; // Sync
RaisePropertyChanged(nameof(MaximumLayerCount));
RaisePropertyChanged(nameof(IncrementValue));
}
/*else if (e.PropertyName == nameof(LayerIndexEnd))
{
LayerCount = LayerRangeCount;
RaisePropertyChanged(nameof(IncrementValue));
}*/
base.OnPropertyChanged(e);
}
#endregion
#region Properties
public uint LayerCount
{
get => _layerCount;
set
{
if (!RaiseAndSetIfChanged(ref _layerCount, Math.Min(value, SlicerFile.LayerCount - LayerIndexStart))) return;
LayerIndexEnd = LayerIndexStart + _layerCount - 1;
RaisePropertyChanged(nameof(MaximumLayerCount));
RaisePropertyChanged(nameof(IncrementValue));
}
}
public uint MaximumLayerCount => Math.Max(LayerCount, SlicerFile.LayerCount - LayerIndexStart);
public decimal FromExposureTime
{
get => _fromExposureTime;
set
{
if(!RaiseAndSetIfChanged(ref _fromExposureTime, Math.Round(value, 2))) return;
RaisePropertyChanged(nameof(IncrementValue));
}
}
public decimal ToExposureTime
{
get => _toExposureTime;
set
{
if(!RaiseAndSetIfChanged(ref _toExposureTime, Math.Round(value, 2))) return;
RaisePropertyChanged(nameof(IncrementValue));
}
}
public decimal IncrementValue => Math.Round(IncrementValueRaw, 2);
public decimal IncrementValueRaw => (_toExposureTime - _fromExposureTime) / (LayerRangeCount + 1);
#endregion
#region Constructor
public OperationFadeExposureTime() { }
public OperationFadeExposureTime(FileFormat slicerFile) : base(slicerFile) { }
public override void InitWithSlicerFile()
{
base.InitWithSlicerFile();
if (_fromExposureTime <= 0) _fromExposureTime = (decimal)SlicerFile.BottomExposureTime;
if (_toExposureTime <= 0) _toExposureTime = (decimal)SlicerFile.ExposureTime;
LayerIndexEnd = LayerIndexStart + _layerCount - 1; // Sync
}
#endregion
#region Equality
protected bool Equals(OperationFadeExposureTime other)
{
return _fromExposureTime == other._fromExposureTime && _toExposureTime == other._toExposureTime && _layerCount == other._layerCount;
}
public override bool Equals(object obj)
{
if (ReferenceEquals(null, obj)) return false;
if (ReferenceEquals(this, obj)) return true;
if (obj.GetType() != this.GetType()) return false;
return Equals((OperationFadeExposureTime)obj);
}
public override int GetHashCode()
{
return HashCode.Combine(_fromExposureTime, _toExposureTime, _layerCount);
}
#endregion
#region Methods
protected override bool ExecuteInternally(OperationProgress progress)
{
LayerIndexEnd = LayerIndexStart + _layerCount - 1; // Sanitize
var increment = IncrementValueRaw;
var exposure = _fromExposureTime;
for (uint layerIndex = LayerIndexStart; layerIndex <= LayerIndexEnd; layerIndex++)
{
progress.Token.ThrowIfCancellationRequested();
exposure += increment;
SlicerFile[layerIndex].ExposureTime = (float)exposure;
}
return !progress.Token.IsCancellationRequested;
}
#endregion
}
}
|
