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

501 lines
19 KiB
C
Raw Normal View History

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
// Copyright (c) 1997-2002 Max-Planck-Institute Saarbruecken (Germany).
// All rights reserved.
//
// This file is part of CGAL (www.cgal.org).
//
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
// $URL: https://github.com/CGAL/cgal/blob/v5.1/Nef_3/include/CGAL/Nef_3/SNC_intersection.h $
// $Id: SNC_intersection.h 0779373 2020-03-26T13:31:46+01:00 Sébastien Loriot
// SPDX-License-Identifier: GPL-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) : Michael Seel <seel@mpi-sb.mpg.de>
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
// Peter Hachenberger <hachenberger@mpi-sb.mpg.de>
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
#ifndef CGAL_SNC_INTERSECTION_H
#define CGAL_SNC_INTERSECTION_H
#include <CGAL/license/Nef_3.h>
#include <CGAL/basic.h>
#undef CGAL_NEF_DEBUG
#define CGAL_NEF_DEBUG 37
#include <CGAL/Nef_2/debug.h>
namespace CGAL {
template < class Node, class Object>
struct Project_shalfedge_point {
typedef Node argument_type;
typedef Object result_type;
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
Object& operator()( Node& x) const {
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 x.source()->source()->point();
/* a Point_3& reference must be returned by D.point() */
}
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
const Object& operator()( const Node& x) const {
return x.source()->source()->point();
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
/* a Point_3& reference must be returned by D.point() */
}
};
template<typename SNC_structure_>
class SNC_intersection : public SNC_const_decorator<SNC_structure_> {
// TODO: granados: is it really necessary to inherit from the decorator?
typedef SNC_structure_ SNC_structure;
typedef SNC_intersection<SNC_structure> Self;
typedef SNC_const_decorator<SNC_structure> Base;
// typedef SNC_const_decorator<SNC_structure> SNC_const_decorator;
typedef typename SNC_structure::SHalfedge SHalfedge;
typedef typename SNC_structure::Halfedge_handle Halfedge_handle;
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
typedef typename SNC_structure::Halffacet_const_handle
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
Halffacet_const_handle;
typedef typename SNC_structure::SHalfedge_const_handle SHalfedge_const_handle;
typedef typename SNC_structure::SHalfloop_const_handle SHalfloop_const_handle;
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
typedef typename SNC_structure::SHalfedge_around_facet_const_circulator
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
SHalfedge_around_facet_const_circulator;
typedef typename SNC_structure::Halffacet_cycle_const_iterator
Halffacet_cycle_const_iterator;
#ifdef CGAL_NEF3_FACET_WITH_BOX
typedef typename SNC_structure::Partial_facet Partial_facet;
#endif
typedef typename SNC_structure::Point_3 Point_3;
typedef typename SNC_structure::Vector_3 Vector_3;
typedef typename SNC_structure::Segment_3 Segment_3;
typedef typename SNC_structure::Line_3 Line_3;
typedef typename SNC_structure::Ray_3 Ray_3;
typedef typename SNC_structure::Plane_3 Plane_3;
typedef typename SNC_structure::Triangle_3 Triangle_3;
public:
SNC_intersection() : Base() {}
SNC_intersection(const SNC_structure& W) : Base(W) {}
bool does_contain_internally(const Segment_3& s, const Point_3& p) const {
if(!are_strictly_ordered_along_line (s.source(), p, s.target()))
return false;
if(!s.supporting_line().has_on(p))
return false;
return true;
}
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
bool does_contain_internally( Halffacet_const_handle f,
const Point_3& p,
bool check_has_on = true) const {
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(check_has_on && !f->plane().has_on(p))
return false;
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
return (locate_point_in_halffacet( p, f) == CGAL::ON_BOUNDED_SIDE);
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
}
#ifdef CGAL_NEF3_FACET_WITH_BOX
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
bool does_contain_internally( Partial_facet& pf,
const Point_3& p) const {
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
CGAL_NEF_TRACEN("does point lie in partial facet" << p);
// pf.debug();
if( !pf.f->plane().has_on(p))
return false;
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
return (locate_point_in_halffacet( p, pf) == CGAL::ON_BOUNDED_SIDE);
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
}
#endif
bool does_contain_on_boundary( Halffacet_const_handle f, const Point_3& p) const {
typedef Project_shalfedge_point
< SHalfedge, const Point_3> Project;
typedef Circulator_project
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
< SHalfedge_around_facet_const_circulator, Project,
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
const Point_3&, const Point_3*> Circulator;
Halffacet_cycle_const_iterator fc = f->facet_cycles_begin();
CGAL_assertion(fc.is_shalfedge());
if (fc.is_shalfedge() ) {
SHalfedge_const_handle se(fc);
SHalfedge_around_facet_const_circulator hfc(se);
Circulator c(hfc), cp(c), cend(c);
do {
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
c++;
CGAL_NEF_TRACEN("contained on edge "<<Segment_3( *c, *cp)<<"? "<<
Segment_3( *c, *cp).has_on(p));
if( Segment_3( *c, *cp).has_on(p))
return true;
cp++;
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
while( c != cend);
}
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
Halffacet_cycle_const_iterator fe = f->facet_cycles_end();
++fc;
CGAL_For_all(fc, fe) {
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
if (fc.is_shalfloop() ) {
SHalfloop_const_handle l(fc);
CGAL_NEF_TRACEN("isolated point on "<<l->incident_sface()->center_vertex()->point()<<"? ");
if( l->incident_sface()->center_vertex()->point() == p)
return true;
}
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
else if (fc.is_shalfedge() ) {
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
SHalfedge_const_handle se(fc);
SHalfedge_around_facet_const_circulator hfc(se);
Circulator c(hfc), cp(c), cend(c);
do {
c++;
CGAL_NEF_TRACEN("contained on edge "<<Segment_3( *c, *cp)<<"? "<<
Segment_3( *c, *cp).has_on(p));
if( Segment_3( *c, *cp).has_on(p))
return true;
cp++;
}
while( c != cend);
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
else
CGAL_error_msg( "Damn wrong handle.");
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 false;
}
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
#ifdef LINE3_LINE3_INTERSECTION
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
bool does_intersect_internally( const Segment_3& s1,
const Segment_3& s2,
Point_3& p) const {
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
CGAL_NEF_TRACEN("does intersect internally with LINE3_LINE3_INTERSECTION");
if ( s1.is_degenerate() || s2.is_degenerate())
/* the segment is degenerate so there is not internal intersection */
return false;
if ( s1.has_on(s2.source()) || s1.has_on(s2.target()) ||
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
s2.has_on(s1.source()) || s2.has_on(s1.target()))
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
/* the segments does intersect at one endpoint */
return false;
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
Object o = intersection(Line_3(ray), Line_3(s));
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 ( !CGAL::assign(p, o))
return false;
return( does_contain_internally( s, p));
}
#else // LINE3_LINE3_INTERSECTION
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
bool does_intersect_internally( const Segment_3& s1,
const Segment_3& s2,
Point_3& p) const {
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(s2.has_on(s1.target()))
return false;
Ray_3 r(s1.source(), s1.target());
if(!does_intersect_internally(r, s2, p))
return false;
Plane_3 pl(s1.target(), r.to_vector());
return (pl.oriented_side(p) == CGAL::NEGATIVE);
}
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
bool does_intersect_internally( const Ray_3& s1,
const Segment_3& s2,
Point_3& p) const {
CGAL_NEF_TRACEN("does intersect internally without LINE3_LINE3_INTERSECTION");
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
CGAL_assertion(!s1.is_degenerate());
CGAL_assertion(!s2.is_degenerate());
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
if ( orientation( s1.source(), s1.point(1), s2.source(), s2.target())
!= COPLANAR)
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
// the segments doesn't define a plane
return false;
if ( s1.has_on(s2.source()) || s1.has_on(s2.target()) ||
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
s2.has_on(s1.source()))
// the segments does intersect at one endpoint
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 false;
Line_3 ls1(s1), ls2(s2);
if ( ls1.direction() == ls2.direction() ||
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
ls1.direction() == -ls2.direction() )
// the segments are parallel
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 false;
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
Vector_3 vs1(s1.to_vector()), vs2(s2.to_vector()),
vt(cross_product( vs1, vs2)),
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
ws1(cross_product( vt, vs1)); // , ws2(cross_product( vt, vs2));
Plane_3 hs1( s1.source(), ws1);
Object o = intersection(hs1, ls2);
CGAL_assertion(CGAL::assign( p, o));
// since line(s1) and line(s2) are not parallel they intersects in only
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
// one point
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
CGAL::assign( p ,o);
Plane_3 pl(s1.source(), vs1);
if(pl.oriented_side(p) != CGAL::POSITIVE)
return false;
pl = Plane_3(s2.source(), vs2);
if(pl.oriented_side(p) != CGAL::POSITIVE)
return false;
pl = Plane_3(s2.target(), vs2);
return (pl.oriented_side(p) == CGAL::NEGATIVE);
}
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
#endif // LINE3_LINE3_INTERSECTION
bool does_intersect( const Ray_3& r, const Triangle_3& tr,
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
Point_3& ip) const {
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
// Intersection between an open ray and
// a closed 2d-triangular region in the space
CGAL_NEF_TRACEN("-> Intersection triangle - ray");
CGAL_NEF_TRACEN(" -> Ray: "<<r);
CGAL_NEF_TRACEN(" -> Triangle: "<<tr);
CGAL_assertion( !r.is_degenerate());
Plane_3 h( tr.supporting_plane());
CGAL_assertion( !h.is_degenerate());
if( h.has_on( r.source()))
return false;
Object o = intersection( h, r);
if( !CGAL::assign( ip, o))
return false;
CGAL_NEF_TRACEN(" -> intersection point: "<<ip);
return tr.has_on(ip);
}
bool does_intersect( const Segment_3& s, const Triangle_3& tr,
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
Point_3& ip) const {
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
// Intersection between a open segment and
// a closed 2d-triangular region in the space
CGAL_NEF_TRACEN("-> Intersection triangle - segment");
CGAL_NEF_TRACEN(" -> Segment: "<<s);
CGAL_NEF_TRACEN(" -> Triangle: "<<tr);
CGAL_assertion( !s.is_degenerate());
Plane_3 h( tr.supporting_plane());
CGAL_assertion( !h.is_degenerate());
if( h.has_on( s.source()) || h.has_on( s.target()))
return false;
Object o = intersection( h, s);
if( !CGAL::assign( ip, o))
return false;
CGAL_NEF_TRACEN(" -> intersection point: "<<ip);
return tr.has_on(ip);
}
bool does_intersect_internally( const Ray_3& ray,
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
Halffacet_const_handle f,
Point_3& p,
bool checkHasOn = true) const {
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
CGAL_NEF_TRACEN("-> Intersection facet - ray");
Plane_3 h( f->plane());
CGAL_NEF_TRACEN("-> facet's plane: " << h);
CGAL_NEF_TRACEN("-> a point on the plane: " << h.point());
CGAL_NEF_TRACEN("-> ray: " << ray);
CGAL_assertion(!ray.is_degenerate());
if(checkHasOn) {
if(h.has_on(ray.source()))
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
return false;
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
} else
CGAL_assertion(!h.has_on(ray.source()));
Object o = intersection( h, ray);
if( !CGAL::assign( p, o))
return false;
CGAL_NEF_TRACEN( "-> intersection point: " << p );
CGAL_NEF_TRACEN( "-> point in facet interior? "<<does_contain_internally( f, p));
return does_contain_internally( f, p, false);
}
#ifdef CGAL_NEF3_FACET_WITH_BOX
bool does_intersect_internally( const Ray_3& ray,
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
Partial_facet pf,
Point_3& p) const {
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
CGAL_NEF_TRACEN("-> Intersection facet - ray");
Plane_3 h( pf.f->plane());
CGAL_NEF_TRACEN("-> facet's plane: " << h);
CGAL_NEF_TRACEN("-> a point on the plane: " << h.point());
CGAL_NEF_TRACEN("-> ray: " << ray);
CGAL_assertion(!ray.is_degenerate());
if( h.has_on( ray.source()))
/* no possible internal intersection */
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
return false;
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
Object o = intersection( h, ray);
if( !CGAL::assign( p, o))
return false;
CGAL_NEF_TRACEN( "-> intersection point: " << p );
// CGAL_NEF_TRACEN( "-> point in facet interior? "<<does_contain_internally( f, p));
return does_contain_internally( pf, p, false);
}
#endif
bool does_intersect_internally( const Segment_3& seg,
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
Halffacet_const_handle f,
Point_3& p) const {
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
CGAL_NEF_TRACEN("-> Intersection facet - segment");
Plane_3 h( f->plane());
CGAL_NEF_TRACEN("-> facet's plane: " << h);
CGAL_NEF_TRACEN("-> a point on the plane: " << h.point());
CGAL_NEF_TRACEN("-> segment: " << seg);
CGAL_assertion(!seg.is_degenerate());
if( h.has_on( seg.source()) || h.has_on(seg.target()))
/* no possible internal intersection */
return false;
return does_intersect(seg, f, p);
}
bool does_intersect(const Segment_3& seg,
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
Halffacet_const_handle f,
Point_3& p) const {
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
Plane_3 h( f->plane());
Object o = intersection( h, seg);
if( !CGAL::assign( p, o))
return false;
CGAL_NEF_TRACEN( "-> intersection point: " << p );
CGAL_NEF_TRACEN( "-> point in facet interior? "<<does_contain_internally( f, p));
return( does_contain_internally( f, p, false));
}
#ifdef CGAL_NEF3_FACET_WITH_BOX
bool does_intersect_internally( const Segment_3& seg,
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
Partial_facet pf,
Point_3& p) const {
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
CGAL_NEF_TRACEN("-> Intersection partial facet - segment");
Plane_3 h( pf.f->plane());
CGAL_NEF_TRACEN("-> facet's plane: " << h);
CGAL_NEF_TRACEN("-> a point on the plane: " << h.point());
CGAL_NEF_TRACEN("-> segment: " << seg);
CGAL_assertion(!seg.is_degenerate());
if( h.has_on( seg.source()) || h.has_on(seg.target()))
/* no possible internal intersection */
return false;
Object o = intersection( h, seg);
if( !CGAL::assign( p, o))
return false;
CGAL_NEF_TRACEN( "-> intersection point: " << p );
// CGAL_NEF_TRACEN( "-> point in facet interior? "<<does_contain_internally( f, p));
return( does_contain_internally( pf, p, false));
}
#endif
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
Bounded_side locate_point_in_halffacet( const Point_3& p,
Halffacet_const_handle f) const {
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
CGAL_NEF_TRACEN("locate point in halffacet " << p << ", " << f->plane());
typedef Project_shalfedge_point
< SHalfedge, const Point_3> Project;
typedef Circulator_project
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
< SHalfedge_around_facet_const_circulator, Project,
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
const Point_3&, const Point_3*> Circulator;
typedef Container_from_circulator<Circulator> Container;
Plane_3 h(f->plane());
CGAL_assertion(h.has_on(p));
Halffacet_cycle_const_iterator fc = f->facet_cycles_begin();
Bounded_side outer_bound_pos(CGAL::ON_BOUNDARY);
if (fc.is_shalfedge() ) {
SHalfedge_const_handle se(fc);
SHalfedge_around_facet_const_circulator hfc(se);
Circulator c(hfc);
Container ct(c);
CGAL_assertion( !is_empty_range(ct.begin(), ct.end()));
outer_bound_pos = bounded_side_3(ct.begin(), ct.end(), p, h);
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
}
else
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
CGAL_error_msg( "is facet first cycle a SHalfloop?");
if( outer_bound_pos != CGAL::ON_BOUNDED_SIDE )
return outer_bound_pos;
/* The point p is not in the relative interior of the outer face cycle
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
so it is not necesary to know the possition of p with respect to the
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
inner face cycles */
Halffacet_cycle_const_iterator fe = f->facet_cycles_end();
++fc;
if( fc == fe )
return outer_bound_pos;
Bounded_side inner_bound_pos(CGAL::ON_BOUNDARY);
CGAL_For_all(fc, fe) {
if (fc.is_shalfloop() ) {
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
SHalfloop_const_handle l(fc);
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(l->incident_sface()->center_vertex()->point() == p )
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
inner_bound_pos = CGAL::ON_BOUNDARY;
else
inner_bound_pos = CGAL::ON_UNBOUNDED_SIDE;
}
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
else if (fc.is_shalfedge() ) {
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
SHalfedge_const_handle se(fc);
SHalfedge_around_facet_const_circulator hfc(se);
Circulator c(hfc);
Container ct(c);
CGAL_assertion( !is_empty_range(ct.begin(), ct.end()));
inner_bound_pos = bounded_side_3( ct.begin(), ct.end(),
p, h.opposite());
}
else
CGAL_error_msg( "Damn wrong handle.");
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( inner_bound_pos != CGAL::ON_UNBOUNDED_SIDE )
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
return opposite(inner_bound_pos);
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
/* At this point the point p belongs to relative interior of the facet's
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
outer cycle, and its possition is completely known when it belongs
to the clousure of any inner cycle */
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::ON_BOUNDED_SIDE;
}
#ifdef CGAL_NEF3_FACET_WITH_BOX
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
Bounded_side locate_point_in_halffacet( const Point_3& p,
Partial_facet pf) const {
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(p.x() < pf.f->b.min_coord(0) || p.x() > pf.f->b.max_coord(0) ||
p.y() < pf.f->b.min_coord(1) || p.y() > pf.f->b.max_coord(1) ||
p.z() < pf.f->b.min_coord(2) || p.z() > pf.f->b.max_coord(2))
return CGAL::ON_UNBOUNDED_SIDE;
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 Project_shalfedge_point
< SHalfedge, Point_3> Project;
typedef Circulator_project
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
< SHalfedge_around_facet_const_circulator, Project,
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
const Point_3&, const Point_3*> Circulator;
typedef Container_from_circulator<Circulator> Container;
typedef typename Partial_facet::Outer_cycle_iterator Outer_cycle_iterator;
typedef typename Partial_facet::Inner_cycle_iterator Inner_cycle_iterator;
typedef typename Partial_facet::Isolated_vertex_iterator Isolated_vertex_iterator;
Plane_3 h(pf.f->plane());
CGAL_assertion(h.has_on(p));
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
Bounded_side outer_bound_pos(CGAL::ON_BOUNDED_SIDE);
Outer_cycle_iterator oc = pf.outer_cycles_begin();
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
while(oc != pf.outer_cycles_end() &&
outer_bound_pos == CGAL::ON_BOUNDED_SIDE) {
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(oc->first == oc->second) {
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
SHalfedge_around_facet_const_circulator hfc(oc->first);
Circulator c(hfc);
Container ct(c);
CGAL_assertion( !is_empty_range(ct.begin(), ct.end()));
outer_bound_pos = bounded_side_3(ct.begin(), ct.end(), p, h);
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
} else {
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
outer_bound_pos = bounded_side_3(Circulator(SHalfedge_around_facet_const_circulator(oc->first)),
Circulator(SHalfedge_around_facet_const_circulator(oc->second)), p, h);
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
}
++oc;
}
if(outer_bound_pos != CGAL::ON_BOUNDED_SIDE )
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
return outer_bound_pos;
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
Bounded_side inner_bound_pos(CGAL::ON_UNBOUNDED_SIDE);
Inner_cycle_iterator ic = pf.inner_cycles_begin();
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
while(ic != pf.inner_cycles_end() &&
inner_bound_pos == CGAL::ON_UNBOUNDED_SIDE) {
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(ic->first == ic->second) {
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
SHalfedge_around_facet_const_circulator hfc(ic->first);
Circulator c(hfc);
Container ct(c);
CGAL_assertion( !is_empty_range(ct.begin(), ct.end()));
inner_bound_pos = bounded_side_3(ct.begin(), ct.end(), p, h);
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
} else {
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
inner_bound_pos = bounded_side_3(Circulator(SHalfedge_around_facet_const_circulator(ic->first)),
Circulator(SHalfedge_around_facet_const_circulator(ic->second)), p, h);
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
}
++ic;
}
if(inner_bound_pos != CGAL::ON_UNBOUNDED_SIDE )
return opposite(inner_bound_pos);
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
Isolated_vertex_iterator iv = pf.isolated_vertices_begin();
while(iv != pf.isolated_vertices_end()) {
if(*iv == p)
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
return CGAL::ON_BOUNDARY;
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
++iv;
}
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 CGAL::ON_BOUNDED_SIDE;
}
#endif
}; // SNC_intersection
} //namespace CGAL
#endif //CGAL_SNC_INTERSECTION_H