%PDF-
%PDF-
Mini Shell
Mini Shell
//
// Copyright 2007-2008 Christian Henning, Andreas Pokorny, Lubomir Bourdev
//
// Distributed under the Boost Software License, Version 1.0
// See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt
//
#ifndef BOOST_GIL_EXTENSION_IO_PNG_TAGS_HPP
#define BOOST_GIL_EXTENSION_IO_PNG_TAGS_HPP
#include <boost/gil/io/base.hpp>
#include <string>
#include <vector>
#ifdef BOOST_GIL_IO_PNG_FLOATING_POINT_SUPPORTED
#ifdef BOOST_GIL_IO_PNG_FIXED_POINT_SUPPORTED
# error "Cannot set both symbols"
#endif // BOOST_GIL_IO_PNG_FIXED_POINT_SUPPORTED
#endif // BOOST_GIL_IO_PNG_FLOATING_POINT_SUPPORTED
#ifndef BOOST_GIL_EXTENSION_IO_PNG_C_LIB_COMPILED_AS_CPLUSPLUS
extern "C" {
#endif
#include <png.h>
#ifndef BOOST_GIL_EXTENSION_IO_PNG_C_LIB_COMPILED_AS_CPLUSPLUS
}
#endif
#ifndef BOOST_GIL_EXTENSION_IO_ZLIB_C_LIB_COMPILED_AS_CPLUSPLUS
extern "C" {
#endif
#include <zlib.h>
#ifndef BOOST_GIL_EXTENSION_IO_ZLIB_C_LIB_COMPILED_AS_CPLUSPLUS
}
#endif
#if PNG_LIBPNG_VER_MAJOR == 1
#if PNG_LIBPNG_VER_MINOR <= 4
#define BOOST_GIL_IO_PNG_1_4_OR_LOWER
#endif // PNG_LIBPNG_VER_MAJOR == 1
#endif // PNG_LIBPNG_VER_MINOR <= 4
namespace boost { namespace gil {
/// Defines png tag.
struct png_tag : format_tag {};
/// see http://en.wikipedia.org/wiki/Portable_Network_Graphics for reference
/// Defines type for image width property.
struct png_image_width : property_base< png_uint_32 > {};
/// Defines type for image height property.
struct png_image_height : property_base< png_uint_32 > {};
/// Defines type for interlace method property.
struct png_interlace_method : property_base< int > {};
/// Defines type for filter method property.
struct png_filter_method : property_base< int > {};
/// Defines type for bit depth method property.
struct png_bitdepth : property_base< int > {};
/// Defines type for bit depth method property.
struct png_color_type : property_base< int > {};
/// Defines type for number of channels property.
struct png_num_channels : property_base< png_byte > {};
#ifdef BOOST_GIL_IO_PNG_FLOATING_POINT_SUPPORTED
/// Defines type for CIE chromacities property.
struct png_chromacities_type : property_base< double > {};
/// Defines type for gamma correction property.
struct png_gamma : property_base< double > {};
/// Defines type for physical scale unit property.
struct png_unit : property_base< int > {};
/// Defines type for physical scale property.
struct png_scale : property_base< double > {};
#else
/// Defines type for CIE chromacities property.
struct png_chromacities_type : property_base< png_fixed_point > {};
/// Defines type for gamma correction property.
struct png_gamma : property_base< png_fixed_point > {};
/// Defines type for physical scale unit property.
struct png_unit : property_base< int > {};
#ifdef BOOST_GIL_IO_PNG_FIXED_POINT_SUPPORTED
/// Defines type for physical scale property.
struct png_scale : property_base< png_fixed_point > {};
#else
/// Defines type for physical scale property.
struct png_scale : property_base< std::string > {};
#endif // BOOST_GIL_IO_PNG_FIXED_POINT_SUPPORTED
#endif // BOOST_GIL_IO_PNG_FLOATING_POINT_SUPPORTED
/// Returns image resolution in pixels per meter, from pHYs chunk data.
struct png_pixels_per_meter : property_base< png_uint_32 > {};
/// Defines type for ICC profile name property.
struct png_ICC_name : property_base< std::string > {};
/// Defines type for ICC profile property.
#if PNG_LIBPNG_VER_MINOR >= 5
struct png_ICC_profile : property_base< std:: vector <uint8_t> > {};
#else
struct png_ICC_profile : property_base< std:: vector <char> > {};
#endif
/// Defines type for ICC profile length property.
struct png_ICC_profile_length : property_base< png_uint_32 > {};
/// Defines type for ICC compression property.
struct png_ICC_compression_type : property_base< int > {};
/// Defines type for rendering intent property.
struct png_intent : property_base< int > {};
/// Defines type for color palette property.
struct png_color_palette : property_base< std::vector< png_color > > {};
/// Defines type for number of colors property.
struct png_num_palette : property_base< int > {};
/// Defines type for background property.
struct png_background : property_base< png_color_16 > {};
/// Defines type for histogram property.
struct png_histrogram : property_base< std::vector< png_uint_16 > > {};
/// Defines type for screen offset property.
struct png_offset : property_base< png_int_32 > {};
/// Defines type for screen offset type property.
struct png_offset_type : property_base< int > {};
/// Defines type pixel calibration for property.
struct png_CAL : property_base< std::string > {};
/// Defines type for pixel calibration parameters property.
struct png_CAL_params : property_base< std::vector< std::string > > {};
/// Defines type for pixel calibration x property.
struct png_CAL_X : property_base< png_int_32 > {};
/// Defines type for pixel calibration type property.
struct png_CAL_type : property_base< int > {};
/// Defines type for number of pixel calibration properties.
struct png_CAL_nparam : property_base< int > {};
/// Defines type for physical resolution property.
struct png_resolution : property_base< png_uint_32 > {};
/// Defines type for physical resolution unit property.
struct png_unit_type : property_base< int > {};
/// Defines type for significant bits property.
struct png_significant_bits : property_base< png_color_8 > {};
/// Helper structure for reading text property.
struct gil_io_png_text
{
/// Compression type
int _compression;
// Key
std::string _key;
/// Text
std::string _text;
};
/// Defines type for text property.
struct png_text_ : property_base< std::vector< gil_io_png_text > > {};
/// Defines type for number of text property.
struct png_num_text : property_base< int > {};
/// Defines type for modification time property.
struct png_mod_time : property_base< png_time > {};
/// Defines type for transparency data property.
struct png_trans : property_base< std::vector< png_byte > > {};
/// Defines type for number of transparency data property.
struct png_num_trans : property_base< int > {};
/// Defines type for transparency data values property.
struct png_trans_values : property_base< std::vector< png_color_16 > > {};
/// Defines type for png function return type.
struct png_return_value : property_base< png_uint_32 > {};
////////////////////////
// Write properties
////////////////////////
// relates to info_ptr->compression_type
struct png_compression_type : property_base< png_byte >
{
static const type default_value = PNG_COMPRESSION_TYPE_BASE;
};
// compression level - default values taken from libpng manual.
// Look for png_set_compression_level
struct png_compression_level : property_base< int >
{
static const type default_value = 3;
};
struct png_compression_mem_level : property_base< int >
{
static const type default_value = MAX_MEM_LEVEL;
};
struct png_compression_strategy : property_base< int >
{
static const type default_value = Z_DEFAULT_STRATEGY;
};
struct png_compression_window_bits : property_base< int >
{
static const type default_value = 9;
};
struct png_compression_method : property_base< int >
{
static const type default_value = 8;
};
struct png_compression_buffer_size : property_base< int >
{
static const type default_value = 8192;
};
// dithering
struct png_dithering_palette : property_base< std::vector< png_color > >
{};
struct png_dithering_num_palette : property_base< int >
{
static const type default_value = 0;
};
struct png_dithering_maximum_colors : property_base< int >
{
static const type default_value = 0;
};
struct png_dithering_histogram : property_base< std::vector< png_uint_16 > >
{};
struct png_full_dither : property_base< int >
{
static const type default_value = 0;
};
// filter
struct png_filter : property_base< int >
{
static const type default_value = 0;
};
// invert mono
struct png_invert_mono : property_base< bool >
{
static const type default_value = false;
};
// true bits
struct png_true_bits : property_base< std::vector< png_color_8 > >
{};
// sRGB Intent
struct png_srgb_intent : property_base< int >
{
static const type default_value = 0;
};
// strip alpha
struct png_strip_alpha : property_base< bool >
{
static const type default_value = false;
};
struct png_swap_alpha : property_base< bool >
{
static const type default_value = false;
};
/// PNG info base class. Containing all header information both for reading and writing.
///
/// This base structure was created to avoid code doubling.
struct png_info_base
{
/// Default constructor
png_info_base()
: _width ( 0 )
, _height( 0 )
, _bit_depth ( 0 )
, _color_type ( 0 )
, _interlace_method ( PNG_INTERLACE_NONE )
, _compression_method( PNG_COMPRESSION_TYPE_DEFAULT )
, _filter_method ( PNG_FILTER_TYPE_DEFAULT )
, _num_channels( 0 )
#ifdef BOOST_GIL_IO_PNG_FLOATING_POINT_SUPPORTED
, _valid_cie_colors( 0 )
, _white_x ( 0.0 )
, _white_y ( 0.0 )
, _red_x ( 0.0 )
, _red_y ( 0.0 )
, _green_x ( 0.0 )
, _green_y ( 0.0 )
, _blue_x ( 0.0 )
, _blue_y ( 0.0 )
, _valid_file_gamma( 0 )
, _file_gamma ( 1.0 )
#else
, _valid_cie_colors( 0 )
, _white_x ( 0 )
, _white_y ( 0 )
, _red_x ( 0 )
, _red_y ( 0 )
, _green_x ( 0 )
, _green_y ( 0 )
, _blue_x ( 0 )
, _blue_y ( 0 )
, _valid_file_gamma( 0 )
, _file_gamma ( 1 )
#endif // BOOST_GIL_IO_PNG_FLOATING_POINT_SUPPORTED
, _valid_icc_profile ( 0 )
, _icc_name ( )
, _iccp_compression_type( PNG_COMPRESSION_TYPE_BASE )
, _profile ( )
, _profile_length ( 0 )
, _valid_intent( 0 )
, _intent ( 0 )
, _valid_palette( 0 )
, _palette ( )
, _num_palette ( 0 )
, _valid_background( 0 )
, _background ( )
, _valid_histogram( 0 )
, _histogram ( )
, _valid_offset ( 0 )
, _offset_x ( 0 )
, _offset_y ( 0 )
, _off_unit_type( PNG_OFFSET_PIXEL )
, _valid_pixel_calibration( 0 )
, _purpose ( )
, _X0 ( 0 )
, _X1 ( 0 )
, _cal_type ( 0 )
, _num_params ( 0 )
, _units ( )
, _params ( )
, _valid_resolution( 0 )
, _res_x ( 0 )
, _res_y ( 0 )
, _phy_unit_type ( PNG_RESOLUTION_UNKNOWN )
, _pixels_per_meter( 0 )
, _valid_significant_bits( 0 )
, _sig_bits ( )
, _valid_scale_factors( 0 )
, _scale_unit ( PNG_SCALE_UNKNOWN )
#ifdef BOOST_GIL_IO_PNG_FLOATING_POINT_SUPPORTED
, _scale_width ( 0.0 )
, _scale_height( 0.0 )
#else
#ifdef BOOST_GIL_IO_PNG_FIXED_POINT_SUPPORTED
, _scale_width ( 0 )
, _scale_height( 0 )
#else
, _scale_width ()
, _scale_height()
#endif // BOOST_GIL_IO_PNG_FIXED_POINT_SUPPORTED
#endif // BOOST_GIL_IO_PNG_FLOATING_POINT_SUPPORTED
, _valid_text( 0 )
, _text ( )
, _num_text ( 0 )
, _valid_modification_time( 0 )
, _mod_time ( )
, _valid_transparency_factors( 0 )
, _trans ( )
, _num_trans ( 0 )
, _trans_values ( )
{}
/// The image width.
png_image_width::type _width;
/// The image height.
png_image_height::type _height;
/// The bit depth per channel.
png_bitdepth::type _bit_depth;
/// The color space type.
png_color_type::type _color_type;
/// The interlace methos.
png_interlace_method::type _interlace_method;
/// The compression method.
png_compression_method::type _compression_method;
/// The filer method.
png_filter_method::type _filter_method;
/// The number of channels.
png_num_channels::type _num_channels;
// CIE chromacities
/// The return value when reading CIE chromacities.
png_return_value::type _valid_cie_colors;
/// The white x value.
png_chromacities_type::type _white_x;
/// The white y value.
png_chromacities_type::type _white_y;
/// The red x value.
png_chromacities_type::type _red_x;
/// The red y value.
png_chromacities_type::type _red_y;
/// The green x value.
png_chromacities_type::type _green_x;
/// The green y value.
png_chromacities_type::type _green_y;
/// The blue x value.
png_chromacities_type::type _blue_x;
/// The blue y value.
png_chromacities_type::type _blue_y;
// Gamma Value
/// The return value when reading gamma value.
png_return_value::type _valid_file_gamma;
/// The file gamma value.
png_gamma::type _file_gamma;
// Embedded ICC profile
/// The return value when reading ICC profile.
png_return_value::type _valid_icc_profile;
/// The ICC name.
png_ICC_name::type _icc_name;
/// The icc compression type.
png_ICC_compression_type::type _iccp_compression_type;
/// The ICC profile.
png_ICC_profile::type _profile;
/// The ICC profile length.
png_ICC_profile_length::type _profile_length;
// Rendering intent
/// The return value when reading rendering intent.
png_return_value::type _valid_intent;
/// The rendering intent value.
png_intent::type _intent;
// Image palette
/// The return value when reading image palette.
png_return_value::type _valid_palette;
/// The color palette.
png_color_palette::type _palette;
/// The number of colors in the palettes.
png_num_palette::type _num_palette;
// Background
/// The return value when reading background.
png_return_value::type _valid_background;
/// The background color.
png_background::type _background;
// Histogram
/// The return value when reading histogram.
png_return_value::type _valid_histogram;
/// The histogram.
png_histrogram::type _histogram;
// Screen offsets
/// The return value when reading screen offsets.
png_return_value::type _valid_offset;
/// The x offset.
png_offset::type _offset_x;
/// The y offset.
png_offset::type _offset_y;
/// The offset unit.
png_offset_type::type _off_unit_type;
// Pixel Calibration
/// The return value when reading pixel calibration.
png_return_value::type _valid_pixel_calibration;
/// The purpose.
png_CAL::type _purpose;
/// The x_0 value.
png_CAL_X::type _X0;
/// The x_1 value.
png_CAL_X::type _X1;
/// The calibration type.
png_CAL_type::type _cal_type;
/// The number of calibration parameters.
png_CAL_nparam::type _num_params;
/// The calibration unit type.
png_CAL::type _units;
/// The calibration parameters.
png_CAL_params::type _params;
// Physical resolution
/// The return value when reading physical resolution properties.
png_return_value::type _valid_resolution;
/// The x physical resolution.
png_resolution::type _res_x;
/// The y physical resolution.
png_resolution::type _res_y;
/// The physical resolution unit.
png_unit_type::type _phy_unit_type;
/// The Image resolution in pixels per meter.
png_pixels_per_meter::type _pixels_per_meter;
// Number of significant bits
/// The return value when reading significant bits.
png_return_value::type _valid_significant_bits;
/// The significant bits.
png_significant_bits::type _sig_bits;
// Scale Factors
/// The return value when reading scale factors.
png_return_value::type _valid_scale_factors;
/// The scaling unit.
png_unit::type _scale_unit;
/// The scaling width.
png_scale::type _scale_width;
/// The scaling height.
png_scale::type _scale_height;
// Comments information
/// The return value when reading image comments.
png_return_value::type _valid_text;
/// The comments.
png_text_::type _text;
/// The number of comments.
png_num_text::type _num_text;
// Last modification time
/// The return value when reading modification time.
png_return_value::type _valid_modification_time;
/// The modification time.
png_mod_time::type _mod_time;
// Transparency data
/// The return value when reading transparency data.
png_return_value::type _valid_transparency_factors;
/// The transparency data.
png_trans::type _trans;
/// The number of transparency data.
png_num_trans::type _num_trans;
/// The transparency data values.
png_trans_values::type _trans_values;
};
/// Read information for png images.
///
/// The structure is returned when using read_image_info.
template<>
struct image_read_info< png_tag > : public png_info_base
{
/// Default constructor.
image_read_info< png_tag >()
: png_info_base()
{}
};
/// PNG settings base class.
///
/// This base structure was created to avoid code doubling.
struct png_read_settings_base
{
/// Default Constructor.
png_read_settings_base()
{
_read_cie_chromacities = false;
_read_file_gamma = false;
_read_icc_profile = false;
_read_intent = false;
_read_palette = false;
_read_background = false;
_read_histogram = false;
_read_screen_offsets = false;
_read_pixel_calibration = false;
_read_physical_resolution = false;
_read_pixels_per_meter = false;
_read_number_of_significant_bits = false;
_read_scale_factors = false;
_read_comments = false;
_read_last_modification_time = false;
_read_transparency_data = false;
}
/// Helper function to enabling reading all png properties.
void set_read_members_true()
{
_read_cie_chromacities = true;
_read_file_gamma = true;
_read_icc_profile = true;
_read_intent = true;
_read_palette = true;
_read_background = true;
_read_histogram = true;
_read_screen_offsets = true;
_read_pixel_calibration = true;
_read_physical_resolution = true;
_read_pixels_per_meter = true;
_read_number_of_significant_bits = true;
_read_scale_factors = true;
_read_comments = true;
_read_last_modification_time = true;
_read_transparency_data = true;
}
/// Enable reading CIE chromacities.
bool _read_cie_chromacities;
/// Enable reading file gamma.
bool _read_file_gamma;
/// Enable reading ICC profile.
bool _read_icc_profile;
/// Enable reading rendering intent.
bool _read_intent;
/// Enable reading color palette.
bool _read_palette;
/// Enable reading background color.
bool _read_background;
/// Enable reading histogram.
bool _read_histogram;
/// Enable reading screen offsets.
bool _read_screen_offsets;
/// Enable reading pixel calibration.
bool _read_pixel_calibration;
/// Enable reading physical resolution.
bool _read_physical_resolution;
/// Enable reading pixels per meter information.
bool _read_pixels_per_meter;
/// Enable reading significant bits.
bool _read_number_of_significant_bits;
/// Enable reading scaling factors.
bool _read_scale_factors;
/// Enable reading comments.
bool _read_comments;
/// Enable reading modification time.
bool _read_last_modification_time;
/// Enable reading transparency data.
bool _read_transparency_data;
};
#ifdef BOOST_GIL_IO_PNG_FLOATING_POINT_SUPPORTED
/// Read settings for png images.
///
/// The structure can be used for all read_xxx functions, except read_image_info.
template<>
struct image_read_settings< png_tag > : public image_read_settings_base
, public png_read_settings_base
{
/// Default Constructor
image_read_settings< png_tag >()
: image_read_settings_base()
, png_read_settings_base()
, _screen_gamma( 1.0 )
{}
/// Constructor
/// \param top_left Top left coordinate for reading partial image.
/// \param dim Dimensions for reading partial image.
/// \param gamma Screen gamma value.
image_read_settings( const point_t& top_left
, const point_t& dim
, const bool apply_screen_gamma = false
, const png_gamma::type& screen_gamma = 1.0
)
: image_read_settings_base( top_left
, dim
)
, png_read_settings_base()
, _apply_screen_gamma( apply_screen_gamma )
, _screen_gamma( screen_gamma )
{}
/// Apply screen gamma value.
bool _apply_screen_gamma;
/// The screen gamma value.
png_gamma::type _screen_gamma;
};
#else
/// Read settings for png images.
///
/// The structure can be used for all read_xxx functions, except read_image_info.
template<>
struct image_read_settings< png_tag > : public image_read_settings_base
, public png_read_settings_base
{
/// Default Constructor.
image_read_settings< png_tag >()
: image_read_settings_base()
, png_read_settings_base()
, _apply_screen_gamma( false )
, _screen_gamma ( 2 )
{}
image_read_settings( const point_t& top_left
, const point_t& dim
)
: image_read_settings_base( top_left
, dim
)
, png_read_settings_base()
, _apply_screen_gamma( false )
, _screen_gamma ( 2 )
{}
/// Apply screen gamma value.
bool _apply_screen_gamma;
/// The screen gamma value.
png_gamma::type _screen_gamma;
};
#endif
/// Write information for png images.
///
/// The structure can be used for write_view() function.
template<>
struct image_write_info< png_tag > : public png_info_base
{
image_write_info( const png_compression_type::type compression_type = png_compression_type::default_value
, const png_compression_level::type compression_level = png_compression_level::default_value
, const png_compression_mem_level::type compression_mem_level = png_compression_mem_level::default_value
, const png_compression_strategy::type compression_strategy = png_compression_strategy::default_value
, const png_compression_window_bits::type compression_window_bits = png_compression_window_bits::default_value
, const png_compression_method::type compression_method = png_compression_method::default_value
, const png_compression_buffer_size::type compression_buffer_size = png_compression_buffer_size::default_value
, const png_dithering_num_palette::type num_palette = png_dithering_num_palette::default_value
, const png_dithering_maximum_colors::type maximum_colors = png_dithering_maximum_colors::default_value
, const png_full_dither::type full_dither = png_full_dither::default_value
, const png_filter::type filter = png_filter::default_value
, const png_invert_mono::type invert_mono = png_invert_mono::default_value
, const png_srgb_intent::type srgb_intent = png_srgb_intent::default_value
, const png_strip_alpha::type strip_alpha = png_strip_alpha::default_value
, const png_swap_alpha::type swap_alpha = png_swap_alpha::default_value
)
: png_info_base()
, _compression_type( compression_type )
, _compression_level( compression_level )
, _compression_mem_level( compression_mem_level )
, _compression_strategy( compression_strategy )
, _compression_window_bits( compression_window_bits )
, _compression_method( compression_method )
, _compression_buffer_size( compression_buffer_size )
, _set_dithering( false )
, _dithering_palette()
, _dithering_num_palette( num_palette )
, _dithering_maximum_colors( maximum_colors )
, _dithering_histogram()
, _full_dither( full_dither )
, _set_filter( false )
, _filter( filter )
, _invert_mono( invert_mono )
, _set_true_bits( false )
, _true_bits()
, _set_srgb_intent( false )
, _srgb_intent( srgb_intent )
, _strip_alpha( strip_alpha )
, _swap_alpha( swap_alpha )
{}
// compression stuff
png_compression_type::type _compression_type;
png_compression_level::type _compression_level;
png_compression_mem_level::type _compression_mem_level;
png_compression_strategy::type _compression_strategy;
png_compression_window_bits::type _compression_window_bits;
png_compression_method::type _compression_method;
png_compression_buffer_size::type _compression_buffer_size;
// png_set_dither
bool _set_dithering;
png_dithering_palette::type _dithering_palette;
png_dithering_num_palette::type _dithering_num_palette;
png_dithering_maximum_colors::type _dithering_maximum_colors;
png_dithering_histogram::type _dithering_histogram;
png_full_dither::type _full_dither;
//png_set_filter
bool _set_filter;
png_filter::type _filter;
// png_set_invert_mono
png_invert_mono::type _invert_mono;
// png_set_sBIT
bool _set_true_bits;
png_true_bits::type _true_bits;
// png_set_sRGB
bool _set_srgb_intent;
png_srgb_intent::type _srgb_intent;
// png_set_strip_alpha
png_strip_alpha::type _strip_alpha;
// png_set_swap_alpha
png_swap_alpha::type _swap_alpha;
};
} // namespace gil
} // namespace boost
#endif
Zerion Mini Shell 1.0