TriangulatedWall::Face Struct Reference

#include <TriangulatedWall.h>

Public Member Functions
Mdouble	getDistance (const Vec3D &otherPosition) const
	computes the signed distance to the face in normal direction More...
bool	getDistanceAndNormal (const BaseParticle &p, Mdouble &distance, Vec3D &normal_return, Mdouble interactionRadius) const
	Returns true if contact with the face exists, false if not. If contact exists, then the distance and normal is returned as well. More...

Public Attributes
std::array< Vec3D *, 3 >	vertex
	defines the three vertices (anticlockwise direction around the normal) More...
std::array< Face *, 3 >	neighbor = {{nullptr}}
	For each edge, stores the neighboring face (nullptr if none) More...
std::array< Vec3D, 3 >	edgeNormal
	For each edge, stores the vector normal to the face normal and the edge direction (vector between the vertices). More...
Vec3D	normal
	face normal (vertices are ordered anticlockwise direction around the normal) More...

Detailed Description

Struct used to store the properties of a face needed for contact detection.

Member Function Documentation

getDistance()

Mdouble TriangulatedWall::Face::getDistance

(

const Vec3D &

otherPosition

)

const

computes the signed distance to the face in normal direction

{
    return Vec3D::dot(*vertex[0] - otherPosition, normal);
}

References Vec3D::dot(), normal, and vertex.

getDistanceAndNormal()

bool TriangulatedWall::Face::getDistanceAndNormal	(	const BaseParticle &	p,
		Mdouble &	distance,
		Vec3D &	normal_return,
		Mdouble	interactionRadius
	)		const

Returns true if contact with the face exists, false if not. If contact exists, then the distance and normal is returned as well.

check if there is contact with the face, determine if contact is with face, edge, vertex, return distance and normal; only return edge, vertex contact if neighbor face pointer is higher to avoid doubles

Todo:

make the triangle work from both sides

{
    //check if particle overlaps
    distance = getDistance(p.getPosition());
    //return if distance is large, or particle has too much overlap
    if (fabs(distance) >= interactionRadius)
        return false;
    
    //Contact radius squared
    Mdouble allowedDistanceSquared = interactionRadius * interactionRadius - distance * distance;
    int touchingEdge = -1;
    Vec3D* touchingVertex = nullptr;
    //loop through edges to find out if there is a contact with face, edge, vertex, or neither.
    for (unsigned i = 0; i < 3; i++)
    {
        //distance from the edge
        Mdouble edgeDistance = Vec3D::dot(edgeNormal[i], *vertex[i] - p.getPosition());
        if (edgeDistance <= 0) //if in contact with the face
            continue;
        if (edgeDistance * edgeDistance >= allowedDistanceSquared) //if not in contact with anything
            return false;
        //this point is only reached if in contact, but not with the face
        //if edge is convex, treat as face, not edge contact
        bool convex = (neighbor[i] && ((neighbor[i]->getDistance(p.getPosition()) < 0) ? (
                Vec3D::dot(neighbor[i]->normal, edgeNormal[i]) > 1e-12) : (
                                               Vec3D::dot(neighbor[i]->normal, edgeNormal[i]) < -1e-12)));
        if (touchingEdge == -1)
        {
            //edge or vertex contact (depending if more edges are found)
            touchingEdge = i;
        }
        else
        {
            //vertex contact
            touchingVertex = vertex[(i == 2 && touchingEdge == 0) ? 0 : i];
        }
        //if (!convex) continue;
        //do not compute if neighbor exists and has lower index or face contact.
        if (neighbor[i] > this)
        { //if neighbor has higher index
            if (neighbor[i]->neighbor[0] == this)
            {
                edgeDistance = Vec3D::dot(neighbor[i]->edgeNormal[0], *vertex[i] - p.getPosition());
            }
            else if (neighbor[i]->neighbor[1] == this)
            {
                edgeDistance = Vec3D::dot(neighbor[i]->edgeNormal[1], *vertex[i] - p.getPosition());
            }
            else
            { //if (neighbor[i]->neighbor[2]==this)
                edgeDistance = Vec3D::dot(neighbor[i]->edgeNormal[2], *vertex[i] - p.getPosition());
            }
            if (edgeDistance <= 0 && !convex) //if neighbor has face contact, ignore the edge contact
                return false;
        }
        else if (neighbor[i] && !convex)
        {
            return false;
        }
    }
    
    
    //check if convex neighbours are overlapping as well
    if (touchingVertex)
    { //vertex contact
        normal_return = *touchingVertex - p.getPosition();
        distance = Vec3D::getLength(normal_return);
        normal_return /= distance;
        //return false;
        //logger(INFO,"vertex contact");
    }
    else if (touchingEdge == -1)
    { //face contact
        if (distance >= 0)
        { // front face contact
            normal_return = normal;
        }
        else
        { // back face contact
            normal_return = -normal;
            distance = -distance;
        }
        //return false;
        //logger(INFO,"face contact");
    }
    else
    { //edge contact
        Vec3D VP = *vertex[touchingEdge] - p.getPosition();
        Vec3D VW = *vertex[touchingEdge] - *vertex[(touchingEdge == 2) ? 0 : (touchingEdge + 1)];
        normal_return = VP - Vec3D::dot(VP, VW) / Vec3D::getLengthSquared(VW) * VW;
        distance = Vec3D::getLength(normal_return);
        normal_return /= distance;
        //return false;
        //logger(INFO,"edge contact at c=% p=% d=% n=%",p.getPosition() + distance * normal_return,p.getPosition(), distance, normal_return);
    }
    return true;
}

References Vec3D::dot(), Vec3D::getLength(), Vec3D::getLengthSquared(), BaseInteractable::getPosition(), and constants::i.

Member Data Documentation

edgeNormal

std::array<Vec3D, 3> TriangulatedWall::Face::edgeNormal

For each edge, stores the vector normal to the face normal and the edge direction (vector between the vertices).

neighbor

std::array<Face*, 3> TriangulatedWall::Face::neighbor = {{nullptr}}

For each edge, stores the neighboring face (nullptr if none)

normal

Vec3D TriangulatedWall::Face::normal

face normal (vertices are ordered anticlockwise direction around the normal)

Referenced by getDistance().

vertex

std::array<Vec3D*, 3> TriangulatedWall::Face::vertex

defines the three vertices (anticlockwise direction around the normal)

Referenced by getDistance(), TriangulatedWall::readVTK(), and TriangulatedWall::set().

---

The documentation for this struct was generated from the following files:

• TriangulatedWall.h
• TriangulatedWall.cc