void
ipMITKSegmentationUndo (mitkIpPicDescriptor* segmentation)
{
mitkIpPicTSV_t *undo, *data;
assert (segmentation);
undo = mitkIpPicQueryTag (segmentation, tagUNDO);
if (!undo) {
ipMITKSegmentationError (ipMITKSegmentationUNDO_DISABLED);
}
/* if any level is stored ... */
data = mitkIpPicQuerySubTag (undo, tagUNDO_DATA);
if (data->n[0]) {
/* ... replace the image data and remove this level */
_mitkIpPicTagsElement_t* head = (_mitkIpPicTagsElement_t *) data->value;
_mitkIpPicTagsElement_t* current = head;
mitkIpPicTSV_t* tag;
while( current->next != NULL ) {
current = current->next;
}
tag = _mitkIpPicRemoveTag (&head, current, current->tsv->tag);
data->value = head;
data->n[0]--;
memmove (segmentation->data, tag->value, _mitkIpPicSize (segmentation));
mitkIpPicFreeTag (tag);
tag = mitkIpPicDelTag (segmentation, tagSEGMENTATION_EMPTY);
if (tag) {
mitkIpPicFreeTag (tag);
}
}
}
mitkIpBool_t
ipMITKSegmentationUndoIsEnabled (mitkIpPicDescriptor* segmentation)
{
mitkIpPicTSV_t *undo = NULL;
if (segmentation) {
undo = mitkIpPicQueryTag (segmentation, tagUNDO);
}
return (undo ? mitkIpTrue : mitkIpFalse);
}
void mitk::PicFileReader::FillImage(Image::Pointer output)
{
mitkIpPicDescriptor *outputPic = mitkIpPicNew();
outputPic = CastToIpPicDescriptor(output, nullptr, outputPic);
mitkIpPicDescriptor *pic = mitkIpPicGet(const_cast<char *>(this->GetLocalFileName().c_str()), outputPic);
// comes upside-down (in MITK coordinates) from PIC file
ConvertHandedness(pic);
mitkIpPicTSV_t *tsv;
if ((tsv = mitkIpPicQueryTag(pic, "SOURCE HEADER")) != NULL)
{
if (tsv->n[0] > 1e+06)
{
mitkIpPicTSV_t *tsvSH;
tsvSH = mitkIpPicDelTag(pic, "SOURCE HEADER");
mitkIpPicFreeTag(tsvSH);
}
}
if ((tsv = mitkIpPicQueryTag(pic, "ICON80x80")) != NULL)
{
mitkIpPicTSV_t *tsvSH;
tsvSH = mitkIpPicDelTag(pic, "ICON80x80");
mitkIpPicFreeTag(tsvSH);
}
if ((tsv = mitkIpPicQueryTag(pic, "VELOCITY")) != NULL)
{
mitkIpPicDescriptor *header = mitkIpPicCopyHeader(pic, NULL);
header->data = tsv->value;
ConvertHandedness(header);
output->SetChannel(header->data, 1);
header->data = NULL;
mitkIpPicFree(header);
mitkIpPicDelTag(pic, "VELOCITY");
}
// Copy the memory to avoid mismatches of malloc() and delete[].
// mitkIpPicGet will always allocate a new memory block with malloc(),
// but MITK Images delete the data via delete[].
output->SetImportChannel(pic->data, 0, Image::CopyMemory);
pic->data = nullptr;
mitkIpPicFree(pic);
}
mitkIpBool_t
ipMITKSegmentationUndoAvailable (mitkIpPicDescriptor* segmentation)
{
mitkIpPicTSV_t *undo, *data;
assert (segmentation);
undo = mitkIpPicQueryTag (segmentation, tagUNDO);
if (!undo) {
ipMITKSegmentationError (ipMITKSegmentationUNDO_DISABLED);
}
data = mitkIpPicQuerySubTag (undo, tagUNDO_DATA);
return (data->n[0] ? mitkIpTrue : mitkIpFalse);
}
void
ipMITKSegmentationUndoSave (mitkIpPicDescriptor* segmentation)
{
mitkIpPicTSV_t *undo, *data, *level, *tag;
assert (segmentation);
undo = mitkIpPicQueryTag (segmentation, tagUNDO);
if (!undo) {
ipMITKSegmentationError (ipMITKSegmentationUNDO_DISABLED);
}
/* if no level is available ... */
data = mitkIpPicQuerySubTag (undo, tagUNDO_DATA);
level = mitkIpPicQuerySubTag (undo, tagUNDO_LEVEL);
if (*((mitkIpUInt1_t *) level->value) > 0) {
if (data->n[0] == *((mitkIpUInt1_t *) level->value)) {
/* ... remove the first one. */
_mitkIpPicTagsElement_t* head = (_mitkIpPicTagsElement_t *) data->value;
mitkIpPicTSV_t* tag = _mitkIpPicRemoveTag (&head, head, head->tsv->tag);
data->value = head;
data->n[0]--;
mitkIpPicFreeTag (tag);
}
/* build and store the level */
tag = (mitkIpPicTSV_t *) malloc (sizeof (mitkIpPicTSV_t));
if (!tag) {
ipMITKSegmentationError (ipMITKSegmentationOUT_OF_MEMORY);
}
strcpy (tag->tag, "IMAGE");
tag->type = segmentation->type;
tag->bpe = segmentation->bpe;
tag->dim = segmentation->dim;
tag->n[0] = segmentation->n[0];
tag->n[1] = segmentation->n[1];
tag->value = malloc (_mitkIpPicSize (segmentation));
memmove (tag->value, segmentation->data, _mitkIpPicSize (segmentation));
mitkIpPicAddSubTag (data, tag);
}
}
void mitk::PicFileReader::GenerateOutputInformation()
{
Image::Pointer output = this->GetOutput();
if ((output->IsInitialized()) && (this->GetMTime() <= m_ReadHeaderTime.GetMTime()))
return;
itkDebugMacro(<<"Reading file for GenerateOutputInformation()" << m_FileName);
// Check to see if we can read the file given the name or prefix
//
if ( m_FileName == "" && m_FilePrefix == "" )
{
throw itk::ImageFileReaderException(__FILE__, __LINE__, "One of FileName or FilePrefix must be non-empty");
}
if( m_FileName != "")
{
mitkIpPicDescriptor* header=mitkIpPicGetHeader(const_cast<char *>(m_FileName.c_str()), NULL);
if ( !header )
{
throw itk::ImageFileReaderException(__FILE__, __LINE__, "File could not be read.");
}
header=MITKipPicGetTags(const_cast<char *>(m_FileName.c_str()), header);
int channels = 1;
mitkIpPicTSV_t *tsv;
if ( (tsv = mitkIpPicQueryTag( header, "SOURCE HEADER" )) != NULL)
{
if(tsv->n[0]>1e+06)
{
mitkIpPicTSV_t *tsvSH;
tsvSH = mitkIpPicDelTag( header, "SOURCE HEADER" );
mitkIpPicFreeTag(tsvSH);
}
}
if ( (tsv = mitkIpPicQueryTag( header, "ICON80x80" )) != NULL)
{
mitkIpPicTSV_t *tsvSH;
tsvSH = mitkIpPicDelTag( header, "ICON80x80" );
mitkIpPicFreeTag(tsvSH);
}
if ( (tsv = mitkIpPicQueryTag( header, "VELOCITY" )) != NULL)
{
++channels;
mitkIpPicDelTag( header, "VELOCITY" );
}
if( header == NULL || header->bpe == 0)
{
itk::ImageFileReaderException e(__FILE__, __LINE__);
itk::OStringStream msg;
msg << " Could not read file "
<< m_FileName.c_str();
e.SetDescription(msg.str().c_str());
throw e;
return;
}
// First initialize the geometry of the output image by the pic-header
SlicedGeometry3D::Pointer slicedGeometry = mitk::SlicedGeometry3D::New();
PicHelper::InitializeEvenlySpaced(header, header->n[2], slicedGeometry);
// if pic image only 3D, the n[3] value is not initialized
unsigned int timesteps = 1;
if( header->dim > 3 )
timesteps = header->n[3];
TimeSlicedGeometry::Pointer timeSliceGeometry = TimeSlicedGeometry::New();
timeSliceGeometry->InitializeEvenlyTimed(slicedGeometry, timesteps);
timeSliceGeometry->ImageGeometryOn();
// Cast the pic descriptor to ImageDescriptor and initialize the output
output->Initialize( CastToImageDescriptor(header));
output->SetGeometry( timeSliceGeometry );
mitkIpPicFree ( header );
}
else
{
int numberOfImages=0;
m_StartFileIndex=0;
mitkIpPicDescriptor* header=NULL;
char fullName[1024];
while(m_StartFileIndex<10)
{
sprintf(fullName, m_FilePattern.c_str(), m_FilePrefix.c_str(), m_StartFileIndex+numberOfImages);
FILE * f=fopen(fullName,"r");
if(f==NULL)
{
//already found an image?
if(numberOfImages>0)
break;
//no? let's increase start
++m_StartFileIndex;
}
else
{
fclose(f);
//only open the header of the first file found,
//@warning what to do when images do not have the same size??
if(header==NULL)
{
header=mitkIpPicGetHeader(fullName, NULL);
header=MITKipPicGetTags(fullName, header);
}
++numberOfImages;
}
}
printf("\n numberofimages %d\n",numberOfImages);
if(numberOfImages==0)
{
itk::ImageFileReaderException e(__FILE__, __LINE__);
itk::OStringStream msg;
msg << "no images found";
e.SetDescription(msg.str().c_str());
throw e;
return;
}
//@FIXME: was ist, wenn die Bilder nicht alle gleich gross sind?
if(numberOfImages>1)
{
printf("\n numberofimages %d > 1\n",numberOfImages);
header->dim=3;
header->n[2]=numberOfImages;
}
printf(" \ninitialisize output\n");
output->Initialize( CastToImageDescriptor(header) );
mitkIpPicFree ( header );
}
m_ReadHeaderTime.Modified();
}
void mitk::PicFileReader::GenerateData()
{
Image::Pointer output = this->GetOutput();
// Check to see if we can read the file given the name or prefix
//
if ( m_FileName == "" && m_FilePrefix == "" )
{
throw itk::ImageFileReaderException(__FILE__, __LINE__, "One of FileName or FilePrefix must be non-empty");
}
if( m_FileName != "")
{
mitkIpPicDescriptor* outputPic = mitkIpPicNew();
outputPic = CastToIpPicDescriptor(output, outputPic);
mitkIpPicDescriptor* pic=MITKipPicGet(const_cast<char *>(m_FileName.c_str()),
outputPic);
// comes upside-down (in MITK coordinates) from PIC file
ConvertHandedness(pic);
mitkIpPicTSV_t *tsv;
if ( (tsv = mitkIpPicQueryTag( pic, "SOURCE HEADER" )) != NULL)
{
if(tsv->n[0]>1e+06)
{
mitkIpPicTSV_t *tsvSH;
tsvSH = mitkIpPicDelTag( pic, "SOURCE HEADER" );
mitkIpPicFreeTag(tsvSH);
}
}
if ( (tsv = mitkIpPicQueryTag( pic, "ICON80x80" )) != NULL)
{
mitkIpPicTSV_t *tsvSH;
tsvSH = mitkIpPicDelTag( pic, "ICON80x80" );
mitkIpPicFreeTag(tsvSH);
}
if ( (tsv = mitkIpPicQueryTag( pic, "VELOCITY" )) != NULL)
{
mitkIpPicDescriptor* header = mitkIpPicCopyHeader(pic, NULL);
header->data = tsv->value;
ConvertHandedness(header);
output->SetChannel(header->data, 1);
header->data = NULL;
mitkIpPicFree(header);
mitkIpPicDelTag( pic, "VELOCITY" );
}
//slice-wise reading
//currently much too slow.
//else
//{
// int sstart, smax;
// int tstart, tmax;
// sstart=output->GetRequestedRegion().GetIndex(2);
// smax=sstart+output->GetRequestedRegion().GetSize(2);
// tstart=output->GetRequestedRegion().GetIndex(3);
// tmax=tstart+output->GetRequestedRegion().GetSize(3);
// int s,t;
// for(s=sstart; s<smax; ++s)
// {
// for(t=tstart; t<tmax; ++t)
// {
// mitkIpPicDescriptor* pic=mitkIpPicGetSlice(const_cast<char *>(m_FileName.c_str()), NULL, t*smax+s+1);
// output->SetPicSlice(pic,s,t);
// }
// }
//}
}
else
{
int position;
mitkIpPicDescriptor* pic=NULL;
int zDim=(output->GetDimension()>2?output->GetDimensions()[2]:1);
printf("\n zdim is %u \n",zDim);
for (position = 0; position < zDim; ++position)
{
char fullName[1024];
sprintf(fullName, m_FilePattern.c_str(), m_FilePrefix.c_str(), m_StartFileIndex+position);
pic=MITKipPicGet(fullName, pic);
if(pic==NULL)
{
itkDebugMacro("Pic file '" << fullName << "' does not exist.");
}
/* FIXME else
if(output->SetPicSlice(pic, position)==false)
{
itkDebugMacro("Image '" << fullName << "' could not be added to Image.");
}*/
}
if(pic!=NULL)
mitkIpPicFree(pic);
}
}
main( int argc, char *argv[] )
{
XtAppContext app_context;
Widget toplevel, bb, pic, annotation;
/*Widget button;*/
toplevel = XtVaAppInitialize( &app_context,
"Test",
NULL, 0,
&argc, argv,
fallback_resources,
NULL );
XtAddEventHandler( toplevel,
(EventMask)0,
True,_XEditResCheckMessages,
NULL );
n = 0;
XtSetArg( args[n], XmNheight, 400 ); n++;
XtSetArg( args[n], XmNwidth, 400 ); n++;
XtSetValues( toplevel, args, n );
bb = XmCreateDrawingArea( toplevel, "bb", args, n );
XtManageChild( bb );
n = 0;
XtSetArg( args[n], XmNx, 200 ); n++;
XtSetArg( args[n], XmNy, 100 ); n++;
annotation = XtCreateManagedWidget( "annotation",
xipAnnotationWidgetClass,
bb,
args, n );
XtAddCallback( annotation, XipNactivateCallback, activate, NULL );
n = 0;
XtSetArg( args[n], XmNx, 0 ); n++;
XtSetArg( args[n], XmNy, 0 ); n++;
XtSetArg( args[n], XipNquantisation, True ); n++;
XtSetArg( args[n], XipNpic, mitkIpPicGet( "../b.pic", NULL ) ); n++;
pic = XtCreateManagedWidget( "pic",
xipPicWidgetClass,
bb,
args, n );
/**************/
XtRealizeWidget( toplevel );
/**************/
{
mitkIpPicDescriptor *pic;
_mitkIpPicTagsElement_t *head;
mitkIpPicTSV_t *tsv;
pic = mitkIpPicGetTags( "../b.pic",
NULL );
tsv = mitkIpPicQueryTag( pic, "ANNOTATION" );
if( tsv != NULL )
{
head = tsv->value;
tsv = _mitkIpPicFindTag( head, "TEXT" )->tsv;
text = malloc( strlen(tsv->value) );
strcpy( text, tsv->value );
printf( "%s\n", text );
tsv = _mitkIpPicFindTag( head, "POSITION" )->tsv;
x = ((mitkIpUInt4_t *)(tsv->value))[0];
y = ((mitkIpUInt4_t *)(tsv->value))[1];
printf( "%i %i\n", x, y );
}
mitkIpPicFree( pic );
}
/**************/
XtVaSetValues( annotation,
XmNx, x,
XmNy, y,
NULL );
/**************/
XtAppMainLoop(app_context);
}
bool mitk::PicHelper::GetSpacing(const mitkIpPicDescriptor* aPic, Vector3D & spacing)
{
mitkIpPicDescriptor* pic = const_cast<mitkIpPicDescriptor*>(aPic);
mitkIpPicTSV_t *tsv;
bool pixelSize = false;
tsv = mitkIpPicQueryTag( pic, "REAL PIXEL SIZE" );
if(tsv==NULL)
{
tsv = mitkIpPicQueryTag( pic, "PIXEL SIZE" );
pixelSize = true;
}
if(tsv)
{
bool tagFound = false;
if((tsv->dim*tsv->n[0]>=3) && (tsv->type==mitkIpPicFloat))
{
if(tsv->bpe==32)
{
FillVector3D(spacing,((mitkIpFloat4_t*)tsv->value)[0], ((mitkIpFloat4_t*)tsv->value)[1],((mitkIpFloat4_t*)tsv->value)[2]);
tagFound = true;
}
else if(tsv->bpe==64)
{
FillVector3D(spacing,((mitkIpFloat8_t*)tsv->value)[0], ((mitkIpFloat8_t*)tsv->value)[1],((mitkIpFloat8_t*)tsv->value)[2]);
tagFound = true;
}
}
if(tagFound && pixelSize)
{
tsv = mitkIpPicQueryTag( pic, "PIXEL SPACING" );
if(tsv)
{
mitk::ScalarType zSpacing = 0;
if((tsv->dim*tsv->n[0]>=3) && (tsv->type==mitkIpPicFloat))
{
if(tsv->bpe==32)
{
zSpacing = ((mitkIpFloat4_t*)tsv->value)[2];
}
else if(tsv->bpe==64)
{
zSpacing = ((mitkIpFloat8_t*)tsv->value)[2];
}
if(zSpacing != 0)
{
spacing[2] = zSpacing;
}
}
}
}
if(tagFound) return true;
}
#ifdef HAVE_IPDICOM
tsv = mitkIpPicQueryTag( pic, "SOURCE HEADER" );
if( tsv )
{
void *data;
mitkIpUInt4_t len;
mitkIpFloat8_t spacing_z = 0;
mitkIpFloat8_t thickness = 1;
mitkIpFloat8_t fx = 1;
mitkIpFloat8_t fy = 1;
bool ok=false;
if( dicomFindElement( (unsigned char *) tsv->value, 0x0018, 0x0088, &data, &len ) )
{
ok=true;
sscanf( (char *) data, "%lf", &spacing_z );
// itkGenericOutputMacro( "spacing: " << spacing_z << " mm");
}
if( dicomFindElement( (unsigned char *) tsv->value, 0x0018, 0x0050, &data, &len ) )
{
ok=true;
sscanf( (char *) data, "%lf", &thickness );
// itkGenericOutputMacro( "thickness: " << thickness << " mm");
if( thickness == 0 )
thickness = 1;
}
if( dicomFindElement( (unsigned char *) tsv->value, 0x0028, 0x0030, &data, &len )
&& len>0 && ((char *)data)[0] )
{
sscanf( (char *) data, "%lf\\%lf", &fy, &fx ); // row / column value
// itkGenericOutputMacro( "fx, fy: " << fx << "/" << fy << " mm");
}
else
ok=false;
if(ok)
FillVector3D(spacing, fx, fy,( spacing_z > 0 ? spacing_z : thickness));
return ok;
}
#endif /* HAVE_IPDICOM */
if(spacing[0]<=0 || spacing[1]<=0 || spacing[2]<=0)
{
itkGenericOutputMacro(<< "illegal spacing by pic tag: " << spacing << ". Setting spacing to (1,1,1).");
spacing.Fill(1);
}
void
ipMITKSegmentationUndoEnable (mitkIpPicDescriptor* segmentation, const mitkIpUInt1_t level)
{
mitkIpPicTSV_t *undo, *data, *max;
assert (segmentation);
undo = mitkIpPicQueryTag (segmentation, tagUNDO);
if (!undo) {
undo = (mitkIpPicTSV_t *) malloc (sizeof (mitkIpPicTSV_t));
if (!undo) {
ipMITKSegmentationError (ipMITKSegmentationOUT_OF_MEMORY);
}
strcpy (undo->tag, tagUNDO);
undo->type = mitkIpPicTSV;
undo->bpe = 32;
undo->dim = 1;
undo->n[0] = 0;
undo->value = NULL;
mitkIpPicAddTag (segmentation, undo);
}
data = mitkIpPicQuerySubTag (undo, tagUNDO_DATA);
if (!data) {
data = (mitkIpPicTSV_t *) malloc (sizeof (mitkIpPicTSV_t));
if (!data) {
ipMITKSegmentationError (ipMITKSegmentationOUT_OF_MEMORY);
}
strcpy (data->tag, tagUNDO_DATA);
data->type = mitkIpPicTSV;
data->bpe = 32;
data->dim = 1;
data->n[0] = 0;
data->value = NULL;
mitkIpPicAddSubTag (undo, data);
}
if (data->n[0] > level) {
/* remove levels which exceed the maximum */
mitkIpUInt1_t i;
for (i = data->n[0] - level; i > 0; i--) {
_mitkIpPicTagsElement_t *head = (_mitkIpPicTagsElement_t *) data->value;
mitkIpPicTSV_t* tag = _mitkIpPicRemoveTag (&head, head, head->tsv->tag);
data->value = head;
data->n[0]--;
mitkIpPicFreeTag (tag);
}
}
max = mitkIpPicQuerySubTag (undo, tagUNDO_LEVEL);
if (max) {
/* change the maximum of levels */
mitkIpUInt1_t* value = (mitkIpUInt1_t *) max->value;
*value = level;
} else {
mitkIpUInt1_t* value = (mitkIpUInt1_t *) malloc (sizeof (mitkIpUInt1_t));
if (!value) {
ipMITKSegmentationError (ipMITKSegmentationOUT_OF_MEMORY);
}
*value = level;
max = (mitkIpPicTSV_t *) malloc (sizeof (mitkIpPicTSV_t));
if (!max) {
ipMITKSegmentationError (ipMITKSegmentationOUT_OF_MEMORY);
}
strcpy (max->tag, tagUNDO_LEVEL);
max->type = mitkIpPicUInt;
max->bpe = 8;
max->dim = 1;
max->n[0] = 1;
max->value = value;
mitkIpPicAddSubTag (undo, max);
}
}
mitk::Image::Pointer mitk::PicFileReader::CreateImage()
{
Image::Pointer output = Image::New();
std::string fileName = this->GetLocalFileName();
mitkIpPicDescriptor *header = mitkIpPicGetHeader(const_cast<char *>(fileName.c_str()), NULL);
if (!header)
{
mitkThrow() << "File could not be read.";
}
header = mitkIpPicGetTags(const_cast<char *>(fileName.c_str()), header);
int channels = 1;
mitkIpPicTSV_t *tsv;
if ((tsv = mitkIpPicQueryTag(header, "SOURCE HEADER")) != NULL)
{
if (tsv->n[0] > 1e+06)
{
mitkIpPicTSV_t *tsvSH;
tsvSH = mitkIpPicDelTag(header, "SOURCE HEADER");
mitkIpPicFreeTag(tsvSH);
}
}
if ((tsv = mitkIpPicQueryTag(header, "ICON80x80")) != NULL)
{
mitkIpPicTSV_t *tsvSH;
tsvSH = mitkIpPicDelTag(header, "ICON80x80");
mitkIpPicFreeTag(tsvSH);
}
if ((tsv = mitkIpPicQueryTag(header, "VELOCITY")) != NULL)
{
++channels;
mitkIpPicDelTag(header, "VELOCITY");
}
if (header == NULL || header->bpe == 0)
{
mitkThrow() << " Could not read file " << fileName;
}
// if pic image only 2D, the n[2] value is not initialized
unsigned int slices = 1;
if (header->dim == 2)
{
header->n[2] = slices;
}
// First initialize the geometry of the output image by the pic-header
SlicedGeometry3D::Pointer slicedGeometry = mitk::SlicedGeometry3D::New();
PicHelper::InitializeEvenlySpaced(header, header->n[2], slicedGeometry);
// if pic image only 3D, the n[3] value is not initialized
unsigned int timesteps = 1;
if (header->dim > 3)
{
timesteps = header->n[3];
}
slicedGeometry->ImageGeometryOn();
ProportionalTimeGeometry::Pointer timeGeometry = ProportionalTimeGeometry::New();
timeGeometry->Initialize(slicedGeometry, timesteps);
// Cast the pic descriptor to ImageDescriptor and initialize the output
output->Initialize(CastToImageDescriptor(header));
output->SetTimeGeometry(timeGeometry);
mitkIpPicFree(header);
return output;
}
