Egalware/EgtGeomKernel
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

EgtGeomKernel 1.5d5 :

Browse Source 
- aggiunta scrittura binaria
- tolte GetKey, Load e Save da interfaccia IGeoObj.
This commit is contained in:
Dario Sassi
2014-04-14 15:57:58 +00:00
parent 39db15e41e
commit f956fd20cc
37 changed files with 829 additions and 198 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Attribs.cpp
+11 -11
View File
@@ -14,6 +14,7 @@
//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "Attribs.h"
#include "NgeWriter.h"
#include "/EgtDev/Include/EGnStringUtils.h"
#include "/EgtDev/Include/EGkStringUtils3d.h"
@@ -81,30 +82,29 @@ Attribs::Dump( string& sOut, const char* szNewLine) const
//----------------------------------------------------------------------------
bool
Attribs::Save( ostream& osOut) const
Attribs::Save( NgeWriter& ngeOut) const
{
// flag presenza attributi
osOut << "A" << endl ;
ngeOut.WriteKey( NGE_A, true) ;
// livello
osOut << ToString( m_Data[LEVEL]) << "," ;
ngeOut.WriteUchar( m_Data[LEVEL], ",") ;
// modo
osOut << ToString( m_Data[MODE]) << "," ;
ngeOut.WriteUchar( m_Data[MODE], ",") ;
// stato (se SEL è convertito in ON)
int nStat = (( m_Data[STATUS] > GDB_ST_ON) ? GDB_ST_ON : m_Data[STATUS]) ;
osOut << ToString( nStat) << "," ;
ngeOut.WriteUchar( nStat, ",") ;
// marcatura (sempre OFF)
osOut << ToString( GDB_MK_OFF) << ";" ;
ngeOut.WriteUchar( GDB_MK_OFF, ";") ;
// materiale
osOut << ToString( m_Material) << ";" ;
ngeOut.WriteInt( m_Material, ";") ;
// colore
osOut << ToString( m_Color) << ";" ;
ngeOut.WriteCol( m_Color, ";") ;
// numero di stringhe di info (nelle linee successive)
osOut << ToString( int( m_slInfo.size())) << ";" << endl ;
ngeOut.WriteInt( int( m_slInfo.size()), ";", true) ;
// stringhe di info
STRLIST::const_iterator iIter ;
for ( iIter = m_slInfo.begin() ; iIter != m_slInfo.end() ; ++ iIter)
osOut << *iIter << endl ;
ngeOut.WriteString( *iIter, nullptr, true) ;
return true ;
}
Attribs.h
+2 -1
View File
@@ -18,6 +18,7 @@
#include "/EgtDev/Include/EGnScan.h"
#include "/EgtDev/Include/EGnStringBase.h"
class NgeWriter ;
//----------------------------------------------------------------------------
#define CLIP( nV, nMIN, nMAX) (( nV < nMIN) ? nMIN : (( nV > nMAX) ? nMAX : nV))
@@ -40,7 +41,7 @@ class Attribs
*pAttribs = *(const_cast<Attribs*>(this)) ;
return pAttribs ; }
bool Dump( std::string& sOut, const char* szNewLine) const ;
bool Save( std::ostream& osOut) const ;
bool Save( NgeWriter& ngeOut) const ;
bool Load( Scanner& TheScanner) ;
void SetLevel( int nLev)
{ m_OldData[LEVEL] = m_Data[LEVEL] ;
BinaryRW.h
+49
View File
@@ -0,0 +1,49 @@
//----------------------------------------------------------------------------
// EgalTech 2014-2014
//----------------------------------------------------------------------------
// File : BinaryRW.h Data : 12.04.14 Versione : 1.5d3
// Contenuto : Funzioni per lettura e scrittura di file binari.
//
//
//
// Modifiche : 12.04.14 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------
#pragma once
#include "/EgtDev/Include/EGkColor.h"
#include <ostream>
//----------------------------------------------------------------------------
inline void
WriteUchar( std::ostream& osOut, unsigned char cVal)
{
osOut.write( (char*) &cVal, sizeof( cVal)) ;
}
//----------------------------------------------------------------------------
inline void
WriteInt( std::ostream& osOut, int nVal)
{
osOut.write( (char*) &nVal, sizeof( nVal)) ;
}
//----------------------------------------------------------------------------
inline void
WriteString( std::ostream& osOut, const std::string sVal)
{
WriteInt( osOut, int( sVal.size())) ;
osOut.write( sVal.c_str(), sVal.size()) ;
}
//----------------------------------------------------------------------------
inline void
WriteCol( std::ostream& osOut, Color cCol)
{
WriteUchar( osOut, cCol.GetIntRed()) ;
WriteUchar( osOut, cCol.GetIntGreen()) ;
WriteUchar( osOut, cCol.GetIntBlue()) ;
WriteUchar( osOut, cCol.GetIntAlpha()) ;
}
CurveArc.cpp
+20 -11
View File
@@ -16,13 +16,14 @@
#include "CurveArc.h"
#include "GeoConst.h"
#include "GeoObjFactory.h"
#include "NgeWriter.h"
#include "/EgtDev/Include/EGkStringUtils3d.h"
#include <new>
using namespace std ;
//----------------------------------------------------------------------------
GEOOBJ_REGISTER( CRV_ARC, "C_ARC", CurveArc) ;
GEOOBJ_REGISTER( CRV_ARC, NGE_C_ARC, CurveArc) ;
//----------------------------------------------------------------------------
@@ -162,6 +163,13 @@ CurveArc::Copy( const CurveArc& caSrc)
caSrc.m_VtS, caSrc.m_dAngCenDeg, caSrc.m_dDeltaN) ;
}
//----------------------------------------------------------------------------
GeoObjType
CurveArc::GetType( void) const
{
return static_cast<GeoObjType>( GEOOBJ_GETTYPE( CurveArc)) ;
}
//----------------------------------------------------------------------------
const string&
CurveArc::GetTitle( void) const
@@ -185,29 +193,30 @@ CurveArc::Dump( string& sOut, const char* szNewLine) const
return true ;
}
//----------------------------------------------------------------------------
const string&
CurveArc::GetKey( void) const
int
CurveArc::GetNgeId( void) const
{
return GEOOBJ_GETKEY( CurveArc) ;
return GEOOBJ_GETNGEID( CurveArc) ;
}
//----------------------------------------------------------------------------
bool
CurveArc::Save( ostream& osOut) const
CurveArc::Save( NgeWriter& ngeOut) const
{
// centro
osOut << ToString( m_PtCen) << ";" ;
ngeOut.WritePoint( m_PtCen, ";") ;
// versore Normale
osOut << ToString( m_VtN) << ";" ;
ngeOut.WriteVector( m_VtN, ";") ;
// raggio
osOut << ToString( m_dRad) << ";" ;
ngeOut.WriteDouble( m_dRad, ";") ;
// versore Iniziale
osOut << ToString( m_VtS) << ";" ;
ngeOut.WriteVector( m_VtS, ";") ;
// angolo al centro
osOut << ToString( m_dAngCenDeg) << ";" ;
ngeOut.WriteDouble( m_dAngCenDeg, ";") ;
// deltaN
osOut << ToString( m_dDeltaN) << ";" << endl ;
ngeOut.WriteDouble( m_dDeltaN, ";", true) ;
return true ;
}
CurveArc.h
+5 -5
View File
@@ -16,22 +16,22 @@
#include "ObjGraphicsMgr.h"
#include "CurveAux.h"
#include "DllMain.h"
#include "GeoObjRW.h"
#include "/EgtDev/Include/EGkCurveArc.h"
//----------------------------------------------------------------------------
class CurveArc : public ICurveArc
class CurveArc : public ICurveArc, public IGeoObjRW
{
public : // IGeoObj
virtual ~CurveArc( void) ;
virtual CurveArc* Clone( void) const ;
virtual GeoObjType GetType( void) const
{ return CRV_ARC ; }
virtual GeoObjType GetType( void) const ;
virtual bool IsValid( void) const
{ return ( m_nStatus == OK) ; }
virtual const std::string& GetTitle( void) const ;
virtual bool Dump( std::string& sOut, const char* szNewLine = "\n") const ;
virtual const std::string& GetKey( void) const ;
virtual bool Save( std::ostream& osOut) const ;
virtual int GetNgeId( void) const ;
virtual bool Save( NgeWriter& ngeOut) const ;
virtual bool Load( Scanner& TheScanner) ;
virtual bool GetLocalBBox( BBox3d& b3Loc) const ;
virtual bool GetBBox( const Frame3d& frRef, BBox3d& b3Ref) const ;
CurveBezier.cpp
+17 -9
View File
@@ -17,6 +17,7 @@
#include "GeoConst.h"
#include "DistPointLine.h"
#include "GeoObjFactory.h"
#include "NgeWriter.h"
#include "PolynomialPoint3d.h"
#include "/EgtDev/Include/EGkCurveArc.h"
#include "/EgtDev/Include/ENkPolynomial.h"
@@ -26,7 +27,7 @@
using namespace std ;
//----------------------------------------------------------------------------
GEOOBJ_REGISTER( CRV_BEZ, "C_BEZ", CurveBezier) ;
GEOOBJ_REGISTER( CRV_BEZ, NGE_C_BEZ, CurveBezier) ;
//----------------------------------------------------------------------------
CurveBezier::CurveBezier( void)
@@ -303,6 +304,13 @@ CurveBezier::Copy( const CurveBezier& cbSrc)
return true ;
}
//----------------------------------------------------------------------------
GeoObjType
CurveBezier::GetType( void) const
{
return static_cast<GeoObjType>( GEOOBJ_GETTYPE( CurveBezier)) ;
}
//----------------------------------------------------------------------------
const string&
CurveBezier::GetTitle( void) const
@@ -331,26 +339,26 @@ CurveBezier::Dump( string& sOut, const char* szNewLine) const
}
//----------------------------------------------------------------------------
const string&
CurveBezier::GetKey( void) const
int
CurveBezier::GetNgeId( void) const
{
return GEOOBJ_GETKEY( CurveBezier) ;
return GEOOBJ_GETNGEID( CurveBezier) ;
}
//----------------------------------------------------------------------------
bool
CurveBezier::Save( ostream& osOut) const
CurveBezier::Save( NgeWriter& ngeOut) const
{
// flag razionale
osOut << ToString( m_bRat) << ";" ;
ngeOut.WriteBool( m_bRat, ";") ;
// grado
osOut << ToString( m_nDeg) << ";" << endl ;
ngeOut.WriteInt( m_nDeg, ";", true) ;
// ciclo sui punti di controllo ( con pesi se razionale)
for ( int i = 0 ; i <= m_nDeg ; ++ i) {
if ( ! m_bRat)
osOut << ToString( m_aPtCtrl[i]) << ";" << endl ;
ngeOut.WritePoint( m_aPtCtrl[i], ";", true) ;
else
osOut << ToString( m_aPtCtrl[i], m_aWeCtrl[i]) << ";" << endl ;
ngeOut.WritePointW( m_aPtCtrl[i], m_aWeCtrl[i], ";", true) ;
}
return true ;
CurveBezier.h
+5 -5
View File
@@ -17,23 +17,23 @@
#include "CurveAux.h"
#include "PolynomialPoint3d.h"
#include "DllMain.h"
#include "GeoObjRW.h"
#include "/EgtDev/Include/EGkCurveBezier.h"
#include "/EgtDev/Include/EgtNumCollection.h"
//----------------------------------------------------------------------------
class CurveBezier : public ICurveBezier
class CurveBezier : public ICurveBezier, public IGeoObjRW
{
public : // IGeoObj
virtual ~CurveBezier( void) ;
virtual CurveBezier* Clone( void) const ;
virtual GeoObjType GetType( void) const
{ return CRV_BEZ ; }
virtual GeoObjType GetType( void) const ;
virtual bool IsValid( void) const
{ return ( m_nStatus == OK) ; }
virtual const std::string& GetTitle( void) const ;
virtual bool Dump( std::string& sOut, const char* szNewLine = "\n") const ;
virtual const std::string& GetKey( void) const ;
virtual bool Save( std::ostream& osOut) const ;
virtual int GetNgeId( void) const ;
virtual bool Save( NgeWriter& ngeOut) const ;
virtual bool Load( Scanner& TheScanner) ;
virtual bool GetLocalBBox( BBox3d& b3Loc) const ;
virtual bool GetBBox( const Frame3d& frRef, BBox3d& b3Ref) const ;
CurveComposite.cpp
+23 -10
View File
@@ -16,6 +16,7 @@
#include "CurveComposite.h"
#include "GeoConst.h"
#include "GeoObjFactory.h"
#include "NgeWriter.h"
#include "/EgtDev/Include/EGnStringUtils.h"
#include "/EgtDev/Include/EgtPointerOwner.h"
#include "/EgtDev/Include/EGkCurveArc.h"
@@ -25,7 +26,7 @@
using namespace std ;
//----------------------------------------------------------------------------
GEOOBJ_REGISTER( CRV_COMPO, "C_CMP", CurveComposite) ;
GEOOBJ_REGISTER( CRV_COMPO, NGE_C_CMP, CurveComposite) ;
//----------------------------------------------------------------------------
CurveComposite::CurveComposite( void)
@@ -235,6 +236,13 @@ CurveComposite::Copy( const CurveComposite& ccSrc)
return true ;
}
//----------------------------------------------------------------------------
GeoObjType
CurveComposite::GetType( void) const
{
return static_cast<GeoObjType>( GEOOBJ_GETTYPE( CurveComposite)) ;
}
//----------------------------------------------------------------------------
const string&
CurveComposite::GetTitle( void) const
@@ -266,29 +274,33 @@ CurveComposite::Dump( string& sOut, const char* szNewLine) const
}
//----------------------------------------------------------------------------
const string&
CurveComposite::GetKey( void) const
int
CurveComposite::GetNgeId( void) const
{
return GEOOBJ_GETKEY( CurveComposite) ;
return GEOOBJ_GETNGEID( CurveComposite) ;
}
//----------------------------------------------------------------------------
bool
CurveComposite::Save( ostream& osOut) const
CurveComposite::Save( NgeWriter& ngeOut) const
{
// numero di curve
osOut << ToString( m_nCounter) << endl ;
ngeOut.WriteInt( m_nCounter, nullptr, true) ;
// ciclo sulle curve componenti
int i = 0 ;
const ICurve* pCrvSmpl = GetFirstCurve() ;
while ( pCrvSmpl != nullptr) {
// recupero il gestore di lettura/scrittura dell'entità
const IGeoObjRW* pCSmplRW = dynamic_cast<const IGeoObjRW*>( pCrvSmpl) ;
if ( pCSmplRW == nullptr)
return false ;
// emetto tipo della curva semplice
osOut << pCrvSmpl->GetKey() << endl ;
ngeOut.WriteKey( pCSmplRW->GetNgeId(), true) ;
// assegno ed emetto nome della curva semplice
string sCrvName = "#" + ToString( ++i) ;
osOut << sCrvName << endl ;
ngeOut.WriteString( sCrvName, nullptr, true) ;
// salvataggio della curva semplice
if ( ! pCrvSmpl->Save( osOut))
if ( ! pCSmplRW->Save( ngeOut))
return false ;
// passo alla successiva
pCrvSmpl = GetNextCurve() ;
@@ -330,7 +342,8 @@ CurveComposite::Load( Scanner& TheScanner)
// recupero la linea con il nome
bool bOk = TheScanner.GetLine( sLine) ;
// ne leggo i dati
bOk = bOk && pGeoO->Load( TheScanner) ;
IGeoObjRW* pGObjRW = dynamic_cast<IGeoObjRW*>( pGeoO) ;
bOk = bOk && ( pGObjRW != nullptr && pGObjRW->Load( TheScanner)) ;
// verifico sia una curva
ICurve* pCrv = ::GetCurve( pGeoO) ;
bOk = bOk && ( pCrv != nullptr && pCrv->IsSimple()) ;
CurveComposite.h
+5 -5
View File
@@ -16,24 +16,24 @@
#include "ObjGraphicsMgr.h"
#include "CurveAux.h"
#include "DllMain.h"
#include "GeoObjRW.h"
#include "/EgtDev/Include/EGkCurveComposite.h"
#include "/EgtDev/Include/EgtLogger.h"
#include <list>
//----------------------------------------------------------------------------
class CurveComposite : public ICurveComposite
class CurveComposite : public ICurveComposite, public IGeoObjRW
{
public : // IGeoObj
virtual ~CurveComposite( void) ;
virtual CurveComposite* Clone( void) const ;
virtual GeoObjType GetType( void) const
{ return CRV_COMPO ; }
virtual GeoObjType GetType( void) const ;
virtual bool IsValid( void) const
{ return ( m_nStatus == OK) ; }
virtual const std::string& GetTitle( void) const ;
virtual bool Dump( std::string& sOut, const char* szNewLine = "\n") const ;
virtual const std::string& GetKey( void) const ;
virtual bool Save( std::ostream& osOut) const ;
virtual int GetNgeId( void) const ;
virtual bool Save( NgeWriter& ngeOut) const ;
virtual bool Load( Scanner& TheScanner) ;
virtual bool GetLocalBBox( BBox3d& b3Loc) const ;
virtual bool GetBBox( const Frame3d& frRef, BBox3d& b3Ref) const ;
CurveLine.cpp
+15 -7
View File
@@ -15,13 +15,14 @@
#include "stdafx.h"
#include "CurveLine.h"
#include "GeoObjFactory.h"
#include "NgeWriter.h"
#include "/EgtDev/Include/EGkStringUtils3d.h"
#include <new>
using namespace std ;
//----------------------------------------------------------------------------
GEOOBJ_REGISTER( CRV_LINE, "C_LIN", CurveLine) ;
GEOOBJ_REGISTER( CRV_LINE, NGE_C_LIN, CurveLine) ;
//----------------------------------------------------------------------------
CurveLine::CurveLine( void)
@@ -84,6 +85,13 @@ CurveLine::Copy( const CurveLine& clSrc)
return Set( clSrc.m_PtStart, clSrc.m_PtEnd) ;
}
//----------------------------------------------------------------------------
GeoObjType
CurveLine::GetType( void) const
{
return static_cast<GeoObjType>( GEOOBJ_GETTYPE( CurveLine)) ;
}
//----------------------------------------------------------------------------
const string&
CurveLine::GetTitle( void) const
@@ -104,19 +112,19 @@ CurveLine::Dump( string& sOut, const char* szNewLine) const
}
//----------------------------------------------------------------------------
const string&
CurveLine::GetKey( void) const
int
CurveLine::GetNgeId( void) const
{
return GEOOBJ_GETKEY( CurveLine) ;
return GEOOBJ_GETNGEID( CurveLine) ;
}
//----------------------------------------------------------------------------
bool
CurveLine::Save( ostream& osOut) const
CurveLine::Save( NgeWriter& ngeOut) const
{
// parametri : punti iniziale e finale
osOut << ToString( m_PtStart) << ";";
osOut << ToString( m_PtEnd) << ";" << endl ;
ngeOut.WritePoint( m_PtStart, ";") ;
ngeOut.WritePoint( m_PtEnd, ";", true) ;
return true ;
}
CurveLine.h
+5 -5
View File
@@ -16,22 +16,22 @@
#include "ObjGraphicsMgr.h"
#include "CurveAux.h"
#include "DllMain.h"
#include "GeoObjRW.h"
#include "/EgtDev/Include/EGkCurveLine.h"
//----------------------------------------------------------------------------
class CurveLine : public ICurveLine
class CurveLine : public ICurveLine, public IGeoObjRW
{
public : // IGeoObj
virtual ~CurveLine( void) ;
virtual CurveLine* Clone( void) const ;
virtual GeoObjType GetType( void) const
{ return CRV_LINE ; }
virtual GeoObjType GetType( void) const ;
virtual bool IsValid( void) const
{ return ( m_nStatus == OK) ; }
virtual const std::string& GetTitle( void) const ;
virtual bool Dump( std::string& sOut, const char* szNewLine = "\n") const ;
virtual const std::string& GetKey( void) const ;
virtual bool Save( std::ostream& osOut) const ;
virtual int GetNgeId( void) const ;
virtual bool Save( NgeWriter& ngeOut) const ;
virtual bool Load( Scanner& TheScanner) ;
virtual bool GetLocalBBox( BBox3d& b3Loc) const ;
virtual bool GetBBox( const Frame3d& frRef, BBox3d& b3Ref) const ;
EgtGeomKernel.rc
BIN
View File
Binary file not shown.
EgtGeomKernel.vcxproj
+5
View File
@@ -266,6 +266,7 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
<ClCompile Include="SurfTriMesh.cpp" />
<ClCompile Include="Triangulate.cpp" />
<ClCompile Include="Vector3d.cpp" />
<ClCompile Include="NgeWriter.cpp" />
</ItemGroup>
<ItemGroup>
<ClInclude Include="..\Include\EGkBBox3d.h" />
@@ -328,10 +329,13 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
<ClInclude Include="GeoFrame3d.h" />
<ClInclude Include="GeomDB.h" />
<ClInclude Include="GeoObjFactory.h" />
<ClInclude Include="GeoObjRW.h" />
<ClInclude Include="GeoPoint3d.h" />
<ClInclude Include="GeoVector3d.h" />
<ClInclude Include="IdManager.h" />
<ClInclude Include="IterManager.h" />
<ClInclude Include="NgeConst.h" />
<ClInclude Include="NgeKeyW.h" />
<ClInclude Include="ObjGraphicsMgr.h" />
<ClInclude Include="OutTsc.h" />
<ClInclude Include="PolynomialPoint3d.h" />
@@ -340,6 +344,7 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
<ClInclude Include="stdafx.h" />
<ClInclude Include="SurfTriMesh.h" />
<ClInclude Include="Triangulate.h" />
<ClInclude Include="NgeWriter.h" />
</ItemGroup>
<ItemGroup>
<ResourceCompile Include="EgtGeomKernel.rc" />
EgtGeomKernel.vcxproj.filters
+15
View File
@@ -141,6 +141,9 @@
<ClCompile Include="Triangulate.cpp">
<Filter>File di origine\Base</Filter>
</ClCompile>
<ClCompile Include="NgeWriter.cpp">
<Filter>File di origine\Gdb</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
<ClInclude Include="stdafx.h">
@@ -359,6 +362,18 @@
<ClInclude Include="..\Include\EGkPlane3d.h">
<Filter>File di intestazione</Filter>
</ClInclude>
<ClInclude Include="NgeConst.h">
<Filter>File di intestazione</Filter>
</ClInclude>
<ClInclude Include="NgeWriter.h">
<Filter>File di intestazione</Filter>
</ClInclude>
<ClInclude Include="NgeKeyW.h">
<Filter>File di intestazione</Filter>
</ClInclude>
<ClInclude Include="GeoObjRW.h">
<Filter>File di intestazione</Filter>
</ClInclude>
</ItemGroup>
<ItemGroup>
<ResourceCompile Include="EgtGeomKernel.rc">
GdbExecutor.cpp
+10 -3
View File
@@ -1875,11 +1875,18 @@ GdbExecutor::ExecuteLoad( const std::string& sCmd2, const STRVECTOR& vsParams)
bool
GdbExecutor::ExecuteSave( const std::string& sCmd2, const STRVECTOR& vsParams)
{
// 1 parametro ( NomeFile)
if ( vsParams.size() != 1)
// almeno 1 parametro ( NomeFile)
if ( vsParams.size() < 1)
return false ;
// il secondo parametro, opzionale, indica il formato del file
bool bBinary = false ;
if ( vsParams.size() == 2) {
string sBinary = vsParams[1] ;
ToUpper( sBinary) ;
bBinary = ( sBinary == "B" || sBinary == "BINARY") ;
}
// esecuzione salvataggio
return m_pGDB->Save( vsParams[0]) ;
return m_pGDB->Save( vsParams[0], bBinary) ;
}
//----------------------------------------------------------------------------
GdbGeo.cpp
+17 -14
View File
@@ -17,6 +17,8 @@
#include "GeoObjFactory.h"
#include "CurveAux.h"
#include "Attribs.h"
#include "NgeWriter.h"
#include "GeoObjRW.h"
#include "/EgtDev/Include/EGkGdbFunct.h"
#include "/EgtDev/Include/EGnStringUtils.h"
#include <new>
@@ -81,25 +83,25 @@ GdbGeo::GetType( void) const
//----------------------------------------------------------------------------
bool
GdbGeo::Save( std::ostream& osOut) const
GdbGeo::Save( NgeWriter& ngeOut) const
{
bool bOk = true ;
// recupero il gestore di lettura/scrittura dell'entità
IGeoObjRW* pGObjRW = dynamic_cast<IGeoObjRW*>( m_pGeoObj) ;
if ( pGObjRW == nullptr)
return false ;
// tipo entità
osOut << m_pGeoObj->GetKey() << endl ;
// nome
osOut << m_nId << "@" << GetParentId() << endl ;
// tipo entità e identificativi
ngeOut.WriteKey( pGObjRW->GetNgeId(), true) ;
ngeOut.WriteInt( m_nId, "@") ;
ngeOut.WriteInt( GetParentId(), nullptr, true) ;
// attributi
if ( ! GdbObj::SaveAttribs( osOut))
bOk = false ;
if ( ! GdbObj::SaveAttribs( ngeOut))
return false ;
// parametri geometrici
osOut << "G" << endl ;
if ( ! m_pGeoObj->Save( osOut))
bOk = false ;
return bOk ;
ngeOut.WriteKey( NGE_G, true) ;
return pGObjRW->Save( ngeOut) ;
}
//----------------------------------------------------------------------------
@@ -150,7 +152,8 @@ GdbGeo::Load( const std::string& sType, Scanner& TheScanner, int& nParentId)
return false ;
// parametri geometrici
return m_pGeoObj->Load( TheScanner) ;
IGeoObjRW* pGObjRW = dynamic_cast<IGeoObjRW*>( m_pGeoObj) ;
return ( pGObjRW != nullptr && pGObjRW->Load( TheScanner)) ;
}
//----------------------------------------------------------------------------
GdbGeo.h
+1 -1
View File
@@ -25,7 +25,7 @@ class GdbGeo : public GdbObj
public :
virtual ~GdbGeo( void) ;
virtual GdbGeo* Clone( int nId, IdManager& IdMgr) const ;
virtual bool Save( std::ostream& osOut) const ;
virtual bool Save( NgeWriter& ngeOut) const ;
virtual bool Load( const std::string& sType, Scanner& TheScanner, int& nParentId) ;
virtual bool GetLocalBBox( BBox3d& b3Loc, int nFlag, int nLev = 0) const ;
virtual bool GetBBox( const Frame3d& frRef, BBox3d& b3Ref, int nFlag, int nLev = 0) const ;
GdbGroup.cpp
+11 -10
View File
@@ -15,8 +15,9 @@
#include "stdafx.h"
#include "GdbGroup.h"
#include "IdManager.h"
#include "NgeWriter.h"
#include "/EgtDev/Include/EGkGdbFunct.h"
#include "\EgtDev\Include\EGnStringUtils.h"
#include "/EgtDev/Include/EGnStringUtils.h"
using namespace std ;
@@ -101,28 +102,28 @@ GdbGroup::Clone( int nId, IdManager& IdMgr) const
//----------------------------------------------------------------------------
bool
GdbGroup::Save( std::ostream& osOut) const
GdbGroup::Save( NgeWriter& ngeOut) const
{
bool bOk = true ;
// tipo entità
osOut << GetKey() << endl ;
// identificativi
osOut << m_nId << "@" << GetParentId() << endl ;
// tipo entità e identificativi
ngeOut.WriteKey( NGE_A_GRP, true) ;
ngeOut.WriteInt( m_nId, "@") ;
ngeOut.WriteInt( GetParentId(), nullptr, true) ;
// attributi
if ( ! GdbObj::SaveAttribs( osOut))
if ( ! GdbObj::SaveAttribs( ngeOut))
bOk = false ;
// dati del riferimento
osOut << "G" << endl ;
if ( ! m_gfrFrame.Save( osOut))
ngeOut.WriteKey( NGE_G, true) ;
if ( ! m_gfrFrame.Save( ngeOut))
bOk = false ;
// salvataggio dei figli
const GdbObj* pGdbObj = GetFirstObj() ;
while ( pGdbObj != nullptr) {
if ( ! pGdbObj->Save( osOut))
if ( ! pGdbObj->Save( ngeOut))
bOk = false ;
pGdbObj = pGdbObj->GetNext() ;
}
GdbGroup.h
+1 -5
View File
@@ -26,7 +26,7 @@ class GdbGroup : public GdbObj
public :
virtual ~GdbGroup( void) ;
virtual GdbGroup* Clone( int nId, IdManager& IdMgr) const ;
virtual bool Save( std::ostream& osOut) const ;
virtual bool Save( NgeWriter& ngeOut) const ;
virtual bool Load( const std::string& sType, Scanner& TheScanner, int& nParentId) ;
virtual bool GetLocalBBox( BBox3d& b3Loc, int nFlag, int nLev = 0) const ;
virtual bool GetBBox( const Frame3d& frRef, BBox3d& b3Ref, int nFlag, int nLev = 0) const ;
@@ -63,10 +63,6 @@ class GdbGroup : public GdbObj
const GdbObj* GetLastObj( void) const
{ return m_pLastObj ; }
public :
static const std::string& GetKey( void)
{ static std::string s_sKey = "A_GRP" ; return s_sKey ; }
public :
const Frame3d& GetFrame( void) const
{ return m_gfrFrame.GetFrame() ; }
GdbObj.cpp
+2 -2
View File
@@ -205,10 +205,10 @@ GdbObj::Remove( void)
// Attribs
//----------------------------------------------------------------------------
bool
GdbObj::SaveAttribs( std::ostream& osOut) const
GdbObj::SaveAttribs( NgeWriter& ngeOut) const
{
if ( m_pAttribs != nullptr)
return m_pAttribs->Save( osOut) ;
return m_pAttribs->Save( ngeOut) ;
return true ;
}
GdbObj.h
+3 -3
View File
@@ -19,10 +19,10 @@
#include "/EgtDev/Include/EGkBBox3d.h"
#include <string>
class GdbGroup ;
class IdManager ;
class Attribs ;
class NgeWriter ;
//----------------------------------------------------------------------------
class GdbObj
@@ -30,7 +30,7 @@ class GdbObj
public :
virtual ~GdbObj( void) ;
virtual GdbObj* Clone( int nId, IdManager& IdMgr) const = 0 ;
virtual bool Save( std::ostream& osOut) const = 0 ;
virtual bool Save( NgeWriter& ngeOut) const = 0 ;
virtual bool Load( const std::string& sType, Scanner& TheScanner, int& nParentId) = 0 ;
virtual bool GetLocalBBox( BBox3d& b3Loc, int nFlag, int nLev = 0) const = 0 ;
virtual bool GetBBox( const Frame3d& frRef, BBox3d& b3Ref, int nFlag, int nLev = 0) const = 0 ;
@@ -48,7 +48,7 @@ class GdbObj
bool Copy( const GdbObj* pSou) ;
public :
bool SaveAttribs( std::ostream& osOut) const ;
bool SaveAttribs( NgeWriter& ngeOut) const ;
bool LoadAttribs( Scanner& TheScanner) ;
Attribs* GetAttribs( void)
{ return m_pAttribs ; }
GeoFrame3d.cpp
+14 -6
View File
@@ -15,6 +15,7 @@
#include "stdafx.h"
#include "GeoFrame3d.h"
#include "GeoObjFactory.h"
#include "NgeWriter.h"
#include "/EgtDev/Include/EGkStringUtils3d.h"
#include "/EgtDev/Include/EGkPolyLine.h"
#include <new>
@@ -22,7 +23,7 @@
using namespace std ;
//----------------------------------------------------------------------------
GEOOBJ_REGISTER( GEO_FRAME3D, "G_FRM", GeoFrame3d) ;
GEOOBJ_REGISTER( GEO_FRAME3D, NGE_G_FRM, GeoFrame3d) ;
//----------------------------------------------------------------------------
GeoFrame3d::GeoFrame3d( void)
@@ -92,6 +93,13 @@ GeoFrame3d::Copy( const GeoFrame3d& gfSrc)
return Set( gfSrc.m_frF) ;
}
//----------------------------------------------------------------------------
GeoObjType
GeoFrame3d::GetType( void) const
{
return static_cast<GeoObjType>( GEOOBJ_GETTYPE( GeoFrame3d)) ;
}
//----------------------------------------------------------------------------
const string&
GeoFrame3d::GetTitle( void) const
@@ -114,17 +122,17 @@ GeoFrame3d::Dump( string& sOut, const char* szNewLine) const
}
//----------------------------------------------------------------------------
const string&
GeoFrame3d::GetKey( void) const
int
GeoFrame3d::GetNgeId( void) const
{
return GEOOBJ_GETKEY( GeoFrame3d) ;
return GEOOBJ_GETNGEID( GeoFrame3d) ;
}
//----------------------------------------------------------------------------
bool
GeoFrame3d::Save( ostream& osOut) const
GeoFrame3d::Save( NgeWriter& ngeOut) const
{
osOut << ToString( m_frF) << ";" << endl ;
ngeOut.WriteFrame( m_frF, ";", true) ;
return true ;
}
GeoFrame3d.h
+5 -5
View File
@@ -15,23 +15,23 @@
#include "ObjGraphicsMgr.h"
#include "DllMain.h"
#include "GeoObjRW.h"
#include "/EgtDev/Include/EGkGeoFrame3d.h"
//----------------------------------------------------------------------------
class GeoFrame3d : public IGeoFrame3d
class GeoFrame3d : public IGeoFrame3d, public IGeoObjRW
{
public : // IGeoObj
virtual ~GeoFrame3d( void) ;
virtual GeoFrame3d* Clone( void) const ;
virtual GeoObjType GetType( void) const
{ return GEO_FRAME3D ; }
virtual GeoObjType GetType( void) const ;
virtual bool IsValid( void) const
{ return ( m_frF.GetType() != Frame3d::ERR) ; }
virtual const std::string& GetTitle( void) const ;
virtual bool Dump( std::string& sOut, const char* szNewLine = "\n") const ;
virtual const std::string& GetKey( void) const ;
virtual bool Save( std::ostream& osOut) const ;
virtual int GetNgeId( void) const ;
virtual bool Save( NgeWriter& ngeOut) const ;
virtual bool Load( Scanner& TheScanner) ;
virtual bool GetLocalBBox( BBox3d& b3Loc) const ;
virtual bool GetBBox( const Frame3d& frRef, BBox3d& b3Ref) const ;
GeoObjFactory.h
+34 -11
View File
@@ -13,34 +13,41 @@
#pragma once
#include "NgeKeyW.h"
#include "/EgtDev/Include/EGkGeoObj.h"
#include <string>
#include <unordered_map>
#include "/EgtDev/Include/EGkGeoObj.h"
//----------------------------------------------------------------------------
#define GEOOBJ_REGISTER(nKey,sKey,T) static const bool bReg_##T = GeoObjRegister<class T>::DoRegister(nKey,sKey)
#define GEOOBJ_GETTYPE( T) GeoObjRegister<class T>::GetType()
#define GEOOBJ_GETKEY( T) GeoObjRegister<class T>::GetKey()
#define GEOOBJ_KEYTOTYPE( sKey) GeoObjFactory::KeyToType( sKey)
#define GEOOBJ_CREATE( nKey) GeoObjFactory::Create( nKey)
#define GEOOBJ_REGISTER( nKey, nNgeId, T) static const bool bReg_##T = \
GeoObjRegister<class T>::DoRegister( nKey, nNgeId)
#define GEOOBJ_GETTYPE( T) GeoObjRegister<class T>::GetType()
#define GEOOBJ_GETKEY( T) GeoObjRegister<class T>::GetKey()
#define GEOOBJ_GETNGEID( T) GeoObjRegister<class T>::GetNgeId()
#define GEOOBJ_KEYTOTYPE( sKey) GeoObjFactory::KeyToType( sKey)
#define GEOOBJ_NGEIDTOTYPE( nNgeId) GeoObjFactory::NgeIdToType( nNgeId)
#define GEOOBJ_CREATE( nKey) GeoObjFactory::Create( nKey)
//----------------------------------------------------------------------------
template <class T>
class GeoObjRegister
{
public :
static bool DoRegister( int nKey, std::string sKey)
{ if ( ! GeoObjFactory::Register( nKey, sKey, Create))
static bool DoRegister( int nKey, int nNgeId)
{ if ( ! GeoObjFactory::Register( nKey, NgeAscKeyW[nNgeId], nNgeId, Create))
return false ;
GetTypePrivate() = nKey ;
GetKeyPrivate() = sKey ;
GetKeyPrivate() = NgeAscKeyW[nNgeId] ;
GetNgeIdPrivate() = nNgeId ;
return true ; }
static IGeoObj* Create( void)
{ return new(nothrow) T ; }
static const int& GetType( void)
static int GetType( void)
{ return GetTypePrivate() ; }
static const std::string& GetKey( void)
{ return GetKeyPrivate() ; }
static int GetNgeId( void)
{ return GetNgeIdPrivate() ; }
private :
GeoObjRegister( void) {}
@@ -51,6 +58,9 @@ class GeoObjRegister
static std::string& GetKeyPrivate( void)
{ static std::string s_sKey ;
return s_sKey ; }
static int& GetNgeIdPrivate( void)
{ static int s_nNgeId ;
return s_nNgeId ; }
} ;
//----------------------------------------------------------------------------
@@ -60,8 +70,9 @@ class GeoObjFactory
// definizione del tipo funzione di creazione
typedef IGeoObj* ( *GeoCreator) ( void) ;
// per registrare le funzioni di creazione
static bool Register( int nKey, std::string sKey, GeoCreator Creator)
static bool Register( int nKey, std::string sKey, int nNgeId, GeoCreator Creator)
{ return GetKeyTypeMap().insert( std::pair< std::string, int>( sKey, nKey)).second &&
GetNgeIdTypeMap().insert( std::pair< int, int>( nNgeId, nKey)).second &&
GetCreatorMap().insert( std::pair< int, GeoCreator>( nKey, Creator)).second ; }
// per restituire il tipo data la chiave
static int KeyToType( std::string sKey)
@@ -69,6 +80,12 @@ class GeoObjFactory
if ( Iter != GetKeyTypeMap().end())
return Iter->second ;
return 0 ; }
// per restituire il tipo dato l'indice Nge
static int NgeIdToType( int nNgeId)
{ NgeIdTypeMap::iterator Iter = GetNgeIdTypeMap().find( nNgeId) ;
if ( Iter != GetNgeIdTypeMap().end())
return Iter->second ;
return 0 ; }
// per creare l'oggetto richiesto
static IGeoObj* Create( int nKey)
{ CreatorMap::iterator Iter = GetCreatorMap().find( nKey) ;
@@ -87,6 +104,12 @@ class GeoObjFactory
static KeyTypeMap& GetKeyTypeMap( void)
{ static KeyTypeMap s_KeyTypeMap ;
return s_KeyTypeMap ; }
// definizione del tipo mappa con coppie NgeId, tipo
typedef std::unordered_map<int, int> NgeIdTypeMap ;
// metodo di accesso alla mappa statica
static NgeIdTypeMap& GetNgeIdTypeMap( void)
{ static NgeIdTypeMap s_NgeIdTypeMap ;
return s_NgeIdTypeMap ; }
// definizione del tipo mappa con coppie tipo, funzione di creazione
typedef std::unordered_map<int, GeoCreator> CreatorMap ;
// metodo di accesso alla mappa statica
GeoObjRW.h
+27
View File
@@ -0,0 +1,27 @@
//----------------------------------------------------------------------------
// EgalTech 2014-2014
//----------------------------------------------------------------------------
// File : GeoObjRW.h Data : 14.03.14 Versione : 1.5d5
// Contenuto : Dichiarazione della interfaccia IGeoObjRW.
//
//
//
// Modifiche : 20.11.13 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------
#pragma once
#include "/EgtDev/Include/EGnScan.h"
class NgeWriter ;
//-----------------------------------------------------------------------------
class __declspec( novtable) IGeoObjRW
{
public :
virtual int GetNgeId( void) const = 0 ;
virtual bool Save( NgeWriter& ngeOut) const = 0 ;
virtual bool Load( Scanner& TheScanner) = 0 ;
} ;
GeoPoint3d.cpp
+14 -6
View File
@@ -15,13 +15,14 @@
#include "stdafx.h"
#include "GeoPoint3d.h"
#include "GeoObjFactory.h"
#include "NgeWriter.h"
#include "\EgtDev\Include\EGkStringUtils3d.h"
#include <new>
using namespace std ;
//----------------------------------------------------------------------------
GEOOBJ_REGISTER( GEO_PNT3D, "G_PNT", GeoPoint3d) ;
GEOOBJ_REGISTER( GEO_PNT3D, NGE_G_PNT, GeoPoint3d) ;
//----------------------------------------------------------------------------
GeoPoint3d::GeoPoint3d( void)
@@ -82,6 +83,13 @@ GeoPoint3d::Copy( const GeoPoint3d& clSrc)
return Set( clSrc.m_ptP) ;
}
//----------------------------------------------------------------------------
GeoObjType
GeoPoint3d::GetType( void) const
{
return static_cast<GeoObjType>( GEOOBJ_GETTYPE( GeoPoint3d)) ;
}
//----------------------------------------------------------------------------
const string&
GeoPoint3d::GetTitle( void) const
@@ -101,18 +109,18 @@ GeoPoint3d::Dump( string& sOut, const char* szNewLine) const
}
//----------------------------------------------------------------------------
const string&
GeoPoint3d::GetKey( void) const
int
GeoPoint3d::GetNgeId( void) const
{
return GEOOBJ_GETKEY( GeoPoint3d) ;
return GEOOBJ_GETNGEID( GeoPoint3d) ;
}
//----------------------------------------------------------------------------
bool
GeoPoint3d::Save( ostream& osOut) const
GeoPoint3d::Save( NgeWriter& ngeOut) const
{
// parametri : punto
osOut << ToString( m_ptP) << ";" << endl ;
ngeOut.WritePoint( m_ptP, ";", true) ;
return true ;
}
GeoPoint3d.h
+5 -5
View File
@@ -15,23 +15,23 @@
#include "ObjGraphicsMgr.h"
#include "DllMain.h"
#include "GeoObjRW.h"
#include "/EgtDev/Include/EGkGeoPoint3d.h"
//----------------------------------------------------------------------------
class GeoPoint3d : public IGeoPoint3d
class GeoPoint3d : public IGeoPoint3d, public IGeoObjRW
{
public : // IGeoObj
virtual ~GeoPoint3d( void) ;
virtual GeoPoint3d* Clone( void) const ;
virtual GeoObjType GetType( void) const
{ return GEO_PNT3D ; }
virtual GeoObjType GetType( void) const ;
virtual bool IsValid( void) const
{ return true ; }
virtual const std::string& GetTitle( void) const ;
virtual bool Dump( std::string& sOut, const char* szNewLine = "\n") const ;
virtual const std::string& GetKey( void) const ;
virtual bool Save( std::ostream& osOut) const ;
virtual int GetNgeId( void) const ;
virtual bool Save( NgeWriter& ngeOut) const ;
virtual bool Load( Scanner& TheScanner) ;
virtual bool GetLocalBBox( BBox3d& b3Loc) const ;
virtual bool GetBBox( const Frame3d& frRef, BBox3d& b3Ref) const ;
GeoVector3d.cpp
+14 -6
View File
@@ -15,6 +15,7 @@
#include "stdafx.h"
#include "GeoVector3d.h"
#include "GeoObjFactory.h"
#include "NgeWriter.h"
#include "/EgtDev/Include/EGkStringUtils3d.h"
#include "/EgtDev/Include/EGkPolyLine.h"
#include <new>
@@ -22,7 +23,7 @@
using namespace std ;
//----------------------------------------------------------------------------
GEOOBJ_REGISTER( GEO_VECT3D, "G_VEC", GeoVector3d) ;
GEOOBJ_REGISTER( GEO_VECT3D, NGE_G_VEC, GeoVector3d) ;
//----------------------------------------------------------------------------
GeoVector3d::GeoVector3d( void)
@@ -83,6 +84,13 @@ GeoVector3d::Copy( const GeoVector3d& clSrc)
return Set( clSrc.m_vtV) ;
}
//----------------------------------------------------------------------------
GeoObjType
GeoVector3d::GetType( void) const
{
return static_cast<GeoObjType>( GEOOBJ_GETTYPE( GeoVector3d)) ;
}
//----------------------------------------------------------------------------
const string&
GeoVector3d::GetTitle( void) const
@@ -102,18 +110,18 @@ GeoVector3d::Dump( string& sOut, const char* szNewLine) const
}
//----------------------------------------------------------------------------
const string&
GeoVector3d::GetKey( void) const
int
GeoVector3d::GetNgeId( void) const
{
return GEOOBJ_GETKEY( GeoVector3d) ;
return GEOOBJ_GETNGEID( GeoVector3d) ;
}
//----------------------------------------------------------------------------
bool
GeoVector3d::Save( ostream& osOut) const
GeoVector3d::Save( NgeWriter& ngeOut) const
{
// parametri : vettore
osOut << ToString( m_vtV) << ";" << endl ;
ngeOut.WriteVector( m_vtV, ";", true) ;
return true ;
}
GeoVector3d.h
+5 -5
View File
@@ -15,22 +15,22 @@
#include "ObjGraphicsMgr.h"
#include "DllMain.h"
#include "GeoObjRW.h"
#include "/EgtDev/Include/EGkGeoVector3d.h"
//----------------------------------------------------------------------------
class GeoVector3d : public IGeoVector3d
class GeoVector3d : public IGeoVector3d, public IGeoObjRW
{
public : // IGeoObj
virtual ~GeoVector3d( void) ;
virtual GeoVector3d* Clone( void) const ;
virtual GeoObjType GetType( void) const
{ return GEO_VECT3D ; }
virtual GeoObjType GetType( void) const ;
virtual bool IsValid( void) const
{ return true ; }
virtual const std::string& GetTitle( void) const ;
virtual bool Dump( std::string& sOut, const char* szNewLine = "\n") const ;
virtual const std::string& GetKey( void) const ;
virtual bool Save( std::ostream& osOut) const ;
virtual int GetNgeId( void) const ;
virtual bool Save( NgeWriter& ngeOut) const ;
virtual bool Load( Scanner& TheScanner) ;
virtual bool GetLocalBBox( BBox3d& b3Loc) const ;
virtual bool GetBBox( const Frame3d& frRef, BBox3d& b3Ref) const ;
GeomDB.cpp
+33 -18
View File
@@ -17,7 +17,9 @@
#include "GdbGeo.h"
#include "DllMain.h"
#include "Attribs.h"
#include "NgeWriter.h"
#include "/EgtDev/Include/EgnStringUtils.h"
#include "/EgtDev/Include/EGkStringUtils3d.h"
#include "/EgtDev/Include/EgnStringConverter.h"
#include "/EgtDev/Include/EgtPointerOwner.h"
#include <new>
@@ -182,7 +184,7 @@ GeomDB::LoadOneObj( Scanner& TheScanner, bool& bEnd)
return true ;
}
// se gruppo
else if ( sType == GdbGroup::GetKey()) {
else if ( sType == "A_GRP") {
pGdbObj = new( nothrow) GdbGroup ;
}
// se copia TODO ("X_CPY")..
@@ -210,16 +212,15 @@ GeomDB::LoadOneObj( Scanner& TheScanner, bool& bEnd)
//----------------------------------------------------------------------------
bool
GeomDB::Save( const std::string& sFileOut) const
GeomDB::Save( const std::string& sFileOut, bool bBinary) const
{
// apertura file
ofstream ofSave ;
ofSave.open( stringtoW( sFileOut)) ;
if ( ! ofSave.good())
NgeWriter ngeOut ;
if ( ! ngeOut.Init( sFileOut, bBinary))
return false ;
// intestazione
bool bOk = SaveHeader( ofSave) ;
bool bOk = SaveHeader( ngeOut) ;
// ciclo di scrittura degli oggetti
const GdbObj* pGdbObj = m_GrpRadix.GetFirstObj() ;
@@ -230,36 +231,50 @@ GeomDB::Save( const std::string& sFileOut) const
// se non temporaneo
if ( nLevel != GDB_LV_TEMP) {
// salvo l'oggetto
if ( ! pGdbObj->Save( ofSave))
if ( ! pGdbObj->Save( ngeOut))
bOk = false ;
}
// passo al successivo
pGdbObj = pGdbObj->GetNext() ;
}
ofSave << "END" << endl ;
// terminazione
if ( ! SaveFooter( ngeOut))
bOk = false ;
// chiusura file
ofSave.close() ;
if ( ! ngeOut.Close())
bOk = false ;
return bOk ;
}
//----------------------------------------------------------------------------
bool
GeomDB::SaveHeader( ostream& osOut) const
GeomDB::SaveHeader( NgeWriter& ngeOut) const
{
// intestazione
osOut << "START" << endl ;
osOut << "GeomDB,1.5.3.9;" << endl ;
ngeOut.WriteKey( NGE_START, true) ;
ngeOut.WriteString( NGE_GEOMDB, ",") ;
ngeOut.WriteInt( NGE_MAJOR_VER, ".") ;
ngeOut.WriteInt( NGE_MINOR_VER, ".") ;
ngeOut.WriteInt( NGE_PATCH_VER, ";", true) ;
// materiale di default come colore
osOut << "MAT_DEF" << endl ;
Color colDef( 0, 0, 0, 0) ;
GetDefaultMaterial( colDef) ;
osOut << ToString( colDef.GetIntRed()) << "," ;
osOut << ToString( colDef.GetIntGreen()) << "," ;
osOut << ToString( colDef.GetIntBlue()) << "," ;
osOut << ToString( colDef.GetIntAlpha()) << ";" << endl ;
GetDefaultMaterial( colDef) ;
ngeOut.WriteKey( NGE_MAT_DEF, true) ;
ngeOut.WriteCol( colDef, ";", true) ;
return true ;
}
//----------------------------------------------------------------------------
bool
GeomDB::SaveFooter( NgeWriter& ngeOut) const
{
// terminazione
ngeOut.WriteKey( NGE_END, true) ;
return true ;
}
GeomDB.h
+4 -2
View File
@@ -20,6 +20,7 @@
#include "SelManager.h"
#include "/EgtDev/Include/EGkGeomDB.h"
class NgeWriter ;
//----------------------------------------------------------------------------
class GeomDB : public IGeomDB
@@ -31,7 +32,7 @@ class GeomDB : public IGeomDB
virtual bool Init( void) ;
virtual bool Clear( void) ;
virtual bool Load( const std::string& sFileIn) ;
virtual bool Save( const std::string& sFileOut) const ;
virtual bool Save( const std::string& sFileOut, bool bBinary = true) const ;
virtual bool ExistsObj( int nId) const ;
virtual int AddGroup( int nId, int nParentId, const Frame3d& frFrame) ;
virtual int AddGeoObj( int nId, int nParentId, IGeoObj* pGeoObj) ;
@@ -132,7 +133,8 @@ class GeomDB : public IGeomDB
bool Erase( GdbObj* pGObj) ;
bool LoadHeader( Scanner& TheScanner) ;
bool LoadOneObj( Scanner& TheScanner, bool& bEnd) ;
bool SaveHeader( std::ostream& osOut) const ;
bool SaveHeader( NgeWriter& ngeOut) const ;
bool SaveFooter( NgeWriter& ngeOut) const ;
bool SetStatus( GdbObj* pGdbObj, int nStat) ;
bool RevertStatus( GdbObj* pGdbObj) ;
bool AddGdbIteratorToList( GdbIterator* pIter)
NgeConst.h
+44
View File
@@ -0,0 +1,44 @@
//----------------------------------------------------------------------------
// EgalTech 2014-2014
//----------------------------------------------------------------------------
// File : NgeConst.h Data : 12.04.14 Versione : 1.5d3
// Contenuto : Costanti per file Nge.
//
//
//
// Modifiche : 12.04.14 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------
#pragma once
#include <string>
//----------------------------------------------------------------------------
// Costanti per file NGE
//----------------------------------------------------------------------------
// versione
const int NGE_MAJOR_VER = 1 ;
const int NGE_MINOR_VER = 5 ;
const int NGE_PATCH_VER = 4 ;
// nome GDB
const std::string NGE_GEOMDB = "GeomDB" ;
// indici KeyWord
const int NGE_START = 0 ;
const int NGE_END = 1 ;
const int NGE_MAT_DEF = 2 ;
const int NGE_A = 3 ;
const int NGE_G = 4 ;
const int NGE_P = 5 ;
const int NGE_A_GRP = 6 ;
const int NGE_X_CPY = 7 ;
const int NGE_G_VEC = 8 ;
const int NGE_G_PNT = 9 ;
const int NGE_G_FRM = 10 ;
const int NGE_C_LIN = 11 ;
const int NGE_C_ARC = 12 ;
const int NGE_C_BEZ = 13 ;
const int NGE_C_CMP = 14 ;
const int NGE_S_TRM = 15 ;
const int NGE_LAST_ID = 15 ; // ultimo valore
NgeKeyW.h
+63
View File
@@ -0,0 +1,63 @@
//----------------------------------------------------------------------------
// EgalTech 2014-2014
//----------------------------------------------------------------------------
// File : NgeKeyW.h Data : 13.04.14 Versione : 1.5d5
// Contenuto : Parole chiave per file Nge.
//
//
//
// Modifiche : 13.04.14 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------
#pragma once
#include "NgeConst.h"
#include "/EgtDev/Include/EGkGeoObjType.h"
#include <string>
//----------------------------------------------------------------------------
// KeyWord per file NGE ASCII
//----------------------------------------------------------------------------
const std::string NgeAscKeyW[] = { "START", // NGE_START
"END", // NGE_END
"MAT_DEF", // NGE_MAT_DEF
"A", // NGE_A
"G", // NGE_G
"P", // NGE_P
"A_GRP", // NGE_A_GRP
"X_CPY", // NGE_X_CPY
"G_VEC", // NGE_G_VEC
"G_PNT", // NGE_G_PNT
"G_FRM", // NGE_G_FRM
"C_LIN", // NGE_C_LIN
"C_ARC", // NGE_C_ARC
"C_BEZ", // NGE_C_BEZ
"C_CMP", // NGE_C_CMP
"S_TRM"} ; // NGE_S_TRM
//----------------------------------------------------------------------------
// KeyWord per file NGE BINARY
//----------------------------------------------------------------------------
// basi per KeyWord binarie
const int NGEB_GEN_BASE = 0x0000 ;
const int NGEB_GDB_BASE = 0x1000 ;
const int NGEB_GEO_BASE = 0x2000 ;
// KeyWord binarie
const int NgeBinKeyW[] = { NGEB_GEN_BASE + 0x0F0F, // NGE_START
NGEB_GEN_BASE + 0x0FFF, // NGE_END
NGEB_GEN_BASE + 0x0100, // NGE_MAT_DEF
NGEB_GEN_BASE + 0x0200, // NGE_A
NGEB_GEN_BASE + 0x0201, // NGE_G
NGEB_GEN_BASE + 0x0202, // NGE_P
NGEB_GDB_BASE + 0x0000, // NGE_A_GRP
NGEB_GDB_BASE + 0x0001, // NGE_X_CPY
NGEB_GEO_BASE + GEO_VECT3D, // NGE_G_VEC
NGEB_GEO_BASE + GEO_PNT3D, // NGE_G_PNT
NGEB_GEO_BASE + GEO_FRAME3D, // NGE_G_FRM
NGEB_GEO_BASE + CRV_LINE, // NGE_C_LIN
NGEB_GEO_BASE + CRV_ARC, // NGE_C_ARC
NGEB_GEO_BASE + CRV_BEZ, // NGE_C_BEZ
NGEB_GEO_BASE + CRV_COMPO, // NGE_C_CMP
NGEB_GEO_BASE + SRF_TRIMESH} ; // NGE_S_TRM
NgeWriter.cpp
+262
View File
@@ -0,0 +1,262 @@
//----------------------------------------------------------------------------
// EgalTech 2014-2014
//----------------------------------------------------------------------------
// File : NgeWriter.cpp Data : 13.04.14 Versione : 1.5d5
// Contenuto : Implementazione della classe Writer.
//
//
//
// Modifiche : 13.04.14 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------
//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "NgeWriter.h"
#include "NgeConst.h"
#include "NgeKeyW.h"
#include "/EgtDev/Include/EGkStringUtils3d.h"
#include "/EgtDev/Include/EgnStringConverter.h"
using namespace std ;
//----------------------------------------------------------------------------
bool
NgeWriter::Init( const std::string& sFileOut, bool bBinary)
{
// salvo tipo file
m_bBinary = bBinary ;
// apertura del file di uscita
ios_base::openmode nMode = ios::out | ( m_bBinary ? ios::binary : 0) ;
int nProt = _SH_DENYWR ;
m_OutFile.open( stringtoW( sFileOut), nMode, nProt) ;
return m_OutFile.good() ;
}
//----------------------------------------------------------------------------
bool
NgeWriter::Close( void)
{
bool bOk = ( m_OutFile.good() && m_OutFile.is_open()) ;
if ( m_OutFile.is_open())
m_OutFile.close() ;
return bOk ;
}
//----------------------------------------------------------------------------
void
NgeWriter::WriteUchar( unsigned char ucVal, const char* szSep, bool bEndL)
{
if ( ! m_OutFile.is_open())
return ;
if ( m_bBinary)
m_OutFile.write( (char*) &ucVal, sizeof( ucVal)) ;
else {
m_OutFile << ToString( ucVal) ;
if ( szSep != nullptr)
m_OutFile << szSep ;
if ( bEndL)
m_OutFile << endl ;
}
}
//----------------------------------------------------------------------------
void
NgeWriter::WriteBool( bool bVal, const char* szSep, bool bEndL)
{
if ( ! m_OutFile.is_open())
return ;
if ( m_bBinary)
m_OutFile.write( (char*) &bVal, sizeof( bVal)) ;
else {
m_OutFile << ToString( bVal) ;
if ( szSep != nullptr)
m_OutFile << szSep ;
if ( bEndL)
m_OutFile << endl ;
}
}
//----------------------------------------------------------------------------
void
NgeWriter::WriteInt( int nVal, const char* szSep, bool bEndL)
{
if ( ! m_OutFile.is_open())
return ;
if ( m_bBinary)
m_OutFile.write( (char*) &nVal, sizeof( nVal)) ;
else {
m_OutFile << ToString( nVal) ;
if ( szSep != nullptr)
m_OutFile << szSep ;
if ( bEndL)
m_OutFile << endl ;
}
}
//----------------------------------------------------------------------------
void
NgeWriter::WriteDouble( double dVal, const char* szSep, bool bEndL, int nPrec)
{
if ( ! m_OutFile.is_open())
return ;
if ( m_bBinary)
m_OutFile.write( (char*) &dVal, sizeof( dVal)) ;
else {
m_OutFile << ToString( dVal, nPrec) ;
if ( szSep != nullptr)
m_OutFile << szSep ;
if ( bEndL)
m_OutFile << endl ;
}
}
//----------------------------------------------------------------------------
void
NgeWriter::WriteString( const std::string& sVal, const char* szSep, bool bEndL)
{
if ( ! m_OutFile.is_open())
return ;
if ( m_bBinary) {
int nDim= int( sVal.size()) ;
m_OutFile.write( (char*) &nDim, sizeof( nDim)) ;
m_OutFile.write( sVal.c_str(), sVal.size()) ;
}
else {
m_OutFile << sVal ;
if ( szSep != nullptr)
m_OutFile << szSep ;
if ( bEndL)
m_OutFile << endl ;
}
}
//----------------------------------------------------------------------------
void
NgeWriter::WriteVector( const Vector3d& vtV, const char* szSep, bool bEndL, int nPrec)
{
if ( ! m_OutFile.is_open())
return ;
if ( m_bBinary)
m_OutFile.write( (char*) &vtV.v, sizeof( vtV.v)) ;
else {
m_OutFile << ToString( vtV, nPrec) ;
if ( szSep != nullptr)
m_OutFile << szSep ;
if ( bEndL)
m_OutFile << endl ;
}
}
//----------------------------------------------------------------------------
void
NgeWriter::WritePoint( const Point3d& ptP, const char* szSep, bool bEndL, int nPrec)
{
if ( ! m_OutFile.is_open())
return ;
if ( m_bBinary)
m_OutFile.write( (char*) &ptP.v, sizeof( ptP.v)) ;
else {
m_OutFile << ToString( ptP, nPrec) ;
if ( szSep != nullptr)
m_OutFile << szSep ;
if ( bEndL)
m_OutFile << endl ;
}
}
//----------------------------------------------------------------------------
void
NgeWriter::WritePointW( const Point3d& ptP, double dW, const char* szSep, bool bEndL, int nPrecP, int nPrecW)
{
if ( ! m_OutFile.is_open())
return ;
if ( m_bBinary) {
m_OutFile.write( (char*) &ptP.v, sizeof( ptP.v)) ;
m_OutFile.write( (char*) &dW, sizeof( dW)) ;
}
else {
m_OutFile << ToString( ptP, dW, nPrecP, nPrecW) ;
if ( szSep != nullptr)
m_OutFile << szSep ;
if ( bEndL)
m_OutFile << endl ;
}
}
//----------------------------------------------------------------------------
void
NgeWriter::WriteFrame( const Frame3d& frF, const char* szSep, bool bEndL, int nPrecP, int nPrecV)
{
if ( ! m_OutFile.is_open())
return ;
if ( m_bBinary) {
m_OutFile.write( (char*) &frF.Orig().v, sizeof( frF.Orig().v)) ;
m_OutFile.write( (char*) &frF.VersX().v, sizeof( frF.VersX().v)) ;
m_OutFile.write( (char*) &frF.VersY().v, sizeof( frF.VersY().v)) ;
m_OutFile.write( (char*) &frF.VersZ().v, sizeof( frF.VersZ().v)) ;
}
else {
m_OutFile << ToString( frF, nPrecP, nPrecV) ;
if ( szSep != nullptr)
m_OutFile << szSep ;
if ( bEndL)
m_OutFile << endl ;
}
}
//----------------------------------------------------------------------------
void
NgeWriter::WriteKey( int nKey, bool bEndL)
{
if ( ! m_OutFile.is_open())
return ;
if ( nKey < 0 || nKey > NGE_LAST_ID)
return ;
if ( m_bBinary)
m_OutFile.write( (char*) &NgeBinKeyW[nKey], sizeof( int)) ;
else {
m_OutFile << NgeAscKeyW[nKey] ;
if ( bEndL)
m_OutFile << endl ;
}
}
//----------------------------------------------------------------------------
void
NgeWriter::WriteCol( const Color& cCol, const char* szSep, bool bEndL)
{
if ( ! m_OutFile.is_open())
return ;
if ( m_bBinary) {
unsigned char ucCol[4] ;
ucCol[0] = cCol.GetIntRed() ;
ucCol[1] = cCol.GetIntGreen() ;
ucCol[2] = cCol.GetIntBlue() ;
ucCol[3] = cCol.GetIntAlpha() ;
m_OutFile.write( (char*) ucCol, sizeof( ucCol)) ;
}
else {
m_OutFile << ToString( cCol) ;
if ( szSep != nullptr)
m_OutFile << szSep ;
if ( bEndL)
m_OutFile << endl ;
}
}
NgeWriter.h
+48
View File
@@ -0,0 +1,48 @@
//----------------------------------------------------------------------------
// EgalTech 2014-2014
//----------------------------------------------------------------------------
// File : NgeWriter.h Data : 12.04.14 Versione : 1.5d5
// Contenuto : Dichiarazione della classe NgeWriter.
//
//
//
// Modifiche : 12.04.14 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------
#pragma once
#include "NgeConst.h"
#include "/EgtDev/Include/EGkPoint3d.h"
#include "/EgtDev/Include/EGkColor.h"
#include <fstream>
//----------------------------------------------------------------------------
class NgeWriter
{
public :
NgeWriter( void) : m_bBinary( false) {}
~NgeWriter( void)
{ Close() ; }
bool Init( const std::string& sFileOut, bool bBinary) ;
bool Close( void) ;
void WriteUchar( unsigned char ucVal, const char* szSep, bool bEndL = false) ;
void WriteBool( bool bVal, const char* szSep, bool bEndL = false) ;
void WriteInt( int nVal, const char* szSep, bool bEndL = false) ;
void WriteDouble( double dVal, const char* szSep, bool bEndL = false, int nPrec = 6) ;
void WriteVector( const Vector3d& vtV, const char* szSep, bool bEndL = false, int nPrec = 9) ;
void WritePoint( const Point3d& ptP, const char* szSep, bool bEndL = false, int nPrec = 6) ;
void WritePointW( const Point3d& ptP, double dW, const char* szSep, bool bEndL = false,
int nPrecP = 6, int nPrecW = 9) ;
void WriteFrame( const Frame3d& frF, const char* szSep, bool bEndL, int nPrecP = 6, int nPrecV = 9) ;
void WriteString( const std::string& sVal, const char* szSep, bool bEndL = false) ;
void WriteKey( int nKey, bool bEndL) ;
void WriteCol( const Color& cCol, const char* szSep, bool bEndL = false) ;
private :
bool m_bBinary ;
std::ofstream m_OutFile ;
} ;
SurfTriMesh.cpp
+30 -22
View File
@@ -15,6 +15,7 @@
#include "stdafx.h"
#include "SurfTriMesh.h"
#include "GeoObjFactory.h"
#include "NgeWriter.h"
#include "Triangulate.h"
#include "\EgtDev\Include\EGkStringUtils3d.h"
#include "\EgtDev\Include\EGkPolyLine.h"
@@ -23,7 +24,7 @@
using namespace std ;
//----------------------------------------------------------------------------
GEOOBJ_REGISTER( SRF_TRIMESH, "S_TRM", SurfTriMesh) ;
GEOOBJ_REGISTER( SRF_TRIMESH, NGE_S_TRM, SurfTriMesh) ;
//----------------------------------------------------------------------------
SurfTriMesh::SurfTriMesh( void)
@@ -297,6 +298,13 @@ SurfTriMesh::Copy( const SurfTriMesh& stmSrc)
return true ;
}
//----------------------------------------------------------------------------
GeoObjType
SurfTriMesh::GetType( void) const
{
return static_cast<GeoObjType>( GEOOBJ_GETTYPE( SurfTriMesh)) ;
}
//----------------------------------------------------------------------------
const string&
SurfTriMesh::GetTitle( void) const
@@ -320,41 +328,41 @@ SurfTriMesh::Dump( string& sOut, const char* szNewLine) const
}
//----------------------------------------------------------------------------
const string&
SurfTriMesh::GetKey( void) const
int
SurfTriMesh::GetNgeId( void) const
{
return GEOOBJ_GETKEY( SurfTriMesh) ;
return GEOOBJ_GETNGEID( SurfTriMesh) ;
}
//----------------------------------------------------------------------------
bool
SurfTriMesh::Save( ostream& osOut) const
SurfTriMesh::Save( NgeWriter& ngeOut) const
{
// flag aperta/chiusa
osOut << ToString( m_bClosed) << ";" ;
ngeOut.WriteBool( m_bClosed, ";") ;
// numero di vertici
osOut << ToString( GetVertexNum()) << ";" ;
ngeOut.WriteInt( GetVertexNum(), ";") ;
// numero di triangoli
osOut << ToString( GetTriangleNum()) << ";" << endl ;
ngeOut.WriteInt( GetTriangleNum(), ";", true) ;
// ciclo sui vertici
for ( int i = 0 ; i < int( m_vVert.size()) ; ++ i) {
osOut << ToString( i) << ";" ;
osOut << ToString( m_vVert[i].ptP) << ";" ;
osOut << ToString( m_vVert[i].nIdTria) << ";" ;
osOut << ToString( m_vVert[i].nFlag) << ";" << endl ;
ngeOut.WriteInt( i, ";") ;
ngeOut.WritePoint( m_vVert[i].ptP, ";") ;
ngeOut.WriteInt( m_vVert[i].nIdTria, ";") ;
ngeOut.WriteInt( m_vVert[i].nFlag, ";", true) ;
}
// ciclo sui triangoli
for ( int i = 0 ; i < int( m_vTria.size()) ; ++ i) {
osOut << ToString( i) << ";" ;
osOut << ToString( m_vTria[i].nIdVert[0]) << "," ;
osOut << ToString( m_vTria[i].nIdVert[1]) << "," ;
osOut << ToString( m_vTria[i].nIdVert[2]) << ";" ;
osOut << ToString( m_vTria[i].nIdAdjac[0]) << "," ;
osOut << ToString( m_vTria[i].nIdAdjac[1]) << "," ;
osOut << ToString( m_vTria[i].nIdAdjac[2]) << ";" ;
osOut << ToString( m_vTria[i].vtN) << ";" ;
osOut << ToString( m_vTria[i].nTFlag) << ";" ;
osOut << ToString( m_vTria[i].nEFlag) << ";" << endl ;
ngeOut.WriteInt( i, ";") ;
ngeOut.WriteInt( m_vTria[i].nIdVert[0], ",") ;
ngeOut.WriteInt( m_vTria[i].nIdVert[1], ",") ;
ngeOut.WriteInt( m_vTria[i].nIdVert[2], ";") ;
ngeOut.WriteInt( m_vTria[i].nIdAdjac[0], ",") ;
ngeOut.WriteInt( m_vTria[i].nIdAdjac[1], ",") ;
ngeOut.WriteInt( m_vTria[i].nIdAdjac[2], ";") ;
ngeOut.WriteVector( m_vTria[i].vtN, ";") ;
ngeOut.WriteInt( m_vTria[i].nTFlag, ";") ;
ngeOut.WriteInt( m_vTria[i].nEFlag, ";", true) ;
}
return true ;
SurfTriMesh.h
+5 -5
View File
@@ -15,6 +15,7 @@
#include "ObjGraphicsMgr.h"
#include "DllMain.h"
#include "GeoObjRW.h"
#include "/EgtDev/Include/EGkSurfTriMesh.h"
#include "/EgtDev/Include/EgtNumCollection.h"
@@ -58,19 +59,18 @@ class StmTria
} ;
//----------------------------------------------------------------------------
class SurfTriMesh : public ISurfTriMesh
class SurfTriMesh : public ISurfTriMesh, public IGeoObjRW
{
public : // IGeoObj
virtual ~SurfTriMesh( void) ;
virtual SurfTriMesh* Clone( void) const ;
virtual GeoObjType GetType( void) const
{ return SRF_TRIMESH ; }
virtual GeoObjType GetType( void) const ;
virtual bool IsValid( void) const
{ return ( m_nStatus == OK) ; }
virtual const std::string& GetTitle( void) const ;
virtual bool Dump( std::string& sOut, const char* szNewLine = "\n") const ;
virtual const std::string& GetKey( void) const ;
virtual bool Save( std::ostream& osOut) const ;
virtual int GetNgeId( void) const ;
virtual bool Save( NgeWriter& ngeOut) const ;
virtual bool Load( Scanner& TheScanner) ;
virtual bool GetLocalBBox( BBox3d& b3Loc) const ;
virtual bool GetBBox( const Frame3d& frRef, BBox3d& b3Ref) const ;