Пример #1
0
 public NodeColorAction(String group) {
   super(group, VisualItem.FILLCOLOR, ColorLib.rgba(202, 225, 255, 250));
   add("_hover", ColorLib.gray(220, 230));
   add("ingroup('_search_')", ColorLib.rgb(255, 190, 190));
   add("ingroup('_focus_')", ColorLib.rgb(205, 197, 191));
   add(isprocessfilter, ColorLib.rgba(255, 193, 193, 255));
 }
  public GraphVisualisation(rndalg.Graph graphToShow, Vector<Vertex> cut) {
    super();

    Graph displayed = new Graph(false);
    displayed.addColumn("id", String.class);
    displayed.addColumn("isCut", Boolean.class);

    this.makeGraph(displayed, graphToShow, cut);
    this.addGraph("graph", displayed);

    LabelRenderer r = new LabelRenderer("id");
    r.setRoundedCorner(10, 10);
    r.setHorizontalPadding(5);
    r.setVerticalPadding(2);
    this.setRendererFactory(new DefaultRendererFactory(r));

    ActionList layoutActions = new ActionList(Activity.INFINITY);
    ForceDirectedLayout layout = new ForceDirectedLayout("graph");
    layoutActions.add(layout);
    layoutActions.add(new RepaintAction());

    // black text
    ColorAction textCA =
        new ColorAction("graph.nodes", VisualItem.TEXTCOLOR, ColorLib.rgb(0, 0, 0));
    // black edges
    // ColorAction edgeCA = new ColorAction("graph.edges", VisualItem.STROKECOLOR,
    // ColorLib.rgb(0,0,0));
    // edges
    ColorAction edgeCA =
        new ColorAction(
            "graph.edges",
            ExpressionParser.predicate("isCut = false"),
            VisualItem.STROKECOLOR,
            ColorLib.rgb(0, 0, 0));
    ColorAction edgeCutCA =
        new ColorAction(
            "graph.edges",
            ExpressionParser.predicate("isCut = true"),
            VisualItem.STROKECOLOR,
            ColorLib.rgb(255, 0, 0));

    // concatenate the color actions
    ActionList colorActions = new ActionList();
    colorActions.add(textCA);
    colorActions.add(edgeCA);
    colorActions.add(edgeCutCA);

    this.putAction("draw", colorActions);
    this.putAction("layout", layoutActions);
    this.runAfter("draw", "layout");

    this.run("draw");
  }
Пример #3
0
    public int getColor(VisualItem item) {
      if (ENTROPY_COLOR) return entropyColor(item);
      // test
      //			if (item.getBoolean("cut")){
      //				return new Color(222,13,107).getRGB();
      //			}
      // color is fixed, what changes as a function of the value is the transparency (alpha)
      int color = sca.getColor(item);

      // lemmas and senses in the pathToRoot
      if (item.isInGroup("pathToRoot")
          && ((item.getInt("type") == 1) || (item.getInt("type") == 4)))
        color = ColorScheme.pathToRootColor;

      // count off -- just return color
      if (NodeColorAction.this.docuBurstActionList.countType.equals(DocuBurstActionList.NOCOUNT))
        return color;

      float total =
          (float)
              (item.getFloat(
                  DocuBurstActionList.CACHECOUNT
                      + NodeColorAction.this.docuBurstActionList.countType));
      float maxTotal =
          NodeColorAction.this.docuBurstActionList.getMaxTotal(
              NodeColorAction.this.docuBurstActionList.countType);

      if (total < 0) color = ColorScheme.negativeColor;

      if (total == 0) {
        if (color != ColorScheme.pathToRootColor)
          // zero senses get grey, zero lemmas and words get clear
          return ColorLib.setAlpha(ColorScheme.zeroOccurrenceSenseColor, ColorScheme.zeroAlpha);
        else
          // modulate path to root color
          return ColorLib.setAlpha(color, ColorScheme.zeroAlpha);
      }

      // initial alpha for zero and one count
      int alpha = ColorScheme.zeroAlpha;

      alpha += (int) (((float) total / (float) maxTotal) * (float) (255 - alpha));

      if (total < 0)
        System.err.println(
            "total: " + total + " node: " + item.getString("label") + " alpha: " + alpha);

      // this should not occur except for rounding errors
      if (alpha > 255) alpha = 255;

      return ColorLib.setAlpha(color, alpha);
    }
Пример #4
0
  /**
   * Create a new, empty FisheyeMenu.
   *
   * @see #addMenuItem(String, javax.swing.Action)
   */
  public FisheyeMenu() {
    super(new Visualization());
    m_vis.addTable(ITEMS, m_items);

    // set up the renderer to use
    LabelRenderer renderer = new LabelRenderer(LABEL);
    renderer.setHorizontalPadding(0);
    renderer.setVerticalPadding(1);
    renderer.setHorizontalAlignment(Constants.LEFT);
    m_vis.setRendererFactory(new DefaultRendererFactory(renderer));

    // set up this display
    setSize(100, 470);
    setHighQuality(true);
    setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 5));
    addControlListener(
        new ControlAdapter() {
          // dispatch an action event to the menu item
          public void itemClicked(VisualItem item, MouseEvent e) {
            ActionListener al = (ActionListener) item.get(ACTION);
            al.actionPerformed(
                new ActionEvent(item, e.getID(), "click", e.getWhen(), e.getModifiers()));
          }
        });

    // text color function
    // items with the mouse over printed in red, otherwise black
    ColorAction colors = new ColorAction(ITEMS, VisualItem.TEXTCOLOR);
    colors.setDefaultColor(ColorLib.gray(0));
    colors.add("hover()", ColorLib.rgb(255, 0, 0));

    // initial layout and coloring
    ActionList init = new ActionList();
    init.add(new VerticalLineLayout(m_maxHeight));
    init.add(colors);
    init.add(new RepaintAction());
    m_vis.putAction("init", init);

    // fisheye distortion based on the current anchor location
    ActionList distort = new ActionList();
    Distortion feye = new FisheyeDistortion(0, m_scale);
    distort.add(feye);
    distort.add(colors);
    distort.add(new RepaintAction());
    m_vis.putAction("distort", distort);

    // update the distortion anchor position to be the current
    // location of the mouse pointer
    addControlListener(new AnchorUpdateControl(feye, "distort"));
  }
Пример #5
0
    public int entropyColor(VisualItem item) {
      // color is fixed, what changes as a function of the value is the transparency (alpha)
      int color = sca.getColor(item);

      // lemmas and senses in the pathToRoot
      if (item.isInGroup("pathToRoot")
          && ((item.getInt("type") == 1) || (item.getInt("type") == 4)))
        color = ColorScheme.pathToRootColor;

      // count off -- just return color
      if (NodeColorAction.this.docuBurstActionList.countType.equals(DocuBurstActionList.NOCOUNT))
        return color;

      // float total = item.getFloat(DocuBurstActionList.CONDENTROPY);
      float total = item.getFloat(DocuBurstActionList.CONDENTROPY);
      float maxTotal =
          NodeColorAction.this.docuBurstActionList.getMaxTotal(DocuBurstActionList.CONDENTROPY);

      if (total < 0) color = ColorScheme.negativeColor;

      if (total == 0) {
        if (color != ColorScheme.pathToRootColor)
          // zero senses get grey, zero lemmas and words get clear
          return ColorLib.setAlpha(color, 255);
        else
          // modulate path to root color
          return ColorLib.setAlpha(color, ColorScheme.zeroAlpha);
      }

      // initial alpha for zero and one count
      int alpha = 10;

      float condEntropyMin = NodeColorAction.this.docuBurstActionList.getCondEntropyMinTotal();

      // alpha += (int) ( (1 - Math.log(total/maxTotal)/Math.log(condEntropyMin)) * (float) (255 -
      // alpha));
      alpha +=
          (int) ((Math.log(total / maxTotal) / Math.log(condEntropyMin)) * (float) (255 - alpha));

      if (total < 0)
        System.err.println(
            "total: " + total + " node: " + item.getString("label") + " alpha: " + alpha);

      // this should not occur except for rounding errors
      if (alpha > 255) alpha = 255;

      return ColorLib.setAlpha(color, alpha);
    }
Пример #6
0
    @Override
    public int getColor(VisualItem item) {

      // highlight border of glyphs for which search is true
      // TODO: thicker borders? more outstanding highlighting?
      // do (inefficient) manual comparison (for now)
      Iterator itemsInGroup = m_vis.getGroup(Visualization.SEARCH_ITEMS).tuples();
      while (itemsInGroup.hasNext()) {
        Tuple itemInGroup = (Tuple) itemsInGroup.next();
        if (item.getString(DocumentGridTable.NODE_NAME)
            .equals(itemInGroup.getString(DocumentGridTable.NODE_NAME))) {
          // debug
          //                    System.out.println("debug: "+this.getClass().getName()+": item in
          // group! "+item.toString());
          return ColorLib.rgb(191, 99, 130);
        }
      }

      if (item.isHover()) {
        return Color.LIGHT_GRAY.getRGB();
      }

      // default border color
      //            return ColorLib.gray(50);
      return Color.DARK_GRAY.getRGB();
    }
Пример #7
0
 /** @see prefuse.render.Renderer#render(java.awt.Graphics2D, prefuse.visual.VisualItem) */
 @Override
 public void render(Graphics2D g, VisualItem item) {
   // render the edge line
   super.render(g, item);
   // render the edge arrow head, if appropriate
   if (m_curArrow != null) {
     g.setPaint(ColorLib.getColor(item.getFillColor()));
     g.fill(m_curArrow);
   }
 }
Пример #8
0
  public ScatterPlot(Table t, String xfield, String yfield, String sfield) {
    super(new Visualization());

    // --------------------------------------------------------------------
    // STEP 1: setup the visualized data

    m_vis.addTable(group, t);

    DefaultRendererFactory rf = new DefaultRendererFactory(m_shapeR);
    m_vis.setRendererFactory(rf);

    // --------------------------------------------------------------------
    // STEP 2: create actions to process the visual data

    // set up the actions
    AxisLayout x_axis = new AxisLayout(group, xfield, Constants.X_AXIS, VisiblePredicate.TRUE);
    m_vis.putAction("x", x_axis);

    AxisLayout y_axis = new AxisLayout(group, yfield, Constants.Y_AXIS, VisiblePredicate.TRUE);
    m_vis.putAction("y", y_axis);

    ColorAction color = new ColorAction(group, VisualItem.STROKECOLOR, ColorLib.rgb(100, 100, 255));
    m_vis.putAction("color", color);

    DataShapeAction shape = new DataShapeAction(group, sfield);
    m_vis.putAction("shape", shape);

    ActionList draw = new ActionList();
    draw.add(x_axis);
    draw.add(y_axis);
    if (sfield != null) draw.add(shape);
    draw.add(color);
    draw.add(new RepaintAction());
    m_vis.putAction("draw", draw);

    // --------------------------------------------------------------------
    // STEP 3: set up a display and ui components to show the visualization

    setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10));
    setSize(700, 450);
    setHighQuality(true);

    ToolTipControl ttc = new ToolTipControl(new String[] {xfield, yfield});
    addControlListener(ttc);

    // --------------------------------------------------------------------
    // STEP 4: launching the visualization

    m_vis.run("draw");
  }
Пример #9
0
    /** @see prefuse.render.Renderer#render(java.awt.Graphics2D, prefuse.visual.VisualItem) */
    @Override
    public void render(Graphics2D g, VisualItem item) {
      Shape s = getShape(item);
      GraphicsLib.paint(g, item, m_line, getStroke(item), getRenderType(item));

      // check if we have a text label, if so, render it
      String str;
      if (item.canGetString(VisualItem.LABEL)) {
        str = (String) item.getString(VisualItem.LABEL);
        if (str != null && !str.equals("")) {
          float x = (float) m_box.getMinX();
          float y = (float) m_box.getMinY() + m_ascent;

          // draw label background
          GraphicsLib.paint(g, item, s, null, RENDER_TYPE_FILL);

          AffineTransform origTransform = g.getTransform();
          AffineTransform transform = this.getTransform(item);
          if (transform != null) {
            g.setTransform(transform);
          }

          g.setFont(item.getFont());
          g.setColor(ColorLib.getColor(item.getTextColor()));

          if (!(str.length() > 5
              && str.substring(str.length() - 5, str.length()).equals("_last"))) {

            g.setColor(Color.WHITE);
            // TODO properly hunt down source of null str! for now, triage
            if (str != null) {
              // bump y down by appropriate amount
              FontMetrics fm = g.getFontMetrics(item.getFont());
              int strHeight = fm.getAscent();
              //                        g.drawString(str, x, y);
              g.drawString(str, x, y + strHeight);
            }

            if (transform != null) {
              g.setTransform(origTransform);
            }
          }
        }
      }
    }
 public void renderText(Graphics2D g, VisualItem item, Shape shape) {
   String s = getText(item);
   int textColor = item.getTextColor();
   if (s != null) {
     Rectangle2D r = shape.getBounds2D();
     g.setPaint(ColorLib.getColor(textColor));
     g.setFont(m_font);
     FontMetrics fm = g.getFontMetrics();
     double size = item.getSize();
     double x = r.getX() + size * m_horizBorder;
     double y = r.getY() + size * m_vertBorder;
     g.drawString(s, (float) x, (float) y + fm.getAscent());
     // if ( isHyperlink(item) ) {
     // int lx = (int)Math.round(x), ly = (int)Math.round(y);
     // g.drawLine(lx,ly,lx+fm.stringWidth(s),ly+fm.getHeight()-1);
     // }
   }
 }
  /* (non-Javadoc)
   * @see org.lukep.javavis.visualisation.views.AbstractVisualisationView#visit(org.lukep.javavis.visualisation.visualisers.PrefuseVisualiser, org.lukep.javavis.ui.swing.WorkspaceContext, prefuse.Display)
   */
  @Override
  public void visit(PrefuseVisualiser visualiser, WorkspaceContext wspContext, Display display) {

    display.reset();

    // -- 1. load the data ------------------------------------------------

    Graph graph = new Graph();
    graph.addColumn("type", String.class);
    graph.addColumn("name", String.class);
    graph.addColumn("model", IGenericModelNode.class);
    graph.addColumn("metricMeasurement", double.class);

    // create package vertices
    ProjectModel modelStore = wspContext.getModelStore();
    HashMap<IGenericModelNode, Node> parentNodeMap =
        new HashMap<IGenericModelNode, Node>(modelStore.getPackageMap().size() + 10);
    Node curNode;

    for (PackageModel pkg : modelStore.getPackageMap().values()) {

      // add the package node
      curNode = graph.addNode();
      curNode.setString("type", pkg.getModelTypeName());
      curNode.setString("name", pkg.getSimpleName());
      curNode.set("model", pkg);

      // link to the parent with an edge
      IGenericModelNode parentPackage = pkg.getParent();
      if (parentPackage != null
          && parentPackage instanceof PackageModel
          && parentNodeMap.containsKey(parentPackage)) {

        // link to the parent package with an edge
        graph.addEdge(parentNodeMap.get(parentPackage), curNode);
      }

      parentNodeMap.put(pkg, curNode);
    }

    // create class and method nodes
    Queue<IGenericModelNode> modelQueue =
        new LinkedList<IGenericModelNode>(modelStore.getClassMap().values());
    IGenericModelNode model;

    while (modelQueue.peek() != null) {
      model = modelQueue.remove();

      curNode = graph.addNode();
      curNode.setString("type", model.getModelTypeName());
      curNode.setString("name", model.getSimpleName());
      curNode.set("model", model);

      // add children to iterModels
      if (model.getChildCount() > 0) {
        for (Relationship r : model.getChildren())
          if (r.getRelationshipType() == RelationshipType.ENCLOSED_IN)
            modelQueue.add(r.getTarget());
        parentNodeMap.put(model, curNode);
      }

      // link to the parent package
      if (parentNodeMap.containsKey(model.getParent())) {
        graph.addEdge(parentNodeMap.get(model.getParent()), curNode);
      }

      // grab metric measurement if applicable
      if (model instanceof IMeasurableNode
          && wspContext.getMetric().testAppliesTo(model.getModelTypeName())) {
        curNode.setDouble(
            "metricMeasurement",
            ((IMeasurableNode) (model)).getMetricMeasurement(wspContext.getMetric()).getResult());
      }
    }

    // -- 2. the visualisation --------------------------------------------

    // TODO implement a Visualization cache
    Visualization vis = new Visualization();
    vis.add("graph", graph);
    vis.setInteractive("graph.edges", null, false);

    // -- 3. the renderers and renderer factory ---------------------------

    LabelRenderer r = new LabelRenderer("name");
    r.setRoundedCorner(8, 8);

    vis.setRendererFactory(new DefaultRendererFactory(r));

    // -- 4. the processing actions ---------------------------------------

    // create our nominal color palette
    // pink for classes, baby blue for packages
    int[] palette = ColorLib.getCoolPalette();
    // create a metric palette
    int[] mPalette = ColorLib.getInterpolatedPalette(0xFF00AA6D, 0xFFFFAA6D);

    // TODO replace
    int[] mPalette2 = new int[mPalette.length + 1];
    mPalette2[0] = Color.lightGray.getRGB();
    for (int i = 1; i < mPalette.length; i++) mPalette2[i] = mPalette[i];

    // map nominal data values to colors using our provided palette
    DataColorAction fill =
        new DataColorAction(
            "graph.nodes", "type", Constants.NOMINAL, VisualItem.FILLCOLOR, palette);
    DataColorAction fillMetrics =
        new DataColorAction(
            "graph.nodes",
            "metricMeasurement",
            Constants.NUMERICAL,
            VisualItem.FILLCOLOR,
            mPalette2);
    // use black for node text
    ColorAction text = new ColorAction("graph.nodes", VisualItem.TEXTCOLOR, ColorLib.gray(0));
    // use light grey for edges
    ColorAction edges = new ColorAction("graph.edges", VisualItem.STROKECOLOR, ColorLib.gray(200));

    // create an action list containing all color assignments
    ActionList colour = new ActionList();
    colour.add(fillMetrics);
    colour.add(text);
    colour.add(edges);

    // create an action list with an animated layout
    ActionList layout = new ActionList(Activity.INFINITY);
    // layout.add(new ForceDirectedLayout("graph"));
    layout.add(new NodeLinkTreeLayout("graph"));
    layout.add(new RepaintAction());

    // add the actions to the visualisation
    vis.putAction("colour", colour);
    vis.putAction("layout", layout);

    // -- 5. the display and interactive controls -------------------------

    display.setVisualization(vis);

    // -- 6. launch the visualization -------------------------------------

    vis.run("colour");
    vis.run("layout");
  }
Пример #12
0
 public TextColorAction(String group) {
   super(group, VisualItem.TEXTCOLOR, ColorLib.gray(0));
   add("_hover", ColorLib.rgb(255, 0, 0));
 }
Пример #13
0
 public NodeColorAction(
     DocuBurstActionList docuBurstActionList, String group, boolean trackSenseIndex) {
   super(group, VisualItem.FILLCOLOR, ColorLib.rgba(100, 100, 100, 0));
   this.docuBurstActionList = docuBurstActionList;
   add("type = 1", new WordCountColorAction(group, VisualItem.FILLCOLOR));
 }
  public Congress(Table t) {
    super(new BorderLayout());

    // --------------------------------------------------------------------
    // STEP 1: setup the visualized data

    final Visualization vis = new Visualization();
    m_vis = vis;

    final String group = "by_state";

    // filter to show only candidates receiving more than $100,000
    Predicate p = (Predicate) ExpressionParser.parse("[" + TOTAL_RECEIPTS + "] >= 100000");
    VisualTable vt = vis.addTable(group, t, p);

    // add a new column containing a label string showing
    // candidate name, party, state, year, and total receipts
    vt.addColumn(
        "label",
        "CONCAT(CAP(Candidate), ' (', "
            + "CAP([Party Designation]), '-', [State Code], "
            + "') ', Year, ': $', FORMAT([Total Receipts],2))");

    // add calculation for senators
    vt.addColumn("Senate", "District <= 0");

    vis.setRendererFactory(
        new RendererFactory() {
          AbstractShapeRenderer sr = new ShapeRenderer();
          Renderer arY = new AxisRenderer(Constants.RIGHT, Constants.TOP);
          Renderer arX = new AxisRenderer(Constants.CENTER, Constants.FAR_BOTTOM);

          public Renderer getRenderer(VisualItem item) {
            return item.isInGroup("ylab") ? arY : item.isInGroup("xlab") ? arX : sr;
          }
        });

    // --------------------------------------------------------------------
    // STEP 2: create actions to process the visual data

    // set up dynamic queries, search set
    RangeQueryBinding receiptsQ = new RangeQueryBinding(vt, RECEIPTS);
    ListQueryBinding yearsQ = new ListQueryBinding(vt, "Year");
    SearchQueryBinding searchQ = new SearchQueryBinding(vt, "Candidate");

    // construct the filtering predicate
    AndPredicate filter = new AndPredicate(searchQ.getPredicate());
    filter.add(yearsQ.getPredicate());
    filter.add(receiptsQ.getPredicate());

    // set up the actions
    AxisLayout xaxis = new AxisLayout(group, "State Code", Constants.X_AXIS, VisiblePredicate.TRUE);
    AxisLayout yaxis = new AxisLayout(group, RECEIPTS, Constants.Y_AXIS, VisiblePredicate.TRUE);
    // yaxis.setScale(Constants.LOG_SCALE);
    yaxis.setRangeModel(receiptsQ.getModel());
    receiptsQ.getNumberModel().setValueRange(0, 65000000, 0, 65000000);

    xaxis.setLayoutBounds(m_dataB);
    yaxis.setLayoutBounds(m_dataB);

    AxisLabelLayout ylabels = new AxisLabelLayout("ylab", yaxis, m_ylabB);
    NumberFormat nf = NumberFormat.getCurrencyInstance();
    nf.setMaximumFractionDigits(0);
    ylabels.setNumberFormat(nf);

    AxisLabelLayout xlabels = new AxisLabelLayout("xlab", xaxis, m_xlabB, 15);
    vis.putAction("xlabels", xlabels);

    // dems = blue, reps = red, other = gray
    int[] palette =
        new int[] {
          ColorLib.rgb(150, 150, 255), ColorLib.rgb(255, 150, 150), ColorLib.rgb(180, 180, 180)
        };
    DataColorAction color =
        new DataColorAction(group, "Party", Constants.ORDINAL, VisualItem.STROKECOLOR, palette);

    int[] shapes = new int[] {Constants.SHAPE_RECTANGLE, Constants.SHAPE_DIAMOND};
    DataShapeAction shape = new DataShapeAction(group, "Senate", shapes);

    Counter cntr = new Counter(group);

    ActionList draw = new ActionList();
    draw.add(cntr);
    draw.add(color);
    draw.add(shape);
    draw.add(xaxis);
    draw.add(yaxis);
    draw.add(ylabels);
    draw.add(new ColorAction(group, VisualItem.FILLCOLOR, 0));
    draw.add(new RepaintAction());
    vis.putAction("draw", draw);

    ActionList update = new ActionList();
    update.add(new VisibilityFilter(group, filter));
    update.add(cntr);
    update.add(xaxis);
    update.add(yaxis);
    update.add(ylabels);
    update.add(new RepaintAction());
    vis.putAction("update", update);

    UpdateListener lstnr =
        new UpdateListener() {
          public void update(Object src) {
            vis.run("update");
          }
        };
    filter.addExpressionListener(lstnr);

    // --------------------------------------------------------------------
    // STEP 4: set up a display and ui components to show the visualization

    m_display = new Display(vis);
    m_display.setItemSorter(
        new ItemSorter() {
          public int score(VisualItem item) {
            int score = super.score(item);
            if (item.isInGroup(group)) score += item.getInt(TOTAL_RECEIPTS);
            return score;
          }
        });
    m_display.setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10));
    m_display.setSize(700, 450);
    m_display.setHighQuality(true);
    m_display.addComponentListener(
        new ComponentAdapter() {
          public void componentResized(ComponentEvent e) {
            displayLayout();
          }
        });
    displayLayout();

    m_details = new JFastLabel(m_title);
    m_details.setPreferredSize(new Dimension(75, 20));
    m_details.setVerticalAlignment(SwingConstants.BOTTOM);

    m_total.setPreferredSize(new Dimension(500, 20));
    m_total.setHorizontalAlignment(SwingConstants.RIGHT);
    m_total.setVerticalAlignment(SwingConstants.BOTTOM);

    ToolTipControl ttc = new ToolTipControl("label");
    Control hoverc =
        new ControlAdapter() {
          public void itemEntered(VisualItem item, MouseEvent evt) {
            if (item.isInGroup(group)) {
              m_total.setText(item.getString("label"));
              item.setFillColor(item.getStrokeColor());
              item.setStrokeColor(ColorLib.rgb(0, 0, 0));
              item.getVisualization().repaint();
            }
          }

          public void itemExited(VisualItem item, MouseEvent evt) {
            if (item.isInGroup(group)) {
              m_total.setText(m_totalStr);
              item.setFillColor(item.getEndFillColor());
              item.setStrokeColor(item.getEndStrokeColor());
              item.getVisualization().repaint();
            }
          }
        };
    m_display.addControlListener(ttc);
    m_display.addControlListener(hoverc);

    // --------------------------------------------------------------------
    // STEP 5: launching the visualization

    this.addComponentListener(lstnr);

    // details
    Box infoBox = new Box(BoxLayout.X_AXIS);
    infoBox.add(Box.createHorizontalStrut(5));
    infoBox.add(m_details);
    infoBox.add(Box.createHorizontalGlue());
    infoBox.add(Box.createHorizontalStrut(5));
    infoBox.add(m_total);
    infoBox.add(Box.createHorizontalStrut(5));

    // set up search box
    JSearchPanel searcher = searchQ.createSearchPanel();
    searcher.setLabelText("Candidate: ");
    searcher.setBorder(BorderFactory.createEmptyBorder(5, 5, 5, 0));

    // create dynamic queries
    Box radioBox = new Box(BoxLayout.X_AXIS);
    radioBox.add(Box.createHorizontalStrut(5));
    radioBox.add(searcher);
    radioBox.add(Box.createHorizontalGlue());
    radioBox.add(Box.createHorizontalStrut(5));
    radioBox.add(yearsQ.createRadioGroup());
    radioBox.add(Box.createHorizontalStrut(16));

    JRangeSlider slider = receiptsQ.createVerticalRangeSlider();
    slider.setThumbColor(null);
    slider.setMinExtent(150000);
    slider.addMouseListener(
        new MouseAdapter() {
          public void mousePressed(MouseEvent e) {
            m_display.setHighQuality(false);
          }

          public void mouseReleased(MouseEvent e) {
            m_display.setHighQuality(true);
            m_display.repaint();
          }
        });

    vis.run("draw");
    vis.run("xlabels");

    add(infoBox, BorderLayout.NORTH);
    add(m_display, BorderLayout.CENTER);
    add(slider, BorderLayout.EAST);
    add(radioBox, BorderLayout.SOUTH);
    UILib.setColor(this, ColorLib.getColor(255, 255, 255), Color.GRAY);
    slider.setForeground(Color.LIGHT_GRAY);
    UILib.setFont(radioBox, FontLib.getFont("Tahoma", 15));
    m_details.setFont(FontLib.getFont("Tahoma", 18));
    m_total.setFont(FontLib.getFont("Tahoma", 16));
  }
Пример #15
0
  public trial(int st, String n) {

    // setup a visualisation
    super(new Visualization());

    System.out.println(st + "  " + n);

    // generate a graph
    initGraph(n, st);

    //  standard labelRenderer for the given label
    LabelRenderer nodeRenderer = new LabelRenderer(LABEL);
    // rendererFactory for the visualization items
    DefaultRendererFactory rendererFactory = new DefaultRendererFactory();
    // set the labelRenderer
    rendererFactory.setDefaultRenderer(nodeRenderer);
    m_vis.setRendererFactory(rendererFactory);

    // Color Actions
    ColorAction nodeText = new ColorAction(NODES, VisualItem.TEXTCOLOR);
    nodeText.setDefaultColor(ColorLib.gray(0));
    ColorAction nodeStroke = new ColorAction(NODES, VisualItem.STROKECOLOR);
    nodeStroke.setDefaultColor(ColorLib.gray(100));
    ColorAction nodeFill = new ColorAction(NODES, VisualItem.FILLCOLOR);
    nodeFill.setDefaultColor(ColorLib.gray(255));
    ColorAction edgeStrokes = new ColorAction(EDGES, VisualItem.STROKECOLOR);
    edgeStrokes.setDefaultColor(ColorLib.gray(100));

    // ColorAction fill = new ColorAction(NODES, VisualItem.FILLCOLOR,
    ColorLib.rgb(200, 200, 255);
    // fill.add(VisualItem.FIXED, ColorLib.rgb(255,100,100));
    // fill.add(VisualItem.HIGHLIGHT, ColorLib.rgb(255,200,125));

    // bundle the color actions
    ActionList draw = new ActionList();
    //    draw.add(fill);
    draw.add(new ColorAction(NODES, VisualItem.STROKECOLOR, 0));
    draw.add(new ColorAction(NODES, VisualItem.TEXTCOLOR, ColorLib.rgb(0, 0, 0)));
    draw.add(new ColorAction(EDGES, VisualItem.FILLCOLOR, ColorLib.gray(200)));
    draw.add(new ColorAction(EDGES, VisualItem.STROKECOLOR, ColorLib.gray(200)));
    draw.add(nodeText);
    draw.add(nodeStroke);
    draw.add(nodeFill);
    draw.add(edgeStrokes);

    ActionList animate = new ActionList(Activity.INFINITY);
    //   animate.add(fill);
    animate.add(new RepaintAction());

    m_nodeRenderer = new LabelRenderer(m_label);

    m_nodeRenderer.setRenderType(AbstractShapeRenderer.RENDER_TYPE_FILL);
    m_nodeRenderer.setHorizontalAlignment(Constants.LEFT);
    m_nodeRenderer.setRoundedCorner(8, 8);
    m_edgeRenderer = new EdgeRenderer(Constants.EDGE_TYPE_CURVE);

    DefaultRendererFactory rf = new DefaultRendererFactory(m_nodeRenderer);
    m_vis.setRendererFactory(rf);

    // DataSizeAction
    DataSizeAction nodeDataSizeAction = new DataSizeAction(NODES, SIZE);
    draw.add(nodeDataSizeAction);
    m_vis.putAction("draw", draw);
    m_vis.putAction("layout", animate);

    m_vis.runAfter("draw", "layout");

    // create the layout action for the graph
    NodeLinkTreeLayout treeLayout = new NodeLinkTreeLayout(GRAPH, m_orientation, 80, 5, 10);
    treeLayout.setLayoutAnchor(new Point2D.Double(250, -150));
    m_vis.putAction("treeLayout", treeLayout);
    m_vis.addFocusGroup("selected");

    CollapsedSubtreeLayout subLayout = new CollapsedSubtreeLayout(GRAPH, m_orientation);
    m_vis.putAction("subLayout", subLayout);

    m_vis.run("treeLayout");
    m_vis.run("draw");

    pan(250, 250);
    setHighQuality(true);
    addControlListener(new ZoomControl());
    addControlListener(new PanControl());
    addControlListener(new DragControl(true));
    addControlListener(new NodeClicked());
    addControlListener(new FocusControl());

    registerKeyboardAction(
        new OrientAction(Constants.ORIENT_LEFT_RIGHT),
        "left-to-right",
        KeyStroke.getKeyStroke("ctrl 1"),
        WHEN_FOCUSED);
    registerKeyboardAction(
        new OrientAction(Constants.ORIENT_TOP_BOTTOM),
        "top-to-bottom",
        KeyStroke.getKeyStroke("ctrl 2"),
        WHEN_FOCUSED);
    registerKeyboardAction(
        new OrientAction(Constants.ORIENT_RIGHT_LEFT),
        "right-to-left",
        KeyStroke.getKeyStroke("ctrl 3"),
        WHEN_FOCUSED);
    registerKeyboardAction(
        new OrientAction(Constants.ORIENT_BOTTOM_TOP),
        "bottom-to-top",
        KeyStroke.getKeyStroke("ctrl 4"),
        WHEN_FOCUSED);
    TupleSet search = new PrefixSearchTupleSet();
    m_vis.addFocusGroup(Visualization.SEARCH_ITEMS, search);
    search.addTupleSetListener(
        new TupleSetListener() {
          public void tupleSetChanged(TupleSet t, Tuple[] add, Tuple[] rem) {
            m_vis.cancel("animatePaint");
            m_vis.run("fullPaint");
            m_vis.run("animatePaint");
          }
        });
  }
Пример #16
0
  public PhysioMapRadialGraphView(
      SemGenSettings sets, Graph g, String label, SemSimModel semsimmodel) {
    super(new Visualization());
    this.semsimmodel = semsimmodel;

    // -- set up visualization --
    m_vis.add(tree, g);
    m_vis.setInteractive(treeEdges, null, false);

    // -- set up renderers --
    LabelRenderer m_nodeRenderer = new LabelRenderer(label);
    m_nodeRenderer.setRenderType(AbstractShapeRenderer.RENDER_TYPE_DRAW_AND_FILL);
    m_nodeRenderer.setHorizontalAlignment(Constants.CENTER);
    m_nodeRenderer.setRoundedCorner(8, 8);
    EdgeRenderer m_edgeRenderer =
        new EdgeRenderer(Constants.EDGE_TYPE_LINE, prefuse.Constants.EDGE_ARROW_REVERSE);
    m_edgeRenderer.setArrowType(prefuse.Constants.EDGE_ARROW_REVERSE);
    m_edgeRenderer.setArrowHeadSize(8, 8);

    // MAYBE HERE?
    DefaultRendererFactory rf = new DefaultRendererFactory(m_nodeRenderer);
    rf.add(new InGroupPredicate(treeEdges), m_edgeRenderer);
    m_vis.setRendererFactory(rf);
    // m_vis.

    // -- set up processing actions --
    // colors
    ItemAction nodeColor = new NodeColorAction(treeNodes);
    ItemAction borderColor = new BorderColorAction(treeNodes);
    m_vis.putAction("borderColor", borderColor);
    ItemAction textColor = new TextColorAction(treeNodes);
    m_vis.putAction("textColor", textColor);
    ItemAction edgeColor =
        new ColorAction(treeEdges, VisualItem.STROKECOLOR, ColorLib.rgb(0, 0, 0));
    ItemAction arrowColor = new ArrowColorAction(treeEdges);
    m_vis.putAction("arrowColor", arrowColor);

    FontAction fonts = new FontAction(treeNodes, FontLib.getFont("Verdana", 12));
    fonts.add("ingroup('_focus_')", FontLib.getFont("Verdana", 12));

    // recolor
    // When recolor, do these actions
    ActionList recolor = new ActionList();
    recolor.add(nodeColor);
    recolor.add(borderColor);
    recolor.add(textColor);
    recolor.add(arrowColor);
    m_vis.putAction("recolor", recolor);

    // repaint
    ActionList repaint = new ActionList();
    repaint.add(recolor);
    repaint.add(new RepaintAction());
    m_vis.putAction("repaint", repaint);

    // animate paint change
    ActionList animatePaint = new ActionList(400);
    animatePaint.add(new ColorAnimator(treeNodes));
    animatePaint.add(new RepaintAction());
    m_vis.putAction("animatePaint", animatePaint);

    // create the tree layout action
    RadialTreeLayout treeLayout = new RadialTreeLayout(tree);
    treeLayout.setAutoScale(true);
    m_vis.putAction("treeLayout", treeLayout);

    CollapsedSubtreeLayout subLayout = new CollapsedSubtreeLayout(tree);
    m_vis.putAction("subLayout", subLayout);

    // create the filtering and layout
    ActionList filter = new ActionList();
    filter.add(new TreeRootAction(tree));
    filter.add(fonts);
    filter.add(treeLayout);
    filter.add(borderColor);
    filter.add(subLayout);
    filter.add(textColor);
    filter.add(nodeColor);
    filter.add(edgeColor);
    filter.add(arrowColor);
    m_vis.putAction("filter", filter);

    // animated transition
    ActionList animate = new ActionList(700);
    animate.setPacingFunction(new SlowInSlowOutPacer());
    animate.add(new QualityControlAnimator());
    animate.add(new VisibilityAnimator(tree));
    animate.add(new PolarLocationAnimator(treeNodes, linear));
    animate.add(new ColorAnimator(treeNodes));
    animate.add(new RepaintAction());
    m_vis.putAction("animate", animate);
    m_vis.alwaysRunAfter("filter", "animate");
    // ------------------------------------------------

    // initialize the display

    setSize(sets.getAppWidth() - ExtractorTab.leftpanewidth - 50, sets.getAppHeight() - 235);
    setItemSorter(new TreeDepthItemSorter());
    addControlListener(new DragControl());
    addControlListener(new ZoomToFitControl());
    addControlListener(new ZoomControl());
    addControlListener(new PanControl());
    addControlListener(new FocusControl(1, "filter"));
    addControlListener(new HoverActionControl("repaint"));

    // ------------------------------------------------

    // filter graph and perform layout
    m_vis.run("filter");

    // maintain a set of items that should be interpolated linearly
    // this isn't absolutely necessary, but makes the animations nicer
    // the PolarLocationAnimator should read this set and act accordingly
    m_vis.addFocusGroup(linear, new DefaultTupleSet());
    m_vis
        .getGroup(Visualization.FOCUS_ITEMS)
        .addTupleSetListener(
            new TupleSetListener() {
              public void tupleSetChanged(TupleSet t, Tuple[] add, Tuple[] rem) {
                TupleSet linearInterp = m_vis.getGroup(linear);
                if (add.length < 1) return;
                linearInterp.clear();
                for (Node n = (Node) add[0]; n != null; n = n.getParent()) linearInterp.addTuple(n);
              }
            });

    SearchTupleSet search = new PrefixSearchTupleSet();
    m_vis.addFocusGroup(Visualization.SEARCH_ITEMS, search);
    search.addTupleSetListener(
        new TupleSetListener() {
          public void tupleSetChanged(TupleSet t, Tuple[] add, Tuple[] rem) {
            m_vis.cancel("animatePaint");
            m_vis.run("recolor");
            m_vis.run("animatePaint");
          }
        });
  }
Пример #17
0
  static {
    // EDGE_COLORS.put("refers_to", ColorLib.rgb(0, 0, 0));

    QUERYSET_COLORS.put("start", ColorLib.rgb(0, 175, 0));
    QUERYSET_COLORS.put("source", ColorLib.rgb(0, 175, 0));
    QUERYSET_COLORS.put("end", ColorLib.rgb(220, 0, 0));
    QUERYSET_COLORS.put("target", ColorLib.rgb(220, 0, 0));
    QUERYSET_COLORS.put("start,end", ColorLib.rgb(220, 0, 220));
    QUERYSET_COLORS.put("source,target", ColorLib.rgb(220, 0, 220));
    QUERYSET_COLORS.put("rank", ColorLib.rgb(0, 175, 220));

    NODE_COLORS.put("Node", ColorLib.rgb(240, 240, 240));

    // Saturated greens
    NODE_COLORS.put("Sequence", ColorLib.rgb(211, 247, 163));
    NODE_COLORS.put("Gene", ColorLib.rgb(211, 247, 163));
    NODE_COLORS.put("Protein", ColorLib.rgb(199, 240, 178));
    NODE_COLORS.put("Enzyme", ColorLib.rgb(193, 234, 174));
    // NODE_COLORS.put("ProteinGroup", ColorLib.rgb(199, 240, 178));
    NODE_COLORS.put("AllelicVariant", ColorLib.rgb(199, 240, 178));

    // Beige
    NODE_COLORS.put("Article", ColorLib.rgb(250, 230, 160));

    // Cyans (to do, make greener)
    NODE_COLORS.put("HomologGroup", ColorLib.rgb(187, 237, 215));
    NODE_COLORS.put("OrthologGroup", ColorLib.rgb(194, 237, 218));

    // Desaturated blues
    NODE_COLORS.put("GO", ColorLib.rgb(185, 218, 234));
    NODE_COLORS.put("BiologicalProcess", ColorLib.rgb(185, 218, 234));
    NODE_COLORS.put("MolecularFunction", ColorLib.rgb(189, 223, 239));
    NODE_COLORS.put("CellularComponent", ColorLib.rgb(174, 214, 234));

    // Light purples
    NODE_COLORS.put("Ligand", ColorLib.rgb(210, 203, 240));
    NODE_COLORS.put("Substance", ColorLib.rgb(210, 203, 240));
    NODE_COLORS.put("Compound", ColorLib.rgb(210, 203, 240));
    NODE_COLORS.put("Drug", ColorLib.rgb(203, 196, 233));
    NODE_COLORS.put("Glycan", ColorLib.rgb(198, 200, 242));

    // Pink
    NODE_COLORS.put("GenomicContext", ColorLib.rgb(255, 215, 253));

    // Blues
    NODE_COLORS.put("Locus", ColorLib.rgb(180, 196, 239)); // unused
    NODE_COLORS.put("Phenotype", ColorLib.rgb(193, 209, 255));
    // NODE_COLORS.put("Locus/Phenotype, ColorLib.rgb(195, 199, 242));

    // TMP MAPPING for illustration purposes BY LERONEN! Should never get to SVN!
    NODE_COLORS.put("Gene/Phenotype", ColorLib.rgb(211, 247, 163));
    //        NODE_COLORS.put("Gene/Phenotype", ColorLib.rgb(193, 223, 242));

    // Greens
    NODE_COLORS.put("Family", ColorLib.rgb(179, 226, 192));
    NODE_COLORS.put("Region", ColorLib.rgb(195, 229, 204));
    NODE_COLORS.put("Domain", ColorLib.rgb(195, 229, 204));
    NODE_COLORS.put("Repeat", ColorLib.rgb(195, 229, 204));
    NODE_COLORS.put("Site", ColorLib.rgb(190, 229, 201));
    NODE_COLORS.put("ActiveSite", ColorLib.rgb(190, 229, 201));
    NODE_COLORS.put("BindingSite", ColorLib.rgb(190, 229, 201));
    NODE_COLORS.put("PostTranslationalModification", ColorLib.rgb(190, 229, 201));

    // Purple
    NODE_COLORS.put("Pathway", ColorLib.rgb(208, 185, 231));

    // Browns
    NODE_COLORS.put("Tissue", ColorLib.rgb(229, 218, 189));
    // NODE_COLORS.put("Organism", ColorLib.rgb(229, 215, 177));
    NODE_COLORS.put("MeSHHeading", ColorLib.rgb(239, 231, 176));
    NODE_COLORS.put("OMIM", ColorLib.rgb(239, 231, 176));
  }
Пример #18
0
 public ArrowColorAction(String group) {
   super(group, VisualItem.FILLCOLOR, ColorLib.rgb(0, 0, 0));
 }
Пример #19
0
  public static JComponent demo(Graph g, String label) {

    // create a new, empty visualization for our data
    final Visualization vis = new Visualization();
    VisualGraph vg = vis.addGraph(graph, g);
    vis.setValue(edges, null, VisualItem.INTERACTIVE, Boolean.FALSE);
    int[] palette =
        new int[] {
          ColorLib.rgb(77, 175, 74),
          ColorLib.rgb(55, 126, 184),
          ColorLib.rgb(228, 26, 28),
          ColorLib.rgb(152, 78, 163),
          ColorLib.rgb(255, 127, 0)
        };

    int[] shape_palette =
        new int[] {Constants.SHAPE_ELLIPSE, Constants.SHAPE_RECTANGLE, Constants.SHAPE_TRIANGLE_UP};

    TupleSet focusGroup = vis.getGroup(Visualization.FOCUS_ITEMS);
    focusGroup.addTupleSetListener(
        new TupleSetListener() {
          public void tupleSetChanged(TupleSet ts, Tuple[] add, Tuple[] rem) {
            for (int i = 0; i < rem.length; ++i) ((VisualItem) rem[i]).setFixed(false);
            for (int i = 0; i < add.length; ++i) {
              ((VisualItem) add[i]).setFixed(false);
              ((VisualItem) add[i]).setFixed(true);
            }
            vis.run("draw");
          }
        });

    // set up the renderers

    /*      ShapeRenderer s = new ShapeRenderer();
    s.rectangle(0, 0, 30, 30);
    vis.setRendererFactory(new DefaultRendererFactory(s));*/

    MyRenderer tr = new MyRenderer(label);
    // MyRenderer tr = new MyRenderer(label);
    DefaultRendererFactory d = new DefaultRendererFactory(tr);

    EdgeRenderer MyEdgeRenderer = new EdgeRenderer();
    d.add(new InGroupPredicate(edges), MyEdgeRenderer);
    vis.setRendererFactory(d);

    // -- set up the actions ----------------------------------------------

    int maxhops = 1024, hops = 1024;
    final GraphDistanceFilter filter = new GraphDistanceFilter(graph, hops);

    ActionList draw = new ActionList();
    draw.add(filter);

    // draw.add(new ColorAction(nodes, VisualItem.FILLCOLOR, ColorLib.rgb(180,180,255)));
    draw.add(new ColorAction(nodes, VisualItem.STROKECOLOR, 0));
    draw.add(new ColorAction(nodes, VisualItem.TEXTCOLOR, ColorLib.rgb(0, 0, 0)));
    draw.add(new ColorAction(edges, VisualItem.FILLCOLOR, ColorLib.gray(100)));
    draw.add(new ColorAction(edges, VisualItem.STROKECOLOR, ColorLib.gray(170)));
    draw.add(new DataShapeAction(nodes, "type", shape_palette));

    DataColorAction fill =
        new DataColorAction(
            "graph.nodes", "type", Constants.NOMINAL, VisualItem.FILLCOLOR, palette);
    // use black for node text
    ColorAction text = new ColorAction("graph.nodes", VisualItem.TEXTCOLOR, ColorLib.gray(0));
    // use light grey for edges
    ColorAction edges = new ColorAction("graph.edges", VisualItem.STROKECOLOR, ColorLib.gray(200));

    // create an action list containing all color assignments
    ActionList color = new ActionList();
    color.add(fill);
    color.add(text);
    color.add(edges);

    //        ColorAction fill = new ColorAction(nodes,
    //                VisualItem.FILLCOLOR, ColorLib.rgb(200,200,255));
    fill.add("_fixed", ColorLib.rgb(255, 100, 100));
    fill.add("_highlight", ColorLib.rgb(255, 200, 125));

    // Instead have to use  GridLayout here - how do i create
    ForceDirectedLayout fdl = new ForceDirectedLayout(graph);
    // GridLayout fdl = new GridLayout(graph);
    ForceSimulator fsim = fdl.getForceSimulator();
    fsim.getForces()[0].setParameter(0, -5f);

    ActionList animate = new ActionList(Activity.INFINITY);
    // ActionList animate = new ActionList(vis);

    animate.add(fdl);
    animate.add(fill);
    animate.add(new RepaintAction());

    // finally, we register our ActionList with the Visualization.
    // we can later execute our Actions by invoking a method on our
    // Visualization, using the name we've chosen below.
    vis.putAction("draw", draw);
    vis.putAction("layout", animate);
    vis.runAfter("draw", "layout");
    vis.putAction("color", color);
    // vis.putAction("layout", layout);

    // --------------------------------------------------------------------
    // STEP 4: set up a display to show the visualization

    Display display = new Display(vis);
    display.setSize(2000, 2000);
    display.setForeground(Color.GRAY);
    display.setBackground(Color.WHITE);

    // main display controls
    display.addControlListener(new FocusControl(1));
    display.addControlListener(new DragControl());
    display.addControlListener(new PanControl());
    display.addControlListener(new ZoomControl());
    display.addControlListener(new WheelZoomControl());
    display.addControlListener(new ZoomToFitControl());
    display.addControlListener(new NeighborHighlightControl());

    display.setForeground(Color.GRAY);
    display.setBackground(Color.WHITE);

    // --------------------------------------------------------------------
    // STEP 5: launching the visualization

    // create a panel for editing force values
    final JForcePanel fpanel = new JForcePanel(fsim);

    final JValueSlider slider = new JValueSlider("Distance", 0, maxhops, hops);
    slider.addChangeListener(
        new ChangeListener() {
          public void stateChanged(ChangeEvent e) {
            filter.setDistance(slider.getValue().intValue());
            vis.run("draw");
          }
        });
    slider.setBackground(Color.WHITE);
    slider.setPreferredSize(new Dimension(300, 30));
    slider.setMaximumSize(new Dimension(300, 30));

    Box cf = new Box(BoxLayout.Y_AXIS);
    cf.add(slider);
    cf.setBorder(BorderFactory.createTitledBorder("Connectivity Filter"));
    fpanel.add(cf);

    fpanel.add(Box.createVerticalGlue());

    // create a new JSplitPane to present the interface
    JSplitPane split = new JSplitPane();
    split.setLeftComponent(display);
    split.setRightComponent(fpanel);
    split.setOneTouchExpandable(true);
    split.setContinuousLayout(false);
    split.setDividerLocation(530);
    split.setDividerLocation(800);

    // position and fix the default focus node
    NodeItem focus = (NodeItem) vg.getNode(0);
    PrefuseLib.setX(focus, null, 400);
    PrefuseLib.setY(focus, null, 250);
    focusGroup.setTuple(focus);

    // now we run our action list and return
    return split;
  }
 public int getColor(VisualItem item) {
   if (m_vis.isInGroup(item, Visualization.SEARCH_ITEMS)) return ColorLib.rgb(255, 190, 190);
   else if (m_vis.isInGroup(item, Visualization.FOCUS_ITEMS)) return ColorLib.rgb(198, 229, 229);
   else if (item.getDOI() > -1) return ColorLib.rgb(164, 193, 193);
   else return ColorLib.rgba(255, 255, 255, 0);
 }
  public ConcordanceTree() {
    super(new Visualization());

    m_display_self = this;
    m_label = NAME;

    tree = new Tree();
    Table ntable = tree.getNodeTable();
    ntable.addColumn(NAME, String.class);
    ntable.addColumn(NODECOUNT, int.class);
    ntable.addColumn(ROWCOUNT, int.class);
    resetTree();

    m_vis.add(TREE, tree);
    // m_vis.add(TREE, t, new WordCountPredicate());

    m_nodeRenderer = new LabelRenderer(m_label);
    m_nodeRenderer.setRenderType(AbstractShapeRenderer.RENDER_TYPE_FILL);
    m_nodeRenderer.setHorizontalAlignment(Constants.LEFT);
    m_nodeRenderer.setRoundedCorner(8, 8);
    m_edgeRenderer = new EdgeRenderer(Constants.EDGE_TYPE_CURVE);

    DefaultRendererFactory rf = new DefaultRendererFactory(m_nodeRenderer);
    rf.add(new InGroupPredicate(TREEEDGES), m_edgeRenderer);
    m_vis.setRendererFactory(rf);

    // colors
    ItemAction nodeColor = new NodeColorAction(TREENODES);
    ItemAction textColor = new ColorAction(TREENODES, VisualItem.TEXTCOLOR, ColorLib.rgb(0, 0, 0));
    m_vis.putAction("textColor", textColor);

    ItemAction edgeColor =
        new ColorAction(TREEEDGES, VisualItem.STROKECOLOR, ColorLib.rgb(255, 155, 155));

    // quick repaint
    ActionList repaint = new ActionList();
    repaint.add(nodeColor);
    // WordSizeAction wsaction = new WordSizeAction(TREEEDGES);
    repaint.add(new RepaintAction());
    m_vis.putAction("repaint", repaint);

    // full paint
    ActionList fullPaint = new ActionList();
    fullPaint.add(nodeColor);
    m_vis.putAction("fullPaint", fullPaint);

    // animate paint change
    ActionList animatePaint = new ActionList(400);
    animatePaint.add(new ColorAnimator(TREENODES));
    animatePaint.add(new RepaintAction());
    m_vis.putAction("animatePaint", animatePaint);

    // create the tree layout action
    NodeLinkTreeLayout treeLayout = new NodeLinkTreeLayout(TREE, m_orientation, 10, 0, 0);

    Point2D anchor = new Point2D.Double(25, HEIGHT / 2);
    treeLayout.setLayoutAnchor(anchor);
    m_vis.putAction("treeLayout", treeLayout);

    CollapsedSubtreeLayout subLayout = new CollapsedSubtreeLayout(TREE, m_orientation);
    m_vis.putAction("subLayout", subLayout);

    AutoPanAction autoPan = new AutoPanAction();
    AutoCenterAction autocenter = new AutoCenterAction();
    AutoFitAction autofit = new AutoFitAction();

    ActionList positioning = new ActionList();
    positioning.add(autofit);
    m_vis.putAction("positioning", positioning);

    ActionList fna = new ActionList();
    fna.add(new WordFontAction(TREENODES, defaultTreeFont));
    //   fna.add(new EdgeWidthAction(TREEEDGES));
    // fna.add(new WordSizeAction(TREEEDGES));
    m_vis.putAction("fontnodeaction", fna);

    // create the filtering and layout
    ActionList filter = new ActionList();
    filter.add(fna);
    filter.add(fisheyetreefilter);
    // VisibilityFilter visibfilter = new VisibilityFilter(new WordCountPredicate());
    // filter.add(visibfilter);
    filter.add(treeLayout);
    filter.add(subLayout);
    filter.add(textColor);
    filter.add(nodeColor);
    filter.add(edgeColor);
    m_vis.putAction("filter", filter);

    // This doesn't quite work as expected; the layout is calculated
    // for the entire tree and low freq nodes are simply not shown,
    // leaving gaps in the layout
    //
    // setPredicate(new WordCountPredicate());

    // animated transition
    ActionList animate = new ActionList(1000);
    animate.setPacingFunction(new SlowInSlowOutPacer());
    // animate.add(autoPan);
    animate.add(new QualityControlAnimator());
    animate.add(new VisibilityAnimator(TREE));
    animate.add(new LocationAnimator(TREENODES));
    animate.add(new ColorAnimator(TREENODES));
    animate.add(new RepaintAction());
    m_vis.putAction("animate", animate);
    m_vis.alwaysRunAfter("filter", "animate");

    // create animator for orientation changes
    ActionList orient = new ActionList(2000);
    orient.setPacingFunction(new SlowInSlowOutPacer());
    // orient.add(autoPan);
    // orient.add(autocenter);
    orient.add(new QualityControlAnimator());
    orient.add(new LocationAnimator(TREENODES));
    orient.add(new RepaintAction());
    // orient.add(autofit);

    m_vis.putAction("orient", orient);

    // ------------------------------------------------

    // initialize the display
    setSize(WIDTH, HEIGHT);
    setItemSorter(new TreeDepthItemSorter());
    addControlListener(new ZoomToFitControl());
    addControlListener(new ZoomControl());
    addControlListener(new WheelZoomControl());
    addControlListener(new PanControl());
    addControlListener(new FocusControl(1, "filter"));
    addControlListener(new ToolTipControl(NODECOUNT));

    registerKeyboardAction(
        new OrientAction(Constants.ORIENT_LEFT_RIGHT),
        "left-to-right",
        KeyStroke.getKeyStroke("ctrl 1"),
        WHEN_IN_FOCUSED_WINDOW);
    registerKeyboardAction(
        new OrientAction(Constants.ORIENT_TOP_BOTTOM),
        "top-to-bottom",
        KeyStroke.getKeyStroke("ctrl 2"),
        WHEN_IN_FOCUSED_WINDOW);
    registerKeyboardAction(
        new OrientAction(Constants.ORIENT_RIGHT_LEFT),
        "right-to-left",
        KeyStroke.getKeyStroke("ctrl 3"),
        WHEN_IN_FOCUSED_WINDOW);
    registerKeyboardAction(
        new OrientAction(Constants.ORIENT_BOTTOM_TOP),
        "bottom-to-top",
        KeyStroke.getKeyStroke("ctrl 4"),
        WHEN_IN_FOCUSED_WINDOW);
    registerKeyboardAction(
        new FisheyeExpandAction(-1),
        "collapse-one",
        KeyStroke.getKeyStroke("ctrl 5"),
        WHEN_IN_FOCUSED_WINDOW);
    registerKeyboardAction(
        new FisheyeExpandAction(+1),
        "expand-one",
        KeyStroke.getKeyStroke("ctrl 6"),
        WHEN_IN_FOCUSED_WINDOW);

    // ------------------------------------------------

    // filter graph and perform layout
    setOrientation(m_orientation);
    m_vis.run("filter");

    /*
    TupleSet search = new PrefixSearchTupleSet();
      m_vis.addFocusGroup(Visualization.SEARCH_ITEMS, search);
      search.addTupleSetListener(new TupleSetListener() {
          public void tupleSetChanged(TupleSet t, Tuple[] add, Tuple[] rem) {
            m_vis.cancel("animatePaint");
            m_vis.run("fullPaint");
            m_vis.run("animatePaint");
          }
        });
       */

  }
Пример #22
0
  public MPtrack(Table t) {
    super(new BorderLayout());

    // --------------------------------------------------------------------
    // STEP 1: setup the visualized data

    final Visualization vis = new Visualization();
    m_vis = vis;

    final String group = "by_state";

    VisualTable vt = vis.addTable(group, t);

    vis.setRendererFactory(
        new RendererFactory() {
          AbstractShapeRenderer sr = new ShapeRenderer(30);
          Renderer arY = new AxisRenderer(Constants.RIGHT, Constants.TOP);
          Renderer arX = new AxisRenderer(Constants.CENTER, Constants.FAR_BOTTOM);

          public Renderer getRenderer(VisualItem item) {
            return item.isInGroup("ylab") ? arY : item.isInGroup("xlab") ? arX : sr;
          }
        });

    // --------------------------------------------------------------------

    // set up the actions
    AxisLayout xaxis = new AxisLayout(group, "States", Constants.X_AXIS, VisiblePredicate.TRUE);
    AxisLayout yaxis = new AxisLayout(group, PARTY, Constants.Y_AXIS, VisiblePredicate.TRUE);
    // yaxis.setScale(Constants.LOG_SCALE);

    xaxis.setLayoutBounds(m_dataB);
    yaxis.setLayoutBounds(m_dataB);

    AxisLabelLayout ylabels = new AxisLabelLayout("ylab", yaxis, m_ylabB, 5);

    AxisLabelLayout xlabels = new AxisLabelLayout("xlab", xaxis, m_xlabB, 5);
    vis.putAction("xlabels", xlabels);

    int[] palette = new int[] {ColorLib.rgb(150, 150, 255)};

    int[] palette2 = new int[200];

    for (int i = 0; i < 200; i++) {
      palette2[i] = ColorLib.rgba(255, 0, 0, 2 * i);
    }

    /*
    DataColorAction color = new DataColorAction(group, "Party",
            Constants.ORDINAL, VisualItem.STROKECOLOR, palette);
            */

    DataColorAction color2 =
        new DataColorAction(group, "Attendance", Constants.ORDINAL, VisualItem.FILLCOLOR, palette2);

    ActionList draw = new ActionList();
    draw.add(color2);
    draw.add(xaxis);
    draw.add(yaxis);
    draw.add(ylabels);
    draw.add(new RepaintAction());
    vis.putAction("draw", draw);

    ActionList update = new ActionList();
    update.add(xaxis);
    update.add(yaxis);
    update.add(ylabels);
    update.add(new RepaintAction());
    vis.putAction("update", update);

    UpdateListener lstnr =
        new UpdateListener() {
          public void update(Object src) {
            vis.run("update");
          }
        };

    // --------------------------------------------------------------------
    // STEP 4: set up a display and ui components to show the visualization

    m_display = new Display(vis);

    m_display.setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10));
    m_display.setSize(700, 450);
    m_display.setHighQuality(true);
    m_display.addComponentListener(
        new ComponentAdapter() {
          public void componentResized(ComponentEvent e) {
            displayLayout();
          }
        });
    displayLayout();

    m_details = new JFastLabel(m_title);
    m_details.setPreferredSize(new Dimension(75, 20));
    m_details.setVerticalAlignment(SwingConstants.BOTTOM);

    ToolTipControl ttc = new ToolTipControl("label");
    Control hoverc =
        new ControlAdapter() {
          public void itemEntered(VisualItem item, MouseEvent evt) {
            if (item.isInGroup(group)) {
              item.setFillColor(item.getStrokeColor());
              item.setStrokeColor(ColorLib.rgb(0, 0, 0));
              item.getVisualization().repaint();
            }
          }

          public void itemExited(VisualItem item, MouseEvent evt) {
            if (item.isInGroup(group)) {
              item.setFillColor(item.getEndFillColor());
              item.setStrokeColor(item.getEndStrokeColor());
              item.getVisualization().repaint();
            }
          }
        };
    m_display.addControlListener(ttc);
    m_display.addControlListener(hoverc);

    // --------------------------------------------------------------------
    // STEP 5: launching the visualization

    this.addComponentListener(lstnr);

    // details
    Box infoBox = new Box(BoxLayout.X_AXIS);
    infoBox.add(Box.createHorizontalStrut(5));
    infoBox.add(m_details);
    infoBox.add(Box.createHorizontalGlue());
    infoBox.add(Box.createHorizontalStrut(5));
    infoBox.add(Box.createHorizontalStrut(5));

    // create dynamic queries
    Box radioBox = new Box(BoxLayout.X_AXIS);
    radioBox.add(Box.createHorizontalStrut(5));
    radioBox.add(Box.createHorizontalGlue());
    radioBox.add(Box.createHorizontalStrut(5));
    radioBox.add(Box.createHorizontalStrut(16));

    vis.run("draw");
    vis.run("xlabels");

    add(infoBox, BorderLayout.NORTH);
    add(m_display, BorderLayout.CENTER);
    add(radioBox, BorderLayout.SOUTH);
    UILib.setColor(this, ColorLib.getColor(255, 255, 255), Color.GRAY);
    UILib.setFont(radioBox, FontLib.getFont("Tahoma", 15));
    m_details.setFont(FontLib.getFont("Tahoma", 18));
  }
Пример #23
0
  public static void main(String[] argv) {

    // -- 1. load the data ------------------------------------------------

    // load the socialnet.xml file. it is assumed that the file can be
    // found at the root of the java classpath
    Graph graph = null;
    try {
      graph = new GraphMLReader().readGraph(System.in);
    } catch (DataIOException e) {
      e.printStackTrace();
      System.err.println("Error loading graph. Exiting...");
      System.exit(1);
    }

    // -- 2. the visualization --------------------------------------------

    // add the graph to the visualization as the data group "graph"
    // nodes and edges are accessible as "graph.nodes" and "graph.edges"
    Visualization vis = new Visualization();
    vis.add("graph", graph);
    vis.setInteractive("graph.edges", null, false);

    // -- 3. the renderers and renderer factory ---------------------------

    // draw the "name" label for NodeItems
    LabelRenderer r = new LabelRenderer("label");
    r.setRoundedCorner(8, 8); // round the corners

    EdgeRenderer eRender =
        new EdgeRenderer(Constants.EDGE_TYPE_CURVE, Constants.EDGE_ARROW_FORWARD);

    // create a new default renderer factory
    // return our name label renderer as the default for all non-EdgeItems
    // includes straight line edges for EdgeItems by default
    vis.setRendererFactory(new DefaultRendererFactory(r, eRender));

    // -- 4. the processing actions ---------------------------------------

    // create our nominal color palette
    // pink for females, baby blue for males
    int[] palette =
        new int[] {
          ColorLib.rgb(190, 190, 255), ColorLib.rgb(255, 180, 180), ColorLib.rgb(128, 128, 128),
        };
    // map nominal data values to colors using our provided palette
    DataColorAction fill =
        new DataColorAction(
            "graph.nodes", "type", Constants.NOMINAL, VisualItem.FILLCOLOR, palette);

    // use black for node text
    ColorAction text = new ColorAction("graph.nodes", VisualItem.TEXTCOLOR, ColorLib.gray(0));
    // use light grey for edges
    ColorAction edges = new ColorAction("graph.edges", VisualItem.STROKECOLOR, ColorLib.gray(200));
    ColorAction arrows = new ColorAction("graph.edges", VisualItem.FILLCOLOR, ColorLib.gray(200));

    // create an action list containing all color assignments
    ActionList color = new ActionList();
    color.add(fill);
    color.add(text);
    color.add(edges);
    color.add(arrows);

    // Add a size action
    DataSizeAction size = new DataSizeAction("graph.nodes", "type", 2, Constants.LINEAR_SCALE);
    vis.putAction("size", size);

    // create an action list with an animated layout
    ActionList layout = new ActionList(Activity.INFINITY);
    layout.add(new ForceDirectedLayout("graph"));
    layout.add(new RepaintAction());

    // add the actions to the visualization
    vis.putAction("color", color);
    vis.putAction("layout", layout);

    // -- 5. the display and interactive controls -------------------------

    Display d = new Display(vis);
    d.setSize(720, 500); // set display size
    // drag individual items around
    d.addControlListener(new DragControl());
    // pan with left-click drag on background
    d.addControlListener(new PanControl());
    // zoom with right-click drag
    d.addControlListener(new ZoomControl());

    // -- 6. launch the visualization -------------------------------------

    // create a new window to hold the visualization
    JFrame frame = new JFrame("IFDS Visualization");
    // ensure application exits when window is closed
    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    frame.add(d);
    frame.pack(); // layout components in window
    frame.setVisible(true); // show the window

    // assign the colors
    vis.run("color");
    // start up the animated layout
    vis.run("layout");
  }
Пример #24
0
  /*
   * Constructor for the class
   * This is where all the important stuff happens
   */
  public TabularDataVis(Table t) {
    super(new BorderLayout());

    /*
     * Step 1: Setup the Visualization
     */

    // create a new visualization object, and assign it to the global variable
    final Visualization vis = new Visualization();
    g_vis = vis;

    // create a visual abstraction of the table data (loaded in the buildFrame method)
    // call our data "canUrban"
    VisualTable vt = vis.addTable("canUrban", t);

    // add a new column containing a label string showing
    // the Geographic name and population
    // note: uses the prefuse expression language
    vt.addColumn(
        "label", "CONCAT([Geographic name], ' (Population: ', FORMAT([2006 Population],0), ')')");

    // add a new column that divides the provinces by their geographic location (derived values)
    // note: uses the prefuse expression language
    vt.addColumn(
        "geographic location",
        "IF ([Province]='BC') THEN 1 ELSE "
            + "(IF ([Province] = 'AB' OR [Province] = 'SK' OR [Province] = 'MB') THEN 2 ELSE "
            + "(IF ([Province] = 'ON' OR [Province] = 'QC') THEN 3 ELSE"
            + "(IF ([Province] = 'NS' OR [Province] = 'NB' OR [Province] = 'PE' OR [Province] = 'NL') THEN 4 ELSE 5)))");

    // add a new column that converts the population data to ordinal data (derived values)
    // note: uses the prefuse expression language
    vt.addColumn(
        "population ordinal",
        "IF ([2006 Population] > 5000000) THEN 7 ELSE "
            + "(IF ([2006 Population] > 1000000) THEN 6 ELSE "
            + "(IF ([2006 Population] > 250000) THEN 5 ELSE "
            + "(IF ([2006 Population] > 100000) THEN 4 ELSE "
            + "(IF ([2006 Population] > 50000) THEN 3 ELSE "
            + "(IF ([2006 Population] > 20000) THEN 2 ELSE 1)))))");

    // create a new renderer factory for drawing the visual items
    vis.setRendererFactory(
        new RendererFactory() {

          // specify the default shape renderer (the actions will decide how to actually render the
          // visual elements)
          AbstractShapeRenderer sr = new ShapeRenderer();
          // renderers for the axes
          Renderer arY = new AxisRenderer(Constants.RIGHT, Constants.TOP);
          Renderer arX = new AxisRenderer(Constants.CENTER, Constants.FAR_BOTTOM);

          // return the appropriate renderer for a given visual item
          public Renderer getRenderer(VisualItem item) {
            return item.isInGroup("ylab") ? arY : item.isInGroup("xlab") ? arX : sr;
          }
        });

    /*
     * Step 2: Add X-Axis
     */

    // add the x-axis
    AxisLayout xaxis =
        new AxisLayout("canUrban", "Province", Constants.X_AXIS, VisiblePredicate.TRUE);

    // ensure the axis spans the width of the data container
    xaxis.setLayoutBounds(g_dataB);

    // add the labels to the x-axis
    AxisLabelLayout xlabels = new AxisLabelLayout("xlab", xaxis, g_xlabB, 15);

    /*
     * Step 3: Add the Y-Axis and its dynamic query feature
     */

    // dynamic query based on population data
    RangeQueryBinding populationQ = new RangeQueryBinding(vt, "2006 Population");
    AndPredicate filter = new AndPredicate(populationQ.getPredicate());

    // add the y-axis
    AxisLayout yaxis =
        new AxisLayout("canUrban", "2006 Population", Constants.Y_AXIS, VisiblePredicate.TRUE);

    // set the range controls on the y-axis
    yaxis.setRangeModel(populationQ.getModel());
    populationQ.getNumberModel().setValueRange(0, 6000000, 0, 6000000);

    // ensure the y-axis spans the height of the data container
    yaxis.setLayoutBounds(g_dataB);

    // add the labels to the y-axis
    AxisLabelLayout ylabels = new AxisLabelLayout("ylab", yaxis, g_ylabB);
    NumberFormat nf = NumberFormat.getIntegerInstance();
    nf.setMaximumFractionDigits(0);
    ylabels.setNumberFormat(nf);

    /*
     * Step 4: Add the search box
     */

    // dynamic query based on Geographic name data
    SearchQueryBinding searchQ = new SearchQueryBinding(vt, "Geographic name");
    filter.add(searchQ.getPredicate()); // reuse the same filter as the population query

    /*
     * Step 5: Colours and Shapes
     */

    // assign a set of five perceptually distinct colours to assign to the provinces
    // chosen from ColorBrewer (5-class qualitative Set1)
    int[] palette =
        new int[] {
          ColorLib.rgb(77, 175, 74),
          ColorLib.rgb(55, 126, 184),
          ColorLib.rgb(228, 26, 28),
          ColorLib.rgb(152, 78, 163),
          ColorLib.rgb(255, 127, 0)
        };

    // specify the stroke (exterior line) based on the ordinal data
    DataColorAction color =
        new DataColorAction(
            "canUrban", "geographic location", Constants.ORDINAL, VisualItem.STROKECOLOR, palette);

    // specify the fill (interior) as a static colour (white)
    ColorAction fill = new ColorAction("canUrban", VisualItem.FILLCOLOR, 0);

    // represent all the data points with rectangles
    ShapeAction shape = new ShapeAction("canUrban", Constants.SHAPE_RECTANGLE);

    // assign the size of the visual element based on the population data (we
    // converted the 2006 Population data to ordinal values)
    DataSizeAction size = new DataSizeAction("canUrban", "population ordinal");

    // setup a counter to keep track of which data points are currently being viewed
    Counter cntr = new Counter("canUrban");

    /*
     * Step 6: Create the action list for drawing the visual elements
     */

    ActionList draw = new ActionList();
    draw.add(cntr);
    draw.add(color);
    draw.add(fill);
    draw.add(shape);
    draw.add(size);
    draw.add(xaxis);
    draw.add(yaxis);
    draw.add(ylabels);
    draw.add(new RepaintAction());
    vis.putAction("draw", draw);
    vis.putAction("xlabels", xlabels);

    /*
     * create the action list for updating the visual elements
     * (during interactive operations and re-sizing of the window)
     */
    ActionList update = new ActionList();
    update.add(new VisibilityFilter("canUrban", filter)); // filter performs the size/name filtering
    update.add(cntr);
    update.add(xaxis);
    update.add(yaxis);
    update.add(ylabels);
    update.add(new RepaintAction());
    vis.putAction("update", update);

    // create an update listener that will update the visualization when fired
    UpdateListener lstnr =
        new UpdateListener() {

          public void update(Object src) {
            vis.run("update");
          }
        };

    // add this update listener to the filter, so that when the filter changes (i.e.,
    // the user adjusts the axis parameters, or enters a name for filtering), the
    // visualization is updated
    filter.addExpressionListener(lstnr);

    /*
     * Step 7: Setup the Display and the other Interface components
     * (scroll bar, query box, tool tips)
     */

    // create the display
    g_display = new Display(vis);

    // set the display properties
    g_display.setBorder(BorderFactory.createEmptyBorder(10, 20, 10, 20));
    g_display.setSize(700, 450);
    g_display.setHighQuality(true);

    // call the function that sets the sizes of the containers that contain
    // the data and the axes
    displayLayout();

    // whenever the window is re-sized, update the layout of the axes
    g_display.addComponentListener(
        new ComponentAdapter() {

          public void componentResized(ComponentEvent e) {
            displayLayout();
          }
        });

    // title label (top left)
    JFastLabel g_details = new JFastLabel("Canadian Urban Population");
    g_details.setPreferredSize(new Dimension(350, 20));
    g_details.setVerticalAlignment(SwingConstants.BOTTOM);

    // total label (top right)
    g_total.setPreferredSize(new Dimension(350, 20));
    g_total.setHorizontalAlignment(SwingConstants.RIGHT);
    g_total.setVerticalAlignment(SwingConstants.BOTTOM);

    // tool tips
    ToolTipControl ttc = new ToolTipControl("label");
    Control hoverc =
        new ControlAdapter() {

          public void itemEntered(VisualItem item, MouseEvent evt) {
            if (item.isInGroup("canUrban")) {
              g_total.setText(item.getString("label"));
              item.setFillColor(item.getStrokeColor());
              item.setStrokeColor(ColorLib.rgb(0, 0, 0));
              item.getVisualization().repaint();
            }
          }

          public void itemExited(VisualItem item, MouseEvent evt) {
            if (item.isInGroup("canUrban")) {
              g_total.setText(g_totalStr);
              item.setFillColor(item.getEndFillColor());
              item.setStrokeColor(item.getEndStrokeColor());
              item.getVisualization().repaint();
            }
          }
        };
    g_display.addControlListener(ttc);
    g_display.addControlListener(hoverc);

    // vertical slider for adjusting the population filter
    JRangeSlider slider = populationQ.createVerticalRangeSlider();
    slider.setThumbColor(null);
    slider.setToolTipText("drag the arrows to filter the data");
    // smallest window: 200,000
    slider.setMinExtent(200000);
    slider.addMouseListener(
        new MouseAdapter() {

          public void mousePressed(MouseEvent e) {
            g_display.setHighQuality(false);
          }

          public void mouseReleased(MouseEvent e) {
            g_display.setHighQuality(true);
            g_display.repaint();
          }
        });

    // search box
    JSearchPanel searcher = searchQ.createSearchPanel();
    searcher.setLabelText("Urban Centre: ");
    searcher.setBorder(BorderFactory.createEmptyBorder(5, 5, 5, 0));

    /*
     * Step 8: Create Containers for the Interface Elements
     */

    // add the listener to this component
    this.addComponentListener(lstnr);

    // container for elements at the top of the screen
    Box topContainer = new Box(BoxLayout.X_AXIS);
    topContainer.add(Box.createHorizontalStrut(5));
    topContainer.add(g_details);
    topContainer.add(Box.createHorizontalGlue());
    topContainer.add(Box.createHorizontalStrut(5));
    topContainer.add(g_total);
    topContainer.add(Box.createHorizontalStrut(5));

    // container for elements at the bottom of the screen
    Box bottomContainer = new Box(BoxLayout.X_AXIS);
    bottomContainer.add(Box.createHorizontalStrut(5));
    bottomContainer.add(searcher);
    bottomContainer.add(Box.createHorizontalGlue());
    bottomContainer.add(Box.createHorizontalStrut(5));
    bottomContainer.add(Box.createHorizontalStrut(16));

    // fonts, colours, etc.
    UILib.setColor(this, ColorLib.getColor(255, 255, 255), Color.GRAY);
    slider.setForeground(Color.LIGHT_GRAY);
    UILib.setFont(bottomContainer, FontLib.getFont("Tahoma", 15));
    g_details.setFont(FontLib.getFont("Tahoma", 18));
    g_total.setFont(FontLib.getFont("Tahoma", 16));

    // add the containers to the JPanel
    add(topContainer, BorderLayout.NORTH);
    add(g_display, BorderLayout.CENTER);
    add(slider, BorderLayout.EAST);
    add(bottomContainer, BorderLayout.SOUTH);

    /*
     * Step 9: Start the Visualization
     */

    vis.run("draw");
    vis.run("xlabels");
  }
Пример #25
0
/**
 * Color palette for the BMVis visualization.
 *
 * @author Kimmo Kulovesi
 */
public class ColorPalette {
  /** Predefined edge type stroke colors. */
  public static final HashMap<String, Integer> EDGE_COLORS = new HashMap<String, Integer>();
  /** Predefined node type colors. */
  public static final HashMap<String, Integer> NODE_COLORS = new HashMap<String, Integer>();

  /** Predefined queryset colors. */
  public static final HashMap<String, Integer> QUERYSET_COLORS = new HashMap<String, Integer>();

  static {
    // EDGE_COLORS.put("refers_to", ColorLib.rgb(0, 0, 0));

    QUERYSET_COLORS.put("start", ColorLib.rgb(0, 175, 0));
    QUERYSET_COLORS.put("source", ColorLib.rgb(0, 175, 0));
    QUERYSET_COLORS.put("end", ColorLib.rgb(220, 0, 0));
    QUERYSET_COLORS.put("target", ColorLib.rgb(220, 0, 0));
    QUERYSET_COLORS.put("start,end", ColorLib.rgb(220, 0, 220));
    QUERYSET_COLORS.put("source,target", ColorLib.rgb(220, 0, 220));
    QUERYSET_COLORS.put("rank", ColorLib.rgb(0, 175, 220));

    NODE_COLORS.put("Node", ColorLib.rgb(240, 240, 240));

    // Saturated greens
    NODE_COLORS.put("Sequence", ColorLib.rgb(211, 247, 163));
    NODE_COLORS.put("Gene", ColorLib.rgb(211, 247, 163));
    NODE_COLORS.put("Protein", ColorLib.rgb(199, 240, 178));
    NODE_COLORS.put("Enzyme", ColorLib.rgb(193, 234, 174));
    // NODE_COLORS.put("ProteinGroup", ColorLib.rgb(199, 240, 178));
    NODE_COLORS.put("AllelicVariant", ColorLib.rgb(199, 240, 178));

    // Beige
    NODE_COLORS.put("Article", ColorLib.rgb(250, 230, 160));

    // Cyans (to do, make greener)
    NODE_COLORS.put("HomologGroup", ColorLib.rgb(187, 237, 215));
    NODE_COLORS.put("OrthologGroup", ColorLib.rgb(194, 237, 218));

    // Desaturated blues
    NODE_COLORS.put("GO", ColorLib.rgb(185, 218, 234));
    NODE_COLORS.put("BiologicalProcess", ColorLib.rgb(185, 218, 234));
    NODE_COLORS.put("MolecularFunction", ColorLib.rgb(189, 223, 239));
    NODE_COLORS.put("CellularComponent", ColorLib.rgb(174, 214, 234));

    // Light purples
    NODE_COLORS.put("Ligand", ColorLib.rgb(210, 203, 240));
    NODE_COLORS.put("Substance", ColorLib.rgb(210, 203, 240));
    NODE_COLORS.put("Compound", ColorLib.rgb(210, 203, 240));
    NODE_COLORS.put("Drug", ColorLib.rgb(203, 196, 233));
    NODE_COLORS.put("Glycan", ColorLib.rgb(198, 200, 242));

    // Pink
    NODE_COLORS.put("GenomicContext", ColorLib.rgb(255, 215, 253));

    // Blues
    NODE_COLORS.put("Locus", ColorLib.rgb(180, 196, 239)); // unused
    NODE_COLORS.put("Phenotype", ColorLib.rgb(193, 209, 255));
    // NODE_COLORS.put("Locus/Phenotype, ColorLib.rgb(195, 199, 242));

    // TMP MAPPING for illustration purposes BY LERONEN! Should never get to SVN!
    NODE_COLORS.put("Gene/Phenotype", ColorLib.rgb(211, 247, 163));
    //        NODE_COLORS.put("Gene/Phenotype", ColorLib.rgb(193, 223, 242));

    // Greens
    NODE_COLORS.put("Family", ColorLib.rgb(179, 226, 192));
    NODE_COLORS.put("Region", ColorLib.rgb(195, 229, 204));
    NODE_COLORS.put("Domain", ColorLib.rgb(195, 229, 204));
    NODE_COLORS.put("Repeat", ColorLib.rgb(195, 229, 204));
    NODE_COLORS.put("Site", ColorLib.rgb(190, 229, 201));
    NODE_COLORS.put("ActiveSite", ColorLib.rgb(190, 229, 201));
    NODE_COLORS.put("BindingSite", ColorLib.rgb(190, 229, 201));
    NODE_COLORS.put("PostTranslationalModification", ColorLib.rgb(190, 229, 201));

    // Purple
    NODE_COLORS.put("Pathway", ColorLib.rgb(208, 185, 231));

    // Browns
    NODE_COLORS.put("Tissue", ColorLib.rgb(229, 218, 189));
    // NODE_COLORS.put("Organism", ColorLib.rgb(229, 215, 177));
    NODE_COLORS.put("MeSHHeading", ColorLib.rgb(239, 231, 176));
    NODE_COLORS.put("OMIM", ColorLib.rgb(239, 231, 176));
  }

  /** Node text color. */
  public static final int NODE_TEXT = ColorLib.gray(0);

  /** Groupnode border stroke color. */
  public static final int GROUPNODE_STROKE = ColorLib.gray(0);

  /** Edgenode fill color. */
  public static final int EDGENODE_FILL = 0;

  /**
   * Default node fill color. This is generally unused, due to the use of type-specific colors set
   * in NODE_COLORS.
   */
  public static final int DEFAULT_FILL = ColorLib.rgb(200, 215, 255);

  /** Selected node color. */
  public static final int NODE_SELECT = ColorLib.rgb(255, 100, 100);

  /** Node hover highlight color. */
  public static final int NODE_HOVER = ColorLib.rgb(255, 155, 140);

  /** Node hover neighbor highlight color. */
  public static final int NEIGHBOR_HOVER = ColorLib.rgb(255, 175, 0);

  /** Selected node hover highlight color. */
  public static final int SELECT_HOVER = ColorLib.rgb(255, 120, 120);

  /** Node hover neighbor highlight color for selected nodes. */
  public static final int SELECT_NEIGHBOR = ColorLib.rgb(255, 100, 35);

  /** Default edge stroke color. */
  public static final int DEFAULT_EDGE_STROKE = ColorLib.rgb(15, 15, 15);
}
Пример #26
0
    public void itemReleased(VisualItem item, MouseEvent evt) {

      item.setFillColor(ColorLib.rgb(255, 255, 255));
      item.setStrokeColor(item.getEndStrokeColor());
      item.getVisualization().repaint();
    }
Пример #27
0
  public Display getGraphDisplay(
      GraphLayoutType glType, final ExperimentPanel expPanel, String highlightName) {
    Display display = new Display();
    int X = expPanel.getDetailWidth();
    int Y = expPanel.getDetailHeight();
    display.setSize(X, Y); // set display size
    // display.setHighQuality(true);
    // display.setPreferredSize(new Dimension(600,600));
    display.addControlListener(new DragControl()); // drag items around
    display.addControlListener(new PanControl()); // pan with background left-drag
    display.addControlListener(new WheelZoomControl()); // zoom with vertical right-drag
    display.addControlListener(
        new ZoomToFitControl(Visualization.ALL_ITEMS, 50, 500, Control.MIDDLE_MOUSE_BUTTON));
    display.addControlListener(new NeighborHighlightControl());

    Visualization vis = new Visualization();
    if (clusterGraph == null) {
      clusterGraph = this.toGraph();
    }
    vis.add("graph", clusterGraph);
    LabelRenderer r = new LabelRenderer("name");
    r.setHorizontalAlignment(Constants.CENTER);
    // r.setRoundedCorner(8, 8); // round the corners

    DefaultRendererFactory rf = new DefaultRendererFactory(r);
    rf.setDefaultEdgeRenderer(new EdgeRenderer(Constants.EDGE_TYPE_CURVE));
    vis.setRendererFactory(rf);
    int[] palette = new int[] {ColorLib.rgb(255, 180, 180), ColorLib.rgb(190, 190, 255)};
    DataColorAction fill =
        new DataColorAction(
            "graph.nodes", "type", Constants.NOMINAL, VisualItem.FILLCOLOR, palette);
    fill.add(VisualItem.FIXED, ColorLib.rgb(255, 100, 100));
    fill.add(VisualItem.HIGHLIGHT, ColorLib.rgb(255, 200, 125));
    int[] text_palette = new int[] {ColorLib.gray(0), ColorLib.gray(255)};
    DataColorAction text =
        new DataColorAction(
            "graph.nodes",
            "indeterminate",
            Constants.NUMERICAL,
            VisualItem.TEXTCOLOR,
            text_palette);
    // ColorAction text = new ColorAction("graph.nodes", VisualItem.TEXTCOLOR, ColorLib.gray(0));
    ColorAction edges = new ColorAction("graph.edges", VisualItem.STROKECOLOR, ColorLib.gray(200));

    ActionList color = new ActionList(Activity.INFINITY);
    color.add(text);
    color.add(fill);
    color.add(edges);
    color.add(new RepaintAction());

    if (highlightName != null) {
      String pred = "name='" + highlightName + "'";
      Iterator iter = vis.items("graph.nodes", ExpressionParser.predicate(pred));
      while (iter.hasNext()) {
        NodeItem ni = (NodeItem) iter.next();
        highlightedItem = ni;
        ni.setFixed(true);
        Iterator iterEdge = ni.edges();
        while (iterEdge.hasNext()) {
          EdgeItem eItem = (EdgeItem) iterEdge.next();
          NodeItem nItem = eItem.getAdjacentItem(ni);
          if (eItem.isVisible()) {
            eItem.setHighlighted(true);
            nItem.setHighlighted(true);
          }
        }
      }
    }

    ActionList layout = new ActionList();
    switch (glType) {
      case BALLOON_TREE:
        layout.add(new BalloonTreeLayout("graph"));
        break;
      case FORCE_DIRECTED:
        layout = new ActionList(Activity.INFINITY);
        layout.add(new ForceDirectedLayout("graph"));
        break;
      case NODE_LINK_TREE:
        layout.add(new NodeLinkTreeLayout("graph"));
        break;
      case RADIAL_TREE:
        layout.add(new RadialTreeLayout("graph"));
        break;
    }
    // layout.add(fill);
    layout.add(new RepaintAction());

    vis.putAction("color", color);
    vis.putAction("layout", layout);
    display.setVisualization(vis);
    vis.run("color");
    vis.run("layout");
    // Rectangle2D bounds = vis.getBounds(Visualization.ALL_ITEMS);
    // GraphicsLib.expand(bounds, 50 + (int)(1/display.getScale()));
    // DisplayLib.fitViewToBounds(display,bounds,1);
    // vis.runAfter("layout",1000);

    Control shutoffHighlight =
        new HoverActionControl("color") {
          // public void itemEntered(VisualItem item, MouseEvent evt) {
          // }
          public void itemExited(VisualItem item, MouseEvent evt) {
            if (highlightedItem != null) {
              highlightedItem.setFixed(false);
              Iterator iterEdge = highlightedItem.edges();
              while (iterEdge.hasNext()) {
                EdgeItem eItem = (EdgeItem) iterEdge.next();
                NodeItem nItem = eItem.getAdjacentItem(highlightedItem);
                if (eItem.isVisible()) {
                  eItem.setHighlighted(false);
                  nItem.setHighlighted(false);
                }
              }
              highlightedItem = null;
            }
          }
        };
    display.addControlListener(shutoffHighlight);

    Control selectItem =
        new FocusControl() {

          public void itemClicked(VisualItem item, MouseEvent evt) {
            if (item.isInGroup("graph.nodes")) {
              if (item.getString("type").equals("peptide")) {
                Peptide pep = minPeptides.get(item.getString("name"));
                expPanel.showPeptide(pep, true);
              }
              if (item.getString("type").equals("protein")) {
                Protein pro = minProteins.get(item.getString("name"));
                expPanel.showProtein(pro, true);
              }
              String pred = "name='" + item.getString("name") + "'";
              Iterator iter =
                  item.getVisualization().items("graph.nodes", ExpressionParser.predicate(pred));
              while (iter.hasNext()) {
                NodeItem ni = (NodeItem) iter.next();
                highlightedItem = ni;
                ni.setFixed(true);
                Iterator iterEdge = ni.edges();
                while (iterEdge.hasNext()) {
                  EdgeItem eItem = (EdgeItem) iterEdge.next();
                  NodeItem nItem = eItem.getAdjacentItem(ni);
                  if (eItem.isVisible()) {
                    eItem.setHighlighted(true);
                    nItem.setHighlighted(true);
                  }
                }
              }
            }
          }
        };
    display.addControlListener(selectItem);

    final JPopupMenu menu = new JPopupMenu();

    // Create and add a menu item
    // JMenuItem printItem = new JMenuItem("Print This");
    // printItem.addActionListener(new java.awt.event.ActionListener() {

    //    public void actionPerformed(java.awt.event.ActionEvent evt) {
    //        PrintUtilities.printComponent(display);
    //    }
    // });
    // menu.add(printItem);

    // Set the component to show the popup menu
    display.addMouseListener(
        new MouseAdapter() {

          public void mousePressed(MouseEvent evt) {
            if (evt.isPopupTrigger()) {
              menu.show(evt.getComponent(), evt.getX(), evt.getY());
            }
          }

          public void mouseReleased(MouseEvent evt) {
            if (evt.isPopupTrigger()) {
              menu.show(evt.getComponent(), evt.getX(), evt.getY());
            }
          }
        });
    display.pan(X / 2.0, Y / 2.0);
    return display;
  }
Пример #28
0
 public BorderColorAction(String group) {
   super(group, VisualItem.STROKECOLOR, ColorLib.rgba(0, 0, 255, 255));
   add(isprocessfilter, ColorLib.rgba(176, 23, 31, 255));
 }
Пример #29
0
    @Override
    public void render(Graphics2D g, VisualItem item) {

      if (item.isVisible()) {
        item.setShape(Constants.SHAPE_RECTANGLE);
        RectangularShape shape = (RectangularShape) getShape(item);
        if (shape != null) {

          shape
              .getBounds2D()
              .setRect(
                  (double) item.get(VisualItem.X),
                  (double) item.get(VisualItem.Y),
                  item.getSize(),
                  item.getSize());

          // draw basic glyph
          Color strokeColor = ColorLib.getColor(item.getStrokeColor());
          Color fillColor = ColorLib.getColor(item.getFillColor());

          //                    int size = (int)item.getSize();
          int x = (int) item.getX() + bufferPx;
          int y = (int) item.getY() + bufferPx;
          int w = (int) item.getDouble(WIDTH) - 2 * bufferPx;
          int h = (int) item.getDouble(HEIGHT) - 2 * bufferPx;
          g.setPaint(fillColor);
          g.fillRect(x, y, w, h);

          // draw string on-top of glyph, filling the glyph's area

          //                    String s = "doc=" + item.getString(NODE_NAME) + "\n";
          String s = "";

          // set text: full document if no search term, else excerpts containing the search term
          String queryStr = searchQ.getSearchSet().getQuery();
          String focusText = item.getString(DocumentGridTable.NODE_FOCUS_TEXT);
          if (queryStr != null
              && !queryStr.isEmpty()
              && focusText != null
              && !focusText.equals("null")
              && !focusText.equals("")) {
            // if search query and terms present in document, use term-containing spans
            s += focusText;
          } else if (queryStr != null
              && !queryStr.isEmpty()
              && focusText.equals(FOCUS_SENT_SPLITTER)) {
            // if search query but no terms present in document, use blank
            s += "";
          } else if ((queryStr == null || queryStr.isEmpty()) && item.canGetInt(NODE_ID)) {
            // if no search query, build feature-oriented summary based on color attribute
            s = controller.getDocumentSummary(item.getInt(NODE_ID), colorAttrName);
          }

          // TODO : idea: set font size dynamically based on number of active nodes? based on size
          // of rect?
          int fontSize = 10;

          item.setFont(FontLib.getFont("Tahoma", Font.PLAIN, fontSize));

          Font f = item.getFont();

          // compute width, height for the given text
          // NOTE: this logic has been moved into drawStringMultiline
          //                    int[] textDims = getTextDims(g, f, s);

          // debug
          //                    System.out.println("debug: "+this.getClass().getName()+":
          // drawStringMultiline at x="+x1+", y="+y1+", w="+w+", h="+h);
          drawStringMultiline(g, f, s, x, y, w, h);
        }
      }
    }
Пример #30
0
  public AggregateDemo() {
    // initialize display and data
    super(new Visualization());
    initDataGroups();

    // set up the renderers
    // draw the nodes as basic shapes
    Renderer nodeR = new ShapeRenderer(20);
    // draw aggregates as polygons with curved edges
    Renderer polyR = new PolygonRenderer(Constants.POLY_TYPE_CURVE);
    ((PolygonRenderer) polyR).setCurveSlack(0.15f);

    // modification to try drawing edges to aggregates
    Renderer edgeR =
        new EdgeRenderer() {
          @Override
          protected Shape getRawShape(VisualItem item) {
            EdgeItem edge = (EdgeItem) item;
            VisualItem item1 = edge.getSourceItem();
            VisualItem item2 = edge.getTargetItem();
            item2 = (AggregateItem) at.getAggregates(item2).next();

            int type = m_edgeType;

            getAlignedPoint(m_tmpPoints[0], item1.getBounds(), m_xAlign1, m_yAlign1);
            getAlignedPoint(m_tmpPoints[1], item2.getBounds(), m_xAlign2, m_yAlign2);
            m_curWidth = (float) (m_width * getLineWidth(item));

            // create the arrow head, if needed
            EdgeItem e = (EdgeItem) item;
            if (e.isDirected() && m_edgeArrow != Constants.EDGE_ARROW_NONE) {
              // get starting and ending edge endpoints
              boolean forward = (m_edgeArrow == Constants.EDGE_ARROW_FORWARD);
              Point2D start = null, end = null;
              start = m_tmpPoints[forward ? 0 : 1];
              end = m_tmpPoints[forward ? 1 : 0];

              // compute the intersection with the target bounding box
              VisualItem dest = forward ? e.getTargetItem() : e.getSourceItem();
              int i =
                  GraphicsLib.intersectLineRectangle(start, end, dest.getBounds(), m_isctPoints);
              if (i > 0) end = m_isctPoints[0];

              // create the arrow head shape
              AffineTransform at = getArrowTrans(start, end, m_curWidth);
              m_curArrow = at.createTransformedShape(m_arrowHead);

              // update the endpoints for the edge shape
              // need to bias this by arrow head size
              Point2D lineEnd = m_tmpPoints[forward ? 1 : 0];
              lineEnd.setLocation(0, -m_arrowHeight);
              at.transform(lineEnd, lineEnd);
            } else {
              m_curArrow = null;
            }

            // create the edge shape
            Shape shape = null;
            double n1x = m_tmpPoints[0].getX();
            double n1y = m_tmpPoints[0].getY();
            double n2x = m_tmpPoints[1].getX();
            double n2y = m_tmpPoints[1].getY();
            switch (type) {
              case Constants.EDGE_TYPE_LINE:
                m_line.setLine(n1x, n1y, n2x, n2y);
                shape = m_line;
                break;
              case Constants.EDGE_TYPE_CURVE:
                getCurveControlPoints(edge, m_ctrlPoints, n1x, n1y, n2x, n2y);
                m_cubic.setCurve(
                    n1x,
                    n1y,
                    m_ctrlPoints[0].getX(),
                    m_ctrlPoints[0].getY(),
                    m_ctrlPoints[1].getX(),
                    m_ctrlPoints[1].getY(),
                    n2x,
                    n2y);
                shape = m_cubic;
                break;
              default:
                throw new IllegalStateException("Unknown edge type");
            }

            // return the edge shape
            return shape;
          }
        };

    DefaultRendererFactory drf = new DefaultRendererFactory(nodeR, edgeR);
    drf.add("ingroup('aggregates')", polyR);
    m_vis.setRendererFactory(drf);

    // set up the visual operators
    // first set up all the color actions
    ColorAction nStroke = new ColorAction(NODES, VisualItem.STROKECOLOR);
    nStroke.setDefaultColor(ColorLib.gray(100));
    nStroke.add("_hover", ColorLib.gray(50));

    ColorAction nFill = new ColorAction(NODES, VisualItem.FILLCOLOR);
    nFill.setDefaultColor(ColorLib.gray(255));
    nFill.add("_hover", ColorLib.gray(200));

    ColorAction nEdges = new ColorAction(EDGES, VisualItem.STROKECOLOR);
    nEdges.setDefaultColor(ColorLib.gray(100));

    ColorAction aStroke = new ColorAction(AGGR, VisualItem.STROKECOLOR);
    aStroke.setDefaultColor(ColorLib.gray(200));
    aStroke.add("_hover", ColorLib.rgb(255, 100, 100));

    int[] palette =
        new int[] {
          ColorLib.rgba(255, 200, 200, 255),
          ColorLib.rgba(200, 255, 200, 255),
          ColorLib.rgba(200, 200, 255, 255)
        };
    ColorAction aFill =
        new DataColorAction(AGGR, "id", Constants.NOMINAL, VisualItem.FILLCOLOR, palette);

    // bundle the color actions
    ActionList colors = new ActionList();
    colors.add(nStroke);
    colors.add(nFill);
    colors.add(nEdges);
    colors.add(aStroke);
    colors.add(aFill);

    // now create the main layout routine
    ActionList layout = new ActionList(Activity.INFINITY);
    layout.add(colors);
    layout.add(new ForceDirectedLayout(GRAPH, true));
    layout.add(new AggregateLayout(AGGR));
    layout.add(new RepaintAction());
    m_vis.putAction("layout", layout);

    // set up the display
    setSize(500, 500);
    pan(250, 250);
    setHighQuality(true);
    addControlListener(new AggregateDragControl());
    addControlListener(new ZoomControl());
    addControlListener(new PanControl());

    // set things running
    m_vis.run("layout");
  }