clang-format : Added extension .inl

Applied clang-format on all files in ApplicationCode including new extension .inl. Also includes some missing clang-format on other files.
This commit is contained in:
Magne Sjaastad 2019-11-19 11:08:59 +01:00
parent ae9575feb2
commit 651c28dc49
8 changed files with 602 additions and 563 deletions

View File

@ -64,7 +64,6 @@ double RiaWeightedMeanCalculator<T>::aggregatedWeight() const
return m_aggregatedWeight;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------

View File

@ -107,7 +107,9 @@ RiaGrpcUnaryCallback<ServiceT, RequestT, ReplyT>::RiaGrpcUnaryCallback(ServiceT*
template <typename ServiceT, typename RequestT, typename ReplyT>
RiaGrpcCallbackInterface* RiaGrpcUnaryCallback<ServiceT, RequestT, ReplyT>::createNewFromThis() const
{
return new RiaGrpcUnaryCallback<ServiceT, RequestT, ReplyT>(this->m_service, this->m_methodImpl, this->m_methodRequest);
return new RiaGrpcUnaryCallback<ServiceT, RequestT, ReplyT>( this->m_service,
this->m_methodImpl,
this->m_methodRequest );
}
//--------------------------------------------------------------------------------------------------
@ -150,7 +152,8 @@ QString RiaGrpcUnaryCallback<ServiceT, RequestT, ReplyT>::methodType() const
///
//--------------------------------------------------------------------------------------------------
template <typename ServiceT, typename RequestT, typename ReplyT, typename StateHandlerT>
RiaGrpcServerToClientStreamCallback<ServiceT, RequestT, ReplyT, StateHandlerT>::RiaGrpcServerToClientStreamCallback(ServiceT* service,
RiaGrpcServerToClientStreamCallback<ServiceT, RequestT, ReplyT, StateHandlerT>::RiaGrpcServerToClientStreamCallback(
ServiceT* service,
MethodImplT methodImpl,
MethodRequestT methodRequest,
StateHandlerT* stateHandler )
@ -166,10 +169,13 @@ RiaGrpcServerToClientStreamCallback<ServiceT, RequestT, ReplyT, StateHandlerT>::
///
//--------------------------------------------------------------------------------------------------
template <typename ServiceT, typename RequestT, typename ReplyT, typename StateHandlerT>
RiaGrpcCallbackInterface* RiaGrpcServerToClientStreamCallback<ServiceT, RequestT, ReplyT, StateHandlerT>::createNewFromThis() const
RiaGrpcCallbackInterface*
RiaGrpcServerToClientStreamCallback<ServiceT, RequestT, ReplyT, StateHandlerT>::createNewFromThis() const
{
return new RiaGrpcServerToClientStreamCallback<ServiceT, RequestT, ReplyT, StateHandlerT>(
this->m_service, m_methodImpl, m_methodRequest, new StateHandlerT);
return new RiaGrpcServerToClientStreamCallback<ServiceT, RequestT, ReplyT, StateHandlerT>( this->m_service,
m_methodImpl,
m_methodRequest,
new StateHandlerT );
}
//--------------------------------------------------------------------------------------------------
@ -248,12 +254,12 @@ QString RiaGrpcServerToClientStreamCallback<ServiceT, RequestT, ReplyT, StateHan
return "StreamingMethod";
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
template <typename ServiceT, typename RequestT, typename ReplyT, typename StateHandlerT>
RiaGrpcClientToServerStreamCallback<ServiceT, RequestT, ReplyT, StateHandlerT>::RiaGrpcClientToServerStreamCallback(ServiceT* service,
RiaGrpcClientToServerStreamCallback<ServiceT, RequestT, ReplyT, StateHandlerT>::RiaGrpcClientToServerStreamCallback(
ServiceT* service,
MethodImplT methodImpl,
MethodRequestT methodRequest,
StateHandlerT* stateHandler )
@ -269,10 +275,13 @@ RiaGrpcClientToServerStreamCallback<ServiceT, RequestT, ReplyT, StateHandlerT>::
///
//--------------------------------------------------------------------------------------------------
template <typename ServiceT, typename RequestT, typename ReplyT, typename StateHandlerT>
RiaGrpcCallbackInterface* RiaGrpcClientToServerStreamCallback<ServiceT, RequestT, ReplyT, StateHandlerT>::createNewFromThis() const
RiaGrpcCallbackInterface*
RiaGrpcClientToServerStreamCallback<ServiceT, RequestT, ReplyT, StateHandlerT>::createNewFromThis() const
{
return new RiaGrpcClientToServerStreamCallback<ServiceT, RequestT, ReplyT, StateHandlerT>(
this->m_service, m_methodImpl, m_methodRequest, new StateHandlerT(true));
return new RiaGrpcClientToServerStreamCallback<ServiceT, RequestT, ReplyT, StateHandlerT>( this->m_service,
m_methodImpl,
m_methodRequest,
new StateHandlerT( true ) );
}
//--------------------------------------------------------------------------------------------------

View File

@ -19,20 +19,21 @@
#include <cmath>
#pragma warning( disable : 4503 )
namespace cvf
{
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
template <typename DataType>
DataType GeometryTools::interpolateQuad(const cvf::Vec3d& v1, DataType s1,
const cvf::Vec3d& v2, DataType s2,
const cvf::Vec3d& v3, DataType s3,
const cvf::Vec3d& v4, DataType s4,
DataType GeometryTools::interpolateQuad( const cvf::Vec3d& v1,
DataType s1,
const cvf::Vec3d& v2,
DataType s2,
const cvf::Vec3d& v3,
DataType s3,
const cvf::Vec3d& v4,
DataType s4,
const cvf::Vec3d& point )
{
cvf::Vec4d bc = barycentricCoords( v1, v2, v3, v4, point );
@ -56,7 +57,6 @@ bool GeometryTools::insertVertexInPolygon( std::vector<IndexType> * polygon,
{
CVF_ASSERT( polygon );
// Check if vertex is directly included already
for ( typename std::vector<IndexType>::iterator it = polygon->begin(); it != polygon->end(); ++it )
@ -80,7 +80,6 @@ bool GeometryTools::insertVertexInPolygon( std::vector<IndexType> * polygon,
if ( existsOrInserted ) return true;
#endif
// Copy the start polygon to a list
std::list<IndexType> listPolygon;
@ -97,9 +96,13 @@ bool GeometryTools::insertVertexInPolygon( std::vector<IndexType> * polygon,
for ( typename std::list<IndexType>::iterator it = listPolygon.begin(); it != listPolygon.end(); ++it )
{
it2 = it;
++it2; insertBefore = it2; if (it2 == listPolygon.end()) it2 = listPolygon.begin();
++it2;
insertBefore = it2;
if ( it2 == listPolygon.end() ) it2 = listPolygon.begin();
double sqDistToLine = GeometryTools::linePointSquareDist(nodeCoords[*it], nodeCoords[*it2], nodeCoords[vertexIndex]);
double sqDistToLine = GeometryTools::linePointSquareDist( nodeCoords[*it],
nodeCoords[*it2],
nodeCoords[vertexIndex] );
if ( fabs( sqDistToLine ) < tolerance * tolerance )
{
it = listPolygon.insert( insertBefore, vertexIndex );
@ -118,7 +121,6 @@ bool GeometryTools::insertVertexInPolygon( std::vector<IndexType> * polygon,
return existsOrInserted;
}
//--------------------------------------------------------------------------------------------------
/// \brief Test if a point touches a polygon within the specified tolerance
///
@ -227,7 +229,6 @@ bool GeometryTools::isPointTouchingIndexedPolygon( const cvf::Vec3d& polygonNor
return false;
}
//--------------------------------------------------------------------------------------------------
/// Returns true if we get an actual polygon
/// The returned polygon will keep the winding from the first face.
@ -330,7 +331,6 @@ bool GeometryTools::calculateOverlapPolygonOfTwoQuads(std::vector<IndexType> * p
if ( numCv2VxesOnCv1 >= 4 )
{
int k;
for ( k = 3; k >= 0; --k ) // Return opposite winding, to match winding of face 1
{
@ -352,7 +352,8 @@ bool GeometryTools::calculateOverlapPolygonOfTwoQuads(std::vector<IndexType> * p
{
if ( nextCv1Idx > 3 ) nextCv1Idx = 0;
if (cv1VxTouchCv2[cv1Idx] && cv1VxTouchCv2Edge[cv1Idx] == -1) // Start of cv1 edge is touching inside the cv2 polygon (not on an cv2 edge)
if ( cv1VxTouchCv2[cv1Idx] &&
cv1VxTouchCv2Edge[cv1Idx] == -1 ) // Start of cv1 edge is touching inside the cv2 polygon (not on an cv2 edge)
{
if ( polygon->empty() || polygon->back() != cv1CubeFaceIndices[cv1Idx] )
{
@ -361,8 +362,8 @@ bool GeometryTools::calculateOverlapPolygonOfTwoQuads(std::vector<IndexType> * p
if ( cv1VxTouchCv2[nextCv1Idx] && cv1VxTouchCv2Edge[nextCv1Idx] == -1 )
{
// Both ends of this cv1 edge is touching inside(not on an edge) cv2 polygon, no intersections possible (assuming convex cube-face)
// Continue with next Cv1-edge.
// Both ends of this cv1 edge is touching inside(not on an edge) cv2 polygon, no intersections possible
// (assuming convex cube-face) Continue with next Cv1-edge.
continue;
}
}
@ -412,23 +413,25 @@ bool GeometryTools::calculateOverlapPolygonOfTwoQuads(std::vector<IndexType> * p
double fractionAlongEdge2;
bool found = false;
if ( edgeIntersectionStorage )
found = edgeIntersectionStorage->findIntersection(
cv1CubeFaceIndices[cv1Idx],
found = edgeIntersectionStorage->findIntersection( cv1CubeFaceIndices[cv1Idx],
cv1CubeFaceIndices[nextCv1Idx],
cv2CubeFaceIndices[cv2Idx],
cv2CubeFaceIndices[nextCv2Idx],
&intersectionVxIndex, &intersectStatus,
&fractionAlongEdge1, &fractionAlongEdge2);
&intersectionVxIndex,
&intersectStatus,
&fractionAlongEdge1,
&fractionAlongEdge2 );
if ( !found )
{
intersectStatus = GeometryTools::inPlaneLineIntersect3D( normal,
nodes[cv1CubeFaceIndices[cv1Idx]],
nodes[cv1CubeFaceIndices[nextCv1Idx]],
nodes[cv2CubeFaceIndices[cv2Idx]],
nodes[cv2CubeFaceIndices[nextCv2Idx]],
&intersection, &fractionAlongEdge1, &fractionAlongEdge2,
&intersection,
&fractionAlongEdge1,
&fractionAlongEdge2,
tolerance );
switch ( intersectStatus )
@ -442,20 +445,30 @@ bool GeometryTools::calculateOverlapPolygonOfTwoQuads(std::vector<IndexType> * p
break;
case GeometryTools::LINES_TOUCH:
{
if (fractionAlongEdge1 <= 0.0) intersectionVxIndex = cv1CubeFaceIndices[cv1Idx];
else if (fractionAlongEdge1 >= 1.0) intersectionVxIndex = cv1CubeFaceIndices[nextCv1Idx];
else if (fractionAlongEdge2 <= 0.0) intersectionVxIndex = cv2CubeFaceIndices[cv2Idx];
else if (fractionAlongEdge2 >= 1.0) intersectionVxIndex = cv2CubeFaceIndices[nextCv2Idx];
else CVF_ASSERT(false); // Tolerance trouble
if ( fractionAlongEdge1 <= 0.0 )
intersectionVxIndex = cv1CubeFaceIndices[cv1Idx];
else if ( fractionAlongEdge1 >= 1.0 )
intersectionVxIndex = cv1CubeFaceIndices[nextCv1Idx];
else if ( fractionAlongEdge2 <= 0.0 )
intersectionVxIndex = cv2CubeFaceIndices[cv2Idx];
else if ( fractionAlongEdge2 >= 1.0 )
intersectionVxIndex = cv2CubeFaceIndices[nextCv2Idx];
else
CVF_ASSERT( false ); // Tolerance trouble
}
break;
case GeometryTools::LINES_OVERLAP:
{
if (fractionAlongEdge1 <= 0.0) intersectionVxIndex = cv1CubeFaceIndices[cv1Idx];
else if (fractionAlongEdge1 >= 1.0) intersectionVxIndex = cv1CubeFaceIndices[nextCv1Idx];
else if (fractionAlongEdge2 <= 0.0) intersectionVxIndex = cv2CubeFaceIndices[cv2Idx];
else if (fractionAlongEdge2 >= 1.0) intersectionVxIndex = cv2CubeFaceIndices[nextCv2Idx];
else CVF_ASSERT(false); // Tolerance trouble
if ( fractionAlongEdge1 <= 0.0 )
intersectionVxIndex = cv1CubeFaceIndices[cv1Idx];
else if ( fractionAlongEdge1 >= 1.0 )
intersectionVxIndex = cv1CubeFaceIndices[nextCv1Idx];
else if ( fractionAlongEdge2 <= 0.0 )
intersectionVxIndex = cv2CubeFaceIndices[cv2Idx];
else if ( fractionAlongEdge2 >= 1.0 )
intersectionVxIndex = cv2CubeFaceIndices[nextCv2Idx];
else
CVF_ASSERT( false ); // Tolerance trouble
}
break;
default:
@ -467,17 +480,17 @@ bool GeometryTools::calculateOverlapPolygonOfTwoQuads(std::vector<IndexType> * p
cv1CubeFaceIndices[nextCv1Idx],
cv2CubeFaceIndices[cv2Idx],
cv2CubeFaceIndices[nextCv2Idx],
intersectionVxIndex, intersectStatus,
fractionAlongEdge1, fractionAlongEdge2);
intersectionVxIndex,
intersectStatus,
fractionAlongEdge1,
fractionAlongEdge2 );
}
}
// Store data for each intersection along the Cv1-edge
if ( (intersectStatus == GeometryTools::LINES_CROSSES)
|| (intersectStatus == GeometryTools::LINES_TOUCH)
|| (intersectStatus == GeometryTools::LINES_OVERLAP) )
if ( ( intersectStatus == GeometryTools::LINES_CROSSES ) ||
( intersectStatus == GeometryTools::LINES_TOUCH ) || ( intersectStatus == GeometryTools::LINES_OVERLAP ) )
{
CVF_ASSERT( intersectionVxIndex != cvf::UNDEFINED_UINT );
@ -530,8 +543,8 @@ bool GeometryTools::calculateOverlapPolygonOfTwoQuads(std::vector<IndexType> * p
if intersected cv2 edge has endpoint touching cv1 then
add endpoint to polygon. continue to add next endpoint until it does not touch Cv1
*/
if ( !cv1VxTouchCv2[nextCv1Idx]
&& ( cv1VxTouchCv2[cv1Idx] || ( intersectedCv2EdgeIdxs.size() ) ) ) // Two touches along edge also qualifies
if ( !cv1VxTouchCv2[nextCv1Idx] &&
( cv1VxTouchCv2[cv1Idx] || ( intersectedCv2EdgeIdxs.size() ) ) ) // Two touches along edge also qualifies
{
if ( lastIntersection < intersectedCv2EdgeIdxs.size() )
{
@ -540,7 +553,9 @@ bool GeometryTools::calculateOverlapPolygonOfTwoQuads(std::vector<IndexType> * p
// Continue the polygon along the Cv2 edges as long as they touch cv1.
// Depending on the faces having opposite winding, which is guaranteed as long as
// no intersecting CVs share a connection
while (cv2VxTouchCv1[cv2Idx] && count < 4 && (cv2VxTouchCv1Edge[cv2Idx] == -1)) // Touch of edge is regarded as being outside, so we must stop
while (
cv2VxTouchCv1[cv2Idx] && count < 4 &&
( cv2VxTouchCv1Edge[cv2Idx] == -1 ) ) // Touch of edge is regarded as being outside, so we must stop
{
if ( polygon->empty() || polygon->back() != cv2CubeFaceIndices[cv2Idx] )
{
@ -566,17 +581,16 @@ bool GeometryTools::calculateOverlapPolygonOfTwoQuads(std::vector<IndexType> * p
// Sanity checks
if ( polygon->size() < 3 )
{
// cvf::Trace::show(cvf::String("Degenerated connection polygon detected. (Less than 3 vertexes) Cv's probably not in contact: %1 , %2").arg(m_ownerCvId).arg(m_neighborCvId));
// cvf::Trace::show(cvf::String("Degenerated connection polygon detected. (Less than 3 vertexes) Cv's probably
// not in contact: %1 , %2").arg(m_ownerCvId).arg(m_neighborCvId));
polygon->clear();
return false;
}
return true;
}
//--------------------------------------------------------------------------------------------------
/// This method assumes that all intersection and mid edge vertexes are created an are already
/// merged into all the polygons. We can also assume that all the connection polygons are completely
@ -587,7 +601,8 @@ bool GeometryTools::calculateOverlapPolygonOfTwoQuads(std::vector<IndexType> * p
// template <typename NodeArrayType, typename NodeType, typename IndicesArrayType, typename IndicesType>
// void setup( ArrayWrapper<NodeArrayType, NodeType> nodeArray, ArrayWrapper<IndicesArrayType, IndicesType> indices)
template <typename VerticeArrayType, typename PolygonArrayType, typename IndexType>
void GeometryTools::calculatePartiallyFreeCubeFacePolygon(ArrayWrapperConst<VerticeArrayType, cvf::Vec3d> nodeCoords,
void GeometryTools::calculatePartiallyFreeCubeFacePolygon(
ArrayWrapperConst<VerticeArrayType, cvf::Vec3d> nodeCoords,
ArrayWrapperConst<PolygonArrayType, IndexType> completeFacePolygon,
const cvf::Vec3d& faceNormal,
const std::vector<std::vector<IndexType>*>& faceOverlapPolygons,
@ -641,7 +656,8 @@ void GeometryTools::calculatePartiallyFreeCubeFacePolygon(ArrayWrapperConst<Vert
std::list<IndexType>::const_iterator polIt;
for ( polIt = resultPolygon.begin(); polIt != resultPolygon.end(); ++polIt )
{
cvf::Trace::show(cvf::String("%1 \t%2 %3 %4").arg((int)(*polIt))
cvf::Trace::show( cvf::String( "%1 \t%2 %3 %4" )
.arg( (int)( *polIt ) )
.arg( nodeCoords[*polIt].x() )
.arg( nodeCoords[*polIt].y() )
.arg( nodeCoords[*polIt].z() ) );
@ -658,7 +674,8 @@ void GeometryTools::calculatePartiallyFreeCubeFacePolygon(ArrayWrapperConst<Vert
cvf::Trace::show( "Connection " + cvf::String( (long long)cIdx ) );
for ( polIt = faceOverlapPolygons[cIdx]->begin(); polIt != faceOverlapPolygons[cIdx]->end(); ++polIt )
{
cvf::Trace::show(cvf::String("%1 \t%2 %3 %4").arg((int)(*polIt))
cvf::Trace::show( cvf::String( "%1 \t%2 %3 %4" )
.arg( (int)( *polIt ) )
.arg( nodeCoords[*polIt].x() )
.arg( nodeCoords[*polIt].y() )
.arg( nodeCoords[*polIt].z() ) );
@ -675,7 +692,6 @@ void GeometryTools::calculatePartiallyFreeCubeFacePolygon(ArrayWrapperConst<Vert
// merge the connection polygon into the main polygon,
// and remove the connection polygon from the merge able connection polygons.
for ( typename std::list<IndexType>::iterator pIt = resultPolygon.begin(); pIt != resultPolygon.end(); ++pIt )
{
// Set iterator to previous node in polygon
@ -703,7 +719,8 @@ void GeometryTools::calculatePartiallyFreeCubeFacePolygon(ArrayWrapperConst<Vert
if ( isConnectionPolygonMerged[opIdx] ) continue; // Already merged
// Find position of pIt vertex index in the current connection polygon
typename VxIdxToPolygonPositionMap::iterator vxIndexPositionInPolygonIt = polygonSearchMaps[opIdx].find(*pIt);
typename VxIdxToPolygonPositionMap::iterator vxIndexPositionInPolygonIt = polygonSearchMaps[opIdx].find(
*pIt );
if ( vxIndexPositionInPolygonIt != polygonSearchMaps[opIdx].end() )
{
@ -719,13 +736,16 @@ void GeometryTools::calculatePartiallyFreeCubeFacePolygon(ArrayWrapperConst<Vert
if ( hasSameWinding )
{
// Same winding as main polygon. We need to go the opposite way
if (startCPIt == faceOverlapPolygons[opIdx]->begin()) startCPIt = faceOverlapPolygons[opIdx]->end();
if ( startCPIt == faceOverlapPolygons[opIdx]->begin() )
startCPIt = faceOverlapPolygons[opIdx]->end();
--startCPIt;
}
else
{
// Opposite winding. Go forward when merging
++startCPIt; if (startCPIt == faceOverlapPolygons[opIdx]->end()) startCPIt = faceOverlapPolygons[opIdx]->begin();
++startCPIt;
if ( startCPIt == faceOverlapPolygons[opIdx]->end() )
startCPIt = faceOverlapPolygons[opIdx]->begin();
}
// Calculate possible new edge-to-edge angle and test against existing angle
@ -779,7 +799,8 @@ void GeometryTools::calculatePartiallyFreeCubeFacePolygon(ArrayWrapperConst<Vert
// Now remove all double edges
bool goneAround = false;
for ( typename std::list<IndexType>::iterator pIt = resultPolygon.begin(); pIt != resultPolygon.end() && !goneAround; ++pIt)
for ( typename std::list<IndexType>::iterator pIt = resultPolygon.begin(); pIt != resultPolygon.end() && !goneAround;
++pIt )
{
// Set iterator to next node in polygon.
typename std::list<IndexType>::iterator nextPIt = pIt;
@ -803,7 +824,8 @@ void GeometryTools::calculatePartiallyFreeCubeFacePolygon(ArrayWrapperConst<Vert
resultPolygon.erase( pIt );
resultPolygon.erase( prevPIt );
if ( resultPolygon.begin() == resultPolygon.end()) break; // Polygon has been completely removed. Nothing left. Break out of while
if ( resultPolygon.begin() == resultPolygon.end() )
break; // Polygon has been completely removed. Nothing left. Break out of while
pIt = nextPIt;
++nextPIt;
@ -818,8 +840,8 @@ void GeometryTools::calculatePartiallyFreeCubeFacePolygon(ArrayWrapperConst<Vert
--prevPIt;
}
if ( resultPolygon.begin() == resultPolygon.end()) break; // Polygon has been completely removed. Nothing left. Break out of for loop
if ( resultPolygon.begin() == resultPolygon.end() )
break; // Polygon has been completely removed. Nothing left. Break out of for loop
}
// Check for holes
@ -840,7 +862,8 @@ void GeometryTools::calculatePartiallyFreeCubeFacePolygon(ArrayWrapperConst<Vert
cvf::Trace::show( "Polygon: " );
for ( std::list<IndexType>::iterator pIt = resultPolygon.begin(); pIt != resultPolygon.end(); ++pIt )
{
cvf::Trace::show(cvf::String("%1 \t%2 %3 %4").arg((int)(*pIt))
cvf::Trace::show( cvf::String( "%1 \t%2 %3 %4" )
.arg( (int)( *pIt ) )
.arg( nodeCoords[*pIt].x() )
.arg( nodeCoords[*pIt].y() )
.arg( nodeCoords[*pIt].z() ) );
@ -857,8 +880,6 @@ void GeometryTools::calculatePartiallyFreeCubeFacePolygon(ArrayWrapperConst<Vert
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@ -869,8 +890,13 @@ void EdgeIntersectStorage<IndexType>::setVertexCount(size_t size)
}
template <typename IndexType>
void EdgeIntersectStorage<IndexType>::canonizeAddress(IndexType& e1P1, IndexType& e1P2, IndexType& e2P1, IndexType& e2P2,
bool& flipE1, bool& flipE2, bool& flipE1E2)
void EdgeIntersectStorage<IndexType>::canonizeAddress( IndexType& e1P1,
IndexType& e1P2,
IndexType& e2P1,
IndexType& e2P2,
bool& flipE1,
bool& flipE2,
bool& flipE1E2 )
{
flipE1 = e1P1 > e1P2;
flipE2 = e2P1 > e2P2;
@ -907,9 +933,14 @@ void EdgeIntersectStorage<IndexType>::canonizeAddress(IndexType& e1P1, IndexType
///
//--------------------------------------------------------------------------------------------------
template <typename IndexType>
void EdgeIntersectStorage<IndexType>::addIntersection(IndexType e1P1, IndexType e1P2, IndexType e2P1, IndexType e2P2,
IndexType vxIndexIntersectionPoint, GeometryTools::IntersectionStatus intersectionStatus,
double fractionAlongEdge1, double fractionAlongEdge2)
void EdgeIntersectStorage<IndexType>::addIntersection( IndexType e1P1,
IndexType e1P2,
IndexType e2P1,
IndexType e2P2,
IndexType vxIndexIntersectionPoint,
GeometryTools::IntersectionStatus intersectionStatus,
double fractionAlongEdge1,
double fractionAlongEdge2 )
{
static bool flipE1;
static bool flipE2;
@ -935,15 +966,18 @@ void EdgeIntersectStorage<IndexType>::addIntersection(IndexType e1P1, IndexType
m_edgeIntsectMap[e1P1][e1P2][e2P1][e2P2] = iData;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
template <typename IndexType>
bool EdgeIntersectStorage<IndexType>::findIntersection(IndexType e1P1, IndexType e1P2, IndexType e2P1, IndexType e2P2,
IndexType* vxIndexIntersectionPoint, GeometryTools::IntersectionStatus* intersectionStatus,
double* fractionAlongEdge1, double* fractionAlongEdge2)
bool EdgeIntersectStorage<IndexType>::findIntersection( IndexType e1P1,
IndexType e1P2,
IndexType e2P1,
IndexType e2P2,
IndexType* vxIndexIntersectionPoint,
GeometryTools::IntersectionStatus* intersectionStatus,
double* fractionAlongEdge1,
double* fractionAlongEdge2 )
{
static bool flipE1;
static bool flipE2;
@ -985,6 +1019,4 @@ bool EdgeIntersectStorage<IndexType>::findIntersection(IndexType e1P1, IndexType
return true;
}
}
} // namespace cvf

View File

@ -17,9 +17,8 @@ TEST( RiaPolyArcLineSampler, Basic )
#if 1
for ( size_t pIdx = 0; pIdx < sampledPoints.size(); ++pIdx )
{
std::cout << sampledPoints[pIdx].x() << " "
<< sampledPoints[pIdx].y() << " "
<< sampledPoints[pIdx].z() << " md: " << mds[pIdx] << std::endl;
std::cout << sampledPoints[pIdx].x() << " " << sampledPoints[pIdx].y() << " " << sampledPoints[pIdx].z()
<< " md: " << mds[pIdx] << std::endl;
}
#endif
EXPECT_EQ( 55, (int)sampledPoints.size() );