一段小波编码程序(C++)

最新推荐文章于 2022-07-19 14:54:13 发布
最新推荐文章于 2022-07-19 14:54:13 发布
阅读量147 收藏 2
点赞数
文章标签： c/c++
原文链接：http://www.cnblogs.com/feathersky/archive/2008/12/18/1357501.html
版权

 有兴趣可以看看  因为有些部分不是我写的 所以我就不传全部了 只传我写的代码的一部分

如果能看懂小波变换与编码算法思想的人 应该可以看懂这段代码 否则还是不要看了

这段是EBCOT编码 当年我就这个编码花了比较长的时间才搞明白 其他的 EZW S+P等几个简单的 如果看懂了算法 代码很容易就可以编好的 所以那些代码就不帖了 我也不知道丢在哪里去了

 


ContractedBlock.gif ExpandedBlockStart.gif Code
#include <time.h>

#ifndef _EBCOT_H_
#define _EBCOT_H_

#include "stdio.h"
#include "stdlib.h"
#include "mq.h"

#define KRUN 9
#define KUNI 18

#define LL 0
#define LH 1
#define HL 2
#define HH 3

static char 
SIGNIFICANCE_TABLE1[3][3][5] =
{
    0,1,2,2,2,
    3,3,3,3,3,
    4,4,4,4,4,
    5,6,6,6,6,
    7,7,7,7,7,
    7,7,7,7,7,
    8,8,8,8,8,
    8,8,8,8,8,
};

static char 
SIGNIFICANCE_TABLE2[3][3][5] =
{
    0,1,2,2,2,
    5,6,6,6,6,
    8,8,8,8,8,
    3,3,3,3,3,
    7,7,7,7,7,
    4,4,4,4,4,
    7,7,7,7,7,
    8,8,8,8,8,
};

static char 
SIGNIFICANCE_TABLE3[5][5] =
{
    0,1,2,2,2,
    3,4,5,5,5,
    6,7,7,7,7,
    8,8,8,8,8,
    8,8,8,8,8,
};

static char 
SIGN_TABLE[3][3][2] =
{
    14,-1,
    13,-1,
    12,-1,
    11,-1,
    10,1,
    11,1,
    12,1,
    13,1,
    14,1,
};

#define HEIGHT 42
#define WIDTH  51

struct Tile
{
    short int  value[HEIGHT][WIDTH];    

    char  sign[HEIGHT][WIDTH];
    char  sig_state[HEIGHT][WIDTH];
    char  sig_state1[HEIGHT][WIDTH];
    
    char tilekind;
    char bp;

    int tileHeight;
    int tileWidth;
};

struct Tile tile;

char Sig(int h,int w)
{
//    return tile.sig_state[h-1][w-1]+tile.sig_state[h-1][w]+tile.sig_state[h-1][w+1]
//        +  tile.sig_state[h][w-1]+tile.sig_state[h][w+1]
 //       +  tile.sig_state[h+1][w-1]+tile.sig_state[h+1][w]+tile.sig_state[h+1][w+1];
    
    return  tile.sig_state[h][w-1]+tile.sig_state[h][w+1];
      
    /*
    int kh=tile.sig_state[h][w-1]   + tile.sig_state[h][w+1];
    int kv=tile.sig_state[h-1][w]   + tile.sig_state[h+1][w];
    int kd=tile.sig_state[h-1][w-1] + tile.sig_state[h-1][w+1] + tile.sig_state[h+1][w-1] + tile.sig_state[h+1][w+1];

    
    if(tile.tilekind==HL)   return SIGNIFICANCE_TABLE2[kh][kv][kd];
    
    if(tile.tilekind=HH)    return SIGNIFICANCE_TABLE3[kd][kh+kv];
    
    return SIGNIFICANCE_TABLE1[kh][kv][kd];    

    */
}


void Get_KSign_XFlip(int h,int w,char * Ksign,char * Xflip)
{
    int xh=tile.sign[h][w-1]*tile.sig_state[h][w-1]+tile.sign[h][w+1]*tile.sig_state[h][w+1];
    int xv=tile.sign[h-1][w]*tile.sig_state[h-1][w]+tile.sign[h+1][w]*tile.sig_state[h+1][w];

    int _xh=min(1,xh)*xh>0?1:-1;
    int _xv=min(1,xv)*xv>0?1:-1;

    *Ksign=SIGN_TABLE[_xh+1][_xv+1][0];
    *Xflip=SIGN_TABLE[_xh+1][_xv+1][1];

}

char Kmag(int h,int w)
{
//    char Ksign,Xflip;

    return tile.sig_state[h][w]+16;
//    if(tile.sig_state[h][w]==1) return 17;    

//    Get_KSign_XFlip(h,w,&Ksign,&Xflip);

//    if(Ksign>0) return 16;

    return 15;
}


//----------------------------------------

static char lastSign=1;

void Encode_Sign(int h,int w)
{
    if(tile.sign[h][w]==lastSign)
    {
        mq_encode(0,10);
    }
    else
    {
        mq_encode(1,10);
        lastSign ^= 1;
    }

    /*
    char Ksign,Xflip;

    Get_KSign_XFlip(h,w,&Ksign,&Xflip);

    if(tile.sign[h][w]*Xflip==1)
    {
        mq_encode(0,Ksign);
    }    
    else
    {
        mq_encode(1,Ksign);
    }
    */
}

void Decode_Sign(int h,int w)
{
    int x=mq_decode(10);

    if(x==0)
    {
        tile.sign[h][w]=lastSign;
    }
    else
    {
        lastSign ^= 1;
        tile.sign[h][w]=lastSign;    
    }

    /*
    char Ksign,Xflip;

    Get_KSign_XFlip(h,w,&Ksign,&Xflip);

    int x=mq_decode(Ksign);

    if(x==0)
    {
        tile.sign[h][w]=Xflip;
    }    
    else
    {
        tile.sign[h][w]=-Xflip;
    }
    */
}

void SeparateSign()
{
    int w,h;

    for(h=0; h<HEIGHT; h++)
    for(w=0; w<WIDTH;  w++)
    {
        if(tile.value[h][w]>=0) 
        {
            tile.sign[h][w]=1;
        }
        else
        {
            tile.sign[h][w]=0;
            tile.value[h][w]=-tile.value[h][w];
        }
    }
}

void CombinationSign()
{
    int w,h;

    for(h=0; h<HEIGHT; h++)
    for(w=0; w<WIDTH;  w++)
    {
        if(tile.sign[h][w]==0)         
            tile.value[h][w]=-tile.value[h][w];
    }
}

void Pass2()
{    
    int h,w;

    lastSign=1;

    for(h=1;  h<=tile.tileHeight;  h++)
    for(w=1;  w<tile.tileWidth;    w+=4)
    {
        
        char Vp;
        char r=0;
        
        
        if( (!tile.sig_state[h][w-1]) && (!tile.sig_state[h][w]) && (!tile.sig_state[h][w+1]) && (!tile.sig_state[h][w+2]) && (!tile.sig_state[h][w+3]) && (!tile.sig_state[h][w+4]) )
        {
            Vp=(tile.value[h][w+r] >> tile.bp) & 1;
            
            while(Vp==0)
            {
                if(++r==4) break;
                Vp=(tile.value[h][w+r] >> tile.bp) & 1;
            }
            
            if(r==4)
            {
                mq_encode(0,KRUN);
            }
            else
            {
                mq_encode(1,KRUN);
                mq_encode(r/2,KUNI);
                mq_encode(r%2,KUNI);
            }
        }
        
        for(; r<4; r++)
        {
            if(tile.sig_state[h][w+r]==0 )
            {
                Vp=(tile.value[h][w+r] >> tile.bp) & 1;
                
                mq_encode(Vp, Sig(h,w+r) );
                
                if(Vp)
                {
                    tile.sig_state[h][w+r]=1;        
                //    tile.sig_state1[h][w+r]=1;                    
                    Encode_Sign(h,w+r);
                }
            }
            else
            {
                Vp=(tile.value[h][w+r] >> tile.bp) & 1;

                mq_encode(Vp,Kmag(h,w+r) );
                
            //    tile.sig_state[h][w+r]=tile.sig_state1[h][w+r];
            }
        }
    }
    
}

void De_Pass2()
{
    int h,w;

    lastSign=1;

    for(h=1;  h<=tile.tileHeight;  h++)
    for(w=1;  w<tile.tileWidth;    w+=4)
    {
        
        char Vp;
        char r=0,x;
        
        
        if( (!tile.sig_state[h][w-1]) && (!tile.sig_state[h][w]) && (!tile.sig_state[h][w+1]) && (!tile.sig_state[h][w+2]) && (!tile.sig_state[h][w+3]) && (!tile.sig_state[h][w+4]) )
        {
            x=mq_decode(KRUN);
            
            if(x==0)
            {
                r=4;
            }
            else
            {
                r=mq_decode(KUNI);
                r=2*r+mq_decode(KUNI);
                //tile.value[h+r][w] |= (1<<tile.bp);
            }
        }    
        
        
        for(; r<4; r++)
        {
            if(tile.sig_state[h][w+r]==0 )
            {        
                Vp=mq_decode( Sig(h,w+r)  );
                
                tile.value[h][w+r] |= (Vp<<tile.bp);
                
                if(Vp)
                {    
                    tile.sig_state[h][w+r]=1;    
                //    tile.sig_state1[h][w+r]=1;        
                    Decode_Sign(h,w+r);
                }
            }
            else
            {
                tile.value[h][w+r] |= mq_decode( Kmag(h,w+r) )<<tile.bp;
                
                //tile.sig_state[h][w+r]=tile.sig_state1[h][w+r];
                
            }
        }    
    }
}

void InitEncode()
{
    memset(tile.value,      0, sizeof(short int)*WIDTH*HEIGHT);
}

int Encode(int highLayer,int lowLayer,unsigned char * pStream)
{
    int length=0;

    if(highLayer<lowLayer) return length;

    mq_enc_init(pStream);    
    
    memset(tile.sign,       0 ,sizeof(char)*3*WIDTH*HEIGHT);

    SeparateSign();

    tile.bp=highLayer;

    Pass2( );

    while(--tile.bp>=lowLayer)
    {
    
        Pass2();
    }

    length=mq_enc_flush();
    //mq_enc_flush();

    mq_enc_destroy();

    return length;

}

int Decode(int highLayer,int lowLayer,unsigned char * pStream)
{
    int length=0;

    if(highLayer<lowLayer) return length;
    
    mq_dec_init(pStream);    


    memset(tile.sign,       0 ,sizeof(char)*3*WIDTH*HEIGHT);
    memset(tile.value,      0, sizeof(short int)*WIDTH*HEIGHT);



    tile.bp=highLayer;

    De_Pass2();
    
    while(--tile.bp>=lowLayer)
    {
                
        De_Pass2();
    }

    CombinationSign();

    length=mq_dec_len();

    mq_dec_destroy();

    return length;
}

unsigned char stream[100000];

int testEBC2()
{
    short int   vv[HEIGHT][WIDTH];
    int h, w;
        int count=0,c=1;

    tile.tilekind=LL;

    tile.tileHeight=10;
    tile.tileWidth=10;


    memset(tile.value, 0, sizeof(short int  )*WIDTH*HEIGHT);

    tile.value[0][0]=0;
    tile.value[1][0]=0;
    tile.value[2][0]=0;
    tile.value[3][0]=0;
    tile.value[4][0]=0;

    tile.value[0][1]=0;
    tile.value[1][1]=-22;
    tile.value[2][1]=-1;
    tile.value[3][1]=18;
    tile.value[4][1]=-9;

    for(h=1; h<=tile.tileHeight; h++)
    for(w=1; w<=tile.tileWidth;  w++)
    {
        tile.value[h][w]=(h+w)%256;

        vv[h][w]=tile.value[h][w];
    }

    Encode(7,0,stream);

    memset(tile.value,0,sizeof( short int  )*WIDTH*HEIGHT);
    Decode(7,0,stream);

    for(h=1; h<=tile.tileHeight; h++)
    for(w=1; w<=tile.tileWidth;  w++)
    {
        c=vv[h][w]-tile.value[h][w];
        if(c!=0)
        {
            count++;
        }
    }

    return 0;
}

#endif

转载于:https://www.cnblogs.com/feathersky/archive/2008/12/18/1357501.html

weixin_30352645
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
一维小波变换的C++实现
11-22 1029
　　将小波展开系数当成离散信号，尺度函数和小波函数的MRA方程系数看成数字滤波器组，根据Mallat快速算法的原理，小波变换对数据的处理方法可简化成对信号逐级采样和滤波的过程。 图1 小波变换的滤波器实现 (a)分解算法 (b)重构算法 　　一层小波分解算法流程如图2所示，信号将先经过小波分解低通滤波器和高通滤波器，随后被降采样，实现数据重构。而滤波算法可简化为待处理信号与滤波...
小波分解java实例_小波变换分解C++源码
weixin_34211615的博客
02-27 421
【实例简介】VC实现的二维小波变换源代码.rarVC编写,具有小波变换,复原,图像融合等算法.经过调试,可以正常运行.rarwavelet.0.3.tar.gz图像处理中的小波变换C++源代码,含有使用文档和例子,非常全面!.rar图像小波变换的vc++代码,包括小波反变换WaveletTransform.rar基于Gabor小波变换的特征提取和人工智能的人脸检测系统源代码.rar基于小波变换的图...
C_C++ Wavelet小波分析之一维小波分解与重构
03-17
这是小波分解与重构的源代码，对于学习分析的人可以参考下，函数都是与MATLAB里面小波函数一致，可以直接使用DB4小波和SYM4小波，其他的类型的小波大家可以自己改改。
小波分析 C++库
踏月寻玉
04-15 4450
链接 Some C/C++ Wavelet libraries are listed below. Wavelet Geophysical Wavelet Library WvLib wavelet1d WAILI GNU Scientific Library or gsl see here for DWT documentation bli
关于C++程序的编码问题
12-22
我们传统的程序基本都只在Windows或只在Linux下运行，Windows程序使用简体中文GB18030编码，Linux程序则只使用英文，多年以来这些程序运行起来都没有问题。 　近年来，随着程序的组件化，部分代码特别是公用组件都...
小波滤波和小波包程序
06-12
简洁明了的小波滤波和小波包c++实现源代码，稍加修改就可以加入任何一个信号处理的应用程序中。
小波滤波和小波包程序.zip
05-30
简洁明了的小波滤波和小波包c++实现源代码，稍加修改就可以加入任何一个信号处理的应用程序中。 简洁明了的小波滤波和小波包c++实现源代码，稍加修改就可以加入任何一个信号处理的应用程序中。
c++ 几个实用小程序
09-29
c++ 上课练习用小程序，适合初学者的编程使用。在入门阶段，可以深刻的了解c++的程序结构和编码方式。
小波变换C＋＋程序代码
07-19
C++编写，进行小波变换的程序代码，可用于图像处理中的去噪、边缘检测、分割等。
二维小波变换源代码（C++实现）
11-10
二维小波变换源代码（C++实现），对学习图像处理非常有用
C++实现小波变换
02-08
教育C++写小波变换，小波变换的例子程序，还有一些源代码案例分析
c++实现的小波变换
05-28
小波变换的代码，有两种小波，分别是haar，sym2，处理效果还不错。
小波变换c++源码 实现了简单小波变化，有一定参考意义。
03-06
小波变换源码，c++。实现了简单小波变化，有一定参考意义。
小波变换网文精粹：小波变换和motion信号处理(六)
深入理解数字信号处理
04-15 3300
小波变换网文精粹：小波变换和motion信号处理(六) 转自：http://www.kunli.info/2011/02/15/fourier-wavelet-motion-signal-1/ 六、小波变换与傅立叶变换的比较         接下来，上几张图，我们以一些基本的信号处理来呈现小波变换比傅立叶变换好的地方，我保证，你看了这个比较之后，大概能隐约感受到小波变换的强大，并对背后的原理
小波学习之二（单层一维离散小波变换DWT的Mallat算法C++实现优化）
ASS-ASH的博客
07-19 1181
这样得到的y=[x(3)x(2)x(1)x(1)x(2)x(3)x(4)x(5)x(6)x(7)x(7)x(6)x(5)]3、最后就是下采样即隔点采样，其下采样是按照式a=z(22length(z))进行的，高频低频部分均如此，项数为floor（(7+4-1)/2）。这里设Lo_D=[h(1)h(2)h(3)h(4)]。最后的dwt低频系数结果是[z(2)z(4)z(6)z(8)z(10)]，高频系数求解过程和低频系数一样，在此不再赘述。...
数字图像处理，二维图像小波阈值去噪的C++实现（matlab验证）
热门推荐
EbowTang的练习场
10-26 2万+
一，小波阈值去噪基本理论 引言 图像在获取或传输过程中会因各种噪声的干扰使质量下降,这将对后续图像的处理产生不利影响.
连续小波变换算法的C++实现
weixin_34223655的博客
10-01 867
2019独角兽企业重金招聘Python工程师标准>>> ...
写一段c++程序
最新发布
05-30
好的，以下是一个简单的 C++ 程序，它会输出 "Hello, world!"： ```cpp #include int main() { std::cout , world!" ; return 0; } ``` 这段代码会包含头文件 `iostream`，并定义了一个 `main` 函数，它使用 `...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值