import org.gephi.data.attributes.api.AttributeColumn; //导入依赖的package包/类
AttributeColumn getAttributeField(String[] patterns, AttributeColumn[] columns) {
    for (AttributeColumn col : columns) {
        for (String str : patterns) {
            Pattern pattern = Pattern.compile(str, Pattern.CASE_INSENSITIVE);
            Matcher matcher = pattern.matcher(col.getTitle());
            if (matcher.find() && (col.getType() == AttributeType.FLOAT
                    // Make sure data is formatted correctly
                    || col.getType() == AttributeType.DOUBLE
                    || col.getType() == AttributeType.BIGDECIMAL
                    || col.getType() == AttributeType.DYNAMIC_BIGDECIMAL
                    || col.getType() == AttributeType.DYNAMIC_DOUBLE
                    || col.getType() == AttributeType.DYNAMIC_FLOAT)) {

                return col;
            }
        }
    }
    return null;
}
 

import org.gephi.data.attributes.api.AttributeColumn; //导入依赖的package包/类
private SimpleFeatureType getFeatureTypeForAttributes(Class geometryClass, AttributeColumn[] nodeColums) {
    SimpleFeatureTypeBuilder builder = new SimpleFeatureTypeBuilder();
    builder.setName(geometryClass.getName());

    //Add a geometry
    builder.add(LOCATION_FIELD, geometryClass);

    for (AttributeColumn col : nodeColums) {
        String name = col.getTitle();
        AttributeType typ = col.getType();

        //ignore Lists? 
        if (!typ.isListType()) {
            builder.add(name, typ.getType());
        }
    }
    //add size and color attributes
    builder.add(SIZE_FIELD, Float.class);
    builder.add(COLOR_FIELD, String.class);

    //build the type
    SimpleFeatureType featureType = builder.buildFeatureType();
    return featureType;
}
 

import org.gephi.data.attributes.api.AttributeColumn; //导入依赖的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.AttributeColumn; //导入依赖的package包/类
/**
 * This method checks, if the given Column is boolean
 * @param chosenColumn name of the column
 * @return true if column is boolean, false otherwise
 */
private boolean checkIfColumnIsBoolean(String chosenColumn) {
    AttributeColumn[] columns = attrModel.getNodeTable().getColumns();
    for (AttributeColumn column : columns) {
        if (column.getTitle().equals(chosenColumn)) {
            return column.getType() == AttributeType.BOOLEAN;
        }
    }
    return false;
}
 

import org.gephi.data.attributes.api.AttributeColumn; //导入依赖的package包/类
/**
 * This method checks, if the given string exists in all columns
 * @param s string to be checked
 * @param columns columns where to check
 * @return true if existing as column, false if not
 */
private static boolean exists(String s, AttributeColumn[] columns) {
    for (AttributeColumn column : columns) {
        if (s.equals(column.getTitle())) {
            return true;
        }
    }
    return false;
}
 

import org.gephi.data.attributes.api.AttributeColumn; //导入依赖的package包/类
public AttributeColumn[] findGeoFields(AttributeColumn[] columns) {
    String[] latAttributes = {"latitude", "^lat$", "^y$", "(.*)lat(.*)"};
    String[] lonAttributes = {"longitude", "lon", "lng", "^x$", "(.*)lon(.*)", "(.*)lng(.*)"};

    // find attributes by iterating over property names
    longitudeColumn = getAttributeField(lonAttributes, columns);
    latitudeColumn = getAttributeField(latAttributes, columns);
    AttributeColumn[] result = {getLongitudeColumn(), getLatitudeColumn()};
    return result;
}
 

import org.gephi.data.attributes.api.AttributeColumn; //导入依赖的package包/类
private Coordinate getCoordinateForNode(Node node, AttributeColumn[] geoFields) {
    double latitude, longitude;

    //is there a location set? else use pseudo-coordinates...
    if (geoFields[0] != null) {
        final AttributeRow row = (AttributeRow) (node).getNodeData().getAttributes();
        latitude = getDoubleForCoordinateFieldObject(row.getValue(geoFields[0]));
        longitude = getDoubleForCoordinateFieldObject(row.getValue(geoFields[1]));
    } else {
        latitude = node.getNodeData().x();
        longitude = node.getNodeData().y();
    }
    Coordinate coordinate = new Coordinate(latitude, longitude);
    return coordinate;
}
 

import org.gephi.data.attributes.api.AttributeColumn; //导入依赖的package包/类
public float getFloatValue(Node node, AttributeColumn column) {
return ((Number) node.getNodeData().getAttributes().getValue(column.getIndex())).floatValue();
}
 

import org.gephi.data.attributes.api.AttributeColumn; //导入依赖的package包/类
@Override
public LayoutProperty[] getProperties() {
    List<LayoutProperty> properties = new ArrayList<LayoutProperty>();
    final String TIMEFORCE =  "Time Force Layout";
    
    try {
        properties.add(LayoutProperty.createProperty(
                this, Double.class,
                "Scale of Order",
                TIMEFORCE,
                "Determines the separation of the nodes on the x-axis",
                "getOrderScale", "setOrderScale"));
        properties.add(LayoutProperty.createProperty(
                this, AttributeColumn.class,
                "Order",
                TIMEFORCE,
                "Selects the attribute that indicates the order of events",
                "getOrder", "setOrder", NodeColumnNumbersEditor.class));
        properties.add(LayoutProperty.createProperty(
                this, Boolean.class,
                "Set Vertical Force",
                TIMEFORCE,
                "Used to push unconnected groups of nodes away from each other",
                "isVertical", "setVertical"));
        properties.add(LayoutProperty.createProperty(
                this, Double.class,
                "Vertical Scale",
                TIMEFORCE,
                "Sets the strength of the vertical force",
                "getScalingRatio", "setScalingRatio"));
        properties.add(LayoutProperty.createProperty(
                this, Boolean.class,
                "Strong Gravity Mode",
                TIMEFORCE,
                "Sets the strong gravity mode",
                "isStrongGravityMode", "setStrongGravityMode"));
        properties.add(LayoutProperty.createProperty(
                this, Double.class,
                "Gravity",
                TIMEFORCE,
                "Pulls nodes to origin of the y-axis. Prevents islands from drifting away.",
                "getGravity", "setGravity"));
        properties.add(LayoutProperty.createProperty(
                this, Double.class,
                "Jitter Tolerance",
                TIMEFORCE,
                "How much swiging you allow.",
                "getJitterTolerance", "setJitterTolerance"));
        properties.add(LayoutProperty.createProperty(
                this, Integer.class,
                "Threads",
                TIMEFORCE,
                "Possibility to use more threads if your cores can handle it.",
                "getThreadsCount", "setThreadsCount"));
        properties.add(LayoutProperty.createProperty(
                this, Boolean.class,
                "Center",
                TIMEFORCE,
                "Centers the graph",
                "isCenter", "setCenter"));

    } catch (Exception e) {
        e.printStackTrace();
    }

    return properties.toArray(new LayoutProperty[0]);
}
 

import org.gephi.data.attributes.api.AttributeColumn; //导入依赖的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.AttributeColumn; //导入依赖的package包/类
public AttributeColumn getOrder() {
    return order;
}
 

import org.gephi.data.attributes.api.AttributeColumn; //导入依赖的package包/类
public void setOrder(AttributeColumn order) {
   this.order = order;
}
 

import org.gephi.data.attributes.api.AttributeColumn; //导入依赖的package包/类
/**
 * @return the longitudeColumn
 */
public AttributeColumn getLongitudeColumn() {
    return longitudeColumn;
}
 

import org.gephi.data.attributes.api.AttributeColumn; //导入依赖的package包/类
/**
 * @return the latitudeColumn
 */
public AttributeColumn getLatitudeColumn() {
    return latitudeColumn;
}
 

import org.gephi.data.attributes.api.AttributeColumn; //导入依赖的package包/类
public SHPExporterDialog(AttributeColumn[] nodeColums, AttributeColumn[] geoFields) {
    super(new JFrame(), "SHP Export Options", true);
    initComponents();
    this.nodeColums = nodeColums;
    this.geoFields = geoFields;
}
 

import org.gephi.data.attributes.api.AttributeColumn; //导入依赖的package包/类
public AttributeColumn[] getGeoFields() {
    return realCoordinatesRadioButton.isSelected() ? 
        new AttributeColumn[]{(AttributeColumn) longitudeComboBox.getSelectedItem(),
        (AttributeColumn) latitudeComboBox.getSelectedItem()} :
        new AttributeColumn[]{null, null};
}
 

import org.gephi.data.attributes.api.AttributeColumn; //导入依赖的package包/类
public boolean execute() {
    try {
        PreviewModel previewModel;
        final PreviewController previewController = Lookup.getDefault().lookup(PreviewController.class);

        //there seems to be a bug in gephi or in gephi & eclipse that needs a refresh of the preview - else the model is empty
        previewController.refreshPreview();

        previewModel = previewController.getModel();
        AttributeModel model = Lookup.getDefault().lookup(AttributeController.class).getModel();
        AttributeColumn[] nodeColums = model.getNodeTable().getColumns();

        //try to find the GeoFields
        AttributeColumn[] geoFields;
        GeoAttributeFinder gaf = new GeoAttributeFinder();
        geoFields = gaf.findGeoFields(nodeColums);

        SHPExporterDialog exporterDialog;
        exporterDialog = new SHPExporterDialog(nodeColums, geoFields);
        exporterDialog.setTitle("SHP Export Options");
        if (exporterDialog.showDialog()) {
            geoFields = exporterDialog.getGeoFields();
            File exportFile = exporterDialog.getFile();

            //Construct Export Filenames
            String baseName = exportFile.getName();
            baseName = baseName.substring(0, baseName.lastIndexOf("."));
            File pointFile = new File(exportFile.getParentFile(), baseName + ".node.shp");
            File edgeFile = new File(exportFile.getParentFile(), baseName + ".edge.shp");

            //convert data to pointFeatureSource
            SimpleFeatureType pointFeatureType = getFeatureTypeForAttributes(Point.class, nodeColums);
            SimpleFeatureCollection pointFeatureSource;
            pointFeatureSource = getPointFeatureSource(previewModel, pointFeatureType, geoFields);

            //convert data to edgeFeatureSource
            AttributeColumn[] edgeColums = model.getEdgeTable().getColumns();
            SimpleFeatureType edgeFeatureType = getFeatureTypeForAttributes(LineString.class, edgeColums);
            SimpleFeatureCollection edgeFeatureSource;
            edgeFeatureSource = getFeatureSource(false, previewModel, edgeFeatureType, geoFields);


            //Create Shapefile
            //Netbean securit-manager ist running wild - dunno what to do but cathc the exception
            writeSHP(pointFile.toURL(), pointFeatureType, pointFeatureSource);

            writeSHP(edgeFile.toURL(), edgeFeatureType, edgeFeatureSource);
            return true;
        }
    } catch (IOException ex) {
        Logger.getLogger(SHPExporter.class.getName()).log(Level.SEVERE, null, ex);
    }
    return true;
}
 

import org.gephi.data.attributes.api.AttributeColumn; //导入依赖的package包/类
private SimpleFeatureCollection getPointFeatureSource(PreviewModel previewModel, SimpleFeatureType featureType, AttributeColumn[] geoFields) {
    boolean isPoints = true;
    SimpleFeatureCollection collection = getFeatureSource(isPoints, previewModel, featureType, geoFields);
    return collection;
}