export.hpp

Go to the documentation of this file.

/* Copyright (c) 2023 Otto Link. Distributed under the terms of the GNU General
   Public License. The full license is in the file LICENSE, distributed with
   this software. */
 
#pragma once
#include <filesystem>
#include <map>
#include <opencv2/imgcodecs.hpp>
#include <png.h>
 
#include "highmap/array.hpp"
#include "highmap/tensor.hpp"
 
namespace hmap
{
 
enum Cmap : int; // highmap/colormap.hpp
 
enum MeshType : int
{
  TRI_OPTIMIZED, 
  TRI,           
};
 
static std::map<MeshType, std::string> mesh_type_as_string = {
    {TRI_OPTIMIZED, "triangles (optimized)"},
    {TRI, "triangles"}};
 
enum AssetExportFormat : int
{
  _3DS,    
  _3MF,    
  ASSBIN,  
  ASSXML,  
  FXBA,    
  FBX,     
  COLLADA, 
  X3D,     
  GLTF,    
  GLB,     
  GTLF2,   
  GLB2,    
  PLY,     
  PLYB,    
  STP,     
  STL,     
  STLB,    
  OBJ,     
  OBJNOMTL 
};
 
// clang-format off
static std::map<AssetExportFormat, std::vector<std::string> >
asset_export_format_as_string = {
    {_3DS, {"Autodesk 3DS (legacy) - *.3ds", "3ds", "3ds"}},
    {_3MF, {"The 3MF-File-Format - *.3mf", "3mf", "3mf"}},
    {ASSBIN, {"Assimp Binary - *.assbin", "assbin", "assbin"}},
    {ASSXML, {"Assxml Document - *.assxml", "assxml", "assxml"}},
    {FXBA, {"Autodesk FBX (ascii) - *.fbx", "fbxa", "fbx"}},
    {FBX, {"Autodesk FBX (binary) - *.fbx", "fbx", "fbx"}},
    {COLLADA, {"COLLADA - Digital Asset Exchange Schema - *.dae", "collada", "dae"}},
    {X3D, {"Extensible 3D - *.x3d", "x3d", "x3d"}},
    {GLTF, {"GL Transmission Format - *.gltf", "gltf", "gltf"}},
    {GLB, {"GL Transmission Format (binary) - *.glb", "glb", "glb"}},
    {GTLF2, {"GL Transmission Format v. 2 - *.gltf", "gltf2", "gltf"}},
    {GLB2, {"GL Transmission Format v. 2 (binary) - *.glb", "glb2", "glb"}},
    {PLY, {"Stanford Polygon Library - *.ply", "ply", "ply"}},
    {PLYB, {"Stanford Polygon Library (binary) - *.ply", "plyb", "ply"}},
    {STP, {"Step Files - *.stp", "stp", "stp"}},
    {STL, {"Stereolithography - *.stl", "stl", "stl"}},
    {STLB, {"Stereolithography (binary) - *.stl", "stlb", "stl"}},
    {OBJ, {"Wavefront OBJ format - *.obj", "obj", "obj"}},
    {OBJNOMTL, {"Wavefront OBJ format without material file - *.obj", "objnomtl", "obj"}},
};
// clang-format on
 
bool export_asset(const std::string &fname,
                  const Array       &array,
                  MeshType           mesh_type = MeshType::TRI,
                  AssetExportFormat  export_format = AssetExportFormat::GLB2,
                  float              elevation_scaling = 0.2f,
                  const std::string &texture_fname = "",
                  const std::string &normal_map_fname = "",
                  float              max_error = 5e-4f);
 
std::string export_as_ascii(const Array      &array,
                            const Vec2<int>  &export_shape = {64, 64},
                            const std::string chars_map = " .:-=+*#%@");
 
void export_as_cubemap(const std::string &fname,
                       const Array       &z,
                       int                cubemap_resolution = 128,
                       float              overlap = 0.25f,
                       int                ir = 16,
                       Cmap               cmap = Cmap::GRAY,
                       bool               splitted = false,
                       Array             *p_cubemap = nullptr);
 
void export_banner_png(const std::string        &fname,
                       const std::vector<Array> &arrays,
                       int                       cmap,
                       bool                      hillshading = false);
 
void export_normal_map_png(const std::string &fname,
                           const Array       &array,
                           int                depth = CV_8U);
 
void export_splatmap_png(const std::string &fname,
                         const Array       *p_r,
                         const Array       *p_g = nullptr,
                         const Array       *p_b = nullptr,
                         const Array       *p_a = nullptr,
                         int                depth = CV_8U);
 
void export_tiled(const std::string &fname_radical,
                  const std::string &fname_extension,
                  const Array       &array,
                  const Vec2<int>   &tiling,
                  int                leading_zeros = 0,
                  int                depth = CV_8U,
                  bool               overlapping_edges = false,
                  bool               reverse_tile_y_indexing = false);
 
Array read_to_array(const std::string &fname);
 
void write_raw_16bit(const std::string &fname, const Array &array);
 
// --- helpers
 
std::filesystem::path add_filename_suffix(
    const std::filesystem::path &file_path,
    const std::string           &suffix);
 
} // namespace hmap