Pourquoi est-ce qui se passe (avec traitement et bizarrerie UnfoldingMaps)

rocksNwaves:

Dans le cadre de la classe Coursera UCSD Java, nous travaillons avec le traitement et dépliage bibliothèques cartes.

Le cours vous fournit un code de démarrage, que je suis en train de se développer. Mais je suis tombé sur un problème.

Sur mon ordinateur de travail, où je fais la plupart de mes études, j'ai une application vraiment sympa a commencé. J'ai décidé de prendre la maison à ma femme pour lui montrer, en clonant mon repo github à mon ordinateur portable à la maison.

Aucun des fichiers librar / JAR ont été inclus, alors je les ai téléchargés directement depuis le traitement et les pages de téléchargement de dépliage. Le résultat a été un véritable cauchemar. Erreur après erreur après erreur. Je suppose Coursera / UCSD utilisé les anciennes versions des bibliothèques, et les nouvelles versions ne sont pas rétrocompatibles. Semble merdique, mais peu importe.

Ensuite, je l' ai téléchargé tous les fichiers JAR de la vue de Coursera. Les résultats sont un peu mieux, mais les choses sont encore assez loufoque. A savoir, lorsque je crée un UnfoldingMap()objet, les paramètres pour l' emplacement de la fenêtre ainsi que la taille ne font absolument rien.

1.) J'utilise le traitement size()méthode pour la taille ou en bas de la fenêtre contenant, il redimensionne l'objet carte vers le haut ou vers le bas. Il ignore totalement les arguments de taille et l' emplacement UnfoldingMap().

2.) L'objet de la carte est toujours poussé à la partie inférieure gauche de la fenêtre, peu importe la position pour les arguments de it.

3.) Le gris que background()j'ai choisi ne montre sur la carte, mais l'arrière - plan lui - même est alors entouré d'un grand champ noir, que des échelles aussi avec les size()paramètres.

Voici un code:

package module3;

//Java utilities libraries
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

//Processing library
import processing.core.PApplet;

//Unfolding libraries
import de.fhpotsdam.unfolding.UnfoldingMap;
import de.fhpotsdam.unfolding.marker.Marker;
import de.fhpotsdam.unfolding.data.PointFeature;
import de.fhpotsdam.unfolding.marker.SimplePointMarker;
import de.fhpotsdam.unfolding.providers.Google;
import de.fhpotsdam.unfolding.providers.MBTilesMapProvider;
import de.fhpotsdam.unfolding.utils.MapUtils;

//Parsing library
import parsing.ParseFeed;

public class EarthquakeCityMap extends PApplet {

    // Less than this threshold is a light earthquake
    public static final float THRESHOLD_MODERATE = 5;
    // Less than this threshold is a minor earthquake
    public static final float THRESHOLD_LIGHT = 4;

    // This is where to find the local tiles, for working without an
        // Internet connection 
    public static String mbTilesString = "blankLight-1-3.mbtiles";

    // The map
    private UnfoldingMap map;

    //feed with magnitude 2.5+ Earthquakes
    private String earthquakesURLweek = "https://earthquake.usgs.gov/earthquakes/feed/v1.0/summary/2.5_week.atom";
        private String earthquakesURLday = "https://earthquake.usgs.gov/earthquakes/feed/v1.0/summary/2.5_day.atom";

    public void setup() {
            size(400, 400, "processing.opengl.PGraphics3D");
            background(99);

            map = new UnfoldingMap(this, 50, 50, 1100, 700, new Google.GoogleMapProvider());
        map.zoomToLevel(2);
        MapUtils.createDefaultEventDispatcher(this, map);   

        //List of markers to be added to map
        List<Marker> markers = new ArrayList<Marker>();

        //Use parser to collect properties for each earthquake
        //PointFeatures have a getLocation method
        List<PointFeature> earthquakes = ParseFeed.parseEarthquake(this, earthquakesURLweek);

            // for each earthqauke feature, create a custom marker and add it
            // to the list.
            for (PointFeature quake : earthquakes){
                Marker quakeMark = createMarker(quake);
                markers.add(quakeMark);
                Map<String, Object> properties = quakeMark.getProperties();
            }

        // Add the markers to the map so that they are displayed
        map.addMarkers(markers);
    }

        /**
         * A helper method to style markers based on features (magnitude, depth,
         * etc) of an earthquake.
         * @param feature A PointFeature object representing a single earthquake.
         * @return 
         */
    private SimplePointMarker createMarker(PointFeature feature){  

            // Create a new SimplePointMarker at the location given by the PointFeature
            SimplePointMarker marker = new SimplePointMarker(feature.getLocation(), feature.getProperties());

            Object magObj = feature.getProperty("magnitude");
            Object ageObj =  marker.getProperty("days ellapsed");
            float mag = Float.parseFloat(magObj.toString());
            int age = (int) ageObj;

            //Set processing color and alpha data, for setting marker colors 
            //below.
            int alpha = 255 - (age * 255 / 7);
        int yellow = color(255, 255, 0, alpha);
            int red = color(255, 0, 0, alpha);
            int green = color(0, 255, 0, alpha);

            // Style markers based on earthquake magnitude
            if (mag < THRESHOLD_LIGHT){
                marker.setColor(green);
            }
            if (mag >= THRESHOLD_LIGHT && mag < THRESHOLD_MODERATE){
                marker.setColor(yellow);
            }
            if (mag >= THRESHOLD_MODERATE){
                marker.setColor(red);
            }

            //set radius of marker based on quake magnitude
            float radius = (float) (mag * 3.5);
            marker.setStrokeColor(color(50,15));
            marker.setRadius(radius);

        return marker;
    }

    public void draw() {
        map.draw();
        addKey();
    }

George Profenza:

L'option la plus simple serait d' utiliser une version obsolète de traitement qui se poursuit toujours comme supports dépliage 0.9.6 (pour le traitement 2.2.1) .

Puisque vous utilisez Eclipse , vous pouvez compiler en fait une nouvelle version de travail pourrait pour vous. (Je remarque il y a quelques mises à jour mineures de l' année dernière, mais pas communiqué). Pour mettre à jour via Eclipse , vous pouvez:

1. obtenir le repo (si vous êtes sur un système Unix (Linux / OSX) que vous pourriez avoir déjà gitinstallé: git clone https://github.com/tillnagel/unfolding: cette façon , vous pouvez toujours tirer les dernières mises à jour et de reconstruire facilement, sinon zip télécharger, décompressez, etc.)
2. importer le projet Eclipse (via Importer un projet existant)
3. Faites glisser build.xml du projet dans la Ant Vue et sélectionnez une cible pour compiler. maincompilera tous , y compris l'emballage de traitement.

Si vous souhaitez utiliser uniquement la ligne de commande:

1. Installer Ant (si ce n'est pas déjà sur votre système) et l' ajouter à votre PATHvariable d'environnement (par exemple pour vérifier echo $PATHsur Unix ou echo %PATH%sous Windows et d' assurer le dossier dans lequel la vie des fourmis est répertorié, sinon ajouté il)
2. clone / télécharger le repo
3. ant run (par exemple ant unfolding_processingpour construire l'emballage traitement uniquement ou simplement ant(qui par défaut du maintout bâtiment cible)

Je peux confirmer la compilation manuellement la dernière version fonctionne GitHub avec le traitement 3.4

J'ai téléchargé l'emballage de traitement ici : Espérons que vous pouvez faire glisser le fichier .jar sur le dessus de votre projet Eclipse.