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); }
/// <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 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)); }