예제 #1
0
		public unsafe void GetIndexedDataLinearTest()
		{
			Bitmap Bitmap = new Bitmap(3, 3, PixelFormat.Format8bppIndexed);

			Bitmap.LockBitsUnlock(PixelFormat.Format8bppIndexed, (BitmapData) =>
			{
				byte *Data = (byte *)BitmapData.Scan0.ToPointer();
				for (int n = 0; n < 9; n++) Data[n] = (byte)n;
			});

			Assert.AreEqual(
				"000102030405060708",
				Bitmap.GetIndexedDataLinear().ToHexString()
			);
		}
예제 #2
0
		/// <summary>
		/// 
		/// </summary>
		/// <param name="Bitmap"></param>
		/// <param name="AlphaThresold"></param>
		/// <returns></returns>
		static public bool[,] GetMask(Bitmap Bitmap, byte AlphaThresold = 1)
		{
			var Width = Bitmap.Width;
			var Height = Bitmap.Height;
			var Mask = new bool[Bitmap.Width, Bitmap.Height];
			Bitmap.LockBitsUnlock(System.Drawing.Imaging.PixelFormat.Format32bppArgb, (BitmapData) => {
				for (int y = 0; y < Height; y++)
				{
					var Ptr = ((byte *)BitmapData.Scan0.ToPointer()) + BitmapData.Stride * y;
					Ptr += 3;
					for (int x = 0; x < Width; x++)
					{
						Mask[x, y] = (*Ptr >= AlphaThresold);
						Ptr += 4;
						//Console.Write(Mask[x, y] ? 1 : 0);
					}
					//Console.WriteLine("");
				}
			});
			return Mask;
		}
예제 #3
0
        public Bitmap ToBitmap()
        {
            var Bitmap = new Bitmap(Width, Height, PixelFormat.Format24bppRgb);
            Bitmap.LockBitsUnlock(PixelFormat.Format32bppArgb, (BitmapData) =>
            {
                int Count = Width * Height;
                var Output = (OutputPixel*)BitmapData.Scan0;
                PixelFormatDecoder.Decode(
                    GuPixelFormat,
                    Address,
                    Output,
                    Width,
                    Height,
                    IgnoreAlpha: true
                );

                for (int n = 0; n < Count; n++)
                {
                    var Color = Output[n];
                    Output[n].R = Color.B;
                    Output[n].G = Color.G;
                    Output[n].B = Color.R;
                    Output[n].A = 0xFF;
                }
            });
            return Bitmap;
        }
예제 #4
0
        public static unsafe void TransferChannelsDataLinear(Rectangle Rectangle, Bitmap Bitmap, byte[] NewData, Direction Direction, params BitmapChannel[] Channels)
        {
            int WidthHeight = Bitmap.Width * Bitmap.Height;
            var FullRectangle = Bitmap.GetFullRectangle();
            if (!FullRectangle.Contains(Rectangle.Location)) throw(new InvalidProgramException());
            if (!FullRectangle.Contains(Rectangle.Location + Rectangle.Size - new Size(1, 1))) throw (new InvalidProgramException());

            int NumberOfChannels = 1;
            foreach (var Channel in Channels)
            {
                if (Channel != BitmapChannel.Indexed)
                {
                    NumberOfChannels = 4;
                    break;
                }
            }

            Bitmap.LockBitsUnlock((NumberOfChannels == 1) ? PixelFormat.Format8bppIndexed : PixelFormat.Format32bppArgb, (BitmapData) =>
            {
                byte* BitmapDataScan0 = (byte*)BitmapData.Scan0.ToPointer();
                int Width = Bitmap.Width;
                int Height = Bitmap.Height;
                int Stride = BitmapData.Stride;
                if (NumberOfChannels == 1)
                {
                    Stride = Width;
                }

                int RectangleTop = Rectangle.Top;
                int RectangleBottom = Rectangle.Bottom;
                int RectangleLeft = Rectangle.Left;
                int RectangleRight = Rectangle.Right;

                fixed (byte* OutputPtrStart = &NewData[0])
                {
                    byte* OutputPtr = OutputPtrStart;
                    foreach (var Channel in Channels)
                    {
                        for (int y = RectangleTop; y < RectangleBottom; y++)
                        {
                            byte* InputPtr = BitmapDataScan0 + Stride * y;
                            if (NumberOfChannels != 1)
                            {
                                InputPtr = InputPtr + (int)Channel;
                            }
                            InputPtr += NumberOfChannels * RectangleLeft;
                            for (int x = RectangleLeft; x < RectangleRight; x++)
                            {
                                if (Direction == Direction.FromBitmapToData)
                                {
                                    *OutputPtr = *InputPtr;
                                }
                                else
                                {
                                    *InputPtr  = * OutputPtr;
                                }
                                OutputPtr++;
                                InputPtr += NumberOfChannels;
                            }
                        }
                    }
                }
            });
        }
예제 #5
0
		public static unsafe void TransferChannelsDataInterleaved(Rectangle Rectangle, Bitmap Bitmap, byte* NewDataPtr, Direction Direction, params BitmapChannel[] Channels)
		{
			int NumberOfChannels = 1;
			foreach (var Channel in Channels)
			{
				if (Channel != BitmapChannel.Indexed)
				{
					NumberOfChannels = 4;
					break;
				}
			}

			Bitmap.LockBitsUnlock(Rectangle, (NumberOfChannels == 1) ? PixelFormat.Format8bppIndexed : PixelFormat.Format32bppArgb, (BitmapData) =>
			{
				for (int y = 0; y < BitmapData.Height; y++)
				{
					byte* BitmapPtr = ((byte*)BitmapData.Scan0.ToPointer()) + BitmapData.Stride * y;
					byte* DataPtr = NewDataPtr + (NumberOfChannels * BitmapData.Width) * y;
					int z = 0;
					for (int x = 0; x < BitmapData.Width; x++)
					{
						for (int c = 0; c < NumberOfChannels; c++)
						{
							byte* DataPtrPtr = &DataPtr[z + c];
							byte* BitmapPtrPtr = &BitmapPtr[z + (int)Channels[c]];

							if (Direction == BitmapUtils.Direction.FromBitmapToData)
							{
								*DataPtrPtr = *BitmapPtrPtr;
							}
							else
							{
								*BitmapPtrPtr  = * DataPtrPtr;
							}
						}
						z += NumberOfChannels;
					}
				}
			});
		}
예제 #6
0
		/// <summary>
		/// 
		/// </summary>
		/// <param name="DistanceMap"></param>
		/// <returns></returns>
		static public Bitmap BitmapFromDistanceMap(DistanceEntry[,] DistanceMap)
		{
			var Bitmap = new Bitmap(DistanceMap.GetLength(0), DistanceMap.GetLength(1));
			var Width = Bitmap.Width;
			var Height = Bitmap.Height;
			Bitmap.LockBitsUnlock(System.Drawing.Imaging.PixelFormat.Format32bppArgb, (BitmapData) =>
			{
				for (int y = 0; y < Height; y++)
				{
					var Ptr = ((byte *)BitmapData.Scan0.ToPointer()) + BitmapData.Stride * y;
					for (int x = 0; x < Width; x++)
					{
						byte Distance = (byte)MathUtils.FastClamp((int)(DistanceMap[x, y].Distance * 4), 0, 255);
						*Ptr++ = Distance;
						*Ptr++ = Distance;
						*Ptr++ = Distance;
						*Ptr++ = 0xFF;
					}
				}
			});
			return Bitmap;
		}
예제 #7
0
 public Texture Load(string FileName)
 {
     var Bitmap = new Bitmap(Image.FromFile(FileName));
     Bitmap.LockBitsUnlock(System.Drawing.Imaging.PixelFormat.Format32bppArgb, (BitmapData) =>
     {
         this.SetData((OutputPixel *)BitmapData.Scan0, BitmapData.Width, BitmapData.Height);
     });
     return this;
 }