Merge branch 'MoreBezier'

EXE_GdbCreateCurve.cpp

@@ -2609,28 +2609,29 @@ MyCreateCurveBezierForm( int nParentId, int nCrvId)
    Vector3d vtExtr ;
    pCurve->GetExtrusion( vtExtr) ;
    vtExtr.LocToLoc( frCrv, frLoc) ;
-   int nType = pCurve->GetType() ;
-   PtrOwner<ICurve> pCrv ;
-   switch ( nType ) {
-   case CRV_LINE :
-      pCrv.Set( LineToBezierCurve( GetCurveLine( pCurve))) ;
-      break ;
-   case CRV_ARC :
-      pCrv.Set( ArcToBezierCurve( GetCurveArc( pCurve))) ;
-      break ;
-   case CRV_BEZIER :
-      pCrv.Set( BezierToBasicBezierCurve( GetCurveBezier( pCurve))) ;
-      break ;
-   case CRV_COMPO :
-      pCrv.Set( CompositeToBezierCurve( GetCurveComposite( pCurve))) ;
-      break ;
-   default :
-      break ;
-   }
+   PtrOwner<ICurve> pCrvBez ( CurveToBezierCurve( pCurve)) ;
+
+   //int nType = pCurve->GetType() ;
+   //switch ( nType ) {
+   //case CRV_LINE :
+   //   pCrvBez.Set( LineToBezierCurve( GetCurveLine( pCurve))) ;
+   //   break ;
+   //case CRV_ARC :
+   //   pCrvBez.Set( ArcToBezierCurve( GetCurveArc( pCurve))) ;
+   //   break ;
+   //case CRV_BEZIER :
+   //   pCrvBez.Set( BezierToBasicBezierCurve( GetCurveBezier( pCurve))) ;
+   //   break ;
+   //case CRV_COMPO :
+   //   pCrvBez.Set( CompositeToBezierCurve( GetCurveComposite( pCurve))) ;
+   //   break ;
+   //default :
+   //   break ;
+   //}
    // setto l'estrusione
-   pCrv->SetExtrusion( vtExtr) ;
+   pCrvBez->SetExtrusion( vtExtr) ;
    // aggiungo la curva in forma di Bezier al DB
-   int nId = pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pCrv)) ;
+   int nId = pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pCrvBez)) ;
    return nId ;
 }
 
@@ -2643,7 +2644,7 @@ ExeCreateCurveBezierForm( int nParentId, int nCrvId)
    ExeSetModified() ;
    // se richiesto, salvo il comando Lua equivalente
    if ( IsCmdLog()) {
-      string sLua = "EgtCreateCurveBezierForm(" + IdToString( nParentId) + "," +
+      string sLua = "EgtCurveBezierForm(" + IdToString( nParentId) + "," +
                      IdToString( nCrvId) + "," +
                      " -- Id=" + ToString( nId) ;
       LOG_INFO( GetCmdLogger(), sLua.c_str()) ;

EXE_GdbCreateSurf.cpp

@@ -35,6 +35,7 @@
 #include "/EgtDev/Include/EgtPointerOwner.h"
 #include "/EgtDev/Include/EGkExtText.h"
 #include "/EgtDev/Include/EGkSbzStandard.h"
+#include "/EgtDev/Include/EGkSbzFromCurves.h"
 
 using namespace std ;
 
@@ -1894,18 +1895,265 @@ ExeCreateBezierSphere( int nParentId, const Point3d& ptCenter, double dR, int nR
   // reucpero il punto in locale
    Point3d ptCenterLoc = GetPointLocal( pGeomDB, ptCenter, nRefType, frLoc) ;
   // Creo la superficie
-   PtrOwner<ISurfBezier> pSurfBez( CreateBezierSphere( ptCenterLoc, dR)) ;
+   PtrOwner<ISurfBezier> pSurfBez( GetSurfBezierSphere( ptCenterLoc, dR)) ;
    int nId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pSurfBez)) : GDB_ID_NULL) ;
    ExeSetModified() ;
    // se richiesto, salvo il comando Lua equivalente
    if ( IsCmdLog()) {
       string sLua = "EgtCreateBezierSphere(" + IdToString( nParentId) + "," +
-         ToString( ptCenter) + "," +
-         ToString( dR) + "," +
-         RefTypeToString( nRefType) + ")" +
-         " -- Id=" + ToString( nId) ;
+                                               ToString( ptCenter) + "," +
+                                               ToString( dR) + "," +
+                                               RefTypeToString( nRefType) + ")" +
+                                               " -- Id=" + ToString( nId) ;
       LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
    }
   // resituisco l'identificativo dell'entit� creata
    return nId ;
 }
+
+//-------------------------------------------------------------------------------
+int
+ExeCreateSurfBzByFlatContour( int nParentId, int nCrvId, double dLinTol)
+{
+   IGeomDB* pGeomDB = GetCurrGeomDB() ;
+   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
+   nParentId = AdjustId( nParentId) ;
+   bool bOk = true ;
+   // recupero il riferimento locale
+   Frame3d frLoc ;
+   bOk = bOk && pGeomDB->GetGroupGlobFrame( nParentId, frLoc) ;
+   // recupero la curva in locale
+   CurveLocal CrvLoc( pGeomDB, nCrvId, frLoc) ;
+   bOk = bOk && ( CrvLoc.Get() != nullptr) ;
+   // calcolo la superficie
+   ISurfBezier* pSbz = ( bOk ? GetSurfBezierByFlatContour( CrvLoc, dLinTol) : nullptr) ;
+   // inserisco la superficie nel DB
+   int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, pSbz) : GDB_ID_NULL) ;
+   ExeSetModified() ;
+   // se richiesto, salvo il comando Lua equivalente
+   if ( IsCmdLog()) {
+      string sLua = "EgtSurfBzByFlatContour(" + IdToString( nParentId) + "," +
+                                                ToString( nCrvId) + "," +
+                                                ToString( dLinTol) + ")" +
+                                                " -- Id=" + ToString( nNewId) ;
+      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
+   }
+   // restituisco l'identificativo della nuova entità
+   return nNewId ;
+}
+
+//-------------------------------------------------------------------------------
+int
+ExeCreateSurfBzByRegion( int nParentId, const INTVECTOR& vCrvIds, double dLinTol)
+{
+   IGeomDB* pGeomDB = GetCurrGeomDB() ;
+   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
+      nParentId = AdjustId( nParentId) ;
+   bool bOk = true ;
+   // recupero il riferimento locale
+   Frame3d frLoc ;
+   bOk = bOk && pGeomDB->GetGroupGlobFrame( nParentId, frLoc) ;
+   // recupero le curve in locale
+   CURVELOCALVECTOR vCrvLoc ;
+   vCrvLoc.reserve( vCrvIds.size()) ;
+   CICURVEPVECTOR vCrvP ;
+   vCrvP.reserve( vCrvIds.size()) ;
+   for ( size_t i = 0 ; i < vCrvIds.size() ; ++ i) {
+      int nId = (( vCrvIds[i] != GDB_ID_SEL) ? vCrvIds[i] : pGeomDB->GetFirstSelectedObj()) ;
+      while ( nId != GDB_ID_NULL) {
+         vCrvLoc.emplace_back( pGeomDB, nId, frLoc) ;
+         vCrvP.push_back( vCrvLoc.back().Get()) ;
+         bOk = bOk && ( vCrvLoc[i].Get() != nullptr) ;
+         // passo al successivo
+         nId = (( vCrvIds[i] != GDB_ID_SEL) ? GDB_ID_NULL : pGeomDB->GetNextSelectedObj()) ;
+      }
+   }
+   // calcolo la superficie
+   ISurfBezier* pSbz = ( bOk ? GetSurfBezierByRegion( vCrvP, dLinTol) : nullptr) ;
+   bOk = bOk && ( pSbz != nullptr) ;
+   // inserisco la superficie nel DB
+   int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, pSbz) : GDB_ID_NULL) ;
+   ExeSetModified() ;
+   // se richiesto, salvo il comando Lua equivalente
+   if ( IsCmdLog()) {
+      string sLua = "EgtSurfBzByRegion(" + IdToString( nParentId) + ",{" +
+                                           IdListToString( vCrvIds) + "}," +
+                                           ToString( dLinTol) + ")" +
+                                           " -- Id=" + ToString( nNewId) ;
+      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
+   }
+   // restituisco l'identificativo della nuova entità
+   return nNewId ;
+}
+
+//-------------------------------------------------------------------------------
+int
+ExeCreateSurfBzByExtrusion( int nParentId, const INTVECTOR& vCrvIds, const Vector3d& vtExtr,
+                            double dLinTol, int nRefType)
+{
+   IGeomDB* pGeomDB = GetCurrGeomDB() ;
+   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
+      nParentId = AdjustId( nParentId) ;
+   bool bOk = true ;
+   // recupero il riferimento locale
+   Frame3d frLoc ;
+   bOk = bOk && pGeomDB->GetGroupGlobFrame( nParentId, frLoc) ;
+   // recupero le curve in locale
+   CURVELOCALVECTOR vCrvLoc ;
+   vCrvLoc.reserve( vCrvIds.size()) ;
+   ICURVEPVECTOR vCrvP ;
+   vCrvP.reserve( vCrvIds.size()) ;
+   for ( size_t i = 0 ; i < vCrvIds.size() ; ++ i) {
+      int nId = (( vCrvIds[i] != GDB_ID_SEL) ? vCrvIds[i] : pGeomDB->GetFirstSelectedObj()) ;
+      while ( nId != GDB_ID_NULL) {
+         vCrvLoc.emplace_back( pGeomDB, nId, frLoc) ;
+         vCrvP.push_back( const_cast<ICurve*>( vCrvLoc.back().Get())) ;
+         bOk = bOk && ( vCrvLoc[i].Get() != nullptr) ;
+         // passo al successivo
+         nId = (( vCrvIds[i] != GDB_ID_SEL) ? GDB_ID_NULL : pGeomDB->GetNextSelectedObj()) ;
+      }
+   }
+   // porto in locale il vettore estrusione
+   Vector3d vtExtrL = GetVectorLocal( pGeomDB, vtExtr, nRefType, frLoc) ;
+   // creo le superfici e le inserisco nel DB
+   int nFirstId = GDB_ID_NULL ;
+   for ( int i = 0 ; i < int( vCrvP.size()) ; ++ i) {
+      // calcolo la superficie
+      ISurfBezier* pSbz = ( bOk ? GetSurfBezierByExtrusion( vCrvP[i], vtExtrL, false, dLinTol) : nullptr) ;
+      // inserisco la superficie nel DB
+      int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, pSbz) : GDB_ID_NULL) ;
+      bOk = bOk && ( nNewId != GDB_ID_NULL) ;
+      if ( bOk  &&  nFirstId == GDB_ID_NULL)
+         nFirstId = nNewId ;
+   }
+   ExeSetModified() ;
+   // se richiesto, salvo il comando Lua equivalente
+   if ( IsCmdLog()) {
+      string sLua = "EgtSurfBzByExtrusion(" + IdToString( nParentId) + ",{" +
+                                              IdListToString( vCrvIds) + "},{" +
+                                              ToString( vtExtr) + "}," +
+                                              ToString( dLinTol) + "," +
+                                              RefTypeToString( nRefType) + ")" +
+                                              " -- Id=" + ToString( nFirstId) ;
+      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
+   }
+   // restituisco l'identificativo della nuova entità
+   return nFirstId ;
+}
+
+//-------------------------------------------------------------------------------
+int
+ExeCreateSurfBzByScrewing( int nParentId, int nCrvId,
+                           const Point3d& ptAx, const Vector3d& vtAx,
+                           double dAngRotDeg, double dMove, bool bCapEnds, double dLinTol, int nRefType)
+{
+   IGeomDB* pGeomDB = GetCurrGeomDB() ;
+   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
+   nParentId = AdjustId( nParentId) ;
+   bool bOk = true ;
+   // recupero il riferimento locale
+   Frame3d frLoc ;
+   bOk = bOk && pGeomDB->GetGroupGlobFrame( nParentId, frLoc) ;
+   // recupero la curva in locale
+   CurveLocal CrvLoc( pGeomDB, nCrvId, frLoc) ;
+   bOk = bOk && ( CrvLoc.Get() != nullptr) ;
+   // porto in locale punto e vettore asse
+   Point3d ptAxL = GetPointLocal( pGeomDB, ptAx, nRefType, frLoc) ;
+   Vector3d vtAxL = GetVectorLocal( pGeomDB, vtAx, nRefType, frLoc) ;
+   // calcolo la superficie
+   ISurfBezier* pSbz = ( bOk ? GetSurfBezierByScrewing( CrvLoc, ptAxL, vtAxL, dAngRotDeg, dMove, bCapEnds, dLinTol) : nullptr) ;
+   // inserisco la superficie nel DB
+   int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, pSbz) : GDB_ID_NULL) ;
+   ExeSetModified() ;
+   // se richiesto, salvo il comando Lua equivalente
+   if ( IsCmdLog()) {
+      string sLua = "EgtSurfbzByScrewing(" + IdToString( nParentId) + "," +
+                                             ToString( nCrvId) + ",{" +
+                                             ToString( ptAx) + "},{" +
+                                             ToString( vtAx) + "}," +
+                                             ToString( dAngRotDeg) + "," +
+                                             ToString( dMove) + "," +
+                                             ( bCapEnds ? "true" : "false") + "," +
+                                             ToString( dLinTol) + "," +
+                                             RefTypeToString( nRefType) + ")" +
+                                             " -- Id=" + ToString( nNewId) ;
+      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
+   }
+   // restituisco l'identificativo della nuova entità
+   return nNewId ;
+}
+
+//-------------------------------------------------------------------------------
+int
+ExeCreateSurfBzByRevolve( int nParentId, int nCrvId,
+                           const Point3d& ptAx, const Vector3d& vtAx,
+                           bool bCapEnds, double dLinTol, int nRefType)
+{
+   IGeomDB* pGeomDB = GetCurrGeomDB() ;
+   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
+   nParentId = AdjustId( nParentId) ;
+   bool bOk = true ;
+   // recupero il riferimento locale
+   Frame3d frLoc ;
+   bOk = bOk && pGeomDB->GetGroupGlobFrame( nParentId, frLoc) ;
+   // recupero la curva in locale
+   CurveLocal CrvLoc( pGeomDB, nCrvId, frLoc) ;
+   bOk = bOk && ( CrvLoc.Get() != nullptr) ;
+   // porto in locale punto e vettore asse
+   Point3d ptAxL = GetPointLocal( pGeomDB, ptAx, nRefType, frLoc) ;
+   Vector3d vtAxL = GetVectorLocal( pGeomDB, vtAx, nRefType, frLoc) ;
+   // calcolo la superficie
+   ISurfBezier* pSbz = ( bOk ? GetSurfBezierByRevolve( CrvLoc, ptAxL, vtAxL, bCapEnds, dLinTol) : nullptr) ;
+   // inserisco la superficie nel DB
+   int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, pSbz) : GDB_ID_NULL) ;
+   ExeSetModified() ;
+   // se richiesto, salvo il comando Lua equivalente
+   if ( IsCmdLog()) {
+      string sLua = "EgtSurfbzByScrewing(" + IdToString( nParentId) + "," +
+                                             ToString( nCrvId) + ",{" +
+                                             ToString( ptAx) + "},{" +
+                                             ToString( vtAx) + "}," +
+                                             ( bCapEnds ? "true" : "false") + "," +
+                                             ToString( dLinTol) + "," +
+                                             RefTypeToString( nRefType) + ")" +
+                                             " -- Id=" + ToString( nNewId) ;
+      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
+   }
+   // restituisco l'identificativo della nuova entità
+   return nNewId ;
+}
+
+//-------------------------------------------------------------------------------
+int
+ExeCreateSurfBzRuled( int nParentId, int nCrvId1, int nCrvId2, int nRuledType, double dLinTol)
+{
+   IGeomDB* pGeomDB = GetCurrGeomDB() ;
+   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
+   nParentId = AdjustId( nParentId) ;
+   bool bOk = true ;
+   // recupero il riferimento locale
+   Frame3d frLoc ;
+   bOk = bOk && pGeomDB->GetGroupGlobFrame( nParentId, frLoc) ;
+   // recupero le curve in locale
+   CurveLocal CrvLoc1( pGeomDB, nCrvId1, frLoc) ;
+   bOk = bOk && ( CrvLoc1.Get() != nullptr) ;
+   CurveLocal CrvLoc2( pGeomDB, nCrvId2, frLoc) ;
+   bOk = bOk && ( CrvLoc2.Get() != nullptr) ;
+   // calcolo la superficie
+   ISurfBezier* pSbz = ( bOk ? GetSurfBezierRuled( CrvLoc1, CrvLoc2, nRuledType, dLinTol) : nullptr) ;
+   // inserisco la superficie nel DB
+   int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, pSbz) : GDB_ID_NULL) ;
+   ExeSetModified() ;
+   // se richiesto, salvo il comando Lua equivalente
+   if ( IsCmdLog()) {
+      string sLua = "EgtSurfbzByScrewing(" + IdToString( nParentId) + "," +
+                                             ToString( nCrvId1) + "," +
+                                             ToString( nCrvId2) + "," +
+                                             ToString( nRuledType) + "," +
+                                             ToString( dLinTol) + ")" +
+                                             " -- Id=" + ToString( nNewId) ;
+      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
+   }
+   // restituisco l'identificativo della nuova entità
+   return nNewId ;
+}

EXE_GdbGetCurve.cpp

@@ -20,6 +20,7 @@
 #include "/EgtDev/Include/EXeExecutor.h"
 #include "/EgtDev/Include/EXeConst.h"
 #include "/EgtDev/Include/EGkGeoPoint3d.h"
+#include "/EgtDev/Include/EGkGeoPoint3d.h"
 #include "/EgtDev/Include/EGkCurve.h"
 #include "/EgtDev/Include/EGkCurveArc.h"
 #include "/EgtDev/Include/EGkCurveBezier.h"
@@ -177,7 +178,7 @@ ExeCurveIsFlat( int nId, Plane3d& Plane, bool bUseExtrusion, double dToler)
       return false ;
   // recupero la curva
    ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ;
-  // ne verifico la planarità
+  // ne verifico la planarit�
    return ( pCurve != nullptr  &&  pCurve->IsFlat( Plane, bUseExtrusion, dToler)) ;
 }
 
@@ -307,7 +308,7 @@ ExeCurveNearestExtremityToPoint( int nId, const Point3d& ptP, bool& bStart)
    VERIFY_GEOMDB( pGeomDB, false)
   // recupero la curva
    ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ;
-  // recupero quale estremo è più vicino al punto
+  // recupero quale estremo � pi� vicino al punto
    return ( pCurve != nullptr  &&  pCurve->GetNearestExtremityToPoint( ptP, bStart)) ;
 }
 
@@ -383,7 +384,7 @@ ExeCurveMinAreaRectangleXY( int nId, int nRefId, Frame3d& frRect, double& dDimX,
       PL.LocToLoc( frCrv, pGeomDB->GetGridFrame()) ;
    else if ( bOk  &&  nRefId != nId) {
       Frame3d frDest ;
-     // nRefId può essere un gruppo o una entità
+     // nRefId pu� essere un gruppo o una entit�
       if ( pGeomDB->GetGroupGlobFrame( nRefId, frDest)  ||
            pGeomDB->GetGlobFrame( nRefId, frDest))
          PL.LocToLoc( frCrv, frDest) ;

EXE_GdbGetSurf.cpp

@@ -1723,4 +1723,37 @@ ExeExtractSurfBezierLoops( int nId, int nDestGrpId, int* pnCount)
    if ( pnCount != nullptr)
       *pnCount = nCount ;
    return nFirstId ;
+}
+
+//----------------------------------------------------------------------------
+int
+ExeShowSurfBezierControlPoints( int nSrfId, int* pnCount)
+{
+   IGeomDB* pGeomDB = GetCurrGeomDB() ;
+   VERIFY_GEOMDB( pGeomDB, false)
+   int nParent = pGeomDB->GetParentId( nSrfId) ;
+   // recupero la superficie di bezier
+   IGeoObj* pGeoObj = pGeomDB->GetGeoObj( nSrfId) ;
+   if ( pGeoObj->GetType() != SRF_BEZIER)
+      return GDB_ID_NULL ;
+   int nDegU = - 1, nDegV = - 1, nSpanU = - 1, nSpanV = - 1 ;
+   bool bRat = false, bTrimmed = false ;
+   ISurfBezier* pSrfBez = GetSurfBezier( pGeoObj) ;
+   pSrfBez->GetInfo( nDegU, nDegV, nSpanU, nSpanV, bRat, bTrimmed) ;
+   int nFirstId = -1 ;
+   int nCount = 0 ;
+   for ( int i = 0 ; i < (nDegU * nSpanU + 1) * ( nDegV * nSpanV + 1) ; ++i) {
+      bool bOk = true ;
+      IGeoPoint3d* pGeoPt( CreateGeoPoint3d()) ;
+      pGeoPt->Set( pSrfBez->GetControlPoint( i, &bOk)) ;
+      int nId = pGeomDB->AddGeoObj( GDB_ID_NULL, nParent, pGeoPt) ;
+      if ( nFirstId == GDB_ID_NULL)
+         nFirstId = nId ;
+      if ( nId != GDB_ID_NULL)
+         ++nCount ;
+   }
+   // restituisco i risultati
+   if ( pnCount != nullptr)
+      *pnCount = nCount ;
+   return nFirstId ;
 }

EXE_GdbModifyCurve.cpp

@@ -2911,3 +2911,84 @@ ExeCurveGetFatCurve( int nId, int nDestGrpId, double dRad, bool bSquareEnds, boo
       *pnCount = nCount ;
    return nFirstId ;
 }
+
+//----------------------------------------------------------------------------
+bool
+ExeCurveBezierIncreaseDegree( int nCrvId) 
+{
+   IGeomDB* pGeomDB = GetCurrGeomDB() ;
+   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
+   // recupero la curva
+   const ICurve* pCrv = GetCurve( pGeomDB->GetGeoObj( nCrvId)) ;
+   if ( pCrv == nullptr)
+      return GDB_ID_NULL ;
+   //// recupero il riferimento della curva
+   //Frame3d frCrv ;
+   //if ( ! pGeomDB->GetGlobFrame( nCrvId, frCrv))
+   //   return GDB_ID_NULL ;
+
+   if( pCrv->GetType() != CRV_BEZIER)
+      return false ;
+
+   // aumento il grado della curva
+   bool bOk = true ;
+   PtrOwner<ICurveBezier> pCrvBezierNew ( BezierIncreaseDegree( GetCurveBezier( pCrv))) ;
+   Vector3d vtExtr ;
+   if ( bOk && pCrv->GetExtrusion( vtExtr))
+      pCrvBezierNew->SetExtrusion( vtExtr) ;
+   double dThick = 0 ;
+   if ( bOk  &&  pCrv->GetThickness( dThick))
+      pCrvBezierNew->SetThickness(dThick) ;
+   // sostituisco la vecchia curva con la nuova
+   bOk = bOk && pGeomDB->ReplaceGeoObj( nCrvId, Release( pCrvBezierNew)) ;
+   ExeSetModified() ;
+
+   if ( IsCmdLog()) {
+      string sLua = "EgtCurveBezierIncreaseDegree(" + ToString( nCrvId) + ")"
+                     " -- Ok=" + ToString( bOk) ;
+      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
+   }
+
+   return bOk ;
+}
+
+//----------------------------------------------------------------------------
+bool
+ExeCurveBezierDecreaseDegree( int nCrvId, double dTol) 
+{
+   IGeomDB* pGeomDB = GetCurrGeomDB() ;
+   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
+   // recupero la curva
+   const ICurve* pCrv = GetCurve( pGeomDB->GetGeoObj( nCrvId)) ;
+   if ( pCrv == nullptr)
+      return GDB_ID_NULL ;
+   //// recupero il riferimento della curva
+   //Frame3d frCrv ;
+   //if ( ! pGeomDB->GetGlobFrame( nCrvId, frCrv))
+   //   return GDB_ID_NULL ;
+
+   if( pCrv->GetType() != CRV_BEZIER)
+      return false ;
+
+   // riduco il grado della curva
+   bool bOk = true ;
+   PtrOwner<ICurveBezier> pCrvBezierNew ( BezierDecreaseDegree( GetCurveBezier( pCrv), dTol)) ;
+   bOk = bOk  &&  ! IsNull( pCrvBezierNew)  &&  pCrvBezierNew->IsValid() ;
+   Vector3d vtExtr ;
+   if ( bOk && pCrv->GetExtrusion( vtExtr))
+      pCrvBezierNew->SetExtrusion( vtExtr) ;
+   double dThick = 0 ;
+   if ( bOk  &&  pCrv->GetThickness( dThick))
+      pCrvBezierNew->SetThickness(dThick) ;
+   // sostituisco la vecchia curva con la nuova
+   bOk = bOk && pGeomDB->ReplaceGeoObj( nCrvId, Release( pCrvBezierNew)) ;
+   ExeSetModified() ;
+
+   if ( IsCmdLog()) {
+      string sLua = "EgtCurveBezierDecreaseDegree(" + ToString( nCrvId) + ")"
+                    " -- Ok=" + ToString( bOk) ;
+      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
+   }
+
+   return bOk ;
+}

LUA_GdbCreateSurf.cpp

@@ -977,6 +977,213 @@ LuaCreateBezierSphere( lua_State* L)
    return 2 ;
 }
 
+//-------------------------------------------------------------------------------
+static int
+LuaCreateSurfBzByFlatContour( lua_State* L)
+{
+   // 2 o 3 parametri : ParentId, CrvId [, dTol]
+   int nParentId ;
+   LuaCheckParam( L, 1, nParentId)
+   int nCrvId ;
+   LuaCheckParam( L, 2, nCrvId)
+   double dLinTol = LIN_TOL_SRF ;
+   if ( lua_gettop( L) >= 3)
+      LuaCheckParam( L, 3, dLinTol) ;
+   LuaClearStack( L) ;
+   // creo Sbz piana e la trimmo con il contorno
+   int nId = ExeCreateSurfBzByFlatContour( nParentId, nCrvId, dLinTol) ;
+   // restituisco il risultato
+   if ( nId != GDB_ID_NULL)
+      LuaSetParam( L, nId) ;
+   else
+      LuaSetParam( L) ;
+   return 1 ;
+}
+
+//-------------------------------------------------------------------------------
+static int
+LuaCreateSurfBzByRegion( lua_State* L)
+{
+   // 2 o 3 parametri : ParentId, CrvIds [, dTol]
+   int nParentId ;
+   LuaCheckParam( L, 1, nParentId)
+      INTVECTOR vCrvIds ;
+   LuaCheckParam( L, 2, vCrvIds)
+      double dLinTol = LIN_TOL_SRF ;
+   if ( lua_gettop( L) >= 3)
+      LuaCheckParam( L, 3, dLinTol) ;
+   LuaClearStack( L) ;
+   // creo una Sbz piana a cui aggiungo le curve come trim
+   int nId = ExeCreateSurfBzByRegion( nParentId, vCrvIds, dLinTol) ;
+   // restituisco il risultato
+   if ( nId != GDB_ID_NULL)
+      LuaSetParam( L, nId) ;
+   else
+      LuaSetParam( L) ;
+   return 1 ;
+}
+
+
+//-------------------------------------------------------------------------------
+static int
+LuaCreateSurfBzByExtrusion( lua_State* L)
+{
+   // 3 o 4 o 5 parametri : ParentId, CrvIds, vtExtr [, dTol] [, nRefType]
+   int nParentId ;
+   LuaCheckParam( L, 1, nParentId)
+   INTVECTOR vCrvIds ;
+   LuaCheckParam( L, 2, vCrvIds)
+   Vector3d vtExtr ;
+   LuaCheckParam( L, 3, vtExtr)
+   double dLinTol = LIN_TOL_SRF ;
+   int nRefType = RTY_DEFAULT ;
+   if ( LuaGetParam( L, 4, dLinTol))
+      LuaGetParam( L, 5, nRefType) ;
+   else
+      LuaGetParam( L, 4, nRefType) ;
+   LuaClearStack( L) ;
+   // creo STM estrudendo uno o più percorsi, se piani si possono mettere i tappi
+   int nId = ExeCreateSurfBzByExtrusion( nParentId, vCrvIds, vtExtr, dLinTol, nRefType) ;
+   // restituisco il risultato
+   if ( nId != GDB_ID_NULL)
+      LuaSetParam( L, nId) ;
+   else
+      LuaSetParam( L) ;
+   return 1 ;
+}
+
+//-------------------------------------------------------------------------------
+static int
+LuaCreateSurfBzByScrewing( lua_State* L)
+{
+   // 6 o 7 o 8 o 9 parametri : ParentId, CrvId, ptAx, vtAx, dAngRotDeg, dMove [, bCapEnds] [, dTol] [, nRefType]
+   int nParentId ;
+   LuaCheckParam( L, 1, nParentId)
+      int nCrvId ;
+   LuaCheckParam( L, 2, nCrvId)
+      Point3d ptAx ;
+   LuaCheckParam( L, 3, ptAx)
+      Vector3d vtAx ;
+   LuaCheckParam( L, 4, vtAx)
+      double dAngRotDeg ;
+   LuaCheckParam( L, 5, dAngRotDeg)
+      double dMove ;
+   LuaCheckParam( L, 6, dMove)
+      int nPar = 7 ;
+   bool bCapEnds = false ;
+   if ( LuaGetParam( L, nPar, bCapEnds))
+      ++ nPar ;
+   double dLinTol = LIN_TOL_SRF ;
+   if ( LuaGetParam( L, nPar, dLinTol))
+      ++ nPar ;
+   int nRefType = RTY_DEFAULT ;
+   if ( LuaGetParam( L, nPar, nRefType))
+      ++ nPar ;
+   LuaClearStack( L) ;
+   // creo STM riempiendo un contorno piano
+   int nId = ExeCreateSurfBzByScrewing( nParentId, nCrvId, ptAx, vtAx, dAngRotDeg, dMove, bCapEnds, dLinTol, nRefType) ;
+   // restituisco il risultato
+   if ( nId != GDB_ID_NULL)
+      LuaSetParam( L, nId) ;
+   else
+      LuaSetParam( L) ;
+   return 1 ;
+}
+
+//-------------------------------------------------------------------------------
+static int
+LuaCreateSurfBzByRevolve( lua_State* L)
+{
+   // 4 o 5 o 6 o 7 parametri : ParentId, CrvId, ptAx, vtAx [, bCapEnds] [, dTol] [, nRefType]
+   int nParentId ;
+   LuaCheckParam( L, 1, nParentId)
+   int nCrvId ;
+   LuaCheckParam( L, 2, nCrvId)
+   Point3d ptAx ;
+   LuaCheckParam( L, 3, ptAx)
+   Vector3d vtAx ;
+   LuaCheckParam( L, 4, vtAx)
+   int nPar = 5 ;
+   bool bCapEnds = false ;
+   if ( LuaGetParam( L, nPar, bCapEnds))
+      ++ nPar ;
+   double dLinTol = LIN_TOL_SRF ;
+   if ( LuaGetParam( L, nPar, dLinTol))
+      ++ nPar ;
+   int nRefType = RTY_DEFAULT ;
+   if ( LuaGetParam( L, nPar, nRefType))
+      ++ nPar ;
+   LuaClearStack( L) ;
+   // creo STM riempiendo un contorno piano
+   int nId = ExeCreateSurfBzByRevolve( nParentId, nCrvId, ptAx, vtAx, bCapEnds, dLinTol, nRefType) ;
+   // restituisco il risultato
+   if ( nId != GDB_ID_NULL)
+      LuaSetParam( L, nId) ;
+   else
+      LuaSetParam( L) ;
+   return 1 ;
+}
+
+//-------------------------------------------------------------------------------
+static int
+LuaCreateSurfBzByPointCurve( lua_State* L)
+{
+   // 4 o 5 o 6 o 7 parametri : ParentId, CrvId, ptAx, vtAx [, bCapEnds] [, dTol] [, nRefType]
+   int nParentId ;
+   LuaCheckParam( L, 1, nParentId)
+   int nCrvId ;
+   LuaCheckParam( L, 2, nCrvId)
+   Point3d ptAx ;
+   LuaCheckParam( L, 3, ptAx)
+   Vector3d vtAx ;
+   LuaCheckParam( L, 4, vtAx)
+   int nPar = 5 ;
+   bool bCapEnds = false ;
+   if ( LuaGetParam( L, nPar, bCapEnds))
+      ++ nPar ;
+   double dLinTol = LIN_TOL_SRF ;
+   if ( LuaGetParam( L, nPar, dLinTol))
+      ++ nPar ;
+   int nRefType = RTY_DEFAULT ;
+   if ( LuaGetParam( L, nPar, nRefType))
+      ++ nPar ;
+   LuaClearStack( L) ;
+   // creo STM riempiendo un contorno piano
+   int nId = ExeCreateSurfBzByRevolve( nParentId, nCrvId, ptAx, vtAx, bCapEnds, dLinTol, nRefType) ;
+   // restituisco il risultato
+   if ( nId != GDB_ID_NULL)
+      LuaSetParam( L, nId) ;
+   else
+      LuaSetParam( L) ;
+   return 1 ;
+}
+
+//-------------------------------------------------------------------------------
+static int
+LuaCreateSurfBzRuled( lua_State* L)
+{
+   // 4 o 5 parametri : ParentId, CrvId1, CrvId2, nRuledType [, dTol]
+   int nParentId ;
+   LuaCheckParam( L, 1, nParentId)
+   int nCrvId1 ;
+   LuaCheckParam( L, 2, nCrvId1)
+   int nCrvId2 ;
+   LuaCheckParam( L, 3, nCrvId2)
+   int nRuledType ;
+   LuaCheckParam( L, 4, nRuledType)
+   double dLinTol = LIN_TOL_SRF ;
+   LuaGetParam( L, 5, dLinTol) ;
+   LuaClearStack( L) ;
+   // creo STM riempiendo un contorno piano
+   int nId = ExeCreateSurfBzRuled( nParentId, nCrvId1, nCrvId2, nRuledType, dLinTol) ;
+   // restituisco il risultato
+   if ( nId != GDB_ID_NULL)
+      LuaSetParam( L, nId) ;
+   else
+      LuaSetParam( L) ;
+   return 1 ;
+}
+
 //-------------------------------------------------------------------------------
 bool
 LuaInstallGdbCreateSurf( LuaMgr& luaMgr)
@@ -1015,6 +1222,12 @@ LuaInstallGdbCreateSurf( LuaMgr& luaMgr)
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfBezierRat", LuaCreateSurfBezierRational) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfBezierLeaves", LuaCreateSurfBezierLeaves) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfBezierTria2D", LuaCreateSurfBezierTria2D) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtCreateBezierSphere", LuaCreateBezierSphere) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfBzSphere", LuaCreateBezierSphere) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfBzByFlatContour", LuaCreateSurfBzByFlatContour) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfBzByRegion", LuaCreateSurfBzByRegion) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfBzByExtrusion", LuaCreateSurfBzByExtrusion) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfBzByScrewing", LuaCreateSurfBzByScrewing) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfBzByRevolve", LuaCreateSurfBzByRevolve) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfBzRuled", LuaCreateSurfBzRuled) ;
    return bOk ;
 }

LUA_GdbGetCurve.cpp

@@ -161,7 +161,7 @@ LuaCurveIsACircle( lua_State* L)
    double dToler = EPS_SMALL ;
    LuaGetParam( L, 2, dToler) ;
    LuaClearStack( L) ;
-  // verifico se curva è equivalente ad una circonferenza
+  // verifico se curva � equivalente ad una circonferenza
    Point3d ptCen ;
    Vector3d vtN ;
    double dRad ;
@@ -185,7 +185,7 @@ LuaCurveIsARectangle( lua_State* L)
    double dToler = EPS_SMALL ;
    LuaGetParam( L, 2, dToler) ;
    LuaClearStack( L) ;
-  // verifico se curva è equivalente ad un rettangolo
+  // verifico se curva � equivalente ad un rettangolo
    Point3d ptP ;
    Vector3d vtL1 ;
    Vector3d vtL2 ;
@@ -207,7 +207,7 @@ LuaCurveIsATrapezoid( lua_State* L)
    double dToler = EPS_SMALL ;
    LuaGetParam( L, 2, dToler) ;
    LuaClearStack( L) ;
-  // verifico se curva è equivalente ad un trapezio
+  // verifico se curva � equivalente ad un trapezio
    Point3d ptP ;
    Vector3d vtB1 ;
    Vector3d vtL1 ;
@@ -586,7 +586,7 @@ LuaCurveCompoGetTempParam( lua_State* L)
 
 //----------------------------------------------------------------------------
 static int
-LuaShowCurveBezierControlPoint( lua_State* L)
+LuaShowCurveBezierControlPoints( lua_State* L)
 {
    // 1 parametro : nCrvId
    int nCrvId ;
@@ -640,6 +640,6 @@ LuaInstallGdbGetCurve( LuaMgr& luaMgr)
    bOk = bOk && luaMgr.RegisterFunction( "EgtCurveCompoNormVersor", LuaCurveCompoNormVersor) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtCurveCompoGetTempProp", LuaCurveCompoGetTempProp) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtCurveCompoGetTempParam", LuaCurveCompoGetTempParam) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtShowCurveBezierControlPoints", LuaShowCurveBezierControlPoint) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtShowCurveBezierControlPoints", LuaShowCurveBezierControlPoints) ;
    return bOk ;
 }

LUA_GdbGetSurf.cpp

@@ -1188,6 +1188,28 @@ LuaExtractSurfBezierLoops( lua_State* L)
    return 2 ;
 }
 
+//----------------------------------------------------------------------------
+static int
+LuaShowSurfBezierControlPoints( lua_State* L)
+{
+   // 1 parametro : nCrvId
+   int nCrvId ;
+   LuaCheckParam( L, 1, nCrvId)
+      LuaClearStack( L) ;
+   int nCount = 0 ;
+   int nId = ExeShowSurfBezierControlPoints( nCrvId, &nCount) ;
+   // restituisco il risultato
+   if ( nId != GDB_ID_NULL) {
+      LuaSetParam( L, nId) ;
+      LuaSetParam( L, nCount) ;  
+   }
+   else {
+      LuaSetParam( L) ;
+      LuaSetParam( L) ;
+   }
+   return 2 ;
+}
+
 //-------------------------------------------------------------------------------
 bool
 LuaInstallGdbGetSurf( LuaMgr& luaMgr)
@@ -1242,5 +1264,6 @@ LuaInstallGdbGetSurf( LuaMgr& luaMgr)
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfBezierGetControlCurveU", LuaSurfBezierGetControlCurveU) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfBezierGetControlCurveV", LuaSurfBezierGetControlCurveV) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtExtractSurfBezierLoops", LuaExtractSurfBezierLoops) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtShowSurfBezierControlPoints", LuaShowSurfBezierControlPoints) ;
    return bOk ;
 }

LUA_GdbModifyCurve.cpp

@@ -1165,6 +1165,38 @@ LuaCurveGetFatCurve( lua_State* L)
    return 2 ;
 }
 
+//----------------------------------------------------------------------------
+static int
+LuaCurveBezierIncreaseDegree( lua_State* L)
+{
+   // 1 parametro : CrvId
+   int nId ;
+   LuaCheckParam( L, 1, nId)
+   LuaClearStack( L) ;
+   // eseguo
+   int nCount = 0 ;
+   bool bOk = ExeCurveBezierIncreaseDegree( nId) ;
+   LuaSetParam( L, bOk) ;
+
+   return 1 ;
+}
+
+//----------------------------------------------------------------------------
+static int
+LuaCurveBezierDecreaseDegree( lua_State* L)
+{
+   // 1 parametro : CrvId
+   int nId ;
+   LuaCheckParam( L, 1, nId)
+   LuaClearStack( L) ;
+   // eseguo
+   int nCount = 0 ;
+   bool bOk = ExeCurveBezierDecreaseDegree( nId) ;
+   LuaSetParam( L, bOk) ;
+
+   return 1 ;
+}
+
 //-------------------------------------------------------------------------------
 bool
 LuaInstallGdbModifyCurve( LuaMgr& luaMgr)
@@ -1229,5 +1261,7 @@ LuaInstallGdbModifyCurve( LuaMgr& luaMgr)
    bOk = bOk && luaMgr.RegisterFunction( "EgtCurveGetFatCurve", LuaCurveGetFatCurve) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtProjectCurveOnSurfBz", LuaProjectCurveOnSurfBz) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtProjectCurveOnSurfBzExt", LuaProjectCurveOnSurfBzExt) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtCurveBezierIncreaseDeg", LuaCurveBezierIncreaseDegree) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtCurveBezierDecreaseDeg", LuaCurveBezierDecreaseDegree) ;
    return bOk ;
 }