阿里开源黑白图片上色算法DDColor的部署与测试并将模型转onnx后用c++推理

已于 2024-04-29 17:49:50 修改
阅读量798 收藏 9
点赞数 3
文章标签： DDColor onnx c++
于 2024-04-23 18:16:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liang_baikai/article/details/138134024
版权

阿里开源黑白图片上色算法DDColor的部署与测试并将模型转onnx后用c++推理

文章目录

简介

DDColor是一种基于深度学习的图像上色技术，它利用卷积神经网络（CNN）对黑白图像进行上色处理。该模型通常包含一个编码器和一个解码器，编码器提取图像的特征，解码器则根据这些特征生成颜色。DDColor模型能够处理多种类型的图像，并生成自然且逼真的颜色效果。它在图像编辑、电影后期制作以及历史照片修复等领域有广泛的应用。

环境部署

下载源码

git clone https://github.com/piddnad/DDColor.git

安装环境

conda create -n ddcolor python=3.9
conda activate ddcolor
pip install -r requirements.txt
python3 setup.py develop
pip install modelscope
pip install onnx
pip install onnxruntime

下载模型

这里下载
或者运行下面的脚本下载：

from modelscope.hub.snapshot_download import snapshot_download
model_dir = snapshot_download('damo/cv_ddcolor_image-colorization', cache_dir='./modelscope')
print('model assets saved to %s'%model_dir)
#模型会被下载到modelscope/damo/cv_ddcolor_image-colorization/pytorch_model.pt

测试一下

import argparse
import cv2
import numpy as np
import os
from tqdm import tqdm
import torch
from basicsr.archs.ddcolor_arch import DDColor
import torch.nn.functional as F

class ImageColorizationPipeline(object):

    def __init__(self, model_path, input_size=256, model_size='large'):

        self.input_size = input_size
        if torch.cuda.is_available():
            self.device = torch.device('cuda')
        else:
            self.device = torch.device('cpu')

        if model_size == 'tiny':
            self.encoder_name = 'convnext-t'
        else:
            self.encoder_name = 'convnext-l'

        self.decoder_type = "MultiScaleColorDecoder"

        if self.decoder_type == 'MultiScaleColorDecoder':
            self.model = DDColor(
                encoder_name=self.encoder_name,
                decoder_name='MultiScaleColorDecoder',
                input_size=[self.input_size, self.input_size],
                num_output_channels=2,
                last_norm='Spectral',
                do_normalize=False,
                num_queries=100,
                num_scales=3,
                dec_layers=9,
            ).to(self.device)
        else:
            self.model = DDColor(
                encoder_name=self.encoder_name,
                decoder_name='SingleColorDecoder',
                input_size=[self.input_size, self.input_size],
                num_output_channels=2,
                last_norm='Spectral',
                do_normalize=False,
                num_queries=256,
            ).to(self.device)

        self.model.load_state_dict(torch.load(model_path, map_location=torch.device('cpu'))['params'],strict=False)
        self.model.eval()

    @torch.no_grad()
    def process(self, img):
        self.height, self.width = img.shape[:2]
        # print(self.width, self.height)
        # if self.width * self.height < 100000:
        #     self.input_size = 256

        img = (img / 255.0).astype(np.float32)
        orig_l = cv2.cvtColor(img, cv2.COLOR_BGR2Lab)[:, :, :1]  # (h, w, 1)

        # resize rgb image -> lab -> get grey -> rgb
        img = cv2.resize(img, (self.input_size, self.input_size))
        img_l = cv2.cvtColor(img, cv2.COLOR_BGR2Lab)[:, :, :1]
        img_gray_lab = np.concatenate((img_l, np.zeros_like(img_l), np.zeros_like(img_l)), axis=-1)
        img_gray_rgb = cv2.cvtColor(img_gray_lab, cv2.COLOR_LAB2RGB)

        tensor_gray_rgb = torch.from_numpy(img_gray_rgb.transpose((2, 0, 1))).float().unsqueeze(0).to(self.device)

        # (1, 2, self.height, self.width)
        output_ab = self.model(tensor_gray_rgb).cpu()

        # resize ab -> concat original l -> rgb
        output_ab_resize = F.interpolate(output_ab, size=(self.height, self.width))[0].float().numpy().transpose(1, 2, 0)
        output_lab = np.concatenate((orig_l, output_ab_resize), axis=-1)
        output_bgr = cv2.cvtColor(output_lab, cv2.COLOR_LAB2BGR)

        output_img = (output_bgr * 255.0).round().astype(np.uint8)

        return output_img


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument('--model_path', type=str,default='pretrain/net_g_200000.pth')
    parser.add_argument('--input_size', type=int,default=512, help='input size for model')
    parser.add_argument('--model_size', type=str,default='large', help='ddcolor model size')
    args = parser.parse_args()

    colorizer = ImageColorizationPipeline(model_path=args.model_path, input_size=args.input_size, model_size=args.model_size)

    img = cv2.imread("./down.jpg")
    image_out = colorizer.process(img)
    cv2.imwrite("./downout.jpg", image_out)


if __name__ == '__main__':
    main()


python test.py  --model_path=./modelscope/damo/cv_ddcolor_image-colorization/pytorch_model.pt

看看效果

在这里插入图片描述

在这里插入图片描述
效果看起来非常的nice！

模型转onnx

import argparse
import cv2
import numpy as np
import os
from tqdm import tqdm
import torch
from basicsr.archs.ddcolor_arch import DDColor
import torch.nn.functional as F

class ImageColorizationPipeline(object):

    def __init__(self, model_path, input_size=256, model_size='large'):
        
        self.input_size = input_size
        if torch.cuda.is_available():
            self.device = torch.device('cuda')
        else:
            self.device = torch.device('cpu')

        if model_size == 'tiny':
            self.encoder_name = 'convnext-t'
        else:
            self.encoder_name = 'convnext-l'

        self.decoder_type = "MultiScaleColorDecoder"

        if self.decoder_type == 'MultiScaleColorDecoder':
            self.model = DDColor(
                encoder_name=self.encoder_name,
                decoder_name='MultiScaleColorDecoder',
                input_size=[self.input_size, self.input_size],
                num_output_channels=2,
                last_norm='Spectral',
                do_normalize=False,
                num_queries=100,
                num_scales=3,
                dec_layers=9,
            ).to(self.device)
        else:
            self.model = DDColor(
                encoder_name=self.encoder_name,
                decoder_name='SingleColorDecoder',
                input_size=[self.input_size, self.input_size],
                num_output_channels=2,
                last_norm='Spectral',
                do_normalize=False,
                num_queries=256,
            ).to(self.device)

        print(model_path)

        self.model.load_state_dict(
            torch.load(model_path, map_location=torch.device('cpu'))['params'],
            strict=False)
        self.model.eval()

    @torch.no_grad()
    def process(self, img):
        self.height, self.width = img.shape[:2]
        # print(self.width, self.height)
        # if self.width * self.height < 100000:
        #     self.input_size = 256

        img = (img / 255.0).astype(np.float32)
        orig_l = cv2.cvtColor(img, cv2.COLOR_BGR2Lab)[:, :, :1]  # (h, w, 1)

        # resize rgb image -> lab -> get grey -> rgb
        img = cv2.resize(img, (self.input_size, self.input_size))
        img_l = cv2.cvtColor(img, cv2.COLOR_BGR2Lab)[:, :, :1]
        img_gray_lab = np.concatenate((img_l, np.zeros_like(img_l), np.zeros_like(img_l)), axis=-1)
        img_gray_rgb = cv2.cvtColor(img_gray_lab, cv2.COLOR_LAB2RGB)

        tensor_gray_rgb = torch.from_numpy(img_gray_rgb.transpose((2, 0, 1))).float().unsqueeze(0).to(self.device)
        output_ab = self.model(tensor_gray_rgb).cpu()  # (1, 2, self.height, self.width)
        
        # resize ab -> concat original l -> rgb
        output_ab_resize = F.interpolate(output_ab, size=(self.height, self.width))[0].float().numpy().transpose(1, 2, 0)
        output_lab = np.concatenate((orig_l, output_ab_resize), axis=-1)
        output_bgr = cv2.cvtColor(output_lab, cv2.COLOR_LAB2BGR)

        output_img = (output_bgr * 255.0).round().astype(np.uint8)    

        return output_img


    @torch.no_grad()
    def expirt_onnx(self, img):
        self.height, self.width = img.shape[:2]
        
        img = (img / 255.0).astype(np.float32)
        orig_l = cv2.cvtColor(img, cv2.COLOR_BGR2Lab)[:, :, :1]  # (h, w, 1)

        # resize rgb image -> lab -> get grey -> rgb
        img = cv2.resize(img, (self.input_size, self.input_size))
        img_l = cv2.cvtColor(img, cv2.COLOR_BGR2Lab)[:, :, :1]
        img_gray_lab = np.concatenate((img_l, np.zeros_like(img_l), np.zeros_like(img_l)), axis=-1)
        img_gray_rgb = cv2.cvtColor(img_gray_lab, cv2.COLOR_LAB2RGB)

        tensor_gray_rgb = torch.from_numpy(img_gray_rgb.transpose((2, 0, 1))).float().unsqueeze(0).to(self.device)
        
        mymodel = self.model.to('cpu')
        tensor_gray_rgb = tensor_gray_rgb.to('cpu')
        onnx_save_path = "color.onnx"

        torch.onnx.export(mymodel,  # 要导出的模型
                          tensor_gray_rgb,  # 模型的输入
                          onnx_save_path,  # 导出的文件路径
                          export_params=True,  # 是否将训练参数导出
                          opset_version=12,  # 导出的ONNX的操作集版本
                          do_constant_folding=True,  # 是否执行常量折叠优化
                          input_names=['input'],  # 输入张量的名称
                          output_names=['output'],  # 输出张量的名称
                          dynamic_axes={'input': {0: 'batch_size'}, 
                                        'output': {0: 'batch_size'}})
        return



def main():
    parser = argparse.ArgumentParser()
    parser.add_argument('--model_path', type=str, default='pretrain/net_g_200000.pth')
    parser.add_argument('--input_size', type=int, default=512, help='input size for model')
    parser.add_argument('--model_size', type=str, default='large', help='ddcolor model size')
    args = parser.parse_args()

    colorizer = ImageColorizationPipeline(model_path=args.model_path, input_size=args.input_size, model_size=args.model_size)

    img = cv2.imread("./down.jpg")
    image_out = colorizer.expirt_onnx(img)
    # image_out = colorizer.process(img)
    # cv2.imwrite("./downout.jpg", image_out)


if __name__ == '__main__':
    main()


python model2onnx.py  --model_path=./modelscope/damo/cv_ddcolor_image-colorization/pytorch_model.pt

测试一下生成的onnx模型

import onnxruntime
import cv2
import numpy as np

def colorize_image(input_image_path, output_image_path, model_path):
    input_image = cv2.imread(input_image_path)

    img = (input_image / 255.0).astype(np.float32)
    orig_l = cv2.cvtColor(img, cv2.COLOR_BGR2Lab)[:, :, :1]  # (h, w, 1)
    img = cv2.resize(img, (512, 512))
    img_l = cv2.cvtColor(img, cv2.COLOR_BGR2Lab)[:, :, :1]
    img_gray_lab = np.concatenate((img_l, np.zeros_like(img_l), np.zeros_like(img_l)), axis=-1)
    input_blob = cv2.cvtColor(img_gray_lab, cv2.COLOR_LAB2RGB)

    # Change data layout from HWC to CHW
    input_blob = np.transpose(input_blob, (2, 0, 1))
    input_blob = np.expand_dims(input_blob, axis=0)  # Add batch dimension

    # Initialize ONNX Runtime Inference Session
    session = onnxruntime.InferenceSession(model_path)

    # Perform inference
    output_blob = session.run(None, {'input': input_blob})[0]

    # Post-process the output
    output_blob = np.squeeze(output_blob)  # Remove batch dimension

    # Separate ab channels
    # Change data layout from CHW to HWC
    output_ab = output_blob.transpose((1, 2, 0))

    # Resize to match input image size
    output_ab = cv2.resize(output_ab, (input_image.shape[1], input_image.shape[0]))
    output_lab = np.concatenate((orig_l, output_ab), axis=-1)

    # Convert LAB to BGR
    output_bgr = cv2.cvtColor(output_lab, cv2.COLOR_LAB2BGR)

    output_bgr = output_bgr*255

    # Save the colorized image
    cv2.imwrite(output_image_path, output_bgr)


# Define paths
input_image_path = 'down.jpg'
output_image_path = 'downout2.jpg'
model_path = 'color.onnx'

# Perform colorization
colorize_image(input_image_path, output_image_path, model_path)


python testonnx.py

看看效果

在这里插入图片描述
嗯，模型没有问题，下面开始用c++推理

C++ 推理

#pragma once
#include <iostream>
#include <assert.h>
#include <vector>
#include <onnxruntime_cxx_api.h>
#include <opencv2/opencv.hpp>

namespace LIANGBAIKAI_BASE_MODEL_NAME
{
    class ONNX_DDcolor
    {
    public:
        ONNX_DDcolor() : session(nullptr){};
        virtual ~ONNX_DDcolor() = default;
        /*初始化
         * @param model_path 模型
         * @param gpu_id 选择用那块GPU
         */
        void Init(const char *model_path, int gpu_id = 0)
        {
            env = Ort::Env(ORT_LOGGING_LEVEL_ERROR, "ONNX_DDcolor");
            Ort::SessionOptions session_options;
            // 使用五个线程执行op,提升速度
            session_options.SetIntraOpNumThreads(5);
            session_options.SetGraphOptimizationLevel(GraphOptimizationLevel::ORT_ENABLE_ALL);

            if (gpu_id >= 0)
            {
                OrtCUDAProviderOptions cuda_option;
                cuda_option.device_id = gpu_id;
                session_options.AppendExecutionProvider_CUDA(cuda_option);
            }

            session = Ort::Session(env, model_path, session_options);
            return;
        }

        /**执行模型推理
         * @param src : 输入图
         * @param inputid : 输入id
         * @param outputid : 输出的id
         * @return 输出结果图
         */
        cv::Mat Run(cv::Mat src, unsigned inputid = 0, unsigned outputid = 0, bool show_log = false)
        {

            cv::Mat img;
            src.convertTo(img, CV_32FC3, 1.0/255.0);

            // 拷贝图片并将图片由 BGR 转为 LAB,分离出L通道
            cv::Mat orig_lab;
            cv::cvtColor(img, orig_lab, cv::COLOR_BGR2Lab);
            cv::Mat orig_l = orig_lab.clone();
            cv::extractChannel(orig_lab, orig_l, 0); // 分离出 L 通道
            cv::resize(img, img, cv::Size(512, 512));
            
            //将图片由RGB转为Lab,然后将ab通道用同尺寸的0矩阵代替，最后再将图片转回rgb
            cv::Mat img_lab;
            cv::cvtColor(img, img_lab, cv::COLOR_BGR2Lab);
            std::vector<cv::Mat> lab_planes;
            cv::split(img_lab, lab_planes);
            cv::Mat img_gray_lab = cv::Mat::zeros(img_lab.rows, img_lab.cols, CV_32FC3);
            std::vector<cv::Mat> img_channels = {lab_planes[0], cv::Mat::zeros(img_lab.rows, img_lab.cols, CV_32F), cv::Mat::zeros(img_lab.rows, img_lab.cols, CV_32F)};
            cv::merge(img_channels, img_gray_lab);
            // Convert LAB to RGB
            cv::Mat input_blob;
            cv::cvtColor(img_gray_lab, input_blob, cv::COLOR_Lab2RGB);

            //将input_blob送入神经网络输入,进行推理
            int64_t H = input_blob.rows;
            int64_t W = input_blob.cols;
            cv::Mat blob;
            cv::dnn::blobFromImage(input_blob, blob, 1.0 , cv::Size(W, H), cv::Scalar(0, 0, 0), false, true);

            // 创建tensor
            size_t input_tensor_size = blob.total();
            std::vector<float> input_tensor_values(input_tensor_size);

            // overwrite input dims
            std::vector<int64_t> input_node_dims = GetInputOrOutputShape("input", inputid, show_log);
            input_node_dims[0] = 1;
            input_node_dims[2] = W;
            input_node_dims[3] = H;

            for (size_t i = 0; i < input_tensor_size; ++i)
            {
                input_tensor_values[i] = blob.at<float>(i);
                // std::cout <<" " << input_tensor_values[i] ;
            }
            // std::cout << std::endl;

            // 查看输入的shape
            if (show_log)
            {
                std::cout << "shape:";
                for (auto &i : input_node_dims)
                {
                    std::cout << " " << i;
                }
                std::cout << std::endl;
                std::cout << "input_tensor_size: " << input_tensor_size << std::endl;
            }

            auto memory_info = Ort::MemoryInfo::CreateCpu(OrtDeviceAllocator, OrtMemTypeCPU);
            auto input_tensor = Ort::Value::CreateTensor<float>(memory_info, input_tensor_values.data(), input_tensor_size, input_node_dims.data(), input_node_dims.size());

            std::string input_name = GetInputOrOutputName("input", inputid, show_log);
            std::string output_name = GetInputOrOutputName("output", outputid, show_log);
            const char *inputname[] = {input_name.c_str()};   // 输入节点名
            const char *outputname[] = {output_name.c_str()}; // 输出节点名

            std::vector<Ort::Value> output_tensor = session.Run(Ort::RunOptions{nullptr}, inputname, &input_tensor, 1, outputname, 1);

            if (show_log)
            {
                // 显示有几个输出的结果
                std::cout << "output_tensor_size: " << output_tensor.size() << std::endl;
            }

            // 获取output的shape
            Ort::TensorTypeAndShapeInfo shape_info = output_tensor[0].GetTensorTypeAndShapeInfo();

            // 获取output的dim
            size_t dim_count = shape_info.GetDimensionsCount();
            if (show_log)
            {
                std::cout << dim_count << std::endl;
            }

            auto shape = shape_info.GetShape();
            if (show_log)
            {
                // 显示输出的shape信息
                std::cout << "shape: ";
                for (auto &i : shape)
                {
                    std::cout << i << " ";
                }
                std::cout << std::endl;
            }

            // 取output数据
            float *f = output_tensor[0].GetTensorMutableData<float>();

            int output_width = shape[2];
            int output_height = shape[3];
            int size_pic = output_width * output_height;
            cv::Mat fin_img;

            std::vector<cv::Mat> abChannels(2);
            abChannels[0] = cv::Mat(output_height, output_width, CV_32FC1, f);
            abChannels[1] = cv::Mat(output_height, output_width, CV_32FC1, f + size_pic);
            merge(abChannels, fin_img);


            cv::Mat output_ab;
            cv::resize(fin_img, output_ab, cv::Size(src.cols, src.rows));

            // Concatenate L and ab channels
            std::vector<cv::Mat> output_channels = {orig_l, output_ab};
            cv::Mat output_lab;
            cv::merge(output_channels, output_lab);

            // Convert LAB to BGR
            cv::Mat output_bgr;
            cv::cvtColor(output_lab, output_bgr, cv::COLOR_Lab2BGR);

            output_bgr.convertTo(output_bgr, CV_8UC3, 255);
            return output_bgr;
        }

    private:
        /*获取模型的inputname 或者 outputname
         * @param input_or_output  选择要获取的是input还是output
         * @param id 选择要返回的是第几个name
         * @param show_log 是否打印信息
         * @return 返回name
         */
        std::string GetInputOrOutputName(std::string input_or_output = "input", unsigned id = 0, bool show_log = false)
        {
            size_t num_input_nodes = session.GetInputCount();
            size_t num_output_nodes = session.GetOutputCount();

            if (show_log)
            {
                // 显示模型有几个输入几个输出
                std::cout << "num_input_nodes:" << num_input_nodes << std::endl;
                std::cout << "num_output_nodes:" << num_output_nodes << std::endl;
            }

            std::vector<const char *> input_node_names(num_input_nodes);
            std::vector<const char *> output_node_names(num_output_nodes);

            Ort::AllocatorWithDefaultOptions allocator;
            std::string name;
            if (input_or_output == "input")
            {
                Ort::AllocatedStringPtr input_name_Ptr = session.GetInputNameAllocated(id, allocator);
                name = input_name_Ptr.get();
            }
            else
            {
                auto output_name_Ptr = session.GetOutputNameAllocated(id, allocator);
                name = output_name_Ptr.get();
            }

            if (show_log)
            {
                std::cout << "name:" << name << std::endl;
            }

            return name;
        }

        /*获取模型的input或者output的shape信息
         * @param input_or_output  选择要获取的是input还是output
         * @param id 选择要返回的是第几个shape
         * @param show_log 是否打印信息
         * @return 返回shape信息
         */
        std::vector<int64_t> GetInputOrOutputShape(std::string input_or_output = "input", unsigned id = 0, bool show_log = false)
        {
            std::vector<int64_t> shape;
            if (input_or_output == "input")
            {
                Ort::TypeInfo type_info = session.GetInputTypeInfo(id);
                auto tensor_info = type_info.GetTensorTypeAndShapeInfo();
                // 得到输入节点的数据类型
                ONNXTensorElementDataType type = tensor_info.GetElementType();
                if (show_log)
                {
                    std::cout << "input_type: " << type << std::endl;
                }
                shape = tensor_info.GetShape();
                if (show_log)
                {
                    std::cout << "intput shape:";
                    for (auto &i : shape)
                    {
                        std::cout << " " << i;
                    }
                    std::cout << std::endl;
                }
            }
            else
            {
                Ort::TypeInfo type_info_out = session.GetOutputTypeInfo(id);
                auto tensor_info_out = type_info_out.GetTensorTypeAndShapeInfo();
                // 得到输出节点的数据类型
                ONNXTensorElementDataType type_out = tensor_info_out.GetElementType();
                if (show_log)
                {
                    std::cout << "output type: " << type_out << std::endl;
                }

                // 得到输出节点的输入维度 std::vector<int64_t>
                shape = tensor_info_out.GetShape();
                if (show_log)
                {
                    std::cout << "output shape:";
                    for (auto &i : shape)
                    {
                        std::cout << " " << i;
                    }
                    std::cout << std::endl;
                }
            }
            return shape;
        }

        mutable Ort::Session session;

        Ort::Env env; 
    };

}

测试没有问题，成功！

凉_白开
关注
  • 3
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
DDColor-PDF文献
04-23
DDColor:Towards Photo-Realistic Image Colorization via Dual Decoders
【老照片上色+在线运行】DDColor：阿里黑白图像上色模型（2022.12提出）
进一寸有一寸的欢喜
01-23 1374
DDColor 是最新的 SOTA 图像上色算法，能够对输入的黑白图像生成自然生动的彩色结果。算法使用 UNet 结构的骨干网络和图像解码器分别实现图像特征提取和特征图上采样，并利用 Transformer 结构的颜色解码器完成基于视觉语义的颜色查询，最终聚合输出彩色通道预测结果。
给黑白图片上色的节点——ComfyUI-DDColor
u013224364的博客
04-26 333
看，上色还是很出色的，但是如果对黑白漫画上色的话，效果不是很好，上的颜色很乱，不符合日常常识，如下。【干货分享】用ComfyUI-DDColor一键给黑白老照片上色，使用简单，效果还非常惊艳。这个上色对黑白照片上色效果很好，我就随便在网上找一张黑白照片看看效果，如下。如果你图片小，就把上面的数字改小一点，设置为512，如下。什么情况下使用这些模型呢？把上面的模型放到下面的目录中，如下。星球号：32767063。
【达摩院OpenVI】老片图像上色，一键开源体验
孙佰贵的专栏
03-08 5788
本文介绍开源图像上色一键体验，它是指对黑白图像添加色彩，使其变成彩色图像。更具体的说，我们常见的彩色图像通常是三通道图像，而黑白图像只有一个灰度通道，因此，图像上色旨在利用单一灰度通道恢复图像的两个彩色通道。随着摄影技术的演进，彩色照片在现在已经非常普及，但仍然有大量历史黑白照片遗留。图像上色可以对这些宝贵的旧时代遗产进行修复，令老照片重获新生。
DDColor：AI图像着色工具，优秀的黑白图像上色模型，支持双解码器！
z_ipython的博客
01-26 1514
在数字图像处理领域，图像上色一直是一个重要的课题。传统的图像上色方法通常需要人工干预，耗时且效果有限。然而，随着深度学习技术的发展，自动图像上色模型逐渐成为了研究热点。其中，DDColor图像上色模型以其出色的性能和便捷的使用方式备受关注。DDColor是一个由阿里达摩院研究的基于深度学习技术的图像上色模型，它能够自动将黑白或灰度图像着色，使图像更加生动逼真。该模型采用了先进的神经网络架构和训练技术，能够识别图像中的物体和场景，并为其添加逼真的颜色。
进行实心填充区域显示置后操作的对话框定制 (2000年)
04-24
城市规划设计的现状图和总平面图的地域类的区域颜色填充，在AutoCAD中可以通过如下步骤实现：(1)用Ddcolor命令设置当前层颜色，即选定地类颜色。(2)用Hatch或Bhatch命令进行区域填充。(3)用“＼工具＼显示排序＼放后...
【C++第三阶段】list容器&排序
还有很多需要学习，现在还很菜
04-29 703
以下内容仅为当前认识，可能有不足之处，欢迎讨论！
《21天学通C++》（第十章）实现继承（1）
立志成为炼丹师？
04-28 315
覆盖是一种极端情况，即派生类中的重载方法会隐藏基类中方法的所有重载版本，导致需要调用时无法调用，示例代码如下。解决方法3：在派生类中，把基类中的方法全部重载一次，并在派生类中就调用基类方法。只要派生类中实现了从基类中继承的函数，且返回值和标值相同，就可以覆盖。如果基类包含重载的构造函数，可以使用初始化列表传递参数。，避免不定义的情况下，随机数值产生影响。解决办法1：使用作用域解析符。解决方法2：在派生类中使用。同样使用作用域解析运算符。在构造一个派生类时，使用作用域解析运算符。若想调用基类中的方法。
c入门基础题（3）
梦昼初
04-26 1005
1、找出数组中最大元素的位置（下标值） 输入 多组测试，每组先输入一个不大于10的整数n 然后是n个整数 输出 输出这n个整数中最大的元素及下标值 样例输入 4 1 4 5 6 样例输出 6 3 #include<stdio.h> int main(){ int a[20]; int n,x=0,y,z,s,m,f; int i,j; while(scanf("%d",&n)!=EOF){ for(i=1;i<=n;i++){ scanf("%d",&y)
C++相关概念和易错语法（9）（变量的存储、new和delete混用分析）
SGlow0708的博客
04-28 778
我们发现如果这个时候直接去调用operator delete[]、operator delete、delete、free就会导致释放的内存起始位置发生了位移，这就会导致报错，而delete[]就会先从前4个字节开始，先读取个数，然后。注意数组是开辟了空间的，会发生复制操作，就算是常量字符串储存在代码段，也要拷贝过来。如果类没有显式实现析构函数，那么就意味着不会多开辟那4个字节，也就不会报错，这个时候混用不会导致程序崩溃。当我们创建类的数组时，使用new[]，因为使用它可以在开辟空间的时候。
整型提升和算术转换＜C语言＞
2302_80803681的博客
04-30 603
整型提升和算术转换
c++ 读取输入加速
最新发布
qq_34179431的博客
05-05 133
c++ 在处理大规模输入输出时cin会很慢， 可能需要使用scanf 代码这时候就需要使用下面的函数来加速cin 的输入。
C++之模板
专注
05-02 701
函数模板可以声明、定义分离；不同的是模板参数声明定义都要给。// 声明// 定义int a = 10;int b = 14;return 0;20204、类模板。
迭代器iterator是C++中用于遍历容器中元素的对象
book_dw5189的博客
04-28 822
迭代器的使用通常伴随着容器的.begin()和.end()成员函数，这两个函数分别返回指向容器第一个元素和尾后元素的迭代器。
手搓带头双向循环链表（C语言）
m0_62646213的博客
04-28 676
带头双向循环链表的实现与测试，优劣分析
使用C++和QT开发第一款跨平台桌面应用程序
Python私教
05-03 458
跨平台的C++图形用户界面（GUI）应用程序开发框架。QT专注但不局限于图形用户界面的开发，其他也包括系统调用，网络编程，数据库编程，2D，3D图形处理等。QT支持各大主流的操作系统，比如Linux，Windows，macOS，Android，iOS等。
【C++】析构函数的作用及其使用
原小明
04-28 594
当一个对象的生命周期结束时，无论是对象所在的作用域结束（例如，局部对象在函数退出时）、对象被delete（针对动态分配的对象）、或者容器（如std::vector）自动销毁其元素时，析构函数都会被自动调用。在继承关系中，当派生类的析构函数执行完毕后，基类的析构函数会被自动调用，确保了基类资源的正确释放。同样，如果一个类包含了另一个类的对象作为成员，那么当该类的析构函数被调用时，成员对象的析构函数也会被自动调用，递归地清理整个对象结构。然而，对于管理了资源的类，最好显式定义析构函数以确保资源的正确清理。
C++ 堆结构和堆排序（从顶到底/从底到顶的大顶堆）+ 优化
呵呵哒!的博客
05-01 452
heapInsert、heapify方法的单次调用，时间复杂度O(logn)，完全二叉树的结构决定的。依次弹出堆内最大值并排好序，和上面一样的操作流程，这里就不再演示了。，尤其是和比较器结合之后，后面博客会重点讲述。三、从底到顶建立大根堆。二、从顶到底建立大根堆。堆结构比堆排序有用的多。
[C++]22:C++11_part_one
2201_75943325的博客
04-28 800
默认成员函数：构造+析构 拷贝构造+拷贝赋值构造 取地址重载+const取地址重载 -------> 移动构造+移动赋值 ， 一共有8个默认成员函数！1.如果你没有自己实现移动构造函数，且没有实现析构函数 、拷贝构造、拷贝赋值重载中的任意一个。那么编译器会自动生成一个默认移动构造。默认生成的移动构造函数，对于内置类型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动构造，如果实现了就调用移动构造，没有实现就调用拷贝构造。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值