Index: DataManagement/mitkImage.cpp
===================================================================
--- DataManagement/mitkImage.cpp	(revision 25468)
+++ DataManagement/mitkImage.cpp	(working copy)
@@ -181,8 +181,17 @@
       return NULL;
     if(GetSource()->Updating()==false)
       GetSource()->UpdateOutputInformation();
+
   }
-  m_CompleteData=GetChannelData();
+  //m_CompleteData=GetChannelData();
+  m_CompleteData = GetImageData();
+//TODO
+/*
+for(int i=this->GetNumberOfChannels()-1; i>=0; i--)
+{
+  m_CompleteData=GetChannelData(i);
+}
+*/
   if(m_CompleteData.GetPointer()==NULL) 
     return NULL;
   return m_CompleteData->GetPicDescriptor();
@@ -377,9 +386,13 @@
       ch=m_Channels[n];
       // ok, let's combine the volumes!
       if(ch.GetPointer()==NULL)
-        ch=new ImageDataItem(m_PixelType, m_Dimension, m_Dimensions, NULL, true);
+        //ch=new ImageDataItem(m_PixelType, m_Dimension, m_Dimensions, NULL, true);
+//TODO
+ch=new ImageDataItem(m_PixelType, 4, m_Dimensions, NULL, true);
       ch->SetComplete(true);
-      size_t size=m_OffsetTable[m_Dimension-1]*(m_PixelType.GetBpe()/8);
+      //size_t size=m_OffsetTable[m_Dimension-1]*(m_PixelType.GetBpe()/8);
+//TODO
+size_t size=m_OffsetTable[3]*(m_PixelType.GetBpe()/8);
       unsigned int t;
       ImageDataItemPointerArray::iterator slicesIt = m_Slices.begin()+n*m_Dimensions[2]*m_Dimensions[3];
       for(t=0;t<m_Dimensions[3];++t)
@@ -451,6 +464,108 @@
   }
 }
 
+mitk::Image::ImageDataItemPointer mitk::Image::GetImageData(void *data, ImportMemoryManagementType importMemoryManagement)
+{
+  ImageDataItemPointer img, ch, vol;
+
+  int numOfChannels = GetNumberOfChannels();
+  if (numOfChannels==1)
+  {
+    return GetChannelData(0, data, importMemoryManagement);
+  }
+
+  // add channel as 5. dimension
+  if(m_CompleteData.GetPointer()==NULL)
+  {
+    unsigned int dimensions[5];
+    for(int i=0; i<5; i++)
+    {
+      dimensions[i] = 1;
+    }
+    for(int i=0; i<m_Dimension; i++)
+    {
+      dimensions[i] = m_Dimensions[i];
+    }
+    dimensions[4] = numOfChannels; // channel
+
+    m_CompleteData = new ImageDataItem(m_PixelType, 5, dimensions, NULL, true);
+  }
+  m_CompleteData->SetComplete(true);
+  size_t size = m_OffsetTable[4]*(m_PixelType.GetBpe()/8); // size of a channel in byte
+
+  // merge every channel
+  for(int n=0; n<numOfChannels; n++)
+  {
+    ch = GetChannelData(n, data, importMemoryManagement);
+   
+    // copy data of channel to image (m_CompleteData)
+    size_t offset = ((size_t) n)*m_OffsetTable[4]*(m_PixelType.GetBpe()/8);
+    std::memcpy(static_cast<char*>(m_CompleteData->GetData())+offset, ch->GetData(), size);
+
+    mitkIpPicDescriptor * pic = ch->GetPicDescriptor();
+
+    // replace old channel with reference to image
+    ch = new ImageDataItem(*m_CompleteData, 3, data, importMemoryManagement == ManageMemory, offset);
+    ch->SetComplete(true);
+    mitkIpFuncCopyTags(ch->GetPicDescriptor(), pic);
+
+    m_Channels[n] = ch;
+
+  }
+
+  ImageDataItemPointerArray::iterator it, end;
+  // get rid of volumes - they may point to old channel
+  for( it=m_Volumes.begin(), end=m_Volumes.end(); it!=end; ++it )
+  {
+    (*it)=NULL;
+  }
+  // get rid of slices - they may point to old volume
+  for( it=m_Slices.begin(), end=m_Slices.end(); it!=end; ++it )
+  {
+    (*it)=NULL;
+  }
+
+  if(m_CompleteData->GetPicDescriptor()->info->tags_head==NULL)
+  {
+    mitkIpFuncCopyTags(m_CompleteData->GetPicDescriptor(), m_Channels[0]->GetPicDescriptor());
+  }
+    
+  return m_CompleteData;
+  
+/*
+  // channel is unavailable. Can we calculate it?
+  if((GetSource()!=NULL) && (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, 0);
+    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, m_Dimensions[3]);
+    m_RequestedRegion.SetSize(4, 1);
+    m_RequestedRegionInitialized=true;
+    GetSource()->Update();
+    // did it work?
+    if(IsChannelSet(n))
+      //yes: now we can call ourselves without the risk of a endless loop (see "if" above)
+      return GetChannelData(n,data,importMemoryManagement);
+    else
+      return NULL;
+  }
+  else
+  {
+    ImageDataItemPointer item = AllocateChannelData(n,data,importMemoryManagement);
+    item->SetComplete(true);
+    return item;
+  }
+  */
+}
+
+
 bool mitk::Image::IsSliceSet(int s, int t, int n) const
 {
   if(IsValidSlice(s,t,n)==false) return false;
@@ -729,6 +844,8 @@
       itkExceptionMacro(<< "invalid dimension[" << i << "]: " << dimensions[i]);
   }
 
+//TODO
+/*
   m_Dimensions=new unsigned int[m_Dimension>4?m_Dimension:4];
   std::memcpy(m_Dimensions, dimensions, sizeof(unsigned int)*m_Dimension);
   if(m_Dimension<4)
@@ -737,7 +854,23 @@
     for(i=0,p=m_Dimensions+m_Dimension;i<4-m_Dimension;++i, ++p)
       *p=1;
   }
+*/
+  m_Dimensions=new unsigned int[5];
+  for(unsigned int i=0; i<5; i++)
+  {
+    if (i<dimension)
+    {
+      m_Dimensions[i] = dimensions[i];
+    }
+    else
+    {
+      m_Dimensions[i] = 1;
+    }
+  }
+  m_Dimensions[4] = channels;
 
+//TODO
+/*
   for(i=0;i<4;++i)
   {
     m_LargestPossibleRegion.SetIndex(i, 0);
@@ -745,7 +878,14 @@
   }
   m_LargestPossibleRegion.SetIndex(i, 0);
   m_LargestPossibleRegion.SetSize(i, channels);
+*/
+  for(unsigned int i=0; i<5; i++)
+  {
+    m_LargestPossibleRegion.SetIndex(i, 0);
+    m_LargestPossibleRegion.SetSize (i, m_Dimensions[i]);
+  }
 
+
   if(m_LargestPossibleRegion.GetNumberOfPixels()==0)
   {
     delete [] m_Dimensions;
@@ -790,13 +930,14 @@
 }
 
 void mitk::Image::Initialize(const mitk::PixelType& type, const mitk::Geometry3D& geometry, unsigned int channels, int tDim ) 
-{
+{  
+  /*
   unsigned int dimensions[5];
   dimensions[0] = (unsigned int)(geometry.GetExtent(0)+0.5);
   dimensions[1] = (unsigned int)(geometry.GetExtent(1)+0.5);
   dimensions[2] = (unsigned int)(geometry.GetExtent(2)+0.5);
-  dimensions[3] = 0;
-  dimensions[4] = 0;
+  dimensions[3] = 1;
+  dimensions[4] = 1;
 
   unsigned int dimension = 2;
   if ( dimensions[2] > 1 )
@@ -819,7 +960,41 @@
     dimension = 4;
 
   Initialize( type, dimension, dimensions, channels );
+*/
+  unsigned int dimensions[5];
+  dimensions[0] = (unsigned int)(geometry.GetExtent(0)+0.5);
+  dimensions[1] = (unsigned int)(geometry.GetExtent(1)+0.5);
+  dimensions[2] = (unsigned int)(geometry.GetExtent(2)+0.5);
+//TODO
+  dimensions[3] = 1;
+  dimensions[4] = channels;
 
+  unsigned int dimension = 2;
+  if ( dimensions[2] > 1 )
+    dimension = 3;
+
+  if ( tDim > 0)
+  {
+    dimensions[3] = tDim;
+  }
+  else
+  {
+    const mitk::TimeSlicedGeometry* timeGeometry = dynamic_cast<const mitk::TimeSlicedGeometry*>(&geometry);
+    if ( timeGeometry != NULL ) 
+    {
+      dimensions[3] = timeGeometry->GetTimeSteps();
+    }
+  }
+
+  if ( dimensions[3] > 1 )
+    dimension = 4;
+
+//TODO
+  if ( dimensions[4] > 1 )
+    dimension = 5;
+
+  Initialize( type, dimension, dimensions, channels );
+
   SetGeometry(static_cast<Geometry3D*>(geometry.Clone().GetPointer()));
   
   mitk::BoundingBox::BoundsArrayType bounds = geometry.GetBoundingBox()->GetBounds();
@@ -849,7 +1024,9 @@
 
 void mitk::Image::Initialize(const mitk::Image* image) 
 {
-  Initialize(*image->GetPixelType().GetTypeId(), *image->GetTimeSlicedGeometry());
+//TODO
+  //Initialize(*image->GetPixelType().GetTypeId(), *image->GetTimeSlicedGeometry());
+  Initialize(*image->GetPixelType().GetTypeId(), *image->GetTimeSlicedGeometry(), image->GetNumberOfChannels());
 }
 
 void mitk::Image::Initialize(vtkImageData* vtkimagedata, int channels, int tDim, int sDim)
@@ -857,7 +1034,9 @@
   if(vtkimagedata==NULL) return;
 
   m_Dimension=vtkimagedata->GetDataDimension();
-  unsigned int i, *tmpDimensions=new unsigned int[m_Dimension>4?m_Dimension:4];
+
+/*
+  unsigned int i, *tmpDimensions=new unsigned int[m_Dimension>5?m_Dimension:5];
   for(i=0;i<m_Dimension;++i) tmpDimensions[i]=vtkimagedata->GetDimensions()[i];
   if(m_Dimension<4)
   {
@@ -865,7 +1044,21 @@
     for(i=0,p=tmpDimensions+m_Dimension;i<4-m_Dimension;++i, ++p)
       *p=1;
   }
+*/
 
+  unsigned int* tmpDimensions = new unsigned int[5];
+  for(unsigned int i=0; i<5; i++)
+  {
+    if (i<m_Dimension)
+    {
+      tmpDimensions[i] = vtkimagedata->GetDimensions()[i];
+    }
+    else
+    {
+      tmpDimensions[i] = 1;
+    }
+  }
+
   if(sDim>=0)
   {
     tmpDimensions[2]=sDim;
@@ -878,6 +1071,13 @@
     if(m_Dimension < 4)
       m_Dimension = 4;
   }
+//TODO
+  if(channels>1)
+  {
+    tmpDimensions[4]=channels;
+    if(m_Dimension < 5)
+      m_Dimension = 5;
+  }
 
   mitk::PixelType pixelType;
 
@@ -966,15 +1166,31 @@
 
   m_Dimension=pic->dim;
 
+//TODO
+/*
   m_Dimensions=new unsigned int[m_Dimension>4?m_Dimension:4];
   std::memcpy(m_Dimensions, pic->n, sizeof(unsigned int)*m_Dimension);
-  if(m_Dimension<4)
+  if(m_Dimension<5)
   {
     unsigned int i, *p;
     for(i=0,p=m_Dimensions+m_Dimension;i<4-m_Dimension;++i, ++p)
       *p=1;
   }
+*/
 
+  m_Dimensions = new unsigned int[5];
+  for(unsigned int i=0; i<5; i++)
+  {
+    if (i<m_Dimension)
+    {
+      m_Dimensions[i] = pic->n[i];
+    }
+    else
+    {
+      m_Dimensions[i] = 1;
+    }
+  }
+
   if(sDim>=0)
   {
     m_Dimensions[2]=sDim;
@@ -987,7 +1203,14 @@
     if(m_Dimension < 4)
       m_Dimension = 4;
   }
-
+//TODO
+  if(channels>1)
+  {
+    m_Dimensions[4]=channels;
+    if(m_Dimension < 5)
+      m_Dimension = 5;
+  }
+/*
   unsigned int i;
   for(i=0;i<4;++i)
   {
@@ -996,6 +1219,12 @@
   }
   m_LargestPossibleRegion.SetIndex(i, 0);
   m_LargestPossibleRegion.SetSize(i, channels);
+*/
+  for(unsigned int i=0; i<5; i++)
+  {
+    m_LargestPossibleRegion.SetIndex(i, 0);
+    m_LargestPossibleRegion.SetSize (i, m_Dimensions[i]);
+  }
 
   m_PixelType=PixelType(pic);
   SlicedGeometry3D::Pointer slicedGeometry = SlicedGeometry3D::New(); 
Index: DataManagement/mitkImage.h
===================================================================
--- DataManagement/mitkImage.h	(revision 25468)
+++ DataManagement/mitkImage.h	(working copy)
@@ -536,6 +536,10 @@
   //## @warning for internal use only
   virtual ImageDataItemPointer GetChannelData(int n = 0, void *data = NULL, ImportMemoryManagementType importMemoryManagement = CopyMemory);
 
+  //##Documentation
+  //## @warning for internal use only
+  virtual ImageDataItemPointer GetImageData(void *data = NULL, ImportMemoryManagementType importMemoryManagement = CopyMemory);
+
   template < typename ItkImageType >
     friend void _ComputeExtremaInItkImage(ItkImageType* itkImage, mitk::Image * mitkImage, int t);
 
Index: IO/mitkPicFileReader.cpp
===================================================================
--- IO/mitkPicFileReader.cpp	(revision 25468)
+++ IO/mitkPicFileReader.cpp	(working copy)
@@ -49,6 +49,14 @@
 
         int channels = 1;
 
+//TODO
+if (header->dim == 5)
+{
+  channels = header->n[4];
+  header->dim = 4;
+}
+
+
         mitkIpPicTSV_t *tsv;
         if ( (tsv = mitkIpPicQueryTag( header, "SOURCE HEADER" )) != NULL)
         {
@@ -193,7 +201,10 @@
 
     if( m_FileName != "")
     {
+//TODO
         mitkIpPicDescriptor* pic=MITKipPicGet(const_cast<char *>(m_FileName.c_str()), output->GetPic());
+        //mitkIpPicDescriptor* pic=MITKipPicGet(const_cast<char *>(m_FileName.c_str()), NULL);
+
         // comes upside-down (in MITK coordinates) from PIC file
         ConvertHandedness(pic);
 
@@ -224,6 +235,32 @@
           mitkIpPicDelTag( pic, "VELOCITY" );
         }
 
+
+//TODO
+/*
+if (pic->dim <= 4)
+{
+  output->SetChannel(pic->data, 0);
+}
+else
+{
+  int bytesPerPixel = pic->bpe / 8;
+  int bytesPerChannel = 1;
+
+  for(int i=0; i<4; i++)
+  {
+    bytesPerChannel *= pic->n[i];
+  }
+  bytesPerChannel *= bytesPerPixel;
+
+  for(int n=0; n<pic->n[4]; n++)
+  {
+    output->SetChannel((void*)((char*)pic->data + (n * bytesPerChannel)), n);
+  }
+}
+*/
+
+
         //slice-wise reading
         //currently much too slow.
         //else