Java AttributeModel类代码示例

import org.gephi.data.attributes.api.AttributeModel; //导入依赖的package包/类
public GephiProcessing calculateClusteringCoefficient() {
    Stopwatch stopwatch = Stopwatch.createStarted();
    AttributeModel am = Lookup.getDefault().lookup(AttributeController.class).getModel();
    ClusteringCoefficient clusteringCoefficient = new ClusteringCoefficient();
    DynamicModel dynamicModel = Lookup.getDefault().lookup(DynamicController.class).getModel();
    Log.info(LogCategory.GEXF, "Calculating average clustering coefficient...");
    for (double i = 0.0; i < reportingIntervalCount; i++) {
        double high = i + 0.9;
        DynamicGraph dynamicGraph = dynamicModel.createDynamicGraph(graphModel.getGraph());
        Graph subGraph = dynamicGraph.getSnapshotGraph(i, high);
        clusteringCoefficient.execute(graphModel, am);

        double sum = 0.0;
        for (Node node : subGraph.getNodes()) {
            sum += (double) node.getAttributes().getValue(ClusteringCoefficient.CLUSTERING_COEFF);
        }
        Double avg = sum / subGraph.getNodeCount();
        clusteringCoefficientAverages.add(avg);
    }
    long timeElapsed = stopwatch.elapsed(TimeUnit.SECONDS);
    Log.info(LogCategory.GEXF, "...Finished! (elapsed time: " + timeElapsed + "s");
    return this;
}
 

import org.gephi.data.attributes.api.AttributeModel; //导入依赖的package包/类
public GephiProcessing calculateUndirectedDegree() {
    Stopwatch stopwatch = Stopwatch.createStarted();
    AttributeModel am = Lookup.getDefault().lookup(AttributeController.class).getModel();
    Degree degree = new Degree();
    DynamicModel dynamicModel = Lookup.getDefault().lookup(DynamicController.class).getModel();
    Log.info(LogCategory.GEXF, "Calculating averages for degree...");
    for (double i = 0.0; i < reportingIntervalCount; i++) {
        double high = i + 0.9;
        DynamicGraph dynamicGraph = dynamicModel.createDynamicGraph(graphModel.getGraph());
        Graph subGraph = dynamicGraph.getSnapshotGraph(i, high);
        degree.execute(graphModel, am);

        int degreeSum = 0;
        for (Node node : subGraph.getNodes()) {
            degreeSum += (int) node.getAttributes().getValue(Degree.DEGREE);
        }
        Double avgDegree = (double) degreeSum / subGraph.getNodeCount();
        degreeAverages.add(avgDegree);
    }
    long timeElapsed = stopwatch.elapsed(TimeUnit.SECONDS);
    Log.info(LogCategory.GEXF, ".. Finised (elapsed time: " + timeElapsed + "s");
    return this;
}
 

import org.gephi.data.attributes.api.AttributeModel; //导入依赖的package包/类
public GephiProcessing calculateInDegree() {
    Stopwatch stopwatch = Stopwatch.createStarted();
    AttributeModel am = Lookup.getDefault().lookup(AttributeController.class).getModel();
    Degree degree = new Degree();
    DynamicModel dynamicModel = Lookup.getDefault().lookup(DynamicController.class).getModel();
    Log.info(LogCategory.GEXF, "Calculating averages for In-Degree...");
    for (double i = 0.0; i < reportingIntervalCount; i++) {
        double high = i + 0.9;
        DynamicGraph dynamicGraph = dynamicModel.createDynamicGraph(graphModel.getGraph());
        Graph subGraph = dynamicGraph.getSnapshotGraph(i, high);
        degree.execute(graphModel, am);

        int inDegreeSum = 0;
        for (Node node : subGraph.getNodes()) {
            inDegreeSum += (int) node.getAttributes().getValue(Degree.INDEGREE);
        }
        Double avgInDegree = (double) inDegreeSum / subGraph.getNodeCount();

        inDegreeAverages.add(avgInDegree);
    }
    long timeElapsed = stopwatch.elapsed(TimeUnit.SECONDS);
    Log.info(LogCategory.GEXF, ".. Finised (elapsed time: " + timeElapsed + "s");
    return this;
}
 

import org.gephi.data.attributes.api.AttributeModel; //导入依赖的package包/类
public GephiProcessing calculateOutDegree() {
    Stopwatch stopwatch = Stopwatch.createStarted();
    AttributeModel am = Lookup.getDefault().lookup(AttributeController.class).getModel();
    Degree degree = new Degree();
    DynamicModel dynamicModel = Lookup.getDefault().lookup(DynamicController.class).getModel();
    Log.info(LogCategory.GEXF, "Calculating averages for Out-degree...");
    for (double i = 0.0; i < reportingIntervalCount; i++) {
        double high = i + 0.9;
        DynamicGraph dynamicGraph = dynamicModel.createDynamicGraph(graphModel.getGraph());
        Graph subGraph = dynamicGraph.getSnapshotGraph(i, high);
        degree.execute(graphModel, am);

        int outDegreeSum = 0;
        for (Node node : subGraph.getNodes()) {
            outDegreeSum += (int) node.getAttributes().getValue(Degree.OUTDEGREE);
        }
        Double avgOutDegree = (double) outDegreeSum / subGraph.getNodeCount();

        outDegreeAverages.add(avgOutDegree);
    }
    long timeElapsed = stopwatch.elapsed(TimeUnit.SECONDS);
    Log.info(LogCategory.GEXF, ".. Finised (elapsed time: " + timeElapsed + "s");
    return this;
}
 

import org.gephi.data.attributes.api.AttributeModel; //导入依赖的package包/类
/**
 * This method handles the action, when "finish" is clicked
 */
public void finishedClicked() {
    // check if really wants to finish
    int result = JOptionPane.showConfirmDialog(mainFrame, "Do you really want to finish?", "Finishing...", JOptionPane.YES_NO_OPTION);
    if(result != JOptionPane.YES_OPTION) {
        return;
    }
    
    // add columns if not already existing
    AttributeModel attrModel = Lookup.getDefault().lookup(AttributeController.class).getModel();
    for(int i = 0; i < Constants.newColumnsNode.length; i++) {
        if(attrModel.getNodeTable().getColumn(Constants.newColumnsNode[i]) == null) {
            attrModel.getNodeTable().addColumn(Constants.newColumnsNode[i], Constants.newColumnsNodeType[i]);
        }
    }
    for(int i = 0; i < Constants.newColumnsEdge.length; i++) {
        if(attrModel.getEdgeTable().getColumn(Constants.newColumnsEdge[i]) == null) {
            attrModel.getEdgeTable().addColumn(Constants.newColumnsEdge[i], Constants.newColumnsEdgeType[i]);
        }
    }
    
    // close frame
    mainFrame.dispose();  
    System.exit(0);
}
 

import org.gephi.data.attributes.api.AttributeModel; //导入依赖的package包/类
public Partition<Node> partition(Graph<MultimodalItem, SameClassLink> itemsGraph) {

		UndirectedGraph graph = getGraph(itemsGraph);
		
		System.out.println("Nodes: " + graph.getNodeCount());
		System.out.println("Edges: " + graph.getEdgeCount());

		AttributeModel attributeModel = Lookup.getDefault().lookup(AttributeController.class).getModel();
		
		// Run modularity algorithm - community detection
		Modularity modularity = new Modularity();
		modularity.setUseWeight(true);
		modularity.setResolution(1.);
		modularity.setRandom(true);
		modularity.execute(graphModel, attributeModel);
		
		AttributeColumn modColumn = attributeModel.getNodeTable().getColumn(Modularity.MODULARITY_CLASS);

		@SuppressWarnings("unchecked")
		Partition<Node> p = partitionController.buildPartition(modColumn, graph);
		
		return p;
	}
 

import org.gephi.data.attributes.api.AttributeModel; //导入依赖的package包/类
public GephiProcessing calculateDynamicCentralities() {
    Stopwatch stopwatch = Stopwatch.createStarted();
    AttributeModel am = Lookup.getDefault().lookup(AttributeController.class).getModel();
    GraphDistance graphDistance = new GraphDistance();
    DynamicModel dynamicModel = Lookup.getDefault().lookup(DynamicController.class).getModel();
    Log.info(LogCategory.GEXF, "Calculating average centralities...");
    for (double i = 0.0; i < reportingIntervalCount; i++) {
        double high = i + 1;
        DynamicGraph dynamicGraph = dynamicModel.createDynamicGraph(graphModel.getGraph());
        Graph subGraph = dynamicGraph.getSnapshotGraph(i, high);
        graphDistance.execute(graphModel, am);

        double betweennessSum = 0.0;
        double closenessSum = 0.0;
        double eccentricitySum = 0.0;
        for (Node node : subGraph.getNodes()) {
            betweennessSum += (double) node.getAttributes().getValue(GraphDistance.BETWEENNESS);
            closenessSum += (double) node.getAttributes().getValue(GraphDistance.CLOSENESS);
            eccentricitySum += (double) node.getAttributes().getValue(GraphDistance.ECCENTRICITY);
        }
        Double averageBetweenness = betweennessSum / subGraph.getNodeCount();
        Double averageCloseness = closenessSum / subGraph.getNodeCount();
        Double averageEccentricity =  eccentricitySum / subGraph.getNodeCount();

        betweennessAverages.add(averageBetweenness);
        closenessAverages.add(averageCloseness);
        eccentricityAverages.add(averageEccentricity);
    }
    long timeElapsed = stopwatch.elapsed(TimeUnit.SECONDS);
    Log.info(LogCategory.GEXF, "...Finished! (elapsed time: " + timeElapsed + "s");
    return this;
}
 

import org.gephi.data.attributes.api.AttributeModel; //导入依赖的package包/类
/**
 * Indicates to which degree nodes in the network tend to cluster together
 */
public  static double getAverageClusteringCoefficient(GraphModel graphModel, AttributeModel attributeModel) {
    ClusteringCoefficient clusteringCoefficient = new ClusteringCoefficient();
    clusteringCoefficient.execute(graphModel, attributeModel);

    double sum = 0;
    for (Node node : graphModel.getGraph().getNodes()) {
        sum += (double)node.getAttributes().getValue(ClusteringCoefficient.CLUSTERING_COEFF);
    }
    return sum / graphModel.getGraph().getNodeCount();
}
 

import org.gephi.data.attributes.api.AttributeModel; //导入依赖的package包/类
private static double getAverageGraphDistance(GraphModel graphModel, AttributeModel attributeModel, String distanceType) {
    GraphDistance graphDistance = new GraphDistance();
    graphDistance.setDirected(true);
    graphDistance.setNormalized(true);
    graphDistance.execute(graphModel, attributeModel);

    double sum = 0;
    for (Node node : graphModel.getGraph().getNodes()) {
        sum += (double)node.getAttributes().getValue(distanceType);
    }
    return sum / graphModel.getGraph().getNodeCount();
}
 

import org.gephi.data.attributes.api.AttributeModel; //导入依赖的package包/类
private static double getAverageDegree(GraphModel graphModel, AttributeModel attributeModel, String degreeType) {
    Degree degree = new Degree();
    degree.execute(graphModel, attributeModel);
    int sum = 0;
    for (Node node : graphModel.getGraph().getNodes()) {
        sum += (int)node.getAttributes().getValue(degreeType);
    }
    return sum / graphModel.getGraph().getNodeCount();
}
 

import org.gephi.data.attributes.api.AttributeModel; //导入依赖的package包/类
@Override
public void resetPropertiesValues() {
   AttributeModel attModel = Lookup.getDefault().lookup(AttributeController.class).getModel();
   for (AttributeColumn c : attModel.getNodeTable().getColumns()) {
       if(c.getId().equalsIgnoreCase("order")
               || c.getId().equalsIgnoreCase("ord")
               || c.getTitle().equalsIgnoreCase("order")
               || c.getTitle().equalsIgnoreCase("ord")) {
           order = c;
       } else {
           order = null;
       }
   }
    int nodesCount = 0;

    if (graphModel != null) {
        nodesCount = graphModel.getGraphVisible().getNodeCount();
    }

    setOrderScale(10.0);
    
    // Tuning
    setScalingRatio(1.0);
    
    setStrongGravityMode(false);
    setGravity(1.);
    
    setVertical(false);
    setCenter(false);

    // Performance
    if (nodesCount >= 50000) {
        setJitterTolerance(10d);
    } else if (nodesCount >= 5000) {
        setJitterTolerance(1d);
    } else {
        setJitterTolerance(0.3d);
    }

    setThreadsCount(2);
    

    
}
 

import org.gephi.data.attributes.api.AttributeModel; //导入依赖的package包/类
/**
     * Calculates the average number of control messages sent and received.
     *
     * The averages are calculated by dividing the total number of control messages sent/received
     * over the entire execution of the protocol with the number of reporting intervals, i.e. it calculates
     * control messages per reporting interval.
     *
     * @return A pointer to itself for easy client method chaining
     */
    public GephiProcessing averageControlMsgs() {
        AttributeModel am = Lookup.getDefault().lookup(AttributeController.class).getModel();

        am.getNodeTable().addColumn(NodeAttributes.CONTROL_MSGS_SENT_AVG, AttributeType.DOUBLE);
        am.getNodeTable().addColumn(NodeAttributes.CONTROL_MSGS_RECEIVED_AVG, AttributeType.DOUBLE);

        for (double i = 0.0; i < reportingIntervalCount; i++) {
            double high = i + 0.9;
            Integer controlMsgSentCountTotal = 0;
            Integer controlMsgRcvdCountTotal = 0;
            for (Node node : graphModel.getGraph().getNodes()) {

                DynamicInteger gossipsSent = (DynamicInteger) node.getAttributes().getValue(NodeAttributes.CONTROL_MSGS_SENT);
                DynamicInteger gossipsReceived = (DynamicInteger) node.getAttributes().getValue(NodeAttributes.CONTROL_MSGS_RECEIVED);


                if (gossipsSent == null || gossipsReceived == null) {
                    Log.debug(LogCategory.COLLECTOR, "Could not find control msg count attributes");
                    return this;
                }

                Integer controlMsgSentCount =  gossipsSent.getValue(new Interval(i, high));
                Integer controlMsgRcvdCount = gossipsReceived.getValue(new Interval(i, high));

                // null value means the node was down for this interval due to churn
                if (controlMsgRcvdCount != null && controlMsgSentCount != null) {
                    controlMsgSentCountTotal += controlMsgSentCount;
                    controlMsgRcvdCountTotal += controlMsgRcvdCount;
                }

//                double maxInterval = gossipsSent.getHigh();
//                Integer gossipSentCount = gossipsSent.getValue(maxInterval - 1, maxInterval);
//                Integer gossipReceivedCount = gossipsReceived.getValue(maxInterval - 1, maxInterval);

//            Log.debug("node id: " + node.getNodeData().getId());
//            Log.debug("gossipSentCount: " + gossipSentCount);
//            Log.debug("reportingIntervalCount :" + reportingIntervalCount);
//            Log.debug("average: " +  gossipSentCount / reportingIntervalCount);

//                node.getAttributes().setValue(NodeAttributes.CONTROL_MSGS_SENT_AVG, Math.round(avgGossipsSent * 100.0) / 100.0);
//                node.getAttributes().setValue(NodeAttributes.CONTROL_MSGS_RECEIVED_AVG, Math.round(avgGossipsReceieved * 100.0) / 100.0);
            }
            double avgGossipsSent = (double) controlMsgSentCountTotal / graphModel.getGraph().getNodeCount();
            double avgGossipsReceieved = (double) controlMsgRcvdCountTotal / graphModel.getGraph().getNodeCount();

            controlMsgsSentAvg.add(avgGossipsSent);
            controlMsgsRcvdAvg.add(avgGossipsReceieved);
        }
        return this;
    }
 

import org.gephi.data.attributes.api.AttributeModel; //导入依赖的package包/类
public GephiProcessing averageTopicDiameter(Set<String> topics) {

        Stopwatch stopwatch = Stopwatch.createStarted();
        final AttributeModel am = Lookup.getDefault().lookup(AttributeController.class).getModel();
        final FilterController filterController = Lookup.getDefault().lookup(FilterController.class);
        final DynamicModel dynamicModel = Lookup.getDefault().lookup(DynamicController.class).getModel();
        DynamicGraph dynamicGraph = dynamicModel.createDynamicGraph(graphModel.getGraph());
        final int topicSize = topics.size();

        for (double i = 0.0; i < reportingIntervalCount; i++) {
            Log.info(LogCategory.GEXF, "Calculating topic diameter for interval " + i + "...");
            double diameter = 0;
            double high = i + 1;
            Graph graph = dynamicGraph.getSnapshotGraph(i, high);

//            Log.debug(LogCategory.GEXF, "Node count: " + graph.getNodeCount());
//            Log.debug(LogCategory.GEXF, "Edge count: " + graph.getEdgeCount());

            for (String topic : topics) {


                AttributeEqualBuilder.EqualStringFilter nodeFilter =
                        new AttributeEqualBuilder
                                .EqualStringFilter(am.getNodeTable().getColumn(NodeAttributes.TOPICS));

                AttributeEqualBuilder.EqualStringFilter edgeFilter =
                        new AttributeEqualBuilder
                                .EqualStringFilter(am.getNodeTable().getColumn(EdgeAttributes.TOPICS));

                final String pattern = ".*" + topic + ".*";

                nodeFilter.init(graph);
                edgeFilter.init(graph);

                nodeFilter.setUseRegex(true);
                edgeFilter.setUseRegex(true);

                nodeFilter.setPattern(pattern);
                edgeFilter.setPattern(pattern);

                nodeFilter.evaluate(graph, graph);
                nodeFilter.finish();

                edgeFilter.evaluate(graph, graph);
                edgeFilter.finish();

                Query nodeQuery = filterController.createQuery(nodeFilter);
                Query edgeQuery = filterController.createQuery(edgeFilter);

                filterController.setSubQuery(nodeQuery, edgeQuery);
                GraphView view = filterController.filter(edgeQuery);
                graphModel.setVisibleView(view);
                HierarchicalGraph subGraph = graphModel.getHierarchicalGraphVisible();

//            Log.debug(LogCategory.GEXF, "Topic graph " + topic + " node count: " + subGraph.getNodeCount());
//            Log.debug(LogCategory.GEXF, "Topic graph " + topic + " edge count: " + subGraph.getEdgeCount());

                GraphDistance graphDistance = new GraphDistance();
                graphDistance.execute(subGraph, am);
                diameter += graphDistance.getDiameter();
            }
            double averageDiameter = diameter / topicSize;
//        averageDiameter = (averageDiameter * 100.0) / 100.0;
            topicDiameterAverages.add(averageDiameter);
        }
        long timeElapsed = stopwatch.elapsed(TimeUnit.SECONDS);
        Log.info(LogCategory.GEXF, "...Finished! (elapsed time: " + timeElapsed + "s");
        return this;
    }
 

import org.gephi.data.attributes.api.AttributeModel; //导入依赖的package包/类
public static double getAverageInDegree(GraphModel graphModel, AttributeModel attributeModel) {
    return getAverageDegree(graphModel, attributeModel, Degree.INDEGREE);
}
 

import org.gephi.data.attributes.api.AttributeModel; //导入依赖的package包/类
public static double getAverageOutDegree(GraphModel graphModel, AttributeModel attributeModel) {
    return getAverageDegree(graphModel, attributeModel, Degree.OUTDEGREE);
}