[C#/WINFORM] Bitmap 클래스 : 비트맵 자르기(Shear)

TestProject.zip

다운로드

▶ BitmapHelper.cs

using System;
using System.Drawing;
using System.Drawing.Imaging;
using System.Runtime.InteropServices;

namespace TestProject
{
    /// <summary>
    /// 비트맵 헬퍼
    /// </summary>
    public static class BitmapHelper
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Method
        ////////////////////////////////////////////////////////////////////////////////////////// Static
        //////////////////////////////////////////////////////////////////////////////// Public

        #region 비트맵 로드하기 - LoadBitmap(filePath)

        /// <summary>
        /// 비트맵 로드하기
        /// </summary>
        /// <param name="filePath">파일 경로</param>
        /// <returns>비트맵</returns>
        public static Bitmap LoadBitmap(string filePath)
        {
            using(Bitmap bitmap = new Bitmap(filePath))
            {
                return new Bitmap(bitmap);
            }
        }

        #endregion
        #region 비트맵 자르기 - ShearBitmap(sourceBitmap, shearX, shearY)

        /// <summary>
        /// 비트맵 자르기
        /// </summary>
        /// <param name="sourceBitmap">소스 비트맵</param>
        /// <param name="shearX">자르기 X</param>
        /// <param name="shearY">자르기 Y</param>
        /// <returns>비트맵</returns>
        public static Bitmap ShearBitmap(Bitmap sourceBitmap, double shearX, double shearY)
        {
            BitmapData sourceBitmapData = sourceBitmap.LockBits
            (
                new Rectangle(0, 0, sourceBitmap.Width, sourceBitmap.Height),
                ImageLockMode.ReadOnly,
                PixelFormat.Format32bppArgb
            );

            byte[] sourceByteArray = new byte[sourceBitmapData.Stride * sourceBitmapData.Height];
            byte[] targetByteArray = new byte[sourceBitmapData.Stride * sourceBitmapData.Height];

            Marshal.Copy(sourceBitmapData.Scan0, sourceByteArray, 0, sourceByteArray.Length);

            sourceBitmap.UnlockBits(sourceBitmapData);

            int xOffset = (int )Math.Round(sourceBitmap.Width  * shearX / 2.0);
            int yOffset = (int )Math.Round(sourceBitmap.Height * shearY / 2.0);

            int sourceXY = 0;
            int targetXY = 0;

            Point sourcePoint = new Point();
            Point targetPoint = new Point();

            Rectangle sourceRectangle = new Rectangle(0, 0, sourceBitmap.Width, sourceBitmap.Height);

            for(int y = 0; y < sourceBitmap.Height; y++)
            {
                for(int x = 0; x < sourceBitmap.Width; x++)
                {
                    sourceXY = y * sourceBitmapData.Stride + x * 4;

                    sourcePoint.X = x;
                    sourcePoint.Y = y;

                    if(sourceXY >= 0 && sourceXY + 3 < sourceByteArray.Length)
                    {
                        targetPoint = ShearXY(sourcePoint, shearX, shearY, xOffset, yOffset);

                        targetXY = targetPoint.Y * sourceBitmapData.Stride + targetPoint.X * 4;

                        if(sourceRectangle.Contains(targetPoint) && targetXY >= 0)
                        {
                            if(targetXY + 6 <= targetByteArray.Length)
                            {
                                targetByteArray[targetXY + 4] = sourceByteArray[sourceXY    ];
                                targetByteArray[targetXY + 5] = sourceByteArray[sourceXY + 1];
                                targetByteArray[targetXY + 6] = sourceByteArray[sourceXY + 2];
                                targetByteArray[targetXY + 7] = 255;
                            }

                            if(targetXY - 3 >= 0)
                            {
                                targetByteArray[targetXY - 4] = sourceByteArray[sourceXY    ];
                                targetByteArray[targetXY - 3] = sourceByteArray[sourceXY + 1];
                                targetByteArray[targetXY - 2] = sourceByteArray[sourceXY + 2];
                                targetByteArray[targetXY - 1] = 255;
                            }

                            if(targetXY + 3 < targetByteArray.Length)
                            {
                                targetByteArray[targetXY    ] = sourceByteArray[sourceXY    ];
                                targetByteArray[targetXY + 1] = sourceByteArray[sourceXY + 1];
                                targetByteArray[targetXY + 2] = sourceByteArray[sourceXY + 2];
                                targetByteArray[targetXY + 3] = 255;
                            }
                        }
                    }
                }
            }

            Bitmap targetBitmap = new Bitmap(sourceBitmap.Width, sourceBitmap.Height);

            BitmapData targetBitmapData = targetBitmap.LockBits
            (
                new Rectangle(0, 0, targetBitmap.Width, targetBitmap.Height),
                ImageLockMode.WriteOnly,
                PixelFormat.Format32bppArgb
            );

            Marshal.Copy(targetByteArray, 0, targetBitmapData.Scan0, targetByteArray.Length);

            targetBitmap.UnlockBits(targetBitmapData);

            return targetBitmap;
        }

        #endregion

        //////////////////////////////////////////////////////////////////////////////// Private

        #region XY 자르기 - ShearXY(sourcePoint, shearX, shearY, offsetX, offsetY)

        /// <summary>
        /// XY 자르기
        /// </summary>
        /// <param name="sourcePoint">소스 포인트</param>
        /// <param name="shearX">자르기 X</param>
        /// <param name="shearY">자르기 Y</param>
        /// <param name="offsetX">오프셋 X</param>
        /// <param name="offsetY">오프셋 Y</param>
        /// <returns>포인트</returns>
        private static Point ShearXY(Point sourcePoint, double shearX, double shearY, int offsetX, int offsetY)
        {
            Point targetPoint = new Point();

            targetPoint.X = (int)(Math.Round(sourcePoint.X + shearX * sourcePoint.Y));

            targetPoint.X -= offsetX;

            targetPoint.Y = (int)(Math.Round(sourcePoint.Y + shearY * sourcePoint.X));

            targetPoint.Y -= offsetY;

            return targetPoint;
        }

        #endregion
    }
}

 

728x90

 

▶ MainForm.cs

using System.Drawing;
using System.Windows.Forms;

namespace TestProject
{
    /// <summary>
    /// 메인 폼
    /// </summary>
    public partial class MainForm : Form
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Constructor
        ////////////////////////////////////////////////////////////////////////////////////////// Public

        #region 생성자 - MainForm()

        /// <summary>
        /// 생성자
        /// </summary>
        public MainForm()
        {
            InitializeComponent();

            Bitmap sourceBitmap = BitmapHelper.LoadBitmap("IMAGE\\sample.jpg");
            Bitmap targetBitmap = BitmapHelper.ShearBitmap(sourceBitmap, 0.0, 1.0);

            this.pictureBox.SizeMode = PictureBoxSizeMode.Zoom;
            this.pictureBox.Image    = targetBitmap;
        }

        #endregion
    }
}