TWKBWriter.ExtendedPrecisionWriter Class Reference

Inheritance diagram for TWKBWriter.ExtendedPrecisionWriter:

Collaboration diagram for TWKBWriter.ExtendedPrecisionWriter:

Public Member Functions
PrecisionWriter	calculate (final Coordinate[] coordinates, final int maxPrecision)
void	writeExtendedPrecision (final DataOutput output) throws IOException
void	writePoint (final Coordinate coordinate, final DataOutput output) throws IOException
void	writePointArray (final Coordinate[] coordinates, final DataOutput output) throws IOException

Protected Member Functions
void	checkCoordinate (final Coordinate c)
void	finalize (final int maxPrecision)

Protected Attributes
double	precisionMultiplier = 0

Private Attributes
boolean	hasZ = false
int	zPrecision = TWKBUtils.MIN_EXTENDED_PRECISION
double	zPrecisionMultiplier = 0
boolean	hasM = false
int	mPrecision = TWKBUtils.MIN_EXTENDED_PRECISION
double	mPrecisionMultiplier = 0

Member Function Documentation

calculate()

PrecisionWriter calculate	(	final Coordinate []	coordinates,
		final int	maxPrecision
	)

References TWKBWriter.PrecisionWriter.calculate().

Referenced by TWKBWriter.write().

                                                                                             {
      hasZ = !Double.isNaN(coordinates[0].getZ());
      hasM = !Double.isNaN(coordinates[0].getM());
      super.calculate(coordinates, maxPrecision);
      return this;
    }

checkCoordinate()

void checkCoordinate ( final Coordinate  c )

protected

References Coordinate.getM(), and Coordinate.getZ().

                                                       {
      super.checkCoordinate(c);
      if (hasZ) {
        final BigDecimal zCoord = new BigDecimal(Double.toString(c.getZ())).stripTrailingZeros();
        zPrecision = Math.max(zCoord.scale(), zPrecision);
      }
      if (hasM) {
        final BigDecimal mCoord = new BigDecimal(Double.toString(c.getM())).stripTrailingZeros();
        mPrecision = Math.max(mCoord.scale(), mPrecision);
      }
    }

finalize()

void finalize ( final int  maxPrecision )

protected

References TWKBUtils.MAX_EXTENDED_PRECISION.

                                                    {
      super.finalize(maxPrecision);
      if (hasZ) {
        zPrecision = Math.min(TWKBUtils.MAX_EXTENDED_PRECISION, zPrecision);
        zPrecisionMultiplier = Math.pow(10, zPrecision);
      }
      if (hasM) {
        mPrecision = Math.min(TWKBUtils.MAX_EXTENDED_PRECISION, mPrecision);
        mPrecisionMultiplier = Math.pow(10, mPrecision);
      }
    }

writeExtendedPrecision()

void writeExtendedPrecision

(

final DataOutput

output

)

throws IOException

References TWKBUtils.zigZagEncode().

                                                                                   {
      byte extendedDimensions = 0;
      if (hasZ) {
        extendedDimensions |= 0x1;
        extendedDimensions |= TWKBUtils.zigZagEncode(zPrecision) << 2;
      }
      if (hasM) {
        extendedDimensions |= 0x2;
        extendedDimensions |= TWKBUtils.zigZagEncode(mPrecision) << 5;
      }
      output.writeByte(extendedDimensions);
    }

writePoint()

void writePoint	(	final Coordinate	coordinate,
		final DataOutput	output
	)		throws IOException

                           {
      super.writePoint(coordinate, output);
      if (hasZ) {
        Varint.writeSignedVarLong(Math.round(coordinate.getZ() * zPrecisionMultiplier), output);
      }
      if (hasM) {
        Varint.writeSignedVarLong(Math.round(coordinate.getM() * mPrecisionMultiplier), output);
      }
    }

writePointArray()

void writePointArray	(	final Coordinate []	coordinates,
		final DataOutput	output
	)		throws IOException

References TWKBWriter.PrecisionWriter.precisionMultiplier.

                           {
      long lastX = 0;
      long lastY = 0;
      long lastZ = 0;
      long lastM = 0;
      Varint.writeUnsignedVarInt(coordinates.length, output);
      for (final Coordinate c : coordinates) {
        final long x = Math.round(c.getX() * precisionMultiplier);
        final long y = Math.round(c.getY() * precisionMultiplier);
        Varint.writeSignedVarLong(x - lastX, output);
        Varint.writeSignedVarLong(y - lastY, output);
        lastX = x;
        lastY = y;
        if (hasZ) {
          final long z = Math.round(c.getZ() * zPrecisionMultiplier);
          Varint.writeSignedVarLong(z - lastZ, output);
          lastZ = z;
        }
        if (hasM) {
          final long m = Math.round(c.getZ() * mPrecisionMultiplier);
          Varint.writeSignedVarLong(m - lastM, output);
          lastM = m;
        }
      }
    }

Member Data Documentation

hasM

boolean hasM = false

private

hasZ

boolean hasZ = false

private

mPrecision

int mPrecision = TWKBUtils.MIN_EXTENDED_PRECISION

private

mPrecisionMultiplier

double mPrecisionMultiplier = 0

private

precisionMultiplier

double precisionMultiplier = 0

protectedinherited

Referenced by TWKBWriter.PrecisionWriter.writePoint(), TWKBWriter.PrecisionWriter.writePointArray(), and TWKBWriter.ExtendedPrecisionWriter.writePointArray().

zPrecision

int zPrecision = TWKBUtils.MIN_EXTENDED_PRECISION

private

zPrecisionMultiplier

double zPrecisionMultiplier = 0

private