Example #1
0
        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));
        }
Example #2
0
 public DX9Renderer(Control renderTarget, IScaler imageScaler, uint[,] screen, bool smooth)
 {
     this.renderTarget = renderTarget;
     this.imageScaler = imageScaler;
     this.screen = screen;
     this.smoothOutput = smooth;
 }
Example #3
0
 public OpenGLRenderer(Control renderTarget, IScaler imageScaler, uint[,] screen, bool smooth)
 {
     this.renderTarget = renderTarget;
     this.imageScaler  = imageScaler;
     this.screen       = screen;
     this.smoothOutput = smooth;
 }
Example #4
0
        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;
     }
 }
Example #6
0
 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;
 }
Example #8
0
 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;
 }
Example #10
0
        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;
        }
Example #11
0
            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;
            }
Example #13
0
            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();
            }
Example #14
0
 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();
 }
Example #18
0
        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;
        }
Example #19
0
            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();
            }
Example #20
0
        /// <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;
        }
Example #21
0
        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);
        }
Example #22
0
            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();
                }
            }
Example #23
0
        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);
        }
Example #24
0
 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));
 }
Example #25
0
 public void ChangeScaler(IScaler imageScaler)
 {
 }
Example #26
0
    /*
  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);
      }
    }
Example #27
0
 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);
                }
            }
        }
Example #29
0
 public void ChangeScaler(IScaler imageScaler)
 {
     this.imageScaler = imageScaler;
     Reset();
 }
Example #30
0
 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 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 void ForceOffsetCorrection()
 {
     if (!m_Offset.IsZero)
         m_Convolver = m_Convolver ?? m_Upscaler;
 }
Example #36
0
        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);
        }
Example #37
0
 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)
 {
 }
Example #39
0
        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 ScaleSize(IScaler scaler)
 {
     this.scaler = scaler;
     this.size   = scaler.Scale();
 }
Example #41
0
 public void ChangeScaler(IScaler imageScaler)
 {
 }
Example #42
0
 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_);
                }
            }
        }
Example #44
0
 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)
 {
 }