コード例 #1
0
ファイル: cgal_utility.cpp プロジェクト: yangyanli/FPNN
void projectPointsToPlane(const std::vector<CgalPoint>& points, const CgalPlane& plane, std::vector<CgalPoint2>& coords_2d) {
  CgalPoint origin = plane.projection(points[0]);
  CgalVector base1 = plane.base1();
  CgalVector base2 = plane.base2();
  base1 = base1 / std::sqrt(base1.squared_length());
  base2 = base2 / std::sqrt(base2.squared_length());

  CgalLine base_line1(origin, base1);
  CgalLine base_line2(origin, base2);

  for (size_t i = 0, iEnd = points.size(); i < iEnd; ++i) {
    CgalPoint point = plane.projection(points[i]);
    CgalVector x_vector(origin, base_line1.projection(point));
    CgalVector y_vector(origin, base_line2.projection(point));
    double x = std::sqrt(x_vector.squared_length());
    double y = std::sqrt(y_vector.squared_length());
    x = x_vector * base1 < 0 ? -x : x;
    y = y_vector * base2 < 0 ? -y : y;
    coords_2d.push_back(CgalPoint2(x, y));
  }

  return;
}
コード例 #2
0
ファイル: chrobak_payne_drawing.hpp プロジェクト: Bia10/clrn
void chrobak_payne_straight_line_drawing(const Graph& g,
        PlanarEmbedding embedding,
        ForwardIterator ordering_begin,
        ForwardIterator ordering_end,
        GridPositionMap drawing,
        VertexIndexMap vm
                                        )
{

    typedef typename graph_traits<Graph>::vertex_descriptor vertex_t;
    typedef typename graph_traits<Graph>::edge_descriptor edge_t;
    typedef typename graph_traits<Graph>::vertex_iterator vertex_iterator_t;
    typedef typename PlanarEmbedding::value_type::const_iterator
    edge_permutation_iterator_t;
    typedef typename graph_traits<Graph>::vertices_size_type v_size_t;
    typedef std::vector<vertex_t> vertex_vector_t;
    typedef std::vector<v_size_t> vsize_vector_t;
    typedef std::vector<bool> bool_vector_t;
    typedef boost::iterator_property_map
    <typename vertex_vector_t::iterator, VertexIndexMap>
    vertex_to_vertex_map_t;
    typedef boost::iterator_property_map
    <typename vsize_vector_t::iterator, VertexIndexMap>
    vertex_to_vsize_map_t;
    typedef boost::iterator_property_map
    <typename bool_vector_t::iterator, VertexIndexMap>
    vertex_to_bool_map_t;

    vertex_vector_t left_vector(num_vertices(g),
                                graph_traits<Graph>::null_vertex()
                               );
    vertex_vector_t right_vector(num_vertices(g),
                                 graph_traits<Graph>::null_vertex()
                                );
    vsize_vector_t seen_as_right_vector(num_vertices(g), 0);
    vsize_vector_t seen_vector(num_vertices(g), 0);
    vsize_vector_t delta_x_vector(num_vertices(g),0);
    vsize_vector_t y_vector(num_vertices(g));
    vsize_vector_t x_vector(num_vertices(g),0);
    bool_vector_t installed_vector(num_vertices(g),false);

    vertex_to_vertex_map_t left(left_vector.begin(), vm);
    vertex_to_vertex_map_t right(right_vector.begin(), vm);
    vertex_to_vsize_map_t seen_as_right(seen_as_right_vector.begin(), vm);
    vertex_to_vsize_map_t seen(seen_vector.begin(), vm);
    vertex_to_vsize_map_t delta_x(delta_x_vector.begin(), vm);
    vertex_to_vsize_map_t y(y_vector.begin(), vm);
    vertex_to_vsize_map_t x(x_vector.begin(), vm);
    vertex_to_bool_map_t installed(installed_vector.begin(), vm);

    v_size_t timestamp = 1;
    vertex_vector_t installed_neighbors;

    ForwardIterator itr = ordering_begin;
    vertex_t v1 = *itr;
    ++itr;
    vertex_t v2 = *itr;
    ++itr;
    vertex_t v3 = *itr;
    ++itr;

    delta_x[v2] = 1;
    delta_x[v3] = 1;

    y[v1] = 0;
    y[v2] = 0;
    y[v3] = 1;

    right[v1] = v3;
    right[v3] = v2;

    installed[v1] = installed[v2] = installed[v3] = true;

    for(ForwardIterator itr_end = ordering_end; itr != itr_end; ++itr)
    {
        vertex_t v = *itr;

        // First, find the leftmost and rightmost neighbor of v on the outer
        // cycle of the embedding.
        // Note: since we're moving clockwise through the edges adjacent to v,
        // we're actually moving from right to left among v's neighbors on the
        // outer face (since v will be installed above them all) looking for
        // the leftmost and rightmost installed neigbhors

        vertex_t leftmost = graph_traits<Graph>::null_vertex();
        vertex_t rightmost = graph_traits<Graph>::null_vertex();

        installed_neighbors.clear();

        vertex_t prev_vertex = graph_traits<Graph>::null_vertex();
        edge_permutation_iterator_t pi, pi_end;
        pi_end = embedding[v].end();
        for(pi = embedding[v].begin(); pi != pi_end; ++pi)
        {
            vertex_t curr_vertex = source(*pi,g) == v ?
                                   target(*pi,g) : source(*pi,g);

            // Skip any self-loops or parallel edges
            if (curr_vertex == v || curr_vertex == prev_vertex)
                continue;

            if (installed[curr_vertex])
            {
                seen[curr_vertex] = timestamp;

                if (right[curr_vertex] != graph_traits<Graph>::null_vertex())
                {
                    seen_as_right[right[curr_vertex]] = timestamp;
                }
                installed_neighbors.push_back(curr_vertex);
            }

            prev_vertex = curr_vertex;
        }

        typename vertex_vector_t::iterator vi, vi_end;
        vi_end = installed_neighbors.end();
        for(vi = installed_neighbors.begin(); vi != vi_end; ++vi)
        {
            if (right[*vi] == graph_traits<Graph>::null_vertex() ||
                    seen[right[*vi]] != timestamp
               )
                rightmost = *vi;
            if (seen_as_right[*vi] != timestamp)
                leftmost = *vi;
        }

        ++timestamp;

        //stretch gaps
        ++delta_x[right[leftmost]];
        ++delta_x[rightmost];

        //adjust offsets
        std::size_t delta_p_q = 0;
        vertex_t stopping_vertex = right[rightmost];
        for(vertex_t temp = right[leftmost]; temp != stopping_vertex;
                temp = right[temp]
           )
        {
            delta_p_q += delta_x[temp];
        }

        delta_x[v] = ((y[rightmost] + delta_p_q) - y[leftmost])/2;
        y[v] = y[leftmost] + delta_x[v];
        delta_x[rightmost] = delta_p_q - delta_x[v];

        bool leftmost_and_rightmost_adjacent = right[leftmost] == rightmost;
        if (!leftmost_and_rightmost_adjacent)
            delta_x[right[leftmost]] -= delta_x[v];

        //install v
        if (!leftmost_and_rightmost_adjacent)
        {
            left[v] = right[leftmost];
            vertex_t next_to_rightmost;
            for(vertex_t temp = leftmost; temp != rightmost;
                    temp = right[temp]
               )
            {
                next_to_rightmost = temp;
            }

            right[next_to_rightmost] = graph_traits<Graph>::null_vertex();
        }
        else
        {
            left[v] = graph_traits<Graph>::null_vertex();
        }

        right[leftmost] = v;
        right[v] = rightmost;
        installed[v] = true;

    }

    graph::detail::accumulate_offsets
    (*ordering_begin,0,g,x,delta_x,left,right);

    vertex_iterator_t vi, vi_end;
    for(boost::tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
    {
        vertex_t v(*vi);
        drawing[v].x = x[v];
        drawing[v].y = y[v];
    }

}
コード例 #3
0
vector_t create_y_vector(crsMat_t crsMat, vector_t x_vector){
  vector_t y_vector ("Y VECTOR", crsMat.numRows());
  KokkosSparse::spmv("N", 1, crsMat, x_vector, 1, y_vector);
  return y_vector;
}