Java:JGraphT 使用循环添加边

Question

是否可以通过使用循环向图形添加边？我正在解析一个字符串以确定适当的边和标签。由于某种原因，它只会为用于遍历 String 的 while 循环的第一轮添加边缘。对于所有其他人，会出现以下消息...

警告:边被删除，因为底层 JGraphT 图拒绝创建它。当违反底层图的约束时，可能会发生这种情况，例如，试图向禁止它们的图添加平行边或自循环。为避免出现此消息，请确保使用合适的底层 JGraphT 图。

import java.awt.*;
import java.awt.geom.*;

import javax.swing.*;

import org.jgraph.*;
import org.jgraph.graph.*;

import org.jgrapht.*;
import org.jgrapht.ext.*;
import org.jgrapht.graph.*;

// resolve ambiguity
import org.jgrapht.graph.DefaultEdge;

public class JGraphAdapterDemo
    extends JApplet
{

    private static final long serialVersionUID = 3256444702936019250L;
    private static final Color DEFAULT_BG_COLOR = Color.decode("#FAFBFF");
    private static final Dimension DEFAULT_SIZE = new Dimension(530, 320);

    static ListenableGraph<String, String> g =
        new ListenableDirectedMultigraph<String, String>(String.class);

    static int [] finalStates = new int[10];
    static int startState = 0;
    static char tran = ' ';
    static int endState = 0;

    private JGraphModelAdapter<String,String> jgAdapter;

    public static void main(String [] args)
    {
        JGraphAdapterDemo applet = new JGraphAdapterDemo();
        applet.init();

        JFrame frame = new JFrame();
        frame.getContentPane().add(applet);
        frame.setTitle("JGraphT Adapter to JGraph Demo");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.pack();
        frame.setVisible(true);
    }

    public void init()
    {
        // create a JGraphT graph
        ListenableGraph<String, String> g =
            new ListenableDirectedMultigraph<String, String>(String.class);

        // create a visualization using JGraph, via an adapter
        jgAdapter = new JGraphModelAdapter<String, String>(g);

        JGraph jgraph = new JGraph(jgAdapter);

        adjustDisplaySettings(jgraph);
        getContentPane().add(jgraph);
        resize(DEFAULT_SIZE);

        int numStates = 4;
        int numSymbols;
        int currentState;
        int i = 0;

            String input = "4 2 0 2 -1 0 a 1 1 b 3 2 c 2 3 c 3 -1";     //place input String here
            int readInt = 0;
            int j = 0;
            String str = "";
            int place = 0;
            String fState;

            //read in numStates, numSymbols, initialState
            i=0;

            //parse string 
            i = input.indexOf(" ",0);

            str = input.substring(0,i); //number of states
            numStates = Integer.parseInt(str);  //convert to int

            for(int k = 0; k< numStates; k++){
                g.addVertex("q"+k);
            }

            i++;
            j = i;

            i=input.indexOf(" ",j);

            str = input.substring(j,i); //number of symbols
            numSymbols = Integer.parseInt(str);

            i++;
            j = i;

            i=input.indexOf(" ",j);

            str = input.substring(j,i); //initial state
            currentState = Integer.parseInt(str);   

            i++;
            j = i;      

            //read in finalStates
            while(readInt!=-1){
                i=input.indexOf(" ",j);
                fState = input.substring(j,i);  //a final state
                readInt = Integer.parseInt(fState);
                if(readInt!=-1){
                    finalStates[place] = readInt;
                    i++;
                    j = i;
                    place++;
                }//end if
            }//end while
            i++;
            j = i;

            String sState;
            String eState;

            while(startState!=-1&& j<(input.length()-2)){           //until end of file
                i=input.indexOf(" ",j);
                sState = input.substring(j,i);  //start state
                startState = Integer.parseInt(sState);  //convert to int
                if(startState!=-1){             
                    i++;
                    j = i;

                    String cStr = "";
                    tran = input.charAt(i);         //transition
                    cStr = cStr + tran;
                    i = i+2;
                    j=i;        

                    i=input.indexOf(" ",j); 
                    eState = input.substring(j,i);      //end state
                    endState = Integer.parseInt(eState);

                    i++;
                    j=i;
                    String one = "q"+startState;
                    String two = "q"+endState;
                    System.out.println(one+ two +" "+cStr);
                    g.addEdge(one, two, cStr);

                    //drawEdge(one, two, cStr);

                }//end if

            }//end while

    }

    public static void drawEdge(String v, String v1, String label){
        System.out.println(v +" "+v1+ " "+label);
        g.addEdge(v,v1,label);
    }

    private void adjustDisplaySettings(JGraph jg)
    {
        jg.setPreferredSize(DEFAULT_SIZE);

        Color c = DEFAULT_BG_COLOR;
        String colorStr = null;

        try {
            colorStr = getParameter("bgcolor");
        } catch (Exception e) {
        }

        if (colorStr != null) {
            c = Color.decode(colorStr);
        }

        jg.setBackground(c);
    }

    @SuppressWarnings("unchecked") // FIXME hb 28-nov-05: See FIXME below
    private void positionVertexAt(Object vertex, int x, int y)
    {
        DefaultGraphCell cell = jgAdapter.getVertexCell(vertex);
        AttributeMap attr = cell.getAttributes();
        Rectangle2D bounds = GraphConstants.getBounds(attr);

        Rectangle2D newBounds =
            new Rectangle2D.Double(
                x,
                y,
                bounds.getWidth(),
                bounds.getHeight());

        GraphConstants.setBounds(attr, newBounds);

        // TODO: Clean up generics once JGraph goes generic
        AttributeMap cellAttr = new AttributeMap();
        cellAttr.put(cell, attr);
        jgAdapter.edit(cellAttr, null, null, null);
    }

    //~ Inner Classes ----------------------------------------------------------

    /**
     * a listenable directed multigraph that allows loops and parallel edges.
    // */
    private static class ListenableDirectedMultigraph<V, E>
    extends DefaultListenableGraph<V, E>
    implements DirectedGraph<V, E>
    {
    private static final long serialVersionUID = 1L;

    ListenableDirectedMultigraph(Class<E> edgeClass)
        {
        super(new DirectedMultigraph<V, E>(edgeClass));
        }
    }


}

Answer 1

如果你想使用一个允许循环的图，你必须创建一个抽象类“AbstractBaseGraph”。为此，您必须创建另一个类来扩展您的父类(super class)。这是一个例子。

public class MiGrafo
extends AbstractBaseGraph<String, DefaultEdge>
implements DirectedGraph<String, DefaultEdge> {

public MiGrafo() {// EdgeFactory<String, DefaultEdge> arg0, boolean arg1,boolean arg2
    super(new ClassBasedEdgeFactory<String, DefaultEdge>(
            DefaultEdge.class),
        true,
        true);
    // TODO Auto-generated constructor stub
}

此外，您必须在扩展后实现有向图或无向图。

当您创建允许使用循环的新图时，您只需写下这句话:

MiGrafo h = new MiGrafo();

最后你只需要像简单的图一样使用图。

再见。