From b688e7f69d5276e01e331de1364845bfb725cd14 Mon Sep 17 00:00:00 2001 From: Dario Sassi Date: Wed, 20 Nov 2013 17:39:24 +0000 Subject: [PATCH] EgtGeomKernel 1.3a1 : primo salvatraggio. --- EgtGeomKernel.rc | Bin 0 -> 4566 bytes EgtGeomKernel.sln | 20 ++ EgtGeomKernel.vcxproj | 142 ++++++++ EgtGeomKernel.vcxproj.filters | 65 ++++ EgtGeomKernelDll.cpp | 40 +++ EgtGeomKernelDll.h | 20 ++ Frame3d.cpp | 305 ++++++++++++++++ GeomDB.cpp | 650 ++++++++++++++++++++++++++++++++++ GeomDB.h | 70 ++++ Point3d.cpp | 144 ++++++++ Resource.h | 16 + Vector3d.cpp | 268 ++++++++++++++ stdafx.cpp | 7 + stdafx.h | 29 ++ 14 files changed, 1776 insertions(+) create mode 100644 EgtGeomKernel.rc create mode 100644 EgtGeomKernel.sln create mode 100644 EgtGeomKernel.vcxproj create mode 100644 EgtGeomKernel.vcxproj.filters create mode 100644 EgtGeomKernelDll.cpp create mode 100644 EgtGeomKernelDll.h create mode 100644 Frame3d.cpp create mode 100644 GeomDB.cpp create mode 100644 GeomDB.h create mode 100644 Point3d.cpp create mode 100644 Resource.h create mode 100644 Vector3d.cpp create mode 100644 stdafx.cpp create mode 100644 stdafx.h diff --git a/EgtGeomKernel.rc b/EgtGeomKernel.rc new file mode 100644 index 0000000000000000000000000000000000000000..9dd32df0824046a40beaddfcf513130bcafee9c3 GIT binary patch literal 4566 zcmdUz*-qO)6o$`rrM`n3Zi-q#47>nKh)@GTWKk<2Axah^r3uO+fz)Sj`~5Q+Y{w2& z(wkJ4Gvo1@v;1e7@N4>(7gQS^T#Tv7nKUjyYHjK6T)6Z0AIh&!Yx8(;}lziKROt zs>UV0Ke?inJDc#hA#U%`NAq1LwZ`m<)fQvb#b#IubT#Nj^BLX^=uVL4_bgKg1@CWJ zvD)9thBh{QLEhPam-)px9U>rL5QA1RW#lYA!S*W1Ub&|TYF)*3_SVXaT3dnMBPKbj zBAdu4s_!M@b-B8f?3QYCOC0-3pJ=&Cqr(j~T361FtG*r18&wp4sUj3rmwdDZA8l6+ zNo$jiCT~|8izl4f18U0XHD`h)Z8GzYoT`xF4Wde?tg`cps!<1(?3=Kz-4PTQWOQYT zCbF1}KjhXJFQW7s{&ga-MeS*>+)-vnd9fpKKX+B5iguS&j|RCPLGz4+9&eX~rz9OBpgT{@O2IK53@PSNXBlGN;uI{JCuN9d^QXt5_jt4a5AjfS2s z@J!zON?A-*ocpS)b#N6jB{Z1fZ}nk)JT$v$;}i@AlY$a0k>@xr3-jM=(nSg(`RK!%yj81A6c8yb56L2+{IcH z%L!PV!71Ir`n(A8)SXG6?gGUJBvu@jLR5Nrj|UmqF>6_nn9aZ-DMtT8Y>U_8DNm|1 zpD+rSWxTxpUgLFit-;eHEq^@Oi;JN?h|kc^`y&5FJ<6%;AP$I$7<<-{SzpKyva%)M zrKfZZ=nJ5a9$DYKfM17Q!?k2yBXi8YIngxBp_h-gtW14JZ5|I<*>6QfF^b6<9-=P4 zlFiySNKRgH-J}X+Bf1GUb*EEM*B4?scT|&ojZn12^cbpt>1;`~O=fz(`b^%uCr+P< z+clTP>D!-PZ++$D`;hIjD6New({mXA^?O%+;oIN40n4-&+clSlt7BZ>diqBu|8<-9 HyEy#;b}AeH literal 0 HcmV?d00001 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