root/lang/ruby/RubyESRIShape/IndexedPointList.cpp @ 3487

#include <stdio.h>
#include <malloc.h>

#define ESHP_INTERNAL
#include "Shape.h"

IndexedPointList::IndexedPointList()
{
        mPartIndexes = NULL;
        mPoints = NULL;
        mNParts = 0;
        mNPoints = 0;
}

IndexedPointList::~IndexedPointList()
{
        freeBuffers();
}

void IndexedPointList::allocBuffers()
{
        freeBuffers();

        mPartIndexes = (ESInt32*)malloc(sizeof(ESInt32) * mNParts);
        mPoints      = (ESPointEx*)malloc(sizeof(ESPointEx) * mNPoints);
}

void IndexedPointList::freeBuffers()
{
        if (mPartIndexes)
        {
                free(mPartIndexes);
                mPartIndexes = NULL;
        }

        if (mPoints)
        {
                free(mPoints);
                mPoints = NULL;
        }
}

void IndexedPointList::copyFrom(const IndexedPointList& aSrc)
{
        mNParts  = aSrc.mNParts;
        mNPoints = aSrc.mNPoints;
        allocBuffers();

        memcpy(mPoints     , aSrc.mPoints     , sizeof(ESPointEx) * mNPoints);
        memcpy(mPartIndexes, aSrc.mPartIndexes, sizeof(ESInt32  ) * mNParts);
        memcpy(mBounds     , aSrc.mBounds     , sizeof(ESDouble ) * 4);

        mZRange[0] = aSrc.mZRange[0];
        mZRange[1] = aSrc.mZRange[1];

        mMRange[0] = aSrc.mMRange[0];
        mMRange[1] = aSrc.mMRange[1];
}

es_error_t IndexedPointList::readFromMainFile(FILE* fp, ShpReadContext& rctx, int option)
{
        es_error_t rv = ESHP_OK;

        mBounds[0] = Shape::freadLittleDouble(fp);
        mBounds[1] = Shape::freadLittleDouble(fp);
        mBounds[2] = Shape::freadLittleDouble(fp);
        mBounds[3] = Shape::freadLittleDouble(fp);
        rctx.readSize              += 32;
        rctx.readRecordContentSize += 32;

        mNParts  = Shape::freadLittle32(fp);
        mNPoints = Shape::freadLittle32(fp);
        rctx.readSize              += 8;
        rctx.readRecordContentSize += 8;

        allocBuffers();

        ESInt32 i;
        for (i = 0;i < mNParts;i++)
        {
                mPartIndexes[i] = Shape::freadLittle32(fp);
                rctx.readSize              += 4;
                rctx.readRecordContentSize += 4;
        }

        for (i = 0;i < mNPoints;i++)
        {
                mPoints[i].x = Shape::freadLittleDouble(fp);
                mPoints[i].y = Shape::freadLittleDouble(fp);
                rctx.readSize              += 16;
                rctx.readRecordContentSize += 16;
        }

        if (option & SHPRECORD_WITH_Z)
        {
                // Z
                mZRange[0] = Shape::freadLittleDouble(fp);
                mZRange[1] = Shape::freadLittleDouble(fp);
                rctx.readSize              += 16;
                rctx.readRecordContentSize += 16;

                for (i = 0;i < mNPoints;i++)
                {
                        mPoints[i].z = Shape::freadLittleDouble(fp);
                        rctx.readSize              += 8;
                        rctx.readRecordContentSize += 8;
                }

                // Measure
                mMRange[0] = Shape::freadLittleDouble(fp);
                mMRange[1] = Shape::freadLittleDouble(fp);
                rctx.readSize              += 16;
                rctx.readRecordContentSize += 16;

                for (i = 0;i < mNPoints;i++)
                {
                        mPoints[i].m = Shape::freadLittleDouble(fp);
                        rctx.readSize              += 8;
                        rctx.readRecordContentSize += 8;
                }
        }

        return rv;
}

VALUE IndexedPointList::getPartAsRubyObj(int index)
{
        if (index < 0 || index >= mNParts)
                return Qnil;

        int len = (index == (mNParts-1)) ? mNPoints : mPartIndexes[index+1];
        len -= mPartIndexes[index];

        int start = mPartIndexes[index];

        VALUE arr = rb_ary_new2(len);
        for (int i = 0;i < len;i++)
        {
                ESPointEx& p = mPoints[start+i];
                ShpPoint* shp = new ShpPoint(p.x, p.y, p.z, p.m);
                rb_ary_push(arr, shp->toRubyObject());
        }

        return arr;
}