532 lines
19 KiB
C++
532 lines
19 KiB
C++
#include <iostream> // std::cout
|
||
#include <vector> // std::vector
|
||
#include <cmath> // cos(),sin(),sqrt()
|
||
#include <limits> // std::numeric_limits<T>
|
||
#include <stdexcept> // std::domain_error()
|
||
#include "igs_ifx_common.h"
|
||
#include "igs_rotate_blur.h"
|
||
namespace {
|
||
//------------------------------------------------------------------
|
||
template <class T>
|
||
class rotate_ {
|
||
public:
|
||
rotate_(const T *in_top, const int height, const int width,
|
||
const int channels, const double xc, const double yc,
|
||
const double sub_size, const int imax, const double dmax,
|
||
const double radian, const double blur_radius,
|
||
const double spin_radius)
|
||
: in_top_(in_top)
|
||
, hh_(height)
|
||
, ww_(width)
|
||
, cc_(channels)
|
||
, xc_(xc)
|
||
, yc_(yc)
|
||
, sub_size_(sub_size)
|
||
, imax_(imax)
|
||
, dmax_(dmax)
|
||
, radian_(radian)
|
||
, blur_radius_(blur_radius)
|
||
, spin_radius_(spin_radius) {}
|
||
void pixel_value(const T *in_current_pixel, const int xx, const int yy,
|
||
const int z1, const int z2, const double ref_increase_val,
|
||
const double ref_decrease_val,
|
||
const double each_pixel_blur_ratio, T *result_pixel) {
|
||
/* Pixel位置(0.5 1.5 2.5 ...) */
|
||
const double xp = static_cast<double>(xx) + 0.5;
|
||
const double yp = static_cast<double>(yy) + 0.5;
|
||
|
||
/* 中心からPixel位置へのベクトルと長さ */
|
||
const double xv = xp - this->xc_;
|
||
const double yv = yp - this->yc_;
|
||
const double dist = sqrt(xv * xv + yv * yv);
|
||
|
||
/* 指定半径の範囲内なら何もしない */
|
||
if (dist <= this->blur_radius_) {
|
||
for (int zz = z1; zz <= z2; ++zz) {
|
||
result_pixel[zz] = in_current_pixel[zz];
|
||
}
|
||
return;
|
||
}
|
||
|
||
/* 中心からPixel位置への単位ベクトル */
|
||
const double cosval = xv / dist;
|
||
const double sinval = yv / dist;
|
||
|
||
/* 円周接線方向Sampling１つずらした位置への回転角度 */
|
||
const double xw = xv - this->sub_size_ * sinval;
|
||
const double yw = yv + this->sub_size_ * cosval;
|
||
const double sub_radian =
|
||
acos((xv * xw + yv * yw) /
|
||
(sqrt(xv * xv + yv * yv) * sqrt(xw * xw + yw * yw)));
|
||
|
||
/* 積算値と積算回数 */
|
||
std::vector<double> accum_val(this->cc_);
|
||
int accum_counter = 0;
|
||
|
||
/* 参照画像による強弱付加 */
|
||
double scale = this->radian_;
|
||
if (0.0 <= each_pixel_blur_ratio) {
|
||
scale *= each_pixel_blur_ratio;
|
||
}
|
||
|
||
/* Radial方向Sampling */
|
||
for (double ss = this->sub_size_ / 2.0 - 0.5; ss < 0.5;
|
||
ss += this->sub_size_) {
|
||
/* Radial方向位置 */
|
||
const double xp2 = xp + ss * cosval;
|
||
const double yp2 = yp + ss * sinval;
|
||
|
||
/* ぼかす回転角度範囲range */
|
||
double radian = scale;
|
||
|
||
if (0.0 < this->spin_radius_) { /* 外への強調 */
|
||
const double xv2 = xp2 - this->xc_;
|
||
const double yv2 = yp2 - this->yc_;
|
||
const double dist2 = sqrt(xv2 * xv2 + yv2 * yv2);
|
||
radian *=
|
||
/**(dist2 - this->blur_radius_) /
|
||
(this->spin_radius_ - this->blur_radius_);**/
|
||
(dist2 - this->blur_radius_) / this->spin_radius_;
|
||
}
|
||
|
||
/* Sampling回数 */
|
||
int sub_count = static_cast<int>(radian / sub_radian);
|
||
|
||
/* Sampling開始角度 */
|
||
const double sub_start =
|
||
(radian - sub_count * sub_radian) / 2.0 - radian / 2.0;
|
||
|
||
/* 円周方向Sampling */
|
||
for (double rr = sub_start; 0 < sub_count--; rr += sub_radian) {
|
||
/* Radial位置(xp2,yp2)から円周位置(xx,yy)へ */
|
||
const double cosval2 = cos(rr);
|
||
const double sinval2 = sin(rr);
|
||
|
||
const double xd = xp2 - this->xc_;
|
||
const double yd = yp2 - this->yc_;
|
||
|
||
int xx = static_cast<int>(xd * cosval2 - yd * sinval2 + this->xc_);
|
||
int yy = static_cast<int>(xd * sinval2 + yd * cosval2 + this->yc_);
|
||
|
||
/* clamp */
|
||
xx = (xx < 0) ? 0 : ((this->ww_ <= xx) ? this->ww_ - 1 : xx);
|
||
yy = (yy < 0) ? 0 : ((this->hh_ <= yy) ? this->hh_ - 1 : yy);
|
||
|
||
/* 画像のPixel位置 */
|
||
const T *in_current =
|
||
this->in_top_ + this->cc_ * yy * this->ww_ + this->cc_ * xx;
|
||
|
||
/* 積算 */
|
||
for (int zz = z1; zz <= z2; ++zz) {
|
||
accum_val[zz] += static_cast<double>(in_current[zz]);
|
||
}
|
||
++accum_counter;
|
||
}
|
||
}
|
||
/* 積算しなかったとき(念のためのCheck) */
|
||
if (accum_counter <= 0) {
|
||
for (int zz = z1; zz <= z2; ++zz) {
|
||
result_pixel[zz] = in_current_pixel[zz];
|
||
}
|
||
return;
|
||
}
|
||
/* ここで画像Pixelに保存 */
|
||
for (int zz = z1; zz <= z2; ++zz) {
|
||
accum_val[zz] /= static_cast<double>(accum_counter);
|
||
|
||
if ((0 <= ref_increase_val) && (in_current_pixel[zz] < accum_val[zz])) {
|
||
/* 増分のみMask! */
|
||
accum_val[zz] =
|
||
static_cast<double>(in_current_pixel[zz]) +
|
||
(accum_val[zz] - in_current_pixel[zz]) * ref_increase_val;
|
||
} else if ((0 <= ref_decrease_val) &&
|
||
(accum_val[zz] < in_current_pixel[zz])) {
|
||
/* 減分のみMask! */
|
||
accum_val[zz] =
|
||
static_cast<double>(in_current_pixel[zz]) +
|
||
(accum_val[zz] - in_current_pixel[zz]) * ref_decrease_val;
|
||
}
|
||
|
||
accum_val[zz] += 0.5; /* 誤差対策 */
|
||
if (this->dmax_ < accum_val[zz]) {
|
||
result_pixel[zz] = static_cast<T>(this->imax_);
|
||
} else if (accum_val[zz] < 0) {
|
||
result_pixel[zz] = 0;
|
||
} else {
|
||
result_pixel[zz] = static_cast<T>(accum_val[zz]);
|
||
}
|
||
}
|
||
}
|
||
|
||
private:
|
||
rotate_() {}
|
||
|
||
const T *in_top_;
|
||
const int hh_;
|
||
const int ww_;
|
||
const int cc_;
|
||
const double xc_;
|
||
const double yc_;
|
||
const double sub_size_;
|
||
const int imax_;
|
||
const double dmax_;
|
||
const double radian_;
|
||
const double blur_radius_;
|
||
const double spin_radius_;
|
||
|
||
/* copy constructorを無効化 */
|
||
rotate_(const rotate_ &);
|
||
|
||
/* 代入演算子を無効化 */
|
||
rotate_ &operator=(const rotate_ &);
|
||
};
|
||
//------------------------------------------------------------------
|
||
const double pi = 3.14159265358979;
|
||
template <class IT, class RT>
|
||
void rotate_convert_template_(
|
||
const IT *in, const int margin /* 参照画像(in)がもつ余白 */
|
||
|
||
,
|
||
const RT *ref /* 求める画像(out)と同じ高さ、幅、チャンネル数 */
|
||
,
|
||
const int ref_bits, const int ref_mode // R,G,B,A,luminance
|
||
|
||
,
|
||
IT *out, const int hh /* 求める画像(out)の高さ */
|
||
,
|
||
const int ww /* 求める画像(out)の幅 */
|
||
,
|
||
const int cc, const double xc, const double yc, const double degree,
|
||
const double blur_radius /* ぼかしの始まる半径 */
|
||
,
|
||
const double spin_radius /* ゼロ以上でspin指定となり、
|
||
かつぼかし強弱の一定になる半径となる */
|
||
,
|
||
const int sub_div /* 1ならJaggy、2以上はAntialias */
|
||
,
|
||
const bool alpha_rendering_sw) {
|
||
ref_bits; // for warning
|
||
|
||
/* 強度のないとき、または、サブ分割がないとき、なにもしない */
|
||
if (degree <= 0.0 || sub_div <= 0
|
||
// || spin_radius<=blur_radius
|
||
) {
|
||
return;
|
||
}
|
||
|
||
rotate_<IT> cl_rota(in, hh + margin * 2, ww + margin * 2, cc, xc + margin,
|
||
yc + margin, 1.0 / sub_div,
|
||
std::numeric_limits<IT>::max(),
|
||
static_cast<double>(std::numeric_limits<IT>::max()),
|
||
degree * pi / 180.0, blur_radius, spin_radius);
|
||
|
||
#if defined RGBA_ORDER_OF_TOONZ6
|
||
const int z1 = igs::image::rgba::blu;
|
||
const int z2 = igs::image::rgba::red;
|
||
#elif defined RGBA_ORDER_OF_OPENGL
|
||
const int z1 = igs::image::rgba::red;
|
||
const int z2 = igs::image::rgba::blu;
|
||
#else
|
||
Must be define / DRGBA_ORDER_OF_TOONZ6 or
|
||
/ DRGBA_ORDER_OF_OPENGL
|
||
#endif
|
||
|
||
const IT *p_in = in + margin * (ww + margin * 2) * cc + margin * cc;
|
||
IT *pout = out;
|
||
|
||
if (0 == ref) { /* 参照なし */
|
||
if (igs::image::rgba::siz == cc) {
|
||
using namespace igs::image::rgba;
|
||
if (alpha_rendering_sw) { /* Alphaも処理する */
|
||
for (int yy = margin; yy < hh + margin; ++yy, p_in += 2 * margin * cc) {
|
||
for (int xx = margin; xx < ww + margin;
|
||
++xx, p_in += cc, pout += cc) {
|
||
cl_rota.pixel_value(p_in, xx, yy, alp, alp, -1.0, -1.0, -1.0, pout);
|
||
if (0 == pout[alp]) {
|
||
pout[red] = p_in[red];
|
||
pout[gre] = p_in[gre];
|
||
pout[blu] = p_in[blu];
|
||
continue;
|
||
}
|
||
cl_rota.pixel_value(p_in, xx, yy, z1, z2, -1.0, -1.0, -1.0, pout);
|
||
}
|
||
}
|
||
} else { /* Alpha処理しない、RGB増分をAlphaでMaskする */
|
||
const unsigned int val_max = std::numeric_limits<IT>::max();
|
||
for (int yy = margin; yy < hh + margin; ++yy, p_in += 2 * margin * cc) {
|
||
for (int xx = margin; xx < ww + margin;
|
||
++xx, p_in += cc, pout += cc) {
|
||
pout[alp] = p_in[alp];
|
||
if (0 == pout[alp]) {
|
||
pout[red] = p_in[red];
|
||
pout[gre] = p_in[gre];
|
||
pout[blu] = p_in[blu];
|
||
continue;
|
||
}
|
||
cl_rota.pixel_value(p_in, xx, yy, z1, z2,
|
||
static_cast<double>(p_in[alp]) / val_max, -1.0,
|
||
-1.0, pout);
|
||
}
|
||
}
|
||
}
|
||
} else { /* Alphaがない, RGB/Grayscale... */
|
||
for (int yy = margin; yy < hh + margin; ++yy, p_in += 2 * margin * cc) {
|
||
for (int xx = margin; xx < ww + margin; ++xx, p_in += cc, pout += cc) {
|
||
cl_rota.pixel_value(p_in, xx, yy, 0, cc - 1, -1.0, -1.0, -1.0, pout);
|
||
}
|
||
}
|
||
}
|
||
} else { /* 参照あり */
|
||
const RT *refe = ref;
|
||
const int r_max = std::numeric_limits<RT>::max();
|
||
if (igs::image::rgba::siz == cc) {
|
||
using namespace igs::image::rgba;
|
||
if (alpha_rendering_sw) { /* Alphaも処理する */
|
||
for (int yy = margin; yy < hh + margin; ++yy, p_in += 2 * margin * cc) {
|
||
for (int xx = margin; xx < ww + margin;
|
||
++xx, p_in += cc, pout += cc, refe += cc) {
|
||
const double refv =
|
||
igs::color::ref_value(refe, cc, r_max, ref_mode);
|
||
if (0 == refv) {
|
||
for (int zz = 0; zz < cc; ++zz) {
|
||
pout[zz] = p_in[zz];
|
||
}
|
||
continue;
|
||
}
|
||
|
||
cl_rota.pixel_value(p_in, xx, yy, alp, alp, -1.0, -1.0, refv, pout);
|
||
if (0 == pout[alp]) {
|
||
pout[red] = p_in[red];
|
||
pout[gre] = p_in[gre];
|
||
pout[blu] = p_in[blu];
|
||
continue;
|
||
}
|
||
cl_rota.pixel_value(p_in, xx, yy, z1, z2, -1.0, -1.0, refv, pout);
|
||
}
|
||
}
|
||
} else { /* Alpha処理しない、RGB増分をAlphaでMaskする */
|
||
const unsigned int val_max = std::numeric_limits<IT>::max();
|
||
for (int yy = margin; yy < hh + margin; ++yy, p_in += 2 * margin * cc) {
|
||
for (int xx = margin; xx < ww + margin;
|
||
++xx, p_in += cc, pout += cc, refe += cc) {
|
||
const double refv =
|
||
igs::color::ref_value(refe, cc, r_max, ref_mode);
|
||
if (0 == refv) {
|
||
for (int zz = 0; zz < cc; ++zz) {
|
||
pout[zz] = p_in[zz];
|
||
}
|
||
continue;
|
||
}
|
||
|
||
pout[alp] = p_in[alp];
|
||
if (0 == pout[alp]) {
|
||
pout[red] = p_in[red];
|
||
pout[gre] = p_in[gre];
|
||
pout[blu] = p_in[blu];
|
||
continue;
|
||
}
|
||
cl_rota.pixel_value(p_in, xx, yy, z1, z2,
|
||
static_cast<double>(p_in[alp]) / val_max, -1.0,
|
||
refv, pout);
|
||
}
|
||
}
|
||
}
|
||
} else { /* Alphaがない, RGB/Grayscale... */
|
||
for (int yy = margin; yy < hh + margin; ++yy, p_in += 2 * margin * cc) {
|
||
for (int xx = margin; xx < ww + margin;
|
||
++xx, p_in += cc, pout += cc, refe += cc) {
|
||
const double refv = igs::color::ref_value(refe, cc, r_max, ref_mode);
|
||
if (0 == refv) {
|
||
for (int zz = 0; zz < cc; ++zz) {
|
||
pout[zz] = p_in[zz];
|
||
}
|
||
continue;
|
||
}
|
||
|
||
cl_rota.pixel_value(p_in, xx, yy, 0, cc - 1, -1.0, -1.0, refv, pout);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
//------------------------------------------------------------------
|
||
}
|
||
|
||
void igs::rotate_blur::convert(
|
||
const unsigned char *in, const int margin /* 参照画像(in)がもつ余白 */
|
||
|
||
,
|
||
const unsigned char *ref /* outと同じ高さ、幅、チャンネル数 */
|
||
,
|
||
const int ref_bits, const int ref_mode // R,G,B,A,luminance
|
||
|
||
,
|
||
unsigned char *out
|
||
|
||
,
|
||
const int height /* 求める画像(out)の高さ */
|
||
,
|
||
const int width /* 求める画像(out)の幅 */
|
||
,
|
||
const int channels, const int bits
|
||
|
||
,
|
||
const double xc, const double yc, const double degree /* ぼかしの回転角度 */
|
||
,
|
||
const double blur_radius /* ぼかしの始まる半径 */
|
||
,
|
||
const double spin_radius /* ゼロ以上でspin指定となり、
|
||
かつぼかし強弱の一定になる半径となる */
|
||
,
|
||
const int sub_div /* 1ならJaggy、2以上はAntialias */
|
||
,
|
||
const bool alpha_rendering_sw) {
|
||
if ((igs::image::rgba::siz != channels) &&
|
||
(igs::image::rgb::siz != channels) && (1 != channels) /* bit(monoBW) */
|
||
) {
|
||
throw std::domain_error("Bad channels,Not rgba/rgb/grayscale");
|
||
}
|
||
|
||
if ((std::numeric_limits<unsigned char>::digits != bits) &&
|
||
(std::numeric_limits<unsigned short>::digits != bits)) {
|
||
throw std::domain_error("Bad in bits,Not uchar/ushort");
|
||
}
|
||
if ((0 != ref) && (std::numeric_limits<unsigned char>::digits != ref_bits) &&
|
||
(std::numeric_limits<unsigned short>::digits != ref_bits)) {
|
||
throw std::domain_error("Bad ref bits,Not uchar/ushort");
|
||
}
|
||
|
||
/* 強度のないとき、または、サブ分割がないとき */
|
||
if (degree <= 0.0 || sub_div <= 0
|
||
// || spin_radius<=blur_radius
|
||
) {
|
||
if (std::numeric_limits<unsigned char>::digits == bits) {
|
||
igs::image::copy_except_margin(in, margin, out, height, width, channels);
|
||
} else if (std::numeric_limits<unsigned short>::digits == bits) {
|
||
igs::image::copy_except_margin(
|
||
reinterpret_cast<const unsigned short *>(in), margin,
|
||
reinterpret_cast<unsigned short *>(out), height, width, channels);
|
||
}
|
||
return;
|
||
}
|
||
|
||
if (std::numeric_limits<unsigned char>::digits == ref_bits) {
|
||
if (std::numeric_limits<unsigned char>::digits == bits) {
|
||
rotate_convert_template_(in, margin, ref, ref_bits, ref_mode, out, height,
|
||
width, channels, xc, yc, degree, blur_radius,
|
||
spin_radius, sub_div, alpha_rendering_sw);
|
||
} else if (std::numeric_limits<unsigned short>::digits == bits) {
|
||
rotate_convert_template_(reinterpret_cast<const unsigned short *>(in),
|
||
margin, ref, ref_bits, ref_mode,
|
||
reinterpret_cast<unsigned short *>(out), height,
|
||
width, channels, xc, yc, degree, blur_radius,
|
||
spin_radius, sub_div, alpha_rendering_sw);
|
||
}
|
||
} else { /* ref_bitsがゼロでも(refがなくても)ここにくる */
|
||
if (std::numeric_limits<unsigned char>::digits == bits) {
|
||
rotate_convert_template_(
|
||
in, margin, reinterpret_cast<const unsigned short *>(ref), ref_bits,
|
||
ref_mode, out, height, width, channels, xc, yc, degree, blur_radius,
|
||
spin_radius, sub_div, alpha_rendering_sw);
|
||
} else if (std::numeric_limits<unsigned short>::digits == bits) {
|
||
rotate_convert_template_(
|
||
reinterpret_cast<const unsigned short *>(in), margin,
|
||
reinterpret_cast<const unsigned short *>(ref), ref_bits, ref_mode,
|
||
reinterpret_cast<unsigned short *>(out), height, width, channels, xc,
|
||
yc, degree, blur_radius, spin_radius, sub_div, alpha_rendering_sw);
|
||
}
|
||
}
|
||
}
|
||
//--------------------------------------------------------------------
|
||
namespace {
|
||
double reference_margin_length_(const double xc, const double yc,
|
||
const double xp, const double yp, double radian,
|
||
const double blur_radius,
|
||
const double spin_radius,
|
||
const double sub_size) {
|
||
sub_size; // for warning
|
||
|
||
const double xv = xp - xc;
|
||
const double yv = yp - yc;
|
||
|
||
if (0.0 < spin_radius) { /* 外への強調 */
|
||
const double dist = sqrt(xv * xv + yv * yv);
|
||
// radian *= (dist-blur_radius)/(spin_radius-blur_radius);
|
||
radian *= (dist - blur_radius) / spin_radius;
|
||
}
|
||
|
||
double cosval = cos(radian / 2.0);
|
||
double sinval = sin(radian / 2.0);
|
||
const double x1 = xv * cosval - yv * sinval + xc;
|
||
const double y1 = xv * sinval + yv * cosval + yc;
|
||
const double xv1 = x1 - xp;
|
||
const double yv1 = y1 - yp;
|
||
const double dist1 = sqrt(xv1 * xv1 + yv1 * yv1); /* 必ずプラス値 */
|
||
|
||
cosval = cos(-radian / 2.0);
|
||
sinval = sin(-radian / 2.0);
|
||
const double xp2 = xv * cosval - yv * sinval + xc;
|
||
const double yp2 = xv * sinval + yv * cosval + yc;
|
||
const double xv2 = xp2 - xp;
|
||
const double yv2 = yp2 - yp;
|
||
const double dist2 = sqrt(xv2 * xv2 + yv2 * yv2); /* 必ずプラス値 */
|
||
|
||
return (dist1 < dist2) ? dist2 : dist1;
|
||
}
|
||
}
|
||
int igs::rotate_blur::reference_margin(
|
||
const int height /* 求める画像(out)の高さ */
|
||
,
|
||
const int width /* 求める画像(out)の幅 */
|
||
,
|
||
const double xc, const double yc, const double degree /* ぼかしの回転角度 */
|
||
,
|
||
const double blur_radius /* ぼかしの始まる半径 */
|
||
,
|
||
const double spin_radius /* ゼロ以上でspin指定となり、
|
||
かつぼかし強弱の一定になる半径となる */
|
||
,
|
||
const int sub_div /* 1ならJaggy、2以上はAntialias */
|
||
) {
|
||
/* 強度のないとき、または、サブ分割がないとき、なにもしない */
|
||
if (degree <= 0.0 || sub_div <= 0
|
||
// || spin_radius<=blur_radius
|
||
) {
|
||
return 0;
|
||
}
|
||
|
||
double margin1 = 0;
|
||
double margin2 = 0;
|
||
|
||
double deg = degree;
|
||
if (180.0 < deg) {
|
||
deg = 180.0;
|
||
}
|
||
|
||
margin1 = reference_margin_length_(xc, yc, -width / 2.0, -height / 2.0,
|
||
deg * pi / 180.0, blur_radius, spin_radius,
|
||
1.0 / sub_div);
|
||
|
||
margin2 = reference_margin_length_(xc, yc, -width / 2.0, height / 2.0,
|
||
deg * pi / 180.0, blur_radius, spin_radius,
|
||
1.0 / sub_div);
|
||
if (margin1 < margin2) {
|
||
margin1 = margin2;
|
||
}
|
||
|
||
margin2 = reference_margin_length_(xc, yc, width / 2.0, -height / 2.0,
|
||
deg * pi / 180.0, blur_radius, spin_radius,
|
||
1.0 / sub_div);
|
||
if (margin1 < margin2) {
|
||
margin1 = margin2;
|
||
}
|
||
|
||
margin2 = reference_margin_length_(xc, yc, width / 2.0, height / 2.0,
|
||
deg * pi / 180.0, blur_radius, spin_radius,
|
||
1.0 / sub_div);
|
||
if (margin1 < margin2) {
|
||
margin1 = margin2;
|
||
}
|
||
|
||
return static_cast<int>(ceil(margin1));
|
||
}
|