C++实现图像转字符画

最新推荐文章于 2023-06-21 09:17:44 发布
最新推荐文章于 2023-06-21 09:17:44 发布
阅读量3.5k 收藏 30
点赞数 14
分类专栏： 杂七杂八
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/YanEast/article/details/107066247
版权

这个是我顺手写的玩具，因此有好些bug，例如图像步长、大小不能自适应等等的问题。不过按照这个思路你能拿到很好的结果。个人认为效果也可以，先上效果：

鲜红的幼月

效果可以吧。

实现思路很简单，就是按照灰度查表。但是单纯这样是拿不到好结果的——因此我使用拉普拉斯算子的一个变种进行边缘检测，然后以此进行灰度加强，最后再输出图片。完整代码如下，图像编解码使用WIC接口，手写了一个二维卷积，一个图片转灰度图。组合在一起就是结果：

/*
 | Img2Char
 | 文件名称: img2chr.cpp
 | 文件作用: 唯一的源文件
 | 创建日期: 2020-04-16
 | 更新日期: 2020-04-18
 | 开发人员: JuYan
 +----------------------------
 Copyright (C) JuYan, all rights reserved.
 该程序可以把你的图像变成字符画
 WARNING: bug有好几个
*/
#pragma region include和define
#include <list>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <assert.h>
#include <Windows.h>
#include <algorithm>
#include <wincodec.h>
#pragma comment(lib, "Windowscodecs.lib")
#define memalloc(type, num)    (type*)_memalloc(sizeof(type) * (num))
#define BUFF2(p, i, j)       (*((p) + (j) * w + (i)))
#define KERNEL_W             7
#define KERNEL_H             7
#pragma endregion
#pragma region struct定义
enum ImageChannle
{
    Channel_B, Channel_G, Channel_R, Channel_A
};
typedef struct tagImageData
{
    BYTE *rgba;
    int   w, h;
} ImageData;
typedef struct tagGaryImageData
{
    BYTE *dat;                              // 0xff是顶级
    int  *tmp;                              // 在各个处理过程中可能用到的temp数据
    int   w, h;
} GaryImageData;
#pragma endregion
#pragma region 全局变量
IWICImagingFactory *pFactory = NULL;
#pragma endregion
#pragma region 杂项函数
// 打印错误信息
void printmsg(const char *msg, ...)
{
    va_list va;
    va_start(va, msg);
    vfprintf(stderr, msg, va);
    putchar('\n');
    va_end(va);
}
// 分配内存和释放内存
void* _memalloc(size_t sz)
{
    void *p;
    p = malloc(sz);
    if (p == NULL)
    {
        printmsg("Can not allocate %d bytes on heap.", sz);
        assert(0);
        abort();
    }
    return p;
}
void memfree(void *p)
{
    if (p != NULL)
    {
        free(p);
    }
    p = NULL;
}
#pragma endregion 
#pragma region 图片读写
// 释放一个接口
template<class T> inline void SafeRelease(T * &p)
{
    if (p)
    {
        p->Release();
    }
    p = NULL;
}
// 读取图片, 得到rgba, 失败返回false
bool LoadImageData(const wchar_t *file, ImageData *res)
{
    bool    ret;
    BYTE   *dat;
    HRESULT hr;
    WICRect rcLock;
    UINT    i, j, k, datSz, dataStride, imgW, imgH;
    int dataStep;
    BYTE   *pImgData;
    IWICBitmap *pBitmap = NULL;
    IWICBitmapLock  *pLock = NULL;
    WICPixelFormatGUID formatGUID;
    IWICBitmapDecoder  *pDecoder = NULL;                                            // 解码器要即时创建和释放
    IWICBitmapFrameDecode *pDecFrame = NULL;
    ret = true;
    res->w = 0;
    res->h = 0;
    res->rgba = NULL;
    hr = pFactory->CreateDecoderFromFilename(file, NULL, GENERIC_READ, WICDecodeMetadataCacheOnDemand, &pDecoder);
    if (FAILED(hr))
    {
        printmsg("Can not load image : 0x%x", hr);
        return false;
    }
    hr = pDecoder->GetFrame(0, &pDecFrame);
    if (FAILED(hr))
    {
        ret = false;
        goto err;
    }
    // 载入图像信息
    pDecFrame->GetSize(&imgW, &imgH);
    pDecFrame->GetPixelFormat(&formatGUID);                                         // 取得图像编码
    if (IsEqualGUID(formatGUID, GUID_WICPixelFormat32bppBGRA))
    {
        dataStep = 4;
    }
    else if (IsEqualGUID(formatGUID, GUID_WICPixelFormat24bppBGR))
    {
        dataStep = 3;
    }
    else {
        ret = false;
        printmsg("Unknow image format");
        goto err;
    }
    // 拷贝图像数据
    rcLock.X = 0;
    rcLock.Y = 0;
    rcLock.Width = imgW;
    rcLock.Height = imgH;                                                           // 接下来我们创建位图以得到数据
    hr = pFactory->CreateBitmapFromSource(pDecFrame, WICBitmapCacheOnDemand, &pBitmap);
    if (FAILED(hr))
    {
        ret = false;
        goto err;
    }
    pBitmap->Lock(&rcLock, WICBitmapLockWrite, &pLock);
    pLock->GetStride(&dataStride);                                                  // 取得一行有多少字节
    hr = pLock->GetDataPointer(&datSz, &dat);                                       // 取得图像数据
    if (FAILED(hr))
    {
        ret = false;
        printmsg("Can not get image data from memory.");
        goto err;
    }
    pImgData = memalloc(BYTE, imgW * imgH * sizeof(UINT));                          // 最后, 拷贝像素数据
    for (i = 0, j = 0; i < dataStride * imgH; i += dataStride)
    {
        for (k = 0; k < imgW * dataStep; k += dataStep, j += 4)
        {
            pImgData[j + 0] = dat[i + k + 0];
            pImgData[j + 1] = dat[i + k + 1];
            pImgData[j + 2] = dat[i + k + 2];
            if (dataStep == 4)
            {
                pImgData[j + 3] = dat[i + k + 3];
            }
            else {
                pImgData[j + 3] = 0xff;
            }
        }
    }
    res->w = (int)imgW;
    res->h = (int)imgH;
    res->rgba = pImgData;
err:
    SafeRelease(pLock);
    SafeRelease(pBitmap);
    SafeRelease(pDecFrame);
    SafeRelease(pDecoder);
    return ret;
}
// 保存一段数据, 格式为32位的PNG
bool SaveImageData(const wchar_t *file, const ImageData *dat)
{
    bool ret;
    UINT w, h;
    HRESULT hr;
    IWICStream *pStream = NULL;
    IWICBitmapEncoder *pEncoder = NULL;
    IWICBitmapFrameEncode *pBitmapFrame = NULL;
    WICPixelFormatGUID formatGUID = GUID_WICPixelFormat32bppBGRA;
    ret = true;
    w = (UINT)dat->w;
    h = (UINT)dat->h;
    pFactory->CreateStream(&pStream);
    hr = pStream->InitializeFromFilename(file, GENERIC_WRITE);
    if (FAILED(hr))
    {
        ret = false;
        printmsg("Can not save file");
        goto err;
    }
    hr = pFactory->CreateEncoder(GUID_ContainerFormatPng, NULL, &pEncoder);         // png编码器
    if (FAILED(hr))
    {
        ret = false;
        printmsg("Can not create encoder");
        goto err;
    }
    pEncoder->Initialize(pStream, WICBitmapEncoderNoCache);
    hr = pEncoder->CreateNewFrame(&pBitmapFrame, NULL);                             // 创建一个帧
    if (FAILED(hr))
    {
        ret = false;
        goto err;
    }
    pBitmapFrame->Initialize(NULL);
    pBitmapFrame->SetSize(w, h);
    pBitmapFrame->SetPixelFormat(&formatGUID);
    hr = pBitmapFrame->WritePixels(
        h,
        w * sizeof(UINT),
        w * h * sizeof(UINT),
        dat->rgba
    );
    if (FAILED(hr))
    {
        ret = false;
        goto err;
    }
    pBitmapFrame->Commit();                                                         // 提交更改
    pEncoder->Commit();
    pStream->Commit(STGC_DEFAULT);
err:
    SafeRelease(pStream);
    SafeRelease(pBitmapFrame);
    SafeRelease(pEncoder);
    return ret;
}
// 释放ImageData
void ReleaseImageData(ImageData *p)
{
    memfree(p->rgba);
}
#pragma endregion
#pragma region 灰度处理
void CreateGaryImage(const ImageData *src, GaryImageData *res)
{
    BYTE *pres;
    int imgsize, r;
    const BYTE *psrc;
    assert(src->rgba);
    res->w = src->w;
    res->h = src->h;
    imgsize = res->w * res->h;

    res->dat = memalloc(BYTE, imgsize);                                             // 分配内存空间
    res->tmp = memalloc(int,  imgsize);

    pres = res->dat;
    psrc = src->rgba;
    while (imgsize-- > 0)
    {
        if (psrc[Channel_A] != 0)
        {
            r = (int)(psrc[Channel_R] * 0.3 + psrc[Channel_G] * 0.59 + psrc[Channel_B] * 0.11);
        }
        else {
            r = 0xff;                                                               // 完全透明的地方设置为白色
        }
        *pres++ = r > 0xff ? 0xff : r;
        psrc += 4;                                                                  // R G B A 四个通道
    }

}
// 把灰度图转到一个已有的RGBA数据上
void Gary2RGBA(const GaryImageData *src, ImageData *dst)
{
    int imgsize;
    BYTE * pdst;
    const BYTE *psrc;
    assert(src->dat);
    pdst = dst->rgba;
    psrc = src->dat;
    imgsize = src->w * src->h;
    while (imgsize-- > 0)                                                           // 这玩意说白了就是把rgb三个通道设置为灰度值
    {
        pdst[Channel_A] = 0xff;
        pdst[Channel_R] = *psrc;
        pdst[Channel_G] = *psrc;
        pdst[Channel_B] = *psrc;
        pdst += 4;
        psrc++;
    }
}
// 释放灰度图
void ReleaseGaryImage(GaryImageData *p)
{
    if (p->dat != NULL)
    {
        memfree(p->tmp);
        memfree(p->dat);
    }
}
#pragma endregion
#pragma region 拉普拉斯
template<typename T> int GetPixelValue(T *dat, int x, int y, int maxw, int maxh)
{
    if (x < 0)
        x = 0;
    if (y < 0)
        y = 0;
    if (x >= maxw)
        x = maxw - 1;
    if (y >= maxh)
        y = maxh - 1;

    return (int)*(dat + y * maxw + x);
}
inline int GetPixelValue(const GaryImageData &img, int x, int y)
{
    return GetPixelValue(img.dat, x, y, img.w, img.h);
}
// 对灰度图像进行卷积
void CreateGaryImageCov(const double kernel[KERNEL_W][KERNEL_H], const GaryImageData &src, GaryImageData *dst)
{
    int x, y;
    int m, n, w;
    int imgsize, cx, cy;
    double sum;
    w = src.w;
    dst->w = src.w;
    dst->h = src.h;
    imgsize = src.w * src.h;

    dst->dat = memalloc(BYTE, imgsize);                                     // 分配内存空间
    dst->tmp = memalloc(int, imgsize);
 
    cx = KERNEL_W / 2;
    cy = KERNEL_H / 2;
    for (x = 0; x < src.w; x++)
    {
        for (y = 0; y < src.h; y++)
        {
            int curx, cury;
            sum = 0;
            curx = x - cx;
            cury = y - cy;
            for (m = 0; m < KERNEL_W; m++)
            {
                for (n = 0; n < KERNEL_H; n++)
                {
                    sum += kernel[m][n] * (GetPixelValue(src, curx + m, cury + n) / 255.0);
                }
            }
            if (sum > 1)
            {
                sum = 1;
            }
            else if (sum < 0)
            {
                sum = 0;
            }
            BUFF2(dst->dat, x, y) = (BYTE)(sum * 0xff);
        }
    }
}
// 拉普拉斯算子变种
void ApplyLaplaceOper(const GaryImageData &src, GaryImageData *dst)
{
    const double kernel[KERNEL_W][KERNEL_H] =
    {
        0,   1,   0,    0,   1,   0,   0,
        1,   1,   0,    1,   0,   1,   1,
        0,   0,   1,    0,   1,   0,   1,
        1,   0,   0, -22.3,  0,   0,   1,
        0,   0,   1,    0,   1,   0,   1,
        1,   1,   0,    1,   0,   1,   1,
        0,   0,   1,    0,   1,   0,   0,
    };
    CreateGaryImageCov(kernel, src, dst);
}
#pragma endregion
#pragma region 字符画输出
// 这个表是按照灰度对应的字符
const char str[] =
{
    "@@&QNOBD%GmH8Abd$UwKXPZE#VShkC25eao3YnuTzxfL7vsc]|}1J?)(l=I+<>ri!*-~;:,... "
};
int wmain(int argc, wchar_t *argv[])
{
    HRESULT hr;
    ImageData img;
    GaryImageData gary, bord;
    constexpr int step = 2;                                                         // 图像转灰度的步长
    CoInitialize(NULL);
    hr = CoCreateInstance(CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER, IID_IWICImagingFactory, (LPVOID*)&pFactory);
    if (FAILED(hr))
    {
        printmsg("Can not create factory : 0x%x", hr);
        goto err;
    }
    if (argc == 1 || LoadImageData(argv[1], &img) == false)
    {
        printmsg("Can not open file");
        goto err;
    }
    CreateGaryImage(&img, &gary);                                                   // 创建灰度图像
    ApplyLaplaceOper(gary, &bord);
    /**/
    FILE *f;
    fopen_s(&f, "out.txt", "wb");
    for (int i = 0; i < gary.h; i += step)
    {
        const int maxlen = sizeof(str) - 1;
        for (int j = 0; j < gary.w; j += step)
        {
            int k = (int)(GetPixelValue(gary, j, i) / 256.0 * maxlen);
            double m = GetPixelValue(bord, j, i) / 255.0;
            k = k - 20 * (m - 0.1);
            if (k < 0)
            {
                k = 0;
            }
            fwrite(&str[k], 1, 1, f);
            fwrite(&str[k], 1, 1, f);
        }
        fwrite("\r\n", 1, 2, f);
    }
    fclose(f);

    Gary2RGBA(&bord, &img);
    SaveImageData(L"out.png", &img);
sverr:
    ReleaseImageData(&img);
    ReleaseGaryImage(&gary);
    ReleaseGaryImage(&bord);
err:
    SafeRelease(pFactory);
    CoUninitialize();
    return 0;
}
#pragma endregion

 

Ju Yan
关注
  • 14
    点赞
  • 踩
  • 30
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
字符画拼图
qq_42748385的博客
10-09 1041
初学C语言时做过的一个小游戏，当时想做个字符画拼图，做了一半就搁置了，只实现了数字拼图的功能，也不打算继续完善了，有感兴趣的同学可以参考此程序做个控制台应用，写实验报告绰绰有余。 1开发背景 字符画拼图起源于数字拼图，数字拼图曾作为最强大脑比赛项目而被人熟知，游戏要求八个数字，九宫格，打乱之后把它们按顺序重新排好，考验选手的推理力和手指灵活性。本次开发将游戏移植到控制台窗口，保持玩法不变但将数字替换为字符画，玩家在预先观察字符画后需要将打乱的九个字符画重新排序，这就在考验推理能力的同时..
帮我写一个能把视频转换成字符的c++程序。
weixin_35754676的博客
01-08 127
非常抱歉，但我无法写代码。然而，我可以给您一些提示，帮助您自己写出这个程序。 转换视频为字符的程序通常需要执行以下步骤： 打开视频文件，并读取视频帧 将每一帧的像素值转换为字符 将字符写入输出文件或输出到屏幕 重复步骤2和3，直到视频处理完成 您可以使用视频处理库，如FFmpeg，来读取视频帧和获取像素数据。然后，您可以使用某种算法将像素转换为字符，并将字符写入文件或输出到屏幕。 希望这些信息...
C++ ：用字符画圣诞树
小天狼星_布莱克 的博客
12-28 1210
三天前是2022年的圣诞节~~我就用字符画了一棵圣诞树~~
OpenCV+C++实现视频字符画（附源码）
melanchoe的博客
03-16 4167
字符画实现基本思路 萌新小白为了实现这个功能真的是百度了很久很久，看了很多大佬的文章，终于我成功了Ψ(￣∀￣)Ψ。现在来分享一下我的大致思路。 思路分析 若相对整个视频进行字符画处理，则需要对视频的每一帧进行处理，读取视频的每一帧的代码如下： VideoCapture cap; cap.open("F:/opencv/images/test01.MP4"); if (!cap.isOpened()...
C++ Builder写的ZEC 汉字（姓名）生成ASCII字符画 v0.3
06-04
C++ Builder写的ZEC 汉字（姓名）生成ASCII字符画 v0.3
C++ Dev-C++ 字符画
qq_41084564的博客
06-28 987
┏┓ ┏┓┏┓ ┃┃┏━┳┳┳━┓┃┗┛┣━┳┳┓ ┃┗┫┃┃┃┃┻┫┗┓┏┫┃┃┃┃ ┗━┻━┻━┻━┛ ┗┛┗━┻━┛ cout<<"┏┓ ┏┓┏┓ "<<endl; cout<<"┃┃┏━┳┳┳━┓┃┗┛┣━┳┳┓ "<<endl; cout<<"┃┗┫┃┃┃┃┻┫┗┓┏┫┃┃┃┃"<<endl; cout<<"┗━┻━┻━┻━┛ ┗┛┗━┻━┛"&lt...
视频转字符动画c语言,HTML5视频转字符动画
weixin_39962758的博客
05-21 474
什么是视频转字符动画？大至就是一. 实现原理将视频拆分成独立的帧(等同于每换一个画面截一张图)将图转换成黑白图(如何将图片转成黑白自行百度)后，拿到每个像素点的颜色，点的rgb是相同的，是一个0~255的整数，0表示完全黑，255表示完全白准备一组字符，比如@#&!:,.这些字符同字号时的表面积应该是递增的且越多越好，对应2中的rgb数值，比如 @对应0，表示黑， .对应255表示白将...
100行代码让你的代码跳起舞（视频转字符画）
热门推荐
weixin_41813169的博客
08-15 6万+
思路分析 整体步骤分为三步： 对视频进行抽帧得到图片 对图片进行处理得到字符画 按照一定顺序和一定时间在终端打印字符画实现动画效果 最终效果 代码实现 第一步视频抽帧 # 第一步视频抽帧 def chouzhen(video_path): # 保存图片的路径 savedpath = video_path.split('.')[0] + '/'...
图片转字符画.exe
07-02
图片转字符画程序。 程序较为简陋，需手动输入图片的地址。 此处不建议复制文件属性中的地址会出现错误的。强烈建议手打。 前言详细介绍 https://blog.csdn.net/weixin_44983545/article/details/107086584 地址要...
C++&&Opencv实现控制台字符动画的方法
12-17
根据颜色所处的范围选择不同的字符 再在控制台的特定位置打印即可 重点就是获取像素点的颜色 获取图像中某像素点的颜色图片载入变量 opencv中可使用Mat类型来储存图片 Mat img; img = imread("图片路径"); 将图片...
c++ 急速狂飙 字符画小游戏（免费）
01-29
c++字符画游戏
ascii字符画生成工具
03-22
ascii字符画生成工具，上传图片生成ascii字符画，可调节大小精度，效果精美
字符/图片转换成字符画
06-05
图片/文字转换成字符拼成的图，很酷 图片/文字转换成字符拼成的图，很酷
OpenCV实现车牌字符分割(C++)
01-21
关于车牌定位可以看这篇文章： OpenCV车牌定位(C++) ，本文使用的图片也是来自这里。 先来看一看原图： 最左边的汉字本来是 沪，截取时只获得了右边一点点的部分，这与原图和获取方法都有关，对于 川、沪… 这一类...
图像处理 zhang细化算法 opencv C++代码 算法实现
05-25
在二值图像处理特别是OCR识别与匹配中，都要通过对字符进行细化以便获得图像的骨架，通过zhang-suen细化算法获得图像，作为图像的特征之一，常用来作为识别或者模式匹配。此代码用C++实现了这一算法，配有注释，简洁...
基于C++与opencv在图像上显示中文方案设计与实现
05-12
基于C++与opencv在图像上显示中文方案设计与实现
视频转换字符画视频
weixin_41982136的博客
04-29 3548
目录 文本信息 项目所用主要库 视频转换的原理 完整代码 代码中值得注意的事项 不足之处 视频压缩 文本信息 视频有一帧一帧的画面构成，利用字符替代画面中的像素信息，就可以将视频转换为字符画的视频，本文将利用python库，对一段视频进行转换，将其转换为字符串展示的视频，本文在文章——Python将视频转换为全字符视频（含音频）的参考下完成。以下代码及原视频可...
图片转为ASCII字符画的方法
lujx_1024的博客
06-21 2630
字符画是一系列字符的组合，我们可以把字符看作是比较大块的像素，一个字符能表现一种颜色（暂且这么理解吧），字符的种类越多，可以表现的颜色也越多，图片也会更有层次感。 问题来了，我们是要转换一张彩色的图片，这么多的颜色，要怎么对应到单色的字符画上去？
用C++实现在控制台输出红色爱心
m0_53061304的博客
04-05 1909
本篇文章介绍了如何使用C++来实现在控制台中输出红色爱心。通过学习这个小案例，大家可以了解到一些有趣的C++语法和API调用方法，同时也可以锻炼自己的编程能力和创造力。在开始之前，我们需要先了解几个知识点。首先是控制台颜色输出，可以通过Windows API提供的SetConsoleTextAttribute函数来设置控制台文字颜色。在日常编程中，我们经常需要使用C++来实现各种有趣的功能。本篇文章将介绍如何在控制台中输出红色爱心，通过这个小案例，大家可以了解到一些有趣的C++语法和API调用方法。
c++ 将图片转换为字符画
最新发布
07-27
将图片转换为字符画是一种将图片中的像素点映射为对应的字符的过程。通过使用不同的字符代替不同灰度级别的像素，可以在文本环境中显示出图像的近似效果。这种技术可以通过许多方式实现，包括使用程序编写的算法和在线字符画生成器。 生成字符画的过程通常包括以下几个步骤：首先，将原始图片转换为灰度图像，即使得每个像素点只有一个灰度值（黑白照片）。其次，将灰度图像中的像素值映射到一组字符中，例如使用ASCII码中的字符集。不同的灰度级别对应不同的字符。然后，将映射后的字符按照相应的排列方式，例如每行固定字符数或根据像素灰度级别进行排列，重新组织为文本文件。最后，将生成的文本文件输出显示，以呈现出与原始图像相似的字符画效果。 生成字符画的过程可以根据不同的需求和算法进行调整和优化。一些算法可以在转换过程中添加一些光影效果，以产生更真实的效果。此外，还可以通过改变字符的颜色或使用更多的字符集来增强字符画的细节和质量。 使用字符画的好处是可以在某些情况下以较小的文件大小传输和存储图像，也可以在文本环境中展示图像。字符画也有一定的美学价值和情怀意义，成为一种独特的艺术形式。 总之，将图片转换为字符画是一种将图像转换为文本形式的过程，可以通过一系列算法和字符映射方式来实现。这种技术可以在文本环境中显示图像的近似效果，有一定的实用性和美学价值。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值