java.lang.Object
- java.lang.Thread
- - gov.nih.mipav.model.algorithms.AlgorithmBase
  - - gov.nih.mipav.model.algorithms.AlgorithmFRETAcceptorPhotobleach

All Implemented Interfaces:

java.awt.event.ActionListener, java.awt.event.WindowListener, java.lang.Runnable, java.util.EventListener
```
public class AlgorithmFRETAcceptorPhotobleach
extends AlgorithmBase
```
Fluorescence Resonance Energy Transfer FRET refers to the nonradiative transfer of energy from an excited state donor fluorescent molecule to a nearby acceptor fluorescent molecule. The energy transfer efficiency E, defined as the number of energy transfer events divided by the number of photons absorbed by the donor, is related to the distance R between the acceptor and donor by: E = 1/[1 + (r/R0)**6] (eq. 1) where R0, the Forster critical distance, is the distance at which E = 0.5. We also have E = 1 - FDA/FD, (eq. 2) where FDA is the donor fluorescence in the presence of an acceptor and FD is the donor fluorescence in the absence of the acceptor. The equivalent of an acceptor's absence can be created by photobleaching the acceptor. Thus, a method using equation 2, can be performed on a single sample by measuring the donor fluorescence before and after photobleaching the acceptor molecules.
Because FRET falls off as the sixth power of the distance between the donor and the acceptor, no FRET occurs for distances greater than 2R0. Since R0 is on the order of 10 to 70 Angstroms, by performing FRET measurements it is possible to distinguish proteins that are merely nearby in the same compartment from those proteins that are interacting with each other.

This program compares the fluorescence of two 2D images or of two 2D slices inside a 2 slice 3D image - an image before acceptor photobleaching and an image after acceptor photobleaching. In the 3D image the prebleached slice is required to be the first slice and the postbleached slice is required to be the second slice. Before acceptor photobleaching, the donor fluorescence is quenched by FRET with the unbleached acceptor. After destroying the acceptor by photobleaching, the donor fluorescence will increase. Only 1 color will be used from a color image.

An optional registration may be performed before FRET. In this registration the prebleached image is registered to the postbleached image. AlgorithmRegOAR2D is used with the cost function being the only registration parameter the user can vary in the dialog box. Correlation ratio is the default cost function, but the user can also select least squares, normalized cross correlation, or normalized mutual information. The FRET will be performed with the registered prebleached image rather than on the original prebleached image. If the image is a color image, the selected color will determine the transformations for all the colors.

The code here assumes the presence of 1 or 2 or 3 VOI regions - a required donor region and optional background region and optional signal normalization region. The VOIs must all be placed in the postbleached image. Radio buttons in the dialog box are used to select a red photobleached or a blue background VOI or a green signal VOI. Either an ellipse VOI, rectangle VOI, or polyline VOI will be selected from the top MIPAV toolbar. There is no need to hit the NEW_VOI button. The background region will have a smaller average intensity than the donor region.

If a background VOI is present, the average of the prebleached background is subtracted from the average of the prebleached donor region and the average of the postbleached background is subtracted is subtracted from the average of the postbleached donor region. Then, the energy transfer efficiency is calculated as (background subtracted postbleached donor intensity - (background subtracted prebleached donor intensity)/ background subtracted postbleached donor intensity

A signal VOI cannot be used unless a background VOI is also present. Let b1 and s1 be the prebleached values and b2 and s2 be the postbleached values. The following equation is used to convert a donor value from the prebleached image into a donor value on the postbleached image: postbleached = ((s2 - b2)/(s1 - b1)) * prebleached + (b2*s1 - b1*s2)/(s1 - b1)

Reference: 1.) "Imaging Protein-Protein Interactions Using Fluorescence Energy Transfer Microscopy" by Anne K. Kenworthy, Methods, 24, 2001, pp. 289 - 296.

2.) "Quantitative Fluorescence Resonance Energy Transfer Measurements Using Fluorescence Microscopy" by Gerald W. Gordon, Gail Berry, Xiao Huan Liang, Beth Levine, and Brian Herman, Biophysical Journal, Volume 74, May, 1998, pp. 2702-2713.

Nested Class Summary
- Nested classes/interfaces inherited from class java.lang.Thread
  java.lang.Thread.State, java.lang.Thread.UncaughtExceptionHandler

Field Summary

Fields
Modifier and Type	Field	Description
`private int`	`backgroundIndex`	DOCUMENT ME!
`private int`	`cost`	DOCUMENT ME!
`private boolean`	`createRegImage`	DOCUMENT ME!
`private int`	`donorIndex`	DOCUMENT ME!
`private ModelImage`	`postImage`	private ModelImage srcImage; // image before acceptor photobleaching.
`private boolean`	`register`	DOCUMENT ME!
`private int`	`signalIndex`	DOCUMENT ME!
`private boolean`	`useBlue`	DOCUMENT ME!
`private boolean`	`useGreen`	DOCUMENT ME!
`private boolean`	`useRed`	DOCUMENT ME!

Fields inherited from class gov.nih.mipav.model.algorithms.AlgorithmBase
destFlag, destImage, image25D, mask, maxProgressValue, minProgressValue, multiThreadingEnabled, nthreads, progress, progressModulus, progressStep, runningInSeparateThread, separable, srcImage, threadStopped

Fields inherited from class java.lang.Thread
MAX_PRIORITY, MIN_PRIORITY, NORM_PRIORITY

Constructor Summary

Constructors
Constructor	Description
`AlgorithmFRETAcceptorPhotobleach(ModelImage preImage, ModelImage postImage, boolean useRed, boolean useGreen, boolean useBlue, int donorIndex, int backgroundIndex, int signalIndex, boolean register, int cost, boolean createRegImage)`	Creates a new AlgorithmFRETAcceptorPhotobleach object.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type Method Description

void finalize()
Prepares this class for destruction.

void runAlgorithm()
starts the algorithm.
- Methods inherited from class gov.nih.mipav.model.algorithms.AlgorithmBase
  actionPerformed, addListener, addProgressChangeListener, calculateImageSize, calculatePrincipleAxis, computeElapsedTime, computeElapsedTime, convertIntoFloat, delinkProgressToAlgorithm, delinkProgressToAlgorithmMulti, displayError, errorCleanUp, fireProgressStateChanged, fireProgressStateChanged, fireProgressStateChanged, fireProgressStateChanged, fireProgressStateChanged, generateProgressValues, getDestImage, getElapsedTime, getMask, getMaxProgressValue, getMinProgressValue, getNumberOfThreads, getProgress, getProgressChangeListener, getProgressChangeListeners, getProgressModulus, getProgressStep, getProgressValues, getSrcImage, isCompleted, isImage25D, isMultiThreadingEnabled, isRunningInSeparateThread, isThreadStopped, linkProgressToAlgorithm, linkProgressToAlgorithm, makeProgress, notifyListeners, removeListener, removeProgressChangeListener, run, setCompleted, setImage25D, setMask, setMaxProgressValue, setMinProgressValue, setMultiThreadingEnabled, setNumberOfThreads, setProgress, setProgressModulus, setProgressStep, setProgressValues, setProgressValues, setRunningInSeparateThread, setSrcImage, setStartTime, setThreadStopped, startMethod, windowActivated, windowClosed, windowClosing, windowDeactivated, windowDeiconified, windowIconified, windowOpened
- Methods inherited from class java.lang.Thread
  activeCount, checkAccess, clone, countStackFrames, currentThread, dumpStack, enumerate, getAllStackTraces, getContextClassLoader, getDefaultUncaughtExceptionHandler, getId, getName, getPriority, getStackTrace, getState, getThreadGroup, getUncaughtExceptionHandler, holdsLock, interrupt, interrupted, isAlive, isDaemon, isInterrupted, join, join, join, onSpinWait, resume, setContextClassLoader, setDaemon, setDefaultUncaughtExceptionHandler, setName, setPriority, setUncaughtExceptionHandler, sleep, sleep, start, stop, suspend, toString, yield
- Methods inherited from class java.lang.Object
  equals, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Field Detail
  - backgroundIndex
```
private int backgroundIndex
```
    DOCUMENT ME!
  - cost
```
private int cost
```
    DOCUMENT ME!
  - createRegImage
```
private boolean createRegImage
```
    DOCUMENT ME!
  - donorIndex
```
private int donorIndex
```
    DOCUMENT ME!
  - postImage
```
private ModelImage postImage
```
    private ModelImage srcImage; // image before acceptor photobleaching.
  - register
```
private boolean register
```
    DOCUMENT ME!
  - signalIndex
```
private int signalIndex
```
    DOCUMENT ME!
  - useBlue
```
private boolean useBlue
```
    DOCUMENT ME!
  - useGreen
```
private boolean useGreen
```
    DOCUMENT ME!
  - useRed
```
private boolean useRed
```
    DOCUMENT ME!
- Constructor Detail
  - AlgorithmFRETAcceptorPhotobleach
```
public AlgorithmFRETAcceptorPhotobleach(ModelImage preImage,
                                        ModelImage postImage,
                                        boolean useRed,
                                        boolean useGreen,
                                        boolean useBlue,
                                        int donorIndex,
                                        int backgroundIndex,
                                        int signalIndex,
                                        boolean register,
                                        int cost,
                                        boolean createRegImage)
```
    Creates a new AlgorithmFRETAcceptorPhotobleach object.
    
    Parameters:
    
    preImage - image before acceptor photobleaching or 2 slice 3D image
    
    postImage - image after acceptor photobleaching null if 3D image is used
    
    useRed - If true, use the red color values for the FRET
    
    useGreen - If true, use the green color values for the FRET
    
    useBlue - If true, use the blue color values for the FRET
    
    donorIndex - the index of the donor VOI
    
    backgroundIndex - the index of the background VOI if >= 0
    
    signalIndex - the index of the signal normalization VOI if >= 0
    
    register - If true register the preImage to the postImage before FRET
    
    cost - Cost function used in registration
    
    createRegImage - If register = true and createRegImage = true, then create a frame with the registered image
- Method Detail
  - finalize
```
public void finalize()
```
    Prepares this class for destruction.
    
    Overrides:
    
    finalize in class AlgorithmBase
  - runAlgorithm
```
public void runAlgorithm()
```
    starts the algorithm.
    
    Specified by:
    
    runAlgorithm in class AlgorithmBase

Modifier and Type	Method	Description
`void`	`finalize()`	Prepares this class for destruction.
`void`	`runAlgorithm()`	starts the algorithm.

Class AlgorithmFRETAcceptorPhotobleach

Nested Class Summary

Nested classes/interfaces inherited from class java.lang.Thread

Field Summary

Fields inherited from class gov.nih.mipav.model.algorithms.AlgorithmBase

Fields inherited from class java.lang.Thread

Constructor Summary

Method Summary

Methods inherited from class gov.nih.mipav.model.algorithms.AlgorithmBase

Methods inherited from class java.lang.Thread

Methods inherited from class java.lang.Object

Field Detail

backgroundIndex

cost

createRegImage

donorIndex

postImage

register

signalIndex

useBlue

useGreen

useRed

Constructor Detail

AlgorithmFRETAcceptorPhotobleach

Method Detail

finalize

runAlgorithm