My useless image manipulation program

using pointers to edit pictures blows

from Stardock Forums

So i got an idea in class a while ago and thought it would be a good learning experience.  Completely useless, but fun to stare at.

what it does:

takes a picture (jpg format), then makes it look wavy using a sin wave.

It started out pretty easy until i realized that using GetPixel and SetPixel is slow as balls.  The alternative was editing memory directly :(

btw, if anyone knows how to edit a picture using pointers vertically instead of horizonatally, please let me know.  My brain shutdown when i tried to figure this out, so im just rotating the image and changing it again.  I know the theory of how to do it but the code eludes me.

 

heres the fun code:

Code: c#
  3.         private void makeMovingImage()
  4.         {
  5.             Image temp;
  6.             imageArray = new Bitmap[num];
  7.             for (int x = 0; x < num; x++)
  8.             {
  9.                 temp = image2;
  10.                 imageArray[x] = makeNewImage(temp);
  11.                 temp = new Bitmap(imageArray[x]);
  12.                 temp.RotateFlip(RotateFlipType.Rotate90FlipNone);
  13.                 temp = makeNewImage(temp);
  14.                 temp.RotateFlip(RotateFlipType.Rotate270FlipNone);
  15.                 imageArray[x] = new Bitmap(temp);
  16.                 ctr += .2;
  17.             }
  18.         }
  21.         private unsafe Bitmap makeNewImage(Image newimg)
  22.         {
  23.             Bitmap image = new Bitmap(newimg);
  24.             Bitmap newImage = new Bitmap(image.Width + 20, image.Height);
  25.             Rectangle imageRect = new Rectangle(0, 0, image.Width, image.Height);
  26.             Rectangle newImageRect = new Rectangle(0, 0, newImage.Width, newImage.Height);
  27.             BitmapData imageData = image.LockBits(imageRect, ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
  28.             BitmapData newImageData = newImage.LockBits(newImageRect, ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
  29.             int oldSize = imageData.Stride * image.Height;
  30.             int newSize = newImageData.Stride * newImage.Height;
  31.             byte[] oldData = new byte[oldSize];
  32.             byte[] newData = new byte[newSize];
  33.             System.Runtime.InteropServices.Marshal.Copy(imageData.Scan0, oldData, 0, oldSize);
  34.             System.Runtime.InteropServices.Marshal.Copy(newImageData.Scan0, newData, 0, newSize);
  35.             byte* oldPointer = (byte*)imageData.Scan0;
  36.             byte* newPointer = (byte*)newImageData.Scan0;
  37.             int offset = 0;
  38.             int pixel = 0;
  40.             for (int y = 0; y < image.Height; y++)
  41.             {
  42.                 offset = (int)Math.Round((10 * Math.Sin(ctr)));
  44.                 ctr += .2;
  45.                 offset += 10;
  47.                 for (int counter = 0; counter < offset; counter++)
  48.                 {
  49.                     newPointer[0] = 0;
  50.                     newPointer[1] = 255;
  51.                     newPointer[2] = 0;
  52.                     newPointer += 3;
  53.                     pixel++;
  54.                 }
  55.                 for (int x = 0; x < image.Width; x++)
  56.                 {
  57.                     newPointer[0] = oldPointer[0];
  58.                     newPointer[1] = oldPointer[1];
  59.                     newPointer[2] = oldPointer[2];
  60.                     oldPointer += 3;
  61.                     newPointer += 3;
  62.                     pixel++;
  63.                 }
  64.                 for (int counter = pixel; counter < newImage.Width; counter++)
  65.                 {
  66.                     newPointer[0] = 0;
  67.                     newPointer[1] = 255;
  68.                     newPointer[2] = 0;
  69.                     newPointer += 3;
  70.                 }
  71.                 pixel = 0;
  72.                 oldPointer += imageData.Stride - (imageData.Width * 3);
  73.                 newPointer += newImageData.Stride - (newImageData.Width * 3);
  74.             }
  75.             image.UnlockBits(imageData);
  76.             newImage.UnlockBits(newImageData);
  78.             return newImage;
  79.         }

I use this code with a kinda double buffered form to show a moving picture. if anyone wants the full source code, i have no problems sending it, i just dont want to show off my horrible coding practices

 

will post pics after i finish my visual studio 2008 install

 

moving image

 

8,517 views 0 replies