mesh_to_volume.h

/*
 * Copyright 2021 Adobe. All rights reserved.
 * This file is licensed to you under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License. You may obtain a copy
 * of the License at http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under
 * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
 * OF ANY KIND, either express or implied. See the License for the specific language
 * governing permissions and limitations under the License.
 */
#pragma once
 
#include <lagrange/Logger.h>
#include <lagrange/MeshTrait.h>
#include <lagrange/legacy/inline.h>
 
// clang-format off
#include <lagrange/utils/warnoff.h>
#include <openvdb/openvdb.h>
#include <openvdb/tools/MeshToVolume.h>
#include <lagrange/utils/warnon.h>
// clang-format on
 
#include <Eigen/Dense>
 
namespace lagrange {
namespace volume {
LAGRANGE_LEGACY_INLINE
namespace legacy {

template <typename MeshType>
class MeshAdapter
{
    static_assert(MeshTrait<MeshType>::is_mesh(), "Input type is not Mesh");
 
public:
    MeshAdapter(const MeshType& mesh, const openvdb::math::Transform& transform)
        : m_mesh(mesh)
        , m_transform(transform)
    {}

    size_t polygonCount() const { return static_cast<size_t>(m_mesh.get_num_facets()); }

    size_t pointCount() const { return static_cast<size_t>(m_mesh.get_num_vertices()); }

    size_t vertexCount(size_t /*f*/) const
    {
        return static_cast<size_t>(m_mesh.get_vertex_per_facet());
    }

    void getIndexSpacePoint(size_t f, size_t lv, openvdb::Vec3d& pos) const
    {
        Eigen::RowVector3d p =
            m_mesh.get_vertices().row(m_mesh.get_facets()(f, lv)).template cast<double>();
        pos = openvdb::Vec3d(p.x(), p.y(), p.z());
        pos = m_transform.worldToIndex(pos);
    }
 
protected:
    const MeshType& m_mesh;
    const openvdb::math::Transform& m_transform;
};

template <typename MeshType, typename GridType = openvdb::FloatGrid>
auto mesh_to_volume(const MeshType& mesh, double voxel_size) -> typename GridType::Ptr
{
    static_assert(MeshTrait<MeshType>::is_mesh(), "Input type is not Mesh");
 
    openvdb::initialize();
 
    const openvdb::Vec3d offset(voxel_size / 2.0, voxel_size / 2.0, voxel_size / 2.0);
    auto transform = openvdb::math::Transform::createLinearTransform(voxel_size);
    transform->postTranslate(offset);
 
    MeshAdapter<MeshType> adapter(mesh, *transform);
    try {
        return openvdb::tools::meshToVolume<GridType, MeshAdapter<MeshType>>(adapter, *transform);
    } catch (openvdb::ArithmeticError&) {
        logger().error("Voxel size too small: {}", voxel_size);
        throw;
    }
}
 
} // namespace legacy
} // namespace volume
} // namespace lagrange