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()
);
}
template <class Type> void Bench_PackB_IM<Type>::TiffVerif()
{
Pt2di SzDalle = Pt2di(mPer,64);
Tiff_Im aTifFile
(
ELISE_BFI_DATA_DIR "ex.tif",
sz,
type_of_ptr((Type *)0),
Tiff_Im::NoByte_PackBits_Compr,
Tiff_Im::BlackIsZero,
L_Arg_Opt_Tiff()
+ Arg_Tiff(Tiff_Im::ATiles(SzDalle))
);
ELISE_COPY(aTifFile.all_pts(),pck.in(),aTifFile.out());
INT VDIF;
ELISE_COPY(aTifFile.all_pts(),Abs(pck.in()-aTifFile.in()),VMax(VDIF));
BENCH_ASSERT(VDIF==0);
if (type_of_ptr((Type *)0)==GenIm::u_int1)
{
PackB_IM<U_INT1> aPack2 = aTifFile.un_load_pack_bit_U_INT1();
ELISE_COPY(aTifFile.all_pts(),Abs(pck.in()-aPack2.in()),VMax(VDIF));
BENCH_ASSERT(VDIF==0);
}
if (type_of_ptr((Type *)0)==GenIm::u_int2)
{
PackB_IM<U_INT2> aPack2 = aTifFile.un_load_pack_bit_U_INT2();
ELISE_COPY(aTifFile.all_pts(),Abs(pck.in()-aPack2.in()),VMax(VDIF));
BENCH_ASSERT(VDIF==0);
}
}
void cPackObsLiaison::GetPtsTerrain
(
const cParamEstimPlan & aPEP,
cSetName & aSelectorEstim,
cArgGetPtsTerrain & anArg,
const char * anAttr
)
{
cStatObs aSO(false);
if ( aPEP.AttrSup().IsInit())
anAttr = aPEP.AttrSup().Val().c_str();
ELISE_ASSERT
(
mIsMult,
"Require PMUL for cPackObsLiaison::GetPtsTerrain"
);
cPonderationPackMesure aPPM = aPEP.Pond();
aPPM.Add2Compens().SetVal(false);
for
(
std::map<std::string,cObsLiaisonMultiple *>::iterator itOML=mDicoMul.begin();
itOML!=mDicoMul.end();
itOML++
)
{
cObsLiaisonMultiple * anOLM = itOML->second;
std::string aNameP = anOLM->Pose1()->Name();
if (aSelectorEstim.IsSetIn(aNameP))
{
Im2D_Bits<1> aM(1,1);
if (aPEP.KeyCalculMasq().IsInit())
{
std::string aNameM =
anAttr ?
mAppli.ICNM()->Assoc1To2(aPEP.KeyCalculMasq().Val(),aNameP,anAttr,true):
mAppli.ICNM()->StdCorrect(aPEP.KeyCalculMasq().Val(),aNameP,true);
aNameM = mAppli.DC() + aNameM;
Tiff_Im aTF = Tiff_Im::UnivConvStd(aNameM);
Pt2di aSz = aTF.sz();
aM = Im2D_Bits<1>(aSz.x,aSz.y);
ELISE_COPY(aTF.all_pts(),aTF.in_bool(),aM.out());
anArg.SetMasq(&aM);
}
anOLM->AddObsLM(aPPM,0,&anArg,(cArgVerifAero*)0,aSO,0);
anArg.SetMasq(0);
}
}
}
void Write_Vignette(string aDir, string aNameOut,vector<double> aParam,string aDirOut, Pt2di aSz){
//Bulding the output file system
ELISE_fp::MkDirRec(aDir + aDirOut);
//Reading the image and creating the objects to be manipulated
aNameOut=aDir + aDirOut + aNameOut;
Tiff_Im aTF=Tiff_Im(aNameOut.c_str(), aSz, GenIm::real4, Tiff_Im::No_Compr, Tiff_Im::BlackIsZero);
Im2D_REAL4 aIm(aSz.x,aSz.y);
ELISE_COPY
(
aTF.all_pts(),
aTF.in(),
aIm.out()
);
REAL4 ** aData = aIm.data();
for (int aY=0 ; aY<aSz.y ; aY++)
{
for (int aX=0 ; aX<aSz.x ; aX++)
{
double x0=aSz.x/2;
double y0=aSz.y/2;
double D=pow(aX-x0,2)+pow(aY-y0,2);
double aCor=1+aParam[0]*D+aParam[1]*pow(D,2)+aParam[2]*pow(D,3);
if(aCor<1){aData[aY][aX]=1;}else{aData[aY][aX]=aCor;}
}
}
Tiff_Im aTOut
(
aNameOut.c_str(),
aSz,
GenIm::real4,
Tiff_Im::No_Compr,
Tiff_Im::BlackIsZero
);
ELISE_COPY
(
aTOut.all_pts(),
aIm.in(),
aTOut.out()
);
}
void TestNtt(const std::string &aName)
{
Tiff_Im aTF = Tiff_Im::StdConvGen(aName,1,true);
Pt2di aSz = aTF.sz();
Im2D_REAL4 aI0(aSz.x,aSz.y);
ELISE_COPY( aTF.all_pts(),aTF.in(),aI0.out());
int aWSz=2;
TIm2D<REAL4,REAL8> aTIm(aI0);
double aSomGlob=0.0;
double aNbGlob=0.0;
for (int aKdx=-aWSz ; aKdx<=aWSz ; aKdx+=aWSz)
{
printf("## ");
for (int aKdy=-aWSz ; aKdy<=aWSz ; aKdy+=aWSz)
{
int aDx = aKdx;
int aDy = aKdy;
Pt2di aDep(aDx,aDy);
Pt2di aP;
RMat_Inertie aMat;
for (aP.x = aWSz ; aP.x<aSz.x-aWSz ; aP.x++)
{
for (aP.y=aWSz ; aP.y<aSz.y-aWSz ; aP.y++)
{
aMat.add_pt_en_place(aTIm.get(aP),aTIm.get(aP+aDep));
}
}
double aC = aMat.correlation();
aC = 1-aC;
if (dist8(aDep) == aWSz)
{
aSomGlob += aC;
aNbGlob ++;
}
printf(" %4d",round_ni(10000*(aC)));
}
printf("\n");
}
aSomGlob /= aNbGlob;
std::cout << " G:" << aSomGlob << "\n";
printf("\n\n");
}
void DebugDrag()
{
std::string aDir = "/media/data1/Jeux-Tests/Dragon-2/MEC2Im-Epi_Im1_Right_IMGP7511_IMGP7512.tif-Epi_Im2_Left_IMGP7511_IMGP7512.tif/";
std::string aNamePx = "Px1_Num6_DeZoom2_LeChantier.tif";
std::string aNameMasq = "AutoMask_LeChantier_Num_5.tif";
Tiff_Im aTP = Tiff_Im::StdConv(aDir+aNamePx);
Tiff_Im aTM = Tiff_Im::StdConv(aDir+aNameMasq);
double aMinPx;
ELISE_COPY
(
aTP.all_pts(),
aTP.in() * aTM.in(),
VMin(aMinPx)
);
std::cout << "MIN PX " << aMinPx << "\n";
}
void SobelTestNtt(const std::string &aName)
{
Tiff_Im aTF = Tiff_Im::StdConvGen(aName,1,true);
Pt2di aSz = aTF.sz();
Im2D_REAL4 aI0(aSz.x,aSz.y);
ELISE_COPY( aTF.all_pts(),aTF.in(),aI0.out());
Video_Win * aW=0;
// aW = Video_Win::PtrWStd(aSz);
if (aW)
{
ELISE_COPY(aW->all_pts(),Min(255,aI0.in()/256.0),aW->ogray());
aW->clik_in();
}
Fonc_Num aF1 = sobel(aI0.in_proj());
Fonc_Num aF2 = aI0.in_proj();
for (int aK=0 ; aK<3 ; aK++)
aF2 = rect_som(aF2,1) / 9.0;
aF2 = sobel(aF2);
if (aW)
{
ELISE_COPY(aW->all_pts(),Min(255, 200 * (aF1/Max(aF2,1e-7))),aW->ogray());
aW->clik_in();
}
double aSF1,aSF2,aSomPts;
ELISE_COPY(aI0.all_pts(),Virgule(aF1,aF2,1.0),Virgule(sigma(aSF1),sigma(aSF2),sigma(aSomPts)));
std::cout << "Indice " << aSF1 / aSF2 << "\n";
}
int PreparSift_Main(int argc,char ** argv)
{
double aPEg = 1.0;
double aPSrtEg = 3.0;
double aPM = 2.0;
std::string aNameIn,aNameOut="Sift.tif";
ElInitArgMain
(
argc,argv,
LArgMain() << EAMC(aNameIn,"Full name (Dir+Pattern)", eSAM_IsPatFile),
LArgMain() << EAM(aNameOut,"NameOut",true)
);
Tiff_Im aTif = Tiff_Im::StdConvGen(aNameIn,1,true);
// Init Mems
Pt2di aSz = aTif.sz();
Im2D_U_INT2 anIm(aSz.x,aSz.y);
Im1D_REAL8 aH(aNbH,0.0);
// Load image
{
Symb_FNum aFTif(aTif.in());
ELISE_COPY(aTif.all_pts(),aFTif,anIm.out()| (aH.histo().chc(aFTif)<<1) );
}
Im1D_REAL8 aHSqrt(aNbH,0.0);
ELISE_COPY(aH.all_pts(),sqrt(aH.in()),aHSqrt.out());
int aVMax =0;
// Calcul Histo
MakeFoncRepart(aH,&aVMax);
MakeFoncRepart(aHSqrt);
// Fonc Loc
Fonc_Num aFonc(Rconv(anIm.in_proj()));
Fonc_Num aS1S2 = Virgule(aFonc,Square(aFonc));
for (int aK=0 ; aK< TheNbIter ; aK++)
{
aS1S2 = rect_som(aS1S2,TheNbVois) / ElSquare(1+2*TheNbVois);
}
Symb_FNum aFS1 = aS1S2.v0();
Symb_FNum aFS2 = aS1S2.v1()-Square(aFS1);
Fonc_Num aFLoc = (anIm.in()-aFS1) / sqrt(Max(1.0,aFS2));
// aFLoc = aFLoc * 20;
aFLoc = atan(aFLoc) /(PI/2);
// Symb_FNum aFonc(aTif.in());
std::cout << "MaxMin " << aVMax << "\n";
Fonc_Num aFEg = aH.in()[anIm.in()];
Fonc_Num aFEgS = aHSqrt.in()[anIm.in()];
Fonc_Num aFM = anIm.in() * (255.0 / aVMax);
// Fonc_Num aFRes = (aFEg*aPEg + aFM * aPM + aFEgS*aPSrtEg + aFLoc) / (aPEg + aPM + aPSrtEg);
Symb_FNum aFMoy = (aFEg*aPEg + aFM * aPM + aFEgS*aPSrtEg ) / (aPEg + aPM + aPSrtEg);
Symb_FNum aFMarge = Min(64,Min(aFMoy,255-aFMoy));
Fonc_Num aFRes = aFMoy + aFMarge * aFLoc;
/*
Fonc_Num aFRes = Max(0,Min(255,aFMoy + 60 * aFLoc));
*/
Tiff_Im::Create8BFromFonc(aNameOut,aSz,aFRes);
return EXIT_SUCCESS;
}
void Drunk(string aFullPattern,string aOri,string DirOut, bool Talk)
{
string aPattern,aNameDir;
SplitDirAndFile(aNameDir,aPattern,aFullPattern);
//Reading input files
list<string> ListIm=RegexListFileMatch(aNameDir,aPattern,1,false);
int nbIm=ListIm.size();
if (Talk){cout<<"Images to process: "<<nbIm<<endl;}
//Paralelizing (an instance of Drunk is called for each image)
string cmdDRUNK;
list<string> ListDrunk;
if(nbIm!=1)
{
for(int i=1;i<=nbIm;i++)
{
string aFullName=ListIm.front();
ListIm.pop_front();
cmdDRUNK=MMDir() + "bin/Drunk " + aNameDir + aFullName + " " + aOri + " Out=" + DirOut + " Talk=0";
ListDrunk.push_back(cmdDRUNK);
}
cEl_GPAO::DoComInParal(ListDrunk,aNameDir + "MkDrunk");
//Calling the banner at the end
if (Talk){Drunk_Banniere();}
}else{
//Bulding the output file system
ELISE_fp::MkDirRec(aNameDir + DirOut);
//Processing the image
string aNameIm=ListIm.front();
string aNameOut=aNameDir + DirOut + aNameIm + ".tif";
//Loading the camera
string aNameCam="Ori-"+aOri+"/Orientation-"+aNameIm+".xml";
cInterfChantierNameManipulateur * anICNM = cInterfChantierNameManipulateur::BasicAlloc(aNameDir);
CamStenope * aCam = CamOrientGenFromFile(aNameCam,anICNM);
//Reading the image and creating the objects to be manipulated
Tiff_Im aTF= Tiff_Im::StdConvGen(aNameDir + aNameIm,3,false);
Pt2di aSz = aTF.sz();
Im2D_U_INT1 aImR(aSz.x,aSz.y);
Im2D_U_INT1 aImG(aSz.x,aSz.y);
Im2D_U_INT1 aImB(aSz.x,aSz.y);
Im2D_U_INT1 aImROut(aSz.x,aSz.y);
Im2D_U_INT1 aImGOut(aSz.x,aSz.y);
Im2D_U_INT1 aImBOut(aSz.x,aSz.y);
ELISE_COPY
(
aTF.all_pts(),
aTF.in(),
Virgule(aImR.out(),aImG.out(),aImB.out())
);
U_INT1 ** aDataR = aImR.data();
U_INT1 ** aDataG = aImG.data();
U_INT1 ** aDataB = aImB.data();
U_INT1 ** aDataROut = aImROut.data();
U_INT1 ** aDataGOut = aImGOut.data();
U_INT1 ** aDataBOut = aImBOut.data();
//Parcours des points de l'image de sortie et remplissage des valeurs
Pt2dr ptOut;
for (int aY=0 ; aY<aSz.y ; aY++)
{
for (int aX=0 ; aX<aSz.x ; aX++)
{
ptOut=aCam->DistDirecte(Pt2dr(aX,aY));
aDataROut[aY][aX] = Reechantillonnage::biline(aDataR, aSz.x, aSz.y, ptOut);
aDataGOut[aY][aX] = Reechantillonnage::biline(aDataG, aSz.x, aSz.y, ptOut);
aDataBOut[aY][aX] = Reechantillonnage::biline(aDataB, aSz.x, aSz.y, ptOut);
}
}
Tiff_Im aTOut
(
aNameOut.c_str(),
aSz,
GenIm::u_int1,
Tiff_Im::No_Compr,
Tiff_Im::RGB
);
ELISE_COPY
(
aTOut.all_pts(),
Virgule(aImROut.in(),aImGOut.in(),aImBOut.in()),
aTOut.out()
);
}
}
void Vignette_correct(string aDir, GrpVodka aGrpVodka,string aDirOut, string InCal){
//Bulding the output file system
ELISE_fp::MkDirRec(aDir + aDirOut);
//Reading vignette files
char foc[5],dia[4];
sprintf(foc, "%04d", int(10*aGrpVodka.foc));
sprintf(dia, "%03d", int(10*aGrpVodka.diaph));
string aNameVignette="Foc" + (string)foc + "Diaph" + (string)dia + "-FlatField.tif";
//string aNameVignette = "Foc"+ ToString(round_ni(aGrpVodka.foc)) + "Diaph" + ToString(round_ni(10*aGrpVodka.diaph)) + "-FlatField.tif";
Tiff_Im aTFV= Tiff_Im::StdConvGen(aDir + InCal + aNameVignette,1,false);
Pt2di aSz = aTFV.sz();
Im2D_REAL4 aVignette(aSz.x,aSz.y);
ELISE_COPY
(
aTFV.all_pts(),
aTFV.in(),
aVignette.out()
);
REAL4 ** aDataVignette = aVignette.data();
//Correcting images
int nbIm=aGrpVodka.size();
#ifdef USE_OPEN_MP
#pragma omp parallel for
#endif
for(int i=0;i<nbIm;i++)
{
string aNameIm=aGrpVodka.aListIm[i];
cout<<"Correcting "<<aNameIm<<endl;
string aNameOut=aDir + aDirOut + aNameIm +"_vodka.tif";
//Reading the image and creating the objects to be manipulated
Tiff_Im aTF= Tiff_Im::StdConvGen(aDir + aNameIm,3,false);
Pt2di aSz = aTF.sz();
Im2D_U_INT1 aImR(aSz.x,aSz.y);
Im2D_U_INT1 aImG(aSz.x,aSz.y);
Im2D_U_INT1 aImB(aSz.x,aSz.y);
ELISE_COPY
(
aTF.all_pts(),
aTF.in(),
Virgule(aImR.out(),aImG.out(),aImB.out())
);
U_INT1 ** aDataR = aImR.data();
U_INT1 ** aDataG = aImG.data();
U_INT1 ** aDataB = aImB.data();
for (int aY=0 ; aY<aSz.y ; aY++)
{
for (int aX=0 ; aX<aSz.x ; aX++)
{
double aCor=aDataVignette[aY][aX];
double R = aDataR[aY][aX] * aCor;
double G = aDataG[aY][aX] * aCor;
double B = aDataB[aY][aX] * aCor;
if(R>255){aDataR[aY][aX]=255;}else if(aCor<1){continue;}else{aDataR[aY][aX]=R;}
if(G>255){aDataG[aY][aX]=255;}else if(aCor<1){continue;}else{aDataG[aY][aX]=G;}
if(B>255){aDataB[aY][aX]=255;}else if(aCor<1){continue;}else{aDataB[aY][aX]=B;}
}
}
Tiff_Im aTOut
(
aNameOut.c_str(),
aSz,
GenIm::u_int1,
Tiff_Im::No_Compr,
Tiff_Im::RGB
);
ELISE_COPY
(
aTOut.all_pts(),
Virgule(aImR.in(),aImG.in(),aImB.in()),
aTOut.out()
);
}
}
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 cModeleAnalytiqueComp::MakeExport()
{
if (!mModele.MakeExport().Val())
return;
cMatrCorresp * pMatr = GetMatr(mModele.PasCalcul(),mModele.PointUnique().Val());
const ElPackHomologue * aPackIn =0;
ElPackHomologue aPackRef;
ElPackHomologue aNewPack;
if (mModele.UseHomologueReference().Val())
{
aPackRef = mAppli.PDV1()->ReadPackHom(mAppli.PDV2());
aPackIn = & aPackRef;
}
else
{
aPackIn = & pMatr->PackHomCorr();
}
/*
* FILTRAGE EVENTUEL DES POINTS HOMOLOGUES
*/
double aTol = mAppli.TolerancePointHomInImage().Val();
double aFiltre = mAppli.FiltragePointHomInImage().Val();
bool GotOut = false;
switch (mModele.TypeModele())
{
case eTMA_Homologues :
SauvHomologues(pMatr->PackHomInit());
break;
case eTMA_DHomD :
// std::cout << "PKS = " << aPackIn->size() << "\n"; getchar();
SolveHomographie(*aPackIn);
SauvHomologues(pMatr->PackHomInit());
break;
case eTMA_Ori :
{
if ((aTol<1e10) || (aFiltre !=0))
{
GotOut = FiltragePointHomologues(pMatr->PackHomInit(),aNewPack,aTol,aFiltre);
aPackIn = & aNewPack;
}
SauvHomologues(pMatr->PackHomInit());
if (mModele.AffineOrient().Val())
{
cMA_AffineOrient aMAAO
(
mAppli,
*this,
mGeoTer,
mModele.L1CalcOri().Val(),
pMatr->Sz(),
*aPackIn
);
// SauvHomologues(*aPackIn);
if (mModele.MakeImagePxRef().Val())
{
aMAAO.MakeImagePxRef();
}
}
}
break;
case eTMA_Nuage3D :
{
std::string aNameRes = std::string("Nuage3D")
+ mAppli.NameChantier()
+ std::string(".tif");
if (mModele.KeyNuage3D().IsInit())
{
aNameRes = mAppli.ICNM()->Assoc1To1
(
mModele.KeyNuage3D().Val(),
mAppli.NameChantier(),
true
);
}
aNameRes = mAppli.FullDirResult() + aNameRes;
Tiff_Im aFile
(
aNameRes.c_str(),
pMatr->ImAppX().sz(),
GenIm::real4,
Tiff_Im::No_Compr,
Tiff_Im::PtDAppuisDense
);
ELISE_COPY
(
aFile.all_pts(),
Virgule
(
pMatr->ImPds().in(),
pMatr->ImAppX().in(),
pMatr->ImAppY().in(),
pMatr->ImAppZ().in()
),
aFile.out()
);
}
break;
default :
ELISE_ASSERT(false,"TypeModeleAnalytique Non Traite");
break;
}
delete pMatr;
if (GotOut)
{
mAppli.MicMacErreur
(
eErrPtHomHorsImage,
"Point Homologue Hors Image",
"Specification Utilisateur sur la Tolerance : <TolerancePointHomInImage>"
);
}
}
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;
}
void RotateImage(double alpha, Pt2di aSzOut, vector<Pt2dr> Pts , string aNameDir, string aNameIm)
{
cout<<"Rotating "<<aNameIm<<endl;
string aNameOut=aNameDir + "Croped_images/" + aNameIm + ".tif";
//Reading the image and creating the objects to be manipulated
Tiff_Im aTF= Tiff_Im::StdConvGen(aNameDir + aNameIm,1,false);
Pt2di aSz = aTF.sz();
Pt2dr P1Cor=Rot2D(alpha, Pts[0], Pts[1]); //P1Cor.x=cos(alpha)*(Pts[0].x-Pts[1].x)+sin(alpha)*(Pts[0].y-Pts[1].y)+Pts[1].x; P1Cor.y=-sin(alpha)*(Pts[0].x-Pts[1].x)+cos(alpha)*(Pts[0].y-Pts[1].y)+Pts[1].y;
Pt2dr P3Cor=Rot2D(alpha, Pts[2], Pts[1]); //P3Cor.x=cos(alpha)*(Pts[2].x-Pts[1].x)+sin(alpha)*(Pts[2].y-Pts[1].y)+Pts[1].x; P3Cor.y=-sin(alpha)*(Pts[2].x-Pts[1].x)+cos(alpha)*(Pts[2].y-Pts[1].y)+Pts[1].y;
Im2D_U_INT1 aImR(aSz.x,aSz.y);
//Im2D_U_INT1 aImG(aSz.x,aSz.y);
//Im2D_U_INT1 aImB(aSz.x,aSz.y);
Im2D_U_INT1 aImROut(aSzOut.x,aSzOut.y);
Im2D_U_INT1 aImGOut(aSzOut.x,aSzOut.y);
Im2D_U_INT1 aImBOut(aSzOut.x,aSzOut.y);
ELISE_COPY
(
aTF.all_pts(),
aTF.in(),
aImR.out()//Virgule(aImR.out(),aImG.out(),aImB.out())
);
U_INT1 ** aDataR = aImR.data();
//U_INT1 ** aDataG = aImG.data();
//U_INT1 ** aDataB = aImB.data();
U_INT1 ** aDataROut = aImROut.data();
U_INT1 ** aDataGOut = aImGOut.data();
U_INT1 ** aDataBOut = aImBOut.data();
//Parcours des points de l'image de sortie et remplissage des valeurs
Pt2dr ptOut;
Pt2di imageTopCorner, imageBottomCorner;
imageTopCorner.x = (int)(P1Cor.x + 0.5) + (int)(max(abs(P1Cor.x - Pts[1].x), abs(P1Cor.x - P3Cor.x)) - aSzOut.x) / 2;
imageTopCorner.y = (int)(P1Cor.y + 0.5) + (int)(max(abs(P3Cor.y - Pts[1].y), abs(P1Cor.y - P3Cor.y)) - aSzOut.y) / 2;
imageBottomCorner.x = imageTopCorner.x + aSzOut.x;
imageBottomCorner.y = imageTopCorner.y + aSzOut.y;
for (int aY=imageTopCorner.y ; aY<imageBottomCorner.y ; aY++)
{
for (int aX=imageTopCorner.x ; aX<imageBottomCorner.x ; aX++)
{
ptOut.x=cos(-alpha)*(aX-Pts[1].x)+sin(-alpha)*(aY-Pts[1].y)+Pts[1].x;
ptOut.y=-sin(-alpha)*(aX-Pts[1].x)+cos(-alpha)*(aY-Pts[1].y)+Pts[1].y;
aDataROut[aY-imageTopCorner.y][aX-imageTopCorner.x] = Reechantillonnage::biline(aDataR, aSz.x, aSz.y, ptOut);
aDataGOut[aY-imageTopCorner.y][aX-imageTopCorner.x] = Reechantillonnage::biline(aDataR, aSz.x, aSz.y, ptOut);
aDataBOut[aY-imageTopCorner.y][aX-imageTopCorner.x] = Reechantillonnage::biline(aDataR, aSz.x, aSz.y, ptOut);
}
}
Tiff_Im aTOut
(
aNameOut.c_str(),
aSzOut,
GenIm::u_int1,
Tiff_Im::No_Compr,
Tiff_Im::RGB
);
ELISE_COPY
(
aTOut.all_pts(),
Virgule(aImROut.in(),aImGOut.in(),aImBOut.in()),
aTOut.out()
);
#if (ELISE_unix || ELISE_Cygwin || ELISE_MacOs)
string aCom="convert ephemeral:" + aNameDir + "Croped_images/" + aNameIm + ".tif " + aNameDir + "Croped_images/" + aNameIm;
system_call(aCom.c_str());
#endif
#if (ELISE_windows)
string aCom=MMDir() + "binaire-aux/convert ephemeral:" + aNameDir + "Croped_images/" + aNameIm + ".tif " + aNameDir + "Croped_images/" + aNameIm;
system_call(aCom.c_str());
#endif
}
int ApplyParralaxCor_main(int argc, char ** argv)
{
//std::string aNameIm, aNameIm2, aNameParallax, aNameDEM;
std::string aNameIm, aNameParallax;
std::string aNameOut = "";
//Reading the arguments
ElInitArgMain
(
argc, argv,
LArgMain()
<< EAMC(aNameIm, "Image to be corrected", eSAM_IsPatFile)
//<< EAMC(aNameIm2, "Other image", eSAM_IsPatFile)
<< EAMC(aNameParallax, "Paralax correction file", eSAM_IsPatFile),
//<< EAMC(aNameDEM, "DEM file", eSAM_IsPatFile),
LArgMain()
<< EAM(aNameOut, "Out", true, "Name of output image (Def=ImName_corrected.tif")
);
std::string aDir, aPatIm;
SplitDirAndFile(aDir, aPatIm, aNameIm);
cout << "Correcting " << aNameIm << endl;
if (aNameOut == "")
aNameOut = aNameIm + "_corrected.tif";
//Reading the image and creating the objects to be manipulated
Tiff_Im aTF = Tiff_Im::StdConvGen(aDir + aNameIm, 1, false);
Pt2di aSz = aTF.sz(); cout << "size of image = " << aSz << endl;
Im2D_U_INT1 aIm(aSz.x, aSz.y);
ELISE_COPY
(
aTF.all_pts(),
aTF.in(),
aIm.out()//Virgule(aImR.out(),aImG.out(),aImB.out())
);
U_INT1 ** aData = aIm.data();
//Reading the parallax correction file
Tiff_Im aTFPar = Tiff_Im::StdConvGen(aDir + aNameParallax, 1, false);
Im2D_REAL8 aPar(aSz.x, aSz.y);
ELISE_COPY
(
aTFPar.all_pts(),
aTFPar.in(),
aPar.out()//Virgule(aImR.out(),aImG.out(),aImB.out())
);
REAL8 ** aDatPar = aPar.data();
//Output container
Im2D_U_INT1 aImOut(aSz.x, aSz.y);
U_INT1 ** aDataOut = aImOut.data();
/*Things needed for RPC angle computation, not main goal of this function
//Read RPCs
RPC aRPC;
string aNameRPC1 = "RPC_" + StdPrefix(aNameIm) + ".xml";
aRPC.ReadDimap(aNameRPC1);
cout << "Dimap File " << aNameRPC1 << " read" << endl;
RPC aRPC2;
string aNameRPC2 = "RPC_" + StdPrefix(aNameIm2) + ".xml";
aRPC2.ReadDimap(aNameRPC2);
cout << "Dimap File " << aNameRPC2 << " read" << endl;
//Reading the DEM file
Tiff_Im aTFDEM = Tiff_Im::StdConvGen(aDir + aNameDEM, 1, false);
Im2D_REAL8 aDEM(aSz.x, aSz.y);
ELISE_COPY
(
aTFDEM.all_pts(),
aTFDEM.in(),
aDEM.out()
);
REAL8 ** aDatDEM = aDEM.data();
//Output angle container 1
Im2D_REAL8 aAngleBOut(aSz.x, aSz.y);
REAL8 ** aDataAngleBOut = aAngleBOut.data();
string aNameAngleB = "AngleB.tif";
//Output angle container 2
Im2D_REAL8 aAngleNOut(aSz.x, aSz.y);
REAL8 ** aDataAngleNOut = aAngleNOut.data();
string aNameAngleN = "AngleN.tif";
*/
//Pt3dr PBTest(1500,3000, 0);
//Pt3dr PWTest = aRPC.DirectRPC(PBTest);
//Pt3dr PNTest = aRPC2.InverseRPC(PWTest);
//cout << "PB0 = " << PBTest << endl;
//cout << "PW0 = " << PWTest << endl;
//cout << "PN0 = " << PNTest << endl;
//cout << aRPC.height_scale << " " << aRPC.height_off << endl;
//PBTest.z=1000;
//PWTest = aRPC.DirectRPC(PBTest);
//PNTest = aRPC2.InverseRPC(PWTest);
//cout << "PB1 = " << PBTest << endl;
//cout << "PW1 = " << PWTest << endl;
//cout << "PN1 = " << PNTest << endl;
cout << "size of image = " << aSz << endl;
//Computing output data
for (int aX = 0; aX < aSz.x; aX++)
{
for (int aY = 0; aY < aSz.y; aY++)
{
/*
Pt3dr P0B(aX, aY, aDatDEM[aY][aX]);
Pt3dr PW0 = aRPC.DirectRPC(P0B);
Pt3dr PW1 = PW0, PW2 = PW0;
PW1.z = PW1.z - 1;
PW2.z = PW2.z + 1;
Pt3dr P1B = aRPC.InverseRPC(PW1);
Pt3dr P2B = aRPC.InverseRPC(PW2);
Pt3dr P1N = aRPC2.InverseRPC(PW1);
Pt3dr P2N = aRPC2.InverseRPC(PW2);
//Pt3dr P1B(aX, aY, 0);
//Pt3dr P2B(aX, aY, 10000);
//Pt3dr P1N = aRPC2.InverseRPC(aRPC.DirectRPC(P1B));
//Pt3dr P2N = aRPC2.InverseRPC(aRPC.DirectRPC(P2B));
double aAngleB = atan((P2B.x - P1B.x) / (P2B.y - P1B.y));
aDataAngleBOut[aY][aX] = aAngleB;
double aAngleN = atan((P2N.x - P1N.x) / (P2N.y - P1N.y));
aDataAngleNOut[aY][aX] = aAngleN;
//cout << aX << " " << aY << " " << aAngle << endl;
//cout << P1N << " " << P2N << " " << aAngle << endl;
*/
//THE THINGS COMPUTED ABOVE WILL BE USED IN A FURTHER UPDATE
Pt2dr ptOut;
ptOut.x = aX - aDatPar[aY][aX];// * cos(aAngleB);
ptOut.y = aY - aDatPar[aY][aX];// * sin(aAngleB);
aDataOut[aY][aX] = Reechantillonnage::biline(aData, aSz.x, aSz.y, ptOut);
}
}
cout << "size of image = " << aSz << endl;
Tiff_Im aTOut
(
aNameOut.c_str(),
aSz,
GenIm::u_int1,
Tiff_Im::No_Compr,
Tiff_Im::BlackIsZero
);
ELISE_COPY
(
aTOut.all_pts(),
aImOut.in(),
aTOut.out()
);
/*
Tiff_Im aTAngleBOut
(
aNameAngleB.c_str(),
aSz,
GenIm::real8,
Tiff_Im::No_Compr,
Tiff_Im::BlackIsZero
);
ELISE_COPY
(
aTAngleBOut.all_pts(),
aAngleBOut.in(),
aTAngleBOut.out()
);
Tiff_Im aTAngleNOut
(
aNameAngleN.c_str(),
aSz,
GenIm::real8,
Tiff_Im::No_Compr,
Tiff_Im::BlackIsZero
);
ELISE_COPY
(
aTAngleNOut.all_pts(),
aAngleNOut.in(),
aTAngleNOut.out()
);
*/
return 0;
}
BiScroller::BiScroller
(
VideoWin_Visu_ElImScr & aVisu,
ElImScroller * ScrGray,
ElImScroller * ScrCol,
ModeFusion aModeFusion,
Elise_colour * Cols,
INT NbCol,
const std::string & mNameMasq
) :
ElImScroller (aVisu,1,Inf(ScrGray->SzU(),ScrCol?ScrCol->SzU():ScrGray->SzU()),1.0),
mMemGray (1,aVisu.SzW()),
mScrGray ( ScrGray),
mMemCol (1,aVisu.SzW()),
mScrCol (ScrCol),
mModeFusion (aModeFusion),
mVideoVisu (aVisu),
mImGray (mMemGray.Images()[0]),
mDataGray (mImGray.data()),
mImCol (mMemCol.Images()[0]),
mDataCol (mImCol.data()),
mTabRGB (3,NbCol,256),
mDataTabRGB (mTabRGB.data()),
mImR (aVisu.SzW().x,1),
mDataImR (mImR.data()[0]),
mImG (aVisu.SzW().x,1),
mDataImG (mImG.data()[0]),
mImB (aVisu.SzW().x,1),
mDataImB (mImB.data()[0]),
mTr (0.0,0.0),
mIm1Act (true),
mIm2Act (mScrCol!=0),
mImMasq (1,1)
{
mSubScrolls.push_back(mScrGray);
if (mScrCol)
mSubScrolls.push_back(mScrCol);
for (INT iCol = 0; iCol<NbCol ; iCol++)
for (INT iGray=0; iGray < 256; iGray ++)
{
Elise_colour CGray = Elise_colour::gray(iGray/255.0);
Elise_colour CCol = Cols[iCol];
Elise_colour ColMixed = som_pond(CCol,0.3,CGray);
if (iCol == 0)
ColMixed = CGray;
SetRGBEntry(iGray, iCol, ColMixed);
}
if (mNameMasq!="")
{
Tiff_Im aFM = Tiff_Im::UnivConvStd(mNameMasq);
Pt2di aSz = aFM.sz();
mImMasq=Im2D_U_INT1 (aSz.x,aSz.y);
Fonc_Num aFIn = aFM.in();
if (aModeFusion==eModeMasq)
{
aFIn = (aFM.in()!=0);
}
ELISE_COPY(aFM.all_pts(),aFIn,mImMasq.out());
}
/*
REAL DistCible = 60.0;
DistCible /= 255.0;
for (INT iCol = 0; iCol<NbCol ; iCol++)
{
Elise_colour CCol = Cols[iCol];
Elise_colour aGray = Elise_colour::gray(CCol.GrayVal());
REAL dist = ElMax(1e-10,aGray.eucl_dist(CCol));
Elise_colour vAtDit = aGray + (DistCible/dist) * (CCol-aGray);
Elise_colour v0 = vAtDit - Elise_colour::gray(vAtDit.MinRGB());
Elise_colour v1 = vAtDit + Elise_colour::gray(1.0-vAtDit.MaxRGB());
for (INT iGray=0; iGray < 256; iGray ++)
{
REAL GrayLevel = iGray/255.0;
Elise_colour ColMixed = som_pond(v0,1-GrayLevel,v1);
if (iCol == 0)
ColMixed = Elise_colour::gray(GrayLevel);
SetRGBEntry(iGray, iCol, ColMixed);
}
}
*/
}
int Luc_main_truc(int argc, char ** argv)
{
/*
std::string aFullPattern, aOri, aNameOut="PointsCordinates.txt";
//Reading the arguments
ElInitArgMain
(
argc, argv,
LArgMain() << EAMC(aFullPattern, "Images Pattern 1", eSAM_IsPatFile)
<< EAMC(aOri, "Orientation", eSAM_IsPatFile),
LArgMain() << EAM(aNameOut, "Out", true, "Output file (txt)")
);
string aPattern, aNameDir;
SplitDirAndFile(aNameDir, aPattern, aFullPattern);
//Reading input files
list<string> ListIm = RegexListFileMatch(aNameDir, aPattern, 1, false);
int nbIm = ListIm.size();
string oriFileName = aNameDir + aNameOut;
FILE *f = fopen(oriFileName.c_str(), "w");
for (int i = 1; i <= nbIm; i++)
{
//Processing the image
string aNameIm = ListIm.front();
ListIm.pop_front();
string aNameOut = aNameDir + aNameIm + ".tif";
//Loading the camera
string aNameCam = "Ori-" + aOri + "/Orientation-" + aNameIm + ".xml";
cInterfChantierNameManipulateur * anICNM = cInterfChantierNameManipulateur::BasicAlloc(aNameDir);
CamStenope * aCam = CamOrientGenFromFile(aNameCam, anICNM);
cout << aNameIm << " [ " << aCam->VraiOpticalCenter().x << " , " << aCam->VraiOpticalCenter().y << " , " << aCam->VraiOpticalCenter().z << " ]" << endl;
fprintf(f, "%s %0.6f %0.6f %0.6f\n", aNameIm, aCam->VraiOpticalCenter().x, aCam->VraiOpticalCenter().y, aCam->VraiOpticalCenter().z);
}
fclose(f);
*/
std::string aFullPattern1, aFullPattern2, aFile3D1, aFile3D2, aOri, aDirOut = "Visualisation/";
int aSzW = 1;
double aSzMovArea = 5;
//Reading the arguments
ElInitArgMain
(
argc, argv,
LArgMain() << EAMC(aFullPattern1, "Images Pattern 1", eSAM_IsPatFile)
<< EAMC(aFullPattern2, "Images Pattern 2", eSAM_IsPatFile)
<< EAMC(aFile3D1, "File 3D 1", eSAM_IsPatFile)
<< EAMC(aFile3D2, "File 3D 2", eSAM_IsPatFile)
<< EAMC(aOri, "Orientation", eSAM_IsPatFile),
LArgMain() << EAM(aDirOut, "Out", true, "Output folder (end with /) and/or prefix (end with another char)")
<< EAM(aSzMovArea, "SzMovArea", true, "Max magnitude of movement in meters (def=5)")
);
//Creating vector of images
std::string aDir, aPatIm1, aPatIm2;
SplitDirAndFile(aDir, aPatIm1, aFullPattern1);
SplitDirAndFile(aDir, aPatIm2, aFullPattern2);
cInterfChantierNameManipulateur * aICNM = cInterfChantierNameManipulateur::BasicAlloc(aDir);
const std::vector<std::string> * aSetIm1 = aICNM->Get(aPatIm1);
const std::vector<std::string> * aSetIm2 = aICNM->Get(aPatIm2);
std::vector<std::string> aVectIm1 = *aSetIm1;
std::vector<std::string> aVectIm2 = *aSetIm2;
cout << "Set 1 size : " << aVectIm1.size() << endl;
cout << "Set 1 : " << aVectIm1 << endl;
cout << "Set 2 size : " << aVectIm2.size() << endl;
cout << "Set 2 : " << aVectIm2 << endl;
//loading 3D models
cElNuage3DMaille * info3D1 = cElNuage3DMaille::FromFileIm(aFile3D1);
cElNuage3DMaille * info3D2 = cElNuage3DMaille::FromFileIm(aFile3D2);
cout << "Sz geom 1: " << info3D1->SzGeom() << endl;
cout << "Sz geom 2: " << info3D2->SzGeom() << endl;
cout << "Resol geom 1: " << info3D1->ResolSolGlob() << endl;
cout << "Resol geom 2: " << info3D2->ResolSolGlob() << endl;
//Loading images
vector<SpatioTempImage> aGrIm1 = LoadGrpImages(aDir, aPatIm1, aOri);
vector<SpatioTempImage> aGrIm2 = LoadGrpImages(aDir, aPatIm2, aOri);
cout << "Loaded " << aGrIm1.size() << " images for group 1 and " << aGrIm2.size() << " for group 2" << endl;
//Bulding the output file system
ELISE_fp::MkDirRec(aDir + aDirOut);
std::string aNameOut = "banane.tif";
//Reading the image and creating the objects to be manipulated
aNameOut = aDir + aDirOut + aNameOut;
Pt2di aSz( info3D1->SzGeom().x , info3D1->SzGeom().y );
Tiff_Im aTF = Tiff_Im(aNameOut.c_str(), aSz, GenIm::real4, Tiff_Im::No_Compr, Tiff_Im::BlackIsZero);
Im2D_REAL4 aIm(aSz.x, aSz.y);
ELISE_COPY
(
aTF.all_pts(),
aTF.in(),
aIm.out()
);
REAL4 ** aData = aIm.data();
for (int aY = aSzW; aY < aSz.y - aSzW; aY++)
{
for (int aX = aSzW; aX < aSz.x - aSzW; aX++)
{
/*******************************
HOW TO
//transform XY pixel coordinates to terrain coordinates
Pt2dr pos2DPtIm1; pos2DPtIm1.x = 10050 + aX*0.14999999999999999*2; pos2DPtIm1.y = 10350 - aY*0.14999999999999999*2;
//Go back to pix coordinates
pos2DPtIm1 = info3D->Plani2Index(pos2DPtIm1);
********************************/
Pt2dr pos2DMNT( aX , aY );
//Test if there is data
if (info3D1->CaptHasData(pos2DMNT)){
//Get 3D info at XY
Pt3d<double> pos3DMNT = info3D1->PreciseCapteur2Terrain(pos2DMNT);
//cout << "pos3DMNT1 = " << pos3DMNT << endl;
//Get Im1(i,j)
Pt2di pos2DIm1( int(aGrIm1[0].aCamera->Ter2Capteur(pos3DMNT).x) , int(aGrIm1[0].aCamera->Ter2Capteur(pos3DMNT).y) );
cout << "pos2DIm1 = " << pos2DIm1 << endl;
//Extracting window from Im1
Im2D_U_INT1 aWindow1 = Window_Maker(aGrIm1[0], pos2DIm1, 1);
Fonc_Num aScoreMin = 100;
/*
for (int bX = pos3DMNT.x - aSzMovArea; bX <= pos3DMNT.x + aSzMovArea; bX++)
{
for (int bY = pos3DMNT.y - aSzMovArea; bY <= pos3DMNT.y + aSzMovArea; bY++)
{
Pt2di aPos(int(aGrIm2[0].aCamera->Ter2Capteur(pos3DMNT).x), int(aGrIm2[0].aCamera->Ter2Capteur(pos3DMNT).y));
//Extracting window from Im2
Im2D_U_INT1 aWindow2 = Window_Maker(aGrIm2[0], aPos, 1);
double aScore = Correlator(&aWindow1, &aWindow2);
if (aScore < aScoreMin)
{
//CACACACACACACACCACACACACA TESTER SI PT EXIST DANS INFO3D2=====================================================================================
aScoreMin = aScore;
Pt2dr aPos2D(bX, bY);
Pt3dr aPos3D = info3D2->PreciseCapteur2Terrain(info3D2->Plani2Index(aPos2D));
cout << "pos set 1 = " << pos3DMNT << endl;
cout << "pos set 2 = " << aPos3D << endl;
aData[aY][aX] = square_euclid(pos3DMNT, aPos3D);
cout << aData[aY][aX] << endl;
}
}
}
//Get Im2(i,j)
Pt2di pos2DIm2( int(aGrIm2[0].aCamera->Ter2Capteur(pos3DMNT).x) , int(aGrIm2[0].aCamera->Ter2Capteur(pos3DMNT).y) );
cout << "pos2DIm2 = " << pos2DIm2 << endl;
//Define researsh area in pixels from input info in meters
int aSzMovAreaPix = aSzMovArea / aGrIm2[0].aCamera->ResolutionSol();
cout <<"Pouet"<<endl;
double aScoreMin = 100;
for (int bX = pos2DIm2.x - aSzMovAreaPix; bX <= pos2DIm2.x + aSzMovAreaPix; bX++)
{
for (int bY = pos2DIm2.y - aSzMovAreaPix; bY <= pos2DIm2.y + aSzMovAreaPix; bY++)
{
Pt2di aPos( bX, bY );
//Extracting window from Im2
vector<vector<float> > aWindow2 = Window_Maker(aGrIm2[0], aPos, 1);
cout << aWindow2 << endl;
double aScore = Correlator(aWindow1, aWindow2);
cout << aScore << endl;
if (aScore < aScoreMin)
{
aScoreMin = aScore;
Pt2dr aPosR(aPos.x, aPos.y);
cout << "aPos " << aPos << endl;
cout << "aPosR " << aPosR << endl;
Pt3dr aPosPt3D = aGrIm2[0].aCamera->PreciseCapteur2Terrain(aPosR);
cout << aPosPt3D << endl;
Pt2dr aPos2DPtIm2 = info3D2->Plani2Index(aPosR);
cout << aPos2DPtIm2 << endl;
aData[aY][aX] = square_euclid(pos3DMNT, info3D2->PreciseCapteur2Terrain(aPos2DPtIm2));
cout << aData[aY][aX] << endl;
}
}
}
*/
}
else
{
aData[aY][aX] = 1;
//cout << "not in Masq" << endl;
}
}
}
Tiff_Im aTOut
(
aNameOut.c_str(),
aSz,
GenIm::real4,
Tiff_Im::No_Compr,
Tiff_Im::BlackIsZero
);
ELISE_COPY
(
aTOut.all_pts(),
aIm.in(),
aTOut.out()
);
return 0;
}
int EstimFlatField_main(int argc,char ** argv)
{
std::string aFullDir,aDir,aPat;
std::string aNameOut;
double aResol=1.0;
double aDilate=1.0;
int aNbMed = 1;
int aNbMedSsRes = 3;
bool ByMoy = false;
double TolMed = 0.25;
ElInitArgMain
(
argc,argv,
LArgMain() << EAMC(aFullDir,"Images = Dir + Pat", eSAM_IsPatFile)
<< EAMC(aResol,"Resolution "),
LArgMain() << EAM(aNbMed,"NbMed",true)
<< EAM(aNameOut,"Out",true,"Name of result")
<< EAM(aDilate,"SousResAdd",true)
<< EAM(aNbMedSsRes,"NbMedSsRes",true)
<< EAM(TolMed,"TolMed",true)
<< EAM(ByMoy,"ByMoy",true,"Average or median (def=false")
);
if (!MMVisualMode)
{
SplitDirAndFile(aDir,aPat,aFullDir);
if (aNameOut=="")
aNameOut = "FlatField.tif";
aNameOut = aDir + aNameOut;
cTplValGesInit<std::string> aTplN;
cInterfChantierNameManipulateur * aICNM = cInterfChantierNameManipulateur::StdAlloc(0,0,aDir,aTplN);
MakeXmlXifInfo(aFullDir,aICNM);
std::list<std::string> aLName = aICNM->StdGetListOfFile(aPat);
Paral_Tiff_Dev(aDir,std::vector<std::string> (aLName.begin(),aLName.end()),1,false);
Pt2di aSzIm(-1,-1);
double aNbPix=-1;
Im2D_REAL4 aImIn(1,1);
Im2D_REAL8 aFFRes1(1,1);
Pt2di aSzF(-1,-1);
int aNbIm = (int)aLName.size();
int aCpt = aNbIm;
std::vector<Im2D_REAL4> aVImRed;
// for (std::list<std::string>::const_iterator itN=aLName.begin(); itN!=aLName.end() ; itN++)
// for (std::list<std::string>::reverse_iterator itN=aLName.rbegin(); itN!=aLName.rend() ; itN++)
for (std::list<std::string>::const_iterator itN=aLName.begin(); itN!=aLName.end() ; itN++)
{
std::cout << "To Do " << aCpt << *itN << "\n";
Tiff_Im aTIn = Tiff_Im::StdConvGen(aDir+*itN,1,true);
std::string aImRefSz;
if (aSzIm.x<0)
{
aImRefSz = *itN;
aSzIm = aTIn.sz();
aImIn = Im2D_REAL4(aSzIm.x,aSzIm.y,0.0);
if (ByMoy)
aFFRes1 = Im2D_REAL8(aSzIm.x,aSzIm.y,0.0);
aNbPix = aSzIm.x*aSzIm.y;
aSzF = round_up(Pt2dr(aSzIm)/aResol);
}
else
{
if (aSzIm!=aTIn.sz())
{
std::cout << "For Image " << *itN << " sz=" << aTIn.sz() << " Ref=" << aImRefSz << " Sz=" << aSzIm << "\n";
ELISE_ASSERT(false,"Different size");
}
}
double aSom = 0;
// ELISE_COPY(aImIn.all_pts(),aTIn.in(),aImIn.out()|sigma(aSom));
Fonc_Num aFIN = aTIn.in();
ELISE_COPY(aImIn.all_pts(),Rconv(aFIN),aImIn.out()|sigma(aSom));
double aMoy = aSom/aNbPix;
if (ByMoy)
{
ELISE_COPY
(
aImIn.all_pts(),
aFFRes1.in()+(aImIn.in()/aMoy),
aFFRes1.out()
);
}
else
{
Im2D_REAL4 aIRed(aSzF.x,aSzF.y);
ELISE_COPY
(
aIRed.all_pts(),
StdFoncChScale
(
aImIn.in_proj() / aMoy,
Pt2dr(0.0,0.0),
Pt2dr(aResol,aResol),
Pt2dr(aDilate,aDilate)
),
aIRed.out()
);
aVImRed.push_back(aIRed);
}
aCpt--;
}
Fonc_Num aF;
if (ByMoy)
{
std::cout << "Filtrage Median "<< aNbMed << "\n";
ELISE_COPY
(
aFFRes1.all_pts(),
MedianBySort(aFFRes1.in_proj()/aNbIm,aNbMed),
aFFRes1.out()
);
aF = StdFoncChScale
(
aFFRes1.in_proj() / aNbIm,
Pt2dr(0.0,0.0),
Pt2dr(aResol,aResol),
Pt2dr(aDilate,aDilate)
);
if (aNbMedSsRes)
aF = MedianBySort(aF,aNbMedSsRes);
}
else
{
int aMoyMed = 2;
Im2D_REAL4 aRes = ImMediane<float,double>(aVImRed,-1e30,0.0,TolMed);
aF = aRes.in_proj();
for (int aK=0 ; aK<3 ; aK++)
aF = MedianBySort(aF,4);
for (int aK=0 ; aK<3 ; aK++)
aF = rect_som(aF,aMoyMed)/ElSquare(1+2*aMoyMed);
}
Tiff_Im aTOut
(
aNameOut.c_str(),
aSzF ,
GenIm::real8,
Tiff_Im::No_Compr,
Tiff_Im::BlackIsZero
);
ELISE_COPY
(
aTOut.all_pts(),
aF,
aTOut.out()
);
}
return EXIT_SUCCESS;
}
void Egal_field_correct_ite(string aDir,std::vector<std::string> * aSetIm, cl_MatPtsHom aMatPtsHomol , string aDirOut, string InVig, int ResolModel, int nbIm, int nbIte, double aThresh)
{
//truc à iterer--------------------------------------------------------------------------------------------------------------------------------------
for(int iter=0;iter<nbIte;iter++){
cout<<"Pass "<<iter+1<<" out of "<< nbIte<<endl;
//Filtering the tie points
aMatPtsHomol = TiePtsFilter(aMatPtsHomol, aThresh);
//Correcting the tie points
//#pragma omp parallel for
for(int numImage1=0;numImage1<nbIm;numImage1++)
{
vector<int> cpt(nbIm,0);
cout<<"Computing factors for Im "<<numImage1<<endl;
//For each tie point point, compute correction value (distance-ponderated mean value of all the tie points)
for(int k = 0; k<int(aMatPtsHomol.aMat[numImage1].size()) ; k++){//go through each tie point
double aCorR=0.0,aCorG=0.0,aCorB=0.0;
double aSumDist=0;
Pt2dr aPt(aMatPtsHomol.aMat[numImage1].Pts[k].x/ResolModel,aMatPtsHomol.aMat[numImage1].Pts[k].x/ResolModel);
for(int numPt = 0; numPt<int(aMatPtsHomol.aMat[numImage1].size()) ; numPt++){//go through each tie point
Pt2dr aPtIn(aMatPtsHomol.aMat[numImage1].Pts[numPt].x/ResolModel,aMatPtsHomol.aMat[numImage1].Pts[numPt].y/ResolModel);
double aDist=euclid(aPtIn, aPt);
if(aDist<1){aDist=1;}
aSumDist=aSumDist+1/(aDist);
aCorR = aCorR + aMatPtsHomol.aMat[numImage1].kR[numPt]/(aDist);
aCorG = aCorG + aMatPtsHomol.aMat[numImage1].kG[numPt]/(aDist);
aCorB = aCorB + aMatPtsHomol.aMat[numImage1].kB[numPt]/(aDist);
}
//Normalize
aCorR = aCorR/aSumDist;
aCorG = aCorG/aSumDist;
aCorB = aCorB/aSumDist;
//correcting Tie points color with computed surface
//int numImage2=aMatPtsHomol.aMat[numImage1].OtherIm[k];
//int pos=cpt[numImage2];cpt[numImage2]++;
//if(aMatPtsHomol.aMat[numImage1][numImage2].R1[pos]*aCorR>255)
//{
// aCorR=255/aMatPtsHomol.aMat[numImage1][numImage2].R1[pos];
//}
//if(aMatPtsHomol.aMat[numImage1][numImage2].G1[pos]*aCorB>255)
//{
// aCorG=255/aMatPtsHomol.aMat[numImage1][numImage2].G1[pos];
//}
//if(aMatPtsHomol.aMat[numImage1][numImage2].B1[pos]*aCorG>255)
//{
// aCorB=255/aMatPtsHomol.aMat[numImage1][numImage2].B1[pos];
//}
aMatPtsHomol.aMat[numImage1].kR[k]=aCorR;
aMatPtsHomol.aMat[numImage1].kG[k]=aCorG;
aMatPtsHomol.aMat[numImage1].kB[k]=aCorB;
}
//cout<<cpt<<endl;
}
}
//Filtering the tie points
aMatPtsHomol = TiePtsFilter(aMatPtsHomol, aThresh);
cout<<"Factors were computed"<<endl;
//end truc à iterer--------------------------------------------------------------------------------------------------------------------------------------
//Applying the correction to the images
//Bulding the output file system
ELISE_fp::MkDirRec(aDir + aDirOut);
//Reading input files
string suffix="";if(InVig!=""){suffix="_Vodka.tif";}
#ifdef USE_OPEN_MP
#pragma omp parallel for
#endif
for(int i=0;i<nbIm;i++)
{
string aNameIm=InVig + (*aSetIm)[i] + suffix;//if vignette is used, change the name of input file to read
cout<<"Correcting "<<aNameIm<<" (with "<<aMatPtsHomol.aMat[i].size()<<" data points)"<<endl;
string aNameOut=aDir + aDirOut + (*aSetIm)[i] +"_egal.tif";
Pt2di aSzMod=aMatPtsHomol.aMat[i].SZ;//Size of the correction surface, taken from the size of the scaled image
//cout<<"aSzMod"<<aSzMod<<endl;
Im2D_REAL4 aImCorR(aSzMod.x,aSzMod.y,0.0);
Im2D_REAL4 aImCorG(aSzMod.x,aSzMod.y,0.0);
Im2D_REAL4 aImCorB(aSzMod.x,aSzMod.y,0.0);
REAL4 ** aCorR = aImCorR.data();
REAL4 ** aCorG = aImCorG.data();
REAL4 ** aCorB = aImCorB.data();
//cout<<vectPtsRadioTie[i].size()<<endl;
//For each point of the surface, compute correction value (distance-ponderated mean value of all the tie points)
long start=time(NULL);
for (int aY=0 ; aY<aSzMod.y ; aY++)
{
for (int aX=0 ; aX<aSzMod.x ; aX++)
{
float aCorPtR=0,aCorPtG=0,aCorPtB=0;
double aSumDist=0;
Pt2dr aPt(aX,aY);
for(int j = 0; j<int(aMatPtsHomol.aMat[i].size()) ; j++){//go through each tie point
Pt2dr aPtIn(aMatPtsHomol.aMat[i].Pts[j].x/ResolModel,aMatPtsHomol.aMat[i].Pts[j].y/ResolModel);
double aDist=euclid(aPtIn, aPt);
if(aDist<1){aDist=1;}
aSumDist=aSumDist+1/(aDist);
aCorPtR = aCorPtR + aMatPtsHomol.aMat[i].kR[j]/(aDist);
aCorPtG = aCorPtG + aMatPtsHomol.aMat[i].kG[j]/(aDist);
aCorPtB = aCorPtB + aMatPtsHomol.aMat[i].kB[j]/(aDist);
}
//Normalize
aCorR[aY][aX] = aCorPtR/aSumDist;
aCorG[aY][aX] = aCorPtG/aSumDist;
aCorB[aY][aX] = aCorPtB/aSumDist;
}
}
long end = time(NULL);
cout<<"Correction field computed in "<<end-start<<" sec, applying..."<<endl;
//Reading the image and creating the objects to be manipulated
Tiff_Im aTF= Tiff_Im::StdConvGen(aDir + aNameIm,3,false);
Pt2di aSz = aTF.sz();
Im2D_U_INT1 aImR(aSz.x,aSz.y);
Im2D_U_INT1 aImG(aSz.x,aSz.y);
Im2D_U_INT1 aImB(aSz.x,aSz.y);
ELISE_COPY
(
aTF.all_pts(),
aTF.in(),
Virgule(aImR.out(),aImG.out(),aImB.out())
);
U_INT1 ** aDataR = aImR.data();
U_INT1 ** aDataG = aImG.data();
U_INT1 ** aDataB = aImB.data();
for (int aY=0 ; aY<aSz.y ; aY++)
{
for (int aX=0 ; aX<aSz.x ; aX++)
{
Pt2dr aPt(double(aX/ResolModel),double(aY/ResolModel));
//To be able to correct the edges
if(aPt.x>aSzMod.x-2){aPt.x=aSzMod.x-2;}
if(aPt.y>aSzMod.y-2){aPt.y=aSzMod.y-2;}
//Bilinear interpolation from the scaled surface to the full scale image
double R = aDataR[aY][aX]*Reechantillonnage::biline(aCorR, aSzMod.x, aSzMod.y, aPt);
double G = aDataG[aY][aX]*Reechantillonnage::biline(aCorG, aSzMod.x, aSzMod.y, aPt);
double B = aDataB[aY][aX]*Reechantillonnage::biline(aCorB, aSzMod.x, aSzMod.y, aPt);
//Overrun management:
if(R>255){aDataR[aY][aX]=255;}else if(R<0){aDataR[aY][aX]=0;}else{aDataR[aY][aX]=R;}
if(G>255){aDataG[aY][aX]=255;}else if(G<0){aDataG[aY][aX]=0;}else{aDataG[aY][aX]=G;}
if(B>255){aDataB[aY][aX]=255;}else if(B<0){aDataB[aY][aX]=0;}else{aDataB[aY][aX]=B;}
}
}
//Writing ouput image
Tiff_Im aTOut
(
aNameOut.c_str(),
aSz,
GenIm::u_int1,
Tiff_Im::No_Compr,
Tiff_Im::RGB
);
ELISE_COPY
(
aTOut.all_pts(),
Virgule(aImR.in(),aImG.in(),aImB.in()),
aTOut.out()
);
}
}
