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 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,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 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 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, 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 __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 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, 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
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 _try_as_img(self):
from iotbx.detectors import ImageFactory
img = ImageFactory(self.file_name)
img.read()
self._file_type = "img"
self._file_object = img
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))
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)
