Pt2dr prolong
(
TIm2D<INT1,INT> & im,
const Seg2d & seg,
REAL step,
REAL Rvlim,
bool BorneInf,
bool etirement
)
{
Pt2dr dec = vunit(seg.p0()-seg.p1()) * step;
if (! etirement)
dec = -dec;
Pt2dr pt = seg.p0();
INT Ivlim = (INT)(Rvlim * (1<<(2*NBB)));
Pt2di p0 (1,1);
Pt2di p1 (im.sz()-Pt2di(2,2));
for (;;)
{
ElPFixed<NBB> Fpt (pt);
if (! Fpt.inside(p0,p1))
return pt;
INT v = TImGet<INT1,INT,NBB>::getb2(im,Fpt);
if ( BorneInf ? (v>Ivlim) : (v<Ivlim) )
pt += dec;
else
return pt;
}
}
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));
}
void bench_seg_mean_square()
{
for (int i = 0; i<100 ; i++)
{
INT nx = (INT) (10 +NRrandom3()*20);
INT ny = nx -5;
Pt2dr tr = Pt2dr((NRrandom3()-0.5)*1e4,(NRrandom3()-0.5)*1e4);
Pt2dr rot = Pt2dr::FromPolar(1.0,NRrandom3() *100);
RMat_Inertie m;
for (int x= -nx; x <= nx ; x++)
for (int y= -ny; y <= ny ; y++)
{
Pt2dr Z = tr+rot*Pt2dr(x,y);
m.add_pt_en_place(Z.x,Z.y);
}
Seg2d s = seg_mean_square(m,100.0);
Pt2dr cdg = s.p0();
Pt2dr all = (s.p1()-s.p0())/ 100.0;
BENCH_ASSERT
(
(euclid(cdg-tr) < BIG_epsilon)
&& (std::abs(all^rot) < BIG_epsilon)
);
// BENCH_ASSERT(Abs(d0 -d1) < BIG_epsilon);
}
}
INT Approx_poly::one_pass_pcc()
{
SomApproxPoly * som;
for
(
som = prem_som()->_next;
(som != 0);
som = som->_next
)
{
SomApproxPoly * ancetre = som->_pred;
bool found = false;
for
(
int step = 0;
(ancetre!=0) && (step!= _arg._nb_jump);
ancetre = ancetre->_pred , step++
)
{
Seg2d seg = _calc_seg(ancetre,som);
Pt2dr p0 = seg.p0();
Pt2dr p1 = seg.p1();
if (euclid(p0-p1) < 1e-5)
p1 = p1 + Pt2dr(1e-5,1e-5);
SegComp SComp (p0,p1);
REAL cost = ancetre->_cost
+ _arg._prec
+ _calc_cout(ancetre,som,SComp,_arg);
if ((!found) || (cost < som->_cost))
{
som->_cost = cost;
som->_best_anc = ancetre;
found = true;
}
}
El_Internal.ElAssert
(
found,
EEM0 << "Incoherence in approx_polygonale"
);
}
INT res = 1;
som = last_som();
for
(
SomApproxPoly * pred = som->_best_anc ;
(pred != 0) ;
som = pred, pred =pred->_best_anc, res++
)
{
som->_pred = pred;
pred->_next = som;
}
return res;
}
// -----------------------------------------------------------------------------
// Returns a list of points where the 'cutting' line [cutter] crosses any
// existing lines in the list.
// The point list is sorted along the direction of [cutter]
// -----------------------------------------------------------------------------
vector<Vec2d> LineList::cutPoints(const Seg2d& cutter) const
{
// Init
vector<Vec2d> intersect_points;
Vec2d intersection;
// Go through map lines
for (const auto& line : objects_)
{
// Check for intersection
intersection = cutter.start();
if (MathStuff::linesIntersect(cutter, line->seg(), intersection))
{
// Add intersection point to vector
intersect_points.push_back(intersection);
LOG_DEBUG("Intersection point", intersection, "valid with", line);
}
else if (intersection != cutter.start())
{
LOG_DEBUG("Intersection point", intersection, "invalid");
}
}
// Return if no intersections
if (intersect_points.empty())
return intersect_points;
// Check cutting line direction
double xdif = cutter.br.x - cutter.tl.x;
double ydif = cutter.br.y - cutter.tl.y;
if ((xdif * xdif) > (ydif * ydif))
{
// Sort points along x axis
if (xdif >= 0)
std::sort(intersect_points.begin(), intersect_points.end(), [](const Vec2d& left, const Vec2d& right) {
return left.x < right.x;
});
else
std::sort(intersect_points.begin(), intersect_points.end(), [](const Vec2d& left, const Vec2d& right) {
return left.x > right.x;
});
}
else
{
// Sort points along y axis
if (ydif >= 0)
std::sort(intersect_points.begin(), intersect_points.end(), [](const Vec2d& left, const Vec2d& right) {
return left.y < right.y;
});
else
std::sort(intersect_points.begin(), intersect_points.end(), [](const Vec2d& left, const Vec2d& right) {
return left.y > right.y;
});
}
return intersect_points;
}
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;
}
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);
}
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();
}
void HWind::action_seg(const Seg2d & seg)
{
_w.draw_seg(seg.p0(),seg.p1(),_lst);
}
void bench_dist_point_seg_droite()
/*
On tire un segment vertical V et un point p, le calcul de d0 = D2(V,p)
est trivial ;
On tire une rotation affine r, soit d1 la distance r(V), r(p),
elle doit etre invariante par rotation. Ce processus donne
des pointe te sgement quelconuq
on verifie d1=d0
*/
{ INT f;
for (f =0; f< 1000; f++)
{
ElFifo<Pt2dr> poly;
poly.set_circ(NRrandom3() > 0.5);
random_polyl(poly,(INT)(2+20*NRrandom3()));
SegComp s = random_seg(true);
SegComp::ModePrim mode = ran_prim_seg();
ElFifo<Pt2dr> inters;
ElFifo<INT > index;
s.inter_polyline(mode,poly,index,inters);
for (INT k=0; k<index.nb(); k++)
{
INT ind = index[k];
Pt2dr inter = inters[k];
Pt2dr p0 = poly[ind];
Pt2dr p1 = poly[ind+1];
BENCH_ASSERT
(
(s.square_dist(mode,inter)<epsilon)
&& (SegComp(p0,p1).square_dist_seg(inter) < epsilon)
);
}
if ((mode==SegComp::droite) && poly.circ())
BENCH_ASSERT((inters.nb()%2)==0);
}
for ( f = 0; f<10000 ; f++)
{
bool ok;
SegComp::ModePrim m0 = ran_prim_seg();
SegComp::ModePrim m1 = ran_prim_seg();
SegComp s0 = random_seg(true);
SegComp s1 = SegNotPar(s0);
Pt2dr i = s0.inter(m0,s1,m1,ok);
BENCH_ASSERT
(
(s0.square_dist_droite(i) < BIG_epsilon)
&& (s1.square_dist_droite(i) < BIG_epsilon)
);
if ( pt_loin_from_bande(s0,i)
&& pt_loin_from_bande(s1,i)
)
{
BENCH_ASSERT
(
ok == ( seg_prim_inside(s0,i,m0)
&& seg_prim_inside(s1,i,m1)
)
);
}
}
for ( f = 0; f<10000 ; f++)
{
Pt2dr p1 = Pt2dr(0,NRrandom3()*1e3);
Pt2dr p2 = Pt2dr(0,p1.y +10+1e3*NRrandom3());
Pt2dr q = Pt2dr((NRrandom3()-0.5)*1e4,(NRrandom3()-0.5)*1e4);
SegComp::ModePrim mode = ran_prim_seg();
Pt2dr proj_q = Pt2dr(0,q.y);
Pt2dr projP_q = proj_q;
double d0 = ElSquare(q.x);
double dp0 = d0;
if (proj_q.y>p2.y)
{
if (mode == SegComp::seg)
{
dp0 += ElSquare(proj_q.y-p2.y);
projP_q.y = p2.y;
}
}
else if (proj_q.y<p1.y)
{
if (mode != SegComp::droite)
{
dp0 += ElSquare(proj_q.y-p1.y);
projP_q.y = p1.y;
}
}
Pt2dr tr = Pt2dr((NRrandom3()-0.5)*1e5,(NRrandom3()-0.5)*1e5);
REAL teta = NRrandom3() *100;
Pt2dr rot(cos(teta),sin(teta));
p1 = tr + p1 * rot;
p2 = tr + p2 * rot;
q = tr + q * rot;
proj_q = tr + proj_q * rot;
projP_q = tr + projP_q * rot;
SegComp s(p1,p2);
REAL d1 = s.square_dist_droite(q);
REAL dp1 = s.square_dist(mode,q);
BENCH_ASSERT(std::abs(d0 -d1) < BIG_epsilon);
BENCH_ASSERT(std::abs(dp0 -dp1) < BIG_epsilon);
Pt2dr proj_q_2 = s.proj_ortho_droite(q);
BENCH_ASSERT( euclid(proj_q-proj_q_2) < BIG_epsilon);
BENCH_ASSERT(euclid(projP_q,s.proj_ortho(mode,q))<BIG_epsilon);
}
for ( f = 0; f<10000 ; f++)
{
REAL rho = 1+NRrandom3()*1e3;
REAL teta = (NRrandom3()-0.5)*1.9999*PI;
Pt2dr p1 = Pt2dr::FromPolar(rho,teta);
REAL teta2 = angle(p1);
Pt2dr p2 = Pt2dr::FromPolar(1+NRrandom3()*1e3,NRrandom3()*1e3);
REAL teta3 = angle(p2,p1*p2);
BENCH_ASSERT(std::abs(teta2-teta)<epsilon);
BENCH_ASSERT(std::abs(teta3-teta)<epsilon);
}
for ( f =0; f< 2000; f++)
{
SegComp::ModePrim m0 = ran_prim_seg();
SegComp::ModePrim m1 = ran_prim_seg();
SegComp s0 = random_seg(true);
SegComp s1 = SegNotPar(s0);
Seg2d proj = s0.proj_ortho(m0,s1,m1);
BENCH_ASSERT
(
std::abs
(
square_euclid(proj.p0()-proj.p1())
-s0.square_dist(m0,s1,m1)
) < epsilon
);
BENCH_ASSERT
(
(s0.square_dist(m0,proj.p0())<epsilon)
&& (s1.square_dist(m1,proj.p1())<epsilon)
);
for (INT k=0; k< 8*(2+(INT)m0)*(2+(INT)m1) ; k++)
{
Pt2dr q0 = proj.p0() + s0.tangente()*((NRrandom3()-0.5) * (1<<(k%10))) ;
Pt2dr q1 = proj.p1() + s1.tangente()*((NRrandom3()-0.5) * (1<<(k%10))) ;
q0 = s0.proj_ortho(m0,q0);
q1 = s1.proj_ortho(m1,q1);
BENCH_ASSERT
(
euclid(proj.p0(),proj.p1())
< (euclid(q0,q1)+epsilon)
);
}
}
cout << "OK OK OK DIIIIIIST \n";
}
void cElHJaPlan3D::Show
(
Video_Win aW,
INT aCoul,
bool ShowDroite,
bool ShowInterEmpr
)
{
if (aCoul >=0)
ELISE_COPY(aW.all_pts(),aCoul,aW.ogray());
Box2dr aBoxW(Pt2dr(0,0),Pt2dr(aW.sz()));
for (INT aK=0; aK<INT(mVInters.size()) ; aK++)
{
cElHJaDroite * aDr =mVInters[aK];
if (aDr)
{
ElSeg3D aSeg = aDr->Droite();
Pt3dr aQ0 = aSeg.P0();
Pt3dr aQ1 = aSeg.P1();
Pt2dr aP0(aQ0.x,aQ0.y);
Pt2dr aP1(aQ1.x,aQ1.y);
Seg2d aS(aP0,aP1);
Seg2d aSC = aS.clipDroite(aBoxW);
if (ShowDroite && (! aSC.empty()))
{
aW.draw_seg(aSC.p0(),aSC.p1(),aW.pdisc()(P8COL::magenta));
}
}
}
tFullSubGrPl aSGrFul;
if (ShowInterEmpr)
{
for (tItSomGrPl itS=mGr->begin(aSGrFul) ; itS.go_on() ; itS++)
{
aW.draw_circle_loc
(
(*itS).attr().Pt(),
4.0,
aW.pdisc()(P8COL::blue)
);
for (tItArcGrPl itA=(*itS).begin(aSGrFul) ; itA.go_on() ; itA++)
{
tSomGrPl &s1 = (*itA).s1();
tSomGrPl &s2 = (*itA).s2();
if (&s1 < &s2)
{
aW.draw_seg
(
s1.attr().Pt(),
s2.attr().Pt(),
aW.pdisc()(P8COL::black)
);
}
}
}
}
// for (INT aK=0 ; aK<INT(mFacOblig.size()) ; aK++)
// mFacOblig[aK]->Show(PI/2.0,P8COL::cyan,false);
}
