Esempio 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)
Esempio 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')