viennagrid_numeric compare(viennagrid::mesh const & mesh1, NTreeNode * ntree1, viennagrid::quantity_field const & solution1,
viennagrid::mesh const & mesh2, NTreeNode * ntree2, viennagrid::quantity_field const & solution2,
viennagrid_numeric inside_epsilon, viennagrid_numeric epsilon)
{
typedef viennagrid::result_of::const_element_range<MeshType>::type ConstElementRangeType;
typedef viennagrid::result_of::iterator<ConstElementRangeType>::type ConstElementRangeIterator;
ConstElementRangeType vertices1(mesh1, 0);
ConstElementRangeType vertices2(mesh2, 0);
ConstElementRangeType lines1(mesh1, 1);
ConstElementRangeType lines2(mesh2, 1);
ConstElementRangeType triangles1(mesh1, 2);
ConstElementRangeType triangles2(mesh2, 2);
viennagrid_numeric distance_vertices1 = compare_on_vertices(mesh1, ntree1, solution1, mesh2, ntree2, solution2, inside_epsilon);
viennagrid_numeric distance_vertices2 = compare_on_vertices(mesh2, ntree2, solution2, mesh1, ntree1, solution1, inside_epsilon);
viennagrid_numeric worst_distance = -1;
for (ConstElementRangeIterator lit1 = lines1.begin(); lit1 != lines1.end(); ++lit1)
{
PointType l1p1 = viennagrid::get_point( viennagrid::vertices(*lit1)[0] );
PointType l1p2 = viennagrid::get_point( viennagrid::vertices(*lit1)[1] );
for (ConstElementRangeIterator lit2 = lines2.begin(); lit2 != lines2.end(); ++lit2)
{
PointType l2p1 = viennagrid::get_point( viennagrid::vertices(*lit2)[0] );
PointType l2p2 = viennagrid::get_point( viennagrid::vertices(*lit2)[1] );
bool intersect = viennagrid::element_line_intersect(*lit2, l1p1, l1p2, epsilon);
if (intersect)
{
std::pair<PointType, PointType> cp = viennagrid::closest_points(*lit1, *lit2);
if (!(viennagrid::detail::is_equal(epsilon, cp.first, l1p1) ||
viennagrid::detail::is_equal(epsilon, cp.first, l1p2) ||
viennagrid::detail::is_equal(epsilon, cp.first, l2p1) ||
viennagrid::detail::is_equal(epsilon, cp.first, l2p2)))
{
viennagrid_numeric value1 = get_value(mesh1, ntree1, solution1, cp.first, inside_epsilon);
viennagrid_numeric value2 = get_value(mesh2, ntree2, solution2, cp.first, inside_epsilon);
if ((value1 < 0) || (value2 < 0))
continue;
viennagrid_numeric distance = std::abs(value1 - value2);
if (worst_distance < distance)
worst_distance = distance;
}
}
}
}
return std::max( std::max(distance_vertices1, distance_vertices2), worst_distance );
}
void CPlayer::drawPivot()
{
auto sides(hexagonGame.getSides());
float div{360.f / sides * 0.5f}, radius{hexagonGame.getRadius() * 0.75f};
Color colorMain{hexagonGame.getColorMain()}, colorB{hexagonGame.getColor(1)};
if(Config::getBlackAndWhite()) colorB = Color::Black;
ssvs::VertexVector<sf::PrimitiveType::Quads> vertices2(4);
ssvs::VertexVector<sf::PrimitiveType::Triangles> vertices3(3);
for(auto i(0u); i < sides; ++i)
{
float sAngle{div * 2.f * i};
Vec2f p1{getOrbitFromDeg(startPos, sAngle - div, radius)};
Vec2f p2{getOrbitFromDeg(startPos, sAngle + div, radius)};
Vec2f p3{getOrbitFromDeg(startPos, sAngle + div, radius + baseThickness)};
Vec2f p4{getOrbitFromDeg(startPos, sAngle - div, radius + baseThickness)};
vertices2.emplace_back(p1, colorMain);
vertices2.emplace_back(p2, colorMain);
vertices2.emplace_back(p3, colorMain);
vertices2.emplace_back(p4, colorMain);
vertices3.emplace_back(p1, colorB);
vertices3.emplace_back(p2, colorB);
vertices3.emplace_back(startPos, colorB);
}
if(!hexagonGame.getStatus().drawing3D) hexagonGame.render(vertices3);
hexagonGame.render(vertices2);
}
