void R_s_k_2::draw_one_cost(const Edge& edge,
const FT min_value,
const FT max_value,
const bool view_ghost)
{
FT mass = m_dt.get_mass(edge);
if (mass == 0.0)
{
if (!view_ghost) return;
viewer->glColor3f(0.5f, 0.5f, 0.5f);
draw_edge(edge);
return;
}
if (m_dt.is_ghost(edge))
{
if (!view_ghost) return;
viewer->glColor3f(0.5f, 0.5f, 0.5f);
draw_edge(edge);
return;
}
FT value = m_dt.get_cost(edge).finalize(m_alpha);
FT color = (value - min_value) / (max_value - min_value);
viewer->glColor3d(0.0, 1.0-color, color); // [green, blue]
draw_edge(edge);
}
void draw_menu_iter(void)
{
static bool sparse = FALSE;
Simulation *sim = stgs.linked_sim;
#if LOOP_OPT_STEPS
static size_t prev_steps = 0;
bool do_draw = sim->steps-prev_steps >= exp(max(stgs.speed-LOOP_OPT_SPEED, 0));
if (do_draw) {
#endif
draw_dir_arrow();
draw_function();
draw_steps();
#if LOOP_OPT_STEPS
prev_steps = sim->steps;
}
#endif
if (!sparse && is_grid_sparse(sim->grid)) {
draw_edge();
sparse = TRUE;
do_draw = TRUE;
}
#if LOOP_OPT_STEPS
if (do_draw) {
#endif
wnoutrefresh(menuw);
#if LOOP_OPT_STEPS
}
#endif
}
int Graf::save_svg(ostream &out)
{
if(currentLayout && n>0)
{
out << head_svg;
int maxx = 0,maxy=0,v,cx,cy,cindex;
for(cindex=0;cindex<n;cindex++)
{
Nod& cnode = getNode(cindex);
if(maxx < cnode.x) maxx = cnode.x;
if(maxy < cnode.y) maxy = cnode.y;
}
maxx += 40; maxy += 40;
cx = (maxx / 100) + (maxx % 100 ? 1 : 0);
cy = (maxy / 100) + (maxy % 100 ? 1 : 0);
put_viewbox(out,cx,cy);
for(v=0;v<capacitate;v++)
if(lnod[v].alocat)
{
Muchie *cap;
cx = lnod[v].x; cy = lnod[v].y;
for(cap=lnod[v].first;cap;cap=cap->next)
if(cap->v > v)
draw_edge(out,cx,cy,lnod[cap->v].x,lnod[cap->v].y);
}
for(v=0;v<capacitate;v++)
if(lnod[v].alocat)
draw_node(out,v,lnod[v].x,lnod[v].y);
out << svg_end;
return 1;
}
else return 0;
}
static void draw_subtree_edges (tsp_bbnode *bbnode, int depth, int maxdepth,
double upbound)
{
if (bbnode->child0 != (tsp_bbnode *) NULL &&
(maxdepth <= 0 || depth < maxdepth) &&
bbnode->child0->lowerbound <= upbound - 1.0) {
draw_edge (bbnode, bbnode->child0);
draw_subtree_edges (bbnode->child0, depth+1, maxdepth, upbound);
}
if (bbnode->child1 != (tsp_bbnode *) NULL &&
(maxdepth <= 0 || depth < maxdepth) &&
bbnode->child1->lowerbound <= upbound - 1.0) {
draw_edge (bbnode, bbnode->child1);
draw_subtree_edges (bbnode->child1, depth+1, maxdepth, upbound);
}
}
void R_s_k_2::draw_pedges(const float line_width)
{
int nb_edges = 0;
int nb_pinned = 0;
int nb_cyclic = 0;
int nb_discart = 0;
FT min_value = (std::numeric_limits<FT>::max)();
FT max_value = -(std::numeric_limits<FT>::max)();
std::vector<FT> values;
std::vector<Edge> edges;
for (Finite_edges_iterator ei = m_dt.finite_edges_begin(); ei != m_dt.finite_edges_end(); ++ei)
{
Edge edge = *ei;
for (unsigned int i = 0; i < 2; ++i)
{
if (m_dt.is_pinned(edge))
{
nb_pinned++;
continue;
}
if (m_dt.is_target_cyclic(edge))
{
nb_cyclic++;
continue;
}
PEdge pedge;
bool ok = create_pedge(edge, pedge);
if (ok)
{
edges.push_back(edge);
values.push_back(pedge.priority());
min_value = (std::min)(min_value, values.back());
max_value = (std::max)(max_value, values.back());
}
else
{
nb_discart++;
viewer->glColor3f(1.0, 0.0, 1.0);
draw_edge(edge);
}
edge = m_dt.twin_edge(edge);
nb_edges++;
}
}
if (min_value == max_value) max_value += 1.0;
std::size_t N = values.size();
for (unsigned int i = 0; i < N; ++i)
draw_one_pedge(edges[i], values[i], min_value, max_value, line_width);
std::cout << "There are: " << N << " pedges"
<< " x " << nb_discart << " discarted"
<< " x " << nb_pinned << " pinned"
<< " x " << nb_cyclic << " cyclic"
<< " = " << nb_edges << " edges"
<< std::endl;
}
void CLevelGraph::draw_vertex (const int &vertex_id)
{
CGameGraph::const_iterator I,E;
const CGameGraph &graph = ai().game_graph();
graph.begin (vertex_id,I,E);
for ( ; I != E; ++I) {
int neighbour_id = graph.value(vertex_id,I);
if (neighbour_id < vertex_id)
draw_edge (vertex_id,neighbour_id);
}
}
void R_s_k_2::draw_edges(const float line_width,
const float red,
const float green,
const float blue)
{
viewer->glLineWidth(line_width);
for (Finite_edges_iterator ei = m_dt.finite_edges_begin();
ei != m_dt.finite_edges_end(); ei++)
{
Edge edge = *ei;
Edge twin = m_dt.twin_edge(edge);
if (m_dt.is_pinned(edge) && m_dt.is_pinned(twin))
viewer->glColor3f(0.9f,0.9f,0.75f);
else
viewer->glColor3f(red,green,blue);
draw_edge(edge);
}
}
void draw_menu_full(void)
{
draw_edge();
draw_logo();
draw_color_list();
draw_init_size();
draw_direction();
draw_speed();
draw_function();
draw_control_buttons();
draw_io_buttons();
draw_size();
draw_steps();
draw_labels();
wnoutrefresh(menuw);
if (dialogw) {
draw_dialog();
}
}
/* Dibuja las aristas para cada nodo de esta celda */
static void draw_raw_links(cairo_t* cr, Zone* cell)
{
cairo_set_line_width(cr, 2 * LINE_SIZE);
/* Por cada nodo de la celda */
for(int i = 0; i < cell -> building_count; i++)
{
/* La arista toma el color del nodo */
color_dip(cr, cell -> buildings[i] -> color);
for(int j = 0; j < cell -> buildings[i] -> link_count; j++)
{
draw_edge(cr, cell-> buildings[i], cell-> buildings[i]-> linked[j]);
/* La dibujamos en el lienzo */
color_dip(cr, cell-> buildings[i] -> color);
cairo_set_line_width(cr,2 * LINE_SIZE);
cairo_stroke(cr);
}
/* Marcamos que ya pasamos por este nodo en esta pasada */
cell -> buildings[i] -> drawn = draw_count;
}
}
void R_s_k_2::draw_relevance(const float line_width, const int nb)
{
MultiIndex mindex;
FT min_value = (std::numeric_limits<FT>::max)();
FT max_value = -(std::numeric_limits<FT>::max)();
unsigned int nb_initial = 0;
for (Finite_edges_iterator ei = m_dt.finite_edges_begin(); ei != m_dt.finite_edges_end(); ++ei)
{
Edge edge = *ei;
if (m_dt.is_ghost(edge)) continue;
FT value = m_dt.get_edge_relevance(edge); // >= 0
nb_initial++;
min_value = (std::min)(min_value, value);
max_value = (std::max)(max_value, value);
mindex.insert(PEdge(edge, value));
}
if (min_value == max_value) max_value += 1.0;
viewer->glLineWidth(line_width);
int nb_remove = (std::min)(nb, int(mindex.size()));
viewer->glColor3d(0.5, 0.1, 0.1);
for (int i = 0; i < nb_remove; ++i)
{
PEdge pedge = *(mindex.get<1>()).begin();
(mindex.get<0>()).erase(pedge);
}
viewer->glColor3d(0.0, 0.5, 0.0);
while (!mindex.empty())
{
PEdge pedge = *(mindex.get<1>()).begin();
(mindex.get<0>()).erase(pedge);
draw_edge(pedge.edge());
}
}
