/** Determinant of matrix */
double matrix<double>::determinant(){
matrix<double> m1(_matrix);
int signum;
gsl_permutation *p;
if (size_j() != size_i())
{
std::cout << "\n ** Size mismatch in matrix<double> determinant" << std::endl;
exit(EXIT_FAILURE);
}
if ((p = gsl_permutation_alloc(size_i())) == NULL)
{
std::cout << "\n ** Error in matrix<double> determinant" << std::endl;
exit(EXIT_FAILURE);
}
if(gsl_linalg_LU_decomp (m1.as_gsl_type_ptr(), p, &signum))
{
std::cout << "\n ** Error in matrix<double> determinant" << std::endl;
gsl_permutation_free(p);
exit(EXIT_FAILURE);
}
gsl_permutation_free(p);
return gsl_linalg_LU_det(m1.as_gsl_type_ptr() , signum);
}
/** Multiplication assignment (matrix) */
matrix<double>& matrix<double>::operator*=(const matrix<double>& m)
{
if (!((size_i() == size_j()) && (size_i() == m.size_i()) && (size_j() == m.size_j())))
{
std::cout << "\n Error in matrix<double> *= (matrix)" << std::endl;
exit(EXIT_FAILURE);
}
*this = *this * m;
return *this;
}
Button::Button(const QString name, QWidget *parent):QPushButton(parent)
{
//pcmdFlat = new QPushButton;
this->setFlat(true);
if(name == "C:\\colors\\green.png")
this->color_ = Qt::green;
if(name == "C:\\colors\\red.png")
this->color_ = Qt::red;
if(name == "C:\\colors\\blue.png")
this->color_ = Qt::blue;
if(name == "C:\\colors\\blue.png")
this->color_ = Qt::gray;
QPixmap pix(name);
this->setIcon(pix);
QSize size_i(50, 50);
this->setIconSize(size_i);
this->setFixedSize(size_i);
/*QVBoxLayout* vLayout = new QVBoxLayout;
vLayout->addWidget(this);
setLayout(vLayout);*/
}
/** Multiplication operator (matrix) */
matrix<double> matrix<double>::operator*(const matrix<double>& m)
{
unsigned int i,j,k;
matrix<double> m1(size_i(),m.size_i(),0.);
if (size_j() != m.size_i())
{
std::cout << "\n Error in matrix<double> *" << std::endl;
exit(EXIT_FAILURE);
}
for(i=0; i<size_i(); i++)
for(j=0; j<m.size_j(); j++)
for(k=0; k<m.size_i(); k++)
m1(i,j)+=(*this)(i,k)*m(k,j);
return m1;
}
/** Transpose matrix */
matrix<double> matrix<double>::transpose()
{
matrix<double> m1(size_j(), size_i(), 0.);
if (gsl_matrix_transpose_memcpy(m1.as_gsl_type_ptr(), _matrix))
{
std::cout << "\n Error in matrix<double> transpose" << std::endl;
exit(EXIT_FAILURE);
}
return m1;
}
/** Assign */
matrix<double>& matrix<double>::operator=(const matrix<double>& m)
{
if(size_i()==m.size_i() && size_j()==m.size_j())
gsl_matrix_memcpy(_matrix, m.as_gsl_type_ptr());
else
{
std::cout << "\n ** Wrong size assign in matrix<complex> operator =" << std::endl;
exit(EXIT_FAILURE);
}
return *this;
}
void matrix<double>::eigensystem(matrix<complex> &U, vector<complex> &S) {
matrix<double> m(*this);
gsl_eigen_nonsymmv_workspace *ws;
ws = gsl_eigen_nonsymmv_alloc(size_i());
gsl_eigen_nonsymmv(m.as_gsl_type_ptr(), S.as_gsl_type_ptr(),
U.as_gsl_type_ptr(), ws);
gsl_eigen_nonsymmv_free(ws);
}
/** Assign submatrix */
void matrix<double>::assign(const size_t& i, const size_t& j, const matrix<double>& a)
{
size_t ki,kj;
double *x;
if(i+a.size_i() <= size_i() && j+a.size_j() <= size_j())
for(ki=i;ki<i+a.size_i();ki++)
for(kj=j;kj<j+a.size_j();kj++)
{
x = gsl_matrix_ptr(_matrix, ki, kj);
*x = a(ki-i,kj-j);
}
else
{
std::cout << "\n ** Wrong size assign in matrix<double> assign submatrix" << std::endl;
exit(EXIT_FAILURE);
}
}
/** Multiplication assignment (vector double) */
vector<double> matrix<double>::operator*(const vector<double>& v)
{
vector<double> v1(size_i(),0.);
if (size_j() != v.size())
{
std::cout << "\n ** Size mismatch in matrix<double> * (vector double)"
<< std::endl;
exit(EXIT_FAILURE);
}
if(gsl_blas_dgemv(CblasNoTrans, 1., _matrix, v.as_gsl_type_ptr(),
0., v1.as_gsl_type_ptr()))
{
std::cout << "\n ** Error in matrix<double> * (vector double)"
<< std::endl;
exit(EXIT_FAILURE);
}
return v1;
}
void ItkReader::ReadImageDirect(DataContainer& data) {
typedef itk::ImageIOBase::IOComponentType ScalarPixelType;
itk::ImageIOBase::Pointer imageIO =
itk::ImageIOFactory::CreateImageIO(p_url.getValue().c_str(), itk::ImageIOFactory::ReadMode);
if (imageIO.IsNotNull())
{
WeaklyTypedPointer wtp;
imageIO->SetFileName(p_url.getValue());
imageIO->ReadImageInformation();
const ScalarPixelType pixelType = imageIO->GetComponentType();
const size_t numDimensions = imageIO->GetNumberOfDimensions();
LDEBUG("Reading Image with Reader " << imageIO->GetNameOfClass());
LDEBUG("Pixel Type is " << imageIO->GetComponentTypeAsString(pixelType));
LDEBUG("numDimensions: " << numDimensions);
if (numDimensions > 3) {
LERROR("Error: Dimensions higher than 3 not supported!");
return;
}
itk::ImageIORegion ioRegion(numDimensions);
itk::ImageIORegion::IndexType ioStart = ioRegion.GetIndex();
itk::ImageIORegion::SizeType ioSize = ioRegion.GetSize();
cgt::vec3 imageOffset(0.f);
cgt::vec3 voxelSize(1.f);
cgt::ivec3 size_i(1);
//we assured above that numDimensions is < 3
for (int i = 0; i < static_cast<int>(numDimensions); i++) {
size_i[i] = imageIO->GetDimensions(i);
imageOffset[i] = imageIO->GetOrigin(i);
voxelSize[i] = imageIO->GetSpacing(i);
ioStart[i] = 0;
ioSize[i] = size_i[i];
}
cgt::svec3 size(size_i);
size_t dimensionality = (size_i[2] == 1) ? ((size_i[1] == 1) ? 1 : 2) : 3;
LDEBUG("Image Size is " << size);
LDEBUG("Voxel Size is " << voxelSize);
LDEBUG("Image Offset is " << imageOffset);
LDEBUG("component size: " << imageIO->GetComponentSize());
LDEBUG("components: " << imageIO->GetNumberOfComponents());
LDEBUG("pixel type (string): " << imageIO->GetPixelTypeAsString(imageIO->GetPixelType())); // 'vector'
LDEBUG("pixel type: " << imageIO->GetPixelType()); // '5'
switch (pixelType) {
case itk::ImageIOBase::CHAR:
wtp._baseType = WeaklyTypedPointer::INT8; break;
case itk::ImageIOBase::UCHAR:
wtp._baseType = WeaklyTypedPointer::UINT8; break;
case itk::ImageIOBase::SHORT:
wtp._baseType = WeaklyTypedPointer::INT16; break;
case itk::ImageIOBase::USHORT:
wtp._baseType = WeaklyTypedPointer::UINT16; break;
case itk::ImageIOBase::INT:
wtp._baseType = WeaklyTypedPointer::INT32; break;
case itk::ImageIOBase::UINT:
wtp._baseType = WeaklyTypedPointer::UINT32; break;
case itk::ImageIOBase::DOUBLE:
LWARNING("Pixel Type is DOUBLE. Conversion to float may result in loss of precision!");
case itk::ImageIOBase::FLOAT:
wtp._baseType = WeaklyTypedPointer::FLOAT; break;
default:
LERROR("Error while loading ITK image: unsupported type: " << pixelType);
return;
}
wtp._numChannels = imageIO->GetNumberOfComponents();
//Setup the image region to read
ioRegion.SetIndex(ioStart);
ioRegion.SetSize(ioSize);
imageIO->SetIORegion(ioRegion);
if (pixelType != itk::ImageIOBase::DOUBLE) {
//Finally, allocate buffer and read the image data
wtp._pointer = new uint8_t[imageIO->GetImageSizeInBytes()];
imageIO->Read(wtp._pointer);
}
else {
//convert float volume to double volume
double * inputBuf = new double[imageIO->GetImageSizeInComponents()];
wtp._pointer = new uint8_t[imageIO->GetImageSizeInComponents() * sizeof(float)];
imageIO->Read(inputBuf);
double * dptr = inputBuf;
float * fptr = static_cast<float*>(wtp._pointer);
for (int i = 0, s = imageIO->GetImageSizeInComponents(); i < s; ++i) {
*fptr = *dptr;
fptr++;
dptr++;
}
delete[] inputBuf;
}
ImageData* image = new ImageData(dimensionality, size, wtp._numChannels);
ImageRepresentationLocal::create(image, wtp);
image->setMappingInformation(ImageMappingInformation(size, imageOffset/* + p_imageOffset.getValue()*/, voxelSize /** p_voxelSize.getValue()*/));
data.addData(p_targetImageID.getValue(), image);
}
else {
LWARNING("Unable to create ImageIO Instance; No suitable reader found!");
}
}
void ItkReader::ReadImageSeries(DataContainer& data) {
typedef itk::ImageIOBase::IOComponentType ScalarPixelType;
std::vector<std::string> imageFileNames = GetImageFileNames();
if (!imageFileNames.size())
return;
itk::ImageIOBase::Pointer imageIO =
itk::ImageIOFactory::CreateImageIO(imageFileNames[0].c_str(), itk::ImageIOFactory::ReadMode);
const int numSlices = imageFileNames.size();
if (imageIO.IsNotNull())
{
WeaklyTypedPointer wtp;
imageIO->SetFileName(imageFileNames[0]);
imageIO->ReadImageInformation();
const ScalarPixelType pixelType = imageIO->GetComponentType();
const size_t numDimensions = imageIO->GetNumberOfDimensions();
LDEBUG("Reading Image with Reader " << imageIO->GetNameOfClass());
LDEBUG("Pixel Type is " << imageIO->GetComponentTypeAsString(pixelType));
LDEBUG("numDimensions: " << numDimensions);
if (numDimensions > 3) {
LERROR("Error: Dimensions higher than 3 not supported!");
return;
}
itk::ImageIORegion ioRegion(numDimensions);
itk::ImageIORegion::IndexType ioStart = ioRegion.GetIndex();
itk::ImageIORegion::SizeType ioSize = ioRegion.GetSize();
cgt::vec3 imageOffset(0.f);
cgt::vec3 voxelSize(1.f);
cgt::ivec3 size_i(1);
//we assured above that numDimensions is < 3
for (int i = 0; i < static_cast<int>(numDimensions); i++) {
size_i[i] = imageIO->GetDimensions(i);
imageOffset[i] = imageIO->GetOrigin(i);
voxelSize[i] = imageIO->GetSpacing(i);
ioStart[i] = 0;
ioSize[i] = size_i[i];
}
cgt::svec3 size(size_i);
size_t dimensionality = (size_i[2] == 1) ? ((size_i[1] == 1) ? 1 : 2) : 3;
if (dimensionality > 2) {
LERROR("Error: Cannot load image series with more than two dimensions!");
return;
}
LDEBUG("Image Size is " << size);
LDEBUG("Voxel Size is " << voxelSize);
LDEBUG("Image Offset is " << imageOffset);
LDEBUG("component size: " << imageIO->GetComponentSize());
LDEBUG("components: " << imageIO->GetNumberOfComponents());
LDEBUG("pixel type (string): " << imageIO->GetPixelTypeAsString(imageIO->GetPixelType()));
LDEBUG("pixel type: " << imageIO->GetPixelType());
switch (pixelType) {
case itk::ImageIOBase::CHAR:
wtp._baseType = WeaklyTypedPointer::INT8; break;
case itk::ImageIOBase::UCHAR:
wtp._baseType = WeaklyTypedPointer::UINT8; break;
case itk::ImageIOBase::SHORT:
wtp._baseType = WeaklyTypedPointer::INT16; break;
case itk::ImageIOBase::USHORT:
wtp._baseType = WeaklyTypedPointer::UINT16; break;
case itk::ImageIOBase::INT:
wtp._baseType = WeaklyTypedPointer::INT32; break;
case itk::ImageIOBase::UINT:
wtp._baseType = WeaklyTypedPointer::UINT32; break;
case itk::ImageIOBase::DOUBLE:
LWARNING("Pixel Type is DOUBLE. Conversion to float may result in loss of precision!");
case itk::ImageIOBase::FLOAT:
wtp._baseType = WeaklyTypedPointer::FLOAT; break;
default:
LERROR("Error while loading ITK image: unsupported type: " << pixelType);
return;
}
wtp._numChannels = imageIO->GetNumberOfComponents();
//Setup the image region to read
ioRegion.SetIndex(ioStart);
ioRegion.SetSize(ioSize);
imageIO->SetIORegion(ioRegion);
//allocate a temporary buffer if necessary
double* inputBuf = (pixelType == itk::ImageIOBase::DOUBLE) ? new double[imageIO->GetImageSizeInComponents()] : nullptr;
size_t sliceSize = (pixelType == itk::ImageIOBase::DOUBLE) ? imageIO->GetImageSizeInComponents() * sizeof(float) : imageIO->GetImageSizeInBytes();
wtp._pointer = new uint8_t[numSlices * sliceSize];
for (int idx = 0; idx < numSlices; ++idx) {
itk::ImageIOBase::Pointer fileIO = imageIO;
//itk::ImageIOFactory::CreateImageIO(imageFileNames[idx].c_str(), itk::ImageIOFactory::ReadMode);
fileIO->SetFileName(imageFileNames[idx]);
fileIO->ReadImageInformation();
fileIO->SetIORegion(ioRegion);
size_t currentSliceSize = (pixelType == itk::ImageIOBase::DOUBLE) ? imageIO->GetImageSizeInComponents() * sizeof(float) : fileIO->GetImageSizeInBytes();
if (currentSliceSize != sliceSize) {
LERROR("Image " << imageFileNames[idx] << " has different dimensionality or data type!");
delete static_cast<uint8_t*>(wtp._pointer);
delete inputBuf;
wtp._pointer = nullptr;
return;
}
uint8_t* sliceBuffer = static_cast<uint8_t*>(wtp._pointer) + idx * sliceSize;
if (pixelType != itk::ImageIOBase::DOUBLE) {
// directly read slice into buffer
fileIO->Read(sliceBuffer);
}
else {
//convert float volume to double volume
fileIO->Read(inputBuf);
double* dptr = inputBuf;
float* fptr = reinterpret_cast<float*>(sliceBuffer);
for (int i = 0, s = fileIO->GetImageSizeInComponents(); i < s; ++i) {
*fptr = static_cast<float>(*dptr);
fptr++;
dptr++;
}
}
}
delete[] inputBuf;
size[2] = numSlices;
//series adds one dimension
ImageData* image = new ImageData(dimensionality+1, size, wtp._numChannels);
ImageRepresentationLocal::create(image, wtp);
image->setMappingInformation(ImageMappingInformation(size, imageOffset/* + p_imageOffset.getValue()*/, voxelSize /** p_voxelSize.getValue()*/));
data.addData(p_targetImageID.getValue(), image);
}
else {
LWARNING("Unable to create ImageIO Instance; No suitable reader found!");
}
}
