hexpainter.h

[詳解]

/*
 * Copyright 2016-2021 oZ/acy (名賀月晃嗣)
 * Redistribution and use in source and binary forms, 
 *     with or without modification, 
 *   are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 *    this list of conditions and the following disclaimer in the documentation
 *    and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, 
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 */
#ifndef INCLUDE_GUARD_EUNOMIA_HEX_PAINTER_H
#define INCLUDE_GUARD_EUNOMIA_HEX_PAINTER_H
 
#include <algorithm>
#include <cmath>
#include <cstdlib>
#include "imagebuffer.h"
 
namespace eunomia
{
template<class C_>
class HexPainter
{
private:
  int r_; 
  int p0_; 
  int q0_; 
 
  static inline const double SQRT3_ = std::sqrt(3);
 
public:
  HexPainter(int r, int p0, int q0) noexcept : r_(r), p0_(p0), q0_(q0) {}
 
  void resetOrigin(int p0, int q0) noexcept
  {
    p0_ = p0;
    q0_ = q0;
  }
 
  void resetRadius(int r) noexcept { r_ = r; }
 
  void getOrigin(int& p, int& q) const noexcept
  {
    p = p0_;
    q = q0_;
  }
 
  int getRadius() const noexcept { return r_; }
 
  void draw(ImageBuffer<C_>& pict, int x, int y, const C_& color);
 
  void draw(ImageBuffer<C_>& pict, int x, int y, int w, int h, const C_& color);
 
  void fill(ImageBuffer<C_>& pict, int x, int y, const C_& color);
 
  void fill(ImageBuffer<C_>& pict, int x, int y, int w, int h, const C_& color);
 
  void getHexPosition(int p, int q, int& x, int& y);
 
  void getPixelPosition(int x, int y, int& p, int& q)
  {
    p = SQRT3_ * r_ * (x + 0.5 * (y % 2)) + p0_;
    q = (3.0 * y * r_) / 2.0 + q0_;
  }
 
  void getPixelPosition(int x, int y, double& p, double& q)
  {
    p = SQRT3_ * r_ * (x + 0.5 * (y % 2)) + p0_;
    q = (3.0 * y * r_) / 2.0 + q0_;
  }
 
  int distance(int x0, int y0, int x1, int y1)
  {
    int y0_2 = y0 / 2;
    if (y0 < 0)
      y0_2 -= 1;
  
    int y1_2 = y1 / 2;
    if (y1 < 0)
      y1_2 -= 1;
  
    int a = std::abs(x1 - x0 - y1_2 + y0_2);
    int b = std::abs(y1 - y0);
    int c = std::abs(x1 + y1 - y1_2 - x0 - y0 + y0_2);
  
    return std::max({a, b, c});
  }
 
private:
  void
  calcVertex_(
    int& p1, int& p2, int& q1, int& q2, int& q3, int &q4,
    double p, double q)
  {
    // 頂點の座標: なほ、(p, q)は中心の座標
    //
    //          (p, q1)
    // (p1, q2)         (p2, q2)
    //          (p, q)
    // (p1, q3)         (p2, q3)
    //          (p, q4)
    //double p, q;
    p1 = p - SQRT3_ * r_ / 2.0;
    p2 = p + SQRT3_ * r_ / 2.0;
 
    q1 = q - r_;
    q2 = q - r_ / 2.0;
    q3 = q + r_ / 2.0;
    q4 = q + r_;
  }
 
  void fillLeftHalf_(ImageBuffer<C_>& pict, int x, int y, const C_& color);
  void fillRightHalf_(ImageBuffer<C_>& pict, int x, int y, const C_& color);
};
 
 
 
 
template<class C_>
inline
void
HexPainter<C_>::draw(ImageBuffer<C_>& pict, int x, int y, const C_& color)
{
  double p, q;
  getPixelPosition(x, y, p, q);
 
  int p1, p2;
  int q1, q2, q3, q4;
  calcVertex_(p1, p2, q1, q2, q3, q4, p, q);
 
  // 座標を求めた後は直線を引く
  pict.line(p1, q2, p, q1, color);
  pict.line(p1, q2, p1, q3, color);
  pict.line(p1, q3, p, q4, color);
  pict.line(p2, q2, p, q1, color);
  pict.line(p2, q2, p2, q3, color);
  pict.line(p2, q3, p, q4, color);
}
 
 
template<class C_>
inline
void
HexPainter<C_>::draw(
  ImageBuffer<C_>& pict, int x, int y, int w, int h, const C_& color)
{
  double p, q;
  int p1, p2, q1, q2, q3, q4;
 
  for (int j = 0; j < h; j++) {
 
    // 左端のみ必要な描畫
    if ((y + j) % 2 == 0) {
      getPixelPosition(x, y + j, p, q);
      calcVertex_(p1, p2, q1, q2, q3, q4, p, q);
      pict.line(p1, q3, p, q4, color);  // 左下斜め
    }
 
    // いつも必要な描畫
    for (int i = 0; i < w; i++) {
      getPixelPosition(x + i, y + j, p, q);
      calcVertex_(p1, p2, q1, q2, q3, q4, p, q);
 
      pict.line(p1, q2, p, q1, color);  //左上斜め
      pict.line(p1, q2, p1, q3, color); //左端
      pict.line(p2, q2, p, q1, color);  //右上斜め
    }
    
    // 右端のみ必要な描畫
    getPixelPosition(x + w - 1, y + j, p, q);
    calcVertex_(p1, p2, q1, q2, q3, q4, p, q);
    pict.line(p2, q2, p2, q3, color);  // 右端
    if ((y + j) % 2 == 1) {
      pict.line(p2, q3, p, q4, color); // 右下斜め
    }
  }
 
  // 下端で必要な描畫
  for (int i = 0; i < w; i++) {
    getPixelPosition(x + i, y + h - 1, p, q);
    calcVertex_(p1, p2, q1, q2, q3, q4, p, q);
    pict.line(p1, q3, p, q4, color);  // 左下斜め
    pict.line(p2, q3, p, q4, color); // 右下斜め
  }
}
 
 
template<class C_>
inline
void
HexPainter<C_>::fill(ImageBuffer<C_>& pict, int x, int y, const C_& color)
{
  fillLeftHalf_(pict, x, y, color);
  fillRightHalf_(pict, x, y, color);
}
 
template<class C_>
inline
void
HexPainter<C_>::fillLeftHalf_(
  ImageBuffer<C_>& pict, int x, int y, const C_& color)
{
  // 頂點の座標の算出
  double p, q;
  getPixelPosition(x, y, p, q);
  int p1, p2;
  int q1, q2, q3, q4;
  calcVertex_(p1, p2, q1, q2, q3, q4, p, q);
 
  // 塗り潰し
  int dp = (int)p - p1;
  int dq1 = q2 - q1;
  int dq2 = q4 - q3;
 
  int pp1 = p1;
  int pp2 = p;
  int qq1 = q2;
  int qq2 = q1;
  int qq3 = q3;
  int qq4 = q4;
 
  int e1 = -dp;
  int e2 = -dp;
  int lx = (dp + 1) / 2;
  for (int i = 0; i < lx; i++) {
    pict.line(pp1, qq1, pp1, qq3, color);
    pict.line(pp2, qq2, pp2, qq4, color);
 
    pp1++;
    pp2--;
 
    e1 += 2 * dq1;
    if (e1 >= 0) {
      qq1--;
      qq2++;
      e1 -= 2 * dp;
    }
    e2 += 2 * dq2;
    if (e2 >= 0) {
      qq3++;
      qq4--;
      e2 -= 2 * dp;
    }
  }
  if (!(dp % 2))
    pict.line(pp1, qq1, pp1, qq3, color);
}
 
template<class C_>
inline
void
HexPainter<C_>::fillRightHalf_(
  ImageBuffer<C_>& pict, int x, int y, const C_& color)
{
  // 頂點の座標の算出
  double p, q;
  getPixelPosition(x, y, p, q);
  int p1, p2;
  int q1, q2, q3, q4;
  calcVertex_(p1, p2, q1, q2, q3, q4, p, q);
 
  // 塗り潰し
  int dp = p2 - (int)p;
  int dq1 = q2 - q1;
  int dq2 = q4 - q3;
  int pp1 = p;
  int pp2 = p2;
  int qq1 = q1;
  int qq2 = q2;
  int qq3 = q4;
  int qq4 = q3;
 
  int e1 = -dp;
  int e2 = -dp;
  int lx = (dp + 1) / 2;
  for (int i = 0; i < lx; i++) {
    pict.line(pp1, qq1, pp1, qq3, color);
    pict.line(pp2, qq2, pp2, qq4, color);
 
    pp1++;
    pp2--;
 
    e1 += 2 * dq1;
    if (e1 >= 0) {
      qq1++;
      qq2--;
      e1 -= 2 * dp;
    }
    e2 += 2 * dq2;
    if (e2 >= 0) {
      qq3--;
      qq4++;
      e2 -= 2 * dp;
    }
  }
  if (!(dp % 2))
    pict.line(pp1, qq1, pp1, qq3, color);
}
 
 
template<class C_>
inline
void
HexPainter<C_>::fill(
  ImageBuffer<C_>& pict, int x, int y, int w, int h, const C_& color)
{
  // 使ひ廻す變數
  double p, q;
  int p1, p2;
  int q1, q2, q3, q4;
 
  // 中央の「箱」の塗り潰し
  int pbox0, qbox0, pbox1, qbox1;
  if (y % 2 == 0) {
    getPixelPosition(x, y, p, q);
    calcVertex_(p1, p2, q1, q2, q3, q4, p, q);
    pbox0 = p;
    qbox0 = q2;
 
    getPixelPosition(x + w - 1, y, p, q);
    calcVertex_(p1, p2, q1, q2, q3, q4, p, q);
    pbox1 = p2;
 
    getPixelPosition(x + w - 1, y + h - 1, p, q);
    calcVertex_(p1, p2, q1, q2, q3, q4, p, q);
    qbox1 = q3;
  } else {
    getPixelPosition(x, y, p, q);
    calcVertex_(p1, p2, q1, q2, q3, q4, p, q);
    pbox0 = p1;
    qbox0 = q2;
 
    getPixelPosition(x + w - 1, y, p, q);
    calcVertex_(p1, p2, q1, q2, q3, q4, p, q);
    pbox1 = p;
 
    getPixelPosition(x + w - 1, y + h - 1, p, q);
    calcVertex_(p1, p2, q1, q2, q3, q4, p, q);
    qbox1 = q3;
  }
  pict.box(pbox0, qbox0, pbox1, qbox1, color, true);
 
  // 左端の塗り潰し
  for (int j = 0; j < h; j++) {
    if ((y + j) % 2 == 0) {
      fillLeftHalf_(pict, x, y + j, color);
    }
  }
 
  // 右端の塗り潰し
  for (int j = 0; j < h; j++) {
    if ((y + j) % 2 != 0) {
      fillRightHalf_(pict, x + w - 1, y + j, color);
    }
  }
 
  for (int i = 0; i < w; i++) {
    int dp, dq; //dq1, dq2;
    int pp1, pp2, qq1, qq2; //, qq3, qq4;
    int e, lx;
 
    // 上端三角形の塗り潰し
    getPixelPosition(x + i, y, p, q);
    calcVertex_(p1, p2, q1, q2, q3, q4, p, q);
 
    dp = (int)p - p1;
    dq = q2 - q1;
 
    pp1 = p1;
    pp2 = p;
    qq1 = q2;
    qq2 = q1;
 
    e = -dp;
    lx = (dp + 1) / 2;
    for (int i = 0; i < lx; i++) {
      pict.line(pp1, qq1, pp1, q2, color);
      pict.line(pp2, qq2, pp2, q2, color);
 
      pp1++;
      pp2--;
      e += 2 * dq;
      if (e >= 0) {
        qq1--;
        qq2++;
        e -= 2 * dp;
      }
    }
    if (!(dp % 2))
      pict.line(pp1, qq1, pp1, q2, color);
 
    dp = p2 - (int)p;
    pp1 = p;
    pp2 = p2;
    qq1 = q1;
    qq2 = q2;
 
    e = -dp;
    lx = (dp + 1) / 2;
    for (int i = 0; i < lx; i++) {
      pict.line(pp1, qq1, pp1, q2, color);
      pict.line(pp2, qq2, pp2, q2, color);
 
      pp1++;
      pp2--;
 
      e += 2 * dq;
      if (e >= 0) {
        qq1++;
        qq2--;
        e -= 2 * dp;
      }
    }
    if (!(dp % 2))
      pict.line(pp1, qq1, pp1, q2, color);
 
 
    // 下端三角形の塗り潰し
    getPixelPosition(x + i, y + h - 1, p, q);
    calcVertex_(p1, p2, q1, q2, q3, q4, p, q);
 
    dp = (int)p - p1;
    dq = q4 - q3;
 
    pp1 = p1;
    pp2 = p;
    qq1 = q3;
    qq2 = q4;
 
    e = -dp;
    lx = (dp + 1) / 2;
    for (int i = 0; i < lx; i++) {
      pict.line(pp1, q3, pp1, qq1, color);
      pict.line(pp2, q3, pp2, qq2, color);
 
      pp1++;
      pp2--;
 
      e += 2 * dq;
      if (e >= 0) {
        qq1++;
        qq2--;
        e -= 2 * dp;
      }
    }
    if (!(dp % 2))
      pict.line(pp1, q3, pp1, qq1, color);
 
    dp = p2 - (int)p;
    pp1 = p;
    pp2 = p2;
    qq1 = q4;
    qq2 = q3;
 
    e = -dp;
    lx = (dp + 1) / 2;
    for (int i = 0; i < lx; i++) {
      pict.line(pp1, q3, pp1, qq1, color);
      pict.line(pp2, q3, pp2, qq2, color);
 
      pp1++;
      pp2--;
 
      e += 2 * dq;
      if (e >= 0) {
        qq1--;
        qq2++;
        e -= 2 * dp;
      }
    }
    if (!(dp % 2))
      pict.line(pp1, q3, pp1, qq1, color);
 
  }//end of for
}
 
 
 
 
template<class C_>
inline
void
HexPainter<C_>::getHexPosition(int p, int q, int& x, int& y)
{
  // []はHEX ()はピクセル
  // 長方形を五つのHEX(の全部または一部)に分割する。
  // 長方形左上を(0, 0)とし、差分(dp, dq)を求めて判定する。
  //
  // [x0, y0] (√3*R, 0)     [x0+1, y0]
  //          (√3*R, R/2)
  // (0, R)                 (2*√3*R, R)
  //           [x0, y0+1]
  // (0, 2*R)               (2*√3*R, 2*R)
  //          (√3*R, 5*R/2)
  // [x0, y0+2] (√3*R, 3*R)  [x0+1, y0+2]
 
  int qq = q - q0_;
  int y0 = std::floor(qq / 3.0 / r_) * 2;
  double dq = qq - (y0 / 2) * 3 * r_;
 
  int pp = p - p0_;
  int x0 = std::floor(pp * SQRT3_ / 3.0 / r_);
  double dp = pp - x0 * SQRT3_ * r_;
 
  double u = -1 * dp * SQRT3_ / 3;
  double v = dp * SQRT3_ / 3;
 
  if ((dq < u + r_) || (dq < v)) {
    if (dp < SQRT3_ * r_ / 2) {
      x = x0;
    } else {
      x = x0 + 1;
    }
    y = y0;
  }
  else if ((dq >= u + 3 * r_) || (dq >= v + 2 * r_)) {
    if (dp < SQRT3_ * r_ / 2) {
      x = x0;
    } else {
      x = x0 + 1;
    }
    y = y0 + 2;
  }
  else {
    x = x0;
    y = y0 + 1;
  }
}
 
 
}// end of namespace eunomia
 
 
 
 
#endif // INCLUDE_GUARD_EUNOMIA_HEX_PAINTER_H