SweepOptions.h

/*
 * Copyright 2025 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/internal/constants.h>
#include <lagrange/utils/assert.h>
 
#include <Eigen/Geometry>
 
#include <array>
#include <functional>
#include <vector>
 
namespace lagrange::primitive {


template <typename Scalar>
class SweepOptions
{
public:
    using Point = Eigen::Matrix<Scalar, 1, 3>;
    using Frame = Eigen::Matrix<Scalar, 3, 3>;
    using Transform = Eigen::Transform<Scalar, 3, Eigen::AffineCompact>;
 
public:
    static SweepOptions<Scalar>
    linear_sweep(const Point& from, const Point& to, bool follow_tangent = true);

    static SweepOptions<Scalar> circular_sweep(
        const Point& p,
        const Point& axis,
        Scalar angle = static_cast<Scalar>(2 * lagrange::internal::pi),
        bool follow_tangent = true);
 
public:
    std::vector<Transform> sample_transforms() const;

    Transform sample_transform(Scalar t) const;

    std::vector<Scalar> sample_offsets() const;

    Scalar sample_offset(Scalar t) const;

    void set_pivot(const Point& pivot) { m_pivot = pivot; }

    const Point& get_pivot() const { return m_pivot; }

    void set_normalization(const Transform& normalization) { m_normalization = normalization; }

    const Transform& get_normalization() const { return m_normalization; }

    void set_num_samples(size_t num_samples)
    {
        la_runtime_assert(num_samples >= 2, "At least 2 samples are required.");
        m_num_samples = num_samples;
    }

    size_t get_num_samples() const { return m_num_samples; }

    void set_periodic(bool periodic) { m_periodic = periodic; }

    bool is_periodic() const { return m_periodic; }

    void set_domain(std::array<Scalar, 2> domain)
    {
        la_runtime_assert(
            domain[0] < domain[1],
            "Invalid domain: the end value must be greater than the start value.");
        m_domain = std::move(domain);
    }

    const std::array<Scalar, 2>& get_domain() const { return m_domain; }

    bool is_closed() const
    {
        return is_periodic() && std::abs(m_domain[1] - m_domain[0] - 1) < static_cast<Scalar>(1e-6);
    }

    void set_position_function(std::function<Point(Scalar)> fn) { m_position_fn = std::move(fn); }

    bool has_positions() const { return bool(m_position_fn); }

    void set_frame_function(std::function<Frame(Scalar)> fn) { m_frame_fn = std::move(fn); }

    bool has_frames() const { return bool(m_frame_fn); }

    void set_twist_function(std::function<Scalar(Scalar)> fn) { m_twist_fn = std::move(fn); }

    bool has_twists() const { return bool(m_twist_fn); }

    void set_taper_function(std::function<Scalar(Scalar)> fn) { m_taper_fn = std::move(fn); }

    bool has_tapers() const { return bool(m_taper_fn); }

    void set_offset_function(std::function<Scalar(Scalar)> fn) { m_offset_fn = std::move(fn); }

    bool has_offsets() const { return bool(m_offset_fn); }
 
protected:
    Point m_pivot = Point::Zero();
    Transform m_normalization = Transform::Identity();
    size_t m_num_samples = 16;
    bool m_periodic = false;
    std::array<Scalar, 2> m_domain = {0, 1};

    std::function<Point(Scalar)> m_position_fn;
    std::function<Frame(Scalar)> m_frame_fn;
    std::function<Scalar(Scalar)> m_twist_fn;
    std::function<Scalar(Scalar)> m_taper_fn;
    std::function<Scalar(Scalar)> m_offset_fn;
};

 
} // namespace lagrange::primitive