用 java绘图一直都吸引着开发人员的注意。传统上，java 开发人员使用 java.awt.graphics 或 java 2d api 进行绘图。一些开发人员甚至使用现成的开源工具箱（如 jsci）来绘图。但很多时候，您的选择被限定在了 awt 或 swing 上。为了最大限度地减少对第三方工具箱的依赖，或者为了简化绘图基础，可以考虑使用 draw2d，并编写自己的代码来制图或绘图。

draw2d 简介

draw2d 是一个驻留在 swt composite 之上的轻量级窗口小部件系统。一个 draw2d 实例 由一个 swt composite、一个轻量级系统及其内容的图形组成。图形 是 draw2d 的构建块。关于 draw2d api 的所有细节，可以从 draw2d developer’s guide 的 eclipse 帮助文件中找到。因为本文不打算成为一篇讲述 draw2d 的教程，所以，为了简便起见，只要您了解 draw2d api 可以帮助您在 swt canvas 上进行绘图就足够了。您可以直接使用一些标准的图形，比如 ellipse、polyline、rectanglefigure 和 triangle，或者，您可以扩展它们来创建自己的图形。此外，一些容器图形，如 panel，可以充当所有子图形的总容器。

draw2d 有两个重要的包：org.eclipse.draw2d.geometry 和 org.eclipse.draw2d.graph，本文中使用了这两个包。org.eclipse.draw2d.geometry 包有一些有用的类，比如 rectangle、point 和 pointlist，这些类都是自我解释的。另一个包 org.eclipse.draw2d.graph 开发人员使用的可能不是太多。这个包提供了一些重要的类，比如 directedgraph、node、edge、nodelist 和 edgelist，这些类有助于创建图表。

在本文中，我将解释如何使用 draw2d 编写代码，帮助您以图形的方式形象化您的数据。我将从一项技术的描述开始，该技术将位于某一范围内的数据值（比如，从 0 到 2048）按比例缩放成另一范围内的等效数据值（例如，从 0 到 100）。然后，我将举例说明如何绘制出任意个级数的 x-y 坐标图，每个级数都包含一组数据元素。在学习了本文中的概念之后，就可以很容易地绘制其他类型的图表，比如饼图和条形图。

具体的绘图过程

步骤 1：您想绘制什么样的图形？

显然，您想以图形方式描绘来自数据源的数据。所以，您需要那些您想以图形形式形象化的数据。为了简便起见，我使用了一个名为 datagenerator 的简单函数生成的数据，而不是从 xml 文件或其他一些数据源读取数据，该函数使用了一个 for(;;) 循环，并以数组列表的形式返回生成的值。

清单 1. 生成一些数据

private arraylist datagenerator() { 
  double series1[] = new double[5];  
      for(int i=0; i<series1.length; i++) 
       series1[i] = (i*10) + 10; // a linear  
       series containing 10,20,30,40,50 
       
      double series2[] = new double[9];  
      series2[0] = 20; series2[1] = 150; series2[2] = 5; 
      series2[3] = 90; series2[4] = 35;  series2[5] = 20; 
      series2[6] = 150; series2[7] = 5; series2[8] = 45; 
       
      double series3[] = new double[7];  
      for(int i=0; i<series3.length; i++) 
       series3[i] = (i*20) + 15; 
      
      seriesdata.add(series1); 
      seriesdata.add(series2); 
      seriesdata.add(series3);  
                 return seriesdata; 
 }

步骤 2：缩放技术 ―― 从给定的数据生成 x 坐标和 y 坐标

一些新的术语

figurecanvas

draw2d 中的 figurecanvas 是 swt canvas 的一个扩展。figurecanvas 可以包含 draw2d 图形。

panel

panel 是 draw2d 中的一个通用容器图形，它可以包含子图形。您可以向一个 panel 图形中添加许多图形，然后将这个 panel 图形提供给 figurecanvas。

directedgraph

directedgraph 是一个 2-d 图形，拥有有限数量的 node，每个 node 都位于一些 point 中，相邻的 node 是通过 edges 彼此连接在一起的。

当您想绘制一架 2-d 飞机上的点时，必须找出每个点的 x 坐标和 y 坐标。绘图的奇妙之处在于能够将某一个给定数据值从一个范围按比例缩放到另一个范围中，也就是说，如果给定一组值，如 {10,20,30}，那么您应该能够确定 2-d 飞机上具体哪些点（x 坐标和 y 坐标）表示的是 10、20 和 30 这些数据值。

绘制总是在按照某一个限定缩放比例进行的。换句话说，在同一限定区域内，可以绘制任意数量的点。因为该区域是固定的，所以您总是可以找到 x 坐标轴的跨度（长度）和 y 坐标轴的跨度（高度）。x 坐标轴和 y 坐标轴的跨度只是等式的一部分。另一部分是找出数据值的范围，并根据每个数据值在新范围内的等效值来计算这些值的坐标。

计算 x 坐标和 y 坐标

x 坐标：x 坐标是某一个点距离原点的水平距离。计算元素的数量，然后将 x 坐标轴的跨度分成 n 个区段，其中，n 是给定集合中的元素的数量，通过这种方式，可以计算某一集合中的所有点的横向坐标。用这种分割方法可以获得每个区段的长度。集合中的第一个点位于等于区段长度的第一段距离内。后续的每个点则位于区段长度加上原点到前一个点的距离的那一段距离内。

例如，给出一个集合 {10,20,30,40}，您立刻就可以知道要绘制 4 个点，因为集合中包含 4 个元素。所以，应该将 x 坐标轴的跨度分成 4 个相等的区段，每个区段的长度 = 跨度/4。因此，如果 x 坐标轴的跨度是 800，那么区段的长度将是 800/4，即 200。第一个元素（10）的 x 坐标将是 200，第二个元素（20）的 x 坐标将是 400，依此类推。

清单 2. 计算 x 坐标

private int[] getxcoordinates(arraylist seriesdata){ 
 int xspan = (int)grafixconstants.xspan; 
           int longestseries = utilities.getlongestseries(seriesdata); 
           int numsegments =  
           ((double[])seriesdata.get(longestseries)).length;         
           int sectionwidth =  
           (int)xspan / numsegments; //want to divide span of xaxis 
         
           int xpositions[] =  
           new int[numsegments]; // will contain x-coordinate of all dots. 
 for(int i=0; i<numsegments; i++){ 
  xpositions[i]=  
  (i+1)*sectionwidth;//dots spaced at distance of sectionwidth    
 } 
 return xpositions; 
}

y 坐标：y 坐标是某一个点距离原点的纵向距离。计算 y 坐标要将某一个值按比例从一个范围缩放到另一个范围。例如，给出相同的集合 {10,20,30,40}，您可以看出，数据的范围是 0 到 40，新的范围就是 y 坐标轴的跨度（高度）。假设 y 坐标轴的高度为 400，那么第一个元素（10）的高度将是100，第二个元素的高度将是 200，依此类推。

通过以下例子，您可以更好地理解如何按比例将一个值从一个范围缩放到另一个范围：假定一个范围的跨度是从 0 到 2048，而您打算将该范围内的任意值（比如说 1024）缩放到另一个从 0 到 100 的范围内，那么您立刻就可以知道，等刻度值是 50。该缩放所遵循的三值线算法是：

line 1---> 2048 / 1024 equals 2.

line 2---> 100 - 0 equals 100.

line 3---> 100 / 2 equals 50, which is the desired scaled value.

步骤 3：您想在哪儿进行绘图？

您还需要进行绘图的地方。可以通过扩展 eclipse viewpart 和使用 swt composite 来创建您自己的视图。此外，也可以使用从 main() 函数中调用的 swt shell。

在扩展 eclipse viewpart 时，至少必须实现两个函数：createpartcontrol(composite parent) 和 setfocus()。函数 createpartcontrol(composite parent) 是在屏幕上绘制视图时自动调用的。您的兴趣只在所接收的 swt composite 上。因此，将它传递给某个类，然后通过对这个类进行编码来绘制图形。

清单 3. 使用 eclipse viewpart 绘图

public class maingrafixview extends viewpart{ 
 public void createpartcontrol(composite parent) { 
   
  //create or get data in an arraylist 
  arraylist seriesdata = datagenerator(); 

  //instantiate a plotter, and provide data to it. 
  directedgraphxyplotter dgxygraph = new directedgraphxyplotter(parent); 
  dgxygraph.setdata(seriesdata); 
  dgxygraph.plot(); //ask it to plot    

 } 
 public void setfocus() {  
 } 
}

步骤 4；您需要绘制哪种图形？

一旦拥有了数据以及想用来绘制图形的区域，就必须确定您需要哪种类型的可视化。在本文中，我演示了如何编写代码来创建 x-y 坐标图和线形图。一旦知道了绘制 x-y 坐标图的技术，就应该能够绘制出其他图形，比如条形图和饼图。要想更多地了解 x-y 坐标图，请参阅我为本文编写的 directedgraphxyplotter 类（参见所附源代码中的 \src\grafix\plotters\directedgraphxyplotter.java）。

步骤 5：创建自己的 x-y 坐标图

x-y 坐标图应该能够绘制出 2-d 飞机上的任意数量的级数线。每个级数线都应该以图形形式显示出引用 x 和 y 引用线的那些级数中的每个点的位置。每个点都应该通过一条线连接到级数中的下一个点上。通过使用表示一个点和一条线的 draw2d 图形，您应该能够创建这样一个坐标图。例如，为了表示一个点，我通过扩展 ellipse 图形创建了一个 dot 图形，并使用 polylineconnection 图形来表示连接线。

directedgraphxyplotter 类只有两个公共函数：setdata(arraylist seriesdata) 和 plot()。函数 setdata(arraylist seriesdata) 接受您想要以图形形式形象化的数据（参见步骤 1），而 plot() 函数则开始绘图。

一旦调用了 plot() 函数，就必须依次采用以下步骤：

采用一个 swt composite，并将 figurecanvas 放在它之上。然后，将一个类似 panel 的通用容器图放在画布上。

计算将要绘制的级数的数量，然后填充创建 directedgraphs 所需数量的 nodelists 和 edgelists。

在 panel 图上绘制 x 坐标轴和 y 坐标轴。（参见所附源代码中 \src\grafix\figure 目录下的 xrulerbar.java 和 yrulerbar.java。）

创建和级数一样多的 directedgraphs，以便进行绘图。

在 panel 图上绘制点和连接线，同时采用步骤 d 中创建的 directedgraphs 中的图形数据。

最后，通过提供 panel 图来设置画布的内容，其中包括到目前为止您已经准备好的所有的点和连接线。

在以下代码中：

第 6-11 行代码对应于上述的步骤 a。

第 14 行，即函数 populatenodesandedges()，对应于上述的步骤 b。

第 16 行，即函数 drawaxis()，对应于上述的步骤 c。

第 17 行、第 18 行和第 19 行对应于上述的步骤 d 和步骤 e。

第 20 行对应于上述的步骤 f。

清单 4. plot() 函数

1. public void plot(){ 
2.     //if no place to plot, or no data to plot, return. 
3.     if(null==_parent || null==_seriesdata) 
4.         return; 
5. 
6.     composite composite = new composite(_parent, swt.border); 
7.     composite.setlayout(new filllayout()); 
8.     figurecanvas canvas = new figurecanvas(composite); 
9.      
10.     panel contents = new panel();//a panel is a general purpose container figure 
11.     contents.setlayoutmanager(new xylayout()); 
12.     initializespan(contents.getclientarea()); 
13.      
14.     populatenodesandedges();      
15.      
16.     drawaxis(contents); 
17.     for(int i=0; i<_numseries; i++){ 
18.      drawdotsandconnections(contents,getdirectedgraph(i)); //  
draw points & connecting wires 
19.     } 
20.     canvas.setcontents(contents); 
21. }

plot() 调用了两个重要内部函数来帮助绘制图形中的点：populatenodesandedges() 和 drawdotsandconnections()。在您发现这两个函数到底完成什么功能之前，让我们来看一下 directedgraph。

directedgraph 是什么？为了使用 draw2d 进行绘图，事实上您必须先创建一个图形，定义将要绘制的点和线。一旦创建好这个图形，就可以使用它实际在画布上进行绘图。您可以将 directedgraph 形象化为拥有有限数量的 node 的一个 2-d 图形，在该图形中，每个 node 都位于一些 point 上，相邻的 node 是通过 edges 连接在一起的。

您可以通过以下代码行来了解创建 directedgraph 的关键所在。首先，创建一个 node 列表和一个 edges 列表。然后，创建一个新的 directedgraph，并通过刚才创建的 nodelist 和 edgelist 设置其成员（nodes 和 edges）。现在，使用 graphvisitor 来访问这个 directedgraph。为了简便起见，包 org.eclipse.draw2d.internal.graph 中有许多 graphvisitor 实现，这些 graphvisitor 有一些用来访问图形的特定算法。

因此，创建 directedgraph 的示例代码类似于下面这样：

清单 5. 示例 directedgraph

//this is a sample, you will need to add actual node(s) to this nodelist. 
nodelist nodes = new nodelist(); //create a list of nodes. 
//this is a sample, you will need to add actual edge(s) to this edgelist. 
edgelist edges = new edgelist(); //create a list of edges.  
directedgraph graph = new directedgraph(); 
graph.nodes = nodes; 
graph.edges = edges; 
new breakcycles().visit(graph);//ask breakcycles to visit the graph. 
//now our "graph" is ready to be used.

现在，已经知道 directedgraph 包含许多 node，其中，每个 node 都可能包含一些数据，并且还存储了这些数据的 x 坐标和 y 坐标，以及一个 edges 的列表，每个 edge 都知道在自己的两端分别有一个 node，您可以通过以下技术，使用这些信息来绘图，其中涉及两个部分：

部分 a ―― 通过以下步骤填充 node 和 edge：

创建一个 nodelist，在该列表中，集合中的每个元素都有一个 node，集合 {10,20,30,40} 需要 4 个 node。

找出每个元素的 x 坐标和 y 坐标，将它们存储在 node.x 和 node.y 成员变量中。

创建一个 edgelist，在该列表中，有 n -1 个 edge，其中，n 是集合中的元素的数量。例如，集合 {10,20,30,40} 需要三个 edge。

将 node 与每个 edge 的左右端相关联，并相应地设置 edge.start 和 edge.end 成员变量。

部分 b ―― 通过以下步骤绘制表示 node 和 edge 的图形：

绘制一个 dot 图来表示每个 node。

绘制一个 polylineconnection 图形来表示每个 edge。

界定每个 polylineconnection 图形，以固定 dot 图的左右端。

现在，回到内部函数的工作上来：

函数 populatenodesandedges() 实现了该技术的部分 a，而函数 drawdotsandconnections() 则实现了该技术的部分 b。

函数 populatenodesandedges() 计算将绘制多少级数。它为每个级数创建了一个 nodelist 和一个 edgelist。

每个 nodelist 都包含一个用于特殊级数的 node 的列表。每个 node 都保存着关于应该在什么地方绘制 x 坐标和 y 坐标的信息。函数 getxcoordinates() 和 getycoordinates() 分别用于检索 x 坐标值和 y 坐标值。使用步骤 2 中的相同算法，这些函数也可以内部地将数据值按比例从一个范围缩放到另一个范围。

每个 edgelist 都包含一个用于特殊级数的 edges 的列表。每个 edge 的左右端上都分别有一个 node。

清单 6. populatenodesandedges() 函数

private void populatenodesandedges(){ 
      
    _seriesscaledvalues = new arraylist(getscaledvalues(_seriesdata)); 
  _nodelists = new arraylist(); 
  _edgelists = new arraylist(); 
   
  for(int i=0; i<_numseries; i++){ 
   _nodelists.add(new nodelist());// one nodelist per series. 
   _edgelists.add(new edgelist());// one edgelist per series. 
  } 
  //populate all nodelists with the nodes.  
  for(int i=0; i<_numseries; i++){//for each series 
   double data[] = (double[])_seriesdata.get(i);//get the series 
   int xcoords[] = getxcoordinates(_seriesdata); 
   int ycoords[] = getycoordinates(i, data); 
   //each nodelist has as many nodes as points in a series 
   for(int j=0; j<data.length; j++){ 
    double doublevalue = new double(data[j]); 
    node node = new node(doublevalue); 
    node.x = xcoords[j]; 
    node.y = ycoords[j];     
    ((nodelist)_nodelists.get(i)).add(node); 
   }      
  } 
  //populate all edgelists with the edges.  
  for(int i=0; i<_numseries; i++){ 
   nodelist nodes = (nodelist)_nodelists.get(i);    
   for(int j=0; j<nodes.size()-1; j++){ 
    node leftnode = nodes.getnode(j); 
    node rightnode = nodes.getnode(j+1); 
    edge edge = new edge(leftnode,rightnode); 
    edge.start = new point(leftnode.x, leftnode.y);  
    edge.end = new point(rightnode.x, rightnode.y); 
    ((edgelist)_edgelists.get(i)).add(edge); 
   }  
  } 
  int breakpoint = 0; 
 }

一旦函数 populatenodesandedges() 完成了它的使命，为所有将要绘制的级数创建了 nodelists 和 edgelists，另一个函数 drawdotsandconnections() 就开始为每个 node 绘制一个 dot 图形，并为每个 edge 绘制一个 polylineconnection 图形。

清单 7. drawdotsandconnections()、drawnode() 和 drawedge() 函数

private void drawdotsandconnections(ifigure contents, directedgraph graph){ 
     for (int i = 0; i < graph.nodes.size(); i++) { 
         node node = graph.nodes.getnode(i); 
         drawnode(contents, node); 
     } 
     for (int i = 0; i < graph.edges.size(); i++) { 
         edge edge = graph.edges.getedge(i); 
         drawedge(contents, edge); 
     }   
 } 
  
 private void drawnode(ifigure contents, node node){ 
   dot dotfigure = new dot(); 
   node.data = dotfigure; 
   int xpos = node.x; 
   int ypos = node.y;   
   contents.add(dotfigure); 
   contents.setconstraint(dotfigure, new rectangle(xpos,ypos,-1,-1)); 
 } 
  
 private void drawedge(ifigure contents, edge edge){ 
     polylineconnection wirefigure = new polylineconnection(); 
  //edge.source is the node to the left of this edge 
     ellipseanchor sourceanchor = new ellipseanchor((dot)edge.source.data); 

  //edge.target is the node to the right of this edge 
  ellipseanchor targetanchor = new ellipseanchor((dot)edge.target.data); 
     wirefigure.setsourceanchor(sourceanchor); 
     wirefigure.settargetanchor(targetanchor); 
     contents.add(wirefigure);      
 }

结束语

如果您想以图形形式描绘将展示的数据，那么 draw2d 是一个好工具。可以使用 draw2d 编写自己的用来绘制图形的 java 代码，这有助于您将精力集中于缩放代码和绘制代码上，把其他与绘制相关的工作留给 draw2d 和 swt。您还可以通过使用所选择的 draw2d 图形来控制您的图形的外观。draw2d 简化了绘图的基本步骤，并且可以最大限度地减少您对第三方工具箱的依赖。