AffineMatrixParameter.cpp

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2018 ISIS Rutherford Appleton Laboratory UKRI,
//   NScD Oak Ridge National Laboratory, European Spallation Source,
//   Institut Laue - Langevin & CSNS, Institute of High Energy Physics, CAS
// SPDX - License - Identifier: GPL - 3.0 +
#include "MantidDataObjects/AffineMatrixParameter.h"
 
namespace Mantid::DataObjects {
 
//----------------------------------------------------------------------------------------------
AffineMatrixParameter::AffineMatrixParameter(size_t outD, size_t inD) : m_affineMatrix(outD + 1, inD + 1) {
  m_isValid = false;
  m_affineMatrix.identityMatrix();
  size_t nx = m_affineMatrix.numRows();
  size_t ny = m_affineMatrix.numCols();
  // big chunk of memory holding the whole matrix
  m_rawMem = new coord_t[nx * ny];
  // array of pointers (one per column)
  m_rawMatrix = new coord_t *[nx];
  for (size_t i = 0; i < nx; i++)
    m_rawMatrix[i] = m_rawMem + (i * ny);
  // Copy into the raw matrix (for speed)
  copyRawMatrix();
}
 
//----------------------------------------------------------------------------------------------
AffineMatrixParameter::~AffineMatrixParameter() {
  // delete array of pointers to rows
  delete[] m_rawMatrix;
  m_rawMatrix = nullptr;
 
  // delete large mem block holding the matrix
  delete[] m_rawMem;
  m_rawMem = nullptr;
}
 
//----------------------------------------------------------------------------------------------
void AffineMatrixParameter::copyRawMatrix() {
  for (size_t x = 0; x < m_affineMatrix.numRows(); ++x)
    for (size_t y = 0; y < m_affineMatrix.numCols(); ++y)
      m_rawMatrix[x][y] = m_affineMatrix[x][y];
}
 
//----------------------------------------------------------------------------------------------
AffineMatrixType AffineMatrixParameter::getAffineMatrix() const { return m_affineMatrix; }
 
//----------------------------------------------------------------------------------------------
coord_t **AffineMatrixParameter::getRawMatrix() { return m_rawMatrix; }
 
//----------------------------------------------------------------------------------------------
std::string AffineMatrixParameter::getName() const { return AffineMatrixParameter::parameterName(); }
 
//----------------------------------------------------------------------------------------------
std::string AffineMatrixParameter::toXMLString() const {
  std::vector<coord_t> elements = this->m_affineMatrix.getVector();
  const size_t size = elements.size();
  std::string parameterValue;
 
  for (size_t i = 1; i <= size; i++) {
    std::stringstream sstream;
    sstream << elements[i - 1];
    parameterValue.append(sstream.str());
    sstream.clear();
    if (i % m_affineMatrix.numCols() == 0) {
      if (i != size) {
        parameterValue.append(";");
      }
    } else {
      parameterValue.append(",");
    }
  }
 
  return parameterXMLTemplate(parameterValue);
}
 
//----------------------------------------------------------------------------------------------
AffineMatrixParameter *AffineMatrixParameter::clone() const {
  return new AffineMatrixParameter(m_affineMatrix.numRows() - 1, m_affineMatrix.numCols() - 1);
}
 
//----------------------------------------------------------------------------------------------
bool AffineMatrixParameter::isValid() const { return m_isValid; }
 
//----------------------------------------------------------------------------------------------
// cppcheck-suppress operatorEqVarError
AffineMatrixParameter &AffineMatrixParameter::operator=(const AffineMatrixParameter &other) {
  if ((other.m_affineMatrix.numCols() != this->m_affineMatrix.numCols()) ||
      (other.m_affineMatrix.numRows() != this->m_affineMatrix.numRows())) {
    throw std::runtime_error("Cannot make assignemnts between "
                             "AffineMatrixParameter when the matrixes are of "
                             "different sizes.");
  }
  if (this != &other) {
    this->m_affineMatrix = other.m_affineMatrix;
    this->m_isValid = other.m_isValid;
    copyRawMatrix();
  }
  return *this;
}
 
//----------------------------------------------------------------------------------------------
AffineMatrixParameter::AffineMatrixParameter(const AffineMatrixParameter &other)
    : m_affineMatrix(other.m_affineMatrix) {
  m_isValid = other.m_isValid;
  size_t nx = m_affineMatrix.numRows();
  size_t ny = m_affineMatrix.numCols();
  m_rawMem = new coord_t[nx * ny];
  m_rawMatrix = new coord_t *[nx];
  for (size_t i = 0; i < nx; i++)
    m_rawMatrix[i] = m_rawMem + (i * ny);
  copyRawMatrix();
}
 
//----------------------------------------------------------------------------------------------
void AffineMatrixParameter::setMatrix(const AffineMatrixType &newMatrix) {
  if (newMatrix.numRows() != this->m_affineMatrix.numRows())
    throw std::runtime_error("setMatrix(): Number of rows must match!");
  if (newMatrix.numCols() != this->m_affineMatrix.numCols())
    throw std::runtime_error("setMatrix(): Number of columns must match!");
  m_affineMatrix = newMatrix;
  // Copy into the raw matrix (for speed)
  copyRawMatrix();
  this->m_isValid = true;
}
} // namespace Mantid::DataObjects