c# - EmguCv.CV.CvInvoke 抛出的 EmguCv TypeInitializationException

Question

首先让我说，我确实完整地遵循了许多教程，例如位于 EmguCv 主站点上的教程，但抛出了 TypeInitializationException。

现在，仔细听，因为这是非常奇怪的部分。我首先要说我的问题有三个“级别”，但是，所有“级别”中的代码完全相同，甚至没有丝毫变化。这自然会表明我有引用或链接问题，但我再次尝试按照不同的教程进行多次尝试，但无济于事。

级别 1(此级别产生 TypeInitializationException)
我创建了一个新项目，正确地引用了所有内容等等，然后在这个新项目中编写我的代码。调试后，我抛出异常并且我的程序退出。这是问题图片的链接:http://prntscr.com/uychc

Level 2(这个级别运行完全正常，没有抛出异常)
在此级别中，我几乎找到了 EmguCv 的示例项目之一(在本例中为 VideoSurveilance)，然后删除默认代码并将我的所有代码复制并粘贴到其中。在添加了一些我需要的引用后，程序运行良好。我不能发布超过 3 个链接，但您必须相信我视频图片显示正确。

级别 3(此级别不会抛出异常，但会警告我有“第一次机会”)
在这一关中，我将整个 2 级项目复制并粘贴到不同的目录中。找到并重新链接丢失的文件/引用后，我能够运行该程序，但图片不显示，我收到“Emgu.CV.dll 警告中出现类型为“System.TypeInitializationException”的第一次机会异常”警告。http://prntscr.com/uycmn

我目前运行 Windows 7 x64(是的，我将构建选项更改为 x64 和 x64 .dll)并且正在运行 EmguCv 2.4.9 和 2.4.2(在两者上测试)和 Visual Studios 2010 和 2012(在两者上测试)。

这是它可能值的代码:

    using System;
    using System.Collections.Generic;
    using System.ComponentModel;
    using System.Data;
    using System.Drawing;
    using System.Linq;
    using System.Text;
    //using System.Threading.Tasks;
    using System.Windows.Forms;

    using System.Windows;
    using System.Windows.Controls;
    using System.Windows.Data;
    using System.Windows.Documents;
    using System.Windows.Input;
    using System.Windows.Media;
    using System.Windows.Media.Imaging;
    using System.Windows.Navigation;
    using System.Windows.Shapes;

    using Microsoft.Kinect;
    using Emgu.CV;
    using Emgu.CV.CvEnum;
    using Emgu.CV.Structure;
    using Emgu.CV.UI;
    using System.IO;

    namespace VideoSurveilance
    {
       public partial class VideoSurveilance : Form
       {
            KinectSensor sensor;
            WriteableBitmap depthBitmap;
            WriteableBitmap colorBitmap;
            DepthImagePixel[] depthPixels;
            byte[] colorPixels;

            int blobCount = 0;

          public VideoSurveilance()
          {
             InitializeComponent();

          }

          private void VideoSurveilance_Load(object sender, System.EventArgs e)
          {
              foreach (var potentialSensor in KinectSensor.KinectSensors)
              {
                  if (potentialSensor.Status == KinectStatus.Connected)
                  {
                      this.sensor = potentialSensor;
                      break;
                  }
              }


              if (null != this.sensor)
              {

                  this.sensor.DepthStream.Enable(DepthImageFormat.Resolution640x480Fps30);
                  this.sensor.ColorStream.Enable(ColorImageFormat.RgbResolution640x480Fps30);
                  this.colorPixels = new byte[this.sensor.ColorStream.FramePixelDataLength];
                  this.depthPixels = new DepthImagePixel[this.sensor.DepthStream.FramePixelDataLength];
                  this.colorBitmap = new WriteableBitmap(this.sensor.ColorStream.FrameWidth, this.sensor.ColorStream.FrameHeight, 96.0, 96.0, PixelFormats.Bgr32, null);
                  this.depthBitmap = new WriteableBitmap(this.sensor.DepthStream.FrameWidth, this.sensor.DepthStream.FrameHeight, 96.0, 96.0, PixelFormats.Bgr32, null);



                  WriteableBitmap bitmap;
                  bitmap = new WriteableBitmap(this.sensor.DepthStream.FrameWidth, this.sensor.DepthStream.FrameHeight, 96.0, 96.0, PixelFormats.Bgr32, null);



                  byte[] retVal = new byte[bitmap.PixelWidth * bitmap.PixelHeight * 4];
                  bitmap.CopyPixels(new Int32Rect(0, 0, bitmap.PixelWidth, bitmap.PixelHeight), retVal, bitmap.PixelWidth * 4, 0);

                  Bitmap b = new Bitmap(bitmap.PixelWidth, bitmap.PixelHeight);
                  int k = 0;
                  byte red, green, blue, alpha;
                  for (int i = 0; i < bitmap.PixelWidth; i++)
                  {
                      for (int j = 0; j < bitmap.PixelHeight && k < retVal.Length; j++)
                      {
                          alpha = retVal[k++];
                          blue = retVal[k++];
                          green = retVal[k++];
                          red = retVal[k++];

                          System.Drawing.Color c = new System.Drawing.Color();
                          c = System.Drawing.Color.FromArgb(alpha, red, green, blue);

                          b.SetPixel(i, j, c);
                      }
                  }


                  Image<Bgr, Byte> temp = new Image<Bgr, byte>(b);



                  this.ibOriginal.Image = temp;

                  this.sensor.AllFramesReady += this.sensor_AllFramesReady;

                  try
                  {
                      this.sensor.Start();
                  }
                  catch (IOException)
                  {
                      this.sensor = null;
                  }
              }
          }


          private void sensor_AllFramesReady(object sender, AllFramesReadyEventArgs e)
          {
              blobCount = 0;
              BitmapSource depthBmp = null;
              Image<Bgr, Byte> openCVImg;
              using (ColorImageFrame colorFrame = e.OpenColorImageFrame())
              {
                  using (DepthImageFrame depthFrame = e.OpenDepthImageFrame())
                  {
                      if (depthFrame != null)
                      {

                          blobCount = 0;
                          if (colorFrame != null)
                          {
                              byte[] pixels = new byte[colorFrame.PixelDataLength];
                              colorFrame.CopyPixelDataTo(pixels);

                              int stride = colorFrame.Width * 4;
                              BitmapSource color = BitmapImage.Create(colorFrame.Width, colorFrame.Height, 96, 96, PixelFormats.Bgr32, null, pixels, stride);
                              openCVImg = new Image<Bgr, byte>(color.ToBitmap());
                          }
                          else
                          {
                              return;
                          }

                          Image<Gray, byte> gray_image;

                          using (MemStorage stor = new MemStorage())
                          {
                              gray_image = openCVImg.InRange(new Bgr(0, 0, 150), new Bgr(200, 200, 255));

                              gray_image = gray_image.SmoothGaussian(9);

                              CircleF[] circles = gray_image.HoughCircles(new Gray(100),
                                                                          new Gray(50),
                                                                          2,
                                                                          gray_image.Height / 4,
                                                                          10,
                                                                          400)[0];

                              foreach (CircleF circle in circles)
                              {
                                  CvInvoke.cvCircle(openCVImg,
                                                    new System.Drawing.Point(Convert.ToInt32(circle.Center.X), Convert.ToInt32(circle.Center.Y)),
                                                    3,
                                                    new MCvScalar(0, 255, 0),
                                                    -1,
                                                    LINE_TYPE.CV_AA,
                                                    0);

                                  openCVImg.Draw(circle,
                                                 new Bgr(System.Drawing.Color.Red),
                                                 3);
                              }
                          }
                          ibOriginal.Image = openCVImg;
                          ibProcessed.Image = gray_image;

                      }
                  }



              }
          }


       }
    }

using System;
using System.Globalization;
using System.IO;
using System.Windows;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using Microsoft.Kinect;
using System.ComponentModel;
using System.Runtime.InteropServices;
using Emgu.CV;

namespace VideoSurveilance
{
    public static class Helper
    {

        private const int MaxDepthDistance = 4000;
        private const int MinDepthDistance = 850;
        private const int MaxDepthDistanceOffset = 3150;

        public static BitmapSource SliceDepthImage(this DepthImageFrame image, int min = 20, int max = 1000)
        {
            int width = image.Width;
            int height = image.Height;

            //var depthFrame = image.Image.Bits;
            short[] rawDepthData = new short[image.PixelDataLength];
            image.CopyPixelDataTo(rawDepthData);

            var pixels = new byte[height * width * 4];

            const int BlueIndex = 0;
            const int GreenIndex = 1;
            const int RedIndex = 2;

            for (int depthIndex = 0, colorIndex = 0;
                depthIndex < rawDepthData.Length && colorIndex < pixels.Length;
                depthIndex++, colorIndex += 4)
            {

                // Calculate the distance represented by the two depth bytes
                int depth = rawDepthData[depthIndex] >> DepthImageFrame.PlayerIndexBitmaskWidth;

                // Map the distance to an intesity that can be represented in RGB
                var intensity = CalculateIntensityFromDistance(depth);

                if (depth > min && depth < max)
                {
                    // Apply the intensity to the color channels
                    pixels[colorIndex + BlueIndex] = intensity; //blue
                    pixels[colorIndex + GreenIndex] = intensity; //green
                    pixels[colorIndex + RedIndex] = intensity; //red                    
                }
            }

            return BitmapSource.Create(width, height, 96, 96, PixelFormats.Bgr32, null, pixels, width * 4);
        }




        public static byte CalculateIntensityFromDistance(int distance)
        {
            // This will map a distance value to a 0 - 255 range
            // for the purposes of applying the resulting value
            // to RGB pixels.
            int newMax = distance - MinDepthDistance;
            if (newMax > 0)
                return (byte)(255 - (255 * newMax
                / (MaxDepthDistanceOffset)));
            else
                return (byte)255;
        }


        public static System.Drawing.Bitmap ToBitmap(this BitmapSource bitmapsource)
        {
            System.Drawing.Bitmap bitmap;
            using (var outStream = new MemoryStream())
            {
                // from System.Media.BitmapImage to System.Drawing.Bitmap
                BitmapEncoder enc = new BmpBitmapEncoder();
                enc.Frames.Add(BitmapFrame.Create(bitmapsource));
                enc.Save(outStream);
                bitmap = new System.Drawing.Bitmap(outStream);
                return bitmap;
            }
        }


        [DllImport("gdi32")]
        private static extern int DeleteObject(IntPtr o);

        /// <summary>
        /// Convert an IImage to a WPF BitmapSource. The result can be used in the Set Property of Image.Source
        /// </summary>
        /// <param name="image">The Emgu CV Image</param>
        /// <returns>The equivalent BitmapSource</returns>
        public static BitmapSource ToBitmapSource(IImage image)
        {
            using (System.Drawing.Bitmap source = image.Bitmap)
            {
                IntPtr ptr = source.GetHbitmap(); //obtain the Hbitmap

                BitmapSource bs = System.Windows.Interop.Imaging.CreateBitmapSourceFromHBitmap(
                    ptr,
                    IntPtr.Zero,
                    Int32Rect.Empty,
                    System.Windows.Media.Imaging.BitmapSizeOptions.FromEmptyOptions());

                DeleteObject(ptr); //release the HBitmap
                return bs;
            }
        }

    }
}

我真诚地感谢任何试图帮助我的人，并希望任何有类似问题的人都能从这个长问题中受益。

Answer 1

找到“蛮力”解决方案:

您必须手动将“cvextern.dll”文件放入您的构建目录(x64、调试、发布或其他)。

这就完成了工作。我不敢相信我花了一整天的时间试图弄清楚这个问题。