PingOutlineComponent.cpp

#include <sstream>
#include "PingOutlineComponent.h"
#include "Context.h"
#include "EntityStore.h"
#include "Types.h"
 
#include "Components/Core/MeshComponent.h"
#include "Components/Core/MeshRenderComponent.h"
#include "Components/Core/TransformComponent.h"
#include "Components/Core/TextComponent.h"
#include "Components/Appearance/MaterialComponent.h"
#include "../Extensions/AxisCube/Source/Components/AnnotationAxisComponent.h"
 
#include "Resources/MeshManager.h"
#include "Resources/MaterialManager.h"
#include "Resources/DefaultMaterial.h"
 
#include "DataSetComponent.h"
#include "DataRefComponent.h"
#include "BeamGroupComponent.h"
#include "../Systems/DataSetSystem.h"
#include "../BeamUtils.h"
 
using glm::vec3;
using glm::angleAxis;
 
using namespace Cogs::Core;
using namespace Cogs::Reflection;
using namespace Cogs::Core;
 
namespace {
 
  void setVertexColorMaterial(Cogs::Core::Context* context, Cogs::Core::EntityPtr entity)
  {
    auto material = context->materialInstanceManager->createMaterialInstance(context->materialManager->getDefaultMaterial());
    material->setPermutation("Line");
    material->setVariant("LightModel", "BaseColor");
    material->setVariant("EnableLighting", false);
    material->setVariant("VertexColor", true);
 
    auto matRndComp = entity->getComponent<MeshRenderComponent>();
    matRndComp->material = material;
    matRndComp->setRenderFlag(RenderFlags::CustomMaterial);
    matRndComp->setChanged();
  }
 
  void setAnnotationLineMaterial(Cogs::Core::Context* context, Cogs::Core::EntityPtr entity)
  {
    auto material = context->materialInstanceManager->createMaterialInstance(context->materialManager->getDefaultMaterial());
    material->setPermutation("Line");
    material->setVariant("LightModel", "BaseColor");
    material->setVariant("EnableLighting", false);
    material->setVec4Property(DefaultMaterial::DiffuseColor, glm::vec4(0.8f, 0.8f, 0.8f, 1));
    material->setFloatProperty(DefaultMaterial::LineWidth, 1.5f);
    //material->setUIntProperty(material->material->getUIntKey("stipplePattern"), 0x0000000F);
 
    auto matRndComp = entity->getComponent<MeshRenderComponent>();
    matRndComp->material = material;
    matRndComp->setRenderFlag(RenderFlags::CustomMaterial);
    matRndComp->setChanged();
  }
 
  MeshHandle buildVesselSIMRADCoordsys(Context* context,
                                       const glm::quat& vesselOrientation,
                                       const glm::vec3& vesselPosition,
                                       const float size)
  {
    glm::quat R;
    glm::vec3 O;
    EchoSounder::getArrayToVesselTransform(R, O,
                                           glm::vec3(glm::radians(0.f), glm::radians(0.f), glm::radians(0.f)),
                                           glm::vec3(0, 0, 0));
 
    R = vesselOrientation * R;
    O = vesselPosition + (vesselOrientation * O);
 
    auto mesh = context->meshManager->create();
    auto P = mesh->mapPositions(0, 6);
    auto C = mesh->map<glm::vec4>(VertexDataType::Colors0, VertexFormats::Color4f, 0, 6);
    P[0] = R*glm::vec3(0, 0, 0) + O; C[0] = glm::vec4(1, 0, 0, 1);
    P[1] = R*glm::vec3(size, 0, 0) + O; C[1] = glm::vec4(1, 0, 0, 1);
    P[2] = R*glm::vec3(0, 0, 0) + O; C[2] = glm::vec4(0, 1, 0, 1);
    P[3] = R*glm::vec3(0, size, 0) + O; C[3] = glm::vec4(0, 1, 0, 1);
    P[4] = R*glm::vec3(0, 0, 0) + O; C[4] = glm::vec4(0, 0, 1, 1);
    P[5] = R*glm::vec3(0, 0, size) + O; C[5] = glm::vec4(0, 0, 1, 1);
 
    mesh->primitiveType = Cogs::PrimitiveType::LineList;
    mesh->setBounds(Cogs::Geometry::BoundingBox{ glm::vec3(0), glm::vec3(1) });
 
    return mesh;
  }
 
  void getFrontBeams(std::vector<glm::vec3> & output, const std::vector<glm::vec3> & allDirs,
                     uint32_t minorCount, uint32_t majorCount, bool excludeEndPoints = false)
  {
    uint32_t eOffset = excludeEndPoints ? 1 : 0;
    for (uint32_t i = eOffset; i < minorCount - eOffset; ++i) {
      auto index = minorCount * (majorCount - 1) + i;
      output.push_back(allDirs[index]);
    }
  }
 
  void getRightBeams(std::vector<glm::vec3> & output, const std::vector<glm::vec3> & allDirs,
                    uint32_t minorCount, uint32_t majorCount, bool excludeEndPoints = false)
  {
    uint32_t eOffset = excludeEndPoints ? 1 : 0;
    for (uint32_t i = eOffset; i < majorCount - eOffset; ++i) {
      auto index = (majorCount - 1 - i) * minorCount + (minorCount - 1);
      output.push_back(allDirs[index]);
    }
  }
 
 void getBackBeams(std::vector<glm::vec3> & output, const std::vector<glm::vec3> & allDirs,
                   uint32_t minorCount, uint32_t /*majorCount*/, bool excludeEndPoints = false)
 {
   uint32_t eOffset = excludeEndPoints ? 1 : 0;
   for (uint32_t i = eOffset; i < minorCount - eOffset; ++i) {
     auto index = minorCount - 1 - i;
     output.push_back(allDirs[index]);
   }
 }
 
 void getLeftBeams(std::vector<glm::vec3> & output, const std::vector<glm::vec3> & allDirs,
                    uint32_t minorCount, uint32_t majorCount, bool excludeEndPoints = false) {
   uint32_t eOffset = excludeEndPoints ? 1 : 0;
   for (uint32_t i = eOffset; i < majorCount - eOffset; ++i) {
     auto index = i * minorCount;
     output.push_back(allDirs[index]);
   }
 }
 
 
  std::vector<glm::vec3> getOuterAnnotationBeams(const std::vector<glm::vec3> &dirs,
                                                 uint32_t minorCount, uint32_t majorCount,
                                                 Cogs::Core::EchoSounder::AnnotationPosition annoPostion)
  {
    std::vector<glm::vec3> outerBeams;
    if (annoPostion == Cogs::Core::EchoSounder::AnnotationPosition::Front) {
      getRightBeams(outerBeams, dirs, minorCount, majorCount);
      getBackBeams(outerBeams, dirs, minorCount, majorCount, true);
      getLeftBeams(outerBeams, dirs, minorCount, majorCount);
    }
    if (annoPostion == Cogs::Core::EchoSounder::AnnotationPosition::Right) {
      getBackBeams(outerBeams, dirs, minorCount, majorCount);
      getLeftBeams(outerBeams, dirs, minorCount, majorCount, true);
      getFrontBeams(outerBeams, dirs, minorCount, majorCount);
    }
    return outerBeams;
  }
 
  std::vector<glm::vec3> getFrontAnnotationBeams(const std::vector<glm::vec3> &dirs,
                                                 uint32_t minorCount, uint32_t majorCount,
                                                 Cogs::Core::EchoSounder::AnnotationPosition annoPostion)
  {
    std::vector<glm::vec3> frontDirection;
    if (annoPostion == Cogs::Core::EchoSounder::AnnotationPosition::Front) {
      getFrontBeams(frontDirection, dirs, minorCount, majorCount);
    }
    else if (annoPostion == Cogs::Core::EchoSounder::AnnotationPosition::Right) {
      getRightBeams(frontDirection, dirs, minorCount, majorCount);
    }
    return frontDirection;
  }
}
 
 
void EchoSounder::PingOutlineComponent::registerType()
{
  static constexpr EnumeratorDef annoTypeEnumerator[] = {
    { "VerticalDepth", AnnotationType::VerticalDepth },
    { "Range", AnnotationType::Range },
  };
  TypeDatabase::createType<AnnotationType>().setEnumerators(annoTypeEnumerator);
 
  static constexpr EnumeratorDef connectedTicksEnumerator[]{
    { "None", ConnectedTicksMode::None },
    { "Fan", ConnectedTicksMode::Fan },
    { "Grid", ConnectedTicksMode::Grid },
  };
  TypeDatabase::createType<ConnectedTicksMode>().setEnumerators(connectedTicksEnumerator);
 
  static constexpr EnumeratorDef annotationPositionEnumerator[]{
    { "Front", AnnotationPosition::Front },
    { "Right", AnnotationPosition::Right },
  };
  TypeDatabase::createType<AnnotationPosition>().setEnumerators(annotationPositionEnumerator);
 
  Field fields[] = {
    Field(Name("flat"), &PingOutlineComponent::flat),
    Field(Name("individualBeams"), &PingOutlineComponent::individualBeams),
    Field(Name("annotationType"), &PingOutlineComponent::annotationType),
    Field(Name("connectedTicks"), &PingOutlineComponent::connectedTicks),
    Field(Name("annotationPosition"), &PingOutlineComponent::annotationPosition),
    Field(Name("showVesselCoordsys"), &PingOutlineComponent::showVesselCoordsys),
    Field(Name("showBoundingFrustum"), &PingOutlineComponent::showBoundingFrustum),
    Field(Name("showAABB"), &PingOutlineComponent::showAABB),
    Field(Name("numTickMarks"), &PingOutlineComponent::numTickMarks),
    Field(Name("tickLength"), &PingOutlineComponent::tickLength),
    Field(Name("unit"), &PingOutlineComponent::unit),
    Field(Name("widthScaleAlongship"), &PingOutlineComponent::widthScaleAlongship),
    Field(Name("widthScaleAthwartship"), &PingOutlineComponent::widthScaleAthwartship),
    Field(Name("depthStart"), &PingOutlineComponent::depthStart),
    Field(Name("depthRange"), &PingOutlineComponent::depthRange),
    Field(Name("textColor"), &PingOutlineComponent::textColor)
  };
  Method methods[] = {
    Method(Name("initialize"), &PingOutlineComponent::initialize),
    Method(Name("update"), &PingOutlineComponent::update),
  };
  DynamicComponent::registerDerivedType<PingOutlineComponent>()
    .setFields(fields)
    .setMethods(methods);
}
 
void EchoSounder::PingOutlineComponent::initialize(Context * context)
{
  this->context = context;
  this->dataSystem = ExtensionRegistry::getExtensionSystem<DataSetSystem>(context);
 
  annotation[0] = context->store->createChildEntity("EchoConfigAnnotation", getContainer(), "Annotation0");
  annotation[1] = context->store->createChildEntity("EchoConfigAnnotation", getContainer(), "Annotation1");
 
  vesselCoordSys = context->store->createChildEntity("MeshPart", getContainer(), "CoordSys");
  setVertexColorMaterial(context, vesselCoordSys);
 
  boundingFrustum = context->store->createChildEntity("MeshPart", getContainer(), "Frustum");
  setVertexColorMaterial(context, boundingFrustum);
 
  axisAlignedBBox = context->store->createChildEntity("MeshPart", getContainer(), "AABB");
  setVertexColorMaterial(context, axisAlignedBBox);
 
  annoLineMesh = context->store->createChildEntity("MeshPart", getContainer(), "Annotation mesh");
  setAnnotationLineMaterial(context, annoLineMesh);
}
 
void EchoSounder::PingOutlineComponent::update()
{
  if (!this->dataSystem) return;
 
  auto dataRefComp = getComponent<DataRefComponent>();
  if (dataRefComp->data) {
    auto * dataComp = dataRefComp->data->getComponent<DataSetComponent>();
    auto & dataData = dataSystem->getData(dataComp);
    auto * groupComp = this->getComponent<BeamGroupComponent>();
    const auto & config = dataData.persistent->config;
 
    if ((hasChanged() || groupComp->hasChanged() || (configGen != dataData.configGen) || dataRefComp->hasChanged()) && (0 < config.beamCount))
    {
      configGen = dataData.configGen;
 
      auto depthMin = config.depthOffset;
      if (std::isfinite(depthStart)) {
        depthMin = std::max(depthMin, depthStart);
      }
      auto depthMax = config.depthOffset + config.sampleCount * config.depthStep;
      if (std::isfinite(depthRange)) {
        depthMax = std::min(depthMax, depthMin + depthRange);
      }
 
      MeshHandle mesh;
      if (groupComp->sane) {
        std::vector<glm::vec3> V;
        std::vector<uint32_t> indices;
 
        std::vector<float> directionX(groupComp->beams.size());
        std::vector<float> directionY(groupComp->beams.size());
        for (size_t i = 0; i < groupComp->beams.size(); i++) {
          const auto srcIx = groupComp->beams[i];
          directionX[i] = config.directionX[srcIx];
          directionY[i] = config.directionY[srcIx];
        }
 
        auto beamMinorClosed = groupComp->minorClosed;
        auto minorCount = groupComp->minorCount;
        auto majorCount = groupComp->majorCount;
 
        const auto srcMinNum = groupComp->minorCount;
        unsigned srcMinNumPadded = srcMinNum + (beamMinorClosed ? 1u : 0u);
 
        std::vector<uint32_t> beams(srcMinNumPadded);
        for (unsigned i = 0; i < srcMinNum; i++) {
          beams[i] = groupComp->beams[i];
        }
        if (beamMinorClosed) {
          beams[srcMinNum] = beams[0];
        }
 
        if (!flat) {
          inflateFans(directionX, directionY,
                      config.directionX, config.beamWidthX,
                      config.directionY, config.beamWidthY,
                      beams, groupComp->topology, srcMinNumPadded);
 
          //after inflation, we know we have at least 2 beams in each direction.
          minorCount = std::max(2u, srcMinNumPadded);
          majorCount = std::max(2u, majorCount);
 
          glm::quat rotation;
          glm::vec3 translation;
          getArrayToVesselTransform(rotation, translation, config.transducerAlpha, config.transducerOffset);
          buildBeamBundleOutline2(V, indices, context,
                                  rotation, translation,
                                  config.coordSys,
                                  directionX.data(), majorCount,
                                  directionY.data(), minorCount,
                                  depthMin, depthMax, false, individualBeams);
 
          for (uint32_t k = 0; k < 2; k++) {
            auto annoComp = annotation[k]->getComponent<AnnotationAxisComponent>();
            annoComp->strings.clear();
            annoComp->positions.clear();
            annoComp->setChanged();
          }
        }
        else if (groupComp->majorCount == 1) {
 
          if (groupComp->minorCount == 1) {
            //we only have one beam, it's given a width in the data visualization, so draw lines around the extent of the data
            createBeamExtentGeometry(V, indices, context, directionX, directionY,
                                     groupComp->minorCount, config);
          }
          else {
            //when we have multiple beams, data is only visualized between beams. So we draw line through center of beams.
            createBeamCenterGeometry(V, indices, context, directionX, directionY,
                                     individualBeams, groupComp->minorCount, config);
          }
 
        }
 
        createTickGeometryAndAnnotations(context, directionX, directionY, minorCount, majorCount, false, config);
 
        if (!indices.empty()) {
          mesh = context->meshManager->create();
          mesh->setPositions(V);
          mesh->setIndexes(indices);
          mesh->primitiveType = Cogs::PrimitiveType::LineList;
          mesh->setBounds(calculateBounds(mesh.operator->()));
        }
      }
 
      auto * meshComp = getComponent<MeshComponent>();
      meshComp->meshHandle = mesh;
      meshComp->setChanged();
 
      {
        float xMin = std::numeric_limits<float>::max();
        float xMax = -std::numeric_limits<float>::max();
        float yMin = std::numeric_limits<float>::max();
        float yMax = -std::numeric_limits<float>::max();
 
        for (auto b : groupComp->beams) {
          xMin = std::min(xMin, config.directionX[b]);
          xMax = std::max(xMax, config.directionX[b]);
          yMin = std::min(yMin, config.directionY[b]);
          yMax = std::max(yMax, config.directionY[b]);
        }
 
        glm::quat arrayOrientationVessel;
        glm::vec3 arrayPositionVessel;
        getArrayToVesselTransform(arrayOrientationVessel,
                                  arrayPositionVessel,
                                  config.transducerAlpha,
                                  config.transducerOffset);
 
        // --- Vessel coordsystem ----------------------------------------------
        {
          auto * coordsys_meshComp = vesselCoordSys->getComponent<MeshComponent>();
          coordsys_meshComp->meshHandle = showVesselCoordsys
                                        ? buildVesselSIMRADCoordsys(context,
                                                                    glm::quat(),
                                                                    glm::vec3(),
                                                                    100.f)
                                        : MeshHandle::NoHandle;
          coordsys_meshComp->setChanged();
        }
 
        // --- Beam bounding frustum -------------------------------------------
        {
          auto * beam_meshComp = boundingFrustum->getComponent<MeshComponent>();
          if (showBoundingFrustum) {
            glm::vec4 frustum[6];
            getBoundingFrustum(frustum,
                               arrayOrientationVessel,
                               arrayPositionVessel,
                               config.coordSys,
                               xMin, xMax, yMin, yMax, depthMin, depthMax);
            beam_meshComp->meshHandle = buildFrustumOutline(context, frustum);
          }
          else {
            beam_meshComp->meshHandle = MeshHandle::NoHandle;
          }
 
          beam_meshComp->setChanged();
        }
        // --- Beam bounding box -----------------------------------------------
        {
          auto * bbox_meshComp = axisAlignedBBox->getComponent<MeshComponent>();
          if (showAABB) {
            glm::vec3 bbmin, bbmax;
            getAxisAlignedBoundingBox(bbmin, bbmax,
                                      arrayOrientationVessel,
                                      arrayPositionVessel,
                                      config.coordSys,
                                      xMin, xMax, yMin, yMax, depthMin, depthMax);
            if (std::isfinite(verticalDepthMax)) {
              bbmin.z = std::max(bbmin.z, -verticalDepthMax);
              bbmax.z = std::max(bbmax.z, -verticalDepthMax);
            }
            bbox_meshComp->meshHandle = buildBoxOutline(context, bbmin, bbmax);
          }
          else {
            bbox_meshComp->meshHandle = MeshHandle::NoHandle;
          }
          bbox_meshComp->setChanged();
        }
      }
    }
  }
  else {
    if (dataRefComp->hasChanged()) {
      auto * meshComp = getComponent<MeshComponent>();
      meshComp->meshHandle = MeshHandle::NoHandle;
      meshComp->setChanged();
    }
  }
}
 
void EchoSounder::PingOutlineComponent::createTickGeometryAndAnnotations(Context* context,
                                                                         const std::vector<float>& directionX,
                                                                         const std::vector<float>& directionY,
                                                                         uint32_t minorCount, uint32_t majorCount,
                                                                         bool /*minorClosed*/,
                                                                         const Config& config)
{
  uint32_t beamCount = minorCount * majorCount;
  if (beamCount < 1) return;
 
  std::vector<glm::vec3> V;
  std::vector<uint32_t> indices;
 
  glm::quat rotation;
  glm::vec3 translation;
  getArrayToVesselTransform(rotation, translation, config.transducerAlpha, config.transducerOffset);
 
  std::vector<glm::vec3> dirs;
 
  if (beamCount == 1) {
    //if we only have one beam we draw it with an extent (see createBeamExtentGrid), so we need to create similar extent here
    dirs.resize(2);
    bool xDom = isXDominant(directionX, directionY); //even if we have just one beam, we use this function to get consistent behaviour for multiple places in code.
    dirs[0] = rotation *getBeamDir(config.coordSys,
                                   directionX[0] - (xDom ? 0.5f : 0.f)*widthScaleAlongship*config.beamWidthX[0],
                                   directionY[0] - (xDom ? 0.f : 0.5f)*widthScaleAthwartship*config.beamWidthY[0]);
    dirs[1] = rotation * getBeamDir(config.coordSys,
                                    directionX[0] + (xDom ? 0.5f : 0.f)*widthScaleAlongship*config.beamWidthX[0],
                                    directionY[0] + (xDom ? 0.f : 0.5f)*widthScaleAthwartship*config.beamWidthY[0]);
    minorCount = 2;
  }
  else {
    dirs.resize(beamCount);
    for (unsigned i = 0; i < beamCount; i++) {
      dirs[i] = rotation * getBeamDir(config.coordSys, directionX[i], directionY[i]);
    }
  }
 
  float minDistance = std::isfinite(depthStart) ? depthStart : config.depthOffset;
  float maxDistance = minDistance + (std::isfinite(depthRange) ? depthRange : config.sampleCount*config.depthStep);
 
  float minDepth = 0.f;
  float maxDepth = 0.f;
  switch (annotationType) {
  case AnnotationType::VerticalDepth :
  {
      minDepth = 1e-5f * maxDistance;
      maxDepth = 1e-5f * maxDistance;
      for (auto & d : dirs) {
        minDepth = glm::max(minDepth, -(translation.z + minDistance * d.z));
        maxDepth = glm::max(maxDepth, -(translation.z + maxDistance * d.z));
      }
      break;
    }
  case AnnotationType::Range :
   {
      minDepth = minDistance;
      maxDepth = maxDistance;
      break;
    }
  default:
    assert(false && "Uknown annotation type.");
    return;
  }
 
  auto v = std::max(1.f, (maxDepth - minDepth) / numTickMarks);
  auto s = std::log10(v);
  auto m = std::ceil(s);
  auto q = std::round(std::log2(10.f)*(s - m));
  auto depthStep = std::exp2(q)*std::pow(10.f, m);
  auto tickA = static_cast<size_t>(std::ceil(minDepth / depthStep));
  auto tickB = std::min(tickA + 1000u, static_cast<size_t>(std::floor(maxDepth / depthStep)));
 
  if (minorCount == 1 || majorCount == 1) {
    addAnnotations(V, indices, tickA, tickB, depthStep, dirs, translation, maxDistance, true, connectedTicks != ConnectedTicksMode::None);
  }
  else {
    if (connectedTicks == ConnectedTicksMode::Grid) {
      //we have a grid. Pick outer beams to draw connection lines, and then front beams to draw connection lines with annotation ticks and values
      std::vector<glm::vec3> outerDirection = getOuterAnnotationBeams(dirs, minorCount, majorCount, annotationPosition);
      addAnnotations(V, indices, tickA, tickB, depthStep, outerDirection, translation, maxDistance, false, true);
    }
 
    std::vector<glm::vec3> frontDirection = getFrontAnnotationBeams(dirs, minorCount, majorCount, annotationPosition);
    addAnnotations(V, indices, tickA, tickB, depthStep, frontDirection, translation, maxDistance, true, connectedTicks != ConnectedTicksMode::None);
  }
 
 
  MeshHandle mesh;
  auto * annoMeshComp = annoLineMesh->getComponent<MeshComponent>();
 
  if (!indices.empty()) {
    mesh = context->meshManager->create();
    mesh->setPositions(V);
    mesh->setIndexes(indices);
    mesh->primitiveType = Cogs::PrimitiveType::LineList;
    mesh->setBounds(calculateBounds(mesh.operator->()));
  }
 
  annoMeshComp->meshHandle = mesh;
  annoMeshComp->setChanged();
 
}
 
void EchoSounder::PingOutlineComponent::addAnnotations(std::vector<glm::vec3> &V,
                                                       std::vector<uint32_t> &indices,
                                                       size_t tickA, size_t tickB, float depthStep,
                                                       const std::vector<glm::vec3> &dirs,
                                                       const glm::vec3 & translation,
                                                       float maxDistance, bool showTicks, bool connectTicks)
{
  AnnotationAxisComponent* annoComp[2];
  auto tickDir = dirs.back() - dirs.front();
  assert(dirs.size() > 1 && tickDir != glm::vec3(0, 0, 0));
  tickDir = tickLength * depthStep*glm::normalize(tickDir);
 
  for (size_t k = 0; k < 2; k++) {
    annoComp[k] = annotation[k]->getComponent<AnnotationAxisComponent>();
    annoComp[k]->viewDependentAnchor = true;
    annoComp[k]->viewDependentAnchorReference = (k != 0 ? -1.f : 1.f)*tickDir;
    annoComp[k]->strings.clear();
    annoComp[k]->positions.clear();
    annoComp[k]->setChanged();
  }
 
  for (size_t t = tickA; t <= tickB; t++) {
    auto offset = static_cast<uint32_t>(V.size());
 
    float d = -(t*depthStep);
 
    unsigned numCreatedVertices = 0;
 
    bool first = true;
    bool qInside = false;
    glm::vec3 q;
    for (unsigned i = 0; i < dirs.size(); i++) {
      //find corresponding point for beam which has the desired depth. For vertical depths, this point may be between beams.
      switch (annotationType) {
      case AnnotationType::VerticalDepth:
      {
        // Almost horizontal line, skip.
        if (std::abs(dirs[i].z) < 1e-5) continue;
 
        // Intersection of ray and z=depth plane
        auto tt = d / dirs[i].z;
        auto p = tt * dirs[i];
 
        // skip lines where intersection is found traversing the beam backwards
        if (tt < 0) continue;
 
        // Check if point is further away than maxDistance.
        bool pInside = tt < maxDistance;
        if ((first == false) && (pInside != qInside)) {
 
          // One point too far away and one closer than maxDistance.
          // We insert the intersection between the line segment [p,q] and a sphere of radius maxDistance,
          //
          //   <p + t(q-p), p + t(q-p)> = lengthB^2
          //   <p,p> + 2<p,q-p>t + <q-p,q-p>t^2 = lengthB^2
          //   A t^2 + B t + C = 0,
          //
          // where A = <p,p>, B=2<p,q-p>, and C=<p,p>-lengthB^2.
          //
          // We solve it with the quadratic formula and pick the first solution in [0,1].
          auto ttt = 0.5f;
          auto pq = q - p;
          auto a = glm::dot(pq, pq);
          if (1e-5*maxDistance <= a) {
            auto b = 2.f*glm::dot(p, pq);
            auto c = glm::dot(p, p) - maxDistance * maxDistance;
            auto t0 = (-b + glm::sqrt(b*b - 4 * a * c)) / (2 * a);
            auto t1 = (-b - glm::sqrt(b*b - 4 * a * c)) / (2 * a);
            if (0.f <= t0 && t0 <= 1.f) {
              ttt = t0;
            }
            else if (0.f <= t1 && t1 <= 1.f) {
              ttt = t1;
            }
          }
          V.push_back(translation + (1.f - ttt)*p + ttt * q); numCreatedVertices++;
        }
        if (pInside) {
          V.push_back(translation + p); numCreatedVertices++;
        }
 
        q = p;
        qInside = pInside;
        first = false;
        break;
      }
      case AnnotationType::Range:
      {
        if (d == 0) continue;
        V.push_back(translation - (dirs[i] * d)); numCreatedVertices++;
        break;
      }
      default: {
        assert(false && "Uknown annotation type");
      }
      }
    }
 
    if (connectTicks) {
      for (unsigned i = 0; i + 1 < numCreatedVertices; i++) {
        indices.push_back(offset + i);
        indices.push_back(offset + i + 1);
      }
    }
 
    if (showTicks) {
      std::stringstream sstream;
      // Add tick marks and annotations
      if (numCreatedVertices >= 2) {
        sstream.str("");
        sstream << -d << unit; //coordinate system has negative z as downwards, but we want to show positive values to user
        annoComp[0]->strings.push_back(sstream.str());
        annoComp[1]->strings.push_back(sstream.str());
 
        V.push_back(V[offset] - tickDir);
        indices.push_back(offset);
        indices.push_back(offset + numCreatedVertices);
        annoComp[0]->positions.push_back(V[offset] - 2.f*tickDir);
 
        V.push_back(V[offset + numCreatedVertices - 1] + tickDir);
        indices.push_back(offset + numCreatedVertices - 1);
        indices.push_back(offset + numCreatedVertices + 1);
        annoComp[1]->positions.push_back(V[offset + numCreatedVertices - 1] + 2.f*tickDir);
      }
    }
  }
}
 
 
void EchoSounder::PingOutlineComponent::createBeamCenterGeometry(std::vector<glm::vec3>& V,
                                                                 std::vector<uint32_t>& indices,
                                                                 Context* /*context*/,
                                                                 const std::vector<float>& directionX,
                                                                 const std::vector<float>& directionY,
                                                                 bool individualBeams,
                                                                 const uint32_t bN,
                                                                 const Config& config)
{
  if (bN < 1) return;
 
  glm::quat rotation;
  glm::vec3 translation;
  getArrayToVesselTransform(rotation, translation, config.transducerAlpha, config.transducerOffset);
 
  auto l0 = std::isfinite(depthStart) ? depthStart : config.depthOffset;
  auto l1 = l0 + (std::isfinite(depthRange) ? depthRange : config.sampleCount * config.depthStep);
 
  uint32_t offset = static_cast<uint32_t>(V.size());
  for (uint32_t b = 0; b < bN; b++) {
    auto d = rotation *getBeamDir(config.coordSys, directionX[b], directionY[b]);
    V.push_back(translation + l0*d);
    V.push_back(translation + l1*d);
  }
 
  for (uint32_t i = 0; i + 1 < bN; i++) {
    indices.push_back(offset + 2 * i + 0);          // Upper arc
    indices.push_back(offset + 2 * (i + 1) + 0);
    indices.push_back(offset + 2 * i + 1);          // Lower arc
    indices.push_back(offset + 2 * (i + 1) + 1);
  }
 
  //outer beams:
  indices.push_back(offset + 0);
  indices.push_back(offset + 1);
  indices.push_back(offset + 2 * (bN - 1) + 0);
  indices.push_back(offset + 2 * (bN - 1) + 1);
 
  if (individualBeams) { //inner beams
    for (uint32_t i = 1; i < bN - 1; ++i) {
      indices.push_back(offset + (2 * i));
      indices.push_back(offset + (2 * i) + 1);
    }
  }
 
 
}
 
void EchoSounder::PingOutlineComponent::createBeamExtentGeometry(std::vector<glm::vec3>& V,
                                                                 std::vector<uint32_t>& indices,
                                                                 Context* /*context*/,
                                                                 const std::vector<float>& directionX,
                                                                 const std::vector<float>& directionY,
                                                                 const uint32_t bN,
                                                                 const Config& config)
{
  if (bN < 1) return;
 
  glm::quat rotation;
  glm::vec3 translation;
  getArrayToVesselTransform(rotation, translation, config.transducerAlpha, config.transducerOffset);
 
  bool xDom = isXDominant(directionX, directionY);
 
 
  for (uint32_t b = 0; b < bN; b++) {
    uint32_t offset = static_cast<uint32_t>(V.size());
 
    auto d00 = rotation * getBeamDir(config.coordSys,
                                     directionX[b] - (xDom ? 0.5f : 0.f)*widthScaleAlongship*config.beamWidthX[b],
                                     directionY[b] - (xDom ? 0.f : 0.5f)*widthScaleAthwartship*config.beamWidthY[b]);
    auto d01 = rotation * getBeamDir(config.coordSys,
                                     directionX[b] + (xDom ? 0.5f : 0.f)*widthScaleAlongship*config.beamWidthX[b],
                                     directionY[b] + (xDom ? 0.f : 0.5f)*widthScaleAthwartship*config.beamWidthY[b]);
 
    auto l0 = std::isfinite(depthStart) ? depthStart : config.depthOffset;
    auto l1 = l0 + (std::isfinite(depthRange) ? depthRange : config.sampleCount * config.depthStep);
 
    V.push_back(translation + l0*d00);
    V.push_back(translation + l1*d00);
    V.push_back(translation + l0*d01);
    V.push_back(translation + l1*d01);
 
    indices.push_back(offset + 0);
    indices.push_back(offset + 1);
 
    indices.push_back(offset + 1);
    indices.push_back(offset + 3);
 
    indices.push_back(offset + 3);
    indices.push_back(offset + 2);
 
    indices.push_back(offset + 2);
    indices.push_back(offset + 0);
  }
}