void cAppli_MPI2Mnt::DoAll()
{
if (mDoMnt ) DoMTD();
mParamTarget = StdGetFromSI(mTargetGeom,XML_ParamNuage3DMaille);
if (mDoMnt ) DoBascule();
if (mDoMnt ) DoMerge();
//============== Generation d'un Ori
cXML_ParamNuage3DMaille aN = StdGetFromSI(mDirApp+mDirBasc +mNameMerge,XML_ParamNuage3DMaille);
cFileOriMnt aFOM = ToFOM(aN,true);
MakeFileXML(aFOM,mDirApp+mDirBasc +mNameOriMasq);
double aSR = aN.SsResolRef().Val();
int aISR = round_ni(aSR);
ELISE_ASSERT(ElAbs(aSR-aISR)<1e-7,"cAppli_MPI2Mnt::DoAll => ToFOM");
aFOM.NombrePixels() = aFOM.NombrePixels()* aISR;
aFOM.ResolutionPlani() = aFOM.ResolutionPlani() / aISR;
aFOM.ResolutionAlti() = aFOM.ResolutionAlti() / aISR;
MakeFileXML(aFOM,mDirApp+mDirBasc +mNameOriMerge);
//============== Generation d'un Ori
if (mDoOrtho) DoOrtho();
}
void cAppli_XifGps2Xml::ExportSys(cSysCoord * aSC,const std::string & anOri)
{
std::string aKeyExport = "NKS-Assoc-Im2Orient@-" + anOri;
for (int aKI=0 ; aKI<int(mVIm.size()) ; aKI++)
{
const cIm_XifGp & anIm = mVIm[aKI];
if (anIm.mHasPT)
{
cOrientationConique anOC = mOC0;
anOC.Externe().Centre() = aSC->FromGeoC(anIm.mPGeoC);
MakeFileXML(anOC,mDir+mICNM->Assoc1To1(aKeyExport,anIm.mName,true));
}
}
}
int LucasChCloud_main(int argc,char ** argv)
{
//===================== PARAMETRES EN DUR ==============
std::string aNameNuage,aNameOut;
ElInitArgMain
(
argc,argv,
LArgMain() << EAMC(aNameNuage,"Name input "),
LArgMain() << EAM(aNameOut,"Out",true)
);
if (! EAMIsInit(&aNameOut))
aNameOut = DirOfFile(aNameNuage) + "TestScale_" + NameWithoutDir(aNameNuage);
cXML_ParamNuage3DMaille aXML = StdGetObjFromFile<cXML_ParamNuage3DMaille>
(
aNameNuage,
StdGetFileXMLSpec("SuperposImage.xml"),
"XML_ParamNuage3DMaille",
"XML_ParamNuage3DMaille"
);
double aScale = 2;
cRepereCartesien aRep;
aRep.Ori() = Pt3dr(0,0,0);
aRep.Ox() = Pt3dr(aScale,0,0);
aRep.Oy() = Pt3dr(0,aScale,0);
aRep.Oz() = Pt3dr(0,0,aScale);
aXML.RepereGlob().SetVal(aRep);
MakeFileXML(aXML,aNameOut);
return 0;
}
void TestRandomSetOfMesureSegDr()
{
std::string aInput="/media/data1/ExempleDoc/Test-CompDrAnalogik/MesureLineImageOri.xml";
std::string aOut="/media/data1/ExempleDoc/Test-CompDrAnalogik/MesureLineImage.xml";
cSetOfMesureSegDr aSMS = StdGetFromPCP(aInput,SetOfMesureSegDr);
for
(
std::list<cMesureAppuiSegDr1Im>::iterator itIm=aSMS.MesureAppuiSegDr1Im().begin();
itIm!=aSMS.MesureAppuiSegDr1Im().end();
itIm++
)
{
std::string aNameIm = itIm->NameIm();
{
for
(
std::list<cOneMesureSegDr>::iterator itMes=itIm->OneMesureSegDr().begin();
itMes!=itIm->OneMesureSegDr().end();
itMes++
)
{
Pt2dr aP1 = itMes->Pt1Im();
Pt2dr aP2 = itMes->Pt2Im();
SegComp aSeg(aP1,aP2);
itMes->Pt1Im() = aSeg.from_rep_loc(Pt2dr(0.6+NRrandC(),0));
itMes->Pt2Im() = aSeg.from_rep_loc(Pt2dr(0.4-NRrandC(),0));
}
}
}
MakeFileXML(aSMS,aOut);
exit(0);
}
int XifGps2Xml_main(int argc,char ** argv)
{
MMD_InitArgcArgv(argc,argv,2);
std::string aFullName;
std::string anOri;
bool DoRTL = true;
std::string aNameRTL = "RTLFromExif.xml";
std::string aNameSys = aNameRTL;
double aDefZ=0;
ElInitArgMain
(
argc,argv,
LArgMain() << EAMC(aFullName,"Full Name", eSAM_IsPatFile)
<< EAMC(anOri,"Orientation", eSAM_IsExistDirOri),
LArgMain() << EAM(DoRTL,"DoRTL",true,"Do Local Tangent RTL (def=true)")
<< EAM(aNameRTL,"RTL", true,"Name RTL", eSAM_IsExistFileRP)
<< EAM(aNameSys,"SysCo",true, "System of coordinates, by default RTL created (RTLFromExif.xml)", eSAM_IsExistFileRP)
<< EAM(aDefZ,"DefZ","Default value for altitude (def 0)")
);
if (MMVisualMode) return EXIT_SUCCESS;
cAppli_XifGps2Xml anAppli(aFullName,aDefZ);
if (DoRTL)
{
ELISE_ASSERT(anAppli.mNbOk!=0,"No GPS data to compute RTL reference system");
MakeFileXML(anAppli.mSysRTL,anAppli.mDir+aNameRTL);
}
cSysCoord * aSysCo = cSysCoord::FromFile(anAppli.mDir + aNameSys);
anAppli.ExportSys(aSysCo,anOri);
return 0;
}
void cImplemBlockCam::Export(const cExportBlockCamera & aEBC)
{
MakeFileXML(mEstimSBC,mAppli.ICNM()->Dir()+aEBC.NameFile());
}
void cAppliOptimTriplet::Execute()
{
ElTimer aChrono;
if (! EAMIsInit(&mNbMaxSel))
{
mNbMaxSel = mQuick ? QuickDefNbMaxSel : StdDefNbMaxSel;
}
if (mShow)
mQuitExist = false;
mNbMaxInit = mQuick ? QuickNbMaxInit : StdNbMaxInit ;
if (! EAMIsInit(&mShow))
mShow = EAMIsInit(&mSzShow);
if (MMVisualMode) return;
cNewO_OneIm * mNoIm3 = new cNewO_OneIm(*mNM,m3S.mV2);
std::string aNameSauveXml = mNM->NameOriOptimTriplet(false,mNoIm1,mNoIm2,mNoIm3,false);
std::string aNameSauveBin = mNM->NameOriOptimTriplet(true ,mNoIm1,mNoIm2,mNoIm3,false);
if (ELISE_fp::exist_file(aNameSauveXml) && ELISE_fp::exist_file(aNameSauveBin) && mQuitExist)
return ;
std::string aName3R = mNM->NameOriInitTriplet(true,mNoIm1,mNoIm2,mNoIm3);
cXml_Ori3ImInit aXml3Ori = StdGetFromSI(aName3R,Xml_Ori3ImInit);
mIms.push_back(new cImOfTriplet(0,*this,mNoIm1,ElRotation3D::Id));
mIms.push_back(new cImOfTriplet(1,*this,mNoIm2,Xml2El(aXml3Ori.Ori2On1())));
mIms.push_back(new cImOfTriplet(2,*this,mNoIm3,Xml2El(aXml3Ori.Ori3On1())));
mIm1 = mIms[0];
mIm2 = mIms[1];
mIm3 = mIms[2];
mFoc = 1/ ( (1.0/mIm1->Foc()+1.0/mIm2->Foc()+1.0/mIm3->Foc()) / 3.0 ) ;
// mP12 = new cPairOfTriplet(mIm1,mIm2,mIm3);
// mP13 = new cPairOfTriplet(mIm1,mIm3,mIm2);
// mP23 = new cPairOfTriplet(mIm2,mIm3,mIm1);
mPairs.push_back(new cPairOfTriplet(mIm1,mIm2,mIm3));
mPairs.push_back(new cPairOfTriplet(mIm1,mIm3,mIm2));
mPairs.push_back(new cPairOfTriplet(mIm2,mIm3,mIm1));
mP12 = mPairs[0];
mP13 = mPairs[1];
mP23 = mPairs[2];
mNM->LoadTriplet(mIm1->Im(),mIm2->Im(),mIm3->Im(),&mIm1->VFullPtOf3(),&mIm2->VFullPtOf3(),&mIm3->VFullPtOf3());
if (EAMIsInit(&mSzShow) && (!EAMIsInit(&mNbMaxSel)))
{
mNbMaxSel = ModeShowNbMaxSel;
}
if (mShow)
std::cout << "Time load " << aChrono.uval() << "\n";
int aNb3 = round_up(CoutAttenueTetaMax(mIm2->VFullPtOf3().size() ,mNbMaxSel));
mNbMaxSel = aNb3;
// mSel3 = IndPackReduit(mIm2->VFullPtOf3(),mNbMaxInit,mNbMaxSel);
mSel3 = IndPackReduit(mIm2->VFullPtOf3(),mNbMaxInit,mNbMaxSel);
for (int aK=0 ; aK<3 ; aK++)
{
mIms[aK]->SetReduce(mSel3);
mFullH123.push_back(&(mIms[aK]->VFullPtOf3()));
mRedH123.push_back(&(mIms[aK]->VRedPtOf3()));
}
mP12->SetPackRed(false,mNbMaxInit,mNbMaxSel,mSel3,*mFullH123[1]);
mP23->SetPackRed(true ,mNbMaxInit,mNbMaxSel,mSel3,*mFullH123[1]);
mP13->SetPackRed(true ,mNbMaxInit,mNbMaxSel,mSel3,*mFullH123[0]);
mPds3 = ElMin(MaxSurPond3,(mP12->NbR()+mP13->NbR()+mP23->NbR())/double(mIm1->NbR()));
mBestResidu = ResiduGlob();
/*
TestOPA(*mP12);
*/
if (mShow)
{
std::cout << "Time reduc " << aChrono.uval() << " Pds3=" << mPds3 << "\n";
}
for (int aKP=0 ; aKP<int(mPairs.size()) ; aKP++)
{
TestOPA(*(mPairs[aKP]));
}
if (mShow)
{
std::cout << "Time opa " << aChrono.uval() << "\n";
}
if (mShow)
{
std::cout << "NB TRIPLE " << mIm2->VFullPtOf3().size() << " Resi3: " << ResiduTriplet() << " F " << mFoc << "\n";
std::cout << "RESIDU/PAIRES " << mP12->ResiduMoy() << " " << mP13->ResiduMoy() << " " << mP23->ResiduMoy() << " " << "\n";
std::cout << "R Glob " << ResiduGlob() << "\n";
}
#if (ELISE_X11)
if (EAMIsInit(&mSzShow))
{
mIm2->InitW(mSzShow);
ShowPoints(mIm2,mP12->FullVP2(),P8COL::cyan,2);
ShowPoints(mIm2,mP23->FullVP1(),P8COL::yellow,2);
ShowPointSel(mIm2,mP12->VRedP2(),P8COL::cyan);
ShowPointSel(mIm2,mP23->VRedP1(),P8COL::yellow);
std::cout << "NB 12 " << mP12->VRedP2().size() << "\n";
// ShowPoints(mIm2,mIm2->VFullPtOf3(),P8COL::blue,4);
// ShowPointSel(mSel3.mVSel,mIm2,mIm2->VFullPtOf3(),P8COL::red);
//
ShowPoints(mIm2,mIm2->VFullPtOf3(),P8COL::blue,2);
ShowPointSel(mIm2,mIm2->VRedPtOf3(),P8COL::blue);
//==================================
mIm1->InitW(mSzShow);
ShowPoints(mIm1,mP13->FullVP1(),P8COL::cyan,2);
ShowPointSel(mIm1,mP13->VRedP1(),P8COL::cyan);
ShowPoints(mIm1,mIm1->VFullPtOf3(),P8COL::blue,2);
ShowPointSel(mIm1,mIm1->VRedPtOf3(),P8COL::blue);
mIm2->W()->clik_in();
}
#endif
/*
SolveBundle3Image
(
mFoc,
mIm2->Rot(),
mIm3->Rot(),
mFullH123,
mP12->FullHoms(),
mP13->FullHoms(),
mP23->FullHoms()
);
*/
int aNbIterBundle = mQuick ? QuickNbIterBundle : StdNbIterBundle;
double aBOnH;
Pt3dr aPMed;
SolveBundle3Image
(
mFoc,
mIm2->Ori(),
mIm3->Ori(),
aPMed,
aBOnH,
mRedH123,
mP12->RedHoms(),
mP13->RedHoms(),
mP23->RedHoms(),
mPds3,
aNbIterBundle
);
cXml_Ori3ImInit aXml;
aXml.Ori2On1() = El2Xml(mIm2->Ori());
aXml.Ori3On1() = El2Xml(mIm3->Ori());
aXml.ResiduTriplet() = ResiduGlob();
aXml.NbTriplet() = (int)mRedH123[0]->size();
aXml.BSurH() = aBOnH;
aXml.PMed() = aPMed;
MakeFileXML(aXml,aNameSauveXml);
MakeFileXML(aXml,aNameSauveBin);
if (mShow)
{
std::cout << "NB TRIPLE " << mIm2->VFullPtOf3().size() << " Resi3: " << ResiduTriplet() << " F " << mFoc << "\n";
std::cout << "RESIDU/PAIRES " << mP12->ResiduMoy() << " " << mP13->ResiduMoy() << " " << mP23->ResiduMoy() << " " << "\n";
std::cout << "R Glob " << ResiduGlob() << "\n";
std::cout << "Time bundle " << aChrono.uval() << "\n";
}
for (int aK=0 ; aK<3 ; aK++)
{
delete mPairs[aK];
delete mIms[aK];
}
mPairs.clear();
mIms.clear();
mFullH123.clear();
mRedH123.clear();
}
int ConvertRtk_main(int argc,char ** argv)
{
std::string aDir, aFile, aOut;
bool addInc = false;
ElInitArgMain
(
argc, argv,
LArgMain() << EAMC(aDir, "Directory")
<< EAMC(aFile, "Rtk output.txt file", eSAM_IsExistFile),
LArgMain() << EAM(aOut,"Out",false,"output txt file name : def=Output.txt")
<< EAM(addInc,"addInc",false,"export also uncertainty values : def=flase",eSAM_IsBool)
);
std::string aFullName = aDir+aFile;
//name output .xml file
if (aOut=="")
{
aOut = StdPrefixGen(aFile) + ".xml";
}
std::vector<Pt3dr> aPosList;
std::vector<Pt3dr> aIcList;
//read rtk input file
ifstream fichier(aFullName.c_str()); //déclaration du flux et ouverture du fichier
if(fichier) // si l'ouverture a réussi
{
std::string ligne; //Une variable pour stocker les lignes lues
while(!fichier.eof())
{
getline(fichier,ligne);
if(ligne.compare(0,1,"%") == 0) //pour sauter l'entête (toute les lignes qui commencent par "%")
{
std::cout << " % Skip Header Line % " << std::endl;
std::cout << "Ligne = "<< ligne << std::endl;
}
else if(ligne.size() != 0) // problème de dernière ligne du fihier
{
std::string s = ligne;
std::vector<string> coord;
int lowmark=-1;
int uppermark=-1;
for(unsigned int i=0;i<s.size()+1;i++) // parser chaque ligne par l'espace
{
if(std::isspace(s[i]) && (lowmark!=-1))
{
string token = s.substr(lowmark,uppermark);
coord.push_back(token);
//nouveau mot
lowmark=-1;
uppermark=-1;
}
else
if(!(std::isspace(s[i])) && (lowmark==-1))
{
lowmark=i;
uppermark=i+1;
}
else if(!(std::isspace(s[i])) && (lowmark!=-1))
{
uppermark++;
}
else
{
lowmark=-1;
uppermark=-1;
}
}
Pt3dr Pt; //position
Pt3dr Ic;
Pt.x = atof(coord[2].c_str());
Pt.y = atof (coord[3].c_str());
Pt.z = atof (coord[4].c_str());
Ic.x = atof(coord[7].c_str());
Ic.y = atof(coord[8].c_str());
Ic.z = atof(coord[9].c_str());
aPosList.push_back(Pt);
aIcList.push_back(Ic);
}
}
fichier.close(); // fermeture fichier
}
else
std::cout<< "Erreur à l'ouverture !" << '\n';
//save coordinates in a .xml file
cDicoAppuisFlottant aDico;
for (int aKP=0 ; aKP<int(aPosList.size()) ; aKP++)
{
cOneAppuisDAF aOAD;
aOAD.Pt() = aPosList[aKP];
aOAD.Incertitude() = aIcList[aKP];
aDico.OneAppuisDAF().push_back(aOAD);
}
MakeFileXML(aDico,aOut);
return EXIT_SUCCESS;
}
int TestCam_main(int argc,char ** argv)
{
std::string aFullName;
std::string aNameCam;
std::string aNameDir;
std::string aNameTag = "OrientationConique";
bool ExtP = false;
bool TOC = false;
Pt2dr TDINV;
double X,Y,Z;
X = Y = Z = 0;
bool aModeGrid = false;
std::string Out;
ElInitArgMain
(
argc,argv,
LArgMain() << EAMC(aFullName,"File name", eSAM_IsPatFile)
<< EAMC(X,"x")
<< EAMC(Y,"y")
<< EAMC(Z,"z"),
LArgMain()
<< EAM(aNameTag,"Tag",true,"Tag to get cam")
<< EAM(aModeGrid,"Grid",true,"Test Grid Mode", eSAM_IsBool)
<< EAM(Out,"Out",true,"To Regenerate an orientation file",eSAM_NoInit)
<< EAM(ExtP,"ExtP",true,"Detail on external parameter", eSAM_IsBool)
<< EAM(TOC,"TOC",true,"Test corners", eSAM_IsBool)
<< EAM(TDINV,"TDINV",true,"Test Dist Inv",eSAM_NoInit)
);
SplitDirAndFile(aNameDir,aNameCam,aFullName);
cInterfChantierNameManipulateur * anICNM = cInterfChantierNameManipulateur::BasicAlloc(aNameDir);
/*
cTplValGesInit<std::string> aTplFCND;
cInterfChantierNameManipulateur * anICNM =
cInterfChantierNameManipulateur::StdAlloc(0,0,aNameDir,aTplFCND);
*/
ElCamera * aCam = Gen_Cam_Gen_From_File(aModeGrid,aFullName,aNameTag,anICNM);
CamStenope * aCS = aCam->CS();
if (ExtP)
{
std::cout << " ########### EXTERNAL ##############\n";
if (aCS)
{
std::cout << "Center " << aCS->VraiOpticalCenter() << "\n";
}
std::cout << " I : " << aCS->L3toR3(Pt3dr(1,0,0)) - aCS->L3toR3(Pt3dr(0,0,0)) << "\n";
std::cout << " J : " << aCS->L3toR3(Pt3dr(0,1,0)) - aCS->L3toR3(Pt3dr(0,0,0))<< "\n";
std::cout << " K : " << aCS->L3toR3(Pt3dr(0,0,1)) - aCS->L3toR3(Pt3dr(0,0,0))<< "\n";
std::cout << "\n";
}
if (TOC)
TestOneCorner(aCam);
if (EAMIsInit(&TDINV))
TestDistInv(aCam,TDINV);
if (aModeGrid)
{
std::cout << "Camera is grid " << aCam->IsGrid() << " " << aCam->Dist().Type() << "\n";
}
TestCamCHC(*aCam);
TestDirect(aCam,Pt3dr(X,Y,Z));
if (Out!="")
{
cOrientationConique aCO = aCam->StdExportCalibGlob();
MakeFileXML(aCO,Out);
}
return EXIT_SUCCESS;
}
cMA_AffineOrient::cMA_AffineOrient
(
cAppliMICMAC & anAppli,
cModeleAnalytiqueComp & aModele,
const cGeomDiscFPx & aGeoTer,
bool L1,
const Pt2di & aSzM,
const ElPackHomologue & aPackHom
) :
mAppli (anAppli),
mSzM (aSzM),
mImResidu (mSzM.x,mSzM.y),
mTImResidu (mImResidu),
mImPds (mSzM.x,mSzM.y),
mTImPds (mImPds),
mGeoTer (aGeoTer),
mPas (aModele.Modele().PasCalcul()),
mOri1 (aModele.mGeom1.GetOriNN()),
mOri2 (aModele.mGeom2.GetOriNN()),
mOC1 (new cOrientationConique(mOri1->StdExportCalibGlob())),
mOC2 (new cOrientationConique(mOri2->StdExportCalibGlob())),
// OO mOC1 (mOri1->OC() ? new cOrientationConique(*(mOri1->OC())) : 0),
// OO mOC2 (mOri2->OC() ? new cOrientationConique(*(mOri2->OC())) : 0),
mNbPtMin (aModele.Modele().NbPtMinValideEqOriRel().Val()),
mNewOri1 (*(mOri1->Dupl())),
mNewOri2 (*(mOri2->Dupl())),
mCam1 (*mOri1),
mCam2 (*mOri2),
mPack (aPackHom),
mSetEq (
(L1 ? cNameSpaceEqF::eSysL1Barrodale : cNameSpaceEqF::eSysPlein),
mPack.size()
),
mChR (Pt3dr(0,0,0),0,0,0),
// mSetEq (cNameSpaceEqF::eSysL1Barrodale,mPack.size()),
// On va donner des points corriges de la dist :
// mPIF (mSetEq.NewParamIntrNoDist(1.0,Pt2dr(0,0))),
mPIF (mSetEq.NewParamIntrNoDist(true,new CamStenopeIdeale(true,1.0,Pt2dr(0,0),aNoPAF))),
mCamF1 (mPIF->NewCam
(
cNameSpaceEqF::eRotFigee,
mChR * mCam1.Orient().inv()
)
),
mCamF2 (mPIF->NewCam
(
cNameSpaceEqF::eRotBaseU,
mChR * mCam2.Orient().inv(),
mCamF1
)
),
mCpl12 (mSetEq.NewCpleCam(*mCamF1,*mCamF2)),
mFocale (mOri1->Focale())
{
mSetEq.SetClosed();
mPIF->SetFocFree(false);
mPIF->SetPPFree(false);
int aNbEtape = 9;
int aFlag = 0;
for
(
std::list<int>::const_iterator itB = aModele.Modele().NumsAngleFiges().begin();
itB != aModele.Modele().NumsAngleFiges().end();
itB++
)
aFlag |= 1 << *itB;
for (int aK=0 ; aK<aNbEtape ; aK++)
{
mCamF2->RF().SetFlagAnglFige(aFlag);
/*
mCamF2->RF().SetModeRot
(
(aK<3) ?
cNameSpaceEqF::eRotCOptFige :
cNameSpaceEqF::eRotBaseU
);
*/
OneItere(aK==(aNbEtape-1));
}
std::string aName = mAppli.FullDirResult()
+ std::string("Residus_Dz")
+ ToString(round_ni(mGeoTer.DeZoom()))
+ std::string("_")
+ mAppli.NameChantier()
+ std::string(".tif");
Tiff_Im aFileResidu
(
aName.c_str(),
mSzM,
GenIm::u_int1,
Tiff_Im::No_Compr,
Tiff_Im::RGB
);
mNewOri2.SetOrientation(mCamF2->RF().CurRot());
Pt3dr aPMoy = CalcPtMoy(mNewOri1,mNewOri2);
mNewOri1.SetAltiSol(aPMoy.z);
mNewOri2.SetAltiSol(aPMoy.z);
std::string aNAu = aModele.Modele().AutomSelExportOri().Val();
std::string aNEx1 = aModele.Modele().AutomNamesExportOri1().Val();
std::string aNEx2 = aModele.Modele().AutomNamesExportOri2().Val();
std::string aNI1 = mAppli.PDV1()->Name();
std::string aNI2 = mAppli.PDV2()->Name();
std::string aNOri1 = mAppli.FullDirGeom()
+ StdNameFromCple(aModele.AutomExport(),aNAu,aNEx1,"@",aNI1,aNI2);
std::string aNOri2 = mAppli.FullDirGeom()
+ StdNameFromCple(aModele.AutomExport(),aNAu,aNEx2,"@",aNI1,aNI2);
bool aXmlRes = false;
if (StdPostfix(aNOri1)== "xml")
{
aXmlRes = true;
ELISE_ASSERT
(
(StdPostfix(aNOri2)=="xml")
&& (mOC1!=0) && (mOC2!=0),
"Incoherence in XML export for cMA_AffineOrient"
);
// Les points de verifs, si ils existent n'ont pas de raison d'etre transposables
mOC1->Verif().SetNoInit();
mOC2->Verif().SetNoInit();
ElRotation3D aR1 = mCamF1->RF().CurRot();
ElRotation3D aR2 = mCamF2->RF().CurRot();
mOC2->Externe() = From_Std_RAff_C2M(aR2,mOC2->Externe().ParamRotation().CodageMatr().IsInit());
mOC1->Externe().AltiSol().SetVal(aPMoy.z);
mOC2->Externe().AltiSol().SetVal(aPMoy.z);
mOC1->Externe().Profondeur().SetVal(ProfFromCam(aR1.inv(),aPMoy));
mOC2->Externe().Profondeur().SetVal(ProfFromCam(aR2.inv(),aPMoy));
}
TestOri1Ori2(true,*mOri1,*mOri2);
TestOri1Ori2(true,mNewOri1,mNewOri2);
std::cout << "ZMoyen = " << aPMoy.z << "\n";
Fonc_Num aFoK = (mImPds.in()>0);
Fonc_Num aFRes = Max(0,Min(255,128.0 +mImResidu.in()*20));
ELISE_COPY
(
aFileResidu.all_pts(),
aFoK*its_to_rgb(Virgule(aFRes,3.14,32*Abs(mImResidu.in()>0.5)))
+ (1-aFoK)*Virgule(255,0,0),
aFileResidu.out()
);
bool Exp1 = aModele.Modele().AutomNamesExportOri1().IsInit();
bool Exp2 = aModele.Modele().AutomNamesExportOri2().IsInit();
ELISE_ASSERT(Exp1 == Exp2,"Incoherence in AutomNamesExportOri");
if (Exp1)
{
std::cout << "EXPORT OOOOOOOOOOOOOOORI\n";
AssertAutomSelExportOriIsInit(aModele.Modele());
if(aXmlRes)
{
MakeFileXML(*mOC1,aNOri1,"MicMacForAPERO");
MakeFileXML(*mOC2,aNOri2,"MicMacForAPERO");
}
else
{
ELISE_ASSERT(false,"Cannot write ori ");
// OO mNewOri1.write_txt(aNOri1.c_str());
// OO mNewOri2.write_txt(aNOri2.c_str());
}
}
if (aModele.Modele().SigmaPixPdsExport().ValWithDef(-1) > 0)
{
double aPds = aModele.Modele().SigmaPixPdsExport().Val();
for
(
ElPackHomologue::iterator iT = mPack.begin();
iT != mPack.end();
iT++
)
{
Pt2dr aQ1 = mCam1.F2toPtDirRayonL3(iT->P1());
Pt2dr aQ2 = mCam2.F2toPtDirRayonL3(iT->P2());
double aL = ElAbs(mCpl12->ResiduSigneP1P2(aQ1,aQ2))*mFocale;
double aP = ElSquare(aPds)/(ElSquare(aPds)+ElSquare(aL));
iT->Pds() *= aP;
}
}
}
void cEtapeMecComp::OneBasculeMnt
(
Pt2di aP0Sauv,
Pt2di aP1Sauv,
cBasculeRes & aBR,
float ** aDataF,
INT2 ** aDataI,
Pt2di aSzData
)
{
ELISE_ASSERT
(
mIsOptimCont,
"Basculement requiert une optimisation continue "
);
cFileOriMnt anOri;
if (aBR.Explicite().IsInit())
{
anOri = aBR.Explicite().Val();
std::string aNameXML = mAppli.FullDirResult()
+ StdPrefixGen(anOri.NameFileMnt())
+ std::string(".xml");
MakeFileXML(anOri,aNameXML);
}
else if (aBR.ByFileNomChantier().IsInit())
{
std::string aNameFile =
mAppli.WorkDir()
+ aBR.Prefixe()
+ (aBR.NomChantier().Val() ? mAppli.NameChantier() :"")
+ aBR.Postfixe();
anOri = StdGetObjFromFile<cFileOriMnt>
(
aNameFile,
mAppli.NameSpecXML(),
aBR.NameTag().Val(),
"FileOriMnt"
);
}
else
{
ELISE_ASSERT(false,"Internal Error cEtapeMecComp::OneBasculeMnt");
}
// cFileOriMnt * aPtrOri=0;
// cFileOriMnt * aPtrOri=0;
// cFileOriMnt & anOri = aBR.Ori();
// std::cout << "XML MADE \n"; getchar();
const cGeomBasculement3D * aGeomB = 0;
if (anOri.Geometrie() == eGeomMNTEuclid)
{
if (
(mAppli.GeomMNT()==eGeomMNTFaisceauIm1ZTerrain_Px1D)
|| (mAppli.GeomMNT()==eGeomMNTFaisceauIm1ZTerrain_Px2D)
)
{
aGeomB = (mAppli.PDV1()->Geom().GeoTerrainIntrinseque());
}
/*
CE CAS PARTICULIER VIENT DE CE QUE cGeomImage_Faisceau redifinit la methode
Bascule. A ete utilise avec Denis Feurer & Co pour basculer en terrain
les reultat image.
*/
else if (
(mAppli.GeomMNT()==eGeomMNTFaisceauIm1PrCh_Px1D)
|| (mAppli.GeomMNT()==eGeomMNTFaisceauIm1PrCh_Px2D)
)
{
aGeomB = &(mAppli.PDV2()->Geom());
}
else
{
ELISE_ASSERT(false,"Geometrie source non traitee dans le basculement");
}
}
else
{
ELISE_ASSERT(false,"Geometrie destination non traitee dans le basculement");
}
Pt2dr aP0 = mGeomTer.DiscToR2(Pt2di(0,0));
Pt2dr aP1 = mGeomTer.DiscToR2(Pt2di(1,1));
cBasculeMNT aBasc
(
mGeomTer,
aP0,
aP1-aP0,
anOri.OriginePlani(),
anOri.ResolutionPlani(),
aGeomB,
mIsOptimCont,
aDataF,
aDataI,
aSzData
);
Pt2di anOffset;
double aDef = -1e10;
double aSousDef = -9e9;
std::cout << "BEGIN BASCULE \n";
//Im2D_REAL4 aMnt= aBasc.Basculer(anOffset,aP0Sauv,aP1Sauv,aDef);
Im2D_REAL4 aMnt= aBasc.BasculerAndInterpoleInverse(anOffset,aP0Sauv,aP1Sauv,(float)aDef);
ELISE_COPY
(
select(aMnt.all_pts(),aMnt.in() > aSousDef),
(aMnt.in()-anOri.OrigineAlti())/anOri.ResolutionAlti(),
aMnt.out()
);
std::cout << anOffset << " " << aMnt.sz();
std::cout << "END BASCULE \n";
bool isNewFile;
Tiff_Im aFileRes = Tiff_Im::CreateIfNeeded
(
isNewFile,
anOri.NameFileMnt(),
anOri.NombrePixels(),
GenIm::real4,
Tiff_Im::No_Compr,
Tiff_Im::BlackIsZero
);
Tiff_Im * aFileMasq =0;
if ( anOri.NameFileMasque().IsInit())
{
aFileMasq = new Tiff_Im(Tiff_Im::CreateIfNeeded
(
isNewFile,
anOri.NameFileMasque().Val(),
anOri.NombrePixels(),
GenIm::bits1_msbf,
Tiff_Im::No_Compr,
Tiff_Im::BlackIsZero
)
);
}
if (isNewFile)
{
ELISE_COPY
(
aFileRes.all_pts(),
aBR.OutValue().Val(),
aFileRes.out()
);
if (aFileMasq)
{
ELISE_COPY
(
aFileMasq->all_pts(),
0,
aFileMasq->out()
);
}
}
Im2D_REAL4 anOld(aMnt.sz().x,aMnt.sz().y);
ELISE_COPY
(
anOld.all_pts(),
trans(aFileRes.in(aBR.OutValue().Val()),anOffset),
anOld.out()
);
ELISE_COPY
(
select(anOld.all_pts(),aMnt.in()>aSousDef),
aMnt.in(),
anOld.out()
);
ELISE_COPY
(
rectangle(anOffset,anOffset+aMnt.sz()),
trans(anOld.in(),-anOffset),
aFileRes.out()
);
if (aFileMasq)
{
ELISE_COPY
(
rectangle(anOffset,anOffset+aMnt.sz()),
aFileMasq->in(0) || trans(aMnt.in()>aSousDef,-anOffset),
aFileMasq->out()
);
}
delete aFileMasq;
}
int Luc_main_XAlign(int argc,char ** argv)
{
//MMD_InitArgcArgv(argc,argv,3);
std::string aFilePtsIn;
//Reading the arguments
ElInitArgMain
(
argc,argv,
LArgMain() << EAMC(aFilePtsIn,"Input file"),
LArgMain()
);
std::string aFilePtsOut="GCP_xAligned.xml";
std::ifstream file(aFilePtsIn.c_str(), ios::in);
int nbIm;
file >> nbIm;
std::vector<Pt3dr> aVPts(nbIm);
std::vector<Pt3dr> aVInc(nbIm);
std::vector<std::string> aVName(nbIm,"");
for(int i=0 ; i<nbIm ; i++)
{
string name;
file >> aVName[i] >> aVPts[i].x >> aVPts[i].y >> aVPts[i].z >> aVInc[i].x >> aVInc[i].y >> aVInc[i].z;
}
file.close();
//Least Square
// Create L2SysSurResol to solve least square equation with 3 unknown
L2SysSurResol aSys(2);
//For Each SIFT point
double sumX=0, sumY=0;
for(int i=0;i<int(aVPts.size());i++){
double aPds[2]={aVPts[i].x,1};
double poids=1;
aSys.AddEquation(poids,aPds,aVPts[i].y);
sumX=sumX+aVPts[i].x;
sumY=sumY+aVPts[i].y;
}
Pt2dr aRotCenter; aRotCenter.x=sumX/aVPts.size();aRotCenter.y=sumY/aVPts.size();
bool Ok;
Im1D_REAL8 aSol = aSys.GSSR_Solve(&Ok);
double aAngle;
if (Ok)
{
double* aData = aSol.data();
aAngle=atan(aData[0]);
cout<<"Angle = "<<aAngle<<endl<<"Rot Center = "<<aRotCenter<<endl;
for(int i=0;i<int(aVPts.size());i++){
Pt2dr aPt; aPt.x=aVPts[i].x; aPt.y=aVPts[i].y;
aPt=Rot2D(aAngle, aPt, aRotCenter);aVPts[i].x=aPt.x;aVPts[i].y=aPt.y;
}
}
//End Least Square
cDicoAppuisFlottant aDico;
for (int aKP=0 ; aKP<int(aVPts.size()) ; aKP++)
{
cOneAppuisDAF aOAD;
aOAD.Pt() = aVPts[aKP];
aOAD.NamePt() = aVName[aKP];
aOAD.Incertitude() = aVInc[aKP];
aDico.OneAppuisDAF().push_back(aOAD);
}
MakeFileXML(aDico,aFilePtsOut);
return 0;
}
void ConvertOnePolygone
(
Pt3dr aNorm,
std::string aNameIn,
std::string aNameOut,
std::string aNamePoly,
std::string aNameMesure,
bool isPonct,
int aNbRelief,
double * aProfRelief,
double * aRayRelief,
bool isSortant,
bool Permut
)
{
cPolygoneEtal * aPE = cPolygoneEtal::FromName(aNameIn,0);
cPolygoneCalib aPC;
aPC.Name() = aNameMesure;
for
(
cPolygoneEtal::tContCible::const_iterator itC=aPE->ListeCible().begin();
itC != aPE->ListeCible().end();
itC++
)
{
cCibleCalib aCC;
aCC.Id() = (*itC)->Ind() ;
aCC.Position() = (*itC)->Pos();
if (Permut)
{
Pt3dr aP = aCC.Position();
aCC.Position() = Pt3dr(aP.z,aP.x,aP.y);
}
// Defaut , normale sortante IGN
aCC.Normale() = aNorm;
aCC.Ponctuel() = isPonct;
const cMirePolygonEtal & aMire = (*itC)->Mire();
for (int aK=0 ; aK<aMire.NbDiam() ; aK++)
aCC.Rayons().push_back(aMire.KthDiam(aK));
for (int aK=0 ; aK<aNbRelief; aK++)
{
cCercleRelief aCR;
aCR.Rayon() = aRayRelief[aK];
aCR.Profondeur() = aProfRelief[aK];
aCC.CercleRelief().push_back(aCR);
}
aCC.Negatif().SetVal(aMire.IsNegatif());
aCC.ReliefIsSortant() = isSortant;
aCC.NomType() = aMire.Name();
aCC.Qualite() = (*itC)->Qual();
aPC.Cibles().push_back(aCC);
}
if (aNamePoly=="CapriceDesDieux")
{
TraitementSpec_CdD(aPC.Cibles(),Cdd_NumCol);
}
if (aNamePoly=="Clous_CDD")
{
TraitementSpec_CdD(aPC.Cibles(),Clous_NumCol);
}
if (aNamePoly== "Mtd-Hall")
{
TraitementSpecHall(aPC.Cibles());
}
MakeFileXML(aPC,aNameOut);
}
