矢量的码下格式有哪些

       矢量图，也称为面向对象的码下图像或绘图图像，在数学上定义为一系列由点连接的码下网页源码如何获得线。矢量文件中的码下图形元素称为对象。每个对象都是码下一个自成一体的实体，它具有颜色、码下形状、码下轮廓、码下大小和屏幕位置等属性。码下

       矢量图是码下根据几何特性来绘制图形，矢量可以是码下一个点或一条线，矢量图只能靠软件生成，码下文件占用内在空间较小，因为这种类型的图像文件包含独立的分离图像，可以自由无限制的重新组合。它的特点是放大后图像不会失真，和分辨率无关，适用于图形设计、文字设计和一些标志设计、android应用源码版式设计等。

       优点

       文件小，图像中保存的是线条和图块的信息，所以矢量图形文件与分辨率和图像大小无关，只与图像的复杂程度有关，图像文件所占的存储空间较小。

       图像可以无限级缩放，对图形进行缩放，旋转或变形操作时，图形不会产生锯齿效果。

       可采取高分辨率印刷，矢量图形文件可以在任何输出设备打印机上以打印或印刷的最高分辨率进行打印输出。

       最大的缺点是难以表现色彩层次丰富的逼真图像效果。

       矢量图与位图的效果是天壤之别，矢量图无限放大不模糊，大部分位图都是由矢量导出来的，也可以说矢量图就是位图的源码，源码是可以编辑的。

       矢量的常用格式

       .bw

       它是包含各种像素信息的一种黑白图形文件格式。

       .ai(Illustrator)

       它是Illustrator中的一种图形文件格式，也即Illustrator软件生成的大型的源码矢量文件格式，用Illustrator、CorelDraw、Photoshop均能打开、编辑、修改等等。

       .cdr(CorelDraw)

       它是CorelDraw中的一种图形文件格式，是所有CorelDraw应用程序中均能够使用的一种图形图像文件格式。

       .col(Color Map File)

       它是由Autodesk Animator、Autodesk Animator Pro等程序创建的一种调色板文件格式，其中存储的是调色板中各种项目的RGB值。

       .cgm(Computer Graphics Metafile)是电脑影像文件的英文缩写。CGM是ISO委员会定义的一种图形格式（International standard ISO/IEC :）， 用来描述、存储和传输与设备无关的矢量(向量)、标量以及两者混合的影像。

       .dwg，它是AutoCAD中使用的一种图形文件格式。

       .dxb(drawing interchange binary)，它是AutoCAD创建的一种图形文件格式。

       .dxf(Autodesk Drawing Exchange Format)，它是试玩平台源码AutoCAD中的图形文件格式，以ASCII方式储存图形，在表现图形的大小方面十分精确，可被CorelDraw、3DS等大型软件调用编辑。

       .wmf(Windows Metafile Format)

       .wmf是Microsoft Windows中常见的一种图元文件格式，它具有文件短小、图案造型化的特点，整个图形常由各个独立的组成部分拼接而成，但其图形往往较粗糙，并且只能在Microsoft Office中调用编辑。

       .emf(Enhanced MetaFile)

       .emf是由Microsoft公司开发的Windows 位扩展图元文件格式。其总体设计目标是要弥补在Microsoft Windows 3.1(Win)中使用的*.wmf文件格式的不足，使得图元文件更加易于使用。

       .eps(Encapsulated PostScript)

       .eps是用PostScript 语言描述的一种ASCII图形文件格式，在PostScript图形打印机上能打印出高品质的图形图像，最高能表示位图形图像。该格式分为PhotoShop EPS格式（Adobe Illustrator Eps）和标准EPS格式，其中标准EPS格式又可分为图形格式和图像格式。值得注意的是，在PhotoShop中只能打开图像格式的EPS文件。

       .eps格式包含两个部分：第一部分是药店源码屏幕显示的低解析度影像，方便影像处理时的预览和定位；第二部分包含各个分色的单独资料。.eps文件以D CS/CMYK形式存储，文件中包含CMYK四种颜色的单独资料，可以直接输出四色网片。但是，除了在PostScript打印机上比较可靠之外，

       .eps格式还有许多缺陷：首先，*.eps格式存储图像效率特别低；其次，*.eps格式的压缩方案也较差，一般同样的图像经*.tiff的LZW压缩后，要比* .eps的图像小3到4倍。

       .ico(Icon file)，它是Windows的图标文件格式。

       .iff(Image File Format)，是Amiga等超级图形处理平台上使用的一种图形文件格式，好莱坞的特技大片多采用该格式进行处理，可逼真再现原景。当然，该格式耗用的内存、外存等计算机资源也十分巨大。

       .lbm，是Deluxe Paint中使用的一种图形文件格式，其编码方式类似于*.iff。

       .mag，是日本人常用的一种图形文件格式。

       .mac(Macintosh)，是Macintosh中使用的一种灰度图形文件格式，在Macintosh paintbrush中使用，其分辨率只能是×。

       .mpt(Macintosh Paintbrush)，是Macintosh中使用的一种图形文件格式。

       .msk(Mask Data File)，是Animator Pro中的一种图形文件格式，其中包含一个位图图形。

       .opt/*.twe

       .opt(Optics Menu Settings File)*.twe(Tween Data File) 是Animator Pro创建的图形文件格式。

       .ply(Polygon File)，是Animator Pro创建的一种图形文件格式，其中包含用来描述多边形的一系列点的信息。

       .pbm/*.pgm/*.ppm，(Portable Pixmap) 图形文件格式。

       .pcd(Kodak PhotoCD)，是一种Photo CD文件格式，由Kodak公司开发，其他软件系统只能对其进行读取。该格式主要用于存储CD-ROM上的彩色扫描图像，它使用YCC色彩模式定义图像中的色彩。

       .pcx(PC Paintbrush)/*.pcc，最早是由Zsoft公司的PC Paintbrush图形软件所支持的一种经过压缩的PC位图文件格式。后来，Microsoft将PC Paintbrush移植到Windows环境中，*.pcx图像格式也就得到了更多的图形图像处理软件的支持。该格式支持的颜色数从最早的色发展到万色。它采用行程编码方案进行压缩，带有一个字节的文件头。

       .pic，是一种图形文件格式，其中包含了未经压缩的图像信息。

       .pict/.pict2/.pnt

       .pict文件格式主要应用于Mac机上，也可在安装了Quick Time的PC机上使用。该格式的文件不适用于打印（若在PostScript打印机上打印*.pict格式的文件，则会造成PostSlipt错误），而经常用于多媒体项目。* .pict也是Mac应用软件用于图像显示的格式之一。

       .pdd，和.psd一样，都是PhotoShop软件中专用的一种图形文件格式，能够保存图像数据的每一个细小部分，包括层、附加的蒙版通道以及其他内容，而这些内容在转存成其他格式时将会丢失。另外，因为这两种格式是PhotoShop支持的自身格式文件，所以PhotoShop能以比其他格式更快的速度打开和存储它们。遗憾是，尽管PhotoShop在计算过程中应用了压缩技术，但用这两种格式存储的图像文件仍然特别大。不过，用这两种格式存储图像不会造成任何的数据流失，所以当你在编辑过程中时，最好还是选择这两种格式存盘，以后再转换成占用磁盘空间较小、存储质量较好的其他文件格式。

       .pxr(PiXaR)，也许只有PIXAR工作站用户才比较了解*.pxr这种文件格式，该格式支持灰度图像和RGB彩色图像。可在PhotoShop中打开一幅由PIXAR工作站创建的*.pxr图像，也可以用*.pxr格式来存储图像文件，以便输送到工作站上。

       .ras/ .raw

       .ras (Sun Raster files)/ .raw(Raw GrayScale)图形文件格式。

       Scitex CT

       Scitex CT是在Scitex高档印前工作站上创建的一种图像文件格式，该工作站主要用于图像的编辑和分色。Scitex CT图像总是以CMYK模式打开，如果它们最终还要返回到Scitex系统，则请保持其CMYK模式。可利用PhotoShop来打开并编辑Scitex CT图像。

       .svg 可缩放矢量图形(Scalable Vector Graphics)

       .tga(Tagged Graphic)

       .tga是True Vision公司为其显示卡开发的一种图像文件格式，创建时间较早，最高色彩数可达位，其中包括8位Alpha通道用于显示实况电视。该格式已经被广泛应用于PC机的各个领域，而且该格式文件使得Windows与3DS相互交换图像文件成为可能。你可以先在3DS中生成色彩丰富的*.tga文件，然后在Win dows中利用Photoshop、Freeherd、Painter等应用软件来进行修改和渲染。

       .win，是类似于*.tga的一种图形文件格式。

       .xbm (X BitMap)，是一种图形文件格式。

        矢量的格式有哪些的下载地址： 本地下载

请问有没有LZW压缩算法的源代码？

       #include<stdio.h>

       #include<string.h>

       #include<stdlib.h>

       #define PATHSIZE

       #define BITS

       #define HashShift BITS-8

       #define MAX_VALUE ((1<<BITS)-1)

       #define MAX_CODE (MAX_VALUE-1)

       #define HashTableLen

       #define process

       /*压缩结构*/

       typedef struct

       {

        int *code;

        unsigned int *prenum;

        unsigned char *baknum;

       }LZW_DATA;

       unsigned char decode_stack[HashTableLen];

       LZW_DATA lzwt,*lzw;

       void dataout(FILE *output,unsigned int code);/*输出压缩后的流*/

       unsigned int hashfind(unsigned int hash_prenum,unsigned int hash_character);/*压缩算法*/

       char *decode(unsigned char *buffer,unsigned int code);

       unsigned int incode(FILE *input);

       void compress(FILE *input,FILE *output);

       void decompress(FILE *input,FILE *output);

       int main()

       {

        FILE *fp1,*fp2;

        char path[PATHSIZE];

        S1:puts("Input function.(h:hoop,u:uncompress)...");

        fflush(stdin);

        gets(path);

        if(!strcmp(path,"h")||!strcmp(path,"hoop"))

        {

        printf("Input source file path:");

        fflush(stdin);

        gets(path);

        if((fp1=fopen(path,"rb"))==NULL)

        {

        puts("Can not open source file!");

        return 1;

        }

        printf("Input objective file path:");

        fflush(stdin);

        gets(path);

        if((fp2=fopen(path,"wb"))==NULL)

        {

        puts("Can not open objective file!");

        return 1;

        }

        compress(fp1,fp2);

        }

        else if(!strcmp(path,"u")||!strcmp(path,"uncompress"))

        {

        printf("Input source file path:");

        fflush(stdin);

        gets(path);

        if((fp1=fopen(path,"rb"))==NULL)

        {

        puts("Can not open source file!");

        return 1;

        }

        printf("Input objective file path:");

        fflush(stdin);

        gets(path);

        if((fp2=fopen(path,"wb"))==NULL)

        {

        puts("Can not open objective file!");

        return 1;

        }

        decompress(fp1,fp2);

        }

        else

        {

        puts("Input error,please input again!");

        goto S1;

        }

        fclose(fp1);

        fclose(fp2);

        S2:puts("If continue or not(y:yes/n:no)?");

        fflush(stdin);

        gets(path);

        if(!strcmp(path,"y")||!strcmp(path,"yes"))

        {

        goto S1;

        }

        else if(!strcmp(path,"n")||!strcmp(path,"no"))

        {

        goto S3;

        }

        else

        {

        puts("Input error,please input again!");

        goto S2;

        }

        S3:return 0;

       }

       void compress(FILE *input,FILE *output)

       {

        int i,index,len1,len2;

        int curr_code;

        int baknum;

        int prenum;

        len1=HashTableLen*sizeof(unsigned int);

        len2=HashTableLen*sizeof(unsigned char);

        if(!(lzwt.code=(int*)malloc(len1)))

        {

        puts("Internal memory distribution error!");

        exit(0);

        }

        if(!(lzwt.prenum=(unsigned int*)malloc(len1)))

        {

        puts("Internal memory distribution error!");

        exit(0);

        }

        if(!(lzwt.baknum=(unsigned char*)malloc(len2)))

        {

        puts("Internal memory distribution error!");

        exit(0);

        }

        lzw=&lzwt;

        curr_code=;

        for(i=0;i<HashTableLen;i++)

        {

        lzw->code[i]=-1;

        }

        i=0;

        puts("Hoop begin.");

        prenum=getc(input);

        while((baknum=getc(input))!=EOF)

        {

        index=hashfind(prenum,baknum);

        if(lzw->code[index]!=-1)

        {

        prenum=lzw->code[index];

        }

        else

        {

        if(curr_code<=(MAX_CODE))

        {

        lzw->code[index]=curr_code++;

        lzw->prenum[index]=prenum;

        lzw->baknum[index]=baknum;

        }

        dataout(output,prenum);

        prenum=baknum;

        }

        if(i==prenum)

        {

        i=0;

        putchar('.');

        }

        else

        {

        i++;

        }

        }

        dataout(output,prenum);

        dataout(output,MAX_VALUE);

        dataout(output,0);

        free(lzw->code);

        free(lzw->prenum);

        free(lzw->baknum);

       }

       unsigned int hashfind(unsigned int prenum,unsigned int baknum)

       {

        int index;

        int offset;

        index=(baknum<<HashShift)^prenum;

        if(index==0)

        {

        offset=1;

        }

        else

        {

        offset=HashTableLen-index;

        }

        while(1)

        {

        if(lzw->code[index]==-1)

        {

        return index;

        }

        if(lzw->prenum[index]==prenum&&lzw->baknum[index]==baknum)

        {

        return index;

        }

        index-=offset;

        if(index<0)

        {

        index+=HashTableLen;

        }

        }

       }

       void dataout(FILE *output,unsigned int code)

       {

        static int outbinary=0;

        static unsigned long nob=0L;

        nob|=(unsigned long)code<<(-BITS-outbinary);

        outbinary+=BITS;

        while(outbinary>=8)

        {

        putc(nob>>,output);

        nob<<=8;

        outbinary=outbinary-8;

        }

       }

       void decompress(FILE *input,FILE *output)

       {

        unsigned int curr_code;

        unsigned int baknum;

        unsigned int prenum;

        int i,ch,len1,len2;

        char *ps;

        len1=HashTableLen*sizeof(unsigned int);

        len2=HashTableLen*sizeof(unsigned char);

        if(!(lzwt.code=(int*)malloc(len1)))

        {

        puts("Internal memory distribution error!");

        exit(0);

        }

        if(!(lzwt.prenum=(unsigned int*)malloc(len1)))

        {

        puts("Internal memory distribution error!");

        exit(0);

        }

        if(!(lzwt.baknum=(unsigned char*)malloc(len2)))

        {

        puts("Internal memory distribution error!");

        exit(0);

        }

        lzw=&lzwt;

        curr_code=;

        i=0;

        puts("Uncompress begin.");

        ch=prenum=incode(input);

        putc(prenum,output);

        while((baknum=incode(input))!=MAX_VALUE)

        {

        if(baknum>=curr_code)

        {

        *decode_stack=ch;

        ps=decode(decode_stack+1,prenum);

        }

        else

        {

        ps=decode(decode_stack,prenum);

        }

        ch=*ps;

        while(ps>=decode_stack)

        {

        putc(*(ps--),output);

        }

        if(curr_code<=MAX_CODE)

        {

        lzw->prenum[curr_code]=prenum;

        lzw->baknum[curr_code]=ch;

        curr_code++;

        }

        prenum=baknum;

        if(i==process)

        {

        i=0;

        putchar('.');

        }

        else

        {

        i++;

        }

        }

        free(lzw->code);

        free(lzw->prenum);

        free(lzw->baknum);

       }

       char *decode(unsigned char *buffer,unsigned int code)

       {

        int len=0;

        while(code>)

        {

        *buffer++=lzw->baknum[code];

        code=lzw->prenum[code];

        len++;

        if(len>=HashTableLen)

        {

        puts("Internal memory run over!");

        exit(1);

        }

        }

        *buffer=code;

        return buffer;

       }

       unsigned int incode(FILE *input)

       {

        unsigned int ret;

        static int inputbinary=0;

        static unsigned long nib=0L;

        while(inputbinary<=)

        {

        nib|=(unsigned long)getc(input)<<(-inputbinary);

        inputbinary=inputbinary+8;

        }

        ret=nib>>(-BITS);

        nib<<=BITS;

        inputbinary=inputbinary-BITS;

        return ret;

       }

       这是我以前写的LZW算法，压缩和解压缩文本文件都没问题，就是解压后可能字符的顺序有点问题，呵呵用作学习的

       我在这个地址回答过了，这样的复杂算法一般不会有个人去写的，我写了就觉得晕，如果提问的是同一个人，加我QQ我抽空教你原理。

       /question/.html?fr=im

急求LZW算法源代码!!!

       #include<iostream>

       #include<cstdio>

       #include<cstring>

       #include<ctime>//用来计算压缩的时间

       using namespace std;

       //定义常数

       const int MAX = ;//最大code数，是一个素数，求模是速度比较快

       const int ascii = ; //ascii代码的数量

       const int ByteSize = 8; //8个字节

       struct Element//hash表中的元素

       {

        int key;

        int code;

        Element *next;

       }*table[MAX];//hash表

       int hashfunction(int key)//hash函数

       {

        return key%MAX;

       }

       void hashinit(void)//hash表初始化

       {

        memset(table,0,sizeof(table));

       }

       void hashinsert(Element element)//hash表的插入

       {

        int k = hashfunction(element.key);

        if(table[k]!=NULL)

        {

        Element *e=table[k];

        while(e->next!=NULL)

        {

        e=e->next;

        }

        e->next=new Element;

        e=e->next;

        e->key = element.key;

        e->code = element.code;

        e->next = NULL;

        }

        else

        {

        table[k]=new Element;

        table[k]->key = element.key;

        table[k]->code = element.code;

        table[k]->next = NULL;

        }

       }

       bool hashfind(int key,Element &element)//hash表的查找

       {

        int k = hashfunction(key);

        if(table[k]!=NULL)

        {

        Element *e=table[k];

        while(e!=NULL)

        {

        if(e->key == key)

        {

        element.key = e->key;

        element.code = e->code;

        return true;

        }

        e=e->next;

        }

        return false;

        }

        else

        {

        return false;

        }

       }

       void compress(void)//压缩程序

       {

        //打开一个流供写入

        FILE *fp;

        fp = fopen("result.dat", "wb");

        Element element;

        int used;

        char c;

        int pcode, k;

        for(int i=0;i<ascii;i++)

        {

        element.key = i;

        element.code = i;

        hashinsert(element);

        }

        used = ascii;

        c = getchar();

        pcode = c;

        while((c = getchar()) != EOF)

        {

        k = (pcode << ByteSize) + c;

        if(hashfind(k, element))

        pcode = element.code;

        else

        {

        //cout<<pcode<<' ';

        fwrite(&pcode, sizeof(pcode), 1, fp);

        element.code = used++;

        element.key = (pcode << ByteSize) | c;

        hashinsert(element);

        pcode = c;

        }

        }

        //cout<<pcode<<endl;

        fwrite(&pcode, sizeof(pcode), 1, fp);

       }

       int main(void)

       {

        int t1,t2;

        //欲压缩的文本文件

        //freopen("input.txt","r",stdin);

        freopen("book5.txt","r",stdin);

        t1=time(NULL);

        hashinit();

        compress();

        t2=time(NULL);

        cout<<"Compress complete! See result.dat."<<endl;

        cout<<endl<<"Total use "<<t2-t1<<" seconds."<<endl;

       }

跪求C语言进行哈夫曼编码、算术编码和LZW编码，要求源程序要有注释。

       以下是哈夫曼编码

       #include<iostream>

       #include<math.h>

       #include<string>

       #include<iomanip>

       using namespace std;

       int n;

       int isin(string str,char a)

       {

        int temp=0;

        for(int i=0;i<str.length();i++)

        {

        if(str[i]==a) temp=1;

        }

        return temp;

       }

       void bubble(double p[],string sign[])//排序

       {

        for(int i=0;i<n-1;i++)

        {

        for(int j=i+1;j<n;j++)

        {

        if(p[i]<p[j])

        {

        double temp=p[i];

        p[i]=p[j];

        p[j]=temp;

        string m=sign[i];

        sign[i]=sign[j];

        sign[j]=m;

        }

        }

        }

       }

       void huff(double tempp[],string tempstr[])

       {

        double p[][];

        string sign[][];

        sign[0][i]=tempstr[i]; //符号放在sign数组中

        for(int i=0;i<n;i++)

        {

        p[0][i]=tempp[i]; //p数组放对应的概率(第1列中)

        }

        for(i=0;i<n-1;i++)

        {

        bubble(p[i],sign[i]); //第一次排序

        for(int j=0;j<n-2-i;j++)

        {

        p[i+1][j]=p[i][j]; //前n-2-i个概率重新放在p数组中(是数组的第2列中)

        sign[i+1][j]=sign[i][j];

        }

        p[i+1][j]=p[i][j]+p[i][j+1];//第一次两个最小概率求和

        sign[i+1][j]=sign[i][j]+sign[i][j+1];//符号跟随

        for(j=n-1-i;j<n;j++)

        {

        p[i+1][j]=0;

        }

        }

        string final[];

        for(i=n-2;i>=0;i--)

        {

        for(int k=0;k<n;k++)

        {

        if(isin(sign[i][n-2-i],sign[0][k][0])) final[k]+="0";

        if(isin(sign[i][n-1-i],sign[0][k][0])) final[k]+="1";

        }

        }

        cout<<setw(9)<<"哈弗曼编码如下:"<<endl;

        for(i=0;i<n;i++)

        {

        cout<<setw(7)<<sign[0][i]<<setw(7)<<p[0][i]<<setw()<<final[i]<<

        setw(7)<<final[i].length()<<endl;

        }

       }

       void main()

       {

        char a[];

        cout<<"该字符串符号为:";

        cin>>a;

        string s=a;

        n=s.length();

        char b[][2];

        for(int i=0;i<n;i++)

        {

        b[i][0]=a[i];

        b[i][1]='\0';

        }

        string str[];

        for(i=0;i<n;i++)

        {

        str[i]=b[i];

        }

        double tempp[];

        cout<<"字符概率依次为：";

        for(i=0;i<n;i++)

        {

        cin>>tempp[i];

        }

        huff(tempp,str);

       }