#include <cmath> // sqrt() sin() cos()
#ifndef M_PI /* only Microsoft C++ */
#define M_PI 3.14159265358979323846
#endif
#include <iostream> // std::cout
#include "igs_maxmin_lens_matrix.h"
namespace {
/*
y
^
| <-
| \
| |
<---------------+----------------> x
|
|
|
v
*/
bool inside_polygon_(double radius, int odd_diameter, double xp, double yp,
int polygon_number, double roll_degree) {
if (polygon_number < 3) { /* equal less than 2 is circle */
return true;
}
double radian = roll_degree * (M_PI / 180),
add_radian = 2.0 * M_PI / polygon_number;
double x1 = radius * cos(radian), y1 = radius * sin(radian), x2 = 0, y2 = 0,
xa = odd_diameter, xb = odd_diameter;
radian += add_radian;
/* 線分の回数loop回す */
for (int ii = 0; ii < polygon_number;
++ii, radian += add_radian, x1 = x2, y1 = y2) {
/* (0,0)を原点とした正多角形の各頂点
数学的開始点(右)及び回転方向(CCW)とするため、
内部では上下左右反転する。
これをしないと左からCW回転となる
計算の考えを単純にするため反転しない2013-12-10
*/
x2 = radius * cos(radian);
y2 = radius * sin(radian);
/* scanline方向でy1とy2の間で区切った領域外なら次へ
((y2==y1==yp)の場合も)しない線分なら次へ */
if (!(((y1 <= yp) && (yp <= y2)) || ((y2 <= yp) && (yp <= y1)))) {
continue;
}
/* scanline方向でy1とy2の間で区切った領域 */
/* 水平線分 */
if (y2 == y1) {
if (((x1 <= xp) && (xp <= x2)) || ((x2 <= xp) && (xp <= x1))) {
return true;
} /* 水平線分上 */
else {
return false;
} /* 水平範囲外 */
}
/* 水平方向の初めの交差位置(xa) */
if (xa == odd_diameter) {
/* (x2 - x1)/(y2 - y1)=(xa - x1)/(yp - y1);
(xa - x1)=(yp - y1)*(x2 - x1)/(y2 - y1); */
xa = (yp - y1) * (x2 - x1) / (y2 - y1) + x1;
} else
/* 2番目の交差位置(xb) */
if (xb == odd_diameter) {
xb = (yp - y1) * (x2 - x1) / (y2 - y1) + x1;
if (((xa <= xp) && (xp <= xb)) || ((xb <= xp) && (xp <= xa))) {
return true;
} /* 水平範囲内 */
else {
return false;
} /* 水平範囲外 */
}
}
return false;
}
/*
二点(x1,y1),(x2,y2)を通る直線
x - x1 y - y1
------- = -------
x2 - x1 y2 - y1
--> (x - x1) * (y2 - y1) = (y - y1) * (x2 - x1)
--> x * (y2 - y1) - x1 * (y2 - y1) = y * (x2 - x1) - y1 * (x2 - x1)
--> y * (x2 - x1) - y1 * (x2 - x1) = x * (y2 - y1) - x1 * (y2 - y1)
--> y * (x2 - x1) + x1 * (y2 - y1) = x * (y2 - y1) + y1 * (x2 - x1)
--> (y1 - y2) * x + (x2 - x1) * y + x1 * (y2 - y1) - y1 * (x2 - x1) = 0
--> (y1 - y2) * x + (x2 - x1) * y + x1*y2 - x1*y1 - y1*x2 + y1*x1 = 0
--> (y1 - y2) * x + (x2 - x1) * y + x1*y2 - y1*x2 = 0
点(x0,y0)と直線との距離(垂線の長さ)(h)
a * x + b * y + c = 0 ならば、
| a * x0 + b * y0 + c |
h = -----------------------
sqrt(a * a + b * b)
| (y1 - y2) * x0 + (x2 - x1) * y0 + x1*y2 - y1*x2 |
h = ---------------------------------------------------
sqrt((y1 - y2) * (y1 - y2) + (x2 - x1) * (x2 - x1))
*/
double length_to_polygon_(double radius, double xp, double yp,
int polygon_number, double roll_degree) {
/* 現在位置での角度 */
double radian = atan2(yp, xp); /* 0 ... M_PI , -M_PI ... 0 */
if (radian < 0) {
radian += M_PI * 2.0;
} /* 0 ... M_PI*2 */
/* 多角形の辺の2点 */
double x1 = 0.0, y1 = 0.0, x2 = 0.0, y2 = 0.0;
const double add_radian = 2.0 * M_PI / polygon_number;
double radian1 = roll_degree * (M_PI / 180);
/* rad1だとMS-VC++_v10でエラー!!! */
while (radian1 < 0.0) {
radian1 += add_radian;
}
double radian2 = radian1 + add_radian;
/* rad2だとMS-VC++_v10でエラー!!! */
/* 開始角度より現在位置の角度が小さい場合360先に進める */
if (radian < radian1) {
radian += M_PI * 2.0;
}
for (int ii = 0; ii < polygon_number;
++ii, radian1 = radian2, radian2 += add_radian) {
if (radian1 <= radian && radian <= radian2) {
x1 = radius * cos(radian1);
y1 = radius * sin(radian1);
x2 = radius * cos(radian2);
y2 = radius * sin(radian2);
break;
}
}
if (x1 == 0.0) {
/* エラー */
return -1.0; //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
}
return fabs((y1 - y2) * xp + (x2 - x1) * yp + x1 * y2 - y1 * x2) /
sqrt((y1 - y2) * (y1 - y2) + (x2 - x1) * (x2 - x1));
}
void alloc_lens_matrix_(const int odd_diameter, std::vector<int> &lens_offsets,
std::vector<int> &lens_sizes,
std::vector<std::vector<double>> &lens_ratio) {
lens_offsets.resize(odd_diameter);
lens_sizes.resize(odd_diameter);
lens_ratio.resize(odd_diameter);
for (int yy = 0; yy < odd_diameter; ++yy) {
lens_ratio.at(yy).resize(odd_diameter);
}
}
void free_lens_matrix_(std::vector<int> &lens_offsets,
std::vector<int> &lens_sizes,
std::vector<std::vector<double>> &lens_ratio) {
lens_ratio.clear();
lens_sizes.clear();
lens_offsets.clear();
}
}
const int igs::maxmin::diameter_from_outer_radius(const double outer_radius) {
/* -------- 半径(radius)を含むピクセル直径 --------
中心pixelが必要、奇数(1,3,5...)となる
---+---|---+---|---+---|---+---|---+---
outer_radius--> +---->
Pixelの半分幅足す(+0.5) |-------->
全体が入るPixel数幅(ceil()) |--------------->
整数化時誤差防ぐ(+0.5) |------------------->
整数化(static_cast<int>) |-------|------->
中心を除く半径Pixel幅(-1) |------->
中心除く直径(*2) <-------| |------->
直径(+1) <-------|-------|------->
-->odd_diameter
*/
return (static_cast<int>(ceil(outer_radius + 0.5) + 0.5) - 1) * 2 + 1;
}
const double igs::maxmin::outer_radius_from_radius(
const double radius, const double smooth_outer_range) {
if (radius < 1.0) {
/*
半径ゼロでは処理しない絵となり、
わずかな半径に変化したとき、
いきなり大きなエッジ足(smooth_outer_range)が
飛び出さないように
radiusがゼロなら足長さを1.0(影響のない最小値)に、
radiusが1ならradius + smooth_outer_rangeになり、
影響が反映される
smooth_outer_rangeは1以上でないとsmoothにならない。
*/
return 1.0 + radius * (radius + smooth_outer_range - 1.0);
}
return radius + smooth_outer_range;
}
const int igs::maxmin::alloc_and_shape_lens_matrix(
const double radius // 0<=
,
const double outer_radius, const int polygon_number // =2
,
const double roll_degree // 0<= ... <=360
,
std::vector<int> &lens_offsets, std::vector<int> &lens_sizes,
std::vector<std::vector<double>> &lens_ratio) {
/*------ 大きさが無い指定のときMemory解放 ------*/
if (radius <= 0.0) {
free_lens_matrix_(lens_offsets, lens_sizes, lens_ratio);
return 0;
}
/*------ 半径から必要なピクセル単位の直径を求める ------*/
const int odd_diameter =
igs::maxmin::diameter_from_outer_radius(outer_radius);
/*------ Memory確保or再利用 ------*/
alloc_lens_matrix_(odd_diameter, lens_offsets, lens_sizes, lens_ratio);
/*------ lens matrix情報を書き込む ------*/
igs::maxmin::reshape_lens_matrix(
radius,
igs::maxmin::outer_radius_from_radius(radius, outer_radius - radius),
odd_diameter, polygon_number, roll_degree, lens_offsets, lens_sizes,
lens_ratio);
return odd_diameter;
}
const void igs::maxmin::reshape_lens_matrix(
const double radius // 0<=
,
const double outer_radius, const int odd_diameter /* 最大直径 */
,
const int polygon_number // =2
,
const double roll_degree // 0<= ... <=360
,
std::vector<int> &lens_offsets /* 最大直径分の配列 */
,
std::vector<int> &lens_sizes /* 最大直径分の配列 */
,
std::vector<std::vector<double>> &lens_ratio /* 最大直径分の配列 */
) {
/***std::cout
<< "ra=" << radius
<< " outr=" << outer_radius
<< " dia=" << odd_diameter
<< " pol=" << polygon_number
<< " deg=" << roll_degree
<< " lens_offsets=" << lens_offsets.size()
<< " lens_sizes=" << lens_sizes.size()
<< " lens_ratio=" << lens_ratio.size()
<< std::endl;***/
/* --- scanlineスタート位置とscanlineサイズ生成 --- */
double yp = 0.5 - (odd_diameter / 2.0); /* matrix中心からのy距離 */
for (int yy = 0; yy < odd_diameter; ++yy, yp += 1.0) {
/* --- 開始位置とサイズを計算 ------------------- */
lens_offsets.at(yy) = -1; /* 初期化 */
lens_sizes.at(yy) = 0; /* 初期化 */
double xp = 0.5 - (odd_diameter / 2.0); /* matrix中心からのx距離 */
for (int xx = 0; xx < odd_diameter; ++xx, xp += 1.0) {
const double current_radius = sqrt(xp * xp + yp * yp);
/* 外枠影響内 */
if ((current_radius <= outer_radius) &&
inside_polygon_(outer_radius, odd_diameter, xp, yp, polygon_number,
roll_degree)) {
/* scanlineスタート位置(ポインタ)のセット */
if (lens_offsets.at(yy) < 0) {
/* 半径内に入った瞬間その位置を記録 */
lens_offsets.at(yy) = xx;
}
} else { /* 影響外 */
/* scalineサイズのセット */
if ((0 <= lens_offsets.at(yy)) && (lens_sizes.at(yy) == 0)) {
/* 半径内を出た瞬間そこまでのサイズを記録 */
lens_sizes.at(yy) = xx - lens_offsets.at(yy);
}
}
}
/* scanlineの最後までが半径内のとき */
if ((0 <= lens_offsets.at(yy)) && (lens_sizes.at(yy) == 0)) {
lens_sizes.at(yy) = odd_diameter - lens_offsets.at(yy);
}
/* --- 外枠から内枠へのリニア変化 --------------- */
/* 円の外 */
if (lens_sizes.at(yy) <= 0) {
continue;
}
/* ratio設定 */
xp = 0.5 - (odd_diameter / 2.0); /* matrix中心からのx距離 */
int xr = 0;
for (int xx = 0; xx < odd_diameter; ++xx, xp += 1.0) {
const double current_radius = sqrt(xp * xp + yp * yp);
/* 外枠内 */
if ((current_radius <= outer_radius) &&
inside_polygon_(outer_radius, odd_diameter, xp, yp, polygon_number,
roll_degree)) {
/* 内枠内 */
if ((current_radius <= radius) &&
inside_polygon_(radius, odd_diameter, xp, yp, polygon_number,
roll_degree)) {
lens_ratio.at(yy).at(xr++) = 1.0;
}
/* 外枠と内枠の間 */
else {
if (polygon_number < 3) {
lens_ratio.at(yy).at(xr++) =
(outer_radius - current_radius) / (outer_radius - radius);
} else {
const double leninn =
length_to_polygon_(radius, xp, yp, polygon_number, roll_degree);
const double lenout = length_to_polygon_(
outer_radius, xp, yp, polygon_number, roll_degree);
lens_ratio.at(yy).at(xr++) = lenout / (leninn + lenout);
}
}
}
}
}
}