Keywords: sensor, rolling shutter

Summary

This demo shows how a focal plane can be configured with a "rolling shutter", where each line (row) of a 2D array is integrated and read out sequentially. In contrast to a "global shutter" (where all rows are read out at once), the rolling readout produces artifacts in the image when motion is present in the scene at frequencies proportional to the rolling shutter line rate. In this case, we are looking at a spinning rotor on a helicopter.

Details

A 2D array using a "global shutter" integrates all pixels for a fixed period of time and then reads them all out. However, the readout period can be considered dead time when pixels waiting to be readout could be still integration (and thereby improving signal to noise). A "rolling shutter" approach allows each line to integrate until it is read out, by cycling or rolling the readout through the 2D array in a line by line basis. Because each line is imaged at a different time, moving objects will change in appearance or location between lines.

The scene contains a frequently used example of a spinning rotor. The rotor is spinning at 500 RPM and the line read time is 10 microseconds. With the 320 x 240 array used in this sime, it takes 2.4 milliseconds to read all 240 rows out. As each line line is integrated, the rotor changes location. During the 2.4 milliseconds to read the array, the rotor will complete 1.2 revolutions (500 revolutions/second x 2.4e-03 seconds = 1.2 revolutions). Hence, the first row see the rotor in a very different position than the last row. As a result, the rotor appeaars to shred and bend. The exact nature of the artifacts change depending on the relative speed of the object (in this case, the rotor) and the line read out rate.

Important Files

This section highlights key files important to the simulation.

The Helicopter

The helicopter is setup using the GLIST wrapper helicopter_delta.glist. This wrapper combines a static instance of the "base helicopter" object (all the geometry except the rotor) with a second object (the rotor blades) that uses the DeltaMotion model to rotate the blades. The contents of the helicopter_delta.glist are shown below:

<geometrylist>
  <object>
    <basegeometry>
      <obj>
        <filename>helicopter_base.obj</filename>
        <assign name="paint" id="2">default</assign>
      </obj>
    </basegeometry>
    <staticinstance>
      <rotation>
        <cartesiantriple><x>0</x><y>0</y><z>1.5707</z></cartesiantriple>
      </rotation>
    </staticinstance>
  </object>
  <object>
    <basegeometry>
      <obj>
        <filename>helicopter_blades.obj</filename>
        <assign name="paint" id="2">default</assign>
      </obj>
    </basegeometry>
    <dynamicinstance>
      <motion type="delta">
        <filename>helicopter_blades.mov</filename>
      </motion>
    </dynamicinstance>
  </object>
</geometrylist>

Note how the each OBJ file uses the GLIST <assign> option to attribute the geometry. The motion for the helicopter blades is described in the geometry/helicopter_blades.mov file. The INIT_POSITION defines a TRANSLATION that moves the origin of blades OBJ file to be at the top of the helicopter. Remember that the DeltaMotion model only lets you add 180 degrees of rotation per time step to avoid ambiguities. In this MOV file, the 500 RPM motion is represented by a series of entries describing an additional 90 degrees of rotation every 0.0005 seconds. Since the array is going to collect data for 2.4 milliseconds, These 0.0005 second MOVE intervals are repeated 2,000 times, thereby defining 1 full second of motion. The MOV file has an inital translation to place the rotor blades at the top of the helicopter.

DIRSIG_MOV = 1.0

OPTIONS {
    START_HIDDEN = FALSE
    END_HIDDEN = FALSE
}

INIT_POSITION {
    TRANSLATION = 7.0, 0.0, 6.0
    SCALE       = 1.0, 1.0, 1.0
    ROTATION    = 0.0, 0.0, 0.0
}

MOVES {
    # 500 RPM = 2PI in 0.002 seconds
    MOVE = 0.0005, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.5707
    MOVE = 0.0005, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.5707
    ...
    MOVE = 0.0005, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.5707
}
Important
 This constant angular rotation can be more easily represented using the FlexMotion spin orientation engine.

The Platform

The platform for this demo contains a single instrument with a single focal plane. However, this focal plane uses two advanced features:

  1. The integration time is defined

  2. The rolling shutter line readout time delay is defined

Note
 Both of these option were only available as hand-edits to the DIRSIG .platform file until the 4.7.3 release when interfaces were added on the Clock tab of the Focal Plane Editor.

The focal plane clock is setup to start a readout on a 400 Hz (2.5 millisecond) interval. The integration time is set to 50 microseconds and uses 40 time steps to sample within that time interval. Due to the speed of the rotor, less than 40 steps results in an aliased sampling of the blade rotation. This temporal integration parameters can be found within the <capturemethod> element for the focal plane:

              <temporalintegration>
                <time>5e-05</time>
                <samples>40</samples>
              </temporalintegration>

The per line rolling shutter readout time was set to 10 microseconds. This parameter is assigned to the <detectorarray> in the focal plane:

            <detectorarray spatialunits="microns" rollingreadout="1e-05">
              <clock type="independent" temporalunits="hertz">
                <rate>20</rate>
              </clock>
              ...
            </detectorarray>

With this configuration, the array read out will begin every 2.5 milliseconds. At the start of an array readout the first line will integrate for 0.05 milliseconds and then be read. Since the next line is read every 0.01 milliseconds, there is 0.05 milliseconds of dead time between when the current line is done integrating and the next line is read.

Note
 The point of a rolling shutter is to let each line integrate for a period of time closer to the readout rate than a global shutter readout would normally allow. In this example, if takes 2.4 milliseconds to readout the array and the readout interval is 2.5 milliseconds, than the integration time could only be 0.1 milliseconds for the whole array. With the rolling shutter, every pixel can integrate for up to 2.4 milliseconds, or 24x longer than the global shutter approach.

Setup

This section includes any step-by-step instructions for running and visualizing the simulation.

To run the simulation, perform the following steps:

  1. Run the DIRSIG demo_delta.sim file

  2. Load the resulting demo.img radiance file in the image viewer.

Results

The static image belowe shows the blade artifacts from the rolling shutter and blur from the temporal integration.

demo.png
Figure 1. Output of the single-frame simulation.
video.gif
Figure 2. Output of the multi-frame simulation.