mirror of https://github.com/CGAL/cgal
189 lines
7.6 KiB
C++
189 lines
7.6 KiB
C++
// Copyright (c) 2005 Stanford University (USA).
|
|
// All rights reserved.
|
|
//
|
|
// This file is part of CGAL (www.cgal.org); you can redistribute it and/or
|
|
// modify it under the terms of the GNU Lesser General Public License as
|
|
// published by the Free Software Foundation; either version 3 of the License,
|
|
// or (at your option) any later version.
|
|
//
|
|
// Licensees holding a valid commercial license may use this file in
|
|
// accordance with the commercial license agreement provided with the software.
|
|
//
|
|
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
|
|
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
|
|
//
|
|
// $URL$
|
|
// $Id$
|
|
// SPDX-License-Identifier: LGPL-3.0+
|
|
//
|
|
//
|
|
// Author(s) : Daniel Russel <drussel@alumni.princeton.edu>
|
|
|
|
#ifndef CGAL_KINETIC_SIMULATION_TRAITS_H
|
|
#define CGAL_KINETIC_SIMULATION_TRAITS_H
|
|
#include <CGAL/Kinetic/basic.h>
|
|
|
|
#include <CGAL/Polynomial/Sturm_root_stack.h>
|
|
#include <CGAL/Polynomial/Sturm_root_stack_traits.h>
|
|
#include <CGAL/Polynomial/CORE_kernel.h>
|
|
#include <CGAL/Polynomial/Kernel.h>
|
|
#include <CGAL/Polynomial/Numeric_root_stack.h>
|
|
#include <CGAL/Polynomial/Root_stack_default_traits.h>
|
|
|
|
#include <CGAL/Exact_predicates_exact_constructions_kernel.h>
|
|
#include <CGAL/Cartesian.h>
|
|
#include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
|
|
#include <CGAL/Filtered_kernel.h>
|
|
#include <CGAL/Kinetic/Active_objects_vector.h>
|
|
#include <CGAL/Kinetic/Cartesian_instantaneous_kernel.h>
|
|
#include <CGAL/Kinetic/Cartesian_kinetic_kernel.h>
|
|
#include <CGAL/Kinetic/Derivitive_filter_function_kernel.h>
|
|
#include <CGAL/Kinetic/Handle_degeneracy_function_kernel.h>
|
|
#include <CGAL/Kinetic/Default_simulator.h>
|
|
#include <CGAL/Kinetic/Two_list_pointer_event_queue.h>
|
|
|
|
#include <CGAL/Exact_predicates_exact_constructions_kernel.h>
|
|
//#include <CGAL/Kinetic/Heap_pointer_event_queue.h>
|
|
|
|
|
|
#define CGAL_KINETIC_USE_CORE
|
|
|
|
namespace CGAL { namespace Kinetic {
|
|
|
|
template <class StaticKernel,
|
|
class KineticKernel,
|
|
class SimulatorC>
|
|
struct Simulation_traits
|
|
{
|
|
public:
|
|
|
|
typedef typename StaticKernel::FT NT;
|
|
struct Static_kernel: public StaticKernel {};
|
|
|
|
struct Kinetic_kernel: public KineticKernel {};
|
|
|
|
typedef SimulatorC Simulator;
|
|
|
|
typedef typename KineticKernel::Function_kernel Function_kernel;
|
|
|
|
typedef typename KineticKernel::Function_kernel::Root Time;
|
|
|
|
Simulation_traits(const Time &lb, const Time &ub): sp_(new Simulator(lb, ub, kk_.function_kernel_object())){}
|
|
Simulation_traits(const Time &lb): sp_(new Simulator(lb, kk_.function_kernel_object())) {
|
|
}
|
|
|
|
Simulator* simulator_handle(){ return sp_.get();}
|
|
const Simulator* simulator_handle() const { return sp_.get();}
|
|
const Static_kernel& static_kernel_object(){return k_;}
|
|
const Kinetic_kernel& kinetic_kernel_object(){return kk_;}
|
|
|
|
const Static_kernel& static_kernel_object() const {return k_;}
|
|
const Kinetic_kernel& kinetic_kernel_object() const {return kk_;}
|
|
const Function_kernel& function_kernel_object() const {return fk_;}
|
|
protected:
|
|
Static_kernel k_;
|
|
Kinetic_kernel kk_;
|
|
Function_kernel fk_;
|
|
typename Simulator::Handle sp_;
|
|
};
|
|
|
|
|
|
|
|
#ifndef CGAL_KINETIC_USE_CORE
|
|
struct Suggested_exact_simulation_traits_types
|
|
{
|
|
typedef CGAL::Exact_predicates_exact_constructions_kernel Static_kernel;
|
|
typedef Static_kernel::FT NT;
|
|
|
|
typedef CGAL::POLYNOMIAL::Polynomial<NT> Function;
|
|
typedef CGAL::POLYNOMIAL::Sturm_root_stack_traits<Function> Root_stack_traits;
|
|
typedef CGAL::POLYNOMIAL::Sturm_root_stack<Root_stack_traits> Root_stack;
|
|
typedef CGAL::POLYNOMIAL::Kernel<Function, Root_stack> Function_kernel;
|
|
|
|
typedef CGAL::Kinetic::Handle_degeneracy_function_kernel<Function_kernel, false> Simulator_function_kernel;
|
|
typedef CGAL::Kinetic::Cartesian_kinetic_kernel<Simulator_function_kernel> Kinetic_kernel;
|
|
typedef Simulator_function_kernel::Root Time;
|
|
typedef CGAL::Kinetic::Two_list_pointer_event_queue<Function_kernel> Queue_base;
|
|
|
|
struct Event_queue: public Queue_base
|
|
{
|
|
Event_queue(const Time &start, const Time &end, Function_kernel fk, int num): Queue_base(start, end, fk, num){}
|
|
Event_queue(const Time &start, Function_kernel fk, int num): Queue_base(start, fk, num){}
|
|
};
|
|
|
|
typedef CGAL::Kinetic::Default_simulator<Simulator_function_kernel, Event_queue > Simulator;
|
|
};
|
|
#else
|
|
struct Suggested_exact_simulation_traits_types
|
|
{
|
|
typedef CGAL::POLYNOMIAL::CORE_kernel Function_kernel;
|
|
|
|
typedef CGAL::Filtered_kernel<CGAL::Cartesian<Function_kernel::FT> > Static_kernel;
|
|
|
|
typedef CGAL::Kinetic::Handle_degeneracy_function_kernel<Function_kernel, false> Simulator_function_kernel;
|
|
typedef CGAL::Kinetic::Cartesian_kinetic_kernel<Simulator_function_kernel> Kinetic_kernel;
|
|
typedef Simulator_function_kernel::Root Time;
|
|
typedef CGAL::Kinetic::Two_list_pointer_event_queue<Function_kernel> Queue_base;
|
|
|
|
struct Event_queue: public Queue_base
|
|
{
|
|
Event_queue(const Time &start, const Time &end, Function_kernel fk, int num): Queue_base(start, end, fk, num){}
|
|
Event_queue(const Time &start, Function_kernel fk, int num): Queue_base(start, fk, num){}
|
|
};
|
|
|
|
typedef CGAL::Kinetic::Default_simulator<Simulator_function_kernel, Event_queue > Simulator;
|
|
};
|
|
|
|
#endif
|
|
|
|
struct Suggested_exact_simulation_traits_base: public Simulation_traits<Suggested_exact_simulation_traits_types::Static_kernel,
|
|
Suggested_exact_simulation_traits_types::Kinetic_kernel,
|
|
Suggested_exact_simulation_traits_types::Simulator> {
|
|
typedef Simulation_traits<Suggested_exact_simulation_traits_types::Static_kernel,
|
|
Suggested_exact_simulation_traits_types::Kinetic_kernel,
|
|
Suggested_exact_simulation_traits_types::Simulator> P;
|
|
Suggested_exact_simulation_traits_base(const P::Time &lb, const P::Time &ub): P(lb, ub) {}
|
|
Suggested_exact_simulation_traits_base(const P::Time &lb): P(lb) {}
|
|
bool is_exact() const {
|
|
return true;
|
|
}
|
|
};
|
|
|
|
struct Suggested_inexact_simulation_traits_types
|
|
{
|
|
typedef CGAL::Exact_predicates_inexact_constructions_kernel Static_kernel;
|
|
typedef Static_kernel::FT NT;
|
|
typedef CGAL::POLYNOMIAL::Polynomial<NT> Function;
|
|
typedef CGAL::POLYNOMIAL::Root_stack_default_traits<Function> Root_stack_traits;
|
|
typedef CGAL::POLYNOMIAL::Numeric_root_stack<Root_stack_traits> Root_stack;
|
|
typedef CGAL::POLYNOMIAL::Kernel<Function, Root_stack> Function_kernel;
|
|
typedef CGAL::Kinetic::Derivitive_filter_function_kernel<Function_kernel> Simulator_function_kernel;
|
|
typedef CGAL::Kinetic::Cartesian_kinetic_kernel<Simulator_function_kernel> Kinetic_kernel;
|
|
typedef Simulator_function_kernel::Root Time;
|
|
typedef CGAL::Kinetic::Heap_pointer_event_queue<Function_kernel> Queue_base;
|
|
|
|
struct Event_queue: public Queue_base
|
|
{
|
|
Event_queue(const Time &start, const Time &finish, Function_kernel fk, int num): Queue_base(start, finish, fk, num){}
|
|
Event_queue(const Time &start, Function_kernel fk, int num): Queue_base(start, fk, num){}
|
|
};
|
|
typedef CGAL::Kinetic::Default_simulator<Simulator_function_kernel, Event_queue > Simulator;
|
|
};
|
|
|
|
struct Suggested_inexact_simulation_traits_base: public Simulation_traits<Suggested_inexact_simulation_traits_types::Static_kernel,
|
|
Suggested_inexact_simulation_traits_types::Kinetic_kernel,
|
|
Suggested_inexact_simulation_traits_types::Simulator> {
|
|
typedef Simulation_traits<Suggested_inexact_simulation_traits_types::Static_kernel,
|
|
Suggested_inexact_simulation_traits_types::Kinetic_kernel,
|
|
Suggested_inexact_simulation_traits_types::Simulator> P;
|
|
Suggested_inexact_simulation_traits_base(const P::Time &lb, const P::Time &ub): P(lb, ub) {}
|
|
Suggested_inexact_simulation_traits_base(const P::Time &lb): P(lb) {}
|
|
bool is_exact() const {
|
|
return false;
|
|
}
|
|
};
|
|
|
|
|
|
} } //namespace CGAL::Kinetic
|
|
#endif
|