int Luc_main_corner_crop(int argc,char ** argv){
std::string aFullPattern, cornersTxt;
//Reading the arguments
ElInitArgMain
(
argc,argv,
LArgMain() << EAMC(aFullPattern,"Images Pattern")
<< EAMC(cornersTxt,"Corner txt File"),
LArgMain()
);
std::string aDir,aPatIm;
SplitDirAndFile(aDir,aPatIm,aFullPattern);
ELISE_fp::MkDirRec(aDir + "Croped_images/");
cInterfChantierNameManipulateur * aICNM = cInterfChantierNameManipulateur::BasicAlloc(aDir);
const std::vector<std::string> * aSetIm = aICNM->Get(aPatIm);
std::vector<std::string> aVectIm=*aSetIm;
int nbIm=aVectIm.size();
vector<vector<Pt2dr> > Pts;
vector<int> SzX, SzY;
std::ifstream file(cornersTxt.c_str(), ios::in);
for(int i=0 ; i<nbIm ; i++)
{
vector<Pt2dr> PtsIm(3);
string name;
file >> name >> PtsIm[0].x >> PtsIm[0].y >> name >> PtsIm[1].x >> PtsIm[1].y >> name >> PtsIm[2].x >> PtsIm[2].y;
Pts.push_back(PtsIm);
SzX.push_back((int)euclid(PtsIm[0], PtsIm[1])); SzY.push_back((int)euclid(PtsIm[2], PtsIm[1]));
}
file.close();
cout<<Pts<<endl;
Pt2di aCrop; int border=10;
aCrop.x=min(*min_element(SzX.begin(), SzX.end())-2*border,*min_element(SzY.begin(), SzY.end())-2*border);
aCrop.y=aCrop.x;
//aCrop.x=*min_element(std::begin(SzX), std::end(SzX))-2*border;
//aCrop.y=*min_element(std::begin(SzY), std::end(SzY))-2*border;
cout<<"Cropping to : "<<aCrop.x<<" "<<aCrop.y<<endl;
for(int i=0 ; i<nbIm ; i++)
{
double alpha=(atan((Pts[i][0].y-Pts[i][1].y)/(Pts[i][0].x-Pts[i][1].x))+atan(-(Pts[i][2].x-Pts[i][1].x)/(Pts[i][2].y-Pts[i][1].y)))/2;
cout<<"Alpha = "<<alpha<<endl;
RotateImage(alpha, aCrop, Pts[i], aDir, aVectIm[i]);
}
//Pt2dr P1,P2,P3;
//P1.x= 795 ; P1.y= 1064;
//P2.x= 7401; P2.y= 926 ;
//P3.x= 7518; P3.y= 7598;
//cout<<(P1.y-P2.y)/(P1.x-P2.x)<<endl;
//cout<<atan((P1.y-P2.y)/(P1.x-P2.x))<<endl;
//cout<<(P3.x-P2.x)/(P3.y-P2.y)<<endl;
//cout<<atan((P3.x-P2.x)/(P3.y-P2.y))<<endl;
//double aT1=atan((P1.y-P2.y)/(P1.x-P2.x));
//double aT2=atan(-(P3.x-P2.x)/(P3.y-P2.y));
//cout<<aT1<<" + "<<aT2<< " = " <<(aT1+aT2)<<endl;
return 0;
}
int TD_Match1_main(int argc,char ** argv)
{
bool ByCorrel = false;
std::string aNameI1,aNameI2;
int aDeltaPax=100;
int aSzW = 5;
ElInitArgMain
(
argc,argv,
LArgMain() << EAMC(aNameI1,"Name Im1")
<< EAMC(aNameI2,"Name Im2"),
LArgMain() << EAM(aDeltaPax,"DPax",true,"Delta paralax")
<< EAM(aSzW,"SzW",true,"Size of Window, Def=5")
<< EAM(ByCorrel,"ByCorrel",true,"By correlation")
);
Pt2di aP;
// on charger nos deux images
// image 1
cTD_Im aI1 = cTD_Im::FromString(aNameI1);
Pt2di aSz = aI1.Sz();
std::string aNameMasqIm1 = std::string("Masq_") + aNameI1;
cTD_Im aIMasq(aSz.x,aSz.y);
if (ELISE_fp::exist_file(aNameMasqIm1))
{
aIMasq = cTD_Im::FromString(aNameMasqIm1);
}
else
{
for (aP.x=0; aP.x < aSz.x ; aP.x++)
{
for (aP.y=0 ; aP.y < aSz.y ; aP.y++)
{
aIMasq.SetVal(aP.x,aP.y,1);
}
}
}
// image 2
cTD_Im aI2 = cTD_Im::FromString(aNameI2);
//aI1 = aI1.ImageMoy(aSzW,1);
// aI2 = aI2.ImageMoy(aSzW,1);
// on crée un image pour stocker le résultat de la corrélation
cTD_Im aICorelMin = cTD_Im(aSz.x, aSz.y);
// on crée la carte de profondeur
cTD_Im aIProf = cTD_Im(aSz.x, aSz.y);
for (aP.x=0; aP.x < aSz.x ; aP.x++)
{
if ((aP.x%50)==0) std::cout << "Reste " << aSz.x-aP.x << "\n";
for (aP.y=0 ; aP.y < aSz.y ; aP.y++)
{
float aDiffMin = Beaucoup;
int aPaxOpt=0;
Pt2di aPPax(0,0);
if (aIMasq.GetVal(aP.x,aP.y))
{
for ( aPPax.x = -aDeltaPax ; aPPax.x<=aDeltaPax ; aPPax.x++)
{
Pt2di aP2 = aP+aPPax;
if (1)
{
float aDiff = ByCorrel ?
SimilByCorrel(aSzW,aI1,aP,aI2,aP2):
SimilByDif(aSzW,aI1,aP,aI2,aP2);
//float aDiff = SimilMultiW(aI1,aP,aI2,aP2);
if (aDiff < aDiffMin)
{
aDiffMin = aDiff;
aPaxOpt = aPPax.x;
}
}
}
}
aIProf.SetVal(aP.x,aP.y,aPaxOpt);
}
}
std::string aNameRes = "CartePax";
aNameRes += std::string("_SzW") + ToString(aSzW);
aNameRes += ByCorrel ? "Correl" : "Dif";
aNameRes += ".tif";
aIProf.Save(aNameRes );
System("to8Bits " + aNameRes + " Circ=1 Dyn=10");
return EXIT_SUCCESS;
}
int TD_Match2_main(int argc,char ** argv)
{
std::string aNameI1,aNameI2;
int aDeltaPax=100;
int aSzW = 5;
ElInitArgMain
(
argc,argv,
LArgMain() << EAMC(aNameI1,"Name Im1")
<< EAMC(aNameI2,"Name Im2"),
LArgMain() << EAM(aDeltaPax,"DPax",true,"Delta paralax")
<< EAM(aSzW,"SzW",true,"Size of Window, Def=5")
);
// image 1
cTD_Im aI1 = cTD_Im::FromString(aNameI1);
// image 2
cTD_Im aI2 = cTD_Im::FromString(aNameI2);
//dimension de nos images, sera utile pour nos boucles
Pt2di aSz = aI1.Sz();
cTD_Im aIBestScore(aSz.x,aSz.y);
cTD_Im aIBestPax(aSz.x,aSz.y);
Pt2di aP;
for (aP.x=0; aP.x < aSz.x ; aP.x++)
{
for (aP.y=0 ; aP.y < aSz.y ; aP.y++)
{
aIBestScore.SetVal(aP.x,aP.y,Beaucoup);
aIBestPax.SetVal(aP.x,aP.y,sin((float)aP.x)*30*sin((float)aP.y));
}
}
Pt2di aPPax;
for ( aPPax.x = -aDeltaPax ; aPPax.x<=aDeltaPax ; aPPax.x++)
{
std::cout << "Pax= " << aPPax.x << "\n";
// Calculer images des valeurs absolue des difference trans
cTD_Im aImDif(aSz.x,aSz.y);
for (aP.x=0; aP.x < aSz.x ; aP.x++)
{
for (aP.y=0 ; aP.y < aSz.y ; aP.y++)
{
Pt2di aPTr = aP + aPPax;
float aDif = 256;
if (aI2.Ok(aPTr.x,aPTr.y))
{
aDif = aI1.GetVal(aP) - aI2.GetVal(aPTr);
}
aImDif.SetVal(aP.x,aP.y,std::fabs(aDif));
}
}
// Calculer l'image moyenne
cTD_Im aImDifMoy = aImDif.ImageMoy(aSzW,1);
// Mettre a jour aIBestScore et aIBestPax
for (aP.x=0; aP.x < aSz.x ; aP.x++)
{
for (aP.y=0 ; aP.y < aSz.y ; aP.y++)
{
float aDif =aImDifMoy.GetVal(aP);
if (aDif<aIBestScore.GetVal(aP))
{
aIBestScore.SetVal(aP.x,aP.y,aDif);
aIBestPax.SetVal(aP.x,aP.y,aPPax.x);
}
}
}
}
aIBestPax.Save("CartePax2.tif");
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;
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")
);
#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) || EAMIsInit(&aOriMasq3D);
cInterfChantierNameManipulateur * anICNM = cInterfChantierNameManipulateur::BasicAlloc(aDir);
std::string aKeyOri;
if (EAMIsInit(&aOriMasq3D))
{
anICNM->CorrecNameOrient(aOriMasq3D);
if (! EAMIsInit(&aNameMasq3D))
{
aNameMasq3D = aDir + "AperiCloud_" + aOriMasq3D + ".ply";
}
aMasq3D = cMasqBin3D::FromSaisieMasq3d(aDir+aNameMasq3D);
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;
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 (aMasq3D!=0)
{
aVCam.push_back(anICNM->StdCamOfNames(aNameIm,aOriMasq3D));
}
}
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);
bool Ok = ((aMasq1.get(aQ1,0) && aMasq2.get(aQ2,0)) || (! UseMasq));
if (Ok && aMasq3D)
{
Pt3dr aPTer= aVCam[aKN1]->PseudoInter(aP1,*(aVCam[aKN2]),aP2);
if (! aMasq3D->IsInMasq(aPTer))
Ok = false;
}
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;
return 0;
}
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();
}
}
}
cAppliTarama::cAppliTarama(int argc,char ** argv) :
cAppliWithSetImage(argc-1,argv+1,0)
{
NoInit = "XXXXXXXXXX";
// MemoArg(argc,argv);
MMD_InitArgcArgv(argc,argv);
std::string aDir,aPat,aFullDir;
std::string Aero;
int Zoom = 8;
std::string NOREP = "NO-REPERE";
std::string Repere = NOREP;
std::string DirOut = "TA";
double aZMoy = 0;
int aKNadir = -1;
double aIncidMax = 1e5;
bool UnUseAXC = false;
ElInitArgMain
(
argc,argv,
LArgMain() << EAMC(aFullDir,"Full Image (Dir+Pat)", eSAM_IsPatFile)
<< EAMC(Aero,"Orientation", eSAM_IsExistDirOri),
LArgMain()
<< EAM(Zoom,"Zoom",true,"Resolution, (Def=8, must be pow of 2)")
<< EAM(Repere,"Repere",true,"Local coordinate system as created with RepLocBascule")
<< EAM(DirOut,"Out",true,"Directory for output (Deg=TA)")
<< EAM(aZMoy,"ZMoy",true,"Average value of Z")
<< EAM(aKNadir,"KNadir",true,"KBest image or Nadir (when exist)")
<< EAM(aIncidMax,"IncMax",true,"Maximum incidence of image", eSAM_NoInit)
<< EAM(UnUseAXC,"UnUseAXC",true,"Internal use for unamophosed ortho")
);
if (!MMVisualMode)
{
#if (ELISE_windows)
replace( aFullDir.begin(), aFullDir.end(), '\\', '/' );
#endif
SplitDirAndFile(aDir,aPat,aFullDir);
StdCorrecNameOrient(Aero,aDir);
MMD_InitArgcArgv(argc,argv);
std::string aCom = MM3dBinFile( "MICMAC" )
+ MMDir() + std::string("include/XML_MicMac/MM-TA.xml ")
+ std::string(" WorkDir=") +aDir + std::string(" ")
+ std::string(" +PatternAllIm=") + QUOTE(aPat) + std::string(" ")
+ std::string(" +Zoom=") + ToString(Zoom)
+ std::string(" +Aero=") + Aero
+ std::string(" +DirMEC=") + DirOut
;
if (EAMIsInit(&aIncidMax))
{
aCom = aCom + " +DoIncid=true +IncidMax=" + ToString(aIncidMax) + " " + " +ZMoy=" + ToString(AltiMoy()) + " " ;
;
}
if (EAMIsInit(&aKNadir))
aCom = aCom + " +KBestMasqNadir=" + ToString(aKNadir);
if (EAMIsInit(&aZMoy))
{
aCom = aCom + " +FileZMoy=File-ZMoy.xml"
+ " +ZMoy=" + ToString(aZMoy);
}
if (EAMIsInit(&UnUseAXC)) aCom = aCom + " +UnUseAXC=" + ToString(UnUseAXC);
if (Repere!=NOREP)
{
bool IsOrthoXCste;
bool IsAnamXsteOfCart;
if (RepereIsAnam(aDir+Repere,IsOrthoXCste,IsAnamXsteOfCart))
{
aCom = aCom
+ std::string(" +DoAnam=true ")
+ std::string(" +DoIncid=true ")
+ std::string(" +ParamAnam=") + Repere;
}
else
{
aCom = aCom + std::string(" +Repere=") + Repere ;
}
}
std::cout << "Com = " << aCom << "\n";
mResult = system_call(aCom.c_str());
}
else
{
mResult = EXIT_SUCCESS;
}
}
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)
{
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)
);
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 GCPBascule_main(int argc,char ** argv)
{
// MemoArg(argc,argv);
MMD_InitArgcArgv(argc,argv);
std::string aDir,aPat,aFullDir;
std::string AeroOut;
std::string AeroIn;
std::string DicoPts;
std::string MesureIm;
bool ModeL1 = false;
bool CPI = false;
bool ShowUnused = true;
bool ShowDetail = false;
bool NLDShow = false;
bool NLDFTR = true;
std::string aPatNLD;
std::vector<std::string> NLDDegX; NLDDegX.push_back("1"); NLDDegX.push_back("X"); NLDDegX.push_back("Y");
std::vector<std::string> NLDDegY; NLDDegY.push_back("1"); NLDDegY.push_back("X"); NLDDegY.push_back("Y");
std::vector<std::string> NLDDegZ; NLDDegZ.push_back("1"); NLDDegZ.push_back("X"); NLDDegZ.push_back("X2");
/*
Pt3di NLDDegX(1,1,1);
Pt3di NLDDegY(1,1,1);
Pt3di NLDDegZ(2,0,2);
*/
ElInitArgMain
(
argc,argv,
LArgMain() << EAMC(aFullDir,"Full name (Dir+Pat)", eSAM_IsPatFile)
<< EAMC(AeroIn,"Orientation in", eSAM_IsExistDirOri)
<< EAMC(AeroOut,"Orientation out", eSAM_IsOutputDirOri)
<< EAMC(DicoPts,"Ground Control Points File", eSAM_IsExistFile)
<< EAMC(MesureIm,"Image Measurements File", eSAM_IsExistFile),
LArgMain()
<< EAM(ModeL1,"L1",true,"L1 minimisation vs L2 (Def=false)", eSAM_IsBool)
<< 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)
<< EAM(ShowDetail,"ShowD",true,"Show details (def=false)", eSAM_IsBool)
<< EAM(aPatNLD,"PatNLD",true,"Pattern for Non linear deformation, with aerial like geometry (def,unused)")
<< EAM(NLDDegX,"NLDegX",true,"Non Linear monoms for X, when PatNLD, (Def =[1,X,Y])")
<< EAM(NLDDegY,"NLDegY",true,"Non Linear monoms for Y, when PatNLD, (Def =[1,X,Y])")
<< EAM(NLDDegZ,"NLDegZ",true,"Non Linear monoms for Z, when PatNLD, (Def =[1,X,X2])")
<< EAM(NLDFTR,"NLFR",true,"Non Linear : Force True Rot (Def=true)",eSAM_IsBool)
<< EAM(NLDShow,"NLShow",true,"Non Linear : Show Details (Def=false)",eSAM_IsBool)
);
if (!MMVisualMode)
{
#if (ELISE_windows)
replace( aFullDir.begin(), aFullDir.end(), '\\', '/' );
#endif
SplitDirAndFile(aDir,aPat,aFullDir);
StdCorrecNameOrient(AeroIn,aDir);
MMD_InitArgcArgv(argc,argv);
std::string aCom = MM3dBinFile_quotes( "Apero" )
+ ToStrBlkCorr( MMDir()+"include/XML_MicMac/Apero-GCP-Bascule.xml" )+" "
+ std::string(" DirectoryChantier=") +aDir + std::string(" ")
+ std::string(" +PatternAllIm=") + QUOTE(aPat) + std::string(" ")
+ std::string(" +AeroIn=") + AeroIn
+ std::string(" +AeroOut=") + AeroOut
+ std::string(" +DicoApp=") + DicoPts
+ std::string(" +SaisieIm=") + MesureIm
;
if (EAMIsInit(&ShowUnused)) aCom = aCom + " +ShowUnused=" + ToString(ShowUnused);
if (EAMIsInit(&ShowDetail)) aCom = aCom + " +ShowDetail=" + ToString(ShowDetail);
if (ModeL1)
{
aCom = aCom+ std::string(" +L2Basc=") + ToString(!ModeL1);
}
if (CPI) aCom += " +CPI=true ";
if (EAMIsInit(&aPatNLD))
{
aCom = aCom + " +UseNLD=true +PatNLD=" + QUOTE(aPatNLD)
+ " +NLFlagX=" + ToString(FlagOfDeg(NLDDegX))
+ " +NLFlagY=" + ToString(FlagOfDeg(NLDDegY))
+ " +NLFlagZ=" + ToString(FlagOfDeg(NLDDegZ))
+ " +NLDForceTR=" + ToString(NLDFTR)
+ " +NLDShow=" + ToString(NLDShow)
;
}
std::cout << "Com = " << aCom << "\n";
int aRes = System(aCom.c_str(),false,true,true);
return aRes;
}
else return EXIT_SUCCESS;
}
