Application: gvSIG desktop

package org.gvsig.sqlite.dal.geopackage;

import java.io.IOException;

import java.nio.ByteOrder;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.primitive.Envelope;

import static org.gvsig.sqlite.dal.geopackage.GeopackageUtils.GEOMETRY_MAGIC_NUMBER;

import static org.gvsig.sqlite.dal.geopackage.GeopackageUtils.GEOMETRY_VERSION_1;

import org.sqlite.SQLiteConnection;

/*

 * Based on portions of code from GeoPackage Libraries 

 * of National Geospatial-Intelligence Agency (NGA)

 * https://github.com/ngageoint/geopackage-java

 */

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("UseSpecificCatch")

public class GeopackageGeometryBuilder {

    private int srsId;

    private Envelope envelope;

    private Geometry geometry;

    @SuppressWarnings("FieldMayBeFinal")

    private ByteOrder byteOrder;

    private boolean extended;

    private boolean empty;

    /*friend*/ GeopackageGeometryBuilder() {

        this.byteOrder = GeopackageUtils.DEFAULT_BYTE_ORDER;

    }

    public void setGeometry(SQLiteConnection conn, Geometry geometry) {

        this.geometry = geometry;

        this.srsId = GeopackageUtils.getSrsId(conn, geometry);

        if( this.geometry == null || this.geometry.isEmpty()) {

            this.envelope = null;

            this.extended = false;

            this.empty = true;

        } else {

            this.empty = false;

            this.extended = false;

            this.envelope = this.geometry.getEnvelope();

        }

    }

    public byte[] build() {

        try {

            ByteWriter writer = new ByteWriter();

            // Write GP as the 2 byte magic number

            writer.writeString(GEOMETRY_MAGIC_NUMBER);

            // Write a byte as the version, value of 0 = version 1

            writer.writeByte(GEOMETRY_VERSION_1);

            // Build and write a flags byte

            byte flags = buildFlagsByte();

            writer.writeByte(flags);

            writer.setByteOrder(byteOrder);

            // Write the 4 byte srs id int

            writer.writeInt(srsId);

            // Write the envelope

            writeEnvelope(writer);

            // Save off where the WKB bytes start

            int wkbGeometryIndex = writer.size();

            // Write the Well-Known Binary Geometry if not marked as empty

            if (!empty) {

                byte[] wkb = geometry.convertToWKB();

                writer.writeBytes(wkb);

            }

            // Get the bytes

            byte[] bytes = writer.getBytes();

            // Close the writer

            writer.close();

            return bytes;

        } catch (Throwable ex) {

            throw new RuntimeException("Can't build geometry bytes", ex);

        }

    }

    /**

     * Build the flags byte from the flag values

     *

     * @return envelope indicator

     */

    private byte buildFlagsByte() {

        byte flag = 0;

        // Add the binary type to bit 5, 0 for standard and 1 for extended

        int binaryType = extended ? 1 : 0;

        flag += (binaryType << 5);

        // Add the empty geometry flag to bit 4, 0 for non-empty and 1 for

        // empty

        int emptyValue = empty ? 1 : 0;

        flag += (emptyValue << 4);

        // Add the envelope contents indicator code (3-bit unsigned integer to

        // bits 3, 2, and 1)

        int envelopeIndicator = envelope == null ? 0 : getIndicator(envelope);

        flag += (envelopeIndicator << 1);

        // Add the byte order to bit 0, 0 for Big Endian and 1 for Little

        // Endian

        int byteOrderValue = (byteOrder == ByteOrder.BIG_ENDIAN) ? 0 : 1;

        flag += byteOrderValue;

        return flag;

    }

    /**

     * Get the envelope flag indicator

     *

     * 1 for xy, 2 for xyz, 3 for xym, 4 for xyzm (null would be 0)

     *

     * @param envelope geometry envelope

     *

     * @return indicator

     */

    public static int getIndicator(Envelope envelope) {

        int indicator = 1;

        if (envelope.hasZ()) {

            indicator++;

        }

        if (envelope.hasM()) {

            indicator += 2;

        }

        return indicator;

    }

    /**

     * Write the envelope bytes

     *

     * @param writer byte writer

     * @throws IOException

     */

    private void writeEnvelope(ByteWriter writer) throws IOException {

        if (envelope != null) {

            // Write x and y values

            writer.writeDouble(envelope.getMinimum(Geometry.DIMENSIONS.X));

            writer.writeDouble(envelope.getMaximum(Geometry.DIMENSIONS.X));

            writer.writeDouble(envelope.getMinimum(Geometry.DIMENSIONS.Y));

            writer.writeDouble(envelope.getMaximum(Geometry.DIMENSIONS.Y));

            // Write z values

            if (envelope.hasZ()) {

                writer.writeDouble(envelope.getMinimum(Geometry.DIMENSIONS.Z));

                writer.writeDouble(envelope.getMaximum(Geometry.DIMENSIONS.Z));

            }

//            // Write m values

//            if (envelope.hasM()) {

//                writer.writeDouble(envelope.getMinM());

//                writer.writeDouble(envelope.getMaxM());

//            }

        }

    }

}