/BitmapResampler.cs

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;



namespace TankIconMaker

{

    static class BitmapResampler

    {

        public struct Contributor

        {

            /// <summary>X or Y coordinate of the contributing pixel in the source.</summary>

            public int Coord;

            public double Weight;

        }



        public struct ContributorEntry

        {

            /// <summary>Number of entries in <see cref="SrcPixel"/>.</summary>

            public int SrcPixelCount;

            /// <summary>

            ///     All the pixels in the source image which contribute to the destination pixel, and the associated weight.

            ///     Some of the entries at the end of the array may be unused/unpopulated; see <see cref="SrcPixelCount"/> for

            ///     the actual count.</summary>

            public Contributor[] SrcPixel;

        }



        public static unsafe BitmapBase SizePos(BitmapBase source, double scaleWidth, double scaleHeight, int inX, int inY, int outX, int outY, int maxWidth = 0, int maxHeight = 0, Filter filter = null)

        {

            if (source.Width <= 0 || source.Height <= 0)

                return source.ToBitmapSame();



            PixelRect pureImg = source.PreciseSize(0);

            if (pureImg.Width <= 0 || pureImg.Height <= 0)

                return source.ToBitmapSame();



            int outWidth = (int) Math.Round(pureImg.Width * scaleWidth);

            int outHeight = (int) Math.Round(pureImg.Height * scaleHeight);



            if (scaleWidth == 1 && scaleHeight == 1)

            {

                //no resize needed

                if (inX != outX || inY != outY)

                {

                    BitmapBase result;

                    if (maxWidth == 0 && maxHeight == 0)

                        result = new BitmapRam(outX - inX + source.Width, outY - inY + source.Height);

                    else

                        result = new BitmapRam(Math.Min(outX - inX + source.Width, maxWidth), Math.Min(outY - inY + source.Height, maxHeight));



                    result.DrawImage(source, outX - inX, outY - inY);

                    return result;

                }

                else

                    return source.ToBitmapSame();

            }



            if (filter == null)

            {

                if (scaleWidth < 1)

                    filter = new LanczosFilter();

                else

                    filter = new MitchellFilter();

            }



            int transparentOffset;

            if (pureImg.Left != 0 || pureImg.Top != 0)

            {

                transparentOffset = pureImg.Left * 4 + pureImg.Top * source.Stride;

                // Resample looks better if transprent pixels is cropped. Especially if the image is square

                // Data+DataOffset, pureImg.Width, pureImg.Height instead of Data, Width, Height works like left-top cropping

            }

            else

            {

                transparentOffset = 0;

            }



            BitmapBase afterHorzResample, afterVertResample;



            // Horizontal resampling

            if (scaleWidth == 1)

            {

                afterHorzResample = source;

            }

            else

            {

                afterHorzResample = new BitmapRam(outWidth, pureImg.Height);

                ContributorEntry[] contrib = filter.PrecomputeResample(scaleWidth, pureImg.Width, outWidth);

                Resample1D(afterHorzResample, source, transparentOffset, contrib, outWidth, pureImg.Height, true);

                transparentOffset = 0;

            }



            // Vertical resampling

            if (scaleHeight == 1)

            {

                afterVertResample = afterHorzResample;

            }

            else

            {

                afterVertResample = new BitmapRam(outWidth, outHeight);

                ContributorEntry[] contrib = filter.PrecomputeResample(scaleHeight, pureImg.Height, outHeight);

                Resample1D(afterVertResample, afterHorzResample, transparentOffset, contrib, outHeight, outWidth, false);

            }



            BitmapBase final;

            //At this point image will be resized and moved to another BitmapBase anyway

            int drawX = outX - (int) Math.Round((inX - pureImg.Left) * scaleWidth);

            int drawY = outY - (int) Math.Round((inY - pureImg.Top) * scaleHeight);

            if (maxWidth == 0 && maxHeight == 0)

                final = new BitmapRam(Math.Max(drawX + outWidth, maxWidth), Math.Max(drawY + outHeight, maxHeight));

            else

                final = new BitmapRam(Math.Max(drawX + outWidth, maxWidth), Math.Max(drawY + outHeight, maxHeight));

            final.DrawImage(afterVertResample, drawX, drawY);

            return final;

        }



        unsafe private static void Resample1D(BitmapBase bmpDest, BitmapBase bmpSrc, int transparentOffset, ContributorEntry[] contrib, int alongSize, int crossSize, bool horz)

        {

            using (bmpSrc.UseRead())

            using (bmpDest.UseWrite())

            {

                byte* srcBytes = bmpSrc.Data + transparentOffset;

                for (int crossCoord = 0; crossCoord < crossSize; ++crossCoord)

                {

                    for (int alongCoord = 0; alongCoord < alongSize; ++alongCoord)

                    {

                        for (int channel = 0; channel < 4; ++channel)

                        {

                            double intensity = 0;

                            double wsum = 0;



                            for (int j = 0; j < contrib[alongCoord].SrcPixelCount; j++)

                            {

                                int contribCoord = contrib[alongCoord].SrcPixel[j].Coord;

                                int contribOffset = (horz ? contribCoord : crossCoord) * 4 + (horz ? crossCoord : contribCoord) * bmpSrc.Stride;

                                double weight = contrib[alongCoord].SrcPixel[j].Weight;



                                if (channel != 3)

                                    weight *= srcBytes[contribOffset + 3] / 255d;



                                if (weight == 0)

                                    continue;



                                wsum += weight;

                                intensity += srcBytes[contribOffset + channel] * weight;

                            }



                            bmpDest.Data[(horz ? alongCoord : crossCoord) * 4 + (horz ? crossCoord : alongCoord) * bmpDest.Stride + channel] =

                                (byte) Math.Min(Math.Max(intensity / wsum, byte.MinValue), byte.MaxValue);

                        }

                    }

                }

            }

        }



        /// <summary>Implements a resampling filter.</summary>

        public abstract class Filter

        {

            public double Radius { get; protected set; }

            public abstract double GetValue(double x);



            public ContributorEntry[] PrecomputeResample(double scale, int srcWidth, int destWidth)

            {

                // all variables are named as if we're scaling horizontally for the sake of readability, but the results work for both orientations

                var dest = new ContributorEntry[destWidth]; // one entry for every pixel in the resulting (destination) row of pixels

                double r = scale < 1 ? Radius / scale : Radius; // filter radius in terms of source image pixels

                double s = scale < 1 ? scale : 1; // filter scale relative to source pixels



                for (int destX = 0; destX < destWidth; destX++)

                {

                    dest[destX].SrcPixelCount = 0;

                    dest[destX].SrcPixel = new Contributor[(int) Math.Floor(2 * r + 1)];

                    double center = (destX + 0.5) / scale;

                    int srcFromX = (int) Math.Floor(center - r);

                    int srcToX = (int) Math.Ceiling(center + r);



                    for (int srcX = srcFromX; srcX <= srcToX; srcX++)

                    {

                        double weight = GetValue((center - srcX - 0.5) * s);



                        if ((weight == 0) || (srcX < 0) || (srcX >= srcWidth))

                            continue;



                        dest[destX].SrcPixel[dest[destX].SrcPixelCount].Coord = srcX;

                        dest[destX].SrcPixel[dest[destX].SrcPixelCount].Weight = weight;

                        dest[destX].SrcPixelCount++;

                    }

                }

                return dest;

            }

        }



        /// <summary>

        ///     Implements filters based on the Lanczos kernel. This includes the filters commonly known as "lanczos3" (radius

        ///     = 3) and "sinc256" (radius = 8).</summary>

        public class LanczosFilter : Filter

        {

            public LanczosFilter(int radius = 3)

            {

                Radius = radius;

            }



            private double sinc(double x)

            {

                if (x == 0)

                    return 1;

                x *= Math.PI;

                return Math.Sin(x) / x;

            }



            public override double GetValue(double x)

            {

                if (x < 0)

                    x = -x;

                if (x >= Radius)

                    return 0;

                return sinc(x) * sinc(x / Radius);

            }

        }



        /// <summary>

        ///     Implements the family of bicubic filters, specifically the Mitchell-Netravali filters with two parameters,

        ///     which is a generalization of the Keys cubic filters. All of these have a radius of 2.</summary>

        /// <remarks>

        ///     For more information see: http://www.imagemagick.org/Usage/filter/#cubics and

        ///     http://entropymine.com/imageworsener/bicubic/</remarks>

        public class BicubicFilter : Filter

        {

            public double B { get; private set; }

            public double C { get; private set; }



            /// <summary>

            ///     Constructor. See Remarks for common values for B and C. See also <see cref="CatmullRomFilter"/> and <see

            ///     cref="MitchellFilter"/>.</summary>

            /// <remarks>

            ///     <para>

            ///         Common values for B and C:</para>

            ///     <list type="bullet">

            ///         <item>Catmull_Rom, GIMP: B = 0, C = 1/2 (implemented as <see cref="CatmullRomFilter"/>)</item>

            ///         <item>Mitchell: B = 1/3, C = 1/3 (implemented as <see cref="MitchellFilter"/>)</item>

            ///         <item>Photoshop: B = 0, C = 3/4</item>

            ///         <item>B-Spline: B = 1, C = 0 (aka "spline")</item>

            ///         <item>Faststone: B = 0, C = 1</item></list></remarks>

            public BicubicFilter(double b, double c)

            {

                Radius = 2;

                B = b;

                C = c;

            }



            public override double GetValue(double x)

            {

                if (x < 0)

                    x = -x;

                double x2 = x * x;

                if (x < 1)

                    return (((12 - 9 * B - 6 * C) * (x * x2)) + ((-18 + 12 * B + 6 * C) * x2) + (6 - 2 * B)) / 6;

                if (x < 2)

                    return (((-B - 6 * C) * (x * x2)) + ((6 * B + 30 * C) * x2) + ((-12 * B - 48 * C) * x) + (8 * B + 24 * C)) / 6;

                return 0;

            }

        }



        public class CatmullRomFilter : BicubicFilter

        {

            public CatmullRomFilter()

                : base(0, 0.5)

            {

            }

        }



        public class MitchellFilter : BicubicFilter

        {

            public MitchellFilter()

                : base(1 / 3.0, 1 / 3.0)

            {

            }

        }



    }

}