Bitmap myBitmap = new Bitmap("Spiral.png");

Rectangle expansionRectangle = new Rectangle(135, 10,
myBitmap.Width, myBitmap.Height);

Rectangle compressionRectangle = new Rectangle(300, 10,
myBitmap.Width / 2, myBitmap.Height / 2);

myGraphics.DrawImage(myBitmap, 10, 10);
myGraphics.DrawImage(myBitmap, expansionRectangle);
myGraphics.DrawImage(myBitmap, compressionRectangle);

static int ComputePixel(float x, float y, out float x1, out float y1)
{
double r, nn;

if (x == 0 && y == 0)
{
x1 = x;
y1 = y;
return 1;
}

nn = Math.Sqrt(x * x + y * y);
r = (Math.Abs(x) > Math.Abs(y)) ? Math.Abs(nn / x) : Math.Abs(nn / y);

x1 = (float)(r * x);
y1 = (float)(r * y);

return 1;
}

static Color GetPixelColorInterpolated(ref Bitmap image, float x, float y)
{
int xi = (int)(x);
if (x < 0) xi--;
int yi = (int)(y);
if (y < 0) yi--;

if (xi < -1 || xi >= image.Width || yi < -1 || yi >= image.Height)
{
return GetPixelColorWithOverflow(ref image, -999, -999);
}

//get four neighbouring pixels
if ((xi + 1) < image.Width && xi >= 0 && (yi + 1) < image.Height && yi >= 0)
{
ushort wt1 = (ushort)((x – xi) * 256.0f), wt2 = (ushort)((y – yi) * 256.0f);
ushort wd = (ushort)(wt1 * wt2 >> 8);
ushort wb = (ushort)(wt1 – wd);
ushort wc = (ushort)(wt2 – wd);
ushort wa = (ushort)(256 – wt1 – wc);
ushort wrr, wgg, wbb;

Color clr = image.GetPixel(xi, yi);
wbb = (ushort)(wa * clr.B); wgg = (ushort)(wa * clr.G); wrr = (ushort)(wa * clr.R);

clr = image.GetPixel(xi + 1, yi);
wbb += (ushort)(wb * clr.B); wgg += (ushort)(wb * clr.G); wrr += (ushort)(wb * clr.R);

clr = image.GetPixel(xi, yi + 1);
wbb += (ushort)(wc * clr.B); wgg += (ushort)(wc * clr.G); wrr += (ushort)(wc * clr.R);

clr = image.GetPixel(xi + 1, yi + 1);
wbb += (ushort)(wd * clr.B); wgg += (ushort)(wd * clr.G); wrr += (ushort)(wd * clr.R);

return Color.FromArgb(255, wrr >> 8, wgg >> 8, wbb >> 8);
}
else
{
float t1 = x – xi, t2 = y – yi;
float d = t1 * t2;
float b = t1 – d;
float c = t2 – d;
float a = 1 – t1 – c;

Color rgb11, rgb21, rgb12, rgb22;
rgb11 = GetPixelColorWithOverflow(ref image, xi, yi);
rgb21 = GetPixelColorWithOverflow(ref image, xi + 1, yi);
rgb12 = GetPixelColorWithOverflow(ref image, xi, yi + 1);
rgb22 = GetPixelColorWithOverflow(ref image, xi + 1, yi + 1);

//calculate linear interpolation
return Color.FromArgb(255,
(byte)(a * rgb11.R + b * rgb21.R + c * rgb12.R + d * rgb22.R),
(byte)(a * rgb11.G + b * rgb21.G + c * rgb12.G + d * rgb22.G),
(byte)(a * rgb11.B + b * rgb21.B + c * rgb12.B + d * rgb22.B));
}
}

static Color GetPixelColorWithOverflow(ref Bitmap image, long x, long y)
{
if (!IsInside(ref image, x, y))
{
return Color.FromArgb(255, 255, 255, 255);
}

return image.GetPixel((int)x, (int)y);
}

static bool IsInside(ref Bitmap image, long x, long y)
{
return (0 <= y && y < image.Height && 0 <= x && x < image.Width);
}

private void transformEllipseToolStripMenuItem_Click(object sender, EventArgs e)
{
Bitmap image = new Bitmap("D:\\PSD\\info1.jpg");

int x, y;
float x1, y1;
float fx, fy, xmid, ymid, ar;
Bitmap image2 = new Bitmap(image);

xmid = (float)(image.Width / 2.0);
ymid = (float)(image.Height / 2.0);
ar = (float)(image.Height) / (float)(image.Width);
for (y = 0; y < image.Height; y++)
{
for (x = 0; x < image.Width; x++)
{
ComputePixel(ar * (x – xmid), y – ymid, out fx, out fy);
x1 = xmid + fx / ar;
y1 = ymid + fy;

image2.SetPixel(x, y, GetPixelColorInterpolated(ref image, x1, y1));
}
}

this.pictureBox1.Image = image2;
}