Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from http://www.ncbi.nlm.nih.gov/IEB/ToolBox/CPP_DOC/doxyhtml/phylo__tree__render_8cpp_source.html below:

NCBI C++ ToolKit: src/gui/widgets/phylo_tree/phylo_tree_render.cpp Source File

m_UseSplines =

;

m_RotatedLabels =

;

m_ForceSquare =

;

m_RegenerateTexture =

;

m_LabelViewPct = 0.6f;

m_RenderScale =

;

m_pMouseZoomHandler =

;

m_SwitchedLayout =

;

m_ValidLayout = eNeedLayoutAndSize;

m_DistanceBarLowerLeft =

;

m_RasterRect.Init(0, 0, m_DimX, m_DimY);

m_BufferdRenderTime = 0.0f;

m_HighlightLongerEdges =

;

m_HighlightFunctionK = 50.0f;

m_HighlightFunctionMidpoint = 90.0f;

m_HighlightIntensity = 1.0f;

sub_menu->

(

, &m_BufferdRenderTime);

sub_menu->

(

, &m_HighlightFunctionK, 50.0f, 1.0f, 500.0f, 10.0f);

sub_menu->

(

, &m_HighlightFunctionMidpoint);

: m_DimX(width), m_DimY(height)

(node_size > 0.0f) {

(node_size > 0.0f) {

node_size_scaler = 1.0f;

(!node.

() && node_size > 2.0f) {

node_size_scaler = 0.5f;

gl.

((

)p.

(), (

)p.

(), 0.0);

gl.

(0.0f, 0.0f, 0.0f);

gl.

(GL_LINE_STIPPLE);

gl.

(GL_LINES);

gl.

(-node_size, -node_size);

gl.

(node_size, -node_size);

gl.

(-node_size, node_size);

gl.

(node_size, node_size);

gl.

(-node_size, -node_size);

gl.

(-node_size, node_size);

gl.

(node_size, -node_size);

gl.

(node_size, node_size);

gl.

(0.0f, 0.0f, 0.0f);

gl.

(GL_LINE_STIPPLE);

gl.

(GL_LINES);

gl.

(1.0f, 0.0f, 0.0f, 0.3f);

gl.

(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

gl.

(GL_LINES);

rounded = default_scale;

(default_scale < 1.0) {

(rounded < 1.0) {

rounded = default_scale*multiplier;

rounded = (double)((

)(floor(rounded) + 0.5));

rounded = rounded / multiplier;

(rounded > 10.0) {

rounded = default_scale*multiplier;

rounded = (double)((

)(floor(rounded) + 0.5));

rounded = rounded / multiplier;

kSpacing = 4.0f;

total_height = vp_height * (1.0 / pct_visible);

visible_highlighted_nodes =

(total_height / kSpacing, tree_size);

(dist_between_nodes < 0.5f)

(edge_node !=

) {

(sel_edge_node !=

) {

(filler_points_node !=

) {

(sel_filler_points_node !=

) {

(edge_node !=

) {

(sel_edge_node !=

) {

(filler_points_node !=

) {

filler_points_node->

().

(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

(sel_filler_points_node !=

) {

sel_filler_points_node->

().

(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

final_len = target_len;

base_ypos = 20.0f;

base_xpos = 2.0f*

;

(1.5f*target_len + 20.0f);

base_xpos =

(0.0f, base_xpos);

final_len = target_len * rounded/default_scale;

sprintf(buf_round,

,

, rounded);

gl.

(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

gl.

(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

gl.

(GL_LINES);

gl.

(base_xpos, base_ypos);

gl.

(base_xpos, base_ypos + bar_height);

gl.

(base_xpos, base_ypos + bar_height/2.0f);

gl.

(base_xpos + final_len, base_ypos + bar_height/2.0f);

gl.

(base_xpos + final_len, base_ypos);

gl.

(base_xpos + final_len, base_ypos + bar_height);

tx = base_xpos + (float)

;

ty = base_ypos + bar_height/2.0f + (float)

;

std::vector<NodePointer>::iterator niter, erase_iter =

.end();

x = (*node).X();

y = (*node).Y();

gl.

(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

proj_len = proj_dir.

();

arrowhead_base(node_proj_pos.

() - proj_dir.

()*16.0f,

node_proj_pos.

() - proj_dir.

()*16.0f);

shaft_len = proj_len - 16.0f;

(shaft_len > 0.0f) {

gl.

(GL_TRIANGLE_STRIP);

gl.

(GL_TRIANGLES);

node_size_scaler = 1.0f;

(!active_node.Expanded() && s > 2.0f ) {

node_size_scaler = 0.5f;

gl.

((

)p.

(), (

)p.

(), 0.0);

gl.

(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

= 3.141592653589793238463f / num_lines;

gl.

(GL_TRIANGLE_STRIP);

angle =

;

(

= 0;

< num_lines - 1;

++) {

sina = sin(angle), cosa = cos(angle);

(event.Dragging()) {

wxPoint ms_pos =

.GetPosition();

sel_changed =

;

sel_changed =

;

(proj >

) {

dist =

.Length2();

(child_node, parent_node, c, parent_color);

line_colors.push_back(parent_color.

());

line_coords.push_back(p1);

line_coords.push_back(p2);

selected_edge =

(child_node, parent_node, c, parent_color);

(!selected_edge) {

line_colors.push_back(parent_color.

());

line_coords.push_back(p1);

line_coords.push_back(p2);

sel_line_colors.push_back(parent_color.

());

sel_line_colors.push_back(c.

());

sel_line_coords.push_back(p1);

sel_line_coords.push_back(p2);

selected_edge =

(child_node, parent_node, c, parent_color);

vector<CVect2<float> >& tree_edge_vec = selected_edge ? sel_edge_node_coords : edge_node_coords;

vector<CVect4<unsigned char> >&

= selected_edge ? sel_edge_node_colors : edge_node_colors;

vector<CVect3<float> >

;

cur_len = 0.0f;

closest =

;

(

=0;

<

.size()-1; ++

) {

cur_len += (

[

+1]-

[

]).Length();

pct_copied = cur_len/

;

col = parent_color*(1.0f-pct_copied) + c*pct_copied;

tree_edge_vec.push_back(p1);

tree_edge_vec.push_back(p2);

selected_edge =

(child_node, parent_node, c, parent_color);

vector<CVect2<float> >& tree_edge_vec = selected_edge ? sel_edge_node_coords : edge_node_coords;

vector<CVect4<unsigned char> >&

= selected_edge ? sel_edge_node_colors : edge_node_colors;

vector<CVect2<float> >

;

angle1 = (*parent_node)->GetAngle();

angle2 = (*child_node)->GetAngle();

steps =

((

)floorf((angle1-angle2)*resolution));

(steps < 2 || radius == 0.0f)

tdelta = -1.0f*(angle1-angle2)/(

)steps;

(

=0;

<=steps; ++

) {

closest =

;

(trace_line_coords !=

&&

.Length2() > 0.0f) {

(

= 0;

<

.size() - 1; ++

) {

.push_back(parent_color_uc);

(

==

.size() - 2)

.push_back(parent_color_uc);

tree_edge_vec.push_back(p1);

tree_edge_vec.push_back(p2);

trace_line_colors->push_back(trace_color_uc);

trace_line_colors->push_back(trace_color_uc);

trace_line_coords->push_back(pt2 -

);

trace_line_coords->push_back(pt2);

trace_point_coords->push_back(pt2 -

);

trace_point_colors->push_back(parent_color_uc);

.push_back(pt2);

(

= 0;

<

.size() - 1; ++

) {

.push_back(parent_color_uc);

(

==

.size() - 2)

.push_back(parent_color_uc);

tree_edge_vec.push_back(p1);

tree_edge_vec.push_back(p2);

selected_edge =

(child_node, parent_node, c, parent_color);

(!selected_edge) {

edge_node_colors.push_back(parent_color_uc);

edge_node_colors.push_back(parent_color_uc);

edge_node_colors.push_back(parent_color_uc);

edge_node_colors.push_back(c.

());

edge_node_coords.push_back(pt1);

edge_node_coords.push_back(mid_point);

edge_node_coords.push_back(mid_point);

edge_node_coords.push_back(pt2);

sel_edge_node_colors.push_back(parent_color_uc);

sel_edge_node_colors.push_back(parent_color_uc);

sel_edge_node_colors.push_back(parent_color_uc);

sel_edge_node_colors.push_back(c.

());

sel_edge_node_coords.push_back(pt1);

sel_edge_node_coords.push_back(mid_point);

sel_edge_node_coords.push_back(mid_point);

sel_edge_node_coords.push_back(pt2);

cap_end = 100.0f / 512.0f;

= 3.141592653589793238463

- acosf(cap_end / sqrtf((1.0f - cap_end)*(1.0f - cap_end) + 0.5f * 0.5f))

- atan2(0.5f, 1.0f - cap_end);

steps =

((

)1, circleSegments / 2);

(

= 0;

< steps; ++

) {

cosa = cosf(

);

sina = sinf(

);

vertices.push_back(

(cap_end*(1 - cosa), -cap_end * sina));

vertices.push_back(

(cap_end*(1 - cosa), cap_end*sina));

circleSegments,

vector<CVect2<float> > vb;

geom->SetVertexBuffer2D(vb);

->SetVBOGeom(geom);

->SetRotationZ(angle);

m(0, 0) = width_scale;

m(1, 1) = node_scale;

m(2, 2) = node_scale;

m(0, 3) = (**node).X() -

.X();

m(1, 3) = (**node).Y() -

.Y();

(*node)->SetNodePixelOffset(

->GetPixelOffset());

->GetState().BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

->GetState().Enable(GL_BLEND);

->GetState().Disable(GL_TEXTURE_2D);

->GetState().Disable(GL_TEXTURE_1D);

.SetAlpha(alpha);

->GetState().ColorC(

);

->GetState().ScaleInvarient(

);

glPushAttrib(GL_ALL_ATTRIB_BITS);

vector<CVect2<float> > vb;

(cosf((**node).GetAngle()) < 0.0f)

angle = (float)M_PI;

->SetRotationZ(angle);

(width_scale == 0.0f)

width_scale = node_scale;

m(0, 0) = width_scale;

m(1, 1) = node_scale;

m(2, 2) = node_scale;

m(0, 3) = (**node).X() -

.X();

m(1, 3) = (**node).Y() -

.Y();

(*node)->SetNodePixelOffset(

->GetPixelOffset());

->GetState().Color4f(

.GetRed(),

.GetGreen(),

.GetBlue(), alpha);

->GetState().ScaleInvarient(

);

vector<float>& color_coords,

this_node_size = def_node_size;

num_lines =

(

(2.0f, def_node_size) * 10.0f);

(collapsed_node) {

(

().GetApi()) {

color_coords.push_back(color_coord);

((**node).HasNodeMarker()) {

m(0,3) = (**node).X();

m(1,3) = (**node).Y();

vector<CVect2<float> > vb;

vector<CRgbaColor> cb;

target_alpha = 1.0f;

color_count = (**node).GetMarkerColors().size();

color_countf = (float)color_count;

((**node).GetNodeSize() > 0)

s2 = (**node).GetNodeSize();

s2 *= (**node).GetMarkerSize();

= 6.28f/(float)num_lines;

angle = 3.14159f/2.0f;

(

=0;

<num_lines;

++){

color_idx = (size_t)((((

)

)/(

)(num_lines)) * color_countf);

color_idx =

(color_idx, color_count-1);

c = (**node).GetMarkerColors()[color_idx];

s2*sinf(angle+

)));

((**node).GetBoundedDisplay()) {

c.

(1.0f - node_alpha);

recompute = (

!= (*node).GetDisplayLabel());

(*node).SetLabelRect(

);

(*node).SetDisplayLabel(

);

.Init(po.

(), po.

(), po.

() + pixel_size.

(), po.

() + pixel_size.

());

(*node).SetLabelRect(

);

(*node).SetDisplayLabel(

);

(*node).SetDisplayLabel(

);

& layout_type)

(!(*node).GetLabel().empty()) {

(*node).GetSubtreeBoundary()->ComputeShapes(

boundary_pts, scale, node_pos, layout_type);

(x1 > x2)

(x1, x2);

(y1 > y2)

(y1, y2);

std::vector<ProjectionElement>& xexts,

std::vector<ProjectionElement>& yexts,

goal = ((float)(

.Right()-

.Left()))/1e04f;

= 1e10f;

prev_delta = 1e10f;

viewport_x, viewport_y;

left =

.Left();

right =

.Right();

top =

.Top();

bottom =

.Bottom();

(

> goal &&

++ < max_iterations

) {

prev_delta =

;

viewport_maxx = -1e10f;

viewport_minx = 1e10f;

viewport_maxy = -1e10f;

viewport_miny = 1e10f;

node_maxx = -1e10f;

node_minx = 1e10f;

node_maxy = -1e10f;

node_miny = 1e10f;

label_zoom = 1.0f;

distance_between_nodes =

label_zoom =

(1.0f, distance_between_nodes/height);

(

=0;

<xexts.size(); ++

) {

(xexts[

].m_NodeCoord*vp_width - left*vp_width)/(right-left);

node_maxx =

(viewport_x, node_maxx);

node_minx =

(viewport_x, node_minx);

xexts[

].m_ProjectionCood = viewport_x;

viewport_maxx = node_maxx;

viewport_minx = node_minx;

node_extents.

(viewport_maxx);

node_extents.

(viewport_minx);

(

=0;

<xexts.size(); ++

) {

viewport_x = xexts[

].m_ProjectionCood;

offsetx = xexts[

].m_PixelOffset*label_zoom;

overlap_x = (node_maxx - viewport_x);

overlap_x = (viewport_x - node_minx);

(non_overlap_x, scaled_width);

offsetx = (offsetx >= 0.0f) ? usable_offsetx : -usable_offsetx;

(offsetx != 0.0f) {

viewport_x += offsetx;

viewport_maxx =

(viewport_x, viewport_maxx);

viewport_minx =

(viewport_x, viewport_minx);

text_extents.

(viewport_maxx);

text_extents.

(viewport_minx);

(

=0;

<yexts.size(); ++

) {

(yexts[

].m_NodeCoord*vp_height - bottom*vp_height)/(top-bottom);

viewport_maxy =

(viewport_y, viewport_maxy);

viewport_miny =

(viewport_y, viewport_miny);

node_maxy =

(viewport_y, node_maxy);

node_miny =

(viewport_y, node_miny);

yexts[

].m_ProjectionCood = viewport_y;

viewport_maxy = node_maxy;

viewport_miny = node_miny;

node_extents.

(viewport_maxy);

node_extents.

(viewport_miny);

(

=0;

<yexts.size(); ++

) {

viewport_y = yexts[

].m_ProjectionCood;

offsety = yexts[

].m_PixelOffset*label_zoom;

overlap_y = (node_maxy - viewport_y);

overlap_y = (viewport_y - node_miny);

offsety = (offsety >= 0.0f) ? usable_offsety : -usable_offsety;

(offsety != 0.0f) {

viewport_y += offsety;

viewport_maxy =

(viewport_y, viewport_maxy);

viewport_miny =

(viewport_y, viewport_miny);

text_extents.

(viewport_maxy);

text_extents.

(viewport_miny);

(viewport_maxx != -1e10f) {

(

(rd) > 0.0f) {

off = (rd/vp_width)*(right-left);

(viewport_minx != 1e10f) {

(

(ld) > 0.0f) {

off = (ld/vp_width)*(right-left);

( viewport_maxy != -1e10f) {

(

(

) > 0.0f) {

off = (

/vp_height)*(top-bottom);

( viewport_miny != 1e10f) {

(

(bd) > 0.0f) {

off = (bd/vp_height)*(top-bottom);

vp_extent.

(viewport_maxx-viewport_minx,

viewport_maxy-viewport_miny);

(right-left > 1000000 || top-bottom > 1000000)

.SetBottom(bottom);

(node_coord >

[0].m_NodeCoord) {

(

[0].m_PixelOffset <= pixel_offset) {

max_pixel_offset = -FLT_MAX;

resolved =

;

erase_from = -1;

(

ext_idx=0; ext_idx<

.size() && !resolved; ++ext_idx) {

max_pixel_offset =

(max_pixel_offset,

[ext_idx].m_PixelOffset);

(node_coord >

[ext_idx].m_NodeCoord) {

(pixel_offset >= max_pixel_offset) {

[ext_idx].m_PixelOffset = pixel_offset;

[ext_idx].m_NodeCoord = node_coord;

erase_from = ext_idx;

(node_coord ==

[ext_idx].m_NodeCoord) {

(pixel_offset > max_pixel_offset) {

[ext_idx].m_PixelOffset = pixel_offset;

erase_from = ext_idx;

(pixel_offset <= max_pixel_offset) {

(!resolved && pixel_offset > max_pixel_offset) {

(erase_from != (

)-1) {

erase_to = erase_from + 1;

(; erase_to <

.size(); ++erase_to)

(pixel_offset <

[erase_to].m_PixelOffset)

(erase_to > (

)(erase_from + 1))

(

=0;

<m_Extents.size(); ++

) {

dim << m_Extents[

].m_NodeCoord <<

<<

m_Extents[

].m_PixelOffset <<

);

GLdouble left_margin, top_margin, right_margin, bottom_margin;

->

(left_margin, top_margin, right_margin, bottom_margin);

(node->GetDisplayLabel().empty()) {

bottom =

.Bottom();

= (double)node->GetAngle();

(

> (M_PI / 2.0) &&

< ((3.0*M_PI) / 2.0)) {

cos_a = (float)cos(

);

sin_a = (float)sin(

);

(

corner = 0; corner < 4; ++corner) {

rpos(pos.

()*cos_a - pos.

()*sin_a, pos.

()*sin_a + pos.

()*cos_a);

vector<ProjectionElement>& yexts)

xexts = m_MaxX.m_Extents;

(

=0;

<m_MinX.m_Extents.size(); ++

) {

.m_NodeCoord = -

.m_NodeCoord;

.m_PixelOffset = -

.m_PixelOffset;

xexts.push_back(

);

yexts = m_MaxY.m_Extents;

(

=0;

<m_MinY.m_Extents.size(); ++

) {

.m_NodeCoord = -

.m_NodeCoord;

.m_PixelOffset = -

.m_PixelOffset;

yexts.push_back(

);

(

);

m_MaxX.DumpExtent(

);

(

);

m_MaxY.DumpExtent(

);

(

);

m_MinX.DumpExtent(

);

(

);

m_MinY.DumpExtent(

);

init_collision_info)

GLdouble top, bottom, left, right;

vector<ProjectionElement> xexts, yexts;

too_small =

;

left_pct = 0.0f;

right_pct = 0.0f;

bottom_pct = 0.0f;

top_pct = 0.0f;

(

.Width() > 0.0 &&

.Height() > 0.0) {

init_collision_info,

render_total.

();

(init_collision_info)

collision_resolution =

(ceilf(sqrtf(

->

())),

collision_resolution,

node_size = 0.0f;

node_size = def_node_size;

(edge_node !=

&&

narrow_edge_node !=

) {

narrow_edge_node->

(line_width > 1.0f);

sel_narrow_edge_node->

(line_width > 1.0f);

(

= 0;

< nodes.size(); ++

) {

(nodes[

]->GetName() ==

) {

nodes[

]->SetVisible(node_size > 0.0f);

(s.

() != scale2d.

() || s.

() != scale2d.

())

render_total.

();

rmgrgl->Disable(GL_TEXTURE_1D);

rmgrgl->Disable(GL_TEXTURE_2D);

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);

(rpdf ==

) {

(

<<

);

(pdf_font_face != current_font_face) {

.SetFontFace(pdf_font_face,

);

(pdf_font_face != current_font_face) {

.SetFontFace(current_font_face,

);

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);

glPushAttrib(GL_ALL_ATTRIB_BITS);

->SetTextureFiltering(GL_LINEAR_MIPMAP_LINEAR, GL_LINEAR);

renderer = [

, w, h]() {

GLint vp_width, vp_height;

vp_height = (

)(((

)vp_width)*((

)h) / (

)w);

vp_width = (

)(((

)vp_height)*((

)w) / (

)h);

->SetFilterMin(GL_LINEAR_MIPMAP_LINEAR);

glDrawBuffer(GL_BACK);

glPixelStorei(GL_PACK_ALIGNMENT, 1);

glReadBuffer(GL_BACK);

glReadPixels(0, 0, w, h, GL_RGBA, GL_UNSIGNED_BYTE, image->

());

->SetFilterMin(GL_LINEAR_MIPMAP_LINEAR);

(std::exception&)

& ycoord_limit)

xcoord_limit = 1.0f;

ycoord_limit = ((float)h)/(float)w;

ycoord_limit = 1.0f;

xcoord_limit = ((float)w)/(float)h;

(node !=

) {

node_alpha = 1.0f;

CPhyloTree::TSelState::iterator iter =

sel_state = (*iter).second;

node_color_idx = (**node).GetNodeFgColorIdx();

(node_color_idx != -1)

node_color_idx;

((**node).GetClusterColorIdx() != -1)

((**node).GetClusterColorIdx());

label_color_idx = (**node).GetLabelFgColorIdx();

(label_color_idx != -1)

label_color_idx;

parent_color_idx = -1;

selected_state =

;

(beg_state != end_state &&

color_idx = (**child_node).GetClusterColorIdx();

(color_idx == -1) {

color_idx = (**child_node).GetNodeEdColorIdx();

parent_color_idx = (**parent_node).GetNodeEdColorIdx();

(color_idx == -1){

transparency = 1.0f / (1.0f + powf(

,

c.

(1.0f - transparency);

selected_state =

;

(parent_color_idx != -1 && (**child_node).GetEdgeColorGradient()) {

selected_state;

height_factor,

vector<ProjectionElement> xexts, yexts;

label_height = (

)min_height;

width = ((float)

->

())*width_factor*tree_height;

computed_wh_ratio = width/min_height;

(computed_wh_ratio < wh_ratio) {

width = wh_ratio*min_height;

(computed_wh_ratio > wh_ratio) {

min_height = width/wh_ratio;

(0, 0, width, min_height);

(tmp_pane, xexts, yexts, vr, node_rect, text_rect, 1);

GLdouble top_margin, bottom_margin, left_margin, right_margin;

->

(top_margin, bottom_margin, left_margin, right_margin);

w = width + left_pixels + right_pixels + left_margin + right_margin;

h = min_height + top_pixels + bottom_pixels + top_margin + bottom_margin;

computed_wh_ratio = w/h;

(computed_wh_ratio < wh_ratio) {

(computed_wh_ratio > wh_ratio) {

.SetRight(

(w*1.05));

.SetTop(

(h*1.05));

GLdouble left, bottom, right, top;

vp_height -= (

)(bottom + top);

d = d - (d / 4.0f) + 1.0;

actual_size = 0.0f;

actual_size = node_size;

actual_size = def_node_size;

static const char * bgColor

void AddPixelRect(const CVect2< float > &pt, const CGlRect< float > &rect)

Add point in bounded area along with a rectangle based at that point and defined in pixels,...

void AddBoundedPoint(const CVect2< float > &pt)

Add point to be included in bounded area.

static EGUIState wxGetSelectState(const wxMouseEvent &event)

CGlAttrGuard - guard class for restoring OpenGL attributes.

CGlVboNode A rendering node that holds a vertex buffer object.

unsigned char * SetData(void)

virtual bool IsScaleMode() const

virtual EPanMode GetPanMode() const

float GetEdgeScore() const

void SetNodeDisplayColor(const CRgbaColor &c)

Set/get node color.

void SetNodeOffset(const CVect2< float > &o)

void SetVisible(bool b)

Flag to renderer to determine whether to draw label.

void SetTextDisplayColor(const CRgbaColor &c)

Set/get text color.

float GetNodeWidthScaler(const CPhyloTreeScheme *scheme) const

Get modified node width (length) for collapsed nodes. Default is 1.

float GetNodeLayoutSize(const CPhyloTreeScheme *scheme) const

Get modified node size - use this instead of GetDefaultNodeSize when doing layout (doesn't go to 0 if...

float GetAngle(void) const

float GetDefaultNodeSize(const CPhyloTreeScheme *scheme) const

Get modified node size - includes scaled (BOA) size.

void SetAlreadyDrawn(bool b)

Flag set after each drawing and cleared when rendering frame done.

void SetNodeDisplaySize(float s)

set/get node size (this is the result of GetDefaultNodeSize())

unsigned int GetVisibleNodes(void)

void ComputeLengthsFromRoot()

Create sorted array of distances of nodes from the parent (the m_LenDistribution array)

CTreeLabel GetTreeLabel() const

void Relabel(CPhyloTreeScheme *scheme, string labelFmt)

float GetClosestLen(float pct) const

Look in vector of sorted distances of nodes from the root and given a pct (0..1), return the distance...

double GetNormDistance(void)

CTreeGraphicsModel & GetModel()

Get model for rendering.

bool HasLenDistribution() const

Return true if data is available (for trees without distances, may not be)

void SetCollapsedLabel(CPhyloTree::TTreeIdx idx)

Collapse single node, do any relabeling if needed.

CVect2< float > GetNodeLabelOffset(const string &label, CPhyloTreeNode *node, IPhyloTreeLOD *lod, CVect2< float > &pixel_offset) const

Get label rectangle.

bool IsVisible(IPhyloTreeLOD *lod) const

string GetToolTipForNode(const CPhyloTree &tree, const CPhyloTreeNode &node, const string &format, const string &line_break)

string GetLabel(const CPhyloTree &tree, const CPhyloTreeNode &node) const

TVPUnit GetMinVerticalSeparation() const

void SetScheme(CPhyloTreeScheme &sl, const CPhyloTree *tree)

bool Expanded() const

Return true if node is currently not collapsed.

bool IsLeafEx() const

Return true if node is a leaf or is collapsed.

string & SetTooltipFormat(void)

const TLabelsVisibility & GetLabelVisibility(void) const

GLdouble & SetSize(TPhyloTreeSizes obj)

void SetFont(const CGlTextureFont &font)

string & SetLabelFormat(void)

void GetMargins(GLdouble &left, GLdouble &top, GLdouble &right, GLdouble &bottom) const

TSelectionVisibility GetSelectionVisibility() const

float GetNonSelectedAlpha() const

bool GetShowAllSelected() const

short GetColorIdx(TPhyloTreeObject obj, TPhyloTreeColors col)

TZoomBehavior GetZoomBehavior(const string &renderer)

CRgbaColor & SetColor(TPhyloTreeObject obj, TPhyloTreeColors col)

const CGlTextureFont & GetFont(void) const

GLdouble GetNodeSize() const

Tree subclass also has functions and data needed for rendering and selection.

bool SelectByPoint(const CVect2< float > &pt, bool sel, bool toggle, bool labels_visible, bool rotated_labels=false)

Determine if the point pt is close enough to a node to select or deselect it.

void ClearSelection()

Sets selection state of all nodes to eNotSelected and clears m_Selected.

void SetCurrentNode(TTreeIdx node_idx)

Set the index of the currently active node.

TTreeIdx GetCurrentNodeIdx() const

Return the index of the currently active node (may be Null()).

TTreeIdx TestForNode(const CVect2< float > &pt, bool labels_visible, bool rotated_labels=false)

Search nodes to find and return closest node to 'pt' that is within the max.

TTreeIdx FindNodeById(TID id) const

Return index of the node with the given id or Null().

void SetCurrentEdge(TTreeIdx child_idx, TTreeIdx parent_idx)

Set/Get the edge between the two specified nodes as current.

void GetSelState(TSelState &sel_state, TTreeIdx idx, bool sel_children=true, bool sel_parents=true) const

Given the selection of node 'idx', store the selection state (selected, traced, shared) of that node ...

bool SelectByRect(const CVect2< float > &ll, const CVect2< float > &ur, bool toggle)

Select or deselect all nodes in the rectangle bounded by ll and ur.

class CRgbaColor provides a simple abstraction for managing colors.

const CVect2< float > & GetScale() const

void ResizeGrid(const CGlPane &pane, float resolution, bool tilex=true, bool tiley=true)

vector< size_t > & GetNodes()

void UpdateScaled(const CGlPane &pane, const CVect2< float > &scale)

Only update scaled geometry (needed when zoom changes)

void Sync(const CGlPane &pane, CTreeGraphicsModel *m)

Insert data from model (labels/nodes)

virtual void UpdateVisibility(const TModelRect &r)

Find collisions between labels in visible regions to determine visiblity.

CGlVboNode * AddTempCollapsedNode(const vector< CVect2< float > > &vb)

Return a node that can be used to represent a collapsed tree.

vector< size_t > & GetNodeIndices()

Get all the nodes (indicies point to nodes in phylo tree)

CTreeTriFanNode * GetTriFanNode()

CTreeBoundaryNode * GetBoundaryNode()

CRgbaGradColorTable * GetColorTable()

Get color table used a 1D texture map for edges and nodes.

void SetRotateLabels(bool b)

CTreeCollisionModel2D & GetCollisionData()

virtual void ClearArrays()

Clear arrays prior to re-synching with the model.

virtual void SyncBuffers()

Update buffers as needed.

string GetFontName() const

CRgbaColor GetColor() const

TTreeIdx GetParent() const

Get node's parent.

TData & GetValue()

Return the value object for the node.

bool IsLeaf() const

Report whether this is a leaf node.

static TTreeIdx Null()

Static function that returns the null value.

static TTreeIdx Null()

Return the index value that represents a NULL node.

TNodeType & GetNode(TTreeIdx idx)

Return a reference to the node at the given index.

void SetLabelVisibility(bool b)

Set default label visibility (if false, no labels rendered, if true, labels which are turned on and v...

void CreateVbo(size_t numSements)

bool GetLabelVisibility() const

virtual void GHH_ReleaseMouse()=0

releases captured mouse

virtual void GHH_CaptureMouse()=0

captures mouse events in the hosting window for D&D

virtual void GHH_SetCursor(const wxCursor &cursor)=0

changes the cursor in the hosting window

virtual TVPUnit HMGH_GetVPPosByY(int y) const =0

virtual void HMGH_OnRefresh(void)=0

a chnage that requires a redraw but no GL buffer updates

virtual void HMGH_OnChanged(void)=0

a topology or selection (color) change (requires update to buffers

virtual void FireEditEvent(EPhyloTreeEditCommand ec)=0

void UpdateExtent(float node_coord, float pixel_offset, bool has_label)

Compare the new coordinate and pixel offset with the contents of m_Extents.

void DumpExtent(const string &dim)

write out values for debugging purposes

vector< ProjectionElement > m_Extents

Sorted (in decreasing order) set of coordinates and pixel offsets.

void DumpExtents()

Write output to log for debugging.

void ConsolidateExtents(vector< ProjectionElement > &xexts, vector< ProjectionElement > &yexts)

Combine together m_MaxX and m_MinX and m_MaxY and m_MinY.

CExtentDimension m_MinX

the 'leftmost' nodes, except that signs are flipped in order to allow uniform processing in all dimen...

CExtentDimension m_MaxY

Same as for m_MaxX values, but in y dimension.

CExtentDimension m_MinY

the 'bottommost' nodes, with signs flipped.

CExtentDimension m_MaxX

the 'rightmost' nodes and labels (includes the node with the largest x value, and any nodes to the le...

CPhyloTree::TTreeIdx TTreeIdx

virtual ~IPhyloTreeRender()

virtual void x_SetGlRenderOptions(CPhyloTreeDataSource &ds)

Set OpenGL rendering options that depend on layout chosen.

bool m_RenderScale

If true render a scale legend at the bottom of the screen.

float m_TreePixels

Sum of size (height) of all leaf nodes in pixels, without considering labels (accomodates nodes that ...

virtual float GetNodeLabelDist(const CPhyloTreeNode *node) const

float m_ClosestEdgeDistSq

bool LabelsVisible()

Return true if lables are visible according to rendering scheme and at current scale.

bool m_DistanceBarLowerLeft

CGlTextureFont * m_pLabelFont

virtual void RenderPdf(CGlPane &pane, CPhyloTreeDataSource &ds, CRef< CPdf > pdf)

float m_LabelViewPct

When sizing the tree to window, this is the maximum % of screen area (width) that will be allocated t...

void x_RenderSplineVbo(TTreeIdx child_node_idx, CPhyloTreeNode *child_node, CPhyloTreeNode *parent_node, vector< CVect2< float > > &edge_node_coords, vector< CVect4< unsigned char > > &edge_node_colors, vector< CVect2< float > > &sel_edge_node_coords, vector< CVect4< unsigned char > > &sel_edge_node_colors, const CVect3< float > &pt1, const CVect3< float > &pt2, const CVect3< float > &pt3, const CVect3< float > &pt4)

bool x_GetEdgeDist(const CVect2< float > &from, const CVect2< float > &to)

bool GetDistRendering(void) const

short GetNodeColorIdx(CPhyloTreeNode *node)

CVect2< float > m_RightClick

@ eSelRect

selecting a single glyph by point

CRef< CPhyloTreeScheme > m_SL

std::vector< CVect2< float > > m_SelectedEdge

Graphical representation of currently selected edge, if any, and data members needed for the selectio...

CPhyloTree::TSelState m_NodeSingleSelection

When user only wants to display a single, current selection from the selection set (including traced ...

int GetMaxLeavesVisible()

double ComputeScale(double default_scale, int &precision) const

virtual double ComputeDistFromPixels(CGlPane &pane, const CVect2< TModelUnit > &pixpos1, const CVect2< TModelUnit > &pixpos2) const

CTooltipInfo TTHH_GetTooltip(const wxRect &rect)

virtual bool Render(CGlPane &pane, CPhyloTreeDataSource &ds)

Returns false if rendering does not occur (e.g.

virtual float GetNodeLayoutSize(const CPhyloTreeNode *node) const

This is the height of the node for layout purposes.

TTreeIdx m_ActiveTooltipNode

void x_DrawBoundingAreas(CPhyloTreeNode *node)

void OnTimerLeftUp(wxTimerEvent &event)

CPhyloTreeLabel m_LabelExt

virtual float GetLabelViewPct() const

CVect2< float > m_ClosestEdgeDir

void OnLeftDown(wxMouseEvent &event)

event handlers

float m_HighlightFunctionK

Parms for logistics function to highlight edges when zoomed out to the point that many edges overlap ...

virtual string GetDescription(void)=0

virtual wxEvtHandler * GetEvtHandler()

float m_BufferdRenderTime

For performance analysis (time to update VBOs after topology change)

CIRef< I3DFrameBuffer > m_MinimapBuffer

virtual bool SupportsRotatedLabels() const

bool x_SelectByRect(bool toggle)

Returns true if selection status changed (or may have changed..)

void x_GenerateTexture(void)

string TTHH_NeedTooltip(const wxPoint &pt)

virtual void x_ComputeNodeBoundary(CPhyloTree *tree, CPhyloTree::TNodeType &node, CBoundaryPoints &boundary_pts, const string &layout_type)

void InitExtents()

Set extents to default values so CalculateExtents can be called.

void InitLabel(CPhyloTree *tree, CPhyloTree::TNodeType &node)

Initialize (for current layout) label text and extent (label rectangle)

virtual void UpdateDataSource(CPhyloTreeDataSource &ds, CGlPane &p)

void x_RenderCircularVbo(TTreeIdx child_node_idx, CPhyloTreeNode *child_node, CPhyloTreeNode *parent_node, vector< CVect2< float > > *trace_line_coords, vector< CVect4< unsigned char > > *trace_line_colors, vector< CVect2< float > > *trace_point_coords, vector< CVect4< unsigned char > > *trace_point_colors, vector< CVect2< float > > &edge_node_coords, vector< CVect4< unsigned char > > &edge_node_colors, vector< CVect2< float > > &sel_edge_node_coords, vector< CVect4< unsigned char > > &sel_edge_node_colors, float radius, const CVect2< float > &center, const CVect2< float > &offset, float resolution)

virtual void x_RenderVbo(CPhyloTreeDataSource &)

I3DTexture * GetTexture(float &xcoord_limit, float &ycoord_limit)

void x_RenderNodeVbo(CPhyloTreeNode *node, TTreeIdx node_idx, vector< float > &color_coords, const CVect2< float > delta=CVect2< float >(0.0f, 0.0f))

void x_RenderSelection(CGlPane &pane)

void SetActiveTooltipNode(int id)

id is the tip id of the tip that the users mouse is currently on, or -1

void SetHighlightEdges(bool enable)

IGenericHandlerHost * GetGenericHost()

CPhyloTree::TTreeIdx GetHoverNodeIdx(CVect2< float > pt)

void OnMotion(wxMouseEvent &event)

void x_RenderPseudoSplineVbo(TTreeIdx child_node_idx, CPhyloTreeNode *child_node, CPhyloTreeNode *parent_node, vector< CVect2< float > > &edge_node_coords, vector< CVect4< unsigned char > > &edge_node_colors, vector< CVect2< float > > &sel_edge_node_coords, vector< CVect4< unsigned char > > &sel_edge_node_colors, const CVect2< float > &pt1, const CVect2< float > &mid_point, const CVect2< float > &pt2)

virtual TVPUnit DistanceBetweenNodes(void) const

void OnLeftDblClick(wxMouseEvent &event)

virtual void RemoveCurrentDataSource()

bool m_HighlightLongerEdges

If true, highlight longer edges when zoomed out.

CGlCurve< CCurveBezier > m_Curve

wxTimer m_MouseSingleTimer

If user is double clicking, want to avoid mouse single-click actions.

CGlPane * m_pPane

event handling

void x_RenderTreeLabel(CGlPane &pane, IRender &gl)

float m_HighlightIntensity

void x_OnSelectCursor(void)

void x_RenderLineVbo(TTreeIdx child_node_idx, CPhyloTreeNode *child_node, CPhyloTreeNode *parent_node, vector< CVect2< float > > &line_coords, vector< CVect4< unsigned char > > &line_colors, double x1, double y1, double x2, double y2)

virtual void x_Layout(CPhyloTreeDataSource &ds)

void x_RenderTooltipHints(CGlPane &pane)

CPhyloTreeNode * GetHoverNode(CVect2< float > pt)

bool GetEdgeColor(CPhyloTreeNode *child_node, CPhyloTreeNode *parent_node, CRgbaColor &c, CRgbaColor &parent_color)

Returns true if color is from selection (sel, shared, trace)

void PointToNode(int id, wxRect tip_rect, float sec)

point to a particular node from a tooltip to help user spot it rectangle should be the tooltip screen...

void x_RenderNodeHighlight(CGlPane &pane, CPhyloTree::TTreeIdx node_idx, const CRgbaColor &c)

void OnTimer(wxTimerEvent &event)

virtual float DefaultNodeSize()

Return default node size according to scheme or 0 if not visible at current scale.

float m_LabelPixels

Height of tree in pixels when labels are displayed.

CIRef< I3DTexture > m_Texture

virtual TModelUnit x_GetVerticalSeparationFactor() const

layout-spefic constant for label vertical sepatation needed for visibility

virtual float GetDefaultNodeSize(const CPhyloTreeNode *node) const

bool x_AddCollapsedTextureNode(CPhyloTreeNode *node, const CVect2< float > delta, CRgbaColor color, float alpha)

void OnLeftUp(wxMouseEvent &event)

bool GetRotatedLabels(void) const

ELayoutStatus m_ValidLayout

void CalculateExtents(CPhyloTree *tree, CPhyloTree::TNodeType &node)

TModelRect m_ZoomableExtent

void OnRightDown(wxMouseEvent &event)

virtual void SetPane(CGlPane *pane)

void x_RenderScaleMarker(CGlPane &pane, IRender &gl)

CVect2< float > x_FindBestSize(CGlPane &pane, std::vector< ProjectionElement > &xexts, std::vector< ProjectionElement > &yexts, TModelRect &limits, TModelRect &node_extents, TModelRect &text_extents, int max_iterations=500)

Returns viewport projection size in x/y from last iteration and puts optimal viewing (to see whole tr...

float m_HighlightFunctionMidpoint

virtual bool x_WideLines()

Returns true if lines are separated enough to use the wider form of lines (more separation is require...

CProjectionExtents m_ProjectionExtents

void x_AddCollapsedGeomNode(CPhyloTreeNode *node, const CVect2< float > delta, CRgbaColor color, float alpha, size_t circleSegments, bool skip_pdf)

TVPRect GetMinDimensions(CGlPane &pane, const CPhyloTreeDataSource &ds, const CPhyloTreeScheme &sc, int &label_height, TModelRect &node_rect, TModelRect &text_rect, float width_factor, float height_factor=1.0f, float wh_ratio=-1.0f)

virtual void Redraw(void)

CPhyloTreeDataSource * m_DS

bool m_MoveDuringSelection

void ComputeViewingLimits(CGlPane &pane, bool force_square=false, bool init_collision_info=true)

Compute the optimal viewing pane size so that the tree occupies the entire viewing area,...

wxMouseEvent m_LastMouseEvent

event info from last mouse click - used for single click processing

void SetScheme(CPhyloTreeScheme &sl)

std::vector< NodePointer > m_NodePointers

virtual void BufferedRender(CGlPane &pane, CPhyloTreeDataSource &ds, bool init_collision_info=true, bool select_edge=false)

IPhyloTreeRenderHost * m_pHost

short GetLabelColorIdx(CPhyloTreeNode *node)

void x_ComputeEdgeHighlight()

compute coefficients for edge highlighting (if enabled)

virtual bool IsDistanceBarLowerLeft() const

virtual void x_SetElementVisibility()

float SetNodeColoration(CPhyloTreeNode *node, TTreeIdx node_idx)

nodes, edges and labels can be colored for default, trace, shared, select or cluster

virtual void Layout(CPhyloTreeDataSource &ds, CGlPane &p)

float GetNodeSize(const CPhyloTreeNode *node) const

void SetHost(IPhyloTreeRenderHost *pHost)

virtual void RenderForHardcopy(CGlPane &pane, CPhyloTreeDataSource &ds)

CMouseZoomHandler * m_pMouseZoomHandler

static const Colors colors

static const TDS_WORD limits[]

void swap(NCBI_NS_NCBI::pair_base_member< T1, T2 > &pair1, NCBI_NS_NCBI::pair_base_member< T1, T2 > &pair2)

#define LOG_POST(message)

This macro is deprecated and it's strongly recomended to move in all projects (except tests) to macro...

void Error(CExceptionArgs_Base &args)

double roundn(double num, unsigned dec=6)

const T * GetData() const

CIRef< IVboGeom > AddGeomObject(GLenum node_type, const string &name)

Add a geometry (vertex buffer object) node.

void SetModelLimitsRect(const TModelRect &R)

void SetVertexBuffer2D(const vector< CVect2< float > > &data)

void Color4fv(const GLfloat *v)

static CGlResMgr & Instance()

void SetViewport(const TVPRect &R)

virtual void Translatef(GLfloat x, GLfloat y, GLfloat z)=0

CVect2< TModelUnit > GetScale() const

virtual void Enable(GLenum glstate)=0

virtual void LineStipple(GLint factor, GLushort pattern)=0

Set line stipple pattern: glLineStipple(). Deprecated in gl 3.2+.

vector< CGlVboNode * > & GetTempNodes()

CIRef< IRender > GetRenderer(ERenderTarget target)

Returns first renderer in m_Renderers that renders to 'target'.

virtual void Begin(GLenum mode)=0

Start rendering.

virtual bool IsBitmapFont() const

Returns true if the currently loaded font is from a bitmap.

virtual void BlendFunc(GLenum sfactor, GLenum dfactor)=0

Options to be used when GL_BLEND is enabled.

void Color3f(GLfloat r, GLfloat g, GLfloat b)

virtual void ScaleInvarient(bool b, CVect2< TModelUnit > scale=CVect2< TModelUnit >(TModelUnit(1), TModelUnit(1)))

Generic rendering options not specfically tied to OpenGL (or pdf..)

virtual void MatrixMode(GLenum mode)=0

CIRef< IRender > GetCurrentRenderer()

Returns current renderer, or NULL.

IRender & GetGl()

convenience function for getting current render manager

CIRef< IVboGeom > FindGeomObject(const string &name)

Find a geometry object (just geometry - not a render node) by name.

virtual void ScaleFactor(const CVect2< TModelUnit > &scale)

After setting scale invarient rendering need to update the scale whenever projection matrix changes.

void RectC(const TVPRect &rc)

void Vertex2d(GLdouble x, GLdouble y)

TVPRect & GetViewport(void)

virtual void BeginText(const CGlTextureFont *font, const CRgbaColor &color)=0

Text is drawn is pixel coordinates.

virtual void Enable(GLenum glstate)

glEnable() all options in m_Enabled

virtual void LineWidth(GLfloat w)

Set line width for drawing: glLineWidth()

virtual void LoadIdentity()=0

virtual void EndText()=0

Pops matrices and attributes after writing text.

void SetPosition(const CMatrix4< float > &mat)

Set 1 transformation and have it be "mat".

TModelUnit UnProjectX(TVPUnit m_x) const

virtual void PopMatrix()=0

virtual void BlendEquation(GLenum mode)

Options for glBlendEquation.

float GetColorTexCoord(short idx, float alpha) const

Get position for color with alpha level closest to 'alpha'.

static string PdfBaseFontName(EFontFace face, EFontFace &pdf_face)

Name of basefont for PDF purposes, or "" if not available.

float DrawBuffered(vector< TPoint > &buf) const

draw into an array and return combined length of segments in buf

TModelRect & GetModelLimitsRect(void)

void AddRenderer(CIRef< IRender > rm)

Get/Set Renderer.

virtual void Disable(GLenum glstate)

glDisable() all options in m_Disabled

EFontFace GetFontFace() const

virtual void End()=0

Finish rendering (create buffer and send to renderer)

void Inflate(T d_x, T d_y)

static bool CheckGlError()

Check if there are any OpenGL errors.

virtual void PolygonMode(GLenum face, GLenum mode)=0

Set the polygon rasterization mode.

void Vertex2fv(const GLfloat *v)

TModelUnit UnProjectY(TVPUnit m_y) const

size_t GetVertexCount() const

void SetCurrentRenderer(CIRef< IRender > rm)

Set current renderer (rm must already be in m_Renderers)

void Color4f(GLfloat r, GLfloat g, GLfloat b, GLfloat a)

TModelUnit GetPixelDist(TModelUnit d) const

Return the scaled pixel distance. Only important for pdf rendering.

void SetVisibleRect(const TModelRect &R)

TPoint & SetPoint(size_t i)

EFontFace

Set of pre-defined fonts for which we know we have valid font files.

void SetVisible(bool b)

Set/get node visibility.

virtual void WriteText(TModelUnit x, TModelUnit y, const char *text, TModelUnit rotate_degrees=0.0)=0

Write text at specified model coords.

virtual TModelUnit TextWidth(const char *text) const

Compute and return font metrics.

virtual TModelUnit TextHeight(void) const

TModelRect & GetVisibleRect(void)

void Recalc()

recalculate the curve (curve-specific)

void Vertex2f(GLfloat x, GLfloat y)

virtual void Disable(GLenum glstate)=0

glDisable()

virtual void Ortho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble nearVal, GLdouble farVal)=0

void SetColorBuffer(const vector< CRgbaColor > &data)

virtual void LineWidth(GLfloat w)=0

Set line width for drawing: glLineWidth()

virtual void BlendFunc(GLenum sfactor, GLenum dfactor)

Options to be used when GL_BLEND is enabled.

TModelUnit GetScaleX(void) const

TModelUnit GetScaleY(void) const

TModelUnit GetOutputUnitScaler() const

static EFontFace FaceFromString(const string &str)

Selects a font face given a string or eFontFace_LastFont on failure.

unsigned int GetFontSize() const

virtual void ColorC(const CRgbaColor &c)=0

Set current color (glColor{3,4}{f,d}{v,})

virtual void PushMatrix()=0

CGlVboNode * AddTempGeomNode(const string &name, bool visible=true)

Add a geometry node of unspecified type (caller will have to allocate appropriate buffer type for the...

TVPPoint Project(TModelUnit m_x, TModelUnit m_y) const

CVect2< TModelUnit > UnProjectEx(const CVect2< TModelUnit > &pt)

CGlVboNode * FindGeomNode(const string &name)

Find a geometry (vertex buffer object) node by name.

CRgbaColor & GetColor(size_t i)

virtual void Render(CGlPane &pane, CGlModel2D *model)

Specialized for models - which are just collections of buffers.

void SetPdf(CRef< CPdf > &pdf)

m_Pdf does the actually writing to the file

void Lighten(float scale)

const float * GetColorArray(void) const

Access the color array directly.

CVect4< unsigned char > GetRgbaUC()

TObjectType * GetPointer(void) THROWS_NONE

Get pointer,.

void Reset(void)

Reset reference object.

bool IsNull(void) const THROWS_NONE

Check if pointer is null – same effect as Empty().

TObjectType * GetPointerOrNull(void) THROWS_NONE

Get pointer value.

TObjectType & GetNCObject(void) const

Get object.

#define END_NCBI_SCOPE

End previously defined NCBI scope.

#define BEGIN_NCBI_SCOPE

Define ncbi namespace.

static string IntToString(int value, TNumToStringFlags flags=0, int base=10)

Convert int to string.

static enable_if< is_arithmetic< TNumeric >::value||is_convertible< TNumeric, Int8 >::value, string >::type NumericToString(TNumeric value, TNumToStringFlags flags=0, int base=10)

Convert numeric value to string.

double Elapsed(void) const

Return time elapsed since first Start() or last Restart() call (in seconds).

void Start(void)

Start the timer.

static const char label[]

unsigned int

A callback function used to compare two keys in a database.

<!DOCTYPE HTML >< html > n< header > n< title > PubSeq Gateway Help Page</title > n< style > n td

bool ne(T x_, T y_, T round_)

Int4 delta(size_t dimension_, const Int4 *score_)

double r(size_t dimension_, const Int4 *score_, const double *prob_, double theta_)

void copy(Njn::Matrix< S > *matrix_, const Njn::Matrix< T > &matrix0_)

#define PTRENDER_EFFECTS_TIMER_ID

#define PHYLO_MOUSE_CLICK_TIMER_ID

static void s_GenerateCollapsedNode(vector< CVect2< float > > &vertices, size_t circleSegments)

Predicate to find location of a node in above selection set.

Structure holds a 'pointer' from an active tooltip to its corresponding node.

wxRect m_TipRect

Rectangle defining tooltip in screen coords.

CPhyloTreeNode::TTreeIdx m_NodeIdx

Pointer to the node with id m_NodeID.

TModelPoint m_TipCenter

Center of tooltip widget, in screen coords with (0,0) in lower left.

CPhyloTree::TID m_NodeID

ID of the node to point to.

CStopWatch m_Timer

Timer to track duration of arrow display.

A coord (in one of +x,-x,+y,-y) and pixel offset in the same direction.

#define NULL_TREE_IDX

Global define for a NULL link in the tree used for comparison.

float Dot(iterator1 iter1, iterator1 end1, iterator2 iter2, iterator2 end2)

Dot-product similarity.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4