Esempio n. 1
0
        /// <summary>
        /// Writes the image data into the stream in the given format.
        /// </summary>
        /// <param name="image">The image whose data to write.</param>
        /// <param name="stream">The stream into which to write the data.</param>
        /// <param name="type">The type of Netpbm image according to which to encode the data.</param>
        /// <typeparam name="TPixelComponent">The type of pixel component values.</typeparam>
        public void WriteImageData <TPixelComponent>(NetpbmImage <TPixelComponent> image, Stream stream, ImageType type)
        {
            // check if the format is supported
            var supportedTypes = SupportedTypesForImage(image);

            if (!supportedTypes.Contains(type))
            {
                throw new ArgumentOutOfRangeException("type", type, "the image cannot be encoded into this type");
            }

            using (var writer = new NetpbmBinaryWriter(stream, new UTF8Encoding(false, true), leaveOpen: true))
            {
                bool isPlain;
                switch (type)
                {
                case ImageType.PBM:
                case ImageType.PGM:
                case ImageType.PPM:
                case ImageType.PAM:
                case ImageType.BigPAM:
                    isPlain = false;
                    break;

                case ImageType.PlainPBM:
                case ImageType.PlainPGM:
                case ImageType.PlainPPM:
                    isPlain = true;
                    break;

                default:
                    throw new ArgumentOutOfRangeException("type", type, "unknown image type");
                }

                if (isPlain)
                {
                    // output in row-major order as decimal numbers
                    // add newlines after each row to make things nicer

                    foreach (var row in image.NativeRows)
                    {
                        foreach (var value in row)
                        {
                            writer.WriteUnprefixed(value.ToString());
                            writer.Write(' ');
                        }
                        writer.Write('\n');
                    }
                }
                else if (type == ImageType.PBM)
                {
                    // special case: bit-packed format!
                    var values = new List <TPixelComponent>(8);
                    foreach (var row in image.NativeRows)
                    {
                        foreach (var value in row)
                        {
                            values.Add(value);

                            if (values.Count == 8)
                            {
                                byte theByte = EncodeBitmapValuesIntoByte(image, values);
                                writer.Write(theByte);
                                values.Clear();
                            }
                        }

                        if (values.Count != 0)
                        {
                            byte theByte = EncodeBitmapValuesIntoByte(image, values);
                            writer.Write(theByte);
                        }
                    }
                }
                else
                {
                    // just the big endian bytes
                    foreach (var row in image.NativeRows)
                    {
                        foreach (var value in row)
                        {
                            writer.Write(image.ComponentToBigEndianBytes(value).ToArray());
                        }
                    }
                }
            }
        }
Esempio n. 2
0
        /// <summary>
        /// Writes a row of image data into the stream in the given format.
        /// </summary>
        /// <param name="image">The image whose row is being encoded (for formatting purposes).</param>
        /// <param name="row">The row to write.</param>
        /// <param name="stream">The stream to write into.</param>
        /// <param name="type">The format according to which to write.</param>
        public void WriteImageRow <TPixelComponent>(NetpbmImage <TPixelComponent> image, IEnumerable <TPixelComponent> row, Stream stream, ImageType type)
        {
            using (var writer = new NetpbmBinaryWriter(stream, new UTF8Encoding(false, true), leaveOpen: true))
            {
                bool isPlain;
                switch (type)
                {
                case ImageType.PBM:
                case ImageType.PGM:
                case ImageType.PPM:
                case ImageType.PAM:
                case ImageType.BigPAM:
                    isPlain = false;
                    break;

                case ImageType.PlainPBM:
                case ImageType.PlainPGM:
                case ImageType.PlainPPM:
                    isPlain = true;
                    break;

                default:
                    throw new ArgumentOutOfRangeException("type", type, "unknown image type");
                }

                if (isPlain)
                {
                    // output row as decimal numbers
                    // add a newline after the row to make things nicer

                    foreach (var value in row)
                    {
                        writer.WriteUnprefixed(value.ToString());
                        writer.Write(' ');
                    }
                    writer.Write('\n');
                }
                else if (type == ImageType.PBM)
                {
                    // special case: bit-packed format!
                    var values = new List <TPixelComponent>(8);
                    foreach (var value in row)
                    {
                        values.Add(value);

                        if (values.Count == 8)
                        {
                            byte theByte = EncodeBitmapValuesIntoByte(image, values);
                            writer.Write(theByte);
                            values.Clear();
                        }
                    }

                    if (values.Count != 0)
                    {
                        byte theByte = EncodeBitmapValuesIntoByte(image, values);
                        writer.Write(theByte);
                    }
                }
                else
                {
                    // just the big endian bytes
                    foreach (var value in row)
                    {
                        writer.Write(image.ComponentToBigEndianBytes(value).ToArray());
                    }
                }
            }
        }
Esempio n. 3
0
        /// <summary>
        /// Writes the image header into the stream in the given format.
        /// </summary>
        /// <param name="header">The image header to write.</param>
        /// <param name="stream">The stream into which to write the header.</param>
        /// <param name="type">The type of Netpbm image according to which to encode the header.</param>
        /// <typeparam name="TPixelComponent">The type of pixel component values.</typeparam>
        public void WriteImageHeader <TPixelComponent>(NetpbmHeader <TPixelComponent> header, Stream stream, ImageType type)
        {
            // check if the format is supported
            var supportedTypes = SupportedTypesForHeader(header);

            if (!supportedTypes.Contains(type))
            {
                throw new ArgumentOutOfRangeException("type", type, "the image cannot be encoded into this type");
            }

            using (var writer = new NetpbmBinaryWriter(stream, new UTF8Encoding(false, true), leaveOpen: true))
            {
                int magicNumber = (int)type;
                switch (type)
                {
                case ImageType.PBM:
                case ImageType.PGM:
                case ImageType.PPM:
                case ImageType.PAM:
                case ImageType.PlainPBM:
                case ImageType.PlainPGM:
                case ImageType.PlainPPM:
                    break;

                case ImageType.BigPAM:
                    magicNumber = (int)ImageType.PAM;
                    break;

                default:
                    throw new ArgumentOutOfRangeException("type", type, "unknown image type");
                }

                // output the magic
                writer.WriteUnprefixed("P{0}\n", magicNumber);

                if (type == ImageType.PAM || type == ImageType.BigPAM)
                {
                    // output width line
                    writer.WriteUnprefixed("WIDTH {0}\n", header.Width);

                    // output height line
                    writer.WriteUnprefixed("HEIGHT {0}\n", header.Height);

                    // output number of components
                    writer.WriteUnprefixed("DEPTH {0}\n", header.Components.Count);

                    // maximum value
                    writer.WriteUnprefixed("MAXVAL {0}\n", header.HighestComponentValue);

                    // find the components we are working with
                    writer.WriteUnprefixed("TUPLTYPE {0}\n", GetPamTupleType(header));

                    writer.WriteUnprefixed("ENDHDR\n");
                }
                else
                {
                    // output width and height
                    writer.WriteUnprefixed("{0} {1}\n", header.Width, header.Height);

                    // unless PBM (where the max value is always 1)
                    if (type != ImageType.PBM && type != ImageType.PlainPBM)
                    {
                        // output the max value
                        writer.WriteUnprefixed("{0}\n", header.HighestComponentValue);
                    }

                    // the header's final newline
                    writer.Write('\n');
                }
            }
        }