private ThumbnailSettings(Size size, InterpolationMode interpolationMode, Color backColor, ThreadPriority threadPriority)
 {
     this.size = size;
       this.interpolationMode = interpolationMode;
       this.backColor = backColor;
       this.threadPriority = threadPriority;
 }

    /// <summary>
    /// Applies the GDI+ pixel scaler.
    /// </summary>
    /// <param name="type">The type of scaler to use.</param>
    /// <param name="width">The width.</param>
    /// <param name="height">The height.</param>
    /// <param name="filterRegion">The filter region, if any.</param>
    /// <returns>
    /// The rescaled image.
    /// </returns>
    public cImage ApplyScaler(InterpolationMode type, int width, int height, Rectangle? filterRegion = null) {
      if (!((IList<InterpolationMode>)INTERPOLATORS).Contains(type))
        throw new NotSupportedException(string.Format("Interpolation mode '{0}' not supported.", type));

      var startX = filterRegion == null ? 0 : Math.Max(0, filterRegion.Value.Left);
      var startY = filterRegion == null ? 0 : Math.Max(0, filterRegion.Value.Top);

      var endX = filterRegion == null ? this.Width : Math.Min(this.Width, filterRegion.Value.Right);
      var endY = filterRegion == null ? this.Height : Math.Min(this.Height, filterRegion.Value.Bottom);

      // run through scaler
      var bitmap = new Bitmap(width, height);
      using (var graphics = Graphics.FromImage(bitmap)) {

        //set the resize quality modes to high quality                
        graphics.CompositingQuality = CompositingQuality.HighQuality;
        graphics.InterpolationMode = type;
        graphics.SmoothingMode = SmoothingMode.HighQuality;

        //draw the image into the target bitmap                
        //graphics.DrawImage(source, 0, 0, result.Width, result.Height);

        // FIXME: this is a hack to prevent the microsoft bug from creating a white pixel on top and left border (see http://forums.asp.net/t/1031961.aspx/1)
        graphics.DrawImage(filterRegion == null ? this.ToBitmap() : this.ToBitmap(startX, startY, endX - startX, endY - startY), -1, -1, bitmap.Width + 1, bitmap.Height + 1);
      }
      var result = FromBitmap(bitmap);
      result.HorizontalOutOfBoundsMode = this.HorizontalOutOfBoundsMode;
      result.VerticalOutOfBoundsMode = this.VerticalOutOfBoundsMode;
      return (result);

    }

 private void bicubicaToolStripMenuItem_Click(object sender, EventArgs e)
 {
     desativaOpcoes();
     bicubicaToolStripMenuItem.Checked = true;
     suavizacao = InterpolationMode.Bicubic;
     refreshImages();
 }

		private void contextMenuFilterBicubic_Click(object sender, EventArgs e)
		{
			this.filter = InterpolationMode.Bicubic;
			this.Invalidate();
			this.contextMenuFilterNearest.Checked = this.contextMenuFilterBilinear.Checked = false;
			this.contextMenuFilterBicubic.Checked = true;
		}

        /// <summary>
        /// Interpolate between two values using the specified interpolation mode.
        /// </summary>
        /// <param name="from">The starting value to interpolate from.</param>
        /// <param name="to">The end value to interpolate to.</param>
        /// <param name="delta">The percentage of progress between the two. Ranges from 0.0 to 1.0 are acceptable.</param>
        /// <param name="mode">The interpolation mode to used, specified by the InterpolationMode enum. ex: InterpolationMode.Sigmoid</param>
        /// <returns>The current value between from and to based on the delta specified.</returns>
        public static float Interpolate(float from, float to, float delta, InterpolationMode mode)
        {
            // return the results of different methods based on which mode is specified
            if (mode == InterpolationMode.Linear)
            {
                // use linear for entire interpolation curve
                return _InterpolateLinear(from, to, delta);
            }
            else if (mode == InterpolationMode.EaseInOut)
            {
                // use sigmoid for the entire interpolation curve
                return _InterpolateSigmoid(from, to, delta);
            }
            else if (mode == InterpolationMode.EaseIn)
            {
                // use sigmoid for only the first half of the curve
                if (delta <= 0.5f)
                    return _InterpolateSigmoid(from, to, delta);
                else
                    return _InterpolateLinear(from, to, delta);
            }
            else if (mode == InterpolationMode.EaseOut)
            {
                // use sigmoid for only the last half of the curve
                if (delta >= 0.5f)
                    return _InterpolateSigmoid(from, to, delta);
                else
                    return _InterpolateLinear(from, to, delta);
            }

            // default to linear
            return _InterpolateLinear(from, to, delta);
        }

 public InterpolationModeGraphics(
     System.Drawing.Graphics graphics, InterpolationMode newMode)
 {
     _graphics = graphics;
     _oldMode = graphics.InterpolationMode;
     graphics.InterpolationMode = newMode;
 }

		public PolynomialImageTransformer(RegistrationDefinition registration, InterpolationMode interpolationMode, int polynomialDegree) : base(registration, interpolationMode)
		{
			List<PositionAssociation> associationList = registration.GetAssociationList();
			TransformationStyle arg_15_0 = registration.warpStyle;
			int num = associationList.Count;
			if (num == 2)
			{
				num++;
			}
			JamaMatrix jamaMatrix = new JamaMatrix(num, 2);
			JamaMatrix jamaMatrix2 = new JamaMatrix(num, 2);
			for (int i = 0; i < num; i++)
			{
				LatLon latLon = (i == associationList.Count) ? PolynomialImageTransformer.getThirdPosition(associationList[0].sourcePosition.pinPosition.latlon, associationList[1].sourcePosition.pinPosition.latlon, true) : associationList[i].sourcePosition.pinPosition.latlon;
				jamaMatrix.SetElement(i, 0, latLon.lon);
				jamaMatrix.SetElement(i, 1, latLon.lat);
				LatLon latLon2 = (i == associationList.Count) ? PolynomialImageTransformer.getThirdPosition(MercatorCoordinateSystem.LatLonToMercator(associationList[0].globalPosition.pinPosition.latlon), MercatorCoordinateSystem.LatLonToMercator(associationList[1].globalPosition.pinPosition.latlon), false) : MercatorCoordinateSystem.LatLonToMercator(associationList[i].globalPosition.pinPosition.latlon);
				jamaMatrix2.SetElement(i, 0, latLon2.lon);
				jamaMatrix2.SetElement(i, 1, latLon2.lat);
			}
			this.destMercatorToSourceTransformer = PolynomialImageTransformer.getPolyPointTransformer(jamaMatrix, jamaMatrix2, polynomialDegree);
			this.sourceToDestMercatorTransformer_approximate = PolynomialImageTransformer.getApproximateInverterPolyPointTransformer(jamaMatrix, jamaMatrix2, polynomialDegree);
			DownhillInverterPointTransformer flakyPointTransformer = new DownhillInverterPointTransformer(this.destMercatorToSourceTransformer, this.sourceToDestMercatorTransformer_approximate);
			IPointTransformer sourceToMercator = new RobustPointTransformer(flakyPointTransformer, this.sourceToDestMercatorTransformer_approximate);
			this.destLatLonToSourceTransformer = new LatLonToSourceTransform(this.destMercatorToSourceTransformer);
			this.sourceToDestLatLonTransformer = new SourceToLatLonTransform(sourceToMercator);
		}

		private RenderQualityStyle(string _styleName, InterpolationMode invokeImageInterpolationMode, InterpolationMode warpInterpolationMode, double hackyWarperAntialiasFactor)
		{
			this._styleName = _styleName;
			this._invokeImageInterpolationMode = invokeImageInterpolationMode;
			this._warpInterpolationMode = warpInterpolationMode;
			this._hackyWarperAntialiasFactor = hackyWarperAntialiasFactor;
		}

        public async static Task<BitmapHolder> ToBitmapHolderAsync(this Stream imageStream, Tuple<int, int> downscale, bool useDipUnits, InterpolationMode mode)
        {
            if (imageStream == null)
                return null;

            using (IRandomAccessStream image = new RandomStream(imageStream))
            {
                if (downscale != null && (downscale.Item1 > 0 || downscale.Item2 > 0))
                {
                    using (var downscaledImage = await image.ResizeImage(downscale.Item1, downscale.Item2, mode, useDipUnits).ConfigureAwait(false))
                    {
                        BitmapDecoder decoder = await BitmapDecoder.CreateAsync(downscaledImage);
                        PixelDataProvider pixelDataProvider = await decoder.GetPixelDataAsync();

                        var bytes = pixelDataProvider.DetachPixelData();
                        int[] array = new int[decoder.PixelWidth * decoder.PixelHeight];
                        CopyPixels(bytes, array);

                        return new BitmapHolder(array, (int)decoder.PixelWidth, (int)decoder.PixelHeight);
                    }
                }
                else
                {
                    BitmapDecoder decoder = await BitmapDecoder.CreateAsync(image);
                    PixelDataProvider pixelDataProvider = await decoder.GetPixelDataAsync();

                    var bytes = pixelDataProvider.DetachPixelData();
                    int[] array = new int[decoder.PixelWidth * decoder.PixelHeight];
                    CopyPixels(bytes, array);

                    return new BitmapHolder(array, (int)decoder.PixelWidth, (int)decoder.PixelHeight);
                }
            }
        }

        /// <summary>Initializes a new instance of the 
        /// <see cref="T:XNAnimation.Controllers.AnimationController" />
        /// class.
        /// </summary>
        /// <param name="skeleton">The skeleton of the model to be animated</param>
        public AnimationController(SkinnedModelBoneCollection skeleton)
        {
            this.skeleton = skeleton;
            localBonePoses = new Pose[skeleton.Count];
            skinnedBoneTransforms = new Matrix[skeleton.Count];
            skeleton[0].CopyBindPoseTo(localBonePoses);

            time = TimeSpan.Zero;
            speed = 1.0f;
            loopEnabled = true;
            playbackMode = PlaybackMode.Forward;

            blendWeight = 1.0f;

            translationInterpolation = InterpolationMode.None;
            orientationInterpolation = InterpolationMode.None;
            scaleInterpolation = InterpolationMode.None;

            crossFadeEnabled = false;
            crossFadeInterpolationAmount = 0.0f;
            crossFadeTime = TimeSpan.Zero;
            crossFadeElapsedTime = TimeSpan.Zero;

            hasFinished = false;
            isPlaying = false;
        }

        /// <summary>
        /// Creates a scaled thumbnail.
        /// </summary>
        /// <param name="width">The maximum width of the thumbnail to create.</param>
        /// <param name="height">The maximum height of the thumbnail to create.</param>
        /// <param name="interpolationMode">The Interpolation of the thumbnailing (HighQualityBicubic provides best quality)</param>
        /// <returns>A bitmap thumbnail of the source image.</returns>
        public static Bitmap CreateThumbnail(Bitmap aBitmap, int width, int height, InterpolationMode interpolationMode)
        {
            //Calculate scales
            float x = ((float)aBitmap.Width / (float)width);
            float y = ((float)aBitmap.Height / (float)height);

            float factor = Math.Max(x, y);
            if (factor < 1)
                factor = 1;

            int thWidth = (int)Math.Round((aBitmap.Width / factor), 0);
            int thHeight = (int)Math.Round((aBitmap.Height / factor), 0);

            // Set the size of the target image
            Bitmap bmpTarget = new Bitmap(thWidth, thHeight);

            Graphics grfxThumb = Graphics.FromImage(bmpTarget);
            grfxThumb.InterpolationMode = interpolationMode;

            // Draw the original image to the target image
            grfxThumb.DrawImage(aBitmap, new Rectangle(0, 0, thWidth, Convert.ToInt32(thWidth * aBitmap.Height / aBitmap.Width)));

            grfxThumb.Dispose();
            return bmpTarget;
        }

        public static Image KaMagnify(
            this Image self,
            int rate,
            InterpolationMode im = InterpolationMode.Default)
        {
            if ( !self.KaIs() )
            {
                return null;
            }

            var src = self.Clone() as Image;
            var w = src.Width * rate;
            var h = src.Height * rate;

            var res = new Bitmap( w, h );

            Graphics g = null;
            using ( g = Graphics.FromImage( res ) )
            {
                g.InterpolationMode = im;
                g.DrawImage( src, 0, 0, w, h );
            }

            return res;
        }

        public static Image ScaleByPercent(Image imgPhoto, int Percent, InterpolationMode interpolationMode)
        {
            float nPercent = ((float)Percent / 100);

            int sourceWidth = imgPhoto.Width;
            int sourceHeight = imgPhoto.Height;
            int sourceX = 0;
            int sourceY = 0;

            int destX = 0;
            int destY = 0;
            int destWidth = (int)(sourceWidth * nPercent);
            int destHeight = (int)(sourceHeight * nPercent);

            Bitmap bmPhoto = new Bitmap(destWidth, destHeight,
                                     System.Drawing.Imaging.PixelFormat.Format24bppRgb);
            bmPhoto.SetResolution(imgPhoto.HorizontalResolution,
                                    imgPhoto.VerticalResolution);

            Graphics grPhoto = Graphics.FromImage(bmPhoto);
            grPhoto.InterpolationMode = interpolationMode;

            //int memoryMB = (int)(Process.GetCurrentProcess().PagedMemorySize64 / (1024 * 1024));

            grPhoto.DrawImage(imgPhoto,
                new Rectangle(destX, destY, destWidth, destHeight),
                new Rectangle(sourceX, sourceY, sourceWidth, sourceHeight),
                GraphicsUnit.Pixel);

            grPhoto.Dispose();
            return bmPhoto;
        }

 public InterpolationModeGraphics(
     Graphics graphics, InterpolationMode newMode)
 {
     _graphics = graphics;
     _oldMode = graphics.InterpolationMode;
     graphics.InterpolationMode = newMode;
 }

		public LinearScroll(Vector2 position, Vector2 target, float duration, InterpolationMode mode = InterpolationMode.Linear)
		{
			_InitialPoint = position;
			_TargetPoint = target;
			_Method = Interpolate.GetMethod(mode);
			_Duration = duration;
		}

		public Tweener(float from, float to, float time, InterpolationMode mode = InterpolationMode.Linear)
		{
			_From = from;
			_To = to;
			_DesiredTime = time;
			_Method = Interpolate.GetMethod(mode);
		}

	// Constructor, which saves away all of the important information.
	// We assume that the lock on the "graphics" object is held by the caller.
	internal GraphicsContainer(Graphics graphics)
			{
				// Push this container onto the stack.
				this.graphics = graphics;
				next = graphics.stackTop;
				graphics.stackTop = this;

				// Save the graphics state information.
				clip = graphics.Clip;
				if(clip != null)
				{
					clip = clip.Clone();
				}
				compositingMode = graphics.CompositingMode;
				compositingQuality = graphics.CompositingQuality;
				interpolationMode = graphics.InterpolationMode;
				pageScale = graphics.PageScale;
				pageUnit = graphics.PageUnit;
				pixelOffsetMode = graphics.PixelOffsetMode;
				renderingOrigin = graphics.RenderingOrigin;
				smoothingMode = graphics.SmoothingMode;
				textContrast = graphics.TextContrast;
				textRenderingHint = graphics.TextRenderingHint;
				if (graphics.transform == null)
				{
					transform = null;
				}
				else
				{
					transform = Matrix.Clone(graphics.transform);
				}
			}

        public TextureBrush(Texture texture)
        {
            IsAsync = texture.IsAsync;
            disposeTexture = false;
            this.texture = texture;

            Color = Color4.White;
            InterpolationMode = InterpolationMode.Default;
        }

 public FontState(Font f, char g, InterpolationMode i, int r, string file)
 {
     font = f;
     glyph = g;
     interpolation = i;
     range = r;
     filename = file;
     s.Start();
 }

 public void Resize(int width, int height, InterpolationMode mode = InterpolationMode.Bicubic)
 {
     Bitmap tmp = new Bitmap(width, height);
     Graphics g = Graphics.FromImage(tmp);
     g.InterpolationMode = mode;
     g.DrawImage(Image, 0, 0, width, height);
     Image.Dispose();
     Image = tmp;
 }