SceneOptimizer.h

Go to the documentation of this file.

//! @file SceneOptimizer.h
//! CSceneOptimizer handles an advanced multi-object optimization in different ways
//! 
///////////////////////////////////////////////////////////////////////////////////
 
#if !defined(AFX_PAIRPOINT_H__D524AB81_02DE_11D2_A0E7_000000000000__INCLUDED_)
#define AFX_PAIRPOINT_H__D524AB81_02DE_11D2_A0E7_000000000000__INCLUDED_
 
#ifdef _MSC_VER
#pragma once
#endif // _MSC_VER
 
#ifndef MOOTOOLS_CRUNCHERSDK
#   include "ProgressBar.h"
#endif
 
#include "PolygonCruncherInterface.h"
#include "3DFaceList.h"
#include "MultiresolutionObject.h"
#include "MRCommon.h"
 
#ifndef MOOTOOLS_NO_MR
#include "MRManager.h"
#endif
 
BEGIN_MOOTOOLS_NAMESPACE
 
#define MIN_PAIR_VALUE ((real)-3.402823466E+38)
 
// Change id when changing the order of setting flags
#define CURRENT_POLYGON_CRUNCHER_SETTINGS_VERSION 2
#define OPTIMIZE_NO_CONSTRAINT -1.0f
#define OPTIMIZE_UNDEFINED_TOLERANCE (-1.0f)
 
//! @enum OptimizerResult
//! These flags are used in CSceneOptimizer::GetScene to obtain the result optimization
typedef enum OptimizerResult
{
    ORIGINAL_OBJECT = 0x01,                 //!< Internal purpose: get the original scene (not optimized), if possible. When it's possible, don't free returned scene
    OPTIMIZED_OBJECT_FOR_DISPLAY = 0x02,    //!< Internal purpose: get a scene which has invalid face. For OpenGL display purpose only. Don't free returned scene
    OPTIMIZED_OBJECT_CLEANED = 0x04,        //!< Get a cleaned scene which can be used outside Polygon Cruncher. Use for converting or saving the optimization result. Don't free returned scene unless OPTIMIZED_COPY_SCENE is used. To be used with static optimization. Cf. #OPTIMIZATION
    OPTIMIZED_CURRENT_SCENE = 0x08,         //!< Internal purpose: returns the original scene (if no Optimize not already called) or potentialy optimized (if it has been optimized and if SCENEOPTIMIZER_INTERACTIVE_MODE is not set). Don't free returned scene unless OPTIMIZED_COPY_SCENE used.
    OPTIMIZED_MULTIRESOLUTION_SCENE = 0x10, //!< Return a scene containing multiresolution object (compute this scene if needed). Free returned scene if OPTIMIZED_COPY_SCENE set. cf. #OPTIMIZATION_DYNAMIC
    OPTIMIZED_CLEANED_MULTIRESOLUTION_SCENE = 0x20, //!< Returns a cleaned scene from the current multiresolution scene ratio. The multiresolution scene is frozen and ratio can't be changed anymore unless OPTIMIZED_COPY_SCENE is set. In that case, caller must free the returned scene if OPTIMIZED_COPY_SCENE is set.
    OPTIMIZED_APPLY_TO_SCENE = 0x40,    //!< Internal purpose: returns the scene or the multiresolution scene. Don't free the returned scene. The flag is used alone. No copy is possible.
    OPTIMIZED_COPY_SCENE = 0x100,   //!< Return a copy of the scene. To be use in special case only with OPTIMIZED_CLEANED_MULTIRESOLUTION_SCENE (duplicate memory)
    OPTIMIZED_DELETE_ORIGINAL_SCENE = 0x200, //!< Delete the original scene which is the scene provided to CSceneOptimizer::SetScene. To be used with OPTIMIZED_MULTIRESOLUTION_SCENE or OPTIMIZED_CLEANED_MULTIRESOLUTION_SCENE mode.
    OPTIMIZED_COPY_SELECTION = 0x400,   //!< Internal purpose: returns a copy of the selected node in the scene, or the whole scene if no selection exists. To be used in special case only with OPTIMIZED_CLEANED_MULTIRESOLUTION_SCENE (duplicate memory)
} OptimizerResult;
 
//! @enum SCENEOPTIMIZER_FLAGS
//! Defines the way CSceneOptimizer mode and if you'll use static / dynamic / interactive mode.
//! 
//! static: nor SCENEOPTIMIZER_TRACK_CHANGES nor SCENEOPTIMIZER_TRACK_CHANGES must be set. There no multiresolution scene.\n
//! dynamic: SCENEOPTIMIZER_TRACK_CHANGES only must be set. A multiresolution scene can be get and you can change the ratio as you want.\n
//! interactive: both SCENEOPTIMIZER_TRACK_CHANGES and SCENEOPTIMIZER_TRACK_CHANGES must be set. A multiresolution scene can be get and you can change the ratio as you want and modify the optimization mode if needed.
typedef enum SCENEOPTIMIZER_FLAGS
{
    SCENEOPTIMIZER_OPTIMIZATION_FLAGS = 0x0000FFFF, 
    //////////////////////////////
    //! @name Running flags
    //! 
    //! These flags modify the way optimizer perform optimization
    //! It could be modified whenever its needed
    //! @{
    SCENEOPTIMIZER_NONE = 0x00,
    SCENEOPTIMIZER_EXCLUDE_HIDDEN_NODES = 0x01, //!< The optimizer excludes hidden nodes
    SCENEOPTIMIZER_HIDE_FROZEN_FACES = 0x02, //!< The optimizer only displays the face to be optimized, hides the frozen faces
    SCENEOPTIMIZER_PROGRESSIVE_RATIO = 0x04, //!< When optimizing several meshes with great differences in the number of faces, that flag makes the ratio progressive depending on the number of face of each object.\n Doing that, objects with many faces are optimized more than objects with few faces using the same optimize ratio.
 
    //! @}
 
    //////////////////////////////
    //! @name Initialization flags
    //! Should be called just after the SceneOptimizer creation and before CSceneOptimizer::SetScene
    //! 
    //! The optimizer is used through an user interaction. This is the case if we need both optimization and optimization mode changes with the same provided scene.
    //! Dynamic or interactive optimization implies to keep the original faces and points somewhere and increase the memory requirements
    //! @{
    SCENEOPTIMIZER_INITIALIZATION_FLAGS = 0x00FF0000,
    SCENEOPTIMIZER_INTERACTIVE_MODE     = 0x00010000, //!< Interactive mode is to be used with SCENEOPTIMIZER_TRACK_CHANGES when you need to get a multiresolution scene and change the optimization settings. Cf. #OPTIMIZATION_INTERACTIVE
    SCENEOPTIMIZER_TRACK_CHANGES        = 0x00020000, //!< Dynamic mode which allows to produce a multiresolution scene, by keeping trace of each optimization steps. Cf. #OPTIMIZATION_DYNAMIC
 
    //! @}
 
    //////////////////////////////
    //! @name Internal flags
    //!
    //! @{
    SCENEOPTIMIZER_INTERNAL_FLAGS   = 0xFF000000,
    SCENEOPTIMIZER_DELETE_SCENE     = 0x01000000, //!< Set by CSceneOptimizer::SetScene. The optimizer will delete automatically the provided scene to be optimized. If a multiresolution scene has been required, it is always automatically deleted by the optimizer.
    SCENEOPTIMIZER_NEW_SCENE_LOADED = 0x02000000, //!< Private. A new scene has been set (using the load menu for example)
 
    //! @}
} SCENEOPTIMIZER_FLAGS;
 
class CMRWriter;
class CMRReader;
class CMRContractionsCreator;
class C3DExtObject;
class CMultiresolutionObject;
class CTrackContractions2;
class SceneOptimizerParsingInfo;
 
#ifdef MOOTOOLS_CRUNCHERSDK
#define COptimizerWnd CWnd
#endif
 
#ifdef PLY_MAGICCRUNCHER_COMP
typedef void (*OptimizerRatioCallback)(double ratio, void *data);
#endif
 
// void ShowSelectedFaces(bool showOnlySelected, C3DFaceList *faces, CMaterialHashMap& excludedMaterials);
//! @class CSceneOptimizer
//! @brief CSceneOptimizer is the main entry to optimize a scene. There are various optimization modes and which includes keeping UV or not, keeping vertex colors or not...
//! @details Object optimization mode is set using CSCeneOptimizer::SetOptimizeMode. This is usually called once before calling CSceneOptimizer::Optimize. Changing it using the same optimizer requires to use the interactive mode.
//!
//! The scene optimizer contains a set of C3DExtObject. You can convert an usual C3DScene to a scene usuable by CSceneOptimizer using C3DPolygonCruncherObjectCreator.\n
//! 
//! Optimization is a process that might requires a large amount of memory.\n
//! The scene optimizer can run itself in different mode that can be set using CSCeneOptimizer::SetFlag\n
//! 
//! * **Static:** you need to optimize the scene once at a given ratio, or several time using a decreasing ratio.\n
//! This means CSCeneOptimizer::Optimize can be called multiple time with values going from 1.0 to 0.0f.
//! * **Dynamic:** you need to change optimization ratio in any way and multiple times. Uses SCENEOPTIMIZER_TRACK_CHANGES.\n
//! A multiresolution scene is computed. You can get it using CSCeneOptimizer::GetScene(OPTIMIZED_MULTIRESOLUTION_SCENE) and then change the ratio using CSCeneOptimizer::SetMultiresolutionRatio.
//! * **Interactive:** you need to change optimization ratio in any way and multiple times, and also may changes the object optimization mode using the same input scene. Uses SCENEOPTIMIZER_TRACK_CHANGES|SCENEOPTIMIZER_INTERACTIVE_MODE.\n
//! A multiresolution scene is computed. You need to release it each time you changed object optimization mode.
//!
//! SCENEOPTIMIZER_PROGRESSIVE_RATIO can be combined with theses modes. It offers to modulate the optimize ratio between the different objects of the CSceneOptimizer depending on their number of faces.\n
//! Doing this makes objects sorted by face number. Objects with many faces are optimized first, while objects with less faces begin to be optimized as the ratio decrease.\n
//! The goal is that CSceneOptimizer produces object with similar number of faces.
//! 
//! Memory requirements is the lowest for static mode and the highest for interactive mode.\n
//! CSceneOptimizer::Optimize will compute the optimization up to the provided ratio.\n
//! SCENEOPTIMIZER_TRACK_CHANGES record this computing giving you access to multiresolution scene where you can play with the ratio as you want, through an user interaction or camera distance for example.
//! CSCeneOptimizer::GetScene gives you access to the result (static: OPTIMIZED_OBJECT_CLEANED, dynamic: OPTIMIZED_MULTIRESOLUTION_SCENE/OPTIMIZED_CLEANED_MULTIRESOLUTION_SCENE).
//! 
//! CSceneOptimizer (in dynamic/interactive mode) offers **MagicCruncher** feature, which allows computing automatically the best optimization ratio giving always appropriate results.\n
//! For example if you optimize some cubic objects which are not highly optimizable, MagicCruncher will stop optimization before object 'destruction' will occurs.\n
//! When the scene has several objects, MagicCruncher will set a different ratio, so that each object is properly optimized depending on its optimizable capabilities.\n
//!
//! MagicCruncher can take a while, and if time is important, OPTIMIZE_USE_PREDICTIVE_RATIO with CSceneOptimizer::Optimize or CSceneOptimizer::SetMultiresolutionRatio is a faster but not optimal way to compute a reasonable and not destructive high ratio.
//! CSceneOptimizer provides a default method for computing this empiric predictive ratio, but you can provide your own with CSceneOptimizer::SetPredictiveCallback
//!
class DLLFUNCTION CSceneOptimizer
{
public:
    //! @enum OptimizableObjectInfo
    //! GetOptimizableObjects gives a way to return an array of C3DExtObject or CMultiresolutionObject depending on the type of optimization.
    typedef struct OptimizableObjectInfo
    {
        CMultiresolutionObject *multires;
        C3DExtObject *object;
        C3DSceneNode *node;
    } OptimizableObjectInfo;
 
    typedef enum
    {
        APPLY_TO_SCENE = 0x0, // The whole scene is concerned by the operation
        APPLY_TO_SELECTED_NODES = 0x01, // Only nodes which have SCENE_NODE_SELECTED flags are concerned by the operation
        EXCLUDE_LOCKED_NODES = 0x02, // Only nodes which have their ratio unlocked are concerned by the operation. This flag is not always supported, as it as no meaning in most of case.
    } ApplyTo;
 
    //! @enum ModifySceneMode
    //! Advanced usage only
    typedef enum ModifySceneMode
    {
        BEGIN_SCENE_MODIFICATION = 0x01,
        CANCEL_SCENE_MODIFICATION = 0x02,
        APPLY_SCENE_MODIFICATION = 0x04, //!< The above flags are called sequencelly BEGIN_SCENE_MODIFICATION/APPLY_SCENE_MODIFICATION or CANCEL_SCENE_MODIFICATION
        VALIDATE_SCENE_MODIFICATION = 0x08, //!< This flag is used alone once the initial scene has been modified globally in a command. This flush the modified scene and reset the optimization
    } ModifySceneMode;
 
    //! @enum MagicCruncherMode
    //! Flags defining the way MagicCruncher runs.
    typedef enum MagicCruncherMode
    {
        MAGICCRUNCHER_DEFAULT = 0x00,
        MAGICCRUNCHER_INCLUDE_LOCKED_RATIO = 0x01, //!< By default mesh that are locked are excluded from the MagicCruncher process. Locking an object can be done using CMultiresolutionObject::LockRatio
        MAGICCRUNCHER_INCLUDE_HIDDEN_NODE = 0x02, //!< By default mesh that are hidden are excluded from the MagicCruncher process.
        MAGICCRUNCHER_INCLUDE_SELNODES_ONLY = 0x04, //!< MagicCrunching is applied only to node which have SCENE_NODE_IS_SELECTED. This is a way to only apply MagicCruncher on a part of the scene.
        MAGICCRUNCHER_INCLUDE_ALL_NODES = MAGICCRUNCHER_INCLUDE_LOCKED_RATIO|MAGICCRUNCHER_INCLUDE_HIDDEN_NODE,
        MAGICCRUNCHER_WHOLE_SCENE = 0x10, //!< Internal flag - MagicCrunching is applied to the whole scene instead of node by node. Other flags are ignored it this settings applied, and the optimizer mode is used (ie. SCENEOPTIMIZER_EXCLUDE_HIDDEN_NODES)
        MAGICCRUNCHER_ULTRA_MODE = 0x20, //!< Mode ultra: change the way hausdorff measure is normalized
 
        //! @name Reaching the optimal results
        //! The following flags determine how much close to the optimal object we want to be.\n
        //! We always manage to be under the provided similarity threshold, but we then continue investigation to reach the closer ratio to the optimal optimization.\n
        //! * in draft mode, we approximate we allow an error of 5% on the optimal ratio
        //! * in medium mode we approximate the optimal ratio to 2500 points
        //! * in draft mode we approximate the optimal ratio to 500 points
        //! @{
        MAGICCRUNCHER_DRAFT_DICHO = 0x100,
        MAGICCRUNCHER_MEDIUM_DICHO = 0x200, // default choice if nothing specified
        MAGICCRUNCHER_ACCURATE_DICHO = 0x400,
        MAGICCRUNCHER_DICHO_LEVEL = MAGICCRUNCHER_DRAFT_DICHO | MAGICCRUNCHER_MEDIUM_DICHO | MAGICCRUNCHER_ACCURATE_DICHO,
 
        //! @}
    } MagicCruncherMode;
 
    //! @enum MagicCruncherResult
    //! Value return in MagicCruncherParams::resultCode after performing MagicCruncher
    typedef enum MagicCruncherResult
    {
        MAGICCRUNCHER_VALID = 0x00, // The magicCruncher result is valid
        MAGICCRUNCHER_ERROR = 0x01, // The magicCruncher result is not valid
        MAGICCRUNCHER_CANCEL = 0x02, // User cancel
        MAGICCRUNCHER_TIMEOUT = 0x04, // The progress is too slow
    } MagicCruncherResult;
 
    //! @enum MagicCruncherParams
    //! Allows to have an advanced control on MagicCruncher getting a progress callback or set a time out limit.
    typedef struct MagicCruncherParams
    {
        // Input settings
        CruncherProgressCallback callback; //!< Define a progress callback
        void *callbackData; //!< Your own data provided when the progress callback is called
        unsigned int timeOut; //!< timeOut value in ms
        bool useExternalApplication; //!< Internal only
 
        // Output results
        unsigned int resultCode; // MagicCruncher result value. Cf. MagicCruncherResult 
 
        MagicCruncherParams()
        {
            callback = NULL;
            callbackData = NULL;
            timeOut = -1; // no timeout
            useExternalApplication = false; // Default built-in and fast process
 
            resultCode = MAGICCRUNCHER_VALID;
        };
    } MagicCruncherParams;
 
    typedef double (*PredictiveCallback)(C3DObject *object);
    typedef enum {
        MAGICCRUNCHER_SIMILARITY_COUNT = 4,
        MAGICCRUNCHER_DEFAULT_SIMILARITY_INDEX = 1, // 0.005
    } MagicCruncherSimilarityCount;
 
    //! @enum MultiresolutionInfo
    //! Allows to have an advanced control on MagicCruncher getting a progress callback or set a time out limit.
    typedef enum
    {
        MULTIRES_MIN_FACES = 0, //!< Get the smaller number of face of the multiresolution mesh, when SetObjectRatio = 0.0
        MULTIRES_MIN_POINTS,  //!< same for points number
        MULTIRES_MAX_FACES, //!< Get the maximal number of face of the multiresolution mesh, when SetObjectRatio = 1.0
        MULTIRES_MAX_POINTS, //!< same for points number
        MULTIRES_CUR_FACES, //!< Get the current number of face of the multiresolution mesh, corresponding to the ratio used in the last SetObjectRatio call
        MULTIRES_CUR_POINTS, //!< same for points number
    } MultiresolutionInfo;
 
    //! @enum LockRatioStatus
    //! CSceneOptimizer::GetLockedRatioStatus allows to know if none, one or all the object have been locked using CMultiresolution::LockRatio
    typedef enum LockRatioStatus
    {
        NONE_LOCKED = 0,
        SOME_LOCKED,
        ALL_LOCKED
    } LockRatioStatus;
 
protected:
    unsigned int flags;
    CruncherProgressInfo progressInfo;
    CruncherProgressCallback progressCallback;
    PredictiveCallback predictiveCallback;
    void *progressCallbackData;
    void *ompLock;
 
    C3DScene *scene; // initial face not triangulate
    C3DScene *multiResolutionScene; // multi resolution scene
 
    bool lockOptimizeReentrance, lockMagicReetrance;
    int lockInit; // lock initialization for objects (allow to prevent display of dialog box in scene optimizer)
 
    unsigned int GetSrcExtObjects(CXArray<OptimizableObjectInfo>& objects, bool onlyOptimizable = true) const; // Retrieve all optimizable objects from the original scene (don't care about active multiresolution)
    CMultiresolutionObject *GetMultiresolutionObject(C3DSceneNode *node, bool onlyOptimizable = true) const; // Return the associated multiresolution if possible. If onlyOptimizable = true, then we check CanOptimizeNode status
    C3DExtObject *GetExtObject(C3DSceneNode *node, bool checkIfOptimizable = true) const; // Return the associated ext object if possible. If checkIfOptimizable = true, then we check CanOptimizeNode status
    bool SetOptimizeModeOrExtMode(longuint mode, bool extendedMode, bool cleanNotNeedParameters);
    longuint GetOptimizeModeOrExtMode(bool extMode) const;
 
#ifndef MOOTOOLS_CRUNCHERSDK
    unsigned int MRGetLayerRange(unsigned int& minlayer, unsigned int& maxlayer);
    unsigned int MRGetLayerNodes(C3DNodeArray& nodes, unsigned int layernbr, float *bbox);
    CMRContractionsCreator *CreateMRData(CMRWriter& mrManager, C3DGeomObject *object, C3DScene *multiResolutionScene);
    static void AddTrackPoint(SceneOptimizerParsingInfo *info, int ptindex);
    static void AddFaceAndChannelTrack(SceneOptimizerParsingInfo *buildinfo, int faceindex);
    static void AddChannelTrackPoints(SceneOptimizerParsingInfo *info, int faceindex, int perVertexStartByPos = -1);
    static void AddFaceAndChannelTrackPoints(SceneOptimizerParsingInfo *info, int faceindex, int perVertexStartByIndex = -1);
    static void AddUVTrackPoint(SceneOptimizerParsingInfo *info, unsigned char channel, int uvindex);
    static void AddChangeFaceIndex(SceneOptimizerParsingInfo *buildinfo, int index, unsigned char flag);
#endif
 
    int GetMultiresolutionInfo(MultiresolutionInfo info, const CMultiresolutionObject *object) const;
    C3DScene *ComputeMultiresolutionScene();
 
public:
    // Initialisation
    CSceneOptimizer();
    virtual ~CSceneOptimizer();
 
    void Clean(); //!< Delete input scene and multiresolution scene
 
    static double ComputeProgressiveThreshold(int objectPtNbr, int maxSceneObjectPtNbr); //!< Return the progressive threshold to be used. objectPtNbr is the object point nbr, and maxSceneObjectPtNbr is the maximum object point number among all objects in the scene
    static double GetObjectRatioFromGlobalRatio(bool progressive, double globalRatio, double objectProgressiveThreshold, unsigned int ratioMode, bool& leftUnoptimized); //!< Return the progressive ratio value from the global ratio value for a given object
    static double DefaultPredictiveRatio(C3DObject * object);
    double ComputePredictiveRatio(C3DObject * object) const; //!< return an heuristic ratio to be used to optimized the mesh. Comparatively to MagicCruncher the ratio is computed in a very fast way, but it gives a mesh optimization which is not optimal.
    void SetPredictiveCallback(PredictiveCallback callback); //!< This method allows to provide you own predictive callback method when you use OPTIMIZE_USE_PREDICTIVE_RATIO. Giving an object, the callback returns the optimal ratio.
 
    C3DScene *DetachScene(); //!< The scene provided using SetScene, does not belong any more to the optimizer
    void DeleteScene(); //!< The scene provided to the optimizer is deleted (only if it has been allowed using SetScene)
    void SetScene(C3DScene& scene, bool optimizerHandleDeletion); //!< Sets the scene to optimize. If optimizerHandleDeletion = true, the optimizer will delete the scene at destroy, using DeleteScene or if another scene is provided using SetScene.
 
    //! @brief Get the optimization result.
    //! @details CLEAN modes removes any invalid faces that are progressively set while optimization occurs.
    //! When you ask for a cleaned scene you cannot used anymore CSceneOptimizer::Optimize or CSceneOptimize::SetMultiresolutionRatio, unless you use OPTIMIZED_COPY_SCENE.\n
    //! In that case you'll have to delete the return scene when no longer need it.\n\n
    //! When using OPTIMIZED_MULTIRESOLUTION_SCENE or OPTIMIZED_CLEANED_MULTIRESOLUTION_SCENE, the scene return has the CMultiresolutionScene class.\n
    //! You can traverse the scene and set the ratio for each objects independently.\n\n
    //! When using dynamic mode, you can delete the source scene using DeleteScene() once you have the multiresolution scene to reduce memory needs. You can also GetScene do this using OPTIMIZED_MULTIRESOLUTION_SCENE|OPTIMIZED_DELETE_ORIGINAL_SCENE.
    //! If you have set SCENEOPTIMIZER_INTERACTIVE_MODE, the source scene must be kept as a new optimization computation (CsceneOptimizer::Optimize) each time you modify SetOptimizeMode.
    C3DScene *GetScene(unsigned int optimizerResultFlags);
 
#ifndef MOOTOOLS_NO_MR
#ifndef MOOTOOLS_CRUNCHERSDK
    void MRCleanSceneBeforeOptimization(C3DScene * scene, unsigned int optimizationMode);
    bool SaveMR(const CXString& mrFullPath, unsigned int shellFileClass, CMRWriter& mrManager, bool saveInDifferentLayers = false); // Save MR Data process
#endif
    C3DScene *LoadMRFile(const CXString& filename, bool addToCurrentScene, unsigned int mrflags = MRMGR_NONE, const CXString& mrZipFile = CXString(), const CXString& extractDirectory = CXString(), CMRReader *customMgr = NULL); // Load MR Data process. The returned scene belong to the optimizer. Flags is one of the MRMGR_FLAGS loading flags
#endif
 
    static double GetDefaultSimilarity(); //!< Return a default similarity value that can be used as default for MagicCruncher
    static int GetClosestSimilarityIndex(double similarity);  //!< Return the closest index in the GetDefaultSimilarityValues array based on the provide similarity value
    static const double *GetDefaultSimilarityValues(int& size); //!< Return #size default values to be use with MagicCruncherOptimization. These default are ordered from the lowest similarities to the highest one.
    static double MagicCruncherOptimization(const CXArray<CMultiresolutionObject*> *objects, unsigned int magicCruncherMode, double hausdorffThreshold, MagicCruncherParams *params = NULL); //!< This method can be called when we only have CMultiresolutionObject* objets without the CSceneOptimizer that allow to compute it
    double MagicCruncherOptimization(unsigned int magicMode, double similarityThreshold, ApplyTo applyTo = APPLY_TO_SCENE, MagicCruncherParams* params = NULL); //!< Find optimal optimization with an optimal ratio for each objects, return the global ratio (1.0 is nothing done). magicMode is a combination of MagicCruncherMode flags
 
    //! @name Working with the computed multiresolution scene
    //! @details When using SCENEOPTIMIZER_TRACK_CHANGES, CSceneOptimizer::Optimize pre-compute optimization and allows dynamic access to optimization through a multiresolution scene (CMultiresolutionScene)
    //! These methods give access to the multiresolution scene which contains CMultiresolutionObject\n
    //! The node ID are kept between the original scene and the multiresolution scene. This property can be used for specific purpose.\n
    //! @{
    void CleanMultiresolutionScene(); //!< Delete an already computed multiresolution scene. This is automatically called on destroy but might be required on interactive optimization. Cf. usage in #OPTIMIZATION_INTERACTIVE
    bool HasMultiresolutionScene() const; //!< Return true if a multiresolution scene is available (this occurs if GetScene(OPTIMIZED_MULTIRESOLUTION_SCENE) has been called.
    //! @brief Modify the ratio of the multiresolution scene (CMultiresolutionScene) by calling each CMultiresolutionObject::SetObjectRatio independently.
    //! @param ratio Define the target ratio if OPTIMIZE_TO_RATIO set.
    //! @param requiredElement If OPTIMIZE_TO_NBR set, requiredElement is the target number of points (OPTIMIZE_TO_POINT) or faces (OPTIMIZE_TO_FACE).
    //! @param mode Can be OPTIMIZE_TO_POINT|OPTIMIZE_TO_NBR, OPTIMIZE_TO_FACE|OPTIMIZE_TO_NBR, OPTIMIZE_TO_POINT|OPTIMIZE_TO_RATIO, OPTIMIZE_TO_FACE|OPTIMIZE_TO_RATIO
    //! @param applyTo Could be APPLY_TO_SCENE or APPLY_TO_SELECTED_NODES. Object which ratio is locked is not taken into account, unless OPTIMIZE_UNLOCK_RATIO is defined.
    bool SetMultiresolutionRatio(double ratio, int requiredElement, unsigned int mode, ApplyTo applyTo = APPLY_TO_SCENE);
 
    //! @}
 
    bool OptimizerHandleDeletion() const { return IsFlagSet(SCENEOPTIMIZER_DELETE_SCENE); }
    bool IsNewScene() const { return IsFlagSet(SCENEOPTIMIZER_NEW_SCENE_LOADED); }
 
    bool HasSameRatio(ApplyTo applyTo) const; //!< Return true if all the nodes concerned by applyTo has same optimization ratio. return true, if no multiresolution scene were computed
    double GetMaxThresholdFromSelection(ApplyTo mode) const;
    bool IsProgressiveRatioEnabled() const; //!< Return true if SCENEOPTIMIZER_PROGRESSIVE_RATIO is set and if there is more than one node to optimize
 
    void ModifyScene(ModifySceneMode mode); //!< Advanced usage only. Provide a way to modify the internal scene for performing some changes on it (point welding, collapsing...)
 
    //! Optimize compute optimization up to ratio
    //! * If SCENEOPTIMIZER_TRACK_CHANGES is set, it computes a multiresolution scene up to the ratio provided.\n
    //! Using GetScene(OPTIMIZED_MULTIRESOLUTION_SCENE), allows to play dynamically with the optimization ratio, using the CMultiresolutionObject
    //! * If SCENEOPTIMIZER_TRACK_CHANGES is false then Optimize should be called any time you need to get an optimization of the scene.
    //! It is slower as a change of ratio recomputes all but it requires less memory.
    //! @note in any case if SCENEOPTIMIZER_INTERACTIVE_MODE is not defined, Optimize must be called only with decreasing ratio.
    int Optimize(double ratio, bool& userCancel, unsigned int ratioMode = OPTIMIZE_TO_RATIO|OPTIMIZE_TO_FACE);
    double GetObjectRatioFromGlobalRatio(double globalRatio, double objectProgressiveThreshold, unsigned int ratioMode, bool& leftUnoptimized) const; //!< Returns the progressive ratio value from the global ratio value for a given object. leftUnoptimized is return to true, if the ratio is above the thresholdRatio in case of progressive optimization
 
    ///////////////////////////
    // Scene optimizer flags (among SCENEOPTIMIZER_OPTIMIZATION_FLAGS flags)
    inline bool IsFlagSet(SCENEOPTIMIZER_FLAGS flag) const
    {
        return ((flags & flag) == flag) ? true : false;
    }
 
    unsigned int SaveFlags() const // Returns only SCENEOPTIMIZER_OPTIMIZATION_FLAGS, for saving scene optimizer mode
    {
        return (flags & SCENEOPTIMIZER_OPTIMIZATION_FLAGS);
    };
 
    void LoadFlags(unsigned int flags) // Returns only SCENEOPTIMIZER_OPTIMIZATION_FLAGS, for restoring a previously save scene optimizer mode
    {
        SetFlags(flags & SCENEOPTIMIZER_OPTIMIZATION_FLAGS, true);
    };
 
    void SetFlags(unsigned int newflags, bool set);
    void SetFlag(SCENEOPTIMIZER_FLAGS flag, bool set);
    
    ///////////////////////////
    //! @name Object optimization mode
    //! It's better to use LockInitialization, modify the optimization mode in the way you want then called UnlockInitialization to take avantage of multithreading.
    //! @{
    longuint GetOptimizeMode() const; //!< Return combination of OPTIMIZE_MODE used by the optimizer. As each object might have a different mode (if C3DExtObject::SetOptimizeMode has been called independently), it returns a combination of all C3DExtObject::GetOptimizeMode object flags.
    longuint GetOptimizeExtMode() const; //!< Return combination of OPTIMIZE_EXTMODE. Same remark than above.
    bool SetOptimizeExtMode(longuint optimizeExtModeFlags, bool cleanNotNeedParameters); //!< Set one or more OPTIMIZE_EXTMODE flags of each scene optimizer objects
    bool SetOptimizeMode(longuint optimizeModeFlags, bool cleanNotNeedParameters); //!< Set one or more OPTIMIZE_MODE flags of each scene optimizer objects
    bool SetOptimizeMode(C3DExtObject *object, OPTIMIZE_MODE newflag, bool set); //!< Modify one OPTIMIZE_MODE flag one of each scene optimizer objects
    // void ShowSelectedFaces(bool hideFrozenFaces);
    void LockInitialization(); //!< As changing the object's optimisation mode can lead to a reset, LockInitialization and UnlockInitialization can be used to postpone this reset, reduce the calculations required and parallelise the process.
    void UnlockInitialization(); //!< Unlock a previously locked initalization.
    
    //! @}
 
    int LockOptimizeRatio(bool lock, ApplyTo mode = APPLY_TO_SCENE); //!< Prevent multiresolution object ratio to be changed, by calling appropriate CMultiresolutionObject::LockRatio methods. Return the number of object which status changed (were unlocked, get lock or were locked, get unlocked).  applyTo could be APPLY_TO_SCENE or APPLY_TO_SELECTED_NODES
 
#ifdef MOOTOOLS_PRODUCT_BUILD
    unsigned int GetFrozenObjects(CXArray<OptimizableObjectInfo>& objects, unsigned int applyToMode) const;
    int GetFrozenInfo(MultiresolutionInfo info, ApplyTo applyTo) const;
    LockRatioStatus HasFrozenMultiresolutionObjects(ApplyTo mode = APPLY_TO_SCENE) const; //!< Return NONE_LOCKED, SOME_LOCKED, ALL_LOCKED were LOCKED means FROZEN
    int UnfreezeMultiresolutionObjects(ApplyTo mode = APPLY_TO_SCENE);
#endif
 
    //! @brief Node locking status
    //! @details When the multiresolution scene has been computed, this is possible to froze a multiresolution object, using CMultiresolution::LockRatio
    //! The following methods, check if none/some/all object are locked
    LockRatioStatus GetLockedRatioStatus(ApplyTo mode = APPLY_TO_SCENE) const;
    //bool HasLockedRatio() const; // Determine if one of the multiresolution SetConstraintRatio
 
    bool SetConstraintRatio(float constraint); //!< This can be use to limit the optimization to a given constraint ratio. This is mainly for internal purpose
    float GetConstraintRatio() const; //!< Retrieved the ratio set using 
 
    bool SetUVWTolerance(float tolerance); //!< Set the UVW tolerance for all scene optimizer objects
    float GetUVWTolerance() const;  //!< Set the UVW tolerance for all scene optimizer objects
    bool SetVCTolerance(int tolerance);  //!< Set the UVW tolerance for all scene optimizer objects
    int GetVCTolerance() const;  //!< Set the UVW tolerance for all scene optimizer objects
    bool SetNormalThreshold(double radianThreshold);  //!< Set the UVW tolerance for all scene optimizer objects
    double GetNormalThreshold() const;  //!< Set the UVW tolerance for all scene optimizer objects
    bool SetSymetryTolerance(float tolerance);  //!< Set the UVW tolerance for all scene optimizer objects
    float GetSymetryTolerance() const;  //!< Set the UVW tolerance for all scene optimizer objects
    bool ContainMaterialFrontier();  //!< Returns true if at least one object has a material frontier. A material frontier means that one point of the object is connected to faces which have a different material.\n This allows to know if setting one of the OPTIMIZE_MATERIAL_FRONTIER_MASK optimization mode has some meaning.
    bool ContainUVWInfo(C3DScene *scene = NULL); //!< Returns true if at least one of the object have UVW (UVW_CHANNEL). Check on the provided scene, otherwise check in the optimizer attached scene.\n This allows to know if setting one of the OPTIMIZE_UV_MASK optimization mode has some meaning.
    bool ContainVCInfo(C3DScene* scene = NULL);  //!< Returns true if at least one of the object have verter colors (VC_CHANNEL). The check is performed on the provided scene, otherwise check is done on scene optimizer.\n This allows to know if setting one of the OPTIMIZE_VC_MASK optimization mode has some meaning.
    bool ContainNormalInfo(C3DScene* scene = NULL);  //!< Returns true if at least one of the object have specified normals (SPEC_NORMAL_CHANNEL). The check is performed on the provided scene, otherwise check is done on scene optimizer.\n This allows to know if setting one of the OPTIMIZE_NORMALS_MASK optimization mode has some meaning.
 
    int GetSymetricPairsNumber() const; //!< Return the number of symetric points found, which is the sum of symetrical points of each optimizer objects.
 
    // Materials optimisations
    bool SelectMaterial(C3DExtObject *object, MaterialID id, bool optimised);
 
    // Optimisation information
    bool HasLockedNodes() const;
    unsigned int GetOptimizableObjects(CXArray<OptimizableObjectInfo>& objects, unsigned int applyToMode, bool onlyOptimizable = true) const; //!< Get ExtObject or CMultiresolutionObject from the scene (optimizable scene or multiresolution scene). 
    bool CanOptimizeNode(const C3DSceneNode *node) const;
 
    ApplyTo GetApplyToMode() const; //!< return APPLY_TO_SCENE if none or all optimizable meshes are selected, APPLY_TO_SELECTION otherwise.
 
    //! @name Get point / face number information
    //! Retrieve information on the removable (optimizable) point / face number and on the optimized point / face number.
    //! @note
    //! Depending on SetOptimizeMode not all the object point are removable. For example OPTIMIZE_EXCLUDE_BORDER will exclude some points from the optimization process.\n
    //! The optimization ratio use the removable point / face to compute the optimized number of points.
    //! 
    //! @{
    int GetMultiresolutionInfo(MultiresolutionInfo info, ApplyTo applyMode = APPLY_TO_SCENE) const; //!< Get information on the number of optimized / optimizable / total points or faces number for the whole scene or the selection. applyTo could be any values
    int GetInitialRemovableElementNumber(bool faceNbr) const; //!< Return number of removable faces (or points if !faceNbr)
    int GetRemovedElementNumber(bool faceNbr) const; //!< Return number of removed faces (or points if !faceNbr)
 
    int GetInitialRemovableFacesNumber() const; //!< Returns the number of faces that can be removed.
    int GetInitialRemovablePointsNumber() const;  //!< Returns the number of points that can be removed
    int GetRemovedFacesNumber() const; //!< Returns the number of faces that have been removed
    int GetRemovedPointsNumber() const; //!< Returns the number of points that have been removed
 
    //! @}
 
    //! @name Callbacks
    //! These method give a way to provide feedback to an user through a dialog box 
    //! @{
    void SetProgressCallback(CruncherProgressCallback callback, void *data); //!< Set a progress callback if you want to give some feedback to an user
    void CancelProgress(); //!< Force progress to cancel
    bool CheckCancelButton();
    void SetMeshPos(unsigned int curmesh);
 
    void AddProgressPos(unsigned int value);
    void SetProgressPos(unsigned int pos);
 
    void SetProgressMeshRange(unsigned int meshnbr);
    void SetProgressRange(unsigned int min, unsigned int max);
    void AddProgressRange(unsigned int value);
 
    void SetProgressStatus(const CXString& status);
    void ShowInformation(bool show, int textid = -1);
 
    //! @}
 
    //! @name Multithreading
    //! These methods controls the number of thread allowed to the CSceneOptimizer.\n
    //! This is equivalent to calling OMPSetMaxThreadCount / OMPGetMaxThreadCount directly.
    //! @{
    void SetMaxThreadCount(unsigned int count); //!< Set the maximum parallel threads for task that are computed in parallel (ie MagicCruncher features)
    unsigned int GetMaxThreadCount() const; //!< Get the maximum parallel threads
 
    //! @}
 
#ifdef PLY_ALPHA_FEATURE
    bool SetStrength(OPTIMIZE_STRENGTH_TYPE type, float powerStrength); // power is a value > 0.0f, 1.0f is default
    float GetStrength(OPTIMIZE_STRENGTH_TYPE type) const; // power is a value > 0.0f, 1.0f is default
 
#ifdef PLY_WEIGHT
    bool ContainWeightInfo();
#endif
#endif
 
#ifdef _DEBUG
    void DumpOptimizationMode() const;
#endif
 
#ifndef MOOTOOLS_CRUNCHERSDK
    // UI
protected:
    unsigned int infoCount, progressCount;
    CWnd *pOptimizerWnd;
    CInfoBox infoDlg;
    CProgressDlg progressDlg;
 
public:
    void SetOptimizerWnd(CWnd *pOptimizerWnd);
    CWnd *GetOptimizerWnd() { return pOptimizerWnd; };
    static bool DefaultProgressCallback(unsigned int flags, const CruncherProgressInfo& info, void *data);
 
#ifdef PLY_MAGICCRUNCHER_COMP
    protected:
        OptimizerRatioCallback ratioCallback;
        void *ratioCallbackData;
        C3DScene *switchedMultiResolutionScene; // multi resolution scene
 
    public:
        void SetRatioCallback(OptimizerRatioCallback callback, void *data);
        void SwitchMultiresolutionScene(C3DScene *scene);
        double MagicCruncherGlobalOptimizationWithExternalApp(double similarityThreshold, bool accurate, double& resultingHausdorff); // Find optimal optimization globally with a single ratio, return the ratio (1.0 is nothing done)
        C3DScene *GethausdorffMeasure(bool sceneReference);
#endif
#elif defined(PLY_MAGICCRUNCHER_COMP)
    #pragma error("PLY_MAGICCRUNCHER_COMP should not be defined")
#endif
};
 
END_MOOTOOLS_NAMESPACE
 
#endif // !defined(AFX_PAIRPOINT_H__D524AB81_02DE_11D2_A0E7_000000000000__INCLUDED_)