Next Article in Journal
Albedo Impacts of Changing Agricultural Practices in the United States through Space-Borne Analysis
Next Article in Special Issue
A Hybrid Data Balancing Method for Classification of Imbalanced Training Data within Google Earth Engine: Case Studies from Mountainous Regions
Previous Article in Journal
Applicability Evaluation of Multisource Satellite Precipitation Data for Hydrological Research in Arid Mountainous Areas
Previous Article in Special Issue
Compact Cloud Detection with Bidirectional Self-Attention Knowledge Distillation
 
 
Font Type:
Arial Georgia Verdana
Font Size:
Aa Aa Aa
Line Spacing:
Column Width:
Background:
Article

A Comparison of Three Temporal Smoothing Algorithms to Improve Land Cover Classification: A Case Study from NEPAL

1
International Centre for Integrated Mountain Development, Kathmandu GPO Box 3226, Nepal
2
Spatial Informatics Group, LLC, 2529 Yolanda Ct., Pleasanton, CA 94566, USA
3
SERVIR-Mekong, SM Tower, 24th Tower, 979/69 Paholyothin Road, Samsen Nai, Phayathai, Bangkok 10400, Thailand
*
Author to whom correspondence should be addressed.
Remote Sens. 2020, 12(18), 2888; https://0-doi-org.brum.beds.ac.uk/10.3390/rs12182888
Submission received: 15 June 2020 / Revised: 12 August 2020 / Accepted: 14 August 2020 / Published: 6 September 2020

Abstract

:
Time series land cover data statistics often fluctuate abruptly due to seasonal impact and other noise in the input image. Temporal smoothing techniques are used to reduce the noise in time series data used in land cover mapping. The effects of smoothing may vary based on the smoothing method and land cover category. In this study, we compared the performance of Fourier transformation smoothing, Whittaker smoother and Linear-Fit averaging smoother on Landsat 5, 7 and 8 based yearly composites to classify land cover in Province No. 1 of Nepal. The performance of each smoother was tested based on whether it was applied on image composites or on land cover primitives generated using the random forest machine learning method. The land cover data used in the study was from the years 2000 to 2018. Probability distribution was examined to check the quality of primitives and accuracy of the final land cover maps were accessed. The best results were found for the Whittaker smoothing for stable classes and Fourier smoothing for other classes. The results also show that classification using a properly selected smoothing algorithm outperforms a classification based on its unsmoothed data set. The final land cover generated by combining the best results obtained from different smoothing approaches increased our overall land cover map accuracy from 79.18% to 83.44%. This study shows that smoothing can result in a substantial increase in the quality of the results and that the smoothing approach should be carefully considered for each land cover class.

Graphical Abstract

1. Introduction

Thematic land cover and forest maps are important sources of information for managers and policy makers for local and national-level policies and development strategies [1,2,3,4]. Important decisions regarding land use allocation, food production, hydrological modelling and natural resource management need to be supported by accurate information on spatial and temporal land cover dynamics which is occurring at a tremendous rate [3,5,6,7]. Remote sensing is a widely-accepted method for land cover classification. Since commercial high resolution images, free medium resolution images and open source cloud computing platforms are becoming more available, using machine learning (ML) techniques to classify land cover types with remotely-sensed data has gained popularity [8,9].
Dealing with noise is one of the main challenges in satellite image classification schemes. Satellite images can contain noise from different sources. Atmospheric effects while the image is taken, sensor degradation and thermal noise, and processing of signals received by sensors are some of the sources that can introduce noise to the images [10]. Noise might propagate through the classification scheme and negatively affect the performance of the model and quality of the outputs [10,11]. Pixel-based classifications in particular were found to be especially sensitive to noise as a considerable proportion of the signal of a pixel might come from the surrounding pixels [12,13]. Various techniques have been proposed to reduce the impact of noise. These methods include pre-processing of the input images or post-processing the results [12].
Even without these processes, random forest, among other machine learning methods, has been found to adapt and reduce the impacts of noise. This is because it uses bootstrapping and random split construction unlike other algorithms [14]. Random forest has been found to perform well in similar classification problems [15]. While convolution neural networks (CNN) has been gaining momentum in the remote sensing community, it is still a budding field and needs more research [16]. Another method to reduce noise and improve classification accuracy is the use of time-series remote sensing data [17,18]. However, one caveat to this technique is that image noise and sensor-introduced noises from individual scenes compound when information from multiple scenes are combined. This is because, if even one scene has noise it can impact the whole series. [19,20]. The issue of noise can also be remedied by smoothing the data either early in the process or before final assemblage of a land cover map so that the noise and inconsistencies are filtered out.
Smoothing is a method of identifying the underlying structure of data such as trends [21,22]. There are multiple studies that explore the use of smoothing algorithms on time-series data in order to reduce noise. For example, Lunetta et al. [20] explored the use of Fourier transformation on normalized difference vegetation index (NDVI) values; Chen et al. [23], Cao et al. [24] applied smoothing to vegetation index data by using a modified Savitzky–Golay filter; Jonsson and Eklundh [25,26] developed the TIMESAT software package, which can assimilate Savitzky–Golay, asymmetric Gaussian, and double-logistic algorithms to smooth NDVI time-series data from different sensors. However, these smoothing algorithms were found to be mathematically complex and computationally intensive. Therefore, various groups proposed methodologies that simplify the process. For example, Sakamoto et al. [27], Geerken et al. [28] explored the use of Fourier transforms for smoothing NDVI data, where the raw data is converted to harmonics and then frequencies corresponding to noise are removed. Eilers [29] introduced the Whittaker smoother, which uses a simple algorithm that runs quickly, yet still balances the fidelity of noisy data with the smoothness of the resulting curve [30]. The Whittaker smoother has also been recently adopted in Google Earth Engine (GEE) to smooth MODIS EVI time series data [31]. Khanal et al. also used the Whittaker smoother to map built-up areas of Kathmandu with improvements in results [32].
Techniques for smoothing remote sensing data have been widely-used; however, there are few studies that compare the smoothing algorithms themselves. Shao et al. [33] focused on smoothing MODIS-NDVI data to support land cover classification. However, since classifications using ML algorithms use more than just NDVI data, studies on how smoothing multiple input features and then training models with this data are needed. Similarly, Atkinson et al. [34] compared Fourier, Whittaker Smoother, Asymmetric Gaussian and Double Logistic smoothing approaches on phenology. Other studies have been done to test the performance of multiple smoothers on MODIS-LAI products [35] and hyper-spectral imagery [36] as well. Performance of some smoothers have also been tested in the context of land cover but with smoothers such as majority filter, Gaussian smoothing and bilateral filtering [37].
This study follows the Regional Land Cover Monitoring System (RLCMS) approach to perform land cover classification [38,39]. RLCMS is a joint USAID and NASA collaborative project that provides support to dedicated development and sustainable landscape projects [40]. This approach introduces the concept of primitives, which can be described as biophysical layers that represent information required to segregate land cover types [38,41,42], for example, tree canopy cover for forest/non-forest classification. The primitives are prepared from composites that are pre-processed with cloud/shadow masking, BRDF correction and terrain correction. ML techniques such as random forest are then used to generate primitives in the form of probability layers [38,40]. These primitives are then used in accordance with land cover typology in a decision tree that outputs required land cover map. While a land cover type can depend on multiple primitives, in this study we focus on definitions that allow single primitives per type as our focus is on studying the impact of smoothing rather than building an extensive land cover map.
Saah et al. [38] applied the Whittaker smoothing algorithm on primitive layers before assembling the final land cover map to stabilize the time-series and remove noise. However, they did not explore and evaluate the impact of including smoothing at a different stage of the image processing. Moreover, specific primitives or land cover classes may show better performance using a different smoothing algorithm. Therefore, this study explores the impact of temporal smoothing on image classification accuracy by following the RLCMS methodology and testing the approaches across all the classes in multiple stages of the workflow. This was done by applying three different smoothing algorithms on eight land cover classes. We compared the final accuracy of applying smoothing during pre-processing and post-processing. This study will help guide future work on land cover mapping on the appropriate choice for smoothing methodologies towards increasing the accuracy of the final results.

2. Materials and Methods

2.1. Study Area

Province No. 1, the easternmost province of Nepal, was selected as the study area. The province stretches from approximately 88.2217°E to 86.1358°E and 28.1310°N to 26.3298°N. This area was chosen because it has extensive topographical and land cover type variation within a short north–south distance: the south contains the flat plains of the Terai region, which progress to hills and snowy mountains in the north. The 2010 land cover map of Nepal (Figure 1) shows that the study region contains all land cover types presented by Uddin et al. [43].

2.2. Land Cover Typology

The land cover maps of Nepal prepared by Uddin et al. [43] were used to develop the land cover typology for this study. From the 12 classes presented in the Uddin et al. land cover map, we derived eight classes to further examine. For this study all forests were consolidated into a single class. Additionally, we created a new class “river bed” in order to obtain better segregation from classes such as built-up and barren land. When not separated, river beds have a tendency to be classified as either built-up or barren land with no real consistency. The complete typology used for this study is shown in Table 1.

2.3. Reference Data Collection

The reference data were labelled using visual interpretation using Collect Earth [44,45] where the plot size was set to equal the spatial resolution of the 30 m Landsat images that were used in land cover mapping. Each plot had 49 points which were labelled according to observed land cover type. The plots were generated on a systematic grid with 2 km between sample plots and additional reference points were added with opportunistic sampling for underrepresented classes. The label land cover type for each plot was derived based on the majority type occurrence within the plot. The training points and validation points were randomly split from this reference data set with 86,093 points being used for training and 4299 for validation. The distributions of these points can be seen on Appendix A. The maximum number of points per class for validation was capped in order to avoid skewed accuracy because of a large number of points in a more accurate class. Because of persistent cloud covers, from 4307 validation data only 3677 points were used to perform accuracy assessment.

2.4. Land Cover Classification

The overall methodology of classification and comparison using various approaches is shown in Figure 2.

2.4.1. Optical Image Processing

Landsat 5, 7 and 8 surface reflectance images in GEE were used to prepare time series composites from the years 2000 to 2018. First, each scene was pre-processed by shadow masking, cloud masking, and then applying BRDF and topographic corrections [40]. The pre-processed scenes were used to create yearly composites. In order to prepare these composites, six bands from each scene were used: blue, green, red, nir, swir1 and swir2. The closest real pixel to the median, referred to as ’medoid’, 20 percentile and 80 percentile of those bands were stored in a composite. Additionally, 20 and 80 percentile of NDVI, NDWI were also stored. In addition, information from auxiliary layers such as the JRC global water and SRTM DEM layers were added to the composite. The resulting layer, along with labelled reference data, was used to create primitives for each land cover type. The primitives were generated using a random forest classifier with 100 trees. Feature importance was also calculated to avoid overfitting. These primitives were then run through a decision tree classifier to obtain the final land cover maps.

2.4.2. Application of Smoothing

Three smoothing algorithms were tested using two different approaches, while everything else was kept constant. In the first approach, smoothing was applied during pre-processing on the composites where all spectral bands were smoothed temporally within our study period starting from 2000 and extending to 2018. These smoothed bands were then combined with the reference data to train a random forest classifier. This classifier was next used to create primitives for each class. This technique was repeated with each of the three smoothing algorithms. In our second approach, primitives for each class were first prepared using composites without smoothing and reference data. Then, each probability layer was smoothed temporally to obtain a smooth time series of primitives for each class. This technique was repeated for each of the three smoothing algorithms. The GEE codes for these implementations can be found in Appendix B.1 and Appendix B.2. This process resulted in 7 layers: three for each of the three smoothing algorithms applied on composite image, three for each of the three smoothing algorithms applied on primitives and one original data layer where smoothing was not applied.
The three algorithms that were used are detailed below:
Whittaker Smoothing
The Whittaker smoother is a popular smoothing approach that has been shown to work well with evenly-spaced data [29,46]. The Whittaker smoother can be considered as a special case of B-spline smoothing where the number of knots are equal to the data points [47]. Studies conducted by Hermance et al. [48,49] have successfully demonstrated its use in signal processing. The Whittaker smoother works by fitting a smooth series to a discrete data set. For a noisy y-series and its corresponding smooth z-series, the fidelity of data and roughness of z has to be balanced. Fidelity S is the sum of squares of differences and R is the roughness of the smooth data which is expressed as second order differences. With the goal of minimizing the balanced combination of the two, the combination Q can be expressed as
Q = S + κ R
where,
S = i ( y i z i ) 2
and
R = i ( ( z i z i 1 ) ( z i 1 z i 2 ) ) 2
κ controls the degree of smoothness where the larger the κ is, the smoother z is. This can be noted in matrix form as in Equation (4).
( I + λ D d D d ) z = y
where,
I = Identity matrix
λ = Smoothing degree, the larger λ is, the smoother z will be
D = differential matrix with m-2 rows and m columns with d as the order of differences Each row of the differential matrix D with the order of differences 2 contains the pattern 1 −2 1, shifted in a way where for each row i, d i , i = 1 , d i , i + 1 = 2 , d i , i + 2 = 1 and all other values are 0. For example,
1 2 1 0 0 0 1 2 1 0 0 0 1 2 1
This matrix equation can be solved to compute the matrix z to obtain the smooth series.
Fourier Smoothing
Fourier smoothing is another popular smoothing approach based on the Fourier transformation of data. There are multiple scenarios where it has been used [25,33,34,50,51]. First, the raw data is converted to frequency domain by implementing a direct Fourier transformation (DFT). The DFT is defined by Equation (5) [52]
A n = k = 0 N 1 X k e ( 2 π i n k / N ) n = 0 , 1 , , N 1
where,
A n = nth coefficient of the DFT
X k = kth data in the times series
N = Number of data in the time series
i = 1    It can also be written as (6),
A n = k = 0 N 1 X k W n k n = 0 , 1 , , N 1
where,
W = e ( 2 π i / N )
However, since computations with the complex exponential are not straightforward on GEE yet, Equation (7) is re-expressed using Euler’s formula as follows:
W = c o s ( 2 π n k / N ) + i s i n ( 2 π n k / N )
The real and imaginary parts were handled separately. From the results, the data located in indices greater than the specified smoothing degree were set as zero. After reducing the higher harmonics to zero, the resulting values are reverted back to the time domain by applying inverse DFT. This essentially means that, first we fit the whole data set using a set of cyclic functions and then discarding the higher harmonics to remove the overfit so that we essentially are left with smoothened data set. The Fourier smoother along with Whittaker smoother was found to be two of the best smoothers in terms of classification in a study done by Shao et al. [33].
Linear Fit Smoothing
Linear Fit Smoothing is what we refer to as a simple derivative of moving window averaging where the window, a subset of the whole data set is used to average and obtain smooth values [53]. In this case, instead of taking the average over the moving window, data within a window is used to estimate a linear fit which is further averaged to get the final smoothened results.
The nature and smoothing effect of these algorithms can be explored through Figure 3a,b which were explored on different points exhibiting different types of time series data. From the plots it can be seen that, Fourier smoothing tends to preserve the shape of the time series more than others while Whittaker smoothing gave us the most flattened smoothing among the others. The value of smoothing degree of all of these algorithms was decided based on trial and error method of testing multiple values and deciding on the one that gave the best result. The parameters used for these smoothing algorithms are listed below in Table 2.

2.4.3. Final Land Cover Map Generation and Accuracy Assessment

Primitives were assessed based on how well it could distinguish the feature it was supposed to represent vs the others. From the seven sets of primitives, the best primitive for each land cover type was picked based on their performance; this was used to create the eighth set of primitives. Different land cover maps were prepared in an assemblage logic using a decision tree classifier. For each set of primitives, the same assemblage logic was applied to produce land cover maps (see Appendix B.3 and Appendix C). The decision tree was kept constant so that only smoothing had an effect on the change in accuracy of the land cover maps. The accuracy of and change in accuracy between each land cover type was compared in order to understand the impact of different algorithms on different land cover types.

3. Results

The primitive assessment (Figure 4) shows the performance of the six different smoothing approaches on each of the eight different land cover types (snow, forest, cropland, wetland, riverbed, settlement, barren and grassland). A primitive is said to have better separability when the two box plots generated from it, one representing the probability distributions of its corresponding land cover type and another representing others, have either narrower plots or larger distance between its two plots. Narrower plots represent more consistent probability distribution while increased distance between the box plots means a clearer separation between the primitive’s corresponding type and others. This results in reduced omission and commission when the proper threshold is applied for classification. Therefore, better separation is used to identify better primitives. We found that for snow and forest there is a clear separation between the class itself and other classes, followed by wetlands, settlement and riverbed. For grassland and cropland there is more overlap between the probability distributions.
Figure 4 also shows that Fourier smoothing results in the best separation for snow, wetlands, riverbed, barren land and grassland. For the other land cover types, Whittaker performed better than Fourier. Linear-fit was found to perform better than Fourier for forest, cropland and settlement but not as good as Whittaker. On the other hand, it performed better than Whittaker for other types but did not consistently outperform either Whittaker or Fourier. Furthermore, it was found that smoothing on the composite generally shows narrower distributions for snow, wetland and riverbed classes as compared to primitives. For forest, cropland and settlement the distributions are narrower when smoothing is applied on the primitives as opposed to on composites.
An example of the accuracy gained by smoothing versus visual assessment alone is shown in Figure 5. Here, we show that classification of forest without smoothing results in an inconsistent sudden drop in forest cover for the year 2014 (Figure 5b,f). The seen temporal dynamics of deforestation and regrowth would not be expected considering the short time frame [54]. Our results show a more consistent change after temporal smoothing in land cover types, which is more in line with the expected pathways.
The best performing smoothing algorithms were then used in the land cover assemblage. Figure 6 shows the accuracy of the different land cover classes before smoothing and after combining best primitives post-smoothing. It can be seen that snow and grassland classes show least improvements, while settlement, cropland and forest have larger improvements. It can also be noted that smoothing shows larger improvements for categories with little temporal variability. For example, snow, riverbeds and wetlands can be expected to have more temporal dynamics and show the least improvement.
The final accuracy assessment (Table 3) demonstrates how smoothing improved results. The overall accuracy increased from 79.18% to 83.44%. It is important to note that this result means that using smoothed data sets, given that the smoothing parameters are optimized for the input data set, is better than using no smoothing at all. However, to ensure that smoothing is not introducing errors, the nature of land cover type in question needs to be properly identified and the appropriate smoothing approach needs to be taken. Consequently, to optimize the accuracy of the final maps, our results showed that it is best to use different algorithms based on the land cover type and then combine the best primitives to prepare the final land cover map.

4. Discussion

Three different smoothing algorithms were applied on eight different land cover classes. We found that improvements vary amongst different categories. We argue that this difference in performance is caused by the nature of the classes. In the case of Nepal, barren land often interchanges with grassland, and wetland (mainly rivers) often interchanges with riverbeds. Forest, cropland and settlement are more constant classes, which changes either once or infrequently. It therefore appears that Whittaker smoothing works best on land cover types with clear differentiation between them, whereas Fourier can be used on land cover types that more frequently changing. Fourier transformation showed good results for land cover types that frequently change as it breaks down a data series into a combination of cyclic equations; by doing this it preserves many of the highs and lows of the data while still removing noise. Fourier smoothing therefore works best when applied on the composite layer rather than the primitives, as the random forest method can then can use the noise-free composite.
In this study, we explored the use of smoothing on remote sensing composites and primitive layers. However, most studies (e.g., [20,23,24]) apply categorical classification on composites based on indices directly and do not have the intermediate primitive layers as used in this study. Moreover, the study was applied on a relatively small area with distinct climatological and topographic characteristics that determine the spatio-temporal land cover dynamics. More testing is needed to investigate if these findings also apply to other regions. It should also be noted that combining our smoothing algorithms with change detection algorithms such as LandTrendr [55] and Breaks For Additive Seasonal and Trend (BFAST) [56] might help improve land cover mapping accuracy as these algorithms are specifically designed to detect changes.
A main issue in generating land cover maps from annual composites is the number of valid observations (i.e., cloud-free pixels in a year). As such, the intra-annual distribution of pixels varies from year to year and as a consequence, the phenology is not necessarily fully represented in each annual composite. This might be captured in the ML model if multiple years are covered, but smoothing applies some additional noise reduction. This study shows that a smoothing algorithm should be selected based on the dynamics of a class. For example, Whittaker smoothing shows better results for stable classes. Fourier shows good results for classes that are dynamic when applied on composites. In general, it was found that smoothing on the primitives gives better performance than when applied on the composite layers for stable classes. Primitives are confidence layers generated by the ML algorithm so smoothing a set of primitives uses temporal information to improve estimates generated by the ML model rather than observation made by sensors. Stable classes show better performance after smoothing as it flattens out the inter annual dynamics in surface reflectance or class probability. For highly dynamic classes temporal segmentation algorithms might be another alternative approach to capture rapid changes.
We noticed an interesting phenomenon where changes in average probability were largely insignificant, but the lengths of error bars were significantly reduced. This means that smoothing does not necessarily increase the average confidence of overall classification but still improves the inter-class separability by reducing the deviation among pixels. The results line up with Shao et al. [33] while applying the Fourier and the Whittaker algorithms on an NDVI layer that was used for classification. Mingwei  et al. [57] applied Fourier transformation on MODIS derived vegetation indices and found good correlation, which seems contradictory to our results. However, it needs to be noted that the study took a look at phenology, where there is a cyclic change in values, while we are looking at annual layers for which we do not expect to see much back and forth changes.

5. Conclusions

This study tested on using temporal smoothing as a means to improve land cover maps that were prepared by using a machine learning algorithm. Here the Fourier, Linear-fit and Whittaker smoothing algorithms were tested on image composites and on image primitives representing individual land cover types over time. Overall, we found that using temporal smoothing with machine learning improves the results compared to no smoothing; however, for classes that frequently undergo changes, Fourier smoothing produces the best results when applied on composite images. Conversely, for classes that do not undergo regular changes, Whittaker gave the best results when applied on primitives. Land cover types that do not undergo frequent changes generally were more improved with smoothing; in some cases, the accuracy of results decreased in classes that show frequent changes. The overall accuracy of the maps produced by our approach improved from 79.18% to 83.44% when we combined the best techniques for each land cover type. We therefore recommend that when creating land cover maps from satellite data, researchers identify the dynamics of the land cover type based on the target temporal resolution and then apply the appropriate algorithm. In cases where smoothing needs to be applied to the whole land cover rather than primitives from just one class, we recommend smoothing each class separately and then using the smoothed layers to prepare the final land cover map.   

Author Contributions

Conceptualization, methodology, validation, and formal analysis, N.K., M.A.M. and K.U.; writing—original draft preparation N.K., M.A.M., and A.P.; writing—review and editing, N.K., M.A.M., A.P., K.U, F.C. and K.T. Finally, all the authors read, edited, and critiqued the manuscript and approved the final version. All authors have read and agreed to the published version of the manuscript.

Funding

This research received no external funding.

Acknowledgments

We express our gratitude to David Molden, Director General and Eklabya Sharma, Deputy Director General of ICIMOD for the overall guidance. This study was partially supported by core funds of ICIMOD contributed by the governments of Afghanistan, Australia, Austria, Bangladesh, Bhutan, China, India, Myanmar, Nepal, Norway, Pakistan, Switzerland, and the United Kingdom. This paper has been prepared under the SERVIR-Hindu Kush Himalaya (SERVIR-HKH) initiative funded by the NASA and USAID. Our special gratitude goes to Ghulam Rasul, Regional Programme Manager, MENRIS and Birendra Bajracharya, Chief of Party, SERVIR-HKH for their encouragement and very active support in bringing out this work. We also thank the SERVIR RLCMS team for their assistance. Finally, we would like to thank those who reviewed the articles and provided valuable suggestions to improve the manuscript.

Conflicts of Interest

The authors declare no conflict of interest. The views and interpretations in this publication are those of the authors. They are not necessarily attributable to ICIMOD and do not imply the expression of any opinion by ICIMOD concerning the legal status of any country, territory, city, or area of its authority or concerning the delimitation of its frontiers or boundaries or the endorsement of any product.

Appendix A. Reference Data

Table A1. Training point distribution.
Table A1. Training point distribution.
Land ClassTraining PointsValidation Points
bare1272545
cropland29,537600
forest45,806600
grassland378162
riverBed1615600
settlement1501600
snow3565600
wetland2419600

Appendix B. Smoothing Codes

Appendix B.1. Smoothing Composites

1
    DESCRIPTION
2
 
3
    In order to test the impact of smoothing in landcover classification, we need to
4
    first
5
    check with smoothing the surface reflectance itself as well as smoothing the
6
    intermediate smoothing results. In this step we will be smoothing composites
7
    themself
8
    using different algorithms namely whittaker, fourier and linear fit.
9
 
10
    SCRIPT INFO
11
 
12
    The users can/should change the following
13
    1. imageCollection - source image collection that needs to be smoothened
14
    2. boundary - the study region
15
    3. smoothingAlgorithm - the algorithm to perform smoothing. can be ’whittaker’,
16
    ’fourier’
17
    or ’linearFit’
18
    3. startYear - the start year from when to perform temporal smoothing
19
    4. endYear - the end year to which to perform temporal smoothing
20
    5. exportPath - the collection in which smoothened images are exported
21
 
22
    DEVELOPER NOTES
23
    1. Make sure the masks in each region is common to avoid errors
24
 
25
 
26
    AUTHOR
27
    Nishanta Khanal
28
    ICIMOD, 2019
29
    */
30
 
31
    var imageCollection =
32
        ee.ImageCollection(’projects/servir-hkh/ncomp_yearly_30/compositesV2’);
33
    var boundary = ee.FeatureCollection(’users/nkhanal/boundaries/p1_buffer_2000’);
34
    var smoothingAlgorithm = "fourier";
35
    var startYear = 2000;
36
    var endYear = 2018;
37
    var exportPath = ’users/nkhanal/sm/four/comp’;
38
 
39
 
40
    var addCovariates =
41
        require("users/khanalnishant/ICIMOD:RLCMS/V2/Training/1_addCovariates_yearly")
42
 
43
    var smoothing = require("users/khanalnishant/EETest:Algo/WhittakerSmoothing")
44
    var param = 10;
45
    if(smoothingAlgorithm == ’fourier’){
46
      smoothing = require("users/khanalnishant/EETest:Algo/FourierSmoothing");
47
      param = false;
48
    }else if (smoothingAlgorithm == ’linearFit’){
49
      smoothing = require("users/khanalnishant/Algorithms:LinearFitSmoothing");
50
      param = 420;
51
    }
52
 
53
 
54
 
55
    // #####################################3
56
    // # perform smoothing
57
    // #####################################3
58
    // #add image attribures for smoothing
59
    function prepareImage(image){
60
        var imgYear = ee.Number.parse(image.id())
61
        image = image.unmask(0).clip(boundary).toShort()
62
        return image.set(’year’, imgYear,
63
                         ’system:time_start’, ee.Date.fromYMD(imgYear, 1, 1).millis());
64
    }
65
    var imageCollection = imageCollection.map(prepareImage)
66
    print(imageCollection.first())
67
 
68
    // # get original band names and add fitted at end to select fitted bands
69
    var bandNames = ee.Image(imageCollection.first()).bandNames()
70
    function fittedName(band){
71
        return ee.String(band).cat(’_fitted’)
72
    }
73
    var fittedNames = bandNames.map(fittedName)
74
 
75
    var smoothingResults = smoothing.runModel(imageCollection, param)
76
    var imageCollection = smoothingResults[0].select(fittedNames, bandNames)
77
    var rmse = smoothingResults[1]
78
 
79
    function exportHelper(image, assetID, imageCollectionID){
80
      image = image.int16()
81
      // # image = setExportProperties(image, args)
82
 
83
      Export.image.toAsset({
84
          image:ee.Image(image),
85
          description:smoothingAlgorithm+"-"+assetID +"-from-js",
86
          assetId:imageCollectionID+’/’+assetID,
87
          region:boundary,
88
          maxPixels:1e13,
89
          scale: 30
90
      });
91
    }
92
 
93
    for (var year=startYear;year<=endYear;year++){
94
      var image = ee.Image(imageCollection.filter(ee.Filter.eq(’year’,year)).first())
95
                 .clip(boundary)
96
      exportHelper(image, year, exportPath)
97
    }
98
 
99
    Export.image.toAsset({
100
        image:ee.Image(rmse),
101
        description:smoothingAlgorithm+"-rmse-from-js",
102
        assetId:exportPath+’/rmse’,
103
        region:boundary,
104
        maxPixels:1e13,
105
        scale: 30
106
    });

Appendix B.2. Smoothing Primitives

1
    /*
2
    DESCRIPTION
3
 
4
    In order to test the impact of smoothing landcover classification, we need to
5
    first check with smoothing the surface reflectance itself as well as smoothing the
6
    intermediate smoothing results. In this step we will be smoothing primitives using
7
    different algorithms namely whittaker, fourier and linear fit. The export will
8
    generate  an image with timeseries data and rmse on different bands. Different
9
    script is later required to split them into images.
10
 
11
    SCRIPT INFO
12
 
13
    The users can/should change the following
14
    1. imageCollection - source image collection that contains the unsmoothened
15
    primitives
16
    2. primitive - the primitive to be smoothened
17
    3. boundary - the study region
18
    4. smoothingAlgorithm - the algorithm to perform smoothing. can be ’whittaker’,
19
    ’fourier’ or ’linearFit’
20
    5. startYear - the start year from when to perform temporal smoothing
21
    6. endYear - the end year to which to perform temporal smoothing
22
    7. exportPath - the collection in which smoothened images are exported
23
 
24
    DEVELOPER NOTES
25
    1. Make sure the masks in each region is common to avoid errors
26
 
27
    AUTHOR
28
    Nishanta Khanal
29
    ICIMOD, 2019
30
    */
31
 
32
    var imageCollectionId = ’users/nkhanal/sm/nosm/prims’;
33
    var primitive = ’wetland’
34
    var boundary = ee.FeatureCollection(’users/nkhanal/boundaries/p1_buffer_2000’);
35
    var smoothingAlgorithm = "linearFit";
36
    var startYear = 2000;
37
    var endYear = 2018;
38
    var exportPath = ’users/nkhanal/sm/line/primtemp’;
39
 
40
    var addCovariates =
41
      require("users/khanalnishant/ICIMOD:RLCMS/V2/Training/1_addCovariates_yearly")
42
 
43
    var smoothing = require("users/khanalnishant/EETest:Algo/WhittakerSmoothing")
44
    var param = 10;
45
    if(smoothingAlgorithm == ’fourier’){
46
      smoothing = require("users/khanalnishant/EETest:Algo/FourierSmoothing");
47
      param = false;
48
    }else if (smoothingAlgorithm == ’linearFit’){
49
      smoothing = require("users/khanalnishant/Algorithms:LinearFitSmoothing");
50
      param = 420;
51
    }
52
 
53
 
54
    // #####################################3
55
    // # perform smoothing
56
    // #####################################3
57
    // #add image attribures for smoothing
58
    var yearlyPrims = [];
59
    for (var year = startYear; year<=endYear; year++){
60
      var image = ee.Image(imageCollectionId+’/’+primitive+’-’+year).unmask(0)
61
            .clip(boundary);
62
      image = image.set(’year’, year,
63
               ’system:time_start’, ee.Date.fromYMD(year, 1, 1).millis())
64
      yearlyPrims.push(image);
65
    }
66
    imageCollection = ee.ImageCollection(yearlyPrims);
67
    print(imageCollection.first())
68
 
69
    // # get original band names and add fitted at end to select fitted bands
70
    var bandNames = ee.Image(imageCollection.first()).bandNames()
71
    function fittedName(band){
72
        return ee.String(band).cat(’_fitted’)
73
    }
74
    var fittedNames = bandNames.map(fittedName)
75
 
76
    var smoothingResults = smoothing.runModel(imageCollection, param)
77
    var imageCollection = smoothingResults[0].select(fittedNames, bandNames)
78
    var rmse = smoothingResults[1]
79
 
80
    function exportHelper(image, assetID, exportPath){
81
      image = image.int16()
82
      Export.image.toAsset({
83
          image:ee.Image(image),
84
          description:smoothingAlgorithm+"-"+assetID +"-from-js",
85
          assetId:exportPath+’/’+primitive+’-’+assetID,
86
          region:boundary,
87
          maxPixels:1e13,
88
          scale: 30
89
      });
90
    }
91
 
92
    var img = ee.Image([])
93
    for (var year=startYear;year<=endYear;year++){
94
      var image = ee.Image(imageCollection.filter(ee.Filter.eq(’year’,year)).first())
95
                 .clip(boundary)
96
        img = img.addBands(image.rename(’b’+year));
97
    }
98
    var img = img.addBands(rmse.rename(’rmse’)).toInt16();
99
 
100
    Export.image.toAsset({
101
        image:img,
102
        description:smoothingAlgorithm+"-"+primitive+"-from-js",
103
        assetId:exportPath+’/’+primitive+’Results’,
104
        region:boundary,
105
        maxPixels:1e13,
106
        scale: 30
107
    });

Appendix B.3. Assemblage

1
    /*
2
    DESCRIPTION
3
 
4
    Now that we have satisfactory primitives we will run them through assembler
5
    to obtain a land cover map. The assembler prepares a decision tree based on
6
    user specified thresholds which can be tuned based on visual assessment as
7
    well as primitive assessment plots. The order of primitives in the list denotes
8
    the order in which primitives are placed in the decision tree with the first
9
    primitive placed on the top and so forth. This basically means that if a pixel
10
    has high probability on two primitives (according to the specified threshold)
11
    the final class will be based on the primitive that is higher up on the decision
12
    tree.
13
 
14
    SCRIPT INFOS
15
 
16
    The users can/should change the following parameters.
17
    1. boundary - this should contain the boundary of region of interest
18
    2. repository - the repository that contains the stack of primitives required
19
    3. scale - the spatial resolution of the resulting landCover
20
    4. exportPath - the path to which to export the resulting landcover
21
    5. primitives - the list of primitives to include in the assembler
22
    6. defaultThresholds - (optional) the default thresholds that the interface
23
        initiates with.It can be changed in the UI later. This should be in line
24
        with the list of primitives.
25
    7. year - (optional) the default year to load into the interface
26
 
27
    The users need to do the following
28
    1. After the script is run, initiate the export task by going to the "Tasks" tab
29
    ------->>>>>>>
30
 
31
    */
32
 
33
    /*
34
    Variables - refer above notes section for description on these
35
    */
36
    var boundary = ee.FeatureCollection("users/nkhanal/boundaries/p1_buffer_2000")
37
                .geometry();
38
    var repository = ’users/nkhanal/sm/final/prims/’;
39
    var scale = 30;
40
    var exportPath = ’users/nkhanal/sm/final/lc’;
41
    var primitives = [’snow’,’forest’,’cropland’,’wetland’,’riverBed’,’settlement’,
42
    ’bare’];
43
    var defaultThresholds = [70, 60, 60, 65, 60, 60, 70];
44
    var year = 2017;
45
 
46
    /* -------------------------------------------------------------------------------
47
    WARNING!!!
48
 
49
    FUNCTIONS AND PROCEDURES BELOW HERE
50
 
51
    edit at your own risk
52
    */
53
 
54
    // container for the classified landclass image
55
    var landClass = ee.Image();
56
 
57
    // ************************************************
58
    // ui objects
59
    // containers for sliders
60
    var sliders = {};
61
    // containers for inspected values
62
    var valLabels = {};
63
    // list of all selectable years
64
    var availableYears = [’2000’,’2001’,’2002’,’2003’,’2004’,’2005’,
65
              ’2006’,’2007’,’2008’,’2009’,’2010’,’2011’,
66
      ’2012’,’2013’,’2014’,’2015’,’2016’,’2017’,’2018’];
67
    // dropdown to select years
68
    var yearList = ui.Select(availableYears, ’year’’’+year);
69
    // checkbox to visualize primitives using thresholds
70
    var primThresholds = ui.Checkbox({
71
      label:’Visualize primitive by thresholds’,
72
style:{’height’:’18px’,’fontSize’:’11px’’padding’:’4px’’margin’:’0px’}
73
    });
74
    // button to refresh display according to parameters
75
    var refreshDisplay = ui.Button({
76
      label:’Refresh Display’,
77
      onClick: refresh,
78
      style: {’fontSize’:’11px’’padding’:’4px’’margin’:’0px’}
79
    });
80
    // button to export the current LandCover
81
    var exportLC = ui.Button({
82
      label:’Export current landCover’,
83
      onClick: exportHelper,
84
      style: {’fontSize’:’11px’’padding’:’4px’’margin’:’0px’}
85
    });
86
    // button to export the current LandCover
87
    var exportAllLC = ui.Button({
88
      label:’Export landcover stack’,
89
      onClick: exportAllHelper,
90
      style: {’fontSize’:’11px’’padding’:’4px’’margin’:’0px’}
91
    });
92
    // button to export problem regions
93
    var exportPA = ui.Button({
94
      label:’Export Problem Regions’,
95
      onClick: exportAreas,
96
      style: {’fontSize’:’11px’’padding’:’4px’’margin’:’0px’}
97
    });
98
 
99
    // ************************************************
100
    // functions
101
 
102
    // function to reclassify stack image using decision tree
103
    function reclassify(stackImage, decisionTree){
104
      var classifier = ee.Classifier.decisionTree(decisionTree);
105
      var landClass = stackImage.classify(classifier);
106
      return landClass;
107
    }
108
 
109
    // client side list map function to change list of primitives
110
    // to a list of images corresponding to the primitives
111
    // also adds the primitives to the map
112
    function getPrimitiveImages(primitive){
113
      var image = ee.Image(repository+primitive).select(’b’+year)
114
                            ;.multiply(0.01)
115
                            .rename(primitive);
116
      var primLayer = ui.Map.Layer(image, {max:100}, primitive, false, 1);
117
      if (primThresholds.getValue()){
118
        primLayer = ui.Map.Layer(image.gte(sliders[primitive].getValue()),
119
                          {},
120
                          primitive,
121
                          false,
122
                          1);
123
      }
124
      Map.layers().set(primitives.indexOf(primitive), primLayer);
125
      return image;
126
    }
127
 
128
    // function to build decision tree from interface
129
    function buildDecisionTree(){
130
      var values = {
131
        forest:sliders[’forest’].getValue(),
132
        wetland:sliders[’wetland’].getValue(),
133
        settlement:sliders[’settlement’].getValue(),
134
        cropland:sliders[’cropland’].getValue(),
135
        snow:sliders[’snow’].getValue(),
136
        riverBed:sliders[’riverBed’].getValue(),
137
        bare:sliders[’bare’].getValue()
138
      }
139
 
140
      var DT = [’1) root 9999 9999 9999’]
141
      var base = 1;
142
      for (var i = 0; i < primitives.length; i++){
143
        var a = base * 2
144
        var b = base * 2 + 1
145
        DT.push(’’+a+’) ’+
146
                primitives[i]+’>=’+values[primitives[i]]+
147
                ’ 9999 9999 ’+(i+1)+’ *’);
148
        if(i == primitives.length-1){
149
           DT.push(’’+b+’) ’+primitives[i]+’<’+values[primitives[i]]+’ 9999 9999 8 *’);
150
        }else DT.push(’’+b+’) ’+primitives[i]+’<’+values[primitives[i]]+’ 9999 9999 9999’);
151
        base = b
152
      }
153
      return DT.join(’\n’)
154
    }
155
 
156
    // function to start the process
157
    function process(year){
158
      var stackImage = ee.Image(primitives.map(getPrimitiveImages)).clip(boundary);
159
      landClass = reclassify(stackImage, buildDecisionTree());
160
      var lcLayer = ui.Map.Layer(landClass, imageVisParam, ’land cover’true, 1);
161
      Map.layers().set(primitives.length, lcLayer);
162
    }
163
 
164
    // function to add legend to the map
165
    function addLegend(){
166
      var UTILS = require(’users/khanalnishant/Algorithms:Utilities’)
167
      var palette = imageVisParam.palette
168
      palette = palette
169
      var labels = primitives.concat(’grassland’)
170
    UTILS.addLegend(palette, labels,’Legend’,{
171
        ’position’:’bottom-right’,
172
        ’padding’:’8px 16px’,
173
      });
174
    }
175
 
176
    // function to add inspect panel to the map
177
    function addInspect(){
178
      var panel = ui.Panel([],
179
                   ui.Panel.Layout.Flow(’vertical’),
180
                   {maxHeight:’200px’,position:’bottom-center’});
181
      var inspectLabel = ui.Label(’Click to inspect primitive values’,
182
                     {’height’:’18px’,
183
                     ’fontSize’:’11px’,
184
                     ’padding’:’0px’,
185
                     ’margin’:’1px’});
186
      panel.add(inspectLabel)
187
      for (var i = 0; i <primitives.length;i++){
188
        var insLabel =  ui.Label(primitives[i],{’width’:’60px’,
189
                        ’fontSize’:’11px’,
190
                        ’padding’:’0px’,
191
                        ’margin’:’1px’});
192
        valLabels[primitives[i]] =  ui.Label(’Click Map’,{’fontSize’:’11px’,
193
                           ’padding’:’0px’,
194
                           ’margin’:’1px’});
195
        var inspectSubPanel = ui.Panel([insLabel, valLabels[primitives[i]]],
196
                     ui.Panel.Layout.Flow(’horizontal’));
197
        panel.add(inspectSubPanel);
198
      }
199
      Map.add(panel)
200
    }
201
 
202
    // function to update the inspect section once map is clicked
203
    function fetchValues(lonlat){
204
      var point = ee.Geometry.Point(lonlat.lon, lonlat.lat);
205
      var stack = ee.Image([]);
206
      for (var i=0; i<primitives.length;i++){
207
        var image = Map.layers().get(i).get(’eeObject’);
208
        stack = stack.addBands(image);
209
        valLabels[primitives[i]].setValue(’updating values’);
210
      }
211
      var pointSampled = stack.sample(point,30).first().evaluate(updateValues);
212
    }
213
 
214
    //update the labels once the sampling is done
215
    function updateValues(feature){
216
      // print(feature.properties);
217
      for (var i=0; i<primitives.length;i++){
218
        var value = parseFloat(feature.properties[primitives[i]]).toFixed(2);
219
        valLabels[primitives[i]].setValue(value);
220
      }
221
    }
222
 
223
    // function to export all Land Covers
224
    function exportHelper(){
225
      Export.image.toAsset({
226
        image:landClass.toInt8(),
227
        description:’LandCover-’+year,
228
        region:boundary,
229
        scale:scale,
230
        assetId:exportPath+’/’+year,
231
        maxPixels:1e10
232
      });
233
    }
234
 
235
    // function to export current Land Cover
236
    function exportAllHelper(){
237
      print("initiating export");
238
      var tempYr = year;
239
      var decisionTree = buildDecisionTree();
240
      var image = ee.Image([]);
241
      for (var i = 0; i<availableYears.length;i++){
242
        year = availableYears[i];
243
        var stackImage = ee.Image(primitives.map(getPrimitiveImages)).clip(boundary);
244
        var landClass = reclassify(stackImage, decisionTree)
245
        image = image.addBands(landClass.rename("b"+year));
246
      }
247
      image = image.set(’decisionTree’,
248
                  decisionTree,
249
                  ’year’,
250
                  ee.Date.fromYMD(parseInt(year),
251
                  1,
252
                  1));
253
      Export.image.toAsset({
254
        image:image.toInt8(),
255
        description:’LandCover-stack’,
256
        region:boundary,
257
        scale:30,
258
        assetId:exportPath+’/lcstack’,
259
        maxPixels:1e10
260
      });
261
      year = tempYr;
262
    }
263
 
264
    // function to export Problem Areas
265
    function exportAreas(){
266
      var generatedPoints = ee.FeatureCollection.randomPoints(geometry, 100);
267
      // add latitude and longitude as attributes
268
      generatedPoints = generatedPoints.map(function(feature){
269
        var coords = feature.geometry().coordinates();
270
          return feature.set(’latitude’,coords.get(1),’longitude’, coords.get(0))
271
      });
272
      Export.table.toDrive({
273
        collection:generatedPoints,
274
        description: ’RLCMS-additionalPoints’,
275
        fileFormat: ’CSV’
276
      })
277
    }
278
    // function to refresh display based on parameters
279
    function refresh(){
280
      // get layer shown state
281
      var layers = Map.layers();
282
      var shownStat = layers.map(function(layer){
283
        return layer.getShown();
284
      });
285
      // get selected year
286
      year = yearList.getValue();
287
      // initiate the process
288
      process(year);
289
      // reassign the previous layer shown status
290
      layers = Map.layers();
291
      layers.map(function(layer){
292
       return layer.setShown(shownStat[layers.indexOf(layer)]);
293
      });
294
    }
295
 
296
    // function to initialize the application
297
    function init(){
298
      var panel = ui.Panel([], ui.Panel.Layout.Flow(’vertical’),
299
      {position:’bottom-left’});
300
      var yearLabel = ui.Label(’Year’,{’width’:’30px’,
301
                         ’height’:’18px’,
302
                         ’fontSize’:’11px’,
303
                         ’margin’:’15px 0px’});
304
      var yearSubPanel = ui.Panel([yearLabel, yearList],
305
                          ui.Panel.Layout.Flow(’horizontal’));
306
      panel.add(yearSubPanel);
307
      var sliderLabel = ui.Label(’Adjust Probability Thresholds’,
308
                          {’height’:’18px’,
309
                          ’fontSize’:’11px’,
310
                          ’padding’:’0px’,
311
                          ’margin’:’1px’});
312
      panel.add(sliderLabel);
313
      for (var i = 0; i< primitives.length;i++){
314
        var label = ui.Label(primitives[i],{’width’:’50px’,
315
                             ’height’:’18px’,
316
                             ’fontSize’:’11px’,
317
                             ’padding’:’0px’,
318
                             ’margin’:’1px’});
319
        sliders[primitives[i]] = ui.Slider({
320
          min:0,
321
          max:100,
322
          value:defaultThresholds[i],
323
style:{’height’:’18px’,’fontSize’:’11px’’padding’:’0px’’margin’:’1px’}
324
        });
325
        var subPanel = ui.Panel([label, sliders[primitives[i]]],
326
                                ui.Panel.Layout.Flow(’horizontal’),
327
                                {’padding’:’4px’});
328
        panel.add(subPanel);
329
      }
330
      panel.add(primThresholds);
331
      panel.add(refreshDisplay);
332
      panel.add(exportLC);
333
      panel.add(exportAllLC);
334
      panel.add(exportPA);
335
      Map.add(panel);
336
      addLegend();
337
      addInspect();
338
      Map.onClick(fetchValues);
339
    }
340
 
341
    init();
342
    process(year);

Appendix C. Datasets

Here are the list of datasets that were used and/or prepared for this study.
  • Non-smoothened primitives : users/nkhanal/sm/nosm/prims
  • Non-smoothened land cover : users/nkhanal/sm/nosm/lc
  • Final smoothened and best selected primitives: users/nkhanal/sm/final/prims
  • Final smoothened and best selected land cover: users/nkhanal/sm/final/lc
These addresses refer to the GEE asset ID of the dataset in question.

References

  1. Running, S.W. Ecosystem disturbance, carbon, and climate. Science 2008, 321, 652–653. [Google Scholar] [CrossRef] [PubMed]
  2. Waldner, F.; Fritz, S.; Di Gregorio, A.; Defourny, P. Mapping priorities to focus cropland mapping activities: Fitness assessment of existing global, regional and national cropland maps. Remote Sens. 2015, 7, 7959–7986. [Google Scholar] [CrossRef] [Green Version]
  3. Boisvenue, C.; Smiley, B.P.; White, J.C.; Kurz, W.A.; Wulder, M.A. Improving carbon monitoring and reporting in forests using spatially-explicit information. Carbon Balance Manag. 2016, 11, 23. [Google Scholar] [CrossRef] [PubMed] [Green Version]
  4. Pettorelli, N.; Wegmann, M.; Skidmore, A.; Mücher, S.; Dawson, T.P.; Fernandez, M.; Lucas, R.; Schaepman, M.E.; Wang, T.; O’Connor, B.; et al. Framing the concept of satellite remote sensing essential biodiversity variables: Challenges and future directions. Remote Sens. Ecol. Conserv. 2016, 2, 122–131. [Google Scholar] [CrossRef]
  5. Turner, B.L.; Lambin, E.F.; Reenberg, A. The emergence of land change science for global environmental change and sustainability. Proc. Natl. Acad. Sci. USA 2007, 104, 20666–20671. [Google Scholar] [CrossRef] [Green Version]
  6. Bui, Y.T.; Orange, D.; Visser, S.; Hoanh, C.T.; Laissus, M.; Poortinga, A.; Tran, D.T.; Stroosnijder, L. Lumped surface and sub-surface runoff for erosion modeling within a small hilly watershed in northern Vietnam. Hydrol. Process. 2014, 28, 2961–2974. [Google Scholar] [CrossRef]
  7. Otukei, J.R.; Blaschke, T. Land cover change assessment using decision trees, support vector machines and maximum likelihood classification algorithms. Int. J. Appl. Earth Obs. Geoinf. 2010, 12, S27–S31. [Google Scholar] [CrossRef]
  8. Tuia, D.; Persello, C.; Bruzzone, L. Domain adaptation for the classification of remote sensing data: An overview of recent advances. IEEE Geosci. Remote Sens. Mag. 2016, 4, 41–57. [Google Scholar] [CrossRef]
  9. Phiri, D.; Morgenroth, J. Developments in Landsat land cover classification methods: A review. Remote Sens. 2017, 9, 967. [Google Scholar] [CrossRef] [Green Version]
  10. Landgrebe, D.A.; Malaret, E. Noise in remote-sensing systems: The effect on classification error. IEEE Trans. Geosci. Remote Sens. 1986, 294–300. [Google Scholar] [CrossRef]
  11. Markham, B.; Townshend, J. Land Cover Classification Accuracy as a Function of Sensor Spatial Resolution; NASA: Washington, DC, USA, 1981. [Google Scholar]
  12. Song, M.; Civco, D.; Hurd, J. A competitive pixel-object approach for land cover classification. Int. J. Remote Sens. 2005, 26, 4981–4997. [Google Scholar] [CrossRef]
  13. Townshend, J.; Huang, C.; Kalluri, S.; Defries, R.; Liang, S.; Yang, K. Beware of per-pixel characterization of land cover. Int. J. Remote Sens. 2000, 21, 839–843. [Google Scholar] [CrossRef] [Green Version]
  14. Pelletier, C.; Valero, S.; Inglada, J.; Champion, N.; Marais Sicre, C.; Dedieu, G. Effect of training class label noise on classification performances for land cover mapping with satellite image time series. Remote Sens. 2017, 9, 173. [Google Scholar] [CrossRef] [Green Version]
  15. Rahmati, O.; Ghorbanzadeh, O.; Teimurian, T.; Mohammadi, F.; Tiefenbacher, J.P.; Falah, F.; Pirasteh, S.; Ngo, P.T.T.; Bui, D.T. Spatial Modeling of Snow Avalanche Using Machine Learning Models and Geo-Environmental Factors: Comparison of Effectiveness in Two Mountain Regions. Remote Sens. 2019, 11, 2995. [Google Scholar] [CrossRef] [Green Version]
  16. Ghorbanzadeh, O.; Blaschke, T.; Gholamnia, K.; Meena, S.R.; Tiede, D.; Aryal, J. Evaluation of different machine learning methods and deep-learning convolutional neural networks for landslide detection. Remote Sens. 2019, 11, 196. [Google Scholar] [CrossRef] [Green Version]
  17. Shao, Y.; Lunetta, R.S. Sub-pixel mapping of tree canopy, impervious surfaces, and cropland in the Laurentian Great Lakes Basin using MODIS time-series data. IEEE J. Sel. Top. Appl. Earth Obs. Remote Sens. 2010, 4, 336–347. [Google Scholar] [CrossRef]
  18. Franklin, S.E.; Ahmed, O.S.; Wulder, M.A.; White, J.C.; Hermosilla, T.; Coops, N.C. Large area mapping of annual land cover dynamics using multitemporal change detection and classification of Landsat time series data. Can. J. Remote Sens. 2015, 41, 293–314. [Google Scholar] [CrossRef]
  19. Goward, S.N.; Markham, B.; Dye, D.G.; Dulaney, W.; Yang, J. Normalized difference vegetation index measurements from the Advanced Very High Resolution Radiometer. Remote Sens. Environ. 1991, 35, 257–277. [Google Scholar] [CrossRef]
  20. Lunetta, R.S.; Shao, Y.; Ediriwickrema, J.; Lyon, J.G. Monitoring agricultural cropping patterns across the Laurentian Great Lakes Basin using MODIS-NDVI data. Int. J. Appl. Earth Obs. Geoinf. 2010, 12, 81–88. [Google Scholar] [CrossRef]
  21. Wand, M.P.; Jones, M.C. Kernel Smoothing; Chapman and Hall/CRC: London, UK, 1994. [Google Scholar]
  22. Simonoff, J.S. Smoothing Methods in Statistics; Springer Science & Business Media: Berlin, Germany, 2012. [Google Scholar]
  23. Chen, J.; Jönsson, P.; Tamura, M.; Gu, Z.; Matsushita, B.; Eklundh, L. A simple method for reconstructing a high-quality NDVI time-series data set based on the Savitzky–Golay filter. Remote Sens. Environ. 2004, 91, 332–344. [Google Scholar] [CrossRef]
  24. Cao, R.; Chen, Y.; Shen, M.; Chen, J.; Zhou, J.; Wang, C.; Yang, W. A simple method to improve the quality of NDVI time-series data by integrating spatiotemporal information with the Savitzky-Golay filter. Remote Sens. Environ. 2018, 217, 244–257. [Google Scholar] [CrossRef]
  25. Jonsson, P.; Eklundh, L. Seasonality extraction by function fitting to time-series of satellite sensor data. IEEE Trans. Geosci. Remote Sens. 2002, 40, 1824–1832. [Google Scholar] [CrossRef]
  26. Jönsson, P.; Eklundh, L. TIMESAT—A program for analyzing time-series of satellite sensor data. Comput. Geosci. 2004, 30, 833–845. [Google Scholar] [CrossRef] [Green Version]
  27. Sakamoto, T.; Yokozawa, M.; Toritani, H.; Shibayama, M.; Ishitsuka, N.; Ohno, H. A crop phenology detection method using time-series MODIS data. Remote Sens. Environ. 2005, 96, 366–374. [Google Scholar] [CrossRef]
  28. Geerken, R.; Zaitchik, B.; Evans, J. Classifying rangeland vegetation type and coverage from NDVI time series using Fourier Filtered Cycle Similarity. Int. J. Remote Sens. 2005, 26, 5535–5554. [Google Scholar] [CrossRef]
  29. Eilers, P.H. A perfect smoother. Anal. Chem. 2003, 75, 3631–3636. [Google Scholar] [CrossRef]
  30. Atzberger, C.; Eilers, P.H. Evaluating the effectiveness of smoothing algorithms in the absence of ground reference measurements. Int. J. Remote Sens. 2011, 32, 3689–3709. [Google Scholar] [CrossRef]
  31. Kong, D.; Zhang, Y.; Gu, X.; Wang, D. A robust method for reconstructing global MODIS EVI time series on the Google Earth Engine. ISPRS J. Photogramm. Remote Sens. 2019, 155, 13–24. [Google Scholar] [CrossRef]
  32. Khanal, N.; Uddin, K.; Matin, M.A.; Tenneson, K. Automatic Detection of Spatiotemporal Urban Expansion Patterns by Fusing OSM and Landsat Data in Kathmandu. Remote Sens. 2019, 11, 2296. [Google Scholar] [CrossRef] [Green Version]
  33. Shao, Y.; Lunetta, R.S.; Wheeler, B.; Iiames, J.S.; Campbell, J.B. An evaluation of time-series smoothing algorithms for land-cover classifications using MODIS-NDVI multi-temporal data. Remote Sens. Environ. 2016, 174, 258–265. [Google Scholar] [CrossRef]
  34. Atkinson, P.M.; Jeganathan, C.; Dash, J.; Atzberger, C. Inter-comparison of four models for smoothing satellite sensor time-series data to estimate vegetation phenology. Remote Sens. Environ. 2012, 123, 400–417. [Google Scholar] [CrossRef]
  35. Kandasamy, S.; Baret, F.; Verger, A.; Neveux, P.; Weiss, M. A comparison of methods for smoothing and gap filling time series of remote sensing observations-application to MODIS LAI products. Biogeosciences 2013, 10, 4055. [Google Scholar] [CrossRef] [Green Version]
  36. Vaiphasa, C. Consideration of smoothing techniques for hyperspectral remote sensing. ISPRS J. Photogramm. Remote Sens. 2006, 60, 91–99. [Google Scholar] [CrossRef]
  37. Schindler, K. An overview and comparison of smooth labeling methods for land-cover classification. IEEE Trans. Geosci. Remote Sens. 2012, 50, 4534–4545. [Google Scholar] [CrossRef]
  38. Saah, D.; Tenneson, K.; Poortinga, A.; Nguyen, Q.; Chishtie, F.; San Aung, K.; Markert, K.N.; Clinton, N.; Anderson, E.R.; Cutter, P.; et al. Primitives as building blocks for constructing land cover maps. Int. J. Appl. Earth Obs. Geoinf. 2020, 85, 101979. [Google Scholar] [CrossRef]
  39. Potapov, P.; Tyukavina, A.; Turubanova, S.; Talero, Y.; Hernandez-Serna, A.; Hansen, M.; Saah, D.; Tenneson, K.; Poortinga, A.; Aekakkararungroj, A.; et al. Annual continuous fields of woody vegetation structure in the Lower Mekong region from 2000-2017 Landsat time-series. Remote Sens. Environ. 2019, 232, 111278. [Google Scholar] [CrossRef]
  40. Poortinga, A.; Tenneson, K.; Shapiro, A.; Nquyen, Q.; San Aung, K.; Chishtie, F.; Saah, D. Mapping Plantations in Myanmar by Fusing Landsat-8, Sentinel-2 and Sentinel-1 Data along with Systematic Error Quantification. Remote Sens. 2019, 11, 831. [Google Scholar] [CrossRef] [Green Version]
  41. Poortinga, A.; Nguyen, Q.; Tenneson, K.; Troy, A.; Bhandari, B.; Ellenburg, W.L.; Aekakkararungroj, A.; Ha, L.T.; Pham, H.; Nguyen, G.V.; et al. Linking earth observations for assessing the food security situation in Vietnam: A landscape approach. Front. Environ. Sci. 2019, 7, 186. [Google Scholar] [CrossRef] [Green Version]
  42. Poortinga, A.; Aekakkararungroj, A.; Kityuttachai, K.; Nguyen, Q.; Bhandari, B.; Thwal, N.S.; Priestley, H.; Kim, J.; Tenneson, K.; Chishtie, F.; et al. Predictive Analytics for Identifying Land Cover Change Hotspots in the Mekong Region. Remote Sens. 2020, 12, 1472. [Google Scholar] [CrossRef]
  43. Uddin, K.; Shrestha, H.L.; Murthy, M.; Bajracharya, B.; Shrestha, B.; Gilani, H.; Pradhan, S.; Dangol, B. Development of 2010 national land cover database for the Nepal. J. Environ. Manag. 2015, 148, 82–90. [Google Scholar] [CrossRef]
  44. Bey, A.; Sánchez-Paus Díaz, A.; Maniatis, D.; Marchi, G.; Mollicone, D.; Ricci, S.; Bastin, J.F.; Moore, R.; Federici, S.; Rezende, M.; et al. Collect earth: Land use and land cover assessment through augmented visual interpretation. Remote Sens. 2016, 8, 807. [Google Scholar] [CrossRef] [Green Version]
  45. Saah, D.; Johnson, G.; Ashmall, B.; Tondapu, G.; Tenneson, K.; Patterson, M.; Poortinga, A.; Markert, K.; Quyen, N.H.; San Aung, K.; et al. Collect Earth: An online tool for systematic reference data collection in land cover and use applications. Environ. Model. Softw. 2019, 118, 166–171. [Google Scholar] [CrossRef]
  46. Atzberger, C.; Eilers, P.H. A time series for monitoring vegetation activity and phenology at 10-daily time steps covering large parts of South America. Int. J. Digit. Earth 2011, 4, 365–386. [Google Scholar] [CrossRef]
  47. Chountasis, S.; Katsikis, V.N.; Pappas, D.; Perperoglou, A. The whittaker smoother and the moore-penrose inverse in signal reconstruction. Appl. Math. Sci. 2012, 6, 1205–1219. [Google Scholar]
  48. Hermance, J.F.; Jacob, R.W.; Bradley, B.A.; Mustard, J.F. Extracting phenological signals from multiyear AVHRR NDVI time series: Framework for applying high-order annual splines with roughness damping. IEEE Trans. Geosci. Remote Sens. 2007, 45, 3264–3276. [Google Scholar] [CrossRef]
  49. Hermance, J.F. Stabilizing high-order, non-classical harmonic analysis of NDVI data for average annual models by damping model roughness. Int. J. Remote Sens. 2007, 28, 2801–2819. [Google Scholar] [CrossRef]
  50. Berman, M. Automated smoothing of image and other regularly spaced data. IEEE Trans. Pattern Anal. Mach. Intell. 1994, 16, 460–468. [Google Scholar] [CrossRef]
  51. Schmidt, K.; Skidmore, A. Smoothing vegetation spectra with wavelets. Int. J. Remote Sens. 2004, 25, 1167–1184. [Google Scholar] [CrossRef]
  52. Cochran, W.T.; Cooley, J.W.; Favin, D.L.; Helms, H.D.; Kaenel, R.A.; Lang, W.W.; Maling, G.C.; Nelson, D.E.; Rader, C.M.; Welch, P.D. What is the fast Fourier transform? Proc. IEEE 1967, 55, 1664–1674. [Google Scholar] [CrossRef]
  53. Guiñón, J.L.; Ortega, E.; García-Antón, J.; Pérez-Herranz, V. Moving average and Savitzki-Golay smoothing filters using Mathcad. Pap. ICEE 2007, 2007. [Google Scholar]
  54. Nagendra, H.; Karmacharya, M.; Karna, B. Evaluating forest management in Nepal: Views across space and time. Ecol. Soc. 2005, 10, 24. [Google Scholar] [CrossRef]
  55. Kennedy, R.E.; Yang, Z.; Cohen, W.B. Detecting trends in forest disturbance and recovery using yearly Landsat time series: 1. LandTrendr—Temporal segmentation algorithms. Remote Sens. Environ. 2010, 114, 2897–2910. [Google Scholar] [CrossRef]
  56. Verbesselt, J.; Hyndman, R.; Newnham, G.; Culvenor, D. Detecting trend and seasonal changes in satellite image time series. Remote Sens. Environ. 2010, 114, 106–115. [Google Scholar] [CrossRef]
  57. Mingwei, Z.; Qingbo, Z.; Zhongxin, C.; Jia, L.; Yong, Z.; Chongfa, C. Crop discrimination in Northern China with double cropping systems using Fourier analysis of time-series MODIS data. Int. J. Appl. Earth Obs. Geoinf. 2008, 10, 476–485. [Google Scholar] [CrossRef]
Figure 1. Province 1 (right) is located in the eastern part of Nepal (left). The different colours indicate the 2010 land cover classes.
Figure 1. Province 1 (right) is located in the eastern part of Nepal (left). The different colours indicate the 2010 land cover classes.
Remotesensing 12 02888 g001
Figure 2. Overall methodology of the study.
Figure 2. Overall methodology of the study.
Remotesensing 12 02888 g002
Figure 3. Exploring the nature of smoothing in composites, (a) un-smoothed data vs. smoothing applied on composites. NO = No smoothing applied, SCF = Fourier smoothing applied on composite, SCL = Linear-fit smoothing applied on composite, SCW = Whittaker smoothing applied on composite, (b) un-smoothed data vs. smoothing applied on primitives. SPF = Fourier smoothing applied on primitive, SPL = Linear-fit smoothing applied on primitive, SPW = Whittaker smoothing applied on primitive.
Figure 3. Exploring the nature of smoothing in composites, (a) un-smoothed data vs. smoothing applied on composites. NO = No smoothing applied, SCF = Fourier smoothing applied on composite, SCL = Linear-fit smoothing applied on composite, SCW = Whittaker smoothing applied on composite, (b) un-smoothed data vs. smoothing applied on primitives. SPF = Fourier smoothing applied on primitive, SPL = Linear-fit smoothing applied on primitive, SPW = Whittaker smoothing applied on primitive.
Remotesensing 12 02888 g003aRemotesensing 12 02888 g003b
Figure 4. Assessment of primitives prepared using different algorithms. NO = No smoothing applied, SCF = Fourier smoothing applied on composite, SCL = Linear-fit smoothing applied on composite, SCW = Whittaker smoothing applied on composite, SPF = Fourier smoothing applied on primitive, SPL = Linear-fit smoothing applied on primitive, SPW = Whittaker smoothing applied on primitive. The distance between red and blue box plots in the vertical axis shows the inter-class separability of a primitive.
Figure 4. Assessment of primitives prepared using different algorithms. NO = No smoothing applied, SCF = Fourier smoothing applied on composite, SCL = Linear-fit smoothing applied on composite, SCW = Whittaker smoothing applied on composite, SPF = Fourier smoothing applied on primitive, SPL = Linear-fit smoothing applied on primitive, SPW = Whittaker smoothing applied on primitive. The distance between red and blue box plots in the vertical axis shows the inter-class separability of a primitive.
Remotesensing 12 02888 g004
Figure 5. This figure shows forest (green) and other land cover (yellow) from 2013 to 2016 in the southern part of the study region. (ad) shows un-smoothened results for 2013, 2014, 2015 and 2016 respectively. Similarly, (eh) shows smoothened results for 2013, 2014, 2015 and 2016 respectively. A huge improvement can be seen in 2014. These are the final results generated from the best primitive set, i.e., picking best primitives after applying different algorithms on each primitive.
Figure 5. This figure shows forest (green) and other land cover (yellow) from 2013 to 2016 in the southern part of the study region. (ad) shows un-smoothened results for 2013, 2014, 2015 and 2016 respectively. Similarly, (eh) shows smoothened results for 2013, 2014, 2015 and 2016 respectively. A huge improvement can be seen in 2014. These are the final results generated from the best primitive set, i.e., picking best primitives after applying different algorithms on each primitive.
Remotesensing 12 02888 g005
Figure 6. Comparison of class wise accuracy before applying any smoothing and after selecting the best primitives from various smoothing results. In the plot, accuracy extends from 0% (at centre) to 100% (at the outer edges).
Figure 6. Comparison of class wise accuracy before applying any smoothing and after selecting the best primitives from various smoothing results. In the plot, accuracy extends from 0% (at centre) to 100% (at the outer edges).
Remotesensing 12 02888 g006
Table 1. Typology of the land cover classes used for the study.
Table 1. Typology of the land cover classes used for the study.
ClassDescription
forestLand covered with canopy vegetation and shrubs
croplandLand used for cultivation of crops
settlementLand containing artificial surfaces
wetlandAreas containing surface water, e.g., lakes and rivers
river bedSandy banks of water bodies especially rivers
grasslandLand covered with herbaceous plants that are not trees or shrubs
snowLand covered in snow
bareLand without vegetative cover and also not occupied by settlement
Table 2. Parameters used for smoothing algorithms.
Table 2. Parameters used for smoothing algorithms.
Smoothing AlgorithmParameters
Whittaker Smoothingsmoothing degree ( λ ) = 5
order of differences (d) = 3
Fourier Smoothingsmoothing degree (harmonics to preserve) = 2
Linear-Fit Smoothingwindow size = 3
Table 3. Comparison of overall land cover time-series accuracy using different approaches of smoothing.
Table 3. Comparison of overall land cover time-series accuracy using different approaches of smoothing.
Smoothing AlgorithmAccuracy
No smoothing0.7968
Fourier on primitive0.8268
Whittaker on primitive0.8297
Linear Fit on primitive0.8270
Fourier on composite0.8200
Whittaker on composite0.8294
Linear Fit on composite0.8217
Merged Using best Primitives0.8344

Share and Cite

MDPI and ACS Style

Khanal, N.; Matin, M.A.; Uddin, K.; Poortinga, A.; Chishtie, F.; Tenneson, K.; Saah, D. A Comparison of Three Temporal Smoothing Algorithms to Improve Land Cover Classification: A Case Study from NEPAL. Remote Sens. 2020, 12, 2888. https://0-doi-org.brum.beds.ac.uk/10.3390/rs12182888

AMA Style

Khanal N, Matin MA, Uddin K, Poortinga A, Chishtie F, Tenneson K, Saah D. A Comparison of Three Temporal Smoothing Algorithms to Improve Land Cover Classification: A Case Study from NEPAL. Remote Sensing. 2020; 12(18):2888. https://0-doi-org.brum.beds.ac.uk/10.3390/rs12182888

Chicago/Turabian Style

Khanal, Nishanta, Mir Abdul Matin, Kabir Uddin, Ate Poortinga, Farrukh Chishtie, Karis Tenneson, and David Saah. 2020. "A Comparison of Three Temporal Smoothing Algorithms to Improve Land Cover Classification: A Case Study from NEPAL" Remote Sensing 12, no. 18: 2888. https://0-doi-org.brum.beds.ac.uk/10.3390/rs12182888

Note that from the first issue of 2016, this journal uses article numbers instead of page numbers. See further details here.

Article Metrics

Back to TopTop