解析 SUM 光栅文件图象（RAS文件）代码,CSharp代码库,德仔网

代码语言
代码分类
【CSharp】解析 SUM 光栅文件图象（RAS文件）
作者:zgke / 发布于2014/7/29/ 555
只实现了24位色和8位色这个结构也太简单了。只有文件头和数据区。就是8位色的色彩表有些特殊先是红色表绿色表蓝色表平时都是 RGB、RGB 这样放这东西居然RRRR.....GGG......B....

	using System;
	using System.Collections.Generic;
	using System.Text;
	using System.Runtime.InteropServices;
	using System.Drawing.Imaging;
	using System.Drawing;
	using System.IO;

	namespace Zgke.MyImage.ImageFile
	{
	 /// <summary>
	 /// SUN光栅图形 RAS
	 /// zgke@sina.com
	 /// qq:116149
	 /// </summary>
	 public class ImageRas
	 {
	 public ImageRas(string p_ImageFile)
	 {
	 if (System.IO.File.Exists(p_ImageFile))
	 {
	 LoadImage(System.IO.File.ReadAllBytes(p_ImageFile));
	 }
	 }

	 public ImageRas()
	 {
	 }

	 #region 私有
	 /// <summary>
	 /// 文件头 956AA659
	 /// </summary>
	 private uint m_Mageic = 0x956AA659;

	 /// <summary>
	 /// 宽
	 /// </summary>
	 private uint m_Width = 0;

	 /// <summary>
	 /// 高
	 /// </summary>
	 private uint m_Height = 0;

	 /// <summary>
	 /// 颜色深
	 /// </summary>
	 private uint m_Depth = 0;

	 /// <summary>
	 /// 图形区域数据大小
	 /// </summary>
	 private uint m_Length = 0;

	 /// <summary>
	 /// 数据类型
	 /// </summary>
	 private uint m_Type = 0;

	 /// <summary>
	 /// 色彩图形类型
	 /// </summary>
	 private uint m_MapType = 0;

	 /// <summary>
	 /// 色彩长度
	 /// </summary>
	 private uint m_MapLength = 0;

	 /// <summary>
	 /// 颜色表
	 /// </summary>
	 private Color[] m_ColorList = new Color[256];

	 /// <summary>
	 /// 图形
	 /// </summary>
	 private Bitmap m_Image;
	 #endregion

	 /// <summary>
	 /// 获取图形
	 /// </summary>
	 public Bitmap Image
	 {
	 get
	 {
	 return m_Image;
	 }
	 set
	 {
	 if (value != null)
	 {
	 m_Image = value;
	 m_Width = (uint)value.Width;
	 m_Height = (uint)value.Height;
	 switch (value.PixelFormat)
	 {
	 case PixelFormat.Format8bppIndexed:

	 break;
	 case PixelFormat.Format32bppArgb:

	 break;
	 default:
	 m_Depth = 24;
	 break;
	 }
	 }
	 }
	 }

	 /// <summary>
	 /// 获取数据
	 /// </summary>
	 /// <param name="p_ImageBytes"></param>
	 private void LoadImage(byte[] p_ImageBytes)
	 {
	 if (BitConverter.ToUInt32(p_ImageBytes, 0) != m_Mageic) throw new Exception("文件头不正确！");
	 m_Width = BytesToUint(p_ImageBytes, 4);
	 m_Height = BytesToUint(p_ImageBytes, 8);
	 m_Depth = BytesToUint(p_ImageBytes, 12);
	 m_Length = BytesToUint(p_ImageBytes, 16);
	 m_Type = BytesToUint(p_ImageBytes, 20);
	 m_MapType = BytesToUint(p_ImageBytes, 24);
	 m_MapLength = BytesToUint(p_ImageBytes, 28);
	 int _StarIndex = 32;
	 switch (m_MapType)
	 {

	 case 1:
	 int _ColorTable = (int)m_MapLength / 3;
	 for (int i = 0; i != _ColorTable; i++)
	 {
	 m_ColorList[i] = Color.FromArgb(p_ImageBytes[_StarIndex], p_ImageBytes[_StarIndex + _ColorTable], p_ImageBytes[_StarIndex + (_ColorTable * 2)]);
	 _StarIndex++;
	 }
	 _StarIndex += _ColorTable * 2;
	 break;
	 default:
	 break;
	 }

	 LoadData(p_ImageBytes, _StarIndex);
	 }

	 /// <summary>
	 /// 字节转换为UINT
	 /// </summary>
	 /// <param name="p_Value">字节数组</param>
	 /// <param name="p_Index">开始位置</param>
	 /// <returns></returns>
	 private uint BytesToUint(byte[] p_Value, int p_Index)
	 {
	 byte[] _ValueBytes = new byte[4];
	 _ValueBytes[0] = p_Value[p_Index + 3];
	 _ValueBytes[1] = p_Value[p_Index + 2];
	 _ValueBytes[2] = p_Value[p_Index + 1];
	 _ValueBytes[3] = p_Value[p_Index];
	 return BitConverter.ToUInt32(_ValueBytes, 0);
	 }

	 /// <summary>
	 /// 获取反转的BYTES
	 /// </summary>
	 /// <param name="p_Value"></param>
	 /// <returns></returns>
	 private byte[] UintToBytes(uint p_Value)
	 {
	 byte[] _ValueBytes = BitConverter.GetBytes(p_Value);
	 Array.Reverse(_ValueBytes);
	 return _ValueBytes;
	 }

	 /// <summary>
	 /// 获取图形数据
	 /// </summary>
	 /// <param name="p_ValueBytes">文件留</param>
	 /// <param name="p_StarIndex">RGB留开始位置</param>
	 private void LoadData(byte[] p_ValueBytes, int p_StarIndex)
	 {
	 PixelFormat _Format = PixelFormat.Format24bppRgb;
	 switch (m_Depth)
	 {
	 case 8:
	 _Format = PixelFormat.Format8bppIndexed;
	 break;
	 case 24:
	 _Format = PixelFormat.Format24bppRgb;
	 break;
	 default:
	 throw new Exception("未实现！");

	 }
	 m_Image = new Bitmap((int)m_Width, (int)m_Height, _Format);
	 BitmapData _Data = m_Image.LockBits(new Rectangle(0, 0, m_Image.Width, m_Image.Height), ImageLockMode.ReadWrite, m_Image.PixelFormat);
	 byte[] _WriteBytes = new byte[_Data.Height * _Data.Stride];
	 int _StarIndex = 0;
	 int _WriteIndex = 0;

	 for (int i = 0; i != _Data.Height; i++)
	 {
	 _WriteIndex = i * _Data.Stride;
	 _StarIndex = i * ((int)m_Length / (int)m_Height) + p_StarIndex;
	 for (int z = 0; z != _Data.Width; z++)
	 {
	 switch (m_Depth)
	 {
	 case 8:
	 _WriteBytes[_WriteIndex] = p_ValueBytes[_StarIndex];
	 _WriteIndex++;
	 _StarIndex++;
	 break;
	 case 24:
	 _WriteBytes[_WriteIndex] = p_ValueBytes[_StarIndex + 2];
	 _WriteBytes[_WriteIndex + 1] = p_ValueBytes[_StarIndex + 1];
	 _WriteBytes[_WriteIndex + 2] = p_ValueBytes[_StarIndex];
	 _WriteIndex += 3;
	 _StarIndex += 3;
	 break;
	 }
	 }
	 }

	 switch (m_Depth)
	 {
	 case 8:
	 ColorPalette _Palette = m_Image.Palette;
	 for (int i = 0; i != m_ColorList.Length; i++)
	 {
	 _Palette.Entries[i] = m_ColorList[i];
	 }
	 m_Image.Palette = _Palette;
	 break;
	 default:
	 break;
	 }

	
	 Marshal.Copy(_WriteBytes, 0, _Data.Scan0, _WriteBytes.Length);
	 m_Image.UnlockBits(_Data);

	 }

	 /// <summary>
	 /// 保存图形
	 /// </summary>
	 /// <returns></returns>
	 private byte[] SaveImageOfRas()
	 {
	 if (m_Image == null) return new byte[0];
	 MemoryStream _Stream = new MemoryStream();
	 _Stream.Write(BitConverter.GetBytes(m_Mageic), 0, 4);
	 _Stream.Write(UintToBytes(m_Width), 0, 4);
	 _Stream.Write(UintToBytes(m_Height), 0, 4);

	 switch (m_Depth)
	 {
	 case 8:
	 BitmapData _Data256 = m_Image.LockBits(new Rectangle(0, 0, m_Image.Width, m_Image.Height), ImageLockMode.ReadOnly, m_Image.PixelFormat);
	 byte[] _DataBytes = new byte[_Data256.Stride * _Data256.Height];
	 int _Stride = _Data256.Stride;
	 Marshal.Copy(_Data256.Scan0, _DataBytes, 0, _DataBytes.Length);
	 m_Image.UnlockBits(_Data256);

	 _Stream.Write(UintToBytes(8), 0, 4);
	 uint _WidthCount = (uint)m_Image.Width;
	 if (m_Image.Width % 2 != 0) _WidthCount = (uint)m_Image.Width + 1;
	 uint _AllCount = _WidthCount * (uint)m_Image.Height;
	 _Stream.Write(UintToBytes(_AllCount), 0, 4);
	 _Stream.Write(UintToBytes(0), 0, 4);
	 _Stream.Write(UintToBytes(1), 0, 4);
	 _Stream.Write(UintToBytes(768), 0, 4);
	 byte[] _RedBytes = new byte[256];
	 byte[] _GreenBytes = new byte[256];
	 byte[] _BlueBytes = new byte[256];
	 for (int i = 0; i != 256; i++)
	 {
	 _RedBytes[i] = m_Image.Palette.Entries[i].R;
	 _GreenBytes[i] = m_Image.Palette.Entries[i].G;
	 _BlueBytes[i] = m_Image.Palette.Entries[i].B;
	 }
	 _Stream.Write(_RedBytes, 0, _RedBytes.Length);
	 _Stream.Write(_GreenBytes, 0, _GreenBytes.Length);
	 _Stream.Write(_BlueBytes, 0, _BlueBytes.Length);
	 byte[] _Write = new byte[_WidthCount];
	 for (int i = 0; i != m_Image.Height; i++)
	 {
	 Array.Copy(_DataBytes, i * _Stride, _Write, 0, _WidthCount);
	 _Stream.Write(_Write, 0, _Write.Length);
	 }
	 break;
	 default:
	 Bitmap _NewBitmap = new Bitmap(m_Image.Width, m_Image.Height, PixelFormat.Format24bppRgb);
	 Graphics _Graphics = Graphics.FromImage(_NewBitmap);
	 _Graphics.DrawImage(m_Image, new Rectangle(0, 0, m_Image.Width, m_Image.Height));
	 _Graphics.Dispose();
	 BitmapData _Data24 = _NewBitmap.LockBits(new Rectangle(0, 0, _NewBitmap.Width, _NewBitmap.Height), ImageLockMode.ReadOnly, _NewBitmap.PixelFormat);
	 byte[] _DataBytes24 = new byte[_Data24.Stride * _Data24.Height];
	 int _Stride24 = _Data24.Stride;
	 Marshal.Copy(_Data24.Scan0, _DataBytes24, 0, _DataBytes24.Length);
	 _NewBitmap.UnlockBits(_Data24);

	 _Stream.Write(UintToBytes(24), 0, 4);
	 uint _WidthCount24 = (uint)_NewBitmap.Width;
	 if (_NewBitmap.Width % 2 != 0) _WidthCount24 = (uint)_NewBitmap.Width + 1;
	 uint _AllCount24 = _WidthCount24 * (uint)_NewBitmap.Height * 3;
	 _WidthCount24 = _WidthCount24 * 3;
	 _Stream.Write(UintToBytes(_AllCount24), 0, 4);
	 _Stream.Write(UintToBytes(0), 0, 4);
	 _Stream.Write(UintToBytes(0), 0, 4);
	 _Stream.Write(UintToBytes(0), 0, 4);
	 byte[] _Write24 = new byte[0];
	 for (int i = 0; i != m_Image.Height; i++)
	 {
	 _Write24 = new byte[_WidthCount24];
	 int _WriteIndex = 0;
	 int _StarIndex = i * _Stride24;
	 for (int z = 0; z != m_Image.Width; z++)
	 {
	 _Write24[_WriteIndex] = _DataBytes24[_StarIndex + 2];
	 _Write24[_WriteIndex + 1] = _DataBytes24[_StarIndex + 1];
	 _Write24[_WriteIndex + 2] = _DataBytes24[_StarIndex];
	 _WriteIndex += 3;
	 _StarIndex += 3;
	 }

	 _Stream.Write(_Write24, 0, _Write24.Length);
	 }
	 _NewBitmap.Dispose();
	 break;
	 }

	
	 byte[] _Return = _Stream.ToArray();
	 return _Return;
	 }

	 /// <summary>
	 /// 保存图形到RAS文件
	 /// </summary>
	 /// <param name="p_File"></param>
	 public void SaveRas(string p_File)
	 {
	 byte[] _Value = SaveImageOfRas();
	 if (_Value.Length != 0) File.WriteAllBytes(p_File, _Value);

	 }
	 }
	}
试试其它关键字
　SUM　　RAS　　光栅文件　
同语言下
可能有用的
zgke贡献的其它代码(46)