openCV/OpenCV/OpenCVClass.cs

using OpenCvSharp;
using System;

namespace OpenCV
{
    class OpenCVClass : IDisposable
    {
        IplImage gray;
        IplImage inversion;
        IplImage bin;
        IplImage blur;
        IplImage zoomin;
        IplImage zoomout;
        IplImage resize;
        IplImage slice;
        IplImage symm;
        IplImage rotate;
        IplImage affine;
        IplImage perspective;
        IplImage draw;

        public IplImage GrayScale(IplImage src)
        {
            gray = new IplImage(src.Size, BitDepth.U8, 1);
            Cv.CvtColor(src, gray, ColorConversion.BgrToGray);
            return gray;
        }

        public IplImage InversionImage(IplImage src)
        {
            inversion = new IplImage(src.Size, BitDepth.U8, 3);
            Cv.Not(src, inversion);
            return inversion;
        }

        public IplImage Binary(IplImage src)
        {
            bin = GrayScale(src);
            Cv.Threshold(bin, bin, 150, 255, ThresholdType.Binary);
            return bin;
        }

        public IplImage Blur(IplImage src)
        {
            blur = new IplImage(src.Size, BitDepth.U8, 3);
            Cv.Smooth(src, blur, SmoothType.Blur, 9); // param1은 홀수, 중간 픽셀 선택을 위함
            return blur;
        }

        public IplImage ZoomIn(IplImage src)
        {
            zoomin = new IplImage(new CvSize(src.Width * 2, src.Height * 2) , BitDepth.U8, 3);
            Cv.PyrUp(src, zoomin, CvFilter.Gaussian5x5);
            return zoomin;
        }

        public IplImage ZoomOut(IplImage src)
        {
            zoomout = new IplImage(new CvSize(src.Width / 2, src.Height / 2), BitDepth.U8, 3);
            Cv.PyrDown(src, zoomout, CvFilter.Gaussian5x5);
            return zoomout;
        }

        public IplImage Resize(IplImage src, double widthRate, double heightRate)
        {
            resize = new IplImage(new CvSize((int)(src.Width * widthRate), (int)(src.Height * heightRate)), BitDepth.U8, 3);
            Cv.Resize(src, resize, Interpolation.Linear);
            return resize;
        }

        public IplImage Slice(IplImage src, int x, int y, int roiWidht, int roiHeight)
        {
            //slice = new IplImage(new CvSize(roiWidht, roiHeight), BitDepth.U8, 3);

            //src.ROI = new CvRect(x, y, roiWidht, roiHeight);
            //src.SetROI(new CvRect(x, y, roiWidht, roiHeight));
            //Cv.SetImageROI(src, new CvRect(x, y, roiWidht, roiHeight));

            //Cv.Copy(src, slice);
            //Cv.Resize(src, slice);
            //slice = src.Clone(); // 속성까지 복사되어 채널 등 값이 변경됨

            //src.ResetROI();
            //Cv.ResetImageROI(src);

            CvRect roi = new CvRect(x, y, roiWidht, roiHeight);
            slice = src.Clone(roi);

            return slice;
        }

        public IplImage Symmetry(IplImage src, FlipMode mode)
        {
            symm = new IplImage(src.Size, BitDepth.U8, 3);
            Cv.Flip(src, symm, mode);
            return symm;
        }

        public IplImage Rotate(IplImage src, double angle)
        {
            rotate = new IplImage(src.Size, BitDepth.U8, 3);
            CvMat matrix = Cv.GetRotationMatrix2D(new CvPoint2D32f(src.Width / 2, src.Height / 2), angle, 1);
            Cv.WarpAffine(src, rotate, matrix, Interpolation.Linear, CvScalar.ScalarAll(0));
            return rotate;
        }

        public IplImage AffineImage(IplImage src, CvPoint2D32f[] srcPoints, CvPoint2D32f[] dstPoints)
        {
            if (srcPoints.Length != 3 || dstPoints.Length != 3)
                return null;

            affine = new IplImage(src.Size, BitDepth.U8, 3);
            CvMat matrix = Cv.GetAffineTransform(srcPoints, dstPoints);
            Cv.WarpAffine(src, affine, matrix, Interpolation.Linear, CvScalar.RealScalar(0));
            return affine;
        }

        public IplImage PerspectiveImage(IplImage src, CvPoint2D32f[] srcPoints, CvPoint2D32f[] dstPoints)
        {
            if (srcPoints.Length != 4 || dstPoints.Length != 4)
                return null;

            perspective = new IplImage(src.Size, BitDepth.U8, 3);
            CvMat matrix = Cv.GetPerspectiveTransform(srcPoints, dstPoints);
            Cv.WarpPerspective(src, perspective, matrix, Interpolation.Linear, CvScalar.RealScalar(0));
            return perspective;
        }

        public IplImage DrawImage()
        {
            draw = new IplImage(new CvSize(640, 480), BitDepth.U8, 3);
        }

        private void Release(params IplImage[] images)
        {
            for (int i = 0; i < images.Length; i++)
            {
                if (images[i] != null)
                    Cv.ReleaseImage(images[i]);
            }
        }

        public void Dispose()
        {
            Release(
                gray,
                inversion,
                bin,
                blur,
                zoomin,
                zoomout,
                resize,
                slice,
                symm,
                rotate,
                affine,
                perspective,
                draw
                );
        }
    }
}