image_bits.h

// Aseprite Document Library
// Copyright (C) 2019  Igara Studio S.A.
// Copyright (C) 2001-2014  David Capello
//
// This file is released under the terms of the MIT license.
// Read LICENSE.txt for more information.

#ifndef DOC_IMAGE_BITS_H_INCLUDED
#define DOC_IMAGE_BITS_H_INCLUDED
#pragma once

#include <algorithm>

namespace doc {

  class Image;
  template<typename ImageTraits> class ImageIterator;
  template<typename ImageTraits> class ImageConstIterator;

  template<typename ImageTraits>
  class ImageBits {
  public:
    typedef typename ImageTraits::address_t address_t;
    typedef ImageIterator<ImageTraits> iterator;
    typedef ImageConstIterator<ImageTraits> const_iterator;

    ImageBits() :
      m_image(NULL),
      m_bounds(0, 0, 0, 0) {
    }

    ImageBits(const ImageBits& other) :
      m_image(other.m_image),
      m_bounds(other.m_bounds) {
    }

    ImageBits(Image* image, const gfx::Rect& bounds) :
      m_image(image),
      m_bounds(bounds) {
      ASSERT(bounds.x >= 0 && bounds.x+bounds.w <= image->width() &&
             bounds.y >= 0 && bounds.y+bounds.h <= image->height());
    }

    ImageBits& operator=(const ImageBits& other) {
      m_image = other.m_image;
      m_bounds = other.m_bounds;
      return *this;
    }

    // Iterate over the full area.
    iterator begin() {
      return iterator(m_image, m_bounds, m_bounds.x, m_bounds.y);
    }
    iterator end() {
      iterator it(m_image, m_bounds, m_bounds.x+m_bounds.w-1, m_bounds.y+m_bounds.h-1);
      ++it;
      return it;
    }

    const_iterator begin() const {
      return const_iterator(m_image, m_bounds, m_bounds.x, m_bounds.y);
    }
    const_iterator end() const {
      const_iterator it(m_image, m_bounds, m_bounds.x+m_bounds.w-1, m_bounds.y+m_bounds.h-1);
      ++it;
      return it;
    }

    // Iterate over a sub-area.
    iterator begin_area(const gfx::Rect& area) {
      ASSERT(m_bounds.contains(area));
      return iterator(m_image, area, area.x, area.y);
    }
    iterator end_area(const gfx::Rect& area) {
      ASSERT(m_bounds.contains(area));
      iterator it(m_image, area, area.x+area.w-1, area.y+area.h-1);
      ++it;
      return it;
    }

    const_iterator begin_area(const gfx::Rect& area) const {
      ASSERT(m_bounds.contains(area));
      return const_iterator(m_image, area, area.x, area.y);
    }
    const_iterator end_area(const gfx::Rect& area) const {
      ASSERT(m_bounds.contains(area));
      const_iterator it(m_image, area, area.x+area.w-1, area.y+area.h-1);
      ++it;
      return it;
    }

    Image* image() const { return m_image; }
    const gfx::Rect& bounds() { return m_bounds; }

    Image* image() { return m_image; }

    void unlock() {
      if (m_image) {
        m_image->unlockBits(*this);
        m_image = NULL;
      }
    }

  private:
    Image* m_image;
    gfx::Rect m_bounds;
  };

  template<typename ImageTraits>
  class LockImageBits {
  public:
    typedef ImageBits<ImageTraits> Bits;
    typedef typename Bits::iterator iterator;
    typedef typename Bits::const_iterator const_iterator;

    explicit LockImageBits(const Image* image)
      : m_bits(image->lockBits<ImageTraits>(Image::ReadLock, image->bounds())) {
    }

    LockImageBits(const Image* image, const gfx::Rect& bounds)
      : m_bits(image->lockBits<ImageTraits>(Image::ReadLock, bounds)) {
    }

    LockImageBits(Image* image, Image::LockType lockType)
      : m_bits(image->lockBits<ImageTraits>(lockType, image->bounds())) {
    }

    LockImageBits(Image* image, Image::LockType lockType, const gfx::Rect& bounds)
      : m_bits(image->lockBits<ImageTraits>(lockType, bounds)) {
    }

    ~LockImageBits() {
      m_bits.image()->unlockBits(m_bits);
    }

    // Iterators.
    iterator begin() { return m_bits.begin(); }
    iterator end() { return m_bits.end(); }
    const_iterator begin() const { return m_bits.begin(); }
    const_iterator end() const { return m_bits.end(); }

    iterator begin_area(const gfx::Rect& area) { return m_bits.begin_area(area); }
    iterator end_area(const gfx::Rect& area) { return m_bits.end_area(area); }
    const_iterator begin_area(const gfx::Rect& area) const { return m_bits.begin_area(area); }
    const_iterator end_area(const gfx::Rect& area) const { return m_bits.end_area(area); }

    const Image* image() const { return m_bits.image(); }
    const gfx::Rect& bounds() const { return m_bits.bounds(); }

    Image* image() { return m_bits.image(); }

  private:
    Bits m_bits;

    LockImageBits();            // Undefined
  };

  template<class ImageTraits,
           class UnaryFunction>
  inline void for_each_pixel(const Image* image, UnaryFunction f) {
    const LockImageBits<ImageTraits> bits(image);
    std::for_each(bits.begin(), bits.end(), f);
  }

  template<class ImageTraits,
           class UnaryOperation>
  inline void transform_image(Image* image, UnaryOperation f) {
    LockImageBits<ImageTraits> bits(image);
    std::transform(bits.begin(), bits.end(), bits.begin(), f);
  }

} // namespace doc

#endif