ffmpeg视频解码原理和实战-（5）硬件加速解码后进行渲染并输出帧率

news2024/11/14 12:13:08

头文件：

xvideoview.h


#ifndef XVIDEO_VIEW_H
#define XVIDEO_VIEW_H
#include <mutex>
#include <fstream>
struct AVFrame;

void MSleep(unsigned int ms);

//获取当前时间戳 毫秒
long long NowMs();


/// 视频渲染接口类
/// 隐藏SDL实现
/// 渲染方案可替代
// 线程安全
class XVideoView
{
public:
    enum Format  //枚举的值和ffmpeg中一致
    {
        YUV420P = 0,
        NV12 = 23,
        ARGB = 25,
        RGBA = 26,
        BGRA = 28
    };
    enum RenderType
    {
        SDL = 0
    };
    static XVideoView* Create(RenderType type = SDL);

    
    /// 初始化渲染窗口 线程安全 可多次调用
    /// @para w 窗口宽度
    /// @para h 窗口高度
    /// @para fmt 绘制的像素格式
    /// @para win_id 窗口句柄，如果为空，创建新窗口
    /// @return 是否创建成功
    virtual bool Init(int w, int h,
        Format fmt = RGBA) = 0;

    //清理所有申请的资源，包括关闭窗口
    virtual void Close() = 0;

    //处理窗口退出事件
    virtual bool IsExit() = 0;

    //
    /// 渲染图像 线程安全
    ///@para data 渲染的二进制数据
    ///@para linesize 一行数据的字节数，对于YUV420P就是Y一行字节数
    /// linesize<=0 就根据宽度和像素格式自动算出大小
    /// @return 渲染是否成功
    virtual bool Draw(const unsigned  char* data, int linesize = 0) = 0;
    virtual bool Draw(
        const unsigned  char* y, int y_pitch,
        const unsigned  char* u, int u_pitch,
        const unsigned  char* v, int v_pitch
    ) = 0;


    //显示缩放
    void Scale(int w, int h)
    {
        scale_w_ = w;
        scale_h_ = h;
    }

    bool DrawFrame(AVFrame* frame);

    int render_fps() { return render_fps_; }

    //打开文件
    bool Open(std::string filepath);


    //
    /// 读取一帧数据，并维护AVFrame空间
    /// 每次调用会覆盖上一次数据
    AVFrame* Read();
    void set_win_id(void* win) { win_id_ = win; }
    virtual ~XVideoView();
protected:
    void* win_id_ = nullptr; //窗口句柄
    int render_fps_ = 0;       //显示帧率
    int width_ = 0;             //材质宽高
    int height_ = 0;
    Format fmt_ = RGBA;         //像素格式
    std::mutex mtx_;            //确保线程安全
    int scale_w_ = 0;           //显示大小
    int scale_h_ = 0;
    long long beg_ms_ = 0;       //计时开始时间
    int count_ = 0;              //统计显示次数
    unsigned char* cache_ = nullptr;//用于复制NV12缓冲
private:
    std::ifstream ifs_;
    AVFrame* frame_ = nullptr;
};

#endif

xsdl.h


#pragma once


#include "xvideoview.h"
struct SDL_Window;
struct SDL_Renderer;
struct SDL_Texture;
class XSDL :public XVideoView
{
public:
    void Close() override;
    
    /// 初始化渲染窗口 线程安全
    /// @para w 窗口宽度
    /// @para h 窗口高度
    /// @para fmt 绘制的像素格式
    /// @para win_id 窗口句柄，如果为空，创建新窗口
    /// @return 是否创建成功
    bool Init(int w, int h,
        Format fmt = RGBA) override;

    //
    /// 渲染图像 线程安全
    ///@para data 渲染的二进制数据
    ///@para linesize 一行数据的字节数，对于YUV420P就是Y一行字节数
    /// linesize<=0 就根据宽度和像素格式自动算出大小
    /// @return 渲染是否成功
    bool Draw(const unsigned  char* data,
        int linesize = 0) override;
    bool Draw(
        const unsigned  char* y, int y_pitch,
        const unsigned  char* u, int u_pitch,
        const unsigned  char* v, int v_pitch
    ) override;
    bool IsExit() override;
private:
    SDL_Window* win_ = nullptr;
    SDL_Renderer* render_ = nullptr;
    SDL_Texture* texture_ = nullptr;
};

源文件：

xvideoview.cpp


#include "xsdl.h"
#include <thread>
#include <iostream>
using namespace std;
extern "C"
{
#include <libavcodec/avcodec.h>
}
#pragma comment(lib,"avutil.lib")

void MSleep(unsigned int ms)
{
	auto beg = clock();
	for (int i = 0; i < ms; i++)
	{
		this_thread::sleep_for(1ms);
		if ((clock() - beg) / (CLOCKS_PER_SEC / 1000) >= ms)
			break;
	}
}
long long NowMs()
{
	return clock() / (CLOCKS_PER_SEC / 1000);
}
AVFrame* XVideoView::Read()
{
	if (width_ <= 0 || height_ <= 0 || !ifs_)return NULL;
	//AVFrame空间已经申请，如果参数发生变化，需要释放空间
	if (frame_)
	{
		if (frame_->width != width_
			|| frame_->height != height_
			|| frame_->format != fmt_)
		{
			//释放AVFrame对象空间，和buf引用计数减一
			av_frame_free(&frame_);
		}
	}
	if (!frame_)
	{
		//分配对象空间和像素空间
		frame_ = av_frame_alloc();
		frame_->width = width_;
		frame_->height = height_;
		frame_->format = fmt_;
		frame_->linesize[0] = width_ * 4;
		if (frame_->format == AV_PIX_FMT_YUV420P)
		{
			frame_->linesize[0] = width_; // Y
			frame_->linesize[1] = width_ / 2;//U
			frame_->linesize[2] = width_ / 2;//V
		}

		//生成AVFrame空间，使用默认对齐
		auto re = av_frame_get_buffer(frame_, 0);
		if (re != 0)
		{
			char buf[1024] = { 0 };
			av_strerror(re, buf, sizeof(buf) - 1);
			cout << buf << endl;
			av_frame_free(&frame_);
			return NULL;

		}
	}
	if (!frame_)return NULL;

	//读取一帧数据
	if (frame_->format == AV_PIX_FMT_YUV420P)
	{
		ifs_.read((char*)frame_->data[0],
			frame_->linesize[0] * height_);	//Y
		ifs_.read((char*)frame_->data[1],
			frame_->linesize[1] * height_ / 2);	//U
		ifs_.read((char*)frame_->data[2],
			frame_->linesize[2] * height_ / 2);	//V
	}
	else	//RGBA ARGB BGRA 32
	{
		ifs_.read((char*)frame_->data[0], frame_->linesize[0] * height_);
	}

	if (ifs_.gcount() == 0)
		return NULL;
	return frame_;




}

//打开文件
bool XVideoView::Open(std::string filepath)
{
	if (ifs_.is_open())
	{
		ifs_.close();
	}
	ifs_.open(filepath, ios::binary);
	return ifs_.is_open();
}
XVideoView* XVideoView::Create(RenderType type)
{
	switch (type)
	{
	case XVideoView::SDL:
		return new XSDL();
		break;
	default:
		break;
	}
	return nullptr;
}
XVideoView::~XVideoView()
{
	if (cache_)
		delete cache_;
	cache_ = nullptr;
}

bool XVideoView::DrawFrame(AVFrame* frame)
{
	if (!frame || !frame->data[0])return false;
	count_++;
	if (beg_ms_ <= 0)
	{
		beg_ms_ = clock();
	}
	//计算显示帧率
	else if ((clock() - beg_ms_) / (CLOCKS_PER_SEC / 1000) >= 1000) //一秒计算一次fps
	{
		render_fps_ = count_;
		count_ = 0;
		beg_ms_ = clock();
	}
	int linesize = 0;
	switch (frame->format)
	{
	case AV_PIX_FMT_YUV420P:
		return Draw(frame->data[0], frame->linesize[0],//Y
			frame->data[1], frame->linesize[1],	//U
			frame->data[2], frame->linesize[2]	//V
		);
	case AV_PIX_FMT_NV12:
		if (!cache_)
		{
			cache_ = new unsigned char[4096 * 2160 * 1.5];
		}
		linesize = frame->width;
		if (frame->linesize[0] == frame->width)
		{
			memcpy(cache_, frame->data[0], frame->linesize[0] * frame->height); //Y
			memcpy(cache_ + frame->linesize[0] * frame->height, frame->data[1], frame->linesize[1] * frame->height / 2); //UV
		}
		else //逐行复制
		{
			for (int i = 0; i < frame->height; i++) //Y
			{
				memcpy(cache_ + i * frame->width,
					frame->data[0] + i * frame->linesize[0],
					frame->width
				);
			}
			for (int i = 0; i < frame->height / 2; i++)  //UV
			{
				auto p = cache_ + frame->height * frame->width;// 移位Y
				memcpy(p + i * frame->width,
					frame->data[1] + i * frame->linesize[1],
					frame->width
				);
			}
		}

		//frame->data[0] + frame->data[1]
		return Draw(cache_, linesize);
	case AV_PIX_FMT_BGRA:
	case AV_PIX_FMT_ARGB:
	case AV_PIX_FMT_RGBA:
		return Draw(frame->data[0], frame->linesize[0]);
	default:
		break;
	}
	return false;
}

xsdl.cpp


#include "xsdl.h"
#include "sdl/SDL.h"
#include <iostream>
using namespace std;
#pragma comment(lib,"SDL2.lib")
static bool InitVideo()
{
    static bool is_first = true;
    static mutex mux;
    unique_lock<mutex> sdl_lock(mux);
    if (!is_first)return true;
    is_first = false;
    if (SDL_Init(SDL_INIT_VIDEO))
    {
        cout << SDL_GetError() << endl;
        return false;
    }
    //设定缩放算法，解决锯齿问题,线性插值算法
    SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "1");
    return true;
}
bool XSDL::IsExit()
{
    SDL_Event ev;
    SDL_WaitEventTimeout(&ev, 1);
    if (ev.type == SDL_QUIT)
        return true;
    return false;
}
void XSDL::Close()
{
    //确保线程安全
    unique_lock<mutex> sdl_lock(mtx_);
    if (texture_)
    {
        SDL_DestroyTexture(texture_);
        texture_ = nullptr;
    }
    if (render_)
    {
        SDL_DestroyRenderer(render_);
        render_ = nullptr;
    }
    if (win_)
    {
        SDL_DestroyWindow(win_);
        win_ = nullptr;
    }
}

bool XSDL::Init(int w, int h, Format fmt)
{
    if (w <= 0 || h <= 0)return false;
    //初始化SDL 视频库
    InitVideo();

    //确保线程安全
    unique_lock<mutex> sdl_lock(mtx_);
    width_ = w;
    height_ = h;
    fmt_ = fmt;

    if (texture_)
        SDL_DestroyTexture(texture_);
    if (render_)
        SDL_DestroyRenderer(render_);

    ///1 创建窗口
    if (!win_)
    {
        if (!win_id_)
        {
            //新建窗口
            win_ = SDL_CreateWindow("",
                SDL_WINDOWPOS_UNDEFINED,
                SDL_WINDOWPOS_UNDEFINED,
                w, h, SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE
            );
        }
        else
        {
            //渲染到控件窗口
            win_ = SDL_CreateWindowFrom(win_id_);
        }
    }
    if (!win_)
    {
        cerr << SDL_GetError() << endl;
        return false;
    }

    /// 2 创建渲染器

    render_ = SDL_CreateRenderer(win_, -1, SDL_RENDERER_ACCELERATED);
    if (!render_)
    {
        cerr << SDL_GetError() << endl;
        return false;
    }
    //创建材质 （显存）
    unsigned int sdl_fmt = SDL_PIXELFORMAT_RGBA8888;
    switch (fmt)
    {
    case XVideoView::RGBA:
        sdl_fmt = SDL_PIXELFORMAT_RGBA32;
        break;
    case XVideoView::BGRA:
        sdl_fmt = SDL_PIXELFORMAT_BGRA32;
        break;
    case XVideoView::ARGB:
        sdl_fmt = SDL_PIXELFORMAT_ARGB32;
        break;
    case XVideoView::YUV420P:
        sdl_fmt = SDL_PIXELFORMAT_IYUV;
        break;
    case XVideoView::NV12:
        sdl_fmt = SDL_PIXELFORMAT_NV12;
        break;
    default:
        break;
    }

    texture_ = SDL_CreateTexture(render_,
        sdl_fmt,                        //像素格式
        SDL_TEXTUREACCESS_STREAMING,    //频繁修改的渲染（带锁）
        w, h                            //材质大小
    );
    if (!texture_)
    {
        cerr << SDL_GetError() << endl;
        return false;
    }
    return true;
}
bool XSDL::Draw(
    const unsigned  char* y, int y_pitch,
    const unsigned  char* u, int u_pitch,
    const unsigned  char* v, int v_pitch
)
{
    //参数检查
    if (!y || !u || !v)return false;
    unique_lock<mutex> sdl_lock(mtx_);
    if (!texture_ || !render_ || !win_ || width_ <= 0 || height_ <= 0)
        return false;

    //复制内存到显显存
    auto re = SDL_UpdateYUVTexture(texture_,
        NULL,
        y, y_pitch,
        u, u_pitch,
        v, v_pitch);
    if (re != 0)
    {
        cout << SDL_GetError() << endl;
        return false;
    }
    //清空屏幕
    SDL_RenderClear(render_);

    //材质复制到渲染器

    SDL_Rect rect;
    SDL_Rect* prect = nullptr;
    if (scale_w_ > 0)  //用户手动设置缩放
    {
        rect.x = 0; rect.y = 0;
        rect.w = scale_w_;//渲染的宽高，可缩放
        rect.h = scale_w_;
        prect = &rect;
    }
    re = SDL_RenderCopy(render_, texture_, NULL, prect);
    if (re != 0)
    {
        cout << SDL_GetError() << endl;
        return false;
    }
    SDL_RenderPresent(render_);
    return true;
}
bool XSDL::Draw(const unsigned char* data, int linesize)
{
    if (!data)return false;
    unique_lock<mutex> sdl_lock(mtx_);
    if (!texture_ || !render_ || !win_ || width_ <= 0 || height_ <= 0)
        return false;
    if (linesize <= 0)
    {
        switch (fmt_)
        {
        case XVideoView::RGBA:
        case XVideoView::ARGB:
            linesize = width_ * 4;
            break;
        case XVideoView::YUV420P:
            linesize = width_;
            break;
        default:
            break;
        }
    }
    if (linesize <= 0)
        return false;
    //复制内存到显显存
    auto re = SDL_UpdateTexture(texture_, NULL, data, linesize);
    if (re != 0)
    {
        cout << SDL_GetError() << endl;
        return false;
    }
    //清空屏幕
    SDL_RenderClear(render_);

    //材质复制到渲染器

    SDL_Rect rect;
    SDL_Rect* prect = nullptr;
    if (scale_w_ > 0)  //用户手动设置缩放
    {
        rect.x = 0; rect.y = 0;
        rect.w = scale_w_;//渲染的宽高，可缩放
        rect.h = scale_w_;
        prect = &rect;
    }
    re = SDL_RenderCopy(render_, texture_, NULL, prect);
    if (re != 0)
    {
        cout << SDL_GetError() << endl;
        return false;
    }
    SDL_RenderPresent(render_);
    return true;
}

main.cpp

#include <iostream>
#include <fstream>
#include<string>
#include"xsdl.h"
using namespace std;
extern "C" { //指定函数是c语言函数，函数名不包含重载标注
//引用ffmpeg头文件
#include <libavcodec/avcodec.h>
#include <libavutil/opt.h>
}
//预处理指令导入库
#pragma comment(lib,"avcodec.lib")
#pragma comment(lib,"avutil.lib")
int main(int argc, char* argv[])
{
    auto view = XVideoView::Create();
    //1 分割h264 存入AVPacket
      // ffmpeg -i v1080.mp4 -s 400x300 test.h264
    string filename = "test.h264";
    ifstream ifs(filename, ios::binary);
    if (!ifs)return -1;
    unsigned char inbuf[4096] = { 0 };//用于存储h264编码流

    AVCodecID codec_id = AV_CODEC_ID_H264;

    //1 找解码器
    auto codec = avcodec_find_decoder(codec_id);

    //2 创建解码器上下文
    AVCodecContext *c = avcodec_alloc_context3(codec);


    //硬件加速格式 DXVA2
    AVHWDeviceType hw_type = AV_HWDEVICE_TYPE_DXVA2;
    
    /// 打印所有支持的硬件加速方式
    for (int i = 0;; i++)
    {
        //const AVCodecHWConfig *avcodec_get_hw_config(const AVCodec *codec, int index);
        //用于获取指定编解码器的硬件加速配置。
        //index: 硬件配置的索引值，从 0 开始递增。用于遍历所有可用的硬件配置。
        const AVCodecHWConfig *config = avcodec_get_hw_config(codec, i);
        if (!config)break;
        if (config->device_type)
            //const char *av_hwdevice_get_type_name(enum AVHWDeviceType type);
            //该函数接收一个 AVHWDeviceType 类型的参数，并返回一个描述该硬件设备类型的字符串指针
            //如 CUDA、DXVA2、VAAPI 等。
            cout << av_hwdevice_get_type_name(config->device_type) << endl;
    }

    //初始化硬件加速器上下文 
    AVBufferRef* hw_ctx = nullptr;
    av_hwdevice_ctx_create(&hw_ctx, hw_type, NULL, NULL, 0);

    //设定硬件GPU加速
    c->hw_device_ctx = av_buffer_ref(hw_ctx);//把硬件加速器上下文引用赋值给解码器上下文，以便在后续的编码或解码操作中利用硬件加速功能
    c->thread_count = 16;
   
    //3 打开编码器上下文
    avcodec_open2(c, NULL, NULL);

    //分割上下文
    AVCodecParserContext* parser = av_parser_init(codec_id);
    AVPacket* pkt = av_packet_alloc();
    AVFrame* frame = av_frame_alloc();
    AVFrame* hw_frame = av_frame_alloc(); //硬解码转换用这个frame
    long long begin = NowMs();
    int count = 0;//解码统计
    bool is_init_win = false;

    while (!ifs.eof())
    {
        ifs.read((char*)inbuf, sizeof(inbuf));//将h264编码的流读入inbuf中，一次读4096
        int data_size = ifs.gcount();// 返回上一次读取操作实际读取的字符数,并用data_size记录
        if (data_size <= 0)break;

        //检查输入流是否已经到达文件末尾（EOF，End Of File）
        if (ifs.eof())
        {
            ifs.clear();
            ifs.seekg(0, ios::beg);//回到文件开头重复读取
        }
        auto data = inbuf;//data和inbuf指向同一片区域
        while (data_size > 0) //一次有多帧数据
        {
         
            //通过0001 截断输出到AVPacket 返回帧大小
            int ret = av_parser_parse2(parser, c,
                &pkt->data, &pkt->size, //截断后输出到AVpacket的data中
                data, data_size,        //h264编码流，待处理数据
                AV_NOPTS_VALUE, AV_NOPTS_VALUE, 0
            );//返回消耗的输入数据字节数ret。如果所有输入数据都被消耗，则返回值等于 buf_size。如果解析过程中出现错误，则返回负数。
            data += ret;//data指针向前移动 ret个字节,继续处理inbuf未处理的数据
            data_size -= ret; //待处理的数据大小
            if (pkt->size)//如果还有截断后的avpacket流则进行解码操作
            {
                //cout << pkt->size << " "<<flush;
                //发送packet到解码线程
                ret = avcodec_send_packet(c, pkt);//把avpacket给解码器进行解码
                if (ret < 0)
                    break;
                //获取多帧解码数据 
               
                while (ret >= 0)//如果解码成功
                {
                    //每次回调用av_frame_unref 
                    ret = avcodec_receive_frame(c, frame);//拿到解码后的数据存储到frame中
                    if (ret < 0)
                        break;
                    auto pframe = frame;  //为了同时支持硬解码和软解码
                    if (c->hw_device_ctx) //硬解码
                    {
                        //硬解码转换GPU =》CPU ，显存=》内存
                        //AV_PIX_FMT_NV12,      ///< planar YUV 4:2:0, 12bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (first byte U and the following byte V)
                        av_hwframe_transfer_data(hw_frame, frame, 0);
                        pframe = hw_frame;//如果是硬解码则pframe = hw_frame

                    }
                    //AV_PIX_FMT_DXVA2_VLD
                    AV_PIX_FMT_DXVA2_VLD;
                    cout << frame->format << " " << flush;
                    //
                 /// 第一帧初始化窗口
                    if (!is_init_win)
                    {
                        is_init_win = true;
                        view->Init(pframe->width, pframe->height, (XVideoView::Format)pframe->format);
                    }
                    view->DrawFrame(pframe);

                    count++;
                    auto cur = NowMs();
                    if (cur - begin >= 1000)// 1秒钟计算一次
                    {
                        cout << "\nfps = " << count << endl;
                        count = 0;
                        begin = cur;
                    }
                }
            }
        }
    }
    ///取出缓存数据,防止丢帧
    int ret = avcodec_send_packet(c, NULL);
    while (ret >= 0)
    {
        ret = avcodec_receive_frame(c, frame);
        if (ret < 0)
            break;
        cout << frame->format << "-" << flush;
    }
    av_parser_close(parser);
    avcodec_free_context(&c);
    av_frame_free(&frame);
    av_packet_free(&pkt);

    getchar();
    return 0;
}

运行结果：

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1807584.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

【Redis学习笔记06】Jedis客户端（下）

【Redis学习笔记06】Jedis客户端（下）

Jedis客户端 1. 命令 1.1 Hash类型 Hash类型相信大家并不陌生&#xff0c;许多编程语言都有对应数据结构的实现&#xff0c;可能叫做哈希、字典、映射、关联数组&#xff0c;是相当重要的&#xff01; 在实际开发中非常常用在面试中也是高频考点 1.1.1 常见命令 HSET命令…
阅读更多...
Django API开发实战：前后端分离、Restful风格与DRF序列化器详解

Django API开发实战：前后端分离、Restful风格与DRF序列化器详解

系列文章目录 Django入门全攻略&#xff1a;从零搭建你的第一个Web项目Django ORM入门指南&#xff1a;从概念到实践&#xff0c;掌握模型创建、迁移与视图操作Django ORM实战&#xff1a;模型字段与元选项配置&#xff0c;以及链式过滤与QF查询详解Django ORM深度游&#xff…
阅读更多...
1024粉丝记

1024粉丝记

阅读更多...
NLP实战入门——文本分类任务（TextRNN，TextCNN，TextRNN_Att，TextRCNN，FastText，DPCNN，BERT，ERNIE）

NLP实战入门——文本分类任务（TextRNN，TextCNN，TextRNN_Att，TextRCNN，FastText，DPCNN，BERT，ERNIE）

本文参考自https://github.com/649453932/Chinese-Text-Classification-Pytorch?tabreadme-ov-file&#xff0c;https://github.com/leerumor/nlp_tutorial?tabreadme-ov-file&#xff0c;https://zhuanlan.zhihu.com/p/73176084&#xff0c;是为了进行NLP的一些典型模型的总…
阅读更多...
Day 25 二叉树的终止

Day 25 二叉树的终止

450.删除二叉搜索树中的节点 不理解用tmp保存root节点&#xff0c;然后删除&#xff1f;rootroot->right不会覆盖吗&#xff1f; 需要考虑要删除的节点是不是叶子节点&#xff0c;有无左右孩子 有左右孩子的话&#xff0c;需要将左孩子节点移动到右孩子节点的左面节点的左…
阅读更多...
Python | Leetcode Python题解之第142题环形链表II

Python | Leetcode Python题解之第142题环形链表II

题目&#xff1a; 题解&#xff1a; # Definition for singly-linked list. # class ListNode: # def __init__(self, x): # self.val x # self.next Noneclass Solution(object):def detectCycle(self, head):""":type head: ListNode:…
阅读更多...
element-plus 的el-scrollbar滚动条组件

element-plus 的el-scrollbar滚动条组件

el-scrollbar组件可以替换原生的滚动条&#xff0c;可以设置出现滚动条的高度&#xff0c;若无设置则根据容器自适应。 通过使用 setScrollTop 与 setScrollLeft 方法&#xff0c;可以手动控制滚动条滚动。 scroll 滚动条的滚动事件&#xff0c;会返回滚动条当前的位置。 &l…
阅读更多...
机器学习--生成式模型和判别式模型的具体分析

机器学习--生成式模型和判别式模型的具体分析

文章目录 生成式模型和判别式模型的具体分析生成式模型定义工作原理优点缺点常见模型 判别式模型 总结生成式模型判别式模型 生成式模型和判别式模型的具体分析 生成式模型和判别式模型在机器学习中有着不同的目标、应用场景和性能特点。以下将详细分析它们的定义、工作原理、…
阅读更多...
《庆余年》角色穿越高考：谁将笑傲现代考场？

《庆余年》角色穿越高考：谁将笑傲现代考场？

一、引言 《庆余年》是一部以古代中国为背景的权谋小说&#xff0c;其角色们各具特色&#xff0c;聪明才智、武艺高强、忠诚耿直等特质使得他们在古代世界中游刃有余。然而&#xff0c;如果我们将这些角色置于现代高考的背景之下&#xff0c;他们将如何面对这一挑战&#xff1…
阅读更多...
C# WPF入门学习主线篇（二十）—— 资源和样式

C# WPF入门学习主线篇（二十）—— 资源和样式

C# WPF入门学习主线篇&#xff08;二十&#xff09;—— 资源和样式 欢迎来到C# WPF入门学习系列的第二十篇。在前面的章节中&#xff0c;我们探讨了布局管理及各种控件的使用。本篇博客将重点介绍WPF中的资源&#xff08;Resource&#xff09;和样式&#xff08;Style&#xf…
阅读更多...
抛弃昂贵BI，企业仍可低成本实现数据分析

抛弃昂贵BI，企业仍可低成本实现数据分析

有的读者看完《BI工具选型不入坑&#xff0c;你要这么选》这篇文章就陷入迷茫了&#xff0c;我要做企业级数据分析&#xff0c;看过去各家产品都各有千秋&#xff0c;实在难以抉择&#xff0c;或者已经选了仍是纠结不已。 这里我抛出另一种思路&#xff1a;如果不用BI&#xf…
阅读更多...
MySQL 5.7详细下载安装配置教程（MySQL 5.7安装包）_mysql5.7的安装教程

MySQL 5.7详细下载安装配置教程（MySQL 5.7安装包）_mysql5.7的安装教程

记录MySQL 5.7 的下载安装教程&#xff0c;并提供了Mysql 安装包 &#xff0c;以下是详细下载安装过程。 一、下载Mysql安装包 网盘下载&#xff1a; 下载MySQL 5.7安装包&#xff0c;网盘下载地址&#xff1a;点击此处直接下载 官网下载&#xff1a; 进入官网&#xff0c…
阅读更多...
如何稳定高效地进行 TiDB 数据导入导出？

如何稳定高效地进行 TiDB 数据导入导出？

对于在数据库行业中摸爬滚打多年的老鸟 DBA 来说&#xff0c;TiDB 可是一点也不陌生&#xff0c;作为 PingCAP 公司自主研发的真开源分布式数据库&#xff0c;其先进的设计理念以及丰富的生态工具&#xff0c;可算得上是业界自主创新和性能领先的代名词。 TiDB 是谁&#xff1…
阅读更多...
《Brave New Words 》3.4 最重要的学科领域

《Brave New Words 》3.4 最重要的学科领域

Part III Empowering the Next Innovators 第三部分 赋能下一代创新者 The Most Important Subject-Matter Domain to Master 最重要的学科领域 In the world of education, it’s crucial for developers to field-test their ideas. Essentially, it means taking our educat…
阅读更多...
LabVIEW进行图像拼接的实现方法与优化

LabVIEW进行图像拼接的实现方法与优化

在工业检测和科研应用中&#xff0c;对于大尺寸物体的拍摄需要通过多次拍摄后进行图像拼接。LabVIEW 作为强大的图形化编程工具&#xff0c;能够实现图像拼接处理。本文将详细介绍LabVIEW进行图像拼接的实现方法、注意事项和提高效率的策略。 图像拼接的实现方法 1. 图像采集…
阅读更多...
前端UI框架Element Plus 和 Ant Design Vue哪个好

前端UI框架Element Plus 和 Ant Design Vue哪个好

Element Plus 和 Ant Design Vue 都是基于 Vue.js 的 UI 组件库&#xff0c;它们具备一系列可复用的组件和丰富的功能&#xff0c;并且是当前国内主流的两个 UI 组件库。 &#xff08;1&#xff09;Element Plus 是饿了么前端团队推出的开源项目&#xff0c;是对 Element UI 的…
阅读更多...
基于Python + Flask+ Mysq实现简易留言板

基于Python + Flask+ Mysq实现简易留言板

使用Python Flask Mysql实现简易留言板&#xff0c;包括网友编辑留言、修改留言&#xff0c;删除留言、分页显示四大功能。 写出留言板建设过程&#xff0c;包括开发使用工具、留言板模块设计、数据库设计、页面设计、关键技术。 留言板建设过程总结 一&#xff0e;开发使用…
阅读更多...
RapidMiner数据挖掘4 —— 决策树

RapidMiner数据挖掘4 —— 决策树

0. 序章 0.1 文本说明 所有应用程序操作的名称和编程说明都以黄色背景书写&#xff0c;问题以蓝色背景书写&#xff0c;以方便他们在文本中识别。 在整个课程中&#xff0c;请逐步遵循所有说明&#xff0c;并确保获得预期结果&#xff0c;然后再继续下一部分或问题。 通过在Ub…
阅读更多...
文刻ai工具跟绘唐AI工具有什么区别

文刻ai工具跟绘唐AI工具有什么区别

文刻AI工具和绘唐AI工具是两种不同的人工智能工具。点击查看 文刻AI工具是一种自然语言处理工具&#xff0c;可以用于生成、修改和校对文本。它可以帮助用户更高效地写作&#xff0c;提供词汇和语法建议&#xff0c;检查拼写和语法错误&#xff0c;并提供自动补全和自动纠正功…
阅读更多...
网络安全难学吗？2024该怎么系统学习网络安全？

网络安全难学吗？2024该怎么系统学习网络安全？

学习网络安全需要循序渐进&#xff0c;由浅入深。很多人对网络安全进行了解以后&#xff0c;就打算开始学习网络安全&#xff0c;但是又不知道怎么去系统的学习。 网络安全本身的知识不难&#xff0c;但需要学习的内容有很多&#xff0c;其中包括Linux、数据库、渗透测试、等保…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023