FaceList.h

Go to the documentation of this file.

//! @file FaceList.h
//! @brief CFaceList class is the base class for different kind of face list.
//!
//////////////////////////////////////////////////////////////////////
 
#if !defined(AFX_FACELIST_H__CA6BC2A4_FAC2_11D1_A0DE_000000000000__INCLUDED_)
#define AFX_FACELIST_H__CA6BC2A4_FAC2_11D1_A0DE_000000000000__INCLUDED_
 
#ifdef _MSC_VER
#pragma once
#endif // _MSC_VER
 
#include "DataChunk.h"
#include "3DExtraData.h"
#include "AssociationMap.h"
#include "ElementArray.h"
#include "Face.h"
 
BEGIN_MOOTOOLS_NAMESPACE
 
//! @enum FACELIST_PROPERTIES
//! @brief some face list properties
typedef enum FACELIST_PROPERTIES
{
    FACELIST_NONE = 0x00,
    FACELIST_INTERNAL_FLAGS         = 0xFFF00000,
    FACELIST_ORDERED_FOR_RENDERING  = 0x00100000,
    FACELIST_MAT2FACE_INCLUDE_BACK  = 0x00200000, // The material graph includes both front and back face materials
    FACELIST_HAS_CHANGED            = 0x00400000, //!< Should be set each time something important changed, in order to update internal graphs
    FACELIST_SERIALIZE_FLAGS        = FACELIST_ORDERED_FOR_RENDERING,
} FACELIST_PROPERTIES;
typedef enum FACELIST_PROPERTIES {…};
 
//! @enum ConnectionInfoType
//! @brief This enum allows to get a set of face indexes given two point indexes
//! It is used by different methods such CFaceList::GetFacesConnectedToPoints or CFaceList::GetFacesNeighbourg
typedef enum ConnectionInfoType XEnumType(unsigned int)
{
    //!< The following are used by CFaceList::GetFacesConnectedToPoints
    CONNECTION_PT1_OR_PT2 = 1,      //!< Union of faces shared by pt1 and pt2
    CONNECTION_PT1_AND_PT2 = 2,     //!< Intersection of faces shared by pt1 and pt2
    CONNECTION_PT1_MINUS_PT2,       //!< Faces shared by pt1 but not by pt2
    CONNECTION_PT2_MINUS_PT1,       //!< Faces shared by pt2 but not by pt1
    CONNECTION_PT1_XOR_PT2,         //!< All faces shared by pt1 xor pt2
    CONNECTION_EDGE1 = 0x01,        //!< Used by CFaceList::GetFacesByOppositeEdges
    CONNECTION_EDGE2 = 0x02,        //!< Used by CFaceList::GetFacesByOppositeEdges
    CONNECTION_EXCLUDE_EDGE12 = 0x04, //!< Used by CFaceList::GetFacesByOppositeEdges
    CONNECTION_BY_POINTS = CONNECTION_PT1_OR_PT2,   //!< Get neighbourg faces of face index (CFaceList::GetFacesNeighbourg)
    CONNECTION_BY_EDGES = CONNECTION_PT1_AND_PT2,   //!< Get point indexes of any edges which contain point index (link by and edge) or get faces connected by an edge to face index (CFaceList::GetFacesNeighbourg)
    CONNECTION_BY_FACES,                            //!< Get point indexes of any faces which contain point index (CFaceList::GetPointsNeighbourg only)
    CONNECTION_BY_FACES_EXCLUDING_EDGE,             //!< Get point indexes of any faces which contain point index minus the edges which contain point index (CFaceList::GetPointsNeighbourg only)
} ConnectionInfoType;
typedef enum ConnectionInfoType XEnumType(unsigned int) {…};
 
// Default data chunk that can be added to a face list
#define FACEPROPERTY_CHUNK          MAKE_CUSTOM_ID('F', 'C', 'P', 'R')
#define FACE_ORIGINAL_INDEX_CHUNK   MAKE_CUSTOM_ID('F', 'A', 'O', 'I')
#define FACE_SMOOTH_FLAG            MAKE_CUSTOM_ID('F', 'A', 'S', 'F')
#define FACE_SUB_MAT_FLAG           MAKE_CUSTOM_ID('F', 'A', 'S', 'M')
#define FACE_BACK_MATERIAL          MAKE_CUSTOM_ID('B', 'K', 'M', 'T')
#define FACETAG_DATA_CHUNK          MAKE_CUSTOM_ID('F', 'C', 'T', 'G')
 
class CFacePropertyMethods : public CElementMethods
{
    DECLARE_SERIAL_XOBJECT(CFacePropertyMethods);
 
    SIZET GetSizeof() const;
    ElementType GetType() const;
    ElementType GetBaseType() const;
    void ConstructElement(void* pNewData);
};
class CFacePropertyMethods : public CElementMethods {…};
 
class C3DEdge
{
protected:
    int point1;
    int point2;
 
public:
    C3DEdge();
    C3DEdge(int point1, int point2);
    int Point1() const;
    int Point2() const;
 
    void SetMatchLessEdge(int point1, int point2);
    void SetEdge(int point1, int point2);
    C3DEdge& operator=(const C3DEdge& edge);
    bool operator<(const C3DEdge& edge);
    bool operator==(const C3DEdge& edge) const;
    bool operator!=(const C3DEdge& edge) const;
};
class C3DEdge {…};
 
//! @class CFaceGraphHelper
//! @brief This class allows to increase performance on repetitive calls to specific CFaceList methods.
class DLL_3DFUNCTION CFaceGraphHelper
{
    friend CFaceList;
 
public:
    CFaceGraphHelper();
    virtual ~CFaceGraphHelper();
 
    void ReleaseArray(const int *connections); //!< To be call once do not need any more indexes returned by the method using the CFaceGraphHelper.
 
protected:
#ifdef _DEBUG
    bool lock;
#endif
 
    CHashTable<int> hash;
    int *connections;
    unsigned int connectionsSize;
 
    int *GetArray(unsigned int size);
};
class DLL_3DFUNCTION CFaceGraphHelper {…};
 
//! @class CFaceTagger
//! @brief CFaceTagger is the base class that allows to gather face together using C3DFaceList::TagFaces.
//! @details Derive this class to have your own control on the way face are gathered together.
class DLL_3DFUNCTION CFaceTagger
{
    friend CFaceList;
 
protected:
    CGeomInfo *info;
    CPointList *points;
    CFaceList *faces;
 
    // initialized before calling BelongToGroup
public:
    virtual ~CFaceTagger();
 
    //! Default implementation return true
    virtual bool InitProcess(CGeomInfo *info);
    //! Default implementation does nothing
    virtual void EndProcess(unsigned int createdGroup);
 
    //! @brief BeginNewGroup is called when a new group is to be created.
    //! @details Groupnbr is the number of the group, firstface is the first face of the group
    //! default implementation does nothing
    virtual void BeginNewGroup(unsigned int groupnbr, unsigned int firstface);
 
    //! @name BelongToGroup check if some faces belong to the #face group
    //! @details You decide if a face belong to a group or not using your own criteria and goal
    //! * Returns false if the given face should not belong to #face group\n
    //! * Returns true if it belongs to #face group\n
    //! You can exclude some of the provided faces to be part of the group. In such case simply set faces[i] = -1\n
    //! Faces you let belong to the group will be enqueued, so you'll be asked by propagation if their connections belong to the same group too.\n
    //! Faces you exclude from the group will be excluded from the group but process laterly in a different group.\n\n
    //! * The default implementation returns true, without excluding any faces to belong to the group.\n
    //! Doing that all connected faces belong to the group.\n
    //! This implementation automatically creates group of faces connected by edges, or group of faces connected by points\n
    //! 
    //! * If you return false, following your own criteria, a new group will begin and the process continue until all faces have been assigned to its specific group.
    //! @{
    virtual bool BelongToGroup(unsigned int face, C3DEdge& edge, int *faces, unsigned int size); //!< Called when exploreByEdge= true in C3DFaceList::TagFaces.\n faces is an array of size face indexes connected by an edge to face.\n Return true by default
    virtual bool BelongToGroup(unsigned int face, unsigned int point, int *faces, unsigned int size); //!< Called when exploreByEdge= false. faces is an array of size face indexes connected to faces points.\n C3DFaceList::TagFaces.\n Return true by default
 
    //! @}
 
    //! @brief ProcessGroup validates a group of face that belong to the same group.
    //! @brief This group contains size elements
    virtual void ProcessGroup(const int *faces, unsigned int size) = 0; 
};
class DLL_3DFUNCTION CFaceTagger {…};
 
#define FACELIST_DEFAULT_INDEX_NBR 4
 
class CSingleFace;
 
//! @class CFaceList
//! @brief CFaceList is the common base class for a lot of different classes (C3DFaceList, CUVWFaceList...)
//! @details Every faces is an index array (of at least 3 indexes) that refers to another list (usually points or vectors).
//! Faces are gather together in a CFaceList, which is in fact an array of array.
//!
//! CFaceList offers all methods to get/set the face indexes, to modify these indexes and associates any kind of data to faces\n
//! CFaceList includes different relationship graph to find easily who is connected with who.
//! Cf. @ref FACES to get advanced details on the way using CFaceList.
//!
//! @note As CFaceList inherits from CInstanciatedObject, it can be referenced multiple time. Use CPointList::Delete instead of delete to delete the list.
class DLL_3DFUNCTION CFaceList : public CXObject, public CInstanciatedObject
{
    DECLARE_DYNAMIC_XOBJECT(CFaceList);
 
public:
    //! @enum SetSizeMode
    //! Defines the way SetSize size down or not the index memory block 
    enum SetSizeMode
    {
        DEFAULT = 0, //!< Memory block is shrink down if specified size is below existing size
        FREE_EXTRA, //!< Free any extra memory and do not allocate any extra memory 
        //!< The number of face is growing, but we don't know the exact size.
        //!< Preallocate is first called with an estimated #number of faces, SetSize is then called several time with and increasing number of face (GROW_MODE), 
        //!< and finally called a last time with the definitive number of face.
        GROW_MODE,
    };
    enum SetSizeMode {…};
 
    //!< Create a new face list. When srcFaces is provided, the data structure (datachunks) is inherited but the face list is created empty
    CFaceList(CFaceList *srcFaces);
 
    virtual CFace *CreateFace() const = 0; //!< Get a face object the appropriate derived face type (ie it will return a C3DFace, with C3DFaceList, CNormalFace with CNormalFaceList...). Call CFaceList::ReleaseFace when you do not need it anymore
    void ReleaseFace(CFace *face) const;  //!< Release a face created with CFaceList::CreateFace
 
    bool GetFace(unsigned int index, CFace& face) const;
    bool GetFace(unsigned int index, CFace& face);
    int *GetIndexes(unsigned int index, int& size) const;
    int IsFaceIndex(unsigned int faceindex, int pointindex) const; //!< Check if point index belong to face. Return the index position of this pointindex or POINT_NOT_BELONG_TO_FACE) const;
    int* SetFaceSize(unsigned int index, int size, FACE_PROPERTIES invalidFlag = FACE_IS_INVALID); //!< Set the number of indexes for the given face index. If size < 3, then invalidFlag flag is set, if size >= 3 the flag is removed. For channel flags, FACE_IS_UNUSED should be used to keep the same number of faces between 3d faces and channel faces, if the matching 3d face is not set to invalid on a clean operation
    unsigned int GetFaceFlags(unsigned int index) const;
    bool IsFaceFlagSet(unsigned int index, FACE_PROPERTIES flag) const;
    bool CheckFaceFlags(unsigned int index, unsigned int flags, bool allSetOrNoneSet) const;
    bool IsFaceOneFlagSet(unsigned int index, unsigned int flags) const;
    void SetFaceFlag(unsigned int index, FACE_PROPERTIES flag, bool set);
    void SetFaceFlags(unsigned int index, unsigned int flags, bool set);
    int CollectIndexes(unsigned int index, CHashTable<int>& hash, bool erase = false) const; //!< Add the face indexes to the hash, and return the adedd count
 
    bool CopyFace(unsigned int dstindex, unsigned int srcindex, bool inheritPropertiesOnly = false); //!< Copy srcindex face to dstindex face.  inheritPropertiesOnly = true means only flags and properties are copied, otherwise indexes are also copied.
    bool CopyFace(unsigned int dstindex, unsigned int srcindex, const CFaceList& srcfacelist, bool inheritPropertiesOnly = false); //!< Copy a face from another face list.
    bool CopyFace(unsigned int dstindex, const CFace& srcface, bool inheritPropertiesOnly = false);
 
    // Save a particular face outside the face list
    void CopyTo(int index, CSingleFace& face) const;
    void CopyFrom(int index, const CSingleFace& face);
 
    // Element access
    virtual void Serialize(CXArchive& ar);
    void RemoveAll();
 
    //! @brief Preallocate the data with an estimated face nbr and total indexes count for the whole face set. The method removes any existing data.
    //! @details When filling the faces, SetSize must be called using GROW_MODE, otherwise faces array will be resized, loosing the preallocation advantages
    //! use constructAllElementsOnce carefully as it construct all elements (even if they are not used)
    void PreAllocate(int estimatedFaceNbr, int estimatedIndexNbr, bool constructAllElementsOnce = false);
    void SetSize(int size, SetSizeMode sizeMode, int defaultFaceSize = FACELIST_DEFAULT_INDEX_NBR); //!< Resize the size of the number of face. If growOnly, memory is not reallocated if buffer's size decrease
    void SetSize(int size, int defaultFaceSize = FACELIST_DEFAULT_INDEX_NBR, SetSizeMode sizeMode = DEFAULT, int growFaceMode = -1); //!< Resize the size of the number of face. If growOnly, memory is not reallocated if buffer's size decrease
    void SetSize(int size, unsigned int *initialSize, int defaultFaceSize = FACELIST_DEFAULT_INDEX_NBR, int growFaceMode = -1); //!< This reset the face and initialize it again
    void SetSize(const CFaceList& srcfaces, int growFaceMode = -1); //!< Reset face list and get faces size from srcfaces face list. No data is copied, only size are preallocated
    void ExpandSize(const CFaceList& srcfaces); //!< Expand the face list with srcfaces sizes. No data is copied, only size are preallocated. The method grows the faces (if needed), so CFaceList::PreAllocate can be used
    void FreeExtra();
 
    bool RemoveDataChunk(DataChunkID id); //!< Remove the data chunk specified by its id
    unsigned int AddDataChunk(DataChunkID id, 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 face. The returned data can be cast accordingly giving the data chunk id.
    CFacePropertyData *GetMainDataChunk(unsigned int index) const; //!< return the main data chunk for index. The main data chunk is a chunk like another one, but with faster access. It contains the flags, and it can be cast to C3DFacePropertyData, as it also contain the material
    void AppendDataChunks(CFaceList *srcFaces, bool copyEmpty = true); //!< Copy the data chunks that exists in the provided srcFaces list. If copyEmpty = true, the data chunk are created empty. Otherwise they are copied from the source face list.
    unsigned int GetDataChunkNbr() const; //!< Return the number of data chunk in the face list
    const CDataChunk& GetDataChunks() 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.
 
#ifdef _DEBUG
    unsigned int CountElements() const;
    virtual void Dump() const;
    unsigned int MemoryStats() const;
    virtual CXString GetFaceListType() const = 0;
#endif
 
    int GetSize() const; //!< Return the number of faces of the list
 
    void SaveFacesIndex(unsigned int dataChunkID = FACE_ORIGINAL_INDEX_CHUNK); //!< Save face indexes in a specific FACE_ORIGINAL_INDEX_CHUNK data chunk. Face index can be retrieve after, after a process that delete some faces or reorder them.
    unsigned int GetOriginalIndex(unsigned int index, unsigned int dataChunkID = FACE_ORIGINAL_INDEX_CHUNK) const; //!< Retrieve the original index of the face
 
//  int GetConnectedFaceGroup(const CGeomInfo *info, CHashAssocMap<int, int, int>& faceGroup, ConnectionInfoType mode, FACE_PROPERTIES flag = FACE_NONE, bool set = TRUE);
    bool AreFacesConnected(const CGeomInfo *info, CHashTable<int>& facesSet);
//  bool MergeFaces(const CGeomInfo *info, CFace& mergeFace, CHashTable<int>& facesToMerge);
    void GetEdgesOnBorder(CEdgeGraph& borderMap, CHashTable<int>& faces);
    void FlipFaces(FACE_PROPERTIES properties = FACE_NONE, bool musthave = true); //!< Reverse the indexes order. For a 3D face, a side effect is the normal inversion
    
    //! @brief Create group of faces which points/edges are delimited by a given property.
    //! @details This property is implemented by the caller through the faceTagger method.
    //! * exploreByEdge = true\n
    //! the faces are explored using an edge connection\n
    //! * exploreByEdge = false\n
    //! the faces are explored using a point connection.\n
    //! this is the slowest exploration mode as CFaceTagger::BelongToGroup is called for each face corner
    //!
    //! @return The method returns the number of created group.
    unsigned int TagFaces(CGeomInfo *info, CFaceTagger& faceTagger, bool exploreByEdge); //!< Gather face together in a CFaceTagger object.
 
    bool Clean(const CGeomInfo *info); //!< Clean faces with FACE_IS_INVALID status defined
    bool Clean(const CGeomInfo *info, bool cleanFaces,  CXUIntArray *newfacesindex = NULL); //!< Clean faces with FACE_IS_INVALID status defined and get an array contains the new to old index position (useful to clean external data too). 
    bool ReorderFaces(const unsigned int *neworder, unsigned int size, bool moveToDestinationIndexes); //!< Reorder faces given the order specified by neworder. If moveToDestinationIndexes is true  : Face[0] goes to face[neworder[0]], otherwise Face[neworder[0]] goes to face[0]. -1 in the array means no order changes.
    bool UpdateIndex(const unsigned int *newpointindex, unsigned int bufsize, bool onlyValidFaces = true); // Replace index using newpointindex information which size is bufsize (usually same than number of faces). For example index #0 will be newpointindex[0] after the call. newpointindex[i] can be egal to -1, meaning no change (equal to newpointindex[i] = i).
    bool UpdateIndex(CXUIntArray *newpointindex, bool onlyValidFaces = true); //!< Same method with a CXUIntArray class
    // int ReplaceIndex(const CGeomInfo *info, int replaceWithIndex, int *replacedIndexes, unsigned int size);
 
    // List informations
    void SetSizeAndFlags(int newsize, unsigned int flags); //!< Set face size and flags
    void SetSizeAndFlags(const CFaceList& faces, unsigned int flags); //!< Set faces which size are the same than provided faces list and set flags for these faces.
    void ExpandSizeAndFlags(const CFaceList& faces, unsigned int flags); //!< Increase face size and set flags for the new faces
 
    void SetFlag(FACELIST_PROPERTIES flag, bool set); //<! Set face list flag
    bool IsFlagSet(FACELIST_PROPERTIES flag) const; //<! Retrieve face list flag
    unsigned int GetChangedStamp() const; // Return a value that can be used to know if the list changed (value changed each time FACELIST_HAS_CHANGED set)
 
    bool IsTriangular(FACE_PROPERTIES properties = FACE_NONE, bool musthave = true) const; // Returns true if the face list contains triangles with the given optional properties. The function returns false if it has at least one valid not triangular face. It returns false, if there is no face or only triangles with the provided properties.
    bool HasQuadrangle(FACE_PROPERTIES properties = FACE_NONE, bool musthave = true) const; // Returns true if the face list contains at least one face with more than 4 points and the given properties (or no specific properties if properties = FACE_NONE)
    bool HasNGons(FACE_PROPERTIES properties = FACE_NONE, bool musthave = true) const; // Returns true if the face list contains at least one face with more than 4 points and the given properties (or no specific properties if properties = FACE_NONE)
    unsigned int GetFaceCount(unsigned int edgenbr, FACE_PROPERTIES properties = FACE_NONE, bool musthave = true) const; // Returns the number of face with the given properties and edgenbr. If edgenbr = -1, return the number of face > 4 edges
    unsigned int GetIndexesCount(FACE_PROPERTIES properties = FACE_NONE, bool musthave = true) const;
 
    bool InheritFlags(CFaceList& srcList, FACE_PROPERTIES srcflag, FACE_PROPERTIES dstflag, bool accumulate);
    int GetNumberOfFaces(FACE_PROPERTIES, bool set) const;
    int GetNumberOfFaces(unsigned int property, bool set) const; // Return the number of faces that have at least one flag set.
    void SetFacesFlags(unsigned int first, unsigned int last, unsigned int flags, bool set);
    void SetFacesFlags(unsigned int flags, bool set);
    void SetFacesSize(unsigned int facesize);
 
    const C3DEdgeArray* InitEdgeArray(); //!< Always return an array (even if empty) containing all edge of the face list, without connection information.
    void DeleteEdgeArray(); //!< A call to DeleteEdgeArray must be balanced for each call to InitEdgeArray
 
    int InitEdgeToFaceGraph(const CGeomInfo *info); //!< Init Edge graph which is a map containing each different edge and their connections. Return the number of edges of the graph. Needed for any methods that required information about connections.
    void DeleteEdgeToFaceGraph(); //!< Release the edge graph when no longer needed. Any call to InitEdgeToFaceGraph must be followed by a call to DeleteEdgeToFaceGraph
 
    const int *GetFacesConnectedToEdge(const C3DEdge&, int& size); //!< Get faces connected to an edge. The returned array has size indexes.
    CEdgeGraph& GetEdgeGraph(void); //!< Get the CEdgeGraph
    void SetBorderFacesStatus(void);
 
    int InitPointToFaceGraph(const CGeomInfo *info); //<! Init a point to face graph that informs about which point is connected to which face. Return the number of entry in the point to face graph, which is the number of points, unless some faces are invalid
    void DeletePointToFaceGraph(); //!< Release the point to face graph. Any call to InitPointToFaceGraph must be followed by a call to DeletePointToFaceGraph
    bool HasPointToFaceGraph() const; //!< Return true if the point to face graph is computed
 
    //int *GetFacesConnectedToFace(int, int& size);
    const int *GetFacesNeighbourg(CFaceGraphHelper& helper, int faceindex, ConnectionInfoType type, int& size);
    int GetFacesNeighbourg(CHashTable<int>& hash, int faceindex, ConnectionInfoType type, bool clearhash);
    const int *GetFacesConnectedToPoint(int, int& size) const;
    int GetFacesConnectedToPoints(CHashTable<int>& hash, int point1, int point2, ConnectionInfoType type, bool clearhash) const;
    const int *GetFacesConnectedToPoints(CFaceGraphHelper& helper, int point1, int point2, ConnectionInfoType type, int& size) const;
    int GetPointsConnectedToPoints(CHashTable<int>& hash, int point1, int point2, ConnectionInfoType type);
    const int *GetPointsConnectedToPoints(CFaceGraphHelper& helper, int point1, int point2, ConnectionInfoType type, int& size);
    const int *GetPointsConnectedToEdge(CFaceGraphHelper& helper, int point1, int point2, int& size, bool excludePt1AndPt2);
    const int *GetPointsNeighbourg(CFaceGraphHelper& helper, int pointindex, int& size, ConnectionInfoType type);
    bool IsPointNeighbourg(CFaceGraphHelper& helper, int index, int isNeighbourgIndex);
    bool DoesEdgeExists(const C3DEdge& edge, int face = -1) const;
    int GetFacesByOppositeEdges(CFaceGraphHelper& helper, int point1, int point2, ConnectionInfoType type, CEdgeGraph& edgeGraph);
    bool IsIsolatedFace(int facenbr) const;
 
    // Update the point to face graph when it exists
    int GraphRemoveFaceReference(CGeomInfo *info, int faceindex, bool setAlonePointsToInvalid);
    int GraphMergePointConnectivity(int, int);
    bool GraphDisconnectFace(int ptindex, int faceindex);
    bool GraphConnectFace(int ptindex, int faceindex);
 
    virtual unsigned int GetChecksum(unsigned int checksumFlags = CHECKSUM_FACES | CHECKSUM_FACES_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 CFaceList& reffaces);
    virtual CFaceList& operator=(const CFaceList& reffaces);
 
private:
    int size;
    CSimpleCollection<int, unsigned short> ptsIndex;
    CDataChunk dataChunks;
 
    // Point to face graph
    typedef CSimpleCollection<int, unsigned short> CFaceGraph;
    CFaceGraph *faceGraph;
    int faceGraphLock;
 
    // Edge to face graph
    CEdgeGraph *edgeGraph;
    int edgeGraphLock;
 
    // Edge array
    C3DEdgeArray* edgeArray;
    int edgeArrayLock;
 
    CHashTable<int> *hashConnectionSet; // Hash for GetConnectionSet
 
    int GetConnectionSet(CHashTable<int>& hashConnections, const int *pt1data, const int *pt2data, int size1, int size2, ConnectionInfoType type);
 
protected:
    unsigned int changeStamp;
    unsigned int flags;
 
    virtual ~CFaceList(); // Use Delete instead
 
    // protected Methods
    void CleanPointsIndex(const CGeomInfo *info);
 
    // Virtual protected methods
    virtual bool UpdateList();
 
    // Protected point graph
    void CreatePointToFaceGraph(const CGeomInfo *info);
 
    // Protected edge graph
    void CreateEdgeToFaceGraph();
};
class DLL_3DFUNCTION CFaceList : public CXObject, public CInstanciatedObject {…};
 
// Allow to save a face outside a face for a temporary usage.
class DLL_3DFUNCTION CSingleFace
{
    friend CFaceList;
 
protected:
    CSimpleCollection<int, unsigned short> ptsIndex;
    CDataChunk dataChunks;
 
    void SetList(const CFaceList& list);
 
public:
    CSingleFace(const CFaceList& list);
};
class DLL_3DFUNCTION CSingleFace {…};
 
///////////////////////////////////////////////////////////////////////////////////
// CFacePropertyMethods
inline SIZET CFacePropertyMethods::GetSizeof() const
{
    return sizeof(CFacePropertyData);
}
 
inline ElementType CFacePropertyMethods::GetType() const
{
    return MAKE_CUSTOM_ID('F', 'A', 'C', 'E');
}
 
inline ElementType CFacePropertyMethods::GetBaseType() const
{
    return MAKE_CUSTOM_ID('F', 'A', 'C', 'E');
}
 
inline void CFacePropertyMethods::ConstructElement(void* pNewData)
{
    xConstruct(CFacePropertyData, pNewData);
}
 
///////////////////////////////////////////////////////////////////////////////////
// C3DEdge
inline void CFaceGraphHelper::ReleaseArray(const int *refconnections)
{
#ifdef _DEBUG
    lock = false; // lock can be FALSE (ie. CFaceList::GetFacesConnectedToPoints)
    XASSERT(!refconnections || refconnections == this->connections);
#endif
}
inline void CFaceGraphHelper::ReleaseArray(const int *refconnections) {…}
 
///////////////////////////////////////////////////////////////////////////////////
//! @class C3DEdge
//! @brief C3DEdge is a class containing 2 point indexes that represent the edge of a face.
//! @note
//! The points are ordered for making comparison easier. That means that C3DEdge::point1 < C3DEdge::point2\n
//! If you need unordered edge, use C3DEdge::SetMatchLessEdge. C3DEdge::operator == cannot be used with such edges
inline C3DEdge::C3DEdge()
{
}
 
inline void C3DEdge::SetEdge(int refpoint1, int refpoint2)
{
#ifdef _DEBUG
    if (refpoint1 == refpoint2)
        XTRACE("SetEdge point1 == point2\n");
#endif
 
    if (refpoint1 < refpoint2)
    {
        this->point1 = refpoint1;
        this->point2 = refpoint2;
    }
    else
    {
        this->point1 = refpoint2;
        this->point2 = refpoint1;
    }
}
 
inline C3DEdge::C3DEdge(int refpoint1, int refpoint2)
{
    SetEdge(refpoint1, refpoint2);
};
 
inline int C3DEdge::Point1() const
{
    return point1;
}
 
inline int C3DEdge::Point2() const
{
    return point2;
}
 
inline void C3DEdge::SetMatchLessEdge(int refpoint1, int refpoint2)
{
    // The operator == cannot be used with such edge
    // But this is useful in another case, ie for symetric edge
    // e1 = Edge(a,b), e2 = Sym(e1)
    // SetMatchLessEdge, allows to know that e1.point1 = Sym(e2.point1) and e1.point2 = Sym(e2.point2)
    this->point1 = refpoint1;
    this->point2 = refpoint2;
}
 
inline C3DEdge& C3DEdge::operator=(const C3DEdge& edge)
{
    this->point1 = edge.point1;
    this->point2 = edge.point2;
 
    return *this;
}
 
inline bool C3DEdge::operator<(const C3DEdge& edge)
{
    if (point1 < edge.point1)
        return true;
 
    return false;
}
 
inline bool C3DEdge::operator==(const C3DEdge& edge) const
{
    // Pair are ordered (point1 < point2)
    if (point1 == edge.point1 && point2 == edge.point2)
        return true;
 
    return false;
};
 
inline bool C3DEdge::operator!=(const C3DEdge& edge) const
{
    // Pair are ordered (point1 < point2)
    if (point1 != edge.point1)
        return true;
    
    if (point2 != edge.point2)
        return true;
 
    return false;
};
 
// This hash value does not work with unordered pairs (C3DEdge(point1 = 3, point2 = 8) and C3DEdge(point1 = 8, point2 = 3) does not give the same hash) 
template <> class CHashMethods<C3DEdge>
{
public:
    static inline unsigned int HashValue(const C3DEdge &edge)
    {
    #ifdef OLD_HASH_FUNCTIONS
        return ((unsigned int)(edge.Point1() << 8)) + edge.Point2();
    #else
        return HashMixValue(edge.Point1()) + edge.Point2();
    #endif
    }
 
    static inline bool HashCompare(const C3DEdge &edge1, const C3DEdge &edge2)
    {
        // Pair are ordered (point1 < point2)
        if (edge1.Point1() != edge2.Point1() || edge1.Point2() != edge2.Point2())
            return false;
 
        return true;
    }
};
 
///////////////////////////////////////////////////////////////////////////////////
// CFaceList
inline int CFaceList::GetSize() const
{
    return size;
}
inline int CFaceList::GetSize() const {…}
 
inline void CFaceList::ReleaseFace(CFace *face) const
{
    xDelete(face);
}
inline void CFaceList::ReleaseFace(CFace *face) const {…}
    
inline bool CFaceList::GetFace(unsigned int index, CFace& face) const
{
    if (index >= ptsIndex.GetEntriesSize())
        return false;
 
    ((CFace&)face).faces = (CFaceList *)this; // Not really safe. Should be NULL ?
    ptsIndex.GetEntry(index, face);
    face.prop = (CFacePropertyData *)dataChunks.GetMainData(index);
 
    return true;
}
 
inline bool CFaceList::GetFace(unsigned int index, CFace& face)
{
    if (index >= ptsIndex.GetEntriesSize())
        return false;
 
    face.faces = this;
    ptsIndex.GetEntry(index, face);
    face.prop = (CFacePropertyData *)dataChunks.GetMainData(index);
 
    return true;
}
 
// Note: this method is to be use with care, as it does not perform any check on the provided data.
// The face might have the FACE_IS_UNUSED or FACE_IS_INVALID flag
inline int *CFaceList::GetIndexes(unsigned int index, int& refsize) const
{
    XASSERT(index < ptsIndex.GetEntriesSize());
    return ptsIndex.GetEntry(index, refsize);
}
 
inline int CFaceList::IsFaceIndex(unsigned int faceindex, int pointindex) const
{
    if (faceindex >= ptsIndex.GetEntriesSize())
        return POINT_NOT_BELONG_TO_FACE;
 
    int size;
    const int *points_data = ptsIndex.GetEntry(faceindex, size);
    for (int i = 0; i < size; i++)
    {
        if (points_data[i] == pointindex)
            return i;
    }
 
    return POINT_NOT_BELONG_TO_FACE;
}
inline int CFaceList::IsFaceIndex(unsigned int faceindex, int pointindex) const {…}
 
inline int* CFaceList::SetFaceSize(unsigned int index, int refsize, FACE_PROPERTIES invalidFlag)
{
    XASSERT(index < ptsIndex.GetEntriesSize());
    SetFaceFlag(index, invalidFlag, refsize < 3);
    return ptsIndex.SetEntrySize(index, refsize);
}
inline int* CFaceList::SetFaceSize(unsigned int index, int refsize, FACE_PROPERTIES invalidFlag) {…}
 
inline unsigned int CFaceList::GetFaceFlags(unsigned int index) const
{
    if (index >= ptsIndex.GetEntriesSize())
        return FACE_NONE;
 
    return ((CFacePropertyData *)dataChunks.GetMainData(index))->flags;
}
 
inline bool CFaceList::IsFaceFlagSet(unsigned int index, FACE_PROPERTIES flag) const
{
    if (index >= ptsIndex.GetEntriesSize())
        return false;
 
    CFacePropertyData *prop = (CFacePropertyData *)dataChunks.GetMainData(index);
    return ((prop->flags & flag) == flag);
}
 
inline bool CFaceList::CheckFaceFlags(unsigned int index, unsigned int checkflags, bool allSetOrNoneSet) const
{
    if (index >= ptsIndex.GetEntriesSize())
        return false;
 
    CFacePropertyData *prop = (CFacePropertyData *)dataChunks.GetMainData(index);
 
    if (allSetOrNoneSet && ((prop->flags & checkflags) == checkflags))
        return true;
    else if (!allSetOrNoneSet && ((prop->flags & checkflags) == 0))
        return true;
 
    return false;
}
 
inline void CFaceList::SetFaceFlag(unsigned int index, FACE_PROPERTIES flag, bool set)
{
    if (index >= ptsIndex.GetEntriesSize())
        return;
 
    CFacePropertyData *prop = (CFacePropertyData *)dataChunks.GetMainData(index);
    if (set)
        prop->flags |= flag;
    else
        prop->flags &= ~flag;
}
 
inline void CFaceList::SetFaceFlags(unsigned int index, unsigned int refflags, bool set)
{
    if (index >= ptsIndex.GetEntriesSize())
        return;
 
    CFacePropertyData *prop = (CFacePropertyData *)dataChunks.GetMainData(index);
    if (set)
        prop->flags |= refflags;
    else
        prop->flags &= ~refflags;
}
 
inline bool CFaceList::IsFaceOneFlagSet(unsigned int index, unsigned int refflags) const
{
    if (index >= ptsIndex.GetEntriesSize())
        return false;
 
    CFacePropertyData *prop = (CFacePropertyData *)dataChunks.GetMainData(index);
    return ((prop->flags & refflags) != 0);
}
 
// inheritPropertiesOnly = true means that only the flags and properties are copied. The face indexes and size are not modified. If the face is empty, it remains empty
// inheritPropertiesOnly = false means that the whole face is copied (indexes and properties)
//
// Do not use this method if a CFace exists for the list. It might become invalid if reallocation occurs
// Prefer CFace::Copy() instead or use GetFace(dstindex) after the call to the method
inline bool CFaceList::CopyFace(unsigned int dstindex, unsigned int srcindex, bool inheritPropertiesOnly)
{
    if (dstindex == srcindex)
        return true;
 
    dataChunks.CopyData(dstindex, srcindex, dataChunks);
    if (inheritPropertiesOnly)
        return true;
        
    ptsIndex.SetEntry(dstindex, srcindex);
    return true;
}
inline bool CFaceList::CopyFace(unsigned int dstindex, unsigned int srcindex, bool inheritPropertiesOnly) {…}
 
// inheritPropertiesOnly = true means that only the flags and properties are copied. The face indexes and size are not modified. If the face is empty, it remains empty
// inheritPropertiesOnly = false means that the whole face is copied (indexes and properties)// Slowest method, because it create a CFace accessor each time its called
//
// use CopyFace(CFace& dstface, const CFace& srcface) when possible
inline bool CFaceList::CopyFace(unsigned int dstindex, unsigned int srcindex, const CFaceList& srcfacelist, bool inheritPropertiesOnly)
{
    dataChunks.CopyData(dstindex, srcindex, srcfacelist.dataChunks);
    if (inheritPropertiesOnly)
        return true;
 
    int tmpsize;
    int *indexes = srcfacelist.ptsIndex.GetEntry(srcindex, tmpsize);
    if (!indexes)
        return false;
 
    ptsIndex.SetEntry(dstindex, indexes, tmpsize);
    return true;
}
inline bool CFaceList::CopyFace(unsigned int dstindex, unsigned int srcindex, const CFaceList& srcfacelist, bool inheritPropertiesOnly) {…}
 
// inheritPropertiesOnly = true means that only the flags and properties are copied. The face indexes and size are not modified. If the face is empty, it remains empty
// inheritPropertiesOnly = false means that the whole face is copied (indexes and properties)
//
// If srcface belong to the face list, it might become invalid if reallocation occurs
// Prefer CFace::Copy() instead or use GetFace after the call to the method
inline bool CFaceList::CopyFace(unsigned int dstindex, const CFace& srcface, bool inheritPropertiesOnly)
{
    dataChunks.CopyData(dstindex, srcface.GetEntryIndex(), srcface.faces->dataChunks);
    if (inheritPropertiesOnly)
        return true;
    
    ptsIndex.SetEntry(dstindex, srcface);
    return true;
}
 
inline const CDataChunk& CFaceList::GetDataChunks() const
{
    return dataChunks;
}
inline const CDataChunk& CFaceList::GetDataChunks() const {…}
 
inline unsigned int CFaceList::GetOriginalIndex(unsigned int index, unsigned int dataChunkID) const
{
    COriginalIndexData *data = (COriginalIndexData *)dataChunks.GetData(dataChunkID, index);
    if (data)
        return data->index;
 
    return -1;
}
inline unsigned int CFaceList::GetOriginalIndex(unsigned int index, unsigned int dataChunkID) const {…}
 
///////////////////////////////////////////////////////////////////////////////////
// CFacePropertyData Inline implementation
 
inline CFacePropertyData *CFaceList::GetMainDataChunk(unsigned int index) const
{
    return static_cast<CFacePropertyData *>(dataChunks.GetMainData(index));
}
inline CFacePropertyData *CFaceList::GetMainDataChunk(unsigned int index) const {…}
 
inline void *CFaceList::GetDataChunk(unsigned id, unsigned int index) const
{
    return dataChunks.GetData(id, index);
}
inline void *CFaceList::GetDataChunk(unsigned id, unsigned int index) const {…}
 
inline SIZET CFaceList::GetSizeOfData(unsigned id) const
{
    return dataChunks.GetSizeOfDataChunk(id);
}
inline SIZET CFaceList::GetSizeOfData(unsigned id) const {…}
 
///////////////////////////////////////////////////////////////////////////////////
// CFace Inline implementation (method with reference to CFaceList only)
inline bool CFace::Copy(const CFace& srcface)
{
    CCollectionElement<int, unsigned short>::Copy(srcface);
    return faces->CopyFace(GetEntryIndex(), srcface, true);
}
 
inline bool CFace::Copy(unsigned int srcindex)
{
    CCollectionElement<int, unsigned short>::Copy(srcindex);
    return faces->CopyFace(GetEntryIndex(), srcindex, true);
}
 
inline void CFace::Inherit(const CFace& face)
{
    faces->CopyFace(GetEntryIndex(), face, true);
}
inline void CFace::Inherit(const CFace& face) {…}
 
inline void *CFace::GetDataChunk(unsigned int id) const
{
    return faces->GetDataChunk(id, GetEntryIndex());
}
 
inline SIZET CFace::GetSizeOfData(unsigned int id) const
{
    return faces->GetSizeOfData(id);
}
 
 
END_MOOTOOLS_NAMESPACE
 
#endif // !defined(AFX_FACELIST_H__CA6BC2A4_FAC2_11D1_A0DE_000000000000__INCLUDED_)