精华内容
下载资源
问答
  • 1.打开图片,可以按Ctrl或者Shift来进行多张图片选择或者用鼠标框选。... PSB大型文件格式支持PSD所有功能,并且支持高或宽达到300000像素超大文件。PSB文件属于新格式,只有CS或更高版本打开。  JP...

    1.打开图片,可以按Ctrl或者Shift来进行多张图片的选择或者用鼠标框选。

    2.勾选图像序列,可以选择命名上有次序的多个图像。

    3.  PSD是ps里面的标准保存格式,包含颜色、图层、通道、路径、动画等信息是我们创作图像作品的原始文件。

       PSB大型文件格式支持PSD的所有功能,并且支持高或宽达到300000像素的超大文件。PSB文件属于新格式,只有CS或更高版本打开。

       JPG是最流行的图片格式,体积小巧,可变压缩比、支持交错广泛用于互联网传输,是我们最常见的图片格式。

       GIF图片支持透明色,支持动画,我们在网页上看的的动态图,聊天表情大都是GIF图片。PS也可以制作出漂亮的GIF动画图片。

    4.隐藏图层之后会使文件变小,方便网络传输。

     

    转载于:https://www.cnblogs.com/yuxingyoucan/p/5277328.html

    展开全文
  • WEB 的动画实现多种多样,...GIF(Graphics Interchange Format)原义是“图像互换格式”,GIF文件的数据,是一种基于LZW算法连续色调无损压缩格式。其压缩率一般在50%左右,它不属于任何应用程序。GIF格式可以...

    WEB 的动画实现多种多样,随着H5 的发展,实现动画的方式越来越多了。初步统计实现动画的方式有以下一些方式实现

    一、GIF动画

    通常咱们社交聊天的一些动态表情,大多都是gif动画。
    GIF(Graphics Interchange Format)的原义是“图像互换格式”,GIF文件的数据,是一种基于LZW算法的连续色调的无损压缩格式。其压缩率一般在50%左右,它不属于任何应用程序。GIF格式可以存多幅彩色图像,如果把存于一个文件中的多幅图像数据逐幅读出并显示到屏幕上,就可构成一种最简单的动画。

    GIF 分为静态GIF和动画GIF两种,扩展名为.gif,是一种压缩位图格式,支持透明背景图像,适用于多种操作系统,“体型”很小,网上很多小动画都是GIF格式,其实GIF是将多幅图像保存为一个图像文件,从而形成动画,最常见的就是通过一帧帧的动画串联起来的搞笑gif图,所以归根到底GIF仍然是图片文件格式。

    GIF制作方式可以通过PS制作,或者通过图片、视频、FLASH转换

    缺点:高清的gif体积较大。压缩后的体检较小的会失帧。交互差,实质上他就是一个会动的图片

    二、FLASH动画 / SilverLight

    FLASH
    Flash非常强大,它们包含丰富的视频、声音、图形和动画。利用Flash可以制作各种各样非常华丽的动画,和视频,但是由于各种原因,2012年8月15日,Flash退出Android平台,正式告别移动端。2015年12月1日,Adobe将动画制作软件Flash professional CC2015升级并改名为Animate CC 2015.5,从此与Flash技术划清界限。

    很早之前在各种企业门户的首页大图轮播基本都是使用flash,早几年12306的购票网站首页的顶部的大图也是用的flash,如今都换成了静态的图片。这种技术逐渐淡出了视野,只有在线视频直播如 优酷,爱奇艺等视频网站。

    缺点:基于flash播放器来播放,flash播放器非常耗性能,经常报各种漏洞

    SilverLight
    Microsoft Silverlight是一个跨浏览器的、跨平台的插件,是一种新的Web呈现技术,能在各种平台上运行。借助该技术,您将拥有内容丰富、视觉效果绚丽的交互式体验,而且,无论是在浏览器内、还是在桌面操作系统(如Windows和Apple Macintosh)中,您都可以获得这种一致的体验。

    缺点:以浏览器插件的形式来支持动画,开发起来不那么容易。了解下有这个东东就够了哈

    三、Javascript + HTML

    原理: 其主要思想是通过setInterval或setTimeout方法的回调函数来持续调用改变某个元素的CSS样式以达到元素样式变化的效果。

    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <style type="text/css">
            #animate {
                width: 200px;
                height: 200px;
                background: #ccc;
            }
        </style>
    </head>
    <body>
        <div id="animate"></div>
        <script>
            let elem = document.getElementById('animate');
            let left = 0;
            let timer = setInterval(function(){
                if(left<window.innerWidth-200){
                    elem.style.marginLeft = left+'px';
                    left ++;
                }else {
                    clearInterval(timer);
                }
            },16); //这里的16毫秒
        </script>
    </body>
    </html>

    Jquery的animate()方法就是这种方式实现的。

    缺点:javascript 实现动画通常会导致页面频繁性重排重绘,消耗性能,一般应该在桌面端浏览器。在移动端上使用会有明显的卡顿

    16ms的问题:一般认为人眼能辨识的流畅动画为每秒60帧,这里16ms比(1000ms/60)帧略小一些,但是一般可仍为该动画是流畅的。
    在很多移动端动画性能优化时,一般使用16ms来进行节流处理连续触发的浏览器事件。例如对touchmove、scroll事件进行节流等。通过这种方式减少持续事件的触发频率,可以大大提升动画的流畅性

    四、SMIL

    SMIL特性:
    程序以开始,以结束,整个程序由body和head两个部分组成,SMIL要求其标记和标记的属性必须小写!有些标记必须有一斜杠作为结束标记,属性值必须用双引号括起来,SMIL文件的拓展名为.smil或者.smi。

    <smil>
    <head></head>
     
    <body>
    <seq>
    <!-- 演示开始进行2秒后开始显示,持续播放5秒 -->
    <img src="1.jpg" dur="5s" begin="2"/> 
    <!-- 演示开始进行3秒后开始显示,持续播放10秒 -->
    <img src="2.jpg" dur="10s" bengin="3"/> 
     <!-- 演示开始进行5秒后开始显示,在整个演示播放40秒以后,就结束播放 -->
    <video src="test.rm" begin="5s" end="40s"/>
    <!-- 只播放视频文件的第5秒到第10秒,重复播放2次 -->
    <video src="test.rm" clip-begin="5s" clip-end="10s" repeat="2"/>
    </seq>
    </body>
    </smil>

    嵌入html
    向 标签添加命名空间定义,添加一个 <?import> 元素,以导入 "time" 命名空间,添加一个定义 "time" 类的 <style> 元素

    <html xmlns:time="urn:schemas-microsoft-com:time">
    <head>
      <?import namespace="time" implementation="#default#time2">
      <style>.time {behavior: url(#default#time2)}</style>
    </head>
    
    <body>
        <!-- repeatCount循环次数 -->
      <time:seq repeatCount="indefinite">
        <img class="time" src="image1.jpg" dur="3s" />
        <img class="time" src="image2.jpg" dur="3s" />
      </time:seq>
    </body>
    </html>

    缺点:一看就知道只支持IE。没啥好说的

    五、APNG

    APNG, 全称是“Animated Portable Network Graphics”, 是PNG的位图动画扩展,他和gif的区别在于:图片质量, gif最多支持256种颜色,不支持Alpha透明通道。可以称之为色彩丰富支持Alpha透明通道体积大小和gif甚至更小的gif。
    2007年4月20日,PNG组织投票以10:8否决APNG进入官方标准。也就是PNG不认可他。

    缺点:Chrome 59之后,只有IE不支持

    APNG的制作:http://littlesvr.ca/apng/

    六、Javascript + SVG

    SVG的动画元素是和SMIL开发组合作开发的。SMIL开发组和SVG开发组合作开发了SMIL动画规范,在规范中制定了一个基本的XML动画特征集合。SVG吸收了SMIL动画规范当中的动画优点,并提供了一些SVG继承实现。

    特性
    SVG 指可伸缩矢量图形 (Scalable Vector Graphics)
    SVG 用来定义用于网络的基于矢量的图形
    SVG 使用 XML 格式定义图形
    SVG 图像在放大或改变尺寸的情况下其图形质量不会有所损失
    SVG 是万维网联盟的标准
    SVG 与诸如 DOM和 XSL 之类的W3C标准是一个整体

    SVG animation最强大的地方在于:™只要在页面放几个animate元素,没有任何CSS, 没有任何JS,页面上的元素就像是没吃草的马儿一样,愉快地跑起来了。你会发现,我勒个去,原来要实现个动画效果这么简单。什么CSS3动画,哪边凉快哪边呆着吧!

    <svg width="320" height="320" xmlns="http://www.w3.org/2000/svg">
      <g> 
        <text font-family="microsoft yahei" font-size="120" y="160" x="160">哈哈</text>
        <animateTransform attributeName="transform" begin="0s" dur="10s" type="rotate" from="0 160 160" to="360 160 160" repeatCount="indefinite"/>
      </g>
    </svg>

    元素
    <set>
    此元素没有动画效果,可以在特定时间之后修改某个属性值(也可以是CSS属性值)

    <svg width="320" height="320" xmlns="http://www.w3.org/2000/svg">
      <g> 
        <text font-family="microsoft yahei" font-size="120" y="160" x="160">
            测试
        <!-- 3秒后把x值改为60 -->
        <set attributeName="x" attributeType="XML" to="60" begin="3s" />
        </text>
      </g>
    </svg>

    <animate>
    基础动画元素。实现单属性的动画过渡效果

    <svg width="320" height="320" xmlns="http://www.w3.org/2000/svg">
      <g> 
        <text font-family="microsoft yahei" font-size="120" y="160" x="160">
        测试
        <!-- 从0秒开始,总时长3秒,x值从160到60,(repeatCount)不间断循环 -->
        <animate attributeName="x" from="160" to="60" begin="0s" dur="3s" repeatCount="indefinite" />
        </text>
      </g>
    </svg>

    <animateColor>
    颜色动画,因为animate能实现其功能,所以被废弃了。逝者已矣...

    <animateTransform>
    实现transform变换动画效果的,与CSS3的transform变换是一个套路

    <svg width="320" height="320" xmlns="http://www.w3.org/2000/svg">
      <g> 
        <text font-family="microsoft yahei" font-size="80" y="100" x="100">测试</text>
        <!-- 从0秒开始,总时长3秒,变换类型为scale(缩放),值从1到1.5,repeatCount)不间断循环  -->
        <animateTransform attributeName="transform" begin="0s" dur="3s"  type="scale" from="1" to="1.5" repeatCount="indefinite"/>
      </g>
    </svg>

    <animateMotion>
    animateMotion元素可以让SVG各种图形沿着特定的path路径运动~

    <svg width="320" height="320" xmlns="http://www.w3.org/2000/svg">
      <text font-family="microsoft yahei" font-size="30" x="0" y="0" fill="green">动
       <!-- 从0秒开始,总时长3秒,不间断循环,沿着路径path运动 -->
        <animateMotion path="m124.067754,67.21128c39.580339,-101.001223 194.657404,0 0,129.858716c-194.657404,-129.858716 -39.580339,-230.859939 0,-129.858716z" begin="0s" dur="5s"   rotate="auto" repeatCount="indefinite"/>
      </text>
        <path d="m124.067754,67.21128c39.580339,-101.001223 194.657404,0 0,129.858716c-194.657404,-129.858716 -39.580339,-230.859939 0,-129.858716z" stroke-width="1.5" stroke="#cd0000" fill="none"/>
    </svg>

    展示的时候是这个样子的。
    svg动画

    暂停和播放

    // svg指当前svg DOM元素
    // 暂停
    svg.pauseAnimations();
    
    // 重启动
    svg.unpauseAnimations()

    关于svg的之后再写文章详细介绍吧

    七、Video

    <Video>是 HTML 5 的新标签。

    <video src="movie.ogg" controls="controls">
    您的浏览器不支持 video 标签。
    </video>

    相关属性
    属性 | 值 | 描述
    ------- | ------- | -------
    autoplay | autoplay | 如果出现该属性,则视频在就绪后马上播放。
    controls | controls | 如果出现该属性,则向用户显示控件,比如播放按钮。
    height | pixels | 设置视频播放器的高度。
    loop | loop | 如果出现该属性,则当媒介文件完成播放后再次开始播放。
    preload | preload | 如果出现该属性,则视频在页面加载时进行加载,并预备播放。如果使用 "autoplay",则忽略该属性。
    src | url | 要播放的视频的 URL。
    width | pixels | 设置视频播放器的宽度。

    八、Javascript + Canvas

    canvas作为H5新增元素,是借助Web API来实现动画的。
    结合setInterval 或者requestAnimationFrame可以实现各种样的动画,下面的例子展示了一个7色圆的颜色过度

    <!DOCTYPE html>
    <html>
    <head>
      <meta charset="utf-8">
      <meta name="viewport" content="width=device-width">
      <title>JS Bin</title>
    </head>
    <body>
      <canvas id="canvas"></canvas>
      <script>
        function colorPalette(gradient) {
        var canvas = document.createElement("canvas");
        canvas.width = "1";
        canvas.height = "256";
        // document.body.appendChild(canvas); // debug
        var ctx = canvas.getContext("2d"),
            grad = ctx.createLinearGradient(0, 0, 1, 256);
          gradient.forEach(function (item) {
            grad.addColorStop(item[0], item[1]);
          });
          ctx.fillStyle = grad;
          ctx.fillRect(0, 0, 1, 256);
          return ctx.getImageData(0, 0, 1, 256).data;
        }
    
        (function () {
          var palette = colorPalette([
            [0, 'red'],
            [0.7, 'orange'],
            [0.17, 'yellow'],
            [0.22, 'green'],
            [0.42, 'cyan'],
            [0.82, 'blue'],
            [0.90, 'purple'],
          ])
    
          // Canvas元素
          var canvas = document.querySelector('canvas');
          var context = canvas.getContext('2d');
          var width = canvas.width, height = canvas.height;
          var start = Date.now()
          // 绘制方法
          var draw = function () {
            context.clearRect(0, 0, width, height);
            // 计算偏移
            var offset = Math.floor((Date.now() - start) / (3300 / 256)) % 256;
            context.fillStyle = 'rgba(' + [
              palette[offset * 4 + 0],
              palette[offset * 4 + 1],
              palette[offset * 4 + 2],
              palette[offset * 4 + 3]
            ] + ')';
            context.arc(width / 2, height / 2, height / 2, 0, 2 * Math.PI);
            context.fill();
            // 持续变化
            requestAnimationFrame(draw);
          };
          draw();
        })();
      </script>
    </body>
    </html>

    点这里在线看demo

    cavans 有些复杂,一时半会消化不了。之后再写详细的文章研究。Canvas主要优势是可以应对页面中多个动画元素渲染较慢的情况,完全通过javascript来渲染控制动画的执行。可用于实现较复杂动画

    九、CSS3 transition/animation

    transition
    transition是过度动画。但是transition并不能实现独立的动画,只能在某个标签元素样式或状态改变时进行平滑的动画效果过渡,而不是马上改变。

    在移动端开发中,直接使用transition动画会让页面变慢甚至卡顿。所以我们通常添加transform:translate3D(0,0,0)或transform:translateZ(0)来开启移动端动画的GPU加速,让动画过程更加流畅。

    animation
    animation 算是真正意义上的CSS3动画。通过对关键帧和循环次数的控制,页面标签元素会根据设定好的样式改变进行平滑过渡。而且关键帧状态的控制是通过百分比来控制的。

    CSS3最大的优势是摆脱了js的控制,并且能利用硬件加速以及实现复杂动画效果。

    有一篇文章做了简单的介绍,点这里
    假如用CSS3 来实现上面的Canvas 7彩颜色过渡的话,就非常简单了。

    @keyframes color {
        0% { background-color: red; }
        7% { background-color: orange; }
       17% { background-color: yellow; }
       22% { background-color: green; }
       42% { background-color: cyan; }
       82% { background-color: blue; }
       90% { background-color: purple; }    
    }

    当然并不是用CSS3 做动画比Canvas牛逼,只是使用场景不一样吧。

    知道的就这些了,之后再补充吧。

    [完]

    转载于:https://www.cnblogs.com/chuchur/p/10462282.html

    展开全文
  • TGA与YUV文件的转换

    2020-04-13 23:15:50
    一、TGA文件介绍 1.简介 TGA(Targa)格式是计算机上应用最广泛...TGA结构比较简单,属于一种图形、图像数据通用格式,在多媒体领域有很大影响,是计算机生成图像向电视转换一种首选格式。TGA图像格式最大特...

    一、TGA文件介绍

    1.简介

    TGA(Targa)格式是计算机上应用最广泛的图象格式。在兼顾了BMP的图象质量的同时又兼顾了JPEG的体积优势。并且还有自身的特点:通道效果、方向性。在CG领域常作为影视动画的序列输出格式,因为兼具体积小和效果清晰的特点。
    TGA的结构比较简单,属于一种图形、图像数据的通用格式,在多媒体领域有很大影响,是计算机生成图像向电视转换的一种首选格式。TGA图像格式最大的特点是可以做出不规则形状的图形、图像文件,一般图形、图像文件都为四方形,若需要有圆形、菱形甚至是缕空的图像文件时,TGA就可以派上用场了。

    2.TGA文件存储格式

    1)是以小端模式存储的,包括规格定义和RGB数据,也就是BGR形式存放。
    2)看到的图片的左上角一行像素可能放在文件内存中的最后一行(图片y轴可能是世界坐标系的和屏幕坐标系相反),或者文件内存中的第一行就是左上角一行像素。
    3) TGA头文件记录了调色板偏移大小和规格,和图像像素数据的偏移大小和规格。
    4) TGA分为压缩编码的和非压缩编码的,压缩算法是采用了RLE算法(由于个人能力不足,本文暂时不涉及RLE压缩算法)

    3.文件格式

    TGA文件具体格式如下:
    在这里插入图片描述

    二、TGA to YUV的具体实现

    1.编程思路

    在实现之前,先写了一个思维导图架构了一下工程逻辑:
    在这里插入图片描述

    2.源代码

    header.h:

    #pragma once
    #include <iostream>
    
    typedef struct
    {
        char  IdLength = 0;         
        char  ColourMapType = 0;   
        char  ImageTypeCode = 0;    
        short ColourMapOffset = 0;  
        short ColourMapLength = 0;  
        char  ColourMapDepth = 0;   
        short X_ori = 0;       
        short Y_ori = 0;        
        short Width = 0;          
        short Height = 0;          
        char  BitsPerPixel = 0;     
        char  ImageDescriptor = 0;  
    } HEADER;
    
    typedef struct
    {
        unsigned char R, G, B, A;
    } DATA;
    
    void ReadTGAHeader(HEADER* TGAHdPtr, FILE* TGAPtr);
    void ReadColourData(HEADER* TGAHdPtr, DATA* ColourData, FILE* TGAPtr);
    void Transform2RGB(DATA* ColourData, unsigned char* RGBBuff, HEADER* TGAHdPtr);
    void RGB2YUV(unsigned char* RGB, unsigned char* Y,
        unsigned char* U, unsigned char* V, int Width, int Height);
    

    main.cpp:

    #include <iostream>
    #include <cstdio>
    #include <fstream>
    #include <windows.h>
    #include "header.h"
    
    using namespace std;
    
    int main(int argc, char** argv)
    {
        FILE* TGAFile, * yuvFile;
        HEADER Hd; 
        int Width, Height, pxCount;
    
    	char* TGAFileName = NULL;
    	char* yuvFileName = NULL;
    	TGAFileName = argv[1];
    	yuvFileName = argv[2];
    
    	if (fopen_s(&TGAFile, TGAFileName, "rb") == 0)
    	{
    		cout << "File opened! " << TGAFileName << "." << endl;
    	}
    	else
    	{
    		cout << "File not opened! " << TGAFileName << "." << endl;
    		exit(0);
    	}
    	if (fopen_s(&yuvFile, yuvFileName, "wb+") == 0)
    	{
    		cout << "File opened! " << yuvFileName << "." << endl;
    	}
    	else
    	{
    		cout << "File not opened!  " << yuvFileName << "." << endl;
    		exit(0);
    	}
    
    	ReadTGAHeader(&Hd, TGAFile);
    	
    	Width = Hd.Height;
    	Height = Hd.Width;
    	pxCount = Width * Height;
    	unsigned char* RGB = (unsigned char*)malloc(sizeof(unsigned char) * (Width * Height * 3));
    	unsigned char* Y, * U, * V;
    	unsigned char* R, * G, * B;
    	R = (unsigned char*)malloc(sizeof(unsigned char) * (Width * Height));
    	G = (unsigned char*)malloc(sizeof(unsigned char) * (Width * Height));
    	B = (unsigned char*)malloc(sizeof(unsigned char) * (Width * Height));
    	Y = (unsigned char*)malloc(sizeof(char) * (Width * Height));
    	U = (unsigned char*)malloc(sizeof(char) * (Width * Height / 4));
    	V = (unsigned char*)malloc(sizeof(char) * (Width * Height / 4));
    
    	DATA* RGBaData = NULL;
    	RGBaData = new DATA[Hd.Width * Hd.Height];
    	memset(RGBaData, 0, Hd.Height * Hd.Width);   
    	RGB = new unsigned char[Hd.Width * Hd.Height * 3];
    	memset(RGB, 0, Hd.Height * Hd.Width * 3);   
    
    	int Ost = 0;
    	Ost += Hd.IdLength;
    	Ost += Hd.ColourMapType * Hd.ColourMapLength * Hd.ColourMapDepth;
    	fseek(TGAFile, Ost, SEEK_CUR); 
    
    	ReadColourData(&Hd, RGBaData, TGAFile);
    
    	Width = Hd.Width;
    	Height = Hd.Height;
    	for (int i = 0; i < Height; i++)
    	{
    		for (int j = 0; j < Width; j++)
    		{
    			int RGBPxNum = (Height - 1 - i) * Width + j;
    			int TGAPxNum = i * Width + j;
    
    			RGB[3 * RGBPxNum + 2] = RGBaData[TGAPxNum].R;
    			RGB[3 * RGBPxNum + 1] = RGBaData[TGAPxNum].G;
    			RGB[3 * RGBPxNum] = RGBaData[TGAPxNum].B;
    		}
    	}
    
    	RGB2YUV(RGB, Y, U, V, Width, Height);
    	free(RGB);
    
    	fwrite(Y, sizeof(unsigned char), Width * Height, yuvFile);
    	fwrite(U, sizeof(unsigned char), Width * Height / 4, yuvFile);
    	fwrite(V, sizeof(unsigned char), Width * Height / 4, yuvFile);
    	fclose(yuvFile);
    }
    

    ReadTGA.cpp:

    #include <iostream>
    #include "header.h"
    using namespace std;
    
    void ReadTGAHeader(HEADER* TGAHdPtr, FILE* TGAPtr)
    {
    
        fread(&TGAHdPtr->IdLength, 1, 1, TGAPtr);
        fread(&TGAHdPtr->ColourMapType, 1, 1, TGAPtr);
        fread(&TGAHdPtr->ImageTypeCode, 1, 1, TGAPtr);
        fread(&TGAHdPtr->ColourMapOffset, 2, 1, TGAPtr);
        fread(&TGAHdPtr->ColourMapLength, 2, 1, TGAPtr);
        fread(&TGAHdPtr->ColourMapDepth, 1, 1, TGAPtr);
        fread(&TGAHdPtr->X_ori, 2, 1, TGAPtr);
        fread(&TGAHdPtr->Y_ori, 2, 1, TGAPtr);
        fread(&TGAHdPtr->Width, 2, 1, TGAPtr);
        fread(&TGAHdPtr->Height, 2, 1, TGAPtr);
        fread(&TGAHdPtr->BitsPerPixel, 1, 1, TGAPtr);
        fread(&TGAHdPtr->ImageDescriptor, 1, 1, TGAPtr);
    
    
        if (TGAHdPtr->ImageTypeCode != 2 && TGAHdPtr->ImageTypeCode != 10)
        {
            cout << "本程序仅支持 Image Type Code 为 2(无压缩、无调色板的RGB图像)或 10(游程编码的RGB图像)\n";
            exit(-1);
        }
        if (TGAHdPtr->BitsPerPixel != 16 && TGAHdPtr->BitsPerPixel != 24 && TGAHdPtr->BitsPerPixel != 32)
        {
            cout << "本程序仅支持 Image pixel size 为 16,24,32 的图像\n";
            exit(-1);
        }
        if (TGAHdPtr->ColourMapType != 0 && TGAHdPtr->ColourMapType != 1)
        {
            cout << "本程序仅支持 Colour Map Type 为 0 或 1 的图像\n";
            exit(-1);
        }
    
    
        cout << "\nTGA header information:\n";
        printf("ID length:         %d\n", TGAHdPtr->IdLength);
        printf("Colour Map type:   %d\n", TGAHdPtr->ColourMapType);
        printf("Image type code:   %d\n", TGAHdPtr->ImageTypeCode);
        printf("Colour map Ost: %d\n", TGAHdPtr->ColourMapOffset);
        printf("Colour map length: %d\n", TGAHdPtr->ColourMapLength);
        printf("Colour map depth:  %d\n", TGAHdPtr->ColourMapDepth);
        printf("X origin:          %d\n", TGAHdPtr->X_ori);
        printf("Y origin:          %d\n", TGAHdPtr->Y_ori);
        printf("Width:             %d\n", TGAHdPtr->Width);
        printf("Height:            %d\n", TGAHdPtr->Height);
        printf("Image pixel size:  %d\n", TGAHdPtr->BitsPerPixel);
        printf("Descriptor:        %d\n\n", TGAHdPtr->ImageDescriptor);
    }
    

    RGB2YUV.cpp:

    #include<stdio.h>
    #include "header.h"
    
    
    float RGB2YUV02990[256], RGB2YUV05870[256], RGB2YUV01140[256], RGB2YUV01684[256],
    RGB2YUV03316[256], RGB2YUV05000[256], RGB2YUV04187[256], RGB2YUV00813[256];
    
    void InitRGB_table() {
    	for (int i = 0; i < 256; i++)
    	{
    		RGB2YUV02990[i] = (float)0.2990 * i;
    		RGB2YUV05870[i] = (float)0.5870 * i;
    		RGB2YUV01140[i] = (float)0.1140 * i;
    		RGB2YUV01684[i] = (float)0.1684 * i;
    		RGB2YUV03316[i] = (float)0.3316 * i;
    		RGB2YUV05000[i] = (float)0.5000 * i;
    		RGB2YUV04187[i] = (float)0.4187 * i;
    		RGB2YUV00813[i] = (float)0.0813 * i;
    	}
    }
    
    
    void RGB2YUV(unsigned char* RGB, unsigned char* Y, unsigned char* U, unsigned char* V, int Width, int Height)
    {
    	int y = 0;
    	for (int i = 0; i < Width * Height * 3; i = i + 3)
    	{
    		InitRGB_table();
    		Y[y] = RGB2YUV01140[RGB[i]] + RGB2YUV05870[RGB[i + 1]] + RGB2YUV02990[RGB[i + 2]];
    		//Y范围:16-235
    		if (Y[y] > 235)
    			Y[y] = 235;
    		if (Y[y] < 16)
    			Y[y] = 16;
    		y++;
    	}
    
    	int m = 0, n = 0;
    	for (int i = 0; i < Width * Height * 3;)
    	{
    		unsigned char* rgb;
    		rgb = new unsigned char[Width * Height * 3];
    		rgb[i] = (RGB[i] + RGB[i + 3] + RGB[i + Width * 3] + RGB[i + Width * 3 + 3]) / 4;
    		InitRGB_table();
    		U[m] = RGB2YUV05000[rgb[i]] - RGB2YUV03316[rgb[i + 1]] - RGB2YUV01684[rgb[i + 2]] + 128;
    		V[n] = -RGB2YUV00813[rgb[i]] - RGB2YUV04187[rgb[i + 1]] * +RGB2YUV05000[rgb[i + 2]] + 128;
    		m++;
    		n++;
    		//U,V范围:16-240
    		if (U[m] > 240)
    			U[m] = 240;
    		if (U[m] < 16)
    			U[m] = 16;
    		if (V[n] > 240)
    			V[n] = 240;
    		if (V[n] < 16)
    			V[n] = 16;
    		if ((i / 3) % 256 == 254)
    			i = i + 258 * 3;
    		else
    			i = i + 6;
    		delete[]RGB;
    	}
    }
    

    三、实验结果

    原图:

    在这里插入图片描述

    运行结果:

    16位 24位 32位
    在这里插入图片描述 在这里插入图片描述 在这里插入图片描述

    程序截图:

    在这里插入图片描述

    展开全文
  • 一、TGA文件格式基本介绍 TGA(Targa)格式是计算机上应用最广泛图象格式。在兼顾了BMP图象质量同时又兼顾了JPEG体积优势。并且还有自身特点:通道效果、方向性。在CG领域常作为影视动画的序列输出格式,...

    一、TGA文件格式基本介绍
    TGA(Targa)格式是计算机上应用最广泛的图象格式。在兼顾了BMP的图象质量的同时又兼顾了JPEG的体积优势。并且还有自身的特点:通道效果、方向性。在CG领域常作为影视动画的序列输出格式,因为兼具体积小和效果清晰的特点。
    TGA的结构比较简单,属于一种图形、图像数据的通用格式,在多媒体领域有很大影响,是计算机生成图像向电视转换的一种首选格式。TGA图像格式最大的特点是可以做出不规则形状的图形、图像文件,一般图形、图像文件都为四方形,若需要有圆形、菱形甚至是缕空的图像文件时,TGA就可以派上用场了。
    TGA可以压缩也可以不压缩,文件格式较为简单。
    二、实验内容
    通过C++编写程序,实现TGA文件到YUV文件的转换
    三、主要思路
    1.利用photoshop将JPEG形式的图像转无压缩的TGA图像
    2.读取TGA文件的文件头,获取文件信息
    3.读取TGA的其他数据
    4.将TGA中的数据转入存储RGB三种颜色的数组
    5.从RGB转成YUV
    四、TGA文件主体架构
    PART1:文件信息头TGA FILE HEADER:
    包含三部分:
    (1)图像信息字段长度:1字节,规定了包含在字段6(Image ID字段)中的字节数,最大的字符数是255,它的值为0,则表示在这个文件中没有图像信息字段
    (2)颜色表类型:1字节,其值为0表示没有颜色表,为1表示有颜色表
    (3)图像类型:1字节,用于存储各种位深度的伪彩色,真彩色,调配色
    此部分结构体定义如下:

    typedef struct TGAFILEHEADER1{
    	BYTE IDLENGTH;//图像信息字段长度,1个字节,值为0,则表示在这个文件中没有图像信息字段。
    	BYTE COLORMAPTYPE;//颜色表类型,1个字节,0 表示没有颜色表,1 表示颜色表存在
    	BYTE IMAGETYPE;//图像类型,1个字节
    }TGAFILEHEADER1;
    

    PART2: 颜色表规约COLOR MAP SPECIFICATION
    包含三部分:
    (1)颜色表首地址:2字节,第一个颜色表表项的索引,是装载颜色表的首地址。
    (2)颜色表长度:2字节,颜色表表项的数量
    (3)颜色表表项大小:1字节,每个表项占用的位数,典型的值有15,16,24,或者32位。
    此部分结构体定义如下:

    typedef struct TGAFILEHEADER2 {
    	WORD FIRSTENTRYINDEX; //颜色表首地址,2字节
    	WORD COLORMAPLENTH;//颜色表长度,2字节
    	BYTE COLORMAPENTRYSIZE;//颜色表表项大小,1字节
    	//每个表项占用的位数,典型的值有15,16,24,或者32位
    }TGAFILEHEADER2;
    

    PART3:图像规约IMAGE SPECIFICATION
    (1)图像X的起始位置:2字节,图像左下角的水平坐标
    (2)图像Y的起始位置:2字节,图像左下角的垂直坐标
    (3)图像宽度:2字节
    (4)图像高度:2字节
    (5)像素深度:1字节,表示每个像素占用的位数,通常的值是8,16,24,32位。
    (6)图像描述符:1字节
    在这里插入图片描述
    0-3位,规定了每个像素属性位的数量;4-5位,这些位用于表示像素数据从文件发送到屏幕的顺序,位4表示从左到右,位5表示从上到下,如下图所示。
    在这里插入图片描述
    此部分结构体定义如下:

    typedef struct TGAFILEHEADER3 {
    	WORD XORIGION; //2个字节,图像左下角的水平坐标
    	WORD YORIGION;//2个字节,图像左下角的垂直坐标
    	WORD IMAGEWIDTH;//2个字节,图像宽度
    	WORD IMAGEHEIGHT;//2个字节,图像高度
    	BYTE BITDEPTH;//1个字节,像素z深度
    	BYTE IMAGEDESCRIPTOR;//1个字节,图像描述符
    	//0-3位,规定了每个像素属性位的数量。看field 24(属性类型,Attributes Type)以获取更多信息
    	//Targa 16, 该值为 0 或 1;Targa 24,该值为 0;Targa 32,该值为 8
    	//4-5位,这些位用于表示像素数据从文件发送到屏幕的顺序
    	//00:bottom left,01:bottom right,10:top left,11:top right
    	//6-7位,必需为0。
    }TGAFILEHEADER3;
    

    五、实验具体流程及结果:
    1.首先从photoshop中导入三张JPEG的图片,并将其分别转化为像素深度为16bit,24bit,32bit的三张TGA图片。获得的三张TGA图片分别为:
    16.tga:1600✖️1600,16bit像素深度:
    在这里插入图片描述
    24.tga:1600✖️1600,24bit像素深度
    在这里插入图片描述
    32.tga:1200✖️1200,32bit像素深度
    在这里插入图片描述
    2.写代码:
    代码中重点部分:
    part1:结构体定义:

    typedef struct TGAFILEHEADER1{
    	BYTE IDLENGTH;//图像信息字段长度,1个字节,值为0,则表示在这个文件中没有图像信息字段。
    	BYTE COLORMAPTYPE;//颜色表类型,1个字节,0 表示没有颜色表,1 表示颜色表存在
    	BYTE IMAGETYPE;//图像类型,1个字节
    }TGAFILEHEADER1;
    
    typedef struct TGAFILEHEADER2 {
    	WORD FIRSTENTRYINDEX; //颜色表首地址,2字节
    	WORD COLORMAPLENTH;//颜色表长度,2字节
    	BYTE COLORMAPENTRYSIZE;//颜色表表项大小,1字节
    	//每个表项占用的位数,典型的值有15,16,24,或者32位
    }TGAFILEHEADER2;
    
    typedef struct TGAFILEHEADER3 {
    	WORD XORIGION; //2个字节,图像左下角的水平坐标
    	WORD YORIGION;//2个字节,图像左下角的垂直坐标
    	WORD IMAGEWIDTH;//2个字节,图像宽度
    	WORD IMAGEHEIGHT;//2个字节,图像高度
    	BYTE BITDEPTH;//1个字节,像素z深度
    	BYTE IMAGEDESCRIPTOR;//1个字节,图像描述符
    	//0-3位,规定了每个像素属性位的数量。看field 24(属性类型,Attributes Type)以获取更多信息
    	//Targa 16, 该值为 0 或 1;Targa 24,该值为 0;Targa 32,该值为 8
    	//4-5位,这些位用于表示像素数据从文件发送到屏幕的顺序
    	//00:bottom left,01:bottom right,10:top left,11:top right
    	//6-7位,必需为0。
    }TGAFILEHEADER3;
    

    PART2:无调色板的情况(COLORTYPE=0):

    if (FILE_HEADER1.COLORMAPTYPE == 0)//no color chart
    	{
    		if (fread(DATA, sizeof(unsigned char), DataSize, TGA) == 0)
    		{
    			cout << "Failed to read the data into the buffer!" << endl;
    		}
    		else
    		{
    			cout << "Successfully read in the data into the buffer." << endl;
    		}
    		if (imagedescriptor == 1)//means Targa 16&bottom left
    		{
    			int j = DataSize / 2;
    			for (int i = 0; i < DataSize;)
    			{
    				ALPHA[j] = DATA[i + 1] & 0b10000000;
    				RED[j] = (DATA[i+1] & 0b01111100) << 1;
    				GREEN[j] = ((DATA[i+1] & 0b00000011) << 6) | ((DATA[i] & 0b11100000) >> 2);
    				BLUE[j] = (DATA[i] & 0b00011111) << 3;
    				i += 2;
    				j--;
    			}
    		}
    		else if (imagedescriptor == 0)//means Targa 24&bottom left
    		{
    			int j = DataSize / 3;
    			for (int i = 0; i < DataSize;)
    			{
    				RED[j] = DATA[i + 2];
    				GREEN[j] = DATA[i + 1];
    				BLUE[j] = DATA[i];
    				i += 3;
    				j--;
    			}
    		}
    		else if (imagedescriptor == 8)//means Targa 32&bottom left
    		{
    			int j = DataSize / 4;
    			for (int i = 0; i < DataSize;)
    			{
    				ALPHA[j] = DATA[i + 3];
    				RED[j] = DATA[i + 2];
    				GREEN[j] = DATA[i + 1];
    				BLUE[j] = DATA[i];
    				i += 4;
    				j--;
    			}
    		}
    		else
    		{
    			cout << "This picture is too special to analyse!" << endl;
    		}
    	}
    

    PART3:有调色板的情况(COLORTYPE=1):

    else if(FILE_HEADER1.COLORMAPTYPE == 1)//there is a color chart
    	{
    		int COLORMAPADDRESS = 0;
    		int COLORMAPLENGTH = 0;
    		int COLORMAPSIZE = 0;
    		int bitsperpixel = 0;
    		COLORMAPADDRESS = FILE_HEADER2.FIRSTENTRYINDEX;
    		COLORMAPLENGTH = FILE_HEADER2.COLORMAPLENTH;
    		COLORMAPSIZE = FILE_HEADER2.COLORMAPENTRYSIZE;
    		bitsperpixel = FILE_HEADER3.BITDEPTH;
    		unsigned char* COLORMAP = NULL;		
    		COLORMAP = (unsigned char*)malloc(COLORMAPSIZE);
    		fseek(TGA, COLORMAPADDRESS, SEEK_SET);
    		if (fread(COLORMAP, sizeof(unsigned char), COLORMAPSIZE, TGA) == 0)
    		{
    			cout << "Read Color Map error!" << endl;
    		}
    		else
    		{
    			cout << "Successfully read Color Map!" << endl;
    		}
    		if (COLORMAPSIZE = 16)
    		{
    			unsigned char* COLORMAP_ALPHA = NULL;
    			unsigned char* COLORMAP_RED = NULL;
    			unsigned char* COLORMAP_GREEN = NULL;
    			unsigned char* COLORMAP_BLUE = NULL;
    			COLORMAP_ALPHA = (unsigned char*)malloc(COLORMAPSIZE / 2);
    			COLORMAP_RED = (unsigned char*)malloc(COLORMAPSIZE / 2);
    			COLORMAP_GREEN = (unsigned char*)malloc(COLORMAPSIZE / 2);
    			COLORMAP_BLUE = (unsigned char*)malloc(COLORMAPSIZE / 2);
    			int j = COLORMAPSIZE / 2;
    			for (int i = 0; i < COLORMAPSIZE;)
    			{
    				COLORMAP_ALPHA[j] = COLORMAP[i + 1] & 0b10000000;
    				COLORMAP_RED[j] = (COLORMAP[i + 1] & 0b01111100) << 1;
    				COLORMAP_GREEN[j] = ((COLORMAP[i + 1] & 0b00000011) << 6) | ((COLORMAP[i] & 0b11100000) >> 2);
    				COLORMAP_BLUE[j] = (COLORMAP[i] & 0b00011111) << 3;
    				i += 2;
    				j--;
    			}
    			if (fread(DATA, sizeof(unsigned char), DataSize, TGA) == 0)
    			{
    				cout << "Failed to read the data into the buffer!" << endl;
    			}
    			else
    			{
    				cout << "Successfully read in the data into the buffer." << endl;
    			}
    			int bytesperpixel = 0;
    			bytesperpixel = bitsperpixel / 8;
    			int k = DataSize / bytesperpixel;
    			for (int i = 0; i < DataSize;)
    			{
    				if (bytesperpixel == 2)
    				{
    					for (int j = 0; j < COLORMAPSIZE; j++)
    					{
    						if (j == ((DATA[i] & 0b11111111 << 8) + DATA[i + 1]))
    						{
    							ALPHA[k - i / 2] = COLORMAP_ALPHA[j];
    							RED[k - i / 2] = COLORMAP_RED[j];
    							GREEN[k - i / 2] = COLORMAP_GREEN[j];
    							BLUE[k - i / 2] = COLORMAP_BLUE[j];
    							i += 2;
    							k--;
    						}
    					}
    				}
    				if (bytesperpixel == 3)
    				{
    					for (int j = 0; j < COLORMAPSIZE; j++)
    					{
    						if (j == ((DATA[i] & 0b11111111 << 16) + (DATA[i + 1] & 0b11111111 << 8) + DATA[i + 2]))
    						{
    							ALPHA[k - i / 3] = COLORMAP_ALPHA[j];
    							RED[k - i / 3] = COLORMAP_RED[j];
    							GREEN[k - i / 3] = COLORMAP_GREEN[j];
    							BLUE[k - i / 3] = COLORMAP_BLUE[j];
    							i += 3;
    							k--;
    						}
    					}
    				}
    				if (bytesperpixel == 4)
    				{
    					for (int j = 0; j < COLORMAPSIZE; j++)
    					{
    						if (j == ((DATA[i] & 0b11111111 << 24) + (DATA[i + 1] & 0b11111111 << 16) + (DATA[i + 2] & 0b11111111 << 8) + DATA[i + 3]))
    						{
    							ALPHA[k - i / 4] = COLORMAP_ALPHA[j];
    							RED[k - i / 4] = COLORMAP_RED[j];
    							GREEN[k - i / 4] = COLORMAP_GREEN[j];
    							BLUE[k - i / 4] = COLORMAP_BLUE[j];
    							i += 4;
    							k--;
    						}
    					}
    				}
    			}
    			free(COLORMAP_ALPHA);
    			free(COLORMAP_RED);
    			free(COLORMAP_GREEN);
    			free(COLORMAP_BLUE);		
    		}
    		else if (COLORMAPSIZE = 24)
    		{
    			unsigned char* COLORMAP_RED = NULL;
    			unsigned char* COLORMAP_GREEN = NULL;
    			unsigned char* COLORMAP_BLUE = NULL;
    			COLORMAP_RED = (unsigned char*)malloc(COLORMAPSIZE / 3);
    			COLORMAP_GREEN = (unsigned char*)malloc(COLORMAPSIZE / 3);
    			COLORMAP_BLUE = (unsigned char*)malloc(COLORMAPSIZE / 3);
    			int j = COLORMAPSIZE / 3;
    			for (int i = 0; i < COLORMAPSIZE;)
    			{
    				COLORMAP_RED[j] = COLORMAP[i + 2];
    				COLORMAP_GREEN[j] = COLORMAP[i + 1];
    				COLORMAP_BLUE[j] = COLORMAP[i];
    				i += 3;
    				j--;
    			}
    			if (fread(DATA, sizeof(unsigned char), DataSize, TGA) == 0)
    			{
    				cout << "Failed to read the data into the buffer!" << endl;
    			}
    			else
    			{
    				cout << "Successfully read in the data into the buffer." << endl;
    			}
    			int bytesperpixel = 0;
    			bytesperpixel = bitsperpixel / 8;
    			int k = DataSize / bytesperpixel;
    			for (int i = 0; i < DataSize;)
    			{
    				if (bytesperpixel == 2)
    				{
    					for (int j = 0; j < COLORMAPSIZE; j++)
    					{
    						if (j == ((DATA[i] & 0b11111111 << 8) + DATA[i + 1]))
    						{
    							RED[k - i / 2] = COLORMAP_RED[j];
    							GREEN[k - i / 2] = COLORMAP_GREEN[j];
    							BLUE[k - i / 2] = COLORMAP_BLUE[j];
    							i += 2;
    							k--;
    						}
    					}
    				}
    				if (bytesperpixel == 3)
    				{
    					for (int j = 0; j < COLORMAPSIZE; j++)
    					{
    						if (j == ((DATA[i] & 0b11111111 << 16) + (DATA[i + 1] & 0b11111111 << 8) + DATA[i + 2]))
    						{
    							RED[k - i / 3] = COLORMAP_RED[j];
    							GREEN[k - i / 3] = COLORMAP_GREEN[j];
    							BLUE[k - i / 3] = COLORMAP_BLUE[j];
    							i += 3;
    							k--;
    						}
    					}
    				}
    				if (bytesperpixel == 4)
    				{
    					for (int j = 0; j < COLORMAPSIZE; j++)
    					{
    						if (j == ((DATA[i] & 0b11111111 << 24) + (DATA[i + 1] & 0b11111111 << 16) + (DATA[i + 2] & 0b11111111 << 8) + DATA[i + 3]))
    						{
    							RED[k - i / 4] = COLORMAP_RED[j];
    							GREEN[k - i / 4] = COLORMAP_GREEN[j];
    							BLUE[k - i / 4] = COLORMAP_BLUE[j];
    							i += 4;
    							k--;
    						}
    					}
    				}
    			}
    			free(COLORMAP_RED);
    			free(COLORMAP_GREEN);
    			free(COLORMAP_BLUE);
    		}
    		else if (COLORMAPSIZE = 32)
    		{
    		    unsigned char* COLORMAP_ALPHA = NULL;
    		    unsigned char* COLORMAP_RED = NULL;
    		    unsigned char* COLORMAP_GREEN = NULL;
    		    unsigned char* COLORMAP_BLUE = NULL;
    		    COLORMAP_ALPHA = (unsigned char*)malloc(COLORMAPSIZE / 2);
    		    COLORMAP_RED = (unsigned char*)malloc(COLORMAPSIZE / 2);
    		    COLORMAP_GREEN = (unsigned char*)malloc(COLORMAPSIZE / 2);
    		    COLORMAP_BLUE = (unsigned char*)malloc(COLORMAPSIZE / 2);
    		    int j = COLORMAPSIZE / 4;
    		    for (int i = 0; i < COLORMAPSIZE;)
    		    {
    			    COLORMAP_ALPHA[j] = COLORMAP[i + 3];
    			    COLORMAP_RED[j] = COLORMAP[i + 2];
    			    COLORMAP_GREEN[j] = COLORMAP[i + 1];
    			    COLORMAP_BLUE[j] = COLORMAP[i];
    			    i += 3;
    			    j--;
    		    }
    		    if (fread(DATA, sizeof(unsigned char), DataSize, TGA) == 0)
    		    {
    			    cout << "Failed to read the data into the buffer!" << endl;
    		    }
    		    else
    		    {
    			    cout << "Successfully read in the data into the buffer." << endl;
    		    } 
    		    int bytesperpixel = 0;
    		    bytesperpixel = bitsperpixel / 8;
    		    int k = DataSize / bytesperpixel;
    		    for (int i = 0; i < DataSize;)
    		    {
    			if (bytesperpixel == 2)
    			{
    				for (int j = 0; j < COLORMAPSIZE; j++)
    				{
    					if (j == ((DATA[i] & 0b11111111 << 8) + DATA[i + 1]))
    					{
    						ALPHA[k - i / 2] = COLORMAP_ALPHA[j];
    						RED[k - i / 2] = COLORMAP_RED[j];
    						GREEN[k - i / 2] = COLORMAP_GREEN[j];
    						BLUE[k - i / 2] = COLORMAP_BLUE[j];
    						i += 2;
    						k--;
    					}
    				}
    			}
    			if (bytesperpixel == 3)
    			{
    				for (int j = 0; j < COLORMAPSIZE; j++)
    				{
    					if (j == ((DATA[i] & 0b11111111 << 16) + (DATA[i + 1] & 0b11111111 << 8) + DATA[i + 2]))
    					{
    						ALPHA[k - i / 3] = COLORMAP_ALPHA[j];
    						RED[k - i / 3] = COLORMAP_RED[j];
    						GREEN[k - i / 3] = COLORMAP_GREEN[j];
    						BLUE[k - i / 3] = COLORMAP_BLUE[j];
    						i += 3;
    						k--;
    					}
    				}
    			}
    			if (bytesperpixel == 4)
    			{
    				for (int j = 0; j < COLORMAPSIZE; j++)
    				{
    					if (j == ((DATA[i] & 0b11111111 << 24) + (DATA[i + 1] & 0b11111111 << 16) + (DATA[i + 2] & 0b11111111 << 8) + DATA[i + 3]))
    					{
    						ALPHA[k - i / 4] = COLORMAP_ALPHA[j];
    						RED[k - i / 4] = COLORMAP_RED[j];
    						GREEN[k - i / 4] = COLORMAP_GREEN[j];
    						BLUE[k - i / 4] = COLORMAP_BLUE[j];
    						i += 4;
    						k--;
    					}
    				}
    			}
    		}
    		free(COLORMAP_ALPHA);
    		free(COLORMAP_RED);
    		free(COLORMAP_GREEN);
    		free(COLORMAP_BLUE);
            }
    		else
    		{
    			cout << "This colormap is too special.This program cannot analyse this picture!" << endl;
    		}
    
    	}
    	else
    	{
    		cout << "this program cannot analyse this picture!" << endl;
    	}
    

    PART4:RGB转换为YUV(rgb2yuv.cpp):

    #include<iostream>
    #include<windows.h>
    #include<math.h>
    #include <cstring>
    #include <cstdlib>
    #include"header.h"
    using namespace std;
    
    void RGBtoYUV(int w,int h,int size,unsigned char*RED_BUFFER,unsigned char*GREEN_BUFFER,unsigned char*BLUE_BUFFER)
    {
    	FILE* YUV = NULL;
    	if (fopen_s(&YUV, "C:\\32.yuv", "wb") != 0)
    	{
    		cout << "Failed to create the yuv file!" << endl;
    	}
    	else
    	{
    		cout << "Successfully created the yuv file!" << endl;
    	}
    	unsigned char* Y_BUFFER = NULL; 
    	unsigned char* U_BUFFER = NULL; 
    	unsigned char* V_BUFFER = NULL;
    	Y_BUFFER = new unsigned char[size / 3];
    	U_BUFFER = new unsigned char[size / 12];
        V_BUFFER = new unsigned char[size / 12];
    	for (int i = 0; i < size/3; i++)//caculate Y
    	{
    		Y_BUFFER[i] = RED_BUFFER[i] * 0.2990 +
    			GREEN_BUFFER[i] * 0.5870 +
    			BLUE_BUFFER[i] * 0.1140;
    		//Y=0.2990*Red+0.5870*Green+0.1440*Blue
    		if (Y_BUFFER[i] > 235)
    		{
    			Y_BUFFER[i] = 235;
    		}
    		if (Y_BUFFER[i] < 16)
    		{
    			Y_BUFFER[i] = 16;
    		}
    		//In order to avoid the overload of the luminace, so we need to reserve some space
    	}
    
    
    	int u = 0;
    	for (int i = 0; i < size/3;)//caculate u
    	{
    		U_BUFFER[u] = (RED_BUFFER[i] + RED_BUFFER[i + 1] + RED_BUFFER[i + w] + RED_BUFFER[i + w + 1]) / 4 * (-0.1684) +
    			(GREEN_BUFFER[i] + GREEN_BUFFER[i + 1] + GREEN_BUFFER[i + w] + GREEN_BUFFER[i + w + 1]) / 4 * (-0.3316) +
    			(BLUE_BUFFER[i] + BLUE_BUFFER[i + 1] + BLUE_BUFFER[i + w] + BLUE_BUFFER[i + w + 1]) / 4 * (0.500) + 128;
    		if (U_BUFFER[u] > 235)
    		{
    			U_BUFFER[u] = 235;
    		}
    		if (U_BUFFER[u] < 16)
    		{
    			U_BUFFER[u] = 16;
    		}
    		if (i % w == (w-2))
    		{
    			i = i + w + 2;
    		}
    		else
    		{
    			i = i + 2;
    		}
    		u++;
    	}
    	int v = 0;
    	for (int i = 0; i < size/3;)//caculate v
    	{
    		V_BUFFER[v] = (RED_BUFFER[i] + RED_BUFFER[i + 1] + RED_BUFFER[i + w] + RED_BUFFER[i + w + 1]) / 4 * (0.5) +
    			(GREEN_BUFFER[i] + GREEN_BUFFER[i + 1] + GREEN_BUFFER[i + w] + GREEN_BUFFER[i + w + 1]) / 4 * (-0.4187) +
    			(BLUE_BUFFER[i] + BLUE_BUFFER[i + 1] + BLUE_BUFFER[i + w] + BLUE_BUFFER[i + w + 1]) / 4 * (-0.0813) + 128;
    		if (V_BUFFER[v] > 235)
    		{
    			V_BUFFER[v] = 235;
    		}
    		if (V_BUFFER[v] < 16)
    		{
    			V_BUFFER[v] = 16;
    		}
    		if (i % w == (w - 2))
    		{
    			i = i + w +2;
    		}
    		else
    		{
    			i = i + 2;
    		}
    		v++;
    	}
    	fwrite(Y_BUFFER, sizeof(unsigned char), size/3, YUV);
    	fwrite(U_BUFFER, sizeof(unsigned char), size/12, YUV);
    	fwrite(V_BUFFER, sizeof(unsigned char), size/12, YUV);
    
    	
    }
    

    完整主函数(main.cpp):

    #include<iostream>
    #include<windows.h>
    #include<math.h>
    #include <cstring>
    #include <cstdlib>
    #include"header.h"
    using namespace std;
    
    typedef struct TGAFILEHEADER1{
    	BYTE IDLENGTH;//图像信息字段长度,1个字节,值为0,则表示在这个文件中没有图像信息字段。
    	BYTE COLORMAPTYPE;//颜色表类型,1个字节,0 表示没有颜色表,1 表示颜色表存在
    	BYTE IMAGETYPE;//图像类型,1个字节
    }TGAFILEHEADER1;
    
    typedef struct TGAFILEHEADER2 {
    	WORD FIRSTENTRYINDEX; //颜色表首地址,2字节
    	WORD COLORMAPLENTH;//颜色表长度,2字节
    	BYTE COLORMAPENTRYSIZE;//颜色表表项大小,1字节
    	//每个表项占用的位数,典型的值有15,16,24,或者32位
    }TGAFILEHEADER2;
    
    typedef struct TGAFILEHEADER3 {
    	WORD XORIGION; //2个字节,图像左下角的水平坐标
    	WORD YORIGION;//2个字节,图像左下角的垂直坐标
    	WORD IMAGEWIDTH;//2个字节,图像宽度
    	WORD IMAGEHEIGHT;//2个字节,图像高度
    	BYTE BITDEPTH;//1个字节,像素z深度
    	BYTE IMAGEDESCRIPTOR;//1个字节,图像描述符
    	//0-3位,规定了每个像素属性位的数量。看field 24(属性类型,Attributes Type)以获取更多信息
    	//Targa 16, 该值为 0 或 1;Targa 24,该值为 0;Targa 32,该值为 8
    	//4-5位,这些位用于表示像素数据从文件发送到屏幕的顺序
    	//00:bottom left,01:bottom right,10:top left,11:top right
    	//6-7位,必需为0。
    }TGAFILEHEADER3;
    
    int main()
    {
    	FILE* TGA = NULL;
    	FILE* RGB = NULL;
    	TGAFILEHEADER1 FILE_HEADER1;
    	TGAFILEHEADER2 FILE_HEADER2;
    	TGAFILEHEADER3 FILE_HEADER3;
    	if (fopen_s(&TGA, "C:\\32.tga", "rb") != 0)
    	{
            cout << "Failed to open the tga file!" << endl;
    	}
    	else
    	{
    	cout << "Successfully opened the tga file!" << endl;
    	}
    	if (fopen_s(&RGB, "C:\\32.rgb", "wb") != 0)
    	{
    		cout << "Failed to create the rgb file!" << endl;
    	}
    	else
    	{
    		cout << "Successfully created the rgb file!" << endl;
    	}
    	fseek(TGA, 0L, SEEK_END);
    	int FileSize;
    	FileSize = ftell(TGA);
    	fseek(TGA, 0L, SEEK_SET);
    	/*cout << sizeof(TGAFILEHEADER) << endl;*/
    	if (fread(&FILE_HEADER1, 1, 3, TGA) == 0)
    	{
    		cout << "Read File Header1 error!" << endl;
    	}
    	else
    	{
    		cout << "Successfully read File Header!" << endl;
    	}
    	if (FILE_HEADER1.IDLENGTH == 0)
    	{
    		cout << "There's no Image information words in this picture." << endl;
    	}
    	else
    	{
    		cout << "This program cannot analyse this picture!" << endl;
    	}
    	if (FILE_HEADER1.COLORMAPTYPE == 0)
    	{
    		cout << "There is no PLTE in this picture." << endl;
    	}
    	else
    	{
    		cout << "This Image includes a PLTE!" << endl;
    	}
    	if (FILE_HEADER1.IMAGETYPE == 2)
    	{
    		cout << "This is a ture color image!" << endl;
    	}
    	else
    	{
    		cout << "This is a ture color image!" << endl;
    	}
    	if (fread(&FILE_HEADER2, 1, 5, TGA) == 0)
    	{
    		cout << "Read File Header2 error!" << endl;
    	}
    	else
    	{
    		cout << "Successfully read File Header!" << endl;
    	}
    	int colortype = FILE_HEADER2.COLORMAPENTRYSIZE;
    	cout << "The fisrt entry of the index is " << FILE_HEADER2.FIRSTENTRYINDEX << "." << endl;
    	cout << "The length of the color map is " << FILE_HEADER2.COLORMAPLENTH << "." << endl;
    	cout << "The size of the color map entry is " << colortype << "." << endl;
    	if (fread(&FILE_HEADER3, 1, 10, TGA) == 0)
    	{
    		cout << "Read File Header3 error!" << endl;
    	}
    	else
    	{
    		cout << "Successfully read File Header!" << endl;
    	}
    	int bitdepth = FILE_HEADER3.BITDEPTH;
    	int imagedescriptor = FILE_HEADER3.IMAGEDESCRIPTOR;
    	cout << "The X-origin of the image is " << FILE_HEADER3.XORIGION << "." << endl;
    	cout << "The Y-origin of the image is " << FILE_HEADER3.YORIGION << "." << endl;
    	cout << "The width of the image is " << FILE_HEADER3.IMAGEWIDTH << "." << endl;
    	cout << "The height of the image is " << FILE_HEADER3.IMAGEHEIGHT << "." << endl;
    	cout << "The bitdepth of the image is " << bitdepth << "." << endl;
    	cout << "The imagedescripter of the image is " << imagedescriptor << "." << endl;
    
    	int FILEHEADERSIZE = sizeof(FILE_HEADER1) + sizeof(FILE_HEADER1) + sizeof(FILE_HEADER1);
    	int width = 0;
    	int height = 0;
    	width = FILE_HEADER3.IMAGEWIDTH;
    	height = FILE_HEADER3.IMAGEHEIGHT;
    	int DataSize = 0;
    	DataSize = width * height * bitdepth / 8;
    	cout << "The size of the data is " << DataSize << "bytes." << endl;
    
    	unsigned char* DATA = NULL;
    	unsigned char* RED = NULL;
    	unsigned char* GREEN = NULL;
    	unsigned char* BLUE = NULL;
    	unsigned char* ALPHA = NULL;
    	DATA = (unsigned char*)malloc(DataSize);
    	RED = (unsigned char*)malloc(height * width);
    	GREEN = (unsigned char*)malloc(height * width);
    	BLUE = (unsigned char*)malloc(height * width);
    	ALPHA = (unsigned char*)malloc(height * width);
    
    	if (FILE_HEADER1.COLORMAPTYPE == 0)//no color chart
    	{
    		if (fread(DATA, sizeof(unsigned char), DataSize, TGA) == 0)
    		{
    			cout << "Failed to read the data into the buffer!" << endl;
    		}
    		else
    		{
    			cout << "Successfully read in the data into the buffer." << endl;
    		}
    		if (imagedescriptor == 1)//means Targa 16&bottom left
    		{
    			int j = DataSize / 2;
    			for (int i = 0; i < DataSize;)
    			{
    				ALPHA[j] = DATA[i + 1] & 0b10000000;
    				RED[j] = (DATA[i+1] & 0b01111100) << 1;
    				GREEN[j] = ((DATA[i+1] & 0b00000011) << 6) | ((DATA[i] & 0b11100000) >> 2);
    				BLUE[j] = (DATA[i] & 0b00011111) << 3;
    				i += 2;
    				j--;
    			}
    		}
    		else if (imagedescriptor == 0)//means Targa 24&bottom left
    		{
    			int j = DataSize / 3;
    			for (int i = 0; i < DataSize;)
    			{
    				RED[j] = DATA[i + 2];
    				GREEN[j] = DATA[i + 1];
    				BLUE[j] = DATA[i];
    				i += 3;
    				j--;
    			}
    		}
    		else if (imagedescriptor == 8)//means Targa 32&bottom left
    		{
    			int j = DataSize / 4;
    			for (int i = 0; i < DataSize;)
    			{
    				ALPHA[j] = DATA[i + 3];
    				RED[j] = DATA[i + 2];
    				GREEN[j] = DATA[i + 1];
    				BLUE[j] = DATA[i];
    				i += 4;
    				j--;
    			}
    		}
    		else
    		{
    			cout << "This picture is too special to analyse!" << endl;
    		}
    	}
    	else if(FILE_HEADER1.COLORMAPTYPE == 1)//there is a color chart
    	{
    		int COLORMAPADDRESS = 0;
    		int COLORMAPLENGTH = 0;
    		int COLORMAPSIZE = 0;
    		int bitsperpixel = 0;
    		COLORMAPADDRESS = FILE_HEADER2.FIRSTENTRYINDEX;
    		COLORMAPLENGTH = FILE_HEADER2.COLORMAPLENTH;
    		COLORMAPSIZE = FILE_HEADER2.COLORMAPENTRYSIZE;
    		bitsperpixel = FILE_HEADER3.BITDEPTH;
    		unsigned char* COLORMAP = NULL;		
    		COLORMAP = (unsigned char*)malloc(COLORMAPSIZE);
    		fseek(TGA, COLORMAPADDRESS, SEEK_SET);
    		if (fread(COLORMAP, sizeof(unsigned char), COLORMAPSIZE, TGA) == 0)
    		{
    			cout << "Read Color Map error!" << endl;
    		}
    		else
    		{
    			cout << "Successfully read Color Map!" << endl;
    		}
    		if (COLORMAPSIZE = 16)
    		{
    			unsigned char* COLORMAP_ALPHA = NULL;
    			unsigned char* COLORMAP_RED = NULL;
    			unsigned char* COLORMAP_GREEN = NULL;
    			unsigned char* COLORMAP_BLUE = NULL;
    			COLORMAP_ALPHA = (unsigned char*)malloc(COLORMAPSIZE / 2);
    			COLORMAP_RED = (unsigned char*)malloc(COLORMAPSIZE / 2);
    			COLORMAP_GREEN = (unsigned char*)malloc(COLORMAPSIZE / 2);
    			COLORMAP_BLUE = (unsigned char*)malloc(COLORMAPSIZE / 2);
    			int j = COLORMAPSIZE / 2;
    			for (int i = 0; i < COLORMAPSIZE;)
    			{
    				COLORMAP_ALPHA[j] = COLORMAP[i + 1] & 0b10000000;
    				COLORMAP_RED[j] = (COLORMAP[i + 1] & 0b01111100) << 1;
    				COLORMAP_GREEN[j] = ((COLORMAP[i + 1] & 0b00000011) << 6) | ((COLORMAP[i] & 0b11100000) >> 2);
    				COLORMAP_BLUE[j] = (COLORMAP[i] & 0b00011111) << 3;
    				i += 2;
    				j--;
    			}
    			if (fread(DATA, sizeof(unsigned char), DataSize, TGA) == 0)
    			{
    				cout << "Failed to read the data into the buffer!" << endl;
    			}
    			else
    			{
    				cout << "Successfully read in the data into the buffer." << endl;
    			}
    			int bytesperpixel = 0;
    			bytesperpixel = bitsperpixel / 8;
    			int k = DataSize / bytesperpixel;
    			for (int i = 0; i < DataSize;)
    			{
    				if (bytesperpixel == 2)
    				{
    					for (int j = 0; j < COLORMAPSIZE; j++)
    					{
    						if (j == ((DATA[i] & 0b11111111 << 8) + DATA[i + 1]))
    						{
    							ALPHA[k - i / 2] = COLORMAP_ALPHA[j];
    							RED[k - i / 2] = COLORMAP_RED[j];
    							GREEN[k - i / 2] = COLORMAP_GREEN[j];
    							BLUE[k - i / 2] = COLORMAP_BLUE[j];
    							i += 2;
    							k--;
    						}
    					}
    				}
    				if (bytesperpixel == 3)
    				{
    					for (int j = 0; j < COLORMAPSIZE; j++)
    					{
    						if (j == ((DATA[i] & 0b11111111 << 16) + (DATA[i + 1] & 0b11111111 << 8) + DATA[i + 2]))
    						{
    							ALPHA[k - i / 3] = COLORMAP_ALPHA[j];
    							RED[k - i / 3] = COLORMAP_RED[j];
    							GREEN[k - i / 3] = COLORMAP_GREEN[j];
    							BLUE[k - i / 3] = COLORMAP_BLUE[j];
    							i += 3;
    							k--;
    						}
    					}
    				}
    				if (bytesperpixel == 4)
    				{
    					for (int j = 0; j < COLORMAPSIZE; j++)
    					{
    						if (j == ((DATA[i] & 0b11111111 << 24) + (DATA[i + 1] & 0b11111111 << 16) + (DATA[i + 2] & 0b11111111 << 8) + DATA[i + 3]))
    						{
    							ALPHA[k - i / 4] = COLORMAP_ALPHA[j];
    							RED[k - i / 4] = COLORMAP_RED[j];
    							GREEN[k - i / 4] = COLORMAP_GREEN[j];
    							BLUE[k - i / 4] = COLORMAP_BLUE[j];
    							i += 4;
    							k--;
    						}
    					}
    				}
    			}
    			free(COLORMAP_ALPHA);
    			free(COLORMAP_RED);
    			free(COLORMAP_GREEN);
    			free(COLORMAP_BLUE);		
    		}
    		else if (COLORMAPSIZE = 24)
    		{
    			unsigned char* COLORMAP_RED = NULL;
    			unsigned char* COLORMAP_GREEN = NULL;
    			unsigned char* COLORMAP_BLUE = NULL;
    			COLORMAP_RED = (unsigned char*)malloc(COLORMAPSIZE / 3);
    			COLORMAP_GREEN = (unsigned char*)malloc(COLORMAPSIZE / 3);
    			COLORMAP_BLUE = (unsigned char*)malloc(COLORMAPSIZE / 3);
    			int j = COLORMAPSIZE / 3;
    			for (int i = 0; i < COLORMAPSIZE;)
    			{
    				COLORMAP_RED[j] = COLORMAP[i + 2];
    				COLORMAP_GREEN[j] = COLORMAP[i + 1];
    				COLORMAP_BLUE[j] = COLORMAP[i];
    				i += 3;
    				j--;
    			}
    			if (fread(DATA, sizeof(unsigned char), DataSize, TGA) == 0)
    			{
    				cout << "Failed to read the data into the buffer!" << endl;
    			}
    			else
    			{
    				cout << "Successfully read in the data into the buffer." << endl;
    			}
    			int bytesperpixel = 0;
    			bytesperpixel = bitsperpixel / 8;
    			int k = DataSize / bytesperpixel;
    			for (int i = 0; i < DataSize;)
    			{
    				if (bytesperpixel == 2)
    				{
    					for (int j = 0; j < COLORMAPSIZE; j++)
    					{
    						if (j == ((DATA[i] & 0b11111111 << 8) + DATA[i + 1]))
    						{
    							RED[k - i / 2] = COLORMAP_RED[j];
    							GREEN[k - i / 2] = COLORMAP_GREEN[j];
    							BLUE[k - i / 2] = COLORMAP_BLUE[j];
    							i += 2;
    							k--;
    						}
    					}
    				}
    				if (bytesperpixel == 3)
    				{
    					for (int j = 0; j < COLORMAPSIZE; j++)
    					{
    						if (j == ((DATA[i] & 0b11111111 << 16) + (DATA[i + 1] & 0b11111111 << 8) + DATA[i + 2]))
    						{
    							RED[k - i / 3] = COLORMAP_RED[j];
    							GREEN[k - i / 3] = COLORMAP_GREEN[j];
    							BLUE[k - i / 3] = COLORMAP_BLUE[j];
    							i += 3;
    							k--;
    						}
    					}
    				}
    				if (bytesperpixel == 4)
    				{
    					for (int j = 0; j < COLORMAPSIZE; j++)
    					{
    						if (j == ((DATA[i] & 0b11111111 << 24) + (DATA[i + 1] & 0b11111111 << 16) + (DATA[i + 2] & 0b11111111 << 8) + DATA[i + 3]))
    						{
    							RED[k - i / 4] = COLORMAP_RED[j];
    							GREEN[k - i / 4] = COLORMAP_GREEN[j];
    							BLUE[k - i / 4] = COLORMAP_BLUE[j];
    							i += 4;
    							k--;
    						}
    					}
    				}
    			}
    			free(COLORMAP_RED);
    			free(COLORMAP_GREEN);
    			free(COLORMAP_BLUE);
    		}
    		else if (COLORMAPSIZE = 32)
    		{
    		    unsigned char* COLORMAP_ALPHA = NULL;
    		    unsigned char* COLORMAP_RED = NULL;
    		    unsigned char* COLORMAP_GREEN = NULL;
    		    unsigned char* COLORMAP_BLUE = NULL;
    		    COLORMAP_ALPHA = (unsigned char*)malloc(COLORMAPSIZE / 2);
    		    COLORMAP_RED = (unsigned char*)malloc(COLORMAPSIZE / 2);
    		    COLORMAP_GREEN = (unsigned char*)malloc(COLORMAPSIZE / 2);
    		    COLORMAP_BLUE = (unsigned char*)malloc(COLORMAPSIZE / 2);
    		    int j = COLORMAPSIZE / 4;
    		    for (int i = 0; i < COLORMAPSIZE;)
    		    {
    			    COLORMAP_ALPHA[j] = COLORMAP[i + 3];
    			    COLORMAP_RED[j] = COLORMAP[i + 2];
    			    COLORMAP_GREEN[j] = COLORMAP[i + 1];
    			    COLORMAP_BLUE[j] = COLORMAP[i];
    			    i += 3;
    			    j--;
    		    }
    		    if (fread(DATA, sizeof(unsigned char), DataSize, TGA) == 0)
    		    {
    			    cout << "Failed to read the data into the buffer!" << endl;
    		    }
    		    else
    		    {
    			    cout << "Successfully read in the data into the buffer." << endl;
    		    } 
    		    int bytesperpixel = 0;
    		    bytesperpixel = bitsperpixel / 8;
    		    int k = DataSize / bytesperpixel;
    		    for (int i = 0; i < DataSize;)
    		    {
    			if (bytesperpixel == 2)
    			{
    				for (int j = 0; j < COLORMAPSIZE; j++)
    				{
    					if (j == ((DATA[i] & 0b11111111 << 8) + DATA[i + 1]))
    					{
    						ALPHA[k - i / 2] = COLORMAP_ALPHA[j];
    						RED[k - i / 2] = COLORMAP_RED[j];
    						GREEN[k - i / 2] = COLORMAP_GREEN[j];
    						BLUE[k - i / 2] = COLORMAP_BLUE[j];
    						i += 2;
    						k--;
    					}
    				}
    			}
    			if (bytesperpixel == 3)
    			{
    				for (int j = 0; j < COLORMAPSIZE; j++)
    				{
    					if (j == ((DATA[i] & 0b11111111 << 16) + (DATA[i + 1] & 0b11111111 << 8) + DATA[i + 2]))
    					{
    						ALPHA[k - i / 3] = COLORMAP_ALPHA[j];
    						RED[k - i / 3] = COLORMAP_RED[j];
    						GREEN[k - i / 3] = COLORMAP_GREEN[j];
    						BLUE[k - i / 3] = COLORMAP_BLUE[j];
    						i += 3;
    						k--;
    					}
    				}
    			}
    			if (bytesperpixel == 4)
    			{
    				for (int j = 0; j < COLORMAPSIZE; j++)
    				{
    					if (j == ((DATA[i] & 0b11111111 << 24) + (DATA[i + 1] & 0b11111111 << 16) + (DATA[i + 2] & 0b11111111 << 8) + DATA[i + 3]))
    					{
    						ALPHA[k - i / 4] = COLORMAP_ALPHA[j];
    						RED[k - i / 4] = COLORMAP_RED[j];
    						GREEN[k - i / 4] = COLORMAP_GREEN[j];
    						BLUE[k - i / 4] = COLORMAP_BLUE[j];
    						i += 4;
    						k--;
    					}
    				}
    			}
    		}
    		free(COLORMAP_ALPHA);
    		free(COLORMAP_RED);
    		free(COLORMAP_GREEN);
    		free(COLORMAP_BLUE);
            }
    		else
    		{
    			cout << "This colormap is too special.This program cannot analyse this picture!" << endl;
    		}
    
    	}
    	else
    	{
    		cout << "this program cannot analyse this picture!" << endl;
    	}
    
    	fwrite(BLUE, sizeof(unsigned char),width*height, RGB);
    	fwrite(GREEN, sizeof(unsigned char), width* height, RGB);
    	fwrite(RED, sizeof(unsigned char), width* height, RGB);
    	RGBtoYUV(width, height, width* height * 3, RED, GREEN, BLUE);
    	/*free(DATA);
    	free(RED);
    	free(ALPHA);
    	free(GREEN);
    	free(BLUE);*/
    }
    

    六、实验结果:
    (1)像素深度为16:
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    (2)像素深度为24:
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    (3)像素深度为32:
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • Java zip压缩包查看程序源码 1个目标文件 摘要:Java源码,文件操作,压缩包查看 Java zip压缩包查看程序,应用弹出文件选择框,选择ZIP格式的压缩文件,可以像Winrar软件一样查看压缩文件内部的文件及文件夹,源码...
  • Java zip压缩包查看程序源码 1个目标文件 摘要:Java源码,文件操作,压缩包查看 Java zip压缩包查看程序,应用弹出文件选择框,选择ZIP格式的压缩文件,可以像Winrar软件一样查看压缩文件内部的文件及文件夹,源码...
  • 利用SVG制作名字画板

    2019-07-03 20:55:59
    其他图像格式都是基于像素处理,SVG 则是属于图像的形状描述,所以它本质上是文本文件,体积较小,且不管放大多少倍都不会失真。 需要用到: js ,动态地为元素添加样式; css3 ,我们需要css的动画属性; 一...
  • 学习笔记

    2017-05-02 20:38:00
    GIF:优点(动画存储格式),缺点(最多256色,画质差) PNG:优点(可保存透明背景图片),缺点(画质中等) JPG:优点(文件小,利于网络传输),缺点(画质损失) GIF GIF文件的数据,是一种基于LZW算法连续...
  • flash shiti

    2014-03-14 10:32:41
    12. 如果导入的是图像序列中的一个picture001.bmp 文件,并且序列中的其他文件位于相同的 文件夹中,则将被识别为图像序列将是下面哪些: □ A. picture001.bmp □ B. picture002.bmp □ C. picture003.bmp □ D. ...
  • HTML学习笔记chap3

    2018-09-18 17:36:58
    图片格式 ...保存为一个图像,从而变为动画,所以仍属于图文文件格式。 3.PNG支持透明效果,通常应用于Java、S60或网页中 插入图片 1.插入图片标记为img标签,相关定义属性如下: src:图片...
  • 主要内容有C#开发环境使用、C#语言基础应用、字符串处理技术、数组和集合使用、面向对象编程...文件、C#与Word互操作、高效应用Excel、基本图形绘制、图像处理技术、常用图表应用、动画处理技术、音频与视频控制...
  • 3.4 日期时间格式的数据处理 67 实例053 动态获得系统当前日期和时间 67 实例054 手动设置系统日期时间 69 实例055 根据生日自动计算员工年龄 70 实例056 根据年份判断十二生肖 71 实例057 获取当前日期是星期几 72 ...
  • 实例235 在RichTextBox控件中显示RTF格式的文件 实例236 使用RichTextBox控件保存文件 实例237 为RichTextBox控件添加自定义滚动条 实例238 在RichTextBox控件中实现关键字描红 实例239 在RichTextBox控件中...
  • 实例235 在RichTextBox控件中显示RTF格式的文件 实例236 使用RichTextBox控件保存文件 实例237 为RichTextBox控件添加自定义滚动条 实例238 在RichTextBox控件中实现关键字描红 实例239 在RichTextBox控件中...
  • 实例235 在RichTextBox控件中显示RTF格式的文件 实例236 使用RichTextBox控件保存文件 实例237 为RichTextBox控件添加自定义滚动条 实例238 在RichTextBox控件中实现关键字描红 实例239 在RichTextBox控件中...
  • 本书是第I卷,以开发人员在项目开发中经常遇到问题和必须掌握技术为中心,介绍了应用Visual C++进行程序开发各个方面知识和技巧,主要包括编程基础、界面设计、应用程序控制和图形图像。全书分4篇15章,共计...
  • 本书是第I卷,以开发人员在项目开发中经常遇到问题和必须掌握技术为中心,介绍了应用Visual C++进行程序开发各个方面知识和技巧,主要包括编程基础、界面设计、应用程序控制和图形图像。全书分4篇15章,共计...
  • java源码包---java 源码 大量 实例

    千次下载 热门讨论 2013-04-18 23:15:26
     Java zip压缩包查看程序,应用弹出文件选择框,选择ZIP格式的压缩文件,可以像Winrar软件一样查看压缩文件内部的文件及文件夹,源码截图如上所示。 Java 数字签名、数字证书生成源码 2个目标文件 摘要:JAVA源码,...
  • Java zip压缩包查看程序源码 1个目标文件 摘要:Java源码,文件操作,压缩包查看 Java zip压缩包查看程序,应用弹出文件选择框,选择ZIP格式的压缩文件,可以像Winrar软件一样查看压缩文件内部的文件及文件夹,源码...
  • JAVA上百实例源码以及开源项目

    千次下载 热门讨论 2016-01-03 17:37:40
     Java zip压缩包查看程序,应用弹出文件选择框,选择ZIP格式的压缩文件,可以像Winrar软件一样查看压缩文件内部的文件及文件夹,源码截图如上所示。 Java 数字签名、数字证书生成源码 2个目标文件 摘要:JAVA源码,...
  • java源码包2

    千次下载 热门讨论 2013-04-20 11:28:17
     Java zip压缩包查看程序,应用弹出文件选择框,选择ZIP格式的压缩文件,可以像Winrar软件一样查看压缩文件内部的文件及文件夹,源码截图如上所示。 Java 数字签名、数字证书生成源码 2个目标文件 摘要:JAVA源码...
  • 精灵图实际上是将所有帧图片放在一个文件中,游戏时靠一个RECT来控制画图像文件哪一部分,进而控制游戏显示哪一帧图,只需控制好RECT位置即可。如下图: 控制RECT四个角坐标移动,有以下代码: ...
  • java源码包3

    千次下载 热门讨论 2013-04-20 11:30:13
     Java zip压缩包查看程序,应用弹出文件选择框,选择ZIP格式的压缩文件,可以像Winrar软件一样查看压缩文件内部的文件及文件夹,源码截图如上所示。 Java 数字签名、数字证书生成源码 2个目标文件 摘要:JAVA源码...
  • libarchive:多格式的存档和压缩库。 LZ4 :非常快速的压缩算法。 LZFSE:LZFSE压缩库和命令行工具。 LZHAM :无损压缩数据库,压缩比率跟LZMA接近,但是解压缩速度却要快得多。 LZMA :7z格式默认和通用的压缩...
  • java源码包

    2015-12-01 16:29:37
     Java zip压缩包查看程序,应用弹出文件选择框,选择ZIP格式的压缩文件,可以像Winrar软件一样查看压缩文件内部的文件及文件夹,源码截图如上所示。 Java 数字签名、数字证书生成源码 2个目标文件 摘要:JAVA源码,...
  • 手机 pdf 阅读器

    2009-02-12 23:00:29
    修正umd格式的文件在历史中显示图标为TXT的bug 阅读TXT时,触屏用户也可以在菜单中使用“反色”的功能了 [2007.10.28] Ver:3.1.22 修正在在UIQ、S60机器上运行缓慢的bug [2007.10.22] Ver:3.1.21 修正在部分MOTO-...
  • Microsoft C# Windows程序设计(上下册)

    热门讨论 2011-08-05 10:28:13
    11.2 位图文件格式 11.3 加载和绘制 11.4 图像信息 11.5 绘制图像 11.6 匹配矩形 11.7 旋转和剪切 11.8 显示部分图像 11.9 在图像上绘制 11.10 关于image类更多内容 11.11 bitmap类 11.12 ...
  • unoconv:在 LibreOffice/OpenOffice 支持任意文件格式之间进行转换。 XlsxWriter:一个用于创建 Excel .xlsx 文件 Python 模块。 xlwings:一个使得在 Excel 中方便调用 Python 库(反之亦然),基于 BSD ...
  • 实例020 Dreamweaver中编码格式的选择 35 实例021 Dreamweaver中创建表格 36 实例022 在表格中插入宠物照片 38 实例023 Dreamweaver创建表单 40 实例024 Dreamweaver中创建和附加CSS样式 42 实例025 Dreamweaver控制...

空空如也

空空如也

1 2 3
收藏数 41
精华内容 16
关键字:

属于动画图像文件格式的是