source: other-projects/tipple-android/tipple-ar/tipple-standalone-hpg/src/org/greenstone/android/tipple/base/TipLocation.java@ 26528

package org.greenstone.android.tipple.base;

import java.util.List;
import java.util.HashMap;

import android.graphics.Bitmap;
import android.graphics.Color;
import android.graphics.drawable.Drawable;
import android.location.Location;

public class TipLocation {

    // Text and/or Audio associated with (Latitude,Longitude) location with radius
    // with the ability to project onto a screen

    static final float SCREEN_Z = -700; // the distance of the screen from the camera
    static final float EARTH_RADIUS = 6371000;
    static final float INVISIBLE_SCALE = -1;

    private double latitude_;
    private double longitude_;
    private double altitude_;

    private double radiusInKM_;
    // private double avgRadLatLong_;

    private float distance_; // the distance in meters from the camera

    private float screen_x_; // the x position on the screen in pixels
    private float screen_y_; // the y position on the screen in pixels
    private float screen_scale_; // the scale of the marker to draw on the screen (1/distance)

    float marker_hit_x_; // the centre of the marker in screen coordinates
    float marker_hit_y_;
    float marker_hit_radius_; // the radius of the marker (approximated by a circle)

    private String title_;
    private String text_;
    private String tts_text_;
    private String title_tts_;

    private Bitmap marker_bitmap_;
    private Drawable marker_drawable_;

    private int colour_fill_;
    private int colour_outline_;

    private String audioFilename_;
    private List<String> audioPaths_;

    protected String id_;

    public TipLocation(HashMap<String, String> hashmap) {
        latitude_ = Double.parseDouble(hashmap.get("latitude"));
        longitude_ = Double.parseDouble(hashmap.get("longitude"));
        altitude_ = hashmap.containsKey("altitude") ? Double.parseDouble(hashmap.get("altitude"))
                : 0;
        radiusInKM_ = Double.parseDouble(hashmap.get("radius"));

        title_ = hashmap.get("title");
        text_ = hashmap.get("text");
        tts_text_ = (hashmap.containsKey("tts")) ? hashmap.get("tts") : null;
        title_tts_ = (hashmap.containsKey("tts_title")) ? hashmap.get("tts_title") : null;

        marker_bitmap_ = Global.getBitmap(hashmap.get("marker_type"));
        marker_drawable_ = Global.getDrawable(hashmap.get("marker_type"));

        try {
            colour_fill_ = Color.parseColor(hashmap.get("colour_fill"));
        } catch (Exception ex) {
            colour_fill_ = Color.BLUE;
        }
        try {
            colour_outline_ = Color.parseColor(hashmap.get("colour_outline"));
        } catch (Exception ex) {
            colour_outline_ = Color.BLUE;
        }

        audioFilename_ = hashmap.get("audio");

        // Consolidate whitespace
        title_ = title_.replaceAll("^\\s+", "");
        title_ = title_.replaceAll("\\s+$", "");
        title_ = title_.replaceAll("\\s+", " ");

        if (text_ != null) {
            text_ = text_.replaceAll("^\\s+", "");
            text_ = text_.replaceAll("\\s+$", "");
            text_ = text_.replaceAll("\\s+", " ");
        }

        id_ = title_.replaceAll("/\\s+/", "-");
    }

    public void setAltitude(double x) {
        altitude_ = x;
    }

    public void setTitle(String x) {
        title_ = x;
    }

    public int getColourFill() {
        return colour_fill_;
    }

    public int getColourOutline() {
        return colour_outline_;
    }

    public boolean isVisible() {
        return screen_scale_ != INVISIBLE_SCALE;
    }

    public double getLatitude() {
        return latitude_;
    }

    public double getLongitude() {
        return longitude_;
    }

    public double getAltitude() {
        return altitude_;
    }

    public float getDistance() {
        return distance_;
    }

    public float getScreenX() {
        return screen_x_;
    }

    public float getScreenY() {
        return screen_y_;
    }

    /**
     * The scale factor of the location's marker. When the location is 1 metre from the camera the
     * scale factor is 1.
     */
    public float getScreenScale() {
        return screen_scale_;
    }

    public void setHitCircle(float x, float y, float r) {
        marker_hit_x_ = x;
        marker_hit_y_ = y;
        marker_hit_radius_ = r;
    }

    public boolean hits(float x, float y) {
        float dX = marker_hit_x_ - x;
        float dY = marker_hit_y_ - y;
        float distSquared = dX * dX + dY * dY;
        
        float radSquared = marker_hit_radius_ * marker_hit_radius_;

        return distSquared <= radSquared;
    }

    public double getRadiusKM() {
        return radiusInKM_;
    }

    public String getText() {
        return text_;
    }

    public String getTTSText() {
        return (tts_text_ != null) ? tts_text_ : text_;
    }

    public String getTitle() {
        return title_;
    }

    public String getTitleTTS() {
        return (title_tts_ != null) ? title_tts_ : title_;
    }

    public String getID() {
        return id_;
    }

    public List<String> getAudio() {
        return audioPaths_;
    }

    public String getAudioFilename() {
        return audioFilename_;
    }

    public Bitmap getMarkerBitmap() {
        return marker_bitmap_;
    }

    public Drawable getMarkerDrawable() {
        return marker_drawable_;
    }

    public void projectToScreen(Location cameraLocation, float[] rotationMatrix) {
        float[] onWorldAxes = new float[4];
        float[] onPhoneAxes;

        calcDifference(cameraLocation, onWorldAxes);

        onPhoneAxes = SensorFusion.getInstance().worldToPhone(onWorldAxes);

        distance_ = (float) Math.sqrt(onPhoneAxes[0] * onPhoneAxes[0] + onPhoneAxes[1]
                * onPhoneAxes[1] + onPhoneAxes[2] * onPhoneAxes[2]);

        float scalingFactor = SCREEN_Z / onPhoneAxes[2];
        float projectedX = onPhoneAxes[0] * scalingFactor;
        float projectedY = onPhoneAxes[1] * scalingFactor;

        screen_x_ = 400 - projectedY;
        screen_y_ = 240 - projectedX;
        if (onPhoneAxes[2] < 0) {
            // in front of camera
            screen_scale_ = 1 / distance_;
        } else {
            // behind camera, so use invisible radius
            screen_scale_ = INVISIBLE_SCALE;
        }
    }

    private void calcDifference(Location origin, float[] result) {
        // Uses trigonometry to calculate the location of the given point in
        // terms of the XYZ axes centred at the origin.
        // A = longitude, B = latitude, O = origin, P = point, D = difference
        double sinDA = Math.sin(Math.toRadians(longitude_ - origin.getLongitude()));
        double cosDA = Math.cos(Math.toRadians(longitude_ - origin.getLongitude()));
        double sinPB = Math.sin(Math.toRadians(latitude_));
        double cosPB = Math.cos(Math.toRadians(latitude_));
        double sinOB = Math.sin(Math.toRadians(origin.getLatitude()));
        double cosOB = Math.cos(Math.toRadians(origin.getLatitude()));
        double r = EARTH_RADIUS + origin.getAltitude() + altitude_;

        double x = r * cosPB * sinDA;
        double y = r * (sinPB * cosOB - cosDA * cosPB * sinOB);
        double z = r * (cosDA * cosPB * cosOB + sinPB * sinOB);

        result[0] = (float) x;
        result[1] = (float) y;
        result[2] = (float) (z - (EARTH_RADIUS + origin.getAltitude()));
        result[3] = 1;
    }
}