INLINE Real metric_edge_length(
Few<Vector<dim>, 2> p, Few<Matrix<dim, dim>, 2> ms) {
auto v = p[1] - p[0];
auto l_a = metric_length(ms[0], v);
auto l_b = metric_length(ms[1], v);
return edge_length(l_a, l_b);
}
typename viennagrid::result_of::coord<typename PointAccessorT::value_type>::type aspect_ratio_impl(PointAccessorT const point_accessor, ElementT const & element, NumericLimitsT)
{
typedef typename PointAccessorT::value_type PointType;
typedef typename viennagrid::result_of::coord<PointType>::type NumericType;
typedef typename viennagrid::result_of::const_line_range<ElementT>::type LinesOnElementRangeType;
typedef typename viennagrid::result_of::iterator<LinesOnElementRangeType>::type LinesOnElementRangeIterator;
PointType circum_center = viennagrid::circumcenter(point_accessor, element);
NumericType circum_radius = viennagrid::norm_2( point_accessor(viennagrid::vertices(element)[0]) - circum_center );
LinesOnElementRangeType lines(element);
NumericType min_length = 2 * circum_radius;
std::vector<NumericType> edge_length( lines.size() );
// unsigned int index = 0;
for (LinesOnElementRangeIterator lit = lines.begin(); lit != lines.end(); ++lit)
{
PointType line = point_accessor( viennagrid::vertices(*lit)[0] ) -
point_accessor( viennagrid::vertices(*lit)[1] );
NumericType length = viennagrid::norm_2( line );
if (length < min_length)
min_length = length;
}
return circum_radius / min_length;
}
HalfEdge * element_max_edge( const Element *el, gdouble *length )
{
g_return_val_if_fail( el != NULL, NULL );
HalfEdge *he_iter = el->adjacent_halfedge;
HalfEdge *max_he = he_iter;
gdouble max_length = edge_length( he_iter->edge );
for ( he_iter = he_iter->next; he_iter != el->adjacent_halfedge; he_iter = he_iter->next )
{
gdouble l = edge_length( he_iter->edge );
if ( l > max_length )
{
max_length = l;
max_he = he_iter;
}
}
if ( length != NULL )
*length = max_length;
return max_he;
}
vec4 control_polygon_length(in samplerBuffer data,
in int offset,
in int u,
in int v)
{
int i, j;
vec4 output = vec4(0.0);
vec4 first, second;
mat4 mvp = projection_matrix * view_matrix * model_matrix;
// 2------3
// | |
// | |
// 0------1
/*For Edge 01*/
for ( i = 1; i < u; ++i ) {
output[0] += edge_length(texelFetch(data, offset + i).xyz, texelFetch(data, offset + i - 1).xyz);
}
/*For Edge 13*/
for ( i = 2 * u - 1; i < u * v; i += u ) {
output[1] += edge_length(texelFetch(data, offset + i).xyz, texelFetch(data, offset + i - u).xyz);
}
/*For Edge 23*/
for ( i = u * v - u + 1; i < u * v; ++i ) {
output[2] += edge_length(texelFetch(data, offset + i).xyz, texelFetch(data, offset + i - 1).xyz);
}
/*For Edge 02*/
for ( i = u; i <= u * v - u; i += u ) {
output[3] += edge_length(texelFetch(data, offset + i).xyz, texelFetch(data, offset + i - u).xyz);
}
/**/
return output;
}
void UpdateDesiredMeshDensity::computeExistingLengths()
{
QSet<int> all_bcs = GuiMainWindow::pointer()->getAllBoundaryCodes();
QSet<int> fixed_bcs = all_bcs - m_BoundaryCodes;
QVector<double> edge_length(m_Grid->GetNumberOfPoints(), 1e99);
QVector<int> edge_count(m_Grid->GetNumberOfPoints(), 0);
m_Fixed.fill(false, m_Grid->GetNumberOfPoints());
EG_VTKDCC(vtkIntArray, cell_code, m_Grid, "cell_code");
for (vtkIdType id_cell = 0; id_cell < m_Grid->GetNumberOfCells(); ++id_cell) {
if (isSurface(id_cell, m_Grid)) {
if (fixed_bcs.contains(cell_code->GetValue(id_cell))) {
vtkIdType N_pts, *pts;
m_Grid->GetCellPoints(id_cell, N_pts, pts);
QVector<vec3_t> x(N_pts);
for (int i = 0; i < N_pts; ++i) {
m_Grid->GetPoint(pts[i], x[i].data());
m_Fixed[pts[i]] = true;
}
for (int i = 0; i < N_pts; ++i) {
int j = i + 1;
if (j >= N_pts) {
j = 0;
}
double L = (x[i] - x[j]).abs();
edge_length[pts[i]] = min(edge_length[pts[i]], L);
edge_length[pts[j]] = min(edge_length[pts[j]], L);
++edge_count[pts[i]];
++edge_count[pts[j]];
}
}
}
}
EG_VTKDCN(vtkDoubleArray, characteristic_length_desired, m_Grid, "node_meshdensity_desired");
for (vtkIdType id_node = 0; id_node < m_Grid->GetNumberOfPoints(); ++id_node) {
if (edge_count[id_node] > 0) {
if (edge_length[id_node] > 1e98) {
EG_BUG;
}
characteristic_length_desired->SetValue(id_node, edge_length[id_node]);
}
}
}
void Boundary::fix_contours (bool silent) {
assert_boundary (*this);
if (!silent)
std::cerr << "fix_contours";
int deg_edges = 0;
int deg_spikes = 0;
std::vector <int> deg_con_indices;
Boundary::contour_iterator cit = contours_begin ();
Boundary::contour_iterator cit_end = contours_end ();
Boundary::edge_iterator eit, eit_end;
while (cit != cit_end) {
bool fixed_something = false;
eit = edges_begin (cit);
eit_end = edges_end (cit);
// remove spikes with exterior angle = pi
while (eit != eit_end) {
edge_iterator eit_next = eit;
++eit_next;
vec_t d = edge_vertex1 (eit_next);
d -= edge_vertex0 (eit);
if (d.norm () < VERTEX_MERGE_TOLERANCE) {
if (is_self_referential (eit)) {
// further processing is dangerous
goto deg_contour;
}
// remove spike. the norm-zero edge created by this
// operation is removed later
eit = remove_vertex1 (eit);
++deg_spikes;
--eit;
// remove_vertex1 could have removed our end
eit_end = edges_end (cit);
fixed_something = true;
} else {
eit = eit_next;
}
}
eit = edges_begin (cit);
// remove norm-zero edges
while (eit != eit_end) {
double len = edge_length (eit);
if (len < VERTEX_MERGE_TOLERANCE) {
if (is_self_referential (eit)) {
// further processing is dangerous
goto deg_contour;
}
++deg_edges;
eit = remove_vertex1 (eit);
// remove_vertex1 could have removed our end
eit_end = edges_end (cit);
fixed_something = true;
} else {
++eit;
}
}
if (!fixed_something)
++cit;
continue;
deg_contour:
// current contour has been reduced to or was a single-vertex
// contour. we mark it for later removal.
deg_con_indices.push_back (cit - contours_begin ());
++cit;
}
int deg_contours = (int)deg_con_indices.size ();
// remove degenerate contours
{
std::vector <int>::reverse_iterator it;
it = deg_con_indices.rbegin ();
for (; it != deg_con_indices.rend (); ++it) {
erase_contour_by_index (*it);
}
}
// final "status report"
if (!silent) {
std::cerr << "\n"
<< std::setw (4) << deg_contours << " deg. contours (removed)\n"
<< std::setw (4) << deg_spikes << " deg. spikes (removed)\n"
<< std::setw (4) << deg_edges << " deg. edges (removed)\n";
}
assert_boundary (*this);
}
INLINE Real iso_edge_length(Few<Vector<dim>, 2> p, Few<Real, 2> hs) {
auto real_l = norm(p[1] - p[0]);
auto l_a = real_l / hs[0];
auto l_b = real_l / hs[0];
return edge_length(l_a, l_b);
}
