mitkBeamformingSettings.h

Go to the documentation of this file.

/*============================================================================

The Medical Imaging Interaction Toolkit (MITK)

Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.

Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.

============================================================================*/

#ifndef MITK_BEAMFORMING_SETTINGS
#define MITK_BEAMFORMING_SETTINGS

#include <itkObject.h>
#include <itkMacro.h>
#include <mitkCommon.h>
#include <MitkPhotoacousticsAlgorithmsExports.h>

namespace mitk {
  class MITKPHOTOACOUSTICSALGORITHMS_EXPORT BeamformingSettings : public itk::Object
  {
  public:
    mitkClassMacroItkParent(BeamformingSettings, itk::Object);
    itkCloneMacro(Self);

    enum Apodization { Hamm, Hann, Box };

    enum BeamformingAlgorithm { DMAS, DAS, sDMAS };

    enum ProbeGeometry { Linear, Concave};

    itkGetConstMacro(PitchInMeters, float);
    itkGetConstMacro(SpeedOfSound, float);
    itkGetConstMacro(TimeSpacing, float);
    itkGetConstMacro(Angle, float);
    itkGetConstMacro(IsPhotoacousticImage, bool);
    itkGetConstMacro(TransducerElements, unsigned int);
    itkGetConstMacro(SamplesPerLine, unsigned int);
    itkGetConstMacro(ReconstructionLines, unsigned int);
    itkGetConstMacro(InputDim, const unsigned int*);
    itkGetConstMacro(UseGPU, bool);
    itkGetConstMacro(GPUBatchSize, unsigned int);
    itkGetConstMacro(ApodizationFunction, const float*);
    itkGetConstMacro(Apod, Apodization);
    itkGetConstMacro(ApodizationArraySize, int);
    itkGetConstMacro(Algorithm, BeamformingAlgorithm);
    itkGetConstMacro(ReconstructionDepth, float);
    itkGetConstMacro(Geometry, ProbeGeometry);
    itkGetConstMacro(ProbeRadius, float);
    itkGetConstMacro(ElementHeights, float*);
    itkGetConstMacro(ElementPositions, float*);
    itkGetConstMacro(HorizontalExtent, float);

    static bool SettingsChangedOpenCL(const BeamformingSettings::Pointer lhs, const BeamformingSettings::Pointer rhs)
    {
      return !((std::abs(lhs->GetAngle() - rhs->GetAngle()) < 0.01f) && // 0.01 degree error margin
        (lhs->GetApod() == rhs->GetApod()) &&
        (lhs->GetGeometry() == rhs->GetGeometry()) &&
        (std::abs(lhs->GetProbeRadius() - rhs->GetProbeRadius()) < 0.001f) &&
        (lhs->GetIsPhotoacousticImage() == rhs->GetIsPhotoacousticImage()) &&
        (std::abs(lhs->GetPitchInMeters() - rhs->GetPitchInMeters()) < 0.000001f) && // 0.0001 mm error margin
        (lhs->GetReconstructionLines() == rhs->GetReconstructionLines()) &&
        (lhs->GetSamplesPerLine() == rhs->GetSamplesPerLine()) &&
        (lhs->GetReconstructionDepth() == rhs->GetReconstructionDepth()) &&
        (std::abs(lhs->GetSpeedOfSound() - rhs->GetSpeedOfSound()) < 0.01f) &&
        (std::abs(lhs->GetTimeSpacing() - rhs->GetTimeSpacing()) < 0.00000000001f) && //0.01 ns error margin
        (lhs->GetTransducerElements() == rhs->GetTransducerElements()));
    }

    static Pointer New(float pitchInMeters,
      float speedOfSound,
      float timeSpacing,
      float angle,
      bool isPhotoacousticImage,
      unsigned int samplesPerLine,
      unsigned int reconstructionLines,
      unsigned int* inputDim,
      float reconstructionDepth,
      bool useGPU,
      unsigned int GPUBatchSize,
      Apodization apod,
      unsigned int apodizationArraySize,
      BeamformingAlgorithm algorithm,
      ProbeGeometry geometry,
      float probeRadius)
    {
      Pointer smartPtr = new BeamformingSettings(pitchInMeters,
        speedOfSound,
        timeSpacing,
        angle,
        isPhotoacousticImage,
        samplesPerLine,
        reconstructionLines,
        inputDim,
        reconstructionDepth,
        useGPU,
        GPUBatchSize,
        apod,
        apodizationArraySize,
        algorithm,
        geometry,
        probeRadius);
      smartPtr->UnRegister();
      return smartPtr;
    }

    unsigned short* GetMinMaxLines();

  protected:

    BeamformingSettings(float pitchInMeters,
      float speedOfSound,
      float timeSpacing,
      float angle,
      bool isPhotoacousticImage,
      unsigned int samplesPerLine,
      unsigned int reconstructionLines,
      unsigned int* inputDim,
      float reconstructionDepth,
      bool useGPU,
      unsigned int GPUBatchSize,
      Apodization apod,
      unsigned int apodizationArraySize,
      BeamformingAlgorithm algorithm,
      ProbeGeometry geometry,
      float probeRadius
    );

    ~BeamformingSettings() override;

    float m_PitchInMeters;

    float m_SpeedOfSound;

    float m_TimeSpacing; // [s]

    float m_Angle;

    bool m_IsPhotoacousticImage;

    unsigned int m_TransducerElements;

    unsigned int m_SamplesPerLine;

    unsigned int m_ReconstructionLines;

    const unsigned int* m_InputDim;

    float m_ReconstructionDepth;

    bool m_UseGPU;

    unsigned int m_GPUBatchSize;
    const float* m_ApodizationFunction;

    Apodization m_Apod;

    int m_ApodizationArraySize;

    BeamformingAlgorithm m_Algorithm;

    ProbeGeometry m_Geometry;

    float m_ProbeRadius;

    float *m_ElementHeights;

    float *m_ElementPositions;

    float m_HorizontalExtent;

    unsigned short* m_MinMaxLines;
  };
}
#endif //MITK_BEAMFORMING_SETTINGS