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

2464 lines
82 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-2000 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_S2/include/CGAL/Nef_S2/SM_overlayer.h $
// $Id: SM_overlayer.h fdb17cb 2020-03-26T19:26:10+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>
// Peter Hachenberger <hachenberger@mpi-sb.mpg.de>
#ifndef CGAL_SM_OVERLAYER_H
#define CGAL_SM_OVERLAYER_H
#include <CGAL/license/Nef_S2.h>
#include <CGAL/basic.h>
#include <CGAL/Union_find.h>
#include <CGAL/Nef_2/Segment_overlay_traits.h>
#ifdef CGAL_I_DO_WANT_TO_USE_GENINFO
#include <CGAL/Nef_2/geninfo.h>
#else
#include <boost/any.hpp>
#endif
#include <CGAL/Nef_S2/Sphere_geometry.h>
#include <CGAL/Nef_S2/SM_decorator.h>
#include <CGAL/Nef_S2/SM_const_decorator.h>
#include <CGAL/Nef_S2/SM_point_locator.h>
#include <CGAL/Nef_S2/SM_io_parser.h>
#include <CGAL/Nef_S2/ID_support_handler.h>
#undef CGAL_NEF_DEBUG
#define CGAL_NEF_DEBUG 131
#include <CGAL/Nef_2/debug.h>
#ifndef CGAL_USE_LEDA
#define LEDA_MEMORY(t)
#else
#include <LEDA/system/memory.h>
#endif
#include <CGAL/use.h>
namespace CGAL {
template <typename Decorator_, typename I>
struct SMO_from_segs {
typedef Decorator_ SM_decorator;
typedef typename SM_decorator::SVertex_handle Vertex_handle;
typedef typename SM_decorator::SHalfedge_handle Halfedge_handle;
typedef typename SM_decorator::Sphere_point Point;
typedef typename SM_decorator::Sphere_segment Segment;
typedef CGAL::Unique_hash_map<I,bool> Iterator_map;
SM_decorator G;
const Iterator_map& M;
SMO_from_segs(SM_decorator Gi, const Iterator_map& Mi) : G(Gi),M(Mi) {}
Vertex_handle new_vertex(const Point& p)
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
{ Vertex_handle v = G.new_svertex(p);
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_I_DO_WANT_TO_USE_GENINFO
geninfo<Halfedge_handle>::create(G.info(v));
#else
G.info(v)=Halfedge_handle();
#endif
return v;
}
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
void link_as_target_and_append(Vertex_handle v, Halfedge_handle e)
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
{ G.link_as_target_and_append(v,e); }
Halfedge_handle new_halfedge_pair_at_source(Vertex_handle v)
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
{ Halfedge_handle e =
G.new_shalfedge_pair_at_source(v,SM_decorator::BEFORE);
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 e;
}
void supporting_segment(Halfedge_handle e, I it) const
{ if ( M[it] ) e->mark() = true; }
void trivial_segment(Vertex_handle v, I it) const
{ if ( M[it] ) v->mark() = true; }
void starting_segment(Vertex_handle v, I it) const
{ if ( M[it] ) v->mark() = true; }
void passing_segment(Vertex_handle v, I it) const
{ if ( M[it] ) v->mark() = true; }
void ending_segment(Vertex_handle v, I it) const
{ if ( M[it] ) v->mark() = true; }
void halfedge_below(Vertex_handle v, Halfedge_handle e) const
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 CGAL_I_DO_WANT_TO_USE_GENINFO
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
geninfo<Halfedge_handle>::access(G.info(v)) = e;
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
G.info(v)=e;
#endif
}
Halfedge_handle halfedge_below(Vertex_handle v) const
{
#ifdef CGAL_I_DO_WANT_TO_USE_GENINFO
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
return geninfo<Halfedge_handle>::access(G.info(v));
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
return
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
boost::any_cast<Halfedge_handle>( G.info(v) );
#endif
}
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
void assert_equal_marks(Vertex_handle v1, Vertex_handle v2) 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_USE(v1);
CGAL_USE(v2);
CGAL_assertion(v1->mark()==v2->mark());
}
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
void discard_info(Vertex_handle v) 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
#ifdef CGAL_I_DO_WANT_TO_USE_GENINFO
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
geninfo<Halfedge_handle>::clear(G.info(v));
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
G.info(v)=boost::any();
#endif
}
void assert_equal_marks(Halfedge_handle e1, Halfedge_handle e2) const
{
CGAL_USE(e1);
CGAL_USE(e2);
CGAL_assertion(e1->mark()==e2->mark());
}
void discard_info(Halfedge_handle ) const {}
void clear_temporary_vertex_info() const
{ Vertex_handle v;
CGAL_forall_svertices(v,G)
#ifdef CGAL_I_DO_WANT_TO_USE_GENINFO
geninfo<Halfedge_handle>::clear(G.info(v));
#else
G.info(v)=boost::any();
#endif
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
}
}; // SMO_from_segs
template <typename SM_overlayer, typename IT, typename INFO>
struct SMO_from_sm {
typedef typename SM_overlayer::SM_const_decorator SM_const_decorator;
typedef typename SM_overlayer::SVertex_handle Vertex_handle;
typedef typename SM_overlayer::SHalfedge_handle Halfedge_handle;
typedef typename SM_overlayer::Sphere_point Point;
typedef typename SM_overlayer::Sphere_segment Segment;
SM_overlayer G;
CGAL::Unique_hash_map<IT,INFO>& M;
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
SMO_from_sm(SM_overlayer Gi,
SM_const_decorator* /* pGIi */,
CGAL::Unique_hash_map<IT,INFO>& Mi) :
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
G(Gi), M(Mi) {}
Vertex_handle new_vertex(const Point& p)
{ CGAL_NEF_TRACEN(" new vertex " << p);
Vertex_handle v = G.new_svertex(p);
G.assoc_info(v);
return v;
}
void link_as_target_and_append(Vertex_handle v, Halfedge_handle e)
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
{ CGAL_NEF_TRACEN(" link as target and append "
<< e->source()->point() << "->"
<< v->point());
G.link_as_target_and_append(v,e); }
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
Halfedge_handle new_halfedge_pair_at_source(Vertex_handle v)
{ CGAL_NEF_TRACEN(" new halfedge pair at source " << v->point());
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
Halfedge_handle e =
G.new_shalfedge_pair_at_source(v,SM_overlayer::BEFORE);
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
G.assoc_info(e);
return e;
}
void halfedge_below(Vertex_handle v, Halfedge_handle e) const
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
CGAL_NEF_TRACEN(" edge below " << v->point() << ":");
CGAL_NEF_TRACEN(&*e);
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
G.halfedge_below(v) = e;
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
}
void supporting_segment(Halfedge_handle e, IT it) const
{ INFO& si = M[it];
G.is_forward(e) = true;
if ( si._from == -1 ) return; // equatorial segment
G.supp_object(e,si._from) = si._o;
CGAL_NEF_TRACEN(" supporting segment "<<si._from<<":"<<*it);
}
void trivial_segment(Vertex_handle v, IT it) const
{ INFO& si = M[it];
CGAL_assertion( ! si._o.empty() );
typename SM_const_decorator::SHalfedge_const_handle se;
typename SM_const_decorator::SHalfloop_const_handle sl;
typename SM_const_decorator::SVertex_const_handle sv;
if(CGAL::assign(se, si._o)) {
if(se->source()->point() != v->point())
se = se->twin();
if(se->source()->point() != v->point())
G.supp_object(v,si._from) = si._o;
else
G.supp_object(v,si._from) = make_object(se->source());
} else if(CGAL::assign(sl, si._o)) {
G.supp_object(v,si._from) = si._o;
} else if(CGAL::assign(sv, si._o)) {
CGAL_assertion(sv->point() == v->point());
G.supp_object(v,si._from) = si._o;
} else
CGAL_error_msg( "wrong handle");
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
CGAL_NEF_TRACEN("trivial_segment " << si._from << ":" << v->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
// debug();
}
void starting_segment(Vertex_handle v, IT it) const
{ INFO& si = M[it];
if ( si._from == -1 ) return;
typename SM_const_decorator::SHalfedge_const_handle se;
typename SM_const_decorator::SHalfloop_const_handle sl;
if(CGAL::assign(se, si._o)) {
if(se->source()->point() != v->point()) {
se = se->twin();
if(se->source()->point() != v->point()) {
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
G.supp_object(v,si._from) = si._o;
return;
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
}
}
G.supp_object(v,si._from) = make_object(se->source());
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
CGAL_NEF_TRACEN("starting_segment " << si._from << ":"<<
v->point() << " " << se->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
} else if(CGAL::assign(sl, si._o)) {
G.supp_object(v,si._from) = si._o;
} else
CGAL_error_msg( "wrong object");
// debug();
}
void ending_segment(Vertex_handle v, IT it) const
{ INFO& si = M[it];
if ( si._from == -1 ) return;
typename SM_const_decorator::SHalfedge_const_handle se;
typename SM_const_decorator::SHalfloop_const_handle sl;
if(CGAL::assign(se, si._o)) {
if(se->source()->point() != v->point()) {
se = se->twin();
if(se->source()->point() != v->point()) {
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
G.supp_object(v,si._from) = si._o;
return;
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
}
}
G.supp_object(v,si._from) = make_object(se->source());
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
CGAL_NEF_TRACEN("ending_segment " << si._from << ":"<<
v->point() << ":" <<
se->source()->point() << "->" <<
se->twin()->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
} else if(CGAL::assign(sl, si._o)) {
G.supp_object(v,si._from) = si._o;
} else
CGAL_error_msg( "wrong object");
// debug();
}
void passing_segment(Vertex_handle v, IT it) const
{ INFO& si = M[it];
if ( si._from == -1 ) return;
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
G.supp_object(v,si._from) = si._o;
CGAL_NEF_TRACEN("passing_segment " << si._from << ":"<< v->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
// debug();
}
Halfedge_handle halfedge_below(Vertex_handle v) const
{ return G.halfedge_below(v); }
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
void assert_equal_marks(Vertex_handle v1, Vertex_handle v2) 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_USE(v1);
CGAL_USE(v2);
CGAL_NEF_TRACEV(G.mark(v1,0));CGAL_NEF_TRACEV(G.mark(v1,1));
CGAL_NEF_TRACEV(G.mark(v2,0));CGAL_NEF_TRACEV(G.mark(v2,1));
CGAL_assertion(G.mark(v1,0)==G.mark(v2,0)&&
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
G.mark(v1,1)==G.mark(v2,1)); }
void discard_info(Vertex_handle v) 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
{ G.discard_info(v); }
void assert_equal_marks(Halfedge_handle e1, Halfedge_handle e2) const
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
CGAL_USE(e1);
CGAL_USE(e2);
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
CGAL_assertion(G.mark(e1,0)==G.mark(e2,0) &&
G.mark(e1,1)==G.mark(e2,1));
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
void discard_info(Halfedge_handle e) 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
{ G.discard_info(e); }
void debug() const {
typename SM_overlayer::SVertex_iterator svii;
CGAL_forall_svertices(svii, G) {
typename SM_overlayer::SVertex_const_handle vs;
typename SM_overlayer::SHalfedge_const_handle es;
if(CGAL::assign(vs, G.supp_object(svii,0)))
std::cerr << svii->point() << " supported by svertex " << vs->point() << std::endl;
else if(CGAL::assign(es, G.supp_object(svii,0)))
std::cerr << svii->point() << " supported by sedge" << std::endl;
else
std::cerr << svii->point() << " is neither supported by svertex or sedge" << std::endl;
if(CGAL::assign(vs, G.supp_object(svii,1)))
std::cerr << svii->point() << " supported by svertex" << vs->point() << std::endl;
else if(CGAL::assign(es, G.supp_object(svii,1)))
std::cerr << svii->point() << " supported by sedge" << std::endl;
else
std::cerr << svii->point() << " is neither supported by svertex or sedge" << std::endl;
}
}
}; // SMO_from_sm
template <typename SM_decorator, typename ITERATOR>
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
class SMO_decorator {
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
public:
typedef SM_decorator Graph;
typedef typename SM_decorator::SVertex_handle SVertex_handle;
typedef typename SM_decorator::SHalfedge_handle SHalfedge_handle;
typedef typename SM_decorator::Sphere_point Point_2;
typedef typename SM_decorator::Sphere_segment Segment_2;
SM_decorator G;
SMO_decorator(Graph Gi) : G(Gi) {}
SVertex_handle new_vertex(const Point_2& p)
{ return G.snew_vertex(p); }
void link_as_target_and_append(SVertex_handle v, SHalfedge_handle e)
{ G.link_as_target_and_append(v,e); }
SHalfedge_handle new_halfedge_pair_at_source(SVertex_handle v)
{ return G.new_shalfedge_pair_at_source(v,Graph::BEFORE); }
void supporting_segment(SHalfedge_handle /*e*/, ITERATOR /*it*/) {}
void halfedge_below(SVertex_handle /*v*/, SHalfedge_handle /*e*/) {}
void trivial_segment(SVertex_handle /*v*/, ITERATOR /*it*/) {}
void starting_segment(SVertex_handle /*v*/, ITERATOR /*it*/) {}
void passing_segment(SVertex_handle /*v*/, ITERATOR /*it*/) {}
void ending_segment(SVertex_handle /*v*/, ITERATOR /*it*/) {}
}; // SMO_decorator
// ============================================================================
// ============================================================================
/*{\Manpage {SM_overlayer}{SM_decorator}{Overlay in the sphere}{O}}*/
template <typename SM_decorator_>
class SM_overlayer : public SM_decorator_ {
public:
/*{\Mdefinition An instance |\Mvar| of data type |\Mname| is a
decorator object offering sphere map overlay calculation. Overlay is
either calculated from two sphere maps or from a set of halfspaces.
The result is stored in a sphere map |M| that carries the geometry and
the topology of the overlay.
The template parameter provides the underlying topological interface
to sphere maps. The template parameter |SM_decorator| has to be a model
conforming to our map decorator concept |SM_decorator|. The concept
also describes the interface how the topological information stored in
|M| can be extracted or extended.
The overlay of a set of sphere segments $S$ is stored in a sphere map
$M = (V,E,L,F)$. Vertices are either the endpoints of segments (trivial
segments are allowed) or the result of the internal intersection of
two segments. Between two vertices there's an edge if there's a
segment that supports the spherical embedding of $e$ and if there's no
vertex in the relative interior of the embedding of $e$.
The faces refer to the maximal connected open point sets of the
spherical subdivision implied by the embedding of the vertices and
edges. SFaces are bounded by possibly several face cycles\cgalFootnote{For
the definition of sphere maps and their concepts see the manual page
of |SM_decorator|.} including isolated vertices. The overlay process
in the method |create_from_segments| creates the objects and the
topology of the result. The method starts from zero- and
one-dimensional geometric objects in $S$ and produces a spherical
structure where each point of the sphere can be assigned to an object
(vertex, edge, loop, or face) of |M|.
The overlay of two sphere maps $M_i = (V_i, E_i, L_i, F_i)$ has the
additional aspect that we already start from two spherical
subdivisions. We use the index $i=0,1$ defining the reference to
$M_i$, unindexed variables refer to the resulting sphere map $M$. The
$1$-skeleta of the two maps subdivide the edges, loops, and faces of
the complementary structure into smaller units. This means vertices,
edges, and loops of $M_i$ can split edges and loops of $M_{1-i}$ and
face cycles of $M_i$ subdivide faces of $M_{1-i}$. The 1-skeleton $G$
of $M$ is defined by the overlay of the embedding of the 1-skeleta of
$M_0$ and $M_1$ (Take a trivial segment for each vertex and a segment
for each edge, and a circle for a loop, and use the overlay definition
of a set of segments and loops above). The faces of $M$ refer to the
maximal connected open point sets of the spherical subdivision implied
by the embedding of $G$. Each object from the output tuple $(V,E,F)$
has a \emph{supporting} object $u_i$ in each of the two input
structures. Imagine the two maps to be transparent balls, where one
contains the other. Then each point of the sphere is covered by an
object from each of the input structures. This support relationship
from the input structures to the output structure defines an
information flow. Each supporting object $u_i$ of $u$ $(i=0,1)$
carries an associated information $|mark|(u_i)$. After the subdivision
operation this information is attributed to the output object $u$ by
$|mark|(u,i)$.}*/
typedef SM_decorator_ SM_decorator;
typedef typename SM_decorator::Map Map;
typedef SM_decorator Base;
typedef SM_overlayer<SM_decorator_> Self;
typedef CGAL::SM_const_decorator<Map> SM_const_decorator;
typedef CGAL::SM_point_locator<SM_const_decorator> SM_point_locator;
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
// typedef typename SM_const_decorator::Constructor_parameter
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
// Constructor_const_parameter;
typedef typename SM_const_decorator::SVertex_const_handle SVertex_const_handle;
typedef typename SM_const_decorator::SHalfedge_const_handle SHalfedge_const_handle;
typedef typename SM_const_decorator::SHalfloop_const_handle SHalfloop_const_handle;
typedef typename SM_const_decorator::SFace_const_handle SFace_const_handle;
typedef typename SM_const_decorator::SVertex_const_iterator SVertex_const_iterator;
typedef typename SM_const_decorator::SHalfedge_const_iterator SHalfedge_const_iterator;
typedef typename SM_const_decorator::SFace_const_iterator SFace_const_iterator;
// typedef typename Base::Constructor_parameter Constructor_parameter;
typedef typename Base::SVertex_handle SVertex_handle;
typedef typename Base::SHalfedge_handle SHalfedge_handle;
typedef typename Base::SHalfloop_handle SHalfloop_handle;
typedef typename Base::SFace_handle SFace_handle;
typedef typename Base::SVertex_iterator SVertex_iterator;
typedef typename Base::SHalfedge_iterator SHalfedge_iterator;
typedef typename Base::SFace_iterator SFace_iterator;
typedef typename Base::Object_handle Object_handle;
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
typedef typename Base::SHalfedge_around_svertex_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_svertex_circulator;
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
typedef typename Base::SHalfedge_around_sface_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_sface_circulator;
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
typedef typename Base::SFace_cycle_iterator
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
SFace_cycle_iterator;
typedef std::pair<SHalfedge_handle,SHalfedge_handle> SHalfedge_pair;
/*{\Mtypes 3}*/
typedef typename Base::Sphere_kernel Sphere_kernel;
/*{\Mtypemember the geometry kernel.}*/
typedef typename Sphere_kernel::Sphere_point Sphere_point;
/*{\Mtypemember the point type of the sphere geometry.}*/
typedef typename Sphere_kernel::Sphere_segment Sphere_segment;
/*{\Mtypemember the segment type of the sphere geometry.}*/
typedef typename Sphere_kernel::Sphere_circle Sphere_circle;
/*{\Mtypemember the circle type of the sphere geometry.}*/
typedef typename Base::Mark Mark;
/*{\Mtypemember the mark of sphere map objects.}*/
typedef typename Base::GenPtr GenPtr;
using Base::info;
using Base::set_first_out_edge;
using Base::first_out_edge;
using Base::last_out_edge;
using Base::out_edges;
using Base::link_as_loop;
using Base::link_as_face_cycle;
using Base::link_as_prev_next_pair;
using Base::link_as_isolated_vertex;
using Base::is_isolated;
using Base::set_source;
using Base::set_face;
using Base::delete_vertex_only;
using Base::delete_face_only;
using Base::delete_edge_pair;
using Base::delete_edge_pair_only;
using Base::is_sm_boundary_object;
using Base::undo_sm_boundary_object;
using Base::store_sm_boundary_object;
using Base::clear_face_cycle_entries;
using Base::is_closed_at_source;
using Base::has_outdeg_two;
using Base::convert_edge_to_loop;
using Base::merge_edge_pairs_at_target;
/*{\Mgeneralization SM_decorator}*/
protected:
SM_const_decorator PI[2];
const Sphere_kernel& K;
public:
// ---------------------------------------------------------------
struct Seg_info { // to transport information from input to output
Object_handle _o; int _from;
Seg_info() : _o(), _from(-1) {}
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
Seg_info(SVertex_const_handle v, int i)
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
{ _o=make_object(v); _from=i; }
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
Seg_info(SHalfedge_const_handle e, int i)
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
{ _o=make_object(e); _from=i; }
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
Seg_info(SHalfloop_const_handle l, int i)
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
{ _o=make_object(l); _from=i; }
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
Seg_info(const Seg_info& si)
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
{ _o=si._o; _from=si._from; }
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
Seg_info& operator=(const Seg_info& si)
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
{ _o=si._o; _from=si._from; return *this; }
LEDA_MEMORY(Seg_info)
}; // Seg_info
typedef std::list<Sphere_segment> Seg_list;
typedef typename Seg_list::iterator Seg_iterator;
typedef std::pair<Seg_iterator,Seg_iterator> Seg_it_pair;
typedef std::pair<Sphere_segment,Sphere_segment> Seg_pair;
typedef CGAL::Unique_hash_map<Seg_iterator,Seg_info> Seg_map;
// ---------------------------------------------------------------
struct vertex_info {
Mark m[2];
Object_handle o_supp[2];
SHalfedge_handle e_below;
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
vertex_info()
{
m[0]=m[1]=Mark();
o_supp[0]=o_supp[1]=Object_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
LEDA_MEMORY(vertex_info)
}; // vertex_info
void assoc_info(SVertex_handle v) const
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 CGAL_I_DO_WANT_TO_USE_GENINFO
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
geninfo<vertex_info>::create(info(v));
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
info(v)=vertex_info();
#endif
}
void discard_info(SVertex_handle v) const
{
#ifdef CGAL_I_DO_WANT_TO_USE_GENINFO
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
geninfo<vertex_info>::clear(info(v));
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
info(v)=boost::any();
#endif
}
vertex_info& ginfo(SVertex_handle v) const
{
#ifdef CGAL_I_DO_WANT_TO_USE_GENINFO
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
return geninfo<vertex_info>::access(info(v));
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
return
*boost::any_cast<vertex_info>(&info(v));
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
}
Mark& mark(SVertex_handle v, int i) const
{ return ginfo(v).m[i]; }
Object_handle& supp_object(SVertex_handle v, int i) const
{ return ginfo(v).o_supp[i]; }
SHalfedge_handle& halfedge_below(SVertex_handle v) const
{ return ginfo(v).e_below; }
// ---------------------------------------------------------------
struct edge_info {
Mark m[2];
Mark mf[2];
Object_handle o_supp[2];
bool forw;
edge_info()
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
{ m[0]=m[1]=mf[0]=mf[1]=Mark();
o_supp[0]=o_supp[1]=Object_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
forw=false; }
LEDA_MEMORY(edge_info)
};
void assoc_info(SHalfedge_handle e) const
{
#ifdef CGAL_I_DO_WANT_TO_USE_GENINFO
geninfo<edge_info>::create(info(e));
geninfo<edge_info>::create(info(e->twin()));
#else
info(e)=edge_info();
info(e->twin())=edge_info();
#endif
}
void discard_info(SHalfedge_handle e) const
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 CGAL_I_DO_WANT_TO_USE_GENINFO
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
geninfo<edge_info>::clear(info(e));
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
geninfo<edge_info>::clear(info(e->twin()));
#else
info(e)=boost::any();
info(e->twin())=boost::any();
#endif
}
edge_info& ginfo(SHalfedge_handle e) const
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 CGAL_I_DO_WANT_TO_USE_GENINFO
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
return geninfo<edge_info>::access(info(e));
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
return
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
*boost::any_cast<edge_info>(&info(e));
#endif
}
Mark& mark(SHalfedge_handle e, int i) const
{ return ginfo(e).m[i]; }
Object_handle& supp_object(SHalfedge_handle e, int i) const
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
// uedge information we store in the smaller one
{ if (&*e < &*(e->twin())) return ginfo(e).o_supp[i];
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 return ginfo(e->twin()).o_supp[i]; }
Mark& incident_mark(SHalfedge_handle e, int i) const
// biedge information we store in the edge
{ return ginfo(e).mf[i]; }
bool& is_forward(SHalfedge_handle e) const
// biedge information we store in the edge
{ return ginfo(e).forw; }
// ---------------------------------------------------------------
struct face_info {
Mark m[2];
face_info() { m[0]=m[1]=Mark(); }
LEDA_MEMORY(face_info)
};
void assoc_info(SFace_handle f) const
{
#ifdef CGAL_I_DO_WANT_TO_USE_GENINFO
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
geninfo<face_info>::create(info(f));
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
info(f)=face_info();
#endif
}
void discard_info(SFace_handle f) const
{
#ifdef CGAL_I_DO_WANT_TO_USE_GENINFO
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
geninfo<face_info>::clear(info(f));
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
info(f)=boost::any();
#endif
}
face_info& ginfo(SFace_handle f) const
{
#ifdef CGAL_I_DO_WANT_TO_USE_GENINFO
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
return geninfo<face_info>::access(info(f));
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
return
*boost::any_cast<face_info>(&info(f));
#endif
}
Mark& mark(SFace_handle f, int i) const
{ return ginfo(f).m[i]; }
// ---------------------------------------------------------------
template <typename Below_accessor>
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
SFace_handle determine_face(SHalfedge_handle e,
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 std::vector<SHalfedge_handle>& MinimalSHalfedge,
const CGAL::Unique_hash_map<SHalfedge_handle,int>& SFaceCycle,
const Below_accessor& D)
{ CGAL_NEF_TRACEN("determine_face "<<PH(e));
int fc = SFaceCycle[e];
SHalfedge_handle e_min = MinimalSHalfedge[fc];
SHalfedge_handle e_below = D.halfedge_below(e_min->target());
if(e_below == SHalfedge_handle())
return SFace_handle();
SFace_handle f = e_below->incident_sface();
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
if ( f != SFace_handle() ) return f; // has already a face
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
// e_below also has no face
f = determine_face(e_below, MinimalSHalfedge, SFaceCycle,D);
if(f != SFace_handle())
link_as_face_cycle(e_below,f);
return f;
}
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
Sphere_segment segment(SM_const_decorator ,
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_const_handle e) const
{ return K.construct_segment(e->source()->point(),
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
e->target()->point(),
e->circle()); }
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
Sphere_segment trivial_segment(SM_const_decorator ,
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
SVertex_const_handle v) const
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
{ Sphere_point p = v->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
return K.construct_segment(p,p); }
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
Seg_pair two_segments(SM_const_decorator ,
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_const_handle e) const
// we know that e->source()==e->target()
{ return e->circle().split_at(e->source()->point()); }
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
Seg_pair two_segments(SM_const_decorator ,
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
SHalfloop_const_handle l) const
{ return l->circle().split_at_xy_plane(); }
// ---------------------------------------------------------------
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
// INTERFACE INTERFACE INTERFACE INTERFACE INTERFACE INTERFACE
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
// ---------------------------------------------------------------
/*{\Mcreation 6}*/
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
SM_overlayer(Map* M,
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 Sphere_kernel& G = Sphere_kernel()) : Base(M), K(G) {}
/*{\Mcreate |\Mvar| is a decorator object manipulating the map
of |v|.}*/
/*{\Moperations 1.1 1}*/
template <typename Forward_iterator>
void create_from_segments(
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
Forward_iterator start, Forward_iterator end);
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
/*{\Mop produces the sphere map which is the overlay of the
segments from the iterator range |[start,end)|. \precond
|Forward_iterator| has value type |Sphere_segment|.}*/
template <typename Forward_iterator>
void create_from_circles(Forward_iterator start, Forward_iterator end);
/*{\Mop produces the sphere map which is the overlay of the
circles from the iterator range |[start,end)|. \precond
|Forward_iterator| has value type |Sphere_circle|.}*/
void create(const Sphere_circle& c);
/*{\Mop produces the sphere map which consists of one loop
and the two halfspheres incident to it.}*/
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
void subdivide(const Map* M0, const Map* M1,
bool with_trivial_segments = 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
template <typename Association>
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
void subdivide(const Map* M0, const Map* M1,
Association& A,
bool with_trivial_segments = 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
/*{\Mop constructs the overlay of the sphere maps |M0| and |M1| in
|M|, where all objects (vertices, halfedges, faces) of |M| are
\emph{enriched} by the marks of the supporting objects of the two
input structures: e.g. let |v| be a vertex supported by a node |v0| in
|M0| and by a face |f1| in |M1| and |D0|, |D1| be decorators of
type |SM_decorator| on |M0|,|M1|. Then |\Mvar.mark(v,0) = D0.v0->mark()|
and |\Mvar.mark(v,1) = D1.f1->mark()|.}*/
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
template <typename Selection>
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
void select(const Selection& SP) const;
/*{\Mop sets the marks of all objects according to the selection
predicate |SP|. |Selection| has to be a function object type with a
function operator\\
[[Mark operator()(Mark m0, Mark m1) const]]\\
For each object |u| of |M| enriched by the marks of the supporting
objects according to the previous procedure |subdivide|, after this
operation |\Mvar.u->mark() = SP ( \Mvar.mark(u,0),\Mvar.mark(u,1)
)|. The additional marks are invalidated afterwards.
\precond subdivide() was called before.}*/
void simplify();
/*{\Mop simplifies the structure of |M| according to the marks of
its objects. An edge |e| separating two faces |f1| and |f2| and equal
marks |e->mark() == f1->mark() == f2->mark()| is removed and the faces are
unified. An isolated vertex |v| in a face |f| with |v->mark()==f->mark()|
is removed. A vertex |v| with outdegree two, two collinear out-edges
|e1|,|e2| and equal marks |v->mark() == e1->mark() == e2->mark()| is removed
and the edges are unified.}*/
int check_sphere(const Seg_list& L, bool compute_halfsphere[3][2]) const;
template <typename Iterator>
void subdivide_segments(Iterator start, Iterator end) const;
template <typename Iterator, typename T>
void partition_to_halfsphere(Iterator start, Iterator end,
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
Seg_list& L, CGAL::Unique_hash_map<Iterator,T>& M,
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
Sphere_circle xycircle, Sphere_circle yzcircle, bool include_equator) const;
template <typename Mark_accessor>
void merge_halfsphere_maps(SVertex_handle v1, SVertex_handle v2,
const Mark_accessor& D);
template <typename Mark_accessor>
void merge_nodes(SHalfedge_handle e1, SHalfedge_handle e2,
const Mark_accessor& D);
template <typename Below_accessor, typename Halfsphere_geometry>
void create_face_objects(SHalfedge_iterator e_start, SHalfedge_iterator e_end,
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
SVertex_iterator v_start, SVertex_iterator v_end,
const Below_accessor& D,
const Halfsphere_geometry& SG);
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 <typename Below_accessor>
void complete_face_support(SVertex_iterator v_start, SVertex_iterator v_end,
const Below_accessor& D, std::vector<Mark>& mohs, int offset, bool both=true) const;
void complete_sface_marks() const;
void set_outer_face_mark(int offset, const std::vector<Mark>& mohs);
template <typename Association>
void transfer_data(Association& A);
void dump(std::ostream& os = std::cerr) const
{ SM_io_parser<Base>::dump(*this,os); }
}; // SM_overlayer<SM_decorator>
template <typename Map>
template <typename Forward_iterator>
void SM_overlayer<Map>::
create_from_segments(Forward_iterator start, Forward_iterator end)
{
CGAL_NEF_TRACEN("creating from segment iterator range");
Seg_list L(start,end);
Unique_hash_map<Seg_iterator,bool> From_input(false);
Seg_iterator it;
CGAL_forall_iterators(it,L) From_input[it]=true;
Seg_list L_pos,L_neg;
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
partition_to_halfsphere(L.begin(), L.end(), L_pos, From_input,
Sphere_circle(0,0,1), Sphere_circle(1,0,0), true);
partition_to_halfsphere(L.begin(), L.end(), L_neg, From_input,
Sphere_circle(0,0,-1), Sphere_circle(1,0,0), 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
typedef SMO_from_segs<Self,Seg_iterator> SM_output;
typedef typename Sphere_kernel::Positive_halfsphere_geometry PH_geometry;
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
typedef CGAL::Segment_overlay_traits<
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
Seg_iterator, SM_output, PH_geometry> PHS_traits;
typedef CGAL::generic_sweep<PHS_traits> Positive_halfsphere_sweep;
typedef typename Sphere_kernel::Negative_halfsphere_geometry NH_geometry;
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
typedef CGAL::Segment_overlay_traits<
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
Seg_iterator, SM_output, NH_geometry> NHS_traits;
typedef CGAL::generic_sweep<NHS_traits> Negative_halfsphere_sweep;
SVertex_iterator v;
SHalfedge_iterator e;
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
SM_output O(*this,From_input);
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 PHS_traits::INPUT Input_range;
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
PH_geometry ph_g;
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
Positive_halfsphere_sweep SP(
Input_range(L_pos.begin(),L_pos.end()),O,
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
ph_g);
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
SP.sweep();
//CGAL_NEF_TRACEN("POS SWEEP\n"<<(dump(std::cerr),""));
v=--this->svertices_end(); e=--this->shalfedges_end();
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
NH_geometry nh_g;
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
Negative_halfsphere_sweep SM(
Input_range(L_neg.begin(),L_neg.end()),O,
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
nh_g);
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
SM.sweep();
//CGAL_NEF_TRACEN("NEG SWEEP\n"<<(dump(std::cerr),""));
++v; ++e;
// now two CCs of sphere graph are calculated
// v = first vertex of CC in negative x-sphere
// e = first edge of CC in negative x-sphere
create_face_objects(this->shalfedges_begin(), e, this->svertices_begin(), v, O,
PH_geometry());
create_face_objects(e, this->shalfedges_end(), v, this->svertices_end(), O,
NH_geometry());
SHalfedge_iterator u;
CGAL_forall_sedges(u,*this) {
Sphere_segment s(u->source()->point(),u->target()->point());
u->circle() = s.sphere_circle();
u->twin()->circle() = s.sphere_circle().opposite();
}
merge_halfsphere_maps(this->svertices_begin(),v,O);
this->check_integrity_and_topological_planarity();
O.clear_temporary_vertex_info();
}
template <typename Map>
template <typename Forward_iterator>
void SM_overlayer<Map>::
create_from_circles(Forward_iterator start, Forward_iterator end)
{
CGAL_NEF_TRACEN("creating from circle iterator range");
Seg_list L;
Unique_hash_map<Seg_iterator,bool> From_input(false);
for ( ; start != end; ++start ) {
std::pair<Sphere_segment,Sphere_segment> spair =
start->split_at_xy_plane();
L.push_back(spair.first); L.push_back(spair.second);
}
Seg_iterator it;
CGAL_forall_iterators(it,L) From_input[it]=true;
Seg_list L_pos,L_neg;
partition_to_halfsphere(L.begin(), L.end(), L_pos, From_input,
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
Sphere_circle(0,0,1), Sphere_circle(1,0,0), 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
partition_to_halfsphere(L.begin(), L.end(), L_neg, From_input,
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
Sphere_circle(0,0,-1), Sphere_circle(1,0,0), 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
typedef SMO_from_segs<Self,Seg_iterator> SM_output;
typedef typename Sphere_kernel::Positive_halfsphere_geometry PH_geometry;
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
typedef CGAL::Segment_overlay_traits<
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
Seg_iterator, SM_output, PH_geometry> PHS_traits;
typedef CGAL::generic_sweep<PHS_traits> Positive_halfsphere_sweep;
typedef typename Sphere_kernel::Negative_halfsphere_geometry NH_geometry;
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
typedef CGAL::Segment_overlay_traits<
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
Seg_iterator, SM_output, NH_geometry> NHS_traits;
typedef CGAL::generic_sweep<NHS_traits> Negative_halfsphere_sweep;
SVertex_iterator v;
SHalfedge_iterator e;
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
SM_output O(*this,From_input);
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 PHS_traits::INPUT Input_range;
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
PH_geometry ph_g;
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
Positive_halfsphere_sweep SP(
Input_range(L_pos.begin(),L_pos.end()),O,
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
ph_g);
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
SP.sweep();
//CGAL_NEF_TRACEN("POS SWEEP\n"<<(dump(std::cerr),""));
v=--this->svertices_end(); e=--this->shalfedges_end();
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
NH_geometry nh_geom;
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
Negative_halfsphere_sweep SM(
Input_range(L_neg.begin(),L_neg.end()), O,
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
nh_geom);
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
SM.sweep();
//CGAL_NEF_TRACEN("NEG SWEEP\n"<<(dump(std::cerr),""));
++v; ++e;
// now two CCs of sphere graph are calculated
// v = first vertex of CC in negative x-sphere
// e = first edge of CC in negative x-sphere
create_face_objects(this->shalfedges_begin(), e, this->svertices_begin(), v, O,
PH_geometry());
create_face_objects(e, this->shalfedges_end(), v, this->svertices_end(), O,
NH_geometry());
SHalfedge_iterator u;
CGAL_forall_sedges(u,*this) {
Sphere_segment s(u->source()->point(),u->target()->point());
u->circle() = s.sphere_circle();
u->twin()->circle() = s.sphere_circle().opposite();
}
merge_halfsphere_maps(this->svertices_begin(),v,O);
this->check_integrity_and_topological_planarity();
O.clear_temporary_vertex_info();
}
#ifdef CGAL_NEF_NEW_CHECK_SPHERE
template <typename Map>
int SM_overlayer<Map>::
check_sphere(const Seg_list& L, bool compute_halfsphere[3][2]) const {
int chsp = 0;
CGAL_NEF_TRACEN("chsp " << chsp);
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 Seg_list::const_iterator it;
CGAL_forall_iterators(it,L) {
CGAL_NEF_TRACEN("source " << it->source());
CGAL_NEF_TRACEN("target " << it->target());
if((chsp&1)!=1)
if(it->source().hx()>0 || it->target().hx()>0)
chsp|=1;
if((chsp&2)!=2)
if(it->source().hx()<0 || it->target().hx()<0)
chsp|=2;
if((chsp&4)!=4)
if(it->source().hy()>0 || it->target().hy()>0)
chsp|=4;
if((chsp&8)!=8)
if(it->source().hy()<0 || it->target().hy()<0)
chsp|=8;
if((chsp&16)!=16)
if(it->source().hz()>0 || it->target().hz()>0)
chsp|=16;
if((chsp&32)!=32)
if(it->source().hz()<0 || it->target().hz()<0)
chsp|=32;
CGAL_NEF_TRACEN("chsp " << chsp);
if(chsp == 63)
break;
}
CGAL_forall_iterators(it,L) {
CGAL_NEF_TRACEN("chsp " << chsp);
if(chsp == 63)
break;
// int l = it->compare_length_to_halfcircle();
CGAL_NEF_TRACEN("source " << it->source());
CGAL_NEF_TRACEN("target " << it->target());
CGAL_NEF_TRACEN("cicle " << it->sphere_circle());
CGAL_NEF_TRACEN("is long " << it->is_long());
if(it->is_short()) continue;
CGAL_NEF_TRACEN("not short");
CGAL_NEF_TRACEN("circle " << it->sphere_circle());
if(it->is_long()) {
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
if((chsp&60)!=60 &&
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
it->sphere_circle().orthogonal_vector().x()!=0) chsp|=60;
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
if((chsp&51)!=51 &&
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
it->sphere_circle().orthogonal_vector().y()!=0) chsp|=51;
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
if((chsp&15)!=15 &&
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
it->sphere_circle().orthogonal_vector().z()!=0) chsp|=15;
} else {
int n = 0;
if(it->source().hx()==0) ++n;
if(it->source().hy()==0) ++n;
if(it->source().hz()==0) ++n;
CGAL_assertion(n<3);
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
CGAL_NEF_TRACEN("n " << n);
CGAL_NEF_TRACEN("number of coordinats =0:" << n);
if(n==0) {
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
if((chsp&60)!=60 &&
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
it->sphere_circle().orthogonal_vector().x()!=0) chsp|=60;
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
if((chsp&51)!=51 &&
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
it->sphere_circle().orthogonal_vector().y()!=0) chsp|=51;
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
if((chsp&15)!=15 &&
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
it->sphere_circle().orthogonal_vector().z()!=0) chsp|=15;
} else if(n==1) {
if((chsp&48)!=48 && it->source().z()==0) {
Sphere_point i = intersection(it->sphere_circle(), Sphere_circle(1,0,0));
CGAL_NEF_TRACEN("intersection " << i);
if(!it->has_on_after_intersection(i)) i=i.antipode();
if(i.z() > 0) chsp|=16;
else if(i.z() < 0) chsp|=32;
} else if((chsp&3)!=3 && it->source().x()==0) {
Sphere_point i = intersection(it->sphere_circle(), Sphere_circle(0,1,0));
CGAL_NEF_TRACEN("intersection " << i);
if(!it->has_on_after_intersection(i)) i=i.antipode();
if(i.x() > 0) chsp|=1;
else if(i.x() < 0) chsp|=2;
} else if((chsp&12)!=12) {
Sphere_point i = intersection(it->sphere_circle(), Sphere_circle(1,0,0));
CGAL_NEF_TRACEN("intersection " << i);
if(!it->has_on_after_intersection(i)) i=i.antipode();
if(i.y() > 0) chsp|=4;
else if(i.y() < 0) chsp|=8;
}
} else { // n==2
if((chsp&60)!=60 && it->source().x()!=0) {
Sphere_point i = intersection(it->sphere_circle(), Sphere_circle(1,0,0));
CGAL_NEF_TRACEN("intersection " << i);
if(!it->has_on_after_intersection(i)) i=i.antipode();
if((chsp&12)!=12)
if(i.y() > 0) chsp|=4;
else if(i.y() < 0) chsp|=8;
if((chsp&48)!=48)
if(i.z() > 0) chsp|=16;
else if(i.z() < 0) chsp|=32;
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
} else if((chsp&51)!=51 && it->source().y()!=0) {
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
Sphere_point i = intersection(it->sphere_circle(), Sphere_circle(0,1,0));
CGAL_NEF_TRACEN("intersection " << i);
if(!it->has_on_after_intersection(i)) i=i.antipode();
if((chsp&3)!=3)
if(i.x() > 0) chsp|=1;
else if(i.x() < 0) chsp|=2;
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
if((chsp&48)!=48)
if(i.z() > 0) chsp|=16;
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(i.z() < 0) chsp|=32;
} else if((chsp&15)!=15 && it->source().z()!=0) {
Sphere_point i = intersection(it->sphere_circle(), Sphere_circle(0,0,1));
CGAL_NEF_TRACEN("intersection " << i);
if(!it->has_on_after_intersection(i)) i=i.antipode();
if((chsp&3)!=3)
if(i.x() > 0) chsp|=1;
else if(i.x() < 0) chsp|=2;
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
if((chsp&12)!=12)
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(i.y() > 0) chsp|=4;
else if(i.y() < 0) chsp|=8;
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
}
}
}
CGAL_NEF_TRACEN("chsp " << chsp);
compute_halfsphere[0][0] = (chsp&1)==1;
compute_halfsphere[0][1] = (chsp&2)==2;
compute_halfsphere[1][0] = (chsp&4)==4;
compute_halfsphere[1][1] = (chsp&8)==8;
compute_halfsphere[2][0] = (chsp&16)==16;
compute_halfsphere[2][1] = (chsp&32)==32;
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
if((chsp&1)==0) {
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
compute_halfsphere[0][1]=true;
return 0;
}
if((chsp&2)==0) {
compute_halfsphere[0][0]=true;
return 1;
}
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
if((chsp&4)==0) {
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
compute_halfsphere[1][1]=true;
return 2;
}
if((chsp&8)==0) {
compute_halfsphere[1][0]=true;
return 3;
}
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
if((chsp&16)==0) {
compute_halfsphere[2][1]=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
return 4;
}
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
if((chsp&32)==0) {
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
compute_halfsphere[2][0]=true;
return 5;
}
return -1;
}
#else
template <typename Map>
int SM_overlayer<Map>::
check_sphere(const Seg_list& L, bool compute_halfsphere[3][2]) const {
for(int i=0; i<6; i++)
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
compute_halfsphere[i/2][i%2] = 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
CGAL_NEF_TRACEN("compute_halfsphere (at begin)");
for(int i=0; i<6; ++i)
CGAL_NEF_TRACEN(" " << i << " : " << compute_halfsphere[i/2][i%2]);
typename Seg_list::const_iterator it;
CGAL_forall_iterators(it,L) {
if(!compute_halfsphere[0][0])
if(it->source().hx()>0 || it->target().hx()>0)
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
compute_halfsphere[0][0] = 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
if(!compute_halfsphere[0][1])
if(it->source().hx()<0 || it->target().hx()<0)
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
compute_halfsphere[0][1] = 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
if(!compute_halfsphere[1][0])
if(it->source().hy()>0 || it->target().hy()>0)
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
compute_halfsphere[1][0] = 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
if(!compute_halfsphere[1][1])
if(it->source().hy()<0 || it->target().hy()<0)
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
compute_halfsphere[1][1] = 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
if(!compute_halfsphere[2][0])
if(it->source().hz()>0 || it->target().hz()>0)
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
compute_halfsphere[2][0] = 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
if(!compute_halfsphere[2][1])
if(it->source().hz()<0 || it->target().hz()<0)
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
compute_halfsphere[2][1] = 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
}
CGAL_NEF_TRACEN("compute_halfsphere (after vertices)");
for(int i=0; i<6; ++i)
CGAL_NEF_TRACEN(" " << i << " : " << compute_halfsphere[i/2][i%2]);
if(!compute_halfsphere[2][0]) {
CGAL_forall_iterators(it,L) {
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
if((it->source().hz()==0 && it->target().hz()==0)
|| it->is_long()) {
compute_halfsphere[2][0] = true;
break;
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
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(!compute_halfsphere[2][0]) {
compute_halfsphere[2][1] = true;
return 4;
}
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(!compute_halfsphere[2][1]) {
CGAL_forall_iterators(it,L) {
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
if(it->is_long() || (it->source().hz()==0 && it->target().hz()==0)) {
compute_halfsphere[2][1] = true;
break;
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(!compute_halfsphere[2][1])
return 5;
if(!compute_halfsphere[0][0]) {
CGAL_forall_iterators(it,L) {
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
if((it->source().hx()==0 && it->target().hx()==0) || it->is_long()) {
compute_halfsphere[0][0] = true;
break;
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(!compute_halfsphere[0][0]) {
compute_halfsphere[0][1] = true;
return 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(!compute_halfsphere[0][1]) {
CGAL_forall_iterators(it,L) {
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
if((it->source().hx()==0 && it->target().hx()==0) || it->is_long()) {
compute_halfsphere[0][1] = true;
break;
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(!compute_halfsphere[0][1])
return 1;
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(!compute_halfsphere[1][0]) {
CGAL_forall_iterators(it,L) {
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
if((it->source().hy()==0 && it->target().hy()==0) || it->is_long()) {
compute_halfsphere[1][0] = true;
break;
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
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(!compute_halfsphere[1][0]) {
compute_halfsphere[1][1] = true;
return 2;
}
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(!compute_halfsphere[1][1]) {
CGAL_forall_iterators(it,L) {
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
if((it->source().hy()==0 && it->target().hy()==0) || it->is_long()) {
compute_halfsphere[1][1] = true;
break;
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(!compute_halfsphere[1][1])
return 3;
return -1;
}
#endif
template <typename Map>
void SM_overlayer<Map>::
create(const Sphere_circle& c)
{ SHalfloop_handle l1 = this->new_shalfloop_pair();
SHalfloop_handle l2 = l1->twin();
l1->circle() = c; l2->circle() = c.opposite();
SFace_handle f1 = this->new_sface();
SFace_handle f2 = this->new_sface();
link_as_loop(l1,f1);
link_as_loop(l2,f2);
}
template <typename Map>
void SM_overlayer<Map>::
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
subdivide(const Map* M0, const Map* M1,
bool with_trivial_segments) {
PI[0] = SM_const_decorator(M0);
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
PI[1] = SM_const_decorator(M1);
bool compute_halfsphere[3][2];
int cs=0;
Seg_list L;
Seg_map From;
for (int i=0; i<2; ++i) {
SVertex_const_iterator v;
CGAL_forall_svertices(v,PI[i]) {
CGAL_NEF_TRACEN(v->point() << " from " << i << " mark " << v->mark());
if ( !PI[i].is_isolated(v) ) continue;
cs = -1;
L.push_back(trivial_segment(PI[i],v));
From[--L.end()] = Seg_info(v,i);
}
SHalfedge_const_iterator e;
CGAL_forall_sedges(e,PI[i]) {
if ( e->source() == e->target() ) {
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
if(with_trivial_segments) {
CGAL_NEF_TRACEN("trivial segment " << e->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
v = e->source();
L.push_back(trivial_segment(PI[i],v));
From[--L.end()] = Seg_info(v,i);
} else {
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
CGAL_NEF_TRACEN("once around " << e->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
Seg_pair p = two_segments(PI[i],e);
L.push_back(p.first);
L.push_back(p.second);
From[--L.end()] = From[--(--L.end())] = Seg_info(e,i);
}
} else {
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
CGAL_NEF_TRACEN("normal segment " << e->source()->point()
<< "->" << e->twin()->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
L.push_back(segment(PI[i],e));
From[--L.end()] = Seg_info(e,i);
}
}
if ( PI[i].has_shalfloop() ) {
CGAL_NEF_TRACEN("loop ");
SHalfloop_const_handle shl = PI[i].shalfloop();
Seg_pair p = two_segments(PI[i],shl);
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
L.push_back(p.first);
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
L.push_back(p.second.opposite());
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
From[--L.end()] = From[--(--L.end())] =
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
Seg_info(shl,i);
}
}
CGAL_assertion_code(typename Seg_list::iterator it);
CGAL_assertion_code(CGAL_forall_iterators(it,L) CGAL_NEF_TRACEN(" "<<*it));
#ifdef CGAL_NEF3_SPHERE_SWEEP_OPTIMIZATION_OFF
cs = -1;
compute_halfsphere[2][0]=true;
compute_halfsphere[2][1]=true;
#else
if(cs != -1)
cs = check_sphere(L, compute_halfsphere);
#endif
CGAL_NEF_TRACEN("compute_halfsphere\n cs = " << cs);
for(int i=0; i<6; ++i)
CGAL_NEF_TRACEN(" " << i << " : " << compute_halfsphere[i/2][i%2]);
Seg_list L_pos,L_neg;
switch(cs) {
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
case 1:
partition_to_halfsphere(L.begin(), L.end(), L_pos, From,
Sphere_circle(1,0,0), Sphere_circle(0,0,-1),
compute_halfsphere[0][1]);
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
break;
case 0:
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
partition_to_halfsphere(L.begin(), L.end(), L_neg, From,
Sphere_circle(-1,0,0), Sphere_circle(0,0,-1),
compute_halfsphere[0][0]);
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
break;
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
case 3:
partition_to_halfsphere(L.begin(), L.end(), L_pos, From,
Sphere_circle(0,1,0), Sphere_circle(1,0,0),
compute_halfsphere[1][1]);
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
break;
case 2:
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
partition_to_halfsphere(L.begin(), L.end(), L_neg, From,
Sphere_circle(0,-1,0), Sphere_circle(1,0,0),
compute_halfsphere[1][0]);
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
break;
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
case 5:
partition_to_halfsphere(L.begin(), L.end(), L_pos, From,
Sphere_circle(0,0,1), Sphere_circle(1,0,0),
compute_halfsphere[2][1]);
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
break;
case 4:
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
partition_to_halfsphere(L.begin(), L.end(), L_neg, From,
Sphere_circle(0,0,-1), Sphere_circle(1,0,0),
compute_halfsphere[2][0]);
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
break;
case -1:
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
partition_to_halfsphere(L.begin(), L.end(), L_pos, From,
Sphere_circle(0,0,1), Sphere_circle(1,0,0), true);
partition_to_halfsphere(L.begin(), L.end(), L_neg, From,
Sphere_circle(0,0,-1), Sphere_circle(1,0,0), 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
break;
default: CGAL_error_msg( "wrong value");
}
cs = cs==-1 ? 2 : cs/2;
#ifdef CGAL_NEF3_TIMER_SPHERE_SWEEPS
timer_sphere_sweeps.start();
#endif
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 SMO_from_sm<Self,Seg_iterator,Seg_info> SM_output;
typedef typename Sphere_kernel::Positive_halfsphere_geometry PH_geometry;
typedef typename Sphere_kernel::Negative_halfsphere_geometry NH_geometry;
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
typedef CGAL::Segment_overlay_traits<
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
Seg_iterator, SM_output, PH_geometry> PHS_traits;
typedef CGAL::generic_sweep<PHS_traits> Positive_halfsphere_sweep;
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
typedef CGAL::Segment_overlay_traits<
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
Seg_iterator, SM_output, NH_geometry> NHS_traits;
typedef CGAL::generic_sweep<NHS_traits> Negative_halfsphere_sweep;
typedef typename PHS_traits::INPUT Input_range;
SVertex_handle v;
SHalfedge_handle e;
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
SM_output O(*this,PI,From);
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(compute_halfsphere[cs][0]) {
PH_geometry phg(cs);
Positive_halfsphere_sweep SP(
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
Input_range(L_pos.begin(),L_pos.end()),O,phg);
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
SP.sweep();
v=--this->svertices_end(); e=--this->shalfedges_end();
#ifdef CGAL_NEF3_TIMER_SPHERE_SWEEPS
number_of_sphere_sweeps++;
#endif
}
if(compute_halfsphere[cs][1]) {
NH_geometry nhg(cs);
Negative_halfsphere_sweep SM(
Input_range(L_neg.begin(),L_neg.end()),O,
nhg);
SM.sweep();
#ifdef CGAL_NEF3_TIMER_SPHERE_SWEEPS
number_of_sphere_sweeps++;
#endif
}
#ifdef CGAL_NEF3_TIMER_SPHERE_SWEEPS
timer_sphere_sweeps.stop();
#endif
if(compute_halfsphere[cs][0]) {
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
++v;
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
++e;
}
else {
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
v = this->svertices_begin();
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
e = this->shalfedges_begin();
}
if(compute_halfsphere[cs][0])
create_face_objects(this->shalfedges_begin(), e, this->svertices_begin(), v, O,
PH_geometry(cs));
if(compute_halfsphere[cs][1])
create_face_objects(e, this->shalfedges_end(), v, this->svertices_end(), O,
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
NH_geometry(cs));
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_forall_sedges(e,*this) {
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
e->circle() = Sphere_circle(e->source()->point(), e->twin()->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
e->twin()->circle() = e->circle().opposite();
CGAL_NEF_TRACEN(PH(e) << " with circle " << e->circle());
}
std::vector<Mark> mohs(4);
SM_point_locator L0(M0);
SM_point_locator L1(M1);
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
L0.marks_of_halfspheres(mohs, 0, cs);
L1.marks_of_halfspheres(mohs, 2, cs);
CGAL_NEF_TRACEN("mohs[0]=" << mohs[0]);
CGAL_NEF_TRACEN("mohs[1]=" << mohs[1]);
CGAL_NEF_TRACEN("mohs[2]=" << mohs[2]);
CGAL_NEF_TRACEN("mohs[3]=" << mohs[3]);
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
CGAL_NEF_TRACEN("compute_halfsphrere\n cs = " << cs <<
"\n [cs][0] = " << compute_halfsphere[cs][0] <<
"\n [cs][1] = " << compute_halfsphere[cs][1]);
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
/*
SVertex_iterator svii;
CGAL_forall_svertices(svii, *this) {
SVertex_const_handle vs;
SHalfedge_const_handle es;
if(CGAL::assign(vs, supp_object(svii,0)))
std::cerr << svii->point() << " supported by svertex " << vs->point() << std::endl;
else if(CGAL::assign(es, supp_object(svii,0)))
std::cerr << svii->point() << " supported by sedge" << std::endl;
else
std::cerr << svii->point() << " is neither supported by svertex or sedge" << std::endl;
if(CGAL::assign(vs, supp_object(svii,1)))
std::cerr << svii->point() << " supported by svertex " << vs->point() << std::endl;
else if(CGAL::assign(es, supp_object(svii,1)))
std::cerr << svii->point() << " supported by sedge" << std::endl;
else
std::cerr << svii->point() << " is neither supported by svertex or sedge" << std::endl;
}
*/
if(compute_halfsphere[cs][0])
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
complete_face_support(this->svertices_begin(), v, O, mohs, 0,
compute_halfsphere[cs][1]);
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(compute_halfsphere[cs][1])
complete_face_support(v, this->svertices_end(), O, mohs, 1,
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
compute_halfsphere[cs][0]);
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
complete_sface_marks();
// DEBUG CODE: to do: have all svertices a halfedge below associated?
CGAL_NEF_TRACEN("Vertex info after swep");
CGAL_assertion_code(SVertex_iterator svi);
#ifdef CGAL_I_DO_WANT_TO_USE_GENINFO
CGAL_assertion_code(
for(svi=this->svertices_begin(); svi!=this->svertices_end(); svi++) {
CGAL_NEF_TRACEN("vertex "<<svi->point()<<" info "<< info(svi)<< " marks "<<mark(svi,0)<<" "<<mark(svi,1));
}
)
#else
CGAL_assertion_code(
for(svi=this->svertices_begin(); svi!=this->svertices_end(); svi++) {
CGAL_NEF_TRACEN("vertex "<<svi->point()<< " marks "<<mark(svi,0)<<" "<<mark(svi,1));
}
)
#endif
if(compute_halfsphere[cs][0] && compute_halfsphere[cs][1])
merge_halfsphere_maps(this->svertices_begin(),v,O);
else
set_outer_face_mark(compute_halfsphere[cs][1], mohs);
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
CGAL_assertion_code(this->check_integrity_and_topological_planarity());
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
CGAL_NEF_TRACEN("subdivided");
CGAL_assertion_code(CGAL_forall_svertices(v,*this) CGAL_NEF_TRACEN(PH(v)));
}
template <typename Map>
template <typename Association>
void SM_overlayer<Map>::
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
subdivide(const Map* M0, const Map* M1,
Association& A,
bool with_trivial_segments)
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
PI[0] = SM_const_decorator(M0);
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
PI[1] = SM_const_decorator(M1);
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 compute_halfsphere[3][2];
int cs=0;
Seg_list L;
Seg_map From;
for (int i=0; i<2; ++i) {
SVertex_const_iterator v;
CGAL_forall_svertices(v,PI[i]) {
CGAL_NEF_TRACEN(v->point() << " from " << i << " mark " << v->mark());
if ( !PI[i].is_isolated(v) ) continue;
cs = -1;
L.push_back(trivial_segment(PI[i],v));
From[--L.end()] = Seg_info(v,i);
}
SHalfedge_const_iterator e;
CGAL_forall_sedges(e,PI[i]) {
if ( e->source() == e->target() ) {
if(with_trivial_segments) {
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
CGAL_NEF_TRACEN("trivial segment " << e->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
v = e->source();
L.push_back(trivial_segment(PI[i],v));
From[--L.end()] = Seg_info(v,i);
} else {
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
CGAL_NEF_TRACEN("once around " << e->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
Seg_pair p = two_segments(PI[i],e);
L.push_back(p.first);
L.push_back(p.second);
From[--L.end()] = From[--(--L.end())] = Seg_info(e,i);
}
} else {
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
CGAL_NEF_TRACEN("normal segment " << e->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
L.push_back(segment(PI[i],e));
From[--L.end()] = Seg_info(e,i);
}
}
if ( PI[i].has_shalfloop() ) {
cs = -1;
CGAL_NEF_TRACEN("loop ");
SHalfloop_const_handle shl = PI[i].shalfloop();
Seg_pair p = two_segments(PI[i],shl);
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
L.push_back(p.first);
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
L.push_back(p.second.opposite());
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
From[--L.end()] = From[--(--L.end())] =
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
Seg_info(shl,i);
}
}
CGAL_assertion_code(typename Seg_list::iterator it);
CGAL_assertion_code(CGAL_forall_iterators(it,L) CGAL_NEF_TRACEN(" "<<*it));
#ifdef CGAL_NEF3_SPHERE_SWEEP_OPTIMIZATION_OFF
cs = -1;
#endif
if(cs != -1)
cs = check_sphere(L, compute_halfsphere);
else {
compute_halfsphere[2][0]=true;
compute_halfsphere[2][1]=true;
}
CGAL_NEF_TRACEN("compute_halfsphere\n cs = " << cs);
for(int i=0; i<6; ++i)
CGAL_NEF_TRACEN(" " << i << " : " << compute_halfsphere[i/2][i%2]);
Seg_list L_pos,L_neg;
switch(cs) {
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
case 1:
partition_to_halfsphere(L.begin(), L.end(), L_pos, From,
Sphere_circle(1,0,0), Sphere_circle(0,0,-1),
compute_halfsphere[0][1]);
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
break;
case 0:
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
partition_to_halfsphere(L.begin(), L.end(), L_neg, From,
Sphere_circle(-1,0,0), Sphere_circle(0,0,-1),
compute_halfsphere[0][0]);
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
break;
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
case 3:
partition_to_halfsphere(L.begin(), L.end(), L_pos, From,
Sphere_circle(0,1,0), Sphere_circle(1,0,0),
compute_halfsphere[1][1]);
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
break;
case 2:
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
partition_to_halfsphere(L.begin(), L.end(), L_neg, From,
Sphere_circle(0,-1,0), Sphere_circle(1,0,0),
compute_halfsphere[1][0]);
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
break;
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
case 5:
partition_to_halfsphere(L.begin(), L.end(), L_pos, From,
Sphere_circle(0,0,1), Sphere_circle(1,0,0),
compute_halfsphere[2][1]);
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
break;
case 4:
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
partition_to_halfsphere(L.begin(), L.end(), L_neg, From,
Sphere_circle(0,0,-1), Sphere_circle(1,0,0),
compute_halfsphere[2][0]);
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
break;
case -1:
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
partition_to_halfsphere(L.begin(), L.end(), L_pos, From,
Sphere_circle(0,0,1), Sphere_circle(1,0,0), true);
partition_to_halfsphere(L.begin(), L.end(), L_neg, From,
Sphere_circle(0,0,-1), Sphere_circle(1,0,0), 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
break;
default: CGAL_error_msg( "wrong value");
}
cs = cs==-1 ? 2 : cs/2;
#ifdef CGAL_NEF3_TIMER_SPHERE_SWEEPS
timer_sphere_sweeps.start();
#endif
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 SMO_from_sm<Self,Seg_iterator,Seg_info> SM_output;
typedef typename Sphere_kernel::Positive_halfsphere_geometry PH_geometry;
typedef typename Sphere_kernel::Negative_halfsphere_geometry NH_geometry;
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
typedef CGAL::Segment_overlay_traits<
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
Seg_iterator, SM_output, PH_geometry> PHS_traits;
typedef CGAL::generic_sweep<PHS_traits> Positive_halfsphere_sweep;
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
typedef CGAL::Segment_overlay_traits<
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
Seg_iterator, SM_output, NH_geometry> NHS_traits;
typedef CGAL::generic_sweep<NHS_traits> Negative_halfsphere_sweep;
typedef typename PHS_traits::INPUT Input_range;
SVertex_handle v;
SHalfedge_handle e;
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
SM_output O(*this,PI,From);
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(compute_halfsphere[cs][0]) {
PH_geometry phg(cs);
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
// the following is only needed for indexed items
SHalfedge_const_handle se;
SHalfloop_const_handle sl;
for(Seg_iterator it=L_pos.begin(); it!=L_pos.end();++it) {
CGAL_NEF_TRACEN("pos " << *it);
if(phg.compare_xy(it->target(),it->source())<0) {
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
Object_handle o = From[it]._o;
if(CGAL::assign(se, o)) {
if(it->sphere_circle() == se->circle())
From[it] = Seg_info(se->twin(), From[it]._from);
} else if(CGAL::assign(sl, o)) {
if(it->sphere_circle() == sl->circle())
From[it] = Seg_info(sl->twin(), From[it]._from);
}
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
}
}
*/
Positive_halfsphere_sweep SP(
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
Input_range(L_pos.begin(),L_pos.end()),O,phg);
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
SP.sweep();
v=--this->svertices_end(); e=--this->shalfedges_end();
#ifdef CGAL_NEF3_TIMER_SPHERE_SWEEPS
number_of_sphere_sweeps++;
#endif
}
if(compute_halfsphere[cs][1]) {
NH_geometry nhg(cs);
/*
SHalfedge_const_handle se;
SHalfloop_const_handle sl;
for(Seg_iterator it=L_neg.begin(); it!=L_neg.end();++it) {
CGAL_NEF_TRACEN("neg " << *it);
if(nhg.compare_xy(it->target(),it->source())<0) {
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
Object_handle o = From[it]._o;
if(CGAL::assign(se, o)) {
if(it->sphere_circle() == se->circle())
From[it] = Seg_info(se->twin(), From[it]._from);
} else if(CGAL::assign(sl, o)) {
if(it->sphere_circle() == sl->circle())
From[it] = Seg_info(sl->twin(), From[it]._from);
}
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
}
}
*/
Negative_halfsphere_sweep SM(
Input_range(L_neg.begin(),L_neg.end()),O,
nhg);
SM.sweep();
#ifdef CGAL_NEF3_TIMER_SPHERE_SWEEPS
number_of_sphere_sweeps++;
#endif
}
#ifdef CGAL_NEF3_TIMER_SPHERE_SWEEPS
timer_sphere_sweeps.stop();
#endif
if(compute_halfsphere[cs][0]) {
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
++v;
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
++e;
}
else {
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
v = this->svertices_begin();
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
e = this->shalfedges_begin();
}
if(compute_halfsphere[cs][0])
create_face_objects(this->shalfedges_begin(), e, this->svertices_begin(), v, O,
PH_geometry(cs));
if(compute_halfsphere[cs][1])
create_face_objects(e, this->shalfedges_end(), v, this->svertices_end(), O,
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
NH_geometry(cs));
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_forall_sedges(e,*this) {
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
e->circle() = Sphere_circle(e->source()->point(), e->twin()->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
e->twin()->circle() = e->circle().opposite();
CGAL_NEF_TRACEN(PH(e) << " with circle " << e->circle());
}
std::vector<Mark> mohs(4);
SM_point_locator L0(M0);
SM_point_locator L1(M1);
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
L0.marks_of_halfspheres(mohs, 0, cs);
L1.marks_of_halfspheres(mohs, 2, cs);
CGAL_NEF_TRACEN("mohs[0]=" << mohs[0]);
CGAL_NEF_TRACEN("mohs[1]=" << mohs[1]);
CGAL_NEF_TRACEN("mohs[2]=" << mohs[2]);
CGAL_NEF_TRACEN("mohs[3]=" << mohs[3]);
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
CGAL_NEF_TRACEN("compute_halfsphrere\n cs = " << cs <<
"\n [cs][0] = " << compute_halfsphere[cs][0] <<
"\n [cs][1] = " << compute_halfsphere[cs][1]);
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
/*
SVertex_iterator svii;
CGAL_forall_svertices(svii, *this) {
SVertex_const_handle vs;
SHalfedge_const_handle es;
if(CGAL::assign(vs, supp_object(svii,0)))
std::cerr << svii->point() << " supported by svertex " << vs->point() << std::endl;
else if(CGAL::assign(es, supp_object(svii,0)))
std::cerr << svii->point() << " supported by sedge" << std::endl;
else
std::cerr << svii->point() << " is neither supported by svertex or sedge" << std::endl;
if(CGAL::assign(vs, supp_object(svii,1)))
std::cerr << svii->point() << " supported by svertex " << vs->point() << std::endl;
else if(CGAL::assign(es, supp_object(svii,1)))
std::cerr << svii->point() << " supported by sedge" << std::endl;
else
std::cerr << svii->point() << " is neither supported by svertex or sedge" << std::endl;
}
*/
if(compute_halfsphere[cs][0])
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
complete_face_support(this->svertices_begin(), v, O, mohs, 0,
compute_halfsphere[cs][1]);
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(compute_halfsphere[cs][1])
complete_face_support(v, this->svertices_end(), O, mohs, 1,
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
compute_halfsphere[cs][0]);
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
complete_sface_marks();
// DEBUG CODE: to do: have all svertices a halfedge below associated?
CGAL_NEF_TRACEN("Vertex info after swep");
CGAL_assertion_code(SVertex_iterator svi);
#ifdef CGAL_I_DO_WANT_TO_USE_GENINFO
CGAL_assertion_code(
for(svi=this->svertices_begin(); svi!=this->svertices_end(); svi++) {
CGAL_NEF_TRACEN("vertex "<<svi->point() <<" info "<<info(svi) << " marks "<<mark(svi,0)<<" "<<mark(svi,1));
}
)
#else
CGAL_assertion_code(
for(svi=this->svertices_begin(); svi!=this->svertices_end(); svi++) {
CGAL_NEF_TRACEN("vertex "<<svi->point() << " marks "<<mark(svi,0)<<" "<<mark(svi,1));
}
)
#endif
transfer_data(A);
if(compute_halfsphere[cs][0] && compute_halfsphere[cs][1])
merge_halfsphere_maps(this->svertices_begin(),v,O);
else
set_outer_face_mark(compute_halfsphere[cs][1], mohs);
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
CGAL_assertion_code(this->check_integrity_and_topological_planarity());
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
CGAL_NEF_TRACEN("subdivided");
CGAL_assertion_code(CGAL_forall_svertices(v,*this) CGAL_NEF_TRACEN(PH(v)));
}
template <typename Map>
template <typename Association>
void SM_overlayer<Map>::
transfer_data(Association& A) {
SVertex_iterator sv;
SHalfedge_handle se;
SVertex_const_handle sv0,sv1;
SHalfedge_const_handle se0, se1;
SHalfloop_const_handle sl0, sl1;
CGAL_forall_svertices(sv, *this) {
// std::cerr << "svertex " << sv->point() << std::endl;
Object_handle o0 = supp_object(sv,0), o1 = supp_object(sv,1);
if(o0.empty()) {
if(CGAL::assign(sv1, o1))
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
A.handle_support(sv, sv1);
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
continue;
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(CGAL::assign(se0, o0)) {
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
if(o1.empty())
continue;
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(assign(se1, o1))
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
A.handle_support(sv, se0, se1);
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(CGAL::assign(sv1, o1))
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
A.handle_support(sv, se0, sv1);
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(CGAL::assign(sl1, o1))
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
A.handle_support(sv, se0, sl1);
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
CGAL_error_msg( "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
} else if(CGAL::assign(sv0, o0)) {
if(o1.empty())
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
A.handle_support(sv, sv0);
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(CGAL::assign(se1, o1))
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
A.handle_support(sv, sv0, se1);
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(CGAL::assign(sv1, o1))
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
A.handle_support(sv, sv0, sv1);
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(CGAL::assign(sl1, o1))
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
A.handle_support(sv, sv0, sl1);
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
CGAL_error_msg( "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
} else if(CGAL::assign(sl0, o0)) {
if(o1.empty())
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
continue;
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(CGAL::assign(sv1, o1))
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
A.handle_support(sv, sl0, sv1);
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(CGAL::assign(se1, o1))
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
A.handle_support(sv, sl0, se1);
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(CGAL::assign(sl1, o1))
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
A.handle_support(sv, sl0, sl1);
} 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( "wrong handle");
}
CGAL_forall_sedges(se, *this) {
CGAL_assertion(is_forward(se));
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
Object_handle o0 = supp_object(se,0), o1 = supp_object(se,1);
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(o0.empty()) {
if(assign(se1, o1))
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
A.handle_support(se, se1);
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(assign(sl1, o1))
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
A.handle_support(se, sl1);
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
continue; // CGAL_error_msg( "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
} else if(assign(se0, o0)) {
if(o1.empty())
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
A.handle_support(se, se0);
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(assign(se1, o1))
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
A.handle_support(se, se0, se1);
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(assign(sl1, o1))
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
A.handle_support(se, se0, sl1);
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
CGAL_error_msg( "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
} else if(assign(sl0, o0)) {
if(o1.empty())
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
A.handle_support(se, sl0);
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(assign(se1, o1))
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
A.handle_support(se, sl0, se1);
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(assign(sl1, o1))
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
A.handle_support(se, sl0, sl1);
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
CGAL_error_msg( "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
} else
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
CGAL_error_msg( "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
}
}
template <typename Map>
void SM_overlayer<Map>::
set_outer_face_mark(int offset, const std::vector<Mark>& mohs) {
SFace_handle sf = this->new_sface();
assoc_info(sf);
mark(sf, 0) = mohs[offset];
mark(sf, 1) = mohs[offset+2];
SHalfedge_iterator e;
CGAL_forall_shalfedges(e, *this) {
if ( e->incident_sface() != SFace_handle() ) continue;
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
link_as_face_cycle(e,sf);
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
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
SVertex_handle v;
CGAL_forall_svertices(v, *this) {
if(!is_isolated(v) || v->incident_sface() != SFace_handle()) continue;
link_as_isolated_vertex(v,sf);
}
}
template <typename Map>
template <typename Iterator, typename T>
void SM_overlayer<Map>::
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
partition_to_halfsphere(Iterator start, Iterator beyond, Seg_list& L,
CGAL::Unique_hash_map<Iterator,T>& M,
Sphere_circle xycircle, Sphere_circle yzcircle,
bool include_equator) 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("partition_to_halfsphere ");
// CGAL_assertion(pos!=0);
Sphere_segment s1,s2;
// Sphere_circle xycircle(0,0,pos);
if(include_equator) {
while ( start != beyond) {
int i = start->intersection(xycircle,s1,s2);
CGAL_NEF_TRACEN("segment " << start->source() << " " << start->target());
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
if (i>1) {
L.push_back(s2); M[--L.end()] = M[start];
CGAL_NEF_TRACEN(">1 " << s2.source() << " " << s2.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
}
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
if (i>0) {
L.push_back(s1); M[--L.end()] = M[start];
CGAL_NEF_TRACEN(">0 " << s1.source() << " " << 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
}
++start;
}
}
else {
while(start != beyond) {
L.push_back(*start);
M[--L.end()] = M[start];
++start;
}
}
// now all segments are split into hemispheres
// we still have to:
// - split segments containing our special poles y^-, y^+
// - split halfcircles
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
// - add four equator segments
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
// Sphere_circle yzcircle(1,0,0);
typename Seg_list::iterator it, itl;
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
CGAL_forall_iterators(it,L) { CGAL_NEF_TRACEN(" "<<*it);
if ( equal_as_sets(it->sphere_circle(),xycircle) ) {
CGAL_NEF_TRACEN(" splitting xy seg "<<*it);
bool added=false;
int n1 = it->intersection(yzcircle,s1,s2);
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
if (n1 > 1 && !s2.is_degenerate()) {
M[ L.insert(it,s2) ] = M[it];
added=true;
CGAL_NEF_TRACEN(">1 " << s2.source() << " " << s2.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
}
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
if (n1 > 0 && !s1.is_degenerate()) {
M[ L.insert(it,s1) ] = M[it];
added = true;
CGAL_NEF_TRACEN(">1 " << s1.source() << " " << 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
}
int n2 = it->intersection(yzcircle.opposite(),s1,s2);
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
if (n2 > 1 && !s2.is_degenerate()) {
M[ L.insert(it,s2) ] = M[it];
added=true;
CGAL_NEF_TRACEN(">1 " << s2.source() << " " << s2.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
}
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
if (n2 > 0 && !s1.is_degenerate()) {
M[ L.insert(it,s1) ] = M[it];
added=true;
CGAL_NEF_TRACEN(">1 " << s1.source() << " " << 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
}
if(added) {
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
itl = it; --it; M[itl] = T(); L.erase(itl);
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 least one item was appended
}
}
CGAL_forall_iterators(it,L) {
if ( it->is_halfcircle() ) {
CGAL_NEF_TRACEN(" splitting halfcircle "<<*it);
Sphere_segment s1,s2;
it->split_halfcircle(s1,s2);
CGAL_NEF_TRACEN(" into " << s1);
CGAL_NEF_TRACEN(" into " << s2);
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
*it = s2;
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
M[ L.insert(it,s1) ] = M[it];
}
}
if(include_equator) {
// append 4 xy-equator segments:
Sphere_point S(0,-1,0),N(0,1,0);
Sphere_segment sp(S,N,xycircle);
Sphere_segment sm(S,N,xycircle.opposite());
Sphere_segment s[4];
sp.split_halfcircle(s[0],s[1]);
sm.split_halfcircle(s[2],s[3]);
L.insert(L.end(),s,s+4);
}
}
template <typename Map>
template <typename Below_accessor, typename Halfsphere_geometry>
void SM_overlayer<Map>::
create_face_objects(SHalfedge_iterator e_start, SHalfedge_iterator e_end,
SVertex_iterator v_start, SVertex_iterator v_end,
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
const Below_accessor& D,
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 Halfsphere_geometry& SG)
{
CGAL_NEF_TRACEN("create_face_objects()");
if(e_start != e_end) {
CGAL::Unique_hash_map<SHalfedge_handle,int> SFaceCycle(-1);
std::vector<SHalfedge_handle> MinimalSHalfedge;
SHalfedge_around_sface_circulator hfc(last_out_edge(v_start)),hend(hfc);
CGAL_NEF_TRACEN("equator cycle "<<PH(hfc));
CGAL_For_all(hfc,hend) SFaceCycle[hfc]=0; // outer face cycle = 0
MinimalSHalfedge.push_back(first_out_edge(v_start)->twin());
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
int i=1;
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
for (SHalfedge_iterator e = e_start; e != e_end; ++e) {
if ( SFaceCycle[e] >= 0 ) continue; // already assigned
SHalfedge_around_sface_circulator hfc(e),hend(hfc);
SHalfedge_handle e_min = e;
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
CGAL_NEF_TRACEN("");
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(" face cycle numbering "<<i);
CGAL_For_all(hfc,hend) {
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
SFaceCycle[hfc]=i; // assign face cycle number
if (hfc->twin()->source() == e_min->twin()->source()) {
Sphere_point p1 = hfc->source()->point(),
p2 = hfc->twin()->source()->point(),
p3 = hfc->snext()->twin()->source()->point();
if ( SG.orientation(p1,p2,p3) <= 0 )
e_min = hfc;
} else if ( SG.compare_xy(hfc->twin()->source()->point(), e_min->twin()->source()->point()) < 0 )
e_min = hfc;
CGAL_NEF_TRACEN(PH(hfc));
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("");
MinimalSHalfedge.push_back(e_min);
++i;
}
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
for (int j=1; j<i; ++j) {
SHalfedge_handle e = MinimalSHalfedge[j];
CGAL_NEF_TRACEN(" face cycle "<<j<<" minimal halfedge "<<PH(e));
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
Sphere_point p1 = e->source()->point(),
p2 = e->twin()->source()->point(),
p3 = e->snext()->twin()->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
if ( SG.orientation(p1,p2,p3) > 0 ) { // left_turn => outer face cycle
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
SFace_handle f = this->new_sface();
link_as_face_cycle(e,f);
CGAL_NEF_TRACEN(" creating new face object "<<&*f<<" bd "<<&*e);
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
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
for (SHalfedge_iterator e = e_start; e != e_end; ++e) {
if ( e->incident_sface() != SFace_handle() ) continue;
if ( SFaceCycle[e] == 0 ) continue;
CGAL_NEF_TRACEN("linking hole "<<PH(e));
SFace_handle f = determine_face(e,MinimalSHalfedge,SFaceCycle,D);
if(f != SFace_handle())
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
link_as_face_cycle(e,f);
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
}
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
for (SVertex_iterator v = v_start; v != v_end; ++v) {
if ( !is_isolated(v) ) continue;
SHalfedge_handle e_below = D.halfedge_below(v);
CGAL_assertion( e_below != SHalfedge_handle() || e_start == e_end );
if(e_below != SHalfedge_handle())
link_as_isolated_vertex(v,e_below->incident_sface());
}
}
template <typename Map>
template <typename Below_accessor>
void SM_overlayer<Map>::
complete_face_support(SVertex_iterator v_start, SVertex_iterator v_end,
const Below_accessor& , std::vector<Mark>& mohs, int offset, bool both) const
{ CGAL_NEF_TRACEN("complete_face_support");
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
for (SVertex_iterator v = v_start; v != v_end; ++v) {
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("VERTEX = "<<PH(v));
Mark m_buffer[2];
SHalfedge_handle e_below = halfedge_below(v);
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
if ( v == v_start ) {
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
for (int i=0; i<2; ++i){
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
m_buffer[i] = mohs[offset+2*i];
}
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 ( e_below != SHalfedge_handle() ) {
for (int i=0; i<2; ++i) {
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
CGAL_NEF_TRACEN("edge below "<< PH(e_below) << " " << mark(e_below,i));
m_buffer[i] = incident_mark(e_below,i);
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 { // e_below does not exist
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
// CGAL_assertion( v->point().hz() == 0 &&
// ( offset == 0 ? (v->point().hx() >= 0) : (v->point().hx()<=0)) );
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(!is_isolated(v)) {
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
if(!both) {
for (int i=0; i<2; ++i)
m_buffer[i] = mohs[offset+2*i];
CGAL_NEF_TRACEN("no edge below ");
} else {
for (int i=0; i<2; ++i)
m_buffer[i] = incident_mark(first_out_edge(v)->sprev(),i);
}
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(" faces right-below "<<m_buffer[0]<<" "<<m_buffer[1]);
for (int i=0; i<2; ++i) {
Object_handle o = supp_object(v,i);
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
if ( o.empty() ) {
CGAL_NEF_TRACEN("no vertex support");
mark(v,i) = m_buffer[i]; continue;
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
}
SVertex_const_handle vs;
SHalfedge_const_handle es;
SHalfloop_const_handle ls;
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
if ( CGAL::assign(vs,o) ) {
CGAL_NEF_TRACEN("support by svertex");
mark(v,i) = vs->mark(); continue;
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(es,supp_object(v,i)) ) {
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
CGAL_NEF_TRACEN("support by sedge");
if ( es->source()->point() == v->point() )
{ mark(v,i) = es->source()->mark(); continue; }
if ( es->target()->point() == v->point() )
{ mark(v,i) = es->target()->mark(); continue; }
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
mark(v,i) = es->mark(); continue;
}
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
if ( CGAL::assign(ls,o) ) {
mark(v,i) = ls->mark();
CGAL_NEF_TRACEN("loop " << ls->circle()); continue; }
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("wrong handle");
} CGAL_NEF_TRACEN(" vertex marks "<<mark(v,0)<<" "<<mark(v,1));
if ( is_isolated(v) ) continue;
SHalfedge_around_svertex_circulator e(first_out_edge(v)), hend(e);
CGAL_For_all(e,hend) {
if ( !is_forward(e) ) break;
CGAL_NEF_TRACEN(" forward edge "<<PH(e));
for (int i=0; i<2; ++i) {
if ( ! supp_object(e,i).empty() ) {
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
SHalfedge_const_handle ei;
if ( CGAL::assign(ei,supp_object(e,i)) ) {
if (!equal_not_opposite(ei->circle(),e->circle()))
ei = ei->twin();
CGAL_assertion( ei->circle() == e->circle() );
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(" supporting edge "<<i<<" "<<PH(ei));
incident_mark(e->twin(),i) =
ei->twin()->incident_sface()->mark();
mark(e,i) = mark(e->twin(),i) = ei->mark();
incident_mark(e,i) = m_buffer[i] =
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
ei->incident_sface()->mark();
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
}
SHalfloop_const_handle li;
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
if ( CGAL::assign(li,supp_object(e,i)) ) {
if (!equal_not_opposite(li->circle(),e->circle()))
li = li->twin();
CGAL_assertion( li->circle() == e->circle() );
CGAL_NEF_TRACEN(" supporting loop "<<i<<" "<<PH(li));
incident_mark(e->twin(),i) =
li->twin()->incident_sface()->mark();
mark(e,i) = mark(e->twin(),i) = li->mark();
incident_mark(e,i) = m_buffer[i] =
li->incident_sface()->mark();
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_NEF_TRACEN(" support from face below "<<i);
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
incident_mark(e->twin(),i) = mark(e,i) = mark(e->twin(),i) =
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
incident_mark(e,i) = m_buffer[i];
}
} CGAL_NEF_TRACEN(" face marks "<<m_buffer[0]<<" "<<m_buffer[1]);
}
CGAL_NEF_TRACEN(" mark of "<<PH(v)<<" "<<mark(v,0)<<" "<<mark(v,1));
}
}
template <typename Map>
void SM_overlayer<Map>::complete_sface_marks() const {
SFace_iterator f;
for (f = this->sfaces_begin(); f != this->sfaces_end(); ++f) {
assoc_info(f);
SFace_cycle_iterator boundary_object(f->sface_cycles_begin());
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
if (!boundary_object.is_shalfedge() )
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("Outer face cycle should be first.");
SHalfedge_handle e(boundary_object);
for (int i=0; i<2; ++i) mark(f,i) = incident_mark(e,i);
}
}
template <typename Map>
template <typename Mark_accessor>
void SM_overlayer<Map>::
merge_nodes(SHalfedge_handle e1, SHalfedge_handle e2,
const Mark_accessor& D)
{
SVertex_handle v1 = e1->source(), v2 = e2->target();
CGAL_NEF_TRACEN("merge_nodes "<<PH(v1)<<PH(v2));
CGAL_assertion(v1->point()==v2->point());
SHalfedge_handle ep1 = e1->sprev(), en2 = e2->snext();
SHalfedge_around_svertex_circulator eav(out_edges(v2)),ee(eav);
CGAL_For_all(eav,ee) { set_source(eav,v1); }
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
link_as_prev_next_pair(e2,e1);
link_as_prev_next_pair(ep1,en2);
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
D.assert_equal_marks(v1,v2);
D.discard_info(v2);
delete_vertex_only(v2);
}
template <typename Map>
template <typename Mark_accessor>
void SM_overlayer<Map>::
merge_halfsphere_maps(SVertex_handle v1, SVertex_handle v2,
const Mark_accessor& D)
{ CGAL_NEF_TRACEN("merging halfspheres "<<PH(v1)<<PH(v2));
CGAL_assertion(v1->point()==v2->point());
std::list<SHalfedge_pair> L_equator;
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
SHalfedge_around_sface_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
ep(last_out_edge(v1)), en(first_out_edge(v2)->twin());
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
do {
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
L_equator.push_back(SHalfedge_pair(ep,en));
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
merge_nodes(ep,en,D); ++ep; --en;
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
} while ( ep->source() != v1 );
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 std::list<SHalfedge_pair>::iterator it;
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
CGAL_forall_iterators(it,L_equator) {
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_handle e1 = it->first, e2 = it->second;
SHalfedge_handle e1t = e1->twin(), e2t = e2->twin();
CGAL_NEF_TRACEV(PH(e1));CGAL_NEF_TRACEV(PH(e2));
SHalfedge_handle e2tp = e2t->sprev();
SHalfedge_handle e2tn = e2t->snext();
link_as_prev_next_pair(e2tp,e1);
link_as_prev_next_pair(e1,e2tn);
SFace_handle f = e2t->incident_sface();
if ( is_sm_boundary_object(e2t) )
{ undo_sm_boundary_object(e2t,f); store_sm_boundary_object(e1,f); }
set_face(e1,f);
if ( e2 == first_out_edge(e2->source()) )
set_first_out_edge(e2->source(),e1t);
D.discard_info(e2);
delete_edge_pair_only(e2);
}
}
template <typename Map>
template <typename Selection>
void SM_overlayer<Map>::
select(const Selection& SP) const
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
SVertex_iterator v;
CGAL_forall_svertices(v,*this) {
v->mark() = SP(mark(v,0),mark(v,1));
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
discard_info(v);
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_iterator e;
CGAL_forall_sedges(e,*this) {
e->mark() = SP(mark(e,0),mark(e,1));
e->twin()->mark() = SP(mark(e->twin(),0),mark(e->twin(),1));
CGAL_assertion(e->mark() == e->twin()->mark());
discard_info(e);
}
SFace_iterator f;
CGAL_forall_sfaces(f,*this) {
f->mark() = SP(mark(f,0),mark(f,1));
discard_info(f);
}
}
template <typename Map>
void SM_overlayer<Map>::simplify()
{
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
CGAL_NEF_TRACEN("simplifying");
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 CGAL::Union_find<SFace_handle>::handle Union_find_handle;
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
CGAL::Unique_hash_map< SFace_handle, Union_find_handle> Pitem(nullptr);
CGAL::Unique_hash_map< SVertex_handle, Union_find_handle> Vitem(nullptr);
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::Union_find< SFace_handle> UF;
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
SFace_iterator f;
CGAL_forall_sfaces(f,*this) {
Pitem[f] = UF.make_set(f);
clear_face_cycle_entries(f);
}
if ( this->has_shalfloop() ) {
SHalfloop_handle l = this->shalfloop();
SFace_handle f = *(UF.find(Pitem[l->incident_sface()]));
link_as_loop(l,f);
f = *(UF.find(Pitem[l->twin()->incident_sface()]));
link_as_loop(l->twin(),f);
}
SHalfedge_iterator e, en;
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
for(e = this->shalfedges_begin(); e != this->shalfedges_end(); e = en) {
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
en = e; ++en; if ( en==e->twin() ) ++en;
CGAL_NEF_TRACEN("can simplify ? " << PH(e));
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
CGAL_NEF_TRACEN(e->mark() << " " <<
e->incident_sface()->mark() << " " <<
e->twin()->incident_sface()->mark());
if (( e->mark() == e->incident_sface()->mark() &&
e->mark() == e->twin()->incident_sface()->mark())){
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("deleting "<<PH(e));
if ( !UF.same_set(Pitem[e->incident_sface()],
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
Pitem[e->twin()->incident_sface()]) ) {
UF.unify_sets( Pitem[e->incident_sface()],
Pitem[e->twin()->incident_sface()] );
CGAL_NEF_TRACEN("unioning disjoint faces");
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
CGAL_NEF_TRACEN("is_closed_at_source " << is_closed_at_source(e) <<
" " << is_closed_at_source(e->twin()));
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 ( is_closed_at_source(e) )
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
Vitem[e->source()] = Pitem[e->incident_sface()];
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 ( is_closed_at_source(e->twin()))
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
Vitem[e->target()] = Pitem[e->incident_sface()];
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
delete_edge_pair(e);
}
}
CGAL::Unique_hash_map<SHalfedge_handle,bool> linked(false);
for (e = this->shalfedges_begin(); e != this->shalfedges_end(); ++e) {
if ( linked[e] ) continue;
SHalfedge_around_sface_circulator hfc(e),hend(hfc);
SFace_handle f = *(UF.find( Pitem[e->incident_sface()]));
CGAL_For_all(hfc,hend) { set_face(hfc,f); linked[hfc]=true; }
store_sm_boundary_object(e,f);
}
SVertex_iterator v,vn;
for(v = this->svertices_begin(); v != this->svertices_end(); v=vn) {
vn=v; ++vn;
if ( is_isolated(v) ) {
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
if(Vitem[v] != nullptr) {
set_face(v,*(UF.find(Vitem[v])));
CGAL_NEF_TRACEN("incident face of " << PH(v) << " set to " << &*(v->incident_sface()));
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
set_face(v, *(UF.find(Pitem[v->incident_sface()])));
CGAL_NEF_TRACEN("isolated svertex " << PH(v) <<
" already has incident face " << &*(v->incident_sface()));
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 ( v->mark() == v->incident_sface()->mark() ) {
CGAL_NEF_TRACEN("removing isolated vertex"<<PH(v));
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
delete_vertex_only(v);
}
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
store_sm_boundary_object(v,v->incident_sface()); // isolated, but should stay
} else { // v not isolated
SHalfedge_handle e2 = first_out_edge(v), e1 = e2->sprev();
if ( has_outdeg_two(v) &&
v->mark() == e1->mark() && v->mark() == e2->mark() &&
e1->circle() == e2->circle() ) {
CGAL_NEF_TRACEN("collinear at "<<PH(v)<<PH(e1)<<PH(e2));
if ( e1 == e2 ){ CGAL_NEF_TRACEN("edge_to_loop"); convert_edge_to_loop(e1);}
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
else {CGAL_NEF_TRACEN("merge_edge_pairs"); merge_edge_pairs_at_target(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
}
}
}
SFace_iterator fn;
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
for (f = fn = this->sfaces_begin(); f != this->sfaces_end(); f=fn) {
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
++fn;
Union_find_handle pit = Pitem[f];
if ( UF.find(pit) != pit ) {
CGAL_NEF_TRACEN("delete face " << &*f);
delete_face_only(f);
}
}
}
template <typename Map>
template <typename Iterator>
void SM_overlayer<Map>::
subdivide_segments(Iterator start, Iterator end) const
{
typedef SMO_decorator<SM_decorator,Iterator> SM_output;
typedef typename Sphere_kernel::Positive_halfsphere_geometry PH_geometry;
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
typedef CGAL::Segment_overlay_traits<
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
Iterator, SM_output, PH_geometry> PHS_traits;
typedef CGAL::generic_sweep<PHS_traits> Positive_halfsphere_sweep;
typedef typename Sphere_kernel::Negative_halfsphere_geometry NH_geometry;
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
typedef CGAL::Segment_overlay_traits<
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
Iterator, SM_output, NH_geometry> NHS_traits;
typedef CGAL::generic_sweep<NHS_traits> Negative_halfsphere_sweep;
std::list<Sphere_segment> Lp,Lm;
partition_xy( start, end, Lp , +1);
partition_xy( start, end, Lm , -1);
// both lists initialized with four quarter segments
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
// supporting the xy-equator thereby separating the
// two halfspheres
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
// all other segments in the range are split into their
// connected components with respect to the xy-plane.
SVertex_handle v1,v2;
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
SM_output O(*this);
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 PHS_traits::INPUT Input_range;
Positive_halfsphere_sweep SP(Input_range(Lp.begin(),Lp.end()),O);
SP.sweep();
//CGAL_NEF_TRACEN("POS SWEEP\n"<<(dump(std::cerr),""));
v1= this->vertices_begin(); v2=--this->vertices_end();
Negative_halfsphere_sweep SM(Input_range(Lm.begin(),Lm.end()),O);
SM.sweep();
//CGAL_NEF_TRACEN("NEG SWEEP\n"<<(dump(std::cerr),""));
++v2;
// now two CCs of sphere graph calculated
// v1 = first node of CC in positive xy-sphere
// v2 = first node of CC in negative xy-sphere
merge_halfsphere_maps(v1,v2,O);
this->check_integrity_and_topological_planarity(false);
}
} //namespace CGAL
#endif //CGAL_SM_OVERLAYER_H