基于Processing的数据可视化

虽然数据可视化领域有很多成熟、界面友好、功能强大的软件产品（例如Tableau、VIDI、NodeXL等），但是借助Processing我们可以基于Java语言框架进行丰富多元的可视化编程，熟悉了Processing也可以说是上一学期Topics课程的最大收获，以另一种方式将数据重新组织、统计并以可视化界面展现出来。今天再看其他资料时碰巧看到XX对Processing的支持，颇感亲切，所以决定把上学期Topics的作业过程记录下来。

可视化内容是从Databank下载的217个国家、6个地区的7项统计数据。要求从通过数据可视化看出每个指标的变化趋势、所选不同国家之间的对比情况、不同时间段数据变化、不同地区所包含国家的统计数据对比等。

– Electricity production (kWh)
– Electricity production from renewable sources (kWh)
– Electric power consumption (kWh)
– Electric power consumption (kWh per capita)
– CO2 emissions (metric tons per capita)
– CO2 emissions (kt)
– Population, total

数据文件如下：

 

最终可视化结果如下：

 

源码如下：

import processing.core.*; 
import processing.data.*; 
import processing.event.*; 
import processing.opengl.*; 

import controlP5.*; 
import java.lang.Math; 

import java.util.HashMap; 
import java.util.ArrayList; 
import java.io.File; 
import java.io.BufferedReader; 
import java.io.PrintWriter; 
import java.io.InputStream; 
import java.io.OutputStream; 
import java.io.IOException; 

public class TCS1 extends PApplet {
  
ControlP5 cp5;


FloatTable data, dataRegion; 
float dataMin, dataMax; 
float volumnMax;

float plotX1, plotY1; 
float plotX2, plotY2; 
float labelX, labelY;

int yearMin, yearMax; 
int[] years; 
int yearInterval = 3;


int showRow = 6;
int showRegionRow = 0;

int yearStartCol = 8;

//Integrator[] interpolators;

PFont plotFont;
DropdownList dropCountry, dropCate, dropRegion;

boolean isNormalOn = true;
boolean isGroupOn = false;
boolean isCompareOn = false;


int groupMode = 1;
static final int GROUP_MODE_REGIONS = 1;
static final int GROUP_MODE_DECADES = 2;

IntList listCompare = new IntList();
int[][] compareColors = new int[300][3];
int cateCompare = 0;

int[] decadeYearIndex = new int[4];
String[] decadeYearStr = new String[4];

public void setup() { 
  size(1200, 750); 


  cp5 = new ControlP5(this);
  data = new FloatTable("data.tsv");
  dataRegion = new FloatTable("region.tsv");

  years = PApplet.parseInt(data.getColumnNames());

  yearMin = years[yearStartCol]; 
  yearMax = years[years.length - 1]; 

  //init decade year
  for (int i=7; i>3; i--) {
    decadeYearStr[7-i] = data.getColumnNames()[i];
    decadeYearIndex[7-i] = 7-i;
  }



  
  interpolators = new Integrator[data.getColumnCount()];
   for(int col=yearStartCol; col=weishu; i--) {
        maxStr += "0";
        eachStr += "0";
      }
      eachStr += "0" + firstNum;
      maxStr += firstNum + "";
    } 
    else {
      for (int i=-1; i>=weishu+1; i--) {
        maxStr += "0";
        eachStr += "0";
      }
      eachStr += "0" + firstNum;
      maxStr += firstNum + "";
    }
  } 
  else if (weishu == 0) {
    if (firstNum != 10) {
      maxStr = "0."+firstNum;
      eachStr = "0.0" + firstNum;
    } 
    else {
      maxStr = firstNum / 10 + "";
      eachStr = "0." + firstNum / 10;
    }
  }
  else if (weishu == 1) {
    if (firstNum != 10) {
      maxStr = firstNum + "";
      eachStr = "0." + firstNum;
    } 
    else {
      maxStr = firstNum + "";
      eachStr = firstNum / 10 + "";
    }
  }
  else {
    maxStr += firstNum + "";
    eachStr += firstNum + "";
    for (int i=1; i= 10) {
        if (weishu == 0) {
          volumnNumbers[i] = currentFirstNum / 100 + "";
        }
        else {
          volumnNumbers[i] = currentFirstNum / pow(10, 2-weishu) + "";
        }
      }
      else if (PApplet.parseFloat(currentFirstNum) / 10 >= 1) {
        volumnNumbers[i] += "0.";
        for (int j=-1; j>weishu-1;j--) {
          volumnNumbers[i] += "0";
        }
        volumnNumbers[i] += currentFirstNum;
      }
      else {
        volumnNumbers[i] += "0.";
        for (int j=-1; j>weishu-2;j--) {
          volumnNumbers[i] += "0";
        }
        volumnNumbers[i] += currentFirstNum;
      }
    } 
    else if (weishu == 1) {
      if (PApplet.parseFloat(currentFirstNum) / 10 >= 1) {

        volumnNumbers[i] = (currentFirstNum / 10) + "." + (currentFirstNum - ((currentFirstNum / 10) * 10));
      } 
      else {
        volumnNumbers[i] = "0."+currentFirstNum;
      }
    }
    else {
      volumnNumbers[i] = currentFirstNum + "";
      for (int j=0; j 0) {
    if (v > 100) {
      return String.format("%.0f", v);
    } 
    else if (v > 10) {
      return String.format("%.2f", v);
    } 
    else if (v > 1) {
      return String.format("%.3f", v);
    } 
    else {
      return String.format("%.4f", v);
    }
  }
  return "";
}


public void drawDataPoints(int row) {
  for (int col=yearStartCol; col3; col--) {
    if (data.isValid(row, col)) {
      float value = data.getFloat(row, col);
      System.out.println(value);
      float x = map(decadeYearIndex[7-col], -0.7f, 3.7f, plotX1, plotX2);
      float y = map(value, 0, volumnMax, plotY2, plotY1);

      rect(x-(recWidth / 2), y, recWidth, plotY2 - y);
     
      text(value, x, y - 20);
    }
  }
}


public void drawDataLine(int row) {
  beginShape();
  //stroke(23, 23, 23);
  for (int col=yearStartCol; col= data.length)) {
      throw new RuntimeException("There is no row " + rowIndex);
    }
    if ((col < 0) || (col >= data[rowIndex].length)) {
      throw new RuntimeException("Row " + rowIndex + " does not have a column " + col);
    }
    // end training wheels
    
    return data[rowIndex][col];
  }
  
  
  public boolean isValid(int row, int col) {
    //System.out.println("data[6].length" + data[6].length);
    if (row < 0) return false;
    if (row >= rowCount) return false;
    //if (col >= columnCount) return false;
    if (col >= data[row].length) return false;
    if (col < 0) return false;
    if(data[row][col] == 0) return false;
    return !Float.isNaN(data[row][col]);
  }


  public float getColumnMin(int col) {
    float m = Float.MAX_VALUE;
    for (int row = 0; row < rowCount; row++) {
      if (isValid(row, col)) {
        if (data[row][col] < m) {
          m = data[row][col];
        }
      }
    }
    return m;
  }


  public float getColumnMax(int col) {
    float m = -Float.MAX_VALUE;
    for (int row = 0; row < rowCount; row++) {
      if (isValid(row, col)) {
        if (data[row][col] > m) {
          m = data[row][col];
        }
      }
    }
    return m;
  }

  
  public float getRowMin(int row) {
    float m = Float.MAX_VALUE;
    for (int col = 0; col < columnCount; col++) {
      if (isValid(row, col)) {
        if (data[row][col] < m) {
          m = data[row][col];
        }
      }
    }
    return m;
  } 


  public float getRowMax(int row) {
    float m = -Float.MAX_VALUE;
    for (int col = 0; col < columnCount; col++) {
      if (isValid(row, col)) {
        if (data[row][col] > m) {
          m = data[row][col];
        }
      }
    }
    return m;
  }


  public float getTableMin() {
    float m = Float.MAX_VALUE;
    for (int row = 0; row < rowCount; row++) {
      for (int col = 0; col < columnCount; col++) {
        if (isValid(row, col)) {
          if (data[row][col] < m) {
            m = data[row][col];
          }
        }
      }
    }
    return m;
  }


  public float getTableMax() {
    float m = -Float.MAX_VALUE;
    for (int row = 0; row < rowCount; row++) {
      for (int col = 0; col < columnCount; col++) {
        if (isValid(row, col)) {
          if (data[row][col] > m) {
            m = data[row][col];
          }
        }
      }
    }
    return m;
  }
  
  public boolean hasData(int row, int startCol) {
    boolean hasData = false;
    for (int col = startCol; col < columnCount; col++) {
      //System.out.println("row="+row+" col="+col+" isValid="+isValid(row, col));
      if (isValid(row, col)) {
        hasData = true;
        break;
      }
    }
    return hasData;
  }
  
  
  public float getRowMin(int row, int startCol) {
    float m = Float.MAX_VALUE;
      for (int col = startCol; col < columnCount; col++) {
        
        //System.out.println("row="+row+" col="+col+" isValid="+isValid(row, col));
        if (isValid(row, col)) {
          if (data[row][col] < m) {
            m = data[row][col];
          }
        }
      }
    return m;
  }
  
  public float getRowMax(int row, int startCol) {
    float m = -Float.MAX_VALUE;
      for (int col = startCol; col < columnCount; col++) {
        //System.out.println("row="+row+" col="+col+" isValid="+isValid(row, col));
        if (isValid(row, col)) {
          if (data[row][col] > m) {
            m = data[row][col];
          }
        }
      }
    return m;
  }
  
  public float getRowMin(int row, int startCol, int endCol) {
    float m = Float.MAX_VALUE;
      for (int col = startCol; col < endCol + 1; col++) {
        
        //System.out.println("row="+row+" col="+col+" isValid="+isValid(row, col));
        if (isValid(row, col)) {
          if (data[row][col] < m) {
            m = data[row][col];
          }
        }
      }
    return m;
  }
  
  public float getRowMax(int row, int startCol, int endCol) {
    float m = -Float.MAX_VALUE;
      for (int col = startCol; col < endCol + 1; col++) {
        //System.out.println("row="+row+" col="+col+" isValid="+isValid(row, col));
        if (isValid(row, col)) {
          if (data[row][col] > m) {
            m = data[row][col];
          }
        }
      }
    return m;
  }
}
class Integrator {

  final float DAMPING = 0.5f;
  final float ATTRACTION = 0.2f;

  float value;
  float vel;
  float accel;
  float force;
  float mass = 1;

  float damping = DAMPING;
  float attraction = ATTRACTION;
  boolean targeting;
  float target;


  Integrator() { }


  Integrator(float value) {
    this.value = value;
  }


  Integrator(float value, float damping, float attraction) {
    this.value = value;
    this.damping = damping;
    this.attraction = attraction;
  }


  public void set(float v) {
    value = v;
  }


  public void update() {
    if (targeting) {
      force += attraction * (target - value);      
    }

    accel = force / mass;
    vel = (vel + accel) * damping;
    value += vel;

    force = 0;
  }


  public void target(float t) {
    targeting = true;
    target = t;
  }


  public void noTarget() {
    targeting = false;
  }
}
  static public void main(String[] passedArgs) {
    String[] appletArgs = new String[] { "TCS1" };
    if (passedArgs != null) {
      PApplet.main(concat(appletArgs, passedArgs));
    } else {
      PApplet.main(appletArgs);
    }
  }
}