ForkMaster/smesh
1
0
Fork 0
mirror of https://git.salome-platform.org/gitpub/modules/smesh.git synced 2025-02-28 16:05:37 +05:00
Code Issues Packages Projects Releases Wiki Activity

First executable version

Browse Source
This commit is contained in:
abd 2006-04-17 14:23:18 +00:00
parent 4a90225df0
commit 866e747b9f
62 changed files with 247 additions and 70 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
src/StdMeshers/Makefile.in
View File

@ -50,7 +50,8 @@ EXPORT_HEADERS = \
StdMeshers_Hexa_3D.hxx \
StdMeshers_AutomaticLength.hxx \
StdMeshers_Distribution.hxx \
StdMeshers_QuadranglePreference.hxx
StdMeshers_QuadranglePreference.hxx \
SMESH_StdMeshers.hxx
EXPORT_PYSCRIPTS =

41
src/StdMeshers/SMESH_StdMeshers.hxx Executable file
View File

@ -0,0 +1,41 @@
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : SMESH_StdMeshers.hxx
// Author : Alexander BORODIN
// Module : SMESH
// $Header:
#ifndef _SMESH_StdMeshers_HXX_
#define _SMESH_StdMeshers_HXX_
#ifdef WNT
#if defined STDMESHERS_EXPORTS
#define STDMESHERS_EXPORT __declspec( dllexport )
#else
#define STDMESHERS_EXPORT __declspec( dllimport )
#endif
#else
#define STDMESHERS_EXPORT
#endif
#endif

4
src/StdMeshers/StdMeshers_Arithmetic1D.hxx
View File

@ -29,10 +29,12 @@
#ifndef _SMESH_ARITHMETIC1D_HXX_
#define _SMESH_ARITHMETIC1D_HXX_
#include "SMESH_StdMeshers.hxx"
#include "SMESH_Hypothesis.hxx"
#include "Utils_SALOME_Exception.hxx"
class StdMeshers_Arithmetic1D:
class STDMESHERS_EXPORT StdMeshers_Arithmetic1D:
public SMESH_Hypothesis
{
public:

4
src/StdMeshers/StdMeshers_AutomaticLength.hxx
View File

@ -29,6 +29,8 @@
#ifndef _SMESH_AutomaticLength_HXX_
#define _SMESH_AutomaticLength_HXX_
#include "SMESH_StdMeshers.hxx"
#include "SMESH_Hypothesis.hxx"
#include "Utils_SALOME_Exception.hxx"
@ -45,7 +47,7 @@ class TopoDS_TShape;
* S = S0 * f(L/Lmin) where f(x) = 1 + (2/Pi * 7 * atan(x/5) )
*/
class StdMeshers_AutomaticLength:public SMESH_Hypothesis
class STDMESHERS_EXPORT StdMeshers_AutomaticLength:public SMESH_Hypothesis
{
public:
StdMeshers_AutomaticLength(int hypId, int studyId, SMESH_Gen * gen);

4
src/StdMeshers/StdMeshers_Deflection1D.cxx
View File

@ -25,8 +25,6 @@
// Module : SMESH
// $Header$
using namespace std;
#include "StdMeshers_Deflection1D.hxx"
#include "utilities.h"
@ -44,6 +42,8 @@ using namespace std;
#include <gp_Lin.hxx>
#include <gp_Pnt.hxx>
using namespace std;
//=============================================================================
/*!
*

4
src/StdMeshers/StdMeshers_Deflection1D.hxx
View File

@ -28,10 +28,12 @@
#ifndef _StdMeshers_Deflection1D_HXX_
#define _StdMeshers_Deflection1D_HXX_
#include "SMESH_StdMeshers.hxx"
#include "SMESH_Hypothesis.hxx"
#include "Utils_SALOME_Exception.hxx"
class StdMeshers_Deflection1D:public SMESH_Hypothesis
class STDMESHERS_EXPORT StdMeshers_Deflection1D:public SMESH_Hypothesis
{
public:
StdMeshers_Deflection1D(int hypId, int studyId, SMESH_Gen * gen);

4
src/StdMeshers/StdMeshers_Distribution.cxx
View File

@ -53,7 +53,7 @@ bool Function::value( const double, double& f ) const
{
CASCatch_TRY
{
f = pow( 10, f );
f = pow( 10., f );
}
CASCatch_CATCH(CASCatch_Failure)
{
@ -201,7 +201,7 @@ FunctionExpr::~FunctionExpr()
{
}
Standard_Boolean FunctionExpr::Value( Standard_Real T, Standard_Real& F )
Standard_Boolean FunctionExpr::Value( const Standard_Real T, Standard_Real& F )
{
double f;
Standard_Boolean res = value( T, f );

15
src/StdMeshers/StdMeshers_Distribution.hxx
View File

@ -29,6 +29,8 @@
#ifndef _STD_MESHERS_DISTRIBUTION_HXX_
#define _STD_MESHERS_DISTRIBUTION_HXX_
#include "SMESH_StdMeshers.hxx"
#include <vector>
#include <math_Function.hxx>
#include <ExprIntrp_GenExp.hxx>
@ -36,7 +38,7 @@
#include <TColStd_Array1OfReal.hxx>
class Function
class STDMESHERS_EXPORT Function
{
public:
Function( const int );
@ -48,7 +50,7 @@ private:
int myConv;
};
class FunctionIntegral : public Function
class STDMESHERS_EXPORT FunctionIntegral : public Function
{
public:
FunctionIntegral( const Function*, const double );
@ -61,7 +63,7 @@ private:
double myStart;
};
class FunctionTable : public Function
class STDMESHERS_EXPORT FunctionTable : public Function
{
public:
FunctionTable( const std::vector<double>&, const int );
@ -84,12 +86,12 @@ private:
std::vector<double> myData;
};
class FunctionExpr : public Function, public math_Function
class STDMESHERS_EXPORT FunctionExpr : public Function, public math_Function
{
public:
FunctionExpr( const char*, const int );
virtual ~FunctionExpr();
virtual Standard_Boolean Value( Standard_Real, Standard_Real& );
virtual Standard_Boolean Value( const Standard_Real, Standard_Real& );
virtual bool value( const double, double& ) const;
virtual double integral( const double, const double ) const;
@ -99,14 +101,17 @@ private:
TColStd_Array1OfReal myValues;
};
STDMESHERS_EXPORT
bool buildDistribution( const Function& f,
const double start, const double end,
const int nbSeg,
vector<double>& data,
const double eps );
STDMESHERS_EXPORT
bool buildDistribution( const TCollection_AsciiString& f, const int conv, const double start, const double end,
const int nbSeg, vector<double>& data, const double eps );
STDMESHERS_EXPORT
bool buildDistribution( const std::vector<double>& f, const int conv, const double start, const double end,
const int nbSeg, vector<double>& data, const double eps );

3
src/StdMeshers/StdMeshers_Hexa_3D.cxx
View File

@ -27,7 +27,6 @@
// Module : SMESH
// $Header$
using namespace std;
#include "StdMeshers_Hexa_3D.hxx"
#include "StdMeshers_Quadrangle_2D.hxx"
#include "SMESH_Gen.hxx"
@ -60,6 +59,8 @@ using namespace std;
//modified by NIZNHY-PKV Wed Nov 17 15:31:58 2004 f
#include "StdMeshers_Penta_3D.hxx"
using namespace std;
static bool ComputePentahedralMesh(SMESH_Mesh & aMesh, const TopoDS_Shape & aShape);
//modified by NIZNHY-PKV Wed Nov 17 15:32:00 2004 t

4
src/StdMeshers/StdMeshers_Hexa_3D.hxx
View File

@ -30,6 +30,8 @@
#ifndef _SMESH_HEXA_3D_HXX_
#define _SMESH_HEXA_3D_HXX_
#include "SMESH_StdMeshers.hxx"
#include "SMESH_3D_Algo.hxx"
#include "SMESH_Mesh.hxx"
#include "StdMeshers_Quadrangle_2D.hxx"
@ -77,7 +79,7 @@ typedef struct cubeStruct
Point3DStruct* np; // normalised 3D coordinates
} CubeStruct;
class StdMeshers_Hexa_3D:
class STDMESHERS_EXPORT StdMeshers_Hexa_3D:
public SMESH_3D_Algo
{
public:

4
src/StdMeshers/StdMeshers_LengthFromEdges.hxx
View File

@ -30,10 +30,12 @@
#ifndef _SMESH_LENGTHFROMEDGES_HXX_
#define _SMESH_LENGTHFROMEDGES_HXX_
#include "SMESH_StdMeshers.hxx"
#include "SMESH_Hypothesis.hxx"
#include "Utils_SALOME_Exception.hxx"
class StdMeshers_LengthFromEdges:
class STDMESHERS_EXPORT StdMeshers_LengthFromEdges:
public SMESH_Hypothesis
{
public:

4
src/StdMeshers/StdMeshers_LocalLength.hxx
View File

@ -30,10 +30,12 @@
#ifndef _SMESH_LOCALLENGTH_HXX_
#define _SMESH_LOCALLENGTH_HXX_
#include "SMESH_StdMeshers.hxx"
#include "SMESH_Hypothesis.hxx"
#include "Utils_SALOME_Exception.hxx"
class StdMeshers_LocalLength:public SMESH_Hypothesis
class STDMESHERS_EXPORT StdMeshers_LocalLength:public SMESH_Hypothesis
{
public:
StdMeshers_LocalLength(int hypId, int studyId, SMESH_Gen * gen);

3
src/StdMeshers/StdMeshers_MEFISTO_2D.cxx
View File

@ -27,7 +27,6 @@
// Module : SMESH
// $Header$
using namespace std;
#include "StdMeshers_MEFISTO_2D.hxx"
#include "SMESH_Gen.hxx"
#include "SMESH_Mesh.hxx"
@ -63,6 +62,8 @@ using namespace std;
#include <TopTools_ListOfShape.hxx>
#include <string>
using namespace std;
//#include <algorithm>
//=============================================================================

4
src/StdMeshers/StdMeshers_MEFISTO_2D.hxx
View File

@ -30,6 +30,8 @@
#ifndef _StdMeshers_MEFISTO_2D_HXX_
#define _StdMeshers_MEFISTO_2D_HXX_
#include "SMESH_StdMeshers.hxx"
#include "SMESH_2D_Algo.hxx"
#include <TopoDS_Wire.hxx>
@ -45,7 +47,7 @@ class SMDS_MeshNode;
#include <map>
#include "Rn.h"
class StdMeshers_MEFISTO_2D:
class STDMESHERS_EXPORT StdMeshers_MEFISTO_2D:
public SMESH_2D_Algo
{
public:

4
src/StdMeshers/StdMeshers_MaxElementArea.hxx
View File

@ -30,10 +30,12 @@
#ifndef _SMESH_MAXELEMENTAREA_HXX_
#define _SMESH_MAXELEMENTAREA_HXX_
#include "SMESH_StdMeshers.hxx"
#include "SMESH_Hypothesis.hxx"
#include "Utils_SALOME_Exception.hxx"
class StdMeshers_MaxElementArea:public SMESH_Hypothesis
class STDMESHERS_EXPORT StdMeshers_MaxElementArea:public SMESH_Hypothesis
{
public:
StdMeshers_MaxElementArea(int hypId, int studyId, SMESH_Gen * gen);

4
src/StdMeshers/StdMeshers_MaxElementVolume.cxx
View File

@ -27,8 +27,6 @@
// Module : SMESH
// $Header$
using namespace std;
#include "StdMeshers_MaxElementVolume.hxx"
#include "SMDS_MeshElement.hxx"
@ -42,6 +40,8 @@ using namespace std;
#include <TopExp_Explorer.hxx>
#include <TopTools_IndexedMapOfShape.hxx>
using namespace std;
//=============================================================================
/*!
*

4
src/StdMeshers/StdMeshers_MaxElementVolume.hxx
View File

@ -30,10 +30,12 @@
#ifndef _SMESH_MAXELEMENTVOLUME_HXX_
#define _SMESH_MAXELEMENTVOLUME_HXX_
#include "SMESH_StdMeshers.hxx"
#include "SMESH_Hypothesis.hxx"
#include "Utils_SALOME_Exception.hxx"
class StdMeshers_MaxElementVolume:
class STDMESHERS_EXPORT StdMeshers_MaxElementVolume:
public SMESH_Hypothesis
{
public:

3
src/StdMeshers/StdMeshers_NotConformAllowed.cxx
View File

@ -26,10 +26,11 @@
// Module : SMESH
// $Header$
using namespace std;
#include "StdMeshers_NotConformAllowed.hxx"
#include "utilities.h"
using namespace std;
//=============================================================================
/*!
*

4
src/StdMeshers/StdMeshers_NotConformAllowed.hxx
View File

@ -29,10 +29,12 @@
#ifndef _StdMeshers_NotConformAllowed_HXX_
#define _StdMeshers_NotConformAllowed_HXX_
#include "SMESH_StdMeshers.hxx"
#include "SMESH_Hypothesis.hxx"
#include "Utils_SALOME_Exception.hxx"
class StdMeshers_NotConformAllowed:
class STDMESHERS_EXPORT StdMeshers_NotConformAllowed:
public SMESH_Hypothesis
{
public:

4
src/StdMeshers/StdMeshers_NumberOfSegments.hxx
View File

@ -30,6 +30,8 @@
#ifndef _SMESH_NUMBEROFSEGMENTS_HXX_
#define _SMESH_NUMBEROFSEGMENTS_HXX_
#include "SMESH_StdMeshers.hxx"
#include "SMESH_Hypothesis.hxx"
#include "Utils_SALOME_Exception.hxx"
#include <vector>
@ -40,7 +42,7 @@
* It provides parameters for subdivision an edge by various
* distribution types, considering the given number of resulting segments
*/
class StdMeshers_NumberOfSegments:
class STDMESHERS_EXPORT StdMeshers_NumberOfSegments:
public SMESH_Hypothesis
{
public:

8
src/StdMeshers/StdMeshers_Penta_3D.hxx
View File

@ -27,6 +27,8 @@
#ifndef StdMeshers_Penta_3D_HeaderFile
#define StdMeshers_Penta_3D_HeaderFile
#include "SMESH_StdMeshers.hxx"
#include <map>
////////////////////////////////////////////////////////////////////////
@ -44,7 +46,7 @@
typedef std::map< double, std::vector<const SMDS_MeshNode*> > StdMeshers_IJNodeMap;
class StdMeshers_SMESHBlock {
class STDMESHERS_EXPORT StdMeshers_SMESHBlock {
public:
//
@ -102,7 +104,7 @@ protected:
////////////////////////////////////////////////////////////////////////
#include "SMDS_MeshNode.hxx"
class StdMeshers_TNode {
class STDMESHERS_EXPORT StdMeshers_TNode {
public:
@ -160,7 +162,7 @@ private:
#include "SMESH_Mesh.hxx"
#include <TopoDS_Shape.hxx>
//
class StdMeshers_Penta_3D {
class STDMESHERS_EXPORT StdMeshers_Penta_3D {
//
public: // methods
StdMeshers_Penta_3D();

4
src/StdMeshers/StdMeshers_Propagation.hxx
View File

@ -27,10 +27,12 @@
#ifndef _SMESH_PROPAGATION_HXX_
#define _SMESH_PROPAGATION_HXX_
#include "SMESH_StdMeshers.hxx"
#include "SMESH_Hypothesis.hxx"
#include "Utils_SALOME_Exception.hxx"
class StdMeshers_Propagation:public SMESH_Hypothesis
class STDMESHERS_EXPORT StdMeshers_Propagation:public SMESH_Hypothesis
{
public:
StdMeshers_Propagation(int hypId, int studyId, SMESH_Gen * gen);

4
src/StdMeshers/StdMeshers_QuadranglePreference.hxx
View File

@ -28,6 +28,8 @@
#ifndef _StdMeshers_QuadranglePreference_HXX_
#define _StdMeshers_QuadranglePreference_HXX_
#include "SMESH_StdMeshers.hxx"
#include "SMESH_Hypothesis.hxx"
#include "Utils_SALOME_Exception.hxx"
@ -37,7 +39,7 @@
* GIBI can do it if the global number of nodes is even (DALL operator).
* See PAL10467
*/
class StdMeshers_QuadranglePreference:public SMESH_Hypothesis
class STDMESHERS_EXPORT StdMeshers_QuadranglePreference:public SMESH_Hypothesis
{
public:
StdMeshers_QuadranglePreference(int hypId, int studyId, SMESH_Gen * gen);

2
src/StdMeshers/StdMeshers_Quadrangle_2D.cxx
View File

@ -27,7 +27,6 @@
// Module : SMESH
// $Header$
using namespace std;
#include "StdMeshers_Quadrangle_2D.hxx"
#include "SMESH_Gen.hxx"
#include "SMESH_Mesh.hxx"
@ -66,6 +65,7 @@ DEFINE_ARRAY2(StdMeshers_Array2OfNode,
StdMeshers_BaseCollectionNodePtr, SMDS_MeshNodePtr)
#endif
using namespace std;
//=============================================================================
/*!

4
src/StdMeshers/StdMeshers_Quadrangle_2D.hxx
View File

@ -30,6 +30,8 @@
#ifndef _SMESH_QUADRANGLE_2D_HXX_
#define _SMESH_QUADRANGLE_2D_HXX_
#include "SMESH_StdMeshers.hxx"
#include "SMESH_2D_Algo.hxx"
#include "SMESH_Mesh.hxx"
#include "Utils_SALOME_Exception.hxx"
@ -59,7 +61,7 @@ typedef struct faceQuadStruct
UVPtStruct* uv_grid;
} FaceQuadStruct;
class StdMeshers_Quadrangle_2D:
class STDMESHERS_EXPORT StdMeshers_Quadrangle_2D:
public SMESH_2D_Algo
{
public:

4
src/StdMeshers/StdMeshers_Regular_1D.hxx
View File

@ -30,11 +30,13 @@
#ifndef _SMESH_REGULAR_1D_HXX_
#define _SMESH_REGULAR_1D_HXX_
#include "SMESH_StdMeshers.hxx"
#include "SMESH_1D_Algo.hxx"
class TopoDS_Edge;
class StdMeshers_Regular_1D:
class STDMESHERS_EXPORT StdMeshers_Regular_1D:
public SMESH_1D_Algo
{
public:

4
src/StdMeshers/StdMeshers_StartEndLength.hxx
View File

@ -28,10 +28,12 @@
#ifndef _STDMESHERS_STARTENDLENGTH_HXX_
#define _STDMESHERS_STARTENDLENGTH_HXX_
#include "SMESH_StdMeshers.hxx"
#include "SMESH_Hypothesis.hxx"
#include "Utils_SALOME_Exception.hxx"
class StdMeshers_StartEndLength:public SMESH_Hypothesis
class STDMESHERS_EXPORT StdMeshers_StartEndLength:public SMESH_Hypothesis
{
public:
StdMeshers_StartEndLength(int hypId, int studyId, SMESH_Gen * gen);

3
src/StdMeshers_I/Makefile.in
View File

@ -52,7 +52,8 @@ EXPORT_HEADERS = \
StdMeshers_MEFISTO_2D_i.hxx \
StdMeshers_Hexa_3D_i.hxx \
StdMeshers_AutomaticLength_i.hxx \
StdMeshers_QuadranglePreference_i.hxx
StdMeshers_QuadranglePreference_i.hxx \
SMESH_StdMeshers_I.hxx
# Libraries targets

41
src/StdMeshers_I/SMESH_StdMeshers_I.hxx Executable file
View File

@ -0,0 +1,41 @@
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : SMESH_StdMeshers_I.hxx
// Author : Alexander BORODIN
// Module : SMESH
// $Header:
#ifndef _SMESH_StdMeshers_I_HXX_
#define _SMESH_StdMeshers_I_HXX_
#ifdef WNT
#if defined STDMESHERS_I_EXPORTS
#define STDMESHERS_I_EXPORT __declspec( dllexport )
#else
#define STDMESHERS_I_EXPORT __declspec( dllimport )
#endif
#else
#define STDMESHERS_I_EXPORT
#endif
#endif

3
src/StdMeshers_I/StdMeshers_Arithmetic1D_i.cxx
View File

@ -26,7 +26,6 @@
// Module : SMESH
// $Header$
using namespace std;
#include "StdMeshers_Arithmetic1D_i.hxx"
#include "SMESH_Gen_i.hxx"
#include "SMESH_Gen.hxx"
@ -37,6 +36,8 @@ using namespace std;
#include <TCollection_AsciiString.hxx>
using namespace std;
//=============================================================================
/*!
* StdMeshers_Arithmetic1D_i::StdMeshers_Arithmetic1D_i

4
src/StdMeshers_I/StdMeshers_Arithmetic1D_i.hxx
View File

@ -29,6 +29,8 @@
#ifndef _SMESH_ARITHMETIC1D_I_HXX_
#define _SMESH_ARITHMETIC1D_I_HXX_
#include "SMESH_StdMeshers_I.hxx"
#include <SALOMEconfig.h>
#include CORBA_SERVER_HEADER(SMESH_BasicHypothesis)
@ -38,7 +40,7 @@
// ======================================================
// Arithmetic 1D hypothesis
// ======================================================
class StdMeshers_Arithmetic1D_i:
class STDMESHERS_I_EXPORT StdMeshers_Arithmetic1D_i:
public virtual POA_StdMeshers::StdMeshers_Arithmetic1D,
public virtual SMESH_Hypothesis_i
{

3
src/StdMeshers_I/StdMeshers_AutomaticLength_i.cxx
View File

@ -26,7 +26,6 @@
// Module : SMESH
// $Header$
using namespace std;
#include "StdMeshers_AutomaticLength_i.hxx"
#include "SMESH_Gen_i.hxx"
#include "SMESH_Gen.hxx"
@ -37,6 +36,8 @@ using namespace std;
#include <TCollection_AsciiString.hxx>
using namespace std;
//=============================================================================
/*!
* StdMeshers_AutomaticLength_i::StdMeshers_AutomaticLength_i

4
src/StdMeshers_I/StdMeshers_AutomaticLength_i.hxx
View File

@ -29,6 +29,8 @@
#ifndef _SMESH_AutomaticLength_I_HXX_
#define _SMESH_AutomaticLength_I_HXX_
#include "SMESH_StdMeshers_I.hxx"
#include <SALOMEconfig.h>
#include CORBA_SERVER_HEADER(SMESH_BasicHypothesis)
@ -41,7 +43,7 @@ class SMESH_Gen;
// 1D Hypothesis to compute segment length free of thinking
// =========================================================
class StdMeshers_AutomaticLength_i:
class STDMESHERS_I_EXPORT StdMeshers_AutomaticLength_i:
public virtual POA_StdMeshers::StdMeshers_AutomaticLength,
public virtual SMESH_Hypothesis_i
{

3
src/StdMeshers_I/StdMeshers_Deflection1D_i.cxx
View File

@ -27,7 +27,6 @@
// Module : SMESH
// $Header$
using namespace std;
#include "StdMeshers_Deflection1D_i.hxx"
#include "SMESH_Gen_i.hxx"
#include "SMESH_Gen.hxx"
@ -38,6 +37,8 @@ using namespace std;
#include <TCollection_AsciiString.hxx>
using namespace std;
//=============================================================================
/*!
* StdMeshers_Deflection1D_i::StdMeshers_Deflection1D_i

4
src/StdMeshers_I/StdMeshers_Deflection1D_i.hxx
View File

@ -30,6 +30,8 @@
#ifndef _SMESH_Deflection1D_I_HXX_
#define _SMESH_Deflection1D_I_HXX_
#include "SMESH_StdMeshers_I.hxx"
#include <SALOMEconfig.h>
#include CORBA_SERVER_HEADER(SMESH_BasicHypothesis)
@ -41,7 +43,7 @@ class SMESH_Gen;
// ======================================================
// Local Length hypothesis
// ======================================================
class StdMeshers_Deflection1D_i:
class STDMESHERS_I_EXPORT StdMeshers_Deflection1D_i:
public virtual POA_StdMeshers::StdMeshers_Deflection1D,
public virtual SMESH_Hypothesis_i
{

3
src/StdMeshers_I/StdMeshers_Hexa_3D_i.cxx
View File

@ -27,13 +27,14 @@
// Module : SMESH
// $Header$
using namespace std;
#include "StdMeshers_Hexa_3D_i.hxx"
#include "SMESH_Gen.hxx"
#include "Utils_CorbaException.hxx"
#include "utilities.h"
using namespace std;
//=============================================================================
/*!
* StdMeshers_Hexa_3D_i::StdMeshers_Hexa_3D_i

4
src/StdMeshers_I/StdMeshers_Hexa_3D_i.hxx
View File

@ -30,6 +30,8 @@
#ifndef _SMESH_HEXA_3D_I_HXX_
#define _SMESH_HEXA_3D_I_HXX_
#include "SMESH_StdMeshers_I.hxx"
#include <SALOMEconfig.h>
#include CORBA_SERVER_HEADER(SMESH_BasicHypothesis)
@ -41,7 +43,7 @@ class SMESH_Gen;
// ======================================================
// Hexaedron 3d algorithm
// ======================================================
class StdMeshers_Hexa_3D_i:
class STDMESHERS_I_EXPORT StdMeshers_Hexa_3D_i:
public virtual POA_StdMeshers::StdMeshers_Hexa_3D,
public virtual SMESH_3D_Algo_i
{

3
src/StdMeshers_I/StdMeshers_LengthFromEdges_i.cxx
View File

@ -27,13 +27,14 @@
// Module : SMESH
// $Header$
using namespace std;
#include "StdMeshers_LengthFromEdges_i.hxx"
#include "SMESH_Gen.hxx"
#include "Utils_CorbaException.hxx"
#include "utilities.h"
using namespace std;
//=============================================================================
/*!
* StdMeshers_LengthFromEdges_i::StdMeshers_LengthFromEdges_i

4
src/StdMeshers_I/StdMeshers_LengthFromEdges_i.hxx
View File

@ -30,6 +30,8 @@
#ifndef _SMESH_LENGTHFROMEDGES_I_HXX_
#define _SMESH_LENGTHFROMEDGES_I_HXX_
#include "SMESH_StdMeshers_I.hxx"
#include <SALOMEconfig.h>
#include CORBA_SERVER_HEADER(SMESH_BasicHypothesis)
@ -39,7 +41,7 @@
// ======================================================
// Length from edges hypothesis
// ======================================================
class StdMeshers_LengthFromEdges_i:
class STDMESHERS_I_EXPORT StdMeshers_LengthFromEdges_i:
public virtual POA_StdMeshers::StdMeshers_LengthFromEdges,
public virtual SMESH_Hypothesis_i
{

3
src/StdMeshers_I/StdMeshers_LocalLength_i.cxx
View File

@ -27,7 +27,6 @@
// Module : SMESH
// $Header$
using namespace std;
#include "StdMeshers_LocalLength_i.hxx"
#include "SMESH_Gen_i.hxx"
#include "SMESH_Gen.hxx"
@ -38,6 +37,8 @@ using namespace std;
#include <TCollection_AsciiString.hxx>
using namespace std;
//=============================================================================
/*!
* StdMeshers_LocalLength_i::StdMeshers_LocalLength_i

4
src/StdMeshers_I/StdMeshers_LocalLength_i.hxx
View File

@ -30,6 +30,8 @@
#ifndef _SMESH_LOCALLENGTH_I_HXX_
#define _SMESH_LOCALLENGTH_I_HXX_
#include "SMESH_StdMeshers_I.hxx"
#include <SALOMEconfig.h>
#include CORBA_SERVER_HEADER(SMESH_BasicHypothesis)
@ -41,7 +43,7 @@ class SMESH_Gen;
// ======================================================
// Local Length hypothesis
// ======================================================
class StdMeshers_LocalLength_i:
class STDMESHERS_I_EXPORT StdMeshers_LocalLength_i:
public virtual POA_StdMeshers::StdMeshers_LocalLength,
public virtual SMESH_Hypothesis_i
{

3
src/StdMeshers_I/StdMeshers_MEFISTO_2D_i.cxx
View File

@ -27,13 +27,14 @@
// Module : SMESH
// $Header$
using namespace std;
#include "StdMeshers_MEFISTO_2D_i.hxx"
#include "SMESH_Gen.hxx"
#include "Utils_CorbaException.hxx"
#include "utilities.h"
using namespace std;
//=============================================================================
/*!
* StdMeshers_MEFISTO_2D_i::StdMeshers_MEFISTO_2D_i

4
src/StdMeshers_I/StdMeshers_MEFISTO_2D_i.hxx
View File

@ -30,6 +30,8 @@
#ifndef _StdMeshers_MEFISTO_2D_I_HXX_
#define _StdMeshers_MEFISTO_2D_I_HXX_
#include "SMESH_StdMeshers_I.hxx"
#include <SALOMEconfig.h>
#include CORBA_SERVER_HEADER(SMESH_BasicHypothesis)
@ -41,7 +43,7 @@ class SMESH_Gen;
// ======================================================
// Triangle (MEFISTO) 2d algorithm
// ======================================================
class StdMeshers_MEFISTO_2D_i:
class STDMESHERS_I_EXPORT StdMeshers_MEFISTO_2D_i:
public virtual POA_StdMeshers::StdMeshers_MEFISTO_2D,
public virtual SMESH_2D_Algo_i
{

3
src/StdMeshers_I/StdMeshers_MaxElementArea_i.cxx
View File

@ -27,7 +27,6 @@
// Module : SMESH
// $Header$
using namespace std;
#include "StdMeshers_MaxElementArea_i.hxx"
#include "SMESH_Gen_i.hxx"
#include "SMESH_Gen.hxx"
@ -38,6 +37,8 @@ using namespace std;
#include <TCollection_AsciiString.hxx>
using namespace std;
//=============================================================================
/*!
* StdMeshers_MaxElementArea_i::StdMeshers_MaxElementArea_i

4
src/StdMeshers_I/StdMeshers_MaxElementArea_i.hxx
View File

@ -30,6 +30,8 @@
#ifndef _SMESH_MAXELEMENTAREA_I_HXX_
#define _SMESH_MAXELEMENTAREA_I_HXX_
#include "SMESH_StdMeshers_I.hxx"
#include <SALOMEconfig.h>
#include CORBA_SERVER_HEADER(SMESH_BasicHypothesis)
@ -39,7 +41,7 @@
// ======================================================
// Maximum Element Area hypothesis
// ======================================================
class StdMeshers_MaxElementArea_i:
class STDMESHERS_I_EXPORT StdMeshers_MaxElementArea_i:
public virtual POA_StdMeshers::StdMeshers_MaxElementArea,
public virtual SMESH_Hypothesis_i
{

3
src/StdMeshers_I/StdMeshers_MaxElementVolume_i.cxx
View File

@ -27,7 +27,6 @@
// Module : SMESH
// $Header$
using namespace std;
#include "StdMeshers_MaxElementVolume_i.hxx"
#include "SMESH_Gen_i.hxx"
#include "SMESH_Gen.hxx"
@ -38,6 +37,8 @@ using namespace std;
#include <TCollection_AsciiString.hxx>
using namespace std;
//=============================================================================
/*!
* StdMeshers_MaxElementVolume_i::StdMeshers_MaxElementVolume_i

4
src/StdMeshers_I/StdMeshers_MaxElementVolume_i.hxx
View File

@ -30,6 +30,8 @@
#ifndef _SMESH_MAXELEMENTVOLUME_I_HXX_
#define _SMESH_MAXELEMENTVOLUME_I_HXX_
#include "SMESH_StdMeshers_I.hxx"
#include <SALOMEconfig.h>
#include CORBA_SERVER_HEADER(SMESH_BasicHypothesis)
@ -39,7 +41,7 @@
// ======================================================
// Maximum Element Volume hypothesis
// ======================================================
class StdMeshers_MaxElementVolume_i:
class STDMESHERS_I_EXPORT StdMeshers_MaxElementVolume_i:
public virtual POA_StdMeshers::StdMeshers_MaxElementVolume,
public virtual SMESH_Hypothesis_i
{

4
src/StdMeshers_I/StdMeshers_NotConformAllowed_i.cxx
View File

@ -26,13 +26,13 @@
// Module : SMESH
// $Header$
using namespace std;
using namespace std;
#include "StdMeshers_NotConformAllowed_i.hxx"
#include "SMESH_Gen.hxx"
#include "utilities.h"
using namespace std;
//=============================================================================
/*!
* Constructor:

4
src/StdMeshers_I/StdMeshers_NotConformAllowed_i.hxx
View File

@ -29,6 +29,8 @@
#ifndef _StdMeshers_NotConformAllowed_I_HXX_
#define _StdMeshers_NotConformAllowed_I_HXX_
#include "SMESH_StdMeshers_I.hxx"
#include <SALOMEconfig.h>
#include CORBA_SERVER_HEADER(SMESH_BasicHypothesis)
@ -36,7 +38,7 @@
#include "StdMeshers_NotConformAllowed.hxx"
class StdMeshers_NotConformAllowed_i:
class STDMESHERS_I_EXPORT StdMeshers_NotConformAllowed_i:
public POA_StdMeshers::StdMeshers_NotConformAllowed,
public SMESH_Hypothesis_i
{

3
src/StdMeshers_I/StdMeshers_NumberOfSegments_i.cxx
View File

@ -27,7 +27,6 @@
// Module : SMESH
// $Header$
using namespace std;
#include "StdMeshers_NumberOfSegments_i.hxx"
#include "SMESH_Gen_i.hxx"
#include "SMESH_Gen.hxx"
@ -38,6 +37,8 @@ using namespace std;
#include <TCollection_AsciiString.hxx>
using namespace std;
//=============================================================================
/*!
* StdMeshers_NumberOfSegments_i::StdMeshers_NumberOfSegments_i

4
src/StdMeshers_I/StdMeshers_NumberOfSegments_i.hxx
View File

@ -30,6 +30,8 @@
#ifndef _SMESH_NUMBEROFSEGMENTS_I_HXX_
#define _SMESH_NUMBEROFSEGMENTS_I_HXX_
#include "SMESH_StdMeshers_I.hxx"
#include <SALOMEconfig.h>
#include CORBA_SERVER_HEADER(SMESH_Mesh)
#include CORBA_SERVER_HEADER(SMESH_BasicHypothesis)
@ -40,7 +42,7 @@
// ======================================================
// Number of segments hypothesis
// ======================================================
class StdMeshers_NumberOfSegments_i:
class STDMESHERS_I_EXPORT StdMeshers_NumberOfSegments_i:
public virtual POA_StdMeshers::StdMeshers_NumberOfSegments,
public virtual SMESH_Hypothesis_i
{

3
src/StdMeshers_I/StdMeshers_Propagation_i.cxx
View File

@ -24,13 +24,14 @@
// Module : SMESH
// $Header$
using namespace std;
#include "StdMeshers_Propagation_i.hxx"
#include "SMESH_Gen.hxx"
#include "Utils_CorbaException.hxx"
#include "utilities.h"
using namespace std;
//=============================================================================
/*!
* StdMeshers_Propagation_i::StdMeshers_Propagation_i

4
src/StdMeshers_I/StdMeshers_Propagation_i.hxx
View File

@ -27,6 +27,8 @@
#ifndef _SMESH_PROPAGATION_I_HXX_
#define _SMESH_PROPAGATION_I_HXX_
#include "SMESH_StdMeshers_I.hxx"
#include <SALOMEconfig.h>
#include CORBA_SERVER_HEADER(SMESH_BasicHypothesis)
@ -38,7 +40,7 @@ class SMESH_Gen;
// ======================================================
// Propagation hypothesis
// ======================================================
class StdMeshers_Propagation_i:
class STDMESHERS_I_EXPORT StdMeshers_Propagation_i:
public virtual POA_StdMeshers::StdMeshers_Propagation,
public virtual SMESH_Hypothesis_i
{

3
src/StdMeshers_I/StdMeshers_QuadranglePreference_i.cxx
View File

@ -27,7 +27,6 @@
// Module : SMESH
// $Header$
using namespace std;
#include "StdMeshers_QuadranglePreference_i.hxx"
#include "SMESH_Gen_i.hxx"
#include "SMESH_Gen.hxx"
@ -37,6 +36,8 @@ using namespace std;
#include <TCollection_AsciiString.hxx>
using namespace std;
//=============================================================================
/*!
* StdMeshers_QuadranglePreference_i::StdMeshers_QuadranglePreference_i

4
src/StdMeshers_I/StdMeshers_QuadranglePreference_i.hxx
View File

@ -30,6 +30,8 @@
#ifndef _SMESH_QuadranglePreference_I_HXX_
#define _SMESH_QuadranglePreference_I_HXX_
#include "SMESH_StdMeshers_I.hxx"
#include <SALOMEconfig.h>
#include CORBA_SERVER_HEADER(SMESH_BasicHypothesis)
@ -41,7 +43,7 @@ class SMESH_Gen;
// ======================================================
// Local Length hypothesis
// ======================================================
class StdMeshers_QuadranglePreference_i:
class STDMESHERS_I_EXPORT StdMeshers_QuadranglePreference_i:
public virtual POA_StdMeshers::StdMeshers_QuadranglePreference,
public virtual SMESH_Hypothesis_i
{

3
src/StdMeshers_I/StdMeshers_Quadrangle_2D_i.cxx
View File

@ -27,13 +27,14 @@
// Module : SMESH
// $Header$
using namespace std;
#include "StdMeshers_Quadrangle_2D_i.hxx"
#include "SMESH_Gen.hxx"
#include "Utils_CorbaException.hxx"
#include "utilities.h"
using namespace std;
//=============================================================================
/*!
* StdMeshers_Quadrangle_2D_i::StdMeshers_Quadrangle_2D_i

4
src/StdMeshers_I/StdMeshers_Quadrangle_2D_i.hxx
View File

@ -30,6 +30,8 @@
#ifndef _SMESH_QUADRANGLE_2D_I_HXX_
#define _SMESH_QUADRANGLE_2D_I_HXX_
#include "SMESH_StdMeshers_I.hxx"
#include <SALOMEconfig.h>
#include CORBA_SERVER_HEADER(SMESH_BasicHypothesis)
@ -41,7 +43,7 @@ class SMESH_Gen;
// ======================================================
// Quadrangle (Mapping) 2d algorithm
// ======================================================
class StdMeshers_Quadrangle_2D_i:
class STDMESHERS_I_EXPORT StdMeshers_Quadrangle_2D_i:
public virtual POA_StdMeshers::StdMeshers_Quadrangle_2D,
public virtual SMESH_2D_Algo_i
{

3
src/StdMeshers_I/StdMeshers_Regular_1D_i.cxx
View File

@ -27,13 +27,14 @@
// Module : SMESH
// $Header$
using namespace std;
#include "StdMeshers_Regular_1D_i.hxx"
#include "SMESH_Gen.hxx"
#include "Utils_CorbaException.hxx"
#include "utilities.h"
using namespace std;
//=============================================================================
/*!
* StdMeshers_Regular_1D_i::StdMeshers_Regular_1D_i

4
src/StdMeshers_I/StdMeshers_Regular_1D_i.hxx
View File

@ -30,6 +30,8 @@
#ifndef _SMESH_REGULAR_1D_I_HXX_
#define _SMESH_REGULAR_1D_I_HXX_
#include "SMESH_StdMeshers_I.hxx"
#include <SALOMEconfig.h>
#include CORBA_SERVER_HEADER(SMESH_BasicHypothesis)
@ -39,7 +41,7 @@
// ======================================================
// Wire Discretization 1d algorithm
// ======================================================
class StdMeshers_Regular_1D_i:
class STDMESHERS_I_EXPORT StdMeshers_Regular_1D_i:
public virtual POA_StdMeshers::StdMeshers_Regular_1D,
public virtual SMESH_1D_Algo_i
{

3
src/StdMeshers_I/StdMeshers_StartEndLength_i.cxx
View File

@ -27,7 +27,6 @@
// Module : SMESH
// $Header$
using namespace std;
#include "StdMeshers_StartEndLength_i.hxx"
#include "SMESH_Gen_i.hxx"
#include "SMESH_Gen.hxx"
@ -38,6 +37,8 @@ using namespace std;
#include <TCollection_AsciiString.hxx>
using namespace std;
//=============================================================================
/*!
* StdMeshers_StartEndLength_i::StdMeshers_StartEndLength_i

4
src/StdMeshers_I/StdMeshers_StartEndLength_i.hxx
View File

@ -30,6 +30,8 @@
#ifndef _SMESH_StartEndLength_I_HXX_
#define _SMESH_StartEndLength_I_HXX_
#include "SMESH_StdMeshers_I.hxx"
#include <SALOMEconfig.h>
#include CORBA_SERVER_HEADER(SMESH_BasicHypothesis)
@ -41,7 +43,7 @@ class SMESH_Gen;
// ======================================================
// Local Length hypothesis
// ======================================================
class StdMeshers_StartEndLength_i:
class STDMESHERS_I_EXPORT StdMeshers_StartEndLength_i:
public virtual POA_StdMeshers::StdMeshers_StartEndLength,
public virtual SMESH_Hypothesis_i
{

6
src/StdMeshers_I/StdMeshers_i.cxx
View File

@ -25,7 +25,8 @@
// Module : SMESH
// $Header$
using namespace std;
#include "SMESH_StdMeshers_I.hxx"
#include "SMESH_Gen_i.hxx"
#include "utilities.h"
@ -48,6 +49,8 @@ using namespace std;
#include "StdMeshers_Quadrangle_2D_i.hxx"
#include "StdMeshers_Hexa_3D_i.hxx"
using namespace std;
//=============================================================================
/*!
*
@ -56,6 +59,7 @@ using namespace std;
extern "C"
{
STDMESHERS_I_EXPORT
GenericHypothesisCreator_i* GetHypothesisCreator (const char* aHypName)
{
MESSAGE("Get HypothesisCreator for " << aHypName);