sopt::utilities Namespace Reference

Classes
struct	bad_lexical_cast
	Exception to be thrown by lexical_cast (below) More...

Functions
Image	read_tiff (std::string const &name)
	Reads tiff image. More...
void	write_tiff (Image<> const &image, std::string const &filename)
	Writes a tiff greyscale file. More...
template<typename T , typename U >
T	lexical_cast (const U &in)
	Convert between any types via stringstream. More...
template<typename T = std::string>
std::vector< T >	split (std::string s, const std::string &sep)
	Split a string on a specified delimiter with optional cast to another type. More...
template<typename T >
std::vector< float >	imageToFloat (sopt::Vector< T > const &image)
template<typename T >
sopt::Vector< T >	floatToImage (std::vector< float > const &float_image)
template<typename T >
Vector< T > &	get_wavelet_basis_coefficients (Vector< T > &coeffs, const t_uint basis_index, const t_uint size)
	return wavelet basis coefficients from a dictionary More...
template<typename T >
Vector< T > &	get_wavelet_levels_1d (Vector< T > &coeffs, const t_uint level, const t_uint size)
	return wavelet basis coefficients for a given level and below (1d case) More...
template<typename T >
Vector< T > &	get_wavelet_levels (Vector< T > &coeffs, const t_uint level, const t_uint rows, const t_uint cols)
	return wavelet basis coefficients for a given level and below (2d case) More...
template<typename T >
Vector< T > &	get_wavelet_low_high_pass (Vector< T > &coeffs, const t_uint level, const t_uint rows, const t_uint cols)
	return wavelet basis coefficients low pass (rows) and high pass (cols) for a given level More...
template<typename T >
Vector< T > &	get_wavelet_high_high_pass (Vector< T > &coeffs, const t_uint level, const t_uint rows, const t_uint cols)
	return wavelet basis coefficients high pass (rows) and high pass (cols) for a given level More...
template<typename T >
Vector< T > &	get_wavelet_high_low_pass (Vector< T > &coeffs, const t_uint level, const t_uint rows, const t_uint cols)
	return wavelet basis coefficients high pass (rows) and high pass (cols) for a given level More...
template<typename T >
Vector< T > &	get_wavelet_low_low_pass (Vector< T > &coeffs, const t_uint level, const t_uint rows, const t_uint cols)
	return wavelet basis coefficients high pass (rows) and high pass (cols) for a given level More...
template<typename T >
Vector< T > &	get_wavelet_high_pass_1d (Vector< T > &coeffs, const t_uint level, const t_uint size)
	return 1d high pass filter for a given level of a wavelet More...

Function Documentation

floatToImage()

template<typename T >

sopt::Vector<T> sopt::utilities::floatToImage

(

std::vector< float > const &

float_image

)

Definition at line 83 of file utilities.h.

                                                                {
  sopt::Vector<T> image(float_image.size());
  for (int i = 0; i < float_image.size(); i++) {
    if constexpr(std::is_same<T, t_complex>::value)
    {
      image[i] = t_complex(float_image[i], 0);
    }
    else
    {
      image[i] = static_cast<T>(float_image[i]);
    }
  }
  return image;
}

get_wavelet_basis_coefficients()

template<typename T >

Vector< T > & sopt::utilities::get_wavelet_basis_coefficients	(	Vector< T > &	coeffs,
		const t_uint	basis_index,
		const t_uint	size
	)

return wavelet basis coefficients from a dictionary

Definition at line 105 of file wavelets.h.

                                                             {
  assert(coeffs.size() > basis_index * size);
  return coeffs.segment(basis_index * size, size);
}

get_wavelet_high_high_pass()

template<typename T >

Vector< T > & sopt::utilities::get_wavelet_high_high_pass	(	Vector< T > &	coeffs,
		const t_uint	level,
		const t_uint	rows,
		const t_uint	cols
	)

return wavelet basis coefficients high pass (rows) and high pass (cols) for a given level

Definition at line 139 of file wavelets.h.

                                                         {
  auto const Nx = rows >> level;  // bitshift to divide by 2^level
  auto const Ny = cols >> level;
  const Matrix<T> signal =
      Matrix<T>::Map(get_wavelet_levels(coeffs, level, rows, cols).data(), Nx, Ny);
  return Vector<T>::Map(signal.bottomRightCorner(signal.rows() / 2, signal.cols() / 2).data(),
                        signal.size() / 4);
}

References cols, get_wavelet_levels(), and rows.

get_wavelet_high_low_pass()

template<typename T >

Vector< T > & sopt::utilities::get_wavelet_high_low_pass	(	Vector< T > &	coeffs,
		const t_uint	level,
		const t_uint	rows,
		const t_uint	cols
	)

return wavelet basis coefficients high pass (rows) and high pass (cols) for a given level

Definition at line 149 of file wavelets.h.

                                                        {
  auto const Nx = rows >> level;  // bitshift to divide by 2^level
  auto const Ny = cols >> level;
  const Matrix<T> signal =
      Matrix<T>::Map(get_wavelet_levels(coeffs, level, rows, cols).data(), Nx, Ny);
  return Vector<T>::Map(signal.bottomLeftCorner(signal.rows() / 2, signal.cols() / 2).data(),
                        signal.size() / 4);
}

References cols, get_wavelet_levels(), and rows.

get_wavelet_high_pass_1d()

template<typename T >

Vector< T > & sopt::utilities::get_wavelet_high_pass_1d	(	Vector< T > &	coeffs,
		const t_uint	level,
		const t_uint	size
	)

return 1d high pass filter for a given level of a wavelet

Definition at line 116 of file wavelets.h.

                                                                                              {
  auto const N = static_cast<t_uint>(coeffs.size()) >> level;  // bitshift to divide by 2^level
  return get_wavelet_levels(coeffs, level, size).tail(N / 2);
}

References get_wavelet_levels(), and N.

get_wavelet_levels()

template<typename T >

Vector< T > & sopt::utilities::get_wavelet_levels	(	Vector< T > &	coeffs,
		const t_uint	level,
		const t_uint	rows,
		const t_uint	cols
	)

return wavelet basis coefficients for a given level and below (2d case)

Definition at line 121 of file wavelets.h.

                                                 {
  const Matrix<T> signal = Matrix<T>::Map(coeffs.data(), rows, cols);
  auto const Nx = static_cast<t_uint>(signal.rows()) >> level;  // bitshift to divide by 2^level
  auto const Ny = static_cast<t_uint>(signal.cols()) >> level;
  return Vector<T>::Map(signal.topLeftCorner(Nx, Ny).data(), Nx * Ny);
}

References cols, and rows.

Referenced by get_wavelet_high_high_pass(), get_wavelet_high_low_pass(), get_wavelet_high_pass_1d(), get_wavelet_low_high_pass(), and get_wavelet_low_low_pass().

get_wavelet_levels_1d()

template<typename T >

Vector< T > & sopt::utilities::get_wavelet_levels_1d	(	Vector< T > &	coeffs,
		const t_uint	level,
		const t_uint	size
	)

return wavelet basis coefficients for a given level and below (1d case)

Definition at line 111 of file wavelets.h.

                                                                                           {
  auto const N = static_cast<t_uint>(coeffs.size()) >> level;  // bitshift to divide by 2^level
  return coeffs.head(N);
}

References N.

get_wavelet_low_high_pass()

template<typename T >

Vector< T > & sopt::utilities::get_wavelet_low_high_pass	(	Vector< T > &	coeffs,
		const t_uint	level,
		const t_uint	rows,
		const t_uint	cols
	)

return wavelet basis coefficients low pass (rows) and high pass (cols) for a given level

Definition at line 129 of file wavelets.h.

                                                        {
  auto const Nx = rows >> level;  // bitshift to divide by 2^level
  auto const Ny = cols >> level;
  const Matrix<T> signal =
      Matrix<T>::Map(get_wavelet_levels(coeffs, level, rows, cols).data(), Nx, Ny);
  return Vector<T>::Map(signal.topRightCorner(signal.rows() / 2, signal.cols() / 2).data(),
                        signal.size() / 4);
}

References cols, get_wavelet_levels(), and rows.

get_wavelet_low_low_pass()

template<typename T >

Vector< T > & sopt::utilities::get_wavelet_low_low_pass	(	Vector< T > &	coeffs,
		const t_uint	level,
		const t_uint	rows,
		const t_uint	cols
	)

return wavelet basis coefficients high pass (rows) and high pass (cols) for a given level

Definition at line 159 of file wavelets.h.

                                                       {
  auto const Nx = rows >> level;  // bitshift to divide by 2^level
  auto const Ny = cols >> level;
  const Matrix<T> signal =
      Matrix<T>::Map(get_wavelet_levels(coeffs, level, rows, cols).data(), Nx, Ny);
  return Vector<T>::Map(signal.topLeftCorner(signal.rows() / 2, signal.cols() / 2).data(),
                        signal.size() / 4);
}

References cols, get_wavelet_levels(), and rows.

imageToFloat()

template<typename T >

std::vector<float> sopt::utilities::imageToFloat

(

sopt::Vector< T > const &

image

)

Definition at line 67 of file utilities.h.

                                                          {
  std::vector<float> float_image(image.size());
  for (int i = 0; i < image.size(); i++) {
    if constexpr(std::is_same<T, t_complex>::value)
    {
      float_image[i] = image[i].real();
    }
    else
    {
      float_image[i] = static_cast<float>(image[i]);
    }
  }
  return float_image;
}

Referenced by sopt::ONNXDifferentiableFunc< SCALAR >::function(), and sopt::ONNXDifferentiableFunc< SCALAR >::gradient().

lexical_cast()

template<typename T , typename U >

T sopt::utilities::lexical_cast

(

const U &

in

)

Convert between any types via stringstream.

Definition at line 24 of file utilities.h.

                            {
  try {
    std::stringstream ss;
    ss << in;
    T out;
    ss >> out;
    return out;
  } catch(const std::exception& e) {
    throw bad_lexical_cast(e.what());
  }
}

read_tiff()

sopt::Image sopt::utilities::read_tiff

(

std::string const &

filename

)

Reads tiff image.

Definition at line 38 of file utilities.cc.

                                             {
  SOPT_MEDIUM_LOG("Reading image file {} ", filename);
  TIFF *tif = TIFFOpen(filename.c_str(), "r");
  if (tif == nullptr) SOPT_THROW("Could not open file ") << filename;
 
  uint32_t width;
  uint32_t height;
  uint32_t t;
 
  TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, &width);
  TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &height);
  TIFFGetField(tif, TIFFTAG_PHOTOMETRIC, &t);
  SOPT_LOW_LOG("- image size {}, {} ", width, height);
  Image<> result = Image<>::Zero(height, width);
 
  uint32_t *raster = static_cast<uint32_t *>(_TIFFmalloc(width * height * sizeof(uint32_t)));
  if (raster == nullptr) SOPT_THROW("Could not allocate memory to read file ") << filename;
  if (TIFFReadRGBAImage(tif, width, height, raster, 0) == 0)
    SOPT_THROW("Could not read file ") << filename;
 
  uint32_t *pixel = raster;
  for (uint32_t i(0); i < height; ++i)
    for (uint32_t j(0); j < width; ++j, ++pixel) result(i, j) = convert_to_greyscale(*pixel);
 
  _TIFFfree(raster);
 
  TIFFClose(tif);
  return result;
}

References SOPT_LOW_LOG, SOPT_MEDIUM_LOG, and SOPT_THROW.

Referenced by main(), and sopt::tools::read_standard_tiff().

split()

template<typename T = std::string>

std::vector<T> sopt::utilities::split	(	std::string	s,
		const std::string &	sep
	)

Split a string on a specified delimiter with optional cast to another type.

Definition at line 38 of file utilities.h.

                                                      {
  std::vector<T> rtn;
  while (true) {
    const size_t delim_pos = s.find(sep);
    if (delim_pos == std::string::npos)  break;
    const std::string sub = s.substr(0, delim_pos);
    if (sub.length()) {
      if constexpr(std::is_same<T, std::string>::value) {
        rtn.push_back(sub);
      }
      else {
        rtn.push_back(lexical_cast<T>(sub));
      }
    }
    s.replace(0, delim_pos+1, "");
  }
  // check for trailing component
  if (s.length()) {
    if constexpr(std::is_same<T, std::string>::value) {
      rtn.push_back(s);
    }
    else {
      rtn.push_back(lexical_cast<T>(s));
    }
  }
  return rtn;
}

write_tiff()

void sopt::utilities::write_tiff	(	Image<> const &	image,
		std::string const &	filename
	)

Writes a tiff greyscale file.

Definition at line 68 of file utilities.cc.

                                                                 {
  SOPT_MEDIUM_LOG("Writing image file {} ", filename);
  SOPT_LOW_LOG("- image size {}, {} ", image.rows(), image.cols());
  TIFF *tif = TIFFOpen(filename.c_str(), "w");
  if (tif == nullptr) SOPT_THROW("Could not open file ") << filename;
 
  uint32_t const width = image.cols();
  uint32_t const height = image.rows();
 
  SOPT_TRACE("Allocating buffer");
  std::vector<uint32_t> raster(width * height);
 
  TIFFSetField(tif, TIFFTAG_IMAGEWIDTH, width);
  TIFFSetField(tif, TIFFTAG_IMAGELENGTH, height);
  TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, sizeof(decltype(raster)::value_type));
  TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, 8);
  TIFFSetField(tif, TIFFTAG_ROWSPERSTRIP, height);
  TIFFSetField(tif, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
  TIFFSetField(tif, TIFFTAG_COMPRESSION, COMPRESSION_LZW);
  TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_RGB);
  TIFFSetField(tif, TIFFTAG_ORIENTATION, ORIENTATION_BOTLEFT);
 
  SOPT_TRACE("Initializing buffer");
  auto pixel = raster.begin();
  for (uint32_t i(0); i < height; ++i)
    for (uint32_t j(0); j < width; ++j, ++pixel) *pixel = convert_from_greyscale(image(i, j));
 
  SOPT_TRACE("Writing strip");
  TIFFWriteEncodedStrip(tif, 0, raster.data(), width * height * sizeof(decltype(raster)::value_type));
 
  TIFFWriteDirectory(tif);
  SOPT_TRACE("Closing tif");
  TIFFClose(tif);
  SOPT_TRACE("Freeing raster");
}

References SOPT_LOW_LOG, SOPT_MEDIUM_LOG, SOPT_THROW, and SOPT_TRACE.

Referenced by main(), and TEST_CASE().