예제 #1
0
  def tst_nearest_n(self):
    from math import sqrt, atan2, pi, floor
    from random import uniform
    from dials.algorithms.profile_model.modeller import CircleSampler
    width = 1000
    height = 1000
    scan_range = (2, 12)
    depth = scan_range[1] - scan_range[0]
    nz = 2
    sampler = CircleSampler((width, height), scan_range, nz)
    xc, yc = sampler.image_centre()
    r1 = sampler.r1()

    for i in range(1000):
      x = uniform(0, 1000)
      y = uniform(0, 1000)
      z = uniform(scan_range[0], scan_range[1])

      r = sqrt((x - xc)**2 + (y - yc)**2)
      if r < r1:
        index00 = 0
      else:
        t = atan2(y - yc, x - xc)
        ai = int(floor(t * 8 / (2 * pi) + 0.5)) % 8
        index00 = ai + 1

      index01 = int((z-scan_range[0]) * nz / depth)
      if index01 < 0:
        index01 = 0
      if index01 >= 2:
        index01 = 1

      index0 = index00 + index01 * 9
      index1 = sampler.nearest_n(0, (x, y, z))
      assert(index0 == index1[0])
      if index0 % 9 == 0:
        assert(len(index1) == 9)
        assert(all(idx == index0 + i for i, idx in enumerate(index1)))
      else:
        assert(len(index1) == 4)
        assert(index1[1] == (index0 // 9) * 9)
        if (index0 % 9) == 1:
          assert(index1[2] == index0 + 1)
          assert(index1[3] == index0 + 7)
        elif (index0 % 9) == 8:
          assert(index1[2] == index0 - 7)
          assert(index1[3] == index0 - 1)
        else:
          assert(index1[2] == index0 + 1)
          assert(index1[3] == index0 - 1)

    print 'OK'
예제 #2
0
    def tst_nearest_n(self):
        from math import sqrt, atan2, pi, floor
        from random import uniform
        from dials.algorithms.profile_model.modeller import CircleSampler
        width = 1000
        height = 1000
        scan_range = (2, 12)
        depth = scan_range[1] - scan_range[0]
        nz = 2
        sampler = CircleSampler((width, height), scan_range, nz)
        xc, yc = sampler.image_centre()
        r1 = sampler.r1()

        for i in range(1000):
            x = uniform(0, 1000)
            y = uniform(0, 1000)
            z = uniform(scan_range[0], scan_range[1])

            r = sqrt((x - xc)**2 + (y - yc)**2)
            if r < r1:
                index00 = 0
            else:
                t = atan2(y - yc, x - xc)
                ai = int(floor(t * 8 / (2 * pi) + 0.5)) % 8
                index00 = ai + 1

            index01 = int((z - scan_range[0]) * nz / depth)
            if index01 < 0:
                index01 = 0
            if index01 >= 2:
                index01 = 1

            index0 = index00 + index01 * 9
            index1 = sampler.nearest_n((x, y, z))
            assert (index0 == index1[0])
            if index0 % 9 == 0:
                assert (len(index1) == 9)
                assert (all(idx == index0 + i for i, idx in enumerate(index1)))
            else:
                assert (len(index1) == 4)
                assert (index1[1] == (index0 // 9) * 9)
                if (index0 % 9) == 1:
                    assert (index1[2] == index0 + 1)
                    assert (index1[3] == index0 + 7)
                elif (index0 % 9) == 8:
                    assert (index1[2] == index0 - 7)
                    assert (index1[3] == index0 - 1)
                else:
                    assert (index1[2] == index0 + 1)
                    assert (index1[3] == index0 - 1)

        print 'OK'
예제 #3
0
def test_nearest_n():
    from dials.algorithms.profile_model.modeller import CircleSampler

    width = 1000
    height = 1000
    scan_range = (2, 12)
    depth = scan_range[1] - scan_range[0]
    nz = 2
    sampler = CircleSampler((width, height), scan_range, nz)
    xc, yc = sampler.image_centre()
    r1 = sampler.r1()

    for i in range(1000):
        x = random.uniform(0, 1000)
        y = random.uniform(0, 1000)
        z = random.uniform(scan_range[0], scan_range[1])

        r = math.sqrt((x - xc)**2 + (y - yc)**2)
        if r < r1:
            index00 = 0
        else:
            t = math.atan2(y - yc, x - xc)
            ai = int(math.floor(t * 8 / (2 * math.pi) + 0.5)) % 8
            index00 = ai + 1

        index01 = int((z - scan_range[0]) * nz / depth)
        if index01 < 0:
            index01 = 0
        if index01 >= 2:
            index01 = 1

        index0 = index00 + index01 * 9
        index1 = sampler.nearest_n(0, (x, y, z))
        assert index0 == index1[0]
        if index0 % 9 == 0:
            assert len(index1) == 9
            assert all(idx == index0 + i for i, idx in enumerate(index1))
        else:
            assert len(index1) == 4
            assert index1[1] == (index0 // 9) * 9
            if (index0 % 9) == 1:
                assert index1[2] == index0 + 1
                assert index1[3] == index0 + 7
            elif (index0 % 9) == 8:
                assert index1[2] == index0 - 7
                assert index1[3] == index0 - 1
            else:
                assert index1[2] == index0 + 1
                assert index1[3] == index0 - 1
예제 #4
0
def compute_reference(experiments, reflections):
    from dials.algorithms.profile_model.modeller import CircleSampler
    from dials.array_family import flex
    from dials.algorithms.profile_model.gaussian_rs.transform import TransformForward
    from dials.algorithms.profile_model.gaussian_rs.transform import TransformSpec
    from dials.algorithms.profile_model.gaussian_rs import CoordinateSystem

    reflections = select_strong(reflections)
    print("Selected %d strong spots" % len(reflections))

    sampler = CircleSampler(
        experiments[0].detector[0].get_image_size(),
        experiments[0].scan.get_array_range(),
        1,
    )

    n_sigma = 4.0
    grid_size = 25
    spec = TransformSpec(
        experiments[0].beam,
        experiments[0].detector,
        experiments[0].goniometer,
        experiments[0].scan,
        experiments[0].profile.sigma_b(deg=False),
        experiments[0].profile.sigma_m(deg=False),
        n_sigma,
        grid_size,
    )

    m2 = experiments[0].goniometer.get_rotation_axis()
    s0 = experiments[0].beam.get_s0()

    reference = [
        flex.double(
            flex.grid(1 + 2 * grid_size, 1 + 2 * grid_size, 1 + 2 * grid_size))
        for i in range(len(sampler))
    ]
    count = [0] * len(sampler)

    for r in reflections:
        s1 = r["s1"]
        phi = r["xyzcal.mm"][2]
        xyz = r["xyzcal.px"]
        bbox = r["bbox"]
        panel = r["panel"]
        image = r["shoebox"].data.as_double()
        mask = r["shoebox"].mask.as_1d() == 5
        mask.reshape(image.accessor())
        cs = CoordinateSystem(m2, s0, s1, phi)

        try:
            transform = TransformForward(spec, cs, bbox, panel, image, mask)
            d = transform.profile()

            d /= flex.sum(d)

            index = sampler.nearest(0, xyz)
            indices = sampler.nearest_n(0, xyz)
            for i in indices:
                w = sampler.weight(i, 0, xyz)
                reference[i] += w * d
                count[i] += 1
        except Exception:
            pass

    for i in range(len(reference)):
        r = reference[i]
        if flex.sum(r) > 0:
            print(flex.max(r))
            g = r.accessor()
            r = r.as_1d()
            s = r > 0.02 * flex.max(r)
            r.set_selected(~s, flex.double(len(r), 0))
            r = r / flex.sum(r)
            r.reshape(g)
            reference[i] = r

    for i in range(len(reference)):
        from matplotlib import pylab

        print(count[i])
        r = reference[i]
        d = r.as_numpy_array()[11, :, :]
        pylab.imshow(d, interpolation="None")
        pylab.show()

    return reference