Ejemplo n.º 1
0
    def __init__(self,
                 experiments,
                 filter_type="median",
                 kernel_size=10,
                 niter=100):
        """
        Initialize the finalizer

        :param experiments: The experiment list
        :param kernel_size: The median filter kernel size
        :param niter: The number of iterations for filling holes
        """
        from dials.algorithms.background.gmodel import PolarTransform

        # Set some parameters
        self.filter_type = filter_type
        self.kernel_size = kernel_size
        self.niter = niter

        # Check the input
        assert len(experiments) == 1
        experiment = experiments[0]
        assert len(experiment.detector) == 1

        # Save the experiment
        self.experiment = experiment

        # Create the transform object
        self.transform = PolarTransform(experiment.beam,
                                        experiment.detector[0],
                                        experiment.goniometer)
Ejemplo n.º 2
0
  def run(self):
    ''' Perform the integration. '''
    from dials.util.command_line import heading
    from dials.util.options import flatten_experiments
    from dials.util import log
    from time import time
    from libtbx.utils import Sorry
    from dials.array_family import flex

    # Parse the command line
    params, options = self.parser.parse_args(show_diff_phil=False)
    experiments = flatten_experiments(params.input.experiments)
    if len(experiments) == 0:
      self.parser.print_help()
      return

    assert len(experiments) == 1
    imageset = experiments[0].imageset
    beam = experiments[0].beam
    detector = experiments[0].detector
    goniometer = experiments[0].goniometer
    assert len(detector) == 1

    # Configure logging
    log.config()

    from dials.algorithms.background.gmodel import PolarTransform
    import cPickle as pickle
    model = pickle.load(open(params.model))
    image = model.data(0)
    mask = flex.bool(image.accessor(), True)

    # Do the transformation
    transform = PolarTransform(beam, detector[0], goniometer)
    result = transform.to_polar(image, mask)
    data = result.data()
    mask = result.mask()

    pickle.dump((data, mask), open(params.output.data, "w"))

    from matplotlib import pylab
    vmax = sorted(list(data))[int(0.99 * len(data))]
    figure = pylab.figure(figsize=(6,4))
    pylab.imshow(
      data.as_numpy_array(),
      interpolation = 'none',
      vmin          = 0,
      vmax          = vmax)
    ax1 = pylab.gca()
    ax1.get_xaxis().set_visible(False)
    ax1.get_yaxis().set_visible(False)
    cb = pylab.colorbar()
    cb.ax.tick_params(labelsize=8)
    logger.info("Saving polar model %s" % (params.output.image))
    pylab.savefig("%s" % (params.output.image), dpi=600, bbox_inches='tight')
Ejemplo n.º 3
0
  def __init__(self, experiments, filter_type='median', kernel_size=10, niter=100):
    '''
    Initialize the finalizer

    :param experiments: The experiment list
    :param kernel_size: The median filter kernel size
    :param niter: The number of iterations for filling holes

    '''
    from dials.algorithms.background.gmodel import PolarTransform

    # Set some parameters
    self.filter_type = filter_type
    self.kernel_size = kernel_size
    self.niter = niter

    # Check the input
    assert len(experiments) == 1
    experiment = experiments[0]
    assert len(experiment.detector) == 1

    # Save the experiment
    self.experiment = experiment

    # Create the transform object
    self.transform = PolarTransform(
      experiment.beam,
      experiment.detector[0],
      experiment.goniometer)
Ejemplo n.º 4
0
class FinalizeModel(object):
  '''
  A class to finalize the background model

  '''

  def __init__(self, experiments, filter_type='median', kernel_size=10, niter=100):
    '''
    Initialize the finalizer

    :param experiments: The experiment list
    :param kernel_size: The median filter kernel size
    :param niter: The number of iterations for filling holes

    '''
    from dials.algorithms.background.gmodel import PolarTransform

    # Set some parameters
    self.filter_type = filter_type
    self.kernel_size = kernel_size
    self.niter = niter

    # Check the input
    assert len(experiments) == 1
    experiment = experiments[0]
    assert len(experiment.detector) == 1

    # Save the experiment
    self.experiment = experiment

    # Create the transform object
    self.transform = PolarTransform(
      experiment.beam,
      experiment.detector[0],
      experiment.goniometer)

  def finalize(self, data, mask):
    '''
    Finalize the model

    :param data: The data array
    :param mask: The mask array

    '''
    from dials.algorithms.image.filter import median_filter, mean_filter
    from dials.algorithms.image.fill_holes import diffusion_fill
    from dials.algorithms.image.fill_holes import simple_fill
    from dials.array_family import flex

    # Print some image properties
    sub_data = data.as_1d().select(mask.as_1d())
    logger.info('Raw image statistics:')
    logger.info('  min:  %d' % int(flex.min(sub_data)))
    logger.info('  max:  %d' % int(flex.max(sub_data)))
    logger.info('  mean: %d' % int(flex.mean(sub_data)))
    logger.info('')

    # Transform to polar
    logger.info('Transforming image data to polar grid')
    result = self.transform.to_polar(data, mask)
    data = result.data()
    mask = result.mask()
    sub_data = data.as_1d().select(mask.as_1d())
    logger.info('Polar image statistics:')
    logger.info('  min:  %d' % int(flex.min(sub_data)))
    logger.info('  max:  %d' % int(flex.max(sub_data)))
    logger.info('  mean: %d' % int(flex.mean(sub_data)))
    logger.info('')

    # Filter the image to remove noise
    if self.kernel_size > 0:
      if self.filter_type == 'median':
        logger.info('Applying median filter')
        data = median_filter(data, mask, (self.kernel_size, 0))
        sub_data = data.as_1d().select(mask.as_1d())
        logger.info('Median polar image statistics:')
        logger.info('  min:  %d' % int(flex.min(sub_data)))
        logger.info('  max:  %d' % int(flex.max(sub_data)))
        logger.info('  mean: %d' % int(flex.mean(sub_data)))
        logger.info('')
      elif self.filter_type == 'mean':
        logger.info('Applying mean filter')
        mask_as_int = mask.as_1d().as_int()
        mask_as_int.reshape(mask.accessor())
        data = mean_filter(data, mask_as_int, (self.kernel_size, 0), 1)
        sub_data = data.as_1d().select(mask.as_1d())
        logger.info('Mean polar image statistics:')
        logger.info('  min:  %d' % int(flex.min(sub_data)))
        logger.info('  max:  %d' % int(flex.max(sub_data)))
        logger.info('  mean: %d' % int(flex.mean(sub_data)))
        logger.info('')
      else:
        raise RuntimeError('Unknown filter_type: %s' % self.filter_type)

    # Fill any remaining holes
    logger.info("Filling holes")
    data = simple_fill(data, mask)
    data = diffusion_fill(data, mask, self.niter)
    mask = flex.bool(data.accessor(), True)
    sub_data = data.as_1d().select(mask.as_1d())
    logger.info('Filled polar image statistics:')
    logger.info('  min:  %d' % int(flex.min(sub_data)))
    logger.info('  max:  %d' % int(flex.max(sub_data)))
    logger.info('  mean: %d' % int(flex.mean(sub_data)))
    logger.info('')

    # Transform back
    logger.info('Transforming image data from polar grid')
    result = self.transform.from_polar(data, mask)
    data = result.data()
    mask = result.mask()
    sub_data = data.as_1d().select(mask.as_1d())
    logger.info('Final image statistics:')
    logger.info('  min:  %d' % int(flex.min(sub_data)))
    logger.info('  max:  %d' % int(flex.max(sub_data)))
    logger.info('  mean: %d' % int(flex.mean(sub_data)))
    logger.info('')

    # Fill in any discontinuities
    # FIXME NEED TO HANDLE DISCONTINUITY
    # mask = ~self.transform.discontinuity()[:-1,:-1]
    # data = diffusion_fill(data, mask, self.niter)

    # Get and apply the mask
    mask = self.experiment.imageset.get_mask(0)[0]
    mask = mask.as_1d().as_int().as_double()
    mask.reshape(data.accessor())
    data *= mask

    # Return the result
    return data
Ejemplo n.º 5
0
class FinalizeModel(object):
    """
    A class to finalize the background model
    """
    def __init__(self,
                 experiments,
                 filter_type="median",
                 kernel_size=10,
                 niter=100):
        """
        Initialize the finalizer

        :param experiments: The experiment list
        :param kernel_size: The median filter kernel size
        :param niter: The number of iterations for filling holes
        """
        from dials.algorithms.background.gmodel import PolarTransform

        # Set some parameters
        self.filter_type = filter_type
        self.kernel_size = kernel_size
        self.niter = niter

        # Check the input
        assert len(experiments) == 1
        experiment = experiments[0]
        assert len(experiment.detector) == 1

        # Save the experiment
        self.experiment = experiment

        # Create the transform object
        self.transform = PolarTransform(experiment.beam,
                                        experiment.detector[0],
                                        experiment.goniometer)

    def finalize(self, data, mask):
        """
        Finalize the model

        :param data: The data array
        :param mask: The mask array
        """
        from dials.algorithms.image.filter import median_filter, mean_filter
        from dials.algorithms.image.fill_holes import diffusion_fill
        from dials.algorithms.image.fill_holes import simple_fill
        from dials.array_family import flex

        # Print some image properties
        sub_data = data.as_1d().select(mask.as_1d())
        logger.info("Raw image statistics:")
        logger.info("  min:  %d" % int(flex.min(sub_data)))
        logger.info("  max:  %d" % int(flex.max(sub_data)))
        logger.info("  mean: %d" % int(flex.mean(sub_data)))
        logger.info("")

        # Transform to polar
        logger.info("Transforming image data to polar grid")
        result = self.transform.to_polar(data, mask)
        data = result.data()
        mask = result.mask()
        sub_data = data.as_1d().select(mask.as_1d())
        logger.info("Polar image statistics:")
        logger.info("  min:  %d" % int(flex.min(sub_data)))
        logger.info("  max:  %d" % int(flex.max(sub_data)))
        logger.info("  mean: %d" % int(flex.mean(sub_data)))
        logger.info("")

        # Filter the image to remove noise
        if self.kernel_size > 0:
            if self.filter_type == "median":
                logger.info("Applying median filter")
                data = median_filter(data,
                                     mask, (self.kernel_size, 0),
                                     periodic=True)
                sub_data = data.as_1d().select(mask.as_1d())
                logger.info("Median polar image statistics:")
                logger.info("  min:  %d" % int(flex.min(sub_data)))
                logger.info("  max:  %d" % int(flex.max(sub_data)))
                logger.info("  mean: %d" % int(flex.mean(sub_data)))
                logger.info("")
            elif self.filter_type == "mean":
                logger.info("Applying mean filter")
                mask_as_int = mask.as_1d().as_int()
                mask_as_int.reshape(mask.accessor())
                data = mean_filter(data, mask_as_int, (self.kernel_size, 0), 1)
                sub_data = data.as_1d().select(mask.as_1d())
                logger.info("Mean polar image statistics:")
                logger.info("  min:  %d" % int(flex.min(sub_data)))
                logger.info("  max:  %d" % int(flex.max(sub_data)))
                logger.info("  mean: %d" % int(flex.mean(sub_data)))
                logger.info("")
            else:
                raise RuntimeError("Unknown filter_type: %s" %
                                   self.filter_type)

        # Fill any remaining holes
        logger.info("Filling holes")
        data = simple_fill(data, mask)
        data = diffusion_fill(data, mask, self.niter)
        mask = flex.bool(data.accessor(), True)
        sub_data = data.as_1d().select(mask.as_1d())
        logger.info("Filled polar image statistics:")
        logger.info("  min:  %d" % int(flex.min(sub_data)))
        logger.info("  max:  %d" % int(flex.max(sub_data)))
        logger.info("  mean: %d" % int(flex.mean(sub_data)))
        logger.info("")

        # Transform back
        logger.info("Transforming image data from polar grid")
        result = self.transform.from_polar(data, mask)
        data = result.data()
        mask = result.mask()
        sub_data = data.as_1d().select(mask.as_1d())
        logger.info("Final image statistics:")
        logger.info("  min:  %d" % int(flex.min(sub_data)))
        logger.info("  max:  %d" % int(flex.max(sub_data)))
        logger.info("  mean: %d" % int(flex.mean(sub_data)))
        logger.info("")

        # Fill in any discontinuities
        mask = ~self.transform.discontinuity()[:-1, :-1]
        data = diffusion_fill(data, mask, self.niter)

        # Get and apply the mask
        mask = self.experiment.imageset.get_mask(0)[0]
        mask = mask.as_1d().as_int().as_double()
        mask.reshape(data.accessor())
        data *= mask

        # Return the result
        return data