1006 lines
36 KiB
C++
1006 lines
36 KiB
C++
#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_radial_blur.h"
|
|
namespace {
|
|
//------------------------------------------------------------------
|
|
template <class T>
|
|
class radial_ {
|
|
public:
|
|
radial_(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 intensity /* 平均値ぼかし強度 */
|
|
,
|
|
const double radius /* 平均値ぼかしの始まる半径 */
|
|
)
|
|
: in_top_(in_top)
|
|
, hh_(height)
|
|
, ww_(width)
|
|
, cc_(channels)
|
|
, xc_(xc)
|
|
, yc_(yc)
|
|
, sub_size_(sub_size)
|
|
, imax_(imax)
|
|
, dmax_(dmax)
|
|
, intensity_(intensity)
|
|
, radius_(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->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;
|
|
|
|
/* Radial方向のSamplingの開始位置と終了位置 */
|
|
double scale = this->intensity_;
|
|
if (0.0 <= each_pixel_blur_ratio) {
|
|
scale *= each_pixel_blur_ratio;
|
|
}
|
|
const double length = (dist - this->radius_) * scale;
|
|
const double count_half = floor(length / 2.0 / this->sub_size_);
|
|
const double sub_sta = -this->sub_size_ * count_half;
|
|
const double sub_end = this->sub_size_ * count_half;
|
|
|
|
/* 積算値と積算回数 */
|
|
std::vector<double> accum_val(this->cc_);
|
|
int accum_counter = 0;
|
|
|
|
/* 円周接線方向Samplingの相対位置 */
|
|
for (double ss = this->sub_size_ / 2.0 - 0.5; ss < 0.5;
|
|
ss += this->sub_size_) {
|
|
/* 円周接線方向Sampling位置 */
|
|
const double xps = xp + ss * sinval;
|
|
const double yps = yp + ss * cosval;
|
|
|
|
/* 中心からSampling位置へのベクトルと長さ */
|
|
const double xvs = xps - this->xc_;
|
|
const double yvs = yps - this->yc_;
|
|
const double dists = sqrt(xvs * xvs + yvs * yvs);
|
|
|
|
/* 中心からSampling位置への単位ベクトル */
|
|
const double cosvals = xvs / dists;
|
|
const double sinvals = yvs / dists;
|
|
|
|
/* Radial方向のSampling */
|
|
for (double tt = sub_sta; tt <= sub_end; tt += this->sub_size_) {
|
|
/* Sampling位置からPixel位置を得る */
|
|
int xi = static_cast<int>(xps + tt * cosvals);
|
|
int yi = static_cast<int>(yps + tt * sinvals);
|
|
|
|
/* clamp */
|
|
xi = (xi < 0) ? 0 : ((this->ww_ <= xi) ? this->ww_ - 1 : xi);
|
|
yi = (yi < 0) ? 0 : ((this->hh_ <= yi) ? this->hh_ - 1 : yi);
|
|
|
|
/* 画像のPixel位置 */
|
|
const T *in_current =
|
|
this->in_top_ + this->cc_ * this->ww_ * yi + this->cc_ * xi;
|
|
|
|
/* 積算 */
|
|
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:
|
|
radial_() {}
|
|
|
|
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 intensity_;
|
|
const double radius_;
|
|
|
|
/* copy constructorを無効化 */
|
|
radial_(const radial_ &);
|
|
|
|
/* 代入演算子を無効化 */
|
|
radial_ &operator=(const radial_ &);
|
|
};
|
|
template <class IT, class RT>
|
|
void radial_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 intensity /* 強度。ゼロより大きく2以下 */
|
|
/* radius円境界での平均値ぼかしゼロとするためintensityは2より小さい */
|
|
,
|
|
const double radius /* 平均値ぼかしの始まる半径 */
|
|
,
|
|
const int sub_div /* 1ならJaggy、2以上はAntialias */
|
|
,
|
|
const bool alpha_rendering_sw) {
|
|
ref_bits; // for warning
|
|
|
|
/* 強度のないとき、または、サブ分割がないとき、なにもしない */
|
|
if (intensity <= 0.0 || sub_div <= 0) {
|
|
return;
|
|
}
|
|
|
|
radial_<IT> cl_ra(
|
|
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()), intensity, 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_ra.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_ra.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;
|
|
}
|
|
/* Alpha値あるならRGB増分のみAlphaでMaskする */
|
|
cl_ra.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_ra.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_ra.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_ra.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_ra.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_ra.pixel_value(p_in, xx, yy, 0, cc - 1, -1.0, -1.0, refv, pout);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
//--------------------------------------------------------------------
|
|
namespace {
|
|
class twist_ {
|
|
public:
|
|
twist_(const int height, const double xc, const double yc,
|
|
const double twist_radian, const double twist_radius)
|
|
: xc_(xc)
|
|
, yc_(yc)
|
|
, twist_xp_(0)
|
|
, twist_yp_(0)
|
|
, twist_radian_(twist_radian)
|
|
, twist_radius_(twist_radius)
|
|
, current_xp_(0)
|
|
, current_yp_(0)
|
|
, current_radian_(0)
|
|
, current_cos_(0)
|
|
, current_sin_(0)
|
|
, current_radius_(0) {
|
|
/* twist_radiusは、Twist曲線上半径1のPixel画像上半径 */
|
|
/* twist_radiusはゼロのとき、高さの半分を設定する */
|
|
if (this->twist_radius_ <= 0.0) {
|
|
this->twist_radius_ = height / 2.0;
|
|
}
|
|
/* ゼロだと計算不能になる */
|
|
if (this->twist_radius_ <= 0.0) {
|
|
throw std::domain_error("twist_radius is equal less than zero");
|
|
}
|
|
}
|
|
void current_pos(const double xp, const double yp) {
|
|
/* 現在位置 */
|
|
this->current_xp_ = xp;
|
|
this->current_yp_ = yp;
|
|
|
|
/* 中心からの距離 */
|
|
const double xv = xp - this->xc_;
|
|
const double yv = yp - this->yc_;
|
|
this->current_radius_ = sqrt(xv * xv + yv * yv);
|
|
|
|
/* 基準からの距離比 */
|
|
const double tt = this->current_radius_ / this->twist_radius_;
|
|
|
|
/* Twist曲線上の位置 */
|
|
const double xx = tt * cos(tt * this->twist_radian_);
|
|
const double yy = tt * sin(tt * this->twist_radian_);
|
|
|
|
/* Twist曲線の回転角度 */
|
|
this->current_radian_ = atan2(yv, xv) - atan2(yy, xx);
|
|
|
|
/* Twist曲線上の位置を回転角度に傾けた位置 */
|
|
this->current_cos_ = cos(this->current_radian_);
|
|
this->current_sin_ = sin(this->current_radian_);
|
|
this->twist_xp_ = xx * this->current_cos_ - yy * this->current_sin_;
|
|
this->twist_yp_ = xx * this->current_sin_ + yy * this->current_cos_;
|
|
}
|
|
void twist_pos(const double pixel_pos, int &xi, int &yi) {
|
|
/* 基準半径からの比 */
|
|
const double tt = (this->current_radius_ + pixel_pos) / this->twist_radius_;
|
|
|
|
/* Twist曲線上の比による位置 */
|
|
const double xx = tt * cos(tt * this->twist_radian_);
|
|
const double yy = tt * sin(tt * this->twist_radian_);
|
|
|
|
/* その位置の角度に傾ける */
|
|
double x2 = xx * this->current_cos_ - yy * this->current_sin_;
|
|
double y2 = xx * this->current_sin_ + yy * this->current_cos_;
|
|
|
|
/* Twist曲線上の位置の差 */
|
|
x2 = (x2 - this->twist_xp_);
|
|
y2 = (y2 - this->twist_yp_);
|
|
|
|
/* Pixel画像上の位置の差 */
|
|
x2 *= this->twist_radius_;
|
|
y2 *= this->twist_radius_;
|
|
|
|
/* Pixel画像上の位置 */
|
|
x2 += this->current_xp_;
|
|
y2 += this->current_yp_;
|
|
|
|
xi = static_cast<int>(x2);
|
|
yi = static_cast<int>(y2);
|
|
}
|
|
|
|
private:
|
|
twist_();
|
|
|
|
const double xc_;
|
|
const double yc_;
|
|
|
|
double twist_xp_;
|
|
double twist_yp_;
|
|
double twist_radian_;
|
|
double twist_radius_;
|
|
|
|
double current_xp_;
|
|
double current_yp_;
|
|
double current_radian_;
|
|
double current_cos_;
|
|
double current_sin_;
|
|
double current_radius_;
|
|
|
|
/* copy constructorを無効化 */
|
|
twist_(const twist_ &);
|
|
|
|
/* 代入演算子を無効化 */
|
|
twist_ &operator=(const twist_ &);
|
|
};
|
|
//--------------------------------
|
|
template <class T>
|
|
class radial_twist_ {
|
|
public:
|
|
radial_twist_(const T *in_top, const int height /* 求める画像(out)の高さ */
|
|
,
|
|
const int width /* 求める画像(out)の幅 */
|
|
,
|
|
const int channels, const double xc, const double yc,
|
|
const double sub_size, const int imax, const double dmax,
|
|
const double intensity /* 平均値ぼかし強度 */
|
|
,
|
|
const double radius /* 平均値ぼかしの始まる半径 */
|
|
,
|
|
const double twist_radian, const double twist_radius)
|
|
: in_top_(in_top)
|
|
, hh_(height)
|
|
, ww_(width)
|
|
, cc_(channels)
|
|
, xc_(xc)
|
|
, yc_(yc)
|
|
, sub_size_(sub_size)
|
|
, imax_(imax)
|
|
, dmax_(dmax)
|
|
, intensity_(intensity)
|
|
, radius_(radius)
|
|
, cl_tw_(height, xc, yc, twist_radian, twist_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->radius_) {
|
|
for (int zz = z1; zz <= z2; ++zz) {
|
|
result_pixel[zz] = in_current_pixel[zz];
|
|
}
|
|
return;
|
|
}
|
|
|
|
/* Radial方向のSamplingの開始位置と終了位置 */
|
|
double scale = this->intensity_;
|
|
if (0.0 <= each_pixel_blur_ratio) {
|
|
scale *= each_pixel_blur_ratio;
|
|
}
|
|
const double length = (dist - this->radius_) * scale;
|
|
const double count_half = floor(length / 2.0 / this->sub_size_);
|
|
const double sub_sta = -this->sub_size_ * count_half;
|
|
const double sub_end = this->sub_size_ * count_half;
|
|
|
|
/* 積算値と積算回数 */
|
|
std::vector<double> accum_val(this->cc_);
|
|
int accum_counter = 0;
|
|
|
|
/* SubPixelによるSamplingの相対位置 */
|
|
for (double xsub = this->sub_size_ / 2.0 - 0.5; xsub < 0.5;
|
|
xsub += this->sub_size_) {
|
|
for (double ysub = this->sub_size_ / 2.0 - 0.5; ysub < 0.5;
|
|
ysub += this->sub_size_) {
|
|
/* Sampling位置をセット */
|
|
this->cl_tw_.current_pos(xp + xsub, yp + ysub);
|
|
|
|
/* Radial&Twist方向のSampling */
|
|
for (double tt = sub_sta; tt <= sub_end; tt += this->sub_size_) {
|
|
/* Sampling位置からPixel位置を得る */
|
|
int xi = 0;
|
|
int yi = 0;
|
|
this->cl_tw_.twist_pos(tt, xi, yi);
|
|
|
|
/* clamp */
|
|
xi = (xi < 0) ? 0 : ((this->ww_ <= xi) ? this->ww_ - 1 : xi);
|
|
yi = (yi < 0) ? 0 : ((this->hh_ <= yi) ? this->hh_ - 1 : yi);
|
|
|
|
/* 画像のPixel位置 */
|
|
const T *in_current =
|
|
this->in_top_ + this->cc_ * this->ww_ * yi + this->cc_ * xi;
|
|
|
|
/* 積算 */
|
|
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:
|
|
radial_twist_() {}
|
|
|
|
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 intensity_;
|
|
const double radius_;
|
|
twist_ cl_tw_;
|
|
|
|
/* copy constructorを無効化 */
|
|
radial_twist_(const radial_twist_ &);
|
|
|
|
/* 代入演算子を無効化 */
|
|
radial_twist_ &operator=(const radial_twist_ &);
|
|
};
|
|
//--------------------------------
|
|
template <class IT, class RT>
|
|
void twist_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 twist_radian,
|
|
const double twist_radius,
|
|
const double intensity /* 強度。ゼロより大きく2以下 */
|
|
/* radius円境界での平均値ぼかしゼロとするためintensityは2より小さい */
|
|
,
|
|
const double radius /* 平均値ぼかしの始まる半径 */
|
|
,
|
|
const int sub_div /* 1ならJaggy、2以上はAntialias */
|
|
,
|
|
const bool alpha_rendering_sw) {
|
|
ref_bits; // for warning
|
|
|
|
/* 強度のないとき、または、サブ分割がないとき、なにもしない */
|
|
if (intensity <= 0.0 || sub_div <= 0) {
|
|
return;
|
|
}
|
|
|
|
radial_twist_<IT> cl_ratw(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()),
|
|
intensity, radius, twist_radian, twist_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_ratw.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_ratw.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_ratw.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_ratw.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_ratw.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_ratw.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_ratw.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_ratw.pixel_value(p_in, xx, yy, 0, cc - 1, -1.0, -1.0, refv, pout);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
//--------------------------------------------------------------------
|
|
void igs::radial_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 twist_radian,
|
|
const double twist_radius
|
|
/*
|
|
Twist Radius
|
|
ひねりの基準半径を指定します。
|
|
単位はミリメートルです。
|
|
最小は0。最大1000mm(1m)です。
|
|
初期値は0でひねりはありません。
|
|
*/
|
|
,
|
|
const double intensity /* 強度。ゼロより大きく2以下 */
|
|
/* radius円境界での平均値ぼかしゼロとするためintensityは2より小さい */
|
|
,
|
|
const double radius /* 平均値ぼかしの始まる半径 */
|
|
,
|
|
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 (intensity <= 0.0 || sub_div <= 0) {
|
|
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 (0.0 == twist_radian) {
|
|
if (std::numeric_limits<unsigned char>::digits == ref_bits) {
|
|
if (std::numeric_limits<unsigned char>::digits == bits) {
|
|
radial_convert_template_(in, margin, ref, ref_bits, ref_mode, out,
|
|
height, width, channels, xc, yc, intensity,
|
|
radius, sub_div, alpha_rendering_sw);
|
|
} else if (std::numeric_limits<unsigned short>::digits == bits) {
|
|
radial_convert_template_(
|
|
reinterpret_cast<const unsigned short *>(in), margin, ref, ref_bits,
|
|
ref_mode, reinterpret_cast<unsigned short *>(out), height, width,
|
|
channels, xc, yc, intensity, radius, sub_div, alpha_rendering_sw);
|
|
}
|
|
} else { /* ref_bitsがゼロでも(refがなくても)ここにくる */
|
|
if (std::numeric_limits<unsigned char>::digits == bits) {
|
|
radial_convert_template_(
|
|
in, margin, reinterpret_cast<const unsigned short *>(ref), ref_bits,
|
|
ref_mode, out, height, width, channels, xc, yc, intensity, radius,
|
|
sub_div, alpha_rendering_sw);
|
|
} else if (std::numeric_limits<unsigned short>::digits == bits) {
|
|
radial_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, intensity, radius, sub_div, alpha_rendering_sw);
|
|
}
|
|
}
|
|
} else {
|
|
if (std::numeric_limits<unsigned char>::digits == ref_bits) {
|
|
if (std::numeric_limits<unsigned char>::digits == bits) {
|
|
twist_convert_template_(in, margin, ref, ref_bits, ref_mode, out,
|
|
height, width, channels, xc, yc, twist_radian,
|
|
twist_radius, intensity, radius, sub_div,
|
|
alpha_rendering_sw);
|
|
} else if (std::numeric_limits<unsigned short>::digits == bits) {
|
|
twist_convert_template_(
|
|
reinterpret_cast<const unsigned short *>(in), margin, ref, ref_bits,
|
|
ref_mode, reinterpret_cast<unsigned short *>(out), height, width,
|
|
channels, xc, yc, twist_radian, twist_radius, intensity, radius,
|
|
sub_div, alpha_rendering_sw);
|
|
}
|
|
} else { /* ref_bitsがゼロでも(refがなくても)ここにくる */
|
|
if (std::numeric_limits<unsigned char>::digits == bits) {
|
|
twist_convert_template_(
|
|
in, margin, reinterpret_cast<const unsigned short *>(ref), ref_bits,
|
|
ref_mode, out, height, width, channels, xc, yc, twist_radian,
|
|
twist_radius, intensity, radius, sub_div, alpha_rendering_sw);
|
|
} else if (std::numeric_limits<unsigned short>::digits == bits) {
|
|
twist_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, twist_radian, twist_radius, intensity, radius, sub_div,
|
|
alpha_rendering_sw);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#if 0 //-------------------- comment out start ------------------------
|
|
namespace {
|
|
double enlarge_margin_length_(
|
|
const double xc
|
|
,const double yc
|
|
,const double xp
|
|
,const double yp
|
|
,const double intensity
|
|
,const double radius
|
|
,const double sub_size
|
|
) {
|
|
const double xv = xp - xc;
|
|
const double yv = yp - yc;
|
|
const double dist = sqrt(xv*xv + yv*yv);
|
|
|
|
/* "dist = len - (len - radius) * intensity / 2.0;"より */
|
|
const double len = (2.0 * dist - radius * intensity) /
|
|
(2.0-intensity);
|
|
|
|
/***const double length = (len - radius) * intensity;
|
|
const double count_half = floor(length / sub_size);
|
|
return sub_size * count_half;***/
|
|
|
|
if (len <= radius) { return 0; }
|
|
return (len - radius) * intensity / 2.0;
|
|
}
|
|
}
|
|
int igs::radial_blur::enlarge_margin( /* Twist時は正確ではない... */
|
|
const int height
|
|
,const int width
|
|
,const double xc
|
|
,const double yc
|
|
,const double twist_radian
|
|
,const double twist_radius
|
|
,const double intensity/* 強度。ゼロより大きく2以下 */
|
|
/* radius円境界での平均値ぼかしゼロとするためintensityは2より小さい */
|
|
,const double radius /* 平均値ぼかしの始まる半径 */
|
|
,const int sub_div /* 1ならJaggy、2以上はAntialias */
|
|
) {
|
|
/* 強度のないとき、2以上のとき、または、サブ分割がないとき、
|
|
なにもしない */
|
|
if (intensity <= 0.0 || 2.0 <= intensity || sub_div <= 0) {
|
|
return 0;
|
|
}
|
|
|
|
double margin1 = 0;
|
|
double margin2 = 0;
|
|
|
|
margin1 = enlarge_margin_length_(
|
|
xc,yc,-width/2.0,-height/2.0,intensity,radius,1.0/sub_div);
|
|
|
|
margin2 = enlarge_margin_length_(
|
|
xc,yc,-width/2.0, height/2.0,intensity,radius,1.0/sub_div);
|
|
if (margin1 < margin2) { margin1 = margin2; }
|
|
|
|
margin2 = enlarge_margin_length_(
|
|
xc,yc, width/2.0,-height/2.0,intensity,radius,1.0/sub_div);
|
|
if (margin1 < margin2) { margin1 = margin2; }
|
|
|
|
margin2 = enlarge_margin_length_(
|
|
xc,yc, width/2.0, height/2.0,intensity,radius,1.0/sub_div);
|
|
if (margin1 < margin2) { margin1 = margin2; }
|
|
|
|
return static_cast<int>(ceil(margin1));
|
|
}
|
|
#endif //-------------------- comment out end -------------------------
|
|
namespace {
|
|
double reference_margin_length_(const double xc, const double yc,
|
|
const double xp, const double yp,
|
|
const double intensity, const double radius,
|
|
const double sub_size) {
|
|
const double xv = xp - xc;
|
|
const double yv = yp - yc;
|
|
const double dist = sqrt(xv * xv + yv * yv);
|
|
if (dist <= radius) {
|
|
return 0;
|
|
}
|
|
const double half_length = (dist - radius) * intensity / 2.0;
|
|
const double count_half = floor(half_length / sub_size);
|
|
return sub_size * count_half;
|
|
}
|
|
}
|
|
int igs::radial_blur::
|
|
reference_margin(/* Twist時は正確ではない... */
|
|
const int height, const int width, const double xc,
|
|
const double yc, const double twist_radian,
|
|
const double twist_radius,
|
|
const double intensity /* 強度。ゼロより大きく2以下 */
|
|
/* radius円境界での平均値ぼかしゼロとするためintensityは2より小さい
|
|
*/
|
|
,
|
|
const double radius /* 平均値ぼかしの始まる半径 */
|
|
,
|
|
const int sub_div /* 1ならJaggy、2以上はAntialias */
|
|
) {
|
|
twist_radius; // for warning
|
|
twist_radian; // for warning
|
|
|
|
/* 強度のないとき、2以上のとき、または、サブ分割がないとき、
|
|
なにもしない */
|
|
if (intensity <= 0.0 || 2.0 <= intensity || sub_div <= 0) {
|
|
return 0;
|
|
}
|
|
|
|
double margin1 = 0;
|
|
double margin2 = 0;
|
|
|
|
/*
|
|
四隅から参照する外部への最大マージンを計算する
|
|
*/
|
|
margin1 = reference_margin_length_(xc, yc, -width / 2.0, -height / 2.0,
|
|
intensity, radius, 1.0 / sub_div);
|
|
|
|
margin2 = reference_margin_length_(xc, yc, -width / 2.0, height / 2.0,
|
|
intensity, radius, 1.0 / sub_div);
|
|
if (margin1 < margin2) {
|
|
margin1 = margin2;
|
|
}
|
|
|
|
margin2 = reference_margin_length_(xc, yc, width / 2.0, -height / 2.0,
|
|
intensity, radius, 1.0 / sub_div);
|
|
if (margin1 < margin2) {
|
|
margin1 = margin2;
|
|
}
|
|
|
|
margin2 = reference_margin_length_(xc, yc, width / 2.0, height / 2.0,
|
|
intensity, radius, 1.0 / sub_div);
|
|
if (margin1 < margin2) {
|
|
margin1 = margin2;
|
|
}
|
|
|
|
return static_cast<int>(ceil(margin1));
|
|
}
|