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;
}
void cImage_LumRas::CalculShadeByDiff()
{
mImShade.Resize(mAppli.mImGr.sz());
std::string aNameOut = mDir+ "LumRas_"+StdPrefix(mName) + ".tif";
Tiff_Im TifTest
(
aNameOut.c_str(),
mIm.sz(),
// GenIm::u_int1,
GenIm::real4,
Tiff_Im::No_Compr,
Tiff_Im::BlackIsZero
);
Fonc_Num aFRas = FLoc(6,50,mIm);
Fonc_Num aFStd = FLoc(6,50,mAppli.mImGr);
Tiff_Im::Create8BFromFonc("Test-Ras.tif",mIm.sz(),aFRas*100);
Tiff_Im::Create8BFromFonc("Test-Std.tif",mIm.sz(),aFStd*100);
// Fonc_Num cImage_LumRas::FLoc(int aNbIter,int aSzW,Fonc_Num aF)
ELISE_COPY(mImShade.all_pts(),(aFRas-aFStd),mImShade.out());
ELISE_COPY
(
TifTest.all_pts(),
// Max(0,Min(255,128 * (1 + 2*mImShade.in()))),
mImShade.in(),
TifTest.out()
);
}
int DigitalGlobe2Grid_main(int argc, char **argv)
{
std::string aNameFile; // .RPB file from Digital Globe
std::string inputSyst = "+proj=longlat +datum=WGS84 "; //input syst proj4
std::string targetSyst;//output syst proj4
std::string refineCoef="";
bool binaire = true;
double altiMin, altiMax;
int nbLayers;
double stepPixel = 100.f;
double stepCarto = 50.f;
ElInitArgMain
(
argc, argv,
LArgMain() << EAMC(aNameFile, "RPB from DigitalGlobe file")
<< EAMC(altiMin, "min altitude (ellipsoidal)")
<< EAMC(altiMax, "max altitude (ellipsoidal)")
<< EAMC(nbLayers, "number of layers (min 4)")
<< EAMC(targetSyst, "targetSyst - target system in Proj4 format (ex : \"+proj=utm +zone=32 +north +datum=WGS84 +units=m +no_defs\""),
LArgMain()
//caracteristique du systeme geodesique saisies sans espace (+proj=utm +zone=10 +north +datum=WGS84...)
<< EAM(stepPixel, "stepPixel", true, "Step in pixel (Def=100pix)")
<< EAM(stepCarto, "stepCarto", true, "Step in m (carto) (Def=50m)")
<< EAM(refineCoef, "refineCoef", true, "File of Coef to refine Grid")
<< EAM(binaire, "Bin", true, "Export Grid in binaries (Def=True)")
);
//Reading Inverse RPC, computing Direct RPC and setting up RPC object
RPC aRPC;
aRPC.ReadRPB(aNameFile);
cout << "RPB File read" << endl;
//Generating a 50*50*50 grid on the normalized space with random normalized heights
Pt3di aGridSz(50, 50, 50);
vector<Pt3dr> aGridGeoNorm = aRPC.GenerateNormGrid(aGridSz);//50 is the size of grid for generated GCPs (50*50)
//Converting the points to image space
vector<Pt3dr> aGridImNorm;
for (u_int i = 0; i < aGridGeoNorm.size(); i++)
{
aGridImNorm.push_back(aRPC.InverseRPCNorm(aGridGeoNorm[i]));
}
aRPC.GCP2Direct(aGridGeoNorm, aGridImNorm);
cout << "Direct RPC estimated" << endl;
aRPC.ReconstructValidity();
aRPC.info();
//Computing Grid
std::string aNameIm = StdPrefix(aNameFile) + ".TIF";
aRPC.RPC2Grid(nbLayers, altiMin, altiMax, refineCoef, aNameIm, stepPixel, stepCarto, targetSyst, inputSyst, binaire);
return EXIT_SUCCESS;
}
void PartitionRenato(int argc,char** argv)
{
std::string aName;
double aPropSzW=0.1,aSeuil=75;
double aPropExag = 0.1;
int aNbIter = 3;
ElInitArgMain
(
argc,argv,
LArgMain() << EAMC(aName,"Name Input"),
LArgMain() << EAM(aPropSzW,"PropSzW",true,"Prop Size of W, def =0.1")
<< EAM(aSeuil,"Seuil",true,"Threshold beetween Black & White, Def=75")
);
Tiff_Im aTIn = Tiff_Im::UnivConvStd(aName);
Pt2di aSz = aTIn.sz();
int aSzW = round_ni((euclid(aSz)*aPropSzW) / sqrt(aNbIter));
Im2D_REAL4 anIm0(aSz.x,aSz.y);
Im2D_REAL4 anIm1(aSz.x,aSz.y);
Im2D_U_INT1 aImInside(aSz.x,aSz.y,1);
ELISE_COPY(anIm0.all_pts(),255-aTIn.in(),anIm0.out());
int aNbF = 3;
for (int aKF=0 ; aKF<aNbF ; aKF++)
{
Im2D_REAL4 anImFond(aSz.x,aSz.y);
Fonc_Num aFIn = anIm0.in(0);
for (int aK=0 ; aK<aNbIter ; aK++)
aFIn = (rect_som(aFIn,aSzW)*aImInside.in(0)) / Max(1.0,rect_som(aImInside.in(0),aSzW));
ELISE_COPY(anImFond.all_pts(),aFIn,anImFond.out());
if (aKF == (aNbF-1))
{
Fonc_Num aF = anIm0.in()-anImFond.in();
aF = aF / aSeuil;
aF = (aF -0.1) / (1-2*aPropExag);
aF = Max(0.0,Min(1.0,aF));
ELISE_COPY(anIm1.all_pts(),255.0 *(1-aF),anIm1.out());
}
else
{
ELISE_COPY
(
aImInside.all_pts(),
anIm0.in() < anImFond.in()+aSeuil,
aImInside.out()
);
}
}
Tiff_Im::Create8BFromFonc(std::string("Bin-")+StdPrefix(aName)+".tif",aTIn.sz(),anIm1.in());
}
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
);
}
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;
}
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",
""
);
}
void AutoCorrel(const std::string & aName)
{
Tiff_Im aTF(aName.c_str());
Pt2di aSz = aTF.sz();
Im2D_REAL4 anI(aSz.x,aSz.y);
ELISE_COPY(aTF.all_pts(),aTF.in(),anI.out());
int aNb = 2;
Fonc_Num aF = 1.0;
for (int aK=0 ; aK<4 ; aK++)
{
aF = Min(aF,Correl(anI.in(0),trans(anI.in(0),TAB_4_NEIGH[aK])*(aNb*2),aNb));
}
Tiff_Im::Create8BFromFonc
(
StdPrefix(aName)+"_AutoCor.tif",
aSz,
Min(255,Max(0,(1+aF)*128))
);
}
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;
}
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;
}
cTmpReechEpip::cTmpReechEpip
(
bool aConsChan,
const std::string & aNameOri,
Box2dr aBoxImIn,
ElDistortion22_Gen * anEpi,
Box2dr aBox,
double aStep,
const std::string & aNameOut,
const std::string & aPostMasq,
int aNumKer ,
bool Debug
) :
mBoxImIn(aBoxImIn),
mEpi (anEpi),
mStep (aStep),
mP0 (aBox._p0),
mSzEpi (aBox.sz()),
mSzRed (round_up (aBox.sz() / aStep) + Pt2di(1,1)),
mRedIMasq (mSzRed.x,mSzRed.y,0),
mRedTMasq (mRedIMasq),
mRedImX (mSzRed.x,mSzRed.y),
mRedTImX (mRedImX),
mRedImY (mSzRed.x,mSzRed.y),
mRedTImY (mRedImY)
{
cInterpolateurIm2D<REAL4> * aPtrSCI = 0;
if (aNumKer==0)
{
aPtrSCI = new cInterpolBilineaire<REAL4>;
}
else
{
cKernelInterpol1D * aKer = 0;
if (aNumKer==1)
aKer = new cCubicInterpKernel(-0.5);
else
aKer = new cSinCardApodInterpol1D(cSinCardApodInterpol1D::eTukeyApod,aNumKer,aNumKer/2,1e-4,false);
aPtrSCI = new cTabIM2D_FromIm2D<REAL4> (aKer,1000,false);
// cTabIM2D_FromIm2D<REAL4> aSSCI (&aKer,1000,false);
}
cInterpolateurIm2D<REAL4> & aSCI = *aPtrSCI;
Pt2di aPInd;
for (aPInd.x=0 ; aPInd.x<mSzRed.x ; aPInd.x++)
{
for (aPInd.y=0 ; aPInd.y<mSzRed.y ; aPInd.y++)
{
bool Ok= false;
Pt2dr aPEpi = ToFullEpiCoord(aPInd);
Pt2dr aPIm = anEpi->Inverse(aPEpi);
if ((aPIm.x>mBoxImIn._p0.x) && (aPIm.y>mBoxImIn._p0.y) && (aPIm.x<mBoxImIn._p1.x) && (aPIm.y<mBoxImIn._p1.y))
{
Pt2dr aPEpi2 = anEpi->Direct(aPIm);
if (euclid(aPEpi-aPEpi2) < 1e-2)
{
Ok= true;
mRedTMasq.oset(aPInd,Ok);
}
}
mRedTImX.oset(aPInd,aPIm.x);
mRedTImY.oset(aPInd,aPIm.y);
}
}
ELISE_COPY(mRedIMasq.all_pts(),dilat_d8(mRedIMasq.in(0),4),mRedIMasq.out());
Tiff_Im aTifOri = Tiff_Im::StdConvGen(aNameOri.c_str(),aConsChan ? -1 :1 ,true);
Tiff_Im aTifEpi = Debug ?
Tiff_Im(aNameOut.c_str()) :
Tiff_Im
(
aNameOut.c_str(),
mSzEpi,
aTifOri.type_el(),
Tiff_Im::No_Compr,
aTifOri.phot_interp()
) ;
Tiff_Im aTifMasq = aTifEpi;
bool ExportMasq = (aPostMasq!="NONE");
// std::cout << "POSTMAS " << aPostMasq << "\n";
if (ExportMasq)
{
std::string aNameMasq = StdPrefix(aNameOut)+ aPostMasq +".tif";
aTifMasq = Debug ?
Tiff_Im(aNameMasq.c_str()) :
Tiff_Im
(
aNameMasq.c_str(),
mSzEpi,
GenIm::bits1_msbf,
Tiff_Im::No_Compr,
Tiff_Im::BlackIsZero
) ;
}
int aNbBloc=2000;
int aBrd = aNumKer+10;
Pt2di aSzBrd(aBrd,aBrd);
int aX00 = 0;
int aY00 = 0;
for (int aX0=aX00 ; aX0<mSzEpi.x ; aX0+=aNbBloc)
{
int aX1 = ElMin(aX0+aNbBloc,mSzEpi.x);
for (int aY0=aY00 ; aY0<mSzEpi.y ; aY0+=aNbBloc)
{
// std::cout << "X0Y0 " << aX0 << " " << aY0 << "\n";
int aY1 = ElMin(aY0+aNbBloc,mSzEpi.y);
Pt2di aP0Epi(aX0,aY0);
Pt2di aSzBloc(aX1-aX0,aY1-aY0);
TIm2D<REAL4,REAL8> aTImX(aSzBloc);
TIm2D<REAL4,REAL8> aTImY(aSzBloc);
TIm2DBits<1> aTImMasq(aSzBloc,0);
Pt2dr aInfIm(1e20,1e20);
Pt2dr aSupIm(-1e20,-1e20);
bool NonVide= false;
for (int anX =aX0 ; anX<aX1 ; anX++)
{
for (int anY =aY0 ; anY<aY1 ; anY++)
{
Pt2dr aIndEpi (anX/mStep , anY/mStep);
Pt2di aPIndLoc (anX-aX0,anY-aY0);
if (mRedTMasq.get(round_down(aIndEpi)))
{
double aXIm = mRedTImX.getr(aIndEpi,-1,true);
double aYIm = mRedTImY.getr(aIndEpi,-1,true);
if ((aXIm>0) && (aYIm>0))
{
// aTImMasq.oset(aPIndLoc,1);
aTImX.oset(aPIndLoc,aXIm);
aTImY.oset(aPIndLoc,aYIm);
aInfIm = Inf(aInfIm,Pt2dr(aXIm,aYIm));
aSupIm = Sup(aSupIm,Pt2dr(aXIm,aYIm));
NonVide= true;
}
}
}
}
Pt2di aP0BoxIm = Sup(Pt2di(0,0),Pt2di(round_down(aInfIm) - aSzBrd));
Pt2di aP1BoxIm = Inf(aTifOri.sz(),Pt2di(round_down(aSupIm) + aSzBrd));
Pt2di aSzIm = aP1BoxIm - aP0BoxIm;
NonVide = NonVide && (aSzIm.x>0) && (aSzIm.y>0);
if (NonVide)
{
// std::vector<Im2D_REAL4> aVIm;
std::vector<Im2D_REAL4> aVIm= aTifOri.VecOfImFloat(aSzIm);
ELISE_COPY
(
rectangle(Pt2di(0,0),aSzIm),
trans(aTifOri.in(),aP0BoxIm),
StdOut(aVIm)
);
std::vector<Im2D_REAL4> aVImEpi = aTifEpi.VecOfImFloat(aSzBloc);
ELISE_ASSERT(aVImEpi.size()==aVIm.size(),"Incohe in nb chan, cTmpReechEpip::cTmpReechEpip");
for (int aKIm=0 ; aKIm <int(aVImEpi.size()) ; aKIm++)
{
TIm2D<REAL4,REAL8> aImEpi(aVImEpi[aKIm]);
REAL4 ** aDataOri = aVIm[aKIm].data();
for (int anX =0 ; anX<aSzBloc.x ; anX++)
{
for (int anY =0 ; anY<aSzBloc.y ; anY++)
{
Pt2di aIndEpi(anX,anY);
aImEpi.oset(aIndEpi,0);
Pt2di anIndEpiGlob = aIndEpi + aP0Epi;
Pt2dr aIndEpiRed (anIndEpiGlob.x/mStep , anIndEpiGlob.y/mStep);
if (mRedTMasq.get(round_down(aIndEpiRed),0))
{
double aXIm = mRedTImX.getr(aIndEpiRed,-1,true);
double aYIm = mRedTImY.getr(aIndEpiRed,-1,true);
Pt2dr aPImLoc = Pt2dr(aXIm,aYIm) - Pt2dr(aP0BoxIm);
double aV= 128;
if ((aPImLoc.x>aNumKer+2) && (aPImLoc.y>aNumKer+2) && (aPImLoc.x<aSzIm.x-aNumKer-3) && (aPImLoc.y<aSzIm.y-aNumKer-3))
{
aTImMasq.oset(aIndEpi,1);
aV = aSCI.GetVal(aDataOri,aPImLoc);
// aV= 255;
}
aImEpi.oset(aIndEpi,aV);
}
}
}
}
ELISE_COPY
(
rectangle(aP0Epi,aP0Epi+aSzBloc),
Tronque(aTifEpi.type_el(),trans(StdInput(aVImEpi),-aP0Epi)),
aTifEpi.out()
);
}
if (ExportMasq)
{
ELISE_COPY
(
rectangle(aP0Epi,aP0Epi+aSzBloc),
trans(aTImMasq._the_im.in(0),-aP0Epi),
aTifMasq.out()
);
}
// std::cout << "ReechDONE " << aX0 << " "<< aY0 << "\n";
}
}
}
cElNuageLaser::cElNuageLaser
(
const std::string & aNameFile,
const char * aNameOri,
const char * aNameGeomCible ,
const char * aNameGeomInit
) :
mVPts (),
mQt (0)
{
std::string aNameBin = StdPrefix(aNameFile) + ".tif";
if (! ELISE_fp::exist_file(aNameBin))
{
INT aNb = 3;
FILE * aFP = ElFopen(aNameFile.c_str(),"r");
ELISE_ASSERT(aFP!=0,"Cannot Open File for Laser Data");
char Buf[10000];
INT aCpt =0;
while (aNb>=3)
{
aNb=0;
char * got = fgets(Buf,10000,aFP);
Pt3dr aP;
if (got)
{
aNb = sscanf(Buf,"%lf %lf %lf",&aP.x,&aP.y,&aP.z);
}
if (aNb>=3)
mVPts.push_back(aP);
aCpt++;
}
INT aNbPts = (INT) mVPts.size();
Im2D_REAL8 aImPts(aNbPts,3);
REAL ** aData = aImPts.data();
for (INT aK=0 ; aK<aNbPts ; aK++)
{
Pt3dr aP = mVPts[aK];
aData[0][aK] = aP.x;
aData[1][aK] = aP.y;
aData[2][aK] = aP.z;
}
Tiff_Im aFile
(
aNameBin.c_str(),
Pt2di(aNbPts,3),
GenIm::real8,
Tiff_Im::No_Compr,
Tiff_Im::BlackIsZero,
Tiff_Im::Empty_ARG
+ Arg_Tiff(Tiff_Im::ANoStrip())
);
ELISE_COPY(aImPts.all_pts(),aImPts.in(),aFile.out());
}
else
{
Tiff_Im aFile(aNameBin.c_str());
Pt2di aSz = aFile.sz();
Im2D_REAL8 aImPts(aSz.x,aSz.y);
ELISE_COPY(aImPts.all_pts(),aFile.in(),aImPts.out());
REAL ** aD = aImPts.data();
mVPts.reserve(aSz.x);
for (INT aK=0 ; aK<aSz.x ; aK++)
{
Pt3dr aP(aD[0][aK],aD[1][aK],aD[2][aK]);
mVPts.push_back(aP);
}
}
Ori3D_Std * aOri = 0;
eModeConvGeom aMode = eConvId;
if (aNameOri)
{
if (!strcmp(aNameGeomInit,"GeomCarto"))
{
if (!strcmp(aNameGeomCible,"GeomCarto"))
{
aMode = eConvId;
}
else if (!strcmp(aNameGeomCible,"GeomTerrain"))
{
aMode = eConvCarto2Terr;
}
else if (!strcmp(aNameGeomCible,"GeomTerIm1"))
{
aMode = eConvCarto2TerIm;
}
else
{
ELISE_ASSERT(false,"Bad GeomCible in cElNuageLaser::cElNuageLaser");
}
}
else
{
ELISE_ASSERT(false,"Bad GeomInit in cElNuageLaser::cElNuageLaser");
}
if (aMode != eConvId)
aOri = new Ori3D_Std (aNameOri) ;
}
for (INT aK=0 ; aK<INT( mVPts.size()); aK++)
{
Pt3dr aP = mVPts[aK];
if (aOri)
{
if (aMode == eConvCarto2Terr)
aP = aOri->carte_to_terr(aP);
else if (aMode == eConvCarto2TerIm)
{
aP = aOri->carte_to_terr(aP);
Pt2dr aP2 = aOri->to_photo(aP);
aP.x = aP2.x;
aP.y = aP2.y;
}
mVPts[aK] = aP;
}
REAL aZ = aP.z;
Pt2dr aP2 (aP.x,aP.y);
if (aK==0)
{
mZMax = mZMin = aZ;
mPInf =mPSup = aP2;
}
ElSetMin(mZMin,aZ);
ElSetMax(mZMax,aZ);
mPInf.SetInf(aP2);
mPSup.SetSup(aP2);
}
delete aOri;
}
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;
}
int Aster2Grid_main(int argc, char ** argv)
{
//GET PSEUDO-RPC2D FOR ASTER FROM LATTICE POINTS
std::string aAsterMetaDataXML;
//std::string aTxtImage, aTxtLong, aTxtLat, aTxtSatPos, aNameIm;
std::string inputSyst = "+proj=longlat +datum=WGS84 "; //input syst proj4
std::string targetSyst;//output syst proj4
std::string refineCoef = "";
bool binaire = true;
bool expGrid = true;
bool expDIMAP = false;
int nbLayers;
double aHMin = 0, aHMax = 3000;
double stepPixel = 100.f;
double stepCarto = 1500.f;//equals to 100*image resolution in m
//Object being worked on
RPC aRPC;
//Reading the arguments
ElInitArgMain
(
argc, argv,
LArgMain()
<< EAMC(aAsterMetaDataXML, "XML file conatining the meta data", eSAM_IsPatFile)
<< EAMC(nbLayers, "number of layers (min 4)")
<< EAMC(targetSyst, "targetSyst - target system in Proj4 format (ex : \"+proj=utm +zone=32 +north +datum=WGS84 +units=m +no_defs\""),
LArgMain()
<< EAM(aHMin, "HMin", true, "Min elipsoid height of scene (Def=0)")
<< EAM(aHMax, "HMax", true, "Max elipsoid height of scene (Def=3000)")
<< EAM(stepPixel, "stepPixel", true, "Step in pixel (Def=100pix)")
<< EAM(stepCarto, "stepCarto", true, "Step in m (carto) (Def=1500m, GSD*100)")
<< EAM(refineCoef, "refineCoef", true, "File of Coef to refine Grid")
<< EAM(expGrid, "expGrid", true, "Export Grid (Def=True)")
<< EAM(binaire, "Bin", true, "Convert Grid to binary format (Def=True)")
<< EAM(expDIMAP, "expDIMAP", true, "Export RPC file in DIMAP format (Def=False)")
);
//Read from AsterMetaDataXML
////TODO : READ THIS FROM HDF
aRPC.AsterMetaDataXML(aAsterMetaDataXML);
std::string aNameIm=StdPrefix(aAsterMetaDataXML) + ".tif";
/*OLD : from multiple txt files*/
/*
//Reading files
vector<vector<Pt2dr> > aMatPtsIm = ReadLatticeIm(aTxtImage);// cout << aMatPtsIm << endl;
vector<vector<Pt3dr> > aMatPtsECEF = ReadLatticeGeo(aTxtLong, aTxtLat);// cout << aMatPtsGeo << endl;
vector<vector<Pt3dr> > aMatSatPos = ReadSatPos(aTxtSatPos);
////END TODO
*/
//Find Validity and normalization values
aRPC.ComputeNormFactors(aHMin, aHMax);
cout << "Normalization factors computed" << endl;
//Generate 2 vectors :
//1 - vectorized nbLayers grids in lon lat z
//2 - associated image coordinates
vector<vector<Pt3dr> > aGridNorm = aRPC.GenerateNormLineOfSightGrid(nbLayers, aHMin, aHMax);
//Compute Direct and Inverse RPC
//Method 1 : Using the same grid for direct and inverse
aRPC.GCP2Direct(aGridNorm[0], aGridNorm[1]);
cout << "Direct RPC estimated" << endl;
aRPC.GCP2Inverse(aGridNorm[0], aGridNorm[1]);
cout << "Inverse RPC estimated" << endl;
/*Method 2 : Using a new generated grid from Direct to get inverse
aRPC.GCP2Direct(aGridNorm[0], aGridNorm[1]);
cout << "Direct RPC estimated" << endl;
//Generating a 50*50*50 grid on the normalized space with random normalized heights
Pt3di aGridSz(50, 50, 50);
vector<Pt3dr> aGridImNorm = aRPC.GenerateNormGrid(aGridSz);//50 is the size of grid for generated GCPs (50*50)
//Converting the points to image space
vector<Pt3dr> aGridGeoNorm;
for (u_int i = 0; i < aGridImNorm.size(); i++)
{
aGridGeoNorm.push_back(aRPC.DirectRPCNorm(aGridImNorm[i]));
}
aRPC.GCP2Inverse(aGridGeoNorm, aGridImNorm);
cout << "Inverse RPC estimated" << endl;*/
/*Method 3 : Using a new generated grid from Direct to get inverse
aRPC.GCP2Inverse(aGridNorm[0], aGridNorm[1]);
cout << "Inverse RPC estimated" << endl;
//Generating a 50*50*50 grid on the normalized space with random normalized heights
Pt3di aGridSz(50, 50, 50);
vector<Pt3dr> aGridGeoNorm = aRPC.GenerateNormGrid(aGridSz);//50 is the size of grid for generated GCPs (50*50)
//Converting the points to image space
vector<Pt3dr> aGridImNorm;
for (u_int i = 0; i < aGridGeoNorm.size(); i++)
{
aGridImNorm.push_back(aRPC.InverseRPCNorm(aGridGeoNorm[i]));
}
aRPC.GCP2Direct(aGridGeoNorm, aGridImNorm);
cout << "Direct RPC estimated" << endl;*/
aRPC.info();
//Export RPC
if (expDIMAP == true)
{
std::string aNameDIMAP = "RPC_" + StdPrefix(aAsterMetaDataXML) + ".xml";
aRPC.WriteAirbusRPC(aNameDIMAP);
cout << "RPC exported in DIMAP format as : " << aNameDIMAP << endl;
}
//Computing Grid
if (expGrid == true)
aRPC.RPC2Grid(nbLayers, aHMin, aHMax, refineCoef, aNameIm, stepPixel, stepCarto, targetSyst, inputSyst, binaire);
/*OLD METHOD*/
/*
////TODO : READ THIS FROM HDF
//Reading files
vector<vector<Pt2dr> > aMatPtsIm = ReadLatticeIm(aTxtImage);// cout << aMatPtsIm << endl;
vector<vector<Pt3dr> > aMatPtsECEF = ReadLatticeGeo_OLD(aTxtLong, aTxtLat);// cout << aMatPtsGeo << endl;
vector<vector<Pt3dr> > aMatSatPos = ReadSatPos(aTxtSatPos);
////END TODO
RPC2D aRPC2D;
RPC aRPC3D;
cout << "Computing RPC2D" << endl;
aRPC2D.ComputeRPC2D(aMatPtsIm, aMatPtsGeo, aHMax, aHMin);
aRPC2D.info();
////Test
//Pt3dr aPtTest3(-150.9131, 63.3609, 683);
//Pt2dr aPtDir3 = aRPC2D.InverseRPC2D(aPtTest3, 0, 0);
//cout << "Canyon = " << aPtDir3 << endl;
//Pt3dr aPtTest2(-150.5422, 63.1457, 3311);
//Pt2dr aPtDir2 = aRPC2D.InverseRPC2D(aPtTest2, 0, 0);
//cout << "East mountain = " << aPtDir2 << endl;
//Pt3dr aPtTest(-151.0321, 63.2009, 2097);
//Pt2dr aPtDir = aRPC2D.InverseRPC2D(aPtTest, 0, 0);
//cout << "West mountain = " << aPtDir << endl;
//Pt3dr aPtTest4(aMatPtsGeo[3][3].x, aMatPtsGeo[3][3].y, 0);
//Pt2dr aPtDir4 = aRPC2D.InverseRPC2D(aPtTest4, 0, 0);
//cout << "Lattice (3,3) Geo : " << setprecision(15) << aMatPtsGeo[3][3] << endl;
//cout << "Lattice (3,3) Ima : " << aMatPtsIm[3][3] << endl;
//cout << "LatticePT33 = " << aPtDir4 << endl;
//aPtTest.x = (aPtTest.x - aRPC2D.long_off) / aRPC2D.long_scale;
//aPtTest.y = (aPtTest.y - aRPC2D.lat_off) / aRPC2D.lat_scale;
//aPtTest.z = (aPtTest.z - aRPC2D.height_off) / aRPC2D.height_scale;
//Pt3dr aPt = aRPC2D.InversePreRPCNorm(aPtTest, aMatPtsGeo, aMatSatPos);
//cout << aPt << endl;
//Creating a folder for intemediate files
ELISE_fp::MkDirSvp("processing");
//Generate ramdom points in geodetic
cout << "Generating ramdom points in normalized geodetic coordinates" << endl;
vector<Pt3dr> aVectGeoNorm = aRPC3D.GenerateRandNormGrid(49);
//Filtering points out of image
cout << "Generated points : " << aVectGeoNorm.size() << endl;
aVectGeoNorm = aRPC2D.filterOutOfBound(aVectGeoNorm, aMatPtsGeo);
cout << "Filtered points : " << aVectGeoNorm.size() << endl;
//Compute their image coord with pre-RPC method
cout << "Converting points points in normalized image coordinates" << endl;
vector<Pt3dr> aVectImNorm;
for (u_int i = 0; i < aVectGeoNorm.size(); i++)
{
Pt3dr aPt = aRPC2D.InversePreRPCNorm(aVectGeoNorm[i], aMatPtsGeo, aMatSatPos);
//cout << "Original point : " << aGridGeoNorm[i] << endl;
//cout << "Inverted point : " << aPt << endl;
aVectImNorm.push_back(aPt);
}
//cout << aVectGeoNorm << endl;
//cout << aVectImNorm << endl;
//Compute Direct and Inverse RPC
aRPC3D.Validity2Dto3D(aRPC2D);
aRPC3D.GCP2Direct(aVectGeoNorm, aVectImNorm);
cout << "Direct RPC estimated" << endl;
aRPC3D.GCP2Inverse(aVectGeoNorm, aVectImNorm);
cout << "Inverse RPC estimated" << endl;
aRPC3D.info();
////Testing the reconstructed RPC
//Pt3dr aPtTestGeo(aMatPtsGeo[3][3].x, aMatPtsGeo[3][3].y, 0);
//Pt3dr aPtTestIma(aMatPtsIm[3][3].x, aMatPtsIm[3][3].y, 0);
////cout << "Point Test Geo : " << aPtTest4 << endl;
//double noRefine[] = { 0, 1, 0, 0, 0, 1 };
//vector<double> vRefineCoef;
//for (int i = 0; i<6; i++)
//{
// vRefineCoef.push_back(noRefine[i]);
//}
//Pt3dr aPtInverse3D = aRPC3D.InverseRPC(aPtTestGeo, vRefineCoef);
//Pt3dr aPtDirect3D = aRPC3D.DirectRPC(aPtTestIma);
//Pt2dr aPtInverse2D = aRPC2D.InverseRPC2D(aPtTestGeo, 0, 0);
//cout << "Lattice (3,3) Geo = " << setprecision(15) << aMatPtsGeo[3][3] << endl;
//cout << "LatticePT33 RPC2D = " << aPtInverse2D << endl;
//cout << "LatticePT33 Inverse RPC3D = " << aPtInverse3D << endl;
//cout << "Lattice (3,3) Ima = " << aMatPtsIm[3][3] << endl;
//cout << "LatticePT33 Direct RPC3D = " << aPtDirect3D << endl;
//Pt3dr aPtTest1(-150.9131, 63.3609, 0);// 683);//Canyon
//Pt2dr aPtInverse2D1 = aRPC2D.InverseRPC2D(aPtTest1, 0, 0);
////Pt3dr aPtInverse2D3D1 = aRPC2D.InversePreRPCNorm(aPtTest1, aMatPtsGeo, aMatSatPos);
//Pt3dr aPtInverse3D1 = aRPC3D.InverseRPC(aPtTest1, vRefineCoef);
//Pt3dr aPtTest2(-150.5422, 63.1457, 0);// 3311);//East Mountain
//Pt2dr aPtInverse2D2 = aRPC2D.InverseRPC2D(aPtTest2, 0, 0);
////Pt3dr aPtInverse2D3D2 = aRPC2D.InversePreRPCNorm(aPtTest2, aMatPtsGeo, aMatSatPos);
//Pt3dr aPtInverse3D2 = aRPC3D.InverseRPC(aPtTest2, vRefineCoef);
//Pt3dr aPtTest3(-151.0321, 63.2009, 0);//, 2097);//West Mountain
//Pt3dr aPtTest31(-151.0321, 63.2009, 2097);//West Mountain 3D
//Pt3dr aPtTest3i(2090.5, 2856.1, 2097);//West Mountain Im
//Pt2dr aPtInverse2D3 = aRPC2D.InverseRPC2D(aPtTest3, 0, 0);
////Pt3dr aPtInverse2D3D3 = aRPC2D.InversePreRPCNorm(aPtTest3, aMatPtsGeo, aMatSatPos);
//Pt3dr aPtInverse3D3 = aRPC3D.InverseRPC(aPtTest3, vRefineCoef);
//Pt3dr aPtInverse3D31 = aRPC3D.InverseRPC(aPtTest31, vRefineCoef);
//Pt3dr aPtDirect3D31 = aRPC3D.DirectRPC(aPtTest3i);
//Pt3dr aPtInverse3D312 = aRPC3D.InverseRPC(aPtDirect3D31, vRefineCoef);
//cout << "Canyon Geo = " << aPtTest1 << endl;
//cout << "Canyon Ima = " << "[2111.3,1654.99]" << endl;
//cout << "Canyon RPC2D = " << aPtInverse2D1 << endl;
////cout << "Canyon RPC2D3D = " << aPtInverse2D3D1 << endl;
//cout << "Canyon RPC3D = " << aPtInverse3D1 << endl;
//cout << "East mountain Geo = " << aPtTest2 << endl;
//cout << "East mountain Ima = " << "[3719.5,2605.6]" << endl;
//cout << "East mountain RPC2D = " << aPtInverse2D2 << endl;
////cout << "East mountain RPC2D3D= " << aPtInverse2D3D2 << endl;
//cout << "East mountain RPC3D = " << aPtInverse3D2 << endl;
//cout << "West mountain Geo = " << aPtTest3 << endl;
//cout << "West mountain Ima = " << "[2090.5,2856.1]" << endl;
//cout << "West mountain RPC2D = " << aPtInverse2D3 << endl;
////cout << "West mountain RPC2D3D= " << aPtInverse2D3D3 << endl;
//cout << "West mountain RPC3D 0= " << aPtInverse3D3 << endl;
//cout << "West mountain RPC3D 1= " << aPtInverse3D31 << endl;
//cout << "West mountain RPC3D d= " << aPtDirect3D31 << endl;
//cout << "West mountain RPC3D i= " << aPtInverse3D312 << endl;
//Computing Grid
aRPC3D.RPC2Grid(nbLayers, aHMin, aHMax, refineCoef, aNameIm, stepPixel, stepCarto, targetSyst, inputSyst, binaire);
*/
return 0;
}
vector<ArsenicImage> LoadGrpImages(string aDir, std::string aPatIm, int ResolModel, string InVig)
{
cInterfChantierNameManipulateur * aICNM = cInterfChantierNameManipulateur::BasicAlloc(aDir);
const std::vector<std::string> * aSetIm = aICNM->Get(aPatIm);
std::vector<std::string> aVectIm=*aSetIm;
//Scaling the images the comply with MM-Initial-Model
list<string> ListConvert, ListVig;
vector<std::string> VectImSc,VectMasq;
int nbIm=aVectIm.size();
char ResolModelch[3];sprintf(ResolModelch, "%02d", ResolModel);string ResolModelStr=(string)ResolModelch;
if(ResolModel<10){ResolModelStr=ResolModelStr.substr(1,1);}
//If a vignette correction folder is entered
string postfix="";
if(InVig!=""){
string cmdVig=MMDir() + "bin/mm3d Vodka \"" + aPatIm + "\" DoCor=1 Out=" + InVig + " InCal=" + InVig;
postfix="_Vodka.tif";
ListVig.push_back(cmdVig);
cEl_GPAO::DoComInParal(ListVig,aDir + "MkVig");
}
//Finding the appropriate NuageImProf_STD-MALT_Etape_[0-9].xml for the ResolModel :
string aEtape=FindMaltEtape(ResolModel, aDir + (aVectIm)[0], "MM-Malt-Img-" + StdPrefix(aVectIm[0]) + "/NuageImProf_STD-MALT_Etape_[0-9].xml");
//Reading images and Masq
for (int aK1=0 ; aK1<nbIm ; aK1++)
{
string cmdConv=MMDir() + "bin/ScaleIm " + InVig + (aVectIm)[aK1] + postfix + " " + ResolModelStr + " F8B=1 Out=" + (aVectIm)[aK1] + "_Scaled.tif";
ListConvert.push_back(cmdConv);
//VectMasq.push_back("Masq-TieP-" + (aVectIm)[aK1] + "/RN" + (aVectIm)[aK1] + "_Masq.tif");
VectMasq.push_back("MM-Malt-Img-" + StdPrefix((aVectIm)[aK1]) + "/AutoMask_STD-MALT_Num_" + aEtape + ".tif");
//VectMasq.push_back("MM-Malt-Img-" + StdPrefix((aVectIm)[aK1]) + "/Masq_STD-MALT_DeZoom" + ResolModelStr + ".tif");
//cout<<VectMasq[aK1]<<endl;
VectImSc.push_back((aVectIm)[aK1]+std::string("_Scaled.tif"));
}
cEl_GPAO::DoComInParal(ListConvert,aDir + "MkScale");
//Reading the infos
vector<ArsenicImage> aGrIm;
for (int aK1=0 ; aK1<int(nbIm) ; aK1++)
{
ArsenicImage aIm;
//reading 3D info
//cElNuage3DMaille * info3D1 = cElNuage3DMaille::FromFileIm("MM-Malt-Img-" + StdPrefix(aVectIm[aK1]) + "/NuageImProf_STD-MALT_Etape_1.xml");
cElNuage3DMaille * info3D1 = cElNuage3DMaille::FromFileIm("MM-Malt-Img-" + StdPrefix(aVectIm[aK1]) + "/NuageImProf_STD-MALT_Etape_" + aEtape + ".xml");
aIm.info3D=info3D1;
Tiff_Im aTF1= Tiff_Im::StdConvGen(aDir + VectImSc[aK1],3,false);
Tiff_Im aTFM= Tiff_Im::StdConvGen(aDir + VectMasq[aK1],1,false);
Pt2di aSz = aTF1.sz();
Im2D_REAL4 aIm1R(aSz.x,aSz.y);
Im2D_REAL4 aIm1G(aSz.x,aSz.y);
Im2D_REAL4 aIm1B(aSz.x,aSz.y);
Im2D_INT1 aMasq(aSz.x,aSz.y);
ELISE_COPY
(
aTF1.all_pts(),
aTF1.in(),
Virgule(aIm1R.out(),aIm1G.out(),aIm1B.out())
);
ELISE_COPY
(
aTFM.all_pts(),
aTFM.in(),
aMasq.out()
);
aIm.Mask=aMasq;
aIm.RChan=aIm1R;
aIm.GChan=aIm1G;
aIm.BChan=aIm1B;
aIm.SZ=aSz;
aGrIm.push_back(aIm);
}
return aGrIm;
}
int ConvertIm_main(int argc,char ** argv)
{
MMD_InitArgcArgv(argc,argv);
Tiff_Im::SetDefTileFile(1000000);
std::string aNameIn ;
INT aReducX=0;
INT aReducY=0;
INT aReducXY=0;
INT aVisu=0;
GenIm::type_el aTypeOut ;
std::string aNameTypeOut ="";
Tiff_Im::PH_INTER_TYPE aPhInterpOut ;
std::string aNamePITOut ="";
std::string PITOut[] = {"RGB","BW"};
std::list<std::string> lOut(PITOut, PITOut + sizeof(PITOut) / sizeof(std::string) );
std::string aNameOut;
std::string anExt;
Pt2di aP0(0,0);
Pt2di aSzOut ;
Pt2di aSzTF(-1,-1);
REAL aDyn=1.0;
Pt2di aSzTileInterne(-1,-1);
int aKCh = -1;
std::vector<int> aVPermut;
int aNoTile = 0;
std::string aF2 ="";
ElInitArgMain
(
argc,argv,
LArgMain() << EAMC(aNameIn, "Image", eSAM_IsExistFile),
LArgMain() << EAM(aNameOut,"Out",true)
<< EAM(anExt,"Ext",true)
<< EAM(aSzOut,"SzOut",true, "Size out", eSAM_NoInit)
<< EAM(aP0,"P0",true)
<< EAM(aNameTypeOut,"Type",true, "TypeMNT", eSAM_None, ListOfVal(GenIm::bits1_msbf, ""))
<< EAM(aNamePITOut,"Col",true, "Col", eSAM_None,lOut)
<< EAM(aReducXY,"ReducXY",true)
<< EAM(aReducX,"ReducX",true)
<< EAM(aReducY,"ReducY",true)
<< EAM(aVisu,"Visu",true)
<< EAM(aSzTF,"SzTifTile",true)
<< EAM(aSzTileInterne,"SzTileInterne",true)
<< EAM(aDyn,"Dyn",true)
<< EAM(aKCh,"KCh",true)
<< EAM(aNoTile,"NoTile",true)
<< EAM(aVPermut,"Permut",true, "Permut", eSAM_NoInit)
<< EAM(aF2,"F2",true)
);
if (!MMVisualMode)
{
// Tiff_Im aTifIn = Tiff_Im::BasicConvStd(aNameIn);
Tiff_Im aTifIn = Tiff_Im::UnivConvStd(aNameIn);
INT aNbChIn = aTifIn.nb_chan();
if (! EAMIsInit(&aTypeOut)) aTypeOut =aTifIn.type_el();
if (! EAMIsInit(&aPhInterpOut)) aPhInterpOut = aTifIn.phot_interp();
if (! EAMIsInit(&aSzOut)) aSzOut = aTifIn.sz();
if (aReducXY)
{
aReducX = 1;
aReducY = 1;
}
if (aNameOut=="")
{
if (anExt=="")
{
if (aReducX && aReducY)
anExt = "_RXY";
else if (aReducX)
anExt = "_RX";
else if (aReducY)
anExt = "_RY";
else
anExt= "_Out";
}
if (IsPostfixed(aNameIn))
aNameOut = StdPrefix(aNameIn) + anExt +"." + StdPostfix(aNameIn);
else
aNameOut = aNameIn + anExt + "tif";
}
Pt2di aCoefReduc(aReducX != 0 ? 2 : 1, aReducY != 0 ? 2 : 1);
aSzOut = aSzOut.dcbyc(aCoefReduc);
if (aNameTypeOut != "")
aTypeOut = type_im(aNameTypeOut);
if (aKCh != -1)
aNamePITOut="BW";
if ( aVPermut.size() !=0)
{
if ( aVPermut.size() ==1)
aPhInterpOut = Tiff_Im::BlackIsZero;
else if ( aVPermut.size() ==3)
aPhInterpOut = Tiff_Im::RGB;
else
{
ELISE_ASSERT(aNamePITOut=="","Nb Canaux incoherents");
}
}
else
{
if (aNamePITOut=="RGB")
aPhInterpOut = Tiff_Im::RGB;
else if (aNamePITOut=="BW")
aPhInterpOut = Tiff_Im::BlackIsZero;
else
{
ELISE_ASSERT(aNamePITOut=="","Mode Couleur Inconnu");
}
}
Tiff_Im::COMPR_TYPE aComprOut = Tiff_Im::No_Compr;
L_Arg_Opt_Tiff aLArg = Tiff_Im::Empty_ARG;
if (! aNoTile)
{
if (aSzTileInterne != Pt2di(-1,-1))
aLArg = aLArg + Arg_Tiff(Tiff_Im::ATiles(aSzTileInterne));
if (aSzTF != Pt2di(-1,-1))
aLArg = aLArg + Arg_Tiff(Tiff_Im::AFileTiling(aSzTF));
}
else
{
aLArg = aLArg + Arg_Tiff(Tiff_Im::ANoStrip());
aLArg = aLArg + Arg_Tiff(Tiff_Im::AFileTiling(Pt2di(-1,-1)));
}
Tiff_Im aTifOut
(
aNameOut.c_str(),
aSzOut,
aTypeOut,
aComprOut,
aPhInterpOut,
aLArg
);
INT aNbChOut = aTifOut.nb_chan();
Pt2di aSzROut = aSzOut;
Output anOut = aTifOut.out();
Fonc_Num aFin = aTifIn.in_proj();
if (aF2!="")
{
Tiff_Im aT2 = Tiff_Im::BasicConvStd(DirOfFile(aNameIn)+aF2);
aFin = Virgule(aFin,aT2.in(0));
}
if (aVPermut.size() != 0)
aFin = aFin.permut(aVPermut);
if (type_im_integral( aTypeOut))
{
}
else
{
aFin = Rconv(aFin);
}
aFin = reduc_binaire_gen(aFin, aReducX != 0, aReducY != 0, 16, true, 0);
anOut = Filtre_Out_RedBin_Gen(anOut, aReducX != 0, aReducY != 0);
aSzROut = aSzOut.mcbyc(aCoefReduc);
aFin = trans(aFin,aP0);
if (aKCh!=-1)
aFin = aFin.kth_proj(aKCh);
else
{
if ((aNbChOut==1) && (aNbChIn==3))
aFin = (aFin.v0() + aFin.v1() + aFin.v2()) / 3.0;
if ((aNbChOut==3) && (aNbChIn==1))
aFin = Virgule(aFin,aFin,aFin);
}
if (aVisu)
anOut = anOut | Video_Win::WiewAv(aSzROut);
if (aDyn != 1.0)
aFin = aFin * aDyn;
if (type_im_integral(aTypeOut) && (aTypeOut!=GenIm::int4))
{
int aVMin,aVMax;
min_max_type_num(aTypeOut,aVMin,aVMax);
aFin = Max(aVMin,Min(aVMax-1,aFin));
}
ELISE_COPY(rectangle(Pt2di(0,0),aSzROut),aFin,anOut);
return EXIT_SUCCESS;
}
else return EXIT_SUCCESS;
}
int GrShade_main(int argc,char ** argv)
{
std::string aNameIn;
std::string aNameOut;
std::string aNameCol="";
Pt2di aP0Glob(0,0),aSzGlob(0,0);
INT aNbDir = 20;
REAL aFZ = 1.0;
REAL aPdsAnis = 0.95;
INT aBrd = -1;
std::string aTMNt = "real4";
std::string aTShade = "real4";
INT aDequant =0;
INT aVisu = 0;
REAL aHypsoDyn = -1.0;
REAL aHypsoSat = 0.5;
Pt2di aSzMaxDalles (3000,3000);
INT aSzRecDalles = 300;
std::string aModeOmbre="CielVu";
std::string modeOmbre[] = {aModeOmbre,"IgnE","Local","Med","Mixte"};
std::list<std::string> lModeOmbre(modeOmbre, modeOmbre + sizeof(modeOmbre) / sizeof(std::string) );
std::string aFileMasq="";
double aDericheFact=2.0;
int aNbIterF = 4;
double aFactExp = 0.95;
double aDyn = 1.0;
int aNbMed = 100;
int aNbIterMed = 1;
Tiff_Im::SetDefTileFile(1<<15);
std::vector<double> aVPdsFiltre;
std::string aModeColor = "IntensShade";
std::string modeColor[] = {aModeColor,"BackRGB","GrayBackRGB"};
std::list<std::string> lModeColor(modeColor, modeColor + sizeof(modeColor) / sizeof(std::string) );
double aTetaH = 25.0;
double anAzimut = 0.0;
double aDynMed = 1.0;
ElInitArgMain
(
argc,argv,
LArgMain() << EAMC(aNameIn, "File name", eSAM_IsExistFile) ,
LArgMain() << EAM(aNameOut,"Out",true)
<< EAM(aNameCol,"FileCol",true, "Color file", eSAM_IsExistFile)
<< EAM(aVisu,"Visu",true)
<< EAM(aP0Glob,"P0",true)
<< EAM(aSzGlob,"Sz",true)
<< EAM(aFZ,"FZ",true)
<< EAM(aDynMed,"DynMed",true)
<< EAM(aPdsAnis,"Anisotropie",true)
<< EAM(aNbDir,"NbDir",true)
<< EAM(aBrd,"Brd",true)
<< EAM(aTMNt,"TypeMnt",true, "Type", eSAM_None, ListOfVal(GenIm::bits1_msbf, ""))
<< EAM(aTShade,"TypeShade",true, "Type", eSAM_None, ListOfVal(GenIm::bits1_msbf, ""))
<< EAM(aDequant,"Dequant",true)
<< EAM(aHypsoDyn,"HypsoDyn",true)
<< EAM(aHypsoSat,"HypsoSat",true)
<< EAM(aSzMaxDalles,"SzMaxDalles",true)
<< EAM(aSzRecDalles,"SzRecDalles",true)
<< EAM(aModeOmbre,"ModeOmbre",true,"in {CielVu,IgnE,Local,Med,Mixte}",eSAM_None,lModeOmbre)
<< EAM(aFileMasq,"Mask",true, "Mask file", eSAM_IsExistFile)
<< EAM(aDericheFact,"DericheFact",true)
<< EAM(aNbIterF,"NbIterF",true)
<< EAM(aFactExp,"FactExp",true)
<< EAM(aDyn,"Dyn",true)
<< EAM(aVPdsFiltre,"PdsF",true,"[CielVu,Local,Grad,Med]", eSAM_NoInit)
<< EAM(aModeColor,"ModeColor",true,"Color mode", eSAM_None, lModeColor)
<< EAM(aNbMed,"NbMed",true)
<< EAM(aNbIterMed,"NbIterMed",true)
<< EAM(aTetaH,"TetaH",true)
<< EAM(anAzimut,"Azimut",true)
);
if (!MMVisualMode)
{
double aPdsDef = aVPdsFiltre.size() ? 0 : 1;
for (int aK=aVPdsFiltre.size() ; aK<4 ; aK++)
aVPdsFiltre.push_back(aPdsDef);
double aSPdsF = 0;
for (int aK=0 ; aK<4 ; aK++)
aSPdsF += aVPdsFiltre[aK];
for (int aK=0 ; aK<4 ; aK++)
aVPdsFiltre[aK] /= aSPdsF;
std::string aDir,aNameFileIn;
SplitDirAndFile(aDir,aNameFileIn,aNameIn);
bool WithHypso = (aHypsoDyn>0) || (aNameCol != "");
// bool WithCol = (aNameCol != "");
if (aNameOut=="")
aNameOut = StdPrefix(aNameIn) +std::string("Shade.tif");
Tiff_Im aFileIn = Tiff_Im::StdConvGen(aNameIn,1,true,false);
if (aSzGlob== Pt2di(0,0))
aSzGlob = aFileIn.sz() -aP0Glob;
Fonc_Num aFIn = aFileIn.in_gen(Tiff_Im::eModeCoulGray,Tiff_Im::eModeNoProl);
{
Tiff_Im
(
aNameOut.c_str(),
aSzGlob,
GenIm::u_int1,
Tiff_Im::No_Compr,
WithHypso ? Tiff_Im::RGB : Tiff_Im::BlackIsZero
);
}
Tiff_Im aTifOut(aNameOut.c_str());
if (aSzMaxDalles.x<0) aSzMaxDalles = aSzGlob;
Pt2di aPRD(aSzRecDalles,aSzRecDalles);
cDecoupageInterv2D aDecoup
(
Box2di(aP0Glob,aP0Glob+aSzGlob),
aSzMaxDalles,
Box2di(-aPRD,aPRD)
);
Im2DGen aMnt = AllocImGen(aDecoup.SzMaxIn(),aTMNt);
Im2DGen aShade = AllocImGen(aDecoup.SzMaxIn(),aTShade);
cout << "SZ Max In " << aDecoup.SzMaxIn() << endl;
REAL aRatio = ElMin(800.0/aSzGlob.x,700.0/aSzGlob.y);
Video_Win * pW = aVisu ?
Video_Win::PtrWStd(Pt2di(Pt2dr(aSzGlob)*aRatio)) :
0 ;
aTetaH *= (2*PI)/360.0;
anAzimut *= (2*PI)/360.0;
for (int aKDec=0; aKDec<aDecoup.NbInterv() ; aKDec++)
{
Box2di aBoxIn = aDecoup.KthIntervIn(aKDec);
Pt2di aSzIn = aBoxIn.sz();
Pt2di aP0In = aBoxIn.P0();
cout << "DEQ " << aDequant << "Sz In " << aSzIn <<endl;
REAL aVMin;
if (aDequant)
{
ElImplemDequantifier aDeq(aSzIn);
aDeq.SetTraitSpecialCuv(true);
aDeq.DoDequantif(aSzIn, trans(aFIn,aP0In),true);
REAL aVMax;
ELISE_COPY
(
rectangle(Pt2di(0,0),aSzIn),
aDeq.ImDeqReelle() * aFZ,
aMnt.out() | VMax(aVMax) |VMin(aVMin)
);
}
else
{
ELISE_COPY
(
rectangle(Pt2di(0,0),aSzIn),
trans(aFIn,aP0In)*aFZ,
aMnt.out()|VMin(aVMin)
);
}
Im2D_Bits<1> aIMasq(aSzIn.x,aSzIn.y,1);
if (aFileMasq!="")
{
if (ELISE_fp::exist_file(aDir+aFileMasq))
aFileMasq = aDir+aFileMasq;
double aDif=100;
Tiff_Im aFM = Tiff_Im::StdConvGen(aFileMasq,1,true,false);
ELISE_COPY
(
select(rectangle(Pt2di(0,0),aSzIn),trans(!aFM.in_proj(),aP0In)),
aVMin-aDif,
aMnt.out()
| (aIMasq.out() << 0)
);
aVMin-= aDif;
}
if (aBrd>0)
{
cout << "VMin = " << aVMin <<endl;
ELISE_COPY(aMnt.border(aBrd),aVMin-1000,aMnt.out());
}
// Im2D_REAL4 aShade(aSzGlob.x,aSzGlob.y);
ELISE_COPY(aShade.all_pts(),0,aShade.out());
if (pW)
pW = pW->PtrChc(Pt2dr(aP0Glob-aP0In),Pt2dr(aRatio,aRatio));
REAL SPds = 0;
REAL aSTot = 0;
REAL Dyn = 1.0;
if (aTShade != "u_int1")
Dyn = 100;
bool Done = false;
if ( (aModeOmbre=="CielVu")
|| ((aModeOmbre=="Mixte") && (aVPdsFiltre[0] > 0.0))
)
{
std::cout << "BEGIN CIEL" << endl;
Done = true;
for (int aK=0 ; aK< 2 ; aK++)
{
SPds = 0;
for (int i=0; i<aNbDir; i++)
{
REAL Teta = (2*PI*i) / aNbDir ;
Pt2dr U(cos(Teta),sin(Teta));
Pt2di aDir = Pt2di(U * (aNbDir * 4));
REAL Pds = (1-aPdsAnis) + aPdsAnis *ElSquare(1.0 - euclid(U,Pt2dr(0,1))/2);
if (aK==1)
Pds = (Pds*Dyn) / (2*aSTot);
Symb_FNum Gr = (1-cos(PI/2-atan(gray_level_shading(aMnt.in()))))
*255.0;
cout << "Dir " << i << " Sur " << aNbDir << " P= " << Pds << endl;
SPds += Pds;
if (aK==1)
{
ELISE_COPY
(
line_map_rect(aDir,Pt2di(0,0),aSzIn),
Min(255*Dyn,aShade.in()+Pds*Gr),
aShade.out()
// | (pW ? (pW->ogray()<<(aShade.in()/SPds)) : Output::onul())
| (pW ? (pW->ogray()<<(Gr)) : Output::onul())
);
}
}
aSTot = SPds;
}
double aMul = (aModeOmbre=="Mixte") ? aVPdsFiltre[0] : 1.0;
ELISE_COPY(aShade.all_pts(),aShade.in()*(aMul/SPds),aShade.out());
SPds = aMul;
std::cout << "BEGIN CIEL" << endl;
}
if (
(aModeOmbre=="Local")
|| ((aModeOmbre=="Mixte") && (aVPdsFiltre[1] > 0.0))
)
{
std::cout << "BEGIN LOCAL" << endl;
Done = true;
Fonc_Num aFonc = aMnt.in_proj();
Fonc_Num aMoy = aFonc;
for (int aK=0 ; aK<aNbIterF; aK++)
aMoy = canny_exp_filt(aMoy*aIMasq.in_proj(),aFactExp,aFactExp)
/ Max(0.1,canny_exp_filt(aIMasq.in_proj(),aFactExp,aFactExp));
double aMul = (aModeOmbre=="Mixte") ? aVPdsFiltre[1] : 1.0;
ELISE_COPY
(
rectangle(Pt2di(0,0),aSzIn),
Max(0,Min(255, aShade.in() +(128+(aFonc-aMoy)*aDyn)* aMul)),
aShade.out()
);
SPds += aMul;
std::cout << "END LOCAL" << endl;
}
if (
(aModeOmbre=="Med")
|| ((aModeOmbre=="Mixte") && (aVPdsFiltre[3] > 0.0))
)
{
std::cout << "BEGIN MED" << endl;
Done = true;
Fonc_Num aFonc = round_ni(aMnt.in_proj()*aDynMed);
int aVMax,aVMin;
ELISE_COPY
(
rectangle(Pt2di(-1,-1),aSzIn+Pt2di(1,1)),
aFonc,
VMin(aVMin)|VMax(aVMax)
);
Fonc_Num aMoy = aFonc-aVMin;
for (int aK=0 ; aK<aNbIterMed; aK++)
aMoy = rect_median(aMoy,aNbMed,aVMax-aVMin+1);
aMoy = aMoy + aVMin;
double aMul = (aModeOmbre=="Mixte") ? aVPdsFiltre[3] : 1.0;
ELISE_COPY
(
rectangle(Pt2di(0,0),aSzIn),
Max(0,Min(255, aShade.in() +(128+((aFonc-aMoy)*aDyn)/aDynMed)* aMul)),
aShade.out()
);
SPds += aMul;
std::cout << "END MED" << endl;
}
if (
(aModeOmbre=="IgnE")
|| ((aModeOmbre=="Mixte") && (aVPdsFiltre[2] > 0.0))
)
{
int aCpt=0; aCpt++;
std::cout << "IGN E " << aCpt << " " << aKDec << "\n";
Done = true;
if (aCpt>0)
{
Symb_FNum aGrad = deriche(aMnt.in_proj(),aDericheFact);
Symb_FNum aGx = (aGrad.v0());
Symb_FNum aGy = (aGrad.v1());
Symb_FNum aNG = sqrt(1+Square(aGx)+Square(aGy));
Symb_FNum aNx (aGx/aNG);
Symb_FNum aNy (aGy/aNG);
Symb_FNum aNz (1/aNG);
Pt2dr aDirS = Pt2dr::FromPolar(1.0,anAzimut) * Pt2dr(1,0);
double aSx = aDirS.x * sin(aTetaH);
double aSy = aDirS.y * sin(aTetaH);
double aSz = cos(aTetaH);
Symb_FNum aScal(aNx*aSx+aNy*aSy+aNz*aSz);
std::cout << "AAAAAAAaa" << endl;
double aMul = (aModeOmbre=="Mixte") ? aVPdsFiltre[2] : 1.0;
ELISE_COPY
(
rectangle(Pt2di(0,0),aSzIn),
Max(0,aShade.in() + 255*aScal * aMul),
aShade.out()
);
SPds += aMul;
std::cout << "BBBBbbb" << endl;
}
}
if (! Done)
{
ELISE_ASSERT(false,"Unknown ModeOmbre");
}
Fonc_Num aFoncRes = Max(0,Min(255,aShade.in()/SPds));
if (WithHypso)
{
Fonc_Num aFIntens = aFoncRes;
Fonc_Num aFTeinte = trans(aFIn,aP0In)*aHypsoDyn;
Fonc_Num aFSat = 255*aHypsoSat;
if (aNameCol!="")
{
Tiff_Im aFileCol = Tiff_Im::StdConvGen(aDir+aNameCol,-1,true,false);
Symb_FNum aFNC(trans(rgb_to_its(aFileCol.in()),aP0In));
if (aModeColor == "IntensShade")
{
aFIntens = aFoncRes;
aFTeinte = aFNC.v1();
aFSat = aFNC.v2();
}
else if (aModeColor == "BackRGB")
{
aFIntens = aIMasq.in()*aFoncRes + (1- aIMasq.in()) * aFNC.v0();
aFTeinte = aFNC.v1();
aFSat = aFNC.v2() * (1- aIMasq.in());
}
else if (aModeColor == "GrayBackRGB")
{
aFIntens = aIMasq.in()*aFoncRes + (1- aIMasq.in()) * aFNC.v0();
aFTeinte = aFNC.v1();
aFSat = aFNC.v2()*(1-aIMasq.in());
}
else
{
ELISE_ASSERT(false,"Unknown mode color");
}
}
aFoncRes = its_to_rgb(Virgule(aFIntens,aFTeinte,aFSat));
//aFoncRes = its_to_rgb(Virgule(aFoncRes,trans(aFIn,aP0In)*aHypsoDyn,255*aHypsoSat));
}
/*
if (WithCol)
{
Tiff_Im aFileCol(aNameCol.c_str());
Symb_FNum aFNC(trans(rgb_to_its(aFileCol.in()),aP0In));
aFoncRes = its_to_rgb(Virgule(aFoncRes,aFNC.v1(),aFNC.v2()*aHypsoSat));
// aFoncRes = aFileCol.in();
}
*/
// Tiff_Im::Create8BFromFonc(aNameOut,aShade.sz(),aShade.in()/SPds);
cout << "WithHypso " << WithHypso << " DIM " << aFoncRes.dimf_out() << endl;
Box2di aBoxOut = aDecoup.KthIntervOut(aKDec);
ELISE_COPY
(
rectangle(aBoxOut.P0()-aP0Glob,aBoxOut.P1()-aP0Glob),
trans(aFoncRes,aP0Glob-aP0In),
aTifOut.out()
);
}
return EXIT_SUCCESS;
}
else return EXIT_SUCCESS;
}
cAppli_LumRas::cAppli_LumRas(int argc,char ** argv) :
cAppliWithSetImage(argc-2,argv +2,TheFlagNoOri|TheFlagDev16BGray),
// mTifBaseGr (0),
mTifBaseCoul (0),
mImGr (1,1),
mImMasq (1,1)
{
std::vector<double> aPdsI;
ElInitArgMain
(
argc,argv,
LArgMain() << EAM(mNameImBase, "Image name", true, "Image name", eSAM_IsExistFile)
<< EAM(mPatImRas, "Image pattern", true, "Pattern", eSAM_IsPatFile) ,
LArgMain() << EAM(mPostMasq,"Masq",true,"Mask for computation", eSAM_NoInit)
<< EAM(aPdsI,"PdsIn",true,"Pds on RGB Input, def=[1,1,1]", eSAM_NoInit)
<< EAM(mNameTargSh,"TargShade",true,"Targeted Shade", eSAM_NoInit)
);
if (!MMVisualMode)
{
for (int aK=(int)aPdsI.size() ; aK<3 ; aK++)
aPdsI.push_back(1);
// mTifBaseGr = new Tiff_Im (Tiff_Im::StdConvGen(mNameImBase,1,true));
mTifBaseCoul = new Tiff_Im (Tiff_Im::StdConvGen(mNameImBase,3,true));
mSz = mTifBaseCoul->sz();
mImGr.Resize(mSz);
Symb_FNum aFCoul(mTifBaseCoul->in());
Fonc_Num aFGr = (aPdsI[0]*aFCoul.v0()+aPdsI[1]*aFCoul.v1()+aPdsI[2]*aFCoul.v2())/(aPdsI[0]+aPdsI[1]+aPdsI[2]);
ELISE_COPY(mImGr.all_pts(),aFGr,mImGr.out());
mImMasq = Im2D_Bits<1>(mSz.x,mSz.y,1);
if (EAMIsInit(&mPostMasq))
{
CorrecNameMasq(mEASF.mDir,NameWithoutDir(mNameImBase),mPostMasq);
std::string aNameMasq = StdPrefix(mNameImBase)+mPostMasq+".tif";
Tiff_Im aTM(aNameMasq.c_str());
ELISE_COPY(mImMasq.all_pts(),aTM.in(0),mImMasq.out());
}
ELISE_COPY(mImMasq.border(1),0,mImMasq.out());
mKeyHom = "NKS-Assoc-CplIm2Hom@@dat";
// mKeyHom = "";
Fonc_Num aGlobSh;
for (int aK=0 ; aK<int(mVSoms.size()) ; aK++)
{
std::string aName = mVSoms[aK]->attr().mIma->mNameIm;
mVIm.push_back(new cImage_LumRas(mEASF.mDir+aName,*this));
//Fonc_Num aFShade = mVIm.back()->mImShade.in();
// aGlobSh = (aK==0) ? aFShade : Virgule(aGlobSh,aFShade);
}
if (EAMIsInit(&mNameTargSh))
{
DoShadeByLeastSquare();
}
else
{
for (int aK=0 ; aK<int(mVIm.size()) ; aK++)
mVIm[aK]->CalculShadeByDiff();
}
/*
// RGB
std::string aNameOut = mEASF.mDir+ "LumRas_"+StdPrefix(mNameImBase) + ".tif";
Tiff_Im TifTest
(
aNameOut.c_str(),
mSz,
GenIm::u_int1,
Tiff_Im::No_Compr,
Tiff_Im::RGB
);
ELISE_COPY
(
TifTest.all_pts(),
// Max(0,Min(255,128 * (1 + 5*aGlobSh))),
Max(0,Min(255,aFCoul+ 20*aGlobSh)),
TifTest.out()
);
*/
}
}