//-----------------------------------------------------------------------------
double IntervalCell::volume(const MeshEntity& interval) const
{
// Check that we get an interval
if (interval.dim() != 1)
{
dolfin_error("IntervalCell.cpp",
"compute volume (length) of interval cell",
"Illegal mesh entity, not an interval");
}
// Get mesh geometry
const MeshGeometry& geometry = interval.mesh().geometry();
// Get the coordinates of the two vertices
const unsigned int* vertices = interval.entities(0);
const double* x0 = geometry.x(vertices[0]);
const double* x1 = geometry.x(vertices[1]);
// Compute length of interval (line segment)
double sum = 0.0;
for (std::size_t i = 0; i < geometry.dim(); ++i)
{
const double dx = x1[i] - x0[i];
sum += dx*dx;
}
return std::sqrt(sum);
}
void operator() ( MeshEntity& e ) const
{
if ( M_policy (e.markerID(), M_watermark) )
{
e.replaceFlag ( M_flagPolicy ( e.flag(), M_flagToSet ) );
}
}
void operator() ( MeshEntity& e ) const
{
if ( std::binary_search ( M_watermarks.begin(), M_watermarks.end(), e.markerID() ) )
{
e.replaceFlag ( M_flagPolicy ( e.flag(), M_flagToSet ) );
}
}
//-----------------------------------------------------------------------------
double QuadrilateralCell::volume(const MeshEntity& cell) const
{
if (cell.dim() != 2)
{
dolfin_error("QuadrilateralCell.cpp",
"compute volume (area) of cell",
"Illegal mesh entity");
}
// Get mesh geometry
const MeshGeometry& geometry = cell.mesh().geometry();
// Get the coordinates of the four vertices
const unsigned int* vertices = cell.entities(0);
const Point p0 = geometry.point(vertices[0]);
const Point p1 = geometry.point(vertices[1]);
const Point p2 = geometry.point(vertices[2]);
const Point p3 = geometry.point(vertices[3]);
if (geometry.dim() == 2)
{
const Point c = (p0 - p2).cross(p1 - p3);
return 0.5 * c.norm();
}
else
dolfin_error("QuadrilateralCell.cpp",
"compute volume of quadrilateral",
"Only know how to compute volume in R^2");
// FIXME: could work in R^3 but need to check co-planarity
return 0.0;
}
//-----------------------------------------------------------------------------
double HexahedronCell::volume(const MeshEntity& cell) const
{
if (cell.dim() != 2)
{
dolfin_error("HexahedronCell.cpp",
"compute volume (area) of cell",
"Illegal mesh entity");
}
// Get mesh geometry
const MeshGeometry& geometry = cell.mesh().geometry();
// Get the coordinates of the four vertices
const unsigned int* vertices = cell.entities(0);
const Point p0 = geometry.point(vertices[0]);
const Point p1 = geometry.point(vertices[1]);
const Point p2 = geometry.point(vertices[2]);
const Point p3 = geometry.point(vertices[3]);
const Point p4 = geometry.point(vertices[4]);
const Point p5 = geometry.point(vertices[5]);
dolfin_error("HexahedronCell.cpp",
"compute volume of hexahedron",
"Not implemented");
return 0.0;
}
void operator() (MeshEntity& e) const
{
std::pair<flag_Type, bool> tmp = this->findFlag ( e.markerID() );
if ( tmp.second )
{
e.replaceFlag ( M_flagPolicy ( e.flag(), tmp.first ) );
}
}
//-----------------------------------------------------------------------------
void MeshPartitioning::build_mesh_domains(Mesh& mesh,
const LocalMeshData& local_data)
{
// Local domain data
const std::map<std::size_t, std::vector<
std::pair<std::pair<std::size_t, std::size_t>, std::size_t> > >&
domain_data = local_data.domain_data;
if (domain_data.empty())
return;
// Initialse mesh domains
const std::size_t D = mesh.topology().dim();
mesh.domains().init(D);
std::map<std::size_t, std::vector<
std::pair<std::pair<std::size_t, std::size_t>,
std::size_t> > >::const_iterator dim_data;
for (dim_data = domain_data.begin(); dim_data != domain_data.end();
++dim_data)
{
// Get mesh value collection used for marking
const std::size_t dim = dim_data->first;
// Initialise mesh
mesh.init(dim);
// Create empty MeshValueCollection
MeshValueCollection<std::size_t> mvc(mesh, dim);
// Get domain data
const std::vector<std::pair<std::pair<std::size_t, std::size_t>,
std::size_t> >& local_value_data
= dim_data->second;
// Build mesh value vollection
build_mesh_value_collection(mesh, local_value_data, mvc);
// Get data from mesh value collection
const std::map<std::pair<std::size_t, std::size_t>, std::size_t>& values
= mvc.values();
// Get map from mes domains
std::map<std::size_t, std::size_t>& markers = mesh.domains().markers(dim);
std::map<std::pair<std::size_t, std::size_t>,
std::size_t>::const_iterator it;
for (it = values.begin(); it != values.end(); ++it)
{
const std::size_t cell_index = it->first.first;
const std::size_t local_entity_index = it->first.second;
const Cell cell(mesh, cell_index);
const MeshEntity e(mesh, dim, cell.entities(dim)[local_entity_index]);
markers[e.index()] = it->second;
}
}
}
const_iterator end(const MeshEntity& e) const
{
assert(e.getDimension() <= dimension);
assert(e.getDimension() < dimension || e.getIndex() == 0);
const typename std::map<MeshEntity, qpoints_t>::const_iterator qIter = quadratureMap.find(e);
assert(qIter != quadratureMap.end());
return qIter->second.end();
}
void setQuadrature(const MeshEntity& e, const std::map<vertex<dimension>, double> weights)
{
assert(e.getDimension() <= dimension);
// We only have one cell per cell, so if we have quadrature for MeshEntity(dimension, k)
// for k>0, something is wrong
assert(e.getDimension() < dimension || e.getIndex() == 0);
quadratureMap[e] = qpoints_t(weights.begin(), weights.end());
}
//-----------------------------------------------------------------------------
bool CollisionDetection::collides_interval_point(const MeshEntity& entity,
const Point& point)
{
// Get coordinates
const MeshGeometry& geometry = entity.mesh().geometry();
const unsigned int* vertices = entity.entities(0);
return collides_interval_point(geometry.point(vertices[0]),
geometry.point(vertices[1]),
point);
}
//-----------------------------------------------------------------------------
// High-level collision detection predicates
//-----------------------------------------------------------------------------
bool CollisionPredicates::collides(const MeshEntity& entity,
const Point& point)
{
// Intersection is only implemented for simplex meshes
if (!entity.mesh().type().is_simplex())
{
dolfin_error("Cell.cpp",
"intersect cell and point",
"Intersection is only implemented for simplex meshes");
}
// Get data
const MeshGeometry& g = entity.mesh().geometry();
const unsigned int* v = entity.entities(0);
const std::size_t tdim = entity.mesh().topology().dim();
const std::size_t gdim = entity.mesh().geometry().dim();
// Pick correct specialized implementation
if (tdim == 1 && gdim == 1)
return collides_segment_point_1d(g.point(v[0])[0], g.point(v[1])[0], point[0]);
if (tdim == 1 && gdim == 2)
return collides_segment_point_2d(g.point(v[0]), g.point(v[1]), point);
if (tdim == 1 && gdim == 3)
return collides_segment_point_3d(g.point(v[0]), g.point(v[1]), point);
if (tdim == 2 && gdim == 2)
return collides_triangle_point_2d(g.point(v[0]),
g.point(v[1]),
g.point(v[2]),
point);
if (tdim == 2 && gdim == 3)
return collides_triangle_point_3d(g.point(v[0]),
g.point(v[1]),
g.point(v[2]),
point);
if (tdim == 3)
return collides_tetrahedron_point_3d(g.point(v[0]),
g.point(v[1]),
g.point(v[2]),
g.point(v[3]),
point);
dolfin_error("CollisionPredicates.cpp",
"compute entity-point collision",
"Not implemented for dimensions %d / %d", tdim, gdim);
return false;
}
bool CParaWorldAsset::UnloadAssetByKeyName(const string& keyname)
{
string sFileExt = CParaFile::GetFileExtension(keyname);
if(sFileExt == "dds" || sFileExt == "png")
{
TextureEntity* pEntity = (TextureEntity*) GetTextureManager().get(keyname);
if(pEntity && (pEntity->GetState()==AssetEntity::ASSET_STATE_FAILED_TO_LOAD || pEntity->IsLoaded()))
{
pEntity->UnloadAsset();
pEntity->SetLocalFileName("");
if(pEntity->GetState()==AssetEntity::ASSET_STATE_FAILED_TO_LOAD)
pEntity->SetState(AssetEntity::ASSET_STATE_NORMAL);
return true;
}
}
else if(sFileExt == "x" || sFileExt == "xml")
{
{
MeshEntity* pEntity = (MeshEntity*) GetMeshManager().get(keyname);
if(pEntity && pEntity->IsLoaded())
{
pEntity->UnloadAsset();
pEntity->SetLocalFileName("");
return true;
}
}
{
ParaXEntity* pEntity = (ParaXEntity*) GetParaXManager().get(keyname);
if(pEntity && pEntity->IsLoaded())
{
pEntity->UnloadAsset();
pEntity->SetLocalFileName("");
return true;
}
}
}
#ifdef USE_DIRECTX_RENDERER
else if(sFileExt == "iges")
{
CadModel* pCadModel = (CadModel*) m_CadModelManager.get(keyname);
if(pCadModel && pCadModel->IsLoaded())
{
pCadModel->UnloadAsset();
pCadModel->SetLocalFileName("");
return true;
}
}
#endif
return false;
}
//--------------------------------------------------------------------
// Desc: Load new template into memory, template with the same identifier
// will not be created twice.
//
// Params: sMeshFileName the identifier string
//--------------------------------------------------------------------
MeshEntity* CParaWorldAsset::LoadMesh(const string& sIdentifier, const string& fileName)
{
string sFileName;
CParaFile::ToCanonicalFilePath(sFileName, fileName, false);
if (m_bUseAssetSearch)
DoAssetSearch(sFileName, CParaFile::GetCurDirectory(CParaFile::APP_MODEL_DIR).c_str());
pair<MeshEntity*, bool> res = GetMeshManager().CreateEntity(sIdentifier, sFileName);
if (res.second == true)
{
MeshEntity* pNewEntity = res.first;
pNewEntity->Init();
}
return res.first;
}
//-----------------------------------------------------------------------------
double TriangleCell::volume(const MeshEntity& triangle) const
{
// Check that we get a triangle
if (triangle.dim() != 2)
{
dolfin_error("TriangleCell.cpp",
"compute volume (area) of triangle cell",
"Illegal mesh entity, not a triangle");
}
// Get mesh geometry
const MeshGeometry& geometry = triangle.mesh().geometry();
// Get the coordinates of the three vertices
const unsigned int* vertices = triangle.entities(0);
const double* x0 = geometry.x(vertices[0]);
const double* x1 = geometry.x(vertices[1]);
const double* x2 = geometry.x(vertices[2]);
if (geometry.dim() == 2)
{
// Compute area of triangle embedded in R^2
double v2 = (x0[0]*x1[1] + x0[1]*x2[0] + x1[0]*x2[1])
- (x2[0]*x1[1] + x2[1]*x0[0] + x1[0]*x0[1]);
// Formula for volume from http://mathworld.wolfram.com
return 0.5 * std::abs(v2);
}
else if (geometry.dim() == 3)
{
// Compute area of triangle embedded in R^3
const double v0 = (x0[1]*x1[2] + x0[2]*x2[1] + x1[1]*x2[2])
- (x2[1]*x1[2] + x2[2]*x0[1] + x1[1]*x0[2]);
const double v1 = (x0[2]*x1[0] + x0[0]*x2[2] + x1[2]*x2[0])
- (x2[2]*x1[0] + x2[0]*x0[2] + x1[2]*x0[0]);
const double v2 = (x0[0]*x1[1] + x0[1]*x2[0] + x1[0]*x2[1])
- (x2[0]*x1[1] + x2[1]*x0[0] + x1[0]*x0[1]);
// Formula for volume from http://mathworld.wolfram.com
return 0.5*sqrt(v0*v0 + v1*v1 + v2*v2);
}
else
{
dolfin_error("TriangleCell.cpp",
"compute volume of triangle",
"Only know how to compute volume when embedded in R^2 or R^3");
}
return 0.0;
}
//-----------------------------------------------------------------------------
bool
CollisionDetection::collides_tetrahedron_point(const MeshEntity& tetrahedron,
const Point& point)
{
dolfin_assert(tetrahedron.mesh().topology().dim() == 3);
// Get the vertices as points
const MeshGeometry& geometry = tetrahedron.mesh().geometry();
const unsigned int* vertices = tetrahedron.entities(0);
return collides_tetrahedron_point(geometry.point(vertices[0]),
geometry.point(vertices[1]),
geometry.point(vertices[2]),
geometry.point(vertices[3]),
point);
}
/**
* Visitor action; invoke MeshEntity::SetScale on a mesh.
*
* @param [in,out] meshEntity The mesh entity.
*
* @return true.
*/
bool
SetScaleDialog::SetScaleVisitor::Execute(MeshEntity& meshEntity) const
{
if (_rowArgs != NULL)
{
meshEntity.SetScale(MeshEntity::ROW_SLICE_TYPE,
_rowArgs->alignSlice, _rowArgs->refSlice,
_rowArgs->naturalScale, _rowArgs->scaleOrTiles);
}
if (_colArgs != NULL)
{
meshEntity.SetScale(MeshEntity::COL_SLICE_TYPE,
_colArgs->alignSlice, _colArgs->refSlice,
_colArgs->naturalScale, _colArgs->scaleOrTiles);
}
return true;
}
/**
* Visitor action; invoke MeshEntity::GeneralFunction on a mesh.
*
* @param [in,out] meshEntity The mesh.
*
* @return true.
*/
bool
GeneralFunctionDialog::GeneralFunctionVisitor::Execute(MeshEntity& meshEntity) const
{
meshEntity.GeneralFunction(_sFactors, _tFactors,
_alignRow, _alignCol, _refRow, _refCol,
_surfaceValues);
return true;
}
Entity *MeshEntity::DuplicateEntity()
{
MeshEntity *ent = (MeshEntity*)this->GetObjectClass()->Create(FALSE);
List<BYTE> data;
BufferOutputSerializer sSave(data);
this->Serialize(sSave);
BufferInputSerializer sLoad(data);
ent->Serialize(sLoad);
ent->GenerateUniqueName();
ent->bLightmapped = FALSE;
ent->Init();
return ent;
}
//-----------------------------------------------------------------------------
bool CollisionDetection::collides_triangle_point(const MeshEntity& triangle,
const Point& point)
{
dolfin_assert(triangle.mesh().topology().dim() == 2);
const MeshGeometry& geometry = triangle.mesh().geometry();
const unsigned int* vertices = triangle.entities(0);
if (triangle.mesh().geometry().dim() == 2)
return collides_triangle_point_2d(geometry.point(vertices[0]),
geometry.point(vertices[1]),
geometry.point(vertices[2]),
point);
else
return collides_triangle_point(geometry.point(vertices[0]),
geometry.point(vertices[1]),
geometry.point(vertices[2]),
point);
}
//-----------------------------------------------------------------------------
double IntervalCell::volume(const MeshEntity& interval) const
{
// Check that we get an interval
if (interval.dim() != 1)
{
dolfin_error("IntervalCell.cpp",
"compute volume (length) of interval cell",
"Illegal mesh entity, not an interval");
}
// Get mesh geometry
const MeshGeometry& geometry = interval.mesh().geometry();
// Get the coordinates of the two vertices
const unsigned int* vertices = interval.entities(0);
const Point x0 = geometry.point(vertices[0]);
const Point x1 = geometry.point(vertices[1]);
return x1.distance(x0);
}
//! visits a particular entity
void ColorVisitor::Visit(Entity* pTarget)
{
SHOOT_ASSERT(pTarget->IsA(MeshEntity::TypeID), "ColorVisitor target is not of type MeshEntity");
SHOOT_ASSERT(pTarget->GetComponent<ExplosionVisitor>() == NULL, "Can't apply ColorVisitor and ExplosionVisitor simultaneously");
m_OriginalVertexBuffers.clear();
m_VertexBuffers.clear();
MeshEntity* pMesh = static_cast<MeshEntity*>(pTarget);
std::vector<SubMesh*>& subMeshes = pMesh->GetSubMeshes();
for(u32 i=0; i<subMeshes.size(); ++i)
{
GraphicComponent* pGraphic = subMeshes[i]->GetComponent<GraphicComponent>();
VertexBuffer* pSourceVB = pGraphic->GetVertexBuffer();
SHOOT_ASSERT(pSourceVB->GetDynamic(), "ColorVisitor needs a dynamic vertex buffer");
SHOOT_ASSERT(pSourceVB->GetPrimitiveType() == GraphicsDriver::PT_Triangle, "ColorVisitor only supported triangulated meshes for now");
SHOOT_ASSERT(pSourceVB->GetIndices(), "ColorVisitor only works with indexed vertex buffers");
VertexBuffer* pVB = static_cast<VertexBuffer*>(pSourceVB->Copy());
Vertex3D* pVertices = snew Vertex3D[pSourceVB->GetNumVertices()];
u16* pIndices = snew u16[pSourceVB->GetNumIndices()];
memcpy(pVertices, pSourceVB->GetVertices(), pSourceVB->GetNumVertices()*sizeof(Vertex3D));
memcpy(pIndices, pSourceVB->GetIndices(), pSourceVB->GetNumIndices()*sizeof(u16));
pVB->SetVertices(pVertices, pSourceVB->GetNumVertices());
pVB->SetIndices(pIndices, pSourceVB->GetNumIndices());
pVB->SetVertexFlag(Vertex3D::VF_Color);
m_OriginalVertexBuffers.push_back(pSourceVB);
m_VertexBuffers.push_back(pVB);
pGraphic->SetVertexBuffer(pVB);
}
m_fInterpolator = 0.0f;
GraphicComponent* pGraphic = subMeshes[0]->GetComponent<GraphicComponent>();
m_SrcColor = pGraphic->GetMaterial()->GetColor();
m_DestColor = m_Color;
super::Visit(pTarget);
}
//-----------------------------------------------------------------------------
double IntervalCell::diameter(const MeshEntity& interval) const
{
// Check that we get an interval
if (interval.dim() != 1)
{
dolfin_error("IntervalCell.cpp",
"compute diameter of interval cell",
"Illegal mesh entity, not an interval");
}
// Diameter is same as volume for interval (line segment)
return volume(interval);
}
//-----------------------------------------------------------------------------
double IntervalCell::circumradius(const MeshEntity& interval) const
{
// Check that we get an interval
if (interval.dim() != 1)
{
dolfin_error("IntervalCell.cpp",
"compute diameter of interval cell",
"Illegal mesh entity, not an interval");
}
// Circumradius is half the volume for an interval (line segment)
return volume(interval)/2.0;
}
const value_type operator()(const MeshEntity& entity) const
{
assert(entity.getDimension() == dimension);
const typename std::map<MeshEntity, value_type>::const_iterator entityIter(relations.find(entity));
if (entityIter != relations.end())
{
return entityIter->second;
}
else
{
return defaultValue;
}
}
//-----------------------------------------------------------------------------
bool
CollisionDetection::collides_interval_interval(const MeshEntity& interval_0,
const MeshEntity& interval_1)
{
// Get coordinates
const MeshGeometry& geometry_0 = interval_0.mesh().geometry();
const MeshGeometry& geometry_1 = interval_1.mesh().geometry();
const unsigned int* vertices_0 = interval_0.entities(0);
const unsigned int* vertices_1 = interval_1.entities(0);
const double x00 = geometry_0.point(vertices_0[0])[0];
const double x01 = geometry_0.point(vertices_0[1])[0];
const double x10 = geometry_1.point(vertices_1[0])[0];
const double x11 = geometry_1.point(vertices_1[1])[0];
const double a0 = std::min(x00, x01);
const double b0 = std::max(x00, x01);
const double a1 = std::min(x10, x11);
const double b1 = std::max(x10, x11);
// Check for collisions
const double dx = std::min(b0 - a0, b1 - a1);
const double eps = std::max(DOLFIN_EPS_LARGE, DOLFIN_EPS_LARGE*dx);
return b1 > a0 - eps && a1 < b0 + eps;
}
//-----------------------------------------------------------------------------
double TriangleCell::diameter(const MeshEntity& triangle) const
{
// Check that we get a triangle
if (triangle.dim() != 2)
{
dolfin_error("TriangleCell.cpp",
"compute diameter of triangle cell",
"Illegal mesh entity, not a triangle");
}
// Get mesh geometry
const MeshGeometry& geometry = triangle.mesh().geometry();
// Only know how to compute the diameter when embedded in R^2 or R^3
if (geometry.dim() != 2 && geometry.dim() != 3)
dolfin_error("TriangleCell.cpp",
"compute diameter of triangle",
"Only know how to compute diameter when embedded in R^2 or R^3");
// Get the coordinates of the three vertices
const unsigned int* vertices = triangle.entities(0);
const Point p0 = geometry.point(vertices[0]);
const Point p1 = geometry.point(vertices[1]);
const Point p2 = geometry.point(vertices[2]);
// FIXME: Assuming 3D coordinates, could be more efficient if
// FIXME: if we assumed 2D coordinates in 2D
// Compute side lengths
const double a = p1.distance(p2);
const double b = p0.distance(p2);
const double c = p0.distance(p1);
// Formula for diameter (2*circumradius) from http://mathworld.wolfram.com
return 0.5*a*b*c / volume(triangle);
}
//-----------------------------------------------------------------------------
double HexahedronCell::diameter(const MeshEntity& cell) const
{
// Check that we get a cell
if (cell.dim() != 2)
{
dolfin_error("HexahedronCell.cpp",
"compute diameter of hexahedron cell",
"Illegal mesh entity");
}
dolfin_error("HexahedronCell.cpp",
"compute diameter of hexahedron cell",
"Don't know how to compute diameter");
dolfin_not_implemented();
return 0.0;
}
//-----------------------------------------------------------------------------
bool CollisionDetection::collides(const MeshEntity& entity,
const Point& point)
{
switch (entity.dim())
{
case 0:
dolfin_not_implemented();
break;
case 1:
return collides_interval_point(entity, point);
case 2:
return collides_triangle_point(entity, point);
case 3:
return collides_tetrahedron_point(entity, point);
default:
dolfin_error("CollisionDetection.cpp",
"collides entity with point",
"Unknown dimension of entity");
}
return false;
}
//-----------------------------------------------------------------------------
bool
CollisionDetection::collides_triangle_triangle(const MeshEntity& triangle_0,
const MeshEntity& triangle_1)
{
dolfin_assert(triangle_0.mesh().topology().dim() == 2);
dolfin_assert(triangle_1.mesh().topology().dim() == 2);
// Get vertices as points
const MeshGeometry& geometry_0 = triangle_0.mesh().geometry();
const unsigned int* vertices_0 = triangle_0.entities(0);
const MeshGeometry& geometry_1 = triangle_1.mesh().geometry();
const unsigned int* vertices_1 = triangle_1.entities(0);
return collides_triangle_triangle(geometry_0.point(vertices_0[0]),
geometry_0.point(vertices_0[1]),
geometry_0.point(vertices_0[2]),
geometry_1.point(vertices_1[0]),
geometry_1.point(vertices_1[1]),
geometry_1.point(vertices_1[2]));
}
//-----------------------------------------------------------------------------
bool
CollisionDetection::collides_tetrahedron_triangle(const MeshEntity& tetrahedron,
const MeshEntity& triangle)
{
dolfin_assert(tetrahedron.mesh().topology().dim() == 3);
dolfin_assert(triangle.mesh().topology().dim() == 2);
// Get the vertices of the tetrahedron as points
const MeshGeometry& geometry_tet = tetrahedron.mesh().geometry();
const unsigned int* vertices_tet = tetrahedron.entities(0);
// Get the vertices of the triangle as points
const MeshGeometry& geometry_tri = triangle.mesh().geometry();
const unsigned int* vertices_tri = triangle.entities(0);
return collides_tetrahedron_triangle(geometry_tet.point(vertices_tet[0]),
geometry_tet.point(vertices_tet[1]),
geometry_tet.point(vertices_tet[2]),
geometry_tet.point(vertices_tet[3]),
geometry_tri.point(vertices_tri[0]),
geometry_tri.point(vertices_tri[1]),
geometry_tri.point(vertices_tri[2]));
}
