ReadClipper (gatk 4.1.7.0 API)

java.lang.Object
- org.broadinstitute.hellbender.utils.clipping.ReadClipper

Direct Known Subclasses:

ClipReads.ReadClipperWithData
```
public class ReadClipper
extends java.lang.Object
```
A comprehensive clipping tool. General Contract: - All clipping operations return a new read with the clipped bases requested, it never modifies the original read. - If a read is fully clipped, return an empty SAMRecord, never null. - When hard clipping, add cigar operator H for every *reference base* removed (i.e. Matches, SoftClips and Deletions, but *not* insertions). See Hard Clipping notes for details. There are several types of clipping to use: Write N's: Change the bases to N's in the desired region. This can be applied anywhere in the read. Write Q0's: Change the quality of the bases in the desired region to Q0. This can be applied anywhere in the read. Write both N's and Q0's: Same as the two independent operations, put together. Soft Clipping: Do not change the read, just mark the reads as soft clipped in the Cigar String and adjust the alignment start and end of the read. Hard Clipping: Creates a new read without the hard clipped bases (and base qualities). The cigar string will be updated with the cigar operator H for every reference base removed (i.e. Matches, Soft clipped bases and deletions, but *not* insertions). This contract with the cigar is necessary to allow read.getUnclippedStart() / End() to recover the original alignment of the read (before clipping).

Constructor Summary

Constructors
Constructor and Description

ReadClipper(GATKRead read)
Initializes a ReadClipper object.

Constructors
Constructor and Description
`ReadClipper(GATKRead read)` Initializes a ReadClipper object.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addOp(ClippingOp op)` Add clipping operation to the read.
`protected GATKRead`	`clipByReferenceCoordinates(int refStart, int refStop, ClippingRepresentation clippingOp)` Generic functionality to clip a read, used internally by hardClipByReferenceCoordinatesLeftTail and hardClipByReferenceCoordinatesRightTail.
`static GATKRead`	`clipLowQualEnds(GATKRead read, byte lowQual, ClippingRepresentation algorithm)`
`GATKRead`	`clipRead(ClippingRepresentation algorithm)` Clips a read according to ops and the chosen algorithm.
`java.util.List<ClippingOp>`	`getOps()` Check the list of operations set up for this read.
`GATKRead`	`getRead()` The original read.
`static GATKRead`	`hardClipAdaptorSequence(GATKRead read)`
`static GATKRead`	`hardClipBothEndsByReferenceCoordinates(GATKRead read, int left, int right)`
`protected GATKRead`	`hardClipByReferenceCoordinates(int refStart, int refStop)`
`static GATKRead`	`hardClipByReferenceCoordinatesLeftTail(GATKRead read, int refStop)`
`static GATKRead`	`hardClipByReferenceCoordinatesRightTail(GATKRead read, int refStart)`
`static GATKRead`	`hardClipLowQualEnds(GATKRead read, byte lowQual)`
`static GATKRead`	`hardClipSoftClippedBases(GATKRead read)`
`static GATKRead`	`hardClipToRegion(GATKRead read, int refStart, int refStop)` Hard clip the read to the variable region (from refStart to refStop)
`static GATKRead`	`revertSoftClippedBases(GATKRead read)` Reverts ALL soft-clipped bases
`static GATKRead`	`softClipBothEndsByReferenceCoordinates(GATKRead read, int left, int right)`
`static GATKRead`	`softClipByReadCoordinates(GATKRead read, int start, int stop)`
`protected GATKRead`	`softClipByReferenceCoordinates(int refStart, int refStop)` Generic functionality to soft clip a read (is analogous to hardClipByReferenceCoordinates()) Note, it REQUIRES you to give the directionality of your soft clip (i.e.
`static GATKRead`	`softClipToRegionIncludingClippedBases(GATKRead read, int refStart, int refStop)` Soft clip the read to the variable region (from refStart to refStop) processing also the clipped bases
`boolean`	`wasClipped()` Check whether or not this read has been clipped.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - ReadClipper
```
public ReadClipper(GATKRead read)
```
    Initializes a ReadClipper object. You can set up your clipping operations using the addOp method. When you're ready to generate a new read with all the clipping operations, use clipRead(). Note: Use this if you want to set up multiple operations on the read using the ClippingOp class. If you just want to apply one of the typical modes of clipping, use the static clipping functions available in this class instead.
    
    Parameters:
    
    read - the read to clip
- Method Detail
  - addOp
```
public void addOp(ClippingOp op)
```
    Add clipping operation to the read. You can add as many operations as necessary to this read before clipping. Beware that the order in which you add these operations matter. For example, if you hard clip the beginning of a read first then try to hard clip the end, the indices will have changed. Make sure you know what you're doing, otherwise just use the static functions below that take care of the ordering for you. Note: You only choose the clipping mode when you use clipRead()
    
    Parameters:
    
    op - a ClippingOp object describing the area you want to clip.
  - getOps
```
public java.util.List<ClippingOp> getOps()
```
    Check the list of operations set up for this read.
    
    Returns:
    
    a list of the operations set up for this read.
  - wasClipped
```
public boolean wasClipped()
```
    Check whether or not this read has been clipped.
    
    Returns:
    
    true if this read has produced a clipped read, false otherwise.
  - getRead
```
public GATKRead getRead()
```
    The original read.
    
    Returns:
    
    returns the read to be clipped (original)
  - clipRead
```
public GATKRead clipRead(ClippingRepresentation algorithm)
```
    Clips a read according to ops and the chosen algorithm.
    
    Parameters:
    
    algorithm - What mode of clipping do you want to apply for the stacked operations.
    
    Returns:
    
    the read with the clipping applied (Could be an empty, unmapped read if the clip removed all bases)
  - hardClipByReferenceCoordinatesLeftTail
```
public static GATKRead hardClipByReferenceCoordinatesLeftTail(GATKRead read,
                                                              int refStop)
```
  - hardClipByReferenceCoordinatesRightTail
```
public static GATKRead hardClipByReferenceCoordinatesRightTail(GATKRead read,
                                                               int refStart)
```
  - hardClipBothEndsByReferenceCoordinates
```
public static GATKRead hardClipBothEndsByReferenceCoordinates(GATKRead read,
                                                              int left,
                                                              int right)
```
  - clipLowQualEnds
```
public static GATKRead clipLowQualEnds(GATKRead read,
                                       byte lowQual,
                                       ClippingRepresentation algorithm)
```
  - hardClipLowQualEnds
```
public static GATKRead hardClipLowQualEnds(GATKRead read,
                                           byte lowQual)
```
  - hardClipSoftClippedBases
```
public static GATKRead hardClipSoftClippedBases(GATKRead read)
```
  - hardClipToRegion
```
public static GATKRead hardClipToRegion(GATKRead read,
                                        int refStart,
                                        int refStop)
```
    Hard clip the read to the variable region (from refStart to refStop)
    
    Parameters:
    
    read - the read to be clipped
    
    refStart - the beginning of the variant region (inclusive)
    
    refStop - the end of the variant region (inclusive)
    
    Returns:
    
    the read hard clipped to the variant region (Could return an empty, unmapped read)
  - hardClipAdaptorSequence
```
public static GATKRead hardClipAdaptorSequence(GATKRead read)
```
  - revertSoftClippedBases
```
public static GATKRead revertSoftClippedBases(GATKRead read)
```
    Reverts ALL soft-clipped bases
    
    Parameters:
    
    read - the read
    
    Returns:
    
    the read with all soft-clipped bases turned into matches (May return empty, unclipped reads close to the beginning of a contig)
  - hardClipByReferenceCoordinates
```
protected GATKRead hardClipByReferenceCoordinates(int refStart,
                                                  int refStop)
```
  - clipByReferenceCoordinates
```
protected GATKRead clipByReferenceCoordinates(int refStart,
                                              int refStop,
                                              ClippingRepresentation clippingOp)
```
    Generic functionality to clip a read, used internally by hardClipByReferenceCoordinatesLeftTail and hardClipByReferenceCoordinatesRightTail. Should not be used directly. Note, it REQUIRES you to give the directionality of your hard clip (i.e. whether you're clipping the left of right tail) by specifying either refStart < 0 or refStop < 0.
    
    Parameters:
    
    refStart - first base to clip (inclusive)
    
    refStop - last base to clip (inclusive)
    
    clippingOp - clipping operation to be performed
    
    Returns:
    
    a new read, without the clipped bases (May return empty, unclipped reads)
  - softClipToRegionIncludingClippedBases
```
public static GATKRead softClipToRegionIncludingClippedBases(GATKRead read,
                                                             int refStart,
                                                             int refStop)
```
    Soft clip the read to the variable region (from refStart to refStop) processing also the clipped bases
    
    Parameters:
    
    read - the read to be clipped
    
    refStart - the beginning of the variant region (inclusive)
    
    refStop - the end of the variant region (inclusive)
    
    Returns:
    
    the read soft clipped to the variant region (May return empty, unclipped reads)
  - softClipBothEndsByReferenceCoordinates
```
public static GATKRead softClipBothEndsByReferenceCoordinates(GATKRead read,
                                                              int left,
                                                              int right)
```
  - softClipByReferenceCoordinates
```
protected GATKRead softClipByReferenceCoordinates(int refStart,
                                                  int refStop)
```
    Generic functionality to soft clip a read (is analogous to hardClipByReferenceCoordinates()) Note, it REQUIRES you to give the directionality of your soft clip (i.e. whether you're clipping the left of right tail) by specifying either refStart < 0 or refStop < 0.
    
    Parameters:
    
    refStart - first base to clip (inclusive)
    
    refStop - last base to clip (inclusive)
    
    Returns:
    
    a new read, with the soft clipped bases
  - softClipByReadCoordinates
```
public static GATKRead softClipByReadCoordinates(GATKRead read,
                                                 int start,
                                                 int stop)
```

Class ReadClipper

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

ReadClipper

Method Detail

addOp

getOps

wasClipped

getRead

clipRead

hardClipByReferenceCoordinatesLeftTail

hardClipByReferenceCoordinatesRightTail

hardClipBothEndsByReferenceCoordinates

clipLowQualEnds

hardClipLowQualEnds

hardClipSoftClippedBases

hardClipToRegion

hardClipAdaptorSequence

revertSoftClippedBases

hardClipByReferenceCoordinates

clipByReferenceCoordinates

softClipToRegionIncludingClippedBases

softClipBothEndsByReferenceCoordinates

softClipByReferenceCoordinates

softClipByReadCoordinates