void PulseProgressDialog::show()
{
#ifdef PULSEPROGRESS_USE_THREAD
this->Bind( wxEVT_LOCALTHREAD_COMPLETED , &PulseProgressDialog::onComplete , this);
m_wxpd = new wxProgressDialog(
::fwWX::std2wx(m_title),
" ", // sinon pas de place pour ecrire definit espace initial
100 /*percent*/,
NULL, wxPD_AUTO_HIDE | wxPD_APP_MODAL | wxPD_SMOOTH);
m_wxpd->Pulse( m_message );
m_wxpd->Fit();
m_wxpd->Show();
m_wxpd->Update();
m_thread = new LocalThread( m_stuff);
if ( m_thread->Create() != wxTHREAD_NO_ERROR )
{
wxLogError("Can't create the thread!");
delete m_thread;
m_thread = NULL;
}
else
{
if (m_thread->Run() != wxTHREAD_NO_ERROR )
{
wxLogError("Can't create the thread!");
delete m_thread;
m_thread = NULL;
}
}
int i=0;
while( m_thread->isFinished()== false ) // moins couteux que wxThread::isRunning
{
OSLM_TRACE("PulseProgressDialog in Loop m_thread->isRunning" << m_thread->IsRunning() << " " << ++i );
m_wxpd->Pulse();
m_wxpd->Update();
wxYield();
wxMilliSleep(m_frequence);
}
OSLM_TRACE("PulseProgressDialog AFTER Loop m_thread->isRunning " << m_thread->IsRunning() << " " << ++i );
if ( m_thread->getErrorMessage().size() )
{
m_wxpd->Update(100,"Failed !!!");
OSLM_WARN( "PulseProgressDialog::m_stuff an exception has occured " << m_thread->getErrorMessage() );
throw ::fwTools::Failed( m_thread->getErrorMessage() );
}
m_wxpd->Update(100,"Done");
#else
m_thread = NULL;
m_stuff();
#endif
}
void SSliceIndexDicomPullerEditor::triggerNewSlice()
{
// DicomSeries
::fwMedData::DicomSeries::csptr dicomSeries = this->getInOut< ::fwMedData::DicomSeries >("series");
SLM_ASSERT("DicomSeries should not be null !", dicomSeries);
// Compute slice index
std::size_t selectedSliceIndex = m_sliceIndexSlider->value() + dicomSeries->getFirstInstanceNumber();
OSLM_TRACE("triggered new slice : " << selectedSliceIndex);
if(!dicomSeries->isInstanceAvailable(selectedSliceIndex))
{
if(m_pacsConfiguration)
{
m_pullSeriesWorker->post(std::bind(&::ioPacs::SSliceIndexDicomPullerEditor::pullInstance, this));
}
else
{
SLM_ERROR("There is no instance available for selected slice index.");
}
}
else
{
//m_slotReadImage->asyncRun(selectedSliceIndex);
this->readImage(selectedSliceIndex);
}
}
void SImageSeriesReader::updating()
{
if( this->hasLocationDefined() )
{
// Retrieve dataStruct associated with this service
::fwMedData::ImageSeries::sptr imageSeries = this->getInOut< ::fwMedData::ImageSeries >(::fwIO::s_DATA_KEY);
SLM_ASSERT("ImageSeries is not instanced", imageSeries);
::fwGui::Cursor cursor;
cursor.setCursor(::fwGui::ICursor::BUSY);
try
{
::fwData::Image::sptr image = ::fwData::Image::New();
if ( SImageReader::loadImage( this->getFile(), image, m_sigJobCreated ) )
{
imageSeries->setImage(image);
initSeries(imageSeries);
this->notificationOfDBUpdate();
}
}
catch(::fwTools::Failed& e)
{
OSLM_TRACE("Error : " << e.what());
FW_RAISE_EXCEPTION(e);
}
cursor.setDefaultCursor();
}
}
SCurvedHistogram::Points SCurvedHistogram::getResampledBSplinePoints(const Points& _bSplinePoints ) const
{
Points points;
Point point = _bSplinePoints.front();
double dx, dy;
const double maxLength = 2000;
double segmentLength = 0;
points.push_back( point );
for(Points::const_iterator it = _bSplinePoints.begin() + 1; it != _bSplinePoints.end(); ++it)
{
dx = abs((*it).first - point.first); // theoretically positive
dy = abs((*it).second - point.second);
segmentLength += sqrt( dx * dx + dy * dy );
if(segmentLength > maxLength)
{
points.push_back( *it );
segmentLength = 0;
}
point = *it;
}
points.push_back( _bSplinePoints.back() );
OSLM_TRACE("B-Spline points size moved from " << _bSplinePoints.size() << " to " << points.size());
return points;
}
void Code::updating()
{
::fwData::String::sptr stringObj = this->getInOut< ::fwData::String >(s_STRING_INOUT);
SLM_ASSERT("The given string object is null", stringObj);
m_valueCtrl->setText(QString::fromStdString(stringObj->value()));
OSLM_TRACE(stringObj->getID() << " updated value : " << stringObj->value());
}
void ProgressDialog::operator()(float percent,std::string msg)
{
SLM_ASSERT("m_pdialog not instanced", m_pdialog);
int value = (int)(percent*100);
OSLM_TRACE( "ProgressDialog msg" << msg << " : " << value <<"%");
m_pdialog->Show(true); // can be hidden if previous load as finished
m_pdialog->Update(value, ::fwGuiWx::std2wx(msg) );
}
void DicomSegmentReader::readSurfaceSegmentation( ::fwData::Reconstruction::sptr a_reconstruction,
::gdcm::SmartPointer< ::gdcm::Segment > a_segment ) throw (::fwTools::Failed)
{
if (a_segment->GetSurfaceCount() != 1)
throw ::fwTools::Failed("Unappropriated surface count for a segment");
//***** Set the reconstruction *****//
// Organ Name
// TODO : if empty, try to get label with DicomDictionarySegment
a_reconstruction->setOrganName( a_segment->GetSegmentDescription());
OSLM_TRACE("Organ Name : " << a_reconstruction->getOrganName());
a_reconstruction->setStructureType(a_segment->GetSegmentLabel());
OSLM_TRACE("Structure type : " << a_reconstruction->getStructureType());
a_reconstruction->setIsAutomatic( ((a_segment->GetSegmentAlgorithmType() == ::gdcm::Segment::AUTOMATIC)? true : false) );
OSLM_TRACE("Reconstruction is automatic : " << a_reconstruction->getIsAutomatic());
}
void notifyMsg(std::string event)
{
if ( this->pickSomething() )
{
double world[3] = {-1,0,0};
::fwRenderVTK::vtk::getNearestPickedPosition(m_picker, m_adaptor->getRenderer(), world);
OSLM_TRACE("PICK" << world[0] << " ," << world[1] << " ," << world[2] );
::fwComEd::InteractionMsg::sptr msg = ::fwComEd::InteractionMsg::New();
int index[3];
m_adaptor->worldToImageSliceIndex(world, index);
msg->setEventPoint(index[0], index[1], index[2]);
msg->setEvent(event);
OSLM_TRACE( "Key Ctrl : " << m_caller->GetControlKey() );
OSLM_TRACE( "Key Shift : " << m_caller->GetShiftKey() );
msg->setModifiersStatus( ::fwComEd::InteractionMsg::CTRL, m_caller->GetControlKey());
msg->setModifiersStatus( ::fwComEd::InteractionMsg::SHIFT, m_caller->GetShiftKey());
m_adaptor->notifyEvent( msg );
}
}
void SNegatoSlicingInteractor::updateSlicing( double pickedPoint[3] )
{
::fwData::Image::sptr image = this->getInOut< ::fwData::Image >(s_IMAGE_INOUT);
SLM_ASSERT("Missing image", image);
::fwData::Integer::sptr sliceIndex[3];
this->getSliceIndex(sliceIndex);
int index[3];
int originalIndex = sliceIndex[m_orientation]->value();
this->worldToImageSliceIndex(pickedPoint, index);
index[m_orientation] = originalIndex;
OSLM_TRACE("sliceIndex[0] "<< sliceIndex[0]->value()<< " index[0] " << index[0] << " pickedPt "<<pickedPoint[0]);
OSLM_TRACE("sliceIndex[1] "<< sliceIndex[1]->value()<< " index[1] " << index[1] << " pickedPt "<<pickedPoint[1]);
OSLM_TRACE("sliceIndex[2] "<< sliceIndex[2]->value()<< " index[2] " << index[2] << " pickedPt "<<pickedPoint[2]);
#ifdef DEBUG
for ( int i = 0; i < image->getNumberOfDimensions(); i++ )
{
OSLM_ASSERT("index["<< i <<"] = " << index[i]
<< " and image->getSize()[" << i << "] = " << image->getSize()[i],
index[i] >= 0 && index[i] < image->getSize()[i]);
}
#endif
if(setSliceIndex(index))
{
auto sig = image->signal< ::fwData::Image::SliceIndexModifiedSignalType >(
::fwData::Image::s_SLICE_INDEX_MODIFIED_SIG);
{
::fwCom::Connection::Blocker block(sig->getConnection(this->slot(s_UPDATE_SLICE_INDEX_SLOT)));
sig->asyncEmit(m_axialIndex->value(), m_frontalIndex->value(), m_sagittalIndex->value());
}
}
}
bool lexicalCast( Numeric::ValueType &v, const std::string &s )
{
bool ok = false;
try
{
T val = ::boost::lexical_cast< T >( s );
v = val;
ok = true;
}
catch ( const ::boost::bad_lexical_cast &)
{
OSLM_TRACE("lexicalCast failed for '" << s << "'" << " to type: " << typeid(T).name() );
}
return ok;
}
void GzBufferImageWriter::write()
{
assert( getFile().empty() == false );
::fwData::Image::sptr image = getConcreteObject();
OSLM_TRACE( "GzBufferImageWriter::write()" << image.get() << " " << image->className()) ;
/// test if can open archive
gzFile rawFile = gzopen( getFile().string().c_str(), "wb1");
SLM_ASSERT("rawFile not instanced", rawFile);
if ( rawFile == 0 )
{
std::string str = "GzBufferImageWriter::write unable to open ";
str+= getFile().string();
gzclose(rawFile);
throw std::ios_base::failure(str);
}
::fwComEd::helper::Image imageHelper(image);
// file is OK : process now
size_t imageSizeInBytes = image->getSizeInBytes();
char *ptr = static_cast<char*>(imageHelper.getBuffer());
size_t writtenBytes = 0;
int uncompressedbyteswrited;
while ( writtenBytes < imageSizeInBytes
&& (uncompressedbyteswrited = gzwrite(rawFile, ptr+writtenBytes, imageSizeInBytes-writtenBytes)) > 0 )
{
writtenBytes += uncompressedbyteswrited;
}
gzclose(rawFile);
assert( uncompressedbyteswrited != 0 && writtenBytes==imageSizeInBytes);
if ( uncompressedbyteswrited != 0 && writtenBytes==imageSizeInBytes)
{
std::string str = "GzBufferImageWriter::write unable to write ";
str+= getFile().string();
throw std::ios_base::failure(str);
}
}
void notifyMsg(std::string event)
{
double world[3] = {-1,0,0};
this->pickSomething();
::fwRenderVTK::vtk::getNearestPickedPosition(m_picker, m_adaptor->getRenderer(), world);
OSLM_TRACE("PICK" << world[0] << " ," << world[1] << " ," << world[2] );
::fwComEd::InteractionMsg::sptr msg = ::fwComEd::InteractionMsg::New();
msg->setEventPoint(world[0], world[1], world[2]);
msg->setEvent(event);
msg->setModifiersStatus( ::fwComEd::InteractionMsg::CTRL, m_caller->GetControlKey());
msg->setModifiersStatus( ::fwComEd::InteractionMsg::SHIFT, m_caller->GetShiftKey());
msg->setEventTimestamp(::fwCore::HiResClock::getTimeInMilliSec());
m_adaptor->notifyEvent( msg );
}
void DicomStudyReader::readStudy()
{
SLM_TRACE_FUNC();
// List of tag use in this method
// const ::gdcm::Tag sDateTag(0x0008,0x0020); // Study Date
// const ::gdcm::Tag sTimeTag(0x0008,0x0030); // Study Time
// const ::gdcm::Tag sModTag(0x0008,0x0060); // Modality
// const ::gdcm::Tag sINameTag(0x0008,0x0080); // Institution Name
// const ::gdcm::Tag sDescTag(0x0008,0x1030); // Study Description
// const ::gdcm::Tag sSerDTag(0x0008,0x103e); // Series Description
// const ::gdcm::Tag sUIDTag(0x0020,0x000d); // Study Instance UID
// const ::gdcm::Tag sIDTag(0x0020,0x0010); // Study ID
// Init
::fwData::Study::sptr study = this->getConcreteObject();
const ::gdcm::DataSet & a_ds = this->getDataSet();
// Study's date
study->setDate(helper::GdcmData::getTagValue<0x0008,0x0020>(a_ds));
OSLM_TRACE("Study's date : "<<study->getDate());
// Study's time
study->setTime(helper::GdcmData::getTagValue<0x0008,0x0030>(a_ds));
OSLM_TRACE("Study's time : "<<study->getTime());
// Study's modality
study->setModality(::fwTools::toStringWithoutAccent( helper::GdcmData::getTagValue<0x0008,0x0060>(a_ds) ));
OSLM_TRACE("Study's modality : "<<study->getModality());
// Study's hospital
study->setHospital(::fwTools::toStringWithoutAccent( helper::GdcmData::getTagValue<0x0008,0x0080>(a_ds) )); // Institution Name
OSLM_TRACE("Study's hospital : "<<study->getHospital());
// Study's description
const std::string studyDesc = helper::GdcmData::getTagValue<0x0008,0x1030>(a_ds);
study->setDescription(studyDesc);
OSLM_TRACE("Study's description : "<<study->getDescription());
// Study's UID
study->setUID(helper::GdcmData::getTagValue<0x0020,0x000d>(a_ds));
OSLM_TRACE("Study's UID : "<<study->getUID());
// Study's description
study->setAcquisitionZone( ::fwTools::toStringWithoutAccent( studyDesc ));
OSLM_TRACE("Study's zone : "<<study->getAcquisitionZone());
}
//------------------------------------------------------------------------------
vtkObject* NegatoOneSlice::getImageSource()
{
if ( !m_imageSource )
{
OSLM_TRACE(this->getID() << ": Create ImageSource");
if (!m_imageSourceId.empty())
{
m_imageSource = this->getVtkObject(m_imageSourceId);
}
else
{
m_imageSource = vtkImageData::New();
m_manageImageSource = true;
}
}
return m_imageSource;
}
bool App::OnCmdLineParsed(wxCmdLineParser & parser)
{
bool parsing;
parsing = wxApp::OnCmdLineParsed(parser);
// Retrieves the substitute parameters
wxString value;
parser.Found("s", &value);
if(!value.IsEmpty())
{
std::string str ( ::fwWX::wx2std(value) );
typedef ::boost::tokenizer< ::boost::char_separator<char> > tokenizer;
::boost::char_separator<char> sep("@");
tokenizer tokens(str, sep);
assert ( std::distance (tokens.begin(),tokens.end())%2 == 0 );
for (tokenizer::iterator tok_iter = tokens.begin(); tok_iter != tokens.end(); ++tok_iter)
{
std::string key = *tok_iter;
std::string val = (*++tok_iter);
::fwRuntime::io::XMLSubstitute::getDefault()->getRefDictionary()[key]= val ;
OSLM_TRACE("Token : "<< key << " - " << val );
}
}
// // Profile path is valid ?
// m_profilePathIsValid = ::boost::filesystem::exists( m_profilePath );
//
// // Print a message if the path is not valid
// if ( ! m_profilePathIsValid )
// {
// const wxString msgPart1 = wxT("A valid profile is required to start the application. The file ");
// const wxString msgPart3 = wxT(" does not exist.");
//
// std::stringstream mes;
// mes << std::string(msgPart1.mb_str());
// mes << m_profilePath;
// mes << std::string(msgPart3.mb_str());
//
// usage(mes.str());
// parsing = false;
// }
return parsing;
}
void AlgoMeshDeformation::computeSimu()
{
SLM_TRACE_FUNC();
m_step += m_direction;
if ( m_step == m_nbStep )
{
m_direction = -1;
}
else if ( m_step == 0 )
{
m_direction = 1;
}
const float scale = m_step / (float) m_nbStep;
::fwDataTools::helper::Array originPointsHelper(m_originPoints);
::fwData::Mesh::PointsMultiArrayType points = m_meshHelper->getPoints();
::fwData::Mesh::PointColorsMultiArrayType colors = m_meshHelper->getPointColors();
::fwData::Mesh::PointsMultiArrayType opoints =
::fwData::Mesh::PointsMultiArrayType(
static_cast< ::fwData::Mesh::PointsMultiArrayType::element* >(originPointsHelper.getBuffer()),
::boost::extents[m_nbPoints][3] );
for(unsigned int i = 0; i < m_nbPoints; ++i)
{
points[i][0] = opoints[i][0];
OSLM_TRACE("opoints[i][1] - m_yCenter = " << opoints[i][1] - m_yCenter);
if( opoints[i][1] - m_yCenter > 0 )
{
points[i][1] = opoints[i][1] + (opoints[i][1] - m_yCenter) * scale;
colors[i][0] = ::fwTools::numericRoundCast< ::fwData::Mesh::ColorValueType >(255 * scale);
}
else
{
colors[i][0] = 0;
}
points[i][2] = opoints[i][2];
}
::fwDataTools::Mesh::generatePointNormals( m_mesh.lock() );
}
virtual void Execute( vtkObject* caller, unsigned long eventId, void*)
{
int pos[2];
m_service->getInteractor()->GetLastEventPosition(pos);
OSLM_TRACE( "EventId: " << eventId);
if ( eventId == vtkCommand::RightButtonPressEvent )
{
std::copy(pos, pos+1, m_lastPos);
m_display[0] = pos[0];
m_display[1] = pos[1];
this->fillPickList();
if (m_picker->Pick( m_display, m_service->getRenderer() ) )
{
if(this->getSelectedPoint())
{
this->SetAbortFlag(1);
}
else
{
m_pickedPoint.reset();
m_pickedPointList.reset();
}
}
}
else if ( (eventId == vtkCommand::RightButtonReleaseEvent ) && !m_pickedPoint.expired() &&
!m_pickedPointList.expired() && std::equal(pos, pos+1, m_lastPos) )
{
::fwData::PointList::PointListContainer& points = m_pickedPointList.lock()->getPoints();
::fwData::PointList::PointListContainer::iterator itr =
std::find( points.begin(), points.end(), m_pickedPoint.lock() );
if(itr != points.end())
{
::fwData::Point::sptr point = *itr;
points.erase(itr);
auto sig = m_pickedPointList.lock()->signal< ::fwData::PointList::PointRemovedSignalType >(
::fwData::PointList::s_POINT_REMOVED_SIG );
sig->asyncEmit(point);
}
}
}
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 Win32::load()
{
if(m_handle == 0)
{
// Opens the dynamic library.
std::string lib(getFullPath(true).string());
OSLM_TRACE("Opens the dynamic library " << lib);
m_handle = LoadLibrary( lib.c_str() );
if(m_handle == 0)
{
// Retrieves the last error message.
DWORD lastError = GetLastError();
char buffer[1024];
FormatMessage( FORMAT_MESSAGE_FROM_SYSTEM, 0, lastError, 0, buffer, 1024, 0 );
// Builds the error message and throws the exception.
std::string message( buffer );
throw RuntimeException( message );
}
}
}
void Code::onModifyValue()
{
QString value = m_valueCtrl->toPlainText();
::fwData::String::sptr stringObj = this->getInOut< ::fwData::String >(s_STRING_INOUT);
::fwData::String::sptr oldValue;
oldValue = ::fwData::Object::copy(stringObj);
std::string strValue = value.toStdString();
stringObj->value() = strValue;
if ( oldValue->value() != stringObj->value() )
{
OSLM_TRACE( stringObj->getID() << " modified");
auto sig = stringObj->signal< ::fwData::Object::ModifiedSignalType >(::fwData::Object::s_MODIFIED_SIG);
{
::fwCom::Connection::Blocker block(sig->getConnection(m_slotUpdate));
sig->asyncEmit();
}
}
}
void Image::updateImageOpacity()
{
if (m_imagePortId>= 0)
{
::fwData::Image::sptr img = this->getObject< ::fwData::Image >();
if(img->getField( "TRANSPARENCY" ) )
{
::fwData::Integer::sptr transparency = img->getField< ::fwData::Integer >( "TRANSPARENCY" );
m_imageOpacity = (100 - (*transparency) ) / 100.0 ;
}
if(img->getField( "VISIBILITY" ) )
{
::fwData::Boolean::sptr visible = img->getField< ::fwData::Boolean >( "VISIBILITY" );
m_imageOpacity = (*visible)?m_imageOpacity:0.0;
}
vtkImageBlend *imageBlend = vtkImageBlend::SafeDownCast(m_imageRegister);
imageBlend->SetOpacity(m_imagePortId, m_imageOpacity);
OSLM_TRACE( "vtkImageBlend " << this->m_imageRegisterId << " opacity :" << m_imagePortId << "," << m_imageOpacity );
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);
}
}
::fwRenderVTK::IVtkAdaptorService::sptr NegatoOneSlice::getImageSliceAdaptor()
{
::fwRenderVTK::IVtkAdaptorService::sptr imageSliceAdaptor;
if (m_imageSliceAdaptor.expired())
{
OSLM_TRACE(this->getID() << ": Create ImageSlice Adaptor Service");
::fwData::Image::sptr image;
::fwData::Composite::sptr sceneComposite;
image = this->getObject< ::fwData::Image >();
sceneComposite = this->getRenderService()->getObject< ::fwData::Composite >();
imageSliceAdaptor = ::fwServices::add< ::fwRenderVTK::IVtkAdaptorService >(
sceneComposite,
"::visuVTKAdaptor::ImageSlice"
);
imageSliceAdaptor->setRenderService(this->getRenderService());
imageSliceAdaptor->setRenderId( this->getRenderId() );
imageSliceAdaptor->setPickerId( this->getPickerId() );
imageSliceAdaptor->setTransformId( this->getTransformId() );
::visuVTKAdaptor::ImageSlice::sptr ISA;
ISA = ::visuVTKAdaptor::ImageSlice::dynamicCast(imageSliceAdaptor);
ISA->setVtkImageSource(this->getImageSource());
ISA->setCtrlImage(image);
ISA->setInterpolation(m_interpolation);
::fwComEd::helper::MedicalImageAdaptor::dynamicCast(ISA)->setOrientation((Orientation) m_orientation);
m_imageSliceAdaptor = imageSliceAdaptor;
this->registerService(imageSliceAdaptor);
}
else
{
imageSliceAdaptor = m_imageSliceAdaptor.lock();
}
return imageSliceAdaptor;
}
void SliceListEditor::onChangeSliceMode( bool checked )
{
if(::fwTools::fwID::exist(m_adaptorUID))
{
::fwServices::IService::sptr service = ::fwServices::get(m_adaptorUID);
::fwData::Image::sptr image = service->getObject< ::fwData::Image >();
SLM_ASSERT("SliceListEditor adaptorUID " << m_adaptorUID <<" isn't an Adaptor on an Image?" , image);
::fwData::Integer::sptr dataInfo = ::fwData::Integer::New();
if(m_oneSliceItem->isChecked())
{
dataInfo->value() = 1;
m_nbSlice = 1;
}
else if(m_threeSlicesItem->isChecked())
{
dataInfo->value() = 3;
m_nbSlice = 3;
}
else if(m_obliqueSliceItem->isChecked())
{
dataInfo->value() = -1;
m_nbSlice = -1;
}
else
{
OSLM_FATAL("Unknown slice mode");
}
dataInfo->setField(::fwComEd::Dictionary::m_relatedServiceId , ::fwData::String::New( m_adaptorUID ) );
::fwComEd::ImageMsg::sptr imageMsg = ::fwComEd::ImageMsg::New();
imageMsg->addEvent( "SLICE_MODE", dataInfo );
::fwServices::IEditionService::notify(this->getSptr(), image, imageMsg);
}
else
{
OSLM_TRACE("Service "<< m_adaptorUID << " is not yet present.");
}
}
void SJumpToPointController::jumpToViewPoint(::fwData::TransformationMatrix3D::sptr matrix)
{
OSLM_TRACE(" DisplayMatrixReceived " << *(matrix));
// Get the current matrix
::fwData::TransformationMatrix3D::sptr currentMatrix = this->getInOut< ::fwData::TransformationMatrix3D >(
S_MATRIX_KEY);
// Modify this matrix
for(int lt = 0; lt < 4; lt++)
{
for(int ct = 0; ct < 4; ct++)
{
currentMatrix->setCoefficient(lt, ct, matrix->getCoefficient(lt, ct));
}
}
auto sig = currentMatrix->signal< ::fwData::Object::ModifiedSignalType >(::fwData::Object::s_MODIFIED_SIG);
{
::fwCom::Connection::Blocker block(sig->getConnection(m_slotUpdate));
sig->asyncEmit();
}
}
//------------------------------------------------------------------------------
::fwRenderVTK::IVtkAdaptorService::sptr NegatoOneSlice::getImageAdaptor()
{
::fwRenderVTK::IVtkAdaptorService::sptr imageAdaptor;
if (m_imageAdaptor.expired())
{
OSLM_TRACE(this->getID() << ": Create Image Adaptor Service");
::fwData::Image::sptr image;
image = this->getObject< ::fwData::Image >();
imageAdaptor = ::fwServices::add< ::fwRenderVTK::IVtkAdaptorService >(
image,
"::visuVTKAdaptor::Image"
);
imageAdaptor->setRenderService(this->getRenderService());
imageAdaptor->setRenderId( this->getRenderId() );
imageAdaptor->setPickerId( this->getPickerId() );
imageAdaptor->setTransformId( this->getTransformId() );
::visuVTKAdaptor::Image::sptr IA;
IA = ::visuVTKAdaptor::Image::dynamicCast(imageAdaptor);
IA->setVtkImageRegister(this->getImageSource());
IA->setSelectedTFKey( this->getSelectedTFKey() );
IA->setTFSelectionFwID( this->getTFSelectionFwID() );
IA->setImageOpacity(1.);
IA->setAllowAlphaInTF(m_allowAlphaInTF);
m_imageAdaptor = imageAdaptor;
this->registerService(imageAdaptor);
}
else
{
imageAdaptor = m_imageAdaptor.lock();
}
return imageAdaptor;
}
wxThread::ExitCode PulseProgressDialog::LocalThread::Entry()
{
try
{
m_stuff();
}
catch ( std::exception &e)
{
m_errorMessage = e.what();
}
m_isFinished=true;
// TODO meilleur arret
// Don't Poll a wxThread
// A common problem users experience with wxThread is that in their main thread they will check the thread every now
//and then to see if it has ended through IsRunning(), only to find that their application has run into problems because
//the thread is using the default behavior (i.e. it's detached) and has already deleted itself. Naturally, they instead
// attempt to use joinable threads in place of the previous behavior. However, polling a wxThread for when it has ended is
// in general a bad idea - in fact calling a routine on any running wxThread should be avoided if possible. Instead, find a
// way to notify yourself when the thread has ended.
// wxQueueEvent(m_client, new wxThreadEvent(wxEVT_LOCALTHREAD_COMPLETED)); avec m_client un addr sur PulseProgressDialog qui a lanc� le thread
OSLM_TRACE("UUU PulseProgressDialog::LocalThread::Entry() FINI !!!!");
return (wxThread::ExitCode)0; // success
}
void SMeshCreation::updating()
{
SLM_TRACE_FUNC();
/// Retrieve objects
auto pImage = this->getInput< ::fwData::Image >("image");
SLM_ASSERT("'image' key not found", pImage);
auto pMesh = this->getInOut< ::fwData::Mesh >("mesh");
SLM_ASSERT("'mesh' key not found", pMesh);
///VTK Mesher
// vtk img
vtkSmartPointer< vtkImageData > vtkImage = vtkSmartPointer< vtkImageData >::New();
::fwVtkIO::toVTKImage( pImage, vtkImage );
// contour filter
vtkSmartPointer< vtkDiscreteMarchingCubes > contourFilter = vtkSmartPointer< vtkDiscreteMarchingCubes >::New();
contourFilter->SetInputData(vtkImage);
contourFilter->SetValue(0, 255);
contourFilter->ComputeScalarsOn();
contourFilter->ComputeNormalsOn();
contourFilter->Update();
// smooth filter
vtkSmartPointer< vtkWindowedSincPolyDataFilter > smoothFilter =
vtkSmartPointer< vtkWindowedSincPolyDataFilter >::New();
smoothFilter->SetInputConnection(contourFilter->GetOutputPort());
smoothFilter->SetNumberOfIterations( 50 );
smoothFilter->BoundarySmoothingOn();
smoothFilter->SetPassBand ( 0.1 );
smoothFilter->SetFeatureAngle(120.0);
smoothFilter->SetEdgeAngle(90);
smoothFilter->FeatureEdgeSmoothingOn();
smoothFilter->Update();
// Get polyData
vtkSmartPointer< vtkPolyData > polyData;
// decimate filter
unsigned int reduction = m_reduction;
if( reduction > 0 )
{
vtkSmartPointer< vtkDecimatePro > decimate = vtkSmartPointer< vtkDecimatePro >::New();
decimate->SetInputConnection( smoothFilter->GetOutputPort() );
decimate->SetTargetReduction( reduction/100.0 );
decimate->PreserveTopologyOff();
decimate->SplittingOn();
decimate->BoundaryVertexDeletionOn();
decimate->SetSplitAngle( 120 );
decimate->Update();
polyData = decimate->GetOutput();
OSLM_TRACE("final GetNumberOfCells = " << polyData->GetNumberOfCells());
::fwVtkIO::helper::Mesh::fromVTKMesh( polyData, pMesh);
}
else
{
polyData = smoothFilter->GetOutput();
OSLM_TRACE("final GetNumberOfCells = " << polyData->GetNumberOfCells());
::fwVtkIO::helper::Mesh::fromVTKMesh( polyData, pMesh);
}
/// Notification
::fwData::Object::ModifiedSignalType::sptr sig;
sig = pMesh->signal< ::fwData::Object::ModifiedSignalType >(::fwData::Object::s_MODIFIED_SIG);
{
::fwCom::Connection::Blocker block(sig->getConnection(m_slotUpdate));
sig->asyncEmit();
}
}
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 );
}
}
}
void DicomStudyReader::read() throw(::fwTools::Failed)
{
SLM_TRACE_FUNC();
::fwData::Study::sptr study = this->getConcreteObject();
SLM_ASSERT("::fwData::Study not set", study);
//***** Get all file names *****//
std::vector< std::string > studyFiles = this->getFileNames(); // files which contain a common study
OSLM_TRACE("Number of files for a study : " << studyFiles.size());
//***** Get group of file names for each series *****//
const ::gdcm::Tag gTagSUID(0x0020,0x000e); // Series UID
const ::gdcm::Tag gTagImageType(0x0008,0x0008); // ImageType
gdcm::Scanner gScanner;
gScanner.AddTag(gTagSUID);
gScanner.AddTag(gTagImageType);
if( !gScanner.Scan( studyFiles ) )
{
throw ::fwTools::Failed("No series found");
}
::gdcm::Directory::FilenamesType keys = gScanner.GetKeys();
::gdcm::Directory::FilenamesType::const_iterator it = keys.begin();
::gdcm::Directory::FilenamesType::const_iterator itEnd = keys.end();
// Create a map to associate each series with its files.
std::map< std::string, std::vector< std::string > > seriesMap; // Key : series UID ; Value : filenames found
int secondaryCaptureCounter = 0;
for(; it != itEnd; ++it)
{
const char * filename = it->c_str();
const char * seriesUID = gScanner.GetValue(filename, gTagSUID);
if (seriesUID != 0)
{
std::string seriesKey(seriesUID);
// Treatment of secondary capture dicom file.
if(gScanner.GetValue(filename, gTagImageType))
{
std::string imageType(gScanner.GetValue(filename, gTagImageType));
std::string::size_type idx = imageType.find("DERIVED\\SECONDARY");
if( idx != std::string::npos)
{
std::string::size_type endIdx = imageType.find_first_not_of("DERIVED\\SECONDARY");
std::string optionalInfo = imageType.substr(endIdx);
std::ostringstream indice;
if(!optionalInfo.empty())
{
indice << optionalInfo;
}
else
{
// Tag as Secondary Capture
indice << "_SC_" << secondaryCaptureCounter;
secondaryCaptureCounter++;
}
seriesKey += indice.str();
}
}
seriesMap[seriesKey].push_back( filename );
}
else
{
OSLM_ERROR ( "No study UID found in : " << filename );
}
}
//***** Read each patient (and so studies, series, ...) *****//
DicomSeriesReader seriesReader;
std::map< std::string, std::vector< std::string > >::iterator itMap = seriesMap.begin();
std::map< std::string, std::vector< std::string > >::iterator itMapEnd = seriesMap.end();
while (itMap != itMapEnd)
{
OSLM_TRACE ( "Series map key : " << itMap->first );
if ( itMap->second.size() > 0 )
{
OSLM_TRACE ( "First series map value : " << *(itMap->second.begin()) );
seriesReader.setFileNames(itMap->second);
::fwData::Acquisition::NewSptr series;
seriesReader.setObject(series);
try
{
// Read one series
seriesReader.read();
// Add a complete series
study->addAcquisition(series);
}
catch (::fwTools::Failed & e)
{
OSLM_ERROR ("Reading error with series : " << itMap->first);
// Acquisition skipped
}
}
itMap++;
}
if(study->getNumberOfAcquisitions() == 0)
throw ::fwTools::Failed("Study has no acquisition");
//***** Read study *****//
this->setReader( seriesReader.getReader() );
this->readStudy();
}
