glcdgraphics: bug fix in glcd.c, moved methods Scale() and Blend() to image.c, added static methods for loading/saving image; showpic and convpic working again; convpic cleaned up; showpic: added parameters for scaling and centering image

1 files changed, 189 insertions, 0 deletions

diff --git a/glcdgraphics/image.c b/glcdgraphics/image.c
index 72003b1..1240b80 100644
--- a/glcdgraphics/image.c
+++ b/glcdgraphics/image.c
@@ -10,11 +10,17 @@
  * to the COPYING file distributed with this package.
  *
  * (c) 2004 Andreas Regel <andreas.regel AT powarman.de>
+ * (c) 2013 Wolfgang Astleitner <mrwastl AT users sourceforge net>
  */
 
 #include "bitmap.h"
 #include "image.h"
+#include "imagefile.h"
+#include "glcd.h"
+#include "pbm.h"
+#include "extformats.h"
 
+#include <string.h>
 
 namespace GLCD
 {
@@ -64,4 +70,187 @@ void cImage::Clear()
     lastChange = 0;
 }
 
+
+uint32_t cImage::Blend(uint32_t FgColour, uint32_t BgColour, uint8_t Level, double antiAliasGranularity) const
+{
+    if (antiAliasGranularity > 0.0)
+       Level = uint8_t(int(Level / antiAliasGranularity + 0.5) * antiAliasGranularity);
+    int Af = (FgColour & 0xFF000000) >> 24;
+    int Rf = (FgColour & 0x00FF0000) >> 16;
+    int Gf = (FgColour & 0x0000FF00) >>  8;
+    int Bf = (FgColour & 0x000000FF);
+    int Ab = (BgColour & 0xFF000000) >> 24;
+    int Rb = (BgColour & 0x00FF0000) >> 16;
+    int Gb = (BgColour & 0x0000FF00) >>  8;
+    int Bb = (BgColour & 0x000000FF);
+    int A = (Ab + (Af - Ab) * Level / 0xFF) & 0xFF;
+    int R = (Rb + (Rf - Rb) * Level / 0xFF) & 0xFF;
+    int G = (Gb + (Gf - Gb) * Level / 0xFF) & 0xFF;
+    int B = (Bb + (Bf - Bb) * Level / 0xFF) & 0xFF;
+    return (A << 24) | (R << 16) | (G << 8) | B;
+}
+
+bool cImage::Scale(uint16_t scalew, uint16_t scaleh, bool AntiAlias)
+{
+    if (! (scalew || scaleh) )
+        return false;
+
+    unsigned int orig_w = Width();
+    unsigned int orig_h = Height();
+
+    // one out of scalew/h == 0 ? -> auto aspect ratio
+    if (scalew && ! scaleh) {
+       scaleh = (uint16_t)( ((uint32_t)scalew * (uint32_t)orig_h) / (uint32_t)orig_w );
+    } else if (!scalew && scaleh) {
+       scalew = (uint16_t)( ((uint32_t)scaleh * (uint32_t)orig_w) / (uint32_t)orig_h );
+    }
+
+    cImage tempImg = cImage();
+    tempImg.SetWidth(scalew);
+    tempImg.SetHeight(scaleh);
+
+    // Scaling/Blending based on VDR / osd.c
+    // Fixed point scaling code based on www.inversereality.org/files/bitmapscaling.pdf
+    // by deltener@mindtremors.com
+    //
+    // slightly improved by Wolfgang Astleitner (modify factors and ratios so that scaled image is centered when upscaling)
+
+    double FactorX, FactorY;
+    int    RatioX,    RatioY;
+
+    if (!AntiAlias) {
+        FactorX = (double)scalew / (double)orig_w;
+        FactorY = (double)scaleh / (double)orig_h;
+        RatioX = (orig_w << 16) / scalew;
+        RatioY = (orig_h << 16) / scaleh;
+    } else {
+        FactorX = (double)scalew / (double)(orig_w-1);
+        FactorY = (double)scaleh / (double)(orig_h-1);
+        RatioX = ((orig_w-1) << 16) / scalew;
+        RatioY = ((orig_h-1) << 16) / scaleh;
+    }
+
+    bool downscale = (!AntiAlias || (FactorX <= 1.0 && FactorY <= 1.0));
+
+    for (unsigned int frame = 0; frame < Count() ; frame ++ ) {
+        cBitmap *b = new cBitmap(scalew, scaleh, GRAPHLCD_Transparent);
+
+        cBitmap *currFrame = GetBitmap(frame);
+
+        b->SetMonochrome(currFrame->IsMonochrome());
+
+        if (downscale) {
+            // Downscaling - no anti-aliasing:
+            const uint32_t *DestRow = b->Data();
+            int SourceY = 0;
+            for (int y = 0; y < scaleh; y++) {
+                int SourceX = 0;
+                const uint32_t *SourceRow = currFrame->Data() + (SourceY >> 16) * orig_w;
+                uint32_t *Dest = (uint32_t*) DestRow;
+                for (int x = 0; x < scalew; x++) {
+                    *Dest++ = SourceRow[SourceX >> 16];
+                    SourceX += RatioX;
+                }
+                SourceY += RatioY;
+                DestRow += scalew;
+            }
+        } else {
+            // Upscaling - anti-aliasing:
+            int SourceY = 0;
+            for (int y = 0; y < scaleh /*- 1*/; y++) {
+                int SourceX = 0;
+                int sy = SourceY >> 16;
+                uint8_t BlendY = 0xFF - ((SourceY >> 8) & 0xFF);
+                for (int x = 0; x < scalew /*- 1*/; x++) {
+                    int sx = SourceX >> 16;
+                    uint8_t BlendX = 0xFF - ((SourceX >> 8) & 0xFF);
+                    // TODO: antiAliasGranularity
+                    uint32_t c1 = Blend(currFrame->GetPixel(sx, sy),     currFrame->GetPixel(sx + 1, sy),     BlendX);
+                    uint32_t c2 = Blend(currFrame->GetPixel(sx, sy + 1), currFrame->GetPixel(sx + 1, sy + 1), BlendX);
+                    uint32_t c3 = Blend(c1, c2, BlendY);
+                    b->DrawPixel(x, y, c3);
+                    SourceX += RatioX;
+                }
+                SourceY += RatioY;
+            }
+        }
+        tempImg.AddBitmap(b);
+    }
+    // clear all bitmaps from this image
+    unsigned int temp_delay = Delay();
+    Clear();
+    // set new resolution
+    SetWidth(scalew);
+    SetHeight(scaleh);
+    SetDelay(temp_delay);
+    // re-add bitmaps from scaled image container
+    cBitmap * b;
+    cBitmap * tempb;
+    for (unsigned int frame = 0; frame < tempImg.Count(); frame ++) {
+      tempb = tempImg.GetBitmap(frame);
+      b = new cBitmap(scalew, scaleh, (uint32_t*)tempb->Data());
+      b->SetMonochrome(tempb->IsMonochrome());
+      AddBitmap(b);
+    }
+    return true;
+}
+
+
+/* static methods */
+bool cImage::LoadImage(cImage & image, const std::string & fileName) {
+    const std::string fext = GetFilenameExtension(fileName);
+    cImageFile* imgFile = NULL;
+    bool result = true;
+
+    if (fext == "PBM") {
+        imgFile = new cPBMFile();
+    } else if (fext == "GLCD") {
+        imgFile = new cGLCDFile();
+    } else {
+        imgFile = new cExtFormatFile();
+    }
+
+    uint16_t scale_w = 0;
+    uint16_t scale_h = 0;
+
+    if (!imgFile || (imgFile->LoadScaled(image, fileName, scale_w, scale_h) == false) )
+        result = false;
+
+    if (imgFile) delete imgFile;
+    return result;
+}
+
+
+bool cImage::SaveImage(cImage & image, const std::string & fileName) {
+    const std::string fext = GetFilenameExtension(fileName);
+    cImageFile* imgFile = NULL;
+    bool result = false;
+
+    if (fext == "PBM") {
+        imgFile = new cPBMFile();
+    } else if (fext == "GLCD") {
+        imgFile = new cGLCDFile();
+    } else {
+        imgFile = new cExtFormatFile();
+    }
+    if ( imgFile && imgFile->Save(image, fileName) )
+      result = true;
+
+    if (imgFile) delete imgFile;
+    return result;
+}
+
+
+const std::string cImage::GetFilenameExtension(const std::string & fileName) {
+    size_t pos = fileName.find_last_of('.');
+    std::string ext = "";
+    if (pos != std::string::npos) {
+      ext = fileName.substr(pos+1);
+      for (size_t i = 0; i < ext.size(); i++)
+        ext[i] = toupper(ext[i]);
+    }
+    return ext;
+}
+
+
 } // end of namespace