ninepatch.cc

Go to the documentation of this file.

#include "ion/image/ninepatch.h"

#include <algorithm>

#include "base/integral_types.h"
#include "ion/base/allocationmanager.h"
#include "ion/base/datacontainer.h"
#include "ion/base/logging.h"

namespace ion {
namespace image {

namespace {

using base::DataContainer;
using base::DataContainerPtr;
using gfx::Image;
using gfx::ImagePtr;
using math::Point2f;
using math::Point2ui;
using math::Range1ui;
using math::Range2f;
using math::Range2ui;
using math::Vector2f;
using math::Vector2ui;

typedef base::AllocMap<uint32, uint32> RegionMap;

static const uint32 kMarked = 0xff000000;

static void ReadStretchRegions(const ImagePtr& image, RegionMap* regions,
                               uint32 length, uint32 stride) {
  bool in_stretch_region = false;
  uint32 stretch_region_start = 0;

  DCHECK_EQ(Image::kRgba8888, image->GetFormat());
  const uint32* data = image->GetData()->GetData<uint32>();
  for (uint32 i = 1U; i < length - 1U; ++i) {
    const bool marked = data[i * stride] == kMarked;
    if (marked && !in_stretch_region) {
      stretch_region_start = i;
      in_stretch_region = true;
    } else if (!marked && in_stretch_region) {
      (*regions)[stretch_region_start] = i - stretch_region_start;
      in_stretch_region = false;
    }
  }
  if (in_stretch_region)
    (*regions)[stretch_region_start] = (length - 1) - stretch_region_start;
}

static Range2ui ReadPaddingBox(const ImagePtr& image) {
  Point2ui start;
  Point2ui end;
  Range2ui box;

  DCHECK_EQ(Image::kRgba8888, image->GetFormat());
  const uint32* data = image->GetData()->GetData<uint32>();
  const uint32 width = image->GetWidth();
  const uint32 height = image->GetHeight();
  const uint32* row = &data[width * (height - 1U)];
  const uint32* col = &data[width - 1U];

  for (uint32 x = 1U; x < width - 1U; ++x) {
    if (row[x] == kMarked) {
      if (!start[0])
        start[0] = x;
      end[0] = x;
    }
  }
  for (uint32 y = 1U; y < height - 1U; ++y) {
    if (col[width * y] == kMarked) {
      if (!start[1])
        start[1] = y;
      end[1] = y;
    }
  }
  if (start != Point2ui::Zero() || end != Point2ui::Zero()) {
    ++end[0];
    ++end[1];
    box.Set(start, end);
  }
  return box;
}

static uint32 GetPixel(const ImagePtr& image, uint32 x, uint32 y) {
  if (x < image->GetWidth() && y < image->GetHeight()) {
    const uint32* pixels = image->GetData()->GetData<uint32>();
    return pixels[y * image->GetWidth() + x];
  }
  return 0U;
}

static void SetPixel(const ImagePtr& image, uint32 x, uint32 y, uint32 value) {
  if (x < image->GetWidth() && y < image->GetHeight()) {
    uint32* pixels = image->GetData()->GetMutableData<uint32>();
    pixels[y * image->GetWidth() + x] = value;
  }
}

static void CopyRegion(const Range2ui& source_rect, const Range2f& dest_rect,
                       const ImagePtr& source, const ImagePtr& dest) {
  const Point2f source_start(static_cast<float>(source_rect.GetMinPoint()[0]),
                             static_cast<float>(source_rect.GetMinPoint()[1]));
  const Point2ui& source_end = source_rect.GetMaxPoint();
  const Vector2f source_size(
      static_cast<float>(source_end[0]) - source_start[0],
      static_cast<float>(source_end[1]) - source_start[1]);
  const Point2f& dest_start_f = dest_rect.GetMinPoint();
  const Point2f& dest_end_f = dest_rect.GetMaxPoint();
  const Vector2f inv_dest_size(1.f / (dest_end_f[0] - dest_start_f[0]),
                               1.f / (dest_end_f[1] - dest_start_f[1]));
  const Vector2ui dest_start(static_cast<uint32>(dest_start_f[0]),
                             static_cast<uint32>(dest_start_f[1]));
  const Vector2ui dest_end(static_cast<uint32>(dest_end_f[0]),
                           static_cast<uint32>(dest_end_f[1]));

  for (uint32 y = dest_start[1]; y < dest_end[1]; ++y) {
    const float y_distance =
        static_cast<float>(y - dest_start[1]) * inv_dest_size[1];
    const uint32 source_y =
        static_cast<uint32>(source_start[1] + y_distance * source_size[1]);
    DCHECK_LT(source_y, source_end[1]);
    for (uint32 x = dest_start[0]; x < dest_end[0]; ++x) {
      const float x_distance =
          static_cast<float>(x - dest_start[0]) * inv_dest_size[0];
      const uint32 source_x =
          static_cast<uint32>(source_start[0] + x_distance * source_size[0]);
      DCHECK_LT(source_x, source_end[0]);
      const uint32 value = GetPixel(source, source_x, source_y);
      SetPixel(dest, x, y, value);
    }
  }
}

}  // anonymous namespace

struct NinePatch::Region {
  Region() : stretch_h(false), stretch_v(false) {}
  Region(const Point2ui& source_start, const Point2f& dest_start)
      : stretch_h(false), stretch_v(false) {
    source.SetMinPoint(source_start);
    dest.SetMinPoint(dest_start);
  }

  bool stretch_h;
  bool stretch_v;
  Range2ui source;
  Range2f dest;
};

NinePatch::NinePatch(const ImagePtr& image)
    : regions_h_(*this), regions_v_(*this), wipeable_(true) {
  if (image.Get() && image->GetWidth() && image->GetHeight() &&
      image->GetFormat() == Image::kRgba8888 && image->GetData().Get() &&
      image->GetData()->GetData()) {
    image_ = image;
    ReadStretchRegions(image_, &regions_v_, image_->GetWidth(), 1U);
    ReadStretchRegions(image_, &regions_h_, image_->GetHeight(),
                       image_->GetWidth());
    padding_ = ReadPaddingBox(image_);
  }
}

NinePatch::~NinePatch() {}

const ImagePtr NinePatch::BuildImage(uint32 width, uint32 height,
                                     const base::AllocatorPtr& alloc) const {
  base::AllocatorPtr allocator =
      base::AllocationManager::GetNonNullAllocator(alloc);

  ImagePtr output(new (allocator) Image);
  const uint32 length = 4U * width * height;
  uint32* pixels = reinterpret_cast<uint32*>(allocator->AllocateMemory(length));
  output->Set(Image::kRgba8888, width, height,
             DataContainer::Create<uint32>(
                 pixels, std::bind(DataContainer::AllocatorDeleter, allocator,
                                   std::placeholders::_1),
                                   wipeable_, allocator));
  memset(pixels, 0, length);

  if (image_.Get()) {
    const base::AllocVector<Region> regions = GetRegionsForSize(width, height);
    const size_t count = regions.size();
    for (size_t i = 0; i < count; ++i)
      CopyRegion(regions[i].source, regions[i].dest, image_, output);
  }
  return output;
}

const Vector2ui NinePatch::GetMinimumSize() const {
  Vector2ui min_size(2U, 2U);
  if (image_.Get()) {
    min_size.Set(image_->GetWidth(), image_->GetHeight());
    for (RegionMap::const_iterator it = regions_v_.begin();
         it != regions_v_.end(); ++it)
      min_size[0] -= it->second;
    for (RegionMap::const_iterator it = regions_h_.begin();
         it != regions_h_.end(); ++it)
      min_size[1] -= it->second;

    min_size[0] = std::max(2U, min_size[0]);
    min_size[1] = std::max(2U, min_size[1]);
  }
  return min_size - Vector2ui(2U, 2U);
}

const Range2ui NinePatch::GetPaddingBox(uint32 width, uint32 height) const {
  if (padding_.IsEmpty() || !image_.Get()) {
    return Range2ui(Point2ui::Zero(), Point2ui(width, height));
  }
  const Vector2ui min_size = GetMinimumSize();
  const Vector2ui clamped_size(std::max(min_size[0], width),
                               std::max(min_size[1], height));
  const Vector2ui natural_size(image_->GetWidth() - 2U,
                               image_->GetHeight() - 2U);
  Range2ui box(padding_.GetMinPoint() - Vector2ui(1U, 1U),
               padding_.GetMaxPoint() - Vector2ui(1U, 1U));
  const Vector2ui offset(clamped_size[0] - natural_size[0],
                         clamped_size[1] - natural_size[1]);
  box.SetMaxPoint(box.GetMaxPoint() + offset);
  return box;
}

const Vector2ui NinePatch::GetSizeToFitContent(
    uint32 content_width, uint32 content_height) const {
  if (padding_.IsEmpty() || !image_.Get()) {
    return Vector2ui(content_width, content_height);
  }
  const Vector2ui natural_size(image_->GetWidth() - 2U,
                               image_->GetHeight() - 2U);
  const Vector2ui natural_pad_size = padding_.GetSize();

  const Vector2ui size(natural_size[0] + content_width - natural_pad_size[0],
                       natural_size[1] + content_height - natural_pad_size[1]);

  const Vector2ui min_size = GetMinimumSize();
  const Vector2ui clamped_size(std::max(min_size[0], size[0]),
                               std::max(min_size[1], size[1]));
  return clamped_size;
}

const base::AllocVector<NinePatch::Region> NinePatch::GetRegionsForSize(
    uint32 width, uint32 height) const {
  DCHECK(image_.Get());
  base::AllocVector<Region> regions(*this);

  const Vector2ui min_size = GetMinimumSize();
  const Vector2ui natural_size(image_->GetWidth(), image_->GetHeight());

  if (natural_size[0] == 2U + min_size[0] ||
      natural_size[1] == 2U + min_size[1])
    return regions;

  const Point2f stretch_ratio(
      static_cast<float>(width - min_size[0]) /
          static_cast<float>(natural_size[0] - 2U - min_size[0]),
      static_cast<float>(height - min_size[1]) /
          static_cast<float>(natural_size[1] - 2U - min_size[1]));
  Point2ui next_stretch(0U, 0U);
  Point2f next_dest(0.f, 0.f);

  uint32 region_start_y = 1;
  while (region_start_y < natural_size[1] - 1U) {
    uint32 region_start_x = 1;
    RegionMap::const_iterator y_iter = regions_h_.lower_bound(region_start_y);
    if (y_iter == regions_h_.end()) {
      next_stretch[1] = natural_size[1] - 1U;
    } else {
      next_stretch[1] = y_iter->first;
    }
    while (region_start_x < natural_size[0] - 1U) {
      RegionMap::const_iterator x_iter = regions_v_.lower_bound(region_start_x);
      if (x_iter == regions_v_.end()) {
        next_stretch[0] = natural_size[0] - 1U;
      } else {
        next_stretch[0] = x_iter->first;
      }

      const bool is_static_region_x = region_start_x < next_stretch[0];
      const bool is_static_region_y = region_start_y < next_stretch[1];

      Vector2ui source_size;
      Vector2f dest_size;
      Region region(Point2ui(region_start_x, region_start_y),
                    Point2f(next_dest[0], next_dest[1]));
      if (is_static_region_x) {
        region.stretch_h = false;
        source_size[0] = next_stretch[0] - region_start_x;
        dest_size[0] = static_cast<float>(source_size[0]);
        region_start_x = next_stretch[0];
      } else {
        region.stretch_h = true;
        source_size[0] = regions_v_.find(region_start_x)->second;
        dest_size[0] = static_cast<float>(source_size[0]) * stretch_ratio[0];
        region_start_x += regions_v_.find(region_start_x)->second;
      }
      if (is_static_region_y) {
        region.stretch_v = false;
        source_size[1] = next_stretch[1] - region_start_y;
        dest_size[1] = static_cast<float>(source_size[1]);
      } else {
        region.stretch_v = true;
        source_size[1] = regions_h_.find(region_start_y)->second;
        dest_size[1] = static_cast<float>(source_size[1]) * stretch_ratio[1];
      }

      region.source.SetMaxPoint(region.source.GetMinPoint() + source_size);
      region.dest.SetMaxPoint(region.dest.GetMinPoint() + dest_size);

      next_dest[0] += dest_size[0];

      regions.push_back(region);
    }
    next_dest[0] = 0.0;
    next_dest[1] += regions.back().dest.GetSize()[1];
    const bool is_static_region_y = region_start_y < next_stretch[1];
    if (is_static_region_y)
      region_start_y = next_stretch[1];
    else
      region_start_y += regions_h_.find(region_start_y)->second;
  }
  return regions;
}

}  // namespace image
}  // namespace ion