Fonc_Num RectKth_Pondere
(
Fonc_Num f1,
Fonc_Num f2,
REAL kth,
INT side,
INT max_vals
)
{
cout << "!!!!!!!!!!!!!!!!!!!!! Non benche !!!!!!!!!!!!\n";
ELISE_ASSERT
(
(f1.dimf_out()==1) && (f2.dimf_out() ==1),
"Bad Dim in Rect_Pondere"
);
Pt2di PSz(side,side);
return new Kieme_Opb_Not_Comp
(
Virgule(f1,f2),
kth,
Box2di(-PSz,PSz),
max_vals,
Histo_Kieme::KTH,
Histo_Kieme::undef,
false,
true
);
}
void cDico_SymbFN::AddF(Fonc_Num aF)
{
Fonc_Num::tKindOfExpr aK = aF.KindOfExpr();
if (
(aK == Fonc_Num::eIsICste)
|| (aK == Fonc_Num::eIsRCste)
|| (aK == Fonc_Num::eIsVarSpec)
)
return;
cCelDico_SFN & aCel = mDic[aF];
// Lorsque l'expression est marquee comme interessante,
// on force l'emission de symbole pour clarifier
if (aF.HasNameCpp())
aCel.mNbRef++;
aCel.mNbRef++;
if ((!aF.IsVarSpec()) && (aCel.mNbRef == 2))
{
aCel.mNum = mNumSymb++;
tPair * aPair = &(*mDic.find(aF));
mVSymb.push_back(aPair);
}
}
Fonc_Num_Computed * compute (const Arg_Fonc_Num_Comp & arg)
{
Box2di b(0);
Tjs_El_User.ElAssert
(
arg.flux()->is_rect_2d(b),
EEM0 << "Must use operator created by `create_op_buf_simple_tpl'"
<< " with 2D rectangle flux"
);
INT nbpcky = mOptimizeNbPackY ?
adjust_nb_pack_y(_nb_pack_y,b._p1.y-b._p0.y) :
_nb_pack_y ;
Simple_OPBuf_Gen * calc = 0;
if (_f.integral_fonc(true))
calc = _calc_I;
else
calc = _calc_R;
Fonc_Num f = calc->adapt_box(_f,b);
if (f.integral_fonc(true))
return new Simple_Buffered_Op_Comp<INT,Itin>
(arg,_dim_out,f,_side,_calc_I,nbpcky,mCatFoncInit);
else
return new Simple_Buffered_Op_Comp<REAL,Rtin>
(arg,_dim_out,f,_side,_calc_R,nbpcky,mCatFoncInit);
}
REAL SurfIER_Fonc_Num_Not_Comp::ValFonc(const PtsKD & pts) const
{
return mFctr
(
Pt2dr(fCEl.x.ValFonc(pts),fCEl.y.ValFonc(pts)),
fA.ValFonc(pts),fB.ValFonc(pts),fC.ValFonc(pts),
Pt2dr(fP0.x.ValFonc(pts),fP0.y.ValFonc(pts)),
Pt2dr(fP1.x.ValFonc(pts),fP1.y.ValFonc(pts))
);
}
Fonc_Num SurfIER_Fonc_Num_Not_Comp::deriv(INT k) const
{
ELISE_ASSERT(mFctr==SurfIER,"SurfIER_Fonc_Num_Not_Comp::deriv");
return
fCEl.x.deriv(k) * FNF("DerCElXSurfIER",DerCElXSurfIER)
+ fCEl.y.deriv(k) * FNF("DerCElYSurfIER",DerCElYSurfIER)
+ fA.deriv(k) * FNF("DerASurfIER",DerASurfIER)
+ fB.deriv(k) * FNF("DerBSurfIER",DerBSurfIER)
+ fC.deriv(k) * FNF("DerCSurfIER",DerCSurfIER)
+ fP0.x.deriv(k) * FNF("DerP0XSurfIER",DerP0XSurfIER)
+ fP0.y.deriv(k) * FNF("DerP0YSurfIER",DerP0YSurfIER)
+ fP1.x.deriv(k) * FNF("DerP1XSurfIER",DerP1XSurfIER)
+ fP1.y.deriv(k) * FNF("DerP1YSurfIER",DerP1YSurfIER);
}
Fonc_Num_Computed * OP_Naire_Not_Comp::compute
(const Arg_Fonc_Num_Comp & arg)
{
Fonc_Num_Computed * fc = _f.compute(arg);
Tjs_El_User.ElAssert
(
_accept_dim_in(fc->idim_out()),
EEM0
<< " Unexpected dimension for operator " << _name << "\n"
<< "| dim = " << fc->idim_out()
);
INT dout = _dim_out(fc->idim_out());
if (fc->integral())
{
if( _real)
return new OP_un_Ndim_Comp_RI(arg,fc,arg.flux(),dout,_fri);
else
return new OP_un_Ndim_Comp_II(arg,fc,arg.flux(),dout,_fii);
}
else
{
if ( _real)
return new OP_un_Ndim_Comp_RR(arg,fc,arg.flux(),dout,_frr);
else
return new OP_un_Ndim_Comp_IR(arg,fc,arg.flux(),dout,_fir);
}
}
Fonc_Num skeleton_gen(Fonc_Num f,INT max_d,L_ArgSkeleton larg,bool AvecDist)
{
Data_ArgSkeleton askel(10,10,larg);
INT d = (max_d + 1)/2 + 2; // euclid dist
if (askel._ang >0)
{
REAL da = (d * 1.2) / cos(atan(askel._ang+1)) +2;
d = std::max (d,round_up(da));
}
d = std::max(d,askel._surf+2);
INT per_reaf = (INT) (3 * d) + 5;
per_reaf = std::max(per_reaf,500);
return create_op_buf_simple_tpl
(
new Skel_OPB_Comp(larg,AvecDist),
f,
AvecDist ? 2 : f.dimf_out(),
Box2di(d),
per_reaf
);
}
void cDico_SymbFN::PutFonc(Fonc_Num aF,cElCompileFN & aComp)
{
tIter anIt = mDic.find(aF);
if (anIt==mDic.end())
{
aF.compile(aComp);
return;
}
cCelDico_SFN & aCel = anIt->second;
if ( aCel.mSymbPut)
aComp << aCel.NameSymb();
else
aF.compile(aComp);
}
void cDico_SymbFN::PutSymbs(cElCompileFN & anEnv)
{
for (INT aK=0 ; aK<INT(mVSymb.size()) ; aK++)
{
tPair * aPair = mVSymb[aK];
Fonc_Num aPF = aPair->first;
anEnv << " double "
<< aPair->second.NameSymb()
<< " = "
<< aPF << ";" ;
if (aPF.HasNameCpp())
anEnv << " // " << aPF.NameCpp();
anEnv << "\n";
aPair->second.mSymbPut = true;
}
anEnv << "\n";
}
void SystLinSurResolu::PushDifferentialEquation
(
Fonc_Num aFonc,
const PtsKD & aPts,
REAL aPds
)
{
INT anIndEq = mNbEqCur;
SetNbEquation(mNbEqCur+1);
mDataB[anIndEq] = - aFonc.ValFonc(aPts);
for (INT iVar=0; iVar<mNbVarCur ; iVar++)
{
mDataA[anIndEq][iVar] = aFonc.ValDeriv(aPts,iVar);
mDataB[anIndEq] += mDataA[anIndEq][iVar] * aPts(iVar);
}
mDataPds[anIndEq] = aPds;
}
void cDynFoncteur::ComputeValDeriv()
{
ELISE_ASSERT(mDimOut==1,"Dim !=1,DynFoncteur");
mVal[0] = mFoncForm.ValFonc(mPts);
for (INT aD = 0 ; aD<mNbCompVar ; aD++)
{
INT aIC = LIC(aD);
mCompDer[0][aIC] = mDerForm[aD].ValFonc(mPts);
}
}
Fonc_Num skeleton_and_dist(Fonc_Num f,INT max_d,L_ArgSkeleton larg)
{
Tjs_El_User.ElAssert
(
f.dimf_out()==1,
EEM0 << "dim should equal 1 in skeleton_and_dist"
);
return skeleton_gen(f,max_d,larg,true);
}
template <class Type> void bench_op_buf_cat
(
Type *,
Fonc_Num aOpFonc,
Fonc_Num aFoncInit,
Fonc_Num aFoncCat,
Pt2di p0,
Pt2di p1
)
{
INT dOp = aOpFonc.dimf_out();
INT dInit = aFoncInit.dimf_out();
INT dTot = aFoncCat.dimf_out();
BENCH_ASSERT(dTot== (dInit+dOp));
Type * dif = new Type [dTot];
ELISE_COPY
(
rectangle(p0,p1),
Abs(aFoncCat-Virgule(aOpFonc,aFoncInit)),
sigma(dif,dTot)
);
for (INT d=0; d<dTot ; d++)
{
BENCH_ASSERT(dif[d]==0);
}
delete [] dif;
}
INT SurfIER_Fonc_Num_Not_Comp::CmpFormelIfSameKind(Fonc_Num_Not_Comp * aF2)
{
SurfIER_Fonc_Num_Not_Comp * pSFNC = (SurfIER_Fonc_Num_Not_Comp *) aF2;
INT res = CmpTertiare(mName,pSFNC->mName);
if (res) return res;
res = fCEl.x.CmpFormel(pSFNC->fCEl.x);
if (res) return res;
res = fCEl.y.CmpFormel(pSFNC->fCEl.y);
if (res) return res;
res = fA.CmpFormel(pSFNC->fA);
if (res) return res;
res = fB.CmpFormel(pSFNC->fB);
if (res) return res;
res = fC.CmpFormel(pSFNC->fC);
if (res) return res;
res = fP0.x.CmpFormel(pSFNC->fP0.x);
if (res) return res;
res = fP0.y.CmpFormel(pSFNC->fP0.y);
if (res) return res;
res = fP1.x.CmpFormel(pSFNC->fP1.x);
if (res) return res;
res = fP1.y.CmpFormel(pSFNC->fP1.y);
if (res) return res;
return 0;
}
template <class Type> Fonc_Num Tfonc_a_trou(Fonc_Num f,Liste_Pts<Type,INT> l)
{
Tjs_El_User.ElAssert
(
f.dimf_out() <= l.dim()-2,
EEM0 << "fonc_a_trou : Fonc_Num.dimf_out() > Liste_Pts.dim()-2"
);
return create_op_buf_simple_tpl
(
new FoncATrou_OPB_Comp<Type> (l),
0,
f,
l.dim()-2,
Box2di(0)
);
}
Fonc_Num_Computed * Kieme_Opb_Not_Comp::compute(const Arg_Fonc_Num_Comp & arg)
{
return new Kieme_Opb_Comp
(
arg,
(mModePond ? 1 : _f.dimf_out()),
_f,
_side,
_kth,
_mode,
_max_vals,
_mode_res,
mCatInit,
mModePond
);
}
void FillStat(cXml_StatVino & aStat,Flux_Pts aFlux,Fonc_Num aFonc)
{
aFonc = Rconv(aFonc);
int aNbCh = aFonc.dimf_out();
aStat.Soms().resize(aNbCh,0.0);
aStat.Soms2().resize(aNbCh,0.0);
aStat.ECT().resize(aNbCh,0.0);
aStat.VMax().resize(aNbCh,0.0);
aStat.VMin().resize(aNbCh,0.0);
Symb_FNum aSF(aFonc);
ELISE_COPY
(
aFlux,
Virgule(1.0,aSF,Square(aSF)),
Virgule
(
sigma(aStat.Nb()),
sigma(VData(aStat.Soms()),aNbCh) | VMin(VData(aStat.VMin()),aNbCh) | VMax(VData(aStat.VMax()),aNbCh),
sigma(VData(aStat.Soms2()),aNbCh)
)
);
double aNb = aStat.Nb();
aStat.IntervDyn() = Pt2dr(0,0);
for (int aK=0 ; aK<aNbCh ; aK++)
{
aStat.Soms()[aK] /= aNb;
aStat.Soms2()[aK] /= aNb;
aStat.ECT()[aK] = sqrt(ElMax(0.0,aStat.Soms2()[aK]-ElSquare(aStat.Soms()[aK])));
aStat.IntervDyn().x += aStat.VMin()[aK];
aStat.IntervDyn().y += aStat.VMax()[aK];
}
aStat.IntervDyn() = aStat.IntervDyn() / aNbCh;
}
cDynFoncteur::cDynFoncteur
(
const cIncListInterv & aListInterv,
const cECFN_SetString & aScVS,
Fonc_Num aFonc
) :
cElCompiledFonc(1),
mScVS (aScVS),
mFoncForm (aFonc),
mPts (aListInterv.I1Max())
{
// ELISE_ASSERT(aListInterv.IsConnexe0N(),"Bad Interv in cDynFoncteur::cDynFoncteur");
const cMapIncInterv & aMap = aListInterv.Map();
for (tCSetIII itCur = aMap.begin() ; itCur != aMap.end() ; itCur++)
AddIntRef (*itCur);
Close(true);
for (INT aD=0 ; aD<mNbCompVar ; aD++)
{
INT aIC = LIC(aD);
mDerForm.push_back(aFonc.deriv(aIC));
}
}
REAL ValFonc(const PtsKD & pts) const
{
return _f.ValFonc(pts);
}
virtual void show(ostream & os) const
{
_f.show(os);
}
virtual bool is1() const
{
return _f.is1();
}
void VarDerNN(ElGrowingSetInd & aSet)const {_f.VarDerNN(aSet);}
virtual Fonc_Num deriv(INT k) const
{
return _f.deriv(k);
}
virtual bool integral_fonc (bool iflx) const
{return _f.integral_fonc(iflx);}
virtual INT dimf_out() const
{
return _f.dimf_out();
}
virtual INT dimf_out() const
{
return _dim_out + (mCatFoncInit?_f.dimf_out() : 0);
}
int ConvertIm_main(int argc,char ** argv)
{
MMD_InitArgcArgv(argc,argv);
Tiff_Im::SetDefTileFile(1000000);
std::string aNameIn ;
INT aReducX=0;
INT aReducY=0;
INT aReducXY=0;
INT aVisu=0;
GenIm::type_el aTypeOut ;
std::string aNameTypeOut ="";
Tiff_Im::PH_INTER_TYPE aPhInterpOut ;
std::string aNamePITOut ="";
std::string PITOut[] = {"RGB","BW"};
std::list<std::string> lOut(PITOut, PITOut + sizeof(PITOut) / sizeof(std::string) );
std::string aNameOut;
std::string anExt;
Pt2di aP0(0,0);
Pt2di aSzOut ;
Pt2di aSzTF(-1,-1);
REAL aDyn=1.0;
Pt2di aSzTileInterne(-1,-1);
int aKCh = -1;
std::vector<int> aVPermut;
int aNoTile = 0;
std::string aF2 ="";
ElInitArgMain
(
argc,argv,
LArgMain() << EAMC(aNameIn, "Image", eSAM_IsExistFile),
LArgMain() << EAM(aNameOut,"Out",true)
<< EAM(anExt,"Ext",true)
<< EAM(aSzOut,"SzOut",true, "Size out", eSAM_NoInit)
<< EAM(aP0,"P0",true)
<< EAM(aNameTypeOut,"Type",true, "TypeMNT", eSAM_None, ListOfVal(GenIm::bits1_msbf, ""))
<< EAM(aNamePITOut,"Col",true, "Col", eSAM_None,lOut)
<< EAM(aReducXY,"ReducXY",true)
<< EAM(aReducX,"ReducX",true)
<< EAM(aReducY,"ReducY",true)
<< EAM(aVisu,"Visu",true)
<< EAM(aSzTF,"SzTifTile",true)
<< EAM(aSzTileInterne,"SzTileInterne",true)
<< EAM(aDyn,"Dyn",true)
<< EAM(aKCh,"KCh",true)
<< EAM(aNoTile,"NoTile",true)
<< EAM(aVPermut,"Permut",true, "Permut", eSAM_NoInit)
<< EAM(aF2,"F2",true)
);
if (!MMVisualMode)
{
// Tiff_Im aTifIn = Tiff_Im::BasicConvStd(aNameIn);
Tiff_Im aTifIn = Tiff_Im::UnivConvStd(aNameIn);
INT aNbChIn = aTifIn.nb_chan();
if (! EAMIsInit(&aTypeOut)) aTypeOut =aTifIn.type_el();
if (! EAMIsInit(&aPhInterpOut)) aPhInterpOut = aTifIn.phot_interp();
if (! EAMIsInit(&aSzOut)) aSzOut = aTifIn.sz();
if (aReducXY)
{
aReducX = 1;
aReducY = 1;
}
if (aNameOut=="")
{
if (anExt=="")
{
if (aReducX && aReducY)
anExt = "_RXY";
else if (aReducX)
anExt = "_RX";
else if (aReducY)
anExt = "_RY";
else
anExt= "_Out";
}
if (IsPostfixed(aNameIn))
aNameOut = StdPrefix(aNameIn) + anExt +"." + StdPostfix(aNameIn);
else
aNameOut = aNameIn + anExt + "tif";
}
Pt2di aCoefReduc(aReducX != 0 ? 2 : 1, aReducY != 0 ? 2 : 1);
aSzOut = aSzOut.dcbyc(aCoefReduc);
if (aNameTypeOut != "")
aTypeOut = type_im(aNameTypeOut);
if (aKCh != -1)
aNamePITOut="BW";
if ( aVPermut.size() !=0)
{
if ( aVPermut.size() ==1)
aPhInterpOut = Tiff_Im::BlackIsZero;
else if ( aVPermut.size() ==3)
aPhInterpOut = Tiff_Im::RGB;
else
{
ELISE_ASSERT(aNamePITOut=="","Nb Canaux incoherents");
}
}
else
{
if (aNamePITOut=="RGB")
aPhInterpOut = Tiff_Im::RGB;
else if (aNamePITOut=="BW")
aPhInterpOut = Tiff_Im::BlackIsZero;
else
{
ELISE_ASSERT(aNamePITOut=="","Mode Couleur Inconnu");
}
}
Tiff_Im::COMPR_TYPE aComprOut = Tiff_Im::No_Compr;
L_Arg_Opt_Tiff aLArg = Tiff_Im::Empty_ARG;
if (! aNoTile)
{
if (aSzTileInterne != Pt2di(-1,-1))
aLArg = aLArg + Arg_Tiff(Tiff_Im::ATiles(aSzTileInterne));
if (aSzTF != Pt2di(-1,-1))
aLArg = aLArg + Arg_Tiff(Tiff_Im::AFileTiling(aSzTF));
}
else
{
aLArg = aLArg + Arg_Tiff(Tiff_Im::ANoStrip());
aLArg = aLArg + Arg_Tiff(Tiff_Im::AFileTiling(Pt2di(-1,-1)));
}
Tiff_Im aTifOut
(
aNameOut.c_str(),
aSzOut,
aTypeOut,
aComprOut,
aPhInterpOut,
aLArg
);
INT aNbChOut = aTifOut.nb_chan();
Pt2di aSzROut = aSzOut;
Output anOut = aTifOut.out();
Fonc_Num aFin = aTifIn.in_proj();
if (aF2!="")
{
Tiff_Im aT2 = Tiff_Im::BasicConvStd(DirOfFile(aNameIn)+aF2);
aFin = Virgule(aFin,aT2.in(0));
}
if (aVPermut.size() != 0)
aFin = aFin.permut(aVPermut);
if (type_im_integral( aTypeOut))
{
}
else
{
aFin = Rconv(aFin);
}
aFin = reduc_binaire_gen(aFin, aReducX != 0, aReducY != 0, 16, true, 0);
anOut = Filtre_Out_RedBin_Gen(anOut, aReducX != 0, aReducY != 0);
aSzROut = aSzOut.mcbyc(aCoefReduc);
aFin = trans(aFin,aP0);
if (aKCh!=-1)
aFin = aFin.kth_proj(aKCh);
else
{
if ((aNbChOut==1) && (aNbChIn==3))
aFin = (aFin.v0() + aFin.v1() + aFin.v2()) / 3.0;
if ((aNbChOut==3) && (aNbChIn==1))
aFin = Virgule(aFin,aFin,aFin);
}
if (aVisu)
anOut = anOut | Video_Win::WiewAv(aSzROut);
if (aDyn != 1.0)
aFin = aFin * aDyn;
if (type_im_integral(aTypeOut) && (aTypeOut!=GenIm::int4))
{
int aVMin,aVMax;
min_max_type_num(aTypeOut,aVMin,aVMax);
aFin = Max(aVMin,Min(aVMax-1,aFin));
}
ELISE_COPY(rectangle(Pt2di(0,0),aSzROut),aFin,anOut);
return EXIT_SUCCESS;
}
else return EXIT_SUCCESS;
}
Fonc_Num SimplifyFCUV(Fonc_Num aF)
{
if (FnumCoorUseCsteVal) return aF.Simplify();
return aF;
}
void cDynFoncteur::ComputeVal()
{
ELISE_ASSERT(mDimOut==1,"Dim !=1,DynFoncteur");
mVal[0] = mFoncForm.ValFonc(mPts);
}
bool operator()
(const Fonc_Num & aF1,const Fonc_Num & aF2) const
{
return aF1.CmpFormel(aF2) == -1;
}
