include/shape/ssi/ssi_dsearch.hpp File Reference

#include <shape/ssi/ssi_def.hpp>
#include <shape/ssi/ssi_qsegment.hpp>
#include <list>
#include <queue>
#include <shape/ssi/ssi_ordered_pair.hpp>
#include <shape/ssi/ssi_tri_tri.hpp>
#include <shape/ssi/ssi_math.hpp>

Go to the source code of this file.

Classes

struct dcurve
struct dim_cmp< DPoint >
struct sdpoint_t
struct pdpoint_t
struct sdknode
struct pdknode
struct assoc_t< DPoint >
struct pair_cmp
struct dist_cmp
struct dsearch< C, V >

Namespaces

namespace mmx
namespace mmx::ssi

Defines

#define TMPL template<class C,class V>
#define SHIFT 3
#define __up__ 0
#define __down__ 1
#define __up__triangle__(q) q[0],q[3],q[2]
#define __down__triangle__(q) q[0],q[1],q[2]
#define __up__param_triangle__(q) q[3],q[2],q[0]
#define __down__param_triangle__(q) q[1],q[0],q[2]
#define __convert_order__(i, point) { point[(i+1)%2] = 1.0-point[(i+1)%2]; }
#define __triangle_triangle_case__(trig0, trig1)
#define push_s push
#define push_f push
#define VOISINS_AUSSI

Typedefs

typedef std::list< point2 > list2_t
typedef std::list< point3 > list3_t
typedef list2_t::iterator p2ref_t
typedef std::priority_queue
< assoc_t< pdpoint_t >
, std::vector< assoc_t
< pdpoint_t > >, assoc_t
< pdpoint_t >::dist_cmp > pheap_t
typedef std::priority_queue
< assoc_t< sdpoint_t >
, std::vector< assoc_t
< sdpoint_t > >, assoc_t
< sdpoint_t >::dist_cmp > sheap_t
typedef std::set< assoc_t
< pdpoint_t >, assoc_t
< pdpoint_t >::pair_cmp > pset_t
typedef assoc_t< sdpoint_t > sdassc_t
typedef assoc_t< pdpoint_t > pdassc_t
typedef std::pair< pdpoint_t
*, pdpoint_t * > ppair_t
typedef std::list< ppair_t > links_t
typedef std::map< dcurve
*, links_t > curves_links_t
typedef ordered_pair< dcurve * > cpair_t
typedef pset_t::iterator pset_iterator

Functions

void space2prm (vector2 &pa, vector2 &pb, const vector3 &sa, const vector3 &sb, const vector3 &base, const vector3 &pu, const vector3 &pv)
template<class DP > double distance (DP *pa, DP *pb)
void append (dcurve *a, dcurve *b)
void prepend (dcurve *a, dcurve *b)
void reverse (dcurve *c)
bool empty (dcurve *c)
pdpoint_t * sibble (pdpoint_t *p)
void extremums (sdpoint_t *dst, dcurve *src)
void extremums (pdpoint_t *dst, dcurve *c)
dcurve * curve (pdpoint_t *p)
dcurve * curve (sdpoint_t *p)
bool isfirst (sdpoint_t *p)
bool islast (sdpoint_t *p)
bool isfirst (pdpoint_t *p)
bool islast (pdpoint_t *p)
bool isextrem (pdpoint_t *p)
bool isextrem (sdpoint_t *p)
void link (sdpoint_t *a, sdpoint_t *b)
void link (pdpoint_t *a, pdpoint_t *b)
void swap (dcurve *c)
bool isright (pdpoint_t *p)
template<class DPoint > void _link (DPoint *a, DPoint *b)
sdknode * make (sdpoint_t *first, sdpoint_t *last, const dim_cmp< sdpoint_t > &f)
pdknode * make (pdpoint_t **first, pdpoint_t **last, const dim_cmp< pdpoint_t > &f)
void solve_sheap (sheap_t &h)
void solve_pheap (pheap_t &h)
template<class A , class B > void container_add (A &h, const B &a)
void container_add (pset_t &s, const pdassc_t &a)
cpair_t curves (const pdassc_t &ass)
pdassc_t sibbles (const pdassc_t &ass)
void satisfy_links (curves_links_t::iterator it)
void solve_pset (curves_links_t &links, pset_t &s)
std::list< dcurve * > * reduce2 (std::vector< dcurve * > *conflicts)
void build_sheap (sheap_t &h, sdpoint_t *first, sdpoint_t *last, double prec)

Define Documentation

#define __convert_order__	(	i,
		point		)	{ point[(i+1)%2] = 1.0-point[(i+1)%2]; }

Definition at line 24 of file ssi_dsearch.hpp.

#define __down__ 1

Definition at line 15 of file ssi_dsearch.hpp.

Referenced by dsearch< C, V >::push(), and ssiqtsl< C, V >::solve_cf().

#define __down__param_triangle__ ( q ) q[1],q[0],q[2]

Definition at line 23 of file ssi_dsearch.hpp.

#define __down__triangle__ ( q ) q[0],q[1],q[2]

Definition at line 19 of file ssi_dsearch.hpp.

#define __triangle_triangle_case__	(	trig0,
		trig1		)

Value:

{                                                                     \
  if ( geom::intersectp_triangles3_isegment                           \
       ( coplanar, seg[0], seg[1],                                    \
         trig0##triangle__(a),                                        \
         trig1##triangle__(b), point3::value_type(1e-12) ))           \
    {                                                                 \
      if ( !coplanar )                                                \
        {                                                             \
          space2prm(/* points in parameter space */                    \
                 seg0[0], seg0[1],                                    \
                 /* corresponding points in R3 */                     \
                  seg[0],  seg[1],                                    \
                 /* parametric plane = base + 2 vectors  */           \
                 trig0##param_triangle__(a)                           \
                 );                                                   \
          space2prm( seg1[0], seg1[1],                                 \
                    seg[0], seg[1],                                   \
                    trig1##param_triangle__(b) );                     \
          /* retrieve the correct offset coordinates in quad */       \
        __convert_order__(trig0,seg0[0]);                             \
        __convert_order__(trig0,seg0[1]);                             \
        __convert_order__(trig1,seg1[0]);                             \
        __convert_order__(trig1,seg1[1]);                             \
        }                                                             \
    else                                                              \
      {\
        seg0[0][0] = 1.0/3.0; seg0[0][1] = 1.0/3.0;                   \
        seg0[1][0] = 1.0/3.0; seg0[1][0] = 1.0/3.0;                   \
        seg1[0][0] = 1.0/3.0; seg1[0][1] = 1.0/3.0;                   \
        seg1[1][0] = 1.0/3.0; seg1[1][1] = 1.0/3.0;                   \
        __convert_order__(trig0,seg0[0]);                             \
        __convert_order__(trig0,seg0[1]);                             \
        __convert_order__(trig1,seg1[0]);                             \
        __convert_order__(trig1,seg1[1]);                             \
      };                                                              \
        {                                                             \
          f->convert(seg0,this,2);                                    \
          s->convert(seg1,this,2);                                    \
          push( seg0[0], seg0[1], seg1[0], seg1[1], seg[0],seg[1] );  \
        }                                                             \
    };                                                                \
}                                                                     \