void RootManager::uninitializeRootObject()
{
SLM_TRACE_FUNC();
SLM_WARN_IF("(Hack) Sorry, the OSR must be initialized to uninitialize it. ToDo => transform in assert", ! getDefault()->m_isRootInitialized );
if ( getDefault()->m_isRootInitialized )
{
// Setting initialization to false
getDefault()->m_isRootInitialized = false ;
assert( getDefault()->m_rootObjectConfigurationName.first ) ;
// Stop services reported in m_rootObjectConfiguration before stopping everything
//::fwServices::stopAndUnregister(getDefault()->m_rootObjectConfiguration) ;
getDefault()->m_ctm->stopAndDestroy();
OSLM_WARN_IF("Sorry, few services still exist before erasing root object ( cf debug following message )"
<< std::endl << ::fwServices::OSR::getRegistryInformation(),
! ::fwServices::OSR::getKSContainer().empty());
//::fwServices::GlobalEventManager::getDefault()->clearMessages();
SLM_TRACE("uninitializeRootObject : Reset the last shared_ptr on root object.");
// Reset the root object: involve complete m_container clearing
//getDefault()->m_rootObject.reset();
//assert( getDefault()->m_rootObject.use_count() == 0 );
// ::fwRuntime::profile::Profile::sptr profile = ::fwRuntime::profile::getCurrentProfile();
// SLM_TRACE("Stopping Profile");
// profile->stop();
// SLM_TRACE("Profile Stopped");
}
}
void ContainerBuilder::setParent(::fwGui::container::fwContainer::sptr parent)
{
SLM_ASSERT("Sorry, QtContainer not yet initialized, cleaning impossible", m_container);
::fwGuiQt::container::QtContainer::sptr parentContainer = ::fwGuiQt::container::QtContainer::dynamicCast(parent);
SLM_ASSERT("dynamicCast fwContainer to QtContainer failed", parentContainer);
::fwGuiQt::container::QtContainer::sptr container = ::fwGuiQt::container::QtContainer::dynamicCast(m_container);
SLM_ASSERT("dynamicCast fwContainer to QtContainer failed", container);
QWidget *qtContainer = container->getQtContainer();
SLM_ASSERT("Sorry, QtContainer not yet initialized", qtContainer);
QWidget *qtParent = parentContainer->getQtContainer();
SLM_ASSERT("Sorry, parent QtContainer not yet initialized", qtParent);
if(qtParent != m_parent->getQtContainer() )
{
if(!qtParent->layout())
{
SLM_TRACE("New parent container hasn't layout");
QBoxLayout *layout = new QBoxLayout(QBoxLayout::TopToBottom);
layout->setContentsMargins(0, 0, 0, 0);
qtParent->setLayout(layout);
}
qtParent->layout()->addWidget(qtContainer);
qtContainer->update();
m_parent = parentContainer;
}
}
void GridFromFloat::configuring() throw ( ::fwTools::Failed )
{
SLM_TRACE_FUNC();
SLM_ASSERT("\"config\" tag missing", m_configuration->getName() == "config");
this->IAdaptor::configuring();
SLM_TRACE("IAdaptor configuring ok");
// Set the x/y min/max values
m_xMin = ::boost::lexical_cast< float >( m_configuration->getAttributeValue("xMin") );
m_xMax = ::boost::lexical_cast< float >( m_configuration->getAttributeValue("xMax") );
m_yMin = ::boost::lexical_cast< float >( m_configuration->getAttributeValue("yMin") );
m_yMax = ::boost::lexical_cast< float >( m_configuration->getAttributeValue("yMax") );
// If the corresponding attributes are present in the config, set the xSpacing, ySpacing between the lines and color of the lines
if (!m_configuration->getAttributeValue("xSpacing").empty())
{
m_xSpacing = ::boost::lexical_cast< float >( m_configuration->getAttributeValue("xSpacing") );
}
if (!m_configuration->getAttributeValue("ySpacing").empty())
{
m_ySpacing = ::boost::lexical_cast< float >( m_configuration->getAttributeValue("ySpacing") );
}
if (!m_configuration->getAttributeValue("color").empty())
{
::scene2D::data::InitQtPen::setPenColor(m_pen, m_configuration->getAttributeValue("color"));
}
}
void Square::processInteraction( ::scene2D::data::Event::sptr _event )
{
SLM_TRACE_FUNC();
if ( _event->getType() == ::scene2D::data::Event::MouseButtonPress && _event->getButton() == ::scene2D::data::Event::LeftButton )
{
if ( this->coordViewIsInItem( _event->getCoord(), m_rec ) )
{
SLM_TRACE("Point is captured");
m_pointIsCaptured = true;
m_oldCoord = this->coordViewToCoordItem( _event->getCoord(), m_rec );
m_rec->setBrush( Qt::yellow );
_event->setAccepted(true);
}
}
else if ( m_pointIsCaptured && _event->getType() == ::scene2D::data::Event::MouseMove )
{
::scene2D::data::Coord newCoord = this->coordViewToCoordItem( _event->getCoord(), m_rec );
m_rec->moveBy( newCoord.getX() - m_oldCoord.getX(), newCoord.getY() - m_oldCoord.getY() );
m_oldCoord = newCoord;
_event->setAccepted(true);
}
else if ( m_pointIsCaptured && _event->getType() == ::scene2D::data::Event::MouseButtonRelease )
{
m_rec->setBrush( m_color );
m_pointIsCaptured = false;
_event->setAccepted(true);
}
}
void Image::buildPipeline( )
{
SLM_TRACE_FUNC();
m_map2colors->SetInputData(m_imageData);
m_map2colors->SetLookupTable(m_lut);
m_map2colors->SetOutputFormatToRGBA();
if (!m_imageRegisterId.empty())
{
m_imageRegister = this->getVtkObject(m_imageRegisterId);
}
vtkImageAlgorithm *algorithm = vtkImageAlgorithm::SafeDownCast(m_imageRegister);
vtkImageData *imageData = vtkImageData::SafeDownCast(m_imageRegister);
vtkImageBlend *imageBlend = vtkImageBlend::SafeDownCast(m_imageRegister);
SLM_ASSERT("Invalid vtk image register", algorithm||imageData||imageBlend );
if (imageBlend)
{
SLM_TRACE("Register is a vtkImageBlend");
if (m_imagePortId < 0)
{
m_imagePortId = imageBlend->GetNumberOfInputConnections(0);
imageBlend->AddInputConnection(m_map2colors->GetOutputPort());
OSLM_TRACE(this->getID() << ": Added image " << m_imagePortId << " on vtkImageBlend");
}
}
else if (algorithm)
{
SLM_TRACE("Register is a vtkImageAlgorithm");
algorithm->SetInputConnection(m_map2colors->GetOutputPort());
}
else if (imageData)
{
SLM_TRACE("Register is a vtkImageData");
m_map2colors->SetOutput(imageData);
m_map2colors->Update();
}
this->setVtkPipelineModified();
}
void startSlicing()
{
SLM_TRACE("vtkEvent: MiddleButtonPressEvent");
SLM_ASSERT("m_adaptor not instanced", m_adaptor);
SLM_ASSERT("m_picker not instanced", m_picker);
double pickPoint[3];
double pickedPoint[3];
int x, y;
m_adaptor->getInteractor()->GetEventPosition(x, y);
pickPoint[0] = x;
pickPoint[1] = y;
pickPoint[2] = 0;
OSLM_TRACE(
"vtkEvent: MiddleButtonPressEvent: picking " << pickPoint[0] << ", " << pickPoint[1] << ", " <<
pickPoint[2]);
if ( this->Pick(pickPoint, pickedPoint) )
{
SLM_TRACE("vtkEvent: MiddleButtonPressEvent:picked point");
SLM_ASSERT("Slicing has already begun", !m_mouseMoveObserved);
m_adaptor->getInteractor()->AddObserver(vtkCommand::MouseMoveEvent, this, 1.);
m_mouseMoveObserved = true;
SetAbortFlag(1);
//m_pickedProp = m_picker->GetProp3D();
m_pickedProp = ::fwRenderVTK::vtk::getNearestPickedProp(m_picker, m_adaptor->getRenderer());
m_localPicker = fwVtkCellPicker::New();
m_localPicker->InitializePickList();
m_localPicker->PickFromListOn();
m_localPicker->AddPickList(m_pickedProp);
double localPickedPoint[3];
this->localPick(pickPoint, localPickedPoint);
m_adaptor->startSlicing(localPickedPoint);
}
}
void Dictionary::loadDictionary()
{
// Make sure data dictionary is loaded
if (!dcmDataDict.isDictionaryLoaded())
{
::boost::filesystem::path full_path(::boost::filesystem::initial_path< ::boost::filesystem::path >());
std::string dicoPath = full_path.string() + "/share/" + PRJ_NAME + "_" + FWDICOMIOEXT_VER + "/dicom.dic";
bool loaded = dcmDataDict.wrlock().loadDictionary(dicoPath.c_str());
dcmDataDict.unlock();
SLM_ASSERT("Unable to load DICOM dictionary !", loaded);
SLM_TRACE("DICOM dictionary loaded !");
}
}
void stopSlicing()
{
SLM_TRACE("vtkEvent: MiddleButtonReleaseEvent");
SLM_ASSERT("m_adaptor not instanced", m_adaptor);
SLM_ASSERT("m_picker not instanced", m_picker);
SLM_ASSERT("Slicing doesn't begun", m_mouseMoveObserved);
m_adaptor->getInteractor()->RemoveObservers(vtkCommand::MouseMoveEvent, this);
m_mouseMoveObserved = false;
m_adaptor->stopSlicing();
m_localPicker->Delete();
m_localPicker = nullptr;
m_pickedProp = nullptr;
}
SeriesDBLazyReader::MapSeriesType buildMapSeriesFromScanner( ::gdcm::Scanner & scanner )
{
::gdcm::Directory::FilenamesType keys = scanner.GetKeys();
::gdcm::Directory::FilenamesType::const_iterator it = keys.begin();
SeriesDBLazyReader::MapSeriesType mapSeries;
for(; it != keys.end() ; ++it)
{
const char *filename = it->c_str();
assert( scanner.IsKey( filename ) );
const char *seriesUID = scanner.GetValue( filename, seriesUIDTag );
const char *acqDate = scanner.GetValue( filename, acquisitionDateTag );
if (seriesUID)
{
std::string fileSetId = seriesUID;
if (acqDate)
{
fileSetId += "_";
fileSetId += acqDate;
}
const char *imageTypeStr = scanner.GetValue(filename, imageTypeTag);
if(imageTypeStr)
{
// Treatment of secondary capture dicom file.
std::string imageType(imageTypeStr);
SLM_TRACE("Image Type : " + imageType);
fileSetId += "_";
fileSetId += imageTypeStr;
}
mapSeries[fileSetId].push_back(filename);
}
else
{
SLM_ERROR ( "Error in vtkGdcmIO : No serie name found in : " + *it );
}
}
return mapSeries;
}
void Square::configuring() throw ( ::fwTools::Failed )
{
SLM_TRACE_FUNC();
SLM_ASSERT("\"config\" tag missing", m_configuration->getName() == "config");
this->IAdaptor::configuring();
SLM_TRACE("IAdaptor configuring ok");
m_coord.setX( ::boost::lexical_cast< double >( m_configuration->getAttributeValue("x") ) );
m_coord.setY( ::boost::lexical_cast< double >( m_configuration->getAttributeValue("y") ) );
m_size = ::boost::lexical_cast< ::boost::uint32_t >( m_configuration->getAttributeValue("size") );
if ( m_configuration->hasAttribute("color") )
{
this->setColor(m_configuration->getAttributeValue("color"));
}
}
void SPacsConfigurationEditor::pingPacs()
{
::fwDicomIOExt::data::PacsConfiguration::sptr pacsConfiguration
= this->getObject< ::fwDicomIOExt::data::PacsConfiguration >();
::fwDicomIOExt::dcmtk::SeriesEnquirer::sptr seriesEnquirer = ::fwDicomIOExt::dcmtk::SeriesEnquirer::New();
bool success = false;
try
{
seriesEnquirer->initialize(
pacsConfiguration->getLocalApplicationTitle(),
pacsConfiguration->getPacsHostName(),
pacsConfiguration->getPacsApplicationPort(),
pacsConfiguration->getPacsApplicationTitle(),
pacsConfiguration->getMoveApplicationTitle());
seriesEnquirer->connect();
success = seriesEnquirer->pingPacs();
seriesEnquirer->disconnect();
}
catch (::fwDicomIOExt::exceptions::Base& exception)
{
SLM_TRACE(exception.what());
success = false;
}
// Display a message with the ping result.
::fwGui::dialog::MessageDialog messageBox;
messageBox.setTitle("Ping Pacs");
if(success)
{
messageBox.setMessage( "Ping succeed !" );
}
else
{
messageBox.setMessage( "Ping failed !" );
}
messageBox.setIcon(::fwGui::dialog::IMessageDialog::INFO);
messageBox.addButton(::fwGui::dialog::IMessageDialog::OK);
::fwGui::dialog::IMessageDialog::Buttons answer = messageBox.show();
}
void App::MacReopenApp ( const wxString & fileName)
{
SLM_TRACE("MacReopenApp");
eventMac(fileName);
}
virtual void Execute( vtkObject* caller, unsigned long eventId, void*)
{
if(m_mouseMoveObserved && eventId == START_SLICING_EVENT)
{
SetAbortFlag(1); // To handle space bar pressed and middle click slicing at the same time
}
if(m_mouseMoveObserved || !m_adaptor->getInteractor()->GetShiftKey())
{
if (eventId == START_SLICING_EVENT && !m_mouseMoveObserved)
{
startSlicing();
}
else if(eventId == STOP_SLICING_EVENT && m_mouseMoveObserved)
{
stopSlicing();
}
else if (eventId == vtkCommand::MouseMoveEvent)
{
SLM_TRACE("vtkEvent: MouseMoveEvent");
SLM_ASSERT("m_mouseMoveObserved not instanced", m_mouseMoveObserved);
int x, y;
double pickPoint[3];
double pickedPoint[3];
m_adaptor->getInteractor()->GetEventPosition(x, y);
pickPoint[0] = x;
pickPoint[1] = y;
pickPoint[2] = 0;
if ( this->localPick(pickPoint, pickedPoint))
{
m_adaptor->updateSlicing(pickedPoint);
}
}
else if (eventId == vtkCommand::KeyPressEvent && !m_adaptor->getInteractor()->GetControlKey())
{
vtkRenderWindowInteractor* rwi = vtkRenderWindowInteractor::SafeDownCast(caller);
char* keySym = rwi->GetKeySym();
if ( std::string(keySym) == "A" || std::string(keySym) == "a" )
{
m_adaptor->pushSlice(-1, m_adaptor->getOrientation());
}
else if (std::string(keySym) == "Z" || std::string(keySym) == "z" )
{
m_adaptor->pushSlice(1, m_adaptor->getOrientation());
}
if ( std::string(keySym) == "T" || std::string(keySym) == "t" )
{
m_adaptor->pushSlice(-1, ::fwDataTools::helper::MedicalImageAdaptor::Z_AXIS);
}
else if (std::string(keySym) == "Y" || std::string(keySym) == "y" )
{
m_adaptor->pushSlice(1, ::fwDataTools::helper::MedicalImageAdaptor::Z_AXIS);
}
else if (std::string(keySym) == "G" || std::string(keySym) == "g" )
{
m_adaptor->pushSlice(-1, ::fwDataTools::helper::MedicalImageAdaptor::Y_AXIS);
}
else if (std::string(keySym) == "H" || std::string(keySym) == "h" )
{
m_adaptor->pushSlice(1, ::fwDataTools::helper::MedicalImageAdaptor::Y_AXIS);
}
else if (std::string(keySym) == "B" || std::string(keySym) == "b" )
{
m_adaptor->pushSlice(-1, ::fwDataTools::helper::MedicalImageAdaptor::X_AXIS);
}
else if (std::string(keySym) == "N" || std::string(keySym) == "n" )
{
m_adaptor->pushSlice(1, ::fwDataTools::helper::MedicalImageAdaptor::X_AXIS);
}
else if (std::string(keySym) == "space" && !m_mouseMoveObserved)
{
this->startSlicing();
}
}
else if(eventId == vtkCommand::KeyReleaseEvent)
{
vtkRenderWindowInteractor* rwi = vtkRenderWindowInteractor::SafeDownCast(caller);
char* keySym = rwi->GetKeySym();
if (std::string(keySym) == "space" && m_mouseMoveObserved)
{
this->stopSlicing();
}
}
}
else if (m_adaptor->getInteractor()->GetShiftKey())
{
if (eventId == MouseWheelForwardEvent)
{
m_adaptor->pushSlice(1, m_adaptor->getOrientation());
}
else if (eventId == vtkCommand::MouseWheelBackwardEvent)
{
m_adaptor->pushSlice(-1, m_adaptor->getOrientation());
}
}
}
void ImageURLPanel::OnEnter(wxMouseEvent& WXUNUSED(event))
{
SLM_TRACE("ImageURLPanel::OnEnter");
SetCursor(wxCURSOR_HAND);
}
void ImageURLPanel::OnLeave(wxMouseEvent& WXUNUSED(event))
{
SLM_TRACE("ImageURLPanel::OnLeave");
SetCursor(wxCURSOR_ARROW);
}
void App::MacNewFile ( const wxString & fileName)
{
SLM_TRACE("MacNewFile");
eventMac(fileName);
}
void SeriesDBReader::addSeries( const ::fwMedData::SeriesDB::sptr& seriesDB,
const std::vector< std::string >& filenames)
{
//gdcm::Trace::SetDebug( 1 );
//gdcm::Trace::SetWarning( 1 );
//gdcm::Trace::SetError( 1 );
::gdcm::Scanner scanner;
const ::gdcm::Tag seriesUIDTag(0x0020, 0x000e);
const ::gdcm::Tag seriesDateTag(0x0008, 0x0021);
const ::gdcm::Tag seriesTimeTag(0x0008, 0x0031);
const ::gdcm::Tag seriesTypeTag(0x0008, 0x0060);
const ::gdcm::Tag seriesDescriptionTag(0x0008, 0x103e);
const ::gdcm::Tag seriesPhysicianNamesTag(0x0008, 0x1050);
const ::gdcm::Tag equipmentInstitutionNameTag(0x0008, 0x0080);
const ::gdcm::Tag patientNameTag(0x0010, 0x0010);
const ::gdcm::Tag patientIDTag(0x0010, 0x0020);
const ::gdcm::Tag patientBirthdateTag(0x0010, 0x0030);
const ::gdcm::Tag patientSexTag(0x0010, 0x0040);
const ::gdcm::Tag studyUIDTag(0x0020, 0x000d);
const ::gdcm::Tag studyDateTag(0x0008, 0x0020);
const ::gdcm::Tag studyTimeTag(0x0008, 0x0030);
const ::gdcm::Tag studyReferingPhysicianNameTag(0x0008, 0x0090);
const ::gdcm::Tag studyDescriptionTag(0x0008, 0x1030);
const ::gdcm::Tag studyPatientAgeTag(0x0010, 0x1010);
const ::gdcm::Tag imageTypeTag(0x0008, 0x0008);
const ::gdcm::Tag acquisitionDateTag(0x0008, 0x0022);
const ::gdcm::Tag acquisitionTimeTag(0x0008, 0x0032);
scanner.AddTag( seriesUIDTag );
scanner.AddTag( seriesDateTag );
scanner.AddTag( seriesTimeTag );
scanner.AddTag( seriesTypeTag );
scanner.AddTag( seriesDescriptionTag );
scanner.AddTag( seriesPhysicianNamesTag );
scanner.AddTag( equipmentInstitutionNameTag );
scanner.AddTag( studyUIDTag );
scanner.AddTag( patientNameTag );
scanner.AddTag( patientIDTag );
scanner.AddTag( patientBirthdateTag );
scanner.AddTag( patientSexTag );
scanner.AddTag( studyUIDTag );
scanner.AddTag( studyDateTag );
scanner.AddTag( studyTimeTag );
scanner.AddTag( studyReferingPhysicianNameTag );
scanner.AddTag( studyDescriptionTag );
scanner.AddTag( studyPatientAgeTag );
scanner.AddTag( imageTypeTag );
scanner.AddTag( acquisitionDateTag );
scanner.AddTag( acquisitionTimeTag );
try
{
const bool isScanned = scanner.Scan( filenames );
if( !isScanned )
{
SLM_ERROR("Scanner failed");
return;
}
const ::gdcm::Directory::FilenamesType keys = scanner.GetKeys();
typedef std::map< std::string, std::vector< std::string > > MapSeriesType;
MapSeriesType mapSeries;
for(const std::string& filename : keys)
{
SLM_ASSERT("'"+filename+"' is not a key in the mapping table", scanner.IsKey(filename.c_str()));
const char* seriesUID = scanner.GetValue( filename.c_str(), seriesUIDTag );
const char* acqDate = scanner.GetValue( filename.c_str(), acquisitionDateTag );
if (seriesUID)
{
std::string fileSetId = seriesUID;
if (acqDate)
{
fileSetId += "_";
fileSetId += acqDate;
}
const char* imageType = scanner.GetValue(filename.c_str(), imageTypeTag);
if(imageType)
{
// Treatment of secondary capture dicom file.
SLM_TRACE("Image Type : " + std::string(imageType));
fileSetId += "_";
fileSetId += imageType;
}
mapSeries[fileSetId].push_back(filename);
}
else
{
SLM_ERROR("No series name found in : " + filename );
}
}
for(const auto& elt : mapSeries)
{
::fwMedData::ImageSeries::sptr series = ::fwMedData::ImageSeries::New();
::fwMedData::Patient::sptr patient = series->getPatient();
::fwMedData::Study::sptr study = series->getStudy();
::fwMedData::Equipment::sptr equipment = series->getEquipment();
seriesDB->getContainer().push_back(series);
SLM_TRACE( "Processing: '" + elt.first + "' file set.");
const MapSeriesType::mapped_type& files = elt.second;
if ( !files.empty() )
{
vtkSmartPointer< vtkStringArray > fileArray = vtkSmartPointer< vtkStringArray >::New();
vtkSmartPointer< vtkGDCMImageReader > reader = vtkSmartPointer< vtkGDCMImageReader >::New();
reader->FileLowerLeftOn();
::gdcm::IPPSorter ippSorter;
ippSorter.SetComputeZSpacing( true );
ippSorter.SetZSpacingTolerance( 1e-3 );
bool isSorted = ippSorter.Sort( files );
std::vector<std::string> sorted;
double zspacing = 0.;
if(isSorted)
{
sorted = ippSorter.GetFilenames();
zspacing = ippSorter.GetZSpacing();
OSLM_TRACE("Found z-spacing:" << ippSorter.GetZSpacing());
}
else
{
// Else an error has been encountered.
// We fall back to a more trivial sorting based on the InstanceNumber DICOM tag.
SLM_WARN("IPP Sorting failed. Falling back to Instance Number sorting.");
::gdcm::Sorter sorter;
sorter.SetSortFunction(sortByInstanceNumber);
isSorted = sorter.StableSort( filenames);
if(isSorted)
{
// If the custom sorted returns true, it worked
// and the filenames are sorted by InstanceNumber (ASC).
sorted = sorter.GetFilenames();
}
else
{
// There is nothing more we can do to sort DICOM files.
SLM_ERROR("Failed to sort '"+elt.first+"'");
}
}
fileArray->Initialize();
if(isSorted)
{
SLM_TRACE("Success to sort '" + elt.first+"'");
if (!zspacing && sorted.size() > 1)
{
SLM_TRACE( "Guessing zspacing ..." );
if (!sorted.empty())
{
::gdcm::Reader localReader1;
::gdcm::Reader localReader2;
const std::string& f1 = *(sorted.begin());
const std::string& f2 = *(sorted.begin() + 1);
SLM_TRACE( "Search spacing in: '" + f1 +"'");
SLM_TRACE( "Search spacing in: '" + f2 +"'");
localReader1.SetFileName( f1.c_str() );
localReader2.SetFileName( f2.c_str() );
const bool canRead = localReader1.Read() && localReader2.Read();
if(canRead)
{
const std::vector<double> vOrigin1 =
::gdcm::ImageHelper::GetOriginValue(localReader1.GetFile());
const std::vector<double> vOrigin2 =
::gdcm::ImageHelper::GetOriginValue(localReader2.GetFile());
zspacing = vOrigin2[2] - vOrigin1[2];
OSLM_TRACE(
"Found z-spacing:" << zspacing << " from : << " << vOrigin2[2] << " | " <<
vOrigin1[2]);
}
SLM_ERROR_IF("Cannot read: '" + f1 + "' or: '" + f2 +"'", !canRead);
}
}
}
for(const std::string& file : sorted)
{
SLM_TRACE("Add '" + file + "' to vtkGdcmReader");
fileArray->InsertNextValue(file.c_str());
}
::fwData::Image::sptr pDataImage = ::fwData::Image::New();
bool res = false;
if (fileArray->GetNumberOfValues() > 0)
{
reader->SetFileNames( fileArray );
try
{
SLM_TRACE("Read Series: '" + elt.first + "'");
//add progress observation
vtkSmartPointer< ::fwVtkIO::helper::vtkLambdaCommand > progressCallback =
vtkSmartPointer< ::fwVtkIO::helper::vtkLambdaCommand >::New();
progressCallback->SetCallback([this](vtkObject* caller, long unsigned int, void* )
{
auto filter = static_cast<vtkGDCMImageReader*>(caller);
m_job->doneWork( filter->GetProgress()*100 );
});
reader->AddObserver(vtkCommand::ProgressEvent, progressCallback);
m_job->addSimpleCancelHook( [&]()
{
reader->AbortExecuteOn();
} );
reader->Update();
reader->UpdateInformation();
reader->PropagateUpdateExtent();
try
{
::fwVtkIO::fromVTKImage(reader->GetOutput(), pDataImage);
res = true;
}
catch(std::exception& e)
{
OSLM_ERROR("VTKImage to fwData::Image failed : "<<e.what());
}
}
catch (std::exception& e)
{
OSLM_ERROR( "Error during conversion : " << e.what() );
}
catch (...)
{
SLM_ERROR( "Unexpected error during conversion" );
}
m_job->finish();
}
if (res)
{
SLM_ASSERT("No file to read", !files.empty());
// Read medical info
vtkMedicalImageProperties* medprop = reader->GetMedicalImageProperties();
const std::string patientName = medprop->GetPatientName(); //"0010|0010"
const std::string patientId = medprop->GetPatientID();
const std::string patientBirthdate = medprop->GetPatientBirthDate(); //"0010|0030"
const std::string patientSex = medprop->GetPatientSex(); //"0010|0040"
const ::gdcm::Scanner::ValuesType gdcmPhysicianNames = scanner.GetValues( seriesPhysicianNamesTag );
const char* seriesUIDStr = scanner.GetValue( files[0].c_str(), seriesUIDTag );
const char* seriesTimeStr = scanner.GetValue( files[0].c_str(), seriesTimeTag );
const char* seriesDateStr = scanner.GetValue( files[0].c_str(), seriesDateTag );
const std::string seriesModality = medprop->GetModality(); //"0008|0060"
const std::string seriesDescription = medprop->GetSeriesDescription();
const std::string seriesDate = ( seriesDateStr ? seriesDateStr : "" );
const std::string seriesTime = ( seriesTimeStr ? seriesTimeStr : "" );
::fwMedData::DicomValuesType seriesPhysicianNames;
for(const std::string& name : gdcmPhysicianNames)
{
::fwMedData::DicomValuesType result;
::boost::split( result, name, ::boost::is_any_of("\\"));
seriesPhysicianNames.reserve(seriesPhysicianNames.size() + result.size());
seriesPhysicianNames.insert(seriesPhysicianNames.end(), result.begin(), result.end());
}
const char* studyUIDStr = scanner.GetValue( files[0].c_str(), studyUIDTag );
const char* studyReferingPhysicianNameStr =
scanner.GetValue( files[0].c_str(), studyReferingPhysicianNameTag );
const std::string studyDate = medprop->GetStudyDate();
const std::string studyTime = medprop->GetStudyTime();
const std::string studyDescription = medprop->GetStudyDescription(); //"0008|1030"
const std::string studyPatientAge = medprop->GetPatientAge();
const std::string equipementInstitution = medprop->GetInstitutionName(); //"0008|0080"
const std::string studyReferingPhysicianName =
( studyReferingPhysicianNameStr ? studyReferingPhysicianNameStr : "" );
const double thickness = medprop->GetSliceThicknessAsDouble();//"0018|0050"
double center = 0.0;
double width = 0.0;
if (medprop->GetNumberOfWindowLevelPresets())//FIXME : Multiple preset !!!
{
medprop->GetNthWindowLevelPreset(0, &width, ¢er); //0028|1050,1051
}
// Image must have 3 dimensions
if(pDataImage->getNumberOfDimensions() == 2)
{
::fwData::Image::SizeType imgSize = pDataImage->getSize();
imgSize.resize(3);
imgSize[2] = 1;
pDataImage->setSize(imgSize);
::fwData::Image::OriginType imgOrigin = pDataImage->getOrigin();
imgOrigin.resize(3);
imgOrigin[2] = 0.;
pDataImage->setOrigin(imgOrigin);
}
::fwData::Image::SpacingType vPixelSpacing = pDataImage->getSpacing();
vPixelSpacing.resize(3);
// assume z-spacing = 1 if not guessed
vPixelSpacing[2] = zspacing ? zspacing : (thickness ? thickness : 1.);
pDataImage->setSpacing(vPixelSpacing);
pDataImage->setWindowCenter(center);
pDataImage->setWindowWidth(width);
// Get the series instance UID.
SLM_ASSERT("No series UID", seriesUIDStr);
series->setInstanceUID(( seriesUIDStr ? seriesUIDStr : "UNKNOWN-UID" ));
series->setModality( seriesModality );
series->setDescription( seriesDescription );
series->setDate( seriesDate );
series->setTime( seriesTime );
series->setPerformingPhysiciansName( seriesPhysicianNames );
series->setImage(pDataImage);
SLM_ASSERT("No study UID", studyUIDStr);
study->setInstanceUID(( studyUIDStr ? studyUIDStr : "UNKNOWN-UID" ));
study->setDate(studyDate);
study->setTime(studyTime);
study->setDescription(studyDescription);
study->setPatientAge(studyPatientAge);
study->setReferringPhysicianName(studyReferingPhysicianName);
patient->setName(patientName);
patient->setPatientId(patientId);
patient->setBirthdate(patientBirthdate);
patient->setSex(patientSex);
equipment->setInstitutionName(equipementInstitution);
} // if res
} // if !files.empty()
}
} // try
catch (std::exception& e)
{
OSLM_ERROR( "Try with another reader or retry with this reader on a specific subfolder : " << e.what() );
for(const auto filename : filenames)
{
SLM_ERROR("file error : " + filename );
}
}
}
