Пример #1
0
        //Uses pointers to scan through the bitmap a LOT faster
        //Make sure to check "Allow unsafe code" in the project properties
        public static unsafe Region getRegionFast(Bitmap bitmap, Color transparencyKey, int tolerance)
        {
            //Bounds
            GraphicsUnit unit = GraphicsUnit.Pixel;
            RectangleF boundsF = bitmap.GetBounds(ref unit);
            Rectangle bounds = new Rectangle((int)boundsF.Left, (int)boundsF.Top,
                                             (int)boundsF.Width, (int)boundsF.Height);

            int yMax = (int)boundsF.Height;
            int xMax = (int)boundsF.Width;

            //Transparency Color
            if (tolerance <= 0) tolerance = 1;

            //Lock Image
            BitmapData bitmapData = bitmap.LockBits(bounds, ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb);
            uint* pixelPtr = (uint*)bitmapData.Scan0.ToPointer();

            //Stores all the rectangles for the region
            GraphicsPath path = new GraphicsPath();

            //Scan the image, looking for lines that are NOT the transperancy color
            for (int y = 0; y < yMax; y++)
            {
                byte* basePos = (byte*)pixelPtr;

                for (int x = 0; x < xMax; x++, pixelPtr++)
                {
                    //Go on with the loop if its transperancy color

                    if (colorsMatch(pixelPtr, transparencyKey, tolerance))
                        continue;

                    //Line start
                    int x0 = x;

                    //Find the next transparency colored pixel
                    while (x < xMax && !colorsMatch(pixelPtr, transparencyKey, tolerance))
                    {
                        x++;
                        pixelPtr++;
                    }

                    //Add the line as a rectangle
                    path.AddRectangle(new Rectangle(x0, y, x - x0, 1));
                }

                //Go to next line
                pixelPtr = (uint*)(basePos + bitmapData.Stride);
            }

            //Create the Region
            Region outputRegion = new Region(path);

            //Clean Up
            path.Dispose();
            bitmap.UnlockBits(bitmapData);

            return outputRegion;
        }
Пример #2
0
        // creates a new "DRAFT" sample image
        private Bitmap CreateDraftImage()
        {
            string sText = "DRAFT";

            Bitmap destination = new Bitmap(400, 400);
            using (Graphics g = Graphics.FromImage(destination))
            {
                GraphicsUnit units = GraphicsUnit.Pixel;

                g.Clear(Color.White);
                StringFormat stringFormat = new StringFormat();
                stringFormat.Alignment = StringAlignment.Center;
                stringFormat.LineAlignment = StringAlignment.Center;

                g.DrawString(sText, new Font(
                    "Arial", 
                    90, 
                    FontStyle.Bold,
                    GraphicsUnit.Pixel), 
                    new SolidBrush(
                        Color.FromArgb(64, Color.Black)),
                        destination.GetBounds(ref units),
                        stringFormat);
            }

            return destination;
        }
Пример #3
0
		public void Bitmap1bitFeatures ()
		{
			string sInFile = getInFile ("bitmaps/1bit.png");
			using (Bitmap bmp = new Bitmap (sInFile)) {
				GraphicsUnit unit = GraphicsUnit.World;
				RectangleF rect = bmp.GetBounds (ref unit);

				Assert.AreEqual (PixelFormat.Format1bppIndexed, bmp.PixelFormat);

				Assert.AreEqual (0, bmp.Palette.Flags, "Palette.Flags");
				Assert.AreEqual (2, bmp.Palette.Entries.Length, "Palette.Entries");
				Assert.AreEqual (-16777216, bmp.Palette.Entries[0].ToArgb (), "Palette.0");
				Assert.AreEqual (-1, bmp.Palette.Entries[1].ToArgb (), "Palette.1");

				Assert.AreEqual (288, bmp.Width, "bmp.Width");
				Assert.AreEqual (384, bmp.Height, "bmp.Height");

				Assert.AreEqual (0, rect.X, "rect.X");
				Assert.AreEqual (0, rect.Y, "rect.Y");
				Assert.AreEqual (288, rect.Width, "rect.Width");
				Assert.AreEqual (384, rect.Height, "rect.Height");

				Assert.AreEqual (288, bmp.Size.Width, "bmp.Size.Width");
				Assert.AreEqual (384, bmp.Size.Height, "bmp.Size.Height");
			}
		}
Пример #4
0
        /// <summary>
        /// Create an instance from an existing bitmap
        /// </summary>
        /// <param name="bitmap">The bitmap</param>
        public UnsafeBitmap(Bitmap bitmap)
        {
            this.bitmap = bitmap;

            GraphicsUnit unit = GraphicsUnit.Pixel;
            RectangleF bounds = bitmap.GetBounds(ref unit);

            size = new Point((int)bounds.Width, (int)bounds.Height);
        }
Пример #5
0
        public Object(Bitmap i, string n, Point location)
        {
            image = i;
            name = n;

            GraphicsUnit units = GraphicsUnit.Point;
            RectangleF boundingBox = image.GetBounds(ref units);

            physics = new Physics(location, boundingBox);
        }
Пример #6
0
 public static Image drawImageFromHex(char hex)
 {
     Image img = new Bitmap(20, 20);
     using (Graphics gfx = Graphics.FromImage(img))
     {
         GraphicsUnit gfu = GraphicsUnit.Pixel;
         gfx.FillRectangle(new SolidBrush(Color.Red), img.GetBounds(ref gfu));
         gfx.DrawString(hex.ToString(), new Font("Arial", 10), new SolidBrush(Color.Black), Point.Empty);
     }
     return img;
 }
Пример #7
0
        public static Icon SmallQuestionIcon()
        {
            Bitmap bitmap = new Bitmap(16, 16);
            Graphics g = Graphics.FromImage(bitmap);
            GraphicsUnit unit = GraphicsUnit.Pixel;

            g.FillRectangle(Brushes.White, bitmap.GetBounds(ref unit));
            g.DrawString("?",new Font("Arial",9),Brushes.Black,new PointF(2,2));
            g.Flush();

            return Make(Image.FromHbitmap(bitmap.GetHbitmap()), 16, true);
        }
Пример #8
0
		public BitmapWidget (System.Drawing.Bitmap b)
		{
			this.b = b;
			GraphicsUnit unit = GraphicsUnit.Pixel;

			//
			// Quick hack to make stuff not too large
			//
			RectangleF bounds = b.GetBounds (ref unit);
			bounds.Height = System.Math.Min (bounds.Height, 600);
			bounds.Width = System.Math.Min (bounds.Width, 400);
			SetSizeRequest ((int) bounds.Width, (int) bounds.Height);
		}
        public BitmapWidget(System.Drawing.Bitmap b)
        {
            this.b = b;
            GraphicsUnit unit = GraphicsUnit.Pixel;

            //
            // Quick hack to make stuff not too large
            //
            RectangleF bounds = b.GetBounds(ref unit);

            bounds.Height = System.Math.Min(bounds.Height, 600);
            bounds.Width  = System.Math.Min(bounds.Width, 400);
            SetSizeRequest((int)bounds.Width, (int)bounds.Height);
        }
Пример #10
0
		/* Checks bitmap features on a know 1bbp bitmap */
		/* Checks bitmap features on a know 1bbp bitmap */
		private void Bitmap8bitsFeatures (string filename)
		{
			using (Bitmap bmp = new Bitmap (filename)) {
				GraphicsUnit unit = GraphicsUnit.World;
				RectangleF rect = bmp.GetBounds (ref unit);

				Assert.AreEqual (PixelFormat.Format8bppIndexed, bmp.PixelFormat);
				Assert.AreEqual (110, bmp.Width, "bmp.Width");
				Assert.AreEqual (100, bmp.Height, "bmp.Height");

				Assert.AreEqual (0, rect.X, "rect.X");
				Assert.AreEqual (0, rect.Y, "rect.Y");
				Assert.AreEqual (110, rect.Width, "rect.Width");
				Assert.AreEqual (100, rect.Height, "rect.Height");

				Assert.AreEqual (110, bmp.Size.Width, "bmp.Size.Width");
				Assert.AreEqual (100, bmp.Size.Height, "bmp.Size.Height");
			}
		}
Пример #11
0
		public void Bitmap1bitFeatures ()
		{
			string sInFile = getInFile ("bitmaps/almogaver1bit.bmp");
			using (Bitmap bmp = new Bitmap (sInFile)) {
				GraphicsUnit unit = GraphicsUnit.World;
				RectangleF rect = bmp.GetBounds (ref unit);

				// ??? why is it a 4bbp ?
				Assert.AreEqual (PixelFormat.Format4bppIndexed, bmp.PixelFormat);
				Assert.AreEqual (173, bmp.Width, "bmp.Width");
				Assert.AreEqual (183, bmp.Height, "bmp.Height");

				Assert.AreEqual (0, rect.X, "rect.X");
				Assert.AreEqual (0, rect.Y, "rect.Y");
				Assert.AreEqual (173, rect.Width, "rect.Width");
				Assert.AreEqual (183, rect.Height, "rect.Height");

				Assert.AreEqual (173, bmp.Size.Width, "bmp.Size.Width");
				Assert.AreEqual (183, bmp.Size.Height, "bmp.Size.Height");
			}
		}
Пример #12
0
		public void Bitmap8bbpIndexedGreyscaleFeatures ()
		{
			string sInFile = getInFile ("bitmaps/nature-greyscale.jpg");
			using (Bitmap bmp = new Bitmap (sInFile)) {
				GraphicsUnit unit = GraphicsUnit.World;
				RectangleF rect = bmp.GetBounds (ref unit);

				Assert.AreEqual (PixelFormat.Format8bppIndexed, bmp.PixelFormat, "PixelFormat");
				Assert.AreEqual (110, bmp.Width, "bmp.Width");
				Assert.AreEqual (100, bmp.Height, "bmp.Height");

				Assert.AreEqual (0, rect.X, "rect.X");
				Assert.AreEqual (0, rect.Y, "rect.Y");
				Assert.AreEqual (110, rect.Width, "rect.Width");
				Assert.AreEqual (100, rect.Height, "rect.Height");

				Assert.AreEqual (110, bmp.Size.Width, "bmp.Size.Width");
				Assert.AreEqual (100, bmp.Size.Height, "bmp.Size.Height");

				Assert.AreEqual (110, bmp.PhysicalDimension.Width, "bmp.PhysicalDimension.Width");
				Assert.AreEqual (100, bmp.PhysicalDimension.Height, "bmp.PhysicalDimension.Height");

				Assert.AreEqual (72, bmp.HorizontalResolution, "HorizontalResolution");
				Assert.AreEqual (72, bmp.VerticalResolution, "VerticalResolution");

				Assert.AreEqual (77896, bmp.Flags, "Flags");

				ColorPalette cp = bmp.Palette;
				Assert.AreEqual (256, cp.Entries.Length, "Palette.Entries");
				Assert.AreEqual (0, cp.Flags, "Palette.Flags");
				for (int i = 0; i < 256; i++) {
					Color c = cp.Entries [i];
					Assert.AreEqual (0xFF, c.A, "A" + i.ToString ());
					Assert.AreEqual (i, c.R, "R" + i.ToString ());
					Assert.AreEqual (i, c.G, "G" + i.ToString ());
					Assert.AreEqual (i, c.B, "B" + i.ToString ());
				}
			}
		}
Пример #13
0
        void LockBitmap()
        {
            GraphicsUnit unit    = GraphicsUnit.Pixel;
            RectangleF   boundsF = bitmap.GetBounds(ref unit);
            Rectangle    bounds  = new Rectangle((int)boundsF.X,
                                                 (int)boundsF.Y,
                                                 (int)boundsF.Width,
                                                 (int)boundsF.Height);

            // Figure out the number of bytes in a row
            // This is rounded up to be a multiple of 4
            // bytes, since a scan line in an image must always be a multiple of 4 bytes
            // in length.
            int pixelsize;

            switch (bitmap.PixelFormat)
            {
            case PixelFormat.Format24bppRgb:
                pixelsize = 3;
                break;

            case PixelFormat.Format32bppArgb:
                pixelsize = 4;
                break;

            default:
                throw new NotSupportedException();
            }

            width = (int)boundsF.Width * pixelsize;
            if (width % 4 != 0)
            {
                width = 4 * (width / 4 + 1);
            }
            bitmapData = bitmap.LockBits(bounds, ImageLockMode.ReadWrite, bitmap.PixelFormat);

            pBase = (byte *)bitmapData.Scan0.ToPointer();
        }
Пример #14
0
        public static unsafe Region getRegionFast(Bitmap bitmap, Color transparencyKey, int tolerance)
        {
            GraphicsUnit unit = GraphicsUnit.Pixel;
            RectangleF boundsF = bitmap.GetBounds(ref unit);
            Rectangle bounds = new Rectangle((int)boundsF.Left, (int)boundsF.Top,
                                             (int)boundsF.Width, (int)boundsF.Height);
            int yMax = (int)boundsF.Height;
            int xMax = (int)boundsF.Width;
            if (tolerance <= 0) tolerance = 1;
            BitmapData bitmapData = bitmap.LockBits(bounds, ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb);
            uint* pixelPtr = (uint*)bitmapData.Scan0.ToPointer();
            GraphicsPath path = new GraphicsPath();
            for (int y = 0; y < yMax; y++)
            {
                byte* basePos = (byte*)pixelPtr;

                for (int x = 0; x < xMax; x++, pixelPtr++)
                {
                    if (colorsMatch(pixelPtr, transparencyKey, tolerance))
                        continue;
                    int x0 = x;
                    while (x < xMax && !colorsMatch(pixelPtr, transparencyKey, tolerance))
                    {
                        x++;
                        pixelPtr++;
                    }
                    path.AddRectangle(new Rectangle(x0, y, x - x0, 1));
                }
                pixelPtr = (uint*)(basePos + bitmapData.Stride);
            }

            Region outputRegion = new Region(path);
            path.Dispose();
            bitmap.UnlockBits(bitmapData);
            return outputRegion;
        }
Пример #15
0
        public void LockBitmap()
        {
            GraphicsUnit unit    = GraphicsUnit.Pixel;
            RectangleF   boundsF = bitmap.GetBounds(ref unit);
            Rectangle    bounds  = new Rectangle(
                (int)boundsF.X,
                (int)boundsF.Y,
                (int)boundsF.Width,
                (int)boundsF.Height
                );

            // Figure out the number of bytes in a row
            // This is rounded up to be a multiple of 4
            // bytes, since a scan line in an image must always be a multiple of 4 bytes
            // in length.
            _width = (int)boundsF.Width * sizeof(PixelData);
            if (_width % 4 != 0)
            {
                _width = 4 * (_width / 4 + 1);
            }
            _bitmapData = bitmap.LockBits(bounds, ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);

            _base = (Byte *)_bitmapData.Scan0.ToPointer();
        }
Пример #16
0
 private void RenderEQ(byte[] EqDataArray)
 {
   if (this.info.SupportGfxLCD)
   {
     object obj2;
     Monitor.Enter(obj2 = this.DWriteMutex);
     try
     {
       Bitmap image = new Bitmap(this.LCD_CONFIG.ColumnsGraphics, this.LCD_CONFIG.RowsGraphics);
       GraphicsUnit pixel = GraphicsUnit.Pixel;
       RectangleF bounds = image.GetBounds(ref pixel);
       Graphics graphics = Graphics.FromImage(image);
       graphics.FillRectangle(Brushes.White, bounds);
       for (int i = 0; i < this.EQSettings.Render_BANDS; i++)
       {
         RectangleF ef2;
         if (this.DoDebug)
         {
           Log.Info("LCDHypeWrapper.RenderEQ(): Rendering {0} band {1} = {2}",
                    new object[]
                      {
                        this.EQSettings.UseNormalEq
                          ? "Normal EQ"
                          : (this.EQSettings.UseStereoEq
                               ? "Stereo EQ"
                               : (this.EQSettings.UseVUmeter ? "VU Meter" : "VU Meter 2")), i,
                        this.EQSettings.UseNormalEq
                          ? this.EQSettings.EqArray[1 + i].ToString()
                          : (this.EQSettings.UseStereoEq
                               ? (this.EQSettings.EqArray[1 + i].ToString() + " : " +
                                  this.EQSettings.EqArray[9 + i].ToString())
                               : (this.EQSettings.EqArray[1 + i].ToString() + " : " +
                                  this.EQSettings.EqArray[2 + i].ToString()))
                      });
         }
         if (this.EQSettings.UseNormalEq)
         {
           ef2 = new RectangleF((bounds.X + (i * (((int)bounds.Width) / this.EQSettings.Render_BANDS))) + 1f,
                                bounds.Y + (((int)bounds.Height) - this.EQSettings.EqArray[1 + i]),
                                (float)((((int)bounds.Width) / this.EQSettings.Render_BANDS) - 2),
                                (float)this.EQSettings.EqArray[1 + i]);
           graphics.FillRectangle(Brushes.Black, ef2);
         }
         else
         {
           int num2;
           RectangleF ef3;
           if (this.EQSettings.UseStereoEq)
           {
             int num4 = (((int)bounds.Width) / 2) / this.EQSettings.Render_BANDS;
             num2 = i * num4;
             int num3 = (i + this.EQSettings.Render_BANDS) * num4;
             ef2 = new RectangleF((bounds.X + num2) + 1f,
                                  bounds.Y + (((int)bounds.Height) - this.EQSettings.EqArray[1 + i]),
                                  (float)(num4 - 2), (float)this.EQSettings.EqArray[1 + i]);
             ef3 = new RectangleF((bounds.X + num3) + 1f,
                                  bounds.Y + (((int)bounds.Height) - this.EQSettings.EqArray[9 + i]),
                                  (float)(num4 - 2), (float)this.EQSettings.EqArray[9 + i]);
             graphics.FillRectangle(Brushes.Black, ef2);
             graphics.FillRectangle(Brushes.Black, ef3);
           }
           else if (this.EQSettings.UseVUmeter | this.EQSettings.UseVUmeter2)
           {
             ef2 = new RectangleF(bounds.X + 1f, bounds.Y + 1f, (float)this.EQSettings.EqArray[1 + i],
                                  (float)(((int)(bounds.Height / 2f)) - 2));
             num2 = this.EQSettings.UseVUmeter ? 0 : (((int)bounds.Width) - this.EQSettings.EqArray[2 + i]);
             ef3 = new RectangleF((bounds.X + num2) + 1f, (bounds.Y + (bounds.Height / 2f)) + 1f,
                                  (float)this.EQSettings.EqArray[2 + i], (float)(((int)(bounds.Height / 2f)) - 2));
             graphics.FillRectangle(Brushes.Black, ef2);
             graphics.FillRectangle(Brushes.Black, ef3);
           }
         }
       }
       this.DrawImage(image);
       return;
     }
     catch (Exception exception)
     {
       Log.Info("LCDHypeWrapper.DisplayEQ(): CAUGHT EXCEPTION {0}", new object[] {exception});
       if (exception.Message.Contains("ThreadAbortException")) {}
       return;
     }
     finally
     {
       Monitor.Exit(obj2);
     }
   }
   lock (this.DWriteMutex)
   {
     if (this.EQSettings.UseVUmeter || this.EQSettings.UseVUmeter2)
     {
       if (this.DoDebug)
       {
         Log.Info("LCDHypeWrapper.RenderEQ(): Drawing VU meter");
       }
       string strLeft = "";
       string strRight = "";
       int segmentCount = this.LCD_CONFIG.ColumnsText;
       if (this.EQSettings._useVUindicators)
       {
         strLeft = "L";
         strRight = "R";
         segmentCount--;
       }
       if (this.DoDebug)
       {
         Log.Info("LCDHypeWrapper.RenderEQ(): segment count: {0}", segmentCount);
       }
       for (int j = 0; j < segmentCount; j++)
       {
         if (EqDataArray[1] > j)
         {
           strLeft = strLeft + '=';
         }
         else
         {
           strLeft = strLeft + ' ';
         }
         if (EqDataArray[2] > j)
         {
           strRight = strRight + '=';
         }
         else
         {
           strRight = strRight + ' ';
         }
       }
       if (this.EQSettings.UseVUmeter2)
       {
         char[] strArray = strRight.ToCharArray();
         Array.Reverse(strArray);
         strRight = new string(strArray);
         //strRight = strRight.Replace(">", "<");
       }
       if (this.DoDebug)
       {
         Log.Info("LCDHypeWrapper.RenderEQ(): Sending VU meter data to display: L = \"{0}\" - R = \"{1}\"",
                  new object[] {strLeft, strRight});
       }
       this.LCDHypeWrapper_SetLine(0, strLeft);
       this.LCDHypeWrapper_SetLine(1, strRight);
     }
   }
 }
Пример #17
0
		public void Bitmap32bitsFeatures ()
		{
			string sInFile = getInFile ("bitmaps/almogaver32bits.tif");
			using (Bitmap bmp = new Bitmap (sInFile)) {
				GraphicsUnit unit = GraphicsUnit.World;
				RectangleF rect = bmp.GetBounds (ref unit);
// MS reports 24 bpp while we report 32 bpp
//				Assert.AreEqual (PixelFormat.Format24bppRgb, bmp.PixelFormat);
				Assert.AreEqual (173, bmp.Width, "bmp.Width");
				Assert.AreEqual (183, bmp.Height, "bmp.Height");

				Assert.AreEqual (0, rect.X, "rect.X");
				Assert.AreEqual (0, rect.Y, "rect.Y");
				Assert.AreEqual (173, rect.Width, "rect.Width");
				Assert.AreEqual (183, rect.Height, "rect.Height");

				Assert.AreEqual (173, bmp.Size.Width, "bmp.Size.Width");
				Assert.AreEqual (183, bmp.Size.Height, "bmp.Size.Height");
			}
		}
Пример #18
0
        public static unsafe GraphicsPath CreateRegion(Bitmap bitmap)
        {
            GraphicsUnit unit = GraphicsUnit.Pixel;
            RectangleF boundsF = bitmap.GetBounds(ref unit);
            Rectangle bounds = new Rectangle((int)boundsF.Left, (int)boundsF.Top,
                               (int)boundsF.Width, (int)boundsF.Height);

            Color transparencyKey;
            if (UseTransparencyColorTopLeft)
            { transparencyKey = bitmap.GetPixel(0, 0); }
            else
            { transparencyKey = Color.FromArgb(255, 255, 0, 255); }

            uint key = (uint)((transparencyKey.A << 24) |
                              (transparencyKey.R << 16) |
                              (transparencyKey.G << 8) |
                              (transparencyKey.B << 0));

            // Access raw bits of the image
            BitmapData bitmapData = bitmap.LockBits(bounds, ImageLockMode.ReadOnly,
                                    PixelFormat.Format32bppArgb);
            uint* pixelPtr = (uint*)bitmapData.Scan0.ToPointer();

            // Get it only once
            int yMax = (int)boundsF.Height;
            int xMax = (int)boundsF.Width;

            // To store the rectangles
            GraphicsPath path = new GraphicsPath();

            for (int y = 0; y < yMax; y++)
            {
                // Store pointer to get next line from it
                byte* basePos = (byte*)pixelPtr;

                for (int x = 0; x < xMax; x++, pixelPtr++)
                {   // Is it transparent?
                    if (*pixelPtr == key) continue; // Yes, go on with the loop

                    // Store where scan starts
                    int x0 = x;
                    //not transparent - scan until we find the next transparent byte
                    while (x < xMax && (*pixelPtr != key))
                    {
                        ++x; pixelPtr++;
                    }
                    //add rectangle found to path
                    path.AddRectangle(new Rectangle(x0, y, x - x0, 1));
                }
                // Goto next line
                pixelPtr = (uint*)(basePos + bitmapData.Stride);
            }
            bitmap.UnlockBits(bitmapData);
            return path;
        }
Пример #19
0
		public void Bitmap32bitFeatures ()
		{
			string sInFile = getInFile ("bitmaps/almogaver32bits.bmp");
			using (Bitmap bmp = new Bitmap (sInFile)) {
				GraphicsUnit unit = GraphicsUnit.World;
				RectangleF rect = bmp.GetBounds (ref unit);

				Assert.AreEqual (173, bmp.Width, "bmp.Width");
				Assert.AreEqual (183, bmp.Height, "bmp.Height");

				Assert.AreEqual (0, rect.X, "rect.X");
				Assert.AreEqual (0, rect.Y, "rect.Y");
				Assert.AreEqual (173, rect.Width, "rect.Width");
				Assert.AreEqual (183, rect.Height, "rect.Height");

				Assert.AreEqual (173, bmp.Size.Width, "bmp.Size.Width");
				Assert.AreEqual (183, bmp.Size.Height, "bmp.Size.Height");
			}
		}
Пример #20
0
		public void NonInvertedBitmap ()
		{
			// regression check against http://bugzilla.ximian.com/show_bug.cgi?id=80751
			string sInFile = getInFile ("bitmaps/non-inverted.bmp");
			using (Bitmap bmp = new Bitmap (sInFile)) {
				GraphicsUnit unit = GraphicsUnit.World;
				RectangleF rect = bmp.GetBounds (ref unit);

				Assert.AreEqual (90, bmp.Width, "bmp.Width");
				Assert.AreEqual (60, bmp.Height, "bmp.Height");

				Assert.AreEqual (0, rect.X, "rect.X");
				Assert.AreEqual (0, rect.Y, "rect.Y");
				Assert.AreEqual (90, rect.Width, "rect.Width");
				Assert.AreEqual (60, rect.Height, "rect.Height");

				Assert.AreEqual (90, bmp.Size.Width, "bmp.Size.Width");
				Assert.AreEqual (60, bmp.Size.Height, "bmp.Size.Height");

				// sampling values from a well known bitmap
				Assert.AreEqual (-16777216, bmp.GetPixel (12, 21).ToArgb (), "12,21");
				Assert.AreEqual (-1, bmp.GetPixel (21, 37).ToArgb (), "21,37");
			}
		}
Пример #21
0
        private void LockBitmap(Bitmap bitmap)
        {
            GraphicsUnit unit = GraphicsUnit.Pixel;
            RectangleF boundsF = bitmap.GetBounds(ref unit);
            Rectangle bounds = new Rectangle((int)boundsF.X,
                                             (int)boundsF.Y,
                                             (int)boundsF.Width,
                                             (int)boundsF.Height);

            // Figure out the number of bytes in a row
            // This is rounded up to be a multiple of 4
            // bytes, since a scan line in an image must always be a multiple of 4 bytes
            // in length. 
            scanWidth = (int)boundsF.Width * sizeof(PixelData);
            if (scanWidth % 4 != 0)
            {
                scanWidth = 4 * (scanWidth / 4 + 1);
            }

            bitmapData =
                bitmap.LockBits(bounds, ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb);

            pBase = (byte*)bitmapData.Scan0.ToPointer();
        }
Пример #22
0
        private void PaintImage(Bitmap image, object sender, PaintEventArgs e, string drawString)
        {
            Graphics g = e.Graphics;
            PictureBox pictureBox = sender as PictureBox;

            if (image != null)
            {
                GraphicsUnit Unit = GraphicsUnit.Pixel;
                RectangleF bounds = image.GetBounds(ref Unit);
                
                float Scale = ComputeScale();

                g.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.NearestNeighbor;

                RectangleF destRect = new RectangleF();

                destRect.Size = new SizeF(bounds.Width * Scale, bounds.Height * Scale);
                destRect.Location = new PointF(-ImageOffsetX * Scale, -ImageOffsetY * Scale);

                g.DrawImage(image, destRect, bounds, Unit);
            }

            Font drawFont = new Font("Arial", 12);

            SizeF textSize = g.MeasureString(drawString, drawFont);
            DrawOutlinedString(g, (int)(pictureBox.Width / 2 - textSize.Width / 2), (int)(pictureBox.Height - textSize.Height), drawString, drawFont);
        }
Пример #23
0
		public void Bitmap96Features ()
		{
			string sInFile = getInFile ("bitmaps/96x96x256.ico");
			using (Bitmap bmp = new Bitmap (sInFile)) {
				GraphicsUnit unit = GraphicsUnit.World;
				RectangleF rect = bmp.GetBounds (ref unit);

				Assert.IsTrue (bmp.RawFormat.Equals (ImageFormat.Icon), "Icon");
				Assert.AreEqual (PixelFormat.Format32bppArgb, bmp.PixelFormat);
				Assert.AreEqual (73746, bmp.Flags, "bmp.Flags");
				Assert.AreEqual (256, bmp.Palette.Entries.Length, "Palette");
				Assert.AreEqual (1, bmp.FrameDimensionsList.Length, "FrameDimensionsList");
				Assert.AreEqual (0, bmp.PropertyIdList.Length, "PropertyIdList");
				Assert.AreEqual (0, bmp.PropertyItems.Length, "PropertyItems");
#if NET_2_0
				Assert.IsNull (bmp.Tag, "Tag");
#endif
				Assert.AreEqual (96.0f, bmp.HorizontalResolution, "HorizontalResolution");
				Assert.AreEqual (96.0f, bmp.VerticalResolution, "VerticalResolution");
				Assert.AreEqual (96, bmp.Width, "bmp.Width");
				Assert.AreEqual (96, bmp.Height, "bmp.Height");

				Assert.AreEqual (0, rect.X, "rect.X");
				Assert.AreEqual (0, rect.Y, "rect.Y");
				Assert.AreEqual (96, rect.Width, "rect.Width");
				Assert.AreEqual (96, rect.Height, "rect.Height");

				Assert.AreEqual (96, bmp.Size.Width, "bmp.Size.Width");
				Assert.AreEqual (96, bmp.Size.Height, "bmp.Size.Height");
			}
		}
Пример #24
0
        private Point GetPixelSize(Bitmap bitmap)
        {
            GraphicsUnit unit = GraphicsUnit.Pixel;
            RectangleF bounds = bitmap.GetBounds(ref unit);

            return new Point((int)bounds.Width, (int)bounds.Height);
        }
Пример #25
0
		public void Bitmap16Features ()
		{
			string sInFile = getInFile ("bitmaps/smiley.ico");
			using (Bitmap bmp = new Bitmap (sInFile)) {
				GraphicsUnit unit = GraphicsUnit.World;
				RectangleF rect = bmp.GetBounds (ref unit);

				Assert.IsTrue (bmp.RawFormat.Equals (ImageFormat.Icon), "Icon");
				// note that image is "promoted" to 32bits
				Assert.AreEqual (PixelFormat.Format32bppArgb, bmp.PixelFormat);
				Assert.AreEqual (73746, bmp.Flags, "bmp.Flags");
				Assert.AreEqual (16, bmp.Palette.Entries.Length, "Palette");
				Assert.AreEqual (-16777216, bmp.Palette.Entries[0].ToArgb (), "Palette#0");
				Assert.AreEqual (-16777216, bmp.Palette.Entries[1].ToArgb (), "Palette#1");
				Assert.AreEqual (-16744448, bmp.Palette.Entries[2].ToArgb (), "Palette#2");
				Assert.AreEqual (-8355840, bmp.Palette.Entries[3].ToArgb (), "Palette#3");
				Assert.AreEqual (-16777088, bmp.Palette.Entries[4].ToArgb (), "Palette#4");
				Assert.AreEqual (-8388480, bmp.Palette.Entries[5].ToArgb (), "Palette#5");
				Assert.AreEqual (-16744320, bmp.Palette.Entries[6].ToArgb (), "Palette#6");
				Assert.AreEqual (-4144960, bmp.Palette.Entries[7].ToArgb (), "Palette#7");
				Assert.AreEqual (-8355712, bmp.Palette.Entries[8].ToArgb (), "Palette#8");
				Assert.AreEqual (-65536, bmp.Palette.Entries[9].ToArgb (), "Palette#9");
				Assert.AreEqual (-16711936, bmp.Palette.Entries[10].ToArgb (), "Palette#10");
				Assert.AreEqual (-256, bmp.Palette.Entries[11].ToArgb (), "Palette#11");
				Assert.AreEqual (-16776961, bmp.Palette.Entries[12].ToArgb (), "Palette#12");
				Assert.AreEqual (-65281, bmp.Palette.Entries[13].ToArgb (), "Palette#13");
				Assert.AreEqual (-16711681, bmp.Palette.Entries[14].ToArgb (), "Palette#14");
				Assert.AreEqual (-1, bmp.Palette.Entries[15].ToArgb (), "Palette#15");
				Assert.AreEqual (1, bmp.FrameDimensionsList.Length, "FrameDimensionsList");
				Assert.AreEqual (0, bmp.PropertyIdList.Length, "PropertyIdList");
				Assert.AreEqual (0, bmp.PropertyItems.Length, "PropertyItems");
#if NET_2_0
				Assert.IsNull (bmp.Tag, "Tag");
#endif
				Assert.AreEqual (96.0f, bmp.HorizontalResolution, "HorizontalResolution");
				Assert.AreEqual (96.0f, bmp.VerticalResolution, "VerticalResolution");
				Assert.AreEqual (16, bmp.Width, "bmp.Width");
				Assert.AreEqual (16, bmp.Height, "bmp.Height");

				Assert.AreEqual (0, rect.X, "rect.X");
				Assert.AreEqual (0, rect.Y, "rect.Y");
				Assert.AreEqual (16, rect.Width, "rect.Width");
				Assert.AreEqual (16, rect.Height, "rect.Height");

				Assert.AreEqual (16, bmp.Size.Width, "bmp.Size.Width");
				Assert.AreEqual (16, bmp.Size.Height, "bmp.Size.Height");
			}
		}
Пример #26
0
		public void Bitmap2bitFeatures ()
		{
			string sInFile = getInFile ("bitmaps/81674-2bpp.png");
			using (Bitmap bmp = new Bitmap (sInFile)) {
				GraphicsUnit unit = GraphicsUnit.World;
				RectangleF rect = bmp.GetBounds (ref unit);

				// quite a promotion! (2 -> 32)
				Assert.AreEqual (PixelFormat.Format32bppArgb, bmp.PixelFormat);

				// MS returns a random Flags value (not a good sign)
				//Assert.AreEqual (0, bmp.Palette.Flags, "Palette.Flags");
				Assert.AreEqual (0, bmp.Palette.Entries.Length, "Palette.Entries");

				Assert.AreEqual (100, bmp.Width, "bmp.Width");
				Assert.AreEqual (100, bmp.Height, "bmp.Height");

				Assert.AreEqual (0, rect.X, "rect.X");
				Assert.AreEqual (0, rect.Y, "rect.Y");
				Assert.AreEqual (100, rect.Width, "rect.Width");
				Assert.AreEqual (100, rect.Height, "rect.Height");

				Assert.AreEqual (100, bmp.Size.Width, "bmp.Size.Width");
				Assert.AreEqual (100, bmp.Size.Height, "bmp.Size.Height");
			}
		}
Пример #27
0
		public void Bitmap24bitFeatures ()
		{
			string sInFile = getInFile ("bitmaps/nature24bits.jpg");
			using (Bitmap bmp = new Bitmap (sInFile)) {
				GraphicsUnit unit = GraphicsUnit.World;
				RectangleF rect = bmp.GetBounds (ref unit);

				Assert.AreEqual (PixelFormat.Format24bppRgb, bmp.PixelFormat, "PixelFormat");
				Assert.AreEqual (110, bmp.Width, "bmp.Width");
				Assert.AreEqual (100, bmp.Height, "bmp.Height");

				Assert.AreEqual (0, rect.X, "rect.X");
				Assert.AreEqual (0, rect.Y, "rect.Y");
				Assert.AreEqual (110, rect.Width, "rect.Width");
				Assert.AreEqual (100, rect.Height, "rect.Height");

				Assert.AreEqual (110, bmp.Size.Width, "bmp.Size.Width");
				Assert.AreEqual (100, bmp.Size.Height, "bmp.Size.Height");

				Assert.AreEqual (110, bmp.PhysicalDimension.Width, "bmp.PhysicalDimension.Width");
				Assert.AreEqual (100, bmp.PhysicalDimension.Height, "bmp.PhysicalDimension.Height");

				Assert.AreEqual (72, bmp.HorizontalResolution, "HorizontalResolution");
				Assert.AreEqual (72, bmp.VerticalResolution, "VerticalResolution");

				Assert.AreEqual (77960, bmp.Flags, "Flags");

				Assert.AreEqual (0, bmp.Palette.Entries.Length, "Palette.Entries");
				/* note: under MS flags aren't constant between executions in this case (no palette) */
			}
		}
Пример #28
0
		public void Bitmap4bitFeatures ()
		{
			string sInFile = getInFile ("bitmaps/4bit.png");
			using (Bitmap bmp = new Bitmap (sInFile)) {
				GraphicsUnit unit = GraphicsUnit.World;
				RectangleF rect = bmp.GetBounds (ref unit);

				Assert.AreEqual (PixelFormat.Format4bppIndexed, bmp.PixelFormat);

				Assert.AreEqual (0, bmp.Palette.Flags, "Palette.Flags");
				Assert.AreEqual (16, bmp.Palette.Entries.Length, "Palette.Entries");
				Assert.AreEqual (-12106173, bmp.Palette.Entries[0].ToArgb (), "Palette.0");
				Assert.AreEqual (-10979957, bmp.Palette.Entries[1].ToArgb (), "Palette.1");
				Assert.AreEqual (-8879241, bmp.Palette.Entries[2].ToArgb (), "Palette.2");
				Assert.AreEqual (-10381134, bmp.Palette.Entries[3].ToArgb (), "Palette.3");
				Assert.AreEqual (-7441574, bmp.Palette.Entries[4].ToArgb (), "Palette.4");
				Assert.AreEqual (-6391673, bmp.Palette.Entries[5].ToArgb (), "Palette.5");
				Assert.AreEqual (-5861009, bmp.Palette.Entries[6].ToArgb (), "Palette.6");
				Assert.AreEqual (-3824008, bmp.Palette.Entries[7].ToArgb (), "Palette.7");
				Assert.AreEqual (-5790569, bmp.Palette.Entries[8].ToArgb (), "Palette.8");
				Assert.AreEqual (-6178617, bmp.Palette.Entries[9].ToArgb (), "Palette.9");
				Assert.AreEqual (-4668490, bmp.Palette.Entries[10].ToArgb (), "Palette.10");
				Assert.AreEqual (-5060143, bmp.Palette.Entries[11].ToArgb (), "Palette.11");
				Assert.AreEqual (-3492461, bmp.Palette.Entries[12].ToArgb (), "Palette.12");
				Assert.AreEqual (-2967099, bmp.Palette.Entries[13].ToArgb (), "Palette.13");
				Assert.AreEqual (-2175574, bmp.Palette.Entries[14].ToArgb (), "Palette.14");
				Assert.AreEqual (-1314578, bmp.Palette.Entries[15].ToArgb (), "Palette.15");

				Assert.AreEqual (288, bmp.Width, "bmp.Width");
				Assert.AreEqual (384, bmp.Height, "bmp.Height");

				Assert.AreEqual (0, rect.X, "rect.X");
				Assert.AreEqual (0, rect.Y, "rect.Y");
				Assert.AreEqual (288, rect.Width, "rect.Width");
				Assert.AreEqual (384, rect.Height, "rect.Height");

				Assert.AreEqual (288, bmp.Size.Width, "bmp.Size.Width");
				Assert.AreEqual (384, bmp.Size.Height, "bmp.Size.Height");
			}
		}
Пример #29
0
 public FastBitmap(Bitmap bitmap)
     : this(bitmap, System.Drawing.Rectangle.Round(bitmap.GetBounds(ref graphicsUnit)))
 {
 }
        private static void CreateAvatarWithInitials(string userId, int size, string fullname, string initials, string pathToFile)
        {
            using (var bitmap = new Bitmap(size, size, PixelFormat.Format24bppRgb))
            using (var g = Graphics.FromImage(bitmap))
            {
                g.SmoothingMode = SmoothingMode.AntiAlias;
                var backgroundColor = GetColorFor(userId, fullname);
                g.Clear(backgroundColor);

                var units = GraphicsUnit.Pixel;

                using (var rectangleFont = new Font("Arial", (int)(size / 4), FontStyle.Bold))
                {
                    g.DrawString(initials, rectangleFont, Brushes.Beige, bitmap.GetBounds(ref units), Center);
                }

                bitmap.Save(pathToFile, ImageFormat.Png);
            }
        }
Пример #31
0
        //预处理,包括分割、二值化、去边缘杂点、平移居中
        public List<Bitmap> Preproc(Bitmap im)
        {
            int[] dx = new int[] { 0, 0, -1, 1, 1, 1, -1, -1 };
            int[] dy = new int[] { 1, -1, 0, 0, -1, 1, 1, -1 };
            List<Bitmap> result = new List<Bitmap>();
            for (int i = 0; i < 4; i++)
            {
                int l = i * 11 + 1;
                //分割
                Bitmap tmp = new Bitmap(11, 24);
                Graphics g = Graphics.FromImage(tmp);
                g.DrawImage(im, 0, 0, new Rectangle(l, 0, 11, 24), GraphicsUnit.Pixel);
                g.Save();
                g.Dispose();
                //二值化
                int threshold = 200; //阈值
                for (int x = 0; x < tmp.Width; x++)
                    for (int y = 0; y < tmp.Height; y++)
                    {
                        Color col = tmp.GetPixel(x, y);
                        int sum = col.R + col.G + col.B;
                        sum /= 3;
                        if (sum <= threshold) tmp.SetPixel(x, y, Color.Black);
                        else tmp.SetPixel(x, y, Color.White);
                    }
                //去除噪点
                HashSet<Point> edge = new HashSet<Point>();
                //edge--边缘黑点(仅左右边缘)
                for (int ih = 0; ih < tmp.Height; ih++)
                {
                    if (tmp.GetPixel(0, ih).ToArgb() == Color.Black.ToArgb())
                    {
                        edge.Add(new Point(0, ih));
                    }
                    if (tmp.GetPixel(tmp.Width - 1, ih).ToArgb() == Color.Black.ToArgb())
                    {
                        edge.Add(new Point(tmp.Width - 1, ih));
                    }
                }
                //BFS
                Queue<Point> q = new Queue<Point>();
                HashSet<Point> rec = new HashSet<Point>();
                //rec--记录块中黑点个数
                foreach (Point p1 in edge)
                {
                    if (tmp.GetPixel(p1.X, p1.Y).ToArgb() == Color.White.ToArgb()) continue;
                    rec.Clear();
                    q.Enqueue(p1);
                    rec.Add(p1);
                    while (q.Count > 0)
                    {
                        Point now = q.Dequeue();
                        for (int ii = 0; ii < 8; ii++)
                        {
                            var pix = GraphicsUnit.Pixel;//getbound要求一个引用。。。
                            Point tp = now;
                            tp.Offset(dx[ii], dy[ii]);
                            //(1)图像之内
                            //(2)是黑色
                            //(3)尚未被标记
                            if (tmp.GetBounds(ref pix).Contains(tp)
                                && tmp.GetPixel(tp.X, tp.Y).ToArgb() == Color.Black.ToArgb()
                                && !rec.Contains(tp))
                            {
                                q.Enqueue(tp);
                                rec.Add(tp);
                            }
                        }
                    }
                    //bfs结束,块中点少于阈值,全部染白
                    if (rec.Count <= 6)
                    {
                        foreach (Point po in rec)
                        {
                            tmp.SetPixel(po.X, po.Y, Color.White);
                        }
                    }
                }
                //平移,使图片居中
                int x1 = -1, x2 = 100, y1 = -1, y2 = 100;
                for (int x = 0; x < tmp.Width; x++)
                    for (int y = 0; y < tmp.Height; y++)
                    {
                        if (tmp.GetPixel(x, y).ToArgb() == Color.Black.ToArgb())
                        {
                            x1 = Math.Max(x1, x);
                            x2 = Math.Min(x2, x);
                            y1 = Math.Max(y1, y);
                            y2 = Math.Min(y2, y);
                        }
                    }
                Bitmap tmp2 = new Bitmap(11, 24);
                g = Graphics.FromImage(tmp2);
                g.FillRectangle(new SolidBrush(Color.White), 0, 0, 11, 24);
                g.DrawImage(tmp, 5 - (x1 + x2) / 2, 12 - (y1 + y2) / 2);
                g.Save();
                g.Dispose();

                result.Add(tmp2);
                //tmp.Save(@".\"+i.ToString()+".bmp");
            }
            return result;
        }
Пример #32
0
		private Image PreparePhoto(byte[] photo)
		{
			if (photo == null || photo.Length == 0) return null;

			using (var stream = new MemoryStream(photo))
			using (var image = Image.FromStream(stream))
			{
				var imageMinSize = Math.Min(image.Width, image.Height);
				var size = imageSize;
				if (imageMinSize < 96) size = 64;
				if (imageMinSize < 64) size = 32;

				using (var bitmap = new Bitmap(size, size))
				using (var g = Graphics.FromImage(bitmap))
				{
					var delta = (image.Width - image.Height) / 2;
					var srcRect = new RectangleF(0f, 0f, imageMinSize, imageMinSize);
					if (image.Width < image.Height) srcRect.Y = -delta;
					else srcRect.X = delta;

					g.SmoothingMode = SmoothingMode.HighQuality;
					g.PixelOffsetMode = PixelOffsetMode.HighQuality;
					g.CompositingQuality = CompositingQuality.HighQuality;

					var gu = GraphicsUnit.Pixel;
					var destRect = bitmap.GetBounds(ref gu);
					g.DrawImage(image, destRect, srcRect, gu);

					var saveStream = new MemoryStream();
					bitmap.Save(saveStream, ImageFormat.Png);
					return Image.FromStream(saveStream);
				}
			}
		}
Пример #33
0
        private void updateDestImage()
        {
            if (this.sourceImage != null && this.preferences != null)
            {
                if (this.destinationImage != null)
                {
                    this.destinationImage.Dispose();
                }

                FrameDimension frameDimensions = new FrameDimension(this.srcImage.FrameDimensionsList[0]);

                int destWidth;
                int destHeight;
                if (preferences.FramesPerRow > 0)
                {
                    int numRows = (int)Math.Ceiling(numFrames / (double)preferences.FramesPerRow);
                    int numCols = (int)Math.Min(numFrames, preferences.FramesPerRow);

                    destWidth = (numCols * (this.srcImage.Width + preferences.BetweenFrameWidth)) + preferences.BetweenFrameWidth;
                    destHeight = numRows * (this.srcImage.Height + preferences.BetweenFrameWidth) + preferences.BetweenFrameWidth;
                }
                else
                {
                    destWidth = (this.srcImage.Width + preferences.BetweenFrameWidth) * numFrames + preferences.BetweenFrameWidth;
                    destHeight = this.srcImage.Height + 2 * preferences.BetweenFrameWidth;
                }

                this.destinationImage = new Bitmap(destWidth, destHeight);

                Graphics destGraphics = Graphics.FromImage(this.destinationImage);

                GraphicsUnit unit = GraphicsUnit.Pixel;

                Brush bgBrush = new SolidBrush(preferences.BetweenFrameColor);
                destGraphics.FillRectangle(bgBrush, destinationImage.GetBounds(ref unit));
                bgBrush.Dispose();

                int currentX, currentY;

                for (int frame = 0; frame < numFrames; frame++)
                {
                    this.srcImage.SelectActiveFrame(frameDimensions, frame);

                    if (preferences.FramesPerRow <= 0)
                    {
                        currentX = preferences.BetweenFrameWidth + (preferences.BetweenFrameWidth + srcImage.Width) * frame;
                        currentY = preferences.BetweenFrameWidth;
                    }
                    else
                    {
                        int fila, columna;

                        fila = (frame / preferences.FramesPerRow);
                        columna = (frame % preferences.FramesPerRow);

                        currentX = preferences.BetweenFrameWidth + (preferences.BetweenFrameWidth + srcImage.Width) * columna;
                        currentY = preferences.BetweenFrameWidth + (preferences.BetweenFrameWidth + srcImage.Height) * fila;
                    }

                    Bitmap modifiedImage = getModifiedImage();

                    if (preferences.DrawFlipped)
                    {
                        modifiedImage.RotateFlip(RotateFlipType.RotateNoneFlipX);
                    }
                    destGraphics.DrawImageUnscaled(modifiedImage, currentX, currentY);
                }

                destGraphics.Dispose();

                this.sourceImage.Width = (int)Math.Ceiling(this.srcImage.Width * preferences.Zoom);
                this.sourceImage.Height = (int)Math.Ceiling(this.srcImage.Height * preferences.Zoom);
                this.sourceImage.ZoomFactor = preferences.Zoom;

                this.destImage.Image = this.destinationImage;
                this.destImage.Width = (int)Math.Ceiling(this.destinationImage.Width * preferences.Zoom);
                this.destImage.Height = (int)Math.Ceiling(this.destinationImage.Height * preferences.Zoom);
                this.destImage.ZoomFactor = preferences.Zoom;
            }
        }