public static void Bisectrix(LineParameters l1,
LineParameters l2,
out int x, out int y)
{
double k = (double)(l2.len) / (double)(l1.len);
double tx = l2.x2 - (l2.x1 - l1.x1) * k;
double ty = l2.y2 - (l2.y1 - l1.y1) * k;
//All bisectrices must be on the right of the line
//If the next point is on the left (l1 => l2.2)
//then the bisectix should be rotated by 180 degrees.
if ((double)(l2.x2 - l2.x1) * (double)(l2.y1 - l1.y1) <
(double)(l2.y2 - l2.y1) * (double)(l2.x1 - l1.x1) + 100.0)
{
tx -= (tx - l2.x1) * 2.0;
ty -= (ty - l2.y1) * 2.0;
}
// Check if the bisectrix is too short
double dx = tx - l2.x1;
double dy = ty - l2.y1;
if ((int)Math.Sqrt(dx * dx + dy * dy) < SUBPIXEL_SCALE)
{
x = (l2.x1 + l2.x1 + (l2.y1 - l1.y1) + (l2.y2 - l2.y1)) >> 1;
y = (l2.y1 + l2.y1 - (l2.x1 - l1.x1) - (l2.x2 - l2.x1)) >> 1;
return;
}
x = AggMath.iround(tx);
y = AggMath.iround(ty);
}
//---------------------------------------------------------------------
public DistanceInterpolator3(int x1, int y1, int x2, int y2,
int sx, int sy, int ex, int ey,
int x, int y)
{
unchecked
{
_dx = (x2 - x1);
_dy = (y2 - y1);
_dx_start = (LineAA.Mr(sx) - LineAA.Mr(x1));
_dy_start = (LineAA.Mr(sy) - LineAA.Mr(y1));
_dx_end = (LineAA.Mr(ex) - LineAA.Mr(x2));
_dy_end = (LineAA.Mr(ey) - LineAA.Mr(y2));
_dist = (AggMath.iround((double)(x + LineAA.SUBPIXEL_SCALE / 2 - x2) * (double)(_dy) -
(double)(y + LineAA.SUBPIXEL_SCALE / 2 - y2) * (double)(_dx)));
_dist_start = ((LineAA.Mr(x + LineAA.SUBPIXEL_SCALE / 2) - LineAA.Mr(sx)) * _dy_start -
(LineAA.Mr(y + LineAA.SUBPIXEL_SCALE / 2) - LineAA.Mr(sy)) * _dx_start);
_dist_end = ((LineAA.Mr(x + LineAA.SUBPIXEL_SCALE / 2) - LineAA.Mr(ex)) * _dy_end -
(LineAA.Mr(y + LineAA.SUBPIXEL_SCALE / 2) - LineAA.Mr(ey)) * _dx_end);
_dx <<= LineAA.SUBPIXEL_SHIFT;
_dy <<= LineAA.SUBPIXEL_SHIFT;
_dx_start <<= LineAA.MR_SUBPIXEL_SHIFT;
_dy_start <<= LineAA.MR_SUBPIXEL_SHIFT;
_dx_end <<= LineAA.MR_SUBPIXEL_SHIFT;
_dy_end <<= LineAA.MR_SUBPIXEL_SHIFT;
}
}
//
public void SetFilterOffset(double dx, double dy)
{
_dx_dbl = dx;
_dy_dbl = dy;
_dx_int = AggMath.iround(dx * img_subpix_const.SCALE);
_dy_int = AggMath.iround(dy * img_subpix_const.SCALE);
}
//---------------------------------------------------------------------
public void Setup(double r, double fx, double fy)
{
m_r = AggMath.iround(r * GradientSpanGen.GR_SUBPIX_SCALE);
m_fx = AggMath.iround(fx * GradientSpanGen.GR_SUBPIX_SCALE);
m_fy = AggMath.iround(fy * GradientSpanGen.GR_SUBPIX_SCALE);
UpdateValues();
}
//----------------------------------------------------------------
public void Begin(double x, double y, int len)
{
// Calculate transformed coordinates at x1,y1
double xt = x;
double yt = y;
m_trans_dir.Transform(ref xt, ref yt);
int x1 = AggMath.iround(xt * SUBPIXEL_SCALE);
int y1 = AggMath.iround(yt * SUBPIXEL_SCALE);
double dx;
double dy;
double delta = 1 / (double)SUBPIXEL_SCALE;
// Calculate scale by X at x1,y1
dx = xt + delta;
dy = yt;
m_trans_inv.Transform(ref dx, ref dy);
dx -= x;
dy -= y;
int sx1 = (int)AggMath.uround(SUBPIXEL_SCALE / Math.Sqrt(dx * dx + dy * dy)) >> SUBPIXEL_SHIFT;
// Calculate scale by Y at x1,y1
dx = xt;
dy = yt + delta;
m_trans_inv.Transform(ref dx, ref dy);
dx -= x;
dy -= y;
int sy1 = (int)AggMath.uround(SUBPIXEL_SCALE / Math.Sqrt(dx * dx + dy * dy)) >> SUBPIXEL_SHIFT;
// Calculate transformed coordinates at x2,y2
x += len;
xt = x;
yt = y;
m_trans_dir.Transform(ref xt, ref yt);
int x2 = AggMath.iround(xt * SUBPIXEL_SCALE);
int y2 = AggMath.iround(yt * SUBPIXEL_SCALE);
// Calculate scale by X at x2,y2
dx = xt + delta;
dy = yt;
m_trans_inv.Transform(ref dx, ref dy);
dx -= x;
dy -= y;
int sx2 = (int)AggMath.uround(SUBPIXEL_SCALE / Math.Sqrt(dx * dx + dy * dy)) >> SUBPIXEL_SHIFT;
// Calculate scale by Y at x2,y2
dx = xt;
dy = yt + delta;
m_trans_inv.Transform(ref dx, ref dy);
dx -= x;
dy -= y;
int sy2 = (int)AggMath.uround(SUBPIXEL_SCALE / Math.Sqrt(dx * dx + dy * dy)) >> SUBPIXEL_SHIFT;
// Initialize the interpolators
m_coord_x = new LineInterpolatorDDA2(x1, x2, (int)len);
m_coord_y = new LineInterpolatorDDA2(y1, y2, (int)len);
m_scale_x = new LineInterpolatorDDA2(sx1, sx2, (int)len);
m_scale_y = new LineInterpolatorDDA2(sy1, sy2, (int)len);
}
public DistanceInterpolator1(int x1, int y1, int x2, int y2, int x, int y)
{
_dx = (x2 - x1);
_dy = (y2 - y1);
_dist = (AggMath.iround((double)(x + LineAA.SUBPIXEL_SCALE / 2 - x2) * (double)(_dy) -
(double)(y + LineAA.SUBPIXEL_SCALE / 2 - y2) * (double)(_dx)));
_dx <<= LineAA.SUBPIXEL_SHIFT;
_dy <<= LineAA.SUBPIXEL_SHIFT;
}
//---------------------------------------------------------------------
public int Calculate(int x, int y, int d)
{
double dx = x - m_fx;
double dy = y - m_fy;
double d2 = dx * m_fy - dy * m_fx;
double d3 = m_r2 * (dx * dx + dy * dy) - d2 * d2;
return(AggMath.iround((dx * m_fx + dy * m_fy + System.Math.Sqrt(System.Math.Abs(d3))) * m_mul));
}
//--------------------------------------------------------------------
// This function normalizes integer values and corrects the rounding
// errors. It doesn't do anything with the source floating point values
// (m_weight_array_dbl), it corrects only integers according to the rule
// of 1.0 which means that any sum of pixel weights must be equal to 1.0.
// So, the filter function must produce a graph of the proper shape.
//--------------------------------------------------------------------
void Normalize()
{
int i;
int flip = 1;
for (i = 0; i < (int)ImgSubPixConst.SCALE; i++)
{
for (; ;)
{
int sum = 0;
int j;
for (j = 0; j < _diameter; j++)
{
sum += _weight_array[j * (int)ImgSubPixConst.SCALE + i];
}
if (sum == (int)ImgFilterConst.SCALE)
{
break;
}
double k = (double)((int)ImgFilterConst.SCALE) / (double)(sum);
sum = 0;
for (j = 0; j < _diameter; j++)
{
sum += _weight_array[j * (int)ImgSubPixConst.SCALE + i] =
(int)AggMath.iround(_weight_array[j * (int)ImgSubPixConst.SCALE + i] * k);
}
sum -= (int)ImgFilterConst.SCALE;
int inc = (sum > 0) ? -1 : 1;
for (j = 0; j < _diameter && sum != 0; j++)
{
flip ^= 1;
int idx = flip != 0 ? _diameter / 2 + j / 2 : _diameter / 2 - j / 2;
int v = _weight_array[idx * (int)ImgSubPixConst.SCALE + i];
if (v < (int)ImgFilterConst.SCALE)
{
_weight_array[idx * (int)ImgSubPixConst.SCALE + i] += (int)inc;
sum += inc;
}
}
}
}
int pivot = _diameter << (ImgSubPixConst.SHIFT - 1);
for (i = 0; i < pivot; i++)
{
_weight_array[pivot + i] = _weight_array[pivot - i];
}
int end = (Diameter << ImgSubPixConst.SHIFT) - 1;
_weight_array[0] = _weight_array[end];
}
/// <summary>
/// fix_degeneration_bisectrix_start
/// </summary>
/// <param name="lp"></param>
/// <param name="x"></param>
/// <param name="y"></param>
public static void FixDegenBisectrixStart(LineParameters lp,
ref int x, ref int y)
{
int d = AggMath.iround(((double)(x - lp.x2) * (double)(lp.y2 - lp.y1) -
(double)(y - lp.y2) * (double)(lp.x2 - lp.x1)) / lp.len);
if (d < SUBPIXEL_SCALE / 2)
{
x = lp.x1 + (lp.y2 - lp.y1);
y = lp.y1 - (lp.x2 - lp.x1);
}
}
//---------------------------------------------------------------------
public DistanceInterpolator2(int x1, int y1, int x2, int y2,
int sx, int sy, int x, int y)
{
m_dx = (x2 - x1);
m_dy = (y2 - y1);
m_dx_start = (LineAA.Mr(sx) - LineAA.Mr(x1));
m_dy_start = (LineAA.Mr(sy) - LineAA.Mr(y1));
m_dist = (AggMath.iround((double)(x + LineAA.SUBPIXEL_SCALE / 2 - x2) * (double)(m_dy) -
(double)(y + LineAA.SUBPIXEL_SCALE / 2 - y2) * (double)(m_dx)));
m_dist_start = ((LineAA.Mr(x + LineAA.SUBPIXEL_SCALE / 2) - LineAA.Mr(sx)) * m_dy_start -
(LineAA.Mr(y + LineAA.SUBPIXEL_SCALE / 2) - LineAA.Mr(sy)) * m_dx_start);
m_dx <<= LineAA.SUBPIXEL_SHIFT;
m_dy <<= LineAA.SUBPIXEL_SHIFT;
m_dx_start <<= LineAA.MR_SUBPIXEL_SHIFT;
m_dy_start <<= LineAA.MR_SUBPIXEL_SHIFT;
}
public DistanceInterpolator2(int x1, int y1, int x2, int y2,
int ex, int ey, int x, int y, int none)
{
_dx = (x2 - x1);
_dy = (y2 - y1);
_dx_start = (LineAA.Mr(ex) - LineAA.Mr(x2));
_dy_start = (LineAA.Mr(ey) - LineAA.Mr(y2));
_dist = (AggMath.iround((double)(x + LineAA.SUBPIXEL_SCALE / 2 - x2) * (double)(_dy) -
(double)(y + LineAA.SUBPIXEL_SCALE / 2 - y2) * (double)(_dx)));
_dist_start = ((LineAA.Mr(x + LineAA.SUBPIXEL_SCALE / 2) - LineAA.Mr(ex)) * _dy_start -
(LineAA.Mr(y + LineAA.SUBPIXEL_SCALE / 2) - LineAA.Mr(ey)) * _dx_start);
_dx <<= LineAA.SUBPIXEL_SHIFT;
_dy <<= LineAA.SUBPIXEL_SHIFT;
_dx_start <<= LineAA.MR_SUBPIXEL_SHIFT;
_dy_start <<= LineAA.MR_SUBPIXEL_SHIFT;
}
public void Calculate(double y)
{
double k = (y - m_y1) * m_1dy;
if (k < 0.0)
{
k = 0.0;
}
if (k > 1.0)
{
k = 1.0;
}
m_r = m_r1 + AggMath.iround(m_dr * k);
m_g = m_g1 + AggMath.iround(m_dg * k);
m_b = m_b1 + AggMath.iround(m_db * k);
m_a = m_a1 + AggMath.iround(m_da * k);
m_x = AggMath.iround((m_x1 + m_dx * k) * (double)SUBPIXEL_SCALE);
}
public void Calculate(double y)
{
double k = (y - _y1) * _1dy;
if (k < 0.0)
{
k = 0.0;
}
if (k > 1.0)
{
k = 1.0;
}
_r = _r1 + AggMath.iround(_dr * k);
_g = _g1 + AggMath.iround(_dg * k);
_b = _b1 + AggMath.iround(_db * k);
_a = _a1 + AggMath.iround(_da * k);
_x = AggMath.iround((_x1 + _dx * k) * (double)SUBPIXEL_SCALE);
}
public void Reset(ISpanInterpolator inter,
IGradientValueCalculator gvc,
IGradientColorsProvider m_colorsProvider,
double distance)
{
_grad0X = _grad0Y = _xoffset = _yoffset = 0;//reset
_interpolator = inter;
_grValueCalculator = gvc;
_colorsProvider = m_colorsProvider;
_dist = AggMath.iround(distance * GR_SUBPIX_SCALE);
if (_dist < 1)
{
_dist = 1;
}
_stepRatio = (float)m_colorsProvider.GradientSteps / (float)_dist;
_xoffset = _yoffset = 0;//reset
}
//----------------------------------------------------------------
public void Begin(double x, double y, int len)
{
double tx = x;
double ty = y;
_trans.Transform(ref tx, ref ty);
int x1 = AggMath.iround(tx * SUB_PIXEL_SCALE);
int y1 = AggMath.iround(ty * SUB_PIXEL_SCALE);
//
tx = x + len; //***
ty = y; //**
_trans.Transform(ref tx, ref ty);
int x2 = AggMath.iround(tx * SUB_PIXEL_SCALE);
int y2 = AggMath.iround(ty * SUB_PIXEL_SCALE);
//
_li_x = new LineInterpolatorDDA2(x1, x2, len);
_li_y = new LineInterpolatorDDA2(y1, y2, len);
}
//----------------------------------------------------------------
public void Begin(double x, double y, int len)
{
double tx;
double ty;
tx = x;
ty = y;
m_trans.Transform(ref tx, ref ty);
int x1 = AggMath.iround(tx * (double)SUB_PIXEL_SCALE);
int y1 = AggMath.iround(ty * (double)SUB_PIXEL_SCALE);
tx = x + len;
ty = y;
m_trans.Transform(ref tx, ref ty);
int x2 = AggMath.iround(tx * (double)SUB_PIXEL_SCALE);
int y2 = AggMath.iround(ty * (double)SUB_PIXEL_SCALE);
m_li_x = new LineInterpolatorDDA2(x1, x2, (int)len);
m_li_y = new LineInterpolatorDDA2(y1, y2, (int)len);
}
//----------------------------------------------------------------
public void ReSync(double xe, double ye, int len)
{
// Assume x1,y1 are equal to the ones at the previous end point
int x1 = m_coord_x.Y;
int y1 = m_coord_y.Y;
int sx1 = m_scale_x.Y;
int sy1 = m_scale_y.Y;
// Calculate transformed coordinates at x2,y2
double xt = xe;
double yt = ye;
m_trans_dir.Transform(ref xt, ref yt);
int x2 = AggMath.iround(xt * SUBPIXEL_SCALE);
int y2 = AggMath.iround(yt * SUBPIXEL_SCALE);
double delta = 1 / (double)SUBPIXEL_SCALE;
double dx;
double dy;
// Calculate scale by X at x2,y2
dx = xt + delta;
dy = yt;
m_trans_inv.Transform(ref dx, ref dy);
dx -= xe;
dy -= ye;
int sx2 = (int)AggMath.uround(SUBPIXEL_SCALE / Math.Sqrt(dx * dx + dy * dy)) >> SUBPIXEL_SHIFT;
// Calculate scale by Y at x2,y2
dx = xt;
dy = yt + delta;
m_trans_inv.Transform(ref dx, ref dy);
dx -= xe;
dy -= ye;
int sy2 = (int)AggMath.uround(SUBPIXEL_SCALE / Math.Sqrt(dx * dx + dy * dy)) >> SUBPIXEL_SHIFT;
// Initialize the interpolators
m_coord_x = new LineInterpolatorDDA2(x1, x2, (int)len);
m_coord_y = new LineInterpolatorDDA2(y1, y2, (int)len);
m_scale_x = new LineInterpolatorDDA2(sx1, sx2, (int)len);
m_scale_y = new LineInterpolatorDDA2(sy1, sy2, (int)len);
}
//
public void Rebuild(Imaging.IImageFilterFunc filterFunc, bool normalization = true)
{
double r = filterFunc.GetRadius();
//---------------
_radius = r;
_diameter = AggMath.uceil(r) * 2;
_start = -((_diameter / 2) - 1);
int size = _diameter << ImgSubPixConst.SHIFT;
if (size > _weight_array.Length)
{
_weight_array = new int[size];
}
else if (size < _weight_array.Length)
{
_weight_array = new int[size];
}
//---------------
int i;
int pivot = Diameter << (ImgSubPixConst.SHIFT - 1);
for (i = 0; i < pivot; i++)
{
double x = (double)i / (double)ImgSubPixConst.SCALE;
double y = filterFunc.CalculateWeight(x);
_weight_array[pivot + i] =
_weight_array[pivot - i] = AggMath.iround(y * ImgFilterConst.SCALE);
}
int end = (Diameter << ImgSubPixConst.SHIFT) - 1;
_weight_array[0] = _weight_array[end];
if (normalization)
{
Normalize();
}
}
void Calculate(Imaging.IImageFilter filter, bool normalization)
{
double r = filter.GetRadius();
ReallocLut(r);
int i;
int pivot = Diameter << (ImgSubPixConst.SHIFT - 1);
for (i = 0; i < pivot; i++)
{
double x = (double)i / (double)ImgSubPixConst.SCALE;
double y = filter.CalculateWeight(x);
_weight_array[pivot + i] =
_weight_array[pivot - i] = AggMath.iround(y * ImgFilterConst.SCALE);
}
int end = (Diameter << ImgSubPixConst.SHIFT) - 1;
_weight_array[0] = _weight_array[end];
if (normalization)
{
Normalize();
}
}
public static int Convert(double x)
{
return(AggMath.iround(
x * LineAA.SUBPIXEL_SCALE,
LineAA.SUBPIXEL_COORD));
}
//--------------------------------- //from vector clipper static int upscale(double v) => AggMath.iround(v * poly_subpix.SCALE);
//----------------------------------------------------------------
public void ReSync(double xe, double ye, int len)
{
m_trans.Transform(ref xe, ref ye);
m_li_x = new LineInterpolatorDDA2(m_li_x.Y, AggMath.iround(xe * (double)SUB_PIXEL_SCALE), (int)len);
m_li_y = new LineInterpolatorDDA2(m_li_y.Y, AggMath.iround(ye * (double)SUB_PIXEL_SCALE), (int)len);
}
//---------------------------------
//from vector clipper
static int upscale(double v)
{
return(AggMath.iround(v * poly_subpix.SCALE));
}
