bool mitk::Image::IsVolumeSet_unlocked(int t, int n) const
{
if(IsValidVolume(t,n)==false) return false;
ImageDataItemPointer ch, vol;
// volume directly available?
vol=m_Volumes[GetVolumeIndex(t,n)];
if((vol.GetPointer()!=nullptr) && (vol->IsComplete()))
return true;
// is volume available as part of a channel that is available?
ch=m_Channels[n];
if((ch.GetPointer()!=nullptr) && (ch->IsComplete()))
return true;
// let's see if all slices of the volume are set, so that we can (could) combine them to a volume
unsigned int s;
for(s=0;s<m_Dimensions[2];++s)
{
if(m_Slices[GetSliceIndex(s,t,n)].GetPointer()==nullptr)
{
return false;
}
}
return true;
}
mitk::Image::ImageDataItemPointer mitk::Image::GetSliceData(int s, int t, int n, void *data, ImportMemoryManagementType importMemoryManagement)
{
if(IsValidSlice(s,t,n)==false) return NULL;
const size_t ptypeSize = this->m_ImageDescriptor->GetChannelTypeById(n).GetSize();
// slice directly available?
int pos=GetSliceIndex(s,t,n);
if(m_Slices[pos].GetPointer()!=NULL)
return m_Slices[pos];
// is slice available as part of a volume that is available?
ImageDataItemPointer sl, ch, vol;
vol=m_Volumes[GetVolumeIndex(t,n)];
if((vol.GetPointer()!=NULL) && (vol->IsComplete()))
{
sl=new ImageDataItem(*vol, m_ImageDescriptor, 2, data, importMemoryManagement == ManageMemory, ((size_t) s)*m_OffsetTable[2]*(ptypeSize));
sl->SetComplete(true);
return m_Slices[pos]=sl;
}
// is slice available as part of a channel that is available?
ch=m_Channels[n];
if((ch.GetPointer()!=NULL) && (ch->IsComplete()))
{
sl=new ImageDataItem(*ch, m_ImageDescriptor, 2, data, importMemoryManagement == ManageMemory, (((size_t) s)*m_OffsetTable[2]+((size_t) t)*m_OffsetTable[3])*(ptypeSize));
sl->SetComplete(true);
return m_Slices[pos]=sl;
}
// slice is unavailable. Can we calculate it?
if((GetSource().IsNotNull()) && (GetSource()->Updating()==false))
{
// ... wir mussen rechnen!!! ....
m_RequestedRegion.SetIndex(0, 0);
m_RequestedRegion.SetIndex(1, 0);
m_RequestedRegion.SetIndex(2, s);
m_RequestedRegion.SetIndex(3, t);
m_RequestedRegion.SetIndex(4, n);
m_RequestedRegion.SetSize(0, m_Dimensions[0]);
m_RequestedRegion.SetSize(1, m_Dimensions[1]);
m_RequestedRegion.SetSize(2, 1);
m_RequestedRegion.SetSize(3, 1);
m_RequestedRegion.SetSize(4, 1);
m_RequestedRegionInitialized=true;
GetSource()->Update();
if(IsSliceSet(s,t,n))
//yes: now we can call ourselves without the risk of a endless loop (see "if" above)
return GetSliceData(s,t,n,data,importMemoryManagement);
else
return NULL;
}
else
{
ImageDataItemPointer item = AllocateSliceData(s,t,n,data,importMemoryManagement);
item->SetComplete(true);
return item;
}
}
void
ThermalBand::CheckExpand(const ThermalBand& tb, bool update)
{
assert(size());
// check to see if ceiling will fit into range
while (GetSliceIndex(tb.GetCeiling())+1 >= slices.capacity()) {
Decimate(update);
}
}
bool mitk::Image::IsSliceSet(int s, int t, int n) const
{
if(IsValidSlice(s,t,n)==false) return false;
if(m_Slices[GetSliceIndex(s,t,n)].GetPointer()!=NULL)
return true;
ImageDataItemPointer ch, vol;
vol=m_Volumes[GetVolumeIndex(t,n)];
if((vol.GetPointer()!=NULL) && (vol->IsComplete()))
return true;
ch=m_Channels[n];
if((ch.GetPointer()!=NULL) && (ch->IsComplete()))
return true;
return false;
}
mitk::Image::ImageDataItemPointer mitk::Image::AllocateSliceData(int s, int t, int n, void *data, ImportMemoryManagementType importMemoryManagement)
{
int pos;
pos=GetSliceIndex(s,t,n);
const size_t ptypeSize = this->m_ImageDescriptor->GetChannelTypeById(n).GetSize();
// is slice available as part of a volume that is available?
ImageDataItemPointer sl, ch, vol;
vol=m_Volumes[GetVolumeIndex(t,n)];
if(vol.GetPointer()!=NULL)
{
sl=new ImageDataItem(*vol, m_ImageDescriptor, 2, data, importMemoryManagement == ManageMemory, ((size_t) s)*m_OffsetTable[2]*(ptypeSize));
sl->SetComplete(true);
return m_Slices[pos]=sl;
}
// is slice available as part of a channel that is available?
ch=m_Channels[n];
if(ch.GetPointer()!=NULL)
{
sl=new ImageDataItem(*ch, m_ImageDescriptor, 2, data, importMemoryManagement == ManageMemory, (((size_t) s)*m_OffsetTable[2]+((size_t) t)*m_OffsetTable[3])*(ptypeSize));
sl->SetComplete(true);
return m_Slices[pos]=sl;
}
// allocate new volume (instead of a single slice to keep data together!)
m_Volumes[GetVolumeIndex(t,n)]=vol=AllocateVolumeData(t,n,NULL,importMemoryManagement);
sl=new ImageDataItem(*vol, m_ImageDescriptor, 2, data, importMemoryManagement == ManageMemory, ((size_t) s)*m_OffsetTable[2]*(ptypeSize));
sl->SetComplete(true);
return m_Slices[pos]=sl;
////ALTERNATIVE:
//// allocate new slice
//sl=new ImageDataItem(*m_PixelType, 2, m_Dimensions);
//m_Slices[pos]=sl;
//return vol;
}
mitk::Image::ImageDataItemPointer mitk::Image::GetVolumeData(int t, int n, void *data, ImportMemoryManagementType importMemoryManagement)
{
if(IsValidVolume(t,n)==false) return NULL;
ImageDataItemPointer ch, vol;
// volume directly available?
int pos=GetVolumeIndex(t,n);
vol=m_Volumes[pos];
if((vol.GetPointer()!=NULL) && (vol->IsComplete()))
return vol;
const size_t ptypeSize = this->m_ImageDescriptor->GetChannelTypeById(n).GetSize();
// is volume available as part of a channel that is available?
ch=m_Channels[n];
if((ch.GetPointer()!=NULL) && (ch->IsComplete()))
{
vol=new ImageDataItem(*ch, m_ImageDescriptor, 3, data, importMemoryManagement == ManageMemory, (((size_t) t)*m_OffsetTable[3])*(ptypeSize));
vol->SetComplete(true);
return m_Volumes[pos]=vol;
}
// let's see if all slices of the volume are set, so that we can (could) combine them to a volume
bool complete=true;
unsigned int s;
for(s=0;s<m_Dimensions[2];++s)
{
if(m_Slices[GetSliceIndex(s,t,n)].GetPointer()==NULL)
{
complete=false;
break;
}
}
if(complete)
{
// if there is only single slice we do not need to combine anything
if(m_Dimensions[2]<=1)
{
ImageDataItemPointer sl;
sl=GetSliceData(0,t,n,data,importMemoryManagement);
vol=new ImageDataItem(*sl, m_ImageDescriptor, 3, data, importMemoryManagement == ManageMemory);
vol->SetComplete(true);
}
else
{
mitk::PixelType chPixelType = this->m_ImageDescriptor->GetChannelTypeById(n);
vol=m_Volumes[pos];
// ok, let's combine the slices!
if(vol.GetPointer()==NULL)
vol=new ImageDataItem( chPixelType, 3, m_Dimensions, NULL, true);
vol->SetComplete(true);
size_t size=m_OffsetTable[2]*(ptypeSize);
for(s=0;s<m_Dimensions[2];++s)
{
int posSl;
ImageDataItemPointer sl;
posSl=GetSliceIndex(s,t,n);
sl=m_Slices[posSl];
if(sl->GetParent()!=vol)
{
// copy data of slices in volume
size_t offset = ((size_t) s)*size;
std::memcpy(static_cast<char*>(vol->GetData())+offset, sl->GetData(), size);
// FIXME mitkIpPicDescriptor * pic = sl->GetPicDescriptor();
// replace old slice with reference to volume
sl=new ImageDataItem(*vol, m_ImageDescriptor, 2, data, importMemoryManagement == ManageMemory, ((size_t) s)*size);
sl->SetComplete(true);
//mitkIpFuncCopyTags(sl->GetPicDescriptor(), pic);
m_Slices[posSl]=sl;
}
}
//if(vol->GetPicDescriptor()->info->tags_head==NULL)
// mitkIpFuncCopyTags(vol->GetPicDescriptor(), m_Slices[GetSliceIndex(0,t,n)]->GetPicDescriptor());
}
return m_Volumes[pos]=vol;
}
// volume is unavailable. Can we calculate it?
if((GetSource().IsNotNull()) && (GetSource()->Updating()==false))
{
// ... wir muessen rechnen!!! ....
m_RequestedRegion.SetIndex(0, 0);
m_RequestedRegion.SetIndex(1, 0);
m_RequestedRegion.SetIndex(2, 0);
m_RequestedRegion.SetIndex(3, t);
m_RequestedRegion.SetIndex(4, n);
m_RequestedRegion.SetSize(0, m_Dimensions[0]);
m_RequestedRegion.SetSize(1, m_Dimensions[1]);
m_RequestedRegion.SetSize(2, m_Dimensions[2]);
m_RequestedRegion.SetSize(3, 1);
m_RequestedRegion.SetSize(4, 1);
m_RequestedRegionInitialized=true;
GetSource()->Update();
if(IsVolumeSet(t,n))
//yes: now we can call ourselves without the risk of a endless loop (see "if" above)
return GetVolumeData(t,n,data,importMemoryManagement);
else
return NULL;
}
else
{
ImageDataItemPointer item = AllocateVolumeData(t,n,data,importMemoryManagement);
item->SetComplete(true);
return item;
}
}
