DEM转换为gltf

#include <iostream>
#include <fstream>
#include <iomanip>
#include <nlohmann\json.hpp>
#include "fifo_map.hpp"

#include <gdal/gdal_priv.h>

using namespace std;
using namespace nlohmann;

// A workaround to give to use fifo_map as map, we are just ignoring the 'less' compare
template<class K, class V, class dummy_compare, class A>
using my_workaround_fifo_map = fifo_map<K, V, fifo_map_compare<K>, A>;
using my_json = basic_json<my_workaround_fifo_map>;

int main()
{
    GDALAllRegister();
    CPLSetConfigOption("GDAL_FILENAME_IS_UTF8", "NO");  //支持中文路径

    my_json gltf;

    gltf["asset"] = {
        {"generator", "CL"},
        {"version", "2.0"} 
    };

    gltf["scene"] = 0;
    gltf["scenes"] = {
        {{"nodes", {0} }}
    };

    gltf["nodes"] = {
        {{"mesh", 0}}
    };

    my_json positionJson;
    positionJson["POSITION"] = 1;
    positionJson["TEXCOORD_0"] = 2;
    
    my_json primitivesJson;
    primitivesJson = {
        {{"attributes", positionJson}, {"indices", 0}, {"material", 0} }
    };  

    gltf["meshes"] = {
        {{"primitives", primitivesJson}}
    };

    my_json pbrJson;
    pbrJson["baseColorTexture"]["index"] = 0;

    gltf["materials"] = {
        {{"pbrMetallicRoughness", pbrJson}}
    };
    
    size_t pointNum = 0;
    size_t binBufNum = 0;
    size_t indicesNum = 0;
    
    {   
        string binPath = "D:/Work/WebGLTutorial/Data/new.bin";
        ofstream binFile(binPath, std::ios::binary);
    
        const char *filePath = "D:/Work/WebGLTutorial/Data/DEM.tif";
        GDALDataset* img = (GDALDataset *)GDALOpen(filePath, GA_ReadOnly);
        if (!img)
        {
            printf("Can't Open Image!");
            return 0;
        }
        int bufWidth = img->GetRasterXSize();   //图像宽度
        int bufHeight = img->GetRasterYSize();  //图像高度
        int bandNum = img->GetRasterCount();    //波段数
        if (bandNum != 1)
        {
            printf("DEM波段数不为1");
            return 0;
        }
        int depth = GDALGetDataTypeSize(img->GetRasterBand(1)->GetRasterDataType()) / 8;    //图像深度
        
         //获取地理坐标信息
        double padfTransform[6];
        if (img->GetGeoTransform(padfTransform) == CE_Failure)
        {
            printf("获取仿射变换参数失败");
            return 0;
        }

        double startX = padfTransform[0];
        double dX = padfTransform[1];
        double startY = padfTransform[3];
        double dY = padfTransform[5];

        //申请buf
        size_t imgBufNum = (size_t)bufWidth * bufHeight * bandNum;
        float *imgBuf = new float[imgBufNum];

        //读取
        img->RasterIO(GF_Read, 0, 0, bufWidth, bufHeight, imgBuf, bufWidth, bufHeight,
            GDT_Float32, bandNum, nullptr, bandNum*depth, bufWidth*bandNum*depth, depth);

        pointNum = (size_t)bufWidth * bufHeight;
        size_t position_texture_num = pointNum * 5;
        float *position_texture = new float[position_texture_num];
        
        for (int yi = 0; yi < bufHeight; yi++)
        {
            for (int xi = 0; xi < bufWidth; xi++)
            {
                size_t n = (size_t)(bufWidth * 5) * yi + 5 * xi;
                position_texture[n] = dX * xi;
                position_texture[n+1] = dY * yi;
                size_t m = (size_t)(bufWidth * bandNum) * yi + bandNum * xi;
                position_texture[n + 2] = imgBuf[m];
                position_texture[n + 3] = float(xi) / (bufWidth-1);
                position_texture[n + 4] = float(yi) / (bufHeight-1);            
            }
        }

        //释放
        delete[] imgBuf;
        imgBuf = nullptr;                   
    
        binFile.write((char*)position_texture, position_texture_num * sizeof(float));
    
        size_t vertexBufNum = position_texture_num * sizeof(float);
        binBufNum = binBufNum + vertexBufNum;

        int mod = vertexBufNum % sizeof(uint16_t);  
        if (mod != 0)
        {                   
            int spaceNum = sizeof(float) - mod;     
            char *space = new char[spaceNum];
            binBufNum = binBufNum + sizeof(char) * spaceNum;
            memset(space, 0, sizeof(char) * spaceNum);
            binFile.write(space, sizeof(char) * spaceNum);
            delete[] space;
            space = nullptr;
        }
                    
        indicesNum = (size_t)(bufWidth - 1) * (bufHeight - 1) * 2 * 3;
        uint16_t *indices = new uint16_t[indicesNum];

        for (int yi = 0; yi < bufHeight-1; yi++)
        {
            for (int xi = 0; xi < bufWidth-1; xi++)
            {
                uint16_t m00 = (uint16_t)(bufWidth * yi + xi) ;
                uint16_t m01 = (uint16_t)(bufWidth * (yi+1) + xi);
                uint16_t m11 = (uint16_t)(bufWidth * (yi + 1) + xi + 1);
                uint16_t m10 = (uint16_t)(bufWidth * yi + xi + 1);

                size_t n = (size_t)(bufWidth - 1) * yi + xi;
                indices[n * 6] = m00;
                indices[n * 6 + 1] = m01;
                indices[n * 6 + 2] = m11;
                indices[n * 6 + 3] = m11;
                indices[n * 6 + 4] = m10;
                indices[n * 6 + 5] = m00;
            }
        }
        
        binFile.write((char*)indices, sizeof(uint16_t) * indicesNum);
        binBufNum = binBufNum + sizeof(uint16_t) * indicesNum;

        delete[] position_texture;
        position_texture = nullptr;

        delete[] indices;
        indices = nullptr;
    }
       
    gltf["textures"] = {
        {{"sampler", 0}, {"source", 0}}
    };

    gltf["images"] = {
        {{"uri", "tex.jpg"}}
    };

    gltf["samplers"] = {
        {{"magFilter", 9729}, {"minFilter", 9987}, {"wrapS", 33648}, {"wrapT", 33648}}
    };

          
    gltf["buffers"] = {
    {{"uri", "new.bin"}, {"byteLength", binBufNum}}
    };
    
    my_json indicesBufferJson;
    indicesBufferJson["buffer"] = 0;
    indicesBufferJson["byteOffset"] = pointNum * 5 * 4;
    indicesBufferJson["byteLength"] = indicesNum * 2;
    indicesBufferJson["target"] = 34963;

    my_json positionBufferJson;
    positionBufferJson["buffer"] = 0;
    positionBufferJson["byteStride"] = sizeof(float) * 5;
    positionBufferJson["byteOffset"] = 0;
    positionBufferJson["byteLength"] = pointNum * 5 * 4;
    positionBufferJson["target"] = 34962;
    
    gltf["bufferViews"] = {
        indicesBufferJson, positionBufferJson
    };

    my_json indicesAccessors;
    indicesAccessors["bufferView"] = 0;
    indicesAccessors["byteOffset"] = 0;
    indicesAccessors["componentType"] = 5123;
    indicesAccessors["count"] = indicesNum;
    indicesAccessors["type"] = "SCALAR";
    indicesAccessors["max"] = { 18719 };
    indicesAccessors["min"] = { 0 };
    
    my_json positionAccessors;
    positionAccessors["bufferView"] = 1;
    positionAccessors["byteOffset"] = 0;
    positionAccessors["componentType"] = 5126;
    positionAccessors["count"] = pointNum;
    positionAccessors["type"] = "VEC3";
    positionAccessors["max"] = { 770, 0.0,  1261.151611328125 };
    positionAccessors["min"] = { 0.0, -2390,  733.5555419921875 };

    my_json textureAccessors;
    textureAccessors["bufferView"] = 1;
    textureAccessors["byteOffset"] = sizeof(float) * 3;
    textureAccessors["componentType"] = 5126;
    textureAccessors["count"] = pointNum;
    textureAccessors["type"] = "VEC2";
    textureAccessors["max"] = { 1, 1 };
    textureAccessors["min"] = { 0, 0 };

    gltf["accessors"] = {
        indicesAccessors, positionAccessors, textureAccessors
    };        

    string jsonFile = "D:/Work/WebGLTutorial/Data/new.gltf";
    std::ofstream outFile(jsonFile);
    outFile << std::setw(4) << gltf << std::endl;        
}