【VM服务管家】专题_7.3 图像转换

最新推荐文章于 2023-05-19 09:37:12 发布
最新推荐文章于 2023-05-19 09:37:12 发布
阅读量1.3k 收藏 12
点赞数 7
分类专栏： VM服务管家 文章标签： 计算机视觉 人工智能 图像处理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MVExpert/article/details/130413657
版权

目录

3.1 图像转换扫盲篇（CSharp）

描述
环境：VM4.2 + VS2013及以上
现象：相机、VM脚本、VM SDK、算子SDK、算法模块中的图像类型是什么？
解答

  1. 图像格式一览
    除了Bitmap、Mat和Halcon中的图像类型，在VM和开发（开发包含三种：VM SDK开发（也称VM二次开发）算子SDK开发、自定义算法模块开发）中涉及的图像类型如下：
    相机：图像数据流（此处图像数据流类型是MyCamera.MV_FRAME_OUT，是来自MvCameraControl.Net.dll，即海康机器人工业相机SDK，在MVS SDK和算子SDK中都有这个dll；算子SDK的MVDCamera.Net.dll也可以进行相机取流，它是对MvCameraControl.Net.dll的二次封装，用MVDCamera.Net.dll时，图像数据流类型是CMvdImage）；
    VM：脚本输入图像（图像类型是ImageData）；
    VM SDK：流程输入图像（ImageBaseData_V2，VM4.2 SDK新增）、Group输入图像（ImageBaseData_V2，VM4.2 SDK新增）、图像源SDK输入图像（ImageBaseData）、模块输入图像（InputImageData）、流程输出图像（区分VM4.0 SDK和VM4.2 SDK的获取输出图像的方式，VM4.2获取流程图像的类型是ImageBaseData_V2） ；
    算子SDK：输入图像(CMvdImage)；
    算法模块：输入图像(HKA_IMAGE，是C++中图像类型)。
  2. 图像类型转换（含单通道和三通道图像）三通道的Bitmap、Mat为BGR，三通道的VM和二次开发为RGB，针对常用图像转换场景，列举如下（见3.2~3.6）。篇幅所致，后续每种图像转换用函数表达，函数输入某种图像类型，返回转换后的某种图像类型。

3.2 相机采图转流程输入、Group输入、图像源SDK输入、模块输入、算子输入图像

描述
环境：VM4.2 + VS2013及以上
现象：相机采图转换成其他图像类型
解答
相机采图（MyCamera.MV_FRAME_OUT）转换为流程输入图像、Group输入图像、图像源SDK输入图像、模块输入图像、算子输入图像。
1 相机采图转流程输入（ImageBaseData_V2）、Group输入（ImageBaseData_V2）

public ImageBaseData_V2 CCDToImageBaseDataV2(MyCamera.MV_FRAME_OUT frameOut)
{
    ImageBaseData_V2 imageBaseDataV2 = new ImageBaseData_V2();
    if (frameOut.stFrameInfo.enPixelType == MyCamera.MvGvspPixelType.PixelType_Gvsp_Mono8)
    {
        imageBaseDataV2 = new ImageBaseData_V2(frameOut.pBufAddr, frameOut.stFrameInfo.nFrameLen, frameOut.stFrameInfo.nWidth, frameOut.stFrameInfo.nHeight, VMPixelFormat.VM_PIXEL_MONO_08);
    }
    else if (frameOut.stFrameInfo.enPixelType == MyCamera.MvGvspPixelType.PixelType_Gvsp_RGB8_Packed)
    {
        imageBaseDataV2 = new ImageBaseData_V2(frameOut.pBufAddr, frameOut.stFrameInfo.nFrameLen, frameOut.stFrameInfo.nWidth, frameOut.stFrameInfo.nHeight, VMPixelFormat.VM_PIXEL_RGB24_C3);
    }

    return imageBaseDataV2;
}
var image = CCDToImageBaseDataV2(stFrameOut);
//设置到流程
var procedure = VmSolution.Instance["流程1"] as VmProcedure;
procedure.ModuParams.SetInputImage_V2("ImageData", image);
//设置到Group
var group = VmSolution.Instance["流程1.组合模块1"] as IMVSGroupTool;
group.ModuParams.SetInputImage_V2("ImageData", image);

2 相机采图转图像源SDK输入（ImageBaseData）

public ImageBaseData CCDToImageBaseData(MyCamera.MV_FRAME_OUT frameOut)
{
    ImageBaseData imageBaseData = new ImageBaseData();
    imageBaseData.Width = frameOut.stFrameInfo.nWidth;
    imageBaseData.Height = frameOut.stFrameInfo.nHeight;
    imageBaseData.DataLen = frameOut.stFrameInfo.nFrameLen;
    if (frameOut.stFrameInfo.enPixelType == MyCamera.MvGvspPixelType.PixelType_Gvsp_Mono8)
    {
        imageBaseData.Pixelformat = (int)VMPixelFormat.VM_PIXEL_MONO_08;
    }
    else if (frameOut.stFrameInfo.enPixelType == MyCamera.MvGvspPixelType.PixelType_Gvsp_RGB8_Packed)
    {
        imageBaseData.Pixelformat = (int)VMPixelFormat.VM_PIXEL_RGB24_C3;
    }
    imageBaseData.ImageData = new byte[frameOut.stFrameInfo.nFrameLen];
    Marshal.Copy(frameOut.pBufAddr, imageBaseData.ImageData, 0, (int)frameOut.stFrameInfo.nFrameLen);
    return imageBaseData;
}
var image = CCDToImageBaseData(stFrameOut);
//设置到图像源
ImageSourceModuleTool imageSourceModuleTool = (ImageSourceModuleTool)VmSolution.Instance["流程1.图像源1"];
imageSourceModuleTool.SetImageData(image);

3 相机采图转模块输入（InputImageData）

public InputImageData CCDToInputImageData(MyCamera.MV_FRAME_OUT frameOut)
{
    InputImageData inputImageData = new InputImageData();
    inputImageData.Names.DataName = "InImage";//只能使用默认名称InImage
    inputImageData.Names.HeightName = "InImageHeight";//默认InImageHeight
    inputImageData.Names.WidthName = "InImageWidth";//默认InImageWidth
    inputImageData.Names.PixelFormatName = "InImagePixelFormat";//默认InImagePixelFormat
    inputImageData.Width = frameOut.stFrameInfo.nWidth;
    inputImageData.Height = frameOut.stFrameInfo.nHeight;
    inputImageData.DataLen = frameOut.stFrameInfo.nFrameLen;

    if (frameOut.stFrameInfo.enPixelType == MyCamera.MvGvspPixelType.PixelType_Gvsp_Mono8)
    {
        inputImageData.Pixelformat = ImagePixelFormat.IMAGE_PIXEL_FORMAT_MONO8;

    }
    else if (frameOut.stFrameInfo.enPixelType == MyCamera.MvGvspPixelType.PixelType_Gvsp_RGB8_Packed)
    {
        inputImageData.Pixelformat = ImagePixelFormat.IMAGE_PIXEL_FORMAT_RGB24;
    }
    //申请内存
    inputImageData.Data = Marshal.AllocHGlobal((int)frameOut.stFrameInfo.nFrameLen);
    byte[] imagedataBuffer = new byte[(int)frameOut.stFrameInfo.nFrameLen];
    Marshal.Copy(frameOut.pBufAddr, imagedataBuffer, 0, (int)frameOut.stFrameInfo.nFrameLen);
    Marshal.Copy(imagedataBuffer, 0, inputImageData.Data, (int)frameOut.stFrameInfo.nFrameLen);
    return inputImageData;
}
var image= CCDToInputImageData(stFrameOut);
//设置到模块        
var circlefindTool = VmSolution.Instance["流程1.圆查找1"] as IMVSImageEnhanceModuCs.IMVSImageEnhanceModuTool;
circlefindTool.ModuParams.SetInputImage(image);

4 相机采图转算子输入（CmvdImage）

public CMvdImage CCDToCMvdImage(MyCamera.MV_FRAME_OUT frameOut)
{
    VisionDesigner.CMvdImage cMvdImage = new VisionDesigner.CMvdImage();
    VisionDesigner.MVD_IMAGE_DATA_INFO stImageData = new VisionDesigner.MVD_IMAGE_DATA_INFO();
    stImageData.stDataChannel[0].nLen = (uint)(frameOut.stFrameInfo.nFrameLen);
    stImageData.stDataChannel[0].nSize = (uint)(frameOut.stFrameInfo.nFrameLen);
    byte[] m_BufForDriver1 = new byte[frameOut.stFrameInfo.nFrameLen];
    //数据Copy
    Marshal.Copy(frameOut.pBufAddr, m_BufForDriver1, 0, (int)frameOut.stFrameInfo.nFrameLen);
    stImageData.stDataChannel[0].arrDataBytes = m_BufForDriver1;
    if (frameOut.stFrameInfo.enPixelType == MyCamera.MvGvspPixelType.PixelType_Gvsp_Mono8)
    {
        stImageData.stDataChannel[0].nRowStep = (uint)frameOut.stFrameInfo.nWidth;
        //初始化CMvdImage
        cMvdImage.InitImage((uint)frameOut.stFrameInfo.nWidth, (uint)frameOut.stFrameInfo.nHeight, MVD_PIXEL_FORMAT.MVD_PIXEL_MONO_08, stImageData);
    }
    else if (frameOut.stFrameInfo.enPixelType == MyCamera.MvGvspPixelType.PixelType_Gvsp_RGB8_Packed)
    {
        stImageData.stDataChannel[0].nRowStep = (uint)frameOut.stFrameInfo.nWidth * 3;
        //初始化CMvdImage
        cMvdImage.InitImage((uint)frameOut.stFrameInfo.nWidth, (uint)frameOut.stFrameInfo.nHeight, MVD_PIXEL_FORMAT.MVD_PIXEL_RGB_RGB24_C3, stImageData);
    }
    return cMvdImage;
}

问题根因
不熟悉相机采图转换为其它类型

3.3 Bitmap转流程输入、Group输入、图像源SDK输入、模块输入、算子输入、算子输出、流程输出图像

描述
环境：VM4.2 + VS2013及以上
现象：Bitmap转换成其他图像类型
解答
Bitmap转换为流程输入图像、Group输入图像、图像源SDK输入图像、模块输入图像、算子输入图像，流程输出图像转换为Bitmap。
1 Bitmap转流程输入（ImageBaseData_V2）、Group输入（ImageBaseData_V2）

public ImageBaseData_V2 BitmapToImageBaseData_V2(Bitmap bmpInputImg)
{
    ImageBaseData_V2 imageBaseData_V2 = new ImageBaseData_V2();
    System.Drawing.Imaging.PixelFormat bitPixelFormat = bmpInputImg.PixelFormat;
    BitmapData bmData = bmpInputImg.LockBits(new Rectangle(0, 0, bmpInputImg.Width, bmpInputImg.Height), ImageLockMode.ReadOnly, bitPixelFormat);//锁定

    if (bitPixelFormat == System.Drawing.Imaging.PixelFormat.Format8bppIndexed)
    {
        Int32 bitmapDataSize = bmData.Stride * bmData.Height;//bitmap图像缓存长度
        int offset = bmData.Stride - bmData.Width;
        Int32 ImageBaseDataSize = bmData.Width * bmData.Height;//imageBaseData_V2图像真正的缓存长度
        byte[] _BitImageBufferBytes = new byte[bitmapDataSize];
        byte[] _ImageBaseDataBufferBytes = new byte[ImageBaseDataSize];
        Marshal.Copy(bmData.Scan0, _BitImageBufferBytes, 0, bitmapDataSize);
        int bitmapIndex = 0;
        int ImageBaseDataIndex = 0;
        for (int i = 0; i < bmData.Height; i++)
        {
            for (int j = 0; j < bmData.Width; j++)
            {
                _ImageBaseDataBufferBytes[ImageBaseDataIndex++] = _BitImageBufferBytes[bitmapIndex++];
            }
            bitmapIndex += offset;//删除冗余数据
        }
        IntPtr _ImageBaseDataIntptr = Marshal.AllocHGlobal(ImageBaseDataSize);
        Marshal.Copy(_ImageBaseDataBufferBytes, 0, _ImageBaseDataIntptr, ImageBaseDataSize);
        imageBaseData_V2 = new ImageBaseData_V2(_ImageBaseDataIntptr, (uint)ImageBaseDataSize, bmData.Width, bmData.Height, VMPixelFormat.VM_PIXEL_MONO_08);
        Marshal.FreeHGlobal(_ImageBaseDataIntptr);
    }
    else if (bitPixelFormat == System.Drawing.Imaging.PixelFormat.Format24bppRgb)
    {
        Int32 bitmapDataSize = bmData.Stride * bmData.Height;//bitmap图像缓存长度
        int offset = bmData.Stride - bmData.Width * 3;
        Int32 ImageBaseDataSize = bmData.Width * bmData.Height * 3;//imageBaseData_V2图像真正的缓存长度
        byte[] _BitImageBufferBytes = new byte[bitmapDataSize];
        byte[] _ImageBaseDataBufferBytes = new byte[ImageBaseDataSize];
        Marshal.Copy(bmData.Scan0, _BitImageBufferBytes, 0, bitmapDataSize);
        int bitmapIndex = 0;
        int ImageBaseDataIndex = 0;
        for (int i = 0; i < bmData.Height; i++)
        {
            for (int j = 0; j < bmData.Width; j++)
            {
                _ImageBaseDataBufferBytes[ImageBaseDataIndex++] = _BitImageBufferBytes[bitmapIndex + 2];//bitmap为BGR，imageBaseData_V2为RGB
                _ImageBaseDataBufferBytes[ImageBaseDataIndex++] = _BitImageBufferBytes[bitmapIndex + 1];
                _ImageBaseDataBufferBytes[ImageBaseDataIndex++] = _BitImageBufferBytes[bitmapIndex];
                bitmapIndex += 3;
            }
            bitmapIndex += offset;
        }
        IntPtr _ImageBaseDataIntptr = Marshal.AllocHGlobal(ImageBaseDataSize);
        Marshal.Copy(_ImageBaseDataBufferBytes, 0, _ImageBaseDataIntptr, ImageBaseDataSize);
        imageBaseData_V2 = new ImageBaseData_V2(_ImageBaseDataIntptr, (uint)ImageBaseDataSize, bmData.Width, bmData.Height, VMPixelFormat.VM_PIXEL_RGB24_C3);
        Marshal.FreeHGlobal(_ImageBaseDataIntptr);
}
bmpInputImg.UnlockBits(bmData);  // 解除锁定
    return imageBaseData_V2;
}

2 Bitmap转图像源SDK输入（ImageBaseData）

public ImageBaseData BitmapToImageBaseData(Bitmap bmpInputImg)
{
    ImageBaseData imageBaseData = new ImageBaseData();
    System.Drawing.Imaging.PixelFormat bitPixelFormat = bmpInputImg.PixelFormat;
    BitmapData bmData = bmpInputImg.LockBits(new Rectangle(0, 0, bmpInputImg.Width, bmpInputImg.Height), ImageLockMode.ReadOnly, bitPixelFormat);//锁定

    if (bitPixelFormat == System.Drawing.Imaging.PixelFormat.Format8bppIndexed)
    {
        Int32 bitmapDataSize = bmData.Stride * bmData.Height;//bitmap图像缓存长度
        int offset = bmData.Stride - bmData.Width;
        Int32 ImageBaseDataSize = bmData.Width * bmData.Height;
        byte[] _BitImageBufferBytes = new byte[bitmapDataSize];
        byte[] _ImageBaseDataBufferBytes = new byte[ImageBaseDataSize];
        Marshal.Copy(bmData.Scan0, _BitImageBufferBytes, 0, bitmapDataSize);
        int bitmapIndex = 0;
        int ImageBaseDataIndex = 0;
        for (int i = 0; i < bmData.Height; i++)
        {
            for (int j = 0; j < bmData.Width; j++)
            {
                _ImageBaseDataBufferBytes[ImageBaseDataIndex++] = _BitImageBufferBytes[bitmapIndex++];
            }
            bitmapIndex += offset;
        }
        imageBaseData = new ImageBaseData(_ImageBaseDataBufferBytes, (uint)ImageBaseDataSize, bmData.Width, bmData.Height, (int)VMPixelFormat.VM_PIXEL_MONO_08);
    }
    else if (bitPixelFormat == System.Drawing.Imaging.PixelFormat.Format24bppRgb)
    {
        Int32 bitmapDataSize = bmData.Stride * bmData.Height;//bitmap图像缓存长度
        int offset = bmData.Stride - bmData.Width * 3;
        Int32 ImageBaseDataSize = bmData.Width * bmData.Height * 3;
        byte[] _BitImageBufferBytes = new byte[bitmapDataSize];
        byte[] _ImageBaseDataBufferBytes = new byte[ImageBaseDataSize];
        Marshal.Copy(bmData.Scan0, _BitImageBufferBytes, 0, bitmapDataSize);
        int bitmapIndex = 0;
        int ImageBaseDataIndex = 0;
        for (int i = 0; i < bmData.Height; i++)
        {
            for (int j = 0; j < bmData.Width; j++)
            {
                _ImageBaseDataBufferBytes[ImageBaseDataIndex++] = _BitImageBufferBytes[bitmapIndex + 2];
                _ImageBaseDataBufferBytes[ImageBaseDataIndex++] = _BitImageBufferBytes[bitmapIndex + 1];
                _ImageBaseDataBufferBytes[ImageBaseDataIndex++] = _BitImageBufferBytes[bitmapIndex];
                bitmapIndex += 3;
            }
            bitmapIndex += offset;
        }
        imageBaseData = new ImageBaseData(_ImageBaseDataBufferBytes, (uint)ImageBaseDataSize, bmData.Width, bmData.Height, (int)VMPixelFormat.VM_PIXEL_RGB24_C3);
}
bmpInputImg.UnlockBits(bmData);  // 解除锁定
    return imageBaseData;
}

3 Bitmap转模块输入（InputImageData）

public InputImageData BitmapToInputImageData(Bitmap bmpInputImg)
{
    InputImageData inputImageData = new InputImageData();
    System.Drawing.Imaging.PixelFormat bitPixelFormat = bmpInputImg.PixelFormat;
    BitmapData bmData = bmpInputImg.LockBits(new Rectangle(0, 0, bmpInputImg.Width, bmpInputImg.Height), ImageLockMode.ReadOnly, bitPixelFormat);//锁定

    inputImageData.Names.DataName = "InImage";//只能使用默认名称InImage
    inputImageData.Names.HeightName = "InImageHeight";//默认InImageHeight
    inputImageData.Names.WidthName = "InImageWidth";//默认InImageWidth
    inputImageData.Names.PixelFormatName = "InImagePixelFormat";//默认InImagePixelFormat
    inputImageData.Width = bmData.Width;
    inputImageData.Height = bmData.Height;

    if (bitPixelFormat == System.Drawing.Imaging.PixelFormat.Format8bppIndexed)
    {
        Int32 bitmapDataSize = bmData.Stride * bmData.Height;//bitmap图像缓存长度
        int offset = bmData.Stride - bmData.Width;
        Int32 ImageBaseDataSize = bmData.Width * bmData.Height;
        byte[] _BitImageBufferBytes = new byte[bitmapDataSize];
        byte[] _ImageBaseDataBufferBytes = new byte[ImageBaseDataSize];
        Marshal.Copy(bmData.Scan0, _BitImageBufferBytes, 0, bitmapDataSize);
        int bitmapIndex = 0;
        int ImageBaseDataIndex = 0;
        for (int i = 0; i < bmData.Height; i++)
        {
            for (int j = 0; j < bmData.Width; j++)
            {
                _ImageBaseDataBufferBytes[ImageBaseDataIndex++] = _BitImageBufferBytes[bitmapIndex++];
            }
            bitmapIndex += offset;
        }
        inputImageData.Pixelformat = ImagePixelFormat.IMAGE_PIXEL_FORMAT_MONO8;
        inputImageData.DataLen = (uint)ImageBaseDataSize;
        inputImageData.Data = Marshal.AllocHGlobal(ImageBaseDataSize);//inputImageData.Data需要申请内存;
        Marshal.Copy(_ImageBaseDataBufferBytes, 0, inputImageData.Data, _ImageBaseDataBufferBytes.Length);
    }
    else if (bitPixelFormat == System.Drawing.Imaging.PixelFormat.Format24bppRgb)
    {
        Int32 bitmapDataSize = bmData.Stride * bmData.Height;//bitmap图像缓存长度
        int offset = bmData.Stride - bmData.Width * 3;
        Int32 ImageBaseDataSize = bmData.Width * bmData.Height * 3;
        byte[] _BitImageBufferBytes = new byte[bitmapDataSize];
        byte[] _ImageBaseDataBufferBytes = new byte[ImageBaseDataSize];
        Marshal.Copy(bmData.Scan0, _BitImageBufferBytes, 0, bitmapDataSize);
        int bitmapIndex = 0;
        int ImageBaseDataIndex = 0;
        for (int i = 0; i < bmData.Height; i++)
        {
            for (int j = 0; j < bmData.Width; j++)
            {
                _ImageBaseDataBufferBytes[ImageBaseDataIndex++] = _BitImageBufferBytes[bitmapIndex + 2];
                _ImageBaseDataBufferBytes[ImageBaseDataIndex++] = _BitImageBufferBytes[bitmapIndex + 1];
                _ImageBaseDataBufferBytes[ImageBaseDataIndex++] = _BitImageBufferBytes[bitmapIndex];
                bitmapIndex += 3;
            }
            bitmapIndex += offset;
        }
        inputImageData.Pixelformat = ImagePixelFormat.IMAGE_PIXEL_FORMAT_RGB24;
        inputImageData.DataLen = (uint)ImageBaseDataSize;
        inputImageData.Data = Marshal.AllocHGlobal(ImageBaseDataSize);//inputImageData.Data需要申请内存;
        Marshal.Copy(_ImageBaseDataBufferBytes, 0, inputImageData.Data, _ImageBaseDataBufferBytes.Length);
    }
    bmpInputImg.UnlockBits(bmData);  // 解除锁定
    return inputImageData;
}

4 Bitmap与算子（CmvdImage）互转

public CMvdImage BitmapToCMvdImage(Bitmap bmpInputImg)
{
    CMvdImage cMvdImage = new CMvdImage();
    System.Drawing.Imaging.PixelFormat bitPixelFormat = bmpInputImg.PixelFormat;
    BitmapData bmData = bmpInputImg.LockBits(new Rectangle(0, 0, bmpInputImg.Width, bmpInputImg.Height), ImageLockMode.ReadOnly, bitPixelFormat);//锁定

    if (bitPixelFormat == System.Drawing.Imaging.PixelFormat.Format8bppIndexed)
    {
        Int32 bitmapDataSize = bmData.Stride * bmData.Height;//bitmap图像缓存长度
        int offset = bmData.Stride - bmData.Width;
        Int32 ImageBaseDataSize = bmData.Width * bmData.Height;
        byte[] _BitImageBufferBytes = new byte[bitmapDataSize];
        byte[] _ImageBaseDataBufferBytes = new byte[ImageBaseDataSize];
        Marshal.Copy(bmData.Scan0, _BitImageBufferBytes, 0, bitmapDataSize);
        int bitmapIndex = 0;
        int ImageBaseDataIndex = 0;
        for (int i = 0; i < bmData.Height; i++)
        {
            for (int j = 0; j < bmData.Width; j++)
            {
                _ImageBaseDataBufferBytes[ImageBaseDataIndex++] = _BitImageBufferBytes[bitmapIndex++];
            }
            bitmapIndex += offset;
        }
        MVD_IMAGE_DATA_INFO stImageData = new MVD_IMAGE_DATA_INFO();
        stImageData.stDataChannel[0].nRowStep = (uint)bmData.Width;
        stImageData.stDataChannel[0].nLen = (uint)ImageBaseDataSize;
        stImageData.stDataChannel[0].nSize = (uint)ImageBaseDataSize;
        stImageData.stDataChannel[0].arrDataBytes = _ImageBaseDataBufferBytes;
        cMvdImage.InitImage((uint)bmData.Width, (uint)bmData.Height, MVD_PIXEL_FORMAT.MVD_PIXEL_MONO_08, stImageData);
    }
    else if (bitPixelFormat == System.Drawing.Imaging.PixelFormat.Format24bppRgb)
    {
        Int32 bitmapDataSize = bmData.Stride * bmData.Height;//bitmap图像缓存长度
        int offset = bmData.Stride - bmData.Width * 3;
        Int32 ImageBaseDataSize = bmData.Width * bmData.Height * 3;
        byte[] _BitImageBufferBytes = new byte[bitmapDataSize];
        byte[] _ImageBaseDataBufferBytes = new byte[ImageBaseDataSize];
        Marshal.Copy(bmData.Scan0, _BitImageBufferBytes, 0, bitmapDataSize);
        int bitmapIndex = 0;
        int ImageBaseDataIndex = 0;
        for (int i = 0; i < bmData.Height; i++)
        {
            for (int j = 0; j < bmData.Width; j++)
            {
                _ImageBaseDataBufferBytes[ImageBaseDataIndex++] = _BitImageBufferBytes[bitmapIndex + 2];
                _ImageBaseDataBufferBytes[ImageBaseDataIndex++] = _BitImageBufferBytes[bitmapIndex + 1];
                _ImageBaseDataBufferBytes[ImageBaseDataIndex++] = _BitImageBufferBytes[bitmapIndex];
                bitmapIndex += 3;
            }
            bitmapIndex += offset;
        }
        MVD_IMAGE_DATA_INFO stImageData = new MVD_IMAGE_DATA_INFO();
        stImageData.stDataChannel[0].nRowStep = (uint)bmData.Width * 3;
        stImageData.stDataChannel[0].nLen = (uint)ImageBaseDataSize;
        stImageData.stDataChannel[0].nSize = (uint)ImageBaseDataSize;
        stImageData.stDataChannel[0].arrDataBytes = _ImageBaseDataBufferBytes;
        cMvdImage.InitImage((uint)bmData.Width, (uint)bmData.Height, MVD_PIXEL_FORMAT.MVD_PIXEL_RGB_RGB24_C3, stImageData);
    }
    bmpInputImg.UnlockBits(bmData);  // 解除锁定
    return cMvdImage;
}
public Bitmap CMvdImageToBitmap(CMvdImage cMvdImage)
{
    Bitmap bmpInputImg= null;
    byte[] buffer = new byte[cMvdImage.GetImageData(0).arrDataBytes.Length];
    buffer = cMvdImage.GetImageData(0).arrDataBytes;

    if (MVD_PIXEL_FORMAT.MVD_PIXEL_MONO_08 == cMvdImage.PixelFormat)
    {
        Int32 imageWidth = Convert.ToInt32(cMvdImage.Width);
        Int32 imageHeight = Convert.ToInt32(cMvdImage.Height);
        System.Drawing.Imaging.PixelFormat bitMaPixelFormat = System.Drawing.Imaging.PixelFormat.Format8bppIndexed;
        bmpInputImg = new Bitmap(imageWidth, imageHeight, bitMaPixelFormat);
        int offset = imageWidth % 4 != 0 ? (4 - imageWidth % 4) : 0;//添加冗余位，变成4的倍数
        int strid = imageWidth + offset;
        int bitmapBytesLenth = strid * imageHeight;
        byte[] bitmapDataBytes = new byte[bitmapBytesLenth];
        for (
最低0.47元/天 解锁文章
大话视觉
关注
专栏目录
海康机器人工业视觉相机SDK的CImage图像转VM算子CMvdImage图像封装函数 C#
04-11
将海康工业相机SDK去图所得的CImage图像转换为海康VM算子能用的CMvdImage图像。已经封装好函数，可以直接调用。转换流程讲解查找我对应的博客。如果需要相机算子中别的图像转换也可以参照这个函数，过程是一样的，只是内部参数修改一下。
VM图像类型转换专题（C#篇）
让视觉应用更轻松
10-15 3996
当前行业主流的图像格式包括相机图像数据流、Bitmap、Mat和Halcon中的图像类型等，而VM不同开发模式的图像类型也有所不同，本文将介绍如何实现这些图像类型之间的互转。
利用相机SDK采相转换至HImage
好习惯成就伟大
12-05 2225
Halcon采相功能非常强大，基本支持各大品牌以及各个通信接口的相机，并且Halcon提供为相机厂商提供了制作Halcon相机接口库的办法，总之Halcon基本可以直接连接所有工业相机。 但是Halcon连接相机采相存在两个问题：一是相机参数可调整范围有限，不如相机的SDK提供的可调参数多；二是相机SDK提供了采相回调函数，采相实时性更好（Halcon下也可回调，没...
u-boot FIT image介绍
kunkliu的博客
05-08 1075
1. 前言 Linux kernel在ARM架构中引入device tree（全称是flattened device tree，后续将会以FDT代称）的时候[1]，其实怀揣了一个Unify Kernel的梦想----同一个Image，可以支持多个不同的平台。随着新的ARM64架构将FDT列为必选项，并将和体系结构有关的代码剥离之后，这个梦想已经接近实现： 在编译linux kernel的时候，不必特意的指定具体的架构和SOC，只需要告诉kernel本次编译需要支持哪些板级的platform即可，最终将
halcon 导出C++程序与visualstdio2019配置环境，在控制台显示一张图片
Bishop077的博客
10-02 2636
halcon 导出c++在vs2019控制到窗口运行黑屏问题
香橙派基于翔云的人脸识别
qq_58744641的博客
08-25 1166
首先将USB摄像头插入到香橙派的USB接口中然后通过lsmod命令可以看到内核自动加载了下面的模块3.安装fswebcam安装完fswebcam后可以使用下面的命令来拍照-d选项用于指定 USB 摄像头的设备节点用于去除照片的水印-r选项用于指定照片的分辨率-S选项用设置于跳过前面的帧数用于设置生成的照片的名字和路径拍完照后可以将拍好的图片传到电脑上观看。注意：在执行程序前需要在执行文件的路径先保存有一张用来识别的图片。...
process_vm_access.rar_vm Read
09-23
在Linux系统中，`process_vm_access`是一个内核函数，主要负责处理进程间虚拟内存的访问。这个功能允许一个进程去读取或者写入另一个进程的虚拟内存空间，但其权限受到严格的限制，通常用于调试、监控或者安全相关的...
vm_tools_15.5.0
04-19
该文件为 vm15.5.0对应的tool,包含linux和windows两个版本tool, 适用于15.5.x系列! 其它版本下载方式参考笔者博文(1->1.12): https://blog.csdn.net/u011127242/article/details/88882164
vmmc.rar_Mirror Mirror
09-23
标题中的“vmmc.rar_Mirror Mirror”提示我们这是一个与镜像技术相关的压缩文件，特别是针对Linux系统的。描述中提到的“Mirror set structures for Linux v2.13.6”表明这是关于Linux内核版本2.13.6的磁盘镜像集的...
Oracle_VM_VirtualBox_Extension_Pack-5.2.22最新版
11-14
Oracle_VM_VirtualBox_Extension_Pack-5.2.22，用于VirtualBox外接移动设备识别
VM安装清理工具_VM_Install_Cleaner.exe
11-27
此时，"VM安装清理工具_VM_Install_Cleaner.exe"就能发挥重要作用。 "VM安装清理工具"是一款专门针对VMware产品的卸载辅助软件，它能够帮助用户干净利落地移除VMware的组件，确保系统中不再有遗留的文件和设置。这...
zw版【转发·台湾nvp系列Delphi例程】HALCON HighpassImage
weixin_34309543的博客
10-01 129
zw版【转发·台湾nvp系列Delphi例程】HALCON HighpassImage unit Unit1;interfaceuses Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms, Dialogs, StdCtrls, OleCtrls, HALCONXLib_TLB;type...
DHFS读写流程
qq_70085330的博客
06-02 526
目录 一、HDFS写数据流程 二、节点距离计算 三、副本节点选择 四、HDFS读数据流程 23天 面试重点 一、HDFS写数据流程 流程图：（图片来源于尚硅谷） 流程图解析: 1、客户端通过 Distributed FileSystem 模块向 NameNode 请求上传文件，NameNode 检查目标文件是否已存在，父目录是否存在。 2、NameNode 返回是否可以上传。 3、客户端请求第一个Block上传到哪几个DataNode服务器上。 4、NameNode..
TX2 读取海康/大恒工业摄像头 显示/保存
highoooo的博客
05-30 1395
1 MVS下载或SDK下载 在海康机器人官网，服务支持-软件下载中间中，下载相应的客户端安装包。 2 放到TX2目录下解压并安装 sudo tar –xvf MVS-2.1.1_aarch64_20220511.tar sudo ./setup.sh 3.c/c++ 库文件和头文件都在opt/MVS/下 4.samples里面可以直接make就可以玩了 5.读取工业摄像头并用转为cv::Mat用yolov5-trt推理 5.1 cmakelists cmake_minimum_required(VER
海康MVS相机取图传入VisionMaster图像源模块
最新发布
weixin_43165677的博客
05-19 1219
海康MVS与VisionMaster SDK使用踩坑记录。
【VM服务管家】VM4.2平台SDK_6.2 模块操作类
让视觉应用更轻松
05-03 977
打开流程的配置窗口，获取流程1的输出图像，将其设置为流程2的输入图像，虽然在VM中可以通过连线的方式实现，但也可以通过代码的方式实现，C#代码如下。另外，通过Group设置输入输出图像也是调用同样的接口函数SetInputImage_V2()和GetOutputImageV2()，其中要注意的是，当用代码给流程输入图像时，流程中的其它模块的图像输入源需要订阅流程的图像参数。注意：设置输入参数（基本参数），参数配置窗口界面不会显示所设置的参数，此时模块运行，参数永久有效，流程运行，参数一次有效；
抖音3D旋转相册 （源码下载）
热门推荐
qq_43541242的博客
07-17 2万+
先来看效果 （图片我随便找的，相信我用你的图片替换会更好看！哈哈） 自己实现步骤（当然你可以下载我提供的替换一下里面的照片） 页面编写.新建index.html文件，里面写如下代码！就这一页代码就行了！ <!DOCTYPE html> <html> <head> <meta charset="UTF-8"> <title>Bootstrap Template</title> <meta name="view
VM图像类型转换专题（C++）
让视觉应用更轻松
01-18 704
当前行业主流的图像格式包括相机图像数据流、QImage、Mat和Halcon中的图像类型等，而VM不同开发模式的图像类型也有所不同，本文将介绍如何实现这些图像类型之间的互转。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值