NCBI C++ ToolKit
phylo_tree_boundary_shapes.hpp
Go to the documentation of this file.

Go to the SVN repository for this file.

1 #ifndef GUI_WIDGETS_PHYLO_TREE___PHYLO_TREE_BOUNDARY_SHAPES__HPP
2 #define GUI_WIDGETS_PHYLO_TREE___PHYLO_TREE_BOUNDARY_SHAPES__HPP
3 
4 /* $Id: phylo_tree_boundary_shapes.hpp 35987 2016-07-25 13:06:57Z falkrb $
5  * ===========================================================================
6  *
7  * PUBLIC DOMAIN NOTICE
8  * National Center for Biotechnology Information
9  *
10  * This software/database is a "United States Government Work" under the
11  * terms of the United States Copyright Act. It was written as part of
12  * the author's official duties as a United States Government employee and
13  * thus cannot be copyrighted. This software/database is freely available
14  * to the public for use. The National Library of Medicine and the U.S.
15  * Government have not placed any restriction on its use or reproduction.
16  *
17  * Although all reasonable efforts have been taken to ensure the accuracy
18  * and reliability of the software and data, the NLM and the U.S.
19  * Government do not and cannot warrant the performance or results that
20  * may be obtained by using this software or data. The NLM and the U.S.
21  * Government disclaim all warranties, express or implied, including
22  * warranties of performance, merchantability or fitness for any particular
23  * purpose.
24  *
25  * Please cite the author in any work or product based on this material.
26  *
27  * ===========================================================================
28  *
29  * Authors: Bob Falk
30  *
31  * File Description:
32  *
33  */
34 
35 #include <corelib/ncbistl.hpp>
36 #include <corelib/ncbiobj.hpp>
37 #include <gui/utils/vect2.hpp>
38 #include <gui/utils/rgba_color.hpp>
39 #include <gui/opengl/glrect.hpp>
40 #include <gui/opengl/glvbonode.hpp>
41 
43 
44 /////////////////////////////////////////////////////////////////////////////
45 ///
46 /// CBoundaryParms
47 ///
48 /// Parameters for boundaries parsed from node features
49 ///
50 /// A simple class to hold the parameter values for boundary shapes that
51 /// were parsed from the node features. Makes it easier to have several
52 /// different shapes with same parameters and to pass the parameters around.
54 {
55 public:
57  : m_BorderWidth(5.0f)
58  , m_CornerWidth(5.0f)
60  , m_BoundaryEdgeColor(0.0f, 0.0f, 0.0f, 1.0f)
63  , m_TextBox(true)
64  , m_TriOffset(0.0f) {}
65 
66  /// Set/get color of boundary region
67  void SetColor(const CRgbaColor& c) { m_Color = c; }
68  CRgbaColor& GetColor() { return m_Color; }
69 
70  /// Set/get size of border region around subtree (in pixels)
71  void SetBorderWidth(float w) { m_BorderWidth = w; }
72  float GetBorderWidth() const { return m_BorderWidth; }
73 
74  /// Get/set size of rounded corners used for region (may
75  /// not apply to all typs of regions) (in pixels)
76  void SetCornerWidth(float w) { m_CornerWidth = w; }
77  float GetCornerWidth() const { return m_CornerWidth; }
78 
79  /// Enable/disable drawing of a single-pixel width colored edge around
80  /// boundary
82  bool GetDrawBoundaryEdge() const { return m_BoundaryEdge; }
83 
84  /// Set boundary edge color
87 
88  /// Enable/disable inclusion of text boxes into boundary area
90  bool GetIncludeTextArea() const { return m_IncludeTextArea; }
91 
92  /// Enable/disable inclusion of text boxes into boundary area
93  void SetAxisAligned(bool b) { m_AxisAligned = b; }
94  bool GetAxisAligned() const { return m_AxisAligned; }
95 
96  /// Enable/disable using a separate bounding box for text (meant for triangles)
97  void SetTextBox(bool b) { m_TextBox = b; }
98  bool GetTextBox() const { return m_TextBox; }
99 
100  /// Set/Get distance of a triangle's starting vertex behind its base node
101  void SetTriOffset(float o) { m_TriOffset = o; }
102  float GetTriOffset() const { return m_TriOffset; }
103 
104 protected:
105  /// Number (width) of empty pixels on boundary edge
107 
108  // Color for the bounding region, including alpha
110 
111  /// Width, in pixels, of the rounding area at each corner. This effectivly
112  /// adds to a boundaries border width because the border width has to be
113  /// at least the size of the corner width to guarantee all graphical
114  /// elements remain inside the boundary.
116 
117  /// If true a single pixel-width edge is drawn around the boundary using the
118  /// color m_BoundaryEdgeColor
121 
122  /// If true, boundary is sized (enlarged) to include all text boxes.
124 
125  /// If true shape will be aligned with x and y axes
127 
128  /// If true a separate box will be created for text data. (esp. for triangles)
129  bool m_TextBox;
130 
131  /// For triangles the toplevel node is always at one of the 3 corners
132  /// and this is the offset behind that node, relative to the triangles
133  /// orientation
134  float m_TriOffset;
135 };
136 
137 
138 /////////////////////////////////////////////////////////////////////////////
139 ///
140 /// IBoundaryShape --
141 ///
142 /// Base class for boundaries (ovarlay regions) to be drawn over subtrees.
143 ///
144 /// The base class defines the interface for initializing the shape with a
145 /// set of points and drawing the boundary. Also defined are common
146 /// properties including border width, color, and whether the boundary is
147 /// currently visible.
148 class IBoundaryShape : public CObject
149 {
150 public:
152  : m_Hidden(false) {}
153 
154  virtual ~IBoundaryShape() {}
155 
156  /// Given points which scale (pts) and rectangles for text (pixel_pts) which
157  /// do not scale, compute the minimal area for the boundary
158  virtual void ComputeShape(const CVect2<float>& scale,
159  const CVect2<float>& base_node_pos,
160  const std::vector<CVect2<float> >& pts,
161  const vector<std::pair<CVect2<float>, CGlRect<float> > >& pixel_pts) = 0;
162  /// Render the boundary if !hidden
163  virtual void Render(const CVect2<float>& scale,
164  float alpha_mod = 1.0f,
165  bool include_labels = true);
166  virtual void RenderVbo(CRef<CGlVboNode>& tri_node,
167  CRef<CGlVboNode>& edge_node,
168  const CVect2<float>& scale,
169  float alpha_mod = 1.0f,
170  bool include_labels = true);
171 
172  /// Enable/disable rendering of the boundary
173  void Hide(bool b) { m_Hidden = b; }
174 
175  void SetBoundaryParms(const CBoundaryParms& p) { m_Parms = p; }
177 
178  /// Create a new boundary object given it's name
179  static IBoundaryShape* CreateBoundary(const string& boundary_type);
180 
181  virtual void ComputeShapeWithLabels(const CVect2<float>& scale,
182  bool labels_visible = true) {}
183 
184  const TModelRect& GetExtent() const { return m_Extent; }
185 
186 protected:
187  virtual void x_GetTris(vector<CVect2<float> >& tris,
188  const CVect2<float>& scale) {}
189  virtual void x_GetEdges(vector<CVect2<float> >& edges,
190  const CVect2<float>& scale) {}
191 
192  /// If true, do not render
193  bool m_Hidden;
194 
195  /// Paramters for boundary parsed from features string
197 
198  /// These pairs define the (scaled) location and associated text
199  /// rectangle for the labels inside the boundary. The CGlRect
200  /// objects are defined in pixel dimensions and the rect is assumed
201  /// to have its lower left corner at the CVect2 object
202  vector<std::pair<CVect2<float>, CGlRect<float> > > m_PixelPoints;
203 
204  /// Nodes inside the boundary
205  std::vector<CVect2<float> > m_NodePoints;
206 
207  /// Parent/root node for nodes in the bounded area
209 
210  /// Extent of boundery (min/max xy)
212 };
213 
214 
215 /////////////////////////////////////////////////////////////////////////////
216 ///
217 /// CBoundaryShapeRectBase --
218 ///
219 /// Base class for rectangular boundaries
220 ///
221 /// Defineds are of rectangle and computes size of rectangle. Rendering
222 /// is left to subclasses which may or may not have rounded corners
223 ///
225 {
226 public:
229 
230  virtual void ComputeShape(const CVect2<float>& scale,
231  const CVect2<float>& base_node_pos,
232  const std::vector<CVect2<float> >& pts,
233  const vector<std::pair<CVect2<float>, CGlRect<float> > >& pixel_pts);
234  virtual void ComputeShapeWithLabels(const CVect2<float>& scale,
235  bool labels_visible = true);
236 
237 protected:
238  /// Corners of the rectangle
240 
241  /// Delta values applied to corners to accomodate labels which do not scale
242  /// with the tree as a whole
247 };
248 
249 /////////////////////////////////////////////////////////////////////////////
250 ///
251 /// CBoundaryShapeRect --
252 ///
253 /// Simple rectangular boundary
254 ///
256 {
257 public:
259  virtual ~CBoundaryShapeRect() {}
260 
261 protected:
262  void x_GetTris(vector<CVect2<float> >& tris,
263  const CVect2<float>& scale);
264  void x_GetEdges(vector<CVect2<float> >& edges,
265  const CVect2<float>& scale);
266 };
267 
268 /////////////////////////////////////////////////////////////////////////////
269 ///
270 /// CBoundaryShapeRoundedRect --
271 ///
272 /// Simple rectangular boundary with rounded corners.
273 ///
275 {
276 public:
279 
280 protected:
281 
282  void x_GetTris(vector<CVect2<float> >& tris,
283  const CVect2<float>& scale);
284  void x_GetEdges(vector<CVect2<float> >& edges,
285  const CVect2<float>& scale);
286  void x_GetRoudedCornerTris(vector<CVect2<float> >& tris,
287  const CVect2<float>& pos,
288  float corner_width_x,
289  float corner_width_y,
290  float start_angle);
291  void x_GetRoudedCornerEdges(vector<CVect2<float> >& edges,
292  const CVect2<float>& pos,
293  float corner_width_x,
294  float corner_width_y,
295  float start_angle);
296 };
297 
298 /////////////////////////////////////////////////////////////////////////////
299 ///
300 /// CBoundaryShapeTri --
301 ///
302 /// Triangular boundary region
303 ///
305 {
306 public:
308  virtual ~CBoundaryShapeTri() {}
309 
310  virtual void ComputeShape(const CVect2<float>& scale,
311  const CVect2<float>& base_node_pos,
312  const std::vector<CVect2<float> >& pts,
313  const vector<std::pair<CVect2<float>, CGlRect<float> > >& pixel_pts);
314  virtual void ComputeShapeWithLabels(const CVect2<float>& scale,
315  bool labels_visible = true);
316 
317 protected:
318 
319  /// Rounded corners are drawn as circles that replace the corner that would
320  /// extend from intersection[1,2] to initial_vertex. The circle is drawn
321  /// at position 'pos' with initial scaled radius corner_width_[x,y]
322  struct RoundedCorner {
329  };
330 
331  void x_GetTris(vector<CVect2<float> >& tris,
332  const CVect2<float>& scale);
333  void x_GetEdges(vector<CVect2<float> >& edges,
334  const CVect2<float>& scale);
335 
336  void x_ComputeTriParms(const std::vector<CVect2<float> >& pts,
337  const CVect2<float>& base_pos,
338  const CVect2<float>& dir,
339  const CVect2<float>& perp_dir,
340  float& max_len,
341  float& max_angle_top,
342  float& max_angle_bottom);
343 
345  const CVect2<float>& prev_pt_in,
346  const CVect2<float>& next_pt_in,
347  const CVect2<float>& scale,
348  CVect2<float>& pt_out1,
349  CVect2<float>& pt_out2);
350 
351  /// Get the points that make up the roundec
352  void x_GetArc(const RoundedCorner& c,
353  const CVect2<float>& scale,
354  vector<CVect2<float> >& edges);
355 
356  /// Corners of the rectangles that make up the triangle with clipped
357  /// corners (to allow rounding) and the (optional) text box.
361 
362  /// Used for debugging text box
364 
365  /// The rounded corners
366  std::vector<RoundedCorner> m_RoundedCorners;
367 
368  /// Center of the shape, used for scaling if a border is applied
370  /// Width and height (maximum extents) used if scaling is applied
371  float m_Width;
372  float m_Height;
373 
374  /// Allows multiple passes with different border colors if desired
376 };
377 
378 /////////////////////////////////////////////////////////////////////////////
379 ///
380 /// BoundaryShapeEllipse --
381 ///
382 /// Elliptical boundary region
383 ///
385 {
386 public:
388 
389  virtual void ComputeShape(const CVect2<float>& /*scale*/,
390  const CVect2<float>& /*base_node_pos*/,
391  const std::vector<CVect2<float> >& /*pts*/,
392  const vector<std::pair<CVect2<float>, CGlRect<float> > >& /*pixel_pts*/) {}
393  //virtual void Render(const CVect2<float>& /*scale*/, float /*alpha_mod = 1.0f*/) {}
394 };
395 
396 
397 /////////////////////////////////////////////////////////////////////////////
398 ///
399 /// CBoundaryPoints --
400 ///
401 /// Holds all points in a bounded region. Points may be fixed (such as text-box
402 /// corners) or scaled such as node points. Fixed-scale points will be attached to
403 /// scaled points (text box moves with node)
404 ///
405 /// Improvement: If very large trees are bounded can reduce number of points
406 /// by only considering convex hull for set (this becomes a bit more complex with
407 /// the fixed scaling though)
408 ///
410 public:
412 
413  /// Add point to be included in bounded area
414  void AddBoundedPoint(const CVect2<float>& pt);
415  /// Add point in bounded area along with a rectangle based at
416  /// that point and defined in pixels, that also will be included
417  /// in the bounded area (allows non-resizing text to be included)
418  void AddPixelRect(const CVect2<float>& pt,
419  const CGlRect<float>& rect);
420 
421  /// Add the boundary areas of the subtree to this boundary area
422  void AddBoundedPoints(CBoundaryPoints& pts);
423  /// Clear all accumulated bounding points
424  void ClearBoundedPoints();
425 
426  const vector<CVect2<float> >& GetGraphPoints() const { return m_GraphPoints; }
427  const vector<std::pair<CVect2<float>, CGlRect<float> > >& GetPixelPoints() const { return m_PixelPoints; }
428 
429 protected:
430  /// Points and text rectangles used to compute boundary area (and discarded
431  /// afterwards)
432  vector<CVect2<float> > m_GraphPoints;
433  vector<std::pair<CVect2<float>, CGlRect<float> > > m_PixelPoints;
434 };
435 
436 /////////////////////////////////////////////////////////////////////////////
437 ///
438 /// CSubtreeBoundary --
439 ///
440 /// Primary boundary object for drawing boundaries around subtrees
441 ///
442 /// This boundary object parses the boundary features requested and
443 /// creates the appropriate IBoundaryShape subclass with the parsed
444 /// parameters. Based on the requested features, more than one
445 /// shape may be created so that different shapes can be shown
446 /// for different layouts (e.g. a rectangle for a rectangular cladogram
447 /// and a triangular boundary for a slanted cladogram).
448 ///
450 public:
452  : m_BoundaryShape(NULL)
453  , m_LastScale(0.0f, 0.0f) {}
454 
455  ~CSubtreeBoundary();
456 
457  /// Render current shape
458  void RenderBoundary(const CVect2<float>& scale,
459  float alpha_mod = 1.0f,
460  bool include_labels = true);
461  /// Render to vbo (create vbo but do not draw)
462  void RenderBoundaryVbo(const CVect2<float>& scale,
463  float alpha_mod = 1.0f,
464  bool include_labels=true);
465  /// Render the vbo
466  void RenderVbo();
467 
468  CRef<CGlVboNode> GetBoundaryTris() { return m_BoundaryTris; }
469  CRef<CGlVboNode> GetBoundaryEdges() { return m_BoundaryEdges; }
470 
471  /// Parse the features to create the shapes and set their options
472  void CreateShapes(const std::string& features);
473  /// Use the accumulated point data to compute shape dimensions
474  void ComputeShapes(const CBoundaryPoints& boundary_pts,
475  const CVect2<float>& scale,
476  const CVect2<float>& base_node_pos,
477  const string& layout_type);
478 
479  /// Show/hide boundary area
480  void Hide(bool b=true);
481 
482  /// Return true if boundary (in model coordinates) overlaps rectangle r
483  bool Overlaps(TModelRect& r) const;
484 
485  /// Set get source string for boundary parms
486  void SetBoundaryString(const string& str) { m_BoundaryStr = str; }
487  string GetBoundaryString() const { return m_BoundaryStr; }
488 
489 protected:
490  /// All shapes created for boundary (may be different shapes for differnt
491  /// layout algorighms). Key is a string designating the layout algorithm.
493 
494 
495  /// Feature string from which boundary parameters were created
497 
498 
499  /// Current (active) boundary shape (for current layout)
501 
502  /// For parsing boudary info - get a parameter
503  string x_GetParameter(const string& features, const string& parm);
504  /// For parsing a color parameter
505  bool x_GetColorParameter(const string& features,
506  const string& parm,
507  bool parm_required,
508  CRgbaColor& c);
509  /// Add a boundary for the specified layout algorithm
510  void x_AddBoundaryType(const CBoundaryParms& parms,
511  const string& boundary_type,
512  const string& layout_type);
513 
516 
518 };
519 
520 
522 
523 #endif // GUI_WIDGETS_PHYLO_TREE___PHYLO_TREE_BOUNDARY_SHAPES__HPP
BoundaryShapeEllipse –.
virtual void ComputeShape(const CVect2< float > &, const CVect2< float > &, const std::vector< CVect2< float > > &, const vector< std::pair< CVect2< float >, CGlRect< float > > > &)
Given points which scale (pts) and rectangles for text (pixel_pts) which do not scale,...
void SetCornerWidth(float w)
Get/set size of rounded corners used for region (may not apply to all typs of regions) (in pixels)
void SetIncludeTextArea(bool b)
Enable/disable inclusion of text boxes into boundary area.
bool m_AxisAligned
If true shape will be aligned with x and y axes.
void SetTriOffset(float o)
Set/Get distance of a triangle's starting vertex behind its base node.
void SetBoundaryEdgeColor(const CRgbaColor &r)
Set boundary edge color.
void SetDrawBoundaryEdge(bool b)
Enable/disable drawing of a single-pixel width colored edge around boundary.
float m_TriOffset
For triangles the toplevel node is always at one of the 3 corners and this is the offset behind that ...
bool m_IncludeTextArea
If true, boundary is sized (enlarged) to include all text boxes.
void SetTextBox(bool b)
Enable/disable using a separate bounding box for text (meant for triangles)
void SetColor(const CRgbaColor &c)
Set/get color of boundary region.
bool m_TextBox
If true a separate box will be created for text data. (esp. for triangles)
float m_BorderWidth
Number (width) of empty pixels on boundary edge.
void SetAxisAligned(bool b)
Enable/disable inclusion of text boxes into boundary area.
float m_CornerWidth
Width, in pixels, of the rounding area at each corner.
bool m_BoundaryEdge
If true a single pixel-width edge is drawn around the boundary using the color m_BoundaryEdgeColor.
CRgbaColor & GetBoundaryEdgeColor()
void SetBorderWidth(float w)
Set/get size of border region around subtree (in pixels)
const vector< CVect2< float > > & GetGraphPoints() const
const vector< std::pair< CVect2< float >, CGlRect< float > > > & GetPixelPoints() const
vector< CVect2< float > > m_GraphPoints
Points and text rectangles used to compute boundary area (and discarded afterwards)
vector< std::pair< CVect2< float >, CGlRect< float > > > m_PixelPoints
CBoundaryShapeRectBase –.
virtual void ComputeShape(const CVect2< float > &scale, const CVect2< float > &base_node_pos, const std::vector< CVect2< float > > &pts, const vector< std::pair< CVect2< float >, CGlRect< float > > > &pixel_pts)
Given points which scale (pts) and rectangles for text (pixel_pts) which do not scale,...
float m_PixelDeltaNegX
Delta values applied to corners to accomodate labels which do not scale with the tree as a whole.
virtual void ComputeShapeWithLabels(const CVect2< float > &scale, bool labels_visible=true)
CVect2< float > m_Points[4]
Corners of the rectangle.
CBoundaryShapeRect –.
void x_GetEdges(vector< CVect2< float > > &edges, const CVect2< float > &scale)
void x_GetTris(vector< CVect2< float > > &tris, const CVect2< float > &scale)
CBoundaryShapeRoundedRect –.
void x_GetRoudedCornerTris(vector< CVect2< float > > &tris, const CVect2< float > &pos, float corner_width_x, float corner_width_y, float start_angle)
void x_GetRoudedCornerEdges(vector< CVect2< float > > &edges, const CVect2< float > &pos, float corner_width_x, float corner_width_y, float start_angle)
void x_GetTris(vector< CVect2< float > > &tris, const CVect2< float > &scale)
void x_GetEdges(vector< CVect2< float > > &edges, const CVect2< float > &scale)
CBoundaryShapeTri –.
void x_GetArc(const RoundedCorner &c, const CVect2< float > &scale, vector< CVect2< float > > &edges)
Get the points that make up the roundec.
void x_GetEdges(vector< CVect2< float > > &edges, const CVect2< float > &scale)
CRgbaColor m_CurrentBorderColor
Allows multiple passes with different border colors if desired.
float m_Width
Width and height (maximum extents) used if scaling is applied.
void x_GetTris(vector< CVect2< float > > &tris, const CVect2< float > &scale)
virtual void ComputeShapeWithLabels(const CVect2< float > &scale, bool labels_visible=true)
virtual void ComputeShape(const CVect2< float > &scale, const CVect2< float > &base_node_pos, const std::vector< CVect2< float > > &pts, const vector< std::pair< CVect2< float >, CGlRect< float > > > &pixel_pts)
Given points which scale (pts) and rectangles for text (pixel_pts) which do not scale,...
std::vector< RoundedCorner > m_RoundedCorners
The rounded corners.
RoundedCorner x_ComputeRoundedCorner(const CVect2< float > &pt_in, const CVect2< float > &prev_pt_in, const CVect2< float > &next_pt_in, const CVect2< float > &scale, CVect2< float > &pt_out1, CVect2< float > &pt_out2)
CVect2< float > m_TextBox[4]
Used for debugging text box.
CVect2< float > m_Rect1[4]
Corners of the rectangles that make up the triangle with clipped corners (to allow rounding) and the ...
void x_ComputeTriParms(const std::vector< CVect2< float > > &pts, const CVect2< float > &base_pos, const CVect2< float > &dir, const CVect2< float > &perp_dir, float &max_len, float &max_angle_top, float &max_angle_bottom)
CVect2< float > m_Center
Center of the shape, used for scaling if a border is applied.
CObject –.
Definition: ncbiobj.hpp:180
class CRgbaColor provides a simple abstraction for managing colors.
Definition: rgba_color.hpp:58
string m_BoundaryStr
Feature string from which boundary parameters were created.
CRef< CGlVboNode > GetBoundaryTris()
CRef< CGlVboNode > m_BoundaryTris
CRef< IBoundaryShape > m_BoundaryShape
Current (active) boundary shape (for current layout)
map< string, CRef< IBoundaryShape > > m_Shapes
All shapes created for boundary (may be different shapes for differnt layout algorighms).
void SetBoundaryString(const string &str)
Set get source string for boundary parms.
CRef< CGlVboNode > m_BoundaryEdges
CRef< CGlVboNode > GetBoundaryEdges()
virtual void ComputeShapeWithLabels(const CVect2< float > &scale, bool labels_visible=true)
CBoundaryParms m_Parms
Paramters for boundary parsed from features string.
std::vector< CVect2< float > > m_NodePoints
Nodes inside the boundary.
CBoundaryParms & GetBoundaryParms()
CVect2< float > m_BaseNodePos
Parent/root node for nodes in the bounded area.
virtual void x_GetTris(vector< CVect2< float > > &tris, const CVect2< float > &scale)
const TModelRect & GetExtent() const
virtual void x_GetEdges(vector< CVect2< float > > &edges, const CVect2< float > &scale)
virtual void Render(const CVect2< float > &scale, float alpha_mod=1.0f, bool include_labels=true)
Render the boundary if !hidden.
void Hide(bool b)
Enable/disable rendering of the boundary.
vector< std::pair< CVect2< float >, CGlRect< float > > > m_PixelPoints
These pairs define the (scaled) location and associated text rectangle for the labels inside the boun...
virtual void RenderVbo(CRef< CGlVboNode > &tri_node, CRef< CGlVboNode > &edge_node, const CVect2< float > &scale, float alpha_mod=1.0f, bool include_labels=true)
TModelRect m_Extent
Extent of boundery (min/max xy)
virtual void ComputeShape(const CVect2< float > &scale, const CVect2< float > &base_node_pos, const std::vector< CVect2< float > > &pts, const vector< std::pair< CVect2< float >, CGlRect< float > > > &pixel_pts)=0
Given points which scale (pts) and rectangles for text (pixel_pts) which do not scale,...
void SetBoundaryParms(const CBoundaryParms &p)
static IBoundaryShape * CreateBoundary(const string &boundary_type)
Create a new boundary object given it's name.
bool m_Hidden
If true, do not render.
Definition: map.hpp:338
#define true
Definition: bool.h:35
#define false
Definition: bool.h:36
static const char * str(char *buf, int n)
Definition: stats.c:84
string
Definition: cgiapp.hpp:687
#define NULL
Definition: ncbistd.hpp:225
#define END_NCBI_SCOPE
End previously defined NCBI scope.
Definition: ncbistl.hpp:103
#define BEGIN_NCBI_SCOPE
Define ncbi namespace.
Definition: ncbistl.hpp:100
#define NCBI_GUIWIDGETS_PHYLO_TREE_EXPORT
Definition: gui_export.h:535
Portable reference counted smart and weak pointers using CWeakRef, CRef, CObject and CObjectEx.
The NCBI C++/STL use hints.
double r(size_t dimension_, const Int4 *score_, const double *prob_, double theta_)
Rounded corners are drawn as circles that replace the corner that would extend from intersection[1,...
static const char *const features[]
Modified on Sun Apr 21 03:39:25 2024 by modify_doxy.py rev. 669887