C++ 下 OpenCV 的 Mat 与 Halcon 的 HObject 之间转换，位图 byte 格式或 3D 深度图 real 格式

Mat 转 HObject 的相关代码，位图 byte 格式或是深度图 real 格式，深度图表示为 3D 高度图，将高度信息存放在 HObject 里面。

//Mat转HObject
HObject HMatToHObject(cv::Mat image)
{
    HObject ho_obj=HObject();
    if(image.empty())
        return ho_obj;
    //3通道
    if(3==image.channels())
    {
        int w=image.cols;
        int h=image.rows;
        //byte位图
        if(image.depth()==CV_8U)
        {
            vector<cv::Mat> ichannels;
            cv::Mat imagB;
            cv::Mat imagG;
            cv::Mat imagR;
            cv::split(image, ichannels);
            imagB=ichannels.at(0);
            imagG=ichannels.at(1);
            imagR=ichannels.at(2);
            uchar* dataRed=new uchar[w*h];
            uchar* dataGreen=new uchar[w*h];
            uchar* dataBlue=new uchar[w*h];
            for(int i=0;i<h;i++)
            {
                memcpy(dataRed + w*i, imagR.ptr() + imagR.step*i, w);
                memcpy(dataGreen + w*i, imagG.ptr() + imagG.step*i, w);
                memcpy(dataBlue + w*i, imagB.ptr() + imagB.step*i, w);
            }
            GenImage3(&ho_obj, "byte", w, h, (Hlong)(dataRed), (Hlong)(dataGreen), (Hlong)(dataBlue));
            delete[] dataRed;
            delete[] dataGreen;
            delete[] dataBlue;
        }
        //深度图real
        else if(image.depth()==CV_32F)
        {
            HObject ho_X, ho_Y, ho_Z, ho_Rect;
            HTuple hv_Rows, hv_Cols, hv_Gray;
            GenImageConst(&ho_X, "real", w, h);
            GenImageConst(&ho_Y, "real", w, h);
            GenImageConst(&ho_Z, "real", w, h);
            Compose3(ho_X, ho_Y, ho_Z, &ho_obj);
            int* rows=new int[w * h];
            int* cols=new int[w * h];
            double* dGray=new double[3 * w * h];
            int k=0;
            for(int y=0;y<h;y++)
            {
                Vec3f* ptr=image.ptr<Vec3f>(y);
                for(int x=0;x<w;x++)
                {
                    float xx=ptr[x][0];
                    float yy=ptr[x][1];
                    float zz=ptr[x][2];
                    if(xx==0.0 && yy==0.0 && zz==0.0)
                        continue;
                    dGray[k*3]=xx;
                    dGray[k*3 + 1]=yy;
                    dGray[k*3 + 2]=zz;
                    rows[k]=y;
                    cols[k]=x;
                    k++;
                }
            }
            hv_Rows=HTuple(rows, k);
            hv_Cols=HTuple(cols, k);
            hv_Gray=HTuple(dGray, 3*k);
            SetGrayval(ho_obj, hv_Rows, hv_Cols, hv_Gray);
            GenRegionPoints(&ho_Rect, hv_Rows, hv_Cols);
            ReduceDomain(ho_obj, ho_Rect, &ho_obj);
            delete[] rows;
            delete[] cols;
            delete[] dGray;
        }
    }
    //byte位图
    else if(1==image.channels())
    {
        int w=image.cols;
        int h=image.rows;
        //位图
        if(image.depth()==CV_8U)
        {
            uchar* dataGray=new uchar[w*h];
            for(int i=0;i<h;i++)
                memcpy(dataGray + w*i, image.ptr() + image.step*i, w);
            GenImage1(&ho_obj, "byte", w, h, (Hlong)(dataGray));
            delete[] dataGray;
        }
        //深度图real
        else if(image.depth()==CV_32F)
        {
            HObject ho_Rect;
            HTuple hv_Rows, hv_Cols, hv_Gray;
            GenImageConst(&ho_obj, "real", w, h);
            int* rows=new int[w * h];
            int* cols=new int[w * h];
            double* dGray=new double[w * h];
            int k=0;
            for(int y=0;y<h;y++)
            {
                float* ptr=image.ptr<float>(y);
                for(int x=0;x<w;x++)
                {
                    float gg=ptr[x];
                    if(gg==0.0)
                        continue;
                    dGray[k]=gg;
                    rows[k]=y;
                    cols[k]=x;
                    k++;
                }
            }
            hv_Rows=HTuple(rows, k);
            hv_Cols=HTuple(cols, k);
            hv_Gray=HTuple(dGray, k);
            SetGrayval(ho_obj, hv_Rows, hv_Cols, hv_Gray);
            GenRegionPoints(&ho_Rect, hv_Rows, hv_Cols);
            ReduceDomain(ho_obj, ho_Rect, &ho_obj);
            delete[] rows;
            delete[] cols;
            delete[] dGray;
        }
    }
    return ho_obj;
}

HObject 转 Mat 的相关代码，位图 byte 格式或是深度图 real 格式，深度图表示为 3D 高度图，将高度信息存放在 Mat 里面。

//图像转换
cv::Mat HObjectToMat(HObject ho_obj)
{
    HTuple hv_Channel;
    CountChannels(ho_obj, &hv_Channel);
    cv::Mat image=Mat();
    if(!(1==hv_Channel.Length()))
        return image;
    //3通道
    if(3==hv_Channel.I())
    {
        HTuple hv_R, hv_G, hv_B;
        HTuple hv_Type, hv_Width, hv_Height;
        GetImagePointer3(ho_obj, &hv_R, &hv_G, &hv_B, &hv_Type, &hv_Width, &hv_Height);
        int w=hv_Width.I();
        int h=hv_Height.I();
        //byte位图
        if(hv_Type.S()==HString("byte"))
        {
            uchar* ptrRed=(uchar*)hv_R.L();
            uchar* ptrGreen=(uchar*)hv_G.L();
            uchar* ptrBlue=(uchar*)hv_B.L();
            image.create(h, w, CV_8UC(3));
            cv::Mat imagR(h, w, CV_8UC(1));
            cv::Mat imagG(h, w, CV_8UC(1));
            cv::Mat imagB(h, w, CV_8UC(1));
            for(int i=0;i<h;i++)
            {
                memcpy(imagR.ptr() + imagR.step*i, ptrRed + w*i, w);
                memcpy(imagG.ptr() + imagG.step*i, ptrGreen + w*i, w);
                memcpy(imagB.ptr() + imagB.step*i, ptrBlue + w*i, w);
            }
            vector<cv::Mat> images;
            images.push_back(imagB);
            images.push_back(imagG);
            images.push_back(imagR);
            merge(images, image);
        }
        //real高度图
        else if(hv_Type.S()==HString("real"))
        {
            HTuple hv_Rows, hv_Cols, hv_Gray;
            GetRegionPoints(ho_obj, &hv_Rows, &hv_Cols);
            GetGrayval(ho_obj, hv_Rows, hv_Cols, &hv_Gray);
            Hlong* lRows=hv_Rows.LArr();
            Hlong* lCols=hv_Cols.LArr();
            double* dGray=hv_Gray.DArr();
            image=Mat::zeros(h, w, CV_32FC3);
            int size=hv_Rows.Length();
            for(int i=0;i<size;i++)
            {
                long row=lRows[i];
                long col=lCols[i];
                image.at<Vec3f>(row, col)[0]=dGray[i*3];
                image.at<Vec3f>(row, col)[1]=dGray[i*3 + 1];
                image.at<Vec3f>(row, col)[2]=dGray[i*3 + 2];
            }
        }
    }
    //单通道
    else if(1==hv_Channel.I())
    {
        HTuple hv_Gray, hv_Type, hv_Width, hv_Height;
        GetImagePointer1(ho_obj, &hv_Gray, &hv_Type, &hv_Width, &hv_Height);
        int w=hv_Width.I();
        int h=hv_Height.I();
        //位图
        if(hv_Type.S()==HString("byte"))
        {
            uchar* ptr=(uchar*)hv_Gray.L();
            image.create(h, w, CV_8UC(1));
            for(int i=0;i<h;i++)
                memcpy(image.ptr() + image.step*i, ptr + w*i, w);
        }
        //高度图
        else if(hv_Type.S()==HString("real"))
        {
            HTuple hv_Rows, hv_Cols, hv_Gray;
            GetRegionPoints(ho_obj, &hv_Rows, &hv_Cols);
            GetGrayval(ho_obj, hv_Rows, hv_Cols, &hv_Gray);
            Hlong* lRows=hv_Rows.LArr();
            Hlong* lCols=hv_Cols.LArr();
            double* dGray=hv_Gray.DArr();
            int size=hv_Rows.Length();
            image=Mat::zeros(h, w, CV_32FC1);
            for(int i=0;i<size;i++)
            {
                long row=lRows[i];
                long col=lCols[i];
                image.at<float>(row, col)=dGray[i];
            }
        }
    }
    return image;
}