Warum ist das passiert (Fremdheit mit Verarbeitung und UnfoldingMaps)

rocksNwaves:

Im Rahmen der Coursera UCSD Java-Klasse, sind wir mit der Verarbeitung arbeiten und Karten Bibliotheken Entfalten.

Der Kurs liefert Sie Starter-Code, die ich zu erweitern versuchen. Aber ich lief in ein Problem.

Auf meinem Computer, wo ich die meisten meines Studiums zu tun, habe ich eine sehr schöne App gestartet. Ich beschloss, es nach Hause zu meiner Frau zu nehmen, sie zu zeigen, von meinem GitHub Repo zu mir nach Hause Laptop klonen.

Keiner der librar / JAR-Dateien enthalten war, so dass ich sie direkt von der Verarbeitung heruntergeladen und Seiten-Download des Ausklappen. Das Ergebnis war ein Alptraum. Fehler nach Fehler nach Fehler. Ich gehe davon aus Coursera / UCSD alten Versionen der Bibliotheken verwendet und die neuen Versionen sind nicht abwärtskompatibel. Scheint beschissen, aber was auch immer.

Als nächstes Ich habe die alle JAR - Dateien aus dem Coursera Sicht. Die Ergebnisse sind etwas besser, aber die Dinge sind immer noch ziemlich verrückt. Das heißt, wenn ich ein erstellen UnfoldingMap()Objekt, die Parameter für die Position innerhalb des Fensters sowie Größe absolut nichts tun.

1.) verwende ich size()Verarbeitungsmethode Größe nach oben oder unten enthält die Fenster skaliert er das Kartenobjekt nach oben oder unten. Es ignoriert völlig die Größe und Lage Argumente UnfoldingMap().

2.) Das Kartenobjekt wird immer auf die linke untere Ecke des Fensters geschoben, nein, es Argumente für die Position wichtig.

3.) Die grau background()ich gewählt habe , tut zeigen , um die Karte, aber der Hintergrund selbst wird dann von einem großen schwarzen Feld umgibt, das auch Skalen mit den size()Parametern.

Hier ist ein 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:

Die einfachste Möglichkeit wäre, eine veraltete Version Verarbeitung zu verwenden , die unterstützt Entfalten immer noch wie 0.9.6 Ausklappen (für die Verarbeitung 2.2.1) .

Da Sie Eclipse verwenden können Sie tatsächlich eine neuere Version funktionieren könnte für Sie zusammenstellen . (Ich bin zu bemerken , es gibt ein paar sind kleinere Updates aus dem letzten Jahr, aber keine Freigabe). So aktualisieren Sie über Eclipse können Sie:

1. erhalten die repo (wenn Sie auf einem Unix - System (Linux / OSX) sind vielleicht Sie bereits gitinstalliert: git clone https://github.com/tillnagel/unfolding: So finden Sie immer die neuesten Updates ziehen und wieder aufbauen leicht, sonst download zip, unzip, etc.)
2. Importieren Sie das Projekt in Eclipse (via Import Vorhandenes Projekt)
3. Ziehen build.xml aus dem Projekt in die Ant - Ansicht und wählen Sie ein Ziel zu kompilieren. mainwerden alle von ihnen , einschließlich der Verarbeitung Wrapper kompilieren.

Wenn Sie nur Befehlszeile verwenden:

1. Installieren Sie Ant (wenn das nicht bereits auf Ihrem System) , und fügen Sie Ihre PATHUmgebungsvariablen (zB zu prüfen , echo $PATHauf Unix oder echo %PATH%Windows und sorgt für die Ordner , in dem ant Leben aufgeführt ist , wenn es nicht hinzugefügt)
2. Klon / laden Sie die repo
3. laufen ant (zB ant unfolding_processingdie Verarbeitung nur Wrapper oder einfach zu bauen ant(was standardmäßig das mainZiel Gebäude alles)

Ich kann manuell die neueste Version von Github Werken Kompilieren bestätigen mit der Verarbeitung 3.4

Ich habe die Verarbeitung Wrapper hochgeladen hier : Hoffentlich Sie die .jar - Datei auf Ihrem Eclipse - Projekt ziehen.