Пример #1
0
def background_correct(data, raw_asic):

    prime_asic = get_factorizable_block(raw_asic)
    print "Working on block", prime_asic
    block = data.matrix_copy_block(i_row=prime_asic[0],
                                   i_column=prime_asic[1],
                                   n_rows=prime_asic[2] - prime_asic[0],
                                   n_columns=prime_asic[3] - prime_asic[1])

    complex_data = flex.polar(block.as_double(),
                              flex.double(flex.grid(block.focus())))
    from scitbx import fftpack
    fft = fftpack.complex_to_complex_2d(block.focus())
    # input data here
    fft.forward(complex_data)
    # your manipulation here
    low_pass_filter(complex_data)

    fft.backward(complex_data)
    # real data
    filtered_data = flex.real(complex_data) / (fft.n()[0] * fft.n()[1])
    corrected_data = block - filtered_data.iround()

    requested_block = data.matrix_copy_block(i_row=raw_asic[0],
                                             i_column=raw_asic[1],
                                             n_rows=raw_asic[2] - raw_asic[0],
                                             n_columns=raw_asic[3] -
                                             raw_asic[1])
    requested_block.matrix_paste_block_in_place(
        block=corrected_data,
        i_row=prime_asic[0] - raw_asic[0],
        i_column=prime_asic[1] - raw_asic[1])

    return requested_block
Пример #2
0
def background_correct(data, raw_asic):

  prime_asic = get_factorizable_block(raw_asic)
  print "Working on block",prime_asic
  block = data.matrix_copy_block(
      i_row=prime_asic[0],i_column=prime_asic[1],
      n_rows=prime_asic[2]-prime_asic[0],
      n_columns=prime_asic[3]-prime_asic[1])

  complex_data = flex.polar(block.as_double(),flex.double(flex.grid(block.focus())))
  from scitbx import fftpack
  fft = fftpack.complex_to_complex_2d(block.focus())
  # input data here
  fft.forward(complex_data)
  # your manipulation here
  low_pass_filter(complex_data)

  fft.backward(complex_data)
  # real data
  filtered_data = flex.real(complex_data)/(fft.n()[0]*fft.n()[1])
  corrected_data = block - filtered_data.iround()

  requested_block = data.matrix_copy_block(
      i_row=raw_asic[0],i_column=raw_asic[1],
      n_rows=raw_asic[2]-raw_asic[0],
      n_columns=raw_asic[3]-raw_asic[1])
  requested_block.matrix_paste_block_in_place(
      block = corrected_data,
      i_row = prime_asic[0] - raw_asic[0],
      i_column = prime_asic[1] - raw_asic[1]
      )

  return requested_block
Пример #3
0
def background_correct_padded_block(data, raw_asic):

  Pad = padded_unpadded(data,raw_asic)

  block = Pad.get_padded_input_data()

  complex_data = flex.polar(block.as_double(),flex.double(flex.grid(block.focus())))
  from scitbx import fftpack
  fft = fftpack.complex_to_complex_2d(block.focus())
  # input data here
  fft.forward(complex_data)
  # your manipulation here
  low_pass_filter(complex_data)

  fft.backward(complex_data)
  # real data
  filtered_data = flex.real(complex_data)/(fft.n()[0]*fft.n()[1])
  # XXX change this depending on float/int data type:
  corrected_data = block - filtered_data.iround()

  return Pad.get_unpadded_result_data(corrected_data)
Пример #4
0
def background_correct_padded_block(data, raw_asic):

  Pad = padded_unpadded(data,raw_asic)

  block = Pad.get_padded_input_data()

  complex_data = flex.polar(block.as_double(),flex.double(flex.grid(block.focus())))
  from scitbx import fftpack
  fft = fftpack.complex_to_complex_2d(block.focus())
  # input data here
  fft.forward(complex_data)
  # your manipulation here
  low_pass_filter(complex_data)

  fft.backward(complex_data)
  # real data
  filtered_data = flex.real(complex_data)/(fft.n()[0]*fft.n()[1])
  # XXX change this depending on float/int data type:
  corrected_data = block - filtered_data.iround()

  return Pad.get_unpadded_result_data(corrected_data)