zcy
/
dust3d
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
dust3d/thirdparty/cgal/CGAL-5.1/include/CGAL/squared_distance_3_1.h

1008 lines
25 KiB
C
Raw Normal View History

Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
// Copyright (c) 1998-2004
Integrate Instant-Meshes 1. Drop windows 32bit support Add windows 64bit support. 2. Remove Script(quickjs) support The current integrated quickjs is a very old version which doesn’t support windows 64bit system. In the future, (TODO)WebAssembly should be integrate as plugin system. 3. Integrate Instant-Meshes Instant-Meshes take less than 1 second on all three platforms. 4. Remove QuadriFlow Current implementation of QuadriFlow is too slow (take about 5 seconds on the example model) to do realtime remeshing.
2020-01-04 10:29:10 +00:00
// Utrecht University (The Netherlands),
// ETH Zurich (Switzerland),
// INRIA Sophia-Antipolis (France),
// Max-Planck-Institute Saarbruecken (Germany),
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
// and Tel-Aviv University (Israel). All rights reserved.
Integrate Instant-Meshes 1. Drop windows 32bit support Add windows 64bit support. 2. Remove Script(quickjs) support The current integrated quickjs is a very old version which doesn’t support windows 64bit system. In the future, (TODO)WebAssembly should be integrate as plugin system. 3. Integrate Instant-Meshes Instant-Meshes take less than 1 second on all three platforms. 4. Remove QuadriFlow Current implementation of QuadriFlow is too slow (take about 5 seconds on the example model) to do realtime remeshing.
2020-01-04 10:29:10 +00:00
//
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
// This file is part of CGAL (www.cgal.org)
Integrate Instant-Meshes 1. Drop windows 32bit support Add windows 64bit support. 2. Remove Script(quickjs) support The current integrated quickjs is a very old version which doesn’t support windows 64bit system. In the future, (TODO)WebAssembly should be integrate as plugin system. 3. Integrate Instant-Meshes Instant-Meshes take less than 1 second on all three platforms. 4. Remove QuadriFlow Current implementation of QuadriFlow is too slow (take about 5 seconds on the example model) to do realtime remeshing.
2020-01-04 10:29:10 +00:00
//
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
// $URL: https://github.com/CGAL/cgal/blob/v5.1/Distance_3/include/CGAL/squared_distance_3_1.h $
// $Id: squared_distance_3_1.h 0c94ff4 2020-06-23T18:49:46+02:00 Laurent Rineau
// SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-Commercial
Integrate Instant-Meshes 1. Drop windows 32bit support Add windows 64bit support. 2. Remove Script(quickjs) support The current integrated quickjs is a very old version which doesn’t support windows 64bit system. In the future, (TODO)WebAssembly should be integrate as plugin system. 3. Integrate Instant-Meshes Instant-Meshes take less than 1 second on all three platforms. 4. Remove QuadriFlow Current implementation of QuadriFlow is too slow (take about 5 seconds on the example model) to do realtime remeshing.
2020-01-04 10:29:10 +00:00
//
//
// Author(s) : Geert-Jan Giezeman, Andreas Fabri
#ifndef CGAL_DISTANCE_3_1_H
#define CGAL_DISTANCE_3_1_H
#include <CGAL/squared_distance_3_0.h>
#include <CGAL/Segment_3.h>
#include <CGAL/Line_3.h>
#include <CGAL/Ray_3.h>
namespace CGAL {
namespace internal {
template <class K>
typename K::FT
squared_distance(
const typename K::Point_3 &pt,
const typename K::Line_3 &line,
const K& k)
{
typedef typename K::Vector_3 Vector_3;
typename K::Construct_vector_3 construct_vector;
Vector_3 dir(line.direction().vector());
Vector_3 diff = construct_vector(line.point(), pt);
return internal::squared_distance_to_line(dir, diff, k);
}
template <class K>
inline
typename K::FT
squared_distance(
const typename K::Line_3 & line,
const typename K::Point_3 & pt,
const K& k)
{
return squared_distance(pt, line, k);
}
template <class K>
typename K::FT
squared_distance(
const typename K::Point_3 &pt,
const typename K::Ray_3 &ray,
const K& k)
{
typename K::Construct_vector_3 construct_vector;
typedef typename K::Vector_3 Vector_3;
Vector_3 diff = construct_vector(ray.source(), pt);
const Vector_3 &dir = ray.direction().vector();
if (!is_acute_angle(dir,diff, k) )
return (typename K::FT)(diff*diff);
return squared_distance_to_line(dir, diff, k);
}
template <class K>
inline
typename K::FT
squared_distance(
const typename K::Ray_3 & ray,
const typename K::Point_3 & pt,
const K& k)
{
return squared_distance(pt, ray, k);
}
template <class K>
typename K::FT
squared_distance(
const typename K::Point_3 &pt,
const typename K::Segment_3 &seg,
const K& k,
const Homogeneous_tag)
{
typename K::Construct_vector_3 construct_vector;
typedef typename K::Vector_3 Vector_3;
typedef typename K::RT RT;
typedef typename K::FT FT;
// assert that the segment is valid (non zero length).
Vector_3 diff = construct_vector(seg.source(), pt);
Vector_3 segvec = construct_vector(seg.source(), seg.target());
RT d = wdot(diff,segvec, k);
if (d <= (RT)0)
return (FT(diff*diff));
RT e = wdot(segvec,segvec, k);
if ( (d * segvec.hw()) > (e * diff.hw()))
return squared_distance(pt, seg.target(), k);
Vector_3 wcr = wcross(segvec, diff, k);
return FT(wcr*wcr)/FT(e * diff.hw() * diff.hw());
}
template <class K>
typename K::FT
squared_distance(
const typename K::Point_3 &pt,
const typename K::Segment_3 &seg,
const K& k,
const Cartesian_tag&)
{
typename K::Construct_vector_3 construct_vector;
typedef typename K::Vector_3 Vector_3;
typedef typename K::RT RT;
typedef typename K::FT FT;
// assert that the segment is valid (non zero length).
Vector_3 diff = construct_vector(seg.source(), pt);
Vector_3 segvec = construct_vector(seg.source(), seg.target());
RT d = wdot(diff,segvec, k);
if (d <= (RT)0)
return (FT(diff*diff));
RT e = wdot(segvec,segvec, k);
if (d > e)
return squared_distance(pt, seg.target(), k);
Vector_3 wcr = wcross(segvec, diff, k);
return FT(wcr*wcr)/e;
}
template <class K>
inline
typename K::FT
squared_distance(
const typename K::Point_3 &pt,
const typename K::Segment_3 &seg,
const K& k)
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
{
Integrate Instant-Meshes 1. Drop windows 32bit support Add windows 64bit support. 2. Remove Script(quickjs) support The current integrated quickjs is a very old version which doesn’t support windows 64bit system. In the future, (TODO)WebAssembly should be integrate as plugin system. 3. Integrate Instant-Meshes Instant-Meshes take less than 1 second on all three platforms. 4. Remove QuadriFlow Current implementation of QuadriFlow is too slow (take about 5 seconds on the example model) to do realtime remeshing.
2020-01-04 10:29:10 +00:00
typedef typename K::Kernel_tag Tag;
Tag tag;
return squared_distance(pt, seg, k, tag);
}
template <class K>
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
inline
Integrate Instant-Meshes 1. Drop windows 32bit support Add windows 64bit support. 2. Remove Script(quickjs) support The current integrated quickjs is a very old version which doesn’t support windows 64bit system. In the future, (TODO)WebAssembly should be integrate as plugin system. 3. Integrate Instant-Meshes Instant-Meshes take less than 1 second on all three platforms. 4. Remove QuadriFlow Current implementation of QuadriFlow is too slow (take about 5 seconds on the example model) to do realtime remeshing.
2020-01-04 10:29:10 +00:00
typename K::FT
squared_distance(
const typename K::Segment_3 & seg,
const typename K::Point_3 & pt,
const K& k)
{
return squared_distance(pt, seg, k);
}
template <class K>
typename K::Comparison_result
compare_distance_pssC3(
const typename K::Point_3 &pt,
const typename K::Segment_3 &seg1,
const typename K::Segment_3 &seg2,
const K& k)
{
typename K::Construct_vector_3 construct_vector;
typedef typename K::Vector_3 Vector_3;
typedef typename K::RT RT;
typedef typename K::FT FT;
FT d1=FT(0), d2=FT(0);
RT e1 = RT(1), e2 = RT(1);
// assert that the segment is valid (non zero length).
{
Vector_3 diff = construct_vector(seg1.source(), pt);
Vector_3 segvec = construct_vector(seg1.source(), seg1.target());
RT d = wdot(diff,segvec, k);
if (d <= (RT)0){
d1 = (FT(diff*diff));
}else{
RT e = wdot(segvec,segvec, k);
if (d > e){
d1 = squared_distance(pt, seg1.target(), k);
} else{
Vector_3 wcr = wcross(segvec, diff, k);
d1 = FT(wcr*wcr);
e1 = e;
}
}
}
{
Vector_3 diff = construct_vector(seg2.source(), pt);
Vector_3 segvec = construct_vector(seg2.source(), seg2.target());
RT d = wdot(diff,segvec, k);
if (d <= (RT)0){
d2 = (FT(diff*diff));
}else{
RT e = wdot(segvec,segvec, k);
if (d > e){
d2 = squared_distance(pt, seg2.target(), k);
} else{
Vector_3 wcr = wcross(segvec, diff, k);
d2 = FT(wcr*wcr);
e2 = e;
}
}
}
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
return CGAL::compare(d1*e2, d2*e1);
Integrate Instant-Meshes 1. Drop windows 32bit support Add windows 64bit support. 2. Remove Script(quickjs) support The current integrated quickjs is a very old version which doesn’t support windows 64bit system. In the future, (TODO)WebAssembly should be integrate as plugin system. 3. Integrate Instant-Meshes Instant-Meshes take less than 1 second on all three platforms. 4. Remove QuadriFlow Current implementation of QuadriFlow is too slow (take about 5 seconds on the example model) to do realtime remeshing.
2020-01-04 10:29:10 +00:00
}
template <class K>
typename K::Comparison_result
compare_distance_ppsC3(
const typename K::Point_3 &pt,
const typename K::Point_3 &pt2,
const typename K::Segment_3 &seg,
const K& k)
{
typename K::Construct_vector_3 construct_vector;
typedef typename K::Vector_3 Vector_3;
typedef typename K::RT RT;
typedef typename K::FT FT;
RT e2 = RT(1);
// assert that the segment is valid (non zero length).
FT d1 = squared_distance(pt, pt2, k);
FT d2 = FT(0);
{
Vector_3 diff = construct_vector(seg.source(), pt);
Vector_3 segvec = construct_vector(seg.source(), seg.target());
RT d = wdot(diff,segvec, k);
if (d <= (RT)0){
d2 = (FT(diff*diff));
}else{
RT e = wdot(segvec,segvec, k);
if (d > e){
d2 = squared_distance(pt, seg.target(), k);
} else{
Vector_3 wcr = wcross(segvec, diff, k);
d2 = FT(wcr*wcr);
e2 = e;
}
}
}
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
return CGAL::compare(d1*e2, d2);
Integrate Instant-Meshes 1. Drop windows 32bit support Add windows 64bit support. 2. Remove Script(quickjs) support The current integrated quickjs is a very old version which doesn’t support windows 64bit system. In the future, (TODO)WebAssembly should be integrate as plugin system. 3. Integrate Instant-Meshes Instant-Meshes take less than 1 second on all three platforms. 4. Remove QuadriFlow Current implementation of QuadriFlow is too slow (take about 5 seconds on the example model) to do realtime remeshing.
2020-01-04 10:29:10 +00:00
}
template <class K>
typename K::FT
squared_distance_parallel(
const typename K::Segment_3 &seg1,
const typename K::Segment_3 &seg2,
const K& k)
{
typedef typename K::Vector_3 Vector_3;
const Vector_3 &dir1 = seg1.direction().vector();
const Vector_3 &dir2 = seg2.direction().vector();
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
Integrate Instant-Meshes 1. Drop windows 32bit support Add windows 64bit support. 2. Remove Script(quickjs) support The current integrated quickjs is a very old version which doesn’t support windows 64bit system. In the future, (TODO)WebAssembly should be integrate as plugin system. 3. Integrate Instant-Meshes Instant-Meshes take less than 1 second on all three platforms. 4. Remove QuadriFlow Current implementation of QuadriFlow is too slow (take about 5 seconds on the example model) to do realtime remeshing.
2020-01-04 10:29:10 +00:00
if (same_direction(dir1, dir2, k)) {
if (!is_acute_angle(seg1.source(), seg1.target(), seg2.source(), k))
return squared_distance(seg1.target(), seg2.source(), k);
if (!is_acute_angle(seg1.target(), seg1.source(), seg2.target(), k))
return squared_distance(seg1.source(), seg2.target(), k);
} else {
if (!is_acute_angle(seg1.source(), seg1.target(), seg2.target(), k))
return squared_distance(seg1.target(), seg2.target(), k);
if (!is_acute_angle(seg1.target(), seg1.source(), seg2.source(), k))
return squared_distance(seg1.source(), seg2.source(), k);
}
return squared_distance(seg2.source(), seg1.supporting_line(), k);
}
template <class K>
inline
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
typename K::RT
Integrate Instant-Meshes 1. Drop windows 32bit support Add windows 64bit support. 2. Remove Script(quickjs) support The current integrated quickjs is a very old version which doesn’t support windows 64bit system. In the future, (TODO)WebAssembly should be integrate as plugin system. 3. Integrate Instant-Meshes Instant-Meshes take less than 1 second on all three platforms. 4. Remove QuadriFlow Current implementation of QuadriFlow is too slow (take about 5 seconds on the example model) to do realtime remeshing.
2020-01-04 10:29:10 +00:00
_distance_measure_sub(typename K::RT startwdist, typename K::RT endwdist,
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
const typename K::Vector_3 &start,
const typename K::Vector_3 &end,
const K&)
Integrate Instant-Meshes 1. Drop windows 32bit support Add windows 64bit support. 2. Remove Script(quickjs) support The current integrated quickjs is a very old version which doesn’t support windows 64bit system. In the future, (TODO)WebAssembly should be integrate as plugin system. 3. Integrate Instant-Meshes Instant-Meshes take less than 1 second on all three platforms. 4. Remove QuadriFlow Current implementation of QuadriFlow is too slow (take about 5 seconds on the example model) to do realtime remeshing.
2020-01-04 10:29:10 +00:00
{
return CGAL_NTS abs(wmult((K*)0, startwdist, end.hw())) -
CGAL_NTS abs(wmult((K*)0, endwdist, start.hw()));
}
template <class K>
typename K::FT
squared_distance(
const typename K::Segment_3 &seg1,
const typename K::Segment_3 &seg2,
const K& k)
{
typename K::Construct_vector_3 construct_vector;
typedef typename K::Vector_3 Vector_3;
typedef typename K::Point_3 Point_3;
typedef typename K::RT RT;
typedef typename K::FT FT;
const Point_3 &start1 = seg1.source();
const Point_3 &start2 = seg2.source();
const Point_3 &end1 = seg1.target();
const Point_3 &end2 = seg2.target();
if (start1 == end1)
return squared_distance(start1, seg2, k);
if (start2 == end2)
return squared_distance(start2, seg1, k);
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
Integrate Instant-Meshes 1. Drop windows 32bit support Add windows 64bit support. 2. Remove Script(quickjs) support The current integrated quickjs is a very old version which doesn’t support windows 64bit system. In the future, (TODO)WebAssembly should be integrate as plugin system. 3. Integrate Instant-Meshes Instant-Meshes take less than 1 second on all three platforms. 4. Remove QuadriFlow Current implementation of QuadriFlow is too slow (take about 5 seconds on the example model) to do realtime remeshing.
2020-01-04 10:29:10 +00:00
Vector_3 dir1, dir2, normal;
dir1 = seg1.direction().vector();
dir2 = seg2.direction().vector();
normal = wcross(dir1, dir2, k);
if (is_null(normal, k))
return squared_distance_parallel(seg1, seg2, k);
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
Integrate Instant-Meshes 1. Drop windows 32bit support Add windows 64bit support. 2. Remove Script(quickjs) support The current integrated quickjs is a very old version which doesn’t support windows 64bit system. In the future, (TODO)WebAssembly should be integrate as plugin system. 3. Integrate Instant-Meshes Instant-Meshes take less than 1 second on all three platforms. 4. Remove QuadriFlow Current implementation of QuadriFlow is too slow (take about 5 seconds on the example model) to do realtime remeshing.
2020-01-04 10:29:10 +00:00
bool crossing1, crossing2;
RT sdm_s1to2, sdm_e1to2, sdm_s2to1, sdm_e2to1;
Vector_3 perpend1, perpend2, s2mins1, e2mins1, e1mins2;
perpend1 = wcross(dir1, normal, k);
perpend2 = wcross(dir2, normal, k);
s2mins1 = construct_vector(start1, start2);
e2mins1 = construct_vector(start1, end2);
e1mins2 = construct_vector(start2, end1);
sdm_s1to2 = -RT(wdot(perpend2, s2mins1, k));
sdm_e1to2 = wdot(perpend2, e1mins2, k);
sdm_s2to1 = wdot(perpend1, s2mins1, k);
sdm_e2to1 = wdot(perpend1, e2mins1, k);
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
Integrate Instant-Meshes 1. Drop windows 32bit support Add windows 64bit support. 2. Remove Script(quickjs) support The current integrated quickjs is a very old version which doesn’t support windows 64bit system. In the future, (TODO)WebAssembly should be integrate as plugin system. 3. Integrate Instant-Meshes Instant-Meshes take less than 1 second on all three platforms. 4. Remove QuadriFlow Current implementation of QuadriFlow is too slow (take about 5 seconds on the example model) to do realtime remeshing.
2020-01-04 10:29:10 +00:00
if (sdm_s1to2 < RT(0)) {
crossing1 = (sdm_e1to2 >= RT(0));
} else {
if (sdm_e1to2 <= RT(0)) {
crossing1 = true;
} else {
crossing1 = (sdm_s1to2 == RT(0));
}
}
if (sdm_s2to1 < RT(0)) {
crossing2 = (sdm_e2to1 >= RT(0));
} else {
if (sdm_e2to1 <= RT(0)) {
crossing2 = true;
} else {
crossing2 = (sdm_s2to1 == RT(0));
}
}
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
Integrate Instant-Meshes 1. Drop windows 32bit support Add windows 64bit support. 2. Remove Script(quickjs) support The current integrated quickjs is a very old version which doesn’t support windows 64bit system. In the future, (TODO)WebAssembly should be integrate as plugin system. 3. Integrate Instant-Meshes Instant-Meshes take less than 1 second on all three platforms. 4. Remove QuadriFlow Current implementation of QuadriFlow is too slow (take about 5 seconds on the example model) to do realtime remeshing.
2020-01-04 10:29:10 +00:00
if (crossing1) {
if (crossing2) {
return squared_distance_to_plane(normal, s2mins1, k);
}
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
Integrate Instant-Meshes 1. Drop windows 32bit support Add windows 64bit support. 2. Remove Script(quickjs) support The current integrated quickjs is a very old version which doesn’t support windows 64bit system. In the future, (TODO)WebAssembly should be integrate as plugin system. 3. Integrate Instant-Meshes Instant-Meshes take less than 1 second on all three platforms. 4. Remove QuadriFlow Current implementation of QuadriFlow is too slow (take about 5 seconds on the example model) to do realtime remeshing.
2020-01-04 10:29:10 +00:00
RT dm;
dm = _distance_measure_sub(
sdm_s2to1, sdm_e2to1, s2mins1, e2mins1, k);
if (dm < RT(0)) {
return squared_distance(start2, seg1, k);
} else {
if (dm > RT(0)) {
return squared_distance(end2, seg1, k);
} else {
// should not happen with exact arithmetic.
return squared_distance_parallel(seg1, seg2, k);
}
}
} else {
if (crossing2) {
RT dm;
dm =_distance_measure_sub(
sdm_s1to2, sdm_e1to2, s2mins1, e1mins2, k);
if (dm < RT(0)) {
return squared_distance(start1, seg2, k);
} else {
if (dm > RT(0)) {
return squared_distance(end1, seg2, k);
} else {
// should not happen with exact arithmetic.
return squared_distance_parallel(seg1, seg2, k);
}
}
} else {
FT min1, min2;
RT dm;
dm = _distance_measure_sub(
sdm_s1to2, sdm_e1to2, s2mins1, e1mins2, k);
if (dm == RT(0)) // should not happen with exact arithmetic.
return squared_distance_parallel(seg1, seg2, k);
min1 = (dm < RT(0)) ?
squared_distance(seg1.source(), seg2, k):
squared_distance(end1, seg2, k);
dm = _distance_measure_sub(
sdm_s2to1, sdm_e2to1, s2mins1, e2mins1, k);
if (dm == RT(0)) // should not happen with exact arithmetic.
return squared_distance_parallel(seg1, seg2, k);
min2 = (dm < RT(0)) ?
squared_distance(start2, seg1, k):
squared_distance(end2, seg1, k);
return (min1 < min2) ? min1 : min2;
}
}
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
Integrate Instant-Meshes 1. Drop windows 32bit support Add windows 64bit support. 2. Remove Script(quickjs) support The current integrated quickjs is a very old version which doesn’t support windows 64bit system. In the future, (TODO)WebAssembly should be integrate as plugin system. 3. Integrate Instant-Meshes Instant-Meshes take less than 1 second on all three platforms. 4. Remove QuadriFlow Current implementation of QuadriFlow is too slow (take about 5 seconds on the example model) to do realtime remeshing.
2020-01-04 10:29:10 +00:00
}
template <class K>
typename K::FT
squared_distance_parallel(
const typename K::Segment_3 &seg,
const typename K::Ray_3 &ray,
const K& k)
{
typedef typename K::Vector_3 Vector_3;
bool same_direction;
const Vector_3 &dir1 = seg.direction().vector();
const Vector_3 &dir2 = ray.direction().vector();
if (CGAL_NTS abs(dir1.hx()) > CGAL_NTS abs(dir1.hy())) {
same_direction = (CGAL_NTS sign(dir1.hx()) == CGAL_NTS sign(dir2.hx()));
} else {
same_direction = (CGAL_NTS sign(dir1.hy()) == CGAL_NTS sign(dir2.hy()));
}
if (same_direction) {
if (!is_acute_angle(seg.source(), seg.target(), ray.source(), k))
return squared_distance(seg.target(), ray.source(), k);
} else {
if (!is_acute_angle(seg.target(), seg.source(), ray.source(), k))
return squared_distance(seg.source(), ray.source(), k);
}
return squared_distance(ray.source(), seg.supporting_line(), k);
}
template <class K>
typename K::FT
squared_distance(
const typename K::Segment_3 &seg,
const typename K::Ray_3 &ray,
const K& k)
{
typename K::Construct_vector_3 construct_vector;
typedef typename K::Point_3 Point_3;
typedef typename K::Vector_3 Vector_3;
typedef typename K::RT RT;
typedef typename K::FT FT;
const Point_3 & ss = seg.source();
const Point_3 & se = seg.target();
if (ss == se)
return squared_distance(ss, ray, k);
Vector_3 raydir, segdir, normal;
raydir = ray.direction().vector();
segdir = seg.direction().vector();
normal = wcross(segdir, raydir, k);
if (is_null(normal, k))
return squared_distance_parallel(seg, ray, k);
bool crossing1, crossing2;
RT sdm_ss2r, sdm_se2r, sdm_rs2s, sdm_re2s;
Vector_3 perpend2seg, perpend2ray, ss_min_rs, se_min_rs;
perpend2seg = wcross(segdir, normal, k);
perpend2ray = wcross(raydir, normal, k);
ss_min_rs = construct_vector(ray.source(), ss);
se_min_rs = construct_vector(ray.source(), se);
sdm_ss2r = wdot(perpend2ray, ss_min_rs, k);
sdm_se2r = wdot(perpend2ray, se_min_rs, k);
if (sdm_ss2r < RT(0)) {
crossing1 = (sdm_se2r >= RT(0));
} else {
if (sdm_se2r <= RT(0)) {
crossing1 = true;
} else {
crossing1 = (sdm_ss2r == RT(0));
}
}
sdm_rs2s = -RT(wdot(perpend2seg, ss_min_rs, k));
sdm_re2s = wdot(perpend2seg, raydir, k);
if (sdm_rs2s < RT(0)) {
crossing2 = (sdm_re2s >= RT(0));
} else {
if (sdm_re2s <= RT(0)) {
crossing2 = true;
} else {
crossing2 = (sdm_rs2s == RT(0));
}
}
if (crossing1) {
if (crossing2) {
return squared_distance_to_plane(normal, ss_min_rs, k);
}
return squared_distance(ray.source(), seg, k);
} else {
if (crossing2) {
RT dm;
dm = _distance_measure_sub(
sdm_ss2r, sdm_se2r, ss_min_rs, se_min_rs, k);
if (dm < RT(0)) {
return squared_distance(ss, ray, k);
} else {
if (dm > RT(0)) {
return squared_distance(se, ray, k);
} else {
// parallel, should not happen (no crossing)
return squared_distance_parallel(seg, ray, k);
}
}
} else {
FT min1, min2;
RT dm;
dm = _distance_measure_sub(
sdm_ss2r, sdm_se2r, ss_min_rs, se_min_rs, k);
if (dm == RT(0))
return squared_distance_parallel(seg, ray, k);
min1 = (dm < RT(0))
? squared_distance(ss, ray, k)
: squared_distance(se, ray, k);
min2 = squared_distance(ray.source(), seg, k);
return (min1 < min2) ? min1 : min2;
}
}
}
template <class K>
inline
typename K::FT
squared_distance(
const typename K::Ray_3 & ray,
const typename K::Segment_3 & seg,
const K& k)
{
return squared_distance(seg, ray, k);
}
template <class K>
typename K::FT
squared_distance(
const typename K::Segment_3 &seg,
const typename K::Line_3 &line,
const K& k)
{
typename K::Construct_vector_3 construct_vector;
typedef typename K::Vector_3 Vector_3;
typedef typename K::Point_3 Point_3;
typedef typename K::RT RT;
const Point_3 &linepoint = line.point();
const Point_3 &start = seg.source();
const Point_3 &end = seg.target();
if (start == end)
return squared_distance(start, line, k);
Vector_3 linedir = line.direction().vector();
Vector_3 segdir = seg.direction().vector();
Vector_3 normal = wcross(segdir, linedir, k);
if (is_null(normal, k))
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
return squared_distance_to_line(linedir,
construct_vector(linepoint,start), k);
Integrate Instant-Meshes 1. Drop windows 32bit support Add windows 64bit support. 2. Remove Script(quickjs) support The current integrated quickjs is a very old version which doesn’t support windows 64bit system. In the future, (TODO)WebAssembly should be integrate as plugin system. 3. Integrate Instant-Meshes Instant-Meshes take less than 1 second on all three platforms. 4. Remove QuadriFlow Current implementation of QuadriFlow is too slow (take about 5 seconds on the example model) to do realtime remeshing.
2020-01-04 10:29:10 +00:00
bool crossing;
RT sdm_ss2l, sdm_se2l;
Vector_3 perpend2line, start_min_lp, end_min_lp;
perpend2line = wcross(linedir, normal, k);
start_min_lp = construct_vector(linepoint, start);
end_min_lp = construct_vector(linepoint, end);
sdm_ss2l = wdot(perpend2line, start_min_lp, k);
sdm_se2l = wdot(perpend2line, end_min_lp, k);
if (sdm_ss2l < RT(0)) {
crossing = (sdm_se2l >= RT(0));
} else {
if (sdm_se2l <= RT(0)) {
crossing = true;
} else {
crossing = (sdm_ss2l == RT(0));
}
}
if (crossing) {
return squared_distance_to_plane(normal, start_min_lp, k);
} else {
RT dm;
dm = _distance_measure_sub(
sdm_ss2l, sdm_se2l, start_min_lp, end_min_lp, k);
if (dm <= RT(0)) {
return squared_distance_to_line(linedir, start_min_lp, k);
} else {
return squared_distance_to_line(linedir, end_min_lp, k);
}
}
}
template <class K>
inline
typename K::FT
squared_distance(
const typename K::Line_3 & line,
const typename K::Segment_3 & seg,
const K& k)
{
return squared_distance(seg, line, k);
}
template <class K>
typename K::FT
ray_ray_squared_distance_parallel(
const typename K::Vector_3 &ray1dir,
const typename K::Vector_3 &ray2dir,
const typename K::Vector_3 &s1_min_s2,
const K& k)
{
if (!is_acute_angle(ray2dir, s1_min_s2, k)) {
if (!same_direction(ray1dir, ray2dir, k))
return (typename K::FT)(s1_min_s2*s1_min_s2);
}
return squared_distance_to_line(ray1dir, s1_min_s2, k);
}
template <class K>
typename K::FT
squared_distance(
const typename K::Ray_3 &ray1,
const typename K::Ray_3 &ray2,
const K& k)
{
typename K::Construct_vector_3 construct_vector;
typedef typename K::Vector_3 Vector_3;
typedef typename K::Point_3 Point_3;
typedef typename K::RT RT;
typedef typename K::FT FT;
const Point_3 & s1 = ray1.source();
const Point_3 & s2 = ray2.source();
Vector_3 dir1, dir2, normal;
dir1 = ray1.direction().vector();
dir2 = ray2.direction().vector();
normal = wcross(dir1, dir2, k);
Vector_3 s1_min_s2 = construct_vector(s2, s1);
if (is_null(normal, k))
return ray_ray_squared_distance_parallel(dir1, dir2, s1_min_s2, k);
bool crossing1, crossing2;
RT sdm_s1_2, sdm_s2_1;
Vector_3 perpend1, perpend2;
perpend1 = wcross(dir1, normal, k);
perpend2 = wcross(dir2, normal, k);
sdm_s1_2 = wdot(perpend2, s1_min_s2, k);
if (sdm_s1_2 < RT(0)) {
crossing1 = (RT(wdot(perpend2, dir1, k)) >= RT(0));
} else {
if (RT(wdot(perpend2, dir1, k)) <= RT(0)) {
crossing1 = true;
} else {
crossing1 = (sdm_s1_2 == RT(0));
}
}
sdm_s2_1 = -RT(wdot(perpend1, s1_min_s2, k));
if (sdm_s2_1 < RT(0)) {
crossing2 = (RT(wdot(perpend1, dir2, k)) >= RT(0));
} else {
if (RT(wdot(perpend1, dir2, k)) <= RT(0)) {
crossing2 = true;
} else {
crossing2 = (sdm_s2_1 == RT(0));
}
}
if (crossing1) {
if (crossing2)
return squared_distance_to_plane(normal, s1_min_s2, k);
return squared_distance(ray2.source(), ray1, k);
} else {
if (crossing2) {
return squared_distance(ray1.source(), ray2, k);
} else {
FT min1, min2;
min1 = squared_distance(ray1.source(), ray2, k);
min2 = squared_distance(ray2.source(), ray1, k);
return (min1 < min2) ? min1 : min2;
}
}
}
template <class K>
typename K::FT
squared_distance(
const typename K::Line_3 &line,
const typename K::Ray_3 &ray,
const K& k)
{
typename K::Construct_vector_3 construct_vector;
typedef typename K::Vector_3 Vector_3;
typedef typename K::Point_3 Point_3;
typedef typename K::RT RT;
const Point_3 & rs =ray.source();
Vector_3 raydir, linedir, normal;
linedir = line.direction().vector();
raydir = ray.direction().vector();
normal = wcross(raydir, linedir, k);
Vector_3 rs_min_lp = construct_vector(line.point(), rs);
if (is_null(normal, k))
return squared_distance_to_line(linedir, rs_min_lp, k);
bool crossing;
RT sdm_sr_l;
Vector_3 perpend2l;
perpend2l = wcross(linedir, normal, k);
sdm_sr_l = wdot(perpend2l, rs_min_lp, k);
if (sdm_sr_l < RT(0)) {
crossing = (RT(wdot(perpend2l, raydir, k)) >= RT(0));
} else {
if (RT(wdot(perpend2l, raydir, k)) <= RT(0)) {
crossing = true;
} else {
crossing = (sdm_sr_l == RT(0));
}
}
if (crossing)
return squared_distance_to_plane(normal, rs_min_lp, k);
else
return squared_distance_to_line(linedir, rs_min_lp, k);
}
template <class K>
inline typename K::FT
squared_distance(
const typename K::Ray_3 & ray,
const typename K::Line_3 & line,
const K& k)
{
return squared_distance(line, ray, k);
}
template <class K>
typename K::FT
squared_distance(
const typename K::Line_3 &line1,
const typename K::Line_3 &line2,
const K& k)
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
{
Integrate Instant-Meshes 1. Drop windows 32bit support Add windows 64bit support. 2. Remove Script(quickjs) support The current integrated quickjs is a very old version which doesn’t support windows 64bit system. In the future, (TODO)WebAssembly should be integrate as plugin system. 3. Integrate Instant-Meshes Instant-Meshes take less than 1 second on all three platforms. 4. Remove QuadriFlow Current implementation of QuadriFlow is too slow (take about 5 seconds on the example model) to do realtime remeshing.
2020-01-04 10:29:10 +00:00
typename K::Construct_vector_3 construct_vector;
typedef typename K::Vector_3 Vector_3;
Vector_3 dir1, dir2, normal, diff;
dir1 = line1.direction().vector();
dir2 = line2.direction().vector();
normal = wcross(dir1, dir2, k);
diff = construct_vector(line1.point(), line2.point());
if (is_null(normal, k))
return squared_distance_to_line(dir2, diff, k);
return squared_distance_to_plane(normal, diff, k);
}
} // namespace internal
template <class K>
inline
typename K::FT
squared_distance(const Point_3<K> &pt,
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
const Line_3<K> &line)
Integrate Instant-Meshes 1. Drop windows 32bit support Add windows 64bit support. 2. Remove Script(quickjs) support The current integrated quickjs is a very old version which doesn’t support windows 64bit system. In the future, (TODO)WebAssembly should be integrate as plugin system. 3. Integrate Instant-Meshes Instant-Meshes take less than 1 second on all three platforms. 4. Remove QuadriFlow Current implementation of QuadriFlow is too slow (take about 5 seconds on the example model) to do realtime remeshing.
2020-01-04 10:29:10 +00:00
{
return internal::squared_distance(pt, line, K());
}
template <class K>
inline
typename K::FT
squared_distance(
const Line_3<K> & line,
const Point_3<K> & pt)
{
return internal::squared_distance(pt, line, K());
}
template <class K>
inline
typename K::FT
squared_distance(
const Point_3<K> &pt,
const Ray_3<K> &ray)
{
return internal::squared_distance(pt, ray, K());
}
template <class K>
inline
typename K::FT
squared_distance(
const Ray_3<K> & ray,
const Point_3<K> & pt)
{
return internal::squared_distance(pt, ray, K());
}
template <class K>
inline
typename K::FT
squared_distance(
const Point_3<K> &pt,
const Segment_3<K> &seg)
{
return internal::squared_distance(pt, seg, K());
}
template <class K>
inline
typename K::FT
squared_distance(
const Segment_3<K> & seg,
const Point_3<K> & pt)
{
return internal::squared_distance(pt, seg, K());
}
template <class K>
inline
typename K::FT
squared_distance_parallel(
const Segment_3<K> &seg1,
const Segment_3<K> &seg2)
{
return internal::squared_distance_parallel(seg1, seg2, K());
}
template <class K>
inline
typename K::FT
squared_distance(const Segment_3<K> &seg1,
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
const Segment_3<K> &seg2)
Integrate Instant-Meshes 1. Drop windows 32bit support Add windows 64bit support. 2. Remove Script(quickjs) support The current integrated quickjs is a very old version which doesn’t support windows 64bit system. In the future, (TODO)WebAssembly should be integrate as plugin system. 3. Integrate Instant-Meshes Instant-Meshes take less than 1 second on all three platforms. 4. Remove QuadriFlow Current implementation of QuadriFlow is too slow (take about 5 seconds on the example model) to do realtime remeshing.
2020-01-04 10:29:10 +00:00
{
return internal::squared_distance(seg1, seg2, K());
}
template <class K>
inline
typename K::FT
squared_distance_parallel(
const Segment_3<K> &seg,
const Ray_3<K> &ray)
{
return internal::squared_distance_parallel(ray,seg, K());
}
template <class K>
inline
typename K::FT
squared_distance(
const Segment_3<K> &seg,
const Ray_3<K> &ray)
{
return internal::squared_distance(ray, seg, K());
}
template <class K>
inline
typename K::FT
squared_distance(
const Ray_3<K> & ray,
const Segment_3<K> & seg)
{
return internal::squared_distance(seg, ray, K());
}
template <class K>
inline
typename K::FT
squared_distance(
const Segment_3<K> &seg,
const Line_3<K> &line)
{
return internal::squared_distance(seg, line, K());
}
template <class K>
inline
typename K::FT
squared_distance(
const Line_3<K> & line,
const Segment_3<K> & seg)
{
return internal::squared_distance(seg, line, K());
}
template <class K>
inline
typename K::FT
ray_ray_squared_distance_parallel(
const Vector_3<K> &ray1dir,
const Vector_3<K> &ray2dir,
const Vector_3<K> &s1_min_s2)
{
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
return internal::ray_ray_squared_distance_parallel(ray1dir, ray2dir,
s1_min_s2, K());
Integrate Instant-Meshes 1. Drop windows 32bit support Add windows 64bit support. 2. Remove Script(quickjs) support The current integrated quickjs is a very old version which doesn’t support windows 64bit system. In the future, (TODO)WebAssembly should be integrate as plugin system. 3. Integrate Instant-Meshes Instant-Meshes take less than 1 second on all three platforms. 4. Remove QuadriFlow Current implementation of QuadriFlow is too slow (take about 5 seconds on the example model) to do realtime remeshing.
2020-01-04 10:29:10 +00:00
}
template <class K>
inline
typename K::FT
squared_distance(
const Ray_3<K> &ray1,
const Ray_3<K> &ray2)
{
return internal::squared_distance(ray1, ray2, K());
}
template <class K>
inline
typename K::FT
squared_distance(
const Line_3<K> &line,
const Ray_3<K> &ray)
{
return internal::squared_distance(line, ray, K());
}
template <class K>
inline
typename K::FT
squared_distance(
const Ray_3<K> & ray,
const Line_3<K> & line)
{
return internal::squared_distance(line, ray, K());
}
template <class K>
inline
typename K::FT
squared_distance(
const Line_3<K> &line1,
const Line_3<K> &line2)
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
{
Integrate Instant-Meshes 1. Drop windows 32bit support Add windows 64bit support. 2. Remove Script(quickjs) support The current integrated quickjs is a very old version which doesn’t support windows 64bit system. In the future, (TODO)WebAssembly should be integrate as plugin system. 3. Integrate Instant-Meshes Instant-Meshes take less than 1 second on all three platforms. 4. Remove QuadriFlow Current implementation of QuadriFlow is too slow (take about 5 seconds on the example model) to do realtime remeshing.
2020-01-04 10:29:10 +00:00
return internal::squared_distance(line1, line2, K());
}
} //namespace CGAL
#endif