}
//--------------------------------------------------------------------
+//--------------------------------------------------------------------
+void vvImage::AddVtkImage(vtkImageData* input)
+{
+ // RP: 20/12/2011
+ // Note that we're simply adding a new image to the vector.
+ // mItkToVtkConverters is therefore not being updated, but
+ // up to here it's not being used anyway...
+ mImageDimension = 0;
+ int* extent = input->GetWholeExtent();
+ if (extent[4] != extent[5])
+ mImageDimension = 3;
+ else if (extent[3] != extent[4])
+ mImageDimension = 2;
+ else if (extent[0] != extent[1])
+ mImageDimension = 1;
+
+ mVtkImages.push_back(input);
+}
+
+//--------------------------------------------------------------------
+
//--------------------------------------------------------------------
int vvImage::GetNumberOfSpatialDimensions()
{
void Init();
void Reset();
template<class TItkImageType> void AddItkImage(TItkImageType *input);
+ void AddVtkImage(vtkImageData* input);
const std::vector<vtkImageData*>& GetVTKImages();
vtkImageData* GetFirstVTKImageData();
int GetNumberOfDimensions() const;
banded=""
# params read from conf file
+ use_coeffs=1
params="$nb_iter $nb_samples $sampling_algo $nb_hist_bins $nb_levels $bspline_spacing $metric $optimizer $interpolator"
# register all phases to the reference
vf_in=$vf_dir/vf_inside_${ref_phase_nb}_$phase_nb.mhd
result_in=$output_dir/result_inside_${ref_phase_nb}_$phase_nb.mhd
log_in=$log_dir/log_inside_${ref_phase_nb}_$phase_nb.log
+ if [ $use_coeffs = 1 ]; then
+ init_coeff_in=$coeff_in # empty at first iteration
+ coeff_in=$vf_dir/coeff_inside_${ref_phase_nb}_$phase_nb.mhd
+ fi
# outside params
reference_out=$mask_dir/${banded}outside_$ref_phase_nb.mhd
vf_out=$vf_dir/vf_outside_$ref_phase_nb\_$phase_nb.mhd
result_out=$output_dir/result_outside_$ref_phase_nb\_$phase_nb.mhd
log_out=$log_dir/log_outside_${ref_phase_nb}_$phase_nb.log
+ if [ $use_coeffs = 1 ]; then
+ init_coeff_out=$coeff_out # empty at first iteration
+ coeff_out=$vf_dir/coeff_outside_${ref_phase_nb}_$phase_nb.mhd
+ fi
# registration
if [ "$method" == "blutdir" ]; then
- registration_blutdir $reference_in $target_in $mask_ref_in $mask_targ_in $vf_in $result_in $params $log_in
- registration_blutdir $reference_out $target_out $mask_ref_out $mask_targ_out $vf_out $result_out $params $log_out
+ registration_blutdir $reference_in $target_in $mask_ref_in $mask_targ_in $vf_in $result_in $params $log_in $coeff_in $init_coeff_in
+ registration_blutdir $reference_out $target_out $mask_ref_out $mask_targ_out $vf_out $result_out $params $log_out $coeff_out $init_coeff_out
elif [ "$method" == "elastix" ]; then
registration_elastix $reference_in $target_in $mask_ref_in $mask_targ_in $vf_in $result_in $params $log_in
registration_elastix $reference_out $target_out $mask_ref_out $mask_targ_out $vf_out $result_out $params $log_out
echo
}
+midp_in_out()
+{
+ echo
+ echo "----------- Mid-position ------------"
+ start=`date`
+ echo "start: $start"
+ echo
+
+ mkdir -p $midp_dir
+
+ ########### calculate the midp wrt the reference phase
+ phase_nb=$ref_phase_nb
+ phase_file=$ref_phase_file
+ echo "Calculating midp_$phase_nb.mhd..."
+ vf_midp_in=$midp_dir/vf_inside_midp_$phase_nb.mhd
+ vf_midp_out=$midp_dir/vf_outside_midp_$phase_nb.mhd
+ # average the vf's from reference phase to phase
+ clitkAverageTemporalDimension -i $vf_dir/vf_inside_${ref_phase_nb}_4D.mhd -o $vf_midp_in
+ abort_on_error midp $? clean_up_midp
+ clitkAverageTemporalDimension -i $vf_dir/vf_outside_${ref_phase_nb}_4D.mhd -o $vf_midp_out
+ abort_on_error midp $? clean_up_midp
+
+ # invert the vf (why?)
+ clitkInvertVF -i $vf_midp_in -o $vf_midp_in
+ abort_on_error midp $? clean_up_midp
+ clitkInvertVF -i $vf_midp_out -o $vf_midp_out
+ abort_on_error midp $? clean_up_midp
+
+ # combine in and out VF's
+ ref_vf_midp_in=$vf_midp_in
+ ref_vf_midp_out=$vf_midp_out
+ vf_midp=$midp_dir/vf_midp_$phase_nb.mhd
+ clitkCombineImage -i $vf_midp_in -j $vf_midp_out -o $vf_midp -m $mask_dir/mm_$phase_nb.mhd
+ clitkZeroVF -i $vf_midp -o vf_zero.mhd
+ clitkCombineImage -i $vf_midp -j vf_zero.mhd -o $vf_midp -m $mask_dir/patient_mask_$phase_nb.mhd
+
+ # create the midp by warping the reference phase with the reference vf
+ midp=$midp_dir/midp_$phase_nb.mhd
+ clitkWarpImage -i $phase_file -o $midp --vf=$vf_midp -s 1
+ abort_on_error midp $? clean_up_midp
+
+ clitkImageConvert -i $midp -o $midp -t float
+ abort_on_error midp $? clean_up_midp
+
+ ########### calculate the midp wrt the other phases
+ for i in $( seq 0 $((${#phase_files[@]} - 1))); do
+ phase_file=${phase_files[$i]}
+ phase_nb=${phase_nbs[$i]}
+ vf_midp_in=$midp_dir/vf_inside_midp_$phase_nb.mhd
+ vf_midp_out=$midp_dir/vf_outside_midp_$phase_nb.mhd
+
+ if [ "$phase_nb" != "$ref_phase_nb" ]; then
+ echo "Calculating midp_$phase_nb.mhd..."
+ # calculate vf from phase to midp, using the vf from reference phase to midp (-i)
+ # and the vf from reference phase to phase (-j)
+ clitkComposeVF -i $ref_vf_midp_in -j $vf_dir/vf_inside_$ref_phase_nb\_$phase_nb.mhd -o $vf_midp_in
+ abort_on_error midp $? clean_up_midp
+ clitkComposeVF -i $ref_vf_midp_out -j $vf_dir/vf_outside_$ref_phase_nb\_$phase_nb.mhd -o $vf_midp_out
+ abort_on_error midp $? clean_up_midp
+
+ # combine in and out VF's
+ vf_midp=$midp_dir/vf_midp_$phase_nb.mhd
+ clitkCombineImage -i $vf_midp_in -j $vf_midp_out -o $vf_midp -m $mask_dir/mm_$phase_nb.mhd
+ clitkZeroVF -i $vf_midp -o vf_zero.mhd
+ clitkCombineImage -i $vf_midp -j vf_zero.mhd -o $vf_midp -m $mask_dir/patient_mask_$phase_nb.mhd
+
+ midp=$midp_dir/midp_$phase_nb.mhd
+ clitkWarpImage -i $phase_file -o $midp --vf=$vf_midp -s 1
+ abort_on_error midp $? clean_up_midp
+
+ clitkImageConvert -i $midp -o $midp -t float
+ abort_on_error midp $? clean_up_midp
+ fi
+ done
+
+ rm vf_zero.*
+
+ # create 4D midp
+ create_mhd_4D_pattern.sh $midp_dir/midp_
+ create_mhd_4D_pattern.sh $midp_dir/vf_midp_
+ create_mhd_4D_pattern.sh $midp_dir/vf_inside_midp_
+ create_mhd_4D_pattern.sh $midp_dir/vf_outside_midp_
+
+ echo "Calculating midp_avg.mhd..."
+ clitkAverageTemporalDimension -i $midp_dir/midp_4D.mhd -o $midp_dir/midp_avg.mhd
+ abort_on_error midp $? clean_up_midp
+
+ echo "Calculating midp_med.mhd..."
+ clitkMedianTemporalDimension -i $midp_dir/midp_4D.mhd -o $midp_dir/midp_med.mhd
+ abort_on_error midp $? clean_up_midp
+
+ # clean-up
+ #rm $midp_dir/vf_*
+
+ echo
+ echo "-------- Mid-position done ! --------"
+ end=`date`
+ echo "start: $start"
+ echo "end: $end"
+ echo
+}
######################### main
registration
fi
+midp_combined_vf=0
if [ "$step" == "midp" -o "$step" == "all" ]; then
- midp
+ if [ $midp_combined_vf = 0 ]; then
+ midp_in_out
+ else
+ midp
+ fi
fi
echo
if [ $# -ne 2 ]; then
echo "Usage: $0 input.pts output.txt" 1>&2
+ exit 1
fi
-to_append=/tmp/$RANDOM
-to_prepend=/tmp/$RANDOM
+to_append=`mktemp`
+to_prepend=`mktemp`
for i in $(seq 0 $((`cat $1 | wc -l` - 1)));
do
echo "LANDMARKS1" > $2
paste -d ' ' $to_prepend $1 $to_append >> $2
+
+rm $to_append $to_prepend
################# BLUTDIR #####################
registration_blutdir()
{
- reference=$1
- target=$2
- mask_ref=$3
- mask_targ=$4
- vf=$5
- result=$6
- nb_iter=$7
- nb_samples=$8
- sampling_algo=$9
- hist_bins=${10}
- nb_levels=${11}
- spacing=${12}
- metric=${13}
- optimizer=${14}
- interpolator=${15}
- log=${16}
+ local reference=$1
+ local target=$2
+ local mask_ref=$3
+ local mask_targ=$4
+ local vf=$5
+ local result=$6
+ local nb_iter=$7
+ local nb_samples=$8
+ local sampling_algo=$9
+ local hist_bins=${10}
+ local nb_levels=${11}
+ local spacing=${12}
+ local metric=${13}
+ local optimizer=${14}
+ local interpolator=${15}
+ local log=${16}
+ local coeff=${17}
+ local init_coeff=${18}
echo "Computing BLUTDIR $reference -> $target ..."
blutdir_params="--levels $nb_levels --metric $metric --optimizer $optimizer --samples $nb_samples --spacing $spacing,$spacing,$spacing --bins $hist_bins --maxIt $nb_iter --interp $interpolator --verbose"
- cmd="clitkBLUTDIR -r $reference -t $target -m $mask_ref --targetMask $mask_targ --vf $vf -o $result $blutdir_params"
+
+ if [ -n "$coeff" ]; then
+ coeff="--coeff $coeff"
+ fi
+
+ if [ -n "$init_coeff" ]; then
+ init_coeff="--initCoeff $init_coeff"
+ fi
+
+ cmd="clitkBLUTDIR -r $reference -t $target -m $mask_ref --targetMask $mask_targ --vf $vf $coeff $init_coeff -o $result $blutdir_params"
$cmd > $log
abort_on_error registration_blutdir $? clean_up_registration
#include "vvImageReader.h"
#include "vvImageWriter.h"
#include <gdcmFile.h>
+#include <vtkImageChangeInformation.h>
#if GDCM_MAJOR_VERSION == 2
#include <gdcmImageHelper.h>
#include <gdcmAttribute.h>
//===========================================
/// Get slices locations ...
+ std::vector<double> theorigin(3);
std::vector<double> sliceLocations;
for(unsigned int i=0; i<args_info.inputs_num; i++) {
//std::cout << "Reading <" << input_files[i] << std::endl;
gdcm::Reader hreader;
hreader.SetFileName(input_files[i].c_str());
hreader.Read();
- std::vector<double> theorigin = gdcm::ImageHelper::GetOriginValue(hreader.GetFile());
+ theorigin = gdcm::ImageHelper::GetOriginValue(hreader.GetFile());
sliceLocations.push_back(theorigin[2]);
gdcm::Attribute<0x28, 0x100> pixel_size;
gdcm::DataSet& ds = hreader.GetFile().GetDataSet();
header->SetFileName(input_files[i]);
header->SetMaxSizeLoadEntry(16384); // required ?
header->Load();
- sliceLocations.push_back(header->GetZOrigin());
+ theorigin[0] = header->GetXOrigin();
+ theorigin[1] = header->GetYOrigin();
+ theorigin[2] = header->GetZOrigin();
+ sliceLocations.push_back(theorigin[2]);
if (header->GetPixelSize() != 2) {
std::cerr << "Pixel type 2 bytes ! " << std::endl;
std::cerr << "In file " << input_files[i] << std::endl;
std::cerr << reader->GetLastError() << std::endl;
return 1;
}
+
+ vvImage::Pointer image = reader->GetOutput();
+ vtkImageData* vtk_image = image->GetFirstVTKImageData();
+ vtkImageChangeInformation* modifier = vtkImageChangeInformation::New();
+ if (args_info.focal_origin_given) {
+ std::vector<double> spacing = image->GetSpacing();
+ std::vector<int> size = image->GetSize();
+ theorigin[0] = -spacing[0]*size[0]/2.0;
+ theorigin[1] = -spacing[1]*size[1]/2.0;
+ modifier->SetInput(vtk_image);
+ modifier->SetOutputOrigin(theorigin[0], theorigin[1], theorigin[2]);
+ modifier->Update();
+ vvImage::Pointer focal_image = vvImage::New();
+ focal_image->AddVtkImage(modifier->GetOutput());
+ image = focal_image;
+ }
vvImageWriter::Pointer writer = vvImageWriter::New();
- writer->SetInput(reader->GetOutput());
+ writer->SetInput(image);
writer->SetOutputFileName(args_info.output_arg);
writer->Update();
+ modifier->Delete();
+
return 0;
}
QColor color(vfColorButton->palette().color(QPalette::Background));
color = QColorDialog::getColor(color, this, "Choose the new color of the vector field");
//vfColorButton->palette().setColor(QPalette::Background, color); SR: Not working?
- vfColorButton->setStyleSheet("* { background-color: " + color.name() + "; border: 0px }");
+ if (color.isValid())
+ vfColorButton->setStyleSheet("* { background-color: " + color.name() + "; border: 0px }");
this->setVFProperty();
}
#include "vvReadState.h"
#include "vvMainWindow.h"
+#include "vvSlicerManager.h"
#include <qtreewidget.h>
}
}
else if (current_index >= 0) {
- if (value == "Fusion")
+ if (value == "Fusion")
value = ReadFusion(current_index);
else if (value == "Overlay")
value = ReadOverlay(current_index);
std::string vvReadState::ReadFusion(int index)
{
std::string file, value;
+ int vali;
+ double vald;
+ vvSlicerManager* slicerManager = m_Window->GetSlicerManagers()[index];
while (!m_XmlReader->isEndElement() || value != "Fusion") {
m_XmlReader->readNext();
value = m_XmlReader->qualifiedName().toString().toStdString();
if (!m_XmlReader->hasError())
m_Window->AddFusionImage(index, file.c_str());
}
+ if (value == "FusionOpacity") {
+ vali = m_XmlReader->readElementText().toInt();
+ if (!m_XmlReader->hasError())
+ slicerManager->SetFusionOpacity(vali);
+ }
+ if (value == "FusionThresholdOpacity") {
+ vali = m_XmlReader->readElementText().toInt();
+ if (!m_XmlReader->hasError())
+ slicerManager->SetFusionThresholdOpacity(vali);
+ }
+ if (value == "FusionColorMap") {
+ vali = m_XmlReader->readElementText().toInt();
+ if (!m_XmlReader->hasError())
+ slicerManager->SetFusionColorMap(vali);
+ }
+ if (value == "FusionWindow") {
+ vald = m_XmlReader->readElementText().toDouble();
+ if (!m_XmlReader->hasError())
+ slicerManager->SetFusionWindow(vald);
+ }
+ if (value == "FusionLevel") {
+ vald = m_XmlReader->readElementText().toDouble();
+ if (!m_XmlReader->hasError())
+ slicerManager->SetFusionLevel(vald);
+ }
}
}
+ m_Window->ImageInfoChanged();
return value;
}
std::string vvReadState::ReadOverlay(int index)
{
std::string file, value;
+ int vali;
+ double vald;
+ vvSlicerManager* slicerManager = m_Window->GetSlicerManagers()[index];
while (!m_XmlReader->isEndElement() || value != "Overlay") {
m_XmlReader->readNext();
value = m_XmlReader->qualifiedName().toString().toStdString();
if (!m_XmlReader->hasError())
m_Window->AddOverlayImage(index, file.c_str());
}
+ if (value == "OverlayColorWindow") {
+ vald = m_XmlReader->readElementText().toDouble();
+ if (!m_XmlReader->hasError())
+ slicerManager->SetOverlayColorWindow(vald);
+ }
+ if (value == "OverlayColorLevel") {
+ vald = m_XmlReader->readElementText().toDouble();
+ if (!m_XmlReader->hasError())
+ slicerManager->SetOverlayColorLevel(vald);
+ }
+ if (value == "LinkOverlayWindowLevel") {
+ vali = m_XmlReader->readElementText().toInt();
+ if (!m_XmlReader->hasError())
+ slicerManager->SetLinkOverlayWindowLevel(vali);
+ }
+ if (value == "OverlayColor") {
+ vali = m_XmlReader->readElementText().toInt();
+ if (!m_XmlReader->hasError())
+ slicerManager->SetOverlayColor(vali);
+ }
}
}
+ m_Window->ImageInfoChanged();
return value;
}
m_XmlWriter->writeEndElement();
}
-void vvSaveState::SaveImage(QTreeWidgetItem* item, int index)
+void vvSaveState::SaveImage(const QTreeWidgetItem* item, int index)
{
+ const vvSlicerManager * slicerManager = m_Window->GetSlicerManagers()[index];
m_XmlWriter->writeStartElement("Image");
-
+
std::ostringstream indexStr;
indexStr.str("");
indexStr << index;
std::string filename = item->data(0, Qt::UserRole).toString().toStdString();
m_XmlWriter->writeTextElement("FileName", QDir::current().absoluteFilePath(filename.c_str()));
-
+
QTreeWidgetItem* item_child;
std::string role;
for (int i = 0; i < item->childCount(); i++) {
item_child = item->child(i);
role = item_child->data(1,Qt::UserRole).toString().toStdString();
if (role == "fusion")
- SaveFusion(item_child);
+ SaveFusion(item_child, slicerManager);
else if (role == "overlay")
- SaveOverlay(item_child);
+ SaveOverlay(item_child, slicerManager);
else if (role == "vector")
SaveVector(item_child);
}
-
+
m_XmlWriter->writeEndElement();
}
-void vvSaveState::SaveFusion(QTreeWidgetItem* item)
+void vvSaveState::SaveFusion(const QTreeWidgetItem* item, const vvSlicerManager* vvManager)
{
m_XmlWriter->writeStartElement("Fusion");
std::string filename = item->data(0, Qt::UserRole).toString().toStdString();
m_XmlWriter->writeTextElement("FileName", QDir::current().absoluteFilePath(filename.c_str()));
+ m_XmlWriter->writeTextElement("FusionOpacity", QString::number(vvManager->GetFusionOpacity()));
+ m_XmlWriter->writeTextElement("FusionThresholdOpacity", QString::number(vvManager->GetFusionThresholdOpacity()));
+ m_XmlWriter->writeTextElement("FusionColorMap", QString::number(vvManager->GetFusionColorMap()));
+ m_XmlWriter->writeTextElement("FusionWindow", QString::number(vvManager->GetFusionWindow()));
+ m_XmlWriter->writeTextElement("FusionLevel", QString::number(vvManager->GetFusionLevel()));
m_XmlWriter->writeEndElement();
}
-void vvSaveState::SaveOverlay(QTreeWidgetItem* item)
+void vvSaveState::SaveOverlay(const QTreeWidgetItem* item, const vvSlicerManager* vvManager)
{
m_XmlWriter->writeStartElement("Overlay");
std::string filename = item->data(0, Qt::UserRole).toString().toStdString();
m_XmlWriter->writeTextElement("FileName", QDir::current().absoluteFilePath(filename.c_str()));
+ m_XmlWriter->writeTextElement("OverlayColorWindow", QString::number(vvManager->GetOverlayColorWindow()));
+ m_XmlWriter->writeTextElement("OverlayColorLevel", QString::number(vvManager->GetOverlayColorLevel()));
+ m_XmlWriter->writeTextElement("LinkOverlayWindowLevel", QString::number(vvManager->GetLinkOverlayWindowLevel()));
+ m_XmlWriter->writeTextElement("OverlayColor", QString::number(vvManager->GetOverlayColor()));
m_XmlWriter->writeEndElement();
}
-void vvSaveState::SaveVector(QTreeWidgetItem* item)
+void vvSaveState::SaveVector(const QTreeWidgetItem* item)
{
m_XmlWriter->writeStartElement("Vector");
std::string filename = item->data(0, Qt::UserRole).toString().toStdString();
#include <string>
#include <memory>
+#include "vvSlicerManager.h"
class vvMainWindow;
class QXmlStreamWriter;
void SaveGlobals();
void SaveGUI();
void SaveTree();
- void SaveImage(QTreeWidgetItem* item, int index);
- void SaveFusion(QTreeWidgetItem* item);
- void SaveOverlay(QTreeWidgetItem* item);
- void SaveVector(QTreeWidgetItem* item);
+ void SaveImage(const QTreeWidgetItem* item, int index);
+ void SaveFusion(const QTreeWidgetItem* item, const vvSlicerManager* slicerManager);
+ void SaveOverlay(const QTreeWidgetItem* item, const vvSlicerManager* slicerManager);
+ void SaveVector(const QTreeWidgetItem* item);
std::auto_ptr<QXmlStreamWriter> m_XmlWriter;
std::auto_ptr<QFile> m_File;
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
-double vvSlicerManager::GetOverlayColorWindow()
+double vvSlicerManager::GetOverlayColorWindow() const
{
if (mSlicers.size())
return mSlicers[0]->GetOverlayColorWindow();
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
-double vvSlicerManager::GetOverlayColorLevel()
+double vvSlicerManager::GetOverlayColorLevel() const
{
if (mSlicers.size())
return mSlicers[0]->GetOverlayColorLevel();
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
-bool vvSlicerManager::GetLinkOverlayWindowLevel()
+bool vvSlicerManager::GetLinkOverlayWindowLevel() const
{
if (mSlicers.size())
return mSlicers[0]->GetLinkOverlayWindowLevel();
double GetColorWindow();
double GetColorLevel();
- double GetOverlayColorWindow();
- double GetOverlayColorLevel();
- bool GetLinkOverlayWindowLevel();
+ double GetOverlayColorWindow() const;
+ double GetOverlayColorLevel() const;
+ bool GetLinkOverlayWindowLevel() const;
int GetColorMap() {
return mColorMap;
}
int GetPreset() {
return mPreset;
}
- int GetOverlayColor() {
+ int GetOverlayColor() const {
return mOverlayColor;
}
- int GetFusionOpacity() {
+ int GetFusionOpacity() const {
return mFusionOpacity;
}
- int GetFusionThresholdOpacity() {
+ int GetFusionThresholdOpacity() const {
return mFusionThresOpacity;
}
- int GetFusionColorMap() {
+ int GetFusionColorMap() const {
return mFusionColorMap;
}
- double GetFusionWindow() {
+ double GetFusionWindow() const {
return mFusionWindow;
}
- double GetFusionLevel() {
+ double GetFusionLevel() const {
return mFusionLevel;
}
git://git.creatis.insa-lyon.fr / clitk.git / commitdiff