remove_occluded_facets.h

/*
 * Copyright 2026 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/raycasting/api.h>
#include <lagrange/scene/SimpleScene.h>
#include <lagrange/utils/ProgressCallback.h>
#include <lagrange/utils/function_ref.h>
#include <lagrange/utils/span.h>
#include <lagrange/utils/value_ptr.h>
 
#include <atomic>
 
namespace lagrange::raycasting {


struct OccludedFacetSamplerOptions
{
    double jitter_sigma = 0.025;

    uint8_t visibility_threshold = 3;
};

template <typename Scalar, typename Index>
class LA_RAYCASTING_API OccludedFacetSampler
{
public:
    struct InstanceInfo
    {
        Index mesh_index;
        Index instance_index;
        uint64_t facet_offset;
        Index num_facets;
    };

    explicit OccludedFacetSampler(
        const scene::SimpleScene<Scalar, Index, 3>& scene,
        const OccludedFacetSamplerOptions& options = {},
        function_ref<bool(Index mesh_index, Index instance_index)> is_occluder = [](Index, Index) {
            return true;
        });
 
    ~OccludedFacetSampler();
    OccludedFacetSampler(OccludedFacetSampler&&) noexcept;
    OccludedFacetSampler& operator=(OccludedFacetSampler&&) noexcept;

    void run_normal_batch(uint64_t num_rays);

    void run_adaptive_batch(uint64_t num_rays);

    void run_brute_force_batch(uint64_t num_rays);

    bool is_visible(uint64_t global_facet_index) const;

    uint64_t num_rays_cast(uint64_t global_facet_index) const;

    uint64_t num_facets() const;

    span<const InstanceInfo> instances() const;
 
private:
    struct Impl;
    value_ptr<Impl> m_impl;
};

struct OccludedFacetEstimateOptions
{
    uint64_t num_rays = 1600000000ULL;

    uint64_t batch_size = 20000000ULL;

    uint64_t num_adaptive_per_normal = 6;

    bool brute_force = false;

    bool until_converged = false;
};

template <typename Scalar, typename Index>
LA_RAYCASTING_API void estimate_occluded_facets(
    OccludedFacetSampler<Scalar, Index>& sampler,
    const OccludedFacetEstimateOptions& options,
    ProgressCallback& progress,
    const std::atomic_bool* cancel = nullptr);

struct RemoveOccludedFacetsOptions
{
    OccludedFacetEstimateOptions estimate_options = {};

    OccludedFacetSamplerOptions sampler_options = {};
};

template <typename Scalar, typename Index>
LA_RAYCASTING_API scene::SimpleScene<Scalar, Index, 3> remove_occluded_facets(
    const scene::SimpleScene<Scalar, Index, 3>& scene,
    const RemoveOccludedFacetsOptions& options,
    ProgressCallback& progress,
    function_ref<bool(Index mesh_index, Index instance_index)> is_occluder =
        [](Index, Index) { return true; },
    const std::atomic_bool* cancel = nullptr);

 
} // namespace lagrange::raycasting