位运算的相关操作

于 2022-12-01 22:48:28 发布
阅读量241 收藏
点赞数
文章标签： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_54005982/article/details/128140298
版权

#define _CRT_SECURE_NO_WARNINGS//必须放在第一行
#include <stdio.h>
#include <assert.h>
#include <string.h>
#include <stdlib.h>
#include <time.h>

/*
* 1.位运算的应用
* 
* 2.2048(调试)
*/

//统计一个字节的数据二进制1的个数
//例如1->1,2->1,3->2,4->1,-1->8
int GetBits1(unsigned char ch)
{
    int count = 0;
    while (ch != 0)//0b1000 0000->8次
    {
        //if ((ch & 1) == 1)
        //    count++;
        count += (ch & 1);
        ch >>= 1;
    }
    return count;
}

int GetBits2(unsigned char ch)
{
    int count = 0;
    while (ch != 0) //1000 0000
    {
        count++;
        ch &= (ch - 1);//丢弃二进制最右边的1
    }
    return count;
}

int GetBits(unsigned char ch)
{
    int bits[256] = {0,1,1,2,1,2,2,3,1};//.... 查表法

    return bits[ch];
}

//int main()
//{
//    printf("%d\n",GetBits(0));//0
//    printf("%d\n", GetBits(1));//1
//    printf("%d\n", GetBits(2));//1
//    printf("%d\n", GetBits(3));//2
//    printf("%d\n", GetBits(4));//1
//    printf("%d\n", GetBits(5));//2
//    printf("%d\n", GetBits(6));//2
//    printf("%d\n", GetBits(-1));//8
//
//    return 0;
//}

//int main()
//{
//    //srand(3);
//    srand(time(NULL));
//
//    for (int i = 0; i < 10; i++)
//    {
//        printf("%d ",rand());
//    }
//    return 0;
//}

//#include <conio.h>
//
//int main()
//{
//    //char ch = getchar();
//    char ch = _getch();//不带回显
//    printf("输入的字符=%c\n",ch);
//
//    return 0;
//}

//#include <graphics.h>        // 引用图形库头文件
//#include <conio.h>
//int main()
//{
//    initgraph(640, 480);    // 创建绘图窗口，大小为 640x480 像素
//    circle(200, 200, 100);    // 画圆，圆心(200, 200)，半径 100
//    _getch();                // 按任意键继续
//    closegraph();            // 关闭绘图窗口
//    return 0;
//}

///
// 程序名称：图像处理——素描算法
// 编译环境：Mictosoft Visual Studio 2013, EasyX_20200315(beta)
// 作　　者：luoyh <2864292458@qq.com>
// 最后修改：2021-11-2
//

#include<graphics.h>
#include<conio.h>
#include<stdio.h>
#include<cmath>

const double PI = acos(-1.0);
const double delta = 1.5;
const int pic_Dis = 3;
double P[pic_Dis][pic_Dis];
void GetP();                        // 获取高斯滤波算子

class Algorithm
{
public:
    Algorithm(IMAGE* img, int width, int heigth);
    void Histogram();                // 类似直方图均衡化
    void Gray();                    // 灰度处理
    void Film();                    // 负片处理
    void Blur();                    // 高斯模糊化处理
    void Sketch();                    // 素描算法

private:
    IMAGE* pimg;
    int WIDTH;
    int HEIGHT;
};

Algorithm::Algorithm(IMAGE* img, int width, int height)
{
    pimg = img;
    WIDTH = width;
    HEIGHT = height;
};

void Algorithm::Film()
{
    DWORD* pMem = GetImageBuffer(pimg);
    for (int i = pimg->getwidth() * pimg->getheight() - 1; i >= 0; i--)
        pMem[i] = (~pMem[i]) & 0x00FFFFFF;
}

void Algorithm::Sketch()        // 素描
{
    IMAGE* gray, * guassian;
    Histogram();                // 直方图
    Gray();                        // 灰度处理
    gray = new IMAGE();
    guassian = new IMAGE();
    *gray = *pimg;
    Film();                        //底片处理

    // 这里需要考虑的是模糊化处理的次数
    for (int i = 0; i < 10; i++)
    {
        Blur();  //模糊算法
    }
    *guassian = *pimg;
    *pimg = *gray;
    DWORD* pMem = GetImageBuffer(pimg);
    DWORD* Gray = GetImageBuffer(gray);
    DWORD* Guassian = GetImageBuffer(guassian);

    int R, G, B;
    int RR, GG, BB;
    for (int i = WIDTH * HEIGHT - 1; i >= 0; i--)
    {
        R = GetRValue(Gray[i]);
        B = GetBValue(Gray[i]);
        G = GetGValue(Gray[i]);
        RR = GetRValue(Guassian[i]);
        BB = GetBValue(Guassian[i]);
        GG = GetGValue(Guassian[i]);
        int r = min(R + (R * RR) / (255 - RR), 255);
        int g = min(G + (G * GG) / (255 - GG), 255);
        int b = min(B + (B * BB) / (255 - BB), 255);
        pMem[i] = RGB(r, g, b);
    }
    delete (gray);
    delete(guassian);
}


void Algorithm::Histogram()        // 类似直方图
{
    DWORD* p_data = GetImageBuffer(pimg);
    int height = HEIGHT;
    int wide = WIDTH;
    int pr[256], pg[256], pb[256];
    int size = HEIGHT * WIDTH;
    for (int p = 0; p <= 255; p++)
    {
        int nr = 0, ng = 0, nb = 0;
        for (int j = 0; j < height; j++)
        {
            for (int i = 0; i < wide; i++)
            {
                if (p == GetRValue(p_data[j * wide + i]))
                {
                    nr++;
                }
                if (p == GetGValue(p_data[j * wide + i]))
                {
                    ng++;
                }
                if (p == GetBValue(p_data[j * wide + i]))
                {
                    nb++;
                }
            }
        }
        pr[p] = nr;
        pg[p] = ng;
        pb[p] = nb;
    }
    double sr[256] = { 0 }, sg[256] = { 0 }, sb[256] = { 0 };
    double aver = 0;
    double aveg = 0;
    double aveb = 0;
    bool T = true;
    bool K = true;
    bool P = true;
    int numr, numg, numb;
    for (int i = 0; i <= 255; i++)
    {
        if (T)
        {
            aver += pr[i] / double(size);
            sr[i] = aver;
            if (aver == 1)
            {
                numr = i;
                T = false;
            }
        }
        if (K)
        {
            aveg += pg[i] / double(size);
            sg[i] = aveg;
            if (aveg == 1)
            {
                numg = i;
                K = false;
            }
        }
        if (P)
        {
            aveb += pb[i] / double(size);
            sb[i] = aveb;
            if (aveb == 1)
            {
                numb = i;
                P = false;
            }
        }
    }
    int ssr[256] = { 0 }, ssg[256] = { 0 }, ssb[256] = { 0 };
    int rx = 0, gx = 0, bx = 0;
    for (int i = 0; i <= 255; i++)
    {
        if (i == 0)
        {
            ssr[i] = 0;
            ssg[i] = 0;
            ssb[i] = 0;
        }
        ssr[i] = (int)(255 * sr[i]);
        ssg[i] = (int)(255 * sg[i]);
        ssb[i] = (int)(255 * sb[i]);
    }

    int r = 0, g = 0, b = 0;
    double myr = 0, myg = 0, myb = 0;
    for (int j = 0; j < height; j++)
    {
        for (int i = 0; i < wide; i++)
        {
            myr = ssr[GetRValue(p_data[j * wide + i])];
            myg = ssg[GetGValue(p_data[j * wide + i])];
            myb = ssb[GetBValue(p_data[j * wide + i])];
            p_data[j * wide + i] = RGB(myr, myg, myb);
        }
    }
};

void Algorithm::Gray()
{
    DWORD* p = GetImageBuffer(pimg);
    COLORREF c;
    for (int i = pimg->getwidth() * pimg->getheight() - 1; i >= 0; i--)
    {
        c = BGR(p[i]);
        c = (GetRValue(c) * 299 + GetGValue(c) * 587 + GetBValue(c) * 114 + 500) / 1000;
        p[i] = RGB(c, c, c);        // 由于是灰度值，无需再执行 BGR 转换
    }
}

void Algorithm::Blur()
{
    GetP();
    BYTE* R;
    BYTE* G;
    BYTE* B;
    int size = HEIGHT * WIDTH;
    R = (BYTE*)calloc(size, sizeof(BYTE));
    G = (BYTE*)calloc(size, sizeof(BYTE));
    B = (BYTE*)calloc(size, sizeof(BYTE));

    DWORD* pMem = GetImageBuffer(pimg);

    for (int i = 0; i < size; i++)
    {
        R[i] = GetRValue(pMem[i]);
        G[i] = GetGValue(pMem[i]);
        B[i] = GetBValue(pMem[i]);
    }

    for (int i = WIDTH; i < WIDTH * (HEIGHT - 1); i++)
    {
        if (i % 500 != 0 || (i + 1) % 500 != 0)
        {
            pMem[i] = RGB(R[i - (WIDTH + 1)] * P[0][0] + R[i - WIDTH] * P[0][1] + R[i - (WIDTH - 1)] * P[0][2] + R[i - 1] * P[1][0] + R[i] * P[1][1] + R[i + 1] * P[1][2] + R[i + (WIDTH - 1)] * P[2][0] + R[i + WIDTH] * P[2][1] + R[i + (WIDTH + 1)] * P[2][2],
                G[i - (WIDTH + 1)] * P[0][0] + G[i - WIDTH] * P[0][1] + G[i - (WIDTH - 1)] * P[0][2] + G[i - 1] * P[1][0] + G[i] * P[1][1] + G[i + 1] * P[1][2] + G[i + (WIDTH - 1)] * P[2][0] + G[i + WIDTH] * P[2][1] + G[i + (WIDTH + 1)] * P[2][2],
                B[i - (WIDTH + 1)] * P[0][0] + B[i - WIDTH] * P[0][1] + B[i - (WIDTH - 1)] * P[0][2] + B[i - 1] * P[1][0] + B[i] * P[1][1] + B[i + 1] * P[1][2] + B[i + (WIDTH - 1)] * P[2][0] + B[i + WIDTH] * P[2][1] + B[i + (WIDTH + 1)] * P[2][2]);
        }
    }
    free(R);
    free(G);
    free(B);
    R = G = B = NULL;
}

int main()
{
    int    width = 0;
    int    height = 0;
    IMAGE g_img;
    loadimage(&g_img, _T("1.jpg"));    // 加载图片
    width = g_img.getwidth();
    height = g_img.getheight();
    initgraph(width, height);
    putimage(0, 0, &g_img);
    _getch();
    Algorithm myA(&g_img, width, height);
    myA.Sketch();
    putimage(0, 0, &g_img);
    _getch();
    return 0;
}

void GetP()
{
    for (int i = 0; i < pic_Dis; i++)
    {
        for (int j = 0; j < pic_Dis; j++)
        {
            int d = (i - 1) * (i - 1) + (j - 1) * (j - 1);
            double x = 1 / (2 * PI * delta);
            P[i][j] = x * exp(-d / (2 * delta));
        }
    }

    double pn = 0;

    for (int i = 0; i < pic_Dis; i++)
    {
        for (int j = 0; j < pic_Dis; j++)
        {
            pn += P[i][j];
        }
    }

    for (int i = 0; i < pic_Dis; i++)
    {
        for (int j = 0; j < pic_Dis; j++)
        {
            P[i][j] = P[i][j] / pn;
        }
    }
}

liuyani12138
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
如何在PB中进行位操作以及二进制与十进制转换（摘录）
欢迎来到 Balloonman2002 之家,:)
01-04 4213
原文：PFC 本文拟结合PFC中所提供的pfc_n_cst_numerical对象，讲解如何在PB脚本中实现位操作以及二进制与十进制相互转换。 （一）编写十进制转换成二进制的函数：public function string of_binary (long al_decimal);integer  li_remainderstring  ls_binary=If I
PB位操作函数
04-01
PB位操作函数 内含源代码 支持接口开发
位运算基本知识和相关操作
01-17
信息科学技术学院《程序设计实习》，位运算相关知识，高效编程必备
C#位运算以及实例计算详解
12-31
程序中的所有内容在计算机内存中都是以二进制的形式储存的（即：0或1），位运算就是直接对在内存中的二进制数的每位进行运算操作。 了解： 在C#中可以对整型运算对象按位进行逻辑运算。按位进行逻辑运算的意义是：...
Java位操作工具类
10-14
经常项目中用到的Java的位运算相关的方法,稍微整理了下 详细介绍可参考博客 http://longshaojian.iteye.com/admin/blogs/1946865 请多指教！
arm学习——有关位操作的总结
08-03
在学习arm的过程中，感觉寄存器，基本不会提供位操作，而是整体的操作， 整体操作的就是要注意在对某位赋值的时候不要影响到其他位，看上去不简单，其实，整体操作有技巧，那么就来总结一下。
C#中的位操作小结
01-20
位操作符是对数据按二进制位进行运算的操作符。位操作是其他很多语言都支持的操作,如C、C++和Java等，C#也不例外支持位操作。注意位操作支持的数据类型是基本数据类型，如byte、short、char、int、long等，C#支持的...
如何在PB中进行位操作以及二进制与十进制转换
wljcom的专栏
02-07 1911
一、编写十进制转换成二进制的函数 public function string of_binary (long al_decimal);integer li_remainder string ls_binary= If IsNull(al_decimal) or al_decimalstring ls_null SetNull(ls_null) Return ls_null End I
pb程序在64位操作系统上使用Instant Client 连接oracle数据库
张振磊的博客
03-04 5488
有时候客户端只想实现能够连接上服务器端oracle数据库，完全没必要安装庞大的客户端。下面我将讲解一下如何通过即时客户端（Instant Client）连接上oracle数据库。 Instant Client下载地址http://www.oracle.com/technetwork/database/features/instant-client/index-097480.html。 注意：因
PB中位操作的实现代码
cn889002的博客
11-22 297
（三）编写公用函数以逐位获取BIT位数据： public function boolean of_getbit (long al_decimal, unsignedinteger ai_bit);Boolean...
java 常量的位运算使用案例
weixin_30525825的博客
12-20 159
在编码的过程中，有时因业务逻辑需要，一个关键字有多个数值，且在调用过程中，此关键字数值对应的各位数值有不同的业务需求，就需要对常量进行位运算； eg：有关键字status，其中（注：位指二进制运算对应的位）： 位1：是否被屏蔽？ 1-是，0-否 位2：是否包含视频？ 1-是，0-否 位3：是否审核通过？ 1-是，0-否 位4：是否已删...
lua位运算 包含什么文件
最新发布
12-23
在lua的位运算中，通常包含了一些基本的文件，例如位运算的运算符文件（例如 AND、OR、XOR、NOT 等），位运算的相关函数文件（例如 bit.band、bit.bor、bit.bxor、bit.bnot 等），以及其他与位运算相关的辅助文件。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值