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

392 lines
15 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) 2008 Max-Planck-Institute Saarbruecken (Germany).
// All rights reserved.
//
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
// This file is part of CGAL (www.cgal.org)
Integrate Instant-Meshes 1. Drop windows 32bit support Add windows 64bit support. 2. Remove Script(quickjs) support The current integrated quickjs is a very old version which doesn’t support windows 64bit system. In the future, (TODO)WebAssembly should be integrate as plugin system. 3. Integrate Instant-Meshes Instant-Meshes take less than 1 second on all three platforms. 4. Remove QuadriFlow Current implementation of QuadriFlow is too slow (take about 5 seconds on the example model) to do realtime remeshing.
2020-01-04 10:29:10 +00:00
//
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
// $URL: https://github.com/CGAL/cgal/blob/v5.1/Polynomial/include/CGAL/polynomial_utils.h $
// $Id: polynomial_utils.h 0779373 2020-03-26T13:31:46+01:00 Sébastien Loriot
// SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-Commercial
Integrate Instant-Meshes 1. Drop windows 32bit support Add windows 64bit support. 2. Remove Script(quickjs) support The current integrated quickjs is a very old version which doesn’t support windows 64bit system. In the future, (TODO)WebAssembly should be integrate as plugin system. 3. Integrate Instant-Meshes Instant-Meshes take less than 1 second on all three platforms. 4. Remove QuadriFlow Current implementation of QuadriFlow is too slow (take about 5 seconds on the example model) to do realtime remeshing.
2020-01-04 10:29:10 +00:00
//
//
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
// Author(s) : Michael Hemmer <hemmer@mpi-inf.mpg.de>
Integrate Instant-Meshes 1. Drop windows 32bit support Add windows 64bit support. 2. Remove Script(quickjs) support The current integrated quickjs is a very old version which doesn’t support windows 64bit system. In the future, (TODO)WebAssembly should be integrate as plugin system. 3. Integrate Instant-Meshes Instant-Meshes take less than 1 second on all three platforms. 4. Remove QuadriFlow Current implementation of QuadriFlow is too slow (take about 5 seconds on the example model) to do realtime remeshing.
2020-01-04 10:29:10 +00:00
//
// ============================================================================
#include <CGAL/basic.h>
#include <CGAL/Polynomial_traits_d.h>
#ifndef CGAL_POLYNOMIAL_UTILS_H
#define CGAL_POLYNOMIAL_UTILS_H
#define CGAL_UNARY_POLY_FUNCTION(functor,function) \
template <typename Polynomial_d> inline \
typename Polynomial_traits_d<Polynomial_d>::functor::result_type \
function(const Polynomial_d& p){ \
typedef Polynomial_traits_d<Polynomial_d> PT; \
return typename PT::functor()(p); \
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
}
Integrate Instant-Meshes 1. Drop windows 32bit support Add windows 64bit support. 2. Remove Script(quickjs) support The current integrated quickjs is a very old version which doesn’t support windows 64bit system. In the future, (TODO)WebAssembly should be integrate as plugin system. 3. Integrate Instant-Meshes Instant-Meshes take less than 1 second on all three platforms. 4. Remove QuadriFlow Current implementation of QuadriFlow is too slow (take about 5 seconds on the example model) to do realtime remeshing.
2020-01-04 10:29:10 +00:00
#define CGAL_UNARY_POLY_FUNCTION_INDEX(functor,function) \
CGAL_UNARY_POLY_FUNCTION(functor,function) \
template <typename Polynomial_d> inline \
typename Polynomial_traits_d<Polynomial_d>::functor::result_type \
function(const Polynomial_d& p, int index ){ \
typedef Polynomial_traits_d<Polynomial_d> PT; \
typename PT::functor fo; \
return fo(p,index); \
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
#define CGAL_BINARY_POLY_FUNCTION(functor,function) \
template <typename Polynomial_d> inline \
typename Polynomial_traits_d<Polynomial_d>::functor::result_type \
function(const Polynomial_d& p, \
const typename Polynomial_traits_d<Polynomial_d>:: \
functor::second_argument_type& second \
){ \
typedef Polynomial_traits_d<Polynomial_d> PT; \
return typename PT::functor()(p,second); \
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
#define CGAL_BINARY_POLY_FUNCTION_INDEX(functor,function) \
CGAL_BINARY_POLY_FUNCTION(functor,function) \
template <typename Polynomial_d> inline \
typename Polynomial_traits_d<Polynomial_d>::functor::result_type \
function(const Polynomial_d& p, \
const typename Polynomial_traits_d<Polynomial_d>:: \
functor::second_argument_type& second, \
int index \
){ \
typedef Polynomial_traits_d<Polynomial_d> PT; \
return typename PT::functor()(p,second,index); \
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
namespace CGAL {
// GetCoefficient
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
template <typename Polynomial_d> inline
Integrate Instant-Meshes 1. Drop windows 32bit support Add windows 64bit support. 2. Remove Script(quickjs) support The current integrated quickjs is a very old version which doesn’t support windows 64bit system. In the future, (TODO)WebAssembly should be integrate as plugin system. 3. Integrate Instant-Meshes Instant-Meshes take less than 1 second on all three platforms. 4. Remove QuadriFlow Current implementation of QuadriFlow is too slow (take about 5 seconds on the example model) to do realtime remeshing.
2020-01-04 10:29:10 +00:00
typename Polynomial_traits_d<Polynomial_d>::Get_coefficient::result_type
get_coefficient(const Polynomial_d& p, int i){
typename Polynomial_traits_d<Polynomial_d>::Get_coefficient get_coefficient;
return get_coefficient(p,i);
}
// GetInnermostCoefficient
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
template <typename Polynomial_d> inline
Integrate Instant-Meshes 1. Drop windows 32bit support Add windows 64bit support. 2. Remove Script(quickjs) support The current integrated quickjs is a very old version which doesn’t support windows 64bit system. In the future, (TODO)WebAssembly should be integrate as plugin system. 3. Integrate Instant-Meshes Instant-Meshes take less than 1 second on all three platforms. 4. Remove QuadriFlow Current implementation of QuadriFlow is too slow (take about 5 seconds on the example model) to do realtime remeshing.
2020-01-04 10:29:10 +00:00
typename Polynomial_traits_d<Polynomial_d>
::Get_innermost_coefficient::result_type
get_innermost_coefficient(const Polynomial_d& p, Exponent_vector ev){
typename Polynomial_traits_d<Polynomial_d>::Get_innermost_coefficient gic;
return gic(p,ev);
}
// ConstructCoefficientConstIteratorRange
// ConstructInnermostCoefficientConstIteratorRange
// Swap
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
template <typename Polynomial_d> inline
Integrate Instant-Meshes 1. Drop windows 32bit support Add windows 64bit support. 2. Remove Script(quickjs) support The current integrated quickjs is a very old version which doesn’t support windows 64bit system. In the future, (TODO)WebAssembly should be integrate as plugin system. 3. Integrate Instant-Meshes Instant-Meshes take less than 1 second on all three platforms. 4. Remove QuadriFlow Current implementation of QuadriFlow is too slow (take about 5 seconds on the example model) to do realtime remeshing.
2020-01-04 10:29:10 +00:00
typename Polynomial_traits_d<Polynomial_d>::Swap::result_type
swap(const Polynomial_d& p, int i, int j){
typename Polynomial_traits_d<Polynomial_d>::Swap swap;
return swap(p,i,j);
}
// Move
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
template <typename Polynomial_d> inline
Integrate Instant-Meshes 1. Drop windows 32bit support Add windows 64bit support. 2. Remove Script(quickjs) support The current integrated quickjs is a very old version which doesn’t support windows 64bit system. In the future, (TODO)WebAssembly should be integrate as plugin system. 3. Integrate Instant-Meshes Instant-Meshes take less than 1 second on all three platforms. 4. Remove QuadriFlow Current implementation of QuadriFlow is too slow (take about 5 seconds on the example model) to do realtime remeshing.
2020-01-04 10:29:10 +00:00
typename Polynomial_traits_d<Polynomial_d>::Move::result_type
move(const Polynomial_d& p, int i, int j){
typename Polynomial_traits_d<Polynomial_d>::Move move;
return move(p,i,j);
}
// Permute
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
template <typename Polynomial_d, typename Input_iterator> inline
Integrate Instant-Meshes 1. Drop windows 32bit support Add windows 64bit support. 2. Remove Script(quickjs) support The current integrated quickjs is a very old version which doesn’t support windows 64bit system. In the future, (TODO)WebAssembly should be integrate as plugin system. 3. Integrate Instant-Meshes Instant-Meshes take less than 1 second on all three platforms. 4. Remove QuadriFlow Current implementation of QuadriFlow is too slow (take about 5 seconds on the example model) to do realtime remeshing.
2020-01-04 10:29:10 +00:00
typename Polynomial_traits_d<Polynomial_d>::Permute::result_type
permute(const Polynomial_d& p, Input_iterator begin, Input_iterator end){
typename Polynomial_traits_d<Polynomial_d>::Permute permute;
return permute(p,begin,end);
}
// Degree
CGAL_UNARY_POLY_FUNCTION_INDEX(Degree,degree)
// TotalDegree
CGAL_UNARY_POLY_FUNCTION(Total_degree,total_degree)
// DegreeVector
CGAL_UNARY_POLY_FUNCTION(Degree_vector,degree_vector)
// LeadingCoefficient
CGAL_UNARY_POLY_FUNCTION(Leading_coefficient,leading_coefficient)
// InnermostLeadingCoefficient
CGAL_UNARY_POLY_FUNCTION(
Innermost_leading_coefficient,
innermost_leading_coefficient)
// Canonicalize
CGAL_UNARY_POLY_FUNCTION(Canonicalize, canonicalize)
// Differentiate
CGAL_UNARY_POLY_FUNCTION_INDEX(Differentiate, differentiate)
// Evaluate
CGAL_BINARY_POLY_FUNCTION(Evaluate,evaluate)
// EvaluateHomogeneous
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
template <typename Polynomial_d, typename T> inline
Integrate Instant-Meshes 1. Drop windows 32bit support Add windows 64bit support. 2. Remove Script(quickjs) support The current integrated quickjs is a very old version which doesn’t support windows 64bit system. In the future, (TODO)WebAssembly should be integrate as plugin system. 3. Integrate Instant-Meshes Instant-Meshes take less than 1 second on all three platforms. 4. Remove QuadriFlow Current implementation of QuadriFlow is too slow (take about 5 seconds on the example model) to do realtime remeshing.
2020-01-04 10:29:10 +00:00
typename Polynomial_traits_d<Polynomial_d>::Evaluate_homogeneous::result_type
evaluate_homogeneous(const Polynomial_d& p,const T& num, const T& den){
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
typedef Polynomial_traits_d<Polynomial_d> PT;
return typename PT::Evaluate_homogeneous()(p,num,den);
}
Integrate Instant-Meshes 1. Drop windows 32bit support Add windows 64bit support. 2. Remove Script(quickjs) support The current integrated quickjs is a very old version which doesn’t support windows 64bit system. In the future, (TODO)WebAssembly should be integrate as plugin system. 3. Integrate Instant-Meshes Instant-Meshes take less than 1 second on all three platforms. 4. Remove QuadriFlow Current implementation of QuadriFlow is too slow (take about 5 seconds on the example model) to do realtime remeshing.
2020-01-04 10:29:10 +00:00
// Substitute
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
template <typename Polynomial_d, typename Input_iterator> inline
Integrate Instant-Meshes 1. Drop windows 32bit support Add windows 64bit support. 2. Remove Script(quickjs) support The current integrated quickjs is a very old version which doesn’t support windows 64bit system. In the future, (TODO)WebAssembly should be integrate as plugin system. 3. Integrate Instant-Meshes Instant-Meshes take less than 1 second on all three platforms. 4. Remove QuadriFlow Current implementation of QuadriFlow is too slow (take about 5 seconds on the example model) to do realtime remeshing.
2020-01-04 10:29:10 +00:00
typename CGAL::Coercion_traits<
typename Polynomial_traits_d<Polynomial_d>::Innermost_coefficient_type,
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
typename std::iterator_traits<Input_iterator>::value_type>
::Type
Integrate Instant-Meshes 1. Drop windows 32bit support Add windows 64bit support. 2. Remove Script(quickjs) support The current integrated quickjs is a very old version which doesn’t support windows 64bit system. In the future, (TODO)WebAssembly should be integrate as plugin system. 3. Integrate Instant-Meshes Instant-Meshes take less than 1 second on all three platforms. 4. Remove QuadriFlow Current implementation of QuadriFlow is too slow (take about 5 seconds on the example model) to do realtime remeshing.
2020-01-04 10:29:10 +00:00
substitute(const Polynomial_d& p,Input_iterator begin, Input_iterator end){
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
typedef Polynomial_traits_d<Polynomial_d> PT;
return typename PT::Substitute()(p,begin, 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
// IsZeroAt
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
template <typename Polynomial_d, typename Input_iterator> inline
Integrate Instant-Meshes 1. Drop windows 32bit support Add windows 64bit support. 2. Remove Script(quickjs) support The current integrated quickjs is a very old version which doesn’t support windows 64bit system. In the future, (TODO)WebAssembly should be integrate as plugin system. 3. Integrate Instant-Meshes Instant-Meshes take less than 1 second on all three platforms. 4. Remove QuadriFlow Current implementation of QuadriFlow is too slow (take about 5 seconds on the example model) to do realtime remeshing.
2020-01-04 10:29:10 +00:00
typename Polynomial_traits_d<Polynomial_d>::Is_zero_at::result_type
is_zero_at(const Polynomial_d& p, Input_iterator begin, Input_iterator end){
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
typedef Polynomial_traits_d<Polynomial_d> PT;
return typename PT::Is_zero_at()(p,begin, 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
// SignAt
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
template <typename Polynomial_d, typename Input_iterator> inline
Integrate Instant-Meshes 1. Drop windows 32bit support Add windows 64bit support. 2. Remove Script(quickjs) support The current integrated quickjs is a very old version which doesn’t support windows 64bit system. In the future, (TODO)WebAssembly should be integrate as plugin system. 3. Integrate Instant-Meshes Instant-Meshes take less than 1 second on all three platforms. 4. Remove QuadriFlow Current implementation of QuadriFlow is too slow (take about 5 seconds on the example model) to do realtime remeshing.
2020-01-04 10:29:10 +00:00
typename Polynomial_traits_d<Polynomial_d>::Sign_at::result_type
sign_at(const Polynomial_d& p, Input_iterator begin, Input_iterator end){
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
typedef Polynomial_traits_d<Polynomial_d> PT;
return typename PT::Sign_at()(p,begin, 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
// SubstituteHomogeneous
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
template <typename Polynomial_d, typename Input_iterator> inline
Integrate Instant-Meshes 1. Drop windows 32bit support Add windows 64bit support. 2. Remove Script(quickjs) support The current integrated quickjs is a very old version which doesn’t support windows 64bit system. In the future, (TODO)WebAssembly should be integrate as plugin system. 3. Integrate Instant-Meshes Instant-Meshes take less than 1 second on all three platforms. 4. Remove QuadriFlow Current implementation of QuadriFlow is too slow (take about 5 seconds on the example model) to do realtime remeshing.
2020-01-04 10:29:10 +00:00
typename CGAL::Coercion_traits<
typename Polynomial_traits_d<Polynomial_d>::Innermost_coefficient_type,
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
typename std::iterator_traits<Input_iterator>::value_type>
::Type
Integrate Instant-Meshes 1. Drop windows 32bit support Add windows 64bit support. 2. Remove Script(quickjs) support The current integrated quickjs is a very old version which doesn’t support windows 64bit system. In the future, (TODO)WebAssembly should be integrate as plugin system. 3. Integrate Instant-Meshes Instant-Meshes take less than 1 second on all three platforms. 4. Remove QuadriFlow Current implementation of QuadriFlow is too slow (take about 5 seconds on the example model) to do realtime remeshing.
2020-01-04 10:29:10 +00:00
substitute_homogeneous(
const Polynomial_d& p,Input_iterator begin, Input_iterator end){
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
typedef Polynomial_traits_d<Polynomial_d> PT;
Integrate Instant-Meshes 1. Drop windows 32bit support Add windows 64bit support. 2. Remove Script(quickjs) support The current integrated quickjs is a very old version which doesn’t support windows 64bit system. In the future, (TODO)WebAssembly should be integrate as plugin system. 3. Integrate Instant-Meshes Instant-Meshes take less than 1 second on all three platforms. 4. Remove QuadriFlow Current implementation of 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 typename PT::Substitute_homogeneous()(p,begin, end);
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
// IsZeroAtHomogeneous
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
template <typename Polynomial_d, typename Input_iterator> inline
Integrate Instant-Meshes 1. Drop windows 32bit support Add windows 64bit support. 2. Remove Script(quickjs) support The current integrated quickjs is a very old version which doesn’t support windows 64bit system. In the future, (TODO)WebAssembly should be integrate as plugin system. 3. Integrate Instant-Meshes Instant-Meshes take less than 1 second on all three platforms. 4. Remove QuadriFlow Current implementation of QuadriFlow is too slow (take about 5 seconds on the example model) to do realtime remeshing.
2020-01-04 10:29:10 +00:00
typename Polynomial_traits_d<Polynomial_d>::Is_zero_at_homogeneous::result_type
is_zero_at_homogeneous(
const Polynomial_d& p, Input_iterator begin, Input_iterator end){
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
typedef Polynomial_traits_d<Polynomial_d> PT;
Integrate Instant-Meshes 1. Drop windows 32bit support Add windows 64bit support. 2. Remove Script(quickjs) support The current integrated quickjs is a very old version which doesn’t support windows 64bit system. In the future, (TODO)WebAssembly should be integrate as plugin system. 3. Integrate Instant-Meshes Instant-Meshes take less than 1 second on all three platforms. 4. Remove QuadriFlow Current implementation of 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 typename PT::Is_zero_at_homogeneous()(p,begin, end);
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
// SignAtHomogeneous
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
template <typename Polynomial_d, typename Input_iterator> inline
Integrate Instant-Meshes 1. Drop windows 32bit support Add windows 64bit support. 2. Remove Script(quickjs) support The current integrated quickjs is a very old version which doesn’t support windows 64bit system. In the future, (TODO)WebAssembly should be integrate as plugin system. 3. Integrate Instant-Meshes Instant-Meshes take less than 1 second on all three platforms. 4. Remove QuadriFlow Current implementation of QuadriFlow is too slow (take about 5 seconds on the example model) to do realtime remeshing.
2020-01-04 10:29:10 +00:00
typename Polynomial_traits_d<Polynomial_d>::Sign_at_homogeneous::result_type
sign_at_homogeneous(
const Polynomial_d& p, Input_iterator begin, Input_iterator end){
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
typedef Polynomial_traits_d<Polynomial_d> PT;
return typename PT::Sign_at_homogeneous()(p,begin, 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
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
// Compare // provided by number_type utils
Integrate Instant-Meshes 1. Drop windows 32bit support Add windows 64bit support. 2. Remove Script(quickjs) support The current integrated quickjs is a very old version which doesn’t support windows 64bit system. In the future, (TODO)WebAssembly should be integrate as plugin system. 3. Integrate Instant-Meshes Instant-Meshes take less than 1 second on all three platforms. 4. Remove QuadriFlow Current implementation of 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_BINARY_POLY_FUNCTION(Compare,compare);
// UnivariateContent
CGAL_UNARY_POLY_FUNCTION(Univariate_content, univariate_content)
// MultivariateContent
CGAL_UNARY_POLY_FUNCTION(Multivariate_content, multivariate_content)
// SquareFreeFactorize
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
template <typename Polynomial_d, typename OutputIterator> inline
Integrate Instant-Meshes 1. Drop windows 32bit support Add windows 64bit support. 2. Remove Script(quickjs) support The current integrated quickjs is a very old version which doesn’t support windows 64bit system. In the future, (TODO)WebAssembly should be integrate as plugin system. 3. Integrate Instant-Meshes Instant-Meshes take less than 1 second on all three platforms. 4. Remove QuadriFlow Current implementation of QuadriFlow is too slow (take about 5 seconds on the example model) to do realtime remeshing.
2020-01-04 10:29:10 +00:00
OutputIterator
square_free_factorize(const Polynomial_d& p, OutputIterator oi){
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
typedef Polynomial_traits_d<Polynomial_d> PT;
return typename PT::Square_free_factorize()(p,oi);
}
Integrate Instant-Meshes 1. Drop windows 32bit support Add windows 64bit support. 2. Remove Script(quickjs) support The current integrated quickjs is a very old version which doesn’t support windows 64bit system. In the future, (TODO)WebAssembly should be integrate as plugin system. 3. Integrate Instant-Meshes Instant-Meshes take less than 1 second on all three platforms. 4. Remove QuadriFlow Current implementation of QuadriFlow is too slow (take about 5 seconds on the example model) to do realtime remeshing.
2020-01-04 10:29:10 +00:00
// MakeSquareFree
CGAL_UNARY_POLY_FUNCTION(Make_square_free, make_square_free)
// IsSquareFree
CGAL_UNARY_POLY_FUNCTION(Is_square_free, is_square_free)
// PseudoDivision
// PseudoDivisionQuotient
// PseudoDivisionRemainder
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
template <typename Polynomial_d> inline
void
Integrate Instant-Meshes 1. Drop windows 32bit support Add windows 64bit support. 2. Remove Script(quickjs) support The current integrated quickjs is a very old version which doesn’t support windows 64bit system. In the future, (TODO)WebAssembly should be integrate as plugin system. 3. Integrate Instant-Meshes Instant-Meshes take less than 1 second on all three platforms. 4. Remove QuadriFlow Current implementation of QuadriFlow is too slow (take about 5 seconds on the example model) to do realtime remeshing.
2020-01-04 10:29:10 +00:00
pseudo_division(
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
const Polynomial_d& f, const Polynomial_d& g,
Polynomial_d& q, Polynomial_d& r,
Integrate Instant-Meshes 1. Drop windows 32bit support Add windows 64bit support. 2. Remove Script(quickjs) support The current integrated quickjs is a very old version which doesn’t support windows 64bit system. In the future, (TODO)WebAssembly should be integrate as plugin system. 3. Integrate Instant-Meshes Instant-Meshes take less than 1 second on all three platforms. 4. Remove QuadriFlow Current implementation of 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 Polynomial_traits_d<Polynomial_d>::Coefficient_type& D){
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
typedef Polynomial_traits_d<Polynomial_d> PT;
typename PT::Pseudo_division()(f,g,q,r,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
return;
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
}
template <typename Polynomial_d> inline
Integrate Instant-Meshes 1. Drop windows 32bit support Add windows 64bit support. 2. Remove Script(quickjs) support The current integrated quickjs is a very old version which doesn’t support windows 64bit system. In the future, (TODO)WebAssembly should be integrate as plugin system. 3. Integrate Instant-Meshes Instant-Meshes take less than 1 second on all three platforms. 4. Remove QuadriFlow Current implementation of QuadriFlow is too slow (take about 5 seconds on the example model) to do realtime remeshing.
2020-01-04 10:29:10 +00:00
typename Polynomial_traits_d<Polynomial_d>::Pseudo_division_quotient::result_type
pseudo_division_quotient(const Polynomial_d& f, const Polynomial_d& g){
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
typedef Polynomial_traits_d<Polynomial_d> PT;
return typename PT::Pseudo_division_quotient()(f,g);
}
template <typename Polynomial_d> inline
Integrate Instant-Meshes 1. Drop windows 32bit support Add windows 64bit support. 2. Remove Script(quickjs) support The current integrated quickjs is a very old version which doesn’t support windows 64bit system. In the future, (TODO)WebAssembly should be integrate as plugin system. 3. Integrate Instant-Meshes Instant-Meshes take less than 1 second on all three platforms. 4. Remove QuadriFlow Current implementation of QuadriFlow is too slow (take about 5 seconds on the example model) to do realtime remeshing.
2020-01-04 10:29:10 +00:00
typename Polynomial_traits_d<Polynomial_d>::Pseudo_division_remainder::result_type
pseudo_division_remainder(const Polynomial_d& f, const Polynomial_d& g){
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
typedef Polynomial_traits_d<Polynomial_d> PT;
return typename PT::Pseudo_division_remainder()(f,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
// GcdUpToConstantFactor
CGAL_BINARY_POLY_FUNCTION(
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
Gcd_up_to_constant_factor,
Integrate Instant-Meshes 1. Drop windows 32bit support Add windows 64bit support. 2. Remove Script(quickjs) support The current integrated quickjs is a very old version which doesn’t support windows 64bit system. In the future, (TODO)WebAssembly should be integrate as plugin system. 3. Integrate Instant-Meshes Instant-Meshes take less than 1 second on all three platforms. 4. Remove QuadriFlow Current implementation of QuadriFlow is too slow (take about 5 seconds on the example model) to do realtime remeshing.
2020-01-04 10:29:10 +00:00
gcd_up_to_constant_factor)
// IntegralDivisionUpToConstantFactor
CGAL_BINARY_POLY_FUNCTION(
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
Integral_division_up_to_constant_factor,
Integrate Instant-Meshes 1. Drop windows 32bit support Add windows 64bit support. 2. Remove Script(quickjs) support The current integrated quickjs is a very old version which doesn’t support windows 64bit system. In the future, (TODO)WebAssembly should be integrate as plugin system. 3. Integrate Instant-Meshes Instant-Meshes take less than 1 second on all three platforms. 4. Remove QuadriFlow Current implementation of QuadriFlow is too slow (take about 5 seconds on the example model) to do realtime remeshing.
2020-01-04 10:29:10 +00:00
integral_division_up_to_constant_factor)
// UnivariateContentUpToConstantFactor
CGAL_UNARY_POLY_FUNCTION(
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
Univariate_content_up_to_constant_factor,
Integrate Instant-Meshes 1. Drop windows 32bit support Add windows 64bit support. 2. Remove Script(quickjs) support The current integrated quickjs is a very old version which doesn’t support windows 64bit system. In the future, (TODO)WebAssembly should be integrate as plugin system. 3. Integrate Instant-Meshes Instant-Meshes take less than 1 second on all three platforms. 4. Remove QuadriFlow Current implementation of QuadriFlow is too slow (take about 5 seconds on the example model) to do realtime remeshing.
2020-01-04 10:29:10 +00:00
univariate_content_up_to_constant_factor)
// SquareFreeFactorizeUpToConstantFactor
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
template <typename Polynomial_d, typename OutputIterator> inline
Integrate Instant-Meshes 1. Drop windows 32bit support Add windows 64bit support. 2. Remove Script(quickjs) support The current integrated quickjs is a very old version which doesn’t support windows 64bit system. In the future, (TODO)WebAssembly should be integrate as plugin system. 3. Integrate Instant-Meshes Instant-Meshes take less than 1 second on all three platforms. 4. Remove QuadriFlow Current implementation of QuadriFlow is too slow (take about 5 seconds on the example model) to do realtime remeshing.
2020-01-04 10:29:10 +00:00
OutputIterator
square_free_factorize_up_to_constant_factor(
const Polynomial_d& p, OutputIterator oi){
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
typedef Polynomial_traits_d<Polynomial_d> PT;
Integrate Instant-Meshes 1. Drop windows 32bit support Add windows 64bit support. 2. Remove Script(quickjs) support The current integrated quickjs is a very old version which doesn’t support windows 64bit system. In the future, (TODO)WebAssembly should be integrate as plugin system. 3. Integrate Instant-Meshes Instant-Meshes take less than 1 second on all three platforms. 4. Remove QuadriFlow Current implementation of 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 typename PT::Square_free_factorize_up_to_constant_factor()(p,oi);
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
// Shift
CGAL_BINARY_POLY_FUNCTION_INDEX(Shift,shift)
// Negate
CGAL_UNARY_POLY_FUNCTION_INDEX(Negate,negate)
// Invert
CGAL_UNARY_POLY_FUNCTION_INDEX(Invert,invert)
// Translate
CGAL_BINARY_POLY_FUNCTION_INDEX(Translate,translate)
// TranslateHomogeneous
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
template <typename Polynomial_d> inline
Integrate Instant-Meshes 1. Drop windows 32bit support Add windows 64bit support. 2. Remove Script(quickjs) support The current integrated quickjs is a very old version which doesn’t support windows 64bit system. In the future, (TODO)WebAssembly should be integrate as plugin system. 3. Integrate Instant-Meshes Instant-Meshes take less than 1 second on all three platforms. 4. Remove QuadriFlow Current implementation of QuadriFlow is too slow (take about 5 seconds on the example model) to do realtime remeshing.
2020-01-04 10:29:10 +00:00
typename Polynomial_traits_d<Polynomial_d>::Translate_homogeneous::result_type
translate_homogeneous(const Polynomial_d& f,
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
const typename Polynomial_traits_d<Polynomial_d>::Innermost_coefficient_type& num,
Integrate Instant-Meshes 1. Drop windows 32bit support Add windows 64bit support. 2. Remove Script(quickjs) support The current integrated quickjs is a very old version which doesn’t support windows 64bit system. In the future, (TODO)WebAssembly should be integrate as plugin system. 3. Integrate Instant-Meshes Instant-Meshes take less than 1 second on all three platforms. 4. Remove QuadriFlow Current implementation of 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 typename Polynomial_traits_d<Polynomial_d>::Innermost_coefficient_type& den){
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
typedef Polynomial_traits_d<Polynomial_d> PT;
return typename PT::Translate_homogeneous()(f,num,den);
}
template <typename Polynomial_d> inline
Integrate Instant-Meshes 1. Drop windows 32bit support Add windows 64bit support. 2. Remove Script(quickjs) support The current integrated quickjs is a very old version which doesn’t support windows 64bit system. In the future, (TODO)WebAssembly should be integrate as plugin system. 3. Integrate Instant-Meshes Instant-Meshes take less than 1 second on all three platforms. 4. Remove QuadriFlow Current implementation of QuadriFlow is too slow (take about 5 seconds on the example model) to do realtime remeshing.
2020-01-04 10:29:10 +00:00
typename Polynomial_traits_d<Polynomial_d>::Translate_homogeneous::result_type
translate_homogeneous(const Polynomial_d& f,
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
const typename Polynomial_traits_d<Polynomial_d>::Innermost_coefficient_type& num,
Integrate Instant-Meshes 1. Drop windows 32bit support Add windows 64bit support. 2. Remove Script(quickjs) support The current integrated quickjs is a very old version which doesn’t support windows 64bit system. In the future, (TODO)WebAssembly should be integrate as plugin system. 3. Integrate Instant-Meshes Instant-Meshes take less than 1 second on all three platforms. 4. Remove QuadriFlow Current implementation of 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 typename Polynomial_traits_d<Polynomial_d>::Innermost_coefficient_type& den,
int index ){
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
typedef Polynomial_traits_d<Polynomial_d> PT;
Integrate Instant-Meshes 1. Drop windows 32bit support Add windows 64bit support. 2. Remove Script(quickjs) support The current integrated quickjs is a very old version which doesn’t support windows 64bit system. In the future, (TODO)WebAssembly should be integrate as plugin system. 3. Integrate Instant-Meshes Instant-Meshes take less than 1 second on all three platforms. 4. Remove QuadriFlow Current implementation of 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 typename PT::Translate_homogeneous()(f,num,den,index);
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
// Scale
CGAL_BINARY_POLY_FUNCTION_INDEX(Scale,scale)
// ScaleHomogeneous
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
template <typename Polynomial_d> inline
Integrate Instant-Meshes 1. Drop windows 32bit support Add windows 64bit support. 2. Remove Script(quickjs) support The current integrated quickjs is a very old version which doesn’t support windows 64bit system. In the future, (TODO)WebAssembly should be integrate as plugin system. 3. Integrate Instant-Meshes Instant-Meshes take less than 1 second on all three platforms. 4. Remove QuadriFlow Current implementation of QuadriFlow is too slow (take about 5 seconds on the example model) to do realtime remeshing.
2020-01-04 10:29:10 +00:00
typename Polynomial_traits_d<Polynomial_d>::Scale_homogeneous::result_type
scale_homogeneous(const Polynomial_d& f,
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
const typename Polynomial_traits_d<Polynomial_d>::Innermost_coefficient_type& num,
Integrate Instant-Meshes 1. Drop windows 32bit support Add windows 64bit support. 2. Remove Script(quickjs) support The current integrated quickjs is a very old version which doesn’t support windows 64bit system. In the future, (TODO)WebAssembly should be integrate as plugin system. 3. Integrate Instant-Meshes Instant-Meshes take less than 1 second on all three platforms. 4. Remove QuadriFlow Current implementation of 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 typename Polynomial_traits_d<Polynomial_d>::Innermost_coefficient_type& den){
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
typedef Polynomial_traits_d<Polynomial_d> PT;
return typename PT::Scale_homogeneous()(f,num,den);
}
template <typename Polynomial_d> inline
Integrate Instant-Meshes 1. Drop windows 32bit support Add windows 64bit support. 2. Remove Script(quickjs) support The current integrated quickjs is a very old version which doesn’t support windows 64bit system. In the future, (TODO)WebAssembly should be integrate as plugin system. 3. Integrate Instant-Meshes Instant-Meshes take less than 1 second on all three platforms. 4. Remove QuadriFlow Current implementation of QuadriFlow is too slow (take about 5 seconds on the example model) to do realtime remeshing.
2020-01-04 10:29:10 +00:00
typename Polynomial_traits_d<Polynomial_d>::Scale_homogeneous::result_type
scale_homogeneous(const Polynomial_d& f,
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
const typename Polynomial_traits_d<Polynomial_d>::Innermost_coefficient_type& num,
Integrate Instant-Meshes 1. Drop windows 32bit support Add windows 64bit support. 2. Remove Script(quickjs) support The current integrated quickjs is a very old version which doesn’t support windows 64bit system. In the future, (TODO)WebAssembly should be integrate as plugin system. 3. Integrate Instant-Meshes Instant-Meshes take less than 1 second on all three platforms. 4. Remove QuadriFlow Current implementation of 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 typename Polynomial_traits_d<Polynomial_d>::Innermost_coefficient_type& den,
int index ){
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
typedef Polynomial_traits_d<Polynomial_d> PT;
Integrate Instant-Meshes 1. Drop windows 32bit support Add windows 64bit support. 2. Remove Script(quickjs) support The current integrated quickjs is a very old version which doesn’t support windows 64bit system. In the future, (TODO)WebAssembly should be integrate as plugin system. 3. Integrate Instant-Meshes Instant-Meshes take less than 1 second on all three platforms. 4. Remove QuadriFlow Current implementation of 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 typename PT::Scale_homogeneous()(f,num,den,index);
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
// Resultant
CGAL_BINARY_POLY_FUNCTION(Resultant,resultant)
template <typename Polynomial_d,typename OutputIterator> inline
OutputIterator polynomial_subresultants
(Polynomial_d p, Polynomial_d q, OutputIterator out) {
typedef Polynomial_traits_d<Polynomial_d> PT;
return typename PT::Polynomial_subresultants() (p, q, out);
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
}
Integrate Instant-Meshes 1. Drop windows 32bit support Add windows 64bit support. 2. Remove Script(quickjs) support The current integrated quickjs is a very old version which doesn’t support windows 64bit system. In the future, (TODO)WebAssembly should be integrate as plugin system. 3. Integrate Instant-Meshes Instant-Meshes take less than 1 second on all three platforms. 4. Remove QuadriFlow Current implementation of QuadriFlow is too slow (take about 5 seconds on the example model) to do realtime remeshing.
2020-01-04 10:29:10 +00:00
template <typename Polynomial_d,typename OutputIterator> inline
OutputIterator principal_subresultants
(Polynomial_d p, Polynomial_d q, OutputIterator out) {
typedef Polynomial_traits_d<Polynomial_d> PT;
return typename PT::Principal_subresultants() (p, q, out);
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
}
Integrate Instant-Meshes 1. Drop windows 32bit support Add windows 64bit support. 2. Remove Script(quickjs) support The current integrated quickjs is a very old version which doesn’t support windows 64bit system. In the future, (TODO)WebAssembly should be integrate as plugin system. 3. Integrate Instant-Meshes Instant-Meshes take less than 1 second on all three platforms. 4. Remove QuadriFlow Current implementation of QuadriFlow is too slow (take about 5 seconds on the example model) to do realtime remeshing.
2020-01-04 10:29:10 +00:00
template<typename Polynomial_d,
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
typename OutputIterator1,
Integrate Instant-Meshes 1. Drop windows 32bit support Add windows 64bit support. 2. Remove Script(quickjs) support The current integrated quickjs is a very old version which doesn’t support windows 64bit system. In the future, (TODO)WebAssembly should be integrate as plugin system. 3. Integrate Instant-Meshes Instant-Meshes take less than 1 second on all three platforms. 4. Remove QuadriFlow Current implementation of 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 OutputIterator2,
typename OutputIterator3> inline
OutputIterator1 polynomial_subresultants_with_cofactors
(Polynomial_d p,
Polynomial_d q,
OutputIterator1 sres_out,
OutputIterator2 coP_out,
OutputIterator3 coQ_out) {
typedef Polynomial_traits_d<Polynomial_d> PT;
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
return typename PT::Polynomial_subresultants_with_cofactors()
Integrate Instant-Meshes 1. Drop windows 32bit support Add windows 64bit support. 2. Remove Script(quickjs) support The current integrated quickjs is a very old version which doesn’t support windows 64bit system. In the future, (TODO)WebAssembly should be integrate as plugin system. 3. Integrate Instant-Meshes Instant-Meshes take less than 1 second on all three platforms. 4. Remove QuadriFlow Current implementation of QuadriFlow is too slow (take about 5 seconds on the example model) to do realtime remeshing.
2020-01-04 10:29:10 +00:00
(p, q, sres_out, coP_out, coQ_out);
}
template <typename Polynomial_d,typename OutputIterator> inline
OutputIterator
principal_sturm_habicht_sequence
(Polynomial_d f, OutputIterator out){
typedef Polynomial_traits_d<Polynomial_d> PT;
return typename PT::Principal_sturm_habicht_sequence() (f, out);
}
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
Integrate Instant-Meshes 1. Drop windows 32bit support Add windows 64bit support. 2. Remove Script(quickjs) support The current integrated quickjs is a very old version which doesn’t support windows 64bit system. In the future, (TODO)WebAssembly should be integrate as plugin system. 3. Integrate Instant-Meshes Instant-Meshes take less than 1 second on all three platforms. 4. Remove QuadriFlow Current implementation of QuadriFlow is too slow (take about 5 seconds on the example model) to do realtime remeshing.
2020-01-04 10:29:10 +00:00
template<typename Polynomial_d,typename OutputIterator> OutputIterator
sturm_habicht_sequence(Polynomial_d f,OutputIterator out) {
typedef Polynomial_traits_d<Polynomial_d> PT;
return typename PT::Sturm_habicht_sequence() (f, out);
}
template<typename Polynomial_d,
typename OutputIterator1,
typename OutputIterator2,
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
typename OutputIterator3>
Integrate Instant-Meshes 1. Drop windows 32bit support Add windows 64bit support. 2. Remove Script(quickjs) support The current integrated quickjs is a very old version which doesn’t support windows 64bit system. In the future, (TODO)WebAssembly should be integrate as plugin system. 3. Integrate Instant-Meshes Instant-Meshes take less than 1 second on all three platforms. 4. Remove QuadriFlow Current implementation of QuadriFlow is too slow (take about 5 seconds on the example model) to do realtime remeshing.
2020-01-04 10:29:10 +00:00
OutputIterator1
sturm_habicht_sequence_with_cofactors
(Polynomial_d f,
OutputIterator1 stha_out,
OutputIterator2 cof_out,
OutputIterator3 cofx_out) {
typedef Polynomial_traits_d<Polynomial_d> PT;
Update CGAL to 5.1
2020-10-13 12:44:25 +00:00
return typename PT::Sturm_habicht_sequence_with_cofactors()
Integrate Instant-Meshes 1. Drop windows 32bit support Add windows 64bit support. 2. Remove Script(quickjs) support The current integrated quickjs is a very old version which doesn’t support windows 64bit system. In the future, (TODO)WebAssembly should be integrate as plugin system. 3. Integrate Instant-Meshes Instant-Meshes take less than 1 second on all three platforms. 4. Remove QuadriFlow Current implementation of QuadriFlow is too slow (take about 5 seconds on the example model) to do realtime remeshing.
2020-01-04 10:29:10 +00:00
(f, stha_out, cof_out, cofx_out);
}
// TODO: REMOVE function below ?
template<typename NT> inline
Polynomial<NT> scale_up(const Polynomial<NT>& p, const NT& a)
{ Polynomial<NT> q(p); q.scale_up(a); return q; }
template<typename NT> inline
Polynomial<NT> scale_down(const Polynomial<NT>& p, const NT& b)
{ Polynomial<NT> q(p); q.scale_down(b); return q; }
template<typename NT> inline
Polynomial<NT> translate_by_one(const Polynomial<NT>& p)
{ Polynomial<NT> q(p); q.translate_by_one(); return q; }
template<typename NT> inline
Polynomial<NT> reversal(const Polynomial<NT>& p)
{ Polynomial<NT> q(p); q.reversal(); return q; }
} //namespace CGAL
#undef CGAL_UNARY_POLY_FUNCTION
#undef CGAL_UNARY_POLY_FUNCTION_INDEX
#undef CGAL_BINARY_POLY_FUNCTION
#undef CGAL_BINARY_POLY_FUNCTION_INDEX
#endif // CGAL_POLYNOMIAL_UTILS_H