com.nextgis.maplib.datasource.GeoGeometry.java Source code

Introduction

Here is the source code for com.nextgis.maplib.datasource.GeoGeometry.java

Source

/******************************************************************************
 * Project:  NextGIS mobile
 * Purpose:  Mobile GIS for Android.
 * Author:   Dmitry Baryshnikov (aka Bishop), polimax@mail.ru
 ******************************************************************************
 *   Copyright (C) 2014 NextGIS
 *
 *    This program is free software: you can redistribute it and/or modify
 *    it under the terms of the GNU General Public License as published by
 *    the Free Software Foundation, either version 2 of the License, or
 *    (at your option) any later version.
 *
 *    This program is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *    GNU General Public License for more details.
 *
 *    You should have received a copy of the GNU General Public License
 *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 ****************************************************************************/
package com.nextgis.maplib.datasource;

import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

import static com.nextgis.maplib.util.GeoConstants.*;

public abstract class GeoGeometry implements Serializable {

    protected int mCRS;

    public static int typeFromJSON(String jsonType) {
        if (jsonType.equals(GEOJSON_TYPE_Point)) {
            return GTPoint;

        } else if (jsonType.equals(GEOJSON_TYPE_LineString)) {
            return GTLineString;

        } else if (jsonType.equals(GEOJSON_TYPE_Polygon)) {
            return GTPolygon;

        } else if (jsonType.equals(GEOJSON_TYPE_MultiPoint)) {
            return GTMultiPoint;

        } else if (jsonType.equals(GEOJSON_TYPE_MultiLineString)) {
            return GTMultiLineString;

        } else if (jsonType.equals(GEOJSON_TYPE_MultiPolygon)) {
            return GTMultiPolygon;

        } else if (jsonType.equals(GEOJSON_TYPE_GeometryCollection)) {
            return GTGeometryCollection;

        } else {
            return GTNone;
        }
    }

    public static GeoGeometry fromJson(JSONObject jsonObject) throws JSONException {
        String jsonType = jsonObject.getString(GEOJSON_TYPE);
        int type = typeFromJSON(jsonType);

        GeoGeometry output = null;
        switch (type) {
        case GTPoint:
            output = new GeoPoint();
            break;
        case GTLineString:
            output = new GeoLineString();
            break;
        case GTPolygon:
            output = new GeoPolygon();
            break;
        case GTMultiPoint:
            output = new GeoMultiPoint();
            break;
        case GTMultiLineString:
            output = new GeoMultiLineString();
            break;
        case GTMultiPolygon:
            output = new GeoMultiPolygon();
            break;
        case GTGeometryCollection:
            output = new GeoGeometryCollection();
        case GTNone:
        default:
            break;
        }

        switch (type) {
        case GTPoint:
        case GTLineString:
        case GTPolygon:
        case GTMultiPoint:
        case GTMultiLineString:
        case GTMultiPolygon:
            JSONArray coordinates = jsonObject.getJSONArray(GEOJSON_COORDINATES);
            output.setCoordinatesFromJSON(coordinates);
            break;
        case GTGeometryCollection:
            JSONArray jsonGeometries = jsonObject.getJSONArray(GEOJSON_GEOMETRIES);
            output.setCoordinatesFromJSON(jsonGeometries);
            break;
        case GTNone:
        default:
            break;
        }

        return output;
    }

    public boolean project(int toCrs) {
        return (mCRS == CRS_WGS84 && toCrs == CRS_WEB_MERCATOR || mCRS == CRS_WEB_MERCATOR && toCrs == CRS_WGS84)
                && rawProject(toCrs);
    }

    protected abstract boolean rawProject(int toCrs);

    public abstract GeoEnvelope getEnvelope();

    public void setCRS(int crs) {
        mCRS = crs;
    }

    public JSONObject toJSON() throws JSONException {
        JSONObject jsonOutObject = new JSONObject();
        jsonOutObject.put(GEOJSON_TYPE, typeToJSON());
        jsonOutObject.put(GEOJSON_COORDINATES, coordinatesToJSON());

        return jsonOutObject;
    }

    public String typeToJSON() {
        switch (getType()) {
        case GTPoint:
            return GEOJSON_TYPE_Point;
        case GTLineString:
            return GEOJSON_TYPE_LineString;
        case GTPolygon:
            return GEOJSON_TYPE_Polygon;
        case GTMultiPoint:
            return GEOJSON_TYPE_MultiPoint;
        case GTMultiLineString:
            return GEOJSON_TYPE_MultiLineString;
        case GTMultiPolygon:
            return GEOJSON_TYPE_MultiPolygon;
        case GTGeometryCollection:
            return GEOJSON_TYPE_GeometryCollection;
        case GTNone:
        default:
            return "";
        }
    }

    public abstract JSONArray coordinatesToJSON() throws JSONException, ClassCastException;

    public abstract int getType();

    public abstract void setCoordinatesFromJSON(JSONArray coordinates) throws JSONException;

    public byte[] toBlob() throws IOException {
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        ObjectOutputStream os = new ObjectOutputStream(out);
        os.writeObject(this);
        return out.toByteArray();
    }

    public static GeoGeometry fromBlob(byte[] raw) throws IOException, ClassNotFoundException {
        ByteArrayInputStream in = new ByteArrayInputStream(raw);
        ObjectInputStream is = new ObjectInputStream(in);
        return (GeoGeometry) is.readObject();
    }

    //public abstract String toWKT();

}