public BasicVisualizationServer<Node, MyLink> getDisplayGraph(){
			//Maps the vertex number to a vertex property.
		 	Transformer<Node,Paint> vertexColor = new Transformer<Node,Paint>() {
	            public Paint transform(Node n) {
	            	if(useScaledColoring){
	            		return n.getScaledColor();
	            	}
	            	else {
	            		return n.getColor();
	            	}
	            }
	        };
	        Transformer<Node,Shape> vertexSize = new Transformer<Node,Shape>(){
				public Shape transform(Node n){
					if(n.getSize() > minimumSize + MAX_ADDITONAL_NODE_SIZE){
						n.setSize(minimumSize + MAX_ADDITONAL_NODE_SIZE);
					}
					else if(n.getSize() < minimumSize){
						n.setSize(minimumSize);
					}
	                Ellipse2D circle = new Ellipse2D.Double(-n.getSize()/2.0, -n.getSize()/2.0, n.getSize(), n.getSize());
	                return circle;
	            }
	        };
	        Transformer<MyLink, Stroke> edgeStroke = new Transformer<MyLink, Stroke>() {
	            float dash[] = { 5.0f };
	            float dash2[] = { 10.0f };
	            public Stroke transform(MyLink n) {
	            	double type = n.getType();
	            	if(type == 1){
	            		return new BasicStroke();
	            		/* Dashed LineType for potentially related Terms
	            		return new BasicStroke(1.0f, BasicStroke.CAP_BUTT,
	                        BasicStroke.JOIN_MITER, 10.0f, dash, 0.0f);
	                        */
	            	}
	            	else if(type == 2){
	            		return new BasicStroke();
	            	}
	            	else if(type == 3){
	            		return new BasicStroke((float)(n.getWeight()*LINE_WIDTH_FOR_RELATIONSHIPS_BETWEEN_SEARCH_TERMS));
	            	}
	            	else {
	            		return null;
	            	}
	            }
	        };
	        Transformer<MyLink, Paint> edgePaint = new Transformer<MyLink, Paint>() {
	            public Paint transform(MyLink link) {
	            	if(link.getType() == 1){
		            	if(useAlphaApproach){
		            		float[] gray = Color.GRAY.getColorComponents(null);
		            		float alphaVal = 0.0f;
		            		if(link.getWeight() > 0.6667){
		            			alphaVal = 0.5f;
		            		}
		            		else if(link.getWeight() > 0.3333){
		            			alphaVal = 0.3f;
		            		}
		            		else{
		            			alphaVal = 0.1f;
		            		}
		            		return new Color(gray[0],gray[1],gray[2],alphaVal);
		            	}
		            	else {
		            		return new Color((float)(1.0*link.getWeight()),(float)(1.0*link.getWeight()),(float)(1.0*link.getWeight()));
		            	}
	            	}
	            	else {
	            		return Color.BLACK;
	            	}
	            }
	        };
	        /*
	        Transformer<Context<Graph<Node,MyLink>,MyLink>,Shape> edgeShape = new Transformer<Context<Graph<Node,MyLink>,MyLink>,Shape>() {
				@Override
				public Shape transform(Context<Graph<Node, MyLink>, MyLink> arg0) {
					return (Shape) (new EdgeShape.Orthogonal<>());
				}
	        	
	        };
	        */
	        
	        // The Layout<V, E> is parameterized by the vertex and edge types
			layout = new FRLayout<Node, MyLink>(g);
			layout.setSize(new Dimension(graphWidth, graphHeight)); // sets the initial size of the layout space
	        layout.setRepulsionMultiplier(1.0);
	        layout.setAttractionMultiplier(0.25);
	        //Set the visualization server.
			vv = new VisualizationViewer<Node, MyLink>(layout);
			vv.setPreferredSize(new Dimension(graphWidth, graphHeight)); // Sets the viewing area size
			vv.setBackground(Color.WHITE); //Set the background color to white.
	        //Set these attributes to the graph.
	        vv.getRenderContext().setVertexFillPaintTransformer(vertexColor);
	        vv.getRenderContext().setVertexShapeTransformer(vertexSize);
	        vv.getRenderContext().setEdgeStrokeTransformer(edgeStroke);
	        vv.getRenderContext().setEdgeDrawPaintTransformer(edgePaint);
	        //vv.getRenderContext().setEdgeShapeTransformer(edgeShape);
	        
	        //Mouse Events
	        /*
	        final PickedState<Node> pickedState = vv.getPickedVertexState();
	        pickedState.addItemListener(new ItemListener() {
				@Override
				public void itemStateChanged(ItemEvent e) {
					Object selection = e.getItem();
					if(selection instanceof Node){
						Node choice = (Node) selection;
						if(pickedState.isPicked(choice)){
							if(!menu.getInfoPane().getText().equals("")){
								menu.getInfoPane().removeAll();
							}
							menu.getInfoPane().setText(choice.toString());
							menu.getInfoPane().revalidate();
							menu.getInfoPane().repaint();
						}
					}
				}
	        	
	        });
	        */
	        
	        // Set the mouse to "picking" mode so that vertices can be selected.
	        DefaultModalGraphMouse<Integer, String> modalMouse = new DefaultModalGraphMouse<Integer, String>();
	        TranslatingGraphMousePlugin translatingMouse = new TranslatingGraphMousePlugin();
	        modalMouse.add(translatingMouse);
	        modalMouse.setMode(Mode.PICKING);
	        vv.setVertexToolTipTransformer(new ToStringLabeller<Node>());
			vv.setGraphMouse(modalMouse);
	        return vv;
	}