Example #1
0
Seg2d  APP_seg_mean_square(SomApproxPoly * s1, SomApproxPoly  *s2)
{
    RMat_Inertie   m = s1->inert_dif(s2);
    Seg2d         s = seg_mean_square(m);
    SegComp       sc(s.p0(),s.p1());
    return  Seg2d(sc.proj_ortho_droite(s1->_pt),sc.proj_ortho_droite(s2->_pt));
}
Example #2
0
void  HPoly
      (
           ActionSeg &             Act,
           ElFifo<Pt2dr> &   f,
           Pt2dr                   dir,
           REAL                    esp
      )
{
     REAL omax = -1e50;
     REAL omin =  1e50;

     SegComp s0 (Pt2dr(0,0),dir);

     for (INT k=0; k<f.nb() ; k++)
     {
          REAL ord = s0.ordonnee(f[k]);
          ElSetMax(omax,ord);
          ElSetMin(omin,ord);
     }
     
     for (REAL ord = round_up(omin/esp) *esp; ord<omax; ord += esp)
     {
          Pt2dr p0 = s0.from_rep_loc(Pt2dr(0.0,ord));
          ClipSeg(Act,f,Seg2d(p0,p0+s0.tangente()));
     }
      
}
Seg2d  retract_std_bi_dir
       (
            Im2D<INT1,INT>   im,
            const Seg2d   &   seg,
            REAL              step,
            REAL              vlim
       )
{
     TIm2D<INT1,INT>   Tim (im);
     Pt2dr q0 =   prolong_iter(Tim,seg,step,0.05,vlim,false,false);
     Pt2dr q1 =   prolong_iter(Tim,seg.reverse(),step,0.05,vlim,false,false);
     return Seg2d(q0,q1);
}
Example #4
0
void  ClipSeg
      (
           ActionSeg &             Act,
           ElFifo<Pt2dr> &   f,
           SegComp                 seg
      )
{
     f.set_circ(true);
     Act._events.clear();

     
     bool OrTrig = (surf_or_poly(f) >= 0);
     for (INT k=0; k<f.nb() ; k++)
     {
         Pt2dr p0 = seg.to_rep_loc(f[k]);
         Pt2dr p1 = seg.to_rep_loc(f[k+1]);

         if ((p0.y>0) != (p1.y>0))
         {
            bool entr = (p0.y>0);
            if (!OrTrig)
               entr = ! entr;
            REAL absc = p0.x-p0.y*((p1.x-p0.x)/(p1.y-p0.y))  ;  

            Act._events.add_ev(EventInterv(absc,entr));
         }
     }
     Act._intervs.init(Act._events);

     const ElFilo<Interval>  & intervs =   Act._intervs.intervs();


	 {
     for (INT k=0 ; k<intervs.nb() ; k++)
     {
         Pt2dr p0 (intervs[k]._v0,0.0);
         Pt2dr p1 (intervs[k]._v1,0.0);
         Act.action_seg
         (
              Seg2d
              (
                  seg.from_rep_loc(p0),
                  seg.from_rep_loc(p1)
              )
         );
     }
	 }
}
Example #5
0
void Data_El_Geom_GWin::draw_seg_cliped
(
       Pt2dr p0,
       Pt2dr p1,
       Data_Line_St * lst,
       Box2dr         box,
       bool auto_flush
)
{
   if (_dnext)
      _dnext->draw_seg_cliped(p0,p1,lst,box,auto_flush);

   Seg2d s = Seg2d(p0,p1).clip(box);
   if (! s.empty())
      draw_seg(s.p0(),s.p1(),lst,auto_flush);
}
Pt2dr prolong_iter
      (
            TIm2D<INT1,INT> & im,
            const Seg2d   &   seg,
            REAL              step,
            REAL              step_min,
            REAL              Rvlim,
            bool              BorneInf,
            bool              etirement
      )
{
    Pt2dr p0 = seg.p0();
    Pt2dr p1 = seg.p1();
    while (step > step_min)
    {
         p0 =  prolong(im,Seg2d(p0,p1),step,Rvlim,BorneInf,etirement);
         step /= 2.0;
    }
    return p0;
}
Example #7
0
Seg2d  APP_seg_extre(SomApproxPoly * s1, SomApproxPoly  *s2)
{
    return Seg2d (s1->_pt,s2->_pt);
}
Example #8
0
void Data_El_Geom_GWin::draw_polyl_cliped
(
         const REAL * x,const REAL *y,INT nb,Box2dr box, Data_Line_St * lst,
         bool circ,
         bool auto_flush
)
{
    if (_dnext)
       _dnext->draw_polyl_cliped(x,y,nb,box,lst,circ,auto_flush);

    _degw->set_line_style(lst);

    REAL x0[NB_BUF_DRAW_POLY];
    REAL y0[NB_BUF_DRAW_POLY];
    REAL x1[NB_BUF_DRAW_POLY];
    REAL y1[NB_BUF_DRAW_POLY];

    INT nb_buf = 0;
    for (INT k0 = 0; k0 <nb-1 ;)
    {
        INT k1 = k0;
        while
        (
                 (k1<nb-1)
              && (box.inside(Pt2dr(x[k1],y[k1])))
              && (box.inside(Pt2dr(x[k1+1],y[k1+1])))
        )
           k1 ++;

        if (k1 > k0)
        {
            draw_polyl(x+k0,y+k0,k1-k0+1,lst,false,false);
            k0 = k1;
        }
        else
        {
             Seg2d seg = Seg2d(x[k0],y[k0],x[k0+1],y[k0+1]).clip(box);

             if (! seg.empty())
             {
                  Pt2dr p0 = prto_window_geom(seg.p0());
                  Pt2dr p1 = prto_window_geom(seg.p1());

                  x0[nb_buf]   =    p0.x;
                  y0[nb_buf]   =    p0.y;
                  x1[nb_buf]   =    p1.x;
                  y1[nb_buf++] =    p1.y;
             }
             if (nb_buf == NB_BUF_DRAW_POLY)
             {
                _degw->_inst_draw_poly_segs(x0,y0,x1,y1,nb_buf);
                nb_buf = 0;
             }
             k0++;
        }
    }

    if (nb_buf)
       _degw->_inst_draw_poly_segs(x0,y0,x1,y1,nb_buf);

    if (circ && (nb > 1))
       draw_seg_cliped
       (
            Pt2dr(x[nb-1],y[nb-1]),
            Pt2dr(x[0],y[0]),
            lst,
            box,
            false
       );

    if (auto_flush)
        _degw->_degd->auto_flush();
}