void MultiChannel<tData>::set( size_t i_iChannel, const Im2D<tData,tBase> &i_im2d )
{
__elise_debug_error( i_iChannel>=mChannels.size(), "MultiChannel::set(Im2D): i_iChannel>=mChannels.size()" );
__elise_debug_error( i_im2d.tx()!=mWidth, "MultiChannel::set(Im2D): i_im2d.tx()!=mWidth" );
__elise_debug_error( i_im2d.ty()!=mHeight, "MultiChannel::set(Im2D): i_im2d.ty()!=mHeight" );
memcpy( mChannels[i_iChannel]->data_lin(), i_im2d.data_lin(), (size_t)mWidth*(size_t)mHeight*sizeof(tData) );
}
void CalcMaxLoc<Type,TypeBase,Compare>::FiltrMaxLoc_BCVS
(
ElSTDNS vector<Pt2di> & Pts,
Im2D<Type,TypeBase> Im,
REAL FactInf,
REAL TolGeom,
Pt2di SzVois,
Im2D_U_INT1 Marq
)
{
Pt2di SzIm = Inf(Im.sz(),Marq.sz());
Box2di BoxIm(Pt2di(0,0),SzIm);
Marq.raz();
mBufFiltr.clear();
INT4 ** dIm = Im.data();
for (INT kp1=0; kp1<(INT)Pts.size() ; kp1++)
{
ELISE_ASSERT
(
BoxIm.contains(Pts[kp1]),
"GenMaxLoc::FiltrMaxLoc_BCVS"
);
}
{
for (INT kp1=0; kp1<(INT)Pts.size() ; kp1++)
{
Pt2di p1 = Pts[kp1];
Box2di BoxP1(p1-SzVois,p1+SzVois);
INT v1 = dIm[p1.y][p1.x];
INT Vinf = round_up(v1*FactInf);
bool Refut = false;
for (INT kp2=0 ; (kp2<(INT)Pts.size())&&(!Refut) ; kp2++)
{
Pt2di p2 = Pts[kp2];
if ( (kp1!= kp2)
&& CmpTot(v1,dIm[p2.y][p2.x],p1,p2)
&& BoxP1.contains(p2)
&& BandeConnectedVsup(p1,p2,Im,Vinf,TolGeom,Marq)
)
Refut = true;
}
if (! Refut)
mBufFiltr.push_back(p1);
}
}
Pts = mBufFiltr;
}
Im2_Pts_in_Comp<Type>::Im2_Pts_in_Comp
(
Im2D<Type,Type> im,
const Arg_Flux_Pts_Comp & arg
) :
Std_Flux_Of_Points<Type>(im.ty(),arg.sz_buf()),
_im (im),
_data (im.data()),
_ind (0),
_nb_pts (im.tx())
{
}
template <class Type,class TBase> void cElNuage3DMaille_FromImProf<Type,TBase>::ProfBouchePPV()
{
Im2D<Type,TBase> aIPPV = BouchePPV(mIm,ImDef().in());
int aNbTest = 7;
for (int aK=0 ; aK< (aNbTest+2) ; aK++)
{
Symb_FNum aFMasq = ImDef().in();
int aSzV = ElMax(1,ElSquare(aNbTest-aK));
Fonc_Num aFLisse = rect_som(aIPPV.in_proj(),aSzV) / ElSquare(1+2*aSzV);
aFLisse = aFLisse*(! aFMasq) + mIm.in() * aFMasq;
ELISE_COPY(aIPPV.all_pts(),aFLisse,aIPPV.out());
}
ELISE_COPY(aIPPV.all_pts(),aIPPV.in(),mIm.out());
ELISE_COPY(ImDef().all_pts(),1,ImDef().out());
}
void MultiChannel<tData>::link( Im2D<tData,tBase> &i_im2d )
{
resize( i_im2d.tx(), i_im2d.ty(), 1 );
*mChannels[0] = i_im2d;
}
bool CalcMaxLoc<Type,TypeBase,Compare>::BandeConnectedVsup
(
Pt2di p1,
Pt2di p2,
Im2D<Type,TypeBase> Im,
Type VInf,
REAL Tol,
Im2D_U_INT1 Marq
)
{
if (p1==p2)
return true;
Pt2di Sz = Inf(Im.sz(),Marq.sz());
Box2di Box(Pt2di(0,0), Sz);
if (!(Box.contains(p1) && Box.contains(p2)))
return false;
U_INT1 ** dMarq = Marq.data();
Type ** dIm = Im.data();
mBufCC.clear();
mBufCC.push_back(p1);
dMarq[p1.y][p1.x] = 1;
Pt2dr aPR1(p1.x,p1.y);
Pt2dr aPR2(p2.x,p2.y);
SegComp seg12(aPR1,aPR2);
bool got = false;
for (INT kBuf=0 ; (kBuf!=(INT)mBufCC.size()) && (! got) ; kBuf++)
{
Pt2di pBuf = mBufCC[ kBuf];
for (INT kV=0 ; kV< 8; kV++)
{
Pt2di pVois = pBuf + TAB_8_NEIGH[kV];
if (
Box.contains(pVois)
&& (dMarq[pVois.y][pVois.x] == 0)
&& (! mCmp(dIm[pVois.y][pVois.x],VInf))
&& (seg12.BoxContains(Pt2dr(pVois),1.0,Tol))
)
{
if (pVois==p2)
got = true;
dMarq[pVois.y][pVois.x] = 1;
mBufCC.push_back(pVois);
}
}
}
{
for (INT kBuf=0 ; kBuf<(INT)mBufCC.size() ; kBuf++)
{
Pt2di pBuf = mBufCC[ kBuf];
dMarq[pBuf.y][pBuf.x] = 0;
}
}
return got;
}
void CalcMaxLoc<Type,TypeBase,Compare>::AllMaxLoc
(
ElSTDNS vector<Pt2di> &res,
Im2D<Type,TypeBase> Im,
Pt2di Vois,
Pt2di p0, Pt2di p1,
TypeBase vMin
)
{
Pt2di Sz(Im.tx(),Im.ty());
Vois.x = ElAbs(Vois.x);
Vois.y = ElAbs(Vois.y);
pt_set_min_max(p0,p1);
p0 = Sup(p0,Vois);
p1 = Inf(p1,Sz-Vois);
if ((p1.x<=p0.x) || (p1.y <= p0.y))
return;
INT dlx = Vois.x;
INT dly = Vois.y;
Type ** data = Im.data();
res.clear();
ElSTDNS vector<Pt3di> & OVois = OrdVois(Vois);
for (INT Y0=p0.y ; Y0<p1.y ; Y0+=dly)
{
INT Y1 = ElMin(p1.y,Y0+dly);
for (INT X0=p0.x ; X0<p1.x ; X0+=dlx)
{
INT X1 = ElMin(p1.x,X0+dlx);
Type vMax = vMin;
INT xMax = DefXY;
INT yMax = DefXY;
for (INT y=Y0; y<Y1 ; y++)
{
for (INT x=X0; x<X1 ; x++)
{
if (mCmp((TypeBase)vMax,(TypeBase)data[y][x]))
{
xMax = x;
yMax = y;
vMax = data[y][x];
}
}
}
if (xMax != DefXY)
{
bool IsMax = true;
for
(
std::vector<Pt3di> ::iterator itOV = OVois.begin();
IsMax &&(itOV != OVois.end());
itOV++
)
{
Type aVal = data[yMax+itOV->y][xMax+itOV->x];
if (itOV->z)
{
if (!mCmp((TypeBase)aVal,(TypeBase)vMax))
IsMax = false;
}
else
{
if (mCmp((TypeBase)vMax,(TypeBase)aVal))
IsMax = false;
}
}
if (IsMax)
{
res.push_back(Pt2di(xMax,yMax));
}
}
}
}
}
void dist_chamfer_cabl(Im2D<U_INT1,INT> I,INT v_max)
{
Im2D<U_INT1,INT> I0(I.tx(),I.ty(),0);
ELISE_COPY(I0.all_pts(),I.in(),I0.out());
Chamfer::d32.im_dist(I);
INT nb_dif;
ELISE_COPY
(
I.all_pts(),
I0.in()!=(I.in()!=0),
sigma(nb_dif)
);
BENCH_ASSERT(nb_dif == 0);
INT tx = I.tx();
INT ty = I.ty();
U_INT1 ** d = I.data();
INT vmax = I.vmax()-1;
for (int x=1; x<tx-1 ; x++)
for (int y=1; y<ty-1 ; y++)
{
INT v;
if (d[y][x])
v = std::min3
(
std::min3(d[y+1][x-1]+3,d[y+1][x]+2,d[y+1][x+1]+3),
std::min3(d[y][x-1]+2,vmax,d[y][x+1]+2),
std::min3(d[y-1][x-1]+3,d[y-1][x]+2,d[y-1][x+1]+3)
);
else
v = 0;
BENCH_ASSERT(v == d[y][x]);
}
INT dif;
ELISE_COPY
(
I.all_pts(),
Abs
(
Min(I.in(),v_max)
- extinc_32(I0.in(0),v_max)
),
VMax(dif)
);
BENCH_ASSERT(dif == 0);
}
FoncATrou_OPB_Comp<Type>::FoncATrou_OPB_Comp
(
Liste_Pts<Type,INT> l,
INT X0,
INT X1,
INT Y0,
INT Y1
) :
_values (1,1),
_l (1),
_cpt (NEW_VECTEUR(Y0,Y1+1,INT)),
_dim_vals (l.dim()-2)
{
INT k;
set_cste(_cpt+Y0,0,Y1-Y0+1);
Im2D<Type,INT> XYV = l.image();
INT nb_pts = 0;
Type * tx = XYV.data()[0];
Type * ty = XYV.data()[1];
Type ** xyv = XYV.data();
//---- filtre les pts hors du rectangle ---------
INT dim = XYV.ty();
{
INT nb_pts_tot = XYV.tx();
for( k=0; k<nb_pts_tot; k++)
if (
(tx[k]>=X0)
&& (tx[k]< X1)
&& (ty[k]>=Y0)
&& (ty[k]< Y1)
)
{
for(INT d=0; d<dim; d++)
xyv[d][nb_pts] = xyv[d][k];
nb_pts++;
}
}
//--------- histo en Y + cumule -----------------------
for( k=0; k<nb_pts; k++)
_cpt[ty[k]]++;
for (INT y = Y0+1; y<=Y1; y++)
_cpt[y] += _cpt[y-1];
//---------------- range en y croissant ----------------
_values = Im2D<Type,INT> (nb_pts,_dim_vals+1);
_tx = _values.data()[0];
_v = _values.data()+1;
for( k=0; k<nb_pts ; k++)
{
INT adr = --_cpt[ty[k]];
_tx[adr] = tx[k];
for (INT d = 0; d<_dim_vals; d++)
_v[d][adr] = xyv[d+2][k];
}
}
template <class TypeIm,class TypeBase> Im2D_Bits<1> CreateGr(tGRGraf & mGr,Im2D<TypeIm,TypeBase> anIm,int aLabelOut,const cParamGrReg & aPGR)
{
bool V8=true;
//int aNbV = V8 ? 8 : 4;
//Pt2di * TabV = V8 ? TAB_8_NEIGH : TAB_4_NEIGH;
TIm2D<TypeIm,TypeBase> aTIm(anIm);
Pt2di aSz = anIm.sz();
Im2D_INT4 aImLabel(aSz.x,aSz.y,-1);
TIm2D<INT4,INT4> aTL(aImLabel);
ELISE_COPY(aImLabel.border(1),-2,aImLabel.out());
Pt2di aP0;
int aCpt=0;
ElGrowingSetInd aSV(1000);
std::vector<tGRSom *> aVSom;
for (aP0.y=0 ; aP0.y<aSz.y ; aP0.y++)
{
for (aP0.x=0 ; aP0.x<aSz.x ; aP0.x++)
{
int aLabel = aTIm.get(aP0);
if ((aTL.get(aP0)==-1) && (aLabel != aLabelOut))
{
std::vector<Pt2di> aVPts;
CompCnx(aVPts,V8,aP0,anIm,aImLabel,INT4(aCpt),&aSV);
int aNbPts = aVPts.size();
if (aNbPts >= aPGR.mSzMinInit)
{
cGR_AttrSom anAttr(aP0,aLabel,aCpt,aNbPts);
tGRSom & aSom = mGr.new_som(anAttr);
aVSom.push_back(&aSom);
for (ElGrowingSetInd::const_iterator itV=aSV.begin(); itV!=aSV.end() ; itV++)
{
tGRSom * aS2 = aVSom[*itV];
if (aS2)
{
cGR_AttrArc anAA;
mGr.add_arc(aSom,*aS2,anAA);
}
}
}
else
{
aVSom.push_back(0);
}
aCpt++;
}
}
}
//std::cout << "BGIN FLAG MONT-DESC\n"; getchar();
// Calcul des flag montant et descandant
int aFlagArcMont = mGr.alloc_flag_arc();
int aFlagArcDesc = mGr.alloc_flag_arc();
ElSubGraphe<cGR_AttrSom,cGR_AttrArc> aSubAll;
for (int aKS=0 ; aKS<int(aVSom.size()) ; aKS++)
{
tGRSom * aSom = aVSom[aKS];
if (aSom)
{
tGRSom * aSMax = aSom;
tGRSom * aSMin = aSom;
for (tGRSom::TArcIter itA=aSom->begin(aSubAll); itA.go_on(); itA++)
{
tGRSom * aS2 = &(itA->s2());
if ( (aS2->attr().ValR() > aSMax->attr().ValR())
|| ((aS2->attr().ValR()==aSMax->attr().ValR()) && (aS2->attr().Sz() > aSMax->attr().Sz()))
)
{
aSMax = aS2;
}
if ( (aS2->attr().ValR() < aSMin->attr().ValR())
|| ((aS2->attr().ValR()==aSMin->attr().ValR()) && (aS2->attr().Sz() > aSMin->attr().Sz()))
)
{
aSMin = aS2;
}
}
if (aSMax != aSom)
mGr.arc_s1s2(*aSom,*aSMax)->sym_flag_set_kth_true(aFlagArcMont);
if (aSMin != aSom)
mGr.arc_s1s2(*aSom,*aSMin)->sym_flag_set_kth_true(aFlagArcDesc);
}
}
// std::cout << "EeenDD FLAG MONT-DESC\n";
// Analyse zone water shade
for (int aKMD=0 ; aKMD<2 ; aKMD++)
{
bool isMont = (aKMD==0);
int aFlagArc = (isMont) ? aFlagArcMont : aFlagArcDesc;
ElPartition<tGRSom * > aPart;
ElSubGraphe<cGR_AttrSom,cGR_AttrArc> aSubAll;
cSubGrFlagArc< ElSubGraphe<cGR_AttrSom,cGR_AttrArc> > aSub(aSubAll,aFlagArc);
PartitionCC(aPart,mGr,aSub);
std::vector<tGRSom *> aVBarbs;
cSubGrSzSup aGrCons(aPGR.mSzBarb);
Ebarbule(mGr,aSub,aGrCons,aVBarbs);
std::set<tGRSom *> aSetB(aVBarbs.begin(),aVBarbs.end());
for (int aKC=0 ; aKC< aPart.nb() ; aKC++)
{
ElSubFilo<tGRSom *> aCC = aPart[aKC];
int aSzTot = SomSz(aCC);
bool Ok = aSzTot >= aPGR.mSeuilZonWS ;
if (Ok)
{
for (int aKS=0 ; aKS<aCC.size() ; aKS++)
{
if (aSetB.find(aCC[aKS])==aSetB.end())
{
aCC[aKS]->attr().Valid() = true;
}
else
{
}
}
}
}
}
// std::cout << "EeenDD PARTITION\n"; getchar();
double aSomT=0;
double aMaxT=0;
int aDelta = 1; // 1
for (int aKS=0 ; aKS<int(aVSom.size()) ; aKS++)
{
tGRSom * aSom = aVSom[aKS];
if (aSom && (! aSom->attr().DoneValR()))
{
ElTimer aChrono;
cSubGrInterv aSG(aSom->attr().ValR()-aDelta,aSom->attr().ValR()+aDelta);
ElFifo<tGRSom *> aCC;
comp_connexe_som(aCC,aSom,aSG);
int aSzCC = SomSz(aCC);
bool Ok = aSzCC >= aPGR.mSeuilValRDelta;
for (int aKC=0 ; aKC<int(aCC.size()) ; aKC++)
{
tGRSom * aSom2 = aCC[aKC];
if (aSom2->attr().ValR() == aSom->attr().ValR())
aSom2->attr().DoneValR() = true;
if (Ok)
aSom2->attr().Valid() = true;
}
// ShowComp(aCC,V8,(Ok?255:0), anIm,aImLabel);
double aT = aChrono.uval();
aSomT += aT;
if (aT > aMaxT)
{
aMaxT = aT;
}
}
}
/*
*/
// EXPORT DES RESULTATS FINALS
Im2D_Bits<1> aImRes(aSz.x,aSz.y,0);
TIm2DBits<1> aTImRes(aImRes);
for (int aKS=0 ; aKS<int(aVSom.size()) ; aKS++)
{
tGRSom * aSom = aVSom[aKS];
if (aSom && aSom->attr().Valid())
{
std::vector<Pt2di> aVPts;
CompCnxCste(aVPts,V8,aSom->attr().P0(),anIm,aImLabel);
for (int aKP=0 ; aKP<int(aVPts.size()) ; aKP++)
{
aTImRes.oset(aVPts[aKP],1);
}
}
}
return aImRes;
}
