3DExtObject.h

Go to the documentation of this file.

//! @file 3DExtObject.h
//! C3DExtObject class is a geom object that can be optimize. It is generally used with a CSceneOptimizer.
//!
//////////////////////////////////////////////////////////////////////
 
#if !defined(AFX_3DExtObject_H__BB3D80E9_003C_11D2_A0E3_000000000000__INCLUDED_)
#define AFX_3DExtObject_H__BB3D80E9_003C_11D2_A0E3_000000000000__INCLUDED_
 
#ifdef _MSC_VER
#pragma once
#endif // _MSC_VER
 
#include "PolygonCruncherConfig.h"
#include "SceneOptimizer.h"
#include "3DObject.h"
#include "3DExtPoint.h"
#include "TrackInfo.h"
#include "CustomHeap.h"
 
BEGIN_MOOTOOLS_NAMESPACE
 
#define FACE_HAS_AT_LEAST_ONE_POINT_TO_BE_OPTIMIZED FACE_USER_PROPERTIES1
#define FACE_HAS_ALL_POINTS_TO_BE_OPTIMIZED FACE_USER_PROPERTIES2
 
#define POINT_OPTIMIZE_FLAG POINT_USER_PROPERTIES1 // Point is to be optimized
#define POINT_OPTIMIZE_PROTECTED POINT_USER_PROPERTIES2 // Point has been constraint
#define POINT_OPTIMIZE_PRESERVED POINT_USER_PROPERTIES3 // Point is only preserved
 
typedef enum _MOVE_FACTOR
{
    FIND_BEST_MOVE = 1,
    MOVE_CONSTRAINT_LEVEL1 = 2,
    MOVE_CONSTRAINT_LEVEL2 = 3,
    MOVE_CONSTRAINT_LEVEL3 = 4,
    MOVE_CONSTRAINT_LEVEL4 = 5,
    MOVE_CONSTRAINT_LEVEL5 = 6,
    MOVE_CONSTRAINT_LEVEL6 = 7,
    MOVE_CONSTRAINT_HIGHEST_LEVEL = 8,
} MOVE_FACTOR;
 
#define MULTIRES_DATA_FILE  MAKE_CUSTOM_ID('M', 'R', 'F', 'L')
#define MULTIRES_DATA_POINTS_ORDER MAKE_CUSTOM_ID('P', 'O', 'R', 'D')
#define MULTIRES_DATA_FACES_ORDER MAKE_CUSTOM_ID('F', 'O', 'R', 'D')
#define MULTIRES_DATA_TRIANGULATION MAKE_CUSTOM_ID('T', 'R', 'D', 'A')
 
class CMultiresolutionObject;
class CMultiresolutionObject1;
 
//! @class C3DExtObject
//! @brief This class handles static optimization of an object.
//! @details CSceneOptimizer handles optimization for a set of C3DExtObject objects.
//! CSceneOptimizer::Optimize calls the C3DExtObject::Optimize for each objects it contains.
//! 
//! When optimizing an object there is two phases:
//! * Optimization initialization, which might changes any time SetOptimizeMode is called
//! * Optimization itself which consist in point removal and which occurs in C3DExtObject::Optimize\n
//! This step can be "recorded" when using SCENEOPTIMIZER_TRACK_CHANGES is set.\n
//! Tracking the changes provides a way to have dynamic optmization through CMultiresolutionObject which is get from the C3DExtObject.
//! 
//! Calling C3DExtObject directly give you some additional possibilities compared to accessing them only through CSceneOptimizer.
//! * It is possible to call Optimize with a specific ratio for each C3DExtObject
//! * It is possible to exclude some materials from the optimization using C3DExtObject::SelectMaterial
//! * It is possible to perform optimization only on the selected points using POINT_IS_SELECTED and one of the OPTIMIZE_SELECTION_MASK flag.
//! 
class DLLFUNCTION C3DExtObject : public C3DObject
{
public:
    DECLARE_SERIAL_XOBJECT(C3DExtObject);
 
protected:
    // optimized results
    CExtPointList *optimizedPoints;
    C3DFaceList *optimizedFaces;
    CDependentChannels *optimizedChannels;
    
    // initial points
    C3DFaceList *initFaces;
    C3DPointList *initPoints; // Is a C3DPointList (SCENEOPTIMIZER_INTERACTIVE_MODE is set) or a CExtPointList (!SCENEOPTIMIZER_INTERACTIVE_MODE)
    CDependentChannels *initChannels;
 
    // Symetry map...
    C3DPointSymetryMap *initSymetryMap;
    C3DPointSymetryMap *optimizedSymetryMap;
 
    // Tracking informations...
    CTrackContractions *trackInfo;
 
    // pairs map (unordered pairs) used to generate single pair 
    // (avoid to have twice the same pair) only used when Init is call
    CXArray<CContractionCost, CContractionCost&> edgesCost;
    CHashTable<CContractionCost *> pairs;
    CostHeap costlist; // Heap list used for the pairs removal
 
    CFaceGraphHelper graphHelper; // Optimization
 
    double prevRatio, sceneRatio, progressiveThreshold;
    int initialRemovablePointNbr, initialRemovableFaceNbr; // Number of faces that can be optimised at the beginning of the process
    int removedPointNbr, removedFaceNbr; // Number of removed point of the current optimisation
    longuint optimizationMode, optimizationExtMode;
 
    CMaterialHashMap excludedMaterials;
    CSceneOptimizer *optimizer;
    C3DSceneNode *refnode;
 
    typedef enum ExtObjectFlags
    {
        EO_NONE = 0x00,
 
        // Internal state flags
        EO_INTERNAL_FLAGS           = 0x0000FF00, // These flags cannot be set by the user
        EO_ALREADY_TRIANGULAR       = 0x00000100, // No triangulation is required, the mesh is already a trimesh
        EO_ALREADY_PERVERTEX        = 0x00000200, // No pervertex computation is required, the mesh is pervertex compatible
 
        EO_INVALIDATION_FLAGS           = 0xFFFF0000,
        EO_INIT_OPTIMIZATION_DATA_DONE  = 0x00010000, // the face and points are ready to optimized (triangulation is done)
        EO_INIT_SELECTION_DONE          = 0x00020000, // Is the faces and points to be optimised is done
        EO_OBJECT_CLEANUP_DONE          = 0x00040000, // Clean and prepare object flags for the initial data information...
        EO_UVTOLERANCE_DONE             = 0x00080000, // Is UV the tolerance must be initialized
        EO_VCTOLERANCE_DONE             = 0x00100000, // Is VC the tolerance must be initialized
        EO_NORMALTHRESHOLD_DONE         = 0x00200000, // Is normal the tolerance must be initialized
        EO_SYMETRY_DONE                 = 0x00400000, // Is symetry map must be initialized
        EO_WEIGHT_DONE                  = 0x00800000, // Is symetry map must be initialized
        EO_PERVERTEX_DONE               = 0x01000000, // Is confused map
        EO_INIT_COST_DONE               = 0x02000000, // The computation of the costs has been done
        EO_OPTIMIZATION_STARTED         = 0x04000000, // The optimization has been started (but might have been canceled)
        EO_OPTIMIZATION_DONE            = 0x08000000, // The optimization has been done (and not canceled)
    } ExtObjectFlags;
 
    unsigned int extflags;
 
    bool hasSeveralMaterials, hasSelectedPoints;
    int workOnInitialObjectLock; // Allow the object to be modified by an external tool
    int lockInit; // lock initialization (allow to call SetOptimizeMode without initialize each time)
    int VCTolerance;
    float UVWTolerance;
    float symetryTolerance;
    double normalThreshold;
    float constraintRatio;
 
    // temporary data for fastest computation
    CSymMatrix tmpSymMatrix;
    C3DPoint resultingPt, bboxPt1, bboxPt2, inflateBBox1, inflateBBox2;
    C3DVectorD lineQv2, lineQd, lineD, lineV2;
    double invmatrix[6];
 
#ifdef MOOTOOLS_PRIVATE_DEBUG
    int positionStats[POINT2_OPTIMAL], matrixvalidcount, matrixrefusedcount, flipedge, flipcount, uncompactcount, verifycount, ignoredPoints, initFaceCount, initPointCount;
#endif
 
    static bool CheckMultiresolutionData(C3DObject *object, CTrackContractions *&trackInfo);
 
    void RemoveCost(int pointindex, CXArray<CContractionCost *, CContractionCost *>& freeContractions, unsigned int& freeContractionsNbr);
    void UpdateCost(int pointindex, CXArray<CContractionCost *, CContractionCost *>& freeContractions, unsigned char contractionOrder);
 
public:
    bool ContainSelection() const;
    bool ContainMaterialFrontier() const;
    bool ContainUVWInfo() const;
    bool ContainVCInfo() const;
    bool ContainNormalInfo() const;
 
    bool SetConstraintRatio(float constraint);
    float GetConstraintRatio();
 
    bool SetUVWTolerance(float tolerance);
    float GetUVWTolerance();
    
    bool SetVCTolerance(int tolerance);
    int GetVCTolerance();
 
    bool SetNormalThreshold(double radianThreshold);
    double GetNormalThreshold();
 
    bool SetSymetryTolerance(float tolerance);
    float GetSymetryTolerance();
    int GetSymetricPairsNumber();
 
    virtual ~C3DExtObject();
    C3DExtObject();
    C3DExtObject(C3DPointList *refpoints, C3DFaceList *reffaces, CDependentChannels *refchannels = NULL);
 
    // Initialisation of the object
    virtual void SetPointList(C3DPointList *, bool deletePrevious = true);
    virtual void SetFaceList(C3DFaceList *, bool deletePrevious = true);
    virtual void SetChannels(CDependentChannels *, bool deletePrevious = true);
 
    CTrackContractions *GetTrackInfo() { return trackInfo; }
    C3DSceneNode *GetNode() { return refnode; }
    inline CExtPointList* GetPointList() const;
    CMultiresolutionObject1 *GetMultiresolutionObject(bool& userCancel);
 
    void SetOptimizer(CSceneOptimizer& optimizer, C3DSceneNode *node);
 
    void BeginModifyInitialObject();
    void EndModifyInitialObject(bool objectChanged);
    void ResetOptimization();
 
    //////////////////////////////////////////////
    // Multiresolution data serialization methods
    //////////////////////////////////////////////
    
    // Return multiresolution data memory block after an optimization was performed (using the extended mode OPTIMIZE_EXT_MULTIRESOLUTION_DATA)
    // Memory must be release using FreeMultiresolutionData
    bool GetMultiresolutionData(void *&data, unsigned long& size);
 
    // Init a CMultiresolutionObject object from multiresolution data.
    // The method always free the provided data block that must have been prealocated using AllocMultiresolutionData
    static CMultiresolutionObject1 *SetMultiresolutionData(C3DObject *object, void *data, unsigned long size, unsigned optimizationMode = OPTIMIZE_NONE);
    // static CMultiresolutionObject2 *SetMultiresolutionData2(C3DObject *object, void *data, unsigned long size);
    static void *AllocMultiresolutionData(unsigned long size);
    static void FreeMultiresolutionData(void *data);
 
    void SetExtFlags(unsigned int flags, bool set);
    void SetExtFlag(ExtObjectFlags flag, bool set);
    bool IsExtFlagSet(ExtObjectFlags flag) const;
 
    longuint GetOptimizeMode(); //!< Returns the optimization mode which is a combination of OPTIMIZE_MODE flags
    longuint GetOptimizeExtMode(); //!< Returns the optimization mode which is a combination of OPTIMIZE_EXTMODE flags
    bool SetOptimizeMode(longuint mode, bool cleanNotNeedParameters); //!< Set optimization mode has a combination of OPTIMIZE_MODE flags
    bool SetOptimizeMode(OPTIMIZE_MODE newflag, bool set); //!< Set one OPTIMIZE_MODE flag
    bool SetOptimizeExtMode(longuint extmode, bool cleanNotNeedParameters); //!< Set optimization mode has a combination of OPTIMIZE_EXTMODE flags
    void LockInitialization(); //!< A good pratice is to lock and unlock initialization before changing one or several OPTIMIZE_MODE. Doing that initialization occurs a single time.
    void UnlockInitialization();
 
    //! @name Select Materials to optimize
    //! It is possible to exclude some materials of the optimization, inserting some MaterialID in the has map provided GetExcludedMaterials.\n
    //! If you modify the list of excluded materials, you have to invalidate optimization.
    //! @code{.cpp}
    //! SetExtFlag(EO_INIT_SELECTION_DONE, false);
    //! InvalidateOptimization();
    //! @endcode
    //! 
    //! You can also use SelectMaterial to exclude a particular material.\n
    //! If you make several call to SelectMaterial, set them between a LockInitialization / UnlockInitialization calls.
    //! 
    //! @{
    CMaterialHashMap *GetExcludedMaterials() { return &excludedMaterials; };
    bool SelectMaterial(MaterialID id, bool optimised);
    bool SelectAllMaterials();
 
    //! @}
 
    // Select the faces to be shown
    // Select the object to be displayed (original or optimised)
    // void ShowSelectedFaces(bool hideFrozenFaces);
    bool PrepareDisplayedObject(bool getOptimizedObject);
 
    void SetProgressiveThreshold(double threshold);
    double GetProgressiveThreshold() const;
 
    //! @name Get information about the object (original and optimised)
    //! @{
    int GetInitialRemovablePointsNumber() const;
    int GetInitialRemovableFacesNumber() const;
    int GetRemovedFacesNumber() const;
    int GetRemovedPointsNumber() const;
 
    //! @}
 
    int Optimize(double ratio, bool& userCancel, unsigned int ratioMode = OPTIMIZE_TO_RATIO|OPTIMIZE_TO_FACE); //!< Optimize the object at the given ratio using MRRATIO_MODE
    void InvalidateOptimization();
 
    // Helper functions
#ifdef MOOTOOLS_PRIVATE_DEBUG
    void Dump() const;
    void CostPointerChange(CContractionCost **NewPairCostPtr);
#endif
 
protected:
    // Initialisation of the object
    void CleanObject();
    void InitObject();
 
    // Select points and faces to be optimised
    void SetSelectedFaces(C3DPointList &points, C3DFaceList &faces);
    void SetSelectedPoints(C3DPointList &points, C3DFaceList& faces);
 
    // Initialisation of the process : pairs computation
    // Called each time the optimisation mode changed
    bool CleanAndPrepareObject();
    bool InitOptimization(bool minimalInitialization = true);
    bool InitSelectionMode(C3DFaceList& faces, C3DPointList& points);
    bool InitOptimizedFacesAndPoints();
    void InitPointsQuadric(C3DFaceList *faces);
    void InitConstraints(C3DFaceList *faces);
    bool InitUVWFlags();
    bool InitVCFlags();
    bool InitNormalFlags();
    bool InitSymetryMap();
 
    void InitOrderedCostList();
    void InsertCost(CContractionCost *cost, unsigned char order);
 
 
#ifdef PLY_ALPHA_FEATURE
#ifdef PLY_STRENGTH
    float strength[OPTIMIZE_STRENGTH_LAST];
 
    bool SetStrength(OPTIMIZE_STRENGTH_TYPE type, float powerStrength); // power is a value > 0.0f, 1.0f is default
    float GetStrength(OPTIMIZE_STRENGTH_TYPE type); // power is a value > 0.0f, 1.0f is default
#endif
 
#ifdef PLY_PERVERTEX
    // Confused vertex map
    unsigned int duplicatedPoints;
    int duplicatedIndex;
    C3DFaceList *confusedOriginalFaces;
    CPointGroupGraph *initConfusedMap;
    CPointGroupGraph *optimizedConfusedMap;
 
    bool InitPerVertexMap();
#endif
 
#ifdef PLY_WEIGHT
    bool InitWeightMap();
    bool ContainWeightInfo() const;
#endif
 
#ifdef PLY_FLIP_EDGES
    bool FlipEdge(CGeomInfo& info, C3DEdge& edge, const int *connectedFaces, bool track);
    unsigned int FlipEdges(unsigned int index);
    unsigned int FlipEdges(CGeomInfo& info);
#endif
 
#ifdef PLY_COMPARE_METHOD
//  void ComputePlanarAreaPairCost(CExtPointList& points, C3DFaceList& faces, CInitialCost *cost);
//  void ComputePlanarLengthPairCost(CExtPointList& points, C3DFaceList& faces, CInitialCost *cost);
//  void ComputeNewPairCost(CExtPointList& points, C3DFaceList& faces, CInitialCost *cost);
 
    int GetMethod() const;
    unsigned int ReplaceStandardPointInFaceList(unsigned int replacedindex, unsigned int newindex, CContractionCost *cost);
    void ComputeStandardPairCost(CExtPointList& points, C3DFaceList& faces, CInitialCost *cost);
    void InitStandardConstraints(C3DFaceList *faces);
    void InitStandardWeightConstraints(C3DFaceList *faces);
#endif
#endif
 
    double ComputePointCost(CSymMatrix& matrix, const C3DPoint& point);
    MOVE_FACTOR GetPointMoveFactor(const C3DPoint *point, int index, bool& online);
    CONTRACTION_PRIORITY VerifyPairQuality(CExtPointList& points, C3DFaceList& faces, CContractionCost *contration, int remainingindex, int removedindex, const C3DPoint& pos);
    bool FindBestPosOnLine(const CSymMatrix& matrix, const C3DExtPoint& pt1, const C3DExtPoint& pt2, CInitialCost *factor);
    bool InverseExist(const CSymMatrix& refmatrix, C3DPoint& point);
    void ComputePairCost(CExtPointList& points, C3DFaceList& faces, CInitialCost *cost);
    unsigned int ReplacePointInFaceList(unsigned int replacedindex, unsigned int newindex, CContractionCost * const cost);
};
 
#ifndef MOOTOOLS_NO_INLINE
inline CExtPointList *C3DExtObject::GetPointList() const
{ 
    return (CExtPointList*)points;
}
#endif
 
END_MOOTOOLS_NAMESPACE
 
#endif // !defined(AFX_3DExtObject_H__BB3D80E9_003C_11D2_A0E3_000000000000__INCLUDED_)