otbRadiometricIndex.h

Go to the documentation of this file.

/*
 * Copyright (C) 2005-2024 Centre National d'Etudes Spatiales (CNES)
 *
 * This file is part of Orfeo Toolbox
 *
 *     https://www.orfeo-toolbox.org/
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#ifndef otbRadiometricIndex_h
#define otbRadiometricIndex_h
 
#include "itkVariableLengthVector.h"
#include "otbBandName.h"
#include <array>
#include <set>
#include <string>
#include <map>
#include <stdexcept>
 
using namespace otb::BandName;
 
namespace otb
{
namespace Functor
{
template <typename TInput, typename TOutput>
class RadiometricIndex
{
public:
  using InputType  = TInput;
  using PixelType  = itk::VariableLengthVector<InputType>;
  using OutputType = TOutput;
 
  using BandNameType = CommonBandNames;
 
  static constexpr size_t NumberOfBands = static_cast<size_t>(BandNameType::MAX);
 
  static constexpr double Epsilon = 0.0000001;
 
  // Necessary to be used as an abstract base class
  virtual ~RadiometricIndex() = default;
 
  RadiometricIndex(const std::set<BandNameType>& requiredBands) : m_RequiredBands(), m_BandIndices()
  {
    if (requiredBands.find(BandNameType::MAX) != requiredBands.end())
    {
      throw std::runtime_error("TBandNameEnum::MAX can not be used as a required band");
    }
 
    // Fill the required bands array
    m_RequiredBands.fill(false);
    m_BandIndices.fill(0);
 
    for (auto b : requiredBands)
    {
      m_RequiredBands[static_cast<size_t>(b)] = true;
    }
  }
 
  std::set<BandNameType> GetRequiredBands() const
  {
    std::set<BandNameType> resp;
    for (size_t i = 0; i < NumberOfBands; ++i)
    {
      if (m_RequiredBands[i])
      {
        resp.insert(static_cast<BandNameType>(i));
      }
    }
 
    return resp;
  }
 
  void SetBandIndex(BandNameType band, size_t index)
  {
    if (band == BandNameType::MAX)
    {
      throw std::runtime_error("Can not set index for CommandBandName::MAX");
    }
    m_BandIndices[static_cast<size_t>(band)] = index;
  }
 
  void SetBandsIndices(const std::map<BandNameType, size_t>& indicesMap)
  {
    for (auto it : indicesMap)
    {
      SetBandIndex(it.first, it.second);
    }
  }
 
  size_t GetBandIndex(BandNameType band) const
  {
    if (band == BandNameType::MAX)
    {
      throw std::runtime_error("Can not get index for CommandBandName::MAX");
    }
    return m_BandIndices[static_cast<size_t>(band)];
  }
 
  virtual TOutput operator()(const itk::VariableLengthVector<TInput>& input) const = 0;
 
protected:
  size_t UncheckedBandIndex(BandNameType band) const
  {
    assert(band != BandNameType::MAX && "Can not retrieve index for band CommandBandName::MAX");
    return m_BandIndices[static_cast<size_t>(band)];
  }
 
  double Value(BandNameType band, const itk::VariableLengthVector<TInput>& input) const
  {
    assert(m_RequiredBands[static_cast<size_t>(band)] && "Retrieving value for a band that is not in the required bands list");
    return static_cast<double>(input[UncheckedBandIndex(band) - 1]);
  }
 
private:
  // Explicitly disable default constructor
  RadiometricIndex() = delete;
 
  using RequiredBandsContainer = std::array<bool, NumberOfBands>;
  RequiredBandsContainer m_RequiredBands;
 
  using BandIndicesContainer = std::array<size_t, NumberOfBands>;
  BandIndicesContainer m_BandIndices;
};
 
} // namespace Functor
} // End namespace otb
 
#endif