mlTSubImageVariant.h

Go to the documentation of this file.

/*************************************************************************************
**
** Copyright 2022, MeVis Medical Solutions AG
**
** The user may use this file in accordance with the license agreement provided with
** the Software or, alternatively, in accordance with the terms contained in a
** written agreement between the user and MeVis Medical Solutions AG.
**
** For further information use the contact form at https://www.mevislab.de/contact
**
**************************************************************************************/
 
#pragma once
 
#include "mlInitSystemML.h"
#include "mlTSubImage.h"
 
#include <variant>
#include <array>
 
namespace ml
{
#ifndef DOXYGEN_SHOULD_SKIP_THIS
  /*
   * This logs to the MeVisLab console a fatal error that the input- and output types are different.
   */
  void MLEXPORT logFatalErrorMessageNotEqualTypes(const char *function, const MLDataType &inputType,
                                                  const MLDataType &outputType);
 
  /*
   * This logs to the MeVisLab console a fatal error that the given type is not supported.
   */
  void MLEXPORT logFatalErrorMessageNotSupportedType(const char *function,
                                                     const MLDataType &inputType);
 
 
  template <typename... T>
  using TSubImageVariant = std::variant<TSubImage<T>...>;
 
  template <typename T> struct TSubImagePair
  {
    TSubImage<T> output;
    TSubImage<T> input;
  };
 
  template <typename... T>
  using TSubImageVariantPair = std::variant<TSubImagePair<T>...>;
 
 
  template <std::size_t N, typename T>
  using TSubImageArray = std::array<TSubImage<T>, N>;
 
  template <std::size_t N, typename ...T>
  using TSubImageVariantArray = std::variant<TSubImageArray<N, T>...>;
 
 
  template <std::size_t N, typename T>
  struct TSubImageArrayPair
  {
    TSubImage<T> output;
    std::array<TSubImage<T>, N> inputs;
  };
 
  template <std::size_t N, typename... T>
  using TSubImageVariantArrayPair = std::variant<TSubImageArrayPair<N, T>...>;
 
 
 
  /*
   * A set of internal helper function to generate different kinds of TSubImageVariants.
   */
 
  namespace detail
  {
    // -----------------------------------------------------------------------------------------
 
    template <typename T>
    auto createTSubImageVariantImpl(const SubImage* subImage)
    {
      logFatalErrorMessageNotSupportedType(__FUNCTION__, subImage->getDataType());
      return T{};
    }
 
    template <typename T, typename U, typename... V>
    auto createTSubImageVariantImpl(const SubImage* subImage)
    {
      static_assert(!std::is_same_v<std::int8_t, U>, "The type std::int8_t/signed char is not supported by the "
                                                     "ML type system. Please use MLint8 instead!");
      if (subImage->getDataType() == TypeTraits<U>::getDataType())
      {
        return T{TSubImage<U>(*subImage)};
      }
      return createTSubImageVariantImpl<T, V...>(subImage);
    }
 
    // -----------------------------------------------------------------------------------------
 
    template <typename T, std::size_t... N>
    auto createTSubImageArrayImpl(const SubImage *subImages, std::index_sequence<N...>)
    {
      return std::array<TSubImage<T>, sizeof...(N)>{TSubImage<T>(subImages[N])...};
    }
 
    template <std::size_t N, typename T>
    auto createTSubImageArray(const SubImage *inputs)
    {
      return TSubImageArray<N, T>{createTSubImageArrayImpl<T>(inputs, std::make_index_sequence<N>())};
    }
 
    // -----------------------------------------------------------------------------------------
 
    template <std::size_t N, typename T>
    auto createTSubImageArrayPair(SubImage &output, const SubImage *inputs)
    {
      return TSubImageArrayPair<N, T>{TSubImage<T>(output),
                                  createTSubImageArrayImpl<T>(inputs, std::make_index_sequence<N>())};
    }
 
    // -----------------------------------------------------------------------------------------
 
    template <typename T, std::size_t N>
    auto createTSubImageVariantArrayImpl(const SubImage *inputs)
    {
      logFatalErrorMessageNotSupportedType(__FUNCTION__, inputs[0].getDataType());
      return T{};
    }
 
    template <typename T, std::size_t N, typename U, typename... V>
    auto createTSubImageVariantArrayImpl(const SubImage *inputs)
    {
      static_assert(!std::is_same_v<std::int8_t, U>,
                    "The type std::int8_t/signed char is not supported by the "
                    "ML type system. Please use MLint8 instead!");
 
      if (inputs[0].getDataType() == TypeTraits<U>::getDataType())
      {
        return T{createTSubImageArray<N, U>(inputs)};
      }
      return createTSubImageVariantArrayImpl<T, N, V...>(inputs);
    }
 
    // -----------------------------------------------------------------------------------------
 
    template <typename T, std::size_t N>
    auto createTSubImageVariantArrayPairImpl(SubImage &output, const SubImage *inputs)
    {
      logFatalErrorMessageNotSupportedType(__FUNCTION__, output.getDataType());
      return T{};
    }
 
    template <typename T, std::size_t N, typename U, typename... V>
    auto createTSubImageVariantArrayPairImpl(SubImage &output, const SubImage *inputs)
    {
      static_assert(!std::is_same_v<std::int8_t, U>, "The type std::int8_t/signed char is not supported by the "
                                                     "ML type system. Please use MLint8 instead!");
 
      if (output.getDataType() == TypeTraits<U>::getDataType())
      {
        return T{createTSubImageArrayPair<N, U>(output, inputs)};
      }
      return createTSubImageVariantArrayPairImpl<T, N, V...>(output, inputs);
    }
 
    // -----------------------------------------------------------------------------------------
 
    template <typename T>
    auto createTSubImageVariantPairImpl(SubImage &output, const SubImage*)
    {
      logFatalErrorMessageNotSupportedType(__FUNCTION__, output.getDataType());
      return T{};
    }
 
    template <typename T, typename U, typename... V>
    auto createTSubImageVariantPairImpl(SubImage &output, const SubImage* input)
    {
      static_assert(!std::is_same_v<std::int8_t, U>,
                    "The type std::int8_t/signed char is not supported by the "
                    "ML type system. Please use MLint8 instead!");
 
      if (output.getDataType() == TypeTraits<U>::getDataType())
      {
        return T{TSubImagePair<U>{output, *input}};
      }
      return createTSubImageVariantPairImpl<T, V...>(output, input);
    }
    // -----------------------------------------------------------------------------------------
  } // namespace detail
 
 
  /* The following comprises a list of commonly used types.
   
     Do not make a preprocessor macros from them, as many refactoring tools
     cannot analyze macros!
 
    List of supported integral types:
      MLuint8, MLint8, MLuint16, MLint16, MLuint32, MLint32, MLuint64, MLint64
 
    List of supported scalar types.
      MLuint8, MLint8, MLuint16, MLint16, MLuint32, MLint32, MLuint64, MLint64, MLfloat, MLdouble
 
    List of supported standard types
      MLuint8, MLint8, MLuint16, MLint16, MLuint32, MLint32, MLuint64, MLint64,
      MLfloat, MLdouble, std::complex<MLfloat>, std::complex<double>, Vector2f,
      Vector2d, Vector3f, Vector3d, Vector6f, Vector6d, Matrix2f, Matrix2d, Matrix3f, Matrix3d
 
  */
 
#endif // DOXYGEN_SHOULD_SKIP_THIS
 
  template <typename... T>
  TSubImageVariant<T...> createTSubImageVariant(const SubImage* subImage)
  {
    return detail::createTSubImageVariantImpl<TSubImageVariant<T...>, T...>(subImage);
  }
 
 
  template <typename... T>
  TSubImageVariantPair<T...> createTSubImageVariantPair(SubImage &output, const SubImage* input)
  {
    return detail::createTSubImageVariantPairImpl<TSubImageVariantPair<T...>, T...>(output, input);
  }
 
 
  template <std::size_t N, typename... T>
  TSubImageVariantArray<N, T...> createTSubImageVariantArray(const SubImage* inputs)
  {
    return detail::createTSubImageVariantArrayImpl<TSubImageVariantArray<N, T...>, N, T...>(inputs);
  }
 
 
  template <std::size_t N, typename... T>
  TSubImageVariantArrayPair<N, T...> createTSubImageVariantArrayPair(SubImage &output,
                                                             const SubImage *inputs)
  {
    TSubImageVariantArrayPair<N, T...> result;
 
    for (std::size_t i = 0; i < N; ++i)
    {
      if (output.getDataType() != inputs[i].getDataType())
      {
        logFatalErrorMessageNotEqualTypes(__FUNCTION__, inputs[0].getDataType(),
                                          output.getDataType());
        return result;
      }
    }
 
    result = detail::createTSubImageVariantArrayPairImpl<TSubImageVariantArrayPair<N, T...>, N, T...>(
        output, inputs);
 
    return result;
  }
 
 
} // namespace ml