行程码压缩算法

最新推荐文章于 2025-02-12 16:44:14 发布
最新推荐文章于 2025-02-12 16:44:14 发布
阅读量3k 收藏 2
点赞数
分类专栏： 算法 文章标签： 压缩 数据 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/goodcrony/article/details/78132000
版权

行程码压缩算法原理参考以下链接

http://www.cnblogs.com/hwl1023/p/5129696.html


以下为具体实现：

1、原始RLE方法

给出的数据序列为：A-A-A-A-A-B-B-C-D

未压缩前：A-A-A-A-A-B-B-C-D

（0x41-0x41-0x41-0x41-0x41-0x42-0x42-0x43-0x44）

压缩后：5-A-2-B-1-C-1-D

（0x05-0x41-0x02-0x42-0x01-0x43-0x01-0x44）


/* Compress inBuf to outBuf
 * Input:
 *  inSize:  input buf size
 *  inBuf:  input buf, need compress
 *  outSize: output buf size, reality outSize <= 2*inSize, but suggest outSize = 2*inSize
 * Output:
 *  outBuf: compressed buf address
 * Return:
 *  0:  Err, input para fault
 *  1:  Err, outSize < reality compressed buf size
 *  >= 2: Succ, reality used compressed buf size
 *
 * List: A-A-A-A-A-B-B-C-D
 * Before: A-A-A-A-A-B-B-C-D
 * (0x41-0x41-0x41-0x41-0x41-0x42-0x42-0x43-0x44)
 * Compressed: 5-A-2-B-1-C-1-D
 * (0x05-0x41-0x02-0x42-0x01-0x43-0x01-0x44)
*/
#define RLE_MAX_NUM    0xFF
int RLE_Compress(int inSize, unsigned char *inBuf, int outSize, unsigned char *outBuf)
{
	int i=0, j=0;
    int rptNum = 0;

    if(inSize<=0 || outSize<=0) return 0;
    if(!inBuf || !outBuf) return 0;

	rptNum = 1;
    for(i=0; i
   
   
    
     outSize-2) goto done;
			outBuf[j++] = rptNum;
			outBuf[j++] = inBuf[i];
			rptNum = 1;
        }else{
            if(rptNum == RLE_MAX_NUM){
                if(j > outSize-2) goto done;
                outBuf[j++] = RLE_MAX_NUM;
                outBuf[j++] = inBuf[i];
                rptNum = 0;
            }
            rptNum++;            
        }
    }
    if(rptNum > 0){
		if(j > outSize-2) goto done;
		outBuf[j++] = rptNum;
        outBuf[j++] = inBuf[i++];
	}

done:
    printf("RLE_Compress: inSize=%d, inLen=%d, outSize=%d, cmpSize=%d\n",
           inSize, i, outSize, j);

    if(i != inSize)
        return 1;
    else
        return j;
}

/* uncompress data
 * Input:
 *  inSize      compressed data size
 *  inBuf       compressed data buf
 *  outSize     uncompress data buf size
 * Output:
 *  outBuf      uncompress data buf address
 *  inLen       reality use'd compressed data size
 * Return:
 *  <=  0       failure
 *  >   0       success, reality uncompress data size
*/
int RLE_UnCompress(int inSize, unsigned char *inBuf, int outSize, unsigned char *outBuf, int *inLen)
{
    int i=0, j=0;
	int len, sign;

    if(inSize <= 0 || outSize <= 0) return -1;
    if(!inBuf || !outBuf) return -1;


    *inLen = 0;
    for(i=0; i
    
    
     
      0){
            if(len+j > outSize){
				break;
			}
            memset(outBuf+j, sign, len);
            j += len;
        }else{    
            break;
        }
    }

    *inLen = i;

    printf("RLE_UnCompress: inSize=%d inLen=%d, outSize=%d unCmpSize=%d\n", inSize, i, outSize, j);
    return j;
}

int RLE_test()
{
	int size1, size2;
    unsigned char src[]={0x0, 0x13, 0x65, 0x95, 0x65, 0x49, 0x55, 0x65, 0x96,
                         0x59, 0x5a, 0x65, 0x59, 0x55, 0xa6, 0x65};
//    unsigned char src[] = {'a', 'b', 'c', 'd', 'e', 'f'};
    unsigned char cmpBuf[1024];
    unsigned char uncmpBuf[1024];

    size1 = RLE_Compress(sizeof(src), src, 1024, cmpBuf);
	printf("size1=%d\n", size1);

	int len;
    size2 = RLE_UnCompress(size1, cmpBuf, 1024, uncmpBuf, &len);
    printf("size2=%d\n", size2);

	printf("-----------------src--------------------\n");
	for(int i=0; i

2、RLE改进一

下面是RLE改进一的形象举例说明：给出的数据序列为：A-A-A-A-A-B-B-C-D

未压缩前：A-A-A-A-A-B-B-C-D

（0x41-0x41-0x41-0x41-0x41-0x42-0x42-0x43-0x44）

压缩后：5-A-2-B-C-D

（0xC5-0x41-0xC2-0x42-0x43-0x44）

/* Compress inBuf to outBuf
 * Input:
 *  inSize:  input buf size
 *  inBuf:  input buf, need compress
 *  outSize: output buf size, reality outSize <= 2*inSize, but suggest outSize = 2*inSize
 * Output:
 *  outBuf: compressed buf address
 * Return:
 *  0:  Err, input para fault
 *  1:  Err, outSize < reality compressed buf size
 *  >= 2: Succ, reality used compressed buf size
 *
 * List: A-A-A-A-A-B-B-C-D
 * Before: A-A-A-A-A-B-B-C-D
 * (0x41-0x41-0x41-0x41-0x41-0x42-0x42-0x43-0x44)
 * Compressed: 5-A-2-B-C-D
 * (0xC5-0x41-0xC2-0x42-0x43-0x44)
*/
#define RLE_ADV1_MAX_NUM    0x3F
#define REL_ADV1_MARK       0xC0
int RLE_ADV1_Compress(int inSize, unsigned char *inBuf, int outSize, unsigned char *outBuf)
{
    int i=0, j=0;
    int rptNum = 0;

    if(inSize<=0 || outSize<=0) return 0;
    if(!inBuf || !outBuf) return 0;

    rptNum = 1;
    for(i=0; i
    
    
     
      1){
                if(j > outSize - 2) goto done;
                outBuf[j++] = rptNum | REL_ADV1_MARK;
                outBuf[j++] = inBuf[i];
                rptNum = 1;
            }else{
                if(inBuf[i] >= REL_ADV1_MARK){
                    if(j > outSize - 2) goto done;
                    outBuf[j++] = 1 | REL_ADV1_MARK;
                    outBuf[j++] = inBuf[i];
                }else{
                    if(j > outSize) goto done;
                    outBuf[j++] = inBuf[i];
                }
            }
        }else{
            if(rptNum == RLE_ADV1_MAX_NUM){
                if(j > outSize-2) goto done;
                outBuf[j++] = RLE_ADV1_MAX_NUM | REL_ADV1_MARK;
                outBuf[j++] = inBuf[i];
                rptNum = 0;
            }
            rptNum++;
        }
    }
    if(rptNum > 0){
        if(inBuf[i] >= REL_ADV1_MARK){
            if(j > outSize - 2) goto done;
            outBuf[j++] = 1 | REL_ADV1_MARK;
            outBuf[j++] = inBuf[i++];
        }else{
            if(j > outSize) goto done;
            outBuf[j++] = inBuf[i++];
        }
    }

done:
    printf("RLE_ADV1_Compress: inSize=%d, inLen=%d, outSize=%d, cmpSize=%d\n",
           inSize, i, outSize, j);

    if(i != inSize)
        return 1;
    else
        return j;
}

/* uncompress data
 * Input:
 *  inSize      compressed data size
 *  inBuf       compressed data buf
 *  outSize     uncompress data buf size
 * Output:
 *  outBuf      uncompress data buf address
 *  inLen       reality use'd compressed data size
 * Return:
 *  <=  0       failure
 *  >   0       success, reality uncompress data size
*/
int RLE_ADV1_UnCompress(int inSize, unsigned char *inBuf, int outSize, unsigned char *outBuf, int *inLen)
{
    int i=0, j=0;
    int len;

    if(inSize <= 0 || outSize <= 0) return -1;
    if(!inBuf || !outBuf) return -1;


    *inLen = 0;
    for(i=0; i
     
     
      
       REL_ADV1_MARK){
//            len = inBuf[i] & RLE_ADV1_MAX_NUM;
            len = inBuf[i] & ~REL_ADV1_MARK;
            if(len+j > outSize){
                break;
            }
            memset(outBuf+j, inBuf[i+1], len);
            j += len;
            i++;
        }else{
            if(j >= outSize){
                break;
            }
            outBuf[j++] = inBuf[i];
        }
    }
    if(i == inSize - 1 && inBuf[i] < REL_ADV1_MARK){
        if(j < outSize){
            outBuf[j++] = inBuf[i++];
        }
    }

    *inLen = i;

    printf("RLE_ADV1_UnCompress: inSize=%d inLen=%d, outSize=%d unCmpSize=%d\n", inSize, i, outSize, j);
    return j;
}

int RLE_ADV1_test()
{
    int size1, size2;
    unsigned char src[]={'a', 'a', 'a', 'a', 'a', 'a', 'a', 'b', 'b', 'c', 'd',
                         'e', 'e', 'e', 'e', 'e', 'f', 'g', 'h', 0xc0, 0xcf};
//    unsigned char src[] = {'a', 'b', 'c', 'd', 'e', 'f'};
    unsigned char cmpBuf[1024];
    unsigned char uncmpBuf[1024];

    size1 = RLE_ADV1_Compress(sizeof(src), src, 1024, cmpBuf);

    int len;
    size2 = RLE_ADV1_UnCompress(size1, cmpBuf, 1024, uncmpBuf, &len);

    printf("-----------------src--------------------\n");
    for(int i=0; i

3、RLE改进二

下面是该RLE改进二的形象举例说明：给出的数据序列为：A-A-A-A-A-B-B-C-D

未压缩前：A-A-A-A-A-B-B-C-D

（0x41-0x41-0x41-0x41-0x41-0x42-0x42-0x43-0x44）

压缩后：5-A-4-B-B-C-D


/* Compress inBuf to outBuf
 * Input:
 *  inSize:  input buf size
 *  inBuf:  input buf, need compress
 *  outSize: output buf size, reality outSize <= 2*inSize, but suggest outSize = 2*inSize
 * Output:
 *  outBuf: compressed buf address
 * Return:
 *  0:  Err, input para fault
 *  1:  Err, outSize < reality compressed buf size
 *  >= 2: Succ, reality used compressed buf size
 *
 * List: A-A-A-A-A-B-B-C-D
 * Before: A-A-A-A-A-B-B-C-D
 *(0x41-0x41-0x41-0x41-0x41-0x42-0x42-0x43-0x44)
 * Compressed: 5-A-4-B-B-C-D
 * (0x85-0x41-0x84-0x42-0x42-0x43-0x44)
*/
#define RLE_ADV2_MAX_NUM    0x7F
#define REL_ADV2_MARK       0x80
int RLE_ADV2_Compress(int inSize, unsigned char *inBuf, int outSize, unsigned char *outBuf)
{
    int i=0, j=0;
    int rptNum = 0;
    int isRpt = 0;

    if(inSize<=0 || outSize<=0) return 0;
    if(!inBuf || !outBuf) return 0;

    rptNum = 1;
    isRpt = 1;
    for(i=0; i
     
     
      
       2){
                if(j > outSize - 2) goto done;
                outBuf[j++] = rptNum | REL_ADV2_MARK;
                outBuf[j++] = inBuf[i];
                rptNum = 0;
            }else{
                if(rptNum == RLE_ADV2_MAX_NUM){
                    if(j > outSize - rptNum - 1) goto done;
                    outBuf[j++] = rptNum;
                    memcpy(outBuf+j, inBuf+i-rptNum+1, rptNum);
                    j += rptNum;
                    rptNum = 0;
                }
            }
            rptNum++;
            isRpt = 0;
        }else{
            if(!isRpt && rptNum > 1){
                rptNum--;
                if(j > outSize - rptNum - 1) goto done;
                outBuf[j++] = rptNum;
                memcpy(outBuf+j, inBuf+i-rptNum, rptNum);
                j += rptNum;
                rptNum = 1;
            }
            if(rptNum == RLE_ADV2_MAX_NUM){
                if(j > outSize-2) goto done;
                outBuf[j++] = rptNum | REL_ADV2_MARK;
                outBuf[j++] = inBuf[i];
                rptNum = 0;
            }
            rptNum++;
            isRpt = 1;
        }
    }
    if(isRpt && rptNum > 2){
        if(j > outSize - 2) goto done;
        outBuf[j++] = rptNum | REL_ADV2_MARK;
        outBuf[j++] = inBuf[i];
    }else {
        if(j > outSize - rptNum - 1) goto done;
        outBuf[j++] = rptNum;
        memcpy(outBuf+j, inBuf+i-rptNum+1, rptNum);
        j += rptNum;
    }
    i++;

done:
    printf("RLE_ADV2_Compress: inSize=%d, inLen=%d, outSize=%d, cmpSize=%d\n",
           inSize, i, outSize, j);

    if(i != inSize)
        return 1;
    else
        return j;
}

/* uncompress data
 * Input:
 *  inSize      compressed data size
 *  inBuf       compressed data buf
 *  outSize     uncompress data buf size
 * Output:
 *  outBuf      uncompress data buf address
 *  inLen       reality use'd compressed data size
 * Return:
 *  <=  0       failure
 *  >   0       success, reality uncompress data size
*/
int RLE_ADV2_UnCompress(int inSize, unsigned char *inBuf, int outSize, unsigned char *outBuf, int *inLen)
{
    int i=0, j=0;
    int len;

    if(inSize <= 0 || outSize <= 0) return -1;
    if(!inBuf || !outBuf) return -1;

    *inLen = 0;
    while(i
      
      
       
        REL_ADV2_MARK){
//            len = inBuf[i] & RLE_ADV2_MAX_NUM;
            len = inBuf[i] & (~REL_ADV2_MARK);
            if(len+j > outSize){
                break;
            }
            memset(outBuf+j, inBuf[i+1], len);
            j += len;
            i += 2;
        }else{
            len = inBuf[i];
            if(i + 1 + len > inSize){
                break;
            }
            memcpy(outBuf+j, inBuf+i+1, len);
            j += len;
            i += (len + 1);
        }
    }

    *inLen = i;

    printf("RLE_ADV2_UnCompress: inSize=%d inLen=%d, outSize=%d unCmpSize=%d\n", inSize, i, outSize, j);
    return j;
}

int RLE_ADV2_test()
{
    int size1, size2;
    unsigned char src[]={'a', 'a', 'a', 'a', 'a', 'a', 'a', 'b', 'b', 'c', 'd',
                         'e', 'e', 'e', 'e', 'e', 'f', 'g', 'h', 0xc0, 0xcf};
//    unsigned char src[] = {'a', 'b', 'c', 'd', 'e', 'f'};
    unsigned char cmpBuf[1024];
    unsigned char uncmpBuf[1024];

    size1 = RLE_ADV2_Compress(sizeof(src), src, 1024, cmpBuf);

    int len;
    size2 = RLE_ADV2_UnCompress(size1, cmpBuf, 1024, uncmpBuf, &len);

    printf("-----------------src--------------------\n");
    for(int i=0; i

4、RLE改进三


/* Compress inBuf to outBuf
 * Input:
 *  inSize:  input buf size
 *  inBuf:  input buf, need compress
 *  outSize: output buf size, reality outSize <= 2*inSize, but suggest outSize = 2*inSize
 * Output:
 *  outBuf: compressed buf address
 * Return:
 *  0:  Err, input para fault
 *  1:  Err, outSize < reality compressed buf size
 *  >= 2: Succ, reality used compressed buf size
 *
 * List: A-A-A-A-A-B-B-C-D
 * Before: A-A-A-A-A-B-B-C-D
 *(0x41-0x41-0x41-0x41-0x41-0x42-0x42-0x43-0x44)
 * Compressed: 5-A-2-B-2-C-D
 * (0x85-0x41-0x82-0x42-0x82-0x43-0x44)
*/
#define RLE_ADV3_MAX_NUM    0x7F
#define REL_ADV3_MARK       0x80
int RLE_ADV3_Compress(int inSize, unsigned char *inBuf, int outSize, unsigned char *outBuf)
{
    int i=0, j=0;
    int rptNum = 0;
    int isRpt = 0;

    if(inSize<=0 || outSize<=0) return 0;
    if(!inBuf || !outBuf) return 0;

    rptNum = 1;
    isRpt = 0;
    for(i=0; i
       
       
        
         outSize - 2) goto done;
                if(rptNum == RLE_ADV3_MAX_NUM && j > outSize -3) goto done;
                outBuf[j++] = rptNum | REL_ADV3_MARK;
                if(rptNum == RLE_ADV3_MAX_NUM) outBuf[j++] = REL_ADV3_MARK;
                outBuf[j++] = inBuf[i];
                rptNum = 0;
                isRpt = 0;
            }else{
                if(rptNum == RLE_ADV3_MAX_NUM){
                    if(j > outSize - rptNum - 1) goto done;
                    outBuf[j++] = rptNum;
                    memcpy(outBuf+j, inBuf+i-rptNum+1, rptNum);
                    j += rptNum;
                    rptNum = 0;
                }
            }
            rptNum++;
        }else{
            if(!isRpt){
                if(rptNum > 1){
                    rptNum--;
                    if(j > outSize - rptNum - 1) goto done;
                    outBuf[j++] = rptNum;
                    memcpy(outBuf+j, inBuf+i-rptNum, rptNum);
                    j += rptNum;
                }
                rptNum = 1;
                isRpt = 1;
            }
            if(rptNum == RLE_ADV3_MAX_NUM){
                if(j > outSize-1) goto done;
                outBuf[j++] = RLE_ADV3_MAX_NUM | REL_ADV3_MARK;
                rptNum = 0;
            }
            rptNum++;
        }
    }
    if(isRpt){
        if(j > outSize - 2) goto done;
        if(rptNum == RLE_ADV3_MAX_NUM && j > outSize -3) goto done;
        outBuf[j++] = rptNum | REL_ADV3_MARK;
        if(rptNum == RLE_ADV3_MAX_NUM) outBuf[j++] = REL_ADV3_MARK;
        outBuf[j++] = inBuf[i];
    }else {
        if(j > outSize - rptNum - 1) goto done;
        outBuf[j++] = rptNum;
        memcpy(outBuf+j, inBuf+i-rptNum+1, rptNum);
        j += rptNum;
    }
    i++;

done:
    printf("RLE_ADV3_Compress: inSize=%d, inLen=%d, outSize=%d, cmpSize=%d\n",
           inSize, i, outSize, j);

    if(i != inSize)
        return 1;
    else
        return j;
}

/* uncompress data
 * Input:
 *  inSize      compressed data size
 *  inBuf       compressed data buf
 *  outSize     uncompress data buf size
 * Output:
 *  outBuf      uncompress data buf address
 *  inLen       reality use'd compressed data size
 * Return:
 *  <=  0       failure
 *  >   0       success, reality uncompress data size
*/
int RLE_ADV3_UnCompress(int inSize, unsigned char *inBuf, int outSize, unsigned char *outBuf, int *inLen)
{
    int i=0, j=0;
    int len, sum=0;

    if(inSize <= 0 || outSize <= 0) return -1;
    if(!inBuf || !outBuf) return -1;

    *inLen = 0;
    while(i
        
        
         
         = REL_ADV3_MARK){
//            len = inBuf[i] & RLE_ADV3_MAX_NUM;
            len = inBuf[i] & (~REL_ADV3_MARK);
            sum += len;
            if(len == RLE_ADV3_MAX_NUM){
                i++;
                continue;
            }
            if(sum+j > outSize){
                break;
            }
            memset(outBuf+j, inBuf[i+1], sum);
            j += sum;
            i += 2;
            sum = 0;
        }else{
            len = inBuf[i];
            if(i + 1 + len > inSize){
                break;
            }
            memcpy(outBuf+j, inBuf+i+1, len);
            j += len;
            i += (len + 1);
        }
    }

    *inLen = i;

    printf("RLE_ADV3_UnCompress: inSize=%d inLen=%d, outSize=%d unCmpSize=%d\n", inSize, i, outSize, j);
    return j;
}


int RLE_ADV3_test()
{
    int size1, size2;
    unsigned char src[]={'a', 'a', 'a', 'a', 'a', 'a', 'a', 'b', 'b', 'c', 'd',
                         'e', 'e', 'e', 'e', 'e', 'f', 'g', 'h', 0xc0, 0xcf};
//    unsigned char src[] = {'a', 'b', 'c', 'd', 'e', 'f'};
    unsigned char cmpBuf[1024];
    unsigned char uncmpBuf[1024];

    size1 = RLE_ADV3_Compress(sizeof(src), src, 1024, cmpBuf);
    cout << "size1=" << size1 << endl;

    int len;
    size2 = RLE_ADV3_UnCompress(size1, cmpBuf, 1024, uncmpBuf, &len);
    cout << "size2=" << size2 << endl;

    printf("-----------------src--------------------\n");
    for(int i=0; i

行程编码压缩算法
Time is a choice
12-21 2万+
1. 算法说明RLE（Run Length Encoding行程编码）算法是一个简单高效的无损数据压缩算法，其基本思路是把数据看成一个线性序列，而这些数据序列组织方式分成两种情况：一种是连续的重复数据块，另一种是连续的不重复数据块。对于连续的重复数据快采用的压缩策略是用一个字节（我们称之为数据重数属性）表示数据块重复的次数，然后在这个数据重数属性字节后面存储对应的数据字节本身，例如某一个文件中有如下
算法系列之八：RLE行程长度压缩算法
java开发指南博客 【转载】
12-12 2325
RLE（Run Length Encoding）行程长度压缩算法（也称游程长度压缩算法），是最早出现、也是最简单的无损数据压缩算法。RLE算法的基本思路是把数据按照线性序列分成两种情况：一种是连续的重复数据块，另一种是连续的不重复数据块。对于第一种情况，对连续的重复数据块进行压缩，压缩方法就是用一个表示块数的属性加上一个数据块代表原来连续的若干块数据。对于第二种情况，RLE算法有两种处理方法，...
无损压缩算法之行程编码
最新发布
浩瀚之水的专栏
02-12 824
无损压缩算法中的行程编码（Run-Length Encoding，简称RLE）是一种简单且直观的压缩技术。
行程长度压缩算法（Run Length Encoding）
热门推荐
K.Sun
04-11 2万+
行程长度压缩法即根据字符串的连续重复字符进行编码的一种方法，例如："aaaaaaabbccccdefffffffgg"输出结果为："a7b2c4d1e1f7g2"很显然这种方法如果处理连续重复字符串的效果较佳，最差的情况就是没有连续的字符，这样的话除了没有压缩不算，而且还增加了字符串的长度，例如："abcdefgh"压缩结果："a1b1c1d1e1f1g1h1"所以应用次方法要注意场景。该压缩法的代
Run-Length Encoding
Lynx's Blog
11-08 1万+
行程长度压缩算法　　Run-Length Encoding（RLE）行程长度的原理是将一扫描行中的颜色值相同的相邻像素用一个计数值和那些像素的颜色值来代替。例如:aaabccccccddeee，则可用3a1b6c2d3e来代替。对于拥有大面积，相同颜色区域的图像，用RLE压缩方法非常有效。由RLE原理派生出许多具体行程压缩方法： 　　1、PCX行程压缩方法：该算法实际上是位映射格式到压
RLE(run length encoding)行程长度压缩算法
02-26 1010
RLE(run length encoding)行程长度压缩算法 是一种最简单的无损数据压缩算法，其思想是：将数据分为按照字节序列分为两类：（1）连续的数据块，（2）非连续的数据块。对于连续的数据块压缩。       最简单的办法是：用一个字节来表示数据块的特点，字节的最高位（7）标记数据块的连续性，低7位[0-6]标记连续的字节数，例如数据：0x01 0x02 0x22 0x21 0x21，压
图像压缩算法Matlab集合
03-18
在图像处理领域，压缩算法是不可或缺的一部分，它们用于减少图像数据的存储空间需求，同时保持图像的质量可接受。本资源“图像压缩算法Matlab集合”提供了多种经典图像压缩方法的Matlab实现，这对于学习和研究图像...
图像处理之图像压缩算法：Huffman Coding：图像压缩算法概述
kkchenjj的博客
07-27 709
Huffman编码是一种广泛应用于图像压缩的熵编码技术，它基于消息出现的频率来分配编码长度，从而实现数据的高效压缩。高效压缩：Huffman编码能够根据像素值出现的频率分配最短的编码，对于频率高的像素值使用较短的编码，频率低的使用较长的编码，从而在不损失信息的情况下减少存储空间。无损压缩：Huffman编码是一种无损压缩算法，这意味着解压缩后的图像与原始图像完全相同，没有信息丢失。适应性强。
行程编码，JPEG压缩编码基本系统_jpeg压缩编码_Vc_图像压缩_
09-29
JPEG压缩算法主要包括三个主要步骤：离散余弦变换（DCT）、量化和熵编码。首先，图像被分割成8x8的块，然后对每个块进行DCT，将图像从空间域转换到频率域。在这个过程中，高频成分（细节）通常会被压缩得更多，因为...
图像无损压缩算法综述.doc
05-29
行程编码是一种简单的无损压缩算法。该算法的基本思想是将输入数据流中的连续重复的符号用一个符号和其重复次数来代替。例如，输入数据流为 AAAABBBCCC，可以用 A4B3C3 来代替。 5. 费诺-香农编码 费诺-香农编码是...
JPEG图像压缩算法
05-24
### JPEG图像压缩算法知识点 #### 一、JPEG压缩原理 JPEG（Joint Photographic Experts Group）是一种广泛应用于存储和传输照片的图像压缩标准和技术。它的主要目的是通过去除人眼不敏感的信息来减少图像文件的...
行程编码（压缩技术）
02-26
实现对字符串的压缩，就是多媒体技术课程中的行程编码的代码
行程编码，JPEG压缩编码（基本系统）
02-25
行程编码，JPEG压缩编码（基本系统）算法.
游程编码实现数据压缩
06-06
游程编码又称“运行长度编码”或“行程编码”，是一种统计编码，该编码属于无损压缩编码。在图像处理领域，对于仅包括很少几个灰度级的图像（特别是二值图）非常有效。该编码方法对单一背景颜色下的物体图像，具有很高的压缩比 ，但是对于其他图像的压缩，其压缩效果不是很明显。甚至最坏情况下会增大图像数据的大小，达不到压缩的目的；
西工大noj行程编码压缩算法
01-05
c语言
【图像压缩】基于行程编码实现图像压缩附matlab代码
matlab_dingdang的博客
03-30 1167
1 简介 编码是方法建立在图像统计特性的基础上的。例如，在传真通信中的文件大多是二值图像，即每个像素的灰度值只有0和1两种取值。将一行中颜色值相同的相邻象素用一个计数值和该颜色值来代替。例如aaabccccccddeee可以表示为3a1b6c2d3e，，即有3个a，1个b，6个c，2个d，3个e。如果一幅图象是由很多块颜色相同的大面积区域组成，那么采用行程编码的压缩效率是惊人的。然而，该算法也导致了一个致命弱点，如果图象中每两个相邻点的颜色都不同，用这种算法不但不能压缩，反而数据量增加一倍。因此对有大面.
游程长度编码压缩比是什么_JPEG 编码过程—为 GPU 处理开路
weixin_39606048的博客
01-12 1609
图片平台上承接了巨量的图片每天需要针对几十亿的图像进行处理，由于JPEG格式是存储系统中存储最多图像格式，而JPEG格式编解码以及处理中都是大量的数据计算，GPU较于CPU具有更强大的数据并行计算的能力。于是研究利用GPU来加速处理图像编解码以及图像处理, 为此很有必要先了解JPEG的的编解码过程。文章参考了大量外部资料，引用了相关的图片以及数据，所涉及到的内容或者原理都有相应的链接跳转以供查询。...
关于位图行程编码格式压缩 &行程长度压缩算法
01-04 801
关于位图行程编码格式压缩---Window中的位图支持行程编码压缩方式，通常位图的象素使用4比特或者8比特来表示，即BITMAPINFOHEADER结构中的biCompression的BI_RLE8和BI_RLE41．8位位图的压缩---在这种情况下BITMAPINFOHEADER结构中的biCompression设置为BI_RLE8,.使用256色位图行程编码格式将位图进行压缩。这种压缩方式包括
基于行程编码的图像压缩算法
m0_61613016的博客
12-24 1801
行程编码图像压缩
探索基本压缩算法函数库及其应用
在深入探讨“基本压缩算法函数库1.2”相关知识点之前，我们需要了解什么是数据压缩，以及为何需要不同的压缩算法。数据压缩是指在保持原始数据的完整性、内容和结构的情况下，通过某种方式减少数据的大小，以便于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值