EMGUCV Archives - icodebroker

[C#/WINFORM/EMGUCV] Tesseract OCR 문자 인식하기

■ Tesseract OCR 문자를 인식하는 방법을 보여준다. ▶ MainForm.cs


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

using Emgu.CV;
using Emgu.CV.OCR;
using Emgu.CV.Structure;

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

        #region Field

        /// <summary>
        /// TESSERACT
        /// </summary>
        private Tesseract tesseract;

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Constructor
        ////////////////////////////////////////////////////////////////////////////////////////// Public

        #region 생성자 - MainForm()

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

            this.tesseract = new Tesseract("", "eng", Tesseract.OcrEngineMode.OEM_TESSERACT_CUBE_COMBINED);

            this.languageValueLabel.Text = "eng : tesseract + cube";

            this.loadLanguageMenuItem.Click += loadLanguageMenuItem_Click;
            this.loadImageButton.Click      += loadImageButton_Click;
        }

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Method
        ////////////////////////////////////////////////////////////////////////////////////////// Private

        #region 언어 로드 메뉴 항목 클릭시 처리하기 - loadLanguageMenuItem_Click(sender, e)

        /// <summary>
        /// 언어 로드 메뉴 항목 클릭시 처리하기
        /// </summary>
        /// <param name="sender">이벤트 발생자</param>
        /// <param name="e">이벤트 인자</param>
        private void loadLanguageMenuItem_Click(object sender, EventArgs e)
        {
            if(this.languageOpenFileDialog.ShowDialog() == DialogResult.OK)
            {
                this.tesseract.Dispose();

                string filePath = Path.GetDirectoryName(this.languageOpenFileDialog.FileName);

                string language =  Path.GetFileNameWithoutExtension(this.languageOpenFileDialog.FileName).Split('.')[0];

                this.tesseract = new Tesseract(filePath, language, Tesseract.OcrEngineMode.OEM_DEFAULT);

                this.languageValueLabel.Text = String.Format("{0} : tesseract", language);
            }
        }

        #endregion
        #region 이미지 로드 버튼 클릭시 처리하기 - loadImageButton_Click(sender, e)

        /// <summary>
        /// 이미지 로드 버튼 클릭시 처리하기
        /// </summary>
        /// <param name="sender">이벤트 발생자</param>
        /// <param name="e">이벤트 인자</param>
        private void loadImageButton_Click(object sender, EventArgs e)
        {
            if(this.imageOpenFileDialog.ShowDialog() == DialogResult.OK)
            {
                Bgr blueBgr = new Bgr(Color.Blue);

                try
                {
                    Image<Bgr, Byte> image = new Image<Bgr, byte>(this.imageOpenFileDialog.FileName);

                    using(Image<Gray, byte> grayImage = image.Convert<Gray, Byte>())
                    {
                        this.tesseract.Recognize(grayImage);

                        Tesseract.Charactor[] charactorArray = this.tesseract.GetCharactors();

                        foreach(Tesseract.Charactor character in charactorArray)
                        {
                            image.Draw(character.Region, blueBgr, 1);
                        }

                        this.imageBox.Image = image;

                        string result = this.tesseract.GetText();

                        this.resultTextBox.Text = result;
                    }
                }
                catch(Exception exception)
                {
                    MessageBox.Show(exception.Message);
                }
            }
        }

        #endregion
    }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

using System;

using System.Drawing;

using System.IO;

using System.Windows.Forms;

using Emgu.CV;

using Emgu.CV.OCR;

using Emgu.CV.Structure;

namespace TestProject

{

/// <summary>

/// 메인 폼

/// </summary>

public partial class MainForm : Form

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Field

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

#region Field

/// <summary>

/// TESSERACT

/// </summary>

private Tesseract tesseract;

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Constructor

////////////////////////////////////////////////////////////////////////////////////////// Public

#region 생성자 - MainForm()

/// <summary>

/// 생성자

/// </summary>

public MainForm()

{

InitializeComponent();

this.tesseract = new Tesseract("", "eng", Tesseract.OcrEngineMode.OEM_TESSERACT_CUBE_COMBINED);

this.languageValueLabel.Text = "eng : tesseract + cube";

this.loadLanguageMenuItem.Click += loadLanguageMenuItem_Click;

this.loadImageButton.Click += loadImageButton_Click;

}

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

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

#region 언어 로드 메뉴 항목 클릭시 처리하기 - loadLanguageMenuItem_Click(sender, e)

/// <summary>

/// 언어 로드 메뉴 항목 클릭시 처리하기

/// </summary>

/// <param name="sender">이벤트 발생자</param>

/// <param name="e">이벤트 인자</param>

private void loadLanguageMenuItem_Click(object sender, EventArgs e)

{

if(this.languageOpenFileDialog.ShowDialog() == DialogResult.OK)

{

this.tesseract.Dispose();

string filePath = Path.GetDirectoryName(this.languageOpenFileDialog.FileName);

string language = Path.GetFileNameWithoutExtension(this.languageOpenFileDialog.FileName).Split('.')[0];

this.tesseract = new Tesseract(filePath, language, Tesseract.OcrEngineMode.OEM_DEFAULT);

this.languageValueLabel.Text = String.Format("{0} : tesseract", language);

}

#endregion

#region 이미지 로드 버튼 클릭시 처리하기 - loadImageButton_Click(sender, e)

/// <summary>

/// 이미지 로드 버튼 클릭시 처리하기

/// </summary>

/// <param name="sender">이벤트 발생자</param>

/// <param name="e">이벤트 인자</param>

private void loadImageButton_Click(object sender, EventArgs e)

{

if(this.imageOpenFileDialog.ShowDialog() == DialogResult.OK)

{

Bgr blueBgr = new Bgr(Color.Blue);

try

{

Image<Bgr, Byte> image = new Image<Bgr, byte>(this.imageOpenFileDialog.FileName);

using(Image<Gray, byte> grayImage = image.Convert<Gray, Byte>())

{

this.tesseract.Recognize(grayImage);

Tesseract.Charactor[] charactorArray = this.tesseract.GetCharactors();

foreach(Tesseract.Charactor character in charactorArray)

{

image.Draw(character.Region, blueBgr, 1);

}

this.imageBox.Image = image;

string result = this.tesseract.GetText();

this.resultTextBox.Text = result;

}

catch(Exception exception)

{

MessageBox.Show(exception.Message);

}

#endregion

}

TestProject.zip

[C#/WINFORM/EMGUCV] 입체 사진 만들기

■ 입체 사진을 만드는 방법을 보여준다. ▶ MainForm.cs


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

using Emgu.CV;
using Emgu.CV.Structure;

using OpenTK.Graphics;
using OpenTK.Graphics.OpenGL;

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

        #region Field

        /// <summary>
        /// 왼쪽 이미지
        /// </summary>
        private Image<Bgr, Byte> leftImage;

        /// <summary>
        /// 오른쪽 이미지
        /// </summary>
        private Image<Bgr, byte> rightImage;

        /// <summary>
        /// 3D 포인트 배열
        /// </summary>
        private MCvPoint3D32f[] point3DArray;


        /// <summary>
        /// GL 로드 여부
        /// </summary>
        private bool giLoaded = false;

        /// <summary>
        /// 텍스처 배열
        /// </summary>
        private int[] textureArray;

        /// <summary>
        /// 텍스처 이미지
        /// </summary>
        private Image<Bgr, Byte> textureImage;

        /// <summary>
        /// 각도
        /// </summary>
        private double angle = 0.0;

        /// <summary>
        /// 각도 증가치
        /// </summary>
        private double angleIncrement = 0.2;

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Constructor
        ////////////////////////////////////////////////////////////////////////////////////////// Public

        #region 생성자 - MainForm()

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

            this.leftImage  = new Image<Bgr, byte>("imageLeft.png" );
            this.rightImage = new Image<Bgr, byte>("imageRight.png");

            Image<Gray, short> disparityMapImage;

            Computer3DPointArray
            (
                leftImage.Convert<Gray, Byte>(),
                rightImage.Convert<Gray, Byte>(),
                out disparityMapImage,
                out this.point3DArray
            );

            this.disparityMapImageBox.Image = disparityMapImage;

            FormClosed                  += Form_FormClosed;
            this.resultGlControl.Load   += resultGlControl_Load;
            this.resultGlControl.Paint  += resultGlControl_Paint;
            this.resultGlControl.Resize += resultGlControl_Resize;
        }

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Method
        ////////////////////////////////////////////////////////////////////////////////////////// Private
        //////////////////////////////////////////////////////////////////////////////// Event

        #region 폼 닫은 경우 처리하기 - Form_FormClosed(sender, e)

        /// <summary>
        /// 폼 닫은 경우 처리하기
        /// </summary>
        /// <param name="sender">이벤트 발생자</param>
        /// <param name="e">이벤트 인자</param>
        private void Form_FormClosed(object sender, FormClosedEventArgs e)
        {
            this.resultGlControl.Dispose();
        }

        #endregion
        #region 결과 GL 컨트롤 로드시 처리하기 - resultGlControl_Load(sender, e)

        /// <summary>
        /// 결과 GL 컨트롤 로드시 처리하기
        /// </summary>
        /// <param name="sender">이벤트 발생자</param>
        /// <param name="e">이벤트 인자</param>
        private void resultGlControl_Load(object sender, EventArgs e)
        {
            this.giLoaded = true;

            GL.ClearColor(0.0f, 0.0f, 0.0f, 0.0f);

            SetupViewport();

            #region 3D 포인트 클라아두를 위한 텍스처를 생성한다.

            int repeat = (int)All.Repeat;
            int linear = (int)All.Linear;

            GL.Enable(EnableCap.CullFace);
            GL.Enable(EnableCap.Texture2D);

            this.textureArray = new int[1];

            GL.GenTextures(1, this.textureArray);

            GL.BindTexture(TextureTarget.Texture2D, this.textureArray[0]);

            GL.TexParameterI(TextureTarget.Texture2D, TextureParameterName.TextureWrapS    , ref repeat);
            GL.TexParameterI(TextureTarget.Texture2D, TextureParameterName.TextureWrapT    , ref repeat);
            GL.TexParameterI(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, ref linear);
            GL.TexParameterI(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, ref linear);

            GL.TexEnv(TextureEnvTarget.TextureEnv, TextureEnvParameter.TextureEnvMode, (int)All.Decal);

            GL.ShadeModel(ShadingModel.Smooth);

            GL.Hint(HintTarget.PerspectiveCorrectionHint, HintMode.Nicest);

            GL.BindTexture(TextureTarget.Texture2D, 1);

            Size imageSize = leftImage.Size;

            int maximumDimension = Math.Max(imageSize.Width, imageSize.Height);

            using(Image<Bgr, Byte> squareImage = new Image<Bgr, byte>(maximumDimension, maximumDimension))
            {
                Rectangle roiRectangle = new Rectangle
                (
                    maximumDimension / 2 - imageSize.Width  / 2,
                    maximumDimension / 2 - imageSize.Height / 2,
                    imageSize.Width,
                    imageSize.Height
                );

                squareImage.ROI = roiRectangle;

                CvInvoke.cvCopy(leftImage, squareImage, IntPtr.Zero);

                squareImage.ROI = Rectangle.Empty;

                this.textureImage = squareImage.Resize(512, 512, Emgu.CV.CvEnum.INTER.CV_INTER_CUBIC, true);

                this.textureImage._Flip(Emgu.CV.CvEnum.FLIP.VERTICAL);

                GL.TexImage2D
                (
                    TextureTarget.Texture2D,
                    0,
                    PixelInternalFormat.Rgb8,
                    this.textureImage.Width,
                    this.textureImage.Height,
                    0,
                    PixelFormat.Bgr,
                    PixelType.UnsignedByte,
                    this.textureImage.MIplImage.imageData
                );
            }

            #endregion
        }

        #endregion
        #region 결과 GL 컨트롤 크기 변경시 처리하기 - resultGlControl_Resize(sender, e)

        /// <summary>
        /// 결과 GL 컨트롤 크기 변경시 처리하기
        /// </summary>
        /// <param name="sender">이벤트 발생자</param>
        /// <param name="e">이벤트 인자</param>
        private void resultGlControl_Resize(object sender, EventArgs e)
        {
            if(!this.giLoaded)
            {
                return;
            }

            SetupViewport();
        }

        #endregion
        #region 결과 GL 컨트롤 PAINT 처리하기 - resultGlControl_Paint(sender, e)

        /// <summary>
        /// 결과 GL 컨트롤 PAINT 처리하기
        /// </summary>
        /// <param name="sender">이벤트 발생자</param>
        /// <param name="e">이벤트 인자</param>
        private void resultGlControl_Paint(object sender, PaintEventArgs e)
        {
            if(!this.giLoaded)
            {
                return;
            }

            GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);

            GL.Enable(EnableCap.Texture2D);

            GL.PushMatrix();

            GL.Rotate(10.0, 0.0, 1.0, 0.0);

            GL.Rotate(this.angle, 0.0, 1.0, 0.0);

            GL.Begin(BeginMode.Points);

            GL.Color4(1.0, 1.0, 1.0, 1.0);

            foreach(MCvPoint3D32f point3D in this.point3DArray)
            {
                GL.TexCoord2(point3D.x + 0.5f, point3D.y + 0.5f);

                GL.Vertex3(point3D.x, point3D.y, point3D.z);
            }

            GL.End();

            GL.PopMatrix();

            if(this.angle >= 30.0 || this.angle <= -30.0)
            {
                this.angleIncrement = -this.angleIncrement;
            }

            this.angle += this.angleIncrement;

            GraphicsContext.CurrentContext.SwapBuffers();

            this.resultGlControl.Invalidate();
        }

        #endregion

        //////////////////////////////////////////////////////////////////////////////// Function

        #region 3D 포인트 배열 계산하기 - Computer3DPointArray(leftImage, rightImage, disparityMapImage, point3DArray)

        /// <summary>
        /// 3D 포인트 배열 계산하기
        /// </summary>
        /// <param name="leftImage">왼쪽 이미지</param>
        /// <param name="rightImage">오른쪽 이미지</param>
        /// <param name="disparityMapImage">차이 맵 이미지</param>
        /// <param name="point3DArray">3D 포인트 배열</param>
        private static void Computer3DPointArray(Image<Gray, Byte> leftImage, Image<Gray, Byte> rightImage, out Image<Gray, short> disparityMapImage,
            out MCvPoint3D32f[] point3DArray)
        {
            Size imageSize = leftImage.Size;

            disparityMapImage = new Image<Gray, short>(imageSize);

          //using(StereoSGBM stereoSolver = new StereoSGBM(5, 64, 0, 0, 0, 0, 0, 0, 0, 0, StereoSGBM.Mode.SGBM))
            using(StereoBM stereoSolver = new StereoBM(Emgu.CV.CvEnum.STEREO_BM_TYPE.BASIC, 0))
            {
                stereoSolver.FindStereoCorrespondence(leftImage, rightImage, disparityMapImage);

                float scale = Math.Max(imageSize.Width, imageSize.Height);

                using
                (
                    Matrix<double> qMartix = new Matrix<double>
                    (
                        new double[,]
                        {
                            { 1.0,  0.0,  0.0, -imageSize.Width  / 2 },
                            { 0.0, -1.0,  0.0,  imageSize.Height / 2 },
                            { 0.0,  0.0, -1.0,  0.0                  },
                            { 0.0,  0.0,  0.0,  scale                }
                        }
                    )
                )
                {
                    point3DArray = PointCollection.ReprojectImageTo3D(disparityMapImage, qMartix);
                }
            }
        }

        #endregion
        #region 뷰포트 셋업하기 - SetupViewport()

        /// <summary>
        /// 뷰포트 셋업하기
        /// </summary>
        private void SetupViewport()
        {
            int width  = this.resultGlControl.Width;
            int height = this.resultGlControl.Height;

            GL.MatrixMode(MatrixMode.Projection);

            GL.LoadIdentity();

            GL.Ortho(-1.5, 1.5, -1.5, 1.5, -1.5, 1.5);

            GL.Viewport(0, 0, width, height);
        }

        #endregion
    }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

using System;

using System.Drawing;

using System.Windows.Forms;

using Emgu.CV;

using Emgu.CV.Structure;

using OpenTK.Graphics;

using OpenTK.Graphics.OpenGL;

namespace TestProject

{

/// <summary>

/// 메인 폼

/// </summary>

public partial class MainForm : Form

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Field

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

#region Field

/// <summary>

/// 왼쪽 이미지

/// </summary>

private Image<Bgr, Byte> leftImage;

/// <summary>

/// 오른쪽 이미지

/// </summary>

private Image<Bgr, byte> rightImage;

/// <summary>

/// 3D 포인트 배열

/// </summary>

private MCvPoint3D32f[] point3DArray;

/// <summary>

/// GL 로드 여부

/// </summary>

private bool giLoaded = false;

/// <summary>

/// 텍스처 배열

/// </summary>

private int[] textureArray;

/// <summary>

/// 텍스처 이미지

/// </summary>

private Image<Bgr, Byte> textureImage;

/// <summary>

/// 각도

/// </summary>

private double angle = 0.0;

/// <summary>

/// 각도 증가치

/// </summary>

private double angleIncrement = 0.2;

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Constructor

////////////////////////////////////////////////////////////////////////////////////////// Public

#region 생성자 - MainForm()

/// <summary>

/// 생성자

/// </summary>

public MainForm()

{

InitializeComponent();

this.leftImage = new Image<Bgr, byte>("imageLeft.png" );

this.rightImage = new Image<Bgr, byte>("imageRight.png");

Image<Gray, short> disparityMapImage;

Computer3DPointArray

(

leftImage.Convert<Gray, Byte>(),

rightImage.Convert<Gray, Byte>(),

out disparityMapImage,

out this.point3DArray

);

this.disparityMapImageBox.Image = disparityMapImage;

FormClosed += Form_FormClosed;

this.resultGlControl.Load += resultGlControl_Load;

this.resultGlControl.Paint += resultGlControl_Paint;

this.resultGlControl.Resize += resultGlControl_Resize;

}

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

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

//////////////////////////////////////////////////////////////////////////////// Event

#region 폼 닫은 경우 처리하기 - Form_FormClosed(sender, e)

/// <summary>

/// 폼 닫은 경우 처리하기

/// </summary>

/// <param name="sender">이벤트 발생자</param>

/// <param name="e">이벤트 인자</param>

private void Form_FormClosed(object sender, FormClosedEventArgs e)

{

this.resultGlControl.Dispose();

}

#endregion

#region 결과 GL 컨트롤 로드시 처리하기 - resultGlControl_Load(sender, e)

/// <summary>

/// 결과 GL 컨트롤 로드시 처리하기

/// </summary>

/// <param name="sender">이벤트 발생자</param>

/// <param name="e">이벤트 인자</param>

private void resultGlControl_Load(object sender, EventArgs e)

{

this.giLoaded = true;

GL.ClearColor(0.0f, 0.0f, 0.0f, 0.0f);

SetupViewport();

#region 3D 포인트 클라아두를 위한 텍스처를 생성한다.

int repeat = (int)All.Repeat;

int linear = (int)All.Linear;

GL.Enable(EnableCap.CullFace);

GL.Enable(EnableCap.Texture2D);

this.textureArray = new int[1];

GL.GenTextures(1, this.textureArray);

GL.BindTexture(TextureTarget.Texture2D, this.textureArray[0]);

GL.TexParameterI(TextureTarget.Texture2D, TextureParameterName.TextureWrapS , ref repeat);

GL.TexParameterI(TextureTarget.Texture2D, TextureParameterName.TextureWrapT , ref repeat);

GL.TexParameterI(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, ref linear);

GL.TexParameterI(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, ref linear);

GL.TexEnv(TextureEnvTarget.TextureEnv, TextureEnvParameter.TextureEnvMode, (int)All.Decal);

GL.ShadeModel(ShadingModel.Smooth);

GL.Hint(HintTarget.PerspectiveCorrectionHint, HintMode.Nicest);

GL.BindTexture(TextureTarget.Texture2D, 1);

Size imageSize = leftImage.Size;

int maximumDimension = Math.Max(imageSize.Width, imageSize.Height);

using(Image<Bgr, Byte> squareImage = new Image<Bgr, byte>(maximumDimension, maximumDimension))

{

Rectangle roiRectangle = new Rectangle

(

maximumDimension / 2 - imageSize.Width / 2,

maximumDimension / 2 - imageSize.Height / 2,

imageSize.Width,

imageSize.Height

);

squareImage.ROI = roiRectangle;

CvInvoke.cvCopy(leftImage, squareImage, IntPtr.Zero);

squareImage.ROI = Rectangle.Empty;

this.textureImage = squareImage.Resize(512, 512, Emgu.CV.CvEnum.INTER.CV_INTER_CUBIC, true);

this.textureImage._Flip(Emgu.CV.CvEnum.FLIP.VERTICAL);

GL.TexImage2D

(

TextureTarget.Texture2D,

PixelInternalFormat.Rgb8,

this.textureImage.Width,

this.textureImage.Height,

PixelFormat.Bgr,

PixelType.UnsignedByte,

this.textureImage.MIplImage.imageData

);

}

#endregion

}

#endregion

#region 결과 GL 컨트롤 크기 변경시 처리하기 - resultGlControl_Resize(sender, e)

/// <summary>

/// 결과 GL 컨트롤 크기 변경시 처리하기

/// </summary>

/// <param name="sender">이벤트 발생자</param>

/// <param name="e">이벤트 인자</param>

private void resultGlControl_Resize(object sender, EventArgs e)

{

if(!this.giLoaded)

{

return;

}

SetupViewport();

}

#endregion

#region 결과 GL 컨트롤 PAINT 처리하기 - resultGlControl_Paint(sender, e)

/// <summary>

/// 결과 GL 컨트롤 PAINT 처리하기

/// </summary>

/// <param name="sender">이벤트 발생자</param>

/// <param name="e">이벤트 인자</param>

private void resultGlControl_Paint(object sender, PaintEventArgs e)

{

if(!this.giLoaded)

{

return;

}

GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);

GL.Enable(EnableCap.Texture2D);

GL.PushMatrix();

GL.Rotate(10.0, 0.0, 1.0, 0.0);

GL.Rotate(this.angle, 0.0, 1.0, 0.0);

GL.Begin(BeginMode.Points);

GL.Color4(1.0, 1.0, 1.0, 1.0);

foreach(MCvPoint3D32f point3D in this.point3DArray)

{

GL.TexCoord2(point3D.x + 0.5f, point3D.y + 0.5f);

GL.Vertex3(point3D.x, point3D.y, point3D.z);

}

GL.End();

GL.PopMatrix();

if(this.angle >= 30.0 || this.angle <= -30.0)

{

this.angleIncrement = -this.angleIncrement;

}

this.angle += this.angleIncrement;

GraphicsContext.CurrentContext.SwapBuffers();

this.resultGlControl.Invalidate();

}

#endregion

//////////////////////////////////////////////////////////////////////////////// Function

#region 3D 포인트 배열 계산하기 - Computer3DPointArray(leftImage, rightImage, disparityMapImage, point3DArray)

/// <summary>

/// 3D 포인트 배열 계산하기

/// </summary>

/// <param name="leftImage">왼쪽 이미지</param>

/// <param name="rightImage">오른쪽 이미지</param>

/// <param name="disparityMapImage">차이 맵 이미지</param>

/// <param name="point3DArray">3D 포인트 배열</param>

private static void Computer3DPointArray(Image<Gray, Byte> leftImage, Image<Gray, Byte> rightImage, out Image<Gray, short> disparityMapImage,

out MCvPoint3D32f[] point3DArray)

{

Size imageSize = leftImage.Size;

disparityMapImage = new Image<Gray, short>(imageSize);

//using(StereoSGBM stereoSolver = new StereoSGBM(5, 64, 0, 0, 0, 0, 0, 0, 0, 0, StereoSGBM.Mode.SGBM))

using(StereoBM stereoSolver = new StereoBM(Emgu.CV.CvEnum.STEREO_BM_TYPE.BASIC, 0))

{

stereoSolver.FindStereoCorrespondence(leftImage, rightImage, disparityMapImage);

float scale = Math.Max(imageSize.Width, imageSize.Height);

using

(

Matrix<double> qMartix = new Matrix<double>

(

new double[,]

{

{ 1.0, 0.0, 0.0, -imageSize.Width / 2 },

{ 0.0, -1.0, 0.0, imageSize.Height / 2 },

{ 0.0, 0.0, -1.0, 0.0 },

{ 0.0, 0.0, 0.0, scale }

}

)

{

point3DArray = PointCollection.ReprojectImageTo3D(disparityMapImage, qMartix);

}

#endregion

#region 뷰포트 셋업하기 - SetupViewport()

/// <summary>

/// 뷰포트 셋업하기

/// </summary>

private void SetupViewport()

{

int width = this.resultGlControl.Width;

int height = this.resultGlControl.Height;

GL.MatrixMode(MatrixMode.Projection);

GL.LoadIdentity();

GL.Ortho(-1.5, 1.5, -1.5, 1.5, -1.5, 1.5);

GL.Viewport(0, 0, width, height);

}

#endregion

}

TestProject.zip

[C#/WINFORM/EMGUCV] 보행자 검출하기 (Pedestrain Detection)

■ 보행자를 검출하는 방법을 보여준다. (Pedestrain Detection) ▶ PedestrianDetectionHelper.cs


using System;
using System.Diagnostics;

using Emgu.CV;
using Emgu.CV.Structure;
using System.Drawing;
#if !IOS
using Emgu.CV.GPU;
#endif

namespace TestProject
{
    /// <summary>
    /// 보행자 검출 헬퍼
    /// </summary>
    public static class PedestrianDetectionHelper
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Method
        ////////////////////////////////////////////////////////////////////////////////////////// Static
        //////////////////////////////////////////////////////////////////////////////// Public

        #region 찾기 - Find(image, processingTime)

        /// <summary>
        /// 찾기
        /// </summary>
        /// <param name="image">이미지</param>
        /// <param name="processingTime">처리 시간</param>
        /// <returns>결과 사각형 배열</returns>
        public static Rectangle[] Find(Image<Bgr, Byte> image, out long processingTime)
        {
            Stopwatch   stopwatch;
            Rectangle[] resultRectangleArray;

            stopwatch = Stopwatch.StartNew();

#if !IOS
            if(GpuInvoke.HasCuda)
            {
                using(GpuHOGDescriptor descriptor = new GpuHOGDescriptor())
                {
                    descriptor.SetSVMDetector(GpuHOGDescriptor.GetDefaultPeopleDetector());

                    using(GpuImage<Bgr, Byte> bgrImage = new GpuImage<Bgr, byte>(image))
                    {
                        using(GpuImage<Bgra, Byte> bgraImage = bgrImage.Convert<Bgra, Byte>())
                        {
                            resultRectangleArray = descriptor.DetectMultiScale(bgraImage);
                        }
                    }
                }
            }
            else
#endif
            {
                using(HOGDescriptor descriptor = new HOGDescriptor())
                {
                    descriptor.SetSVMDetector(HOGDescriptor.GetDefaultPeopleDetector());

                    resultRectangleArray = descriptor.DetectMultiScale(image);
                }
            }

            stopwatch.Stop();

            processingTime = stopwatch.ElapsedMilliseconds;

            return resultRectangleArray;
        }

        #endregion
    }
}

using System;

using System.Diagnostics;

using Emgu.CV;

using Emgu.CV.Structure;

using System.Drawing;

#if !IOS

using Emgu.CV.GPU;

#endif

namespace TestProject

{

/// <summary>

/// 보행자 검출 헬퍼

/// </summary>

public static class PedestrianDetectionHelper

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

////////////////////////////////////////////////////////////////////////////////////////// Static

//////////////////////////////////////////////////////////////////////////////// Public

#region 찾기 - Find(image, processingTime)

/// <summary>

/// 찾기

/// </summary>

/// <param name="image">이미지</param>

/// <param name="processingTime">처리 시간</param>

/// <returns>결과 사각형 배열</returns>

public static Rectangle[] Find(Image<Bgr, Byte> image, out long processingTime)

{

Stopwatch stopwatch;

Rectangle[] resultRectangleArray;

stopwatch = Stopwatch.StartNew();

#if !IOS

if(GpuInvoke.HasCuda)

{

using(GpuHOGDescriptor descriptor = new GpuHOGDescriptor())

{

descriptor.SetSVMDetector(GpuHOGDescriptor.GetDefaultPeopleDetector());

using(GpuImage<Bgr, Byte> bgrImage = new GpuImage<Bgr, byte>(image))

{

using(GpuImage<Bgra, Byte> bgraImage = bgrImage.Convert<Bgra, Byte>())

{

resultRectangleArray = descriptor.DetectMultiScale(bgraImage);

}

else

#endif

{

using(HOGDescriptor descriptor = new HOGDescriptor())

{

descriptor.SetSVMDetector(HOGDescriptor.GetDefaultPeopleDetector());

resultRectangleArray = descriptor.DetectMultiScale(image);

}

stopwatch.Stop();

processingTime = stopwatch.ElapsedMilliseconds;

return resultRectangleArray;

}

#endregion

}

▶ Program.cs


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

using Emgu.CV;
using Emgu.CV.Structure;
using Emgu.CV.UI;
using Emgu.CV.GPU;

namespace TestProject
{
    /// <summary>
    /// 프로그램
    /// </summary>
    class Program
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Method
        ////////////////////////////////////////////////////////////////////////////////////////// Static
        //////////////////////////////////////////////////////////////////////////////// Private

        #region 프로그램 시작하기 - Main()

        /// <summary>
        /// 프로그램 시작하기
        /// </summary>
        [STAThread]
        private static void Main()
        {
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);

            using(Image<Bgr, Byte> image = new Image<Bgr, byte>("sample.png"))
            {
                long processingTime;

                Rectangle[] resultRectangleArray = PedestrianDetectionHelper.Find(image, out processingTime);

                foreach(Rectangle resultRectangle in resultRectangleArray)
                {
                    image.Draw(resultRectangle, new Bgr(Color.Red), 1);
                }

                ImageViewer.Show
                (
                    image,
                    string.Format
                    (
                        "{0}를 사용해 보행자 검출하기 : {1} 밀리초",
                        GpuInvoke.HasCuda ? "GPU" : "CPU",
                        processingTime
                    )
                );
            }
        }

        #endregion
    }
}

using System;

using System.Drawing;

using System.Windows.Forms;

using Emgu.CV;

using Emgu.CV.Structure;

using Emgu.CV.UI;

using Emgu.CV.GPU;

namespace TestProject

{

/// <summary>

/// 프로그램

/// </summary>

class Program

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

////////////////////////////////////////////////////////////////////////////////////////// Static

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

#region 프로그램 시작하기 - Main()

/// <summary>

/// 프로그램 시작하기

/// </summary>

[STAThread]

private static void Main()

{

Application.EnableVisualStyles();

Application.SetCompatibleTextRenderingDefault(false);

using(Image<Bgr, Byte> image = new Image<Bgr, byte>("sample.png"))

{

long processingTime;

Rectangle[] resultRectangleArray = PedestrianDetectionHelper.Find(image, out processingTime);

foreach(Rectangle resultRectangle in resultRectangleArray)

{

image.Draw(resultRectangle, new Bgr(Color.Red), 1);

}

ImageViewer.Show

(

image,

string.Format

(

"{0}를 사용해 보행자 검출하기 : {1} 밀리초",

GpuInvoke.HasCuda ? "GPU" : "CPU",

processingTime

)

);

}

#endregion

}

TestProject.zip

[C#/WINFORM/EMGUCV] SURF 특징점 찾기

■ SURF 특징점을 찾는 방법을 보여준다. ▶ MatchHelper.cs


using System;
using System.Diagnostics;
using System.Drawing;

using Emgu.CV;
using Emgu.CV.CvEnum;
using Emgu.CV.Features2D;
using Emgu.CV.Structure;
using Emgu.CV.Util;
#if !IOS
using Emgu.CV.GPU;
#endif

namespace TestProject
{
    /// <summary>
    /// 매칭 헬퍼
    /// </summary>
    public static class MatchHelper
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Method
        ////////////////////////////////////////////////////////////////////////////////////////// Static
        //////////////////////////////////////////////////////////////////////////////// Public

        #region 매칭 찾기 - FindMatch(modelImage, sourceImage, matchTime, modelVectorOfKeyPoint, sourceVectorOfKeyPoint, indexMatrix, maskMatrix, homographyMatrix)

        /// <summary>
        /// 매칭 찾기
        /// </summary>
        /// <param name="modelImage">모델 이미지</param>
        /// <param name="sourceImage">소스 이미지</param>
        /// <param name="matchTime">매칭 시간</param>
        /// <param name="modelVectorOfKeyPoint">모델 키 포인트 벡터</param>
        /// <param name="sourceVectorOfKeyPoint">소스 키 포인트 벡터</param>
        /// <param name="indexMatrix">인덱스 매트릭스</param>
        /// <param name="maskMatrix">마스크 매트릭스</param>
        /// <param name="homographyMatrix">호모 그래피 매트릭스</param>
        public static void FindMatch(Image<Gray, Byte> modelImage, Image<Gray, byte> sourceImage, out long matchTime, out VectorOfKeyPoint modelVectorOfKeyPoint,
            out VectorOfKeyPoint sourceVectorOfKeyPoint, out Matrix<int> indexMatrix, out Matrix<byte> maskMatrix, out HomographyMatrix homographyMatrix)
        {
            int k = 2;

            double uniquenessThreshold = 0.8;

            SURFDetector surfDetector = new SURFDetector(500, false);

            Stopwatch stopwatch;

            homographyMatrix = null;

#if !IOS
            if(GpuInvoke.HasCuda)
            {
                GpuSURFDetector gpuSURFDetector = new GpuSURFDetector(surfDetector.SURFParams, 0.01f);

                using(GpuImage<Gray, Byte> modelGpuImage = new GpuImage<Gray, byte>(modelImage))
                {
                    using(GpuMat<float> modelKeyPointGpuMat = gpuSURFDetector.DetectKeyPointsRaw(modelGpuImage, null))
                    {
                        using(GpuMat<float> modelDescriptorGpuMat = gpuSURFDetector.ComputeDescriptorsRaw(modelGpuImage, null, modelKeyPointGpuMat))
                        {
                            using(GpuBruteForceMatcher<float> matcher = new GpuBruteForceMatcher<float>(DistanceType.L2))
                            {
                                modelVectorOfKeyPoint = new VectorOfKeyPoint();

                                gpuSURFDetector.DownloadKeypoints(modelKeyPointGpuMat, modelVectorOfKeyPoint);

                                stopwatch = Stopwatch.StartNew();

                                using(GpuImage<Gray, Byte> sourceGpuImage = new GpuImage<Gray, byte>(sourceImage))
                                {
                                    using(GpuMat<float> sourceKeyPointGpuMat = gpuSURFDetector.DetectKeyPointsRaw(sourceGpuImage, null))
                                    {
                                        using(GpuMat<float> sourceDescriptorGpuMat = gpuSURFDetector.ComputeDescriptorsRaw(sourceGpuImage, null, sourceKeyPointGpuMat))
                                        {
                                            using(GpuMat<int> matchIndexGpuMat = new GpuMat<int>(sourceDescriptorGpuMat.Size.Height, k, 1, true))
                                            {
                                                using(GpuMat<float> matchDistainceGpuMat = new GpuMat<float>(sourceDescriptorGpuMat.Size.Height, k, 1, true))
                                                {
                                                    using(GpuMat<Byte> maskGpuMat = new GpuMat<byte>(matchIndexGpuMat.Size.Height, 1, 1))
                                                    {
                                                        using(Stream stream = new Stream())
                                                        {
                                                            matcher.KnnMatchSingle
                                                            (
                                                                sourceDescriptorGpuMat,
                                                                modelDescriptorGpuMat,
                                                                matchIndexGpuMat,
                                                                matchDistainceGpuMat,
                                                                k,
                                                                null,
                                                                stream
                                                            );

                                                            indexMatrix = new Matrix<int>(matchIndexGpuMat.Size);

                                                            maskMatrix = new Matrix<byte>(maskGpuMat.Size);

                                                            using(GpuMat<float> col0 = matchDistainceGpuMat.Col(0))
                                                            {
                                                                using(GpuMat<float> col1 = matchDistainceGpuMat.Col(1))
                                                                {
                                                                    GpuInvoke.Multiply(col1, new MCvScalar(uniquenessThreshold), col1, stream);

                                                                    GpuInvoke.Compare(col0, col1, maskGpuMat, CMP_TYPE.CV_CMP_LE, stream);
                                                                }
                                                            }

                                                            sourceVectorOfKeyPoint = new VectorOfKeyPoint();

                                                            gpuSURFDetector.DownloadKeypoints(sourceKeyPointGpuMat, sourceVectorOfKeyPoint);

                                                            stream.WaitForCompletion();

                                                            maskGpuMat.Download(maskMatrix);

                                                            matchIndexGpuMat.Download(indexMatrix);

                                                            if(GpuInvoke.CountNonZero(maskGpuMat) >= 4)
                                                            {
                                                                int nonZeroCount = Features2DToolbox.VoteForSizeAndOrientation
                                                                (
                                                                    modelVectorOfKeyPoint,
                                                                    sourceVectorOfKeyPoint,
                                                                    indexMatrix,
                                                                    maskMatrix,
                                                                    1.5,
                                                                    20
                                                                );

                                                                if(nonZeroCount >= 4)
                                                                {
                                                                    homographyMatrix = Features2DToolbox.GetHomographyMatrixFromMatchedFeatures
                                                                    (
                                                                        modelVectorOfKeyPoint,
                                                                        sourceVectorOfKeyPoint,
                                                                        indexMatrix,
                                                                        maskMatrix,
                                                                        2
                                                                    );
                                                                }
                                                            }

                                                            stopwatch.Stop();
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
            else
#endif
            {
                modelVectorOfKeyPoint = new VectorOfKeyPoint();

                Matrix<float> modelDescriptorMatrix = surfDetector.DetectAndCompute(modelImage, null, modelVectorOfKeyPoint);

                stopwatch = Stopwatch.StartNew();

                sourceVectorOfKeyPoint = new VectorOfKeyPoint();

                Matrix<float> sourceDescriptorMatrix = surfDetector.DetectAndCompute(sourceImage, null, sourceVectorOfKeyPoint);

                BruteForceMatcher<float> matcher = new BruteForceMatcher<float>(DistanceType.L2);

                matcher.Add(modelDescriptorMatrix);

                indexMatrix = new Matrix<int>(sourceDescriptorMatrix.Rows, k);

                using(Matrix<float> distanceMatrix = new Matrix<float>(sourceDescriptorMatrix.Rows, k))
                {
                    matcher.KnnMatch(sourceDescriptorMatrix, indexMatrix, distanceMatrix, k, null);

                    maskMatrix = new Matrix<byte>(distanceMatrix.Rows, 1);

                    maskMatrix.SetValue(255);

                    Features2DToolbox.VoteForUniqueness(distanceMatrix, uniquenessThreshold, maskMatrix);
                }

                int nonZeroCount = CvInvoke.cvCountNonZero(maskMatrix);

                if(nonZeroCount >= 4)
                {
                    nonZeroCount = Features2DToolbox.VoteForSizeAndOrientation
                    (
                        modelVectorOfKeyPoint,
                        sourceVectorOfKeyPoint,
                        indexMatrix,
                        maskMatrix,
                        1.5,
                        20
                    );

                    if(nonZeroCount >= 4)
                    {
                        homographyMatrix = Features2DToolbox.GetHomographyMatrixFromMatchedFeatures
                        (
                            modelVectorOfKeyPoint,
                            sourceVectorOfKeyPoint,
                            indexMatrix,
                            maskMatrix,
                            2
                        );
                    }
                }

                stopwatch.Stop();
            }

            matchTime = stopwatch.ElapsedMilliseconds;
        }

        #endregion
        #region 그리기 - Draw(modelImage, sourceImage, matchTime)

        /// <summary>
        /// 그리기
        /// </summary>
        /// <param name="modelImage">모델 이미지</param>
        /// <param name="sourceImage">소스 이미지</param>
        /// <param name="matchTime">매칭 시간</param>
        /// <returns>이미지</returns>
        public static Image<Bgr, Byte> Draw(Image<Gray, Byte> modelImage, Image<Gray, byte> sourceImage, out long matchTime)
        {
            HomographyMatrix homographyMatrix;
            VectorOfKeyPoint modelVectorOfKeyPoint;
            VectorOfKeyPoint sourceVectorOfKeyPoint;
            Matrix<int>      indexMatrix;
            Matrix<byte>     maskMatrix;

            FindMatch
            (
                modelImage,
                sourceImage,
                out matchTime,
                out modelVectorOfKeyPoint,
                out sourceVectorOfKeyPoint,
                out indexMatrix,
                out maskMatrix,
                out homographyMatrix
            );

            Image<Bgr, Byte> resultImage = Features2DToolbox.DrawMatches
            (
                modelImage,
                modelVectorOfKeyPoint,
                sourceImage,
                sourceVectorOfKeyPoint,
                indexMatrix,
                new Bgr(255, 255, 255),
                new Bgr(255, 255, 255),
                maskMatrix,
                Features2DToolbox.KeypointDrawType.DEFAULT
            );

            if(homographyMatrix != null)
            {
                Rectangle rectangle = modelImage.ROI;

                PointF[] pointArray = new PointF[]
                {
                    new PointF(rectangle.Left , rectangle.Bottom),
                    new PointF(rectangle.Right, rectangle.Bottom),
                    new PointF(rectangle.Right, rectangle.Top   ),
                    new PointF(rectangle.Left , rectangle.Top   )
                };

                homographyMatrix.ProjectPoints(pointArray);

                resultImage.DrawPolyline
                (
                    Array.ConvertAll<PointF, Point>(pointArray, Point.Round),
                    true,
                    new Bgr(Color.Red),
                    5
                );
            }

            return resultImage;
        }

        #endregion
    }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

using System;

using System.Diagnostics;

using System.Drawing;

using Emgu.CV;

using Emgu.CV.CvEnum;

using Emgu.CV.Features2D;

using Emgu.CV.Structure;

using Emgu.CV.Util;

#if !IOS

using Emgu.CV.GPU;

#endif

namespace TestProject

{

/// <summary>

/// 매칭 헬퍼

/// </summary>

public static class MatchHelper

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

////////////////////////////////////////////////////////////////////////////////////////// Static

//////////////////////////////////////////////////////////////////////////////// Public

#region 매칭 찾기 - FindMatch(modelImage, sourceImage, matchTime, modelVectorOfKeyPoint, sourceVectorOfKeyPoint, indexMatrix, maskMatrix, homographyMatrix)

/// <summary>

/// 매칭 찾기

/// </summary>

/// <param name="modelImage">모델 이미지</param>

/// <param name="sourceImage">소스 이미지</param>

/// <param name="matchTime">매칭 시간</param>

/// <param name="modelVectorOfKeyPoint">모델 키 포인트 벡터</param>

/// <param name="sourceVectorOfKeyPoint">소스 키 포인트 벡터</param>

/// <param name="indexMatrix">인덱스 매트릭스</param>

/// <param name="maskMatrix">마스크 매트릭스</param>

/// <param name="homographyMatrix">호모 그래피 매트릭스</param>

public static void FindMatch(Image<Gray, Byte> modelImage, Image<Gray, byte> sourceImage, out long matchTime, out VectorOfKeyPoint modelVectorOfKeyPoint,

out VectorOfKeyPoint sourceVectorOfKeyPoint, out Matrix<int> indexMatrix, out Matrix<byte> maskMatrix, out HomographyMatrix homographyMatrix)

{

int k = 2;

double uniquenessThreshold = 0.8;

SURFDetector surfDetector = new SURFDetector(500, false);

Stopwatch stopwatch;

homographyMatrix = null;

#if !IOS

if(GpuInvoke.HasCuda)

{

GpuSURFDetector gpuSURFDetector = new GpuSURFDetector(surfDetector.SURFParams, 0.01f);

using(GpuImage<Gray, Byte> modelGpuImage = new GpuImage<Gray, byte>(modelImage))

{

using(GpuMat<float> modelKeyPointGpuMat = gpuSURFDetector.DetectKeyPointsRaw(modelGpuImage, null))

{

using(GpuMat<float> modelDescriptorGpuMat = gpuSURFDetector.ComputeDescriptorsRaw(modelGpuImage, null, modelKeyPointGpuMat))

{

using(GpuBruteForceMatcher<float> matcher = new GpuBruteForceMatcher<float>(DistanceType.L2))

{

modelVectorOfKeyPoint = new VectorOfKeyPoint();

gpuSURFDetector.DownloadKeypoints(modelKeyPointGpuMat, modelVectorOfKeyPoint);

stopwatch = Stopwatch.StartNew();

using(GpuImage<Gray, Byte> sourceGpuImage = new GpuImage<Gray, byte>(sourceImage))

{

using(GpuMat<float> sourceKeyPointGpuMat = gpuSURFDetector.DetectKeyPointsRaw(sourceGpuImage, null))

{

using(GpuMat<float> sourceDescriptorGpuMat = gpuSURFDetector.ComputeDescriptorsRaw(sourceGpuImage, null, sourceKeyPointGpuMat))

{

using(GpuMat<int> matchIndexGpuMat = new GpuMat<int>(sourceDescriptorGpuMat.Size.Height, k, 1, true))

{

using(GpuMat<float> matchDistainceGpuMat = new GpuMat<float>(sourceDescriptorGpuMat.Size.Height, k, 1, true))

{

using(GpuMat<Byte> maskGpuMat = new GpuMat<byte>(matchIndexGpuMat.Size.Height, 1, 1))

{

using(Stream stream = new Stream())

{

matcher.KnnMatchSingle

(

sourceDescriptorGpuMat,

modelDescriptorGpuMat,

matchIndexGpuMat,

matchDistainceGpuMat,

null,

stream

);

indexMatrix = new Matrix<int>(matchIndexGpuMat.Size);

maskMatrix = new Matrix<byte>(maskGpuMat.Size);

using(GpuMat<float> col0 = matchDistainceGpuMat.Col(0))

{

using(GpuMat<float> col1 = matchDistainceGpuMat.Col(1))

{

GpuInvoke.Multiply(col1, new MCvScalar(uniquenessThreshold), col1, stream);

GpuInvoke.Compare(col0, col1, maskGpuMat, CMP_TYPE.CV_CMP_LE, stream);

}

sourceVectorOfKeyPoint = new VectorOfKeyPoint();

gpuSURFDetector.DownloadKeypoints(sourceKeyPointGpuMat, sourceVectorOfKeyPoint);

stream.WaitForCompletion();

maskGpuMat.Download(maskMatrix);

matchIndexGpuMat.Download(indexMatrix);

if(GpuInvoke.CountNonZero(maskGpuMat) >= 4)

{

int nonZeroCount = Features2DToolbox.VoteForSizeAndOrientation

(

modelVectorOfKeyPoint,

sourceVectorOfKeyPoint,

indexMatrix,

maskMatrix,

1.5,

);

if(nonZeroCount >= 4)

{

homographyMatrix = Features2DToolbox.GetHomographyMatrixFromMatchedFeatures

(

modelVectorOfKeyPoint,

sourceVectorOfKeyPoint,

indexMatrix,

maskMatrix,

);

}

stopwatch.Stop();

}

else

#endif

{

modelVectorOfKeyPoint = new VectorOfKeyPoint();

Matrix<float> modelDescriptorMatrix = surfDetector.DetectAndCompute(modelImage, null, modelVectorOfKeyPoint);

stopwatch = Stopwatch.StartNew();

sourceVectorOfKeyPoint = new VectorOfKeyPoint();

Matrix<float> sourceDescriptorMatrix = surfDetector.DetectAndCompute(sourceImage, null, sourceVectorOfKeyPoint);

BruteForceMatcher<float> matcher = new BruteForceMatcher<float>(DistanceType.L2);

matcher.Add(modelDescriptorMatrix);

indexMatrix = new Matrix<int>(sourceDescriptorMatrix.Rows, k);

using(Matrix<float> distanceMatrix = new Matrix<float>(sourceDescriptorMatrix.Rows, k))

{

matcher.KnnMatch(sourceDescriptorMatrix, indexMatrix, distanceMatrix, k, null);

maskMatrix = new Matrix<byte>(distanceMatrix.Rows, 1);

maskMatrix.SetValue(255);

Features2DToolbox.VoteForUniqueness(distanceMatrix, uniquenessThreshold, maskMatrix);

}

int nonZeroCount = CvInvoke.cvCountNonZero(maskMatrix);

if(nonZeroCount >= 4)

{

nonZeroCount = Features2DToolbox.VoteForSizeAndOrientation

(

modelVectorOfKeyPoint,

sourceVectorOfKeyPoint,

indexMatrix,

maskMatrix,

1.5,

);

if(nonZeroCount >= 4)

{

homographyMatrix = Features2DToolbox.GetHomographyMatrixFromMatchedFeatures

(

modelVectorOfKeyPoint,

sourceVectorOfKeyPoint,

indexMatrix,

maskMatrix,

);

}

stopwatch.Stop();

}

matchTime = stopwatch.ElapsedMilliseconds;

}

#endregion

#region 그리기 - Draw(modelImage, sourceImage, matchTime)

/// <summary>

/// 그리기

/// </summary>

/// <param name="modelImage">모델 이미지</param>

/// <param name="sourceImage">소스 이미지</param>

/// <param name="matchTime">매칭 시간</param>

/// <returns>이미지</returns>

public static Image<Bgr, Byte> Draw(Image<Gray, Byte> modelImage, Image<Gray, byte> sourceImage, out long matchTime)

{

HomographyMatrix homographyMatrix;

VectorOfKeyPoint modelVectorOfKeyPoint;

VectorOfKeyPoint sourceVectorOfKeyPoint;

Matrix<int> indexMatrix;

Matrix<byte> maskMatrix;

FindMatch

(

modelImage,

sourceImage,

out matchTime,

out modelVectorOfKeyPoint,

out sourceVectorOfKeyPoint,

out indexMatrix,

out maskMatrix,

out homographyMatrix

);

Image<Bgr, Byte> resultImage = Features2DToolbox.DrawMatches

(

modelImage,

modelVectorOfKeyPoint,

sourceImage,

sourceVectorOfKeyPoint,

indexMatrix,

new Bgr(255, 255, 255),

maskMatrix,

Features2DToolbox.KeypointDrawType.DEFAULT

);

if(homographyMatrix != null)

{

Rectangle rectangle = modelImage.ROI;

PointF[] pointArray = new PointF[]

{

new PointF(rectangle.Left , rectangle.Bottom),

new PointF(rectangle.Right, rectangle.Bottom),

new PointF(rectangle.Right, rectangle.Top ),

new PointF(rectangle.Left , rectangle.Top )

};

homographyMatrix.ProjectPoints(pointArray);

resultImage.DrawPolyline

(

Array.ConvertAll<PointF, Point>(pointArray, Point.Round),

true,

new Bgr(Color.Red),

);

}

return resultImage;

}

#endregion

}

▶ Program.cs


using System;
using System.Windows.Forms;

using Emgu.CV;
using Emgu.CV.GPU;
using Emgu.CV.Structure;
using Emgu.CV.UI;

namespace TestProject
{
    /// <summary>
    /// 프로그램
    /// </summary>
    static class Program
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Method
        ////////////////////////////////////////////////////////////////////////////////////////// Static
        //////////////////////////////////////////////////////////////////////////////// Private

        #region 프로그램 시작하기 - Main()

        /// <summary>
        /// 프로그램 시작하기
        /// </summary>
        [STAThread]
        private static void Main()
        {
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);

            long matchTime;

            using(Image<Gray, Byte> modelImage = new Image<Gray, byte>("box.png"))
            {
                using(Image<Gray, Byte> sourceImage = new Image<Gray, byte>("box_in_scene.png"))
                {
                    Image<Bgr, byte> resultImage = MatchHelper.Draw(modelImage, sourceImage, out matchTime);

                    ImageViewer.Show
                    (
                        resultImage,
                        string.Format
                        (
                            "{0}를 사용해 일치 여부 판단 : {1} 밀리초",
                            GpuInvoke.HasCuda ? "GPU" : "CPU",
                            matchTime
                        )
                    );
                }
            }
        }

        #endregion
    }
}

using System;

using System.Windows.Forms;

using Emgu.CV;

using Emgu.CV.GPU;

using Emgu.CV.Structure;

using Emgu.CV.UI;

namespace TestProject

{

/// <summary>

/// 프로그램

/// </summary>

static class Program

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

////////////////////////////////////////////////////////////////////////////////////////// Static

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

#region 프로그램 시작하기 - Main()

/// <summary>

/// 프로그램 시작하기

/// </summary>

[STAThread]

private static void Main()

{

Application.EnableVisualStyles();

Application.SetCompatibleTextRenderingDefault(false);

long matchTime;

using(Image<Gray, Byte> modelImage = new Image<Gray, byte>("box.png"))

{

using(Image<Gray, Byte> sourceImage = new Image<Gray, byte>("box_in_scene.png"))

{

Image<Bgr, byte> resultImage = MatchHelper.Draw(modelImage, sourceImage, out matchTime);

ImageViewer.Show

(

resultImage,

string.Format

(

"{0}를 사용해 일치 여부 판단 : {1} 밀리초",

GpuInvoke.HasCuda ? "GPU" : "CPU",

matchTime

)

);

}

#endregion

}

TestProject.zip

[C#/WINFORM/EMGUCV] STOP 표지판 인식하기

■ STOP 표지판을 인식하는 방법을 보여준다. ▶ StopSignDetector.cs


using System;
using System.Collections.Generic;
using System.Drawing;

using Emgu.CV;
using Emgu.CV.CvEnum;
using Emgu.CV.Features2D;
using Emgu.CV.Structure;
using Emgu.Util;

namespace TestProject
{
    /// <summary>
    /// STOP 표지판 검출기
    /// </summary>
    public class StopSignDetector : DisposableObject
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Field
        ////////////////////////////////////////////////////////////////////////////////////////// Private

        #region Field

        /// <summary>
        /// 추적기
        /// </summary>
        private Features2DTracker<float> tracker;

        /// <summary>
        /// 검출기
        /// </summary>
        private SURFDetector detector;

        /// <summary>
        /// 팔각형 저장소
        /// </summary>
        private MemStorage octagonStorage;

        /// <summary>
        /// 팔각형 윤곽선
        /// </summary>
        private Contour<Point> octagonContour;

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Constructor
        ////////////////////////////////////////////////////////////////////////////////////////// Public

        #region 생성자 - StopSignDetector(modelImage)

        /// <summary>
        /// 생성자
        /// </summary>
        /// <param name="modelImage">모델 이미지</param>
        public StopSignDetector(Image<Bgr, Byte> modelImage)
        {
            this.detector = new SURFDetector(500, false);

            using(Image<Gray, Byte> maskImage = GetRedPixelMaskImage(modelImage))
            {
                ImageFeature<float>[] imageFeatureArray = this.detector.DetectFeatures(maskImage, null);

                if(imageFeatureArray.Length == 0)
                {
                    throw new Exception("No image feature has been found in the stop sign model");
                }

                this.tracker = new Features2DTracker<float>(imageFeatureArray);
            }

            this.octagonStorage = new MemStorage();

            this.octagonContour = new Contour<Point>(this.octagonStorage);

            this.octagonContour.PushMulti
            (
                new Point[]
                {
                    new Point(1, 0),
                    new Point(2, 0),
                    new Point(3, 1),
                    new Point(3, 2),
                    new Point(2, 3),
                    new Point(1, 3),
                    new Point(0, 2),
                    new Point(0, 1)
                },
                BACK_OR_FRONT.FRONT
            );
        }

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Method
        ////////////////////////////////////////////////////////////////////////////////////////// Public

        #region STOP 표지판 검출하기 - DetectStopSign(sourceImage, imageList, rectangleList)

        /// <summary>
        /// STOP 표지판 검출하기
        /// </summary>
        /// <param name="sourceImage">소스 이미지</param>
        /// <param name="imageList">이미지 리스트</param>
        /// <param name="rectangleList">사각형 리스트</param>
        public void DetectStopSign(Image<Bgr, byte> sourceImage, List<Image<Gray, Byte>> imageList, List<Rectangle> rectangleList)
        {
            Image<Bgr, Byte> smoothImage = sourceImage.SmoothGaussian(5, 5, 1.5, 1.5);

            Image<Gray, Byte> maskImage = GetRedPixelMaskImage(smoothImage);

            maskImage._Dilate(1);

            maskImage._Erode(1);

            using(Image<Gray, Byte> cannyImage = maskImage.Canny(100, 50))
            {
                using(MemStorage storage = new MemStorage())
                {
                    Contour<Point> pointContour = cannyImage.FindContours
                    (
                        CHAIN_APPROX_METHOD.CV_CHAIN_APPROX_SIMPLE,
                        RETR_TYPE.CV_RETR_TREE,
                        storage
                    );

                    FindStopSign(sourceImage, imageList, rectangleList, pointContour);
                }
            }
        }

        #endregion

        ////////////////////////////////////////////////////////////////////////////////////////// Protected

        #region 객체 리소스 해제하기 - DisposeObject()

        /// <summary>
        /// 객체 리소스 해제하기
        /// </summary>
        protected override void DisposeObject()
        {
            this.tracker.Dispose();

            this.octagonStorage.Dispose();
        }

        #endregion

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

        #region 빨간색 픽셀 마스크 이미지 구하기 - GetRedPixelMaskImage(sourceImage)

        /// <summary>
        /// 빨간색 픽셀 마스크 이미지 구하기
        /// </summary>
        /// <param name="sourceImage">소스 이미지</param>
        /// <returns>빨간색 픽셀 마스크 이미지</returns>
        private Image<Gray, Byte> GetRedPixelMaskImage(Image<Bgr, byte> sourceImage)
        {
            using(Image<Hsv, Byte> hsvImage = sourceImage.Convert<Hsv, Byte>())
            {
                Image<Gray, Byte>[] channelImageArray = hsvImage.Split();

                try
                {
                    CvInvoke.cvInRangeS
                    (
                        channelImageArray[0],
                        new MCvScalar(20),
                        new MCvScalar(160),
                        channelImageArray[0]
                    );

                    channelImageArray[0]._Not();

                    channelImageArray[1]._ThresholdBinary(new Gray(10), new Gray(255.0));

                    CvInvoke.cvAnd(channelImageArray[0], channelImageArray[1], channelImageArray[0], IntPtr.Zero);
                }
                finally
                {
                    channelImageArray[1].Dispose();
                    channelImageArray[2].Dispose();
                }

                return channelImageArray[0];
            }
        }

        #endregion
        #region STOP 표지판 찾기 - FindStopSign(sourceImage, imageList, rectangleList, pointContour)

        /// <summary>
        /// STOP 표지판 찾기
        /// </summary>
        /// <param name="sourceImage">소스 이미지</param>
        /// <param name="imageList">이미지 리스트</param>
        /// <param name="rectangleList">사각형 리스트</param>
        /// <param name="pointContour">포인트 윤곽선</param>
        private void FindStopSign(Image<Bgr, byte> sourceImage, List<Image<Gray, Byte>> imageList, List<Rectangle> rectangleList, Contour<Point> pointContour)
        {
            for(; pointContour != null; pointContour = pointContour.HNext)
            {
                pointContour.ApproxPoly(pointContour.Perimeter * 0.02, 0, pointContour.Storage);

                if(pointContour.Area > 200)
                {
                    double ratio = CvInvoke.cvMatchShapes
                    (
                        this.octagonContour,
                        pointContour,
                        CONTOURS_MATCH_TYPE.CV_CONTOURS_MATCH_I3,
                        0
                    );

                    if(ratio > 0.1)
                    {
                        Contour<Point> childPointContour = pointContour.VNext;

                        if(childPointContour != null)
                        {
                            FindStopSign(sourceImage, imageList, rectangleList, childPointContour);
                        }

                        continue;
                    }

                    Rectangle rectangle = pointContour.BoundingRectangle;

                    Image<Gray, Byte> candidateImage;

                    using(Image<Bgr, Byte> temporaryImage = sourceImage.Copy(rectangle))
                    {
                        candidateImage = temporaryImage.Convert<Gray, byte>();
                    }

                    using(Image<Gray, Byte> maskImage = new Image<Gray, byte>(rectangle.Size))
                    {
                        maskImage.Draw
                        (
                            pointContour,
                            new Gray(255),
                            new Gray(255),
                            0,
                            -1,
                            new Point(-rectangle.X, -rectangle.Y)
                        );

                        double mean = CvInvoke.cvAvg(candidateImage, maskImage).v0;

                        candidateImage._ThresholdBinary(new Gray(mean), new Gray(255.0));

                        candidateImage._Not();

                        maskImage._Not();

                        candidateImage.SetValue(0, maskImage);
                    }

                    ImageFeature<float>[] imageFeatureArray = this.detector.DetectFeatures(candidateImage, null);

                    int minimumMatchCount = 10;

                    if(imageFeatureArray != null && imageFeatureArray.Length >= minimumMatchCount)
                    {
                        Features2DTracker<float>.MatchedImageFeature[] matchedImageFeatureArray = this.tracker.MatchFeature(imageFeatureArray, 2);

                        int goodMatchCount = 0;

                        foreach(Features2DTracker<float>.MatchedImageFeature matchedImageFeature in matchedImageFeatureArray)
                        {
                            if(matchedImageFeature.SimilarFeatures[0].Distance < 0.5)
                            {
                                goodMatchCount++;
                            }
                        }

                        if(goodMatchCount >= minimumMatchCount)
                        {
                            rectangleList.Add(rectangle);

                            imageList.Add(candidateImage);
                        }
                    }
                }
            }
        }

        #endregion
    }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

using System;

using System.Collections.Generic;

using System.Drawing;

using Emgu.CV;

using Emgu.CV.CvEnum;

using Emgu.CV.Features2D;

using Emgu.CV.Structure;

using Emgu.Util;

namespace TestProject

{

/// <summary>

/// STOP 표지판 검출기

/// </summary>

public class StopSignDetector : DisposableObject

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Field

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

#region Field

/// <summary>

/// 추적기

/// </summary>

private Features2DTracker<float> tracker;

/// <summary>

/// 검출기

/// </summary>

private SURFDetector detector;

/// <summary>

/// 팔각형 저장소

/// </summary>

private MemStorage octagonStorage;

/// <summary>

/// 팔각형 윤곽선

/// </summary>

private Contour<Point> octagonContour;

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Constructor

////////////////////////////////////////////////////////////////////////////////////////// Public

#region 생성자 - StopSignDetector(modelImage)

/// <summary>

/// 생성자

/// </summary>

/// <param name="modelImage">모델 이미지</param>

public StopSignDetector(Image<Bgr, Byte> modelImage)

{

this.detector = new SURFDetector(500, false);

using(Image<Gray, Byte> maskImage = GetRedPixelMaskImage(modelImage))

{

ImageFeature<float>[] imageFeatureArray = this.detector.DetectFeatures(maskImage, null);

if(imageFeatureArray.Length == 0)

{

throw new Exception("No image feature has been found in the stop sign model");

}

this.tracker = new Features2DTracker<float>(imageFeatureArray);

}

this.octagonStorage = new MemStorage();

this.octagonContour = new Contour<Point>(this.octagonStorage);

this.octagonContour.PushMulti

(

new Point[]

{

new Point(1, 0),

new Point(2, 0),

new Point(3, 1),

new Point(3, 2),

new Point(2, 3),

new Point(1, 3),

new Point(0, 2),

new Point(0, 1)

BACK_OR_FRONT.FRONT

);

}

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

////////////////////////////////////////////////////////////////////////////////////////// Public

#region STOP 표지판 검출하기 - DetectStopSign(sourceImage, imageList, rectangleList)

/// <summary>

/// STOP 표지판 검출하기

/// </summary>

/// <param name="sourceImage">소스 이미지</param>

/// <param name="imageList">이미지 리스트</param>

/// <param name="rectangleList">사각형 리스트</param>

public void DetectStopSign(Image<Bgr, byte> sourceImage, List<Image<Gray, Byte>> imageList, List<Rectangle> rectangleList)

{

Image<Bgr, Byte> smoothImage = sourceImage.SmoothGaussian(5, 5, 1.5, 1.5);

Image<Gray, Byte> maskImage = GetRedPixelMaskImage(smoothImage);

maskImage._Dilate(1);

maskImage._Erode(1);

using(Image<Gray, Byte> cannyImage = maskImage.Canny(100, 50))

{

using(MemStorage storage = new MemStorage())

{

Contour<Point> pointContour = cannyImage.FindContours

(

CHAIN_APPROX_METHOD.CV_CHAIN_APPROX_SIMPLE,

RETR_TYPE.CV_RETR_TREE,

storage

);

FindStopSign(sourceImage, imageList, rectangleList, pointContour);

}

#endregion

////////////////////////////////////////////////////////////////////////////////////////// Protected

#region 객체 리소스 해제하기 - DisposeObject()

/// <summary>

/// 객체 리소스 해제하기

/// </summary>

protected override void DisposeObject()

{

this.tracker.Dispose();

this.octagonStorage.Dispose();

}

#endregion

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

#region 빨간색 픽셀 마스크 이미지 구하기 - GetRedPixelMaskImage(sourceImage)

/// <summary>

/// 빨간색 픽셀 마스크 이미지 구하기

/// </summary>

/// <param name="sourceImage">소스 이미지</param>

/// <returns>빨간색 픽셀 마스크 이미지</returns>

private Image<Gray, Byte> GetRedPixelMaskImage(Image<Bgr, byte> sourceImage)

{

using(Image<Hsv, Byte> hsvImage = sourceImage.Convert<Hsv, Byte>())

{

Image<Gray, Byte>[] channelImageArray = hsvImage.Split();

try

{

CvInvoke.cvInRangeS

(

channelImageArray[0],

new MCvScalar(20),

new MCvScalar(160),

channelImageArray[0]

);

channelImageArray[0]._Not();

channelImageArray[1]._ThresholdBinary(new Gray(10), new Gray(255.0));

CvInvoke.cvAnd(channelImageArray[0], channelImageArray[1], channelImageArray[0], IntPtr.Zero);

}

finally

{

channelImageArray[1].Dispose();

channelImageArray[2].Dispose();

}

return channelImageArray[0];

}

#endregion

#region STOP 표지판 찾기 - FindStopSign(sourceImage, imageList, rectangleList, pointContour)

/// <summary>

/// STOP 표지판 찾기

/// </summary>

/// <param name="sourceImage">소스 이미지</param>

/// <param name="imageList">이미지 리스트</param>

/// <param name="rectangleList">사각형 리스트</param>

/// <param name="pointContour">포인트 윤곽선</param>

private void FindStopSign(Image<Bgr, byte> sourceImage, List<Image<Gray, Byte>> imageList, List<Rectangle> rectangleList, Contour<Point> pointContour)

{

for(; pointContour != null; pointContour = pointContour.HNext)

{

pointContour.ApproxPoly(pointContour.Perimeter * 0.02, 0, pointContour.Storage);

if(pointContour.Area > 200)

{

double ratio = CvInvoke.cvMatchShapes

(

this.octagonContour,

pointContour,

CONTOURS_MATCH_TYPE.CV_CONTOURS_MATCH_I3,

);

if(ratio > 0.1)

{

Contour<Point> childPointContour = pointContour.VNext;

if(childPointContour != null)

{

FindStopSign(sourceImage, imageList, rectangleList, childPointContour);

}

continue;

}

Rectangle rectangle = pointContour.BoundingRectangle;

Image<Gray, Byte> candidateImage;

using(Image<Bgr, Byte> temporaryImage = sourceImage.Copy(rectangle))

{

candidateImage = temporaryImage.Convert<Gray, byte>();

}

using(Image<Gray, Byte> maskImage = new Image<Gray, byte>(rectangle.Size))

{

maskImage.Draw

(

pointContour,

new Gray(255),

-1,

new Point(-rectangle.X, -rectangle.Y)

);

double mean = CvInvoke.cvAvg(candidateImage, maskImage).v0;

candidateImage._ThresholdBinary(new Gray(mean), new Gray(255.0));

candidateImage._Not();

maskImage._Not();

candidateImage.SetValue(0, maskImage);

}

ImageFeature<float>[] imageFeatureArray = this.detector.DetectFeatures(candidateImage, null);

int minimumMatchCount = 10;

if(imageFeatureArray != null && imageFeatureArray.Length >= minimumMatchCount)

{

Features2DTracker<float>.MatchedImageFeature[] matchedImageFeatureArray = this.tracker.MatchFeature(imageFeatureArray, 2);

int goodMatchCount = 0;

foreach(Features2DTracker<float>.MatchedImageFeature matchedImageFeature in matchedImageFeatureArray)

{

if(matchedImageFeature.SimilarFeatures[0].Distance < 0.5)

{

goodMatchCount++;

}

if(goodMatchCount >= minimumMatchCount)

{

rectangleList.Add(rectangle);

imageList.Add(candidateImage);

}

#endregion

}

▶ MainForm.cs


using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Drawing;
using System.Windows.Forms;

using Emgu.CV;
using Emgu.CV.Structure;
using Emgu.CV.UI;

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

        #region Field

        /// <summary>
        /// 검출기
        /// </summary>
        private StopSignDetector detector;

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Constructor
        ////////////////////////////////////////////////////////////////////////////////////////// Public

        #region 생성자 - MainForm()

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

            using(Image<Bgr, Byte> modelImage = new Image<Bgr, Byte>("stop-sign-model.png"))
            {
                using (Image<Bgr, Byte> image = new Image<Bgr, byte>("stop-sign.jpg"))
                {
                    this.detector = new StopSignDetector(modelImage);

                    ProcessImage(image);
                }
            }
        }

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Method
        ////////////////////////////////////////////////////////////////////////////////////////// Private
        //////////////////////////////////////////////////////////////////////////////// Event

        #region 이미지 로드 버튼 클릭시 처리하기 - loadImageButton_Click(sender, e)

        /// <summary>
        /// 이미지 로드 버튼 클릭시 처리하기
        /// </summary>
        /// <param name="sender">이벤트 발생자</param>
        /// <param name="e">이벤트 인자</param>
        private void loadImageButton_Click(object sender, EventArgs e)
        {
            DialogResult result = openFileDialog.ShowDialog();

            if(result == DialogResult.OK)
            {
                Image<Bgr, Byte> image;

                try
                {
                    image = new Image<Bgr, byte>(openFileDialog.FileName);
                }
                catch
                {
                    MessageBox.Show("지원하는 파일 포맷이 아닙니다.");

                    return;
                }

                ProcessImage(image);
            }
        }

        #endregion

        //////////////////////////////////////////////////////////////////////////////// Function

        #region 레이블 및 이미지 추가하기 - AddLabelAndImage(startPoint, text, image)

        /// <summary>
        /// 레이블 및 이미지 추가하기
        /// </summary>
        /// <param name="startPoint">시작 위치</param>
        /// <param name="text">텍스트</param>
        /// <param name="image">이미지</param>
        private void AddLabelAndImage(ref Point startPoint, string text, IImage image)
        {
            Label label = new Label();

            this.resultPanel.Controls.Add(label);

            label.Width    = 100;
            label.Height   = 30;
            label.Location = startPoint;
            label.Text     = text;

            startPoint.Y += label.Height;

            ImageBox imageBox = new ImageBox();

            this.resultPanel.Controls.Add(imageBox);

            imageBox.ClientSize = image.Size;
            imageBox.Location   = startPoint;
            imageBox.Image      = image;

            startPoint.Y += imageBox.Height + 10;
        }

        #endregion
        #region 이미지 처리하기 - ProcessImage(image)

        /// <summary>
        /// 이미지 처리하기
        /// </summary>
        /// <param name="image">이미지</param>
        private void ProcessImage(Image<Bgr, byte> image)
        {
            Stopwatch stopwatch = Stopwatch.StartNew();

            List<Image<Gray, Byte>> imageList     = new List<Image<Gray, byte>>();
            List<Rectangle>         rectangleList = new List<Rectangle>();

            this.detector.DetectStopSign(image, imageList, rectangleList);

            stopwatch.Stop();

            this.messageLabel.Text = String.Format("STOP 표지판 검출 시간 : {0} 밀리초", stopwatch.Elapsed.TotalMilliseconds);

            this.resultPanel.Controls.Clear();

            Point startPoint = new Point(10, 10);

            for(int i = 0; i < imageList.Count; i++)
            {
                Rectangle rectangle = rectangleList[i];

                AddLabelAndImage
                (
                    ref startPoint,
                    string.Format
                    (
                        "STOP 표지판 [{0}, {1}]",
                        rectangle.Location.Y + rectangle.Width  / 2,
                        rectangle.Location.Y + rectangle.Height / 2
                    ),
                    imageList[i]
                );

                image.Draw(rectangle, new Bgr(Color.Aquamarine), 2);
            }

            this.imageBox.Image = image;
        }

        #endregion
    }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

using System;

using System.Collections.Generic;

using System.Diagnostics;

using System.Drawing;

using System.Windows.Forms;

using Emgu.CV;

using Emgu.CV.Structure;

using Emgu.CV.UI;

namespace TestProject

{

/// <summary>

/// 메인 폼

/// </summary>

public partial class MainForm : Form

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Field

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

#region Field

/// <summary>

/// 검출기

/// </summary>

private StopSignDetector detector;

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Constructor

////////////////////////////////////////////////////////////////////////////////////////// Public

#region 생성자 - MainForm()

/// <summary>

/// 생성자

/// </summary>

public MainForm()

{

InitializeComponent();

using(Image<Bgr, Byte> modelImage = new Image<Bgr, Byte>("stop-sign-model.png"))

{

using (Image<Bgr, Byte> image = new Image<Bgr, byte>("stop-sign.jpg"))

{

this.detector = new StopSignDetector(modelImage);

ProcessImage(image);

}

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

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

//////////////////////////////////////////////////////////////////////////////// Event

#region 이미지 로드 버튼 클릭시 처리하기 - loadImageButton_Click(sender, e)

/// <summary>

/// 이미지 로드 버튼 클릭시 처리하기

/// </summary>

/// <param name="sender">이벤트 발생자</param>

/// <param name="e">이벤트 인자</param>

private void loadImageButton_Click(object sender, EventArgs e)

{

DialogResult result = openFileDialog.ShowDialog();

if(result == DialogResult.OK)

{

Image<Bgr, Byte> image;

try

{

image = new Image<Bgr, byte>(openFileDialog.FileName);

}

catch

{

MessageBox.Show("지원하는 파일 포맷이 아닙니다.");

return;

}

ProcessImage(image);

}

#endregion

//////////////////////////////////////////////////////////////////////////////// Function

#region 레이블 및 이미지 추가하기 - AddLabelAndImage(startPoint, text, image)

/// <summary>

/// 레이블 및 이미지 추가하기

/// </summary>

/// <param name="startPoint">시작 위치</param>

/// <param name="text">텍스트</param>

/// <param name="image">이미지</param>

private void AddLabelAndImage(ref Point startPoint, string text, IImage image)

{

Label label = new Label();

this.resultPanel.Controls.Add(label);

label.Width = 100;

label.Height = 30;

label.Location = startPoint;

label.Text = text;

startPoint.Y += label.Height;

ImageBox imageBox = new ImageBox();

this.resultPanel.Controls.Add(imageBox);

imageBox.ClientSize = image.Size;

imageBox.Location = startPoint;

imageBox.Image = image;

startPoint.Y += imageBox.Height + 10;

}

#endregion

#region 이미지 처리하기 - ProcessImage(image)

/// <summary>

/// 이미지 처리하기

/// </summary>

/// <param name="image">이미지</param>

private void ProcessImage(Image<Bgr, byte> image)

{

Stopwatch stopwatch = Stopwatch.StartNew();

List<Image<Gray, Byte>> imageList = new List<Image<Gray, byte>>();

List<Rectangle> rectangleList = new List<Rectangle>();

this.detector.DetectStopSign(image, imageList, rectangleList);

stopwatch.Stop();

this.messageLabel.Text = String.Format("STOP 표지판 검출 시간 : {0} 밀리초", stopwatch.Elapsed.TotalMilliseconds);

this.resultPanel.Controls.Clear();

Point startPoint = new Point(10, 10);

for(int i = 0; i < imageList.Count; i++)

{

Rectangle rectangle = rectangleList[i];

AddLabelAndImage

(

ref startPoint,

string.Format

(

"STOP 표지판 [{0}, {1}]",

rectangle.Location.Y + rectangle.Width / 2,

rectangle.Location.Y + rectangle.Height / 2

imageList[i]

);

image.Draw(rectangle, new Bgr(Color.Aquamarine), 2);

}

this.imageBox.Image = image;

}

#endregion

}

TestProject.zip

[C#/WINFORM/EMGUCV] Latent SVM 검출기 사용하기

■ Latent SVM 검출기를 사용하는 방법을 보여준다. ▶ Program.cs


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

using Emgu.CV;
using Emgu.CV.Structure;
using Emgu.CV.UI;
using System.Diagnostics;

namespace TestProject
{
    /// <summary>
    /// 프로그램
    /// </summary>
    static class Program
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Method
        ////////////////////////////////////////////////////////////////////////////////////////// Static
        //////////////////////////////////////////////////////////////////////////////// Private

        #region 프로그램 시작하기 - Main()

        /// <summary>
        /// 프로그램 시작하기
        /// </summary>
        [STAThread]
        private static void Main()
        {
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            Run();
        }

        #endregion

        #region 실행하기 - Run()

        /// <summary>
        /// 실행하기
        /// </summary>
        private static void Run()
        {
            using(Image<Bgr, Byte> image = new Image<Bgr, byte>("cat.jpg"))
            {
                using(LatentSvmDetector detector = new LatentSvmDetector("cat.xml"))
                {
                    Stopwatch stopwatch = Stopwatch.StartNew();

                    MCvObjectDetection[] objectDetectionArray = detector.Detect(image, 0.5f);

                    stopwatch.Stop();

                    foreach(MCvObjectDetection objectDetection in objectDetectionArray)
                    {
                        if(objectDetection.score > -0.5)
                        {
                            image.Draw(objectDetection.Rect, new Bgr(Color.Red), 1);
                        }
                    }

                    ImageViewer.Show(image, String.Format("객체 탐지 : {0} 밀리초", stopwatch.ElapsedMilliseconds));
                }
            }
        }

        #endregion
    }
}

using System;

using System.Drawing;

using System.Windows.Forms;

using Emgu.CV;

using Emgu.CV.Structure;

using Emgu.CV.UI;

using System.Diagnostics;

namespace TestProject

{

/// <summary>

/// 프로그램

/// </summary>

static class Program

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

////////////////////////////////////////////////////////////////////////////////////////// Static

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

#region 프로그램 시작하기 - Main()

/// <summary>

/// 프로그램 시작하기

/// </summary>

[STAThread]

private static void Main()

{

Application.EnableVisualStyles();

Application.SetCompatibleTextRenderingDefault(false);

Run();

}

#endregion

#region 실행하기 - Run()

/// <summary>

/// 실행하기

/// </summary>

private static void Run()

{

using(Image<Bgr, Byte> image = new Image<Bgr, byte>("cat.jpg"))

{

using(LatentSvmDetector detector = new LatentSvmDetector("cat.xml"))

{

Stopwatch stopwatch = Stopwatch.StartNew();

MCvObjectDetection[] objectDetectionArray = detector.Detect(image, 0.5f);

stopwatch.Stop();

foreach(MCvObjectDetection objectDetection in objectDetectionArray)

{

if(objectDetection.score > -0.5)

{

image.Draw(objectDetection.Rect, new Bgr(Color.Red), 1);

}

ImageViewer.Show(image, String.Format("객체 탐지 : {0} 밀리초", stopwatch.ElapsedMilliseconds));

}

#endregion

}

TestProject.zip

[C#/WINFORM/EMGUCV] 평면 분할하기

■ 평면을 분할하는 방법을 보여준다. ▶ PlanarSubdivisionHelper.cs


using System;
using System.Drawing;

using Emgu.CV;
using Emgu.CV.Structure;

namespace TestProject
{
    /// <summary>
    /// 평면 분할 헬퍼
    /// </summary>
    public static class PlanarSubdivisionHelper
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Method
        ////////////////////////////////////////////////////////////////////////////////////////// Static
        //////////////////////////////////////////////////////////////////////////////// Public

        #region 평면 분할 생성하기 - CreateSubdivision(maximumValue, pointCount, delaunayTriangleArray, voronoiFacetArray)

        /// <summary>
        /// 평면 분할 생성하기
        /// </summary>
        /// <param name="maximumValue">최대 값</param>
        /// <param name="pointCount">포인트 카운트</param>
        /// <param name="delaunayTriangleArray">들로네 삼각형 배열</param>
        /// <param name="voronoiFacetArray">보로노이 패싯 배열</param>
        public static void CreatePlanarSubdivision(float maximumValue, int pointCount, out Triangle2DF[] delaunayTriangleArray, out VoronoiFacet[] voronoiFacetArray)
        {
            #region 0에서 최대 값을 갖는 범위에서 임의 위치를 생성한다.

            PointF[] pointArray = new PointF[pointCount];

            Random random = new Random((int)(DateTime.Now.Ticks & 0x0000ffff));

            for(int i = 0; i < pointArray.Length; i++)
            {
                pointArray[i] = new PointF((float)random.NextDouble() * maximumValue, (float)random.NextDouble() * maximumValue);
            }

            #endregion

            using(PlanarSubdivision subdivision = new PlanarSubdivision(pointArray))
            {
                delaunayTriangleArray = subdivision.GetDelaunayTriangles();

                voronoiFacetArray = subdivision.GetVoronoiFacets();
            }
        }

        #endregion
        #region 평면 분할 그리기 - DrawPlanarSubdivision(maximumValue, pointCount)

        /// <summary>
        /// 평면 분할 그리기
        /// </summary>
        /// <param name="maximumValue">최대 값</param>
        /// <param name="pointCount">포인트 수</param>
        /// <returns></returns>
        public static Image<Bgr, Byte> DrawPlanarSubdivision(float maximumValue, int pointCount)
        {
            Triangle2DF[]  delaunayTriangleArray; // 들로네 삼각형 배열
            VoronoiFacet[] voronoiFacetArray;     // 보로노이 패싯 배열

            Random random = new Random((int)(DateTime.Now.Ticks & 0x0000ffff));

            CreatePlanarSubdivision(maximumValue, pointCount, out delaunayTriangleArray, out voronoiFacetArray);

            Image<Bgr, Byte> targetImage = new Image<Bgr, byte>((int)maximumValue, (int)maximumValue);

            foreach(VoronoiFacet voronoiFacet in voronoiFacetArray)
            {
                Point[] pointArray = Array.ConvertAll<PointF, Point>(voronoiFacet.Vertices, Point.Round);

                targetImage.FillConvexPoly
                (
                    pointArray,
                    new Bgr(random.NextDouble() * 120, random.NextDouble() * 120, random.NextDouble() * 120)
                );

                targetImage.DrawPolyline(pointArray, true, new Bgr(Color.Black), 2);

                targetImage.Draw(new CircleF(voronoiFacet.Point, 5.0f), new Bgr(Color.Red), 0);
            }

            foreach(Triangle2DF triangle in delaunayTriangleArray)
            {
                targetImage.Draw(triangle, new Bgr(Color.White), 1);
            }

            return targetImage;
        }

        #endregion
    }
}

using System;

using System.Drawing;

using Emgu.CV;

using Emgu.CV.Structure;

namespace TestProject

{

/// <summary>

/// 평면 분할 헬퍼

/// </summary>

public static class PlanarSubdivisionHelper

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

////////////////////////////////////////////////////////////////////////////////////////// Static

//////////////////////////////////////////////////////////////////////////////// Public

#region 평면 분할 생성하기 - CreateSubdivision(maximumValue, pointCount, delaunayTriangleArray, voronoiFacetArray)

/// <summary>

/// 평면 분할 생성하기

/// </summary>

/// <param name="maximumValue">최대 값</param>

/// <param name="pointCount">포인트 카운트</param>

/// <param name="delaunayTriangleArray">들로네 삼각형 배열</param>

/// <param name="voronoiFacetArray">보로노이 패싯 배열</param>

public static void CreatePlanarSubdivision(float maximumValue, int pointCount, out Triangle2DF[] delaunayTriangleArray, out VoronoiFacet[] voronoiFacetArray)

{

#region 0에서 최대 값을 갖는 범위에서 임의 위치를 생성한다.

PointF[] pointArray = new PointF[pointCount];

Random random = new Random((int)(DateTime.Now.Ticks & 0x0000ffff));

for(int i = 0; i < pointArray.Length; i++)

{

pointArray[i] = new PointF((float)random.NextDouble() * maximumValue, (float)random.NextDouble() * maximumValue);

}

#endregion

using(PlanarSubdivision subdivision = new PlanarSubdivision(pointArray))

{

delaunayTriangleArray = subdivision.GetDelaunayTriangles();

voronoiFacetArray = subdivision.GetVoronoiFacets();

}

#endregion

#region 평면 분할 그리기 - DrawPlanarSubdivision(maximumValue, pointCount)

/// <summary>

/// 평면 분할 그리기

/// </summary>

/// <param name="maximumValue">최대 값</param>

/// <param name="pointCount">포인트 수</param>

/// <returns></returns>

public static Image<Bgr, Byte> DrawPlanarSubdivision(float maximumValue, int pointCount)

{

Triangle2DF[] delaunayTriangleArray; // 들로네 삼각형 배열

VoronoiFacet[] voronoiFacetArray; // 보로노이 패싯 배열

Random random = new Random((int)(DateTime.Now.Ticks & 0x0000ffff));

CreatePlanarSubdivision(maximumValue, pointCount, out delaunayTriangleArray, out voronoiFacetArray);

Image<Bgr, Byte> targetImage = new Image<Bgr, byte>((int)maximumValue, (int)maximumValue);

foreach(VoronoiFacet voronoiFacet in voronoiFacetArray)

{

Point[] pointArray = Array.ConvertAll<PointF, Point>(voronoiFacet.Vertices, Point.Round);

targetImage.FillConvexPoly

(

pointArray,

new Bgr(random.NextDouble() * 120, random.NextDouble() * 120, random.NextDouble() * 120)

);

targetImage.DrawPolyline(pointArray, true, new Bgr(Color.Black), 2);

targetImage.Draw(new CircleF(voronoiFacet.Point, 5.0f), new Bgr(Color.Red), 0);

}

foreach(Triangle2DF triangle in delaunayTriangleArray)

{

targetImage.Draw(triangle, new Bgr(Color.White), 1);

}

return targetImage;

}

#endregion

}

▶ Program.cs


using System;
using System.Windows.Forms;

using Emgu.CV;
using Emgu.CV.Structure;
using Emgu.CV.UI;

namespace TestProject
{
    /// <summary>
    /// 프로그램
    /// </summary>
    static class Program
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Method
        ////////////////////////////////////////////////////////////////////////////////////////// Static
        //////////////////////////////////////////////////////////////////////////////// Private

        #region 프로그램 시작하기 - Main()

        /// <summary>
        /// 프로그램 시작하기
        /// </summary>
        [STAThread]
        private static void Main()
        {
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);

            Image<Bgr, Byte> image = PlanarSubdivisionHelper.DrawPlanarSubdivision(600, 20);

            ImageViewer.Show(image, "평면 분할하기");
        }

        #endregion
    }
}

using System;

using System.Windows.Forms;

using Emgu.CV;

using Emgu.CV.Structure;

using Emgu.CV.UI;

namespace TestProject

{

/// <summary>

/// 프로그램

/// </summary>

static class Program

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

////////////////////////////////////////////////////////////////////////////////////////// Static

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

#region 프로그램 시작하기 - Main()

/// <summary>

/// 프로그램 시작하기

/// </summary>

[STAThread]

private static void Main()

{

Application.EnableVisualStyles();

Application.SetCompatibleTextRenderingDefault(false);

Image<Bgr, Byte> image = PlanarSubdivisionHelper.DrawPlanarSubdivision(600, 20);

ImageViewer.Show(image, "평면 분할하기");

}

#endregion

}

TestProject.zip

[C#/WINFORM/EMGUCV] 비디오 감시하기

■ 비디오로 감시하는 방법을 보여준다. ▶ MainForm.cs


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

using Emgu.CV;
using Emgu.CV.CvEnum;
using Emgu.CV.Structure;
using Emgu.CV.VideoSurveillance;

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

        #region Field

        /// <summary>
        /// 폰트
        /// </summary>
        private MCvFont font = new MCvFont(FONT.CV_FONT_HERSHEY_SIMPLEX, 1.0, 1.0);

        /// <summary>
        /// 캡처
        /// </summary>
        private Capture capture;

        /// <summary>
        /// 추적기
        /// </summary>
        private BlobTrackerAuto<Bgr> tracker;

        /// <summary>
        /// 검출기
        /// </summary>
        private IBGFGDetector<Bgr> detector;

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Constructor
        ////////////////////////////////////////////////////////////////////////////////////////// Public

        #region 생성자 - MainForm()

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

            Run();
        }

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Method
        ////////////////////////////////////////////////////////////////////////////////////////// Private
        //////////////////////////////////////////////////////////////////////////////// Event

        #region 애플리케이션 휴지시 처리하기 - Application_Idle(sender, e)

        /// <summary>
        /// 애플리케이션 휴지시 처리하기
        /// </summary>
        /// <param name="sender">이벤트 발생자</param>
        /// <param name="e">이벤트 인자</param>
        private void Application_Idle(object sender, EventArgs e)
        {
            Image<Bgr, Byte> captureImage = this.capture.QueryFrame();

            captureImage._SmoothGaussian(3);

            this.detector.Update(captureImage);

            Image<Gray, Byte> maskImage = this.detector.ForegroundMask;

            this.tracker.Process(captureImage, maskImage);

            foreach(MCvBlob blob in this.tracker)
            {
                captureImage.Draw((Rectangle)blob, new Bgr(255.0, 255.0, 255.0), 2);

                captureImage.Draw(blob.ID.ToString(), ref this.font, Point.Round(blob.Center), new Bgr(255.0, 255.0, 255.0));
            }

            this.captureImageBox.Image = captureImage;

            this.maskImageBox.Image = maskImage;
        }

        #endregion

        //////////////////////////////////////////////////////////////////////////////// Function

        #region 실행하기 - Run()

        /// <summary>
        /// 실행하기
        /// </summary>
        private void Run()
        {
            try
            {
                this.capture = new Capture();
            }
            catch(Exception exception)
            {
                MessageBox.Show(exception.Message);

                return;
            }

            this.detector = new FGDetector<Bgr>(FORGROUND_DETECTOR_TYPE.FGD);

            this.tracker = new BlobTrackerAuto<Bgr>();

            Application.Idle += Application_Idle;
        }

        #endregion
    }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

using System;

using System.Drawing;

using System.Windows.Forms;

using Emgu.CV;

using Emgu.CV.CvEnum;

using Emgu.CV.Structure;

using Emgu.CV.VideoSurveillance;

namespace TestProject

{

/// <summary>

/// 메인 폼

/// </summary>

public partial class MainForm : Form

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Field

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

#region Field

/// <summary>

/// 폰트

/// </summary>

private MCvFont font = new MCvFont(FONT.CV_FONT_HERSHEY_SIMPLEX, 1.0, 1.0);

/// <summary>

/// 캡처

/// </summary>

private Capture capture;

/// <summary>

/// 추적기

/// </summary>

private BlobTrackerAuto<Bgr> tracker;

/// <summary>

/// 검출기

/// </summary>

private IBGFGDetector<Bgr> detector;

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Constructor

////////////////////////////////////////////////////////////////////////////////////////// Public

#region 생성자 - MainForm()

/// <summary>

/// 생성자

/// </summary>

public MainForm()

{

InitializeComponent();

Run();

}

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

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

//////////////////////////////////////////////////////////////////////////////// Event

#region 애플리케이션 휴지시 처리하기 - Application_Idle(sender, e)

/// <summary>

/// 애플리케이션 휴지시 처리하기

/// </summary>

/// <param name="sender">이벤트 발생자</param>

/// <param name="e">이벤트 인자</param>

private void Application_Idle(object sender, EventArgs e)

{

Image<Bgr, Byte> captureImage = this.capture.QueryFrame();

captureImage._SmoothGaussian(3);

this.detector.Update(captureImage);

Image<Gray, Byte> maskImage = this.detector.ForegroundMask;

this.tracker.Process(captureImage, maskImage);

foreach(MCvBlob blob in this.tracker)

{

captureImage.Draw((Rectangle)blob, new Bgr(255.0, 255.0, 255.0), 2);

captureImage.Draw(blob.ID.ToString(), ref this.font, Point.Round(blob.Center), new Bgr(255.0, 255.0, 255.0));

}

this.captureImageBox.Image = captureImage;

this.maskImageBox.Image = maskImage;

}

#endregion

//////////////////////////////////////////////////////////////////////////////// Function

#region 실행하기 - Run()

/// <summary>

/// 실행하기

/// </summary>

private void Run()

{

try

{

this.capture = new Capture();

}

catch(Exception exception)

{

MessageBox.Show(exception.Message);

return;

}

this.detector = new FGDetector<Bgr>(FORGROUND_DETECTOR_TYPE.FGD);

this.tracker = new BlobTrackerAuto<Bgr>();

Application.Idle += Application_Idle;

}

#endregion

}

TestProject.zip

[C#/WINFORM/EMGUCV] 사진 이어 붙이기

■ 사진을 이어 붙이는 방법을 보여준다. ▶ MainForm.cs


using System;
using System.Windows.Forms;

using Emgu.CV;
using Emgu.CV.CvEnum;
using Emgu.CV.Stitching;
using Emgu.CV.Structure;

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

        #region Field

        /// <summary>
        /// 파일 열기 대화 상자
        /// </summary>
        private OpenFileDialog openFileDialog;

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Constructor
        ////////////////////////////////////////////////////////////////////////////////////////// Public

        #region 생성자 - MainForm()

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

            this.openFileDialog = new OpenFileDialog();

            this.openFileDialog.CheckFileExists = true;
            this.openFileDialog.Multiselect     = true;
        }

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Constructor
        ////////////////////////////////////////////////////////////////////////////////////////// Public

        #region 이미지 선택 버튼 클릭시 처리하기 - selectButton_Click(sender, e)

        /// <summary>
        /// 이미지 선택 버튼 클릭시 처리하기
        /// </summary>
        /// <param name="sender">이벤트 발생자</param>
        /// <param name="e">이벤트 인자</param>
        private void selectButton_Click(object sender, EventArgs e)
        {
            if(this.openFileDialog.ShowDialog() == DialogResult.OK)
            {
                this.imageDataGridView.Rows.Clear();

                Image<Bgr, Byte>[] sourceImageArray = new Image<Bgr, byte>[this.openFileDialog.FileNames.Length];

                int sourceImageArrayLength = sourceImageArray.Length;

                for(int i = 0; i < sourceImageArrayLength; i++)
                {
                    sourceImageArray[i] = new Image<Bgr, byte>(this.openFileDialog.FileNames[i]);

                    using(Image<Bgr, byte> thumbnailImage = sourceImageArray[i].Resize(200, 200, INTER.CV_INTER_CUBIC, true))
                    {
                        DataGridViewRow row = this.imageDataGridView.Rows[imageDataGridView.Rows.Add()];

                        row.Cells["fileNameColumn" ].Value = this.openFileDialog.FileNames[i];
                        row.Cells["thumbnailColumn"].Value = thumbnailImage.ToBitmap();

                        row.Height = 200;
                    }
                }

                try
                {
                    using(Stitcher stitcher = new Stitcher(true))
                    {
                        Image<Bgr, Byte> resultImage = stitcher.Stitch(sourceImageArray);

                        this.resultImageBox.Image = resultImage;
                    }
                }
                finally
                {
                    foreach(Image<Bgr, Byte> sourceImage in sourceImageArray)
                    {
                        sourceImage.Dispose();
                    }
                }
            }
        }

        #endregion
    }
}

100

101

102

103

104

105

106

using System;

using System.Windows.Forms;

using Emgu.CV;

using Emgu.CV.CvEnum;

using Emgu.CV.Stitching;

using Emgu.CV.Structure;

namespace TestProject

{

/// <summary>

/// 메인 폼

/// </summary>

public partial class MainForm : Form

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Field

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

#region Field

/// <summary>

/// 파일 열기 대화 상자

/// </summary>

private OpenFileDialog openFileDialog;

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Constructor

////////////////////////////////////////////////////////////////////////////////////////// Public

#region 생성자 - MainForm()

/// <summary>

/// 생성자

/// </summary>

public MainForm()

{

InitializeComponent();

this.openFileDialog = new OpenFileDialog();

this.openFileDialog.CheckFileExists = true;

this.openFileDialog.Multiselect = true;

}

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Constructor

////////////////////////////////////////////////////////////////////////////////////////// Public

#region 이미지 선택 버튼 클릭시 처리하기 - selectButton_Click(sender, e)

/// <summary>

/// 이미지 선택 버튼 클릭시 처리하기

/// </summary>

/// <param name="sender">이벤트 발생자</param>

/// <param name="e">이벤트 인자</param>

private void selectButton_Click(object sender, EventArgs e)

{

if(this.openFileDialog.ShowDialog() == DialogResult.OK)

{

this.imageDataGridView.Rows.Clear();

Image<Bgr, Byte>[] sourceImageArray = new Image<Bgr, byte>[this.openFileDialog.FileNames.Length];

int sourceImageArrayLength = sourceImageArray.Length;

for(int i = 0; i < sourceImageArrayLength; i++)

{

sourceImageArray[i] = new Image<Bgr, byte>(this.openFileDialog.FileNames[i]);

using(Image<Bgr, byte> thumbnailImage = sourceImageArray[i].Resize(200, 200, INTER.CV_INTER_CUBIC, true))

{

DataGridViewRow row = this.imageDataGridView.Rows[imageDataGridView.Rows.Add()];

row.Cells["fileNameColumn" ].Value = this.openFileDialog.FileNames[i];

row.Cells["thumbnailColumn"].Value = thumbnailImage.ToBitmap();

row.Height = 200;

}

try

{

using(Stitcher stitcher = new Stitcher(true))

{

Image<Bgr, Byte> resultImage = stitcher.Stitch(sourceImageArray);

this.resultImageBox.Image = resultImage;

}

finally

{

foreach(Image<Bgr, Byte> sourceImage in sourceImageArray)

{

sourceImage.Dispose();

}

#endregion

}

TestProject.zip

[C#/WINFORM/EMGUCV] 자동차 번호판 인식하기

■ 자동차 번호판을 인식하는 방법을 보여준다. ▶ LicensePlateDetector.cs


using System;
using System.Collections.Generic;
using System.Drawing;
using System.Text;

using Emgu.CV;
using Emgu.CV.CvEnum;
using Emgu.CV.OCR;
using Emgu.CV.Structure;
using Emgu.Util;

namespace TestProject
{
    /// <summary>
    /// 자동차 번호판 검출기
    /// </summary>
    public class LicensePlateDetector : DisposableObject
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Field
        ////////////////////////////////////////////////////////////////////////////////////////// Private

        #region Field

        /// <summary>
        /// OCR
        /// </summary>
        private Tesseract ocr;

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Constructor
        ////////////////////////////////////////////////////////////////////////////////////////// Public

        #region 생성자 - LicensePlateDetector(dataPath)

        /// <summary>
        /// 생성자
        /// </summary>
        /// <param name="dataPath">데이터 경로</param>
        public LicensePlateDetector(string dataPath)
        {
            this.ocr = new Tesseract(dataPath, "eng", Tesseract.OcrEngineMode.OEM_TESSERACT_CUBE_COMBINED);

            this.ocr.SetVariable("tessedit_char_whitelist", "ABCDEFGHIJKLMNOPQRSTUVWXYZ-1234567890");
        }

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Method
        ////////////////////////////////////////////////////////////////////////////////////////// Public

        #region 자동차 번호판 검출하기 - DetectLicensePlate(sourceImage, licensePlateImageList, filteredLicensePlateImageList, detectedLicensePlateRectangleList)

        /// <summary>
        /// 자동차 번호판 검출하기
        /// </summary>
        /// <param name="sourceImage">소스 이미지</param>
        /// <param name="licensePlateImageList">자동차 번호판 이미지 리스트</param>
        /// <param name="filteredLicensePlateImageList">필터 자동차 번호판 이미지 리스트</param>
        /// <param name="detectedLicensePlateRectangleList">검출 자동차 번호판 사각형 리스트</param>
        /// <returns>자동차 번호 리스트</returns>
        public List<string> DetectLicensePlate
        (
            Image<Bgr, byte> sourceImage,
            List<Image<Gray, Byte>> licensePlateImageList,
            List<Image<Gray, Byte>> filteredLicensePlateImageList,
            List<MCvBox2D> detectedLicensePlateRectangleList)
        {
            List<string> licenseList = new List<String>();

            using(Image<Gray, byte> grayscaleImage = sourceImage.Convert<Gray, Byte>())
            {
                using(Image<Gray, Byte> cannyImage = new Image<Gray, byte>(grayscaleImage.Size))
                {
                    using(MemStorage storage = new MemStorage())
                    {
                        CvInvoke.cvCanny(grayscaleImage, cannyImage, 100, 50, 3);

                        Contour<Point> pointContour = cannyImage.FindContours
                        (
                            CHAIN_APPROX_METHOD.CV_CHAIN_APPROX_SIMPLE,
                            RETR_TYPE.CV_RETR_TREE,
                            storage
                        );

                        FindLicensePlate
                        (
                            pointContour,
                            grayscaleImage,
                            cannyImage,
                            licensePlateImageList,
                            filteredLicensePlateImageList,
                            detectedLicensePlateRectangleList,
                            licenseList
                        );
                    }
                }
            }

            return licenseList;
        }

        #endregion

        ////////////////////////////////////////////////////////////////////////////////////////// Public

        #region 흰색 픽셀 마스크 구하기 - GetWhitePixelMask(image)

        /// <summary>
        /// 흰색 픽셀 마스크 구하기
        /// </summary>
        /// <param name="image">이미지</param>
        /// <returns>흰색 픽셀 마스크</returns>
        /// <remarks>
        /// 흰색 픽셀은 채도가 40보다 작거나 200보다 큰 경우에 해당한다.
        /// </remarks>
        private static Image<Gray, Byte> GetWhitePixelMask(Image<Bgr, byte> image)
        {
            using(Image<Hsv, Byte> hsvImage = image.Convert<Hsv, Byte>())
            {
                Image<Gray, Byte>[] grayscaleImageArray = hsvImage.Split();

                try
                {
                    grayscaleImageArray[1]._ThresholdBinaryInv(new Gray(40), new Gray(255));

                    grayscaleImageArray[2]._ThresholdBinary(new Gray(200), new Gray(255));

                    CvInvoke.cvAnd(grayscaleImageArray[1], grayscaleImageArray[2], grayscaleImageArray[0], IntPtr.Zero);
                }
                finally
                {
                    grayscaleImageArray[1].Dispose();
                    grayscaleImageArray[2].Dispose();
                }

                return grayscaleImageArray[0];
            }
        }

        #endregion
        #region 자식 카운트 구하기 - GetChildCount(contour)

        /// <summary>
        /// 자식 카운트 구하기
        /// </summary>
        /// <param name="contour">윤곽</param>
        /// <returns>자식 카운트</returns>
        private static int GetChildCount(Contour<Point> contour)
        {
            Contour<Point> childContour = contour.VNext;

            if(childContour == null)
            {
                return 0;
            }

            int count = 0;

            while(childContour != null)
            {
                count++;

                childContour = childContour.HNext;
            }

            return count;
        }

        #endregion
        #region 자동차 번호판 찾기 - FindLicensePlate(pointContour, grayscaleImage, cannyImage, licensePlateImageList, filteredLicensePlateImageList,
            detectedLicensePlateRectangleList, licenseList)

        /// <summary>
        /// 자동차 번호판 찾기
        /// </summary>
        /// <param name="pointContour">포인트 윤곽</param>
        /// <param name="grayscaleImage">회색조 이미지</param>
        /// <param name="cannyImage">캐니 이미지</param>
        /// <param name="licensePlateImageList">자동차 번호판 이미지 리스트</param>
        /// <param name="filteredLicensePlateImageList">필터 자동차 번호판 이미지 리스트</param>
        /// <param name="detectedLicensePlateRectangleList">검출 자동차 번호판 사각형 리스트</param>
        /// <param name="licenseList">자동차 번호 리스트</param>
        private void FindLicensePlate
        (
            Contour<Point> pointContour,
            Image<Gray, Byte> grayscaleImage,
            Image<Gray, Byte> cannyImage,
            List<Image<Gray, Byte>> licensePlateImageList,
            List<Image<Gray, Byte>> filteredLicensePlateImageList,
            List<MCvBox2D> detectedLicensePlateRectangleList,
            List<String> licenseList
        )
        {
            for(; pointContour != null; pointContour = pointContour.HNext)
            {
                int childCount = GetChildCount(pointContour);

                if(childCount == 0)
                {
                    continue;
                }

                if(pointContour.Area > 400)
                {
                    if(childCount < 3)
                    {
                        // 윤곽선에 자식 윤곽선이 3개 보다 작은 경우는 자동차 번호판이 아니디.
                        // (자동차 번호판에 문자가 3자 이상 있다고 가정한다)
                        // 그러나 윤곽선의 자식 윤곽선을 검색해 그 중 하나가 자동차 번호판인지 확인해야 한다.
                        FindLicensePlate
                        (
                            pointContour.VNext,
                            grayscaleImage,
                            cannyImage,
                            licensePlateImageList,
                            filteredLicensePlateImageList,
                            detectedLicensePlateRectangleList,
                            licenseList
                        );

                        continue;
                    }

                    MCvBox2D rectangle = pointContour.GetMinAreaRect();

                    if(rectangle.angle < -45.0)
                    {
                        float temporaryWidth = rectangle.size.Width;

                        rectangle.size.Width  = rectangle.size.Height;
                        rectangle.size.Height = temporaryWidth;

                        rectangle.angle += 90.0f;
                    }
                    else if(rectangle.angle > 45.0)
                    {
                        float temporaryWidth = rectangle.size.Width;

                        rectangle.size.Width  = rectangle.size.Height;
                        rectangle.size.Height = temporaryWidth;

                        rectangle.angle -= 90.0f;
                    }

                    double ratio = (double)rectangle.size.Width / rectangle.size.Height;

                    if(!(3.0 < ratio && ratio < 10.0))
                    {
                        Contour<Point> childContour = pointContour.VNext;

                        if(childContour != null)
                        {
                            FindLicensePlate
                            (
                                childContour,
                                grayscaleImage,
                                cannyImage,
                                licensePlateImageList,
                                filteredLicensePlateImageList,
                                detectedLicensePlateRectangleList,
                                licenseList
                            );
                        }

                        continue;
                    }

                    using(Image<Gray, Byte> temporaryImage1 = grayscaleImage.Copy(rectangle))
                    {
                        using(Image<Gray, Byte> temporaryImage2 = temporaryImage1.Resize(240, 180, INTER.CV_INTER_CUBIC, true))
                        {
                            int edgePixelSize = 2;

                            temporaryImage2.ROI = new Rectangle
                            (
                                new Point(edgePixelSize, edgePixelSize),
                                temporaryImage2.Size - new Size(2 * edgePixelSize, 2 * edgePixelSize)
                            );

                            Image<Gray, Byte> plateImage = temporaryImage2.Copy();

                            Image<Gray, Byte> filteredPlateImage = FilterLicensePlateImage(plateImage);

                            Tesseract.Charactor[] charactorArray;

                            StringBuilder stringBuilder = new StringBuilder();

                            using(Image<Gray, Byte> temporaryImage3 = filteredPlateImage.Clone())
                            {
                                this.ocr.Recognize(temporaryImage3);

                                charactorArray = this.ocr.GetCharactors();

                                if(charactorArray.Length == 0)
                                {
                                    continue;
                                }

                                for(int i = 0; i < charactorArray.Length; i++)
                                {
                                    stringBuilder.Append(charactorArray[i].Text);
                                }
                            }

                            licenseList.Add(stringBuilder.ToString());

                            licensePlateImageList.Add(plateImage);

                            filteredLicensePlateImageList.Add(filteredPlateImage);

                            detectedLicensePlateRectangleList.Add(rectangle);
                        }
                    }
                }
            }
        }

        #endregion
        #region 자동차 번호판 이미지 필터하기 - FilterLicensePlateImage(sourceImage)

        /// <summary>
        /// 자동차 번호판 이미지 필터하기
        /// </summary>
        /// <param name="sourceImage">소스 이미지</param>
        /// <returns>필터 이미지</returns>
        private static Image<Gray, Byte> FilterLicensePlateImage(Image<Gray, Byte> sourceImage)
        {
            Image<Gray, Byte> threshImage = sourceImage.ThresholdBinaryInv(new Gray(120), new Gray(255));

            using(Image<Gray, Byte> maskImage = new Image<Gray, byte>(sourceImage.Size))
            {
                using(Image<Gray, Byte> cannyImage = sourceImage.Canny(100, 50))
                {
                    using(MemStorage storage = new MemStorage())
                    {
                        maskImage.SetValue(255.0);

                        for(Contour<Point> pointContour = cannyImage.FindContours(CHAIN_APPROX_METHOD.CV_CHAIN_APPROX_SIMPLE, RETR_TYPE.CV_RETR_EXTERNAL, storage);
                            pointContour != null; pointContour = pointContour.HNext)
                        {
                            Rectangle rectangle = pointContour.BoundingRectangle;

                            if(rectangle.Height > (sourceImage.Height >> 1))
                            {
                                rectangle.X -= 1;
                                rectangle.Y -= 1;

                                rectangle.Width  += 2;
                                rectangle.Height += 2;

                                rectangle.Intersect(sourceImage.ROI);

                                maskImage.Draw(rectangle, new Gray(0.0), -1);
                            }
                        }

                        threshImage.SetValue(0, maskImage);
                    }
                }
            }

            threshImage._Erode(1);
            threshImage._Dilate(1);

            return threshImage;
        }

        #endregion
        #region 객체 리소스 해제하기 - DisposeObject()

        /// <summary>
        /// 객체 리소스 해제하기
        /// </summary>
        protected override void DisposeObject()
        {
            this.ocr.Dispose();
        }

        #endregion
    }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

using System;

using System.Collections.Generic;

using System.Drawing;

using System.Text;

using Emgu.CV;

using Emgu.CV.CvEnum;

using Emgu.CV.OCR;

using Emgu.CV.Structure;

using Emgu.Util;

namespace TestProject

{

/// <summary>

/// 자동차 번호판 검출기

/// </summary>

public class LicensePlateDetector : DisposableObject

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Field

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

#region Field

/// <summary>

/// OCR

/// </summary>

private Tesseract ocr;

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Constructor

////////////////////////////////////////////////////////////////////////////////////////// Public

#region 생성자 - LicensePlateDetector(dataPath)

/// <summary>

/// 생성자

/// </summary>

/// <param name="dataPath">데이터 경로</param>

public LicensePlateDetector(string dataPath)

{

this.ocr = new Tesseract(dataPath, "eng", Tesseract.OcrEngineMode.OEM_TESSERACT_CUBE_COMBINED);

this.ocr.SetVariable("tessedit_char_whitelist", "ABCDEFGHIJKLMNOPQRSTUVWXYZ-1234567890");

}

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

////////////////////////////////////////////////////////////////////////////////////////// Public

#region 자동차 번호판 검출하기 - DetectLicensePlate(sourceImage, licensePlateImageList, filteredLicensePlateImageList, detectedLicensePlateRectangleList)

/// <summary>

/// 자동차 번호판 검출하기

/// </summary>

/// <param name="sourceImage">소스 이미지</param>

/// <param name="licensePlateImageList">자동차 번호판 이미지 리스트</param>

/// <param name="filteredLicensePlateImageList">필터 자동차 번호판 이미지 리스트</param>

/// <param name="detectedLicensePlateRectangleList">검출 자동차 번호판 사각형 리스트</param>

/// <returns>자동차 번호 리스트</returns>

public List<string> DetectLicensePlate

(

Image<Bgr, byte> sourceImage,

List<Image<Gray, Byte>> licensePlateImageList,

List<Image<Gray, Byte>> filteredLicensePlateImageList,

List<MCvBox2D> detectedLicensePlateRectangleList)

{

List<string> licenseList = new List<String>();

using(Image<Gray, byte> grayscaleImage = sourceImage.Convert<Gray, Byte>())

{

using(Image<Gray, Byte> cannyImage = new Image<Gray, byte>(grayscaleImage.Size))

{

using(MemStorage storage = new MemStorage())

{

CvInvoke.cvCanny(grayscaleImage, cannyImage, 100, 50, 3);

Contour<Point> pointContour = cannyImage.FindContours

(

CHAIN_APPROX_METHOD.CV_CHAIN_APPROX_SIMPLE,

RETR_TYPE.CV_RETR_TREE,

storage

);

FindLicensePlate

(

pointContour,

grayscaleImage,

cannyImage,

licensePlateImageList,

filteredLicensePlateImageList,

detectedLicensePlateRectangleList,

licenseList

);

}

return licenseList;

}

#endregion

////////////////////////////////////////////////////////////////////////////////////////// Public

#region 흰색 픽셀 마스크 구하기 - GetWhitePixelMask(image)

/// <summary>

/// 흰색 픽셀 마스크 구하기

/// </summary>

/// <param name="image">이미지</param>

/// <returns>흰색 픽셀 마스크</returns>

/// <remarks>

/// 흰색 픽셀은 채도가 40보다 작거나 200보다 큰 경우에 해당한다.

/// </remarks>

private static Image<Gray, Byte> GetWhitePixelMask(Image<Bgr, byte> image)

{

using(Image<Hsv, Byte> hsvImage = image.Convert<Hsv, Byte>())

{

Image<Gray, Byte>[] grayscaleImageArray = hsvImage.Split();

try

{

grayscaleImageArray[1]._ThresholdBinaryInv(new Gray(40), new Gray(255));

grayscaleImageArray[2]._ThresholdBinary(new Gray(200), new Gray(255));

CvInvoke.cvAnd(grayscaleImageArray[1], grayscaleImageArray[2], grayscaleImageArray[0], IntPtr.Zero);

}

finally

{

grayscaleImageArray[1].Dispose();

grayscaleImageArray[2].Dispose();

}

return grayscaleImageArray[0];

}

#endregion

#region 자식 카운트 구하기 - GetChildCount(contour)

/// <summary>

/// 자식 카운트 구하기

/// </summary>

/// <param name="contour">윤곽</param>

/// <returns>자식 카운트</returns>

private static int GetChildCount(Contour<Point> contour)

{

Contour<Point> childContour = contour.VNext;

if(childContour == null)

{

return 0;

}

int count = 0;

while(childContour != null)

{

count++;

childContour = childContour.HNext;

}

return count;

}

#endregion

#region 자동차 번호판 찾기 - FindLicensePlate(pointContour, grayscaleImage, cannyImage, licensePlateImageList, filteredLicensePlateImageList,

detectedLicensePlateRectangleList, licenseList)

/// <summary>

/// 자동차 번호판 찾기

/// </summary>

/// <param name="pointContour">포인트 윤곽</param>

/// <param name="grayscaleImage">회색조 이미지</param>

/// <param name="cannyImage">캐니 이미지</param>

/// <param name="licensePlateImageList">자동차 번호판 이미지 리스트</param>

/// <param name="filteredLicensePlateImageList">필터 자동차 번호판 이미지 리스트</param>

/// <param name="detectedLicensePlateRectangleList">검출 자동차 번호판 사각형 리스트</param>

/// <param name="licenseList">자동차 번호 리스트</param>

private void FindLicensePlate

(

Contour<Point> pointContour,

Image<Gray, Byte> grayscaleImage,

Image<Gray, Byte> cannyImage,

List<Image<Gray, Byte>> licensePlateImageList,

List<Image<Gray, Byte>> filteredLicensePlateImageList,

List<MCvBox2D> detectedLicensePlateRectangleList,

List<String> licenseList

)

{

for(; pointContour != null; pointContour = pointContour.HNext)

{

int childCount = GetChildCount(pointContour);

if(childCount == 0)

{

continue;

}

if(pointContour.Area > 400)

{

if(childCount < 3)

{

// 윤곽선에 자식 윤곽선이 3개 보다 작은 경우는 자동차 번호판이 아니디.

// (자동차 번호판에 문자가 3자 이상 있다고 가정한다)

// 그러나 윤곽선의 자식 윤곽선을 검색해 그 중 하나가 자동차 번호판인지 확인해야 한다.

FindLicensePlate

(

pointContour.VNext,

grayscaleImage,

cannyImage,

licensePlateImageList,

filteredLicensePlateImageList,

detectedLicensePlateRectangleList,

licenseList

);

continue;

}

MCvBox2D rectangle = pointContour.GetMinAreaRect();

if(rectangle.angle < -45.0)

{

float temporaryWidth = rectangle.size.Width;

rectangle.size.Width = rectangle.size.Height;

rectangle.size.Height = temporaryWidth;

rectangle.angle += 90.0f;

}

else if(rectangle.angle > 45.0)

{

float temporaryWidth = rectangle.size.Width;

rectangle.size.Width = rectangle.size.Height;

rectangle.size.Height = temporaryWidth;

rectangle.angle -= 90.0f;

}

double ratio = (double)rectangle.size.Width / rectangle.size.Height;

if(!(3.0 < ratio && ratio < 10.0))

{

Contour<Point> childContour = pointContour.VNext;

if(childContour != null)

{

FindLicensePlate

(

childContour,

grayscaleImage,

cannyImage,

licensePlateImageList,

filteredLicensePlateImageList,

detectedLicensePlateRectangleList,

licenseList

);

}

continue;

}

using(Image<Gray, Byte> temporaryImage1 = grayscaleImage.Copy(rectangle))

{

using(Image<Gray, Byte> temporaryImage2 = temporaryImage1.Resize(240, 180, INTER.CV_INTER_CUBIC, true))

{

int edgePixelSize = 2;

temporaryImage2.ROI = new Rectangle

(

new Point(edgePixelSize, edgePixelSize),

temporaryImage2.Size - new Size(2 * edgePixelSize, 2 * edgePixelSize)

);

Image<Gray, Byte> plateImage = temporaryImage2.Copy();

Image<Gray, Byte> filteredPlateImage = FilterLicensePlateImage(plateImage);

Tesseract.Charactor[] charactorArray;

StringBuilder stringBuilder = new StringBuilder();

using(Image<Gray, Byte> temporaryImage3 = filteredPlateImage.Clone())

{

this.ocr.Recognize(temporaryImage3);

charactorArray = this.ocr.GetCharactors();

if(charactorArray.Length == 0)

{

continue;

}

for(int i = 0; i < charactorArray.Length; i++)

{

stringBuilder.Append(charactorArray[i].Text);

}

licenseList.Add(stringBuilder.ToString());

licensePlateImageList.Add(plateImage);

filteredLicensePlateImageList.Add(filteredPlateImage);

detectedLicensePlateRectangleList.Add(rectangle);

}

#endregion

#region 자동차 번호판 이미지 필터하기 - FilterLicensePlateImage(sourceImage)

/// <summary>

/// 자동차 번호판 이미지 필터하기

/// </summary>

/// <param name="sourceImage">소스 이미지</param>

/// <returns>필터 이미지</returns>

private static Image<Gray, Byte> FilterLicensePlateImage(Image<Gray, Byte> sourceImage)

{

Image<Gray, Byte> threshImage = sourceImage.ThresholdBinaryInv(new Gray(120), new Gray(255));

using(Image<Gray, Byte> maskImage = new Image<Gray, byte>(sourceImage.Size))

{

using(Image<Gray, Byte> cannyImage = sourceImage.Canny(100, 50))

{

using(MemStorage storage = new MemStorage())

{

maskImage.SetValue(255.0);

for(Contour<Point> pointContour = cannyImage.FindContours(CHAIN_APPROX_METHOD.CV_CHAIN_APPROX_SIMPLE, RETR_TYPE.CV_RETR_EXTERNAL, storage);

pointContour != null; pointContour = pointContour.HNext)

{

Rectangle rectangle = pointContour.BoundingRectangle;

if(rectangle.Height > (sourceImage.Height >> 1))

{

rectangle.X -= 1;

rectangle.Y -= 1;

rectangle.Width += 2;

rectangle.Height += 2;

rectangle.Intersect(sourceImage.ROI);

maskImage.Draw(rectangle, new Gray(0.0), -1);

}

threshImage.SetValue(0, maskImage);

}

threshImage._Erode(1);

threshImage._Dilate(1);

return threshImage;

}

#endregion

#region 객체 리소스 해제하기 - DisposeObject()

/// <summary>

/// 객체 리소스 해제하기

/// </summary>

protected override void DisposeObject()

{

this.ocr.Dispose();

}

#endregion

}

▶ MainForm.cs


using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Drawing;
using System.Windows.Forms;

using Emgu.CV;
using Emgu.CV.Structure;
using Emgu.CV.UI;

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

        #region Field

        /// <summary>
        /// 번호판 검출기
        /// </summary>
        private LicensePlateDetector licensePlateDetector;

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Constructor
        ////////////////////////////////////////////////////////////////////////////////////////// Public

        #region 생성자 - MainForm()

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

            this.filePathButton.Click += filePathButton_Click;

            this.licensePlateDetector = new LicensePlateDetector("");

            ProcessImage(new Image<Bgr, byte>("LicensePlate.jpg"));
        }

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Method
        ////////////////////////////////////////////////////////////////////////////////////////// Private
        //////////////////////////////////////////////////////////////////////////////// Event

        #region 파일 경로 버튼 클릭시 처리하기 - filePathButton_Click(sender, e)

        /// <summary>
        /// 파일 경로 버튼 클릭시 처리하기
        /// </summary>
        /// <param name="sender">이벤트 발생자</param>
        /// <param name="e">이벤트 인자</param>
        private void filePathButton_Click(object sender, EventArgs e)
        {
            DialogResult result = this.openFileDialog.ShowDialog();

            if(result == DialogResult.OK)
            {
                Image<Bgr, Byte> image;

                try
                {
                    image = new Image<Bgr, byte>(this.openFileDialog.FileName);
                }
                catch
                {
                    MessageBox.Show(string.Format("무효한 파일 : {0}", this.openFileDialog.FileName));

                    return;
                }

                ProcessImage(image);
            }
        }

        #endregion

        //////////////////////////////////////////////////////////////////////////////// Function

        #region 레이블/이미지 추가하기 - AddLabelAndImage(startPoint, labelText, image)

        /// <summary>
        /// 레이블/이미지 추가하기
        /// </summary>
        /// <param name="startPoint">시작 위치</param>
        /// <param name="labelText">레이블 텍스트</param>
        /// <param name="image">이미지</param>
        private void AddLabelAndImage(ref Point startPoint, string labelText, IImage image)
        {
            Label label = new Label();

            this.resultPanel.Controls.Add(label);

            label.Width    = 200;
            label.Height   = 30;
            label.Location = startPoint;
            label.Text     = labelText;

            startPoint.Y += label.Height;

            ImageBox imageBox = new ImageBox();

            this.resultPanel.Controls.Add(imageBox);

            imageBox.ClientSize = image.Size;
            imageBox.Location   = startPoint;
            imageBox.Image      = image;

            startPoint.Y += imageBox.Height + 10;
        }

        #endregion
        #region 이미지 처리하기 - ProcessImage(image)

        /// <summary>
        /// 이미지 처리하기
        /// </summary>
        /// <param name="image">이미지</param>
        private void ProcessImage(Image<Bgr, byte> image)
        {
            Stopwatch stopwatch = Stopwatch.StartNew();

            List<Image<Gray, Byte>> licensePlateImageList = new List<Image<Gray, byte>>();

            List<Image<Gray, Byte>> filteredLicensePlateImageList = new List<Image<Gray, byte>>();

            List<MCvBox2D> licenseRectangleList = new List<MCvBox2D>();

            List<string> licensePlateArray = this.licensePlateDetector.DetectLicensePlate
            (
                image,
                licensePlateImageList,
                filteredLicensePlateImageList,
                licenseRectangleList
            );

            stopwatch.Stop();

            this.messageLabel.Text = string.Format("자동차 번호판 인식 시간 : {0} 밀리초", stopwatch.Elapsed.TotalMilliseconds);

            this.resultPanel.Controls.Clear();

            Point startPoint = new Point(10, 10);

            for(int i = 0; i < licensePlateArray.Count; i++)
            {
                AddLabelAndImage
                (
                    ref startPoint,
                    string.Format("자동차 번호 : {0}", licensePlateArray[i]),
                    licensePlateImageList[i].ConcateVertical(filteredLicensePlateImageList[i])
                );

                image.Draw(licenseRectangleList[i], new Bgr(Color.Red), 2);
            }

            this.imageBox.Image = image;
        }

        #endregion
    }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

using System;

using System.Collections.Generic;

using System.Diagnostics;

using System.Drawing;

using System.Windows.Forms;

using Emgu.CV;

using Emgu.CV.Structure;

using Emgu.CV.UI;

namespace TestProject

{

/// <summary>

/// 메인 폼

/// </summary>

public partial class MainForm : Form

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Field

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

#region Field

/// <summary>

/// 번호판 검출기

/// </summary>

private LicensePlateDetector licensePlateDetector;

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Constructor

////////////////////////////////////////////////////////////////////////////////////////// Public

#region 생성자 - MainForm()

/// <summary>

/// 생성자

/// </summary>

public MainForm()

{

InitializeComponent();

this.filePathButton.Click += filePathButton_Click;

this.licensePlateDetector = new LicensePlateDetector("");

ProcessImage(new Image<Bgr, byte>("LicensePlate.jpg"));

}

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

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

//////////////////////////////////////////////////////////////////////////////// Event

#region 파일 경로 버튼 클릭시 처리하기 - filePathButton_Click(sender, e)

/// <summary>

/// 파일 경로 버튼 클릭시 처리하기

/// </summary>

/// <param name="sender">이벤트 발생자</param>

/// <param name="e">이벤트 인자</param>

private void filePathButton_Click(object sender, EventArgs e)

{

DialogResult result = this.openFileDialog.ShowDialog();

if(result == DialogResult.OK)

{

Image<Bgr, Byte> image;

try

{

image = new Image<Bgr, byte>(this.openFileDialog.FileName);

}

catch

{

MessageBox.Show(string.Format("무효한 파일 : {0}", this.openFileDialog.FileName));

return;

}

ProcessImage(image);

}

#endregion

//////////////////////////////////////////////////////////////////////////////// Function

#region 레이블/이미지 추가하기 - AddLabelAndImage(startPoint, labelText, image)

/// <summary>

/// 레이블/이미지 추가하기

/// </summary>

/// <param name="startPoint">시작 위치</param>

/// <param name="labelText">레이블 텍스트</param>

/// <param name="image">이미지</param>

private void AddLabelAndImage(ref Point startPoint, string labelText, IImage image)

{

Label label = new Label();

this.resultPanel.Controls.Add(label);

label.Width = 200;

label.Height = 30;

label.Location = startPoint;

label.Text = labelText;

startPoint.Y += label.Height;

ImageBox imageBox = new ImageBox();

this.resultPanel.Controls.Add(imageBox);

imageBox.ClientSize = image.Size;

imageBox.Location = startPoint;

imageBox.Image = image;

startPoint.Y += imageBox.Height + 10;

}

#endregion

#region 이미지 처리하기 - ProcessImage(image)

/// <summary>

/// 이미지 처리하기

/// </summary>

/// <param name="image">이미지</param>

private void ProcessImage(Image<Bgr, byte> image)

{

Stopwatch stopwatch = Stopwatch.StartNew();

List<Image<Gray, Byte>> licensePlateImageList = new List<Image<Gray, byte>>();

List<Image<Gray, Byte>> filteredLicensePlateImageList = new List<Image<Gray, byte>>();

List<MCvBox2D> licenseRectangleList = new List<MCvBox2D>();

List<string> licensePlateArray = this.licensePlateDetector.DetectLicensePlate

(

image,

licensePlateImageList,

filteredLicensePlateImageList,

licenseRectangleList

);

stopwatch.Stop();

this.messageLabel.Text = string.Format("자동차 번호판 인식 시간 : {0} 밀리초", stopwatch.Elapsed.TotalMilliseconds);

this.resultPanel.Controls.Clear();

Point startPoint = new Point(10, 10);

for(int i = 0; i < licensePlateArray.Count; i++)

{

AddLabelAndImage

(

ref startPoint,

string.Format("자동차 번호 : {0}", licensePlateArray[i]),

licensePlateImageList[i].ConcateVertical(filteredLicensePlateImageList[i])

);

image.Draw(licenseRectangleList[i], new Bgr(Color.Red), 2);

}

this.imageBox.Image = image;

}

#endregion

}

TestProject.zip

[C#/WINFORM/EMGUCV] 도형 검출하기

■ 도형을 검출하는 방법을 보여준다. ▶ MainForm.cs


using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Drawing;
using System.Text;
using System.Windows.Forms;

using Emgu.CV;
using Emgu.CV.CvEnum;
using Emgu.CV.Structure;

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

        #region 생성자 - MainForm()

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

            this.filePathTextBox.TextChanged += filePathTextBox_TextChanged;
            this.filePathButton.Click        += filePathButton_Click;

            this.filePathTextBox.Text = "sample.png";
        }

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Constructor
        ////////////////////////////////////////////////////////////////////////////////////////// Private
        //////////////////////////////////////////////////////////////////////////////// Event

        #region 파일 경로 텍스트 박스 텍스트 변경시 처리하기 - filePathTextBox_TextChanged(sender, e)

        /// <summary>
        /// 파일 경로 텍스트 박스 텍스트 변경시 처리하기
        /// </summary>
        /// <param name="sender">이벤트 발생자</param>
        /// <param name="e">이벤트 인자</param>
        private void filePathTextBox_TextChanged(object sender, EventArgs e)
        {
            DetectShape();
        }

        #endregion
        #region 파일 경로 버튼 클릭시 처리하기 - filePathButton_Click(sender, e)

        /// <summary>
        /// 파일 경로 버튼 클릭시 처리하기
        /// </summary>
        /// <param name="sender">이벤트 발생자</param>
        /// <param name="e">이벤트 인자</param>
        private void filePathButton_Click(object sender, EventArgs e)
        {
            DialogResult result = this.openFileDialog.ShowDialog();

            if(result == DialogResult.OK || result == DialogResult.Yes)
            {
                this.filePathTextBox.Text = this.openFileDialog.FileName;
            }
        }

        #endregion

        //////////////////////////////////////////////////////////////////////////////// Function

        #region 도형 검출하기 - DetectShape()

        /// <summary>
        /// 도형 검출하기
        /// </summary>
        public void DetectShape()
        {
            if(this.filePathTextBox.Text != string.Empty)
            {
                StringBuilder stringBuilder = new StringBuilder("성능 : ");

                Image<Bgr, Byte> sourceImage = new Image<Bgr, byte>(this.filePathTextBox.Text).Resize(400, 400, INTER.CV_INTER_LINEAR, true);

                Image<Gray, Byte> grayscaleImage = sourceImage.Convert<Gray, Byte>().PyrDown().PyrUp();

                Stopwatch stopwatch = Stopwatch.StartNew();

                #region 원을 검출한다.

                double cannyThreshold             = 180.0;
                double circleAccumulatorThreshold = 120;

                CircleF[][] circleArray = grayscaleImage.HoughCircles
                (
                    new Gray(cannyThreshold),
                    new Gray(circleAccumulatorThreshold),
                    2.0,  // 원 중심 검출에 사용되는 누산기 해상도
                    20.0, // 최소 거리
                    5,    // 최소 반경
                    0     // 최대 반경
                );

                #endregion

                stopwatch.Stop();

                stringBuilder.Append(String.Format("원 - {0} 밀리초; ", stopwatch.ElapsedMilliseconds));

                stopwatch.Reset();

                stopwatch.Start();

                #region 선을 검출한다.

                double cannyThresholdLinking = 120.0;

                Image<Gray, Byte> cannyEdges = grayscaleImage.Canny(cannyThreshold, cannyThresholdLinking);

                LineSegment2D[][] lineArray = cannyEdges.HoughLinesBinary
                (
                    1,              // 거리 해상도 (픽셀 관련 단위)
                    Math.PI / 45.0, // 라디안으로 측정되는 각도 해상도
                    20,             // 한계점
                    30,             // 최소 선 너비
                    10              // 선간 간격
                );

                #endregion

                stopwatch.Stop();

                stringBuilder.Append(String.Format("선 - {0} 밀리초; ", stopwatch.ElapsedMilliseconds));

                stopwatch.Reset();

                stopwatch.Start();

                #region 삼각형과 사각형을 검출한다.

                List<Triangle2DF> triangleList = new List<Triangle2DF>();

                List<MCvBox2D> rectangleList = new List<MCvBox2D>();

                using(MemStorage storage = new MemStorage())
                {
                    for(Contour<Point> pointContour = cannyEdges.FindContours(CHAIN_APPROX_METHOD.CV_CHAIN_APPROX_SIMPLE, RETR_TYPE.CV_RETR_LIST, storage);
                        pointContour != null; pointContour = pointContour.HNext)
                    {
                        Contour<Point> currentContour = pointContour.ApproxPoly(pointContour.Perimeter * 0.05, storage);

                        if(currentContour.Area > 250)
                        {
                            if(currentContour.Total == 3) // 삼각형인 경우
                            {
                                Point[] pointArray = currentContour.ToArray();

                                triangleList.Add(new Triangle2DF(pointArray[0], pointArray[1], pointArray[2]));
                            }
                            else if(currentContour.Total == 4) // 사각형인 경우
                            {
                                #region 윤곽의 모든 각도가 [80, 100]도 이내인지 결정한다.

                                bool isRectangle = true;

                                Point[] pointArray = currentContour.ToArray();

                                LineSegment2D[] edgeArray = PointCollection.PolyLine(pointArray, true);

                                for(int i = 0; i < edgeArray.Length; i++)
                                {
                                    double angle = Math.Abs(edgeArray[(i + 1) % edgeArray.Length].GetExteriorAngleDegree(edgeArray[i]));

                                    if(angle < 80 || angle > 100)
                                    {
                                        isRectangle = false;

                                        break;
                                    }
                                }

                                #endregion

                                if(isRectangle)
                                {
                                    rectangleList.Add(currentContour.GetMinAreaRect());
                                }
                            }
                        }
                    }
                }

                #endregion

                stopwatch.Stop();

                stringBuilder.Append(String.Format("삼각형/사각형 - {0} 밀리초; ", stopwatch.ElapsedMilliseconds));

                Text = stringBuilder.ToString();

                this.originalImageBox.Image = sourceImage;

                #region 삼각형/사각형을 그린다.

                Image<Bgr, Byte> triangleRectangleImage = sourceImage.CopyBlank();

                foreach(Triangle2DF triangle in triangleList)
                {
                    triangleRectangleImage.Draw(triangle, new Bgr(Color.DarkBlue), 2);
                }

                foreach(MCvBox2D rectangle in rectangleList)
                {
                    triangleRectangleImage.Draw(rectangle, new Bgr(Color.DarkOrange), 2);
                }

                this.triangleRectangleImageBox.Image = triangleRectangleImage;

                #endregion
                #region 원을 그린다.

                Image<Bgr, Byte> circleImage = sourceImage.CopyBlank();

                foreach(CircleF circle in circleArray[0])
                {
                    circleImage.Draw(circle, new Bgr(Color.Brown), 2);
                }

                this.circleImageBox.Image = circleImage;

                #endregion
                #region 선을 그린다.

                Image<Bgr, Byte> lineImage = sourceImage.CopyBlank();

                foreach(LineSegment2D line in lineArray[0])
                {
                    lineImage.Draw(line, new Bgr(Color.Green), 2);
                }

                this.lineImageBox.Image = lineImage;

                #endregion
            }
        }

        #endregion
    }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

using System;

using System.Collections.Generic;

using System.Diagnostics;

using System.Drawing;

using System.Text;

using System.Windows.Forms;

using Emgu.CV;

using Emgu.CV.CvEnum;

using Emgu.CV.Structure;

namespace TestProject

{

/// <summary>

/// 메인 폼

/// </summary>

public partial class MainForm : Form

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Constructor

////////////////////////////////////////////////////////////////////////////////////////// Public

#region 생성자 - MainForm()

/// <summary>

/// 생성자

/// </summary>

public MainForm()

{

InitializeComponent();

this.filePathTextBox.TextChanged += filePathTextBox_TextChanged;

this.filePathButton.Click += filePathButton_Click;

this.filePathTextBox.Text = "sample.png";

}

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Constructor

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

//////////////////////////////////////////////////////////////////////////////// Event

#region 파일 경로 텍스트 박스 텍스트 변경시 처리하기 - filePathTextBox_TextChanged(sender, e)

/// <summary>

/// 파일 경로 텍스트 박스 텍스트 변경시 처리하기

/// </summary>

/// <param name="sender">이벤트 발생자</param>

/// <param name="e">이벤트 인자</param>

private void filePathTextBox_TextChanged(object sender, EventArgs e)

{

DetectShape();

}

#endregion

#region 파일 경로 버튼 클릭시 처리하기 - filePathButton_Click(sender, e)

/// <summary>

/// 파일 경로 버튼 클릭시 처리하기

/// </summary>

/// <param name="sender">이벤트 발생자</param>

/// <param name="e">이벤트 인자</param>

private void filePathButton_Click(object sender, EventArgs e)

{

DialogResult result = this.openFileDialog.ShowDialog();

if(result == DialogResult.OK || result == DialogResult.Yes)

{

this.filePathTextBox.Text = this.openFileDialog.FileName;

}

#endregion

//////////////////////////////////////////////////////////////////////////////// Function

#region 도형 검출하기 - DetectShape()

/// <summary>

/// 도형 검출하기

/// </summary>

public void DetectShape()

{

if(this.filePathTextBox.Text != string.Empty)

{

StringBuilder stringBuilder = new StringBuilder("성능 : ");

Image<Bgr, Byte> sourceImage = new Image<Bgr, byte>(this.filePathTextBox.Text).Resize(400, 400, INTER.CV_INTER_LINEAR, true);

Image<Gray, Byte> grayscaleImage = sourceImage.Convert<Gray, Byte>().PyrDown().PyrUp();

Stopwatch stopwatch = Stopwatch.StartNew();

#region 원을 검출한다.

double cannyThreshold = 180.0;

double circleAccumulatorThreshold = 120;

CircleF[][] circleArray = grayscaleImage.HoughCircles

(

new Gray(cannyThreshold),

new Gray(circleAccumulatorThreshold),

2.0, // 원 중심 검출에 사용되는 누산기 해상도

20.0, // 최소 거리

5, // 최소 반경

0 // 최대 반경

);

#endregion

stopwatch.Stop();

stringBuilder.Append(String.Format("원 - {0} 밀리초; ", stopwatch.ElapsedMilliseconds));

stopwatch.Reset();

stopwatch.Start();

#region 선을 검출한다.

double cannyThresholdLinking = 120.0;

Image<Gray, Byte> cannyEdges = grayscaleImage.Canny(cannyThreshold, cannyThresholdLinking);

LineSegment2D[][] lineArray = cannyEdges.HoughLinesBinary

(

1, // 거리 해상도 (픽셀 관련 단위)

Math.PI / 45.0, // 라디안으로 측정되는 각도 해상도

20, // 한계점

30, // 최소 선 너비

10 // 선간 간격

);

#endregion

stopwatch.Stop();

stringBuilder.Append(String.Format("선 - {0} 밀리초; ", stopwatch.ElapsedMilliseconds));

stopwatch.Reset();

stopwatch.Start();

#region 삼각형과 사각형을 검출한다.

List<Triangle2DF> triangleList = new List<Triangle2DF>();

List<MCvBox2D> rectangleList = new List<MCvBox2D>();

using(MemStorage storage = new MemStorage())

{

for(Contour<Point> pointContour = cannyEdges.FindContours(CHAIN_APPROX_METHOD.CV_CHAIN_APPROX_SIMPLE, RETR_TYPE.CV_RETR_LIST, storage);

pointContour != null; pointContour = pointContour.HNext)

{

Contour<Point> currentContour = pointContour.ApproxPoly(pointContour.Perimeter * 0.05, storage);

if(currentContour.Area > 250)

{

if(currentContour.Total == 3) // 삼각형인 경우

{

Point[] pointArray = currentContour.ToArray();

triangleList.Add(new Triangle2DF(pointArray[0], pointArray[1], pointArray[2]));

}

else if(currentContour.Total == 4) // 사각형인 경우

{

#region 윤곽의 모든 각도가 [80, 100]도 이내인지 결정한다.

bool isRectangle = true;

Point[] pointArray = currentContour.ToArray();

LineSegment2D[] edgeArray = PointCollection.PolyLine(pointArray, true);

for(int i = 0; i < edgeArray.Length; i++)

{

double angle = Math.Abs(edgeArray[(i + 1) % edgeArray.Length].GetExteriorAngleDegree(edgeArray[i]));

if(angle < 80 || angle > 100)

{

isRectangle = false;

break;

}

#endregion

if(isRectangle)

{

rectangleList.Add(currentContour.GetMinAreaRect());

}

#endregion

stopwatch.Stop();

stringBuilder.Append(String.Format("삼각형/사각형 - {0} 밀리초; ", stopwatch.ElapsedMilliseconds));

Text = stringBuilder.ToString();

this.originalImageBox.Image = sourceImage;

#region 삼각형/사각형을 그린다.

Image<Bgr, Byte> triangleRectangleImage = sourceImage.CopyBlank();

foreach(Triangle2DF triangle in triangleList)

{

triangleRectangleImage.Draw(triangle, new Bgr(Color.DarkBlue), 2);

}

foreach(MCvBox2D rectangle in rectangleList)

{

triangleRectangleImage.Draw(rectangle, new Bgr(Color.DarkOrange), 2);

}

this.triangleRectangleImageBox.Image = triangleRectangleImage;

#endregion

#region 원을 그린다.

Image<Bgr, Byte> circleImage = sourceImage.CopyBlank();

foreach(CircleF circle in circleArray[0])

{

circleImage.Draw(circle, new Bgr(Color.Brown), 2);

}

this.circleImageBox.Image = circleImage;

#endregion

#region 선을 그린다.

Image<Bgr, Byte> lineImage = sourceImage.CopyBlank();

foreach(LineSegment2D line in lineArray[0])

{

lineImage.Draw(line, new Bgr(Color.Green), 2);

}

this.lineImageBox.Image = lineImage;

#endregion

}

#endregion

}

TestProject.zip

[C#/WINFORM/EMGUCV] 얼굴 인식을 사용해 마우스 제어하기

■ 얼굴 인식을 사용해 마우스를 제어하는 방법을 보여준다. ▶ MainForm.cs


using System;
using System.Drawing;
using System.Runtime.InteropServices;
using System.Windows.Forms;

using Emgu.CV;
using Emgu.CV.Structure;

namespace TestProject
{
    /// <summary>
    /// 메인 폼
    /// </summary>
    public partial class MainForm : Form
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Import
        ////////////////////////////////////////////////////////////////////////////////////////// Static
        //////////////////////////////////////////////////////////////////////////////// Private

        #region 커서 위치 구하기 - GetCursorPos(point)

        /// <summary>
        /// 커서 위치 구하기
        /// </summary>
        /// <param name="point">위치</param>
        /// <returns>처리 결과</returns>
        [DllImport("user32.dll")]
        private static extern bool GetCursorPos(out Point point);

        #endregion
        #region 커서 위치 설정하기 - SetCursorPos(x, y)

        /// <summary>
        /// 커서 위치 설정하기
        /// </summary>
        /// <param name="x">X 좌표</param>
        /// <param name="y">Y 좌표</param>
        /// <returns>처리 결과</returns>
        [DllImport("user32.dll")]
        private static extern bool SetCursorPos(int x, int y);

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Field
        ////////////////////////////////////////////////////////////////////////////////////////// Private

        #region Field

        /// <summary>
        /// 캡처
        /// </summary>
        private Capture capture;

        /// <summary>
        /// 분류기
        /// </summary>
        private CascadeClassifier classifier;

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Constructor
        ////////////////////////////////////////////////////////////////////////////////////////// Public

        #region 생성자 - MainForm()

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

            this.classifier = new CascadeClassifier("haarcascade_frontalface_alt2.xml");

            if(this.capture == null)
            {
                try
                {
                    this.capture = new Capture();
                }
                catch(Exception exception)
                {
                    MessageBox.Show(exception.Message);

                    return;
                }
            }

            Application.Idle += Application_Idle;
            FormClosed       += Form_FormClosed;
        }

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Method
        ////////////////////////////////////////////////////////////////////////////////////////// Private

        #region 애플리케이션 휴지시 처리하기 - Application_Idle(sender, e)

        /// <summary>
        /// 애플리케이션 휴지시 처리하기
        /// </summary>
        /// <param name="sender">이벤트 발생자</param>
        /// <param name="e">이벤트 인자</param>
        private void Application_Idle(object sender, EventArgs e)
        {
            Image<Bgr, Byte> captureImage = this.capture.QueryFrame();

            Image<Gray, Byte> grayscaleImage = captureImage.Convert<Gray, Byte>();

            grayscaleImage._EqualizeHist();

            Rectangle imageRectangle = grayscaleImage.ROI;

            Rectangle mouseStableRectangle = new Rectangle
            (
                (int)(imageRectangle.Width  * 0.4),
                (int)(imageRectangle.Height * 0.4),
                (int)(imageRectangle.Width  * 0.2),
                (int)(imageRectangle.Height * 0.2)
            );

            captureImage.Draw(mouseStableRectangle, new Bgr(255, 0, 0), 1);

            Rectangle[] faceRectangleArray = this.classifier.DetectMultiScale
            (
                grayscaleImage,
                1.1,
                10,
                new Size(20, 20),
                Size.Empty
            );

            if(faceRectangleArray.Length > 0)
            {
                Rectangle maximumFaceRectangle = faceRectangleArray[0];

                for(int i = 1; i < faceRectangleArray.Length; i++)
                {
                    if(faceRectangleArray[i].Width * faceRectangleArray[i].Height > maximumFaceRectangle.Width * maximumFaceRectangle.Height)
                    {
                        maximumFaceRectangle = faceRectangleArray[i];
                    }
                }

                captureImage.Draw(maximumFaceRectangle, new Bgr(255, 255, 0.0), 1);

                Point maximumFaceRectangleCenter = new Point
                (
                    maximumFaceRectangle.X + maximumFaceRectangle.Width  / 2,
                    maximumFaceRectangle.Y + maximumFaceRectangle.Height / 2
                );

                Point imageRectangleCenter = new Point
                (
                    imageRectangle.X + imageRectangle.Width  / 2,
                    imageRectangle.Y + imageRectangle.Height / 2
                );

                captureImage.Draw
                (
                    new Cross2DF(maximumFaceRectangleCenter, maximumFaceRectangle.Width * 0.1f, maximumFaceRectangle.Height * 0.1f),
                    new Bgr(0, 255, 0),
                    1
                );

                if(!mouseStableRectangle.Contains(maximumFaceRectangleCenter))
                {
                    double horizontalFraction = (double)(maximumFaceRectangleCenter.X - imageRectangleCenter.X) / imageRectangle.Width;
                    double verticalFraction   = (double)(maximumFaceRectangleCenter.Y - imageRectangleCenter.Y) / imageRectangle.Height;

                    Rectangle primaryScreenRectangle = Screen.PrimaryScreen.Bounds;

                    int maximumMouseSpeed = primaryScreenRectangle.Width / 20;

                    Point mousePoint;

                    GetCursorPos(out mousePoint);

                    mousePoint.X = Math.Min(Math.Max(0, mousePoint.X + (int)((maximumMouseSpeed / 2) * horizontalFraction)), primaryScreenRectangle.Width );
                    mousePoint.Y = Math.Min(Math.Max(0, mousePoint.Y + (int)((maximumMouseSpeed / 2) * verticalFraction  )), primaryScreenRectangle.Height);

                    SetCursorPos(mousePoint.X, mousePoint.Y);
                }
            }

            this.imageBox.Image = captureImage;
        }

        #endregion
        #region 폼 닫는 경우 처리하기 - Form_FormClosed(sender, e)

        /// <summary>
        /// 폼 닫는 경우 처리하기
        /// </summary>
        /// <param name="sender">이벤트 발생자</param>
        /// <param name="e">이벤트 인자</param>
        private void Form_FormClosed(object sender, FormClosedEventArgs e)
        {
            if(this.capture != null)
            {
                this.capture.Dispose();
            }
        }

        #endregion
        #region 수평 반전 버튼 클릭시 처리하기 - flipHorizontalButton_Click(sender, e)

        /// <summary>
        /// 수평 반전 버튼 클릭시 처리하기
        /// </summary>
        /// <param name="sender">이벤트 발생자</param>
        /// <param name="e">이벤트 인자</param>
        private void flipHorizontalButton_Click(object sender, EventArgs e)
        {
            if(this.capture != null)
            {
                this.capture.FlipHorizontal = !this.capture.FlipHorizontal;
            }
        }

        #endregion
    }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

using System;

using System.Drawing;

using System.Runtime.InteropServices;

using System.Windows.Forms;

using Emgu.CV;

using Emgu.CV.Structure;

namespace TestProject

{

/// <summary>

/// 메인 폼

/// </summary>

public partial class MainForm : Form

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Import

////////////////////////////////////////////////////////////////////////////////////////// Static

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

#region 커서 위치 구하기 - GetCursorPos(point)

/// <summary>

/// 커서 위치 구하기

/// </summary>

/// <param name="point">위치</param>

/// <returns>처리 결과</returns>

[DllImport("user32.dll")]

private static extern bool GetCursorPos(out Point point);

#endregion

#region 커서 위치 설정하기 - SetCursorPos(x, y)

/// <summary>

/// 커서 위치 설정하기

/// </summary>

/// <param name="x">X 좌표</param>

/// <param name="y">Y 좌표</param>

/// <returns>처리 결과</returns>

[DllImport("user32.dll")]

private static extern bool SetCursorPos(int x, int y);

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Field

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

#region Field

/// <summary>

/// 캡처

/// </summary>

private Capture capture;

/// <summary>

/// 분류기

/// </summary>

private CascadeClassifier classifier;

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Constructor

////////////////////////////////////////////////////////////////////////////////////////// Public

#region 생성자 - MainForm()

/// <summary>

/// 생성자

/// </summary>

public MainForm()

{

InitializeComponent();

this.classifier = new CascadeClassifier("haarcascade_frontalface_alt2.xml");

if(this.capture == null)

{

try

{

this.capture = new Capture();

}

catch(Exception exception)

{

MessageBox.Show(exception.Message);

return;

}

Application.Idle += Application_Idle;

FormClosed += Form_FormClosed;

}

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

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

#region 애플리케이션 휴지시 처리하기 - Application_Idle(sender, e)

/// <summary>

/// 애플리케이션 휴지시 처리하기

/// </summary>

/// <param name="sender">이벤트 발생자</param>

/// <param name="e">이벤트 인자</param>

private void Application_Idle(object sender, EventArgs e)

{

Image<Bgr, Byte> captureImage = this.capture.QueryFrame();

Image<Gray, Byte> grayscaleImage = captureImage.Convert<Gray, Byte>();

grayscaleImage._EqualizeHist();

Rectangle imageRectangle = grayscaleImage.ROI;

Rectangle mouseStableRectangle = new Rectangle

(

(int)(imageRectangle.Width * 0.4),

(int)(imageRectangle.Height * 0.4),

(int)(imageRectangle.Width * 0.2),

(int)(imageRectangle.Height * 0.2)

);

captureImage.Draw(mouseStableRectangle, new Bgr(255, 0, 0), 1);

Rectangle[] faceRectangleArray = this.classifier.DetectMultiScale

(

grayscaleImage,

1.1,

10,

new Size(20, 20),

Size.Empty

);

if(faceRectangleArray.Length > 0)

{

Rectangle maximumFaceRectangle = faceRectangleArray[0];

for(int i = 1; i < faceRectangleArray.Length; i++)

{

if(faceRectangleArray[i].Width * faceRectangleArray[i].Height > maximumFaceRectangle.Width * maximumFaceRectangle.Height)

{

maximumFaceRectangle = faceRectangleArray[i];

}

captureImage.Draw(maximumFaceRectangle, new Bgr(255, 255, 0.0), 1);

Point maximumFaceRectangleCenter = new Point

(

maximumFaceRectangle.X + maximumFaceRectangle.Width / 2,

maximumFaceRectangle.Y + maximumFaceRectangle.Height / 2

);

Point imageRectangleCenter = new Point

(

imageRectangle.X + imageRectangle.Width / 2,

imageRectangle.Y + imageRectangle.Height / 2

);

captureImage.Draw

(

new Cross2DF(maximumFaceRectangleCenter, maximumFaceRectangle.Width * 0.1f, maximumFaceRectangle.Height * 0.1f),

new Bgr(0, 255, 0),

);

if(!mouseStableRectangle.Contains(maximumFaceRectangleCenter))

{

double horizontalFraction = (double)(maximumFaceRectangleCenter.X - imageRectangleCenter.X) / imageRectangle.Width;

double verticalFraction = (double)(maximumFaceRectangleCenter.Y - imageRectangleCenter.Y) / imageRectangle.Height;

Rectangle primaryScreenRectangle = Screen.PrimaryScreen.Bounds;

int maximumMouseSpeed = primaryScreenRectangle.Width / 20;

Point mousePoint;

GetCursorPos(out mousePoint);

mousePoint.X = Math.Min(Math.Max(0, mousePoint.X + (int)((maximumMouseSpeed / 2) * horizontalFraction)), primaryScreenRectangle.Width );

mousePoint.Y = Math.Min(Math.Max(0, mousePoint.Y + (int)((maximumMouseSpeed / 2) * verticalFraction )), primaryScreenRectangle.Height);

SetCursorPos(mousePoint.X, mousePoint.Y);

}

this.imageBox.Image = captureImage;

}

#endregion

#region 폼 닫는 경우 처리하기 - Form_FormClosed(sender, e)

/// <summary>

/// 폼 닫는 경우 처리하기

/// </summary>

/// <param name="sender">이벤트 발생자</param>

/// <param name="e">이벤트 인자</param>

private void Form_FormClosed(object sender, FormClosedEventArgs e)

{

if(this.capture != null)

{

this.capture.Dispose();

}

#endregion

#region 수평 반전 버튼 클릭시 처리하기 - flipHorizontalButton_Click(sender, e)

/// <summary>

/// 수평 반전 버튼 클릭시 처리하기

/// </summary>

/// <param name="sender">이벤트 발생자</param>

/// <param name="e">이벤트 인자</param>

private void flipHorizontalButton_Click(object sender, EventArgs e)

{

if(this.capture != null)

{

this.capture.FlipHorizontal = !this.capture.FlipHorizontal;

}

#endregion

}

TestProject.zip

[C#/WINFORM/EMGUCV] 동작 검출하기

■ 동작을 검출하는 방법을 보여준다. ▶ MainForm.cs


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

using Emgu.CV;
using Emgu.CV.CvEnum;
using Emgu.CV.Structure;
using Emgu.CV.VideoSurveillance;

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

        #region Field

        /// <summary>
        /// 캡처
        /// </summary>
        private Capture capture;

        /// <summary>
        /// 동작 히스토리
        /// </summary>
        private MotionHistory motionHistory;

        /// <summary>
        /// BGFG 검출기
        /// </summary>
        private IBGFGDetector<Bgr> bgfgDetector;

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Constructor
        ////////////////////////////////////////////////////////////////////////////////////////// Public

        #region 생성자 - MainForm()

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

            if(this.capture == null)
            {
                try
                {
                    this.capture = new Capture();
                }
                catch(Exception exception)
                {
                    MessageBox.Show(exception.Message);
                }
            }

            if(this.capture != null)
            {
                this.motionHistory = new MotionHistory
                (
                    1.0,  // 동작 히스토리 지속 시간 (초 단위)
                    0.05, // cvCalcMotionGradient용 maxDelta (초 단위)
                    0.5   // cvCalcMotionGradient용 minDelta (초 단위)
                );

                this.capture.ImageGrabbed += capture_ImageGrabbed;

                this.capture.Start();
            }
        }

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Method
        ////////////////////////////////////////////////////////////////////////////////////////// Private
        //////////////////////////////////////////////////////////////////////////////// Event

        #region 폼 닫는 경우 처리하기 - Form_FormClosed(sender, e)

        /// <summary>
        /// 폼 닫는 경우 처리하기
        /// </summary>
        /// <param name="sender">이벤트 발생자</param>
        /// <param name="e">이벤트 인자</param>
        private void Form_FormClosed(object sender, FormClosedEventArgs e)
        {
            this.capture.Stop();
        }

        #endregion
        #region 캡처 이미지 GRAB 처리하기 - capture_ImageGrabbed(sender, e)

        /// <summary>
        /// 캡처 이미지 GRAB 처리하기
        /// </summary>
        /// <param name="sender">이벤트 발생자</param>
        /// <param name="e">이벤트 인자</param>
        private void capture_ImageGrabbed(object sender, EventArgs e)
        {
            using(Image<Bgr, Byte> captureImage = this.capture.RetrieveBgrFrame())
            {
                using(MemStorage storage = new MemStorage())
                {
                    if(this.bgfgDetector == null)
                    {
                        this.bgfgDetector = new FGDetector<Bgr>(FORGROUND_DETECTOR_TYPE.FGD);
                    }

                    this.bgfgDetector.Update(captureImage);

                    this.captureImageBox.Image = captureImage;

                    this.motionHistory.Update(this.bgfgDetector.ForegroundMask);

                    this.forgroundMaskImageBox.Image = this.bgfgDetector.ForegroundMask;

                    #region 동작 마스크 복사본을 구하고 색상을 보정한다.

                    double[] minimumValueArray;
                    double[] maximumValueArray;
                    Point[]  minimumPointArray;
                    Point[]  maximumPointArray;

                    this.motionHistory.Mask.MinMax(out minimumValueArray, out maximumValueArray, out minimumPointArray, out maximumPointArray);

                    Image<Gray, Byte> motionMaskImage = this.motionHistory.Mask.Mul(255.0 / maximumValueArray[0]);

                    #endregion
                    #region 동작 이미지를 설정한다.

                    Image<Bgr, Byte> motionImage = new Image<Bgr, byte>(motionMaskImage.Size);

                    motionImage[0] = motionMaskImage;

                    #endregion

                    // 동작 영역을 정의하는 한계점은 미세 동작 검출 값을 줄인다.
                    double minimumArea = 100;

                    storage.Clear();

                    Seq<MCvConnectedComp> motionComponentSequence = this.motionHistory.GetMotionComponents(storage);

                    foreach(MCvConnectedComp motionComponent in motionComponentSequence)
                    {
                        if(motionComponent.area < minimumArea)
                        {
                            continue;
                        }

                        // 특정 영역의 각도와 동작 픽셀 카운트를 찾는다.
                        double angle;
                        double motionPixelCount;

                        this.motionHistory.MotionInfo(motionComponent.rect, out angle, out motionPixelCount);

                        if(motionPixelCount < motionComponent.area * 0.05)
                        {
                            continue;
                        }

                        DrawMotion(motionImage, motionComponent.rect, angle, new Bgr(Color.Red));
                    }

                    // 전체 동작 각도를 찾고 그린다.
                    double overallAngle;
                    double overallMotionPixelCount;

                    this.motionHistory.MotionInfo(motionMaskImage.ROI, out overallAngle, out overallMotionPixelCount);

                    DrawMotion(motionImage, motionMaskImage.ROI, overallAngle, new Bgr(Color.Green));

                    UpdateMessage
                    (
                        string.Format
                        (
                            "전체 탐지 동작 : {0}; 동작 픽셀 카운트 : {1}",
                            motionComponentSequence.Total,
                            overallMotionPixelCount
                        )
                    );

                    this.motionImageBox.Image = motionImage;
                }
            }
        }

        #endregion

        //////////////////////////////////////////////////////////////////////////////// Function

        #region 메시지 갱신하기 - UpdateMessage(message)

        /// <summary>
        /// 메시지 갱신하기
        /// </summary>
        /// <param name="message">메시지</param>
        private void UpdateMessage(string message)
        {
            if(InvokeRequired && !IsDisposed)
            {
                Invoke((Action<string>)UpdateMessage, message);
            }
            else
            {
                this.message.Text = message;
            }
        }

        #endregion
        #region 동작 그리기 - DrawMotion(image, motionRectangle, angle, color)

        /// <summary>
        /// 동작 그리기
        /// </summary>
        /// <param name="image">이미지</param>
        /// <param name="motionRectangle">동작 사각형</param>
        /// <param name="angle">각도</param>
        /// <param name="color">색상</param>
        private static void DrawMotion(Image<Bgr, Byte> image, Rectangle motionRectangle, double angle, Bgr color)
        {
            float circleRadius = (motionRectangle.Width + motionRectangle.Height) >> 2;

            Point centerPoint = new Point
            (
                motionRectangle.X + motionRectangle.Width  >> 1,
                motionRectangle.Y + motionRectangle.Height >> 1
            );

            CircleF circle = new CircleF(centerPoint, circleRadius);

            int directionX = (int)(Math.Cos(angle * (Math.PI / 180.0)) * circleRadius);
            int directionY = (int)(Math.Sin(angle * (Math.PI / 180.0)) * circleRadius);

            Point pointOnCircle = new Point(centerPoint.X + directionX, centerPoint.Y - directionY);

            LineSegment2D line = new LineSegment2D(centerPoint, pointOnCircle);

            image.Draw(circle, color, 1);

            image.Draw(line, color, 2);
        }

        #endregion
    }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

using System;

using System.Drawing;

using System.Windows.Forms;

using Emgu.CV;

using Emgu.CV.CvEnum;

using Emgu.CV.Structure;

using Emgu.CV.VideoSurveillance;

namespace TestProject

{

/// <summary>

/// 메인 폼

/// </summary>

public partial class MainForm : Form

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Field

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

#region Field

/// <summary>

/// 캡처

/// </summary>

private Capture capture;

/// <summary>

/// 동작 히스토리

/// </summary>

private MotionHistory motionHistory;

/// <summary>

/// BGFG 검출기

/// </summary>

private IBGFGDetector<Bgr> bgfgDetector;

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Constructor

////////////////////////////////////////////////////////////////////////////////////////// Public

#region 생성자 - MainForm()

/// <summary>

/// 생성자

/// </summary>

public MainForm()

{

InitializeComponent();

if(this.capture == null)

{

try

{

this.capture = new Capture();

}

catch(Exception exception)

{

MessageBox.Show(exception.Message);

}

if(this.capture != null)

{

this.motionHistory = new MotionHistory

(

1.0, // 동작 히스토리 지속 시간 (초 단위)

0.05, // cvCalcMotionGradient용 maxDelta (초 단위)

0.5 // cvCalcMotionGradient용 minDelta (초 단위)

);

this.capture.ImageGrabbed += capture_ImageGrabbed;

this.capture.Start();

}

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

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

//////////////////////////////////////////////////////////////////////////////// Event

#region 폼 닫는 경우 처리하기 - Form_FormClosed(sender, e)

/// <summary>

/// 폼 닫는 경우 처리하기

/// </summary>

/// <param name="sender">이벤트 발생자</param>

/// <param name="e">이벤트 인자</param>

private void Form_FormClosed(object sender, FormClosedEventArgs e)

{

this.capture.Stop();

}

#endregion

#region 캡처 이미지 GRAB 처리하기 - capture_ImageGrabbed(sender, e)

/// <summary>

/// 캡처 이미지 GRAB 처리하기

/// </summary>

/// <param name="sender">이벤트 발생자</param>

/// <param name="e">이벤트 인자</param>

private void capture_ImageGrabbed(object sender, EventArgs e)

{

using(Image<Bgr, Byte> captureImage = this.capture.RetrieveBgrFrame())

{

using(MemStorage storage = new MemStorage())

{

if(this.bgfgDetector == null)

{

this.bgfgDetector = new FGDetector<Bgr>(FORGROUND_DETECTOR_TYPE.FGD);

}

this.bgfgDetector.Update(captureImage);

this.captureImageBox.Image = captureImage;

this.motionHistory.Update(this.bgfgDetector.ForegroundMask);

this.forgroundMaskImageBox.Image = this.bgfgDetector.ForegroundMask;

#region 동작 마스크 복사본을 구하고 색상을 보정한다.

double[] minimumValueArray;

double[] maximumValueArray;

Point[] minimumPointArray;

Point[] maximumPointArray;

this.motionHistory.Mask.MinMax(out minimumValueArray, out maximumValueArray, out minimumPointArray, out maximumPointArray);

Image<Gray, Byte> motionMaskImage = this.motionHistory.Mask.Mul(255.0 / maximumValueArray[0]);

#endregion

#region 동작 이미지를 설정한다.

Image<Bgr, Byte> motionImage = new Image<Bgr, byte>(motionMaskImage.Size);

motionImage[0] = motionMaskImage;

#endregion

// 동작 영역을 정의하는 한계점은 미세 동작 검출 값을 줄인다.

double minimumArea = 100;

storage.Clear();

Seq<MCvConnectedComp> motionComponentSequence = this.motionHistory.GetMotionComponents(storage);

foreach(MCvConnectedComp motionComponent in motionComponentSequence)

{

if(motionComponent.area < minimumArea)

{

continue;

}

// 특정 영역의 각도와 동작 픽셀 카운트를 찾는다.

double angle;

double motionPixelCount;

this.motionHistory.MotionInfo(motionComponent.rect, out angle, out motionPixelCount);

if(motionPixelCount < motionComponent.area * 0.05)

{

continue;

}

DrawMotion(motionImage, motionComponent.rect, angle, new Bgr(Color.Red));

}

// 전체 동작 각도를 찾고 그린다.

double overallAngle;

double overallMotionPixelCount;

this.motionHistory.MotionInfo(motionMaskImage.ROI, out overallAngle, out overallMotionPixelCount);

DrawMotion(motionImage, motionMaskImage.ROI, overallAngle, new Bgr(Color.Green));

UpdateMessage

(

string.Format

(

"전체 탐지 동작 : {0}; 동작 픽셀 카운트 : {1}",

motionComponentSequence.Total,

overallMotionPixelCount

)

);

this.motionImageBox.Image = motionImage;

}

#endregion

//////////////////////////////////////////////////////////////////////////////// Function

#region 메시지 갱신하기 - UpdateMessage(message)

/// <summary>

/// 메시지 갱신하기

/// </summary>

/// <param name="message">메시지</param>

private void UpdateMessage(string message)

{

if(InvokeRequired && !IsDisposed)

{

Invoke((Action<string>)UpdateMessage, message);

}

else

{

this.message.Text = message;

}

#endregion

#region 동작 그리기 - DrawMotion(image, motionRectangle, angle, color)

/// <summary>

/// 동작 그리기

/// </summary>

/// <param name="image">이미지</param>

/// <param name="motionRectangle">동작 사각형</param>

/// <param name="angle">각도</param>

/// <param name="color">색상</param>

private static void DrawMotion(Image<Bgr, Byte> image, Rectangle motionRectangle, double angle, Bgr color)

{

float circleRadius = (motionRectangle.Width + motionRectangle.Height) >> 2;

Point centerPoint = new Point

(

motionRectangle.X + motionRectangle.Width >> 1,

motionRectangle.Y + motionRectangle.Height >> 1

);

CircleF circle = new CircleF(centerPoint, circleRadius);

int directionX = (int)(Math.Cos(angle * (Math.PI / 180.0)) * circleRadius);

int directionY = (int)(Math.Sin(angle * (Math.PI / 180.0)) * circleRadius);

Point pointOnCircle = new Point(centerPoint.X + directionX, centerPoint.Y - directionY);

LineSegment2D line = new LineSegment2D(centerPoint, pointOnCircle);

image.Draw(circle, color, 1);

image.Draw(line, color, 2);

}

#endregion

}

TestProject.zip

[C#/WINFORM/EMGUCV] Hello World 출력하기

■ Hello World를 출력하는 방법을 보여준다. ▶ Program.cs


using System;
using System.Drawing;

using Emgu.CV;
using Emgu.CV.CvEnum;
using Emgu.CV.Structure;

namespace HelloWorld
{
    /// <summary>
    /// 프로그램
    /// </summary>
    class Program
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Method
        ////////////////////////////////////////////////////////////////////////////////////////// Static
        //////////////////////////////////////////////////////////////////////////////// Private

        #region 프로그램 시작하기 - Main()

        /// <summary>
        /// 프로그램 시작하기
        /// </summary>
        private static void Main()
        {
            string windowName = "Hello, World!";

            CvInvoke.cvNamedWindow(windowName);

            Image<Bgr, Byte> image = new Image<Bgr, byte>(600, 450, new Bgr(255, 0, 0));

            MCvFont font = new MCvFont(FONT.CV_FONT_HERSHEY_COMPLEX, 1.0, 1.0);

            image.Draw("Hello, world", ref font, new Point(10, 80), new Bgr(0, 255, 0));

            CvInvoke.cvShowImage(windowName, image);

            CvInvoke.cvWaitKey(0);

            CvInvoke.cvDestroyWindow(windowName);
        }

        #endregion
    }
}

using System;

using System.Drawing;

using Emgu.CV;

using Emgu.CV.CvEnum;

using Emgu.CV.Structure;

namespace HelloWorld

{

/// <summary>

/// 프로그램

/// </summary>

class Program

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

////////////////////////////////////////////////////////////////////////////////////////// Static

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

#region 프로그램 시작하기 - Main()

/// <summary>

/// 프로그램 시작하기

/// </summary>

private static void Main()

{

string windowName = "Hello, World!";

CvInvoke.cvNamedWindow(windowName);

Image<Bgr, Byte> image = new Image<Bgr, byte>(600, 450, new Bgr(255, 0, 0));

MCvFont font = new MCvFont(FONT.CV_FONT_HERSHEY_COMPLEX, 1.0, 1.0);

image.Draw("Hello, world", ref font, new Point(10, 80), new Bgr(0, 255, 0));

CvInvoke.cvShowImage(windowName, image);

CvInvoke.cvWaitKey(0);

CvInvoke.cvDestroyWindow(windowName);

}

#endregion

}

TestProject.zip

[C#/WINFORM/EMGUCV] HAAR 얼굴 검출하기

■ HAAR를 사용해 얼굴을 검출하는 방법을 보여준다. ▶ FaceDetectionHelper.cs


using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Drawing;

using Emgu.CV;
#if !IOS
using Emgu.CV.GPU;
#endif
using Emgu.CV.Structure;

namespace TestProject
{
    /// <summary>
    /// 얼굴 검출 헬퍼
    /// </summary>
    public static class FaceDetectionHelper
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Method
        ////////////////////////////////////////////////////////////////////////////////////////// Static
        //////////////////////////////////////////////////////////////////////////////// Private

        #region 검출하기 - Detect(image, faceClassifierFilePath, eyeClassifierFilePath, faceRectangleList, eyeRectangleList, detectionTime)

        /// <summary>
        /// 검출하기
        /// </summary>
        /// <param name="image">이미지</param>
        /// <param name="faceClassifierFilePath">얼굴 분류기 파일 경로</param>
        /// <param name="eyeClassifierFilePath">눈 분류기 파일 경로</param>
        /// <param name="faceRectangleList">얼굴 사각형 리스트</param>
        /// <param name="eyeRectangleList">눈 사각형 리스트</param>
        /// <param name="detectionTime">검출 시간</param>
        public static void Detect(Image<Bgr, Byte> image, string faceClassifierFilePath, string eyeClassifierFilePath,
            List<Rectangle> faceRectangleList, List<Rectangle> eyeRectangleList, out long detectionTime)
        {
            Stopwatch stopWatch;

#if !IOS
            if(GpuInvoke.HasCuda)
            {
                using(GpuCascadeClassifier faceGpuCascadeClassifier = new GpuCascadeClassifier(faceClassifierFilePath))
                {
                    using(GpuCascadeClassifier eyeGpuCascadeClassifier = new GpuCascadeClassifier(eyeClassifierFilePath))
                    {
                        stopWatch = Stopwatch.StartNew();

                        using(GpuImage<Bgr, Byte> gpuImage = new GpuImage<Bgr, byte>(image))
                        {
                            using(GpuImage<Gray, Byte> gpuGray = gpuImage.Convert<Gray, Byte>())
                            {
                                Rectangle[] faceRectangleArray = faceGpuCascadeClassifier.DetectMultiScale(gpuGray, 1.1, 10, Size.Empty);

                                faceRectangleList.AddRange(faceRectangleArray);

                                foreach(Rectangle faceRectangle in faceRectangleArray)
                                {
                                    using(GpuImage<Gray, Byte> faceGpuImage = gpuGray.GetSubRect(faceRectangle))
                                    {
                                        using(GpuImage<Gray, Byte> cloneGpuImage = faceGpuImage.Clone())
                                        {
                                            Rectangle[] eyeRectangleArray = eyeGpuCascadeClassifier.DetectMultiScale(cloneGpuImage, 1.1, 10, Size.Empty);

                                            foreach(Rectangle eyeRectangle in eyeRectangleArray)
                                            {
                                                Rectangle temporaryEyeRectangle = eyeRectangle;

                                                temporaryEyeRectangle.Offset(faceRectangle.X, faceRectangle.Y);

                                                eyeRectangleList.Add(temporaryEyeRectangle);
                                            }
                                        }
                                    }
                                }
                            }
                        }

                        stopWatch.Stop();
                    }
                }
            }
            else
#endif
            {
                using(CascadeClassifier faceCascadeClassifier = new CascadeClassifier(faceClassifierFilePath))
                {
                    using(CascadeClassifier eyeCascadeClassifier = new CascadeClassifier(eyeClassifierFilePath))
                    {
                        stopWatch = Stopwatch.StartNew();

                        using(Image<Gray, Byte> grayImage = image.Convert<Gray, Byte>())
                        {
                            grayImage._EqualizeHist();

                            Rectangle[] faceRectangleArray = faceCascadeClassifier.DetectMultiScale
                            (
                                grayImage,
                                1.1,
                                10,
                                new Size(20, 20),
                                Size.Empty
                            );

                            faceRectangleList.AddRange(faceRectangleArray);

                            foreach(Rectangle faceRectangle in faceRectangleArray)
                            {
                                grayImage.ROI = faceRectangle;

                                Rectangle[] eyeRectangleArray = eyeCascadeClassifier.DetectMultiScale
                                (
                                    grayImage,
                                    1.1,
                                    10,
                                    new Size(20, 20),
                                    Size.Empty
                                );

                                grayImage.ROI = Rectangle.Empty;

                                foreach(Rectangle eyeRectangle in eyeRectangleArray)
                                {
                                    Rectangle temporaryEyeRectangle = eyeRectangle;

                                    temporaryEyeRectangle.Offset(faceRectangle.X, faceRectangle.Y);

                                    eyeRectangleList.Add(temporaryEyeRectangle);
                                }
                            }
                        }

                        stopWatch.Stop();
                    }
                }
            }

            detectionTime = stopWatch.ElapsedMilliseconds;
        }

        #endregion
    }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

using System;

using System.Collections.Generic;

using System.Diagnostics;

using System.Drawing;

using Emgu.CV;

#if !IOS

using Emgu.CV.GPU;

#endif

using Emgu.CV.Structure;

namespace TestProject

{

/// <summary>

/// 얼굴 검출 헬퍼

/// </summary>

public static class FaceDetectionHelper

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

////////////////////////////////////////////////////////////////////////////////////////// Static

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

#region 검출하기 - Detect(image, faceClassifierFilePath, eyeClassifierFilePath, faceRectangleList, eyeRectangleList, detectionTime)

/// <summary>

/// 검출하기

/// </summary>

/// <param name="image">이미지</param>

/// <param name="faceClassifierFilePath">얼굴 분류기 파일 경로</param>

/// <param name="eyeClassifierFilePath">눈 분류기 파일 경로</param>

/// <param name="faceRectangleList">얼굴 사각형 리스트</param>

/// <param name="eyeRectangleList">눈 사각형 리스트</param>

/// <param name="detectionTime">검출 시간</param>

public static void Detect(Image<Bgr, Byte> image, string faceClassifierFilePath, string eyeClassifierFilePath,

List<Rectangle> faceRectangleList, List<Rectangle> eyeRectangleList, out long detectionTime)

{

Stopwatch stopWatch;

#if !IOS

if(GpuInvoke.HasCuda)

{

using(GpuCascadeClassifier faceGpuCascadeClassifier = new GpuCascadeClassifier(faceClassifierFilePath))

{

using(GpuCascadeClassifier eyeGpuCascadeClassifier = new GpuCascadeClassifier(eyeClassifierFilePath))

{

stopWatch = Stopwatch.StartNew();

using(GpuImage<Bgr, Byte> gpuImage = new GpuImage<Bgr, byte>(image))

{

using(GpuImage<Gray, Byte> gpuGray = gpuImage.Convert<Gray, Byte>())

{

Rectangle[] faceRectangleArray = faceGpuCascadeClassifier.DetectMultiScale(gpuGray, 1.1, 10, Size.Empty);

faceRectangleList.AddRange(faceRectangleArray);

foreach(Rectangle faceRectangle in faceRectangleArray)

{

using(GpuImage<Gray, Byte> faceGpuImage = gpuGray.GetSubRect(faceRectangle))

{

using(GpuImage<Gray, Byte> cloneGpuImage = faceGpuImage.Clone())

{

Rectangle[] eyeRectangleArray = eyeGpuCascadeClassifier.DetectMultiScale(cloneGpuImage, 1.1, 10, Size.Empty);

foreach(Rectangle eyeRectangle in eyeRectangleArray)

{

Rectangle temporaryEyeRectangle = eyeRectangle;

temporaryEyeRectangle.Offset(faceRectangle.X, faceRectangle.Y);

eyeRectangleList.Add(temporaryEyeRectangle);

}

stopWatch.Stop();

}

else

#endif

{

using(CascadeClassifier faceCascadeClassifier = new CascadeClassifier(faceClassifierFilePath))

{

using(CascadeClassifier eyeCascadeClassifier = new CascadeClassifier(eyeClassifierFilePath))

{

stopWatch = Stopwatch.StartNew();

using(Image<Gray, Byte> grayImage = image.Convert<Gray, Byte>())

{

grayImage._EqualizeHist();

Rectangle[] faceRectangleArray = faceCascadeClassifier.DetectMultiScale

(

grayImage,

1.1,

10,

new Size(20, 20),

Size.Empty

);

faceRectangleList.AddRange(faceRectangleArray);

foreach(Rectangle faceRectangle in faceRectangleArray)

{

grayImage.ROI = faceRectangle;

Rectangle[] eyeRectangleArray = eyeCascadeClassifier.DetectMultiScale

(

grayImage,

1.1,

10,

new Size(20, 20),

Size.Empty

);

grayImage.ROI = Rectangle.Empty;

foreach(Rectangle eyeRectangle in eyeRectangleArray)

{

Rectangle temporaryEyeRectangle = eyeRectangle;

temporaryEyeRectangle.Offset(faceRectangle.X, faceRectangle.Y);

eyeRectangleList.Add(temporaryEyeRectangle);

}

stopWatch.Stop();

}

detectionTime = stopWatch.ElapsedMilliseconds;

}

#endregion

}

▶ Program.cs


using System;
using System.Collections.Generic;
using System.Drawing;
using System.Windows.Forms;

using Emgu.CV;
using Emgu.CV.Structure;
using Emgu.CV.UI;
using Emgu.CV.GPU;

namespace TestProject
{
    /// <summary>
    /// 프로그램
    /// </summary>
    static class Program
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Method
        ////////////////////////////////////////////////////////////////////////////////////////// Static
        //////////////////////////////////////////////////////////////////////////////// Private

        #region 프로그램 시작하기 - Main()

        /// <summary>
        /// 프로그램 시작하기
        /// </summary>
        [STAThread]
        private static void Main()
        {
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);

            Image<Bgr, Byte> image = new Image<Bgr, byte>("sample.jpg");

            long detectionTime;

            List<Rectangle> faceRectangleList = new List<Rectangle>();
            List<Rectangle> eyeRectangleList  = new List<Rectangle>();

            FaceDetectionHelper.Detect
            (
                image,
                "haarcascade_frontalface_default.xml",
                "haarcascade_eye.xml",
                faceRectangleList,
                eyeRectangleList,
                out detectionTime
            );

            foreach(Rectangle faceRectangle in faceRectangleList)
            {
                image.Draw(faceRectangle, new Bgr(Color.Red), 1);
            }

            foreach(Rectangle eyeRectangle in eyeRectangleList)
            {
                image.Draw(eyeRectangle, new Bgr(Color.Blue), 2);
            }

            ImageViewer.Show
            (
                image,
                string.Format
                (
                    "{0}를 사용해 얼굴/눈 검출 완료 : {1} 밀리초",
                    GpuInvoke.HasCuda ? "GPU" : "CPU",
                    detectionTime
                )
            );
        }

        #endregion
    }
}

using System;

using System.Collections.Generic;

using System.Drawing;

using System.Windows.Forms;

using Emgu.CV;

using Emgu.CV.Structure;

using Emgu.CV.UI;

using Emgu.CV.GPU;

namespace TestProject

{

/// <summary>

/// 프로그램

/// </summary>

static class Program

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

////////////////////////////////////////////////////////////////////////////////////////// Static

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

#region 프로그램 시작하기 - Main()

/// <summary>

/// 프로그램 시작하기

/// </summary>

[STAThread]

private static void Main()

{

Application.EnableVisualStyles();

Application.SetCompatibleTextRenderingDefault(false);

Image<Bgr, Byte> image = new Image<Bgr, byte>("sample.jpg");

long detectionTime;

List<Rectangle> faceRectangleList = new List<Rectangle>();

List<Rectangle> eyeRectangleList = new List<Rectangle>();

FaceDetectionHelper.Detect

(

image,

"haarcascade_frontalface_default.xml",

"haarcascade_eye.xml",

faceRectangleList,

eyeRectangleList,

out detectionTime

);

foreach(Rectangle faceRectangle in faceRectangleList)

{

image.Draw(faceRectangle, new Bgr(Color.Red), 1);

}

foreach(Rectangle eyeRectangle in eyeRectangleList)

{

image.Draw(eyeRectangle, new Bgr(Color.Blue), 2);

}

ImageViewer.Show

(

image,

string.Format

(

"{0}를 사용해 얼굴/눈 검출 완료 : {1} 밀리초",

GpuInvoke.HasCuda ? "GPU" : "CPU",

detectionTime

)

);

}

#endregion

}

TestProject.zip

[C#/WINFORM/EMGUCV] 카메라 영상 캡처하기

■ 카메라 영상을 캡처하는 방법을 보여준다. ▶ MainForm.cs


using System;
using System.Windows.Forms;

using Emgu.CV;
using Emgu.CV.Structure;

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

        #region Field

        /// <summary>
        /// 캡처
        /// </summary>
        private Capture capture = null;

        /// <summary>
        /// 캡처 여부
        /// </summary>
        private bool isCapturing;

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Constructor
        ////////////////////////////////////////////////////////////////////////////////////////// Public

        #region 생성자 - MainForm()

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

            try
            {
                this.capture = new Capture();

                this.capture.ImageGrabbed += capture_ImageGrabbed;
            }
            catch(Exception exception)
            {
                MessageBox.Show(exception.Message);
            }

            FormClosed                      += Form_FormClosed;
            this.captureButton.Click        += captureButtonClick;
            this.flipHorizontalButton.Click += flipHorizontalButton_Click;
            this.flipVerticalButton.Click   += flipVerticalButton_Click;
        }

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Method
        ////////////////////////////////////////////////////////////////////////////////////////// Private
        //////////////////////////////////////////////////////////////////////////////// Event

        #region 폼 닫는 경우 처리하기 - Form_FormClosed(sender, e)

        /// <summary>
        /// 폼 닫는 경우 처리하기
        /// </summary>
        /// <param name="sender">이벤트 발생자</param>
        /// <param name="e">이벤트 인자</param>
        private void Form_FormClosed(object sender, FormClosedEventArgs e)
        {
            if(this.capture != null)
            {
                this.capture.Dispose();
            }
        }

        #endregion

        #region 캡처 이미지 GRAB 처리하기 - capture_ImageGrabbed(sender, e)

        /// <summary>
        /// 캡처 이미지 GRAB 처리하기
        /// </summary>
        /// <param name="sender">이벤트 발생자</param>
        /// <param name="e">이벤트 인자</param>
        private void capture_ImageGrabbed(object sender, EventArgs e)
        {
            Image<Bgr, Byte> captureImage = this.capture.RetrieveBgrFrame();

            Image<Gray, Byte> grayscaleImage           = captureImage.Convert<Gray, Byte>();
            Image<Gray, Byte> downSampleGrayscaleImage = grayscaleImage.PyrDown();
            Image<Gray, Byte> upSampleGrayscaleImage   = downSampleGrayscaleImage.PyrUp();
            Image<Gray, Byte> cannyImage               = upSampleGrayscaleImage.Canny(100, 60);

            this.captureImageBox.Image            = captureImage;
            this.grayscaleImageBox.Image          = grayscaleImage;
            this.GrayscaleSmoothingImageBox.Image = upSampleGrayscaleImage;
            this.cannyImageBox.Image              = cannyImage;
        }

        #endregion

        #region 캡처 버튼 클릭시 처리하기 - captureButtonClick(sender, e)

        /// <summary>
        /// 캡처 버튼 클릭시 처리하기
        /// </summary>
        /// <param name="sender">이벤트 발생자</param>
        /// <param name="e">이벤트 인자</param>
        private void captureButtonClick(object sender, EventArgs e)
        {
            if(this.capture != null)
            {
                if(this.isCapturing)
                {
                    this.captureButton.Text = "캡처 시작";

                    this.capture.Pause();
                }
                else
                {
                    this.captureButton.Text = "캡처 중단";

                    this.capture.Start();
                }

                this.isCapturing = !this.isCapturing;
            }
        }

        #endregion
        #region 수평 반전 버튼 클릭시 처리하기 - flipHorizontalButton_Click(sender, e)

        /// <summary>
        /// 수평 반전 버튼 클릭시 처리하기
        /// </summary>
        /// <param name="sender">이벤트 발생자</param>
        /// <param name="e">이벤트 인자</param>
        private void flipHorizontalButton_Click(object sender, EventArgs e)
        {
            if(this.capture != null)
            {
                this.capture.FlipHorizontal = !this.capture.FlipHorizontal;
            }
        }

        #endregion
        #region 수직 반전 버튼 클릭시 처리하기 - flipVerticalButton_Click(sender, e)

        /// <summary>
        /// 수직 반전 버튼 클릭시 처리하기
        /// </summary>
        /// <param name="sender">이벤트 발생자</param>
        /// <param name="e">이벤트 인자</param>
        private void flipVerticalButton_Click(object sender, EventArgs e)
        {
            if(this.capture != null)
            {
                this.capture.FlipVertical = !this.capture.FlipVertical;
            }
        }

        #endregion
    }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

using System;

using System.Windows.Forms;

using Emgu.CV;

using Emgu.CV.Structure;

namespace TestProject

{

/// <summary>

/// 메인 폼

/// </summary>

public partial class MainForm : Form

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Field

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

#region Field

/// <summary>

/// 캡처

/// </summary>

private Capture capture = null;

/// <summary>

/// 캡처 여부

/// </summary>

private bool isCapturing;

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Constructor

////////////////////////////////////////////////////////////////////////////////////////// Public

#region 생성자 - MainForm()

/// <summary>

/// 생성자

/// </summary>

public MainForm()

{

InitializeComponent();

try

{

this.capture = new Capture();

this.capture.ImageGrabbed += capture_ImageGrabbed;

}

catch(Exception exception)

{

MessageBox.Show(exception.Message);

}

FormClosed += Form_FormClosed;

this.captureButton.Click += captureButtonClick;

this.flipHorizontalButton.Click += flipHorizontalButton_Click;

this.flipVerticalButton.Click += flipVerticalButton_Click;

}

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

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

//////////////////////////////////////////////////////////////////////////////// Event

#region 폼 닫는 경우 처리하기 - Form_FormClosed(sender, e)

/// <summary>

/// 폼 닫는 경우 처리하기

/// </summary>

/// <param name="sender">이벤트 발생자</param>

/// <param name="e">이벤트 인자</param>

private void Form_FormClosed(object sender, FormClosedEventArgs e)

{

if(this.capture != null)

{

this.capture.Dispose();

}

#endregion

#region 캡처 이미지 GRAB 처리하기 - capture_ImageGrabbed(sender, e)

/// <summary>

/// 캡처 이미지 GRAB 처리하기

/// </summary>

/// <param name="sender">이벤트 발생자</param>

/// <param name="e">이벤트 인자</param>

private void capture_ImageGrabbed(object sender, EventArgs e)

{

Image<Bgr, Byte> captureImage = this.capture.RetrieveBgrFrame();

Image<Gray, Byte> grayscaleImage = captureImage.Convert<Gray, Byte>();

Image<Gray, Byte> downSampleGrayscaleImage = grayscaleImage.PyrDown();

Image<Gray, Byte> upSampleGrayscaleImage = downSampleGrayscaleImage.PyrUp();

Image<Gray, Byte> cannyImage = upSampleGrayscaleImage.Canny(100, 60);

this.captureImageBox.Image = captureImage;

this.grayscaleImageBox.Image = grayscaleImage;

this.GrayscaleSmoothingImageBox.Image = upSampleGrayscaleImage;

this.cannyImageBox.Image = cannyImage;

}

#endregion

#region 캡처 버튼 클릭시 처리하기 - captureButtonClick(sender, e)

/// <summary>

/// 캡처 버튼 클릭시 처리하기

/// </summary>

/// <param name="sender">이벤트 발생자</param>

/// <param name="e">이벤트 인자</param>

private void captureButtonClick(object sender, EventArgs e)

{

if(this.capture != null)

{

if(this.isCapturing)

{

this.captureButton.Text = "캡처 시작";

this.capture.Pause();

}

else

{

this.captureButton.Text = "캡처 중단";

this.capture.Start();

}

this.isCapturing = !this.isCapturing;

}

#endregion

#region 수평 반전 버튼 클릭시 처리하기 - flipHorizontalButton_Click(sender, e)

/// <summary>

/// 수평 반전 버튼 클릭시 처리하기

/// </summary>

/// <param name="sender">이벤트 발생자</param>

/// <param name="e">이벤트 인자</param>

private void flipHorizontalButton_Click(object sender, EventArgs e)

{

if(this.capture != null)

{

this.capture.FlipHorizontal = !this.capture.FlipHorizontal;

}

#endregion

#region 수직 반전 버튼 클릭시 처리하기 - flipVerticalButton_Click(sender, e)

/// <summary>

/// 수직 반전 버튼 클릭시 처리하기

/// </summary>

/// <param name="sender">이벤트 발생자</param>

/// <param name="e">이벤트 인자</param>

private void flipVerticalButton_Click(object sender, EventArgs e)

{

if(this.capture != null)

{

this.capture.FlipVertical = !this.capture.FlipVertical;

}

#endregion

}

TestProject.zip

[C#/WINFORM/EMGUCV] Image 클래스 : Convolution 메소드를 사용해 평균값 필터 회선 적용하기

■ Image 클래스의 Convolution 메소드를 사용해 평균값 필터 회선를 적용하는 방법을 보여준다. ▶ 예제 코드 (C#)


using Emgu.CV;
using Emgu.CV.Structure;

float[,] maskArray =
{
    { 1.0f / 9.0f, 1.0f / 9.0f, 1.0f / 9.0f },
    { 1.0f / 9.0f, 1.0f / 9.0f, 1.0f / 9.0f },
    { 1.0f / 9.0f, 1.0f / 9.0f, 1.0f / 9.0f }
};

ConvolutionKernelF convolutionKernelF = new ConvolutionKernelF(maskArray);

Image<Gray, float> sourceImage = new Image<Gray, float>("c:\\source.jpg");
Image<Gray, float> targetImage = sourceImage.Convolution(convolutionKernelF);

using Emgu.CV;

using Emgu.CV.Structure;

float[,] maskArray =

{

{ 1.0f / 9.0f, 1.0f / 9.0f, 1.0f / 9.0f },

{ 1.0f / 9.0f, 1.0f / 9.0f, 1.0f / 9.0f }

};

ConvolutionKernelF convolutionKernelF = new ConvolutionKernelF(maskArray);

Image<Gray, float> sourceImage = new Image<Gray, float>("c:\\source.jpg");

Image<Gray, float> targetImage = sourceImage.Convolution(convolutionKernelF);

[C#/WINFORM/EMGUCV] Image 클래스 : Erode 메소드를 사용해 최소값 필터 회선 적용하기

■ Image 클래스의 Erode 메소드를 사용해 최소값 필터 회선을 적용하는 방법을 보여준다. ▶ 예제 코드 (C#)


using Emgu.CV;
using Emgu.CV.Structure;

Image<Gray, byte> sourceImage = new Image<Gray, byte>("c:\\source.jpg");
Image<Gray, byte> targetImage = sourceImage.Erode(1);

using Emgu.CV;

using Emgu.CV.Structure;

Image<Gray, byte> sourceImage = new Image<Gray, byte>("c:\\source.jpg");

Image<Gray, byte> targetImage = sourceImage.Erode(1);

[C#/WINFORM/EMGUCV] Image 클래스 : Dilate 메소드를 사용해 최대값 필터 회선 적용하기

■ Image 클래스의 Dilate 메소드를 사용해 최대값 필터 회선을 적용하는 방법을 보여준다. ▶ 예제 코드 (C#)


using Emgu.CV;
using Emgu.CV.Structure;

Image<Gray, byte> sourceImage = new Image<Gray, byte>("c:\\source.jpg");
Image<Gray, byte> targetImage = sourceImage.Dilate(1);

using Emgu.CV;

using Emgu.CV.Structure;

Image<Gray, byte> sourceImage = new Image<Gray, byte>("c:\\source.jpg");

Image<Gray, byte> targetImage = sourceImage.Dilate(1);

[C#/WINFORM/EMGUCV] Image 클래스 : SmoothMedian 메소드를 사용해 중간값 필터 회선 적용하기

■ Image 클래스의 SmoothMedian 메소드를 사용해 중간값 필터 회선을 적용하는 방법을 보여준다. ▶ 예제 코드 (C#)


using Emgu.CV;
using Emgu.CV.Structure;

Image<Gray, byte> sourceImage = new Image<Gray, byte>("c:\\source.jpg");
Image<Gray, byte> targetImage = sourceImage.SmoothMedian(3);

using Emgu.CV;

using Emgu.CV.Structure;

Image<Gray, byte> sourceImage = new Image<Gray, byte>("c:\\source.jpg");

Image<Gray, byte> targetImage = sourceImage.SmoothMedian(3);

[C#/WINFORM/EMGUCV] Image 클래스 : Canny 메소드를 사용해 캐니 오퍼레이터 회선 적용하기

■ Image 클래스의 Canny 메소드를 사용해 캐니 오퍼레이터 회선을 적용하는 방법을 보여준다. ▶ 예제 코드 (C#)


using Emgu.CV;
using Emgu.CV.Structure;

Image<Gray, byte> sourceImage = new Image<Gray, byte>("c:\\source.jpg");
Image<Gray, byte> targetImage = sourceImage.Canny(30.0, 200.0);

using Emgu.CV;

using Emgu.CV.Structure;

Image<Gray, byte> sourceImage = new Image<Gray, byte>("c:\\source.jpg");

Image<Gray, byte> targetImage = sourceImage.Canny(30.0, 200.0);

[C#/WINFORM/EMGUCV] Image 클래스 : Convolution 메소드를 사용해 가우시안-라플라시안 에지 회선 적용하기

■ Image 클래스의 Convolution 메소드를 사용해 가우시안-라플라시안 에지 회선을 적용하는 방법을 보여준다. ▶ 예제 코드 (C#)


using Emgu.CV;
using Emgu.CV.Structure;

float[,] maskArray =
{
    { 0.0f, 0.0f, 3.0f,   2.0f,   2.0f,   2.0f, 3.0f, 0.0f, 0.0f },
    { 0.0f, 2.0f, 3.0f,   5.0f,   5.0f,   5.0f, 3.0f, 2.0f, 0.0f },
    { 3.0f, 3.0f, 5.0f,   3.0f,   0.0f,   3.0f, 5.0f, 3.0f, 3.0f },
    { 2.0f, 5.0f, 3.0f, -12.0f, -23.0f, -12.0f, 3.0f, 5.0f, 2.0f },
    { 2.0f, 5.0f, 0.0f, -23.0f, -40.0f, -23.0f, 0.0f, 5.0f, 2.0f },
    { 2.0f, 5.0f, 3.0f, -12.0f, -23.0f, -12.0f, 3.0f, 5.0f, 2.0f },
    { 3.0f, 3.0f, 5.0f,   3.0f,   0.0f,   3.0f, 5.0f, 3.0f, 3.0f },
    { 0.0f, 2.0f, 3.0f,   5.0f,   5.0f,   5.0f, 3.0f, 2.0f, 0.0f },
    { 0.0f, 0.0f, 3.0f,   2.0f,   2.0f,   2.0f, 3.0f, 0.0f, 0.0f }
};

ConvolutionKernelF convolutionKernelF = new ConvolutionKernelF(maskArray);

Image<Gray, float> sourceImage = new Image<Gray, float>("c:\\source.jpg");
Image<Gray, float> targetImage = sourceImage.Convolution(convolutionKernelF);

using Emgu.CV;

using Emgu.CV.Structure;

float[,] maskArray =

{

{ 0.0f, 0.0f, 3.0f, 2.0f, 2.0f, 2.0f, 3.0f, 0.0f, 0.0f },

{ 0.0f, 2.0f, 3.0f, 5.0f, 5.0f, 5.0f, 3.0f, 2.0f, 0.0f },

{ 3.0f, 3.0f, 5.0f, 3.0f, 0.0f, 3.0f, 5.0f, 3.0f, 3.0f },

{ 2.0f, 5.0f, 3.0f, -12.0f, -23.0f, -12.0f, 3.0f, 5.0f, 2.0f },

{ 2.0f, 5.0f, 0.0f, -23.0f, -40.0f, -23.0f, 0.0f, 5.0f, 2.0f },

{ 2.0f, 5.0f, 3.0f, -12.0f, -23.0f, -12.0f, 3.0f, 5.0f, 2.0f },

{ 3.0f, 3.0f, 5.0f, 3.0f, 0.0f, 3.0f, 5.0f, 3.0f, 3.0f },

{ 0.0f, 2.0f, 3.0f, 5.0f, 5.0f, 5.0f, 3.0f, 2.0f, 0.0f },

{ 0.0f, 0.0f, 3.0f, 2.0f, 2.0f, 2.0f, 3.0f, 0.0f, 0.0f }

};

ConvolutionKernelF convolutionKernelF = new ConvolutionKernelF(maskArray);

Image<Gray, float> sourceImage = new Image<Gray, float>("c:\\source.jpg");

Image<Gray, float> targetImage = sourceImage.Convolution(convolutionKernelF);

[C#/WINFORM/EMGUCV] Image 클래스 : Laplace 메소드를 사용해 라플라시안 에지 회선 적용하기

■ Image 클래스의 Laplace 메소드를 사용해 라플라시안 에지 회선을 적용하는 방법을 보여준다. ▶ 예제 코드 (C#)


using Emgu.CV;
using Emgu.CV.Structure;

Image<Gray, float> sourceImage = new Image<Gray, float>("c:\\source.jpg");
Image<Gray, float> targetImage = sourceImage.Laplace(3);

using Emgu.CV;

using Emgu.CV.Structure;

Image<Gray, float> sourceImage = new Image<Gray, float>("c:\\source.jpg");

Image<Gray, float> targetImage = sourceImage.Laplace(3);

[C#/WINFORM/EMGUCV] Image 클래스 : Sobel 메소드를 사용해 소벨 에지 X 회선 적용하기

■ Image 클래스의 Sobel 메소드를 사용해 소벨 에지 X 회선을 적용하는 방법을 보여준다. ▶ 예제 코드 (C#)


using Emgu.CV;
using Emgu.CV.Structure;

Image<Gray, float> sourceImage = new Image<Gray, float>("c:\\source.jpg");
Image<Gray, float> targetImage = sourceImage.Sobel(1, 0, 3);

using Emgu.CV;

using Emgu.CV.Structure;

Image<Gray, float> sourceImage = new Image<Gray, float>("c:\\source.jpg");

Image<Gray, float> targetImage = sourceImage.Sobel(1, 0, 3);

[C#/WINFORM/EMGUCV] Image 클래스 : Sobel 메소드를 사용해 소벨 에지 Y 회선 적용하기

■ Image 클래스의 Sobel 메소드를 사용해 소벨 에지 Y 회선을 적용하는 방법을 보여준다. ▶ 예제 코드 (C#)


using Emgu.CV;
using Emgu.CV.Structure;

Image<Gray, float> sourceImage = new Image<Gray, float>("c:\\source.jpg");
Image<Gray, float> targetImage = sourceImage.Sobel(0, 1, 3);

using Emgu.CV;

using Emgu.CV.Structure;

Image<Gray, float> sourceImage = new Image<Gray, float>("c:\\source.jpg");

Image<Gray, float> targetImage = sourceImage.Sobel(0, 1, 3);