cxImageAlgorithms.cpp

Go to the documentation of this file.

/*=========================================================================
This file is part of CustusX, an Image Guided Therapy Application.
                 
Copyright (c) SINTEF Department of Medical Technology.
All rights reserved.
                 
CustusX is released under a BSD 3-Clause license.
                 
See Lisence.txt (https://github.com/SINTEFMedtek/CustusX/blob/master/License.txt) for details.
=========================================================================*/

#include "cxImageAlgorithms.h"

#include <vtkImageData.h>
#include <vtkImageReslice.h>
#include <vtkMatrix4x4.h>

#include <vtkImageResample.h>
#include <vtkImageClip.h>

#include "cxImage.h"
#include "cxPatientModelService.h"
#include "cxUtilHelpers.h"
#include "cxImageTF3D.h"
#include "cxImageLUT2D.h"
#include "cxRegistrationTransform.h"

#include "cxTime.h"
#include "cxVolumeHelpers.h"

#include "cxSlicedImageProxy.h"
#include "cxSliceProxy.h"


namespace cx
{

ImagePtr resampleImage(PatientModelServicePtr dataManager, ImagePtr image, Transform3D qMd)
{
        //TODO: fix error:
        // There is an error in the transfer functions of the returned image from this function

  // provide a resampled volume for algorithms requiring that (such as PickerRep)
  vtkMatrix4x4Ptr orientatorMatrix = vtkMatrix4x4Ptr::New();
  vtkImageReslicePtr orientator = vtkImageReslicePtr::New();
  orientator->SetInputData(image->getBaseVtkImageData());
  orientator->SetInterpolationModeToLinear();
  orientator->SetOutputDimensionality(3);
  orientator->SetResliceAxes(qMd.inv().getVtkMatrix());
  orientator->AutoCropOutputOn();
  orientator->Update();
  vtkImageDataPtr rawResult = orientator->GetOutput();

//  rawResult->Update();

  QString uid = image->getUid() + "_or%1";
  QString name = image->getName()+" or%1";
//  ImagePtr oriented = dataManager->createDerivedImage(rawResult, uid, name, image);

  ImagePtr oriented = createDerivedImage(dataManager,
                                                                           uid, name,
                                                                           rawResult, image);

  oriented->get_rMd_History()->setRegistration(image->get_rMd() * qMd.inv());
  oriented->mergevtkSettingsIntosscTransform();

  return oriented;
}

ImagePtr resampleImage(PatientModelServicePtr dataManager, ImagePtr image, const Vector3D spacing, QString uid, QString name)
{
  vtkImageResamplePtr resampler = vtkImageResamplePtr::New();
  resampler->SetInputData(image->getBaseVtkImageData());
  resampler->SetAxisOutputSpacing(0, spacing[0]);
  resampler->SetAxisOutputSpacing(1, spacing[1]);
  resampler->SetAxisOutputSpacing(2, spacing[2]);
  resampler->Update();
  vtkImageDataPtr rawResult = resampler->GetOutput();

  if (uid.isEmpty())
  {
    uid = image->getUid() + "_res%1";
    name = image->getName()+" res%1";
  }

  ImagePtr retval = createDerivedImage(dataManager,
                                                                           uid, name,
                                                                           rawResult, image);
  return retval;
}

ImagePtr duplicateImage(PatientModelServicePtr dataManager, ImagePtr image)
{
        Vector3D spacing(image->getBaseVtkImageData()->GetSpacing());
        return resampleImage(dataManager, image, spacing, image->getUid()+"_copy%1", image->getName()+" copy%1");
}

vtkImageDataPtr cropImage(vtkImageDataPtr input, IntBoundingBox3D cropbox)
{
  vtkImageClipPtr clip = vtkImageClipPtr::New();
  clip->SetInputData(input);
  clip->SetOutputWholeExtent(cropbox.begin());
  clip->ClipDataOn();
  clip->Update();
  vtkImageDataPtr rawResult = clip->GetOutput();

//  rawResult->Update();
//  rawResult->UpdateInformation();
  rawResult->ComputeBounds();
  return rawResult;
}

ImagePtr cropImage(PatientModelServicePtr dataManager, ImagePtr image)
{
  DoubleBoundingBox3D bb = image->getCroppingBox();
  double* sp = image->getBaseVtkImageData()->GetSpacing();
  IntBoundingBox3D cropbox(
              static_cast<int>(bb[0]/sp[0]+0.5), static_cast<int>(bb[1]/sp[0]+0.5),
              static_cast<int>(bb[2]/sp[1]+0.5), static_cast<int>(bb[3]/sp[1]+0.5),
              static_cast<int>(bb[4]/sp[2]+0.5), static_cast<int>(bb[5]/sp[2]+0.5));
  vtkImageDataPtr rawResult = cropImage(image->getBaseVtkImageData(), cropbox);

  QString uid = image->getUid() + "_crop%1";
  QString name = image->getName()+" crop%1";
  ImagePtr result = createDerivedImage(dataManager,
                                                                           uid, name,
                                                                           rawResult, image);
  result->mergevtkSettingsIntosscTransform();

  return result;
}

QDateTime extractTimestamp(QString text)
{
  // retrieve timestamp as
  QRegExp tsReg("[0-9]{8}T[0-9]{6}");
  if (tsReg.indexIn(text)>0)
  {
    QDateTime datetime = QDateTime::fromString(tsReg.cap(0), timestampSecondsFormat());
    return datetime;
  }
  return QDateTime();
}

//From https://www.vtk.org/Wiki/VTK/Examples/Cxx/Qt/ImageDataToQImage
QImage vtkImageDataToQImage(vtkImageDataPtr imageData, bool overlay, QColor overlayColor)
{
        if ( !imageData ) { return QImage(); }

        int width = imageData->GetDimensions()[0];
        int height = imageData->GetDimensions()[1];

        QImage image( width, height, QImage::Format_ARGB32 ); //32 bit
        QRgb *rgbPtr = reinterpret_cast<QRgb *>( image.bits() ) + width * ( height - 1 );
        unsigned char *colorsPtr = reinterpret_cast<unsigned char *>( imageData->GetScalarPointer() );

        // Loop over the vtkImageData contents.
        for ( int row = 0; row < height; row++ )
        {
                for ( int col = 0; col < width; col++ )
                {
                        // Swap the vtkImageData RGB values with an equivalent QColor
                        *( rgbPtr++ ) = convertToQColor(colorsPtr, overlay, overlayColor);

                        colorsPtr += imageData->GetNumberOfScalarComponents();
                }

                rgbPtr -= width * 2;
        }

        return image;
}

QRgb convertToQColor(unsigned char *colorsPtr, bool overlay, QColor overlayColor)
{
        if(overlay)
                return modifyOverlayColor(colorsPtr, overlayColor);

        //32 bit
        QRgb rgb;
        rgb = QColor(colorsPtr[0], colorsPtr[1], colorsPtr[2], colorsPtr[3] ).rgba();
        //      rgb = QColor(colorsPtr[0], colorsPtr[1], colorsPtr[2], opacity ).rgba(); //Don't use alpha for now

        return rgb;
}

bool isDark(unsigned char *colorsPtr)
{
        unsigned char threshold = 10;
        if (colorsPtr[0] < threshold &&
                        colorsPtr[1] < threshold &&
                        colorsPtr[2] < threshold)
                return true;
        return false;
}

QRgb modifyOverlayColor(unsigned char *colorsPtr, QColor overlayColor)
{
        if(isDark(colorsPtr))
                overlayColor.setAlpha(0);

        QRgb retval = overlayColor.rgba();
        return retval;
}

vtkImageDataPtr createSlice(ImagePtr image, PLANE_TYPE planeType, Vector3D outputSpacing, Eigen::Array3i outputDimensions, ToolPtr sliceTool, PatientModelServicePtr patientModel, bool applyLUT)
{
        vtkImageDataPtr retval = vtkImageDataPtr::New();

        if(!image || !patientModel)
        {
                return retval;
        }

        cx::SliceProxyPtr proxy = cx::SliceProxy::create(patientModel);
        SlicedImageProxyPtr imageSlicer(new SlicedImageProxy);

        proxy->setTool(sliceTool);

        imageSlicer->setSliceProxy(proxy);
        imageSlicer->setImage(image);

        proxy->initializeFromPlane(planeType, false, false, 1, 0);
        proxy->setClinicalApplicationToFixedValue(mdRADIOLOGICAL);//Always create slices in radiological view

        // Using these values centers image in view, but seems to lock the manual image movement in some directions.
        double screenX = outputDimensions[0]*outputSpacing[0] / 2;
        double screenY = outputDimensions[1]*outputSpacing[1] / 2;

        imageSlicer->setOutputFormat(Vector3D(-screenX,-screenY,0), outputDimensions, outputSpacing);

        imageSlicer->update();
        if (applyLUT)
        {
                imageSlicer->getOutputPort()->Update();
                retval->DeepCopy(imageSlicer->getOutput());
        }
        else //Don't use LUT
        {
                imageSlicer->getOutputPortWithoutLUT()->Update();
                retval->DeepCopy(imageSlicer->getOutputWithoutLUT());

        }

        return retval;
}

} // namespace cx