Por que isso está acontecendo (estranheza com processamento e UnfoldingMaps)

rocksNwaves:

Como parte da Coursera classe UCSD Java, estamos a trabalhar com o Processamento e Unfolding bibliotecas Maps.

O curso fornece código inicial, que eu estou tentando expandir. Mas eu tive um problema.

No meu computador de trabalho, onde eu faço a maioria dos meus estudos, eu tenho um aplicativo muito bom começar. Decidi levá-la para casa para minha esposa para mostrar a ela, clonando o meu github repo para o meu laptop em casa.

Nenhum dos arquivos librar / JAR foram incluídos, então eu baixei-los diretamente de Processamento e páginas de download do desenvolvimento. O resultado foi um pesadelo. Erro após erro após erro. Presumo Coursera / UCSD usado versões antigas das bibliotecas, e as novas versões não são compatíveis com versões anteriores. Parece ruim, mas o que quer.

Em seguida, eu baixei todos os arquivos JAR a partir da visão Coursera. Os resultados são um pouco melhor, mas as coisas ainda são muito maluco. Ou seja, quando eu criar um UnfoldingMap()objeto, os parâmetros para localização dentro da janela, bem como o tamanho não fazer absolutamente nada.

1.) eu uso Processamento size()método de tamanho para cima ou para baixo a janela contendo, ele pode ser expandido o objecto de mapa para cima ou para baixo. Ele ignora totalmente os argumentos tamanho e localização do UnfoldingMap().

2.) O objeto do mapa é sempre empurrado para o canto inferior esquerdo da janela, não importa se de argumentos para a posição.

3.) O cinza background()Eu escolhi não mostrar ao redor do mapa, mas o próprio fundo é então cercado por um campo preto grande, que também escalas com os size()parâmetros.

Aqui está um 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:

A opção mais fácil seria usar um Processamento versão desatualizada que Unfolding ainda suportes como Desdobramento 0.9.6 (para processamento 2.2.1) .

Desde que você está usando o eclipse você pode realmente compilar uma mais recente trabalho versão poder para você. (Eu estou percebendo há algumas pequenas atualizações desde o ano passado, mas nenhuma liberação). Para atualizar via eclipse, você pode:

1. obter o repo (se você estiver em um sistema Unix (Linux / OSX) você já deve ter gitinstalado: git clone https://github.com/tillnagel/unfolding: desta forma você sempre pode puxar as últimas atualizações e reconstruir facilmente, caso contrário, o download zip, unzip, etc.)
2. importar o projeto no eclipse (via de importação existente Projeto)
3. Arraste build.xml do projeto no Ant Ver e selecionar um alvo para compilar. mainirá compilar todos eles, incluindo o invólucro Processing.

Se você quiser usar a linha de comando só:

1. Instale Ant (se isso não é já no seu sistema) e adicioná-lo à sua PATHvariável de ambiente (por exemplo, para verificar echo $PATHno Unix ou echo %PATH%no Windows e garantir a pasta onde vidas formiga estiver na lista, se não for adicionado)
2. clone / baixar o repo
3. executar formiga (por exemplo, ant unfolding_processingpara construir o Processamento de embalagem única ou simplesmente ant(cujo padrão é a mainmeta a construção de tudo)

Posso confirmar manualmente compilando a versão mais recente de obras github com o processamento 3.4

Fiz upload do invólucro Processamento aqui : Esperamos que você pode arrastar o arquivo .jar em cima de seu projeto eclipse.