/// <summary> /// </summary> /// <param name="header"> /// </param> /// <param name="palettes"> /// </param> /// <param name="pixel_data"> /// </param> /// <param name="y_start"> /// </param> /// <param name="y_step"> /// </param> /// <param name="y_end"> /// </param> /// <param name="x_start"> /// </param> /// <param name="x_step"> /// </param> /// <param name="x_end"> /// </param> /// <returns> /// </returns> private static byte[] _getImageDataGrey8bits( TGAHeader header, byte[] palettes, byte[] pixel_data, int y_start, int y_step, int y_end, int x_start, int x_step, int x_end) { var image = pixel_data; var width = header.width; var height = header.height; byte color; var i = 0; int x; int y; var imageData = new byte[width * height * 4]; for (y = y_start; y != y_end; y += y_step) { for (x = x_start; x != x_end; x += x_step, i++) { color = image[i]; imageData[(x + width * y) * 4 + 0] = color; imageData[(x + width * y) * 4 + 1] = color; imageData[(x + width * y) * 4 + 2] = color; imageData[(x + width * y) * 4 + 3] = 255; } } return(imageData); }
/// <summary> /// 指定データから作成 /// </summary> /// <param name="header">TGAヘッダー</param> /// <param name="pImage">イメージデータ</param> /// <param name="pPalette">パレットデータ</param> /// <returns>RESULTタイプ</returns> public RESULT Create(TGAHeader header, byte[] pImage, byte[] pPalette) { // 引数チェック if (pImage == null || header.getImageSize() == 0) { return(RESULT.ERROR_IMAGE); } if (pPalette != null && header.getPaletteSize() == 0) { return(RESULT.ERROR_PALETTE); } if (pPalette == null && header.getPaletteSize() != 0) { return(RESULT.ERROR_PALETTE); } // ヘッダーチェック if (!CheckSupport(header)) { return(RESULT.ERROR_HEADER); } // 情報の設定 this.CalcSize(false); return(RESULT.ERROR_NONE); }
/// <summary> /// Function to write out the DDS header to the stream. /// </summary> /// <param name="settings">Meta data for the image header.</param> /// <param name="writer">Writer interface for the stream.</param> /// <param name="conversionFlags">Flags for image conversion.</param> private void WriteHeader(IImageSettings settings, GorgonBinaryWriter writer, out TGAConversionFlags conversionFlags) { TGAHeader header = default(TGAHeader); conversionFlags = TGAConversionFlags.None; if ((settings.Width > 0xFFFF) || (settings.Height > 0xFFFF)) { throw new IOException(string.Format(Resources.GORGFX_IMAGE_FILE_INCORRECT_ENCODER, Codec)); } header.Width = (ushort)(settings.Width); header.Height = (ushort)(settings.Height); switch (settings.Format) { case BufferFormat.R8G8B8A8_UIntNormal: case BufferFormat.R8G8B8A8_UIntNormal_sRGB: header.ImageType = TGAImageType.TrueColor; header.BPP = 32; header.Descriptor = TGADescriptor.InvertY | TGADescriptor.RGB888A8; conversionFlags |= TGAConversionFlags.Swizzle; break; case BufferFormat.B8G8R8A8_UIntNormal: case BufferFormat.B8G8R8A8_UIntNormal_sRGB: header.ImageType = TGAImageType.TrueColor; header.BPP = 32; header.Descriptor = TGADescriptor.InvertY | TGADescriptor.RGB888A8; break; case BufferFormat.B8G8R8X8_UIntNormal: case BufferFormat.B8G8R8X8_UIntNormal_sRGB: header.ImageType = TGAImageType.TrueColor; header.BPP = 24; header.Descriptor = TGADescriptor.InvertY; conversionFlags |= TGAConversionFlags.RGB888; break; case BufferFormat.R8_UIntNormal: case BufferFormat.A8_UIntNormal: header.ImageType = TGAImageType.BlackAndWhite; header.BPP = 8; header.Descriptor = TGADescriptor.InvertY; break; case BufferFormat.B5G5R5A1_UIntNormal: header.ImageType = TGAImageType.TrueColor; header.BPP = 16; header.Descriptor = TGADescriptor.InvertY | TGADescriptor.RGB555A1; break; default: throw new IOException(string.Format(Resources.GORGFX_FORMAT_NOT_SUPPORTED, settings.Format)); } // Persist to stream. writer.WriteValue(header); }
private void ExportUVTGA(string path = "") { bool ok = !(path == ""); SaveFileDialog FileDialog1 = new SaveFileDialog(); FileDialog1.Filter = "TGA Files(*.tga)|*.tga"; if (ok || FileDialog1.ShowDialog() == DialogResult.OK) { if (!ok) { path = FileDialog1.FileName; } FileStream fs = new FileStream(path, FileMode.Create, FileAccess.Write); TGA = CreateHeaderTGA(); TGA.width = (short)ImageSizeX; TGA.height = (short)ImageSizeY; TGA.bits = 32; TGA.descriptor = 32; byte[] buff = StructureToByteArray(TGA); fs.Write(buff, 0, buff.Length); for (int i = 0; i < memsize / 2; i++) { fs.WriteByte(255); fs.WriteByte(memory[i * 2]); fs.WriteByte(memory[i * 2 + 1]); fs.WriteByte(255); } fs.Close(); if (!ok) { MessageBox.Show("Done"); } } }
/// <summary> /// Writes the image as a text file /// </summary> /// <param name="path">The place the file is going to go</param> /// <param name="rle">Whether or not is being compressed</param> /// <returns></returns> public bool WriteToFile(string path, bool rle = true) { var bpp = (int)Format; using (var writer = new BinaryWriter(File.Create(path))) { var header = new TGAHeader { IdLength = 0, // The IDLength set to 0 indicates that there is no image identification field in the TGA file ColorMapType = 0, // a value of 0 indicates that no palette is included BitsPerPixel = (byte)(bpp * 8), Width = (short)Width, Height = (short)Height, DataTypeCode = DataTypeFor(bpp, rle), ImageDescriptor = (byte)(0x20 | (Format == Format.BGRA ? 8 : 0)) // top-left origin }; WriteTo(writer, header); if (!rle) { writer.Write(buffer); } else { UnloadRleData(writer); } } return(true); }
public static void Main(string[] args) { TGAHeader hdr; Pixel[] pix; //Read in tga file using (var ifile = new FileStream("in.tga", FileMode.Open)) { using (var bfile = new BinaryReader(ifile)) { hdr = new TGAHeader(bfile); pix = new Pixel[hdr.width * hdr.height]; byte[] tmp = new byte[pix.Length * 3]; bfile.Read(tmp, 0, tmp.Length); for (int i = 0, j = 0; i < pix.Length; ++i) { pix[i].b = tmp[j++]; pix[i].g = tmp[j++]; pix[i].r = tmp[j++]; } } } Console.WriteLine("Read TGA file"); //check tga header for bad data if (hdr.colorType != 0) { throw new Exception("Bad colorType"); } if (hdr.compression != 2) { throw new Exception("Can only use uncompressed input"); } if (hdr.bitsPerPixel != 24) { throw new Exception("Can only use BGR (24 bit)"); } if (hdr.descriptor != 0) { throw new Exception("Can only use BGR (descriptor 0)"); } //create empty byte list and compress to it var opix = new List <byte>(); compressIt(pix, opix, hdr); hdr.compression = 10; //File is compressed //Write out compressed tga file using (var ofile = new FileStream("out.tga", FileMode.Create)) { using (var bfile = new BinaryWriter(ofile)) { hdr.Write(bfile); byte[] tmp = new byte[opix.Count]; opix.CopyTo(tmp); bfile.Write(tmp); } } Console.WriteLine("Done"); }
/// <summary> /// </summary> /// <param name="header"> /// </param> /// <param name="palettes"> /// </param> /// <param name="pixel_data"> /// </param> /// <param name="y_start"> /// </param> /// <param name="y_step"> /// </param> /// <param name="y_end"> /// </param> /// <param name="x_start"> /// </param> /// <param name="x_step"> /// </param> /// <param name="x_end"> /// </param> /// <returns> /// </returns> private static byte[] _getImageData16bits( TGAHeader header, byte[] palettes, byte[] pixel_data, int y_start, int y_step, int y_end, int x_start, int x_step, int x_end) { var image = pixel_data; var width = header.width; var height = header.height; int color; var i = 0; int x; int y; var imageData = new byte[width * height * 4]; for (y = y_start; y != y_end; y += y_step) { for (x = x_start; x != x_end; x += x_step, i += 2) { color = image[i + 0] + (image[i + 1] >> 8); imageData[(x + width * y) * 4 + 0] = (byte)((color & 0x7C00) << 7); imageData[(x + width * y) * 4 + 1] = (byte)((color & 0x03E0) << 2); imageData[(x + width * y) * 4 + 2] = (byte)((color & 0x001F) << 3); imageData[(x + width * y) * 4 + 3] = (byte)(((color & 0x8000) > 0) ? 0 : 255); } } return(imageData); }
public TGAHeader CreateHeaderTGA() { TGAHeader temp = new TGAHeader(); temp.imagetype = 0x2; temp.bits = 0x18; return(temp); }
private MemoryStream ExportTGA() { MemoryStream m = new MemoryStream(); TGA = CreateHeaderTGA(); TGA.width = (short)ImageSizeX; TGA.height = (short)ImageSizeY; TGA.bits = 32; TGA.descriptor = 32; byte[] buff = StructureToByteArray(TGA); m.Write(buff, 0, buff.Length); m.Write(memory, 0, memsize); return(m); }
public static Color32[] ReadImage(TGAHeader header, byte[] data) { TGAImage image = new TGAImage(); TGAImageType imageType = header.imageType; if (imageType == TGAImageType.Uncompressed_TrueColor) { return ReadTrueColorImage(header, data); } if (imageType != TGAImageType.RTE_TrueColor) { Debug.Log("Image type of " + header.imageType.ToString() + " is not supported."); return null; } return ReadRTETrueColorImage(header, data); }
/// <summary> /// Writes the header information /// </summary> /// <param name="writer">Writer to use to write</param> /// <param name="header">The header</param> static void WriteTo(BinaryWriter writer, TGAHeader header) { writer.Write(header.IdLength); writer.Write(header.ColorMapType); writer.Write((byte)header.DataTypeCode); writer.Write(header.ColorMapOrigin); writer.Write(header.ColorMapLength); writer.Write(header.ColorMapDepth); writer.Write(header.OriginX); writer.Write(header.OriginY); writer.Write(header.Width); writer.Write(header.Height); writer.Write(header.BitsPerPixel); writer.Write(header.ImageDescriptor); }
/// <summary> /// Reads header from a TGA file /// </summary> /// <param name="reader">Type of reader</param> /// <returns>Header</returns> static TGAHeader ReadHeader(BinaryReader reader) { var header = new TGAHeader { IdLength = reader.ReadByte(), ColorMapType = reader.ReadByte(), DataTypeCode = (DataType)reader.ReadByte(), ColorMapOrigin = reader.ReadInt16(), ColorMapLength = reader.ReadInt16(), ColorMapDepth = reader.ReadByte(), OriginX = reader.ReadInt16(), OriginY = reader.ReadInt16(), Width = reader.ReadInt16(), Height = reader.ReadInt16(), BitsPerPixel = reader.ReadByte(), ImageDescriptor = reader.ReadByte() }; return(header); }
private MemoryStream ExportUVTGA() { MemoryStream m = new MemoryStream(); TGA = CreateHeaderTGA(); TGA.width = (short)ImageSizeX; TGA.height = (short)ImageSizeY; TGA.bits = 32; TGA.descriptor = 32; byte[] buff = StructureToByteArray(TGA); m.Write(buff, 0, buff.Length); for (int i = 0; i < memsize / 2; i++) { m.WriteByte(255); m.WriteByte(memory[i * 2]); m.WriteByte(memory[i * 2 + 1]); m.WriteByte(255); } return(m); }
/// <summary> /// </summary> /// <param name="data"> /// </param> /// <returns> /// </returns> public static TGAHeader GetTGAHeader(byte[] data) { var offset = 0; var header = new TGAHeader { id_length = data[offset++], colormap_type = data[offset++], image_type = data[offset++], colormap_index = data[offset++] | data[offset++] << 8, colormap_length = data[offset++] | data[offset++] << 8, colormap_size = data[offset++], origin = new Array <int>(data[offset++] | data[offset++] << 8, data[offset++] | data[offset++] << 8), width = data[offset++] | data[offset++] << 8, height = data[offset++] | data[offset++] << 8, pixel_size = data[offset++], flags = data[offset++] }; return(header); }
/**-------------------------------------------------------------------------- * 静的メソッド *--------------------------------------------------------------------------*/ /// <summary> /// 対応チェック /// </summary> /// <param name="header">TGAヘッダー構造体</param> /// <returns>true:サポートしている形式</returns> public static bool CheckSupport(TGAHeader header) { // 原点が0ではない? if (header.imageX != 0 && header.imageY != 0) { return(false); } // 対応していないイメージタイプ TYPE type = (TYPE)header.imageType; if (!((TYPE.IMAGE_TYPE_NONE < type && type < TYPE.IMAGE_TYPE_MAX) || (TYPE.IMAGE_TYPE_INDEX_RLE <= type && type <= TYPE.IMAGE_TYPE_RLE_MAX))) { return(false); } // 対応ビット? if (header.imageBit != 8 && header.imageBit != 16 && header.imageBit != 24 && header.imageBit != 32) { return(false); } // 対応パレット? if (header.usePalette == 1) { if (header.paletteIndex != 0) { return(false); } if (header.paletteBit != 24 && header.paletteBit != 32) { return(false); } } return(true); }
/// <summary> /// This function returns a value of type TGAHeader, it is assigned to the variable header in the function Image /// </summary> /// <param name="reader">passed into the function when called it is used to add data to the variable header</param> /// <returns name="header">variable declared in the function it is returned, contains data from reader variable that was added in </returns> static TGAHeader ReadHeader(BinaryReader reader) { /// <summary> /// header is set based on the data passed into the function from reader /// </summary> /// <value></value> var header = new TGAHeader { IdLength = reader.ReadByte(), ColorMapType = reader.ReadByte(), DataTypeCode = (DataType)reader.ReadByte(), ColorMapOrigin = reader.ReadInt16(), ColorMapLength = reader.ReadInt16(), ColorMapDepth = reader.ReadByte(), OriginX = reader.ReadInt16(), OriginY = reader.ReadInt16(), Width = reader.ReadInt16(), Height = reader.ReadInt16(), BitsPerPixel = reader.ReadByte(), ImageDescriptor = reader.ReadByte() }; return(header); }
//ipix = uncompressed data, opix = new data list to compress to static void compressIt(Pixel[] ipix, List <byte> opix, TGAHeader hdr) { //int ipixSize = ipix.Length; int maxSize = 0; List <List <byte> > rows = new List <List <byte> >(hdr.height); while (maxSize++ < hdr.height) { rows.Add(new List <byte>()); } Parallel.For(0, hdr.height, k => { //break up tasks by height of image List <byte> row = new List <byte>(); //this rows byte List int start = k * hdr.width; //get start index of ipix array int ipixSize = (k + 1) * hdr.width; //get ending index of ipix array int i, n; int[] repeats = new int[ipixSize]; for (i = ipixSize - 2; i >= 0; i--) //accumulate repeats of each pixel in ipix { if (ipix[i] == ipix[i + 1]) { repeats[i] = repeats[i + 1] + 1; } else { repeats[i] = 1; } } i = start; while (i < ipixSize) //Compress Image { int j = i; while (j < ipixSize && repeats[j] < 2) //find two identical pixels { j++; } while (i < j) { n = j - i; if (n > 128) { n = 128; } outputByte(n - 1, ref row); while (n-- > 0) { outputPixel(ipix[i++], ref row); } } if (i == ipixSize) //check at end, else guaranteed run of identical pixels { break; } n = repeats[i]; if (n > 128) { n = 128; } outputByte(0x80 + (n - 1), ref row); outputPixel(ipix[i], ref row); i += n; } rows[k] = row; }); foreach (List <byte> row in rows) { foreach (byte pix in row) { opix.Add(pix); } } }
protected void RGBA(TGAHeader tex, byte[] data) { Color32[] colorArray = TGAUtils.ReadImage(tex, data); int num = colorArray.Length * 4; this._data = new byte[num]; int index = 0; int num3 = 0; while (index < colorArray.Length) { this._data[num3++] = colorArray[index].r; this._data[num3++] = colorArray[index].g; this._data[num3++] = colorArray[index].b; this._data[num3++] = colorArray[index].a; index++; } }
private Color32[] ReadImage(TGAHeader header, byte[] data) { switch (header.imageType) { case TGAImageType.RTE_TrueColor: return ReadRTETrueColorImage(header, data); case TGAImageType.Uncompressed_TrueColor: return ReadTrueColorImage(header, data); default: Debug.Log("Image type of " + header.imageType.ToString() + " is not supported."); return null; } }
public bool ReadImage(FileInfo file) { byte[] data = File.ReadAllBytes(file.FullName); if (data == null) { Debug.LogError("TGA: data error"); return false; } if (data.Length < 18) { Debug.LogError("TGA invalid length of only " + data.Length + "bytes"); return false; } header = new TGAHeader(data); //Debug.Log(header.width + " " + header.height + " " + header.bpp + " " + header.imageType.ToString()); colorData = ReadImage(header, data); if (colorData == null) return false; return true; }
private Color32[] ReadTrueColorImage(TGAHeader header, byte[] data) { int bpp = header.pixelDepth / 8; bool hasAlpha = (bpp == 4); Color32[] colors = new Color32[header.width * header.height]; int index = 18; // initial offset int colorIndex = 0; Color32 pixelColor = new Color32(255, 255, 255, 255); for (int y = 0; y < header.height; y++) { for (int x = 0; x < header.width; x++) { if (hasAlpha) { pixelColor.b = data[index++]; pixelColor.g = data[index++]; pixelColor.r = data[index++]; pixelColor.a = data[index++]; } else { pixelColor.b = data[index++]; pixelColor.g = data[index++]; pixelColor.r = data[index++]; } colors[colorIndex++] = pixelColor; } } return colors; }
private Color32[] ReadRTETrueColorImage(TGAHeader header, byte[] data) { int bpp = header.pixelDepth / 8; bool hasAlpha = (bpp == 4); Color32[] colors = new Color32[header.width * header.height]; int index = 18; // initial offset int colorIndex = 0; Color32 pixelColor = new Color32(255, 255, 255, 255); byte pixelRun; byte i; while (colorIndex < header.nPixels) { pixelRun = data[index++]; if ((pixelRun & 128) != 0) { // this is a RLE packet so we need to remove the last bit (-128) and add one to the count to get the number of pixels pixelRun = (byte)((pixelRun - 128) + 1); if (hasAlpha) { pixelColor.b = data[index++]; pixelColor.g = data[index++]; pixelColor.r = data[index++]; pixelColor.a = data[index++]; } else { pixelColor.b = data[index++]; pixelColor.g = data[index++]; pixelColor.r = data[index++]; } for (i = 0; i < pixelRun; i++) { colors[colorIndex++] = pixelColor; } } else { // this is not an RLE packet since last bit is not set. just add one to get count of pixels pixelRun = (byte)(pixelRun + 1); for (i = 0; i < pixelRun; i++) { if (hasAlpha) { pixelColor.b = data[index++]; pixelColor.g = data[index++]; pixelColor.r = data[index++]; pixelColor.a = data[index++]; } else { pixelColor.b = data[index++]; pixelColor.g = data[index++]; pixelColor.r = data[index++]; } colors[colorIndex++] = pixelColor; } } } return colors; }
/**-------------------------------------------------------------------------- * 公開 *--------------------------------------------------------------------------*/ /// <summary> /// コンストラクタ /// </summary> public TGA() { m_Header = new TGAHeader(); m_Footer = new TGAFooter(); }
private static Color32[] ReadRTETrueColorImage(TGAHeader header, byte[] data) { MethodInfo read = typeof(TGAImage).GetMethod("ReadRTETrueColorImage", (BindingFlags.Instance | BindingFlags.NonPublic)); Color32[] colors = read.Invoke(new TGAImage(), new object[] { header, data }) as Color32[]; return colors; }
public void CreateMap(MapDepth depth, string path) { string fullPath = Path.Combine(Directory.GetCurrentDirectory(), Path.Combine("GameData", path)); byte[] bytes = File.ReadAllBytes(fullPath); TGAHeader tex = new TGAHeader(bytes); this._name = Path.GetFileNameWithoutExtension(fullPath); ; this._width = tex.width; this._height = tex.height; this._bpp = (int)depth; this._rowWidth = this._width * this._bpp; switch (depth) { case MapDepth.Greyscale: GreyscaleFromRGB(tex, bytes); break; case MapDepth.HeightAlpha: HeightAlpha(tex, bytes); break; case MapDepth.RGB: RGB(tex, bytes); break; case MapDepth.RGBA: RGBA(tex, bytes); break; } this._isCompiled = true; }
protected void GreyscaleFromRGB(TGAHeader tex, byte[] data) { Color32[] colorArray = TGAUtils.ReadImage(tex, data); int length = colorArray.Length; this._data = new byte[length]; for (int i = 0; i < length; i++) { this._data[i] = colorArray[i].r; } }
private byte[] CreateTGA() { bool tgaSaveMipMaps = false; TGAHeader header = new TGAHeader(); switch (Format) { case TextureFormat.Alpha8: header.imageType = 3; header.pixelDepth = 8; break; case TextureFormat.RGBA32: case TextureFormat.ARGB32: case TextureFormat.BGRA32: case TextureFormat.RGBA4444: case TextureFormat.ARGB4444: header.imageType = 2; header.pixelDepth = 32; break; case TextureFormat.RGB24: case TextureFormat.RGB565: header.imageType = 2; header.pixelDepth = 24; break; default: throw new TextureException("Invalid format for TGA: " + Format + "(" + Name + ")"); } // Convert image to RGBA32 ConvertToRGBA32(); int mipMapCount = 1; if (MipMap) { mipMapCount = GetMipMapCount(Width, Height); } for (int i = 0; i < ImageCount; i++) { header.imageWidth = Width; header.imageHeight = Height; // only want first (largest) mipmap for (int j = 0; j < 1; j++) { int imageSize = header.imageWidth * header.imageHeight * header.pixelDepth / 8; if (tgaSaveMipMaps || j == 0) { //ByteBuffer bbTga = ByteBuffer.allocateDirect(TGAHeader.SIZE + imageSize); //bbTga.order(ByteOrder.LITTLE_ENDIAN); _data.ResetPos(); using (var ms = new MemoryStream()) using (BinaryWriter bw = new BinaryWriter(ms)) { byte[] bytes = new byte[imageSize]; _data.Read(bytes, 0, imageSize); header.write(bw); bw.Write(bytes); return(ms.ToArray()); } } } } // something went wrong, if get here Logger.Log(LogLevel.ERROR, "TGA creation failed for {0}", Name); return(new byte[0]); }