int TestMTD_main(int argc,char ** argv)
{
MMD_InitArgcArgv(argc,argv,1);
std::string aNameIm;
ElInitArgMain
(
argc,argv,
LArgMain() << EAMC(aNameIm,"Image name", eSAM_IsPatFile),
LArgMain()
);
if (MMVisualMode) return EXIT_SUCCESS;
std::string aDir,aPat;
SplitDirAndFile(aDir,aPat,aNameIm);
cInterfChantierNameManipulateur::BasicAlloc(aDir);
cMetaDataPhoto aMTD = cMetaDataPhoto::CreateExiv2(aNameIm);
std::cout << "FocMm " << aMTD.FocMm(true) << "\n";
std::cout << "Foc35 " << aMTD.Foc35(true) << "\n";
std::cout << "Cam [" << aMTD.Cam(true) << "]\n";
return 1;
}
cDbleGrid * cDbleGrid::StdGridPhotogram(const std::string & aNameFile,int aSzDisc)
{
cElXMLTree aTree(aNameFile);
if (aTree.Get("doublegrid"))
{
std::string aDir,aFile;
SplitDirAndFile(aDir,aFile,aNameFile);
cDbleGrid::cXMLMode aXmlMode;
return new cDbleGrid(aXmlMode,aDir,aFile);
}
if (aTree.Get("CalibrationInternConique"))
{
ElCamera * aCam = Cam_Gen_From_File(aNameFile,"CalibrationInternConique",(cInterfChantierNameManipulateur*)0);
cDistStdFromCam aD(*aCam);
cDbleGrid * aRes = new cDbleGrid
(
true,
Pt2dr(0,0),Pt2dr(aCam->Sz()),
Pt2dr(aSzDisc,aSzDisc),
aD
);
delete aCam;
return aRes;
}
ELISE_ASSERT(false,"cDbleGrid::StdGridPhotogram");
return 0;
}
int AperoProg_main(int argc,char ** argv)
{
MMD_InitArgcArgv(argc,argv);
std::string aFullDir= "";
std::string AeroIn= "";
std::string AeroOut="";
/*double aSigmaTieP = 1;
double aFactResElimTieP = 5;
double Viscos = 1.0;
bool ExpTxt = false;*/
ElInitArgMain
(
argc,argv,
LArgMain() << EAMC(aFullDir,"Full Directory (Dir+Pattern)", eSAM_IsPatFile)
<< EAMC(AeroIn,"Input Orientation", eSAM_IsExistDirOri)
<< EAMC(AeroOut,"Output Orientation", eSAM_IsOutputDirOri),
LArgMain()
);
if (!MMVisualMode)
{
std::string aDir,aPat;
#if (ELISE_windows)
replace( aFullDir.begin(), aFullDir.end(), '\\', '/' );
#endif
SplitDirAndFile(aDir,aPat,aFullDir);
StdCorrecNameOrient(AeroIn,aDir);
}
return EXIT_SUCCESS;
}
string FindMaltEtape(int ResolModel, std::string aNameIm, std::string aPatModel)
{
//Getting full image size
Tiff_Im aTFforSize= Tiff_Im::StdConvGen(aNameIm,1,false);
int aSzX = aTFforSize.sz().x;
std::string aDir,aPat;
SplitDirAndFile(aDir,aPat,aPatModel);
cInterfChantierNameManipulateur * aICNM = cInterfChantierNameManipulateur::BasicAlloc(aDir);
const std::vector<std::string> * aSetModel = aICNM->Get(aPat);
std::vector<std::string> aVectModel=*aSetModel;
int nbModel=aVectModel.size();
int aEtape = 0;
for (int i=0 ; i<nbModel ; i++)
{
cElNuage3DMaille * info3D = cElNuage3DMaille::FromFileIm(aDir+aVectModel[i]);
//cout<<info3D->SzGeom()<<endl;
int ResolThisFile=float(aSzX)/float(info3D->SzGeom().x)+0.5;
//cout<<"ResolThisFile : "<<ResolThisFile<<endl;
if(ResolModel==ResolThisFile){aEtape=i+1;}
}
cout<<"MicMac step to be used = num"<<aEtape<<endl;
// Modif GM: compilation c++11
ostringstream oss;
oss << aEtape;
return oss.str();
//string aEtapeStr = static_cast<ostringstream*>( &(ostringstream() << aEtape) )->str();
//return aEtapeStr;
}
void UseRequirement(const std::string & aDir,const cTplValGesInit<cBatchRequirement> & aTplB)
{
if (! aTplB.IsInit())
return;
const cBatchRequirement & aBR = aTplB.Val();
for
(
std::list<cExeRequired>::const_iterator itE=aBR.ExeRequired().begin();
itE!=aBR.ExeRequired().end();
itE++
)
{
//std::string aCom = string("\"")+(g_externalToolHandler.get( "make" ).callName())+"\" " + itE->Exe() + " -f \"" + itE->Make() + "\"";
//System(aCom);
launchMake( itE->Make(), itE->Exe() );
}
for
(
std::list<cFileRequired>::const_iterator itF=aBR.FileRequired().begin();
itF!=aBR.FileRequired().end();
itF++
)
{
int aNbMin = itF->NbMin().Val();
int aNbMax = itF->NbMax().ValWithDef(aNbMin);
for
(
std::list<std::string>::const_iterator itP=itF->Pattern().begin();
itP!=itF->Pattern().end();
itP++
)
{
std::string aDir2,aPat2;
SplitDirAndFile(aDir2,aPat2,*itP);
aDir2 = aDir + aDir2;
std::list<std::string> aL=RegexListFileMatch(aDir2,aPat2,1,false);
int aNb = aL.size();
if ((aNb<aNbMin) || (aNb>aNbMax))
{
std::cout << "For Pattern {" << aPat2 << "} Number "
<< aNb << " Intervalle " << aNbMin << " / " << aNbMax << "\n";
ELISE_ASSERT(false,"File number required");
}
}
}
}
int GCPCtrl_main(int argc,char ** argv)
{
// MemoArg(argc,argv);
MMD_InitArgcArgv(argc,argv);
std::string aDir,aPat,aFullDir;
std::string AeroIn;
std::string DicoPts;
std::string MesureIm;
bool CPI = false;
bool ShowUnused = true;
ElInitArgMain
(
argc,argv,
LArgMain() << EAMC(aFullDir,"Full name (Dir+Pat)", eSAM_IsPatFile)
<< EAMC(AeroIn,"Orientation in", eSAM_IsExistDirOri)
<< EAMC(DicoPts,"Ground Control Points File", eSAM_IsExistFile)
<< EAMC(MesureIm,"Image Measurements File", eSAM_IsExistFile),
LArgMain()
<< EAM(CPI,"CPI",true,"when Calib Per Image has to be used", eSAM_IsBool)
<< EAM(ShowUnused,"ShowU",true,"Show unused point (def=true)", eSAM_IsBool)
);
if (!MMVisualMode)
{
#if (ELISE_windows)
replace( aFullDir.begin(), aFullDir.end(), '\\', '/' );
#endif
SplitDirAndFile(aDir,aPat,aFullDir);
StdCorrecNameOrient(AeroIn,aDir);
std::string aCom = MM3dBinFile_quotes( "Apero" )
+ ToStrBlkCorr( MMDir()+"include/XML_MicMac/Apero-GCP-Control.xml" )+" "
+ std::string(" DirectoryChantier=") +aDir + std::string(" ")
+ std::string(" +PatternAllIm=") + QUOTE(aPat) + std::string(" ")
+ std::string(" +AeroIn=") + AeroIn
+ std::string(" +DicoApp=") + DicoPts
+ std::string(" +SaisieIm=") + MesureIm
;
if (EAMIsInit(&ShowUnused)) aCom = aCom + " +ShowUnused=" + ToString(ShowUnused);
if (CPI) aCom += " +CPI=true ";
std::cout << "Com = " << aCom << "\n";
int aRes = System(aCom.c_str(),false,true,true);
return aRes;
}
else return EXIT_SUCCESS;
}
int SplitMPO_main(int argc,char ** argv)
{
std::string aFullName;
std::string aPostR = "_R";
std::string aPostL = "_L";
bool DoTifGray = false;
ElInitArgMain
(
argc,argv,
LArgMain() << EAMC(aFullName,"Full name (Dir+Pat)", eSAM_IsPatFile) ,
LArgMain() << EAM(aPostR,"Right",true,"Right extension, def=_R")
<< EAM(aPostL,"Left",true,"Left extension, def=_L")
<< EAM(DoTifGray,"TG",true,"Tiff gray, def=false")
);
std::string aDir,aPat;
SplitDirAndFile(aDir,aPat,aFullName);
cInterfChantierNameManipulateur * aICNM = cInterfChantierNameManipulateur::BasicAlloc(aDir);
const std::vector<std::string> * aSetIm = aICNM->Get(aPat);
for (int aKIm=0 ; aKIm<int(aSetIm->size()) ; aKIm++)
{
std::string aNameIn = (*aSetIm)[aKIm];
for (int aK=0 ; aK<2 ; aK++)
{
std::string aPref = StdPrefix(aNameIn);
std::string aPost = StdPostfix(aNameIn);
std::string aNameOut = aPref+((aK==0)? aPostL : aPostR) + ".jpg";
std::string aCom = "exiftool ";
if (aK==0)
aCom = aCom + "-trailer:all= " + aNameIn + " -o " + aNameOut;
else
aCom = aCom+ aNameIn + " -mpimage2 -b> " + aNameOut;
std::cout << aCom << "\n";
VoidSystem(aCom.c_str());
if (DoTifGray)
{
aCom = "convert "
+ aNameOut
+ " -compress None -depth 8 -colorspace Gray "
+ StdPrefix(aNameOut) + "_Gray.tif";
std::cout << aCom << "\n";
VoidSystem(aCom.c_str());
}
}
}
return 1;
}
cAppliListIm::cAppliListIm(const std::string & aFullName) :
mFullName (aFullName)
{
#if (ELISE_windows)
replace( mFullName.begin(), mFullName.end(), '\\', '/' );
#endif
SplitDirAndFile(mDir,mPat,mFullName);
mICNM = cInterfChantierNameManipulateur::BasicAlloc(mDir);
mSetIm = mICNM->Get(mPat);
}
int MakeGrid_main(int argc,char ** argv)
{
MMD_InitArgcArgv(argc,argv);
NoInit = "XXXXXXXXXX";
MemoArg(argc,argv);
std::string aDir,aPat,aFullDir;
std::string AeroIn;
std::string AeroOut;
//std::vector<std::string> ImPl;
ElInitArgMain
(
argc,argv,
LArgMain() << EAMC(aFullDir, "Full Directory (Dir+Pattern)", eSAM_IsPatFile)
<< EAMC(AeroIn, "Input Orientation", eSAM_IsExistDirOri),
LArgMain()
<< EAM(AeroOut,"Out",true)
);
if (!MMVisualMode)
{
if (AeroOut=="")
AeroOut = "Grid-"+AeroIn;
#if (ELISE_windows)
replace( aFullDir.begin(), aFullDir.end(), '\\', '/' );
#endif
SplitDirAndFile(aDir,aPat,aFullDir);
#if (ELISE_windows)
std::string aCom = MMDir() + std::string("bin\\Apero ")
#else
std::string aCom = MMDir() + std::string("bin/Apero ")
#endif
+ MMDir() + std::string("include/XML_MicMac/AperoGrid.xml ")
+ std::string(" DirectoryChantier=") +aDir + std::string(" ")
+ std::string(" +PatternAllIm=") + QUOTE(aPat) + std::string(" ")
+ std::string(" +AeroOut=-") + AeroOut
+ std::string(" +AeroIn=-") + AeroIn
;
std::cout << "Com = " << aCom << "\n";
int aRes = system_call(aCom.c_str());
return aRes;
}
else
return EXIT_SUCCESS;
}
void XML_StdStringify (const std::string &aNameInput)
{
std::string aDir,aPref;
SplitDirAndFile(aDir,aPref,aNameInput);
aPref = StdPrefix(aPref);
Stringify
(
aNameInput,
std::string("CodeGenere")+ELISE_CAR_DIR+"File2String"+ELISE_CAR_DIR+"Str_"+aPref+std::string(".cpp"),
"theNameVar_"+aPref
);
}
int ChgSysCo_main(int argc,char ** argv)
{
MMD_InitArgcArgv(argc,argv);
std::string aFullDir= "";
std::string AeroIn= "";
std::string aStrChSys="";
std::string AeroOut="";
bool ForceRot = false;
ElInitArgMain
(
argc,argv,
LArgMain() << EAMC(aFullDir,"Full Directory (Dir+Pattern)", eSAM_IsPatFile)
<< EAMC(AeroIn,"Input Orientation", eSAM_IsExistDirOri)
<< EAMC(aStrChSys,"Change coordinate file", eSAM_IsExistFile)
<< EAMC(AeroOut,"Output Orientation", eSAM_IsOutputDirOri),
LArgMain() << EAM(ForceRot,"FR",true,"Force orientation matrix to be pure rotation (Def = true)", eSAM_IsBool)
);
if (!MMVisualMode)
{
std::string aDir,aPat;
#if (ELISE_windows)
replace( aFullDir.begin(), aFullDir.end(), '\\', '/' );
#endif
SplitDirAndFile(aDir,aPat,aFullDir);
StdCorrecNameOrient(AeroIn,aDir);
std::cout << "DPPPP= " << aDir << " " << aPat << "\n";
std::string aCom = MM3dBinFile( "Apero" )
+ XML_MM_File("Apero-ChCo.xml")
+ std::string(" DirectoryChantier=") + aDir + " "
+ std::string(" +SetIm=") + aPat + " "
+ std::string(" +AeroIn=-") + AeroIn + " "
+ std::string(" +AeroOut=-") + AeroOut + " "
+ std::string(" +ChC=") + aStrChSys + " "
+ std::string(" +ChCFR=") + ToString(ForceRot)
;
std::cout << "COM = " << aCom << "\n";
int aRes = system_call(aCom.c_str());
return aRes;
}
else return EXIT_SUCCESS;
}
int MMAllAuto_main(int argc,char ** argv)
{
MMD_InitArgcArgv(argc,argv);
std::string aDir,aPat,aFullDir;
std::string AeroIn;
int aZoomF = 2;
ElInitArgMain
(
argc,argv,
LArgMain() << EAMC(aFullDir,"Dir + Pattern", eSAM_IsPatFile)
<< EAMC(AeroIn,"Orientation", eSAM_IsExistDirOri),
LArgMain()
<< EAM(aZoomF,"ZoomF",true,"Zoom Final, def=2",eSAM_IsPowerOf2)
);
#if (ELISE_windows)
replace( aFullDir.begin(), aFullDir.end(), '\\', '/' );
#endif
SplitDirAndFile(aDir,aPat,aFullDir);
StdCorrecNameOrient(AeroIn,aDir);
cInterfChantierNameManipulateur * aICNM = cInterfChantierNameManipulateur::BasicAlloc(aDir);
// Genere les pyramides pour que le paral ne s'ecrase pas les 1 les autres
const cInterfChantierNameManipulateur::tSet * aSetIm = aICNM->Get(aPat);
for (int aKIm=0 ; aKIm<int(aSetIm->size()) ; aKIm++)
{
std::string aCom = MM3dBinFile("MICMAC")
+ XML_MM_File("MM-AllAuto.xml")
+ std::string(" WorkDir=") +aDir + std::string(" ")
+ std::string(" +Im1=") + QUOTE((*aSetIm)[aKIm]) + std::string(" ")
+ std::string(" +Ori=-") + AeroIn
+ std::string(" +ZoomF=") + ToString(aZoomF)
;
system_call(aCom.c_str());
}
// int aRes = system_call(aCom.c_str());
return 0;
}
int Arsenic_main(int argc,char ** argv)
{
std::string aFullPattern,aDirOut="Egal/",InVig="";
//bool InTxt=false;
int ResolModel=16;
double TPA=16,aThresh=1.4;
int nbIte=5;
//Reading the arguments
ElInitArgMain
(
argc,argv,
LArgMain() << EAMC(aFullPattern,"Images Pattern", eSAM_IsPatFile),
LArgMain() << EAM(aDirOut,"Out",true,"Output folder (end with /) and/or prefix (end with another char)")
<< EAM(InVig,"InVig",true,"Input vignette folder (for example : Vignette/ )", eSAM_IsDir)
<< EAM(ResolModel,"ResolModel",true,"Resol of input model (Def=16)")
<< EAM(TPA,"TPA",true,"Tie Point Accuracy (Higher is better, lower gives more points Def=16)")
<< EAM(nbIte,"NbIte",true,"Number of iteration of the process (default=5)")
<< EAM(aThresh,"ThreshDisp",true,"Disparity threshold between the tie points (Def=1.4 for 40%)")
);
if (!MMVisualMode)
{
std::string aDir,aPatIm;
SplitDirAndFile(aDir,aPatIm,aFullPattern);
cInterfChantierNameManipulateur * aICNM = cInterfChantierNameManipulateur::BasicAlloc(aDir);
const std::vector<std::string> * aSetIm = aICNM->Get(aPatIm);
std::vector<std::string> aVectIm=*aSetIm;
int nbIm=aVectIm.size();
ELISE_ASSERT(nbIm>1,"Less than two images found with this pattern");
//Computing homologous points
cout<<"Computing homologous points"<<endl;
cl_MatPtsHom aMatPtsHomol=ReadPtsHom3D(aDir, aPatIm, InVig, ResolModel, TPA);
//Computing and applying the equalization surface
cout<<"Computing and applying the equalization surface"<<endl;
Egal_field_correct_ite(aDir, & aVectIm, aMatPtsHomol, aDirOut, InVig, ResolModel, nbIm, nbIte, aThresh);
Arsenic_Banniere();
}
return 0;
}
int TestNameCalib_main(int argc,char ** argv)
{
std::string aFullNameIm,aNameCalib="TestNameCalib";
ElInitArgMain
(
argc,argv,
LArgMain() << EAMC(aFullNameIm, "Name of images", eSAM_IsPatFile),
LArgMain() << EAM(aNameCalib,"Nb",true,"Name of caib (def=TestNameCalib)")
);
std::string aDir,aNameIm;
SplitDirAndFile(aDir,aNameIm,aFullNameIm);
cInterfChantierNameManipulateur * aICNM = cInterfChantierNameManipulateur::BasicAlloc(aDir);
std::cout << aICNM->StdNameCalib(aNameCalib,aNameIm) << "\n";
return EXIT_SUCCESS;
}
int TestSet_main(int argc,char ** argv)
{
MMD_InitArgcArgv(argc,argv,2);
std::string aDir,aPat,aFullDir;
int aNbMax=10;
ElInitArgMain
(
argc,argv,
LArgMain() << EAMC(aFullDir,"Full Directory (Dir+Pattern)", eSAM_IsPatFile),
LArgMain() << EAM(aNbMax,"Nb",true,"Nb Max printed (def=10)")
);
if (MMVisualMode) return EXIT_SUCCESS;
#if (ELISE_windows)
replace( aFullDir.begin(), aFullDir.end(), '\\', '/' );
#endif
SplitDirAndFile(aDir,aPat,aFullDir);
cInterfChantierNameManipulateur * aICNM = cInterfChantierNameManipulateur::BasicAlloc(aDir);
const cInterfChantierNameManipulateur::tSet * mSetIm = aICNM->Get(aPat);
int aNb = ElMin(aNbMax,int(mSetIm->size()));
for (int aK=0 ; aK< aNb ; aK++)
{
std::string aName = (*mSetIm)[aK];
printf("%3d ",aK);
std::cout << aName ;
std::cout << "\n";
}
if (1)
{
// std::list<std::string> aL = RegexListFileMatch(aDir,aPat,1,false);
std::cout << "NB BY RFLM " << mSetIm->size() << "\n";
}
return EXIT_SUCCESS;
}
void StdXMl2CppAndString(const std::string &aNameInput)
{
XML_StdStringify(aNameInput);
std::string aDir,aPref;
SplitDirAndFile(aDir,aPref,aNameInput);
aPref = StdPrefix(aPref);
cElXMLTree aTreeSpec
(
std::string("include")+ELISE_CAR_DIR+"XML_GEN"+ELISE_CAR_DIR
+ aPref + std::string(".xml"));
aTreeSpec.StdGenCppGlob
(
std::string("src")+ELISE_CAR_DIR+"XML_GEN"+ELISE_CAR_DIR+ aPref + ".cpp",
std::string("include")+ELISE_CAR_DIR+"XML_GEN"+ELISE_CAR_DIR + aPref + ".h",
""
);
}
int Drunk_main(int argc,char ** argv)
{
//Testing the existence of argument (if not, print help file)
if(!MMVisualMode && argc==1)
{
argv[1]=(char*)"";//Compulsory to call MMD_InitArgcArgv
MMD_InitArgcArgv(argc,argv);
string cmdhelp;
cmdhelp=MMDir()+"bin/Drunk -help";
system_call(cmdhelp.c_str());
}
else
{
MMD_InitArgcArgv(argc,argv);
string aFullPattern,aOri;
string DirOut="DRUNK/";
bool Talk=true;
//Reading the arguments
ElInitArgMain
(
argc,argv,
LArgMain() << EAMC(aFullPattern,"Images Pattern", eSAM_IsPatFile)
<< EAMC(aOri,"Orientation name", eSAM_IsExistDirOri),
LArgMain() << EAM(DirOut,"Out",true,"Output folder (end with /) and/or prefix (end with another char)")
<< EAM(Talk,"Talk",true,"Turn on-off commentaries")
);
//Processing the files
string aPattern, aDir;
SplitDirAndFile(aDir, aPattern, aFullPattern);
StdCorrecNameOrient(aOri, aDir);
Drunk(aPattern,aOri,DirOut,Talk);
}
return EXIT_SUCCESS;
}
cImage_LumRas::cImage_LumRas(const std::string& aNameFull,cAppli_LumRas & anAppli) :
mNameFull (aNameFull),
mAppli (anAppli),
mTiffIm (Tiff_Im::StdConvGen(aNameFull,1,true)),
mImShade (1,1),
mIm (1,1)
{
SplitDirAndFile(mDir,mName,mNameFull);
mIm = Im2D_U_INT2::FromFileStd(mNameFull);
if (mAppli.mKeyHom !="")
{
Pt2di aSzIn = mIm.sz();
std::string aNameH = mAppli.mEASF.mICNM->Assoc1To2(mAppli.mKeyHom,mName,NameWithoutDir(mAppli.mNameImBase),true);
std::cout << "SZ IM " << aSzIn << " " << mNameFull << " " << aNameH << "\n";
ElPackHomologue aPack = ElPackHomologue::FromFile(aNameH);
cElHomographie aHom = cElHomographie::RansacInitH(aPack,1000,1000);
aHom = aHom.Inverse();
Pt2di aSz = mAppli.mSz;
Im2D_U_INT2 anImReech(aSz.x,aSz.y);
TIm2D<U_INT2,INT> aTR(anImReech);
TIm2D<U_INT2,INT> aT0(mIm);
Pt2di aP;
for (aP.x=0 ; aP.x<aSz.x ; aP.x++)
{
for (aP.y=0 ; aP.y<aSz.y ; aP.y++)
{
aTR.oset(aP,aT0.getr(aHom.Direct(Pt2dr(aP)),0));
}
}
mIm = anImReech;
}
}
std::string Dir2Write(const std::string DirChantier)
{
static bool First = true;
static std::string aRes;
if (First)
{
First = false;
aRes = DirChantier + "Tmp-MM-Dir/TestOpenMMmmmm" + mm_getstrpid();
if (TestFileOpen(aRes))
return DirChantier + "Tmp-MM-Dir/";
aRes = DirChantier + "TestOpenMMmmmm" + mm_getstrpid();
if (TestFileOpen(aRes))
return DirChantier;
for (int aK=0 ; aK<MemoArgc; aK++)
{
std::string aDir,aName;
SplitDirAndFile(aDir,aName,MemoArgv[aK]);
aRes = aDir + "TestOpenMMmmmm" + mm_getstrpid();
if (TestFileOpen(aRes))
return aDir;
}
aRes = MMDir() + "TestOpenMMmmmm"+mm_getstrpid();
if (TestFileOpen(aRes))
return MMDir();
ELISE_ASSERT(false,"Cannot find any directoruy to write tmp files");
}
return aRes;
}
int MM_FusionNuage_main(int argc,char ** argv)
{
std::string aFullName,anOri;
std::string aKeyNuage= "NKS-Assoc-Im2NuageInit@Masq-TieP-@RN@xml";
std::string aKeyBsH= "NKS-Assoc-Im2NuageInit@Masq-TieP-@BSH-@tif";
cParamFuNu aParam;
ElInitArgMain
(
argc,argv,
LArgMain() << EAMC(aFullName,"Dir + Pat")
<< EAMC(anOri,"Orientation"),
LArgMain() << EAM(aKeyNuage,"Key",true,"Key Assoc Im->Nuage")
<< EAM(aParam.mNbCellCalcGraph,"NbCelGraph",true,"Nb Cell/Im To limit computation time, def=15")
<< EAM(aParam.mPercRecMin,"PercRecMin",true,"Percent of point for graph")
);
std::string aKeyImSec= "NKS-Assoc-ImSec@-"+anOri;
std::string aDir,aPat;
SplitDirAndFile(aDir,aPat,aFullName);
cAppliFusionNuage * anAppli = new cAppliFusionNuage
(
aParam,
aDir,
aPat,
aKeyNuage,
aKeyImSec,
aKeyBsH
);
anAppli->NoOp();
return 0;
}
cElNuage3DMaille * cElNuage3DMaille::FromFileIm
(
const std::string & aFile,
const std::string & aTag,
const std::string & aMasq,
double ExagZ
)
{
std::string aDir,aNF;
SplitDirAndFile(aDir,aNF,aFile);
return FromParam
(
StdGetObjFromFile<cXML_ParamNuage3DMaille>
(
aFile,
StdGetFileXMLSpec("SuperposImage.xml"),
aTag,
"XML_ParamNuage3DMaille"
),
aDir,
aMasq,
ExagZ
);
}
int Apero2PMVS_main(int argc,char ** argv)
{
MMD_InitArgcArgv(argc,argv);
//Reading the arguments
string aFullPattern,aOri;
ElInitArgMain
(
argc,argv,
LArgMain() << EAMC(aFullPattern,"Images' name pattern", eSAM_IsPatFile)
<< EAMC(aOri,"Orientation name", eSAM_IsExistDirOri),
LArgMain()
);
if (MMVisualMode) return EXIT_SUCCESS;
string aPattern, aDir;
SplitDirAndFile(aDir, aPattern, aFullPattern);
StdCorrecNameOrient(aOri, aDir);
Apero2PMVS(aFullPattern,aOri);
return EXIT_SUCCESS;
}
void Apero2PMVS(string aFullPattern, string aOri)
{
string aPattern,aNameDir;
SplitDirAndFile(aNameDir,aPattern,aFullPattern);
//Bulding the output file system
ELISE_fp::MkDirRec(aNameDir + "pmvs-"+ aOri +"/models/");
ELISE_fp::MkDir(aNameDir + "pmvs-"+ aOri +"/visualize/");
ELISE_fp::MkDir(aNameDir + "pmvs-"+ aOri +"/txt/");
//Reading the list of input files
list<string> ListIm=RegexListFileMatch(aNameDir,aPattern,1,false);
int nbIm=ListIm.size();
cout<<"Images to process: "<<nbIm<<endl;
string cmdDRUNK,cmdConv;
list<string> ListDrunk,ListConvert;
cInterfChantierNameManipulateur * anICNM = cInterfChantierNameManipulateur::BasicAlloc(aNameDir);
//Computing PMVS orientations and writing lists of DRUNK and Convert commands
for(int i=0;i<nbIm;i++)
{
//Reading the images list
string aFullName=ListIm.front();
cout<<aFullName<<" ("<<i+1<<" of "<<nbIm<<")"<<endl;
ListIm.pop_front();
//Creating the numerical format for the output files names
char nb[9];
sprintf(nb, "%08d", i);
//Creating the lists of DRUNK and Convert commands
cmdDRUNK=MMDir() + "bin/Drunk " + aNameDir + aFullName + " " + aOri + " Out=" + "pmvs-" + aOri + "/visualize/ Talk=0";
ListDrunk.push_back(cmdDRUNK);
#if (ELISE_unix || ELISE_Cygwin || ELISE_MacOs)
cmdConv="convert ephemeral:" + aNameDir + "pmvs-" + aOri + "/visualize/" + aFullName + ".tif " + aNameDir + "pmvs-"+ aOri +"/visualize/"+(string)nb + ".jpg";
#endif
#if (ELISE_windows)
cmdConv=MMDir() + "binaire-aux/convert ephemeral:" + aNameDir + "pmvs-" + aOri + "/visualize/" + aFullName + ".tif " + aNameDir + "pmvs-"+ aOri +"/visualize/"+(string)nb + ".jpg";
#endif
ListConvert.push_back(cmdConv);
//Formating the camera name
string aNameCam="Ori-"+aOri+"/Orientation-"+aFullName+".xml";
//Loading the camera
CamStenope * aCS = CamOrientGenFromFile(aNameCam,anICNM);
//Compute the Computer Vision calibration matrix
ElMatrix<double> P(4,3,0.0);//Orientation (int & ext) matrix in the CV system
P=OriMatrixConvertion(aCS);
//Write the matrix in the PMVS fashion
string oriFileName=aNameDir + "pmvs-"+ aOri +"/txt/"+(string)nb+".txt";
FILE *f = fopen(oriFileName.c_str(), "w");
fprintf(f,"CONTOUR\n");
fprintf(f,"%0.6f %0.6f %0.6f %0.6f\n", P(0,0),P(1,0),P(2,0),P(3,0));
fprintf(f,"%0.6f %0.6f %0.6f %0.6f\n", P(0,1),P(1,1),P(2,1),P(3,1));
fprintf(f,"%0.6f %0.6f %0.6f %0.6f\n", P(0,2),P(1,2),P(2,2),P(3,2));
fclose(f);
delete aCS;
// delete anICNM; => OBJET A NE PAS DETRUIRE ...
}//end of "for each image"
//Undistorting the images with Drunk
cout<<"Undistorting the images with Drunk"<<endl;
cEl_GPAO::DoComInParal(ListDrunk,aNameDir + "MkDrunk");
//Converting into .jpg (pmvs can't use .tif) with Convert
cout<<"Converting into .jpg"<<endl;
cEl_GPAO::DoComInParal(ListConvert,aNameDir + "MkConvert");
// Write the options file with basic parameters
cout<<"Writing the option file"<<endl;
string optFileName=aNameDir + "pmvs-"+ aOri +"/pmvs_options.txt";
FILE *f_opt = fopen(optFileName.c_str(), "w");
fprintf(f_opt, "level 1\n");
fprintf(f_opt, "csize 2\n");
fprintf(f_opt, "threshold 0.7\n");
fprintf(f_opt, "wsize 7\n");
fprintf(f_opt, "minImageNum 3\n");
fprintf(f_opt, "CPU 4\n");
fprintf(f_opt, "setEdge 0\n");
fprintf(f_opt, "useBound 0\n");
fprintf(f_opt, "useVisData 0\n");
fprintf(f_opt, "sequence -1\n");
fprintf(f_opt, "timages -1 0 %d\n", nbIm);
fprintf(f_opt, "oimages -3\n");
fclose(f_opt);
Apero2PMVS_Banniere();
}
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;
}
int SBGlobBascule_main(int argc,char ** argv)
{
NoInit = "NoP1P2";
aNoPt = Pt2dr(123456,-8765432);
// MemoArg(argc,argv);
MMD_InitArgcArgv(argc,argv);
std::string aDir,aPat,aFullDir;
bool ExpTxt=false;
std::string AeroIn;
std::string AeroOut;
std::string PostPlan="_Masq";
std::string FileMesures ;
std::string TargetRep = "ki" ;
bool CPI = false;
double DistFE = 0;
//Pt3dr Normal;
//Pt3dr SNormal;
ElInitArgMain
(
argc,argv,
LArgMain() << EAMC(aFullDir,"Full name (Dir+Pat)", eSAM_IsPatFile )
<< EAMC(AeroIn,"Orientation in", eSAM_IsExistDirOri)
<< EAMC(FileMesures,"Images measures xml file", eSAM_IsExistFile)
<< EAMC(AeroOut,"Out : orientation ", eSAM_IsOutputDirOri),
LArgMain()
<< EAM(ExpTxt,"ExpTxt",true)
<< EAM(PostPlan,"PostPlan",true)
<< EAM(DistFE,"DistFS",true,"Distance between Ech1 and Ech2 to fix scale (if not given no scaling)")
<< EAM(TargetRep,"Rep",true,"Target coordinate system (Def = ki, ie normal is vertical)")
<< EAM(CPI,"CPI",true,"Calibration Per Image (Def=false)")
);
if (!MMVisualMode)
{
#if (ELISE_windows)
replace( aFullDir.begin(), aFullDir.end(), '\\', '/' );
#endif
SplitDirAndFile(aDir,aPat,aFullDir);
if (EAMIsInit(&PostPlan))
{
CorrecNameMasq(aDir,aPat,PostPlan);
}
StdCorrecNameOrient(AeroIn,aDir);
MMD_InitArgcArgv(argc,argv);
std::string aCom = MM3dBinFile( "Apero" )
+ MMDir() + std::string("include/XML_MicMac/Apero-SB-Bascule.xml ")
+ std::string(" DirectoryChantier=") +aDir + std::string(" ")
+ std::string(" +PatternAllIm=") + QUOTE(aPat) + std::string(" ")
+ std::string(" +AeroOut=-") + AeroOut
+ std::string(" +Ext=") + (ExpTxt?"txt":"dat")
+ std::string(" +AeroIn=-") + AeroIn
+ std::string(" +PostMasq=") + PostPlan
+ std::string(" +DistFE=") + ToString(DistFE)
+ std::string(" +RepNL=") + TargetRep
+ std::string(" +FileMesures=") + FileMesures
+ std::string(" +CPI=") + ToString(CPI)
;
std::cout << "Com = " << aCom << "\n";
int aRes = system_call(aCom.c_str());
return aRes;
}
else
{
return EXIT_SUCCESS;
}
}
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 AperiCloud_main(int argc,char ** argv)
{
MMD_InitArgcArgv(argc,argv);
std::string aDir,aPat,aFullDir;
std::string AeroIn;
//std::vector<std::string> ImPl;
int ExpTxt=0;
int PlyBin=1;
bool CalPerIm=false;
std::string Out="";
int RGB = -1;
double aSeuilEc = 10.0;
double aLimBsH;
bool WithPoints = true;
bool WithCam = true;
Pt2dr aFocs;
Pt3di aColCadre(255,0,0);
Pt3di aColRay(0,255,0);
std::string aSetHom="";
std::string aKeyCalcName;
ElInitArgMain
(
argc,argv,
LArgMain() << EAMC(aFullDir,"Full name (Dir+Pattern)", eSAM_IsPatFile)
<< EAMC(AeroIn,"Orientation directory", eSAM_IsExistDirOri),
LArgMain()
<< EAM(ExpTxt,"ExpTxt",true,"Point in txt format ? (Def=false)", eSAM_IsBool)
<< EAM(Out,"Out",true,"Result (Def=AperiCloud.ply)", eSAM_IsOutputFile)
<< EAM(PlyBin,"Bin",true,"Ply in binary mode (Def=true)", eSAM_IsBool)
<< EAM(RGB,"RGB",true,"Use RGB image to texturate points (Def=true)")
<< EAM(aSeuilEc,"SeuilEc",true,"Max residual (Def=10)")
<< EAM(aLimBsH,"LimBsH",true,"Limit ratio base to height (Def=1e-2)", eSAM_NoInit)
<< EAM(WithPoints,"WithPoints",true,"Do we add point cloud? (Def=true) ",eSAM_IsBool)
<< EAM(CalPerIm,"CalPerIm",true,"If a calibration per image was used (Def=false)",eSAM_IsBool)
<< EAM(aFocs,"Focs",true,"Interval of Focal")
<< EAM(WithCam,"WithCam",true,"With Camera (Def=true)")
<< EAM(aColCadre,"ColCadre",true,"Col of camera rect Def= 255 0 0 (Red)")
<< EAM(aColRay,"ColRay",true,"Col of camera rect Def= 0 255 0 (Green)")
<< EAM(aSetHom,"SH",true,"Set of Hom, Def=\"\", give MasqFiltered for result of HomolFilterMasq")
<< EAM(aKeyCalcName,"KeyName",true,"Key to compute printed string (Def contain only digit)")
);
if (!MMVisualMode)
{
if (RGB >=0)
{
RGB = RGB ? 3 : 1;
}
string aXmlName="Apero-Cloud.xml";
/*
if (CalPerIm)
{
aXmlName="Apero-Cloud-PerIm.xml";
}
*/
#if (ELISE_windows)
replace( aFullDir.begin(), aFullDir.end(), '\\', '/' );
#endif
SplitDirAndFile(aDir,aPat,aFullDir);
StdCorrecNameOrient(AeroIn,aDir);
if (Out=="")
{
Out="AperiCloud_" + AeroIn + ".ply";
}
//std::string aCom = MMDir() + std::string("bin" ELISE_STR_DIR "Apero ")
// + MMDir() + std::string("include" ELISE_STR_DIR "XML_MicMac" ELISE_STR_DIR "Apero-Cloud.xml ")
std::string aCom = MM3dBinFile_quotes("Apero")
+ ToStrBlkCorr( MMDir()+std::string("include" ELISE_STR_DIR "XML_MicMac" ELISE_STR_DIR)+ aXmlName)+" "
+ std::string(" DirectoryChantier=") +aDir + std::string(" ")
+ std::string(" +PatternAllIm=") + QUOTE(aPat) + std::string(" ")
+ std::string(" +Ext=") + (ExpTxt?"txt":"dat")
+ std::string(" +AeroIn=-") + AeroIn
+ std::string(" +Out=") + Out
+ std::string(" +PlyBin=") + (PlyBin?"true":"false")
+ std::string(" +NbChan=") + ToString(RGB)
+ std::string(" +SeuilEc=") + ToString(aSeuilEc)
;
if (EAMIsInit(&CalPerIm))
aCom = aCom + " +CalPerIm=" +ToString(CalPerIm);
if (EAMIsInit(&aFocs))
{
aCom = aCom + " +FocMin=" + ToString(aFocs.x) + " +FocMax=" + ToString(aFocs.y);
}
if (EAMIsInit(&WithCam))
{
aCom = aCom + " +WithCam=" + ToString(WithCam) ;
}
if (EAMIsInit(&aColCadre))
{
aCom = aCom + " +ColCadre=" + StrP2Coul(aColCadre) ;
}
if (EAMIsInit(&aColRay))
{
aCom = aCom + " +ColRay=" + StrP2Coul(aColRay) ;
}
if (! WithPoints)
{
aCom = aCom + std::string(" +KeyAssocImage=NKS-Assoc-Cste@NoPoint");
}
StdCorrecNameHomol(aSetHom,aDir);
if (EAMIsInit(&aSetHom))
aCom = aCom + std::string(" +SetHom=") + aSetHom;
if (EAMIsInit(&aKeyCalcName))
{
aCom = aCom + " +WithCalcName=true +CalcName=" + aKeyCalcName;
}
if (EAMIsInit(&aLimBsH))
aCom = aCom + std::string(" +LimBsH=") + ToString(aLimBsH);
std::cout << "Com = " << aCom << "\n";
int aRes = System(aCom.c_str());
return aRes;
}
else
return EXIT_SUCCESS;
}
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 Devlop_main(int argc,char ** argv)
{
std::string aFullDir;
std::string aPostAdd="None";
std::string aNameOut="";
int En8B = 1;
int EnGray = 1;
int ConsCol = 0;
std::string aSplit = "";
ElInitArgMain
(
argc,argv,
LArgMain() << EAMC(aFullDir,"Full name (Dir+Pattern)", eSAM_IsPatFile),
LArgMain() << EAM(En8B,"8B",true)
<< EAM(EnGray,"Gray",true)
<< EAM(aPostAdd,"Post",true)
<< EAM(ConsCol,"ConsCol",true)
<< EAM(aNameOut,"NameOut",true)
<< EAM(aSplit,"Split",true)
);
if (!MMVisualMode)
{
std::string aDir,aPatFile;
SplitDirAndFile(aDir,aPatFile,aFullDir);
std::string aPost = StdPostfix(aPatFile);
std::string aPref = StdPrefix(aPatFile);
std::string aCom = MMBin() + " " + MM3DStr + " MapCmd ";
std::string aPat= QUOTE("P=" + aDir+ "("+aPref+")." + aPost);
// if (aNameOut =="") aNameOut = "\\$1" + (aPostAdd=="None"?"":aPostAdd) + ".tif" ;
std::string aSubst= "\\$1" + (aPostAdd=="None"?"":aPostAdd) + ".tif";
{
aCom = aCom + MMBin() +"MpDcraw " + aPat + " Add16B8B=0 ";
if (aSplit!="")
{
aCom = aCom + " " + QUOTE("Split="+aSplit);
}
else
{
aCom = aCom + (EnGray ? " GB=1 " : " CB=1 ");
}
aCom = aCom + " 16B=" + (En8B ? "0 " : "1 ") ;
aCom = aCom + " ExtensionAbs=" + aPostAdd ;
aCom = aCom + " ConsCol=" + ToString(ConsCol) ;
if (aNameOut != "")
{
aCom = aCom + QUOTE(" NameOut=" + aNameOut);
aCom = aCom + " " + QUOTE("T=" + aNameOut);
}
else
{
aCom = aCom + " " + QUOTE("T=" + aSubst) ;
}
}
aCom = aCom+ " M=MkDevlop";
// std::cout << aCom << "\n"; getchar();
System(aCom);
//aCom = g_externalToolHandler.get( "make" ).callName()+" all -f MkDevlop -j" + ToString(MMNbProc());
//System(aCom);
launchMake( "MkDevlop", "all" );
return EXIT_SUCCESS;
}
else
return EXIT_SUCCESS;
}
