272 lines
7.2 KiB
C++
272 lines
7.2 KiB
C++
// SPDX-License-Identifier: LGPL-2.1-or-later
|
|
|
|
/***************************************************************************
|
|
* Copyright (c) 2022 Werner Mayer <wmayer[at]users.sourceforge.net> *
|
|
* *
|
|
* This file is part of the FreeCAD CAx development system. *
|
|
* *
|
|
* This library is free software; you can redistribute it and/or *
|
|
* modify it under the terms of the GNU Library General Public *
|
|
* License as published by the Free Software Foundation; either *
|
|
* version 2 of the License, or (at your option) any later version. *
|
|
* *
|
|
* This library is distributed in the hope that it will be useful, *
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
|
|
* GNU Library General Public License for more details. *
|
|
* *
|
|
* You should have received a copy of the GNU Library General Public *
|
|
* License along with this library; see the file COPYING.LIB. If not, *
|
|
* write to the Free Software Foundation, Inc., 59 Temple Place, *
|
|
* Suite 330, Boston, MA 02111-1307, USA *
|
|
* *
|
|
***************************************************************************/
|
|
|
|
#include "BoundBox.h"
|
|
#include "Placement.h"
|
|
#include "Tools3D.h"
|
|
|
|
using namespace Base;
|
|
|
|
|
|
template<typename float_type>
|
|
Line3<float_type>::Line3(const Vector3<float_type>& p1, const Vector3<float_type>& p2)
|
|
: p1(p1)
|
|
, p2(p2)
|
|
{}
|
|
|
|
template<typename float_type>
|
|
bool Line3<float_type>::operator==(const Line3<float_type>& line) const
|
|
{
|
|
return (p1 == line.p1 && p2 == line.p2);
|
|
}
|
|
|
|
template<typename float_type>
|
|
float_type Line3<float_type>::Length() const
|
|
{
|
|
return Base::Distance(p1, p2);
|
|
}
|
|
|
|
template<typename float_type>
|
|
float_type Line3<float_type>::SqrLength() const
|
|
{
|
|
return Base::DistanceP2(p1, p2);
|
|
}
|
|
|
|
template<typename float_type>
|
|
BoundBox3<float_type> Line3<float_type>::CalcBoundBox() const
|
|
{
|
|
BoundBox3<float_type> box;
|
|
box.Add(p1);
|
|
box.Add(p2);
|
|
return box;
|
|
}
|
|
|
|
template<typename float_type>
|
|
Vector3<float_type> Line3<float_type>::GetBase() const
|
|
{
|
|
return p1;
|
|
}
|
|
|
|
template<typename float_type>
|
|
Vector3<float_type> Line3<float_type>::GetDirection() const
|
|
{
|
|
return p2 - p1;
|
|
}
|
|
|
|
template<typename float_type>
|
|
void Line3<float_type>::Transform(const Base::Matrix4D& mat)
|
|
{
|
|
mat.multVec(p1, p1);
|
|
mat.multVec(p2, p2);
|
|
}
|
|
|
|
template<typename float_type>
|
|
void Line3<float_type>::Transform(const Base::Placement& plm)
|
|
{
|
|
plm.multVec(p1, p1);
|
|
plm.multVec(p2, p2);
|
|
}
|
|
|
|
template<typename float_type>
|
|
void Line3<float_type>::Transform(const Base::Rotation& rot)
|
|
{
|
|
rot.multVec(p1, p1);
|
|
rot.multVec(p2, p2);
|
|
}
|
|
|
|
template<typename float_type>
|
|
Line3<float_type> Line3<float_type>::Transformed(const Base::Matrix4D& mat) const
|
|
{
|
|
Line3<float_type> line(*this);
|
|
line.Transform(mat);
|
|
return line;
|
|
}
|
|
|
|
template<typename float_type>
|
|
Line3<float_type> Line3<float_type>::Transformed(const Base::Placement& plm) const
|
|
{
|
|
Line3<float_type> line(*this);
|
|
line.Transform(plm);
|
|
return line;
|
|
}
|
|
|
|
template<typename float_type>
|
|
Line3<float_type> Line3<float_type>::Transformed(const Base::Rotation& rot) const
|
|
{
|
|
Line3<float_type> line(*this);
|
|
line.Transform(rot);
|
|
return line;
|
|
}
|
|
|
|
template<typename float_type>
|
|
bool Line3<float_type>::Contains(const Vector3<float_type>& pt) const
|
|
{
|
|
return Contains(pt, Vector3<float_type>::epsilon());
|
|
}
|
|
|
|
template<typename float_type>
|
|
bool Line3<float_type>::Contains(const Vector3<float_type>& pt, float_type eps) const
|
|
{
|
|
Vector3<float_type> v1 = p1 - pt;
|
|
Vector3<float_type> v2 = p2 - pt;
|
|
Vector3<float_type> v3 = p2 - p1;
|
|
float_type dot = v1.Dot(v2);
|
|
if (dot > eps) {
|
|
return false;
|
|
}
|
|
return v3.Cross(v1).Length() < eps;
|
|
}
|
|
|
|
template<typename float_type>
|
|
Vector3<float_type> Line3<float_type>::FromPos(float_type distance) const
|
|
{
|
|
Vector3<float_type> dir(p2 - p1);
|
|
dir.Normalize();
|
|
return p1 + dir * distance;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
template<typename float_type>
|
|
size_t Polygon3<float_type>::GetSize() const
|
|
{
|
|
return points.size();
|
|
}
|
|
|
|
template<typename float_type>
|
|
void Polygon3<float_type>::Add(const Vector3<float_type>& pnt)
|
|
{
|
|
points.push_back(pnt);
|
|
}
|
|
|
|
template<typename float_type>
|
|
const Vector3<float_type>& Polygon3<float_type>::operator[](size_t pos) const
|
|
{
|
|
return points[pos];
|
|
}
|
|
|
|
template<typename float_type>
|
|
const Vector3<float_type>& Polygon3<float_type>::At(size_t pos) const
|
|
{
|
|
return points.at(pos);
|
|
}
|
|
|
|
template<typename float_type>
|
|
Vector3<float_type>& Polygon3<float_type>::operator[](size_t pos)
|
|
{
|
|
return points[pos];
|
|
}
|
|
|
|
template<typename float_type>
|
|
Vector3<float_type>& Polygon3<float_type>::At(size_t pos)
|
|
{
|
|
return points.at(pos);
|
|
}
|
|
|
|
template<typename float_type>
|
|
bool Polygon3<float_type>::Remove(size_t pos)
|
|
{
|
|
if (pos < points.size()) {
|
|
auto it = points.begin();
|
|
std::advance(it, pos);
|
|
points.erase(it);
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
template<typename float_type>
|
|
void Polygon3<float_type>::Clear()
|
|
{
|
|
points.clear();
|
|
}
|
|
|
|
template<typename float_type>
|
|
BoundBox3<float_type> Polygon3<float_type>::CalcBoundBox() const
|
|
{
|
|
BoundBox3<float_type> box;
|
|
for (const auto& it : points) {
|
|
box.Add(it);
|
|
}
|
|
return box;
|
|
}
|
|
|
|
template<typename float_type>
|
|
void Polygon3<float_type>::Transform(const Base::Matrix4D& mat)
|
|
{
|
|
for (auto& it : points) {
|
|
mat.multVec(it, it);
|
|
}
|
|
}
|
|
|
|
template<typename float_type>
|
|
void Polygon3<float_type>::Transform(const Base::Placement& plm)
|
|
{
|
|
for (auto& it : points) {
|
|
plm.multVec(it, it);
|
|
}
|
|
}
|
|
|
|
template<typename float_type>
|
|
void Polygon3<float_type>::Transform(const Base::Rotation& rot)
|
|
{
|
|
for (auto& it : points) {
|
|
rot.multVec(it, it);
|
|
}
|
|
}
|
|
|
|
template<typename float_type>
|
|
Polygon3<float_type> Polygon3<float_type>::Transformed(const Base::Matrix4D& mat) const
|
|
{
|
|
Polygon3<float_type> poly(*this);
|
|
poly.Transform(mat);
|
|
return poly;
|
|
}
|
|
|
|
template<typename float_type>
|
|
Polygon3<float_type> Polygon3<float_type>::Transformed(const Base::Placement& plm) const
|
|
{
|
|
Polygon3<float_type> poly(*this);
|
|
poly.Transform(plm);
|
|
return poly;
|
|
}
|
|
|
|
template<typename float_type>
|
|
Polygon3<float_type> Polygon3<float_type>::Transformed(const Base::Rotation& rot) const
|
|
{
|
|
Polygon3<float_type> poly(*this);
|
|
poly.Transform(rot);
|
|
return poly;
|
|
}
|
|
|
|
// explicit template instantiation
|
|
namespace Base
|
|
{
|
|
template class BaseExport Line3<float>;
|
|
template class BaseExport Line3<double>;
|
|
template class BaseExport Polygon3<float>;
|
|
template class BaseExport Polygon3<double>;
|
|
} // namespace Base
|