SwathBuildMeshTask.h

#pragma once
#include "Resources/Resources.h"
#include "Services/Variables.h"
#include "../Systems/DataSetSystem.h"
 
#include "../SwathPathResamplingPositions.h"
 
#include "Foundation/Memory/MemoryBuffer.h"
 
#include <vector>
 
namespace Cogs
{
  namespace Core
  {
    namespace EchoSounder
    {
      struct BeamGroupComponent;
 
      class SwathBuildMeshTask
      {
      public:
        SwathBuildMeshTask(Cogs::Core::Context* context,
          Cogs::Core::MeshHandle& mesh,
          const uint32_t chunkIndex,
          const float pathSpacing,
          const float beamSpacing,
          const BeamGroupComponent& groupComp,
          const DataSetData& dataData,
          const SwathPathResamplingPositions& resPos,
          const SwathPathChunks& chunks
          )
        : context(context),
          mesh(mesh),
          chunkIndex(chunkIndex),
          pathSpacing(pathSpacing),
          beamSpacing(beamSpacing),
          bufferCapacity(dataData.persistent->config.capacity),
          maxBeamUpsample(context->variables->get("echo.maxBeamUpsample")->getFloat()),
          coordSys(dataData.persistent->config.coordSys)
        {
          const auto & dataConf = dataData.persistent->config;
          const auto & buffer = dataData.persistent->buffer;
 
          // Set up beam subset.
          assert(groupComp.majorCount == 1);
          assert(groupComp.minorCount > 0);
 
          beamCount = std::max(2u, groupComp.minorCount);
          directionX.resize(beamCount);
          directionY.resize(beamCount);
 
          beams = groupComp.beams;
 
          if (groupComp.minorCount == 1) { // Single-beam data, extrude.
            const uint32_t ix = beams.back();
            beams.push_back(ix);
 
            bool yXpand = true; // Should be the direction mostly across vessel dir.
 
            const auto sx = yXpand ? 0.f : 0.5f*dataConf.beamWidthX[ix];
            const auto sy = yXpand ? 0.5f*dataConf.beamWidthY[ix] : 0.f;
 
            directionX[0] = dataConf.directionX[ix] - sx;
            directionY[0] = dataConf.directionY[ix] - sy;
 
            directionX[1] = dataConf.directionX[ix] + sx;
            directionY[1] = dataConf.directionY[ix] + sy;
          }
 
          else {  // Multi-beam fan
 
            for (uint32_t k = 0; k < beamCount; k++) {
              const auto ix = beams[k];
              directionX[k] = dataConf.directionX[ix];
              directionY[k] = dataConf.directionY[ix];
            }
          }
 
          // Copy setup for beam-subset x pings in our support
          const auto chunk = chunks.getChunks()[chunkIndex];
          tail = (chunk.flags & SwathPathChunkFlag::Tail) != 0;
          head = (chunk.flags & SwathPathChunkFlag::Head) != 0;
 
          const auto & resamplingPositions_src = resPos.getEntries();
          bix_a = resamplingPositions_src[chunk.support.a].bufferIndex;
          bix_b = resamplingPositions_src[chunk.support.b].bufferIndex;
          sliceA = (chunk.extent.a - chunk.support.a);
          sliceB = (chunk.extent.b - chunk.support.a);
 
          //std::cerr << "Chunk " << chunkIndex << " geometry, extent={"
          //  << chunk.extent.a << ", " << chunk.extent.b << "}, buffer extent={" 
          //  << resamplingPositions_src[chunk.extent.a].bufferIndex
          //  << ", " << resamplingPositions_src[chunk.extent.b].bufferIndex << "}\n";
 
          sliceCount = (bix_b - bix_a + 1 + dataConf.capacity) % dataConf.capacity;
          if (pathSpacing != 0.f) { // No resampling along path
 
            sliceCount = sliceCount + 1;  // One extra sample to accommodate linear interpolation.
 
            resamplingPositions.resize(chunk.support.b - chunk.support.a + 1);
            for (uint32_t i = 0; i < resamplingPositions.size(); i++) {
              resamplingPositions[i] = resamplingPositions_src[chunk.support.a + i];
            }
            assert(sliceA <= resamplingPositions.size());
            assert(sliceB <= resamplingPositions.size());
          }
          else {
            assert(sliceA <= sliceCount);
            assert(sliceB <= sliceCount);
          }
 
          metaPings.resize(sliceCount);
          for (uint32_t i = 0; i < sliceCount; i++) {
            uint32_t k = (bix_a + i) % dataConf.capacity;
            metaPings[i] = buffer.metaPings[k];
          }
 
        }
 
 
        SwathBuildMeshTask(const SwathBuildMeshTask& other)
        : context(other.context),
          pathSpacing(other.pathSpacing),
          beamSpacing(other.beamSpacing),
          chunkIndex(other.chunkIndex),
          bufferCapacity(other.bufferCapacity),
          beamCount(other.beamCount),
          sliceCount(other.sliceCount),
          sliceA(other.sliceA),
          sliceB(other.sliceB),
          mesh(other.mesh),
          beams(other.beams),
          coordSys(other.coordSys),
          directionX(other.directionX),
          directionY(other.directionY),
          maxBeamUpsample(other.maxBeamUpsample),
          tail(other.tail),
          head(other.head)
        {
          resamplingPositions.copy(other.resamplingPositions);
          metaPings.copy(other.metaPings);
        }
 
      protected:
        Cogs::Core::Context* context;
        Cogs::Core::MeshHandle& mesh;
        const uint32_t chunkIndex;
        const uint32_t bufferCapacity;
        const float pathSpacing;
        const float beamSpacing;
        const float maxBeamUpsample;
        bool tail;
        bool head;
 
        uint32_t beamCount;
        uint32_t sliceCount;
        uint32_t bix_a;
        uint32_t bix_b;
        uint32_t sliceA;
        uint32_t sliceB;
 
        std::vector<uint32_t> beams;
        const uint32_t coordSys;
        std::vector<float> directionX;
        std::vector<float> directionY;
 
        Cogs::Memory::TypedBuffer<Cogs::Core::EchoSounder::SwathPathResamplingPositions::Entry> resamplingPositions;
        Cogs::Memory::TypedBuffer<Cogs::Core::EchoSounder::PingMetaData> metaPings;
      };
 
    }
  }
}