bcell2d_subdivisor< C, V > Struct Template Reference

#include <bcell2d_algebraic_curve.hpp>

List of all members.

Static Public Member Functions

• template<class CELL > static void subdivide (CELL &cl, CELL *&, CELL *&, int v, double s)

---

Detailed Description

template<class C, class V>
struct mmx::shape::bcell2d_subdivisor< C, V >

Kernel for bcell2d_algebraic_curve Polynomial : the type of polynomial associated to this class. subdivisor : the function which subdivides the representation.

Definition at line 38 of file bcell2d_algebraic_curve.hpp.

---

Member Function Documentation

void subdivide	(	CELL &	cl,
		CELL *&	left,
		CELL *&	right,
		int	v,
		double	s
	)			[inline, static]

Definition at line 52 of file bcell2d_algebraic_curve.hpp.

References Point, Solver, and mmx::split().

                                                                                       {

    typedef typename topology<C,V>::Point Point;
    typedef solver_implicit<C,V> Solver;


    double eps =Approximate().eps;
    if(v==0) {//direction v=0
        left = new CELL(cl);   left ->set_xmax(s);
        right= new CELL(cl);   right->set_xmin(s);

        tensor::split(left->m_polynomial, right->m_polynomial, v);
        if (left->e_intersections.size() == 0)
        Solver::edge_point(left->e_intersections,
                           left->m_polynomial, Solver::east_edge, left->boundingBox());
        right->w_intersections=left->e_intersections;
        left ->w_intersections=cl.w_intersections;
        right->e_intersections=cl.e_intersections;
        foreach(Point* p,cl.n_intersections) {
          if (p->x() == s) {
            left ->n_intersections<< p ;
            right->n_intersections<< p ;
          } else if(p->x() < s)
            left ->n_intersections << p ;
            else 
              right->n_intersections << p ;
        }

        foreach(Point* p,cl.s_intersections) {
          if (p->x() == s) {
            left ->s_intersections<< p ;
            right->s_intersections<< p ;
          } else if(p->x() < s)
            left ->s_intersections<< p ;
          else 
            right->s_intersections<< p ;
        }

        foreach(Point* p,cl.m_singular) {

            if(p->x() < s+eps)
                left ->m_singular << p ;
            //  else
            if(p->x() > s-eps)
                right->m_singular << p ;
        }

        /*  Update neighbors  */
        cl.connect0(left, right);
        left->join0(right);


    } else {//direction v==1

        left = new CELL(cl);  left->set_ymax(s);
        right= new CELL(cl);  right->set_ymin(s);


        tensor::split(left->m_polynomial, right->m_polynomial, v);
        if (left->n_intersections.size() ==0)
          Solver::edge_point(left->n_intersections,
                           left->m_polynomial, Solver::north_edge, left->boundingBox());
        right->s_intersections=left->n_intersections;
        left ->s_intersections=cl.s_intersections;
        right->n_intersections=cl.n_intersections;
        foreach(Point* p,cl.w_intersections) {
          if(p->y() == s) {
            left ->w_intersections << p ;
            right->w_intersections << p ;
          } else if(p->y() < s)
            left ->w_intersections << p ;
          else
            right->w_intersections << p ;
        }

        foreach(Point* p,cl.e_intersections) {
          if(p->y() == s) {
            left ->e_intersections << p ;
            right->e_intersections << p ;
          } else if(p->y() < s)
            left ->e_intersections << p ;
          else
            right->e_intersections << p ;
        }

        foreach(Point* p,cl.m_singular) {
            if(p->y() < s+eps)
                left->m_singular << p ;
            //  else
            if(p->y() > s-eps)
                right->m_singular << p ;
        }
        
        foreach(Point* p,cl.m_xcritical) {
            if(p->y() < s+eps)
                left->m_xcritical << p ;
            //  else
            if(p->y() > s-eps)
                right->m_xcritical << p ;
        }

        foreach(Point* p,cl.m_ycritical) {
            if(p->y() < s+eps)
                left->m_ycritical << p ;
            //  else
            if(p->y() > s-eps)
                right->m_ycritical << p ;
        }

        /*  Update neighbors  */
        cl.connect1(left, right);
        left->join1(right);

    }
    /* disconnect parent */
    cl.disconnect( );

}

---

The documentation for this struct was generated from the following file:

• include/shape/bcell2d_algebraic_curve.hpp