ParametricBathymetry.h

#pragma once
 
#include <marenv/seafloor/BathymetryField.h>
 
#include <memory>
#include <string>
#include <vector>
 
namespace environmentmodels
{
 
namespace parametric
{
 
enum class Primitive
{
   Constant,         
   Slope,            
   TransversalSlope, 
   Valley,           
   Peak,             
   Bump,             
   TransversalInterp 
};
 
enum class InterpMode
{
   Linear,      
   CubicSpline, 
   Polynomial   
};
 
enum class Extrap
{
   Flat,   
   Linear, 
   Extend  
};
 
struct Profile1D
{
   InterpMode          mode   = InterpMode::CubicSpline; 
   Extrap              extrap = Extrap::Flat;            
   std::vector<double> nodes;                            
   std::vector<double> values;                           
 
   // Precomputed coefficients (populated by the builder in the .cpp).
   std::vector<double> poly;                             
   std::vector<double> b;                                
   std::vector<double> c;                                
   std::vector<double> d;                                
 
   [[nodiscard]] double Evaluate(double v) const;
};
 
enum class Shape
{
   Gaussian, 
   Parabola, 
   Cosine    
};
 
enum class Window
{
   Hard,        
   Linear,      
   Smoothstep,  
   RaisedCosine 
};
 
enum class Blend
{
   Replace, 
   Add,     
   Min,     
   Max      
};
 
struct Feature
{
   Primitive type       = Primitive::Constant; 
   double    headingRad  = 0.0;                 
   double    depth       = 200.0;               
   double    gradient    = 0.0;                 
   double    amplitude   = 0.0;                 
   double    width       = 1.0;                 
   double    crossOffset = 0.0;                 
   double    centerX     = 0.0;                 
   double    centerY     = 0.0;                 
   Shape     shape       = Shape::Gaussian;     
 
   std::shared_ptr<const Profile1D> profile;    
};
 
struct Region
{
   double headingRad = 0.0;      
   double min        = -1.0e300; 
   double max        = 1.0e300;  
   Window window     = Window::Hard; 
   double falloff    = 0.0;      
};
 
struct Layer
{
   Feature feature;                 
   Region  region;                  
   Blend   blend = Blend::Replace;  
};
 
struct Segment
{
   double  length = 100.0; 
   Feature profile;        
};
 
struct Track
{
   bool                 present         = false;                
   double               headingRad      = 0.0;                  
   double               start           = 0.0;                  
   double               transitionWidth = 0.0;                  
   Window               transition      = Window::RaisedCosine; 
   std::vector<Segment> segments;                               
};
 
struct Spec
{
   double               baseDepth = 200.0;  
   double               rho       = 2000.0; 
   Track                track;              
   std::vector<Layer>   layers;             
};
 
} // namespace parametric
 
class ParametricBathymetry : public marenv::seafloor::BathymetryField
{
public:
   explicit ParametricBathymetry(parametric::Spec spec);
   ~ParametricBathymetry() override = default;
 
   static std::shared_ptr<ParametricBathymetry> FromJsonString(const std::string& jsonText);
 
   static std::shared_ptr<ParametricBathymetry> FromFile(const std::string& path);
 
   [[nodiscard]] marenv::Status GetDepth(const double pos[2], double& depthOut) override;
 
   [[nodiscard]] marenv::Status ComputeSurfaceUnitNormal(const double pos[2], double unitNormalOut[3]) override;
 
   [[nodiscard]] marenv::Status GetSeabedSigma(const double pos[3], double& sigmaOut) override;
 
   [[nodiscard]] marenv::Status GetSeabedTau(const double pos[3], double& tauOut) override;
 
   [[nodiscard]] marenv::Status GetSeabedRho(const double pos[3], double& rhoOut) override;
 
   [[nodiscard]] marenv::Status ComputeRayIntersection(const double origin[3], const double direction[3],
         double& distanceOut, double maxSearchDistance = 100.0, double startSearchDistance = -1.0,
         double stepSize = 1.0, double convergenceTolerance = 0.01) override;
 
   [[nodiscard]] double DepthAt(double x, double y) const;
 
private:
   double TrackDepth(double x, double y) const;
 
   parametric::Spec m_spec;
};
 
} // namespace environmentmodels