Opencv实现hwc到chw(归一化、减均值、除方差)重磅封装版

已于 2023-04-27 01:19:19 修改
阅读量6.8k 收藏 22
点赞数 8
分类专栏： C++ 文章标签： opencv 计算机视觉 人工智能 图像处理
于 2021-12-30 09:32:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45137428/article/details/122229184
版权

文章目录

1. hwc 和 chw 的内存排布区别：

opencv: 原始数据(rgb)排布(hwc)：假如是 width =5, height =3;
rgbrgbrgbrgbrgb
rgbrgbrgbrgbrgb
rgbrgbrgbrgbrgb
目标排布（chw)： 假如是 width =5, height =3;
rrrrr
rrrrr
rrrrr
ggggg
ggggg
ggggg
bbbbb
bbbbb
bbbbb

2. 预处理参数封装

enum class NormType : int{
    None      = 0,
    MeanStd   = 1,
    AlphaBeta = 2
};

enum class ChannelType : int{
    None          = 0,
    Invert        = 1
};


/**
 * \brief: 为了预处理方便, 我们对预处理需要参数进行封装;
 * 
 */ 
struct Norm{
    float mean_[3];
    float std_[3];
    float alpha_;
    float beta_;

    NormType    normType_    = NormType::None;
    ChannelType channelType_ = ChannelType::None;

    /**
     * \brief: 静态方法, 可以不实例化 Norm, 仅仅通过 Norm::mean_std() 来调用; 减均值除方差的参数赋值
     */ 
    // out = (x * alpha - mean) / std
    static Norm mean_std(const float mean[3], const float std[3], float alpha = 1/255.0f, ChannelType channel_type=ChannelType::None);

    /**
     * \brief: 静态方法, 可以不实例化 Norm, 仅仅通过 Norm::alpha_beta() 来调用; 一般可以用于归一化的参数赋值
     * 
     */ 
    // out = x * alpha + beta
    static Norm alpha_beta(float alpha, float beta = 0, ChannelType channel_type=ChannelType::None);

    // None
    static Norm None();
};


// 封装的话, 可以放到Cpp之中; 结构体的定义可以放到H文件之中
Norm Norm::mean_std(const float mean[3], const float std[3], float alpha, ChannelType channel_type)
{
    Norm out;
    out.normType_    = NormType::MeanStd;
    out.alpha_       = alpha;
    out.channelType_ = channel_type;
    memcpy(out.mean_, mean, sizeof(out.mean_));
    memcpy(out.std_,  std,  sizeof(out.std_));
    return out;
}

Norm Norm::alpha_beta(float alpha, float beta, ChannelType channel_type)
{
    Norm out;
    out.normType_    = NormType::AlphaBeta;
    out.alpha_       = alpha;
    out.beta_        = beta;
    out.channelType_ = channel_type;
    memset(out.mean_, 0, 3 * sizeof(float));
    out.std_[0] = 1.0f; 
    out.std_[1] = 1.0f;
    out.std_[2] = 1.0f;  
    return out;
}

Norm Norm::None()
{
    return Norm();
}

3. 归一化、减均值除方差、hwc2chw的opencv实现封装；

/**
 *@brief: out = (x * alpha - mean) / std, 标准化(减均值除方差)
* alpha 为 1; 
*@return: 3通道
*/ 
void StandNorm_c3(void* model_input_buffer, cv::Mat& src_mat, Norm& in, cv::Size& model_size)
{   
    cv::Mat img_cvtColr;    // 需要的话, 进行通道转换, bgr2rgb 或者 rgb2bgr
    cv::Mat img_convert;    // 利用cv::Mat的 convertTo 进行归一化除以255.0f
    cv::Mat norm_img;       // 存储减均值除方之后的数据
    cv::Mat img_resize;     // 是否需要进行 resize
    int nModelChannels = 3;

    if (in.channelType_ == ChannelType::Invert)
    {   
        cv::cvtColor(src_mat, img_cvtColr, cv::COLOR_BGR2RGB);  // inplace
    }

    if (src_mat.cols != model_size.width || src_mat.rows != model_size.height)
    {   
        //! 需要resize 的情况是 原图resize 还是 cvtColor的resize, 因此要判断是否需要 Invert
        if (in.channelType_ == ChannelType::Invert)
        {
            cv::resize(img_cvtColr, img_resize, model_size);
        }
        else
        {
            cv::resize(src_mat, img_resize, model_size);
        }

        img_resize.convertTo(img_convert, CV_32FC3, in.alpha_);
    }
    else
    {   
        //! 无需resize; 原图convert 还是 cvtColor的convert, 因此要判断是否需要 Invert
        if (in.channelType_ == ChannelType::Invert)
        {
            img_cvtColr.convertTo(img_convert, CV_32FC3, in.alpha_);
        }
        else
        {
            src_mat.convertTo(img_convert, CV_32FC3, in.alpha_);
        }
    }


    cv::Scalar mean(in.mean_[0], in.mean_[1], in.mean_[2]);
    cv::Scalar std(in.std_[0], in.std_[1], in.std_[2]);
    cv::Mat mean_mat(model_size, CV_32FC3, mean);
    cv::Mat std_mat(model_size, CV_32FC3, std);
    norm_img = (img_convert - mean_mat) / std_mat;

    //! 如果模型输入是fp16数据类型, 则需要在这里进行转换
    // cv:: fp16norm_img;
    // norm_img.convertTo(fp16norm_img, CV_16FC3);

    std::vector<cv::Mat> imgArray(nModelChannels);
    //! chw -> hwc
    cv::split(norm_img, imgArray);

    //! 这里我们采用的是 flaot32 数据类型
    size_t dst_plane_size = model_size.area() * sizeof(float);
    memcpy(reinterpret_cast<uint8_t*>(model_input_buffer), 
        imgArray[0].data, imgArray[0].step.p[0]*imgArray[0].size[0]);
    memcpy(reinterpret_cast<uint8_t*>(model_input_buffer) + dst_plane_size, 
        imgArray[1].data, imgArray[1].step.p[0]*imgArray[1].size[0]);
    memcpy(reinterpret_cast<uint8_t*>(model_input_buffer) + 2*dst_plane_size, 
        imgArray[2].data, imgArray[2].step.p[0]*imgArray[2].size[0]);
    return;
}

/**
 *@brief: out = x * alpha + beta, 归一化
* alpha = 1/255
* beta 为 0; 
*@return: 3通道
*/  
void MaxMinNorm_c3(void* model_input_buffer, cv::Mat& src_mat, Norm& in, cv::Size& model_size)
{   
    cv::Mat img_cvtColr;
    cv::Mat img_convert;
    cv::Mat norm_img;
    cv::Mat img_resize;
    int nModelChannels = 3;

    if (in.channelType_ == ChannelType::Invert)
    {   
        cv::cvtColor(src_mat, img_cvtColr, cv::COLOR_BGR2RGB);  // inplace
    }

    if (src_mat.cols != model_size.width || src_mat.rows != model_size.height)
    {   
        //! 需要resize 的情况是 原图resize 还是 cvtColor的resize
        if (in.channelType_ == ChannelType::Invert)
        {
            cv::resize(img_cvtColr, img_resize, model_size);
        }
        else
        {
            cv::resize(src_mat, img_resize, model_size);
        }
        img_resize.convertTo(img_convert, CV_32FC3, in.alpha_);
    }
    else
    {   
        //! 无需resize; 原图convert 还是 cvtColor的convert
        if (in.channelType_ == ChannelType::Invert)
        {
            img_cvtColr.convertTo(img_convert, CV_32FC3, in.alpha_);
        }
        else
        {
            src_mat.convertTo(img_convert, CV_32FC3, in.alpha_);
        }
    }

    //! 如果模型输入是fp16数据类型, 则需要在这里进行转换
    // cv:: fp16norm_img;
    // norm_img.convertTo(fp16norm_img, CV_16FC3);

    std::vector<cv::Mat> imgArray(nModelChannels);
    //! chw -> hwc
    cv::split(img_convert, imgArray);

    //! 这里我们采用的是 flaot32 数据类型
    size_t dst_plane_size = model_size.area() * sizeof(float);
    memcpy(reinterpret_cast<uint8_t*>(model_input_buffer), 
        imgArray[0].data, imgArray[0].step.p[0]*imgArray[0].size[0]);
    memcpy(reinterpret_cast<uint8_t*>(model_input_buffer) + dst_plane_size, 
        imgArray[1].data, imgArray[1].step.p[0]*imgArray[1].size[0]);
    memcpy(reinterpret_cast<uint8_t*>(model_input_buffer) + 2*dst_plane_size, 
        imgArray[2].data, imgArray[2].step.p[0]*imgArray[2].size[0]);
    return;
}

4. 整合2、3的封装；可以直接拷贝走使用，强烈推荐完整版本，助你起飞

#include "opencv2/opencv.hpp"
#include <vector>
#include <iostream>
#include <memory.h>
#include <vector>
#include <string>


enum class NormType : int{
    None      = 0,
    MeanStd   = 1,
    AlphaBeta = 2
};

enum class ChannelType : int{
    None          = 0,
    Invert        = 1
};

/**
 * \brief: 为了预处理方便, 我们对预处理需要参数进行封装;
 * 
 */ 
struct Norm{
    float mean_[3];
    float std_[3];
    float alpha_;
    float beta_;

    NormType    normType_    = NormType::None;
    ChannelType channelType_ = ChannelType::None;

    /**
     * \brief: 静态方法, 可以不实例化 Norm, 仅仅通过 Norm::mean_std() 来调用; 减均值除方差的参数赋值
     */ 
    // out = (x * alpha - mean) / std
    static Norm mean_std(const float mean[3], const float std[3], float alpha = 1/255.0f, ChannelType channel_type=ChannelType::None);

    /**
     * \brief: 静态方法, 可以不实例化 Norm, 仅仅通过 Norm::alpha_beta() 来调用; 一般可以用于归一化的参数赋值
     * 
     */ 
    // out = x * alpha + beta
    static Norm alpha_beta(float alpha, float beta = 0, ChannelType channel_type=ChannelType::None);

    // None
    static Norm None();
};


/**
 *@brief: out = x * alpha + beta, 归一化
* alpha = 1/255
* beta 为 0; 
*@return: 3通道
*/  
void MaxMinNorm_c3(void* model_input_buffer, cv::Mat& src_mat, Norm& in, cv::Size& model_size);


/**
 *@brief: out = (x * alpha - mean) / std, 标准化(减均值除方差)
* alpha 为 1; 
*@return: 3通道
*/ 
void StandNorm_c3(void* model_input_buffer, cv::Mat& src_mat, Norm& in, cv::Size& model_size);

using namespace std;

int main(int argc, char* argv[]){
    cv::Size model_size(224, 224);
    string img_path = "/home/wkx/Cambricon-MLU270/history_img/demo_preprocess/demo/1.jpg";
    auto img = cv::imread(img_path, cv::IMREAD_COLOR);  //cv::IMREAD_COLOR 明确指定以 BGR形式读入图像
    assert(!img.empty());
    float mean_rgb[3] = {0.485, 0.456, 0.406};
    float std_rgb[3]  = {0.229, 0.224, 0.225};
    Norm normalize_;
    // ChannelType::None 表示不进行 BGR2RGB
    normalize_ = Norm::mean_std(mean_rgb, std_rgb, 1/255.0f, ChannelType::None);

    float* model_input_space = new float[model_size.area()*3];
    //! 多batch的话, 可以自己进行偏移
    StandNorm_c3(model_input_space, img, normalize_, model_size);
    // 做完预处理, 如果你使用的trt你就可以将数据拷贝到 gpu进行推理了
    // ...  cudaMemcpy(dst, src, src_size, cudaMemcpyHostToDevice); //! 建议对返回值增加判断
    // .. forward();


    // 仅仅做归一化, 不做减均值除方差
    // normalize_ = Norm::alpha_beta(1/255.0f, 0.0f, ChannelType::None);
    // MaxMinNorm_c3(model_input_space, img, normalize_, model_size);
    // ...  cudaMemcpy(dst, src, src_size, cudaMemcpyHostToDevice); //! 建议对返回值增加判断
    // .. forward();

    delete [] model_input_space;
    return 0;
}



// 封装的话, 可以放到Cpp之中; 结构体的定义可以放到H文件之中
Norm Norm::mean_std(const float mean[3], const float std[3], float alpha, ChannelType channel_type)
{
    Norm out;
    out.normType_    = NormType::MeanStd;
    out.alpha_       = alpha;
    out.channelType_ = channel_type;
    memcpy(out.mean_, mean, sizeof(out.mean_));
    memcpy(out.std_,  std,  sizeof(out.std_));
    return out;
}

Norm Norm::alpha_beta(float alpha, float beta, ChannelType channel_type)
{
    Norm out;
    out.normType_    = NormType::AlphaBeta;
    out.alpha_       = alpha;
    out.beta_        = beta;
    out.channelType_ = channel_type;
    memset(out.mean_, 0, 3 * sizeof(float));
    out.std_[0] = 1.0f; 
    out.std_[1] = 1.0f;
    out.std_[2] = 1.0f;  
    return out;
}

Norm Norm::None()
{
    return Norm();
}


/**
 *@brief: out = (x * alpha - mean) / std, 标准化(减均值除方差)
* alpha 为 1; 
*@return: 3通道
*/ 
void StandNorm_c3(void* model_input_buffer, cv::Mat& src_mat, Norm& in, cv::Size& model_size)
{   
    cv::Mat img_cvtColr;    // 需要的话, 进行通道转换, bgr2rgb 或者 rgb2bgr
    cv::Mat img_convert;    // 利用cv::Mat的 convertTo 进行归一化除以255.0f
    cv::Mat norm_img;       // 存储减均值除方之后的数据
    cv::Mat img_resize;     // 是否需要进行 resize
    int nModelChannels = 3;

    if (in.channelType_ == ChannelType::Invert)
    {   
        cv::cvtColor(src_mat, img_cvtColr, cv::COLOR_BGR2RGB);  // inplace
    }

    if (src_mat.cols != model_size.width || src_mat.rows != model_size.height)
    {   
        //! 需要resize 的情况是 原图resize 还是 cvtColor的resize, 因此要判断是否需要 Invert
        if (in.channelType_ == ChannelType::Invert)
        {
            cv::resize(img_cvtColr, img_resize, model_size);
        }
        else
        {
            cv::resize(src_mat, img_resize, model_size);
        }

        img_resize.convertTo(img_convert, CV_32FC3, in.alpha_);
    }
    else
    {   
        //! 无需resize; 原图convert 还是 cvtColor的convert, 因此要判断是否需要 Invert
        if (in.channelType_ == ChannelType::Invert)
        {
            img_cvtColr.convertTo(img_convert, CV_32FC3, in.alpha_);
        }
        else
        {
            src_mat.convertTo(img_convert, CV_32FC3, in.alpha_);
        }
    }


    cv::Scalar mean(in.mean_[0], in.mean_[1], in.mean_[2]);
    cv::Scalar std(in.std_[0], in.std_[1], in.std_[2]);
    cv::Mat mean_mat(model_size, CV_32FC3, mean);
    cv::Mat std_mat(model_size, CV_32FC3, std);
    norm_img = (img_convert - mean_mat) / std_mat;

    //! 如果模型输入是fp16数据类型, 则需要在这里进行转换
    // cv:: fp16norm_img;
    // norm_img.convertTo(fp16norm_img, CV_16FC3);

    std::vector<cv::Mat> imgArray(nModelChannels);
    //! chw -> hwc
    cv::split(norm_img, imgArray);

    //! 这里我们采用的是 flaot32 数据类型
    size_t dst_plane_size = model_size.area() * sizeof(float);
    memcpy(reinterpret_cast<uint8_t*>(model_input_buffer), 
        imgArray[0].data, imgArray[0].step.p[0]*imgArray[0].size[0]);
    memcpy(reinterpret_cast<uint8_t*>(model_input_buffer) + dst_plane_size, 
        imgArray[1].data, imgArray[1].step.p[0]*imgArray[1].size[0]);
    memcpy(reinterpret_cast<uint8_t*>(model_input_buffer) + 2*dst_plane_size, 
        imgArray[2].data, imgArray[2].step.p[0]*imgArray[2].size[0]);
    return;
}

/**
 *@brief: out = x * alpha + beta, 归一化
* alpha = 1/255
* beta 为 0; 
*@return: 3通道
*/  
void MaxMinNorm_c3(void* model_input_buffer, cv::Mat& src_mat, Norm& in, cv::Size& model_size)
{   
    cv::Mat img_cvtColr;
    cv::Mat img_convert;
    cv::Mat norm_img;
    cv::Mat img_resize;
    int nModelChannels = 3;

    if (in.channelType_ == ChannelType::Invert)
    {   
        cv::cvtColor(src_mat, img_cvtColr, cv::COLOR_BGR2RGB);  // inplace
    }

    if (src_mat.cols != model_size.width || src_mat.rows != model_size.height)
    {   
        //! 需要resize 的情况是 原图resize 还是 cvtColor的resize
        if (in.channelType_ == ChannelType::Invert)
        {
            cv::resize(img_cvtColr, img_resize, model_size);
        }
        else
        {
            cv::resize(src_mat, img_resize, model_size);
        }
        img_resize.convertTo(img_convert, CV_32FC3, in.alpha_);
    }
    else
    {   
        //! 无需resize; 原图convert 还是 cvtColor的convert
        if (in.channelType_ == ChannelType::Invert)
        {
            img_cvtColr.convertTo(img_convert, CV_32FC3, in.alpha_);
        }
        else
        {
            src_mat.convertTo(img_convert, CV_32FC3, in.alpha_);
        }
    }

    //! 如果模型输入是fp16数据类型, 则需要在这里进行转换
    // cv:: fp16norm_img;
    // norm_img.convertTo(fp16norm_img, CV_16FC3);

    std::vector<cv::Mat> imgArray(nModelChannels);
    //! chw -> hwc
    cv::split(img_convert, imgArray);

    //! 这里我们采用的是 flaot32 数据类型
    size_t dst_plane_size = model_size.area() * sizeof(float);
    memcpy(reinterpret_cast<uint8_t*>(model_input_buffer), 
        imgArray[0].data, imgArray[0].step.p[0]*imgArray[0].size[0]);
    memcpy(reinterpret_cast<uint8_t*>(model_input_buffer) + dst_plane_size, 
        imgArray[1].data, imgArray[1].step.p[0]*imgArray[1].size[0]);
    memcpy(reinterpret_cast<uint8_t*>(model_input_buffer) + 2*dst_plane_size, 
        imgArray[2].data, imgArray[2].step.p[0]*imgArray[2].size[0]);
    return;
}

5.简单代码, 不建议使用；for循环实现 hwc --> chw

代码如下：

	using namespace cv;
	Mat MatBGRImage = imread("wokspace/my_src.jpg");
    auto t0 = iLogger::timestamp_now_float();
    
    Mat RGBImg, ResizeImg;
    cvtColor(MatBGRImage, RGBImg, COLOR_BGR2RGB);
    cv::resize(RGBImg, ResizeImg, Size(224, 224));
    // mean_rgb = [0.485, 0.456, 0.406]
    // std_rgb  = [0.229, 0.224, 0.225]

    int channels = ResizeImg.channels(), height = ResizeImg.rows, width = ResizeImg.cols;

    float* nchwMat = (float*)malloc(channels * height * width * sizeof(float));
    memset(nchwMat, 0, channels * height * width * sizeof(float));

    // Convert HWC to CHW and Normalize
    float mean_rgb[3] = {0.485, 0.456, 0.406};
    float std_rgb[3]  = {0.229, 0.224, 0.225};
    uint8_t* ptMat = ResizeImg.ptr<uint8_t>(0);
    int area = height * width;
    for (int c = 0; c < channels; ++c)
    {
        for (int h = 0; h < height; ++h)
        {
            for (int w = 0; w < width; ++w)
            {
                int srcIdx = c * area + h * width + w;
                int divider = srcIdx / 3;  // 0, 1, 2
                for (int i = 0; i < 3; ++i)
                {
                    nchwMat[divider + i * area] = static_cast<float>((ptMat[srcIdx] * 1.0f/255.0f - mean_rgb[i]) * 1.0f/std_rgb[i] );
                }
            }
        }
    }
	// 复制到GPU
    size_t Src_size = 3 * 224 * 224 * sizeof(float);
    
    for (int i = 0; i < explicit_batch; ++i)
    {
        cudaMemcpy(static_cast<float*>(input_tensor_image->pValue + i * Src_size), 
                nchwMat, Src_size, cudaMemcpyHostToDevice);
    }
    free(nchwMat);
    auto t1 = iLogger::timestamp_now_float();
    auto ms0 = t1 - t0;
    printf("preprocess time: %.3f ms\n", ms0);

PS(可以的话，请关注博主一波)：

如果你觉得我的代码有帮助到你，请关注一波，非常感谢。
使用本教程遇到问题无法解决的话，可以在私信联系我或者在本文章下方进行评论(一般24小时内回复)，我会尽我所能帮助你解决问题。

_kx_
关注
  • 8
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
QT数据转OPENCV
09-19
opencv和qt相互转换，封装了一个类，使用起来非常方便
图像归一化，减均值预处理
热门推荐
u014114990的专栏
12-09 1万+
// normlizer.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include #include #include #include using namespace std; using namespace cv; // Example 3 - 9. Summing all of the elements
pytorch | pytorch hwc转chw
m0_59237910的博客
03-30 515
pytorch | pytorch hwc转chw
zhifangtu.rar_opencv 均值_opencv 方差_opencv均值_求 灰度直方图
09-20
利用opencv对视频进行灰度直方图处理，并求出均值，方差。。。
基于OpenCv的旋转匹配
09-10
基于OpenCv实现了模板图像的旋转匹配，此代码基于matchTemplate函数封装实现可以得知旋转角度的模板匹配
openCV图片转视频程序
06-15
利用openCV编写的将多张图片生成视频的程序
OpenCV - 将图片转换为深度学习模型输入格式，BGR通道转RGB，图片归一化，HWC转CHW
HW140701的博客
09-23 3977
文章目录1 将图片转换为深度模型输入格式1.1 自行进行转换1.1.1 BGR通道转RGB通道1.1.2 图片归一化1.1.3 HWC转CHW1.2 使用cv::dnn::blobFromImage进行转换1.2.1 函数形式1.2.1 函数参数 1 将图片转换为深度模型输入格式 在C++进行人脸识别、目标检测的过程中，经常是以图片数据作为深度学习模型推理的输入数据的，但是从OpenCV读取的图片数据并不能直接用于深度学习模型的推理过程。 首先，OpenCV读取图片默认使用的是BGR通道排列方式，而深度学
Opencv python C++ 归一化
jacke121的专栏
05-17 8778
Opencv C++下的Mat归一化 void Mat_L2_mormal(cv::Mat &image) { //mat*mat, cv::Mat out; out=(image) .mul (image); float sum=0.0; for (int i=0;i<image.rows;i++){ sum=sqrt(cv::sum(out.row(i))[0]); image.row(i)=(image.row...
opencv 图像归一化操作(减去均值，除以方差)
大山的专栏
08-01 8480
std::vector<float> mean_value{0.406, 0.456, 0.485}; std::vector<float> std_value{0.225, 0.224, 0.229}; cv::Mat src, dst; std::vector<cv::Mat> bgrChannels(3); cv::split(src, bgrChannels); for (auto i = 0; i < bgrChannels.size(); i++) {
opencv读取图片HWC转CHW
qq_32925101的博客
06-07 4927
在读取图片时，一般可采取或实现，但是二者读取得到的数据格式有些不同。对于给定的图片，当使用加载图片时，可将其直接转换为]的，并且此时格式为。 当采用读取图片时，不同之处有两点：因此，在PIL和CV2读取图片间进行转换时，需要同时注意维度和RGB通道。具体地，将转换为：此外，若设计转，则首先需要对通道进行逆序，通过下面命令实现。 参考资料：http://www.zzvips.com/article/205586.html......
【开发手记】泛化MindSpore的HwcToChw算子，使其支持多通道输入
UnseenMe的博客
12-26 2086
泛化算子，使其支持维度不为3的输入。
OpenCV 图像旋转
05-18
OpenCV图像处理,图像旋转.实现对读入的图像进行自定义旋转
opencv python实现NCC旋转匹配
03-10
1.圆投影保证旋转匹配 2.积分运算减少运算量，提高匹配速度 3.降采样的实现
python opencv-图像数据归一化
01-20
1.1.定义：归一化把需要处理的数据经过处理后（通过某种算法）限制在你需要的一定范围内。 1.2.优点：归一化使数据有可比性，同时又保持相比较的两个数据之间的相对关系 转换成标准模式，防止仿射变换的影响。 减小几何变换的影响;加快梯度下降求最优解的速度,收敛加快 1.3.作用：归纳统一样本统计分布;归一化在0-1是统计概率分布;归一化在某区间上是统计的坐标分布 1.4.方法： 1）线性函数转换：y=(x-MinValue)/(MaxValue-MinValue) 2）对数函数转换：y=log10(x) 3）反余切转换： y=atan(x)*2/PI 4）Z-sco
pytorch 图像预处理之减去均值,除以方差的实例
12-23
由于方式3需要将tensor转换到GPU上面，这一过程很消耗时间，大概需要十秒，故而果断抛弃这样的做法 img (168, 300, 3) sub div in numpy,time 0.0110 sub div in torch.tensor,time 0.0070 sub div in torch.tensor ...
guiyihua.rar_Image data guiyihua_opencv 0_归一化
09-24
用opencv对图像进行归一化，将0到255间的像素值改变为0到1.调试通过
opencv+python实现均值滤波
12-20
本文实例为大家分享了opencv+python实现均值滤波的具体代码，供大家参考，具体内容如下 原理 均值滤波其实就是对目标像素及周边像素取平均值后再填回目标像素来实现滤波目的的方法，当滤波核的大小是3×3 3\times 33...
opencv人脸打马赛克
qq_41661056的博客
04-22 834
【代码】opencv人脸打马赛克。
Opencv_11_通道的分离与合并
最新发布
EveryDayOneHour的博客
04-23 257
imshow("蓝色", mv[0]);imshow("绿色", mv[1]);imshow("红色", mv[2]);imshow("通道混合", dst);imshow("红色", dst);
用Python编写一下提取工件缺陷灰度特征代码包含灰度归一化均值和灰度方差
04-23
以下是Python代码示例，用于提取工件缺陷的灰度特征，包括灰度归一化均值和灰度方差： ```python import cv2 import numpy as np def extract_gray_features(image): gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) normalized_gray = cv2.normalize(gray.astype('float'), None, 0.0, 1.0, cv2.NORM_MINMAX) mean = np.mean(normalized_gray) variance = np.var(normalized_gray) return mean, variance ``` 解释一下代码： - 首先使用OpenCV库中的cvtColor函数将彩色图像转换为灰度图像。 - 然后使用cv2.normalize函数将灰度图像进行归一化处理，使其像素值在0到1之间。 - 接着使用NumPy库中的np.mean和np.var函数分别计算灰度图像的均值和方差。 - 最后将均值和方差作为函数返回值。 使用该函数的具体示例： ```python image = cv2.imread('defect.jpg') mean, variance = extract_gray_features(image) print('Mean:', mean) print('Variance:', variance) ``` 其中，'defect.jpg'是包含工件缺陷的图像文件名。运行后将输出灰度归一化均值和方差的值。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值