image.H

/*
 * This file is part of the "Archon" framework.
 * (http://files3d.sourceforge.net)
 *
 * Copyright © 2002 by Kristian Spangsege and Brian Kristiansen.
 *
 * Permission to use, copy, modify, and distribute this software and
 * its documentation under the terms of the GNU General Public License is
 * hereby granted. No representations are made about the suitability of
 * this software for any purpose. It is provided "as is" without express
 * or implied warranty. See the GNU General Public License
 * (http://www.gnu.org/copyleft/gpl.html) for more details.
 *
 * The characters in this file are ISO8859-1 encoded.
 *
 * The documentation in this file is in "Doxygen" style
 * (http://www.doxygen.org).
 */

#ifndef ARCHON_UTILITIES_IMAGE_H
#define ARCHON_UTILITIES_IMAGE_H

#include <stdio.h>
#include <string.h>
#include <string>

#include <archon/util/exception.H>
#include <archon/util/logger.H>
#include <archon/util/stream.H>
#include <archon/util/text.H>
#include <archon/util/muta_ref.H>
#include <archon/util/file.H>

namespace Archon
{
  namespace Utilities
  {
    using namespace std;

    struct Image
    {
      static const string PNG;  
      static const string TIFF; 
      static const string PNM;  
      static const string JPEG; 
      static const string GIF;  

      operator bool() const { return r; }

      enum ComponentSpecifier
      {
        components_l    = 1, 
        components_la   = 2, 
        components_rgb  = 3, 
        components_rgba = 4  
      };

      Image() {}

      Image(unsigned width, unsigned height,
            ComponentSpecifier components = components_rgba,
            unsigned bitsPerComponent = 8,
            string comment = "");

      unsigned getWidth()             const { return r->width;             }
      unsigned getHeight()            const { return r->height;            }
      unsigned getBitsPerComponent()  const { return r->bitsPerComponent;  }
      unsigned getCharsPerPixel()     const { return r->charsPerPixel;     }
      unsigned getCharsPerRow()       const { return r->charsPerRow;       }
      unsigned getMaxComponentValue() const { return r->maxComponentValue; }

      ComponentSpecifier getComponentSpecifier() const { return r->components; }

      string getComment() const { return r->comment; }

      void setComment(string c)
      {
        r.mutate(); r->comment = c;
      }

      const char *getPixelBuffer() const
      {
        return r->getPixelBuffer();
      }

      char *getPixelBuffer()
      {
        r.leak();
        return r->getPixelBuffer();
      }

      const char *getPixelPtr(int x, int y) const
      {
        return r->getPixelPtr(x, y);
      }

      char *getPixelPtr(int x, int y)
      {
        r.leak();
        return r->getPixelPtr(x, y);
      }

      void getPixel(int x, int y, unsigned &l) const
      {
        r->getPixel(x, y, l);
      }

      void setPixel(int x, int y, unsigned l)
      {
        r.mutate();
        r->setPixel(x, y, l);
      }

      void getPixel(int x, int y, unsigned &l, unsigned &a) const
      {
        r->getPixel(x, y, l, a);
      }

      void setPixel(int x, int y, unsigned l, unsigned a)
      {
        r.mutate();
        r->setPixel(x, y, l, a);
      }

      void getPixel(int x, int y, unsigned &r, unsigned &g, unsigned &b) const
      {
        this->r->getPixel(x, y, r, g, b);
      }

      void setPixel(int x, int y, unsigned r, unsigned g, unsigned b)
      {
        this->r.mutate();
        this->r->setPixel(x, y, r, g, b);
      }

      void getPixel(int x, int y, unsigned &r, unsigned &g,
                    unsigned &b, unsigned &a) const
      {
        this->r->getPixel(x, y, r, g, b, a);
      }

      void setPixel(int x, int y, unsigned r, unsigned g,
                    unsigned b, unsigned a)
      {
        this->r.mutate();
        this->r->setPixel(x, y, r, g, b, a);
      }

      void getPixel(int x, int y, double &l) const
      {
        r->getPixel(x, y, l);
      }

      void setPixel(int x, int y, double l)
      {
        r.mutate();
        r->setPixel(x, y, l);
      }

      void getPixel(int x, int y, double &l, double &a) const
      {
        r->getPixel(x, y, l, a);
      }

      void setPixel(int x, int y, double l, double a)
      {
        r.mutate();
        r->setPixel(x, y, l, a);
      }

      void getPixel(int x, int y, double &r, double &g, double &b) const
      {
        this->r->getPixel(x, y, r, g, b);
      }

      void setPixel(int x, int y, double r, double g, double b)
      {
        this->r.mutate();
        this->r->setPixel(x, y, r, g, b);
      }

      void getPixel(int x, int y, double &r, double &g,
                    double &b, double &a) const
      {
        this->r->getPixel(x, y, r, g, b, a);
      }

      void setPixel(int x, int y, double r, double g, double b, double a)
      {
        this->r.mutate();
        this->r->setPixel(x, y, r, g, b, a);
      }

      void swap(Image &i) { std::swap(r, i.r); }

      struct ImageException: virtual Exception {};

      struct UnknownFormatException: ImageException
      {
        UnknownFormatException(string l, string m): Exception(l, m) {}
      };

      struct InvalidFormatException: ImageException
      {
        InvalidFormatException(string l, string m): Exception(l, m) {}
      };

      struct ProgressTracker
      {
        virtual void progress(double fraction) throw() = 0;
        virtual ~ProgressTracker() {}
      };

      struct Format
      {
        virtual string getSpecifier() const = 0;

        virtual bool checkSignature(Ref<Stream::Reader>) const = 0;

        virtual bool checkSuffix(string suffix) const = 0;

        virtual Image load(Ref<Stream::Reader>, ProgressTracker *, Logger *) const
          throw(InvalidFormatException, IOException, UnexpectedException) = 0;

        virtual void save(Image, Ref<Stream::Writer>, ProgressTracker *, Logger *) const
          throw(IOException, UnexpectedException) = 0;

        virtual ~Format() {}

      protected:
        char *getPixelBufferNoLeak(const Image &i) const
        {
          return const_cast<char *>(i.getPixelBuffer());
        }
      };

      struct Context
      {
        virtual size_t getNumberOfFormats() const = 0;
        virtual const Format *getFormat(size_t index) const = 0;

        static const Context *get();

        virtual ~Context() {}
      };

      Image(Ref<Stream::Reader> r,
            string sourceName, string formatSpecifier = "",
            Logger *l = Logger::get(), const Context *c = 0)
        throw(UnknownFormatException, InvalidFormatException,
              IOException, UnexpectedException)
      {
        _load(r, sourceName, formatSpecifier, 0, l, c);
      }

      explicit Image(string filePath, string formatSpecifier = "",
                     Logger *l = Logger::get(), const Context *c = 0)
        throw(UnknownFormatException, InvalidFormatException,
              IOException, UnexpectedException)
      {
        _load(Stream::makeFileReader(filePath),
              File::nameOf(filePath), formatSpecifier, 0, l, c);
      }

      void load(Ref<Stream::Reader> r,
                string sourceName, string formatSpecifier = "",
                ProgressTracker *t = 0, Logger *l = Logger::get(),
                const Context *c = 0)
        throw(UnknownFormatException, InvalidFormatException,
              IOException, UnexpectedException)
      {
        _load(r, sourceName, formatSpecifier, t, l, c);
      }

      void load(string filePath, string formatSpecifier = "",
                ProgressTracker *t = 0, Logger *l = Logger::get(),
                const Context *c = 0)
        throw(UnknownFormatException, InvalidFormatException,
              IOException, UnexpectedException)
      {
        _load(Stream::makeFileReader(filePath),
              File::nameOf(filePath), formatSpecifier, t, l, c);
      }

      void save(Ref<Stream::Writer> w,
                string targetName, string formatSpecifier = "",
                ProgressTracker *t = 0, Logger *l = Logger::get(),
                const Context *c = 0) const
        throw(UnknownFormatException, IOException, UnexpectedException)
      {
        if(!r) ARCHON_THROW1(StateException, "Null image");
        _save(w, targetName, formatSpecifier, t, l, c);
      }

      void save(string filePath, string formatSpecifier = "",
                ProgressTracker *t = 0, Logger *l = Logger::get(),
                const Context *c = 0) const
        throw(UnknownFormatException, IOException, UnexpectedException)
      {
        if(!r) ARCHON_THROW1(StateException, "Null image");
        _save(Stream::makeFileWriter(filePath),
              File::nameOf(filePath), formatSpecifier, t, l, c);
      }

    private:
      struct Rep: MutaRefObjectBase
      {
        Rep(unsigned width, unsigned height,
            unsigned bitsPerComponent,
            unsigned charsPerPixel,
            unsigned charsPerRow,
            unsigned maxComponentValue,
            ComponentSpecifier components,
            string comment):
          width(width), height(height),
          bitsPerComponent(bitsPerComponent),
          charsPerPixel(charsPerPixel),
          charsPerRow(charsPerRow),
          maxComponentValue(maxComponentValue),
          components(components),
          comment(comment) {}

        unsigned width;
        unsigned height;
        unsigned bitsPerComponent;       // 1, 2, 4, 8, 16
        unsigned charsPerPixel;
        unsigned charsPerRow;
        unsigned maxComponentValue;
        ComponentSpecifier components;
        string comment; // UTF-8

        Rep *refClone() const;
        void refDelete() throw();

        char *getPixelBuffer()
        {
          return reinterpret_cast<char *>(this+1);
        }

        char *getPixelPtr(int x, int y)
        {
          return getPixelBuffer() + y*charsPerRow + x*charsPerPixel;
        }

        unsigned getComponent(char *pixel, unsigned component);
        void setComponent(char *pixel, unsigned component, unsigned v);

        void getPixel(int x, int y, unsigned &l);
        void setPixel(int x, int y, unsigned l);
        void getPixel(int x, int y, unsigned &l, unsigned &a);
        void setPixel(int x, int y, unsigned l, unsigned a);
        void getPixel(int x, int y, unsigned &r, unsigned &g, unsigned &b);
        void setPixel(int x, int y, unsigned r, unsigned g, unsigned b);
        void getPixel(int x, int y, unsigned &r, unsigned &g,
                      unsigned &b, unsigned &a);
        void setPixel(int x, int y, unsigned r, unsigned g,
                      unsigned b, unsigned a);

        double toFloat(unsigned v)
        {
          return double(v)/maxComponentValue;
        }

        unsigned fromFloat(double v)
        {
          if(v<0) v=0;
          else if(v>1) v=1;
          return unsigned(v*maxComponentValue+0.5);
        }

        void getPixel(int x, int y, double &l)
        {
          unsigned _l;
          getPixel(x, y, _l);
          l = toFloat(_l);
        }

        void setPixel(int x, int y, double l)
        {
          setPixel(x, y, fromFloat(l));
        }

        void getPixel(int x, int y, double &l, double &a)
        {
          unsigned _l, _a;
          getPixel(x, y, _l, _a);
          l = toFloat(_l);
          a = toFloat(_a);
        }

        void setPixel(int x, int y, double l, double a)
        {
          setPixel(x, y, fromFloat(l), fromFloat(a));
        }

        void getPixel(int x, int y, double &r, double &g, double &b)
        {
          unsigned _r, _g, _b;
          getPixel(x, y, _r, _g, _b);
          r = toFloat(_r);
          g = toFloat(_g);
          b = toFloat(_b);
        }

        void setPixel(int x, int y, double r, double g, double b)
        {
          setPixel(x, y, fromFloat(r), fromFloat(g), fromFloat(b));
        }

        void getPixel(int x, int y, double &r, double &g,
                      double &b, double &a)
        {
          unsigned _r, _g, _b, _a;
          getPixel(x, y, _r, _g, _b, _a);
          r = toFloat(_r);
          g = toFloat(_g);
          b = toFloat(_b);
          a = toFloat(_a);
        }

        void setPixel(int x, int y, double r, double g, double b, double a)
        {
          setPixel(x, y, fromFloat(r), fromFloat(g), fromFloat(b), fromFloat(a));
        }
      };

      MutaRef<Rep> r;

      void _load(Ref<Stream::Reader>,
                 string sourceName, string formatSpecifier,
                 ProgressTracker *, Logger *, const Context *)
        throw(UnknownFormatException, InvalidFormatException,
              IOException, UnexpectedException);

      void _save(Ref<Stream::Writer>,
                 string targetName, string formatSpecifier,
                 ProgressTracker *, Logger *, const Context *) const
        throw(UnknownFormatException, IOException, UnexpectedException);
    };
  }
}

#endif // ARCHON_UTILITIES_IMAGE_H

---