Python Registry.Registry类代码示例

  def run(self):
    from dxtbx.imageset import MultiFileReader, ImageSweep
    from dxtbx.format.Registry import Registry

    # Get the filenames
    filenames = self.get_file_list()

    # Create the format class
    format_class = Registry.find(filenames[0])

    # Create the reader
    reader = MultiFileReader(format_class, filenames)

    # Create the sweep
    sweep = ImageSweep(reader)

    # Run a load of tests
    self.tst_get_item(sweep)
    self.tst_len(sweep, len(filenames))
    self.tst_iter(sweep)
    self.tst_indices(sweep, range(0, 9))
    self.tst_paths(sweep, filenames)
    self.tst_is_valid(sweep)
    self.tst_get_detectorbase(sweep, range(len(filenames)), 9)
    self.tst_get_models(sweep, range(len(filenames)), 9)
    self.tst_get_array_range(sweep, (0, 9))
    self.tst_to_array(sweep, (3, 7), (3, 7, 50, 100, 100, 200))
    self.tst_set_models(sweep)

  def make_imageset(filenames, format_class=None, check_format=True,
                    single_file_indices=None, format_kwargs=None):
    '''Create an image set'''
    from dxtbx.format.Registry import Registry
    from format.FormatMultiImage import FormatMultiImage

    # Get the format object
    if format_class == None and check_format:
      format_class = Registry.find(filenames[0])
    if format_class is None:
      reader = NullReader(filenames, single_file_indices is not None)
    else:
      if issubclass(format_class, FormatMultiImage):
        assert len(set(filenames)) == 1
        if format_kwargs is None:
          format_kwargs = {}
        format_instance = format_class(filenames[0], **format_kwargs)
        reader = SingleFileReader(format_instance)
      else:
        reader = MultiFileReader(format_class, filenames,
                                 format_kwargs=format_kwargs)

    # Return the imageset
    return ImageSet(reader, indices=single_file_indices,
                    format_kwargs=format_kwargs)

def pydiffdump_fast(files):
  '''First find the class, then read every frame with it.'''

  s = time.time()

  format = Registry.find(files[0])

  scan = None

  for f in files:

    i = format(f)
    print 'Beam:'
    print i.get_xbeam()
    print 'Goniometer:'
    print i.get_xgoniometer()
    print 'Detector:'
    print i.get_xdetector()
    print 'Scan:'
    print i.get_xscan()

    if scan is None:
      scan = i.get_xscan()
    else:
      scan += i.get_xscan()

  print scan

  return time.time() - s

def dxtbx_spotfinder_factory(phil_params):

  from dxtbx.format.Registry import Registry
  reader = Registry.find(phil_params.distl.image[0])
  from spotfinder.dxtbx_toolbox.practical_heuristics import heuristics_base
  Spotfinder = heuristics_base(phil_params)
  return Spotfinder

def pydiffdump(files):
  '''Print the class which claims to work with each file.'''

  s = time.time()

  for f in files:

    print f

    format = Registry.find(f)

    print format.__name__

    if format.understand(f):
      i = format(f)

      print 'Beam:'
      print i.get_beam()
      print 'Goniometer:'
      print i.get_goniometer()
      print 'Detector:'
      print i.get_detector()
      print 'Scan:'
      print i.get_scan()

  return time.time() - s

def TestRegistry2(files):
  '''First find the class, then read every frame with it.'''

  s = time.time()

  format = Registry.find(files[0])

  b0 = format(files[0]).get_beam()
  g0 = format(files[0]).get_goniometer()
  d0 = format(files[0]).get_detector()

  for f in files:

    print f

    i = format(f)
    print i.get_beam()
    print i.get_goniometer()
    print i.get_detector()
    print i.get_scan()
    print i.get_cube()

    print i.get_beam() == b0, i.get_goniometer() == g0, \
          i.get_detector() == d0

  return time.time() - s

  def from_template(template, image_range=None, check_headers=False,
                    check_format=True):
    '''Create a new sweep from a template.

    Params:
        template The template argument
        image_range The image range
        check_headers Check the headers to ensure all images are valid

    Returns:
        A list of sweeps

    '''
    import os
    from dxtbx.format.Registry import Registry
    from dxtbx.sweep_filenames import template_image_range

    if not check_format: assert not check_headers

    # Check the template is valid
    if template.count('#') < 1:
      raise ValueError("Invalid template")

    # Get the template format
    pfx = template.split('#')[0]
    sfx = template.split('#')[-1]
    template_format = '%s%%0%dd%s' % (pfx, template.count('#'), sfx)

    # Get the template image range
    if image_range is None:
      image_range = template_image_range(template)

    # Set the image range
    array_range = (image_range[0] - 1, image_range[1])

    # Create the sweep file list
    filenames = SweepFileList(template_format, array_range)

    # Get the format class
    if check_format:
      format_class = Registry.find(filenames[0])
      from format.FormatMultiImage import FormatMultiImage
      if issubclass(format_class, FormatMultiImage):
        assert len(filenames) == 1
        format_instance = format_class(filenames[0])
        reader = SingleFileReader(format_instance)
      else:
        reader = MultiFileReader(format_class, filenames)
    else:
      reader = NullReader(filenames)

    # Create the sweep object
    sweep = ImageSweep(reader)

    # Check the sweep is valid
    if check_headers and not sweep.is_valid():
      raise RuntimeError('Invalid sweep of images')

    # Return the sweep
    return [sweep]

def cbf_file_to_basis_dict(path):
  """ Maps a cbf file to a dictionary of tuples and basis objects, in the same form as the above from
  read_optical_metrology_from_flat_file
  @param path cbf file path """
  from dxtbx.format.Registry import Registry
  reader = Registry.find(path)
  instance = reader(path)
  return map_detector_to_basis_dict(instance.get_detector())

 def find_format(self, filename):
   ''' Check the current and child formats, otherwise search the registry. '''
   from dxtbx.format.Registry import Registry
   try:
     if self._format_class == None or not self.understand(filename):
       self._format_class = Registry.find(filename)
     self._format_class = self.check_child_formats(filename)
   except Exception:
     return None
   return self._format_class

 def __call__(self, filename):
   ''' Check the current and child formats, otherwise search the registry. '''
   from dxtbx.format.Registry import Registry
   try:
     if self._format_class == None or not self.understand(filename):
       self._format_class = Registry.find(filename)
     self._format_class = self.check_child_formats(filename)
     if self._verbose:
       print 'Using %s for %s' % (self._format_class.__name__, filename)
   except Exception:
     return None
   return self._format_class

  def oneImage(self,framenumber):
    self.reporters[framenumber] = []

    from dxtbx.format.Registry import Registry
    filename = self.phil_params.distl.image[framenumber]
    reader = Registry.find(filename)
    img = reader(filename)

    detector = img.get_detector()
    beam = img.get_beam()
    S0 = beam.get_s0()
    data = img.get_raw_data()
    scan = img.get_scan()
    print scan
    if scan is None:
      print "No scan"
      RR = (0,1)
    else:
      print scan.get_oscillation()
      RR = scan.get_oscillation_range()

    from spotfinder.dxtbx_toolbox import Distl

    sfall = Distl(params = self.phil_params, detector = detector, beam = beam, data = data)

    resolutions = flex.double()
    spotlist = []
    from dials.model.data import ReflectionList,Reflection
    reflections = ReflectionList()


    for ip,panel in enumerate(detector):
      for spot in sfall.finderlist[ip].spots:
        resolutions.append( panel.get_resolution_at_pixel(S0, (spot.ctr_mass_x(), spot.ctr_mass_y())) )
        spotlist.append(spot)
        refl = Reflection()
        refl.panel_number = ip
        refl.centroid_position = (spot.ctr_mass_x(), spot.ctr_mass_y(),0.0)
        refl.centroid_variance = (0.5,0.5,0.0)
        reflections.append(refl)


    selection = (resolutions>0.0)
    if self.phil_params.distl.res.outer is not None:
      selection = (selection and (resolutions>self.phil_params.distl.res.outer))
    if self.phil_params.distl.res.inner is not None:
      selection = (selection and (resolutions<self.phil_params.distl.res.inner))

    reflections = reflections.select(selection)

    return dict(detector=detector, beam=beam, reflections=reflections, scan = scan,
                gonio = img.get_goniometer())

  def __init__(self, name, bases, attributes):
    super(_MetaFormat, self).__init__(name, bases, attributes)

    # Do-nothing until the Format module, defining the base class,
    # has been loaded.
    try:
      sys.modules[Format.__module__]
    except NameError:
      return

    # Add the class to the registry if it is directly derived from
    # Format.
    self._children = []
    if Format in bases:
      from dxtbx.format.Registry import Registry
      Registry.add(self)
      return

    # Add the class to the list of children of its superclasses.
    for base in bases:
      base._children.append(self)
    return

def load(filename):
  """Use DXTBX to get the files from the input filename.

  Params:
      filename The input filename

  Returns:
      The dxtbx format instance

  """
  from dxtbx.format.Registry import Registry
  format_instance = Registry.find(filename)
  return format_instance(filename)

    def _create_sweep(filelist, check_headers):
        """Create a sweep"""
        import os
        from dxtbx.format.Registry import Registry

        # Extract info from filelist
        template, indices, is_sweep = filelist

        # Get the template format
        count = template.count("#")
        if count > 0:
            pfx = template.split("#")[0]
            sfx = template.split("#")[-1]
            template_format = "%s%%0%dd%s" % (pfx, template.count("#"), sfx)
            filenames = [template_format % index for index in indices]
        else:
            filenames = [template]

        # Sort the filenames
        filenames = sorted(filenames)

        # Get the format object
        format_class = Registry.find(filenames[0])

        # Get the first image and our understanding
        first_image = filenames[0]

        # Get the directory and first filename and set the template format
        directory, first_image_name = os.path.split(first_image)
        first_image_number = indices[0]

        # Get the template format
        pfx = template.split("#")[0]
        sfx = template.split("#")[-1]
        template_format = "%s%%0%dd%s" % (pfx, template.count("#"), sfx)

        # Set the image range
        array_range = (min(indices) - 1, max(indices))

        # Create the sweep file list
        filenames = SweepFileList(template_format, array_range)

        # Create the sweep object
        sweep = ImageSweep(MultiFileReader(format_class, filenames))

        # Check the sweep is valid
        if check_headers and not sweep.is_valid():
            raise RuntimeError("Invalid sweep of images")

        # Return the sweep
        return sweep

def print_detector_info2(image):
    """
    Print out information on the detector given an image
    """

    format_instance = Registry.find(image)
    instance = format_instance(image)
    # adds parameters (iotbx)
    temp = instance.get_detectorbase()

    print "\nInformation from dxtbx Registry"
    print "================================="
    for key, val in temp.parameters.iteritems():
        print "%20s::%s" % (key, val)