class _Tiles:
# 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_image_data=None,
show_saturated=True,
):
self.reset_the_cache()
if file_name_or_data is None:
self.raw_image = None
return
if isinstance(file_name_or_data, str):
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_image_data is not None:
self.raw_image.set_image_data(get_image_data(self.raw_image))
image_data = self.raw_image.get_image_data()
if not isinstance(image_data, tuple):
image_data = (image_data,)
self.flex_image = get_flex_image_multipanel(
brightness=self.current_brightness / 100,
panels=detector,
show_untrusted=self.show_untrusted,
image_data=image_data,
beam=self.raw_image.get_beam(),
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, show_saturated=True):
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_image_data(raw_image_data)
self.flex_image = get_flex_image_multipanel(
brightness=self.current_brightness / 100,
panels=detector,
image_data=raw_image_data,
beam=self.raw_image.get_beam(),
)
self.flex_image.adjust(color_scheme=self.current_color_scheme)
def update_brightness(self, b, color_scheme=0):
image_data = self.raw_image.get_image_data()
if not isinstance(image_data, tuple):
image_data = (image_data,)
self.flex_image = get_flex_image_multipanel(
brightness=b / 100,
panels=self.raw_image.get_detector(),
show_untrusted=self.show_untrusted,
image_data=image_data,
beam=self.raw_image.get_beam(),
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.Image(w / 2, h / 2)
import PIL.Image as Image
Image_from_bytes = Image.frombytes(
"RGB", (512, 512), self.flex_image.as_bytes()
)
J = Image_from_bytes.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.Image(w, h)
wx_image.SetData(self.flex_image.as_bytes())
return wx_image.ConvertToBitmap()
else:
wx_image = wx.Image(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):
if sys.platform.lower().find("linux") >= 0:
return 0.0, 0.0
else:
return self.extent[0], self.extent[3]
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).
(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
(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 readout is None:
return None
panel = detector[readout]
if abs(panel.get_distance()) > 0:
return panel.get_resolution_at_pixel(beam, (x, y))
else:
return None
def get_detector_distance(self):
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):
try:
two_theta = self.raw_image.twotheta * math.pi / 180
except AttributeError:
two_theta = 0
return two_theta
