In bundle line, ready to branch ?

Author: deseilligny

MMVII/include/MMVII_Manifolds.h

@@ -3,6 +3,7 @@
 
 #include "MMVII_Mappings.h"
 #include "MMVII_Geom2D.h"
+#include "MMVII_PCSens.h"
 
 
 namespace MMVII
@@ -23,6 +24,7 @@ template <const int DimM,const int DimE> class cManifold
         typedef  std::pair<int,tPtM>                tResPOP; // Type result Param of Pt
 
         cManifold(int aNbMap=1,const tREAL8 aEpsDeriv = 1e-4);
+        virtual ~cManifold();
         int NbMap() const; //< Accessor
 
         /// return the num map of a point, defaults assume mNbMap==1
@@ -62,10 +64,33 @@ template<int DimE> class cLineManifold : public cManifold<1,DimE>
         tResPOP   ParamOfPt(const tPtE &) const override;
         tPtE  ApproxProj(const tPtE &) const  override ;
 
+        cLineManifold(const tSeg & aSeg);
+
    private :
         tSeg   mSeg;
 };
 
+template<int DimE> class cSphereManifold : public cManifold<DimE-1,DimE>
+{
+     public :
+        // virtual  tPtE   PtOfParam(const tPtM &,int aNumMap) const ;
+        static const int DimM = DimE-1;
+        static const int DimC = DimE - DimM;
+
+        typedef cPtxd<tREAL8,DimM>                  tPtM;
+        typedef cPtxd<tREAL8,DimE>                  tPtE;
+        typedef cSegmentCompiled<tREAL8,DimE>       tSeg;
+        typedef  std::pair<int,tPtM>                tResPOP; // Type result Param of Pt
+
+        cSphereManifold(const tPtE & aPPerturb = tPtE::PCste(0.0) );
+        tPtE   PtOfParam(const tResPOP&) const override;
+        tResPOP   ParamOfPt(const tPtE &) const override;
+        tPtE  ApproxProj(const tPtE &) const  override ;
+
+   private :
+        bool mIsPerturb; //< do use artificial perturbation, just 4 bench
+        tPtE mPPerturb;  //< Value to use 4 articial perturbation
+};
 
 template <const int DimM,const int DimE> class cManifoldFromMapping : public  cManifold<DimM,DimE>
 {
@@ -86,6 +111,8 @@ template <const int DimM,const int DimE> class cManifoldFromMapping : public  cM
         tResPOP   ParamOfPt(const tPtE &) const override;
         tPtE  ApproxProj(const tPtE &) const  override ;
 
+        tMan * Man();  //<  Accessor
+        tMap * Map();  //<  Accessor
 
 
    private :
@@ -94,6 +121,31 @@ template <const int DimM,const int DimE> class cManifoldFromMapping : public  cM
 
 };
 
+
+class cLineDist_Manifold;
+///  Helper class to cLineDist_Manifold  so that data can be created before cManifoldFromMapping
+class cAux_LineDist_Manifold
+{
+   public :
+       friend cLineDist_Manifold;
+       cAux_LineDist_Manifold(const tSeg2dr & aSeg,cPerspCamIntrCalib * aCalib );
+   private :
+       cCamUDReD_Map                   mMap_Ud_Red;
+       cDataInvertOfMapping<tREAL8,2>  mMap_Red_Ud;
+       cLineManifold   <2>             mLineMan;
+};
+
+/// class to present the distortion of line by a camera as a Manifold
+class cLineDist_Manifold : public cAux_LineDist_Manifold,
+                           public cManifoldFromMapping<1,2>
+{
+   public :
+     cLineDist_Manifold(const tSeg2dr & aSeg,cPerspCamIntrCalib * aCalib );
+     //virtual ~cLineDist_Manifold() ;
+   private:
+};
+
+
 };
 
 #endif //  __MMVII_MANIFOLDS_H_

MMVII/include/MMVII_Mappings.h

@@ -40,6 +40,8 @@ template <class Type,const int Dim> class cSphereBoundedSet;//   cDataBoundedSet
 template <class Type,const int DimIn,const int DimOut> class cMapping;
 template <class Type,const int DimIn,const int DimOut> class cDataMapping;
 template <class Type,const int Dim> class cDataInvertibleMapping ;// :  public cDataMapping<Type,Dim,Dim>
+template <class Type,const int Dim> class cDataInvertOfMapping;  //  : public cDataInvertibleMapping <Type,Dim>
+
 template <class Type,const int Dim> class cDataIterInvertMapping ;// :  public cDataInvertibleMapping<Type,Dim>
 template <class Type,const int Dim> class cDataIIMFromMap ; // : public cDataIterInvertMapping<Type,Dim>
 
@@ -439,6 +441,7 @@ template <class Type,const int Dim> class cDataInvertibleMapping :  public cData
 #endif
 };
 
+///  If we have a Map M, create M-1, just by "swapping"  Inverses & Values
 template <class Type,const int Dim> class cDataInvertOfMapping : public cDataInvertibleMapping <Type,Dim>
 {
    public :

MMVII/include/MMVII_PCSens.h

@@ -316,6 +316,8 @@ class cPerspCamIntrCalib : public cObj2DelAtEnd,
 
 	     /// return calculator adapted to model of camera (degree, projection)
              cCalculator<double> * EqColinearity(bool WithDerives,int aSzBuf,bool ReUse);
+             ///  return the calculator if first time, else recycle it
+             cCalculator<double> *  SetAndGet_EqProjSeg();
 
 	     void UpdateMapProj2Im();  ///< when PP/F modified
 
@@ -366,6 +368,8 @@ class cPerspCamIntrCalib : public cObj2DelAtEnd,
 	    void CheckBeforeInverse(const tVecOut &) const;
 	    void CheckBeforeInverse(const tPtOut & ) const;
 
+	     /// return calculator adapted to model the projection of 3d seg on a curve
+             cCalculator<double> * EqProjSeg(bool WithDerives,int aSzBuf,bool ReUse);
 
          // ==================   DATA PART   ===================
 	 //
@@ -405,6 +409,7 @@ class cPerspCamIntrCalib : public cObj2DelAtEnd,
             bool                                 mInvIsUpToDate;        
             cTabuMapInv<2>*                      mTabulDUD;  ///< Possibly store a tabulation of D/UD to replace call Undist/Redist
             // cDataMapCalcSymbDer<tREAL8,3,2>   * mProjInv;
+            cCalculator<double> *               mEqProjSeg;
 };
 
 
@@ -605,6 +610,7 @@ class cSensorCamPC : public cSensorImage
 	 cPt3dr  Vec_L2W(const cPt3dr &) const;  ///< Coordinat local of cam to coordinate word for a "vector"
 	 cPt3dr  Vec_W2L(const cPt3dr &) const;  ///< Coordinat word to coordinate local of cam for a "vector"
 
+         cCalculator<double> *  EqProjSeg();
 
          //  Cast to possible heriting class
          bool  IsSensorCamPC() const  override ;

MMVII/include/MMVII_Ptxd.h

@@ -894,19 +894,21 @@ template <class Type,const int Dim> class cSegment
        cSegment(const tPt& aP1,const tPt& aP2);
        /// Estimate fonc linear, with gradient paral to tangent,  given value in P1 and P2, will be F(Q) =  R.first + R.second Q
        void CompileFoncLinear(Type & aVal,tPt & aVec,const Type  &aV1,const Type  & aV2) const;
-       const tPt&  P1() const; ///< Accessor
-       const tPt&  P2() const; ///< Accessor
-       tPt&  P1() ; ///< Accessor
-       tPt&  P2() ; ///< Accessor
+       const tPt&  P1() const {return mVPts.at(0);}   ; ///< Accessor
+       const tPt&  P2() const {return mVPts.at(1);}   ; ///< Accessor
+       tPt&  P1()  {return mVPts.at(0);}   ; ///< Accessor
+       tPt&  P2()  {return mVPts.at(1);}   ; ///< Accessor
        void  Swap(); ///< swap P1 P2 in place
+       const std::vector<tPt> &  VPts() const;
 
        tPt  V12() const;   ///<  Vector  P1->P2
        tPt  Middle() const;  ///<  P middle
 	/// Used for "generik" object that must describes its box
 	cTplBox<Type,Dim>  GetBoxEnglob() const;
     protected :
-       tPt  mP1;
-       tPt  mP2;
+       std::vector<tPt> mVPts;
+       // tPt  mP1;
+       // tPt  mP2;
 };
 
 template <class Type,const int Dim> class cSegmentCompiled : public cSegment<Type,Dim>