private static void Finish(Lut values, string data, int index, int line, ref double key, ref int started, ref int malformed) {
if (started != -1) {
if (double.IsNaN(key)) {
if (malformed == -1) malformed = line;
} else {
double value;
if (FlexibleParser.TryParseDouble(data.Substring(started, index - started), out value)) {
values.Add(new LutPoint(key, value));
} else {
if (malformed == -1) malformed = line;
}
key = double.NaN;
}
started = -1;
} else if (!double.IsNaN(key)) {
key = double.NaN;
}
}
/// <inheritdoc />
public override void GenerateLut()
{
if (Lut == null || Lut.width != (int)Size.x || Lut.height != (int)Size.y)
{
DestroyLut();
Lut = Helper.CreateTempTeture2D((int)Size.x, (int)Size.y, TextureFormat.ARGB32, false, false, false);
}
for (var y = 0; y < Lut.height; y++)
{
var t = y / (float)Lut.height;
var a = BrighnessGradient.Evaluate(ReverseX ? (1.0f - t) : t);
var b = Gradient.Evaluate(ReverseX ? (1.0f - t) : t);
var c = a * b;
c.a = c.grayscale;
Lut.SetPixel(0, y, c);
}
// Make sure the last pixel is white
Lut.SetPixel(0, Lut.height - 1, Color.white);
Lut.wrapMode = TextureWrapMode.Clamp;
Lut.Apply();
}
public void OptimizeTest()
{
var val = "(|0=0.7|2000=0.8|4000=0.9|5000=0.6|)";
var lut = Lut.FromValue(val);
Assert.AreEqual("(|0=0.7|4000=0.9|5000=0.6|)", lut.Optimize().ToString());
}
private static void Finish(Lut values, string data, int index, int line, ref double key, ref int started, ref int malformed)
{
if (started != -1)
{
if (double.IsNaN(key))
{
if (malformed == -1)
{
AcToolsLogging.Write($@"Key is NaN at {line}");
malformed = line;
}
}
else
{
if (FlexibleParser.TryParseDouble(data.Substring(started, index - started), out var value))
{
values.Add(new LutPoint(key, value));
}
else
{
if (malformed == -1)
{
AcToolsLogging.Write($@"Failed to parse key “{data.Substring(started, index - started)}” at {line}");
malformed = line;
}
}
key = double.NaN;
}
started = -1;
}
else if (!double.IsNaN(key))
{
key = double.NaN;
}
}
public static Tuple <double, double> GetOptimalRange([CanBeNull] Lut lut)
{
if (lut == null)
{
return(null);
}
lut.UpdateBoundingBox();
var threshold = Math.Min(lut.MaxY, 1d) * (1d - OptionRangeThreshold);
double?fromX = null, toX = null;
lut.ForEach((x, y) => {
if (y >= threshold)
{
if (!fromX.HasValue)
{
fromX = x;
}
toX = x;
}
});
return(fromX.HasValue && toX.HasValue ? new Tuple <double, double>(fromX ?? 0d, toX ?? 0d) : null);
}
private static void Finish(Lut values, string data, int index, int line, ref double key, ref int started, ref int malformed)
{
if (started != -1)
{
if (double.IsNaN(key))
{
if (malformed == -1)
{
malformed = line;
}
}
else
{
double value;
if (FlexibleParser.TryParseDouble(data.Substring(started, index - started), out value))
{
values.Add(new LutPoint(key, value));
}
else
{
if (malformed == -1)
{
malformed = line;
}
}
key = double.NaN;
}
started = -1;
}
else if (!double.IsNaN(key))
{
key = double.NaN;
}
}
public void ToStringTest()
{
var val = "(|0=0.7|1000=0.8|4000=0.9|)";
var lut = Lut.FromValue(val);
Assert.AreEqual(val, lut.ToString());
}
public static Lut TorqueToPower(Lut torque, int detalization = 100) {
torque.UpdateBoundingBox();
var startFrom = torque.MinX;
var limit = torque.MaxX;
var result = new Lut();
var previousTorquePoint = 0;
var previousRpm = 0d;
for (var i = 0; i <= detalization; i++) {
var rpm = detalization == 0 ? limit : (limit - startFrom) * i / detalization + startFrom;
for (var j = previousTorquePoint; j < torque.Count; j++) {
var p = torque[j];
if (p.X > rpm) {
previousTorquePoint = j > 0 ? j - 1 : 0;
break;
}
if ((i == 0 || p.X > previousRpm) && p.X < rpm) {
result.Add(new LutPoint(p.X, TorqueToPower(p.Y, p.X)));
}
}
result.Add(new LutPoint(rpm, TorqueToPower(torque.InterpolateLinear(rpm), rpm)));
previousRpm = rpm;
}
return result.Optimize();
}
public void Set([NotNull, LocalizationRequired(false)] string key, [CanBeNull] Lut value)
{
if (value == null)
{
return;
}
base[key] = value.ToString();
}
public virtual Table CreateChild(Lut lut, Definition d)
{
XElement xml = new XElement("table");
xml.SetAttributeValue("name", name);
xml.SetAttributeValue("address", lut.dataAddress.ToString("X"));
return(TableFactory.CreateTable(xml, d));
//TODO also set attirbutes and split this up!
}
protected override Task <bool> FixAsync(CarObject car, IProgress <AsyncProgressEntry> progress = null,
CancellationToken cancellation = default(CancellationToken))
{
progress?.Report(AsyncProgressEntry.FromStringIndetermitate("Fixing car…"));
var data = car.AcdData;
if (data == null || data.IsEmpty)
{
return(Task.FromResult(false));
}
Lut torque, power;
try {
torque = TorquePhysicUtils.LoadCarTorque(data);
power = TorquePhysicUtils.TorqueToPower(torque);
} catch (Exception e) {
Logging.Error(e);
return(Task.FromResult(false));
}
var multipler = ActionExtension.InvokeInMainThread(() => {
var dlg = new CarTransmissionLossSelector(car, torque.MaxY, power.MaxY);
dlg.ShowDialog();
return(dlg.IsResultOk ? dlg.Multipler : (double?)null);
});
if (!multipler.HasValue)
{
return(Task.FromResult(false));
}
torque.TransformSelf(x => x.Y * multipler.Value);
power.TransformSelf(x => x.Y * multipler.Value);
if (car.SpecsTorqueCurve != null)
{
var torqueUi = new Lut(car.SpecsTorqueCurve.Points);
torqueUi.TransformSelf(x => x.Y * multipler.Value);
car.SpecsTorqueCurve = new GraphData(torqueUi);
}
if (car.SpecsPowerCurve != null)
{
var powerUi = new Lut(car.SpecsPowerCurve.Points);
powerUi.TransformSelf(x => x.Y * multipler.Value);
car.SpecsPowerCurve = new GraphData(powerUi);
}
car.SpecsTorque = SelectedAcObjectViewModel.SpecsFormat(AppStrings.CarSpecs_Torque_FormatTooltip,
torque.MaxY.ToString(@"F0", CultureInfo.InvariantCulture)) + (multipler.Value == 1d ? "*" : "");
car.SpecsBhp = SelectedAcObjectViewModel.SpecsFormat(multipler.Value == 1d ? AppStrings.CarSpecs_PowerAtWheels_FormatTooltip
: AppStrings.CarSpecs_Power_FormatTooltip, power.MaxY.ToString(@"F0", CultureInfo.InvariantCulture));
return(Task.FromResult(true));
}
private static string GetMissingLutName(DataWrapper data, IniFileSection section, string key)
{
var v = section.GetNonEmpty(key);
if (v == null)
{
return(null);
}
return(!Lut.IsInlineValue(v) && (!data.Contains(v) || data.GetLutFile(v).Values.Count == 0) ? v : null);
}
public void CubicInterpolationExtra()
{
var lut = new Lut {
new LutPoint(-0.009994, 1.059),
new LutPoint(-0.004998, 1.059),
new LutPoint(0, 1.060),
new LutPoint(0.005002, 1.063),
new LutPoint(0.010007, 1.065),
new LutPoint(0.015014, 1.068),
new LutPoint(0.020024, 1.073),
new LutPoint(0.025039, 1.078),
new LutPoint(0.030057, 1.083),
new LutPoint(0.03508, 1.089),
new LutPoint(0.040106, 1.095),
};
lut.UpdateBoundingBox();
var minX = lut.MinX;
var sizeX = lut.MaxX - lut.MinX;
var minY = lut.MinY;
var sizeY = lut.MaxY - lut.MinY;
lut = new Lut(lut.Select(x => new LutPoint((x.X - minX) / sizeX, (x.Y - minY) / sizeY)));
lut.UpdateBoundingBox();
BuildChart(s => {
var min = lut.MinX;
var size = lut.MaxX - lut.MinX;
for (var i = 0d; i <= 1d; i += 0.003)
{
var x = lut.MinX + size * i;
s.Points.Add(new DataPoint(x, lut.InterpolateLinear(x)));
}
s.Color = Color.Black;
}, s => {
var min = lut.MinX;
var size = lut.MaxX - lut.MinX;
for (var i = 0d; i <= 1d; i += 0.003)
{
var x = lut.MinX + size * i;
s.Points.Add(new DataPoint(x, lut.InterpolateCubic(x)));
}
s.Color = Color.Green;
});
// interpolation itself
#if !DEBUG
Assert.IsTrue(lut.InterpolateCubic(0.003) < lut.InterpolateCubic(0.001));
#endif
}
public void LutValueParse()
{
var lut = Lut.FromValue("(|0=0.7|1000=0.8|4000=0.9|)");
Assert.IsTrue(lut.SequenceEqual(Lut.FromValue("(0=0.7|1000=0.8|4000=0.9)")));
Assert.AreEqual(3, lut.Count);
Assert.AreEqual(2, Lut.FromValue("(0=0.7|=0.8|4000=0.9)").Count);
Assert.AreEqual(0.75, lut.InterpolateLinear(500d), 0.00001);
Assert.AreEqual(0.85, lut.InterpolateLinear(2500d), 0.00001);
Assert.AreEqual(0.9, lut.InterpolateLinear(4500d), 0.00001);
}
private static Lut ConvertToValues(JArray obj) {
var values = new Lut();
if (obj == null) return values;
foreach (var entry in obj.OfType<JArray>()) {
double x, y;
if (FlexibleParser.TryParseDouble(Convert.ToString(entry[0], CultureInfo.InvariantCulture), out x) &&
FlexibleParser.TryParseDouble(Convert.ToString(entry[1], CultureInfo.InvariantCulture), out y)) {
values.Add(new LutPoint(x, y));
}
}
return values;
}
/// <summary>
/// Applies LUT (look-up table) correction
/// </summary>
private static void ApplyLut()
{
using (var bitmap = new Bitmap("../../../../_Input/Chicago.jpg"))
using (var lut = new Lut())
{
lut.SetPoint(50, 70);
lut.SetPoint(100, 150);
lut.InterpolationMode = LutInterpolationMode.Cubic;
bitmap.ColorAdjustment.ApplyLut(lut);
bitmap.Save("../../../../_Output/ApplyLut.jpg");
}
}
/// <inheritdoc />
public override void CalculateLut()
{
for (ushort x = 0; x < Lut.width; x++)
{
for (ushort y = 0; y < Lut.height; y++)
{
var t = (x / Size.x) - (NonLinear ? (ReverseY ? (y / Size.y) : ((Size.y - y) / Size.y)) : 0.0f);
var gradientColor = Gradient.Evaluate(ReverseX ? (1.0f - t) : t);
Lut.SetPixel(x, y, gradientColor);
}
}
Lut.Apply();
}
/// <summary>
/// Applies LUT (look-up table) correction using memory-friendly Pipeline API
/// </summary>
private static void ApplyLutMemoryFriendly()
{
using (var reader = ImageReader.Create("../../../../_Input/Chicago.jpg"))
using (var lutTransform = new LutTransform())
using (var lut = new Lut())
using (var writer = ImageWriter.Create("../../../../_Output/ApplyLutMemoryFriendly.jpg"))
{
lut.SetPoint(50, 70);
lut.SetPoint(100, 150);
lut.InterpolationMode = LutInterpolationMode.Cubic;
lutTransform.Lut = lut;
Pipeline.Run(reader + lutTransform + writer);
}
}
public GraphData([NotNull] Lut points)
{
_points = points;
if (Points.Count == 0)
{
MinX = MaxX = MinY = MaxY = 0.0;
_normalizedValuesArray = new List <Point>();
return;
}
_points.UpdateBoundingBox();
MinX = _points.MinX;
MaxX = _points.MaxX;
MinY = _points.MinY;
MaxY = _points.MaxY;
}
public GraphData(Lut points) {
_points = points;
if (Points.Count == 0) {
MinX = MaxX = MinY = MaxY = 0.0;
_normalizedValuesArray = new List<Point>();
return;
}
_points.UpdateBoundingBox();
MinX = _points.MinX;
MaxX = _points.MaxX;
MinY = _points.MinY;
MaxY = _points.MaxY;
_normalizedValuesArray = Points.Select(x => new Point((x.X - MinX) / (MaxX - MinX), (x.Y - MinY) / (MaxY - MinY))).ToList();
}
public void CubicInterpolation() {
var lut = new Lut {
new LutPoint(1d, 1d),
new LutPoint(2d, 1d),
new LutPoint(4d, 5d),
new LutPoint(5d, 3d),
};
// points
Assert.AreEqual(1d, lut.InterpolateCubic(1d));
Assert.AreEqual(1d, lut.InterpolateCubic(2d));
Assert.AreEqual(3d, lut.InterpolateCubic(5d));
// clamping
Assert.AreEqual(1d, lut.InterpolateCubic(-1d));
Assert.AreEqual(3d, lut.InterpolateCubic(5.7d));
// interpolation itself
Assert.IsTrue(lut.InterpolateCubic(1.9d) < 1d);
}
private static Lut ConvertToValues(JArray obj)
{
var values = new Lut();
if (obj == null)
{
return(values);
}
foreach (var entry in obj.OfType <JArray>().Where(x => x.Count == 2))
{
if (FlexibleParser.TryParseDouble(Convert.ToString(entry[0], CultureInfo.InvariantCulture), out var x) &&
FlexibleParser.TryParseDouble(Convert.ToString(entry[1], CultureInfo.InvariantCulture), out var y))
{
values.Add(new LutPoint(x, y));
}
}
return(values);
}
public void CubicInterpolation()
{
var lut = new Lut {
new LutPoint(1d, 1d),
new LutPoint(2d, 1d),
new LutPoint(4d, 5d),
new LutPoint(5d, 3d),
};
// points
Assert.AreEqual(1d, lut.InterpolateCubic(1d));
Assert.AreEqual(1d, lut.InterpolateCubic(2d));
Assert.AreEqual(3d, lut.InterpolateCubic(5d));
// clamping
Assert.AreEqual(1d, lut.InterpolateCubic(-1d));
Assert.AreEqual(3d, lut.InterpolateCubic(5.7d));
// interpolation itself
Assert.IsTrue(lut.InterpolateCubic(1.9d) < 1d);
}
/// <inheritdoc />
public override void CalculateLut()
{
for (var y = 0; y < Lut.height; y++)
{
var t = y / (float)Lut.height;
var a = BrighnessGradient.Evaluate(ReverseX ? (1.0f - t) : t);
var b = Gradient.Evaluate(ReverseX ? (1.0f - t) : t);
var c = a * b;
c.a = c.grayscale;
Lut.SetPixel(0, y, c);
}
// Make sure the last pixel is white...
Lut.SetPixel(0, Lut.height - 1, Color.white);
// Make sure the wrapMode is good for penumbra...
Lut.wrapMode = TextureWrapMode.Clamp;
Lut.Apply();
}
public void MinMax() {
var lut = new Lut();
lut.UpdateBoundingBox();
Assert.AreEqual(double.NaN, lut.MinX);
Assert.AreEqual(double.NaN, lut.MinY);
Assert.AreEqual(double.NaN, lut.MaxX);
Assert.AreEqual(double.NaN, lut.MaxY);
lut.Add(new LutPoint(1d, 1d));
lut.UpdateBoundingBox();
Assert.AreEqual(1d, lut.MinX);
Assert.AreEqual(1d, lut.MinY);
Assert.AreEqual(1d, lut.MaxX);
Assert.AreEqual(1d, lut.MaxY);
lut.Add(new LutPoint(-1d, 2d));
lut.UpdateBoundingBox();
Assert.AreEqual(-1d, lut.MinX);
Assert.AreEqual(1d, lut.MinY);
Assert.AreEqual(1d, lut.MaxX);
Assert.AreEqual(2d, lut.MaxY);
}
public override Table CreateChild(Lut ilut, Definition d)
{
Lut3D lut = (Lut3D)ilut;
xml = new XElement("table");
xml.SetAttributeValue("name", name);
xml.SetAttributeValue("address", ilut.dataAddress.ToString("X"));
XElement tx = new XElement("table");
tx.SetAttributeValue("name", "X");
tx.SetAttributeValue("address", lut.colsAddress.ToString("X"));
tx.SetAttributeValue("elements", lut.cols);
xml.Add(tx);
XElement ty = new XElement("table");
ty.SetAttributeValue("name", "Y");
ty.SetAttributeValue("address", lut.rowsAddress.ToString("X"));
ty.SetAttributeValue("elements", lut.rows);
xml.Add(ty);
return(TableFactory.CreateTable(xml, d));
//TODO also set attirbutes and split this up! Copy to table2D!!
}
public void LinearInterpolation() {
var lut = new Lut {
new LutPoint(1d, 1d),
new LutPoint(2d, 1d),
new LutPoint(4d, 5d),
new LutPoint(5d, 3d),
};
// points
Assert.AreEqual(1d, lut.InterpolateLinear(1d));
Assert.AreEqual(1d, lut.InterpolateLinear(2d));
Assert.AreEqual(3d, lut.InterpolateLinear(5d));
// clamping
Assert.AreEqual(1d, lut.InterpolateLinear(-1d));
Assert.AreEqual(3d, lut.InterpolateLinear(5.7d));
// interpolation itself
Assert.AreEqual(1d, lut.InterpolateLinear(1.5d));
Assert.AreEqual(2d, lut.InterpolateLinear(2.5d));
Assert.AreEqual(3d, lut.InterpolateLinear(3d));
Assert.AreEqual(4d, lut.InterpolateLinear(4.5d));
}
/// <inheritdoc />
public override void GenerateLut()
{
if (Lut == null || Lut.width != (int)Size.x || Lut.height != (int)Size.y)
{
DestroyLut();
Lut = Helper.CreateTempTeture2D((int)Size.x, (int)Size.y, TextureFormat.ARGB32, false, false, false);
Lut.wrapMode = TextureWrapMode.Repeat;
}
for (ushort x = 0; x < Lut.width; x++)
{
for (ushort y = 0; y < Lut.height; y++)
{
var t = (x / Size.x) - (NonLinear ? (ReverseY ? (y / Size.y) : ((Size.y - y) / Size.y)) : 0.0f);
var gradientColor = Gradient.Evaluate(ReverseX ? (1.0f - t) : t);
Lut.SetPixel(x, y, gradientColor);
}
}
Lut.Apply();
}
private static Tuple <double, double> GetOptimalRange([CanBeNull] Lut lut)
{
if (lut == null)
{
return(null);
}
double?fromX = null, toX = null;
for (var i = 0; i < lut.Count; i++)
{
var point = lut[i];
if (point.Y >= 0.999d)
{
if (!fromX.HasValue)
{
fromX = point.X;
}
toX = point.X;
}
}
return(fromX.HasValue ? new Tuple <double, double>(fromX.Value, toX.Value) : null);
}
public void LinearInterpolation()
{
var lut = new Lut {
new LutPoint(1d, 1d),
new LutPoint(2d, 1d),
new LutPoint(4d, 5d),
new LutPoint(5d, 3d),
};
// points
Assert.AreEqual(1d, lut.InterpolateLinear(1d));
Assert.AreEqual(1d, lut.InterpolateLinear(2d));
Assert.AreEqual(3d, lut.InterpolateLinear(5d));
// clamping
Assert.AreEqual(1d, lut.InterpolateLinear(-1d));
Assert.AreEqual(3d, lut.InterpolateLinear(5.7d));
// interpolation itself
Assert.AreEqual(1d, lut.InterpolateLinear(1.5d));
Assert.AreEqual(2d, lut.InterpolateLinear(2.5d));
Assert.AreEqual(3d, lut.InterpolateLinear(3d));
Assert.AreEqual(4d, lut.InterpolateLinear(4.5d));
}
public void MinMax()
{
var lut = new Lut();
lut.UpdateBoundingBox();
Assert.AreEqual(double.NaN, lut.MinX);
Assert.AreEqual(double.NaN, lut.MinY);
Assert.AreEqual(double.NaN, lut.MaxX);
Assert.AreEqual(double.NaN, lut.MaxY);
lut.Add(new LutPoint(1d, 1d));
lut.UpdateBoundingBox();
Assert.AreEqual(1d, lut.MinX);
Assert.AreEqual(1d, lut.MinY);
Assert.AreEqual(1d, lut.MaxX);
Assert.AreEqual(1d, lut.MaxY);
lut.Add(new LutPoint(-1d, 2d));
lut.UpdateBoundingBox();
Assert.AreEqual(-1d, lut.MinX);
Assert.AreEqual(1d, lut.MinY);
Assert.AreEqual(1d, lut.MaxX);
Assert.AreEqual(2d, lut.MaxY);
}
public static Babl?Create(string name,
BablTrcType type,
double gamma,
int lutNum,
float[] lut)
{
trc = new BablTrc(type, gamma);
int i;
if (lutNum is not 0)
{
for (i = 0; trcDb[i] is not null; i++)
{
if (trcDb[i] !.LutSize == lutNum && trcDb[i] !.Lut.SequenceEqual(lut))
{
return(trcDb[i] !);
}
}
}
else
{
for (i = 0; trcDb[i] is not null; i++)
{
if (trcDb[i] !.Equals(type, lutNum, gamma))
{
return(trcDb[i] !);
}
}
}
if (i >= MaxTrcs - 1)
{
Log("too many BablTrcs");
return(null);
}
if (name is not "")
{
trc.Name = name;
}
else if (lutNum is not 0)
{
trc.Name = "lut-trc";
}
else
{
trc.Name = $"trc-{type}-{gamma}";
}
if (lutNum is not 0)
{
int j;
trc.Lut = new float[lutNum];
trc.InvLut = new float[lutNum];
lut.CopyTo(trc.Lut, 0);
for (j = 0; j < lutNum; j++)
{
int k;
var min = 0.0;
var max = 1.0;
for (k = 0; k < 16; k++)
{
var guess = (min + max) / 2;
var reversedIndex = LutToLinear(trc, (float)guess) * (lutNum - 1.0);
if (reversedIndex < j)
{
min = guess;
}
else if (reversedIndex > j)
{
max = guess;
}
}
trc.InvLut[j] = (float)(min + max) / 2;
}
}
trc.FuncToLinearBuffered = ToLinearBufferedGeneric;
trc.FuncFromLinearBuffered = FromLinearBufferedGeneric;
switch (trc.TrcType)
{
case BablTrcType.Linear:
trc.FuncToLinear = Linear;
trc.FuncFromLinear = Linear;
trc.FuncFromLinearBuffered = LinearBuffered;
trc.FuncToLinearBuffered = LinearBuffered;
break;
case BablTrcType.FormulaGamma:
trc.FuncToLinear = GammaToLinear;
trc.FuncFromLinear = GammaFromLinear;
trc.FuncToLinearBuffered = GammaToLinearBuffered;
trc.FuncFromLinearBuffered = GammaFromLinearBuffered;
trc.GammaToLinearX0 = (float)GammaX0;
trc.GammaToLinearX1 = (float)GammaX1;
trc.GammaToLinearPoly = Polynomial.ApproximateGamma(trc.Gamma, trc.GammaToLinearX0, trc.GammaToLinearX1, GammaDegree, GammaScale);
trc.GammaFromLinearX0 = (float)GammaX0;
trc.GammaFromLinearX1 = (float)GammaX1;
trc.GammaFromLinearPoly = Polynomial.ApproximateGamma(trc.Rgamma, trc.GammaFromLinearX0, trc.GammaFromLinearX1, GammaDegree, GammaScale);
break;
case BablTrcType.FormulaCie:
trc.Lut = new float[4];
{
for (var j = 0; j < 4; j++)
{
trc.Lut[j] = lut[j];
}
}
trc.FuncToLinear = FormulaCieToLinear;
trc.FuncFromLinear = FormulaCieFromLinear;
trc.GammaToLinearX0 = lut[4];
trc.GammaToLinearX1 = (float)GammaX1;
trc.GammaToLinearPoly = Polynomial.ApproximateGamma(trc.Rgamma, trc.GammaToLinearX0, trc.GammaToLinearX1, GammaDegree, GammaScale);
trc.GammaFromLinearX0 = lut[3] * lut[4];
trc.GammaFromLinearX1 = (float)GammaX1;
trc.GammaFromLinearPoly = Polynomial.ApproximateGamma(trc.Rgamma, trc.GammaFromLinearX0, trc.GammaFromLinearX1, GammaDegree, GammaScale);
break;
case BablTrcType.FormulaSrgb:
trc.Lut = new float[7];
{
for (var j = 0; j < 7; j++)
{
trc.Lut[j] = lut[j];
}
}
trc.FuncToLinear = FormulaSrgbToLinear;
trc.FuncFromLinear = FormulaSrgbFromLinear;
trc.GammaToLinearX0 = lut[4];
trc.GammaToLinearX1 = (float)GammaX1;
trc.GammaToLinearPoly = Polynomial.ApproximateGamma(trc.Gamma, trc.GammaToLinearX0, trc.GammaToLinearX1, GammaDegree, GammaScale);
trc.GammaFromLinearX0 = lut[3] * lut[4];
trc.GammaFromLinearX1 = (float)GammaX1;
trc.GammaFromLinearPoly = Polynomial.ApproximateGamma(trc.Rgamma, trc.GammaFromLinearX0, trc.GammaFromLinearX1, GammaDegree, GammaScale);
break;
case BablTrcType.Srgb:
trc.FuncToLinear = SrgbToLinear;
trc.FuncFromLinear = SrgbFromLinear;
trc.FuncFromLinearBuffered = SrgbFromLinearBuffered;
trc.FuncToLinearBuffered = SrgbToLinearBuffered;
break;
case BablTrcType.Lut:
trc.FuncToLinear = LutToLinear;
trc.FuncFromLinear = LutFromLinear;
break;
}
trcDb[i] = trc;
return(trc);
}
public static Lut LoadCarTorque(IDataWrapper data, bool considerLimiter = true, int detalization = 100) {
/* read torque curve and engine params */
var torqueFile = data.GetLutFile("power.lut");
if (torqueFile.IsEmptyOrDamaged()) throw new FileNotFoundException("Cannot load power.lut", "data/power.lut");
var engine = data.GetIniFile("engine.ini");
if (engine.IsEmptyOrDamaged()) throw new FileNotFoundException("Cannot load engine.ini", "data/engine.ini");
/* prepare turbos and read controllers */
var turbos = ReadTurbos(engine);
for (var i = 0; i < turbos.Count; i++) {
turbos[i].Controllers = ReadControllers(data.GetIniFile($"ctrl_turbo{i}.ini"));
}
/* prepare torque curve and limits */
var torque = torqueFile.Values;
torque.UpdateBoundingBox();
var limit = considerLimiter && engine.ContainsKey("ENGINE_DATA") ? engine["ENGINE_DATA"].GetDouble("LIMITER", torque.MaxX) : torque.MaxX;
var startFrom = considerLimiter ? 0d : torque.MinX;
/* build smoothed line */
var result = new Lut();
var previousTorquePoint = 0;
var previousRpm = 0d;
for (var i = 0; i <= detalization; i++) {
var rpm = detalization == 0 ? limit : (limit - startFrom) * i / detalization + startFrom;
for (var j = previousTorquePoint; j < torque.Count; j++) {
var p = torque[j];
if (p.X > rpm) {
previousTorquePoint = j > 0 ? j - 1 : 0;
break;
}
if ((i == 0 || p.X > previousRpm) && p.X < rpm && p.X >= 0) {
result.Add(new LutPoint(p.X, ConsiderTurbo(turbos, p.X, p.Y)));
}
}
var baseTorque = torque.InterpolateLinear(rpm);
result.Add(new LutPoint(rpm, ConsiderTurbo(turbos, rpm, baseTorque)));
previousRpm = rpm;
}
return result.Optimize();
}
public override Table CreateChild(Lut lut, Definition d)
{
return(base.CreateChild(lut, d));
//TODO FIX?? AND CHECK FOR STATIC AXES!!
}
public static void ConsiderTurbo(IReadOnlyList<TurboDescription> turbo, Lut torqueValues) {
torqueValues.TransformSelf(x => ConsiderTurbo(turbo, x.X, x.Y));
}
public Lut1DEffectGenerator(Lut lut)
{
redTable = lut.Colors.Select(c => c.R / 255f).ToArray();
greenTable = lut.Colors.Select(c => c.G / 255f).ToArray();
blueTable = lut.Colors.Select(c => c.B / 255f).ToArray();
}
public void ExposeTable(string name, Lut lut)
{
Table baseTable = GetBaseTable(name);
if (baseTable != null)
{
Table childTable = baseTable.CreateChild(lut, this);
//TODO: HANDLE STATIC AXES!!
if (lut.dataAddress < 0x400000)
{
//TODO: HANDLE UPDATES TO EXISTING TABLES!!??
if (ExposedRomTables.ContainsKey(childTable.name))
{
ExposedRomTables.Remove(childTable.name);
}
ExposedRomTables.Add(childTable.name, childTable);
}
else
{
if (ExposedRamTables.ContainsKey(childTable.name))
{
ExposedRamTables.Remove(childTable.name);
}
ExposedRamTables.Add(childTable.name, childTable);
}
}
//if (bt == null) return;
//bt.SetAttributeValue("address", lut.dataAddress.ToString("X"));//(System.Int32.Parse(temptable.Value.Attribute("offset").Value.ToString(), System.Globalization.NumberStyles.AllowHexSpecifier) + offset).ToString("X"));
//IEnumerable<XAttribute> tempattr = bt.Attributes();
//List<String> remattr = new List<String>();
//foreach (XAttribute attr in tempattr)
//{
// if (attr.Name != "address" && attr.Name != "name")
// {
// remattr.Add(attr.Name.ToString());
// }
//}
//foreach (String rem in remattr)
//{
// bt.Attribute(rem).Remove();
//}
//List<String> eleremlist = new List<String>();
//foreach (XElement ele in bt.Elements())
//{
// IEnumerable<XAttribute> childtempattr = ele.Attributes();
// List<String> childremattr = new List<String>();
// if (ele.Name.ToString() != "table")
// {
// eleremlist.Add(ele.Name.ToString());
// continue;
// }
// if (ele.Attribute("type").Value.ContainsCI("static"))
// {
// eleremlist.Add(ele.Name.ToString());
// }
// else if (ele.Attribute("type").Value.ContainsCI("x axis"))
// {
// ele.Attribute("name").Value = "X";
// }
// else if (ele.Attribute("type").Value.ContainsCI("y axis"))
// {
// ele.Attribute("name").Value = "Y";
// }
// foreach (XAttribute attr in childtempattr)
// {
// if (attr.Name != "address" && attr.Name != "name")
// {
// childremattr.Add(attr.Name.ToString());
// }
// }
// foreach (String rem in childremattr)
// {
// ele.Attribute(rem).Remove();
// }
//}
//foreach (String rem in eleremlist)
//{
// bt.Element(rem).Remove();
//}
}
public Lut GetLut([NotNull, LocalizationRequired(false)] string key)
{
var value = GetNonEmpty(key);
return(value == null ? null : Lut.FromValue(value));
}
public override Table CreateChild(Lut lut, Definition d)
{
return(base.CreateChild(lut, d));
}
