Exemple #1
0
    def start_helper(self, version_token):

        is_file = isinstance(self._image_file,
                             six.string_types) and os.path.isfile(
                                 self._image_file)

        if is_file:
            file_name = self._image_file
        else:
            file_name = "inmem"

        args = [
            file_name,
            version_token,
            "viewer.powder_arcs.show=False",
            "viewer.powder_arcs.code=3n9c",
        ]

        params = cxi_phil.cxi_versioned_extract(args)
        horizons_phil = params.persist.commands

        if is_file:
            image = NpyImage(file_name)
        else:
            print(
                "This is not a file; assume the data are in the defined dictionary format"
            )
            image = NpyImage(file_name, source_data=self._image_file)
        image.readHeader(horizons_phil)
        image.translate_tiles(horizons_phil)
        # necessary to keep the phil parameters for subsequent calls to get_tile_manager()
        image.horizons_phil_cache = copy.deepcopy(horizons_phil)
        self.detectorbase = image
Exemple #2
0
    def start_helper(self, version_token):

        from spotfinder.applications.xfel import cxi_phil
        from iotbx.detectors.npy import NpyImage
        import os, copy

        is_file = isinstance(self._image_file, basestring) and os.path.isfile(
            self._image_file)

        if is_file:
            file_name = self._image_file
        else:
            file_name = "inmem"

        args = [
            file_name,
            version_token,
            "viewer.powder_arcs.show=False",
            "viewer.powder_arcs.code=3n9c",
        ]

        params = cxi_phil.cxi_versioned_extract(args)
        horizons_phil = params.persist.commands

        if is_file:
            I = NpyImage(file_name)
        else:
            print "This is not a file; assume the data are in the defined dictionary format"
            I = NpyImage(file_name, source_data=self._image_file)
        I.readHeader(horizons_phil)
        I.translate_tiles(horizons_phil)
        # necessary to keep the phil parameters for subsequent calls to get_tile_manager()
        I.horizons_phil_cache = copy.deepcopy(horizons_phil)
        self.detectorbase = I
def get_CSPAD_active_areas(image, version_phil):
    from libtbx.phil import parse
    from iotbx.detectors.npy import NpyImage
    from spotfinder.applications.xfel.cxi_phil import cxi_basic_start
    data = pickle.load(open(image, "rb"))
    scope = parse(file_name=version_phil)
    basic_scope = cxi_basic_start()
    new_scope = basic_scope.phil_scope.fetch(source=scope)
    phil = new_scope.extract()
    img = NpyImage("dummy", source_data=data)
    img.readHeader(phil)
    tm = img.get_tile_manager(phil)
    return list(tm.effective_tiling_as_flex_int())
Exemple #4
0
 def tiling_from_image(self):
     if self.tm is not None:
         return self.tm
     labelit_regression = libtbx.env.find_in_repositories(
         relative_path="labelit_regression", test=os.path.isdir)
     if detector_phil is None:
         detector_phil = os.path.join(labelit_regression, "xfel",
                                      "cxi-10.1.phil")
     detector_scope = parse(file_name=detector_phil)
     basic_scope = cxi_basic_start()
     new_scope = basic_scope.phil_scope.fetch(source=detector_scope)
     tiling_phil = new_scope.extract()
     img = NpyImage("dummy", source_data=img_data)
     img.readHeader(tiling_phil)
     self.tm = img.get_tile_manager(phil)
     return self.tm
  def start_helper(self, version_token):

    from spotfinder.applications.xfel import cxi_phil
    from iotbx.detectors.npy import NpyImage
    import os,copy

    is_file = isinstance(self._image_file, basestring) and os.path.isfile(self._image_file)

    if is_file:
      file_name = self._image_file
    else:
      file_name = "inmem"

    args = [file_name,
            version_token,
            "viewer.powder_arcs.show=False",
            "viewer.powder_arcs.code=3n9c",
           ]

    params = cxi_phil.cxi_versioned_extract(args)
    horizons_phil = params.persist.commands

    if is_file:
      I = NpyImage(file_name)
    else:
      print "This is not a file; assume the data are in the defined dictionary format"
      I = NpyImage(file_name, source_data=self._image_file)
    I.readHeader(horizons_phil)
    I.translate_tiles(horizons_phil)
    # necessary to keep the phil parameters for subsequent calls to get_tile_manager()
    I.horizons_phil_cache = copy.deepcopy(horizons_phil)
    self.detectorbase = I
Exemple #6
0
def ImageFactory(filename):
  global parameters
  if type(filename)==type("") and os.path.isfile(filename):
    from dxtbx.format.FormatPYunspecified import FormatPYunspecified

    assert FormatPYunspecified.understand(filename)
    I = FormatPYunspecified(filename).get_detectorbase()

  else:
    print "This is not a file; assume the data are in the defined dictionary format"
    I = NpyImage(filename, source_data=parameters.horizons_phil.indexing.data)
  I.readHeader(parameters.horizons_phil)

  I.translate_tiles(parameters.horizons_phil)

  #from xfel.cxi.display_powder_arcs import apply_gaussian_noise
  #apply_gaussian_noise(I,parameters.horizons_phil)
  if (parameters.horizons_phil.viewer.powder_arcs.show):
    from xfel.cxi.display_powder_arcs import superimpose_powder_arcs
    superimpose_powder_arcs(I,parameters.horizons_phil)
  return I
def ImageFactory(path):
  if os.path.isfile(path):
    I = NpyImage(path)
    I.readHeader()
    return (I)
    if "DISTANCE" in source_data and source_data["DISTANCE"] > 1000:
      # downstream CS-PAD detector station of CXI instrument
      LCLS_detector_address = 'CxiDsd-0|Cspad-0'
  else:
    LCLS_detector_address = source_data["DETECTOR_ADDRESS"]
  timesec = reverse_timestamp( source_data["TIMESTAMP"] )[0]
  version_lookup = detector_format_function(LCLS_detector_address,timesec)
  args = [
          "distl.detector_format_version=%s"%version_lookup,
          "viewer.powder_arcs.show=False",
          "viewer.powder_arcs.code=3n9c",
         ]

  horizons_phil = cxi_phil.cxi_versioned_extract(args).persist.commands

  img = NpyImage(params.file_path, source_data)
  img.readHeader(horizons_phil)
  img.translate_tiles(horizons_phil)
  if params.verbose:
    img.show_header()

  the_tiles = img.get_tile_manager(horizons_phil).effective_tiling_as_flex_int(
        reapply_peripheral_margin=False,encode_inactive_as_zeroes=True)

  if params.beam_x is None:
    params.beam_x = img.beamx / img.pixel_size
  if params.beam_y is None:
    params.beam_y = img.beamy / img.pixel_size
  if params.verbose:
    logger.write("I think the beam center is (%s,%s)\n"%(params.beam_x, params.beam_y))
        evt = fake_evt(data3d)
        beam_center, active_areas = cbcaa(fake_config(), sections)
        data = flex.int(
            CsPadDetector(address, evt, env, sections).astype(numpy.float64))

    img_dict = dpack(active_areas=active_areas,
                     address=address,
                     beam_center_x=beam_center[0] * pixel_size,
                     beam_center_y=beam_center[1] * pixel_size,
                     data=data,
                     distance=params.distance,
                     pixel_size=pixel_size,
                     timestamp=timestamp,
                     wavelength=params.wavelength)

    img = NpyImage("", source_data=img_dict)

    args = [
        "distl.detector_format_version=%s" % params.detector_format_version
    ]
    horizons_phil = cxi_phil.cxi_versioned_extract(args)

    img.readHeader(horizons_phil)
    img.translate_tiles(horizons_phil)
    tm = img.get_tile_manager(horizons_phil)
    effective_active_areas = tm.effective_tiling_as_flex_int()

    if annulus:
        inner = params.distance * math.tan(
            2 * math.sinh(params.wavelength /
                          (2 * params.annulus_inner))) / pixel_size
Exemple #10
0
def ImageFactory(path):
  if os.path.isfile(path):
    I = NpyImage(path)
    I.readHeader()
    return (I)
def run(args, source_data=None):
    from xfel import radial_average
    from scitbx.array_family import flex
    from iotbx.detectors.cspad_detector_formats import reverse_timestamp
    from iotbx.detectors.cspad_detector_formats import detector_format_version as detector_format_function
    from spotfinder.applications.xfel import cxi_phil
    from iotbx.detectors.npy import NpyImage
    import os, sys
    from iotbx.detectors.npy import NpyImage

    user_phil = []
    # TODO: replace this stuff with iotbx.phil.process_command_line_with_files
    # as soon as I can safely modify it
    for arg in args:
        if (not "=" in arg):
            try:
                user_phil.append(libtbx.phil.parse("""file_path=%s""" % arg))
            except ValueError as e:
                raise Sorry("Unrecognized argument '%s'" % arg)
        else:
            try:
                user_phil.append(libtbx.phil.parse(arg))
            except RuntimeError as e:
                raise Sorry("Unrecognized argument '%s' (error: %s)" %
                            (arg, str(e)))
    params = master_phil.fetch(sources=user_phil).extract()
    if params.file_path is None or not os.path.isfile(
            params.file_path) and source_data is None:
        master_phil.show()
        raise Usage(
            "file_path must be defined (either file_path=XXX, or the path alone)."
        )
    assert params.handedness is not None
    assert params.n_bins is not None
    assert params.verbose is not None
    assert params.output_bins is not None

    if source_data is None:
        from libtbx import easy_pickle
        source_data = easy_pickle.load(params.file_path)

    if params.output_file is None:
        logger = sys.stdout
    else:
        logger = open(params.output_file, 'w')
        logger.write("%s " % params.output_file)

    if not "DETECTOR_ADDRESS" in source_data:
        # legacy format; try to guess the address
        LCLS_detector_address = 'CxiDs1-0|Cspad-0'
        if "DISTANCE" in source_data and source_data["DISTANCE"] > 1000:
            # downstream CS-PAD detector station of CXI instrument
            LCLS_detector_address = 'CxiDsd-0|Cspad-0'
    else:
        LCLS_detector_address = source_data["DETECTOR_ADDRESS"]
    timesec = reverse_timestamp(source_data["TIMESTAMP"])[0]
    version_lookup = detector_format_function(LCLS_detector_address, timesec)
    args = [
        "distl.detector_format_version=%s" % version_lookup,
        "viewer.powder_arcs.show=False",
        "viewer.powder_arcs.code=3n9c",
    ]

    horizons_phil = cxi_phil.cxi_versioned_extract(args).persist.commands

    img = NpyImage(params.file_path, source_data)
    img.readHeader(horizons_phil)
    img.translate_tiles(horizons_phil)
    if params.verbose:
        img.show_header()

    the_tiles = img.get_tile_manager(
        horizons_phil).effective_tiling_as_flex_int(
            reapply_peripheral_margin=False, encode_inactive_as_zeroes=True)

    if params.beam_x is None:
        params.beam_x = img.beamx / img.pixel_size
    if params.beam_y is None:
        params.beam_y = img.beamy / img.pixel_size
    if params.verbose:
        logger.write("I think the beam center is (%s,%s)\n" %
                     (params.beam_x, params.beam_y))

    bc = (int(params.beam_x), int(params.beam_y))

    extent = int(
        math.ceil(
            max(distance((0, 0), bc), distance((img.size1, 0), bc),
                distance((0, img.size2), bc),
                distance((img.size1, img.size2), bc))))

    if params.n_bins < extent:
        params.n_bins = extent

    extent_in_mm = extent * img.pixel_size
    extent_two_theta = math.atan(extent_in_mm / img.distance) * 180 / math.pi

    sums = flex.double(params.n_bins) * 0
    sums_sq = flex.double(params.n_bins) * 0
    counts = flex.int(params.n_bins) * 0
    data = img.get_raw_data()

    if hasattr(data, "as_double"):
        data = data.as_double()

    logger.write("Average intensity: %9.3f\n" % flex.mean(data))

    if params.verbose:
        logger.write("Generating average...tile:")
        logger.flush()
    for tile in xrange(len(the_tiles) // 4):
        if params.verbose:
            logger.write(" %d" % tile)
            logger.flush()

        x1, y1, x2, y2 = get_tile_coords(the_tiles, tile)

        radial_average(data, bc, sums, sums_sq, counts, img.pixel_size,
                       img.distance, (x1, y1), (x2, y2))

    if params.verbose:
        logger.write(" Finishing...\n")

    # average, avoiding division by zero
    results = sums.set_selected(counts <= 0, 0)
    results /= counts.set_selected(counts <= 0, 1).as_double()

    # calculte standard devations
    std_devs = [
        math.sqrt((sums_sq[i] - sums[i] * results[i]) /
                  counts[i]) if counts[i] > 0 else 0 for i in xrange(len(sums))
    ]

    xvals = flex.double(len(results))
    max_twotheta = float('-inf')
    max_result = float('-inf')

    for i in xrange(len(results)):
        twotheta = i * extent_two_theta / params.n_bins
        xvals[i] = twotheta

        if params.output_bins and "%.3f" % results[i] != "nan":
            #logger.write("%9.3f %9.3f\n"%     (twotheta,results[i]))        #.xy  format for Rex.cell.
            logger.write(
                "%9.3f %9.3f %9.3f\n" %
                (twotheta, results[i], std_devs[i]))  #.xye format for GSASII
        #logger.write("%.3f %.3f %.3f\n"%(twotheta,results[i],ds[i]))  # include calculated d spacings
        if results[i] > max_result:
            max_twotheta = twotheta
            max_result = results[i]

    logger.write(
        "Maximum 2theta for %s, TS %s: %f, value: %f\n" %
        (params.file_path, source_data['TIMESTAMP'], max_twotheta, max_result))

    if params.verbose:
        from pylab import scatter, show, xlabel, ylabel, ylim
        scatter(xvals, results)
        xlabel("2 theta")
        ylabel("Avg ADUs")
        if params.plot_y_max is not None:
            ylim(0, params.plot_y_max)
        show()

    return xvals, results
    evt = fake_evt(data3d)
    beam_center, active_areas = cbcaa(fake_config(),sections)
    data = flex.int(CsPadDetector(address, evt, env, sections).astype(numpy.float64))

  img_dict = dpack(
          active_areas=active_areas,
          address=address,
          beam_center_x=beam_center[0]*pixel_size,
          beam_center_y=beam_center[1]*pixel_size,
          data=data,
          distance=params.distance,
          pixel_size=pixel_size,
          timestamp=timestamp,
          wavelength=params.wavelength)

  img = NpyImage("", source_data=img_dict)

  args = ["distl.detector_format_version=%s"%params.detector_format_version]
  horizons_phil = cxi_phil.cxi_versioned_extract(args)

  img.readHeader(horizons_phil)
  img.translate_tiles(horizons_phil)
  tm = img.get_tile_manager(horizons_phil)
  effective_active_areas = tm.effective_tiling_as_flex_int()

  if annulus:
    inner = params.distance * math.tan(2*math.sinh(params.wavelength/(2*params.annulus_inner)))/pixel_size
    outer = params.distance * math.tan(2*math.sinh(params.wavelength/(2*params.annulus_outer)))/pixel_size
    print "Pixel inner:", inner
    print "Pixel outer:", outer
  if params.resolution is not None:
def ImageFactory(filename):
    if os.path.isfile(filename):
        I = NpyImage(filename)
        I.readHeader()
        return I
Exemple #14
0
        if "DISTANCE" in source_data and source_data["DISTANCE"] > 1000:
            # downstream CS-PAD detector station of CXI instrument
            LCLS_detector_address = 'CxiDsd-0|Cspad-0'
    else:
        LCLS_detector_address = source_data["DETECTOR_ADDRESS"]
    timesec = reverse_timestamp(source_data["TIMESTAMP"])[0]
    version_lookup = detector_format_function(LCLS_detector_address, timesec)
    args = [
        "distl.detector_format_version=%s" % version_lookup,
        "viewer.powder_arcs.show=False",
        "viewer.powder_arcs.code=3n9c",
    ]

    horizons_phil = cxi_phil.cxi_versioned_extract(args).persist.commands

    img = NpyImage(params.file_path, source_data)
    img.readHeader(horizons_phil)
    img.translate_tiles(horizons_phil)
    if params.verbose:
        img.show_header()

    the_tiles = img.get_tile_manager(
        horizons_phil).effective_tiling_as_flex_int(
            reapply_peripheral_margin=False, encode_inactive_as_zeroes=True)

    if params.beam_x is None:
        params.beam_x = img.beamx / img.pixel_size
    if params.beam_y is None:
        params.beam_y = img.beamy / img.pixel_size
    if params.verbose:
        logger.write("I think the beam center is (%s,%s)\n" %
def ImageFactory(filename):
  if os.path.isfile(filename):
    I = NpyImage(filename)
    I.readHeader()
    return I