EgtExchange/BtlGeom.cpp

//----------------------------------------------------------------------------
//  EgalTech 2015-2015
//----------------------------------------------------------------------------
// File : BtlGeom.cpp         Data : 26.08.15         Versione : 1.6h5
// Contenuto : Implementazione della classe BtlGeom.
//
//
//
// Modifiche : 26.08.15 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------

//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "BtlGeom.h"
#include "DllMain.h"
#include "/EgtDev/Include/EGkCurveLine.h"
#include "/EgtDev/Include/EGkCurveArc.h"
#include "/EgtDev/Include/EGkCurveComposite.h"
#include "/EgtDev/Include/EGkSfrCreate.h"
#include "/EgtDev/Include/EGkStmStandard.h"
#include "/EgtDev/Include/EGkStmFromCurves.h"
#include "/EgtDev/Include/EGkExtText.h"
#include "/EgtDev/Include/EGnStringUtils.h"
#include "/EgtDev/Include/EgtPointerOwner.h"

using namespace std ;

//----------------------------------------------------------------------------
BtlGeom::BtlGeom( void)
{
   m_pGDB = nullptr ;
   m_BoxCol = Color( 255, 128, 0, 15) ;
   m_OutsCol = Color( 224, 128, 0, 50) ;
   m_ProcsCol = Color( 80, 160, 160, 100) ;
   m_MarkCol = Color( 96, 192, 192, 100) ;
   m_nInfoId = GDB_ID_NULL ;
   m_nAsseId = GDB_ID_NULL ;
   m_ptOrig = ORIG ;
   m_nPartId = GDB_ID_NULL ;
   m_nAuxId = GDB_ID_NULL ;
   m_nBoxId = GDB_ID_NULL ;
   m_nOutsId = GDB_ID_NULL ;
   m_nProcsId = GDB_ID_NULL ;
   m_vtDim = V_NULL ;
   m_nCount = 0 ;
   m_dFcDepth = 0 ;
   m_bFcPocket = false ;
}

//----------------------------------------------------------------------------
bool
BtlGeom::Init( IGeomDB* pGDB, int nFlatVertPos, bool bSpecialTrim)
{
  // salvo puntatore a DB geometrico
   m_pGDB = pGDB ;
   if ( m_pGDB == nullptr)
      return false ;
  // salvo i flag
   m_nFlatVertPos = nFlatVertPos ;
   m_bSpecialTrim = bSpecialTrim ;
  // se non esiste, creo gruppo per informazioni varie
   m_nAsseId = m_pGDB->GetFirstNameInGroup( GDB_ID_ROOT, INFO_GROUP_NAME) ;
   if ( m_nAsseId == GDB_ID_NULL  &&  ! CreateInfoGroup())
      return false ;
  // se non esiste, creo gruppo per assemblaggio
   m_nAsseId = m_pGDB->GetFirstNameInGroup( GDB_ID_ROOT, ASSEMBLY_GROUP_NAME) ;
   if ( m_nAsseId == GDB_ID_NULL  &&  ! CreateAssemblyGroup())
      return false ;
   return true ;
}

//----------------------------------------------------------------------------
bool
BtlGeom::CreateInfoGroup( void)
{
  // creo il gruppo sotto la radice
   m_nInfoId = m_pGDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, Frame3d()) ;
   if ( m_nInfoId == GDB_ID_NULL)
      return false ;
  // assegno livello di sistema
   m_pGDB->SetLevel( m_nInfoId, GDB_LV_SYSTEM) ;
  // assegno nome
   m_pGDB->SetName( m_nInfoId, INFO_GROUP_NAME) ;
   return true ;
}

//----------------------------------------------------------------------------
bool
BtlGeom::CreateAssemblyGroup( void)
{
  // creo il gruppo sotto la radice
   m_nAsseId = m_pGDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, Frame3d()) ;
   if ( m_nAsseId == GDB_ID_NULL)
      return false ;
  // assegno livello di sistema
   m_pGDB->SetLevel( m_nAsseId, GDB_LV_SYSTEM) ;
  // assegno nome
   m_pGDB->SetName( m_nAsseId, ASSEMBLY_GROUP_NAME) ;
   return true ;
}

//----------------------------------------------------------------------------
bool
BtlGeom::CreatePart( void)
{
  // reset identificativi del pezzo precedente
   m_nPartId = GDB_ID_NULL ;
   m_nAuxId = GDB_ID_NULL ;
   m_nBoxId = GDB_ID_NULL ;
   m_nOutsId = GDB_ID_NULL ;
   m_nProcsId = GDB_ID_NULL ;
  // default
   m_vtDim = V_NULL ;
   m_nCount = 1 ;
  // creazione nuovo pezzo
   int nPartId = m_pGDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, Frame3d( m_ptOrig)) ;
   if ( nPartId == GDB_ID_NULL)
      return false ;
  // creo il layer ausiliario (per nome)
   int nAuxId = m_pGDB->AddGroup( GDB_ID_NULL, nPartId, Frame3d()) ;
   if ( nAuxId == GDB_ID_NULL)
      return false ;
   m_pGDB->SetName( nAuxId, AUX_LAYER_NAME) ;
   m_pGDB->SetMaterial( nAuxId, BLACK) ;
  // creo il layer per il box (parallelepipedo)
   int nBoxId = m_pGDB->AddGroup( GDB_ID_NULL, nPartId, Frame3d()) ;
   if ( nBoxId == GDB_ID_NULL)
      return false ;
   m_pGDB->SetName( nBoxId, BOX_LAYER_NAME) ;
   m_pGDB->SetMaterial( nBoxId, m_BoxCol) ;
  // creo il layer per l'outline (eventuali contorni)
   int nOutsId = m_pGDB->AddGroup( GDB_ID_NULL, nPartId, Frame3d()) ;
   if ( nOutsId == GDB_ID_NULL)
      return false ;
   m_pGDB->SetName( nOutsId, OUTLINE_LAYER_NAME) ;
   m_pGDB->SetMaterial( nOutsId, m_OutsCol) ;
  // creo il layer per le lavorazioni (features o processings)
   int nProcsId = m_pGDB->AddGroup( GDB_ID_NULL, nPartId, Frame3d()) ;
   if ( nProcsId == GDB_ID_NULL)
      return false ;
   m_pGDB->SetName( nProcsId, PROCESSINGS_LAYER_NAME) ;
   m_pGDB->SetMaterial( nProcsId, m_ProcsCol) ;
  // assegnazione identificativi
   m_nPartId = nPartId ;
   m_nAuxId = nAuxId ;
   m_nBoxId = nBoxId ;
   m_nOutsId = nOutsId ;
   m_nProcsId = nProcsId ;
   return true ;
}

//----------------------------------------------------------------------------
bool
BtlGeom::ErasePart( void)
{
  // se non c'è il DB geometrico, errore
   if ( m_pGDB == nullptr)
      return false ;
  // se non esiste un pezzo corrente, esco
   if ( m_nPartId == GDB_ID_NULL)
      return true ;
  // cancello il pezzo
   m_pGDB->Erase( m_nPartId) ;
  // annullo tutti gli identificativi del pezzo
   m_nPartId = GDB_ID_NULL ;
   m_nAuxId = GDB_ID_NULL ;
   m_nBoxId = GDB_ID_NULL ;
   m_nOutsId = GDB_ID_NULL ;
   m_nProcsId = GDB_ID_NULL ;
   return true ;
}

//----------------------------------------------------------------------------
bool
BtlGeom::SetPartProdNbr( int nProdNbr)
{
   if ( m_pGDB == nullptr)
      return false ;
   if ( ! m_pGDB->SetInfo( m_nPartId, IKEY_PROD_NBR, nProdNbr))
      return false ;
   string sName = ToString( nProdNbr) ;
  // assegnazione del nome al pezzo
   return m_pGDB->SetName( m_nPartId, sName) ;
}

//----------------------------------------------------------------------------
bool
BtlGeom::SetPartName( const string& sDes)
{
   if ( m_pGDB == nullptr)
      return false ;
   if ( ! m_pGDB->SetInfo( m_nPartId, IKEY_NAME, sDes))
      return false ;
   int nProdNbr = 0 ;
   m_pGDB->GetInfo( m_nPartId, IKEY_PROD_NBR, nProdNbr) ;
   string sName = ToString( nProdNbr) ;
   if ( ! sDes.empty())
      sName += "-" + sDes ;
  // assegnazione del nome al pezzo
   return m_pGDB->SetName( m_nPartId, sName) ;
}

//----------------------------------------------------------------------------
string
BtlGeom::GetPartName( void)
{
   if ( m_pGDB == nullptr)
      return "" ;
   string sName ;
   m_pGDB->GetName( m_nPartId, sName) ;
   return sName ;
}

//----------------------------------------------------------------------------
bool
BtlGeom::SetPartCount( int nCount)
{
   m_nCount = nCount ;
   return ( m_pGDB != nullptr  &&  m_pGDB->SetInfo( m_nPartId, IKEY_COUNT, nCount)) ;
}

//----------------------------------------------------------------------------
bool
BtlGeom::AddPartBox( double dLength, double dHeight, double dWidth)
{
  // creo il solido (parallelepipedo)
   PtrOwner<ISurfTriMesh> pStm( GetSurfTriMeshBox( dLength, dHeight, dWidth)) ;
   if ( IsNull( pStm))
      return false ;
  // lo inserisco nel layer box del pezzo
   int nId = m_pGDB->AddGeoObj( GDB_ID_NULL, m_nBoxId, Release( pStm)) ;
   if ( nId == GDB_ID_NULL)
      return false ;
  // assegno nome
   m_pGDB->SetName( nId, BOX_BOX_NAME) ;
  // assegno colore
   m_pGDB->SetMaterial( nId, m_BoxCol) ;
  // salvo in info pezzo le sue dimensioni
   m_pGDB->SetInfo( m_nPartId, IKEY_LENGTH, dLength) ;
   m_pGDB->SetInfo( m_nPartId, IKEY_HEIGHT, dHeight) ;
   m_pGDB->SetInfo( m_nPartId, IKEY_WIDTH, dWidth) ;
  // imposto dimensioni pezzo corrente
   m_vtDim.Set( dLength, dHeight, dWidth) ;
  // sistemo il posizionamento
   AdjustPartFlatOrVertPos( m_nPartId) ;
  // aggiorno origine per prossimo pezzo
   const double PART_OFFSET = 300 ;
   switch ( m_nFlatVertPos) {
   case 0 :
      m_ptOrig.y += dHeight + PART_OFFSET ;
      break ;
   case 1 :
      m_ptOrig.y += max( dHeight, dWidth) + PART_OFFSET ;
      break ;
   case 2 :
      m_ptOrig.y += min( dHeight, dWidth) + PART_OFFSET ;
      break ;
   case 3 :
      m_ptOrig.y += dWidth + PART_OFFSET ;
      break ;
   }

  // scrittura del nome sulla superficie del box come testo del layer ausiliario
   string sName ;
   if ( ! m_pGDB->GetName( m_nPartId, sName)  ||  sName.empty())
      sName = "..." ;
   // aggiungo numero di pezzi da produrre
   sName += " - #" + ToString( m_nCount) ;
   // aggiungo dimensioni
   double dDim1 = dLength ;
   double dDim2 = max( dWidth, dHeight) ;
   double dDim3 = min( dWidth, dHeight) ;
   sName += "<br/> (" + ToString( dDim1, 0) + "x" + ToString( dDim2, 0) + "x" + ToString( dDim3, 0) +")" ;
   PtrOwner<IExtText> pText( CreateExtText()) ;
   if ( IsNull( pText))
      return false ;
   int nSide = BTL_SIDE_TOP ;
   if ( m_nFlatVertPos == 1  &&  m_vtDim.z > m_vtDim.y + EPS_SMALL)
      nSide = BTL_SIDE_FRONT ;
   else if ( m_nFlatVertPos == 2  &&  m_vtDim.y < m_vtDim.z + EPS_SMALL)
      nSide = BTL_SIDE_FRONT ;
   else if ( m_nFlatVertPos == 3)
      nSide = BTL_SIDE_BACK ;
   double dSideLen = GetSideLength( nSide) ;
   double dSideWidth = GetSideWidth( nSide) ;
   double dTextHeight = 0.1 * min( dSideLen, dSideWidth) ;
   Point3d ptCen( 0.5 * dSideLen, 0.5 * dSideWidth, 0) ;
   if ( ! pText->Set( ptCen, Z_AX, X_AX, sName, "", 100, false, dTextHeight, 1, 0, ETXT_IPMC))
      return false ;
  // porto il testo nel piano della faccia
   Frame3d frRef = GetSideFrame( nSide) ;
   pText->ToGlob( frRef) ;
  // inserisco il testo nel DB geometrico
   int nTextId = m_pGDB->AddGeoObj( GDB_ID_NULL, m_nAuxId, Release( pText)) ;
   if ( nTextId == GDB_ID_NULL)
      return false ;

   return true ;
}

//----------------------------------------------------------------------------
bool
BtlGeom::AdjustPartFlatOrVertPos( int nPartId)
{
  // determino come modificare la posizione
   if ( m_nFlatVertPos == 0)
      return true ;
  // recupero il box del pezzo
   BBox3d b3Part ;
   int nBoxId = m_pGDB->GetFirstNameInGroup( nPartId, BOX_LAYER_NAME) ;
   if ( nBoxId == GDB_ID_NULL  ||
        ! m_pGDB->GetGlobalBBox( nBoxId, b3Part))
      return false ;
  // dimensioni pezzo
   Vector3d vtDim = b3Part.GetMax() - b3Part.GetMin() ;
  // se richiesto piatto ed è in verticale, ruoto
   if ( m_nFlatVertPos == 1  &&  vtDim.z > vtDim.y + EPS_SMALL) {
      Point3d ptAx = b3Part.GetMin() + 0.5 * Vector3d( 0, vtDim.y, vtDim.y) ;
      m_pGDB->RotateGlob( nPartId, ptAx, X_AX, 0, -1) ;
   }
  // se richiesto in verticale ed è piatto, ruoto
   else if ( m_nFlatVertPos == 2  &&  vtDim.y > vtDim.z + EPS_SMALL) {
      Point3d ptAx = b3Part.GetMin() + 0.5 * Vector3d( 0, vtDim.z, vtDim.z) ;
      m_pGDB->RotateGlob( nPartId, ptAx, X_AX, 0, 1) ;
   }
  // se richiesto come TechnoEssetre devo sempre ruotare di 90deg
   else if (m_nFlatVertPos == 3) {
      Point3d ptAx = b3Part.GetMin() + 0.5 * Vector3d( 0, vtDim.z, vtDim.z) ;
      m_pGDB->RotateGlob( nPartId, ptAx, X_AX, 0, 1) ;
   }
   return true ;
}

//----------------------------------------------------------------------------
bool
BtlGeom::ReadUserAttribute( const string& sString, string& sKey, string& sVal)
{
  // recupero chiave e valore
   SplitFirst( sString, ":", sKey, sVal) ;
  // elimino i doppi apici
   Trim( sKey, " \"") ;
   Trim( sVal, " \"") ;
  // verifico
   return ( ! IsEmptyOrSpaces( sKey)) ;
}

//----------------------------------------------------------------------------
bool
BtlGeom::SetUserAttribute( int nUAttrDest, const string& sString)
{
   if ( m_pGDB == nullptr)
      return false ;
  // recupero chiave e valore
   string sKey, sVal ;
   if ( ! ReadUserAttribute( sString, sKey, sVal))
      return false ;
  // li assegno
   if ( nUAttrDest == UATD_PART)
      return (m_pGDB->SetInfo( m_nPartId, sKey, sVal)) ;
   else
      return (m_pGDB->SetInfo( m_nInfoId, sKey, sVal)) ;
}

//----------------------------------------------------------------------------
bool
BtlGeom::AddPartTransformation( int nUID, const Frame3d& frRef)
{
  // creo un nuovo gruppo nell'assemblaggio
   int nId = m_pGDB->AddGroup( GDB_ID_NULL, m_nAsseId, frRef) ;
   if ( nId == GDB_ID_NULL)
      return false ;
  // assegno Nome con UID
   m_pGDB->SetName( nId, "UID-" + ToString( nUID)) ;
  // assegno Id pezzo istanziato
   m_pGDB->SetInfo( nId, "!SOU", m_nPartId) ;
  // nascondo e blocco
   m_pGDB->SetStatus( nId, GDB_ST_OFF) ;
   m_pGDB->SetMode( nId, GDB_MD_LOCKED) ;
   return true ;
}

//----------------------------------------------------------------------------
bool
BtlGeom::IsTrueSide( int nSide) const
{
   return ( nSide >= BTL_SIDE_FRONT  &&  nSide <= BTL_SIDE_TOP) ;
}

//----------------------------------------------------------------------------
string
BtlGeom::GetOutlineOutName( int nSide) const
{
   return ( ToString( nSide) + "-" + OL_OUTSTM_NAME) ;
}

//----------------------------------------------------------------------------
string
BtlGeom::GetOutlineApertureName( int nSide) const
{
   return ( ToString( nSide) + "-" + OL_APERTURESTM_NAME) ;
}

//----------------------------------------------------------------------------
string
BtlGeom::GetOutlineTopName( int nSide) const
{
   return ( ToString( nSide) + "-" + OL_TOPREGION_NAME) ;
}

//----------------------------------------------------------------------------
string
BtlGeom::GetOutlineBottomName( int nSide) const
{
   return ( ToString( nSide) + "-" + OL_BOTTOMREGION_NAME) ;
}

//----------------------------------------------------------------------------
double
BtlGeom::GetSideLength( int nSide) const
{
   switch ( nSide) {
   case BTL_SIDE_FRONT :
   case BTL_SIDE_BACK :
   case BTL_SIDE_TOP :
   case BTL_SIDE_BOTTOM :
      return m_vtDim.x ;
   case BTL_SIDE_RIGHT :
   case BTL_SIDE_LEFT :
      return m_vtDim.y ;
   }
   return 0 ;
}

//----------------------------------------------------------------------------
double
BtlGeom::GetSideWidth( int nSide) const
{
   switch ( nSide) {
   case BTL_SIDE_FRONT :
   case BTL_SIDE_BACK :
   case BTL_SIDE_RIGHT :
   case BTL_SIDE_LEFT :
      return m_vtDim.z ;
   case BTL_SIDE_TOP :
   case BTL_SIDE_BOTTOM :
      return m_vtDim.y ;
   }
   return 0 ;
}

//----------------------------------------------------------------------------
double
BtlGeom::GetSideHeight( int nSide) const
{
   switch ( nSide) {
   case BTL_SIDE_FRONT :
   case BTL_SIDE_BACK :
      return m_vtDim.y ;
   case BTL_SIDE_TOP :
   case BTL_SIDE_BOTTOM :
      return m_vtDim.z ;
   case BTL_SIDE_RIGHT :
   case BTL_SIDE_LEFT :
      return m_vtDim.x ;
   }
   return 0 ;
}

//----------------------------------------------------------------------------
Frame3d
BtlGeom::GetSideFrame( int nSide) const
{
   Frame3d frRef ;
   switch ( nSide) {
   case BTL_SIDE_FRONT :
      frRef.Set( Point3d( 0, 0, 0), X_AX, Z_AX, - Y_AX) ;
      break ;
   case BTL_SIDE_BOTTOM :
      frRef.Set( Point3d( 0, m_vtDim.y, 0), X_AX, - Y_AX, - Z_AX) ;
      break ;
   case BTL_SIDE_BACK :
      frRef.Set( Point3d( 0, m_vtDim.y, m_vtDim.z), X_AX, - Z_AX, Y_AX) ;
      break ;
   case BTL_SIDE_TOP :
      frRef.Set( Point3d( 0, 0, m_vtDim.z), X_AX, Y_AX, Z_AX) ;
      break ;
   case BTL_SIDE_RIGHT :
      frRef.Set( Point3d( m_vtDim.x, 0, 0), Y_AX, Z_AX, X_AX) ;
      break ;
   case BTL_SIDE_LEFT :
      frRef.Set( Point3d( 0, m_vtDim.y, 0), - Y_AX, Z_AX, - X_AX) ;
      break ;
   }
   return frRef ;
}

//----------------------------------------------------------------------------
Plane3d
BtlGeom::GetSidePlane( int nSide) const
{
   Plane3d plPlane ;
   switch ( nSide) {
   case BTL_SIDE_FRONT :
      plPlane.Set( 0, -Y_AX) ;
      break ;
   case BTL_SIDE_BOTTOM :
      plPlane.Set( 0, -Z_AX) ;
      break ;
   case BTL_SIDE_BACK :
      plPlane.Set( m_vtDim.y, Y_AX) ;
      break ;
   case BTL_SIDE_TOP :
      plPlane.Set( m_vtDim.z, Z_AX) ;
      break ;
   case BTL_SIDE_RIGHT :
      plPlane.Set( m_vtDim.x, X_AX) ;
      break ;
   case BTL_SIDE_LEFT :
      plPlane.Set( 0, -X_AX) ;
      break ;
   default :
      plPlane.Reset() ;
      break ;
   }
   return plPlane ;
}

//----------------------------------------------------------------------------
Vector3d
BtlGeom::GetSideVersN( int nSide) const
{
   switch ( nSide) {
   case BTL_SIDE_FRONT :
      return - Y_AX ;
   case BTL_SIDE_BOTTOM :
      return - Z_AX ;
   case BTL_SIDE_BACK :
      return Y_AX ;
   case BTL_SIDE_TOP :
      return Z_AX ;
   case BTL_SIDE_RIGHT :
      return X_AX ;
   case BTL_SIDE_LEFT :
      return - X_AX ;
   }
   return V_NULL ;
}

//----------------------------------------------------------------------------
int
BtlGeom::GetOppositeSide( int nSide) const
{
   switch ( nSide) {
   case BTL_SIDE_FRONT :
      return BTL_SIDE_BACK ;
   case BTL_SIDE_TOP :
      return BTL_SIDE_BOTTOM ;
   case BTL_SIDE_BACK :
      return BTL_SIDE_FRONT ;
   case BTL_SIDE_BOTTOM :
      return BTL_SIDE_TOP ;
   case BTL_SIDE_RIGHT :
      return BTL_SIDE_LEFT ;
   case BTL_SIDE_LEFT :
      return BTL_SIDE_RIGHT ;
   }
   return BTL_SIDE_NONE ;
}

//----------------------------------------------------------------------------
bool
BtlGeom::SetAlpha( int nId, int nAlpha)
{
   Color cCol ;
   if ( ! m_pGDB->GetCalcMaterial( nId, cCol))
      return false ;
   cCol.SetAlpha( nAlpha) ;
   return m_pGDB->SetMaterial( nId, cCol) ;
}

//----------------------------------------------------------------------------
bool
BtlGeom::SortParts( void)
{
  // tabella Id-SN dei pezzi
   INTINTVECTOR vIdSN ;

  // recupero il numero di serie di ogni singolo pezzo
   int nPartId = m_pGDB->GetFirstGroupInGroup( GDB_ID_ROOT) ;
   while ( nPartId != GDB_ID_NULL) {
      int nLev ;
      if ( m_pGDB->GetCalcLevel( nPartId, nLev)  &&  nLev == GDB_LV_USER) {
         int nSN = 0 ;
         m_pGDB->GetInfo( nPartId, IKEY_PROD_NBR, nSN) ;
         vIdSN.emplace_back( nPartId, nSN) ;
      }
      nPartId = m_pGDB->GetNextGroup( nPartId) ;
   }

  // ordino la tabella secondo SN
   sort( vIdSN.begin(), vIdSN.end(), []( const INTINT& a, const INTINT& b)
                                       { return a.second < b.second ; }) ;

  // cambio posizione dei pezzi nel DB come da ordine in tabella
   Point3d ptIns ;
   for ( int i = 0 ; i < int( vIdSN.size()) ; ++ i) {
      m_pGDB->Relocate( vIdSN[i].first, GDB_ID_ROOT, GDB_LAST_SON) ;
      BBox3d b3Part ;
      int nBoxId = m_pGDB->GetFirstNameInGroup( vIdSN[i].first, BOX_LAYER_NAME) ;
      m_pGDB->GetGlobalBBox( nBoxId, b3Part) ;
      m_pGDB->Translate( vIdSN[i].first, ptIns - b3Part.GetMin()) ;
      ptIns += Vector3d( 0, b3Part.GetMax().y - b3Part.GetMin().y + 300, 0) ;
   }

   return true ;
}