#ifndef __BOUNDINGBOX_HXX__
#define __BOUNDINGBOX_HXX__
+#include <INTERPKERNEL_defines.hxx>
#include <iostream>
namespace INTERP_KERNEL
* \brief Class representing the bounding box of a number of points.
*
*/
- class BoundingBox
+ class INTERPKERNEL_EXPORT BoundingBox
{
public:
namespace INTERP_KERNEL
{
template<int SPACEDIM, int MESHDIM, class ConnType, NumberingPolicy numPol, class MyMeshType>
- class ConvexIntersector: public PlanarIntersector<SPACEDIM,MESHDIM,ConnType,numPol,MyMeshType>
+ class INTERPKERNEL_EXPORT ConvexIntersector: public PlanarIntersector<SPACEDIM,MESHDIM,ConnType,numPol,MyMeshType>
{
public:
ConvexIntersector(const NormalizedUnstructuredMesh<SPACEDIM,MESHDIM,ConnType,numPol,MyMeshType>& mesh_A,
#ifndef __ABSTRACTEDGE_HXX__
#define __ABSTRACTEDGE_HXX__
+#include "Geometric2D_defines.hxx"
+
#include <set>
#include <fstream>
class ComposedEdge;
class ElementaryEdge;
- class IteratorOnComposedEdge
+ class GEOMETRIC2D_EXPORT IteratorOnComposedEdge
{
friend class AbstractEdge;
friend class ComposedEdge;
mutable ItOnFixdLev _current[MAX_INTERSCT_DEPH];
};
- class AbstractEdge
+ class GEOMETRIC2D_EXPORT AbstractEdge
{
public:
virtual ~AbstractEdge() { }
#ifndef __BOUNDS_HXX__
#define __BOUNDS_HXX__
+#include "Geometric2D_defines.hxx"
+
namespace INTERP_KERNEL
{
/*!
ON_BOUNDARY_NEG = 3
} Position;
- class Bounds
+ class GEOMETRIC2D_EXPORT Bounds
{
public:
Bounds():_xMin(0),_xMax(0.),_yMin(0.),_yMax(0.) { }
#ifndef __COMPOSEDNODE_HXX__
#define __COMPOSEDNODE_HXX__
+#include "Geometric2D_defines.hxx"
+
#include "AbstractEdge.hxx"
#include <vector>
namespace INTERP_KERNEL
{
- class ComposedEdge : public AbstractEdge
+ class GEOMETRIC2D_EXPORT ComposedEdge : public AbstractEdge
{
public:
ComposedEdge() { }
#ifndef __COMPOSEDNODEWITHIT_HXX__
#define __COMPOSEDNODEWITHIT_HXX__
+#include "Geometric2D_defines.hxx"
+
#include "ComposedEdge.hxx"
#include <vector>
namespace INTERP_KERNEL
{
- class ComposedEdgeWithIt : public ComposedEdge
+ class GEOMETRIC2D_EXPORT ComposedEdgeWithIt : public ComposedEdge
{
public:
ComposedEdgeWithIt():_iterator(this) { }
#ifndef __EDGE_HXX__
#define __EDGE_HXX__
+#include "Geometric2D_defines.hxx"
+
#include "InterpolationUtils.hxx"
#include "ComposedEdge.hxx"
#include "Bounds.hxx"
FULL_UNKNOWN = 3
} TypeOfEdgeLocInPolygon;
- class MergePoints
+ class GEOMETRIC2D_EXPORT MergePoints
{
public:
MergePoints();
unsigned _ass2End2 : 1;
};
- class IntersectElement
+ class GEOMETRIC2D_EXPORT IntersectElement
{
public:
IntersectElement(double val1, double val2, bool start1, bool end1, bool start2, bool end2, Node *node, const Edge& e1, const Edge& e2, bool keepOrder);
static const unsigned NO_LIMIT = 19;
};
- class Intersector
+ class GEOMETRIC2D_EXPORT Intersector
{
protected:
//! All non symetric methods are relative to 'e1'.
const Edge& _e2;
};
- class SameTypeIntersector : public Intersector
+ class GEOMETRIC2D_EXPORT SameTypeIntersector : public Intersector
{
protected:
SameTypeIntersector(const Edge& e1, const Edge& e2):Intersector(e1,e2) { }
bool keepOrder() const { return true; }
};
- class CrossTypeIntersector : public Intersector
+ class GEOMETRIC2D_EXPORT CrossTypeIntersector : public Intersector
{
protected:
CrossTypeIntersector(const Edge& e1, const Edge& e2, bool reverse):Intersector(e1,e2),_reverse(reverse) { }
/*!
* Deal with an oriented edge of a polygon.
*/
- class Edge
+ class GEOMETRIC2D_EXPORT Edge
{
public:
Edge(Node *start, Node *end, bool direction=true):_cnt(1),_loc(FULL_UNKNOWN) { if(direction) { _start=start; _end=end; } else { _start=end; _end=start; } _start->incrRef(); _end->incrRef(); }
#ifndef __EDGEARCCIRCLE_HXX__
#define __EDGEARCCIRCLE_HXX__
+#include "Geometric2D_defines.hxx"
+
#include "Edge.hxx"
namespace INTERP_KERNEL
{
- class ArcCArcCIntersector : public SameTypeIntersector
+ class GEOMETRIC2D_EXPORT ArcCArcCIntersector : public SameTypeIntersector
{
friend class EdgeArcCircle;
public:
//! 'delta' 'start' in ]-Pi;Pi[
static bool isAngleNotIn(double start, double delta, double angleIn);
//! for an angle 'angle' in ]-3*Pi;3*Pi[ returns angle in ]-Pi;Pi[
- static double normalizeAngle(double angle) { if(angle>M_PI) return angle-2.*M_PI; if(angle<-M_PI) return angle+2.*M_PI; return angle; }
+ static double normalizeAngle(double angle) { if(angle> M_PI) return angle-2.*M_PI; if(angle<-M_PI) return angle+2.*M_PI; return angle; }
private:
const EdgeArcCircle& getE1() const { return (const EdgeArcCircle&)_e1; }
const EdgeArcCircle& getE2() const { return (const EdgeArcCircle&)_e2; }
#ifndef __EDGEINFLIN_HXX__
#define __EDGEINFLIN_HXX__
+#include "Geometric2D_defines.hxx"
+
#include "EdgeLin.hxx"
namespace INTERP_KERNEL
{
- class EdgeInfLin : public EdgeLin
+ class GEOMETRIC2D_EXPORT EdgeInfLin : public EdgeLin
{
public:
EdgeInfLin(Node *start, Node *end):EdgeLin(start,end,true) { }
obviousCaseForCurvAbscisse(node,where,commonNode,obvious);
if(obvious)
return ;
- double ret=((*node)[!_ind]-(*_e1.getStartNode())[!_ind])/((*_e1.getEndNode())[!_ind]-(*_e1.getStartNode())[!_ind]);
+ int index = !_ind;
+ double ret=((*node)[index]-(*_e1.getStartNode())[index])/((*_e1.getEndNode())[index]-(*_e1.getStartNode())[index]);
if(ret>0. && ret <1.)
where=INSIDE;
else if(ret<0.)
#ifndef __EDGELIN_HXX__
#define __EDGELIN_HXX__
+#include "Geometric2D_defines.hxx"
+
#include "Edge.hxx"
namespace INTERP_KERNEL
{
- class SegSegIntersector : SameTypeIntersector
+ class GEOMETRIC2D_EXPORT SegSegIntersector : SameTypeIntersector
{
friend class Edge;
public:
double _matrix[4];//SPACEDIM*SPACEDIM
};
- class EdgeLin : public Edge
+ class GEOMETRIC2D_EXPORT EdgeLin : public Edge
{
friend class SegSegIntersector;
public:
#ifndef __ELEMENTARYEDGE_HXX__
#define __ELEMENTARYEDGE_HXX__
+#include "Geometric2D_defines.hxx"
+
#include "AbstractEdge.hxx"
#include "InterpolationUtils.hxx"
#include "Edge.hxx"
namespace INTERP_KERNEL
{
- class ElementaryEdge : public AbstractEdge
+ class GEOMETRIC2D_EXPORT ElementaryEdge : public AbstractEdge
{
public:
ElementaryEdge(Edge *ptr, bool direction):_direction(direction),_ptr(ptr) { }
--- /dev/null
+
+#ifndef __GEOMETRIC2D_DEFINES_HXX__
+#define __GEOMETRIC2D_DEFINES_HXX__
+
+//export symbols
+#ifdef WIN32
+# ifdef GEOMETRIC2D_EXPORTS
+# define GEOMETRIC2D_EXPORT __declspec(dllexport)
+# else
+# define GEOMETRIC2D_EXPORT __declspec(dllimport)
+# endif
+#else
+# define GEOMETRIC2D_EXPORT
+#endif
+
+#ifdef WIN32
+# include <math.h>
+# define fmax __max
+# define fmin __min
+#endif
+
+#endif //__GEOMETRIC2D_DEFINES_HXX__
\ No newline at end of file
bool Node::isEqual(const Node& other) const
{
- const unsigned SPACEDIM=2;
+ const int SPACEDIM=2;
bool ret=true;
- for(unsigned i=0;i<SPACEDIM;i++)
+ for(int i=0;i<SPACEDIM;i++)
ret&=areDoubleEquals((*this)[i],other[i]);
return ret;
}
#ifndef __NODE_HXX__
#define __NODE_HXX__
+#include "Geometric2D_defines.hxx"
+
#include "Precision.hxx"
#include <cmath>
/*!
* As nodes can be shared between edges it is dealed with ref counting.
*/
- class Node
+ class GEOMETRIC2D_EXPORT Node
{
public:
Node(double x, double y);
bool isEqualAndKeepTrack(const Node& other, std::vector<Node *>& track) const;
void dumpInXfigFile(std::ostream& stream, int resolution, const Bounds& box) const;
double distanceWithSq(const Node& other) const;
- double operator[](int i) const { return _coords[i]; }
+ double operator[]( int i) const { return _coords[i]; }
//!for tests only !
void setNewCoords(double x, double y) { _coords[0]=x; _coords[1]=y; }
static double sign(double val) { if(val>=0) return 1.; else return -1.; }
+
+#include "Geometric2D_defines.hxx"
+
namespace INTERP_KERNEL
{
- class QUADRATIC_PLANAR
+ class GEOMETRIC2D_EXPORT QUADRATIC_PLANAR
{
public:
static double _precision;
#ifndef __QUADRATICPOLYGON_HXX__
#define __QUADRATICPOLYGON_HXX__
+#include "Geometric2D_defines.hxx"
+
#include "ComposedEdge.hxx"
#include <list>
class Edge;
class MergePoints;
- class QuadraticPolygon : public ComposedEdge
+ class GEOMETRIC2D_EXPORT QuadraticPolygon : public ComposedEdge
{
public:
QuadraticPolygon() { }
class QuadraticPolygon;
template<int SPACEDIM, int MESHDIM, class ConnType, NumberingPolicy numPol, class MyMeshType>
- class Geometric2DIntersector : public PlanarIntersector<SPACEDIM,MESHDIM,ConnType,numPol,MyMeshType>
+ class INTERPKERNEL_EXPORT Geometric2DIntersector : public PlanarIntersector<SPACEDIM,MESHDIM,ConnType,numPol,MyMeshType>
{
public:
Geometric2DIntersector(const NormalizedUnstructuredMesh<SPACEDIM,MESHDIM,ConnType,numPol,MyMeshType>& mesh_A,
namespace INTERP_KERNEL
{
- namespace QUADRATIC_PLANAR
+ /*namespace QUADRATIC_PLANAR
{
extern double _precision;
- }
+ }*/
template<int SPACEDIM, int MESHDIM, class ConnType, NumberingPolicy numPol, class MyMeshType>
Geometric2DIntersector<SPACEDIM,MESHDIM,ConnType,numPol,MyMeshType>::Geometric2DIntersector(const NormalizedUnstructuredMesh<SPACEDIM,MESHDIM,ConnType,numPol,MyMeshType>& mesh_A,
--- /dev/null
+#ifndef __INTERPKERNEL_DEFINES_HXX__
+#define __INTERPKERNEL_DEFINES_HXX__
+
+//export symbols
+#ifdef WIN32
+# ifdef INTERPKERNEL_EXPORTS
+# define INTERPKERNEL_EXPORT __declspec(dllexport)
+# else
+# define INTERPKERNEL_EXPORT __declspec(dllimport)
+# endif
+#else
+# define INTERPKERNEL_EXPORT
+#endif
+
+#endif //__INTERPKERNEL_DEFINES_HXX__
std::istream& operator>>(std::istream& in, Matrix<U,type>& m);
template<class T, NumberingPolicy type=ALL_C_MODE>
- class Matrix
+ class INTERPKERNEL_EXPORT Matrix
{
class Row : public std::vector< typename std::pair<int,T> >
{
};
private:
- uint _nb_rows;
+ unsigned int _nb_rows;
T* _coeffs;
- uint* _cols;
- std::vector<uint> _ncols_offset;
+ unsigned int* _cols;
+ std::vector<unsigned int> _ncols_offset;
std::vector< Row > _auxiliary_matrix;
friend std::ostream& operator<<<>(std::ostream& in, const Matrix<T,type>& m);
friend std::istream& operator>><>(std::istream& in, Matrix<T,type>& m);
}
/*! declares a method that specifies the number of rows */
- void resize(uint nbrows)
+ void resize(unsigned int nbrows)
{
_nb_rows=nbrows;
_auxiliary_matrix.resize(nbrows);
for (int i=0; i< _nb_rows; i++)
{
output[i]=0;
- for (int j=_ncols_offset[i]; j< _ncols_offset[i+1]; j++) {
+ for (unsigned int j=_ncols_offset[i]; j< _ncols_offset[i+1]; j++) {
int icol = _cols[j];
output[i]+=input[icol]*_coeffs[j];
}
{
_ncols_offset.resize(_nb_rows+1);
_ncols_offset[0]=0;
- for (int i=0; i<_nb_rows; i++)
+ for (unsigned int i=0; i<_nb_rows; i++)
_ncols_offset[i+1]=_ncols_offset[i]+_auxiliary_matrix[i].size();
int nbcoeffs= _ncols_offset[_nb_rows];
- _cols=new uint[nbcoeffs];
+ _cols=new unsigned int[nbcoeffs];
_coeffs=new T[nbcoeffs];
- uint* cols_ptr=_cols;
+ unsigned int* cols_ptr=_cols;
T* coeffs_ptr=_coeffs;
- for (uint i=0; i<_nb_rows; i++)
+ for (unsigned int i=0; i<_nb_rows; i++)
{
- for (uint j=0; j<_auxiliary_matrix[i].size(); j++)
+ for (unsigned int j=0; j<_auxiliary_matrix[i].size(); j++)
{
*cols_ptr++ = OTT<int,type>::ind2C(_auxiliary_matrix[i][j].first);
*coeffs_ptr++ = _auxiliary_matrix[i][j].second;
/*!
* 0 <= irow < n
*/
- Row &operator [] (uint irow)
+ Row &operator [] (unsigned int irow)
{
return _auxiliary_matrix[irow];
}
namespace INTERP_KERNEL
{
template<class TrueMainInterpolator>
- class Interpolation
+ class INTERPKERNEL_EXPORT Interpolation
{
public:
Interpolation() { }
namespace INTERP_KERNEL
{
- class Interpolation2D : public InterpolationPlanar<Interpolation2D>
+ class INTERPKERNEL_EXPORT Interpolation2D : public InterpolationPlanar<Interpolation2D>
{
public:
Interpolation2D() { }
namespace INTERP_KERNEL
{
- class Interpolation3D : public Interpolation<Interpolation3D>
+ class INTERPKERNEL_EXPORT Interpolation3D : public Interpolation<Interpolation3D>
{
public:
Interpolation3D();
LOG(2, "Source mesh has " << numSrcElems << " elements and target mesh has " << numTargetElems << " elements ");
- MeshElement<ConnType>* srcElems[numSrcElems];
- MeshElement<ConnType>* targetElems[numTargetElems];
+ std::vector<MeshElement<ConnType>*> srcElems(numSrcElems);
+ std::vector<MeshElement<ConnType>*> targetElems(numTargetElems);
std::map<MeshElement<ConnType>*, int> indices;
namespace INTERP_KERNEL
{
- class Interpolation3DSurf : public InterpolationPlanar<Interpolation3DSurf>
+ class INTERPKERNEL_EXPORT Interpolation3DSurf : public InterpolationPlanar<Interpolation3DSurf>
{
public:
Interpolation3DSurf();
typedef enum {Triangulation, Convex, Geometric2D, Generic} IntersectionType;
template<class RealPlanar>
- class InterpolationPlanar : public Interpolation< InterpolationPlanar<RealPlanar> >
+ class INTERPKERNEL_EXPORT InterpolationPlanar : public Interpolation< InterpolationPlanar<RealPlanar> >
{
private:
int _printLevel;
#ifndef _INTERPOLATIONUTILS_HXX_
#define _INTERPOLATIONUTILS_HXX_
+#include <INTERPKERNEL_defines.hxx>
+
#include "NormalizedUnstructuredMesh.hxx"
#include <deque>
*
*/
template<int SPACEDIM, int MESHDIM, class ConnType, NumberingPolicy numPol, class MyMeshType>
- class IntersectorHexa : public TargetIntersector<ConnType>
+ class INTERPKERNEL_EXPORT IntersectorHexa : public TargetIntersector<ConnType>
{
public:
#include <vector>
#include <functional>
#include <map>
-#include <ext/hash_map>
+#ifdef WIN32
+# include <hash_map>
+#else
+# include <ext/hash_map>
+#endif
#include "MEDMEM_define.hxx"
#include "MEDMEM_CellModel.hxx"
+#ifndef WIN32
using __gnu_cxx::hash_map;
+#endif
namespace INTERP_KERNEL
{
* \brief Class representing a triangular face, used as key in caching hash map in IntersectorTetra.
*
*/
- class TriangleFaceKey
+ class INTERPKERNEL_EXPORT TriangleFaceKey
{
public:
{
return _hashVal;
}
+
+#ifdef WIN32
+ operator size_t () const
+ {
+ return _hashVal;
+ }
+#endif
inline void sort3Ints(int* sorted, int node1, int node2, int node3);
}
}
}
-
+#ifndef WIN32
namespace __gnu_cxx
{
+
/**
* \brief Template specialization of __gnu_cxx::hash<T> function object for use with a __gnu_cxx::hash_map
* with TriangleFaceKey as key class.
*/
template<>
class hash<INTERP_KERNEL::TriangleFaceKey>
+
{
public:
/**
}
};
}
+#else
+ struct TriangleFaceKeyComparator
+ {
+ bool operator()(const INTERP_KERNEL::TriangleFaceKey& key1,
+ const INTERP_KERNEL::TriangleFaceKey& key2 ) const
+ {
+ return key1.hashVal() < key2.hashVal();
+ }
+ };
+#endif
namespace INTERP_KERNEL
{
*
*/
template<int SPACEDIM, int MESHDIM, class ConnType, NumberingPolicy numPol, class MyMeshType>
- class IntersectorTetra : public TargetIntersector<ConnType>
+ class INTERPKERNEL_EXPORT IntersectorTetra : public TargetIntersector<ConnType>
{
public:
hash_map< int, double* > _nodes;
/// hash_map relating triangular faces to calculated volume contributions, used for caching
- hash_map< TriangleFaceKey, double > _volumes;
+ hash_map< TriangleFaceKey, double
+#ifdef WIN32
+ , hash_compare<TriangleFaceKey,TriangleFaceKeyComparator>
+#endif
+ > _volumes;
/// reference to the source mesh
const NormalizedUnstructuredMesh<SPACEDIM,MESHDIM,ConnType,numPol,MyMeshType>& _srcMesh;
assert(faceModel.getDimension() == 2);
- int faceNodes[faceModel.getNumberOfNodes()];
+ std::vector<int> faceNodes(faceModel.getNumberOfNodes());
// get the nodes of the face
for(int j = 1; j <= faceModel.getNumberOfNodes(); ++j)
#ifndef __MEDNORMALIZEDUNSTRUCTUREDMESH_HXX__
#define __MEDNORMALIZEDUNSTRUCTUREDMESH_HXX__
+#include <INTERPKERNEL_defines.hxx>
+
#include "NormalizedUnstructuredMesh.hxx"
namespace MEDMEM
}
template<int SPACEDIM,int MESHDIM>
-class MEDNormalizedUnstructuredMesh : public INTERP_KERNEL::NormalizedUnstructuredMesh<SPACEDIM,MESHDIM,int,INTERP_KERNEL::ALL_FORTRAN_MODE,MEDNormalizedUnstructuredMesh<SPACEDIM,MESHDIM> >
+class INTERPKERNEL_EXPORT MEDNormalizedUnstructuredMesh : public INTERP_KERNEL::NormalizedUnstructuredMesh<SPACEDIM,MESHDIM,int,INTERP_KERNEL::ALL_FORTRAN_MODE,MEDNormalizedUnstructuredMesh<SPACEDIM,MESHDIM> >
{
public:
MEDNormalizedUnstructuredMesh(const MEDMEM::MESH *mesh);
* easy bounding box intersection tests between MeshElements and collections of MeshElement (MeshRegions)
*/
template<class ConnType>
- class MeshElement
+ class INTERPKERNEL_EXPORT MeshElement
{
public:
* has a smaller YMIN is sorted before one with a larger YMIN.
*
*/
- class ElementBBoxOrder
+ class INTERPKERNEL_EXPORT ElementBBoxOrder
{
public :
MeshElement<ConnType>::MeshElement(const ConnType index, const NormalizedUnstructuredMesh<SPACEDIM,MESHDIM,ConnType,numPol,MyMeshType>& mesh)
: _index(index), _box(0), _number(mesh.getNumberOfNodesOfElement(index))
{
- const double* vertices[_number];
+ const double**vertices = new const double*[_number];
for(unsigned char i = 0 ; i < _number ; ++i)
vertices[i] = getCoordsOfNode(i , index, mesh);
*
*/
template<class ConnType>
- class MeshRegion
+ class INTERPKERNEL_EXPORT MeshRegion
{
public:
if(_box == 0)
{
- const double* pts[numNodes];
+ const double** pts = new const double*[numNodes];
// get coordinates of the nodes of the element
for(unsigned char i = 0 ; i < numNodes ; ++i)
class TranslationRotationMatrix;
template<int SPACEDIM, int MESHDIM, class ConnType, NumberingPolicy numPol, class MyMeshType>
- class PlanarIntersector
+ class INTERPKERNEL_EXPORT PlanarIntersector
{
public:
PlanarIntersector(double dimCaracteristic, double precision, double medianPlane, bool doRotate, int printLevel);
#include "PointLocatorAlgos.txx"
namespace INTERP_KERNEL
{
-class PointLocator
+class INTERPKERNEL_EXPORT PointLocator
{
public:
PointLocator(const MEDMEM::MESH& mesh);
{
//in 2D, nbedges==nbnodes
int nbedges=nbnodes;
- int sign[nbedges];
+ int* sign = new int[nbedges];
for (int iedge=0; iedge<nbedges; iedge++)
{
const double* A=coords+SPACEDIM*(OTT<ConnType,numPol>::ind2C(conn_elem[iedge]));
}
const MEDMEM::CELLMODEL& model=MEDMEM::CELLMODEL_Map::retrieveCellModel(elem_type);
int nbfaces = model.getNumberOfConstituents(1);
- int sign[nbfaces];
+ int* sign = new int[nbfaces];
for (int iface=0; iface<nbfaces; iface++)
{
int* connface=model.getNodesConstituent(1,iface+1);
};
template<int DIM>
- class PolygonAlgorithms
+ class INTERPKERNEL_EXPORT PolygonAlgorithms
{
public:
PolygonAlgorithms(double epsilon, double precision);
* in the bounding-box filtering process.
*/
template<class ConnType>
- class RegionNode
+ class INTERPKERNEL_EXPORT RegionNode
{
public:
namespace INTERP_KERNEL
{
-class Remapper
+class INTERPKERNEL_EXPORT Remapper
{
public:
Remapper();
#ifndef __TARGETINTERSECTOR__HXX__
#define __TARGETINTERSECTOR__HXX__
+#include <INTERPKERNEL_defines.hxx>
+
namespace INTERP_KERNEL
{
/**
* with the source elements.
*/
template<class ConnType>
- class TargetIntersector
+ class INTERPKERNEL_EXPORT TargetIntersector
{
public:
#ifndef __TETRA_AFFINE_TRANSFORM_HXX__
#define __TETRA_AFFINE_TRANSFORM_HXX__
+#include <INTERPKERNEL_defines.hxx>
+
#undef INVERSION_SELF_CHECK // debugging : check that calculated inverse is correct
namespace INTERP_KERNEL
* into the unit tetrahedron.
*
*/
- class TetraAffineTransform
+ class INTERPKERNEL_EXPORT TetraAffineTransform
{
public:
#ifndef __TRANSFORMED_TRIANGLE_HXX__
#define __TRANSFORMED_TRIANGLE_HXX__
+#include <INTERPKERNEL_defines.hxx>
+
#include <vector>
* If OPTIMIZE is defined, a large number of methods will be prefixed with inline and some optimizations concerning the tests
* with zero double products will be used.
*/
- class TransformedTriangle
+ class INTERPKERNEL_EXPORT TransformedTriangle
{
-
-
+
public:
namespace INTERP_KERNEL
{
template<int SPACEDIM, int MESHDIM, class ConnType, NumberingPolicy numPol, class MyMeshType>
- class TriangulationIntersector : public PlanarIntersector<SPACEDIM,MESHDIM,ConnType,numPol,MyMeshType>
+ class INTERPKERNEL_EXPORT TriangulationIntersector : public PlanarIntersector<SPACEDIM,MESHDIM,ConnType,numPol,MyMeshType>
{
public:
TriangulationIntersector(const NormalizedUnstructuredMesh<SPACEDIM,MESHDIM,ConnType,numPol,MyMeshType>& mesh_A,
class vtkUnstructuredGrid;
template<int MESHDIM>
-class VTKNormalizedUnstructuredMesh : public INTERP_KERNEL::NormalizedUnstructuredMesh<3,MESHDIM,vtkIdType,INTERP_KERNEL::ALL_C_MODE,VTKNormalizedUnstructuredMesh<MESHDIM> >
+class INTERPKERNEL_EXPORT VTKNormalizedUnstructuredMesh : public INTERP_KERNEL::NormalizedUnstructuredMesh<3,MESHDIM,vtkIdType,INTERP_KERNEL::ALL_C_MODE,VTKNormalizedUnstructuredMesh<MESHDIM> >
{
public:
VTKNormalizedUnstructuredMesh(vtkUnstructuredGrid *mesh);
