void PartitionRenato(int argc,char** argv)
{
std::string aName;
double aPropSzW=0.1,aSeuil=75;
double aPropExag = 0.1;
int aNbIter = 3;
ElInitArgMain
(
argc,argv,
LArgMain() << EAMC(aName,"Name Input"),
LArgMain() << EAM(aPropSzW,"PropSzW",true,"Prop Size of W, def =0.1")
<< EAM(aSeuil,"Seuil",true,"Threshold beetween Black & White, Def=75")
);
Tiff_Im aTIn = Tiff_Im::UnivConvStd(aName);
Pt2di aSz = aTIn.sz();
int aSzW = round_ni((euclid(aSz)*aPropSzW) / sqrt(aNbIter));
Im2D_REAL4 anIm0(aSz.x,aSz.y);
Im2D_REAL4 anIm1(aSz.x,aSz.y);
Im2D_U_INT1 aImInside(aSz.x,aSz.y,1);
ELISE_COPY(anIm0.all_pts(),255-aTIn.in(),anIm0.out());
int aNbF = 3;
for (int aKF=0 ; aKF<aNbF ; aKF++)
{
Im2D_REAL4 anImFond(aSz.x,aSz.y);
Fonc_Num aFIn = anIm0.in(0);
for (int aK=0 ; aK<aNbIter ; aK++)
aFIn = (rect_som(aFIn,aSzW)*aImInside.in(0)) / Max(1.0,rect_som(aImInside.in(0),aSzW));
ELISE_COPY(anImFond.all_pts(),aFIn,anImFond.out());
if (aKF == (aNbF-1))
{
Fonc_Num aF = anIm0.in()-anImFond.in();
aF = aF / aSeuil;
aF = (aF -0.1) / (1-2*aPropExag);
aF = Max(0.0,Min(1.0,aF));
ELISE_COPY(anIm1.all_pts(),255.0 *(1-aF),anIm1.out());
}
else
{
ELISE_COPY
(
aImInside.all_pts(),
anIm0.in() < anImFond.in()+aSeuil,
aImInside.out()
);
}
}
Tiff_Im::Create8BFromFonc(std::string("Bin-")+StdPrefix(aName)+".tif",aTIn.sz(),anIm1.in());
}
bool MultiChannel<tData>::read_tiff( Tiff_Im &i_tiff ) // Tiff_Im is not const because of ReadVecOfIm
{
if ( i_tiff.type_el()!=typeEl() ) return false;
vector<Im2DGen *> tiffChannels = i_tiff.ReadVecOfIm();
resize( i_tiff.sz().x, i_tiff.sz().y, i_tiff.nb_chan() );
for ( size_t i=0; i<mChannels.size(); i++ )
set( i, *(Im2D<tData,tBase>*)tiffChannels[i] );
return true;
}
void cPackObsLiaison::GetPtsTerrain
(
const cParamEstimPlan & aPEP,
cSetName & aSelectorEstim,
cArgGetPtsTerrain & anArg,
const char * anAttr
)
{
cStatObs aSO(false);
if ( aPEP.AttrSup().IsInit())
anAttr = aPEP.AttrSup().Val().c_str();
ELISE_ASSERT
(
mIsMult,
"Require PMUL for cPackObsLiaison::GetPtsTerrain"
);
cPonderationPackMesure aPPM = aPEP.Pond();
aPPM.Add2Compens().SetVal(false);
for
(
std::map<std::string,cObsLiaisonMultiple *>::iterator itOML=mDicoMul.begin();
itOML!=mDicoMul.end();
itOML++
)
{
cObsLiaisonMultiple * anOLM = itOML->second;
std::string aNameP = anOLM->Pose1()->Name();
if (aSelectorEstim.IsSetIn(aNameP))
{
Im2D_Bits<1> aM(1,1);
if (aPEP.KeyCalculMasq().IsInit())
{
std::string aNameM =
anAttr ?
mAppli.ICNM()->Assoc1To2(aPEP.KeyCalculMasq().Val(),aNameP,anAttr,true):
mAppli.ICNM()->StdCorrect(aPEP.KeyCalculMasq().Val(),aNameP,true);
aNameM = mAppli.DC() + aNameM;
Tiff_Im aTF = Tiff_Im::UnivConvStd(aNameM);
Pt2di aSz = aTF.sz();
aM = Im2D_Bits<1>(aSz.x,aSz.y);
ELISE_COPY(aTF.all_pts(),aTF.in_bool(),aM.out());
anArg.SetMasq(&aM);
}
anOLM->AddObsLM(aPPM,0,&anArg,(cArgVerifAero*)0,aSO,0);
anArg.SetMasq(0);
}
}
}
void TestNtt(const std::string &aName)
{
Tiff_Im aTF = Tiff_Im::StdConvGen(aName,1,true);
Pt2di aSz = aTF.sz();
Im2D_REAL4 aI0(aSz.x,aSz.y);
ELISE_COPY( aTF.all_pts(),aTF.in(),aI0.out());
int aWSz=2;
TIm2D<REAL4,REAL8> aTIm(aI0);
double aSomGlob=0.0;
double aNbGlob=0.0;
for (int aKdx=-aWSz ; aKdx<=aWSz ; aKdx+=aWSz)
{
printf("## ");
for (int aKdy=-aWSz ; aKdy<=aWSz ; aKdy+=aWSz)
{
int aDx = aKdx;
int aDy = aKdy;
Pt2di aDep(aDx,aDy);
Pt2di aP;
RMat_Inertie aMat;
for (aP.x = aWSz ; aP.x<aSz.x-aWSz ; aP.x++)
{
for (aP.y=aWSz ; aP.y<aSz.y-aWSz ; aP.y++)
{
aMat.add_pt_en_place(aTIm.get(aP),aTIm.get(aP+aDep));
}
}
double aC = aMat.correlation();
aC = 1-aC;
if (dist8(aDep) == aWSz)
{
aSomGlob += aC;
aNbGlob ++;
}
printf(" %4d",round_ni(10000*(aC)));
}
printf("\n");
}
aSomGlob /= aNbGlob;
std::cout << " G:" << aSomGlob << "\n";
printf("\n\n");
}
Im2D_Bits<1> GetMasqSubResol(const std::string & aName,double aResol)
{
Tiff_Im aTF = Tiff_Im::BasicConvStd(aName);
Pt2di aSzF = aTF.sz();
Pt2di aSzR = round_ni(Pt2dr(aSzF)/aResol);
Im2D_Bits<1> aRes(aSzR.x,aSzR.y);
Fonc_Num aFonc = aTF.in_bool_proj();
aFonc = StdFoncChScale(aFonc,Pt2dr(0,0),Pt2dr(aResol,aResol));
aFonc = aFonc > 0.75;
ELISE_COPY (aRes.all_pts(), aFonc,aRes.out());
return aRes;
}
void SobelTestNtt(const std::string &aName)
{
Tiff_Im aTF = Tiff_Im::StdConvGen(aName,1,true);
Pt2di aSz = aTF.sz();
Im2D_REAL4 aI0(aSz.x,aSz.y);
ELISE_COPY( aTF.all_pts(),aTF.in(),aI0.out());
Video_Win * aW=0;
// aW = Video_Win::PtrWStd(aSz);
if (aW)
{
ELISE_COPY(aW->all_pts(),Min(255,aI0.in()/256.0),aW->ogray());
aW->clik_in();
}
Fonc_Num aF1 = sobel(aI0.in_proj());
Fonc_Num aF2 = aI0.in_proj();
for (int aK=0 ; aK<3 ; aK++)
aF2 = rect_som(aF2,1) / 9.0;
aF2 = sobel(aF2);
if (aW)
{
ELISE_COPY(aW->all_pts(),Min(255, 200 * (aF1/Max(aF2,1e-7))),aW->ogray());
aW->clik_in();
}
double aSF1,aSF2,aSomPts;
ELISE_COPY(aI0.all_pts(),Virgule(aF1,aF2,1.0),Virgule(sigma(aSF1),sigma(aSF2),sigma(aSomPts)));
std::cout << "Indice " << aSF1 / aSF2 << "\n";
}
cTmpReechEpip::cTmpReechEpip
(
bool aConsChan,
const std::string & aNameOri,
Box2dr aBoxImIn,
ElDistortion22_Gen * anEpi,
Box2dr aBox,
double aStep,
const std::string & aNameOut,
const std::string & aPostMasq,
int aNumKer ,
bool Debug
) :
mBoxImIn(aBoxImIn),
mEpi (anEpi),
mStep (aStep),
mP0 (aBox._p0),
mSzEpi (aBox.sz()),
mSzRed (round_up (aBox.sz() / aStep) + Pt2di(1,1)),
mRedIMasq (mSzRed.x,mSzRed.y,0),
mRedTMasq (mRedIMasq),
mRedImX (mSzRed.x,mSzRed.y),
mRedTImX (mRedImX),
mRedImY (mSzRed.x,mSzRed.y),
mRedTImY (mRedImY)
{
cInterpolateurIm2D<REAL4> * aPtrSCI = 0;
if (aNumKer==0)
{
aPtrSCI = new cInterpolBilineaire<REAL4>;
}
else
{
cKernelInterpol1D * aKer = 0;
if (aNumKer==1)
aKer = new cCubicInterpKernel(-0.5);
else
aKer = new cSinCardApodInterpol1D(cSinCardApodInterpol1D::eTukeyApod,aNumKer,aNumKer/2,1e-4,false);
aPtrSCI = new cTabIM2D_FromIm2D<REAL4> (aKer,1000,false);
// cTabIM2D_FromIm2D<REAL4> aSSCI (&aKer,1000,false);
}
cInterpolateurIm2D<REAL4> & aSCI = *aPtrSCI;
Pt2di aPInd;
for (aPInd.x=0 ; aPInd.x<mSzRed.x ; aPInd.x++)
{
for (aPInd.y=0 ; aPInd.y<mSzRed.y ; aPInd.y++)
{
bool Ok= false;
Pt2dr aPEpi = ToFullEpiCoord(aPInd);
Pt2dr aPIm = anEpi->Inverse(aPEpi);
if ((aPIm.x>mBoxImIn._p0.x) && (aPIm.y>mBoxImIn._p0.y) && (aPIm.x<mBoxImIn._p1.x) && (aPIm.y<mBoxImIn._p1.y))
{
Pt2dr aPEpi2 = anEpi->Direct(aPIm);
if (euclid(aPEpi-aPEpi2) < 1e-2)
{
Ok= true;
mRedTMasq.oset(aPInd,Ok);
}
}
mRedTImX.oset(aPInd,aPIm.x);
mRedTImY.oset(aPInd,aPIm.y);
}
}
ELISE_COPY(mRedIMasq.all_pts(),dilat_d8(mRedIMasq.in(0),4),mRedIMasq.out());
Tiff_Im aTifOri = Tiff_Im::StdConvGen(aNameOri.c_str(),aConsChan ? -1 :1 ,true);
Tiff_Im aTifEpi = Debug ?
Tiff_Im(aNameOut.c_str()) :
Tiff_Im
(
aNameOut.c_str(),
mSzEpi,
aTifOri.type_el(),
Tiff_Im::No_Compr,
aTifOri.phot_interp()
) ;
Tiff_Im aTifMasq = aTifEpi;
bool ExportMasq = (aPostMasq!="NONE");
// std::cout << "POSTMAS " << aPostMasq << "\n";
if (ExportMasq)
{
std::string aNameMasq = StdPrefix(aNameOut)+ aPostMasq +".tif";
aTifMasq = Debug ?
Tiff_Im(aNameMasq.c_str()) :
Tiff_Im
(
aNameMasq.c_str(),
mSzEpi,
GenIm::bits1_msbf,
Tiff_Im::No_Compr,
Tiff_Im::BlackIsZero
) ;
}
int aNbBloc=2000;
int aBrd = aNumKer+10;
Pt2di aSzBrd(aBrd,aBrd);
int aX00 = 0;
int aY00 = 0;
for (int aX0=aX00 ; aX0<mSzEpi.x ; aX0+=aNbBloc)
{
int aX1 = ElMin(aX0+aNbBloc,mSzEpi.x);
for (int aY0=aY00 ; aY0<mSzEpi.y ; aY0+=aNbBloc)
{
// std::cout << "X0Y0 " << aX0 << " " << aY0 << "\n";
int aY1 = ElMin(aY0+aNbBloc,mSzEpi.y);
Pt2di aP0Epi(aX0,aY0);
Pt2di aSzBloc(aX1-aX0,aY1-aY0);
TIm2D<REAL4,REAL8> aTImX(aSzBloc);
TIm2D<REAL4,REAL8> aTImY(aSzBloc);
TIm2DBits<1> aTImMasq(aSzBloc,0);
Pt2dr aInfIm(1e20,1e20);
Pt2dr aSupIm(-1e20,-1e20);
bool NonVide= false;
for (int anX =aX0 ; anX<aX1 ; anX++)
{
for (int anY =aY0 ; anY<aY1 ; anY++)
{
Pt2dr aIndEpi (anX/mStep , anY/mStep);
Pt2di aPIndLoc (anX-aX0,anY-aY0);
if (mRedTMasq.get(round_down(aIndEpi)))
{
double aXIm = mRedTImX.getr(aIndEpi,-1,true);
double aYIm = mRedTImY.getr(aIndEpi,-1,true);
if ((aXIm>0) && (aYIm>0))
{
// aTImMasq.oset(aPIndLoc,1);
aTImX.oset(aPIndLoc,aXIm);
aTImY.oset(aPIndLoc,aYIm);
aInfIm = Inf(aInfIm,Pt2dr(aXIm,aYIm));
aSupIm = Sup(aSupIm,Pt2dr(aXIm,aYIm));
NonVide= true;
}
}
}
}
Pt2di aP0BoxIm = Sup(Pt2di(0,0),Pt2di(round_down(aInfIm) - aSzBrd));
Pt2di aP1BoxIm = Inf(aTifOri.sz(),Pt2di(round_down(aSupIm) + aSzBrd));
Pt2di aSzIm = aP1BoxIm - aP0BoxIm;
NonVide = NonVide && (aSzIm.x>0) && (aSzIm.y>0);
if (NonVide)
{
// std::vector<Im2D_REAL4> aVIm;
std::vector<Im2D_REAL4> aVIm= aTifOri.VecOfImFloat(aSzIm);
ELISE_COPY
(
rectangle(Pt2di(0,0),aSzIm),
trans(aTifOri.in(),aP0BoxIm),
StdOut(aVIm)
);
std::vector<Im2D_REAL4> aVImEpi = aTifEpi.VecOfImFloat(aSzBloc);
ELISE_ASSERT(aVImEpi.size()==aVIm.size(),"Incohe in nb chan, cTmpReechEpip::cTmpReechEpip");
for (int aKIm=0 ; aKIm <int(aVImEpi.size()) ; aKIm++)
{
TIm2D<REAL4,REAL8> aImEpi(aVImEpi[aKIm]);
REAL4 ** aDataOri = aVIm[aKIm].data();
for (int anX =0 ; anX<aSzBloc.x ; anX++)
{
for (int anY =0 ; anY<aSzBloc.y ; anY++)
{
Pt2di aIndEpi(anX,anY);
aImEpi.oset(aIndEpi,0);
Pt2di anIndEpiGlob = aIndEpi + aP0Epi;
Pt2dr aIndEpiRed (anIndEpiGlob.x/mStep , anIndEpiGlob.y/mStep);
if (mRedTMasq.get(round_down(aIndEpiRed),0))
{
double aXIm = mRedTImX.getr(aIndEpiRed,-1,true);
double aYIm = mRedTImY.getr(aIndEpiRed,-1,true);
Pt2dr aPImLoc = Pt2dr(aXIm,aYIm) - Pt2dr(aP0BoxIm);
double aV= 128;
if ((aPImLoc.x>aNumKer+2) && (aPImLoc.y>aNumKer+2) && (aPImLoc.x<aSzIm.x-aNumKer-3) && (aPImLoc.y<aSzIm.y-aNumKer-3))
{
aTImMasq.oset(aIndEpi,1);
aV = aSCI.GetVal(aDataOri,aPImLoc);
// aV= 255;
}
aImEpi.oset(aIndEpi,aV);
}
}
}
}
ELISE_COPY
(
rectangle(aP0Epi,aP0Epi+aSzBloc),
Tronque(aTifEpi.type_el(),trans(StdInput(aVImEpi),-aP0Epi)),
aTifEpi.out()
);
}
if (ExportMasq)
{
ELISE_COPY
(
rectangle(aP0Epi,aP0Epi+aSzBloc),
trans(aTImMasq._the_im.in(0),-aP0Epi),
aTifMasq.out()
);
}
// std::cout << "ReechDONE " << aX0 << " "<< aY0 << "\n";
}
}
}
int HomFilterMasq_main(int argc,char ** argv)
{
// MemoArg(argc,argv);
MMD_InitArgcArgv(argc,argv);
std::string aDir,aPat,aFullDir;
bool ExpTxt=false;
std::string PostPlan="_Masq";
std::string KeyCalcMasq;
std::string KeyEquivNoMasq;
std::string MasqGlob;
double aResol=10;
bool AcceptNoMask;
std::string aPostIn= "";
std::string aPostOut= "MasqFiltered";
std::string aOriMasq3D,aNameMasq3D;
cMasqBin3D * aMasq3D = 0;
Pt2dr aSelecTer;
ElInitArgMain
(
argc,argv,
LArgMain() << EAMC(aFullDir,"Full name (Dir+Pat)", eSAM_IsPatFile),
LArgMain()
<< EAM(PostPlan,"PostPlan",true,"Post to plan, Def : toto ->toto_Masq.tif like with SaisieMasq")
<< EAM(MasqGlob,"GlobalMasq",true,"Global Masq to add to all image")
<< EAM(KeyCalcMasq,"KeyCalculMasq",true,"For tuning masq per image")
<< EAM(KeyEquivNoMasq,"KeyEquivNoMasq",true,"When given if KENM(i1)==KENM(i2), don't masq")
<< EAM(aResol,"Resol",true,"Sub Resolution for masq storing, Def=10")
<< EAM(AcceptNoMask,"ANM",true,"Accept no mask, def = true if MasqGlob and false else")
<< EAM(ExpTxt,"ExpTxt",true,"Ascii format for in and out, def=false")
<< EAM(aPostIn,"PostIn",true,"Post for Input dir Hom, Def=")
<< EAM(aPostOut,"PostOut",true,"Post for Output dir Hom, Def=MasqFiltered")
<< EAM(aOriMasq3D,"OriMasq3D",true,"Orientation for Masq 3D")
<< EAM(aNameMasq3D,"Masq3D",true,"File of Masq3D, Def=AperiCloud_${OriMasq3D}.ply")
<< EAM(aSelecTer,"SelecTer",true,"[Per,Prop] Period of tiling on ground selection, Prop=proporion of selected")
);
bool aHasOri3D = EAMIsInit(&aOriMasq3D);
bool HasTerSelec = EAMIsInit(&aSelecTer);
#if (ELISE_windows)
replace( aFullDir.begin(), aFullDir.end(), '\\', '/' );
#endif
SplitDirAndFile(aDir,aPat,aFullDir);
if (EAMIsInit(&PostPlan))
{
CorrecNameMasq(aDir,aPat,PostPlan);
}
if (!EAMIsInit(&AcceptNoMask))
AcceptNoMask = EAMIsInit(&MasqGlob) || aHasOri3D;
cInterfChantierNameManipulateur * anICNM = cInterfChantierNameManipulateur::BasicAlloc(aDir);
std::string aKeyOri;
if (aHasOri3D)
{
anICNM->CorrecNameOrient(aOriMasq3D);
if (! EAMIsInit(&aNameMasq3D))
{
aNameMasq3D = aDir + "AperiCloud_" + aOriMasq3D + "_polyg3d.xml";
}
if (ELISE_fp::exist_file(aDir+aNameMasq3D))
{
aMasq3D = cMasqBin3D::FromSaisieMasq3d(aDir+aNameMasq3D);
}
else
{
ELISE_ASSERT(EAMIsInit(&aSelecTer),"Unused OriMasq3D");
}
aKeyOri = "NKS-Assoc-Im2Orient@" + aOriMasq3D;
}
Im2D_Bits<1> aImMasqGlob(1,1);
if (EAMIsInit(&MasqGlob))
aImMasqGlob = GetMasqSubResol(aDir+MasqGlob,aResol);
const std::vector<std::string> * aVN = anICNM->Get(aPat);
std::vector<Im2D_Bits<1> > aVMasq;
std::vector<CamStenope *> aVCam;
double aResolMoy = 0;
for (int aKN = 0 ; aKN<int(aVN->size()) ; aKN++)
{
std::string aNameIm = (*aVN)[aKN];
Tiff_Im aTF = Tiff_Im::StdConvGen(aNameIm,1,false);
Pt2di aSzG = aTF.sz();
Pt2di aSzR (round_ni(Pt2dr(aSzG)/aResol));
Im2D_Bits<1> aImMasq(aSzR.x,aSzR.y,1);
std::string aNameMasq = StdPrefix(aNameIm)+PostPlan + ".tif";
if (EAMIsInit(&KeyCalcMasq))
{
aNameMasq = anICNM->Assoc1To1(KeyCalcMasq,aNameIm,true);
}
if (ELISE_fp::exist_file(aNameMasq))
{
Im2D_Bits<1> aImMasqLoc = GetMasqSubResol(aDir+aNameMasq,aResol);
ELISE_COPY(aImMasq.all_pts(),aImMasq.in() && aImMasqLoc.in(0),aImMasq.out());
}
else
{
if (!AcceptNoMask)
{
std::cout << "For Im " << aNameIm << " file " << aNameMasq << " does not exist\n";
ELISE_ASSERT(false,"Masq not found");
}
}
if (EAMIsInit(&MasqGlob))
{
ELISE_COPY(aImMasq.all_pts(),aImMasq.in() && aImMasqGlob.in(0),aImMasq.out());
}
aVMasq.push_back(aImMasq);
// Tiff_Im::CreateFromIm(aImMasq,"SousRes"+aNameMasq);
if (aHasOri3D)
{
aVCam.push_back(anICNM->StdCamOfNames(aNameIm,aOriMasq3D));
aResolMoy += aVCam.back()->GlobResol();
}
}
if (aHasOri3D)
aResolMoy /= aVCam.size();
std::string anExt = ExpTxt ? "txt" : "dat";
std::string aKHIn = std::string("NKS-Assoc-CplIm2Hom@")
+ std::string(aPostIn)
+ std::string("@")
+ std::string(anExt);
std::string aKHOut = std::string("NKS-Assoc-CplIm2Hom@")
+ std::string(aPostOut)
+ std::string("@")
+ std::string(anExt);
double aPeriodTer=0,aSeuilDistTer=0;
if (HasTerSelec)
{
aPeriodTer = aSelecTer.x * aResolMoy;
aSeuilDistTer = aPeriodTer * sqrt(aSelecTer.y);
}
double aNbInTer=0;
double aNbTestTer=0;
for (int aKN1 = 0 ; aKN1<int(aVN->size()) ; aKN1++)
{
for (int aKN2 = 0 ; aKN2<int(aVN->size()) ; aKN2++)
{
std::string aNameIm1 = (*aVN)[aKN1];
std::string aNameIm2 = (*aVN)[aKN2];
std::string aNameIn = aDir + anICNM->Assoc1To2(aKHIn,aNameIm1,aNameIm2,true);
if (ELISE_fp::exist_file(aNameIn))
{
bool UseMasq = true;
if (EAMIsInit(&KeyEquivNoMasq))
{
UseMasq = (anICNM->Assoc1To1(KeyEquivNoMasq,aNameIm1,true) != anICNM->Assoc1To1(KeyEquivNoMasq,aNameIm2,true) );
}
TIm2DBits<1> aMasq1 ( aVMasq[aKN1]);
TIm2DBits<1> aMasq2 ( aVMasq[aKN2]);
ElPackHomologue aPackIn = ElPackHomologue::FromFile(aNameIn);
ElPackHomologue aPackOut;
for (ElPackHomologue::const_iterator itP=aPackIn.begin(); itP!=aPackIn.end() ; itP++)
{
Pt2dr aP1 = itP->P1();
Pt2dr aP2 = itP->P2();
Pt2di aQ1 = round_ni(aP1/aResol);
Pt2di aQ2 = round_ni(aP2/aResol);
bool Ok = ((aMasq1.get(aQ1,0) && aMasq2.get(aQ2,0)) || (! UseMasq));
if (Ok && aHasOri3D)
{
Pt3dr aPTer= aVCam[aKN1]->PseudoInter(aP1,*(aVCam[aKN2]),aP2);
if (aMasq3D && (! aMasq3D->IsInMasq(aPTer)))
Ok = false;
if (Ok && HasTerSelec)
{
bool OkTer = (mod_real(aPTer.x,aPeriodTer) < aSeuilDistTer) && (mod_real(aPTer.y,aPeriodTer) < aSeuilDistTer);
Ok = OkTer;
aNbTestTer ++;
aNbInTer += OkTer;
}
}
if (Ok)
{
ElCplePtsHomologues aCple(aP1,aP2);
aPackOut.Cple_Add(aCple);
}
}
std::string aNameOut = aDir + anICNM->Assoc1To2(aKHOut,aNameIm1,aNameIm2,true);
aPackOut.StdPutInFile(aNameOut);
std::cout << "IN " << aNameIn << " " << aNameOut << " UseM " << UseMasq << "\n";
}
}
}
// std::vector<cImFMasq *> mVIm;
if (HasTerSelec)
{
std::cout << "A Posteriori Prop=" << aNbInTer / aNbTestTer << "\n";
}
return EXIT_SUCCESS;
}
int PreparSift_Main(int argc,char ** argv)
{
double aPEg = 1.0;
double aPSrtEg = 3.0;
double aPM = 2.0;
std::string aNameIn,aNameOut="Sift.tif";
ElInitArgMain
(
argc,argv,
LArgMain() << EAMC(aNameIn,"Full name (Dir+Pattern)", eSAM_IsPatFile),
LArgMain() << EAM(aNameOut,"NameOut",true)
);
Tiff_Im aTif = Tiff_Im::StdConvGen(aNameIn,1,true);
// Init Mems
Pt2di aSz = aTif.sz();
Im2D_U_INT2 anIm(aSz.x,aSz.y);
Im1D_REAL8 aH(aNbH,0.0);
// Load image
{
Symb_FNum aFTif(aTif.in());
ELISE_COPY(aTif.all_pts(),aFTif,anIm.out()| (aH.histo().chc(aFTif)<<1) );
}
Im1D_REAL8 aHSqrt(aNbH,0.0);
ELISE_COPY(aH.all_pts(),sqrt(aH.in()),aHSqrt.out());
int aVMax =0;
// Calcul Histo
MakeFoncRepart(aH,&aVMax);
MakeFoncRepart(aHSqrt);
// Fonc Loc
Fonc_Num aFonc(Rconv(anIm.in_proj()));
Fonc_Num aS1S2 = Virgule(aFonc,Square(aFonc));
for (int aK=0 ; aK< TheNbIter ; aK++)
{
aS1S2 = rect_som(aS1S2,TheNbVois) / ElSquare(1+2*TheNbVois);
}
Symb_FNum aFS1 = aS1S2.v0();
Symb_FNum aFS2 = aS1S2.v1()-Square(aFS1);
Fonc_Num aFLoc = (anIm.in()-aFS1) / sqrt(Max(1.0,aFS2));
// aFLoc = aFLoc * 20;
aFLoc = atan(aFLoc) /(PI/2);
// Symb_FNum aFonc(aTif.in());
std::cout << "MaxMin " << aVMax << "\n";
Fonc_Num aFEg = aH.in()[anIm.in()];
Fonc_Num aFEgS = aHSqrt.in()[anIm.in()];
Fonc_Num aFM = anIm.in() * (255.0 / aVMax);
// Fonc_Num aFRes = (aFEg*aPEg + aFM * aPM + aFEgS*aPSrtEg + aFLoc) / (aPEg + aPM + aPSrtEg);
Symb_FNum aFMoy = (aFEg*aPEg + aFM * aPM + aFEgS*aPSrtEg ) / (aPEg + aPM + aPSrtEg);
Symb_FNum aFMarge = Min(64,Min(aFMoy,255-aFMoy));
Fonc_Num aFRes = aFMoy + aFMarge * aFLoc;
/*
Fonc_Num aFRes = Max(0,Min(255,aFMoy + 60 * aFLoc));
*/
Tiff_Im::Create8BFromFonc(aNameOut,aSz,aFRes);
return EXIT_SUCCESS;
}
BiScroller::BiScroller
(
VideoWin_Visu_ElImScr & aVisu,
ElImScroller * ScrGray,
ElImScroller * ScrCol,
ModeFusion aModeFusion,
Elise_colour * Cols,
INT NbCol,
const std::string & mNameMasq
) :
ElImScroller (aVisu,1,Inf(ScrGray->SzU(),ScrCol?ScrCol->SzU():ScrGray->SzU()),1.0),
mMemGray (1,aVisu.SzW()),
mScrGray ( ScrGray),
mMemCol (1,aVisu.SzW()),
mScrCol (ScrCol),
mModeFusion (aModeFusion),
mVideoVisu (aVisu),
mImGray (mMemGray.Images()[0]),
mDataGray (mImGray.data()),
mImCol (mMemCol.Images()[0]),
mDataCol (mImCol.data()),
mTabRGB (3,NbCol,256),
mDataTabRGB (mTabRGB.data()),
mImR (aVisu.SzW().x,1),
mDataImR (mImR.data()[0]),
mImG (aVisu.SzW().x,1),
mDataImG (mImG.data()[0]),
mImB (aVisu.SzW().x,1),
mDataImB (mImB.data()[0]),
mTr (0.0,0.0),
mIm1Act (true),
mIm2Act (mScrCol!=0),
mImMasq (1,1)
{
mSubScrolls.push_back(mScrGray);
if (mScrCol)
mSubScrolls.push_back(mScrCol);
for (INT iCol = 0; iCol<NbCol ; iCol++)
for (INT iGray=0; iGray < 256; iGray ++)
{
Elise_colour CGray = Elise_colour::gray(iGray/255.0);
Elise_colour CCol = Cols[iCol];
Elise_colour ColMixed = som_pond(CCol,0.3,CGray);
if (iCol == 0)
ColMixed = CGray;
SetRGBEntry(iGray, iCol, ColMixed);
}
if (mNameMasq!="")
{
Tiff_Im aFM = Tiff_Im::UnivConvStd(mNameMasq);
Pt2di aSz = aFM.sz();
mImMasq=Im2D_U_INT1 (aSz.x,aSz.y);
Fonc_Num aFIn = aFM.in();
if (aModeFusion==eModeMasq)
{
aFIn = (aFM.in()!=0);
}
ELISE_COPY(aFM.all_pts(),aFIn,mImMasq.out());
}
/*
REAL DistCible = 60.0;
DistCible /= 255.0;
for (INT iCol = 0; iCol<NbCol ; iCol++)
{
Elise_colour CCol = Cols[iCol];
Elise_colour aGray = Elise_colour::gray(CCol.GrayVal());
REAL dist = ElMax(1e-10,aGray.eucl_dist(CCol));
Elise_colour vAtDit = aGray + (DistCible/dist) * (CCol-aGray);
Elise_colour v0 = vAtDit - Elise_colour::gray(vAtDit.MinRGB());
Elise_colour v1 = vAtDit + Elise_colour::gray(1.0-vAtDit.MaxRGB());
for (INT iGray=0; iGray < 256; iGray ++)
{
REAL GrayLevel = iGray/255.0;
Elise_colour ColMixed = som_pond(v0,1-GrayLevel,v1);
if (iCol == 0)
ColMixed = Elise_colour::gray(GrayLevel);
SetRGBEntry(iGray, iCol, ColMixed);
}
}
*/
}
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;
}
int GrShade_main(int argc,char ** argv)
{
std::string aNameIn;
std::string aNameOut;
std::string aNameCol="";
Pt2di aP0Glob(0,0),aSzGlob(0,0);
INT aNbDir = 20;
REAL aFZ = 1.0;
REAL aPdsAnis = 0.95;
INT aBrd = -1;
std::string aTMNt = "real4";
std::string aTShade = "real4";
INT aDequant =0;
INT aVisu = 0;
REAL aHypsoDyn = -1.0;
REAL aHypsoSat = 0.5;
Pt2di aSzMaxDalles (3000,3000);
INT aSzRecDalles = 300;
std::string aModeOmbre="CielVu";
std::string modeOmbre[] = {aModeOmbre,"IgnE","Local","Med","Mixte"};
std::list<std::string> lModeOmbre(modeOmbre, modeOmbre + sizeof(modeOmbre) / sizeof(std::string) );
std::string aFileMasq="";
double aDericheFact=2.0;
int aNbIterF = 4;
double aFactExp = 0.95;
double aDyn = 1.0;
int aNbMed = 100;
int aNbIterMed = 1;
Tiff_Im::SetDefTileFile(1<<15);
std::vector<double> aVPdsFiltre;
std::string aModeColor = "IntensShade";
std::string modeColor[] = {aModeColor,"BackRGB","GrayBackRGB"};
std::list<std::string> lModeColor(modeColor, modeColor + sizeof(modeColor) / sizeof(std::string) );
double aTetaH = 25.0;
double anAzimut = 0.0;
double aDynMed = 1.0;
ElInitArgMain
(
argc,argv,
LArgMain() << EAMC(aNameIn, "File name", eSAM_IsExistFile) ,
LArgMain() << EAM(aNameOut,"Out",true)
<< EAM(aNameCol,"FileCol",true, "Color file", eSAM_IsExistFile)
<< EAM(aVisu,"Visu",true)
<< EAM(aP0Glob,"P0",true)
<< EAM(aSzGlob,"Sz",true)
<< EAM(aFZ,"FZ",true)
<< EAM(aDynMed,"DynMed",true)
<< EAM(aPdsAnis,"Anisotropie",true)
<< EAM(aNbDir,"NbDir",true)
<< EAM(aBrd,"Brd",true)
<< EAM(aTMNt,"TypeMnt",true, "Type", eSAM_None, ListOfVal(GenIm::bits1_msbf, ""))
<< EAM(aTShade,"TypeShade",true, "Type", eSAM_None, ListOfVal(GenIm::bits1_msbf, ""))
<< EAM(aDequant,"Dequant",true)
<< EAM(aHypsoDyn,"HypsoDyn",true)
<< EAM(aHypsoSat,"HypsoSat",true)
<< EAM(aSzMaxDalles,"SzMaxDalles",true)
<< EAM(aSzRecDalles,"SzRecDalles",true)
<< EAM(aModeOmbre,"ModeOmbre",true,"in {CielVu,IgnE,Local,Med,Mixte}",eSAM_None,lModeOmbre)
<< EAM(aFileMasq,"Mask",true, "Mask file", eSAM_IsExistFile)
<< EAM(aDericheFact,"DericheFact",true)
<< EAM(aNbIterF,"NbIterF",true)
<< EAM(aFactExp,"FactExp",true)
<< EAM(aDyn,"Dyn",true)
<< EAM(aVPdsFiltre,"PdsF",true,"[CielVu,Local,Grad,Med]", eSAM_NoInit)
<< EAM(aModeColor,"ModeColor",true,"Color mode", eSAM_None, lModeColor)
<< EAM(aNbMed,"NbMed",true)
<< EAM(aNbIterMed,"NbIterMed",true)
<< EAM(aTetaH,"TetaH",true)
<< EAM(anAzimut,"Azimut",true)
);
if (!MMVisualMode)
{
double aPdsDef = aVPdsFiltre.size() ? 0 : 1;
for (int aK=aVPdsFiltre.size() ; aK<4 ; aK++)
aVPdsFiltre.push_back(aPdsDef);
double aSPdsF = 0;
for (int aK=0 ; aK<4 ; aK++)
aSPdsF += aVPdsFiltre[aK];
for (int aK=0 ; aK<4 ; aK++)
aVPdsFiltre[aK] /= aSPdsF;
std::string aDir,aNameFileIn;
SplitDirAndFile(aDir,aNameFileIn,aNameIn);
bool WithHypso = (aHypsoDyn>0) || (aNameCol != "");
// bool WithCol = (aNameCol != "");
if (aNameOut=="")
aNameOut = StdPrefix(aNameIn) +std::string("Shade.tif");
Tiff_Im aFileIn = Tiff_Im::StdConvGen(aNameIn,1,true,false);
if (aSzGlob== Pt2di(0,0))
aSzGlob = aFileIn.sz() -aP0Glob;
Fonc_Num aFIn = aFileIn.in_gen(Tiff_Im::eModeCoulGray,Tiff_Im::eModeNoProl);
{
Tiff_Im
(
aNameOut.c_str(),
aSzGlob,
GenIm::u_int1,
Tiff_Im::No_Compr,
WithHypso ? Tiff_Im::RGB : Tiff_Im::BlackIsZero
);
}
Tiff_Im aTifOut(aNameOut.c_str());
if (aSzMaxDalles.x<0) aSzMaxDalles = aSzGlob;
Pt2di aPRD(aSzRecDalles,aSzRecDalles);
cDecoupageInterv2D aDecoup
(
Box2di(aP0Glob,aP0Glob+aSzGlob),
aSzMaxDalles,
Box2di(-aPRD,aPRD)
);
Im2DGen aMnt = AllocImGen(aDecoup.SzMaxIn(),aTMNt);
Im2DGen aShade = AllocImGen(aDecoup.SzMaxIn(),aTShade);
cout << "SZ Max In " << aDecoup.SzMaxIn() << endl;
REAL aRatio = ElMin(800.0/aSzGlob.x,700.0/aSzGlob.y);
Video_Win * pW = aVisu ?
Video_Win::PtrWStd(Pt2di(Pt2dr(aSzGlob)*aRatio)) :
0 ;
aTetaH *= (2*PI)/360.0;
anAzimut *= (2*PI)/360.0;
for (int aKDec=0; aKDec<aDecoup.NbInterv() ; aKDec++)
{
Box2di aBoxIn = aDecoup.KthIntervIn(aKDec);
Pt2di aSzIn = aBoxIn.sz();
Pt2di aP0In = aBoxIn.P0();
cout << "DEQ " << aDequant << "Sz In " << aSzIn <<endl;
REAL aVMin;
if (aDequant)
{
ElImplemDequantifier aDeq(aSzIn);
aDeq.SetTraitSpecialCuv(true);
aDeq.DoDequantif(aSzIn, trans(aFIn,aP0In),true);
REAL aVMax;
ELISE_COPY
(
rectangle(Pt2di(0,0),aSzIn),
aDeq.ImDeqReelle() * aFZ,
aMnt.out() | VMax(aVMax) |VMin(aVMin)
);
}
else
{
ELISE_COPY
(
rectangle(Pt2di(0,0),aSzIn),
trans(aFIn,aP0In)*aFZ,
aMnt.out()|VMin(aVMin)
);
}
Im2D_Bits<1> aIMasq(aSzIn.x,aSzIn.y,1);
if (aFileMasq!="")
{
if (ELISE_fp::exist_file(aDir+aFileMasq))
aFileMasq = aDir+aFileMasq;
double aDif=100;
Tiff_Im aFM = Tiff_Im::StdConvGen(aFileMasq,1,true,false);
ELISE_COPY
(
select(rectangle(Pt2di(0,0),aSzIn),trans(!aFM.in_proj(),aP0In)),
aVMin-aDif,
aMnt.out()
| (aIMasq.out() << 0)
);
aVMin-= aDif;
}
if (aBrd>0)
{
cout << "VMin = " << aVMin <<endl;
ELISE_COPY(aMnt.border(aBrd),aVMin-1000,aMnt.out());
}
// Im2D_REAL4 aShade(aSzGlob.x,aSzGlob.y);
ELISE_COPY(aShade.all_pts(),0,aShade.out());
if (pW)
pW = pW->PtrChc(Pt2dr(aP0Glob-aP0In),Pt2dr(aRatio,aRatio));
REAL SPds = 0;
REAL aSTot = 0;
REAL Dyn = 1.0;
if (aTShade != "u_int1")
Dyn = 100;
bool Done = false;
if ( (aModeOmbre=="CielVu")
|| ((aModeOmbre=="Mixte") && (aVPdsFiltre[0] > 0.0))
)
{
std::cout << "BEGIN CIEL" << endl;
Done = true;
for (int aK=0 ; aK< 2 ; aK++)
{
SPds = 0;
for (int i=0; i<aNbDir; i++)
{
REAL Teta = (2*PI*i) / aNbDir ;
Pt2dr U(cos(Teta),sin(Teta));
Pt2di aDir = Pt2di(U * (aNbDir * 4));
REAL Pds = (1-aPdsAnis) + aPdsAnis *ElSquare(1.0 - euclid(U,Pt2dr(0,1))/2);
if (aK==1)
Pds = (Pds*Dyn) / (2*aSTot);
Symb_FNum Gr = (1-cos(PI/2-atan(gray_level_shading(aMnt.in()))))
*255.0;
cout << "Dir " << i << " Sur " << aNbDir << " P= " << Pds << endl;
SPds += Pds;
if (aK==1)
{
ELISE_COPY
(
line_map_rect(aDir,Pt2di(0,0),aSzIn),
Min(255*Dyn,aShade.in()+Pds*Gr),
aShade.out()
// | (pW ? (pW->ogray()<<(aShade.in()/SPds)) : Output::onul())
| (pW ? (pW->ogray()<<(Gr)) : Output::onul())
);
}
}
aSTot = SPds;
}
double aMul = (aModeOmbre=="Mixte") ? aVPdsFiltre[0] : 1.0;
ELISE_COPY(aShade.all_pts(),aShade.in()*(aMul/SPds),aShade.out());
SPds = aMul;
std::cout << "BEGIN CIEL" << endl;
}
if (
(aModeOmbre=="Local")
|| ((aModeOmbre=="Mixte") && (aVPdsFiltre[1] > 0.0))
)
{
std::cout << "BEGIN LOCAL" << endl;
Done = true;
Fonc_Num aFonc = aMnt.in_proj();
Fonc_Num aMoy = aFonc;
for (int aK=0 ; aK<aNbIterF; aK++)
aMoy = canny_exp_filt(aMoy*aIMasq.in_proj(),aFactExp,aFactExp)
/ Max(0.1,canny_exp_filt(aIMasq.in_proj(),aFactExp,aFactExp));
double aMul = (aModeOmbre=="Mixte") ? aVPdsFiltre[1] : 1.0;
ELISE_COPY
(
rectangle(Pt2di(0,0),aSzIn),
Max(0,Min(255, aShade.in() +(128+(aFonc-aMoy)*aDyn)* aMul)),
aShade.out()
);
SPds += aMul;
std::cout << "END LOCAL" << endl;
}
if (
(aModeOmbre=="Med")
|| ((aModeOmbre=="Mixte") && (aVPdsFiltre[3] > 0.0))
)
{
std::cout << "BEGIN MED" << endl;
Done = true;
Fonc_Num aFonc = round_ni(aMnt.in_proj()*aDynMed);
int aVMax,aVMin;
ELISE_COPY
(
rectangle(Pt2di(-1,-1),aSzIn+Pt2di(1,1)),
aFonc,
VMin(aVMin)|VMax(aVMax)
);
Fonc_Num aMoy = aFonc-aVMin;
for (int aK=0 ; aK<aNbIterMed; aK++)
aMoy = rect_median(aMoy,aNbMed,aVMax-aVMin+1);
aMoy = aMoy + aVMin;
double aMul = (aModeOmbre=="Mixte") ? aVPdsFiltre[3] : 1.0;
ELISE_COPY
(
rectangle(Pt2di(0,0),aSzIn),
Max(0,Min(255, aShade.in() +(128+((aFonc-aMoy)*aDyn)/aDynMed)* aMul)),
aShade.out()
);
SPds += aMul;
std::cout << "END MED" << endl;
}
if (
(aModeOmbre=="IgnE")
|| ((aModeOmbre=="Mixte") && (aVPdsFiltre[2] > 0.0))
)
{
int aCpt=0; aCpt++;
std::cout << "IGN E " << aCpt << " " << aKDec << "\n";
Done = true;
if (aCpt>0)
{
Symb_FNum aGrad = deriche(aMnt.in_proj(),aDericheFact);
Symb_FNum aGx = (aGrad.v0());
Symb_FNum aGy = (aGrad.v1());
Symb_FNum aNG = sqrt(1+Square(aGx)+Square(aGy));
Symb_FNum aNx (aGx/aNG);
Symb_FNum aNy (aGy/aNG);
Symb_FNum aNz (1/aNG);
Pt2dr aDirS = Pt2dr::FromPolar(1.0,anAzimut) * Pt2dr(1,0);
double aSx = aDirS.x * sin(aTetaH);
double aSy = aDirS.y * sin(aTetaH);
double aSz = cos(aTetaH);
Symb_FNum aScal(aNx*aSx+aNy*aSy+aNz*aSz);
std::cout << "AAAAAAAaa" << endl;
double aMul = (aModeOmbre=="Mixte") ? aVPdsFiltre[2] : 1.0;
ELISE_COPY
(
rectangle(Pt2di(0,0),aSzIn),
Max(0,aShade.in() + 255*aScal * aMul),
aShade.out()
);
SPds += aMul;
std::cout << "BBBBbbb" << endl;
}
}
if (! Done)
{
ELISE_ASSERT(false,"Unknown ModeOmbre");
}
Fonc_Num aFoncRes = Max(0,Min(255,aShade.in()/SPds));
if (WithHypso)
{
Fonc_Num aFIntens = aFoncRes;
Fonc_Num aFTeinte = trans(aFIn,aP0In)*aHypsoDyn;
Fonc_Num aFSat = 255*aHypsoSat;
if (aNameCol!="")
{
Tiff_Im aFileCol = Tiff_Im::StdConvGen(aDir+aNameCol,-1,true,false);
Symb_FNum aFNC(trans(rgb_to_its(aFileCol.in()),aP0In));
if (aModeColor == "IntensShade")
{
aFIntens = aFoncRes;
aFTeinte = aFNC.v1();
aFSat = aFNC.v2();
}
else if (aModeColor == "BackRGB")
{
aFIntens = aIMasq.in()*aFoncRes + (1- aIMasq.in()) * aFNC.v0();
aFTeinte = aFNC.v1();
aFSat = aFNC.v2() * (1- aIMasq.in());
}
else if (aModeColor == "GrayBackRGB")
{
aFIntens = aIMasq.in()*aFoncRes + (1- aIMasq.in()) * aFNC.v0();
aFTeinte = aFNC.v1();
aFSat = aFNC.v2()*(1-aIMasq.in());
}
else
{
ELISE_ASSERT(false,"Unknown mode color");
}
}
aFoncRes = its_to_rgb(Virgule(aFIntens,aFTeinte,aFSat));
//aFoncRes = its_to_rgb(Virgule(aFoncRes,trans(aFIn,aP0In)*aHypsoDyn,255*aHypsoSat));
}
/*
if (WithCol)
{
Tiff_Im aFileCol(aNameCol.c_str());
Symb_FNum aFNC(trans(rgb_to_its(aFileCol.in()),aP0In));
aFoncRes = its_to_rgb(Virgule(aFoncRes,aFNC.v1(),aFNC.v2()*aHypsoSat));
// aFoncRes = aFileCol.in();
}
*/
// Tiff_Im::Create8BFromFonc(aNameOut,aShade.sz(),aShade.in()/SPds);
cout << "WithHypso " << WithHypso << " DIM " << aFoncRes.dimf_out() << endl;
Box2di aBoxOut = aDecoup.KthIntervOut(aKDec);
ELISE_COPY
(
rectangle(aBoxOut.P0()-aP0Glob,aBoxOut.P1()-aP0Glob),
trans(aFoncRes,aP0Glob-aP0In),
aTifOut.out()
);
}
return EXIT_SUCCESS;
}
else return EXIT_SUCCESS;
}
int ApplyParralaxCor_main(int argc, char ** argv)
{
//std::string aNameIm, aNameIm2, aNameParallax, aNameDEM;
std::string aNameIm, aNameParallax;
std::string aNameOut = "";
//Reading the arguments
ElInitArgMain
(
argc, argv,
LArgMain()
<< EAMC(aNameIm, "Image to be corrected", eSAM_IsPatFile)
//<< EAMC(aNameIm2, "Other image", eSAM_IsPatFile)
<< EAMC(aNameParallax, "Paralax correction file", eSAM_IsPatFile),
//<< EAMC(aNameDEM, "DEM file", eSAM_IsPatFile),
LArgMain()
<< EAM(aNameOut, "Out", true, "Name of output image (Def=ImName_corrected.tif")
);
std::string aDir, aPatIm;
SplitDirAndFile(aDir, aPatIm, aNameIm);
cout << "Correcting " << aNameIm << endl;
if (aNameOut == "")
aNameOut = aNameIm + "_corrected.tif";
//Reading the image and creating the objects to be manipulated
Tiff_Im aTF = Tiff_Im::StdConvGen(aDir + aNameIm, 1, false);
Pt2di aSz = aTF.sz(); cout << "size of image = " << aSz << endl;
Im2D_U_INT1 aIm(aSz.x, aSz.y);
ELISE_COPY
(
aTF.all_pts(),
aTF.in(),
aIm.out()//Virgule(aImR.out(),aImG.out(),aImB.out())
);
U_INT1 ** aData = aIm.data();
//Reading the parallax correction file
Tiff_Im aTFPar = Tiff_Im::StdConvGen(aDir + aNameParallax, 1, false);
Im2D_REAL8 aPar(aSz.x, aSz.y);
ELISE_COPY
(
aTFPar.all_pts(),
aTFPar.in(),
aPar.out()//Virgule(aImR.out(),aImG.out(),aImB.out())
);
REAL8 ** aDatPar = aPar.data();
//Output container
Im2D_U_INT1 aImOut(aSz.x, aSz.y);
U_INT1 ** aDataOut = aImOut.data();
/*Things needed for RPC angle computation, not main goal of this function
//Read RPCs
RPC aRPC;
string aNameRPC1 = "RPC_" + StdPrefix(aNameIm) + ".xml";
aRPC.ReadDimap(aNameRPC1);
cout << "Dimap File " << aNameRPC1 << " read" << endl;
RPC aRPC2;
string aNameRPC2 = "RPC_" + StdPrefix(aNameIm2) + ".xml";
aRPC2.ReadDimap(aNameRPC2);
cout << "Dimap File " << aNameRPC2 << " read" << endl;
//Reading the DEM file
Tiff_Im aTFDEM = Tiff_Im::StdConvGen(aDir + aNameDEM, 1, false);
Im2D_REAL8 aDEM(aSz.x, aSz.y);
ELISE_COPY
(
aTFDEM.all_pts(),
aTFDEM.in(),
aDEM.out()
);
REAL8 ** aDatDEM = aDEM.data();
//Output angle container 1
Im2D_REAL8 aAngleBOut(aSz.x, aSz.y);
REAL8 ** aDataAngleBOut = aAngleBOut.data();
string aNameAngleB = "AngleB.tif";
//Output angle container 2
Im2D_REAL8 aAngleNOut(aSz.x, aSz.y);
REAL8 ** aDataAngleNOut = aAngleNOut.data();
string aNameAngleN = "AngleN.tif";
*/
//Pt3dr PBTest(1500,3000, 0);
//Pt3dr PWTest = aRPC.DirectRPC(PBTest);
//Pt3dr PNTest = aRPC2.InverseRPC(PWTest);
//cout << "PB0 = " << PBTest << endl;
//cout << "PW0 = " << PWTest << endl;
//cout << "PN0 = " << PNTest << endl;
//cout << aRPC.height_scale << " " << aRPC.height_off << endl;
//PBTest.z=1000;
//PWTest = aRPC.DirectRPC(PBTest);
//PNTest = aRPC2.InverseRPC(PWTest);
//cout << "PB1 = " << PBTest << endl;
//cout << "PW1 = " << PWTest << endl;
//cout << "PN1 = " << PNTest << endl;
cout << "size of image = " << aSz << endl;
//Computing output data
for (int aX = 0; aX < aSz.x; aX++)
{
for (int aY = 0; aY < aSz.y; aY++)
{
/*
Pt3dr P0B(aX, aY, aDatDEM[aY][aX]);
Pt3dr PW0 = aRPC.DirectRPC(P0B);
Pt3dr PW1 = PW0, PW2 = PW0;
PW1.z = PW1.z - 1;
PW2.z = PW2.z + 1;
Pt3dr P1B = aRPC.InverseRPC(PW1);
Pt3dr P2B = aRPC.InverseRPC(PW2);
Pt3dr P1N = aRPC2.InverseRPC(PW1);
Pt3dr P2N = aRPC2.InverseRPC(PW2);
//Pt3dr P1B(aX, aY, 0);
//Pt3dr P2B(aX, aY, 10000);
//Pt3dr P1N = aRPC2.InverseRPC(aRPC.DirectRPC(P1B));
//Pt3dr P2N = aRPC2.InverseRPC(aRPC.DirectRPC(P2B));
double aAngleB = atan((P2B.x - P1B.x) / (P2B.y - P1B.y));
aDataAngleBOut[aY][aX] = aAngleB;
double aAngleN = atan((P2N.x - P1N.x) / (P2N.y - P1N.y));
aDataAngleNOut[aY][aX] = aAngleN;
//cout << aX << " " << aY << " " << aAngle << endl;
//cout << P1N << " " << P2N << " " << aAngle << endl;
*/
//THE THINGS COMPUTED ABOVE WILL BE USED IN A FURTHER UPDATE
Pt2dr ptOut;
ptOut.x = aX - aDatPar[aY][aX];// * cos(aAngleB);
ptOut.y = aY - aDatPar[aY][aX];// * sin(aAngleB);
aDataOut[aY][aX] = Reechantillonnage::biline(aData, aSz.x, aSz.y, ptOut);
}
}
cout << "size of image = " << aSz << endl;
Tiff_Im aTOut
(
aNameOut.c_str(),
aSz,
GenIm::u_int1,
Tiff_Im::No_Compr,
Tiff_Im::BlackIsZero
);
ELISE_COPY
(
aTOut.all_pts(),
aImOut.in(),
aTOut.out()
);
/*
Tiff_Im aTAngleBOut
(
aNameAngleB.c_str(),
aSz,
GenIm::real8,
Tiff_Im::No_Compr,
Tiff_Im::BlackIsZero
);
ELISE_COPY
(
aTAngleBOut.all_pts(),
aAngleBOut.in(),
aTAngleBOut.out()
);
Tiff_Im aTAngleNOut
(
aNameAngleN.c_str(),
aSz,
GenIm::real8,
Tiff_Im::No_Compr,
Tiff_Im::BlackIsZero
);
ELISE_COPY
(
aTAngleNOut.all_pts(),
aAngleNOut.in(),
aTAngleNOut.out()
);
*/
return 0;
}
int HomFilterMasq_main(int argc,char ** argv)
{
// MemoArg(argc,argv);
MMD_InitArgcArgv(argc,argv);
std::string aDir,aPat,aFullDir;
bool ExpTxt=false;
std::string PostPlan="_Masq";
std::string KeyCalcMasq;
std::string KeyEquivNoMasq;
std::string MasqGlob;
double aResol=10;
bool AcceptNoMask;
std::string aPostIn= "";
std::string aPostOut= "MasqFiltered";
ElInitArgMain
(
argc,argv,
LArgMain() << EAMC(aFullDir,"Full name (Dir+Pat)", eSAM_IsPatFile),
LArgMain()
<< EAM(PostPlan,"PostPlan",true,"Post to plan, Def : toto ->toto_Masq.tif like with SaisieMasq")
<< EAM(MasqGlob,"GlobalMasq",true,"Global Masq to add to all image")
<< EAM(KeyCalcMasq,"KeyCalculMasq",true,"For tuning masq per image")
<< EAM(KeyEquivNoMasq,"KeyEquivNoMasq",true,"When given if KENM(i1)==KENM(i2), don't masq")
<< EAM(aResol,"Resol",true,"Sub Resolution for masq storing, Def=10")
<< EAM(AcceptNoMask,"ANM",true,"Accept no mask, def = true if MasqGlob and false else")
<< EAM(ExpTxt,"ExpTxt",true,"Ascii format for in and out, def=false")
<< EAM(aPostIn,"PostIn",true,"Post for Input dir Hom, Def=")
<< EAM(aPostOut,"PostOut",true,"Post for Output dir Hom, Def=MasqFiltered")
);
#if (ELISE_windows)
replace( aFullDir.begin(), aFullDir.end(), '\\', '/' );
#endif
SplitDirAndFile(aDir,aPat,aFullDir);
if (EAMIsInit(&PostPlan))
{
CorrecNameMasq(aDir,aPat,PostPlan);
}
if (!EAMIsInit(&AcceptNoMask))
AcceptNoMask = EAMIsInit(&MasqGlob);
cInterfChantierNameManipulateur * anICNM = cInterfChantierNameManipulateur::BasicAlloc(aDir);
Im2D_Bits<1> aImMasqGlob(1,1);
if (EAMIsInit(&MasqGlob))
aImMasqGlob = GetMasqSubResol(aDir+MasqGlob,aResol);
const std::vector<std::string> * aVN = anICNM->Get(aPat);
std::vector<Im2D_Bits<1> > aVMasq;
for (int aKN = 0 ; aKN<int(aVN->size()) ; aKN++)
{
std::string aNameIm = (*aVN)[aKN];
Tiff_Im aTF = Tiff_Im::StdConvGen(aNameIm,1,false);
Pt2di aSzG = aTF.sz();
Pt2di aSzR (round_ni(Pt2dr(aSzG)/aResol));
Im2D_Bits<1> aImMasq(aSzR.x,aSzR.y,1);
std::string aNameMasq = StdPrefix(aNameIm)+PostPlan + ".tif";
if (EAMIsInit(&KeyCalcMasq))
{
aNameMasq = anICNM->Assoc1To1(KeyCalcMasq,aNameIm,true);
}
if (ELISE_fp::exist_file(aNameMasq))
{
Im2D_Bits<1> aImMasqLoc = GetMasqSubResol(aDir+aNameMasq,aResol);
ELISE_COPY(aImMasq.all_pts(),aImMasq.in() && aImMasqLoc.in(0),aImMasq.out());
}
else
{
if (!AcceptNoMask)
{
std::cout << "For Im " << aNameIm << " file " << aNameMasq << " does not exist\n";
ELISE_ASSERT(false,"Masq not found");
}
}
if (EAMIsInit(&MasqGlob))
{
ELISE_COPY(aImMasq.all_pts(),aImMasq.in() && aImMasqGlob.in(0),aImMasq.out());
}
aVMasq.push_back(aImMasq);
// Tiff_Im::CreateFromIm(aImMasq,"SousRes"+aNameMasq);
}
std::string anExt = ExpTxt ? "txt" : "dat";
std::string aKHIn = std::string("NKS-Assoc-CplIm2Hom@")
+ std::string(aPostIn)
+ std::string("@")
+ std::string(anExt);
std::string aKHOut = std::string("NKS-Assoc-CplIm2Hom@")
+ std::string(aPostOut)
+ std::string("@")
+ std::string(anExt);
for (int aKN1 = 0 ; aKN1<int(aVN->size()) ; aKN1++)
{
for (int aKN2 = 0 ; aKN2<int(aVN->size()) ; aKN2++)
{
std::string aNameIm1 = (*aVN)[aKN1];
std::string aNameIm2 = (*aVN)[aKN2];
std::string aNameIn = aDir + anICNM->Assoc1To2(aKHIn,aNameIm1,aNameIm2,true);
if (ELISE_fp::exist_file(aNameIn))
{
bool UseMasq = true;
if (EAMIsInit(&KeyEquivNoMasq))
{
UseMasq = (anICNM->Assoc1To1(KeyEquivNoMasq,aNameIm1,true) != anICNM->Assoc1To1(KeyEquivNoMasq,aNameIm2,true) );
}
TIm2DBits<1> aMasq1 ( aVMasq[aKN1]);
TIm2DBits<1> aMasq2 ( aVMasq[aKN2]);
ElPackHomologue aPackIn = ElPackHomologue::FromFile(aNameIn);
ElPackHomologue aPackOut;
for (ElPackHomologue::const_iterator itP=aPackIn.begin(); itP!=aPackIn.end() ; itP++)
{
Pt2dr aP1 = itP->P1();
Pt2dr aP2 = itP->P2();
Pt2di aQ1 = round_ni(aP1/aResol);
Pt2di aQ2 = round_ni(aP2/aResol);
if ((aMasq1.get(aQ1,0) && aMasq2.get(aQ2,0)) || (! UseMasq))
{
ElCplePtsHomologues aCple(aP1,aP2);
aPackOut.Cple_Add(aCple);
}
}
std::string aNameOut = aDir + anICNM->Assoc1To2(aKHOut,aNameIm1,aNameIm2,true);
aPackOut.StdPutInFile(aNameOut);
std::cout << "IN " << aNameIn << " " << aNameOut << " UseM " << UseMasq << "\n";
}
}
}
// std::vector<cImFMasq *> mVIm;
return 0;
}
void SaisieAppuisPredic(int argc, char ** argv,
Pt2di &aSzW,
Pt2di &aNbFen,
std::string &aFullName,
std::string &aDir,
std::string &aName,
std::string &aNamePt,
std::string &anOri,
std::string &aModeOri,
std::string &aNameMesure,
std::string &aTypePts,
std::string &aMasq3D,
std::string &PIMsFilter,
double &aFlou,
bool &aForceGray,
double &aZMoy,
double &aZInc,
std::string & aInputSec)
{
MMD_InitArgcArgv(argc,argv);
ElInitArgMain
(
argc,argv,
LArgMain() << EAMC(aFullName,"Full Name (Dir+Pattern)", eSAM_IsPatFile)
<< EAMC(anOri,"Orientation", eSAM_IsExistDirOri)
<< EAMC(aNamePt,"File for Ground Control Points", eSAM_IsExistFile)
<< EAMC(aNameMesure,"File for Image Measurements", eSAM_IsExistFile),
LArgMain() << EAM(aSzW,"SzW",true,"Size of global window (Def 800 800)")
<< EAM(aNbFen,"NbF",true,"Number of Sub Window (Def 2 2)")
<< EAM(aFlou,"WBlur",true,"Size IN GROUND GEOMETRY of bluring for target")
<< EAM(aTypePts,"Type",true,"in [MaxLoc,MinLoc,GeoCube]")
<< EAM(aForceGray,"ForceGray",true,"Force gray image, def=true")
<< EAM(aModeOri,"OriMode", true, "Orientation type (GRID) (Def=Std)")
<< EAM(aZMoy,"ZMoy",true,"Average Z, Mandatory in PB", eSAM_NoInit)
<< EAM(aZInc,"ZInc",true,"Incertitude on Z, Mandatory in PB", eSAM_NoInit)
<< EAM(aMasq3D,"Masq3D",true,"3D Masq used for visibility", eSAM_NoInit)
<< EAM(PIMsFilter,"PIMsF",true,"PIMs filter used for visibility", eSAM_NoInit)
<< EAM(aInputSec,"InputSec",true,"PIMs filter used for visibility", eSAM_NoInit)
);
if (!MMVisualMode)
{
aTypePts = "eNSM_" + aTypePts;
SplitDirAndFile(aDir,aName,aFullName);
cInterfChantierNameManipulateur * aCINM = cInterfChantierNameManipulateur::BasicAlloc(aDir);
aCINM->CorrecNameOrient(anOri);
const cInterfChantierNameManipulateur::tSet * aSet = aCINM->Get(aName);
//std::cout << "Nb Image =" << aSet->size() << "\n";
ELISE_ASSERT(aSet->size()!=0,"No image found");
if (aNbFen.x<0)
{
if (aSet->size() == 1)
{
aNbFen = Pt2di(1,2);
}
else if (aSet->size() == 2)
{
Tiff_Im aTF = Tiff_Im::StdConvGen(aDir+(*aSet)[0],1,false,true);
Pt2di aSzIm = aTF.sz();
aNbFen = (aSzIm.x>aSzIm.y) ? Pt2di(1,2) : Pt2di(2,1);
}
else
{
aNbFen = Pt2di(2,2);
}
}
aCINM->MakeStdOrient(anOri,false);
}
}
int EstimFlatField_main(int argc,char ** argv)
{
std::string aFullDir,aDir,aPat;
std::string aNameOut;
double aResol=1.0;
double aDilate=1.0;
int aNbMed = 1;
int aNbMedSsRes = 3;
bool ByMoy = false;
double TolMed = 0.25;
ElInitArgMain
(
argc,argv,
LArgMain() << EAMC(aFullDir,"Images = Dir + Pat", eSAM_IsPatFile)
<< EAMC(aResol,"Resolution "),
LArgMain() << EAM(aNbMed,"NbMed",true)
<< EAM(aNameOut,"Out",true,"Name of result")
<< EAM(aDilate,"SousResAdd",true)
<< EAM(aNbMedSsRes,"NbMedSsRes",true)
<< EAM(TolMed,"TolMed",true)
<< EAM(ByMoy,"ByMoy",true,"Average or median (def=false")
);
if (!MMVisualMode)
{
SplitDirAndFile(aDir,aPat,aFullDir);
if (aNameOut=="")
aNameOut = "FlatField.tif";
aNameOut = aDir + aNameOut;
cTplValGesInit<std::string> aTplN;
cInterfChantierNameManipulateur * aICNM = cInterfChantierNameManipulateur::StdAlloc(0,0,aDir,aTplN);
MakeXmlXifInfo(aFullDir,aICNM);
std::list<std::string> aLName = aICNM->StdGetListOfFile(aPat);
Paral_Tiff_Dev(aDir,std::vector<std::string> (aLName.begin(),aLName.end()),1,false);
Pt2di aSzIm(-1,-1);
double aNbPix=-1;
Im2D_REAL4 aImIn(1,1);
Im2D_REAL8 aFFRes1(1,1);
Pt2di aSzF(-1,-1);
int aNbIm = (int)aLName.size();
int aCpt = aNbIm;
std::vector<Im2D_REAL4> aVImRed;
// for (std::list<std::string>::const_iterator itN=aLName.begin(); itN!=aLName.end() ; itN++)
// for (std::list<std::string>::reverse_iterator itN=aLName.rbegin(); itN!=aLName.rend() ; itN++)
for (std::list<std::string>::const_iterator itN=aLName.begin(); itN!=aLName.end() ; itN++)
{
std::cout << "To Do " << aCpt << *itN << "\n";
Tiff_Im aTIn = Tiff_Im::StdConvGen(aDir+*itN,1,true);
std::string aImRefSz;
if (aSzIm.x<0)
{
aImRefSz = *itN;
aSzIm = aTIn.sz();
aImIn = Im2D_REAL4(aSzIm.x,aSzIm.y,0.0);
if (ByMoy)
aFFRes1 = Im2D_REAL8(aSzIm.x,aSzIm.y,0.0);
aNbPix = aSzIm.x*aSzIm.y;
aSzF = round_up(Pt2dr(aSzIm)/aResol);
}
else
{
if (aSzIm!=aTIn.sz())
{
std::cout << "For Image " << *itN << " sz=" << aTIn.sz() << " Ref=" << aImRefSz << " Sz=" << aSzIm << "\n";
ELISE_ASSERT(false,"Different size");
}
}
double aSom = 0;
// ELISE_COPY(aImIn.all_pts(),aTIn.in(),aImIn.out()|sigma(aSom));
Fonc_Num aFIN = aTIn.in();
ELISE_COPY(aImIn.all_pts(),Rconv(aFIN),aImIn.out()|sigma(aSom));
double aMoy = aSom/aNbPix;
if (ByMoy)
{
ELISE_COPY
(
aImIn.all_pts(),
aFFRes1.in()+(aImIn.in()/aMoy),
aFFRes1.out()
);
}
else
{
Im2D_REAL4 aIRed(aSzF.x,aSzF.y);
ELISE_COPY
(
aIRed.all_pts(),
StdFoncChScale
(
aImIn.in_proj() / aMoy,
Pt2dr(0.0,0.0),
Pt2dr(aResol,aResol),
Pt2dr(aDilate,aDilate)
),
aIRed.out()
);
aVImRed.push_back(aIRed);
}
aCpt--;
}
Fonc_Num aF;
if (ByMoy)
{
std::cout << "Filtrage Median "<< aNbMed << "\n";
ELISE_COPY
(
aFFRes1.all_pts(),
MedianBySort(aFFRes1.in_proj()/aNbIm,aNbMed),
aFFRes1.out()
);
aF = StdFoncChScale
(
aFFRes1.in_proj() / aNbIm,
Pt2dr(0.0,0.0),
Pt2dr(aResol,aResol),
Pt2dr(aDilate,aDilate)
);
if (aNbMedSsRes)
aF = MedianBySort(aF,aNbMedSsRes);
}
else
{
int aMoyMed = 2;
Im2D_REAL4 aRes = ImMediane<float,double>(aVImRed,-1e30,0.0,TolMed);
aF = aRes.in_proj();
for (int aK=0 ; aK<3 ; aK++)
aF = MedianBySort(aF,4);
for (int aK=0 ; aK<3 ; aK++)
aF = rect_som(aF,aMoyMed)/ElSquare(1+2*aMoyMed);
}
Tiff_Im aTOut
(
aNameOut.c_str(),
aSzF ,
GenIm::real8,
Tiff_Im::No_Compr,
Tiff_Im::BlackIsZero
);
ELISE_COPY
(
aTOut.all_pts(),
aF,
aTOut.out()
);
}
return EXIT_SUCCESS;
}
void SaisieAppuisInit(int argc, char ** argv,
Pt2di &aSzW,
Pt2di &aNbFen,
std::string &aFullName,
std::string &aDir,
std::string &aName,
std::string &aNamePt,
std::string &anOri,
std::string &aModeOri,
std::string &anOut,
std::string &aNameAuto,
std::string &aPrefix2Add,
bool &aForceGray,
double &aZMoy,
double &aZInc)
{
MMD_InitArgcArgv(argc,argv);
ElInitArgMain
(
argc,argv,
LArgMain() << EAMC(aFullName,"Full name (Dir+Pattern)", eSAM_IsPatFile)
<< EAMC(anOri,"Orientation ; NONE if not used",eSAM_IsExistDirOri)
<< EAMC(aNamePt,"Point name, or point file name", eSAM_None)
<< EAMC(anOut,"Output",eSAM_IsOutputFile),
LArgMain() << EAM(aSzW,"SzW",true,"Sz of window")
<< EAM(aNbFen,"NbF",true,"Nb of sub window (Def depends of number of images with max of 2x2)")
<< EAM(aNameAuto,"NameAuto",true," Prefix for automatic point creation")
<< EAM(aPrefix2Add,"Pref2Add",true," Prefix to add during import (for bug correction ?)")
<< EAM(aForceGray,"ForceGray",true," Force gray image, def =true")
<< EAM(aModeOri,"OriMode", true, "Orientation type (GRID) (Def=Std)")
<< EAM(aZMoy,"ZMoy",true,"Average Z, Mandatory in PB", eSAM_NoInit)
<< EAM(aZInc,"ZInc",true,"Incertitude on Z, Mandatory in PB", eSAM_NoInit)
);
if (!MMVisualMode)
{
SplitDirAndFile(aDir,aName,aFullName);
cInterfChantierNameManipulateur * aICNM = cInterfChantierNameManipulateur::BasicAlloc(aDir);
if ((anOri!="NONE") && (aModeOri != "GRID"))
aICNM->CorrecNameOrient(anOri);
const cInterfChantierNameManipulateur::tSet * aSet = aICNM->Get(aName);
//std::cout << "Nb Image =" << aSet->size() << "\n";
ELISE_ASSERT(aSet->size()!=0,"No image found");
if (aNbFen.x<0)
{
if (aSet->size() == 1)
{
aNbFen = Pt2di(1,2);
}
else if (aSet->size() == 2)
{
Tiff_Im aTF = Tiff_Im::StdConvGen(aDir+(*aSet)[0],1,false,true);
Pt2di aSzIm = aTF.sz();
aNbFen = (aSzIm.x>aSzIm.y) ? Pt2di(1,2) : Pt2di(2,1);
}
else
{
aNbFen = Pt2di(2,2);
}
}
cResulMSO aRMSO = aICNM->MakeStdOrient(anOri,true);
if (0)
{
std::cout << "RMSO; Cam " << aRMSO.Cam()
<< " Nuage " << aRMSO.Nuage()
<< " Ori " << aRMSO.IsKeyOri()
<< "\n";
getchar();
}
}
}
