357 lines
13 KiB
C#
357 lines
13 KiB
C#
using System;
|
|
using System.IO;
|
|
using System.Runtime.Serialization.Formatters.Binary;
|
|
|
|
namespace Pgm {
|
|
|
|
public enum PgmType { P2, P5 }
|
|
|
|
public static class PgmCreator {
|
|
const byte NEW_LINE = 10; /* ascii code of new line */
|
|
const byte HASH = 35; /* ascii code of hash: '#' */
|
|
const byte SPACE = 32; /* ascii code of the blank / space */
|
|
const byte ASCII_P = 80;
|
|
const byte ASCII_2 = 50;
|
|
const byte ASCII_5 = 53;
|
|
|
|
#region PGM Reader
|
|
/// <summary>
|
|
/// Reads in a PGM file in P2 or P5 Format and returns a byte[,]-Array if everything works fine. Otherwise, exceptions are thrown.
|
|
/// For the specification of PGM-Files, see: http://netpbm.sourceforge.net/doc/pgm.html
|
|
///
|
|
/// This Method was used and modified from http://www.cnblogs.com/lihongsheng0217/archive/2008/08/12/1266426.html
|
|
/// Original author: Mennan Tekbir(mtekbir[]gmail[]com).
|
|
/// Major modifications by Radomir Dinic and Gerhard Mitterlechner. License: GPL
|
|
///
|
|
/// IMPORTANT:
|
|
/// *) A comment line must be present ofter the type code (P2 or P5).
|
|
/// *) Also: class only handles gray-values <= 255 correctly! (according to spec. <= 65536 should be supported)
|
|
/// *) Only newlines LF (ASCII 10) are used. Therefore, Windows users who create or modify the P2 PGM (=ASCII) files
|
|
/// MANUALLY may run into problems, because Windows OS uses CR (ASCII 13) AND NL (ASCII 10) for a line break.
|
|
/// </summary>
|
|
/// <param name="filename"></param>
|
|
/// <returns></returns>
|
|
public static byte[,] ReadPgmFile(string filename) {
|
|
try {
|
|
FileStream inputStream;
|
|
BinaryReader pgmReader;
|
|
|
|
inputStream = File.OpenRead(filename);
|
|
pgmReader = new BinaryReader(inputStream);
|
|
|
|
byte[] pgmDataBuffer; //the actual image-data (width*height many elements)
|
|
int width, height; //dimension of the image
|
|
|
|
using (inputStream) { //using two ressources, using can be nested
|
|
using (pgmReader) {
|
|
// stores some header info of PGM-File temporarily.
|
|
// WARNING: Here, the comment can be max. 999 characters long (plus the '#')!
|
|
byte[] tempArray = new byte[1000];
|
|
|
|
/* Sample PGM : (the dimension of the image is arbitrary, but the max-color value must be 255! (more strict than in specification!))
|
|
* P2
|
|
* # Created by ...
|
|
* 512 512
|
|
* 255
|
|
* [data]
|
|
*/
|
|
|
|
//read PGM Type P2, P5
|
|
tempArray[0] = pgmReader.ReadByte();
|
|
if (tempArray[0] != ASCII_P)
|
|
throw new FormatException("Wrong first byte in pgm-File.");
|
|
|
|
tempArray[1] = pgmReader.ReadByte();
|
|
if (tempArray[1] != ASCII_2 && tempArray[1] != ASCII_5)
|
|
throw new FormatException("Wrong second byte in pgm-File.");
|
|
|
|
//make a string out of first two read ASCII-Codes:
|
|
string sType = System.Text.ASCIIEncoding.Default.GetString(tempArray, 0, 2);
|
|
|
|
//read until new line
|
|
while (pgmReader.ReadByte() != NEW_LINE) {;}
|
|
ReadComment(pgmReader, inputStream);
|
|
|
|
width = Convert.ToInt32(ReadUntil(SPACE, pgmReader));
|
|
height = Convert.ToInt32(ReadUntil(NEW_LINE, pgmReader));
|
|
|
|
if (width < 1 || width > 10000 || height < 1 || height > 10000)
|
|
throw new FormatException("Wrong values for width/height.");
|
|
|
|
//read the maximal gray-scale color value (e.g., 255. Must be < 65536 according to the specification.)
|
|
//WARNING: this programm only allows a max color value of 255!!!
|
|
int maxColor = Convert.ToInt32(ReadUntil(NEW_LINE, pgmReader));
|
|
if (maxColor > 255)
|
|
throw new FormatException("Max color value too high: must be <= 255.");
|
|
|
|
//read image data
|
|
pgmDataBuffer = new byte[width * height];
|
|
if (sType == "P5")
|
|
ReadP5(pgmDataBuffer, pgmReader);
|
|
else if (sType == "P2")
|
|
ReadP2(pgmDataBuffer, pgmReader);
|
|
|
|
} //end inner using
|
|
} //end outer using
|
|
return CreateTwodimensionalArray(pgmDataBuffer, width, height);
|
|
} //end outer try
|
|
catch (FormatException) {
|
|
throw; //just rethrow it
|
|
}
|
|
catch (FileNotFoundException e) { //example of nested exception (same type)
|
|
throw new FileNotFoundException("File " + filename + " could not be found.", e);
|
|
}
|
|
catch (OutOfMemoryException e) { //example of nested exceptions (different type)
|
|
throw new ApplicationException("ReadPGMFile has got too little memory!", e);
|
|
}
|
|
catch (IOException e) {
|
|
throw new Exception("ReadPGMFile produced some IO-exception: " + e.Message);
|
|
}
|
|
catch (Exception e) {
|
|
throw new Exception("ReadPGMFile produced some exception: " + e.Message);
|
|
}
|
|
}
|
|
|
|
//Read comments (if existI. Only one or no comment line is supported.
|
|
//Only length of max. 999 characters plus the '#'!
|
|
private static void ReadComment(BinaryReader pgmReader, FileStream inputStream) {
|
|
try {
|
|
byte tempByte = pgmReader.ReadByte();
|
|
if (tempByte == HASH)
|
|
ReadUntil(NEW_LINE, pgmReader);
|
|
else //no comment ==> reset cursor
|
|
inputStream.Seek(-1, SeekOrigin.Current);
|
|
}
|
|
|
|
catch (IOException e) {
|
|
throw new Exception("IO-Exception in ReadComment: " + e.Message);
|
|
}
|
|
catch (Exception e) {
|
|
throw new Exception("Error in ReadComment: " + e.Message);
|
|
}
|
|
}
|
|
|
|
//Reads the image data for a P5 file into buffer.
|
|
private static void ReadP5(byte[] buffer, BinaryReader pgmReader) {
|
|
//If file is binary, read every byte
|
|
try {
|
|
//store each color value:
|
|
byte[] readBytes = pgmReader.ReadBytes(buffer.Length);
|
|
//copy the content to the destination buffer:
|
|
|
|
Array.Copy(readBytes, buffer, readBytes.Length);
|
|
}
|
|
catch (Exception e) {
|
|
throw new Exception("Error reading binary data from P5 file! " + e.Message);
|
|
}
|
|
}
|
|
|
|
//Reads the P2 image data to the buffer.
|
|
private static void ReadP2(byte[] buffer, BinaryReader pgmReader) {
|
|
//if file is text-based every pixel is distinguished by "space"
|
|
//and it has up to 3 chars (max grey-value of 255!)
|
|
try {
|
|
byte[] tempArray = new byte[1000];
|
|
byte tempByte = pgmReader.ReadByte();
|
|
int k = 0;
|
|
while (pgmReader.BaseStream.Position != pgmReader.BaseStream.Length) {
|
|
//read all non-newline or non-whitespace character
|
|
int i = 0;
|
|
while (tempByte != NEW_LINE && tempByte != SPACE) {
|
|
tempArray[i] = tempByte;
|
|
i++;
|
|
tempByte = pgmReader.ReadByte();
|
|
}
|
|
//Convert the non-newline/non-whitespace characters to a string and
|
|
//copy the string representation of every pixel to buffer of image data.
|
|
buffer[k] = Convert.ToByte(System.Text.ASCIIEncoding.Default.GetString(tempArray, 0, i));
|
|
k++;
|
|
|
|
tempByte = pgmReader.ReadByte();
|
|
if (pgmReader.BaseStream.Position != pgmReader.BaseStream.Length) {
|
|
if (tempByte == NEW_LINE || tempByte == SPACE) {
|
|
tempByte = pgmReader.ReadByte(); //read next character (must be a non-newline/non-blank)
|
|
}
|
|
}
|
|
} //end while
|
|
} //end try
|
|
catch (EndOfStreamException e) {
|
|
//if premature end of stream is reached...
|
|
throw new Exception("Unexcpected end of stream reading P2 file: " + e.Message);
|
|
}
|
|
catch (IOException e) {
|
|
throw new Exception("Some IO exception when reading P2 file: " + e.Message);
|
|
}
|
|
catch (Exception e){
|
|
throw new Exception("Some other exception when reading P2 file: " + e.Message);
|
|
}
|
|
}
|
|
|
|
//Reads from pgmReader until separator is reached. (Max 1000 bytes.)
|
|
private static string ReadUntil(byte separator, BinaryReader pgmReader) {
|
|
try {
|
|
byte[] tempArray = new byte[1000];
|
|
int i = 0;
|
|
byte tempByte = pgmReader.ReadByte();
|
|
while (tempByte != separator) {
|
|
tempArray[i] = tempByte;
|
|
i++;
|
|
tempByte = pgmReader.ReadByte();
|
|
}
|
|
//make a string out of tempArray
|
|
return System.Text.ASCIIEncoding.Default.GetString(tempArray, 0, i);
|
|
}
|
|
catch (IndexOutOfRangeException) {
|
|
throw new IndexOutOfRangeException("ReadUntil failed: wrong indices in while-loop.");
|
|
}
|
|
catch (Exception e) {
|
|
throw new Exception("ReadUntil failed: " + e.Message);
|
|
}
|
|
}
|
|
|
|
//Creates a two-dim array out of the one-dim pgmDataBuffer.
|
|
private static byte[,] CreateTwodimensionalArray(byte[] pgmDataBuffer, int width, int height) {
|
|
try {
|
|
byte[,] temp = new byte[width, height];
|
|
for (int y = 0; y < height; y++) {
|
|
for (int x = 0; x < width; x++) {
|
|
temp[x, y] = pgmDataBuffer[y * width + x];
|
|
}
|
|
}
|
|
return temp;
|
|
}
|
|
catch (OutOfMemoryException e) {
|
|
throw new OutOfMemoryException("CreateTwodimensionalArray failed: too little memory.", e);
|
|
}
|
|
catch (IndexOutOfRangeException) {
|
|
throw new Exception("Wrong index in for-loop of CreateTwodimensionalArray.");
|
|
}
|
|
catch (Exception e) {
|
|
throw new Exception("CreateTwodimensionalArray failed: " + e.Message);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region PGM Writer
|
|
/// <summary>
|
|
/// Write a given byte[,] to Pgm-File or throws an exception on an error.
|
|
/// Formats:
|
|
/// P2: ASCII-Format
|
|
/// P5: Binary-Format
|
|
/// </summary>
|
|
/// <param name="filename">filename or path</param>
|
|
/// <param name="imgData">array with image-data</param>
|
|
/// <param name="type">Type P2 or P5</param>
|
|
public static void WritePgmFile(string filename, byte[,] imgData, PgmType type) {
|
|
if (imgData == null)
|
|
throw new ArgumentException("WritePgmFileBinary: imgData must not be null.");
|
|
|
|
switch (type) {
|
|
case PgmType.P2:
|
|
WritePgmFileASCII(filename, imgData, type);
|
|
break;
|
|
case PgmType.P5:
|
|
WritePgmFileBinary(filename, imgData, type);
|
|
break;
|
|
default:
|
|
throw new ArgumentException("WritePgmFile failed: wrong type!");
|
|
}
|
|
}
|
|
|
|
//helper for WritePgmFile
|
|
private static void WritePgmFileASCII(string filename, byte[,] imgData, PgmType type) {
|
|
StreamWriter writer = null;
|
|
try {
|
|
writer = new StreamWriter(filename);
|
|
writer.Write(BuildPgmHeader(imgData.GetLength(0), imgData.GetLength(1), type));
|
|
|
|
for (int y = 0; y < imgData.GetLength(1); y++) {
|
|
for (int x = 0; x < imgData.GetLength(0); x++) {
|
|
string data = imgData[x, y].ToString() + " ";
|
|
writer.Write(data);
|
|
}
|
|
writer.Write('\n');
|
|
}
|
|
}
|
|
catch (UnauthorizedAccessException e) {
|
|
throw new Exception("WritePgmFile failed: no permission to write. " + e.Message);
|
|
}
|
|
catch (Exception e) {
|
|
throw new Exception("WritePgmFileASCII failed: could not write to file " + filename + ". " + e.Message);
|
|
}
|
|
finally { //example using finally (instead of "using")
|
|
if (writer != null) writer.Close();
|
|
}
|
|
}
|
|
|
|
//helper for WritePgmFile
|
|
private static void WritePgmFileBinary(string filename, byte[,] imgData, PgmType type) {
|
|
try {
|
|
FileStream outputStream = File.Create(filename);
|
|
BinaryWriter pgmWriter = new BinaryWriter(outputStream);
|
|
using (outputStream) {
|
|
using (pgmWriter) {
|
|
string PGMInfo = BuildPgmHeader(imgData.GetLength(0), imgData.GetLength(1), type);
|
|
byte[] PGMInfoBuffer = System.Text.ASCIIEncoding.Default.GetBytes(PGMInfo);
|
|
pgmWriter.Write(PGMInfoBuffer);
|
|
byte[] temp = CreateOneDimensionalTempArray(imgData);
|
|
pgmWriter.Write(temp);
|
|
}
|
|
}
|
|
}
|
|
catch (IOException e) {
|
|
throw new Exception("IOException in WritePgmFileBinary writing to file: " + filename + ". " + e.Message);
|
|
}
|
|
catch (OutOfMemoryException e) {
|
|
throw new Exception("WritePgmFile failed with OutOfMemoryException: " + e.Message);
|
|
}
|
|
catch (UnauthorizedAccessException e) {
|
|
throw new Exception("WritePgmFile failed: no permission to write. " + e.Message);
|
|
}
|
|
}
|
|
|
|
private static string BuildPgmHeader(int width, int height, PgmType type) {
|
|
string header = string.Empty;
|
|
switch (type) {
|
|
case PgmType.P2:
|
|
header += "P2\n";
|
|
break;
|
|
case PgmType.P5:
|
|
header += "P5\n";
|
|
break;
|
|
default:
|
|
throw new ArgumentException("Wrong type in BuildPgmHeader.");
|
|
}
|
|
header += "# MMT\n";
|
|
header += width + " " + height + "\n";
|
|
header += "255\n"; //warning: this is hardcoded, should allow a value up to 65535 according to specification!
|
|
return header;
|
|
}
|
|
|
|
private static byte[] CreateOneDimensionalTempArray(byte[,] imgData) {
|
|
if (imgData == null)
|
|
throw new ArgumentException("CreateOneDimensionalTempArray: imgData must not be null.");
|
|
int w = imgData.GetLength(0);
|
|
int h = imgData.GetLength(1);
|
|
try {
|
|
byte[] temp = new byte[w * h];
|
|
|
|
for (int y = 0; y < h; y++) {
|
|
for (int x = 0; x < w; x++) {
|
|
temp[y * w + x] = imgData[x, y];
|
|
}
|
|
}
|
|
return temp;
|
|
}
|
|
catch (OutOfMemoryException e) {
|
|
throw new OutOfMemoryException("CreateOneDimensionalTempArray failed. Too little memory! " + e.Message);
|
|
}
|
|
catch (Exception e) {
|
|
throw new Exception("CreateOneDimensionalTempArray failed.", e);
|
|
}
|
|
}
|
|
#endregion
|
|
}
|
|
}
|