Stefan,
I am sorry it is taking me so long to respond to this e-mail. Is this
something that we need a patch for?
If so I can make the needed changes in the SVN.
Let me know.
The Sunburned Surveyor
On 7/24/07, Stefan Steiniger <[EMAIL PROTECTED]> wrote:
> forwad for Malte as I accidently delted his message from the pending
> request list
>
> Dear OpenJump Enthusiast,
>
> I've tried to make a copy of a FeatureCollection containing Features
> with null values.
> I used the cloneFeatureCollection-Method of the FeatureCollectionTools
> Class from the Pirol Project (now implemented in the OJ beta, too) and
> got a NPE.
>
> I think a Feature should have Attributes containing null values, so I
> fixed this.
> The fixed class is attached.
>
> Greetings from cloudy Hanover,
> Malte
>
>
>
>
>
> /*
> * Created on 12.01.2005
> *
> * SVN header information:
> * $Author: mentaer $
> * $Rev: 2509 $
> * $Date: 2007/02/03 14:19:04 $
> * $Id: FeatureCollectionTools.java,v 1.2 2007/02/03 14:19:04 mentaer Exp $s
> */
> package de.fho.jump.pirol.utilities.apiTools;
>
> import java.util.ArrayList;
> import java.util.Date;
> import java.util.HashMap;
> import java.util.HashSet;
> import java.util.List;
> import java.util.Map;
> import java.util.Set;
>
> import com.vividsolutions.jts.geom.Coordinate;
> import com.vividsolutions.jts.geom.Envelope;
> import com.vividsolutions.jts.geom.Geometry;
> import com.vividsolutions.jts.geom.GeometryFactory;
> import com.vividsolutions.jump.feature.AttributeType;
> import com.vividsolutions.jump.feature.BasicFeature;
> import com.vividsolutions.jump.feature.Feature;
> import com.vividsolutions.jump.feature.FeatureCollection;
> import com.vividsolutions.jump.feature.FeatureDataset;
> import com.vividsolutions.jump.feature.FeatureSchema;
> import com.vividsolutions.jump.workbench.model.Layer;
> import com.vividsolutions.jump.workbench.plugin.PlugInContext;
> import com.vividsolutions.jump.workbench.ui.EditTransaction;
>
> import de.fho.jump.pirol.utilities.FeatureCollection.PirolFeatureCollection;
> import de.fho.jump.pirol.utilities.FormulaParsing.FormulaValue;
> import de.fho.jump.pirol.utilities.attributes.AttributeInfo;
> import de.fho.jump.pirol.utilities.comparisonAndSorting.ObjectComparator;
> import de.fho.jump.pirol.utilities.debugOutput.DebugUserIds;
> import de.fho.jump.pirol.utilities.debugOutput.PersonalLogger;
> import de.fho.jump.pirol.utilities.metaData.MetaInformationHandler;
>
> /**
> * 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.
> *
> * @author Ole Rahn
> * <br>
> * <br>FH Osnabrück - University of Applied Sciences Osnabrück,
> * <br>Project: PIROL (2005),
> * <br>Subproject: Daten- und Wissensmanagement
> *
> * @version $Rev: 2509 $
> */
>
> public class FeatureCollectionTools extends ToolToMakeYourLifeEasier {
>
> protected FeatureCollection fc = null;
> protected List<Feature> featureList;
> private HashMap<Integer, Feature> fid2Object = new HashMap<Integer,
> Feature>();
>
> protected static PersonalLogger logger = new
> PersonalLogger(DebugUserIds.ALL);
>
> public FeatureCollectionTools( FeatureCollection fc ){
> super();
> this.fc = fc;
> this.featureList = this.fc.getFeatures();
> }
>
> public FeatureCollectionTools( List<Feature> fcl ){
> super();
> this.featureList = fcl;
> }
>
> /**
> * gets the Feature with the given FID.
> [EMAIL PROTECTED] fid FID to look for
> [EMAIL PROTECTED] the feature
> */
> public Feature getFeature( int fid ){
> Integer FID = new Integer(fid);
> if (!this.fid2Object.containsKey(FID)){
>
> this.fid2Object.put(FID,FeatureCollectionTools.getFeatureFromCollection(this.featureList,
> fid));
> }
>
> return (Feature)this.fid2Object.get(FID);
> }
>
>
> /**
> * Get the feature with the specified ID from the List
> [EMAIL PROTECTED] features array with Feature objects
> [EMAIL PROTECTED] fid the feature ID we are looking for
> [EMAIL PROTECTED] feature with specified FID if exists, else null
> */
> public static Feature getFeatureFromCollection( List<Feature> features,
> int fid ){
> return
> FeatureCollectionTools.getFeatureFromCollection((Feature[])features.toArray(new
> Feature[0]), fid);
> }
>
> /**
> * Get the feature with the specified ID from the array
> [EMAIL PROTECTED] features array with Feature objects
> [EMAIL PROTECTED] fid the feature ID we are looking for
> [EMAIL PROTECTED] feature with specified FID if exists, else null
> */
> public static Feature getFeatureFromCollection( Feature[] features, int
> fid ){
> Feature feat;
>
> for ( int i=0; i < features.length; i++ ){
> feat = features[i];
>
> if (feat.getID() == fid){
> return feat;
> }
> }
> return null;
> }
>
> /**
> * deep copies a the FeatureSchema, the Features and their Geometries
> * @param fc the FeatureCollection to copy
> * @return the new copied FeatureCollection
> */
> public final static PirolFeatureCollection
> cloneFeatureCollection(FeatureCollection fc){
> FeatureSchema clonedSchema =
> (FeatureSchema)fc.getFeatureSchema().clone();
> FeatureDataset newFc = new FeatureDataset(clonedSchema);
>
> Feature[] featuresToCopy = FeatureCollection2FeatureArray(fc);
> Feature newFeat = null;
> AttributeType attrType = null;
>
> for (int i=0; i<featuresToCopy.length; i++){
> newFeat = new BasicFeature(clonedSchema);
>
> for (int attr=0; attr<clonedSchema.getAttributeCount();
> attr++){
> attrType = clonedSchema.getAttributeType(attr);
> /**
> * FIX for Null Values.
> * Added by mweller 24.07.2007
> */
> if(featuresToCopy[i].getAttribute(attr) != null){
> if (attrType.equals(AttributeType.DOUBLE)){
> newFeat.setAttribute(attr, new
> Double(((Double)featuresToCopy[i].getAttribute(attr)).doubleValue()) );
> } else if (attrType.equals(AttributeType.INTEGER)){
> newFeat.setAttribute(attr, new
> Integer(((Integer)featuresToCopy[i].getAttribute(attr)).intValue()) );
> } else if (attrType.equals(AttributeType.STRING)){
> newFeat.setAttribute(attr,
> ((String)featuresToCopy[i].getAttribute(attr)).trim() );
> } else if (attrType.equals(AttributeType.GEOMETRY)){
> newFeat.setAttribute(attr,
> ((Geometry)featuresToCopy[i].getAttribute(attr)).clone() );
> } else if (attrType.equals(AttributeType.DATE)){
> newFeat.setAttribute(attr,
> ((Date)featuresToCopy[i].getAttribute(attr)).clone() );
> } else if (attrType.equals(AttributeType.OBJECT)){
> logger.printError("not implemented!");
> newFeat.setAttribute(attr,
> (featuresToCopy[i].getAttribute(attr)) );
> }
> }
> else{
> newFeat.setAttribute(attr, null );
> }
> }
>
> newFc.add(newFeat);
> }
> return MetaInformationHandler.createPirolFeatureCollection(newFc);
> }
>
> /**
> * Get the feature with the specified ID from the FeatureCollection
> [EMAIL PROTECTED] features array with Feature objects
> [EMAIL PROTECTED] fid the feature ID we are looking for
> [EMAIL PROTECTED] feature with specified FID if exists, else null
> */
> public static Feature getFeatureFromCollection( FeatureCollection
> features, int fid ){
> return
> FeatureCollectionTools.getFeatureFromCollection(features.getFeatures(), fid);
> }
>
> /**
> [EMAIL PROTECTED] features list of features to calculate the mean for
> [EMAIL PROTECTED] attr name of attribute to calculate the mean for
> [EMAIL PROTECTED] the mean (double because a mean of integers will very
> likely be a double)
> */
> public static double getAritmeticMiddleForAttribute( Feature[] features,
> String attr ){
>
> if (features == null || features.length==0) return Double.NaN;
>
> Feature f = features[0];
> FeatureSchema fs = f.getSchema();
> int attrInd = fs.getAttributeIndex(attr);
> return FeatureCollectionTools.getAritmeticMiddleForAttribute(
> features, attrInd );
> }
>
> /**
> * Method to calculate means (or modes) for the attributes given. If means
> or modes
> * are calulated depends on the attribute type of each given 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...
> [EMAIL PROTECTED] features list of features to calculate mean/modes for
> [EMAIL PROTECTED] attrs array of attribute names to calculate mean/modes
> for
> [EMAIL PROTECTED] array of objects, representing means (or modes) -->
> e.g. Double, Integer or String objects.
> */
> public static Object[] getMeanOrModeForAttributes( Feature[] features,
> String[] attrs ){
> if (features==null || features.length==0) return null;
>
> int numVals = features.length;
> int numAttrs = attrs.length;
>
> FeatureSchema fs = features[0].getSchema();
> Object[] meansOrModes = new Object[numAttrs];
> AttributeType[] ats = new AttributeType[numAttrs];
>
> Object[] sumsOrMaps = new Object[numAttrs];
> boolean[] atIsNumeric = new boolean[numAttrs];
>
> for (int i=0; i<numAttrs; i++){
> ats[i] = fs.getAttributeType(attrs[i]);
> atIsNumeric[i] =
> FeatureCollectionTools.isAttributeTypeNumeric(ats[i]);
> if (atIsNumeric[i]){
> sumsOrMaps[i] = new Double(0);
> } else {
> // Map; no. of max. occurances; modus value
> sumsOrMaps[i] = new Object[]{ new HashMap(), new Integer(0),
> null };
> }
> }
>
> Feature currFeat;
> Double sum;
> Object value, modus;
> Map<Object,Object> map;
>
> Feature[] featArray = features;
>
> Integer maxOcc;
> int occ = 0;
>
> for (int i=0; i<featArray.length; i++){
> currFeat = featArray[i];
> for (int j=0; j<numAttrs; j++){
> if (atIsNumeric[j]){
> sum = ((Double)sumsOrMaps[j]);
> if (currFeat.getAttribute(attrs[j]) != null){
> sumsOrMaps[j] = new Double(sum.doubleValue() +
> ObjectComparator.getDoubleValue(currFeat.getAttribute(attrs[j])));
> } else {
> // value is skipped
> FeatureCollectionTools.logger.printMinorError("skipped
> a value (NULL), when calculating mean for " + attrs[j]);
> }
> } else {
> value = currFeat.getAttribute(attrs[j]);
>
> if (value.getClass().equals(String.class)){
> ((String)value).trim();
> }
>
> map = (Map)((Object[])sumsOrMaps[j])[0];
> maxOcc = (Integer)((Object[])sumsOrMaps[j])[1];
> modus = ((Object[])sumsOrMaps[j])[2];
>
> if ( map.containsKey(value) ){
> occ = ((Integer)map.get(value)).intValue();
> occ += 1;
> map.remove(value);
> } else {
> occ = 1;
> }
> map.put(value,new Integer(occ));
>
> if (occ > maxOcc.intValue()){
> maxOcc = new Integer(occ);
> modus = value;
> }
>
> sumsOrMaps[j] = new Object[]{map,maxOcc,modus};
>
> }
> }
> }
>
> for ( int i=0; i<meansOrModes.length; i++ ){
> if (atIsNumeric[i]){
> meansOrModes[i] = new Double(
> ((Double)sumsOrMaps[i]).doubleValue()/((double)numVals) );
> } else {
> meansOrModes[i] = ((Object[])sumsOrMaps[i])[2];
> }
> }
>
> return meansOrModes;
> }
>
> /**
> * 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.
> [EMAIL PROTECTED] features array of Feature object to create an envelope
> for
> [EMAIL PROTECTED] the envelope containing the given features
> */
> public static Envelope getEnvelopeForFeatures(Feature[] features){
> Envelope env = null;
> Feature feat;
>
> for (int i=0; i<features.length; i++){
> feat = features[i];
> if (env==null){
> env = new Envelope(feat.getGeometry().getCoordinate());
> } else {
> env.expandToInclude(feat.getGeometry().getCoordinate());
> }
> }
>
> return env;
> }
>
> /**
> [EMAIL PROTECTED] features list of features to calculate the mean for
> [EMAIL PROTECTED] attr index of attribute to calculate the mean for
> [EMAIL PROTECTED] the mean (double because a mean of integers will very
> likely be a double)
> */
> public static double getAritmeticMiddleForAttribute( List<Feature>
> features, int attr ){
> return
> FeatureCollectionTools.getAritmeticMiddleForAttribute((Feature[])features.toArray(new
> Feature[0]), attr);
> }
>
> /**
> [EMAIL PROTECTED] featArray array of features to calculate the mean for
> [EMAIL PROTECTED] attr index of attribute to calculate the mean for
> [EMAIL PROTECTED] the mean (double because a mean of integers will very
> likely be a double)
> */
> public static double getAritmeticMiddleForAttribute( Feature[] featArray,
> int attr ){
> double sumVals = 0;
> int numVals = 0;
>
> if (featArray.length==0) {
> logger.printWarning("no features in list - return value will be
> NAN!");
> return Double.NaN;
> }
>
> Feature f = featArray[0];
> FeatureSchema fs = f.getSchema();
>
> if (
> FeatureCollectionTools.isAttributeTypeNumeric(fs.getAttributeType(attr)) ){
>
> //Iterator iter = features.iterator();
> Feature feat;
> double value;
>
> for (int i=0; i<featArray.length; i++){
> feat = featArray[i];
> value =
> ObjectComparator.getDoubleValue(feat.getAttribute(attr));
>
> sumVals += value;
> numVals ++;
> }
> }
>
> return (sumVals/(double)numVals);
> }
>
> /**
> * 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.
> [EMAIL PROTECTED] features the features
> [EMAIL PROTECTED] the point, representing the center of mass
> */
> public static Geometry getCenterOfMass( Feature[] features ){
> double sumX = 0, sumY = 0;
> GeometryFactory gf = new GeometryFactory();
>
> if (features==null || features.length==0) return null;
>
> Feature feat;
>
> for (int i=0; i<features.length; i++){
> feat = features[i];
> sumX += feat.getGeometry().getCoordinate().x;
> sumY += feat.getGeometry().getCoordinate().y;
> }
>
> double newX = sumX / (double)features.length;
> double newY = sumY / (double)features.length;
>
> return gf.createPoint(new Coordinate(newX, newY));
> }
>
> /**
> [EMAIL PROTECTED] features list of features
> [EMAIL PROTECTED] attr name of attribute
> [EMAIL PROTECTED] number of differnt values in the given features
> attributes or -1 if an error occurs
> */
> public static Set getSetOfDifferentAttributeValues( Feature[] features,
> String attr ){
> Feature f = features[0];
> FeatureSchema fs = f.getSchema();
> int attrInd = fs.getAttributeIndex(attr);
> return FeatureCollectionTools.getSetOfDifferentAttributeValues(
> features, attrInd );
> }
>
> /**
> [EMAIL PROTECTED] features list of features
> [EMAIL PROTECTED] attr index of attribute
> [EMAIL PROTECTED] number of differnt values in the given features
> attributes or -1 if an error occurs
> */
> public static Set<Object> getSetOfDifferentAttributeValues( Feature[]
> features, int attr ){
> Feature[] featArray = features;
> int numFeats = featArray.length;
>
> HashSet<Object> differentValues = new HashSet<Object>();
> Object val;
>
> for (int i=numFeats-1; i>=0; i--){
>
> val = featArray[i].getAttribute(attr);
> //if (!differentValues.contains(val))
> differentValues.add(val);
> }
>
> return differentValues;
> }
>
> /**
> [EMAIL PROTECTED] features list of features
> [EMAIL PROTECTED] attr name of attribute
> [EMAIL PROTECTED] number of differnt values in the given features
> attributes or -1 if an error occurs
> */
> public static int getNumOfDifferentAttributeValues( Feature[] features,
> String attr ){
> Feature f = features[0];
> FeatureSchema fs = f.getSchema();
> int attrInd = fs.getAttributeIndex(attr);
> return FeatureCollectionTools.getNumOfDifferentAttributeValues(
> features, attrInd );
> }
>
> /**
> [EMAIL PROTECTED] features list of features
> [EMAIL PROTECTED] attr index of attribute
> [EMAIL PROTECTED] number of differnt values in the given features
> attributes or -1 if an error occurs
> */
> public static int getNumOfDifferentAttributeValues( Feature[] features,
> int attr ){
> return
> FeatureCollectionTools.getSetOfDifferentAttributeValues(features,attr).size();
> }
>
> /**
> [EMAIL PROTECTED] features list of features to calculate the mode for
> [EMAIL PROTECTED] attr name of attribute to calculate the mode for
> [EMAIL PROTECTED] the mode
> */
> public static Object getModusForAttribute( Feature[] features, String attr
> ){
> Feature f = features[0];
> FeatureSchema fs = f.getSchema();
> int attrInd = fs.getAttributeIndex(attr);
> return FeatureCollectionTools.getModusForAttribute( features, attrInd
> );
> }
>
>
> /**
> * 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.)
> * @param features array of Features to count value appearances for
> * @param attrs array of attribute indices of attributes to count value
> appearances for
> * @return Array of mappings of values to number of appearances
> */
> public final static HashMap<Object,Integer>[] getValueAppearancesCount(
> Feature[] features, int[] attrs ){
> HashMap<Object,Integer>[] value2NumAppearanceMaps = new
> HashMap[attrs.length];
>
> for (int i=0; i<attrs.length; i++){
> value2NumAppearanceMaps[i] = new HashMap<Object,Integer>();
> }
>
> Feature feat;
> Object value;
>
> for (int i=0; i<features.length; i++){
> feat = features[i];
>
> for (int attInd=0; attInd<attrs.length; attInd++){
> value = feat.getAttribute(attrs[attInd]);
>
> if (!value2NumAppearanceMaps[attInd].containsKey(value)){
> value2NumAppearanceMaps[attInd].put(value, 1);
> } else {
> value2NumAppearanceMaps[attInd].put(value,
> value2NumAppearanceMaps[attInd].get(value).intValue()+1);
> }
>
> }
>
> }
>
> return value2NumAppearanceMaps;
> }
>
> /**
> [EMAIL PROTECTED] features list of features to calculate the mode for
> [EMAIL PROTECTED] attr index of attribute to calculate the mode for
> [EMAIL PROTECTED] the mode
> */
> public static Object getModusForAttribute( Feature[] features, int attr ){
> HashMap<Object,Integer> map = new HashMap<Object,Integer>();
> Object modus = null;
> int maxNr = 0;
>
> if (features==null || features.length==0) return null;
>
> Feature[] featArray = features;
> Feature feat;
> Object value;
> int occ, numFeats = featArray.length;
>
> for (int i=0; i<numFeats; i++){
> feat = featArray[i];
>
> value = feat.getAttribute(attr);
>
> if (value.getClass().getName().equals(String.class.getName())){
> ((String)value).trim();
> }
>
> if ( map.containsKey(value) ){
> occ = ((Integer)map.get(value)).intValue();
> occ += 1;
> map.remove(value);
> } else {
> occ = 1;
> }
> map.put(value,new Integer(occ));
>
> if (occ > maxNr){
> maxNr = occ;
> modus = value;
> }
> }
>
> return modus;
> }
>
> /**
> * deletes the given features from the map. It thereby creates an
> EditTransaction that
> * enables the user to undo the deletion.
> [EMAIL PROTECTED] features features to be deleted
> [EMAIL PROTECTED] context curr. PlugIn context
> */
> public static void deleteFeatures( List<Feature> features, PlugInContext
> context ){
> Map layer2FeatList = LayerTools.getLayer2FeatureMap(features, context);
>
> Layer[] layersWithFeatures =
> (Layer[])layer2FeatList.keySet().toArray(new Layer[0]);
> Feature[] selFeatsOfLayer;
>
> for ( int i=0; i<layersWithFeatures.length; i++ ){
> EditTransaction edtr = new EditTransaction(new ArrayList(),
> "delete features", layersWithFeatures[i], true, true,
> context.getLayerViewPanel());
>
> selFeatsOfLayer =
> (Feature[])((List)layer2FeatList.get(layersWithFeatures[i])).toArray(new
> Feature[0]);
>
> for (int j=0; j<selFeatsOfLayer.length; j++){
> edtr.deleteFeature(selFeatsOfLayer[j]);
> }
>
> edtr.commit();
> edtr.clearEnvelopeCaches();
> }
> }
>
> /**
> * "deep copys" the given Feature
> [EMAIL PROTECTED] feat the feature to be copied
> [EMAIL PROTECTED] copy of the feature
> */
> public static Feature copyFeature( Feature feat ){
> Feature newFeat = new BasicFeature(feat.getSchema());
>
> int numAttr = feat.getSchema().getAttributeCount();
>
> for ( int i=0; i<numAttr; i++ ){
> newFeat.setAttribute( feat.getSchema().getAttributeName(i),
> feat.getAttribute(i) );
> }
>
> newFeat.setGeometry((Geometry)feat.getGeometry());
>
> return newFeat;
> }
>
> /**
> * "deep copys" the given Feature and thereby sets the given feature schema
> [EMAIL PROTECTED] feat the feature to be copied
> [EMAIL PROTECTED] newFs the new feature schema
> [EMAIL PROTECTED] copy of the feature
> */
> public static Feature copyFeatureAndSetFeatureSchema( Feature feat,
> FeatureSchema newFs ){
> feat = feat.clone(true);
> FeatureSchema fs = feat.getSchema();
>
> Feature newFeat = new BasicFeature(newFs);
> int numAttr = feat.getSchema().getAttributeCount();
>
> for ( int i=0; i<numAttr; i++ ){
> newFeat.setAttribute( fs.getAttributeName(i),
> feat.getAttribute(fs.getAttributeName(i)) );
> }
>
> newFeat.setGeometry((Geometry)feat.getGeometry());
>
> return newFeat;
> }
>
> public String getUniqueAttributeName(String attr){
> return FeatureCollectionTools.getUniqueAttributeName( this.fc, attr );
> }
>
> public static String getUniqueAttributeName(FeatureCollection fc, String
> attr){
> FeatureSchema fs = fc.getFeatureSchema();
> String newName = new String(attr);
> String suffix = "";
>
> for ( int i=2; FeatureCollectionTools.attributeExistsInSchema(fs,
> newName+suffix); i++ ){
> suffix = " ("+i+")";
> }
>
> return newName+suffix;
> }
>
> protected static boolean attributeExistsInSchema(FeatureSchema fs, String
> attr){
> try {
> int index = fs.getAttributeIndex(attr);
> return (index>=0);
> } catch (RuntimeException e) {
> return false;
> }
> }
>
> public PirolFeatureCollection addAttributeToFeatureCollection( String
> attr, AttributeType at, Object defaultVal ){
> if (this.fc != null)
> return FeatureCollectionTools.addAttributeToFeatureCollection(
> this.fc, attr, at, defaultVal, true );
> return null;
> }
>
> public static boolean isAttributeTypeNumeric( AttributeType at ){
> return ( at.equals(AttributeType.DOUBLE) ||
> at.equals(AttributeType.INTEGER) );
> }
>
> /**
> * Method to apply a given formula to the given, new attribute of the
> given featureCollection
> [EMAIL PROTECTED] oldFc old FeatureCollection that will be replaced by
> the new one
> [EMAIL PROTECTED] attrInfo information for the new attribute
> [EMAIL PROTECTED] formula the parsed formula
> [EMAIL PROTECTED] FeatureCollection containing the new attribute
> */
> public static PirolFeatureCollection applyFormulaToFeatureCollection(
> FeatureCollection oldFc, AttributeInfo attrInfo, FormulaValue formula,
> boolean clearOldFeatureCollection ){
>
> PirolFeatureCollection newFc =
> FeatureCollectionTools.addAttributeToFeatureCollection( oldFc, attrInfo,
> clearOldFeatureCollection );
>
> Feature[] features = (Feature[])newFc.getFeatures().toArray(new
> Feature[0]);
> Feature feat;
> int numFeats = features.length, attrInd =
> newFc.getFeatureSchema().getAttributeIndex(attrInfo.getUniqueAttributeName());
>
> for (int i=0; i<numFeats; i++){
> feat = features[i];
> feat.setAttribute(attrInd, new Double(formula.getValue(feat)));
>
> if (i%500 == 0)
> logger.printDebug("done: " + i);
> }
> return newFc;
> }
>
> public static PirolFeatureCollection addAttributeToFeatureCollection(
> FeatureCollection fc, AttributeInfo attrInfo ){
> return FeatureCollectionTools.addAttributeToFeatureCollection(fc,
> attrInfo.getUniqueAttributeName(), attrInfo.getAttributeType(),
> attrInfo.getNullValue(), true);
> }
>
> public static PirolFeatureCollection addAttributeToFeatureCollection(
> FeatureCollection fc, AttributeInfo attrInfo, boolean
> clearOldFeatureCollection ){
> return FeatureCollectionTools.addAttributeToFeatureCollection(fc,
> attrInfo.getUniqueAttributeName(), attrInfo.getAttributeType(),
> attrInfo.getNullValue(), 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...
> [EMAIL PROTECTED] fc the old feature collection
> [EMAIL PROTECTED] attr name of the new attribute
> [EMAIL PROTECTED] at type of the new attribute
> [EMAIL PROTECTED] defaultVal the initial value for the attribute, since
> we do not want NULL values in the attribute table
> [EMAIL PROTECTED] clearOldFeatureCollection if true the old feature
> collection will be erased to save RAM
> [EMAIL PROTECTED] new FeatureCollection with a new FeatureSchema
> including the new attribute
> */
> public static PirolFeatureCollection addAttributeToFeatureCollection(
> FeatureCollection fc, String attr, AttributeType at, Object defaultVal,
> boolean clearOldFeatureCollection ){
> FeatureSchema fs = (FeatureSchema)fc.getFeatureSchema().clone();
> fs.addAttribute(attr,at);
>
> MetaInformationHandler mih = new
> MetaInformationHandler(MetaInformationHandler.createPirolFeatureCollection(fc));
>
> PirolFeatureCollection newFc =
> MetaInformationHandler.createPirolFeatureCollection(new FeatureDataset(fs));
>
> if (mih.containsMetaInformation()){
> newFc.setMetaInformation(mih.getExistentMetaInformationMap());
> }
> mih = null;
>
> Feature feat, newFeat;
>
> if (at.equals(AttributeType.INTEGER)){
> if (Double.class.isInstance(defaultVal)){
> defaultVal = new Integer( ((Double)defaultVal).intValue() );
> }
> }
>
> Feature[] featArray = (Feature[])fc.getFeatures().toArray(new
> Feature[0]);
>
> if (clearOldFeatureCollection)
> fc.clear();
>
> int featuresDone = 0;
>
> for ( int i=featArray.length-1; i>=0; i--, featuresDone++ ){
> feat = featArray[i];
>
> newFeat =
> FeatureCollectionTools.copyFeatureAndSetFeatureSchema(feat,fs);
> newFeat.setAttribute(attr, defaultVal);
> newFc.add(newFeat);
>
> if (i%10000 == 0 && i!=0){
> featArray =
> (Feature[])FeatureCollectionTools.resizeArray(featArray, featArray.length -
> featuresDone);
> featuresDone = 0;
> if (i%50000 == 0){
> System.gc();
> }
> }
> }
>
> featArray = null;
>
> return newFc;
> }
>
> /**
> * 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...
> [EMAIL PROTECTED] fc the old feature collection
> [EMAIL PROTECTED] attr name of the new attribute
> [EMAIL PROTECTED] at type of the new attribute
> [EMAIL PROTECTED] defaultVal the initial value for the attribute, since
> we do not want NULL values in the attribute table
> [EMAIL PROTECTED] new FeatureCollection with a new FeatureSchema
> including the new attribute
> */
> public static PirolFeatureCollection addAttributeToFeatureCollection(
> FeatureCollection fc, String attr, AttributeType at, Object defaultVal ){
> return FeatureCollectionTools.addAttributeToFeatureCollection(fc,
> attr, at, defaultVal, true);
> }
>
> /**
> * Adds multiple attributes to the FeatureCollection
> [EMAIL PROTECTED] attributeInfos list containing the attributes (as
> AttributeInfo objects) to be added
> [EMAIL PROTECTED] a new FeatureCollection containing the old and the new
> attributes
> *
> [EMAIL PROTECTED] AttributeInfo
> */
> public PirolFeatureCollection addAttributesToFeatureCollection( List
> attributeInfos ){
> return
> FeatureCollectionTools.addAttributesToFeatureCollection(this.fc,
> attributeInfos);
> }
>
> /**
> * Adds multiple attributes to a FeatureCollection
> [EMAIL PROTECTED] fc the source feature collection
> [EMAIL PROTECTED] attributeInfos list containing the attributes (as
> AttributeInfo objects) to be added
> [EMAIL PROTECTED] a new FeatureCollection containing the old and the new
> attributes
> *
> [EMAIL PROTECTED] AttributeInfo
> */
> public static PirolFeatureCollection addAttributesToFeatureCollection(
> FeatureCollection fc, List<AttributeInfo> attributeInfos ){
> return FeatureCollectionTools.addAttributesToFeatureCollection(fc,
> (AttributeInfo[])attributeInfos.toArray(new AttributeInfo[0]));
> }
>
> public static PirolFeatureCollection addAttributesToFeatureCollection(
> FeatureCollection fc, AttributeInfo[] attributeInfos ){
> return FeatureCollectionTools.addAttributesToFeatureCollection(fc,
> attributeInfos, true);
> }
>
> /**
> * Adds multiple attributes to a FeatureCollection
> [EMAIL PROTECTED] fc the source feature collection
> [EMAIL PROTECTED] attributeInfos array containing the attributes to be
> added
> [EMAIL PROTECTED] clearOriginalFeatureCollection set true, if you want to
> save RAM by
> *clearing the original FeatureCollection, false if you still want to use
> it.
> [EMAIL PROTECTED] a new FeatureCollection containing the old and the new
> attributes
> */
> public static PirolFeatureCollection addAttributesToFeatureCollection(
> FeatureCollection fc, AttributeInfo[] attributeInfos, boolean
> clearOriginalFeatureCollection ){
> FeatureSchema fs = (FeatureSchema)fc.getFeatureSchema().clone();
>
> MetaInformationHandler mih = new
> MetaInformationHandler(MetaInformationHandler.createPirolFeatureCollection(fc));
>
>
> AttributeInfo attrInfo;
>
> for (int i=0; i<attributeInfos.length; i++){
> attrInfo = attributeInfos[i];
> fs.addAttribute(attrInfo.getUniqueAttributeName(),
> attrInfo.getAttributeType());
> }
>
> PirolFeatureCollection newFc =
> MetaInformationHandler.createPirolFeatureCollection(new FeatureDataset(fs));
>
> if (mih.containsMetaInformation()){
> newFc.setMetaInformation(mih.getExistentMetaInformationMap());
> }
> mih = null;
>
> Feature feat, newFeat;
>
> Feature[] featArray = (Feature[])fc.getFeatures().toArray(new
> Feature[0]);
>
> if (clearOriginalFeatureCollection)
> fc.clear();
>
> int featuresDone = 0;
>
> for ( int i=featArray.length-1; i>=0; i--, featuresDone++ ){
> feat = featArray[i];
>
> newFeat =
> FeatureCollectionTools.copyFeatureAndSetFeatureSchema(feat,fs);
>
>
> for (int j=0; j<attributeInfos.length; j++){
> attrInfo = attributeInfos[j];
> newFeat.setAttribute(attrInfo.getUniqueAttributeName(),
> attrInfo.getNullValue());
> }
>
> newFc.add(newFeat);
>
> if (i%10000 == 0 && i!=0){
> featArray =
> (Feature[])FeatureCollectionTools.resizeArray(featArray, featArray.length -
> featuresDone);
> featuresDone = 0;
> if (i%50000 == 0){
> System.gc();
> }
> logger.printDebug("adding attribute, features left to do " +
> i);
> }
> }
> featArray = null;
>
> return newFc;
> }
>
> /**
> * Reallocates an array with a new size, and copies the contents
> * of the old array to the new array.
> * @param oldArray the old array, to be reallocated.
> * @param newSize the new array size.
> * @return A new array with the same contents.
> */
> public static Object resizeArray (Object oldArray, int newSize) {
> int oldSize = java.lang.reflect.Array.getLength(oldArray);
> Class elementType = oldArray.getClass().getComponentType();
> Object newArray = java.lang.reflect.Array.newInstance(
> elementType,newSize);
> int preserveLength = Math.min(oldSize,newSize);
> if (preserveLength > 0)
> System.arraycopy (oldArray,0,newArray,0,preserveLength);
> return newArray;
> }
>
> public static double[] getMinMaxAttributeValue( Feature[] featArray,
> FeatureSchema fs, String attr ){
> double[] minmax = new double[]{ Double.MAX_VALUE, -Double.MAX_VALUE };
>
>
> if (fs.getAttributeType(attr) == AttributeType.INTEGER ||
> fs.getAttributeType(attr) == AttributeType.DOUBLE){
>
> Feature feat;
> double value;
>
> for ( int i=featArray.length-1; i>=0; i-- ){
> feat = featArray[i];
>
> if (feat.getAttribute(attr) != null){
> value =
> ObjectComparator.getDoubleValue(feat.getAttribute(attr));
>
> if (value<minmax[0]){
> minmax[0] = value;
> }
> if (value>minmax[1]){
> minmax[1] = value;
> }
> } else {
> FeatureCollectionTools.logger.printMinorError("skipped
> value (NULL), when checking min./max. values for Attribute " + attr);
> }
> }
> }
>
> return minmax;
> }
>
> public static double[] getMinMaxAttributeValue( FeatureCollection
> features, String attr ){
> return
> FeatureCollectionTools.getMinMaxAttributeValue(FeatureCollectionTools.FeatureCollection2FeatureArray(features),
> features.getFeatureSchema(), attr);
> }
>
>
> /**
> * Converts a given FeatureCollection into an array of Feature, that can -
> by far - be faster iterated.
> [EMAIL PROTECTED] fc the feature Collection
> [EMAIL PROTECTED] an array of the features of the feature collection
> */
> public static Feature[] FeatureCollection2FeatureArray( FeatureCollection
> fc ){
> return (Feature[])fc.getFeatures().toArray(new Feature[0]);
> }
>
> /**
> * Converts a given list of features into an array of Feature, that can -
> by far - be faster iterated.
> [EMAIL PROTECTED] features list of features
> [EMAIL PROTECTED] an array of the features of the feature list
> */
> public static Feature[] FeatureCollection2FeatureArray( List<Feature>
> features ){
> return (Feature[])features.toArray(new Feature[0]);
> }
> }
>
> -------------------------------------------------------------------------
> This SF.net email is sponsored by: Splunk Inc.
> Still grepping through log files to find problems? Stop.
> Now Search log events and configuration files using AJAX and a browser.
> Download your FREE copy of Splunk now >> http://get.splunk.com/
> _______________________________________________
> Jump-pilot-devel mailing list
> Jump-pilot-devel@lists.sourceforge.net
> https://lists.sourceforge.net/lists/listinfo/jump-pilot-devel
>
>
-------------------------------------------------------------------------
This SF.net email is sponsored by: Splunk Inc.
Still grepping through log files to find problems? Stop.
Now Search log events and configuration files using AJAX and a browser.
Download your FREE copy of Splunk now >> http://get.splunk.com/
_______________________________________________
Jump-pilot-devel mailing list
Jump-pilot-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/jump-pilot-devel
