Package org.openjump.core.apitools

Class FeatureCollectionTools

  • public class FeatureCollectionTools
extends ToolToMakeYourLifeEasier
    Class to speed up handling of FeatureCollections (or lists of features) during progamming by implementing a set of common tasks. Most functions can be used in a static way, but on the other hand for each FeatureCollection a instance of this class can be invoked. This might be more convenient, if there is more than one thing to do with the same feature collection.
    Version:
    $Rev$ [sstein] - 22.Feb.2009 - modified to work in OpenJUMP
    Author:
    Ole Rahn, Stefan Steiniger

    FH Osnabrück - University of Applied Sciences Osnabrück,
    Project: PIROL (2005),
    Subproject: Daten- und Wissensmanagement

    • Constructor Detail

      • FeatureCollectionTools

        public FeatureCollectionTools​(List<Feature> fcl)

    • Method Detail

      • getFeature

        public Feature getFeature​(int fid)
        gets the Feature with the given FID.
        Parameters:
        fid - FID to look for
        Returns:
        the feature

      • getFeatureFromCollection

        public static Feature getFeatureFromCollection​(List<Feature> features,
                                               int fid)
        Get the feature with the specified ID from the List
        Parameters:
        features - array with Feature objects
        fid - the feature ID we are looking for
        Returns:
        feature with specified FID if exists, else null

      • getFeatureFromCollection

        public static Feature getFeatureFromCollection​(Feature[] features,
                                               int fid)
        Get the feature with the specified ID from the array
        Parameters:
        features - array with Feature objects
        fid - the feature ID we are looking for
        Returns:
        feature with specified FID if exists, else null

      • cloneFeatureCollection

        public static PirolFeatureCollection cloneFeatureCollection​(FeatureCollection fc)
        deep copies a the FeatureSchema, the Features and their Geometries
        Parameters:
        fc - the FeatureCollection to copy
        Returns:
        the new copied FeatureCollection

      • getFeatureFromCollection

        public static Feature getFeatureFromCollection​(FeatureCollection features,
                                               int fid)
        Get the feature with the specified ID from the FeatureCollection
        Parameters:
        features - array with Feature objects
        fid - the feature ID we are looking for
        Returns:
        feature with specified FID if exists, else null

      • getAritmeticMiddleForAttribute

        public static double getAritmeticMiddleForAttribute​(Feature[] features,
                                                    String attr)
        Parameters:
        features - list of features to calculate the mean for
        attr - name of attribute to calculate the mean for
        Returns:
        the mean (double because a mean of integers will very likely be a double)

      • getMeanOrModeForAttributes

        public static Object[] getMeanOrModeForAttributes​(Feature[] features,
                                                  String[] attrs)
        Method to calculate means (or modes) for the attributes given. If means or modes are calulated depends on the attribute type of each given attribute. This method is hopefully faster, than calculation each mean (mode) in an extra loop, if there are more means (modes) to calculate than one...
        Parameters:
        features - list of features to calculate mean/modes for
        attrs - array of attribute names to calculate mean/modes for
        Returns:
        array of objects, representing means (or modes) --> e.g. Double, Integer or String objects.

      • getEnvelopeForFeatures

        public static org.locationtech.jts.geom.Envelope getEnvelopeForFeatures​(Feature[] features)
        Creates an envelope object for the features in the given array. This is an easy way to get an envelope for a subset of a layer's features.
        Parameters:
        features - array of Feature object to create an envelope for
        Returns:
        the envelope containing the given features

      • getAritmeticMiddleForAttribute

        public static double getAritmeticMiddleForAttribute​(List<Feature> features,
                                                    int attr)
        Parameters:
        features - list of features to calculate the mean for
        attr - index of attribute to calculate the mean for
        Returns:
        the mean (double because a mean of integers will very likely be a double)

      • getAritmeticMiddleForAttribute

        public static double getAritmeticMiddleForAttribute​(Feature[] featArray,
                                                    int attr)
        Parameters:
        featArray - array of features to calculate the mean for
        attr - index of attribute to calculate the mean for
        Returns:
        the mean (double because a mean of integers will very likely be a double)

      • getCenterOfMass

        public static org.locationtech.jts.geom.Geometry getCenterOfMass​(Feature[] features)
        Calculates the center of mass for the gives features' geometries. It's like getCentroid(), but puts out one center of mass for N features instead of N centers for N features.
        Parameters:
        features - the features
        Returns:
        the point, representing the center of mass

      • getSetOfDifferentAttributeValues

        public static Set getSetOfDifferentAttributeValues​(Feature[] features,
                                                   String attr)
        Parameters:
        features - list of features
        attr - name of attribute
        Returns:
        number of differnt values in the given features attributes or -1 if an error occurs

      • getSetOfDifferentAttributeValues

        public static Set<Object> getSetOfDifferentAttributeValues​(Feature[] features,
                                                           int attr)
        Parameters:
        features - list of features
        attr - index of attribute
        Returns:
        number of differnt values in the given features attributes or -1 if an error occurs

      • getNumOfDifferentAttributeValues

        public static int getNumOfDifferentAttributeValues​(Feature[] features,
                                                   String attr)
        Parameters:
        features - list of features
        attr - name of attribute
        Returns:
        number of differnt values in the given features attributes or -1 if an error occurs

      • getNumOfDifferentAttributeValues

        public static int getNumOfDifferentAttributeValues​(Feature[] features,
                                                   int attr)
        Parameters:
        features - list of features
        attr - index of attribute
        Returns:
        number of differnt values in the given features attributes or -1 if an error occurs

      • getModusForAttribute

        public static Object getModusForAttribute​(Feature[] features,
                                          String attr)
        Parameters:
        features - list of features to calculate the mode for
        attr - name of attribute to calculate the mode for
        Returns:
        the mode

      • getValueAppearancesCount

        public static HashMap<Object,​Integer>[] getValueAppearancesCount​(Feature[] features,
                                                                       int[] attrs)
        Counts the number of appearances of each value of the given attributes within the given features. (Somewhat like a histogram for each given attribute, but each histogram class is just a single value.)
        Parameters:
        features - array of Features to count value appearances for
        attrs - array of attribute indices of attributes to count value appearances for
        Returns:
        Array of mappings of values to number of appearances

      • getModusForAttribute

        public static Object getModusForAttribute​(Feature[] features,
                                          int attr)
        Parameters:
        features - list of features to calculate the mode for
        attr - index of attribute to calculate the mode for
        Returns:
        the mode

      • deleteFeatures

        public static void deleteFeatures​(List<Feature> features,
                                  PlugInContext context)
        deletes the given features from the map. It thereby creates an EditTransaction that enables the user to undo the deletion.
        Parameters:
        features - features to be deleted
        context - curr. PlugIn context

      • copyFeature

        public static Feature copyFeature​(Feature feat)
        "deep copys" the given Feature
        Parameters:
        feat - the feature to be copied
        Returns:
        copy of the feature

      • copyFeatureAndSetFeatureSchema

        public static Feature copyFeatureAndSetFeatureSchema​(Feature feat,
                                                     FeatureSchema newFs)
        "deep copys" the given Feature and thereby sets the given feature schema. The new FeatureSchema should have the same attribute names for copying. The new FeatureSchmema can have less or more attributes.
        Parameters:
        feat - the feature to be copied
        newFs - the new feature schema
        Returns:
        copy of the feature

      • getUniqueAttributeName

        public String getUniqueAttributeName​(String attr)

      • attributeExistsInSchema

        protected static boolean attributeExistsInSchema​(FeatureSchema fs,
                                                 String attr)

      • isAttributeTypeNumeric

        public static boolean isAttributeTypeNumeric​(AttributeType at)

      • applyFormulaToFeatureCollection

        public static PirolFeatureCollection applyFormulaToFeatureCollection​(FeatureCollection oldFc,
                                                                     AttributeInfo attrInfo,
                                                                     FormulaValue formula,
                                                                     boolean clearOldFeatureCollection)
        Method to apply a given formula to the given, new attribute of the given featureCollection
        Parameters:
        oldFc - old FeatureCollection that will be replaced by the new one
        attrInfo - information for the new attribute
        formula - the parsed formula
        Returns:
        FeatureCollection containing the new attribute

      • addAttributeToFeatureCollection

        public static PirolFeatureCollection addAttributeToFeatureCollection​(FeatureCollection fc,
                                                                     String attr,
                                                                     AttributeType at,
                                                                     Object defaultVal,
                                                                     boolean clearOldFeatureCollection)
        Method to add a new attribute to an existing FeatureCollection. Since there is no "legal" way to add an attribute to a FeatureCollection, this method creates (and returns) a new FeatureCollection with a new FeatureSchema to do this operation. If a layer is to be manipulated the new FeatureCollection has to be set as THE FeatureCollection for the layer...
        Parameters:
        fc - the old feature collection
        attr - name of the new attribute
        at - type of the new attribute
        defaultVal - the initial value for the attribute, since we do not want NULL values in the attribute table
        clearOldFeatureCollection - if true the old feature collection will be erased to save RAM
        Returns:
        new FeatureCollection with a new FeatureSchema including the new attribute

      • addAttributeToFeatureCollection

        public static PirolFeatureCollection addAttributeToFeatureCollection​(FeatureCollection fc,
                                                                     String attr,
                                                                     AttributeType at,
                                                                     Object defaultVal)
        Method to add a new attribute to an existing FeatureCollection. Since there is no "legal" way to add an attribute to a FeatureCollection, this method creates (and returns) a new FeatureCollection with a new FeatureSchema to do this operation. If a layer is to be manipulated the new FeatureCollection has to be set as THE FeatureCollection for the layer...
        Parameters:
        fc - the old feature collection
        attr - name of the new attribute
        at - type of the new attribute
        defaultVal - the initial value for the attribute, since we do not want NULL values in the attribute table
        Returns:
        new FeatureCollection with a new FeatureSchema including the new attribute

      • addAttributesToFeatureCollection

        public PirolFeatureCollection addAttributesToFeatureCollection​(List attributeInfos)
        Adds multiple attributes to the FeatureCollection
        Parameters:
        attributeInfos - list containing the attributes (as AttributeInfo objects) to be added
        Returns:
        a new FeatureCollection containing the old and the new attributes
        See Also:
        AttributeInfo

      • addAttributesToFeatureCollection

        public static PirolFeatureCollection addAttributesToFeatureCollection​(FeatureCollection fc,
                                                                      List<AttributeInfo> attributeInfos)
        Adds multiple attributes to a FeatureCollection
        Parameters:
        fc - the source feature collection
        attributeInfos - list containing the attributes (as AttributeInfo objects) to be added
        Returns:
        a new FeatureCollection containing the old and the new attributes
        See Also:
        AttributeInfo

      • addAttributesToFeatureCollection

        public static PirolFeatureCollection addAttributesToFeatureCollection​(FeatureCollection fc,
                                                                      AttributeInfo[] attributeInfos,
                                                                      boolean clearOriginalFeatureCollection)
        Adds multiple attributes to a FeatureCollection
        Parameters:
        fc - the source feature collection
        attributeInfos - array containing the attributes to be added
        clearOriginalFeatureCollection - set true, if you want to save RAM by clearing the original FeatureCollection, false if you still want to use it.
        Returns:
        a new FeatureCollection containing the old and the new attributes

      • resizeArray

        public static Object resizeArray​(Object oldArray,
                                 int newSize)
        Reallocates an array with a new size, and copies the contents of the old array to the new array.
        Parameters:
        oldArray - the old array, to be reallocated.
        newSize - the new array size.
        Returns:
        A new array with the same contents.

      • getMinMaxAttributeValue

        public static double[] getMinMaxAttributeValue​(Feature[] featArray,
                                               FeatureSchema fs,
                                               String attr)

      • getMinMaxAttributeValue

        public static double[] getMinMaxAttributeValue​(FeatureCollection features,
                                               String attr)

      • FeatureCollection2FeatureArray

        public static Feature[] FeatureCollection2FeatureArray​(FeatureCollection fc)
        Converts a given FeatureCollection into an array of Feature, that can - by far - be faster iterated.
        Parameters:
        fc - the feature Collection
        Returns:
        an array of the features of the feature collection

      • FeatureCollection2FeatureArray

        public static Feature[] FeatureCollection2FeatureArray​(List<Feature> features)
        Converts a given list of features into an array of Feature, that can - by far - be faster iterated.
        Parameters:
        features - list of features
        Returns:
        an array of the features of the feature list

      • convertToPointFeature

        public static ArrayList<Feature> convertToPointFeature​(Feature f,
                                                       boolean accountForRings)
        Extracts all points from an input feature and returns them as list of point features. Note: for closed Geometry objects the start and end point are extracted - i.e. the points may be overlap.
        Parameters:
        f - the Feature to convert
        accountForRings - doesn't add a point for the last coordinate if the geometry is a ring (i.e. first point equals last point)
        Returns:
        list of point features

      • sortFeaturesIntoListsByAttributeValue

        public static Object[] sortFeaturesIntoListsByAttributeValue​(FeatureCollection features,
                                                             String idAttribute)
        Sorts features according to unique attribute values into different lists (on list for each unique attribute). TODO: enable sorting for String values
        Parameters:
        features - the Features to sort
        idAttribute - (must be Double or Integer)
        Returns:
        Object[0]: an Array of ArrayLists containing features, Object[1]: an Array of int values containing the unique values used for sorting. Can return null if wrong AttributeType. E.g. use
        Object[] myReturns = FeatureCollectionTools.sortFeaturesIntoListsByAttributeValue(pointFeatures, idAttribute);
        individualPts = (ArrayList[])myReturns[0];
        int[] uniqueValues = (int[])myReturns[1];
        Note that the order in which the lists are returned is not sorted!

      • getNumericalAttributeValue

        public static double getNumericalAttributeValue​(Feature f,
                                                String attributeName)
        gets the value of an attribute; it checks if the attribute is of double or int type, otherwise NaN is returned.
        Parameters:
        f - the Feature from which to extract the numeric attribute
        attributeName - name of the attribute to extract
        Returns:
        value as double

      • sortFeatureListByAttributeBeginWithSmallest

        public static ArrayList<Feature> sortFeatureListByAttributeBeginWithSmallest​(List<Feature> features,
                                                                             String attributeNameForSorting)
        Sorts a list of features according to the values of a attribute. If values are similar the feature are ordered the same way as in the input list. TODO: this method has been tested only briefly (not exhaustively)
        Parameters:
        features - the features to sort
        attributeNameForSorting - attribute needs to be either Integer or Double
        Returns:
        list of sorted features; the smallest value will be first in the list.