sij/mapnik
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

port r1680/r1683/r1690 from 0.7.1-dev branch to trunk

Browse source
This commit is contained in:
Dane Springmeyer 2010-03-12 18:23:06 +00:00
parent 6b85a9a760
commit d7256295ae
4 changed files with 235 additions and 61 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

12
demo/python/rundemo.py
View file

@ -328,10 +328,20 @@ mapnik2.render(m, im)
images_ = []
im.save('demo.png', 'png') # true-colour RGBA
images_.append('demo.png')
im.save('demo256.png', 'png256') # save to palette based (max 256 colours) png
# old behavior, now can do 'png8:c=256'
im.save('demo256.png', 'png256') # save to palette based (max 256 colours) png
images_.append('demo256.png')
im.save('demo64_binary_transparency.png', 'png8:c=64:t=1')
images_.append('demo64_binary_transparency.png')
im.save('demo128_colors_hextree_no_alpha.png', 'png8:c=100:m=h:t=0')
images_.append('demo128_colors_hextree_no_alpha.png')
im.save('demo_high.jpg', 'jpeg100')
images_.append('demo_high.jpg')
im.save('demo_low.jpg', 'jpeg50')
images_.append('demo_low.jpg')

2
include/mapnik/octree.hpp
View file

@ -43,7 +43,7 @@ namespace mapnik {
byte r;
byte g;
byte b;
rgb(byte r_, byte b_, byte g_)
rgb(byte r_, byte g_, byte b_)
: r(r_), g(g_), b(b_) {}
};

169
include/mapnik/png_io.hpp
View file

@ -23,6 +23,7 @@
//$Id$
#include <mapnik/global.hpp>
#include <mapnik/octree.hpp>
#include <mapnik/hextree.hpp>
#include <mapnik/global.hpp>
extern "C"
@ -30,10 +31,7 @@ extern "C"
#include <png.h>
}
// TODO - consider exposing this option to user
// static number of alpha ranges in png256 format
// 2 results in smallest image, 3 is minimum for semitransparency, 4 is recommended, anything else is worse
#define TRANSPARENCY_LEVELS 4
#define MAX_OCTREE_LEVELS 4
#ifdef MAPNIK_BIG_ENDIAN
#define U2RED(x) (((x)>>24)&0xff)
@ -62,7 +60,7 @@ namespace mapnik {
T * out = static_cast<T*>(png_get_io_ptr(png_ptr));
out->flush();
}
template <typename T1, typename T2>
void save_as_png(T1 & file , T2 const& image)
{
@ -109,7 +107,7 @@ namespace mapnik {
}
template <typename T>
void reduce_8 (T const& in, image_data_8 & out, octree<rgb> trees[], unsigned limits[], std::vector<unsigned> & alpha)
void reduce_8 (T const& in, image_data_8 & out, octree<rgb> trees[], unsigned limits[], unsigned levels, std::vector<unsigned> & alpha)
{
unsigned width = in.width();
unsigned height = in.height();
@ -132,7 +130,7 @@ namespace mapnik {
mapnik::rgb c(U2RED(val), U2GREEN(val), U2BLUE(val));
byte index = 0;
int idx = -1;
for(int j=TRANSPARENCY_LEVELS-1; j>0; j--){
for(int j=levels-1; j>0; j--){
if (U2ALPHA(val)>=limits[j]) {
index = idx = trees[j].quantize(c);
break;
@ -154,7 +152,7 @@ namespace mapnik {
}
template <typename T>
void reduce_4 (T const& in, image_data_8 & out, octree<rgb> trees[], unsigned limits[], std::vector<unsigned> & alpha)
void reduce_4 (T const& in, image_data_8 & out, octree<rgb> trees[], unsigned limits[], unsigned levels, std::vector<unsigned> & alpha)
{
unsigned width = in.width();
unsigned height = in.height();
@ -178,7 +176,7 @@ namespace mapnik {
mapnik::rgb c(U2RED(val), U2GREEN(val), U2BLUE(val));
byte index = 0;
int idx=-1;
for(int j=TRANSPARENCY_LEVELS-1; j>0; j--){
for(int j=levels-1; j>0; j--){
if (U2ALPHA(val)>=limits[j]) {
index = idx = trees[j].quantize(c);
break;
@ -274,8 +272,11 @@ namespace mapnik {
}
template <typename T1,typename T2>
void save_as_png256(T1 & file, T2 const& image)
void save_as_png256(T1 & file, T2 const& image, const unsigned max_colors = 256, int trans_mode = -1)
{
// number of alpha ranges in png256 format; 2 results in smallest image with binary transparency
// 3 is minimum for semitransparency, 4 is recommended, anything else is worse
const unsigned TRANSPARENCY_LEVELS = (trans_mode==2||trans_mode<0)?MAX_OCTREE_LEVELS:2;
unsigned width = image.width();
unsigned height = image.height();
unsigned alphaHist[256];//transparency histogram
@ -287,6 +288,8 @@ namespace mapnik {
for (unsigned y = 0; y < height; ++y){
for (unsigned x = 0; x < width; ++x){
unsigned val = U2ALPHA((unsigned)image.getRow(y)[x]);
if (trans_mode==0)
val=255;
alphaHist[val]++;
meanAlpha += val;
if (val>0 && val<255)
@ -296,16 +299,16 @@ namespace mapnik {
meanAlpha /= width*height;
// transparency ranges division points
unsigned limits[TRANSPARENCY_LEVELS+1];
unsigned limits[MAX_OCTREE_LEVELS+1];
limits[0] = 0;
limits[1] = (alphaHist[0]>0)?1:0;
limits[TRANSPARENCY_LEVELS] = 256;
unsigned alphaHistSum = 0;
for(int j=1; j<TRANSPARENCY_LEVELS; j++)
for(unsigned j=1; j<TRANSPARENCY_LEVELS; j++)
limits[j] = limits[1];
for(int i=1; i<256; i++){
for(unsigned i=1; i<256; i++){
alphaHistSum += alphaHist[i];
for(int j=1; j<TRANSPARENCY_LEVELS; j++){
for(unsigned j=1; j<TRANSPARENCY_LEVELS; j++){
if (alphaHistSum<semiCount*(j)/4)
limits[j] = i;
}
@ -320,9 +323,9 @@ namespace mapnik {
limits[1]=127;
}
// estimated number of colors from palette assigned to chosen ranges
unsigned cols[TRANSPARENCY_LEVELS];
unsigned cols[MAX_OCTREE_LEVELS];
// count colors
for(int j=1; j<=TRANSPARENCY_LEVELS; j++) {
for(unsigned j=1; j<=TRANSPARENCY_LEVELS; j++) {
cols[j-1] = 0;
for(unsigned i=limits[j-1]; i<limits[j]; i++){
cols[j-1] += alphaHist[i];
@ -333,23 +336,33 @@ namespace mapnik {
if (divCoef==0) divCoef = 1;
cols[0] = cols[0]>0?1:0; // fully transparent color (one or not at all)
// give chance less populated but not empty cols to have at least few colors(12)
unsigned minCols = (12+1)*divCoef/(256-cols[0]);
for(int j=1; j<TRANSPARENCY_LEVELS; j++) if (cols[j]>12 && cols[j]<minCols) {
divCoef += minCols-cols[j];
cols[j] = minCols;
if (max_colors>=64) {
// give chance less populated but not empty cols to have at least few colors(12)
unsigned minCols = (12+1)*divCoef/(max_colors-cols[0]);
for(unsigned j=1; j<TRANSPARENCY_LEVELS; j++) if (cols[j]>12 && cols[j]<minCols) {
divCoef += minCols-cols[j];
cols[j] = minCols;
}
}
unsigned usedColors = cols[0];
for(int j=1; j<TRANSPARENCY_LEVELS-1; j++){
cols[j] = cols[j]*(256-cols[0])/divCoef;
for(unsigned j=1; j<TRANSPARENCY_LEVELS-1; j++){
cols[j] = cols[j]*(max_colors-cols[0])/divCoef;
usedColors += cols[j];
}
// use rest for most opaque group of pixels
cols[TRANSPARENCY_LEVELS-1] = 256-usedColors;
cols[TRANSPARENCY_LEVELS-1] = max_colors-usedColors;
//no transparency
if (trans_mode == 0)
{
limits[1] = 0;
cols[0] = 0;
cols[1] = max_colors;
}
// octree table for separate alpha range with 1-based index (0 is fully transparent: no color)
octree<rgb> trees[TRANSPARENCY_LEVELS];
for(int j=1; j<TRANSPARENCY_LEVELS; j++)
octree<rgb> trees[MAX_OCTREE_LEVELS];
for(unsigned j=1; j<TRANSPARENCY_LEVELS; j++)
trees[j].setMaxColors(cols[j]);
for (unsigned y = 0; y < height; ++y)
{
@ -359,7 +372,7 @@ namespace mapnik {
unsigned val = row[x];
// insert to proper tree based on alpha range
for(int j=TRANSPARENCY_LEVELS-1; j>0; j--){
for(unsigned j=TRANSPARENCY_LEVELS-1; j>0; j--){
if (cols[j]>0 && U2ALPHA(val)>=limits[j]) {
trees[j].insert(mapnik::rgb(U2RED(val), U2GREEN(val), U2BLUE(val)));
break;
@ -369,11 +382,11 @@ namespace mapnik {
}
unsigned leftovers = 0;
std::vector<rgb> palette;
palette.reserve(256);
palette.reserve(max_colors);
if (cols[0])
palette.push_back(rgb(0,0,0));
for(int j=1; j<TRANSPARENCY_LEVELS; j++) {
for(unsigned j=1; j<TRANSPARENCY_LEVELS; j++) {
if (cols[j]>0) {
if (leftovers>0) {
cols[j] += leftovers;
@ -383,7 +396,7 @@ namespace mapnik {
std::vector<rgb> pal;
trees[j].setOffset(palette.size());
trees[j].create_palette(pal);
assert(pal.size() <= 256);
assert(pal.size() <= max_colors);
leftovers = cols[j]-pal.size();
cols[j] = pal.size();
for(unsigned i=0; i<pal.size(); i++){
@ -396,13 +409,14 @@ namespace mapnik {
//transparency values per palette index
std::vector<unsigned> alphaTable;
//alphaTable.resize(palette.size());//allow semitransparency also in almost opaque range
alphaTable.resize(palette.size() - cols[TRANSPARENCY_LEVELS-1]);
if (trans_mode != 0)
alphaTable.resize(palette.size() - cols[TRANSPARENCY_LEVELS-1]);
if (palette.size() > 16 )
{
// >16 && <=256 colors -> write 8-bit color depth
image_data_8 reduced_image(width,height);
reduce_8(image,reduced_image,trees, limits, alphaTable);
reduce_8(image, reduced_image, trees, limits, TRANSPARENCY_LEVELS, alphaTable);
save_as_png(file,palette,reduced_image,width,height,8,alphaTable);
}
else if (palette.size() == 1)
@ -424,8 +438,97 @@ namespace mapnik {
unsigned image_width = (int(0.5*width) + 3)&~3;
unsigned image_height = height;
image_data_8 reduced_image(image_width,image_height);
reduce_4(image,reduced_image,trees, limits, alphaTable);
reduce_4(image, reduced_image, trees, limits, TRANSPARENCY_LEVELS, alphaTable);
save_as_png(file,palette,reduced_image,width,height,4,alphaTable);
}
}
template <typename T1,typename T2>
void save_as_png256_hex(T1 & file, T2 const& image, int colors = 256, int trans_mode = -1, double gamma = 2.0)
{
unsigned width = image.width();
unsigned height = image.height();
// structure for color quantization
hextree<mapnik::rgba> tree(colors);
if (trans_mode >= 0)
tree.setTransMode(trans_mode);
if (gamma > 0)
tree.setGamma(gamma);
for (unsigned y = 0; y < height; ++y)
{
typename T2::pixel_type const * row = image.getRow(y);
for (unsigned x = 0; x < width; ++x)
{
unsigned val = row[x];
tree.insert(mapnik::rgba(U2RED(val), U2GREEN(val), U2BLUE(val), U2ALPHA(val)));
}
}
//transparency values per palette index
std::vector<mapnik::rgba> pal;
tree.create_palette(pal);
assert(pal.size() <= colors);
std::vector<mapnik::rgb> palette;
std::vector<unsigned> alphaTable;
for(unsigned i=0; i<pal.size(); i++)
{
palette.push_back(rgb(pal[i].r, pal[i].g, pal[i].b));
alphaTable.push_back(pal[i].a);
}
if (palette.size() > 16 )
{
// >16 && <=256 colors -> write 8-bit color depth
image_data_8 reduced_image(width, height);
for (unsigned y = 0; y < height; ++y)
{
mapnik::image_data_32::pixel_type const * row = image.getRow(y);
mapnik::image_data_8::pixel_type * row_out = reduced_image.getRow(y);
for (unsigned x = 0; x < width; ++x)
{
unsigned val = row[x];
mapnik::rgba c(U2RED(val), U2GREEN(val), U2BLUE(val), U2ALPHA(val));
row_out[x] = tree.quantize(c);
}
}
save_as_png(file, palette, reduced_image, width, height, 8, alphaTable);
}
else if (palette.size() == 1)
{
// 1 color image -> write 1-bit color depth PNG
unsigned image_width = (int(0.125*width) + 7)&~7;
unsigned image_height = height;
image_data_8 reduced_image(image_width, image_height);
reduced_image.set(0);
save_as_png(file, palette, reduced_image, width, height, 1, alphaTable);
}
else
{
// <=16 colors -> write 4-bit color depth PNG
unsigned image_width = (int(0.5*width) + 3)&~3;
unsigned image_height = height;
image_data_8 reduced_image(image_width, image_height);
for (unsigned y = 0; y < height; ++y)
{
mapnik::image_data_32::pixel_type const * row = image.getRow(y);
mapnik::image_data_8::pixel_type * row_out = reduced_image.getRow(y);
byte index = 0;
for (unsigned x = 0; x < width; ++x)
{
unsigned val = row[x];
mapnik::rgba c(U2RED(val), U2GREEN(val), U2BLUE(val), U2ALPHA(val));
index = tree.quantize(c);
if (x%2 == 0) index = index<<4;
row_out[x>>1] |= index;
}
}
save_as_png(file, palette, reduced_image, width, height, 4, alphaTable);
}
}
}

113
src/image_util.cpp
View file

@ -39,6 +39,9 @@ extern "C"
#include <mapnik/cairo_renderer.hpp>
#endif
#include <boost/foreach.hpp>
#include <boost/tokenizer.hpp>
// stl
#include <string>
#include <iostream>
@ -52,28 +55,7 @@ namespace mapnik
std::string const& type)
{
std::ostringstream ss(std::ios::out|std::ios::binary);
//all this should go into image_writer factory
if (type=="png") save_as_png(ss,image);
else if (type == "png256") save_as_png256(ss,image);
else if (boost::algorithm::istarts_with(type,std::string("jpeg")))
{
int quality = 85;
try
{
if(type.substr(4).length() != 0)
{
quality = boost::lexical_cast<int>(type.substr(4));
if(quality<1 || quality>100)
throw ImageWriterException("invalid jpeg quality: " + type.substr(4));
}
save_as_jpeg(ss,quality,image);
}
catch(boost::bad_lexical_cast &)
{
throw ImageWriterException("invalid jpeg quality: " + type.substr(4));
}
}
else throw ImageWriterException("unknown file type: " + type);
save_to_stream(image, ss, type);
return ss.str();
}
@ -84,10 +66,89 @@ namespace mapnik
{
std::ofstream file (filename.c_str(), std::ios::out| std::ios::trunc|std::ios::binary);
if (file)
{
save_to_stream(image, file, type);
}
else throw ImageWriterException("Could not write file to " + filename );
}
template <typename T>
void save_to_stream(T const& image,
std::ostream & stream,
std::string const& type)
{
if (stream)
{
//all this should go into image_writer factory
if (type=="png") save_as_png(file,image);
else if (type == "png256") save_as_png256(file,image);
if (type == "png") save_as_png(stream, image);
else if (boost::algorithm::istarts_with(type, std::string("png256")) ||
boost::algorithm::istarts_with(type, std::string("png8"))
)
{
int colors = 256;
int trans_mode = -1;
double gamma = -1;
bool use_octree = true;
if (type.length() > 6){
boost::char_separator<char> sep(":");
boost::tokenizer< boost::char_separator<char> > tokens(type, sep);
BOOST_FOREACH(string t, tokens)
{
if (t == "m=h")
{
use_octree = false;
}
if (t == "m=o")
{
use_octree = true;
}
if (boost::algorithm::istarts_with(t,std::string("c=")))
{
try
{
colors = boost::lexical_cast<int>(t.substr(2));
if (colors < 0 || colors > 256)
throw ImageWriterException("invalid color parameter: " + t.substr(2) + " out of bounds");
}
catch(boost::bad_lexical_cast &)
{
throw ImageWriterException("invalid color parameter: " + t.substr(2));
}
}
if (boost::algorithm::istarts_with(t, std::string("t=")))
{
try
{
trans_mode= boost::lexical_cast<int>(t.substr(2));
if (trans_mode < 0 || trans_mode > 2)
throw ImageWriterException("invalid trans_mode parameter: " + t.substr(2) + " out of bounds");
}
catch(boost::bad_lexical_cast &)
{
throw ImageWriterException("invalid trans_mode parameter: " + t.substr(2));
}
}
if (boost::algorithm::istarts_with(t, std::string("g=")))
{
try
{
gamma= boost::lexical_cast<double>(t.substr(2));
if (gamma < 0)
throw ImageWriterException("invalid gamma parameter: " + t.substr(2) + " out of bounds");
}
catch(boost::bad_lexical_cast &)
{
throw ImageWriterException("invalid gamma parameter: " + t.substr(2));
}
}
}
}
if (use_octree)
save_as_png256(stream, image, colors);
else
save_as_png256_hex(stream, image, colors, trans_mode, gamma);
}
else if (boost::algorithm::istarts_with(type,std::string("jpeg")))
{
int quality = 85;
@ -99,7 +160,7 @@ namespace mapnik
if(quality<0 || quality>100)
throw ImageWriterException("invalid jpeg quality: " + type.substr(4) + " out of bounds");
}
save_as_jpeg(file,quality,image);
save_as_jpeg(stream, quality, image);
}
catch(boost::bad_lexical_cast &)
{
@ -108,7 +169,7 @@ namespace mapnik
}
else throw ImageWriterException("unknown file type: " + type);
}
else throw ImageWriterException("Could not write file to " + filename );
else throw ImageWriterException("Could not write to empty stream" );
}