BckUp

Author: deseilligny

MMVII/include/MMVII_Ptxd.h

@@ -879,6 +879,7 @@ template <class Type,const int Dim> class cSegmentCompiled : public cSegment<Typ
        tPt  Proj(const tPt &) const;
        Type Dist(const tPt &) const; // dist to full line
        Type Abscissa(const tPt& aPt) const;
+       tPt  PtOfAbscissa(const Type & anAbsc) const;
 
        const Type & N2 () const;
        const tPt  & Tgt() const;

MMVII/src/Geoms/PtsBox.cpp

@@ -138,9 +138,17 @@ template <class Type,const int Dim> Type cSegmentCompiled<Type,Dim>::Abscissa(co
     return Scal(mTgt,aPt - this->mP1);
 }
 
+       // Type PtOfAbscissa(const Type & anAbsc) const;
+template <class Type,const int Dim> cPtxd<Type,Dim>  cSegmentCompiled<Type,Dim>::PtOfAbscissa(const Type & anAbsc) const
+{
+     return this->mP1 + mTgt * anAbsc; //  Type(Scal(mTgt,aPt-this->mP1)) ;
+}
+
+
 template <class Type,const int Dim> cPtxd<Type,Dim>  cSegmentCompiled<Type,Dim>::Proj(const tPt & aPt) const
 {
-     return this->mP1 + mTgt * Abscissa(aPt); //  Type(Scal(mTgt,aPt-this->mP1)) ;
+     //return this->mP1 + mTgt * Abscissa(aPt); //  Type(Scal(mTgt,aPt-this->mP1)) ;
+     return PtOfAbscissa(Abscissa(aPt));
 }
 
 template <class Type,const int Dim> Type  cSegmentCompiled<Type,Dim>::Dist(const tPt & aPt) const

MMVII/src/Mappings/cManifold.cpp

@@ -12,28 +12,136 @@ namespace MMVII
 template <const int DimM,const int DimE> class cManifold
 {
      public :
-        static const int DimC = DimE - DimM,
+        static const int DimC = DimE - DimM;
 
         typedef cPtxd<tREAL8,DimM>    tPtM;
         typedef cPtxd<tREAL8,DimE>    tPtE;
-        typedef std::array<tPtE,DimC> tTgSp;
+        typedef std::vector<tPtE>     tTgSp;
 
+
+	cManifold(int aNbMap=1,const tREAL8 aEpsDeriv = 1e-4);
+
+	/// return the num map of a point, defaults assume mNbMap==1
+	virtual int  GetNumMap(const tPtE &) const ;
         ///  Retun a point of manifold in embedding space kowning a parameter, default error
-        virtual  tPtE   PtOfParam(const tPtM &) const ;
+        virtual  tPtE   PtOfParam(const tPtM &,int aNumMap) const ;
         ///  "Inverse" of PtOfParam, Assuming tPtE is on manifold
-        virtual  tPtM   ParamOfPt(const tPtE &) const ;
+        virtual  std::pair<int,tPtM>   ParamOfPt(const tPtE &) const ;
 
         /// return TgSpace
-        virtual tTgSp  TgSpace(const tPtE &) const;
+        virtual tTgSp  TgSpace(const tPtE &) const ;
+        /// Given a point, gives an approximate value of the projection
+        virtual tPtE  ApproxProj(const tPtE &) const  ;
+	///
+        virtual tPtE  Proj(const tPtE &) const  ;
      private :
+	int     mNbMap;
+	tREAL8  mEpsDeriv;
 };
 
+template <const int DimM,const int DimE>  
+   cManifold<DimM,DimE>::cManifold(int aNbMap,const tREAL8 aEpsDeriv) :
+      mNbMap    (aNbMap),
+      mEpsDeriv (aEpsDeriv)
+{
+}
+
+template <const int DimM,const int DimE>  int  cManifold<DimM,DimE>::GetNumMap(const tPtE &) const 
+{
+    MMVII_INTERNAL_ASSERT_tiny(mNbMap==1,"cCurveFromMapping->aNumMap");
+    return 0;
+}
+
+template <const int DimM,const int DimE> cPtxd<tREAL8,DimE>  cManifold<DimM,DimE>::PtOfParam(const tPtM&,int)  const
+{
+   MMVII_INTERNAL_ERROR("No def cManifold<DimM,DimE>::PtOfParam");
+   return tPtE();
+}
+
+template <const int DimM,const int DimE> std::pair<int,cPtxd<tREAL8,DimM>>  cManifold<DimM,DimE>::ParamOfPt(const tPtE&)  const
+{
+   MMVII_INTERNAL_ERROR("No def cManifold<DimM,DimE>::ParamOfPt");
+   return std::pair<int,tPtM>(0,tPtM());
+}
 
 
+template <const int DimM,const int DimE> 
+  typename cManifold<DimM,DimE>::tTgSp  cManifold<DimM,DimE>::TgSpace(const tPtE & aPE)const 
+{
+   tTgSp aRes;
+   auto [aNum,aPParam] = ParamOfPt(aPE);
+
+   for (int aKM=0 ; aKM<DimM ; aKM++)
+   {
+       tPtM aDelta = tPtM::P1Coord(aKM,mEpsDeriv);
+       tPtE aPPlus = PtOfParam(aPParam+aDelta,aNum);
+       tPtE aPMinus = PtOfParam(aPParam-aDelta,aNum);
+       tPtE aTgt = (aPPlus-aPMinus) / (2*mEpsDeriv) ;
+
+       // make some "on the fly" orthogonalization
+       for (const auto & aPrec : aRes)
+       {
+           aTgt = aTgt - aPrec* Scal(aPrec,aTgt);
+       }
+
+       aRes.push_back(VUnit(aTgt));
+   }
+
+   return aRes;
+}
+
 template class cManifold<1,2>; // curve 2d
 template class cManifold<1,3>; // curve 3d
 
 
+template<int DimE> class cCurveFromMapping : public cManifold<1,DimE>
+{
+     public :
+        // virtual  tPtE   PtOfParam(const tPtM &,int aNumMap) const ;
+        static const int DimM = 1;
+        static const int DimC = DimE - DimM;
+
+        typedef cPtxd<tREAL8,DimM>                  tPtM;
+        typedef cPtxd<tREAL8,DimE>                  tPtE;
+        typedef cSegmentCompiled<tREAL8,DimE>       tSeg;
+        typedef cDataInvertibleMapping<tREAL8,DimE> tMap;
+
+        tPtE   PtOfParam(const tPtM &,int aNumMap) const override;
+        std::pair<int,tPtM>   ParamOfPt(const tPtE &) const override;
+        tPtE  ApproxProj(const tPtE &) const  override ;
+     private :
+	tSeg   mSeg;
+	tMap   *mMap;
 
 };
 
+template<int DimE>  cPtxd<tREAL8,DimE> cCurveFromMapping<DimE>::PtOfParam(const tPtM & aP1,int aNumMap) const 
+{
+    MMVII_INTERNAL_ASSERT_tiny(aNumMap==0,"cCurveFromMapping->aNumMap");
+
+    tPtE aPtOnSeg = mSeg.PtOfAbscissa(aP1.x());
+
+    return mMap->Value(aPtOnSeg);
+}
+
+template<int DimE>  std::pair<int,cPtxd<tREAL8,1>> cCurveFromMapping<DimE>::ParamOfPt(const tPtE & aPE) const 
+{
+    tPtE aPOnSeg = mMap->Inverse(aPE);
+    return std::pair<int,tPtM>(0,tPtM(mSeg.Abscissa(aPOnSeg)));
+}
+
+
+template<int DimE>  cPtxd<tREAL8,DimE> cCurveFromMapping<DimE>::ApproxProj(const tPtE & aP1) const 
+{
+    tPtE aP2 = mMap->Value(aP1);
+    tPtE aP3 = mSeg.Proj(aP2);
+    return mMap->Inverse(aP3);
+}
+
+
+template class cCurveFromMapping<2>; // curve 2d
+template class cCurveFromMapping<3>; // curve 2d
+};
+
+
+