应该是作为对象传递给MyDataStream流(argv[1]）的输入数据文件的格式

我正在使用"libspatialindex"库来创建R-树索引。我的数据是二维的，具有以下值：

 (1,  (1,5)),
 (19, (6,8)),
 (20, (3,8)),
 (4,  (1,9)).

数据描述为：

1 is a data point and it is present in the interval (1,5)
19 is a data point and it is present in the interval (6,8)
20 is a data point and it is present in the interval (3,8)
4 is a data point and it is present in the interval (1,9)

我正在尝试将上述数据批量加载到R-Tree中。为此，我使用了libspatialindex中的以下测试代码。然而，我不知道作为对象传递到*MyDataStream流（argv[1]）的输入数据文件的格式应该是什么*

我使用的测试代码是：

// Copyright (c) 2002, Marios Hadjieleftheriou
// include library header file.
#include <spatialindex/SpatialIndex.h>
using namespace SpatialIndex;
#define INSERT 1
#define DELETE 0
#define QUERY 2
class MyDataStream : public IDataStream
{
public:
    MyDataStream(std::string inputFile) : m_pNext(0)
    {
        m_fin.open(inputFile.c_str());
        if (! m_fin)
            throw Tools::IllegalArgumentException("Input file not found.");
        readNextEntry();
    }
    virtual ~MyDataStream()
    {
        if (m_pNext != 0) delete m_pNext;
    }
    virtual IData* getNext()
    {
        if (m_pNext == 0) return 0;
        RTree::Data* ret = m_pNext;
        m_pNext = 0;
        readNextEntry();
        return ret;
    }
    virtual bool hasNext()
    {
        return (m_pNext != 0);
    }
    virtual uint32_t size()
    {
        throw Tools::NotSupportedException("Operation not supported.");
    }
    virtual void rewind()
    {
        if (m_pNext != 0)
        {
            delete m_pNext;
            m_pNext = 0;
        }
        m_fin.seekg(0, std::ios::beg);
        readNextEntry();
    }
    void readNextEntry()
    {
        id_type id;
        uint32_t op;
        double low[2], high[2];
        m_fin >> op >> id >> low[0] >> low[1] >> high[0] >> high[1];
        if (m_fin.good())
        {
            if (op != INSERT)
                throw Tools::IllegalArgumentException(
                    "The data input should contain insertions only."
                );
            Region r(low, high, 2);
            m_pNext = new RTree::Data(sizeof(double), reinterpret_cast<byte*>(low), r, id);
                // Associate a bogus data array with every entry for testing purposes.
                // Once the data array is given to RTRee:Data a local copy will be created.
                // Hence, the input data array can be deleted after this operation if not
                // needed anymore.
        }
    }
    std::ifstream m_fin;
    RTree::Data* m_pNext;
};
int main(int argc, char** argv)
{
    try
    {
        if (argc != 5)
        {
            std::cerr << "Usage: " << argv[0] << " input_file tree_file capacity utilization." << std::endl;
            return -1;
        }
        std::string baseName = argv[2];
        double utilization = atof(argv[4]);
        IStorageManager* diskfile = StorageManager::createNewDiskStorageManager(baseName, 4096);
            // Create a new storage manager with the provided base name and a 4K page size.
        StorageManager::IBuffer* file = StorageManager::createNewRandomEvictionsBuffer(*diskfile, 10, false);
            // applies a main memory random buffer on top of the persistent storage manager
            // (LRU buffer, etc can be created the same way).
        MyDataStream stream(argv[1]);
        // Create and bulk load a new RTree with dimensionality 2, using "file" as
        // the StorageManager and the RSTAR splitting policy.
        id_type indexIdentifier;
        ISpatialIndex* tree = RTree::createAndBulkLoadNewRTree(
            RTree::BLM_STR, stream, *file, utilization, atoi(argv[3]), atoi(argv[3]), 2, SpatialIndex::RTree::RV_RSTAR, indexIdentifier);
        std::cerr << *tree;
        std::cerr << "Buffer hits: " << file->getHits() << std::endl;
        std::cerr << "Index ID: " << indexIdentifier << std::endl;
        bool ret = tree->isIndexValid();
        if (ret == false) std::cerr << "ERROR: Structure is invalid!" << std::endl;
        else std::cerr << "The stucture seems O.K." << std::endl;
        delete tree;
        delete file;
        delete diskfile;
            // delete the buffer first, then the storage manager
            // (otherwise the the buffer will fail trying to write the dirty entries).
    }
    catch (Tools::Exception& e)
    {
        std::cerr << "******ERROR******" << std::endl;
        std::string s = e.what();
        std::cerr << s << std::endl;
        return -1;
    }
    return 0;
}