145 lines
3.3 KiB
C++
145 lines
3.3 KiB
C++
// SPDX-License-Identifier: BSD-3-Clause
|
|
|
|
// Arc.cpp
|
|
|
|
// Copyright 2011, Dan Heeks
|
|
// This program is released under the BSD license. See the file COPYING for details.
|
|
|
|
#include "Arc.h"
|
|
#include "Curve.h"
|
|
|
|
void CArc::SetDirWithPoint(const Point& p)
|
|
{
|
|
double angs = atan2(m_s.y - m_c.y, m_s.x - m_c.x);
|
|
double ange = atan2(m_e.y - m_c.y, m_e.x - m_c.x);
|
|
double angp = atan2(p.y - m_c.y, p.x - m_c.x);
|
|
if (ange < angs) {
|
|
ange += 6.2831853071795864;
|
|
}
|
|
if (angp < angs - 0.0000000000001) {
|
|
angp += 6.2831853071795864;
|
|
}
|
|
if (angp > ange + 0.0000000000001) {
|
|
m_dir = false;
|
|
}
|
|
else {
|
|
m_dir = true;
|
|
}
|
|
}
|
|
|
|
double CArc::IncludedAngle() const
|
|
{
|
|
double angs = atan2(m_s.y - m_c.y, m_s.x - m_c.x);
|
|
double ange = atan2(m_e.y - m_c.y, m_e.x - m_c.x);
|
|
if (m_dir) {
|
|
// make sure ange > angs
|
|
if (ange < angs) {
|
|
ange += 6.2831853071795864;
|
|
}
|
|
}
|
|
else {
|
|
// make sure angs > ange
|
|
if (angs < ange) {
|
|
angs += 6.2831853071795864;
|
|
}
|
|
}
|
|
|
|
return fabs(ange - angs);
|
|
}
|
|
|
|
bool CArc::AlmostALine() const
|
|
{
|
|
Point mid_point = MidParam(0.5);
|
|
if (Line(m_s, m_e - m_s).Dist(mid_point) <= Point::tolerance) {
|
|
return true;
|
|
}
|
|
|
|
const double max_arc_radius = 1.0 / Point::tolerance;
|
|
double radius = m_c.dist(m_s);
|
|
if (radius > max_arc_radius) {
|
|
return true; // We don't want to produce an arc whose radius is too large.
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
Point CArc::MidParam(double param) const
|
|
{
|
|
/// returns a point which is 0-1 along arc
|
|
if (fabs(param) < 0.00000000000001) {
|
|
return m_s;
|
|
}
|
|
if (fabs(param - 1.0) < 0.00000000000001) {
|
|
return m_e;
|
|
}
|
|
|
|
Point p;
|
|
Point v = m_s - m_c;
|
|
v.Rotate(param * IncludedAngle());
|
|
p = v + m_c;
|
|
|
|
return p;
|
|
}
|
|
|
|
// segments - number of segments per full revolution!
|
|
// d_angle - determines the direction and the amount of the arc to draw
|
|
void CArc::GetSegments(void (*callbackfunc)(const double* p), double pixels_per_mm) const
|
|
{
|
|
if (m_s == m_e) {
|
|
return;
|
|
}
|
|
|
|
Point Va = m_s - m_c;
|
|
Point Vb = m_e - m_c;
|
|
|
|
double start_angle = atan2(Va.y, Va.x);
|
|
double end_angle = atan2(Vb.y, Vb.x);
|
|
|
|
if (m_dir) {
|
|
if (start_angle > end_angle) {
|
|
end_angle += 6.28318530717958;
|
|
}
|
|
}
|
|
else {
|
|
if (start_angle < end_angle) {
|
|
end_angle -= 6.28318530717958;
|
|
}
|
|
}
|
|
|
|
double radius = m_c.dist(m_s);
|
|
double d_angle = end_angle - start_angle;
|
|
int segments = (int)(fabs(pixels_per_mm * radius * d_angle / 6.28318530717958 + 1));
|
|
|
|
double theta = d_angle / (double)segments;
|
|
while (theta > 1.0) {
|
|
segments *= 2;
|
|
theta = d_angle / (double)segments;
|
|
}
|
|
double tangential_factor = tan(theta);
|
|
double radial_factor = 1 - cos(theta);
|
|
|
|
double x = radius * cos(start_angle);
|
|
double y = radius * sin(start_angle);
|
|
|
|
double pp[3] = {0.0, 0.0, 0.0};
|
|
|
|
for (int i = 0; i < segments + 1; i++) {
|
|
Point p = m_c + Point(x, y);
|
|
pp[0] = p.x;
|
|
pp[1] = p.y;
|
|
(*callbackfunc)(pp);
|
|
|
|
double tx = -y;
|
|
double ty = x;
|
|
|
|
x += tx * tangential_factor;
|
|
y += ty * tangential_factor;
|
|
|
|
double rx = -x;
|
|
double ry = -y;
|
|
|
|
x += rx * radial_factor;
|
|
y += ry * radial_factor;
|
|
}
|
|
}
|