Java MutableTransformer类代码示例

import edu.uci.ics.jung.visualization.transform.MutableTransformer; //导入依赖的package包/类
public void centerVisualization(V vertex, final boolean immediate) {
    if (vertex != null) {
        Layout<V,E> layout = this.getGraphLayout();
        Point2D q = layout.transform(vertex);
        Point2D lvc = this.getRenderContext().getMultiLayerTransformer().inverseTransform(this.getCenter());
        final int steps = (immediate ? 1 : 10);
        final double dx = (lvc.getX() - q.getX()) / steps;
        final double dy = (lvc.getY() - q.getY()) / steps;

        new Thread() {
            public void run() {
                MutableTransformer transformer = GraphVisualizationPanel.this.getRenderContext().getMultiLayerTransformer().getTransformer(Layer.LAYOUT); 
                for (int i = 0; i < steps; i++) {
                    transformer.translate(dx, dy);
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException ex) {
                    }
                }
            }
        }.start();
    }
}
 

import edu.uci.ics.jung.visualization.transform.MutableTransformer; //导入依赖的package包/类
protected boolean vertexHit(RenderContext<V, E> rc, Shape s) {
	JComponent vv = rc.getScreenDevice();
	Rectangle deviceRectangle = null;
	if (vv != null) {
		Dimension d = vv.getSize();
		deviceRectangle = new Rectangle(0, 0, d.width, d.height);
	}
	if (deviceRectangle != null) {
		MutableTransformer vt = rc.getMultiLayerTransformer().getTransformer(Layer.VIEW);
		if (vt instanceof MutableTransformerDecorator) {
			vt = ((MutableTransformerDecorator) vt).getDelegate();
		}
		return vt.transform(s).intersects(deviceRectangle);
	} else {
		return false;
	}
}
 

import edu.uci.ics.jung.visualization.transform.MutableTransformer; //导入依赖的package包/类
public void paint(Graphics g) {
	g.setColor(Color.gray);

	Graphics2D g2d = (Graphics2D)g;

	Ellipse2D ellipse = new Ellipse2D.Double();
	for(String v : layout.getGraph().getVertices()) {
		Double radius = layout.getRadii().get(v);
		if(radius == null) continue;
		Point2D p = layout.transform(v);
		ellipse.setFrame(-radius, -radius, 2*radius, 2*radius);
		AffineTransform at = AffineTransform.getTranslateInstance(p.getX(), p.getY());
		Shape shape = at.createTransformedShape(ellipse);
		
		MutableTransformer viewTransformer =
			vv.getRenderContext().getMultiLayerTransformer().getTransformer(Layer.VIEW);
		
		if(viewTransformer instanceof MutableTransformerDecorator) {
			shape = vv.getRenderContext().getMultiLayerTransformer().transform(shape);
		} else {
			shape = vv.getRenderContext().getMultiLayerTransformer().transform(Layer.LAYOUT,shape);
		}

		g2d.draw(shape);
	}
}
 

import edu.uci.ics.jung.visualization.transform.MutableTransformer; //导入依赖的package包/类
@Override
public void mouseClicked(MouseEvent e) {
	if (e.getButton() == MouseEvent.BUTTON1 && (plusFocused || minusFocused)) {
		Point2D center = viewer.getRenderContext().getMultiLayerTransformer().inverseTransform(Layer.VIEW,
				viewer.getCenter());
		MutableTransformer transformer = viewer.getRenderContext().getMultiLayerTransformer()
				.getTransformer(Layer.LAYOUT);

		if (plusFocused) {
			transformer.scale(zoomFactor, zoomFactor, center);
			viewer.repaint();
		} else if (minusFocused) {
			transformer.scale(1 / zoomFactor, 1 / zoomFactor, center);
			viewer.repaint();
		}

		Stream.of(listeners.getListeners(JungListener.class)).forEach(l -> l.transformFinished());
	}
}
 

import edu.uci.ics.jung.visualization.transform.MutableTransformer; //导入依赖的package包/类
@Override
public void mouseDragged(MouseEvent e) {
	VisualizationViewer<?, ?> vv = (VisualizationViewer<?, ?>) e.getSource();

	if (down != null) {
		MutableTransformer modelTransformer = vv.getRenderContext().getMultiLayerTransformer()
				.getTransformer(Layer.LAYOUT);
		Point2D p1 = vv.getRenderContext().getMultiLayerTransformer().inverseTransform(down);
		Point2D p2 = vv.getRenderContext().getMultiLayerTransformer().inverseTransform(e.getPoint());

		modelTransformer.translate(p2.getX() - p1.getX(), p2.getY() - p1.getY());
		down = e.getPoint();
		vv.repaint();

		changed = true;
	}
}
 

import edu.uci.ics.jung.visualization.transform.MutableTransformer; //导入依赖的package包/类
/**
   * check the modifiers. If accepted, use the mouse drag motion
   * to rotate the graph
*/
  public void mouseDragged(MouseEvent e) {
      if(down == null) return;
      VisualizationViewer vv = (VisualizationViewer)e.getSource();
      boolean accepted = checkModifiers(e);
      if(accepted) {
          MutableTransformer modelTransformer =
              vv.getRenderContext().getMultiLayerTransformer().getTransformer(Layer.LAYOUT);
          // rotate
          vv.setCursor(cursor);
          
          Point2D center = vv.getCenter();
          Point2D q = down;
          Point2D p = e.getPoint();
          Point2D v1 = new Point2D.Double(center.getX()-p.getX(), center.getY()-p.getY());
          Point2D v2 = new Point2D.Double(center.getX()-q.getX(), center.getY()-q.getY());
          double theta = angleBetween(v1, v2);
          modelTransformer.rotate(theta, vv.getRenderContext().getMultiLayerTransformer().inverseTransform(Layer.VIEW, center));
          down.x = e.getX();
          down.y = e.getY();
      
          e.consume();
      }
  }
 

import edu.uci.ics.jung.visualization.transform.MutableTransformer; //导入依赖的package包/类
/**
   * chack the modifiers. If accepted, translate the graph according
   * to the dragging of the mouse pointer
   * @param e the event
*/
  public void mouseDragged(MouseEvent e) {
      VisualizationViewer<?,?> vv = (VisualizationViewer<?,?>)e.getSource();
      boolean accepted = checkModifiers(e);
      if(accepted) {
          MutableTransformer viewTransformer = vv.getRenderContext().getMultiLayerTransformer().getTransformer(Layer.VIEW);
          vv.setCursor(cursor);
          try {
              Point2D q = viewTransformer.inverseTransform(down);
              Point2D p = viewTransformer.inverseTransform(e.getPoint());
              float dx = (float) (p.getX()-q.getX());
              float dy = (float) (p.getY()-q.getY());
              
              viewTransformer.translate(dx, dy);
              down.x = e.getX();
              down.y = e.getY();
          } catch(RuntimeException ex) {
              System.err.println("down = "+down+", e = "+e);
              throw ex;
          }
      
          e.consume();
      }
  }
 

import edu.uci.ics.jung.visualization.transform.MutableTransformer; //导入依赖的package包/类
/**
* zoom the display in or out, depending on the direction of the
* mouse wheel motion.
*/
  public void mouseWheelMoved(MouseWheelEvent e) {
      boolean accepted = checkModifiers(e);
      float delta = this.delta;
      if(accepted == true) {
          VisualizationViewer vv = (VisualizationViewer)e.getSource();
          MutableTransformer modelTransformer = vv.getRenderContext().getMultiLayerTransformer().getTransformer(Layer.LAYOUT);
          MutableTransformer viewTransformer = vv.getRenderContext().getMultiLayerTransformer().getTransformer(Layer.VIEW);
          int amount = e.getWheelRotation();
          if(amount < 0) {
              delta = -delta;
          }
          changeMagnification(modelTransformer, delta);
          changeMagnification(viewTransformer, delta);
          vv.repaint();
          e.consume();
      }
  }
 

import edu.uci.ics.jung.visualization.transform.MutableTransformer; //导入依赖的package包/类
/**
 * scale to the absolute value passed as 'amount'.
 * 
 */
public void scale(VisualizationViewer<?,?> vv, float amount, Point2D at) {
    MutableTransformer layoutTransformer = vv.getRenderContext().getMultiLayerTransformer().getTransformer(Layer.LAYOUT);
    MutableTransformer viewTransformer = vv.getRenderContext().getMultiLayerTransformer().getTransformer(Layer.VIEW);
    double modelScale = layoutTransformer.getScale();
    double viewScale = viewTransformer.getScale();
    double inverseModelScale = Math.sqrt(crossover)/modelScale;
    double inverseViewScale = Math.sqrt(crossover)/viewScale;
    
    Point2D transformedAt = vv.getRenderContext().getMultiLayerTransformer().inverseTransform(Layer.VIEW, at);
    
    // return the transformers to 1.0
    layoutTransformer.scale(inverseModelScale, inverseModelScale, transformedAt);
    viewTransformer.scale(inverseViewScale, inverseViewScale, at);

    super.scale(vv, amount, at);
}
 

import edu.uci.ics.jung.visualization.transform.MutableTransformer; //导入依赖的package包/类
/**
 * Check the event modifiers. Set the 'down' point for later
 * use. If this event satisfies the modifiers, change the cursor
 * to the system 'move cursor'
 * @param e the event
 */
public void mousePressed(MouseEvent e) {
    VisualizationViewer vv = (VisualizationViewer)e.getSource();
    MutableTransformer vt = vv.getRenderContext().getMultiLayerTransformer().getTransformer(Layer.VIEW);
    if(vt instanceof LensTransformer) {
    	vt = ((LensTransformer)vt).getDelegate();
    }
    Point2D p = vt.inverseTransform(e.getPoint());
    boolean accepted = checkModifiers(e);
    if(accepted) {
        vv.setCursor(Cursor.getPredefinedCursor(Cursor.MOVE_CURSOR));
        testViewCenter(vv.getRenderContext().getMultiLayerTransformer().getTransformer(Layer.LAYOUT), p);
        testViewCenter(vv.getRenderContext().getMultiLayerTransformer().getTransformer(Layer.VIEW), p);
        vv.repaint();
    }
    super.mousePressed(e);
}
 

import edu.uci.ics.jung.visualization.transform.MutableTransformer; //导入依赖的package包/类
/**
 * called to set up translating the lens center or changing the size
 * @param transformer
 * @param point
 */
private void testViewCenter(MutableTransformer transformer, Point2D point) {
    if(transformer instanceof LensTransformer) {
        LensTransformer ht =
            (LensTransformer)transformer;
        double distanceFromCenter = ht.getDistanceFromCenter(point);
        if(distanceFromCenter < 10) {
            ht.setViewCenter(point);
            dragOnLens = true;
        } else if(Math.abs(distanceFromCenter - ht.getViewRadius()) < 10) {
            edgeOffset = ht.getViewRadius() - distanceFromCenter;
            ht.setViewRadius(distanceFromCenter+edgeOffset);
            dragOnEdge = true;
        }
    }
}
 

import edu.uci.ics.jung.visualization.transform.MutableTransformer; //导入依赖的package包/类
/**
   * chack the modifiers. If accepted, translate the graph according
   * to the dragging of the mouse pointer
   * @param e the event
*/
  public void mouseDragged(MouseEvent e) {
      VisualizationViewer vv = (VisualizationViewer)e.getSource();
      boolean accepted = checkModifiers(e);
      if(accepted) {
          MutableTransformer modelTransformer = vv.getRenderContext().getMultiLayerTransformer().getTransformer(Layer.LAYOUT);
          vv.setCursor(cursor);
          try {
              Point2D q = vv.getRenderContext().getMultiLayerTransformer().inverseTransform(down);
              Point2D p = vv.getRenderContext().getMultiLayerTransformer().inverseTransform(e.getPoint());
              float dx = (float) (p.getX()-q.getX());
              float dy = (float) (p.getY()-q.getY());
              
              modelTransformer.translate(dx, dy);
              down.x = e.getX();
              down.y = e.getY();
          } catch(RuntimeException ex) {
              System.err.println("down = "+down+", e = "+e);
              throw ex;
          }
      
          e.consume();
          vv.repaint();
      }
  }
 

import edu.uci.ics.jung.visualization.transform.MutableTransformer; //导入依赖的package包/类
protected boolean vertexHit(RenderContext<V,E> rc, Shape s) {
    JComponent vv = rc.getScreenDevice();
    Rectangle deviceRectangle = null;
    if(vv != null) {
        Dimension d = vv.getSize();
        deviceRectangle = new Rectangle(
                0,0,
                d.width,d.height);
    }
    if (deviceRectangle != null) {
    	MutableTransformer vt = rc.getMultiLayerTransformer().getTransformer(Layer.VIEW);
    	if(vt instanceof MutableTransformerDecorator) {
    		vt = ((MutableTransformerDecorator)vt).getDelegate();
    	}
    	return vt.transform(s).intersects(deviceRectangle);
    } else {
    	return false;
    }
}
 

import edu.uci.ics.jung.visualization.transform.MutableTransformer; //导入依赖的package包/类
/**
   * check the modifiers. If accepted, use the mouse drag motion
   * to rotate the graph
*/
  public void mouseDragged(MouseEvent e) {
      if(down == null) return;
      VisualizationViewer vv = (VisualizationViewer)e.getSource();
      boolean accepted = checkModifiers(e);
      if(accepted) {
          MutableTransformer modelTransformer =
              vv.getLayoutTransformer();
          // rotate
          vv.setCursor(cursor);
          
          Point2D center = vv.getCenter();
          Point2D q = down;
          Point2D p = e.getPoint();
          Point2D v1 = new Point2D.Double(center.getX()-p.getX(), center.getY()-p.getY());
          Point2D v2 = new Point2D.Double(center.getX()-q.getX(), center.getY()-q.getY());
          double theta = angleBetween(v1, v2);
          modelTransformer.rotate(theta, vv.inverseViewTransform(center));
          down.x = e.getX();
          down.y = e.getY();
      
          e.consume();
      }
  }
 

import edu.uci.ics.jung.visualization.transform.MutableTransformer; //导入依赖的package包/类
/**
   * chack the modifiers. If accepted, translate the graph according
   * to the dragging of the mouse pointer
   * @param e the event
*/
  public void mouseDragged(MouseEvent e) {
      VisualizationViewer vv = (VisualizationViewer)e.getSource();
      boolean accepted = checkModifiers(e);
      if(accepted) {
          MutableTransformer viewTransformer = vv.getViewTransformer();
          vv.setCursor(cursor);
          try {
              Point2D q = viewTransformer.inverseTransform(down);
              Point2D p = viewTransformer.inverseTransform(e.getPoint());
              float dx = (float) (p.getX()-q.getX());
              float dy = (float) (p.getY()-q.getY());
              
              viewTransformer.translate(dx, dy);
              down.x = e.getX();
              down.y = e.getY();
          } catch(RuntimeException ex) {
              System.err.println("down = "+down+", e = "+e);
              throw ex;
          }
      
          e.consume();
      }
  }