BeamGroupComponent.cpp

#include "BeamGroupComponent.h"
#include "Context.h"
#include "Types.h"
#include "ExtensionRegistry.h"
 
#include "DataSetComponent.h"
#include "DataRefComponent.h"
#include "../Systems/DataSetSystem.h"
 
using namespace Cogs::Core;
using namespace Cogs::Reflection;
using namespace Cogs::Core::EchoSounder;
 
void BeamGroupComponent::registerType()
{
 
  static constexpr EnumeratorDef enumerators[] = {
    { "SingleBeam", Topology::SingleBeam },
    { "VerticalPlane", Topology::VerticalPlane },
    { "TransversalPlane", Topology::TransversalPlane },
    { "ConeSector", Topology::ConeSector },
    { "Grid", Topology::Grid },
    { "Cone", Topology::Cone }
  };
  TypeDatabase::createType<Topology>().setEnumerators(enumerators);
 
  Field fields[] = {
    Field(Name("topology"), &BeamGroupComponent::topology),
    Field(Name("majorCount"), &BeamGroupComponent::majorCount),
    Field(Name("minorCount"), &BeamGroupComponent::minorCount),
    Field(Name("beams"), &BeamGroupComponent::beams)
  };
  Method methods[] = {
    Method(Name("initialize"), &BeamGroupComponent::initialize),
    Method(Name("update"), &BeamGroupComponent::update),
  };
  DynamicComponent::registerDerivedType<BeamGroupComponent>()
    .setFields(fields)
    .setMethods(methods);
}
 
void BeamGroupComponent::initialize(Context * context)
{
  this->context = context;
}
 
void BeamGroupComponent::update()
{
  auto * dataRefComp = getComponent<DataRefComponent>();
  DataSetSystem* dataSystem = nullptr;
  DataSetComponent* dataComp = nullptr;
  bool changed = false;
 
  if (!dataRefComp) goto insane;
  if (!dataRefComp->data) goto insane;
 
  dataComp = dataRefComp->data->getComponent<DataSetComponent>();
  if (!dataComp) goto insane;
 
  dataSystem = ExtensionRegistry::getExtensionSystem<DataSetSystem>(context);
  if (!dataSystem) goto insane;
  {
    auto& dataData = dataSystem->getData(dataComp);
 
    changed =
      (dataComp_ != dataComp_) || //FIXME philipb : Should be be dataComp_ != dataComp?
      (dataConfGen != dataData.configGen);
 
    if (!changed || hasChanged()) {
      // Check if something actually has changed.
      changed = changed || (majorCount != majorCount_);
      changed = changed || (minorCount != minorCount_);
      changed = changed || (beams.size() != beams_.size());
      if (!changed) {
        for (size_t i = 0; i < beams.size() && !changed; i++) {
          changed = changed || (beams[i] != beams_[i]);
        }
      }
    }
 
    if (changed) {
      gen++;
      dataComp_ = dataComp_;
      dataConfGen = dataData.configGen;
      majorCount_ = majorCount;
      minorCount_ = minorCount;
      beams_ = beams;
 
      if ((majorCount == 0) || (minorCount == 0)) goto insane;
 
      switch (topology)
      {
      case Cogs::Core::EchoSounder::Topology::SingleBeam:
        if ((majorCount != 1) || (minorCount != 1)) goto insane;
        minorClosed = false;
        break;
      case Cogs::Core::EchoSounder::Topology::VerticalPlane:
        if (majorCount != 1) goto insane;
        minorClosed = false;
        break;
      case Cogs::Core::EchoSounder::Topology::TransversalPlane:
        if (majorCount != 1) goto insane;
        minorClosed = false;
        break;
      case Cogs::Core::EchoSounder::Topology::ConeSector:
        if (majorCount != 1) goto insane;
        minorClosed = false;
        break;
      case Cogs::Core::EchoSounder::Topology::Grid:
        minorClosed = false;
        break;
      case Cogs::Core::EchoSounder::Topology::Cone:
        if (majorCount != 1) goto insane;
        minorClosed = true;
        break;
      default:
        assert(false && "Unhandled case");
      }
 
      const auto& config = dataData.persistent->config;
 
      if (majorCount * minorCount != beams.size()) goto insane;
      for (auto ix : beams) {
        if (config.beamCount <= ix) goto insane;
      }
      this->sane = true;
 
      directionX.resize(beams.size());
      directionY.resize(beams.size());
      minDirectionX = std::numeric_limits<float>::max();
      minDirectionY = std::numeric_limits<float>::max();
      maxDirectionX = -std::numeric_limits<float>::max();
      maxDirectionY = -std::numeric_limits<float>::max();
      maxBeamWidthX = -std::numeric_limits<float>::max();
      maxBeamWidthY = -std::numeric_limits<float>::max();
      for (size_t i = 0; i < beams.size(); i++) {
        directionX[i] = config.directionX[i];
        directionY[i] = config.directionY[i];
        maxDirectionX = glm::max(maxDirectionX, directionX[i]);
        minDirectionX = glm::min(minDirectionX, directionX[i]);
        maxDirectionY = glm::max(maxDirectionY, directionY[i]);
        minDirectionY = glm::min(minDirectionY, directionY[i]);
        maxBeamWidthX = glm::max(maxBeamWidthX, config.beamWidthX[i]);
        maxBeamWidthY = glm::max(maxBeamWidthY, config.beamWidthY[i]);
      }
 
      if (majorCount == 1) {
        // FIXME: SN90 probably requires different logic.
        minDirectionX -= 0.5f * maxBeamWidthX;
        maxDirectionX += 0.5f * maxBeamWidthX;
      }
      minDistance = config.depthOffset;
      maxDistance = minDistance + config.sampleCount * config.depthStep;
    }
    if (callback) {
      callback(context);
      callback = nullptr;
    }
    return;
  }
 
insane:
  this->sane = false;
  if (callback) {
    callback(context);
    callback = nullptr;
  }
}