detail_image.hpp

#pragma once
 
#include <algorithm>
#include <cstddef>
#include <memory>
#include <new>
#include <stdexcept>
#include <system_error>
#include <utility>
 
#include "../_cexports/c_img.h"
 
#include "../global.hpp"
#include "../data_type.hpp"
 
#include "../_decl/decl_image.hpp"
#include "../_decl/decl_image_plane.hpp"
#include "../_decl/decl_device_factory.hpp"
 
namespace Cvb
{
 
  CVB_BEGIN_INLINE_NS
 
  inline std::unique_ptr<Image> Image::Load(const String &fileName)
  {
    return Internal::DoBoolCallObjectOut<Image>(
        [&](void *&handle) { return CVB_CALL_CAPI(LoadImageFileTyped(fileName.c_str(), handle)); });
  }
  inline std::unique_ptr<Image> Image::Load(const String &fileName) {…}
 
  inline std::unique_ptr<Image> Image::Create(int width, int height, int numPlanes, DataType dataType)
  {
    return Internal::DoBoolCallObjectOut<Image>([&](void *&handle) {
      return CVB_CALL_CAPI(CreateGenericImageDT(
          numPlanes, width, height, static_cast<CExports::cvbdatatype_t>(dataType.NativeDescriptor()), handle));
    });
  }
  inline std::unique_ptr<Image> Image::Create(int width, int height, int numPlanes, DataType dataType) {…}
 
  template <class RANGE>
  inline typename TypedRange<std::unique_ptr<Image>, ImagePlane, RANGE>::type Image::FromPlanes(MappingOption mapping,
                                                                                                const RANGE &planes)
  {
    auto rangeAdapter = MakeRangeAdapter<ImagePlane>(planes);
    std::vector<ImagePtr> images;
    images.reserve(rangeAdapter.Size());
    for (const auto &plane : planes)
      images.emplace_back(plane.Map());
    return FromImages(mapping, images);
  }
  inline typename TypedRange<std::unique_ptr<Image>, ImagePlane, RANGE>::type Image::FromPlanes(MappingOption mapping, {…}
 
  template <class... PLANES>
  inline typename VarArgRange<std::unique_ptr<Image>, ImagePlane &&, PLANES...>::type
  Image::FromPlanes(MappingOption mapping, PLANES &&...planes)
  {
    return FromImages(mapping, *planes.Map()...);
  }
  Image::FromPlanes(MappingOption mapping, PLANES &&...planes) {…}
 
  inline ImagePlane Image::Plane(int plane) const
  {
    if ((plane < 0) || (plane >= PlanesCount()))
      throw std::out_of_range("plane index out of range");
    return ImagePlane(plane, *this);
  }
  inline ImagePlane Image::Plane(int plane) const {…}
 
  inline std::vector<ImagePlane> Image::Planes() const noexcept
  {
    auto planesCount = PlanesCount();
    std::vector<ImagePlane> planes;
    for (int i = 0; i < planesCount; ++i)
      planes.push_back(Plane(i));
    return planes;
  }
  inline std::vector<ImagePlane> Image::Planes() const noexcept {…}
 
  inline std::vector<double> Image::GetPixel(Point2D<int> position) const
  {
    std::vector<double> pixelValues;
    auto planes = Planes();
    for (auto &plane : planes)
      pixelValues.push_back(plane.GetPixel(position));
 
    return pixelValues;
  }
  inline std::vector<double> Image::GetPixel(Point2D<int> position) const {…}
 
  inline void Image::Save(const String &fileName) const
  {
    std::unique_lock<std::mutex> lock(DeviceFactory::LockAnchor());
    if (!CVB_CALL_CAPI(WriteImageFileTyped(Handle(), fileName.c_str())))
      Utilities::SystemInfo::ThrowLastError();
  }
  inline void Image::Save(const String &fileName) const {…}
 
  inline void Image::Save(const String &fileName, double quality) const
  {
    std::unique_lock<std::mutex> lock(DeviceFactory::LockAnchor());
    if (!CVB_CALL_CAPI(WriteLossyImageFileTyped(Handle(), quality, fileName.c_str())))
      Utilities::SystemInfo::ThrowLastError();
  }
  inline void Image::Save(const String &fileName, double quality) const {…}
 
  inline std::unique_ptr<Image> Image::Map(Rect<int> sourceRect, Size2D<int> targetSize) const
  {
    return Internal::DoBoolCallObjectOut<Image>([&](void *&img) {
      return CVB_CALL_CAPI(CreateImageMap(
          Handle(), static_cast<CExports::cvbdim_t>(sourceRect.Left()),
          static_cast<CExports::cvbdim_t>(sourceRect.Top()), static_cast<CExports::cvbdim_t>(sourceRect.Right()),
          static_cast<CExports::cvbdim_t>(sourceRect.Bottom()), static_cast<CExports::cvbdim_t>(targetSize.Width()),
          static_cast<CExports::cvbdim_t>(targetSize.Height()), img));
    });
  }
  inline std::unique_ptr<Image> Image::Map(Rect<int> sourceRect, Size2D<int> targetSize) const {…}
 
  inline std::unique_ptr<Image> Image::Map(RotationMap rotation) const
  {
    return Internal::DoBoolCallObjectOut<Image>([&](void *&img) {
      return CVB_CALL_CAPI(CreateRotatedImageMap(Handle(), static_cast<CExports::TVPATRotation>(rotation), img));
    });
  }
  inline std::unique_ptr<Image> Image::Map(RotationMap rotation) const {…}
 
  inline std::unique_ptr<Image> Image::Clone() const
  {
    return Internal::DoBoolCallObjectOut<Image>(
        [&](void *&img) { return CVB_CALL_CAPI(CreateDuplicateImageEx(Handle(), img)); });
  }
  inline std::unique_ptr<Image> Image::Clone() const {…}
 
  CVB_END_INLINE_NS
 
}  // namespace Cvb