def histogram(params, image):
from dials.array_family import flex
from matplotlib import pyplot
from astrotbx.input_output.loader import load_raw_image
r, g, b = load_raw_image(image, params=params.raw)
r *= params.scale
g *= params.scale
b *= params.scale
dmax = max(flex.max(r), flex.max(g), flex.max(b))
if params.colour == 'r':
data = r
elif params.colour == 'g':
data = g
else:
data = b
print("Mean / max r: %6.2f / %6.2f" % (flex.mean(r), flex.max(r)))
print("Mean / max g: %6.2f / %6.2f" % (flex.mean(g), flex.max(g)))
print("Mean / max b: %6.2f / %6.2f" % (flex.mean(b), flex.max(b)))
pixels = flex.histogram(data.as_1d(),
data_min=params.min,
data_max=params.max,
n_slots=params.bins)
v = pixels.slot_centers().as_double()
n = pixels.slots().as_double()
pyplot.bar(v, n, log=params.log_n)
pyplot.savefig(params.output % params.colour)
if params.save:
from astrotbx.input_output.saver import save_image
save_image(params.save, r, g, b)
def run(args):
from dials.util.options import OptionParser
import libtbx.load_env
import json
usage = "%s [options] DSC03206.jpg" % (libtbx.env.dispatcher_name)
parser = OptionParser(usage=usage, phil=phil_scope)
params, options, args = parser.parse_args(show_diff_phil=True,
return_unhandled=True)
max_image_r = None
max_image_g = None
max_image_b = None
from astrotbx.input_output.loader import load_image
from astrotbx.input_output.saver import save_image
for image in args:
r, g, b = load_image(image)
if max_image_r is None:
max_image_r = r
else:
max_image_r.as_1d().copy_selected((r > max_image_r).iselection(),
r.as_1d())
if max_image_g is None:
max_image_g = g
else:
max_image_g.as_1d().copy_selected((g > max_image_g).iselection(),
g.as_1d())
if max_image_b is None:
max_image_b = b
else:
max_image_b.as_1d().copy_selected((b > max_image_b).iselection(),
b.as_1d())
# output the image
max_image_r *= params.scale
max_image_g *= params.scale
max_image_b *= params.scale
save_image(params.output, max_image_r, max_image_g, max_image_b)
def run(args):
from dials.util.options import OptionParser
import libtbx.load_env
import json
usage = "%s [options] DSC03206.jpg" % (libtbx.env.dispatcher_name)
parser = OptionParser(usage=usage, phil=phil_scope)
params, options, args = parser.parse_args(show_diff_phil=True,
return_unhandled=True)
sum_image_r = None
sum_image_g = None
sum_image_b = None
from astrotbx.input_output.loader import load_image
from astrotbx.input_output.saver import save_image
for image in args:
r, g, b = load_image(image)
if sum_image_r is None:
sum_image_r = r
else:
sum_image_r += r
if sum_image_g is None:
sum_image_g = g
else:
sum_image_g += g
if sum_image_b is None:
sum_image_b = b
else:
sum_image_b += b
# output the image
sum_image_r *= params.scale / len(args)
sum_image_g *= params.scale / len(args)
sum_image_b *= params.scale / len(args)
save_image(params.output, sum_image_r, sum_image_g, sum_image_b)
def run(args):
from dials.util.options import OptionParser
import libtbx.load_env
import json
usage = "%s [options] DSC03206.jpg" % (
libtbx.env.dispatcher_name)
parser = OptionParser(
usage=usage,
phil=phil_scope)
params, options, args = parser.parse_args(show_diff_phil=True,
return_unhandled=True)
import cPickle as pickle
from dials.array_family import flex
with open(params.data) as fin:
sum_image_r, sum_image_g, sum_image_b = pickle.load(fin)
if params.data_min:
sum_image_r -= params.data_min
sum_image_g -= params.data_min
sum_image_b -= params.data_min
sum_image_r *= params.scale
sum_image_g *= params.scale
sum_image_b *= params.scale
# output the image
from astrotbx.input_output.saver import save_image
save_image(
params.output,
sum_image_r,
sum_image_g,
sum_image_b,
params.png)
def make_test_image():
from scitbx import matrix
from dials.array_family import flex
import random
import math
xmin, xmax = 0, 4272
ymin, ymax = 0, 2848
buffer = 100
n = 30
# generate n random positions - well within field of view
x = flex.double(n)
y = flex.double(n)
z = flex.double(n, 0.0)
for j in range(n):
x[j] = random.uniform(xmin + buffer, xmax - buffer)
y[j] = random.uniform(ymin + buffer, ymax - buffer)
r = background(flex.double(flex.grid(ymax, xmax), 0.0), 3)
g = background(flex.double(flex.grid(ymax, xmax), 0.0), 3)
b = background(flex.double(flex.grid(ymax, xmax), 0.0), 3)
# add some stars
for xy in zip(x, y):
star_x, star_y = random_positions(1000, 1).parts()
star_x += xy[0]
star_y += xy[1]
for i, j in zip(star_x.iround(), star_y.iround()):
r[j, i] += 1
g[j, i] += 1
b[j, i] += 1
from astrotbx.input_output.saver import save_image
save_image('example.png', r, g, b)
def run(args):
from dials.util.options import OptionParser
import libtbx.load_env
import json
usage = "%s [options] DSC03206.jpg" % (libtbx.env.dispatcher_name)
parser = OptionParser(usage=usage, phil=phil_scope)
params, options, args = parser.parse_args(show_diff_phil=True,
return_unhandled=True)
Rtds = json.load(open(params.alignments))
assert len(Rtds) == len(args)
sum_image_r = None
sum_image_g = None
sum_image_b = None
from astrotbx.input_output.loader import load_image, load_raw_image
from astrotbx.input_output.saver import save_image, save_image_gs
from astrotbx.algorithms.image_align import rotate_translate_array
raws = ['arw']
kept = 0
for image, alignment in zip(args, Rtds):
if params.dlimit > 0:
if alignment['d'] > params.dlimit:
print("Ignoring %s" % image)
continue
print("Loading %s" % image)
kept += 1
R, t = alignment['R'], alignment['t']
exten = image.split('.')[-1].lower()
if exten in raws:
r, g, b = load_raw_image(image, params.raw)
else:
r, g, b = load_image(image)
_r = rotate_translate_array(r, R, t)
_g = rotate_translate_array(g, R, t)
_b = rotate_translate_array(b, R, t)
if sum_image_r is None:
sum_image_r = _r
else:
sum_image_r += _r
if sum_image_g is None:
sum_image_g = _g
else:
sum_image_g += _g
if sum_image_b is None:
sum_image_b = _b
else:
sum_image_b += _b
# first scale to get the mean image
sum_image_r *= 1.0 / kept
sum_image_g *= 1.0 / kept
sum_image_b *= 1.0 / kept
# save the data image
if params.data:
import cPickle as pickle
with open(params.data, 'w') as fout:
pickle.dump((sum_image_r, sum_image_g, sum_image_b),
fout,
protocol=pickle.HIGHEST_PROTOCOL)
# output the image scaled however requested (can revisit in
# astrotbx.develop)
sum_image_r *= params.scale
sum_image_g *= params.scale
sum_image_b *= params.scale
if params.greyscale:
save_image_gs(params.output, sum_image_r + sum_image_g + sum_image_b)
else:
save_image(params.output, sum_image_r, sum_image_g, sum_image_b)