3DPointList.h

Go to the documentation of this file.

//! @file 3DPointList.h
//! @brief C3DPointList class definition for handling a list of C3DPoint
//
//////////////////////////////////////////////////////////////////////
 
#if !defined(AFX_3DPOINTLIST_H__CA6BC2A5_FAC2_11D1_A0DE_000000000000__INCLUDED_)
#define AFX_3DPOINTLIST_H__CA6BC2A5_FAC2_11D1_A0DE_000000000000__INCLUDED_
 
#ifdef _MSC_VER
#pragma once
#endif // _MSC_VER
 
#include "PointList.h"
#include "3DPoint.h"
#include "AssociationMap.h"
 
BEGIN_MOOTOOLS_NAMESPACE
 
class IntCoord
{
public:
    int x, y, z;
 
    bool operator!=(const IntCoord& pt) const;
    bool operator==(const IntCoord& pt) const;
};
 
inline bool IntCoord::operator!=(const IntCoord& pt) const
{
    if (x != pt.x)
        return true;
    if (y != pt.y)
        return true;
    if (z != pt.z)
        return true;
 
    return false;
}
 
inline bool IntCoord::operator==(const IntCoord& pt) const
{
    if (x != pt.x)
        return false;
    if (y != pt.y)
        return false;
    if (z != pt.z)
        return false;
 
    return true;
}
 
template <> class CHashMethods<IntCoord>
{
public:
    static inline bool HashCompare(const IntCoord& pt1, const IntCoord& pt2)
    {
        if (pt1.x != pt2.x || pt1.y != pt2.y || pt1.z != pt2.z)
            return false;
 
        return true;
    }
 
    static inline unsigned int HashValue(const IntCoord& pt)
    {
    #ifdef OLD_HASH_FUNCTIONS
        return (unsigned int)(pt.x + pt.y + pt.z);
    #else
        return HashMixValue(HashMixValue(pt.x) + pt.y) + pt.z;
    #endif
    }
};
 
//! @class C3DPointGridMap
//! @brief C3DPointGridMap is a compact class for retrieving quickly points which are in the same voxel of a provided C3DPoint
//! @details The class is used by C3DFaceGridMap for performing ray cast or retrieve the closest face to a point.
class C3DPointGridMap : public CAssociationMap<C3DPointI, int, unsigned int>
{
    friend C3DPointList;
 
protected:
    C3DPointD center; //!< The center of the points bounding box, which allows to perform the computation around the origin for better precision
    double cellDistance[3];
 
    // Center is the center of the points bounding box
    C3DPointGridMap();
    C3DPointGridMap(const C3DPoint& center, double distanceX, double distanceY = 0.0f, double distanceZ = 0.0f);
 
    template<typename TYPE> int *Lookup(const C3DTPoint<TYPE>& point, int& size) const; // Return the element indexes which are at the given x, y, z position
    int* Lookup(const C3DPointI& point, int& size) const; // Return the element indexes which are at the cell position
    using CAssociationMap::Lookup;
 
#ifdef _DEBUG
    void CheckLimits(const C3DVector& limits);
#endif
 
public:
    void GetVoxelSize(C3DPointD& voxel) const;
    template<typename TYPE> void ConvertToLongIntCoord(const C3DTPoint<TYPE>& pt, longint *intcoord) const;
    template<typename TYPE> void ConvertToIntCoord(const C3DTPoint<TYPE>& pt, C3DPointI& intcoord) const;
    template<typename TYPE> void ConvertToCheckedIntCoord(const C3DTPoint<TYPE>& pt, C3DPointI& intcoord) const;
    template<typename TYPE> void ConvertFromIntCoord(const C3DPointI& intcoord, C3DTPoint<TYPE>& pt)  const;
    int XYZToIntCoord(double coordinate, int index) const; //!< index: 0, 1 or 2 [x, y or z]
    int XToIntCoord(double coordinate) const;
    int YToIntCoord(double coordinate) const;
    int ZToIntCoord(double coordinate) const;
    double XYZFromIntCoord(int intcoord, int index) const; //!< index: 0, 1 or 2 [x, y or z]
    double XFromIntCoord(int intcoord) const;
    double YFromIntCoord(int intcoord) const;
    double ZFromIntCoord(int intcoord) const;
    double GetMaxDistance(unsigned char XYZ = 0) const; //!< Return the max distance between two points when using Get3DProximityPoints (cf note in C3DPointGridMap // Get3DProximityPoints)
 
    // Static to init C3DPointGridMap based on a relative value of the bounding box and retrieve the max absolute value between points to be considered equals
    static DLL_3DFUNCTION double GetAbsoluteDistance(double threshold, const C3DBBox& bboxCorner); //!< Return the absolute distance to use to construct C3DPointGridMap based on a threshold value between 0.0 and 1.0 and giving the object bounding box corners
    static DLL_3DFUNCTION double GetMaxDistance(double threshold, const C3DBBox& bboxCorner); //!< Return the max distance between two points considered to be equal (returned by Get3DProximityPoints)
};
 
template<typename TYPE>
int* C3DPointGridMap::Lookup(const C3DTPoint<TYPE>& point, int& size) const
{
    C3DPointI coord;
    ConvertToIntCoord(point, coord);
    return CAssociationMap<C3DPointI, int, unsigned int>::Lookup(coord, size);
}
 
inline int* C3DPointGridMap::Lookup(const C3DPointI& coord, int& size) const
{
    return CAssociationMap<C3DPointI, int, unsigned int>::Lookup(coord, size);
}
 
inline void C3DPointGridMap::GetVoxelSize(C3DPointD& voxel) const
{
    voxel.x = cellDistance[0];
    voxel.y = cellDistance[1];
    voxel.z = cellDistance[2];
}
 
template<typename TYPE>
inline void C3DPointGridMap::ConvertToLongIntCoord(const C3DTPoint<TYPE>& pt, longint* intcoord) const
{
    intcoord[0] = (longint)((pt.x - center.x) / cellDistance[0]);
    intcoord[1] = (longint)((pt.y - center.y) / cellDistance[1]);
    intcoord[2] = (longint)((pt.z - center.z) / cellDistance[2]);
}
 
template<typename TYPE>
inline void C3DPointGridMap::ConvertToIntCoord(const C3DTPoint<TYPE>& pt, C3DPointI& intcoord) const
{
    intcoord.x = (int)((pt.x - center.x) / cellDistance[0]);
    intcoord.y = (int)((pt.y - center.y) / cellDistance[1]);
    intcoord.z = (int)((pt.z - center.z) / cellDistance[2]);
}
 
template<typename TYPE>
inline void C3DPointGridMap::ConvertToCheckedIntCoord(const C3DTPoint<TYPE>& pt, C3DPointI& intcoord) const
{
    TYPE values[3];
 
    values[0] = ((pt.x - center.x) / cellDistance[0]);
    values[1] = ((pt.y - center.y) / cellDistance[1]);
    values[2] = ((pt.z - center.z) / cellDistance[2]);
 
    intcoord.x = (int)ceil(values[0]); // Use the ceil value first (avoid multiple call)
    intcoord.y = (int)ceil(values[1]);
    intcoord.z = (int)ceil(values[2]);
 
    if (intcoord.x - values[0] > FLOAT_EPSILON3) // If value is 12.999998, then it should be 13.0, otherwise 12
        intcoord.x = (int)values[0];
 
    if (intcoord.y - values[1] > FLOAT_EPSILON3)
        intcoord.y = (int)values[1];
 
    if (intcoord.z - values[2] > FLOAT_EPSILON3)
        intcoord.z = (int)values[2];
}
 
template<typename TYPE>
inline void C3DPointGridMap::ConvertFromIntCoord(const C3DPointI& intcoord, C3DTPoint<TYPE>& pt) const
{
    pt.x = (TYPE)((intcoord.x*cellDistance[0]) + center.x);
    pt.y = (TYPE)((intcoord.y*cellDistance[1]) + center.y);
    pt.z = (TYPE)((intcoord.z*cellDistance[2]) + center.z);
}
 
inline int C3DPointGridMap::XYZToIntCoord(double coordinate, int index) const
{
    return (int)((coordinate - center[index]) / cellDistance[index]);
}
 
inline int C3DPointGridMap::XToIntCoord(double coordinate) const
{
    return (int)((coordinate - center.x) / cellDistance[0]);
}
 
inline int C3DPointGridMap::YToIntCoord(double coordinate) const
{
    return (int)((coordinate - center.y) / cellDistance[1]);
}
 
inline int C3DPointGridMap::ZToIntCoord(double coordinate) const
{
    return (int)((coordinate - center.z) / cellDistance[2]);
}
 
inline double C3DPointGridMap::XYZFromIntCoord(int intcoord, int index) const
{
    return (intcoord * cellDistance[index]) + center[index];
}
 
inline double C3DPointGridMap::XFromIntCoord(int intcoord) const
{
    return (intcoord*cellDistance[0])+center.x;
}
 
inline double C3DPointGridMap::YFromIntCoord(int intcoord) const
{
    return (intcoord*cellDistance[1]) + center.y;
}
 
inline double C3DPointGridMap::ZFromIntCoord(int intcoord) const
{
    return (intcoord*cellDistance[2]) + center.z;
}
 
typedef struct WeldProximityMap WeldProximityMap;
 
class DLL_3DFUNCTION C3DPointSymetryMap : public CIntMap, public CInstanciatedObject
{
    public:
        typedef enum SymetricEdgeInfo
        {
            SYM_NONE = 0,
            SYM_EXISTS,
            SYM_IS_SAME,
        } SymetricEdgeInfo;
 
        SymetricEdgeInfo GetSymetricEdge(const CFaceList *faces, const C3DEdge& edge, C3DEdge& symetricEdge, bool preventEdgeOrdering);
};
 
class DLL_3DFUNCTION C3DPointMethods : public CPointMethods
{
    DECLARE_SERIAL_XOBJECT(C3DPointMethods);
 
    SIZET GetSizeof() const;
    ElementType GetType() const;
    void ConstructElement(void* pNewData);
 
};
 
inline SIZET C3DPointMethods::GetSizeof() const
{
    return sizeof(C3DPoint);
}
 
inline ElementType C3DPointMethods::GetType() const
{
    return MAKE_CUSTOM_ID('3', 'D', 'P', 'T');
}
 
inline void C3DPointMethods::ConstructElement(void* pNewData)
{
    xConstruct(C3DPoint, pNewData);
}
 
//! @class
//! C3DPointList is the class which contains the x, y, z C3DPoint. The data is stored internally as a C3DPoint array (Cf. CElementArray).
class DLL_3DFUNCTION C3DPointList : public CPointList
{
protected:
    // Material shared by a point
    CMaterialGraph *materialGraph, *materialBackGraph;
    int materialGraphLock;
 
    // Proximity graph information
    virtual bool UpdateList();
 
    // Protected material graph functions
    void CreatePointMaterialGraph(const CGeomInfo *info, bool front);
    C3DPointGridMap *GetGridCoordMap(double distance, bool absolute, bool offset = false);
 
public:
    DECLARE_SERIAL_XOBJECT(C3DPointList)
 
    C3DPointList(C3DPointList *srcPoints = NULL);
    virtual ~C3DPointList(); //!< Use Delete instead, unless the C3DPointList is created on the stack (take care that it is referenced once only in this case)
 
    static C3DPointList *Create(C3DPointList *srcPoints = NULL); //!< Allocates and creates an empty set of 3d points. Use C3DPointList::Delete to delete it
 
    virtual void RemoveAll();
 
    //! @name Access functions
    //! Get access to the C3DPoint data contained in the array
    //!
    //! @{
    const C3DPoint *GetFirst() const;
    const C3DPoint *GetNext(const C3DPoint *point) const;
    C3DPoint *GetFirst();
    C3DPoint *GetNext(C3DPoint *pointList);
    C3DPoint *ElementAt(int i);
    C3DPoint *operator[](int i);
    const C3DPoint *operator[](int i) const;
 
    //! @}
 
    bool SwapCoordinates(unsigned int swap);
    bool MatrixTransform(const C4x4Matrix& matrix, POINT_PROPERTIES property = POINT_NONE, bool set = TRUE, int index = 0, int count = -1);
    
    // Flags initialisation functions
    // void InitShareCoplanarFacesFlag(const CGeomInfo *info, double maxAngle);
 
    // Material graph functions
    void InitPointMaterialGraph(const CGeomInfo *info);
    void DeletePointMaterialGraph();
    bool InitShareSeveralMaterialsFlag();
    int GetNumberOfMaterialsConnectedToPoint(int ptindex);
    MaterialID *GetMaterialsConnectedToPoint(int ptindex, int& size);
 
    // operators
 
    // others functions
    C3DPointGridMap *InitSlicerMap(bool initMap, unsigned int sliceX, unsigned int sliceY, unsigned int sliceZ, unsigned int pointFlags = POINT_NONE, bool flagsSet = true);
    C3DPointGridMap *InitGridCoordMap(double distance, bool absolute);
    WeldProximityMap *InitWeldMap(double distance, bool absolute);
    void DeleteWeldMap(WeldProximityMap *map) const; //!< Free the weld map returned by InitWeldMap
    int *Get3DProximityPoints(int index, WeldProximityMap *weldMap, int& size); //!< Return the point indexes which are close to the given index. The return array should not be freed
    C3DPointSymetryMap *InitSymetryMap(AXIS_INFO symetry, double precision = FLOAT_EPSILON);
 
    void InitShareCoplanarFacesFlag(const CGeomInfo *info, double maxAngle);
    unsigned int Set2DCornerPointsStatus(CEdgeGraph& graph, double radianAngle);
    unsigned int Set3DCornerPointsStatus(CFaceList *faces, double radianAngle);
 
    double GetCompacityFactor(const int *indexes) const; //!< indexes is an array of 3 point indexes
    bool GetNormal(const int *indexes, C3DVector& normal) const; //!< indexes is an array of 3 point indexes
 
    // 3D modification functions
    C3DPoint GetCenterOfBoundingBox();
    bool GetObjectBoundingBox(C3DPoint *bbox8Pts, unsigned int flags = POINT_NONE, bool set = true, C4x4Matrix *matrix = NULL); //!< Compute OBB bounding box. bbox8Pts are the returned eight corners of the bounding box that are transformed by matrix if any provided.
    bool GetBoundingBox(C3DBBox& bbox, unsigned int flags = POINT_NONE, bool set = false, C4x4Matrix *matrix = NULL);
    bool GetBoundingBox(C3DPoint& min, C3DPoint& max, unsigned int flags = POINT_NONE, bool set = true, C4x4Matrix *matrix = NULL); //!< Compute AABB bounding box. Points are transformed by matrix if any provided
    void NoisyWaveFunc(const C3DPoint& upperleft, const C3DVector& length, double amplitude, double wavelength, double phase, POINT_PROPERTIES property = POINT_NONE, bool set = TRUE);
 
    virtual unsigned int GetChecksum(unsigned int checksumFlags = CHECKSUM_POINTS| CHECKSUM_POINTS_EXTRA) const; //!< Return a value that is a simple way to check if the geometry changed between two call to the method
 
    C3DPointList& operator=(const C3DPointList& refpoints);
    virtual CPointList& operator=(const CPointList& refpoints);
 
#ifdef _DEBUG
    CXString GetPointListType() const;
#endif
};
 
inline const C3DPoint *C3DPointList::GetFirst() const
{ 
    return (const C3DPoint *)CElementArray::GetFirst();
}
 
inline const C3DPoint *C3DPointList::GetNext(const C3DPoint *point) const
{
    return (const C3DPoint *)CElementArray::GetNext(point);
}
 
inline C3DPoint *C3DPointList::GetFirst()
{
    return (C3DPoint *)CElementArray::GetFirst();
}
 
inline C3DPoint *C3DPointList::GetNext(C3DPoint *pointList)
{
    return (C3DPoint *)CElementArray::GetNext(pointList);
}
 
inline C3DPoint *C3DPointList::ElementAt(int i)
{
    return ((C3DPoint *)CElementArray::ElementAt(i));
}
 
inline C3DPoint *C3DPointList::operator[](int i)
{
    return ((C3DPoint *)CElementArray::operator[](i));
}
inline const C3DPoint *C3DPointList::operator[](int i) const
{
    return ((const C3DPoint *)CElementArray::operator[](i));
}
 
END_MOOTOOLS_NAMESPACE
 
#endif // !defined(AFX_3DPOINTLIST_H__CA6BC2A5_FAC2_11D1_A0DE_000000000000__INCLUDED_)