dsearch< C, V > Struct Template Reference

#include <ssi_dsearch.hpp>

Inheritance diagram for dsearch< C, V >:
qsegment< C, V > lsegment< C, V > sample< C, V >

List of all members.

Public Types

Public Member Functions

Public Attributes

Detailed Description

template<class C, class V>
struct mmx::ssi::dsearch< C, V >

Definition at line 288 of file ssi_dsearch.hpp.

Member Typedef Documentation

typedef coord_t bounds_t[2] [inherited]

Definition at line 26 of file ssi_lsegment.hpp.

typedef lrnode<C,V>* lrtree [inherited]

Definition at line 116 of file ssi_qsegment.hpp.

typedef qsegment<C,V>::ParametricSurface ParametricSurface

Reimplemented from qsegment< C, V >.

Definition at line 290 of file ssi_dsearch.hpp.

typedef qnode<C,V>* qtree

Reimplemented from qsegment< C, V >.

Definition at line 291 of file ssi_dsearch.hpp.

Constructor & Destructor Documentation

dsearch ( const ParametricSurface *  s,
unsigned  w,
unsigned  h,
bool  cnf = false 
) [inline]

Definition at line 360 of file ssi_dsearch.hpp.

References dsearch< C, V >::_branches, dsearch< C, V >::branches(), dsearch< C, V >::conflict_count, dsearch< C, V >::find_branches(), lsegment< C, V >::grp, dsearch< C, V >::lefts, dsearch< C, V >::m_cnf, dsearch< C, V >::nbcurves, dsearch< C, V >::nbpoints, igraph::neighbors(), mmx::ssi::reduce2(), lsegment< C, V >::regions, dsearch< C, V >::result, dsearch< C, V >::rights, dsearch< C, V >::search(), and dsearch< C, V >::sizes.

00360                                                                                        : qsegment<C,V>(s, w, h )
00361 {
00362     m_cnf = cnf;
00363     //    _st = time();
00364     unsigned i,j;
00365     conflict_count = 0;
00366     nbpoints = 0;
00367     _branches = new std::list< dcurve * > *[this->regions.size()*this->regions.size()];
00368     memset(_branches,0,sizeof( std::list< dcurve * > * )*
00369            this->regions.size()*this->regions.size() );
00370 
00371     for ( i = 0; i < this->regions.size() ; i++ )
00372         for ( j = i+1; j < this->regions.size() ; j++   )
00373         {
00374 #define VOISINS_AUSSI
00375 #ifndef VOISINS_AUSSI
00376             if ( !this->grp->neighbors(i,j) )
00377 #endif
00378             {
00379                 //cout << i << " " << j << endl;
00380                 search(i,j);
00381                 find_branches(i,j);
00382             };
00383         };
00384 
00385     //      cout << "search: ok\n";
00386     std::vector< dcurve * > * tmp = new std::vector<dcurve*>();
00387 
00388     for ( i = 0; i < this->regions.size(); i++ )
00389         for ( j = i+1; j < this->regions.size(); j++ )
00390         {
00391             if ( branches(i,j) )
00392             {
00393                 for (  std::list<dcurve*>::iterator it = branches(i,j)->begin(); it != branches(i,j)->end(); it ++ )
00394                 {
00395                     tmp->push_back( *it );
00396                 };
00397                 delete branches(i,j);
00398             }
00399         };
00400 
00401     result = reduce2( tmp );
00402     delete tmp;
00403     nbcurves = 0;
00404     lefts = rights = 0;
00405     sizes = 0;
00406     if ( result )
00407     {
00408         nbpoints = 0;
00409         std::list<dcurve *>::iterator it;
00410         nbcurves = result->size();
00411 
00412         sizes  = new unsigned[nbcurves];
00413 
00414         for ( i = 0, it = result->begin(); it != result->end(); it++ , i++ )
00415         {
00416             sizes[i] = (*it)->left.size();
00417             nbpoints+= sizes[i];
00418         };
00419 
00420         lefts  = new point2*[nbcurves];
00421         rights = new point2*[nbcurves];
00422         unsigned c_n = 0;
00423         unsigned k;
00424         for (  it = result->begin(); it != result->end(); it ++, c_n++  )
00425         {
00426             lefts[c_n]  = new point2[sizes[c_n]];
00427             rights[c_n] = new point2[sizes[c_n]];
00428             list2_t::iterator itcr, itcl;
00429             for ( k = 0, itcl = (*it)->left.begin(), itcr = (*it)->right.begin();
00430                   itcl != (*it)->left.end();
00431                   itcl++ , itcr++, k++ )
00432             {
00433 
00434                 lefts[c_n][k] = *itcl;
00435                 rights[c_n][k] = *itcr;
00436             };
00437         };
00438 
00439         for (  std::list<dcurve*>::iterator it = result->begin(); it!= result->end(); it++ )
00440         {
00441             delete *it;
00442         };
00443         delete result;
00444     };
00445     delete[] _branches;
00446 
00447     //std::cout << "d = " << (time()-_st) << std::endl;
00448     //    std::cout << nbcurves << std::endl;
00449 
00450     //    GnuPlotOutput("dsearch.gmv");
00451 };

~dsearch (  )  [inline]

Definition at line 454 of file ssi_dsearch.hpp.

References dsearch< C, V >::lefts, dsearch< C, V >::nbcurves, dsearch< C, V >::rights, and dsearch< C, V >::sizes.

00455 {
00456     if ( sizes ) delete[] sizes;
00457     if ( lefts )
00458     {
00459         for ( unsigned i = 0; i < nbcurves; i++ )
00460             delete[] lefts[i];
00461         delete[] lefts;
00462     };
00463     if ( rights )
00464     {
00465         for ( unsigned i = 0; i < nbcurves; i++ )
00466             delete[] rights[i];
00467         delete[] rights;
00468     };
00469 
00470 };

Member Function Documentation

void addneighbors ( mark_t *  m0,
mark_t *  m1 
) [inline, inherited]

Definition at line 96 of file ssi_lsegment.hpp.

References igraph::add_link(), mark_t::code, coherent_code(), lsegment< C, V >::grp, and mark_t::head.

Referenced by lsegment< C, V >::find_regions().

00097   {
00098     if ( coherent_code( m0->code, m1->code )  )
00099       {
00100         grp->add_link(m0->head,m1->head);
00101         grp->add_link(m1->head,m0->head);
00102       };
00103   };

vector3* base (  )  const [inline, inherited]

Definition at line 25 of file ssi_sample.hpp.

References sample< C, V >::m_svals.

Referenced by qnode< C, V >::fill(), and lsegment< C, V >::lines_changes().

00025 { return m_svals; };

mark_t* begin ( unsigned  i  )  [inline, inherited]

Definition at line 64 of file ssi_lsegment.hpp.

References lsegment< C, V >::lines, and lsegment< C, V >::marks.

Referenced by lsegment< C, V >::find_regions().

00064 { return &(marks[lines[i]]); };

std::list< dcurve * >*& branches ( unsigned  i,
unsigned  j 
) [inline]

Definition at line 300 of file ssi_dsearch.hpp.

References dsearch< C, V >::_branches, and lsegment< C, V >::regions.

Referenced by dsearch< C, V >::dsearch(), and dsearch< C, V >::find_branches().

00301     { return _branches[i*this->regions.size()+j]; };

void cnfpush ( qtree  f,
qtree  s 
) [inline]

Definition at line 498 of file ssi_dsearch.hpp.

References dsearch< C, V >::cnfdata3, and qnode< C, V >::fill().

00499 {
00500     point3 a[4],b[4]; //      point3 a[4]; point3 b[4];
00501     f->fill(a,this);
00502     s->fill(b,this);
00503     cnfdata3.push_back( ((double)(1.0/4.0))*(a[0]+a[1]+a[2]+a[3]) );
00504 };

void convert_regions (  )  [inline, inherited]

Definition at line 206 of file ssi_lsegment.hpp.

References lsegment< C, V >::promote(), and lsegment< C, V >::regions.

Referenced by lsegment< C, V >::lsegment().

00207     {
00208       for ( unsigned i = 0; i < regions.size(); i++ )
00209         promote( regions[i] );
00210     };

mark_t* end ( unsigned  i  )  [inline, inherited]

Definition at line 65 of file ssi_lsegment.hpp.

Referenced by lsegment< C, V >::find_regions().

00065 { return &(marks[lines[i+1]-1]);};

void find_branches ( rid_t  id0,
rid_t  id1 
) [inline]

Definition at line 325 of file ssi_dsearch.hpp.

References dsearch< C, V >::branches(), dsearch< C, V >::curr_config, and dsearch< C, V >::reduce().

Referenced by dsearch< C, V >::dsearch().

00326     {
00327         branches( id0, id1 ) = reduce( curr_config );
00328         delete curr_config;
00329     };

void find_regions (  )  [inline, inherited]

Definition at line 145 of file ssi_lsegment.hpp.

References mark_t::a(), lsegment< C, V >::addneighbors(), mark_t::b(), lsegment< C, V >::begin(), mark_t::code, mmx::ssi::down(), lsegment< C, V >::end(), mark_t::head, INTERVALTEST, sample< C, V >::ncols(), mark_t::next, sample< C, V >::nrows(), lsegment< C, V >::pushr(), lsegment< C, V >::regions, and mmx::ssi::up().

Referenced by lsegment< C, V >::lsegment().

00146   {
00147     mark_t * p;
00148     for ( p = begin(0); p != end(0); p++ )
00149       pushr(0,p);
00150     for ( p = begin(0)+1; p != end(0); p++ )
00151       addneighbors(p,p-1);
00152 
00153     int ncolsTemp = this->ncols();
00154     mark_t * neighbors[ncolsTemp];
00155     unsigned n_neigh;
00156     coord_t i;
00157 #define INTERVALTEST ( std::abs(std::min(down->b(),up->b())-std::max(down->a(),up->a())) > 1 )
00158     for ( i = 0; i < this->nrows()-2; i++ )
00159       {
00160         mark_t * startup = begin(i);
00161         for ( mark_t * down = begin(i+1); down != end(i+1); down++ )
00162           {
00163             while ( startup->b() <= down->a() ) startup++;
00164             mark_t * up = startup;
00165             n_neigh = 0;
00166             while( down->b() > up->a() )
00167               if ( (up->next == 0) && ( up->code == down->code ) && INTERVALTEST)
00168                 {
00169                   regions[up->head]._umax++;
00170                   up->next = down;
00171                   down->head = up->head, up++;
00172                   break;
00173                 }
00174               else
00175                 neighbors[n_neigh++] = up, up++;
00176 
00177               if ( down->head == -1 ) pushr( i+1, down );
00178 
00179               for ( unsigned k = 0; k < n_neigh; k ++ ) addneighbors(down,neighbors[k]);
00180               while( down->b() > up->a() ) addneighbors(down,up), up++;
00181           };
00182       };
00183   };

void GnuPlotOutput ( char *  name  )  [inline]

Definition at line 473 of file ssi_dsearch.hpp.

00474 {
00475     /*
00476     gmv::stream out(name);
00477 
00478     std::vector< vector3 > v;
00479     for ( unsigned i = 0; i < nbcurves; i++ )
00480       {
00481         for ( unsigned k = 0; k < sizes[i]; k++ )
00482           {
00483             v.push_back(vector3());
00484             v.back()[0] = lefts[i][k][0];
00485             v.back()[1] = lefts[i][k][1];
00486             v.back()[2] = 0;
00487             v.push_back(vector3());
00488             v.back()[0] = rights[i][k][0];
00489             v.back()[1] = rights[i][k][1];
00490             v.back()[2] = 0;
00491           };
00492       };
00493     out.points(&(v[0][0]),v.size());
00494     */
00495 }

void lines_changes (  )  [inline, inherited]

Definition at line 119 of file ssi_lsegment.hpp.

References sample< C, V >::base(), lsegment< C, V >::lines, lsegment< C, V >::marks, sample< C, V >::ncols(), lsegment< C, V >::nmarks(), sample< C, V >::nrows(), lsegment< C, V >::pushm(), realloc(), and vcode().

Referenced by lsegment< C, V >::lsegment().

00120   {
00121     int i,j;
00122     lines = (unsigned*)(malloc(sizeof(unsigned)*this->nrows()));
00123     unsigned max_marks = this->nrows()*this->ncols();
00124     while ( !(marks = (mark_t*)(malloc(sizeof(mark_t)*max_marks))) ) max_marks >>= 1;
00125     vector3 * ptr  = this->base();
00126     for ( i = 0; i < this->nrows()-1; i++ )
00127       {
00128         lines[i] = this->nmarks();
00129         vcode_t code = vcode(*ptr,*(ptr+this->ncols()),*(ptr+1));
00130         pushm(code,0);
00131         for (  j = 0; j < this->ncols()-1; j++, ptr++ )
00132           {
00133             vcode_t tmp = vcode(*ptr,*(ptr+this->ncols()),*(ptr+1));
00134             if ( tmp != code )
00135               { code = tmp; this->pushm(code,j); };
00136           };
00137         pushm(code,this->ncols()-1);
00138         ptr++;
00139       };
00140     lines[this->nrows()-1] = nmarks();
00141     marks = (mark_t*)realloc(marks,sizeof(mark_t)*nmarks());
00142   };

qnode< C, V > * make ( rid_t  id,
coord_t  vmin,
coord_t  vmax,
lrnode< C, V > *  lr 
) [inline, inherited]

Definition at line 155 of file ssi_qsegment.hpp.

References qnode< C, V >::box, qnode< C, V >::father, mmx::hull(), qnode< C, V >::l, lrnode< C, V >::ls, qnode< C, V >::mbox(), qnode< C, V >::r, lrnode< C, V >::rmax, lrnode< C, V >::rmin, lrnode< C, V >::rs, qnode< C, V >::umax, lrnode< C, V >::umax, qnode< C, V >::umin, lrnode< C, V >::umin, qnode< C, V >::vmax, and qnode< C, V >::vmin.

Referenced by qsegment< C, V >::qsegment().

00156 {
00157     qnode<C,V> * curr, * l, * r;
00158     curr = l = r = 0;
00159 
00160     if (  vmax  <=  lr->lmin || vmin >=  lr->rmax ) return 0;
00161     if (  vmin  <   lr->lmax || vmax >  lr->rmin  )
00162     {
00163         if ( lr->umax-lr->umin > vmax-vmin)
00164         {
00165             l = make( id, vmin, vmax, lr->ls );
00166             r = make( id, vmin, vmax, lr->rs );
00167         }
00168         else
00169         {
00170             unsigned m = (vmin + vmax)/2;
00171             l = make( id, vmin, m, lr );
00172             r = make( id, m, vmax, lr );
00173         };
00174 
00175         if ( l && r )
00176         {
00177             curr = new qnode<C,V>();
00178             curr->umin = lr->umin;
00179             curr->umax = lr->umax;
00180             curr->vmin = vmin;
00181             curr->vmax = vmax;
00182             hull(curr->box,l->box,r->box);
00183             curr->l = l;
00184             curr->r = r;
00185             l->father = curr;
00186             r->father = curr;
00187             return curr;
00188         };
00189 
00190         if ( l ) { return l; };
00191         if ( r ) { return r; };
00192     }
00193     else
00194     {
00195         curr = new qnode<C,V>();
00196         curr->l    = 0;
00197         curr->r    = 0;
00198         curr->umin = lr->umin;
00199         curr->umax = lr->umax;
00200         curr->vmin = vmin;
00201         curr->vmax = vmax;
00202         curr->mbox(this);
00203 
00204         return curr;
00205     };
00206     return curr;
00207 };

void make_box ( rid_t  id,
qnode< C, V > *  q 
) [inherited]
int ncols (  )  const [inline, inherited]

Definition at line 27 of file ssi_sample.hpp.

References sample< C, V >::m_ncols.

Referenced by lsegment< C, V >::find_regions(), and lsegment< C, V >::lines_changes().

00027 { return m_ncols; };

unsigned nmarks (  )  const [inline, inherited]

Definition at line 53 of file ssi_lsegment.hpp.

References lsegment< C, V >::_size.

Referenced by lsegment< C, V >::lines_changes().

00053 { return _size; };

int nrows (  )  const [inline, inherited]

Definition at line 26 of file ssi_sample.hpp.

References sample< C, V >::m_nrows.

Referenced by lsegment< C, V >::find_regions(), and lsegment< C, V >::lines_changes().

00026 { return m_nrows; };

qtree operator[] ( unsigned  i  )  [inline, inherited]

Reimplemented from lsegment< C, V >.

Definition at line 123 of file ssi_qsegment.hpp.

References qsegment< C, V >::trees.

00123 { return trees[i]; };

void promote ( region_t &  r  )  [inline, inherited]

Definition at line 186 of file ssi_lsegment.hpp.

References region_t::_umax, region_t::_umin, mark_t::a(), mark_t::b(), region_t::data, and mark_t::next.

Referenced by lsegment< C, V >::convert_regions().

00187   {
00188     mark_t     * mpointer;
00189     bounds_t * bpointer;
00190     mpointer = (mark_t*)(r.data);
00191     r.data   = (void*)(malloc(sizeof(bounds_t)*(r._umax)));
00192     bpointer = (bounds_t*)(r.data);
00193 
00194     for ( unsigned i = 0; i < r._umax; i++ )
00195       {
00196         bpointer[i][0] = mpointer->a();
00197         bpointer[i][1] = mpointer->b();
00198         mpointer = mpointer->next;
00199       };
00200 
00201     r._umax += r._umin;
00202     r.data  = (void*)(((bounds_t*)(r.data))-r._umin);
00203   };

void push ( const point2 &  l0,
const point2 &  l1,
const point2 &  r0,
const point2 &  r1,
const point3 &  i0,
const point3 &  i1 
) [inline]

Definition at line 303 of file ssi_dsearch.hpp.

References dsearch< C, V >::curr_config.

00306     {
00307         curr_config->push_back( new dcurve( l0,l1,r0, r1, i0, i1 ) );
00308     };

void push ( qtree  f,
qtree  s 
) [inline]

Definition at line 509 of file ssi_dsearch.hpp.

References __down__, __triangle_triangle_case__, __up__, abs(), dsearch< C, V >::conflict_count, qsegment< C, V >::scale_conflict(), SHIFT, qnode< C, V >::umin, and qnode< C, V >::vmin.

Referenced by dsearch< C, V >::search().

00510 {
00511     if ( std::abs(f->umin-s->umin)+std::abs(f->vmin-s->vmin) < SHIFT ) return;
00512     conflict_count ++;
00513     point3 a[4],b[4];
00514     qsegment<C,V>::scale_conflict(a,b,f,s);
00515     {
00516         point3  seg[2];
00517         point2 seg0[2], seg1[2];
00518         bool   coplanar;
00519         __triangle_triangle_case__(__up__,__up__);
00520         __triangle_triangle_case__(__up__,__down__);
00521         __triangle_triangle_case__(__down__,__down__);
00522         __triangle_triangle_case__(__down__,__up__);
00523     }
00524 };

void pushm ( vcode_t  code,
coord_t  j 
) [inline, inherited]

Definition at line 86 of file ssi_lsegment.hpp.

References lsegment< C, V >::_size, mark_t::code, mark_t::head, mark_t::j, lsegment< C, V >::marks, and mark_t::next.

Referenced by lsegment< C, V >::lines_changes().

00087   {
00088     marks[_size].code = code;
00089     marks[_size].j    = j;
00090     marks[_size].head =-1;
00091     marks[_size].next = 0;
00092     _size++;
00093   }

void pushr ( coord_t  i,
mark_t *  p 
) [inline, inherited]

Definition at line 106 of file ssi_lsegment.hpp.

References region_t::_code, region_t::_umax, region_t::_umin, igraph::add_node(), mark_t::code, region_t::data, lsegment< C, V >::grp, mark_t::head, and lsegment< C, V >::regions.

Referenced by lsegment< C, V >::find_regions().

00107   {
00108     p->head =  regions.size();
00109     regions.push_back( region_t() );
00110     region_t * r =&(regions.back());
00111     r->_umin = i;
00112     r->_umax = 1;
00113     r->data = (void*)p;
00114     r->_code = p->code;
00115     grp->add_node();
00116   };

std::list< dcurve * > * reduce ( std::vector< dcurve * > *  conflicts  )  [inline]

Definition at line 604 of file ssi_dsearch.hpp.

References mmx::ssi::build_sheap(), mmx::ssi::empty(), mmx::ssi::extremums(), dsearch< C, V >::result, and mmx::ssi::solve_sheap().

Referenced by dsearch< C, V >::find_branches().

00605 {
00606     unsigned i;
00607     if ( conflicts->size() == 0 ) return 0;
00608 
00609     unsigned   endsize  = 2*conflicts->size();
00610     sdpoint_t * ends = new sdpoint_t[endsize];
00611 
00612     for ( i = 0; i < endsize; i+= 2 )
00613         extremums( ends + i, (*conflicts)[i/2] );
00614 
00615     sheap_t h;
00616     build_sheap(h,ends, ends + endsize, 0.04 );
00617     solve_sheap(h);
00618     delete[] ends;
00619     std::list< dcurve* > * result = new std::list< dcurve * >();
00620     for ( i = 0; i < conflicts->size() ; i++ )
00621     {
00622         if ( empty((*conflicts)[i]) ) delete (*conflicts)[i];
00623         else result->push_front( (*conflicts)[i] );
00624     };
00625     return result;
00626 };

void rfree ( region_t &  r  )  [inline, inherited]

Definition at line 57 of file ssi_lsegment.hpp.

References region_t::_umin, and region_t::data.

Referenced by lsegment< C, V >::~lsegment().

00058     {
00059       free((void*)(((bounds_t*)(r.data)) + r._umin));
00060     };

void scale_conflict ( vector3  a[4],
vector3  b[4],
qtree  qa,
qtree  qb 
) [inherited]

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

void search ( rid_t  i,
rid_t  j 
) [inline]

Definition at line 596 of file ssi_dsearch.hpp.

References dsearch< C, V >::curr_config, dsearch< C, V >::search(), and qsegment< C, V >::trees.

00597 {
00598     curr_config = new std::vector< dcurve* >();
00599     search( this->trees[i], this->trees[j] );
00600 };

void search ( qtree  f,
qtree  s 
) [inline]

Definition at line 555 of file ssi_dsearch.hpp.

References qnode< C, V >::box, mmx::intersectp(), qnode< C, V >::l, mmx::ssi::leaf(), qnode< C, V >::leaf(), dsearch< C, V >::push(), qnode< C, V >::r, dsearch< C, V >::search_f(), dsearch< C, V >::search_s(), and qnode< C, V >::split().

Referenced by dsearch< C, V >::dsearch(), and dsearch< C, V >::search().

00556 {
00557 
00558 
00559     // if there bounding boxes intersect
00560     if ( intersectp(f->box,s->box) )
00561     {
00562         // compute if needed the next level in the hierarchy
00563         f->split(this);
00564         s->split(this);
00565         // if f and s are root node
00566         if ( !(f->leaf()) && !(s->leaf()) )
00567         {
00568             // check all the possible intersection between  sons
00569             search(f->l,s->l), search(f->l,s->r);
00570             search(f->r,s->l), search(f->r,s->r);
00571             return;
00572         };
00573 
00574         // s is leaf (not f) switch to specialized case
00575         if ( !leaf(f) )
00576         {
00577             search_f(f->l,s);
00578             search_f(f->r,s);
00579             return;
00580         };
00581         // same thing with f
00582         if ( !leaf(s) )
00583         {
00584             search_s(f,s->l);
00585             search_s(f,s->r);
00586             return;
00587         };
00588         // two unit quad had been reached push the conflict
00589         // the function push( qtree, qtree ) compute the intersection on the fly if any
00590         push(f,s);
00591     };
00592 };

void search_f ( qtree  f,
qtree const   s 
) [inline]

Definition at line 527 of file ssi_dsearch.hpp.

References qnode< C, V >::box, mmx::intersectp(), qnode< C, V >::l, mmx::ssi::leaf(), push_f, qnode< C, V >::r, and qnode< C, V >::split().

Referenced by dsearch< C, V >::search().

00528 {
00529 
00530     if (intersectp(f->box,s->box))
00531     {
00532         f->split(this);
00533         if ( leaf(f) ){ push_f(f,s); return; };
00534         search_f(f->l,s);
00535         search_f(f->r,s);
00536     };
00537 };

void search_s ( qtree const   f,
qtree  s 
) [inline]

Definition at line 541 of file ssi_dsearch.hpp.

References qnode< C, V >::box, mmx::intersectp(), qnode< C, V >::l, mmx::ssi::leaf(), push_s, qnode< C, V >::r, and qnode< C, V >::split().

Referenced by dsearch< C, V >::search().

00542 {
00543 
00544     if ( intersectp( f->box, s->box ) )
00545     {
00546         s->split(this);
00547         if ( leaf(s) ) { push_s(f,s); return; };
00548         search_s(f,s->l);
00549         search_s(f,s->r);
00550     };
00551 };

unsigned size ( void   )  const [inline, inherited]

Reimplemented from lsegment< C, V >.

Definition at line 122 of file ssi_qsegment.hpp.

References qsegment< C, V >::trees.

Referenced by qsegment< C, V >::~qsegment().

00122 { return trees.size(); };

const double& uvalue ( int  i  )  const [inline, inherited]

Definition at line 28 of file ssi_sample.hpp.

References sample< C, V >::m_uvals.

Referenced by qnode< C, V >::convert().

00028 { return m_uvals[i]; };

const double& vvalue ( int  i  )  const [inline, inherited]

Definition at line 29 of file ssi_sample.hpp.

References sample< C, V >::m_vvals.

Referenced by qnode< C, V >::convert().

00029 { return m_vvals[i]; };

Member Data Documentation

std::list< dcurve * >** _branches

Definition at line 296 of file ssi_dsearch.hpp.

Referenced by dsearch< C, V >::branches(), and dsearch< C, V >::dsearch().

double _lt [inherited]

Definition at line 76 of file ssi_lsegment.hpp.

double _qt [inherited]

Definition at line 123 of file ssi_qsegment.hpp.

unsigned _size [inherited]

Definition at line 49 of file ssi_lsegment.hpp.

Referenced by lsegment< C, V >::lsegment(), lsegment< C, V >::nmarks(), and lsegment< C, V >::pushm().

double _st

Definition at line 354 of file ssi_dsearch.hpp.

std::vector< point2 > cnfdata2

Definition at line 351 of file ssi_dsearch.hpp.

std::vector< point3 > cnfdata3

Definition at line 350 of file ssi_dsearch.hpp.

Referenced by dsearch< C, V >::cnfpush().

unsigned conflict_count

Definition at line 346 of file ssi_dsearch.hpp.

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

std::vector< dcurve * >* curr_config

Definition at line 295 of file ssi_dsearch.hpp.

Referenced by dsearch< C, V >::find_branches(), dsearch< C, V >::push(), and dsearch< C, V >::search().

graph_t* grp [inherited]

Definition at line 68 of file ssi_lsegment.hpp.

Referenced by lsegment< C, V >::addneighbors(), dsearch< C, V >::dsearch(), lsegment< C, V >::lsegment(), lsegment< C, V >::pushr(), and lsegment< C, V >::~lsegment().

point2** lefts

Definition at line 340 of file ssi_dsearch.hpp.

Referenced by dsearch< C, V >::dsearch(), mmx::shape::selfintersection(), and dsearch< C, V >::~dsearch().

unsigned* lines [inherited]

Definition at line 50 of file ssi_lsegment.hpp.

Referenced by lsegment< C, V >::begin(), lsegment< C, V >::lines_changes(), and lsegment< C, V >::lsegment().

bool m_cnf

Definition at line 292 of file ssi_dsearch.hpp.

Referenced by dsearch< C, V >::dsearch().

coord_t m_ncols [inherited]

Definition at line 21 of file ssi_sample.hpp.

Referenced by qnode< C, V >::fill(), sample< C, V >::ncols(), and sample< C, V >::sample().

coord_t m_nrows [inherited]

Definition at line 20 of file ssi_sample.hpp.

Referenced by sample< C, V >::nrows(), and sample< C, V >::sample().

const ParametricSurface* m_psurf [inherited]

Definition at line 17 of file ssi_sample.hpp.

Referenced by sample< C, V >::sample().

vector3* m_svals [inherited]

Definition at line 22 of file ssi_sample.hpp.

Referenced by sample< C, V >::base(), and sample< C, V >::sample().

double* m_uvals [inherited]

Definition at line 18 of file ssi_sample.hpp.

Referenced by sample< C, V >::sample(), sample< C, V >::uvalue(), and sample< C, V >::~sample().

double* m_vvals [inherited]

Definition at line 19 of file ssi_sample.hpp.

Referenced by sample< C, V >::sample(), and sample< C, V >::vvalue().

mark_t* marks [inherited]

Definition at line 48 of file ssi_lsegment.hpp.

Referenced by lsegment< C, V >::begin(), lsegment< C, V >::lines_changes(), lsegment< C, V >::lsegment(), and lsegment< C, V >::pushm().

unsigned nbcurves

Definition at line 344 of file ssi_dsearch.hpp.

Referenced by dsearch< C, V >::dsearch(), mmx::shape::selfintersection(), and dsearch< C, V >::~dsearch().

unsigned nbpoints

Definition at line 345 of file ssi_dsearch.hpp.

Referenced by dsearch< C, V >::dsearch().

double recons_time

Definition at line 335 of file ssi_dsearch.hpp.

std::vector< region_t > regions [inherited]

Definition at line 65 of file ssi_lsegment.hpp.

Referenced by dsearch< C, V >::branches(), lsegment< C, V >::convert_regions(), dsearch< C, V >::dsearch(), lsegment< C, V >::find_regions(), lsegment< C, V >::operator[](), lsegment< C, V >::pushr(), qsegment< C, V >::qsegment(), lsegment< C, V >::size(), and lsegment< C, V >::~lsegment().

std::list< dcurve * >* result

Definition at line 338 of file ssi_dsearch.hpp.

Referenced by dsearch< C, V >::dsearch(), and dsearch< C, V >::reduce().

point2** rights

Definition at line 341 of file ssi_dsearch.hpp.

Referenced by dsearch< C, V >::dsearch(), and dsearch< C, V >::~dsearch().

double search_time

Definition at line 334 of file ssi_dsearch.hpp.

unsigned* sizes

Definition at line 343 of file ssi_dsearch.hpp.

Referenced by dsearch< C, V >::dsearch(), mmx::shape::selfintersection(), and dsearch< C, V >::~dsearch().

struct { ... } stats
std::vector<qtree> trees [inherited]

Definition at line 118 of file ssi_qsegment.hpp.

Referenced by qsegment< C, V >::operator[](), qsegment< C, V >::qsegment(), dsearch< C, V >::search(), qsegment< C, V >::size(), and qsegment< C, V >::~qsegment().

The documentation for this struct was generated from the following file:
Generated on 6 Dec 2012 for shape by  doxygen 1.6.1