C#调用C++（Opencv3）生成的dll文件

最新推荐文章于 2024-04-27 00:54:20 发布
最新推荐文章于 2024-04-27 00:54:20 发布
阅读量1k 收藏 8
点赞数 3
分类专栏： C#与C++Opencv通讯 文章标签： C#  C++ opencv 通讯
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33515313/article/details/101366577
版权

C#调用C++（Opencv3）生成的dll文件

1、新建一个c++dll工程

1.1、这里选择创建一个win32控制台程序，点击确定

在这里插入图片描述

1.2、点击下一步，别点完成

在这里插入图片描述

1.3、选择DLL(D),选择空项目，点击完成，项目建立成功

在这里插入图片描述在这里插入图片描述

1.4、选择release，X64；右键源文件—》添加—》新建项，添加一个.cpp文件，点击添加

在这里插入图片描述在这里插入图片描述

2、.cpp文件中添加C#需要调用的代码

2.1、代码如下，注意函数接口，图像用IplImage传输，不能使用Mat类传输，同时bool类型变量传输C#调用也会出错，尽量使用int类型。

#include<iostream>
#include<opencv2/opencv.hpp>
using namespace std;
//函数声明，只有声明了，才能被调用
extern"C" __declspec(dllexport) void testdll(IplImage* src, IplImage* dst, int x);
void testdll(IplImage* src, IplImage* dst, int x)       //参数未使用
{
	//图像转为Mat
	cv::Mat srcImage = cv::cvarrToMat(src);

	//图像处理
	cv::Mat dstImage;
	cv::blur(srcImage, dstImage, cv::Size(9, 9));

	//图像回传
	IplImage temp = dstImage;
	*dst = temp;
}

在这里插入图片描述

2.2、dll生成，生成—》重新生成解决方案（或者生成解决方案），生成成功，生成目录如输出窗口所示。

在这里插入图片描述
在这里插入图片描述

3、C#调用opencv C++dll的代码

在路径下面放置dll文件后，通过下面两句声明后即可在C#中调用dll中的该函数（多个函数时，每一个函数都需要单独声明），注意IplImage* 对应C#中的IntPtr。

 [DllImport("tesstdll.dll")]
  public static extern void testdll(IntPtr src, IntPtr dst, int input);

下面的代码为C#工程代码，因为本人对C#代码也不懂，以下C#为同事所写，略为混乱且有一定的bug仅供参考，仅供参考，仅供参考。大概步骤是读取一张图片，格式转换（较为复杂，函数都在下面），再调用dll中函数。

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using Emgu.CV;
using Emgu.Util;
using Emgu.CV.Structure;
using System.Drawing;
using System.Drawing.Imaging;
using System.Threading;
using System.Diagnostics;

namespace WindowsFormsApplication16
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
            timer1.Start();
        }

        [DllImport("tesstdll.dll")]
        public static extern void testdll(IntPtr src, IntPtr dst, int input);

        private void button1_Click(object sender, EventArgs e)
        {
            Mat srcmat = CvInvoke.Imread("00.jpg");
            //Image<Bgr, byte> m1 = new Image<Bgr, byte>("00.jpg");
            imageBox1.Image = srcmat;
            Image<Bgr, byte> dst = srcmat.ToImage<Bgr, byte>();
            IntPtr dstptr = CvInvoke.cvCreateImage(CvInvoke.cvGetSize(dst), Emgu.CV.CvEnum.IplDepth.IplDepth_8U, 3);
            testdll(EmguCVMatToIplImagePointer(srcmat), dstptr, 0);    
            IMG_01.Image = IplImagePointerToEmgucvMat(dstptr);
            #region

            //GetMat(EmguCVMatToIplImagePointer(matSrc));
            //Image<Bgr, byte> m1 = new Image<Bgr, byte>("00.jpg");
            //IMG_01.Image = m1;
            //Image<Bgr, byte> m2 = new Image<Bgr, byte>("01.jpg");
            //IMG_02.Image = m2;
            //Image<Bgr, byte> m3 = new Image<Bgr, byte>("02.jpg");
            //IMG_03.Image = m3;


            //IntPtr ptr = CvInvoke.cvCreateImage(CvInvoke.cvGetSize(m1), Emgu.CV.CvEnum.IplDepth.IplDepth_8U, 3);
            //MessageBox.Show("开始");
            lbl_01.Text = (pipesSortOrder(EmgucvImageToIplImagePointer(m1), ptr, false, false, false, 0)).ToString();
            //lbl_01.Text = (pipesSortOrder(m1.Ptr, ptr, 0, 0, 0, Convert.ToInt32(0))).ToString();
            pipesSortOrder2();
            EmgucvImageToIplImagePointer
            //IMG_01.Image = IplImagePointerToEmgucvMat(ptr);
            DialogResult reslult = MessageBox.Show("运行完毕！", "提示", MessageBoxButtons.YesNo, MessageBoxIcon.Question);
            //IntPtr ptr2 = CvInvoke.cvCreateImage(CvInvoke.cvGetSize(m2), Emgu.CV.CvEnum.IplDepth.IplDepth_8U, 3);
            //lbl_02.Text = (pipesSortOrder(m2.Ptr, ptr2, 1, 0, 0, 0)).ToString();
            //IMG_02.Image = IplImagePointerToEmgucvMat(ptr2);

            //IntPtr ptr3 = CvInvoke.cvCreateImage(CvInvoke.cvGetSize(m3), Emgu.CV.CvEnum.IplDepth.IplDepth_8U, 3);
            //lbl_03.Text = (pipesSortOrder(m3.Ptr, ptr3, 1, 0, 0, 0)).ToString();
            //IMG_03.Image = IplImagePointerToEmgucvMat(ptr3);

            //tsp9_pipes_dll.dll
            //GetMat(src.Ptr);
            //pictureBox1.Image = src.ToBitmap();

            /*  测试成功段内容
            //IntPtr SS = EmgucvImageToIplImagePointer(m1);
            //IntPtr ptr2 = CvInvoke.cvCreateImage(CvInvoke.cvGetSize(m1), Emgu.CV.CvEnum.IplDepth.IplDepth_8U, 3);

            //int reslut = histo_enhance(SS, ptr2);
            //label1.Text = reslut.ToString();
            //IMG_03.Image = IplImagePointerToEmgucvImage<Bgr, byte>(ptr2);
            //*/

            //MIplImage mlI = (MIplImage)Marshal.PtrToStructure(ptr, typeof(MIplImage));
            //Image<Bgr, byte> outframe = new Image<Bgr, byte>(mlI.Width, mlI.Height, mlI.WidthStep, mlI.ImageData);
            //pictureBox2.Image = outframe.ToBitmap();
            //matSrc.ToImage
            //imageBox1.Image = matSrc;


            #endregion

        }

        private void MatDeal()
        {
            Stopwatch sw = new Stopwatch();
            VideoCapture VCapture = new VideoCapture("newpipe.mp4");
            int count = Convert.ToInt32(VCapture.GetCaptureProperty(Emgu.CV.CvEnum.CapProp.FrameCount));
            bool isstart = false;
            for (int i = 1; i <= count; i++)
            {
                Mat src = new Mat();
                VCapture.Read(src);
                Image<Bgr, byte> image = src.ToImage<Bgr, byte>();
                IntPtr ptr2 = CvInvoke.cvCreateImage(CvInvoke.cvGetSize(image), Emgu.CV.CvEnum.IplDepth.IplDepth_8U, 3);
                int reslut = -1;
                if (!isstart)
                {
                    reslut = pipesSortOrder(image.Ptr, ptr2, 0, 0, 0, 0);
                    isstart = true;
                    sw.Start();
                }
                else
                    reslut = pipesSortOrder(image.Ptr, ptr2, 1, 0, 0, 0);
                Mat dst = IplImagePointerToEmgucvMat(ptr2);
                long inter = sw.ElapsedMilliseconds;
                //Image<Bgr, byte> dst = IplImagePointToEmgucvIImage<Bgr, byte>(ptr2);

                try
                {
                    Invoke(new Action(() =>
                    {
                        //lbl_02.Text = reslut.ToString()+"       "+inter.ToString ();
                        //IMG_02.Image = dst;
                    }));
                }
                catch (Exception)
                {
                    throw;
                }


                Thread.Sleep(30);
            }
        }

        //private Image ShowIplImageInWindow(IntPtr src)
        //{
        //    MIplImage img = (MIplImage)Marshal.PtrToStructure(src, typeof(MIplImage));

        //    Bitmap disp = new Bitmap(img.Width, img.Height, PixelFormat.Format24bppRgb);
        //    BitmapData bmp = disp.LockBits(new Rectangle(0, 0, img.Width, img.Height), ImageLockMode.WriteOnly, PixelFormat.Format24bppRgb);
        //    long linebytes = (img.Width * 24 + 31) / 32 * 4;
        //    unsafe
        //    {
        //        byte* pixel = (byte*)bmp.Scan0.ToPointer();
        //        if (img.NChannels == 3)
        //        {
        //            for (int i = 0; i < img.Height; i++)
        //            {
        //                for (int j = 0, n = 0; j < img.Width * 3; j++, n++)
        //                {
        //                    byte b = ((byte*)img.ImageData + img.WidthStep * i)[3 * j];
        //                    byte g = ((byte*)img.ImageData + img.WidthStep * i)[3 * j + 1];
        //                    byte r = ((byte*)img.ImageData + img.WidthStep * i)[3 * j + 2];

        //                    *(pixel + linebytes * (i) + n) = b;
        //                    n++;
        //                    *(pixel + linebytes * (i) + n) = g;
        //                    n++;
        //                    *(pixel + linebytes * (i) + n) = r;
        //                }
        //            }
        //        }
        //        else if (img.NChannels == 1)
        //        {
        //            for (int i = 0; i < img.Height; i++)
        //            {
        //                for (int j = 0, n = 0; j < img.Width; j++, n++)
        //                {
        //                    byte g = ((byte*)img.ImageData + img.WidthStep * i)[j];

        //                    *(pixel + linebytes * (i) + n) = g;
        //                    n++;
        //                    *(pixel + linebytes * (i) + n) = g;
        //                    n++;
        //                    *(pixel + linebytes * (i) + n) = g;
        //                }
        //            }
        //        }
        //        else
        //        {
        //            return null;
        //        }
        //        disp.UnlockBits(bmp);
        //        return (Image)disp;
        //    }
        //}


        //在.net中使用OpenCv和EmguCv时，必须在三者支持的图像格式之间进行转换。.net中用Bitmap类来承载图像，OpenCv中用IplImage指针来承载图像，
        //   EmguCv中用Image<TColor,TDepth>来承载图像。本文主要讲述如何在IplImage、Image<TColor,TDepth>和Bitmap之间转换。

        #region  实现 IplImage  <=>  Image<TColor,TDepth>
        //    IplImage  <=>  Image<TColor,TDepth>
        //用了MIplImage的辅助，我们可以很容易实现IplImage指针和Image<TColor,TDepth>之间的转换。


        /// 将MIplImage结构转换到IplImage指针；
        /// 注意：指针在使用完之后必须用Marshal.FreeHGlobal方法释放。
        /// <param name="mi">MIplImage对象</param>
        /// <returns>返回IplImage指针</returns>
        public static IntPtr MIplImageToIplImagePointer(MIplImage mi)
        {
            IntPtr ptr = Marshal.AllocHGlobal(mi.NSize);
            Marshal.StructureToPtr(mi, ptr, false);
            return ptr;
        }

        /// 将IplImage指针转换成MIplImage结构
        /// <param name="ptr">IplImage指针</param>
        /// <returns>返回MIplImage结构</returns>
        public static MIplImage IplImagePointerToMIplImage(IntPtr ptr)
        {
            return (MIplImage)Marshal.PtrToStructure(ptr, typeof(MIplImage));
        }

        /// 将IplImage指针转换成Emgucv中的Image对象；
        /// 注意：这里需要您自己根据IplImage中的depth和nChannels来决定
        /// <typeparam name="TColor">Color type of this image (either Gray, Bgr, Bgra, Hsv, Hls, Lab, Luv, Xyz or Ycc)</typeparam>
        /// <typeparam name="TDepth">Depth of this image (either Byte, SByte, Single, double, UInt16, Int16 or Int32)</typeparam>
        /// <param name="ptr">IplImage指针</param>
        /// <returns>返回Image对象</returns>
        public static Image<TColor, TDepth> IplImagePointerToEmgucvImage<TColor, TDepth>(IntPtr ptr)
            where TColor : struct, IColor
            where TDepth : new()
        {
            MIplImage mi = IplImagePointerToMIplImage(ptr);
            return new Image<TColor, TDepth>(mi.Width, mi.Height, mi.WidthStep, mi.ImageData);
        }
        /// <summary>
        /// 将IplImage指针转换成Emgucv中的IImage接口；
        /// 1通道对应灰度图像，3通道对应BGR图像，4通道对应BGRA图像。
        /// 注意：3通道可能并非BGR图像，而是HLS,HSV等图像
        /// </summary>
        /// <param name="ptr">IplImage指针</param>
        /// <returns>返回IImage接口</returns>
        public static IImage IplImagePointToEmgucvIImage(IntPtr ptr)
        {
            MIplImage mi = IplImagePointerToMIplImage(ptr);
            Type tColor;
            Type tDepth;
            string unsupportedDepth = "不支持的像素位深度IPL_DEPTH";
            string unsupportedChannels = "不支持的通道数（仅支持1，2，4通道）";
            switch (mi.NChannels)
            {
                case 1:
                    tColor = typeof(Gray);
                    switch (mi.Depth)
                    {
                        case Emgu.CV.CvEnum.IplDepth.IplDepth_8U:
                            tDepth = typeof(Byte);
                            return new Image<Gray, Byte>(mi.Width, mi.Height, mi.WidthStep, mi.ImageData);
                        case Emgu.CV.CvEnum.IplDepth.IplDepth16U:
                            tDepth = typeof(UInt16);
                            return new Image<Gray, UInt16>(mi.Width, mi.Height, mi.WidthStep, mi.ImageData);
                        case Emgu.CV.CvEnum.IplDepth.IplDepth16S:
                            tDepth = typeof(Int16);
                            return new Image<Gray, Int16>(mi.Width, mi.Height, mi.WidthStep, mi.ImageData);
                        case Emgu.CV.CvEnum.IplDepth.IplDepth32S:
                            tDepth = typeof(Int32);
                            return new Image<Gray, Int32>(mi.Width, mi.Height, mi.WidthStep, mi.ImageData);
                        case Emgu.CV.CvEnum.IplDepth.IplDepth32F:
                            tDepth = typeof(Single);
                            return new Image<Gray, Single>(mi.Width, mi.Height, mi.WidthStep, mi.ImageData);
                        case Emgu.CV.CvEnum.IplDepth.IplDepth64F:
                            tDepth = typeof(Double);
                            return new Image<Gray, Double>(mi.Width, mi.Height, mi.WidthStep, mi.ImageData);
                        default:
                            throw new NotImplementedException(unsupportedDepth);
                    }
                case 3:
                    tColor = typeof(Bgr);
                    switch (mi.Depth)
                    {
                        case Emgu.CV.CvEnum.IplDepth.IplDepth_8U:
                            tDepth = typeof(Byte);
                            return new Image<Bgr, Byte>(mi.Width, mi.Height, mi.WidthStep, mi.ImageData);
                        case Emgu.CV.CvEnum.IplDepth.IplDepth16U:
                            tDepth = typeof(UInt16);
                            return new Image<Bgr, UInt16>(mi.Width, mi.Height, mi.WidthStep, mi.ImageData);
                        case Emgu.CV.CvEnum.IplDepth.IplDepth16S:
                            tDepth = typeof(Int16);
                            return new Image<Bgr, Int16>(mi.Width, mi.Height, mi.WidthStep, mi.ImageData);
                        case Emgu.CV.CvEnum.IplDepth.IplDepth32S:
                            tDepth = typeof(Int32);
                            return new Image<Bgr, Int32>(mi.Width, mi.Height, mi.WidthStep, mi.ImageData);
                        case Emgu.CV.CvEnum.IplDepth.IplDepth32F:
                            tDepth = typeof(Single);
                            return new Image<Bgr, Single>(mi.Width, mi.Height, mi.WidthStep, mi.ImageData);
                        case Emgu.CV.CvEnum.IplDepth.IplDepth64F:
                            tDepth = typeof(Double);
                            return new Image<Bgr, Double>(mi.Width, mi.Height, mi.WidthStep, mi.ImageData);
                        default:
                            throw new NotImplementedException(unsupportedDepth);
                    }
                case 4:
                    tColor = typeof(Bgra);
                    switch (mi.Depth)
                    {
                        case Emgu.CV.CvEnum.IplDepth.IplDepth_8U:
                            tDepth = typeof(Byte);
                            return new Image<Bgra, Byte>(mi.Width, mi.Height, mi.WidthStep, mi.ImageData);
                        case Emgu.CV.CvEnum.IplDepth.IplDepth16U:
                            tDepth = typeof(UInt16);
                            return new Image<Bgra, UInt16>(mi.Width, mi.Height, mi.WidthStep, mi.ImageData);
                        case Emgu.CV.CvEnum.IplDepth.IplDepth16S:
                            tDepth = typeof(Int16);
                            return new Image<Bgra, Int16>(mi.Width, mi.Height, mi.WidthStep, mi.ImageData);
                        case Emgu.CV.CvEnum.IplDepth.IplDepth32S:
                            tDepth = typeof(Int32);
                            return new Image<Bgra, Int32>(mi.Width, mi.Height, mi.WidthStep, mi.ImageData);
                        case Emgu.CV.CvEnum.IplDepth.IplDepth32F:
                            tDepth = typeof(Single);
                            return new Image<Bgra, Single>(mi.Width, mi.Height, mi.WidthStep, mi.ImageData);
                        case Emgu.CV.CvEnum.IplDepth.IplDepth64F:
                            tDepth = typeof(Double);
                            return new Image<Bgra, Double>(mi.Width, mi.Height, mi.WidthStep, mi.ImageData);
                        default:
                            throw new NotImplementedException(unsupportedDepth);
                    }
                default:
                    throw new NotImplementedException(unsupportedChannels);
            }
        }
        /// <summary>
        /// 将Emgucv中的Image对象转换成IplImage指针；
        /// </summary>
        /// <typeparam name="TColor">Color type of this image (either Gray, Bgr, Bgra, Hsv, Hls, Lab, Luv, Xyz or Ycc)</typeparam>
        /// <typeparam name="TDepth">Depth of this image (either Byte, SByte, Single, double, UInt16, Int16 or Int32)</typeparam>
        /// <param name="image">Image对象</param>
        /// <returns>返回IplImage指针</returns>
        public static IntPtr EmgucvImageToIplImagePointer<TColor, TDepth>(Image<TColor, TDepth> image)
            where TColor : struct, IColor
            where TDepth : new()
        {
            return image.Ptr;
        }

        #endregion

        #region  实现 Image<TColor,TDepth>  <=>  Bitmap
        //EmguCv中已经实现了这二者之间的转换，分别是Image<TColor,TDepth>类的下列成员：
        //(1)public Bitmap Bitmap { get; set; }
        //该属性可以获取或者设置位图；对于Image<Gray, Byte>, Image<Bgr, Byte> 和 Image<Bgra, Byte>这三种情况效率很高，因为Image<TColor,TDepth>和Bitmap共享数据内存。
        //(2)public Bitmap ToBitmap(int width,int height)及public Bitmap ToBitmap()方法
        //(3)public Image(Bitmap bmp)
        //(4)public Image(int width,int height,int stride,IntPtr scan0)
        //这个构造函数几乎是万能的，只要您清楚图像的内存分布，以及想要的目的。

        /// <summary>
        /// 将IplImage指针转换成位图对象；
        /// 对于不支持的像素格式，可以先使用cvCvtColor函数转换成支持的图像指针
        /// </summary>
        /// <param name="ptr">IplImage指针</param>
        /// <returns>返回位图对象</returns>
        public static Bitmap IplImagePointerToBitmap(IntPtr ptr)
        {
            MIplImage mi = IplImagePointerToMIplImage(ptr);
            PixelFormat pixelFormat;    //像素格式
            string unsupportedDepth = "不支持的像素位深度IPL_DEPTH";
            string unsupportedChannels = "不支持的通道数（仅支持1，2，4通道）";
            switch (mi.NChannels)
            {
                case 1:
                    switch (mi.Depth)
                    {
                        case Emgu.CV.CvEnum.IplDepth.IplDepth_8U:
                            pixelFormat = PixelFormat.Format8bppIndexed;
                            break;
                        case Emgu.CV.CvEnum.IplDepth.IplDepth16U:
                            pixelFormat = PixelFormat.Format16bppGrayScale;
                            break;
                        default:
                            throw new NotImplementedException(unsupportedDepth);
                    }
                    break;
                case 3:
                    switch (mi.Depth)
                    {
                        case Emgu.CV.CvEnum.IplDepth.IplDepth_8U:
                            pixelFormat = PixelFormat.Format24bppRgb;
                            break;
                        case Emgu.CV.CvEnum.IplDepth.IplDepth16U:
                            pixelFormat = PixelFormat.Format48bppRgb;
                            break;
                        default:
                            throw new NotImplementedException(unsupportedDepth);
                    }
                    break;
                case 4:
                    switch (mi.Depth)
                    {
                        case Emgu.CV.CvEnum.IplDepth.IplDepth_8U:
                            pixelFormat = PixelFormat.Format32bppArgb;
                            break;
                        case Emgu.CV.CvEnum.IplDepth.IplDepth16U:
                            pixelFormat = PixelFormat.Format64bppArgb;
                            break;
                        default:
                            throw new NotImplementedException(unsupportedDepth);
                    }
                    break;
                default:
                    throw new NotImplementedException(unsupportedChannels);
            }
            Bitmap bitmap = new Bitmap(mi.Width, mi.Height, mi.WidthStep, pixelFormat, mi.ImageData);
            //对于灰度图像，还要修改调色板
            if (pixelFormat == PixelFormat.Format8bppIndexed)
                SetColorPaletteOfGrayscaleBitmap(bitmap);
            return bitmap;
        }
        /// <summary>
        /// 将位图转换成IplImage指针
        /// </summary>
        /// <param name="bitmap">位图对象</param>
        /// <returns>返回IplImage指针</returns>
        public static IntPtr BitmapToIplImagePointer(Bitmap bitmap)
        {
            IImage iimage = null;
            switch (bitmap.PixelFormat)
            {
                case PixelFormat.Format8bppIndexed:
                    iimage = new Image<Gray, Byte>(bitmap);
                    break;
                case PixelFormat.Format16bppGrayScale:
                    iimage = new Image<Gray, UInt16>(bitmap);
                    break;
                case PixelFormat.Format24bppRgb:
                    iimage = new Image<Bgr, Byte>(bitmap);
                    break;
                case PixelFormat.Format32bppArgb:
                    iimage = new Image<Bgra, Byte>(bitmap);
                    break;
                case PixelFormat.Format48bppRgb:
                    iimage = new Image<Bgr, UInt16>(bitmap);
                    break;
                case PixelFormat.Format64bppArgb:
                    iimage = new Image<Bgra, UInt16>(bitmap);
                    break;
                default:
                    Image<Bgra, Byte> tmp1 = new Image<Bgra, Byte>(bitmap.Size);
                    Byte[,,] data = tmp1.Data;
                    for (int i = 0; i < bitmap.Width; i++)
                    {
                        for (int j = 0; j < bitmap.Height; j++)
                        {
                            Color color = bitmap.GetPixel(i, j);
                            data[j, i, 0] = color.B;
                            data[j, i, 1] = color.G;
                            data[j, i, 2] = color.R;
                            data[j, i, 3] = color.A;
                        }
                    }
                    iimage = tmp1;
                    break;
            }
            return iimage.Ptr;
        }
        /// <summary>
        /// 设置256级灰度位图的调色板
        /// </summary>
        /// <param name="bitmap"></param>
        public static void SetColorPaletteOfGrayscaleBitmap(Bitmap bitmap)
        {
            PixelFormat pixelFormat = bitmap.PixelFormat;
            if (pixelFormat == PixelFormat.Format8bppIndexed)
            {
                ColorPalette palette = bitmap.Palette;
                for (int i = 0; i < palette.Entries.Length; i++)
                    palette.Entries[i] = Color.FromArgb(255, i, i, i);
                bitmap.Palette = palette;
            }
        }
        /// <summary>
        /// 将EmguCV中的mat类图像转换成IplImage指针
        /// </summary>
        /// <param name="srcImg">Mat对象</param>
        /// <returns>返回IplImage指针</returns>
        public static IntPtr EmguCVMatToIplImagePointer(Mat srcImg)
        {
            return EmgucvImageToIplImagePointer<Bgr, byte>(srcImg.ToImage<Bgr, byte>());
        }
        /// <summary>
        /// 将IplImage指针转换成EmguCV中的mat类图像
        /// </summary>
        /// <param name="ptr"></param>
        /// <returns></returns>
        public static Mat IplImagePointerToEmgucvMat(IntPtr ptr)
        {
            Mat dstImg = new Mat();
            Image<Bgr, byte> imgTmp = IplImagePointerToEmgucvImage<Bgr, byte>(ptr);
            CvInvoke.BitwiseAnd(imgTmp, imgTmp, dstImg);
            return dstImg;
        }
        #endregion

        private void timer1_Tick(object sender, EventArgs e)
        {
            //lbl_time.Text = DateTime.Now.ToString("dd hh:mm:ss :fff");
        }

        private void button2_Click(object sender, EventArgs e)
        {
            Thread t = new Thread(MatDeal);
            t.IsBackground = true;
            t.Start();
        }
    }
}
卜辞夏问
关注
专栏目录
C#调用opencv的dll
Learning by doing
11-28 2680
opencv算法和界面配合，刚入职的时候尝试过，利用的MFC，调试起来很痛苦。 后来基本都没怎么用界面，DOS的黑窗口，opencv自带的显示界面及滑动条凑合着调试用。 最近有点时间，刚好双十一在一个视觉群里看到了一个讲C#调用opencv的dll的课程，鉴于群主也是那门课的讲师，在平时解答群员的问题的时候很细心，能力也很强，因此有了这篇文章。 根据相机不同动态调用相机默认的属性...
c++ c# opencv dll 调用的方法
maoxue2008的博客
08-18 1460
一，c++dll c#调用  参数传递  需求：C#传递一个路径给C++ DLL ，DLL接口返回一个字符串给C# c++接口定义： int plate_recognize(const char *path, char** out) path为传进的路径，可心为单指针。 out为返回的字符串，必需为双指针 //双指针  通过这样的方式给返回值赋值。 int i = 0;
C#调用C++dll（opencv算法）
weixin_46021786的博客
02-08 3406
pch.h #ifndef PCH_H #define PCH_H #include “framework.h” #endifpch.cpp #include “pch.h” 在配置属性里面找到-常规-公共语言运行时支持（设置为公共语言运行时支持） C++的文件表 C#调用C++opencv代码的效果图C#代码...
C#调用C++、Opencv的Dll
u010647842的博客
08-25 5181
C#调用C++、Opencv的代码可以通过托管和非托管两种形式 非拖管的形式即是采用[DllImport]的形式，这种形式只能调用的C++的函数， 托管的形式用的是ref，可以调用C++类中的方法 首选介绍下非托管的形式： 一、无参数传递下的非托管形式 (1).C++中建立32为dll格式应用程序 (2).新建cpp程序add.cpp 代码如下： extern "C" _decls
C#调用c++编译的opencv文件生成的dll（VS2013+opencv3.1）
予非池物
11-15 1216
1.新建项目 2.源文件---右键 添加---新建项(.cpp) / 头文件---右键 添加---新建项(.h) 3.配置opencv3.1 4..cpp文件中放入自己的程序（只是一个方法，或者一个类，不要main），并且在函数前加如下代码： extern "C" __declspec(dllexport) #include "std...
vs2019 c#调用opencv, c++ 的dll
09-10
vs2019 c#调用opencv, c++ dll的一个demo, 对使用 vs2019, opencv c# ，c++人员有用
c#winform调用OpenCV4.5.4c++dll打开本地或网络摄像头
01-27
c++编译OpenCV生成dll winform调用dll打开本地或网络摄像头 支持海康、大华等网络摄像头
opencv c++生成dll，供c#调用
最新发布
Mapalas的博客
04-27 808
如果dll导出没有函数，C# 调用DLL报无法在DLL "xxxx.dll"中找到名为“xxxx”的入口点错误。1.确保 C++ 项目和 C# 项目都在相同的平台上编译，例如都是 x64 或都是 x86。如果 C++ 项目是以 x64 模式编译的，则确保 C# 项目也是以 x64 模式编译的。本文使用opencv455来实现切图功能的实现，通过c++生成dll，c#中调用。2.确保都是c++是debug，c#也是debug，同理release也要一致。参考下面文章，主要是添加模块定义文件！
c# 调用c++ dll 调用opencv-wechat微信识别二维码。
05-04
本案例中，我们将探讨如何使用C#调用C++编写的DLL，该DLL内部集成了OpenCV库来处理微信二维码的识别。OpenCV是一个强大的计算机视觉库，而微信二维码识别则涉及移动支付和社交应用中的关键功能。 首先，我们需要...
C#调用C++（包括C++的opencv）
11-09
在IT行业中，跨语言编程是常见的...综上所述，C#调用C++，特别是涉及OpenCV这样的库，需要深入了解C++、C#和.NET互操作性，以及内存管理和数据结构转换。通过遵循这些步骤，你可以在C#项目中有效利用C++的OpenCV功能。
c#窗体通过dll调用opencv
10-15
c#窗体通过dll调用opencv的简单示例，可打开图片，以数组形式返回一列像素的值，完整的opencv dll函数编写示例。
C#调用OpenCv 源程序
08-24
一个完整的程序。由C#调用OpenCv实现的DLL，完成播放摄像头的视频。 使用环境opencv2411+VS2012
C#调用Opencv动态库
08-17
利用C#调用C++编写的Opencv程序
opencv 需要的DLL
01-12
opencv 需要的DLL
c#通过dll读取opencv里的mat图片
12-11
c++里通过opencv读取图片后考入内存传出指针给c#，并在picturebox里显示
如何通过C#调用OpenCV函数（自制OpenCV的c++ dll文件）
热门推荐
小小学渣的博客
10-31 1万+
写在前面：学习CUDA过程中看到了可以用OpenCV写一个类，然后直接调用的方法，感觉很有意思（基础太差，可能这是个很基础的问题）。于是就想在 C# 中调用OpenCV的方法，发现有点麻烦，需要生成 .dll（动态链接库）文件，生成过程中出了些小问题，所以把这个过程记录下来，以备以后查看。 首先，你的电脑上需要安装OpenCV，具体安装过程百度即可，并不难（具体可以参见我转载的另一篇OpenCV
c++创建包含opencv的dll供C,C#调用
duiwangxiaomi的博客
07-02 1686
转 最近，接到了一个小任务，就是创建一个c++的dll，供c#调用。 dll又称动态链接库，其好处有很多，主要提供接口，供项目调用。 其中，要写一个函数，输入一张图片的路径，之后显示图像，并返回字符串，成功打开图像，返回“open”，失败则返回“can not open”。但是在编写过程中也出了一些问题，当参数以及返回值类型为string时，c#端会报“访问受保护的内存”，查了很多的相关资...
c#调用c++ OpenCv dll的教程
zp247030438的博客
04-15 1134
c#应用程序调用opencv(c++).dll
opencv的c++程序封装成dll用c#调用，遇见的问题
予非池物
11-29 1650
先看文章最后一句话 1.问题一：无法加载DLL，找不到指定的模块 解决办法：把你用的dll放在你自己程序的启动路径下。比如bin/debug/....或者x64/debug/..... 如果不知道应该放哪里，就都试试哪个文件夹都试试，再一个一个删除，看看哪个会影响程序运行，就是这个文件夹了 问题二：试图加载格式不正确的程序 解决办法：因为平台设置不正确，看看你的平台是什么，...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值