LAMPCAE/src/ConfigOptions/MeshConfig.cpp

#include "MeshConfig.h"
#include <QDebug>
#include "Common/DebugLogger.h"
#define MESHON  true;
#define MESHOFF false;
#define MESHIMPORT "cgns;msh;neu;stl;dat;vtk;inp;obj"
#define POINTCLOUDIMPORT "xyz;pcd;ply"
#define MESHEXPORT "vtk;neu;stl"
#define POINTCLOUDEXPORT "pcd;ply"


namespace ConfigOption
{
	MeshConfig::MeshConfig()
	{
		this->clearData();
	}

	bool MeshConfig::isMeshEnabled(MeshDataType type/*=MeshDataType::vtkMesh*/)
	{
		bool in = this->isImportMeshEnabled();
		bool ex = this->isExportMeshEnabled();

		bool gen = _enableSurfaceMesh || _enableSolidMesh || _fluidMesh;

		return in || ex || gen ;
	}
	
	bool MeshConfig::isImportMeshEnabled(MeshDataType type/*=MeshDataType::vtkMesh*/)
	{
		switch(type) {
			case MeshDataType::None :{
				return false;
			}
			case MeshDataType::vtkMesh:{
				return !_importMeshSuffix.isEmpty();
			}
			case MeshDataType::PointCloud:{
				return !_importPclSuffix.isEmpty();
			}
			default:{
				return false;
			}
		}
	}
	
	bool MeshConfig::isExportMeshEnabled(MeshDataType type/*=MeshDataType::vtkMesh*/)
	{
		switch(type) {
			case MeshDataType::None :{
				return false;
			}
			case MeshDataType::vtkMesh:{
				return !_exportMeshSuffix.isEmpty();
			}
			case MeshDataType::PointCloud:{
				return !_exportPclSuffix.isEmpty();
			}
			default:{
				return false;
			}
		}
	}

	void MeshConfig::setImportSuffix(QString s,MeshDataType type/*=MeshDataType::vtkMesh*/)
	{
//		Common::function_to_trace();
		switch(type) {
			case MeshDataType::None :{
				break;
			}
			case MeshDataType::vtkMesh:{
				_importMeshSuffix=s;
				break;
			}
			case MeshDataType::PointCloud:{
				_importPclSuffix=s;
				break;
			}
			default:{
				break;
			}
		}
	}
	
	QString MeshConfig::getImportSuffix(MeshDataType type/*=MeshDataType::vtkMesh*/)
	{
		switch(type) {
			case MeshDataType::None :{
				return "";
			}
			case MeshDataType::vtkMesh:{
				return _importMeshSuffix;
			}
			case MeshDataType::PointCloud:{
				return _importPclSuffix;
			}
			default:{
				return "";
			}
		}
	}

	void MeshConfig::setExportSuffix(QString s,MeshDataType type/*=MeshDataType::vtkMesh*/)
	{

		switch(type) {
			case MeshDataType::None :{
				break ;
			}
			case MeshDataType::vtkMesh:{
				_exportMeshSuffix=s;
				break;
			}
			case MeshDataType::PointCloud:{
				_exportPclSuffix=s;
				break;
			}
			default:{
				break;
			}
		}
	}
	 
	QString MeshConfig::getExportSuffix(MeshDataType type/*=MeshDataType::vtkMesh*/)
	{
		switch(type) {
			case MeshDataType::None :{
				return "";
				break ;
			}
			case MeshDataType::vtkMesh:{
				return _exportMeshSuffix;
			}
			case MeshDataType::PointCloud:{
				return _exportPclSuffix;
			}
			default:{
				return "";
			}
		}
	}
	
	bool MeshConfig::isMeshGenerationEnabled()
	{
		return _enableSolidMesh || _enableSurfaceMesh || _fluidMesh;
	}
	void MeshConfig::enableSurfaceMesh(bool on)
	{
		_enableSurfaceMesh = on;
	}
	bool MeshConfig::isSurfaceMeshEnabled()
	{
		return _enableSurfaceMesh;
	}
	void MeshConfig::enableSolidMesh(bool on)
	{
		_enableSolidMesh = on;
	}
	bool MeshConfig::isSolidMeshEnabled()
	{
		return _enableSolidMesh;
	}
	void MeshConfig::enableComponent(bool on)
	{
		_enableComponent = on;
	}
	bool MeshConfig::isComponentEnabled()
	{
		return _enableComponent;
	}

	void MeshConfig::clearData()
	{
		_importMeshSuffix=MESHIMPORT;
		_importPclSuffix=POINTCLOUDIMPORT;
		_exportMeshSuffix=MESHEXPORT;
		_exportPclSuffix=POINTCLOUDEXPORT;

		_enableSurfaceMesh = MESHON;
		_enableSolidMesh = MESHON;
		_enableComponent = MESHON;
		_checkMesh = MESHON;
		_fluidMesh = MESHON;
		_filterMesh = MESHON;
		_meshModeling = MESHON;
	}

	//设置检测网格质量
	void MeshConfig::setCheckMesh(bool on)
	{
		_checkMesh = on;
	}
	//获取检测网格质量状态
	bool MeshConfig::getCheckMeshEnabled()
	{
		return _checkMesh;
	}

	void MeshConfig::enableFluidMesh(bool on)
	{
		_fluidMesh = on;
	}

	bool MeshConfig::isFluidMeshEnabled()
	{
		return _fluidMesh;
	}

	void MeshConfig::enableFilterMesh(bool on)
	{
		_filterMesh = on;
	}

	bool MeshConfig::isFilterMeshEnabled()
	{
		return _filterMesh;
	}

	void MeshConfig::enableMeshModeling(bool on)
	{
		_meshModeling = on;
	}

	bool MeshConfig::isMeshModelingEnabled()
	{
		return _meshModeling;
	}

}