bool code_file(const char * name,bool coder,std::string * ResNewName=0)
{
std::string aStrName(name);
bool dcdpost = false;
string NewName (name);
if (IsPostfixed(name))
{
dcdpost = (StdPostfix(name)=="dcd");
}
else
{
}
if (coder == dcdpost)
return false;
if (coder)
NewName = name + string(".dcd");
else
NewName = StdPrefix(name);
if (ResNewName) * ResNewName = NewName;
std::string aSauv = DirOfFile(aStrName) + "Dup_" + NameWithoutDir(aStrName) + ".dup";
std::string aCp = "cp " + aStrName + " " + aSauv;
VoidSystem(aCp.c_str());
string MV = string(SYS_MV)+ " \"" + name + string("\" \"") + NewName +string("\"");
INT NbOctet = sizeofile(name);
Elise_File_Im F(name, Pt2di(NbOctet,1),GenIm::u_int1);
Im1D_U_INT1 majic = ImMajic();
ELISE_COPY
(
F.all_pts(),
F.in()^majic.in()[FX%majic.tx()],
F.out()
);
// cout << MV.c_str() << "\n";
VoidSystem(MV.c_str());
ELISE_fp::RmFile(aSauv);
return true;
}
bool NameFilter(const std::string & aSubD,cInterfChantierNameManipulateur * aICNM,const cNameFilter & aFilter,const std::string & aName)
{
std::string anEntete = aICNM->Dir()+ aSubD;
std::string aFullName = anEntete + aName;
int aSz = aFilter.SizeMinFile().Val();
if (aSz>=0)
{
if (sizeofile(aFullName.c_str()) < aSz)
return false;
}
if ((aFilter.Min().IsInit())&&(aFilter.Min().Val()>aName))
return false;
if ((aFilter.Max().IsInit())&&(aFilter.Max().Val()<aName))
return false;
const std::list<Pt2drSubst> & aLFoc = aFilter.FocMm();
if (! aLFoc.empty())
{
if (!IsInIntervalle(aLFoc,GetFocalMmDefined(aFullName),true))
{
return false;
}
}
for
(
std::list<cKeyExistingFile>::const_iterator itKEF=aFilter.KeyExistingFile().begin();
itKEF!=aFilter.KeyExistingFile().end();
itKEF++
)
{
bool OKGlob = itKEF->RequireForAll();
for
(
std::list<std::string>::const_iterator itKA=itKEF->KeyAssoc().begin();
itKA!=itKEF->KeyAssoc().end();
itKA++
)
{
std::string aNameF = anEntete + aICNM->Assoc1To1(*itKA,aName,true);
bool fExists = ELISE_fp::exist_file(aNameF);
// std::cout << "KEY-NF " << aNameF << "\n";
bool Ok = itKEF->RequireExist() ? fExists : (!fExists);
if (itKEF->RequireForAll())
OKGlob = OKGlob && Ok;
else
OKGlob = OKGlob || Ok;
}
//std::cout << "KEY-NF " << aName << " " << OKGlob << "\n";
if (!OKGlob)
return false;
}
if (aFilter.KeyLocalisation().IsInit())
{
const cFilterLocalisation & aKLoc = aFilter.KeyLocalisation().Val();
std::string aNameCam = anEntete + aICNM->Assoc1To1(aKLoc.KeyAssocOrient(),aName,true);
ElCamera * aCam = Cam_Gen_From_File(aNameCam,"OrientationConique",aICNM);
Im2D_Bits<1> * aMasq = GetImRemanenteFromFile<Im2D_Bits<1> > (anEntete+ aKLoc.NameMasq());
TIm2DBits<1> TM(*aMasq);
cFileOriMnt * anOri = RemanentStdGetObjFromFile<cFileOriMnt>
(
anEntete+aKLoc.NameMTDMasq(),
StdGetFileXMLSpec("ParamChantierPhotogram.xml"),
"FileOriMnt",
"FileOriMnt"
);
// std::cout << "ADR MASQ " << aMasq << " " << anOri << "\n";
Pt3dr aPMnt = FromMnt(*anOri,aCam->OrigineProf());
Pt2di aP(round_ni(aPMnt.x),round_ni(aPMnt.y));
return ( TM.get(aP,0)==0 );
}
return true;
}
void cAppliApero::CompileInitPoseGen(bool isPrecComp)
{
// Initialisation des inconnues d'orientation
const tLP & aLP = mParam.PoseCameraInc();
for ( tLP::const_iterator itP = aLP.begin(); itP!=aLP.end() ; itP++)
{
bool isMST = itP->MEP_SPEC_MST().IsInit();
std::list<std::string> aLName;
for
(
std::list<std::string>::const_iterator itPat=itP->PatternName().begin();
itPat!=itP->PatternName().end();
itPat++
)
{
if (itP->ByFile().Val())
{
std::list<std::string> aSet = GetListFromSetSauvInFile(mDC+*itPat);
std::copy(aSet.begin(),aSet.end(),std::back_inserter(aLName));
}
else if (itP->ByKey().Val())
{
const std::vector<string> * aSet = mICNM->Get(*itPat);
std::copy(aSet->begin(),aSet->end(),std::back_inserter(aLName));
}
else if (itP->ByPattern().Val())
{
// std::list<std::string > aLName2Add = RegexListFileMatch(DC()+itP->Directory().Val(),*itPat,1,false);
std::list<std::string > aLName2Add = mICNM->StdGetListOfFile(*itPat,1);
if (aLName2Add.empty())
{
std::cout << "For Pattern=["<< *itPat << "]\n";
ELISE_ASSERT(false,"Aucun match pour ce pattern de nom de pose");
}
std::copy(aLName2Add.begin(),aLName2Add.end(),std::back_inserter(aLName));
}
else
{
aLName.push_back(*itPat);
}
}
if (itP->AutomGetImC().IsInit())
{
const std::string & anId = itP->AutomGetImC().Val();
const cBDD_PtsLiaisons & aBDL = GetBDPtsLiaisonOfId(anId);
ELISE_ASSERT(aBDL.KeySet().size()==1,"AddAllNameConnectedBy multiple_set");
// const std::vector<std::string> * aVNL = ICNM()->Get(aBDL.KeySet()[0]);
const std::string & aKA = aBDL.KeyAssoc()[0];
std::map<std::string,double> mCpt;
for (std::list<std::string>::const_iterator it1 = aLName.begin() ;it1!=aLName.end() ; it1++)
mCpt[*it1] = 0;
for (std::list<std::string>::const_iterator it1 = aLName.begin() ;it1!=aLName.end() ; it1++)
{
std::list<std::string>::const_iterator it2 = it1;
it2++;
for (; it2!=aLName.end() ; it2++)
{
std::string aNamePack = mDC+ICNM()->Assoc1To2(aKA,*it1,*it2,true);
double aNb = sizeofile(aNamePack.c_str());
mCpt[*it1] += aNb;
mCpt[*it2] +=aNb;
}
}
double aBestSc = -1e9;
std::string aBestN;
for (std::map<std::string,double>::iterator it=mCpt.begin();it!=mCpt.end(); it++)
{
if (it->second > aBestSc)
{
aBestSc = it->second;
aBestN = it->first;
}
}
aLName.clear();
aLName.push_back(aBestN);
}
if (itP->AddAllNameConnectedBy().IsInit())
{
cElRegex * aFilter=0;
if (itP->FilterConnecBy().IsInit())
aFilter = new cElRegex(itP->FilterConnecBy().Val(),10);
const std::string & anId = itP->AddAllNameConnectedBy().Val();
const cBDD_PtsLiaisons & aBDL = GetBDPtsLiaisonOfId(anId);
ELISE_ASSERT(aBDL.KeySet().size()==1,"AddAllNameConnectedBy multiple_set");
const std::vector<std::string> * aVNL = ICNM()->Get(aBDL.KeySet()[0]);
const std::string & aKA = aBDL.KeyAssoc()[0];
std::list<std::string> aNewL;
for (int aKL=0;aKL<int(aVNL->size()) ; aKL++)
{
std::pair<std::string,std::string> aPair = ICNM()->Assoc2To1(aKA,(*aVNL)[aKL],false);
const std::string * aNewN=0;
if (BoolFind(aLName,aPair.first))
aNewN = & aPair.second;
if (BoolFind(aLName,aPair.second))
aNewN = & aPair.first;
if ( aNewN
&& (!BoolFind(aNewL,*aNewN))
&& (!BoolFind(aLName,*aNewN))
)
{
if((aFilter==0) || (aFilter->Match(*aNewN)))
{
bool isNew = isPrecComp ?
(! NamePoseIsKnown(*aNewN)) :
( (NamePoseIsKnown(*aNewN))
&& (! PoseFromName(*aNewN)->PreInit())
);
if (isNew)
{
aNewL.push_back(*aNewN);
}
}
}
}
aLName = aNewL;
delete aFilter;
}
if (itP->PatternRefuteur().IsInit())
{
std::list<std::string> aNewL;
for
(
std::list<std::string>::const_iterator itS=aLName.begin();
itS != aLName.end();
itS++
)
{
if (!itP->PatternRefuteur().Val()->Match(*itS))
{
aNewL.push_back(*itS);
}
}
aLName = aNewL;
}
if (itP->AutoRefutDupl().Val())
{
std::list<std::string> aNewL;
for
(
std::list<std::string>::const_iterator itS=aLName.begin();
itS != aLName.end();
itS++
)
{
if (!BoolFind(aNewL,*itS))
{
aNewL.push_back(*itS);
}
}
aLName = aNewL;
}
if (itP->Filter().IsInit())
{
std::list<std::string> aNewL;
const cNameFilter & aNF = itP->Filter().Val();
for
(
std::list<std::string>::const_iterator itS=aLName.begin();
itS != aLName.end();
itS++
)
{
if (NameFilter(mICNM,aNF,*itS))
{
aNewL.push_back(*itS);
}
}
aLName = aNewL;
}
if (itP->ReverseOrderName().Val())
{
aLName.reverse();
}
if (itP->KeyTranscriptionName().IsInit())
{
std::string aKeyTr = itP->KeyTranscriptionName().Val();
std::list<std::string> aNewL;
for
(
std::list<std::string>::const_iterator itS=aLName.begin();
itS != aLName.end();
itS++
)
{
aNewL.push_back(ICNM()->Assoc1To1(aKeyTr,*itS,true));
}
aLName = aNewL;
}
if (isPrecComp)
{
cCompileAOI * aCAOI =
itP->OptimizeAfterInit().IsInit() ?
new cCompileAOI(itP->OptimizeAfterInit().Val()):
0 ;
for
(
std::list<std::string>::const_iterator itS=aLName.begin();
itS != aLName.end();
itS++
)
{
std::string aNameCal = "";
if (itP->CalcNameCalib().IsInit())
{
aNameCal = itP->CalcNameCalib().Val();
if (ICNM()->AssocHasKey(aNameCal))
{
aNameCal = ICNM()->Assoc1To1(aNameCal,*itS,true);
}
}
// Si les calibrations sont geres par le nouveua systeme
if (!itP->CalcNameCalibAux().empty())
{
ELISE_ASSERT(!itP->CalcNameCalib().IsInit(),"Choose CalcNameCalib OR CalcNameCalibAux");
aNameCal = "";
for
(
std::list<cCalcNameCalibAux>::const_iterator itCAux = itP->CalcNameCalibAux().begin();
(itCAux != itP->CalcNameCalibAux().end()) && (aNameCal=="");
itCAux++
)
{
// std::cout << "HHHHHHHHH " << itCAux->CalcNameOnExistingTag().IsInit() << "\n";
if (itCAux->CalcNameOnExistingTag().IsInit())
{
const cCalcNameOnExistingTag & aCal = itCAux->CalcNameOnExistingTag().Val();
std::string aXmlFile = DC() + ICNM()->Assoc1To1(aCal.KeyCalcFileOriExt(),*itS,true);
cElXMLTree aTree (aXmlFile);
bool GotTagE = (aTree.GetOneOrZero(aCal.TagExist()) !=0);
bool GotTagNonE = (aTree.GetOneOrZero(aCal.TagNotExist()) !=0);
// std::cout << "Auux " << aXmlFile << " " << GotTagE << " " << GotTagNonE << "\n";
if (aCal.ExigCohTags().Val())
{
ELISE_ASSERT(GotTagE!=GotTagNonE,"Incoherence in CalcNameOnExistingTag");
}
if (GotTagE && (!GotTagNonE))
{
aNameCal = ICNM()->Assoc1To1(aCal.KeyCalcName(),*itS,true);
}
}
if (itCAux->KeyCalcNameDef().IsInit())
{
aNameCal = ICNM()->Assoc1To1(itCAux->KeyCalcNameDef().Val(),*itS,true);
}
}
ELISE_ASSERT(aNameCal!="","Could not find satisfying CalcNameCalibAux");
}
// std::string aNameCal = MatchAndReplace(anAutom,*itS,itP->CalcNameCalib());
if (DicBoolFind(mDicoPose,*itS))
{
if ( itP->AutoRefutDupl().Val())
{
}
else
{
AssertEntreeDicoVide(mDicoPose,*itS,"Poses");
}
}
else
{
cPoseCam * aPC = cPoseCam::Alloc(*this,*itP,*itS,aNameCal,aCAOI);
mDicoPose[*itS] = aPC;
mVecPose.push_back(aPC);
tGrApero::TSom & aSom = mGr.new_som(aPC);
aPC->SetSom(aSom);
if (! isMST)
aPC->InitCpt();
for
(
std::map<std::string,cLayerImage *>::iterator itLI = mMapLayers.begin();
itLI != mMapLayers.end();
itLI++
)
{
itLI->second->AddLayer(*aPC);
}
}
}
}
else
{
if ( itP->AutoRefutDupl().Val())
{
std::list<std::string> aNewL;
for
(
std::list<std::string>::const_iterator itS=aLName.begin();
itS != aLName.end();
itS++
)
{
cPoseCam * aPC = PoseFromNameSVP(*itS);
if (aPC && ! (aPC->PreInit()))
{
aNewL.push_back(*itS);
}
}
aLName = aNewL;
}
if (isMST) // L'init est faite "a la volee" dans MST
{
ConstructMST(aLName,*itP);
}
else
{
for
(
std::list<std::string>::const_iterator itS=aLName.begin();
itS != aLName.end();
itS++
)
{
cPoseCam * aPC = PoseFromName(*itS);
if (itP->PoseFromLiaisons().IsInit())
{
const std::vector<cLiaisonsInit> & aLI =
itP->PoseFromLiaisons().Val().LiaisonsInit();
for
(
std::vector<cLiaisonsInit>::const_iterator itL=aLI.begin();
itL!=aLI.end();
itL++
)
{
cPoseCam * aPC2 = PoseFromName(aPC->CalNameFromL(*itL));
aPC->UpdateHeriteProf2Init(*aPC2);
}
}
else
{
aPC->Set0Prof2Init();
// La valeur par defaut 0 de Prof2Init va tres bien
}
aPC->DoInitIfNow();
}
}
}
}
}
void cAppliMergeCloud::CreateGrapheConx()
{
mRecouvrTot = mVSoms.size(); // Recouvrement total
// Couple d'homologues
std::string aKSH = "NKS-Set-Homol@@"+ mParam.ExtHom().Val();
std::string aKAH = "NKS-Assoc-CplIm2Hom@@"+ mParam.ExtHom().Val();
std::vector<tMCArc *> aVAddCur;
const cInterfChantierNameManipulateur::tSet * aSetHom = ICNM()->Get(aKSH);
for (int aKH=0 ; aKH<int(aSetHom->size()) ; aKH++)
{
const std::string & aNameFile = (*aSetHom)[aKH];
std::string aFullNF = Dir() + aNameFile;
if (sizeofile(aFullNF.c_str()) > mParam.MinSzFilHom().Val())
{
std::pair<std::string,std::string> aPair = ICNM()->Assoc2To1(aKAH,aNameFile,false);
tMCSom * aS1 = SomOfName(aPair.first);
tMCSom * aS2 = SomOfName(aPair.second);
// if ((aS1!=0) && (aS2!=0) && (sizeofile(aNameFile.c_str())>mParam.MinSzFilHom().Val()))
// MPD : redondant + erreur car pas aFullNF
if ((aS1!=0) && (aS2!=0) )
{
tMCArc * anArc = TestAddNewarc(aS1,aS2);
if (anArc)
aVAddCur.push_back(anArc);
}
}
}
// Ajout recursif des voisin
while (! aVAddCur.empty())
{
std::cout << "ADD " << aVAddCur.size() << "\n";
std::vector<tMCArc *> aVAddNew;
for (int aK=0 ; aK<int(aVAddCur.size()) ; aK++)
{
tMCArc & anArc = *(aVAddCur[aK]);
AddVoisVois(aVAddNew,anArc.s1(),anArc.s2());
AddVoisVois(aVAddNew,anArc.s2(),anArc.s1());
}
aVAddCur = aVAddNew;
}
// Calcul des voisins proches (contenu dans Apero ChImSec)
for (int aK=0 ; aK<int(mVSoms.size()) ; aK++)
{
tMCSom * aS1 = mVSoms[aK];
const cOneSolImageSec * aSol = aS1->attr()->SolOfCostPerIm(mParam.CostPerImISOM().Val());
if (aSol)
{
for
(
std::list<std::string>::const_iterator itS=aSol->Images().begin();
itS !=aSol->Images().end();
itS++
)
{
tMCSom * aS2 = SomOfName(*itS);
if (aS2)
{
tMCArc * anArc = mGr.arc_s1s2(*aS1,*aS2);
if (anArc)
{
// anArc->sym_flag_set_kth_true(mFlagCloseN);
anArc->flag_set_kth_true(mFlagCloseN);
aS1->attr()->AddCloseVois(aS2->attr());
}
// std::cout << "AAAaA :" << anArc << "\n";
}
}
}
}
// Na pas effacer, permet de voir le graphe des close image en cas de doute
if (1)
{
for (int aK=0 ; aK<int(mVSoms.size()) ; aK++)
{
tMCSom * aS1 = mVSoms[aK];
std::cout << aS1->attr()->IMM()->mNameIm
<< " All: " << aS1->nb_succ(mSubGrAll)
<< " Closed: " << aS1->nb_succ(mSubGrCloseN) ;
std::cout << " ";
for (tArcIter itA = aS1->begin(mSubGrCloseN) ; itA.go_on() ; itA++)
{
const std::string & aN2 = (*itA).s2().attr()->IMM()->mNameIm;
std::cout << ExtractDigit(StdPrefixGen(aN2),"0000") << " ";
}
std::cout << "\n";
}
}
mRecMoy = mRecouvrTot / mVSoms.size();
mNbImMoy = mVSoms.size() / mRecMoy; // En Fait NbIm^2 /mRecouvrTot
std::cout << "REC TOT " << mRecouvrTot << " RMoy " << mRecMoy << " NbIm " << mNbImMoy << "\n";
}
