C# IImageByte.GetBufferOffsetXY方法代码示例

		public ImageBuffer(IImageByte sourceImage, IRecieveBlenderByte recieveBlender)
		{
			SetDimmensionAndFormat(sourceImage.Width, sourceImage.Height, sourceImage.StrideInBytes(), sourceImage.BitDepth, sourceImage.GetBytesBetweenPixelsInclusive(), true);
			int offset = sourceImage.GetBufferOffsetXY(0, 0);
			byte[] buffer = sourceImage.GetBuffer();
			byte[] newBuffer = new byte[buffer.Length];
			agg_basics.memcpy(newBuffer, offset, buffer, offset, buffer.Length - offset);
			SetBuffer(newBuffer, offset);
			SetRecieveBlender(recieveBlender);
		}

        public override bool SaveImageData(String filename, IImageByte sourceImage)
        {
            if (File.Exists(filename))
            {
                File.Delete(filename);
            }

            ImageFormat format = ImageFormat.Jpeg;
            if (filename.ToLower().EndsWith(".png"))
            {
                format = ImageFormat.Png;
            }
            else if (!filename.ToLower().EndsWith(".jpg") && !filename.ToLower().EndsWith(".jpeg"))
            {
                filename += ".jpg";
            }

            if (!System.IO.File.Exists(filename))
            {
                if (sourceImage.BitDepth == 32)
                {
                    Bitmap bitmapToSave = new Bitmap(sourceImage.Width, sourceImage.Height, PixelFormat.Format32bppArgb);
                    BitmapData bitmapData = bitmapToSave.LockBits(new Rectangle(0, 0, bitmapToSave.Width, bitmapToSave.Height), System.Drawing.Imaging.ImageLockMode.ReadWrite, bitmapToSave.PixelFormat);
                    int destIndex = 0;
                    unsafe
                    {
                        byte[] sourceBuffer = sourceImage.GetBuffer();
                        byte* pDestBuffer = (byte*)bitmapData.Scan0;
                        int scanlinePadding = bitmapData.Stride - bitmapData.Width * 4;
                        for (int y = 0; y < sourceImage.Height; y++)
                        {
                            int sourceIndex = sourceImage.GetBufferOffsetXY(0, sourceImage.Height - 1 - y);
                            for (int x = 0; x < sourceImage.Width; x++)
                            {
                                pDestBuffer[destIndex++] = sourceBuffer[sourceIndex++];
                                pDestBuffer[destIndex++] = sourceBuffer[sourceIndex++];
                                pDestBuffer[destIndex++] = sourceBuffer[sourceIndex++];
                                pDestBuffer[destIndex++] = sourceBuffer[sourceIndex++];
                            }
                            destIndex += scanlinePadding;
                        }
                    }
                    bitmapToSave.Save(filename, format);
                    bitmapToSave.UnlockBits(bitmapData);
                    return true;
                }
                else if (sourceImage.BitDepth == 8 && format == ImageFormat.Png)
                {
                    Bitmap bitmapToSave = new Bitmap(sourceImage.Width, sourceImage.Height, PixelFormat.Format8bppIndexed);
                    ColorPalette palette = bitmapToSave.Palette;
                    for (int i = 0; i < palette.Entries.Length; i++)
                    {
                        palette.Entries[i] = Color.FromArgb(i, i, i);
                    }
                    bitmapToSave.Palette = palette;
                    BitmapData bitmapData = bitmapToSave.LockBits(new Rectangle(0, 0, bitmapToSave.Width, bitmapToSave.Height), System.Drawing.Imaging.ImageLockMode.ReadWrite, bitmapToSave.PixelFormat);
                    int destIndex = 0;
                    unsafe
                    {
                        byte[] sourceBuffer = sourceImage.GetBuffer();
                        byte* pDestBuffer = (byte*)bitmapData.Scan0;
                        for (int y = 0; y < sourceImage.Height; y++)
                        {
                            int sourceIndex = sourceImage.GetBufferOffsetXY(0, sourceImage.Height - 1 - y);
                            for (int x = 0; x < sourceImage.Width; x++)
                            {
                                pDestBuffer[destIndex++] = sourceBuffer[sourceIndex++];
                            }
                        }
                    }
                    bitmapToSave.Save(filename, format);
                    bitmapToSave.UnlockBits(bitmapData);
                    return true;
                }
                else
                {
                    throw new System.NotImplementedException();
                }
            }

            return false;
        }

		public bool Attach(IImageByte sourceImage, int x1, int y1, int x2, int y2)
		{
			m_ByteBuffer = null;
			DettachBuffer();

			if (x1 > x2 || y1 > y2)
			{
				throw new Exception("You need to have your x1 and y1 be the lower left corner of your sub image.");
			}
			RectangleInt boundsRect = new RectangleInt(x1, y1, x2, y2);
			if (boundsRect.clip(new RectangleInt(0, 0, (int)sourceImage.Width - 1, (int)sourceImage.Height - 1)))
			{
				SetDimmensionAndFormat(boundsRect.Width, boundsRect.Height, sourceImage.StrideInBytes(), sourceImage.BitDepth, sourceImage.GetBytesBetweenPixelsInclusive(), false);
				int bufferOffset = sourceImage.GetBufferOffsetXY(boundsRect.Left, boundsRect.Bottom);
				byte[] buffer = sourceImage.GetBuffer();
				SetBuffer(buffer, bufferOffset);
				return true;
			}

			return false;
		}

		protected void CopyFromNoClipping(IImageByte sourceImage, RectangleInt clippedSourceImageRect, int destXOffset, int destYOffset)
		{
			if (GetBytesBetweenPixelsInclusive() != BitDepth / 8
				|| sourceImage.GetBytesBetweenPixelsInclusive() != sourceImage.BitDepth / 8)
			{
				throw new Exception("WIP we only support packed pixel formats at this time.");
			}

			if (BitDepth == sourceImage.BitDepth)
			{
				int lengthInBytes = clippedSourceImageRect.Width * GetBytesBetweenPixelsInclusive();

				int sourceOffset = sourceImage.GetBufferOffsetXY(clippedSourceImageRect.Left, clippedSourceImageRect.Bottom);
				byte[] sourceBuffer = sourceImage.GetBuffer();
				int destOffset;
				byte[] destBuffer = GetPixelPointerXY(clippedSourceImageRect.Left + destXOffset, clippedSourceImageRect.Bottom + destYOffset, out destOffset);

				for (int i = 0; i < clippedSourceImageRect.Height; i++)
				{
					agg_basics.memmove(destBuffer, destOffset, sourceBuffer, sourceOffset, lengthInBytes);
					sourceOffset += sourceImage.StrideInBytes();
					destOffset += StrideInBytes();
				}
			}
			else
			{
				bool haveConversion = true;
				switch (sourceImage.BitDepth)
				{
					case 24:
						switch (BitDepth)
						{
							case 32:
								{
									int numPixelsToCopy = clippedSourceImageRect.Width;
									for (int i = clippedSourceImageRect.Bottom; i < clippedSourceImageRect.Top; i++)
									{
										int sourceOffset = sourceImage.GetBufferOffsetXY(clippedSourceImageRect.Left, clippedSourceImageRect.Bottom + i);
										byte[] sourceBuffer = sourceImage.GetBuffer();
										int destOffset;
										byte[] destBuffer = GetPixelPointerXY(
											clippedSourceImageRect.Left + destXOffset,
											clippedSourceImageRect.Bottom + i + destYOffset,
											out destOffset);
										for (int x = 0; x < numPixelsToCopy; x++)
										{
											destBuffer[destOffset++] = sourceBuffer[sourceOffset++];
											destBuffer[destOffset++] = sourceBuffer[sourceOffset++];
											destBuffer[destOffset++] = sourceBuffer[sourceOffset++];
											destBuffer[destOffset++] = 255;
										}
									}
								}
								break;

							default:
								haveConversion = false;
								break;
						}
						break;

					default:
						haveConversion = false;
						break;
				}

				if (!haveConversion)
				{
					throw new NotImplementedException("You need to write the " + sourceImage.BitDepth.ToString() + " to " + BitDepth.ToString() + " conversion");
				}
			}
		}

		/// <summary>
		/// This will create a new ImageBuffer that references the same memory as the image that you took the sub image from.
		/// It will modify the original main image when you draw to it.
		/// </summary>
		/// <param name="imageContainingSubImage"></param>
		/// <param name="subImageBounds"></param>
		/// <returns></returns>
		public static ImageBuffer NewSubImageReference(IImageByte imageContainingSubImage, RectangleDouble subImageBounds)
		{
			ImageBuffer subImage = new ImageBuffer();
			if (subImageBounds.Left < 0 || subImageBounds.Bottom < 0 || subImageBounds.Right > imageContainingSubImage.Width || subImageBounds.Top > imageContainingSubImage.Height
				|| subImageBounds.Left >= subImageBounds.Right || subImageBounds.Bottom >= subImageBounds.Top)
			{
				throw new ArgumentException("The subImageBounds must be on the image and valid.");
			}
			int left = Math.Max(0, (int)Math.Floor(subImageBounds.Left));
			int bottom = Math.Max(0, (int)Math.Floor(subImageBounds.Bottom));
			int width = Math.Min(imageContainingSubImage.Width - left, (int)subImageBounds.Width);
			int height = Math.Min(imageContainingSubImage.Height - bottom, (int)subImageBounds.Height);
			int bufferOffsetToFirstPixel = imageContainingSubImage.GetBufferOffsetXY(left, bottom);
			subImage.AttachBuffer(imageContainingSubImage.GetBuffer(), bufferOffsetToFirstPixel, width, height, imageContainingSubImage.StrideInBytes(), imageContainingSubImage.BitDepth, imageContainingSubImage.GetBytesBetweenPixelsInclusive());
			subImage.SetRecieveBlender(imageContainingSubImage.GetRecieveBlender());

			return subImage;
		}

		private void BlendInFilterPixel(int[] accumulatedColor, int back_r, int back_g, int back_b, int back_a, IImageByte SourceRenderingBuffer, int maxx, int maxy, int x_lr, int y_lr, int weight)
		{
			byte[] fg_ptr;
			unchecked
			{
				if ((uint)x_lr <= (uint)maxx && (uint)y_lr <= (uint)maxy)
				{
					int bufferIndex = SourceRenderingBuffer.GetBufferOffsetXY(x_lr, y_lr);
					fg_ptr = SourceRenderingBuffer.GetBuffer();

					accumulatedColor[0] += weight * fg_ptr[bufferIndex + ImageBuffer.OrderR];
					accumulatedColor[1] += weight * fg_ptr[bufferIndex + ImageBuffer.OrderG];
					accumulatedColor[2] += weight * fg_ptr[bufferIndex + ImageBuffer.OrderB];
					accumulatedColor[3] += weight * fg_ptr[bufferIndex + ImageBuffer.OrderA];
				}
				else
				{
					accumulatedColor[0] += back_r * weight;
					accumulatedColor[1] += back_g * weight;
					accumulatedColor[2] += back_b * weight;
					accumulatedColor[3] += back_a * weight;
				}
			}
		}

		// Create
		//--------------------------------------------------------------------
		public void create(IImageByte src)
		{
			// we are going to create a dilated image for filtering
			// we add m_dilation pixels to every side of the image and then copy the image in the x
			// direction into each end so that we can sample into this image to get filtering on x repeating
			// if the original image look like this
			//
			// 123456
			//
			// the new image would look like this
			//
			// 0000000000
			// 0000000000
			// 5612345612
			// 0000000000
			// 0000000000

			m_height = (int)agg_basics.uceil(src.Height);
			m_width = (int)agg_basics.uceil(src.Width);
			m_width_hr = (int)agg_basics.uround(src.Width * LineAABasics.line_subpixel_scale);
			m_half_height_hr = (int)agg_basics.uround(src.Height * LineAABasics.line_subpixel_scale / 2);
			m_offset_y_hr = m_dilation_hr + m_half_height_hr - LineAABasics.line_subpixel_scale / 2;
			m_half_height_hr += LineAABasics.line_subpixel_scale / 2;

			int bufferWidth = m_width + m_dilation * 2;
			int bufferHeight = m_height + m_dilation * 2;
			int bytesPerPixel = src.BitDepth / 8;
			int NewSizeInBytes = bufferWidth * bufferHeight * bytesPerPixel;
			if (m_DataSizeInBytes < NewSizeInBytes)
			{
				m_DataSizeInBytes = NewSizeInBytes;
				m_data = new byte[m_DataSizeInBytes];
			}

			m_buf.AttachBuffer(m_data, 0, bufferWidth, bufferHeight, bufferWidth * bytesPerPixel, src.BitDepth, bytesPerPixel);
			byte[] destBuffer = m_buf.GetBuffer();
			byte[] sourceBuffer = src.GetBuffer();

			// copy the image into the middle of the dest
			for (int y = 0; y < m_height; y++)
			{
				for (int x = 0; x < m_width; x++)
				{
					int sourceOffset = src.GetBufferOffsetXY(x, y);
					int destOffset = m_buf.GetBufferOffsetXY(m_dilation, y + m_dilation);
					for (int channel = 0; channel < bytesPerPixel; channel++)
					{
						destBuffer[destOffset++] = sourceBuffer[sourceOffset++];
					}
				}
			}

			// copy the first two pixels form the end into the beginning and from the beginning into the end
			for (int y = 0; y < m_height; y++)
			{
				int s1Offset = src.GetBufferOffsetXY(0, y);
				int d1Offset = m_buf.GetBufferOffsetXY(m_dilation + m_width, y);

				int s2Offset = src.GetBufferOffsetXY(m_width - m_dilation, y);
				int d2Offset = m_buf.GetBufferOffsetXY(0, y);

				for (int x = 0; x < m_dilation; x++)
				{
					for (int channel = 0; channel < bytesPerPixel; channel++)
					{
						destBuffer[d1Offset++] = sourceBuffer[s1Offset++];
						destBuffer[d2Offset++] = sourceBuffer[s2Offset++];
					}
				}
			}
		}