Commit 1d4e1782 authored by Armin Erraji's avatar Armin Erraji

Renamed v3FromVertexMirrored and v3ToVertexMirrored to...

Renamed v3FromVertexMirrored and v3ToVertexMirrored to v3ImageEdgeReceiverStart and -End in CPropagaionEdge because they are the receiving points of the imaged edge. Also added v3ImageEdgeSourceStart and -End in CPropagationFace for the calculation of the mirrored emitting points of the last edge in front of the face. The mirroring is added to the ConstructImageEdges() function.
parent cf201fc8
......@@ -19,6 +19,8 @@ namespace ITAPropagationPathSim
namespace Diffraction
{
bool ITA_PROPAGATION_PATH_SIM_API ConstructAperturePoints(shared_ptr<const CEmitter> pEmitter, shared_ptr<const CSensor> pSensor, const int iNumberIterations, const vector<CPropagationShapeShared> pPropagationListsIn, vector<CPropagationShapeShared>& pPropagationListsOut);
bool ITA_PROPAGATION_PATH_SIM_API AccumulatedAngleCulling(const float fAngleThreshold, const vector<CPropagationShapeShared> pPropagationTreeIn, vector<CPropagationShapeShared>& pPropagationTreeOut);
}
}
......
......@@ -93,7 +93,9 @@ namespace ITAPropagationPathSim
vector<shared_ptr<VistaVector3D>> vv3Vertices;
shared_ptr<VistaVector3D> v3ImageSource;
//shared_ptr<VistaVector3D> v3ImageReceiver;
shared_ptr<VistaVector3D> v3ImageEdgeSourceStart;
shared_ptr<VistaVector3D> v3ImageEdgeSourceEnd;
shared_ptr<bool> pHasValidImageSource;
......@@ -114,13 +116,13 @@ namespace ITAPropagationPathSim
shared_ptr<bool> pHasValidImageEdge;
shared_ptr<VistaVector3D> v3FromVertex;//!< Start vertex of corresponding halfedge
shared_ptr<VistaVector3D> v3ToVertex;//!< End vertex of corresponding halfedge
shared_ptr<VistaVector3D> v3StartVertex;//!< Start vertex of corresponding halfedge
shared_ptr<VistaVector3D> v3EndVertex;//!< End vertex of corresponding halfedge
shared_ptr<VistaVector3D> v3MainFaceNormal;//!< Face normal of main face
shared_ptr<VistaVector3D> v3OppositeFaceNormal;//!< Face normal of opposing face
shared_ptr<VistaVector3D> v3FromVertexMirrored;
shared_ptr<VistaVector3D> v3ToVertexMirrored;
shared_ptr<VistaVector3D> v3ImageEdgeReceiverStart; //!< Start vertex of corresponding mirrored halfedge
shared_ptr<VistaVector3D> v3ImageEdgeReceiverEnd;//!< End vertex of corresponding mirrored halfedge
//!< Position of interaction point relative to the ray starting at v3FromVertex and showing in direction of (v3ToVertex - v3FromVertex)
......
......@@ -58,7 +58,7 @@ bool ITAPropagationPathSim::CombinedModel::Diffraction::ConstructAperturePoints(
vfRelativeApexPosition.push_back(0.5);
//The edge direction for the outgoing part is the difference of the end points of the edge
vpE_out.push_back(make_shared<VistaVector3D>(*pEdge->v3ToVertex - *pEdge->v3FromVertex));
vpE_out.push_back(make_shared<VistaVector3D>(*pEdge->v3EndVertex - *pEdge->v3EdgeStart));
//Get the squared length. The length of an edge is always the same whether it was mirrored or not
vfE_square.push_back(vpE_out.back()->GetLengthSquared());
......@@ -66,21 +66,21 @@ bool ITAPropagationPathSim::CombinedModel::Diffraction::ConstructAperturePoints(
//The first shape has no parent. If the parent is a face, the edge must be mirrored(already done in a previous step)
if (!pEdge->pParent.expired() && pEdge->pParent.lock()->iShapeType == CPropagationShape::FACE)
{
vpE_in.push_back(make_shared<VistaVector3D>(*pEdge->v3ToVertexMirrored - *pEdge->v3FromVertexMirrored));
vpE_in.push_back(make_shared<VistaVector3D>(*pEdge->v3ImageEdgeReceiverEnd - *pEdge->v3ImageEdgeReceiverStart));
vpVertexDiff.push_back(make_unique<VistaVector3D>(*v3LastFromVertex - *pEdge->v3FromVertexMirrored));
vpVertexDiff.push_back(make_unique<VistaVector3D>(*v3LastFromVertex - *pEdge->v3ImageEdgeReceiverStart));
}
else
{
//The input edge direction does not have to be mirrored and is therefore the same direction as the output edge direction
vpE_in.push_back(vpE_out.back());
vpVertexDiff.push_back(make_unique<VistaVector3D>(*v3LastFromVertex - *pEdge->v3FromVertex));
vpVertexDiff.push_back(make_unique<VistaVector3D>(*v3LastFromVertex - *pEdge->v3EdgeStart));
}
//Set the current from vertex as the next "last" one
v3LastFromVertex = pEdge->v3FromVertex;
v3LastFromVertex = pEdge->v3EdgeStart;
//Set the next shape to the child of the current shape
pShape = pShape->pChild;
......@@ -215,7 +215,7 @@ bool ITAPropagationPathSim::CombinedModel::Diffraction::ConstructAperturePoints(
{
//Set the interaction point to the aperture point location
//v3InteractionPoint = from_vertex + vfRelativeApexPosition * (to_vertex - from_vertex)
VistaVector3D v3InteractionPoint = (1 - vfRelativeApexPosition.back()) * (*pEdge->v3FromVertex) + vfRelativeApexPosition.back()*(*pEdge->v3ToVertex);
VistaVector3D v3InteractionPoint = (1 - vfRelativeApexPosition.back()) * (*pEdge->v3EdgeStart) + vfRelativeApexPosition.back()*(*pEdge->v3EndVertex);
//Set the interaction point
pEdge->v3InteractionPoint = make_unique <VistaVector3D>(v3InteractionPoint);
......@@ -250,3 +250,8 @@ bool ITAPropagationPathSim::CombinedModel::Diffraction::ConstructAperturePoints(
return true;
}
bool ITAPropagationPathSim::CombinedModel::Diffraction::AccumulatedAngleCulling(const float fAngleThreshold, const vector<CPropagationShapeShared> pPropagationTreeIn, vector<CPropagationShapeShared>& pPropagationTreeOut)
{
return false;
}
......@@ -154,16 +154,16 @@ namespace ITAPropagationPathSim
bool RecursiveConstructImageEdge(shared_ptr<const CPropagationFace> pParentFace, shared_ptr<CPropagationEdge>& pPropagationEdge)
{
//Only one image must be in front of plane
bool bValidImageEdge = ITAGeoUtils::IsPointInFrontOfPlane(*pParentFace->pPlane, *pPropagationEdge->v3FromVertexMirrored);
bValidImageEdge |= ITAGeoUtils::IsPointInFrontOfPlane(*pParentFace->pPlane, *pPropagationEdge->v3FromVertexMirrored);
bool bValidImageEdge = ITAGeoUtils::IsPointInFrontOfPlane(*pParentFace->pPlane, *pPropagationEdge->v3ImageEdgeReceiverStart);
bValidImageEdge |= ITAGeoUtils::IsPointInFrontOfPlane(*pParentFace->pPlane, *pPropagationEdge->v3ImageEdgeReceiverStart);
//If both images are not valid the whole image edge is invalid
if (!bValidImageEdge)
return false;
ITAGeoUtils::MirrorPointOverPlane(*(pPropagationEdge->v3FromVertexMirrored.get()), *(pParentFace->pPlane.get()), *(pPropagationEdge->v3FromVertexMirrored.get()));
ITAGeoUtils::MirrorPointOverPlane(*(pPropagationEdge->v3ToVertexMirrored.get()), *(pParentFace->pPlane.get()), *(pPropagationEdge->v3ToVertexMirrored.get()));
ITAGeoUtils::MirrorPointOverPlane(*(pPropagationEdge->v3ImageEdgeReceiverStart.get()), *(pParentFace->pPlane.get()), *(pPropagationEdge->v3ImageEdgeReceiverStart.get()));
ITAGeoUtils::MirrorPointOverPlane(*(pPropagationEdge->v3ImageEdgeReceiverEnd.get()), *(pParentFace->pPlane.get()), *(pPropagationEdge->v3ImageEdgeReceiverEnd.get()));
//Recursive construction until no further faces are found
if (!pParentFace->pParent.expired() && pParentFace->pParent.lock()->iShapeType == CPropagationShape::FACE)
......@@ -180,7 +180,9 @@ namespace ITAPropagationPathSim
if( pPropagationShape == nullptr )
return false;
//if the type is face, just go one level deeper
//Create image edge receiver in case of an edge and image edge source of an face followed by at least one edge
//Due to the structure of the propagation tree, image edge sources of each mirrored edge is saved in the corresponding following
//propagation faces and the image edge receiver are saved in the corresponding edge followed up by a number of faces
if (pPropagationShape->iShapeType == CPropagationShape::EDGE)
{
auto pPropagationEdge = static_pointer_cast<CPropagationEdge>(pPropagationShape);
......@@ -189,16 +191,16 @@ namespace ITAPropagationPathSim
if (!pPropagationEdge->pParent.expired() && pPropagationEdge->pParent.lock()->iShapeType == CPropagationShape::FACE)
{
pPropagationEdge->v3FromVertexMirrored = make_shared<VistaVector3D>(*pPropagationEdge->v3FromVertex);
pPropagationEdge->v3ToVertexMirrored = make_shared<VistaVector3D>(*pPropagationEdge->v3ToVertex);
pPropagationEdge->v3ImageEdgeReceiverStart = make_shared<VistaVector3D>(*pPropagationEdge->v3StartVertex);
pPropagationEdge->v3ImageEdgeReceiverEnd = make_shared<VistaVector3D>(*pPropagationEdge->v3EndVertex);
pPropagationEdge->pHasValidImageEdge = make_shared<bool>(true);
auto pParentFace = static_pointer_cast<CPropagationFace>(pPropagationEdge->pParent.lock());
while (true)
{
//Only one image must be in front of plane
bool bValidImageEdge = ITAGeoUtils::IsPointInFrontOfPlane(*pParentFace->pPlane, *pPropagationEdge->v3FromVertexMirrored);
bValidImageEdge |= ITAGeoUtils::IsPointInFrontOfPlane(*pParentFace->pPlane, *pPropagationEdge->v3FromVertexMirrored);
bool bValidImageEdge = ITAGeoUtils::IsPointInFrontOfPlane(*pParentFace->pPlane, *pPropagationEdge->v3ImageEdgeReceiverStart);
bValidImageEdge |= ITAGeoUtils::IsPointInFrontOfPlane(*pParentFace->pPlane, *pPropagationEdge->v3ImageEdgeReceiverEnd);
//If both images are not valid the whole image edge is invalid
if (!bValidImageEdge)
......@@ -208,8 +210,8 @@ namespace ITAPropagationPathSim
break;
}
ITAGeoUtils::MirrorPointOverPlane(*pPropagationEdge->v3FromVertex, *pParentFace->pPlane, *pPropagationEdge->v3FromVertexMirrored);
ITAGeoUtils::MirrorPointOverPlane(*pPropagationEdge->v3ToVertex, *pParentFace->pPlane, *pPropagationEdge->v3ToVertexMirrored);
ITAGeoUtils::MirrorPointOverPlane(*pPropagationEdge->v3StartVertex, *pParentFace->pPlane, *pPropagationEdge->v3ImageEdgeReceiverStart);
ITAGeoUtils::MirrorPointOverPlane(*pPropagationEdge->v3EndVertex, *pParentFace->pPlane, *pPropagationEdge->v3ImageEdgeReceiverEnd);
if (!pParentFace->pParent.expired() && pParentFace->pParent.lock()->iShapeType == CPropagationShape::FACE)
{
......@@ -221,22 +223,54 @@ namespace ITAPropagationPathSim
}
}
//ITAGeoUtils::MirrorPointOverPlane(*pPropagationEdge->v3FromVertex, *pParentFace->pPlane, *pPropagationEdge->v3FromVertexMirrored);
//ITAGeoUtils::MirrorPointOverPlane(*pPropagationEdge->v3ToVertex, *pParentFace->pPlane, *pPropagationEdge->v3ToVertexMirrored);
}
}
else if (pPropagationShape->iShapeType == CPropagationShape::FACE)
{
auto pPropagationFace = dynamic_pointer_cast<CPropagationFace>(pPropagationShape);
//Create image vertices only for edges with faces as parents
if (!pPropagationFace->pParent.expired())
{
if (pPropagationFace->pParent.lock()->iShapeType == CPropagationShape::FACE)
{
auto pParentFace = dynamic_pointer_cast<CPropagationFace>(pPropagationFace->pParent.lock());
if (pParentFace->v3ImageEdgeSourceStart != nullptr)
{
//Only one image must be in front of plane
bool bValidImageEdge = ITAGeoUtils::IsPointInFrontOfPlane(*pPropagationFace->pPlane, *pParentFace->v3ImageEdgeSourceStart);
bValidImageEdge |= ITAGeoUtils::IsPointInFrontOfPlane(*pPropagationFace->pPlane, *pParentFace->v3ImageEdgeSourceEnd);
////First mirroring is valid
//pPropagationEdge->pHasValidImageEdge = make_shared<bool>(true);
//Set image edge source if valid
if (bValidImageEdge)
{
pPropagationFace->v3ImageEdgeSourceStart = make_shared<VistaVector3D>();
pPropagationFace->v3ImageEdgeSourceEnd = make_shared<VistaVector3D>();
ITAGeoUtils::MirrorPointOverPlane(*pParentFace->v3ImageEdgeSourceStart, *pPropagationFace->pPlane, *pPropagationFace->v3ImageEdgeSourceStart);
ITAGeoUtils::MirrorPointOverPlane(*pParentFace->v3ImageEdgeSourceEnd, *pPropagationFace->pPlane, *pPropagationFace->v3ImageEdgeSourceEnd);
////Ff grandparent is also a face, further mirroring of image vertices
//if (pParentFace->pParent != nullptr && pParentFace->pParent->iShapeType == CPropagationShape::FACE)
//{
// pParentFace = static_pointer_cast<CPropagationFace>(pParentFace->pParent);
// *pPropagationEdge->pHasValidImageEdge = RecursiveConstructImageEdge(pParentFace, pPropagationEdge);
//}
}
}
}
else if (pPropagationFace->pParent.lock()->iShapeType == CPropagationShape::EDGE)
{
auto pParentEdge = dynamic_pointer_cast<CPropagationEdge>(pPropagationFace->pParent.lock());
//Calculate image edge source.
//A PointInFrontOfPlane test is not needed, because a backfaceculling with vertices and plane is already done.
pPropagationFace->v3ImageEdgeSourceStart = make_shared<VistaVector3D>();
pPropagationFace->v3ImageEdgeSourceEnd = make_shared<VistaVector3D>();
ITAGeoUtils::MirrorPointOverPlane(*pParentEdge->v3StartVertex, *pPropagationFace->pPlane, *pPropagationFace->v3ImageEdgeSourceStart);
ITAGeoUtils::MirrorPointOverPlane(*pParentEdge->v3EndVertex, *pPropagationFace->pPlane, *pPropagationFace->v3ImageEdgeSourceEnd);
}
}
}
//Go one level deeper
for (auto& pShapeChild : pPropagationShape->vpChildren)
RecursiveConstructImageEdges(pShapeChild);
......
......@@ -91,6 +91,12 @@ void ITAPropagationPathSim::CombinedModel::CPathEngine::ApplyEmitter(shared_ptr<
//Construct image edges
ImageConstruction::ConstructImageEdges(m_pEmitter, m_vpPropagationTree);
//Calculate accumulated angle and filter tree
if (m_pAccumulatedAngleThreshold > 0)
{
Diffraction::AccumulatedAngleCulling(*m_pAccumulatedAngleThreshold, m_vpPropagationTree, m_vpPropagationTree);
}
}
void ITAPropagationPathSim::CombinedModel::CPathEngine::ApplySensor(shared_ptr<ITAGeo::CSensor> pSensor)
......@@ -240,8 +246,8 @@ void ITAPropagationPathSim::CombinedModel::CPathEngine::ConvertShapeListsToPropa
pDiffractionAnchor->v3InteractionPoint = *pEdge->v3InteractionPoint;
pDiffractionAnchor->v3MainWedgeFaceNormal = *pEdge->v3MainFaceNormal;
pDiffractionAnchor->v3OppositeWedgeFaceNormal = *pEdge->v3OppositeFaceNormal;
pDiffractionAnchor->v3VertextStart = *pEdge->v3FromVertex;
pDiffractionAnchor->v3VertextEnd = *pEdge->v3ToVertex;
pDiffractionAnchor->v3VertextStart = *pEdge->v3StartVertex;
pDiffractionAnchor->v3VertextEnd = *pEdge->v3EndVertex;
oPath.push_back(pDiffractionAnchor);
......@@ -666,14 +672,14 @@ bool ITAPropagationPathSim::CombinedModel::CPathEngine::CanPointIlluminateEdge(c
{
//Resolution (100 m)
float fResolution = 10000 * ITAConstants::EPS_F_L;
VistaVector3D v3EdgeDirection = *pPropagationEdge->v3ToVertex - *pPropagationEdge->v3FromVertex;
VistaVector3D v3EdgeDirection = *pPropagationEdge->v3EndVertex - *pPropagationEdge->v3StartVertex;
float fRelativeStepSize = fResolution / (v3EdgeDirection.GetLength());
float fRelativePosition = fRelativeStepSize;
while (fRelativePosition < 1)
{
//If a visible path is found, the edge can be illuminated by the point
if (IsPathVisible(v3Point, *pPropagationEdge->v3FromVertex + fRelativePosition * v3EdgeDirection))
if (IsPathVisible(v3Point, *pPropagationEdge->v3StartVertex + fRelativePosition * v3EdgeDirection))
return true;
else //Search further points on the edge
fRelativePosition += fRelativeStepSize;
......@@ -719,8 +725,8 @@ void ITAPropagationPathSim::CombinedModel::CPathEngine::CanEdgeIlluminateFace(bo
float eps = ITAConstants::EPS_F_L;
bCanEdgeIlluminateFaceOut = ITAGeoUtils::CanFaceBeIlluminated(*pFaceMesh, pPropagationFace->hFace, (1 - eps)*(*pPropagationEdge->v3FromVertex) + (eps)*(*pPropagationEdge->v3ToVertex));
bCanEdgeIlluminateFaceOut |= ITAGeoUtils::CanFaceBeIlluminated(*pFaceMesh, pPropagationFace->hFace, (1 - eps)*(*pPropagationEdge->v3ToVertex) + (eps)*(*pPropagationEdge->v3FromVertex));
bCanEdgeIlluminateFaceOut = ITAGeoUtils::CanFaceBeIlluminated(*pFaceMesh, pPropagationFace->hFace, (1 - eps)*(*pPropagationEdge->v3StartVertex) + (eps)*(*pPropagationEdge->v3EndVertex));
bCanEdgeIlluminateFaceOut |= ITAGeoUtils::CanFaceBeIlluminated(*pFaceMesh, pPropagationFace->hFace, (1 - eps)*(*pPropagationEdge->v3EndVertex) + (eps)*(*pPropagationEdge->v3StartVertex));
}
void ITAPropagationPathSim::CombinedModel::CPathEngine::CanFaceIlluminateEdge(bool &bCanFaceIlluminateEdgeOut, CPropagationFaceShared & pPropagationFace, CPropagationEdgeShared & pPropagationEdge)
......@@ -768,8 +774,8 @@ void ITAPropagationPathSim::CombinedModel::CPathEngine::CanEdgeIlluminateEdge(bo
float eps = ITAConstants::EPS_F_L;
//Illumination test at from vertex position
bMainFaceIlluminated = ITAGeoUtils::CanFaceBeIlluminated(*pEdgeEndMesh, pPropagationEdgeEnd->hMainFace, (1 - eps)*(*pPropagationEdgeStart->v3FromVertex) + (eps)*(*pPropagationEdgeStart->v3ToVertex));
bOppositeFaceIlluminated = ITAGeoUtils::CanFaceBeIlluminated(*pEdgeEndMesh, pPropagationEdgeEnd->hOppositeFace, (1 - eps)*(*pPropagationEdgeStart->v3FromVertex) + (eps)*(*pPropagationEdgeStart->v3ToVertex));
bMainFaceIlluminated = ITAGeoUtils::CanFaceBeIlluminated(*pEdgeEndMesh, pPropagationEdgeEnd->hMainFace, (1 - eps)*(*pPropagationEdgeStart->v3StartVertex) + (eps)*(*pPropagationEdgeStart->v3EndVertex));
bOppositeFaceIlluminated = ITAGeoUtils::CanFaceBeIlluminated(*pEdgeEndMesh, pPropagationEdgeEnd->hOppositeFace, (1 - eps)*(*pPropagationEdgeStart->v3StartVertex) + (eps)*(*pPropagationEdgeStart->v3EndVertex));
if (*m_pFilterIlluminatedRegionDiffraction)
bCanEdgeIlluminateEdgeOut = bMainFaceIlluminated != bOppositeFaceIlluminated; // A XOR B, only valid, if at least one point can lie in the shadow region
......@@ -780,8 +786,8 @@ void ITAPropagationPathSim::CombinedModel::CPathEngine::CanEdgeIlluminateEdge(bo
return;
//Illumination test at to vertex position
bMainFaceIlluminated = ITAGeoUtils::CanFaceBeIlluminated(*pEdgeEndMesh, pPropagationEdgeEnd->hMainFace, (1 - eps)*(*pPropagationEdgeStart->v3ToVertex) + (eps)*(*pPropagationEdgeStart->v3FromVertex));
bOppositeFaceIlluminated = ITAGeoUtils::CanFaceBeIlluminated(*pEdgeEndMesh, pPropagationEdgeEnd->hOppositeFace, (1 - eps)*(*pPropagationEdgeStart->v3ToVertex) + (eps)*(*pPropagationEdgeStart->v3FromVertex));
bMainFaceIlluminated = ITAGeoUtils::CanFaceBeIlluminated(*pEdgeEndMesh, pPropagationEdgeEnd->hMainFace, (1 - eps)*(*pPropagationEdgeStart->v3EndVertex) + (eps)*(*pPropagationEdgeStart->v3StartVertex));
bOppositeFaceIlluminated = ITAGeoUtils::CanFaceBeIlluminated(*pEdgeEndMesh, pPropagationEdgeEnd->hOppositeFace, (1 - eps)*(*pPropagationEdgeStart->v3EndVertex) + (eps)*(*pPropagationEdgeStart->v3StartVertex));
if (*m_pFilterIlluminatedRegionDiffraction)
bCanEdgeIlluminateEdgeOut = bMainFaceIlluminated != bOppositeFaceIlluminated; // A XOR B, only valid, if at least one point can lie in the shadow region
......@@ -796,13 +802,13 @@ void ITAPropagationPathSim::CombinedModel::CPathEngine::CanEdgeIlluminateEdge(bo
//Resolution (100 m)
float fResolution = 10 * ITAConstants::EPS_F_L;
VistaVector3D v3EdgeDirection = *pPropagationEdgeStart->v3ToVertex - *pPropagationEdgeStart->v3FromVertex;
VistaVector3D v3EdgeDirection = *pPropagationEdgeStart->v3EndVertex - *pPropagationEdgeStart->v3StartVertex;
float fRelativeStepSize = fResolution / (v3EdgeDirection.GetLength());
float fRelativePosition = fRelativeStepSize;
while (fRelativePosition < 1)
{
if (CanPointIlluminateEdge(*pPropagationEdgeStart->v3FromVertex + fRelativePosition* v3EdgeDirection, pPropagationEdgeEnd, bTestIntersection))
if (CanPointIlluminateEdge(*pPropagationEdgeStart->v3StartVertex + fRelativePosition* v3EdgeDirection, pPropagationEdgeEnd, bTestIntersection))
{
bCanEdgeIlluminateEdgeOut = true; //if at least one position doesn't contain a intersection with other faces
break;
......@@ -871,8 +877,8 @@ void ITAPropagationPathSim::CombinedModel::CPathEngine::ConstructPropagationShap
//Set vertices
auto hFromVertex = pMesh->from_vertex_handle(pPropagationEdge->hHalfedge);
auto hToVertex = pMesh->to_vertex_handle(pPropagationEdge->hHalfedge);
pPropagationEdge->v3FromVertex = make_shared<VistaVector3D>(pMesh->point(hFromVertex).data());
pPropagationEdge->v3ToVertex = make_shared<VistaVector3D>(pMesh->point(hToVertex).data());
pPropagationEdge->v3StartVertex = make_shared<VistaVector3D>(pMesh->point(hFromVertex).data());
pPropagationEdge->v3EndVertex = make_shared<VistaVector3D>(pMesh->point(hToVertex).data());
//Set face normals
pPropagationEdge->hMainFace = pMesh->face_handle(pPropagationEdge->hHalfedge);
......
......@@ -36,11 +36,11 @@ void CPropagationEdge::CopyFrom(const CPropagationEdge & oPropagationEdgeIn)
hEdge = oPropagationEdgeIn.hEdge;
hMainFace = oPropagationEdgeIn.hMainFace;
hOppositeFace = oPropagationEdgeIn.hOppositeFace;
v3FromVertex = oPropagationEdgeIn.v3FromVertex;
v3ToVertex = oPropagationEdgeIn.v3ToVertex;
v3EdgeStart = oPropagationEdgeIn.v3EdgeStart;
v3EndVertex = oPropagationEdgeIn.v3EndVertex;
v3MainFaceNormal = oPropagationEdgeIn.v3MainFaceNormal;
v3OppositeFaceNormal = oPropagationEdgeIn.v3OppositeFaceNormal;
v3FromVertexMirrored = oPropagationEdgeIn.v3FromVertexMirrored;
v3ToVertexMirrored = oPropagationEdgeIn.v3ToVertexMirrored;
v3ImageEdgeReceiverStart = oPropagationEdgeIn.v3ImageEdgeReceiverStart;
v3ImageEdgeReceiverEnd = oPropagationEdgeIn.v3ImageEdgeReceiverEnd;
pHasValidImageEdge = oPropagationEdgeIn.pHasValidImageEdge;
}
......@@ -87,7 +87,7 @@ int main( int iNumInArgs, char* pcInArgs[] )
const bool bFilterNotVisiblePointToEdge = true; //Intersection test between emitter/sensor and edges
const bool bFilterNotVisiblePaths = true; //Intersection test of calculated sub paths
const int iNumIterations = 100;//!< Number of iterations for the calculation of the aperture points
const int iNumIterations = 5;//!< Number of iterations for the calculation of the aperture points
const int iMaxDiffractionOrder = 3;
const int iMaxReflectionOrder = 2;
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment