Example #1
0
def itk_image_to_medipy_image(itk_image, medipy_image, transferOwnership):
    """ Modify a ``medipy.base.Image`` to match the contents and type of given ITK image. If
        ``transferOwnership`` is ``True``, then the image will own the data, and the
        ``itk.Image`` will not. Otherwise, the image does not own the data, and the 
        ``itk.Image`` is unchanged. If ``medipy_image`` is ``None``, then a new image is 
        created. In any case, the medipy Image is returned
    """
    
    if medipy_image is None :
        itk_type = itk.template(itk_image)[1][0]
        dimension = itk.template(itk_image)[1][1]
        medipy_image = medipy.base.Image(dimension*(0,), types.itk_to_dtype[itk_type])
    
    if itk_image.GetNameOfClass() == "Image" :
        if not itk.NumpyBridge[itk_image].IsBufferShared(medipy_image.data, itk_image) :
            medipy_image.data = itk_image_to_array(itk_image, transferOwnership)
        medipy_image.data_type = "scalar"
    elif itk_image.GetNameOfClass() == "VectorImage" :
        if not itk.NumpyBridge[itk_image].IsBufferShared(medipy_image.data, itk_image) :
            medipy_image.data = itk_vector_image_to_array(itk_image, transferOwnership)
        medipy_image.data_type = "vector"
    
    matrix_type = itk.Matrix[itk.D, medipy_image.ndim, medipy_image.ndim]    
    matrix_bridge = itk.MatrixBridge[matrix_type]
    itk_direction = matrix_bridge.GetArrayFromMatrix(itk_image.GetDirection())
    medipy_image.direction = numpy.fliplr(numpy.flipud(itk_direction))
    
    medipy_image.origin =  [x for x in reversed(itk_image.GetOrigin())]
    medipy_image.spacing = [x for x in reversed(itk_image.GetSpacing())]

    return medipy_image
Example #2
0
 def Show(self, itkIm, title="noname") :
     """ Display an image, with optional title
     If different titles are used then multiple images will be available in imview.
     Flip between them with the menu or space bar
     """
     import itk
     #itkIm = itk.image(itkIm)
     itkIm = itk.output(itkIm)
     if not self.connected :
         # do the login now that we have an image type
         self.imviewObj = itk.Imview[itkIm]
         self.Connection = self.imviewObj.ImviewLogin(self.portNum)
         self.connected = True
         print "Connected"
         print self.Connection
         self.ImageTemp = itk.template(itkIm)[1]
     else:
         if itk.template(itkIm)[1] != self.ImageTemp:
             self.ImageTemp = itk.template(itkIm)[1] 
             self.imviewObj = itk.Imview[itkIm]
     # transmit the image
     status = self.imviewObj.ImviewPutImage(itkIm, self.Connection, title)
     if (status != 0):
         # Failed to send image. Assume that imview has died
         self.__StartImview__()
         status = self.imviewObj.ImviewPutImage(itkIm, self.Connection, title)
         if (status != 0):
             print "Something seriously wrong - give up on this Imview instance"
Example #3
0
def getInformation(image): # tested
    """
    Returns an information string about a ITK image in a compressed way.
    
    Parameters
    ----------
    image : itk.Image
        An ITK image as used by WrapITK.
        
    Returns
    -------
    information : string
        Pretty-formatted string with image metadata.
        
    Notes
    -----
    Performs UpdateOutputInformation() on the image, therefore triggering pipeline processing if necessary
    Only works on 3D images.
    """
    # refresh information
    image.UpdateOutputInformation()
    
    # request information and format string
    s = 'itkImageData info:\n'
    s += '\tscalar-type: {}\n'.format(str(itk.template(image)[1][0]))
    rs = image.GetLargestPossibleRegion().GetSize()
    s += '\tdimensions: {}\n'.format([rs.GetElement(x) for x in range(rs.GetSizeDimension())])
    sp = image.GetSpacing()
    s += '\tspacing: {}\n'.format([sp.GetElement(x) for x in range(rs.GetSizeDimension())])
    o = image.GetOrigin()
    s += '\torigin: {}\n'.format([o.GetElement(x) for x in range(rs.GetSizeDimension())]) 
    s += '\tdata dim.: {}'.format(str(itk.template(image)[1][1])) # alternative impl. for when GetImageDimension() fails 
    
    return s
Example #4
0
def itk_displacement_to_strain(image:itk.Image) -> itk.Image:
	vector_type = itk.template(image)[1][0]
	real_type = itk.template(vector_type)[1][0]
	# Functional interface is invalid for StrainImageFilter so we define a filter object.
	strain_filter = itk.StrainImageFilter[type(image),real_type,real_type].New()
	strain_filter.SetInput(image)
	strain_filter.Update()
	return strain_filter.GetOutput()
Example #5
0
def add(ImgA,
        ImgB):
  s,d = itk.template(ImgA)[1]
  assert s,d == itk.template(ImgB)[1]
  input_type = itk.Image[s,d]
  Result = itk.AddImageFilter[input_type, input_type, input_type].New()
  Result.SetInput1(ImgA)
  Result.SetInput2(ImgB)
  Result.Update()
  return Result.GetOutput()
Example #6
0
 def Overlay(self, itkIm, title="noname") :
     """Send an overlay to image with specified title"""
     import itk
     #itkIm = itk.image(itkIm)
     itkIm = itk.output(itkIm)
     if not self.connected :
         print "No image being viewed - send one first"
     else:
         if itk.template(itkIm)[1] != self.ImageTemp:
             self.ImageTemp = itk.template(itkIm)[1] 
             self.imviewObj = itk.Imview[itkIm]
         status = self.imviewObj.ImviewPutOverlay(itkIm, self.Connection, title)
Example #7
0
def getImageType(image): # tested
    """
    Returns the image type of the supplied image as itk.Image template.
    @param image: an instance of itk.Image
    
    @return a template of itk.Image
    @rtype itk.Image
    """
    try:
        return itk.Image[itk.template(image)[1][0],
                         itk.template(image)[1][1]]
    except IndexError as _:
        raise NotImplementedError, 'The python wrappers of ITK define no template class for this data type.'
Example #8
0
def wasm_type_from_pointset_type(itkpointset):
    import itk

    component = itk.template(itkpointset)[1][0]
    mangle = None
    pixelType = "Scalar"
    pixel_type_components = 1

    if component in (itk.F, itk.D):
        mangle = component
    elif component in [i[1] for i in itk.Array.items()]:
        mangle = itk.template(component)[1][0]
        pixelType = "Array"

    return pixelType, python_to_js(mangle), pixel_type_components
def test_mesh_to_geometry():
    # 3D
    Dimension = 3
    PixelType = itk.ctype('double')
    MeshType = itk.Mesh[PixelType, Dimension]
    mesh = MeshType.New()
    PointType = itk.Point[itk.F, Dimension]
    point0 = PointType()
    point0[0] = -1
    point0[1] = -1
    point0[2] = 0
    mesh.SetPoint(0, point0)
    mesh.SetPointData(0, 8.0)
    point1 = PointType()
    point1[0] = 1
    point1[1] = -1
    point1[2] = 0
    mesh.SetPointData(1, 9.0)
    mesh.SetPoint(1, point1)
    point2 = PointType()
    point2[0] = 1
    point2[1] = 1
    point2[2] = 0
    mesh.SetPoint(2, point2)
    mesh.SetPointData(2, 19.0)
    point3 = PointType()
    point3[0] = 1
    point3[1] = 1
    point3[2] = 0
    mesh.SetPoint(3, point3)
    mesh.SetPointData(3, 24.0)

    geometry = to_geometry(mesh)

    points = mesh.GetPoints()
    point_template = itk.template(points)
    identifier_type = point_template[1][0]
    element_type = point_template[1][1]

    point_values = itk.array_from_vector_container(points)

    assert (geometry['vtkClass'] == 'vtkPolyData')
    assert (geometry['points']['vtkClass'] == 'vtkPoints')
    assert (geometry['points']['numberOfComponents'] == 3)
    assert (geometry['points']['dataType'] == 'Float32Array')
    assert (geometry['points']['size'] == 4 * 3)
    assert (np.array_equal(geometry['points']['values'],
                           point_values.astype(np.float32)))
    assert (geometry['pointData']['vtkClass'] == 'vtkDataSetAttributes')
    assert (geometry['pointData']['arrays'][0]['data']['vtkClass'] ==
            'vtkDataArray')
    assert (geometry['pointData']['arrays'][0]['data']['name'] == 'Point Data')
    assert (
        geometry['pointData']['arrays'][0]['data']['numberOfComponents'] == 1)
    assert (geometry['pointData']['arrays'][0]['data']['size'] == 4)
    assert (geometry['pointData']['arrays'][0]['data']['dataType'] ==
            'Float64Array')
    assert (np.array_equal(
        geometry['pointData']['arrays'][0]['data']['values'],
        np.array([8.0, 9.0, 19.0, 24.0], dtype=np.float64)))
def image_layer_from_image_sitk(image):
    """Convert an itk.Image to a napari.layers.Image."""
    rgb = False
    try:
        if isinstance(image, itk.Image):
            PixelType = itk.template(image)[1][0]
            if PixelType is itk.RGBPixel[itk.UC] or PixelType is itk.RGBAPixel[
                    itk.UC]:
                rgb = True
    except:
        pass
    #print(image["origin"])
    try:
        metadata = dict(image)
    except:
        metadata = None
    scale = image["spacing"]
    translate = image["origin"]
    # Todo: convert the rotation matrix to angles, in degrees
    # rotate = image['direction']
    # https://github.com/InsightSoftwareConsortium/itk-napari-conversion/issues/7

    data = sitk.GetArrayFromImage(image)
    if metadata is None:
        image_layer = napari.layers.Image(data,
                                          rgb=rgb,
                                          scale=scale,
                                          translate=translate)
    else:
        image_layer = napari.layers.Image(data,
                                          rgb=rgb,
                                          metadata=metadata,
                                          scale=scale,
                                          translate=translate)
    return image_layer
Example #11
0
 def __init__(self, *args, **kargs):
   # call the constructor of the superclass but without args and kargs, because the attributes
   # are not all already there!
   # Set/GetRadius() is created in the constructor for example, with the expose() method
   itk.pipeline.__init__(self)
   
   # get the template parameters
   template_parameters = kargs["template_parameters"]
   
   # and store them in an easier way
   ImageType, DistanceMapType = template_parameters
   # the maximum value of the image type
   PixelType, dim = itk.template(ImageType)[1]
   maxValue = itk.NumericTraits[PixelType].max()
   # build the minipipeline
   # use a cast filter to dispatch the input image
   self.connect(itk.CastImageFilter[ImageType, ImageType].New(InPlace=False))
   # dilate the objects in the input image
   self.connect(itk.BinaryThresholdImageFilter[ImageType, ImageType].New(LowerThreshold=0, UpperThreshold=0, InsideValue=0, OutsideValue=maxValue))
   self.connect(itk.BinaryDilateImageFilter[ImageType, ImageType, itk.FlatStructuringElement[dim]].New())
   self.expose("Kernel")
   self.expose("Radius")
   # compute the voronoi map and cast it to a usable image type
   self.append(itk.DanielssonDistanceMapImageFilter[ImageType, DistanceMapType].New(self.filters[0], UseImageSpacing=True, SquaredDistance=False))
   self.append(itk.CastImageFilter[DistanceMapType, ImageType].New(self.filters[-1].GetVoronoiMap()))
   # and mask the voronoi map with the dilated objects
   self.connect(itk.MaskImageFilter[ImageType, ImageType, ImageType].New(Input2=self.filters[2]))
   
   # now we can parse the inputs
   itk.set_inputs(self, args, kargs)
Example #12
0
def RelabelComponents(inputImage,
                      outputImageType = None):
  # relabel = itk.RelabelComponentImageFilter[input_type, output_type].New()
  # relabel.SetInput(inputImage)
  # relabel.Update()
  # return relabel.GetOutput()
  label_field = itk.GetArrayFromImage(inputImage)
  offset = 1
  max_label = int(label_field.max()) # Ensure max_label is an integer
  labels, labels_counts= np.unique(label_field,return_counts=True)
  labels=labels[np.argsort(labels_counts)[::-1]]
  labels0 = labels[labels != 0]
  new_max_label = offset - 1 + len(labels0)
  new_labels0 = np.arange(offset, new_max_label + 1)
  output_type = label_field.dtype
  required_type = np.min_scalar_type(new_max_label)
  if np.dtype(required_type).itemsize > np.dtype(label_field.dtype).itemsize:
      output_type = required_type
  forward_map = np.zeros(max_label + 1, dtype=output_type)
  forward_map[labels0] = new_labels0
  inverse_map = np.zeros(new_max_label + 1, dtype=output_type)
  inverse_map[offset:] = labels0
  relabeled = forward_map[label_field]
  result = itk.GetImageFromArray(relabeled)
  result.SetOrigin(inputImage.GetOrigin())
  result.SetSpacing(inputImage.GetSpacing())
  result.SetDirection(inputImage.GetDirection())
  if not outputImageType is None:
    s,d = itk.template(inputImage)[1]
    output_type = itk.Image[outputImageType,d]
    result = castImage(result, OutputType=output_type)
  return result
Example #13
0
def binaryThresholding(inputImage,
                       lowerThreshold,
                       upperThreshold,
                       outputImageType = None,
                       insideValue = 1,
                       outsideValue = 0):
  # Old version:
  # s,d = itk.template(inputImage)[1]
  # input_type = itk.Image[s,d]
  # output_type = input_type if outputImageType is None else itk.Image[outputImageType,d]
  # thresholder = itk.BinaryThresholdImageFilter[input_type, output_type].New()
  # thresholder.SetInput(inputImage)
  # thresholder.SetLowerThreshold( lowerThreshold )
  # thresholder.SetUpperThreshold( upperThreshold )
  # thresholder.SetInsideValue(insideValue)
  # thresholder.SetOutsideValue(outsideValue)
  # thresholder.Update()
  # return thresholder.GetOutput()
  values = itk.GetArrayFromImage(inputImage)
  cond = (values>=lowerThreshold) & (values<=upperThreshold)
  values[ cond ] = insideValue
  values[ np.logical_not(cond) ] = outsideValue
  result = itk.GetImageFromArray(values)
  result.SetOrigin(inputImage.GetOrigin())
  result.SetSpacing(inputImage.GetSpacing())
  result.SetDirection(inputImage.GetDirection())
  if not outputImageType is None:
    s,d = itk.template(inputImage)[1]
    output_type = itk.Image[outputImageType,d]
    result = castImage(result, OutputType=output_type)
  return result
Example #14
0
def Volume3DToDicom(imgObj, MetadataObj = None, outdir = "", format_templ = "%03d.dcm"):
  format_templ = os.path.join(outdir, format_templ)
  entire_region = imgObj.GetLargestPossibleRegion()

  fngen = itk.NumericSeriesFileNames.New()
  fngen.SetSeriesFormat(format_templ)
  fngen.SetStartIndex( entire_region.GetIndex()[2] )
  fngen.SetEndIndex( entire_region.GetIndex()[2] + entire_region.GetSize()[2] - 1 )
  fngen.SetIncrementIndex(1)

  if not MetadataObj is None:
    metadata_array_copy = itk.vector.itkMetaDataDictionary()
    # I had to create a set of metadata to avoid pointers issues
    metadata_list_objs = [ itk.MetaDataDictionary() for metadata_list in MetadataObj ]
    for metadata_list, temp_metadata in zip(MetadataObj, metadata_list_objs):
      for k,v in metadata_list.items():
        temp_metadata[k] = v
      metadata_array_copy.append(temp_metadata)

  s,d = itk.template(imgObj)[1]
  dicom_io = itk.GDCMImageIO.New()
  writer_type = itk.Image[s,d]
  writer_otype = itk.Image[s,d-1]
  writer = itk.ImageSeriesWriter[writer_type, writer_otype].New()
  writer.SetInput(imgObj)
  writer.SetImageIO(dicom_io)
  writer.SetFileNames(fngen.GetFileNames())
  if not MetadataObj is None:
    writer.SetMetaDataDictionaryArray(metadata_array_copy)
  writer.Update()
Example #15
0
def paste_to_common_space(images:list) -> list:
    image_type = type(images[0])
    pixel_type, dimension = itk.template(images[0])[1]

    resized_images = list()

    # Verify spacing is equivalent
    SPACING_TOLERANCE = 1e-7
    assert(all([itk.spacing(images[idx])[dim] - itk.spacing(images[0])[dim] < SPACING_TOLERANCE
                for dim in range(dimension)
                for idx in range(1,len(images))]))

    # Get largest common region
    max_size = itk.size(images[0])
    for image in images:
        max_size = [max(max_size[i], itk.size(image)[i]) for i in range(len(max_size))]

    # Define paste region
    for image in images:
        region = itk.ImageRegion[dimension]()
        region.SetSize(max_size)
        region.SetIndex([0] * dimension)
        new_image = type(images[0]).New(regions=region, spacing=image.GetSpacing())
        new_image.Allocate()

        resized_image = itk.paste_image_filter(source_image=image,
                                               source_region=image.GetLargestPossibleRegion(),
                                               destination_image=new_image,
                                               destination_index=[0] * dimension,
                                               ttype=type(image))
        resized_images.append(resized_image)
    return resized_images
Example #16
0
    def __init__(self, fileName=None, channel=0, ImageType=None):
        from vtk import vtkLSMReader, vtkImageCast
        import itk
        itk.pipeline.__init__(self)
        # if ImageType is None, give it a default value
        # this is useful to avoid loading Base while loading this module
        if ImageType == None:
            ImageType = itk.Image.UC3
        # remove useless SetInput() method created by the constructor of the pipeline class


#     del self.SetInput
# set up the pipeline
        self.connect(vtkLSMReader())
        self.connect(vtkImageCast())
        PType = itk.template(ImageType)[1][0]
        if PType == itk.UC:
            self[-1].SetOutputScalarTypeToUnsignedChar()
        elif PType == itk.US:
            self[-1].SetOutputScalarTypeToUnsignedShort()
        self.connect(itk.VTKImageToImageFilter[ImageType].New())
        self.connect(itk.ChangeInformationImageFilter[ImageType].New(
            ChangeSpacing=True))
        # and configure the pipeline
        if fileName:
            self.SetFileName(fileName)
        self.SetChannel(channel)
Example #17
0
def castImage(imgObj, OutputType):
  s,d = itk.template(imgObj)[1]
  input_type = itk.Image[s,d]
  output_type = OutputType
  castObj = itk.CastImageFilter[input_type, output_type].New()
  castObj.SetInput(imgObj)
  castObj.Update()
  return castObj.GetOutput()
Example #18
0
    def _get_image_type(image):
        """Returns the image type of the supplied image as itk.Image template.

        Args:
            image: an instance of itk.Image

        Returns:
            a template of itk.Image, type itk.Image
        """
        try:
            return itk.Image[itk.template(image)[1][0],
                             itk.template(image)[1][1]]
        except IndexError:
            raise (
                NotImplementedError,
                'The python wrappers of ITK define no template class for this data type.'
            )
Example #19
0
    def _set_t_98(self, value):
        # Cast value to input pixel type of BETImageFilter
        itk_type = itk.template(itk.template(self._bet_filter)[1][1])[1][0]
        value = medipy.itk.itk_to_dtype[itk_type](value)
        self._bet_filter.SetT98(value)

        colormap = self._image.get_layer_colormap(self._intensity_range_layer)
        colormap.display_range = (colormap.display_range[0], value)

        self.ui.intensity_range.remove_observer("value",
                                                self.on_intensity_range_value)
        self.ui.intensity_range.value = (self.ui.intensity_range.value[0],
                                         value)
        self.ui.intensity_range.add_observer("value",
                                             self.on_intensity_range_value)

        self.notify_observers("t_98")
Example #20
0
def ConnectedComponents(inputImage,
                        outputImageType = None):
  s,d = itk.template(inputImage)[1]
  input_type = itk.Image[s,d]
  output_type = input_type if outputImageType is None else itk.Image[outputImageType,d]
  CC = itk.ConnectedComponentImageFilter[input_type, output_type].New()
  CC.SetInput(inputImage)
  CC.Update()
  return CC.GetOutput()
Example #21
0
def getImageType(image):  # tested
    """
    Returns the image type of the supplied image as itk.Image template.
    
    Parameters
    ----------
    image : itk.Image (instance)
        An instance of itk.Image.
    
    Returns
    -------
    image_type : itk.Image (template)
        An itk image type.
    """
    try:
        return itk.Image[itk.template(image)[1][0], itk.template(image)[1][1]]
    except IndexError as _:
        raise NotImplementedError, 'The python wrappers of ITK define no template class for this data type.'
Example #22
0
def getImageType(image): # tested
    """
    Returns the image type of the supplied image as itk.Image template.
    
    Parameters
    ----------
    image : itk.Image (instance)
        An instance of itk.Image.
    
    Returns
    -------
    image_type : itk.Image (template)
        An itk image type.
    """
    try:
        return itk.Image[itk.template(image)[1][0],
                         itk.template(image)[1][1]]
    except IndexError as _:
        raise NotImplementedError, 'The python wrappers of ITK define no template class for this data type.'
Example #23
0
def binary_image_list_to_meshes(images:list, mesh_pixel_type:type=itk.F, object_pixel_value=1) -> list:
    _, dimension = itk.template(images[0])[1]
    mesh_type = itk.Mesh[mesh_pixel_type, dimension]

    mesh_list = list()
    for image in images:
        mesh = itk.binary_mask3_d_mesh_source(input=image,
                                              object_value=object_pixel_value,
                                              ttype=[type(image), mesh_type])
        mesh_list.append(mesh)
    return mesh_list
Example #24
0
def Gaussian(GaussInput,
             sigma,
             outputImageType = None):
  s,d = itk.template(GaussInput)[1]
  input_type = itk.Image[s,d]
  output_type = input_type if outputImageType is None else itk.Image[outputImageType,d]
  OperationObj = itk.DiscreteGaussianImageFilter[input_type, output_type].New()
  OperationObj.SetInput(GaussInput)
  OperationObj.SetVariance(sigma)
  OperationObj.Update()
  return OperationObj.GetOutput()
Example #25
0
def mesh_to_image(meshes: list,
                  reference_image: itk.Image = None) -> itk.Image:
    # Allow single mesh as input
    if type(meshes) != list:
        meshes = [meshes]

    mesh_type = type(meshes[0])
    pixel_type, dimension = itk.template(mesh_type)[1]
    image_type = itk.Image[pixel_type, dimension]

    mesh_to_image_filter_type = itk.TriangleMeshToBinaryImageFilter[mesh_type,
                                                                    image_type]
    images = list()

    if not reference_image:
        # Set bounds to largest region encompassing all meshes
        # Bounds format: [x_min x_max y_min y_max z_min z_max]
        bounds = meshes[0].GetBoundingBox().GetBounds()
        for mesh in meshes[1:]:
            mesh_bounds = mesh.GetBoundingBox().GetBounds()
            for dim in range(0, dimension):
                bounds[dim * 2] = min(bounds[dim * 2], mesh_bounds[dim * 2])
                bounds[(dim * 2) + 1] = max(bounds[(dim * 2) + 1],
                                            mesh_bounds[(dim * 2) + 1])

        # Calculate spacing, origin, and size with 5 pixel buffer around mesh
        spacing = ((bounds[1] - bounds[0]) / 90, (bounds[3] - bounds[2]) / 90,
                   (bounds[5] - bounds[4]) / 90)
        origin = (bounds[0] - 5 * spacing[0], bounds[2] - 5 * spacing[1],
                  bounds[4] - 5 * spacing[2])
        size = (100, 100, 100)
        direction = itk.Matrix[itk.D, dimension, dimension].GetIdentity()
    else:
        # Use given parameters
        origin = reference_image.GetOrigin()
        spacing = reference_image.GetSpacing()
        size = reference_image.GetLargestPossibleRegion().GetSize()
        direction = reference_image.GetDirection()

    # Generate image for each mesh
    for mesh in meshes:
        mesh_to_image_filter = mesh_to_image_filter_type.New(
            Input=mesh,
            Origin=origin,
            Spacing=spacing,
            Size=size,
            Direction=direction)
        mesh_to_image_filter.Update()

        distance = itk.signed_maurer_distance_map_image_filter(
            mesh_to_image_filter.GetOutput())
        images.append(distance)

    return images[0] if len(images) == 1 else images
Example #26
0
def streamline(model, step=0.5, minimum_fa=0.2, maximum_angle=numpy.pi/3, 
               minimum_length=50, propagation_type="Euler", seed_spacing=None, 
               mask=None) :
    """ Deterministic streamline propagation algorithm, return a list of tracks,
        where a track is a list of points in physical coordinates.
    
        * ``model`` : tensor field
        * ``step`` : propagation step
        * ``minimum_fa`` : minimum fractional anisotropy value allowed for
          propagation
        * ``maximum_angle`` : minimum angle value (in radians) allowed for
          propagation
        * ``minimum_length`` : minimum fiber length, in physical units
        * ``propagation_type`` : propagation criterion, may be either ``"Euler"``
          or ``"RungeKuttaOrder4"``
        * ``seed_spacing`` : spacing between seeds in physical units, defaults
          to ``2*model.spacing``
        * ``mask`` : optional mask to restrict seeding
    """

    if seed_spacing is None : 
        seed_spacing = model.spacing*(2.0,)
    seeds = _generate_image_sampling(model, seed_spacing/model.spacing, mask)

    itk_model = medipy.itk.medipy_image_to_itk_image(model, False)

    ScalarImage = itk.Image[itk.template(itk_model)[1]]
    tractography_filter = itk.StreamlineTractographyAlgorithm[
        itk_model, ScalarImage].New()
    
    tractography_filter.SetInputModel(itk_model)
    for seed in seeds:
        tractography_filter.AppendSeed(seed[::-1])
    tractography_filter.SetStepSize(step)
    tractography_filter.SetUseRungeKuttaOrder4(propagation_type=="RungeKuttaOrder4")
    tractography_filter.SetMaximumAngle(maximum_angle)
    tractography_filter.SetMinimumFA(minimum_fa)
    tractography_filter.SetMinimumLength(minimum_length)
    
    mask_itk = None
    if mask :
        mask_itk = medipy.itk.medipy_image_to_itk_image(mask, False)
        tractography_filter.SetMask(mask_itk)
    
    tractography_filter.Update()

    fibers = []
    for i in range(tractography_filter.GetNumberOfFibers()) :
        fiber = tractography_filter.GetOutputFiberAsPyArray(i)
        if _length(fiber,step)>=minimum_length :
            fibers.append(fiber)
    
    return fibers
Example #27
0
def spatial_parameter_estimation(tensor,
                                 size_plane=3,
                                 size_depth=3,
                                 mask=None):
    """ Neighborhood-based estimation of the mean and standard deviation of 
        second-order tensors.

        <gui>
            <item name="tensor" type="Image" label="DTI data"/>
            <item name="size_plane" type="Int" initializer="3" 
                  label="Neighborhood plane size"/>
            <item name="size_depth" type="Int" initializer="3" 
                  label="Neighborhood depth size"/>
            <item name="mask" type="Image" 
                  initializer="may_be_empty=True, may_be_empty_checked=True" 
                  label="Mask"/>
            <item name="mean" type="Image" initializer="output=True" 
                  role="return" label="Mean image"/>
            <item name="stdev" type="Image" initializer="output=True" 
                  role="return" label="Standard deviation image"/>
        </gui>
    """

    log_tensor = log_transformation(tensor)
    log_tensor_itk = medipy.itk.medipy_image_to_itk_image(log_tensor, False)
    ScalarImage = itk.Image[itk.template(log_tensor_itk)[1]]

    mask_itk = None
    MaskImage = ScalarImage
    if mask:
        mask_itk = medipy.itk.medipy_image_to_itk_image(mask, False)
        MaskImage = mask_itk.__class__

    estimation_filter = itk.SpatialDWIStatisticsImageFilter[
        log_tensor_itk, log_tensor_itk, ScalarImage,
        MaskImage].New(Input=log_tensor_itk,
                       SizePlane=size_plane,
                       SizeDepth=size_depth)
    if mask:
        estimation_filter.SetMaskImage(mask_itk)
    estimation_filter()

    mean_itk = estimation_filter.GetMeanImage()
    mean = medipy.itk.itk_image_to_medipy_image(mean_itk, None, True)
    mean.image_type = "tensor_2"
    mean = exp_transformation(mean)

    standard_deviation_itk = estimation_filter.GetStandardDeviationImage()
    standard_deviation = medipy.itk.itk_image_to_medipy_image(
        standard_deviation_itk, None, True)

    return mean, standard_deviation
Example #28
0
def _GetArrayFromVnlObject(vnl_object, function):
    """Get an array with the content of vnl_object
    """
    # Finds the vnl object type
    import itk

    PixelType = itk.template(vnl_object)[1][0]
    keys = [k for k in itk.PyVnl.keys() if k[0] == PixelType]
    if len(keys) == 0:
        raise RuntimeError("No suitable template parameter can be found.")
    # Create a numpy array of the type of the vnl object
    templatedFunction = getattr(itk.PyVnl[keys[0]], function)
    return templatedFunction(vnl_object)
Example #29
0
def linearTransform(Img,
                    scale,
                    shift,
                    outputImageType = None):
  s,d = itk.template(Img)[1]
  input_type = itk.Image[s,d]
  output_type = input_type if outputImageType is None else itk.Image[outputImageType,d]
  Result = itk.ShiftScaleImageFilter[input_type, output_type].New()
  Result.SetInput(Img)
  Result.SetScale(scale)
  Result.SetShift(shift)
  Result.Update()
  return Result.GetOutput()
Example #30
0
def resampling_transform(image, shape):
    
    imageType = itk.template(image)[0][itk.template(image)[1]]
    
    dummy_image = itk.image_from_array(np.zeros(tuple(reversed(shape)), dtype=itk.array_from_image(image).dtype))
    if len(shape) == 2:
        transformType = itk.MatrixOffsetTransformBase[itk.D, 2, 2]
    else:
        transformType = itk.VersorRigid3DTransform[itk.D]
    initType = itk.CenteredTransformInitializer[transformType, imageType, imageType]
    initializer = initType.New()
    initializer.SetFixedImage(dummy_image)
    initializer.SetMovingImage(image)
    transform = transformType.New()
    
    initializer.SetTransform(transform)
    initializer.InitializeTransform()
    
    if len(shape) == 3:
        transformType = itk.MatrixOffsetTransformBase[itk.D, 3, 3]
        t2 = transformType.New()
        t2.SetCenter(transform.GetCenter())
        t2.SetOffset(transform.GetOffset())
        transform = t2
    m = transform.GetMatrix()
    m_a = itk.array_from_matrix(m)
    
    input_shape = image.GetLargestPossibleRegion().GetSize()
    
    for i in range(len(shape)):
    
        m_a[i, i] = image.GetSpacing()[i] * (input_shape[i] / shape[i])
    
    m_a = itk.array_from_matrix(image.GetDirection()) @ m_a 
    
    transform.SetMatrix(itk.matrix_from_array(m_a))
    
    return transform
     
Example #31
0
    def can_save(self, image):
        if image.image_type != "tensor_2":
            return False

        BridgedTypes = set([itk.template(x[0])[1][0] for x in itk.NumpyBridge])
        PixelType = medipy.itk.dtype_to_itk[image.dtype.type]
        while PixelType not in BridgedTypes:
            PixelType = medipy.itk.types.larger_type[PixelType]
        Dimension = image.ndim

        VectorImageType = itk.VectorImage[PixelType, Dimension]

        return (VectorImageType, ) in itk.Tensor2ImageFileWriter.__template__
Example #32
0
def getInformation(image):  # tested
    """
    Returns an information string about a ITK image in a compressed way.
    
    Parameters
    ----------
    image : itk.Image
        An ITK image as used by WrapITK.
        
    Returns
    -------
    information : string
        Pretty-formatted string with image metadata.
        
    Notes
    -----
    Performs UpdateOutputInformation() on the image, therefore triggering pipeline processing if necessary
    Only works on 3D images.
    """
    # refresh information
    image.UpdateOutputInformation()

    # request information and format string
    s = 'itkImageData info:\n'
    s += '\tscalar-type: {}\n'.format(str(itk.template(image)[1][0]))
    rs = image.GetLargestPossibleRegion().GetSize()
    s += '\tdimensions: {}\n'.format(
        [rs.GetElement(x) for x in range(rs.GetSizeDimension())])
    sp = image.GetSpacing()
    s += '\tspacing: {}\n'.format(
        [sp.GetElement(x) for x in range(rs.GetSizeDimension())])
    o = image.GetOrigin()
    s += '\torigin: {}\n'.format(
        [o.GetElement(x) for x in range(rs.GetSizeDimension())])
    s += '\tdata dim.: {}'.format(str(itk.template(
        image)[1][1]))  # alternative impl. for when GetImageDimension() fails

    return s
Example #33
0
def GetArrayFromVnlMatrix(vnlMatrix):
    """Get an Array with the content of the vnl matrix
    """
    # Check for numpy
    if not HAVE_NUMPY:
        raise ImportError('Numpy not available.')
    # Finds the vnl matrix type
    import itk
    PixelType = itk.template(vnlMatrix)[1][0]
    keys = [k for k in itk.PyVnl.keys() if k[0] == PixelType]
    if len(keys) == 0:
        raise RuntimeError("No suitable template parameter can be found.")
    # Create a numpy array of the type of the vnl matrix
    return itk.PyVnl[keys[0]].GetArrayFromVnlMatrix(vnlMatrix)
Example #34
0
def GetArrayFromVnlMatrix(vnlMatrix):
    """Get an Array with the content of the vnl matrix
    """
    # Check for numpy
    if not HAVE_NUMPY:
        raise ImportError('Numpy not available.')
    # Finds the vnl matrix type
    import itk
    PixelType = itk.template(vnlMatrix)[1][0]
    keys = [k for k in itk.PyVnl.keys() if k[0] == PixelType]
    if len(keys ) == 0:
        raise RuntimeError("No suitable template parameter can be found.")
    # Create a numpy array of the type of the vnl matrix
    return itk.PyVnl[keys[0]].GetArrayFromVnlMatrix(vnlMatrix)
Example #35
0
def main(args):
	img = itk.imread(args.img)
	img_np = itk.GetArrayViewFromImage(img).astype(float)
	num_splits = img_np.shape[args.axis]
	img_np_split = np.split(img_np, num_splits, axis=args.axis)

	out_shape = np.delete(np.shape(img_np), args.axis)

	PixelType = itk.template(img)[1][0]
	Dimension = 2
	PixelDimension = img.GetNumberOfComponentsPerPixel()
	
	Origin = np.delete(np.array(img.GetOrigin())[::-1], args.axis)
	Spacing = np.delete(np.array(img.GetSpacing())[::-1], args.axis)

	index = itk.Index[Dimension]()
	index.Fill(0)

	size = itk.Size[Dimension]()
	size.Fill(1)
	for i, s in enumerate(np.copy(out_shape)[::-1]):
		size[i] = int(s)

	RegionType = itk.ImageRegion[Dimension]
	Region = RegionType()
	Region.SetIndex(index)
	Region.SetSize(size)

	OutputImageType = itk.VectorImage[PixelType, 2]

	if PixelDimension > 1:
		np.append(out_shape, PixelDimension)

	for i, slice_np in enumerate(img_np_split):
		# print(np.reshape(slice_np, out_shape).shape)
		out_img = OutputImageType.New()
		out_img.SetNumberOfComponentsPerPixel(PixelDimension)
		out_img.SetOrigin(Origin)
		out_img.SetSpacing(Spacing)
		out_img.SetRegions(Region)
		out_img.Allocate()

		out_img_np = itk.GetArrayViewFromImage(out_img)
		out_img_np.setfield(np.reshape(slice_np, out_shape), out_img_np.dtype)

		out_name = os.path.join(args.out, args.prefix + str(i) + args.ext)
		print("Writing:", out_name)
		writer = itk.ImageFileWriter.New(FileName=out_name, Input=out_img)
		writer.UseCompressionOn()
		writer.Update()
Example #36
0
def _GetArrayFromVnlObject(vnl_object, function):
    """Get an array with the content of vnl_object
    """
    # Check for numpy
    if not HAVE_NUMPY:
        raise ImportError('Numpy not available.')
    # Finds the vnl object type
    import itk
    PixelType = itk.template(vnl_object)[1][0]
    keys = [k for k in itk.PyVnl.keys() if k[0] == PixelType]
    if len(keys ) == 0:
        raise RuntimeError("No suitable template parameter can be found.")
    # Create a numpy array of the type of the vnl object
    templatedFunction = getattr(itk.PyVnl[keys[0]], function)
    return templatedFunction(vnl_object)
Example #37
0
    def save(self, image):
        BridgedTypes = set([itk.template(x[0])[1][0] for x in itk.NumpyBridge])
        PixelType = medipy.itk.dtype_to_itk[image.dtype.type]
        while PixelType not in BridgedTypes:
            PixelType = medipy.itk.types.larger_type[PixelType]
        Dimension = image.ndim

        VectorImageType = itk.VectorImage[PixelType, Dimension]

        itk_image = medipy.itk.medipy_image_to_itk_image(image, False)

        writer = itk.Tensor2ImageFileWriter[VectorImageType].New(
            ImageIO=self._saver, Input=itk_image)

        writer.SetFileName(self._filename)
        writer.Update()
Example #38
0
def _compute_scalar(image, scalar_name):
    """ Compute a scalar from a tensor image.
    """

    Filter = getattr(itk, "{0}ImageFilter".format(scalar_name))

    itk_image = medipy.itk.medipy_image_to_itk_image(image, False)
    ScalarImage = itk.Image[itk.template(itk_image)[1]]

    filter_ = Filter[itk_image, ScalarImage].New(Input=itk_image)
    filter_()
    itk_output = filter_[0]

    output = medipy.itk.itk_image_to_medipy_image(itk_output, None, True)
    output.data[numpy.isnan(output.data)] = 0
    output.data[numpy.isinf(output.data)] = 0

    return output
Example #39
0
 def __init__(self, *args, **kargs):
   # call the constructor of the superclass but without args and kargs, because the attributes
   # are not all already there!
   # Set/GetRadius() is created in the constructor for example, with the expose() method
   itk.pipeline.__init__(self)
   
   # get the template parameters
   template_parameters = kargs["template_parameters"]
   
   # and store them in an easier way
   ImageType, DistanceMapType = template_parameters
   # the maximum value of the image type
   PixelType, dim = itk.template(ImageType)[1]
   LabelMapType = itk.LabelMap[itk.StatisticsLabelObject[itk.UL, dim]]
   # build the minipipeline
   self.connect(itk.LabelMapToLabelImageFilter[LabelMapType, ImageType].New())
   self.connect(ClosestLabelDilateImageFilter[ImageType, DistanceMapType].New())
   self.expose("Kernel")
   self.expose("Radius")
   self.connect(itk.LabelImageToLabelMapFilter[ImageType, LabelMapType].New())
   
   # now we can parse the inputs
   itk.set_inputs(self, args, kargs)
Example #40
0
  def __init__(self, fileName=None, channel=0, ImageType=None ):
    from vtk import vtkLSMReader, vtkImageCast
    import itk
    itk.pipeline.__init__(self)
    # if ImageType is None, give it a default value
    # this is useful to avoid loading Base while loading this module
    if ImageType == None:
      ImageType = itk.Image.UC3
    # remove useless SetInput() method created by the constructor of the pipeline class
#     del self.SetInput
    # set up the pipeline
    self.connect( vtkLSMReader() )
    self.connect( vtkImageCast() )
    PType = itk.template(ImageType)[1][0]
    if PType == itk.UC:
      self.filters[-1].SetOutputScalarTypeToUnsignedChar()
    elif PType == itk.US:
      self.filters[-1].SetOutputScalarTypeToUnsignedShort()
    self.connect( itk.VTKImageToImageFilter[ImageType].New() )
    self.connect( itk.ChangeInformationImageFilter[ImageType].New( ChangeSpacing=True ) )
    # and configure the pipeline
    if fileName:
      self.SetFileName( fileName )
    self.SetChannel( channel )
Example #41
0
    def __init__(self, imageOrFilter, Label=False, Title=None):
        import tempfile
        import itk
        import os
        import platform
        # get some data from the environment
        command = os.environ.get("WRAPITK_SHOW2D_COMMAND")
        if command is None:
            if platform.system() == "Darwin":
                command = (
                    "open -a ImageJ -n --args -eval 'open(\"%(image)s\"); "
                    "run (\"View 100%%\"); rename(\"%(title)s\");'")
            else:
                command = (
                    "imagej %(image)s -run 'View 100%%' -eval "
                    "'rename(\"%(title)s\")' &")

        label_command = os.environ.get("WRAPITK_SHOW2D_LABEL_COMMAND")
        if label_command is None:
            if platform.system() == "Darwin":
                label_command = (
                    "open -a ImageJ -n --args -eval 'open(\"%(image)s\"); "
                    "run (\"View 100%%\"); rename(\"%(title)s\"); "
                    "run(\"3-3-2 RGB\");'")
            else:
                label_command = (
                    "imagej %(image)s -run 'View 100%%' -eval "
                    "'rename(\"%(title)s\")' -run '3-3-2 RGB' &")

        compress = os.environ.get(
            "WRAPITK_SHOW2D_COMPRESS",
            "true").lower() in ["on", "true", "yes", "1"]
        extension = os.environ.get("WRAPITK_SHOW2D_EXTENSION", ".tif")

        # use the tempfile module to get a non used file name and to put
        # the file at the rignt place
        self.__tmpFile__ = tempfile.NamedTemporaryFile(suffix=extension)
        # get an updated image
        img = output(imageOrFilter)
        img.UpdateOutputInformation()
        img.Update()
        if Title is None:
            # try to generate a title
            s = img.GetSource()
            if s:
                s = itk.down_cast(s)
                if hasattr(img, "GetSourceOutputIndex"):
                    o = '[%s]' % img.GetSourceOutputIndex()
                elif hasattr(img, "GetSourceOutputName"):
                    o = '[%s]' % img.GetSourceOutputName()
                else:
                    o = ""
                Title = "%s%s" % (s.__class__.__name__, o)
            else:
                Title = img.__class__.__name__
            try:
                import IPython
                ip = IPython.get_ipython()
                if ip is not None:
                    names = []
                    ref = imageOrFilter
                    if s:
                        ref = s
                    for n, v in ip.user_ns.iteritems():
                        if isinstance(v, itk.LightObject) and v == ref:
                            names.append(n)
                    if names != []:
                        Title = ", ".join(names) + " - " + Title
            except ImportError:
                # just do nothing
                pass
        # change the LabelMaps to an Image, so we can look at them easily
        if 'LabelMap' in dir(itk) and img.GetNameOfClass() == 'LabelMap':
            # retreive the biggest label in the label map
            maxLabel = img.GetNthLabelObject(
                img.GetNumberOfLabelObjects() - 1).GetLabel()
            # search for a filter to convert the label map
            lab = itk.LabelMapToLabelImageFilter.keys()
            maxVal = itk.NumericTraits[itk.template(params[1])[1][0]].max()
            cond = params[0] == class_(img) and maxVal >= maxLabel
            label_image_type = sorted([params[1] for params in lab if cond])[0]
            convert = itk.LabelMapToLabelImageFilter[
                img, label_image_type].New(img)
            convert.Update()
            img = convert.GetOutput()
            # this is a label image - force the parameter
            Label = True
        write(img, self.__tmpFile__.name, compress)
        # now run imview
        import os
        if Label:
            os.system(
                label_command %
                {"image": self.__tmpFile__.name, "title": Title})
        else:
            os.system(
                command %
                {"image": self.__tmpFile__.name, "title": Title})
Example #42
0
# template should return the same class with a class as parameter
# or with an object of this class, and should also be the same
# with the attribute

# create instances of image for the next tests
im = ImageType.New()
im2 = ImageType.New()

readerType = itk.ImageFileReader[ImageType]
readerType2 = itk.ImageFileReader[im]
readerType3 = itk.ImageFileReader.IUC2

assert readerType == readerType2 == readerType3

# we should be able to get the template and its parameters from the class
(tpl, parameters) = itk.template(ImageType)
assert tpl == itk.Image
assert parameters == (PixelType, dim)

# test that `isinstance` works
obj = itk.ImageFileReader[ImageType].New()
assert isinstance(obj, itk.ImageFileReader.IUC2)
assert isinstance(obj, itk.ImageFileReader)

# the template must raise a KeyError exception if the template parameter
# is unknown
try:
    itk.ImageFileReader['unknown parameter']
    raise Exception('no exception sent for unknown parameter')
except TypeError as e:
    print("Exception caught!")
Example #43
0
IType = itk.Image[PType, dim]
ReaderType = itk.ImageFileReader[IType]
reader = ReaderType.New(FileName=fileName)


# test echo
itk.echo(reader)
itk.echo(reader, sys.stdout)

# test class_
assert itk.class_(reader) == ReaderType
assert itk.class_(reader.GetPointer()) == ReaderType
assert itk.class_("dummy") == str

# test template
assert itk.template(ReaderType) == (itk.ImageFileReader, (IType,))
assert itk.template(reader) == (itk.ImageFileReader, (IType,))
assert itk.template(reader.GetPointer()) == (itk.ImageFileReader, (IType,))
try:
  itk.template(str)
  raise Exception("unknown class should send an exception")
except KeyError:
  pass

# test ctype
assert itk.ctype("unsigned short") == itk.US
assert itk.ctype("        unsigned      \n   short \t  ") == itk.US
try:
  itk.ctype("dummy")
  raise Exception("unknown C type should send an exception")
except KeyError:
Example #44
0
 def __init__(self, imageOrFilter, Label=False) :
   import tempfile, itk, os
   # get some data from the environment
   command = os.environ.get("WRAPITK_SHOW2D_COMMAND", "imview %s -fork")
   label_command = os.environ.get("WRAPITK_SHOW2D_LABEL_COMMAND", "imview %s -c regions.lut -fork")
   compress = os.environ.get("WRAPITK_SHOW2D_COMPRESS", "true").lower() in ["on", "true", "yes", "1"]
   extension = os.environ.get("WRAPITK_SHOW2D_EXTENSION", ".tif")
   # use the tempfile module to get a non used file name and to put
   # the file at the rignt place
   self.__tmpFile__ = tempfile.NamedTemporaryFile(suffix=extension)
   # get an updated image
   img = output(imageOrFilter)
   img.UpdateOutputInformation()
   img.Update()
   # change the LabelMaps to an Image, so we can look at them easily
   if 'LabelMap' in dir(itk) and img.GetNameOfClass() == 'LabelMap':
     # retreive the biggest label in the label map
     maxLabel = img.GetNthLabelObject( img.GetNumberOfLabelObjects() - 1 ).GetLabel()
     # search for a filter to convert the label map
     label_image_type = sorted( [params[1] for params in itk.LabelMapToLabelImageFilter.keys() if params[0] == class_(img) and itk.NumericTraits[itk.template(params[1])[1][0]].max() >= maxLabel ] )[0]
     convert = itk.LabelMapToLabelImageFilter[ img, label_image_type ].New( img )
     convert.Update()
     img = convert.GetOutput()
     # this is a label image - force the parameter
     Label = True
   write(img, self.__tmpFile__.name, compress)
   # now run imview
   import os
   if Label:
     os.system( label_command % self.__tmpFile__.name)
   else:
     os.system( command % self.__tmpFile__.name)
Example #45
0
ReaderType = itk.ImageFileReader[ImageType]
reader = ReaderType.New(FileName=fileName)

# test snake_case keyword arguments
reader = ReaderType.New(file_name=fileName)

# test echo
itk.echo(reader)
itk.echo(reader, sys.stdout)

# test class_
assert itk.class_(reader) == ReaderType
assert itk.class_("dummy") == str

# test template
assert itk.template(ReaderType) == (itk.ImageFileReader, (ImageType,))
assert itk.template(reader) == (itk.ImageFileReader, (ImageType,))
try:
    itk.template(str)
    raise Exception("unknown class should send an exception")
except KeyError:
    pass

# test ctype
assert itk.ctype("unsigned short") == itk.US
assert itk.ctype("        unsigned      \n   short \t  ") == itk.US
assert itk.ctype("signed short") == itk.SS
assert itk.ctype("short") == itk.SS
try:
    itk.ctype("dummy")
    raise Exception("unknown C type should send an exception")
Example #46
0
# template should return the same class with a class as parameter
# or with an object of this class, and should also be the same
# with the attribute

# create instances of image for the next tests
im = IType.New()
im2 = IType.New()

readerType = itk.ImageFileReader[IType]
readerType2 = itk.ImageFileReader[im]
readerType3 = itk.ImageFileReader.IUC2

assert readerType == readerType2 == readerType3

# we should be able to get the template and its parameters from the class
(tpl, parameters) = itk.template( IType )
assert tpl == itk.Image
assert parameters == (PType, dim)

# the template must raise a KeyError exception if the template parameter
# is unknown
try :
  itk.ImageFileReader['unknown parameter']
  raise Exception('no exception sent for unknown parameter')
except KeyError:
  pass

# TODO: test the rest of the dict interface
# TODO: test __eq__, __ne__ and __hash__

# something else ?