public static string GetDescription(this IScaler scaler, bool useDownscalerName = false) { if (useDownscalerName) { switch (scaler.ScalerType) { case ImageScaler.NearestNeighbour: return("Box"); case ImageScaler.Bilinear: return("Triangle"); } } var result = scaler.GetType().Name; switch (scaler.ScalerType) { case ImageScaler.NearestNeighbour: case ImageScaler.Bilinear: case ImageScaler.Bicubic: case ImageScaler.Softcubic: return(result + GetScalerAntiRingingDescription(scaler)); case ImageScaler.Custom: return(GetCustomLinearScalerDescription((Custom)scaler)); } return(result + scaler.KernelTaps + GetScalerAntiRingingDescription(scaler)); }
public DX9Renderer(Control renderTarget, IScaler imageScaler, uint[,] screen, bool smooth) { this.renderTarget = renderTarget; this.imageScaler = imageScaler; this.screen = screen; this.smoothOutput = smooth; }
public OpenGLRenderer(Control renderTarget, IScaler imageScaler, uint[,] screen, bool smooth) { this.renderTarget = renderTarget; this.imageScaler = imageScaler; this.screen = screen; this.smoothOutput = smooth; }
private static string GetScalerAntiRingingDescription(IScaler scaler) { switch (scaler.ScalerType) { case ImageScaler.NearestNeighbour: case ImageScaler.Bilinear: case ImageScaler.Softcubic: return(""); case ImageScaler.Bicubic: return(((Bicubic)scaler).AntiRingingEnabled ? "AR" : ""); case ImageScaler.Lanczos: return(((Lanczos)scaler).AntiRingingEnabled ? "AR" : ""); case ImageScaler.Spline: return(((Spline)scaler).AntiRingingEnabled ? "AR" : ""); case ImageScaler.Jinc: return(((Jinc)scaler).AntiRingingEnabled ? "AR" : ""); case ImageScaler.Custom: return(((Custom)scaler).AntiRingingEnabled ? "AR" : ""); default: throw new ArgumentOutOfRangeException(); } }
public void ForceOffsetCorrection() { if (!m_Offset.IsZero) { m_Convolver = m_Convolver ?? m_Upscaler; } }
public ResizeFilter(IFilter inputFilter, Size outputSize, IScaler upscaler, IScaler downscaler) : base(inputFilter) { m_Upscaler = upscaler; m_Downscaler = downscaler; m_OutputSize = outputSize; }
public Figure(IDrawer drawer, IScaler scaler, IUpdater updater, IMover mover, IRotator rotator) { Updater = updater; Scaler = scaler; Drawer = drawer; Mover = mover; Rotator = rotator; }
public ResizeFilter(IFilter <ITexture> inputFilter, TextureSize outputSize, IScaler upscaler, IScaler downscaler, IScaler convolver = null) : base(inputFilter) { m_Upscaler = upscaler; m_Downscaler = downscaler; m_Convolver = convolver; m_OutputSize = outputSize; }
public ResizeFilter(IFilter inputFilter, TextureSize outputSize, TextureChannels channels, Vector2 offset, IScaler upscaler, IScaler downscaler, IScaler convolver = null) : base(inputFilter) { m_Upscaler = upscaler; m_Downscaler = downscaler; m_Convolver = convolver; m_OutputSize = outputSize; m_Channels = channels; m_Offset = offset; }
public ResizeFilter(IFilter <ITextureOutput <ITexture2D> > inputFilter, TextureSize outputSize, TextureChannels channels, Vector2 offset, IScaler upscaler = null, IScaler downscaler = null, IScaler convolver = null, TextureFormat?outputFormat = null) : base(outputSize, outputFormat ?? inputFilter.Output.Format, inputFilter) { m_OutputSize = outputSize; m_Channels = channels; m_Offset = offset; m_Upscaler = upscaler ?? Renderer.LumaUpscaler; m_Downscaler = downscaler ?? Renderer.LumaDownscaler; m_Convolver = convolver; }
public SuperChromaRes() { Passes = 1; Strength = 1.0f; Softness = 0.0f; Prescaler = true; upscaler = new Bilinear(); downscaler = new Bilinear(); }
public Process(TextureSize outputSize, TextureChannels channels, Vector2 offset, IScaler upscaler = null, IScaler downscaler = null, IScaler convolver = null, TextureFormat?outputFormat = null) { m_OutputSize = outputSize; m_Channels = channels; m_Offset = offset; m_Format = outputFormat; m_Upscaler = upscaler ?? Renderer.LumaUpscaler; m_Downscaler = downscaler ?? Renderer.LumaDownscaler; m_Convolver = convolver; }
public SuperChromaRes() { Passes = 2; Strength = 0.75f; Sharpness = 0.15f; AntiAliasing = 0.25f; AntiRinging = 0.75f; Softness = 0.5f; FirstPassOnly = true; upscaler = new Scaler.Bilinear(); downscaler = new Scaler.Bilinear(); }
public SceneInitializer(Point size, IScaler scaler, List <ObjectModel> systems, List <ObjectModel> renderers, List <EntityModel> entities, List <InputAction> actions) { this.size = size; this.scaler = scaler; this.systems = systems; this.renderers = renderers; this.entities = entities; this.actions = actions; }
public CrystalScene(CrystalGame game, SceneInitializer initializer, ContentManager content, IScaler scaler, Point size) : base(size, content, new CrystalCanvas((uint)size.X, (uint)size.Y), new CrystalWindowCanvas(game.Window), scaler) { this.game = game; this.initializer = initializer; this.content = content; }
public ClassificationModelProperty(string name, double coefficient, ICollection <Range> scaleRanges = null) { Name = name; Coefficient = coefficient; // Create scaler fopr the provided scale ranges if (scaleRanges?.Count > 0) { Scaler = new RangedListScaler(scaleRanges); } else { Scaler = new IdentityScaler(); } }
public EventDensityViewModel(IScaler scaler, IDensityApi densityApi, ILogger logger, ITimeLineRender timeLineRender, IChartRender chartRender) { _scaler = scaler; _densityApi = densityApi; _logger = logger; _timeLineRender = timeLineRender; _chartRender = chartRender; MoveLeftCommand = new DelegateCommand(MoveLeft); MoveRightCommand = new DelegateCommand(MoveRight); RecalculateWholeImage(); }
public void PropagateTo(IScaler scaler, ITranslator translator) { if (!this.ValidForZoom) { return; } Rectangle2D normalizedZoomRectangle = this.NormalizedZoomRectangle; Point2D center = normalizedZoomRectangle.Center; Point2D point = (Transformation3D.Translation(translator.Translation) * Transformation3D.Scaling2D(scaler.ScaleFactor)).GetInverse().Transform(center); double num = 2.0 / System.Math.Max(System.Math.Abs(normalizedZoomRectangle.Width), System.Math.Abs(normalizedZoomRectangle.Height)); scaler.ScaleFactor *= num; Point2D point2D = (Transformation3D.Translation(translator.Translation) * Transformation3D.Scaling2D(scaler.ScaleFactor)).Transform(point); translator.Translation += center - point2D; }
public SuperRes() { TargetSize = () => Renderer.TargetSize; m_ShiftedScaler = new Scaler.Custom(new ShiftedScaler(0.5f), ScalerTaps.Six, false); Passes = 3; Strength = 0.75f; Sharpness = 0.5f; AntiAliasing = 0.25f; AntiRinging = 0.75f; UseNEDI = false; FirstPassOnly = false; upscaler = new Scaler.Jinc(ScalerTaps.Four, false); downscaler = new Scaler.Bilinear(); }
/// <summary> /// Mockable Constructor /// </summary> /// <param name="scaler">Scaler</param> /// <param name="configuration">Configuration</param> /// <param name="minimum">Minimum Scale</param> /// <param name="maximum">Maximmum Scale</param> /// <param name="checkScaleInMinutes">Check Scale Every</param> public AutoScaler(IScaler <T> scaler, T configuration = default(T), byte minimum = 1, byte maximum = 2, byte checkScaleInMinutes = BaseTimes.ScaleCheck) : base((int)TimeSpan.FromMinutes(checkScaleInMinutes).TotalSeconds) { if (minimum > maximum) { throw new ArgumentException("Minimum should be less than Maximum"); } if (null == scaler) { throw new ArgumentNullException("scaler"); } this.configuration = configuration; this.instanceCount.Minimum = 1 > minimum ? (byte)1 : minimum; this.instanceCount.Maximum = 2 > maximum ? (byte)2 : maximum; this.scaler = scaler; }
public Material Update(Parameters parms, IScaler scaler, Vector2 range, List <float> entries = null) { if (m_ScaleMaterial == null) { var circularGraduationMaterial = Resources.Load <Material>("Materials/CircularGraduation"); Assert.IsNotNull(circularGraduationMaterial); m_ScaleMaterial = new Material(circularGraduationMaterial); m_ScaleMaterial.hideFlags = HideFlags.DontSave; } UpdateShaderUniforms(m_ScaleMaterial, parms); if (m_ScaleTexture == null) { // TODO: have buffer size match its circular projection in screen space. m_ScaleTexture = new Texture2D(k_ScaleResolution, 1, TextureFormat.Alpha8, false); // TODO use Alpha8 m_ScaleTexture.filterMode = FilterMode.Bilinear; m_ScaleTexture.hideFlags = HideFlags.HideAndDontSave; } for (var i = 0; i < k_ScaleResolution; ++i) { s_ScalePixels[i] = 0; } if (entries != null) { foreach (var val in entries) { var angle = scaler.ValueToAngle(range.x, range.y, parms.angularRange, val); var normalized = (parms.angularRange - angle) / (parms.angularRange * 2); RenderPoint(s_ScalePixels, normalized, parms.entryLineWidth, 1); } } if (Math.Abs(parms.scaleDensityHint) > Mathf.Epsilon) { RenderScale(s_ScalePixels, parms, scaler, range, 0.5f); } m_ScaleTexture.LoadRawTextureData(s_ScalePixels); m_ScaleTexture.Apply(); m_ScaleMaterial.SetTexture(k_ShaderScaleTex, m_ScaleTexture); return(m_ScaleMaterial); }
public SuperRes() { TargetSize = () => Renderer.TargetSize; Passes = 3; Strength = 1.0f; Softness = 0.0f; HQdownscaling = true; Options = new List <Preset> { new Preset { Name = "Super-xBR", Script = new SuperXbrUi() }, new Preset { Name = "NEDI", Script = new Nedi.NediScaler() }, new Preset { Name = "NNEDI3", Script = new NNedi3.NNedi3Scaler() }, new Preset { Name = "OpenCL NNEDI3", Script = new OclNNedi3Scaler() } }; SelectedIndex = 0; m_Upscaler = new Jinc(ScalerTaps.Four, false); // Deprecated if (HQdownscaling) { m_Downscaler = new Bicubic(0.66f, false); } else { m_Downscaler = new Bilinear(); } }
static void RenderScale(byte[] target, Parameters parms, IScaler scaler, Vector2 range, float intensity) { var delta = Math.Abs(range.y - range.x) / Mathf.Max(1, parms.scaleDensityHint); // value delta between two points. // Find power of 10 above ptValDelta. var gradDelta = Mathf.Pow(10, Mathf.Ceil(Mathf.Log(delta) / Mathf.Log(10))); // Subdivide that power of 10 to get closer to target. while (gradDelta > 2 * delta) { gradDelta *= 0.5f; } var pos = Mathf.Ceil(range.x / gradDelta) * gradDelta; do { var angle = scaler.ValueToAngle(range.x, range.y, parms.angularRange, pos); var normalized = (parms.angularRange - angle) / (parms.angularRange * 2); RenderPoint(target, normalized, parms.lineWidth, intensity); pos += gradDelta; }while (pos < range.y); }
public static ITextureFilter Convolve(this ITextureFilter <ITexture2D> inputFilter, IScaler convolver, TextureChannels?channels = null, Vector2?offset = null, IScaler upscaler = null, IScaler downscaler = null, TextureFormat?outputFormat = null) { return(new ResizeFilter(inputFilter, inputFilter.Output.Size, channels ?? TextureChannels.All, offset ?? Vector2.Zero, upscaler, downscaler, convolver, outputFormat)); }
public void ChangeScaler(IScaler imageScaler) { }
/* input kernel area naming convention: ------------- | A | B | C | ----|---|---| | D | E | F | //input pixel is at position E ----|---|---| | G | H | I | ------------- */ private static void _ScalePixel( IScaler scaler, RotationDegree rotDeg, Kernel_3X3 ker, sPixel[] trg, int trgi, int trgWidth, byte blendInfo,//result of preprocessing all four corners of pixel "e" IColorEq scalePixelColorEq, IColorDist scalePixelColorDist, OutputMatrix outputMatrix ) { //int a = kernel._[Rot._[(0 << 2) + rotDeg]]; var b = ker._[Rot._[(1 << 2) + (int)rotDeg]]; var c = ker._[Rot._[(2 << 2) + (int)rotDeg]]; var d = ker._[Rot._[(3 << 2) + (int)rotDeg]]; var e = ker._[Rot._[(4 << 2) + (int)rotDeg]]; var f = ker._[Rot._[(5 << 2) + (int)rotDeg]]; var g = ker._[Rot._[(6 << 2) + (int)rotDeg]]; var h = ker._[Rot._[(7 << 2) + (int)rotDeg]]; var i = ker._[Rot._[(8 << 2) + (int)rotDeg]]; var blend = BlendInfo.Rotate(blendInfo, rotDeg); if (BlendInfo.GetBottomR(blend) == BlendType.BlendNone) return; var eq = scalePixelColorEq; var dist = scalePixelColorDist; bool doLineBlend; if (BlendInfo.GetBottomR(blend) >= BlendType.BlendDominant) doLineBlend = true; //make sure there is no second blending in an adjacent //rotation for this pixel: handles insular pixels, mario eyes //but support double-blending for 90? corners else if (BlendInfo.GetTopR(blend) != BlendType.BlendNone && !eq._(e, g)) doLineBlend = false; else if (BlendInfo.GetBottomL(blend) != BlendType.BlendNone && !eq._(e, c)) doLineBlend = false; //no full blending for L-shapes; blend corner only (handles "mario mushroom eyes") else if (eq._(g, h) && eq._(h, i) && eq._(i, f) && eq._(f, c) && !eq._(e, i)) doLineBlend = false; else doLineBlend = true; //choose most similar color var px = dist._(e, f) <= dist._(e, h) ? f : h; var output = outputMatrix; output.Move(rotDeg, trgi); if (!doLineBlend) { scaler.BlendCorner(px, output); return; } //test sample: 70% of values max(fg, hc) / min(fg, hc) //are between 1.1 and 3.7 with median being 1.9 var fg = dist._(f, g); var hc = dist._(h, c); var haveShallowLine = _CONFIGURATION.steepDirectionThreshold * fg <= hc && e != g && d != g; var haveSteepLine = _CONFIGURATION.steepDirectionThreshold * hc <= fg && e != c && b != c; if (haveShallowLine) { if (haveSteepLine) scaler.BlendLineSteepAndShallow(px, output); else scaler.BlendLineShallow(px, output); } else { if (haveSteepLine) scaler.BlendLineSteep(px, output); else scaler.BlendLineDiagonal(px, output); } }
public void ChangeScaler(IScaler imageScaler) { this.imageScaler = imageScaler; Reset(); }
/* * input kernel area naming convention: * ------------- | A | B | C | | ----|---|---| | D | E | F | //input pixel is at position E | ----|---|---| | G | H | I | | ------------- */ private static void _ScalePixel( IScaler scaler, RotationDegree rotDeg, Kernel_3X3 ker, sPixel[] trg, int trgi, int trgWidth, byte blendInfo, //result of preprocessing all four corners of pixel "e" IColorEq scalePixelColorEq, IColorDist scalePixelColorDist, OutputMatrix outputMatrix ) { //int a = kernel._[Rot._[(0 << 2) + rotDeg]]; var b = ker._[Rot._[(1 << 2) + (int)rotDeg]]; var c = ker._[Rot._[(2 << 2) + (int)rotDeg]]; var d = ker._[Rot._[(3 << 2) + (int)rotDeg]]; var e = ker._[Rot._[(4 << 2) + (int)rotDeg]]; var f = ker._[Rot._[(5 << 2) + (int)rotDeg]]; var g = ker._[Rot._[(6 << 2) + (int)rotDeg]]; var h = ker._[Rot._[(7 << 2) + (int)rotDeg]]; var i = ker._[Rot._[(8 << 2) + (int)rotDeg]]; var blend = BlendInfo.Rotate(blendInfo, rotDeg); if (BlendInfo.GetBottomR(blend) == BlendType.BlendNone) { return; } var eq = scalePixelColorEq; var dist = scalePixelColorDist; bool doLineBlend; if (BlendInfo.GetBottomR(blend) >= BlendType.BlendDominant) { doLineBlend = true; } //make sure there is no second blending in an adjacent //rotation for this pixel: handles insular pixels, mario eyes //but support double-blending for 90? corners else if (BlendInfo.GetTopR(blend) != BlendType.BlendNone && !eq._(e, g)) { doLineBlend = false; } else if (BlendInfo.GetBottomL(blend) != BlendType.BlendNone && !eq._(e, c)) { doLineBlend = false; } //no full blending for L-shapes; blend corner only (handles "mario mushroom eyes") else if (eq._(g, h) && eq._(h, i) && eq._(i, f) && eq._(f, c) && !eq._(e, i)) { doLineBlend = false; } else { doLineBlend = true; } //choose most similar color var px = dist._(e, f) <= dist._(e, h) ? f : h; var output = outputMatrix; output.Move(rotDeg, trgi); if (!doLineBlend) { scaler.BlendCorner(px, output); return; } //test sample: 70% of values max(fg, hc) / min(fg, hc) //are between 1.1 and 3.7 with median being 1.9 var fg = dist._(f, g); var hc = dist._(h, c); var haveShallowLine = _CONFIGURATION.steepDirectionThreshold * fg <= hc && e != g && d != g; var haveSteepLine = _CONFIGURATION.steepDirectionThreshold * hc <= fg && e != c && b != c; if (haveShallowLine) { if (haveSteepLine) { scaler.BlendLineSteepAndShallow(px, output); } else { scaler.BlendLineShallow(px, output); } } else { if (haveSteepLine) { scaler.BlendLineSteep(px, output); } else { scaler.BlendLineDiagonal(px, output); } } }
public static string ScaleDescription(int inputDimension, int outputDimension, IScaler upscaler, IScaler downscaler, IScaler convolver = null) { if (outputDimension > inputDimension) { return("↑" + upscaler.GetDescription()); } if (outputDimension < inputDimension) { return("↓" + downscaler.GetDescription(true)); } if (convolver != null) { return("⇄ " + convolver.GetDescription(true)); } return(""); }
public ResizeFilter(IFilter inputFilter, TextureSize outputSize, TextureChannels channels, Vector2 offset, IScaler convolver = null) : this(inputFilter, outputSize, channels, offset, Renderer.LumaUpscaler, Renderer.LumaDownscaler, convolver) { }
public ResizeFilter(IFilter inputFilter, TextureSize outputSize, TextureChannels channels, IScaler upscaler, IScaler downscaler, IScaler convolver = null) : this(inputFilter, outputSize, channels, Vector2.Zero, upscaler, downscaler, convolver) { }
public ResizeFilter(IFilter inputFilter, TextureSize outputSize, Vector2 offset, IScaler upscaler, IScaler downscaler, IScaler convolver = null) : this(inputFilter, outputSize, TextureChannels.All, offset, upscaler, downscaler, convolver) { }
public void ForceOffsetCorrection() { if (!m_Offset.IsZero) m_Convolver = m_Convolver ?? m_Upscaler; }
public void Initialize() { this.appPath = Path.GetDirectoryName(Application.ExecutablePath); Directory.SetCurrentDirectory(appPath); config = new EmuConfig("Emu-o-Tron.cfg"); this.LoadKeys(); if (!File.Exists(this.config["palette"])) this.config["palette"] = config.defaults["palette"]; FileStream palFile = File.OpenRead(this.config["palette"]); for (int i = 0; i < 0x40; i++) this.colorChart[i] = (uint)((0xFF << 24) | (palFile.ReadByte() << 16) | (palFile.ReadByte() << 8) | palFile.ReadByte()); if (palFile.Length > 0x40 * 3) //shitty hack for vs palette because im LAZY { uint[] vsColor = new uint[0x200]; for (int i = 0; palFile.Position < palFile.Length; i++) { vsColor[i] = colorChart[palFile.ReadByte()]; } colorChart = vsColor; } palFile.Close(); CreateEmphasisTables(); if (this.config["showFPS"] == "1") { this.showFPSToolStripMenuItem.Checked = true; this.showFPS = true; } else { this.showFPSToolStripMenuItem.Checked = false; this.showFPS = false; } if (this.config["showInput"] == "1") { this.showInputToolStripMenuItem.Checked = true; this.showInput = true; } else { this.showInputToolStripMenuItem.Checked = false; this.showInput = false; } this.smoothOutputToolStripMenuItem.Checked = (this.config["smoothOutput"] == "1"); this.spritesToolStripMenuItem.Checked = (config["displaySprites"] == "1"); this.backgroundToolStripMenuItem.Checked = (config["displayBG"] == "1"); this.spriteLimitToolStripMenuItem.Checked = (config["disableSpriteLimit"] == "1"); this.openPaletteDialog.InitialDirectory = Path.GetFullPath(this.config["paletteDir"]); this.openMovieDialog.InitialDirectory = Path.GetFullPath(this.config["movieDir"]); this.saveMovie.InitialDirectory = Path.GetFullPath(this.config["movieDir"]); this.openFile.InitialDirectory = Path.GetFullPath(this.config["romPath1"]); this.enableSoundToolStripMenuItem.Checked = (config["sound"] == "1"); this.nTSCToolStripMenuItem.Checked = (SystemType)Convert.ToInt32(config["region"]) == SystemType.NTSC; this.pALToolStripMenuItem.Checked = (SystemType)Convert.ToInt32(config["region"]) == SystemType.PAL; for(int i = 1; i <= 5; i++) if(this.config["romPath" + i.ToString()] != "") this.openFile.CustomPlaces.Add(this.config["romPath" + i.ToString()]); this.LoadRecentFiles(); this.Width = Convert.ToInt32(this.config["width"]); this.Height = Convert.ToInt32(this.config["height"]); config["rawNESPalette"] = "0"; switch (this.config["scaler"].ToLower()) { default: case "sizable": case "sizeable": sizeableToolStripMenuItem.Checked = true; this.imageScaler = new Sizeable(); break; case "1x": xToolStripMenuItem.Checked = true; this.imageScaler = new NearestNeighbor1x(); break; case "2x": xToolStripMenuItem1.Checked = true; this.imageScaler = new NearestNeighbor2x(); break; case "scale2x": scale2xToolStripMenuItem.Checked = true; this.imageScaler = new Scale2x(); break; case "scale3x": scale3xToolStripMenuItem.Checked = true; this.imageScaler = new Scale3x(); break; case "fill": fillToolStripMenuItem.Checked = true; this.imageScaler = new Fill(); break; case "tv": tVAspectToolStripMenuItem.Checked = true; this.imageScaler = new TVAspect(); break; case "hq2x": hQ2xToolStripMenuItem.Checked = true; this.imageScaler = new HQ2x(); break; case "phosphor2x": this.imageScaler = new Phosphor2x(); break; case "phosphor3x": this.imageScaler = new Phosphor3x(); break; case "ntsc": this.imageScaler = new NTSC(); config["rawNESPalette"] = "1"; break; } PrepareScaler(); rewindingEnabled = this.config["rewindEnabled"] == "1" ? true : false; saveBufferFreq = Convert.ToInt32(this.config["rewindBufferFreq"]); saveBufferSeconds = Convert.ToInt32(this.config["rewindBufferSeconds"]); saveBuffer = new SaveState[(60 / saveBufferFreq) * saveBufferSeconds]; player1A.freq = 2; player1A.count = 1; player1B.freq = 2; player1B.count = 1; player2A.freq = 2; player2A.count = 1; player2B.freq = 2; player2B.count = 1; state = SystemState.Empty; surfaceControl.Visible = false; volume.master = Convert.ToInt32(config["volume"]) / 100f; volume.square1 = 1; volume.square2 = 1; volume.triangle = 1; volume.noise = 1; volume.dmc = 1; volume.external = 1; if (this.romPath != "") this.OpenFile(romPath); }
private ScaleSize(IScaler scaler) { this.scaler = scaler; this.size = scaler.Scale(); }
public ResizeFilter(IFilter inputFilter, TextureSize outputSize, IScaler convolver = null) : this(inputFilter, outputSize, TextureChannels.All, Vector2.Zero, Renderer.LumaUpscaler, Renderer.LumaDownscaler, convolver) { }
public static string ScaleDescription(TextureSize inputSize, TextureSize outputSize, IScaler upscaler, IScaler downscaler, IScaler convolver = null) { var xDesc = ScaleDescription(inputSize.Width, outputSize.Width, upscaler, downscaler, convolver); var yDesc = ScaleDescription(inputSize.Height, outputSize.Height, upscaler, downscaler, convolver); if (xDesc == yDesc) { return(xDesc); } xDesc = xDesc.AddPrefixToDescription("X: "); yDesc = yDesc.AddPrefixToDescription("Y: "); if (xDesc == "") { return(yDesc); } if (yDesc == "") { return(xDesc); } return(xDesc + ", " + yDesc); }
private void hQ2xToolStripMenuItem_Click(object sender, EventArgs e) { foreach (ToolStripMenuItem item in videoModeToolStripMenuItem.DropDownItems) item.Checked = false; hQ2xToolStripMenuItem.Checked = true; imageScaler = new HQ2x(); if (renderer != null) renderer.ChangeScaler(imageScaler); PrepareScaler(); config["scaler"] = "hq2x"; }
/* * input kernel area naming convention: * ------------- | A | B | C | | ----|---|---| | D | E | F | //input pixel is at position E | ----|---|---| | G | H | I | | ------------- | blendInfo: result of preprocessing all four corners of pixel "e" */ private void ScalePixel(IScaler scaler, int rotDeg, Kernel3x3 ker, int trgi, char blendInfo) { // int a = ker._[Rot._[(0 << 2) + rotDeg]]; var b = ker._[Rot._[(1 << 2) + rotDeg]]; var c = ker._[Rot._[(2 << 2) + rotDeg]]; var d = ker._[Rot._[(3 << 2) + rotDeg]]; var e = ker._[Rot._[(4 << 2) + rotDeg]]; var f = ker._[Rot._[(5 << 2) + rotDeg]]; var g = ker._[Rot._[(6 << 2) + rotDeg]]; var h = ker._[Rot._[(7 << 2) + rotDeg]]; var i = ker._[Rot._[(8 << 2) + rotDeg]]; var blend = blendInfo.Rotate((RotationDegree)rotDeg); if ((BlendType)blend.GetBottomR() == BlendType.None) { return; } var eq = _colorEqualizer; var dist = _colorDistance; bool doLineBlend; if (blend.GetBottomR() >= (char)BlendType.Dominant) { doLineBlend = true; } //make sure there is no second blending in an adjacent //rotation for this pixel: handles insular pixels, mario eyes //but support double-blending for 90� corners else if (blend.GetTopR() != (char)BlendType.None && !eq.IsColorEqual(e, g)) { doLineBlend = false; } else if (blend.GetBottomL() != (char)BlendType.None && !eq.IsColorEqual(e, c)) { doLineBlend = false; } //no full blending for L-shapes; blend corner only (handles "mario mushroom eyes") else if (eq.IsColorEqual(g, h) && eq.IsColorEqual(h, i) && eq.IsColorEqual(i, f) && eq.IsColorEqual(f, c) && !eq.IsColorEqual(e, i)) { doLineBlend = false; } else { doLineBlend = true; } //choose most similar color var px = dist.DistYCbCr(e, f) <= dist.DistYCbCr(e, h) ? f : h; var out_ = _outputMatrix; out_.Move(rotDeg, trgi); if (!doLineBlend) { scaler.BlendCorner(px, out_); return; } //test sample: 70% of values max(fg, hc) / min(fg, hc) //are between 1.1 and 3.7 with median being 1.9 var fg = dist.DistYCbCr(f, g); var hc = dist.DistYCbCr(h, c); var haveShallowLine = _cfg.SteepDirectionThreshold * fg <= hc && e != g && d != g; var haveSteepLine = _cfg.SteepDirectionThreshold * hc <= fg && e != c && b != c; if (haveShallowLine) { if (haveSteepLine) { scaler.BlendLineSteepAndShallow(px, out_); } else { scaler.BlendLineShallow(px, out_); } } else { if (haveSteepLine) { scaler.BlendLineSteep(px, out_); } else { scaler.BlendLineDiagonal(px, out_); } } }
public ResizeFilter(IFilter<ITexture2D> inputFilter, IScaler upscaler = null, IScaler downscaler = null, IScaler convolver = null) : this(inputFilter, inputFilter.OutputSize, TextureChannels.All, Vector2.Zero, upscaler, downscaler, convolver) { }