Ejemplo n.º 1
0
from __future__ import division
from __future__ import print_function

from scitbx.array_family import flex
from dials.model.data import Reflection, ReflectionList
from dials.algorithms import shoebox

rl = ReflectionList()
r1 = Reflection()
r1.shoebox = (10, 20, 10, 20, 10, 20)
r2 = Reflection()
r2.shoebox = (15, 25, 15, 25, 15, 25)
r3 = Reflection()
r3.shoebox = (20, 30, 20, 30, 20, 30)
rl.append(r1)
rl.append(r2)
rl.append(r3)
overlapping = shoebox.find_overlapping(rl)

for e in overlapping.edges():
    print("Edge: ", overlapping.edge_vertices(e))

for v in overlapping.vertices():
    print("Vertex: ", v, " => ", [a for a in overlapping.adjacent_vertices(v)])
Ejemplo n.º 2
0
    def oneImage(self, framenumber):
        self.reporters[framenumber] = []

        import dxtbx.format.Registry
        filename = self.phil_params.distl.image[framenumber]
        reader = dxtbx.format.Registry.get_format_class_for_file(filename)
        img = reader(filename)

        detector = img.get_detector()
        beam = img.get_beam()
        S0 = beam.get_s0()
        data = img.get_raw_data()
        scan = img.get_scan()
        print(scan)
        if scan is None:
            print("No scan")
            RR = (0, 1)
        else:
            print(scan.get_oscillation())
            RR = scan.get_oscillation_range()

        from spotfinder.dxtbx_toolbox import Distl

        sfall = Distl(params=self.phil_params,
                      detector=detector,
                      beam=beam,
                      data=data)

        resolutions = flex.double()
        spotlist = []
        from dials.model.data import ReflectionList, Reflection
        reflections = ReflectionList()

        for ip, panel in enumerate(detector):
            for spot in sfall.finderlist[ip].spots:
                resolutions.append(
                    panel.get_resolution_at_pixel(
                        S0, (spot.ctr_mass_x(), spot.ctr_mass_y())))
                spotlist.append(spot)
                refl = Reflection()
                refl.panel_number = ip
                refl.centroid_position = (spot.ctr_mass_x(), spot.ctr_mass_y(),
                                          0.0)
                refl.centroid_variance = (0.5, 0.5, 0.0)
                reflections.append(refl)

        selection = (resolutions > 0.0)
        if self.phil_params.distl.res.outer is not None:
            selection = (selection
                         and (resolutions > self.phil_params.distl.res.outer))
        if self.phil_params.distl.res.inner is not None:
            selection = (selection
                         and (resolutions < self.phil_params.distl.res.inner))

        reflections = reflections.select(selection)

        return dict(detector=detector,
                    beam=beam,
                    reflections=reflections,
                    scan=scan,
                    gonio=img.get_goniometer())
data2d = flex.double(flex.grid(1, 3, 3), 15)
data2d[0, 1, 1] = 50

for row in range(3):
    for col in range(3):
        data2d[0, row, col] += row * 2
        data2d[0, row, col] += col * 2

mask2d = flex.int(flex.grid(1, 3, 3), 3)
mask2d[0, 1, 1] = 5

background2d = flex.double(flex.grid(1, 3, 3), 0)
from dials.model.data import Reflection, ReflectionList
from scitbx.array_family import flex

r = Reflection()
r.shoebox = data2d
r.shoebox_mask = mask2d
r.shoebox_background = background2d

rlist = ReflectionList()
rlist.append(r)

# from dials.algorithms.background.flat_background_subtractor \
# import layering_and_background_avg
# layering_and_background_avg(rlist)

# from dials.algorithms.background.curved_background_subtractor \
# import layering_and_background_modl
# layering_and_background_modl(rlist)