opencv常用转换函数

最新推荐文章于 2024-07-27 08:00:00 发布
最新推荐文章于 2024-07-27 08:00:00 发布
阅读量311 收藏
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wayky/article/details/90260499
版权

#pragma once
#ifndef USIZE
#define USIZE sizeof(uchar)
#endif

#ifndef FSIZE
#define FSIZE sizeof(float)
#endif
#include <stdio.h>
#include <stdarg.h>
#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/opencv.hpp>
#include <opencv2/imgproc/imgproc.hpp>
//
//#define  __cplusplus__
//#define __CUDACC__
//#include <crt/device_functions.h>
//#undef __cplusplus__
//#undef __CUDACC__


#define SHOWDATA
#define SHOWTIME

#ifdef SHOWTIME
static void TIME(const char *format, ...)
{
    va_list argPtr;
    int count;

    va_start(argPtr, format);
    fflush(stdout);
    count = vfprintf(stderr, format, argPtr);
    va_end(argPtr);

}
#else
static inline void TIME(const char *format, ...)
{

}
#endif

#ifdef SHOWDATA
static void PRINTF(const char *format, ...)
{
    va_list argPtr;
    int count;

    va_start(argPtr, format);
    fflush(stdout);
    count = vfprintf(stderr, format, argPtr);
    va_end(argPtr);

}
#else
static inline void PRINTF(const char *format, ...)
{

}
#endif

struct IMGINFO
{
    int row;
    int col;
    int ch;
    long int imgSize;
    long int _3ImgSizes;
};

static int Mat2Array(cv::Mat& sMat, float* fMem, uchar* uMem)
{
    if (sMat.type() == CV_32FC1 || sMat.type() == CV_32FC2 ||
        sMat.type() == CV_32FC3 || sMat.type() == CV_32FC4)
    {
        if (fMem == nullptr) return false;

        for (int i = 0; i < sMat.rows; i++)
        {
            float* lineHead = sMat.ptr<float>(i);
            for (int j = 0; j < sMat.cols; j++)
            {
                for (int c = 0; c < sMat.channels(); c++)
                {
                    fMem[c + j * sMat.channels() + i * sMat.channels()* sMat.cols] = lineHead[j * sMat.channels() + c];
                }
            }
        }
    }
    else if (sMat.type() == CV_8UC1 || sMat.type() == CV_8UC2 ||
        sMat.type() == CV_8UC3 || sMat.type() == CV_8UC4)
    {

        if (uMem == nullptr) return false;

        for (int i = 0; i < sMat.rows; i++)
        {
            uchar* lineHead = sMat.ptr<uchar>(i);

            for (int j = 0; j < sMat.cols; j++)
            {
                for (int c = 0; c < sMat.channels(); c++)
                {
                    uMem[c + j * sMat.channels() + i * sMat.channels() * sMat.cols] = lineHead[j * sMat.channels() + c];
                }
            }
        }
    }
    return true;

}


static int Mat2ArrayM(cv::Mat& sMat, float* fMem, uchar* uMem)
{
    if (sMat.type() == CV_32FC1 || sMat.type() == CV_32FC2 ||
        sMat.type() == CV_32FC3 || sMat.type() == CV_32FC4)
    {
        if (fMem == nullptr)
        {
            printf("Host array pointer is nullptr!!! please malloc\n");
            return false;
        }


        for (int i = 0; i < sMat.rows; i++)
        {
            for (int j = 0; j < sMat.cols; j++)
            {
                for (int c = 0; c < sMat.channels(); c++)
                {
                    fMem[c + j * sMat.channels() + i * sMat.channels()* sMat.cols] = sMat.at<cv::Vec3b>(j, i)[c];
                }
            }
        }
    }
    else if (sMat.type() == CV_8UC1 || sMat.type() == CV_8UC2 ||
        sMat.type() == CV_8UC3 || sMat.type() == CV_8UC4)
    {

        if (uMem == nullptr)
        {
            printf("Host array pointer is nullptr!!! please malloc\n");
            return false;

        }

        for (int y = 0; y < sMat.rows; y++)
        {
            for (int x = 0; x < sMat.cols; x++)
            {
                for (int c = 0; c < sMat.channels(); c++)
                {
                    /*if (y == 120 && x == 267)
                    {
                    printf("&&&&&&&&&&&&&&%d\n", sMat.at<cv::Vec3b>(y, x)[c]);
                    }*/
                    uMem[c + x * sMat.channels() + y * sMat.channels()* sMat.cols] = sMat.at<cv::Vec3b>(y, x)[c];
                }
            }
        }
    }
    return true;

}

static int Array2Mat(cv::Mat& sMat, float* fMem, uchar* uMem)
{
    if (sMat.type() == CV_32FC1 || sMat.type() == CV_32FC2 ||
        sMat.type() == CV_32FC3 || sMat.type() == CV_32FC4)
    {
        if (fMem == nullptr) return false;

        for (int i = 0; i < sMat.rows; i++)
        {
            float* lineHead = sMat.ptr<float>(i);
            for (int j = 0; j < sMat.cols; j++)
            {
                for (int c = 0; c < sMat.channels(); c++)
                {
                    lineHead[j * sMat.channels() + c] = fMem[c + j * sMat.channels() + i * sMat.channels()* sMat.cols];
                }
            }
        }
    }
    else if (sMat.type() == CV_8UC1 || sMat.type() == CV_8UC2 ||
        sMat.type() == CV_8UC3 || sMat.type() == CV_8UC4)
    {

        if (uMem == nullptr) return false;

        for (int i = 0; i < sMat.rows; i++)
        {
            uchar* lineHead = sMat.ptr<uchar>(i);

            for (int j = 0; j < sMat.cols; j++)
            {
                for (int c = 0; c < sMat.channels(); c++)
                {
                    lineHead[j * sMat.channels() + c] = uMem[c + j * sMat.channels() + i * sMat.channels() * sMat.cols];
                }
            }
        }
    }
    return true;

}

template<class T>
void printfArray(T* arrMem, int len)
{
    bool isUchar = std::is_same<T, uchar>::value;
    bool isFloat = std::is_same<T, float>::value;
    if (isFloat)
    {
        for (int i = 0; i < len; i++)
        {
            PRINTF("printf %f  \n", arrMem[i]);
        }
    }
    if (isUchar)
    {
        for (int i = 0; i < len; i++)
        {
            PRINTF("printf %d  \n", arrMem[i]);
        }
    }
    PRINTF("===========================================\n");

}

template<class T>
void printfArrayLong(T* arrMem, int time, int step)
{
    bool isUchar = std::is_same<T, uchar>::value;
    bool isFloat = std::is_same<T, float>::value;
    if (isFloat)
    {
        for (int i = 0; i < time; i++)
        {
            PRINTF("printf %f  \n", arrMem[i * step]);
        }
    }
    if (isUchar)
    {
        for (int i = 0; i < time; i++)
        {
            PRINTF("printf %d  \n", arrMem[i * step]);
        }
    }
    PRINTF("===========================================\n");

}

static int divUp(int total, int grain)
{
    return (total + grain - 1) / grain;
}


static std::vector<cv::Mat>& img2List(std::string dir, int nPic)
{
    std::vector<cv::Mat> imgList;
    cv::Mat h_Mat;
    for (int i = 0; i < 10; i++)
    {
        h_Mat = cv::imread(dir.c_str() + std::to_string(i) + ".jpg");
        if (!h_Mat.empty())
        {
            //return nullptr;
        }
        imgList.push_back(h_Mat);
    }
    return imgList;
}


/* read binary data  */
static int readBinaryData(const char* filename, float* data, int w, int h, int ch)
{
    FILE* subfile = fopen(filename, "r+");
    fread(data, 4, w * h * ch, subfile);
    return true;

}

static int readBinaryData(const char* filename, uchar* data, int w, int h, int ch)
{
    FILE* subfile = fopen(filename, "r+");
    fread(data, 1, w * h * ch, subfile);
    return true;

}


static bool compareMat(cv::Mat A, cv::Mat B)
{
    CV_Assert(A.type() == B.type());
    CV_Assert(A.size() == B.size());

    if (A.type() == CV_32FC3 )
    {
        for (int i = 0; i < A.rows; i++)
        {
            for (int j = 0; j < A.cols; j++)
            {
                for (int k = 0; k < A.channels(); k++)
                {
                    if (A.at<cv::Vec3f>(i, j)[k] != B.at<cv::Vec3f>(i, j)[k])
                    {

                        float a = A.at<cv::Vec3f>(i, j)[k];
                        float b = B.at<cv::Vec3f>(i, j)[k];

                        printf("i = %d, j = %d k = %d\n", i, j, k);
                        printf("value frist = %f, value second = %f\n",
                            A.at<cv::Vec3f>(i, j)[k], B.at<cv::Vec3f>(i, j)[k]);
                        //return false;
                        //break;
                    }

                }
            }
        }
        return true;

    }
    else if (A.type() == CV_8UC3)
    {
        for (int i = 0; i < A.rows; i++)
        {
            for (int j = 0; j < A.cols; j++)
            {
                for (int k = 0; k < A.channels(); k++)
                {

                    if (A.at<cv::Vec3b>(i, j)[k] != B.at<cv::Vec3b>(i, j)[k])
                    {
                        printf("i = %d, j = %d k = %d\n", i, j, k);
                        printf("value frist = %d, value second = %d\n",
                            A.at<cv::Vec3b>(i, j)[k], B.at<cv::Vec3b>(i, j)[k]);
                        return false;
                        break;
                    }

                }
            }
        }
        return true;

    }
    else
    {

        printf("Unsupport MAT type!!!\n");
        return false;

    }

}


static bool compareArray(float* A, float* B, int w, int h, int c)
{

    //uchar* a = (uchar*)A;
    //uchar* b = (uchar*)B;

    //for (int i = 0; i < w * h * c * sizeof(float); i++)
    //{
    //    if (a[i] != b[i])
    //    {
    //        int ofs = i / 4;
    //        int n = ofs / (w * h);
    //        int outside = ofs % (w * h);

    //        int x = outside % w;
    //        int y = outside / w;


    //        printf("i=%d , x = %d, y = %d n = %d\n",i, x, y, n);
    //        printf("value frist = %d, value second = %d\n", a[i], b[i]);
    //    
    //        if (i >1000) break;
    //    //    return false;
    //    }

    //}


    for (int i = 0; i < w * h * c ; i++)
    {
        if ((A[i] - B[i]) != 0.f)
        {
            int n = i / (w * h);
            int outside = i % (w * h);

            int x = outside % w;
            int y = outside / w;


            printf("x = %d, y = %d n = %d\n", x, y, n);
            printf("value frist = %f, value second = %f\n", A[i], B[i]);
        //    return false;
        }

    }


    return true;
}

static int bbggrrArray2Mat(cv::Mat& sMat, float* fMem, uchar* uMem)
{
    if (sMat.type() == CV_32FC1 || sMat.type() == CV_32FC2 ||
        sMat.type() == CV_32FC3 || sMat.type() == CV_32FC4)
    {
        if (fMem == nullptr) return false;

        /*int imgSize = sMat.cols * sMat.rows * sMat.channels();
        float* h_transe = (float*)malloc(sizeof(float) * sMat.cols * sMat.rows * sMat.channels());
        for (int c = 0; c < 3; c++)
        {
            for (int i = 0; i < sMat.rows; i++)
            {
                for (int j = 0; j < sMat.cols; j++)
                {
                    h_transe[i * sMat.cols + j + c * sMat.rows * sMat.cols] = fMem[c + j * sMat.channels() + i * sMat.channels()* sMat.cols];

                }
            }
        }*/

        for (int i = 0; i < sMat.rows; i++)
        {
            float* lineHead = sMat.ptr<float>(i);
            
            for (int j = 0; j < sMat.cols; j++)
            {
                for (int c = 0; c < sMat.channels(); c++)
                {
                    lineHead[j * sMat.channels() + c] = fMem[i * sMat.cols + j + c * sMat.rows * sMat.cols];
                }
            }
        }
    }
    else if (sMat.type() == CV_8UC1 || sMat.type() == CV_8UC2 ||
        sMat.type() == CV_8UC3 || sMat.type() == CV_8UC4)
    {

        if (uMem == nullptr) return false;

        for (int i = 0; i < sMat.rows; i++)
        {
            uchar* lineHead = sMat.ptr<uchar>(i);

            for (int j = 0; j < sMat.cols; j++)
            {
                for (int c = 0; c < sMat.channels(); c++)
                {
                    lineHead[j * sMat.channels() + c] = uMem[i * sMat.cols + j + c * sMat.rows * sMat.cols];
                }
            }
        }
    }
    return true;

}


static int rrggbbArray2Mat(cv::Mat& sMat, float* fMem, uchar* uMem)
{
    if (sMat.type() == CV_32FC1 || sMat.type() == CV_32FC2 ||
        sMat.type() == CV_32FC3 || sMat.type() == CV_32FC4)
    {
        if (fMem == nullptr) return false;

        /*int imgSize = sMat.cols * sMat.rows * sMat.channels();
        float* h_transe = (float*)malloc(sizeof(float) * sMat.cols * sMat.rows * sMat.channels());
        for (int c = 0; c < 3; c++)
        {
        for (int i = 0; i < sMat.rows; i++)
        {
        for (int j = 0; j < sMat.cols; j++)
        {
        h_transe[i * sMat.cols + j + c * sMat.rows * sMat.cols] = fMem[c + j * sMat.channels() + i * sMat.channels()* sMat.cols];

        }
        }
        }*/

        for (int i = 0; i < sMat.rows; i++)
        {
            float* lineHead = sMat.ptr<float>(i);

            for (int j = 0; j < sMat.cols; j++)
            {
                for (int c = 0; c < sMat.channels(); c++)
                {
                    lineHead[j * sMat.channels() + c] = fMem[i * sMat.cols + j + abs(c - 2) * sMat.rows * sMat.cols];
                }
            }
        }
    }
    else if (sMat.type() == CV_8UC1 || sMat.type() == CV_8UC2 ||
        sMat.type() == CV_8UC3 || sMat.type() == CV_8UC4)
    {

        if (uMem == nullptr) return false;

        for (int i = 0; i < sMat.rows; i++)
        {
            uchar* lineHead = sMat.ptr<uchar>(i);

            for (int j = 0; j < sMat.cols; j++)
            {
                for (int c = 0; c < sMat.channels(); c++)
                {
                    lineHead[j * sMat.channels() + c] = uMem[i * sMat.cols + j + abs(c -2) * sMat.rows * sMat.cols];
                }
            }
        }
    }
    return true;

}


/* simulate opencv cutdown */
static uchar cvRounding(float value)
{
    uchar res;
    float sub = value - (int)value;

    if (sub == 0.5)
        res = ((int)value % 2 == 0) ? (((uchar)(value))) : (((uchar)(value)+1));
    else
        res = ((uchar)(value + .5f));

    return res;
}

写代码的河马
关注
QT与OpenCV开发常用的图像格式转换函数详解
走向CTO的路上...
07-09 563
QT提供的图像格式，支持多种数据类型和像素格式。OpenCV提供的图像格式，支持多种数据类型和通道数。OpenCV早期使用的图像格式，现已基本被Mat取代。将QImage转换为Mat，可以使用函数。该函数将QImage中的像素数据复制到Mat中，并根据QImage的格式设置Mat的相应属性。QT与OpenCV是两个功能强大的开发框架，可以用于各种图像处理和计算机视觉应用。通过学习图像格式转换函数，可以轻松地在QT和OpenCV之间进行数据传递，从而开发出更加灵活和强大的应用。
利用C++实现从std::string类型到bool型的转换
09-04
利用C++实现从std::string类型到bool型的转换。需要的朋友可以过来参考下。希望对大家有所帮助
OpenCV—矩阵数据类型转换cv::convertTo
热门推荐
iracer的博客
10-17 6万+
矩阵数据类型转换函数convertTo( OutputArray m, int rtype, double alpha=1, double beta=0 ) 的使用方法及示例
Opencv中convertTo函数
liuhuicsu的博客
04-30 1万+
常见问题：原Mat类型是CV_8UC1的，用Mat.convertTo(Mat,CV_64FC1)转换一下type，为什么原图像是这样的： 但是转换完了却变成了这样的 OpenCV的convertTo函数如果第三个参数使用默认的话，就会导致数值只是类型的改变，但在浮点数表示的颜色空间中，数值范围是0-1.0。显然按你这样调用的话，基本上所有像素都转换成大于1的浮点数
OpenCV 中的 convertTo 函数
yleave的博客
04-12 8140
文章转载自： iracer的CSDN博客 http://blog.csdn.net/iracer/article/details/49204147 https://blog.csdn.net/qq_22764813/article/details/52135686 函数 void convertTo( OutputArray m, int rtype, double alpha=1, double...
openCV中convertTo的用法
weixin_42557215的博客
05-06 1480
convertTo的用法: src.convertTo(dst, type, scale, shift) dst：目的矩阵； type：需要的输出矩阵类型，或者更明确的，是输出矩阵的深度，如果是负值（常用-1）则输出矩阵和输入矩阵类型相同； scale:比例因子； shift：将输入数组元素按比例缩放后添加的值； dst(i)=src(i)xscale+(shift,shift,.....
opencv 常用函数总结
最新发布
weixin_44063529的博客
07-27 711
本文是一份OpenCV图像处理的常用函数总结，详细介绍了图像的读入、显示、保存、像素处理、图像属性获取、基础操作、阈值处理、图像平滑、形态学转换以及直方图处理等关键技术。文章通过代码示例和参数说明，帮助读者快速掌握OpenCV在图像处理领域的应用。
opencv 常用函数详解
07-21
以下是对OpenCV常用函数的详细讲解： 1. **cv::imread()**: 用于读取图像文件，接受文件路径和读取模式作为参数。读取模式包括IMREAD_COLOR（默认，彩色图像），IMREAD_GRAYSCALE（灰度图像），IMREAD_UNCHANGED...
opencv 常用函数(c++)
MRxjh的博客
11-16 1379
1.创建滑动条 int creatTrackbar(conststring&amp; trackbarname, conststrint&amp; winname, int* value, int count, TrackbarCallback onChange=0, void* userdata=0); 含义：trackbarname 为轨迹条名，winname 为窗口名，valu...
OpenCV常用函数
07-25
### OpenCV常用函数详解 #### 1. 2DRotationMatrix **功能**: 计算二维旋转矩阵，常用于图像的旋转操作。 **用途**: 实现图像或对象的旋转，适用于计算机视觉中的图像预处理阶段。 #### 2. Abs **功能**: 计算数组...
opencv中mat与jpeg相互转换及显示代码
05-17
opencv中Mat转换成内存数据的jpeg格式,以及显示在mfc的界面中
OpenCV之颜色空间转换：cvtColor()和convertTo()函数
A2271959407的博客
03-14 353
1、cvtColor()它是OpenCV库中的函数，包含OpenCV头文件和命名空间后可直接引用，字面意思是颜色转换，功能是颜色类型转换。 2、convertTo()它是OpenCV中Mat类的成员函数，需要实例化出Mat对象才能调用，字面意思是“转换到”，功能是将Mat进行类型转换。
OpenCV总结——convertTo函数与浮点数类型
windxgz的博客
05-08 6328
在使用convertTo函数是遇到了一个现象，这里记录一下（本来以为用的很熟的函数一段时间后还会遇到新的问题，还是需要进一步的研究与学习）。 在使用convertTo函数将CV_8UC1类型的图像转化为CV_32F或CV_64F的时候出现图像变成全白或者部分图像有内容剩下的都不对的情况。查找相关资料后在这里做一个记录，引发这个现象的原因是浮点数类型在颜色空间中的范围是0-1.0之间，但是CV_8UC1中的像素范围是0-255，这样如果直接转化过去的话，很明显大部分的像素都超过1，全是白的，这里需要先对像素进
opencv的convertTo和normalize
葫芦与瓢的博客
06-23 2601
opencv的这两个函数都可以对矩阵进行变换，normalize可以对矩阵进行范数归一化，也可以对矩阵进行线性变换（线性拉伸或者线性压缩）： 当使用线性拉伸或者线性压缩的时候，使用方法如下：         normalize(src,src,0,255,NORM_MINMAX); 该方法的意义是，如果你的src的最大值最小值比如在128和200，那么，使用该函数后，将把整个src的值进行线
opencv中常用转换
不积跬步，无以至千里
12-08 869
opencv中CvMat的常用操作方法
OpenCV的图像颜色空间转换、缩放、裁剪与旋转
2201_75642955的博客
03-28 1134
颜色空间是用于描述颜色的数学模型。常见的颜色空间包括RGB、HSV、灰度等。RGB颜色空间基于红、绿、蓝三种基色，通过调整这三种颜色的混合比例来生成各种颜色。HSV颜色空间则由色调（H）、饱和度（S）和明度（V）三个分量组成，更适合于描述颜色的直观属性。灰度颜色空间则是将彩色图像转换为黑白图像，只保留亮度信息。OpenCV提供了便捷的颜色空间转换功能，使得图像处理任务变得更加灵活和高效。通过理解颜色空间的基本概念以及OpenCV中的转换方法，我们可以更好地应用这些技术来解决实际问题。
OpenCV：单通道转化为3通道 eval()函数去除引号
qq_42745706的博客
03-22 5402
OpenCV：单通道转化为3通道 eval()函数去除引号
Opencv矩阵操作copyTo convertTo clone reshape
小木匠的博客
07-25 3058
矩阵操作（拷贝、洗牌、局部访问）：   src.copyTo(dst) 把src矩阵中的数据拷贝到dst。   src.convertTo(dst, type, scale, shift) 缩放并转换到另外一种数据类型： dst：目的矩阵 type：需要的输出矩阵类型，或者更明确的，是输出矩阵的深度，如果是负值（常用-1）则输出矩阵和输入矩阵类型相同
opencv 常用的函数
05-23
OpenCV是一个经典的计算机视觉库，提供了许多常用的函数，以下是一些常用的函数： 1. cv2.imread()：读取图像 2. cv2.imshow()：显示图像 3. cv2.cvtColor()：颜色空间转换 4. cv2.resize()：图像缩放 5. cv2....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值