SwathIsoSurfacesBuildMeshTask.h

#include "SwathBuildMeshTask.h"
 
namespace Cogs
{
  namespace Core
  {
    namespace EchoSounder
    {
      struct BeamGroupComponent;
      struct SwathIsoComponent;
      struct SwathIsoSurfacesData;
 
 
      class SwathIsoSurfacesBuildMeshTask : public SwathBuildMeshTask
      {
      public:
        SwathIsoSurfacesBuildMeshTask(Cogs::Core::Context* context,
                                      Cogs::Core::MeshHandle& mesh,
                                      const uint32_t chunkIndex,
                                      const Cogs::Core::EchoSounder::BeamGroupComponent& groupComp,
                                      const Cogs::Core::EchoSounder::SwathIsoComponent& swathComp,
                                      const Cogs::Core::EchoSounder::SwathIsoSurfacesData& swathData,
                                      const Cogs::Core::EchoSounder::DataSetData& dataData);
 
        SwathIsoSurfacesBuildMeshTask(const SwathIsoSurfacesBuildMeshTask& other);
 
        void operator()();
 
      protected:
        const float seabedClipOffset;
        const bool useDecibel;
        const bool flipOrientation;
 
        const float depthSpacing;
        const float maxDepthUpsample;
        float overflowThreshold = std::numeric_limits<float>::quiet_NaN();
        float minVerticalDepth = std::numeric_limits<float>::quiet_NaN();
        float maxVerticalDepth = std::numeric_limits<float>::quiet_NaN();
        const float depthOffset;
        const uint32_t coordSys;
        float depthStep;
        float separation;
        uint32_t sampleCount;
 
        SwathIsoComponent::TextureDomain uTextureDomain;
        SwathIsoComponent::TextureDomain vTextureDomain;
        glm::vec2 uTextureRange;
        glm::vec2 vTextureRange;
        std::vector<float> thresholds;
        Cogs::Memory::TypedBuffer<float> depths;
        Cogs::Memory::TypedBuffer<float> values;
        Cogs::Memory::TypedBuffer<float> floatTmp;
 
        Cogs::Memory::TypedBuffer<glm::quat> arrayOrientationVessel;
        Cogs::Memory::TypedBuffer<glm::vec3> arrayPositionVessel;
 
        void linearizeAndClipValues(std::vector<float>& linearizedThresholds);
        void clipVerticalMask();
 
        void depthResample();
 
        void beamResample(std::vector<glm::vec3>& beamDir);
 
        void pathResample();
      };
    }
  }
}