/**
* @brief VSpline constructor.
* @param p1 first point spline.
* @param p4 last point spline.
* @param angle1 angle from first point to first control point.
* @param angle2 angle from second point to second control point.
* @param kCurve coefficient of curvature spline.
* @param kAsm1 coefficient of length first control line.
* @param kAsm2 coefficient of length second control line.
*/
VSpline::VSpline (VPointF p1, VPointF p4, qreal angle1, qreal angle2, qreal kAsm1, qreal kAsm2, qreal kCurve,
quint32 idObject, Draw mode)
:VAbstractCurve(GOType::Spline, idObject, mode), p1(p1), p2(QPointF()), p3(QPointF()), p4(p4), angle1(angle1),
angle2(angle2), kAsm1(kAsm1), kAsm2(kAsm2), kCurve(kCurve)
{
CreateName();
this->p1 = p1;
this->p4 = p4;
this->angle1 = angle1;
this->angle2 = angle2;
this->kAsm1 = kAsm1;
this->kAsm2 = kAsm2;
this->kCurve = kCurve;
qreal L = 0, radius = 0, angle = 90;
QPointF point1 = GetP1().toQPointF();
QPointF point4 = GetP4().toQPointF();
radius = QLineF(point1, point4).length()/1.414213;//1.414213=sqrt(2);
L = kCurve * radius * 4 / 3 * tan( angle * M_PI / 180.0 / 4 );
QLineF p1p2(GetP1().x(), GetP1().y(), GetP1().x() + L * kAsm1, GetP1().y());
p1p2.setAngle(angle1);
QLineF p4p3(GetP4().x(), GetP4().y(), GetP4().x() + L * kAsm2, GetP4().y());
p4p3.setAngle(angle2);
this->p2 = p1p2.p2();
this->p3 = p4p3.p2();
}
void Path::addArcTo(const FloatPoint& p1, const FloatPoint& p2, float radius)
{
FloatPoint p0(m_path.currentPosition());
FloatPoint p1p0((p0.x() - p1.x()), (p0.y() - p1.y()));
FloatPoint p1p2((p2.x() - p1.x()), (p2.y() - p1.y()));
float p1p0_length = sqrtf(p1p0.x() * p1p0.x() + p1p0.y() * p1p0.y());
float p1p2_length = sqrtf(p1p2.x() * p1p2.x() + p1p2.y() * p1p2.y());
double cos_phi = (p1p0.x() * p1p2.x() + p1p0.y() * p1p2.y()) / (p1p0_length * p1p2_length);
// The points p0, p1, and p2 are on the same straight line (HTML5, 4.8.11.1.8)
// We could have used areCollinear() here, but since we're reusing
// the variables computed above later on we keep this logic.
if (qFuzzyCompare(qAbs(cos_phi), 1.0)) {
m_path.lineTo(p1);
return;
}
float tangent = radius / tan(acos(cos_phi) / 2);
float factor_p1p0 = tangent / p1p0_length;
FloatPoint t_p1p0((p1.x() + factor_p1p0 * p1p0.x()), (p1.y() + factor_p1p0 * p1p0.y()));
FloatPoint orth_p1p0(p1p0.y(), -p1p0.x());
float orth_p1p0_length = sqrt(orth_p1p0.x() * orth_p1p0.x() + orth_p1p0.y() * orth_p1p0.y());
float factor_ra = radius / orth_p1p0_length;
// angle between orth_p1p0 and p1p2 to get the right vector orthographic to p1p0
double cos_alpha = (orth_p1p0.x() * p1p2.x() + orth_p1p0.y() * p1p2.y()) / (orth_p1p0_length * p1p2_length);
if (cos_alpha < 0.f)
orth_p1p0 = FloatPoint(-orth_p1p0.x(), -orth_p1p0.y());
FloatPoint p((t_p1p0.x() + factor_ra * orth_p1p0.x()), (t_p1p0.y() + factor_ra * orth_p1p0.y()));
// calculate angles for addArc
orth_p1p0 = FloatPoint(-orth_p1p0.x(), -orth_p1p0.y());
float sa = acos(orth_p1p0.x() / orth_p1p0_length);
if (orth_p1p0.y() < 0.f)
sa = 2 * piDouble - sa;
// anticlockwise logic
bool anticlockwise = false;
float factor_p1p2 = tangent / p1p2_length;
FloatPoint t_p1p2((p1.x() + factor_p1p2 * p1p2.x()), (p1.y() + factor_p1p2 * p1p2.y()));
FloatPoint orth_p1p2((t_p1p2.x() - p.x()), (t_p1p2.y() - p.y()));
float orth_p1p2_length = sqrtf(orth_p1p2.x() * orth_p1p2.x() + orth_p1p2.y() * orth_p1p2.y());
float ea = acos(orth_p1p2.x() / orth_p1p2_length);
if (orth_p1p2.y() < 0)
ea = 2 * piDouble - ea;
if ((sa > ea) && ((sa - ea) < piDouble))
anticlockwise = true;
if ((sa < ea) && ((ea - sa) > piDouble))
anticlockwise = true;
m_path.lineTo(t_p1p0);
addArc(p, radius, sa, ea, anticlockwise);
}
void InputCommandTemplateUnitTests::run()
{
assert( test1(L"", 1, L"") );
assert( test1(L"aaaa;#bbbb dd ff gg;cccc", 3, L"aaaa", L"#bbbb dd ff gg", L"cccc") );
assert( test1(L" {aaaa \"fff;vvv\" {'':; }gg}", 1, L" aaaa \"fff;vvv\" {'':; }gg" ) );
assert( test1(L"#abc {asdasd}; def xxx; #eee 'aaa' 'bbb' ", 3, L"#abc {asdasd}", L" def xxx", L"#eee 'aaa' 'bbb' ") );
assert( test1(L" #ddd {fff} 'f;f{f;f}f;f' {{fd;fd}f;f}", 1, L"#ddd {fff} 'f;f{f;f}f;f' {{fd;fd}f;f}") );
assert( test1(L"#ddd {fff} ; {ffff 'f;f{f;f}f;f'}", 2, L"#ddd {fff} ", L" ffff 'f;f{f;f}f;f'") );
assert( test1(L"#bbb '{};fff;\"aaa\"'", 1, L"#bbb '{};fff;\"aaa\"'") );
InputCommands g1;
g1.push_back(makecmd(false, L" ", L"", L" ", 0));
assert(test2(L" ", 0, &g1));
InputCommands g2;
g2.push_back(makecmd(false, L"тест", L" 123 456 789", L"тест", 3, L" 123", L" 456", L" 789" ));
assert(test2(L"тест 123 456 789", 3, &g2));
InputCommands g3;
g3.push_back(makecmd(false, L"тест2", L" aaa bbb ccc ", L"тест2", 4, L" aaa", L" bbb", L" ccc", L" "));
assert(test2(L"тест2 aaa bbb ccc ", 4, &g3));
InputCommands t1;
t1.push_back( makecmd(true, L"# wout", L" 1 test test2", L" wout", 3, L"1", L"test", L"test2") );
assert( test2(L"# wout 1 test test2", 0, &t1) );
InputCommands t2;
t2.push_back(makecmd(true, L"#wout", L" 1 {red} blue", L"wout", 3, L"1", L"red", L"blue"));
assert(test2(L"#wout 1 {red} blue", 0, &t2));
InputCommands t3;
t3.push_back(makecmd(true, L"#wout", L" 'a;b;c\"\"'", L"wout", 1, L"a;b;c\"\""));
t3.push_back(makecmd(true, L"#ex", L" {v;d's}", L"ex", 1, L"v;d's"));
assert(test2(L"#wout 'a;b;c\"\"';#ex {v;d's}", 0, &t3));
InputCommands t4;
t4.push_back(makecmd(true, L"#wout", L" %0", L"wout", 1, param0));
assert(test2(L"#wout %0", 0, &t4));
InputCommands t5;
tstring p1p2(param1);
p1p2.append(param2);
t5.push_back(makecmd(true, L"#test", L" '%1%2' %3 %4 %0", L"test", 4, p1p2.c_str(), param3, param4, param0));
assert(test2(L"#test '%1%2' %3 %4 %0", 4, &t5));
InputCommands t6;
t6.push_back(makecmd(true, L"#wait", L" 1.2 {#out {light red} {Время идти!};встать}", L"wait", 2, L"1.2", L"#out {light red} {Время идти!};встать"));
assert(test2(L"#wait 1.2 {#out {light red} {Время идти!};встать}", 2, &t6));
}
// cppcheck-suppress unusedFunction
QVector<QPointF> VSpline::SplinePoints(const QPointF &p1, const QPointF &p4, qreal angle1, qreal angle2, qreal kAsm1,
qreal kAsm2, qreal kCurve)
{
QLineF p1pX(p1.x(), p1.y(), p1.x() + 100, p1.y());
p1pX.setAngle( angle1 );
qreal L = 0, radius = 0, angle = 90;
radius = QLineF(QPointF(p1.x(), p4.y()), p4).length();
L = kCurve * radius * 4 / 3 * tan( angle * M_PI / 180.0 / 4 );
QLineF p1p2(p1.x(), p1.y(), p1.x() + L * kAsm1, p1.y());
p1p2.setAngle(angle1);
QLineF p4p3(p4.x(), p4.y(), p4.x() + L * kAsm2, p4.y());
p4p3.setAngle(angle2);
QPointF p2 = p1p2.p2();
QPointF p3 = p4p3.p2();
return GetPoints(p1, p2, p3, p4);
}
smReal Distance(QLineF line, QPointF point)
{
QPointF p1 = line.p1();
QPointF p2 = line.p2();
smReal upperDistanceQuad = (
Quad( point.x() - p1.x() ) +
Quad( point.y() - p1.y() )
);
smReal lowerDistanceQuad = (
Quad( point.x() - p2.x() ) +
Quad( point.y() - p2.y() )
);
smReal lineLenghtQuad = (
Quad( p1.x() - p2.x() ) +
Quad( p1.y() - p2.y() )
);
if (upperDistanceQuad > lowerDistanceQuad + lineLenghtQuad)
return sqrt(lowerDistanceQuad);
if (lowerDistanceQuad > upperDistanceQuad + lineLenghtQuad)
return sqrt(upperDistanceQuad);
//else
QLineF p1p2(p1,p2);
smReal m = getRectM(p1p2);// (p2.y()-p1.y()) / (p2.x() -p1.x());
smReal q = getRectQ(p1p2,m);// p1.y() -(p1.x()*m);
smReal heightToPoint = (
//distanza punto retta -> |y0 -m*x0 -q |/ sqrt(1+m*m)
abs(point.y() - m*point.x() - q)
/
sqrt(1+Quad(m))
);
return heightToPoint;
}
template<typename PointInT> std::vector<Eigen::Vector2f>
pcl::TextureMapping<PointInT>::mapTexture2Face (
const Eigen::Vector3f &p1,
const Eigen::Vector3f &p2,
const Eigen::Vector3f &p3)
{
std::vector<Eigen::Vector2f> tex_coordinates;
// process for each face
Eigen::Vector3f p1p2 (p2[0] - p1[0], p2[1] - p1[1], p2[2] - p1[2]);
Eigen::Vector3f p1p3 (p3[0] - p1[0], p3[1] - p1[1], p3[2] - p1[2]);
Eigen::Vector3f p2p3 (p3[0] - p2[0], p3[1] - p2[1], p3[2] - p2[2]);
// Normalize
p1p2 = p1p2 / std::sqrt (p1p2.dot (p1p2));
p1p3 = p1p3 / std::sqrt (p1p3.dot (p1p3));
p2p3 = p2p3 / std::sqrt (p2p3.dot (p2p3));
// compute vector normal of a face
Eigen::Vector3f f_normal = p1p2.cross (p1p3);
f_normal = f_normal / std::sqrt (f_normal.dot (f_normal));
// project vector field onto the face: vector v1_projected = v1 - Dot(v1, n) * n;
Eigen::Vector3f f_vector_field = vector_field_ - vector_field_.dot (f_normal) * f_normal;
// Normalize
f_vector_field = f_vector_field / std::sqrt (f_vector_field.dot (f_vector_field));
// texture coordinates
Eigen::Vector2f tp1, tp2, tp3;
double alpha = std::acos (f_vector_field.dot (p1p2));
// distance between 3 vertices of triangles
double e1 = (p2 - p3).norm () / f_;
double e2 = (p1 - p3).norm () / f_;
double e3 = (p1 - p2).norm () / f_;
// initialize
tp1[0] = 0.0;
tp1[1] = 0.0;
tp2[0] = static_cast<float> (e3);
tp2[1] = 0.0;
// determine texture coordinate tp3;
double cos_p1 = (e2 * e2 + e3 * e3 - e1 * e1) / (2 * e2 * e3);
double sin_p1 = sqrt (1 - (cos_p1 * cos_p1));
tp3[0] = static_cast<float> (cos_p1 * e2);
tp3[1] = static_cast<float> (sin_p1 * e2);
// rotating by alpha (angle between V and pp1 & pp2)
Eigen::Vector2f r_tp2, r_tp3;
r_tp2[0] = static_cast<float> (tp2[0] * std::cos (alpha) - tp2[1] * std::sin (alpha));
r_tp2[1] = static_cast<float> (tp2[0] * std::sin (alpha) + tp2[1] * std::cos (alpha));
r_tp3[0] = static_cast<float> (tp3[0] * std::cos (alpha) - tp3[1] * std::sin (alpha));
r_tp3[1] = static_cast<float> (tp3[0] * std::sin (alpha) + tp3[1] * std::cos (alpha));
// shifting
tp1[0] = tp1[0];
tp2[0] = r_tp2[0];
tp3[0] = r_tp3[0];
tp1[1] = tp1[1];
tp2[1] = r_tp2[1];
tp3[1] = r_tp3[1];
float min_x = tp1[0];
float min_y = tp1[1];
if (min_x > tp2[0])
min_x = tp2[0];
if (min_x > tp3[0])
min_x = tp3[0];
if (min_y > tp2[1])
min_y = tp2[1];
if (min_y > tp3[1])
min_y = tp3[1];
if (min_x < 0)
{
tp1[0] = tp1[0] - min_x;
tp2[0] = tp2[0] - min_x;
tp3[0] = tp3[0] - min_x;
}
if (min_y < 0)
{
tp1[1] = tp1[1] - min_y;
tp2[1] = tp2[1] - min_y;
tp3[1] = tp3[1] - min_y;
}
tex_coordinates.push_back (tp1);
tex_coordinates.push_back (tp2);
tex_coordinates.push_back (tp3);
return (tex_coordinates);
}
void Path::addArcTo(const FloatPoint& p1, const FloatPoint& p2, float radius)
{
if (isEmpty())
return;
cairo_t* cr = platformPath()->context();
double x0, y0;
cairo_get_current_point(cr, &x0, &y0);
FloatPoint p0(x0, y0);
// Draw only a straight line to p1 if any of the points are equal or the radius is zero
// or the points are collinear (triangle that the points form has area of zero value).
if ((p1.x() == p0.x() && p1.y() == p0.y()) || (p1.x() == p2.x() && p1.y() == p2.y()) || !radius
|| !areaOfTriangleFormedByPoints(p0, p1, p2)) {
cairo_line_to(cr, p1.x(), p1.y());
return;
}
FloatPoint p1p0((p0.x() - p1.x()),(p0.y() - p1.y()));
FloatPoint p1p2((p2.x() - p1.x()),(p2.y() - p1.y()));
float p1p0_length = sqrtf(p1p0.x() * p1p0.x() + p1p0.y() * p1p0.y());
float p1p2_length = sqrtf(p1p2.x() * p1p2.x() + p1p2.y() * p1p2.y());
double cos_phi = (p1p0.x() * p1p2.x() + p1p0.y() * p1p2.y()) / (p1p0_length * p1p2_length);
// all points on a line logic
if (cos_phi == -1) {
cairo_line_to(cr, p1.x(), p1.y());
return;
}
if (cos_phi == 1) {
// add infinite far away point
unsigned int max_length = 65535;
double factor_max = max_length / p1p0_length;
FloatPoint ep((p0.x() + factor_max * p1p0.x()), (p0.y() + factor_max * p1p0.y()));
cairo_line_to(cr, ep.x(), ep.y());
return;
}
float tangent = radius / tan(acos(cos_phi) / 2);
float factor_p1p0 = tangent / p1p0_length;
FloatPoint t_p1p0((p1.x() + factor_p1p0 * p1p0.x()), (p1.y() + factor_p1p0 * p1p0.y()));
FloatPoint orth_p1p0(p1p0.y(), -p1p0.x());
float orth_p1p0_length = sqrt(orth_p1p0.x() * orth_p1p0.x() + orth_p1p0.y() * orth_p1p0.y());
float factor_ra = radius / orth_p1p0_length;
// angle between orth_p1p0 and p1p2 to get the right vector orthographic to p1p0
double cos_alpha = (orth_p1p0.x() * p1p2.x() + orth_p1p0.y() * p1p2.y()) / (orth_p1p0_length * p1p2_length);
if (cos_alpha < 0.f)
orth_p1p0 = FloatPoint(-orth_p1p0.x(), -orth_p1p0.y());
FloatPoint p((t_p1p0.x() + factor_ra * orth_p1p0.x()), (t_p1p0.y() + factor_ra * orth_p1p0.y()));
// calculate angles for addArc
orth_p1p0 = FloatPoint(-orth_p1p0.x(), -orth_p1p0.y());
float sa = acos(orth_p1p0.x() / orth_p1p0_length);
if (orth_p1p0.y() < 0.f)
sa = 2 * piDouble - sa;
// anticlockwise logic
bool anticlockwise = false;
float factor_p1p2 = tangent / p1p2_length;
FloatPoint t_p1p2((p1.x() + factor_p1p2 * p1p2.x()), (p1.y() + factor_p1p2 * p1p2.y()));
FloatPoint orth_p1p2((t_p1p2.x() - p.x()),(t_p1p2.y() - p.y()));
float orth_p1p2_length = sqrtf(orth_p1p2.x() * orth_p1p2.x() + orth_p1p2.y() * orth_p1p2.y());
float ea = acos(orth_p1p2.x() / orth_p1p2_length);
if (orth_p1p2.y() < 0)
ea = 2 * piDouble - ea;
if ((sa > ea) && ((sa - ea) < piDouble))
anticlockwise = true;
if ((sa < ea) && ((ea - sa) > piDouble))
anticlockwise = true;
cairo_line_to(cr, t_p1p0.x(), t_p1p0.y());
addArc(p, radius, sa, ea, anticlockwise);
}
void Path::addArcTo(const FloatPoint& p1, const FloatPoint& p2, float radius)
{
FloatPoint p0(m_path->currentPosition());
if ((p1.x() == p0.x() && p1.y() == p0.y()) || (p1.x() == p2.x() && p1.y() == p2.y()) || radius == 0.f) {
m_path->lineTo(p1);
return;
}
FloatPoint p1p0((p0.x() - p1.x()),(p0.y() - p1.y()));
FloatPoint p1p2((p2.x() - p1.x()),(p2.y() - p1.y()));
float p1p0_length = sqrtf(p1p0.x() * p1p0.x() + p1p0.y() * p1p0.y());
float p1p2_length = sqrtf(p1p2.x() * p1p2.x() + p1p2.y() * p1p2.y());
double cos_phi = (p1p0.x() * p1p2.x() + p1p0.y() * p1p2.y()) / (p1p0_length * p1p2_length);
// all points on a line logic
if (cos_phi == -1) {
m_path->lineTo(p1);
return;
}
if (cos_phi == 1) {
// add infinite far away point
unsigned int max_length = 65535;
double factor_max = max_length / p1p0_length;
FloatPoint ep((p0.x() + factor_max * p1p0.x()), (p0.y() + factor_max * p1p0.y()));
m_path->lineTo(ep);
return;
}
float tangent = radius / tan(acos(cos_phi) / 2);
float factor_p1p0 = tangent / p1p0_length;
FloatPoint t_p1p0((p1.x() + factor_p1p0 * p1p0.x()), (p1.y() + factor_p1p0 * p1p0.y()));
FloatPoint orth_p1p0(p1p0.y(), -p1p0.x());
float orth_p1p0_length = sqrt(orth_p1p0.x() * orth_p1p0.x() + orth_p1p0.y() * orth_p1p0.y());
float factor_ra = radius / orth_p1p0_length;
// angle between orth_p1p0 and p1p2 to get the right vector orthographic to p1p0
double cos_alpha = (orth_p1p0.x() * p1p2.x() + orth_p1p0.y() * p1p2.y()) / (orth_p1p0_length * p1p2_length);
if (cos_alpha < 0.f)
orth_p1p0 = FloatPoint(-orth_p1p0.x(), -orth_p1p0.y());
FloatPoint p((t_p1p0.x() + factor_ra * orth_p1p0.x()), (t_p1p0.y() + factor_ra * orth_p1p0.y()));
// calculate angles for addArc
orth_p1p0 = FloatPoint(-orth_p1p0.x(), -orth_p1p0.y());
float sa = acos(orth_p1p0.x() / orth_p1p0_length);
if (orth_p1p0.y() < 0.f)
sa = 2 * piDouble - sa;
// anticlockwise logic
bool anticlockwise = false;
float factor_p1p2 = tangent / p1p2_length;
FloatPoint t_p1p2((p1.x() + factor_p1p2 * p1p2.x()), (p1.y() + factor_p1p2 * p1p2.y()));
FloatPoint orth_p1p2((t_p1p2.x() - p.x()),(t_p1p2.y() - p.y()));
float orth_p1p2_length = sqrtf(orth_p1p2.x() * orth_p1p2.x() + orth_p1p2.y() * orth_p1p2.y());
float ea = acos(orth_p1p2.x() / orth_p1p2_length);
if (orth_p1p2.y() < 0)
ea = 2 * piDouble - ea;
if ((sa > ea) && ((sa - ea) < piDouble))
anticlockwise = true;
if ((sa < ea) && ((ea - sa) > piDouble))
anticlockwise = true;
m_path->lineTo(t_p1p0);
addArc(p, radius, sa, ea, anticlockwise);
}
