Changeset 1680

Timestamp:

03/11/10 18:16:17 (5 months ago)

Author:

dane

Message:

apply mapnik-0.7.1.mr.hextree2.diff (slighly modified to accept format='png:key=val' as well as format='png256:key=val' while still maintaining default behavior of just format 'png' or 'png256' - also updated rundemo.py with a few examples

Location:

branches/0.7.1-dev

Files:

• demo/python/rundemo.py (modified) (1 diff)
• include/mapnik/octree.hpp (modified) (1 diff)
• include/mapnik/png_io.hpp (modified) (18 diffs)
• src/image_util.cpp (modified) (5 diffs)

branches/0.7.1-dev/demo/python/rundemo.py

@@ -329 +329 @@
 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 'png: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', 'png:c=64:t=1')
+images_.append('demo64_binary_transparency.png')
+
+im.save('demo128_colors_hextree_no_alpha.png', 'png: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')

branches/0.7.1-dev/include/mapnik/octree.hpp

@@ -44 +44 @@
          byte g;
          byte b;
-         rgb(byte r_, byte b_, byte g_)
+         rgb(byte r_, byte g_, byte b_)
             : r(r_), g(g_), b(b_) {}
    };

branches/0.7.1-dev/include/mapnik/png_io.hpp

@@ -24 +24 @@
 #include <mapnik/global.hpp>
 #include <mapnik/octree.hpp>
+#include <mapnik/hextree.hpp>
 #include <mapnik/global.hpp>
 
@@ -31 +32 @@
 }
 
-// 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
@@ -63 +61 @@
       out->flush();
    }
-   
+
    template <typename T1, typename T2>
    void save_as_png(T1 & file , T2 const& image)
@@ -110 +108 @@
 
    template <typename T>
-   void reduce_8  (T const& in, ImageData8 & out, octree<rgb> trees[], unsigned limits[], std::vector<unsigned> & alpha)
+   void reduce_8  (T const& in, ImageData8 & out, octree<rgb> trees[], unsigned limits[], unsigned levels, std::vector<unsigned> & alpha)
    {
       unsigned width = in.width();
@@ -133 +131 @@
             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);
@@ -155 +153 @@
 
    template <typename T>
-   void reduce_4 (T const& in, ImageData8 & out, octree<rgb> trees[], unsigned limits[], std::vector<unsigned> & alpha)
+   void reduce_4 (T const& in, ImageData8 & out, octree<rgb> trees[], unsigned limits[], unsigned levels, std::vector<unsigned> & alpha)
    {
       unsigned width = in.width();
@@ -179 +177 @@
             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);
@@ -275 +273 @@
 
    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();
@@ -288 +289 @@
          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;
@@ -297 +300 @@
 
       // 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;
@@ -321 +324 @@
       }
       // 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++){
@@ -334 +337 @@
       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)
@@ -360 +373 @@
             
             // 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)));
@@ -370 +383 @@
       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) {
@@ -384 +397 @@
             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();
@@ -397 +410 @@
       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 )
@@ -403 +417 @@
          // >16 && <=256 colors -> write 8-bit color depth
          ImageData8 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);
       }
@@ -425 +439 @@
          unsigned image_height = height;
          ImageData8 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
+          ImageData8 reduced_image(width, height);
+
+          for (unsigned y = 0; y < height; ++y)
+          {
+             mapnik::ImageData32::pixel_type const * row = image.getRow(y);
+             mapnik::ImageData8::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;
+         ImageData8 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;
+         ImageData8 reduced_image(image_width, image_height);
+          for (unsigned y = 0; y < height; ++y)
+          {
+             mapnik::ImageData32::pixel_type const * row = image.getRow(y);
+             mapnik::ImageData8::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);
+      }
+   }   
 }

branches/0.7.1-dev/src/image_util.cpp

@@ -40 +40 @@
 #endif
 
+#include <boost/foreach.hpp>
+#include <boost/tokenizer.hpp>
+
 // stl
 #include <string>
@@ -53 +56 @@
     {
         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();
     }
@@ -86 +68 @@
         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("png:"))
+                     ) 
+            {
+                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")))
             {
@@ -100 +161 @@
                             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 &)
@@ -109 +170 @@
             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" );
     }