\s*$/g;
+
+// Prefer a tbody over its parent table for containing new rows
+function manipulationTarget( elem, content ) {
+ if ( nodeName( elem, "table" ) &&
+ nodeName( content.nodeType !== 11 ? content : content.firstChild, "tr" ) ) {
+
+ return jQuery( elem ).children( "tbody" )[ 0 ] || elem;
+ }
+
+ return elem;
+}
+
+// Replace/restore the type attribute of script elements for safe DOM manipulation
+function disableScript( elem ) {
+ elem.type = ( elem.getAttribute( "type" ) !== null ) + "/" + elem.type;
+ return elem;
+}
+function restoreScript( elem ) {
+ if ( ( elem.type || "" ).slice( 0, 5 ) === "true/" ) {
+ elem.type = elem.type.slice( 5 );
+ } else {
+ elem.removeAttribute( "type" );
+ }
+
+ return elem;
+}
+
+function cloneCopyEvent( src, dest ) {
+ var i, l, type, pdataOld, udataOld, udataCur, events;
+
+ if ( dest.nodeType !== 1 ) {
+ return;
+ }
+
+ // 1. Copy private data: events, handlers, etc.
+ if ( dataPriv.hasData( src ) ) {
+ pdataOld = dataPriv.get( src );
+ events = pdataOld.events;
+
+ if ( events ) {
+ dataPriv.remove( dest, "handle events" );
+
+ for ( type in events ) {
+ for ( i = 0, l = events[ type ].length; i < l; i++ ) {
+ jQuery.event.add( dest, type, events[ type ][ i ] );
+ }
+ }
+ }
+ }
+
+ // 2. Copy user data
+ if ( dataUser.hasData( src ) ) {
+ udataOld = dataUser.access( src );
+ udataCur = jQuery.extend( {}, udataOld );
+
+ dataUser.set( dest, udataCur );
+ }
+}
+
+// Fix IE bugs, see support tests
+function fixInput( src, dest ) {
+ var nodeName = dest.nodeName.toLowerCase();
+
+ // Fails to persist the checked state of a cloned checkbox or radio button.
+ if ( nodeName === "input" && rcheckableType.test( src.type ) ) {
+ dest.checked = src.checked;
+
+ // Fails to return the selected option to the default selected state when cloning options
+ } else if ( nodeName === "input" || nodeName === "textarea" ) {
+ dest.defaultValue = src.defaultValue;
+ }
+}
+
+function domManip( collection, args, callback, ignored ) {
+
+ // Flatten any nested arrays
+ args = flat( args );
+
+ var fragment, first, scripts, hasScripts, node, doc,
+ i = 0,
+ l = collection.length,
+ iNoClone = l - 1,
+ value = args[ 0 ],
+ valueIsFunction = isFunction( value );
+
+ // We can't cloneNode fragments that contain checked, in WebKit
+ if ( valueIsFunction ||
+ ( l > 1 && typeof value === "string" &&
+ !support.checkClone && rchecked.test( value ) ) ) {
+ return collection.each( function( index ) {
+ var self = collection.eq( index );
+ if ( valueIsFunction ) {
+ args[ 0 ] = value.call( this, index, self.html() );
+ }
+ domManip( self, args, callback, ignored );
+ } );
+ }
+
+ if ( l ) {
+ fragment = buildFragment( args, collection[ 0 ].ownerDocument, false, collection, ignored );
+ first = fragment.firstChild;
+
+ if ( fragment.childNodes.length === 1 ) {
+ fragment = first;
+ }
+
+ // Require either new content or an interest in ignored elements to invoke the callback
+ if ( first || ignored ) {
+ scripts = jQuery.map( getAll( fragment, "script" ), disableScript );
+ hasScripts = scripts.length;
+
+ // Use the original fragment for the last item
+ // instead of the first because it can end up
+ // being emptied incorrectly in certain situations (#8070).
+ for ( ; i < l; i++ ) {
+ node = fragment;
+
+ if ( i !== iNoClone ) {
+ node = jQuery.clone( node, true, true );
+
+ // Keep references to cloned scripts for later restoration
+ if ( hasScripts ) {
+
+ // Support: Android <=4.0 only, PhantomJS 1 only
+ // push.apply(_, arraylike) throws on ancient WebKit
+ jQuery.merge( scripts, getAll( node, "script" ) );
+ }
+ }
+
+ callback.call( collection[ i ], node, i );
+ }
+
+ if ( hasScripts ) {
+ doc = scripts[ scripts.length - 1 ].ownerDocument;
+
+ // Reenable scripts
+ jQuery.map( scripts, restoreScript );
+
+ // Evaluate executable scripts on first document insertion
+ for ( i = 0; i < hasScripts; i++ ) {
+ node = scripts[ i ];
+ if ( rscriptType.test( node.type || "" ) &&
+ !dataPriv.access( node, "globalEval" ) &&
+ jQuery.contains( doc, node ) ) {
+
+ if ( node.src && ( node.type || "" ).toLowerCase() !== "module" ) {
+
+ // Optional AJAX dependency, but won't run scripts if not present
+ if ( jQuery._evalUrl && !node.noModule ) {
+ jQuery._evalUrl( node.src, {
+ nonce: node.nonce || node.getAttribute( "nonce" )
+ }, doc );
+ }
+ } else {
+ DOMEval( node.textContent.replace( rcleanScript, "" ), node, doc );
+ }
+ }
+ }
+ }
+ }
+ }
+
+ return collection;
+}
+
+function remove( elem, selector, keepData ) {
+ var node,
+ nodes = selector ? jQuery.filter( selector, elem ) : elem,
+ i = 0;
+
+ for ( ; ( node = nodes[ i ] ) != null; i++ ) {
+ if ( !keepData && node.nodeType === 1 ) {
+ jQuery.cleanData( getAll( node ) );
+ }
+
+ if ( node.parentNode ) {
+ if ( keepData && isAttached( node ) ) {
+ setGlobalEval( getAll( node, "script" ) );
+ }
+ node.parentNode.removeChild( node );
+ }
+ }
+
+ return elem;
+}
+
+jQuery.extend( {
+ htmlPrefilter: function( html ) {
+ return html;
+ },
+
+ clone: function( elem, dataAndEvents, deepDataAndEvents ) {
+ var i, l, srcElements, destElements,
+ clone = elem.cloneNode( true ),
+ inPage = isAttached( elem );
+
+ // Fix IE cloning issues
+ if ( !support.noCloneChecked && ( elem.nodeType === 1 || elem.nodeType === 11 ) &&
+ !jQuery.isXMLDoc( elem ) ) {
+
+ // We eschew Sizzle here for performance reasons: https://jsperf.com/getall-vs-sizzle/2
+ destElements = getAll( clone );
+ srcElements = getAll( elem );
+
+ for ( i = 0, l = srcElements.length; i < l; i++ ) {
+ fixInput( srcElements[ i ], destElements[ i ] );
+ }
+ }
+
+ // Copy the events from the original to the clone
+ if ( dataAndEvents ) {
+ if ( deepDataAndEvents ) {
+ srcElements = srcElements || getAll( elem );
+ destElements = destElements || getAll( clone );
+
+ for ( i = 0, l = srcElements.length; i < l; i++ ) {
+ cloneCopyEvent( srcElements[ i ], destElements[ i ] );
+ }
+ } else {
+ cloneCopyEvent( elem, clone );
+ }
+ }
+
+ // Preserve script evaluation history
+ destElements = getAll( clone, "script" );
+ if ( destElements.length > 0 ) {
+ setGlobalEval( destElements, !inPage && getAll( elem, "script" ) );
+ }
+
+ // Return the cloned set
+ return clone;
+ },
+
+ cleanData: function( elems ) {
+ var data, elem, type,
+ special = jQuery.event.special,
+ i = 0;
+
+ for ( ; ( elem = elems[ i ] ) !== undefined; i++ ) {
+ if ( acceptData( elem ) ) {
+ if ( ( data = elem[ dataPriv.expando ] ) ) {
+ if ( data.events ) {
+ for ( type in data.events ) {
+ if ( special[ type ] ) {
+ jQuery.event.remove( elem, type );
+
+ // This is a shortcut to avoid jQuery.event.remove's overhead
+ } else {
+ jQuery.removeEvent( elem, type, data.handle );
+ }
+ }
+ }
+
+ // Support: Chrome <=35 - 45+
+ // Assign undefined instead of using delete, see Data#remove
+ elem[ dataPriv.expando ] = undefined;
+ }
+ if ( elem[ dataUser.expando ] ) {
+
+ // Support: Chrome <=35 - 45+
+ // Assign undefined instead of using delete, see Data#remove
+ elem[ dataUser.expando ] = undefined;
+ }
+ }
+ }
+ }
+} );
+
+jQuery.fn.extend( {
+ detach: function( selector ) {
+ return remove( this, selector, true );
+ },
+
+ remove: function( selector ) {
+ return remove( this, selector );
+ },
+
+ text: function( value ) {
+ return access( this, function( value ) {
+ return value === undefined ?
+ jQuery.text( this ) :
+ this.empty().each( function() {
+ if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
+ this.textContent = value;
+ }
+ } );
+ }, null, value, arguments.length );
+ },
+
+ append: function() {
+ return domManip( this, arguments, function( elem ) {
+ if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
+ var target = manipulationTarget( this, elem );
+ target.appendChild( elem );
+ }
+ } );
+ },
+
+ prepend: function() {
+ return domManip( this, arguments, function( elem ) {
+ if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
+ var target = manipulationTarget( this, elem );
+ target.insertBefore( elem, target.firstChild );
+ }
+ } );
+ },
+
+ before: function() {
+ return domManip( this, arguments, function( elem ) {
+ if ( this.parentNode ) {
+ this.parentNode.insertBefore( elem, this );
+ }
+ } );
+ },
+
+ after: function() {
+ return domManip( this, arguments, function( elem ) {
+ if ( this.parentNode ) {
+ this.parentNode.insertBefore( elem, this.nextSibling );
+ }
+ } );
+ },
+
+ empty: function() {
+ var elem,
+ i = 0;
+
+ for ( ; ( elem = this[ i ] ) != null; i++ ) {
+ if ( elem.nodeType === 1 ) {
+
+ // Prevent memory leaks
+ jQuery.cleanData( getAll( elem, false ) );
+
+ // Remove any remaining nodes
+ elem.textContent = "";
+ }
+ }
+
+ return this;
+ },
+
+ clone: function( dataAndEvents, deepDataAndEvents ) {
+ dataAndEvents = dataAndEvents == null ? false : dataAndEvents;
+ deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;
+
+ return this.map( function() {
+ return jQuery.clone( this, dataAndEvents, deepDataAndEvents );
+ } );
+ },
+
+ html: function( value ) {
+ return access( this, function( value ) {
+ var elem = this[ 0 ] || {},
+ i = 0,
+ l = this.length;
+
+ if ( value === undefined && elem.nodeType === 1 ) {
+ return elem.innerHTML;
+ }
+
+ // See if we can take a shortcut and just use innerHTML
+ if ( typeof value === "string" && !rnoInnerhtml.test( value ) &&
+ !wrapMap[ ( rtagName.exec( value ) || [ "", "" ] )[ 1 ].toLowerCase() ] ) {
+
+ value = jQuery.htmlPrefilter( value );
+
+ try {
+ for ( ; i < l; i++ ) {
+ elem = this[ i ] || {};
+
+ // Remove element nodes and prevent memory leaks
+ if ( elem.nodeType === 1 ) {
+ jQuery.cleanData( getAll( elem, false ) );
+ elem.innerHTML = value;
+ }
+ }
+
+ elem = 0;
+
+ // If using innerHTML throws an exception, use the fallback method
+ } catch ( e ) {}
+ }
+
+ if ( elem ) {
+ this.empty().append( value );
+ }
+ }, null, value, arguments.length );
+ },
+
+ replaceWith: function() {
+ var ignored = [];
+
+ // Make the changes, replacing each non-ignored context element with the new content
+ return domManip( this, arguments, function( elem ) {
+ var parent = this.parentNode;
+
+ if ( jQuery.inArray( this, ignored ) < 0 ) {
+ jQuery.cleanData( getAll( this ) );
+ if ( parent ) {
+ parent.replaceChild( elem, this );
+ }
+ }
+
+ // Force callback invocation
+ }, ignored );
+ }
+} );
+
+jQuery.each( {
+ appendTo: "append",
+ prependTo: "prepend",
+ insertBefore: "before",
+ insertAfter: "after",
+ replaceAll: "replaceWith"
+}, function( name, original ) {
+ jQuery.fn[ name ] = function( selector ) {
+ var elems,
+ ret = [],
+ insert = jQuery( selector ),
+ last = insert.length - 1,
+ i = 0;
+
+ for ( ; i <= last; i++ ) {
+ elems = i === last ? this : this.clone( true );
+ jQuery( insert[ i ] )[ original ]( elems );
+
+ // Support: Android <=4.0 only, PhantomJS 1 only
+ // .get() because push.apply(_, arraylike) throws on ancient WebKit
+ push.apply( ret, elems.get() );
+ }
+
+ return this.pushStack( ret );
+ };
+} );
+var rnumnonpx = new RegExp( "^(" + pnum + ")(?!px)[a-z%]+$", "i" );
+
+var getStyles = function( elem ) {
+
+ // Support: IE <=11 only, Firefox <=30 (#15098, #14150)
+ // IE throws on elements created in popups
+ // FF meanwhile throws on frame elements through "defaultView.getComputedStyle"
+ var view = elem.ownerDocument.defaultView;
+
+ if ( !view || !view.opener ) {
+ view = window;
+ }
+
+ return view.getComputedStyle( elem );
+ };
+
+var swap = function( elem, options, callback ) {
+ var ret, name,
+ old = {};
+
+ // Remember the old values, and insert the new ones
+ for ( name in options ) {
+ old[ name ] = elem.style[ name ];
+ elem.style[ name ] = options[ name ];
+ }
+
+ ret = callback.call( elem );
+
+ // Revert the old values
+ for ( name in options ) {
+ elem.style[ name ] = old[ name ];
+ }
+
+ return ret;
+};
+
+
+var rboxStyle = new RegExp( cssExpand.join( "|" ), "i" );
+
+
+
+( function() {
+
+ // Executing both pixelPosition & boxSizingReliable tests require only one layout
+ // so they're executed at the same time to save the second computation.
+ function computeStyleTests() {
+
+ // This is a singleton, we need to execute it only once
+ if ( !div ) {
+ return;
+ }
+
+ container.style.cssText = "position:absolute;left:-11111px;width:60px;" +
+ "margin-top:1px;padding:0;border:0";
+ div.style.cssText =
+ "position:relative;display:block;box-sizing:border-box;overflow:scroll;" +
+ "margin:auto;border:1px;padding:1px;" +
+ "width:60%;top:1%";
+ documentElement.appendChild( container ).appendChild( div );
+
+ var divStyle = window.getComputedStyle( div );
+ pixelPositionVal = divStyle.top !== "1%";
+
+ // Support: Android 4.0 - 4.3 only, Firefox <=3 - 44
+ reliableMarginLeftVal = roundPixelMeasures( divStyle.marginLeft ) === 12;
+
+ // Support: Android 4.0 - 4.3 only, Safari <=9.1 - 10.1, iOS <=7.0 - 9.3
+ // Some styles come back with percentage values, even though they shouldn't
+ div.style.right = "60%";
+ pixelBoxStylesVal = roundPixelMeasures( divStyle.right ) === 36;
+
+ // Support: IE 9 - 11 only
+ // Detect misreporting of content dimensions for box-sizing:border-box elements
+ boxSizingReliableVal = roundPixelMeasures( divStyle.width ) === 36;
+
+ // Support: IE 9 only
+ // Detect overflow:scroll screwiness (gh-3699)
+ // Support: Chrome <=64
+ // Don't get tricked when zoom affects offsetWidth (gh-4029)
+ div.style.position = "absolute";
+ scrollboxSizeVal = roundPixelMeasures( div.offsetWidth / 3 ) === 12;
+
+ documentElement.removeChild( container );
+
+ // Nullify the div so it wouldn't be stored in the memory and
+ // it will also be a sign that checks already performed
+ div = null;
+ }
+
+ function roundPixelMeasures( measure ) {
+ return Math.round( parseFloat( measure ) );
+ }
+
+ var pixelPositionVal, boxSizingReliableVal, scrollboxSizeVal, pixelBoxStylesVal,
+ reliableTrDimensionsVal, reliableMarginLeftVal,
+ container = document.createElement( "div" ),
+ div = document.createElement( "div" );
+
+ // Finish early in limited (non-browser) environments
+ if ( !div.style ) {
+ return;
+ }
+
+ // Support: IE <=9 - 11 only
+ // Style of cloned element affects source element cloned (#8908)
+ div.style.backgroundClip = "content-box";
+ div.cloneNode( true ).style.backgroundClip = "";
+ support.clearCloneStyle = div.style.backgroundClip === "content-box";
+
+ jQuery.extend( support, {
+ boxSizingReliable: function() {
+ computeStyleTests();
+ return boxSizingReliableVal;
+ },
+ pixelBoxStyles: function() {
+ computeStyleTests();
+ return pixelBoxStylesVal;
+ },
+ pixelPosition: function() {
+ computeStyleTests();
+ return pixelPositionVal;
+ },
+ reliableMarginLeft: function() {
+ computeStyleTests();
+ return reliableMarginLeftVal;
+ },
+ scrollboxSize: function() {
+ computeStyleTests();
+ return scrollboxSizeVal;
+ },
+
+ // Support: IE 9 - 11+, Edge 15 - 18+
+ // IE/Edge misreport `getComputedStyle` of table rows with width/height
+ // set in CSS while `offset*` properties report correct values.
+ // Behavior in IE 9 is more subtle than in newer versions & it passes
+ // some versions of this test; make sure not to make it pass there!
+ //
+ // Support: Firefox 70+
+ // Only Firefox includes border widths
+ // in computed dimensions. (gh-4529)
+ reliableTrDimensions: function() {
+ var table, tr, trChild, trStyle;
+ if ( reliableTrDimensionsVal == null ) {
+ table = document.createElement( "table" );
+ tr = document.createElement( "tr" );
+ trChild = document.createElement( "div" );
+
+ table.style.cssText = "position:absolute;left:-11111px;border-collapse:separate";
+ tr.style.cssText = "border:1px solid";
+
+ // Support: Chrome 86+
+ // Height set through cssText does not get applied.
+ // Computed height then comes back as 0.
+ tr.style.height = "1px";
+ trChild.style.height = "9px";
+
+ // Support: Android 8 Chrome 86+
+ // In our bodyBackground.html iframe,
+ // display for all div elements is set to "inline",
+ // which causes a problem only in Android 8 Chrome 86.
+ // Ensuring the div is display: block
+ // gets around this issue.
+ trChild.style.display = "block";
+
+ documentElement
+ .appendChild( table )
+ .appendChild( tr )
+ .appendChild( trChild );
+
+ trStyle = window.getComputedStyle( tr );
+ reliableTrDimensionsVal = ( parseInt( trStyle.height, 10 ) +
+ parseInt( trStyle.borderTopWidth, 10 ) +
+ parseInt( trStyle.borderBottomWidth, 10 ) ) === tr.offsetHeight;
+
+ documentElement.removeChild( table );
+ }
+ return reliableTrDimensionsVal;
+ }
+ } );
+} )();
+
+
+function curCSS( elem, name, computed ) {
+ var width, minWidth, maxWidth, ret,
+
+ // Support: Firefox 51+
+ // Retrieving style before computed somehow
+ // fixes an issue with getting wrong values
+ // on detached elements
+ style = elem.style;
+
+ computed = computed || getStyles( elem );
+
+ // getPropertyValue is needed for:
+ // .css('filter') (IE 9 only, #12537)
+ // .css('--customProperty) (#3144)
+ if ( computed ) {
+ ret = computed.getPropertyValue( name ) || computed[ name ];
+
+ if ( ret === "" && !isAttached( elem ) ) {
+ ret = jQuery.style( elem, name );
+ }
+
+ // A tribute to the "awesome hack by Dean Edwards"
+ // Android Browser returns percentage for some values,
+ // but width seems to be reliably pixels.
+ // This is against the CSSOM draft spec:
+ // https://drafts.csswg.org/cssom/#resolved-values
+ if ( !support.pixelBoxStyles() && rnumnonpx.test( ret ) && rboxStyle.test( name ) ) {
+
+ // Remember the original values
+ width = style.width;
+ minWidth = style.minWidth;
+ maxWidth = style.maxWidth;
+
+ // Put in the new values to get a computed value out
+ style.minWidth = style.maxWidth = style.width = ret;
+ ret = computed.width;
+
+ // Revert the changed values
+ style.width = width;
+ style.minWidth = minWidth;
+ style.maxWidth = maxWidth;
+ }
+ }
+
+ return ret !== undefined ?
+
+ // Support: IE <=9 - 11 only
+ // IE returns zIndex value as an integer.
+ ret + "" :
+ ret;
+}
+
+
+function addGetHookIf( conditionFn, hookFn ) {
+
+ // Define the hook, we'll check on the first run if it's really needed.
+ return {
+ get: function() {
+ if ( conditionFn() ) {
+
+ // Hook not needed (or it's not possible to use it due
+ // to missing dependency), remove it.
+ delete this.get;
+ return;
+ }
+
+ // Hook needed; redefine it so that the support test is not executed again.
+ return ( this.get = hookFn ).apply( this, arguments );
+ }
+ };
+}
+
+
+var cssPrefixes = [ "Webkit", "Moz", "ms" ],
+ emptyStyle = document.createElement( "div" ).style,
+ vendorProps = {};
+
+// Return a vendor-prefixed property or undefined
+function vendorPropName( name ) {
+
+ // Check for vendor prefixed names
+ var capName = name[ 0 ].toUpperCase() + name.slice( 1 ),
+ i = cssPrefixes.length;
+
+ while ( i-- ) {
+ name = cssPrefixes[ i ] + capName;
+ if ( name in emptyStyle ) {
+ return name;
+ }
+ }
+}
+
+// Return a potentially-mapped jQuery.cssProps or vendor prefixed property
+function finalPropName( name ) {
+ var final = jQuery.cssProps[ name ] || vendorProps[ name ];
+
+ if ( final ) {
+ return final;
+ }
+ if ( name in emptyStyle ) {
+ return name;
+ }
+ return vendorProps[ name ] = vendorPropName( name ) || name;
+}
+
+
+var
+
+ // Swappable if display is none or starts with table
+ // except "table", "table-cell", or "table-caption"
+ // See here for display values: https://developer.mozilla.org/en-US/docs/CSS/display
+ rdisplayswap = /^(none|table(?!-c[ea]).+)/,
+ rcustomProp = /^--/,
+ cssShow = { position: "absolute", visibility: "hidden", display: "block" },
+ cssNormalTransform = {
+ letterSpacing: "0",
+ fontWeight: "400"
+ };
+
+function setPositiveNumber( _elem, value, subtract ) {
+
+ // Any relative (+/-) values have already been
+ // normalized at this point
+ var matches = rcssNum.exec( value );
+ return matches ?
+
+ // Guard against undefined "subtract", e.g., when used as in cssHooks
+ Math.max( 0, matches[ 2 ] - ( subtract || 0 ) ) + ( matches[ 3 ] || "px" ) :
+ value;
+}
+
+function boxModelAdjustment( elem, dimension, box, isBorderBox, styles, computedVal ) {
+ var i = dimension === "width" ? 1 : 0,
+ extra = 0,
+ delta = 0;
+
+ // Adjustment may not be necessary
+ if ( box === ( isBorderBox ? "border" : "content" ) ) {
+ return 0;
+ }
+
+ for ( ; i < 4; i += 2 ) {
+
+ // Both box models exclude margin
+ if ( box === "margin" ) {
+ delta += jQuery.css( elem, box + cssExpand[ i ], true, styles );
+ }
+
+ // If we get here with a content-box, we're seeking "padding" or "border" or "margin"
+ if ( !isBorderBox ) {
+
+ // Add padding
+ delta += jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );
+
+ // For "border" or "margin", add border
+ if ( box !== "padding" ) {
+ delta += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
+
+ // But still keep track of it otherwise
+ } else {
+ extra += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
+ }
+
+ // If we get here with a border-box (content + padding + border), we're seeking "content" or
+ // "padding" or "margin"
+ } else {
+
+ // For "content", subtract padding
+ if ( box === "content" ) {
+ delta -= jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );
+ }
+
+ // For "content" or "padding", subtract border
+ if ( box !== "margin" ) {
+ delta -= jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
+ }
+ }
+ }
+
+ // Account for positive content-box scroll gutter when requested by providing computedVal
+ if ( !isBorderBox && computedVal >= 0 ) {
+
+ // offsetWidth/offsetHeight is a rounded sum of content, padding, scroll gutter, and border
+ // Assuming integer scroll gutter, subtract the rest and round down
+ delta += Math.max( 0, Math.ceil(
+ elem[ "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ] -
+ computedVal -
+ delta -
+ extra -
+ 0.5
+
+ // If offsetWidth/offsetHeight is unknown, then we can't determine content-box scroll gutter
+ // Use an explicit zero to avoid NaN (gh-3964)
+ ) ) || 0;
+ }
+
+ return delta;
+}
+
+function getWidthOrHeight( elem, dimension, extra ) {
+
+ // Start with computed style
+ var styles = getStyles( elem ),
+
+ // To avoid forcing a reflow, only fetch boxSizing if we need it (gh-4322).
+ // Fake content-box until we know it's needed to know the true value.
+ boxSizingNeeded = !support.boxSizingReliable() || extra,
+ isBorderBox = boxSizingNeeded &&
+ jQuery.css( elem, "boxSizing", false, styles ) === "border-box",
+ valueIsBorderBox = isBorderBox,
+
+ val = curCSS( elem, dimension, styles ),
+ offsetProp = "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 );
+
+ // Support: Firefox <=54
+ // Return a confounding non-pixel value or feign ignorance, as appropriate.
+ if ( rnumnonpx.test( val ) ) {
+ if ( !extra ) {
+ return val;
+ }
+ val = "auto";
+ }
+
+
+ // Support: IE 9 - 11 only
+ // Use offsetWidth/offsetHeight for when box sizing is unreliable.
+ // In those cases, the computed value can be trusted to be border-box.
+ if ( ( !support.boxSizingReliable() && isBorderBox ||
+
+ // Support: IE 10 - 11+, Edge 15 - 18+
+ // IE/Edge misreport `getComputedStyle` of table rows with width/height
+ // set in CSS while `offset*` properties report correct values.
+ // Interestingly, in some cases IE 9 doesn't suffer from this issue.
+ !support.reliableTrDimensions() && nodeName( elem, "tr" ) ||
+
+ // Fall back to offsetWidth/offsetHeight when value is "auto"
+ // This happens for inline elements with no explicit setting (gh-3571)
+ val === "auto" ||
+
+ // Support: Android <=4.1 - 4.3 only
+ // Also use offsetWidth/offsetHeight for misreported inline dimensions (gh-3602)
+ !parseFloat( val ) && jQuery.css( elem, "display", false, styles ) === "inline" ) &&
+
+ // Make sure the element is visible & connected
+ elem.getClientRects().length ) {
+
+ isBorderBox = jQuery.css( elem, "boxSizing", false, styles ) === "border-box";
+
+ // Where available, offsetWidth/offsetHeight approximate border box dimensions.
+ // Where not available (e.g., SVG), assume unreliable box-sizing and interpret the
+ // retrieved value as a content box dimension.
+ valueIsBorderBox = offsetProp in elem;
+ if ( valueIsBorderBox ) {
+ val = elem[ offsetProp ];
+ }
+ }
+
+ // Normalize "" and auto
+ val = parseFloat( val ) || 0;
+
+ // Adjust for the element's box model
+ return ( val +
+ boxModelAdjustment(
+ elem,
+ dimension,
+ extra || ( isBorderBox ? "border" : "content" ),
+ valueIsBorderBox,
+ styles,
+
+ // Provide the current computed size to request scroll gutter calculation (gh-3589)
+ val
+ )
+ ) + "px";
+}
+
+jQuery.extend( {
+
+ // Add in style property hooks for overriding the default
+ // behavior of getting and setting a style property
+ cssHooks: {
+ opacity: {
+ get: function( elem, computed ) {
+ if ( computed ) {
+
+ // We should always get a number back from opacity
+ var ret = curCSS( elem, "opacity" );
+ return ret === "" ? "1" : ret;
+ }
+ }
+ }
+ },
+
+ // Don't automatically add "px" to these possibly-unitless properties
+ cssNumber: {
+ "animationIterationCount": true,
+ "columnCount": true,
+ "fillOpacity": true,
+ "flexGrow": true,
+ "flexShrink": true,
+ "fontWeight": true,
+ "gridArea": true,
+ "gridColumn": true,
+ "gridColumnEnd": true,
+ "gridColumnStart": true,
+ "gridRow": true,
+ "gridRowEnd": true,
+ "gridRowStart": true,
+ "lineHeight": true,
+ "opacity": true,
+ "order": true,
+ "orphans": true,
+ "widows": true,
+ "zIndex": true,
+ "zoom": true
+ },
+
+ // Add in properties whose names you wish to fix before
+ // setting or getting the value
+ cssProps: {},
+
+ // Get and set the style property on a DOM Node
+ style: function( elem, name, value, extra ) {
+
+ // Don't set styles on text and comment nodes
+ if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) {
+ return;
+ }
+
+ // Make sure that we're working with the right name
+ var ret, type, hooks,
+ origName = camelCase( name ),
+ isCustomProp = rcustomProp.test( name ),
+ style = elem.style;
+
+ // Make sure that we're working with the right name. We don't
+ // want to query the value if it is a CSS custom property
+ // since they are user-defined.
+ if ( !isCustomProp ) {
+ name = finalPropName( origName );
+ }
+
+ // Gets hook for the prefixed version, then unprefixed version
+ hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];
+
+ // Check if we're setting a value
+ if ( value !== undefined ) {
+ type = typeof value;
+
+ // Convert "+=" or "-=" to relative numbers (#7345)
+ if ( type === "string" && ( ret = rcssNum.exec( value ) ) && ret[ 1 ] ) {
+ value = adjustCSS( elem, name, ret );
+
+ // Fixes bug #9237
+ type = "number";
+ }
+
+ // Make sure that null and NaN values aren't set (#7116)
+ if ( value == null || value !== value ) {
+ return;
+ }
+
+ // If a number was passed in, add the unit (except for certain CSS properties)
+ // The isCustomProp check can be removed in jQuery 4.0 when we only auto-append
+ // "px" to a few hardcoded values.
+ if ( type === "number" && !isCustomProp ) {
+ value += ret && ret[ 3 ] || ( jQuery.cssNumber[ origName ] ? "" : "px" );
+ }
+
+ // background-* props affect original clone's values
+ if ( !support.clearCloneStyle && value === "" && name.indexOf( "background" ) === 0 ) {
+ style[ name ] = "inherit";
+ }
+
+ // If a hook was provided, use that value, otherwise just set the specified value
+ if ( !hooks || !( "set" in hooks ) ||
+ ( value = hooks.set( elem, value, extra ) ) !== undefined ) {
+
+ if ( isCustomProp ) {
+ style.setProperty( name, value );
+ } else {
+ style[ name ] = value;
+ }
+ }
+
+ } else {
+
+ // If a hook was provided get the non-computed value from there
+ if ( hooks && "get" in hooks &&
+ ( ret = hooks.get( elem, false, extra ) ) !== undefined ) {
+
+ return ret;
+ }
+
+ // Otherwise just get the value from the style object
+ return style[ name ];
+ }
+ },
+
+ css: function( elem, name, extra, styles ) {
+ var val, num, hooks,
+ origName = camelCase( name ),
+ isCustomProp = rcustomProp.test( name );
+
+ // Make sure that we're working with the right name. We don't
+ // want to modify the value if it is a CSS custom property
+ // since they are user-defined.
+ if ( !isCustomProp ) {
+ name = finalPropName( origName );
+ }
+
+ // Try prefixed name followed by the unprefixed name
+ hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];
+
+ // If a hook was provided get the computed value from there
+ if ( hooks && "get" in hooks ) {
+ val = hooks.get( elem, true, extra );
+ }
+
+ // Otherwise, if a way to get the computed value exists, use that
+ if ( val === undefined ) {
+ val = curCSS( elem, name, styles );
+ }
+
+ // Convert "normal" to computed value
+ if ( val === "normal" && name in cssNormalTransform ) {
+ val = cssNormalTransform[ name ];
+ }
+
+ // Make numeric if forced or a qualifier was provided and val looks numeric
+ if ( extra === "" || extra ) {
+ num = parseFloat( val );
+ return extra === true || isFinite( num ) ? num || 0 : val;
+ }
+
+ return val;
+ }
+} );
+
+jQuery.each( [ "height", "width" ], function( _i, dimension ) {
+ jQuery.cssHooks[ dimension ] = {
+ get: function( elem, computed, extra ) {
+ if ( computed ) {
+
+ // Certain elements can have dimension info if we invisibly show them
+ // but it must have a current display style that would benefit
+ return rdisplayswap.test( jQuery.css( elem, "display" ) ) &&
+
+ // Support: Safari 8+
+ // Table columns in Safari have non-zero offsetWidth & zero
+ // getBoundingClientRect().width unless display is changed.
+ // Support: IE <=11 only
+ // Running getBoundingClientRect on a disconnected node
+ // in IE throws an error.
+ ( !elem.getClientRects().length || !elem.getBoundingClientRect().width ) ?
+ swap( elem, cssShow, function() {
+ return getWidthOrHeight( elem, dimension, extra );
+ } ) :
+ getWidthOrHeight( elem, dimension, extra );
+ }
+ },
+
+ set: function( elem, value, extra ) {
+ var matches,
+ styles = getStyles( elem ),
+
+ // Only read styles.position if the test has a chance to fail
+ // to avoid forcing a reflow.
+ scrollboxSizeBuggy = !support.scrollboxSize() &&
+ styles.position === "absolute",
+
+ // To avoid forcing a reflow, only fetch boxSizing if we need it (gh-3991)
+ boxSizingNeeded = scrollboxSizeBuggy || extra,
+ isBorderBox = boxSizingNeeded &&
+ jQuery.css( elem, "boxSizing", false, styles ) === "border-box",
+ subtract = extra ?
+ boxModelAdjustment(
+ elem,
+ dimension,
+ extra,
+ isBorderBox,
+ styles
+ ) :
+ 0;
+
+ // Account for unreliable border-box dimensions by comparing offset* to computed and
+ // faking a content-box to get border and padding (gh-3699)
+ if ( isBorderBox && scrollboxSizeBuggy ) {
+ subtract -= Math.ceil(
+ elem[ "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ] -
+ parseFloat( styles[ dimension ] ) -
+ boxModelAdjustment( elem, dimension, "border", false, styles ) -
+ 0.5
+ );
+ }
+
+ // Convert to pixels if value adjustment is needed
+ if ( subtract && ( matches = rcssNum.exec( value ) ) &&
+ ( matches[ 3 ] || "px" ) !== "px" ) {
+
+ elem.style[ dimension ] = value;
+ value = jQuery.css( elem, dimension );
+ }
+
+ return setPositiveNumber( elem, value, subtract );
+ }
+ };
+} );
+
+jQuery.cssHooks.marginLeft = addGetHookIf( support.reliableMarginLeft,
+ function( elem, computed ) {
+ if ( computed ) {
+ return ( parseFloat( curCSS( elem, "marginLeft" ) ) ||
+ elem.getBoundingClientRect().left -
+ swap( elem, { marginLeft: 0 }, function() {
+ return elem.getBoundingClientRect().left;
+ } )
+ ) + "px";
+ }
+ }
+);
+
+// These hooks are used by animate to expand properties
+jQuery.each( {
+ margin: "",
+ padding: "",
+ border: "Width"
+}, function( prefix, suffix ) {
+ jQuery.cssHooks[ prefix + suffix ] = {
+ expand: function( value ) {
+ var i = 0,
+ expanded = {},
+
+ // Assumes a single number if not a string
+ parts = typeof value === "string" ? value.split( " " ) : [ value ];
+
+ for ( ; i < 4; i++ ) {
+ expanded[ prefix + cssExpand[ i ] + suffix ] =
+ parts[ i ] || parts[ i - 2 ] || parts[ 0 ];
+ }
+
+ return expanded;
+ }
+ };
+
+ if ( prefix !== "margin" ) {
+ jQuery.cssHooks[ prefix + suffix ].set = setPositiveNumber;
+ }
+} );
+
+jQuery.fn.extend( {
+ css: function( name, value ) {
+ return access( this, function( elem, name, value ) {
+ var styles, len,
+ map = {},
+ i = 0;
+
+ if ( Array.isArray( name ) ) {
+ styles = getStyles( elem );
+ len = name.length;
+
+ for ( ; i < len; i++ ) {
+ map[ name[ i ] ] = jQuery.css( elem, name[ i ], false, styles );
+ }
+
+ return map;
+ }
+
+ return value !== undefined ?
+ jQuery.style( elem, name, value ) :
+ jQuery.css( elem, name );
+ }, name, value, arguments.length > 1 );
+ }
+} );
+
+
+function Tween( elem, options, prop, end, easing ) {
+ return new Tween.prototype.init( elem, options, prop, end, easing );
+}
+jQuery.Tween = Tween;
+
+Tween.prototype = {
+ constructor: Tween,
+ init: function( elem, options, prop, end, easing, unit ) {
+ this.elem = elem;
+ this.prop = prop;
+ this.easing = easing || jQuery.easing._default;
+ this.options = options;
+ this.start = this.now = this.cur();
+ this.end = end;
+ this.unit = unit || ( jQuery.cssNumber[ prop ] ? "" : "px" );
+ },
+ cur: function() {
+ var hooks = Tween.propHooks[ this.prop ];
+
+ return hooks && hooks.get ?
+ hooks.get( this ) :
+ Tween.propHooks._default.get( this );
+ },
+ run: function( percent ) {
+ var eased,
+ hooks = Tween.propHooks[ this.prop ];
+
+ if ( this.options.duration ) {
+ this.pos = eased = jQuery.easing[ this.easing ](
+ percent, this.options.duration * percent, 0, 1, this.options.duration
+ );
+ } else {
+ this.pos = eased = percent;
+ }
+ this.now = ( this.end - this.start ) * eased + this.start;
+
+ if ( this.options.step ) {
+ this.options.step.call( this.elem, this.now, this );
+ }
+
+ if ( hooks && hooks.set ) {
+ hooks.set( this );
+ } else {
+ Tween.propHooks._default.set( this );
+ }
+ return this;
+ }
+};
+
+Tween.prototype.init.prototype = Tween.prototype;
+
+Tween.propHooks = {
+ _default: {
+ get: function( tween ) {
+ var result;
+
+ // Use a property on the element directly when it is not a DOM element,
+ // or when there is no matching style property that exists.
+ if ( tween.elem.nodeType !== 1 ||
+ tween.elem[ tween.prop ] != null && tween.elem.style[ tween.prop ] == null ) {
+ return tween.elem[ tween.prop ];
+ }
+
+ // Passing an empty string as a 3rd parameter to .css will automatically
+ // attempt a parseFloat and fallback to a string if the parse fails.
+ // Simple values such as "10px" are parsed to Float;
+ // complex values such as "rotate(1rad)" are returned as-is.
+ result = jQuery.css( tween.elem, tween.prop, "" );
+
+ // Empty strings, null, undefined and "auto" are converted to 0.
+ return !result || result === "auto" ? 0 : result;
+ },
+ set: function( tween ) {
+
+ // Use step hook for back compat.
+ // Use cssHook if its there.
+ // Use .style if available and use plain properties where available.
+ if ( jQuery.fx.step[ tween.prop ] ) {
+ jQuery.fx.step[ tween.prop ]( tween );
+ } else if ( tween.elem.nodeType === 1 && (
+ jQuery.cssHooks[ tween.prop ] ||
+ tween.elem.style[ finalPropName( tween.prop ) ] != null ) ) {
+ jQuery.style( tween.elem, tween.prop, tween.now + tween.unit );
+ } else {
+ tween.elem[ tween.prop ] = tween.now;
+ }
+ }
+ }
+};
+
+// Support: IE <=9 only
+// Panic based approach to setting things on disconnected nodes
+Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = {
+ set: function( tween ) {
+ if ( tween.elem.nodeType && tween.elem.parentNode ) {
+ tween.elem[ tween.prop ] = tween.now;
+ }
+ }
+};
+
+jQuery.easing = {
+ linear: function( p ) {
+ return p;
+ },
+ swing: function( p ) {
+ return 0.5 - Math.cos( p * Math.PI ) / 2;
+ },
+ _default: "swing"
+};
+
+jQuery.fx = Tween.prototype.init;
+
+// Back compat <1.8 extension point
+jQuery.fx.step = {};
+
+
+
+
+var
+ fxNow, inProgress,
+ rfxtypes = /^(?:toggle|show|hide)$/,
+ rrun = /queueHooks$/;
+
+function schedule() {
+ if ( inProgress ) {
+ if ( document.hidden === false && window.requestAnimationFrame ) {
+ window.requestAnimationFrame( schedule );
+ } else {
+ window.setTimeout( schedule, jQuery.fx.interval );
+ }
+
+ jQuery.fx.tick();
+ }
+}
+
+// Animations created synchronously will run synchronously
+function createFxNow() {
+ window.setTimeout( function() {
+ fxNow = undefined;
+ } );
+ return ( fxNow = Date.now() );
+}
+
+// Generate parameters to create a standard animation
+function genFx( type, includeWidth ) {
+ var which,
+ i = 0,
+ attrs = { height: type };
+
+ // If we include width, step value is 1 to do all cssExpand values,
+ // otherwise step value is 2 to skip over Left and Right
+ includeWidth = includeWidth ? 1 : 0;
+ for ( ; i < 4; i += 2 - includeWidth ) {
+ which = cssExpand[ i ];
+ attrs[ "margin" + which ] = attrs[ "padding" + which ] = type;
+ }
+
+ if ( includeWidth ) {
+ attrs.opacity = attrs.width = type;
+ }
+
+ return attrs;
+}
+
+function createTween( value, prop, animation ) {
+ var tween,
+ collection = ( Animation.tweeners[ prop ] || [] ).concat( Animation.tweeners[ "*" ] ),
+ index = 0,
+ length = collection.length;
+ for ( ; index < length; index++ ) {
+ if ( ( tween = collection[ index ].call( animation, prop, value ) ) ) {
+
+ // We're done with this property
+ return tween;
+ }
+ }
+}
+
+function defaultPrefilter( elem, props, opts ) {
+ var prop, value, toggle, hooks, oldfire, propTween, restoreDisplay, display,
+ isBox = "width" in props || "height" in props,
+ anim = this,
+ orig = {},
+ style = elem.style,
+ hidden = elem.nodeType && isHiddenWithinTree( elem ),
+ dataShow = dataPriv.get( elem, "fxshow" );
+
+ // Queue-skipping animations hijack the fx hooks
+ if ( !opts.queue ) {
+ hooks = jQuery._queueHooks( elem, "fx" );
+ if ( hooks.unqueued == null ) {
+ hooks.unqueued = 0;
+ oldfire = hooks.empty.fire;
+ hooks.empty.fire = function() {
+ if ( !hooks.unqueued ) {
+ oldfire();
+ }
+ };
+ }
+ hooks.unqueued++;
+
+ anim.always( function() {
+
+ // Ensure the complete handler is called before this completes
+ anim.always( function() {
+ hooks.unqueued--;
+ if ( !jQuery.queue( elem, "fx" ).length ) {
+ hooks.empty.fire();
+ }
+ } );
+ } );
+ }
+
+ // Detect show/hide animations
+ for ( prop in props ) {
+ value = props[ prop ];
+ if ( rfxtypes.test( value ) ) {
+ delete props[ prop ];
+ toggle = toggle || value === "toggle";
+ if ( value === ( hidden ? "hide" : "show" ) ) {
+
+ // Pretend to be hidden if this is a "show" and
+ // there is still data from a stopped show/hide
+ if ( value === "show" && dataShow && dataShow[ prop ] !== undefined ) {
+ hidden = true;
+
+ // Ignore all other no-op show/hide data
+ } else {
+ continue;
+ }
+ }
+ orig[ prop ] = dataShow && dataShow[ prop ] || jQuery.style( elem, prop );
+ }
+ }
+
+ // Bail out if this is a no-op like .hide().hide()
+ propTween = !jQuery.isEmptyObject( props );
+ if ( !propTween && jQuery.isEmptyObject( orig ) ) {
+ return;
+ }
+
+ // Restrict "overflow" and "display" styles during box animations
+ if ( isBox && elem.nodeType === 1 ) {
+
+ // Support: IE <=9 - 11, Edge 12 - 15
+ // Record all 3 overflow attributes because IE does not infer the shorthand
+ // from identically-valued overflowX and overflowY and Edge just mirrors
+ // the overflowX value there.
+ opts.overflow = [ style.overflow, style.overflowX, style.overflowY ];
+
+ // Identify a display type, preferring old show/hide data over the CSS cascade
+ restoreDisplay = dataShow && dataShow.display;
+ if ( restoreDisplay == null ) {
+ restoreDisplay = dataPriv.get( elem, "display" );
+ }
+ display = jQuery.css( elem, "display" );
+ if ( display === "none" ) {
+ if ( restoreDisplay ) {
+ display = restoreDisplay;
+ } else {
+
+ // Get nonempty value(s) by temporarily forcing visibility
+ showHide( [ elem ], true );
+ restoreDisplay = elem.style.display || restoreDisplay;
+ display = jQuery.css( elem, "display" );
+ showHide( [ elem ] );
+ }
+ }
+
+ // Animate inline elements as inline-block
+ if ( display === "inline" || display === "inline-block" && restoreDisplay != null ) {
+ if ( jQuery.css( elem, "float" ) === "none" ) {
+
+ // Restore the original display value at the end of pure show/hide animations
+ if ( !propTween ) {
+ anim.done( function() {
+ style.display = restoreDisplay;
+ } );
+ if ( restoreDisplay == null ) {
+ display = style.display;
+ restoreDisplay = display === "none" ? "" : display;
+ }
+ }
+ style.display = "inline-block";
+ }
+ }
+ }
+
+ if ( opts.overflow ) {
+ style.overflow = "hidden";
+ anim.always( function() {
+ style.overflow = opts.overflow[ 0 ];
+ style.overflowX = opts.overflow[ 1 ];
+ style.overflowY = opts.overflow[ 2 ];
+ } );
+ }
+
+ // Implement show/hide animations
+ propTween = false;
+ for ( prop in orig ) {
+
+ // General show/hide setup for this element animation
+ if ( !propTween ) {
+ if ( dataShow ) {
+ if ( "hidden" in dataShow ) {
+ hidden = dataShow.hidden;
+ }
+ } else {
+ dataShow = dataPriv.access( elem, "fxshow", { display: restoreDisplay } );
+ }
+
+ // Store hidden/visible for toggle so `.stop().toggle()` "reverses"
+ if ( toggle ) {
+ dataShow.hidden = !hidden;
+ }
+
+ // Show elements before animating them
+ if ( hidden ) {
+ showHide( [ elem ], true );
+ }
+
+ /* eslint-disable no-loop-func */
+
+ anim.done( function() {
+
+ /* eslint-enable no-loop-func */
+
+ // The final step of a "hide" animation is actually hiding the element
+ if ( !hidden ) {
+ showHide( [ elem ] );
+ }
+ dataPriv.remove( elem, "fxshow" );
+ for ( prop in orig ) {
+ jQuery.style( elem, prop, orig[ prop ] );
+ }
+ } );
+ }
+
+ // Per-property setup
+ propTween = createTween( hidden ? dataShow[ prop ] : 0, prop, anim );
+ if ( !( prop in dataShow ) ) {
+ dataShow[ prop ] = propTween.start;
+ if ( hidden ) {
+ propTween.end = propTween.start;
+ propTween.start = 0;
+ }
+ }
+ }
+}
+
+function propFilter( props, specialEasing ) {
+ var index, name, easing, value, hooks;
+
+ // camelCase, specialEasing and expand cssHook pass
+ for ( index in props ) {
+ name = camelCase( index );
+ easing = specialEasing[ name ];
+ value = props[ index ];
+ if ( Array.isArray( value ) ) {
+ easing = value[ 1 ];
+ value = props[ index ] = value[ 0 ];
+ }
+
+ if ( index !== name ) {
+ props[ name ] = value;
+ delete props[ index ];
+ }
+
+ hooks = jQuery.cssHooks[ name ];
+ if ( hooks && "expand" in hooks ) {
+ value = hooks.expand( value );
+ delete props[ name ];
+
+ // Not quite $.extend, this won't overwrite existing keys.
+ // Reusing 'index' because we have the correct "name"
+ for ( index in value ) {
+ if ( !( index in props ) ) {
+ props[ index ] = value[ index ];
+ specialEasing[ index ] = easing;
+ }
+ }
+ } else {
+ specialEasing[ name ] = easing;
+ }
+ }
+}
+
+function Animation( elem, properties, options ) {
+ var result,
+ stopped,
+ index = 0,
+ length = Animation.prefilters.length,
+ deferred = jQuery.Deferred().always( function() {
+
+ // Don't match elem in the :animated selector
+ delete tick.elem;
+ } ),
+ tick = function() {
+ if ( stopped ) {
+ return false;
+ }
+ var currentTime = fxNow || createFxNow(),
+ remaining = Math.max( 0, animation.startTime + animation.duration - currentTime ),
+
+ // Support: Android 2.3 only
+ // Archaic crash bug won't allow us to use `1 - ( 0.5 || 0 )` (#12497)
+ temp = remaining / animation.duration || 0,
+ percent = 1 - temp,
+ index = 0,
+ length = animation.tweens.length;
+
+ for ( ; index < length; index++ ) {
+ animation.tweens[ index ].run( percent );
+ }
+
+ deferred.notifyWith( elem, [ animation, percent, remaining ] );
+
+ // If there's more to do, yield
+ if ( percent < 1 && length ) {
+ return remaining;
+ }
+
+ // If this was an empty animation, synthesize a final progress notification
+ if ( !length ) {
+ deferred.notifyWith( elem, [ animation, 1, 0 ] );
+ }
+
+ // Resolve the animation and report its conclusion
+ deferred.resolveWith( elem, [ animation ] );
+ return false;
+ },
+ animation = deferred.promise( {
+ elem: elem,
+ props: jQuery.extend( {}, properties ),
+ opts: jQuery.extend( true, {
+ specialEasing: {},
+ easing: jQuery.easing._default
+ }, options ),
+ originalProperties: properties,
+ originalOptions: options,
+ startTime: fxNow || createFxNow(),
+ duration: options.duration,
+ tweens: [],
+ createTween: function( prop, end ) {
+ var tween = jQuery.Tween( elem, animation.opts, prop, end,
+ animation.opts.specialEasing[ prop ] || animation.opts.easing );
+ animation.tweens.push( tween );
+ return tween;
+ },
+ stop: function( gotoEnd ) {
+ var index = 0,
+
+ // If we are going to the end, we want to run all the tweens
+ // otherwise we skip this part
+ length = gotoEnd ? animation.tweens.length : 0;
+ if ( stopped ) {
+ return this;
+ }
+ stopped = true;
+ for ( ; index < length; index++ ) {
+ animation.tweens[ index ].run( 1 );
+ }
+
+ // Resolve when we played the last frame; otherwise, reject
+ if ( gotoEnd ) {
+ deferred.notifyWith( elem, [ animation, 1, 0 ] );
+ deferred.resolveWith( elem, [ animation, gotoEnd ] );
+ } else {
+ deferred.rejectWith( elem, [ animation, gotoEnd ] );
+ }
+ return this;
+ }
+ } ),
+ props = animation.props;
+
+ propFilter( props, animation.opts.specialEasing );
+
+ for ( ; index < length; index++ ) {
+ result = Animation.prefilters[ index ].call( animation, elem, props, animation.opts );
+ if ( result ) {
+ if ( isFunction( result.stop ) ) {
+ jQuery._queueHooks( animation.elem, animation.opts.queue ).stop =
+ result.stop.bind( result );
+ }
+ return result;
+ }
+ }
+
+ jQuery.map( props, createTween, animation );
+
+ if ( isFunction( animation.opts.start ) ) {
+ animation.opts.start.call( elem, animation );
+ }
+
+ // Attach callbacks from options
+ animation
+ .progress( animation.opts.progress )
+ .done( animation.opts.done, animation.opts.complete )
+ .fail( animation.opts.fail )
+ .always( animation.opts.always );
+
+ jQuery.fx.timer(
+ jQuery.extend( tick, {
+ elem: elem,
+ anim: animation,
+ queue: animation.opts.queue
+ } )
+ );
+
+ return animation;
+}
+
+jQuery.Animation = jQuery.extend( Animation, {
+
+ tweeners: {
+ "*": [ function( prop, value ) {
+ var tween = this.createTween( prop, value );
+ adjustCSS( tween.elem, prop, rcssNum.exec( value ), tween );
+ return tween;
+ } ]
+ },
+
+ tweener: function( props, callback ) {
+ if ( isFunction( props ) ) {
+ callback = props;
+ props = [ "*" ];
+ } else {
+ props = props.match( rnothtmlwhite );
+ }
+
+ var prop,
+ index = 0,
+ length = props.length;
+
+ for ( ; index < length; index++ ) {
+ prop = props[ index ];
+ Animation.tweeners[ prop ] = Animation.tweeners[ prop ] || [];
+ Animation.tweeners[ prop ].unshift( callback );
+ }
+ },
+
+ prefilters: [ defaultPrefilter ],
+
+ prefilter: function( callback, prepend ) {
+ if ( prepend ) {
+ Animation.prefilters.unshift( callback );
+ } else {
+ Animation.prefilters.push( callback );
+ }
+ }
+} );
+
+jQuery.speed = function( speed, easing, fn ) {
+ var opt = speed && typeof speed === "object" ? jQuery.extend( {}, speed ) : {
+ complete: fn || !fn && easing ||
+ isFunction( speed ) && speed,
+ duration: speed,
+ easing: fn && easing || easing && !isFunction( easing ) && easing
+ };
+
+ // Go to the end state if fx are off
+ if ( jQuery.fx.off ) {
+ opt.duration = 0;
+
+ } else {
+ if ( typeof opt.duration !== "number" ) {
+ if ( opt.duration in jQuery.fx.speeds ) {
+ opt.duration = jQuery.fx.speeds[ opt.duration ];
+
+ } else {
+ opt.duration = jQuery.fx.speeds._default;
+ }
+ }
+ }
+
+ // Normalize opt.queue - true/undefined/null -> "fx"
+ if ( opt.queue == null || opt.queue === true ) {
+ opt.queue = "fx";
+ }
+
+ // Queueing
+ opt.old = opt.complete;
+
+ opt.complete = function() {
+ if ( isFunction( opt.old ) ) {
+ opt.old.call( this );
+ }
+
+ if ( opt.queue ) {
+ jQuery.dequeue( this, opt.queue );
+ }
+ };
+
+ return opt;
+};
+
+jQuery.fn.extend( {
+ fadeTo: function( speed, to, easing, callback ) {
+
+ // Show any hidden elements after setting opacity to 0
+ return this.filter( isHiddenWithinTree ).css( "opacity", 0 ).show()
+
+ // Animate to the value specified
+ .end().animate( { opacity: to }, speed, easing, callback );
+ },
+ animate: function( prop, speed, easing, callback ) {
+ var empty = jQuery.isEmptyObject( prop ),
+ optall = jQuery.speed( speed, easing, callback ),
+ doAnimation = function() {
+
+ // Operate on a copy of prop so per-property easing won't be lost
+ var anim = Animation( this, jQuery.extend( {}, prop ), optall );
+
+ // Empty animations, or finishing resolves immediately
+ if ( empty || dataPriv.get( this, "finish" ) ) {
+ anim.stop( true );
+ }
+ };
+
+ doAnimation.finish = doAnimation;
+
+ return empty || optall.queue === false ?
+ this.each( doAnimation ) :
+ this.queue( optall.queue, doAnimation );
+ },
+ stop: function( type, clearQueue, gotoEnd ) {
+ var stopQueue = function( hooks ) {
+ var stop = hooks.stop;
+ delete hooks.stop;
+ stop( gotoEnd );
+ };
+
+ if ( typeof type !== "string" ) {
+ gotoEnd = clearQueue;
+ clearQueue = type;
+ type = undefined;
+ }
+ if ( clearQueue ) {
+ this.queue( type || "fx", [] );
+ }
+
+ return this.each( function() {
+ var dequeue = true,
+ index = type != null && type + "queueHooks",
+ timers = jQuery.timers,
+ data = dataPriv.get( this );
+
+ if ( index ) {
+ if ( data[ index ] && data[ index ].stop ) {
+ stopQueue( data[ index ] );
+ }
+ } else {
+ for ( index in data ) {
+ if ( data[ index ] && data[ index ].stop && rrun.test( index ) ) {
+ stopQueue( data[ index ] );
+ }
+ }
+ }
+
+ for ( index = timers.length; index--; ) {
+ if ( timers[ index ].elem === this &&
+ ( type == null || timers[ index ].queue === type ) ) {
+
+ timers[ index ].anim.stop( gotoEnd );
+ dequeue = false;
+ timers.splice( index, 1 );
+ }
+ }
+
+ // Start the next in the queue if the last step wasn't forced.
+ // Timers currently will call their complete callbacks, which
+ // will dequeue but only if they were gotoEnd.
+ if ( dequeue || !gotoEnd ) {
+ jQuery.dequeue( this, type );
+ }
+ } );
+ },
+ finish: function( type ) {
+ if ( type !== false ) {
+ type = type || "fx";
+ }
+ return this.each( function() {
+ var index,
+ data = dataPriv.get( this ),
+ queue = data[ type + "queue" ],
+ hooks = data[ type + "queueHooks" ],
+ timers = jQuery.timers,
+ length = queue ? queue.length : 0;
+
+ // Enable finishing flag on private data
+ data.finish = true;
+
+ // Empty the queue first
+ jQuery.queue( this, type, [] );
+
+ if ( hooks && hooks.stop ) {
+ hooks.stop.call( this, true );
+ }
+
+ // Look for any active animations, and finish them
+ for ( index = timers.length; index--; ) {
+ if ( timers[ index ].elem === this && timers[ index ].queue === type ) {
+ timers[ index ].anim.stop( true );
+ timers.splice( index, 1 );
+ }
+ }
+
+ // Look for any animations in the old queue and finish them
+ for ( index = 0; index < length; index++ ) {
+ if ( queue[ index ] && queue[ index ].finish ) {
+ queue[ index ].finish.call( this );
+ }
+ }
+
+ // Turn off finishing flag
+ delete data.finish;
+ } );
+ }
+} );
+
+jQuery.each( [ "toggle", "show", "hide" ], function( _i, name ) {
+ var cssFn = jQuery.fn[ name ];
+ jQuery.fn[ name ] = function( speed, easing, callback ) {
+ return speed == null || typeof speed === "boolean" ?
+ cssFn.apply( this, arguments ) :
+ this.animate( genFx( name, true ), speed, easing, callback );
+ };
+} );
+
+// Generate shortcuts for custom animations
+jQuery.each( {
+ slideDown: genFx( "show" ),
+ slideUp: genFx( "hide" ),
+ slideToggle: genFx( "toggle" ),
+ fadeIn: { opacity: "show" },
+ fadeOut: { opacity: "hide" },
+ fadeToggle: { opacity: "toggle" }
+}, function( name, props ) {
+ jQuery.fn[ name ] = function( speed, easing, callback ) {
+ return this.animate( props, speed, easing, callback );
+ };
+} );
+
+jQuery.timers = [];
+jQuery.fx.tick = function() {
+ var timer,
+ i = 0,
+ timers = jQuery.timers;
+
+ fxNow = Date.now();
+
+ for ( ; i < timers.length; i++ ) {
+ timer = timers[ i ];
+
+ // Run the timer and safely remove it when done (allowing for external removal)
+ if ( !timer() && timers[ i ] === timer ) {
+ timers.splice( i--, 1 );
+ }
+ }
+
+ if ( !timers.length ) {
+ jQuery.fx.stop();
+ }
+ fxNow = undefined;
+};
+
+jQuery.fx.timer = function( timer ) {
+ jQuery.timers.push( timer );
+ jQuery.fx.start();
+};
+
+jQuery.fx.interval = 13;
+jQuery.fx.start = function() {
+ if ( inProgress ) {
+ return;
+ }
+
+ inProgress = true;
+ schedule();
+};
+
+jQuery.fx.stop = function() {
+ inProgress = null;
+};
+
+jQuery.fx.speeds = {
+ slow: 600,
+ fast: 200,
+
+ // Default speed
+ _default: 400
+};
+
+
+// Based off of the plugin by Clint Helfers, with permission.
+// https://web.archive.org/web/20100324014747/http://blindsignals.com/index.php/2009/07/jquery-delay/
+jQuery.fn.delay = function( time, type ) {
+ time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time;
+ type = type || "fx";
+
+ return this.queue( type, function( next, hooks ) {
+ var timeout = window.setTimeout( next, time );
+ hooks.stop = function() {
+ window.clearTimeout( timeout );
+ };
+ } );
+};
+
+
+( function() {
+ var input = document.createElement( "input" ),
+ select = document.createElement( "select" ),
+ opt = select.appendChild( document.createElement( "option" ) );
+
+ input.type = "checkbox";
+
+ // Support: Android <=4.3 only
+ // Default value for a checkbox should be "on"
+ support.checkOn = input.value !== "";
+
+ // Support: IE <=11 only
+ // Must access selectedIndex to make default options select
+ support.optSelected = opt.selected;
+
+ // Support: IE <=11 only
+ // An input loses its value after becoming a radio
+ input = document.createElement( "input" );
+ input.value = "t";
+ input.type = "radio";
+ support.radioValue = input.value === "t";
+} )();
+
+
+var boolHook,
+ attrHandle = jQuery.expr.attrHandle;
+
+jQuery.fn.extend( {
+ attr: function( name, value ) {
+ return access( this, jQuery.attr, name, value, arguments.length > 1 );
+ },
+
+ removeAttr: function( name ) {
+ return this.each( function() {
+ jQuery.removeAttr( this, name );
+ } );
+ }
+} );
+
+jQuery.extend( {
+ attr: function( elem, name, value ) {
+ var ret, hooks,
+ nType = elem.nodeType;
+
+ // Don't get/set attributes on text, comment and attribute nodes
+ if ( nType === 3 || nType === 8 || nType === 2 ) {
+ return;
+ }
+
+ // Fallback to prop when attributes are not supported
+ if ( typeof elem.getAttribute === "undefined" ) {
+ return jQuery.prop( elem, name, value );
+ }
+
+ // Attribute hooks are determined by the lowercase version
+ // Grab necessary hook if one is defined
+ if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) {
+ hooks = jQuery.attrHooks[ name.toLowerCase() ] ||
+ ( jQuery.expr.match.bool.test( name ) ? boolHook : undefined );
+ }
+
+ if ( value !== undefined ) {
+ if ( value === null ) {
+ jQuery.removeAttr( elem, name );
+ return;
+ }
+
+ if ( hooks && "set" in hooks &&
+ ( ret = hooks.set( elem, value, name ) ) !== undefined ) {
+ return ret;
+ }
+
+ elem.setAttribute( name, value + "" );
+ return value;
+ }
+
+ if ( hooks && "get" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) {
+ return ret;
+ }
+
+ ret = jQuery.find.attr( elem, name );
+
+ // Non-existent attributes return null, we normalize to undefined
+ return ret == null ? undefined : ret;
+ },
+
+ attrHooks: {
+ type: {
+ set: function( elem, value ) {
+ if ( !support.radioValue && value === "radio" &&
+ nodeName( elem, "input" ) ) {
+ var val = elem.value;
+ elem.setAttribute( "type", value );
+ if ( val ) {
+ elem.value = val;
+ }
+ return value;
+ }
+ }
+ }
+ },
+
+ removeAttr: function( elem, value ) {
+ var name,
+ i = 0,
+
+ // Attribute names can contain non-HTML whitespace characters
+ // https://html.spec.whatwg.org/multipage/syntax.html#attributes-2
+ attrNames = value && value.match( rnothtmlwhite );
+
+ if ( attrNames && elem.nodeType === 1 ) {
+ while ( ( name = attrNames[ i++ ] ) ) {
+ elem.removeAttribute( name );
+ }
+ }
+ }
+} );
+
+// Hooks for boolean attributes
+boolHook = {
+ set: function( elem, value, name ) {
+ if ( value === false ) {
+
+ // Remove boolean attributes when set to false
+ jQuery.removeAttr( elem, name );
+ } else {
+ elem.setAttribute( name, name );
+ }
+ return name;
+ }
+};
+
+jQuery.each( jQuery.expr.match.bool.source.match( /\w+/g ), function( _i, name ) {
+ var getter = attrHandle[ name ] || jQuery.find.attr;
+
+ attrHandle[ name ] = function( elem, name, isXML ) {
+ var ret, handle,
+ lowercaseName = name.toLowerCase();
+
+ if ( !isXML ) {
+
+ // Avoid an infinite loop by temporarily removing this function from the getter
+ handle = attrHandle[ lowercaseName ];
+ attrHandle[ lowercaseName ] = ret;
+ ret = getter( elem, name, isXML ) != null ?
+ lowercaseName :
+ null;
+ attrHandle[ lowercaseName ] = handle;
+ }
+ return ret;
+ };
+} );
+
+
+
+
+var rfocusable = /^(?:input|select|textarea|button)$/i,
+ rclickable = /^(?:a|area)$/i;
+
+jQuery.fn.extend( {
+ prop: function( name, value ) {
+ return access( this, jQuery.prop, name, value, arguments.length > 1 );
+ },
+
+ removeProp: function( name ) {
+ return this.each( function() {
+ delete this[ jQuery.propFix[ name ] || name ];
+ } );
+ }
+} );
+
+jQuery.extend( {
+ prop: function( elem, name, value ) {
+ var ret, hooks,
+ nType = elem.nodeType;
+
+ // Don't get/set properties on text, comment and attribute nodes
+ if ( nType === 3 || nType === 8 || nType === 2 ) {
+ return;
+ }
+
+ if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) {
+
+ // Fix name and attach hooks
+ name = jQuery.propFix[ name ] || name;
+ hooks = jQuery.propHooks[ name ];
+ }
+
+ if ( value !== undefined ) {
+ if ( hooks && "set" in hooks &&
+ ( ret = hooks.set( elem, value, name ) ) !== undefined ) {
+ return ret;
+ }
+
+ return ( elem[ name ] = value );
+ }
+
+ if ( hooks && "get" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) {
+ return ret;
+ }
+
+ return elem[ name ];
+ },
+
+ propHooks: {
+ tabIndex: {
+ get: function( elem ) {
+
+ // Support: IE <=9 - 11 only
+ // elem.tabIndex doesn't always return the
+ // correct value when it hasn't been explicitly set
+ // https://web.archive.org/web/20141116233347/http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
+ // Use proper attribute retrieval(#12072)
+ var tabindex = jQuery.find.attr( elem, "tabindex" );
+
+ if ( tabindex ) {
+ return parseInt( tabindex, 10 );
+ }
+
+ if (
+ rfocusable.test( elem.nodeName ) ||
+ rclickable.test( elem.nodeName ) &&
+ elem.href
+ ) {
+ return 0;
+ }
+
+ return -1;
+ }
+ }
+ },
+
+ propFix: {
+ "for": "htmlFor",
+ "class": "className"
+ }
+} );
+
+// Support: IE <=11 only
+// Accessing the selectedIndex property
+// forces the browser to respect setting selected
+// on the option
+// The getter ensures a default option is selected
+// when in an optgroup
+// eslint rule "no-unused-expressions" is disabled for this code
+// since it considers such accessions noop
+if ( !support.optSelected ) {
+ jQuery.propHooks.selected = {
+ get: function( elem ) {
+
+ /* eslint no-unused-expressions: "off" */
+
+ var parent = elem.parentNode;
+ if ( parent && parent.parentNode ) {
+ parent.parentNode.selectedIndex;
+ }
+ return null;
+ },
+ set: function( elem ) {
+
+ /* eslint no-unused-expressions: "off" */
+
+ var parent = elem.parentNode;
+ if ( parent ) {
+ parent.selectedIndex;
+
+ if ( parent.parentNode ) {
+ parent.parentNode.selectedIndex;
+ }
+ }
+ }
+ };
+}
+
+jQuery.each( [
+ "tabIndex",
+ "readOnly",
+ "maxLength",
+ "cellSpacing",
+ "cellPadding",
+ "rowSpan",
+ "colSpan",
+ "useMap",
+ "frameBorder",
+ "contentEditable"
+], function() {
+ jQuery.propFix[ this.toLowerCase() ] = this;
+} );
+
+
+
+
+ // Strip and collapse whitespace according to HTML spec
+ // https://infra.spec.whatwg.org/#strip-and-collapse-ascii-whitespace
+ function stripAndCollapse( value ) {
+ var tokens = value.match( rnothtmlwhite ) || [];
+ return tokens.join( " " );
+ }
+
+
+function getClass( elem ) {
+ return elem.getAttribute && elem.getAttribute( "class" ) || "";
+}
+
+function classesToArray( value ) {
+ if ( Array.isArray( value ) ) {
+ return value;
+ }
+ if ( typeof value === "string" ) {
+ return value.match( rnothtmlwhite ) || [];
+ }
+ return [];
+}
+
+jQuery.fn.extend( {
+ addClass: function( value ) {
+ var classes, elem, cur, curValue, clazz, j, finalValue,
+ i = 0;
+
+ if ( isFunction( value ) ) {
+ return this.each( function( j ) {
+ jQuery( this ).addClass( value.call( this, j, getClass( this ) ) );
+ } );
+ }
+
+ classes = classesToArray( value );
+
+ if ( classes.length ) {
+ while ( ( elem = this[ i++ ] ) ) {
+ curValue = getClass( elem );
+ cur = elem.nodeType === 1 && ( " " + stripAndCollapse( curValue ) + " " );
+
+ if ( cur ) {
+ j = 0;
+ while ( ( clazz = classes[ j++ ] ) ) {
+ if ( cur.indexOf( " " + clazz + " " ) < 0 ) {
+ cur += clazz + " ";
+ }
+ }
+
+ // Only assign if different to avoid unneeded rendering.
+ finalValue = stripAndCollapse( cur );
+ if ( curValue !== finalValue ) {
+ elem.setAttribute( "class", finalValue );
+ }
+ }
+ }
+ }
+
+ return this;
+ },
+
+ removeClass: function( value ) {
+ var classes, elem, cur, curValue, clazz, j, finalValue,
+ i = 0;
+
+ if ( isFunction( value ) ) {
+ return this.each( function( j ) {
+ jQuery( this ).removeClass( value.call( this, j, getClass( this ) ) );
+ } );
+ }
+
+ if ( !arguments.length ) {
+ return this.attr( "class", "" );
+ }
+
+ classes = classesToArray( value );
+
+ if ( classes.length ) {
+ while ( ( elem = this[ i++ ] ) ) {
+ curValue = getClass( elem );
+
+ // This expression is here for better compressibility (see addClass)
+ cur = elem.nodeType === 1 && ( " " + stripAndCollapse( curValue ) + " " );
+
+ if ( cur ) {
+ j = 0;
+ while ( ( clazz = classes[ j++ ] ) ) {
+
+ // Remove *all* instances
+ while ( cur.indexOf( " " + clazz + " " ) > -1 ) {
+ cur = cur.replace( " " + clazz + " ", " " );
+ }
+ }
+
+ // Only assign if different to avoid unneeded rendering.
+ finalValue = stripAndCollapse( cur );
+ if ( curValue !== finalValue ) {
+ elem.setAttribute( "class", finalValue );
+ }
+ }
+ }
+ }
+
+ return this;
+ },
+
+ toggleClass: function( value, stateVal ) {
+ var type = typeof value,
+ isValidValue = type === "string" || Array.isArray( value );
+
+ if ( typeof stateVal === "boolean" && isValidValue ) {
+ return stateVal ? this.addClass( value ) : this.removeClass( value );
+ }
+
+ if ( isFunction( value ) ) {
+ return this.each( function( i ) {
+ jQuery( this ).toggleClass(
+ value.call( this, i, getClass( this ), stateVal ),
+ stateVal
+ );
+ } );
+ }
+
+ return this.each( function() {
+ var className, i, self, classNames;
+
+ if ( isValidValue ) {
+
+ // Toggle individual class names
+ i = 0;
+ self = jQuery( this );
+ classNames = classesToArray( value );
+
+ while ( ( className = classNames[ i++ ] ) ) {
+
+ // Check each className given, space separated list
+ if ( self.hasClass( className ) ) {
+ self.removeClass( className );
+ } else {
+ self.addClass( className );
+ }
+ }
+
+ // Toggle whole class name
+ } else if ( value === undefined || type === "boolean" ) {
+ className = getClass( this );
+ if ( className ) {
+
+ // Store className if set
+ dataPriv.set( this, "__className__", className );
+ }
+
+ // If the element has a class name or if we're passed `false`,
+ // then remove the whole classname (if there was one, the above saved it).
+ // Otherwise bring back whatever was previously saved (if anything),
+ // falling back to the empty string if nothing was stored.
+ if ( this.setAttribute ) {
+ this.setAttribute( "class",
+ className || value === false ?
+ "" :
+ dataPriv.get( this, "__className__" ) || ""
+ );
+ }
+ }
+ } );
+ },
+
+ hasClass: function( selector ) {
+ var className, elem,
+ i = 0;
+
+ className = " " + selector + " ";
+ while ( ( elem = this[ i++ ] ) ) {
+ if ( elem.nodeType === 1 &&
+ ( " " + stripAndCollapse( getClass( elem ) ) + " " ).indexOf( className ) > -1 ) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+} );
+
+
+
+
+var rreturn = /\r/g;
+
+jQuery.fn.extend( {
+ val: function( value ) {
+ var hooks, ret, valueIsFunction,
+ elem = this[ 0 ];
+
+ if ( !arguments.length ) {
+ if ( elem ) {
+ hooks = jQuery.valHooks[ elem.type ] ||
+ jQuery.valHooks[ elem.nodeName.toLowerCase() ];
+
+ if ( hooks &&
+ "get" in hooks &&
+ ( ret = hooks.get( elem, "value" ) ) !== undefined
+ ) {
+ return ret;
+ }
+
+ ret = elem.value;
+
+ // Handle most common string cases
+ if ( typeof ret === "string" ) {
+ return ret.replace( rreturn, "" );
+ }
+
+ // Handle cases where value is null/undef or number
+ return ret == null ? "" : ret;
+ }
+
+ return;
+ }
+
+ valueIsFunction = isFunction( value );
+
+ return this.each( function( i ) {
+ var val;
+
+ if ( this.nodeType !== 1 ) {
+ return;
+ }
+
+ if ( valueIsFunction ) {
+ val = value.call( this, i, jQuery( this ).val() );
+ } else {
+ val = value;
+ }
+
+ // Treat null/undefined as ""; convert numbers to string
+ if ( val == null ) {
+ val = "";
+
+ } else if ( typeof val === "number" ) {
+ val += "";
+
+ } else if ( Array.isArray( val ) ) {
+ val = jQuery.map( val, function( value ) {
+ return value == null ? "" : value + "";
+ } );
+ }
+
+ hooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ];
+
+ // If set returns undefined, fall back to normal setting
+ if ( !hooks || !( "set" in hooks ) || hooks.set( this, val, "value" ) === undefined ) {
+ this.value = val;
+ }
+ } );
+ }
+} );
+
+jQuery.extend( {
+ valHooks: {
+ option: {
+ get: function( elem ) {
+
+ var val = jQuery.find.attr( elem, "value" );
+ return val != null ?
+ val :
+
+ // Support: IE <=10 - 11 only
+ // option.text throws exceptions (#14686, #14858)
+ // Strip and collapse whitespace
+ // https://html.spec.whatwg.org/#strip-and-collapse-whitespace
+ stripAndCollapse( jQuery.text( elem ) );
+ }
+ },
+ select: {
+ get: function( elem ) {
+ var value, option, i,
+ options = elem.options,
+ index = elem.selectedIndex,
+ one = elem.type === "select-one",
+ values = one ? null : [],
+ max = one ? index + 1 : options.length;
+
+ if ( index < 0 ) {
+ i = max;
+
+ } else {
+ i = one ? index : 0;
+ }
+
+ // Loop through all the selected options
+ for ( ; i < max; i++ ) {
+ option = options[ i ];
+
+ // Support: IE <=9 only
+ // IE8-9 doesn't update selected after form reset (#2551)
+ if ( ( option.selected || i === index ) &&
+
+ // Don't return options that are disabled or in a disabled optgroup
+ !option.disabled &&
+ ( !option.parentNode.disabled ||
+ !nodeName( option.parentNode, "optgroup" ) ) ) {
+
+ // Get the specific value for the option
+ value = jQuery( option ).val();
+
+ // We don't need an array for one selects
+ if ( one ) {
+ return value;
+ }
+
+ // Multi-Selects return an array
+ values.push( value );
+ }
+ }
+
+ return values;
+ },
+
+ set: function( elem, value ) {
+ var optionSet, option,
+ options = elem.options,
+ values = jQuery.makeArray( value ),
+ i = options.length;
+
+ while ( i-- ) {
+ option = options[ i ];
+
+ /* eslint-disable no-cond-assign */
+
+ if ( option.selected =
+ jQuery.inArray( jQuery.valHooks.option.get( option ), values ) > -1
+ ) {
+ optionSet = true;
+ }
+
+ /* eslint-enable no-cond-assign */
+ }
+
+ // Force browsers to behave consistently when non-matching value is set
+ if ( !optionSet ) {
+ elem.selectedIndex = -1;
+ }
+ return values;
+ }
+ }
+ }
+} );
+
+// Radios and checkboxes getter/setter
+jQuery.each( [ "radio", "checkbox" ], function() {
+ jQuery.valHooks[ this ] = {
+ set: function( elem, value ) {
+ if ( Array.isArray( value ) ) {
+ return ( elem.checked = jQuery.inArray( jQuery( elem ).val(), value ) > -1 );
+ }
+ }
+ };
+ if ( !support.checkOn ) {
+ jQuery.valHooks[ this ].get = function( elem ) {
+ return elem.getAttribute( "value" ) === null ? "on" : elem.value;
+ };
+ }
+} );
+
+
+
+
+// Return jQuery for attributes-only inclusion
+
+
+support.focusin = "onfocusin" in window;
+
+
+var rfocusMorph = /^(?:focusinfocus|focusoutblur)$/,
+ stopPropagationCallback = function( e ) {
+ e.stopPropagation();
+ };
+
+jQuery.extend( jQuery.event, {
+
+ trigger: function( event, data, elem, onlyHandlers ) {
+
+ var i, cur, tmp, bubbleType, ontype, handle, special, lastElement,
+ eventPath = [ elem || document ],
+ type = hasOwn.call( event, "type" ) ? event.type : event,
+ namespaces = hasOwn.call( event, "namespace" ) ? event.namespace.split( "." ) : [];
+
+ cur = lastElement = tmp = elem = elem || document;
+
+ // Don't do events on text and comment nodes
+ if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
+ return;
+ }
+
+ // focus/blur morphs to focusin/out; ensure we're not firing them right now
+ if ( rfocusMorph.test( type + jQuery.event.triggered ) ) {
+ return;
+ }
+
+ if ( type.indexOf( "." ) > -1 ) {
+
+ // Namespaced trigger; create a regexp to match event type in handle()
+ namespaces = type.split( "." );
+ type = namespaces.shift();
+ namespaces.sort();
+ }
+ ontype = type.indexOf( ":" ) < 0 && "on" + type;
+
+ // Caller can pass in a jQuery.Event object, Object, or just an event type string
+ event = event[ jQuery.expando ] ?
+ event :
+ new jQuery.Event( type, typeof event === "object" && event );
+
+ // Trigger bitmask: & 1 for native handlers; & 2 for jQuery (always true)
+ event.isTrigger = onlyHandlers ? 2 : 3;
+ event.namespace = namespaces.join( "." );
+ event.rnamespace = event.namespace ?
+ new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" ) :
+ null;
+
+ // Clean up the event in case it is being reused
+ event.result = undefined;
+ if ( !event.target ) {
+ event.target = elem;
+ }
+
+ // Clone any incoming data and prepend the event, creating the handler arg list
+ data = data == null ?
+ [ event ] :
+ jQuery.makeArray( data, [ event ] );
+
+ // Allow special events to draw outside the lines
+ special = jQuery.event.special[ type ] || {};
+ if ( !onlyHandlers && special.trigger && special.trigger.apply( elem, data ) === false ) {
+ return;
+ }
+
+ // Determine event propagation path in advance, per W3C events spec (#9951)
+ // Bubble up to document, then to window; watch for a global ownerDocument var (#9724)
+ if ( !onlyHandlers && !special.noBubble && !isWindow( elem ) ) {
+
+ bubbleType = special.delegateType || type;
+ if ( !rfocusMorph.test( bubbleType + type ) ) {
+ cur = cur.parentNode;
+ }
+ for ( ; cur; cur = cur.parentNode ) {
+ eventPath.push( cur );
+ tmp = cur;
+ }
+
+ // Only add window if we got to document (e.g., not plain obj or detached DOM)
+ if ( tmp === ( elem.ownerDocument || document ) ) {
+ eventPath.push( tmp.defaultView || tmp.parentWindow || window );
+ }
+ }
+
+ // Fire handlers on the event path
+ i = 0;
+ while ( ( cur = eventPath[ i++ ] ) && !event.isPropagationStopped() ) {
+ lastElement = cur;
+ event.type = i > 1 ?
+ bubbleType :
+ special.bindType || type;
+
+ // jQuery handler
+ handle = ( dataPriv.get( cur, "events" ) || Object.create( null ) )[ event.type ] &&
+ dataPriv.get( cur, "handle" );
+ if ( handle ) {
+ handle.apply( cur, data );
+ }
+
+ // Native handler
+ handle = ontype && cur[ ontype ];
+ if ( handle && handle.apply && acceptData( cur ) ) {
+ event.result = handle.apply( cur, data );
+ if ( event.result === false ) {
+ event.preventDefault();
+ }
+ }
+ }
+ event.type = type;
+
+ // If nobody prevented the default action, do it now
+ if ( !onlyHandlers && !event.isDefaultPrevented() ) {
+
+ if ( ( !special._default ||
+ special._default.apply( eventPath.pop(), data ) === false ) &&
+ acceptData( elem ) ) {
+
+ // Call a native DOM method on the target with the same name as the event.
+ // Don't do default actions on window, that's where global variables be (#6170)
+ if ( ontype && isFunction( elem[ type ] ) && !isWindow( elem ) ) {
+
+ // Don't re-trigger an onFOO event when we call its FOO() method
+ tmp = elem[ ontype ];
+
+ if ( tmp ) {
+ elem[ ontype ] = null;
+ }
+
+ // Prevent re-triggering of the same event, since we already bubbled it above
+ jQuery.event.triggered = type;
+
+ if ( event.isPropagationStopped() ) {
+ lastElement.addEventListener( type, stopPropagationCallback );
+ }
+
+ elem[ type ]();
+
+ if ( event.isPropagationStopped() ) {
+ lastElement.removeEventListener( type, stopPropagationCallback );
+ }
+
+ jQuery.event.triggered = undefined;
+
+ if ( tmp ) {
+ elem[ ontype ] = tmp;
+ }
+ }
+ }
+ }
+
+ return event.result;
+ },
+
+ // Piggyback on a donor event to simulate a different one
+ // Used only for `focus(in | out)` events
+ simulate: function( type, elem, event ) {
+ var e = jQuery.extend(
+ new jQuery.Event(),
+ event,
+ {
+ type: type,
+ isSimulated: true
+ }
+ );
+
+ jQuery.event.trigger( e, null, elem );
+ }
+
+} );
+
+jQuery.fn.extend( {
+
+ trigger: function( type, data ) {
+ return this.each( function() {
+ jQuery.event.trigger( type, data, this );
+ } );
+ },
+ triggerHandler: function( type, data ) {
+ var elem = this[ 0 ];
+ if ( elem ) {
+ return jQuery.event.trigger( type, data, elem, true );
+ }
+ }
+} );
+
+
+// Support: Firefox <=44
+// Firefox doesn't have focus(in | out) events
+// Related ticket - https://bugzilla.mozilla.org/show_bug.cgi?id=687787
+//
+// Support: Chrome <=48 - 49, Safari <=9.0 - 9.1
+// focus(in | out) events fire after focus & blur events,
+// which is spec violation - http://www.w3.org/TR/DOM-Level-3-Events/#events-focusevent-event-order
+// Related ticket - https://bugs.chromium.org/p/chromium/issues/detail?id=449857
+if ( !support.focusin ) {
+ jQuery.each( { focus: "focusin", blur: "focusout" }, function( orig, fix ) {
+
+ // Attach a single capturing handler on the document while someone wants focusin/focusout
+ var handler = function( event ) {
+ jQuery.event.simulate( fix, event.target, jQuery.event.fix( event ) );
+ };
+
+ jQuery.event.special[ fix ] = {
+ setup: function() {
+
+ // Handle: regular nodes (via `this.ownerDocument`), window
+ // (via `this.document`) & document (via `this`).
+ var doc = this.ownerDocument || this.document || this,
+ attaches = dataPriv.access( doc, fix );
+
+ if ( !attaches ) {
+ doc.addEventListener( orig, handler, true );
+ }
+ dataPriv.access( doc, fix, ( attaches || 0 ) + 1 );
+ },
+ teardown: function() {
+ var doc = this.ownerDocument || this.document || this,
+ attaches = dataPriv.access( doc, fix ) - 1;
+
+ if ( !attaches ) {
+ doc.removeEventListener( orig, handler, true );
+ dataPriv.remove( doc, fix );
+
+ } else {
+ dataPriv.access( doc, fix, attaches );
+ }
+ }
+ };
+ } );
+}
+var location = window.location;
+
+var nonce = { guid: Date.now() };
+
+var rquery = ( /\?/ );
+
+
+
+// Cross-browser xml parsing
+jQuery.parseXML = function( data ) {
+ var xml, parserErrorElem;
+ if ( !data || typeof data !== "string" ) {
+ return null;
+ }
+
+ // Support: IE 9 - 11 only
+ // IE throws on parseFromString with invalid input.
+ try {
+ xml = ( new window.DOMParser() ).parseFromString( data, "text/xml" );
+ } catch ( e ) {}
+
+ parserErrorElem = xml && xml.getElementsByTagName( "parsererror" )[ 0 ];
+ if ( !xml || parserErrorElem ) {
+ jQuery.error( "Invalid XML: " + (
+ parserErrorElem ?
+ jQuery.map( parserErrorElem.childNodes, function( el ) {
+ return el.textContent;
+ } ).join( "\n" ) :
+ data
+ ) );
+ }
+ return xml;
+};
+
+
+var
+ rbracket = /\[\]$/,
+ rCRLF = /\r?\n/g,
+ rsubmitterTypes = /^(?:submit|button|image|reset|file)$/i,
+ rsubmittable = /^(?:input|select|textarea|keygen)/i;
+
+function buildParams( prefix, obj, traditional, add ) {
+ var name;
+
+ if ( Array.isArray( obj ) ) {
+
+ // Serialize array item.
+ jQuery.each( obj, function( i, v ) {
+ if ( traditional || rbracket.test( prefix ) ) {
+
+ // Treat each array item as a scalar.
+ add( prefix, v );
+
+ } else {
+
+ // Item is non-scalar (array or object), encode its numeric index.
+ buildParams(
+ prefix + "[" + ( typeof v === "object" && v != null ? i : "" ) + "]",
+ v,
+ traditional,
+ add
+ );
+ }
+ } );
+
+ } else if ( !traditional && toType( obj ) === "object" ) {
+
+ // Serialize object item.
+ for ( name in obj ) {
+ buildParams( prefix + "[" + name + "]", obj[ name ], traditional, add );
+ }
+
+ } else {
+
+ // Serialize scalar item.
+ add( prefix, obj );
+ }
+}
+
+// Serialize an array of form elements or a set of
+// key/values into a query string
+jQuery.param = function( a, traditional ) {
+ var prefix,
+ s = [],
+ add = function( key, valueOrFunction ) {
+
+ // If value is a function, invoke it and use its return value
+ var value = isFunction( valueOrFunction ) ?
+ valueOrFunction() :
+ valueOrFunction;
+
+ s[ s.length ] = encodeURIComponent( key ) + "=" +
+ encodeURIComponent( value == null ? "" : value );
+ };
+
+ if ( a == null ) {
+ return "";
+ }
+
+ // If an array was passed in, assume that it is an array of form elements.
+ if ( Array.isArray( a ) || ( a.jquery && !jQuery.isPlainObject( a ) ) ) {
+
+ // Serialize the form elements
+ jQuery.each( a, function() {
+ add( this.name, this.value );
+ } );
+
+ } else {
+
+ // If traditional, encode the "old" way (the way 1.3.2 or older
+ // did it), otherwise encode params recursively.
+ for ( prefix in a ) {
+ buildParams( prefix, a[ prefix ], traditional, add );
+ }
+ }
+
+ // Return the resulting serialization
+ return s.join( "&" );
+};
+
+jQuery.fn.extend( {
+ serialize: function() {
+ return jQuery.param( this.serializeArray() );
+ },
+ serializeArray: function() {
+ return this.map( function() {
+
+ // Can add propHook for "elements" to filter or add form elements
+ var elements = jQuery.prop( this, "elements" );
+ return elements ? jQuery.makeArray( elements ) : this;
+ } ).filter( function() {
+ var type = this.type;
+
+ // Use .is( ":disabled" ) so that fieldset[disabled] works
+ return this.name && !jQuery( this ).is( ":disabled" ) &&
+ rsubmittable.test( this.nodeName ) && !rsubmitterTypes.test( type ) &&
+ ( this.checked || !rcheckableType.test( type ) );
+ } ).map( function( _i, elem ) {
+ var val = jQuery( this ).val();
+
+ if ( val == null ) {
+ return null;
+ }
+
+ if ( Array.isArray( val ) ) {
+ return jQuery.map( val, function( val ) {
+ return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
+ } );
+ }
+
+ return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
+ } ).get();
+ }
+} );
+
+
+var
+ r20 = /%20/g,
+ rhash = /#.*$/,
+ rantiCache = /([?&])_=[^&]*/,
+ rheaders = /^(.*?):[ \t]*([^\r\n]*)$/mg,
+
+ // #7653, #8125, #8152: local protocol detection
+ rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/,
+ rnoContent = /^(?:GET|HEAD)$/,
+ rprotocol = /^\/\//,
+
+ /* Prefilters
+ * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)
+ * 2) These are called:
+ * - BEFORE asking for a transport
+ * - AFTER param serialization (s.data is a string if s.processData is true)
+ * 3) key is the dataType
+ * 4) the catchall symbol "*" can be used
+ * 5) execution will start with transport dataType and THEN continue down to "*" if needed
+ */
+ prefilters = {},
+
+ /* Transports bindings
+ * 1) key is the dataType
+ * 2) the catchall symbol "*" can be used
+ * 3) selection will start with transport dataType and THEN go to "*" if needed
+ */
+ transports = {},
+
+ // Avoid comment-prolog char sequence (#10098); must appease lint and evade compression
+ allTypes = "*/".concat( "*" ),
+
+ // Anchor tag for parsing the document origin
+ originAnchor = document.createElement( "a" );
+
+originAnchor.href = location.href;
+
+// Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport
+function addToPrefiltersOrTransports( structure ) {
+
+ // dataTypeExpression is optional and defaults to "*"
+ return function( dataTypeExpression, func ) {
+
+ if ( typeof dataTypeExpression !== "string" ) {
+ func = dataTypeExpression;
+ dataTypeExpression = "*";
+ }
+
+ var dataType,
+ i = 0,
+ dataTypes = dataTypeExpression.toLowerCase().match( rnothtmlwhite ) || [];
+
+ if ( isFunction( func ) ) {
+
+ // For each dataType in the dataTypeExpression
+ while ( ( dataType = dataTypes[ i++ ] ) ) {
+
+ // Prepend if requested
+ if ( dataType[ 0 ] === "+" ) {
+ dataType = dataType.slice( 1 ) || "*";
+ ( structure[ dataType ] = structure[ dataType ] || [] ).unshift( func );
+
+ // Otherwise append
+ } else {
+ ( structure[ dataType ] = structure[ dataType ] || [] ).push( func );
+ }
+ }
+ }
+ };
+}
+
+// Base inspection function for prefilters and transports
+function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR ) {
+
+ var inspected = {},
+ seekingTransport = ( structure === transports );
+
+ function inspect( dataType ) {
+ var selected;
+ inspected[ dataType ] = true;
+ jQuery.each( structure[ dataType ] || [], function( _, prefilterOrFactory ) {
+ var dataTypeOrTransport = prefilterOrFactory( options, originalOptions, jqXHR );
+ if ( typeof dataTypeOrTransport === "string" &&
+ !seekingTransport && !inspected[ dataTypeOrTransport ] ) {
+
+ options.dataTypes.unshift( dataTypeOrTransport );
+ inspect( dataTypeOrTransport );
+ return false;
+ } else if ( seekingTransport ) {
+ return !( selected = dataTypeOrTransport );
+ }
+ } );
+ return selected;
+ }
+
+ return inspect( options.dataTypes[ 0 ] ) || !inspected[ "*" ] && inspect( "*" );
+}
+
+// A special extend for ajax options
+// that takes "flat" options (not to be deep extended)
+// Fixes #9887
+function ajaxExtend( target, src ) {
+ var key, deep,
+ flatOptions = jQuery.ajaxSettings.flatOptions || {};
+
+ for ( key in src ) {
+ if ( src[ key ] !== undefined ) {
+ ( flatOptions[ key ] ? target : ( deep || ( deep = {} ) ) )[ key ] = src[ key ];
+ }
+ }
+ if ( deep ) {
+ jQuery.extend( true, target, deep );
+ }
+
+ return target;
+}
+
+/* Handles responses to an ajax request:
+ * - finds the right dataType (mediates between content-type and expected dataType)
+ * - returns the corresponding response
+ */
+function ajaxHandleResponses( s, jqXHR, responses ) {
+
+ var ct, type, finalDataType, firstDataType,
+ contents = s.contents,
+ dataTypes = s.dataTypes;
+
+ // Remove auto dataType and get content-type in the process
+ while ( dataTypes[ 0 ] === "*" ) {
+ dataTypes.shift();
+ if ( ct === undefined ) {
+ ct = s.mimeType || jqXHR.getResponseHeader( "Content-Type" );
+ }
+ }
+
+ // Check if we're dealing with a known content-type
+ if ( ct ) {
+ for ( type in contents ) {
+ if ( contents[ type ] && contents[ type ].test( ct ) ) {
+ dataTypes.unshift( type );
+ break;
+ }
+ }
+ }
+
+ // Check to see if we have a response for the expected dataType
+ if ( dataTypes[ 0 ] in responses ) {
+ finalDataType = dataTypes[ 0 ];
+ } else {
+
+ // Try convertible dataTypes
+ for ( type in responses ) {
+ if ( !dataTypes[ 0 ] || s.converters[ type + " " + dataTypes[ 0 ] ] ) {
+ finalDataType = type;
+ break;
+ }
+ if ( !firstDataType ) {
+ firstDataType = type;
+ }
+ }
+
+ // Or just use first one
+ finalDataType = finalDataType || firstDataType;
+ }
+
+ // If we found a dataType
+ // We add the dataType to the list if needed
+ // and return the corresponding response
+ if ( finalDataType ) {
+ if ( finalDataType !== dataTypes[ 0 ] ) {
+ dataTypes.unshift( finalDataType );
+ }
+ return responses[ finalDataType ];
+ }
+}
+
+/* Chain conversions given the request and the original response
+ * Also sets the responseXXX fields on the jqXHR instance
+ */
+function ajaxConvert( s, response, jqXHR, isSuccess ) {
+ var conv2, current, conv, tmp, prev,
+ converters = {},
+
+ // Work with a copy of dataTypes in case we need to modify it for conversion
+ dataTypes = s.dataTypes.slice();
+
+ // Create converters map with lowercased keys
+ if ( dataTypes[ 1 ] ) {
+ for ( conv in s.converters ) {
+ converters[ conv.toLowerCase() ] = s.converters[ conv ];
+ }
+ }
+
+ current = dataTypes.shift();
+
+ // Convert to each sequential dataType
+ while ( current ) {
+
+ if ( s.responseFields[ current ] ) {
+ jqXHR[ s.responseFields[ current ] ] = response;
+ }
+
+ // Apply the dataFilter if provided
+ if ( !prev && isSuccess && s.dataFilter ) {
+ response = s.dataFilter( response, s.dataType );
+ }
+
+ prev = current;
+ current = dataTypes.shift();
+
+ if ( current ) {
+
+ // There's only work to do if current dataType is non-auto
+ if ( current === "*" ) {
+
+ current = prev;
+
+ // Convert response if prev dataType is non-auto and differs from current
+ } else if ( prev !== "*" && prev !== current ) {
+
+ // Seek a direct converter
+ conv = converters[ prev + " " + current ] || converters[ "* " + current ];
+
+ // If none found, seek a pair
+ if ( !conv ) {
+ for ( conv2 in converters ) {
+
+ // If conv2 outputs current
+ tmp = conv2.split( " " );
+ if ( tmp[ 1 ] === current ) {
+
+ // If prev can be converted to accepted input
+ conv = converters[ prev + " " + tmp[ 0 ] ] ||
+ converters[ "* " + tmp[ 0 ] ];
+ if ( conv ) {
+
+ // Condense equivalence converters
+ if ( conv === true ) {
+ conv = converters[ conv2 ];
+
+ // Otherwise, insert the intermediate dataType
+ } else if ( converters[ conv2 ] !== true ) {
+ current = tmp[ 0 ];
+ dataTypes.unshift( tmp[ 1 ] );
+ }
+ break;
+ }
+ }
+ }
+ }
+
+ // Apply converter (if not an equivalence)
+ if ( conv !== true ) {
+
+ // Unless errors are allowed to bubble, catch and return them
+ if ( conv && s.throws ) {
+ response = conv( response );
+ } else {
+ try {
+ response = conv( response );
+ } catch ( e ) {
+ return {
+ state: "parsererror",
+ error: conv ? e : "No conversion from " + prev + " to " + current
+ };
+ }
+ }
+ }
+ }
+ }
+ }
+
+ return { state: "success", data: response };
+}
+
+jQuery.extend( {
+
+ // Counter for holding the number of active queries
+ active: 0,
+
+ // Last-Modified header cache for next request
+ lastModified: {},
+ etag: {},
+
+ ajaxSettings: {
+ url: location.href,
+ type: "GET",
+ isLocal: rlocalProtocol.test( location.protocol ),
+ global: true,
+ processData: true,
+ async: true,
+ contentType: "application/x-www-form-urlencoded; charset=UTF-8",
+
+ /*
+ timeout: 0,
+ data: null,
+ dataType: null,
+ username: null,
+ password: null,
+ cache: null,
+ throws: false,
+ traditional: false,
+ headers: {},
+ */
+
+ accepts: {
+ "*": allTypes,
+ text: "text/plain",
+ html: "text/html",
+ xml: "application/xml, text/xml",
+ json: "application/json, text/javascript"
+ },
+
+ contents: {
+ xml: /\bxml\b/,
+ html: /\bhtml/,
+ json: /\bjson\b/
+ },
+
+ responseFields: {
+ xml: "responseXML",
+ text: "responseText",
+ json: "responseJSON"
+ },
+
+ // Data converters
+ // Keys separate source (or catchall "*") and destination types with a single space
+ converters: {
+
+ // Convert anything to text
+ "* text": String,
+
+ // Text to html (true = no transformation)
+ "text html": true,
+
+ // Evaluate text as a json expression
+ "text json": JSON.parse,
+
+ // Parse text as xml
+ "text xml": jQuery.parseXML
+ },
+
+ // For options that shouldn't be deep extended:
+ // you can add your own custom options here if
+ // and when you create one that shouldn't be
+ // deep extended (see ajaxExtend)
+ flatOptions: {
+ url: true,
+ context: true
+ }
+ },
+
+ // Creates a full fledged settings object into target
+ // with both ajaxSettings and settings fields.
+ // If target is omitted, writes into ajaxSettings.
+ ajaxSetup: function( target, settings ) {
+ return settings ?
+
+ // Building a settings object
+ ajaxExtend( ajaxExtend( target, jQuery.ajaxSettings ), settings ) :
+
+ // Extending ajaxSettings
+ ajaxExtend( jQuery.ajaxSettings, target );
+ },
+
+ ajaxPrefilter: addToPrefiltersOrTransports( prefilters ),
+ ajaxTransport: addToPrefiltersOrTransports( transports ),
+
+ // Main method
+ ajax: function( url, options ) {
+
+ // If url is an object, simulate pre-1.5 signature
+ if ( typeof url === "object" ) {
+ options = url;
+ url = undefined;
+ }
+
+ // Force options to be an object
+ options = options || {};
+
+ var transport,
+
+ // URL without anti-cache param
+ cacheURL,
+
+ // Response headers
+ responseHeadersString,
+ responseHeaders,
+
+ // timeout handle
+ timeoutTimer,
+
+ // Url cleanup var
+ urlAnchor,
+
+ // Request state (becomes false upon send and true upon completion)
+ completed,
+
+ // To know if global events are to be dispatched
+ fireGlobals,
+
+ // Loop variable
+ i,
+
+ // uncached part of the url
+ uncached,
+
+ // Create the final options object
+ s = jQuery.ajaxSetup( {}, options ),
+
+ // Callbacks context
+ callbackContext = s.context || s,
+
+ // Context for global events is callbackContext if it is a DOM node or jQuery collection
+ globalEventContext = s.context &&
+ ( callbackContext.nodeType || callbackContext.jquery ) ?
+ jQuery( callbackContext ) :
+ jQuery.event,
+
+ // Deferreds
+ deferred = jQuery.Deferred(),
+ completeDeferred = jQuery.Callbacks( "once memory" ),
+
+ // Status-dependent callbacks
+ statusCode = s.statusCode || {},
+
+ // Headers (they are sent all at once)
+ requestHeaders = {},
+ requestHeadersNames = {},
+
+ // Default abort message
+ strAbort = "canceled",
+
+ // Fake xhr
+ jqXHR = {
+ readyState: 0,
+
+ // Builds headers hashtable if needed
+ getResponseHeader: function( key ) {
+ var match;
+ if ( completed ) {
+ if ( !responseHeaders ) {
+ responseHeaders = {};
+ while ( ( match = rheaders.exec( responseHeadersString ) ) ) {
+ responseHeaders[ match[ 1 ].toLowerCase() + " " ] =
+ ( responseHeaders[ match[ 1 ].toLowerCase() + " " ] || [] )
+ .concat( match[ 2 ] );
+ }
+ }
+ match = responseHeaders[ key.toLowerCase() + " " ];
+ }
+ return match == null ? null : match.join( ", " );
+ },
+
+ // Raw string
+ getAllResponseHeaders: function() {
+ return completed ? responseHeadersString : null;
+ },
+
+ // Caches the header
+ setRequestHeader: function( name, value ) {
+ if ( completed == null ) {
+ name = requestHeadersNames[ name.toLowerCase() ] =
+ requestHeadersNames[ name.toLowerCase() ] || name;
+ requestHeaders[ name ] = value;
+ }
+ return this;
+ },
+
+ // Overrides response content-type header
+ overrideMimeType: function( type ) {
+ if ( completed == null ) {
+ s.mimeType = type;
+ }
+ return this;
+ },
+
+ // Status-dependent callbacks
+ statusCode: function( map ) {
+ var code;
+ if ( map ) {
+ if ( completed ) {
+
+ // Execute the appropriate callbacks
+ jqXHR.always( map[ jqXHR.status ] );
+ } else {
+
+ // Lazy-add the new callbacks in a way that preserves old ones
+ for ( code in map ) {
+ statusCode[ code ] = [ statusCode[ code ], map[ code ] ];
+ }
+ }
+ }
+ return this;
+ },
+
+ // Cancel the request
+ abort: function( statusText ) {
+ var finalText = statusText || strAbort;
+ if ( transport ) {
+ transport.abort( finalText );
+ }
+ done( 0, finalText );
+ return this;
+ }
+ };
+
+ // Attach deferreds
+ deferred.promise( jqXHR );
+
+ // Add protocol if not provided (prefilters might expect it)
+ // Handle falsy url in the settings object (#10093: consistency with old signature)
+ // We also use the url parameter if available
+ s.url = ( ( url || s.url || location.href ) + "" )
+ .replace( rprotocol, location.protocol + "//" );
+
+ // Alias method option to type as per ticket #12004
+ s.type = options.method || options.type || s.method || s.type;
+
+ // Extract dataTypes list
+ s.dataTypes = ( s.dataType || "*" ).toLowerCase().match( rnothtmlwhite ) || [ "" ];
+
+ // A cross-domain request is in order when the origin doesn't match the current origin.
+ if ( s.crossDomain == null ) {
+ urlAnchor = document.createElement( "a" );
+
+ // Support: IE <=8 - 11, Edge 12 - 15
+ // IE throws exception on accessing the href property if url is malformed,
+ // e.g. http://example.com:80x/
+ try {
+ urlAnchor.href = s.url;
+
+ // Support: IE <=8 - 11 only
+ // Anchor's host property isn't correctly set when s.url is relative
+ urlAnchor.href = urlAnchor.href;
+ s.crossDomain = originAnchor.protocol + "//" + originAnchor.host !==
+ urlAnchor.protocol + "//" + urlAnchor.host;
+ } catch ( e ) {
+
+ // If there is an error parsing the URL, assume it is crossDomain,
+ // it can be rejected by the transport if it is invalid
+ s.crossDomain = true;
+ }
+ }
+
+ // Convert data if not already a string
+ if ( s.data && s.processData && typeof s.data !== "string" ) {
+ s.data = jQuery.param( s.data, s.traditional );
+ }
+
+ // Apply prefilters
+ inspectPrefiltersOrTransports( prefilters, s, options, jqXHR );
+
+ // If request was aborted inside a prefilter, stop there
+ if ( completed ) {
+ return jqXHR;
+ }
+
+ // We can fire global events as of now if asked to
+ // Don't fire events if jQuery.event is undefined in an AMD-usage scenario (#15118)
+ fireGlobals = jQuery.event && s.global;
+
+ // Watch for a new set of requests
+ if ( fireGlobals && jQuery.active++ === 0 ) {
+ jQuery.event.trigger( "ajaxStart" );
+ }
+
+ // Uppercase the type
+ s.type = s.type.toUpperCase();
+
+ // Determine if request has content
+ s.hasContent = !rnoContent.test( s.type );
+
+ // Save the URL in case we're toying with the If-Modified-Since
+ // and/or If-None-Match header later on
+ // Remove hash to simplify url manipulation
+ cacheURL = s.url.replace( rhash, "" );
+
+ // More options handling for requests with no content
+ if ( !s.hasContent ) {
+
+ // Remember the hash so we can put it back
+ uncached = s.url.slice( cacheURL.length );
+
+ // If data is available and should be processed, append data to url
+ if ( s.data && ( s.processData || typeof s.data === "string" ) ) {
+ cacheURL += ( rquery.test( cacheURL ) ? "&" : "?" ) + s.data;
+
+ // #9682: remove data so that it's not used in an eventual retry
+ delete s.data;
+ }
+
+ // Add or update anti-cache param if needed
+ if ( s.cache === false ) {
+ cacheURL = cacheURL.replace( rantiCache, "$1" );
+ uncached = ( rquery.test( cacheURL ) ? "&" : "?" ) + "_=" + ( nonce.guid++ ) +
+ uncached;
+ }
+
+ // Put hash and anti-cache on the URL that will be requested (gh-1732)
+ s.url = cacheURL + uncached;
+
+ // Change '%20' to '+' if this is encoded form body content (gh-2658)
+ } else if ( s.data && s.processData &&
+ ( s.contentType || "" ).indexOf( "application/x-www-form-urlencoded" ) === 0 ) {
+ s.data = s.data.replace( r20, "+" );
+ }
+
+ // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
+ if ( s.ifModified ) {
+ if ( jQuery.lastModified[ cacheURL ] ) {
+ jqXHR.setRequestHeader( "If-Modified-Since", jQuery.lastModified[ cacheURL ] );
+ }
+ if ( jQuery.etag[ cacheURL ] ) {
+ jqXHR.setRequestHeader( "If-None-Match", jQuery.etag[ cacheURL ] );
+ }
+ }
+
+ // Set the correct header, if data is being sent
+ if ( s.data && s.hasContent && s.contentType !== false || options.contentType ) {
+ jqXHR.setRequestHeader( "Content-Type", s.contentType );
+ }
+
+ // Set the Accepts header for the server, depending on the dataType
+ jqXHR.setRequestHeader(
+ "Accept",
+ s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[ 0 ] ] ?
+ s.accepts[ s.dataTypes[ 0 ] ] +
+ ( s.dataTypes[ 0 ] !== "*" ? ", " + allTypes + "; q=0.01" : "" ) :
+ s.accepts[ "*" ]
+ );
+
+ // Check for headers option
+ for ( i in s.headers ) {
+ jqXHR.setRequestHeader( i, s.headers[ i ] );
+ }
+
+ // Allow custom headers/mimetypes and early abort
+ if ( s.beforeSend &&
+ ( s.beforeSend.call( callbackContext, jqXHR, s ) === false || completed ) ) {
+
+ // Abort if not done already and return
+ return jqXHR.abort();
+ }
+
+ // Aborting is no longer a cancellation
+ strAbort = "abort";
+
+ // Install callbacks on deferreds
+ completeDeferred.add( s.complete );
+ jqXHR.done( s.success );
+ jqXHR.fail( s.error );
+
+ // Get transport
+ transport = inspectPrefiltersOrTransports( transports, s, options, jqXHR );
+
+ // If no transport, we auto-abort
+ if ( !transport ) {
+ done( -1, "No Transport" );
+ } else {
+ jqXHR.readyState = 1;
+
+ // Send global event
+ if ( fireGlobals ) {
+ globalEventContext.trigger( "ajaxSend", [ jqXHR, s ] );
+ }
+
+ // If request was aborted inside ajaxSend, stop there
+ if ( completed ) {
+ return jqXHR;
+ }
+
+ // Timeout
+ if ( s.async && s.timeout > 0 ) {
+ timeoutTimer = window.setTimeout( function() {
+ jqXHR.abort( "timeout" );
+ }, s.timeout );
+ }
+
+ try {
+ completed = false;
+ transport.send( requestHeaders, done );
+ } catch ( e ) {
+
+ // Rethrow post-completion exceptions
+ if ( completed ) {
+ throw e;
+ }
+
+ // Propagate others as results
+ done( -1, e );
+ }
+ }
+
+ // Callback for when everything is done
+ function done( status, nativeStatusText, responses, headers ) {
+ var isSuccess, success, error, response, modified,
+ statusText = nativeStatusText;
+
+ // Ignore repeat invocations
+ if ( completed ) {
+ return;
+ }
+
+ completed = true;
+
+ // Clear timeout if it exists
+ if ( timeoutTimer ) {
+ window.clearTimeout( timeoutTimer );
+ }
+
+ // Dereference transport for early garbage collection
+ // (no matter how long the jqXHR object will be used)
+ transport = undefined;
+
+ // Cache response headers
+ responseHeadersString = headers || "";
+
+ // Set readyState
+ jqXHR.readyState = status > 0 ? 4 : 0;
+
+ // Determine if successful
+ isSuccess = status >= 200 && status < 300 || status === 304;
+
+ // Get response data
+ if ( responses ) {
+ response = ajaxHandleResponses( s, jqXHR, responses );
+ }
+
+ // Use a noop converter for missing script but not if jsonp
+ if ( !isSuccess &&
+ jQuery.inArray( "script", s.dataTypes ) > -1 &&
+ jQuery.inArray( "json", s.dataTypes ) < 0 ) {
+ s.converters[ "text script" ] = function() {};
+ }
+
+ // Convert no matter what (that way responseXXX fields are always set)
+ response = ajaxConvert( s, response, jqXHR, isSuccess );
+
+ // If successful, handle type chaining
+ if ( isSuccess ) {
+
+ // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
+ if ( s.ifModified ) {
+ modified = jqXHR.getResponseHeader( "Last-Modified" );
+ if ( modified ) {
+ jQuery.lastModified[ cacheURL ] = modified;
+ }
+ modified = jqXHR.getResponseHeader( "etag" );
+ if ( modified ) {
+ jQuery.etag[ cacheURL ] = modified;
+ }
+ }
+
+ // if no content
+ if ( status === 204 || s.type === "HEAD" ) {
+ statusText = "nocontent";
+
+ // if not modified
+ } else if ( status === 304 ) {
+ statusText = "notmodified";
+
+ // If we have data, let's convert it
+ } else {
+ statusText = response.state;
+ success = response.data;
+ error = response.error;
+ isSuccess = !error;
+ }
+ } else {
+
+ // Extract error from statusText and normalize for non-aborts
+ error = statusText;
+ if ( status || !statusText ) {
+ statusText = "error";
+ if ( status < 0 ) {
+ status = 0;
+ }
+ }
+ }
+
+ // Set data for the fake xhr object
+ jqXHR.status = status;
+ jqXHR.statusText = ( nativeStatusText || statusText ) + "";
+
+ // Success/Error
+ if ( isSuccess ) {
+ deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] );
+ } else {
+ deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] );
+ }
+
+ // Status-dependent callbacks
+ jqXHR.statusCode( statusCode );
+ statusCode = undefined;
+
+ if ( fireGlobals ) {
+ globalEventContext.trigger( isSuccess ? "ajaxSuccess" : "ajaxError",
+ [ jqXHR, s, isSuccess ? success : error ] );
+ }
+
+ // Complete
+ completeDeferred.fireWith( callbackContext, [ jqXHR, statusText ] );
+
+ if ( fireGlobals ) {
+ globalEventContext.trigger( "ajaxComplete", [ jqXHR, s ] );
+
+ // Handle the global AJAX counter
+ if ( !( --jQuery.active ) ) {
+ jQuery.event.trigger( "ajaxStop" );
+ }
+ }
+ }
+
+ return jqXHR;
+ },
+
+ getJSON: function( url, data, callback ) {
+ return jQuery.get( url, data, callback, "json" );
+ },
+
+ getScript: function( url, callback ) {
+ return jQuery.get( url, undefined, callback, "script" );
+ }
+} );
+
+jQuery.each( [ "get", "post" ], function( _i, method ) {
+ jQuery[ method ] = function( url, data, callback, type ) {
+
+ // Shift arguments if data argument was omitted
+ if ( isFunction( data ) ) {
+ type = type || callback;
+ callback = data;
+ data = undefined;
+ }
+
+ // The url can be an options object (which then must have .url)
+ return jQuery.ajax( jQuery.extend( {
+ url: url,
+ type: method,
+ dataType: type,
+ data: data,
+ success: callback
+ }, jQuery.isPlainObject( url ) && url ) );
+ };
+} );
+
+jQuery.ajaxPrefilter( function( s ) {
+ var i;
+ for ( i in s.headers ) {
+ if ( i.toLowerCase() === "content-type" ) {
+ s.contentType = s.headers[ i ] || "";
+ }
+ }
+} );
+
+
+jQuery._evalUrl = function( url, options, doc ) {
+ return jQuery.ajax( {
+ url: url,
+
+ // Make this explicit, since user can override this through ajaxSetup (#11264)
+ type: "GET",
+ dataType: "script",
+ cache: true,
+ async: false,
+ global: false,
+
+ // Only evaluate the response if it is successful (gh-4126)
+ // dataFilter is not invoked for failure responses, so using it instead
+ // of the default converter is kludgy but it works.
+ converters: {
+ "text script": function() {}
+ },
+ dataFilter: function( response ) {
+ jQuery.globalEval( response, options, doc );
+ }
+ } );
+};
+
+
+jQuery.fn.extend( {
+ wrapAll: function( html ) {
+ var wrap;
+
+ if ( this[ 0 ] ) {
+ if ( isFunction( html ) ) {
+ html = html.call( this[ 0 ] );
+ }
+
+ // The elements to wrap the target around
+ wrap = jQuery( html, this[ 0 ].ownerDocument ).eq( 0 ).clone( true );
+
+ if ( this[ 0 ].parentNode ) {
+ wrap.insertBefore( this[ 0 ] );
+ }
+
+ wrap.map( function() {
+ var elem = this;
+
+ while ( elem.firstElementChild ) {
+ elem = elem.firstElementChild;
+ }
+
+ return elem;
+ } ).append( this );
+ }
+
+ return this;
+ },
+
+ wrapInner: function( html ) {
+ if ( isFunction( html ) ) {
+ return this.each( function( i ) {
+ jQuery( this ).wrapInner( html.call( this, i ) );
+ } );
+ }
+
+ return this.each( function() {
+ var self = jQuery( this ),
+ contents = self.contents();
+
+ if ( contents.length ) {
+ contents.wrapAll( html );
+
+ } else {
+ self.append( html );
+ }
+ } );
+ },
+
+ wrap: function( html ) {
+ var htmlIsFunction = isFunction( html );
+
+ return this.each( function( i ) {
+ jQuery( this ).wrapAll( htmlIsFunction ? html.call( this, i ) : html );
+ } );
+ },
+
+ unwrap: function( selector ) {
+ this.parent( selector ).not( "body" ).each( function() {
+ jQuery( this ).replaceWith( this.childNodes );
+ } );
+ return this;
+ }
+} );
+
+
+jQuery.expr.pseudos.hidden = function( elem ) {
+ return !jQuery.expr.pseudos.visible( elem );
+};
+jQuery.expr.pseudos.visible = function( elem ) {
+ return !!( elem.offsetWidth || elem.offsetHeight || elem.getClientRects().length );
+};
+
+
+
+
+jQuery.ajaxSettings.xhr = function() {
+ try {
+ return new window.XMLHttpRequest();
+ } catch ( e ) {}
+};
+
+var xhrSuccessStatus = {
+
+ // File protocol always yields status code 0, assume 200
+ 0: 200,
+
+ // Support: IE <=9 only
+ // #1450: sometimes IE returns 1223 when it should be 204
+ 1223: 204
+ },
+ xhrSupported = jQuery.ajaxSettings.xhr();
+
+support.cors = !!xhrSupported && ( "withCredentials" in xhrSupported );
+support.ajax = xhrSupported = !!xhrSupported;
+
+jQuery.ajaxTransport( function( options ) {
+ var callback, errorCallback;
+
+ // Cross domain only allowed if supported through XMLHttpRequest
+ if ( support.cors || xhrSupported && !options.crossDomain ) {
+ return {
+ send: function( headers, complete ) {
+ var i,
+ xhr = options.xhr();
+
+ xhr.open(
+ options.type,
+ options.url,
+ options.async,
+ options.username,
+ options.password
+ );
+
+ // Apply custom fields if provided
+ if ( options.xhrFields ) {
+ for ( i in options.xhrFields ) {
+ xhr[ i ] = options.xhrFields[ i ];
+ }
+ }
+
+ // Override mime type if needed
+ if ( options.mimeType && xhr.overrideMimeType ) {
+ xhr.overrideMimeType( options.mimeType );
+ }
+
+ // X-Requested-With header
+ // For cross-domain requests, seeing as conditions for a preflight are
+ // akin to a jigsaw puzzle, we simply never set it to be sure.
+ // (it can always be set on a per-request basis or even using ajaxSetup)
+ // For same-domain requests, won't change header if already provided.
+ if ( !options.crossDomain && !headers[ "X-Requested-With" ] ) {
+ headers[ "X-Requested-With" ] = "XMLHttpRequest";
+ }
+
+ // Set headers
+ for ( i in headers ) {
+ xhr.setRequestHeader( i, headers[ i ] );
+ }
+
+ // Callback
+ callback = function( type ) {
+ return function() {
+ if ( callback ) {
+ callback = errorCallback = xhr.onload =
+ xhr.onerror = xhr.onabort = xhr.ontimeout =
+ xhr.onreadystatechange = null;
+
+ if ( type === "abort" ) {
+ xhr.abort();
+ } else if ( type === "error" ) {
+
+ // Support: IE <=9 only
+ // On a manual native abort, IE9 throws
+ // errors on any property access that is not readyState
+ if ( typeof xhr.status !== "number" ) {
+ complete( 0, "error" );
+ } else {
+ complete(
+
+ // File: protocol always yields status 0; see #8605, #14207
+ xhr.status,
+ xhr.statusText
+ );
+ }
+ } else {
+ complete(
+ xhrSuccessStatus[ xhr.status ] || xhr.status,
+ xhr.statusText,
+
+ // Support: IE <=9 only
+ // IE9 has no XHR2 but throws on binary (trac-11426)
+ // For XHR2 non-text, let the caller handle it (gh-2498)
+ ( xhr.responseType || "text" ) !== "text" ||
+ typeof xhr.responseText !== "string" ?
+ { binary: xhr.response } :
+ { text: xhr.responseText },
+ xhr.getAllResponseHeaders()
+ );
+ }
+ }
+ };
+ };
+
+ // Listen to events
+ xhr.onload = callback();
+ errorCallback = xhr.onerror = xhr.ontimeout = callback( "error" );
+
+ // Support: IE 9 only
+ // Use onreadystatechange to replace onabort
+ // to handle uncaught aborts
+ if ( xhr.onabort !== undefined ) {
+ xhr.onabort = errorCallback;
+ } else {
+ xhr.onreadystatechange = function() {
+
+ // Check readyState before timeout as it changes
+ if ( xhr.readyState === 4 ) {
+
+ // Allow onerror to be called first,
+ // but that will not handle a native abort
+ // Also, save errorCallback to a variable
+ // as xhr.onerror cannot be accessed
+ window.setTimeout( function() {
+ if ( callback ) {
+ errorCallback();
+ }
+ } );
+ }
+ };
+ }
+
+ // Create the abort callback
+ callback = callback( "abort" );
+
+ try {
+
+ // Do send the request (this may raise an exception)
+ xhr.send( options.hasContent && options.data || null );
+ } catch ( e ) {
+
+ // #14683: Only rethrow if this hasn't been notified as an error yet
+ if ( callback ) {
+ throw e;
+ }
+ }
+ },
+
+ abort: function() {
+ if ( callback ) {
+ callback();
+ }
+ }
+ };
+ }
+} );
+
+
+
+
+// Prevent auto-execution of scripts when no explicit dataType was provided (See gh-2432)
+jQuery.ajaxPrefilter( function( s ) {
+ if ( s.crossDomain ) {
+ s.contents.script = false;
+ }
+} );
+
+// Install script dataType
+jQuery.ajaxSetup( {
+ accepts: {
+ script: "text/javascript, application/javascript, " +
+ "application/ecmascript, application/x-ecmascript"
+ },
+ contents: {
+ script: /\b(?:java|ecma)script\b/
+ },
+ converters: {
+ "text script": function( text ) {
+ jQuery.globalEval( text );
+ return text;
+ }
+ }
+} );
+
+// Handle cache's special case and crossDomain
+jQuery.ajaxPrefilter( "script", function( s ) {
+ if ( s.cache === undefined ) {
+ s.cache = false;
+ }
+ if ( s.crossDomain ) {
+ s.type = "GET";
+ }
+} );
+
+// Bind script tag hack transport
+jQuery.ajaxTransport( "script", function( s ) {
+
+ // This transport only deals with cross domain or forced-by-attrs requests
+ if ( s.crossDomain || s.scriptAttrs ) {
+ var script, callback;
+ return {
+ send: function( _, complete ) {
+ script = jQuery( "
-
-
-
-
encodeQA {RStoolbox} R Documentation
-
-
Encode QA Conditions to Integers
-
-
Description
-
-
Intended for use with Landsat 16-bit QA bands. Converts pixel quality flags from human readable to integer, which can then be used to
-subset a QA image. Please be aware of the default settings which differ for different parameters.
-Depending on, which sensor and legacy is selected, some quality parameters are not used, since the sequences of available bitwise quality designations differ per sensor and collection.
-
-
-
-
Usage
-
-
encodeQA(
- fill = "no",
- terrainOcclusion = "no",
- radSaturation = "na",
- cloudMask = "all",
- cloud = "all",
- cloudShadow = "all",
- snow = "all",
- cirrus = "all",
- droppedPixel = "no",
- water = "all",
- droppedFrame = "no",
- sensor = "OLI",
- legacy = "collection1"
-)
-
-
-
-
Arguments
-
-
-fill
-Designated fill. Options: c("yes", "no", "all").
- terrainOcclusion
-Terrain induced occlusion. Options: c("yes", "no", "all").
- radSaturation
-Number of bands that contain radiometric saturation. Options: c("na", "low", "med", "high", "all") for no bands, 1-2 bands, 3-4 bands, 5 or more bands contain saturation.
- cloudMask
-Cloud mask. Options: c("yes", "no", "all").
- cloud
-Cloud confidence. Options: c("na", "low", "med", "high", "all").
- cloudShadow
-Cloud shadow confidence. Options: c("yes", "no", "all").
- snow
-Snow / ice confidence. Options: c("na", "low", "med", "high", "all").
- cirrus
-Cirrus confidence. Options: c("na", "low", "med", "high", "all").
- droppedPixel
-Dropped pixel. Options: c("yes", "no", "all").
- water
-Water confidence. Options: c("na", "low", "med", "high", "all").
- droppedFrame
-Dropped frame. Options: c("yes", "no", "all").
- sensor
-Sensor to encode. Options: c("OLI", "TIRS", "ETM+", "TM", "MSS").
- legacy
-Encoding systematic Options: c("collection1", "pre_collection"). Default is "collection1" for the Landsat Collection 1 8-bit quality designations. Use "pre_collection" for imagery downloaded before the Collection 1 quality designations were introduced
-
-
-
-
Value
-
-
Returns the Integer value for the QA values
-
-
-
-
Note
-
-
Only currently populated bits are available as arguments.
-
-
-
-
References
-
-
https://www.usgs.gov/landsat-missions/landsat-collection-1-level-1-quality-assessment-band for Collection 1 quality designations (legacy = "collection1")
-
-
-
-
Examples
-
-
encodeQA(snow = "low", cirrus = c("med", "high"), cloud = "high")
-
-
## [1] 23136 23264 23392 23520 23152 23280 23408 23536
-
-
-
-
[Package
RStoolbox version 0.4.0
Index ]
-
R: Estimate Image Haze for Dark Object Subtraction (DOS)
-
-
-
estimateHaze {RStoolbox} R Documentation
-
-
Estimate Image Haze for Dark Object Subtraction (DOS)
-
-
Description
-
-
estimates the digital number (DN) pixel value of *dark* objects for the visible wavelength range.
-
-
-
-
Usage
-
-
estimateHaze(
- x,
- hazeBands,
- darkProp = 0.01,
- maxSlope = TRUE,
- plot = FALSE,
- returnTables = FALSE
-)
-
-
-
-
Arguments
-
-
-x
-RasterLayer or SpatRaster or a previous result from estimateHaze with returnTables = TRUE from which to estimate haze
- hazeBands
-Integer or Character. Band number or bandname from which to estimate atmospheric haze (optional if x contains only one layer)
- darkProp
-Numeric. Proportion of pixels estimated to be dark.
- maxSlope
-Logical. Use darkProp only as an upper boundary and search for the DN of maximum slope in the histogram below this value.
- plot
-Logical. Option to display histograms and haze values
- returnTables
-Logical. Option to return the frequency table per layer. Only takes effect if x is a SpatRaster. If x is a result of estimateHaze tables will always be returned.
-
-
-
-
Details
-
-
It is assumed that any radiation originating from *dark* pixels is due to atmospheric haze and
-not the reflectance of the surface itself (the surface is dark, i.e. it has a reflectance close to zero).
-Hence, the haze values are estimates of path radiance, which can be subtracted in a dark object subtraction (DOS) procedure (see radCor
-
Atmospheric haze affects almost exclusively the visible wavelength range. Therefore, typically, you'd only want to estimate haze in blue, green and red bands, occasionally also in the nir band.
-
-
-
-
Value
-
-
If returnTables is FALSE (default). Then a vector of length(hazeBands) containing the estimated haze DNs will be returned.
-If returnTables is TRUE a list with two components will be returned. The list element 'SHV' contains the haze values, while 'table'
-contains another list with the sampled frequency tables. The latter can be re-used to try different darkProp thresholds without having to sample
-the raster again.
-
-
-
-
Examples
-
-
## Estimate haze for blue, green and red band
-haze <- estimateHaze(lsat, hazeBands = 1:3, plot = FALSE)
-haze
-
-
## B1_dn B2_dn B3_dn
-## 55 19 12
-
-
## Find threshold interactively
-#### Return the frequency tables for re-use
-#### avoids having to sample the Raster again and again
-haze <- estimateHaze(lsat, hazeBands = 1:3, returnTables = TRUE)
-## Use frequency table instead of lsat and fiddle with
-haze <- estimateHaze(haze, hazeBands = 1:3, darkProp = .1, plot = FALSE)
-haze$SHV
-
-
## B1_dn B2_dn B3_dn
-## 57 20 12
-
-
-
-
[Package
RStoolbox version 0.4.0
Index ]
-
R: Fractional Cover Analysis
-
-
-
fCover {RStoolbox} R Documentation
-
-
Fractional Cover Analysis
-
-
Description
-
-
fCover takes a classified high resolution image, e.g. vegetation and non-vegetation based on Landsat and calculates cover fractions for
-pixels of a coarser resolution, e.g. MODIS.
-
-
-
-
Usage
-
-
fCover(
- classImage,
- predImage,
- nSamples = 1000,
- classes = 1,
- maxNA = 0,
- clamp = TRUE,
- model = "rf",
- tuneLength = 3,
- trControl = trainControl(method = "cv"),
- method = deprecated(),
- filename = NULL,
- overwrite = FALSE,
- verbose,
- ...
-)
-
-
-
-
Arguments
-
-
-classImage
-high resolution RasterLayer or SpatRaster containing a landcover classification, e.g. as obtained by superClass .
- predImage
-coarse resolution RasterLayer or SpatRaster for which fractional cover will be estimated.
- nSamples
-Integer. Number of pixels to sample from predImage to train the regression model
- classes
-Integer. Classes for which fractional cover should be estimated (one or more).
- maxNA
-Numeric. Maximal proportion of NAs allowed in training pixels.
- clamp
-Logical. Enforce results to stay within [0,1] interval. Values <0 are reset to 0 and values >1 to 1.
- model
-Character. Which model to fit for image regression. See train for options. Defaults to randomForest ('rf')
- tuneLength
-Integer. Number of levels for each tuning parameters that should be generated by train. See Details and train
- trControl
-trainControl
- method
-DEPREACTED! in favor of trControl=trainControl(method="cv") Resampling method for parameter tuning. Defaults to 10 fold cross-validation. See trainControl
- filename
-Character. Filename of the output raster file (optional).
- overwrite
-Logical. if TRUE, filename will be overwritten.
- verbose
-Logical. Print progress information.
- ...
-further arguments to be passed to writeRaster
-
-
-
-
Details
-
-
fCover gets the pixel values in a high resolution classified image that correspond to
-randomly selected moderate resolution pixels and then calculates the percent of
-the classified image pixels that represent your cover type of interest. In other words, if
-your high resolution image has a pixel size of 1m and your moderate resolution image has a
-pixel size of 30m the sampling process would take a block of 900 of the 1m resolution pixels
-that correspond to a single 30m pixel and calculate the percentage of the 1m pixels that
-are forest. For example, if there were 600 forest pixels and 300 non-forest pixels the value
-given for the output pixel would be 0.67 since 67
-
-
fCover relies on the train() function from the caret package which provides access to a huge number of classifiers.
-Please see the available options at train . The default classifier (randomForest) we chose has been shown
-to provide very good results in image regression and hence it is recomended you start with this one. If you choose a different
-classifier, make sure it can run in regression mode.
-
-
Many models require tuning of certain parameters. Again, this is handled by train from the caret package.
-With the tuneLength argument you can specify how many different values of each tuning parameter should be tested. The Random Forest
-algorithm for example can be tuned by varying the mtry parameter. Hence, by specifying tuneLength = 10, ten different levels
-of mtry will be tested in a cross-validation scheme and the best-performing value will be chosen for the final model.
-
-
If the total no-data values for a block of high resolution pixels is greater than maxNA then
-it will not be included in the training data set since there is too much missing data to provide
-a reliable cover percentage. If the no-data proporton is less then maxNA the no-data pixels are removed
-from the total number of pixels when calculating the percent cover.
-
-
-
-
Value
-
-
Returns a list with two elements: models contains the fitted models evaluated in tenfold cross-validation (caret train objects);
-fCover contains a SpatRaster with a fractional cover layer for each requested class.
-
-
-
-
See Also
-
-
superClass
-
-
-
-
Examples
-
-
## No test:
-library(terra)
-library(caret)
-
-
## Loading required package: lattice
-
-
## Warning: package 'lattice' was built under R version 4.2.3
-
-
## Create fake input images
-agg.level <- 9
-modis <- terra::aggregate(rlogo, agg.level)
-
-## Perform an exemplary classification
-lc <- unsuperClass(rlogo, nClass=2)
-
-## Calculate the true cover, which is of course only possible in this example,
-## because the fake corse resolution imagery is exactly res(rlogo)*9
-trueCover <- terra::aggregate(lc$map, agg.level,
- fun = function(x, ...){sum(x == 1, ...)/sum(!is.na(x))})
-
-## Run with randomForest and support vector machine (radial basis kernel)
-## Of course the SVM is handicapped in this example,
-## due to poor tuning (tuneLength)
-par(mfrow=c(2,3))
-for(model in c("rf", "svmRadial")){
- fc <- fCover(
- classImage = lc$map ,
- predImage = modis,
- classes=1,
- trControl = trainControl(method = "cv", number = 3),
- model=model,
- nSample = 50,
- tuneLength=2
- )
-
- ## How close is it to the truth?
- compare.rf <- trueCover - fc$map
- plot(fc$map, main = paste("Fractional Cover: Class 1\nModel:", model))
- plot(compare.rf, main = "Diffence\n true vs. predicted")
- plot(trueCover[],fc$map[], xlim = c(0,1), ylim =c(0,1),
- xlab = "True Cover", ylab = "Predicted Cover" )
- abline(coef=c(0,1))
- rmse <- sqrt(global(compare.rf^2, "sum", na.rm = TRUE))/ncell(compare.rf)
- r2 <- cor(trueCover[], fc$map[], "complete.obs")
- text(0.9,0.1, adj=1, labels =
- paste(c("RMSE:","\nR2:"), round(unlist(c(rmse, r2)),3), collapse=""))
-}
-
-
-
## Reset par
-par(mfrow=c(1,1))
-## End(No test)
-
-
-
-
[Package
RStoolbox version 0.4.0
Index ]
-
R: Fortify method for classes from the terra package.
-
-
-
fortifySpatRaster {RStoolbox} R Documentation
-
-
Fortify method for classes from the terra package.
-
-
Description
-
-
Fortify method for classes from the terra package.
-
-
-
-
Usage
-
-
fortifySpatRaster(x, maxpixels = 50000)
-
-
-
-
Arguments
-
-
-x
-SpatRaster object to convert into a dataframe.
- maxpixels
-Integer. Maximum number of pixels to sample
-
-
-
-
Value
-
-
Returns a data.frame with coordinates (x,y) and corresponding raster values.
-
-
-
-
Examples
-
-
r_df <- fortifySpatRaster(rlogo)
-head(r_df)
-
-
## x y red green blue
-## 1 0.5 76.5 255 255 255
-## 2 1.5 76.5 255 255 255
-## 3 2.5 76.5 255 255 255
-## 4 3.5 76.5 255 255 255
-## 5 4.5 76.5 255 255 255
-## 6 5.5 76.5 255 255 255
-
-
-
-
[Package
RStoolbox version 0.4.0
Index ]
-
R: Extract bandwise information from ImageMetaData
-
-
-
getMeta {RStoolbox} R Documentation
-
-
Extract bandwise information from ImageMetaData
-
-
Description
-
-
This is an accessor function to quickly access information stored in ImageMetaData, e.g. scale factor per band.
-Intended for use with imagery which was imported using stackMeta. Will return parameters using the actual band order in img.
-
-
-
-
Usage
-
-
getMeta(img, metaData, what)
-
-
-
-
Arguments
-
-
-img
-SpatRaster or character vector with band names.
- metaData
-ImageMetaData or path to meta data file.
- what
-Character. Parameter to extract. Either data descriptors, or conversion parameters (see Details for options)
-
-
-
-
Details
-
-
Possible metadata parameters (what argument):
-
-
Data descriptors
-
-
-
-
-
-'FILES'
-
-
-
-'QUANTITY'
-
-
-
-'CATEGORY'
-
-
-
-'NA_VALUE'
-
-
-
-'SATURATE_VALUE'
-
-
-
-'SCALE_FACTOR'
-
-
-
-'DATA_TYPE'
-
-
-
-'SPATIAL_RESOLUTION'
-
-
-
-
-
-
-
-
-
Conversion parameters
-
-
-
-
-
-'CALRAD' Conversion parameters from DN to radiance
-
-
-
-'CALBT' Conversion parameters from radiance to brightness temperature
-
-
-
-'CALREF' Conversion parameters from DN to reflectance (Landsat 8 only)
-
-
-
-
-
-
-
-
-
-
-
Value
-
-
If what is one of c('CALRAD', 'CALBT', 'CALREF') a data.frame is returned with bands in rows (order corresponding to img band order).
-Otherwise a named numeric vector with the corresponding parameter is returned (layernames as names).
-
-
-
-
Examples
-
-
## Import example data
-mtlFile <- system.file("external/landsat/LT52240631988227CUB02_MTL.txt", package="RStoolbox")
-meta <- readMeta(mtlFile)
-lsat_t <- stackMeta(mtlFile)
-
-## Get integer scale factors
-getMeta(lsat_t, metaData = meta, what = "SCALE_FACTOR")
-
-
## B1_dn B2_dn B3_dn B4_dn B5_dn B6_dn B7_dn
-## 1 1 1 1 1 1 1
-
-
## Conversion factors for brightness temperature
-getMeta("B6_dn", metaData = meta, what = "CALBT")
-
-
## K1 K2
-## B6_dn 607.76 1260.56
-
-
## Conversion factors to top-of-atmosphere radiance
-## Band order not corresponding to metaData order
-getMeta(lsat_t[[5:1]], metaData = meta, what = "CALRAD")
-
-
## offset gain
-## B5_dn -0.49035 0.120
-## B4_dn -2.38602 0.876
-## B3_dn -2.21398 1.044
-## B2_dn -4.16220 1.322
-## B1_dn -2.19134 0.671
-
-
## Get integer scale factors
-getMeta(lsat_t, metaData = meta, what = "SCALE_FACTOR")
-
-
## B1_dn B2_dn B3_dn B4_dn B5_dn B6_dn B7_dn
-## 1 1 1 1 1 1 1
-
-
## Get file basenames
-getMeta(lsat_t, metaData = meta, what = "FILES")
-
-
## B1_dn B2_dn B3_dn
-## "LT52240631988227CUB02_B1.TIF" "LT52240631988227CUB02_B2.TIF" "LT52240631988227CUB02_B3.TIF"
-## B4_dn B5_dn B6_dn
-## "LT52240631988227CUB02_B4.TIF" "LT52240631988227CUB02_B5.TIF" "LT52240631988227CUB02_B6.TIF"
-## B7_dn
-## "LT52240631988227CUB02_B7.TIF"
-
-
-
-
[Package
RStoolbox version 0.4.0
Index ]
-
R: Extract validation results from superClass objects
-
-
-
getValidation {RStoolbox} R Documentation
-
-
Extract validation results from superClass objects
-
-
Description
-
-
Extract validation results from superClass objects
-
-
-
-
Usage
-
-
getValidation(x, from = "testset", metrics = "overall")
-
-
-
-
Arguments
-
-
-x
-superClass object or caret::confusionMatrix
- from
-Character. 'testset' extracts the results from independent validation with testset. 'cv' extracts cross-validation results.
- metrics
-Character. Only relevant in classification mode (ignored for regression models).
-Select 'overall' for overall accuracy metrics, 'classwise' for classwise metrics,
-'confmat' for the confusion matrix itself and 'caret' to return the whole caret::confusionMatrix object.
-
-
-
-
Value
-
-
Returns a data.frame with validation results.
-If metrics = 'confmat' or 'caret' will return a table or the full caret::confusionMatrix object, respectively.
-
-
-
-
Examples
-
-
library(pls)
-
-
## Warning: package 'pls' was built under R version 4.2.3
-
-
##
-## Attaching package: 'pls'
-
-
## The following object is masked from 'package:caret':
-##
-## R2
-
-
## The following object is masked from 'package:stats':
-##
-## loadings
-
-
## Fit classifier (splitting training into 70% training data, 30% validation data)
-train <- readRDS(system.file("external/trainingPoints.rds", package="RStoolbox"))
-SC <- superClass(rlogo, trainData = train, responseCol = "class",
- model="pls", trainPartition = 0.7)
-## Independent testset-validation
-getValidation(SC)
-
-
## model validation Accuracy Kappa AccuracyLower AccuracyUpper AccuracyNull AccuracyPValue McnemarPValue
-## 1 pls testset 0.7777778 0.6666667 0.3999064 0.971855 0.3333333 0.008281258 NaN
-
-
getValidation(SC, metrics = "classwise")
-
-
## model validation class Sensitivity Specificity Pos.Pred.Value Neg.Pred.Value Precision Recall F1
-## 1 pls testset A 1.0000000 0.6666667 0.6 1.00 0.6 1.0000000 0.75
-## 2 pls testset B 0.3333333 1.0000000 1.0 0.75 1.0 0.3333333 0.50
-## 3 pls testset C 1.0000000 1.0000000 1.0 1.00 1.0 1.0000000 1.00
-## Prevalence Detection.Rate Detection.Prevalence Balanced.Accuracy
-## 1 0.3333333 0.3333333 0.5555556 0.8333333
-## 2 0.3333333 0.1111111 0.1111111 0.6666667
-## 3 0.3333333 0.3333333 0.3333333 1.0000000
-
-
## Cross-validation based
-getValidation(SC, from = "cv")
-
-
## model validation Accuracy Kappa AccuracyLower AccuracyUpper AccuracyNull AccuracyPValue McnemarPValue
-## 1 pls cv 0.9047619 0.8571429 0.6962256 0.9882507 0.3333333 8.441398e-08 NaN
-
-
-
-
[Package
RStoolbox version 0.4.0
Index ]
-
R: Plot RasterLayers in ggplot with greyscale
-
-
-
ggR {RStoolbox} R Documentation
-
-
Plot RasterLayers in ggplot with greyscale
-
-
Description
-
-
Plot single layer imagery in grey-scale. Can be used with a SpatRaster.
-
-
-
-
Usage
-
-
ggR(
- img,
- layer = 1,
- maxpixels = 5e+05,
- alpha = 1,
- hue = 1,
- sat = 0,
- stretch = "none",
- quantiles = c(0.02, 0.98),
- ext = NULL,
- coord_equal = TRUE,
- ggLayer = FALSE,
- ggObj = TRUE,
- geom_raster = FALSE,
- forceCat = FALSE
-)
-
-
-
-
Arguments
-
-
-img
-raster
- layer
-Character or numeric. Layername or number. Can be more than one layer, in which case each layer is plotted in a subplot.
- maxpixels
-Integer. Maximal number of pixels to sample.
- alpha
-Numeric. Transparency (0-1).
- hue
-Numeric. Hue value for color calculation [0,1] (see hsv sat > 0.
- sat
-Numeric. Saturation value for color calculation [0,1] (see hsv
- stretch
-Character. Either 'none', 'lin', 'hist', 'sqrt' or 'log' for no stretch, linear, histogram, square-root or logarithmic stretch.
- quantiles
-Numeric vector with two elements. Min and max quantiles to stretch to. Defaults to 2% stretch, i.e. c(0.02,0.98).
- ext
-Extent object to crop the image
- coord_equal
-Logical. Force addition of coord_equal, i.e. aspect ratio of 1:1. Typically useful for remote sensing data (depending on your projection), hence it defaults to TRUE.
-Note however, that this does not apply if (ggLayer=FALSE).
- ggLayer
-Logical. Return only a ggplot layer which must be added to an existing ggplot. If FALSE s stand-alone ggplot will be returned.
- ggObj
-Logical. Return a stand-alone ggplot object (TRUE) or just the data.frame with values and colors
- geom_raster
-Logical. If FALSE uses annotation_raster (good to keep aestetic mappings free). If TRUE uses geom_raster (and aes(fill)). See Details.
- forceCat
-Logical. If TRUE the raster values will be forced to be categorical (will be converted to factor if needed).
-
-
-
-
Details
-
-
When img contains factor values and annotation=TRUE, the raster values will automatically be converted
-to numeric in order to proceed with the brightness calculation.
-
-
The geom_raster argument switches from the default use of annotation_raster to geom_raster. The difference between the two is that geom_raster performs
-a meaningful mapping from pixel values to fill colour, while annotation_raster is simply adding a picture to your plot. In practice this means that whenever you
-need a legend for your raster you should use geom_raster = TRUE. This also allows you to specify and modify the fill scale manually.
-The advantage of using annotation_raster (geom_raster = TRUE) is that you can still use the scale_fill* for another variable. For example you could add polygons and
-map a value to their fill colour. For more details on the theory behind aestetic mapping have a look at the ggplot2 manuals.
-
-
-
-
Value
-
-
-
-
-
- ggObj = TRUE: ggplot2 plot
-
-
-
- ggLayer = TRUE: ggplot2 layer to be combined with an existing ggplot2
-
-
-
- ggObj = FALSE: data.frame in long format suitable for plotting with ggplot2,
- includes the pixel values and the calculated colors
-
-
-
-
-
-
-
-
-
-
-
See Also
-
-
ggRGB , fortifySpatRaster
-
-
-
-
Examples
-
-
library(ggplot2)
-library(terra)
-
-## Simple grey scale annotation
-ggR(rlogo)
-
-
-
## With linear stretch contrast enhancement
-ggR(rlogo, stretch = "lin", quantiles = c(0.1,0.9))
-
-
-
## ggplot with geom_raster instead of annotation_raster
-## and default scale_fill*
-ggR(rlogo, geom_raster = TRUE)
-
-
-
## with different scale
-ggR(rlogo, geom_raster = TRUE) +
- scale_fill_gradientn(name = "mojo", colours = rainbow(10)) +
- ggtitle("**Funkadelic**")
-
-
-
## Plot multiple layers
-## No test:
-ggR(lsat, 1:6, geom_raster=TRUE, stretch = "lin") +
- scale_fill_gradientn(colors=grey.colors(100), guide = "none") +
- theme(axis.text = element_text(size=5),
- axis.text.y = element_text(angle=90),
- axis.title=element_blank())
-
-
-
## Don't plot, just return a data.frame
-df <- ggR(rlogo, ggObj = FALSE)
-head(df, n = 3)
-
-
## x y value layerName fill
-## 1 0.5 76.5 255 red #FFFFFFFF
-## 2 1.5 76.5 255 red #FFFFFFFF
-## 3 2.5 76.5 255 red #FFFFFFFF
-
-
## Layermode (ggLayer=TRUE)
-data <- data.frame(x = c(0, 0:100,100), y = c(0,sin(seq(0,2*pi,pi/50))*10+20, 0))
-ggplot(data, aes(x, y)) + ggR(rlogo, geom_raster= FALSE, ggLayer = TRUE) +
- geom_polygon(aes(x, y), fill = "blue", alpha = 0.4) +
- coord_equal(ylim=c(0,75))
-
-
-
## Categorical data
-## In this case you probably want to use geom_raster=TRUE
-## in order to perform aestetic mapping (i.e. a meaningful legend)
-rc <- rlogo
-rc[] <- cut(rlogo[[1]][], seq(0,300, 50))
-ggR(rc, geom_raster = TRUE)
-
-
-
## Legend cusomization etc. ...
-ggR(rc, geom_raster = TRUE) + scale_fill_continuous(labels=paste("Class", 1:6))
-
-
-
## End(No test)
-## Creating a nicely looking DEM with hillshade background
-terr <- terrain(srtm, c("slope", "aspect"))
-hill <- shade(terr[["slope"]], terr[["aspect"]])
-ggR(hill)
-
-
-
ggR(hill) +
- ggR(srtm, geom_raster = TRUE, ggLayer = TRUE, alpha = 0.3) +
- scale_fill_gradientn(colours = terrain.colors(100), name = "elevation")
-
-
-
-
-
[Package
RStoolbox version 0.4.0
Index ]
-
R: Create ggplot2 Raster Plots with RGB from 3 RasterLayers
-
-
-
ggRGB {RStoolbox} R Documentation
-
-
Create ggplot2 Raster Plots with RGB from 3 RasterLayers
-
-
Description
-
-
Calculates RGB color composite raster for plotting with ggplot2. Optional values for clipping and and stretching can be used to enhance the imagery.
-
-
-
-
Usage
-
-
ggRGB(
- img,
- r = 3,
- g = 2,
- b = 1,
- scale,
- maxpixels = 5e+05,
- stretch = "none",
- ext = NULL,
- limits = NULL,
- clipValues = "limits",
- quantiles = c(0.02, 0.98),
- ggObj = TRUE,
- ggLayer = FALSE,
- alpha = 1,
- coord_equal = TRUE,
- geom_raster = FALSE,
- nullValue = 0
-)
-
-
-
-
Arguments
-
-
-img
-RasterStack or RasterBrick
- r
-Integer or character. Red layer in x. Can be set to NULL, in which case the red channel will be set to zero.
- g
-Integer or character. Green layer in x. Can be set to NULL, in which case the green channel will be set to zero.
- b
-Integer or character. Blue layer in x. Can be set to NULL, in which case the blue channel will be set to zero.
- scale
-Numeric. Maximum possible pixel value (optional). Defaults to 255 or to the maximum value of x if that is larger than 255
- maxpixels
-Integer. Maximal number of pixels used for plotting.
- stretch
-Character. Either 'none', 'lin', 'hist', 'sqrt' or 'log' for no stretch, linear, histogram, square-root or logarithmic stretch.
- ext
-Extent or SpatExtent object to crop the image
- limits
-Vector or matrix. Can be used to reduce the range of values. Either a vector of two values for all bands (c(min, max))
-or a 3x2 matrix with min and max values (columns) for each layer (rows).
- clipValues
-Matrix, numeric vector, string or NA. Values to reset out of range (out of limits) values to.
-By default ('limits') values are reset to limits. A single value (e.g. NA) will be recycled to all lower/higher clippings,
-A vector of length two (c(min,max)) can be used to specify lower and higher replace values, applied to all bands.
-A two column matrix (typically with three rows) can be used to fully control lower and upper clipping values differently for each band.
- quantiles
-Numeric vector with two elements. Min and max quantiles to stretch. Defaults to 2% stretch, i.e. c(0.02,0.98).
- ggObj
-Logical. If TRUE a ggplot2 object is returned. If FALSE a data.frame with coordinates and color will be returned.
- ggLayer
-Logical. If TRUE a ggplot2 layer is returned. This is useful if you want to add it to an existing ggplot2 object.
-Note that if TRUE & annotate = FALSE you have to add a scale_fill_identity() manually in your call to ggplot().
- alpha
-Numeric. Transparency (0-1).
- coord_equal
-Logical. Force addition of coord_equal, i.e. aspect ratio of 1:1. Typically useful for remote sensing data (depending on your projection), hence it defaults to TRUE.
-Note howver, that this does not apply if (ggLayer=FALSE).
- geom_raster
-Logical. If FALSE annotation_raster is used, otherwise geom_raster()+scale_fill_identity is used.
-Note that you can't use scale_fill* in addition to the latter, because it already requires scale_fill_identity().
- nullValue
-Numeric. Intensity value used for NULL layers in color compositing. E.g. set g=NULL and fix green value at 0.5 (defaults to 0).
-
-
-
-
Details
-
-
Functionality is based on plotRGB
-
-
-
Value
-
-
-
-
-
- ggObj = TRUE: ggplot2 plot
-
-
-
- ggLayer = TRUE: ggplot2 layer to be combined with an existing ggplot2
-
-
-
- ggObj = FALSE: data.frame in long format suitable for plotting with ggplot2, includes the pixel values and the calculated colors
-
-
-
-
-
-
-
-
-
-
-
See Also
-
-
ggR , fortifySpatRaster
-
-
-
-
Examples
-
-
library(ggplot2)
-
-ggRGB(rlogo, r=1, g=2, b=3)
-
-
-
## Define minMax ranges
-ggRGB(rlogo, r=1,g=2, b=3, limits = matrix(c(100,150,10,200,50,255), ncol = 2, by = TRUE))
-
-
-
## Perform stong linear contrast stretch
-ggRGB(rlogo, r = 1, g = 2, b = 3,stretch = "lin", quantiles = c(0.2, 0.8))
-
-
-
## Use only two layers for color calculation
-ggRGB(rlogo, r = 1, g = 2, b = NULL)
-
-
-
## Return only data.frame
-df <- ggRGB(rlogo, ggObj = FALSE)
-head(df)
-
-
## x y fill
-## 1 0.5 76.5 #FFFFFFFF
-## 2 1.5 76.5 #FFFFFFFF
-## 3 2.5 76.5 #FFFFFFFF
-## 4 3.5 76.5 #FFFFFFFF
-## 5 4.5 76.5 #FFFFFFFF
-## 6 5.5 76.5 #FFFFFFFF
-
-
## Use in layer-mode, e.g. to add to another plot
-wave <- data.frame(x = c(0, 0:100,100), y = c(0,sin(seq(0,2*pi,pi/50))*10+20, 0))
-p <- ggplot(wave, aes(x, y))
-p + ggRGB(rlogo, ggLayer = TRUE) +
- geom_polygon(aes(x, y), fill = "blue", alpha = 0.4) +
- coord_equal(ylim=c(0,75))
-
-
-
-
-
[Package
RStoolbox version 0.4.0
Index ]
-
R: Image to Image Contrast Matching
-
-
-
histMatch {RStoolbox} R Documentation
-
-
Image to Image Contrast Matching
-
-
Description
-
-
Performs image to image contrast adjustments based on histogram matching using empirical cumulative
-distribution functions from both images.
-
-
-
-
Usage
-
-
histMatch(
- x,
- ref,
- xmask = NULL,
- refmask = NULL,
- nSamples = 1e+05,
- intersectOnly = TRUE,
- paired = TRUE,
- forceInteger = FALSE,
- returnFunctions = FALSE,
- ...
-)
-
-
-
-
Arguments
-
-
-x
-RasterLayer or SpatRaster. Source raster which is to be modified.
- ref
-RasterLayer or SpatRaster. Reference raster, to which x will be matched.
- xmask
-RasterLayer or SpatRaster. Mask layer for x to exclude pixels which might distort the histogram, i.e. are not present in ref. Any NA pixel in xmask will be ignored (maskvalue = NA).
- refmask
-RasterLayer or SpatRaster. Mask layer for ref. Any NA pixel in refmask will be ignored (maskvalue = NA).
- nSamples
-Integer. Number of random samples from each image to build the histograms.
- intersectOnly
-Logical. If TRUE sampling will only take place in the overlap extent of the two rasters. Otherwise the full rasters will be used for sampling.
- paired
-Logical. If TRUE the corresponding pixels will be used in the overlap.
- forceInteger
-Logical. Force integer output.
- returnFunctions
-Logical. If TRUE the matching functions will be returned instead of applying them to x.
- ...
-Further arguments to be passed to writeRaster .
-
-
-
-
Value
-
-
A SpatRaster of x adjusted to the histogram of ref. If returnFunctions = TRUE a list of functions (one for each layer) will be returned instead.
-
-
-
-
Note
-
-
x and ref must have the same number of layers.
-
-
-
-
References
-
-
Richards and Jia: Remote Sensing Digital Image Analysis. Springer, Berlin, Heidelberg, Germany, 439pp.
-
-
-
-
Examples
-
-
library(ggplot2)
-library(terra)
-## Original image a (+1 to prevent log(0))
-img_a <- rlogo + 1
-## Degraded image b
-img_b <- log(img_a)
-## Cut-off half the image (just for better display)
-img_b[, 1:50] <- NA
-
-## Compare Images before histMatching
-ggRGB(img_a,1,2,3)+
- ggRGB(img_b, 1,2,3, ggLayer = TRUE, stretch = "lin", q = 0:1) +
- geom_vline(aes(xintercept = 50))+
- ggtitle("Img_a vs. Img_b")
-
-
## Warning in matrix(z, nrow = nrow(rr), ncol = ncol(rr), byrow = TRUE): data length [3927] is not a sub-multiple
-## or multiple of the number of columns [101]
-
-
-
## Do histogram matching
-img_b_matched <- histMatch(img_b, img_a)
-
-## Compare Images after histMatching
-ggRGB(img_a, 1, 2, 3)+
- ggRGB(img_b_matched, 1, 2, 3, ggLayer = TRUE, stretch = "lin", q = 0:1) +
- geom_vline(aes(xintercept = 50))+
- ggtitle("Img_a vs. Img_b_matched")
-
-
## Warning in matrix(z, nrow = nrow(rr), ncol = ncol(rr), byrow = TRUE): data length [3927] is not a sub-multiple
-## or multiple of the number of columns [101]
-
-
-
## Histogram comparison
-opar <- par(mfrow = c(1, 3), no.readonly = TRUE)
-img_a[,1:50] <- NA
-redLayers <- c(img_a, img_b, img_b_matched)[[c(1,4,7)]]
-names(redLayers) <- c("img_a", "img_b", "img_b_matched")
-
-hist(redLayers)
-
-
-
## Reset par
-par(opar)
-
-
-
-
[Package
RStoolbox version 0.4.0
Index ]
-
Documentation of the RStoolbox package
-
-
-
+
+
+
+Remote Sensing Data Analysis • RStoolbox
+Skip to contents
+
+
+
+
+
+
# RStoolbox
+
+RStoolbox is an R package providing a wide range of tools for your every-day remote sensing processing needs. The available tool-set covers many aspects from data import, pre-processing, data analysis, image classification and graphical display. RStoolbox builds upon the terra package, which makes it suitable for processing large data-sets even on smaller workstations.
+For more details have a look at the functions overview .
+
+
Installation
+
The package is available on CRAN and can be installed as usual via
+
install.packages ("RStoolbox" )
+
To install the latest version from GitHub you need to have r-base-dev (Linux) or Rtools (Windows) installed. Then run the following lines:
+
library (devtools)install_github ("bleutner/RStoolbox" )
+
+
+
+
+
+
+
+
Developers
+
+Benjamin Leutner Author
+Ned Horning Author
+Jakob Schwalb-Willmann Author
+Konstantin Mueller Author, maintainer
+More about authors...
+
+
+
+
+
+
+
+
diff --git a/logo.png b/logo.png
new file mode 100644
index 0000000..f3ee20b
Binary files /dev/null and b/logo.png differ
diff --git a/lsat.html b/lsat.html
deleted file mode 100644
index 80a3d2f..0000000
--- a/lsat.html
+++ /dev/null
@@ -1,48 +0,0 @@
-R: Landsat 5TM Example Data
-
-
-
lsat {RStoolbox} R Documentation
-
-
Landsat 5TM Example Data
-
-
Description
-
-
Subset of Landsat 5 TM Scene: LT52240631988227CUB02
-Contains all seven bands in DN format.
-
-
-
-
Usage
-
-
lsat
-
-
-
-
Examples
-
-
ggRGB(lsat, stretch = "lin")
-
-
-
-
-
[Package
RStoolbox version 0.4.0
Index ]
-
R: Multiple Endmember Spectral Mixture Analysis (Spectral...
-
-
-
mesma {RStoolbox} R Documentation
-
-
Multiple Endmember Spectral Mixture Analysis (Spectral Unmixing)
-
-
Description
-
-
mesma performs a multiple endmember spectral mixture analysis on a multiband raster image.
-
-
-
-
Usage
-
-
mesma(img, em, method = "NNLS", iterate = 400, tolerance = 1e-08, ..., verbose)
-
-
-
-
Arguments
-
-
-img
-RasterLayer or RasterBrick or SpatRaster. Remote sensing imagery (usually hyperspectral).
- em
-Matrix or data.frame with spectral endmembers. Rows represent a single endmember of a class, columns represent the spectral bands (i.e. columns correspond to number of bands in img). Number of rows needs to be > 1.
- method
-Character. Select an unmixing method. Currently, only "NNLS" is implemented. Default is "NNLS".
-
-
-
- iterate
-Integer. Set maximum iteration per pixel. Processing time could increase the more iterations are made possible. Default is 400.
- tolerance
-Numeric. Tolerance limit representing a nearly zero minimal number. Default is 1e-8.
- ...
-further arguments passed to writeRaster .
- verbose
-Logical. Prints progress messages during execution.
-
-
-
-
Value
-
-
SpatRaster. The object will contain one band per endmember, with each value representing the estimated presence probability of the endmember per pixel (0 to 1), and an RMSE band.
-
-
-
-
Note
-
-
Depending on iterate and tolerance settings, the sum of estimated presence probabilites per pixel varies around 1.
-
-
-
-
Author(s)
-
-
Jakob Schwalb-Willmann
-
-
-
-
References
-
-
Franc, V., Hlaváč, V., & Navara, M. (2005). Sequential coordinate-wise algorithm for the non-negative least squares problem. In: International Conference on Computer Analysis of Images and Patterns (pp. 407-414). Berlin, Heidelberg.
-
-
-
-
Examples
-
-
#load packages
-library(terra)
-library(RStoolbox)
-
-
-#make up some endmember spectra: water and land
-em_names <- c("water", "land")
-pts <- data.frame(class=em_names, cell = c(47916,5294))
-em <- lsat[pts$cell]
-rownames(em) <- em_names
-
-#unmix the image for water and land
-probs <- mesma(lsat, em, method = "NNLS")
-
-#take a look
-terra::hist(probs$water)
-
-
-
terra::plot(probs$water, col = c("white","blue"))
-
-
-
terra::hist(probs$land)
-
-
-
terra::plot(probs$land, col = c("white","brown"))
-
-
-
-
-
[Package
RStoolbox version 0.4.0
Index ]
-
Changelog • RStoolbox Skip to contents
+
+
+
+
+
+
+
+
+
+
+
New:
+
+mesma() class can be used to group endmembers by class. If multiple endmembers per class are provided, mesma() n_models) for multiple endmember combinations drawn from endmembers and will select the best fit per pixel based on the lowest RMSE. See ?mesma #57 , reported by @ytarazona )
+
+
Changes:
+
+mesma() sum_to_one) (fixes #62 , reported by @michaeldorman )
+added a new example to mesma()
+
+
+
CRAN release: 2022-03-07
+
+
New:
+
+rasterCVA() tmf argument). Also a new argument nct allows to fix this threshold to a user selected value instead of deriving it based on the median of the observed change magnitudes.
+
+unsuperClass() output which allows to return the distances to all cluster centers as raster layers, instead of the class itself
+added spectral index kNDVI in spectralIndices()
+added support for terra::SpatRast objects throughout RStoolbox (as alternative to raster objects). Note: internal functionality is still based on raster.
+
+
+
+
+
CRAN release: 2019-07-23
+
+
New:
+
added several Sentinel-2 optimized spectral indices relying on red-edge bands:red-edge inflection point (REIP),
+normalized difference red-edge indices (NDREI1, NDREI2),
+green-band chlorophyll index (CLG), red-edge chlorophyll index (CLRE)
+Modified Chlorophyll Absorption Ratio Index (MCARI)
+MERIS Terrestrial Chlorophyll Index (MTCI)
+
+
+
Fixes:
+
+readSLI() writeSLI() #47 , fix contributed by @aloboa )
+fix calculation of prediction probabilities in superClass()
+adapt to raster 2.9.5 API changes
+fix order of thermal calibration coefficients for Landsat 8 L1 MTL metadata in readMeta (reported by Xiaoma Li)
+fixed an issue where readSLI() #51 , reported by @aloboa )
+
+
+
Changes:
+
modified readSLI label parsing. Internal white space is now converted to underscores (#52 )
+
+
CRAN release: 2019-01-08
+
+
New:
+
function oneHotEncode()
+
+ggR()
+
+encodeQA() decodeQA() classifyQA() legacy argument.
+new predict() unsuperClass()
+
+
+
Changes:
+
all radCor()
+
+
Fixes:
+
fix unsuperClass()
+
+
+
+
New:
+
added tasseledCap()
+
+
Changes:
+
+readEE()
+
+
+
CRAN release: 2018-04-09
+
+
Fixes:
+
fixed non-portable c++ headers
+
+
CRAN release: 2018-04-05
+
+
New:
+
function mesma() #33 , provided by Jakob Schwalb-Willmann)
+
+
Fixes:
+
improved NA handling and faster implementation of mlc classifier (#32 , pull request by Neal Fultz)
+adapt to upcoming caret version (new constraint caret >= 6.0-79)
+
+
+
CRAN release: 2017-11-10
+
+
Fixes:
+
fix tests for upcoming raster version
+
+
CRAN release: 2017-08-28
+
+
Fixes:
+
adapt to new caret version
+fix readEE()
+corrected sign of greenness tasseledCap()
+adapt readMeta() stackMeta()
+
+
+
CRAN release: 2017-04-15
+
+
New:
+
+spectralIndices() maskLayer and maskValue (suggested by Andrea Hess).
+added spectral index GNDWI
+
+
+
Fixes:
+
update readEE()
+
+
CRAN release: 2017-01-10
+
+
New:
+
+spectralIndices()
+
+superClass() v a l i d a t i o n v a l i d a t i o n
+added example data-set for spectral library see ?readSLI
+increased overall test coverage
+
+
+
Changes:
+
ESUN lookup tables for radCor() https://landsat.usgs.gov/esun
+
+
+spectralIndices()
+
+
+
Fixes:
+
fix ggR() ggRGB()
+fix spectralIndices()
+
+estimateHaze()
+
+readMeta()
+fix radCor()
+
+classifyQA()
+enable reading ENVI plot files in ASCII mode with readSLI()
+Deprecated: * spectralIndices() LSWI has been deprecated, as it is identical with the now available NDWI2.
+
+
+
CRAN release: 2016-11-07
+
+
Fixes:
+
fix import issue: replace deprecated export from caret
+
+
CRAN release: 2016-10-06
+
+
Changes:
+
If the bandSet argument in radCor()
+By default superClass()
+Allow reading and importing from Landsat MSS MTL files with readMeta() stackMeta() @aszeitz , #7 )
+
+
+
Fixes:
+
fix readMeta time-stamp conversion now correctly set to GMT time (@mraraju , #12 )
+radCor caused R to crash if bandSet was a single band
+fix single RasterLayer capability for superClass
+spectralIndices now calculates all documented indices if specified to do so (@mej1d1 , #6 )
+unsuperClass predicted map now handles NAs properly
+pifMatch did not return adjusted image (@tmb3006 , #13 )
+Deprecated: * argument norm was dropped from rasterPCA, because it was effectively a duplicate of the standardized pca (spca) argument in the same function.
+
+
+
CRAN release: 2016-01-28
+
+
New:
+
new function validateMap()
+new function getValidation()
+new spectral index NDVIc (proposed by Jeff Evans)
+new argument scaleFactor for spectralIndices()
+implemented dark object subtraction radCor(..,method=‘sdos’) for Landsat 8 data (@BayAludra , #4 )
+
+
+
Changes:
+
superClass based on polygons now considers only pixels which have their center coordinate within a polygon
+rasterCVA now returns angles from 0 to 360° instead of 0:45 by quadrant (reported by Martin Wegmann)
+improved dark object DN estimation based on maximum slope of the histogram in estimateHaze() @BayAludra , #4 )
+
+
+
Fixes:
+
superClass failed when neither valData or trainPartition was specified. regression introduced in 0.1.3 (reported by Anna Stephani)
+spectralIndices valid value range of EVI/EVI2 now [-1,1]
+radCor returned smallest integer instead of NA for some NA pixels
+fix ‘sdos’ for non-contiguous bands in radCor (@BayAludra , #4 )
+
+
+
CRAN release: 2015-11-28
+
+
New:
+
new logical argument predict()
+new generic predict() function for superClass objects. Useful to separate model training and prediction.
+new example data set (landcover training polygons) for lsat example data under /extdata/trainingPolygons.rds
+
+
+
Fixes:
+
fix histMatch for single layers (affected also ‘ihs’ pan-sharpening)
+fix superClass validation sampling for factors (character based factors could lead to wrong factor conversions and wrong validation results)
+improved handling of of training polygons with overlaps and shared borders in superClass
+improved checks and error messages for insufficient training polygons
+
+
+
CRAN release: 2015-11-04
+
+
New:
+
New model for superClass: maximum likelihood classification (model = “mlc”)
+
+
+
Fixes:
+
Restrict calculation of EVI/EVI2 to reflectance data (#3 )
+Enforce valid value ranges in radCor() clamp to turn this on or off (on by default).
+
+
+
CRAN release: 2015-09-08
+
Added kernlab to suggested packages to be able to test examples
+
+
CRAN release: 2015-09-05
+
Initial release to CRAN (2015-09-05) with the following functions: * classifyQA() * cloudMask() * cloudShadowMask() * coregisterImages() * decodeQA() * encodeQA() * estimateHaze() * fortify.raster() * fCover() * getMeta() * ggR() * ggRGB() * histMatch() * ImageMetaData() * normImage() * panSharpen() * pifMatch() * radCor() * rasterCVA() * rasterEntropy() * rasterPCA() * readEE() * readMeta() * readRSTBX() * readSLI() * rescaleImage() * rsOpts() * sam() * saveRSTBX() * spectralIndices() * stackMeta() * superClass() * tasseledCap() * topCor() * unsuperClass() * writeSLI()
+
Included example data sets: * data(srtm) * data(lsat) * data(rlogo)
+
+
+
+
R: Normalize Raster Images: Center and Scale
-
-
-
normImage {RStoolbox} R Documentation
-
-
Normalize Raster Images: Center and Scale
-
-
Description
-
-
For each pixel subtracts the mean of the raster layer and optionally divide by its standard deviation.
-
-
-
-
Usage
-
-
normImage(img, norm = TRUE, ...)
-
-
-
-
Arguments
-
-
-img
-SpatRaster. Image to transform. Transformation will be performed separately for each layer.
- norm
-Logical. Perform normalization (scaling) in addition to centering, i.e. divide by standard deviation.
- ...
-further arguments passed to writeRaster .
-
-
-
-
Value
-
-
Returns a SpatRaster with the same number layers as input layers with each layer being centered and optionally normalized.
-
-
-
-
Examples
-
-
library(terra)
-## Load example data
-
-## Normalization: Center and Scale
-rlogo_center_norm <- normImage(rlogo)
-hist(rlogo_center_norm)
-
-
-
## Centering
-rlogo_center <- normImage(rlogo, norm = FALSE)
-
-
-
-
[Package
RStoolbox version 0.4.0
Index ]
-
R: One-hot encode a raster or vector
-
-
-
oneHotEncode {RStoolbox} R Documentation
-
-
One-hot encode a raster or vector
-
-
Description
-
-
Splits a categorical raster layer (or a vector) into a multilayer raster (or matrix).
-
-
-
-
Usage
-
-
oneHotEncode(img, classes, background = 0, foreground = 1, na.rm = FALSE, ...)
-
-
-
-
Arguments
-
-
-img
-RasterLayer or SpatRaster or integer/numeric vector containing multiple classes
- classes
-integer: vector of classes which should be extracted
- background
-integer: background value (default = 0)
- foreground
-integer: foreground value (default = 1)
- na.rm
-logical: if TRUE, NAs will be coerced to the background value.
- ...
-further arguments passed to writeRaster . Ignored if img is not a SpatRaster, but a numeric/integer vector or matrix
-
-
-
-
Value
-
-
A SpatRaster with as many layers as there are classes.
-Pixels matching the class of interest are set to 1, backround values by default are set to 0 (see background argument)
-
-
-
-
Examples
-
-
## No test:
-sc <- unsuperClass(rlogo, nClasses = 3)
-
-## one-hot encode
-sc_oneHot <- oneHotEncode(sc$map, classes = c(1,2,3))
-
-## check results
-sc_oneHot
-
-
## class : SpatRaster
-## dimensions : 77, 101, 3 (nrow, ncol, nlyr)
-## resolution : 1, 1 (x, y)
-## extent : 0, 101, 0, 77 (xmin, xmax, ymin, ymax)
-## coord. ref. : +proj=merc +lon_0=0 +k=1 +x_0=0 +y_0=0 +ellps=WGS84 +towgs84=0,0,0,0,0,0,0 +units=m +no_defs
-## source(s) : memory
-## names : c_1, c_2, c_3
-## min values : 0, 0, 0
-## max values : 1, 1, 1
-
-
## End(No test)
-
-
-
-
[Package
RStoolbox version 0.4.0
Index ]
-
R: Pan Sharpen Imagery / Image Fusion
-
-
-
panSharpen {RStoolbox} R Documentation
-
-
Pan Sharpen Imagery / Image Fusion
-
-
Description
-
-
provides different methods for pan sharpening a coarse resolution (typically multispectral) image with
-a higher reolution panchromatic image. Values of the pan-chromatic and multispectral images must be of the same scale, (e.g. from 0:1, or all DNs from 0:255)
-
-
-
-
Usage
-
-
panSharpen(img, pan, r, g, b, pc = 1, method = "brovey", norm = TRUE)
-
-
-
-
Arguments
-
-
-img
-RasterLayer or SpatRaster. Coarse resolution multispectral image
- pan
-RasterLayer or SpatRaster. High resolution image, typically panchromatic.
- r
-Character or Integer. Red band in img. Only relevant if method!='pca'
- g
-Character or Integer. Green band in img. Only relevant if method!='pca'
- b
-Character or Integer. Blue band in img. Only relevant if method!='pca'
- pc
-Integer. Only relevant if method = 'pca'. Which principal component to replace. Usually this should be the first component (default). Only if the first component is dominated by something else than brightness it might be worth a try to use the second component.
- method
-Character. Choose method from c("pca", "ihs", "brovey").
- norm
-Logical. Rescale pan image to match the 1st PC component. Only relevant if method = 'pca'. If TRUE only min and max are matched to the 1st PC. If FALSE pan will be histogram matched to the 1st PC.
-
-
-
-
Details
-
-
Pan sharpening options:
-
-
-
-method='pca': Performs a pca using rasterPCA . The first component is then swapped for the pan band an the PCA is rotated backwards.
-
-method='ihs': Performs a color space transform to Intensity-Hue-Saturation space, swaps intensity for the histogram matched pan and does the backwards transformation.
-
-method='brovey': Performs Brovey reweighting. Pan and img must be at the same value scale (e.g. 0:1, or 0:255) otherwise you'll end up with psychodelic colors.
-
-
-
-
-
-
Value
-
-
pan-sharpened SpatRaster
-
-
-
-
Examples
-
-
library(terra)
-library(ggplot2)
-
-## Fake panchromatic image (30m resolution covering
-## the visible range (integral from blue to red))
-pan <- sum(lsat[[1:3]])
-ggR(pan, stretch = "lin")
-
-
-
## Fake coarse resolution image (150m spatial resolution)
-lowResImg <- aggregate(lsat, 5)
-
-
-## Brovey pan sharpening
-lowResImg_pan <- panSharpen(lowResImg, pan, r = 3, g = 2, b = 1, method = "brovey")
-lowResImg_pan
-
-
## class : SpatRaster
-## dimensions : 310, 287, 3 (nrow, ncol, nlyr)
-## resolution : 30, 30 (x, y)
-## extent : 619395, 628005, -419505, -410205 (xmin, xmax, ymin, ymax)
-## coord. ref. : +proj=utm +zone=22 +ellps=WGS84 +towgs84=0,0,0,0,0,0,0 +units=m +no_defs
-## source(s) : memory
-## names : B1_dn_pan, B2_dn_pan, B3_dn_pan
-## min values : 47.20757, 18.43627, 11.80072
-## max values : 191.12757, 87.47762, 85.39481
-
-
## Plot
-ggRGB(lowResImg, stretch = "lin") + ggtitle("Original")
-
-
## Warning in matrix(z, nrow = nrow(rr), ncol = ncol(rr), byrow = TRUE): data length [3534] is not a sub-multiple
-## or multiple of the number of columns [58]
-
-
-
ggRGB(lowResImg_pan, stretch="lin") + ggtitle("Pansharpened (Brovey)")
-
-
## Warning in matrix(z, nrow = nrow(rr), ncol = ncol(rr), byrow = TRUE): data length [88350] is not a sub-multiple
-## or multiple of the number of columns [287]
-
-
-
-
-
[Package
RStoolbox version 0.4.0
Index ]
-
R: Pseudo-Invariant Features based Image Matching
-
-
-
pifMatch {RStoolbox} R Documentation
-
-
Pseudo-Invariant Features based Image Matching
-
-
Description
-
-
Match one scene to another based on linear regression of pseudo-invariant features (PIF).
-
-
-
-
Usage
-
-
pifMatch(
- img,
- ref,
- method = "cor",
- quantile = 0.95,
- returnPifMap = TRUE,
- returnSimMap = TRUE,
- returnModels = FALSE
-)
-
-
-
-
Arguments
-
-
-img
-RasterStack or RasterBrick or SpatRaster. Image to be adjusted.
- ref
-RasterStack or RasterBrick or SpatRaster. Reference image.
- method
-Method to calculate pixel similarity. Options: euclidean distance ('ed'), spectral angle ('sam') or pearson correlation coefficient ('cor').
- quantile
-Numeric. Threshold quantile used to identify PIFs
- returnPifMap
-Logical. Return a binary raster map ot pixels which were identified as pesudo-invariant features.
- returnSimMap
-Logical. Return the similarity map as well
- returnModels
-Logical. Return the linear models along with the adjusted image.
-
-
-
-
Details
-
-
The function consists of three main steps:
-First, it calculates pixel-wise similarity between the two rasters and identifies pseudo-invariant pixels based on
-a similarity threshold.
-In the second step the values of the pseudo-invariant pixels are regressed against each other in a linear model for each layer.
-Finally the linear models are applied to all pixels in the img, thereby matching it to the reference scene.
-
-
Pixel-wise similarity can be calculated using one of three methods: euclidean distance (method = "ed"), spectral angle ("sam") or pearsons correlation coefficient ("cor").
-The threshold is defined as a similarity quantile. Setting quantile=0.95 will select all pixels with a similarity above the 95% quantile as pseudo-invariant features.
-
-
Model fitting is performed with simple linear models (lm
-
-
-
Value
-
-
Returns a List with the adjusted image and intermediate products (if requested).
-
-
-
- img: the adjusted image
-
-
- simMap: pixel-wise similarity map (if returnSimMap = TRUE)
-
-
- pifMap: binary map of pixels selected as pseudo-invariant features (if returnPifMap = TRUE)
-
-
- models: list of linear models; one per layer (if returnModels = TRUE)
-
-
-
-
-
-
Examples
-
-
library(terra)
-
-
-## Create fake example data
-## In practice this would be an image from another acquisition date
-lsat_b <- log(lsat)
-
-## Run pifMatch and return similarity layer, invariant features mask and models
-lsat_b_adj <- pifMatch(lsat_b, lsat, returnPifMap = TRUE,
- returnSimMap = TRUE, returnModels = TRUE)
-## No test:
-## Pixelwise similarity
-ggR(lsat_b_adj$simMap, geom_raster = TRUE)
-
-
-
## Pesudo invariant feature mask
-ggR(lsat_b_adj$pifMap)
-
-
-
## Histograms of changes
-par(mfrow=c(1,3))
-hist(lsat_b[[1]], main = "lsat_b")
-hist(lsat[[1]], main = "reference")
-hist(lsat_b_adj$img[[1]], main = "lsat_b adjusted")
-
-
-
## Model summary for first band
-summary(lsat_b_adj$models[[1]])
-
-
##
-## Call:
-## lm(formula = ref ~ img, data = df)
-##
-## Residuals:
-## Min 1Q Median 3Q Max
-## -3.3904 -0.6021 0.0163 0.7107 24.6845
-##
-## Coefficients:
-## Estimate Std. Error t value Pr(>|t|)
-## (Intercept) -324.9027 0.9321 -348.6 <2e-16 ***
-## img 92.9473 0.2184 425.5 <2e-16 ***
-## ---
-## Signif. codes: 0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
-##
-## Residual standard error: 1.373 on 4447 degrees of freedom
-## Multiple R-squared: 0.976, Adjusted R-squared: 0.976
-## F-statistic: 1.811e+05 on 1 and 4447 DF, p-value: < 2.2e-16
-
-
## End(No test)
-
-
-
-
[Package
RStoolbox version 0.4.0
Index ]
-
R: Pipe operator
-
-
-
%>% {RStoolbox} R Documentation
-
-
Pipe operator
-
-
Description
-
-
See magrittr::%>% for details.
-
-
-
-
Usage
-
-
lhs %>% rhs
-
-
-
-
Arguments
-
-
-lhs
-A value or the magrittr placeholder.
- rhs
-A function call using the magrittr semantics.
-
-
-
-
Value
-
-
The result of calling 'rhs(lhs)'.
-
-
-
[Package
RStoolbox version 0.4.0
Index ]
-
${s.title}
`;
+ } else if (s.previous_headings == "") {
+ return `${s.dir} > ${s.title}
> ${s.what}`;
+ } else {
+ return `${s.dir} > ${s.title}
> ${s.previous_headings} > ${s.what}`;
+ }
+ },
+ },
+ },
+ ]).on('autocomplete:selected', function(event, s) {
+ window.location.href = s.path + "?q=" + q + "#" + s.id;
+ });
+ });
+})(window.jQuery || window.$)
+
+
diff --git a/pkgdown.yml b/pkgdown.yml
new file mode 100644
index 0000000..b8ee0f5
--- /dev/null
+++ b/pkgdown.yml
@@ -0,0 +1,9 @@
+pandoc: 2.7.3
+pkgdown: 2.0.8
+pkgdown_sha: ~
+articles: {}
+last_built: 2024-04-18T08:18Z
+urls:
+ reference: https://bleutner.github.io/RStoolbox/reference
+ article: https://bleutner.github.io/RStoolbox/articles
+
diff --git a/predict.unsuperClass.html b/predict.unsuperClass.html
deleted file mode 100644
index b9cda0c..0000000
--- a/predict.unsuperClass.html
+++ /dev/null
@@ -1,82 +0,0 @@
-R: Predict a raster map based on a unsuperClass model fit.
-
-
-
predict.unsuperClass {RStoolbox} R Documentation
-
-
Predict a raster map based on a unsuperClass model fit.
-
-
Description
-
-
applies a kmeans cluster model to all pixels of a raster.
-Useful if you want to apply a kmeans model of scene A to scene B.
-
-
-
-
Usage
-
-
## S3 method for class 'unsuperClass'
-predict(object, img, output = "classes", ...)
-
-
-
-
Arguments
-
-
-object
-unsuperClass object
- img
-Raster object. Layernames must correspond to layernames used to train the superClass model, i.e. layernames in the original raster image.
- output
-Character. Either 'classes' (kmeans class; default) or 'distances' (euclidean distance to each cluster center).
- ...
-further arguments to be passed to writeRaster , e.g. filename
-
-
-
-
Value
-
-
Returns a raster with the K-means distances base on your object passed in the arguments.
-
-
-
-
Examples
-
-
## Load training data
-
-## Perform unsupervised classification
-uc <- unsuperClass(rlogo, nClasses = 10)
-
-## Apply the model to another raster
-map <- predict(uc, rlogo)
-
-
-
-
[Package
RStoolbox version 0.4.0
Index ]
-
R: Radiometric Calibration and Correction
-
-
-
radCor {RStoolbox} R Documentation
-
-
Radiometric Calibration and Correction
-
-
Description
-
-
Implements several different methods for radiometric calibration and correction of Landsat data.
-You can either specify a metadata file, or supply all neccesary values manually.
-With proper parametrization apref and sdos should work for other sensors as well.
-
-
-
-
Usage
-
-
radCor(
- img,
- metaData,
- method = "apref",
- bandSet = "full",
- hazeValues,
- hazeBands,
- atmosphere,
- darkProp = 0.01,
- clamp = TRUE,
- verbose
-)
-
-
-
-
Arguments
-
-
-img
-SpatRaster
- metaData
-object of class ImageMetaData or a path to the meta data (MTL) file.
- method
-Radiometric conversion/correction method to be used. There are currently four methods available (see Details):
-"rad", "apref", "sdos", "dos", "costz".
- bandSet
-Numeric or character. original Landsat band numbers or names in the form of ("B1", "B2" etc). If set to 'full' all bands in the solar (optical) region will be processed.
- hazeValues
-Numeric. Either a vector with dark DNs per hazeBand (method = 'sdos'); possibly estimated using estimateHaze .
-Or the 'starting haze value' (DN) for the relative scattering models in method = 'dos' or 'costz'. If not provided, hazeValues will be estimated in an automated fashion for all hazeBands.
-Argument only applies to methods 'sdos', 'dos' and 'costz'.
- hazeBands
-Character or integer. Bands corresponding to hazeValues (method = 'sdos') or band to select starting haze value from ('dos' or 'costz').
- atmosphere
-Character. Atmospheric characteristics. Will be estimated if not expicilty provided. Must be one of "veryClear", "clear", "moderate", "hazy" or "veryHazy".
- darkProp
-Numeric. Estimated proportion of dark pixels in the scene. Used only for automatic guessing of hazeValues (typically one would choose 1 or 2%).
- clamp
-Logical. Enforce valid value range. By default reflectance will be forced to stay within [0,1] and radiance >= 0 by replacing invalid values with the correspinding boundary, e.g. -0.1 will become 0.
- verbose
-Logical. Print status information.
-
-
-
-
Details
-
-
The atmospheric correction methods (sdos, dos and costz) apply to the optical (solar) region of the spectrum and do not affect the thermal band.
-
-
Dark object subtraction approaches rely on the estimation of atmospheric haze based on *dark* pixels. Dark pixels are assumed to have zero reflectance, hence the name.
-It is then assumed further that any radiation originating from such *dark* pixels is due to atmospheric haze and
-not the reflectance of the surface itself.
-
-
The folloiwing methods are available:
-
-
-
-
-
-rad Radiance
-
-
-
-apref Apparent reflectance (top-of-atmosphere reflectance)
-
-
-
-dos Dark object subtratction following Chavez (1989)
-
-
-
-costz Dark object subtraction following Chavez (1996)
-
-
-
-sdos Simple dark object subtraction. Classical DOS, Lhaze must be estimated for each band separately.
-
-
-
-
-
-
If either "dos" or "costz" are selected, radCor will use the atmospheric haze decay model described by Chavez (1989).
-Depending on the atmosphere the following coefficients are used:
-
-
-
-
-
-veryClear \lambda^{-4.0}
-
-
-
-clear \lambda^{-2.0}
-
-
-
-moderate \lambda^{-1.0}
-
-
-
-hazy \lambda^{-0.7}
-
-
-
-veryHazy \lambda^{-0.5}
-
-
-
-
-
-
For Landsat 8, no values for extra-terrestrial irradiation (esun) are provided by NASA. These are, however, neccessary for DOS-based approaches.
-Therefore, these values were derived from a standard reference spectrum published by Thuillier et al. (2003) using the Landsat 8 OLI spectral response functions
-(for details, see http://bleutner.github.io/RStoolbox/r/2016/01/26/estimating-landsat-8-esun-values ).
-
-
The implemented sun-earth distances neglect the earth's eccentricity. Instead we use a 100 year daily average (1979-2070).
-
-
-
-
Value
-
-
SpatRaster with top-of-atmosphere radiance (W/(m^2 * srad * \mu m)), at-satellite brightness temperature (K),
-top-of-atmosphere reflectance (unitless) corrected for the sun angle or at-surface reflectance (unitless).
-
-
-
-
Note
-
-
This was originally a fork of randcorr() function in the landsat package. This version works on SpatRasters and hence is suitable for large rasters.
-
-
-
-
References
-
-
S. Goslee (2011): Analyzing Remote Sensing Data in R: The landsat Package. Journal of Statistical Software 43(4).
-
-
G. Thuillier et al. (2003) THE SOLAR SPECTRAL IRRADIANCE FROM 200 TO 2400 nm AS MEASURED BY THE SOLSPEC SPECTROMETER FROM THE ATLAS AND EURECA MISSIONS. Solar Physics 214(1): 1-22 (
-
-
-
-
Examples
-
-
library(terra)
-## Import meta-data and bands based on MTL file
-mtlFile <- system.file("external/landsat/LT52240631988227CUB02_MTL.txt", package="RStoolbox")
-metaData <- readMeta(mtlFile)
-lsat_t <- stackMeta(mtlFile)
-
-
-## Convert DN to top of atmosphere reflectance and brightness temperature
-lsat_ref <- radCor(lsat_t, metaData = metaData, method = "apref")
-
-## Correct DN to at-surface-reflecatance with DOS (Chavez decay model)
-## No test:
-lsat_sref <- radCor(lsat_t, metaData = metaData)
-## End(No test)
-
-## Correct DN to at-surface-reflecatance with simple DOS
-## Automatic haze estimation
-hazeDN <- estimateHaze(lsat_t, hazeBands = 1:4, darkProp = 0.01, plot = FALSE)
-lsat_sref <- radCor(lsat_t, metaData = metaData, method = "sdos",
- hazeValues = hazeDN, hazeBands = 1:4)
-
-
-
-
[Package
RStoolbox version 0.4.0
Index ]
-
R: Change Vector Analysis
-
-
-
rasterCVA {RStoolbox} R Documentation
-
-
Change Vector Analysis
-
-
Description
-
-
Calculates angle and magnitude of change vectors.
-Dimensionality is limited to two bands per image.
-
-
-
-
Usage
-
-
rasterCVA(x, y, tmf = NULL, nct = NULL, ...)
-
-
-
-
Arguments
-
-
-x
-RasterBrick or RasterStack or SpatRaster with two layers. This will be the reference/origin for the change calculations. Both rasters (y and y) need to correspond to each other, i.e. same resolution, extent and origin.
- y
-RasterBrick or RasterStack or SpatRaster with two layers. Both rasters (y and y) need to correspond to each other, i.e. same resolution, extent and origin.
- tmf
-Numeric. Threshold median factor (optional). Used to calculate a threshold magnitude for which pixels are considered stable, i.e. no change. Calculated as tmf * mean(magnitude[magnitude > 0]).
- nct
-Numeric. No-change threshold (optional). Alternative to tmf. Sets an absolute threshold. Change magnitudes below nct are considered stable and set to NA.
- ...
-further arguments passed to writeRaster
-
-
-
-
Details
-
-
Change Vector Analysis (CVA) is used to identify spectral changes between two identical scenes which were acquired at different times.
-CVA is limited to two bands per image. For each pixel it calculates the change vector in the two-dimensional spectral space.
-For example for a given pixel in image A and B for the red and nir band the change vector is calculated for the coordinate pairs: (red_A | nir_A) and (red_B | nir_B).
-
-
The coordinate system is defined by the order of the input bands: the first band defines the x-axis and the second band the y-axis, respectively.
-Angles are returned *in degree* beginning with 0 degrees pointing 'north', i.e. the y-axis, i.e. the second band.
-
-
-
-
Value
-
-
Returns a SpatRaster with two layers: change vector angle and change vector magnitude
-
-
-
-
Examples
-
-
library(terra)
-pca <- rasterPCA(lsat)$map
-
-## Do change vector analysis
-cva <- rasterCVA(pca[[1:2]], pca[[3:4]])
-cva
-
-
## class : SpatRaster
-## dimensions : 310, 287, 2 (nrow, ncol, nlyr)
-## resolution : 30, 30 (x, y)
-## extent : 619395, 628005, -419505, -410205 (xmin, xmax, ymin, ymax)
-## coord. ref. : +proj=utm +zone=22 +ellps=WGS84 +towgs84=0,0,0,0,0,0,0 +units=m +no_defs
-## source(s) : memory
-## names : angle, magnitude
-## min values : 5.423571e-03, 0.1009387
-## max values : 3.599993e+02, 106.5000918
-
-
-
-
[Package
RStoolbox version 0.4.0
Index ]
-
R: Multi-layer Pixel Entropy
-
-
-
rasterEntropy {RStoolbox} R Documentation
-
-
Multi-layer Pixel Entropy
-
-
Description
-
-
Shannon entropy is calculated for each pixel based on it's layer values.
-To be used with categorical / integer valued rasters.
-
-
-
-
Usage
-
-
rasterEntropy(img, ...)
-
-
-
-
Arguments
-
-
-img
-RasterStack or RasterBrick or SpatRaster
- ...
-additional arguments passed to writeRaster
-
-
-
-
Details
-
-
Entropy is calculated as -sum(p log(p)); p being the class frequency per pixel.
-
-
-
-
Value
-
-
SpatRaster "entropy"
-
-
-
-
Examples
-
-
re <- rasterEntropy(rlogo)
-ggR(re, geom_raster = TRUE)
-
-
-
-
-
[Package
RStoolbox version 0.4.0
Index ]
-
R: Principal Component Analysis for Rasters
-
-
-
rasterPCA {RStoolbox} R Documentation
-
-
Principal Component Analysis for Rasters
-
-
Description
-
-
Calculates R-mode PCA for RasterBricks or RasterStacks and returns a RasterBrick with multiple layers of PCA scores.
-
-
-
-
Usage
-
-
rasterPCA(
- img,
- nSamples = NULL,
- nComp = nlyr(img),
- spca = FALSE,
- maskCheck = TRUE,
- ...
-)
-
-
-
-
Arguments
-
-
-img
-RasterLayer or SpatRaster.
- nSamples
-Integer or NULL. Number of pixels to sample for PCA fitting. If NULL, all pixels will be used.
- nComp
-Integer. Number of PCA components to return.
- spca
-Logical. If TRUE, perform standardized PCA. Corresponds to centered and scaled input image. This is usually beneficial for equal weighting of all layers. (FALSE by default)
- maskCheck
-Logical. Masks all pixels which have at least one NA (default TRUE is reccomended but introduces a slow-down, see Details when it is wise to disable maskCheck).
-Takes effect only if nSamples is NULL.
- ...
-further arguments to be passed to writeRaster , e.g. filename.
-
-
-
-
Details
-
-
Internally rasterPCA relies on the use of princomp (R-mode PCA). If nSamples is given the PCA will be calculated
-based on a random sample of pixels and then predicted for the full raster. If nSamples is NULL then the covariance matrix will be calculated
-first and will then be used to calculate princomp and predict the full raster. The latter is more precise, since it considers all pixels,
-however, it may be slower than calculating the PCA only on a subset of pixels.
-
-
Pixels with missing values in one or more bands will be set to NA. The built-in check for such pixels can lead to a slow-down of rasterPCA.
-However, if you make sure or know beforehand that all pixels have either only valid values or only NAs throughout all layers you can disable this check
-by setting maskCheck=FALSE which speeds up the computation.
-
-
Standardised PCA (SPCA) can be useful if imagery or bands of different dynamic ranges are combined. SPC uses the correlation matrix instead of the covariance matrix, which
-has the same effect as using normalised bands of unit variance.
-
-
-
-
Value
-
-
Returns a named list containing the PCA model object ($model) and a SpatRaster with the principal component layers ($object).
-
-
-
-
Examples
-
-
library(ggplot2)
-library(reshape2)
-ggRGB(rlogo, 1,2,3)
-
-
-
## Run PCA
-set.seed(25)
-rpc <- rasterPCA(rlogo)
-rpc
-
-
## $call
-## rasterPCA(img = rlogo)
-##
-## $model
-## Call:
-## princomp(cor = spca, covmat = covMat)
-##
-## Standard deviations:
-## Comp.1 Comp.2 Comp.3
-## 124.814772 17.084151 1.456423
-##
-## 3 variables and 7777 observations.
-##
-## $map
-## class : SpatRaster
-## dimensions : 77, 101, 3 (nrow, ncol, nlyr)
-## resolution : 1, 1 (x, y)
-## extent : 0, 101, 0, 77 (xmin, xmax, ymin, ymax)
-## coord. ref. : +proj=merc +lon_0=0 +k=1 +x_0=0 +y_0=0 +ellps=WGS84 +towgs84=0,0,0,0,0,0,0 +units=m +no_defs
-## source(s) : memory
-## names : PC1, PC2, PC3
-## min values : -323.1956, -46.42416, -9.374094
-## max values : 118.2781, 26.11958, 6.362937
-##
-## attr(,"class")
-## [1] "rasterPCA" "RStoolbox"
-
-
## Model parameters:
-summary(rpc$model)
-
-
## Importance of components:
-## Comp.1 Comp.2 Comp.3
-## Standard deviation 124.8147718 17.08415063 1.456422555
-## Proportion of Variance 0.9814783 0.01838804 0.000133636
-## Cumulative Proportion 0.9814783 0.99986636 1.000000000
-
-
loadings(rpc$model)
-
-
##
-## Loadings:
-## Comp.1 Comp.2 Comp.3
-## red 0.594 0.507 0.625
-## green 0.585 0.262 -0.768
-## blue 0.553 -0.821 0.141
-##
-## Comp.1 Comp.2 Comp.3
-## SS loadings 1.000 1.000 1.000
-## Proportion Var 0.333 0.333 0.333
-## Cumulative Var 0.333 0.667 1.000
-
-
ggRGB(rpc$map,1,2,3, stretch="lin", q=0)
-
-
-
if(require(gridExtra)){
- plots <- lapply(1:3, function(x) ggR(rpc$map, x, geom_raster = TRUE))
- grid.arrange(plots[[1]],plots[[2]], plots[[3]], ncol=2)
-}
-
-
## Loading required package: gridExtra
-
-
## Warning: package 'gridExtra' was built under R version 4.2.2
-
-
-
-
-
[Package
RStoolbox version 0.4.0
Index ]
-
R: Tidy import tool for EarthExplorer .csv export files
-
-
-
readEE {RStoolbox} R Documentation
-
-
Tidy import tool for EarthExplorer .csv export files
-
-
Description
-
-
Imports and tidies CSV files exported from EarthExplorer into data.frames and annotates missing fields.
-
-
-
-
Usage
-
-
readEE(x)
-
-
-
-
Arguments
-
-
-x
-Character, Character or list. One or more paths to EarthExplorer export files.
-
-
-
-
Details
-
-
The EarthExplorer CSV file can be produced from the search results page. Above the results click on 'export results' and select 'comma (,) delimited'.
-
-
Note that only a subset of columns is imported which was deemed interesting. Please contact the maintainer if you think an omited column should be included.
-
-
-
-
Value
-
-
data.frame
-
-
-
-
Examples
-
-
library(ggplot2)
-ee <- readEE(system.file("external/EarthExplorer_LS8.txt", package = "RStoolbox"))
-
-## Scenes with cloud cover < 20%
-ee[ee$Cloud.Cover < 20,]
-
-
## Landsat.Scene.Identifier WRS.Path WRS.Row Data.Category Cloud.Cover Station.Identifier Day.Night
-## 6 LC82240632015157LGN00 224 63 NOMINAL 13.20 LGN DAY
-## 27 LC82240632014186LGN00 224 63 NOMINAL 15.94 LGN DAY
-## 40 LC82240632013327LGN00 224 63 NOMINAL 13.19 LGN DAY
-## 46 LC82240632013215LGN00 224 63 NOMINAL 14.72 LGN DAY
-## 49 LC82240632013167LGN00 224 63 NOMINAL 6.35 LGN DAY
-## Data.Type.Level.1 Date.Acquired Sun.Elevation Sun.Azimuth Geometric.RMSE.Model.X Geometric.RMSE.Model.Y
-## 6 L1T 2015/06/06 51.98871 43.59274 6.244 5.663
-## 27 L1T 2014/07/05 51.01591 44.79093 5.452 5.420
-## 40 L1GT 2013/11/23 61.83434 126.95937 0.000 0.000
-## 46 L1T 2013/08/03 54.43226 51.68815 5.631 5.840
-## 49 L1T 2013/06/16 51.64735 42.59918 6.377 5.862
-## Display.ID Ordering.ID
-## 6 LC82240632015157LGN00 LC82240632015157LGN00
-## 27 LC82240632014186LGN00 LC82240632014186LGN00
-## 40 LC82240632013327LGN00 LC82240632013327LGN00
-## 46 LC82240632013215LGN00 LC82240632013215LGN00
-## 49 LC82240632013167LGN00 LC82240632013167LGN00
-## Download.Link Browse.Link Date Doy Year
-## 6 http://earthexplorer.usgs.gov/download/options/4923/LC82240632015157LGN00 NA 2015-06-06 157 2015
-## 27 http://earthexplorer.usgs.gov/download/options/4923/LC82240632014186LGN00 NA 2014-07-05 186 2014
-## 40 http://earthexplorer.usgs.gov/download/options/4923/LC82240632013327LGN00 NA 2013-11-23 327 2013
-## 46 http://earthexplorer.usgs.gov/download/options/4923/LC82240632013215LGN00 NA 2013-08-03 215 2013
-## 49 http://earthexplorer.usgs.gov/download/options/4923/LC82240632013167LGN00 NA 2013-06-16 167 2013
-## Satellite Num
-## 6 LS8 8
-## 27 LS8 8
-## 40 LS8 8
-## 46 LS8 8
-## 49 LS8 8
-
-
## Available time-series
-ggplot(ee) +
- geom_segment(aes(x = Date, xend = Date, y = 0, yend = 100 - Cloud.Cover,
- col = as.factor(Year))) +
- scale_y_continuous(name = "Scene quality (% clear sky)")
-
-
-
-
-
[Package
RStoolbox version 0.4.0
Index ]
-
R: Read Landsat MTL metadata files
-
-
-
readMeta {RStoolbox} R Documentation
-
-
Read Landsat MTL metadata files
-
-
Description
-
-
Reads metadata and deals with legacy versions of Landsat metadata files and where possible adds missing information (radiometric gain and offset, earth-sun distance).
-
-
-
-
Usage
-
-
readMeta(file, raw = FALSE)
-
-
-
-
Arguments
-
-
-file
-path to Landsat MTL file (...MTL.txt)
- raw
-Logical. If TRUE the full raw metadata will be returned as a list. if FALSE (the default) all important metadata are homogenized into a standard format (ImageMetaData) and some information is added.
-
-
-
-
Value
-
-
Object of class ImageMetaData
-
-
-
-
Examples
-
-
## Example metadata file (MTL)
-mtlFile <- system.file("external/landsat/LT52240631988227CUB02_MTL.txt", package="RStoolbox")
-
-## Read metadata
-metaData <- readMeta(mtlFile)
-
-## Summary
-summary(metaData)
-
-
## Scene: LT52240631988227CUB02
-## Satellite: LANDSAT5
-## Sensor: TM
-## Date: 1988-08-14
-## Path/Row: 224/63
-## Projection: +proj=utm +zone=22 +units=m +datum=WGS84 +ellips=WGS84
-## Scene: PROJCRS["unknown",
-## BASEGEOGCRS["unknown",
-## DATUM["World Geodetic System 1984",
-## ELLIPSOID["WGS 84",6378137,298.257223563,
-## LENGTHUNIT["metre",1]],
-## ID["EPSG",6326]],
-## PRIMEM["Greenwich",0,
-## ANGLEUNIT["degree",0.0174532925199433],
-## ID["EPSG",8901]]],
-## CONVERSION["UTM zone 22N",
-## METHOD["Transverse Mercator",
-## ID["EPSG",9807]],
-## PARAMETER["Latitude of natural origin",0,
-## ANGLEUNIT["degree",0.0174532925199433],
-## ID["EPSG",8801]],
-## PARAMETER["Longitude of natural origin",-51,
-## ANGLEUNIT["degree",0.0174532925199433],
-## ID["EPSG",8802]],
-## PARAMETER["Scale factor at natural origin",0.9996,
-## SCALEUNIT["unity",1],
-## ID["EPSG",8805]],
-## PARAMETER["False easting",500000,
-## LENGTHUNIT["metre",1],
-## ID["EPSG",8806]],
-## PARAMETER["False northing",0,
-## LENGTHUNIT["metre",1],
-## ID["EPSG",8807]],
-## ID["EPSG",16022]],
-## CS[Cartesian,2],
-## AXIS["(E)",east,
-## ORDER[1],
-## LENGTHUNIT["metre",1,
-## ID["EPSG",9001]]],
-## AXIS["(N)",north,
-## ORDER[2],
-## LENGTHUNIT["metre",1,
-## ID["EPSG",9001]]]]
-##
-## Data:
-## FILES QUANTITY CATEGORY
-## B1_dn LT52240631988227CUB02_B1.TIF dn image
-## B2_dn LT52240631988227CUB02_B2.TIF dn image
-## B3_dn LT52240631988227CUB02_B3.TIF dn image
-## B4_dn LT52240631988227CUB02_B4.TIF dn image
-## B5_dn LT52240631988227CUB02_B5.TIF dn image
-## B6_dn LT52240631988227CUB02_B6.TIF dn image
-## B7_dn LT52240631988227CUB02_B7.TIF dn image
-##
-## Available calibration parameters (gain and offset):
-## dn -> radiance (toa)
-## dn -> brightness temperature (toa)
-
-
-
-
[Package
RStoolbox version 0.4.0
Index ]
-
R: Read ENVI spectral libraries
-
-
-
readSLI {RStoolbox} R Documentation
-
-
Read ENVI spectral libraries
-
-
Description
-
-
read/write support for ENVI spectral libraries
-
-
-
-
Usage
-
-
readSLI(path)
-
-
-
-
Arguments
-
-
-path
-Path to spectral library file with ending .sli.
-
-
-
-
Details
-
-
ENVI spectral libraries consist of a binary data file (.sli) and a corresponding header (.hdr, or .sli.hdr) file.
-
-
-
-
Value
-
-
The spectral libraries are read into a data.frame. The first column contains the wavelengths and the remaining columns contain the spectra.
-
-
-
-
See Also
-
-
writeSLI
-
-
-
Examples
-
-
## Example data
-sliFile <- system.file("external/vegSpec.sli", package="RStoolbox")
-sliTmpFile <- paste0(tempdir(),"/vegetationSpectra.sli")
-
-## Read spectral library
-sli <- readSLI(sliFile)
-head(sli)
-
-
## wavelength veg_stressed veg_vital
-## 1 350 0.008958003 0.008836994
-## 2 351 0.008910760 0.008909440
-## 3 352 0.008874181 0.008972186
-## 4 353 0.008847097 0.009025744
-## 5 354 0.008829174 0.009071405
-## 6 355 0.008819440 0.009109739
-
-
plot(sli[,1:2], col = "orange", type = "l")
-lines(sli[,c(1,3)], col = "green")
-
-
-
## Write to binary spectral library
-writeSLI(sli, path = sliTmpFile)
-
-
-
-
[Package
RStoolbox version 0.4.0
Index ]
-
ImageMetaData Class — ImageMetaData • RStoolbox Skip to contents
+
+
+
+
+
+
+
+
+
+
+
Usage
+
ImageMetaData ( file = NA ,
+ format = NA ,
+ sat = NA ,
+ sen = NA ,
+ scene = NA ,
+ colNum = NA ,
+ colTier = NA ,
+ proj = NA ,
+ date = NA ,
+ pdate = NA ,
+ path = NA ,
+ row = NA ,
+ az = NA ,
+ selv = NA ,
+ esd = NA ,
+ files = NA ,
+ bands = NA ,
+ quant = NA ,
+ cat = NA ,
+ na = NA ,
+ vsat = NA ,
+ scal = NA ,
+ dtyp = NA ,
+ calrad = NA ,
+ calref = NA ,
+ calbt = NA ,
+ radRes = NA ,
+ spatRes = NA
+)
+
+
Arguments
+
file
+Character. Metadata file
format
+Character. Metadata format, e.g. xml, mtl
sat
+Character. Satellite platform
sen
+Character. Sensor
scene
+Character. Scene_ID
colNum
+Character Collection number
colTier
+Character Collection tier
proj
+CRS. Projection.
date
+POSIXct. Aquisition date.
pdate
+POSIXct. Processing date.
path
+Integer. Path.
row
+Integer. Row.
az
+Numeric. Sun azimuth
selv
+Numeric. Sun elevation
esd
+Numeric. Earth-sun distance
files
+Character vector. Files containing the data, e.g. tiff files
bands
+Character vector. Band names
quant
+Character vector. Quantity, one of c("dn", "tra", "tre", "sre", "bt", "idx", "angle")
cat
+Character vector. Category, e.g. c("image", "pan", "index", "qa", "aux")
na
+Numeric vector. No-data value per band
vsat
+Numeric vector. Saturation value per band
scal
+Numeric vector. Scale factor per band. e.g. if data was scaled to 1000*reflectance for integer conversion.
dtyp
+Character vector. Data type per band.
calrad
+data.frame. Calibration coefficients for dn->radiance conversion. Must have columns 'gain' and 'offset'. Rows named according to bands.
calref
+data.frame. Calibration coefficients for dn->reflectance conversion. Must have columns 'gain' and 'offset'. Rows named according to bands.
calbt
+data.frame. Calibration coefficients for dn->brightness temperature conversion. Must have columns 'K1' and 'K2'. Rows named according to bands.
radRes
+Numeric vector. Radiometric resolution per band.
spatRes
+Numeric vector. Spatial resolution per band.
+
Value
+
+
+
Returns a structured, fully customizable meta-data table of a file
+
+
+
+
RStoolbox: A Collection of Remote Sensing Tools — RStoolbox • RStoolbox Skip to contents
+
+
+
+
+
+
+
+
+
The RStoolbox package provides a set of functions which simplify performing standard remote sensing tasks in R.
+
+
Data Import and Export
+
+
+
+
readMeta
stackMeta
readSLI & writeSLI
saveRSTBX & readRSTBX
readEE
+
Data Pre-Processing
+
+
+
+
radCor
topCor
cloudMask & cloudShadowMask
classifyQA
rescaleImage
normImage
histMatch
coregisterImages
panSharpen
+
Data Analysis
+
+
+
+
spectralIndices
tasseledCap
sam
rasterPCA
rasterCVA
unsuperClass
superClass
fCover
+
+
+
Classify Landsat QA bands — classifyQA • RStoolbox Skip to contents
+
+
+
+
+
+
+
+
+
extracts five classes from QA band: background, cloud, cirrus, snow and water.
+
+
Usage
+
classifyQA ( img ,
+ type = c ( "background" , "cloud" , "cirrus" , "snow" , "water" ) ,
+ confLayers = FALSE ,
+ sensor = "OLI" ,
+ legacy = "collection1" ,
+ ...
+)
+
+
Arguments
+
img
+SpatRaster. Landsat 8 OLI QA band.
type
+Character. Classes which should be returned. One or more of c("background", "cloud", "cirrus","snow", "water").
confLayers
+Logical. Return one layer per class classified by confidence levels, i.e. cloud:low, cloud:med, cloud:high.
sensor
+Sensor to encode. Options: c("OLI", "TIRS", "ETM+", "TM", "MSS").
legacy
+Encoding systematic Options: c("collection1", "pre_collection"). Default is "collection1" for the Landsat Collection 1 8-bit quality designations. Use "pre_collection" for imagery downloaded before the Collection 1 quality designations were introduced
...
+further arguments passed to writeRaster
+
Value
+
+
+
Returns a SpatRaster with maximal five classes:
class value background 1L cloud 2L cirrus 3L snow 4L water 5L
Values outside of these classes are returned as NA.
+If confLayers = TRUE then a RasterStack with one layer per condition (except 'background') is returned, whereby each layer contains the confidence level of the condition.
Confidence value low 1L med 2L high 3L
+
Details
+
By default each class is queried for *high* confidence. See encodeQA for details. To return the different confidence levels per condition use confLayers=TRUE.
+This approach corresponds to the way LandsatLook Quality Images are produced by the USGS.
+
+
Examples
+
library ( terra ) #> terra 1.7.71qa <- rast ( ncol = 100 , nrow= 100 , val = sample ( 1 : 2 ^ 14 , 10000 ) ) ## QA classes qacs <- classifyQA ( img = qa ) ## Confidence levels qacs_conf <- classifyQA ( img = qa , confLayers = TRUE )
+
+
+
+
Simple Cloud Detection — cloudMask • RStoolbox Skip to contents
+
+
+
+
+
+
+
+
+
Developed for use with Landsat data cloudMask relies on the distinctive difference between the blue (or any other short-wave band)
+and thermal band for semi-automated creation of a cloud mask. Since it relies on thermal information it doesn't work well for sensors without
+thermal bands.
+
+
Usage
+
cloudMask ( x ,
+ threshold = 0.2 ,
+ blue = "B1_sre" ,
+ tir = "B6_sre" ,
+ buffer = NULL ,
+ plot = FALSE ,
+ verbose
+)
+
+
Arguments
+
x
+SpatRaster with reflectance and brightness temperature OR the mask of a previous run of cloudMask with returnDiffLayer=TRUE.
threshold
+Numeric. cloud detection threshold. If not provided it will be guessed. Everything *below* this threshold will be considered a cloud pixel (unless it is removed by filtering afterwards).
blue
+Character or integer. Bandname or number for the blue band
tir
+Character or integer. Bandname or number for the thermal band
buffer
+Integer. Number of pixels to use as a buffer that will be added to the identified cloud centers.
plot
+Logical. Plots of the cloud mask for all sub-steps (sanitizing etc.) Helpful to find proper parametrization.
verbose
+Logical. Print messages or suppress.
+
Value
+
+
+
Returns a SpatRaster with two layers: CMASK contains the binary cloud mask (1 = cloud, NA = not-cloud) and NDTCI contains the cloud index.
+
+
Note
+
Typically clouds are cold in the thermal region and have high reflectance in short wavelengths (blue). By calculating a normalized difference index between the two bands and thresholding a rough cloud mask can be obtained.
+Before calculating the spectral cloud index (let's call it Normalized Difference Thermal Cloud Index (NDTCI)) the thermal band will be matched to the same value range as the blue band. Therefore, it doesn't matter whether you
+provide DN, radiance or brightness temperature.
+
This approach to cloud masking is very simplistic. And aims only at rough removal of potentially clouded areas. Nevertheless, it is able to provide satisfactory results.
+More sophisticated approaches, including cloud cast shadow detection can be found elsewhere, e.g. fmask .
+
It can make sense to find a suitable threshold on a cropped version of the scene. Also make sure you make use of the returnDiffLayer argument to save yourself one processing step.
+Buffering should be seen as final polishing, i.e. as long as the pure cloud centers are not detected properly, you might want to turn it off. since it takes some time to calculate.
+Once your mask detects obvious cloud pixels properly re-enable buffering for fine tuning if desired. Finally, once a suitable threshold is established re-run cloudMask on the whole scene with this threshold and go get a coffee.
+
+
Examples
+
library ( ggplot2 ) ## Import Landsat example subset ## We have two tiny clouds in the east ggRGB ( lsat , stretch = "lin" ) ## Calculate cloud index cldmsk <- cloudMask ( lsat , blue = 1 , tir = 6 ) ggR ( cldmsk , 2 , geom_raster = TRUE ) ## Define threshold (re-use the previously calculated index) ## Everything above the threshold is masked ## In addition we apply a region-growing around the core cloud pixels cldmsk_final <- cloudMask ( cldmsk , threshold = 0.1 , buffer = 5 ) ## Plot cloudmask ggRGB ( lsat , stretch = "lin" ) + ggR ( cldmsk_final [[ 1 ] ] , ggLayer = TRUE , forceCat = TRUE , geom_raster = TRUE ) + scale_fill_manual ( values = c ( "red" ) , na.value = NA ) #> Warning: Removed 88752 rows containing missing values or values outside the scale range#> (`geom_raster()`).#' ## Estimate cloud shadow displacement ## Interactively (click on cloud pixels and the corresponding shadow pixels) if ( FALSE ) shadow <- cloudShadowMask ( lsat , cldmsk_final , nc = 2 ) ## Non-interactively. Pre-defined shadow displacement estimate (shiftEstimate) shadow <- cloudShadowMask ( lsat , cldmsk_final , shiftEstimate = c ( - 16 ,- 6 ) ) ## Plot csmask <- terra :: merge ( cldmsk_final [[ 1 ] ] , shadow ) ggRGB ( lsat , stretch = "lin" ) + ggR ( csmask , ggLayer = TRUE , forceCat = TRUE , geom_raster = TRUE ) + scale_fill_manual ( values = c ( "blue" , "yellow" ) , labels = c ( "shadow" , "cloud" ) , na.value = NA ) #> Warning: Removed 88534 rows containing missing values or values outside the scale range#> (`geom_raster()`).
+
+
+
+
Cloud Shadow Masking for Flat Terrain — cloudShadowMask • RStoolbox Skip to contents
+
+
+
+
+
+
+
+
+
Intended for interactive use, cloudShadowMask will ask the user to select a few
+corresponding cloud/cloudShadow pixels which will be used to estimate coordinates
+for a linear cloudmask shift.
+
+
Usage
+
cloudShadowMask ( img ,
+ cm ,
+ nc = 5 ,
+ shiftEstimate = NULL ,
+ preciseShift = NULL ,
+ quantile = 0.2 ,
+ returnShift = FALSE
+)
+
+
Arguments
+
img
+SpatRaster containing the scene
cm
+SpatRaster. Cloud mask (typically the result of cloudMask
nc
+Integer. Number of control points. A few points (default) are fine because the final shift is estimated by coregisterImages .
shiftEstimate
+NULL or numeric vector of length two (x,y). Estimated displacement of shadows in map units. If NULL, the user will be asked to select control points interactively.
preciseShift
+NULL or numeric vector of length two (x,y). Use this if cloud/cloud-shadow displacement is already known, e.g. from a previous run of cloudShadowMask.
quantile
+Numeric (between 0 and 1). Quantile threshold used for image co-registration. By default the 20% quantile of the total intensity (sum) of the image is used as potential shadow mask.
returnShift
+Logical. Return a numeric vector containing the shift parameters. Useful if you estimate parameters on a subset of the image.
+
Value
+
+
+
Returns a RasterLayer with the cloud shadow mask (0 = shadow, NA = not-shadow).
+
+
Details
+
This is a very simplistic approach to cloud shadow masking (simple shift of the cloud mask). It is not image based and accuracy will suffer from clouds at different altitudes. However, just as cloudMask
+this is a quick and easy to use tool for Landsat data if you're just working on a few scenes and don't have fMask or CDR data at hand. Although for some test scenes
+it does perform surprisingly well.
+
+
Examples
+
library ( ggplot2 ) ## Import Landsat example subset ## We have two tiny clouds in the east ggRGB ( lsat , stretch = "lin" ) ## Calculate cloud index cldmsk <- cloudMask ( lsat , blue = 1 , tir = 6 ) ggR ( cldmsk , 2 , geom_raster = TRUE ) ## Define threshold (re-use the previously calculated index) ## Everything above the threshold is masked ## In addition we apply a region-growing around the core cloud pixels cldmsk_final <- cloudMask ( cldmsk , threshold = 0.1 , buffer = 5 ) ## Plot cloudmask ggRGB ( lsat , stretch = "lin" ) + ggR ( cldmsk_final [[ 1 ] ] , ggLayer = TRUE , forceCat = TRUE , geom_raster = TRUE ) + scale_fill_manual ( values = c ( "red" ) , na.value = NA ) #> Warning: Removed 88752 rows containing missing values or values outside the scale range#> (`geom_raster()`).#' ## Estimate cloud shadow displacement ## Interactively (click on cloud pixels and the corresponding shadow pixels) if ( FALSE ) shadow <- cloudShadowMask ( lsat , cldmsk_final , nc = 2 ) ## Non-interactively. Pre-defined shadow displacement estimate (shiftEstimate) shadow <- cloudShadowMask ( lsat , cldmsk_final , shiftEstimate = c ( - 16 ,- 6 ) ) ## Plot csmask <- terra :: merge ( cldmsk_final [[ 1 ] ] , shadow ) ggRGB ( lsat , stretch = "lin" ) + ggR ( csmask , ggLayer = TRUE , forceCat = TRUE , geom_raster = TRUE ) + scale_fill_manual ( values = c ( "blue" , "yellow" ) , labels = c ( "shadow" , "cloud" ) , na.value = NA ) #> Warning: Removed 88534 rows containing missing values or values outside the scale range#> (`geom_raster()`).
+
+
+
+
Image to Image Co-Registration based on Mutual Information — coregisterImages • RStoolbox Skip to contents
+
+
+
+
+
+
+
+
+
Shifts an image to match a reference image. Matching is based on maximum
+mutual information.
+
+
Usage
+
coregisterImages ( img ,
+ ref ,
+ shift = 3 ,
+ shiftInc = 1 ,
+ nSamples = 100 ,
+ reportStats = FALSE ,
+ verbose ,
+ nBins = 100 ,
+ master = deprecated ( ) ,
+ slave = deprecated ( ) ,
+ ...
+)
+
+
Arguments
+
img
+SpatRaster. Image to shift to match reference image. img and ref must have equal numbers of bands.
ref
+SpatRaster. Reference image. img and ref must have equal numbers of bands.
shift
+Numeric or matrix. If numeric, then shift is the maximal absolute radius (in pixels of img resolution) which img is shifted (seq(-shift, shift, by=shiftInc)).
+If shift is a matrix it must have two columns (x shift and y shift), then only these shift values will be tested.
shiftInc
+Numeric. Shift increment (in pixels, but not restricted to integer). Ignored if shift is a matrix.
nSamples
+Integer. Number of samples to calculate mutual information.
reportStats
+Logical. If FALSE it will return only the shifted images. Otherwise it will return the shifted image in a list containing stats such as mutual information per shift and joint histograms.
verbose
+Logical. Print status messages. Overrides global RStoolbox.verbose option.
nBins
+Integer. Number of bins to calculate joint histogram.
master
+DEPRECATED! Argument was renamed. Please use ref from now on.
slave
+DEPRECATED! Argument was renamed. Please use img from now on.
...
+further arguments passed to writeRaster
+
Value
+
+
+
reportStats=FALSE returns a SpatRaster (x-y shifted image).
+reportStats=TRUE returns a list containing a data.frame with mutual information per shift ($MI), the shift of maximum MI ($bestShift),
+the joint histograms per shift in a list ($jointHist) and the shifted image ($coregImg).
+
+
Details
+
Currently only a simple linear x - y shift is considered and tested. No higher order shifts (e.g. rotation, non-linear transformation) are performed. This means that your imagery
+should already be properly geometrically corrected.
+
Mutual information is a similarity metric originating from information theory.
+Roughly speaking, the higher the mutual information of two data-sets, the higher is their shared information content, i.e. their similarity.
+When two images are exactly co-registered their mutual information is maximal. By trying different image shifts, we aim to find the best overlap which maximises the mutual information.
+
+
Examples
+
library ( terra ) library ( ggplot2 ) library ( reshape2 ) reference <- rlogo ## Shift reference 2 pixels to the right and 3 up missreg <- shift ( reference , 2 , 3 ) ## Compare shift p <- ggR ( reference , sat = 1 , alpha = .5 ) p + ggR ( missreg , sat = 1 , hue = .5 , alpha = 0.5 , ggLayer= TRUE ) ## Coregister images (and report statistics) coreg <- coregisterImages ( missreg , ref = reference , nSamples = 500 , reportStats = TRUE ) ## Plot mutual information per shift ggplot ( coreg $ MI ) + geom_raster ( aes ( x ,y ,fill= mi ) ) ## Plot joint histograms per shift (x/y shift in facet labels) # \donttest{ df <- melt ( coreg $ jointHist ) df $ L1 <- factor ( df $ L1 , levels = names ( coreg $ jointHist ) ) df [ df $ value == 0 , "value" ] <- NA ## don't display p = 0 ggplot ( df ) + geom_raster ( aes ( x = Var2 , y = Var1 ,fill= value ) ) + facet_wrap ( ~ L1 ) + scale_fill_gradientn ( name = "p" , colours = heat.colors ( 10 ) , na.value = NA ) #> Warning: Removed 443028 rows containing missing values or values outside the scale range#> (`geom_raster()`).# } ## Compare correction ggR ( reference , sat = 1 , alpha = .5 ) + ggR ( coreg $ coregImg , sat = 1 , hue = .5 , alpha = 0.5 , ggLayer= TRUE )
+
+
+
+
Decode QA flags to bit-words — decodeQA • RStoolbox Skip to contents
+
+
+
+
+
+
+
+
+
Intended for use with Landsat 16-bit QA bands. Decodes pixel quality flags from integer to bit-words.
+
+
Arguments
+
x
+Integer (16bit)
+
Value
+
+
+
Returns the decoded QA values from an integer
+
+
Examples
+
decodeQA ( 53248 ) #> [1] "1101000000000000"
+
+
+
+
Encode QA Conditions to Integers — encodeQA • RStoolbox Skip to contents
+
+
+
+
+
+
+
+
+
Intended for use with Landsat 16-bit QA bands. Converts pixel quality flags from human readable to integer, which can then be used to
+subset a QA image. Please be aware of the default settings which differ for different parameters.
+Depending on, which sensor and legacy is selected, some quality parameters are not used, since the sequences of available bitwise quality designations differ per sensor and collection.
+
+
Usage
+
encodeQA ( fill = "no" ,
+ terrainOcclusion = "no" ,
+ radSaturation = "na" ,
+ cloudMask = "all" ,
+ cloud = "all" ,
+ cloudShadow = "all" ,
+ snow = "all" ,
+ cirrus = "all" ,
+ droppedPixel = "no" ,
+ water = "all" ,
+ droppedFrame = "no" ,
+ sensor = "OLI" ,
+ legacy = "collection1"
+)
+
+
Arguments
+
fill
+Designated fill. Options: c("yes", "no", "all").
terrainOcclusion
+Terrain induced occlusion. Options: c("yes", "no", "all").
radSaturation
+Number of bands that contain radiometric saturation. Options: c("na", "low", "med", "high", "all") for no bands, 1-2 bands, 3-4 bands, 5 or more bands contain saturation.
cloudMask
+Cloud mask. Options: c("yes", "no", "all").
cloud
+Cloud confidence. Options: c("na", "low", "med", "high", "all").
cloudShadow
+Cloud shadow confidence. Options: c("yes", "no", "all").
snow
+Snow / ice confidence. Options: c("na", "low", "med", "high", "all").
cirrus
+Cirrus confidence. Options: c("na", "low", "med", "high", "all").
droppedPixel
+Dropped pixel. Options: c("yes", "no", "all").
water
+Water confidence. Options: c("na", "low", "med", "high", "all").
droppedFrame
+Dropped frame. Options: c("yes", "no", "all").
sensor
+Sensor to encode. Options: c("OLI", "TIRS", "ETM+", "TM", "MSS").
legacy
+Encoding systematic Options: c("collection1", "pre_collection"). Default is "collection1" for the Landsat Collection 1 8-bit quality designations. Use "pre_collection" for imagery downloaded before the Collection 1 quality designations were introduced
+
Value
+
+
+
Returns the Integer value for the QA values
+
+
Note
+
Only currently populated bits are available as arguments.
+
+
Examples
+
encodeQA ( snow = "low" , cirrus = c ( "med" , "high" ) , cloud = "high" ) #> [1] 23136 23264 23392 23520 23152 23280 23408 23536
+
+
+
+
Estimate Image Haze for Dark Object Subtraction (DOS) — estimateHaze • RStoolbox Skip to contents
+
+
+
+
+
+
+
+
+
estimates the digital number (DN) pixel value of *dark* objects for the visible wavelength range.
+
+
Usage
+
estimateHaze ( x ,
+ hazeBands ,
+ darkProp = 0.01 ,
+ maxSlope = TRUE ,
+ plot = FALSE ,
+ returnTables = FALSE
+)
+
+
Arguments
+
x
+SpatRaster or a previous result from estimateHaze with returnTables = TRUE from which to estimate haze
hazeBands
+Integer or Character. Band number or bandname from which to estimate atmospheric haze (optional if x contains only one layer)
darkProp
+Numeric. Proportion of pixels estimated to be dark.
maxSlope
+Logical. Use darkProp only as an upper boundary and search for the DN of maximum slope in the histogram below this value.
plot
+Logical. Option to display histograms and haze values
returnTables
+Logical. Option to return the frequency table per layer. Only takes effect if x is a SpatRaster. If x is a result of estimateHaze tables will always be returned.
+
Value
+
+
+
If returnTables is FALSE (default). Then a vector of length(hazeBands) containing the estimated haze DNs will be returned.
+If returnTables is TRUE a list with two components will be returned. The list element 'SHV' contains the haze values, while 'table'
+contains another list with the sampled frequency tables. The latter can be re-used to try different darkProp thresholds without having to sample
+the raster again.
+
+
Details
+
It is assumed that any radiation originating from *dark* pixels is due to atmospheric haze and
+not the reflectance of the surface itself (the surface is dark, i.e. it has a reflectance close to zero).
+Hence, the haze values are estimates of path radiance, which can be subtracted in a dark object subtraction (DOS) procedure (see radCor
+
Atmospheric haze affects almost exclusively the visible wavelength range. Therefore, typically, you'd only want to estimate haze in blue, green and red bands, occasionally also in the nir band.
+
+
Examples
+
## Estimate haze for blue, green and red band haze <- estimateHaze ( lsat , hazeBands = 1 : 3 , plot = FALSE ) haze #> B1_dn B2_dn B3_dn #> 55 19 12 ## Find threshold interactively #### Return the frequency tables for re-use #### avoids having to sample the Raster again and again haze <- estimateHaze ( lsat , hazeBands = 1 : 3 , returnTables = TRUE ) ## Use frequency table instead of lsat and fiddle with haze <- estimateHaze ( haze , hazeBands = 1 : 3 , darkProp = .1 , plot = FALSE ) haze $ SHV #> B1_dn B2_dn B3_dn #> 57 20 12
+
+
+
+
Fractional Cover Analysis — fCover • RStoolbox Skip to contents
+
+
+
+
+
+
+
+
+
fCover takes a classified high resolution image, e.g. vegetation and non-vegetation based on Landsat and calculates cover fractions for
+pixels of a coarser resolution, e.g. MODIS.
+
+
Usage
+
fCover ( classImage ,
+ predImage ,
+ nSamples = 1000 ,
+ classes = 1 ,
+ maxNA = 0 ,
+ clamp = TRUE ,
+ model = "rf" ,
+ tuneLength = 3 ,
+ trControl = trainControl ( method = "cv" ) ,
+ method = deprecated ( ) ,
+ filename = NULL ,
+ overwrite = FALSE ,
+ verbose ,
+ ...
+)
+
+
Arguments
+
classImage
+high resolution SpatRaster containing a landcover classification, e.g. as obtained by superClass .
predImage
+coarse resolution SpatRaster for which fractional cover will be estimated.
nSamples
+Integer. Number of pixels to sample from predImage to train the regression model
classes
+Integer. Classes for which fractional cover should be estimated (one or more).
maxNA
+Numeric. Maximal proportion of NAs allowed in training pixels.
clamp
+Logical. Enforce results to stay within [0,1] interval. Values <0 are reset to 0 and values >1 to 1.
model
+Character. Which model to fit for image regression. See train for options. Defaults to randomForest ('rf')
tuneLength
+Integer. Number of levels for each tuning parameters that should be generated by train. See Details and train
trControl
+trainControl
method
+DEPREACTED! in favor of trControl=trainControl(method="cv") Resampling method for parameter tuning. Defaults to 10 fold cross-validation. See trainControl
filename
+Character. Filename of the output raster file (optional).
overwrite
+Logical. if TRUE, filename will be overwritten.
verbose
+Logical. Print progress information.
...
+further arguments to be passed to writeRaster
+
Value
+
+
+
Returns a list with two elements: models contains the fitted models evaluated in tenfold cross-validation (caret train objects);
+fCover contains a SpatRaster with a fractional cover layer for each requested class.
+
+
Details
+
fCover gets the pixel values in a high resolution classified image that correspond to
+randomly selected moderate resolution pixels and then calculates the percent of
+the classified image pixels that represent your cover type of interest. In other words, if
+your high resolution image has a pixel size of 1m and your moderate resolution image has a
+pixel size of 30m the sampling process would take a block of 900 of the 1m resolution pixels
+that correspond to a single 30m pixel and calculate the percentage of the 1m pixels that
+are forest. For example, if there were 600 forest pixels and 300 non-forest pixels the value
+given for the output pixel would be 0.67 since 67
+
fCover relies on the train() function from the caret package which provides access to a huge number of classifiers.
+Please see the available options at train . The default classifier (randomForest) we chose has been shown
+to provide very good results in image regression and hence it is recomended you start with this one. If you choose a different
+classifier, make sure it can run in regression mode.
+
Many models require tuning of certain parameters. Again, this is handled by train from the caret package.
+With the tuneLength argument you can specify how many different values of each tuning parameter should be tested. The Random Forest
+algorithm for example can be tuned by varying the mtry parameter. Hence, by specifying tuneLength = 10, ten different levels
+of mtry will be tested in a cross-validation scheme and the best-performing value will be chosen for the final model.
+
+
If the total no-data values for a block of high resolution pixels is greater than maxNA then
+it will not be included in the training data set since there is too much missing data to provide
+a reliable cover percentage. If the no-data proporton is less then maxNA the no-data pixels are removed
+from the total number of pixels when calculating the percent cover.
+
+
Examples
+
# \donttest{ library ( terra ) library ( caret ) #> Loading required package: lattice## Create fake input images agg.level <- 9 modis <- terra :: aggregate ( rlogo , agg.level ) ## Perform an exemplary classification lc <- unsuperClass ( rlogo , nClass= 2 ) ## Calculate the true cover, which is of course only possible in this example, ## because the fake corse resolution imagery is exactly res(rlogo)*9 trueCover <- terra :: aggregate ( lc $ map , agg.level , fun = function ( x , ... ) { sum ( x == 1 , ... ) / sum ( ! is.na ( x ) ) } ) ## Run with randomForest and support vector machine (radial basis kernel) ## Of course the SVM is handicapped in this example, ## due to poor tuning (tuneLength) par ( mfrow= c ( 2 ,3 ) ) for ( model in c ( "rf" , "svmRadial" ) ) { fc <- fCover ( classImage = lc $ map , predImage = modis , classes= 1 , trControl = trainControl ( method = "cv" , number = 3 ) , model= model , nSample = 50 , tuneLength= 2 ) ## How close is it to the truth? compare.rf <- trueCover - fc $ map plot ( fc $ map , main = paste ( "Fractional Cover: Class 1\nModel:" , model ) ) plot ( compare.rf , main = "Diffence\n true vs. predicted" ) plot ( trueCover [ ] ,fc $ map [ ] , xlim = c ( 0 ,1 ) , ylim = c ( 0 ,1 ) , xlab = "True Cover" , ylab = "Predicted Cover" ) abline ( coef= c ( 0 ,1 ) ) rmse <- sqrt ( global ( compare.rf ^ 2 , "sum" , na.rm = TRUE ) ) / ncell ( compare.rf ) r2 <- cor ( trueCover [ ] , fc $ map [ ] , "complete.obs" ) text ( 0.9 ,0.1 , adj= 1 , labels = paste ( c ( "RMSE:" ,"\nR2:" ) , round ( unlist ( c ( rmse , r2 ) ) ,3 ) , collapse= "" ) ) } ## Reset par par ( mfrow= c ( 1 ,1 ) ) # }
+
+
+
+
Fortify method for classes from the terra package. — fortifySpatRaster • RStoolbox Skip to contents
+
+
+
+
+
+
+
+
+
Fortify method for classes from the terra package.
+
+
Usage
+
fortifySpatRaster ( x , maxpixels = 50000 )
+
+
Arguments
+
x
+SpatRaster object to convert into a dataframe.
maxpixels
+Integer. Maximum number of pixels to sample
+
Value
+
+
+
Returns a data.frame with coordinates (x,y) and corresponding raster values.
+
+
Examples
+
r_df <- fortifySpatRaster ( rlogo ) head ( r_df ) #> x y red green blue#> 1 0.5 76.5 255 255 255#> 2 1.5 76.5 255 255 255#> 3 2.5 76.5 255 255 255#> 4 3.5 76.5 255 255 255#> 5 4.5 76.5 255 255 255#> 6 5.5 76.5 255 255 255
+
+
+
+
Extract bandwise information from ImageMetaData — getMeta • RStoolbox Skip to contents
+
+
+
+
+
+
+
+
+
This is an accessor function to quickly access information stored in ImageMetaData, e.g. scale factor per band.
+Intended for use with imagery which was imported using stackMeta. Will return parameters using the actual band order in img.
+
+
Usage
+
getMeta ( img , metaData , what )
+
+
Arguments
+
img
+SpatRaster or character vector with band names.
metaData
+ImageMetaData or path to meta data file.
what
+Character. Parameter to extract. Either data descriptors, or conversion parameters (see Details for options)
+
Value
+
+
+
If what is one of c('CALRAD', 'CALBT', 'CALREF') a data.frame is returned with bands in rows (order corresponding to img band order).
+Otherwise a named numeric vector with the corresponding parameter is returned (layernames as names).
+
+
Details
+
Possible metadata parameters (what argument):
+
Data descriptors
'FILES' 'QUANTITY' 'CATEGORY' 'NA_VALUE' 'SATURATE_VALUE' 'SCALE_FACTOR' 'DATA_TYPE' 'SPATIAL_RESOLUTION'
Conversion parameters
'CALRAD' Conversion parameters from DN to radiance 'CALBT' Conversion parameters from radiance to brightness temperature 'CALREF' Conversion parameters from DN to reflectance (Landsat 8 only)
+
Examples
+
## Import example data mtlFile <- system.file ( "external/landsat/LT52240631988227CUB02_MTL.txt" , package= "RStoolbox" ) meta <- readMeta ( mtlFile ) lsat_t <- stackMeta ( mtlFile ) ## Get integer scale factors getMeta ( lsat_t , metaData = meta , what = "SCALE_FACTOR" ) #> B1_dn B2_dn B3_dn B4_dn B5_dn B6_dn B7_dn #> 1 1 1 1 1 1 1 ## Conversion factors for brightness temperature getMeta ( "B6_dn" , metaData = meta , what = "CALBT" ) #> K1 K2#> B6_dn 607.76 1260.56## Conversion factors to top-of-atmosphere radiance ## Band order not corresponding to metaData order getMeta ( lsat_t [[ 5 : 1 ] ] , metaData = meta , what = "CALRAD" ) #> offset gain#> B5_dn -0.49035 0.120#> B4_dn -2.38602 0.876#> B3_dn -2.21398 1.044#> B2_dn -4.16220 1.322#> B1_dn -2.19134 0.671## Get integer scale factors getMeta ( lsat_t , metaData = meta , what = "SCALE_FACTOR" ) #> B1_dn B2_dn B3_dn B4_dn B5_dn B6_dn B7_dn #> 1 1 1 1 1 1 1 ## Get file basenames getMeta ( lsat_t , metaData = meta , what = "FILES" ) #> B1_dn B2_dn #> "LT52240631988227CUB02_B1.TIF" "LT52240631988227CUB02_B2.TIF" #> B3_dn B4_dn #> "LT52240631988227CUB02_B3.TIF" "LT52240631988227CUB02_B4.TIF" #> B5_dn B6_dn #> "LT52240631988227CUB02_B5.TIF" "LT52240631988227CUB02_B6.TIF" #> B7_dn #> "LT52240631988227CUB02_B7.TIF"
+
+
+
+
Extract validation results from superClass objects — getValidation • RStoolbox Skip to contents
+
+
+
+
+
+
+
+
+
Extract validation results from superClass objects
+
+
Usage
+
getValidation ( x , from = "testset" , metrics = "overall" )
+
+
Arguments
+
x
+superClass object or caret::confusionMatrix
from
+Character. 'testset' extracts the results from independent validation with testset. 'cv' extracts cross-validation results.
metrics
+Character. Only relevant in classification mode (ignored for regression models).
+Select 'overall' for overall accuracy metrics, 'classwise' for classwise metrics,
+'confmat' for the confusion matrix itself and 'caret' to return the whole caret::confusionMatrix object.
+
Value
+
+
+
Returns a data.frame with validation results.
+If metrics = 'confmat' or 'caret' will return a table or the full caret::confusionMatrix object, respectively.
+
+
Examples
+
library ( pls ) #> #> Attaching package: ‘pls’#> The following object is masked from ‘package:caret’:#> #> R2#> The following object is masked from ‘package:stats’:#> #> loadings## Fit classifier (splitting training into 70\% training data, 30\% validation data) train <- readRDS ( system.file ( "external/trainingPoints_lsat.rds" , package= "RStoolbox" ) ) SC <- superClass ( rlogo , trainData = train , responseCol = "class" , model= "pls" , trainPartition = 0.7 ) ## Independent testset-validation getValidation ( SC ) #> model validation Accuracy Kappa AccuracyLower AccuracyUpper AccuracyNull#> 1 pls testset 0.8888889 0.8333333 0.5175035 0.9971909 0.3333333#> AccuracyPValue McnemarPValue#> 1 0.0009653 NaNgetValidation ( SC , metrics = "classwise" ) #> model validation class Sensitivity Specificity Pos.Pred.Value Neg.Pred.Value#> 1 pls testset A 1.0000000 0.8333333 0.75 1.0000000#> 2 pls testset B 0.6666667 1.0000000 1.00 0.8571429#> 3 pls testset C 1.0000000 1.0000000 1.00 1.0000000#> Precision Recall F1 Prevalence Detection.Rate Detection.Prevalence#> 1 0.75 1.0000000 0.8571429 0.3333333 0.3333333 0.4444444#> 2 1.00 0.6666667 0.8000000 0.3333333 0.2222222 0.2222222#> 3 1.00 1.0000000 1.0000000 0.3333333 0.3333333 0.3333333#> Balanced.Accuracy#> 1 0.9166667#> 2 0.8333333#> 3 1.0000000## Cross-validation based getValidation ( SC , from = "cv" ) #> model validation Accuracy Kappa AccuracyLower AccuracyUpper AccuracyNull#> 1 pls cv 0.8571429 0.7857143 0.636576 0.969511 0.3333333#> AccuracyPValue McnemarPValue#> 1 1.101588e-06 NaN
+
+
+
+
Plot RasterLayers in ggplot with greyscale — ggR • RStoolbox Skip to contents
+
+
+
+
+
+
+
+
+
Plot single layer imagery in grey-scale. Can be used with a SpatRaster.
+
+
Usage
+
ggR ( img ,
+ layer = 1 ,
+ maxpixels = 5e+05 ,
+ alpha = 1 ,
+ hue = 1 ,
+ sat = 0 ,
+ stretch = "none" ,
+ quantiles = c ( 0.02 , 0.98 ) ,
+ ext = NULL ,
+ coord_equal = TRUE ,
+ ggLayer = FALSE ,
+ ggObj = TRUE ,
+ geom_raster = FALSE ,
+ forceCat = FALSE
+)
+
+
Arguments
+
img
+SpatRaster
layer
+Character or numeric. Layername or number. Can be more than one layer, in which case each layer is plotted in a subplot.
maxpixels
+Integer. Maximal number of pixels to sample.
alpha
+Numeric. Transparency (0-1).
hue
+Numeric. Hue value for color calculation [0,1] (see hsv sat > 0.
sat
+Numeric. Saturation value for color calculation [0,1] (see hsv
stretch
+Character. Either 'none', 'lin', 'hist', 'sqrt' or 'log' for no stretch, linear, histogram, square-root or logarithmic stretch.
quantiles
+Numeric vector with two elements. Min and max quantiles to stretch to. Defaults to 2% stretch, i.e. c(0.02,0.98).
ext
+Extent object to crop the image
coord_equal
+Logical. Force addition of coord_equal, i.e. aspect ratio of 1:1. Typically useful for remote sensing data (depending on your projection), hence it defaults to TRUE.
+Note however, that this does not apply if (ggLayer=FALSE).
ggLayer
+Logical. Return only a ggplot layer which must be added to an existing ggplot. If FALSE s stand-alone ggplot will be returned.
ggObj
+Logical. Return a stand-alone ggplot object (TRUE) or just the data.frame with values and colors
geom_raster
+Logical. If FALSE uses annotation_raster (good to keep aestetic mappings free). If TRUE uses geom_raster (and aes(fill)). See Details.
forceCat
+Logical. If TRUE the raster values will be forced to be categorical (will be converted to factor if needed).
+
Value
+
+
+
ggObj = TRUE:ggplot2 plot ggLayer = TRUE:ggplot2 layer to be combined with an existing ggplot2 ggObj = FALSE:data.frame in long format suitable for plotting with ggplot2,
+ includes the pixel values and the calculated colors
+
Details
+
When img contains factor values and annotation=TRUE, the raster values will automatically be converted
+to numeric in order to proceed with the brightness calculation.
+
The geom_raster argument switches from the default use of annotation_raster to geom_raster. The difference between the two is that geom_raster performs
+a meaningful mapping from pixel values to fill colour, while annotation_raster is simply adding a picture to your plot. In practice this means that whenever you
+need a legend for your raster you should use geom_raster = TRUE. This also allows you to specify and modify the fill scale manually.
+The advantage of using annotation_raster (geom_raster = TRUE) is that you can still use the scale_fill* for another variable. For example you could add polygons and
+map a value to their fill colour. For more details on the theory behind aestetic mapping have a look at the ggplot2 manuals.
+
+
Examples
+
library ( ggplot2 ) library ( terra ) ## Simple grey scale annotation ggR ( rlogo ) ## With linear stretch contrast enhancement ggR ( rlogo , stretch = "lin" , quantiles = c ( 0.1 ,0.9 ) ) ## ggplot with geom_raster instead of annotation_raster ## and default scale_fill* ggR ( rlogo , geom_raster = TRUE ) ## with different scale ggR ( rlogo , geom_raster = TRUE ) + scale_fill_gradientn ( name = "mojo" , colours = rainbow ( 10 ) ) + ggtitle ( "**Funkadelic**" ) ## Plot multiple layers # \donttest{ ggR ( lsat , 1 : 6 , geom_raster= TRUE , stretch = "lin" ) + scale_fill_gradientn ( colors= grey.colors ( 100 ) , guide = "none" ) + theme ( axis.text = element_text ( size= 5 ) , axis.text.y = element_text ( angle= 90 ) , axis.title= element_blank ( ) ) ## Don't plot, just return a data.frame df <- ggR ( rlogo , ggObj = FALSE ) head ( df , n = 3 ) #> x y value layerName fill#> 1 0.5 76.5 255 red #FFFFFFFF#> 2 1.5 76.5 255 red #FFFFFFFF#> 3 2.5 76.5 255 red #FFFFFFFF## Layermode (ggLayer=TRUE) data <- data.frame ( x = c ( 0 , 0 : 100 ,100 ) , y = c ( 0 ,sin ( seq ( 0 ,2 * pi ,pi / 50 ) ) * 10 + 20 , 0 ) ) ggplot ( data , aes ( x , y ) ) + ggR ( rlogo , geom_raster= FALSE , ggLayer = TRUE ) + geom_polygon ( aes ( x , y ) , fill = "blue" , alpha = 0.4 ) + coord_equal ( ylim= c ( 0 ,75 ) ) ## Categorical data ## In this case you probably want to use geom_raster=TRUE ## in order to perform aestetic mapping (i.e. a meaningful legend) rc <- rlogo rc [ ] <- cut ( rlogo [[ 1 ] ] [ ] , seq ( 0 ,300 , 50 ) ) ggR ( rc , geom_raster = TRUE ) ## Legend cusomization etc. ... ggR ( rc , geom_raster = TRUE ) + scale_fill_continuous ( labels= paste ( "Class" , 1 : 6 ) ) # } ## Creating a nicely looking DEM with hillshade background terr <- terrain ( srtm , c ( "slope" , "aspect" ) ) hill <- shade ( terr [[ "slope" ] ] , terr [[ "aspect" ] ] ) ggR ( hill ) ggR ( hill ) + ggR ( srtm , geom_raster = TRUE , ggLayer = TRUE , alpha = 0.3 ) + scale_fill_gradientn ( colours = terrain.colors ( 100 ) , name = "elevation" )
+
+
+
+
Create ggplot2 Raster Plots with RGB from 3 RasterLayers — ggRGB • RStoolbox Skip to contents
+
+
+
+
+
+
+
+
+
Calculates RGB color composite raster for plotting with ggplot2. Optional values for clipping and and stretching can be used to enhance the imagery.
+
+
Usage
+
ggRGB ( img ,
+ r = 3 ,
+ g = 2 ,
+ b = 1 ,
+ scale ,
+ maxpixels = 5e+05 ,
+ stretch = "none" ,
+ ext = NULL ,
+ limits = NULL ,
+ clipValues = "limits" ,
+ quantiles = c ( 0.02 , 0.98 ) ,
+ ggObj = TRUE ,
+ ggLayer = FALSE ,
+ alpha = 1 ,
+ coord_equal = TRUE ,
+ geom_raster = FALSE ,
+ nullValue = 0
+)
+
+
Arguments
+
img
+SpatRaster
r
+Integer or character. Red layer in x. Can be set to NULL, in which case the red channel will be set to zero.
g
+Integer or character. Green layer in x. Can be set to NULL, in which case the green channel will be set to zero.
b
+Integer or character. Blue layer in x. Can be set to NULL, in which case the blue channel will be set to zero.
scale
+Numeric. Maximum possible pixel value (optional). Defaults to 255 or to the maximum value of x if that is larger than 255
maxpixels
+Integer. Maximal number of pixels used for plotting.
stretch
+Character. Either 'none', 'lin', 'hist', 'sqrt' or 'log' for no stretch, linear, histogram, square-root or logarithmic stretch.
ext
+Extent or SpatExtent object to crop the image
limits
+Vector or matrix. Can be used to reduce the range of values. Either a vector of two values for all bands (c(min, max))
+or a 3x2 matrix with min and max values (columns) for each layer (rows).
clipValues
+Matrix, numeric vector, string or NA. Values to reset out of range (out of limits) values to.
+By default ('limits') values are reset to limits. A single value (e.g. NA) will be recycled to all lower/higher clippings,
+A vector of length two (c(min,max)) can be used to specify lower and higher replace values, applied to all bands.
+A two column matrix (typically with three rows) can be used to fully control lower and upper clipping values differently for each band.
quantiles
+Numeric vector with two elements. Min and max quantiles to stretch. Defaults to 2% stretch, i.e. c(0.02,0.98).
ggObj
+Logical. If TRUE a ggplot2 object is returned. If FALSE a data.frame with coordinates and color will be returned.
ggLayer
+Logical. If TRUE a ggplot2 layer is returned. This is useful if you want to add it to an existing ggplot2 object.
+Note that if TRUE & annotate = FALSE you have to add a scale_fill_identity() manually in your call to ggplot().
alpha
+Numeric. Transparency (0-1).
coord_equal
+Logical. Force addition of coord_equal, i.e. aspect ratio of 1:1. Typically useful for remote sensing data (depending on your projection), hence it defaults to TRUE.
+Note howver, that this does not apply if (ggLayer=FALSE).
geom_raster
+Logical. If FALSE annotation_raster is used, otherwise geom_raster()+scale_fill_identity is used.
+Note that you can't use scale_fill* in addition to the latter, because it already requires scale_fill_identity().
nullValue
+Numeric. Intensity value used for NULL layers in color compositing. E.g. set g=NULL and fix green value at 0.5 (defaults to 0).
+
Value
+
+
+
ggObj = TRUE:ggplot2 plot ggLayer = TRUE:ggplot2 layer to be combined with an existing ggplot2 ggObj = FALSE:data.frame in long format suitable for plotting with ggplot2, includes the pixel values and the calculated colors
+
Details
+
Functionality is based on plotRGB
+
+
Examples
+
library ( ggplot2 ) ggRGB ( rlogo , r= 1 , g= 2 , b= 3 ) ## Define minMax ranges ggRGB ( rlogo , r= 1 ,g= 2 , b= 3 , limits = matrix ( c ( 100 ,150 ,10 ,200 ,50 ,255 ) , ncol = 2 , by = TRUE ) ) ## Perform stong linear contrast stretch ggRGB ( rlogo , r = 1 , g = 2 , b = 3 ,stretch = "lin" , quantiles = c ( 0.2 , 0.8 ) ) ## Use only two layers for color calculation ggRGB ( rlogo , r = 1 , g = 2 , b = NULL ) ## Return only data.frame df <- ggRGB ( rlogo , ggObj = FALSE ) head ( df ) #> x y fill#> 1 0.5 76.5 #FFFFFFFF#> 2 1.5 76.5 #FFFFFFFF#> 3 2.5 76.5 #FFFFFFFF#> 4 3.5 76.5 #FFFFFFFF#> 5 4.5 76.5 #FFFFFFFF#> 6 5.5 76.5 #FFFFFFFF## Use in layer-mode, e.g. to add to another plot wave <- data.frame ( x = c ( 0 , 0 : 100 ,100 ) , y = c ( 0 ,sin ( seq ( 0 ,2 * pi ,pi / 50 ) ) * 10 + 20 , 0 ) ) p <- ggplot ( wave , aes ( x , y ) ) p + ggRGB ( rlogo , ggLayer = TRUE ) + geom_polygon ( aes ( x , y ) , fill = "blue" , alpha = 0.4 ) + coord_equal ( ylim= c ( 0 ,75 ) )
+
+
+
+
Image to Image Contrast Matching — histMatch • RStoolbox Skip to contents
+
+
+
+
+
+
+
+
+
Performs image to image contrast adjustments based on histogram matching using empirical cumulative
+ distribution functions from both images.
+
+
Usage
+
histMatch ( x ,
+ ref ,
+ xmask = NULL ,
+ refmask = NULL ,
+ nSamples = 1e+05 ,
+ intersectOnly = TRUE ,
+ paired = TRUE ,
+ forceInteger = FALSE ,
+ returnFunctions = FALSE ,
+ ...
+)
+
+
Arguments
+
x
+SpatRaster. Source raster which is to be modified.
ref
+SpatRaster. Reference raster, to which x will be matched.
xmask
+RasterLayer or SpatRaster. Mask layer for x to exclude pixels which might distort the histogram, i.e. are not present in ref. Any NA pixel in xmask will be ignored (maskvalue = NA).
refmask
+RasterLayer or SpatRaster. Mask layer for ref. Any NA pixel in refmask will be ignored (maskvalue = NA).
nSamples
+Integer. Number of random samples from each image to build the histograms.
intersectOnly
+Logical. If TRUE sampling will only take place in the overlap extent of the two rasters. Otherwise the full rasters will be used for sampling.
paired
+Logical. If TRUE the corresponding pixels will be used in the overlap.
forceInteger
+Logical. Force integer output.
returnFunctions
+Logical. If TRUE the matching functions will be returned instead of applying them to x.
...
+Further arguments to be passed to writeRaster .
+
Value
+
+
+
A SpatRaster of x adjusted to the histogram of ref. If returnFunctions = TRUE a list of functions (one for each layer) will be returned instead.
+
+
Note
+
x and ref must have the same number of layers.
+
+
References
+
Richards and Jia: Remote Sensing Digital Image Analysis. Springer, Berlin, Heidelberg, Germany, 439pp.
+
+
Examples
+
library ( ggplot2 ) library ( terra ) ## Original image a (+1 to prevent log(0)) img_a <- rlogo + 1 ## Degraded image b img_b <- log ( img_a ) ## Cut-off half the image (just for better display) img_b [ , 1 : 50 ] <- NA ## Compare Images before histMatching ggRGB ( img_a ,1 ,2 ,3 ) + ggRGB ( img_b , 1 ,2 ,3 , ggLayer = TRUE , stretch = "lin" , q = 0 : 1 ) + geom_vline ( aes ( xintercept = 50 ) ) + ggtitle ( "Img_a vs. Img_b" ) #> Warning: data length [3927] is not a sub-multiple or multiple of the number of columns [101]## Do histogram matching img_b_matched <- histMatch ( img_b , img_a ) ## Compare Images after histMatching ggRGB ( img_a , 1 , 2 , 3 ) + ggRGB ( img_b_matched , 1 , 2 , 3 , ggLayer = TRUE , stretch = "lin" , q = 0 : 1 ) + geom_vline ( aes ( xintercept = 50 ) ) + ggtitle ( "Img_a vs. Img_b_matched" ) #> Warning: data length [3927] is not a sub-multiple or multiple of the number of columns [101]## Histogram comparison opar <- par ( mfrow = c ( 1 , 3 ) , no.readonly = TRUE ) img_a [ ,1 : 50 ] <- NA redLayers <- c ( img_a , img_b , img_b_matched ) [[ c ( 1 ,4 ,7 ) ] ] names ( redLayers ) <- c ( "img_a" , "img_b" , "img_b_matched" ) hist ( redLayers ) ## Reset par par ( opar )
+
+
+
+
Function reference • RStoolbox Skip to contents
+
+
+
+
+
+
+
+
+
All functions
+
+
+
+
+
+
+
+
+
+
+
+ ImageMetaData()
+ ImageMetaData Class
+
+
+ RStoolbox
+ RStoolbox: A Collection of Remote Sensing Tools
+
+
+ classifyQA()
+ Classify Landsat QA bands
+
+
+ cloudMask()
+ Simple Cloud Detection
+
+
+ cloudShadowMask()
+ Cloud Shadow Masking for Flat Terrain
+
+
+ coregisterImages()
+ Image to Image Co-Registration based on Mutual Information
+
+
+ decodeQA()
+ Decode QA flags to bit-words
+
+
+ encodeQA()
+ Encode QA Conditions to Integers
+
+
+ estimateHaze()
+ Estimate Image Haze for Dark Object Subtraction (DOS)
+
+
+ fCover()
+ Fractional Cover Analysis
+
+
+ fortifySpatRaster()
+ Fortify method for classes from the terra package.
+
+
+ getMeta()
+ Extract bandwise information from ImageMetaData
+
+
+ getValidation()
+ Extract validation results from superClass objects
+
+
+ ggR()
+ Plot RasterLayers in ggplot with greyscale
+
+
+ ggRGB()
+ Create ggplot2 Raster Plots with RGB from 3 RasterLayers
+
+
+ histMatch()
+ Image to Image Contrast Matching
+
+
+ lsat
+ Landsat 5TM Example Data
+
+
+ mesma()
+ Multiple Endmember Spectral Mixture Analysis (Spectral Unmixing)
+
+
+ normImage()
+ Normalize Raster Images: Center and Scale
+
+
+ oneHotEncode()
+ One-hot encode a raster or vector
+
+
+ panSharpen()
+ Pan Sharpen Imagery / Image Fusion
+
+
+ pifMatch()
+ Pseudo-Invariant Features based Image Matching
+
+
+ predict(<unsuperClass> )
+ Predict a raster map based on a unsuperClass model fit.
+
+
+ radCor()
+ Radiometric Calibration and Correction
+
+
+ rasterCVA()
+ Change Vector Analysis
+
+
+ rasterEntropy()
+ Multi-layer Pixel Entropy
+
+
+ rasterPCA()
+ Principal Component Analysis for Rasters
+
+
+ readEE()
+ Tidy import tool for EarthExplorer .csv export files
+
+
+ readMeta()
+ Read Landsat MTL metadata files
+
+
+ readSLI()
+ Read ENVI spectral libraries
+
+
+ rescaleImage()
+ Linear Image Rescaling
+
+
+ rlogo
+ Rlogo as SpatRaster
+
+
+ rsOpts()
+ Set global options for RStoolbox
+
+
+ sam()
+ Spectral Angle Mapper
+
+
+ saveRSTBX() readRSTBX()
+ Save and Read RStoolbox Classification Results
+
+
+ sen2
+ Sentinel 2 MSI L2A Scene
+
+
+ spectralIndices()
+ Spectral Indices
+
+
+ srtm
+ SRTM Digital Elevation Model
+
+
+ srtm_sen2
+ SRTM scene for the sen2 exemplary scene
+
+
+ stackMeta()
+ Import separate Landsat files into single stack
+
+
+ superClass()
+ Supervised Classification
+
+
+ tasseledCap()
+ Tasseled Cap Transformation
+
+
+ topCor()
+ Topographic Illumination Correction
+
+
+ unsuperClass()
+ Unsupervised Classification
+
+
+ validateMap()
+ Map accuracy assessment
+
+
+ writeSLI()
+ Write ENVI spectral libraries
+
+
+
+
Landsat 5TM Example Data — lsat • RStoolbox Skip to contents
+
+
+
+
+
+
+
+
+
Subset of Landsat 5 TM Scene: LT52240631988227CUB02
+Contains all seven bands in DN format.
+
+
Examples
+
ggRGB ( lsat , stretch = "sqrt" )
+
+
+
+
Multiple Endmember Spectral Mixture Analysis (Spectral Unmixing) — mesma • RStoolbox Skip to contents
+
+
+
+
+
+
+
+
+
mesma performs a spectral mixture anlylsis (SMA) or multiple endmember spectral mixture analysis (MESMA) on a multiband raster image.
+
+
Usage
+
mesma ( img ,
+ em ,
+ method = "NNLS" ,
+ iterate = 400 ,
+ tolerance = 1e-08 ,
+ n_models = 5 ,
+ sum_to_one = TRUE ,
+ ... ,
+ verbose
+)
+
+
Arguments
+
img
+SpatRaster. Remote sensing imagery (usually hyperspectral).
em
+Matrix or data.frame with spectral endmembers. Columns represent the spectral bands (i.e. columns correspond to number of bands in img). Rows represent either a single endmember per class (SMA) or multiple endmembers per class (MESMA), if a column with name class is present, containing the class name each endmember belongs to, e.g. "water" or "land". See details below. Number of rows needs to be > 1.
method
+Character. Select an unmixing method. Currently, only "NNLS" is implemented. Default is "NNLS".
iterate
+Integer. Set maximum iteration per pixel. Processing time could increase the more iterations are made possible. Default is 400.
tolerance
+Numeric. Tolerance limit representing a nearly zero minimal number. Default is 1e-8.
n_models
+Logical. Only applies if em contains column class. Defines how many endmember combinations should be picked. Maximum is the minimum number of endmembers of a class. Defaults to 5.
sum_to_one
+Logical. Defines whether a sum-to-one constraint should be applied so that probabilities of endmember classes sum to one (a constraint not covered by NNLS) to be interpretable as fractions. Defaults to TRUE. To get actual NNLS results, change to FALSE.
...
+further arguments passed to writeRaster .
verbose
+Logical. Prints progress messages during execution.
+
Value
+
+
+
SpatRaster. The object will contain one band per class, with each value representing the estimated probability of the respective endmember class per pixel, and an RMSE band. If sum_to_one is TRUE (default), values of the class bands can be interpreted as fractions per endmember class (0 to 1).
+
+
Details
+
Argument em determines whether an SMA (each row representing a single endmember per class) or a MESMA (multiple endmembers per class differentiate using the class column) is computed.
+If multiple endmembers per class are provided, mesma will compute a number of SMA (determined by argument n_models) for multiple endmember combinations drawn from em and will select the best fit per pixel based on the lowest RMSE, based on the MESMA approach proposed by Roberts et al. (1998).
+
+
Note
+
Depending on iterate and tolerance settings and the selected endmembers, the sum of estimated probabilities per pixel varies around 1. NNLS does not account for a sum-to-one constraint. Use sum_to_one to sum to one post-NNLS.
+
To achieve best results, it is recommended to adjust n_models in accordance to the number of endemembers per class provided through em so that as many endmember combinations as possible (with each endmember being used once) are computed. The more models are being calculated, the more processing and memory recourses are needed.
+
+
References
+
Franc, V., Hlaváč, V., & Navara, M. (2005). Sequential coordinate-wise algorithm for the non-negative least squares problem. In: International Conference on Computer Analysis of Images and Patterns (pp. 407-414). Berlin, Heidelberg.
+
Roberts, D. A., Gardner, M., Church, R., Ustin, S., Scheer, G., & Green, R. O. (1998). Mapping chaparral in the Santa Monica Mountains using multiple endmember spectral mixture models. Remote sensing of environment, 65(3), 267-279.
+
+
Author
+
Jakob Schwalb-Willmann
+
+
Examples
+
library ( RStoolbox ) library ( terra ) # to perform a SMA, use a single endmember per class, row by row: em <- data.frame ( lsat [ c ( 5294 , 47916 ) ] ) rownames ( em ) <- c ( "forest" , "water" ) # umix the lsat image probs <- mesma ( img = lsat , em = em ) plot ( probs ) # to perform a MESMA, use multiple endmembers per class, differntiating them # by a column named 'class': em <- rbind ( data.frame ( lsat [ c ( 4155 , 17018 , 53134 , 69487 , 83704 ) ] , class = "forest" ) , data.frame ( lsat [ c ( 22742 , 25946 , 38617 , 59632 , 67313 ) ] , class = "water" ) ) # unmix the lsat image probs <- mesma ( img = lsat , em = em ) plot ( probs ) # MESMA can also be performed on more than two endmember classes: em <- rbind ( data.frame ( lsat [ c ( 4155 , 17018 , 53134 , 69487 , 83704 ) ] , class = "forest" ) , data.frame ( lsat [ c ( 22742 , 25946 , 38617 , 59632 , 67313 ) ] , class = "water" ) , data.frame ( lsat [ c ( 4330 , 1762 , 1278 , 1357 , 17414 ) ] , class = "shortgrown" ) ) # unmix the lsat image probs <- mesma ( img = lsat , em = em ) plot ( probs )
+
+
+
+
Normalize Raster Images: Center and Scale — normImage • RStoolbox Skip to contents
+
+
+
+
+
+
+
+
+
For each pixel subtracts the mean of the raster layer and optionally divide by its standard deviation.
+
+
Usage
+
normImage ( img , norm = TRUE , ... )
+
+
Arguments
+
img
+SpatRaster. Image to transform. Transformation will be performed separately for each layer.
norm
+Logical. Perform normalization (scaling) in addition to centering, i.e. divide by standard deviation.
...
+further arguments passed to writeRaster .
+
Value
+
+
+
Returns a SpatRaster with the same number layers as input layers with each layer being centered and optionally normalized.
+
+
Examples
+
library ( terra ) ## Load example data ## Normalization: Center and Scale rlogo_center_norm <- normImage ( rlogo ) hist ( rlogo_center_norm ) ## Centering rlogo_center <- normImage ( rlogo , norm = FALSE )
+
+
+
+
One-hot encode a raster or vector — oneHotEncode • RStoolbox Skip to contents
+
+
+
+
+
+
+
+
+
Splits a categorical raster layer (or a vector) into a multilayer raster (or matrix).
+
+
Usage
+
oneHotEncode ( img , classes , background = 0 , foreground = 1 , na.rm = FALSE , ... )
+
+
Arguments
+
img
+SpatRaster or integer/numeric vector containing multiple classes
classes
+integer: vector of classes which should be extracted
background
+integer: background value (default = 0)
foreground
+integer: foreground value (default = 1)
na.rm
+logical: if TRUE, NAs will be coerced to the background value.
...
+further arguments passed to writeRaster . Ignored if img is not a SpatRaster, but a numeric/integer vector or matrix
+
Value
+
+
+
A SpatRaster with as many layers as there are classes.
+Pixels matching the class of interest are set to 1, backround values by default are set to 0 (see background argument)
+
+
Examples
+
# \donttest{ sc <- unsuperClass ( rlogo , nClasses = 3 ) ## one-hot encode sc_oneHot <- oneHotEncode ( sc $ map , classes = c ( 1 ,2 ,3 ) ) ## check results sc_oneHot #> class : SpatRaster #> dimensions : 77, 101, 3 (nrow, ncol, nlyr)#> resolution : 1, 1 (x, y)#> extent : 0, 101, 0, 77 (xmin, xmax, ymin, ymax)#> coord. ref. : +proj=merc +lon_0=0 +k=1 +x_0=0 +y_0=0 +ellps=WGS84 +towgs84=0,0,0,0,0,0,0 +units=m +no_defs #> source(s) : memory#> names : c_1, c_2, c_3 #> min values : 0, 0, 0 #> max values : 1, 1, 1 # }
+
+
+
+
Pan Sharpen Imagery / Image Fusion — panSharpen • RStoolbox Skip to contents
+
+
+
+
+
+
+
+
+
provides different methods for pan sharpening a coarse resolution (typically multispectral) image with
+a higher reolution panchromatic image. Values of the pan-chromatic and multispectral images must be of the same scale, (e.g. from 0:1, or all DNs from 0:255)
+
+
Usage
+
panSharpen ( img , pan , r , g , b , pc = 1 , method = "brovey" , norm = TRUE )
+
+
Arguments
+
img
+SpatRaster. Coarse resolution multispectral image
pan
+SpatRaster. High resolution image, typically panchromatic.
r
+Character or Integer. Red band in img. Only relevant if method!='pca'
g
+Character or Integer. Green band in img. Only relevant if method!='pca'
b
+Character or Integer. Blue band in img. Only relevant if method!='pca'
pc
+Integer. Only relevant if method = 'pca'. Which principal component to replace. Usually this should be the first component (default). Only if the first component is dominated by something else than brightness it might be worth a try to use the second component.
method
+Character. Choose method from c("pca", "ihs", "brovey").
norm
+Logical. Rescale pan image to match the 1st PC component. Only relevant if method = 'pca'. If TRUE only min and max are matched to the 1st PC. If FALSE pan will be histogram matched to the 1st PC.
+
Value
+
+
+
pan-sharpened SpatRaster
+
+
Details
+
Pan sharpening options:
method='pca': Performs a pca using rasterPCA . The first component is then swapped for the pan band an the PCA is rotated backwards.
method='ihs': Performs a color space transform to Intensity-Hue-Saturation space, swaps intensity for the histogram matched pan and does the backwards transformation.
method='brovey': Performs Brovey reweighting. Pan and img must be at the same value scale (e.g. 0:1, or 0:255) otherwise you'll end up with psychodelic colors.
+
Examples
+
library ( terra ) library ( ggplot2 ) ## Fake panchromatic image (30m resolution covering ## the visible range (integral from blue to red)) pan <- sum ( lsat [[ 1 : 3 ] ] ) ggR ( pan , stretch = "lin" ) ## Fake coarse resolution image (150m spatial resolution) lowResImg <- aggregate ( lsat , 5 ) ## Brovey pan sharpening lowResImg_pan <- panSharpen ( lowResImg , pan , r = 3 , g = 2 , b = 1 , method = "brovey" ) lowResImg_pan #> class : SpatRaster #> dimensions : 310, 287, 3 (nrow, ncol, nlyr)#> resolution : 30, 30 (x, y)#> extent : 619395, 628005, -419505, -410205 (xmin, xmax, ymin, ymax)#> coord. ref. : +proj=utm +zone=22 +ellps=WGS84 +towgs84=0,0,0,0,0,0,0 +units=m +no_defs #> source(s) : memory#> names : B1_dn_pan, B2_dn_pan, B3_dn_pan #> min values : 47.20757, 18.43627, 11.80072 #> max values : 191.12757, 87.47762, 85.39481 ## Plot ggRGB ( lowResImg , stretch = "lin" ) + ggtitle ( "Original" ) #> Warning: data length [3534] is not a sub-multiple or multiple of the number of columns [58]ggRGB ( lowResImg_pan , stretch= "lin" ) + ggtitle ( "Pansharpened (Brovey)" ) #> Warning: data length [88350] is not a sub-multiple or multiple of the number of columns [287]
+
+
+
+
Pseudo-Invariant Features based Image Matching — pifMatch • RStoolbox Skip to contents
+
+
+
+
+
+
+
+
+
Match one scene to another based on linear regression of pseudo-invariant features (PIF).
+
+
Usage
+
pifMatch ( img ,
+ ref ,
+ method = "cor" ,
+ quantile = 0.95 ,
+ returnPifMap = TRUE ,
+ returnSimMap = TRUE ,
+ returnModels = FALSE
+)
+
+
Arguments
+
img
+SpatRaster. Image to be adjusted.
ref
+SpatRaster. Reference image.
method
+Method to calculate pixel similarity. Options: euclidean distance ('ed'), spectral angle ('sam') or pearson correlation coefficient ('cor').
quantile
+Numeric. Threshold quantile used to identify PIFs
returnPifMap
+Logical. Return a binary raster map ot pixels which were identified as pesudo-invariant features.
returnSimMap
+Logical. Return the similarity map as well
returnModels
+Logical. Return the linear models along with the adjusted image.
+
Value
+
+
+
Returns a List with the adjusted image and intermediate products (if requested).
img: the adjusted image
simMap: pixel-wise similarity map (if returnSimMap = TRUE)
pifMap: binary map of pixels selected as pseudo-invariant features (if returnPifMap = TRUE)
models: list of linear models; one per layer (if returnModels = TRUE)
+
Details
+
The function consists of three main steps:
+First, it calculates pixel-wise similarity between the two rasters and identifies pseudo-invariant pixels based on
+a similarity threshold.
+In the second step the values of the pseudo-invariant pixels are regressed against each other in a linear model for each layer.
+Finally the linear models are applied to all pixels in the img, thereby matching it to the reference scene.
+
Pixel-wise similarity can be calculated using one of three methods: euclidean distance (method = "ed"), spectral angle ("sam") or pearsons correlation coefficient ("cor").
+The threshold is defined as a similarity quantile. Setting quantile=0.95 will select all pixels with a similarity above the 95% quantile as pseudo-invariant features.
+
Model fitting is performed with simple linear models (lm
+
+
Examples
+
library ( terra ) ## Create fake example data ## In practice this would be an image from another acquisition date lsat_b <- log ( lsat ) ## Run pifMatch and return similarity layer, invariant features mask and models lsat_b_adj <- pifMatch ( lsat_b , lsat , returnPifMap = TRUE , returnSimMap = TRUE , returnModels = TRUE ) # \donttest{ ## Pixelwise similarity ggR ( lsat_b_adj $ simMap , geom_raster = TRUE ) ## Pesudo invariant feature mask ggR ( lsat_b_adj $ pifMap ) ## Histograms of changes par ( mfrow= c ( 1 ,3 ) ) hist ( lsat_b [[ 1 ] ] , main = "lsat_b" ) hist ( lsat [[ 1 ] ] , main = "reference" ) hist ( lsat_b_adj $ img [[ 1 ] ] , main = "lsat_b adjusted" ) ## Model summary for first band summary ( lsat_b_adj $ models [[ 1 ] ] ) #> #> Call:#> lm(formula = ref ~ img, data = df)#> #> Residuals:#> Min 1Q Median 3Q Max #> -3.3904 -0.6021 0.0163 0.7107 24.6845 #> #> Coefficients:#> Estimate Std. Error t value Pr(>|t|) #> (Intercept) -324.9027 0.9321 -348.6 <2e-16 ***#> img 92.9473 0.2184 425.5 <2e-16 ***#> ---#> Signif. codes: 0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1#> #> Residual standard error: 1.373 on 4447 degrees of freedom#> Multiple R-squared: 0.976, Adjusted R-squared: 0.976 #> F-statistic: 1.811e+05 on 1 and 4447 DF, p-value: < 2.2e-16#> # }
+
+
+
+
Pipe operator — %>% • RStoolbox Skip to contents
+
+
+
+
+
+
+
+
+
See magrittr::%>% for details.
+
+
Arguments
+
lhs
+A value or the magrittr placeholder.
rhs
+A function call using the magrittr semantics.
+
Value
+
+
+
The result of calling `rhs(lhs)`.
+
+
+
+
Predict a raster map based on a unsuperClass model fit. — predict.unsuperClass • RStoolbox Skip to contents
+
+
+
+
+
+
+
+
+
applies a kmeans cluster model to all pixels of a raster.
+Useful if you want to apply a kmeans model of scene A to scene B.
+
+
Usage
+
# S3 method for unsuperClass predict ( object , img , output = "classes" , ... )
+
+
Arguments
+
object
+unsuperClass object
img
+Raster object. Layernames must correspond to layernames used to train the superClass model, i.e. layernames in the original raster image.
output
+Character. Either 'classes' (kmeans class; default) or 'distances' (euclidean distance to each cluster center).
...
+further arguments to be passed to writeRaster , e.g. filename
+
Value
+
+
+
Returns a raster with the K-means distances base on your object passed in the arguments.
+
+
Examples
+
## Load training data ## Perform unsupervised classification uc <- unsuperClass ( rlogo , nClasses = 10 ) ## Apply the model to another raster map <- predict ( uc , rlogo )
+
+
+
+
Radiometric Calibration and Correction — radCor • RStoolbox Skip to contents
+
+
+
+
+
+
+
+
+
Implements several different methods for radiometric calibration and correction of Landsat data.
+You can either specify a metadata file, or supply all neccesary values manually.
+With proper parametrization apref and sdos should work for other sensors as well.
+
+
Usage
+
radCor ( img ,
+ metaData ,
+ method = "apref" ,
+ bandSet = "full" ,
+ hazeValues ,
+ hazeBands ,
+ atmosphere ,
+ darkProp = 0.01 ,
+ clamp = TRUE ,
+ verbose
+)
+
+
Arguments
+
img
+SpatRaster
metaData
+object of class ImageMetaData or a path to the meta data (MTL) file.
method
+Radiometric conversion/correction method to be used. There are currently four methods available (see Details):
+"rad", "apref", "sdos", "dos", "costz".
bandSet
+Numeric or character. original Landsat band numbers or names in the form of ("B1", "B2" etc). If set to 'full' all bands in the solar (optical) region will be processed.
hazeValues
+Numeric. Either a vector with dark DNs per hazeBand (method = 'sdos'); possibly estimated using estimateHaze .
+Or the 'starting haze value' (DN) for the relative scattering models in method = 'dos' or 'costz'. If not provided, hazeValues will be estimated in an automated fashion for all hazeBands.
+Argument only applies to methods 'sdos', 'dos' and 'costz'.
hazeBands
+Character or integer. Bands corresponding to hazeValues (method = 'sdos') or band to select starting haze value from ('dos' or 'costz').
atmosphere
+Character. Atmospheric characteristics. Will be estimated if not expicilty provided. Must be one of "veryClear", "clear", "moderate", "hazy" or "veryHazy".
darkProp
+Numeric. Estimated proportion of dark pixels in the scene. Used only for automatic guessing of hazeValues (typically one would choose 1 or 2%).
clamp
+Logical. Enforce valid value range. By default reflectance will be forced to stay within [0,1] and radiance >= 0 by replacing invalid values with the correspinding boundary, e.g. -0.1 will become 0.
verbose
+Logical. Print status information.
+
Value
+
+
+
SpatRaster with top-of-atmosphere radiance (\(W/(m^2 * srad * \mu m)\)), at-satellite brightness temperature (K),
+top-of-atmosphere reflectance (unitless) corrected for the sun angle or at-surface reflectance (unitless).
+
+
Details
+
The atmospheric correction methods (sdos, dos and costz) apply to the optical (solar) region of the spectrum and do not affect the thermal band.
+
Dark object subtraction approaches rely on the estimation of atmospheric haze based on *dark* pixels. Dark pixels are assumed to have zero reflectance, hence the name.
+It is then assumed further that any radiation originating from such *dark* pixels is due to atmospheric haze and
+not the reflectance of the surface itself.
+
The folloiwing methods are available:
rad Radiance apref Apparent reflectance (top-of-atmosphere reflectance) dos Dark object subtratction following Chavez (1989) costz Dark object subtraction following Chavez (1996) sdos Simple dark object subtraction. Classical DOS, Lhaze must be estimated for each band separately.
If either "dos" or "costz" are selected, radCor will use the atmospheric haze decay model described by Chavez (1989).
+Depending on the atmosphere the following coefficients are used:
veryClear \(\lambda^{-4.0}\) clear \(\lambda^{-2.0}\) moderate \(\lambda^{-1.0}\) hazy \(\lambda^{-0.7}\) veryHazy \(\lambda^{-0.5}\)
For Landsat 8, no values for extra-terrestrial irradiation (esun) are provided by NASA. These are, however, neccessary for DOS-based approaches.
+Therefore, these values were derived from a standard reference spectrum published by Thuillier et al. (2003) using the Landsat 8 OLI spectral response functions
+(for details, see http://bleutner.github.io/RStoolbox/r/2016/01/26/estimating-landsat-8-esun-values ).
+
The implemented sun-earth distances neglect the earth's eccentricity. Instead we use a 100 year daily average (1979-2070).
+
+
Note
+
This was originally a fork of randcorr() function in the landsat package. This version works on SpatRasters and hence is suitable for large rasters.
+
+
References
+
S. Goslee (2011): Analyzing Remote Sensing Data in R: The landsat Package. Journal of Statistical Software 43(4).
+
G. Thuillier et al. (2003) THE SOLAR SPECTRAL IRRADIANCE FROM 200 TO 2400 nm AS MEASURED BY THE SOLSPEC SPECTROMETER FROM THE ATLAS AND EURECA MISSIONS. Solar Physics 214(1): 1-22 (
+
+
Examples
+
library ( terra ) ## Import meta-data and bands based on MTL file mtlFile <- system.file ( "external/landsat/LT52240631988227CUB02_MTL.txt" , package= "RStoolbox" ) metaData <- readMeta ( mtlFile ) lsat_t <- stackMeta ( mtlFile ) ## Convert DN to top of atmosphere reflectance and brightness temperature lsat_ref <- radCor ( lsat_t , metaData = metaData , method = "apref" ) ## Correct DN to at-surface-reflecatance with DOS (Chavez decay model) lsat_sref <- radCor ( lsat_t , metaData = metaData ) ## Correct DN to at-surface-reflecatance with simple DOS ## Automatic haze estimation hazeDN <- estimateHaze ( lsat_t , hazeBands = 1 : 4 , darkProp = 0.01 , plot = FALSE ) lsat_sref <- radCor ( lsat_t , metaData = metaData , method = "sdos" , hazeValues = hazeDN , hazeBands = 1 : 4 )
+
+
+
+
Change Vector Analysis — rasterCVA • RStoolbox Skip to contents
+
+
+
+
+
+
+
+
+
Calculates angle and magnitude of change vectors.
+Dimensionality is limited to two bands per image.
+
+
Usage
+
rasterCVA ( x , y , tmf = NULL , nct = NULL , ... )
+
+
Arguments
+
x
+SpatRaster with two layers. This will be the reference/origin for the change calculations. Both rasters (y and y) need to correspond to each other, i.e. same resolution, extent and origin.
y
+SpatRaster with two layers. Both rasters (y and y) need to correspond to each other, i.e. same resolution, extent and origin.
tmf
+Numeric. Threshold median factor (optional). Used to calculate a threshold magnitude for which pixels are considered stable, i.e. no change. Calculated as tmf * mean(magnitude[magnitude > 0]).
nct
+Numeric. No-change threshold (optional). Alternative to tmf. Sets an absolute threshold. Change magnitudes below nct are considered stable and set to NA.
...
+further arguments passed to writeRaster
+
Value
+
+
+
Returns a SpatRaster with two layers: change vector angle and change vector magnitude
+
+
Details
+
Change Vector Analysis (CVA) is used to identify spectral changes between two identical scenes which were acquired at different times.
+CVA is limited to two bands per image. For each pixel it calculates the change vector in the two-dimensional spectral space.
+For example for a given pixel in image A and B for the red and nir band the change vector is calculated for the coordinate pairs: (red_A | nir_A) and (red_B | nir_B).
+
The coordinate system is defined by the order of the input bands: the first band defines the x-axis and the second band the y-axis, respectively.
+ Angles are returned *in degree* beginning with 0 degrees pointing 'north', i.e. the y-axis, i.e. the second band.
+
+
Examples
+
library ( terra ) pca <- rasterPCA ( lsat ) $ map ## Do change vector analysis cva <- rasterCVA ( pca [[ 1 : 2 ] ] , pca [[ 3 : 4 ] ] ) cva #> class : SpatRaster #> dimensions : 310, 287, 2 (nrow, ncol, nlyr)#> resolution : 30, 30 (x, y)#> extent : 619395, 628005, -419505, -410205 (xmin, xmax, ymin, ymax)#> coord. ref. : +proj=utm +zone=22 +ellps=WGS84 +towgs84=0,0,0,0,0,0,0 +units=m +no_defs #> source(s) : memory#> names : angle, magnitude #> min values : 5.423571e-03, 0.1009387 #> max values : 3.599993e+02, 106.5000918
+
+
+
+
Multi-layer Pixel Entropy — rasterEntropy • RStoolbox Skip to contents
+
+
+
+
+
+
+
+
+
Shannon entropy is calculated for each pixel based on it's layer values.
+To be used with categorical / integer valued rasters.
+
+
Arguments
+
img
+SpatRaster
...
+additional arguments passed to writeRaster
+
Value
+
+
+
SpatRaster "entropy"
+
+
Details
+
Entropy is calculated as -sum(p log(p)); p being the class frequency per pixel.
+
+
Examples
+
re <- rasterEntropy ( rlogo ) ggR ( re , geom_raster = TRUE )
+
+
+
+
Principal Component Analysis for Rasters — rasterPCA • RStoolbox Skip to contents
+
+
+
+
+
+
+
+
+
Calculates R-mode PCA for SpatRasters and returns a SpatRaster with multiple layers of PCA scores.
+
+
Usage
+
rasterPCA ( img ,
+ nSamples = NULL ,
+ nComp = nlyr ( img ) ,
+ spca = FALSE ,
+ maskCheck = TRUE ,
+ ...
+)
+
+
Arguments
+
img
+SpatRaster.
nSamples
+Integer or NULL. Number of pixels to sample for PCA fitting. If NULL, all pixels will be used.
nComp
+Integer. Number of PCA components to return.
spca
+Logical. If TRUE, perform standardized PCA. Corresponds to centered and scaled input image. This is usually beneficial for equal weighting of all layers. (FALSE by default)
maskCheck
+Logical. Masks all pixels which have at least one NA (default TRUE is reccomended but introduces a slow-down, see Details when it is wise to disable maskCheck).
+Takes effect only if nSamples is NULL.
...
+further arguments to be passed to writeRaster , e.g. filename.
+
Value
+
+
+
Returns a named list containing the PCA model object ($model) and a SpatRaster with the principal component layers ($object).
+
+
Details
+
Internally rasterPCA relies on the use of princomp (R-mode PCA). If nSamples is given the PCA will be calculated
+based on a random sample of pixels and then predicted for the full raster. If nSamples is NULL then the covariance matrix will be calculated
+first and will then be used to calculate princomp and predict the full raster. The latter is more precise, since it considers all pixels,
+however, it may be slower than calculating the PCA only on a subset of pixels.
+
Pixels with missing values in one or more bands will be set to NA. The built-in check for such pixels can lead to a slow-down of rasterPCA.
+However, if you make sure or know beforehand that all pixels have either only valid values or only NAs throughout all layers you can disable this check
+by setting maskCheck=FALSE which speeds up the computation.
+
Standardised PCA (SPCA) can be useful if imagery or bands of different dynamic ranges are combined. SPC uses the correlation matrix instead of the covariance matrix, which
+has the same effect as using normalised bands of unit variance.
+
+
Examples
+
library ( ggplot2 ) library ( reshape2 ) ggRGB ( rlogo , 1 ,2 ,3 ) ## Run PCA set.seed ( 25 ) rpc <- rasterPCA ( rlogo ) rpc #> $call#> rasterPCA(img = rlogo)#> #> $model#> Call:#> princomp(cor = spca, covmat = covMat)#> #> Standard deviations:#> Comp.1 Comp.2 Comp.3 #> 124.814772 17.084151 1.456423 #> #> 3 variables and 7777 observations.#> #> $map#> class : SpatRaster #> dimensions : 77, 101, 3 (nrow, ncol, nlyr)#> resolution : 1, 1 (x, y)#> extent : 0, 101, 0, 77 (xmin, xmax, ymin, ymax)#> coord. ref. : +proj=merc +lon_0=0 +k=1 +x_0=0 +y_0=0 +ellps=WGS84 +towgs84=0,0,0,0,0,0,0 +units=m +no_defs #> source(s) : memory#> names : PC1, PC2, PC3 #> min values : -323.1956, -46.42416, -9.374094 #> max values : 118.2781, 26.11958, 6.362937 #> #> attr(,"class")#> [1] "rasterPCA" "RStoolbox"## Model parameters: summary ( rpc $ model ) #> Importance of components:#> Comp.1 Comp.2 Comp.3#> Standard deviation 124.8147718 17.08415063 1.456422555#> Proportion of Variance 0.9814783 0.01838804 0.000133636#> Cumulative Proportion 0.9814783 0.99986636 1.000000000loadings ( rpc $ model ) #> #> Loadings:#> Comp.1 Comp.2 Comp.3#> red 0.594 0.507 0.625#> green 0.585 0.262 -0.768#> blue 0.553 -0.821 0.141#> #> Comp.1 Comp.2 Comp.3#> SS loadings 1.000 1.000 1.000#> Proportion Var 0.333 0.333 0.333#> Cumulative Var 0.333 0.667 1.000ggRGB ( rpc $ map ,1 ,2 ,3 , stretch= "lin" , q= 0 ) if ( require ( gridExtra ) ) { plots <- lapply ( 1 : 3 , function ( x ) ggR ( rpc $ map , x , geom_raster = TRUE ) ) grid.arrange ( plots [[ 1 ] ] ,plots [[ 2 ] ] , plots [[ 3 ] ] , ncol= 2 ) } #> Loading required package: gridExtra
+
+
+
+
Tidy import tool for EarthExplorer .csv export files — readEE • RStoolbox Skip to contents
+
+
+
+
+
+
+
+
+
Imports and tidies CSV files exported from EarthExplorer into data.frames and annotates missing fields.
+
+
Arguments
+
x
+Character, Character or list. One or more paths to EarthExplorer export files.
+
Value
+
+
+
data.frame
+
+
Details
+
The EarthExplorer CSV file can be produced from the search results page. Above the results click on 'export results' and select 'comma (,) delimited'.
+
Note that only a subset of columns is imported which was deemed interesting. Please contact the maintainer if you think an omited column should be included.
+
+
Examples
+
library ( ggplot2 ) ee <- readEE ( system.file ( "external/EarthExplorer_LS8.txt" , package = "RStoolbox" ) ) ## Scenes with cloud cover < 20% ee [ ee $ Cloud.Cover < 20 ,] #> Landsat.Scene.Identifier WRS.Path WRS.Row Data.Category Cloud.Cover#> 6 LC82240632015157LGN00 224 63 NOMINAL 13.20#> 27 LC82240632014186LGN00 224 63 NOMINAL 15.94#> 40 LC82240632013327LGN00 224 63 NOMINAL 13.19#> 46 LC82240632013215LGN00 224 63 NOMINAL 14.72#> 49 LC82240632013167LGN00 224 63 NOMINAL 6.35#> Station.Identifier Day.Night Data.Type.Level.1 Date.Acquired Sun.Elevation#> 6 LGN DAY L1T 2015/06/06 51.98871#> 27 LGN DAY L1T 2014/07/05 51.01591#> 40 LGN DAY L1GT 2013/11/23 61.83434#> 46 LGN DAY L1T 2013/08/03 54.43226#> 49 LGN DAY L1T 2013/06/16 51.64735#> Sun.Azimuth Geometric.RMSE.Model.X Geometric.RMSE.Model.Y#> 6 43.59274 6.244 5.663#> 27 44.79093 5.452 5.420#> 40 126.95937 0.000 0.000#> 46 51.68815 5.631 5.840#> 49 42.59918 6.377 5.862#> Display.ID Ordering.ID#> 6 LC82240632015157LGN00 LC82240632015157LGN00#> 27 LC82240632014186LGN00 LC82240632014186LGN00#> 40 LC82240632013327LGN00 LC82240632013327LGN00#> 46 LC82240632013215LGN00 LC82240632013215LGN00#> 49 LC82240632013167LGN00 LC82240632013167LGN00#> Download.Link#> 6 http://earthexplorer.usgs.gov/download/options/4923/LC82240632015157LGN00#> 27 http://earthexplorer.usgs.gov/download/options/4923/LC82240632014186LGN00#> 40 http://earthexplorer.usgs.gov/download/options/4923/LC82240632013327LGN00#> 46 http://earthexplorer.usgs.gov/download/options/4923/LC82240632013215LGN00#> 49 http://earthexplorer.usgs.gov/download/options/4923/LC82240632013167LGN00#> Browse.Link Date Doy Year Satellite Num#> 6 NA 2015-06-06 157 2015 LS8 8#> 27 NA 2014-07-05 186 2014 LS8 8#> 40 NA 2013-11-23 327 2013 LS8 8#> 46 NA 2013-08-03 215 2013 LS8 8#> 49 NA 2013-06-16 167 2013 LS8 8## Available time-series ggplot ( ee ) + geom_segment ( aes ( x = Date , xend = Date , y = 0 , yend = 100 - Cloud.Cover , col = as.factor ( Year ) ) ) + scale_y_continuous ( name = "Scene quality (% clear sky)" )
+
+
+
+
Read Landsat MTL metadata files — readMeta • RStoolbox Skip to contents
+
+
+
+
+
+
+
+
+
Reads metadata and deals with legacy versions of Landsat metadata files and where possible adds missing information (radiometric gain and offset, earth-sun distance).
+
+
Usage
+
readMeta ( file , raw = FALSE )
+
+
Arguments
+
file
+path to Landsat MTL file (...MTL.txt)
raw
+Logical. If TRUE the full raw metadata will be returned as a list. if FALSE (the default) all important metadata are homogenized into a standard format (ImageMetaData) and some information is added.
+
Value
+
+
+
Object of class ImageMetaData
+
+
Examples
+
## Example metadata file (MTL) mtlFile <- system.file ( "external/landsat/LT52240631988227CUB02_MTL.txt" , package= "RStoolbox" ) ## Read metadata metaData <- readMeta ( mtlFile ) ## Summary summary ( metaData ) #> Scene: LT52240631988227CUB02 #> Satellite: LANDSAT5 #> Sensor: TM #> Date: 1988-08-14 #> Path/Row: 224/63 #> Projection: +proj=utm +zone=22 +units=m +datum=WGS84 +ellips=WGS84 #> Scene: PROJCRS["unknown",#> BASEGEOGCRS["unknown",#> DATUM["World Geodetic System 1984",#> ELLIPSOID["WGS 84",6378137,298.257223563,#> LENGTHUNIT["metre",1]],#> ID["EPSG",6326]],#> PRIMEM["Greenwich",0,#> ANGLEUNIT["degree",0.0174532925199433],#> ID["EPSG",8901]]],#> CONVERSION["UTM zone 22N",#> METHOD["Transverse Mercator",#> ID["EPSG",9807]],#> PARAMETER["Latitude of natural origin",0,#> ANGLEUNIT["degree",0.0174532925199433],#> ID["EPSG",8801]],#> PARAMETER["Longitude of natural origin",-51,#> ANGLEUNIT["degree",0.0174532925199433],#> ID["EPSG",8802]],#> PARAMETER["Scale factor at natural origin",0.9996,#> SCALEUNIT["unity",1],#> ID["EPSG",8805]],#> PARAMETER["False easting",500000,#> LENGTHUNIT["metre",1],#> ID["EPSG",8806]],#> PARAMETER["False northing",0,#> LENGTHUNIT["metre",1],#> ID["EPSG",8807]],#> ID["EPSG",16022]],#> CS[Cartesian,2],#> AXIS["(E)",east,#> ORDER[1],#> LENGTHUNIT["metre",1,#> ID["EPSG",9001]]],#> AXIS["(N)",north,#> ORDER[2],#> LENGTHUNIT["metre",1,#> ID["EPSG",9001]]]]#> #> Data:#> FILES QUANTITY CATEGORY#> B1_dn LT52240631988227CUB02_B1.TIF dn image#> B2_dn LT52240631988227CUB02_B2.TIF dn image#> B3_dn LT52240631988227CUB02_B3.TIF dn image#> B4_dn LT52240631988227CUB02_B4.TIF dn image#> B5_dn LT52240631988227CUB02_B5.TIF dn image#> B6_dn LT52240631988227CUB02_B6.TIF dn image#> B7_dn LT52240631988227CUB02_B7.TIF dn image#> #> Available calibration parameters (gain and offset):#> dn -> radiance (toa)#> dn -> brightness temperature (toa)#>
+
+
+
+
Read ENVI spectral libraries — readSLI • RStoolbox Skip to contents
+
+
+
+
+
+
+
+
+
read/write support for ENVI spectral libraries
+
+
Arguments
+
path
+Path to spectral library file with ending .sli.
+
Value
+
+
+
The spectral libraries are read into a data.frame. The first column contains the wavelengths and the remaining columns contain the spectra.
+
+
Details
+
ENVI spectral libraries consist of a binary data file (.sli) and a corresponding header (.hdr, or .sli.hdr) file.
+
+
Examples
+
## Example data sliFile <- system.file ( "external/vegSpec.sli" , package= "RStoolbox" ) sliTmpFile <- paste0 ( tempdir ( ) ,"/vegetationSpectra.sli" ) ## Read spectral library sli <- readSLI ( sliFile ) head ( sli ) #> wavelength veg_stressed veg_vital#> 1 350 0.008958003 0.008836994#> 2 351 0.008910760 0.008909440#> 3 352 0.008874181 0.008972186#> 4 353 0.008847097 0.009025744#> 5 354 0.008829174 0.009071405#> 6 355 0.008819440 0.009109739plot ( sli [ ,1 : 2 ] , col = "orange" , type = "l" ) lines ( sli [ ,c ( 1 ,3 ) ] , col = "green" ) ## Write to binary spectral library writeSLI ( sli , path = sliTmpFile )
+
+
+
+
Linear Image Rescaling — rescaleImage • RStoolbox Skip to contents
+
+
+
+
+
+
+
+
+
performs linear shifts of value ranges either to match min/max of another image (y)
+or to any other min and max value (ymin and ymax).
+
+
Usage
+
rescaleImage ( x , y , xmin , xmax , ymin , ymax , forceMinMax = FALSE , ... )
+
+
Arguments
+
x
+SpatRaster or numeric vector. Image to normalise.
y
+SpatRaster or numeric vector. Reference image. Optional. Used to extract min and max values if ymin or ymax are missing.
xmin
+Numeric. Min value of x. Either a single value or one value per layer in x. If xmin is not provided it will be extracted from x.
xmax
+Numeric. Max value of x. Either a single value or one value per layer in x. If xmax is not provided it will be extracted from x.
ymin
+Numeric. Min value of y. Either a single value or one value per layer in x. If ymin is not provided it will be extracted from y.
ymax
+Numeric. Max value of y. Either a single value or one value per layer in x. If ymax is not provided it will be extracted from y.
forceMinMax
+Logical. Forces update of min and max data slots in x or y.
...
+additional arguments passed to terra::writeRaster()
+
Value
+
+
+
Returns a SpatRaster of the same dimensions as the input raster x but shifted and stretched to the new limits.
+
+
Details
+
Providing xmin and xmax values manually can be useful if the raster contains a variable of a known, fixed value range,
+e.g. NDVI from -1 to 1 but the actual pixel values don't encompass this entire range.
+By providing xmin = -1 and xmax = 1 the values can be rescaled to any other range,
+e.g. 1 to 100 while comparability to other rescaled NDVI scenes is retained.
+
+
Examples
+
lsat2 <- lsat - 1000 lsat2 #> class : SpatRaster #> dimensions : 310, 287, 7 (nrow, ncol, nlyr)#> resolution : 30, 30 (x, y)#> extent : 619395, 628005, -419505, -410205 (xmin, xmax, ymin, ymax)#> coord. ref. : +proj=utm +zone=22 +ellps=WGS84 +towgs84=0,0,0,0,0,0,0 +units=m +no_defs #> source(s) : memory#> names : B1_dn, B2_dn, B3_dn, B4_dn, B5_dn, B6_dn, ... #> min values : -946, -982, -989, -996, -998, -869, ... #> max values : -815, -913, -908, -873, -852, -854, ... ## Rescale lsat2 to match original lsat value range lsat2_rescaled <- rescaleImage ( lsat2 , lsat ) lsat2_rescaled #> class : SpatRaster #> dimensions : 310, 287, 7 (nrow, ncol, nlyr)#> resolution : 30, 30 (x, y)#> extent : 619395, 628005, -419505, -410205 (xmin, xmax, ymin, ymax)#> coord. ref. : +proj=utm +zone=22 +ellps=WGS84 +towgs84=0,0,0,0,0,0,0 +units=m +no_defs #> source(s) : memory#> names : B1_dn, B2_dn, B3_dn, B4_dn, B5_dn, B6_dn, ... #> min values : 54, 18, 11, 4, 2, 131, ... #> max values : 185, 87, 92, 127, 148, 146, ... ## Rescale lsat to value range [0,1] lsat2_unity <- rescaleImage ( lsat2 , ymin = 0 , ymax = 1 ) lsat2_unity #> class : SpatRaster #> dimensions : 310, 287, 7 (nrow, ncol, nlyr)#> resolution : 30, 30 (x, y)#> extent : 619395, 628005, -419505, -410205 (xmin, xmax, ymin, ymax)#> coord. ref. : +proj=utm +zone=22 +ellps=WGS84 +towgs84=0,0,0,0,0,0,0 +units=m +no_defs #> source(s) : memory#> names : B1_dn, B2_dn, B3_dn, B4_dn, B5_dn, B6_dn, ... #> min values : 0, 0, 0, 0, 0, 0, ... #> max values : 1, 1, 1, 1, 1, 1, ...
+
+
+
+
Rlogo as SpatRaster — rlogo • RStoolbox Skip to contents
+
+
+
+
+
+
+
+
+
Tiny example of raster data used to run examples.
+
+
Examples
+
ggRGB ( rlogo ,r = 1 ,g = 2 ,b = 3 )
+
+
+
+
Set global options for RStoolbox — rsOpts • RStoolbox Skip to contents
+
+
+
+
+
+
+
+
+
shortcut to options(RStoolbox.*)
+
+
Arguments
+
verbose
+Logical. If TRUE many functions will print status messages about the current processing step. By default verbose mode is disabled.
+
Value
+
+
+
No return, just a setter for the verbosiness of the RStoolbox package
+
+
+
+
Spectral Angle Mapper — sam • RStoolbox Skip to contents
+
+
+
+
+
+
+
+
+
Calculates the angle in spectral space between pixels and a set of reference spectra (endmembers) for image classification based on spectral similarity.
+
+
Usage
+
sam ( img , em , angles = FALSE , ... )
+
+
Arguments
+
img
+SpatRaster. Remote sensing imagery.
em
+Matrix or data.frame with endmembers. Each row should contain the endmember spectrum of a class, i.e. columns correspond to bands in img. It is reccomended to set the rownames to class names.
angles
+Logical. If TRUE a RasterBrick containing each one layer per endmember will be returned containing the spectral angles.
...
+further arguments to be passed to writeRaster
+
Value
+
+
+
SpatRaster
+If angles = FALSE a single Layer will be returned in which each pixel is assigned to the closest endmember class (integer pixel values correspond to row order of em.
+
+
Details
+
For each pixel the spectral angle mapper calculates the angle between the vector defined by the pixel values and each endmember vector. The result of this is
+one raster layer for each endmember containing the spectral angle. The smaller the spectral angle the more similar a pixel is to a given endmember class.
+In a second step one can the go ahead an enforce thresholds of maximum angles or simply classify each pixel to the most similar endmember.
+
+
Examples
+
library ( terra ) library ( ggplot2 ) ## Sample endmember spectra ## First location is water, second is open agricultural vegetation pts <- data.frame ( x = c ( 624720 , 627480 ) , y = c ( - 414690 , - 411090 ) ) endmembers <- extract ( lsat , pts ) rownames ( endmembers ) <- c ( "water" , "vegetation" ) ## Calculate spectral angles lsat_sam <- sam ( lsat , endmembers , angles = TRUE ) plot ( lsat_sam ) ## Classify based on minimum angle lsat_sam <- sam ( lsat , endmembers , angles = FALSE ) ggR ( lsat_sam , forceCat = TRUE , geom_raster= TRUE ) + scale_fill_manual ( values = c ( "blue" , "green" ) , labels = c ( "water" , "vegetation" ) )
+
+
+
+
Save and Read RStoolbox Classification Results — saveRSTBX • RStoolbox Skip to contents
+
+
+
+
+
+
+
+
+
Saves objects of classes unsuperClass, superClass, rasterPCA and fCover to
+file. Useful to archive the fitted models.
+
+
Usage
+
saveRSTBX ( x , filename , format = "raster" , ... ) readRSTBX ( filename )
+
+
Arguments
+
x
+RStoolbox object of classes c("fCover", "rasterPCA", "superClass", "unsuperClass")
filename
+Character. Path and filename. Any file extension will be ignored.
format
+Character. Driver to use for the raster file
...
+further arguments passed to writeRaster
+
Value
+
+
+
The output of writeRSTBX will be at least two files written to disk:
+a) an .rds file containing the object itself and
+b) the raster file (depending on the driver you choose this can be more than two files).
+
+
Note
+
All files must be kept in the same directory to read the full object back into R
+by means of readRSTBX. You can move them to another location but you'll have to move *all* of them
+(just like you would with Shapefiles). In case the raster file(s) is missing, readRSTBX will still
+return the object but the raster will be missing.
+
writeRSTBX and readRSTBX are convenience wrappers around saveRDS, readRDS. This means
+you can read all files created this way also with base functionality as long as you don't move your files.
+This is because x$map is a SpatRaster object and hence contains only a static link to the file on disk.
+
+
+
+
Sentinel 2 MSI L2A Scene — sen2 • RStoolbox Skip to contents
+
+
+
+
+
+
+
+
+
Contains all 13 bands in already converted spectral reflectances
+
+
Examples
+
ggRGB ( sen2 , r= 4 , g= 3 , b= 2 , stretch = "lin" )
+
+
+
+
Spectral Indices — spectralIndices • RStoolbox Skip to contents
+
+
+
+
+
+
+
+
+
Calculate a suite of multispectral indices such as NDVI, SAVI etc. in an efficient way.
+
+
Usage
+
spectralIndices ( img ,
+ blue = NULL ,
+ green = NULL ,
+ red = NULL ,
+ nir = NULL ,
+ redEdge1 = NULL ,
+ redEdge2 = NULL ,
+ redEdge3 = NULL ,
+ swir1 = NULL ,
+ swir2 = NULL ,
+ swir3 = NULL ,
+ scaleFactor = 1 ,
+ skipRefCheck = FALSE ,
+ indices = NULL ,
+ index = NULL ,
+ maskLayer = NULL ,
+ maskValue = 1 ,
+ coefs = list ( L = 0.5 , G = 2.5 , L_evi = 1 , C1 = 6 , C2 = 7.5 , s = 1 , swir2ccc = NULL ,
+ swir2coc = NULL ) ,
+ ...
+)
+
+
Arguments
+
img
+SpatRaster. Typically remote sensing imagery, which is to be classified.
blue
+Character or integer. Blue band.
green
+Character or integer. Green band.
red
+Character or integer. Red band.
nir
+Character or integer. Near-infrared band (700-1100nm).
redEdge1
+Character or integer. Red-edge band (705nm)
redEdge2
+Character or integer. Red-edge band (740nm)
redEdge3
+Character or integer. Red-edge band (783nm)
swir1
+not used
swir2
+Character or integer. Short-wave-infrared band (1400-1800nm).
swir3
+Character or integer. Short-wave-infrared band (2000-2500nm).
scaleFactor
+Numeric. Scale factor for the conversion of scaled reflectances to [0,1] value range (applied as reflectance/scaleFactor) Neccesary for calculating EVI/EVI2 with scaled reflectance values.
skipRefCheck
+Logical. When EVI/EVI2 is to be calculated there is a rough heuristic check, whether the data are inside [0,1]+/-0.5 (after applying a potential scaleFactor).
+If there are invalid reflectances, e.g. clouds with reflectance > 1 this check will result in a false positive and skip EVI calculation. Use this argument to skip this check in such cases *iff* you are sure the data and scaleFactor are valid.
indices
+Character. One or more spectral indices to calculate (see Details). By default (NULL) all implemented indices given the spectral bands which are provided will be calculated.
index
+Character. Alias for indices.
maskLayer
+RasterLayer or SpatRaster containing a mask, e.g. clouds, for which pixels are set to NA. Alternatively a layername or -number can be provided if the mask is part of img.
maskValue
+Integer. Pixel value in maskLayer which should be masked in output, i.e. will be set to NA in all calculated indices.
coefs
+List of coefficients (see Details).
...
+further arguments such as filename etc. passed to writeRaster
+
Value
+
+
+
SpatRaster
+
+
Details
+
spectralIndices calculates all indices in one go in C++, which is more efficient than calculating each index separately (for large rasters).
+By default all indices which can be calculated given the specified indices will be calculated. If you don't want all indices, use the indices argument to specify exactly which indices are to be calculated.
+See the table bellow for index names and required bands.
+
Index values outside the valid value ranges (if such a range exists) will be set to NA. For example a pixel with NDVI > 1 will be set to NA.
+
+
+
+
+
+
+
Index Description Source Bands Formula CLG Green-band Chlorophyll Index Gitelson2003 redEdge3, green\(redEdge3/green - 1\) CLRE Red-edge-band Chlorophyll Index Gitelson2003 redEdge3, redEdge1\(redEdge3/redEdge1 - 1\) CTVI Corrected Transformed Vegetation Index Perry1984 red, nir\((NDVI + 0.5)/sqrt(abs(NDVI + 0.5))\) DVI Difference Vegetation Index Richardson1977 red, nir\(s * nir - red\) EVI Enhanced Vegetation Index Huete1999 red, nir, blue\(G * ((nir - red)/(nir + C1 * red - C2 * blue + L_evi))\) EVI2 Two-band Enhanced Vegetation Index Jiang 2008 red, nir\(G * (nir - red)/(nir + 2.4 * red + 1)\) GEMI Global Environmental Monitoring Index Pinty1992 red, nir\((((nir^2 - red^2) * 2 + (nir * 1.5) + (red * 0.5))/(nir + red + 0.5)) * (1 - ((((nir^2 - red^2) * 2 + (nir * 1.5) + (red * 0.5))/(nir + red + 0.5)) * 0.25)) - ((red - 0.125)/(1 - red))\) GNDVI Green Normalised Difference Vegetation Index Gitelson1998 green, nir\((nir - green)/(nir + green)\) KNDVI Kernel Normalised Difference Vegetation Index Camps-Valls2021 red, nir\(tanh(((nir - red)/(nir + red)))^2\) MCARI Modified Chlorophyll Absorption Ratio Index Daughtery2000 green, red, redEdge1\(((redEdge1 - red) - (redEdge1 - green)) * (redEdge1/red)\) MNDWI Modified Normalised Difference Water Index Xu2006 green, swir2\((green - swir2)/(green + swir2)\) MSAVI Modified Soil Adjusted Vegetation Index Qi1994 red, nir\(nir + 0.5 - (0.5 * sqrt((2 * nir + 1)^2 - 8 * (nir - (2 * red))))\) MSAVI2 Modified Soil Adjusted Vegetation Index 2 Qi1994 red, nir\((2 * (nir + 1) - sqrt((2 * nir + 1)^2 - 8 * (nir - red)))/2\) MTCI MERIS Terrestrial Chlorophyll Index DashAndCurran2004 red, redEdge1, redEdge2\((redEdge2 - redEdge1)/(redEdge1 - red)\) NBRI Normalised Burn Ratio Index Garcia1991 nir, swir3\((nir - swir3)/(nir + swir3)\) NDREI1 Normalised Difference Red Edge Index 1 GitelsonAndMerzlyak1994 redEdge2, redEdge1\((redEdge2 - redEdge1)/(redEdge2 + redEdge1)\) NDREI2 Normalised Difference Red Edge Index 2 Barnes2000 redEdge3, redEdge1\((redEdge3 - redEdge1)/(redEdge3 + redEdge1)\) NDVI Normalised Difference Vegetation Index Rouse1974 red, nir\((nir - red)/(nir + red)\) NDVIC Corrected Normalised Difference Vegetation Index Nemani1993 red, nir, swir2\((nir - red)/(nir + red) * (1 - ((swir2 - swir2ccc)/(swir2coc - swir2ccc)))\) NDWI Normalised Difference Water Index McFeeters1996 green, nir\((green - nir)/(green + nir)\) NDWI2 Normalised Difference Water Index Gao1996 nir, swir2\((nir - swir2)/(nir + swir2)\) NRVI Normalised Ratio Vegetation Index Baret1991 red, nir\((red/nir - 1)/(red/nir + 1)\) REIP Red Edge Inflection Point GuyotAndBarnet1988 red, redEdge1, redEdge2, redEdge3\(0.705 + 0.35 * ((red + redEdge3)/(2 - redEdge1))/(redEdge2 - redEdge1)\) RVI Ratio Vegetation Index red, nir\(red/nir\) SATVI Soil Adjusted Total Vegetation Index Marsett2006 red, swir2, swir3\((swir2 - red)/(swir2 + red + L) * (1 + L) - (swir3/2)\) SAVI Soil Adjusted Vegetation Index Huete1988 red, nir\((nir - red) * (1 + L)/(nir + red + L)\) SLAVI Specific Leaf Area Vegetation Index Lymburger2000 red, nir, swir2\(nir/(red + swir2)\) SR Simple Ratio Vegetation Index Birth1968 red, nir\(nir/red\) TTVI Thiam's Transformed Vegetation Index Thiam1997 red, nir\(sqrt(abs((nir - red)/(nir + red) + 0.5))\) TVI Transformed Vegetation Index Deering1975 red, nir\(sqrt((nir - red)/(nir + red) + 0.5)\) WDVI Weighted Difference Vegetation Index Richardson1977 red, nir\(nir - s * red\)
Some indices require additional parameters, such as the slope of the soil line which are specified via a list to the coefs argument.
+Although the defaults are sensible values, values like the soil brightnes factor L for SAVI should be adapted depending on the characteristics of the scene.
+The coefficients are:
Coefficient Description Affected Indices sslope of the soil line DVI, WDVI L_evi, C1, C2, Gvarious EVI Lsoil brightness factor SAVI, SATVI swir2cccminimum swir2 value (completely closed forest canopy) NDVIC swir2cocmaximum swir2 value (completely open canopy) NDVIC
The wavelength band names are defined following Schowengertd 2007, p10.
+The last column shows exemplarily which Landsat 5 TM bands correspond to which wavelength range definition.
Band Description Wavl_min Wavl_max Landsat5_Band Sentinel2_Band vis visible 400 680 1,2,3 2,3,4 red-edge1 red-edge1 680 720 - 5 red-edge2 red-edge2 720 760 - 6 red-edge3 red-edge3 760 800 - 7 nir near infra-red 800 1100 4 8/8a swir1 short-wave infra-red 1100 1351 - 9,10 swir2 short-wave infra-red 1400 1800 5 11 swir3 short-wave infra-red 2000 2500 7 12 mir1 mid-wave infra-red 3000 4000 - - mir2 mid-wave infra-red 45000 5000 - - tir1 thermal infra-red 8000 9500 - - tir2 thermal infra-red 10000 140000 6
+
Examples
+
library ( ggplot2 ) library ( terra ) ## Calculate NDVI ndvi <- spectralIndices ( lsat , red = "B3_dn" , nir = "B4_dn" , indices = "NDVI" ) ndvi #> class : SpatRaster #> dimensions : 310, 287, 1 (nrow, ncol, nlyr)#> resolution : 30, 30 (x, y)#> extent : 619395, 628005, -419505, -410205 (xmin, xmax, ymin, ymax)#> coord. ref. : +proj=utm +zone=22 +ellps=WGS84 +towgs84=0,0,0,0,0,0,0 +units=m +no_defs #> source(s) : memory#> name : NDVI #> min value : -0.5789474 #> max value : 0.7629630 ggR ( ndvi , geom_raster = TRUE ) + scale_fill_gradientn ( colours = c ( "black" , "white" ) ) # \donttest{ ## Calculate all possible indices, given the provided bands ## Convert DNs to reflectance (required to calculate EVI and EVI2) mtlFile <- system.file ( "external/landsat/LT52240631988227CUB02_MTL.txt" , package= "RStoolbox" ) lsat_ref <- radCor ( lsat , mtlFile , method = "apref" ) #> 08:20:41 | Bands to convert to reflectance: B1_dn, B2_dn, B3_dn, B4_dn, B5_dn, B7_dn#> 08:20:41 | Thermal bands to convert to brightness temperature: B6_dn#> 08:20:41 | Processing thermal band(s)#> 08:20:41 | Processing radiance / reflectanceSI <- spectralIndices ( lsat_ref , red = "B3_tre" , nir = "B4_tre" ) plot ( SI ) # }
+
+
+
+
SRTM Digital Elevation Model — srtm • RStoolbox Skip to contents
+
+
+
+
+
+
+
+
+
DEM for the Landsat example area taken from SRTM v3 tile: s04_w050_1arc_v3.tif
+
+
+
+
SRTM scene for the sen2 exemplary scene — srtm_sen2 • RStoolbox Skip to contents
+
+
+
+
+
+
+
+
+
DEM for the Sentinel 2 example area taken from SRTM v4
+
+
Examples
+
ggR ( srtm_sen2 )
+
+
+
+
Import separate Landsat files into single stack — stackMeta • RStoolbox Skip to contents
+
+
+
+
+
+
+
+
+
Reads Landsat MTL or XML metadata files and loads single Landsat Tiffs into a rasterStack.
+Be aware that by default stackMeta() does NOT import panchromatic bands nor thermal bands with resolutions != 30m.
+
+
Usage
+
stackMeta ( file , quantity = "all" , category = "image" , allResolutions = FALSE )
+
+
Arguments
+
file
+Character. Path to Landsat MTL metadata (*_MTL.txt) file or an Landsat CDR xml metadata file (*.xml).
quantity
+Character vector. Which quantity should be returned. Options: digital numbers ('dn'), top of atmosphere reflectance ('tre'), at surface reflectance ('sre'), brightness temperature ('bt'), spectral index ('index'), all quantities ('all').
category
+Character vector. Which category of data to return. Options 'image': image data, 'pan': panchromatic image, 'index': multiband indices, 'qa' quality flag bands, 'all': all categories.
allResolutions
+Logical. if TRUE a list will be returned with length = unique spatial resolutions.
+This argument was introduced to maintain backward compatibility and will be switched to TRUE in an upcoming release. Please base all new code on terra.
+
Value
+
+
+
Returns one single SpatRaster comprising all requested bands.
+If allResolutions = TRUE *and* there are different resolution layers (e.g. a 15m panchromatic band along wit 30m imagery) a list of RasterStacks will be returned.
+
+
Note
+
Be aware that by default stackMeta() does NOT import panchromatic bands nor thermal bands with resolutions != 30m. Use the allResolutions argument to import all layers.
+Note that nowadays the USGS uses cubic convolution to resample the TIR bands to 30m resolution.
+
+
Examples
+
## Example metadata file (MTL) mtlFile <- system.file ( "external/landsat/LT52240631988227CUB02_MTL.txt" , package= "RStoolbox" ) ## Read metadata metaData <- readMeta ( mtlFile ) summary ( metaData ) #> Scene: LT52240631988227CUB02 #> Satellite: LANDSAT5 #> Sensor: TM #> Date: 1988-08-14 #> Path/Row: 224/63 #> Projection: +proj=utm +zone=22 +units=m +datum=WGS84 +ellips=WGS84 #> Scene: PROJCRS["unknown",#> BASEGEOGCRS["unknown",#> DATUM["World Geodetic System 1984",#> ELLIPSOID["WGS 84",6378137,298.257223563,#> LENGTHUNIT["metre",1]],#> ID["EPSG",6326]],#> PRIMEM["Greenwich",0,#> ANGLEUNIT["degree",0.0174532925199433],#> ID["EPSG",8901]]],#> CONVERSION["UTM zone 22N",#> METHOD["Transverse Mercator",#> ID["EPSG",9807]],#> PARAMETER["Latitude of natural origin",0,#> ANGLEUNIT["degree",0.0174532925199433],#> ID["EPSG",8801]],#> PARAMETER["Longitude of natural origin",-51,#> ANGLEUNIT["degree",0.0174532925199433],#> ID["EPSG",8802]],#> PARAMETER["Scale factor at natural origin",0.9996,#> SCALEUNIT["unity",1],#> ID["EPSG",8805]],#> PARAMETER["False easting",500000,#> LENGTHUNIT["metre",1],#> ID["EPSG",8806]],#> PARAMETER["False northing",0,#> LENGTHUNIT["metre",1],#> ID["EPSG",8807]],#> ID["EPSG",16022]],#> CS[Cartesian,2],#> AXIS["(E)",east,#> ORDER[1],#> LENGTHUNIT["metre",1,#> ID["EPSG",9001]]],#> AXIS["(N)",north,#> ORDER[2],#> LENGTHUNIT["metre",1,#> ID["EPSG",9001]]]]#> #> Data:#> FILES QUANTITY CATEGORY#> B1_dn LT52240631988227CUB02_B1.TIF dn image#> B2_dn LT52240631988227CUB02_B2.TIF dn image#> B3_dn LT52240631988227CUB02_B3.TIF dn image#> B4_dn LT52240631988227CUB02_B4.TIF dn image#> B5_dn LT52240631988227CUB02_B5.TIF dn image#> B6_dn LT52240631988227CUB02_B6.TIF dn image#> B7_dn LT52240631988227CUB02_B7.TIF dn image#> #> Available calibration parameters (gain and offset):#> dn -> radiance (toa)#> dn -> brightness temperature (toa)#> ## Load rasters based on metadata file lsat <- stackMeta ( mtlFile ) lsat #> class : SpatRaster #> dimensions : 310, 287, 7 (nrow, ncol, nlyr)#> resolution : 30, 30 (x, y)#> extent : 619395, 628005, -419505, -410205 (xmin, xmax, ymin, ymax)#> coord. ref. : WGS 84 / UTM zone 22N (EPSG:32622) #> sources : LT52240631988227CUB02_B1.TIF #> LT52240631988227CUB02_B2.TIF #> LT52240631988227CUB02_B3.TIF #> ... and 4 more source(s)#> names : B1_dn, B2_dn, B3_dn, B4_dn, B5_dn, B6_dn, ... #> min values : 54, 18, 11, 4, 2, 131, ... #> max values : 185, 87, 92, 127, 148, 146, ...
+
+
+
+
Supervised Classification — superClass • RStoolbox Skip to contents
+
+
+
+
+
+
+
+
+
Supervised classification both for classification and regression mode based on vector training data (points or polygons).
+
+
Usage
+
superClass ( img ,
+ trainData ,
+ valData = NULL ,
+ responseCol = NULL ,
+ nSamples = 1000 ,
+ nSamplesV = 1000 ,
+ polygonBasedCV = FALSE ,
+ trainPartition = NULL ,
+ model = "rf" ,
+ tuneLength = 3 ,
+ kfold = 5 ,
+ minDist = 2 ,
+ mode = "classification" ,
+ predict = TRUE ,
+ predType = "raw" ,
+ filename = NULL ,
+ verbose ,
+ overwrite = TRUE ,
+ ...
+)
+
+
Arguments
+
img
+SpatRaster. Typically remote sensing imagery, which is to be classified.
trainData
+sf or sp spatial vector data containing the training locations (POINTs,or POLYGONs).
valData
+Ssf or sp spatial vector data containing the validation locations (POINTs,or POLYGONs) (optional).
responseCol
+Character or integer giving the column in trainData, which contains the response variable. Can be omitted, when trainData has only one column.
nSamples
+Integer. Number of samples per land cover class. If NULL all pixels covered by training polygons are used (memory intensive!). Ignored if trainData consists of POINTs.
nSamplesV
+Integer. Number of validation samples per land cover class. If NULL all pixels covered by validation polygons are used (memory intensive!). Ignored if valData consists of POINTs.
polygonBasedCV
+Logical. If TRUE model tuning during cross-validation is conducted on a per-polygon basis. Use this to deal with overfitting issues. Does not affect training data supplied as SpatialPointsDataFrames.
trainPartition
+Numeric. Partition (polygon based) of trainData that goes into the training data set between zero and one. Ignored if valData is provided.
model
+Character. Which model to use. See train for options. Defaults to randomForest ('rf'). In addition to the standard caret models, a maximum likelihood classification is available via model = 'mlc'.
tuneLength
+Integer. Number of levels for each tuning parameter (see train for details).
kfold
+Integer. Number of cross-validation resamples during model tuning.
minDist
+Numeric. Minumum distance between training and validation data,
+ e.g. minDist=1 clips validation polygons to ensure a minimal distance of one pixel (pixel size according to img) to the next training polygon.
+Requires all data to carry valid projection information.
mode
+Character. Model type: 'regression' or 'classification'.
predict
+Logical. Produce a map (TRUE, default) or only fit and validate the model (FALSE).
predType
+Character. Type of the final output raster. Either "raw" for class predictions or "prob" for class probabilities. Class probabilities are not available for all classification models (predict.train ).
filename
+Path to output file (optional). If NULL, standard raster handling will apply, i.e. storage either in memory or in the raster temp directory.
verbose
+Logical. prints progress and statistics during execution
overwrite
+logical. Overwrite spatial prediction raster if it already exists.
...
+further arguments to be passed to train
+
Value
+
+
+
A superClass object (effectively a list) containing:
$model: the fitted model
$modelFit: model fit statistics
$training: indexes of samples used for training
$validation: list of
$performance: performance estimates based on independent validation (confusion matrix etc.)
$validationSamples: actual pixel coordinates plus reference and predicted values used for validation
$validationGeometry: validation polygpns (clipped with mindist to training geometries)
$map: the predicted raster
$classMapping: a data.frame containing an integer <-> label mapping
+
Details
+
SuperClass performs the following steps:
+
Ensure non-overlap between training and validation data. This is neccesary to avoid biased performance estimates.
+ A minimum distance (minDist) in pixels can be provided to enforce a given distance between training and validation data.
Sample training coordinates. If trainData (and valData if present) are polygons superClass will calculate the area per polygon and sample
+nSamples locations per class within these polygons. The number of samples per individual polygon scales with the polygon area, i.e. the bigger the polygon, the more samples.
Split training/validation
+If valData was provided (reccomended) the samples from these polygons will be held-out and not used for model fitting but only for validation.
+If trainPartition is provided the trainingPolygons will be divided into training polygons and validation polygons.
Extract raster data
+The predictor values on the sample pixels are extracted from img
Fit the model. Using caret::train on the sampled training data the model will be fit,
+including parameter tuning (tuneLength) in kfold cross-validation. polygonBasedCV=TRUE will define cross-validation folds based on polygons (reccomended)
+otherwise it will be performed on a per-pixel basis.
Predict the classes of all pixels in img based on the final model.
Validate the model with the independent validation data.
+
Examples
+
library ( caret ) library ( randomForest ) #> randomForest 4.7-1.1#> Type rfNews() to see new features/changes/bug fixes.#> #> Attaching package: ‘randomForest’#> The following object is masked from ‘package:gridExtra’:#> #> combine#> The following object is masked from ‘package:ggplot2’:#> #> marginlibrary ( e1071 ) #> #> Attaching package: ‘e1071’#> The following object is masked from ‘package:terra’:#> #> interpolatelibrary ( terra ) train <- readRDS ( system.file ( "external/trainingPoints_lsat.rds" , package= "RStoolbox" ) ) ## Plot training data olpar <- par ( no.readonly = TRUE ) # back-up par par ( mfrow= c ( 1 ,2 ) ) colors <- c ( "yellow" , "green" , "deeppink" ) plotRGB ( rlogo ) plot ( train , add = TRUE , col = colors [ train $ class ] , pch = 19 ) ## Fit classifier (splitting training into 70\% training data, 30\% validation data) SC <- superClass ( rlogo , trainData = train , responseCol = "class" ,model = "rf" , tuneLength = 1 , trainPartition = 0.7 ) #> 08:20:47 | Begin sampling training data#> 08:20:48 | Starting to fit model#> 08:20:48 | Starting spatial predict#> 08:20:48 | Begin validation#> ******************** Model summary ********************#> Random Forest #> #> 21 samples#> 3 predictor#> 3 classes: 'A', 'B', 'C' #> #> No pre-processing#> Resampling: Cross-Validated (5 fold) #> Summary of sample sizes: 16, 16, 18, 17, 17 #> Resampling results:#> #> Accuracy Kappa#> 1 1 #> #> Tuning parameter 'mtry' was held constant at a value of 1#> [[1]]#> TrainAccuracy TrainKappa method#> 1 1 1 rf#> #> [[2]]#> Cross-Validated (5 fold) Confusion Matrix #> #> (entries are average cell counts across resamples)#> #> Reference#> Prediction A B C#> A 1.4 0.0 0.0#> B 0.0 1.4 0.0#> C 0.0 0.0 1.4#> #> Accuracy (average) : 1#> #> #> ******************** Validation summary ********************#> Confusion Matrix and Statistics#> #> Reference#> Prediction A B C#> A 3 0 0#> B 0 3 0#> C 0 0 3#> #> Overall Statistics#> #> Accuracy : 1 #> 95% CI : (0.6637, 1)#> No Information Rate : 0.3333 #> P-Value [Acc > NIR] : 5.081e-05 #> #> Kappa : 1 #> #> Mcnemar's Test P-Value : NA #> #> Statistics by Class:#> #> Class: A Class: B Class: C#> Sensitivity 1.0000 1.0000 1.0000#> Specificity 1.0000 1.0000 1.0000#> Pos Pred Value 1.0000 1.0000 1.0000#> Neg Pred Value 1.0000 1.0000 1.0000#> Prevalence 0.3333 0.3333 0.3333#> Detection Rate 0.3333 0.3333 0.3333#> Detection Prevalence 0.3333 0.3333 0.3333#> Balanced Accuracy 1.0000 1.0000 1.0000SC #> superClass results#> ************ Validation **************#> $validation#> Confusion Matrix and Statistics#> #> Reference#> Prediction A B C#> A 3 0 0#> B 0 3 0#> C 0 0 3#> #> Overall Statistics#> #> Accuracy : 1 #> 95% CI : (0.6637, 1)#> No Information Rate : 0.3333 #> P-Value [Acc > NIR] : 5.081e-05 #> #> Kappa : 1 #> #> Mcnemar's Test P-Value : NA #> #> Statistics by Class:#> #> Class: A Class: B Class: C#> Sensitivity 1.0000 1.0000 1.0000#> Specificity 1.0000 1.0000 1.0000#> Pos Pred Value 1.0000 1.0000 1.0000#> Neg Pred Value 1.0000 1.0000 1.0000#> Prevalence 0.3333 0.3333 0.3333#> Detection Rate 0.3333 0.3333 0.3333#> Detection Prevalence 0.3333 0.3333 0.3333#> Balanced Accuracy 1.0000 1.0000 1.0000#> #> *************** Map ******************#> $map#> class : SpatRaster #> dimensions : 77, 101, 1 (nrow, ncol, nlyr)#> resolution : 1, 1 (x, y)#> extent : 0, 101, 0, 77 (xmin, xmax, ymin, ymax)#> coord. ref. : +proj=merc +lon_0=0 +k=1 +x_0=0 +y_0=0 +ellps=WGS84 +towgs84=0,0,0,0,0,0,0 +units=m +no_defs #> source(s) : memory#> name : class_supervised #> min value : 1 #> max value : 3 ## Plots plot ( SC $ map , col = colors , legend = FALSE , axes = FALSE , box = FALSE ) legend ( 1 ,1 , legend = levels ( train $ class ) , fill = colors , title = "Classes" , horiz = TRUE , bty = "n" ) par ( olpar ) # reset par
+
+
+
+
Tasseled Cap Transformation — tasseledCap • RStoolbox Skip to contents
+
+
+
+
+
+
+
+
+
Calculates brightness, greenness and wetness from multispectral imagery.
+Currently implemented Landsat 4 TM, Landsat 5 TM, Landsat 7ETM+, Landsat 8 OLI, MODIS, QuickBird, Spot5 and RapidEye.
+
+
Usage
+
tasseledCap ( img , sat , ... )
+
+
Arguments
+
img
+SpatRaster. Input image. Band order must correspond to sensor specifications (see Details and Examples)
sat
+Character. Sensor; one of: c("Landsat4TM", "Landsat5TM", "Landsat7ETM", "Landsat8OLI", "MODIS", "QuickBird", "Spot5", "RapidEye"). Case is irrelevant.
...
+Further arguments passed to writeRaster.
+
Value
+
+
+
Returns a SpatRaster with the thee bands: brigthness, greenness, and (soil) wetness.
+
+
Details
+
Currently implemented: Landsat 4 TM, Landsat 5 TM, Landsat 7ETM+, Landsat 8 OLI, MODIS, QuickBird, Spot5, RapdiEye.
+Input data must be in top of atmosphere reflectance.
+Moreover, bands must be provided in ascending order as listed in the table below.
+Irrelevant bands, such as Landsat Thermal Bands or QuickBird/Spot5 Panchromatic Bands must be omitted.
+Required bands are:
sat bands coefficients data unit Landsat4TM 1,2,3,4,5,7 Crist 1985 reflectance Landsat5TM 1,2,3,4,5,7 Crist 1985 reflectance Landsat7ETM 1,2,3,4,5,7 Huang 2002 reflectance Landsat8OLI 2,3,4,5,6,7 Baig 2014 reflectance MODIS 1,2,3,4,5,6,7 Lobser 2007 reflectance QuickBird 2,3,4,5 Yarbrough 2005 reflectance Spot5 2,3,4,5 Ivtis 2008 reflectance RapidEye 1,2,3,4,5 Schoenert 2014 reflectance
+
References
+
Crist (1985) "A TM Tasseled Cap Equivalent Transformation for Reflectance Factor Data." Remote Sensing of Environment 17 (3): 301-306
+
Huang et al. (2002) "Derivation of a Tasselled Cap Transformation Based on Landsat 7 At-Satellite Reflectance." International Journal of Remote Sensing 23 (8): 1741-1748
+
Baig et al. (2014) "Derivation of a Tasselled Cap Transformation Based on Landsat 8 At-Satellite Reflectance." Remote Sensing Letters 5 (5): 423-431.
+
Lobser et al. (2007) "MODIS Tasselled Cap: Land Cover Characteristics Expressed through Transformed MODIS Data." International Journal of Remote Sensing 28 (22): 5079-5101.
+
Yarbrough et al. (2005) "QuickBird 2 tasseled cap transform coefficients: a comparison of derivation methods." Pecora 16 Global Priorities in Land Remote Sensing: 23-27.
+
Ivits et al. (2008) "Orthogonal transformation of segmented SPOT5 images." Photogrammetric Engineering & Remote Sensing 74 (11): 1351-1364.
+
Schoenert et al. (2014) "Derivation of tasseled cap coefficients for RapidEye data." Earth Resources and Environmental Remote Sensing/GIS Applications V (9245): 92450Qs.
+
+
Examples
+
library ( terra ) ## Run tasseled cap (exclude thermal band 6) lsat_tc <- tasseledCap ( lsat [[ c ( 1 : 5 ,7 ) ] ] , sat = "Landsat5TM" ) lsat_tc #> class : SpatRaster #> dimensions : 310, 287, 3 (nrow, ncol, nlyr)#> resolution : 30, 30 (x, y)#> extent : 619395, 628005, -419505, -410205 (xmin, xmax, ymin, ymax)#> coord. ref. : +proj=utm +zone=22 +ellps=WGS84 +towgs84=0,0,0,0,0,0,0 +units=m +no_defs #> source(s) : memory#> names : brightness, greenness, wetness #> min values : 33.0776, -21.2454, 10.9682 #> max values : 254.0931, 69.6422, 122.4285 plot ( lsat_tc )
+
+
+
+
Topographic Illumination Correction — topCor • RStoolbox Skip to contents
+
+
+
+
+
+
+
+
+
account and correct for changes in illumination due to terrain elevation.
+
+
Usage
+
topCor ( img ,
+ dem ,
+ metaData ,
+ solarAngles = c ( ) ,
+ method = "C" ,
+ stratImg = NULL ,
+ nStrat = 5 ,
+ illu ,
+ ...
+)
+
+
Arguments
+
img
+SpatRaster. Imagery to correct
dem
+SpatRaster. Either a digital elevation model as a RasterLayer or a RasterStack/Brick with pre-calculated slope and aspect (see terrain ) in which case the layers must be named 'slope' and 'aspect'.
+Must have the same dimensions as img.
metaData
+Character, ImageMetaData. Either a path to a Landsat meta-data file (MTL) or an ImageMetaData object (see readMeta )
solarAngles
+Numeric vector containing sun azimuth and sun zenith (in radians and in that order). Not needed if metaData is provided
method
+Character. One of c("cos", "avgcos", "minnaert", "C", "stat", "illu"). Choosing 'illu' will return only the local illumination map.
stratImg
+RasterLayer or SpatRaster to define strata, e.g. NDVI. Or the string 'slope' in which case stratification will be on nStrat slope classes. Only relevant if method = 'minnaert'.
nStrat
+Integer. Number of bins or quantiles to stratify by. If a bin has less than 50 samples it will be merged with the next bin. Only relevant if method = 'minnaert'.
illu
+SpatRaster. Optional pre-calculated ilumination map. Run topCor with method="illu" to calculate an ilumination map
...
+arguments passed to writeRaster
+
Value
+
+
+
SpatRaster
+
+
Details
+
For detailed discussion of the various approaches please see Riano et al. (2003).
+
The minnaert correction can be stratified for different landcover characteristics. If stratImg = 'slope' the analysis is stratified by the slope,
+i.e. the slope values are divided into nStrat classes and the correction coefficient k is calculated and applied separately for each slope class.
+An alternative could be to stratify by a vegetation index in which case an additional raster layer has to be provided via the stratImg argument.
+
+
References
+
Riano et al. (2003) Assessment of different topographic correction in Landsat-TM data for mapping vegetation types. IEEE Transactions on Geoscience and Remote Sensing.
+
+
Examples
+
## Load example data metaData <- system.file ( "external/landsat/LT52240631988227CUB02_MTL.txt" , package= "RStoolbox" ) metaData <- readMeta ( metaData ) ## Minnaert correction, solar angles from metaData lsat_minnaert <- topCor ( lsat , dem = srtm , metaData = metaData , method = "minnaert" ) #> 08:20:51 | Calculate slope and aspect#> 08:20:51 | Calculate illumination map#> 08:20:52 | Correct imagery#> 08:20:52 | Estimate coefficients## C correction, solar angles provided manually lsat_C <- topCor ( lsat , dem = srtm , solarAngles = c ( 1.081533 , 0.7023922 ) , method = "C" ) #> 08:20:52 | Calculate slope and aspect#> 08:20:52 | Calculate illumination map#> 08:20:52 | Correct imagery#> 08:20:52 | Estimate coefficients
+
+
+
+
Unsupervised Classification — unsuperClass • RStoolbox Skip to contents
+
+
+
+
+
+
+
+
+
Unsupervised clustering of SpatRaster data using kmeans clustering
+
+
Usage
+
unsuperClass ( img ,
+ nSamples = 10000 ,
+ nClasses = 5 ,
+ nStarts = 25 ,
+ nIter = 100 ,
+ norm = FALSE ,
+ clusterMap = TRUE ,
+ algorithm = "Hartigan-Wong" ,
+ output = "classes" ,
+ ...
+)
+
+
Arguments
+
img
+SpatRaster.
nSamples
+Integer. Number of random samples to draw to fit cluster map. Only relevant if clusterMap = TRUE.
nClasses
+Integer. Number of classes.
nStarts
+Integer. Number of random starts for kmeans algorithm.
nIter
+Integer. Maximal number of iterations allowed.
norm
+Logical. If TRUE will normalize img first using normImage . Normalizing is beneficial if your predictors have different scales.
clusterMap
+Logical. Fit kmeans model to a random subset of the img (see Details).
algorithm
+Character. kmeans algorithm. One of c("Hartigan-Wong", "Lloyd", "MacQueen")
output
+Character. Either 'classes' (kmeans class; default) or 'distances' (euclidean distance to each cluster center).
...
+further arguments to be passed to writeRaster , e.g. filename
+
Value
+
+
+
Returns an RStoolbox::unsuperClass object, which is a list containing the kmeans model ($model) and the raster map ($map).
+For output = "classes", $map contains a SpatRaster with discrete classes (kmeans clusters); for output = "distances" $map contains
+a SpatRaster, with `nClasses` layers, where each layer maps the euclidean distance to the corresponding class centroid.
+
+
Details
+
Clustering is done using kmeans clusterMap=FALSE), however this can be slow and is
+not memory safe. Therefore if you have large raster data (> memory), as is typically the case with remote sensing imagery it is advisable to choose clusterMap=TRUE (the default).
+This means that a kmeans cluster model is calculated based on a random subset of pixels (nSamples). Then the distance of *all* pixels to the cluster centers
+is calculated in a stepwise fashion using predict
+
The solution of the kmeans algorithm often depends on the initial configuration of class centers which is chosen randomly.
+Therefore, kmeans is usually run with multiple random starting configurations in order to find a convergent solution from different starting configurations.
+The nStarts argument allows to specify how many random starts are conducted.
+
+
Examples
+
if ( FALSE ) { library ( terra ) input <- rlogo ## Plot olpar <- par ( no.readonly = TRUE ) # back-up par par ( mfrow= c ( 1 ,2 ) ) plotRGB ( input ) ## Run classification set.seed ( 25 ) unC <- unsuperClass ( input , nSamples = 100 , nClasses = 5 , nStarts = 5 ) unC ## Plots colors <- rainbow ( 5 ) plot ( unC $ map , col = colors , legend = FALSE , axes = FALSE , box = FALSE ) legend ( 1 ,1 , legend = paste0 ( "C" ,1 : 5 ) , fill = colors , title = "Classes" , horiz = TRUE , bty = "n" ) ## Return the distance of each pixel to each class centroid unC <- unsuperClass ( input , nSamples = 100 , nClasses = 3 , output = "distances" ) unC ggR ( unC $ map , 1 : 3 , geom_raster = TRUE ) par ( olpar ) # reset par }
+
+
+
+
Map accuracy assessment — validateMap • RStoolbox Skip to contents
+
+
+
+
+
+
+
+
+
validate a map from a classification or regression model. This can be useful to update the accuracy assessment after filtering, e.g. for a minimum mapping unit.
+
+
Usage
+
validateMap ( map ,
+ valData ,
+ responseCol ,
+ nSamplesV = 500 ,
+ mode = "classification" ,
+ classMapping = NULL
+)
+
+
Arguments
+
map
+SpatRaster. The classified map.
valData
+sf object with validation data (POLYGONs or POINTs).
responseCol
+Character. Column containing the validation data in attribute table of valData.
nSamplesV
+Integer. Number of pixels to sample for validation (only applies to polygons).
mode
+Character. Either 'classification' or 'regression'.
classMapping
+optional data.frame with columns 'class' and 'classID' defining the mapping from raster integers to class names.
+
Value
+
+
+
Returns a structured list includng the preformance and confusion-matrix of your then validated input data
+
+
Examples
+
library ( caret ) library ( terra ) ## Training data poly <- readRDS ( system.file ( "external/trainingPolygons_lsat.rds" , package= "RStoolbox" ) ) ## Split training data in training and validation set (50%-50%) splitIn <- createDataPartition ( poly $ class , p = .5 ) [[ 1 ] ] train <- poly [ splitIn ,] val <- poly [ - splitIn ,] ## Classify (deliberately poorly) sc <- superClass ( lsat , trainData = train , responseCol = "class" , nSamples = 50 , model = "mlc" ) #> 08:20:53 | Begin sampling training data#> 08:20:54 | Starting to fit model#> 08:20:54 | Starting spatial predict#> ******************** Model summary ********************#> Maximum Likelihood Classification #> #> 274 samples#> 7 predictor#> 4 classes: 'cleared', 'fallen_dry', 'forest', 'water' #> #> No pre-processing#> Resampling: Cross-Validated (5 fold) #> Summary of sample sizes: 219, 219, 219, 220, 219 #> Resampling results:#> #> Accuracy Kappa#> 1 1 #> #> [[1]]#> TrainAccuracy TrainKappa method#> 1 1 1 custom#> #> [[2]]#> Cross-Validated (5 fold) Confusion Matrix #> #> (entries are average cell counts across resamples)#> #> Reference#> Prediction cleared fallen_dry forest water#> cleared 16.0 0.0 0.0 0.0#> fallen_dry 0.0 6.8 0.0 0.0#> forest 0.0 0.0 16.0 0.0#> water 0.0 0.0 0.0 16.0#> #> Accuracy (average) : 1#> #> #> ******************** Validation summary ********************#> [1] "No independent validation was performed!"## Polish map with majority filter polishedMap <- focal ( sc $ map , matrix ( 1 ,3 ,3 ) , fun = modal ) ## Validation ## Before filtering val0 <- validateMap ( sc $ map , valData = val , responseCol = "class" , classMapping = sc $ classMapping ) ## After filtering val1 <- validateMap ( polishedMap , valData = val , responseCol = "class" , classMapping = sc $ classMapping )
+
+
+
+
Write ENVI spectral libraries — writeSLI • RStoolbox Skip to contents
+
+
+
+
+
+
+
+
+
Writes binary ENVI spectral library files (sli) with accompanying header (.sli.hdr) files OR ASCII spectral library files in ENVI format.
+
+
Usage
+
writeSLI ( x ,
+ path ,
+ wavl.units = "Micrometers" ,
+ scaleF = 1 ,
+ mode = "bin" ,
+ endian = .Platform $ endian
+)
+
+
Arguments
+
x
+data.frame with first column containing wavelengths and all other columns containing spectra.
path
+path to spectral library file to be created.
wavl.units
+wavelength units. Defaults to Micrometers. Nanometers is another typical option.
scaleF
+optional reflectance scaling factor. Defaults to 1.
mode
+character string specifying output file type. Must be one of "bin" for binary .sli files or "ASCII" for ASCII ENVI plot files.
endian
+character. Optional. By default the endian is determined based on the platform, but can be forced manually by setting it to either "little" or "big".
+
Value
+
+
+
Does not return anything, write the SLI file directly to your drive for where your specified your path parameter
+
+
Details
+
ENVI spectral libraries with ending .sli are binary arrays with spectra saved in rows.
+
+
Examples
+
## Example data sliFile <- system.file ( "external/vegSpec.sli" , package= "RStoolbox" ) sliTmpFile <- paste0 ( tempdir ( ) ,"/vegetationSpectra.sli" ) ## Read spectral library sli <- readSLI ( sliFile ) head ( sli ) #> wavelength veg_stressed veg_vital#> 1 350 0.008958003 0.008836994#> 2 351 0.008910760 0.008909440#> 3 352 0.008874181 0.008972186#> 4 353 0.008847097 0.009025744#> 5 354 0.008829174 0.009071405#> 6 355 0.008819440 0.009109739plot ( sli [ ,1 : 2 ] , col = "orange" , type = "l" ) lines ( sli [ ,c ( 1 ,3 ) ] , col = "green" ) ## Write to binary spectral library writeSLI ( sli , path = sliTmpFile )
+
+
+
+
R: Linear Image Rescaling
-
-
-
rescaleImage {RStoolbox} R Documentation
-
-
Linear Image Rescaling
-
-
Description
-
-
performs linear shifts of value ranges either to match min/max of another image (y)
-or to any other min and max value (ymin and ymax).
-
-
-
-
Usage
-
-
rescaleImage(x, y, xmin, xmax, ymin, ymax, forceMinMax = FALSE, ...)
-
-
-
-
Arguments
-
-
-x
-patRaster or numeric vector. Image to normalise.
- y
-SpatRaster or numeric vector. Reference image. Optional. Used to extract min and max values if ymin or ymax are missing.
- xmin
-Numeric. Min value of x. Either a single value or one value per layer in x. If xmin is not provided it will be extracted from x.
- xmax
-Numeric. Max value of x. Either a single value or one value per layer in x. If xmax is not provided it will be extracted from x.
- ymin
-Numeric. Min value of y. Either a single value or one value per layer in x. If ymin is not provided it will be extracted from y.
- ymax
-Numeric. Max value of y. Either a single value or one value per layer in x. If ymax is not provided it will be extracted from y.
- forceMinMax
-Logical. Forces update of min and max data slots in x or y.
- ...
-additional arguments passed to terra::writeRaster()
-
-
-
-
Details
-
-
Providing xmin and xmax values manually can be useful if the raster contains a variable of a known, fixed value range,
-e.g. NDVI from -1 to 1 but the actual pixel values don't encompass this entire range.
-By providing xmin = -1 and xmax = 1 the values can be rescaled to any other range,
-e.g. 1 to 100 while comparability to other rescaled NDVI scenes is retained.
-
-
-
-
Value
-
-
Returns a SpatRaster of the same dimensions as the input raster x but shifted and stretched to the new limits.
-
-
-
-
See Also
-
-
histMatch
-
-
-
-
Examples
-
-
lsat2 <- lsat - 1000
-lsat2
-
-
## class : SpatRaster
-## dimensions : 310, 287, 7 (nrow, ncol, nlyr)
-## resolution : 30, 30 (x, y)
-## extent : 619395, 628005, -419505, -410205 (xmin, xmax, ymin, ymax)
-## coord. ref. : +proj=utm +zone=22 +ellps=WGS84 +towgs84=0,0,0,0,0,0,0 +units=m +no_defs
-## source(s) : memory
-## names : B1_dn, B2_dn, B3_dn, B4_dn, B5_dn, B6_dn, ...
-## min values : -946, -982, -989, -996, -998, -869, ...
-## max values : -815, -913, -908, -873, -852, -854, ...
-
-
## Rescale lsat2 to match original lsat value range
-lsat2_rescaled <- rescaleImage(lsat2, lsat)
-lsat2_rescaled
-
-
## class : SpatRaster
-## dimensions : 310, 287, 7 (nrow, ncol, nlyr)
-## resolution : 30, 30 (x, y)
-## extent : 619395, 628005, -419505, -410205 (xmin, xmax, ymin, ymax)
-## coord. ref. : +proj=utm +zone=22 +ellps=WGS84 +towgs84=0,0,0,0,0,0,0 +units=m +no_defs
-## source(s) : memory
-## names : B1_dn, B2_dn, B3_dn, B4_dn, B5_dn, B6_dn, ...
-## min values : 54, 18, 11, 4, 2, 131, ...
-## max values : 185, 87, 92, 127, 148, 146, ...
-
-
## Rescale lsat to value range [0,1]
-lsat2_unity <- rescaleImage(lsat2, ymin = 0, ymax = 1)
-lsat2_unity
-
-
## class : SpatRaster
-## dimensions : 310, 287, 7 (nrow, ncol, nlyr)
-## resolution : 30, 30 (x, y)
-## extent : 619395, 628005, -419505, -410205 (xmin, xmax, ymin, ymax)
-## coord. ref. : +proj=utm +zone=22 +ellps=WGS84 +towgs84=0,0,0,0,0,0,0 +units=m +no_defs
-## source(s) : memory
-## names : B1_dn, B2_dn, B3_dn, B4_dn, B5_dn, B6_dn, ...
-## min values : 0, 0, 0, 0, 0, 0, ...
-## max values : 1, 1, 1, 1, 1, 1, ...
-
-
-
-
[Package
RStoolbox version 0.4.0
Index ]
-
R: Rlogo as SpatRaster
-
-
-
rlogo {RStoolbox} R Documentation
-
-
Rlogo as SpatRaster
-
-
Description
-
-
Tiny example of raster data used to run examples.
-
-
-
-
Usage
-
-
rlogo
-
-
-
-
Examples
-
-
ggRGB(rlogo,r = 1,g = 2,b = 3)
-
-
-
-
-
[Package
RStoolbox version 0.4.0
Index ]
-
R: Set global options for RStoolbox
-
-
-
rsOpts {RStoolbox} R Documentation
-
-
Set global options for RStoolbox
-
-
Description
-
-
shortcut to options(RStoolbox.*)
-
-
-
-
Usage
-
-
rsOpts(verbose)
-
-
-
-
Arguments
-
-
-verbose
-Logical. If TRUE many functions will print status messages about the current processing step. By default verbose mode is disabled.
-
-
-
-
Value
-
-
No return, just a setter for the verbosiness of the RStoolbox package
-
-
-
-
Examples
-
-
rsOpts(verbose=TRUE)
-
-
-
-
[Package
RStoolbox version 0.4.0
Index ]
-
R: Spectral Angle Mapper
-
-
-
sam {RStoolbox} R Documentation
-
-
Spectral Angle Mapper
-
-
Description
-
-
Calculates the angle in spectral space between pixels and a set of reference spectra (endmembers) for image classification based on spectral similarity.
-
-
-
-
Usage
-
-
sam(img, em, angles = FALSE, ...)
-
-
-
-
Arguments
-
-
-img
-RasterBrick or RasterStack or SpatRaster. Remote sensing imagery.
- em
-Matrix or data.frame with endmembers. Each row should contain the endmember spectrum of a class, i.e. columns correspond to bands in img. It is reccomended to set the rownames to class names.
- angles
-Logical. If TRUE a RasterBrick containing each one layer per endmember will be returned containing the spectral angles.
- ...
-further arguments to be passed to writeRaster
-
-
-
-
Details
-
-
For each pixel the spectral angle mapper calculates the angle between the vector defined by the pixel values and each endmember vector. The result of this is
-one raster layer for each endmember containing the spectral angle. The smaller the spectral angle the more similar a pixel is to a given endmember class.
-In a second step one can the go ahead an enforce thresholds of maximum angles or simply classify each pixel to the most similar endmember.
-
-
-
-
Value
-
-
SpatRaster
-If angles = FALSE a single Layer will be returned in which each pixel is assigned to the closest endmember class (integer pixel values correspond to row order of em.
-
-
-
-
Examples
-
-
library(terra)
-library(ggplot2)
-
-## Sample endmember spectra
-## First location is water, second is open agricultural vegetation
-pts <- data.frame(x = c(624720, 627480), y = c(-414690, -411090))
-endmembers <- extract(lsat, pts)
-rownames(endmembers) <- c("water", "vegetation")
-
-## Calculate spectral angles
-lsat_sam <- sam(lsat, endmembers, angles = TRUE)
-plot(lsat_sam)
-
-
-
## Classify based on minimum angle
-lsat_sam <- sam(lsat, endmembers, angles = FALSE)
-
-ggR(lsat_sam, forceCat = TRUE, geom_raster=TRUE) +
- scale_fill_manual(values = c("blue", "green"), labels = c("water", "vegetation"))
-
-
-
-
-
[Package
RStoolbox version 0.4.0
Index ]
-
R: Save and Read RStoolbox Classification Results
-
-
-
saveRSTBX {RStoolbox} R Documentation
-
-
Save and Read RStoolbox Classification Results
-
-
Description
-
-
Saves objects of classes unsuperClass, superClass, rasterPCA and fCover to
-file. Useful to archive the fitted models.
-
-
-
-
Usage
-
-
saveRSTBX(x, filename, format = "raster", ...)
-
-readRSTBX(filename)
-
-
-
-
Arguments
-
-
-x
-RStoolbox object of classes c("fCover", "rasterPCA", "superClass", "unsuperClass")
- filename
-Character. Path and filename. Any file extension will be ignored.
- format
-Character. Driver to use for the raster file
- ...
-further arguments passed to writeRaster
-
-
-
-
Value
-
-
The output of writeRSTBX will be at least two files written to disk:
-a) an .rds file containing the object itself and
-b) the raster file (depending on the driver you choose this can be more than two files).
-
-
-
-
Functions
-
-
-
-
-
-
Note
-
-
All files must be kept in the same directory to read the full object back into R
-by means of readRSTBX. You can move them to another location but you'll have to move *all* of them
-(just like you would with Shapefiles). In case the raster file(s) is missing, readRSTBX will still
-return the object but the raster will be missing.
-
-
writeRSTBX and readRSTBX are convenience wrappers around saveRDS, readRDS. This means
-you can read all files created this way also with base functionality as long as you don't move your files.
-This is because x$map is a SpatRaster object and hence contains only a static link to the file on disk.
-
-
-
-
Examples
-
-
## Not run:
-##D input <- rlogo
-##D ## Create filename
-##D file <- paste0(tempdir(), "/test", runif(1))
-##D ## Run PCA
-##D rpc <- rasterPCA(input, nSample = 100)
-##D ## Save object
-##D saveRSTBX(rpc, filename=file)
-##D ## Which files were written?
-##D list.files(tempdir(), pattern = basename(file))
-##D ## Re-read files
-##D re_rpc <- readRSTBX(file)
-##D ## Remove files
-##D file.remove(list.files(tempdir(), pattern = basename(file), full = TRUE))
-## End(Not run)
-
-
-
-
[Package
RStoolbox version 0.4.0
Index ]
-
+
+ https://bleutner.github.io/RStoolbox/404.html
+
+
+ https://bleutner.github.io/RStoolbox/authors.html
+
+
+ https://bleutner.github.io/RStoolbox/index.html
+
+
+ https://bleutner.github.io/RStoolbox/news/index.html
+
+
+ https://bleutner.github.io/RStoolbox/reference/ImageMetaData.html
+
+
+ https://bleutner.github.io/RStoolbox/reference/RStoolbox.html
+
+
+ https://bleutner.github.io/RStoolbox/reference/classifyQA.html
+
+
+ https://bleutner.github.io/RStoolbox/reference/cloudMask.html
+
+
+ https://bleutner.github.io/RStoolbox/reference/cloudShadowMask.html
+
+
+ https://bleutner.github.io/RStoolbox/reference/coregisterImages.html
+
+
+ https://bleutner.github.io/RStoolbox/reference/decodeQA.html
+
+
+ https://bleutner.github.io/RStoolbox/reference/encodeQA.html
+
+
+ https://bleutner.github.io/RStoolbox/reference/estimateHaze.html
+
+
+ https://bleutner.github.io/RStoolbox/reference/fCover.html
+
+
+ https://bleutner.github.io/RStoolbox/reference/fortifySpatRaster.html
+
+
+ https://bleutner.github.io/RStoolbox/reference/getMeta.html
+
+
+ https://bleutner.github.io/RStoolbox/reference/getValidation.html
+
+
+ https://bleutner.github.io/RStoolbox/reference/ggR.html
+
+
+ https://bleutner.github.io/RStoolbox/reference/ggRGB.html
+
+
+ https://bleutner.github.io/RStoolbox/reference/histMatch.html
+
+
+ https://bleutner.github.io/RStoolbox/reference/index.html
+
+
+ https://bleutner.github.io/RStoolbox/reference/lsat.html
+
+
+ https://bleutner.github.io/RStoolbox/reference/mesma.html
+
+
+ https://bleutner.github.io/RStoolbox/reference/normImage.html
+
+
+ https://bleutner.github.io/RStoolbox/reference/oneHotEncode.html
+
+
+ https://bleutner.github.io/RStoolbox/reference/panSharpen.html
+
+
+ https://bleutner.github.io/RStoolbox/reference/pifMatch.html
+
+
+ https://bleutner.github.io/RStoolbox/reference/pipe.html
+
+
+ https://bleutner.github.io/RStoolbox/reference/predict.unsuperClass.html
+
+
+ https://bleutner.github.io/RStoolbox/reference/radCor.html
+
+
+ https://bleutner.github.io/RStoolbox/reference/rasterCVA.html
+
+
+ https://bleutner.github.io/RStoolbox/reference/rasterEntropy.html
+
+
+ https://bleutner.github.io/RStoolbox/reference/rasterPCA.html
+
+
+ https://bleutner.github.io/RStoolbox/reference/readEE.html
+
+
+ https://bleutner.github.io/RStoolbox/reference/readMeta.html
+
+
+ https://bleutner.github.io/RStoolbox/reference/readSLI.html
+
+
+ https://bleutner.github.io/RStoolbox/reference/rescaleImage.html
+
+
+ https://bleutner.github.io/RStoolbox/reference/rlogo.html
+
+
+ https://bleutner.github.io/RStoolbox/reference/rsOpts.html
+
+
+ https://bleutner.github.io/RStoolbox/reference/sam.html
+
+
+ https://bleutner.github.io/RStoolbox/reference/saveRSTBX.html
+
+
+ https://bleutner.github.io/RStoolbox/reference/sen2.html
+
+
+ https://bleutner.github.io/RStoolbox/reference/spectralIndices.html
+
+
+ https://bleutner.github.io/RStoolbox/reference/srtm.html
+
+
+ https://bleutner.github.io/RStoolbox/reference/srtm_sen2.html
+
+
+ https://bleutner.github.io/RStoolbox/reference/stackMeta.html
+
+
+ https://bleutner.github.io/RStoolbox/reference/superClass.html
+
+
+ https://bleutner.github.io/RStoolbox/reference/tasseledCap.html
+
+
+ https://bleutner.github.io/RStoolbox/reference/topCor.html
+
+
+ https://bleutner.github.io/RStoolbox/reference/unsuperClass.html
+
+
+ https://bleutner.github.io/RStoolbox/reference/validateMap.html
+
+
+ https://bleutner.github.io/RStoolbox/reference/writeSLI.html
+
+
diff --git a/spectralIndices.html b/spectralIndices.html
deleted file mode 100644
index 6fbc681..0000000
--- a/spectralIndices.html
+++ /dev/null
@@ -1,391 +0,0 @@
-R: Spectral Indices
-
-
-
spectralIndices {RStoolbox} R Documentation
-
-
Spectral Indices
-
-
Description
-
-
Calculate a suite of multispectral indices such as NDVI, SAVI etc. in an efficient way.
-
-
-
-
Usage
-
-
spectralIndices(
- img,
- blue = NULL,
- green = NULL,
- red = NULL,
- nir = NULL,
- redEdge1 = NULL,
- redEdge2 = NULL,
- redEdge3 = NULL,
- swir1 = NULL,
- swir2 = NULL,
- swir3 = NULL,
- scaleFactor = 1,
- skipRefCheck = FALSE,
- indices = NULL,
- index = NULL,
- maskLayer = NULL,
- maskValue = 1,
- coefs = list(L = 0.5, G = 2.5, L_evi = 1, C1 = 6, C2 = 7.5, s = 1, swir2ccc = NULL,
- swir2coc = NULL),
- ...
-)
-
-
-
-
Arguments
-
-
-img
-SpatRaster, Typically remote sensing imagery, which is to be classified.
- blue
-Character or integer. Blue band.
- green
-Character or integer. Green band.
- red
-Character or integer. Red band.
- nir
-Character or integer. Near-infrared band (700-1100nm).
- redEdge1
-Character or integer. Red-edge band (705nm)
- redEdge2
-Character or integer. Red-edge band (740nm)
- redEdge3
-Character or integer. Red-edge band (783nm)
- swir1
-not used
- swir2
-Character or integer. Short-wave-infrared band (1400-1800nm).
- swir3
-Character or integer. Short-wave-infrared band (2000-2500nm).
- scaleFactor
-Numeric. Scale factor for the conversion of scaled reflectances to [0,1] value range (applied as reflectance/scaleFactor) Neccesary for calculating EVI/EVI2 with scaled reflectance values.
- skipRefCheck
-Logical. When EVI/EVI2 is to be calculated there is a rough heuristic check, whether the data are inside [0,1]+/-0.5 (after applying a potential scaleFactor).
-If there are invalid reflectances, e.g. clouds with reflectance > 1 this check will result in a false positive and skip EVI calculation. Use this argument to skip this check in such cases *iff* you are sure the data and scaleFactor are valid.
- indices
-Character. One or more spectral indices to calculate (see Details). By default (NULL) all implemented indices given the spectral bands which are provided will be calculated.
- index
-Character. Alias for indices.
- maskLayer
-RasterLayer or SpatRaster containing a mask, e.g. clouds, for which pixels are set to NA. Alternatively a layername or -number can be provided if the mask is part of img.
- maskValue
-Integer. Pixel value in maskLayer which should be masked in output, i.e. will be set to NA in all calculated indices.
- coefs
-List of coefficients (see Details).
- ...
-further arguments such as filename etc. passed to writeRaster
-
-
-
-
Details
-
-
spectralIndices calculates all indices in one go in C++, which is more efficient than calculating each index separately (for large rasters).
-By default all indices which can be calculated given the specified indices will be calculated. If you don't want all indices, use the indices argument to specify exactly which indices are to be calculated.
-See the table bellow for index names and required bands.
-
-
Index values outside the valid value ranges (if such a range exists) will be set to NA. For example a pixel with NDVI > 1 will be set to NA.
-
-
-
-
- Index Description Source Bands Formula
-
-
- CLG Green-band Chlorophyll Index Gitelson2003 redEdge3, green redEdge3/green - 1
-
-
- CLRE Red-edge-band Chlorophyll Index Gitelson2003 redEdge3, redEdge1 redEdge3/redEdge1 - 1
-
-
- CTVI Corrected Transformed Vegetation Index Perry1984 red, nir (NDVI + 0.5)/sqrt(abs(NDVI + 0.5))
-
-
- DVI Difference Vegetation Index Richardson1977 red, nir s * nir - red
-
-
- EVI Enhanced Vegetation Index Huete1999 red, nir, blue G * ((nir - red)/(nir + C1 * red - C2 * blue + L_evi))
-
-
- EVI2 Two-band Enhanced Vegetation Index Jiang 2008 red, nir G * (nir - red)/(nir + 2.4 * red + 1)
-
-
- GEMI Global Environmental Monitoring Index Pinty1992 red, nir (((nir^2 - red^2) * 2 + (nir * 1.5) + (red * 0.5))/(nir + red + 0.5)) * (1 - ((((nir^2 - red^2) * 2 + (nir * 1.5) + (red * 0.5))/(nir + red + 0.5)) * 0.25)) - ((red - 0.125)/(1 - red))
-
-
- GNDVI Green Normalised Difference Vegetation Index Gitelson1998 green, nir (nir - green)/(nir + green)
-
-
- KNDVI Kernel Normalised Difference Vegetation Index Camps-Valls2021 red, nir tanh(((nir - red)/(nir + red)))^2
-
-
- MCARI Modified Chlorophyll Absorption Ratio Index Daughtery2000 green, red, redEdge1 ((redEdge1 - red) - (redEdge1 - green)) * (redEdge1/red)
-
-
- MNDWI Modified Normalised Difference Water Index Xu2006 green, swir2 (green - swir2)/(green + swir2)
-
-
- MSAVI Modified Soil Adjusted Vegetation Index Qi1994 red, nir nir + 0.5 - (0.5 * sqrt((2 * nir + 1)^2 - 8 * (nir - (2 * red))))
-
-
- MSAVI2 Modified Soil Adjusted Vegetation Index 2 Qi1994 red, nir (2 * (nir + 1) - sqrt((2 * nir + 1)^2 - 8 * (nir - red)))/2
-
-
- MTCI MERIS Terrestrial Chlorophyll Index DashAndCurran2004 red, redEdge1, redEdge2 (redEdge2 - redEdge1)/(redEdge1 - red)
-
-
- NBRI Normalised Burn Ratio Index Garcia1991 nir, swir3 (nir - swir3)/(nir + swir3)
-
-
- NDREI1 Normalised Difference Red Edge Index 1 GitelsonAndMerzlyak1994 redEdge2, redEdge1 (redEdge2 - redEdge1)/(redEdge2 + redEdge1)
-
-
- NDREI2 Normalised Difference Red Edge Index 2 Barnes2000 redEdge3, redEdge1 (redEdge3 - redEdge1)/(redEdge3 + redEdge1)
-
-
- NDVI Normalised Difference Vegetation Index Rouse1974 red, nir (nir - red)/(nir + red)
-
-
- NDVIC Corrected Normalised Difference Vegetation Index Nemani1993 red, nir, swir2 (nir - red)/(nir + red) * (1 - ((swir2 - swir2ccc)/(swir2coc - swir2ccc)))
-
-
- NDWI Normalised Difference Water Index McFeeters1996 green, nir (green - nir)/(green + nir)
-
-
- NDWI2 Normalised Difference Water Index Gao1996 nir, swir2 (nir - swir2)/(nir + swir2)
-
-
- NRVI Normalised Ratio Vegetation Index Baret1991 red, nir (red/nir - 1)/(red/nir + 1)
-
-
- REIP Red Edge Inflection Point GuyotAndBarnet1988 red, redEdge1, redEdge2, redEdge3 0.705 + 0.35 * ((red + redEdge3)/(2 - redEdge1))/(redEdge2 - redEdge1)
-
-
- RVI Ratio Vegetation Index red, nir red/nir
-
-
- SATVI Soil Adjusted Total Vegetation Index Marsett2006 red, swir2, swir3 (swir2 - red)/(swir2 + red + L) * (1 + L) - (swir3/2)
-
-
- SAVI Soil Adjusted Vegetation Index Huete1988 red, nir (nir - red) * (1 + L)/(nir + red + L)
-
-
- SLAVI Specific Leaf Area Vegetation Index Lymburger2000 red, nir, swir2 nir/(red + swir2)
-
-
- SR Simple Ratio Vegetation Index Birth1968 red, nir nir/red
-
-
- TTVI Thiam's Transformed Vegetation Index Thiam1997 red, nir sqrt(abs((nir - red)/(nir + red) + 0.5))
-
-
- TVI Transformed Vegetation Index Deering1975 red, nir sqrt((nir - red)/(nir + red) + 0.5)
-
-
- WDVI Weighted Difference Vegetation Index Richardson1977 red, nir nir - s * red
-
-
-
-
-
Some indices require additional parameters, such as the slope of the soil line which are specified via a list to the coefs argument.
-Although the defaults are sensible values, values like the soil brightnes factor L for SAVI should be adapted depending on the characteristics of the scene.
-The coefficients are:
-
-
-
-
-
-Coefficient Description Affected Indices
-
-
-
-s slope of the soil line DVI, WDVI
-
-
-
-L_evi, C1, C2, G various EVI
-
-
-
-L soil brightness factor SAVI, SATVI
-
-
-
-swir2ccc minimum swir2 value (completely closed forest canopy) NDVIC
-
-
-
-swir2coc maximum swir2 value (completely open canopy) NDVIC
-
-
-
-
-
-
-
-
-
The wavelength band names are defined following Schowengertd 2007, p10.
-The last column shows exemplarily which Landsat 5 TM bands correspond to which wavelength range definition.
-
-
-
-
- Band Description Wavl_min Wavl_max Landsat5_Band Sentinel2_Band
-
-
- vis visible 400 680 1,2,3 2,3,4
-
-
- red-edge1 red-edge1 680 720 - 5
-
-
- red-edge2 red-edge2 720 760 - 6
-
-
- red-edge3 red-edge3 760 800 - 7
-
-
- nir near infra-red 800 1100 4 8/8a
-
-
- swir1 short-wave infra-red 1100 1351 - 9,10
-
-
- swir2 short-wave infra-red 1400 1800 5 11
-
-
- swir3 short-wave infra-red 2000 2500 7 12
-
-
- mir1 mid-wave infra-red 3000 4000 - -
-
-
- mir2 mid-wave infra-red 45000 5000 - -
-
-
- tir1 thermal infra-red 8000 9500 - -
-
-
- tir2 thermal infra-red 10000 140000 6 -
-
-
-
-
-
-
-
Value
-
-
SpatRaster
-
-
-
-
Examples
-
-
library(ggplot2)
-library(terra)
-
-## Calculate NDVI
-ndvi <- spectralIndices(lsat, red = "B3_dn", nir = "B4_dn", indices = "NDVI")
-ndvi
-
-
## class : SpatRaster
-## dimensions : 310, 287, 1 (nrow, ncol, nlyr)
-## resolution : 30, 30 (x, y)
-## extent : 619395, 628005, -419505, -410205 (xmin, xmax, ymin, ymax)
-## coord. ref. : +proj=utm +zone=22 +ellps=WGS84 +towgs84=0,0,0,0,0,0,0 +units=m +no_defs
-## source(s) : memory
-## name : NDVI
-## min value : -0.5789474
-## max value : 0.7629630
-
-
ggR(ndvi, geom_raster = TRUE) +
- scale_fill_gradientn(colours = c("black", "white"))
-
-
-
## No test:
-
-## Calculate all possible indices, given the provided bands
-## Convert DNs to reflectance (required to calculate EVI and EVI2)
-mtlFile <- system.file("external/landsat/LT52240631988227CUB02_MTL.txt", package="RStoolbox")
-lsat_ref <- radCor(lsat, mtlFile, method = "apref")
-
-
## 01:39:38 | Bands to convert to reflectance: B1_dn, B2_dn, B3_dn, B4_dn, B5_dn, B7_dn
-
-
## 01:39:38 | Thermal bands to convert to brightness temperature: B6_dn
-
-
## 01:39:38 | Processing thermal band(s)
-
-
## 01:39:38 | Processing radiance / reflectance
-
-
SI <- spectralIndices(lsat_ref, red = "B3_tre", nir = "B4_tre")
-plot(SI)
-
-
-
## End(No test)
-
-
-
-
[Package
RStoolbox version 0.4.0
Index ]
-
R: SRTM Digital Elevation Model
-
-
-
srtm {RStoolbox} R Documentation
-
-
SRTM Digital Elevation Model
-
-
Description
-
-
DEM for the Landsat example area taken from SRTM v3 tile: s04_w050_1arc_v3.tif
-
-
-
-
Usage
-
-
srtm
-
-
-
-
Examples
-
-
ggR(srtm)
-
-
-
-
-
[Package
RStoolbox version 0.4.0
Index ]
-
R: Import separate Landsat files into single stack
-
-
-
stackMeta {RStoolbox} R Documentation
-
-
Import separate Landsat files into single stack
-
-
Description
-
-
Reads Landsat MTL or XML metadata files and loads single Landsat Tiffs into a rasterStack.
-Be aware that by default stackMeta() does NOT import panchromatic bands nor thermal bands with resolutions != 30m.
-
-
-
-
Usage
-
-
stackMeta(file, quantity = "all", category = "image", allResolutions = FALSE)
-
-
-
-
Arguments
-
-
-file
-Character. Path to Landsat MTL metadata (*_MTL.txt) file or an Landsat CDR xml metadata file (*.xml).
- quantity
-Character vector. Which quantity should be returned. Options: digital numbers ('dn'), top of atmosphere reflectance ('tre'), at surface reflectance ('sre'), brightness temperature ('bt'), spectral index ('index'), all quantities ('all').
- category
-Character vector. Which category of data to return. Options 'image': image data, 'pan': panchromatic image, 'index': multiband indices, 'qa' quality flag bands, 'all': all categories.
- allResolutions
-Logical. if TRUE a list will be returned with length = unique spatial resolutions.
-This argument was introduced to maintain backward compatibility and will be switched to TRUE in an upcoming release. Please base all new code on terra.
-
-
-
-
Value
-
-
Returns one single SpatRaster comprising all requested bands.
-If allResolutions = TRUE *and* there are different resolution layers (e.g. a 15m panchromatic band along wit 30m imagery) a list of RasterStacks will be returned.
-
-
-
-
Note
-
-
Be aware that by default stackMeta() does NOT import panchromatic bands nor thermal bands with resolutions != 30m. Use the allResolutions argument to import all layers.
-Note that nowadays the USGS uses cubic convolution to resample the TIR bands to 30m resolution.
-
-
-
-
Examples
-
-
## Example metadata file (MTL)
-mtlFile <- system.file("external/landsat/LT52240631988227CUB02_MTL.txt", package="RStoolbox")
-
-## Read metadata
-metaData <- readMeta(mtlFile)
-summary(metaData)
-
-
## Scene: LT52240631988227CUB02
-## Satellite: LANDSAT5
-## Sensor: TM
-## Date: 1988-08-14
-## Path/Row: 224/63
-## Projection: +proj=utm +zone=22 +units=m +datum=WGS84 +ellips=WGS84
-## Scene: PROJCRS["unknown",
-## BASEGEOGCRS["unknown",
-## DATUM["World Geodetic System 1984",
-## ELLIPSOID["WGS 84",6378137,298.257223563,
-## LENGTHUNIT["metre",1]],
-## ID["EPSG",6326]],
-## PRIMEM["Greenwich",0,
-## ANGLEUNIT["degree",0.0174532925199433],
-## ID["EPSG",8901]]],
-## CONVERSION["UTM zone 22N",
-## METHOD["Transverse Mercator",
-## ID["EPSG",9807]],
-## PARAMETER["Latitude of natural origin",0,
-## ANGLEUNIT["degree",0.0174532925199433],
-## ID["EPSG",8801]],
-## PARAMETER["Longitude of natural origin",-51,
-## ANGLEUNIT["degree",0.0174532925199433],
-## ID["EPSG",8802]],
-## PARAMETER["Scale factor at natural origin",0.9996,
-## SCALEUNIT["unity",1],
-## ID["EPSG",8805]],
-## PARAMETER["False easting",500000,
-## LENGTHUNIT["metre",1],
-## ID["EPSG",8806]],
-## PARAMETER["False northing",0,
-## LENGTHUNIT["metre",1],
-## ID["EPSG",8807]],
-## ID["EPSG",16022]],
-## CS[Cartesian,2],
-## AXIS["(E)",east,
-## ORDER[1],
-## LENGTHUNIT["metre",1,
-## ID["EPSG",9001]]],
-## AXIS["(N)",north,
-## ORDER[2],
-## LENGTHUNIT["metre",1,
-## ID["EPSG",9001]]]]
-##
-## Data:
-## FILES QUANTITY CATEGORY
-## B1_dn LT52240631988227CUB02_B1.TIF dn image
-## B2_dn LT52240631988227CUB02_B2.TIF dn image
-## B3_dn LT52240631988227CUB02_B3.TIF dn image
-## B4_dn LT52240631988227CUB02_B4.TIF dn image
-## B5_dn LT52240631988227CUB02_B5.TIF dn image
-## B6_dn LT52240631988227CUB02_B6.TIF dn image
-## B7_dn LT52240631988227CUB02_B7.TIF dn image
-##
-## Available calibration parameters (gain and offset):
-## dn -> radiance (toa)
-## dn -> brightness temperature (toa)
-
-
## Load rasters based on metadata file
-lsat <- stackMeta(mtlFile)
-lsat
-
-
## class : SpatRaster
-## dimensions : 310, 287, 7 (nrow, ncol, nlyr)
-## resolution : 30, 30 (x, y)
-## extent : 619395, 628005, -419505, -410205 (xmin, xmax, ymin, ymax)
-## coord. ref. : WGS 84 / UTM zone 22N (EPSG:32622)
-## sources : LT52240631988227CUB02_B1.TIF
-## LT52240631988227CUB02_B2.TIF
-## LT52240631988227CUB02_B3.TIF
-## ... and 4 more source(s)
-## names : B1_dn, B2_dn, B3_dn, B4_dn, B5_dn, B6_dn, ...
-## min values : 54, 18, 11, 4, 2, 131, ...
-## max values : 185, 87, 92, 127, 148, 146, ...
-
-
-
-
[Package
RStoolbox version 0.4.0
Index ]
-
R: Supervised Classification
-
-
-
superClass {RStoolbox} R Documentation
-
-
Supervised Classification
-
-
Description
-
-
Supervised classification both for classification and regression mode based on vector training data (points or polygons).
-
-
-
-
Usage
-
-
superClass(
- img,
- trainData,
- valData = NULL,
- responseCol = NULL,
- nSamples = 1000,
- nSamplesV = 1000,
- polygonBasedCV = FALSE,
- trainPartition = NULL,
- model = "rf",
- tuneLength = 3,
- kfold = 5,
- minDist = 2,
- mode = "classification",
- predict = TRUE,
- predType = "raw",
- filename = NULL,
- verbose,
- overwrite = TRUE,
- ...
-)
-
-
-
-
Arguments
-
-
-img
-SpatRaster. Typically remote sensing imagery, which is to be classified.
- trainData
-sf or sp spatial vector data containing the training locations (POINTs,or POLYGONs).
- valData
-Ssf or sp spatial vector data containing the validation locations (POINTs,or POLYGONs) (optional).
- responseCol
-Character or integer giving the column in trainData, which contains the response variable. Can be omitted, when trainData has only one column.
- nSamples
-Integer. Number of samples per land cover class. If NULL all pixels covered by training polygons are used (memory intensive!). Ignored if trainData consists of POINTs.
- nSamplesV
-Integer. Number of validation samples per land cover class. If NULL all pixels covered by validation polygons are used (memory intensive!). Ignored if valData consists of POINTs.
- polygonBasedCV
-Logical. If TRUE model tuning during cross-validation is conducted on a per-polygon basis. Use this to deal with overfitting issues. Does not affect training data supplied as SpatialPointsDataFrames.
- trainPartition
-Numeric. Partition (polygon based) of trainData that goes into the training data set between zero and one. Ignored if valData is provided.
- model
-Character. Which model to use. See train for options. Defaults to randomForest ('rf'). In addition to the standard caret models, a maximum likelihood classification is available via model = 'mlc'.
- tuneLength
-Integer. Number of levels for each tuning parameter (see train for details).
- kfold
-Integer. Number of cross-validation resamples during model tuning.
- minDist
-Numeric. Minumum distance between training and validation data,
-e.g. minDist=1 clips validation polygons to ensure a minimal distance of one pixel (pixel size according to img) to the next training polygon.
-Requires all data to carry valid projection information.
- mode
-Character. Model type: 'regression' or 'classification'.
- predict
-Logical. Produce a map (TRUE, default) or only fit and validate the model (FALSE).
- predType
-Character. Type of the final output raster. Either "raw" for class predictions or "prob" for class probabilities. Class probabilities are not available for all classification models (predict.train ).
- filename
-Path to output file (optional). If NULL, standard raster handling will apply, i.e. storage either in memory or in the raster temp directory.
- verbose
-Logical. prints progress and statistics during execution
- overwrite
-logical. Overwrite spatial prediction raster if it already exists.
- ...
-further arguments to be passed to train
-
-
-
-
Details
-
-
SuperClass performs the following steps:
-
-
-
- Ensure non-overlap between training and validation data. This is neccesary to avoid biased performance estimates.
-A minimum distance (minDist) in pixels can be provided to enforce a given distance between training and validation data.
-
- Sample training coordinates. If trainData (and valData if present) are polygons superClass will calculate the area per polygon and sample
-nSamples locations per class within these polygons. The number of samples per individual polygon scales with the polygon area, i.e. the bigger the polygon, the more samples.
-
- Split training/validation
-If valData was provided (reccomended) the samples from these polygons will be held-out and not used for model fitting but only for validation.
-If trainPartition is provided the trainingPolygons will be divided into training polygons and validation polygons.
-
- Extract raster data
-The predictor values on the sample pixels are extracted from img
-
- Fit the model. Using caret::train on the sampled training data the model will be fit,
-including parameter tuning (tuneLength) in kfold cross-validation. polygonBasedCV=TRUE will define cross-validation folds based on polygons (reccomended)
-otherwise it will be performed on a per-pixel basis.
-
- Predict the classes of all pixels in img based on the final model.
-
- Validate the model with the independent validation data.
-
-
-
-
-
-
Value
-
-
A superClass object (effectively a list) containing:
-
-
-
- $model: the fitted model
-
- $modelFit: model fit statistics
-
- $training: indexes of samples used for training
-
- $validation: list of
-
-
-
- $performance: performance estimates based on independent validation (confusion matrix etc.)
-
- $validationSamples: actual pixel coordinates plus reference and predicted values used for validation
-
- $validationGeometry: validation polygpns (clipped with mindist to training geometries)
-
-
-
- $map: the predicted raster
-
- $classMapping: a data.frame containing an integer <-> label mapping
-
-
-
-
-
-
See Also
-
-
train
-
-
-
Examples
-
-
library(caret)
-library(randomForest)
-
-
## Warning: package 'randomForest' was built under R version 4.2.3
-
-
## randomForest 4.7-1.1
-
-
## Type rfNews() to see new features/changes/bug fixes.
-
-
##
-## Attaching package: 'randomForest'
-
-
## The following object is masked from 'package:gridExtra':
-##
-## combine
-
-
## The following object is masked from 'package:ggplot2':
-##
-## margin
-
-
library(e1071)
-
-
## Warning: package 'e1071' was built under R version 4.2.3
-
-
##
-## Attaching package: 'e1071'
-
-
## The following object is masked from 'package:terra':
-##
-## interpolate
-
-
library(terra)
-train <- readRDS(system.file("external/trainingPoints.rds", package="RStoolbox"))
-
-## Plot training data
-olpar <- par(no.readonly = TRUE) # back-up par
-par(mfrow=c(1,2))
-colors <- c("yellow", "green", "deeppink")
-plotRGB(rlogo)
-plot(train, add = TRUE, col = colors[train$class], pch = 19)
-
-## Fit classifier (splitting training into 70% training data, 30% validation data)
-SC <- superClass(rlogo, trainData = train, responseCol = "class",
-model = "rf", tuneLength = 1, trainPartition = 0.7)
-
-
## 01:39:41 | Begin sampling training data
-
-
## 01:39:41 | Starting to fit model
-
-
## 01:39:42 | Starting spatial predict
-
-
## 01:39:42 | Begin validation
-
-
## ******************** Model summary ********************
-
-
## Random Forest
-##
-## 21 samples
-## 3 predictor
-## 3 classes: 'A', 'B', 'C'
-##
-## No pre-processing
-## Resampling: Cross-Validated (5 fold)
-## Summary of sample sizes: 16, 18, 17, 16, 17
-## Resampling results:
-##
-## Accuracy Kappa
-## 1 1
-##
-## Tuning parameter 'mtry' was held constant at a value of 1
-## [[1]]
-## TrainAccuracy TrainKappa method
-## 1 1 1 rf
-##
-## [[2]]
-## Cross-Validated (5 fold) Confusion Matrix
-##
-## (entries are average cell counts across resamples)
-##
-## Reference
-## Prediction A B C
-## A 1.4 0.0 0.0
-## B 0.0 1.4 0.0
-## C 0.0 0.0 1.4
-##
-## Accuracy (average) : 1
-
-
## ******************** Validation summary ********************
-
-
## Confusion Matrix and Statistics
-##
-## Reference
-## Prediction A B C
-## A 3 0 0
-## B 0 3 0
-## C 0 0 3
-##
-## Overall Statistics
-##
-## Accuracy : 1
-## 95% CI : (0.6637, 1)
-## No Information Rate : 0.3333
-## P-Value [Acc > NIR] : 5.081e-05
-##
-## Kappa : 1
-##
-## Mcnemar's Test P-Value : NA
-##
-## Statistics by Class:
-##
-## Class: A Class: B Class: C
-## Sensitivity 1.0000 1.0000 1.0000
-## Specificity 1.0000 1.0000 1.0000
-## Pos Pred Value 1.0000 1.0000 1.0000
-## Neg Pred Value 1.0000 1.0000 1.0000
-## Prevalence 0.3333 0.3333 0.3333
-## Detection Rate 0.3333 0.3333 0.3333
-## Detection Prevalence 0.3333 0.3333 0.3333
-## Balanced Accuracy 1.0000 1.0000 1.0000
-
-
SC
-
-
## superClass results
-## ************ Validation **************
-## $validation
-## Confusion Matrix and Statistics
-##
-## Reference
-## Prediction A B C
-## A 3 0 0
-## B 0 3 0
-## C 0 0 3
-##
-## Overall Statistics
-##
-## Accuracy : 1
-## 95% CI : (0.6637, 1)
-## No Information Rate : 0.3333
-## P-Value [Acc > NIR] : 5.081e-05
-##
-## Kappa : 1
-##
-## Mcnemar's Test P-Value : NA
-##
-## Statistics by Class:
-##
-## Class: A Class: B Class: C
-## Sensitivity 1.0000 1.0000 1.0000
-## Specificity 1.0000 1.0000 1.0000
-## Pos Pred Value 1.0000 1.0000 1.0000
-## Neg Pred Value 1.0000 1.0000 1.0000
-## Prevalence 0.3333 0.3333 0.3333
-## Detection Rate 0.3333 0.3333 0.3333
-## Detection Prevalence 0.3333 0.3333 0.3333
-## Balanced Accuracy 1.0000 1.0000 1.0000
-##
-## *************** Map ******************
-## $map
-## class : SpatRaster
-## dimensions : 77, 101, 1 (nrow, ncol, nlyr)
-## resolution : 1, 1 (x, y)
-## extent : 0, 101, 0, 77 (xmin, xmax, ymin, ymax)
-## coord. ref. : +proj=merc +lon_0=0 +k=1 +x_0=0 +y_0=0 +ellps=WGS84 +towgs84=0,0,0,0,0,0,0 +units=m +no_defs
-## source(s) : memory
-## name : class
-## min value : 1
-## max value : 3
-
-
## Plots
-plot(SC$map, col = colors, legend = FALSE, axes = FALSE, box = FALSE)
-legend(1,1, legend = levels(train$class), fill = colors , title = "Classes",
-horiz = TRUE, bty = "n")
-
-
-
par(olpar) # reset par
-
-
-
-
[Package
RStoolbox version 0.4.0
Index ]
-
R: Tasseled Cap Transformation
-
-
-
tasseledCap {RStoolbox} R Documentation
-
-
Tasseled Cap Transformation
-
-
Description
-
-
Calculates brightness, greenness and wetness from multispectral imagery.
-Currently implemented Landsat 4 TM, Landsat 5 TM, Landsat 7ETM+, Landsat 8 OLI, MODIS, QuickBird, Spot5 and RapidEye.
-
-
-
-
Usage
-
-
tasseledCap(img, sat, ...)
-
-
-
-
Arguments
-
-
-img
-RasterBrick or RasterStack or SpatRaster. Input image. Band order must correspond to sensor specifications (see Details and Examples)
- sat
-Character. Sensor; one of: c("Landsat4TM", "Landsat5TM", "Landsat7ETM", "Landsat8OLI", "MODIS", "QuickBird", "Spot5", "RapidEye"). Case is irrelevant.
- ...
-Further arguments passed to writeRaster.
-
-
-
-
Details
-
-
Currently implemented: Landsat 4 TM, Landsat 5 TM, Landsat 7ETM+, Landsat 8 OLI, MODIS, QuickBird, Spot5, RapdiEye.
-Input data must be in top of atmosphere reflectance.
-Moreover, bands must be provided in ascending order as listed in the table below.
-Irrelevant bands, such as Landsat Thermal Bands or QuickBird/Spot5 Panchromatic Bands must be omitted.
-Required bands are:
-
-
-
-
-
- sat bands coefficients data unit
-
-
-
- Landsat4TM 1,2,3,4,5,7 Crist 1985 reflectance
-
-
-
- Landsat5TM 1,2,3,4,5,7 Crist 1985 reflectance
-
-
-
- Landsat7ETM 1,2,3,4,5,7 Huang 2002 reflectance
-
-
-
- Landsat8OLI 2,3,4,5,6,7 Baig 2014 reflectance
-
-
-
- MODIS 1,2,3,4,5,6,7 Lobser 2007 reflectance
-
-
-
- QuickBird 2,3,4,5 Yarbrough 2005 reflectance
-
-
-
- Spot5 2,3,4,5 Ivtis 2008 reflectance
-
-
-
- RapidEye 1,2,3,4,5 Schoenert 2014 reflectance
-
-
-
-
-
-
-
-
-
-
-
Value
-
-
Returns a SpatRaster with the thee bands: brigthness, greenness, and (soil) wetness.
-
-
-
-
References
-
-
Crist (1985) "A TM Tasseled Cap Equivalent Transformation for Reflectance Factor Data." Remote Sensing of Environment 17 (3): 301-306
-
-
Huang et al. (2002) "Derivation of a Tasselled Cap Transformation Based on Landsat 7 At-Satellite Reflectance." International Journal of Remote Sensing 23 (8): 1741-1748
-
-
Baig et al. (2014) "Derivation of a Tasselled Cap Transformation Based on Landsat 8 At-Satellite Reflectance." Remote Sensing Letters 5 (5): 423-431.
-
-
Lobser et al. (2007) "MODIS Tasselled Cap: Land Cover Characteristics Expressed through Transformed MODIS Data." International Journal of Remote Sensing 28 (22): 5079-5101.
-
-
Yarbrough et al. (2005) "QuickBird 2 tasseled cap transform coefficients: a comparison of derivation methods." Pecora 16 Global Priorities in Land Remote Sensing: 23-27.
-
-
Ivits et al. (2008) "Orthogonal transformation of segmented SPOT5 images." Photogrammetric Engineering & Remote Sensing 74 (11): 1351-1364.
-
-
Schoenert et al. (2014) "Derivation of tasseled cap coefficients for RapidEye data." Earth Resources and Environmental Remote Sensing/GIS Applications V (9245): 92450Qs.
-
-
-
-
Examples
-
-
library(terra)
-
-## Run tasseled cap (exclude thermal band 6)
-lsat_tc <- tasseledCap(lsat[[c(1:5,7)]], sat = "Landsat5TM")
-lsat_tc
-
-
## class : SpatRaster
-## dimensions : 310, 287, 3 (nrow, ncol, nlyr)
-## resolution : 30, 30 (x, y)
-## extent : 619395, 628005, -419505, -410205 (xmin, xmax, ymin, ymax)
-## coord. ref. : WGS 84 / UTM zone 22N (EPSG:32622)
-## source(s) : memory
-## names : brightness, greenness, wetness
-## min values : 33.0776, -21.2454, 10.9682
-## max values : 254.0931, 69.6422, 122.4285
-
-
plot(lsat_tc)
-
-
-
-
-
[Package
RStoolbox version 0.4.0
Index ]
-
R: Topographic Illumination Correction
-
-
-
topCor {RStoolbox} R Documentation
-
-
Topographic Illumination Correction
-
-
Description
-
-
account and correct for changes in illumination due to terrain elevation.
-
-
-
-
Usage
-
-
topCor(
- img,
- dem,
- metaData,
- solarAngles = c(),
- method = "C",
- stratImg = NULL,
- nStrat = 5,
- illu,
- ...
-)
-
-
-
-
Arguments
-
-
-img
-SpatRaster. Imagery to correct
- dem
-SpatRaster. Either a digital elevation model as a RasterLayer or a RasterStack/Brick with pre-calculated slope and aspect (see terrain ) in which case the layers must be named 'slope' and 'aspect'.
-Must have the same dimensions as img.
- metaData
-Character, ImageMetaData. Either a path to a Landsat meta-data file (MTL) or an ImageMetaData object (see readMeta )
- solarAngles
-Numeric vector containing sun azimuth and sun zenith (in radians and in that order). Not needed if metaData is provided
- method
-Character. One of c("cos", "avgcos", "minnaert", "C", "stat", "illu"). Choosing 'illu' will return only the local illumination map.
- stratImg
-RasterLayer or SpatRaster to define strata, e.g. NDVI. Or the string 'slope' in which case stratification will be on nStrat slope classes. Only relevant if method = 'minnaert'.
- nStrat
-Integer. Number of bins or quantiles to stratify by. If a bin has less than 50 samples it will be merged with the next bin. Only relevant if method = 'minnaert'.
- illu
-SpatRaster. Optional pre-calculated ilumination map. Run topCor with method="illu" to calculate an ilumination map
- ...
-arguments passed to writeRaster
-
-
-
-
Details
-
-
For detailed discussion of the various approaches please see Riano et al. (2003).
-
-
The minnaert correction can be stratified for different landcover characteristics. If stratImg = 'slope' the analysis is stratified by the slope,
-i.e. the slope values are divided into nStrat classes and the correction coefficient k is calculated and applied separately for each slope class.
-An alternative could be to stratify by a vegetation index in which case an additional raster layer has to be provided via the stratImg argument.
-
-
-
-
Value
-
-
SpatRaster
-
-
-
-
References
-
-
Riano et al. (2003) Assessment of different topographic correction in Landsat-TM data for mapping vegetation types. IEEE Transactions on Geoscience and Remote Sensing.
-
-
-
-
Examples
-
-
## Load example data
-metaData <- system.file("external/landsat/LT52240631988227CUB02_MTL.txt", package="RStoolbox")
-metaData <- readMeta(metaData)
-
-## Minnaert correction, solar angles from metaData
-lsat_minnaert <- topCor(lsat, dem = srtm, metaData = metaData, method = "minnaert")
-
-
## 01:39:44 | Calculate slope and aspect
-
-
## 01:39:44 | Calculate illumination map
-
-
## 01:39:44 | Correct imagery
-
-
## 01:39:44 | Estimate coefficients
-
-
## C correction, solar angles provided manually
-lsat_C <- topCor(lsat, dem = srtm, solarAngles = c(1.081533, 0.7023922), method = "C")
-
-
## 01:39:44 | Calculate slope and aspect
-
-
## 01:39:44 | Calculate illumination map
-
-
## 01:39:44 | Correct imagery
-
-
## 01:39:44 | Estimate coefficients
-
-
## Warning: [*] CRS do not match
-
-
-
-
[Package
RStoolbox version 0.4.0
Index ]
-
R: Unsupervised Classification
-
-
-
unsuperClass {RStoolbox} R Documentation
-
-
Unsupervised Classification
-
-
Description
-
-
Unsupervised clustering of SpatRaster data using kmeans clustering
-
-
-
-
Usage
-
-
unsuperClass(
- img,
- nSamples = 10000,
- nClasses = 5,
- nStarts = 25,
- nIter = 100,
- norm = FALSE,
- clusterMap = TRUE,
- algorithm = "Hartigan-Wong",
- output = "classes",
- ...
-)
-
-
-
-
Arguments
-
-
-img
-SpatRaster.
- nSamples
-Integer. Number of random samples to draw to fit cluster map. Only relevant if clusterMap = TRUE.
- nClasses
-Integer. Number of classes.
- nStarts
-Integer. Number of random starts for kmeans algorithm.
- nIter
-Integer. Maximal number of iterations allowed.
- norm
-Logical. If TRUE will normalize img first using normImage . Normalizing is beneficial if your predictors have different scales.
- clusterMap
-Logical. Fit kmeans model to a random subset of the img (see Details).
- algorithm
-Character. kmeans algorithm. One of c("Hartigan-Wong", "Lloyd", "MacQueen")
- output
-Character. Either 'classes' (kmeans class; default) or 'distances' (euclidean distance to each cluster center).
- ...
-further arguments to be passed to writeRaster , e.g. filename
-
-
-
-
Details
-
-
Clustering is done using kmeans clusterMap=FALSE), however this can be slow and is
-not memory safe. Therefore if you have large raster data (> memory), as is typically the case with remote sensing imagery it is advisable to choose clusterMap=TRUE (the default).
-This means that a kmeans cluster model is calculated based on a random subset of pixels (nSamples). Then the distance of *all* pixels to the cluster centers
-is calculated in a stepwise fashion using predict
-
The solution of the kmeans algorithm often depends on the initial configuration of class centers which is chosen randomly.
-Therefore, kmeans is usually run with multiple random starting configurations in order to find a convergent solution from different starting configurations.
-The nStarts argument allows to specify how many random starts are conducted.
-
-
-
-
Value
-
-
Returns an RStoolbox::unsuperClass object, which is a list containing the kmeans model ($model) and the raster map ($map).
-For output = "classes", $map contains a SpatRaster with discrete classes (kmeans clusters); for output = "distances" $map contains
-a SpatRaster, with 'nClasses' layers, where each layer maps the euclidean distance to the corresponding class centroid.
-
-
-
-
Examples
-
-
## Not run:
-##D library(terra)
-##D input <- rlogo
-##D
-##D ## Plot
-##D olpar <- par(no.readonly = TRUE) # back-up par
-##D par(mfrow=c(1,2))
-##D plotRGB(input)
-##D
-##D ## Run classification
-##D set.seed(25)
-##D unC <- unsuperClass(input, nSamples = 100, nClasses = 5, nStarts = 5)
-##D unC
-##D
-##D ## Plots
-##D colors <- rainbow(5)
-##D plot(unC$map, col = colors, legend = FALSE, axes = FALSE, box = FALSE)
-##D legend(1,1, legend = paste0("C",1:5), fill = colors, title = "Classes", horiz = TRUE, bty = "n")
-##D
-##D ## Return the distance of each pixel to each class centroid
-##D unC <- unsuperClass(input, nSamples = 100, nClasses = 3, output = "distances")
-##D unC
-##D
-##D ggR(unC$map, 1:3, geom_raster = TRUE)
-##D
-##D par(olpar) # reset par
-## End(Not run)
-
-
-
-
[Package
RStoolbox version 0.4.0
Index ]
-
R: Map accuracy assessment
-
-
-
validateMap {RStoolbox} R Documentation
-
-
Map accuracy assessment
-
-
Description
-
-
validate a map from a classification or regression model. This can be useful to update the accuracy assessment after filtering, e.g. for a minimum mapping unit.
-
-
-
-
Usage
-
-
validateMap(
- map,
- valData,
- responseCol,
- nSamplesV = 500,
- mode = "classification",
- classMapping = NULL
-)
-
-
-
-
Arguments
-
-
-map
-RasterLayer or SpatRaster. The classified map.
- valData
-sf object with validation data (POLYGONs or POINTs).
- responseCol
-Character. Column containing the validation data in attribute table of valData.
- nSamplesV
-Integer. Number of pixels to sample for validation (only applies to polygons).
- mode
-Character. Either 'classification' or 'regression'.
- classMapping
-optional data.frame with columns 'class' and 'classID' defining the mapping from raster integers to class names.
-
-
-
-
Value
-
-
Returns a structured list includng the preformance and confusion-matrix of your then validated input data
-
-
-
-
Examples
-
-
library(caret)
-library(terra)
-
-## Training data
-poly <- readRDS(system.file("external/trainingPolygons.rds", package="RStoolbox"))
-
-## Split training data in training and validation set (50%-50%)
-splitIn <- createDataPartition(poly$class, p = .5)[[1]]
-train <- poly[splitIn,]
-val <- poly[-splitIn,]
-
-## Classify (deliberately poorly)
-sc <- superClass(lsat, trainData = train, responseCol = "class", nSamples = 50, model = "mlc")
-
-
## 01:39:45 | Begin sampling training data
-
-
## 01:39:45 | Starting to fit model
-
-
## 01:39:45 | Starting spatial predict
-
-
## ******************** Model summary ********************
-
-
## Maximum Likelihood Classification
-##
-## 251 samples
-## 7 predictor
-## 4 classes: 'cleared', 'fallen_dry', 'forest', 'water'
-##
-## No pre-processing
-## Resampling: Cross-Validated (5 fold)
-## Summary of sample sizes: 201, 201, 201, 200, 201
-## Resampling results:
-##
-## Accuracy Kappa
-## 0.996 0.9945887
-##
-## [[1]]
-## TrainAccuracy TrainKappa method
-## 1 0.996 0.9945887 custom
-##
-## [[2]]
-## Cross-Validated (5 fold) Confusion Matrix
-##
-## (entries are average cell counts across resamples)
-##
-## Reference
-## Prediction cleared fallen_dry forest water
-## cleared 14.0 0.0 0.2 0.0
-## fallen_dry 0.0 8.2 0.0 0.0
-## forest 0.0 0.0 13.8 0.0
-## water 0.0 0.0 0.0 14.0
-##
-## Accuracy (average) : 0.996
-
-
## ******************** Validation summary ********************
-
-
## [1] "No independent validation was performed!"
-
-
## Polish map with majority filter
-
-polishedMap <- focal(sc$map, matrix(1,3,3), fun = modal)
-
-## Validation
-## Before filtering
-val0 <- validateMap(sc$map, valData = val, responseCol = "class",
- classMapping = sc$classMapping)
-## After filtering
-val1 <- validateMap(polishedMap, valData = val, responseCol = "class",
- classMapping = sc$classMapping)
-
-
-
-
[Package
RStoolbox version 0.4.0
Index ]
-
R: Write ENVI spectral libraries
-
-
-
writeSLI {RStoolbox} R Documentation
-
-
Write ENVI spectral libraries
-
-
Description
-
-
Writes binary ENVI spectral library files (sli) with accompanying header (.sli.hdr) files OR ASCII spectral library files in ENVI format.
-
-
-
-
Usage
-
-
writeSLI(
- x,
- path,
- wavl.units = "Micrometers",
- scaleF = 1,
- mode = "bin",
- endian = .Platform$endian
-)
-
-
-
-
Arguments
-
-
-x
-data.frame with first column containing wavelengths and all other columns containing spectra.
- path
-path to spectral library file to be created.
- wavl.units
-wavelength units. Defaults to Micrometers. Nanometers is another typical option.
- scaleF
-optional reflectance scaling factor. Defaults to 1.
- mode
-character string specifying output file type. Must be one of "bin" for binary .sli files or "ASCII" for ASCII ENVI plot files.
- endian
-character. Optional. By default the endian is determined based on the platform, but can be forced manually by setting it to either "little" or "big".
-
-
-
-
Details
-
-
ENVI spectral libraries with ending .sli are binary arrays with spectra saved in rows.
-
-
-
-
Value
-
-
Does not return anything, write the SLI file directly to your drive for where your specified your path parameter
-
-
-
-
See Also
-
-
readSLI
-
-
-
Examples
-
-
## Example data
-sliFile <- system.file("external/vegSpec.sli", package="RStoolbox")
-sliTmpFile <- paste0(tempdir(),"/vegetationSpectra.sli")
-
-## Read spectral library
-sli <- readSLI(sliFile)
-head(sli)
-
-
## wavelength veg_stressed veg_vital
-## 1 350 0.008958003 0.008836994
-## 2 351 0.008910760 0.008909440
-## 3 352 0.008874181 0.008972186
-## 4 353 0.008847097 0.009025744
-## 5 354 0.008829174 0.009071405
-## 6 355 0.008819440 0.009109739
-
-
plot(sli[,1:2], col = "orange", type = "l")
-lines(sli[,c(1,3)], col = "green")
-
-
-
## Write to binary spectral library
-writeSLI(sli, path = sliTmpFile)
-
-
-
-
[Package
RStoolbox version 0.4.0
Index ]
-
![[R logo]](http://stat.ethz.ch/R-manual/R-devel/doc/html/Rlogo.svg)
-![[Up]](http://stat.ethz.ch/R-manual/R-devel/doc/html/left.jpg)
-![[Top]](http://stat.ethz.ch/R-manual/R-devel/doc/html/up.jpg)
-
