/// <summary> /// Process the filter on the specified image. /// </summary> /// /// <param name="sourceData">Source image data.</param> /// <param name="destinationData">Destination image data.</param> /// protected override unsafe void ProcessFilter(UnmanagedImage sourceData, UnmanagedImage destinationData) { // get source image size int width = sourceData.Width; int height = sourceData.Height; int pixelSize = (sourceData.PixelFormat == PixelFormat.Format8bppIndexed) ? 1 : 3; int srcStride = sourceData.Stride; int dstOffset = destinationData.Stride - pixelSize * newWidth; double xFactor = (double)width / newWidth; double yFactor = (double)height / newHeight; // do the job byte *src = (byte *)sourceData.ImageData.ToPointer( ); byte *dst = (byte *)destinationData.ImageData.ToPointer( ); // coordinates of source points and cooefficiens double ox, oy, dx, dy, k1, k2; int ox1, oy1, ox2, oy2; // destination pixel values double r, g, b; // width and height decreased by 1 int ymax = height - 1; int xmax = width - 1; // temporary pointer byte *p; // check pixel format if (destinationData.PixelFormat == PixelFormat.Format8bppIndexed) { // grayscale for (int y = 0; y < newHeight; y++) { // Y coordinates oy = (double)y * yFactor - 0.5; oy1 = (int)oy; dy = oy - (double)oy1; for (int x = 0; x < newWidth; x++, dst++) { // X coordinates ox = (double)x * xFactor - 0.5f; ox1 = (int)ox; dx = ox - (double)ox1; // initial pixel value g = 0; for (int n = -1; n < 3; n++) { // get Y cooefficient k1 = Interpolation.BiCubicKernel(dy - (double)n); oy2 = oy1 + n; if (oy2 < 0) { oy2 = 0; } if (oy2 > ymax) { oy2 = ymax; } for (int m = -1; m < 3; m++) { // get X cooefficient k2 = k1 * Interpolation.BiCubicKernel((double)m - dx); ox2 = ox1 + m; if (ox2 < 0) { ox2 = 0; } if (ox2 > xmax) { ox2 = xmax; } g += k2 * src[oy2 * srcStride + ox2]; } } *dst = (byte)Math.Max(0, Math.Min(255, g)); } dst += dstOffset; } } else { // RGB for (int y = 0; y < newHeight; y++) { // Y coordinates oy = (double)y * yFactor - 0.5f; oy1 = (int)oy; dy = oy - (double)oy1; for (int x = 0; x < newWidth; x++, dst += 3) { // X coordinates ox = (double)x * xFactor - 0.5f; ox1 = (int)ox; dx = ox - (double)ox1; // initial pixel value r = g = b = 0; for (int n = -1; n < 3; n++) { // get Y cooefficient k1 = Interpolation.BiCubicKernel(dy - (double)n); oy2 = oy1 + n; if (oy2 < 0) { oy2 = 0; } if (oy2 > ymax) { oy2 = ymax; } for (int m = -1; m < 3; m++) { // get X cooefficient k2 = k1 * Interpolation.BiCubicKernel((double)m - dx); ox2 = ox1 + m; if (ox2 < 0) { ox2 = 0; } if (ox2 > xmax) { ox2 = xmax; } // get pixel of original image p = src + oy2 * srcStride + ox2 * 3; r += k2 * p[RGB.R]; g += k2 * p[RGB.G]; b += k2 * p[RGB.B]; } } dst[RGB.R] = (byte)Math.Max(0, Math.Min(255, r)); dst[RGB.G] = (byte)Math.Max(0, Math.Min(255, g)); dst[RGB.B] = (byte)Math.Max(0, Math.Min(255, b)); } dst += dstOffset; } } }
// Apply filter public Bitmap Apply(Bitmap srcImg) { // get source image size int width = srcImg.Width; int height = srcImg.Height; if (angle == 0) { // just clone the image return(AForge.Imaging.Image.Clone(srcImg)); } double angleRad = -angle * Math.PI / 180; double angleCos = Math.Cos(angleRad); double angleSin = Math.Sin(angleRad); double halfWidth = (double)width / 2; double halfHeight = (double)height / 2; double halfNewWidth, halfNewHeight; int newWidth, newHeight; if (keepSize) { halfNewWidth = halfWidth; halfNewHeight = halfHeight; newWidth = width; newHeight = height; } else { // rotate corners double cx1 = halfWidth * angleCos; double cy1 = halfWidth * angleSin; double cx2 = halfWidth * angleCos - halfHeight * angleSin; double cy2 = halfWidth * angleSin + halfHeight * angleCos; double cx3 = -halfHeight * angleSin; double cy3 = halfHeight * angleCos; double cx4 = 0; double cy4 = 0; halfNewWidth = Math.Max(Math.Max(cx1, cx2), Math.Max(cx3, cx4)) - Math.Min(Math.Min(cx1, cx2), Math.Min(cx3, cx4)); halfNewHeight = Math.Max(Math.Max(cy1, cy2), Math.Max(cy3, cy4)) - Math.Min(Math.Min(cy1, cy2), Math.Min(cy3, cy4)); newWidth = (int)(halfNewWidth * 2 + 0.5); newHeight = (int)(halfNewHeight * 2 + 0.5); } // pixel format PixelFormat fmt = (srcImg.PixelFormat == PixelFormat.Format8bppIndexed) ? PixelFormat.Format8bppIndexed : PixelFormat.Format24bppRgb; // lock source bitmap data BitmapData srcData = srcImg.LockBits( new Rectangle(0, 0, width, height), ImageLockMode.ReadOnly, fmt); // create new image Bitmap dstImg = (fmt == PixelFormat.Format8bppIndexed) ? AForge.Imaging.Image.CreateGrayscaleImage(newWidth, newHeight) : new Bitmap(newWidth, newHeight, fmt); // lock destination bitmap data BitmapData dstData = dstImg.LockBits( new Rectangle(0, 0, newWidth, newHeight), ImageLockMode.ReadWrite, fmt); int srcStride = srcData.Stride; int dstOffset = dstData.Stride - ((fmt == PixelFormat.Format8bppIndexed) ? newWidth : newWidth * 3); byte fillR = fillColor.R; byte fillG = fillColor.G; byte fillB = fillColor.B; // do the job unsafe { byte *src = (byte *)srcData.Scan0.ToPointer(); byte *dst = (byte *)dstData.Scan0.ToPointer(); switch (method) { case InterpolationMethod.NearestNeighbor: { // ------------------------------------------- // rotate using nearest neighbor interpolation // ------------------------------------------- double cx, cy; int ox, oy; byte * p; if (fmt == PixelFormat.Format8bppIndexed) { // grayscale cy = -halfNewHeight; for (int y = 0; y < newHeight; y++) { cx = -halfNewWidth; for (int x = 0; x < newWidth; x++, dst++) { // coordinate of the nearest point ox = (int)(angleCos * cx + angleSin * cy + halfWidth); oy = (int)(-angleSin * cx + angleCos * cy + halfHeight); if ((ox < 0) || (oy < 0) || (ox >= width) || (oy >= height)) { *dst = fillG; } else { *dst = src[oy * srcStride + ox]; } cx++; } cy++; dst += dstOffset; } } else { // RGB cy = -halfNewHeight; for (int y = 0; y < newHeight; y++) { cx = -halfNewWidth; for (int x = 0; x < newWidth; x++, dst += 3) { // coordinate of the nearest point ox = (int)(angleCos * cx + angleSin * cy + halfWidth); oy = (int)(-angleSin * cx + angleCos * cy + halfHeight); if ((ox < 0) || (oy < 0) || (ox >= width) || (oy >= height)) { dst[RGB.R] = fillR; dst[RGB.G] = fillG; dst[RGB.B] = fillB; } else { p = src + oy * srcStride + ox * 3; dst[RGB.R] = p[RGB.R]; dst[RGB.G] = p[RGB.G]; dst[RGB.B] = p[RGB.B]; } cx++; } cy++; dst += dstOffset; } } break; } case InterpolationMethod.Bilinear: { // ------------------------------------ // rotate using bilinear interpolation // ------------------------------------ double cx, cy; float ox, oy, dx1, dy1, dx2, dy2; int ox1, oy1, ox2, oy2; int ymax = height - 1; int xmax = width - 1; byte v1, v2; byte * p1, p2, p3, p4; if (fmt == PixelFormat.Format8bppIndexed) { // grayscale cy = -halfNewHeight; for (int y = 0; y < newHeight; y++) { cx = -halfNewWidth; for (int x = 0; x < newWidth; x++, dst++) { ox = (float)(angleCos * cx + angleSin * cy + halfWidth); oy = (float)(-angleSin * cx + angleCos * cy + halfHeight); // top-left coordinate ox1 = (int)ox; oy1 = (int)oy; if ((ox1 < 0) || (oy1 < 0) || (ox1 >= width) || (oy1 >= height)) { *dst = fillG; } else { // bottom-right coordinate ox2 = (ox1 == xmax) ? ox1 : ox1 + 1; oy2 = (oy1 == ymax) ? oy1 : oy1 + 1; if ((dx1 = ox - (float)ox1) < 0) { dx1 = 0; } dx2 = 1.0f - dx1; if ((dy1 = oy - (float)oy1) < 0) { dy1 = 0; } dy2 = 1.0f - dy1; p1 = src + oy1 * srcStride; p2 = src + oy2 * srcStride; // interpolate using 4 points v1 = (byte)(dx2 * p1[ox1] + dx1 * p1[ox2]); v2 = (byte)(dx2 * p2[ox1] + dx1 * p2[ox2]); *dst = (byte)(dy2 * v1 + dy1 * v2); } cx++; } cy++; dst += dstOffset; } } else { // RGB cy = -halfNewHeight; for (int y = 0; y < newHeight; y++) { cx = -halfNewWidth; for (int x = 0; x < newWidth; x++, dst += 3) { ox = (float)(angleCos * cx + angleSin * cy + halfWidth); oy = (float)(-angleSin * cx + angleCos * cy + halfHeight); // top-left coordinate ox1 = (int)ox; oy1 = (int)oy; if ((ox1 < 0) || (oy1 < 0) || (ox1 >= width) || (oy1 >= height)) { dst[RGB.R] = fillR; dst[RGB.G] = fillG; dst[RGB.B] = fillB; } else { // bottom-right coordinate ox2 = (ox1 == xmax) ? ox1 : ox1 + 1; oy2 = (oy1 == ymax) ? oy1 : oy1 + 1; if ((dx1 = ox - (float)ox1) < 0) { dx1 = 0; } dx2 = 1.0f - dx1; if ((dy1 = oy - (float)oy1) < 0) { dy1 = 0; } dy2 = 1.0f - dy1; // get four points p1 = p2 = src + oy1 * srcStride; p1 += ox1 * 3; p2 += ox2 * 3; p3 = p4 = src + oy2 * srcStride; p3 += ox1 * 3; p4 += ox2 * 3; // interpolate using 4 points // red v1 = (byte)(dx2 * p1[RGB.R] + dx1 * p2[RGB.R]); v2 = (byte)(dx2 * p3[RGB.R] + dx1 * p4[RGB.R]); dst[RGB.R] = (byte)(dy2 * v1 + dy1 * v2); // green v1 = (byte)(dx2 * p1[RGB.G] + dx1 * p2[RGB.G]); v2 = (byte)(dx2 * p3[RGB.G] + dx1 * p4[RGB.G]); dst[RGB.G] = (byte)(dy2 * v1 + dy1 * v2); // blue v1 = (byte)(dx2 * p1[RGB.B] + dx1 * p2[RGB.B]); v2 = (byte)(dx2 * p3[RGB.B] + dx1 * p4[RGB.B]); dst[RGB.B] = (byte)(dy2 * v1 + dy1 * v2); } cx++; } cy++; dst += dstOffset; } } break; } case InterpolationMethod.Bicubic: { // ---------------------------------- // rotate using bicubic interpolation // ---------------------------------- double cx, cy; float ox, oy, dx, dy, k1, k2; float r, g, b; int ox1, oy1, ox2, oy2; int ymax = height - 1; int xmax = width - 1; byte * p; if (fmt == PixelFormat.Format8bppIndexed) { // grayscale cy = -halfNewHeight; for (int y = 0; y < newHeight; y++) { cx = -halfNewWidth; for (int x = 0; x < newWidth; x++, dst++) { ox = (float)(angleCos * cx + angleSin * cy + halfWidth); oy = (float)(-angleSin * cx + angleCos * cy + halfHeight); ox1 = (int)ox; oy1 = (int)oy; if ((ox1 < 0) || (oy1 < 0) || (ox1 >= width) || (oy1 >= height)) { *dst = fillG; } else { dx = ox - (float)ox1; dy = oy - (float)oy1; g = 0; for (int n = -1; n < 3; n++) { k1 = Interpolation.BiCubicKernel(dy - (float)n); oy2 = oy1 + n; if (oy2 < 0) { oy2 = 0; } if (oy2 > ymax) { oy2 = ymax; } for (int m = -1; m < 3; m++) { k2 = k1 * Interpolation.BiCubicKernel((float)m - dx); ox2 = ox1 + m; if (ox2 < 0) { ox2 = 0; } if (ox2 > xmax) { ox2 = xmax; } g += k2 * src[oy2 * srcStride + ox2]; } } *dst = (byte)g; } cx++; } cy++; dst += dstOffset; } } else { // RGB cy = -halfNewHeight; for (int y = 0; y < newHeight; y++) { cx = -halfNewWidth; for (int x = 0; x < newWidth; x++, dst += 3) { ox = (float)(angleCos * cx + angleSin * cy + halfWidth); oy = (float)(-angleSin * cx + angleCos * cy + halfHeight); ox1 = (int)ox; oy1 = (int)oy; if ((ox1 < 0) || (oy1 < 0) || (ox1 >= width) || (oy1 >= height)) { dst[RGB.R] = fillR; dst[RGB.G] = fillG; dst[RGB.B] = fillB; } else { dx = ox - (float)ox1; dy = oy - (float)oy1; r = g = b = 0; for (int n = -1; n < 3; n++) { k1 = Interpolation.BiCubicKernel(dy - (float)n); oy2 = oy1 + n; if (oy2 < 0) { oy2 = 0; } if (oy2 > ymax) { oy2 = ymax; } for (int m = -1; m < 3; m++) { k2 = k1 * Interpolation.BiCubicKernel((float)m - dx); ox2 = ox1 + m; if (ox2 < 0) { ox2 = 0; } if (ox2 > xmax) { ox2 = xmax; } // get pixel of original image p = src + oy2 * srcStride + ox2 * 3; r += k2 * p[RGB.R]; g += k2 * p[RGB.G]; b += k2 * p[RGB.B]; } } dst[RGB.R] = (byte)r; dst[RGB.G] = (byte)g; dst[RGB.B] = (byte)b; } cx++; } cy++; dst += dstOffset; } } break; } } } // unlock both images dstImg.UnlockBits(dstData); srcImg.UnlockBits(srcData); return(dstImg); }
/// <summary> /// Process the filter on the specified image. /// </summary> /// /// <param name="sourceData">Source image data.</param> /// <param name="destinationData">Destination image data.</param> /// protected override unsafe void ProcessFilter(UnmanagedImage sourceData, UnmanagedImage destinationData) { // get source image size int width = sourceData.Width; int height = sourceData.Height; double oldXradius = (double)(width - 1) / 2; double oldYradius = (double)(height - 1) / 2; // get destination image size int newWidth = destinationData.Width; int newHeight = destinationData.Height; double newXradius = (double)(newWidth - 1) / 2; double newYradius = (double)(newHeight - 1) / 2; // angle's sine and cosine double angleRad = -angle * Math.PI / 180; double angleCos = Math.Cos(angleRad); double angleSin = Math.Sin(angleRad); int srcStride = sourceData.Stride; int dstOffset = destinationData.Stride - ((destinationData.PixelFormat == PixelFormat.Format8bppIndexed) ? newWidth : newWidth * 3); // fill values byte fillR = fillColor.R; byte fillG = fillColor.G; byte fillB = fillColor.B; // do the job byte *src = (byte *)sourceData.ImageData.ToPointer( ); byte *dst = (byte *)destinationData.ImageData.ToPointer( ); // destination pixel's coordinate relative to image center double cx, cy; // coordinates of source points and cooefficiens double ox, oy, dx, dy, k1, k2; int ox1, oy1, ox2, oy2; // destination pixel values double r, g, b; // width and height decreased by 1 int ymax = height - 1; int xmax = width - 1; // temporary pointer byte *p; if (destinationData.PixelFormat == PixelFormat.Format8bppIndexed) { // grayscale cy = -newYradius; for (int y = 0; y < newHeight; y++) { cx = -newXradius; for (int x = 0; x < newWidth; x++, dst++) { // coordinates of source point ox = angleCos * cx + angleSin * cy + oldXradius; oy = -angleSin * cx + angleCos * cy + oldYradius; ox1 = (int)ox; oy1 = (int)oy; // validate source pixel's coordinates if ((ox1 < 0) || (oy1 < 0) || (ox1 >= width) || (oy1 >= height)) { // fill destination image with filler *dst = fillG; } else { dx = ox - (double)ox1; dy = oy - (double)oy1; // initial pixel value g = 0; for (int n = -1; n < 3; n++) { // get Y cooefficient k1 = Interpolation.BiCubicKernel(dy - (double)n); oy2 = oy1 + n; if (oy2 < 0) { oy2 = 0; } if (oy2 > ymax) { oy2 = ymax; } for (int m = -1; m < 3; m++) { // get X cooefficient k2 = k1 * Interpolation.BiCubicKernel((double)m - dx); ox2 = ox1 + m; if (ox2 < 0) { ox2 = 0; } if (ox2 > xmax) { ox2 = xmax; } g += k2 * src[oy2 * srcStride + ox2]; } } *dst = (byte)Math.Max(0, Math.Min(255, g)); } cx++; } cy++; dst += dstOffset; } } else { // RGB cy = -newYradius; for (int y = 0; y < newHeight; y++) { cx = -newXradius; for (int x = 0; x < newWidth; x++, dst += 3) { // coordinates of source point ox = angleCos * cx + angleSin * cy + oldXradius; oy = -angleSin * cx + angleCos * cy + oldYradius; ox1 = (int)ox; oy1 = (int)oy; // validate source pixel's coordinates if ((ox1 < 0) || (oy1 < 0) || (ox1 >= width) || (oy1 >= height)) { // fill destination image with filler dst[RGB.R] = fillR; dst[RGB.G] = fillG; dst[RGB.B] = fillB; } else { dx = ox - (float)ox1; dy = oy - (float)oy1; // initial pixel value r = g = b = 0; for (int n = -1; n < 3; n++) { // get Y cooefficient k1 = Interpolation.BiCubicKernel(dy - (float)n); oy2 = oy1 + n; if (oy2 < 0) { oy2 = 0; } if (oy2 > ymax) { oy2 = ymax; } for (int m = -1; m < 3; m++) { // get X cooefficient k2 = k1 * Interpolation.BiCubicKernel((float)m - dx); ox2 = ox1 + m; if (ox2 < 0) { ox2 = 0; } if (ox2 > xmax) { ox2 = xmax; } // get pixel of original image p = src + oy2 * srcStride + ox2 * 3; r += k2 * p[RGB.R]; g += k2 * p[RGB.G]; b += k2 * p[RGB.B]; } } dst[RGB.R] = (byte)Math.Max(0, Math.Min(255, r)); dst[RGB.G] = (byte)Math.Max(0, Math.Min(255, g)); dst[RGB.B] = (byte)Math.Max(0, Math.Min(255, b)); } cx++; } cy++; dst += dstOffset; } } }
/// <summary> /// Process the filter on the specified image. /// </summary> /// /// <param name="sourceData">Source image data.</param> /// <param name="destinationData">Destination image data.</param> /// protected override unsafe void ProcessFilter(UnmanagedImage sourceData, UnmanagedImage destinationData) { // get source image size int width = sourceData.Width; int height = sourceData.Height; int pixelSize = sourceData.PixelSize; int srcStride = sourceData.Stride; int dstOffset = destinationData.Offset; double xFactor = (double)width / newWidth; double yFactor = (double)height / newHeight; // do the job byte *src = (byte *)sourceData.ImageData.ToPointer(); byte *dst = (byte *)destinationData.ImageData.ToPointer(); // width and height decreased by 1 int ymax = height - 1; int xmax = width - 1; // check pixel format if (destinationData.PixelFormat == PixelFormat.Format8bppIndexed) { // grayscale for (int y = 0; y < newHeight; y++) { // Y coordinates double oy = (double)y * yFactor - 0.5; int oy1 = (int)oy; double dy = oy - (double)oy1; for (int x = 0; x < newWidth; x++, dst++) { // X coordinates double ox = (double)x * xFactor - 0.5f; int ox1 = (int)ox; double dx = ox - (double)ox1; // initial pixel value double g = 0; for (int n = -1; n < 3; n++) { // get Y cooefficient double k1 = Interpolation.BiCubicKernel(dy - (double)n); int oy2 = oy1 + n; if (oy2 < 0) { oy2 = 0; } if (oy2 > ymax) { oy2 = ymax; } for (int m = -1; m < 3; m++) { // get X cooefficient double k2 = k1 * Interpolation.BiCubicKernel((double)m - dx); int ox2 = ox1 + m; if (ox2 < 0) { ox2 = 0; } if (ox2 > xmax) { ox2 = xmax; } g += k2 * src[oy2 * srcStride + ox2]; } } *dst = (byte)Math.Max(0, Math.Min(255, g)); } dst += dstOffset; } } else if (pixelSize == 3) { // RGB for (int y = 0; y < newHeight; y++) { // Y coordinates double oy = (double)y * yFactor - 0.5f; int oy1 = (int)oy; double dy = oy - (double)oy1; for (int x = 0; x < newWidth; x++, dst += 3) { // X coordinates double ox = (double)x * xFactor - 0.5f; int ox1 = (int)ox; double dx = ox - (double)ox1; // initial pixel value double r = 0; double g = 0; double b = 0; for (int n = -1; n < 3; n++) { // get Y cooefficient double k1 = Interpolation.BiCubicKernel(dy - (double)n); int oy2 = oy1 + n; if (oy2 < 0) { oy2 = 0; } if (oy2 > ymax) { oy2 = ymax; } for (int m = -1; m < 3; m++) { // get X cooefficient double k2 = k1 * Interpolation.BiCubicKernel((double)m - dx); int ox2 = ox1 + m; if (ox2 < 0) { ox2 = 0; } if (ox2 > xmax) { ox2 = xmax; } // get pixel of original image byte *p = src + oy2 * srcStride + ox2 * 3; r += k2 * p[RGB.R]; g += k2 * p[RGB.G]; b += k2 * p[RGB.B]; } } dst[RGB.R] = (byte)Math.Max(0, Math.Min(255, r)); dst[RGB.G] = (byte)Math.Max(0, Math.Min(255, g)); dst[RGB.B] = (byte)Math.Max(0, Math.Min(255, b)); } dst += dstOffset; } } else if (pixelSize == 4) { // ARGB for (int y = 0; y < newHeight; y++) { // Y coordinates double oy = (double)y * yFactor - 0.5f; int oy1 = (int)oy; double dy = oy - (double)oy1; for (int x = 0; x < newWidth; x++, dst += 3) { // X coordinates double ox = (double)x * xFactor - 0.5f; int ox1 = (int)ox; double dx = ox - (double)ox1; // initial pixel value double a = 0; double r = 0; double g = 0; double b = 0; for (int n = -1; n < 3; n++) { // get Y cooefficient double k1 = Interpolation.BiCubicKernel(dy - (double)n); int oy2 = oy1 + n; if (oy2 < 0) { oy2 = 0; } if (oy2 > ymax) { oy2 = ymax; } for (int m = -1; m < 3; m++) { // get X cooefficient double k2 = k1 * Interpolation.BiCubicKernel((double)m - dx); int ox2 = ox1 + m; if (ox2 < 0) { ox2 = 0; } if (ox2 > xmax) { ox2 = xmax; } // get pixel of original image byte *p = src + oy2 * srcStride + ox2 * 3; a += k2 * p[RGB.A]; r += k2 * p[RGB.R]; g += k2 * p[RGB.G]; b += k2 * p[RGB.B]; } } dst[RGB.A] = (byte)Math.Max(0, Math.Min(255, a)); dst[RGB.R] = (byte)Math.Max(0, Math.Min(255, r)); dst[RGB.G] = (byte)Math.Max(0, Math.Min(255, g)); dst[RGB.B] = (byte)Math.Max(0, Math.Min(255, b)); } dst += dstOffset; } } else { throw new InvalidOperationException("Execution should never reach here."); } }
public unsafe Bitmap Apply(Bitmap srcImg) { int width = srcImg.Width; int height = srcImg.Height; if ((this.newWidth == width) && (this.newHeight == height)) { return(GodLesZ.Library.Imaging.Image.Clone(srcImg)); } PixelFormat format = (srcImg.PixelFormat == PixelFormat.Format8bppIndexed) ? PixelFormat.Format8bppIndexed : PixelFormat.Format24bppRgb; BitmapData bitmapdata = srcImg.LockBits(new Rectangle(0, 0, width, height), ImageLockMode.ReadOnly, format); Bitmap bitmap = (format == PixelFormat.Format8bppIndexed) ? GodLesZ.Library.Imaging.Image.CreateGrayscaleImage(this.newWidth, this.newHeight) : new Bitmap(this.newWidth, this.newHeight, format); BitmapData data2 = bitmap.LockBits(new Rectangle(0, 0, this.newWidth, this.newHeight), ImageLockMode.ReadWrite, format); int num3 = (format == PixelFormat.Format8bppIndexed) ? 1 : 3; int stride = bitmapdata.Stride; int num5 = data2.Stride - (num3 * this.newWidth); float num6 = ((float)width) / ((float)this.newWidth); float num7 = ((float)height) / ((float)this.newHeight); byte * numPtr = (byte *)bitmapdata.Scan0.ToPointer(); byte * numPtr2 = (byte *)data2.Scan0.ToPointer(); switch (this.method) { case InterpolationMethod.NearestNeighbor: for (int i = 0; i < this.newHeight; i++) { int num9 = (int)(i * num7); for (int j = 0; j < this.newWidth; j++) { int num8 = (int)(j * num6); byte *numPtr3 = (numPtr + (num9 * stride)) + (num8 * num3); int num12 = 0; while (num12 < num3) { numPtr2[0] = numPtr3[0]; num12++; numPtr2++; numPtr3++; } } numPtr2 += num5; } break; case InterpolationMethod.Bilinear: { int num23 = height - 1; int num24 = width - 1; for (int k = 0; k < this.newHeight; k++) { float num14 = k * num7; int num20 = (int)num14; int num22 = (num20 == num23) ? num20 : (num20 + 1); float num16 = num14 - num20; float num18 = 1f - num16; byte *numPtr4 = numPtr + (num20 * stride); byte *numPtr5 = numPtr + (num22 * stride); for (int m = 0; m < this.newWidth; m++) { float num13 = m * num6; int num19 = (int)num13; int num21 = (num19 == num24) ? num19 : (num19 + 1); float num15 = num13 - num19; float num17 = 1f - num15; byte *numPtr6 = numPtr4 + (num19 * num3); byte *numPtr7 = numPtr4 + (num21 * num3); byte *numPtr8 = numPtr5 + (num19 * num3); byte *numPtr9 = numPtr5 + (num21 * num3); int num29 = 0; while (num29 < num3) { byte num25 = (byte)((num17 * numPtr6[0]) + (num15 * numPtr7[0])); byte num26 = (byte)((num17 * numPtr8[0]) + (num15 * numPtr9[0])); numPtr2[0] = (byte)((num18 * num25) + (num16 * num26)); num29++; numPtr2++; numPtr6++; numPtr7++; numPtr8++; numPtr9++; } } numPtr2 += num5; } break; } case InterpolationMethod.Bicubic: { float num30; float num31; float num32; float num33; float num34; float num35; float num37; int num39; int num40; int num41; int num42; int num43 = height - 1; int num44 = width - 1; if (format != PixelFormat.Format8bppIndexed) { for (int num49 = 0; num49 < this.newHeight; num49++) { num31 = (num49 * num7) - 0.5f; num40 = (int)num31; num33 = num31 - num40; int num50 = 0; while (num50 < this.newWidth) { float num38; num30 = (num50 * num6) - 0.5f; num39 = (int)num30; num32 = num30 - num39; float num36 = num37 = num38 = 0f; for (int num51 = -1; num51 < 3; num51++) { num34 = Interpolation.BiCubicKernel(num33 - num51); num42 = num40 + num51; if (num42 < 0) { num42 = 0; } if (num42 > num43) { num42 = num43; } for (int num52 = -1; num52 < 3; num52++) { num35 = num34 * Interpolation.BiCubicKernel(num52 - num32); num41 = num39 + num52; if (num41 < 0) { num41 = 0; } if (num41 > num44) { num41 = num44; } byte *numPtr10 = (numPtr + (num42 * stride)) + (num41 * 3); num36 += num35 * numPtr10[2]; num37 += num35 * numPtr10[1]; num38 += num35 * numPtr10[0]; } } numPtr2[2] = (byte)num36; numPtr2[1] = (byte)num37; numPtr2[0] = (byte)num38; num50++; numPtr2 += 3; } numPtr2 += num5; } break; } for (int n = 0; n < this.newHeight; n++) { num31 = (n * num7) - 0.5f; num40 = (int)num31; num33 = num31 - num40; int num46 = 0; while (num46 < this.newWidth) { num30 = (num46 * num6) - 0.5f; num39 = (int)num30; num32 = num30 - num39; num37 = 0f; for (int num47 = -1; num47 < 3; num47++) { num34 = Interpolation.BiCubicKernel(num33 - num47); num42 = num40 + num47; if (num42 < 0) { num42 = 0; } if (num42 > num43) { num42 = num43; } for (int num48 = -1; num48 < 3; num48++) { num35 = num34 * Interpolation.BiCubicKernel(num48 - num32); num41 = num39 + num48; if (num41 < 0) { num41 = 0; } if (num41 > num44) { num41 = num44; } num37 += num35 * numPtr[(num42 * stride) + num41]; } } numPtr2[0] = (byte)num37; num46++; numPtr2++; } numPtr2 += num5; } break; } } bitmap.UnlockBits(data2); srcImg.UnlockBits(bitmapdata); return(bitmap); }
protected unsafe override void ProcessFilter(UnmanagedImage sourceData, UnmanagedImage destinationData) { int width = sourceData.Width; int height = sourceData.Height; int num = (sourceData.PixelFormat == PixelFormat.Format8bppIndexed) ? 1 : 3; int stride = sourceData.Stride; int num2 = destinationData.Stride - num * newWidth; double num3 = (double)width / (double)newWidth; double num4 = (double)height / (double)newHeight; byte * ptr = (byte *)sourceData.ImageData.ToPointer(); byte * ptr2 = (byte *)destinationData.ImageData.ToPointer(); int num5 = height - 1; int num6 = width - 1; if (destinationData.PixelFormat == PixelFormat.Format8bppIndexed) { for (int i = 0; i < newHeight; i++) { double num7 = (double)i * num4 - 0.5; int num8 = (int)num7; double num9 = num7 - (double)num8; int num10 = 0; while (num10 < newWidth) { double num11 = (double)num10 * num3 - 0.5; int num12 = (int)num11; double num13 = num11 - (double)num12; double num14 = 0.0; for (int j = -1; j < 3; j++) { double num15 = Interpolation.BiCubicKernel(num9 - (double)j); int num16 = num8 + j; if (num16 < 0) { num16 = 0; } if (num16 > num5) { num16 = num5; } for (int k = -1; k < 3; k++) { double num17 = num15 * Interpolation.BiCubicKernel((double)k - num13); int num18 = num12 + k; if (num18 < 0) { num18 = 0; } if (num18 > num6) { num18 = num6; } num14 += num17 * (double)(int)ptr[num16 * stride + num18]; } } *ptr2 = (byte)System.Math.Max(0.0, System.Math.Min(255.0, num14)); num10++; ptr2++; } ptr2 += num2; } return; } for (int l = 0; l < newHeight; l++) { double num7 = (double)l * num4 - 0.5; int num8 = (int)num7; double num9 = num7 - (double)num8; int num19 = 0; while (num19 < newWidth) { double num11 = (double)num19 * num3 - 0.5; int num12 = (int)num11; double num13 = num11 - (double)num12; double num14; double num20; double num21 = num14 = (num20 = 0.0); for (int m = -1; m < 3; m++) { double num15 = Interpolation.BiCubicKernel(num9 - (double)m); int num16 = num8 + m; if (num16 < 0) { num16 = 0; } if (num16 > num5) { num16 = num5; } for (int n = -1; n < 3; n++) { double num17 = num15 * Interpolation.BiCubicKernel((double)n - num13); int num18 = num12 + n; if (num18 < 0) { num18 = 0; } if (num18 > num6) { num18 = num6; } byte *ptr3 = ptr + (long)num16 * (long)stride + (long)num18 * 3L; num21 += num17 * (double)(int)ptr3[2]; num14 += num17 * (double)(int)ptr3[1]; num20 += num17 * (double)(int)(*ptr3); } } ptr2[2] = (byte)System.Math.Max(0.0, System.Math.Min(255.0, num21)); ptr2[1] = (byte)System.Math.Max(0.0, System.Math.Min(255.0, num14)); *ptr2 = (byte)System.Math.Max(0.0, System.Math.Min(255.0, num20)); num19++; ptr2 += 3; } ptr2 += num2; } }
protected unsafe override void ProcessFilter(UnmanagedImage sourceData, UnmanagedImage destinationData) { int width = sourceData.Width; int height = sourceData.Height; double num = (double)(width - 1) / 2.0; double num2 = (double)(height - 1) / 2.0; int width2 = destinationData.Width; int height2 = destinationData.Height; double num3 = (double)(width2 - 1) / 2.0; double num4 = (double)(height2 - 1) / 2.0; double num5 = (0.0 - angle) * System.Math.PI / 180.0; double num6 = System.Math.Cos(num5); double num7 = System.Math.Sin(num5); int stride = sourceData.Stride; int num8 = destinationData.Stride - ((destinationData.PixelFormat == PixelFormat.Format8bppIndexed) ? width2 : (width2 * 3)); byte r = fillColor.R; byte g = fillColor.G; byte b = fillColor.B; byte * ptr = (byte *)sourceData.ImageData.ToPointer(); byte * ptr2 = (byte *)destinationData.ImageData.ToPointer(); int num9 = height - 1; int num10 = width - 1; double num11; if (destinationData.PixelFormat == PixelFormat.Format8bppIndexed) { num11 = 0.0 - num4; for (int i = 0; i < height2; i++) { double num12 = 0.0 - num3; int num13 = 0; while (num13 < width2) { double num14 = num6 * num12 + num7 * num11 + num; double num15 = (0.0 - num7) * num12 + num6 * num11 + num2; int num16 = (int)num14; int num17 = (int)num15; if (num16 < 0 || num17 < 0 || num16 >= width || num17 >= height) { *ptr2 = g; } else { double num18 = num14 - (double)num16; double num19 = num15 - (double)num17; double num20 = 0.0; for (int j = -1; j < 3; j++) { double num21 = Interpolation.BiCubicKernel(num19 - (double)j); int num22 = num17 + j; if (num22 < 0) { num22 = 0; } if (num22 > num9) { num22 = num9; } for (int k = -1; k < 3; k++) { double num23 = num21 * Interpolation.BiCubicKernel((double)k - num18); int num24 = num16 + k; if (num24 < 0) { num24 = 0; } if (num24 > num10) { num24 = num10; } num20 += num23 * (double)(int)ptr[num22 * stride + num24]; } } *ptr2 = (byte)System.Math.Max(0.0, System.Math.Min(255.0, num20)); } num12 += 1.0; num13++; ptr2++; } num11 += 1.0; ptr2 += num8; } return; } num11 = 0.0 - num4; for (int l = 0; l < height2; l++) { double num12 = 0.0 - num3; int num25 = 0; while (num25 < width2) { double num14 = num6 * num12 + num7 * num11 + num; double num15 = (0.0 - num7) * num12 + num6 * num11 + num2; int num16 = (int)num14; int num17 = (int)num15; if (num16 < 0 || num17 < 0 || num16 >= width || num17 >= height) { ptr2[2] = r; ptr2[1] = g; *ptr2 = b; } else { double num18 = num14 - (double)(float)num16; double num19 = num15 - (double)(float)num17; double num20; double num26; double num27 = num20 = (num26 = 0.0); for (int m = -1; m < 3; m++) { double num21 = Interpolation.BiCubicKernel(num19 - (double)(float)m); int num22 = num17 + m; if (num22 < 0) { num22 = 0; } if (num22 > num9) { num22 = num9; } for (int n = -1; n < 3; n++) { double num23 = num21 * Interpolation.BiCubicKernel((double)(float)n - num18); int num24 = num16 + n; if (num24 < 0) { num24 = 0; } if (num24 > num10) { num24 = num10; } byte *ptr3 = ptr + (long)num22 * (long)stride + (long)num24 * 3L; num27 += num23 * (double)(int)ptr3[2]; num20 += num23 * (double)(int)ptr3[1]; num26 += num23 * (double)(int)(*ptr3); } } ptr2[2] = (byte)System.Math.Max(0.0, System.Math.Min(255.0, num27)); ptr2[1] = (byte)System.Math.Max(0.0, System.Math.Min(255.0, num20)); *ptr2 = (byte)System.Math.Max(0.0, System.Math.Min(255.0, num26)); } num12 += 1.0; num25++; ptr2 += 3; } num11 += 1.0; ptr2 += num8; } }
// Apply filter public Bitmap Apply(Bitmap srcImg) { // get source image size int width = srcImg.Width; int height = srcImg.Height; if ((newWidth == width) && (newHeight == height)) { // just clone the image return(AForge.Imaging.Image.Clone(srcImg)); } PixelFormat fmt = (srcImg.PixelFormat == PixelFormat.Format8bppIndexed) ? PixelFormat.Format8bppIndexed : PixelFormat.Format24bppRgb; // lock source bitmap data BitmapData srcData = srcImg.LockBits( new Rectangle(0, 0, width, height), ImageLockMode.ReadOnly, fmt); // create new image Bitmap dstImg = (fmt == PixelFormat.Format8bppIndexed) ? AForge.Imaging.Image.CreateGrayscaleImage(newWidth, newHeight) : new Bitmap(newWidth, newHeight, fmt); // lock destination bitmap data BitmapData dstData = dstImg.LockBits( new Rectangle(0, 0, newWidth, newHeight), ImageLockMode.ReadWrite, fmt); int pixelSize = (fmt == PixelFormat.Format8bppIndexed) ? 1 : 3; int srcStride = srcData.Stride; int dstOffset = dstData.Stride - pixelSize * newWidth; float xFactor = (float)width / newWidth; float yFactor = (float)height / newHeight; // do the job unsafe { byte *src = (byte *)srcData.Scan0.ToPointer(); byte *dst = (byte *)dstData.Scan0.ToPointer(); switch (method) { case InterpolationMethod.NearestNeighbor: { // ------------------------------------------- // resize using nearest neighbor interpolation // ------------------------------------------- int ox, oy; byte *p; // for each line for (int y = 0; y < newHeight; y++) { // Y coordinate of the nearest point oy = (int)(y * yFactor); // for each pixel for (int x = 0; x < newWidth; x++) { // X coordinate of the nearest point ox = (int)(x * xFactor); p = src + oy * srcStride + ox * pixelSize; for (int i = 0; i < pixelSize; i++, dst++, p++) { *dst = *p; } } dst += dstOffset; } break; } case InterpolationMethod.Bilinear: { // ------------------------------------ // resize using bilinear interpolation // ------------------------------------ float ox, oy, dx1, dy1, dx2, dy2; int ox1, oy1, ox2, oy2; int ymax = height - 1; int xmax = width - 1; byte v1, v2; byte *tp1, tp2; byte *p1, p2, p3, p4; // for each line for (int y = 0; y < newHeight; y++) { // Y coordinates oy = (float)y * yFactor; oy1 = (int)oy; oy2 = (oy1 == ymax) ? oy1 : oy1 + 1; dy1 = oy - (float)oy1; dy2 = 1.0f - dy1; // get temp pointers tp1 = src + oy1 * srcStride; tp2 = src + oy2 * srcStride; // for each pixel for (int x = 0; x < newWidth; x++) { // X coordinates ox = (float)x * xFactor; ox1 = (int)ox; ox2 = (ox1 == xmax) ? ox1 : ox1 + 1; dx1 = ox - (float)ox1; dx2 = 1.0f - dx1; // get four points p1 = tp1 + ox1 * pixelSize; p2 = tp1 + ox2 * pixelSize; p3 = tp2 + ox1 * pixelSize; p4 = tp2 + ox2 * pixelSize; // interpolate using 4 points for (int i = 0; i < pixelSize; i++, dst++, p1++, p2++, p3++, p4++) { v1 = (byte)(dx2 * (*p1) + dx1 * (*p2)); v2 = (byte)(dx2 * (*p3) + dx1 * (*p4)); *dst = (byte)(dy2 * v1 + dy1 * v2); } } dst += dstOffset; } break; } case InterpolationMethod.Bicubic: { // ---------------------------------- // resize using bicubic interpolation // ---------------------------------- float ox, oy, dx, dy, k1, k2; float r, g, b; int ox1, oy1, ox2, oy2; int ymax = height - 1; int xmax = width - 1; byte *p; if (fmt == PixelFormat.Format8bppIndexed) { // grayscale for (int y = 0; y < newHeight; y++) { // Y coordinates oy = (float)y * yFactor - 0.5f; oy1 = (int)oy; dy = oy - (float)oy1; for (int x = 0; x < newWidth; x++, dst++) { // X coordinates ox = (float)x * xFactor - 0.5f; ox1 = (int)ox; dx = ox - (float)ox1; g = 0; for (int n = -1; n < 3; n++) { k1 = Interpolation.BiCubicKernel(dy - (float)n); oy2 = oy1 + n; if (oy2 < 0) { oy2 = 0; } if (oy2 > ymax) { oy2 = ymax; } for (int m = -1; m < 3; m++) { k2 = k1 * Interpolation.BiCubicKernel((float)m - dx); ox2 = ox1 + m; if (ox2 < 0) { ox2 = 0; } if (ox2 > xmax) { ox2 = xmax; } g += k2 * src[oy2 * srcStride + ox2]; } } *dst = (byte)g; } dst += dstOffset; } } else { // RGB for (int y = 0; y < newHeight; y++) { // Y coordinates oy = (float)y * yFactor - 0.5f; oy1 = (int)oy; dy = oy - (float)oy1; for (int x = 0; x < newWidth; x++, dst += 3) { // X coordinates ox = (float)x * xFactor - 0.5f; ox1 = (int)ox; dx = ox - (float)ox1; r = g = b = 0; for (int n = -1; n < 3; n++) { k1 = Interpolation.BiCubicKernel(dy - (float)n); oy2 = oy1 + n; if (oy2 < 0) { oy2 = 0; } if (oy2 > ymax) { oy2 = ymax; } for (int m = -1; m < 3; m++) { k2 = k1 * Interpolation.BiCubicKernel((float)m - dx); ox2 = ox1 + m; if (ox2 < 0) { ox2 = 0; } if (ox2 > xmax) { ox2 = xmax; } // get pixel of original image p = src + oy2 * srcStride + ox2 * 3; r += k2 * p[RGB.R]; g += k2 * p[RGB.G]; b += k2 * p[RGB.B]; } } dst[RGB.R] = (byte)r; dst[RGB.G] = (byte)g; dst[RGB.B] = (byte)b; } dst += dstOffset; } } break; } } } // unlock both images dstImg.UnlockBits(dstData); srcImg.UnlockBits(srcData); return(dstImg); }
public override void OnProcess() { _outputSize = new Size() { Width = (int)(Source.Width * Ratio), Height = (int)(Source.Height * Ratio), }; // get source image size int width = Source.Width; int height = Source.Height; double xFactor = (double)width / _outputSize.Width; double yFactor = (double)height / _outputSize.Height; // coordinates of source points and cooefficiens double ox, oy, dx, dy, k1, k2; int ox1, oy1, ox2, oy2; // destination pixel values double r, g, b; // width and height decreased by 1 int ymax = height - 1; int xmax = width - 1; for (int y = 0; y < _outputSize.Height; y++) { // Y coordinates oy = (double)y * yFactor - 0.5f; oy1 = (int)oy; dy = oy - (double)oy1; for (int x = 0; x < _outputSize.Width; x++) { // X coordinates ox = (double)x * xFactor - 0.5f; ox1 = (int)ox; dx = ox - (double)ox1; // initial pixel value r = g = b = 0; for (int n = -1; n < 3; n++) { // get Y cooefficient k1 = Interpolation.BiCubicKernel(dy - (double)n); oy2 = oy1 + n; if (oy2 < 0) { oy2 = 0; } if (oy2 > ymax) { oy2 = ymax; } for (int m = -1; m < 3; m++) { // get X cooefficient k2 = k1 * Interpolation.BiCubicKernel((double)m - dx); ox2 = ox1 + m; if (ox2 < 0) { ox2 = 0; } if (ox2 > xmax) { ox2 = xmax; } r += k2 * Source.Map[oy2][ox2].R; g += k2 * Source.Map[oy2][ox2].G; b += k2 * Source.Map[oy2][ox2].B; } } Source.Map[y][x] = new Pixel(255, (byte)Math.Max(0, Math.Min(255, r)), (byte)Math.Max(0, Math.Min(255, g)), (byte)Math.Max(0, Math.Min(255, b))); } } Source.Width = _outputSize.Width; Source.Height = _outputSize.Height; }
public unsafe Bitmap Apply(Bitmap srcImg) { double num8; double num9; int num10; int num11; int width = srcImg.Width; int height = srcImg.Height; if (this.angle == 0f) { return(GodLesZ.Library.Imaging.Image.Clone(srcImg)); } double d = (-this.angle * 3.1415926535897931) / 180.0; double num4 = Math.Cos(d); double num5 = Math.Sin(d); double num6 = ((double)width) / 2.0; double num7 = ((double)height) / 2.0; if (this.keepSize) { num8 = num6; num9 = num7; num10 = width; num11 = height; } else { double num12 = num6 * num4; double num13 = num6 * num5; double num14 = (num6 * num4) - (num7 * num5); double num15 = (num6 * num5) + (num7 * num4); double num16 = -num7 * num5; double num17 = num7 * num4; double num18 = 0.0; double num19 = 0.0; num8 = Math.Max(Math.Max(num12, num14), Math.Max(num16, num18)) - Math.Min(Math.Min(num12, num14), Math.Min(num16, num18)); num9 = Math.Max(Math.Max(num13, num15), Math.Max(num17, num19)) - Math.Min(Math.Min(num13, num15), Math.Min(num17, num19)); num10 = (int)((num8 * 2.0) + 0.5); num11 = (int)((num9 * 2.0) + 0.5); } PixelFormat format = (srcImg.PixelFormat == PixelFormat.Format8bppIndexed) ? PixelFormat.Format8bppIndexed : PixelFormat.Format24bppRgb; BitmapData bitmapdata = srcImg.LockBits(new Rectangle(0, 0, width, height), ImageLockMode.ReadOnly, format); Bitmap bitmap = (format == PixelFormat.Format8bppIndexed) ? GodLesZ.Library.Imaging.Image.CreateGrayscaleImage(num10, num11) : new Bitmap(num10, num11, format); BitmapData data2 = bitmap.LockBits(new Rectangle(0, 0, num10, num11), ImageLockMode.ReadWrite, format); int stride = bitmapdata.Stride; int num21 = data2.Stride - ((format == PixelFormat.Format8bppIndexed) ? num10 : (num10 * 3)); byte r = this.fillColor.R; byte g = this.fillColor.G; byte b = this.fillColor.B; byte * numPtr = (byte *)bitmapdata.Scan0.ToPointer(); byte * numPtr2 = (byte *)data2.Scan0.ToPointer(); switch (this.method) { case InterpolationMethod.NearestNeighbor: double num25; double num26; int num27; int num28; if (format != PixelFormat.Format8bppIndexed) { num26 = -num9; for (int j = 0; j < num11; j++) { num25 = -num8; int num32 = 0; while (num32 < num10) { num27 = (int)(((num4 * num25) + (num5 * num26)) + num6); num28 = (int)(((-num5 * num25) + (num4 * num26)) + num7); if (((num27 < 0) || (num28 < 0)) || ((num27 >= width) || (num28 >= height))) { numPtr2[2] = r; numPtr2[1] = g; numPtr2[0] = b; } else { byte *numPtr3 = (numPtr + (num28 * stride)) + (num27 * 3); numPtr2[2] = numPtr3[2]; numPtr2[1] = numPtr3[1]; numPtr2[0] = numPtr3[0]; } num25++; num32++; numPtr2 += 3; } num26++; numPtr2 += num21; } break; } num26 = -num9; for (int i = 0; i < num11; i++) { num25 = -num8; int num30 = 0; while (num30 < num10) { num27 = (int)(((num4 * num25) + (num5 * num26)) + num6); num28 = (int)(((-num5 * num25) + (num4 * num26)) + num7); if (((num27 < 0) || (num28 < 0)) || ((num27 >= width) || (num28 >= height))) { numPtr2[0] = g; } else { numPtr2[0] = numPtr[(num28 * stride) + num27]; } num25++; num30++; numPtr2++; } num26++; numPtr2 += num21; } break; case InterpolationMethod.Bilinear: { double num33; double num34; float num35; float num36; float num37; float num38; float num39; float num40; int num41; int num42; int num43; int num44; byte num47; byte num48; byte * numPtr4; byte * numPtr5; int num45 = height - 1; int num46 = width - 1; if (format != PixelFormat.Format8bppIndexed) { num34 = -num9; for (int m = 0; m < num11; m++) { num33 = -num8; int num52 = 0; while (num52 < num10) { num35 = (float)(((num4 * num33) + (num5 * num34)) + num6); num36 = (float)(((-num5 * num33) + (num4 * num34)) + num7); num41 = (int)num35; num42 = (int)num36; if (((num41 < 0) || (num42 < 0)) || ((num41 >= width) || (num42 >= height))) { numPtr2[2] = r; numPtr2[1] = g; numPtr2[0] = b; } else { byte *numPtr7; num43 = (num41 == num46) ? num41 : (num41 + 1); num44 = (num42 == num45) ? num42 : (num42 + 1); num37 = num35 - num41; if (num37 < 0f) { num37 = 0f; } num39 = 1f - num37; num38 = num36 - num42; if (num38 < 0f) { num38 = 0f; } num40 = 1f - num38; numPtr4 = numPtr5 = numPtr + (num42 * stride); numPtr4 += num41 * 3; numPtr5 += num43 * 3; byte *numPtr6 = numPtr7 = numPtr + (num44 * stride); numPtr6 += num41 * 3; numPtr7 += num43 * 3; num47 = (byte)((num39 * numPtr4[2]) + (num37 * numPtr5[2])); num48 = (byte)((num39 * numPtr6[2]) + (num37 * numPtr7[2])); numPtr2[2] = (byte)((num40 * num47) + (num38 * num48)); num47 = (byte)((num39 * numPtr4[1]) + (num37 * numPtr5[1])); num48 = (byte)((num39 * numPtr6[1]) + (num37 * numPtr7[1])); numPtr2[1] = (byte)((num40 * num47) + (num38 * num48)); num47 = (byte)((num39 * numPtr4[0]) + (num37 * numPtr5[0])); num48 = (byte)((num39 * numPtr6[0]) + (num37 * numPtr7[0])); numPtr2[0] = (byte)((num40 * num47) + (num38 * num48)); } num33++; num52++; numPtr2 += 3; } num34++; numPtr2 += num21; } break; } num34 = -num9; for (int k = 0; k < num11; k++) { num33 = -num8; int num50 = 0; while (num50 < num10) { num35 = (float)(((num4 * num33) + (num5 * num34)) + num6); num36 = (float)(((-num5 * num33) + (num4 * num34)) + num7); num41 = (int)num35; num42 = (int)num36; if (((num41 < 0) || (num42 < 0)) || ((num41 >= width) || (num42 >= height))) { numPtr2[0] = g; } else { num43 = (num41 == num46) ? num41 : (num41 + 1); num44 = (num42 == num45) ? num42 : (num42 + 1); num37 = num35 - num41; if (num37 < 0f) { num37 = 0f; } num39 = 1f - num37; num38 = num36 - num42; if (num38 < 0f) { num38 = 0f; } num40 = 1f - num38; numPtr4 = numPtr + (num42 * stride); numPtr5 = numPtr + (num44 * stride); num47 = (byte)((num39 * numPtr4[num41]) + (num37 * numPtr4[num43])); num48 = (byte)((num39 * numPtr5[num41]) + (num37 * numPtr5[num43])); numPtr2[0] = (byte)((num40 * num47) + (num38 * num48)); } num33++; num50++; numPtr2++; } num34++; numPtr2 += num21; } break; } case InterpolationMethod.Bicubic: { double num53; double num54; float num55; float num56; float num57; float num58; float num59; float num60; float num62; int num64; int num65; int num66; int num67; int num68 = height - 1; int num69 = width - 1; if (format != PixelFormat.Format8bppIndexed) { num54 = -num9; for (int num74 = 0; num74 < num11; num74++) { num53 = -num8; int num75 = 0; while (num75 < num10) { num55 = (float)(((num4 * num53) + (num5 * num54)) + num6); num56 = (float)(((-num5 * num53) + (num4 * num54)) + num7); num64 = (int)num55; num65 = (int)num56; if (((num64 < 0) || (num65 < 0)) || ((num64 >= width) || (num65 >= height))) { numPtr2[2] = r; numPtr2[1] = g; numPtr2[0] = b; } else { float num63; num57 = num55 - num64; num58 = num56 - num65; float num61 = num62 = num63 = 0f; for (int num76 = -1; num76 < 3; num76++) { num59 = Interpolation.BiCubicKernel(num58 - num76); num67 = num65 + num76; if (num67 < 0) { num67 = 0; } if (num67 > num68) { num67 = num68; } for (int num77 = -1; num77 < 3; num77++) { num60 = num59 * Interpolation.BiCubicKernel(num77 - num57); num66 = num64 + num77; if (num66 < 0) { num66 = 0; } if (num66 > num69) { num66 = num69; } byte *numPtr8 = (numPtr + (num67 * stride)) + (num66 * 3); num61 += num60 * numPtr8[2]; num62 += num60 * numPtr8[1]; num63 += num60 * numPtr8[0]; } } numPtr2[2] = (byte)num61; numPtr2[1] = (byte)num62; numPtr2[0] = (byte)num63; } num53++; num75++; numPtr2 += 3; } num54++; numPtr2 += num21; } break; } num54 = -num9; for (int n = 0; n < num11; n++) { num53 = -num8; int num71 = 0; while (num71 < num10) { num55 = (float)(((num4 * num53) + (num5 * num54)) + num6); num56 = (float)(((-num5 * num53) + (num4 * num54)) + num7); num64 = (int)num55; num65 = (int)num56; if (((num64 < 0) || (num65 < 0)) || ((num64 >= width) || (num65 >= height))) { numPtr2[0] = g; } else { num57 = num55 - num64; num58 = num56 - num65; num62 = 0f; for (int num72 = -1; num72 < 3; num72++) { num59 = Interpolation.BiCubicKernel(num58 - num72); num67 = num65 + num72; if (num67 < 0) { num67 = 0; } if (num67 > num68) { num67 = num68; } for (int num73 = -1; num73 < 3; num73++) { num60 = num59 * Interpolation.BiCubicKernel(num73 - num57); num66 = num64 + num73; if (num66 < 0) { num66 = 0; } if (num66 > num69) { num66 = num69; } num62 += num60 * numPtr[(num67 * stride) + num66]; } } numPtr2[0] = (byte)num62; } num53++; num71++; numPtr2++; } num54++; numPtr2 += num21; } break; } } bitmap.UnlockBits(data2); srcImg.UnlockBits(bitmapdata); return(bitmap); }