def __init__(self,arg_module,phil_params,verbose=True): # support the many-image-in-one-H5-container paradigm if phil_params.distl.range is not None: # range parameter only intended for H5 files assert len(self.filenames())==1 # can be only one H5 master file if there is a range of image indices if len(phil_params.distl.range)==1: self.unrolled_range = phil_params.distl.range else: self.unrolled_range = range(phil_params.distl.range[0],phil_params.distl.range[1]) self.filenames.FN = [self.filenames.FN[0]]*len(self.unrolled_range) self.frames = self.h5_frames self.imageindex = self.h5_imageindex self.imagepath = self.h5_imagepath import copy for indx,name in enumerate(self.filenames()): if indx==0: A = ImageFactory(name,optional_index=self.unrolled_range[indx]) self.site_modifications(A,self.filenames.FN[indx]) self.images.append(A) else: Acopy = copy.deepcopy(A) Acopy.img_number = self.unrolled_range[indx] self.images.append(Acopy) else: # range is not present; normal behavior for non-H5 images for indx,name in enumerate(self.filenames()): A = ImageFactory(name) self.site_modifications(A,self.filenames.FN[indx]) self.images.append(A)
def set_image(self, file_name_or_data, metrology_matrices=None, get_raw_data=None): self.reset_the_cache() if file_name_or_data is None: self.raw_image = None return if type(file_name_or_data) is type(""): from iotbx.detectors import ImageFactory self.raw_image = ImageFactory(file_name_or_data) self.raw_image.read() else: try: self.raw_image = file_name_or_data._raw except AttributeError: self.raw_image = file_name_or_data # print "SETTING NEW IMAGE",self.raw_image.filename # XXX Since there doesn't seem to be a good way to refresh the # image (yet), the metrology has to be applied here, and not # in frame.py. detector = self.raw_image.get_detector() if len(detector) > 1 and metrology_matrices is not None: self.raw_image.apply_metrology_from_matrices(metrology_matrices) if get_raw_data is not None: self.raw_image.set_raw_data(get_raw_data(self.raw_image)) raw_data = self.raw_image.get_raw_data() if not isinstance(raw_data, tuple): raw_data = (raw_data, ) if len(detector) > 1: self.flex_image = _get_flex_image_multipanel( brightness=self.current_brightness / 100, panels=detector, show_untrusted=self.show_untrusted, raw_data=raw_data, beam=self.raw_image.get_beam(), color_scheme=self.current_color_scheme, ) else: self.flex_image = _get_flex_image( brightness=self.current_brightness / 100, data=raw_data[0], saturation=self.raw_image.get_detector() [0].get_trusted_range()[1], vendortype=self.raw_image.get_vendortype(), show_untrusted=self.show_untrusted, color_scheme=self.current_color_scheme, ) if self.zoom_level >= 0: self.flex_image.adjust(color_scheme=self.current_color_scheme)
def __init__ (self, file_name) : screen_params.__init__(self) # XXX major hack - Boost.Python doesn't really deal with Unicode strings if isinstance(file_name, unicode) : file_name = str(file_name) if isinstance(file_name, str) or isinstance(file_name, dict): self.file_name = file_name from iotbx.detectors import ImageFactory, ImageException try : img = ImageFactory(file_name) except ImageException, e : raise Sorry(str(e)) img.read()
def run(img_in): im = ImageFactory(img_in) im.read() print dir(im) print im.size2, im.size1 data = numpy.array(im.linearintdata, dtype=numpy.uint16).reshape(im.size2, im.size1) print data, data.dtype prefix = os.path.basename(img_in) of = h5py.File("%s_byteoffset.h5"%prefix, "w") grp = of.create_group("data") dset = grp.create_dataset(prefix, data.shape, dtype=data.dtype, compression=CBF_BYTE_OFFSET) dset[...] = data of.close()
def read_cmos_image(f, read_data=True, fast=True): h = {} data = None get_after = lambda l: l[l.index("=") + 1:].rstrip(";\n ") if fast: for l in open(f): if "}" in l: break if l.startswith("SIZE1="): h["size1"] = int(get_after(l)) elif l.startswith("SIZE2="): h["size2"] = int(get_after(l)) elif l.startswith("TYPE="): assert "unsigned_short" in l elif l.startswith("PIXEL_SIZE="): h["pixel_size"] = float(get_after(l)) elif l.startswith("DISTANCE="): h["distance"] = float(get_after(l)) elif l.startswith("WAVELENGTH="): h["wavelength"] = float(get_after(l)) elif l.startswith("BEAM_CENTER_X="): h["beamx"] = float(get_after(l)) elif l.startswith("BEAM_CENTER_Y="): h["beamy"] = float(get_after(l)) h["orgx"], h["orgy"] = h["beamx"] / h["pixel_size"], h["beamy"] / h[ "pixel_size"] if read_data: ifs = open(f, "rb") ifs.seek(-h["size1"] * h["size2"] * 2, 2) data = numpy.fromfile(ifs, dtype=numpy.uint16).reshape( h["size2"], h["size1"]) else: from iotbx.detectors import ImageFactory im = ImageFactory(f) h["orgx"], h[ "orgy"] = im.beamx / im.pixel_size, im.beamy / im.pixel_size h["wavelength"] = im.wavelength h["distance"] = im.distance if read_data: im.read() data = numpy.array(im.linearintdata, dtype=numpy.uint16).reshape(im.size2, im.size1) return h, data
def get_detector_file(image): """ Returns the RAPD detector file given an image file """ # print "get_detector_file %s" % image try: i = ImageFactory(image) # print i.vendortype # print i.parameters["DETECTOR_SN"] except (IOError, AttributeError, RuntimeError): print error return False # print ">>>%s<<<" % i.vendortype # print ">>>%s<<<" % i.parameters["DETECTOR_SN"] v_type = i.vendortype.strip() sn = str(i.parameters["DETECTOR_SN"]).strip() # pprint(detector_list.DETECTORS) if (v_type, sn) in detector_list.DETECTORS: # print "%s: %s %s %s" % (image, detector_list.DETECTORS[(v_type, sn)], v_type, sn) return detector_list.DETECTORS[(v_type, sn)] else: return False
def print_detector_info(image): """ Print out information on the detector given an image """ image_basename = os.path.basename(image) try: i = ImageFactory(image) except IOError as e: if "no format support found for" in e.message: print "No format support for %s" % image_basename return False else: print e return False except AttributeError as e: if "object has no attribute 'detectorbase'" in e.message: print "No format support for %s" % image_basename return False else: print text.red + e.message + text.stop return False print "\nInformation from iotbx ImageFactory" print "=====================================" print "%20s::%s" % ("image", image_basename) print "%20s::%s" % ("vendortype", str(i.vendortype)) # print "%20s" % "Parameters" for key, val in i.parameters.iteritems(): print "%20s::%s" % (key, val)
def __init__(self,arg_module,verbose=True): self.verbose = verbose self.filenames = file_names(arg_module) self.images = [] for indx,name in enumerate(self.filenames()): A = ImageFactory(name) self.images.append(A)
def run(img_in): im = ImageFactory(img_in) im.read() print dir(im) print im.size2, im.size1 data = numpy.array(im.linearintdata, dtype=numpy.uint16).reshape(im.size2, im.size1) print data, data.dtype prefix = os.path.basename(img_in) of = h5py.File("%s_byteoffset.h5" % prefix, "w") grp = of.create_group("data") dset = grp.create_dataset(prefix, data.shape, dtype=data.dtype, compression=CBF_BYTE_OFFSET) dset[...] = data of.close()
def main(filenames, map_file, npoints=192, max_resolution=6, reverse_phi=False): rec_range = 1 / max_resolution image = ImageFactory(filenames[0]) panel = image.get_detector()[0] beam = image.get_beam() s0 = beam.get_s0() pixel_size = panel.get_pixel_size() xlim, ylim = image.get_raw_data().all() xy = recviewer.get_target_pixels(panel, s0, xlim, ylim, max_resolution) s1 = panel.get_lab_coord(xy * pixel_size[0]) # FIXME: assumed square pixel s1 = s1 / s1.norms() * (1 / beam.get_wavelength()) # / is not supported... S = s1 - s0 grid = flex.double(flex.grid(npoints, npoints, npoints), 0) cnts = flex.int(flex.grid(npoints, npoints, npoints), 0) for filename in filenames: print "Processing image", filename try: fill_voxels(ImageFactory(filename), grid, cnts, S, xy, reverse_phi, rec_range) except: print " Failed to process. Skipped this." recviewer.normalize_voxels(grid, cnts) uc = uctbx.unit_cell((npoints, npoints, npoints, 90, 90, 90)) ccp4_map.write_ccp4_map(map_file, uc, sgtbx.space_group("P1"), (0, 0, 0), grid.all(), grid, flex.std_string(["cctbx.miller.fft_map"])) return from scitbx import fftpack fft = fftpack.complex_to_complex_3d(grid.all()) grid_complex = flex.complex_double( reals=flex.pow2(grid), imags=flex.double(grid.size(), 0)) grid_transformed = flex.abs(fft.backward(grid_complex)) print flex.max(grid_transformed), flex.min(grid_transformed), grid_transformed.all() ccp4_map.write_ccp4_map(map_file, uc, sgtbx.space_group("P1"), (0, 0, 0), grid.all(), grid_transformed, flex.std_string(["cctbx.miller.fft_map"]))
def read_cmos_image(f, read_data=True, fast=True): h = {} data = None get_after = lambda l: l[l.index("=")+1:].rstrip(";\n ") if fast: for l in open(f): if "}" in l: break if l.startswith("SIZE1="): h["size1"] = int(get_after(l)) elif l.startswith("SIZE2="): h["size2"]= int(get_after(l)) elif l.startswith("TYPE="): assert "unsigned_short" in l elif l.startswith("PIXEL_SIZE="): h["pixel_size"]= float(get_after(l)) elif l.startswith("DISTANCE="): h["distance"]= float(get_after(l)) elif l.startswith("WAVELENGTH="): h["wavelength"]= float(get_after(l)) elif l.startswith("BEAM_CENTER_X="): h["beamx"]= float(get_after(l)) elif l.startswith("BEAM_CENTER_Y="): h["beamy"]= float(get_after(l)) h["orgx"], h["orgy"] = h["beamx"]/h["pixel_size"], h["beamy"]/h["pixel_size"] if read_data: ifs = open(f, "rb") ifs.seek(-h["size1"]*h["size2"]*2, 2) data = numpy.fromfile(ifs, dtype=numpy.uint16).reshape(h["size2"],h["size1"]) else: from iotbx.detectors import ImageFactory im = ImageFactory(f) h["orgx"], h["orgy"] = im.beamx/im.pixel_size, im.beamy/im.pixel_size h["wavelength"] = im.wavelength h["distance"] = im.distance if read_data: im.read() data = numpy.array(im.linearintdata, dtype=numpy.uint16).reshape(im.size2, im.size1) return h, data
def __init__(self, arg_module, phil_params, verbose=True): self.verbose = verbose self.filenames = file_names(arg_module) self.phil_params = phil_params self.images = [] for indx, name in enumerate(self.filenames()): A = ImageFactory(name) self.site_modifications(A, self.filenames.FN[indx]) self.images.append(A) self.acceptable_use_tests_basic()
def set_image(self, file_name_or_data, metrology_matrices=None, get_raw_data=None): self.reset_the_cache() if file_name_or_data is None: self.raw_image = None return if type(file_name_or_data) is type(""): from iotbx.detectors import ImageFactory self.raw_image = ImageFactory(file_name_or_data) self.raw_image.read() else: try: self.raw_image = file_name_or_data._raw except AttributeError: self.raw_image = file_name_or_data #print "SETTING NEW IMAGE",self.raw_image.filename # XXX Since there doesn't seem to be a good way to refresh the # image (yet), the metrology has to be applied here, and not # in frame.py. detector = self.raw_image.get_detector() if len(detector) > 1 and metrology_matrices is not None: self.raw_image.apply_metrology_from_matrices(metrology_matrices) if get_raw_data is not None: self.raw_image.set_raw_data(get_raw_data(self.raw_image)) raw_data = self.raw_image.get_raw_data() if not isinstance(raw_data, tuple): raw_data = (raw_data,) if len(detector) > 1: self.flex_image = _get_flex_image_multipanel( brightness=self.current_brightness / 100, panels=detector, show_untrusted=self.show_untrusted, raw_data=raw_data) else: self.flex_image = _get_flex_image( brightness=self.current_brightness / 100, data=raw_data[0], saturation=self.raw_image.get_detector()[0].get_trusted_range()[1], vendortype=self.raw_image.__class__.__name__, show_untrusted=self.show_untrusted ) self.flex_image.adjust(color_scheme=self.current_color_scheme)
def main(filenames, map_file, npoints=192, max_resolution=6, reverse_phi=False): rec_range = 1 / max_resolution image = ImageFactory(filenames[0]) panel = image.get_detector()[0] beam = image.get_beam() s0 = beam.get_s0() pixel_size = panel.get_pixel_size() xlim, ylim = image.get_raw_data().all() xy = recviewer.get_target_pixels(panel, s0, xlim, ylim, max_resolution) s1 = panel.get_lab_coord(xy * pixel_size[0]) # FIXME: assumed square pixel s1 = s1 / s1.norms() * (1 / beam.get_wavelength()) # / is not supported... S = s1 - s0 grid = flex.double(flex.grid(npoints, npoints, npoints), 0) cnts = flex.int(flex.grid(npoints, npoints, npoints), 0) for filename in filenames: print "Processing image", filename try: fill_voxels(ImageFactory(filename), grid, cnts, S, xy, reverse_phi, rec_range) except: print " Failed to process. Skipped this." recviewer.normalize_voxels(grid, cnts) uc = uctbx.unit_cell((npoints, npoints, npoints, 90, 90, 90)) ccp4_map.write_ccp4_map(map_file, uc, sgtbx.space_group("P1"), (0, 0, 0), grid.all(), grid, flex.std_string(["cctbx.miller.fft_map"])) return from scitbx import fftpack fft = fftpack.complex_to_complex_3d(grid.all()) grid_complex = flex.complex_double(reals=flex.pow2(grid), imags=flex.double(grid.size(), 0)) grid_transformed = flex.abs(fft.backward(grid_complex)) print flex.max(grid_transformed), flex.min( grid_transformed), grid_transformed.all() ccp4_map.write_ccp4_map(map_file, uc, sgtbx.space_group("P1"), (0, 0, 0), grid.all(), grid_transformed, flex.std_string(["cctbx.miller.fft_map"]))
def __init__(self, file_name): screen_params.__init__(self) # XXX major hack - Boost.Python doesn't really deal with Unicode strings if isinstance(file_name, unicode): file_name = str(file_name) if isinstance(file_name, str) or isinstance(file_name, dict): self.file_name = file_name from iotbx.detectors import ImageFactory, ImageException try: img = ImageFactory(file_name) except ImageException as e: raise Sorry(str(e)) img.read() else: img = file_name # assume it's already been read self._raw = img try: img.show_header() except Exception: pass # intentional detector = self._raw.get_detector() if len(detector) == 1: # Image size only makes sense for monolithic detectors. image_size = detector[0].get_image_size() self.set_image_size(w=image_size[0], h=image_size[1]) pixel_size = detector[0].get_pixel_size() for panel in detector: pstest = panel.get_pixel_size() assert pixel_size[0] == pixel_size[1] == pstest[0] == pstest[1] self.set_detector_resolution(pixel_size[0]) try: from spotfinder.command_line.signal_strength import master_params params = master_params.extract() self._raw.initialize_viewer_properties(params) except Exception: pass # intentional self._beam_center = None self._integration = None self._spots = None self._color_scheme = None
class _Tiles(object): # maximum number of tiles held in each level cache MaxTileList = 512 def __init__(self, filename): (self.tile_size_x, self.tile_size_y) = (256,256) self.levels = [-3,-2,-1,0,1,2,3,4,5] # set min and max tile levels self.min_level = -3 self.max_level = 5 self.extent = (-180.0, 180., -166.66 , 166.66) #longitude & latitude limits self.set_image(filename) self.current_brightness = 1.0 self.current_color_scheme = 0 self.user_requests_antialiasing = False self.show_untrusted = False def set_image(self, file_name_or_data, metrology_matrices=None, get_raw_data=None): self.reset_the_cache() if file_name_or_data is None: self.raw_image = None return if type(file_name_or_data) is type(""): from iotbx.detectors import ImageFactory self.raw_image = ImageFactory(file_name_or_data) self.raw_image.read() else: try: self.raw_image = file_name_or_data._raw except AttributeError: self.raw_image = file_name_or_data #print "SETTING NEW IMAGE",self.raw_image.filename # XXX Since there doesn't seem to be a good way to refresh the # image (yet), the metrology has to be applied here, and not # in frame.py. detector = self.raw_image.get_detector() if len(detector) > 1 and metrology_matrices is not None: self.raw_image.apply_metrology_from_matrices(metrology_matrices) if get_raw_data is not None: self.raw_image.set_raw_data(get_raw_data(self.raw_image)) raw_data = self.raw_image.get_raw_data() if not isinstance(raw_data, tuple): raw_data = (raw_data,) if len(detector) > 1: self.flex_image = _get_flex_image_multipanel( brightness=self.current_brightness / 100, panels=detector, show_untrusted=self.show_untrusted, raw_data=raw_data) else: self.flex_image = _get_flex_image( brightness=self.current_brightness / 100, data=raw_data[0], saturation=self.raw_image.get_detector()[0].get_trusted_range()[1], vendortype=self.raw_image.__class__.__name__, show_untrusted=self.show_untrusted ) self.flex_image.adjust(color_scheme=self.current_color_scheme) def set_image_data(self, raw_image_data): self.reset_the_cache() # XXX Since there doesn't seem to be a good way to refresh the # image (yet), the metrology has to be applied here, and not # in frame.py. detector = self.raw_image.get_detector() self.raw_image.set_raw_data(raw_image_data) if len(detector) == 1 and len(raw_image_data) == 1: raw_image_data = raw_image_data[0] if len(detector) > 1: self.flex_image = _get_flex_image_multipanel( brightness=self.current_brightness / 100, panels=detector, raw_data=raw_image_data) else: self.flex_image = _get_flex_image( brightness=self.current_brightness / 100, data=raw_image_data, saturation=self.raw_image.get_detector()[0].get_trusted_range()[1], vendortype=self.raw_image.__class__.__name__, show_untrusted=self.show_untrusted ) self.flex_image.adjust(color_scheme=self.current_color_scheme) def update_brightness(self,b,color_scheme=0): raw_data = self.raw_image.get_raw_data() if not isinstance(raw_data, tuple): raw_data = (raw_data,) if len(self.raw_image.get_detector()) > 1: # XXX Special-case read of new-style images until multitile # images are fully supported in dxtbx. self.flex_image = _get_flex_image_multipanel( brightness=b / 100, panels=self.raw_image.get_detector(), show_untrusted=self.show_untrusted, raw_data=raw_data) else: self.flex_image = _get_flex_image( brightness=b / 100, data=raw_data[0], saturation=self.raw_image.get_detector()[0].get_trusted_range()[1], vendortype=self.raw_image.__class__.__name__, show_untrusted=self.show_untrusted ) self.update_color_scheme(color_scheme) self.current_brightness = b def update_color_scheme(self,color_scheme=0): self.flex_image.adjust(color_scheme) self.reset_the_cache() self.UseLevel(self.zoom_level) self.current_color_scheme = color_scheme def reset_the_cache(self): # setup the tile caches and Least Recently Used lists self.cache = {} self.lru = {} for l in self.levels: self.cache[l] = {} self.lru[l] = [] def flex_image_get_tile(self,x,y): # The supports_rotated_tiles_antialiasing_recommended flag in # the C++ FlexImage class indicates whether the underlying image # instance supports tilted readouts. Anti-aliasing only makes # sense if it does. if self.raw_image is not None and \ self.zoom_level >=2 and \ self.flex_image.supports_rotated_tiles_antialiasing_recommended and \ self.user_requests_antialiasing: # much more computationally intensive to prepare nice-looking pictures of tilted readout self.flex_image.setZoom(self.zoom_level+1) fraction = 512./self.flex_image.size1()/(2**(self.zoom_level+1)) self.flex_image.setWindowCart( y, x, fraction ) self.flex_image.prep_string() w,h = self.flex_image.ex_size2(), self.flex_image.ex_size1() assert w==512 assert h==512 wx_image = wx.EmptyImage(w/2,h/2) import Image I = Image.fromstring("RGB",(512,512),self.flex_image.export_string) J = I.resize((256,256),Image.ANTIALIAS) wx_image.SetData(J.tostring()) return wx_image.ConvertToBitmap() elif self.raw_image is not None: self.flex_image.setZoom(self.zoom_level) fraction = 256./self.flex_image.size1()/(2**self.zoom_level) self.flex_image.setWindowCart( y, x, fraction ) self.flex_image.prep_string() w,h = self.flex_image.ex_size2(), self.flex_image.ex_size1() assert w==256 assert h==256 wx_image = wx.EmptyImage(w,h) wx_image.SetData(self.flex_image.export_string) return wx_image.ConvertToBitmap() else: wx_image = wx.EmptyImage(256,256) return wx_image.ConvertToBitmap() def get_binning(self): if self.zoom_level>=0: return 1. return 2.**-self.zoom_level def UseLevel(self, n): """Prepare to serve tiles from the required level. n The required level Returns a tuple (map_width, map_height, ppd_x, ppd_y) if succesful, else None. The width/height values are pixels. The ppd_? values are pixels-per-degree values for X and Y direction. """ # try to get cache for this level, no cache means no level #print "IN USE LEVEL",n try: self.tile_cache = self.cache[n] self.tile_list = self.lru[n] except KeyError: return None self.zoom_level = n if self.raw_image is None: #dummy values if there is no image self.center_x_lon = self.center_y_lat = 500. return (1024,1024,1.,1.) self.num_tiles_x = int(math.ceil((self.flex_image.size1()*(2**self.zoom_level))/256.)) self.num_tiles_y = int(math.ceil((self.flex_image.size2()*(2**self.zoom_level))/256.)) self.ppd_x = 2.**self.zoom_level self.ppd_y = 2.**self.zoom_level #print "USELEVEL %d # tiles: %d %d"%(n,self.num_tiles_x,self.num_tiles_y) #print "USELEVEL %d returning"%n,(self.tile_size_x * self.num_tiles_x, # self.tile_size_y * self.num_tiles_y, # self.ppd_x, self.ppd_y) # The longitude & latitude coordinates at the image center: self.center_x_lon = self.extent[0] + (1./self.ppd_x) * (0 + self.flex_image.size2() * (2**self.zoom_level) / 2. ) self.center_y_lat = self.extent[3] - (1./self.ppd_y) * (0 + self.flex_image.size1() * (2**self.zoom_level) / 2. ) # The 2+num_tiles is just a trick to get PySlip to think the map is # slightly larger, allowing zoom level -3 to be properly framed: # ....for larger display sizes it is necessary to increase this... # ....can tile_generator get the display size & figure it out? return (self.tile_size_x * (2+self.num_tiles_x), self.tile_size_y * (2+self.num_tiles_y), self.ppd_x, self.ppd_y) def get_initial_instrument_centering_within_picture_as_lon_lat(self): import sys detector = self.raw_image.get_detector() if sys.platform.lower().find("linux") >= 0: if len(detector) > 1: return 0.,0. else: return self.center_x_lon-self.extent[0], self.center_y_lat-self.extent[3] else: if len(detector) > 1: return self.extent[0], self.extent[3] else: return self.center_x_lon, self.center_y_lat def GetTile(self, x, y): #from libtbx.development.timers import Timer #T = Timer("get tile") """Get bitmap for tile at tile coords (x, y). x X coord of tile required (tile coordinates) y Y coord of tile required (tile coordinates) Returns bitmap object containing the tile image. Tile coordinates are measured from map top-left. """ try: # if tile in cache, return it from there pic = self.tile_cache[(x, y)] index = self.tile_list.index((x, y)) del self.tile_list[index] except KeyError: pic = self.flex_image_get_tile(x,y) self.tile_cache[(x, y)] = pic self.tile_list.insert(0, (x, y)) if len(self.tile_cache)>=self.MaxTileList: del self.tile_cache[self.tile_list[-1]] del self.tile_list[-1] return pic def get_flex_pixel_coordinates(self, lon, lat): fast_picture_coord_pixel_scale, slow_picture_coord_pixel_scale = \ self.lon_lat_to_picture_fast_slow(lon,lat) if self.flex_image.supports_rotated_tiles_antialiasing_recommended: # for generic_flex_image tilted = self.flex_image.picture_to_readout( slow_picture_coord_pixel_scale,fast_picture_coord_pixel_scale) return tilted else: # standard flex_image return slow_picture_coord_pixel_scale,fast_picture_coord_pixel_scale def lon_lat_to_picture_fast_slow(self,longitude,latitude): # input latitude and longitude in degrees (conceptually) # output fast and slow picture coordinates in units of detector pixels # slow is pointing down (x). fast is pointing right (y). detector = self.raw_image.get_detector() if len(detector) == 1: (size2, size1) = detector[0].get_image_size() else: # XXX Special-case until multitile detectors fully supported. (size1, size2) = (self.flex_image.size1(), self.flex_image.size2()) return \ (size2/2.) - (self.center_x_lon - longitude), \ (size1/2.) - (latitude - self.center_y_lat) def picture_fast_slow_to_lon_lat(self,pic_fast_pixel,pic_slow_pixel): # inverse of the preceding function detector = self.raw_image.get_detector() if detector.num_panels() == 1: (size1, size2) = detector.get_image_size() else: # XXX Special-case until multitile detectors fully supported. (size1, size2) = (self.flex_image.size1(), self.flex_image.size2()) return \ (size2/2.) - self.center_x_lon - pic_fast_pixel, \ (size1/2.) + self.center_y_lat - pic_slow_pixel def picture_fast_slow_to_map_relative(self,pic_fast_pixel,pic_slow_pixel): #return up/down, left/right map relative coords for pyslip layers return pic_fast_pixel+self.extent[0],-pic_slow_pixel+self.extent[3] def map_relative_to_picture_fast_slow(self, map_rel_vert, map_rel_horiz): # return fast, slow picture coords return map_rel_vert-self.extent[0],-map_rel_horiz+self.extent[3] def vec_picture_fast_slow_to_map_relative(self,vector): value = [] for vec in vector: value.append(self.picture_fast_slow_to_map_relative(vec[0],vec[1])) return value def get_spotfinder_data(self, params): pointdata = [] test_pattern = False if test_pattern is True and self.raw_image.__class__.__name__.find("CSPadDetector") >= 0: key_count = -1 for key, asic in self.raw_image._tiles.iteritems(): key_count += 1 focus = asic.focus() for slow in xrange(0,focus[0],20): for fast in xrange(0,focus[1],20): slowpic,fastpic = self.flex_image.tile_readout_to_picture(key_count,slow,fast) mr1,mr2 = self.picture_fast_slow_to_map_relative(fastpic,slowpic) pointdata.append((mr1,mr2,{"data":key})) elif (self.raw_image.__class__.__name__.find("CSPadDetector") >= 0): from cxi_xdr_xes.cftbx.spotfinder.speckfinder import spotfind_readout key_count = -1 for key, asic in self.raw_image._tiles.iteritems(): key_count += 1 indexing = spotfind_readout( readout=asic, peripheral_margin=params.spotfinder.peripheral_margin) for spot in indexing: slow = int(round(spot[0])) fast = int(round(spot[1])) slowpic,fastpic = self.flex_image.tile_readout_to_picture(key_count,slow,fast) mr1,mr2 = self.picture_fast_slow_to_map_relative(fastpic,slowpic) pointdata.append((mr1,mr2,{"data":key})) else: from spotfinder.command_line.signal_strength import master_params working_params = master_params.fetch(sources = []) #placeholder for runtime mods working_params.show(expert_level=1) distl_params = working_params.extract() spotfinder,frameno = self.raw_image.get_spotfinder(distl_params) spots = spotfinder.images[frameno]["spots_total"] for spot in spots: mr = self.picture_fast_slow_to_map_relative( spot.max_pxl_y() + 0.5, spot.max_pxl_x() + 0.5) # spot.ctr_mass_y() + 0.5, spot.ctr_mass_x() + 0.5) pointdata.append(mr) return pointdata def get_effective_tiling_data(self, params): box_data = [] text_data = [] if hasattr(self.raw_image, 'get_tile_manager'): IT = self.raw_image.get_tile_manager(params).effective_tiling_as_flex_int() for i in xrange(len(IT) // 4): tile = IT[4*i:4*i+4] attributes = {'color': '#0000FFA0', 'width': 1, 'closed': False} box_data.append( ((self.picture_fast_slow_to_map_relative(tile[1], tile[0]), self.picture_fast_slow_to_map_relative(tile[1], tile[2])), attributes)) box_data.append( ((self.picture_fast_slow_to_map_relative(tile[1], tile[0]), self.picture_fast_slow_to_map_relative(tile[3], tile[0])), attributes)) box_data.append( ((self.picture_fast_slow_to_map_relative(tile[1], tile[2]), self.picture_fast_slow_to_map_relative(tile[3], tile[2])), attributes)) box_data.append( ((self.picture_fast_slow_to_map_relative(tile[3], tile[0]), self.picture_fast_slow_to_map_relative(tile[3], tile[2])), attributes)) txt_x, txt_y = self.picture_fast_slow_to_map_relative( (tile[1]+tile[3])//2, (tile[0]+tile[2])//2) text_data.append((txt_x, txt_y, "%i" %i)) return box_data, text_data def get_resolution (self, x, y, readout=None) : """ Determine the resolution of a pixel. Arguments are in image pixel coordinates (starting from 1,1). """ d_min = None detector = self.raw_image.get_detector() beam = self.raw_image.get_beam() if detector is None or beam is None: return None beam = beam.get_s0() if len(detector) > 1: if readout is None: return None panel = detector[readout] else: panel = detector[0] if abs(panel.get_distance()) > 0: return panel.get_resolution_at_pixel(beam, (x, y)) else: return None def get_detector_distance (self) : detector = self.raw_image.get_detector() if len(detector) == 1: dist = abs(detector[0].get_distance()) else: # XXX Special-case until multitile detectors fully # supported. dist = self.raw_image.distance twotheta = self.get_detector_2theta() if (twotheta == 0.0) : return dist else : return dist / math.cos(twotheta) def get_detector_2theta (self) : from scitbx.matrix import col detector = self.raw_image.get_detector() if len(detector) == 1: n = col(detector[0].get_normal()) s0 = col(self.raw_image.get_beam().get_unit_s0()) two_theta = s0.angle(n, deg=False) else: # XXX Special-case until multitile detectors fully # supported. try: two_theta = self.raw_image.twotheta * math.pi / 180 except AttributeError: two_theta = 0 return two_theta
def createInput(image_dir, site, logger): logger.debug('createInput') #import glob from iotbx.detectors import ImageFactory try: img_site_id, img_site, c_site, imgs = site l1 = [] l2 = [] d = {} pids = [] vendortype = ImageFactory(imgs[0]).vendortype if vendortype == 'ADSC-HF4M': from detectors.rapd_adsc import Hf4mReadHeader as readHeader elif vendortype == 'Pilatus-6M': from detectors.rapd_pilatus import pilatus_read_header as readHeader elif vendortype == 'ADSC': from detectors.rapd_adsc import Q315ReadHeader as readHeader else: from detectors.mar import MarReadHeader as readHeader l = [p for p in imgs if p.count('priming_shot') == False ] #Remove priming shot (NE-CAT ONLY) for x in range(2): for i in l: if x == 0: #Get headers first header = readHeader(i) #Send images to ImageFactory to read the header (TODO). #Send images to RAM on all cluster nodes first. if RAM == True: image_path = os.path.join( '/dev/shm', os.path.basename(header.get('fullname'))) command = 'cp %s %s' % (header.get('fullname'), image_path) #ONLY work at NE-CAT job = Process(target=Utils.rocksCommand, args=(command, logger)) job.start() pids.append(job) else: image_path = header.get('fullname') x1, y1 = calc_beamcenter(round(header.get('distance'))) l1.append({#'beam_center_x' : round(header.get('beam_center_x'),3), #'beam_center_y' : round(header.get('beam_center_y'),3), #'beam_center_x' : 150.049, #BM #'beam_center_y' : 151.148, #BM #'beam_center_x' : 151.186, #ID #'beam_center_y' : 144.821, #ID #'beam_center_x' : 150.31, #BM #'beam_center_y' : 149.53, #BM 'beam_center_x' : x1, #BM 'beam_center_y' : y1, #BM 'spacegroup' : SPACEGROUP, 'fullname' : image_path, 'distance' : round(header.get('distance')), 'vendortype' : vendortype, }) else: #Then sort by distance for input l3 = [] if os.path.basename(i) not in (l2): for y in range(2): for z in range(len(l1)): if y == 0: if os.path.basename(i) == os.path.basename( l1[z].get('fullname')): dist = l1[z].get('distance') l3.append(l1[z]) l2.append( os.path.basename( l1[z].get('fullname'))) elif l1[z].get('distance') == dist: if os.path.basename( l1[z].get('fullname')) not in l2: l3.append(l1[z]) l2.append( os.path.basename( l1[z].get('fullname'))) d[str(dist)] = tuple(l3[:2]) #wait for images to be copied to RAM. if RAM == True: while len(pids) != 0: for job in pids: if job.is_alive() == False: pids.remove(job) time.sleep(1) inp = { 'directories': { 'work': WORK_DIR }, 'info': d, 'command': 'INDEX+STRATEGY', 'preferences': { "sample_type": "Protein", "beam_flip": "False", "multiprocessing": "True", "a": 0.0, "b": 0.0, "c": 0.0, "alpha": 0.0, "beta": 0.0, "gamma": 0.0 }, 'site_parameters': { 'img_site_id': img_site_id, 'img_site': img_site, 'cluster_site': c_site }, 'return_address': ("127.0.0.1", 50000) } Utils.pp(inp) return (inp) except: logger.exception('**Error in Handler.postprocess**') print 'Could not create input script from folder specified!' return (None)
def _try_as_img(self): from iotbx.detectors import ImageFactory img = ImageFactory(self.file_name) img.read() self._file_type = "img" self._file_object = img
class _Tiles(object): # maximum number of tiles held in each level cache MaxTileList = 512 def __init__(self, filename): (self.tile_size_x, self.tile_size_y) = (256, 256) self.levels = [-3, -2, -1, 0, 1, 2, 3, 4, 5] # set min and max tile levels self.min_level = -3 self.max_level = 5 self.extent = (-180.0, 180.0, -166.66, 166.66 ) # longitude & latitude limits self.set_image(filename) self.current_brightness = 1.0 self.current_color_scheme = 0 self.user_requests_antialiasing = False self.show_untrusted = False def set_image(self, file_name_or_data, metrology_matrices=None, get_raw_data=None): self.reset_the_cache() if file_name_or_data is None: self.raw_image = None return if isinstance(file_name_or_data, six.string_types): from iotbx.detectors import ImageFactory self.raw_image = ImageFactory(file_name_or_data) self.raw_image.read() else: try: self.raw_image = file_name_or_data._raw except AttributeError: self.raw_image = file_name_or_data # print "SETTING NEW IMAGE",self.raw_image.filename # XXX Since there doesn't seem to be a good way to refresh the # image (yet), the metrology has to be applied here, and not # in frame.py. detector = self.raw_image.get_detector() if len(detector) > 1 and metrology_matrices is not None: self.raw_image.apply_metrology_from_matrices(metrology_matrices) if get_raw_data is not None: self.raw_image.set_raw_data(get_raw_data(self.raw_image)) raw_data = self.raw_image.get_raw_data() if not isinstance(raw_data, tuple): raw_data = (raw_data, ) if len(detector) > 1: self.flex_image = _get_flex_image_multipanel( brightness=self.current_brightness / 100, panels=detector, show_untrusted=self.show_untrusted, raw_data=raw_data, beam=self.raw_image.get_beam(), color_scheme=self.current_color_scheme, ) else: self.flex_image = _get_flex_image( brightness=self.current_brightness / 100, data=raw_data[0], saturation=self.raw_image.get_detector() [0].get_trusted_range()[1], vendortype=self.raw_image.get_vendortype(), show_untrusted=self.show_untrusted, color_scheme=self.current_color_scheme, ) if self.zoom_level >= 0: self.flex_image.adjust(color_scheme=self.current_color_scheme) def set_image_data(self, raw_image_data): self.reset_the_cache() # XXX Since there doesn't seem to be a good way to refresh the # image (yet), the metrology has to be applied here, and not # in frame.py. detector = self.raw_image.get_detector() self.raw_image.set_raw_data(raw_image_data) if len(detector) == 1 and len(raw_image_data) == 1: raw_image_data = raw_image_data[0] if len(detector) > 1: self.flex_image = _get_flex_image_multipanel( brightness=self.current_brightness / 100, panels=detector, raw_data=raw_image_data, beam=self.raw_image.get_beam(), ) else: self.flex_image = _get_flex_image( brightness=self.current_brightness / 100, data=raw_image_data, saturation=self.raw_image.get_detector() [0].get_trusted_range()[1], vendortype=self.raw_image.get_vendortype(), show_untrusted=self.show_untrusted, ) self.flex_image.adjust(color_scheme=self.current_color_scheme) def update_brightness(self, b, color_scheme=0): raw_data = self.raw_image.get_raw_data() if not isinstance(raw_data, tuple): raw_data = (raw_data, ) if len(self.raw_image.get_detector()) > 1: # XXX Special-case read of new-style images until multitile # images are fully supported in dxtbx. self.flex_image = _get_flex_image_multipanel( brightness=b / 100, panels=self.raw_image.get_detector(), show_untrusted=self.show_untrusted, raw_data=raw_data, beam=self.raw_image.get_beam(), color_scheme=color_scheme, ) else: self.flex_image = _get_flex_image( brightness=b / 100, data=raw_data[0], saturation=self.raw_image.get_detector() [0].get_trusted_range()[1], vendortype=self.raw_image.get_vendortype(), show_untrusted=self.show_untrusted, color_scheme=color_scheme, ) self.reset_the_cache() self.UseLevel(self.zoom_level) self.current_color_scheme = color_scheme self.current_brightness = b self.flex_image.adjust(color_scheme) def update_color_scheme(self, color_scheme=0): self.flex_image.adjust(color_scheme) self.reset_the_cache() self.UseLevel(self.zoom_level) self.current_color_scheme = color_scheme def reset_the_cache(self): # setup the tile caches and Least Recently Used lists self.cache = {} self.lru = {} for l in self.levels: self.cache[l] = {} self.lru[l] = [] def flex_image_get_tile(self, x, y): # The supports_rotated_tiles_antialiasing_recommended flag in # the C++ FlexImage class indicates whether the underlying image # instance supports tilted readouts. Anti-aliasing only makes # sense if it does. if (self.raw_image is not None and self.zoom_level >= 2 and self.flex_image.supports_rotated_tiles_antialiasing_recommended and self.user_requests_antialiasing): # much more computationally intensive to prepare nice-looking pictures of tilted readout self.flex_image.setZoom(self.zoom_level + 1) fraction = 512.0 / self.flex_image.size1() / (2**(self.zoom_level + 1)) self.flex_image.setWindowCart(y, x, fraction) self.flex_image.prep_string() w, h = self.flex_image.ex_size2(), self.flex_image.ex_size1() assert w == 512 assert h == 512 wx_image = wx.EmptyImage(w / 2, h / 2) import PIL.Image as Image I = Image.frombytes("RGB", (512, 512), self.flex_image.as_bytes()) J = I.resize((256, 256), Image.ANTIALIAS) wx_image.SetData(J.tostring()) return wx_image.ConvertToBitmap() elif self.raw_image is not None: self.flex_image.setZoom(self.zoom_level) fraction = 256.0 / self.flex_image.size1() / (2**self.zoom_level) self.flex_image.setWindowCart(y, x, fraction) self.flex_image.prep_string() w, h = self.flex_image.ex_size2(), self.flex_image.ex_size1() assert w == 256 assert h == 256 wx_image = wx.EmptyImage(w, h) wx_image.SetData(self.flex_image.as_bytes()) return wx_image.ConvertToBitmap() else: wx_image = wx.EmptyImage(256, 256) return wx_image.ConvertToBitmap() def get_binning(self): if self.zoom_level >= 0: return 1.0 return 2.0**-self.zoom_level def UseLevel(self, n): """Prepare to serve tiles from the required level. n The required level Returns a tuple (map_width, map_height, ppd_x, ppd_y) if successful, else None. The width/height values are pixels. The ppd_? values are pixels-per-degree values for X and Y direction. """ # try to get cache for this level, no cache means no level # print "IN USE LEVEL",n try: self.tile_cache = self.cache[n] self.tile_list = self.lru[n] except KeyError: return None self.zoom_level = n if self.raw_image is None: # dummy values if there is no image self.center_x_lon = self.center_y_lat = 500.0 return (1024, 1024, 1.0, 1.0) self.num_tiles_x = int( math.ceil( (self.flex_image.size1() * (2**self.zoom_level)) / 256.0)) self.num_tiles_y = int( math.ceil( (self.flex_image.size2() * (2**self.zoom_level)) / 256.0)) self.ppd_x = 2.0**self.zoom_level self.ppd_y = 2.0**self.zoom_level # print "USELEVEL %d # tiles: %d %d"%(n,self.num_tiles_x,self.num_tiles_y) # print "USELEVEL %d returning"%n,(self.tile_size_x * self.num_tiles_x, # self.tile_size_y * self.num_tiles_y, # self.ppd_x, self.ppd_y) # The longitude & latitude coordinates at the image center: self.center_x_lon = self.extent[0] + (1.0 / self.ppd_x) * ( 0 + self.flex_image.size2() * (2**self.zoom_level) / 2.0) self.center_y_lat = self.extent[3] - (1.0 / self.ppd_y) * ( 0 + self.flex_image.size1() * (2**self.zoom_level) / 2.0) # The 2+num_tiles is just a trick to get PySlip to think the map is # slightly larger, allowing zoom level -3 to be properly framed: # ....for larger display sizes it is necessary to increase this... # ....can tile_generator get the display size & figure it out? return ( self.tile_size_x * (2 + self.num_tiles_x), self.tile_size_y * (2 + self.num_tiles_y), self.ppd_x, self.ppd_y, ) def get_initial_instrument_centering_within_picture_as_lon_lat(self): import sys detector = self.raw_image.get_detector() if sys.platform.lower().find("linux") >= 0: if len(detector) > 1: return 0.0, 0.0 else: return ( self.center_x_lon - self.extent[0], self.center_y_lat - self.extent[3], ) else: if len(detector) > 1: return self.extent[0], self.extent[3] else: return self.center_x_lon, self.center_y_lat def GetTile(self, x, y): # from libtbx.development.timers import Timer # T = Timer("get tile") """Get bitmap for tile at tile coords (x, y). x X coord of tile required (tile coordinates) y Y coord of tile required (tile coordinates) Returns bitmap object containing the tile image. Tile coordinates are measured from map top-left. """ try: # if tile in cache, return it from there pic = self.tile_cache[(x, y)] index = self.tile_list.index((x, y)) del self.tile_list[index] except KeyError: pic = self.flex_image_get_tile(x, y) self.tile_cache[(x, y)] = pic self.tile_list.insert(0, (x, y)) if len(self.tile_cache) >= self.MaxTileList: del self.tile_cache[self.tile_list[-1]] del self.tile_list[-1] return pic def get_flex_pixel_coordinates(self, lon, lat): fast_picture_coord_pixel_scale, slow_picture_coord_pixel_scale = self.lon_lat_to_picture_fast_slow( lon, lat) if (self.flex_image.supports_rotated_tiles_antialiasing_recommended ): # for generic_flex_image tilted = self.flex_image.picture_to_readout( slow_picture_coord_pixel_scale, fast_picture_coord_pixel_scale) return tilted else: # standard flex_image return slow_picture_coord_pixel_scale, fast_picture_coord_pixel_scale def lon_lat_to_picture_fast_slow(self, longitude, latitude): # input latitude and longitude in degrees (conceptually) # output fast and slow picture coordinates in units of detector pixels # slow is pointing down (x). fast is pointing right (y). detector = self.raw_image.get_detector() if len(detector) == 1: (size2, size1) = detector[0].get_image_size() else: # XXX Special-case until multitile detectors fully supported. (size1, size2) = (self.flex_image.size1(), self.flex_image.size2()) return ( (size2 / 2.0) - (self.center_x_lon - longitude), (size1 / 2.0) - (latitude - self.center_y_lat), ) def picture_fast_slow_to_lon_lat(self, pic_fast_pixel, pic_slow_pixel): # inverse of the preceding function detector = self.raw_image.get_detector() if detector.num_panels() == 1: (size1, size2) = detector.get_image_size() else: # XXX Special-case until multitile detectors fully supported. (size1, size2) = (self.flex_image.size1(), self.flex_image.size2()) return ( (size2 / 2.0) - self.center_x_lon - pic_fast_pixel, (size1 / 2.0) + self.center_y_lat - pic_slow_pixel, ) def picture_fast_slow_to_map_relative(self, pic_fast_pixel, pic_slow_pixel): # return up/down, left/right map relative coords for pyslip layers return pic_fast_pixel + self.extent[0], -pic_slow_pixel + self.extent[3] def map_relative_to_picture_fast_slow(self, map_rel_vert, map_rel_horiz): # return fast, slow picture coords return map_rel_vert - self.extent[0], -map_rel_horiz + self.extent[3] def vec_picture_fast_slow_to_map_relative(self, vector): value = [] for vec in vector: value.append(self.picture_fast_slow_to_map_relative( vec[0], vec[1])) return value def get_spotfinder_data(self, params): pointdata = [] test_pattern = False if (test_pattern is True and self.raw_image.__class__.__name__.find("CSPadDetector") >= 0): key_count = -1 for key, asic in self.raw_image._tiles.items(): key_count += 1 focus = asic.focus() for slow in range(0, focus[0], 20): for fast in range(0, focus[1], 20): slowpic, fastpic = self.flex_image.tile_readout_to_picture( key_count, slow, fast) mr1, mr2 = self.picture_fast_slow_to_map_relative( fastpic, slowpic) pointdata.append((mr1, mr2, {"data": key})) elif self.raw_image.__class__.__name__.find("CSPadDetector") >= 0: from cxi_xdr_xes.cftbx.spotfinder.speckfinder import spotfind_readout key_count = -1 for key, asic in self.raw_image._tiles.items(): key_count += 1 indexing = spotfind_readout( readout=asic, peripheral_margin=params.spotfinder.peripheral_margin) for spot in indexing: slow = int(round(spot[0])) fast = int(round(spot[1])) slowpic, fastpic = self.flex_image.tile_readout_to_picture( key_count, slow, fast) mr1, mr2 = self.picture_fast_slow_to_map_relative( fastpic, slowpic) pointdata.append((mr1, mr2, {"data": key})) else: from spotfinder.command_line.signal_strength import master_params working_params = master_params.fetch( sources=[]) # placeholder for runtime mods working_params.show(expert_level=1) distl_params = working_params.extract() spotfinder, frameno = self.raw_image.get_spotfinder(distl_params) spots = spotfinder.images[frameno]["spots_total"] for spot in spots: mr = self.picture_fast_slow_to_map_relative( spot.max_pxl_y() + 0.5, spot.max_pxl_x() + 0.5) # spot.ctr_mass_y() + 0.5, spot.ctr_mass_x() + 0.5) pointdata.append(mr) return pointdata def get_effective_tiling_data(self, params): box_data = [] text_data = [] if hasattr(self.raw_image, "get_tile_manager"): IT = self.raw_image.get_tile_manager( params).effective_tiling_as_flex_int() for i in range(len(IT) // 4): tile = IT[4 * i:4 * i + 4] attributes = { "color": "#0000FFA0", "width": 1, "closed": False } box_data.append(( ( self.picture_fast_slow_to_map_relative( tile[1], tile[0]), self.picture_fast_slow_to_map_relative( tile[1], tile[2]), ), attributes, )) box_data.append(( ( self.picture_fast_slow_to_map_relative( tile[1], tile[0]), self.picture_fast_slow_to_map_relative( tile[3], tile[0]), ), attributes, )) box_data.append(( ( self.picture_fast_slow_to_map_relative( tile[1], tile[2]), self.picture_fast_slow_to_map_relative( tile[3], tile[2]), ), attributes, )) box_data.append(( ( self.picture_fast_slow_to_map_relative( tile[3], tile[0]), self.picture_fast_slow_to_map_relative( tile[3], tile[2]), ), attributes, )) txt_x, txt_y = self.picture_fast_slow_to_map_relative( (tile[1] + tile[3]) // 2, (tile[0] + tile[2]) // 2) text_data.append((txt_x, txt_y, "%i" % i)) return box_data, text_data def get_resolution(self, x, y, readout=None): """ Determine the resolution of a pixel. Arguments are in image pixel coordinates (starting from 1,1). """ detector = self.raw_image.get_detector() beam = self.raw_image.get_beam() if detector is None or beam is None: return None beam = beam.get_s0() if len(detector) > 1: if readout is None: return None panel = detector[readout] else: panel = detector[0] if abs(panel.get_distance()) > 0: return panel.get_resolution_at_pixel(beam, (x, y)) else: return None def get_detector_distance(self): detector = self.raw_image.get_detector() if len(detector) == 1: dist = abs(detector[0].get_distance()) else: # XXX Special-case until multitile detectors fully # supported. dist = self.raw_image.distance twotheta = self.get_detector_2theta() if twotheta == 0.0: return dist else: return dist / math.cos(twotheta) def get_detector_2theta(self): from scitbx.matrix import col detector = self.raw_image.get_detector() if len(detector) == 1: n = col(detector[0].get_normal()) s0 = col(self.raw_image.get_beam().get_unit_s0()) two_theta = s0.angle(n, deg=False) else: # XXX Special-case until multitile detectors fully # supported. try: two_theta = self.raw_image.twotheta * math.pi / 180 except AttributeError: two_theta = 0 return two_theta
from __future__ import division from __future__ import print_function import sys import numpy from iotbx.detectors import ImageFactory from matplotlib import pyplot as plt image = ImageFactory(sys.argv[1]) image.read() nfast = image.parameters["SIZE1"] nslow = image.parameters["SIZE2"] data = image.get_raw_data() print("here 1") data2d = numpy.reshape(numpy.array(data, dtype=float), (nfast, nslow)) print("here 2") data2dsmoth = numpy.zeros(nfast * nslow, dtype=float).reshape(nfast, nslow) diffdata2d = numpy.zeros(nfast * nslow, dtype=float).reshape(nfast, nslow) print("nslow, nfast =", nslow, nfast) print("max(data2d) =", numpy.max(data2d)) print("min(data2d) =", numpy.min(data2d)) for f in range(1, nfast - 1): for s in range(1, nslow - 1): pscan = float(numpy.sum(data2d[f - 1 : f + 1, s - 1 : s + 1]) / 9.0) data2dsmoth[f, s] = pscan print("max(data2dsmoth) =", numpy.max(data2dsmoth))
from __future__ import division import sys import numpy from iotbx.detectors import ImageFactory from matplotlib import pyplot as plt image = ImageFactory( sys.argv[1] ) image.read() nfast = image.parameters['SIZE1'] nslow = image.parameters['SIZE2'] data = image.get_raw_data() print 'here 1' data2d = numpy.reshape( numpy.array( data, dtype = float ), ( nfast , nslow ) ) print 'here 2' data2dsmoth = numpy.zeros( nfast * nslow, dtype = float ).reshape( nfast, nslow ) diffdata2d = numpy.zeros( nfast * nslow, dtype = float ).reshape( nfast, nslow ) print "nslow, nfast =", nslow, nfast print "max(data2d) =", numpy.max( data2d ) print "min(data2d) =", numpy.min( data2d ) for f in range( 1, nfast - 1 ): for s in range( 1, nslow - 1 ): pscan = float( numpy.sum( data2d[f - 1:f + 1, s - 1:s + 1] ) / 9.0 ) data2dsmoth[f, s] = pscan print "max(data2dsmoth) =", numpy.max( data2dsmoth ) print "min(data2dsmoth) =", numpy.min( data2dsmoth )
def _try_as_img (self) : from iotbx.detectors import ImageFactory img = ImageFactory(self.file_name) img.read() self._file_type = "img" self._file_object = img