Export OriRel as orient in OriRel2Im

deseilligny · deseilligny · commit 04bf6e9cc32a · 2026-03-21T19:57:35.000+01:00
diff --git a/MMVII/Doc/CommandReferences/PointCloud.tex b/MMVII/Doc/CommandReferences/PointCloud.tex
@@ -0,0 +1,171 @@
+\chapter{Point Cloud command}
+\label{Chap:PointCloud}
+
+
+%-----------------------------------------------------------------------
+%-----------------------------------------------------------------------
+%-----------------------------------------------------------------------
+
+\section{Generalities}
+
+%-----------------------------------------------------------------------
+\subsection{Introduction}
+
+This section introduce some command/piece of code that have been devlopped for simulating
+images and depth map from lidar data.  This simulation was done with the ambition of being usable as
+training data set for computing canopy model from photogrammetric acquisition. This
+simulation pretend by no way to be physically based, the assumption between this simulation
+is that what make the canopy difficult to modelize in photgrammetry is the 3D structure that :
+
+\begin{itemize}
+   \item make it difficult for modelization via regularization
+   \item generate highly variable images for small change of point of view
+\end{itemize}
+
+
+So the pitch of this simulation is that, if we create data that reflect this difficulties, 
+we will able to train the networks.  Possibly, the images that we will be generated are "more
+challenging" that  real images, but be we hope that being a "too tough teacher with a network" is not a problem.
+
+Conversely, a postive point of simulation is that we can generate "perfectly" registered data.
+
+
+
+%-----------------------------------------------------------------------
+\subsection{MMVII format}
+
+As at this step, it is just a quick and dirty prototype, this mean the
+devlopment has been made with the objective of minmizing the effort for what
+was projected and absolutlely no idea of long term maintenance and evolution.
+For example, we did not  think it 
+was pertinent to add "big" librairies for lidar data reading and manipulation.
+The code is then based on internal classes and format.
+
+The class for representing a point cloud is {\tt cPointCloud}, it contains essentially:
+
+\begin{itemize}
+  \item  a vector of $3d$ point
+  \item different optionnal vector, that are attributes of the point
+  \item  some information useful for computation as : bounding boxes , offset of point,
+         or dynamic of layer \dots
+\end{itemize}
+
+For saving and reading  {\tt cPointCloud}, we use {\tt MMVII} facilitie of
+automated serialization.  As it's very huge data , we use the binary
+format that generate {\tt ".dmp"} files.
+
+At the time being, we  dont make any effort for maintening historical compatibility
+of this format.  It will probably evolve with new layer, and at each evolution
+previous file will become unusable.  Of course, at longer term, if this devlopment
+continue, we will change that by : make an evolutive format or adopt a standard format.
+
+%-----------------------------------------------------------------------
+%-----------------------------------------------------------------------
+%-----------------------------------------------------------------------
+
+\section{Create and viusualizng}
+
+
+%-----------------------------------------------------------------------
+
+\section{Import   data with  {\tt ImportTxtCloud}}
+
+We can only import  data in ply text format.  More precisely , {\tt MMVII} use the general facilities
+for parsing text file with identical line structure, and do not interpret the ply "semantic". Any text format
+close enough to ply, would be readable.
+
+Example of use :
+
+\begin{verbatim}
+ MMVII ImportTxtCloud 18355_51565.ply "XYZBla" NumL0=30O OffsetIsP0=true Bytes8=false HELP
+\end{verbatim}
+
+This command will generate a file {\tt 18355\_51565.dmp}.
+In this command :
+
+\begin{itemize}
+   \item {\tt "XYZBla"}  means that we will read the 3 coordinates at the begining of each line and skip after
+   \item {\tt NumL0=30O}  skip the first lines , probably $300$ is "too much", the important is to skip all the header ;
+   \item {\tt Bytes8=false }  mean that the coordinate are store on $4$ byte (and not $8$);
+   \item {\tt  OffsetIsP0=true }  mean that the coordinate are store with an offset, and that thi offset is computed
+         from first point, this is often required with geographic coordinates to maintain sufficient accuracy.
+\end{itemize}
+
+Note that this import, can be quite long .
+
+
+%-----------------------------------------------------------------------
+
+\section{Cliping data with  {\tt CloudMMVIIClip}}
+
+It is often convenient to make test on small point cloud.  For this one can use the
+command {\tt CloudMMVIIClip} :
+
+
+\begin{verbatim}
+MMVII CloudMMVIIClip 18355_51565.dmp [0.4,0.4,0.6,0.6]
+\end{verbatim}
+
+The command will generate a file {\tt  Clip\_18355\_51565.dmp}.  Note tha the box is relative to the global
+box (that is stored in the file).
+
+
+%-----------------------------------------------------------------------
+
+\section{Visualizing data with {\tt CloudMMVII2Ply}}
+
+As the format {\tt ".dmp"} is purely internal, it cannot be visualized with standard tool.
+This is why it possible to create ply version of {\tt dmp} files with the command 
+{\tt CloudMMVII2Ply}.  This is specially usefull with colored point cloud
+(see~\ref{Cloud::Colorate}).
+
+The command is pretty basic and obvious , for example: 
+
+\begin{verbatim}
+MMVII CloudMMVII2Ply Clip_18355_51565.dmp
+\end{verbatim}
+
+%-----------------------------------------------------------------------
+%-----------------------------------------------------------------------
+%-----------------------------------------------------------------------
+
+\section{Colouring point cloud with {\tt CloudMMVIIColorate}}
+
+\label{Cloud::Colorate}
+
+
+Before generating image, we must compute the "colour" of each point/leave. The hypothesis
+we do for this are the following :
+
+
+\COM{
+\begin{itemize}
+   \item the colour of each leave depend only of the quantity of light/energy it receive taking into account occlusions;
+         this model is quite simplist because in real tree each leave has a different intrisic
+         colour (albedo) , but we adpot it because :
+         \begin{itemize}
+              \item  our intution when observing real tree is that the light occlusion is predominant over the albedo
+                     variation for explaining contrats in images (except maybe trees at the begining of automn, 
+                     when there is a mix of green & brown leaves)
+              \item  we have no mean to generate realistic albedo varaiation;
+              \item  ometting albedo variation make the problem rather more difficult, and in the doubt, it's better
+                     to train the networks with data too difficult than to easy.
+         \end{itemize}
+
+         by the way, we dont exclude to add later some randomized albedo;
+
+
+   \item the light is made from $2$ sources : an homogeneous halph sphere corresponding to the \emph{"sky"} and a mono directionnal spot light 
+         corresponding to the \emph{"sun"}
+
+   \item leaves are spheres.
+
+\end{itemize}
+}
+
+
+
+
+
+
+
diff --git a/MMVII/Doc/Doc2007.tex b/MMVII/Doc/Doc2007.tex
@@ -278,6 +278,7 @@ \chapter{The Fits method}
 \part{Commands reference-documentation}
 
 \include{CommandReferences/MeshCommands}
+\include{CommandReferences/PointCloud}
 \include{CommandReferences/SysCo}
 
 
diff --git a/MMVII/src/ImagesBase/BaseImage.cpp b/MMVII/src/ImagesBase/BaseImage.cpp
@@ -299,6 +299,7 @@ template <class Type,const int Dim> void  cDataTypedIm<Type,Dim>::InitCste(const
    }
    else
    {
+      // StdOut() << "xxInitCsteInitCste " << NbElem() << " " << mRawDataLin << "\n";
       for (tINT8 aK=0 ; aK< NbElem() ; aK++)
            mRawDataLin[aK] = aVal;
    }
diff --git a/MMVII/src/Mesh/cColorateCloud.cpp b/MMVII/src/Mesh/cColorateCloud.cpp
@@ -485,6 +485,7 @@ void cProjPointCloud::ProcessOneProj
 
      mDImIndex  = & (mImIndex.DIm());
      mDImIndex->Resize(mSzIm);
+   //   StdOut() << "xxxSZ_IM=" << mSzIm << "\n";
      mDImIndex->InitCste(NoIndex);
 
 
diff --git a/MMVII/src/PoseEstim/cAppli_OriRel2Im.cpp b/MMVII/src/PoseEstim/cAppli_OriRel2Im.cpp
@@ -4,6 +4,7 @@
 #include "MMVII_Tpl_Images.h"
 #include "MMVII_HeuristikOpt.h"
 #include "MMVII_DeclareAllCmd.h"
+#include "MMVII_Random.h"
 
 namespace MMVII
 {
@@ -99,6 +100,8 @@ class cEstimatePosRel2Im :  public cOptimizeRotAndVUnit // Herit for combinatori
 
      cEstimatePosRel2Im
      (
+         const std::string & aIm1,
+         const std::string & aIm2,
          cPerspCamIntrCalib & aCalib1,
          cPerspCamIntrCalib & aCalib12,
          const cSetHomogCpleIm  &    aSetHomFull,
@@ -176,6 +179,8 @@ class cEstimatePosRel2Im :  public cOptimizeRotAndVUnit // Herit for combinatori
 
 
         //  --------  Data for camera -------------------
+    std::string                  mIm1;
+    std::string                  mIm2;
     cPerspCamIntrCalib &         mCalib1;    ///< Calib of first image
     tREAL8                       mFoc1;      ///< Foc first image
     cPerspCamIntrCalib &         mCalib2;    ///< Calib second image
@@ -224,6 +229,8 @@ class cEstimatePosRel2Im :  public cOptimizeRotAndVUnit // Herit for combinatori
 
 cEstimatePosRel2Im::cEstimatePosRel2Im
 (
+    const  std::string& aIm1,
+    const  std::string& aIm2,
     cPerspCamIntrCalib & aCalib1,
     cPerspCamIntrCalib & aCalib2,
     const cSetHomogCpleIm &     aSetHomFull,
@@ -233,6 +240,8 @@ cEstimatePosRel2Im::cEstimatePosRel2Im
     cTimerSegm *         aTimeSegm
 ) :
    cOptimizeRotAndVUnit(5,4,false),
+   mIm1        (aIm1),
+   mIm2        (aIm2),
    mCalib1     (aCalib1),
    mFoc1       (mCalib1.F()),
    mCalib2     (aCalib2),
@@ -604,12 +613,30 @@ cCdtFinalPoseRel2Im cEstimatePosRel2Im::MakeDecision(bool Show)
     SortOnCriteria(aVBest,[](const auto & aCdt){return aCdt.mScore;});
 
 
+    if (Show)
+    {
+        StdOut()  << " ======== Select solution in each mode ================\n";
+        for (auto & aCdt  : aVBest )
+        {
+            if (mWithGT)
+            {
+                tREAL8 aDTr = Norm2(aCdt.mPose.Tr()-mGTPose.Tr());
+                tREAL8 aDRot = aCdt.mPose.Rot().Dist(mGTPose.Rot());
+                aCdt.mScorePixGT = cPt2dr(aDTr,aDRot)*mFocMoy;
+            }
+            ShowSol(aCdt.mPose,aCdt.mMsg);
+        }
+    }
+
+
     if (aVBest.back().mMode==eModePE2I::eRansac)
     {
         // Worst sol in ransac
         // in this case, probably the scene is planar and the two planary solution
         // can  not be separated at this step, we maintain them
         aVBest.resize(2);
+
+        //        if (mWithGT && (aVBest.at(0).
     }
     else
     {
@@ -640,6 +667,17 @@ cCdtFinalPoseRel2Im cEstimatePosRel2Im::MakeDecision(bool Show)
            StdOut()   << "\n";
         }
     }
+    if (mWithGT && (aVBest.size()>=2))
+    {
+        tREAL8 aSc0 = Norm2(aVBest.at(0).mScorePixGT.value());
+        tREAL8 aSc1 = Norm2(aVBest.at(1).mScorePixGT.value());
+        if (aSc1<aSc0)
+        {
+            StdOut() << "=====  For Images  " << mIm1 << " " << mIm2 << "\n";
+            for (const auto & aCdt : aVBest)
+                ShowSol(aCdt.mPose,aCdt.mMsg);
+        }
+    }
 
     return aRes;
 }
@@ -751,6 +789,7 @@ class cAppli_OriRelPairOfIm : public cMMVII_Appli
 
          cTimerSegm *              mTimeSegm ;
          std::vector<const tNamePair *> mVecPairs;
+         int                       mKSaveOri;
 
 };
 
@@ -773,7 +812,8 @@ cAppli_OriRelPairOfIm::cAppli_OriRelPairOfIm(const std::vector<std::string> & aV
     mUseOri4GT    (false),
     mGTPose       (tPoseR::Identity()),
     mPC1GT        (nullptr),
-    mPC2GT        (nullptr)
+    mPC2GT        (nullptr),
+    mKSaveOri     (0)
 {
 }
 
@@ -811,7 +851,7 @@ cCollecSpecArg2007 & cAppli_OriRelPairOfIm::ArgObl(cCollecSpecArg2007 & anArgObl
 
 cCollecSpecArg2007 & cAppli_OriRelPairOfIm::ArgOpt(cCollecSpecArg2007 & anArgOpt)
 {
-   return       anArgOpt
+    anArgOpt
             <<  mPhProj.DPTieP().ArgDirInOpt()
             <<  mPhProj.DPGndPt2D().ArgDirInOpt()
             <<  mPhProj.DPMulTieP().ArgDirInOpt()
@@ -829,6 +869,14 @@ cCollecSpecArg2007 & cAppli_OriRelPairOfIm::ArgOpt(cCollecSpecArg2007 & anArgOpt
             <<  AOpt2007(mParamOutLayer,"OutLayers","Param for generating outlayers [Nb,Sigma]",{{eTA2007::ISizeV,"[2,2]"}})
             <<  AOpt2007(mShow,"Show","Show messages",{eTA2007::HDV})
    ;
+
+    if (mModeCompute==0)
+    {
+        anArgOpt << mPhProj.DPOrient().ArgDirOutOpt("OriOut","For saving relative or as orientations")
+                 << AOpt2007(mKSaveOri,"KSaveOri","Num of sol to save",{eTA2007::HDV})  ;
+    }
+
+    return anArgOpt;
 }
 
 
@@ -858,6 +906,8 @@ std::vector<std::string>  cAppli_OriRelPairOfIm::Samples() const
 
 int cAppli_OriRelPairOfIm::Exe()
 {
+
+
     mTimeSegm = mShow ? new cTimerSegm(this) : nullptr ;
     mPhProj.FinishInit();
 
@@ -923,6 +973,8 @@ int cAppli_OriRelPairOfIm::DoPairsOf1Im()
     {
         if (aPair->V1() == mIm1)
         {
+            if (mShow)
+                StdOut() << "====== DoPairsOf1Im, V2=" << aPair->V2() << "========\n";
             tRes1Pair aRes = EstimatePose2IM(aPair->V1(), aPair->V2());
             aRes.second.mIm1 = mIm1;
             aRes.second.mIm2 = aPair->V2();
@@ -951,6 +1003,10 @@ int cAppli_OriRelPairOfIm::DoPairsOf1Im()
 cAppli_OriRelPairOfIm::tRes1Pair
         cAppli_OriRelPairOfIm::EstimatePose2IM(const std::string& aIm1,const std::string& aIm2)
 {
+    // For debuging/tuning we must have the same behaviour when we run 1 pair or multiple pair,
+    // so to have the same random number in ransac we re initialize the number generator at each pair
+    cRandGenerator::TheOne()->setSeed(42);
+
     mIm1 = aIm1;
     mIm2 = aIm2;
     OrderMinMax(mIm1,mIm2);
@@ -1024,7 +1080,8 @@ cAppli_OriRelPairOfIm::tRes1Pair
      mCalib1 =  mPhProj.InternalCalibFromImage(mIm1);
      mCalib2 =  mPhProj.InternalCalibFromImage(mIm2);
 
-     mEstimatePose = new cEstimatePosRel2Im(*mCalib1,*mCalib2,mCpleHFull,mCpleHAvg,mCpleHSmall,mDensitySol,mTimeSegm);
+     mEstimatePose = new cEstimatePosRel2Im
+                         (aIm1,aIm2,*mCalib1,*mCalib2,mCpleHFull,mCpleHAvg,mCpleHSmall,mDensitySol,mTimeSegm);
      if (mUseOri4GT)
          mEstimatePose->SetGT(mGTPose);
 
@@ -1036,6 +1093,18 @@ cAppli_OriRelPairOfIm::tRes1Pair
      if (mDo5Pts)
          Generate5Pts(aCdt.mVCdt.at(0).mPose);
 
+     if (mPhProj.DPOrient().DirOutIsInit())
+     {
+         StdOut() << "OUT=" << mPhProj.DPOrient().DirOut() << "\n";
+         const auto & aC = aCdt.mVCdt.at(mKSaveOri);
+
+         cSensorCamPC aCam1(mIm1,tPoseR::Identity(),mCalib1);
+         cSensorCamPC aCam2(mIm2,aC.mPose,mCalib2);
+         mPhProj.SaveCamPC(aCam1);
+         mPhProj.SaveCamPC(aCam2);
+
+     }
+
    /*  if (mUseOri4GT && mShow)
          mEstimatePose->ShowSol(mGTPose,"GroundTruh");*/
 

Original file line number	Diff line number	Diff line change
`@@ -299,6 +299,7 @@ template <class Type,const int Dim> void cDataTypedIm<Type,Dim>::InitCste(const`
`299`	`299`	`}`
`300`	`300`	`else`
`301`	`301`	`{`
	`302`	`+ // StdOut() << "xxInitCsteInitCste " << NbElem() << " " << mRawDataLin << "\n";`
`302`	`303`	`for (tINT8 aK=0 ; aK< NbElem() ; aK++)`
`303`	`304`	`mRawDataLin[aK] = aVal;`
`304`	`305`	`}`