¿Por qué sucede esto (con extrañeza Procesamiento y UnfoldingMaps)

rocksNwaves:

Como parte de la UCSD Coursera clase Java, estamos trabajando con el procesamiento y despliegue de bibliotecas Mapas.

El curso le proporciona el código de arranque, lo que estoy tratando de expandirse. Pero me encontré con un problema.

En mi equipo de trabajo, donde hago la mayor parte de mis estudios, tengo una muy buena aplicación comenzó. Decidí llevarlo a casa para mi esposa para mostrar ella, mediante la clonación de mi repo github a mi ordenador portátil en casa.

Se incluyó ninguno de los archivos del librar / JAR, así que les descargado directamente de procesamiento y de Despliegue páginas de descarga. El resultado fue una pesadilla. De error después de un error tras otro. Asumo Coursera / UCSD utiliza versiones antiguas de las bibliotecas, y las nuevas versiones no son compatibles hacia atrás. Parece malo, pero lo que sea.

A continuación, he descargado todos los archivos JAR de la vista Coursera. Los resultados son un poco mejor, pero las cosas son todavía bastante loco. Es decir, cuando se crea un UnfoldingMap()objeto, los parámetros para la localización dentro de la ventana, así como el tamaño no hacen absolutamente nada.

1.) utilizo Procesamiento size()método para tamaño arriba o hacia abajo la ventana que contiene, se escala el objeto de mapa arriba o hacia abajo. Se ignora totalmente los argumentos de tamaño y ubicación de UnfoldingMap().

2.) El objeto de mapa siempre es empujado a la esquina inferior izquierda de la ventana, sin importar sus argumentos para la posición.

3.) El gris background()he elegido qué durante todo el mapa, pero el fondo en sí es entonces rodeado por un campo grande y negro, que también las escalas con los size()parámetros.

Aquí hay un código:

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:

La opción más fácil sería utilizar una versión obsoleta de procesamiento que sigue despliegue soportes como el despliegue 0.9.6 (para el Procesamiento 2.2.1) .

Dado que está utilizando Eclipse en realidad se puede compilar una obra nueva versión podría para usted. (Estoy notando que hay algunas actualizaciones menores desde el año pasado, pero no se ha liberado). Para actualizar a través de Eclipse se puede:

1. obtener la cesión temporal (si se encuentra en un sistema Unix (Linux / OSX) es posible que ya haya gitinstalado: git clone https://github.com/tillnagel/unfolding: de esta manera siempre se puede tirar de las últimas actualizaciones y reconstruir fácilmente, de lo contrario descarga zip, descomprimir, etc.)
2. importar el proyecto en Eclipse (a través de la importación vigentes Proyecto)
3. Arrastre build.xml del proyecto en el Ant Ver y seleccione un destino para compilar. maincompilará todos ellos incluyendo la envoltura de procesamiento.

Si desea utilizar la línea de comandos solamente:

1. Instalar Hormiga (si es que no está ya en su sistema) y agregarlo a la PATHvariable de entorno (por ejemplo, para comprobar echo $PATHen Unix o echo %PATH%en Windows y garantizar la carpeta en los que figura hormiga vive, si no se añade)
2. clon / descargar el repositorio
3. ejecutar hormigas (por ejemplo, ant unfolding_processingpara construir el procesamiento envoltura única o simplemente ant(que por defecto es la mainconstrucción de todo lo objetivo)

Puedo confirmar manualmente la compilación de la versión más reciente de las obras de GitHub con el procesamiento de 3.4

He subido la envoltura Procesamiento aquí : Esperemos que se puede arrastrar el archivo .jar en la parte superior de su proyecto eclipse.