PointList.h

Go to the documentation of this file.

//! @file PointList.h
//! CPointList class is the base class for different point array (C3DPointList, CUVWPointList...)
//!
//////////////////////////////////////////////////////////////////////
 
#if !defined(AFX_POINTLIST_H__E9597160_87C0_11D3_A029_C00DB92E437A__INCLUDED_)
#define AFX_POINTLIST_H__E9597160_87C0_11D3_A029_C00DB92E437A__INCLUDED_
 
#ifdef _MSC_VER
#pragma once
#endif // _MSC_VER
 
#include "DataChunk.h"
#include "3DExtraData.h"
#include "ElementArray.h"
#include "Point.h"
 
BEGIN_MOOTOOLS_NAMESPACE
 
//! @def POINT_ORIGINAL_INDEX_CHUNK
//! @brief Point data chunk custom ids
#define POINT_ORIGINAL_INDEX_CHUNK  MAKE_CUSTOM_ID('P', 'O', 'O', 'I')
 
//! @enum POINTLIST_PROPERTIES
//! @brief Flags used by CPointList
typedef enum  POINTLIST_PROPERTIES XEnumType(unsigned int)
{
    POINTLIST_NONE = 0x00,
    POINTLIST_HAS_CHANGED = 0x01, //!< Should be set each time something important changed, in order to update internal graphs
} POINTLIST_PROPERTIES;
 
class CPointMethods : public CElementMethods
{
    virtual SIZET GetSizeof() const = 0;
    virtual ElementType GetType() const = 0;
    virtual void ConstructElement(void* pNewData) = 0;
 
    virtual bool IsObject() const;
    ElementType GetBaseType() const;
    void CopyElement(void* pDest, const void* pSrc);
    void SerializeElement(CXArchive& ar, void* pSrc);
};
 
//! @class CPointList
//! @brief CPointList is the base class for different classes (C3DPointList, CUVWPointList...) that contains data such points, uvw, vectors...
//! @details CPointList offers all methods to get/set the points, to modify them and associates any kind of data to points.
//! CPointList includes different relationship graph to find easily who is connected with who.\n
//! @note As CPointList inherits from CInstanciatedObject, it can be referenced multiple time. Use CPointList::Delete instead of delete to delete the list. 
class DLL_3DFUNCTION CPointList : protected CElementArray, public CInstanciatedObject
{
    DECLARE_DYNAMIC_XOBJECT(CPointList);
 
public:
    using CElementArray::GetThisRuntimeClassDescriptor;
    using CElementArray::GetRuntimeClassDescriptor;
    using CElementArray::GetSizeOfElement;
    using CElementArray::IsKindOf;
    using CElementArray::GetSize;
    using CElementArray::SetAt;
    using CElementArray::SetAtGrow;
    using CElementArray::Add;
 
    //! Creates a new point array. When srcPoints is provided, the data structure (datachunks) is inherited but the point list is created empty
    CPointList(CPointList *srcPoints);
 
    int SetGrowFactor(int nGrowBy);
    //! constructAllElements means that size elements are constructed (even if they are not used)\n
    //! this can be used when maintaining a point list that have (0 to size) elements avoiding a repeated construction/destruction\n
    void PreAllocate(int size, bool constructAllElementsOnce = false);
    virtual void SetSize(int size, bool growOnly = false, int growSize = CElementArray::GROW_KEEP_MODE); //!< growOnly = false means that memory block is shrink down if specified size is below existing size. growSize defines the way memory size increases when resizing the point array.
    virtual void RemoveAll();
    void FreeExtra();
 
    bool RemoveDataChunk(DataChunkID channel); //!< Remove the data chunk specified by its id
    unsigned int AddDataChunk(DataChunkID dataid, CElementMethods *methods); //!< Add a data chunk defined by an id and methods which give the way to construct / destroy the data chunk data.
    void *GetDataChunk(DataChunkID id, unsigned int index) const; //!< Return the data chunk for index point. The returned data can be cast accordingly giving the data chunk id.
    void AppendDataChunks(CPointList *srcPoints, bool copyEmpty = true); //!< Copy the data chunks that exists in the provided srcPoints list. If copyEmpty = true, the data chunk are created empty. Otherwise they are copied from the source point list.
    const CDataChunk& GetDataChunks() const; //!< Return the number of data chunk in the face list
    unsigned int GetDataChunkNbr() const; //!< Return the class that handles the data chunks.
    SIZET GetSizeOfData(DataChunkID id) const; //!< Return the data size of one element of the given data chunk.
 
    // CPointAccess
    const CPt *GetFirst() const;
    const CPt *GetNext(const CPt *point) const;
    CPt *GetFirst();
    CPt *GetNext(CPt *pointList);
    CPt *ElementAt(int i);
    const CPt *ElementAt(int i) const;
    CPt *operator[](int i);
    const CPt *operator[](int i) const;
 
    // operator CXObject*() { return (CXObject *)this; };
 
    bool CopyPoint(int dstindex, int srcindex);
    bool CopyPoint(int dstindex, int srcindex, const CPointList& srcpointlist);
 
    // Clean functions
    bool Clean(CFaceList *faces, CXUIntArray *newpointindex = NULL);
    bool Reorder(const unsigned int *reforder, unsigned int size, bool moveToDestinationIndexes);
 
    // Flags init functions
    void SetFlag(POINTLIST_PROPERTIES flag, bool set);
    bool IsFlagSet(POINTLIST_PROPERTIES flag) const;
    unsigned int GetChangedStamp() const; //!< Return a value that can be used to know if the list changed (value changed each time POINTLIST_HAS_CHANGED set)
 
    unsigned int GetPointFlags(unsigned int index) const;
    bool IsPointFlagSet(unsigned int index, POINT_PROPERTIES flag) const;
    bool CheckPointFlags(unsigned int index, unsigned int checkflags, bool allSetOrNoneSet) const;
    void SetPointFlag(unsigned int index, POINT_PROPERTIES flag, bool set);
    void SetPointFlags(unsigned int index, unsigned int refflags, bool set);
    bool IsPointOneFlagSet(unsigned int index, unsigned int refflags) const;
 
    void SetPointsFlags(unsigned int flags, bool set);
    void SetBorderPointsStatus(CEdgeGraph& edgeGraph, bool initPC2BP = false); // set initPC2BP to true to init POINT_CONNECTED_TO_POINT_AT_BORDER (requires a little overtime)
    void Set3DCornerPointsStatus(CFaceList *faces, double radianAngle);
    void SetInvalidPoints(CFaceList& facelist, bool keepExistingInvalidPoints);
    void SavePointsIndex();
    unsigned int GetOriginalIndex(unsigned int index) const;
 
    // List informations functions
    int GetNumberOfPoints(POINT_PROPERTIES, bool set);
    int GetNumberOfPoints(unsigned int properties, bool set);
 
    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
    
    // virtual function
    virtual void Inherit(const CPointList& refpoints);
    virtual void Serialize(CXArchive& ar);
 
    // pure virtual function
    virtual CPointList& operator=(const CPointList& refpoints);
 
#ifdef _DEBUG
    void Dump() const;
    unsigned int MemoryStats() const;
    virtual CXString GetPointListType() const = 0;
#endif
 
private:
    CDataChunk dataChunks;
 
protected:
    unsigned int changeStamp;
    unsigned int flags;
 
    virtual ~CPointList(); //!< Use Delete instead
    virtual bool UpdateList();
 
};
 
///////////////////////////////////////////////////////////////////////////////////
// CPointMethods
// Inline implementation
inline bool CPointMethods::IsObject() const
{
    return true;
}
 
inline ElementType CPointMethods::GetBaseType() const
{
    return MAKE_CUSTOM_ID('P', 'N', 'T', 'S');
}
 
inline void CPointMethods::CopyElement(void* pDest, const void* pSrc)
{
    *((CPt *)pDest) = *((const CPt *)pSrc);
}
 
inline void CPointMethods::SerializeElement(CXArchive& ar, void* pSrc)
{
    ((CPt *)pSrc)->Serialize(ar);
}
 
///////////////////////////////////////////////////////////////////////////////////
// CPointList
// Inline implementation
inline const CPt *CPointList::GetFirst() const
{
    return (const CPt *)CElementArray::GetFirst();
}
 
inline const CPt *CPointList::GetNext(const CPt *pointList) const
{
    return (const CPt *)CElementArray::GetNext(pointList);
}
 
inline CPt *CPointList::GetFirst()
{
    return (CPt *)CElementArray::GetFirst();
}
 
inline CPt *CPointList::GetNext(CPt *pointList)
{
    return (CPt *)CElementArray::GetNext(pointList);
}
 
inline CPt *CPointList::ElementAt(int i)
{
    return ((CPt *)CElementArray::ElementAt(i));
}
 
inline const CPt *CPointList::ElementAt(int i) const
{
    return ((const CPt *)CElementArray::ElementAt(i));
}
 
inline CPt *CPointList::operator[](int i)
{
    return ((CPt *)CElementArray::operator[](i));
}
 
inline const CPt *CPointList::operator[](int i) const
{
    return ((const CPt *)CElementArray::ElementAt(i));
}
 
inline unsigned int CPointList::GetOriginalIndex(unsigned int index) const
{
    COriginalIndexData *data = (COriginalIndexData *)dataChunks.GetData(POINT_ORIGINAL_INDEX_CHUNK, index);
    if (data)
        return data->index;
 
    return -1;
}
 
inline void *CPointList::GetDataChunk(unsigned id, unsigned int index) const
{
    return dataChunks.GetData(id, index);
}
 
inline SIZET CPointList::GetSizeOfData(unsigned id) const
{
    return dataChunks.GetSizeOfDataChunk(id);
}
 
END_MOOTOOLS_NAMESPACE
 
#endif // !defined(AFX_POINTLIST_H__E9597160_87C0_11D3_A029_C00DB92E437A__INCLUDED_)