diff --git a/EgtGeomKernel.rc b/EgtGeomKernel.rc new file mode 100644 index 0000000..9dd32df Binary files /dev/null and b/EgtGeomKernel.rc differ diff --git a/EgtGeomKernel.sln b/EgtGeomKernel.sln new file mode 100644 index 0000000..69832cc --- /dev/null +++ b/EgtGeomKernel.sln @@ -0,0 +1,20 @@ + +Microsoft Visual Studio Solution File, Format Version 11.00 +# Visual Studio 2010 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "EgtGeomKernel", "EgtGeomKernel.vcxproj", "{9A98A202-2853-454A-84CA-DCD1714176C9}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Win32 = Debug|Win32 + Release|Win32 = Release|Win32 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {9A98A202-2853-454A-84CA-DCD1714176C9}.Debug|Win32.ActiveCfg = Debug|Win32 + {9A98A202-2853-454A-84CA-DCD1714176C9}.Debug|Win32.Build.0 = Debug|Win32 + {9A98A202-2853-454A-84CA-DCD1714176C9}.Release|Win32.ActiveCfg = Release|Win32 + {9A98A202-2853-454A-84CA-DCD1714176C9}.Release|Win32.Build.0 = Release|Win32 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/EgtGeomKernel.vcxproj b/EgtGeomKernel.vcxproj new file mode 100644 index 0000000..95fb480 --- /dev/null +++ b/EgtGeomKernel.vcxproj @@ -0,0 +1,142 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + + {9A98A202-2853-454A-84CA-DCD1714176C9} + EgtGeomKernel + MFCDLLProj + + + + DynamicLibrary + true + Unicode + false + + + DynamicLibrary + false + true + Unicode + false + + + + + + + + + + + + + true + $(ProjectName)D$(PlatformArchitecture) + $(SolutionDir)$(Configuration)$(PlatformArchitecture)\ + $(Configuration)$(PlatformArchitecture)\ + + + false + $(ProjectName)R$(PlatformArchitecture) + $(SolutionDir)$(Configuration)$(PlatformArchitecture)\ + $(Configuration)$(PlatformArchitecture)\ + + + + Use + Level3 + Disabled + WIN32;_WINDOWS;I_AM_EGK;_DEBUG;_USRDLL;%(PreprocessorDefinitions) + true + + + Windows + true + + + + + false + _DEBUG;%(PreprocessorDefinitions) + + + 0x0410 + _DEBUG;%(PreprocessorDefinitions) + $(IntDir);%(AdditionalIncludeDirectories) + + + copy $(TargetDir)$(TargetName).pdb \EgtDev\Lib\ +copy $(TargetDir)$(TargetName).lib \EgtDev\Lib\ +copy $(TargetPath) \EgtProg\Dll + + + + + Level3 + Use + MaxSpeed + true + true + WIN32;_WINDOWS;I_AM_EGK;NDEBUG;_USRDLL;%(PreprocessorDefinitions) + true + + + Windows + true + true + true + + + + + false + NDEBUG;%(PreprocessorDefinitions) + + + 0x0410 + NDEBUG;%(PreprocessorDefinitions) + $(IntDir);%(AdditionalIncludeDirectories) + + + copy $(TargetDir)$(TargetName).pdb \EgtDev\Lib\ +copy $(TargetDir)$(TargetName).lib \EgtDev\Lib\ +copy $(TargetPath) \EgtProg\Dll + + + + + + + + Create + Create + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/EgtGeomKernel.vcxproj.filters b/EgtGeomKernel.vcxproj.filters new file mode 100644 index 0000000..a28c81d --- /dev/null +++ b/EgtGeomKernel.vcxproj.filters @@ -0,0 +1,65 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + File di origine + + + File di origine + + + File di origine + + + File di origine + + + File di origine + + + + + File di intestazione + + + File di intestazione + + + File di intestazione + + + File di intestazione + + + File di intestazione + + + File di intestazione + + + File di intestazione + + + File di intestazione + + + + + File di risorse + + + \ No newline at end of file diff --git a/EgtGeomKernelDll.cpp b/EgtGeomKernelDll.cpp new file mode 100644 index 0000000..1f5748c --- /dev/null +++ b/EgtGeomKernelDll.cpp @@ -0,0 +1,40 @@ +//---------------------------------------------------------------------------- +// EgalTech 2013-2013 +//---------------------------------------------------------------------------- +// File : EgtGeomKernelDll.cpp Data : 20.11.13 Versione : 1.3a1 +// Contenuto : Inizializzazione della DLL. +// +// +// +// Modifiche : 16.11.13 DS Creazione modulo. +// +// +//---------------------------------------------------------------------------- + +//--------------------------- Include ---------------------------------------- +#include "stdafx.h" +#include +#include <\EgtDev\Include\EgtTrace.h> + +//--------------------------- Macro ------------------------------------------- +#ifdef _DEBUG +#define new DEBUG_NEW +#undef THIS_FILE +static char THIS_FILE[] = __FILE__; +#endif + + +//----------------------------------------------------------------------------- +extern "C" int APIENTRY +DllMain( HINSTANCE hInstance, DWORD dwReason, LPVOID lpReserved) +{ + + if ( dwReason == DLL_PROCESS_ATTACH) { + EGT_TRACE( "EgtGeomKernel.Dll Initializing!\n") ; + } + else if ( dwReason == DLL_PROCESS_DETACH) { + EGT_TRACE( "EgtGeomKernel.Dll Terminating!\n") ; + } + + return 1 ; +} diff --git a/EgtGeomKernelDll.h b/EgtGeomKernelDll.h new file mode 100644 index 0000000..f88ccdb --- /dev/null +++ b/EgtGeomKernelDll.h @@ -0,0 +1,20 @@ +//---------------------------------------------------------------------------- +// EgalTech 2013-2013 +//---------------------------------------------------------------------------- +// File : EgtGeomKernelDll.h Data : 20.11.13 Versione : 1.3a1 +// Contenuto : Dichiarazione per modulo EgtGeomKernelDll.cpp. +// +// +// +// Modifiche : 04.01.12 DS Creazione modulo. +// +// +//---------------------------------------------------------------------------- + +#pragma once + +//--------------------------- Prototipi --------------------------------------- +// DllMain é già dichiarata in header di sistema +//HMODULE GetDllModule( void) ; +//HINSTANCE GetResourceInstance( void) ; + diff --git a/Frame3d.cpp b/Frame3d.cpp new file mode 100644 index 0000000..b71148f --- /dev/null +++ b/Frame3d.cpp @@ -0,0 +1,305 @@ +//---------------------------------------------------------------------------- +// EgalTech 2013-2013 +//---------------------------------------------------------------------------- +// File : Frame3d.cpp Data : 20.11.13 Versione : 1.3a1 +// Contenuto : Funzioni della classe Riferimento 3d. +// +// +// +// Modifiche : 06.01.13 DS Creazione modulo. +// +// +//---------------------------------------------------------------------------- + +//--------------------------- Include ---------------------------------------- +#include "stdafx.h" +#include "\EgtDev\Include\EGkGeoConst.h" +#include "\EgtDev\Include\EGkFrame3d.h" + +//---------------------------------------------------------------------------- +Frame3d::Frame3d( void) +{ + Reset() ; +} + +//---------------------------------------------------------------------------- +bool +Frame3d::Set( const Point3d& ptOrig, const Vector3d& vtDirX, + const Vector3d& vtDirY, const Vector3d& vtDirZ) +{ + double dOrtXY ; + double dOrtYZ ; + double dOrtZX ; + double dRight ; + Vector3d vtTmp ; + + + // lo inizializzo come errato + m_nType = ERR ; + m_nZType = ERR ; + + // assegnazione dell'origine e delle direzioni + m_ptOrig = ptOrig ; + m_vtVersX = vtDirX ; + m_vtVersY = vtDirY ; + m_vtVersZ = vtDirZ ; + + // se le direzioni non sono normalizzabili, errore + if ( ! m_vtVersX.Normalize() || + ! m_vtVersY.Normalize() || + ! m_vtVersZ.Normalize()) + return false ; + + // verifica della ortogonalità dei versori e del senso destrorso + dOrtXY = m_vtVersX * m_vtVersY ; + dOrtYZ = m_vtVersY * m_vtVersZ ; + dOrtZX = m_vtVersZ * m_vtVersX ; + vtTmp = m_vtVersX ^ m_vtVersY ; + dRight = vtTmp * m_vtVersZ ; + if ( fabs( dOrtXY) > EPS_ZERO || + fabs( dOrtYZ) > EPS_ZERO || + fabs( dOrtZX) > EPS_ZERO || + dRight < EPS_ZERO) + return false ; + + // ne determino il tipo + CalculateType() ; + + return true ; +} + +//---------------------------------------------------------------------------- +bool +Frame3d::Set( const Point3d& ptOrig, const Point3d& ptOnX, const Point3d& ptNearY) +{ + Vector3d vtDirX ; + Vector3d vtDirY ; + Vector3d vtDirZ ; + Vector3d vtTemp ; + + + // calcolo il vettore che rappresenta l'asse X del piano + vtDirX = ptOnX - ptOrig ; + // calcolo il vettore che rappresenta un asse nel piano + vtTemp = ptNearY - ptOrig ; + // alcolo il vettore dell'asse Z + vtDirZ = vtDirX ^ vtTemp ; + // calcolo il vettore dell'asse Y + vtDirY = vtDirZ ^ vtDirX ; + + return Set( ptOrig, vtDirX, vtDirY, vtDirZ) ; +} + +//---------------------------------------------------------------------------- +bool +Frame3d::Set( const Point3d& ptOrig, Type nType) +{ + // origine + m_ptOrig = ptOrig ; + // orientamento + switch ( nType) { + case TOP : + m_nType = m_nZType ; + m_vtVersX.Set( 1, 0, 0) ; + m_vtVersY.Set( 0, 1, 0) ; + m_vtVersZ.Set( 0, 0, 1) ; + break ; + case BOTTOM : + m_nType = BOTTOM ; + m_vtVersX.Set( 1, 0, 0) ; + m_vtVersY.Set( 0, -1, 0) ; + m_vtVersZ.Set( 0, 0, -1) ; + break ; + case FRONT : + m_nType = FRONT ; + m_vtVersX.Set( 1, 0, 0) ; + m_vtVersY.Set( 0, 0, 1) ; + m_vtVersZ.Set( 0, -1, 0) ; + break ; + case BACK : + m_nType = BACK ; + m_vtVersX.Set( -1, 0, 0) ; + m_vtVersY.Set( 0, 0, 1) ; + m_vtVersZ.Set( 0, 1, 0) ; + break ; + case LEFT : + m_nType = LEFT ; + m_vtVersX.Set( 0, -1, 0) ; + m_vtVersY.Set( 0, 0, 1) ; + m_vtVersZ.Set( -1, 0, 0) ; + break ; + case RIGHT : + m_nType = RIGHT ; + m_vtVersX.Set( 0, 1, 0) ; + m_vtVersY.Set( 0, 0, 1) ; + m_vtVersZ.Set( 1, 0, 0) ; + break ; + default : + m_nType = ERR ; + break ; + } + // orientamento di Z coincide con quello generale + m_nZType = m_nType ; + + return ( m_nType != ERR) ; +} + +//---------------------------------------------------------------------------- +bool +Frame3d::Reset( void) +{ + m_nType = TOP ; + m_nZType = TOP ; + m_ptOrig.Set( 0, 0, 0) ; + m_vtVersX.Set( 1, 0, 0) ; + m_vtVersY.Set( 0, 1, 0) ; + m_vtVersZ.Set( 0, 0, 1) ; + + return true ; +} + +//---------------------------------------------------------------------------- +void +Frame3d::Translate( const Vector3d& vtMove) +{ + // verifico validità riferimento + if ( m_nType == ERR) + return ; + + // eseguo la traslazione + m_ptOrig.Translate( vtMove) ; + + // il tipo non cambia (dipende dall'orientamento e non dalla posizione) +} + +//---------------------------------------------------------------------------- +bool +Frame3d::Rotate( const Point3d& ptAx, const Vector3d& vtAx, double dAngRad) +{ + double dCosAng ; + double dSinAng ; + + + // verifico validità riferimento + if ( m_nType == ERR) + return false ; + + // calcolo seno e coseno dell'angolo di rotazione + dCosAng = cos( dAngRad) ; + dSinAng = sin( dAngRad) ; + + // controllo solo la prima rotazione, per le altre è lo stesso + if ( ! m_ptOrig.Rotate( ptAx, vtAx, dCosAng, dSinAng)) { + m_nType = ERR ; + m_nZType = ERR ; + return false ; + } + m_vtVersX.Rotate( vtAx, dCosAng, dSinAng) ; + m_vtVersY.Rotate( vtAx, dCosAng, dSinAng) ; + m_vtVersZ.Rotate( vtAx, dCosAng, dSinAng) ; + + // ricalcolo il tipo + CalculateType() ; + + return true ; +} + +//---------------------------------------------------------------------------- +bool +Frame3d::ToGlob( const Frame3d& frRef) +{ + // verifico validità deu frame + if ( GetType() == ERR || frRef.GetType() == ERR) + return false ; + + // eseguo la trasformazione + m_ptOrig.ToGlob( frRef) ; + m_vtVersX.ToGlob( frRef) ; + m_vtVersY.ToGlob( frRef) ; + m_vtVersZ.ToGlob( frRef) ; + + // ricalcolo il tipo + CalculateType() ; + + return true ; +} + +//---------------------------------------------------------------------------- +bool +Frame3d::ToLoc( const Frame3d& frRef) +{ + // verifico validità dei frame + if ( GetType() == ERR || frRef.GetType() == ERR) + return false ; + + // eseguo la trasformazione + m_ptOrig.ToLoc( frRef) ; + m_vtVersX.ToLoc( frRef) ; + m_vtVersY.ToLoc( frRef) ; + m_vtVersZ.ToLoc( frRef) ; + + // ricalcolo il tipo + CalculateType() ; + + return true ; +} + +//---------------------------------------------------------------------------- +void +Frame3d::CalculateType( void) +{ + // riferimento errato + m_nType = ERR ; + m_nZType = ERR ; + + // se la Zloc non ha componenti x e y globali allora é diretta come Zglob + if ( fabs( m_vtVersZ.x) < EPS_ZERO && fabs( m_vtVersZ.y) < EPS_ZERO) { + // se inoltre ha lo stesso verso di Zglob + if ( m_vtVersZ.z > 0) + m_nZType = TOP ; + else + m_nZType = BOTTOM ; + // se la Xloc coincide con Xglob Type coincide con ZType + if ( fabs( m_vtVersX.y) < EPS_ZERO && fabs( m_vtVersX.z) < EPS_ZERO && + m_vtVersX.x > 0) + m_nType = m_nZType ; + else + m_nType = GEN ; + } + + // se la Zloc non ha componenti y e z globali allora é diretta come Xglob + else if ( fabs( m_vtVersZ.y) < EPS_ZERO && fabs( m_vtVersZ.z) < EPS_ZERO) { + // se inoltre ha lo stesso verso di Xglob + if ( m_vtVersZ.x > 0) + m_nZType = RIGHT ; + else + m_nZType = LEFT ; + // se la Yloc coincide con Zglob Type coincide con ZType + if ( fabs( m_vtVersY.x) < EPS_ZERO && fabs( m_vtVersY.y) < EPS_ZERO && + m_vtVersY.z > 0) + m_nType = m_nZType ; + else + m_nType = GEN ; + } + + // se la Zloc non ha componenti z e x globali allora é diretta come Yglob + else if ( fabs( m_vtVersZ.z) < EPS_ZERO && fabs( m_vtVersZ.x) < EPS_ZERO) { + // se inoltre ha lo stesso verso di Yglob + if ( m_vtVersZ.y > 0) + m_nZType = BACK ; + else + m_nZType = FRONT ; + // se la Yloc coincide con Zglob Type coincide con ZType + if ( fabs( m_vtVersY.x) < EPS_ZERO && fabs( m_vtVersY.y) < EPS_ZERO && + m_vtVersY.z > 0) + m_nType = m_nZType ; + else + m_nType = GEN ; + } + + // altrimenti é generico + else { + m_nZType = GEN ; + m_nType = GEN ; + } +} diff --git a/GeomDB.cpp b/GeomDB.cpp new file mode 100644 index 0000000..858e263 --- /dev/null +++ b/GeomDB.cpp @@ -0,0 +1,650 @@ +//---------------------------------------------------------------------------- +// EgalTech 2013-2013 +//---------------------------------------------------------------------------- +// File : GeomDB.cpp Data : 08.04.13 Versione : 1.1c1 +// Contenuto : Implementazione della classe GeomDB. +// +// +// +// Modifiche : 22.01.13 DS Creazione modulo. +// +// +//---------------------------------------------------------------------------- + +//--------------------------- Include ---------------------------------------- +#include "stdafx.h" +#include +#include +#include "GeoConst.h" +#include "GeomDB.h" +#include "GdbObjFactory.h" +#include "GeoObjTypeFun.h" +#include "Scan.h" +#include "StringUtils.h" + +using namespace std ; + +//---------------------------------------------------------------------------- +// GeomDB +//---------------------------------------------------------------------------- +GeomDB::GeomDB( void) +{ +} + +//---------------------------------------------------------------------------- +GeomDB::~GeomDB( void) +{ + Clear() ; +} + +//---------------------------------------------------------------------------- +bool +GeomDB::Init( void) +{ + // imposto numero minimo buckets di m_GdbNameMap + m_GdbNameMap.rehash( 128) ; + + return true ; +} + +//---------------------------------------------------------------------------- +bool +GeomDB::Clear( void) +{ + PGDBO_LIST::iterator Iter ; + + + // ciclo di pulizia + for ( Iter = m_GeomDB.begin() ; Iter != m_GeomDB.end() ; Iter++) + delete (*Iter) ; + + m_GeomDB.clear() ; + m_GdbNameMap.clear() ; + + return true ; +} + +//---------------------------------------------------------------------------- +bool +GeomDB::Load( std::ifstream& osIn) +{ + bool bOk ; + bool bEnd ; + CScan TheScanner ; + + + // inizializzo lo scanner + if ( ! TheScanner.Initialize( osIn)) { + cout << "GeomDbLoad : Error on Init " << endl ; + return false ; + } + + // leggo l'intestazione + if ( ! LoadStart( TheScanner)) { + cout << "GeomDbLoad : Error on line " << TheScanner.GetCurrLineNbr() << endl ; + return false ; + } + + // ciclo di lettura degli oggetti + bOk = true ; + do { + if ( ! LoadOneObject( TheScanner, bEnd)) { + bOk = false ; + cout << "GeomDbLoad : Error on line " << TheScanner.GetCurrLineNbr() << endl ; + } + } while ( ! bEnd) ; + + return bOk ; +} + +//---------------------------------------------------------------------------- +bool +GeomDB::LoadStart( CScan& TheScanner) +{ + string sLine ; + + + // recupero la prima linea + if ( ! TheScanner.GetLine( sLine)) + return false ; + + // deve essere l'intestazione + if ( sLine != "START") + return false ; + + // recupero la riga successiva + if ( ! TheScanner.GetLine( sLine)) + return false ; + + // leggo i parametri + // TODO + + return true ; +} + +//---------------------------------------------------------------------------- +bool +GeomDB::LoadOneObject( CScan& TheScanner, bool& bEnd) +{ + string sLine ; + GdbObj* pGObj ; + + + // recupero la prossima linea (con il tipo di oggetto) + if ( ! TheScanner.GetLine( sLine)) { + bEnd = true ; + return false ; + } + + // se fine + if ( sLine == "END") { + bEnd = true ; + } + // altrimenti oggetto + else { + bEnd = false ; + // creo l'oggetto + pGObj = GDBOBJ_CREATE( sLine) ; + if ( pGObj == nullptr) + return false ; + // ne leggo i dati e lo inserisco nel DB + if ( ! pGObj->Load( TheScanner) || + ! AddToGeomDB( pGObj)) { + delete pGObj ; + return false ; + } + } + + return true ; +} + +//---------------------------------------------------------------------------- +bool +GeomDB::Save( std::ofstream& osOut) +{ + bool bOk ; + PGDBO_LIST::iterator Iter ; + + + bOk = true ; + // intestazione + osOut << "START" << endl ; + osOut << "GeomDB,1.2a3" << endl ; + // ciclo di scrittura degli oggetti + for ( Iter = m_GeomDB.begin() ; Iter != m_GeomDB.end() ; ++Iter) { + // oggetto geometrico + if ( ! (*Iter)->Save( osOut)) + bOk = false ; + } + // terminazione + osOut << "END" << endl ; + + return bOk ; +} + +//---------------------------------------------------------------------------- +bool +GeomDB::ExistsGdbObj( const std::string& sName) +{ + STRPGDBO_UMAP::const_iterator Iter ; + + + Iter = m_GdbNameMap.find( sName) ; + return ( Iter != m_GdbNameMap.end()) ; +} + +//---------------------------------------------------------------------------- +GdbObj* +GeomDB::GetGdbObj( const std::string& sName) +{ + STRPGDBO_UMAP::const_iterator Iter ; + + + Iter = m_GdbNameMap.find( sName) ; + if ( Iter != m_GdbNameMap.end()) + return Iter->second ; + else + return nullptr ; +} + +//---------------------------------------------------------------------------- +bool +GeomDB::AddToGeomDB( GdbObj* pGObj) +{ + // verifico validità oggetto puntato + if ( pGObj == nullptr) + return false ; + + // verifica validità e unicità del nome + if ( pGObj->m_sName.length() == 0 || ExistsGdbObj( pGObj->m_sName)) + return false ; + + // inserisco in lista principale + m_GeomDB.push_back( pGObj) ; + + // inserisco in mappa nomi + m_GdbNameMap[ pGObj->m_sName] = pGObj ; + + return true ; +} + +//---------------------------------------------------------------------------- +bool +GeomDB::AddVector( const string& sName, const Vector3d& Vect) +{ + GdbVector3d* pGVect ; + + + // verifico validità nome + if ( sName.length() == 0) + return false ; + // alloco oggetto + pGVect = new(nothrow) GdbVector3d ; + if ( pGVect == nullptr) + return false ; + // assegno nome + pGVect->m_sName = sName ; + // assegno dati + pGVect->m_gvV.Set( Vect) ; + // inserisco nel DB + if ( ! AddToGeomDB( pGVect)) { + delete pGVect ; + return false ; + } + + return true ; +} + +//---------------------------------------------------------------------------- +bool +GeomDB::AddPoint( const string& sName, const Point3d& Pnt) +{ + GdbPoint3d* pGPnt ; + + + // verifico validità nome + if ( sName.length() == 0) + return false ; + // alloco oggetto + pGPnt = new(nothrow) GdbPoint3d ; + if ( pGPnt == nullptr) + return false ; + // assegno nome + pGPnt->m_sName = sName ; + // assegno dati + pGPnt->m_gpP.Set( Pnt) ; + // inserisco nel DB + if ( ! AddToGeomDB( pGPnt)) { + delete pGPnt ; + return false ; + } + + return true ; +} + +//---------------------------------------------------------------------------- +bool +GeomDB::AddCurveLine( const string& sName, const CurveLine& CrvLine) +{ + GdbCurveLine* pGdbCL ; + + + // verifico validità nome + if ( sName.length() == 0) + return false ; + // verifico validità dati geometrici + if ( ! CrvLine.IsValid()) + return false ; + // allocazione oggetto + pGdbCL = new(nothrow) GdbCurveLine ; + if ( pGdbCL == nullptr) + return false ; + // assegnazione nome + pGdbCL->m_sName = sName ; + // assegnazione dati + pGdbCL->m_ln = CrvLine ; + // inserimento nel DB + if ( ! AddToGeomDB( pGdbCL)) { + delete pGdbCL ; + return false ; + } + + return true ; +} + +//---------------------------------------------------------------------------- +bool +GeomDB::AddCurveArc( const string& sName, const CurveArc& CrvArc) +{ + GdbCurveArc* pGdbCA ; + + + // verifico validità nome + if ( sName.length() == 0) + return false ; + // verifico validità dati geometrici + if ( ! CrvArc.IsValid()) + return false ; + // alloco oggetto + pGdbCA = new(nothrow) GdbCurveArc ; + if ( pGdbCA == nullptr) + return false ; + // assegno nome + pGdbCA->m_sName = sName ; + // assegno dati + pGdbCA->m_ar = CrvArc ; + // inserisco nel DB + if ( ! AddToGeomDB( pGdbCA)) { + delete pGdbCA ; + return false ; + } + + return true ; +} + +//---------------------------------------------------------------------------- +bool +GeomDB::AddCurveBez( const string& sName, const CurveBezier& CrvBez) +{ + GdbCurveBezier* pGdbCB ; + + + // verifico validità nome + if ( sName.length() == 0) + return false ; + // verifico validità dati geometrici + if ( ! CrvBez.IsValid()) + return false ; + // allocazione oggetto + pGdbCB = new(nothrow) GdbCurveBezier ; + if ( pGdbCB == nullptr) + return false ; + // assegnazione nome + pGdbCB->m_sName = sName ; + // assegnamento dati + pGdbCB->m_bz = CrvBez ; + // inserimento nel DB + if ( ! AddToGeomDB( pGdbCB)) { + delete pGdbCB ; + return false ; + } + + return true ; +} + +//---------------------------------------------------------------------------- +bool +GeomDB::AddCurveCompo( const string& sName, const CurveComposite& CrvCompo) +{ + GdbCurveComposite* pGdbCC ; + + + // verifico validità nome + if ( sName.length() == 0) + return false ; + // verifico validità dati geometrici + if ( ! CrvCompo.IsValid()) + return false ; + // allocazione oggetto + pGdbCC = new(nothrow) GdbCurveComposite ; + if ( pGdbCC == nullptr) + return false ; + // assegnazione nome + pGdbCC->m_sName = sName ; + // assegnamento dati + pGdbCC->m_cc = CrvCompo ; + // inserimento nel DB + if ( ! AddToGeomDB( pGdbCC)) { + delete pGdbCC ; + return false ; + } + + return true ; +} + +//---------------------------------------------------------------------------- +GeoObjType +GeomDB::GetObjType( const std::string& sName) +{ + const GdbObj* pGObj ; + + + // recupero l'oggetto + if ( ( pGObj = GetGdbObj( sName)) == nullptr) + return GEO_NONE ; + // ne identifico il tipo + return pGObj->GetType() ; +} + +//---------------------------------------------------------------------------- +const GeoVector3d* +GeomDB::GetGeoVector3d( const string& sName) +{ + const GdbObj* pGObj ; + + + // recupero l'oggetto e ne verifico il tipo + if ( ( pGObj = GetGdbObj( sName)) == nullptr || pGObj->GetType() != GEO_VECT3D) + return nullptr ; + + // assegno il vettore per riferimento + return &(static_cast(pGObj))->m_gvV ; +} + +//---------------------------------------------------------------------------- +const Vector3d* +GeomDB::GetVector( const string& sName) +{ + return &( GetGeoVector3d( sName)->m_vtV) ; +} + +//---------------------------------------------------------------------------- +const GeoPoint3d* +GeomDB::GetGeoPoint3d( const string& sName) +{ + const GdbObj* pGObj ; + + + // recupero l'oggetto e ne verifico il tipo + if ( ( pGObj = GetGdbObj( sName)) == nullptr || pGObj->GetType() != GEO_PNT3D) + return nullptr ; + + // assegno il punto per riferimento + return &(static_cast(pGObj))->m_gpP ; +} + +//---------------------------------------------------------------------------- +const Point3d* +GeomDB::GetPoint( const string& sName) +{ + return &( GetGeoPoint3d( sName)->m_ptP) ; +} + +//---------------------------------------------------------------------------- +const CurveLine* +GeomDB::GetCurveLine( const string& sName) +{ + const GdbObj* pGObj ; + + + // recupero l'oggetto e ne verifico il tipo + if ( ( pGObj = GetGdbObj( sName)) == nullptr || pGObj->GetType() != CRV_LINE) + return nullptr ; + + // assegno la linea per riferimento + return &(static_cast(pGObj))->m_ln ; +} + +//---------------------------------------------------------------------------- +const CurveArc* +GeomDB::GetCurveArc( const string& sName) +{ + const GdbObj* pGObj ; + + + // recupero l'oggetto e ne verifico il tipo + if ( ( pGObj = GetGdbObj( sName)) == nullptr || pGObj->GetType() != CRV_ARC) + return nullptr ; + + // assegno l'arco per riferimento + return &(static_cast(pGObj))->m_ar ; +} + +//---------------------------------------------------------------------------- +const CurveBezier* +GeomDB::GetCurveBez( const string& sName) +{ + const GdbObj* pGObj ; + + + // recupero l'oggetto e ne verifico il tipo + if ( ( pGObj = GetGdbObj( sName)) == nullptr || pGObj->GetType() != CRV_BEZ) + return nullptr ; + + // assegno la curva di Bezier per riferimento + return &(static_cast(pGObj))->m_bz ; +} + +//---------------------------------------------------------------------------- +const CurveComposite* +GeomDB::GetCurveCompo( const std::string& sName) +{ + const GdbObj* pGObj ; + + + // recupero l'oggetto e ne verifico il tipo + if ( ( pGObj = GetGdbObj( sName)) == nullptr || pGObj->GetType() != CRV_COMPO) + return nullptr ; + + // assegno la curva di Bezier per riferimento + return &(static_cast(pGObj))->m_cc ; +} + +//---------------------------------------------------------------------------- +const Curve* +GeomDB::GetCurve( const string& sName) +{ + const GdbObj* pGObj ; + + + // recupero l'oggetto + if ( ( pGObj = GetGdbObj( sName)) == nullptr) + return nullptr ; + + // ritorno il puntatore alla curva (oppure nullptr se non è una curva) + return ::GetCurve( pGObj->GetGeoObj()) ; +} + +//---------------------------------------------------------------------------- +bool +GeomDB::Copy( const string& sNameSou, const string& sNameDest) +{ + GdbObj* pGdoSou ; + GdbObj* pGdoDest ; + + + // verifico esistenza del sorgente + if ( ( pGdoSou = GetGdbObj( sNameSou)) == nullptr) + return false ; + + // eseguo la copia + if ( ( pGdoDest = pGdoSou->Clone()) == nullptr) + return false ; + + // assegno il nuovo nome + pGdoDest->m_sName = sNameDest ; + + // inserisco nel DB + if ( ! AddToGeomDB( pGdoDest)) { + delete pGdoDest ; + return false ; + } + + return true ; +} + +//---------------------------------------------------------------------------- +bool +GeomDB::Erase( const string& sName) +{ + PGDBO_LIST::iterator Iter ; + + + // elimino da mappa dei nomi + m_GdbNameMap.erase( sName) ; + + // elimino da lista principale + for ( Iter = m_GeomDB.begin() ; Iter != m_GeomDB.end() ; Iter++) { + // se oggetto cercato + if ( (*Iter)->m_sName == sName) { + // lo disalloco (distruttore virtuale) + delete( (*Iter)) ; + // lo tolgo dalla lista + m_GeomDB.erase( Iter) ; + // esco + return true ; + } + } + + return false ; +} + +//---------------------------------------------------------------------------- +bool +GeomDB::Translate( const string& sName, const Vector3d& vtMove) +{ + GdbObj* pGObj ; + + + // recupero l'oggetto + if ( ( pGObj = GetGdbObj( sName)) == nullptr) + return false ; + + // eseguo l'operazione + return pGObj->Translate( vtMove) ; +} + +//---------------------------------------------------------------------------- +bool +GeomDB::Rotate( const string& sName, const Point3d& ptAx, const Vector3d& vtAx, double dAngDeg) +{ + GdbObj* pGObj ; + + + // recupero l'oggetto + if ( ( pGObj = GetGdbObj( sName)) == nullptr) + return false ; + + // eseguo l'operazione + return pGObj->Rotate( ptAx, vtAx, dAngDeg * DEGTORAD) ; +} + +//---------------------------------------------------------------------------- +bool +GeomDB::Scale( const string& sName, const Point3d& ptCen, double dCoeffX, double dCoeffY, double dCoeffZ) +{ + GdbObj* pGObj ; + + + // recupero l'oggetto + if ( ( pGObj = GetGdbObj( sName)) == nullptr) + return false ; + + // eseguo l'operazione + return pGObj->Scale( ptCen, dCoeffX, dCoeffY, dCoeffZ) ; +} + +//---------------------------------------------------------------------------- +bool +GeomDB::Mirror( const string& sName, const Point3d& ptOn, const Vector3d& vtNorm) +{ + GdbObj* pGObj ; + + + // recupero l'oggetto + if ( ( pGObj = GetGdbObj( sName)) == nullptr) + return false ; + + // eseguo l'operazione + return pGObj->Mirror( ptOn, vtNorm) ; +} diff --git a/GeomDB.h b/GeomDB.h new file mode 100644 index 0000000..2eb8433 --- /dev/null +++ b/GeomDB.h @@ -0,0 +1,70 @@ +//---------------------------------------------------------------------------- +// EgalS +//---------------------------------------------------------------------------- +// File : GeomDB.h Data : 08.04.13 Versione : 1.1c1 +// Contenuto : Dichiarazione della classe GeomDB. +// +// +// +// Modifiche : 22.01.13 DS Creazione modulo. +// +// +//---------------------------------------------------------------------------- + +#pragma once + +#include +#include +#include "GdbObj.h" + +//---------------------------------------------------------------------------- +typedef std::list< GdbObj*> PGDBO_LIST ; +typedef std::unordered_map< std::string, GdbObj*> STRPGDBO_UMAP ; + +//---------------------------------------------------------------------------- +class CScan ; + +//---------------------------------------------------------------------------- +class GeomDB +{ + public : + GeomDB( void) ; + ~GeomDB( void) ; + bool Init( void) ; + bool Clear( void) ; + bool Load( std::ifstream& osIn) ; + bool Save( std::ofstream& osOut) ; + bool ExistsGdbObj( const std::string& sName) ; + bool AddVector( const std::string& sName, const Vector3d& Vect) ; + bool AddPoint( const std::string& sName, const Point3d& Pnt) ; + bool AddCurveLine( const std::string& sName, const CurveLine& CrvLine) ; + bool AddCurveArc( const std::string& sName, const CurveArc& CrvArc) ; + bool AddCurveBez( const std::string& sName, const CurveBezier& CrvBez) ; + bool AddCurveCompo( const std::string& sName, const CurveComposite& CrvCompo) ; + GeoObjType GetObjType( const std::string& sName) ; + const GeoVector3d* GetGeoVector3d( const std::string& sName) ; + const Vector3d* GetVector( const std::string& sName) ; + const GeoPoint3d* GetGeoPoint3d( const std::string& sName) ; + const Point3d* GetPoint( const std::string& sName) ; + const CurveLine* GetCurveLine( const std::string& sName) ; + const CurveArc* GetCurveArc( const std::string& sName) ; + const CurveBezier* GetCurveBez( const std::string& sName) ; + const CurveComposite* GetCurveCompo( const std::string& sName) ; + const Curve* GetCurve( const std::string& sName) ; + bool Copy( const std::string& sNameSou, const std::string& sNameDest) ; + bool Erase( const std::string& sName) ; + bool Translate( const std::string& sName, const Vector3d& vtMove) ; + bool Rotate( const std::string& sName, const Point3d& ptAx, const Vector3d& vtAx, double dAngDeg) ; + bool Scale( const std::string& sName, const Point3d& ptCen, double dCoeffX, double dCoeffY, double dCoeffZ) ; + bool Mirror( const std::string& sName, const Point3d& ptOn, const Vector3d& vtNorm) ; + + private : + GdbObj* GetGdbObj( const std::string& sName) ; + bool AddToGeomDB( GdbObj* pGObj) ; + bool LoadStart( CScan& TheScanner) ; + bool LoadOneObject( CScan& TheScanner, bool& bEnd) ; + + private : + PGDBO_LIST m_GeomDB ; // lista principale, proprietaria degli oggetti + STRPGDBO_UMAP m_GdbNameMap ; // map basato sui nomi +} ; diff --git a/Point3d.cpp b/Point3d.cpp new file mode 100644 index 0000000..c60e222 --- /dev/null +++ b/Point3d.cpp @@ -0,0 +1,144 @@ +//---------------------------------------------------------------------------- +// EgalTech 2013-2013 +//---------------------------------------------------------------------------- +// File : Point3d.cpp Data : 20.11.13 Versione : 1.3a1 +// Contenuto : Funzioni della classe Punto 3d. +// +// +// +// Modifiche : 04.01.13 DS Creazione modulo. +// +// +//---------------------------------------------------------------------------- + +//--------------------------- Include ---------------------------------------- +#include "stdafx.h" +#include "\EgtDev\Include\EGkPoint3d.h" +#include "\EgtDev\Include\EGkFrame3d.h" + + +//---------------------------------------------------------------------------- +// Traslazione +//---------------------------------------------------------------------------- +void +Point3d::Translate( const Vector3d& vtMove) +{ + *this = *this + vtMove ; +} + +//---------------------------------------------------------------------------- +// Rotazione +//---------------------------------------------------------------------------- +bool +Point3d::Rotate( const Point3d& ptAx, const Vector3d& vtAx, double dAngRad) +{ + return Rotate( ptAx, vtAx, cos( dAngRad), sin( dAngRad)) ; +} + +//---------------------------------------------------------------------------- +// Rotazione +//---------------------------------------------------------------------------- +bool +Point3d::Rotate( const Point3d& ptAx, const Vector3d& vtAx, double dCosAng, double dSinAng) +{ + Vector3d vtDiff ; + + + // vettore dall'asse al punto + vtDiff = *this - ptAx ; + if ( vtDiff.IsZero()) + return true ; + + // rotazione del vettore + if ( ! vtDiff.Rotate( vtAx, dCosAng, dSinAng)) + return false ; + + // ricostruisco il punto + *this = ptAx + vtDiff ; + + return true ; +} + +//---------------------------------------------------------------------------- +// Scalatura non uniforme +//---------------------------------------------------------------------------- +bool +Point3d::Scale( const Point3d& ptCen, double dCoeffX, double dCoeffY, double dCoeffZ) +{ + Vector3d vtDiff ; + + + // vettore dal centro al punto + vtDiff = *this - ptCen ; + if ( vtDiff.IsZero()) + return true ; + + // scalatura del vettore + if ( ! vtDiff.Scale( dCoeffX, dCoeffY, dCoeffZ)) + return false ; + + // ricostruisco il punto + *this = ptCen + vtDiff ; + + return true ; +} + +//---------------------------------------------------------------------------- +// Specchiatura +//---------------------------------------------------------------------------- +bool +Point3d::Mirror( const Point3d& ptOn, const Vector3d& vtNorm) +{ + Vector3d vtDiff ; + + + // vettore dal riferimento al punto + vtDiff = *this - ptOn ; + if ( vtDiff.IsZero()) + return true ; + + // specchiatura del vettore + if ( ! vtDiff.Mirror( vtNorm)) + return false ; + + // ricostruisco il punto + *this = ptOn + vtDiff ; + + return true ; +} + +//---------------------------------------------------------------------------- +// Cambio di riferimento : dal riferimento al globale +//---------------------------------------------------------------------------- +bool +Point3d::ToGlob( const Frame3d& frRef) +{ + Point3d ptT( x, y, z) ; + + + // verifico validità del frame + if ( frRef.GetType() == Frame3d::ERR) + return false ; + + // eseguo trasformazione + x = ptT.x * frRef.VersX().x + ptT.y * frRef.VersY().x + ptT.z * frRef.VersZ().x + frRef.Orig().x ; + y = ptT.x * frRef.VersX().y + ptT.y * frRef.VersY().y + ptT.z * frRef.VersZ().y + frRef.Orig().y ; + z = ptT.x * frRef.VersX().z + ptT.y * frRef.VersY().z + ptT.z * frRef.VersZ().z + frRef.Orig().z ; + + return true ; +} + +//---------------------------------------------------------------------------- +// Cambio di riferimento : dal globale al riferimento +//---------------------------------------------------------------------------- +bool +Point3d::ToLoc( const Frame3d& frRef) +{ + Vector3d vtT( x - frRef.Orig().x, y - frRef.Orig().y, z - frRef.Orig().z) ; + + x = vtT.x * frRef.VersX().x + vtT.y * frRef.VersX().y + vtT.z * frRef.VersX().z ; + y = vtT.x * frRef.VersY().x + vtT.y * frRef.VersY().y + vtT.z * frRef.VersY().z ; + z = vtT.x * frRef.VersZ().x + vtT.y * frRef.VersZ().y + vtT.z * frRef.VersZ().z ; + + return true ; +} diff --git a/Resource.h b/Resource.h new file mode 100644 index 0000000..ea0bca8 --- /dev/null +++ b/Resource.h @@ -0,0 +1,16 @@ +//{{NO_DEPENDENCIES}} +// Microsoft Visual C++ generated include file. +// Used by EgtGeometry.rc +// + +// Valori predefiniti successivi per i nuovi oggetti +// +#ifdef APSTUDIO_INVOKED +#ifndef APSTUDIO_READONLY_SYMBOLS + +#define _APS_NEXT_RESOURCE_VALUE 2000 +#define _APS_NEXT_CONTROL_VALUE 2000 +#define _APS_NEXT_SYMED_VALUE 2000 +#define _APS_NEXT_COMMAND_VALUE 32771 +#endif +#endif diff --git a/Vector3d.cpp b/Vector3d.cpp new file mode 100644 index 0000000..4b3fc3d --- /dev/null +++ b/Vector3d.cpp @@ -0,0 +1,268 @@ +//---------------------------------------------------------------------------- +// EgalTech 2013-2013 +//---------------------------------------------------------------------------- +// File : Vector3d.cpp Data : 20.11.13 Versione : 1.3a1 +// Contenuto : Funzioni della classe Vettore 3d. +// +// +// +// Modifiche : 04.01.13 DS Creazione modulo. +// +// +//---------------------------------------------------------------------------- + +//--------------------------- Include ---------------------------------------- +#include "stdafx.h" +#include "\EgtDev\Include\EGkGeoConst.h" +#include "\EgtDev\Include\EGkVector3d.h" +#include "\EgtDev\Include\EGKFrame3d.h" + + +//---------------------------------------------------------------------------- +// Definizione a partire da coordinate sferiche +//---------------------------------------------------------------------------- +void +Vector3d::FromSpherical( double dLen, double dAngVertDeg, double dAngOrizzDeg) +{ + double dAngVertRad ; + double dAngOrizzRad ; + double dSinAngVert ; + + + dAngVertRad = dAngVertDeg * DEGTORAD ; + dAngOrizzRad = dAngOrizzDeg * DEGTORAD ; + dSinAngVert = sin( dAngVertRad) ; + x = dLen * dSinAngVert * cos( dAngOrizzRad) ; + y = dLen * dSinAngVert * sin( dAngOrizzRad) ; + z = dLen * cos( dAngVertRad) ; +} + +//---------------------------------------------------------------------------- +// Definizione a partire da coordinate polari +//---------------------------------------------------------------------------- +void +Vector3d::FromPolar( double dLen, double dAngDeg) +{ + double dAngRad ; + + + dAngRad = dAngDeg * DEGTORAD ; + x = dLen * cos( dAngRad) ; + y = dLen * sin( dAngRad) ; + z = 0 ; +} + +//---------------------------------------------------------------------------- +// Quadrato della lunghezza di un vettore +//---------------------------------------------------------------------------- +double +Vector3d::LenSq( void) const +{ + return ( x * x + y * y + z * z) ; +} + +//---------------------------------------------------------------------------- +// Lunghezza di un vettore +//---------------------------------------------------------------------------- +double +Vector3d::Len( void) const +{ + if ( fabs( y) < EPS_ZERO && fabs( z) < EPS_ZERO) + return fabs( x) ; + if ( fabs( z) < EPS_ZERO && fabs( x) < EPS_ZERO) + return fabs( y) ; + if ( fabs( x) < EPS_ZERO && fabs( y) < EPS_ZERO) + return fabs( z) ; + + return sqrt( x * x + y * y + z * z) ; +} + +//---------------------------------------------------------------------------- +// Ritorna la rappresentazione in coordinate sferiche +//---------------------------------------------------------------------------- +void +Vector3d::ToSpherical( double* pdLen, double* pdAngVertDeg, double* pdAngOrizzDeg) const +{ + double dLen ; + double dAngVertDeg ; + double dAngOrizzDeg ; + + + // lunghezza + dLen = Len() ; + + // se vettore nullo + if ( dLen < EPS_ZERO) { + dAngVertDeg = 0 ; + dAngOrizzDeg = 0 ; + } + // altrimenti + else { + // se diretto come Z + if ( fabs( x) < EPS_ZERO && fabs( y) < EPS_ZERO) { + dAngVertDeg = (( z > 0) ? 0 : 180) ; + dAngOrizzDeg = 0 ; + } + // se altrimenti nel piano XY + else if ( fabs( z) < EPS_ZERO) { + dAngVertDeg = 90.0 ; + dAngOrizzDeg = atan2( y, x) * RADTODEG ; + if ( dAngOrizzDeg < 0) + dAngOrizzDeg += 360 ; + } + // caso generico + else { + dAngVertDeg = acos( z / dLen) * RADTODEG ; + dAngOrizzDeg = atan2( y, x) * RADTODEG ; + if ( dAngOrizzDeg < 0) + dAngOrizzDeg += 360 ; + } + } + + // ritorno i valori + if ( pdLen != nullptr) + *pdLen = dLen ; + if ( pdAngVertDeg != nullptr) + *pdAngVertDeg = dAngVertDeg ; + if ( pdAngOrizzDeg != nullptr) + *pdAngOrizzDeg = dAngOrizzDeg ; +} + +//---------------------------------------------------------------------------- +// Normalizzazione di un vettore (trasformazione in versore) +//---------------------------------------------------------------------------- +bool +Vector3d::Normalize( void) +{ + double dSqLen ; + double dLen ; + + + // se già normalizzato, ok + dSqLen = x * x + y * y + z * z ; + if ( fabs( 1.0 - dSqLen) < ( 2 * EPS_ZERO)) + return true ; + + // se troppo piccolo, errore + if ( fabs( dSqLen) < ( EPS_SMALL * EPS_SMALL)) + return false ; + + // eseguo la normalizzazione + dLen = sqrt( dSqLen) ; + *this = *this / dLen ; + + return true ; +} + +//---------------------------------------------------------------------------- +// Rotazione +//---------------------------------------------------------------------------- +bool +Vector3d::Rotate( const Vector3d& vtAx, double dAngRad) +{ + return Rotate( vtAx, cos( dAngRad), sin( dAngRad)) ; +} + +//---------------------------------------------------------------------------- +// Rotazione +//---------------------------------------------------------------------------- +bool +Vector3d::Rotate( const Vector3d& vtAx, double dCosAng, double dSinAng) +{ + double dCompPar ; + Vector3d vtDirAx ; + Vector3d vtCompPar ; + Vector3d vtCompPerp ; + Vector3d vtPerp2 ; + Vector3d vtNewCompPerpX ; + Vector3d vtNewCompPerpY ; + Vector3d vtNewCompPerp ; + + + // ricavo versore asse di rotazione + vtDirAx = vtAx ; + if ( ! vtDirAx.Normalize()) + return false ; + + // separazione del vettore nelle componenti parallela e perp. asse + dCompPar = *this * vtDirAx ; + vtCompPar = vtDirAx * dCompPar ; + vtCompPerp = *this - vtCompPar ; + // calcolo vettore perp. componente perp. e asse + vtPerp2 = vtDirAx ^ vtCompPerp ; + // calcolo componenti perp. del vettore ruotato + vtNewCompPerpX = dCosAng * vtCompPerp ; + vtNewCompPerpY = dSinAng * vtPerp2 ; + vtNewCompPerp = vtNewCompPerpX + vtNewCompPerpY ; + // calcolo del vettore ruotato + *this = vtCompPar + vtNewCompPerp ; + + return true ; +} + +//---------------------------------------------------------------------------- +// Scalatura non uniforme +//---------------------------------------------------------------------------- +bool +Vector3d::Scale( double dCoeffX, double dCoeffY, double dCoeffZ) +{ + x *= dCoeffX ; + y *= dCoeffY ; + z *= dCoeffZ ; + + return true ; +} + +//---------------------------------------------------------------------------- +// Specchiatura +//---------------------------------------------------------------------------- +bool +Vector3d::Mirror( const Vector3d& vtNorm) +{ + double dCompNorm ; + Vector3d vtDirNorm ; + + + // ricavo versore normale al piano di simmetria + vtDirNorm = vtNorm ; + if ( ! vtDirNorm.Normalize()) + return false ; + + // calcolo la componente parallela alla normale + dCompNorm = *this * vtDirNorm ; + + // il simmetrico è il vettore originale meno il doppio della componente parallela + *this = *this - 2 * dCompNorm * vtDirNorm ; + + return true ; +} + +//---------------------------------------------------------------------------- +// Cambio di riferimento : dal riferimento al globale +//---------------------------------------------------------------------------- +bool +Vector3d::ToGlob( const Frame3d& frRef) +{ + Vector3d vtT( x, y, z) ; + + x = vtT.x * frRef.VersX().x + vtT.y * frRef.VersY().x + vtT.z * frRef.VersZ().x ; + y = vtT.x * frRef.VersX().y + vtT.y * frRef.VersY().y + vtT.z * frRef.VersZ().y ; + z = vtT.x * frRef.VersX().z + vtT.y * frRef.VersY().z + vtT.z * frRef.VersZ().z ; + + return true ; +} + +//---------------------------------------------------------------------------- +// Cambio di riferimento : dal globale al riferimento +//---------------------------------------------------------------------------- +bool +Vector3d::ToLoc( const Frame3d& frRef) +{ + Vector3d vtT( x, y, z) ; + + x = vtT.x * frRef.VersX().x + vtT.y * frRef.VersX().y + vtT.z * frRef.VersX().z ; + y = vtT.x * frRef.VersY().x + vtT.y * frRef.VersY().y + vtT.z * frRef.VersY().z ; + z = vtT.x * frRef.VersZ().x + vtT.y * frRef.VersZ().y + vtT.z * frRef.VersZ().z ; + + return true ; +} diff --git a/stdafx.cpp b/stdafx.cpp new file mode 100644 index 0000000..6826075 --- /dev/null +++ b/stdafx.cpp @@ -0,0 +1,7 @@ +// stdafx.cpp : file di origine che include solo le inclusioni standard +// EgtGeometry.pch sarà l'intestazione precompilata +// stdafx.obj conterrà le informazioni sui tipi precompilati + +#include "stdafx.h" + + diff --git a/stdafx.h b/stdafx.h new file mode 100644 index 0000000..0fab164 --- /dev/null +++ b/stdafx.h @@ -0,0 +1,29 @@ +// stdafx.h : file di inclusione per file di inclusione di sistema standard +// o file di inclusione specifici del progetto utilizzati di frequente, ma +// modificati raramente +// + +#pragma once + +#define WINVER 0x0601 +#define _WIN32_WINNT 0x0601 +#define _WIN32_IE 0x0800 + +#include +#include +#include +#include + +// in Debug riconoscimento memory leakage +#ifdef _DEBUG + #define _CRTDBG_MAP_ALLOC + #include + #include +#endif + +// in Debug controllo iteratori +#ifdef _DEBUG + #define _SECURE_SCL 1 +#else + #define _SECURE_SCL 0 +#endif