|
TNTmips Downloads Menu
|
LandsatCalibrationPilot.sml
##################################################################################################################
# DiskFile : LandsatCalibrationPilot.sml
# Programmer : Ralf Koller
# Created : 09.10.2003
# Revisions : 1.0 rc2
# Coming next : 1) Slimming the code when the feature passing arrays to functions is implented by microimages
# 2) A refined master selection routine... So far the routine is vulnerable to clouds in scene
# according to them the spread could be stilted...
# 3) The possibility to choose the number of input scenes
# 4) Adding the possibilty to select between (D)ark (O)bject (S)ubstraction 1-3
# 5) The possibility to write the console output directly into a textfile
# 6) If a under number of PIFs was found, the possibility to reenter their number via a pop-up
# 7) The Implementation of a calibration routine for Landsat TM 4 sensors
# 8) So far only congruent scenes get calibrated, but a future aim is to implent the BRDF correction
# so that it will be possible to normalize each part of a mosaiced scene too. Additionaly a auto-
# selection between PIF (for congruent) and BRDF (for mosaiced scenes) routines will be also pro-
# vided and if necessary the user will be able to select how many steps to perform. So it will be
# also possible to perform only the radiance raster computation or only a reflectance raster
# output
# 9) To pipeline all the routines into a externe c programm to slim and fasten up the whole compu-
# tation processes
# 10) The possibility to process scenes with a different cell size
# 11) To lookup the necessary calibration values directly out of the headerfiles
#
##################################################################################################################
#
# Function : At first the script computes age adjusted radiance and atmosphere corrected (DOS 1) reflectance
# rasters. In the next step four soil brightness index rasters are computed and the spreads are
# compared. The scene with the widest spread becomes the master scene (In a mixed setup - MSS to-
# gether with TM and/or ETM - only TM and ETM are able to become the new master). Now each scene
# gets sorted and the dark and bright histogram tails which are similar to the invariant features
# soil and water, are written to PIF masks. Only pixels which are available in all scenes or scene
# pairs are taken into account. In the next step a user defined number of pseudo invariant features
# is chosen randomly. Those are taken into account for the calculation of the regression coefficents,
# correlation coefficents, the level of confidence and the standard deviation of the regression co-
# efficients. So there is still the possibilty to rerun the regression calculation in a statistic
# programm like SPSS or R in the case that the control values indicate a further investigation. In
# the end the reflectance scene of the master is transfered into the output scene. Additionally the
# slave scenes are adjusted via the regression coefficents and are also written into the userdefined
# outputfiles. In the case MSS scenes were processed with a TM or ETM master scene only MSS band 1,
# 2 and 4 got normalized. Band 3 is just a simple not normalized reflectance band...
#
##################################################################################################################
#
# Usage : - You have to enter 4 scenes. In the case you have less than 4 scenes just double enter one of
# them. If the double entered scene becomes the slave scene, everything should be ok, other-
# wise let me know and i'll send you a modified version of the script.
# - All used scenes must have the same cell and image size while covering the same area
#
##################################################################################################################
#
# Credits : Main Code Assistance - Wolfgang Riedl (Siemens A&D ATS 14 - Germany)
# Shell Sort Algorithm - Dan Glasser (Tech Support - Microimages Inc. - Usa)
#
##################################################################################################################
##################################################################################################################
#
# References : Price, J.C. (1987): Calibration of Satellite Radiometers and the Comparison of Vegetation
# Indices. In: Remote Sensing Of Environment, 21, p. 15-27
#
# Samimi, C. (2003): Das Weidepotential im Gutu Distrikt (Zimbabwe) - Möglichkeiten und Grenzen
# Modellierung unter Verwendung von Landsat TM-5. In: Karlsruher Schriften zur Geographie und
# Geoökologie, 19
#
# Fedosejevs, G., Teillet, P.M. (1995): On the dark target approach to atmospheric correction of
# remotely sensed data. In: Canadian Journal of Remote Sensing, 21, 4, p. 374-387
#
# Teillet, P.M., Helder, D.L., Markham, B.L., Barker, J.L., Thome, K.J., Morfitt, R., Schott, J.R.,
# Palluconi, F.D. (2001): A Lifetime Radiometric Calibration Record for the Landsat Thematic Mapper.
# In: Proceedings of the 23rd Canadian Symposium on Remote Sensing. Quebec.
#
# Song, C., Woodcock, C.E., Seto, K. C., Lenney M.P., Macomber S. A. (2001): Classification and
# Change Detection Using Landsat TM Data: When and How to Correct Atmospheric Effects?. In: Remote
# Sensing of Environment, 75, p. 230-244
#
# Muramatsu, K., Furumi, S., Fujiwara, N. Hayashi, A., Daigo, M., Ochiai, F. (2000): Pattern
# decomposition method in the albedo space for Landsat TM and MSS data analysis. In: International
# Journal of Remote Sensing, 21, 1, p. 99-119
#
# Schott, J.R., Salvaggio, C., Volchok, W.J. (1988): Radiometric Scene Normalization Using Pseudo
# Invariant Features. In: Remote Sensing Of Environment, 26, p. 1-16
#
#
# ETM zones see:
# http://ltpwww.gsfc.nasa.gov/IAS/handbook/handbook_htmls/chapter6/chapter6.html#section6.4.2
#
##################################################################################################################
##################################################################################################################
#
# DISCLAIMER : The usage of the script is for free but a commercial adoption isn't permitted. Please be so kind
# to contact me and inform me if you have used or are using the script. Suggestions for optimization
# purpose and submission of bug reports are also welcome. Thanks a lot... r.
#
# Contact : Ralf Koller ( rpk@gmx.net )
# Student of Geography - FAU Erlangen-Nuernberg - Germany
# Supervising: PD Dr. Cyrus Samimi
#
##################################################################################################################
$warnings 3
##############################################
######### Global Variable Declaration ########
##############################################
class XMLDOC docmain; # class instance for XML text containing main dialog specification
class XMLNODE nodemain; # XMLNODE for main dialog window
class GUI_DLG dlgmain; # dialog class for main dialog window
class XMLDOC docs1; # class instance for XML text contain Scene 1 dialog specification
class XMLNODE nodes1; # XMLNODE for Scene 1 dialog
class GUI_DLG dlgs1; # dialog class for Scene 1 dialog
class XMLDOC docs2; # class instance for XML text contain Scene 2 dialog specification
class XMLNODE nodes2; # XMLNODE for Scene 2 dialog
class GUI_DLG dlgs2; # dialog class for Scene 2 dialog
class XMLDOC docs3; # class instance for XML text contain Scene 3 dialog specification
class XMLNODE nodes3; # XMLNODE for Scene 3 dialog
class GUI_DLG dlgs3; # dialog class for Scene 3 dialog
class XMLDOC docs4; # class instance for XML text contain Scene 4 dialog specification
class XMLNODE nodes4; # XMLNODE for Scene 4 dialog
class GUI_DLG dlgs4; # dialog class for Scene 4 dialog
class DATETIME s1yyyymmdd;
class DATETIME s2yyyymmdd;
class DATETIME s3yyyymmdd;
class DATETIME s4yyyymmdd;
array accumulate[12]; # Norm Year Value Array
array accumulateLY[12]; # Leap Year Value Array
numeric ESMSS11, ESMSS12, ESMSS13, ESMSS14;
numeric ESMSS41, ESMSS42, ESMSS43, ESMSS44;
numeric ESMSS51, ESMSS52, ESMSS53, ESMSS54;
numeric ESTM1, ESTM2, ESTM3, ESTM4, ESTM5, ESTM7;
numeric ESETM1, ESETM2, ESETM3, ESETM4, ESETM5, ESETM7;
numeric QCALMAX, QCALMIN;
numeric B1LGLMINBef2000, B2LGLMINBef2000, B3LGLMINBef2000, B4LGLMINBef2000, B5LGLMINBef2000, B7LGLMINBef2000;
numeric B1LGLMAXBef2000, B2LGLMAXBef2000, B3LGLMAXBef2000, B4LGLMAXBef2000, B5LGLMAXBef2000, B7LGLMAXBef2000;
numeric B1HGLMINBef2000, B2HGLMINBef2000, B3HGLMINBef2000, B4HGLMINBef2000, B5HGLMINBef2000, B7HGLMINBef2000;
numeric B1HGLMAXBef2000, B2HGLMAXBef2000, B3HGLMAXBef2000, B4HGLMAXBef2000, B5HGLMAXBef2000, B7HGLMAXBef2000;
numeric B1LGLMINAFT2000, B2LGLMINAFT2000, B3LGLMINAFT2000, B4LGLMINAFT2000, B5LGLMINAFT2000, B7LGLMINAFT2000;
numeric B1LGLMAXAFT2000, B2LGLMAXAFT2000, B3LGLMAXAFT2000, B4LGLMAXAFT2000, B5LGLMAXAFT2000, B7LGLMAXAFT2000;
numeric B1HGLMINAFT2000, B2HGLMINAFT2000, B3HGLMINAFT2000, B4HGLMINAFT2000, B5HGLMINAFT2000, B7HGLMINAFT2000;
numeric B1HGLMAXAFT2000, B2HGLMAXAFT2000, B3HGLMAXAFT2000, B4HGLMAXAFT2000, B5HGLMAXAFT2000, B7HGLMAXAFT2000;
numeric L1B1gain, L1B2gain, L1B3gain, L1B4gain;
numeric L1B1bias;
numeric L2B1bef75gain, L2B2bef75gain, L2B3bef75gain, L2B4bef75gain;
numeric L2B1bef75bias, L2B2bef75bias, L2B3bef75bias, L2B4bef75bias;
numeric L2B1aft75gain, L2B2aft75gain, L2B3aft75gain, L2B4aft75gain;
numeric L2B1aft75bias, L2B2aft75bias, L2B3aft75bias, L2B4aft75bias;
numeric L2B1aft79gain, L2B2aft79gain, L2B3aft79gain, L2B4aft79gain;
numeric L2B1aft79bias, L2B2aft79bias, L2B3aft79bias, L2B4aft79bias;
numeric L3B1bef78gain, L3B2bef78gain, L3B3bef78gain, L3B4bef78gain;
numeric L3B1bef78bias, L3B2bef78bias, L3B3bef78bias, L3B4bef78bias;
numeric L3B17879gain, L3B27879gain, L3B37879gain, L3B47879gain;
numeric L3B17879bias, L3B27879bias, L3B37879bias, L3B47879bias;
numeric L3B1aft79gain, L3B2aft79gain, L3B3aft79gain, L3B4aft79gain;
numeric L3B1aft79bias, L3B2aft79bias, L3B3aft79bias, L3B4aft79bias;
numeric L4B1bef83gain, L4B2bef83gain, L4B3bef83gain, L4B4bef83gain;
numeric L4B1bef83bias, L4B2bef83bias, L4B3bef83bias, L4B4bef83bias;
numeric L4B1aft83gain, L4B2aft83gain, L4B3aft83gain, L4B4aft83gain;
numeric L4B1aft83bias, L4B2aft83bias, L4B3aft83bias, L4B4aft83bias;
numeric L5B1bef84gain, L5B2bef84gain, L5B3bef84gain, L5B4bef84gain;
numeric L5B1bef84bias, L5B2bef84bias, L5B3bef84bias, L5B4bef84bias;
numeric L5B1aft84gain, L5B2aft84gain, L5B3aft84gain, L5B4aft84gain;
numeric L5B1aft84bias, L5B2aft84bias, L5B3aft84bias, L5B4aft84bias;
numeric biasnewTMb1, biasnewTMb2, biasnewTMb3, biasnewTMb4, biasnewTMb5, biasnewTMb7;
numeric i, j, m, n, o;
numeric ETMlins, ETMcols, TMlins, TMcols, MSSlins, MSScols; # number of lines and columns in input raster set
numeric Scene1Lin, Scene2Lin, Scene3Lin, Scene4Lin; # vertical size of a input raster cell
numeric Scene1Col, Scene2Col, Scene3Col, Scene4Col; # horizontal size of a input raster cell
numeric sensors1, sensors2, sensors3, sensors4; # sensor identification number (Differencing TM and 5 MSS sensor models)
string xmlmain$, xmls1$, xmls2$, xmls3$, xmls4$; # string IDs for main and parameter windows
numeric err, err1, err2, err3, err4; # error numeric variables
numeric ret, ret1, ret2, ret3, ret4; # return numeric variables
numeric createMETA;
numeric earSurCat1, earSurCat2, earSurCat3, earSurCat4; # Earth Surface Categories Identification numers
numeric s1aq, s2aq, s3aq, s4aq; # numeric input for Aquisition Date of the scene
numeric s1ele, s2ele, s3ele, s4ele; # numeric input for sun elevation
numeric s1zenith, s2zenith, s3zenith, s4zenith; # sun zenith
numeric s1zenithSIMPLE, s2zenithSIMPLE, s3zenithSIMPLE, s4zenithSIMPLE;
numeric s1leap, s2leap, s3leap, s4leap;
numeric s1jul, s2jul, s3jul, s4jul; # Julian date
numeric s1year, s2year, s3year, s4year; # Year number extracted from sxaqui
numeric s1month, s2month, s3month, s4month; # Month number extracted from sxaqui
numeric s1day, s2day, s3day, s4day; # Day number extracted from sxaqui
numeric dist1, dist2, dist3, dist4; # Earth Sundistance
numeric pifDarkVAL, pifBrightVAL, minPifVAL, histoTailInputVAL; # numeric input for PIF normalization
numeric sbi1min, sbi1max, sbi1mean, sbi1sd; # numeric values for SBI 1 raster statistics
numeric sbi2min, sbi2max, sbi2mean, sbi2sd; # numeric values for SBI 2 raster statistics
numeric sbi3min, sbi3max, sbi3mean, sbi3sd; # numeric values for SBI 3 raster statistics
numeric sbi4min, sbi4max, sbi4mean, sbi4sd; # numeric values for SBI 4 raster statistics
numeric sbi1spread, sbi2spread, sbi3spread, sbi4spread; # sbi max min differences
numeric slaveMaster = 0; # Master 1=scene1 2=scene2 3=scene3 4=scene4
##############################################
######### Global Constant Declaration ########
##############################################
accumulate[1] = 0; # Norm Year Values
accumulate[2] = 31;
accumulate[3] = 59;
accumulate[4] = 90;
accumulate[5] = 120;
accumulate[6] = 151;
accumulate[7] = 181;
accumulate[8] = 212;
accumulate[9] = 243;
accumulate[10] = 273;
accumulate[11] = 304;
accumulate[12] = 334;
accumulateLY[1] = 0; # Leap Year Values
accumulateLY[2] = 31;
accumulateLY[3] = 60;
accumulateLY[4] = 91;
accumulateLY[5] = 121;
accumulateLY[6] = 152;
accumulateLY[7] = 182;
accumulateLY[8] = 213;
accumulateLY[9] = 244;
accumulateLY[10] = 274;
accumulateLY[11] = 305;
accumulateLY[12] = 335;
biasnewTMb1 = 2.523; #Lifetime Biases for Landsat TM5
biasnewTMb2 = 2.417;
biasnewTMb3 = 1.452;
biasnewTMb4 = 1.854;
biasnewTMb5 = 3.423;
biasnewTMb7 = 2.633;
ESMSS11 = 1844.114888; # ES Values for Landsat MSS1, MSS2, MSS3 - Price 1988
ESMSS12 = 1573.937919;
ESMSS13 = 1288.052988;
ESMSS14 = 901.6370916;
ESMSS41 = 1834.69011; # ES Values for Landsat MSS4 - Price 1988
ESMSS42 = 1595.929068;
ESMSS43 = 1266.061839;
ESMSS44 = 867.0795724;
ESMSS51 = 1834.69011; # ES Values for Landsat MSS5 - Price 1988
ESMSS52 = 1595.929068;
ESMSS53 = 1262.920247;
ESMSS54 = 863.9379797;
ESTM1 = 1959.2; # ES Values for Landsat TM - Fedosejevs 1995
ESTM2 = 1827.4;
ESTM3 = 1550.0;
ESTM4 = 1040.8;
ESTM5 = 220.75;
ESTM7 = 74.960;
ESETM1 = 1969.000; # ES Values for Landsat ETM - User Handbook
ESETM2 = 1840.000;
ESETM3 = 1551.000;
ESETM4 = 1044.000;
ESETM5 = 225.700;
ESETM7 = 82.07;
QCALMAX = 255; # Maximum digital value for Landsat ETM
QCALMIN = 1; # Minimum digital value for Landsat ETM
B1LGLMINBef2000 = -6.2; # LOW GAIN BEFORE 2000 (LMIN)
B2LGLMINBef2000 = -6.0;
B3LGLMINBef2000 = -4.5;
B4LGLMINBef2000 = -4.5;
B5LGLMINBef2000 = -1.0;
B7LGLMINBef2000 = -0.35;
B1LGLMAXBef2000 = 297.5; # LOW GAIN BEFORE 2000 (LMAX)
B2LGLMAXBef2000 = 303.4;
B3LGLMAXBef2000 = 235.5;
B4LGLMAXBef2000 = 235.0;
B5LGLMAXBef2000 = 47.7;
B7LGLMAXBef2000 = 16.6;
B1HGLMINBef2000 = -6.2; #HIGH GAIN BEFORE 2000 (LMIN)
B2HGLMINBef2000 = -6.0;
B3HGLMINBef2000 = -4.5;
B4HGLMINBef2000 = -4.5;
B5HGLMINBef2000 = -1.0;
B7HGLMINBef2000 = -0.35;
B1HGLMAXBef2000 = 194.3; #HIGH GAIN BEFORE 2000 (LMAX)
B2HGLMAXBef2000 = 202.4;
B3HGLMAXBef2000 = 158.6;
B4HGLMAXBef2000 = 157.5;
B5HGLMAXBef2000 = 31.76;
B7HGLMAXBef2000 = 10.932;
B1LGLMINAFT2000 = -6.2; #LOW GAIN AFTER 2000 (LMIN)
B2LGLMINAFT2000 = -6.4;
B3LGLMINAFT2000 = -5.0;
B4LGLMINAFT2000 = -5.1;
B5LGLMINAFT2000 = -1.0;
B7LGLMINAFT2000 = -0.35;
B1LGLMAXAFT2000 = 293.7; #LOW GAIN AFTER 2000 (LMAX)
B2LGLMAXAFT2000 = 300.9;
B3LGLMAXAFT2000 = 234.4;
B4LGLMAXAFT2000 = 241.1;
B5LGLMAXAFT2000 = 47.57;
B7LGLMAXAFT2000 = 16.54;
B1HGLMINAFT2000 = -6.2; #HIGH GAIN AFTER 2000 (LMIN)
B2HGLMINAFT2000 = -6.4;
B3HGLMINAFT2000 = -5.0;
B4HGLMINAFT2000 = -5.1;
B5HGLMINAFT2000 = -1.0;
B7HGLMINAFT2000 = -0.35;
B1HGLMAXAFT2000 = 191.6; #HIGH GAIN AFTER 2000 (LMAX)
B2HGLMAXAFT2000 = 196.5;
B3HGLMAXAFT2000 = 152.9;
B4HGLMAXAFT2000 = 157.4;
B5HGLMAXAFT2000 = 31.06;
B7HGLMAXAFT2000 = 10.80;
L1B1gain = 1.95; # Landsat1 Gain and bias calibration constants
L1B2gain = 1.57;
L1B3gain = 1.39;
L1B4gain = 2.43;
L1B1bias = 0.0;
L2B1bef75gain = 1.57; # Landsat2 Gain and bias calibration constants before 16.Juli7
L2B2bef75gain = 1.17;
L2B3bef75gain = 1.05;
L2B4bef75gain = 2.12;
L2B1bef75bias = 10;
L2B2bef75bias = 7;
L2B3bef75bias = 7;
L2B4bef75bias = 5;
L2B1aft75gain = 2.01; # Landsat2 Gain and bias calibration constants after 16.Juli75
L2B2aft75gain = 1.34;
L2B3aft75gain = 1.15;
L2B4aft75gain = 2.01;
L2B1aft75bias = 8;
L2B2aft75bias = 6;
L2B3aft75bias = 6;
L2B4aft75bias = 4;
L2B1aft79gain = 2.01; # Landsat2 Gain and bias calibration constants after 1.Feb79
L2B2aft79gain = 1.34;
L2B3aft79gain = 1.15;
L2B4aft79gain = 1.01;
L2B1aft79bias = 8;
L2B2aft79bias = 6;
L2B3aft79bias = 6;
L2B4aft79bias = 4;
L3B1bef78gain = 1.70; # Landsat3 Gain and bias calibration constants Before1Jun78
L3B2bef78gain = 1.35;
L3B3bef78gain = 1.12;
L3B4bef78gain = 2.32;
L3B1bef78bias = 4;
L3B2bef78bias = 3;
L3B3bef78bias = 3;
L3B4bef78bias = 1;
L3B17879gain = 2.01; # Landsat3 Gain and bias calibration constants 2Jun78 to 1Feb7
L3B27879gain = 1.39;
L3B37879gain = 1.15;
L3B47879gain = 2.02;
L3B17879bias = 4;
L3B27879bias = 3;
L3B37879bias = 3;
L3B47879bias = 1;
L3B1aft79gain = 2.01; # Landsat3 Gain and bias calibration constants after 1.Feb79
L3B2aft79gain = 1.39;
L3B3aft79gain = 1.15;
L3B4aft79gain = 1.00;
L3B1aft79bias = 4;
L3B2aft79bias = 3;
L3B3aft79bias = 3;
L3B4aft79bias = 1;
L4B1bef83gain = 1.80; # Landsat4 Gain and bias calibration constants Before 1april83
L4B2bef83gain = 1.39;
L4B3bef83gain = 0.99;
L4B4bef83gain = 1.02;
L4B1bef83bias = 2;
L4B2bef83bias = 4;
L4B3bef83bias = 4;
L4B4bef83bias = 3;
L4B1aft83gain = 1.84; # Landsat4 Gain and bias calibration constants after 1 april83
L4B2aft83gain = 1.26;
L4B3aft83gain = 1.08;
L4B4aft83gain = 0.88;
L4B1aft83bias = 4;
L4B2aft83bias = 4;
L4B3aft83bias = 5;
L4B4aft83bias = 4;
L5B1bef84gain = 2.08; # Landsat5 Gain and bias calibration constants before 9 Nov 84
L5B2bef84gain = 1.39;
L5B3bef84gain = 1.22;
L5B4bef84gain = 0.94;
L5B1bef84bias = 3;
L5B2bef84bias = 3;
L5B3bef84bias = 4;
L5B4bef84bias = 4;
L5B1aft84gain = 2.08; # Landsat5 Gain and bias calibration constants after 9 Nov 84
L5B2aft84gain = 1.39;
L5B3aft84gain = 1.13;
L5B4aft84gain = 0.94;
L5B1aft84bias = 3;
L5B2aft84bias = 3;
L5B3aft84bias = 5;
L5B4aft84bias = 4;
#####################################################################
#####################################################################
################ Procedure Definitions ############################
#####################################################################
#####################################################################
#####################################
### Callback procedure to initally disable OK-
### button on main dialog window when it opens
#####################################
proc OnOpenMain () {
dlgmain.SetOkEnabled( 0 );
}
##################################
### Procedure to select SZENE 1
##################################
proc SELECTS1 ()
{
sensors1 = dlgmain.GetCtrlByID( "comps1" ).GetValueNum();
if ( sensors1 == 7 )
{
raster ETM1BAND1, ETM1BAND2, ETM1BAND3, ETM1BAND4, ETM1BAND5, ETM1BAND7; # szene 1 ETM input bands
GetInputRasters(ETM1BAND1, ETM1BAND2, ETM1BAND3, ETM1BAND4, ETM1BAND5, ETM1BAND7);
ETMlins = NumLins(ETM1BAND1);
ETMcols = NumCols(ETM1BAND1);
Scene1Lin = LinScale(ETM1BAND1);
Scene1Col = ColScale(ETM1BAND1);
}
else if ( sensors1 == 6 )
{
raster TM1BAND1, TM1BAND2, TM1BAND3, TM1BAND4, TM1BAND5, TM1BAND7; # szene 1 TM input bands
GetInputRasters(TM1BAND1, TM1BAND2, TM1BAND3, TM1BAND4, TM1BAND5, TM1BAND7);
TMlins = NumLins(TM1BAND1);
TMcols = NumCols(TM1BAND1);
Scene1Lin = LinScale(TM1BAND1);
Scene1Col = ColScale(TM1BAND1);
}
else
{
raster MSS1BAND1, MSS1BAND2, MSS1BAND3, MSS1BAND4; # szene 1 MSS input bands
GetInputRasters(MSS1BAND1, MSS1BAND2, MSS1BAND3, MSS1BAND4);
MSSlins = NumLins(MSS1BAND1);
MSScols = NumCols(MSS1BAND1);
Scene1Lin = LinScale(MSS1BAND1);
Scene1Col = ColScale(MSS1BAND1);
}
}
##################################
### Procedure to select SZENE 2
##################################
proc SELECTS2 ()
{
sensors2 = dlgmain.GetCtrlByID( "comps2" ).GetValueNum();
if ( sensors2 == 7 )
{
raster ETM2BAND1, ETM2BAND2, ETM2BAND3, ETM2BAND4, ETM2BAND5, ETM2BAND7; # szene 2 ETM input bands
GetInputRasters(ETM2BAND1, ETM2BAND2, ETM2BAND3, ETM2BAND4, ETM2BAND5, ETM2BAND7);
Scene2Lin = LinScale(ETM2BAND1);
Scene2Col = ColScale(ETM2BAND1);
if ( ETMlins == 0 )
{
ETMlins = NumLins(ETM2BAND1);
ETMcols = NumCols(ETM2BAND1);
}
}
else if ( sensors2 == 6 )
{
raster TM2BAND1, TM2BAND2, TM2BAND3, TM2BAND4, TM2BAND5, TM2BAND7; # szene 2 TM input bands
GetInputRasters(TM2BAND1, TM2BAND2, TM2BAND3, TM2BAND4, TM2BAND5, TM2BAND7);
Scene2Lin = LinScale(TM2BAND1);
Scene2Col = ColScale(TM2BAND1);
if (TMlins == 0)
{
TMlins = NumLins(TM2BAND1);
TMcols = NumCols(TM2BAND1);
}
}
else
{
raster MSS2BAND1, MSS2BAND2, MSS2BAND3, MSS2BAND4; # szene 2 MSS input bands
GetInputRasters(MSS2BAND1, MSS2BAND2, MSS2BAND3, MSS2BAND4);
Scene2Lin = LinScale(MSS2BAND1);
Scene2Col = ColScale(MSS2BAND1);
if ( MSSlins == 0 )
{
MSSlins = NumLins(MSS2BAND1);
MSScols = NumCols(MSS2BAND1);
}
}
}
##################################
### Procedure to select SZENE 3
##################################
proc SELECTS3 ()
{
sensors3 = dlgmain.GetCtrlByID( "comps3" ).GetValueNum();
if (sensors3 == 7)
{
raster ETM3BAND1, ETM3BAND2, ETM3BAND3, ETM3BAND4, ETM3BAND5, ETM3BAND7; # szene 3 ETM input bands
GetInputRasters(ETM3BAND1, ETM3BAND2, ETM3BAND3, ETM3BAND4, ETM3BAND5, ETM3BAND7);
Scene3Lin = LinScale(ETM3BAND1);
Scene3Col = ColScale(ETM3BAND1);
if (ETMlins == 0)
{
ETMlins = NumLins(ETM3BAND1);
ETMcols = NumCols(ETM3BAND1);
}
}
else if ( sensors3 == 6 )
{
raster TM3BAND1, TM3BAND2, TM3BAND3, TM3BAND4, TM3BAND5, TM3BAND7; # szene 3 TM input bands
GetInputRasters(TM3BAND1, TM3BAND2, TM3BAND3, TM3BAND4, TM3BAND5, TM3BAND7);
Scene3Lin = LinScale(TM3BAND1);
Scene3Col = ColScale(TM3BAND1);
if (TMlins == 0)
{
TMlins = NumLins(TM3BAND1);
TMcols = NumCols(TM3BAND1);
}
}
else
{
raster MSS3BAND1, MSS3BAND2, MSS3BAND3, MSS3BAND4; # szene 3 MSS input bands
GetInputRasters(MSS3BAND1, MSS3BAND2, MSS3BAND3, MSS3BAND4);
Scene3Lin = LinScale(MSS3BAND1);
Scene3Col = ColScale(MSS3BAND1);
if (MSSlins == 0)
{
MSSlins = NumLins(MSS3BAND1);
MSScols = NumCols(MSS3BAND1);
}
}
}
##################################
### Procedure to select SZENE 4
##################################
proc SELECTS4 ()
{
sensors4 = dlgmain.GetCtrlByID( "comps4" ).GetValueNum();
if ( sensors4 == 7 )
{
raster ETM4BAND1, ETM4BAND2, ETM4BAND3, ETM4BAND4, ETM4BAND5, ETM4BAND7; # szene 4 ETM input bands
GetInputRasters(ETM4BAND1, ETM4BAND2, ETM4BAND3, ETM4BAND4, ETM4BAND5, ETM4BAND7);
Scene4Lin = LinScale(ETM4BAND1);
Scene4Col = ColScale(ETM4BAND1);
if ( ETMlins == 0 )
{
ETMlins = NumLins(ETM4BAND1);
ETMcols = NumCols(ETM4BAND1);
}
}
else if ( sensors4 == 6 )
{
raster TM4BAND1, TM4BAND2, TM4BAND3, TM4BAND4, TM4BAND5, TM4BAND7; # szene 4 TM input bands
GetInputRasters(TM4BAND1, TM4BAND2, TM4BAND3, TM4BAND4, TM4BAND5, TM4BAND7);
Scene4Lin = LinScale(TM4BAND1);
Scene4Col = ColScale(TM4BAND1);
if ( TMlins == 0 )
{
TMlins = NumLins(TM4BAND1);
TMcols = NumCols(TM4BAND1);
}
}
else
{
raster MSS4BAND1, MSS4BAND2, MSS4BAND3, MSS4BAND4; # szene 4 MSS input bands
GetInputRasters(MSS4BAND1, MSS4BAND2, MSS4BAND3, MSS4BAND4);
Scene4Lin = LinScale(MSS4BAND1);
Scene4Col = ColScale(MSS4BAND1);
if ( MSSlins == 0 )
{
MSSlins = NumLins(MSS4BAND1);
MSScols = NumCols(MSS4BAND1);
}
}
}
###################################################################################################
###### Procedure to prompt for values for SZENE 1
###################################################################################################
proc SPECS1 () {
if ( sensors1 == 7 )
{
xmls1$ = '
';
err1 = docs1.Parse(xmls1$);
if ( err1 < 0 ) {
PopupError( err1 );
Exit( );
}
nodes1 = docs1.GetElementByID( "dlgs1" );
if ( nodes1 == 0 ) {
PopupMessage( "Could not find dialog node in XML document" );
Exit();
}
dlgs1.SetXMLNode( nodes1 );
ret1 = dlgs1.DoModal();
if (ret1 == -1)
{
Exit();
}
earSurCat1 = dlgs1.GetCtrlByID( "esc1" ).GetValueNum();
s1aq = dlgs1.GetCtrlByID("s1aqui").GetValueNum();
s1ele = dlgs1.GetCtrlByID("s1elevation").GetValueNum();
}
else if ( sensors1 == 6 )
{
xmls1$ = '
';
err1 = docs1.Parse(xmls1$);
if ( err1 < 0 ) {
PopupError( err1 ); # pop up an error dialog
Exit( );
}
nodes1 = docs1.GetElementByID( "dlgs1" );
if ( nodes1 == 0 ) {
PopupMessage( "Could not find dialog node in XML document" );
Exit();
}
dlgs1.SetXMLNode( nodes1 );
ret1 = dlgs1.DoModal();
if (ret1 == -1)
{
Exit();
}
numeric s1TMg1, s1TMg2, s1TMg3, s1TMg4, s1TMg5, s1TMg7;
numeric s1TMb1, s1TMb2, s1TMb3, s1TMb4, s1TMb5, s1TMb7;
s1aq = dlgs1.GetCtrlByID("s1aqui").GetValueNum();
s1ele = dlgs1.GetCtrlByID("s1elevation").GetValueNum();
s1TMg1 = dlgs1.GetCtrlByID("ss1TMg1").GetValueNum();
s1TMg2 = dlgs1.GetCtrlByID("ss1TMg2").GetValueNum();
s1TMg3 = dlgs1.GetCtrlByID("ss1TMg3").GetValueNum();
s1TMg4 = dlgs1.GetCtrlByID("ss1TMg4").GetValueNum();
s1TMg5 = dlgs1.GetCtrlByID("ss1TMg5").GetValueNum();
s1TMg7 = dlgs1.GetCtrlByID("ss1TMg7").GetValueNum();
s1TMb1 = dlgs1.GetCtrlByID("ss1TMb1").GetValueNum();
s1TMb2 = dlgs1.GetCtrlByID("ss1TMb2").GetValueNum();
s1TMb3 = dlgs1.GetCtrlByID("ss1TMb3").GetValueNum();
s1TMb4 = dlgs1.GetCtrlByID("ss1TMb4").GetValueNum();
s1TMb5 = dlgs1.GetCtrlByID("ss1TMb5").GetValueNum();
s1TMb7 = dlgs1.GetCtrlByID("ss1TMb7").GetValueNum();
}
else if ( sensors1 == 5 )
{
xmls1$ = '
';
err1 = docs1.Parse(xmls1$);
if ( err1 < 0 ) {
PopupError( err1 ); # pop up an error dialog
Exit( );
}
nodes1 = docs1.GetElementByID( "dlgs1" );
if ( nodes1 == 0 ) {
PopupMessage( "Could not find dialog node in XML document" );
Exit();
}
dlgs1.SetXMLNode( nodes1 );
ret1 = dlgs1.DoModal();
if (ret1 == -1)
{
Exit();
}
s1aq = dlgs1.GetCtrlByID("s1aqui").GetValueNum();
s1ele = dlgs1.GetCtrlByID("s1elevation").GetValueNum();
}
else if ( sensors1 == 4 )
{
xmls1$ = '
';
err1 = docs1.Parse(xmls1$);
if ( err1 < 0 ) {
PopupError( err1 );
Exit( );
}
nodes1 = docs1.GetElementByID( "dlgs1" );
if ( nodes1 == 0 ) {
PopupMessage( "Could not find dialog node in XML document" );
Exit();
}
dlgs1.SetXMLNode( nodes1 );
ret1 = dlgs1.DoModal();
if (ret1 == -1)
{
Exit();
}
s1aq = dlgs1.GetCtrlByID("s1aqui").GetValueNum();
s1ele = dlgs1.GetCtrlByID("s1elevation").GetValueNum();
}
else if ( sensors1 == 3 )
{
xmls1$ = '
';
err1 = docs1.Parse(xmls1$);
if ( err1 < 0 ) {
PopupError( err1 ); # pop up an error dialog
Exit( );
}
nodes1 = docs1.GetElementByID( "dlgs1" );
if ( nodes1 == 0 ) {
PopupMessage( "Could not find dialog node in XML document" );
Exit();
}
dlgs1.SetXMLNode( nodes1 );
ret1 = dlgs1.DoModal();
if (ret1 == -1)
{
Exit();
}
s1aq = dlgs1.GetCtrlByID("s1aqui").GetValueNum();
s1ele = dlgs1.GetCtrlByID("s1elevation").GetValueNum();
}
else if ( sensors1 == 2 )
{
xmls1$ = '
';
err = docs1.Parse(xmls1$);
if ( err1 < 0 ) {
PopupError( err1 ); # pop up an error dialog
Exit( );
}
nodes1 = docs1.GetElementByID( "dlgs1" );
if ( nodes1 == 0 ) {
PopupMessage( "Could not find dialog node in XML document" );
Exit();
}
dlgs1.SetXMLNode( nodes1 );
ret1 = dlgs1.DoModal();
if (ret1 == -1)
{
Exit();
}
s1aq = dlgs1.GetCtrlByID("s1aqui").GetValueNum();
s1ele = dlgs1.GetCtrlByID("s1elevation").GetValueNum();
}
else if ( sensors1 == 1 )
{
xmls1$ = '
';
err1 = docs1.Parse(xmls1$);
if ( err1 < 0 ) {
PopupError( err1 ); # pop up an error dialog
Exit( );
}
nodes1 = docs1.GetElementByID( "dlgs1" );
if ( nodes1 == 0 ) {
PopupMessage( "Could not find dialog node in XML document" );
Exit();
}
dlgs1.SetXMLNode( nodes1 );
ret1 = dlgs1.DoModal();
if (ret1 == -1)
{
Exit();
}
s1aq = dlgs1.GetCtrlByID("s1aqui").GetValueNum();
s1ele = dlgs1.GetCtrlByID("s1elevation").GetValueNum();
}
}
###################################################################################################
###### Procedure to prompt for values for SZENE 2
###################################################################################################
proc SPECS2 () {
if ( sensors2 == 7 )
{
xmls2$ = '
';
err2 = docs2.Parse(xmls2$);
if ( err2 < 0 ) {
PopupError( err2 );
Exit( );
}
nodes2 = docs2.GetElementByID( "dlgs2" );
if ( nodes2 == 0 ) {
PopupMessage( "Could not find dialog node in XML document" );
Exit();
}
dlgs2.SetXMLNode( nodes2 );
ret2 = dlgs2.DoModal();
if (ret2 == -1)
{
Exit();
}
earSurCat2 = dlgs2.GetCtrlByID( "esc2" ).GetValueNum();
s2aq = dlgs2.GetCtrlByID("s2aqui").GetValueNum();
s2ele = dlgs2.GetCtrlByID("s2elevation").GetValueNum();
}
else if ( sensors2 == 6 )
{
xmls2$ = '
';
err2 = docs2.Parse(xmls2$);
if ( err2 < 0 ) {
PopupError( err2 );
Exit( );
}
nodes2 = docs2.GetElementByID( "dlgs2" );
if ( nodes2 == 0 ) {
PopupMessage( "Could not find dialog node in XML document" );
Exit();
}
dlgs2.SetXMLNode( nodes2 );
ret2 = dlgs2.DoModal();
if (ret2 == -1)
{
Exit();
}
numeric s2TMg1, s2TMg2, s2TMg3, s2TMg4, s2TMg5, s2TMg7;
numeric s2TMb1, s2TMb2, s2TMb3, s2TMb4, s2TMb5, s2TMb7;
s2aq = dlgs2.GetCtrlByID("s2aqui").GetValueNum();
s2ele = dlgs2.GetCtrlByID("s2elevation").GetValueNum();
s2TMg1 = dlgs2.GetCtrlByID("ss2TMg1").GetValueNum();
s2TMg2 = dlgs2.GetCtrlByID("ss2TMg2").GetValueNum();
s2TMg3 = dlgs2.GetCtrlByID("ss2TMg3").GetValueNum();
s2TMg4 = dlgs2.GetCtrlByID("ss2TMg4").GetValueNum();
s2TMg5 = dlgs2.GetCtrlByID("ss2TMg5").GetValueNum();
s2TMg7 = dlgs2.GetCtrlByID("ss2TMg7").GetValueNum();
s2TMb1 = dlgs2.GetCtrlByID("ss2TMb1").GetValueNum();
s2TMb2 = dlgs2.GetCtrlByID("ss2TMb2").GetValueNum();
s2TMb3 = dlgs2.GetCtrlByID("ss2TMb3").GetValueNum();
s2TMb4 = dlgs2.GetCtrlByID("ss2TMb4").GetValueNum();
s2TMb5 = dlgs2.GetCtrlByID("ss2TMb5").GetValueNum();
s2TMb7 = dlgs2.GetCtrlByID("ss2TMb7").GetValueNum();
}
else if ( sensors2 == 5 )
{
xmls2$ = '
';
err2 = docs2.Parse(xmls2$);
if ( err2 < 0 ) {
PopupError( err2 );
Exit( );
}
nodes2 = docs2.GetElementByID( "dlgs2" );
if ( nodes2 == 0 ) {
PopupMessage( "Could not find dialog node in XML document" );
Exit();
}
dlgs2.SetXMLNode( nodes2 );
ret2 = dlgs2.DoModal();
if (ret2 == -1)
{
Exit();
}
s2aq = dlgs2.GetCtrlByID("s2aqui").GetValueNum();
s2ele = dlgs2.GetCtrlByID("s2elevation").GetValueNum();
}
else if ( sensors2 == 4 )
{
xmls2$ = '
';
err2 = docs2.Parse(xmls2$);
if ( err2 < 0 ) {
PopupError( err2 );
Exit( );
}
nodes2 = docs2.GetElementByID( "dlgs2" );
if ( nodes2 == 0 ) {
PopupMessage( "Could not find dialog node in XML document" );
Exit();
}
dlgs2.SetXMLNode( nodes2 );
ret2 = dlgs2.DoModal();
if (ret2 == -1)
{
Exit();
}
s2aq = dlgs2.GetCtrlByID("s2aqui").GetValueNum();
s2ele = dlgs2.GetCtrlByID("s2elevation").GetValueNum();
}
else if ( sensors2 == 3 )
{
xmls2$ = '
';
err2 = docs2.Parse(xmls2$);
if ( err2 < 0 ) {
PopupError( err2 );
Exit( );
}
nodes2 = docs2.GetElementByID( "dlgs2" );
if ( nodes2 == 0 ) {
PopupMessage( "Could not find dialog node in XML document" );
Exit();
}
dlgs2.SetXMLNode( nodes2 );
ret2 = dlgs2.DoModal();
if (ret2 == -1)
{
Exit();
}
s2aq = dlgs2.GetCtrlByID("s2aqui").GetValueNum();
s2ele = dlgs2.GetCtrlByID("s2elevation").GetValueNum();
}
else if ( sensors2 == 2 )
{
xmls2$ = '
';
err2 = docs2.Parse(xmls2$);
if ( err2 < 0 ) {
PopupError( err );
Exit( );
}
nodes2 = docs2.GetElementByID( "dlgs2" );
if ( nodes2 == 0 ) {
PopupMessage( "Could not find dialog node in XML document" );
Exit();
}
dlgs2.SetXMLNode( nodes2 );
ret2 = dlgs2.DoModal();
if (ret2 == -1)
{
Exit();
}
s2aq = dlgs2.GetCtrlByID("s2aqui").GetValueNum();
s2ele = dlgs2.GetCtrlByID("s2elevation").GetValueNum();
}
else if ( sensors2 == 1 )
{
xmls2$ = '
';
err2 = docs2.Parse(xmls2$);
if ( err2 < 0 ) {
PopupError( err2 ); # pop up an error dialog
Exit( );
}
nodes2 = docs2.GetElementByID( "dlgs2" );
if ( nodes2 == 0 ) {
PopupMessage( "Could not find dialog node in XML document" );
Exit();
}
dlgs2.SetXMLNode( nodes2 );
ret2 = dlgs2.DoModal();
if (ret2 == -1)
{
Exit();
}
s2aq = dlgs2.GetCtrlByID("s2aqui").GetValueNum();
s2ele = dlgs2.GetCtrlByID("s2elevation").GetValueNum();
}
}
###################################################################################################
###### Procedure to prompt for values for SZENE 3
###################################################################################################
proc SPECS3 () {
if ( sensors3 == 7 )
{
xmls3$ = '
';
err3 = docs3.Parse(xmls3$);
if ( err3 < 0 ) {
PopupError( err3 );
Exit( );
}
nodes3 = docs3.GetElementByID( "dlgs3" );
if ( nodes3 == 0 ) {
PopupMessage( "Could not find dialog node in XML document" );
Exit();
}
dlgs3.SetXMLNode( nodes3 );
ret3 = dlgs3.DoModal();
if (ret3 == -1)
{
Exit();
}
earSurCat3 = dlgs3.GetCtrlByID( "esc3" ).GetValueNum();
s3aq = dlgs3.GetCtrlByID("s3aqui").GetValueNum();
s3ele = dlgs3.GetCtrlByID("s3elevation").GetValueNum();
}
else if ( sensors3 == 6 )
{
xmls3$ = '
';
err3 = docs3.Parse(xmls3$);
if ( err3 < 0 ) {
PopupError( err3 );
Exit( );
}
nodes3 = docs3.GetElementByID( "dlgs3" );
if ( nodes3 == 0 ) {
PopupMessage( "Could not find dialog node in XML document" );
Exit();
}
dlgs3.SetXMLNode( nodes3 );
ret3 = dlgs3.DoModal();
if (ret3 == -1)
{
Exit();
}
numeric s3TMg1, s3TMg2, s3TMg3, s3TMg4, s3TMg5, s3TMg7;
numeric s3TMb1, s3TMb2, s3TMb3, s3TMb4, s3TMb5, s3TMb7;
s3aq = dlgs3.GetCtrlByID("s3aqui").GetValueNum();
s3ele = dlgs3.GetCtrlByID("s3elevation").GetValueNum();
s3TMg1 = dlgs3.GetCtrlByID("ss3TMg1").GetValueNum();
s3TMg2 = dlgs3.GetCtrlByID("ss3TMg2").GetValueNum();
s3TMg3 = dlgs3.GetCtrlByID("ss3TMg3").GetValueNum();
s3TMg4 = dlgs3.GetCtrlByID("ss3TMg4").GetValueNum();
s3TMg5 = dlgs3.GetCtrlByID("ss3TMg5").GetValueNum();
s3TMg7 = dlgs3.GetCtrlByID("ss3TMg7").GetValueNum();
s3TMb1 = dlgs3.GetCtrlByID("ss3TMb1").GetValueNum();
s3TMb2 = dlgs3.GetCtrlByID("ss3TMb2").GetValueNum();
s3TMb3 = dlgs3.GetCtrlByID("ss3TMb3").GetValueNum();
s3TMb4 = dlgs3.GetCtrlByID("ss3TMb4").GetValueNum();
s3TMb5 = dlgs3.GetCtrlByID("ss3TMb5").GetValueNum();
s3TMb7 = dlgs3.GetCtrlByID("ss3TMb7").GetValueNum();
}
else if ( sensors3 == 5 )
{
xmls3$ = '
';
err3 = docs3.Parse(xmls3$);
if ( err3 < 0 ) {
PopupError( err3 );
Exit( );
}
nodes3 = docs3.GetElementByID( "dlgs3" );
if ( nodes3 == 0 ) {
PopupMessage( "Could not find dialog node in XML document" );
Exit();
}
dlgs3.SetXMLNode( nodes3 );
ret3 = dlgs3.DoModal();
if (ret3 == -1)
{
Exit();
}
s3aq = dlgs3.GetCtrlByID("s3aqui").GetValueNum();
s3ele = dlgs3.GetCtrlByID("s3elevation").GetValueNum();
}
else if ( sensors3 == 4 )
{
xmls3$ = '
';
err3 = docs3.Parse(xmls3$);
if ( err3 < 0 ) {
PopupError( err3 );
Exit( );
}
nodes3 = docs3.GetElementByID( "dlgs3" );
if ( nodes3 == 0 ) {
PopupMessage( "Could not find dialognode in XML document" );
Exit();
}
dlgs3.SetXMLNode( nodes3 );
ret3 = dlgs3.DoModal();
if (ret3 == -1)
{
Exit();
}
s3aq = dlgs3.GetCtrlByID("s3aqui").GetValueNum();
s3ele = dlgs3.GetCtrlByID("s3elevation").GetValueNum();
}
else if ( sensors3 == 3 )
{
xmls3$ = '
';
err3 = docs3.Parse(xmls3$);
if ( err3 < 0 ) {
PopupError( err3 );
Exit( );
}
nodes3 = docs3.GetElementByID( "dlgs3" );
if ( nodes3 == 0 ) {
PopupMessage( "Could not find dialog node in XML document" );
Exit();
}
dlgs3.SetXMLNode( nodes3 );
ret3 = dlgs3.DoModal();
if (ret3 == -1)
{
Exit();
}
s3aq = dlgs3.GetCtrlByID("s3aqui").GetValueNum();
s3ele = dlgs3.GetCtrlByID("s3elevation").GetValueNum();
}
else if ( sensors3 == 2 )
{
xmls3$ = '
';
err3 = docs3.Parse(xmls3$);
if ( err3 < 0 ) {
PopupError( err3 );
Exit( );
}
nodes3 = docs3.GetElementByID( "dlgs3" );
if ( nodes3 == 0 ) {
PopupMessage( "Could not find dialog node in XML document" );
Exit();
}
dlgs3.SetXMLNode( nodes3 );
ret3 = dlgs3.DoModal();
if (ret3 == -1)
{
Exit();
}
s3aq = dlgs3.GetCtrlByID("s3aqui").GetValueNum();
s3ele = dlgs3.GetCtrlByID("s3elevation").GetValueNum();
}
else if ( sensors3 == 1 )
{
xmls3$ = '
';
err3 = docs3.Parse(xmls3$);
if ( err3 < 0 ) {
PopupError( err3 );
Exit( );
}
nodes3 = docs3.GetElementByID( "dlgs3" );
if ( nodes3 == 0 ) {
PopupMessage( "Could not find dialog node in XML document" );
Exit();
}
dlgs3.SetXMLNode( nodes3 );
ret3 = dlgs3.DoModal();
if (ret3 == -1)
{
Exit();
}
s3aq = dlgs3.GetCtrlByID("s3aqui").GetValueNum();
s3ele = dlgs3.GetCtrlByID("s3elevation").GetValueNum();
}
}
###################################################################################################
##### Procedure to prompt for values for SZENE 4
###################################################################################################
proc SPECS4 () {
if ( sensors4 == 7 )
{
xmls4$ = '
';
err4 = docs4.Parse(xmls4$);
if ( err4 < 0 ) {
PopupError( err4 );
Exit( );
}
nodes4 = docs4.GetElementByID( "dlgs4" );
if ( nodes4 == 0 ) {
PopupMessage( "Could not find dialog node in XML document" );
Exit();
}
dlgs4.SetXMLNode( nodes4 );
ret4 = dlgs4.DoModal();
if (ret4 == -1)
{
Exit();
}
earSurCat4 = dlgs4.GetCtrlByID( "esc4" ).GetValueNum();
s4aq = dlgs4.GetCtrlByID("s4aqui").GetValueNum();
s4ele = dlgs4.GetCtrlByID("s4elevation").GetValueNum();
dlgmain.GetCtrlByID("rasrefdoss1").SetEnabled(1);
}
else if ( sensors4 == 6 )
{
xmls4$ = '
';
err4 = docs4.Parse(xmls4$);
if ( err4 < 0 ) {
PopupError( err4 );
Exit( );
}
nodes4 = docs4.GetElementByID( "dlgs4" );
if ( nodes4 == 0 ) {
PopupMessage( "Could not find dialog node in XML document" );
Exit();
}
dlgs4.SetXMLNode( nodes4 );
ret4 = dlgs4.DoModal();
if (ret4 == -1)
{
Exit();
}
numeric s4TMg1, s4TMg2, s4TMg3, s4TMg4, s4TMg5, s4TMg7;
numeric s4TMb1, s4TMb2, s4TMb3, s4TMb4, s4TMb5, s4TMb7;
s4aq = dlgs4.GetCtrlByID("s4aqui").GetValueNum();
s4ele = dlgs4.GetCtrlByID("s4elevation").GetValueNum();
s4TMg1 = dlgs4.GetCtrlByID("ss4TMg1").GetValueNum();
s4TMg2 = dlgs4.GetCtrlByID("ss4TMg2").GetValueNum();
s4TMg3 = dlgs4.GetCtrlByID("ss4TMg3").GetValueNum();
s4TMg4 = dlgs4.GetCtrlByID("ss4TMg4").GetValueNum();
s4TMg5 = dlgs4.GetCtrlByID("ss4TMg5").GetValueNum();
s4TMg7 = dlgs4.GetCtrlByID("ss4TMg7").GetValueNum();
s4TMb1 = dlgs4.GetCtrlByID("ss4TMb1").GetValueNum();
s4TMb2 = dlgs4.GetCtrlByID("ss4TMb2").GetValueNum();
s4TMb3 = dlgs4.GetCtrlByID("ss4TMb3").GetValueNum();
s4TMb4 = dlgs4.GetCtrlByID("ss4TMb4").GetValueNum();
s4TMb5 = dlgs4.GetCtrlByID("ss4TMb5").GetValueNum();
s4TMb7 = dlgs4.GetCtrlByID("ss4TMb7").GetValueNum();
dlgmain.GetCtrlByID("rasrefdoss1").SetEnabled(1);
}
else if ( sensors4 == 5 )
{
xmls4$ = '
';
err4 = docs4.Parse(xmls4$);
if ( err4 < 0 ) {
PopupError( err4 ); # pop up an error dialog
Exit( );
}
nodes4 = docs4.GetElementByID( "dlgs4" );
if ( nodes4 == 0 ) {
PopupMessage( "Could not find dialog node in XML document" );
Exit();
}
dlgs4.SetXMLNode( nodes4 );
ret4 = dlgs4.DoModal();
if (ret4 == -1)
{
Exit();
}
s4aq = dlgs4.GetCtrlByID("s4aqui").GetValueNum();
s4ele = dlgs4.GetCtrlByID("s4elevation").GetValueNum();
dlgmain.GetCtrlByID("rasrefdoss1").SetEnabled(1);
}
else if ( sensors4 == 4 )
{
xmls4$ = '
';
err4 = docs4.Parse(xmls4$);
if ( err4 < 0 ) {
PopupError( err4 ); # pop up an error dialog
Exit( );
}
nodes4 = docs4.GetElementByID( "dlgs4" );
if ( nodes4 == 0 ) {
PopupMessage( "Could not find dialog node in XML document" );
Exit();
}
dlgs4.SetXMLNode( nodes4 );
ret4 = dlgs4.DoModal();
if (ret4 == -1)
{
Exit();
}
s4aq = dlgs4.GetCtrlByID("s4aqui").GetValueNum();
s4ele = dlgs4.GetCtrlByID("s4elevation").GetValueNum();
dlgmain.GetCtrlByID("rasrefdoss1").SetEnabled(1);
}
else if ( sensors4 == 3 )
{
xmls4$ = '
';
err4 = docs4.Parse(xmls4$);
if ( err4 < 0 ) {
PopupError( err4 ); # pop up an error dialog
Exit( );
}
nodes4 = docs4.GetElementByID( "dlgs4" );
if ( nodes4 == 0 ) {
PopupMessage( "Could not find dialog node in XML document" );
Exit();
}
dlgs4.SetXMLNode( nodes4 );
ret4 = dlgs4.DoModal();
if (ret4 == -1)
{
Exit();
}
s4aq = dlgs4.GetCtrlByID("s4aqui").GetValueNum();
s4ele = dlgs4.GetCtrlByID("s4elevation").GetValueNum();
dlgmain.GetCtrlByID("rasrefdoss1").SetEnabled(1);
}
else if ( sensors4 == 2 )
{
xmls4$ = '
';
err4 = docs4.Parse(xmls4$);
if ( err4 < 0 ) {
PopupError( err4 ); # pop up an error dialog
Exit( );
}
nodes4 = docs4.GetElementByID( "dlgs4" );
if ( nodes4 ==0 ) {
PopupMessage( "Could not find dialog node in XML document" );
Exit();
}
dlgs4.SetXMLNode( nodes4 );
ret4 = dlgs4.DoModal();
if (ret4 == -1)
{
Exit();
}
s4aq = dlgs4.GetCtrlByID("s4aqui").GetValueNum();
s4ele = dlgs4.GetCtrlByID("s4elevation").GetValueNum();
dlgmain.GetCtrlByID("rasrefdoss1").SetEnabled(1);
}
else if ( sensors4 == 1 )
{
xmls4$ = '
';
err4 = docs4.Parse(xmls4$);
if ( err4 < 0 ) {
PopupError( err4 );
Exit( );
}
nodes4 = docs4.GetElementByID( "dlgs4" );
if ( nodes4 == 0 ) {
PopupMessage( "Could not find dialog node in XML document" );
Exit();
}
dlgs4.SetXMLNode( nodes4 );
ret4 = dlgs4.DoModal();
if (ret4 == -1)
{
Exit();
}
s4aq = dlgs4.GetCtrlByID("s4aqui").GetValueNum();
s4ele = dlgs4.GetCtrlByID("s4elevation").GetValueNum();
dlgmain.GetCtrlByID("rasrefdoss1").SetEnabled(1);
}
}
#######################################
### Procedure to select reflectance output files SZENE 1 DOS 1 corrected
#######################################
proc OUTREFDOSS1()
{
if ( sensors1 == 7 )
{
raster REFS1ETM1, REFS1ETM2, REFS1ETM3, REFS1ETM4, REFS1ETM5, REFS1ETM7;
GetOutputRaster(REFS1ETM1, ETMlins, ETMcols, "32-bit float");
CopySubobjects(ETM1BAND1, REFS1ETM1, "georef");
GetOutputRaster(REFS1ETM2, ETMlins, ETMcols, "32-bit float");
CopySubobjects(ETM1BAND2, REFS1ETM2, "georef");
GetOutputRaster(REFS1ETM3, ETMlins, ETMcols, "32-bit float");
CopySubobjects(ETM1BAND3, REFS1ETM3, "georef");
GetOutputRaster(REFS1ETM4, ETMlins, ETMcols, "32-bit float");
CopySubobjects(ETM1BAND4, REFS1ETM4, "georef");
GetOutputRaster(REFS1ETM5, ETMlins, ETMcols, "32-bit float");
CopySubobjects(ETM1BAND5, REFS1ETM5, "georef");
GetOutputRaster(REFS1ETM7, ETMlins, ETMcols, "32-bit float");
CopySubobjects(ETM1BAND7, REFS1ETM7, "georef");
dlgmain.GetCtrlByID("rasrefdoss2").SetEnabled(1);
}
else if ( sensors1 == 6 )
{
raster REFS1TM1, REFS1TM2, REFS1TM3, REFS1TM4, REFS1TM5, REFS1TM7;
GetOutputRaster(REFS1TM1, TMlins, TMcols, "32-bit float");
CopySubobjects(TM1BAND1, REFS1TM1, "georef");
GetOutputRaster(REFS1TM2, TMlins, TMcols, "32-bit float");
CopySubobjects(TM1BAND2, REFS1TM2, "georef");
GetOutputRaster(REFS1TM3, TMlins, TMcols, "32-bit float");
CopySubobjects(TM1BAND3, REFS1TM3, "georef");
GetOutputRaster(REFS1TM4, TMlins, TMcols, "32-bit float");
CopySubobjects(TM1BAND4, REFS1TM4, "georef");
GetOutputRaster(REFS1TM5, TMlins, TMcols, "32-bit float");
CopySubobjects(TM1BAND5, REFS1TM5, "georef");
GetOutputRaster(REFS1TM7, TMlins, TMcols, "32-bit float");
CopySubobjects(TM1BAND7, REFS1TM7, "georef");
dlgmain.GetCtrlByID("rasrefdoss2").SetEnabled(1);
}
else
{
raster REFS1MSS1, REFS1MSS2, REFS1MSS3, REFS1MSS4;
GetOutputRaster(REFS1MSS1, MSSlins, MSScols, "32-bit float");
CopySubobjects(MSS1BAND1, REFS1MSS1, "georef");
GetOutputRaster(REFS1MSS2, MSSlins, MSScols, "32-bit float");
CopySubobjects(MSS1BAND2, REFS1MSS2, "georef");
GetOutputRaster(REFS1MSS3, MSSlins, MSScols, "32-bit float");
CopySubobjects(MSS1BAND3, REFS1MSS3, "georef");
GetOutputRaster(REFS1MSS4, MSSlins, MSScols, "32-bit float");
CopySubobjects(MSS1BAND4, REFS1MSS4, "georef");
dlgmain.GetCtrlByID("rasrefdoss2").SetEnabled(1);
}
}
#######################################
### Procedure to select reflectance output files SZENE 2 DOS 1 corrected
#######################################
proc OUTREFDOSS2()
{
if ( sensors2 == 7 )
{
raster REFS2ETM1, REFS2ETM2, REFS2ETM3, REFS2ETM4, REFS2ETM5, REFS2ETM7;
GetOutputRaster(REFS2ETM1, ETMlins, ETMcols, "32-bit float");
CopySubobjects(ETM2BAND1, REFS2ETM1, "georef");
GetOutputRaster(REFS2ETM2, ETMlins, ETMcols, "32-bit float");
CopySubobjects(ETM2BAND2, REFS2ETM2, "georef");
GetOutputRaster(REFS2ETM3, ETMlins, ETMcols, "32-bit float");
CopySubobjects(ETM2BAND3, REFS2ETM3, "georef");
GetOutputRaster(REFS2ETM4, ETMlins, ETMcols, "32-bit float");
CopySubobjects(ETM2BAND4, REFS2ETM4, "georef");
GetOutputRaster(REFS2ETM5, ETMlins, ETMcols, "32-bit float");
CopySubobjects(ETM2BAND5, REFS2ETM5, "georef");
GetOutputRaster(REFS2ETM7, ETMlins, ETMcols, "32-bit float");
CopySubobjects(ETM2BAND7, REFS2ETM7, "georef");
dlgmain.GetCtrlByID("rasrefdoss3").SetEnabled(1);
}
else if ( sensors2 == 6 )
{
raster REFS2TM1, REFS2TM2, REFS2TM3, REFS2TM4, REFS2TM5, REFS2TM7;
GetOutputRaster(REFS2TM1, TMlins, TMcols, "32-bit float");
CopySubobjects(TM2BAND1, REFS2TM1, "georef");
GetOutputRaster(REFS2TM2, TMlins, TMcols, "32-bit float");
CopySubobjects(TM2BAND2, REFS2TM2, "georef");
GetOutputRaster(REFS2TM3, TMlins, TMcols, "32-bit float");
CopySubobjects(TM2BAND3, REFS2TM3, "georef");
GetOutputRaster(REFS2TM4, TMlins, TMcols, "32-bit float");
CopySubobjects(TM2BAND4, REFS2TM4, "georef");
GetOutputRaster(REFS2TM5, TMlins, TMcols, "32-bit float");
CopySubobjects(TM2BAND5, REFS2TM5, "georef");
GetOutputRaster(REFS2TM7, TMlins, TMcols, "32-bit float");
CopySubobjects(TM2BAND7, REFS2TM7, "georef");
dlgmain.GetCtrlByID("rasrefdoss3").SetEnabled(1);
}
else
{
raster REFS2MSS1, REFS2MSS2, REFS2MSS3, REFS2MSS4;
GetOutputRaster(REFS2MSS1, MSSlins, MSScols, "32-bit float");
CopySubobjects(MSS2BAND1, REFS2MSS1, "georef");
GetOutputRaster(REFS2MSS2, MSSlins, MSScols, "32-bit float");
CopySubobjects(MSS2BAND2, REFS2MSS2, "georef");
GetOutputRaster(REFS2MSS3, MSSlins, MSScols, "32-bit float");
CopySubobjects(MSS2BAND3, REFS2MSS3, "georef");
GetOutputRaster(REFS2MSS4, MSSlins, MSScols, "32-bit float");
CopySubobjects(MSS2BAND4, REFS2MSS4, "georef");
dlgmain.GetCtrlByID("rasrefdoss3").SetEnabled(1);
}
}
#######################################
### Procedure to select reflectance output files SZENE 3 DOS 1 corrected
#######################################
proc OUTREFDOSS3()
{
if ( sensors3 == 7 )
{
raster REFS3ETM1, REFS3ETM2, REFS3ETM3, REFS3ETM4, REFS3ETM5, REFS3ETM7;
GetOutputRaster(REFS3ETM1, ETMlins, ETMcols, "32-bit float");
CopySubobjects(ETM3BAND1, REFS3ETM1, "georef");
GetOutputRaster(REFS3ETM2, ETMlins, ETMcols, "32-bit float");
CopySubobjects(ETM3BAND2, REFS3ETM2, "georef");
GetOutputRaster(REFS3ETM3, ETMlins, ETMcols, "32-bit float");
CopySubobjects(ETM3BAND3, REFS3ETM3, "georef");
GetOutputRaster(REFS3ETM4, ETMlins, ETMcols, "32-bit float");
CopySubobjects(ETM3BAND4, REFS3ETM4, "georef");
GetOutputRaster(REFS3ETM5, ETMlins, ETMcols, "32-bit float");
CopySubobjects(ETM3BAND5, REFS3ETM5, "georef");
GetOutputRaster(REFS3ETM7, ETMlins, ETMcols, "32-bit float");
CopySubobjects(ETM3BAND7, REFS3ETM7, "georef");
dlgmain.GetCtrlByID("rasrefdoss4").SetEnabled(1);
}
else if ( sensors3 == 6 )
{
raster REFS3TM1, REFS3TM2, REFS3TM3, REFS3TM4, REFS3TM5, REFS3TM7;
GetOutputRaster(REFS3TM1, TMlins, TMcols, "32-bit float");
CopySubobjects(TM3BAND1, REFS3TM1, "georef");
GetOutputRaster(REFS3TM2, TMlins, TMcols, "32-bit float");
CopySubobjects(TM3BAND2, REFS3TM2, "georef");
GetOutputRaster(REFS3TM3, TMlins, TMcols, "32-bit float");
CopySubobjects(TM3BAND3, REFS3TM3, "georef");
GetOutputRaster(REFS3TM4, TMlins, TMcols, "32-bit float");
CopySubobjects(TM3BAND4, REFS3TM4, "georef");
GetOutputRaster(REFS3TM5, TMlins, TMcols, "32-bit float");
CopySubobjects(TM3BAND5, REFS3TM5, "georef");
GetOutputRaster(REFS3TM7, TMlins, TMcols, "32-bit float");
CopySubobjects(TM3BAND7, REFS3TM7, "georef");
dlgmain.GetCtrlByID("rasrefdoss4").SetEnabled(1);
}
else
{
raster REFS3MSS1, REFS3MSS2, REFS3MSS3, REFS3MSS4;
GetOutputRaster(REFS3MSS1, MSSlins, MSScols, "32-bit float");
CopySubobjects(MSS3BAND1, REFS3MSS1, "georef");
GetOutputRaster(REFS3MSS2, MSSlins, MSScols, "32-bit float");
CopySubobjects(MSS3BAND2, REFS3MSS2, "georef");
GetOutputRaster(REFS3MSS3, MSSlins, MSScols, "32-bit float");
CopySubobjects(MSS3BAND3, REFS3MSS3, "georef");
GetOutputRaster(REFS3MSS4, MSSlins, MSScols, "32-bit float");
CopySubobjects(MSS3BAND4, REFS3MSS4, "georef");
dlgmain.GetCtrlByID("rasrefdoss4").SetEnabled(1);
}
}
#######################################
### Procedure to select reflectance output files SZENE 4 DOS 1 corrected
#######################################
proc OUTREFDOSS4()
{
if ( sensors4 == 7 )
{
raster REFS4ETM1, REFS4ETM2, REFS4ETM3, REFS4ETM4, REFS4ETM5, REFS4ETM7;
GetOutputRaster(REFS4ETM1, ETMlins, ETMcols, "32-bit float");
CopySubobjects(ETM4BAND1, REFS4ETM1, "georef");
GetOutputRaster(REFS4ETM2, ETMlins, ETMcols, "32-bit float");
CopySubobjects(ETM4BAND2, REFS4ETM2, "georef");
GetOutputRaster(REFS4ETM3, ETMlins, ETMcols, "32-bit float");
CopySubobjects(ETM4BAND3, REFS4ETM3, "georef");
GetOutputRaster(REFS4ETM4, ETMlins, ETMcols, "32-bit float");
CopySubobjects(ETM4BAND4, REFS4ETM4, "georef");
GetOutputRaster(REFS4ETM5, ETMlins, ETMcols, "32-bit float");
CopySubobjects(ETM4BAND5, REFS4ETM5, "georef");
GetOutputRaster(REFS4ETM7, ETMlins, ETMcols, "32-bit float");
CopySubobjects(ETM4BAND7, REFS4ETM7, "georef");
dlgmain.GetCtrlByID("raspifglob").SetEnabled(1);
}
else if ( sensors4 == 6 )
{
raster REFS4TM1, REFS4TM2, REFS4TM3, REFS4TM4, REFS4TM5, REFS4TM7;
GetOutputRaster(REFS4TM1, TMlins, TMcols, "32-bit float");
CopySubobjects(TM4BAND1, REFS4TM1, "georef");
GetOutputRaster(REFS4TM2, TMlins, TMcols, "32-bit float");
CopySubobjects(TM4BAND2, REFS4TM2, "georef");
GetOutputRaster(REFS4TM3, TMlins, TMcols, "32-bit float");
CopySubobjects(TM4BAND3, REFS4TM3, "georef");
GetOutputRaster(REFS4TM4, TMlins, TMcols, "32-bit float");
CopySubobjects(TM4BAND4, REFS4TM4, "georef");
GetOutputRaster(REFS4TM5, TMlins, TMcols, "32-bit float");
CopySubobjects(TM4BAND5, REFS4TM5, "georef");
GetOutputRaster(REFS4TM7, TMlins, TMcols, "32-bit float");
CopySubobjects(TM4BAND7, REFS4TM7, "georef");
dlgmain.GetCtrlByID("raspifglob").SetEnabled(1);
}
else
{
raster REFS4MSS1, REFS4MSS2, REFS4MSS3, REFS4MSS4;
GetOutputRaster(REFS4MSS1, MSSlins, MSScols, "32-bit float");
CopySubobjects(MSS4BAND1, REFS4MSS1, "georef");
GetOutputRaster(REFS4MSS2, MSSlins, MSScols, "32-bit float");
CopySubobjects(MSS4BAND2, REFS4MSS2, "georef");
GetOutputRaster(REFS4MSS3, MSSlins, MSScols, "32-bit float");
CopySubobjects(MSS4BAND3, REFS4MSS3, "georef");
GetOutputRaster(REFS4MSS4, MSSlins, MSScols, "32-bit float");
CopySubobjects(MSS4BAND4, REFS4MSS4, "georef");
dlgmain.GetCtrlByID("raspifglob").SetEnabled(1);
}
}
#######################################
### Procedure to select PIF output masks
#######################################
proc OUTCOMPIFS1()
{
if ( sensors1 == 7 )
{
raster PIFMASK, PIFdarkMASK, PIFbrightMASK;
GetOutputRaster(PIFMASK, ETMlins, ETMcols, "8-bit unsigned");
CopySubobjects(ETM1BAND1, PIFMASK, "georef");
GetOutputRaster(PIFdarkMASK, ETMlins, ETMcols, "8-bit unsigned");
CopySubobjects(ETM1BAND1, PIFdarkMASK, "georef");
GetOutputRaster(PIFbrightMASK, ETMlins, ETMcols, "8-bit unsigned");
CopySubobjects(ETM1BAND1, PIFbrightMASK, "georef");
dlgmain.GetCtrlByID("raspifs1").SetEnabled(1);
}
else if ( sensors1 == 6 )
{
raster PIFMASK, PIFdarkMASK, PIFbrightMASK;
GetOutputRaster(PIFMASK, TMlins, TMcols, "8-bit unsigned");
CopySubobjects(TM1BAND1, PIFMASK, "georef");
GetOutputRaster(PIFdarkMASK, TMlins, TMcols, "8-bit unsigned");
CopySubobjects(TM1BAND1, PIFdarkMASK, "georef");
GetOutputRaster(PIFbrightMASK, TMlins, TMcols, "8-bit unsigned");
CopySubobjects(TM1BAND1, PIFbrightMASK, "georef");
dlgmain.GetCtrlByID("raspifs1").SetEnabled(1);
}
else
{
raster PIFMASK, PIFdarkMASK, PIFbrightMASK;
GetOutputRaster(PIFMASK, MSSlins, MSScols, "8-bit unsigned");
CopySubobjects(MSS1BAND1, PIFMASK, "georef");
GetOutputRaster(PIFdarkMASK, MSSlins, MSScols, "8-bit unsigned");
CopySubobjects(MSS1BAND1, PIFdarkMASK, "georef");
GetOutputRaster(PIFbrightMASK, MSSlins, MSScols, "8-bit unsigned");
CopySubobjects(MSS1BAND1, PIFbrightMASK, "georef");
dlgmain.GetCtrlByID("raspifs1").SetEnabled(1);
}
}
proc OUTPIFS1()
{
if ( sensors1 == 7 )
{
raster S1MASK, S1darkMASK, S1brightMASK;
GetOutputRaster(S1MASK, ETMlins, ETMcols, "8-bit unsigned");
CopySubobjects(ETM1BAND1, S1MASK, "georef");
GetOutputRaster(S1darkMASK, ETMlins, ETMcols, "8-bit unsigned");
CopySubobjects(ETM1BAND1, S1darkMASK, "georef");
GetOutputRaster(S1brightMASK, ETMlins, ETMcols, "8-bit unsigned");
CopySubobjects(ETM1BAND1, S1brightMASK, "georef");
dlgmain.GetCtrlByID("raspifs2").SetEnabled(1);
}
else if ( sensors1 == 6 )
{
raster S1MASK, S1darkMASK, S1brightMASK;
GetOutputRaster(S1MASK, TMlins, TMcols, "8-bit unsigned");
CopySubobjects(TM1BAND1, S1MASK, "georef");
GetOutputRaster(S1darkMASK, TMlins, TMcols, "8-bit unsigned");
CopySubobjects(TM1BAND1, S1darkMASK, "georef");
GetOutputRaster(S1brightMASK, TMlins, TMcols, "8-bit unsigned");
CopySubobjects(TM1BAND1, S1brightMASK, "georef");
dlgmain.GetCtrlByID("raspifs2").SetEnabled(1);
}
else
{
raster S1MASK, S1darkMASK, S1brightMASK;
GetOutputRaster(S1MASK, MSSlins, MSScols, "8-bit unsigned");
CopySubobjects(MSS1BAND1, S1MASK, "georef");
GetOutputRaster(S1darkMASK, MSSlins, MSScols, "8-bit unsigned");
CopySubobjects(MSS1BAND1, S1darkMASK, "georef");
GetOutputRaster(S1brightMASK, MSSlins, MSScols, "8-bit unsigned");
CopySubobjects(MSS1BAND1, S1brightMASK, "georef");
dlgmain.GetCtrlByID("raspifs2").SetEnabled(1);
}
}
proc OUTPIFS2()
{
if ( sensors2 == 7 )
{
raster S2MASK, S2darkMASK, S2brightMASK;
GetOutputRaster(S2MASK, ETMlins, ETMcols, "8-bit unsigned");
CopySubobjects(ETM2BAND1, S2MASK, "georef");
GetOutputRaster(S2darkMASK, ETMlins, ETMcols, "8-bit unsigned");
CopySubobjects(ETM2BAND1, S2darkMASK, "georef");
GetOutputRaster(S2brightMASK, ETMlins, ETMcols, "8-bit unsigned");
CopySubobjects(ETM2BAND1, S2brightMASK, "georef");
dlgmain.GetCtrlByID("raspifs3").SetEnabled(1);
}
else if ( sensors2 == 6 )
{
raster S2MASK, S2darkMASK, S2brightMASK;
GetOutputRaster(S2MASK, TMlins, TMcols, "8-bit unsigned");
CopySubobjects(TM2BAND1, S2MASK, "georef");
GetOutputRaster(S2darkMASK, TMlins, TMcols, "8-bit unsigned");
CopySubobjects(TM2BAND1, S2darkMASK, "georef");
GetOutputRaster(S2brightMASK, TMlins, TMcols, "8-bit unsigned");
CopySubobjects(TM2BAND1, S2brightMASK, "georef");
dlgmain.GetCtrlByID("raspifs3").SetEnabled(1);
}
else
{
raster S2MASK, S2darkMASK, S2brightMASK;
GetOutputRaster(S2MASK, MSSlins, MSScols, "8-bit unsigned");
CopySubobjects(MSS2BAND1, S2MASK, "georef");
GetOutputRaster(S2darkMASK, MSSlins, MSScols, "8-bit unsigned");
CopySubobjects(MSS2BAND1, S2darkMASK, "georef");
GetOutputRaster(S2brightMASK, MSSlins, MSScols, "8-bit unsigned");
CopySubobjects(MSS2BAND1, S2brightMASK, "georef");
dlgmain.GetCtrlByID("raspifs3").SetEnabled(1);
}
}
proc OUTPIFS3()
{
if ( sensors3 == 7 )
{
raster S3MASK, S3darkMASK, S3brightMASK;
GetOutputRaster(S3MASK, ETMlins, ETMcols, "8-bit unsigned");
CopySubobjects(ETM3BAND1, S3MASK, "georef");
GetOutputRaster(S3darkMASK, ETMlins, ETMcols, "8-bit unsigned");
CopySubobjects(ETM3BAND1, S3darkMASK, "georef");
GetOutputRaster(S3brightMASK, ETMlins, ETMcols, "8-bit unsigned");
CopySubobjects(ETM3BAND1, S3brightMASK, "georef");
dlgmain.GetCtrlByID("raspifs4").SetEnabled(1);
}
else if ( sensors3 == 6 )
{
raster S3MASK, S3darkMASK, S3brightMASK;
GetOutputRaster(S3MASK, TMlins, TMcols, "8-bit unsigned");
CopySubobjects(TM3BAND1, S3MASK, "georef");
GetOutputRaster(S3darkMASK, TMlins, TMcols, "8-bit unsigned");
CopySubobjects(TM3BAND1, S3darkMASK, "georef");
GetOutputRaster(S3brightMASK, TMlins, TMcols, "8-bit unsigned");
CopySubobjects(TM3BAND1, S3brightMASK, "georef");
dlgmain.GetCtrlByID("raspifs4").SetEnabled(1);
}
else
{
raster S3MASK, S3darkMASK, S3brightMASK;
GetOutputRaster(S3MASK, MSSlins, MSScols, "8-bit unsigned");
CopySubobjects(MSS3BAND1, S3MASK, "georef");
GetOutputRaster(S3darkMASK, MSSlins, MSScols, "8-bit unsigned");
CopySubobjects(MSS3BAND1, S3darkMASK, "georef");
GetOutputRaster(S3brightMASK, MSSlins, MSScols, "8-bit unsigned");
CopySubobjects(MSS3BAND1, S3brightMASK, "georef");
dlgmain.GetCtrlByID("raspifs4").SetEnabled(1);
}
}
proc OUTPIFS4()
{
if ( sensors4 == 7 )
{
raster S4MASK, S4darkMASK, S4brightMASK;
GetOutputRaster(S4MASK, ETMlins, ETMcols, "8-bit unsigned");
CopySubobjects(ETM4BAND1, S4MASK, "georef");
GetOutputRaster(S4darkMASK, ETMlins, ETMcols, "8-bit unsigned");
CopySubobjects(ETM4BAND1, S4darkMASK, "georef");
GetOutputRaster(S4brightMASK, ETMlins, ETMcols, "8-bit unsigned");
CopySubobjects(ETM4BAND1, S4brightMASK, "georef");
dlgmain.GetCtrlByID("rasnorms1").SetEnabled(1);
}
else if ( sensors4 == 6 )
{
raster S4MASK, S4darkMASK, S4brightMASK;
GetOutputRaster(S4MASK, TMlins, TMcols, "8-bit unsigned");
CopySubobjects(TM4BAND1, S4MASK, "georef");
GetOutputRaster(S4darkMASK, TMlins, TMcols, "8-bit unsigned");
CopySubobjects(TM4BAND1, S4darkMASK, "georef");
GetOutputRaster(S4brightMASK, TMlins, TMcols, "8-bit unsigned");
CopySubobjects(TM4BAND1, S4brightMASK, "georef");
dlgmain.GetCtrlByID("rasnorms1").SetEnabled(1);
}
else
{
raster S4MASK, S4darkMASK, S4brightMASK;
GetOutputRaster(S4MASK, MSSlins, MSScols, "8-bit unsigned");
CopySubobjects(MSS4BAND1, S4MASK, "georef");
GetOutputRaster(S4darkMASK, MSSlins, MSScols, "8-bit unsigned");
CopySubobjects(MSS4BAND1, S4darkMASK, "georef");
GetOutputRaster(S4brightMASK, MSSlins, MSScols, "8-bit unsigned");
CopySubobjects(MSS4BAND1, S4brightMASK, "georef");
dlgmain.GetCtrlByID("rasnorms1").SetEnabled(1);
}
}
#######################################
### Procedure to select output files SZENE 1
#######################################
proc OUTS1 () {
if ( sensors1 == 7 )
{
raster OUT1ETM1, OUT1ETM2, OUT1ETM3, OUT1ETM4, OUT1ETM5, OUT1ETM7;
GetOutputRaster(OUT1ETM1, ETMlins, ETMcols, "32-bit float");
CopySubobjects(ETM1BAND1, OUT1ETM1, "georef");
GetOutputRaster(OUT1ETM2, ETMlins, ETMcols, "32-bit float");
CopySubobjects(ETM1BAND2, OUT1ETM2, "georef");
GetOutputRaster(OUT1ETM3, ETMlins, ETMcols, "32-bit float");
CopySubobjects(ETM1BAND3, OUT1ETM3, "georef");
GetOutputRaster(OUT1ETM4, ETMlins, ETMcols, "32-bit float");
CopySubobjects(ETM1BAND4, OUT1ETM4, "georef");
GetOutputRaster(OUT1ETM5, ETMlins, ETMcols, "32-bit float");
CopySubobjects(ETM1BAND5, OUT1ETM5, "georef");
GetOutputRaster(OUT1ETM7, ETMlins, ETMcols, "32-bit float");
CopySubobjects(ETM1BAND7, OUT1ETM7, "georef");
dlgmain.GetCtrlByID("rasnorms2").SetEnabled(1);
}
else if ( sensors1 == 6 )
{
raster OUT1TM1, OUT1TM2, OUT1TM3, OUT1TM4, OUT1TM5, OUT1TM7;
GetOutputRaster(OUT1TM1, TMlins, TMcols, "32-bit float");
CopySubobjects(TM1BAND1, OUT1TM1, "georef");
GetOutputRaster(OUT1TM2, TMlins, TMcols, "32-bit float");
CopySubobjects(TM1BAND2, OUT1TM2, "georef");
GetOutputRaster(OUT1TM3, TMlins, TMcols, "32-bit float");
CopySubobjects(TM1BAND3, OUT1TM3, "georef");
GetOutputRaster(OUT1TM4, TMlins, TMcols, "32-bit float");
CopySubobjects(TM1BAND4, OUT1TM4, "georef");
GetOutputRaster(OUT1TM5, TMlins, TMcols, "32-bit float");
CopySubobjects(TM1BAND5, OUT1TM5, "georef");
GetOutputRaster(OUT1TM7, TMlins, TMcols, "32-bit float");
CopySubobjects(TM1BAND7, OUT1TM7, "georef");
dlgmain.GetCtrlByID("rasnorms2").SetEnabled(1);
}
else
{
raster OUT1MSS1, OUT1MSS2, OUT1MSS3, OUT1MSS4;
GetOutputRaster(OUT1MSS1, MSSlins, MSScols, "32-bit float");
CopySubobjects(MSS1BAND1, OUT1MSS1, "georef");
GetOutputRaster(OUT1MSS2, MSSlins, MSScols, "32-bit float");
CopySubobjects(MSS1BAND2, OUT1MSS2, "georef");
GetOutputRaster(OUT1MSS3, MSSlins, MSScols, "32-bit float");
CopySubobjects(MSS1BAND3, OUT1MSS3, "georef");
GetOutputRaster(OUT1MSS4, MSSlins, MSScols, "32-bit float");
CopySubobjects(MSS1BAND4, OUT1MSS4, "georef");
dlgmain.GetCtrlByID("rasnorms2").SetEnabled(1);
}
}
#######################################
### Procedure to select output files SZENE 2
#######################################
proc OUTS2 () {
if ( sensors2 == 7 )
{
raster OUT2ETM1, OUT2ETM2, OUT2ETM3, OUT2ETM4, OUT2ETM5, OUT2ETM7;
GetOutputRaster(OUT2ETM1, ETMlins, ETMcols, "32-bit float");
CopySubobjects(ETM2BAND1, OUT2ETM1, "georef");
GetOutputRaster(OUT2ETM2, ETMlins, ETMcols, "32-bit float");
CopySubobjects(ETM2BAND2, OUT2ETM2, "georef");
GetOutputRaster(OUT2ETM3, ETMlins, ETMcols, "32-bit float");
CopySubobjects(ETM2BAND3, OUT2ETM3, "georef");
GetOutputRaster(OUT2ETM4, ETMlins, ETMcols, "32-bit float");
CopySubobjects(ETM2BAND4, OUT2ETM4, "georef");
GetOutputRaster(OUT2ETM5, ETMlins, ETMcols, "32-bit float");
CopySubobjects(ETM2BAND5, OUT2ETM5, "georef");
GetOutputRaster(OUT2ETM7, ETMlins, ETMcols, "32-bit float");
CopySubobjects(ETM2BAND7, OUT2ETM7, "georef");
dlgmain.GetCtrlByID("rasnorms3").SetEnabled(1);
}
else if ( sensors2 == 6 )
{
raster OUT2TM1, OUT2TM2, OUT2TM3, OUT2TM4, OUT2TM5, OUT2TM7;
GetOutputRaster(OUT2TM1, TMlins, TMcols, "32-bit float");
CopySubobjects(TM2BAND1, OUT2TM1, "georef");
GetOutputRaster(OUT2TM2, TMlins, TMcols, "32-bit float");
CopySubobjects(TM2BAND2, OUT2TM2, "georef");
GetOutputRaster(OUT2TM3, TMlins, TMcols, "32-bit float");
CopySubobjects(TM2BAND3, OUT2TM3, "georef");
GetOutputRaster(OUT2TM4, TMlins, TMcols, "32-bit float");
CopySubobjects(TM2BAND4, OUT2TM4, "georef");
GetOutputRaster(OUT2TM5, TMlins, TMcols, "32-bit float");
CopySubobjects(TM2BAND5, OUT2TM5, "georef");
GetOutputRaster(OUT2TM7, TMlins, TMcols, "32-bit float");
CopySubobjects(TM2BAND7, OUT2TM7, "georef");
dlgmain.GetCtrlByID("rasnorms3").SetEnabled(1);
}
else
{
raster OUT2MSS1, OUT2MSS2, OUT2MSS3, OUT2MSS4;
GetOutputRaster(OUT2MSS1, MSSlins, MSScols, "32-bit float");
CopySubobjects(MSS2BAND1, OUT2MSS1, "georef");
GetOutputRaster(OUT2MSS2, MSSlins, MSScols, "32-bit float");
CopySubobjects(MSS2BAND2, OUT2MSS2, "georef");
GetOutputRaster(OUT2MSS3, MSSlins, MSScols, "32-bit float");
CopySubobjects(MSS2BAND3, OUT2MSS3, "georef");
GetOutputRaster(OUT2MSS4, MSSlins, MSScols, "32-bit float");
CopySubobjects(MSS2BAND4, OUT2MSS4, "georef");
dlgmain.GetCtrlByID("rasnorms3").SetEnabled(1);
}
}
#######################################
### Procedure to select output files SZENE 3
#######################################
proc OUTS3 () {
if ( sensors3 == 7 )
{
raster OUT3ETM1, OUT3ETM2, OUT3ETM3, OUT3ETM4, OUT3ETM5, OUT3ETM7;
GetOutputRaster(OUT3ETM1, ETMlins, ETMcols, "32-bit float");
CopySubobjects(ETM3BAND1, OUT3ETM1, "georef");
GetOutputRaster(OUT3ETM2, ETMlins, ETMcols, "32-bit float");
CopySubobjects(ETM3BAND2, OUT3ETM2, "georef");
GetOutputRaster(OUT3ETM3, ETMlins, ETMcols, "32-bit float");
CopySubobjects(ETM3BAND3, OUT3ETM3, "georef");
GetOutputRaster(OUT3ETM4, ETMlins, ETMcols, "32-bit float");
CopySubobjects(ETM3BAND4, OUT3ETM4, "georef");
GetOutputRaster(OUT3ETM5, ETMlins, ETMcols, "32-bit float");
CopySubobjects(ETM3BAND5, OUT3ETM5, "georef");
GetOutputRaster(OUT3ETM7, ETMlins, ETMcols, "32-bit float");
CopySubobjects(ETM3BAND7, OUT3ETM7, "georef");
dlgmain.GetCtrlByID("rasnorms4").SetEnabled(1);
}
else if ( sensors3 == 6 )
{
raster OUT3TM1, OUT3TM2, OUT3TM3, OUT3TM4, OUT3TM5, OUT3TM7;
GetOutputRaster(OUT3TM1, TMlins, TMcols, "32-bit float");
CopySubobjects(TM3BAND1, OUT3TM1, "georef");
GetOutputRaster(OUT3TM2, TMlins, TMcols, "32-bit float");
CopySubobjects(TM3BAND2, OUT3TM2, "georef");
GetOutputRaster(OUT3TM3, TMlins, TMcols, "32-bit float");
CopySubobjects(TM3BAND3, OUT3TM3, "georef");
GetOutputRaster(OUT3TM4, TMlins, TMcols, "32-bit float");
CopySubobjects(TM3BAND4, OUT3TM4, "georef");
GetOutputRaster(OUT3TM5, TMlins, TMcols, "32-bit float");
CopySubobjects(TM3BAND5, OUT3TM5, "georef");
GetOutputRaster(OUT3TM7, TMlins, TMcols, "32-bit float");
CopySubobjects(TM3BAND7, OUT3TM7, "georef");
dlgmain.GetCtrlByID("rasnorms4").SetEnabled(1);
}
else
{
raster OUT3MSS1, OUT3MSS2, OUT3MSS3, OUT3MSS4;
GetOutputRaster(OUT3MSS1, MSSlins, MSScols, "32-bit float");
CopySubobjects(MSS3BAND1, OUT3MSS1, "georef");
GetOutputRaster(OUT3MSS2, MSSlins, MSScols, "32-bit float");
CopySubobjects(MSS3BAND2, OUT3MSS2, "georef");
GetOutputRaster(OUT3MSS3, MSSlins, MSScols, "32-bit float");
CopySubobjects(MSS3BAND3, OUT3MSS3, "georef");
GetOutputRaster(OUT3MSS4, MSSlins, MSScols, "32-bit float");
CopySubobjects(MSS3BAND4, OUT3MSS4, "georef");
dlgmain.GetCtrlByID("rasnorms4").SetEnabled(1);
}
}
#######################################
### Procedure to select output files SZENE 4
#######################################
proc OUTS4 () {
if ( sensors4 == 7 )
{
raster OUT4ETM1, OUT4ETM2, OUT4ETM3, OUT4ETM4, OUT4ETM5, OUT4ETM7;
GetOutputRaster(OUT4ETM1, ETMlins, ETMcols, "32-bit float");
CopySubobjects(ETM4BAND1, OUT4ETM1, "georef");
GetOutputRaster(OUT4ETM2, ETMlins, ETMcols, "32-bit float");
CopySubobjects(ETM4BAND2, OUT4ETM2, "georef");
GetOutputRaster(OUT4ETM3, ETMlins, ETMcols, "32-bit float");
CopySubobjects(ETM4BAND3, OUT4ETM3, "georef");
GetOutputRaster(OUT4ETM4, ETMlins, ETMcols, "32-bit float");
CopySubobjects(ETM4BAND4, OUT4ETM4, "georef");
GetOutputRaster(OUT4ETM5, ETMlins, ETMcols, "32-bit float");
CopySubobjects(ETM4BAND5, OUT4ETM5, "georef");
GetOutputRaster(OUT4ETM7, ETMlins, ETMcols, "32-bit float");
CopySubobjects(ETM4BAND7, OUT4ETM7, "georef");
dlgmain.SetOkEnabled(1);
}
else if ( sensors4 == 6 )
{
raster OUT4TM1, OUT4TM2, OUT4TM3, OUT4TM4, OUT4TM5, OUT4TM7;
GetOutputRaster(OUT4TM1, TMlins, TMcols, "32-bit float");
CopySubobjects(TM4BAND1, OUT4TM1, "georef");
GetOutputRaster(OUT4TM2, TMlins, TMcols, "32-bit float");
CopySubobjects(TM4BAND2, OUT4TM2, "georef");
GetOutputRaster(OUT4TM3, TMlins, TMcols, "32-bit float");
CopySubobjects(TM4BAND3, OUT4TM3, "georef");
GetOutputRaster(OUT4TM4, TMlins, TMcols, "32-bit float");
CopySubobjects(TM4BAND4, OUT4TM4, "georef");
GetOutputRaster(OUT4TM5, TMlins, TMcols, "32-bit float");
CopySubobjects(TM4BAND5, OUT4TM5, "georef");
GetOutputRaster(OUT4TM7, TMlins, TMcols, "32-bit float");
CopySubobjects(TM4BAND7, OUT4TM7, "georef");
dlgmain.SetOkEnabled(1);
}
else
{
raster OUT4MSS1, OUT4MSS2, OUT4MSS3, OUT4MSS4;
GetOutputRaster(OUT4MSS1, MSSlins, MSScols, "32-bit float");
CopySubobjects(MSS4BAND1, OUT4MSS1, "georef");
GetOutputRaster(OUT4MSS2, MSSlins, MSScols, "32-bit float");
CopySubobjects(MSS4BAND2, OUT4MSS2, "georef");
GetOutputRaster(OUT4MSS3, MSSlins, MSScols, "32-bit float");
CopySubobjects(MSS4BAND3, OUT4MSS3, "georef");
GetOutputRaster(OUT4MSS4, MSSlins, MSScols, "32-bit float");
CopySubobjects(MSS4BAND4, OUT4MSS4, "georef");
dlgmain.SetOkEnabled(1);
}
}
##################################
### Function for Julian Date aquisition
##################################
func LeapYear(date)
{
if ( (date/4) != round(date/4) ) return false;
if ( (date/100) != round(date/100) ) return true;
if ( (date/400) != round(date/400) ) return false;
return true;
}
func julD(day, month, year)
{
if ( LeapYear(year) )
{
return (day + accumulateLY[month]);
}
else
{
return (day + accumulate[month]);
}
}
##################################
### Function for the calculation of the relative DNmin1000 value
##################################
func DNminCALC(extentLIN, extentCOL, pixel)
{
numeric DNminCALClvl, extentLIN, extentCOL, pixel, DNminCALClevel, DNminCALClvl;
DNminCALClevel = (1000*pixel)/((185000/extentLIN)*(185000/extentCOL));
DNminCALClvl = round(DNminCALClevel);
return DNminCALClvl;
}
######################################################################
######################################################################
#################### Main Program ##################################
######################################################################
######################################################################
clear();
#################################################
### Set up main dialog window
#################################################
xmlmain$ = '
';
err = docmain.Parse(xmlmain$);
if ( err < 0 ) {
PopupError( err ); # pop up an error dialog
Exit( );
}
nodemain = docmain.GetElementByID( "maindlg" );
if ( nodemain == 0 ) {
PopupMessage( "Could not find main dialog node in XML document" );
Exit();
}
dlgmain.SetXMLNode(nodemain);
ret = dlgmain.DoModal();
if (ret == -1)
{
Exit();
}
######################################
###### Begin processing.
###### Calculate Radiance.
######################################
pifDarkVAL = dlgmain.GetCtrlByID("pifDark").GetValueNum();
pifBrightVAL = dlgmain.GetCtrlByID("pifBright").GetValueNum();
minPifVAL = dlgmain.GetCtrlByID("minPif").GetValueNum();
histoTailInputVAL = dlgmain.GetCtrlByID("histoTailInput").GetValueNum();
printf( "Entered PIF-Selection values passed to variables...\n\n" );
printf( "Starting off calculating...\n\n" );
s1zenith = ((2 * pi * (90 - s1ele)) / 360); # sunzenith calculation via 90degree minus sunelevation
s2zenith = ((2 * pi * (90 - s2ele)) / 360);
s3zenith = ((2 * pi * (90 - s3ele)) / 360);
s4zenith = ((2 * pi * (90 - s4ele)) / 360);
s1zenithSIMPLE = 90 - s1ele;
s2zenithSIMPLE = 90 - s2ele;
s3zenithSIMPLE = 90 - s3ele;
s4zenithSIMPLE = 90 - s4ele;
printf("Sun zenith angle (Scene 1): %6f\n", s1zenithSIMPLE);
printf("Sun zenith angle (Scene 2): %6f\n", s2zenithSIMPLE);
printf("Sun zenith angle (Scene 3): %6f\n", s3zenithSIMPLE);
printf("Sun zenith angle (Scene 4): %6f\n\n", s4zenithSIMPLE);
printf( "Sun zenith calculated...\n\n" );
s1yyyymmdd.SetDateYYYYMMDD(s1aq);
s1year = s1yyyymmdd.GetYear();
s1month = s1yyyymmdd.GetMonth();
s1day = s1yyyymmdd.GetDayOfMonth();
s2yyyymmdd.SetDateYYYYMMDD(s2aq);
s2year = s2yyyymmdd.GetYear();
s2month = s2yyyymmdd.GetMonth();
s2day = s2yyyymmdd.GetDayOfMonth();
s3yyyymmdd.SetDateYYYYMMDD(s3aq);
s3year = s3yyyymmdd.GetYear();
s3month = s3yyyymmdd.GetMonth();
s3day = s3yyyymmdd.GetDayOfMonth();
s4yyyymmdd.SetDateYYYYMMDD(s4aq);
s4year = s4yyyymmdd.GetYear();
s4month = s4yyyymmdd.GetMonth();
s4day = s4yyyymmdd.GetDayOfMonth();
s1leap = LeapYear(s1year); #Leap Year = 1 Else = 0
s2leap = LeapYear(s2year);
s3leap = LeapYear(s3year);
s4leap = LeapYear(s4year);
s1jul = julD(s1day, s1month, s1year); #julD(day, month, year)
s2jul = julD(s2day, s2month, s2year);
s3jul = julD(s3day, s3month, s3year);
s4jul = julD(s4day, s4month, s4year);
printf("Julian Date (Scene 1): %3i\n", s1jul);
printf("Julian Date (Scene 2): %3i\n", s2jul);
printf("Julian Date (Scene 3): %3i\n", s3jul);
printf("Julian Date (Scene 4): %3i\n\n", s4jul);
printf( "Julian Date calculated and year, month and day count extracted from aquisition date...\n\n" );
dist1 = 1 / (1 - 0.01674 * cos(0.9856 * (s1jul - 4)));
dist2 = 1 / (1 - 0.01674 * cos(0.9856 * (s2jul - 4)));
dist3 = 1 / (1 - 0.01674 * cos(0.9856 * (s3jul - 4)));
dist4 = 1 / (1 - 0.01674 * cos(0.9856 * (s4jul - 4)));
printf("Earth-Sun distance (Scene 1): %12f\n", dist1);
printf("Earth-Sun distance (Scene 2): %12f\n", dist2);
printf("Earth-Sun distance (Scene 3): %12f\n", dist3);
printf("Earth-Sun distance (Scene 4): %12f\n\n", dist4);
printf( "Earth Sundistance Calculated...\n\n" );
printf( "Computing Radiance...\n\n" );
###########################
### Radiance Scene 1
###########################
if ( sensors1 == 7 )
{
raster RADS1ETM1, RADS1ETM2, RADS1ETM3, RADS1ETM4, RADS1ETM5, RADS1ETM7;
CreateTempRaster(RADS1ETM1, ETMlins, ETMcols,"32-bit float");
CreateTempRaster(RADS1ETM2, ETMlins, ETMcols,"32-bit float");
CreateTempRaster(RADS1ETM3, ETMlins, ETMcols,"32-bit float");
CreateTempRaster(RADS1ETM4, ETMlins, ETMcols,"32-bit float");
CreateTempRaster(RADS1ETM5, ETMlins, ETMcols,"32-bit float");
CreateTempRaster(RADS1ETM7, ETMlins, ETMcols,"32-bit float");
for i = 1 to ETMlins
{
for j = 1 to ETMcols
{
if ( s1aq < 20000701) # Before 1. July 2000
{
if ( earSurCat1 == 8 ) # Desert(hs)
{
RADS1ETM1[i,j] = (B1LGLMAXBef2000-B1LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM1BAND1[i,j]-QCALMIN)+B1LGLMINBef2000;
RADS1ETM2[i,j] = (B2LGLMAXBef2000-B2LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM1BAND2[i,j]-QCALMIN)+B2LGLMINBef2000;
RADS1ETM3[i,j] = (B3LGLMAXBef2000-B3LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM1BAND3[i,j]-QCALMIN)+B3LGLMINBef2000;
RADS1ETM4[i,j] = (B4LGLMAXBef2000-B4LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM1BAND4[i,j]-QCALMIN)+B4LGLMINBef2000;
RADS1ETM5[i,j] = (B5LGLMAXBef2000-B5LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM1BAND5[i,j]-QCALMIN)+B5LGLMINBef2000;
RADS1ETM7[i,j] = (B7LGLMAXBef2000-B7LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM1BAND7[i,j]-QCALMIN)+B7LGLMINBef2000;
}
else if ( earSurCat1 == 7 ) # Desert(ms)
{
RADS1ETM1[i,j] = (B1LGLMAXBef2000-B1LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM1BAND1[i,j]-QCALMIN)+B1LGLMINBef2000;
RADS1ETM2[i,j] = (B2LGLMAXBef2000-B2LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM1BAND2[i,j]-QCALMIN)+B2LGLMINBef2000;
RADS1ETM3[i,j] = (B3LGLMAXBef2000-B3LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM1BAND3[i,j]-QCALMIN)+B3LGLMINBef2000;
RADS1ETM4[i,j] = (B4HGLMAXBef2000-B4HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM1BAND4[i,j]-QCALMIN)+B4HGLMINBef2000;
RADS1ETM5[i,j] = (B5LGLMAXBef2000-B5LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM1BAND5[i,j]-QCALMIN)+B5LGLMINBef2000;
RADS1ETM7[i,j] = (B7LGLMAXBef2000-B7LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM1BAND7[i,j]-QCALMIN)+B7LGLMINBef2000;
}
else if ( earSurCat1 == 6 ) # Desert Ice(ls)
{
RADS1ETM1[i,j] = (B1LGLMAXBef2000-B1LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM1BAND1[i,j]-QCALMIN)+B1LGLMINBef2000;
RADS1ETM2[i,j] = (B2LGLMAXBef2000-B2LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM1BAND2[i,j]-QCALMIN)+B2LGLMINBef2000;
RADS1ETM3[i,j] = (B3LGLMAXBef2000-B3LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM1BAND3[i,j]-QCALMIN)+B3LGLMINBef2000;
RADS1ETM4[i,j] = (B4HGLMAXBef2000-B4HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM1BAND4[i,j]-QCALMIN)+B4HGLMINBef2000;
RADS1ETM5[i,j] = (B5HGLMAXBef2000-B5HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM1BAND5[i,j]-QCALMIN)+B5HGLMINBef2000;
RADS1ETM7[i,j] = (B7HGLMAXBef2000-B7HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM1BAND7[i,j]-QCALMIN)+B7HGLMINBef2000;
}
else if ( earSurCat1 == 5 ) # Ice(hs)
{
RADS1ETM1[i,j] = (B1LGLMAXBef2000-B1LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM1BAND1[i,j]-QCALMIN)+B1LGLMINBef2000;
RADS1ETM2[i,j] = (B2LGLMAXBef2000-B2LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM1BAND2[i,j]-QCALMIN)+B2LGLMINBef2000;
RADS1ETM3[i,j] = (B3LGLMAXBef2000-B3LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM1BAND3[i,j]-QCALMIN)+B3LGLMINBef2000;
RADS1ETM4[i,j] = (B4LGLMAXBef2000-B4LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM1BAND4[i,j]-QCALMIN)+B4LGLMINBef2000;
RADS1ETM5[i,j] = (B5HGLMAXBef2000-B5HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM1BAND5[i,j]-QCALMIN)+B5HGLMINBef2000;
RADS1ETM7[i,j] = (B7HGLMAXBef2000-B7HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM1BAND7[i,j]-QCALMIN)+B7HGLMINBef2000;
}
else if ( earSurCat1 == 4 ) # Land(hs)
{
RADS1ETM1[i,j] = (B1HGLMAXBef2000-B1HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM1BAND1[i,j]-QCALMIN)+B1HGLMINBef2000;
RADS1ETM2[i,j] = (B2HGLMAXBef2000-B2HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM1BAND2[i,j]-QCALMIN)+B2HGLMINBef2000;
RADS1ETM3[i,j] = (B3HGLMAXBef2000-B3HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM1BAND3[i,j]-QCALMIN)+B3HGLMINBef2000;
RADS1ETM4[i,j] = (B4LGLMAXBef2000-B4LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM1BAND4[i,j]-QCALMIN)+B4LGLMINBef2000;
RADS1ETM5[i,j] = (B5HGLMAXBef2000-B5HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM1BAND5[i,j]-QCALMIN)+B5HGLMINBef2000;
RADS1ETM7[i,j] = (B7HGLMAXBef2000-B7HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM1BAND7[i,j]-QCALMIN)+B7HGLMINBef2000;
}
else if ( earSurCat1 == 3 ) # Land Ocean(ls
{
RADS1ETM1[i,j] = (B1HGLMAXBef2000-B1HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM1BAND1[i,j]-QCALMIN)+B1HGLMINBef2000;
RADS1ETM2[i,j] = (B2HGLMAXBef2000-B2HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM1BAND2[i,j]-QCALMIN)+B2HGLMINBef2000;
RADS1ETM3[i,j] = (B3HGLMAXBef2000-B3HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM1BAND3[i,j]-QCALMIN)+B3HGLMINBef2000;
RADS1ETM4[i,j] = (B4HGLMAXBef2000-B4HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM1BAND4[i,j]-QCALMIN)+B4HGLMINBef2000;
RADS1ETM5[i,j] = (B5HGLMAXBef2000-B5HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM1BAND5[i,j]-QCALMIN)+B5HGLMINBef2000;
RADS1ETM7[i,j] = (B7HGLMAXBef2000-B7HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM1BAND7[i,j]-QCALMIN)+B7HGLMINBef2000;
}
else if ( earSurCat1 == 2 ) # Water
{
RADS1ETM1[i,j] = (B1HGLMAXBef2000-B1HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM1BAND1[i,j]-QCALMIN)+B1HGLMINBef2000;
RADS1ETM2[i,j] = (B2HGLMAXBef2000-B2HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM1BAND2[i,j]-QCALMIN)+B2HGLMINBef2000;
RADS1ETM3[i,j] = (B3HGLMAXBef2000-B3HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM1BAND3[i,j]-QCALMIN)+B3HGLMINBef2000;
RADS1ETM4[i,j] = (B4HGLMAXBef2000-B4HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM1BAND4[i,j]-QCALMIN)+B4HGLMINBef2000;
RADS1ETM5[i,j] = (B5HGLMAXBef2000-B5HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM1BAND5[i,j]-QCALMIN)+B5HGLMINBef2000;
RADS1ETM7[i,j] = (B7HGLMAXBef2000-B7HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM1BAND7[i,j]-QCALMIN)+B7HGLMINBef2000;
}
else if ( earSurCat1 == 1 ) # Night(volcanos
{
RADS1ETM1[i,j] = (B1HGLMAXBef2000-B1HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM1BAND1[i,j]-QCALMIN)+B1HGLMINBef2000;
RADS1ETM2[i,j] = (B2HGLMAXBef2000-B2HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM1BAND2[i,j]-QCALMIN)+B2HGLMINBef2000;
RADS1ETM3[i,j] = (B3HGLMAXBef2000-B3HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM1BAND3[i,j]-QCALMIN)+B3HGLMINBef2000;
RADS1ETM4[i,j] = (B4HGLMAXBef2000-B4HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM1BAND4[i,j]-QCALMIN)+B4HGLMINBef2000;
RADS1ETM5[i,j] = (B5LGLMAXBef2000-B5LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM1BAND5[i,j]-QCALMIN)+B5LGLMINBef2000;
RADS1ETM7[i,j] = (B7LGLMAXBef2000-B7LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM1BAND7[i,j]-QCALMIN)+B7LGLMINBef2000;
}
}
else # After 1. July 2000
{
if ( earSurCat1 == 8 ) # Desert(hs)
{
RADS1ETM1[i,j] = (B1LGLMAXAFT2000-B1LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM1BAND1[i,j]-QCALMIN)+B1LGLMINAFT2000;
RADS1ETM2[i,j] = (B2LGLMAXAFT2000-B2LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM1BAND2[i,j]-QCALMIN)+B2LGLMINAFT2000;
RADS1ETM3[i,j] = (B3LGLMAXAFT2000-B3LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM1BAND3[i,j]-QCALMIN)+B3LGLMINAFT2000;
RADS1ETM4[i,j] = (B4LGLMAXAFT2000-B4LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM1BAND4[i,j]-QCALMIN)+B4LGLMINAFT2000;
RADS1ETM5[i,j] = (B5LGLMAXAFT2000-B5LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM1BAND5[i,j]-QCALMIN)+B5LGLMINAFT2000;
RADS1ETM7[i,j] = (B7LGLMAXAFT2000-B7LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM1BAND7[i,j]-QCALMIN)+B7LGLMINAFT2000;
}
else if ( earSurCat1 == 7 ) # Desert(ms)
{
RADS1ETM1[i,j] = (B1LGLMAXAFT2000-B1LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM1BAND1[i,j]-QCALMIN)+B1LGLMINAFT2000;
RADS1ETM2[i,j] = (B2LGLMAXAFT2000-B2LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM1BAND2[i,j]-QCALMIN)+B2LGLMINAFT2000;
RADS1ETM3[i,j] = (B3LGLMAXAFT2000-B3LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM1BAND3[i,j]-QCALMIN)+B3LGLMINAFT2000;
RADS1ETM4[i,j] = (B4HGLMAXAFT2000-B4HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM1BAND4[i,j]-QCALMIN)+B4HGLMINAFT2000;
RADS1ETM5[i,j] = (B5LGLMAXAFT2000-B5LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM1BAND5[i,j]-QCALMIN)+B5LGLMINAFT2000;
RADS1ETM7[i,j] = (B7LGLMAXAFT2000-B7LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM1BAND7[i,j]-QCALMIN)+B7LGLMINAFT2000;
}
else if ( earSurCat1 == 6 ) # Desert Ice(ls)
{
RADS1ETM1[i,j] = (B1LGLMAXAFT2000-B1LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM1BAND1[i,j]-QCALMIN)+B1LGLMINAFT2000;
RADS1ETM2[i,j] = (B2LGLMAXAFT2000-B2LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM1BAND2[i,j]-QCALMIN)+B2LGLMINAFT2000;
RADS1ETM3[i,j] = (B3LGLMAXAFT2000-B3LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM1BAND3[i,j]-QCALMIN)+B3LGLMINAFT2000;
RADS1ETM4[i,j] = (B4HGLMAXAFT2000-B4HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM1BAND4[i,j]-QCALMIN)+B4HGLMINAFT2000;
RADS1ETM5[i,j] = (B5HGLMAXAFT2000-B5HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM1BAND5[i,j]-QCALMIN)+B5HGLMINAFT2000;
RADS1ETM7[i,j] = (B7HGLMAXAFT2000-B7HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM1BAND7[i,j]-QCALMIN)+B7HGLMINAFT2000;
}
else if ( earSurCat1 == 5 ) # Ice(hs)
{
RADS1ETM1[i,j] = (B1LGLMAXAFT2000-B1LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM1BAND1[i,j]-QCALMIN)+B1LGLMINAFT2000;
RADS1ETM2[i,j] = (B2LGLMAXAFT2000-B2LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM1BAND2[i,j]-QCALMIN)+B2LGLMINAFT2000;
RADS1ETM3[i,j] = (B3LGLMAXAFT2000-B3LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM1BAND3[i,j]-QCALMIN)+B3LGLMINAFT2000;
RADS1ETM4[i,j] = (B4LGLMAXAFT2000-B4LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM1BAND4[i,j]-QCALMIN)+B4LGLMINAFT2000;
RADS1ETM5[i,j] = (B5HGLMAXAFT2000-B5HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM1BAND5[i,j]-QCALMIN)+B5HGLMINAFT2000;
RADS1ETM7[i,j] = (B7HGLMAXAFT2000-B7HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM1BAND7[i,j]-QCALMIN)+B7HGLMINAFT2000;
}
else if ( earSurCat1 == 4 ) # Land(hs)
{
RADS1ETM1[i,j] = (B1HGLMAXAFT2000-B1HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM1BAND1[i,j]-QCALMIN)+B1HGLMINAFT2000;
RADS1ETM2[i,j] = (B2HGLMAXAFT2000-B2HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM1BAND2[i,j]-QCALMIN)+B2HGLMINAFT2000;
RADS1ETM3[i,j] = (B3HGLMAXAFT2000-B3HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM1BAND3[i,j]-QCALMIN)+B3HGLMINAFT2000;
RADS1ETM4[i,j] = (B4LGLMAXAFT2000-B4LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM1BAND4[i,j]-QCALMIN)+B4LGLMINAFT2000;
RADS1ETM5[i,j] = (B5HGLMAXAFT2000-B5HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM1BAND5[i,j]-QCALMIN)+B5HGLMINAFT2000;
RADS1ETM7[i,j] = (B7HGLMAXAFT2000-B7HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM1BAND7[i,j]-QCALMIN)+B7HGLMINAFT2000;
}
else if ( earSurCat1 == 3 ) # Land Ocean(ls
{
RADS1ETM1[i,j] = (B1HGLMAXAFT2000-B1HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM1BAND1[i,j]-QCALMIN)+B1HGLMINAFT2000;
RADS1ETM2[i,j] = (B2HGLMAXAFT2000-B2HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM1BAND2[i,j]-QCALMIN)+B2HGLMINAFT2000;
RADS1ETM3[i,j] = (B3HGLMAXAFT2000-B3HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM1BAND3[i,j]-QCALMIN)+B3HGLMINAFT2000;
RADS1ETM4[i,j] = (B4HGLMAXAFT2000-B4HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM1BAND4[i,j]-QCALMIN)+B4HGLMINAFT2000;
RADS1ETM5[i,j] = (B5HGLMAXAFT2000-B5HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM1BAND5[i,j]-QCALMIN)+B5HGLMINAFT2000;
RADS1ETM7[i,j] = (B7HGLMAXAFT2000-B7HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM1BAND7[i,j]-QCALMIN)+B7HGLMINAFT2000;
}
else if ( earSurCat1 == 2 ) # Water
{
RADS1ETM1[i,j] = (B1HGLMAXAFT2000-B1HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM1BAND1[i,j]-QCALMIN)+B1HGLMINAFT2000;
RADS1ETM2[i,j] = (B2HGLMAXAFT2000-B2HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM1BAND2[i,j]-QCALMIN)+B2HGLMINAFT2000;
RADS1ETM3[i,j] = (B3HGLMAXAFT2000-B3HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM1BAND3[i,j]-QCALMIN)+B3HGLMINAFT2000;
RADS1ETM4[i,j] = (B4HGLMAXAFT2000-B4HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM1BAND4[i,j]-QCALMIN)+B4HGLMINAFT2000;
RADS1ETM5[i,j] = (B5HGLMAXAFT2000-B5HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM1BAND5[i,j]-QCALMIN)+B5HGLMINAFT2000;
RADS1ETM7[i,j] = (B7HGLMAXAFT2000-B7HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM1BAND7[i,j]-QCALMIN)+B7HGLMINAFT2000;
}
else if ( earSurCat1 == 1 ) # Night(volcanos
{
RADS1ETM1[i,j] = (B1HGLMAXAFT2000-B1HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM1BAND1[i,j]-QCALMIN)+B1HGLMINAFT2000;
RADS1ETM2[i,j] = (B2HGLMAXAFT2000-B2HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM1BAND2[i,j]-QCALMIN)+B2HGLMINAFT2000;
RADS1ETM3[i,j] = (B3HGLMAXAFT2000-B3HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM1BAND3[i,j]-QCALMIN)+B3HGLMINAFT2000;
RADS1ETM4[i,j] = (B4HGLMAXAFT2000-B4HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM1BAND4[i,j]-QCALMIN)+B4HGLMINAFT2000;
RADS1ETM5[i,j] = (B5LGLMAXAFT2000-B5LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM1BAND5[i,j]-QCALMIN)+B5LGLMINAFT2000;
RADS1ETM7[i,j] = (B7LGLMAXAFT2000-B7LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM1BAND7[i,j]-QCALMIN)+B7LGLMINAFT2000;
}
}
}
}
CloseRaster(ETM1BAND1);
CloseRaster(ETM1BAND2);
CloseRaster(ETM1BAND3);
CloseRaster(ETM1BAND4);
CloseRaster(ETM1BAND5);
CloseRaster(ETM1BAND7);
printf("Radiance calculation for Scene 1 (ETM) is done...\n");
}
else if ( sensors1 == 6 )
{
raster RADS1TM1, RADS1TM2, RADS1TM3, RADS1TM4, RADS1TM5, RADS1TM7;
CreateTempRaster(RADS1TM1, TMlins, TMcols,"32-bit float");
CreateTempRaster(RADS1TM2, TMlins, TMcols,"32-bit float");
CreateTempRaster(RADS1TM3, TMlins, TMcols,"32-bit float");
CreateTempRaster(RADS1TM4, TMlins, TMcols,"32-bit float");
CreateTempRaster(RADS1TM5, TMlins, TMcols,"32-bit float");
CreateTempRaster(RADS1TM7, TMlins, TMcols,"32-bit float");
for i = 1 to TMlins
{
for j = 1 to TMcols
{
if (s1leap == 0)
{
numeric gainnewTMS1b1, gainnewTMS1b2, gainnewTMS1b3, gainnewTMS1b4, gainnewTMS1b5, gainnewTMS1b7;
gainnewTMS1b1 = ((0.145658 * exp(-0.955113 * ((s1year + (s1jul / 365)) - 1984.2082))) + 1.243000);
gainnewTMS1b2 = ((0.058651 * exp(-0.835952 * ((s1year + (s1jul / 365)) - 1984.2082))) + 0.656100);
gainnewTMS1b3 = ((0.111858 * exp(-1.002090 * ((s1year + (s1jul / 365)) - 1984.2082))) + 0.905000);
gainnewTMS1b4 = ((0.107650 * exp(-1.277190 * ((s1year + (s1jul / 365)) - 1984.2082))) + 1.082000);
gainnewTMS1b5 = ((0.243364 * exp(-1.207080 * ((s1year + (s1jul / 365)) - 1984.2082))) + 7.944000);
gainnewTMS1b7 = ((0.403551 * exp(-0.999127 * ((s1year + (s1jul / 365)) - 1984.2082))) + 14.52000);
RADS1TM1[i,j] = ((s1TMg1 * ((gainnewTMS1b1 * ((s1TMg1 * TM1BAND1[i,j]) + s1TMb1)) + biasnewTMb1)) + s1TMb1);
RADS1TM2[i,j] = ((s1TMg2 * ((gainnewTMS1b2 * ((s1TMg2 * TM1BAND2[i,j]) + s1TMb2)) + biasnewTMb2)) + s1TMb2);
RADS1TM3[i,j] = ((s1TMg3 * ((gainnewTMS1b3 * ((s1TMg3 * TM1BAND3[i,j]) + s1TMb3)) + biasnewTMb3)) + s1TMb3);
RADS1TM4[i,j] = ((s1TMg4 * ((gainnewTMS1b4 * ((s1TMg4 * TM1BAND4[i,j]) + s1TMb4)) + biasnewTMb4)) + s1TMb4);
RADS1TM5[i,j] = ((s1TMg5 * ((gainnewTMS1b5 * ((s1TMg5 * TM1BAND5[i,j]) + s1TMb5)) + biasnewTMb5)) + s1TMb5);
RADS1TM7[i,j] = ((s1TMg7 * ((gainnewTMS1b7 * ((s1TMg7 * TM1BAND7[i,j]) + s1TMb7)) + biasnewTMb7)) + s1TMb7);
}
else if (s1leap == 1)
{
numeric gainnewTMS1b1, gainnewTMS1b2, gainnewTMS1b3, gainnewTMS1b4, gainnewTMS1b5, gainnewTMS1b7;
gainnewTMS1b1 = ((0.145658 * exp(-0.955113 * ((s1year + (s1jul / 366)) - 1984.2082))) + 1.243000);
gainnewTMS1b2 = ((0.058651 * exp(-0.835952 * ((s1year + (s1jul / 366)) - 1984.2082))) + 0.656100);
gainnewTMS1b3 = ((0.111858 * exp(-1.002090 * ((s1year + (s1jul / 366)) - 1984.2082))) + 0.905000);
gainnewTMS1b4 = ((0.107650 * exp(-1.277190 * ((s1year + (s1jul / 366)) - 1984.2082))) + 1.082000);
gainnewTMS1b5 = ((0.243364 * exp(-1.207080 * ((s1year + (s1jul / 366)) - 1984.2082))) + 7.944000);
gainnewTMS1b7 = ((0.403551 * exp(-0.999127 * ((s1year + (s1jul / 366)) - 1984.2082))) + 14.52000);
RADS1TM1[i,j] = ((s1TMg1 * ((gainnewTMS1b1 * ((s1TMg1 * TM1BAND1[i,j]) + s1TMb1)) + biasnewTMb1)) + s1TMb1);
RADS1TM2[i,j] = ((s1TMg2 * ((gainnewTMS1b2 * ((s1TMg2 * TM1BAND2[i,j]) + s1TMb2)) + biasnewTMb2)) + s1TMb2);
RADS1TM3[i,j] = ((s1TMg3 * ((gainnewTMS1b3 * ((s1TMg3 * TM1BAND3[i,j]) + s1TMb3)) + biasnewTMb3)) + s1TMb3);
RADS1TM4[i,j] = ((s1TMg4 * ((gainnewTMS1b4 * ((s1TMg4 * TM1BAND4[i,j]) + s1TMb4)) + biasnewTMb4)) + s1TMb4);
RADS1TM5[i,j] = ((s1TMg5 * ((gainnewTMS1b5 * ((s1TMg5 * TM1BAND5[i,j]) + s1TMb5)) + biasnewTMb5)) + s1TMb5);
RADS1TM7[i,j] = ((s1TMg7 * ((gainnewTMS1b7 * ((s1TMg7 * TM1BAND7[i,j]) + s1TMb7)) + biasnewTMb7)) + s1TMb7);
}
}
}
CloseRaster(TM1BAND1);
CloseRaster(TM1BAND2);
CloseRaster(TM1BAND3);
CloseRaster(TM1BAND4);
CloseRaster(TM1BAND5);
CloseRaster(TM1BAND7);
printf("Radiance calculation for Scene 1 (TM) is done...\n");
}
else if ( sensors1 == 5 ) # MSS 5 - Calib Werte nach Price J.C.1987
{
raster RADS1MSS1, RADS1MSS2, RADS1MSS3, RADS1MSS4;
CreateTempRaster(RADS1MSS1, MSSlins, MSScols,"32-bit float");
CreateTempRaster(RADS1MSS2, MSSlins, MSScols,"32-bit float");
CreateTempRaster(RADS1MSS3, MSSlins, MSScols,"32-bit float");
CreateTempRaster(RADS1MSS4, MSSlins, MSScols,"32-bit float");
for i = 1 to MSSlins
{
for j = 1 to MSScols
{
if ( s1aq <= 19841109) # Before 9 November 1984
{
RADS1MSS1[i,j] = L5B1bef84gain * MSS1BAND1[i,j] + L5B1bef84bias;
RADS1MSS2[i,j] = L5B2bef84gain * MSS1BAND2[i,j] + L5B2bef84bias;
RADS1MSS3[i,j] = L5B3bef84gain * MSS1BAND3[i,j] + L5B3bef84bias;
RADS1MSS4[i,j] = L5B4bef84gain * MSS1BAND4[i,j] + L5B4bef84bias;
}
else # after 9 November 1984
{
RADS1MSS1[i,j] = L5B1aft84gain * MSS1BAND1[i,j] + L5B1aft84bias;
RADS1MSS2[i,j] = L5B2aft84gain * MSS1BAND2[i,j] + L5B2aft84bias;
RADS1MSS3[i,j] = L5B3aft84gain * MSS1BAND3[i,j] + L5B3aft84bias;
RADS1MSS4[i,j] = L5B4aft84gain * MSS1BAND4[i,j] + L5B4aft84bias;
}
}
}
CloseRaster(MSS1BAND1);
CloseRaster(MSS1BAND2);
CloseRaster(MSS1BAND3);
CloseRaster(MSS1BAND4);
printf("Radiance calculation for Scene 1 (MSS) is done...\n");
}
else if ( sensors1 == 4 ) # MSS 4
{
raster RADS1MSS1, RADS1MSS2, RADS1MSS3, RADS1MSS4;
CreateTempRaster(RADS1MSS1, MSSlins, MSScols,"32-bit float");
CreateTempRaster(RADS1MSS2, MSSlins, MSScols,"32-bit float");
CreateTempRaster(RADS1MSS3, MSSlins, MSScols,"32-bit float");
CreateTempRaster(RADS1MSS4, MSSlins, MSScols,"32-bit float");
for i = 1 to MSSlins
{
for j = 1 to MSScols
{
if ( s1aq <= 19830401) # Before 1 April 1983
{
RADS1MSS1[i,j]= L4B1bef83gain * MSS1BAND1[i,j] + L4B1bef83bias;
RADS1MSS2[i,j] = L4B2bef83gain * MSS1BAND2[i,j] + L4B2bef83bias;
RADS1MSS3[i,j] = L4B3bef83gain * MSS1BAND3[i,j] + L4B3bef83gain;
RADS1MSS4[i,j] = L4B4bef83gain * MSS1BAND4[i,j] + L4B4bef83bias;
}
else # After 1 April 1983
{
RADS1MSS1[i,j] = L4B1aft83gain * MSS1BAND1[i,j] + L4B1aft83bias;
RADS1MSS2[i,j] = L4B2aft83gain * MSS1BAND2[i,j] + L4B2aft83bias;
RADS1MSS3[i,j] = L4B3aft83gain * MSS1BAND3[i,j] + L4B3aft83bias;
RADS1MSS4[i,j] = L4B4aft83gain * MSS1BAND4[i,j] + L4B4aft83bias;
}
}
}
CloseRaster(MSS1BAND1);
CloseRaster(MSS1BAND2);
CloseRaster(MSS1BAND3);
CloseRaster(MSS1BAND4);
printf("Radiance calculation for Scene 1 (MSS) is done...\n");
}
else if ( sensors1 == 3 ) # MSS 3
{
raster RADS1MSS1, RADS1MSS2, RADS1MSS3, RADS1MSS4;
CreateTempRaster(RADS1MSS1, MSSlins, MSScols,"32-bit float");
CreateTempRaster(RADS1MSS2, MSSlins, MSScols,"32-bit float");
CreateTempRaster(RADS1MSS3, MSSlins, MSScols,"32-bit float");
CreateTempRaster(RADS1MSS4, MSSlins, MSScols,"32-bit float");
for i = 1 to MSSlins
{
for j = 1 to MSScols
{
if ( s1aq <= 19780601 ) # Before 1 Juni 1978
{
RADS1MSS1[i,j] = L3B1bef78gain * MSS1BAND1[i,j] + L3B1bef78bias;
RADS1MSS2[i,j] = L3B2bef78gain * MSS1BAND2[i,j] + L3B2bef78bias;
RADS1MSS3[i,j] = L3B3bef78gain * MSS1BAND3[i,j] + L3B3bef78bias;
RADS1MSS4[i,j] = L3B4bef78gain * MSS1BAND4[i,j] + L3B4bef78bias;
}
else if ( s1aq >= 19780602 and s1aq <= 19790201 ) # 2 Juni 1978 bis 1 Februar 1979
{
RADS1MSS1[i,j] = L3B17879gain * MSS1BAND1[i,j] + L3B17879bias;
RADS1MSS2[i,j] = L3B27879gain * MSS1BAND2[i,j] + L3B27879bias;
RADS1MSS3[i,j] = L3B37879gain * MSS1BAND3[i,j] + L3B37879bias;
RADS1MSS4[i,j] = L3B47879gain * MSS1BAND4[i,j] + L3B47879bias;
}
else if ( s1aq > 19790201 ) # After 1 Februar 1979
{
RADS1MSS1[i,j] = L3B1aft79gain * MSS1BAND1[i,j] + L3B1aft79bias;
RADS1MSS2[i,j] = L3B2aft79gain * MSS1BAND2[i,j] + L3B2aft79bias;
RADS1MSS3[i,j] = L3B3aft79gain * MSS1BAND3[i,j] + L3B3aft79bias;
RADS1MSS4[i,j] = L3B4aft79gain * MSS1BAND4[i,j] + L3B4aft79bias;
}
}
}
CloseRaster(MSS1BAND1);
CloseRaster(MSS1BAND2);
CloseRaster(MSS1BAND3);
CloseRaster(MSS1BAND4);
printf("Radiance calculation for Scene 1 (MSS) is done...\n");
}
else if ( sensors1 == 2 ) # MSS 2
{
raster RADS1MSS1, RADS1MSS2, RADS1MSS3, RADS1MSS4;
CreateTempRaster(RADS1MSS1, MSSlins, MSScols,"32-bit float");
CreateTempRaster(RADS1MSS2, MSSlins, MSScols,"32-bit float");
CreateTempRaster(RADS1MSS3, MSSlins, MSScols,"32-bit float");
CreateTempRaster(RADS1MSS4, MSSlins, MSScols,"32-bit float");
for i = 1 to MSSlins
{
for j = 1 to MSScols
{
if ( s1aq <= 19750716 ) # Before 16 Juli 1975
{
RADS1MSS1[i,j] = L2B1bef75gain * MSS1BAND1[i,j] + L2B1bef75bias;
RADS1MSS2[i,j] = L2B2bef75gain * MSS1BAND2[i,j] + L2B2bef75bias;
RADS1MSS3[i,j] = L2B3bef75gain * MSS1BAND3[i,j] + L2B3bef75bias;
RADS1MSS4[i,j] = L2B4bef75gain * MSS1BAND4[i,j] + L2B4bef75bias;
}
else if ( s1aq > 19750716 and s1aq <= 19790201 )
{
RADS1MSS1[i,j] = L2B1aft75gain * MSS1BAND1[i,j] + L2B1aft75bias; # After 16. Juli 1975
RADS1MSS2[i,j] = L2B2aft75gain * MSS1BAND2[i,j] + L2B2aft75bias;
RADS1MSS3[i,j] = L2B3aft75gain * MSS1BAND3[i,j] + L2B3aft75bias;
RADS1MSS4[i,j] = L2B4aft75gain * MSS1BAND4[i,j] + L2B4aft75bias;
}
else if ( s1aq > 19790201 )
{
RADS1MSS1[i,j] = L2B1aft79gain * MSS1BAND1[i,j] + L2B1aft79bias; # After 1. Februar 1979
RADS1MSS2[i,j] = L2B2aft79gain * MSS1BAND2[i,j] + L2B2aft79bias;
RADS1MSS3[i,j] = L2B3aft79gain * MSS1BAND3[i,j] + L2B3aft79bias;
RADS1MSS4[i,j] = L2B4aft79gain * MSS1BAND4[i,j] + L2B4aft79bias;
}
}
}
CloseRaster(MSS1BAND1);
CloseRaster(MSS1BAND2);
CloseRaster(MSS1BAND3);
CloseRaster(MSS1BAND4);
printf("Radiance calculation for Scene 1 (MSS) is done...\n");
}
else if ( sensors1 == 1 ) # MSS 1
{
raster RADS1MSS1, RADS1MSS2, RADS1MSS3, RADS1MSS4;
CreateTempRaster(RADS1MSS1, MSSlins, MSScols,"32-bit float");
CreateTempRaster(RADS1MSS2, MSSlins, MSScols,"32-bit float");
CreateTempRaster(RADS1MSS3, MSSlins, MSScols,"32-bit float");
CreateTempRaster(RADS1MSS4, MSSlins, MSScols,"32-bit float");
for i = 1 to MSSlins
{
for j = 1 to MSScols
{
RADS1MSS1[i,j] = L1B1gain * MSS1BAND1[i,j] + L1B1bias;
RADS1MSS2[i,j] = L1B2gain * MSS1BAND2[i,j] + L1B1bias;
RADS1MSS3[i,j] = L1B3gain * MSS1BAND3[i,j] + L1B1bias;
RADS1MSS4[i,j] = L1B4gain * MSS1BAND4[i,j] + L1B1bias;
}
}
CloseRaster(MSS1BAND1);
CloseRaster(MSS1BAND2);
CloseRaster(MSS1BAND3);
CloseRaster(MSS1BAND4);
printf("Radiance calculation for Scene 1 (MSS) is done...\n");
}
###########################
### Radiance Scene 2
###########################
if ( sensors2 == 7 )
{
raster RADS2ETM1, RADS2ETM2, RADS2ETM3, RADS2ETM4, RADS2ETM5, RADS2ETM7;
CreateTempRaster(RADS2ETM1, ETMlins, ETMcols,"32-bit float");
CreateTempRaster(RADS2ETM2, ETMlins, ETMcols,"32-bit float");
CreateTempRaster(RADS2ETM3, ETMlins, ETMcols,"32-bit float");
CreateTempRaster(RADS2ETM4, ETMlins, ETMcols,"32-bit float");
CreateTempRaster(RADS2ETM5, ETMlins, ETMcols,"32-bit float");
CreateTempRaster(RADS2ETM7, ETMlins, ETMcols,"32-bit float");
for i = 1 to ETMlins
{
for j = 1 to ETMcols
{
if ( s2aq < 20000701) # Before 1. July 2000
{
if ( earSurCat2 == 8 ) # Desert(hs)
{
RADS2ETM1[i,j] = (B1LGLMAXBef2000-B1LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM2BAND1[i,j]-QCALMIN)+B1LGLMINBef2000;
RADS2ETM2[i,j] = (B2LGLMAXBef2000-B2LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM2BAND2[i,j]-QCALMIN)+B2LGLMINBef2000;
RADS2ETM3[i,j] = (B3LGLMAXBef2000-B3LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM2BAND3[i,j]-QCALMIN)+B3LGLMINBef2000;
RADS2ETM4[i,j] = (B4LGLMAXBef2000-B4LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM2BAND4[i,j]-QCALMIN)+B4LGLMINBef2000;
RADS2ETM5[i,j] = (B5LGLMAXBef2000-B5LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM2BAND5[i,j]-QCALMIN)+B5LGLMINBef2000;
RADS2ETM7[i,j] = (B7LGLMAXBef2000-B7LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM2BAND7[i,j]-QCALMIN)+B7LGLMINBef2000;
}
else if ( earSurCat2 == 7 ) # Desert(ms)
{
RADS2ETM1[i,j] = (B1LGLMAXBef2000-B1LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM2BAND1[i,j]-QCALMIN)+B1LGLMINBef2000;
RADS2ETM2[i,j] = (B2LGLMAXBef2000-B2LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM2BAND2[i,j]-QCALMIN)+B2LGLMINBef2000;
RADS2ETM3[i,j] = (B3LGLMAXBef2000-B3LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM2BAND3[i,j]-QCALMIN)+B3LGLMINBef2000;
RADS2ETM4[i,j] = (B4HGLMAXBef2000-B4HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM2BAND4[i,j]-QCALMIN)+B4HGLMINBef2000;
RADS2ETM5[i,j] = (B5LGLMAXBef2000-B5LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM2BAND5[i,j]-QCALMIN)+B5LGLMINBef2000;
RADS2ETM7[i,j] = (B7LGLMAXBef2000-B7LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM2BAND7[i,j]-QCALMIN)+B7LGLMINBef2000;
}
else if ( earSurCat2 == 6 ) # Desert Ice(ls)
{
RADS2ETM1[i,j] = (B1LGLMAXBef2000-B1LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM2BAND1[i,j]-QCALMIN)+B1LGLMINBef2000;
RADS2ETM2[i,j] = (B2LGLMAXBef2000-B2LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM2BAND2[i,j]-QCALMIN)+B2LGLMINBef2000;
RADS2ETM3[i,j] = (B3LGLMAXBef2000-B3LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM2BAND3[i,j]-QCALMIN)+B3LGLMINBef2000;
RADS2ETM4[i,j] = (B4HGLMAXBef2000-B4HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM2BAND4[i,j]-QCALMIN)+B4HGLMINBef2000;
RADS2ETM5[i,j] = (B5HGLMAXBef2000-B5HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM2BAND5[i,j]-QCALMIN)+B5HGLMINBef2000;
RADS2ETM7[i,j] = (B7HGLMAXBef2000-B7HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM2BAND7[i,j]-QCALMIN)+B7HGLMINBef2000;
}
else if ( earSurCat2 == 5 ) # Ice(hs)
{
RADS2ETM1[i,j] = (B1LGLMAXBef2000-B1LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM2BAND1[i,j]-QCALMIN)+B1LGLMINBef2000;
RADS2ETM2[i,j] = (B2LGLMAXBef2000-B2LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM2BAND2[i,j]-QCALMIN)+B2LGLMINBef2000;
RADS2ETM3[i,j] = (B3LGLMAXBef2000-B3LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM2BAND3[i,j]-QCALMIN)+B3LGLMINBef2000;
RADS2ETM4[i,j] = (B4LGLMAXBef2000-B4LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM2BAND4[i,j]-QCALMIN)+B4LGLMINBef2000;
RADS2ETM5[i,j] = (B5HGLMAXBef2000-B5HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM2BAND5[i,j]-QCALMIN)+B5HGLMINBef2000;
RADS2ETM7[i,j] = (B7HGLMAXBef2000-B7HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM2BAND7[i,j]-QCALMIN)+B7HGLMINBef2000;
}
else if ( earSurCat2 == 4 ) # Land(hs)
{
RADS2ETM1[i,j] = (B1HGLMAXBef2000-B1HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM2BAND1[i,j]-QCALMIN)+B1HGLMINBef2000;
RADS2ETM2[i,j] = (B2HGLMAXBef2000-B2HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM2BAND2[i,j]-QCALMIN)+B2HGLMINBef2000;
RADS2ETM3[i,j] = (B3HGLMAXBef2000-B3HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM2BAND3[i,j]-QCALMIN)+B3HGLMINBef2000;
RADS2ETM4[i,j] = (B4LGLMAXBef2000-B4LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM2BAND4[i,j]-QCALMIN)+B4LGLMINBef2000;
RADS2ETM5[i,j] = (B5HGLMAXBef2000-B5HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM2BAND5[i,j]-QCALMIN)+B5HGLMINBef2000;
RADS2ETM7[i,j] = (B7HGLMAXBef2000-B7HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM2BAND7[i,j]-QCALMIN)+B7HGLMINBef2000;
}
else if ( earSurCat2 == 3 ) # Land Ocean(ls
{
RADS2ETM1[i,j] = (B1HGLMAXBef2000-B1HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM2BAND1[i,j]-QCALMIN)+B1HGLMINBef2000;
RADS2ETM2[i,j] = (B2HGLMAXBef2000-B2HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM2BAND2[i,j]-QCALMIN)+B2HGLMINBef2000;
RADS2ETM3[i,j] = (B3HGLMAXBef2000-B3HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM2BAND3[i,j]-QCALMIN)+B3HGLMINBef2000;
RADS2ETM4[i,j] = (B4HGLMAXBef2000-B4HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM2BAND4[i,j]-QCALMIN)+B4HGLMINBef2000;
RADS2ETM5[i,j] = (B5HGLMAXBef2000-B5HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM2BAND5[i,j]-QCALMIN)+B5HGLMINBef2000;
RADS2ETM7[i,j] = (B7HGLMAXBef2000-B7HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM2BAND7[i,j]-QCALMIN)+B7HGLMINBef2000;
}
else if ( earSurCat2 == 2 ) # Water
{
RADS2ETM1[i,j] = (B1HGLMAXBef2000-B1HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM2BAND1[i,j]-QCALMIN)+B1HGLMINBef2000;
RADS2ETM2[i,j] = (B2HGLMAXBef2000-B2HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM2BAND2[i,j]-QCALMIN)+B2HGLMINBef2000;
RADS2ETM3[i,j] = (B3HGLMAXBef2000-B3HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM2BAND3[i,j]-QCALMIN)+B3HGLMINBef2000;
RADS2ETM4[i,j] = (B4HGLMAXBef2000-B4HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM2BAND4[i,j]-QCALMIN)+B4HGLMINBef2000;
RADS2ETM5[i,j] = (B5HGLMAXBef2000-B5HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM2BAND5[i,j]-QCALMIN)+B5HGLMINBef2000;
RADS2ETM7[i,j] = (B7HGLMAXBef2000-B7HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM2BAND7[i,j]-QCALMIN)+B7HGLMINBef2000;
}
else if ( earSurCat2 == 1 ) # Night(volcanos
{
RADS2ETM1[i,j] = (B1HGLMAXBef2000-B1HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM2BAND1[i,j]-QCALMIN)+B1HGLMINBef2000;
RADS2ETM2[i,j] = (B2HGLMAXBef2000-B2HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM2BAND2[i,j]-QCALMIN)+B2HGLMINBef2000;
RADS2ETM3[i,j] = (B3HGLMAXBef2000-B3HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM2BAND3[i,j]-QCALMIN)+B3HGLMINBef2000;
RADS2ETM4[i,j] = (B4HGLMAXBef2000-B4HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM2BAND4[i,j]-QCALMIN)+B4HGLMINBef2000;
RADS2ETM5[i,j] = (B5LGLMAXBef2000-B5LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM2BAND5[i,j]-QCALMIN)+B5LGLMINBef2000;
RADS2ETM7[i,j] = (B7LGLMAXBef2000-B7LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM2BAND7[i,j]-QCALMIN)+B7LGLMINBef2000;
}
}
else # After 1. July 2000
{
if ( earSurCat2 == 8 ) # Desert(hs)
{
RADS2ETM1[i,j] = (B1LGLMAXAFT2000-B1LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM2BAND1[i,j]-QCALMIN)+B1LGLMINAFT2000;
RADS2ETM2[i,j] = (B2LGLMAXAFT2000-B2LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM2BAND2[i,j]-QCALMIN)+B2LGLMINAFT2000;
RADS2ETM3[i,j] = (B3LGLMAXAFT2000-B3LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM2BAND3[i,j]-QCALMIN)+B3LGLMINAFT2000;
RADS2ETM4[i,j] = (B4LGLMAXAFT2000-B4LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM2BAND4[i,j]-QCALMIN)+B4LGLMINAFT2000;
RADS2ETM5[i,j] = (B5LGLMAXAFT2000-B5LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM2BAND5[i,j]-QCALMIN)+B5LGLMINAFT2000;
RADS2ETM7[i,j] = (B7LGLMAXAFT2000-B7LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM2BAND7[i,j]-QCALMIN)+B7LGLMINAFT2000;
}
else if ( earSurCat2 == 7 ) # Desert(ms)
{
RADS2ETM1[i,j] = (B1LGLMAXAFT2000-B1LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM2BAND1[i,j]-QCALMIN)+B1LGLMINAFT2000;
RADS2ETM2[i,j] = (B2LGLMAXAFT2000-B2LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM2BAND2[i,j]-QCALMIN)+B2LGLMINAFT2000;
RADS2ETM3[i,j] = (B3LGLMAXAFT2000-B3LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM2BAND3[i,j]-QCALMIN)+B3LGLMINAFT2000;
RADS2ETM4[i,j] = (B4HGLMAXAFT2000-B4HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM2BAND4[i,j]-QCALMIN)+B4HGLMINAFT2000;
RADS2ETM5[i,j] = (B5LGLMAXAFT2000-B5LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM2BAND5[i,j]-QCALMIN)+B5LGLMINAFT2000;
RADS2ETM7[i,j] = (B7LGLMAXAFT2000-B7LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM2BAND7[i,j]-QCALMIN)+B7LGLMINAFT2000;
}
else if ( earSurCat2 == 6 ) # Desert Ice(ls)
{
RADS2ETM1[i,j] = (B1LGLMAXAFT2000-B1LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM2BAND1[i,j]-QCALMIN)+B1LGLMINAFT2000;
RADS2ETM2[i,j] = (B2LGLMAXAFT2000-B2LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM2BAND2[i,j]-QCALMIN)+B2LGLMINAFT2000;
RADS2ETM3[i,j] = (B3LGLMAXAFT2000-B3LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM2BAND3[i,j]-QCALMIN)+B3LGLMINAFT2000;
RADS2ETM4[i,j] = (B4HGLMAXAFT2000-B4HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM2BAND4[i,j]-QCALMIN)+B4HGLMINAFT2000;
RADS2ETM5[i,j] = (B5HGLMAXAFT2000-B5HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM2BAND5[i,j]-QCALMIN)+B5HGLMINAFT2000;
RADS2ETM7[i,j] = (B7HGLMAXAFT2000-B7HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM2BAND7[i,j]-QCALMIN)+B7HGLMINAFT2000;
}
else if ( earSurCat2 == 5 ) # Ice(hs)
{
RADS2ETM1[i,j] = (B1LGLMAXAFT2000-B1LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM2BAND1[i,j]-QCALMIN)+B1LGLMINAFT2000;
RADS2ETM2[i,j] = (B2LGLMAXAFT2000-B2LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM2BAND2[i,j]-QCALMIN)+B2LGLMINAFT2000;
RADS2ETM3[i,j] = (B3LGLMAXAFT2000-B3LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM2BAND3[i,j]-QCALMIN)+B3LGLMINAFT2000;
RADS2ETM4[i,j] = (B4LGLMAXAFT2000-B4LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM2BAND4[i,j]-QCALMIN)+B4LGLMINAFT2000;
RADS2ETM5[i,j] = (B5HGLMAXAFT2000-B5HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM2BAND5[i,j]-QCALMIN)+B5HGLMINAFT2000;
RADS2ETM7[i,j] = (B7HGLMAXAFT2000-B7HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM2BAND7[i,j]-QCALMIN)+B7HGLMINAFT2000;
}
else if ( earSurCat2 == 4 ) # Land(hs)
{
RADS2ETM1[i,j] = (B1HGLMAXAFT2000-B1HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM2BAND1[i,j]-QCALMIN)+B1HGLMINAFT2000;
RADS2ETM2[i,j] = (B2HGLMAXAFT2000-B2HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM2BAND2[i,j]-QCALMIN)+B2HGLMINAFT2000;
RADS2ETM3[i,j] = (B3HGLMAXAFT2000-B3HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM2BAND3[i,j]-QCALMIN)+B3HGLMINAFT2000;
RADS2ETM4[i,j] = (B4LGLMAXAFT2000-B4LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM2BAND4[i,j]-QCALMIN)+B4LGLMINAFT2000;
RADS2ETM5[i,j] = (B5HGLMAXAFT2000-B5HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM2BAND5[i,j]-QCALMIN)+B5HGLMINAFT2000;
RADS2ETM7[i,j] = (B7HGLMAXAFT2000-B7HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM2BAND7[i,j]-QCALMIN)+B7HGLMINAFT2000;
}
else if ( earSurCat2 == 3 ) # Land Ocean(ls)
{
RADS2ETM1[i,j] = (B1HGLMAXAFT2000-B1HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM2BAND1[i,j]-QCALMIN)+B1HGLMINAFT2000;
RADS2ETM2[i,j] = (B2HGLMAXAFT2000-B2HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM2BAND2[i,j]-QCALMIN)+B2HGLMINAFT2000;
RADS2ETM3[i,j] = (B3HGLMAXAFT2000-B3HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM2BAND3[i,j]-QCALMIN)+B3HGLMINAFT2000;
RADS2ETM4[i,j] = (B4HGLMAXAFT2000-B4HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM2BAND4[i,j]-QCALMIN)+B4HGLMINAFT2000;
RADS2ETM5[i,j] = (B5HGLMAXAFT2000-B5HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM2BAND5[i,j]-QCALMIN)+B5HGLMINAFT2000;
RADS2ETM7[i,j] = (B7HGLMAXAFT2000-B7HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM2BAND7[i,j]-QCALMIN)+B7HGLMINAFT2000;
}
else if ( earSurCat2 == 2 ) # Water
{
RADS2ETM1[i,j] = (B1HGLMAXAFT2000-B1HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM2BAND1[i,j]-QCALMIN)+B1HGLMINAFT2000;
RADS2ETM2[i,j] = (B2HGLMAXAFT2000-B2HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM2BAND2[i,j]-QCALMIN)+B2HGLMINAFT2000;
RADS2ETM3[i,j] = (B3HGLMAXAFT2000-B3HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM2BAND3[i,j]-QCALMIN)+B3HGLMINAFT2000;
RADS2ETM4[i,j] = (B4HGLMAXAFT2000-B4HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM2BAND4[i,j]-QCALMIN)+B4HGLMINAFT2000;
RADS2ETM5[i,j] = (B5HGLMAXAFT2000-B5HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM2BAND5[i,j]-QCALMIN)+B5HGLMINAFT2000;
RADS2ETM7[i,j] = (B7HGLMAXAFT2000-B7HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM2BAND7[i,j]-QCALMIN)+B7HGLMINAFT2000;
}
else if ( earSurCat2 == 1 ) # Night(volcanos)
{
RADS2ETM1[i,j] = (B1HGLMAXAFT2000-B1HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM2BAND1[i,j]-QCALMIN)+B1HGLMINAFT2000;
RADS2ETM2[i,j] = (B2HGLMAXAFT2000-B2HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM2BAND2[i,j]-QCALMIN)+B2HGLMINAFT2000;
RADS2ETM3[i,j] = (B3HGLMAXAFT2000-B3HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM2BAND3[i,j]-QCALMIN)+B3HGLMINAFT2000;
RADS2ETM4[i,j] = (B4HGLMAXAFT2000-B4HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM2BAND4[i,j]-QCALMIN)+B4HGLMINAFT2000;
RADS2ETM5[i,j] = (B5LGLMAXAFT2000-B5LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM2BAND5[i,j]-QCALMIN)+B5LGLMINAFT2000;
RADS2ETM7[i,j] = (B7LGLMAXAFT2000-B7LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM2BAND7[i,j]-QCALMIN)+B7LGLMINAFT2000;
}
}
}
}
CloseRaster(ETM2BAND1);
CloseRaster(ETM2BAND2);
CloseRaster(ETM2BAND3);
CloseRaster(ETM2BAND4);
CloseRaster(ETM2BAND5);
CloseRaster(ETM2BAND7);
printf("Radiance calculation for Scene 2 (ETM) is done...\n");
}
else if ( sensors2 == 6 )
{
raster RADS2TM1, RADS2TM2, RADS2TM3, RADS2TM4, RADS2TM5, RADS2TM7;
CreateTempRaster(RADS2TM1, TMlins, TMcols,"32-bit float");
CreateTempRaster(RADS2TM2, TMlins, TMcols,"32-bit float");
CreateTempRaster(RADS2TM3, TMlins, TMcols,"32-bit float");
CreateTempRaster(RADS2TM4, TMlins, TMcols,"32-bit float");
CreateTempRaster(RADS2TM5, TMlins, TMcols,"32-bit float");
CreateTempRaster(RADS2TM7, TMlins, TMcols,"32-bit float");
for i = 1 to TMlins
{
for j = 1 to TMcols
{
if (s2leap == 0)
{
numeric gainnewTMS2b1, gainnewTMS2b2, gainnewTMS2b3, gainnewTMS2b4, gainnewTMS2b5, gainnewTMS2b7;
gainnewTMS2b1 = ((0.145658 * exp(-0.955113 * ((s2year + (s2jul / 365)) - 1984.2082))) + 1.243000);
gainnewTMS2b2 = ((0.058651 * exp(-0.835952 * ((s2year + (s2jul / 365)) - 1984.2082))) + 0.656100);
gainnewTMS2b3 = ((0.111858 * exp(-1.002090 * ((s2year + (s2jul / 365)) - 1984.2082))) + 0.905000);
gainnewTMS2b4 = ((0.107650 * exp(-1.277190 * ((s2year + (s2jul / 365)) - 1984.2082))) + 1.082000);
gainnewTMS2b5 = ((0.243364 * exp(-1.207080 * ((s2year + (s2jul / 365)) - 1984.2082))) + 7.944000);
gainnewTMS2b7 = ((0.403551 * exp(-0.999127 * ((s2year + (s2jul / 365)) - 1984.2082))) + 14.52000);
RADS2TM1[i,j] = ((s2TMg1 * ((gainnewTMS2b1 * ((s2TMg1 * TM2BAND1[i,j]) + s2TMb1)) + biasnewTMb1)) + s2TMb1);
RADS2TM2[i,j] = ((s2TMg2 * ((gainnewTMS2b2 * ((s2TMg2 * TM2BAND2[i,j]) + s2TMb2)) + biasnewTMb2)) + s2TMb2);
RADS2TM3[i,j] = ((s2TMg3 * ((gainnewTMS2b3 * ((s2TMg3 * TM2BAND3[i,j]) + s2TMb3)) + biasnewTMb3)) + s2TMb3);
RADS2TM4[i,j] = ((s2TMg4 * ((gainnewTMS2b4 * ((s2TMg4 * TM2BAND4[i,j]) + s2TMb4)) + biasnewTMb4)) + s2TMb4);
RADS2TM5[i,j] = ((s2TMg5 * ((gainnewTMS2b5 * ((s2TMg5 * TM2BAND5[i,j]) + s2TMb5)) + biasnewTMb5)) + s2TMb5);
RADS2TM7[i,j] = ((s2TMg7 * ((gainnewTMS2b7 * ((s2TMg7 * TM2BAND7[i,j]) + s2TMb7)) + biasnewTMb7)) + s2TMb7);
}
else if (s2leap == 1)
{
numeric gainnewTMS2b1, gainnewTMS2b2, gainnewTMS2b3, gainnewTMS2b4, gainnewTMS2b5, gainnewTMS2b7;
gainnewTMS2b1 = ((0.145658 * exp(-0.955113 * ((s2year + (s2jul / 366)) - 1984.2082))) + 1.243000);
gainnewTMS2b2 = ((0.058651 * exp(-0.835952 * ((s2year + (s2jul / 366)) - 1984.2082))) + 0.656100);
gainnewTMS2b3 = ((0.111858 * exp(-1.002090 * ((s2year + (s2jul / 366)) - 1984.2082))) + 0.905000);
gainnewTMS2b4 = ((0.107650 * exp(-1.277190 * ((s2year + (s2jul / 366)) - 1984.2082))) + 1.082000);
gainnewTMS2b5 = ((0.243364 * exp(-1.207080 * ((s2year + (s2jul / 366)) - 1984.2082))) + 7.944000);
gainnewTMS2b7 = ((0.403551 * exp(-0.999127 * ((s2year + (s2jul / 366)) - 1984.2082))) + 14.52000);
RADS2TM1[i,j] = ((s2TMg1 * ((gainnewTMS2b1 * ((s2TMg1 * TM2BAND1[i,j]) + s2TMb1)) + biasnewTMb1)) + s2TMb1);
RADS2TM2[i,j] = ((s2TMg2 * ((gainnewTMS2b2 * ((s2TMg2 * TM2BAND2[i,j]) + s2TMb2)) + biasnewTMb2)) + s2TMb2);
RADS2TM3[i,j] = ((s2TMg3 * ((gainnewTMS2b3 * ((s2TMg3 * TM2BAND3[i,j]) + s2TMb3)) + biasnewTMb3)) + s2TMb3);
RADS2TM4[i,j] = ((s2TMg4 * ((gainnewTMS2b4 * ((s2TMg4 * TM2BAND4[i,j]) + s2TMb4)) + biasnewTMb4)) + s2TMb4);
RADS2TM5[i,j] = ((s2TMg5 * ((gainnewTMS2b5 * ((s2TMg5 * TM2BAND5[i,j]) + s2TMb5)) + biasnewTMb5)) + s2TMb5);
RADS2TM7[i,j] = ((s2TMg7 * ((gainnewTMS2b7 * ((s2TMg7 * TM2BAND7[i,j]) + s2TMb7)) + biasnewTMb7)) + s2TMb7);
}
}
}
CloseRaster(TM2BAND1);
CloseRaster(TM2BAND2);
CloseRaster(TM2BAND3);
CloseRaster(TM2BAND4);
CloseRaster(TM2BAND5);
CloseRaster(TM2BAND7);
printf("Radiance calculation for Scene 2 (TM) is done...\n");
}
else if ( sensors2 == 5 ) # MSS 5 - Calib Werte nach Price J.C.1987
{
raster RADS2MSS1, RADS2MSS2, RADS2MSS3, RADS2MSS4;
CreateTempRaster(RADS2MSS1, MSSlins, MSScols,"32-bit float");
CreateTempRaster(RADS2MSS2, MSSlins, MSScols,"32-bit float");
CreateTempRaster(RADS2MSS3, MSSlins, MSScols,"32-bit float");
CreateTempRaster(RADS2MSS4, MSSlins, MSScols,"32-bit float");
for i = 1 to MSSlins
{
for j = 1 to MSScols
{
if ( s2aq <= 19841109) # Before 9 November 1984
{
RADS2MSS1[i,j] = L5B1bef84gain * MSS2BAND1[i,j] + L5B1bef84bias;
RADS2MSS2[i,j] = L5B2bef84gain * MSS2BAND2[i,j] + L5B2bef84bias;
RADS2MSS3[i,j] = L5B3bef84gain * MSS2BAND3[i,j] + L5B3bef84bias;
RADS2MSS4[i,j] = L5B4bef84gain * MSS2BAND4[i,j] + L5B4bef84bias;
}
else # after 9 November 1984
{
RADS2MSS1[i,j] = L5B1aft84gain * MSS2BAND1[i,j] + L5B1aft84bias;
RADS2MSS2[i,j] = L5B2aft84gain * MSS2BAND2[i,j] + L5B2aft84bias;
RADS2MSS3[i,j] = L5B3aft84gain * MSS2BAND3[i,j] + L5B3aft84bias;
RADS2MSS4[i,j] = L5B4aft84gain * MSS2BAND4[i,j] + L5B4aft84bias;
}
}
}
CloseRaster(MSS2BAND1);
CloseRaster(MSS2BAND2);
CloseRaster(MSS2BAND3);
CloseRaster(MSS2BAND4);
printf("Radiance calculation for Scene 2 (MSS) is done...\n");
}
else if ( sensors2 == 4 ) # MSS 4
{
raster RADS2MSS1, RADS2MSS2, RADS2MSS3, RADS2MSS4;
CreateTempRaster(RADS2MSS1, MSSlins, MSScols,"32-bit float");
CreateTempRaster(RADS2MSS2, MSSlins, MSScols,"32-bit float");
CreateTempRaster(RADS2MSS3, MSSlins, MSScols,"32-bit float");
CreateTempRaster(RADS2MSS4, MSSlins, MSScols,"32-bit float");
for i = 1 to MSSlins
{
for j = 1 to MSScols
{
if ( s2aq <= 19830401) # Before 1 April 1983
{
RADS2MSS1[i,j] = L4B1bef83gain * MSS2BAND1[i,j] + L4B1bef83bias;
RADS2MSS2[i,j] = L4B2bef83gain * MSS2BAND2[i,j] + L4B2bef83bias;
RADS2MSS3[i,j] = L4B3bef83gain * MSS2BAND3[i,j] + L4B3bef83gain;
RADS2MSS4[i,j] = L4B4bef83gain * MSS2BAND4[i,j] + L4B4bef83bias;
}
else # After 1 April 1983
{
RADS2MSS1[i,j] = L4B1aft83gain * MSS2BAND1[i,j] + L4B1aft83bias;
RADS2MSS2[i,j] = L4B2aft83gain * MSS2BAND2[i,j] + L4B2aft83bias;
RADS2MSS3[i,j] = L4B3aft83gain * MSS2BAND3[i,j] + L4B3aft83bias;
RADS2MSS4[i,j] = L4B4aft83gain * MSS2BAND4[i,j] + L4B4aft83bias;
}
}
}
CloseRaster(MSS2BAND1);
CloseRaster(MSS2BAND2);
CloseRaster(MSS2BAND3);
CloseRaster(MSS2BAND4);
printf("Radiance calculation for Scene 2 (MSS) is done...\n");
}
else if ( sensors2 == 3 ) # MSS 3
{
raster RADS2MSS1, RADS2MSS2, RADS2MSS3, RADS2MSS4;
CreateTempRaster(RADS2MSS1, MSSlins, MSScols,"32-bit float");
CreateTempRaster(RADS2MSS2, MSSlins, MSScols,"32-bit float");
CreateTempRaster(RADS2MSS3, MSSlins, MSScols,"32-bit float");
CreateTempRaster(RADS2MSS4, MSSlins, MSScols,"32-bit float");
for i = 1 to MSSlins
{
for j = 1 to MSScols
{
if ( s2aq <= 19780601 ) # Before 1 Juni 1978
{
RADS2MSS1[i,j] = L3B1bef78gain * MSS2BAND1[i,j] + L3B1bef78bias;
RADS2MSS2[i,j] = L3B2bef78gain * MSS2BAND2[i,j] + L3B2bef78bias;
RADS2MSS3[i,j] = L3B3bef78gain * MSS2BAND3[i,j] + L3B3bef78bias;
RADS2MSS4[i,j] = L3B4bef78gain * MSS2BAND4[i,j] + L3B4bef78bias;
}
else if ( s2aq >= 19780602 and s2aq <= 19790201 ) # 2 Juni 1978 bis 1 Februar 1979
{
RADS2MSS1[i,j] = L3B17879gain * MSS2BAND1[i,j] + L3B17879bias;
RADS2MSS2[i,j] = L3B27879gain * MSS2BAND2[i,j] + L3B27879bias;
RADS2MSS3[i,j] = L3B37879gain * MSS2BAND3[i,j] + L3B37879bias;
RADS2MSS4[i,j] = L3B47879gain * MSS2BAND4[i,j] + L3B47879bias;
}
else if ( s2aq > 19790201 ) # After 1 Februar 1979
{
RADS2MSS1[i,j] = L3B1aft79gain * MSS2BAND1[i,j] + L3B1aft79bias;
RADS2MSS2[i,j] = L3B2aft79gain * MSS2BAND2[i,j] + L3B2aft79bias;
RADS2MSS3[i,j] = L3B3aft79gain * MSS2BAND3[i,j] + L3B3aft79bias;
RADS2MSS4[i,j] = L3B4aft79gain * MSS2BAND4[i,j] + L3B4aft79bias;
}
}
}
CloseRaster(MSS2BAND1);
CloseRaster(MSS2BAND2);
CloseRaster(MSS2BAND3);
CloseRaster(MSS2BAND4);
printf("Radiance calculation for Scene 2 (MSS) is done...\n");
}
else if ( sensors2 == 2 ) # MSS 2
{
raster RADS2MSS1, RADS2MSS2, RADS2MSS3, RADS2MSS4;
CreateTempRaster(RADS2MSS1, MSSlins, MSScols,"32-bit float");
CreateTempRaster(RADS2MSS2, MSSlins, MSScols,"32-bit float");
CreateTempRaster(RADS2MSS3, MSSlins, MSScols,"32-bit float");
CreateTempRaster(RADS2MSS4, MSSlins, MSScols,"32-bit float");
for i = 1 to MSSlins
{
for j = 1 to MSScols
{
if ( s2aq <= 19750716 ) # Before 16 Juli 1975
{
RADS2MSS1[i,j] = L2B1bef75gain * MSS2BAND1[i,j] + L2B1bef75bias;
RADS2MSS2[i,j] = L2B2bef75gain * MSS2BAND2[i,j] + L2B2bef75bias;
RADS2MSS3[i,j] = L2B3bef75gain * MSS2BAND3[i,j] + L2B3bef75bias;
RADS2MSS4[i,j] = L2B4bef75gain * MSS2BAND4[i,j] + L2B4bef75bias;
}
else if ( s2aq > 19750716 and s2aq <= 19790201 )
{
RADS2MSS1[i,j] = L2B1aft75gain * MSS2BAND1[i,j] + L2B1aft75bias; # After 16. Juli 1975
RADS2MSS2[i,j] = L2B2aft75gain * MSS2BAND2[i,j] + L2B2aft75bias;
RADS2MSS3[i,j] = L2B3aft75gain * MSS2BAND3[i,j] + L2B3aft75bias;
RADS2MSS4[i,j] = L2B4aft75gain * MSS2BAND4[i,j] + L2B4aft75bias;
}
else if ( s2aq > 19790201 )
{
RADS2MSS1[i,j] = L2B1aft79gain * MSS2BAND1[i,j] + L2B1aft79bias; # After 1. Februar 1979
RADS2MSS2[i,j] = L2B2aft79gain * MSS2BAND2[i,j] + L2B2aft79bias;
RADS2MSS3[i,j] = L2B3aft79gain * MSS2BAND3[i,j] + L2B3aft79bias;
RADS2MSS4[i,j] = L2B4aft79gain * MSS2BAND4[i,j] + L2B4aft79bias;
}
}
}
CloseRaster(MSS2BAND1);
CloseRaster(MSS2BAND2);
CloseRaster(MSS2BAND3);
CloseRaster(MSS2BAND4);
printf("Radiance calculation for Scene 2 (MSS) is done...\n");
}
else if ( sensors2 == 1 ) # MSS 1
{
raster RADS2MSS1, RADS2MSS2, RADS2MSS3, RADS2MSS4;
CreateTempRaster(RADS2MSS1, MSSlins, MSScols,"32-bit float");
CreateTempRaster(RADS2MSS2, MSSlins, MSScols,"32-bit float");
CreateTempRaster(RADS2MSS3, MSSlins, MSScols,"32-bit float");
CreateTempRaster(RADS2MSS4, MSSlins, MSScols,"32-bit float");
for i = 1 to MSSlins
{
for j = 1 to MSScols
{
RADS2MSS1[i,j] = L1B1gain * MSS2BAND1[i,j] + L1B1bias;
RADS2MSS2[i,j] = L1B2gain * MSS2BAND2[i,j] + L1B1bias;
RADS2MSS3[i,j] = L1B3gain * MSS2BAND3[i,j] + L1B1bias;
RADS2MSS4[i,j] = L1B4gain * MSS2BAND4[i,j] + L1B1bias;
}
}
CloseRaster(MSS2BAND1);
CloseRaster(MSS2BAND2);
CloseRaster(MSS2BAND3);
CloseRaster(MSS2BAND4);
printf("Radiance calculation for Scene 2 (MSS) is done...\n");
}
###########################
### Radiance Scene 3
###########################
if ( sensors3 == 7 )
{
raster RADS3ETM1, RADS3ETM2, RADS3ETM3, RADS3ETM4, RADS3ETM5, RADS3ETM7;
CreateTempRaster(RADS3ETM1, ETMlins, ETMcols,"32-bit float");
CreateTempRaster(RADS3ETM2, ETMlins, ETMcols,"32-bit float");
CreateTempRaster(RADS3ETM3, ETMlins, ETMcols,"32-bit float");
CreateTempRaster(RADS3ETM4, ETMlins, ETMcols,"32-bit float");
CreateTempRaster(RADS3ETM5, ETMlins, ETMcols,"32-bit float");
CreateTempRaster(RADS3ETM7, ETMlins, ETMcols,"32-bit float");
for i = 1 to ETMlins
{
for j = 1 to ETMcols
{
if ( s3aq < 20000701) # Before 1. July 2000
{
if ( earSurCat3 == 8 ) # Desert(hs)
{
RADS3ETM1[i,j] = (B1LGLMAXBef2000-B1LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM3BAND1[i,j]-QCALMIN)+B1LGLMINBef2000;
RADS3ETM2[i,j] = (B2LGLMAXBef2000-B2LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM3BAND2[i,j]-QCALMIN)+B2LGLMINBef2000;
RADS3ETM3[i,j] = (B3LGLMAXBef2000-B3LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM3BAND3[i,j]-QCALMIN)+B3LGLMINBef2000;
RADS3ETM4[i,j] = (B4LGLMAXBef2000-B4LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM3BAND4[i,j]-QCALMIN)+B4LGLMINBef2000;
RADS3ETM5[i,j] = (B5LGLMAXBef2000-B5LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM3BAND5[i,j]-QCALMIN)+B5LGLMINBef2000;
RADS3ETM7[i,j] = (B7LGLMAXBef2000-B7LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM3BAND7[i,j]-QCALMIN)+B7LGLMINBef2000;
}
else if ( earSurCat3 == 7 ) # Desert(ms)
{
RADS3ETM1[i,j] = (B1LGLMAXBef2000-B1LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM3BAND1[i,j]-QCALMIN)+B1LGLMINBef2000;
RADS3ETM2[i,j] = (B2LGLMAXBef2000-B2LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM3BAND2[i,j]-QCALMIN)+B2LGLMINBef2000;
RADS3ETM3[i,j] = (B3LGLMAXBef2000-B3LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM3BAND3[i,j]-QCALMIN)+B3LGLMINBef2000;
RADS3ETM4[i,j] = (B4HGLMAXBef2000-B4HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM3BAND4[i,j]-QCALMIN)+B4HGLMINBef2000;
RADS3ETM5[i,j] = (B5LGLMAXBef2000-B5LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM3BAND5[i,j]-QCALMIN)+B5LGLMINBef2000;
RADS3ETM7[i,j] = (B7LGLMAXBef2000-B7LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM3BAND7[i,j]-QCALMIN)+B7LGLMINBef2000;
}
else if ( earSurCat3 == 6 ) # Desert Ice(ls)
{
RADS3ETM1[i,j] = (B1LGLMAXBef2000-B1LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM3BAND1[i,j]-QCALMIN)+B1LGLMINBef2000;
RADS3ETM2[i,j] = (B2LGLMAXBef2000-B2LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM3BAND2[i,j]-QCALMIN)+B2LGLMINBef2000;
RADS3ETM3[i,j] = (B3LGLMAXBef2000-B3LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM3BAND3[i,j]-QCALMIN)+B3LGLMINBef2000;
RADS3ETM4[i,j] = (B4HGLMAXBef2000-B4HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM3BAND4[i,j]-QCALMIN)+B4HGLMINBef2000;
RADS3ETM5[i,j] = (B5HGLMAXBef2000-B5HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM3BAND5[i,j]-QCALMIN)+B5HGLMINBef2000;
RADS3ETM7[i,j] = (B7HGLMAXBef2000-B7HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM3BAND7[i,j]-QCALMIN)+B7HGLMINBef2000;
}
else if ( earSurCat3 == 5 ) # Ice(hs)
{
RADS3ETM1[i,j] = (B1LGLMAXBef2000-B1LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM3BAND1[i,j]-QCALMIN)+B1LGLMINBef2000;
RADS3ETM2[i,j] = (B2LGLMAXBef2000-B2LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM3BAND2[i,j]-QCALMIN)+B2LGLMINBef2000;
RADS3ETM3[i,j] = (B3LGLMAXBef2000-B3LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM3BAND3[i,j]-QCALMIN)+B3LGLMINBef2000;
RADS3ETM4[i,j] = (B4LGLMAXBef2000-B4LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM3BAND4[i,j]-QCALMIN)+B4LGLMINBef2000;
RADS3ETM5[i,j] = (B5HGLMAXBef2000-B5HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM3BAND5[i,j]-QCALMIN)+B5HGLMINBef2000;
RADS3ETM7[i,j] = (B7HGLMAXBef2000-B7HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM3BAND7[i,j]-QCALMIN)+B7HGLMINBef2000;
}
else if ( earSurCat3 == 4 ) # Land(hs)
{
RADS3ETM1[i,j] = (B1HGLMAXBef2000-B1HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM3BAND1[i,j]-QCALMIN)+B1HGLMINBef2000;
RADS3ETM2[i,j] = (B2HGLMAXBef2000-B2HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM3BAND2[i,j]-QCALMIN)+B2HGLMINBef2000;
RADS3ETM3[i,j] = (B3HGLMAXBef2000-B3HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM3BAND3[i,j]-QCALMIN)+B3HGLMINBef2000;
RADS3ETM4[i,j] = (B4LGLMAXBef2000-B4LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM3BAND4[i,j]-QCALMIN)+B4LGLMINBef2000;
RADS3ETM5[i,j] = (B5HGLMAXBef2000-B5HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM3BAND5[i,j]-QCALMIN)+B5HGLMINBef2000;
RADS3ETM7[i,j] = (B7HGLMAXBef2000-B7HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM3BAND7[i,j]-QCALMIN)+B7HGLMINBef2000;
}
else if ( earSurCat3 == 3 ) # Land Ocean(ls
{
RADS3ETM1[i,j] = (B1HGLMAXBef2000-B1HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM3BAND1[i,j]-QCALMIN)+B1HGLMINBef2000;
RADS3ETM2[i,j] = (B2HGLMAXBef2000-B2HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM3BAND2[i,j]-QCALMIN)+B2HGLMINBef2000;
RADS3ETM3[i,j] = (B3HGLMAXBef2000-B3HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM3BAND3[i,j]-QCALMIN)+B3HGLMINBef2000;
RADS3ETM4[i,j] = (B4HGLMAXBef2000-B4HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM3BAND4[i,j]-QCALMIN)+B4HGLMINBef2000;
RADS3ETM5[i,j] = (B5HGLMAXBef2000-B5HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM3BAND5[i,j]-QCALMIN)+B5HGLMINBef2000;
RADS3ETM7[i,j] = (B7HGLMAXBef2000-B7HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM3BAND7[i,j]-QCALMIN)+B7HGLMINBef2000;
}
else if ( earSurCat3 == 2 ) # Water
{
RADS3ETM1[i,j] = (B1HGLMAXBef2000-B1HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM3BAND1[i,j]-QCALMIN)+B1HGLMINBef2000;
RADS3ETM2[i,j] = (B2HGLMAXBef2000-B2HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM3BAND2[i,j]-QCALMIN)+B2HGLMINBef2000;
RADS3ETM3[i,j] = (B3HGLMAXBef2000-B3HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM3BAND3[i,j]-QCALMIN)+B3HGLMINBef2000;
RADS3ETM4[i,j] = (B4HGLMAXBef2000-B4HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM3BAND4[i,j]-QCALMIN)+B4HGLMINBef2000;
RADS3ETM5[i,j] = (B5HGLMAXBef2000-B5HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM3BAND5[i,j]-QCALMIN)+B5HGLMINBef2000;
RADS3ETM7[i,j] = (B7HGLMAXBef2000-B7HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM3BAND7[i,j]-QCALMIN)+B7HGLMINBef2000;
}
else if ( earSurCat3 == 1 ) # Night(volcanos
{
RADS3ETM1[i,j] = (B1HGLMAXBef2000-B1HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM3BAND1[i,j]-QCALMIN)+B1HGLMINBef2000;
RADS3ETM2[i,j] = (B2HGLMAXBef2000-B2HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM3BAND2[i,j]-QCALMIN)+B2HGLMINBef2000;
RADS3ETM3[i,j] = (B3HGLMAXBef2000-B3HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM3BAND3[i,j]-QCALMIN)+B3HGLMINBef2000;
RADS3ETM4[i,j] = (B4HGLMAXBef2000-B4HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM3BAND4[i,j]-QCALMIN)+B4HGLMINBef2000;
RADS3ETM5[i,j] = (B5LGLMAXBef2000-B5LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM3BAND5[i,j]-QCALMIN)+B5LGLMINBef2000;
RADS3ETM7[i,j] = (B7LGLMAXBef2000-B7LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM3BAND7[i,j]-QCALMIN)+B7LGLMINBef2000;
}
}
else # After 1. July 2000
{
if ( earSurCat3 == 8 ) # Desert(hs)
{
RADS3ETM1[i,j] = (B1LGLMAXAFT2000-B1LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM3BAND1[i,j]-QCALMIN)+B1LGLMINAFT2000;
RADS3ETM2[i,j] = (B2LGLMAXAFT2000-B2LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM3BAND2[i,j]-QCALMIN)+B2LGLMINAFT2000;
RADS3ETM3[i,j] = (B3LGLMAXAFT2000-B3LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM3BAND3[i,j]-QCALMIN)+B3LGLMINAFT2000;
RADS3ETM4[i,j] = (B4LGLMAXAFT2000-B4LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM3BAND4[i,j]-QCALMIN)+B4LGLMINAFT2000;
RADS3ETM5[i,j] = (B5LGLMAXAFT2000-B5LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM3BAND5[i,j]-QCALMIN)+B5LGLMINAFT2000;
RADS3ETM7[i,j] = (B7LGLMAXAFT2000-B7LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM3BAND7[i,j]-QCALMIN)+B7LGLMINAFT2000;
}
else if ( earSurCat3 == 7 ) # Desert(ms)
{
RADS3ETM1[i,j] = (B1LGLMAXAFT2000-B1LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM3BAND1[i,j]-QCALMIN)+B1LGLMINAFT2000;
RADS3ETM2[i,j] = (B2LGLMAXAFT2000-B2LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM3BAND2[i,j]-QCALMIN)+B2LGLMINAFT2000;
RADS3ETM3[i,j] = (B3LGLMAXAFT2000-B3LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM3BAND3[i,j]-QCALMIN)+B3LGLMINAFT2000;
RADS3ETM4[i,j] = (B4HGLMAXAFT2000-B4HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM3BAND4[i,j]-QCALMIN)+B4HGLMINAFT2000;
RADS3ETM5[i,j] = (B5LGLMAXAFT2000-B5LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM3BAND5[i,j]-QCALMIN)+B5LGLMINAFT2000;
RADS3ETM7[i,j] = (B7LGLMAXAFT2000-B7LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM3BAND7[i,j]-QCALMIN)+B7LGLMINAFT2000;
}
else if ( earSurCat3 == 6 ) # Desert Ice(ls)
{
RADS3ETM1[i,j] = (B1LGLMAXAFT2000-B1LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM3BAND1[i,j]-QCALMIN)+B1LGLMINAFT2000;
RADS3ETM2[i,j] = (B2LGLMAXAFT2000-B2LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM3BAND2[i,j]-QCALMIN)+B2LGLMINAFT2000;
RADS3ETM3[i,j] = (B3LGLMAXAFT2000-B3LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM3BAND3[i,j]-QCALMIN)+B3LGLMINAFT2000;
RADS3ETM4[i,j] = (B4HGLMAXAFT2000-B4HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM3BAND4[i,j]-QCALMIN)+B4HGLMINAFT2000;
RADS3ETM5[i,j] = (B5HGLMAXAFT2000-B5HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM3BAND5[i,j]-QCALMIN)+B5HGLMINAFT2000;
RADS3ETM7[i,j] = (B7HGLMAXAFT2000-B7HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM3BAND7[i,j]-QCALMIN)+B7HGLMINAFT2000;
}
else if ( earSurCat3 == 5 ) # Ice(hs)
{
RADS3ETM1[i,j] = (B1LGLMAXAFT2000-B1LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM3BAND1[i,j]-QCALMIN)+B1LGLMINAFT2000;
RADS3ETM2[i,j] = (B2LGLMAXAFT2000-B2LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM3BAND2[i,j]-QCALMIN)+B2LGLMINAFT2000;
RADS3ETM3[i,j] = (B3LGLMAXAFT2000-B3LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM3BAND3[i,j]-QCALMIN)+B3LGLMINAFT2000;
RADS3ETM4[i,j] = (B4LGLMAXAFT2000-B4LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM3BAND4[i,j]-QCALMIN)+B4LGLMINAFT2000;
RADS3ETM5[i,j] = (B5HGLMAXAFT2000-B5HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM3BAND5[i,j]-QCALMIN)+B5HGLMINAFT2000;
RADS3ETM7[i,j] = (B7HGLMAXAFT2000-B7HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM3BAND7[i,j]-QCALMIN)+B7HGLMINAFT2000;
}
else if ( earSurCat3 == 4 ) # Land(hs)
{
RADS3ETM1[i,j] = (B1HGLMAXAFT2000-B1HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM3BAND1[i,j]-QCALMIN)+B1HGLMINAFT2000;
RADS3ETM2[i,j] = (B2HGLMAXAFT2000-B2HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM3BAND2[i,j]-QCALMIN)+B2HGLMINAFT2000;
RADS3ETM3[i,j] = (B3HGLMAXAFT2000-B3HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM3BAND3[i,j]-QCALMIN)+B3HGLMINAFT2000;
RADS3ETM4[i,j] = (B4LGLMAXAFT2000-B4LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM3BAND4[i,j]-QCALMIN)+B4LGLMINAFT2000;
RADS3ETM5[i,j] = (B5HGLMAXAFT2000-B5HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM3BAND5[i,j]-QCALMIN)+B5HGLMINAFT2000;
RADS3ETM7[i,j] = (B7HGLMAXAFT2000-B7HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM3BAND7[i,j]-QCALMIN)+B7HGLMINAFT2000;
}
else if ( earSurCat3 == 3 ) # Land Ocean(ls
{
RADS3ETM1[i,j] = (B1HGLMAXAFT2000-B1HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM3BAND1[i,j]-QCALMIN)+B1HGLMINAFT2000;
RADS3ETM2[i,j] = (B2HGLMAXAFT2000-B2HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM3BAND2[i,j]-QCALMIN)+B2HGLMINAFT2000;
RADS3ETM3[i,j] = (B3HGLMAXAFT2000-B3HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM3BAND3[i,j]-QCALMIN)+B3HGLMINAFT2000;
RADS3ETM4[i,j] = (B4HGLMAXAFT2000-B4HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM3BAND4[i,j]-QCALMIN)+B4HGLMINAFT2000;
RADS3ETM5[i,j] = (B5HGLMAXAFT2000-B5HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM3BAND5[i,j]-QCALMIN)+B5HGLMINAFT2000;
RADS3ETM7[i,j] = (B7HGLMAXAFT2000-B7HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM3BAND7[i,j]-QCALMIN)+B7HGLMINAFT2000;
}
else if ( earSurCat3 == 2 ) # Water
{
RADS3ETM1[i,j] = (B1HGLMAXAFT2000-B1HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM3BAND1[i,j]-QCALMIN)+B1HGLMINAFT2000;
RADS3ETM2[i,j] = (B2HGLMAXAFT2000-B2HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM3BAND2[i,j]-QCALMIN)+B2HGLMINAFT2000;
RADS3ETM3[i,j] = (B3HGLMAXAFT2000-B3HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM3BAND3[i,j]-QCALMIN)+B3HGLMINAFT2000;
RADS3ETM4[i,j] = (B4HGLMAXAFT2000-B4HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM3BAND4[i,j]-QCALMIN)+B4HGLMINAFT2000;
RADS3ETM5[i,j] = (B5HGLMAXAFT2000-B5HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM3BAND5[i,j]-QCALMIN)+B5HGLMINAFT2000;
RADS3ETM7[i,j] = (B7HGLMAXAFT2000-B7HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM3BAND7[i,j]-QCALMIN)+B7HGLMINAFT2000;
}
else if ( earSurCat3 == 1 ) # Night(volcanos
{
RADS3ETM1[i,j] = (B1HGLMAXAFT2000-B1HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM3BAND1[i,j]-QCALMIN)+B1HGLMINAFT2000;
RADS3ETM2[i,j] = (B2HGLMAXAFT2000-B2HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM3BAND2[i,j]-QCALMIN)+B2HGLMINAFT2000;
RADS3ETM3[i,j] = (B3HGLMAXAFT2000-B3HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM3BAND3[i,j]-QCALMIN)+B3HGLMINAFT2000;
RADS3ETM4[i,j] = (B4HGLMAXAFT2000-B4HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM3BAND4[i,j]-QCALMIN)+B4HGLMINAFT2000;
RADS3ETM5[i,j] = (B5LGLMAXAFT2000-B5LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM3BAND5[i,j]-QCALMIN)+B5LGLMINAFT2000;
RADS3ETM7[i,j] = (B7LGLMAXAFT2000-B7LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM3BAND7[i,j]-QCALMIN)+B7LGLMINAFT2000;
}
}
}
}
CloseRaster(ETM3BAND1);
CloseRaster(ETM3BAND2);
CloseRaster(ETM3BAND3);
CloseRaster(ETM3BAND4);
CloseRaster(ETM3BAND5);
CloseRaster(ETM3BAND7);
printf("Radiance calculation for Scene 3 (ETM) is done...\n");
}
else if ( sensors3 == 6 )
{
raster RADS3TM1, RADS3TM2, RADS3TM3, RADS3TM4, RADS3TM5, RADS3TM7;
CreateTempRaster(RADS3TM1, TMlins, TMcols,"32-bit float");
CreateTempRaster(RADS3TM2, TMlins, TMcols,"32-bit float");
CreateTempRaster(RADS3TM3, TMlins, TMcols,"32-bit float");
CreateTempRaster(RADS3TM4, TMlins, TMcols,"32-bit float");
CreateTempRaster(RADS3TM5, TMlins, TMcols,"32-bit float");
CreateTempRaster(RADS3TM7, TMlins, TMcols,"32-bit float");
for i = 1 to TMlins
{
for j = 1 to TMcols
{
if (s3leap == 0)
{
numeric gainnewTMS3b1, gainnewTMS3b2, gainnewTMS3b3, gainnewTMS3b4, gainnewTMS3b5, gainnewTMS3b7;
gainnewTMS3b1 = ((0.145658 * exp(-0.955113 * ((s3year + (s3jul / 365)) - 1984.2082))) + 1.243000);
gainnewTMS3b2 = ((0.058651 * exp(-0.835952 * ((s3year + (s3jul / 365)) - 1984.2082))) + 0.656100);
gainnewTMS3b3 = ((0.111858 * exp(-1.002090 * ((s3year + (s3jul / 365)) - 1984.2082))) + 0.905000);
gainnewTMS3b4 = ((0.107650 * exp(-1.277190 * ((s3year + (s3jul / 365)) - 1984.2082))) + 1.082000);
gainnewTMS3b5 = ((0.243364 * exp(-1.207080 * ((s3year + (s3jul / 365)) - 1984.2082))) + 7.944000);
gainnewTMS3b7 = ((0.403551 * exp(-0.999127 * ((s3year + (s3jul / 365)) - 1984.2082))) + 14.52000);
RADS3TM1[i,j] = ((s3TMg1 * ((gainnewTMS3b1 * ((s3TMg1 * TM3BAND1[i,j]) + s3TMb1)) + biasnewTMb1)) + s3TMb1);
RADS3TM2[i,j] = ((s3TMg2 * ((gainnewTMS3b2 * ((s3TMg2 * TM3BAND2[i,j]) + s3TMb2)) + biasnewTMb2)) + s3TMb2);
RADS3TM3[i,j] = ((s3TMg3 * ((gainnewTMS3b3 * ((s3TMg3 * TM3BAND3[i,j]) + s3TMb3)) + biasnewTMb3)) + s3TMb3);
RADS3TM4[i,j] = ((s3TMg4 * ((gainnewTMS3b4 * ((s3TMg4 * TM3BAND4[i,j]) + s3TMb4)) + biasnewTMb4)) + s3TMb4);
RADS3TM5[i,j] = ((s3TMg5 * ((gainnewTMS3b5 * ((s3TMg5 * TM3BAND5[i,j]) + s3TMb5)) + biasnewTMb5)) + s3TMb5);
RADS3TM7[i,j] = ((s3TMg7 * ((gainnewTMS3b7 * ((s3TMg7 * TM3BAND7[i,j]) + s3TMb7)) + biasnewTMb7)) + s3TMb7);
}
else if (s3leap == 1)
{
numeric gainnewTMS3b1, gainnewTMS3b2, gainnewTMS3b3, gainnewTMS3b4, gainnewTMS3b5, gainnewTMS3b7;
gainnewTMS3b1 = ((0.145658 * exp(-0.955113 * ((s3year + (s3jul / 366)) - 1984.2082))) + 1.243000);
gainnewTMS3b2 = ((0.058651 * exp(-0.835952 * ((s3year + (s3jul / 366)) - 1984.2082))) + 0.656100);
gainnewTMS3b3 = ((0.111858 * exp(-1.002090 * ((s3year + (s3jul / 366)) - 1984.2082))) + 0.905000);
gainnewTMS3b4 = ((0.107650 * exp(-1.277190 * ((s3year + (s3jul / 366)) - 1984.2082))) + 1.082000);
gainnewTMS3b5 = ((0.243364 * exp(-1.207080 * ((s3year + (s3jul / 366)) - 1984.2082))) + 7.944000);
gainnewTMS3b7 = ((0.403551 * exp(-0.999127 * ((s3year + (s3jul / 366)) - 1984.2082))) + 14.52000);
RADS3TM1[i,j] = ((s3TMg1 * ((gainnewTMS3b1 * ((s3TMg1 * TM3BAND1[i,j]) + s3TMb1)) + biasnewTMb1)) + s3TMb1);
RADS3TM2[i,j] = ((s3TMg2 * ((gainnewTMS3b2 * ((s3TMg2 * TM3BAND2[i,j]) + s3TMb2)) + biasnewTMb2)) + s3TMb2);
RADS3TM3[i,j] = ((s3TMg3 * ((gainnewTMS3b3 * ((s3TMg3 * TM3BAND3[i,j]) + s3TMb3)) + biasnewTMb3)) + s3TMb3);
RADS3TM4[i,j] = ((s3TMg4 * ((gainnewTMS3b4 * ((s3TMg4 * TM3BAND4[i,j]) + s3TMb4)) + biasnewTMb4)) + s3TMb4);
RADS3TM5[i,j] = ((s3TMg5 * ((gainnewTMS3b5 * ((s3TMg5 * TM3BAND5[i,j]) + s3TMb5)) + biasnewTMb5)) + s3TMb5);
RADS3TM7[i,j] = ((s3TMg7 * ((gainnewTMS3b7 * ((s3TMg7 * TM3BAND7[i,j]) + s3TMb7)) + biasnewTMb7)) + s3TMb7);
}
}
}
CloseRaster(TM3BAND1);
CloseRaster(TM3BAND2);
CloseRaster(TM3BAND3);
CloseRaster(TM3BAND4);
CloseRaster(TM3BAND5);
CloseRaster(TM3BAND7);
printf("Radiance calculation for Scene 3 (TM) is done...\n");
}
else if ( sensors3 == 5 ) # MSS 5 - Calib Werte nach Price J.C.1987
{
raster RADS3MSS1, RADS3MSS2, RADS3MSS3, RADS3MSS4;
CreateTempRaster(RADS3MSS1, MSSlins, MSScols,"32-bit float");
CreateTempRaster(RADS3MSS2, MSSlins, MSScols,"32-bit float");
CreateTempRaster(RADS3MSS3, MSSlins, MSScols,"32-bit float");
CreateTempRaster(RADS3MSS4, MSSlins, MSScols,"32-bit float");
for i = 1 to MSSlins
{
for j = 1 to MSScols
{
if ( s3aq <= 19841109) # Before 9 November 1984
{
RADS3MSS1[i,j] = L5B1bef84gain * MSS3BAND1[i,j] + L5B1bef84bias;
RADS3MSS2[i,j] = L5B2bef84gain * MSS3BAND2[i,j] + L5B2bef84bias;
RADS3MSS3[i,j] = L5B3bef84gain * MSS3BAND3[i,j] + L5B3bef84bias;
RADS3MSS4[i,j] = L5B4bef84gain * MSS3BAND4[i,j] + L5B4bef84bias;
}
else # after 9 November 1984
{
RADS3MSS1[i,j] = L5B1aft84gain * MSS3BAND1[i,j] + L5B1aft84bias;
RADS3MSS2[i,j] = L5B2aft84gain * MSS3BAND2[i,j] + L5B2aft84bias;
RADS3MSS3[i,j] = L5B3aft84gain * MSS3BAND3[i,j] + L5B3aft84bias;
RADS3MSS4[i,j] = L5B4aft84gain * MSS3BAND4[i,j] + L5B4aft84bias;
}
}
}
CloseRaster(MSS3BAND1);
CloseRaster(MSS3BAND2);
CloseRaster(MSS3BAND3);
CloseRaster(MSS3BAND4);
printf("Radiance calculation for Scene 3 (MSS) is done...\n");
}
else if ( sensors3 == 4 ) # MSS 4
{
raster RADS3MSS1, RADS3MSS2, RADS3MSS3, RADS3MSS4;
CreateTempRaster(RADS3MSS1, MSSlins, MSScols,"32-bit float");
CreateTempRaster(RADS3MSS2, MSSlins, MSScols,"32-bit float");
CreateTempRaster(RADS3MSS3, MSSlins, MSScols,"32-bit float");
CreateTempRaster(RADS3MSS4, MSSlins, MSScols,"32-bit float");
for i = 1 to MSSlins
{
for j = 1 to MSScols
{
if ( s3aq <= 19830401) # Before 1 April 1983
{
RADS3MSS1[i,j] = L4B1bef83gain * MSS3BAND1[i,j] + L4B1bef83bias;
RADS3MSS2[i,j] = L4B2bef83gain * MSS3BAND2[i,j] + L4B2bef83bias;
RADS3MSS3[i,j] = L4B3bef83gain * MSS3BAND3[i,j] + L4B3bef83gain;
RADS3MSS4[i,j] = L4B4bef83gain * MSS3BAND4[i,j] + L4B4bef83bias;
}
else # After 1 April 1983
{
RADS3MSS1[i,j] = L4B1aft83gain * MSS3BAND1[i,j] + L4B1aft83bias;
RADS3MSS2[i,j] = L4B2aft83gain * MSS3BAND2[i,j] + L4B2aft83bias;
RADS3MSS3[i,j] = L4B3aft83gain * MSS3BAND3[i,j] + L4B3aft83bias;
RADS3MSS4[i,j] = L4B4aft83gain * MSS3BAND4[i,j] + L4B4aft83bias;
}
}
}
CloseRaster(MSS3BAND1);
CloseRaster(MSS3BAND2);
CloseRaster(MSS3BAND3);
CloseRaster(MSS3BAND4);
printf("Radiance calculation for Scene 3 (MSS) is done...\n");
}
else if ( sensors3 == 3 ) # MSS 3
{
raster RADS3MSS1, RADS3MSS2, RADS3MSS3, RADS3MSS4;
CreateTempRaster(RADS3MSS1, MSSlins, MSScols,"32-bit float");
CreateTempRaster(RADS3MSS2, MSSlins, MSScols,"32-bit float");
CreateTempRaster(RADS3MSS3, MSSlins, MSScols,"32-bit float");
CreateTempRaster(RADS3MSS4, MSSlins, MSScols,"32-bit float");
for i = 1 to MSSlins
{
for j = 1 to MSScols
{
if ( s3aq <= 19780601 ) # Before 1 Juni 1978
{
RADS3MSS1[i,j] = L3B1bef78gain * MSS3BAND1[i,j] + L3B1bef78bias;
RADS3MSS2[i,j] = L3B2bef78gain * MSS3BAND2[i,j] + L3B2bef78bias;
RADS3MSS3[i,j] = L3B3bef78gain * MSS3BAND3[i,j] + L3B3bef78bias;
RADS3MSS4[i,j] = L3B4bef78gain * MSS3BAND4[i,j] + L3B4bef78bias;
}
else if ( s3aq >= 19780602 and s3aq <= 19790201 ) # 2 Juni 1978 bis 1 Februar 1979
{
RADS3MSS1[i,j] = L3B17879gain * MSS3BAND1[i,j] + L3B17879bias;
RADS3MSS2[i,j] = L3B27879gain * MSS3BAND2[i,j] + L3B27879bias;
RADS3MSS3[i,j] = L3B37879gain * MSS3BAND3[i,j] + L3B37879bias;
RADS3MSS4[i,j] = L3B47879gain * MSS3BAND4[i,j] + L3B47879bias;
}
else if ( s3aq > 19790201 ) # After 1 Februar 1979
{
RADS3MSS1[i,j] = L3B1aft79gain * MSS3BAND1[i,j] + L3B1aft79bias;
RADS3MSS2[i,j] = L3B2aft79gain * MSS3BAND2[i,j] + L3B2aft79bias;
RADS3MSS3[i,j] = L3B3aft79gain * MSS3BAND3[i,j] + L3B3aft79bias;
RADS3MSS4[i,j] = L3B4aft79gain * MSS3BAND4[i,j] + L3B4aft79bias;
}
}
}
CloseRaster(MSS3BAND1);
CloseRaster(MSS3BAND2);
CloseRaster(MSS3BAND3);
CloseRaster(MSS3BAND4);
printf("Radiance calculation for Scene 3 (MSS) is done...\n");
}
else if ( sensors3 == 2 ) # MSS 2
{
raster RADS3MSS1, RADS3MSS2, RADS3MSS3, RADS3MSS4;
CreateTempRaster(RADS3MSS1, MSSlins, MSScols,"32-bit float");
CreateTempRaster(RADS3MSS2, MSSlins, MSScols,"32-bit float");
CreateTempRaster(RADS3MSS3, MSSlins, MSScols,"32-bit float");
CreateTempRaster(RADS3MSS4, MSSlins, MSScols,"32-bit float");
for i = 1 to MSSlins
{
for j = 1 to MSScols
{
if ( s3aq <= 19750716 ) # Before 16 Juli 1975
{
RADS3MSS1[i,j] = L2B1bef75gain * MSS3BAND1[i,j] + L2B1bef75bias;
RADS3MSS2[i,j] = L2B2bef75gain * MSS3BAND2[i,j] + L2B2bef75bias;
RADS3MSS3[i,j] = L2B3bef75gain * MSS3BAND3[i,j] + L2B3bef75bias;
RADS3MSS4[i,j] = L2B4bef75gain * MSS3BAND4[i,j] + L2B4bef75bias;
}
else if ( s3aq > 19750716 and s3aq <= 19790201 )
{
RADS3MSS1[i,j] = L2B1aft75gain * MSS3BAND1[i,j] + L2B1aft75bias; # After 16. Juli 1975
RADS3MSS2[i,j] = L2B2aft75gain * MSS3BAND2[i,j] + L2B2aft75bias;
RADS3MSS3[i,j] = L2B3aft75gain * MSS3BAND3[i,j] + L2B3aft75bias;
RADS3MSS4[i,j] = L2B4aft75gain * MSS3BAND4[i,j] + L2B4aft75bias;
}
else if ( s3aq > 19790201 )
{
RADS3MSS1[i,j] = L2B1aft79gain * MSS3BAND1[i,j] + L2B1aft79bias; # After 1. Februar 1979
RADS3MSS2[i,j] = L2B2aft79gain * MSS3BAND2[i,j] + L2B2aft79bias;
RADS3MSS3[i,j] = L2B3aft79gain * MSS3BAND3[i,j] + L2B3aft79bias;
RADS3MSS4[i,j] = L2B4aft79gain * MSS3BAND4[i,j] + L2B4aft79bias;
}
}
}
CloseRaster(MSS3BAND1);
CloseRaster(MSS3BAND2);
CloseRaster(MSS3BAND3);
CloseRaster(MSS3BAND4);
printf("Radiance calculation for Scene 3 (MSS) is done...\n");
}
else if ( sensors3 == 1 ) # MSS 1
{
raster RADS3MSS1, RADS3MSS2, RADS3MSS3, RADS3MSS4;
CreateTempRaster(RADS3MSS1, MSSlins, MSScols,"32-bit float");
CreateTempRaster(RADS3MSS2, MSSlins, MSScols,"32-bit float");
CreateTempRaster(RADS3MSS3, MSSlins, MSScols,"32-bit float");
CreateTempRaster(RADS3MSS4, MSSlins, MSScols,"32-bit float");
for i = 1 to MSSlins
{
for j = 1 to MSScols
{
RADS3MSS1[i,j] = L1B1gain * MSS3BAND1[i,j] + L1B1bias;
RADS3MSS2[i,j] = L1B2gain * MSS3BAND2[i,j] + L1B1bias;
RADS3MSS3[i,j] = L1B3gain * MSS3BAND3[i,j] + L1B1bias;
RADS3MSS4[i,j] = L1B4gain * MSS3BAND4[i,j] + L1B1bias;
}
}
CloseRaster(MSS3BAND1);
CloseRaster(MSS3BAND2);
CloseRaster(MSS3BAND3);
CloseRaster(MSS3BAND4);
printf("Radiance calculation for Scene 3 (MSS) is done...\n");
}
###########################
### Radiance Scene 4
###########################
if ( sensors4 == 7 )
{
raster RADS4ETM1, RADS4ETM2, RADS4ETM3, RADS4ETM4, RADS4ETM5, RADS4ETM7;
CreateTempRaster(RADS4ETM1, ETMlins, ETMcols,"32-bit float");
CreateTempRaster(RADS4ETM2, ETMlins, ETMcols,"32-bit float");
CreateTempRaster(RADS4ETM3, ETMlins, ETMcols,"32-bit float");
CreateTempRaster(RADS4ETM4, ETMlins, ETMcols,"32-bit float");
CreateTempRaster(RADS4ETM5, ETMlins, ETMcols,"32-bit float");
CreateTempRaster(RADS4ETM7, ETMlins, ETMcols,"32-bit float");
for i = 1 to ETMlins
{
for j = 1 to ETMcols
{
if ( s4aq < 20000701) # Before 1. July 2000
{
if ( earSurCat4 == 8 ) # Desert(hs)
{
RADS4ETM1[i,j] = (B1LGLMAXBef2000-B1LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM4BAND1[i,j]-QCALMIN)+B1LGLMINBef2000;
RADS4ETM2[i,j] = (B2LGLMAXBef2000-B2LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM4BAND2[i,j]-QCALMIN)+B2LGLMINBef2000;
RADS4ETM3[i,j] = (B3LGLMAXBef2000-B3LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM4BAND3[i,j]-QCALMIN)+B3LGLMINBef2000;
RADS4ETM4[i,j] = (B4LGLMAXBef2000-B4LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM4BAND4[i,j]-QCALMIN)+B4LGLMINBef2000;
RADS4ETM5[i,j] = (B5LGLMAXBef2000-B5LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM4BAND5[i,j]-QCALMIN)+B5LGLMINBef2000;
RADS4ETM7[i,j] = (B7LGLMAXBef2000-B7LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM4BAND7[i,j]-QCALMIN)+B7LGLMINBef2000;
}
else if ( earSurCat4 == 7 ) # Desert(ms)
{
RADS4ETM1[i,j] = (B1LGLMAXBef2000-B1LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM4BAND1[i,j]-QCALMIN)+B1LGLMINBef2000;
RADS4ETM2[i,j] = (B2LGLMAXBef2000-B2LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM4BAND2[i,j]-QCALMIN)+B2LGLMINBef2000;
RADS4ETM3[i,j] = (B3LGLMAXBef2000-B3LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM4BAND3[i,j]-QCALMIN)+B3LGLMINBef2000;
RADS4ETM4[i,j] = (B4HGLMAXBef2000-B4HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM4BAND4[i,j]-QCALMIN)+B4HGLMINBef2000;
RADS4ETM5[i,j] = (B5LGLMAXBef2000-B5LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM4BAND5[i,j]-QCALMIN)+B5LGLMINBef2000;
RADS4ETM7[i,j] = (B7LGLMAXBef2000-B7LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM4BAND7[i,j]-QCALMIN)+B7LGLMINBef2000;
}
else if ( earSurCat4 == 6 ) # Desert Ice(ls)
{
RADS4ETM1[i,j] = (B1LGLMAXBef2000-B1LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM4BAND1[i,j]-QCALMIN)+B1LGLMINBef2000;
RADS4ETM2[i,j] = (B2LGLMAXBef2000-B2LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM4BAND2[i,j]-QCALMIN)+B2LGLMINBef2000;
RADS4ETM3[i,j] = (B3LGLMAXBef2000-B3LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM4BAND3[i,j]-QCALMIN)+B3LGLMINBef2000;
RADS4ETM4[i,j] = (B4HGLMAXBef2000-B4HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM4BAND4[i,j]-QCALMIN)+B4HGLMINBef2000;
RADS4ETM5[i,j] = (B5HGLMAXBef2000-B5HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM4BAND5[i,j]-QCALMIN)+B5HGLMINBef2000;
RADS4ETM7[i,j] = (B7HGLMAXBef2000-B7HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM4BAND7[i,j]-QCALMIN)+B7HGLMINBef2000;
}
else if ( earSurCat4 == 5 ) # Ice(hs)
{
RADS4ETM1[i,j] = (B1LGLMAXBef2000-B1LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM4BAND1[i,j]-QCALMIN)+B1LGLMINBef2000;
RADS4ETM2[i,j] = (B2LGLMAXBef2000-B2LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM4BAND2[i,j]-QCALMIN)+B2LGLMINBef2000;
RADS4ETM3[i,j] = (B3LGLMAXBef2000-B3LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM4BAND3[i,j]-QCALMIN)+B3LGLMINBef2000;
RADS4ETM4[i,j] = (B4LGLMAXBef2000-B4LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM4BAND4[i,j]-QCALMIN)+B4LGLMINBef2000;
RADS4ETM5[i,j] = (B5HGLMAXBef2000-B5HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM4BAND5[i,j]-QCALMIN)+B5HGLMINBef2000;
RADS4ETM7[i,j] = (B7HGLMAXBef2000-B7HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM4BAND7[i,j]-QCALMIN)+B7HGLMINBef2000;
}
else if ( earSurCat4 == 4 ) # Land(hs)
{
RADS4ETM1[i,j] = (B1HGLMAXBef2000-B1HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM4BAND1[i,j]-QCALMIN)+B1HGLMINBef2000;
RADS4ETM2[i,j] = (B2HGLMAXBef2000-B2HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM4BAND2[i,j]-QCALMIN)+B2HGLMINBef2000;
RADS4ETM3[i,j] = (B3HGLMAXBef2000-B3HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM4BAND3[i,j]-QCALMIN)+B3HGLMINBef2000;
RADS4ETM4[i,j] = (B4LGLMAXBef2000-B4LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM4BAND4[i,j]-QCALMIN)+B4LGLMINBef2000;
RADS4ETM5[i,j] = (B5HGLMAXBef2000-B5HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM4BAND5[i,j]-QCALMIN)+B5HGLMINBef2000;
RADS4ETM7[i,j] = (B7HGLMAXBef2000-B7HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM4BAND7[i,j]-QCALMIN)+B7HGLMINBef2000;
}
else if ( earSurCat4 == 3 ) # Land Ocean(ls
{
RADS4ETM1[i,j] = (B1HGLMAXBef2000-B1HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM4BAND1[i,j]-QCALMIN)+B1HGLMINBef2000;
RADS4ETM2[i,j] = (B2HGLMAXBef2000-B2HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM4BAND2[i,j]-QCALMIN)+B2HGLMINBef2000;
RADS4ETM3[i,j] = (B3HGLMAXBef2000-B3HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM4BAND3[i,j]-QCALMIN)+B3HGLMINBef2000;
RADS4ETM4[i,j] = (B4HGLMAXBef2000-B4HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM4BAND4[i,j]-QCALMIN)+B4HGLMINBef2000;
RADS4ETM5[i,j] = (B5HGLMAXBef2000-B5HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM4BAND5[i,j]-QCALMIN)+B5HGLMINBef2000;
RADS4ETM7[i,j] = (B7HGLMAXBef2000-B7HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM4BAND7[i,j]-QCALMIN)+B7HGLMINBef2000;
}
else if ( earSurCat4 == 2 ) # Water
{
RADS4ETM1[i,j] = (B1HGLMAXBef2000-B1HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM4BAND1[i,j]-QCALMIN)+B1HGLMINBef2000;
RADS4ETM2[i,j] = (B2HGLMAXBef2000-B2HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM4BAND2[i,j]-QCALMIN)+B2HGLMINBef2000;
RADS4ETM3[i,j] = (B3HGLMAXBef2000-B3HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM4BAND3[i,j]-QCALMIN)+B3HGLMINBef2000;
RADS4ETM4[i,j] = (B4HGLMAXBef2000-B4HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM4BAND4[i,j]-QCALMIN)+B4HGLMINBef2000;
RADS4ETM5[i,j] = (B5HGLMAXBef2000-B5HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM4BAND5[i,j]-QCALMIN)+B5HGLMINBef2000;
RADS4ETM7[i,j] = (B7HGLMAXBef2000-B7HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM4BAND7[i,j]-QCALMIN)+B7HGLMINBef2000;
}
else if ( earSurCat4 == 1 ) # Night(volcanos
{
RADS4ETM1[i,j] = (B1HGLMAXBef2000-B1HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM4BAND1[i,j]-QCALMIN)+B1HGLMINBef2000;
RADS4ETM2[i,j] = (B2HGLMAXBef2000-B2HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM4BAND2[i,j]-QCALMIN)+B2HGLMINBef2000;
RADS4ETM3[i,j] = (B3HGLMAXBef2000-B3HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM4BAND3[i,j]-QCALMIN)+B3HGLMINBef2000;
RADS4ETM4[i,j] = (B4HGLMAXBef2000-B4HGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM4BAND4[i,j]-QCALMIN)+B4HGLMINBef2000;
RADS4ETM5[i,j] = (B5LGLMAXBef2000-B5LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM4BAND5[i,j]-QCALMIN)+B5LGLMINBef2000;
RADS4ETM7[i,j] = (B7LGLMAXBef2000-B7LGLMINBef2000)/(QCALMAX-QCALMIN)*(ETM4BAND7[i,j]-QCALMIN)+B7LGLMINBef2000;
}
}
else # After 1. July 2000
{
if ( earSurCat4 == 8 ) # Desert(hs)
{
RADS4ETM1[i,j] = (B1LGLMAXAFT2000-B1LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM4BAND1[i,j]-QCALMIN)+B1LGLMINAFT2000;
RADS4ETM2[i,j] = (B2LGLMAXAFT2000-B2LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM4BAND2[i,j]-QCALMIN)+B2LGLMINAFT2000;
RADS4ETM3[i,j] = (B3LGLMAXAFT2000-B3LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM4BAND3[i,j]-QCALMIN)+B3LGLMINAFT2000;
RADS4ETM4[i,j] = (B4LGLMAXAFT2000-B4LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM4BAND4[i,j]-QCALMIN)+B4LGLMINAFT2000;
RADS4ETM5[i,j] = (B5LGLMAXAFT2000-B5LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM4BAND5[i,j]-QCALMIN)+B5LGLMINAFT2000;
RADS4ETM7[i,j] = (B7LGLMAXAFT2000-B7LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM4BAND7[i,j]-QCALMIN)+B7LGLMINAFT2000;
}
else if ( earSurCat4 == 7 ) # Desert(ms)
{
RADS4ETM1[i,j] = (B1LGLMAXAFT2000-B1LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM4BAND1[i,j]-QCALMIN)+B1LGLMINAFT2000;
RADS4ETM2[i,j] = (B2LGLMAXAFT2000-B2LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM4BAND2[i,j]-QCALMIN)+B2LGLMINAFT2000;
RADS4ETM3[i,j] = (B3LGLMAXAFT2000-B3LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM4BAND3[i,j]-QCALMIN)+B3LGLMINAFT2000;
RADS4ETM4[i,j] = (B4HGLMAXAFT2000-B4HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM4BAND4[i,j]-QCALMIN)+B4HGLMINAFT2000;
RADS4ETM5[i,j] = (B5LGLMAXAFT2000-B5LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM4BAND5[i,j]-QCALMIN)+B5LGLMINAFT2000;
RADS4ETM7[i,j] = (B7LGLMAXAFT2000-B7LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM4BAND7[i,j]-QCALMIN)+B7LGLMINAFT2000;
}
else if ( earSurCat4 == 6 ) # Desert Ice(ls)
{
RADS4ETM1[i,j] = (B1LGLMAXAFT2000-B1LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM4BAND1[i,j]-QCALMIN)+B1LGLMINAFT2000;
RADS4ETM2[i,j] = (B2LGLMAXAFT2000-B2LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM4BAND2[i,j]-QCALMIN)+B2LGLMINAFT2000;
RADS4ETM3[i,j] = (B3LGLMAXAFT2000-B3LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM4BAND3[i,j]-QCALMIN)+B3LGLMINAFT2000;
RADS4ETM4[i,j] = (B4HGLMAXAFT2000-B4HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM4BAND4[i,j]-QCALMIN)+B4HGLMINAFT2000;
RADS4ETM5[i,j] = (B5HGLMAXAFT2000-B5HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM4BAND5[i,j]-QCALMIN)+B5HGLMINAFT2000;
RADS4ETM7[i,j] = (B7HGLMAXAFT2000-B7HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM4BAND7[i,j]-QCALMIN)+B7HGLMINAFT2000;
}
else if ( earSurCat4 == 5 ) # Ice(hs)
{
RADS4ETM1[i,j] = (B1LGLMAXAFT2000-B1LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM4BAND1[i,j]-QCALMIN)+B1LGLMINAFT2000;
RADS4ETM2[i,j] = (B2LGLMAXAFT2000-B2LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM4BAND2[i,j]-QCALMIN)+B2LGLMINAFT2000;
RADS4ETM3[i,j] = (B3LGLMAXAFT2000-B3LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM4BAND3[i,j]-QCALMIN)+B3LGLMINAFT2000;
RADS4ETM4[i,j] = (B4LGLMAXAFT2000-B4LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM4BAND4[i,j]-QCALMIN)+B4LGLMINAFT2000;
RADS4ETM5[i,j] = (B5HGLMAXAFT2000-B5HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM4BAND5[i,j]-QCALMIN)+B5HGLMINAFT2000;
RADS4ETM7[i,j] = (B7HGLMAXAFT2000-B7HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM4BAND7[i,j]-QCALMIN)+B7HGLMINAFT2000;
}
else if ( earSurCat4 == 4 ) # Land(hs)
{
RADS4ETM1[i,j] = (B1HGLMAXAFT2000-B1HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM4BAND1[i,j]-QCALMIN)+B1HGLMINAFT2000;
RADS4ETM2[i,j] = (B2HGLMAXAFT2000-B2HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM4BAND2[i,j]-QCALMIN)+B2HGLMINAFT2000;
RADS4ETM3[i,j] = (B3HGLMAXAFT2000-B3HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM4BAND3[i,j]-QCALMIN)+B3HGLMINAFT2000;
RADS4ETM4[i,j] = (B4LGLMAXAFT2000-B4LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM4BAND4[i,j]-QCALMIN)+B4LGLMINAFT2000;
RADS4ETM5[i,j] = (B5HGLMAXAFT2000-B5HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM4BAND5[i,j]-QCALMIN)+B5HGLMINAFT2000;
RADS4ETM7[i,j] = (B7HGLMAXAFT2000-B7HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM4BAND7[i,j]-QCALMIN)+B7HGLMINAFT2000;
}
else if ( earSurCat4 == 3 ) # Land Ocean(ls
{
RADS4ETM1[i,j] = (B1HGLMAXAFT2000-B1HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM4BAND1[i,j]-QCALMIN)+B1HGLMINAFT2000;
RADS4ETM2[i,j] = (B2HGLMAXAFT2000-B2HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM4BAND2[i,j]-QCALMIN)+B2HGLMINAFT2000;
RADS4ETM3[i,j] = (B3HGLMAXAFT2000-B3HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM4BAND3[i,j]-QCALMIN)+B3HGLMINAFT2000;
RADS4ETM4[i,j] = (B4HGLMAXAFT2000-B4HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM4BAND4[i,j]-QCALMIN)+B4HGLMINAFT2000;
RADS4ETM5[i,j] = (B5HGLMAXAFT2000-B5HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM4BAND5[i,j]-QCALMIN)+B5HGLMINAFT2000;
RADS4ETM7[i,j] = (B7HGLMAXAFT2000-B7HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM4BAND7[i,j]-QCALMIN)+B7HGLMINAFT2000;
}
else if ( earSurCat4 == 2 ) # Water
{
RADS4ETM1[i,j] = (B1HGLMAXAFT2000-B1HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM4BAND1[i,j]-QCALMIN)+B1HGLMINAFT2000;
RADS4ETM2[i,j] = (B2HGLMAXAFT2000-B2HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM4BAND2[i,j]-QCALMIN)+B2HGLMINAFT2000;
RADS4ETM3[i,j] = (B3HGLMAXAFT2000-B3HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM4BAND3[i,j]-QCALMIN)+B3HGLMINAFT2000;
RADS4ETM4[i,j] = (B4HGLMAXAFT2000-B4HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM4BAND4[i,j]-QCALMIN)+B4HGLMINAFT2000;
RADS4ETM5[i,j] = (B5HGLMAXAFT2000-B5HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM4BAND5[i,j]-QCALMIN)+B5HGLMINAFT2000;
RADS4ETM7[i,j] = (B7HGLMAXAFT2000-B7HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM4BAND7[i,j]-QCALMIN)+B7HGLMINAFT2000;
}
else if ( earSurCat4 == 1 ) # Night(volcanos
{
RADS4ETM1[i,j] = (B1HGLMAXAFT2000-B1HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM4BAND1[i,j]-QCALMIN)+B1HGLMINAFT2000;
RADS4ETM2[i,j] = (B2HGLMAXAFT2000-B2HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM4BAND2[i,j]-QCALMIN)+B2HGLMINAFT2000;
RADS4ETM3[i,j] = (B3HGLMAXAFT2000-B3HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM4BAND3[i,j]-QCALMIN)+B3HGLMINAFT2000;
RADS4ETM4[i,j] = (B4HGLMAXAFT2000-B4HGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM4BAND4[i,j]-QCALMIN)+B4HGLMINAFT2000;
RADS4ETM5[i,j] = (B5LGLMAXAFT2000-B5LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM4BAND5[i,j]-QCALMIN)+B5LGLMINAFT2000;
RADS4ETM7[i,j] = (B7LGLMAXAFT2000-B7LGLMINAFT2000)/(QCALMAX-QCALMIN)*(ETM4BAND7[i,j]-QCALMIN)+B7LGLMINAFT2000;
}
}
}
}
CloseRaster(ETM4BAND1);
CloseRaster(ETM4BAND2);
CloseRaster(ETM4BAND3);
CloseRaster(ETM4BAND4);
CloseRaster(ETM4BAND5);
CloseRaster(ETM4BAND7);
printf("Radiance calculation for Scene 4 (ETM) is done...\n\n");
}
else if ( sensors4 == 6 )
{
raster RADS4TM1, RADS4TM2, RADS4TM3, RADS4TM4, RADS4TM5, RADS4TM7;
CreateTempRaster(RADS4TM1, TMlins, TMcols,"32-bit float");
CreateTempRaster(RADS4TM2, TMlins, TMcols,"32-bit float");
CreateTempRaster(RADS4TM3, TMlins, TMcols,"32-bit float");
CreateTempRaster(RADS4TM4, TMlins, TMcols,"32-bit float");
CreateTempRaster(RADS4TM5, TMlins, TMcols,"32-bit float");
CreateTempRaster(RADS4TM7, TMlins, TMcols,"32-bit float");
for i = 1 to TMlins
{
for j = 1 to TMcols
{
if (s4leap == 0)
{
numeric gainnewTMS4b1, gainnewTMS4b2, gainnewTMS4b3, gainnewTMS4b4, gainnewTMS4b5, gainnewTMS4b7;
gainnewTMS4b1 = ((0.145658 * exp(-0.955113 * ((s4year + (s4jul / 365)) - 1984.2082))) + 1.243000);
gainnewTMS4b2 = ((0.058651 * exp(-0.835952 * ((s4year + (s4jul / 365)) - 1984.2082))) + 0.656100);
gainnewTMS4b3 = ((0.111858 * exp(-1.002090 * ((s4year + (s4jul / 365)) - 1984.2082))) + 0.905000);
gainnewTMS4b4 = ((0.107650 * exp(-1.277190 * ((s4year + (s4jul / 365)) - 1984.2082))) + 1.082000);
gainnewTMS4b5 = ((0.243364 * exp(-1.207080 * ((s4year + (s4jul / 365)) - 1984.2082))) + 7.944000);
gainnewTMS4b7 = ((0.403551 * exp(-0.999127 * ((s4year + (s4jul / 365)) - 1984.2082))) + 14.52000);
RADS4TM1[i,j] = ((s4TMg1 * ((gainnewTMS4b1 * ((s4TMg1 * TM4BAND1[i,j]) + s4TMb1)) + biasnewTMb1)) + s4TMb1);
RADS4TM2[i,j] = ((s4TMg2 * ((gainnewTMS4b2 * ((s4TMg2 * TM4BAND2[i,j]) + s4TMb2)) + biasnewTMb2)) + s4TMb2);
RADS4TM3[i,j] = ((s4TMg3 * ((gainnewTMS4b3 * ((s4TMg3 * TM4BAND3[i,j]) + s4TMb3)) + biasnewTMb3)) + s4TMb3);
RADS4TM4[i,j] = ((s4TMg4 * ((gainnewTMS4b4 * ((s4TMg4 * TM4BAND4[i,j]) + s4TMb4)) + biasnewTMb4)) + s4TMb4);
RADS4TM5[i,j] = ((s4TMg5 * ((gainnewTMS4b5 * ((s4TMg5 * TM4BAND5[i,j]) + s4TMb5)) + biasnewTMb5)) + s4TMb5);
RADS4TM7[i,j] = ((s4TMg7 * ((gainnewTMS4b7 * ((s4TMg7 * TM4BAND7[i,j]) + s4TMb7)) + biasnewTMb7)) + s4TMb7);
}
else if (s4leap == 1)
{
numeric gainnewTMS4b1, gainnewTMS4b2, gainnewTMS4b3, gainnewTMS4b4, gainnewTMS4b5, gainnewTMS4b7;
gainnewTMS4b1 = ((0.145658 * exp(-0.955113 * ((s4year + (s4jul / 366)) - 1984.2082))) + 1.243000);
gainnewTMS4b2 = ((0.058651 * exp(-0.835952 * ((s4year + (s4jul / 366)) - 1984.2082))) + 0.656100);
gainnewTMS4b3 = ((0.111858 * exp(-1.002090 * ((s4year + (s4jul / 366)) - 1984.2082))) + 0.905000);
gainnewTMS4b4 = ((0.107650 * exp(-1.277190 * ((s4year + (s4jul / 366)) - 1984.2082))) + 1.082000);
gainnewTMS4b5 = ((0.243364 * exp(-1.207080 * ((s4year + (s4jul / 366)) - 1984.2082))) + 7.944000);
gainnewTMS4b7 = ((0.403551 * exp(-0.999127 * ((s4year + (s4jul / 366)) - 1984.2082))) + 14.52000);
RADS4TM1[i,j] = ((s4TMg1 * ((gainnewTMS4b1 * ((s4TMg1 * TM4BAND1[i,j]) + s4TMb1)) + biasnewTMb1)) + s4TMb1);
RADS4TM2[i,j] = ((s4TMg2 * ((gainnewTMS4b2 * ((s4TMg2 * TM4BAND2[i,j]) + s4TMb2)) + biasnewTMb2)) + s4TMb2);
RADS4TM3[i,j] = ((s4TMg3 * ((gainnewTMS4b3 * ((s4TMg3 * TM4BAND3[i,j]) + s4TMb3)) + biasnewTMb3)) + s4TMb3);
RADS4TM4[i,j] = ((s4TMg4 * ((gainnewTMS4b4 * ((s4TMg4 * TM4BAND4[i,j]) + s4TMb4)) + biasnewTMb4)) + s4TMb4);
RADS4TM5[i,j] = ((s4TMg5 * ((gainnewTMS4b5 * ((s4TMg5 * TM4BAND5[i,j]) + s4TMb5)) + biasnewTMb5)) + s4TMb5);
RADS4TM7[i,j] = ((s4TMg7 * ((gainnewTMS4b7 * ((s4TMg7 * TM4BAND7[i,j]) + s4TMb7)) + biasnewTMb7)) + s4TMb7);
}
}
}
CloseRaster(TM4BAND1);
CloseRaster(TM4BAND2);
CloseRaster(TM4BAND3);
CloseRaster(TM4BAND4);
CloseRaster(TM4BAND5);
CloseRaster(TM4BAND7);
printf("Radiance calculation for Scene 4 (TM) is done...\n\n");
}
else if ( sensors4 == 5 ) # MSS 5 - Calib Werte nach Price J.C.1987
{
raster RADS4MSS1, RADS4MSS2, RADS4MSS3, RADS4MSS4;
CreateTempRaster(RADS4MSS1, MSSlins, MSScols,"32-bit float");
CreateTempRaster(RADS4MSS2, MSSlins, MSScols,"32-bit float");
CreateTempRaster(RADS4MSS3, MSSlins, MSScols,"32-bit float");
CreateTempRaster(RADS4MSS4, MSSlins, MSScols,"32-bit float");
for i = 1 to MSSlins
{
for j = 1 to MSScols
{
if ( s4aq <= 19841109 ) # Before 9 November 1984
{
RADS4MSS1[i,j] = L5B1bef84gain * MSS4BAND1[i,j] + L5B1bef84bias;
RADS4MSS2[i,j] = L5B2bef84gain * MSS4BAND2[i,j] + L5B2bef84bias;
RADS4MSS3[i,j] = L5B3bef84gain * MSS4BAND3[i,j] + L5B3bef84bias;
RADS4MSS4[i,j] = L5B4bef84gain * MSS4BAND4[i,j] + L5B4bef84bias;
}
else # after 9 November 1984
{
RADS4MSS1[i,j] = L5B1aft84gain * MSS4BAND1[i,j] + L5B1aft84bias;
RADS4MSS2[i,j] = L5B2aft84gain * MSS4BAND2[i,j] + L5B2aft84bias;
RADS4MSS3[i,j] = L5B3aft84gain * MSS4BAND3[i,j] + L5B3aft84bias;
RADS4MSS4[i,j] = L5B4aft84gain * MSS4BAND4[i,j] + L5B4aft84bias;
}
}
}
CloseRaster(MSS4BAND1);
CloseRaster(MSS4BAND2);
CloseRaster(MSS4BAND3);
CloseRaster(MSS4BAND4);
printf("Radiance calculation for Scene 4 (MSS) is done...\n\n");
}
else if ( sensors4 == 4 ) # MSS 4
{
raster RADS4MSS1, RADS4MSS2, RADS4MSS3, RADS4MSS4;
CreateTempRaster(RADS4MSS1, MSSlins, MSScols,"32-bit float");
CreateTempRaster(RADS4MSS2, MSSlins, MSScols,"32-bit float");
CreateTempRaster(RADS4MSS3, MSSlins, MSScols,"32-bit float");
CreateTempRaster(RADS4MSS4, MSSlins, MSScols,"32-bit float");
for i = 1 to MSSlins
{
for j = 1 to MSScols
{
if ( s4aq <= 19830401) # Before 1 April 1983
{
RADS4MSS1[i,j] = L4B1bef83gain * MSS4BAND1[i,j] + L4B1bef83bias;
RADS4MSS2[i,j] = L4B2bef83gain * MSS4BAND2[i,j] + L4B2bef83bias;
RADS4MSS3[i,j] = L4B3bef83gain * MSS4BAND3[i,j] + L4B3bef83gain;
RADS4MSS4[i,j] = L4B4bef83gain * MSS4BAND4[i,j] + L4B4bef83bias;
}
else # After 1 April 1983
{
RADS4MSS1[i,j] = L4B1aft83gain * MSS4BAND1[i,j] + L4B1aft83bias;
RADS4MSS2[i,j] = L4B2aft83gain * MSS4BAND2[i,j] + L4B2aft83bias;
RADS4MSS3[i,j] = L4B3aft83gain * MSS4BAND3[i,j] + L4B3aft83bias;
RADS4MSS4[i,j] = L4B4aft83gain * MSS4BAND4[i,j] + L4B4aft83bias;
}
}
}
CloseRaster(MSS4BAND1);
CloseRaster(MSS4BAND2);
CloseRaster(MSS4BAND3);
CloseRaster(MSS4BAND4);
printf("Radiance calculation for Scene 4 (MSS) is done...\n\n");
}
else if ( sensors4 == 3 ) # MSS 3
{
raster RADS4MSS1, RADS4MSS2, RADS4MSS3, RADS4MSS4;
CreateTempRaster(RADS4MSS1, MSSlins, MSScols,"32-bit float");
CreateTempRaster(RADS4MSS2, MSSlins, MSScols,"32-bit float");
CreateTempRaster(RADS4MSS3, MSSlins, MSScols,"32-bit float");
CreateTempRaster(RADS4MSS4, MSSlins, MSScols,"32-bit float");
for i = 1 to MSSlins
{
for j = 1 to MSScols
{
if ( s4aq <= 19780601 ) # Before 1 Juni 1978
{
RADS4MSS1[i,j] = L3B1bef78gain * MSS4BAND1[i,j] + L3B1bef78bias;
RADS4MSS2[i,j] = L3B2bef78gain * MSS4BAND2[i,j] + L3B2bef78bias;
RADS4MSS3[i,j] = L3B3bef78gain * MSS4BAND3[i,j] + L3B3bef78bias;
RADS4MSS4[i,j] = L3B4bef78gain * MSS4BAND4[i,j] + L3B4bef78bias;
}
else if ( s4aq >= 19780602 and s4aq <= 19790201 ) # 2 Juni 1978 bis 1 Februar 1979
{
RADS4MSS1[i,j] = L3B17879gain * MSS4BAND1[i,j] + L3B17879bias;
RADS4MSS2[i,j] = L3B27879gain * MSS4BAND2[i,j] + L3B27879bias;
RADS4MSS3[i,j] = L3B37879gain * MSS4BAND3[i,j] + L3B37879bias;
RADS4MSS4[i,j] = L3B47879gain * MSS4BAND4[i,j] + L3B47879bias;
}
else if ( s1aq > 19790201 ) # After 1 Februar 1979
{
RADS4MSS1[i,j] = L3B1aft79gain * MSS4BAND1[i,j] + L3B1aft79bias;
RADS4MSS2[i,j] = L3B2aft79gain * MSS4BAND2[i,j] + L3B2aft79bias;
RADS4MSS3[i,j] = L3B3aft79gain * MSS4BAND3[i,j] + L3B3aft79bias;
RADS4MSS4[i,j] = L3B4aft79gain * MSS4BAND4[i,j] + L3B4aft79bias;
}
}
}
CloseRaster(MSS4BAND1);
CloseRaster(MSS4BAND2);
CloseRaster(MSS4BAND3);
CloseRaster(MSS4BAND4);
printf("Radiance calculation for Scene 4 (MSS) is done...\n\n");
}
else if ( sensors4 == 2 ) # MSS 2
{
raster RADS4MSS1, RADS4MSS2, RADS4MSS3, RADS4MSS4;
CreateTempRaster(RADS4MSS1, MSSlins, MSScols,"32-bit float");
CreateTempRaster(RADS4MSS2, MSSlins, MSScols,"32-bit float");
CreateTempRaster(RADS4MSS3, MSSlins, MSScols,"32-bit float");
CreateTempRaster(RADS4MSS4, MSSlins, MSScols,"32-bit float");
for i = 1 to MSSlins
{
for j = 1 to MSScols
{
if ( s4aq <= 19750716 ) # Before 16 Juli 1975
{
RADS4MSS1[i,j] = L2B1bef75gain * MSS4BAND1[i,j] + L2B1bef75bias;
RADS4MSS2[i,j] = L2B2bef75gain * MSS4BAND2[i,j] + L2B2bef75bias;
RADS4MSS3[i,j] = L2B3bef75gain * MSS4BAND3[i,j] + L2B3bef75bias;
RADS4MSS4[i,j] = L2B4bef75gain * MSS4BAND4[i,j] + L2B4bef75bias;
}
else if ( s4aq > 19750716 and s4aq <= 19790201 )
{
RADS4MSS1[i,j] = L2B1aft75gain * MSS4BAND1[i,j] + L2B1aft75bias; # After 16. Juli 1975
RADS4MSS2[i,j] = L2B2aft75gain * MSS4BAND2[i,j] + L2B2aft75bias;
RADS4MSS3[i,j] = L2B3aft75gain * MSS4BAND3[i,j] + L2B3aft75bias;
RADS4MSS4[i,j] = L2B4aft75gain * MSS4BAND4[i,j] + L2B4aft75bias;
}
else if ( s4aq > 19790201 )
{
RADS4MSS1[i,j] = L2B1aft79gain * MSS4BAND1[i,j] + L2B1aft79bias; # After 1. Februar 1979
RADS4MSS2[i,j] = L2B2aft79gain * MSS4BAND2[i,j] + L2B2aft79bias;
RADS4MSS3[i,j] = L2B3aft79gain * MSS4BAND3[i,j] + L2B3aft79bias;
RADS4MSS4[i,j] = L2B4aft79gain * MSS4BAND4[i,j] + L2B4aft79bias;
}
}
}
CloseRaster(MSS4BAND1);
CloseRaster(MSS4BAND2);
CloseRaster(MSS4BAND3);
CloseRaster(MSS4BAND4);
printf("Radiance calculation for Scene 4 (MSS) is done...\n\n");
}
else if ( sensors4 == 1 ) # MSS 1
{
raster RADS4MSS1, RADS4MSS2, RADS4MSS3, RADS4MSS4;
CreateTempRaster(RADS4MSS1, MSSlins, MSScols,"32-bit float");
CreateTempRaster(RADS4MSS2, MSSlins, MSScols,"32-bit float");
CreateTempRaster(RADS4MSS3, MSSlins, MSScols,"32-bit float");
CreateTempRaster(RADS4MSS4, MSSlins, MSScols,"32-bit float");
for i = 1 to MSSlins
{
for j = 1 to MSScols
{
RADS4MSS1[i,j] = L1B1gain * MSS4BAND1[i,j] + L1B1bias;
RADS4MSS2[i,j] = L1B2gain * MSS4BAND2[i,j] + L1B1bias;
RADS4MSS3[i,j] = L1B3gain * MSS4BAND3[i,j] + L1B1bias;
RADS4MSS4[i,j] = L1B4gain * MSS4BAND4[i,j] + L1B1bias;
}
}
CloseRaster(MSS4BAND1);
CloseRaster(MSS4BAND2);
CloseRaster(MSS4BAND3);
CloseRaster(MSS4BAND4);
printf("Radiance calculation for Scene 4 (MSS) is done...\n\n");
}
printf("The computation of radiance rasters is done...\n\n\n");
######################################
###### Begin processing.
###### Calculate Refelectance.
######################################
printf( "Starting of to compute the reflectance rasters...\n\n" );
#############################
#### Reflectance Scene 1
#############################
if ( sensors1 == 7 )
{
raster REFS1ETM1, REFS1ETM2, REFS1ETM3, REFS1ETM4, REFS1ETM5, REFS1ETM7;
numeric radsurfETMS1b1, radsurfETMS1b2, radsurfETMS1b3, radsurfETMS1b4, radsurfETMS1b5, radsurfETMS1b7;
numeric valueS1ETM1, valueS1ETM2, valueS1ETM3, valueS1ETM4, valueS1ETM5, valueS1ETM7;
numeric dosS1ETM1nullValCount = 0;
numeric dosS1ETM2nullValCount = 0;
numeric dosS1ETM3nullValCount = 0;
numeric dosS1ETM4nullValCount = 0;
numeric dosS1ETM5nullValCount = 0;
numeric dosS1ETM7nullValCount = 0;
numeric dosS1ETM1realArrayCount = 1;
numeric dosS1ETM2realArrayCount = 1;
numeric dosS1ETM3realArrayCount = 1;
numeric dosS1ETM4realArrayCount = 1;
numeric dosS1ETM5realArrayCount = 1;
numeric dosS1ETM7realArrayCount = 1;
numeric countS1REFnullETM1 = 0;
numeric countS1REFnullETM2 = 0;
numeric countS1REFnullETM3 = 0;
numeric countS1REFnullETM4 = 0;
numeric countS1REFnullETM5 = 0;
numeric countS1REFnullETM7 = 0;
numeric countS1REFoneETM1 = 0;
numeric countS1REFoneETM2 = 0;
numeric countS1REFoneETM3 = 0;
numeric countS1REFoneETM4 = 0;
numeric countS1REFoneETM5 = 0;
numeric countS1REFoneETM7 = 0;
radsurfETMS1b1 = ESETM1 / (dist1^2);
radsurfETMS1b2 = ESETM2 / (dist1^2);
radsurfETMS1b3 = ESETM3 / (dist1^2);
radsurfETMS1b4 = ESETM4 / (dist1^2);
radsurfETMS1b5 = ESETM5 / (dist1^2);
radsurfETMS1b7 = ESETM7 / (dist1^2);
printf("Surface Radiance ETM Band 1 in W/m^2µm (Scene 1): %12f\n", radsurfETMS1b1);
printf("Surface Radiance ETM Band 2 in W/m^2µm (Scene 1): %12f\n", radsurfETMS1b2);
printf("Surface Radiance ETM Band 3 in W/m^2µm (Scene 1): %12f\n", radsurfETMS1b3);
printf("Surface Radiance ETM Band 4 in W/m^2µm (Scene 1): %12f\n", radsurfETMS1b4);
printf("Surface Radiance ETM Band 5 in W/m^2µm (Scene 1): %12f\n", radsurfETMS1b5);
printf("Surface Radiance ETM Band 7 in W/m^2µm (Scene 1): %12f\n\n", radsurfETMS1b7);
for i = 1 to ETMlins
{
for j = 1 to ETMcols
{
if (IsNull(RADS1ETM1[i,j]) == 1)
{
dosS1ETM1nullValCount = dosS1ETM1nullValCount + 1;
}
if (IsNull(RADS1ETM2[i,j]) == 1)
{
dosS1ETM2nullValCount = dosS1ETM2nullValCount + 1;
}
if (IsNull(RADS1ETM3[i,j]) == 1)
{
dosS1ETM3nullValCount = dosS1ETM3nullValCount + 1;
}
if (IsNull(RADS1ETM4[i,j]) == 1)
{
dosS1ETM4nullValCount = dosS1ETM4nullValCount + 1;
}
if (IsNull(RADS1ETM5[i,j]) == 1)
{
dosS1ETM5nullValCount = dosS1ETM5nullValCount + 1;
}
if (IsNull(RADS1ETM7[i,j]) == 1)
{
dosS1ETM7nullValCount = dosS1ETM7nullValCount + 1;
}
}
}
numeric dosS1ETM1realSize = (ETMlins * ETMcols) - dosS1ETM1nullValCount;
numeric dosS1ETM2realSize = (ETMlins * ETMcols) - dosS1ETM2nullValCount;
numeric dosS1ETM3realSize = (ETMlins * ETMcols) - dosS1ETM3nullValCount;
numeric dosS1ETM4realSize = (ETMlins * ETMcols) - dosS1ETM4nullValCount;
numeric dosS1ETM5realSize = (ETMlins * ETMcols) - dosS1ETM5nullValCount;
numeric dosS1ETM7realSize = (ETMlins * ETMcols) - dosS1ETM7nullValCount;
array allValuesDosS1ETM1[dosS1ETM1realSize];
array allValuesDosS1ETM2[dosS1ETM2realSize];
array allValuesDosS1ETM3[dosS1ETM3realSize];
array allValuesDosS1ETM4[dosS1ETM4realSize];
array allValuesDosS1ETM5[dosS1ETM5realSize];
array allValuesDosS1ETM7[dosS1ETM7realSize];
numeric DNminCALCS1ETM1 = DNminCALC(Scene1Lin, Scene1Col, dosS1ETM1realSize);
numeric DNminCALCS1ETM2 = DNminCALC(Scene1Lin, Scene1Col, dosS1ETM2realSize);
numeric DNminCALCS1ETM3 = DNminCALC(Scene1Lin, Scene1Col, dosS1ETM3realSize);
numeric DNminCALCS1ETM4 = DNminCALC(Scene1Lin, Scene1Col, dosS1ETM4realSize);
numeric DNminCALCS1ETM5 = DNminCALC(Scene1Lin, Scene1Col, dosS1ETM5realSize);
numeric DNminCALCS1ETM7 = DNminCALC(Scene1Lin, Scene1Col, dosS1ETM7realSize);
for i = 1 to ETMlins
{
for j = 1 to ETMcols
{
if (IsNull(RADS1ETM1[i,j]) == 0)
{
allValuesDosS1ETM1[dosS1ETM1realArrayCount] = RADS1ETM1[i,j];
dosS1ETM1realArrayCount = dosS1ETM1realArrayCount + 1;
}
if (IsNull(RADS1ETM2[i,j]) == 0)
{
allValuesDosS1ETM2[dosS1ETM2realArrayCount] = RADS1ETM2[i,j];
dosS1ETM2realArrayCount = dosS1ETM2realArrayCount + 1;
}
if (IsNull(RADS1ETM3[i,j]) == 0)
{
allValuesDosS1ETM3[dosS1ETM3realArrayCount] = RADS1ETM3[i,j];
dosS1ETM3realArrayCount = dosS1ETM3realArrayCount + 1;
}
if (IsNull(RADS1ETM4[i,j]) == 0)
{
allValuesDosS1ETM4[dosS1ETM4realArrayCount] = RADS1ETM4[i,j];
dosS1ETM4realArrayCount = dosS1ETM4realArrayCount + 1;
}
if (IsNull(RADS1ETM5[i,j]) == 0)
{
allValuesDosS1ETM5[dosS1ETM5realArrayCount] = RADS1ETM5[i,j];
dosS1ETM5realArrayCount = dosS1ETM5realArrayCount + 1;
}
if (IsNull(RADS1ETM7[i,j]) == 0)
{
allValuesDosS1ETM7[dosS1ETM7realArrayCount] = RADS1ETM7[i,j];
dosS1ETM7realArrayCount = dosS1ETM7realArrayCount + 1;
}
}
}
########################### Scene 1 - Dn1000 - Band 1
numeric lastDOSS1ETM1 = dosS1ETM1realSize;
numeric hDOSS1ETM1 = 1;
while ( (hDOSS1ETM1 * 3 + 1) < lastDOSS1ETM1 - 1 )
{
hDOSS1ETM1 = 3 * hDOSS1ETM1 + 1;
}
while ( hDOSS1ETM1 > 0 )
{
for i = hDOSS1ETM1 - 1 to lastDOSS1ETM1 # for each of the h sets of elements
{
numeric keyDOSS1ETM1 = allValuesDosS1ETM1[i];
numeric jDOSS1ETM1 = i;
while (jDOSS1ETM1 >= hDOSS1ETM1 && allValuesDosS1ETM1[jDOSS1ETM1 - hDOSS1ETM1] > keyDOSS1ETM1)
{
allValuesDosS1ETM1[jDOSS1ETM1] = allValuesDosS1ETM1[jDOSS1ETM1 - hDOSS1ETM1];
jDOSS1ETM1 = jDOSS1ETM1 - hDOSS1ETM1;
}
allValuesDosS1ETM1[jDOSS1ETM1] = keyDOSS1ETM1;
}
hDOSS1ETM1 = floor(hDOSS1ETM1/3);
}
numeric minValueDosS1ETM1 = allValuesDosS1ETM1[1];
numeric dn1000S1ETM1 = 10000;
numeric actualCountDosS1ETM1 = 0;
for i = 1 to dosS1ETM1realSize
{
if (allValuesDosS1ETM1[i] == minValueDosS1ETM1)
{
actualCountDosS1ETM1 = actualCountDosS1ETM1 + 1;
if (actualCountDosS1ETM1 >= DNminCALCS1ETM1)
{
dn1000S1ETM1 = minValueDosS1ETM1;
go to dn1000S1ETM1jumper;
}
}
else
{
minValueDosS1ETM1 = allValuesDosS1ETM1[i+1];
actualCountDosS1ETM1 = 0;
}
}
dn1000S1ETM1jumper:
if (dn1000S1ETM1 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S1ETM1 = allValuesDosS1ETM1[1];
}
if (dn1000S1ETM1 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S1ETM1 = allValuesDosS1ETM1[1];
}
printf("dn1000 Scene 1 ETM1: %12f\n", dn1000S1ETM1);
########################### Scene 1 - Dn1000 - Band 2
numeric lastDOSS1ETM2 = dosS1ETM1realSize;
numeric hDOSS1ETM2 = 1;
while ( (hDOSS1ETM2 * 3 + 1) < lastDOSS1ETM2 - 1 )
{
hDOSS1ETM2 = 3 * hDOSS1ETM2 + 1;
}
while ( hDOSS1ETM2 > 0 )
{
for i = hDOSS1ETM2 - 1 to lastDOSS1ETM2
{
numeric keyDOSS1ETM2 = allValuesDosS1ETM2[i];
numeric jDOSS1ETM2 = i;
while (jDOSS1ETM2 >= hDOSS1ETM2 && allValuesDosS1ETM2[jDOSS1ETM2 - hDOSS1ETM2] > keyDOSS1ETM2)
{
allValuesDosS1ETM2[jDOSS1ETM2] = allValuesDosS1ETM2[jDOSS1ETM2 - hDOSS1ETM2];
jDOSS1ETM2 = jDOSS1ETM2 - hDOSS1ETM2;
}
allValuesDosS1ETM2[jDOSS1ETM2] = keyDOSS1ETM2;
}
hDOSS1ETM2 = floor(hDOSS1ETM2/3);
}
numeric minValueDosS1ETM2 = allValuesDosS1ETM2[1];
numeric dn1000S1ETM2 = 10000;
numeric actualCountDosS1ETM2 = 0;
for i = 1 to dosS1ETM2realSize
{
if (allValuesDosS1ETM2[i] == minValueDosS1ETM2)
{
actualCountDosS1ETM2 = actualCountDosS1ETM2 + 1;
if (actualCountDosS1ETM2 >= DNminCALCS1ETM2)
{
dn1000S1ETM2 = minValueDosS1ETM2;
go to dn1000S1ETM2jumper;
}
}
else
{
minValueDosS1ETM2 = allValuesDosS1ETM2[i+1];
actualCountDosS1ETM2 = 0;
}
}
dn1000S1ETM2jumper:
if (dn1000S1ETM2 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S1ETM2 = allValuesDosS1ETM2[1];
}
if (dn1000S1ETM2 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S1ETM2 = allValuesDosS1ETM2[1];
}
printf("dn1000 Scene 1 ETM2: %12f\n", dn1000S1ETM2);
########################### Scene 1 - Dn1000 - Band 3
numeric lastDOSS1ETM3 = dosS1ETM3realSize;
numeric hDOSS1ETM3 = 1;
while ( (hDOSS1ETM3 * 3 + 1) < lastDOSS1ETM3 - 1 )
{
hDOSS1ETM3 = 3 * hDOSS1ETM3 + 1;
}
while ( hDOSS1ETM3 > 0 )
{
for i = hDOSS1ETM3 - 1 to lastDOSS1ETM3 # for each of the h sets of elements
{
numeric keyDOSS1ETM3 = allValuesDosS1ETM3[i];
numeric jDOSS1ETM3 = i;
while (jDOSS1ETM3 >= hDOSS1ETM3 && allValuesDosS1ETM3[jDOSS1ETM3 - hDOSS1ETM3] > keyDOSS1ETM3)
{
allValuesDosS1ETM3[jDOSS1ETM3] = allValuesDosS1ETM3[jDOSS1ETM3 - hDOSS1ETM3];
jDOSS1ETM3 = jDOSS1ETM3 - hDOSS1ETM3;
}
allValuesDosS1ETM3[jDOSS1ETM3] = keyDOSS1ETM3;
}
hDOSS1ETM3 = floor(hDOSS1ETM3/3);
}
numeric minValueDosS1ETM3 = allValuesDosS1ETM3[1];
numeric dn1000S1ETM3 = 10000;
numeric actualCountDosS1ETM3 = 0;
for i = 1 to dosS1ETM3realSize
{
if (allValuesDosS1ETM3[i] == minValueDosS1ETM3)
{
actualCountDosS1ETM3 = actualCountDosS1ETM3 + 1;
if (actualCountDosS1ETM3 >= DNminCALCS1ETM3)
{
dn1000S1ETM3 = minValueDosS1ETM3;
go to dn1000S1ETM3jumper;
}
}
else
{
minValueDosS1ETM3 = allValuesDosS1ETM3[i+1];
actualCountDosS1ETM3 = 0;
}
}
dn1000S1ETM3jumper:
if (dn1000S1ETM3 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S1ETM3 = allValuesDosS1ETM3[1];
}
if (dn1000S1ETM3 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S1ETM3 = allValuesDosS1ETM3[1];
}
printf("dn1000 Scene 1 ETM3: %12f\n", dn1000S1ETM3);
########################### Scene 1 - Dn1000 - Band 4
numeric lastDOSS1ETM4 = dosS1ETM4realSize;
numeric hDOSS1ETM4 = 1;
while ( (hDOSS1ETM4 * 3 + 1) < lastDOSS1ETM4 - 1 )
{
hDOSS1ETM4 = 3 * hDOSS1ETM4 + 1;
}
while ( hDOSS1ETM4 > 0 )
{
for i = hDOSS1ETM4 - 1 to lastDOSS1ETM4
{
numeric keyDOSS1ETM4 = allValuesDosS1ETM4[i];
numeric jDOSS1ETM4 = i;
while (jDOSS1ETM4 >= hDOSS1ETM4 && allValuesDosS1ETM4[jDOSS1ETM4 - hDOSS1ETM4] > keyDOSS1ETM4)
{
allValuesDosS1ETM4[jDOSS1ETM4] = allValuesDosS1ETM4[jDOSS1ETM4 - hDOSS1ETM4];
jDOSS1ETM4 = jDOSS1ETM4 - hDOSS1ETM4;
}
allValuesDosS1ETM4[jDOSS1ETM4] = keyDOSS1ETM4;
}
hDOSS1ETM4 = floor(hDOSS1ETM4/3);
}
numeric minValueDosS1ETM4 = allValuesDosS1ETM4[1];
numeric dn1000S1ETM4 = 10000;
numeric actualCountDosS1ETM4 = 0;
for i = 1 to dosS1ETM4realSize
{
if (allValuesDosS1ETM4[i] == minValueDosS1ETM4)
{
actualCountDosS1ETM4 = actualCountDosS1ETM4 + 1;
if (actualCountDosS1ETM4 >= DNminCALCS1ETM4)
{
dn1000S1ETM4 = minValueDosS1ETM4;
go to dn1000S1ETM4jumper;
}
}
else
{
minValueDosS1ETM4 = allValuesDosS1ETM4[i+1];
actualCountDosS1ETM4 = 0;
}
}
dn1000S1ETM4jumper:
if (dn1000S1ETM4 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S1ETM4 = allValuesDosS1ETM4[1];
}
if (dn1000S1ETM4 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S1ETM4 = allValuesDosS1ETM4[1];
}
printf("dn1000 Scene 1 ETM4: %12f\n", dn1000S1ETM4);
########################### Scene 1 - Dn1000 - Band 5
numeric lastDOSS1ETM5 = dosS1ETM5realSize;
numeric hDOSS1ETM5 = 1;
while ( (hDOSS1ETM5 * 3 + 1) < lastDOSS1ETM5 - 1 )
{
hDOSS1ETM5 = 3 * hDOSS1ETM5 + 1;
}
while ( hDOSS1ETM5 > 0 )
{
for i = hDOSS1ETM5 - 1 to lastDOSS1ETM5 # for each of the h sets of elements
{
numeric keyDOSS1ETM5 = allValuesDosS1ETM5[i];
numeric jDOSS1ETM5 = i;
while (jDOSS1ETM5 >= hDOSS1ETM5 && allValuesDosS1ETM5[jDOSS1ETM5 - hDOSS1ETM5] > keyDOSS1ETM5)
{
allValuesDosS1ETM5[jDOSS1ETM5] = allValuesDosS1ETM5[jDOSS1ETM5 - hDOSS1ETM5];
jDOSS1ETM5 = jDOSS1ETM5 - hDOSS1ETM5;
}
allValuesDosS1ETM5[jDOSS1ETM5] = keyDOSS1ETM5;
}
hDOSS1ETM5 = floor(hDOSS1ETM5/3);
}
numeric minValueDosS1ETM5 = allValuesDosS1ETM5[1];
numeric dn1000S1ETM5 = 10000;
numeric actualCountDosS1ETM5 = 0;
for i = 1 to dosS1ETM5realSize
{
if (allValuesDosS1ETM5[i] == minValueDosS1ETM5)
{
actualCountDosS1ETM5 = actualCountDosS1ETM5 + 1;
if (actualCountDosS1ETM5 >= DNminCALCS1ETM5)
{
dn1000S1ETM5 = minValueDosS1ETM5;
go to dn1000S1ETM5jumper;
}
}
else
{
minValueDosS1ETM5 = allValuesDosS1ETM5[i+1];
actualCountDosS1ETM5 = 0;
}
}
dn1000S1ETM5jumper:
if (dn1000S1ETM5 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S1ETM5 = allValuesDosS1ETM5[1];
}
if (dn1000S1ETM5 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S1ETM5 = allValuesDosS1ETM5[1];
}
printf("dn1000 Scene 1 ETM5: %12f\n", dn1000S1ETM5);
########################### Scene 1 - Dn1000 - Band 7
numeric lastDOSS1ETM7 = dosS1ETM7realSize;
numeric hDOSS1ETM7 = 1;
while ( (hDOSS1ETM7 * 3 + 1) < lastDOSS1ETM7 - 1 )
{
hDOSS1ETM7 = 3 * hDOSS1ETM7 + 1;
}
while ( hDOSS1ETM7 > 0 )
{
for i = hDOSS1ETM7 - 1 to lastDOSS1ETM7 # for each of the h sets of elements
{
numeric keyDOSS1ETM7 = allValuesDosS1ETM7[i];
numeric jDOSS1ETM7 = i;
while (jDOSS1ETM7 >= hDOSS1ETM7 && allValuesDosS1ETM7[jDOSS1ETM7 - hDOSS1ETM7] > keyDOSS1ETM7)
{
allValuesDosS1ETM7[jDOSS1ETM7] = allValuesDosS1ETM7[jDOSS1ETM7 - hDOSS1ETM7];
jDOSS1ETM7 = jDOSS1ETM7 - hDOSS1ETM7;
}
allValuesDosS1ETM7[jDOSS1ETM7] = keyDOSS1ETM7;
}
hDOSS1ETM7 = floor(hDOSS1ETM7/3);
}
numeric minValueDosS1ETM7 = allValuesDosS1ETM7[1];
numeric dn1000S1ETM7 = 10000;
numeric actualCountDosS1ETM7 = 0;
for i = 1 to dosS1ETM7realSize
{
if (allValuesDosS1ETM7[i] == minValueDosS1ETM7)
{
actualCountDosS1ETM7 = actualCountDosS1ETM7 + 1;
if (actualCountDosS1ETM7 >= DNminCALCS1ETM7)
{
dn1000S1ETM7 = minValueDosS1ETM7;
go to dn1000S1ETM7jumper;
}
}
else
{
minValueDosS1ETM7 = allValuesDosS1ETM7[i+1];
actualCountDosS1ETM7 = 0;
}
}
dn1000S1ETM7jumper:
if (dn1000S1ETM7 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S1ETM7 = allValuesDosS1ETM7[1];
}
if (dn1000S1ETM7 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S1ETM7 = allValuesDosS1ETM7[1];
}
printf("dn1000 Scene 1 ETM7: %12f\n\n", dn1000S1ETM7);
################################### Pathradiance Calculation #######################################
numeric pathRadS1ETM1 = dn1000S1ETM1 - (0.01 * (radsurfETMS1b1 * cos(s1zenith)) / pi);
numeric pathRadS1ETM2 = dn1000S1ETM2 - (0.01 * (radsurfETMS1b2 * cos(s1zenith)) / pi);
numeric pathRadS1ETM3 = dn1000S1ETM3 - (0.01 * (radsurfETMS1b3 * cos(s1zenith)) / pi);
numeric pathRadS1ETM4 = dn1000S1ETM4 - (0.01 * (radsurfETMS1b4 * cos(s1zenith)) / pi);
numeric pathRadS1ETM5 = dn1000S1ETM5 - (0.01 * (radsurfETMS1b5 * cos(s1zenith)) / pi);
numeric pathRadS1ETM7 = dn1000S1ETM7 - (0.01 * (radsurfETMS1b7 * cos(s1zenith)) / pi);
printf("Pathradiance Scene 1 Band 1: %12f\n", pathRadS1ETM1);
printf("Pathradiance Scene 1 Band 2: %12f\n", pathRadS1ETM2);
printf("Pathradiance Scene 1 Band 3: %12f\n", pathRadS1ETM3);
printf("Pathradiance Scene 1 Band 4: %12f\n", pathRadS1ETM4);
printf("Pathradiance Scene 1 Band 5: %12f\n", pathRadS1ETM5);
printf("Pathradiance Scene 1 Band 7: %12f\n\n", pathRadS1ETM7);
################################# Reflectance Calculation with athmo correction
for i = 1 to ETMlins
{
for j = 1 to ETMcols
{
valueS1ETM1 = (pi * (RADS1ETM1[i,j] - pathRadS1ETM1)) / (radsurfETMS1b1 * cos(s1zenith));
if ( valueS1ETM1 < 0 )
{
valueS1ETM1 = 0;
countS1REFnullETM1 = countS1REFnullETM1 + 1;
}
else if ( valueS1ETM1 > 1 )
{
valueS1ETM1 = 1;
countS1REFoneETM1 = countS1REFoneETM1 + 1;
}
REFS1ETM1[i,j] = valueS1ETM1;
valueS1ETM2 = (pi * (RADS1ETM2[i,j] - pathRadS1ETM2)) / (radsurfETMS1b2 * cos(s1zenith));
if ( valueS1ETM2 < 0 )
{
valueS1ETM2 = 0;
countS1REFnullETM2 = countS1REFnullETM2 + 1;
}
else if ( valueS1ETM2 > 1 )
{
valueS1ETM2 = 1;
countS1REFoneETM2 = countS1REFoneETM2 + 1;
}
REFS1ETM2[i,j] = valueS1ETM2;
valueS1ETM3 = (pi * (RADS1ETM3[i,j] - pathRadS1ETM3)) / (radsurfETMS1b3 * cos(s1zenith));
if ( valueS1ETM3 < 0 )
{
valueS1ETM3 = 0;
countS1REFnullETM3 = countS1REFnullETM3 + 1;
}
else if ( valueS1ETM3 > 1 )
{
valueS1ETM3 = 1;
countS1REFoneETM3 = countS1REFoneETM3 + 1;
}
REFS1ETM3[i,j] = valueS1ETM3;
valueS1ETM4 = (pi * (RADS1ETM4[i,j] - pathRadS1ETM4)) / (radsurfETMS1b4 * cos(s1zenith));
if ( valueS1ETM4 < 0 )
{
valueS1ETM4 = 0;
countS1REFnullETM4 = countS1REFnullETM4 + 1;
}
else if ( valueS1ETM4 > 1 )
{
valueS1ETM4 = 1;
countS1REFoneETM4 = countS1REFoneETM4 + 1;
}
REFS1ETM4[i,j] = valueS1ETM4;
valueS1ETM5 = (pi * (RADS1ETM5[i,j] - pathRadS1ETM5)) / (radsurfETMS1b5 * cos(s1zenith));
if ( valueS1ETM5 < 0 )
{
valueS1ETM5 = 0;
countS1REFnullETM5 = countS1REFnullETM5 + 1;
}
else if ( valueS1ETM5 > 1 )
{
valueS1ETM5 = 1;
countS1REFoneETM5 = countS1REFoneETM5 + 1;
}
REFS1ETM5[i,j] = valueS1ETM5;
valueS1ETM7 = (pi * (RADS1ETM7[i,j] - pathRadS1ETM7)) / (radsurfETMS1b7 * cos(s1zenith));
if ( valueS1ETM7 < 0 )
{
valueS1ETM7 = 0;
countS1REFnullETM7 = countS1REFnullETM7 + 1;
}
else if ( valueS1ETM7 > 1 )
{
valueS1ETM7 = 1;
countS1REFoneETM7 = countS1REFoneETM7 + 1;
}
REFS1ETM7[i,j] = valueS1ETM7;
}
}
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 1 Band 1: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS1REFnullETM1, countS1REFoneETM1);
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 1 Band 2: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS1REFnullETM2, countS1REFoneETM2);
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 1 Band 3: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS1REFnullETM3, countS1REFoneETM3);
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 1 Band 4: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS1REFnullETM4, countS1REFoneETM4);
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 1 Band 5: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS1REFnullETM5, countS1REFoneETM5);
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 1 Band 7: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n\n", countS1REFnullETM7, countS1REFoneETM7);
CreatePyramid(REFS1ETM1);
CreatePyramid(REFS1ETM2);
CreatePyramid(REFS1ETM3);
CreatePyramid(REFS1ETM4);
CreatePyramid(REFS1ETM5);
CreatePyramid(REFS1ETM7);
CreateHistogram(REFS1ETM1);
CreateHistogram(REFS1ETM2);
CreateHistogram(REFS1ETM3);
CreateHistogram(REFS1ETM4);
CreateHistogram(REFS1ETM5);
CreateHistogram(REFS1ETM7);
CloseRaster(RADS1ETM1);
CloseRaster(RADS1ETM2);
CloseRaster(RADS1ETM3);
CloseRaster(RADS1ETM4);
CloseRaster(RADS1ETM5);
CloseRaster(RADS1ETM7);
printf("Reflectance calculation for Scene 1 (ETM) is done...\n\n\n");
}
else if ( sensors1 == 6 )
{
raster REFS1TM1, REFS1TM2, REFS1TM3, REFS1TM4, REFS1TM5, REFS1TM7;
numeric radsurfTMS1b1, radsurfTMS1b2, radsurfTMS1b3, radsurfTMS1b4, radsurfTMS1b5, radsurfTMS1b7;
numeric valueS1TM1, valueS1TM2, valueS1TM3, valueS1TM4, valueS1TM5, valueS1TM7;
numeric dosS1TM1nullValCount = 0;
numeric dosS1TM2nullValCount = 0;
numeric dosS1TM3nullValCount = 0;
numeric dosS1TM4nullValCount = 0;
numeric dosS1TM5nullValCount = 0;
numeric dosS1TM7nullValCount = 0;
numeric dosS1TM1realArrayCount = 1;
numeric dosS1TM2realArrayCount = 1;
numeric dosS1TM3realArrayCount = 1;
numeric dosS1TM4realArrayCount = 1;
numeric dosS1TM5realArrayCount = 1;
numeric dosS1TM7realArrayCount = 1;
numeric countS1REFnullTM1 = 0;
numeric countS1REFnullTM2 = 0;
numeric countS1REFnullTM3 = 0;
numeric countS1REFnullTM4 = 0;
numeric countS1REFnullTM5 = 0;
numeric countS1REFnullTM7 = 0;
numeric countS1REFoneTM1 = 0;
numeric countS1REFoneTM2 = 0;
numeric countS1REFoneTM3 = 0;
numeric countS1REFoneTM4 = 0;
numeric countS1REFoneTM5 = 0;
numeric countS1REFoneTM7 = 0;
radsurfTMS1b1 = ESTM1 / (dist1^2);
radsurfTMS1b2 = ESTM2 / (dist1^2);
radsurfTMS1b3 = ESTM3 / (dist1^2);
radsurfTMS1b4 = ESTM4 / (dist1^2);
radsurfTMS1b5 = ESTM5 / (dist1^2);
radsurfTMS1b7 = ESTM7 / (dist1^2);
printf("Surface Radiance TM Band 1 in W/m^2µm (Scene 1): %12f\n", radsurfTMS1b1);
printf("Surface Radiance TM Band 2 in W/m^2µm (Scene 1): %12f\n", radsurfTMS1b2);
printf("Surface Radiance TM Band 3 in W/m^2µm (Scene 1): %12f\n", radsurfTMS1b3);
printf("Surface Radiance TM Band 4 in W/m^2µm (Scene 1): %12f\n", radsurfTMS1b4);
printf("Surface Radiance TM Band 5 in W/m^2µm (Scene 1): %12f\n", radsurfTMS1b5);
printf("Surface Radiance TM Band 7 in W/m^2µm (Scene 1): %12f\n\n", radsurfTMS1b7);
for i = 1 to TMlins
{
for j = 1 to TMcols
{
if (IsNull(RADS1TM1[i,j]) == 1)
{
dosS1TM1nullValCount = dosS1TM1nullValCount + 1;
}
if (IsNull(RADS1TM2[i,j]) == 1)
{
dosS1TM2nullValCount = dosS1TM2nullValCount + 1;
}
if (IsNull(RADS1TM3[i,j]) == 1)
{
dosS1TM3nullValCount = dosS1TM3nullValCount + 1;
}
if (IsNull(RADS1TM4[i,j]) == 1)
{
dosS1TM4nullValCount = dosS1TM4nullValCount + 1;
}
if (IsNull(RADS1TM5[i,j]) == 1)
{
dosS1TM5nullValCount = dosS1TM5nullValCount + 1;
}
if (IsNull(RADS1TM7[i,j]) == 1)
{
dosS1TM7nullValCount = dosS1TM7nullValCount + 1;
}
}
}
numeric dosS1TM1realSize = (TMlins * TMcols) - dosS1TM1nullValCount;
numeric dosS1TM2realSize = (TMlins * TMcols) - dosS1TM2nullValCount;
numeric dosS1TM3realSize = (TMlins * TMcols) - dosS1TM3nullValCount;
numeric dosS1TM4realSize = (TMlins * TMcols) - dosS1TM4nullValCount;
numeric dosS1TM5realSize = (TMlins * TMcols) - dosS1TM5nullValCount;
numeric dosS1TM7realSize = (TMlins * TMcols) - dosS1TM7nullValCount;
array allValuesDosS1TM1[dosS1TM1realSize];
array allValuesDosS1TM2[dosS1TM2realSize];
array allValuesDosS1TM3[dosS1TM3realSize];
array allValuesDosS1TM4[dosS1TM4realSize];
array allValuesDosS1TM5[dosS1TM5realSize];
array allValuesDosS1TM7[dosS1TM7realSize];
numeric DNminCALCS1TM1 = DNminCALC(Scene1Lin, Scene1Col, dosS1TM1realSize);
numeric DNminCALCS1TM2 = DNminCALC(Scene1Lin, Scene1Col, dosS1TM2realSize);
numeric DNminCALCS1TM3 = DNminCALC(Scene1Lin, Scene1Col, dosS1TM3realSize);
numeric DNminCALCS1TM4 = DNminCALC(Scene1Lin, Scene1Col, dosS1TM4realSize);
numeric DNminCALCS1TM5 = DNminCALC(Scene1Lin, Scene1Col, dosS1TM5realSize);
numeric DNminCALCS1TM7 = DNminCALC(Scene1Lin, Scene1Col, dosS1TM7realSize);
for i = 1 to TMlins
{
for j = 1 to TMcols
{
if (IsNull(RADS1TM1[i,j]) == 0)
{
allValuesDosS1TM1[dosS1TM1realArrayCount] = RADS1TM1[i,j];
dosS1TM1realArrayCount = dosS1TM1realArrayCount + 1;
}
if (IsNull(RADS1TM2[i,j]) == 0)
{
allValuesDosS1TM2[dosS1TM2realArrayCount] = RADS1TM2[i,j];
dosS1TM2realArrayCount = dosS1TM2realArrayCount + 1;
}
if (IsNull(RADS1TM3[i,j]) == 0)
{
allValuesDosS1TM3[dosS1TM3realArrayCount] = RADS1TM3[i,j];
dosS1TM3realArrayCount = dosS1TM3realArrayCount + 1;
}
if (IsNull(RADS1TM4[i,j]) == 0)
{
allValuesDosS1TM4[dosS1TM4realArrayCount] = RADS1TM4[i,j];
dosS1TM4realArrayCount = dosS1TM4realArrayCount + 1;
}
if (IsNull(RADS1TM5[i,j]) == 0)
{
allValuesDosS1TM5[dosS1TM5realArrayCount] = RADS1TM5[i,j];
dosS1TM5realArrayCount = dosS1TM5realArrayCount + 1;
}
if (IsNull(RADS1TM7[i,j]) == 0)
{
allValuesDosS1TM7[dosS1TM7realArrayCount] = RADS1TM7[i,j];
dosS1TM7realArrayCount = dosS1TM7realArrayCount + 1;
}
}
}
########################### Scene 1 - Dn1000 - Band 1
numeric lastDOSS1TM1 = dosS1TM1realSize;
numeric hDOSS1TM1 = 1;
while ( (hDOSS1TM1 * 3 + 1) < lastDOSS1TM1 - 1 )
{
hDOSS1TM1 = 3 * hDOSS1TM1 + 1;
}
while ( hDOSS1TM1 > 0 )
{
for i = hDOSS1TM1 - 1 to lastDOSS1TM1 # for each of the h sets of elements
{
numeric keyDOSS1TM1 = allValuesDosS1TM1[i];
numeric jDOSS1TM1 = i;
while (jDOSS1TM1 >= hDOSS1TM1 && allValuesDosS1TM1[jDOSS1TM1 - hDOSS1TM1] > keyDOSS1TM1)
{
allValuesDosS1TM1[jDOSS1TM1] = allValuesDosS1TM1[jDOSS1TM1 - hDOSS1TM1];
jDOSS1TM1 = jDOSS1TM1 - hDOSS1TM1;
}
allValuesDosS1TM1[jDOSS1TM1] = keyDOSS1TM1;
}
hDOSS1TM1 = floor(hDOSS1TM1/3);
}
numeric minValueDosS1TM1 = allValuesDosS1TM1[1];
numeric dn1000S1TM1 = 10000;
numeric actualCountDosS1TM1 = 0;
for i = 1 to dosS1TM1realSize
{
if (allValuesDosS1TM1[i] == minValueDosS1TM1)
{
actualCountDosS1TM1 = actualCountDosS1TM1 + 1;
if (actualCountDosS1TM1 >= DNminCALCS1TM1)
{
dn1000S1TM1 = minValueDosS1TM1;
go to dn1000S1TM1jumper;
}
}
else
{
minValueDosS1TM1 = allValuesDosS1TM1[i+1];
actualCountDosS1TM1 = 0;
}
}
dn1000S1TM1jumper:
if (dn1000S1TM1 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S1TM1 = allValuesDosS1TM1[1];
}
if (dn1000S1TM1 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S1TM1 = allValuesDosS1TM1[1];
}
printf("dn1000 Scene 1 TM1: %12f\n", dn1000S1TM1);
########################### Scene 1 - Dn1000 - Band 2
numeric lastDOSS1TM2 = dosS1TM1realSize;
numeric hDOSS1TM2 = 1;
while ( (hDOSS1TM2 * 3 + 1) < lastDOSS1TM2 - 1 )
{
hDOSS1TM2 = 3 * hDOSS1TM2 + 1;
}
while ( hDOSS1TM2 > 0 )
{
for i = hDOSS1TM2 - 1 to lastDOSS1TM2
{
numeric keyDOSS1TM2 = allValuesDosS1TM2[i];
numeric jDOSS1TM2 = i;
while (jDOSS1TM2 >= hDOSS1TM2 && allValuesDosS1TM2[jDOSS1TM2 - hDOSS1TM2] > keyDOSS1TM2)
{
allValuesDosS1TM2[jDOSS1TM2] = allValuesDosS1TM2[jDOSS1TM2 - hDOSS1TM2];
jDOSS1TM2 = jDOSS1TM2 - hDOSS1TM2;
}
allValuesDosS1TM2[jDOSS1TM2] = keyDOSS1TM2;
}
hDOSS1TM2 = floor(hDOSS1TM2/3);
}
numeric minValueDosS1TM2 = allValuesDosS1TM2[1];
numeric dn1000S1TM2 = 10000;
numeric actualCountDosS1TM2 = 0;
for i = 1 to dosS1TM2realSize
{
if (allValuesDosS1TM2[i] == minValueDosS1TM2)
{
actualCountDosS1TM2 = actualCountDosS1TM2 + 1;
if (actualCountDosS1TM2 >= DNminCALCS1TM2)
{
dn1000S1TM2 = minValueDosS1TM2;
go to dn1000S1TM2jumper;
}
}
else
{
minValueDosS1TM2 = allValuesDosS1TM2[i+1];
actualCountDosS1TM2 = 0;
}
}
dn1000S1TM2jumper:
if (dn1000S1TM2 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S1TM2 = allValuesDosS1TM2[1];
}
if (dn1000S1TM2 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S1TM2 = allValuesDosS1TM2[1];
}
printf("dn1000 Scene 1 TM2: %12f\n", dn1000S1TM2);
########################### Scene 1 - Dn1000 - Band 3
numeric lastDOSS1TM3 = dosS1TM3realSize;
numeric hDOSS1TM3 = 1;
while ( (hDOSS1TM3 * 3 + 1) < lastDOSS1TM3 - 1 )
{
hDOSS1TM3 = 3 * hDOSS1TM3 + 1;
}
while ( hDOSS1TM3 > 0 )
{
for i = hDOSS1TM3 - 1 to lastDOSS1TM3 # for each of the h sets of elements
{
numeric keyDOSS1TM3 = allValuesDosS1TM3[i];
numeric jDOSS1TM3 = i;
while (jDOSS1TM3 >= hDOSS1TM3 && allValuesDosS1TM3[jDOSS1TM3 - hDOSS1TM3] > keyDOSS1TM3)
{
allValuesDosS1TM3[jDOSS1TM3] = allValuesDosS1TM3[jDOSS1TM3 - hDOSS1TM3];
jDOSS1TM3 = jDOSS1TM3 - hDOSS1TM3;
}
allValuesDosS1TM3[jDOSS1TM3] = keyDOSS1TM3;
}
hDOSS1TM3 = floor(hDOSS1TM3/3);
}
numeric minValueDosS1TM3 = allValuesDosS1TM3[1];
numeric dn1000S1TM3 = 10000;
numeric actualCountDosS1TM3 = 0;
for i = 1 to dosS1TM3realSize
{
if (allValuesDosS1TM3[i] == minValueDosS1TM3)
{
actualCountDosS1TM3 = actualCountDosS1TM3 + 1;
if (actualCountDosS1TM3 >= DNminCALCS1TM3)
{
dn1000S1TM3 = minValueDosS1TM3;
go to dn1000S1TM3jumper;
}
}
else
{
minValueDosS1TM3 = allValuesDosS1TM3[i+1];
actualCountDosS1TM3 = 0;
}
}
dn1000S1TM3jumper:
if (dn1000S1TM3 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S1TM3 = allValuesDosS1TM3[1];
}
if (dn1000S1TM3 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S1TM3 = allValuesDosS1TM3[1];
}
printf("dn1000 Scene 1 TM3: %12f\n", dn1000S1TM3);
########################### Scene 1 - Dn1000 - Band 4
numeric lastDOSS1TM4 = dosS1TM4realSize;
numeric hDOSS1TM4 = 1;
while ( (hDOSS1TM4 * 3 + 1) < lastDOSS1TM4 - 1 )
{
hDOSS1TM4 = 3 * hDOSS1TM4 + 1;
}
while ( hDOSS1TM4 > 0 )
{
for i = hDOSS1TM4 - 1 to lastDOSS1TM4
{
numeric keyDOSS1TM4 = allValuesDosS1TM4[i];
numeric jDOSS1TM4 = i;
while (jDOSS1TM4 >= hDOSS1TM4 && allValuesDosS1TM4[jDOSS1TM4 - hDOSS1TM4] > keyDOSS1TM4)
{
allValuesDosS1TM4[jDOSS1TM4] = allValuesDosS1TM4[jDOSS1TM4 - hDOSS1TM4];
jDOSS1TM4 = jDOSS1TM4 - hDOSS1TM4;
}
allValuesDosS1TM4[jDOSS1TM4] = keyDOSS1TM4;
}
hDOSS1TM4 = floor(hDOSS1TM4/3);
}
numeric minValueDosS1TM4 = allValuesDosS1TM4[1];
numeric dn1000S1TM4 = 10000;
numeric actualCountDosS1TM4 = 0;
for i = 1 to dosS1TM4realSize
{
if (allValuesDosS1TM4[i] == minValueDosS1TM4)
{
actualCountDosS1TM4 = actualCountDosS1TM4 + 1;
if (actualCountDosS1TM4 >= DNminCALCS1TM4)
{
dn1000S1TM4 = minValueDosS1TM4;
go to dn1000S1TM4jumper;
}
}
else
{
minValueDosS1TM4 = allValuesDosS1TM4[i+1];
actualCountDosS1TM4 = 0;
}
}
dn1000S1TM4jumper:
if (dn1000S1TM4 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S1TM4 = allValuesDosS1TM4[1];
}
if (dn1000S1TM4 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S1TM4 = allValuesDosS1TM4[1];
}
printf("dn1000 Scene 1 TM4: %12f\n", dn1000S1TM4);
########################### Scene 1 - Dn1000 - Band 5
numeric lastDOSS1TM5 = dosS1TM5realSize;
numeric hDOSS1TM5 = 1;
while ( (hDOSS1TM5 * 3 + 1) < lastDOSS1TM5 - 1 )
{
hDOSS1TM5 = 3 * hDOSS1TM5 + 1;
}
while ( hDOSS1TM5 > 0 )
{
for i = hDOSS1TM5 - 1 to lastDOSS1TM5 # for each of the h sets of elements
{
numeric keyDOSS1TM5 = allValuesDosS1TM5[i];
numeric jDOSS1TM5 = i;
while (jDOSS1TM5 >= hDOSS1TM5 && allValuesDosS1TM5[jDOSS1TM5 - hDOSS1TM5] > keyDOSS1TM5)
{
allValuesDosS1TM5[jDOSS1TM5] = allValuesDosS1TM5[jDOSS1TM5 - hDOSS1TM5];
jDOSS1TM5 = jDOSS1TM5 - hDOSS1TM5;
}
allValuesDosS1TM5[jDOSS1TM5] = keyDOSS1TM5;
}
hDOSS1TM5 = floor(hDOSS1TM5/3);
}
numeric minValueDosS1TM5 = allValuesDosS1TM5[1];
numeric dn1000S1TM5 = 10000;
numeric actualCountDosS1TM5 = 0;
for i = 1 to dosS1TM5realSize
{
if (allValuesDosS1TM5[i] == minValueDosS1TM5)
{
actualCountDosS1TM5 = actualCountDosS1TM5 + 1;
if (actualCountDosS1TM5 >= DNminCALCS1TM5)
{
dn1000S1TM5 = minValueDosS1TM5;
go to dn1000S1TM5jumper;
}
}
else
{
minValueDosS1TM5 = allValuesDosS1TM5[i+1];
actualCountDosS1TM5 = 0;
}
}
dn1000S1TM5jumper:
if (dn1000S1TM5 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S1TM5 = allValuesDosS1TM5[1];
}
if (dn1000S1TM5 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S1TM5 = allValuesDosS1TM5[1];
}
printf("dn1000 Scene 1 TM5: %12f\n", dn1000S1TM5);
########################### Scene 1 - Dn1000 - Band 7
numeric lastDOSS1TM7 = dosS1TM7realSize;
numeric hDOSS1TM7 = 1;
while ( (hDOSS1TM7 * 3 + 1) < lastDOSS1TM7 - 1 )
{
hDOSS1TM7 = 3 * hDOSS1TM7 + 1;
}
while ( hDOSS1TM7 > 0 )
{
for i = hDOSS1TM7 - 1 to lastDOSS1TM7 # for each of the h sets of elements
{
numeric keyDOSS1TM7 = allValuesDosS1TM7[i];
numeric jDOSS1TM7 = i;
while (jDOSS1TM7 >= hDOSS1TM7 && allValuesDosS1TM7[jDOSS1TM7 - hDOSS1TM7] > keyDOSS1TM7)
{
allValuesDosS1TM7[jDOSS1TM7] = allValuesDosS1TM7[jDOSS1TM7 - hDOSS1TM7];
jDOSS1TM7 = jDOSS1TM7 - hDOSS1TM7;
}
allValuesDosS1TM7[jDOSS1TM7] = keyDOSS1TM7;
}
hDOSS1TM7 = floor(hDOSS1TM7/3);
}
numeric minValueDosS1TM7 = allValuesDosS1TM7[1];
numeric dn1000S1TM7 = 10000;
numeric actualCountDosS1TM7 = 0;
for i = 1 to dosS1TM7realSize
{
if (allValuesDosS1TM7[i] == minValueDosS1TM7)
{
actualCountDosS1TM7 = actualCountDosS1TM7 + 1;
if (actualCountDosS1TM7 >= DNminCALCS1TM7)
{
dn1000S1TM7 = minValueDosS1TM7;
go to dn1000S1TM7jumper;
}
}
else
{
minValueDosS1TM7 = allValuesDosS1TM7[i+1];
actualCountDosS1TM7 = 0;
}
}
dn1000S1TM7jumper:
if (dn1000S1TM7 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S1TM7 = allValuesDosS1TM7[1];
}
if (dn1000S1TM7 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S1TM7 = allValuesDosS1TM7[1];
}
printf("dn1000 Scene 1 TM7: %12f\n\n", dn1000S1TM7);
################################### Pathradiance Calculation #######################################
numeric pathRadS1TM1 = dn1000S1TM1 - (0.01 * (radsurfTMS1b1 * cos(s1zenith)) / pi);
numeric pathRadS1TM2 = dn1000S1TM2 - (0.01 * (radsurfTMS1b2 * cos(s1zenith)) / pi);
numeric pathRadS1TM3 = dn1000S1TM3 - (0.01 * (radsurfTMS1b3 * cos(s1zenith)) / pi);
numeric pathRadS1TM4 = dn1000S1TM4 - (0.01 * (radsurfTMS1b4 * cos(s1zenith)) / pi);
numeric pathRadS1TM5 = dn1000S1TM5 - (0.01 * (radsurfTMS1b5 * cos(s1zenith)) / pi);
numeric pathRadS1TM7 = dn1000S1TM7 - (0.01 * (radsurfTMS1b7 * cos(s1zenith)) / pi);
printf("Pathradiance Scene 1 Band 1: %12f\n", pathRadS1TM1);
printf("Pathradiance Scene 1 Band 2: %12f\n", pathRadS1TM2);
printf("Pathradiance Scene 1 Band 3: %12f\n", pathRadS1TM3);
printf("Pathradiance Scene 1 Band 4: %12f\n", pathRadS1TM4);
printf("Pathradiance Scene 1 Band 5: %12f\n", pathRadS1TM5);
printf("Pathradiance Scene 1 Band 7: %12f\n\n", pathRadS1TM7);
################################# Reflectance Calculation with athmo correction
for i = 1 to TMlins
{
for j = 1 to TMcols
{
valueS1TM1 = (pi * (RADS1TM1[i,j] - pathRadS1TM1)) / (radsurfTMS1b1 * cos(s1zenith));
if ( valueS1TM1 < 0 )
{
valueS1TM1 = 0;
countS1REFnullTM1 = countS1REFnullTM1 + 1;
}
else if ( valueS1TM1 > 1 )
{
valueS1TM1 = 1;
countS1REFoneTM1 = countS1REFoneTM1 + 1;
}
REFS1TM1[i,j] = valueS1TM1;
valueS1TM2 = (pi * (RADS1TM2[i,j] - pathRadS1TM2)) / (radsurfTMS1b2 * cos(s1zenith));
if ( valueS1TM2 < 0 )
{
valueS1TM2 = 0;
countS1REFnullTM2 = countS1REFnullTM2 + 1;
}
else if ( valueS1TM2 > 1 )
{
valueS1TM2 = 1;
countS1REFoneTM2 = countS1REFoneTM2 + 1;
}
REFS1TM2[i,j] = valueS1TM2;
valueS1TM3 = (pi * (RADS1TM3[i,j] - pathRadS1TM3)) / (radsurfTMS1b3 * cos(s1zenith));
if ( valueS1TM3 < 0 )
{
valueS1TM3 = 0;
countS1REFnullTM3 = countS1REFnullTM3 + 1;
}
else if ( valueS1TM3 > 1 )
{
valueS1TM3 = 1;
countS1REFoneTM3 = countS1REFoneTM3 + 1;
}
REFS1TM3[i,j] = valueS1TM3;
valueS1TM4 = (pi * (RADS1TM4[i,j] - pathRadS1TM4)) / (radsurfTMS1b4 * cos(s1zenith));
if ( valueS1TM4 < 0 )
{
valueS1TM4 = 0;
countS1REFnullTM4 = countS1REFnullTM4 + 1;
}
else if ( valueS1TM4 > 1 )
{
valueS1TM4 = 1;
countS1REFoneTM4 = countS1REFoneTM4 + 1;
}
REFS1TM4[i,j] = valueS1TM4;
valueS1TM5 = (pi * (RADS1TM5[i,j] - pathRadS1TM5)) / (radsurfTMS1b5 * cos(s1zenith));
if ( valueS1TM5 < 0 )
{
valueS1TM5 = 0;
countS1REFnullTM5 = countS1REFnullTM5 + 1;
}
else if ( valueS1TM5 > 1 )
{
valueS1TM5 = 1;
countS1REFoneTM5 = countS1REFoneTM5 + 1;
}
REFS1TM5[i,j] = valueS1TM5;
valueS1TM7 = (pi * (RADS1TM7[i,j] - pathRadS1TM7)) / (radsurfTMS1b7 * cos(s1zenith));
if ( valueS1TM7 < 0 )
{
valueS1TM7 = 0;
countS1REFnullTM7 = countS1REFnullTM7 + 1;
}
else if ( valueS1TM7 > 1 )
{
valueS1TM7 = 1;
countS1REFoneTM7 = countS1REFoneTM7 + 1;
}
REFS1TM7[i,j] = valueS1TM7;
}
}
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 1 Band 1: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS1REFnullTM1, countS1REFoneTM1);
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 1 Band 2: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS1REFnullTM2, countS1REFoneTM2);
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 1 Band 3: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS1REFnullTM3, countS1REFoneTM3);
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 1 Band 4: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS1REFnullTM4, countS1REFoneTM4);
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 1 Band 5: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS1REFnullTM5, countS1REFoneTM5);
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 1 Band 7: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n\n", countS1REFnullTM7, countS1REFoneTM7);
CreatePyramid(REFS1TM1);
CreatePyramid(REFS1TM2);
CreatePyramid(REFS1TM3);
CreatePyramid(REFS1TM4);
CreatePyramid(REFS1TM5);
CreatePyramid(REFS1TM7);
CreateHistogram(REFS1TM1);
CreateHistogram(REFS1TM2);
CreateHistogram(REFS1TM3);
CreateHistogram(REFS1TM4);
CreateHistogram(REFS1TM5);
CreateHistogram(REFS1TM7);
CloseRaster(RADS1TM1);
CloseRaster(RADS1TM2);
CloseRaster(RADS1TM3);
CloseRaster(RADS1TM4);
CloseRaster(RADS1TM5);
CloseRaster(RADS1TM7);
printf("Reflectance calculation for Scene 1 (TM) is done...\n\n\n");
}
else if ( sensors1 == 5 ) # MSS 5 - Calib Werte nach Price J.C.1987
{
raster REFS1MSS1, REFS1MSS2, REFS1MSS3, REFS1MSS4;
numeric radsurfMSS1b1, radsurfMSS1b2, radsurfMSS1b3, radsurfMSS1b4;
numeric valueS1MSS1, valueS1MSS2, valueS1MSS3, valueS1MSS4;
numeric dosS1MSS1nullValCount = 0;
numeric dosS1MSS2nullValCount = 0;
numeric dosS1MSS3nullValCount = 0;
numeric dosS1MSS4nullValCount = 0;
numeric dosS1MSS1realArrayCount = 1;
numeric dosS1MSS2realArrayCount = 1;
numeric dosS1MSS3realArrayCount = 1;
numeric dosS1MSS4realArrayCount = 1;
numeric countS1REFnullMSS1 = 0;
numeric countS1REFnullMSS2 = 0;
numeric countS1REFnullMSS3 = 0;
numeric countS1REFnullMSS4 = 0;
numeric countS1REFoneMSS1 = 0;
numeric countS1REFoneMSS2 = 0;
numeric countS1REFoneMSS3 = 0;
numeric countS1REFoneMSS4 = 0;
radsurfMSS1b1 = ESMSS51 / (dist1^2);
radsurfMSS1b2 = ESMSS52 / (dist1^2);
radsurfMSS1b3 = ESMSS53 / (dist1^2);
radsurfMSS1b4 = ESMSS54 / (dist1^2);
printf("Surface Radiance MSS Band 1 in W/m^2µm (Scene 1): %12f\n", radsurfMSS1b1);
printf("Surface Radiance MSS Band 2 in W/m^2µm (Scene 1): %12f\n", radsurfMSS1b2);
printf("Surface Radiance MSS Band 3 in W/m^2µm (Scene 1): %12f\n", radsurfMSS1b3);
printf("Surface Radiance MSS Band 4 in W/m^2µm (Scene 1): %12f\n\n", radsurfMSS1b4);
for i = 1 to MSSlins
{
for j = 1 to MSScols
{
if (IsNull(RADS1MSS1[i,j]) == 1)
{
dosS1MSS1nullValCount = dosS1MSS1nullValCount + 1;
}
if (IsNull(RADS1MSS2[i,j]) == 1)
{
dosS1MSS2nullValCount = dosS1MSS2nullValCount + 1;
}
if (IsNull(RADS1MSS3[i,j]) == 1)
{
dosS1MSS3nullValCount = dosS1MSS3nullValCount + 1;
}
if (IsNull(RADS1MSS4[i,j]) == 1)
{
dosS1MSS4nullValCount = dosS1MSS4nullValCount + 1;
}
}
}
numeric dosS1MSS1realSize = (MSSlins * MSScols) - dosS1MSS1nullValCount;
numeric dosS1MSS2realSize = (MSSlins * MSScols) - dosS1MSS2nullValCount;
numeric dosS1MSS3realSize = (MSSlins * MSScols) - dosS1MSS3nullValCount;
numeric dosS1MSS4realSize = (MSSlins * MSScols) - dosS1MSS4nullValCount;
array allValuesDosS1MSS1[dosS1MSS1realSize];
array allValuesDosS1MSS2[dosS1MSS2realSize];
array allValuesDosS1MSS3[dosS1MSS3realSize];
array allValuesDosS1MSS4[dosS1MSS4realSize];
numeric DNminCALCS1MSS1 = DNminCALC(Scene1Lin, Scene1Col, dosS1MSS1realSize);
numeric DNminCALCS1MSS2 = DNminCALC(Scene1Lin, Scene1Col, dosS1MSS2realSize);
numeric DNminCALCS1MSS3 = DNminCALC(Scene1Lin, Scene1Col, dosS1MSS3realSize);
numeric DNminCALCS1MSS4 = DNminCALC(Scene1Lin, Scene1Col, dosS1MSS4realSize);
for i = 1 to MSSlins
{
for j = 1 to MSScols
{
if (IsNull(RADS1MSS1[i,j]) == 0)
{
allValuesDosS1MSS1[dosS1MSS1realArrayCount] = RADS1MSS1[i,j];
dosS1MSS1realArrayCount = dosS1MSS1realArrayCount + 1;
}
if (IsNull(RADS1MSS2[i,j]) == 0)
{
allValuesDosS1MSS2[dosS1MSS2realArrayCount] = RADS1MSS2[i,j];
dosS1MSS2realArrayCount = dosS1MSS2realArrayCount + 1;
}
if (IsNull(RADS1MSS3[i,j]) == 0)
{
allValuesDosS1MSS3[dosS1MSS3realArrayCount] = RADS1MSS3[i,j];
dosS1MSS3realArrayCount = dosS1MSS3realArrayCount + 1;
}
if (IsNull(RADS1MSS4[i,j]) == 0)
{
allValuesDosS1MSS4[dosS1MSS4realArrayCount] = RADS1MSS4[i,j];
dosS1MSS4realArrayCount = dosS1MSS4realArrayCount + 1;
}
}
}
########################### Scene 1 - Dn1000 - Band 1
numeric lastDOSS1MSS1 = dosS1MSS1realSize;
numeric hDOSS1MSS1 = 1;
while ( (hDOSS1MSS1 * 3 + 1) < lastDOSS1MSS1 - 1 )
{
hDOSS1MSS1 = 3 * hDOSS1MSS1 + 1;
}
while ( hDOSS1MSS1 > 0 )
{
for i = hDOSS1MSS1 - 1 to lastDOSS1MSS1 # for each of the h sets of elements
{
numeric keyDOSS1MSS1 = allValuesDosS1MSS1[i];
numeric jDOSS1MSS1 = i;
while (jDOSS1MSS1 >= hDOSS1MSS1 && allValuesDosS1MSS1[jDOSS1MSS1 - hDOSS1MSS1] > keyDOSS1MSS1)
{
allValuesDosS1MSS1[jDOSS1MSS1] = allValuesDosS1MSS1[jDOSS1MSS1 - hDOSS1MSS1];
jDOSS1MSS1 = jDOSS1MSS1 - hDOSS1MSS1;
}
allValuesDosS1MSS1[jDOSS1MSS1] = keyDOSS1MSS1;
}
hDOSS1MSS1 = floor(hDOSS1MSS1/3);
}
numeric minValueDosS1MSS1 = allValuesDosS1MSS1[1];
numeric dn1000S1MSS1 = 10000;
numeric actualCountDosS1MSS1 = 0;
for i = 1 to dosS1MSS1realSize
{
if (allValuesDosS1MSS1[i] == minValueDosS1MSS1)
{
actualCountDosS1MSS1 = actualCountDosS1MSS1 + 1;
if (actualCountDosS1MSS1 >= DNminCALCS1MSS1)
{
dn1000S1MSS1 = minValueDosS1MSS1;
go to dn1000S1MSS1jumper;
}
}
else
{
minValueDosS1MSS1 = allValuesDosS1MSS1[i+1];
actualCountDosS1MSS1 = 0;
}
}
dn1000S1MSS1jumper:
if (dn1000S1MSS1 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S1MSS1 = allValuesDosS1MSS1[1];
}
if (dn1000S1MSS1 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S1MSS1 = allValuesDosS1MSS1[1];
}
printf("dn1000 Scene 1 MSS1: %12f\n", dn1000S1MSS1);
########################### Scene 1 - Dn1000 - Band 2
numeric lastDOSS1MSS2 = dosS1MSS1realSize;
numeric hDOSS1MSS2 = 1;
while ( (hDOSS1MSS2 * 3 + 1) < lastDOSS1MSS2 - 1 )
{
hDOSS1MSS2 = 3 * hDOSS1MSS2 + 1;
}
while ( hDOSS1MSS2 > 0 )
{
for i = hDOSS1MSS2 - 1 to lastDOSS1MSS2
{
numeric keyDOSS1MSS2 = allValuesDosS1MSS2[i];
numeric jDOSS1MSS2 = i;
while (jDOSS1MSS2 >= hDOSS1MSS2 && allValuesDosS1MSS2[jDOSS1MSS2 - hDOSS1MSS2] > keyDOSS1MSS2)
{
allValuesDosS1MSS2[jDOSS1MSS2] = allValuesDosS1MSS2[jDOSS1MSS2 - hDOSS1MSS2];
jDOSS1MSS2 = jDOSS1MSS2 - hDOSS1MSS2;
}
allValuesDosS1MSS2[jDOSS1MSS2] = keyDOSS1MSS2;
}
hDOSS1MSS2 = floor(hDOSS1MSS2/3);
}
numeric minValueDosS1MSS2 = allValuesDosS1MSS2[1];
numeric dn1000S1MSS2 = 10000;
numeric actualCountDosS1MSS2 = 0;
for i = 1 to dosS1MSS2realSize
{
if (allValuesDosS1MSS2[i] == minValueDosS1MSS2)
{
actualCountDosS1MSS2 = actualCountDosS1MSS2 + 1;
if (actualCountDosS1MSS2 >= DNminCALCS1MSS2)
{
dn1000S1MSS2 = minValueDosS1MSS2;
go to dn1000S1MSS2jumper;
}
}
else
{
minValueDosS1MSS2 = allValuesDosS1MSS2[i+1];
actualCountDosS1MSS2 = 0;
}
}
dn1000S1MSS2jumper:
if (dn1000S1MSS2 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S1MSS2 = allValuesDosS1MSS2[1];
}
if (dn1000S1MSS2 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S1MSS2 = allValuesDosS1MSS2[1];
}
printf("dn1000 Scene 1 MSS2: %12f\n", dn1000S1MSS2);
########################### Scene 1 - Dn1000 - Band 3
numeric lastDOSS1MSS3 = dosS1MSS3realSize;
numeric hDOSS1MSS3 = 1;
while ( (hDOSS1MSS3 * 3 + 1) < lastDOSS1MSS3 - 1 )
{
hDOSS1MSS3 = 3 * hDOSS1MSS3 + 1;
}
while ( hDOSS1MSS3 > 0 )
{
for i = hDOSS1MSS3 - 1 to lastDOSS1MSS3 # for each of the h sets of elements
{
numeric keyDOSS1MSS3 = allValuesDosS1MSS3[i];
numeric jDOSS1MSS3 = i;
while (jDOSS1MSS3 >= hDOSS1MSS3 && allValuesDosS1MSS3[jDOSS1MSS3 - hDOSS1MSS3] > keyDOSS1MSS3)
{
allValuesDosS1MSS3[jDOSS1MSS3] = allValuesDosS1MSS3[jDOSS1MSS3 - hDOSS1MSS3];
jDOSS1MSS3 = jDOSS1MSS3 - hDOSS1MSS3;
}
allValuesDosS1MSS3[jDOSS1MSS3] = keyDOSS1MSS3;
}
hDOSS1MSS3 = floor(hDOSS1MSS3/3);
}
numeric minValueDosS1MSS3 = allValuesDosS1MSS3[1];
numeric dn1000S1MSS3 = 10000;
numeric actualCountDosS1MSS3 = 0;
for i = 1 to dosS1MSS3realSize
{
if (allValuesDosS1MSS3[i] == minValueDosS1MSS3)
{
actualCountDosS1MSS3 = actualCountDosS1MSS3 + 1;
if (actualCountDosS1MSS3 >= DNminCALCS1MSS3)
{
dn1000S1MSS3 = minValueDosS1MSS3;
go to dn1000S1MSS3jumper;
}
}
else
{
minValueDosS1MSS3 = allValuesDosS1MSS3[i+1];
actualCountDosS1MSS3 = 0;
}
}
dn1000S1MSS3jumper:
if (dn1000S1MSS3 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S1MSS3 = allValuesDosS1MSS3[1];
}
if (dn1000S1MSS3 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S1MSS3 = allValuesDosS1MSS3[1];
}
printf("dn1000 Scene 1 MSS3: %12f\n", dn1000S1MSS3);
########################### Scene 1 - Dn1000 - Band 4
numeric lastDOSS1MSS4 = dosS1MSS4realSize;
numeric hDOSS1MSS4 = 1;
while ( (hDOSS1MSS4 * 3 + 1) < lastDOSS1MSS4 - 1 )
{
hDOSS1MSS4 = 3 * hDOSS1MSS4 + 1;
}
while ( hDOSS1MSS4 > 0 )
{
for i = hDOSS1MSS4 - 1 to lastDOSS1MSS4
{
numeric keyDOSS1MSS4 = allValuesDosS1MSS4[i];
numeric jDOSS1MSS4 = i;
while (jDOSS1MSS4 >= hDOSS1MSS4 && allValuesDosS1MSS4[jDOSS1MSS4 - hDOSS1MSS4] > keyDOSS1MSS4)
{
allValuesDosS1MSS4[jDOSS1MSS4] = allValuesDosS1MSS4[jDOSS1MSS4 - hDOSS1MSS4];
jDOSS1MSS4 = jDOSS1MSS4 - hDOSS1MSS4;
}
allValuesDosS1MSS4[jDOSS1MSS4] = keyDOSS1MSS4;
}
hDOSS1MSS4 = floor(hDOSS1MSS4/3);
}
numeric minValueDosS1MSS4 = allValuesDosS1MSS4[1];
numeric dn1000S1MSS4 = 10000;
numeric actualCountDosS1MSS4 = 0;
for i = 1 to dosS1MSS4realSize
{
if (allValuesDosS1MSS4[i] == minValueDosS1MSS4)
{
actualCountDosS1MSS4 = actualCountDosS1MSS4 + 1;
if (actualCountDosS1MSS4 >= DNminCALCS1MSS4)
{
dn1000S1MSS4 = minValueDosS1MSS4;
go to dn1000S1MSS4jumper;
}
}
else
{
minValueDosS1MSS4 = allValuesDosS1MSS4[i+1];
actualCountDosS1MSS4 = 0;
}
}
dn1000S1MSS4jumper:
if (dn1000S1MSS4 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S1MSS4 = allValuesDosS1MSS4[1];
}
if (dn1000S1MSS4 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S1MSS4 = allValuesDosS1MSS4[1];
}
printf("dn1000 Scene 1 MSS4: %12f\n", dn1000S1MSS4);
################################### Pathradiance Calculation #######################################
numeric pathRadS1MSS1 = dn1000S1MSS1 - (0.01 * (radsurfMSS1b1 * cos(s1zenith)) / pi);
numeric pathRadS1MSS2 = dn1000S1MSS2 - (0.01 * (radsurfMSS1b2 * cos(s1zenith)) / pi);
numeric pathRadS1MSS3 = dn1000S1MSS3 - (0.01 * (radsurfMSS1b3 * cos(s1zenith)) / pi);
numeric pathRadS1MSS4 = dn1000S1MSS4 - (0.01 * (radsurfMSS1b4 * cos(s1zenith)) / pi);
printf("Pathradiance Scene 1 Band 1: %12f\n", pathRadS1MSS1);
printf("Pathradiance Scene 1 Band 2: %12f\n", pathRadS1MSS2);
printf("Pathradiance Scene 1 Band 3: %12f\n", pathRadS1MSS3);
printf("Pathradiance Scene 1 Band 4: %12f\n\n", pathRadS1MSS4);
################################# Reflectance Calculation with athmo correction
for i = 1 to MSSlins
{
for j = 1 to MSScols
{
valueS1MSS1 = (pi * (RADS1MSS1[i,j] - pathRadS1MSS1)) / (radsurfMSS1b1 * cos(s1zenith));
if ( valueS1MSS1 < 0 )
{
valueS1MSS1 = 0;
countS1REFnullMSS1 = countS1REFnullMSS1 + 1;
}
else if ( valueS1MSS1 > 1 )
{
valueS1MSS1 = 1;
countS1REFoneMSS1 = countS1REFoneMSS1 + 1;
}
REFS1MSS1[i,j] = valueS1MSS1;
valueS1MSS2 = (pi * (RADS1MSS2[i,j] - pathRadS1MSS2)) / (radsurfMSS1b2 * cos(s1zenith));
if ( valueS1MSS2 < 0 )
{
valueS1MSS2 = 0;
countS1REFnullMSS2 = countS1REFnullMSS2 + 1;
}
else if ( valueS1MSS2 > 1 )
{
valueS1MSS2 = 1;
countS1REFoneMSS2 = countS1REFoneMSS2 + 1;
}
REFS1MSS2[i,j] = valueS1MSS2;
valueS1MSS3 = (pi * (RADS1MSS3[i,j] - pathRadS1MSS3)) / (radsurfMSS1b3 * cos(s1zenith));
if ( valueS1MSS3 < 0 )
{
valueS1MSS3 = 0;
countS1REFnullMSS3 = countS1REFnullMSS3 + 1;
}
else if ( valueS1MSS3 > 1 )
{
valueS1MSS3 = 1;
countS1REFoneMSS3 = countS1REFoneMSS3 + 1;
}
REFS1MSS3[i,j] = valueS1MSS3;
valueS1MSS4 = (pi * (RADS1MSS4[i,j] - pathRadS1MSS4)) / (radsurfMSS1b4 * cos(s1zenith));
if ( valueS1MSS4 < 0 )
{
valueS1MSS4 = 0;
countS1REFnullMSS4 = countS1REFnullMSS4 + 1;
}
else if ( valueS1MSS4 > 1 )
{
valueS1MSS4 = 1;
countS1REFoneMSS4 = countS1REFoneMSS4 + 1;
}
REFS1MSS4[i,j] = valueS1MSS4;
}
}
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 1 Band 1: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS1REFnullMSS1, countS1REFoneMSS1);
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 1 Band 2: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS1REFnullMSS2, countS1REFoneMSS2);
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 1 Band 3: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS1REFnullMSS3, countS1REFoneMSS3);
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 1 Band 4: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS1REFnullMSS4, countS1REFoneMSS4);
CreatePyramid(REFS1MSS1);
CreatePyramid(REFS1MSS2);
CreatePyramid(REFS1MSS3);
CreatePyramid(REFS1MSS4);
CreateHistogram(REFS1MSS1);
CreateHistogram(REFS1MSS2);
CreateHistogram(REFS1MSS3);
CreateHistogram(REFS1MSS4);
CloseRaster(RADS1MSS1);
CloseRaster(RADS1MSS2);
CloseRaster(RADS1MSS3);
CloseRaster(RADS1MSS4);
printf("Reflectance calculation for Scene 1 (MSS) is done...\n\n\n");
}
else if ( sensors1 == 4 ) # MSS 4
{
raster REFS1MSS1, REFS1MSS2, REFS1MSS3, REFS1MSS4;
numeric radsurfMSS1b1, radsurfMSS1b2, radsurfMSS1b3, radsurfMSS1b4;
numeric valueS1MSS1, valueS1MSS2, valueS1MSS3, valueS1MSS4;
numeric dosS1MSS1nullValCount = 0;
numeric dosS1MSS2nullValCount = 0;
numeric dosS1MSS3nullValCount = 0;
numeric dosS1MSS4nullValCount = 0;
numeric dosS1MSS1realArrayCount = 1;
numeric dosS1MSS2realArrayCount = 1;
numeric dosS1MSS3realArrayCount = 1;
numeric dosS1MSS4realArrayCount = 1;
numeric countS1REFnullMSS1 = 0;
numeric countS1REFnullMSS2 = 0;
numeric countS1REFnullMSS3 = 0;
numeric countS1REFnullMSS4 = 0;
numeric countS1REFoneMSS1 = 0;
numeric countS1REFoneMSS2 = 0;
numeric countS1REFoneMSS3 = 0;
numeric countS1REFoneMSS4 = 0;
radsurfMSS1b1 = ESMSS41 / (dist1^2);
radsurfMSS1b2 = ESMSS42 / (dist1^2);
radsurfMSS1b3 = ESMSS43 / (dist1^2);
radsurfMSS1b4 = ESMSS44 / (dist1^2);
printf("Surface Radiance MSS Band 1 in W/m^2µm (Scene 1): %12f\n", radsurfMSS1b1);
printf("Surface Radiance MSS Band 2 in W/m^2µm (Scene 1): %12f\n", radsurfMSS1b2);
printf("Surface Radiance MSS Band 3 in W/m^2µm (Scene 1): %12f\n", radsurfMSS1b3);
printf("Surface Radiance MSS Band 4 in W/m^2µm (Scene 1): %12f\n\n", radsurfMSS1b4);
for i = 1 to MSSlins
{
for j = 1 to MSScols
{
if (IsNull(RADS1MSS1[i,j]) == 1)
{
dosS1MSS1nullValCount = dosS1MSS1nullValCount + 1;
}
if (IsNull(RADS1MSS2[i,j]) == 1)
{
dosS1MSS2nullValCount = dosS1MSS2nullValCount + 1;
}
if (IsNull(RADS1MSS3[i,j]) == 1)
{
dosS1MSS3nullValCount = dosS1MSS3nullValCount + 1;
}
if (IsNull(RADS1MSS4[i,j]) == 1)
{
dosS1MSS4nullValCount = dosS1MSS4nullValCount + 1;
}
}
}
numeric dosS1MSS1realSize = (MSSlins * MSScols) - dosS1MSS1nullValCount;
numeric dosS1MSS2realSize = (MSSlins * MSScols) - dosS1MSS2nullValCount;
numeric dosS1MSS3realSize = (MSSlins * MSScols) - dosS1MSS3nullValCount;
numeric dosS1MSS4realSize = (MSSlins * MSScols) - dosS1MSS4nullValCount;
array allValuesDosS1MSS1[dosS1MSS1realSize];
array allValuesDosS1MSS2[dosS1MSS2realSize];
array allValuesDosS1MSS3[dosS1MSS3realSize];
array allValuesDosS1MSS4[dosS1MSS4realSize];
numeric DNminCALCS1MSS1 = DNminCALC(Scene1Lin, Scene1Col, dosS1MSS1realSize);
numeric DNminCALCS1MSS2 = DNminCALC(Scene1Lin, Scene1Col, dosS1MSS2realSize);
numeric DNminCALCS1MSS3 = DNminCALC(Scene1Lin, Scene1Col, dosS1MSS3realSize);
numeric DNminCALCS1MSS4 = DNminCALC(Scene1Lin, Scene1Col, dosS1MSS4realSize);
for i = 1 to MSSlins
{
for j = 1 to MSScols
{
if (IsNull(RADS1MSS1[i,j]) == 0)
{
allValuesDosS1MSS1[dosS1MSS1realArrayCount] = RADS1MSS1[i,j];
dosS1MSS1realArrayCount = dosS1MSS1realArrayCount + 1;
}
if (IsNull(RADS1MSS2[i,j]) == 0)
{
allValuesDosS1MSS2[dosS1MSS2realArrayCount] = RADS1MSS2[i,j];
dosS1MSS2realArrayCount = dosS1MSS2realArrayCount + 1;
}
if (IsNull(RADS1MSS3[i,j]) == 0)
{
allValuesDosS1MSS3[dosS1MSS3realArrayCount] = RADS1MSS3[i,j];
dosS1MSS3realArrayCount = dosS1MSS3realArrayCount + 1;
}
if (IsNull(RADS1MSS4[i,j]) == 0)
{
allValuesDosS1MSS4[dosS1MSS4realArrayCount] = RADS1MSS4[i,j];
dosS1MSS4realArrayCount = dosS1MSS4realArrayCount + 1;
}
}
}
########################### Scene 1 - Dn1000 - Band 1
numeric lastDOSS1MSS1 = dosS1MSS1realSize;
numeric hDOSS1MSS1 = 1;
while ( (hDOSS1MSS1 * 3 + 1) < lastDOSS1MSS1 - 1 )
{
hDOSS1MSS1 = 3 * hDOSS1MSS1 + 1;
}
while ( hDOSS1MSS1 > 0 )
{
for i = hDOSS1MSS1 - 1 to lastDOSS1MSS1 # for each of the h sets of elements
{
numeric keyDOSS1MSS1 = allValuesDosS1MSS1[i];
numeric jDOSS1MSS1 = i;
while (jDOSS1MSS1 >= hDOSS1MSS1 && allValuesDosS1MSS1[jDOSS1MSS1 - hDOSS1MSS1] > keyDOSS1MSS1)
{
allValuesDosS1MSS1[jDOSS1MSS1] = allValuesDosS1MSS1[jDOSS1MSS1 - hDOSS1MSS1];
jDOSS1MSS1 = jDOSS1MSS1 - hDOSS1MSS1;
}
allValuesDosS1MSS1[jDOSS1MSS1] = keyDOSS1MSS1;
}
hDOSS1MSS1 = floor(hDOSS1MSS1/3);
}
numeric minValueDosS1MSS1 = allValuesDosS1MSS1[1];
numeric dn1000S1MSS1 = 10000;
numeric actualCountDosS1MSS1 = 0;
for i = 1 to dosS1MSS1realSize
{
if (allValuesDosS1MSS1[i] == minValueDosS1MSS1)
{
actualCountDosS1MSS1 = actualCountDosS1MSS1 + 1;
if (actualCountDosS1MSS1 >= DNminCALCS1MSS1)
{
dn1000S1MSS1 = minValueDosS1MSS1;
go to dn1000S1MSS1jumper;
}
}
else
{
minValueDosS1MSS1 = allValuesDosS1MSS1[i+1];
actualCountDosS1MSS1 = 0;
}
}
dn1000S1MSS1jumper:
if (dn1000S1MSS1 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S1MSS1 = allValuesDosS1MSS1[1];
}
if (dn1000S1MSS1 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S1MSS1 = allValuesDosS1MSS1[1];
}
printf("dn1000 Scene 1 MSS1: %12f\n", dn1000S1MSS1);
########################### Scene 1 - Dn1000 - Band 2
numeric lastDOSS1MSS2 = dosS1MSS1realSize;
numeric hDOSS1MSS2 = 1;
while ( (hDOSS1MSS2 * 3 + 1) < lastDOSS1MSS2 - 1 )
{
hDOSS1MSS2 = 3 * hDOSS1MSS2 + 1;
}
while ( hDOSS1MSS2 > 0 )
{
for i = hDOSS1MSS2 - 1 to lastDOSS1MSS2
{
numeric keyDOSS1MSS2 = allValuesDosS1MSS2[i];
numeric jDOSS1MSS2 = i;
while (jDOSS1MSS2 >= hDOSS1MSS2 && allValuesDosS1MSS2[jDOSS1MSS2 - hDOSS1MSS2] > keyDOSS1MSS2)
{
allValuesDosS1MSS2[jDOSS1MSS2] = allValuesDosS1MSS2[jDOSS1MSS2 - hDOSS1MSS2];
jDOSS1MSS2 = jDOSS1MSS2 - hDOSS1MSS2;
}
allValuesDosS1MSS2[jDOSS1MSS2] = keyDOSS1MSS2;
}
hDOSS1MSS2 = floor(hDOSS1MSS2/3);
}
numeric minValueDosS1MSS2 = allValuesDosS1MSS2[1];
numeric dn1000S1MSS2 = 10000;
numeric actualCountDosS1MSS2 = 0;
for i = 1 to dosS1MSS2realSize
{
if (allValuesDosS1MSS2[i] == minValueDosS1MSS2)
{
actualCountDosS1MSS2 = actualCountDosS1MSS2 + 1;
if (actualCountDosS1MSS2 >= DNminCALCS1MSS2)
{
dn1000S1MSS2 = minValueDosS1MSS2;
go to dn1000S1MSS2jumper;
}
}
else
{
minValueDosS1MSS2 = allValuesDosS1MSS2[i+1];
actualCountDosS1MSS2 = 0;
}
}
dn1000S1MSS2jumper:
if (dn1000S1MSS2 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S1MSS2 = allValuesDosS1MSS2[1];
}
if (dn1000S1MSS2 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S1MSS2 = allValuesDosS1MSS2[1];
}
printf("dn1000 Scene 1 MSS2: %12f\n", dn1000S1MSS2);
########################### Scene 1 - Dn1000 - Band 3
numeric lastDOSS1MSS3 = dosS1MSS3realSize;
numeric hDOSS1MSS3 = 1;
while ( (hDOSS1MSS3 * 3 + 1) < lastDOSS1MSS3 - 1 )
{
hDOSS1MSS3 = 3 * hDOSS1MSS3 + 1;
}
while ( hDOSS1MSS3 > 0 )
{
for i = hDOSS1MSS3 - 1 to lastDOSS1MSS3 # for each of the h sets of elements
{
numeric keyDOSS1MSS3 = allValuesDosS1MSS3[i];
numeric jDOSS1MSS3 = i;
while (jDOSS1MSS3 >= hDOSS1MSS3 && allValuesDosS1MSS3[jDOSS1MSS3 - hDOSS1MSS3] > keyDOSS1MSS3)
{
allValuesDosS1MSS3[jDOSS1MSS3] = allValuesDosS1MSS3[jDOSS1MSS3 - hDOSS1MSS3];
jDOSS1MSS3 = jDOSS1MSS3 - hDOSS1MSS3;
}
allValuesDosS1MSS3[jDOSS1MSS3] = keyDOSS1MSS3;
}
hDOSS1MSS3 = floor(hDOSS1MSS3/3);
}
numeric minValueDosS1MSS3 = allValuesDosS1MSS3[1];
numeric dn1000S1MSS3 = 10000;
numeric actualCountDosS1MSS3 = 0;
for i = 1 to dosS1MSS3realSize
{
if (allValuesDosS1MSS3[i] == minValueDosS1MSS3)
{
actualCountDosS1MSS3 = actualCountDosS1MSS3 + 1;
if (actualCountDosS1MSS3 >= DNminCALCS1MSS3)
{
dn1000S1MSS3 = minValueDosS1MSS3;
go to dn1000S1MSS3jumper;
}
}
else
{
minValueDosS1MSS3 = allValuesDosS1MSS3[i+1];
actualCountDosS1MSS3 = 0;
}
}
dn1000S1MSS3jumper:
if (dn1000S1MSS3 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S1MSS3 = allValuesDosS1MSS3[1];
}
if (dn1000S1MSS3 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S1MSS3 = allValuesDosS1MSS3[1];
}
printf("dn1000 Scene 1 MSS3: %12f\n", dn1000S1MSS3);
########################### Scene 1 - Dn1000 - Band 4
numeric lastDOSS1MSS4 = dosS1MSS4realSize;
numeric hDOSS1MSS4 = 1;
while ( (hDOSS1MSS4 * 3 + 1) < lastDOSS1MSS4 - 1 )
{
hDOSS1MSS4 = 3 * hDOSS1MSS4 + 1;
}
while ( hDOSS1MSS4 > 0 )
{
for i = hDOSS1MSS4 - 1 to lastDOSS1MSS4
{
numeric keyDOSS1MSS4 = allValuesDosS1MSS4[i];
numeric jDOSS1MSS4 = i;
while (jDOSS1MSS4 >= hDOSS1MSS4 && allValuesDosS1MSS4[jDOSS1MSS4 - hDOSS1MSS4] > keyDOSS1MSS4)
{
allValuesDosS1MSS4[jDOSS1MSS4] = allValuesDosS1MSS4[jDOSS1MSS4 - hDOSS1MSS4];
jDOSS1MSS4 = jDOSS1MSS4 - hDOSS1MSS4;
}
allValuesDosS1MSS4[jDOSS1MSS4] = keyDOSS1MSS4;
}
hDOSS1MSS4 = floor(hDOSS1MSS4/3);
}
numeric minValueDosS1MSS4 = allValuesDosS1MSS4[1];
numeric dn1000S1MSS4 = 10000;
numeric actualCountDosS1MSS4 = 0;
for i = 1 to dosS1MSS4realSize
{
if (allValuesDosS1MSS4[i] == minValueDosS1MSS4)
{
actualCountDosS1MSS4 = actualCountDosS1MSS4 + 1;
if (actualCountDosS1MSS4 >= DNminCALCS1MSS4)
{
dn1000S1MSS4 = minValueDosS1MSS4;
go to dn1000S1MSS4jumper;
}
}
else
{
minValueDosS1MSS4 = allValuesDosS1MSS4[i+1];
actualCountDosS1MSS4 = 0;
}
}
dn1000S1MSS4jumper:
if (dn1000S1MSS4 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S1MSS4 = allValuesDosS1MSS4[1];
}
if (dn1000S1MSS4 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S1MSS4 = allValuesDosS1MSS4[1];
}
printf("dn1000 Scene 1 MSS4: %12f\n", dn1000S1MSS4);
################################### Pathradiance Calculation #######################################
numeric pathRadS1MSS1 = dn1000S1MSS1 - (0.01 * (radsurfMSS1b1 * cos(s1zenith)) / pi);
numeric pathRadS1MSS2 = dn1000S1MSS2 - (0.01 * (radsurfMSS1b2 * cos(s1zenith)) / pi);
numeric pathRadS1MSS3 = dn1000S1MSS3 - (0.01 * (radsurfMSS1b3 * cos(s1zenith)) / pi);
numeric pathRadS1MSS4 = dn1000S1MSS4 - (0.01 * (radsurfMSS1b4 * cos(s1zenith)) / pi);
printf("Pathradiance Scene 1 Band 1: %12f\n", pathRadS1MSS1);
printf("Pathradiance Scene 1 Band 2: %12f\n", pathRadS1MSS2);
printf("Pathradiance Scene 1 Band 3: %12f\n", pathRadS1MSS3);
printf("Pathradiance Scene 1 Band 4: %12f\n\n", pathRadS1MSS4);
################################# Reflectance Calculation with athmo correction
for i = 1 to MSSlins
{
for j = 1 to MSScols
{
valueS1MSS1 = (pi * (RADS1MSS1[i,j] - pathRadS1MSS1)) / (radsurfMSS1b1 * cos(s1zenith));
if ( valueS1MSS1 < 0 )
{
valueS1MSS1 = 0;
countS1REFnullMSS1 = countS1REFnullMSS1 + 1;
}
else if ( valueS1MSS1 > 1 )
{
valueS1MSS1 = 1;
countS1REFoneMSS1 = countS1REFoneMSS1 + 1;
}
REFS1MSS1[i,j] = valueS1MSS1;
valueS1MSS2 = (pi * (RADS1MSS2[i,j] - pathRadS1MSS2)) / (radsurfMSS1b2 * cos(s1zenith));
if ( valueS1MSS2 < 0 )
{
valueS1MSS2 = 0;
countS1REFnullMSS2 = countS1REFnullMSS2 + 1;
}
else if ( valueS1MSS2 > 1 )
{
valueS1MSS2 = 1;
countS1REFoneMSS2 = countS1REFoneMSS2 + 1;
}
REFS1MSS2[i,j] = valueS1MSS2;
valueS1MSS3 = (pi * (RADS1MSS3[i,j] - pathRadS1MSS3)) / (radsurfMSS1b3 * cos(s1zenith));
if ( valueS1MSS3 < 0 )
{
valueS1MSS3 = 0;
countS1REFnullMSS3 = countS1REFnullMSS3 + 1;
}
else if ( valueS1MSS3 > 1 )
{
valueS1MSS3 = 1;
countS1REFoneMSS3 = countS1REFoneMSS3 + 1;
}
REFS1MSS3[i,j] = valueS1MSS3;
valueS1MSS4 = (pi * (RADS1MSS4[i,j] - pathRadS1MSS4)) / (radsurfMSS1b4 * cos(s1zenith));
if ( valueS1MSS4 < 0 )
{
valueS1MSS4 = 0;
countS1REFnullMSS4 = countS1REFnullMSS4 + 1;
}
else if ( valueS1MSS4 > 1 )
{
valueS1MSS4 = 1;
countS1REFoneMSS4 = countS1REFoneMSS4 + 1;
}
REFS1MSS4[i,j] = valueS1MSS4;
}
}
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 1 Band 1: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS1REFnullMSS1, countS1REFoneMSS1);
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 1 Band 2: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS1REFnullMSS2, countS1REFoneMSS2);
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 1 Band 3: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS1REFnullMSS3, countS1REFoneMSS3);
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 1 Band 4: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS1REFnullMSS4, countS1REFoneMSS4);
CreatePyramid(REFS1MSS1);
CreatePyramid(REFS1MSS2);
CreatePyramid(REFS1MSS3);
CreatePyramid(REFS1MSS4);
CreateHistogram(REFS1MSS1);
CreateHistogram(REFS1MSS2);
CreateHistogram(REFS1MSS3);
CreateHistogram(REFS1MSS4);
CloseRaster(RADS1MSS1);
CloseRaster(RADS1MSS2);
CloseRaster(RADS1MSS3);
CloseRaster(RADS1MSS4);
printf("Reflectance calculation for Scene 1 (MSS) is done...\n\n\n");
}
else # MSS 1, 2 and 3
{
raster REFS1MSS1, REFS1MSS2, REFS1MSS3, REFS1MSS4;
numeric radsurfMSS1b1, radsurfMSS1b2, radsurfMSS1b3, radsurfMSS1b4;
numeric valueS1MSS1, valueS1MSS2, valueS1MSS3, valueS1MSS4;
numeric dosS1MSS1nullValCount = 0;
numeric dosS1MSS2nullValCount = 0;
numeric dosS1MSS3nullValCount = 0;
numeric dosS1MSS4nullValCount = 0;
numeric dosS1MSS1realArrayCount = 1;
numeric dosS1MSS2realArrayCount = 1;
numeric dosS1MSS3realArrayCount = 1;
numeric dosS1MSS4realArrayCount = 1;
numeric countS1REFnullMSS1 = 0;
numeric countS1REFnullMSS2 = 0;
numeric countS1REFnullMSS3 = 0;
numeric countS1REFnullMSS4 = 0;
numeric countS1REFoneMSS1 = 0;
numeric countS1REFoneMSS2 = 0;
numeric countS1REFoneMSS3 = 0;
numeric countS1REFoneMSS4 = 0;
radsurfMSS1b1 = ESMSS11 / (dist1^2);
radsurfMSS1b2 = ESMSS12 / (dist1^2);
radsurfMSS1b3 = ESMSS13 / (dist1^2);
radsurfMSS1b4 = ESMSS14 / (dist1^2);
printf("Surface Radiance MSS Band 1 in W/m^2µm (Scene 1): %12f\n", radsurfMSS1b1);
printf("Surface Radiance MSS Band 2 in W/m^2µm (Scene 1): %12f\n", radsurfMSS1b2);
printf("Surface Radiance MSS Band 3 in W/m^2µm (Scene 1): %12f\n", radsurfMSS1b3);
printf("Surface Radiance MSS Band 4 in W/m^2µm (Scene 1): %12f\n\n", radsurfMSS1b4);
for i = 1 to MSSlins
{
for j = 1 to MSScols
{
if (IsNull(RADS1MSS1[i,j]) == 1)
{
dosS1MSS1nullValCount = dosS1MSS1nullValCount + 1;
}
if (IsNull(RADS1MSS2[i,j]) == 1)
{
dosS1MSS2nullValCount = dosS1MSS2nullValCount + 1;
}
if (IsNull(RADS1MSS3[i,j]) == 1)
{
dosS1MSS3nullValCount = dosS1MSS3nullValCount + 1;
}
if (IsNull(RADS1MSS4[i,j]) == 1)
{
dosS1MSS4nullValCount = dosS1MSS4nullValCount + 1;
}
}
}
numeric dosS1MSS1realSize = (MSSlins * MSScols) - dosS1MSS1nullValCount;
numeric dosS1MSS2realSize = (MSSlins * MSScols) - dosS1MSS2nullValCount;
numeric dosS1MSS3realSize = (MSSlins * MSScols) - dosS1MSS3nullValCount;
numeric dosS1MSS4realSize = (MSSlins * MSScols) - dosS1MSS4nullValCount;
array allValuesDosS1MSS1[dosS1MSS1realSize];
array allValuesDosS1MSS2[dosS1MSS2realSize];
array allValuesDosS1MSS3[dosS1MSS3realSize];
array allValuesDosS1MSS4[dosS1MSS4realSize];
numeric DNminCALCS1MSS1 = DNminCALC(Scene1Lin, Scene1Col, dosS1MSS1realSize);
numeric DNminCALCS1MSS2 = DNminCALC(Scene1Lin, Scene1Col, dosS1MSS2realSize);
numeric DNminCALCS1MSS3 = DNminCALC(Scene1Lin, Scene1Col, dosS1MSS3realSize);
numeric DNminCALCS1MSS4 = DNminCALC(Scene1Lin, Scene1Col, dosS1MSS4realSize);
for i = 1 to MSSlins
{
for j = 1 to MSScols
{
if (IsNull(RADS1MSS1[i,j]) == 0)
{
allValuesDosS1MSS1[dosS1MSS1realArrayCount] = RADS1MSS1[i,j];
dosS1MSS1realArrayCount = dosS1MSS1realArrayCount + 1;
}
if (IsNull(RADS1MSS2[i,j]) == 0)
{
allValuesDosS1MSS2[dosS1MSS2realArrayCount] = RADS1MSS2[i,j];
dosS1MSS2realArrayCount = dosS1MSS2realArrayCount + 1;
}
if (IsNull(RADS1MSS3[i,j]) == 0)
{
allValuesDosS1MSS3[dosS1MSS3realArrayCount] = RADS1MSS3[i,j];
dosS1MSS3realArrayCount = dosS1MSS3realArrayCount + 1;
}
if (IsNull(RADS1MSS4[i,j]) == 0)
{
allValuesDosS1MSS4[dosS1MSS4realArrayCount] = RADS1MSS4[i,j];
dosS1MSS4realArrayCount = dosS1MSS4realArrayCount + 1;
}
}
}
########################### Scene 1 - Dn1000 - Band 1
numeric lastDOSS1MSS1 = dosS1MSS1realSize;
numeric hDOSS1MSS1 = 1;
while ( (hDOSS1MSS1 * 3 + 1) < lastDOSS1MSS1 - 1 )
{
hDOSS1MSS1 = 3 * hDOSS1MSS1 + 1;
}
while ( hDOSS1MSS1 > 0 )
{
for i = hDOSS1MSS1 - 1 to lastDOSS1MSS1 # for each of the h sets of elements
{
numeric keyDOSS1MSS1 = allValuesDosS1MSS1[i];
numeric jDOSS1MSS1 = i;
while (jDOSS1MSS1 >= hDOSS1MSS1 && allValuesDosS1MSS1[jDOSS1MSS1 - hDOSS1MSS1] > keyDOSS1MSS1)
{
allValuesDosS1MSS1[jDOSS1MSS1] = allValuesDosS1MSS1[jDOSS1MSS1 - hDOSS1MSS1];
jDOSS1MSS1 = jDOSS1MSS1 - hDOSS1MSS1;
}
allValuesDosS1MSS1[jDOSS1MSS1] = keyDOSS1MSS1;
}
hDOSS1MSS1 = floor(hDOSS1MSS1/3);
}
numeric minValueDosS1MSS1 = allValuesDosS1MSS1[1];
numeric dn1000S1MSS1 = 10000;
numeric actualCountDosS1MSS1 = 0;
for i = 1 to dosS1MSS1realSize
{
if (allValuesDosS1MSS1[i] == minValueDosS1MSS1)
{
actualCountDosS1MSS1 = actualCountDosS1MSS1 + 1;
if (actualCountDosS1MSS1 >= DNminCALCS1MSS1)
{
dn1000S1MSS1 = minValueDosS1MSS1;
go to dn1000S1MSS1jumper;
}
}
else
{
minValueDosS1MSS1 = allValuesDosS1MSS1[i+1];
actualCountDosS1MSS1 = 0;
}
}
dn1000S1MSS1jumper:
if (dn1000S1MSS1 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S1MSS1 = allValuesDosS1MSS1[1];
}
if (dn1000S1MSS1 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S1MSS1 = allValuesDosS1MSS1[1];
}
printf("dn1000 Scene 1 MSS1: %12f\n", dn1000S1MSS1);
########################### Scene 1 - Dn1000 - Band 2
numeric lastDOSS1MSS2 = dosS1MSS1realSize;
numeric hDOSS1MSS2 = 1;
while ( (hDOSS1MSS2 * 3 + 1) < lastDOSS1MSS2 - 1 )
{
hDOSS1MSS2 = 3 * hDOSS1MSS2 + 1;
}
while ( hDOSS1MSS2 > 0 )
{
for i = hDOSS1MSS2 - 1 to lastDOSS1MSS2
{
numeric keyDOSS1MSS2 = allValuesDosS1MSS2[i];
numeric jDOSS1MSS2 = i;
while (jDOSS1MSS2 >= hDOSS1MSS2 && allValuesDosS1MSS2[jDOSS1MSS2 - hDOSS1MSS2] > keyDOSS1MSS2)
{
allValuesDosS1MSS2[jDOSS1MSS2] = allValuesDosS1MSS2[jDOSS1MSS2 - hDOSS1MSS2];
jDOSS1MSS2 = jDOSS1MSS2 - hDOSS1MSS2;
}
allValuesDosS1MSS2[jDOSS1MSS2] = keyDOSS1MSS2;
}
hDOSS1MSS2 = floor(hDOSS1MSS2/3);
}
numeric minValueDosS1MSS2 = allValuesDosS1MSS2[1];
numeric dn1000S1MSS2 = 10000;
numeric actualCountDosS1MSS2 = 0;
for i = 1 to dosS1MSS2realSize
{
if (allValuesDosS1MSS2[i] == minValueDosS1MSS2)
{
actualCountDosS1MSS2 = actualCountDosS1MSS2 + 1;
if (actualCountDosS1MSS2 >= DNminCALCS1MSS2)
{
dn1000S1MSS2 = minValueDosS1MSS2;
go to dn1000S1MSS2jumper;
}
}
else
{
minValueDosS1MSS2 = allValuesDosS1MSS2[i+1];
actualCountDosS1MSS2 = 0;
}
}
dn1000S1MSS2jumper:
if (dn1000S1MSS2 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S1MSS2 = allValuesDosS1MSS2[1];
}
if (dn1000S1MSS2 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S1MSS2 = allValuesDosS1MSS2[1];
}
printf("dn1000 Scene 1 MSS2: %12f\n", dn1000S1MSS2);
########################### Scene 1 - Dn1000 - Band 3
numeric lastDOSS1MSS3 = dosS1MSS3realSize;
numeric hDOSS1MSS3 = 1;
while ( (hDOSS1MSS3 * 3 + 1) < lastDOSS1MSS3 - 1 )
{
hDOSS1MSS3 = 3 * hDOSS1MSS3 + 1;
}
while ( hDOSS1MSS3 > 0 )
{
for i = hDOSS1MSS3 - 1 to lastDOSS1MSS3 # for each of the h sets of elements
{
numeric keyDOSS1MSS3 = allValuesDosS1MSS3[i];
numeric jDOSS1MSS3 = i;
while (jDOSS1MSS3 >= hDOSS1MSS3 && allValuesDosS1MSS3[jDOSS1MSS3 - hDOSS1MSS3] > keyDOSS1MSS3)
{
allValuesDosS1MSS3[jDOSS1MSS3] = allValuesDosS1MSS3[jDOSS1MSS3 - hDOSS1MSS3];
jDOSS1MSS3 = jDOSS1MSS3 - hDOSS1MSS3;
}
allValuesDosS1MSS3[jDOSS1MSS3] = keyDOSS1MSS3;
}
hDOSS1MSS3 = floor(hDOSS1MSS3/3);
}
numeric minValueDosS1MSS3 = allValuesDosS1MSS3[1];
numeric dn1000S1MSS3 = 10000;
numeric actualCountDosS1MSS3 = 0;
for i = 1 to dosS1MSS3realSize
{
if (allValuesDosS1MSS3[i] == minValueDosS1MSS3)
{
actualCountDosS1MSS3 = actualCountDosS1MSS3 + 1;
if (actualCountDosS1MSS3 >= DNminCALCS1MSS3)
{
dn1000S1MSS3 = minValueDosS1MSS3;
go to dn1000S1MSS3jumper;
}
}
else
{
minValueDosS1MSS3 = allValuesDosS1MSS3[i+1];
actualCountDosS1MSS3 = 0;
}
}
dn1000S1MSS3jumper:
if (dn1000S1MSS3 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S1MSS3 = allValuesDosS1MSS3[1];
}
if (dn1000S1MSS3 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S1MSS3 = allValuesDosS1MSS3[1];
}
printf("dn1000 Scene 1 MSS3: %12f\n", dn1000S1MSS3);
########################### Scene 1 - Dn1000 - Band 4
numeric lastDOSS1MSS4 = dosS1MSS4realSize;
numeric hDOSS1MSS4 = 1;
while ( (hDOSS1MSS4 * 3 + 1) < lastDOSS1MSS4 - 1 )
{
hDOSS1MSS4 = 3 * hDOSS1MSS4 + 1;
}
while ( hDOSS1MSS4 > 0 )
{
for i = hDOSS1MSS4 - 1 to lastDOSS1MSS4
{
numeric keyDOSS1MSS4 = allValuesDosS1MSS4[i];
numeric jDOSS1MSS4 = i;
while (jDOSS1MSS4 >= hDOSS1MSS4 && allValuesDosS1MSS4[jDOSS1MSS4 - hDOSS1MSS4] > keyDOSS1MSS4)
{
allValuesDosS1MSS4[jDOSS1MSS4] = allValuesDosS1MSS4[jDOSS1MSS4 - hDOSS1MSS4];
jDOSS1MSS4 = jDOSS1MSS4 - hDOSS1MSS4;
}
allValuesDosS1MSS4[jDOSS1MSS4] = keyDOSS1MSS4;
}
hDOSS1MSS4 = floor(hDOSS1MSS4/3);
}
numeric minValueDosS1MSS4 = allValuesDosS1MSS4[1];
numeric dn1000S1MSS4 = 10000;
numeric actualCountDosS1MSS4 = 0;
for i = 1 to dosS1MSS4realSize
{
if (allValuesDosS1MSS4[i] == minValueDosS1MSS4)
{
actualCountDosS1MSS4 = actualCountDosS1MSS4 + 1;
if (actualCountDosS1MSS4 >= DNminCALCS1MSS4)
{
dn1000S1MSS4 = minValueDosS1MSS4;
go to dn1000S1MSS4jumper;
}
}
else
{
minValueDosS1MSS4 = allValuesDosS1MSS4[i+1];
actualCountDosS1MSS4 = 0;
}
}
dn1000S1MSS4jumper:
if (dn1000S1MSS4 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S1MSS4 = allValuesDosS1MSS4[1];
}
if (dn1000S1MSS4 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S1MSS4 = allValuesDosS1MSS4[1];
}
printf("dn1000 Scene 1 MSS4: %12f\n", dn1000S1MSS4);
################################### Pathradiance Calculation #######################################
numeric pathRadS1MSS1 = dn1000S1MSS1 - (0.01 * (radsurfMSS1b1 * cos(s1zenith)) / pi);
numeric pathRadS1MSS2 = dn1000S1MSS2 - (0.01 * (radsurfMSS1b2 * cos(s1zenith)) / pi);
numeric pathRadS1MSS3 = dn1000S1MSS3 - (0.01 * (radsurfMSS1b3 * cos(s1zenith)) / pi);
numeric pathRadS1MSS4 = dn1000S1MSS4 - (0.01 * (radsurfMSS1b4 * cos(s1zenith)) / pi);
printf("Pathradiance Scene 1 Band 1: %12f\n", pathRadS1MSS1);
printf("Pathradiance Scene 1 Band 2: %12f\n", pathRadS1MSS2);
printf("Pathradiance Scene 1 Band 3: %12f\n", pathRadS1MSS3);
printf("Pathradiance Scene 1 Band 4: %12f\n\n", pathRadS1MSS4);
################################# Reflectance Calculation with athmo correction
for i = 1 to MSSlins
{
for j = 1 to MSScols
{
valueS1MSS1 = (pi * (RADS1MSS1[i,j] - pathRadS1MSS1)) / (radsurfMSS1b1 * cos(s1zenith));
if ( valueS1MSS1 < 0 )
{
valueS1MSS1 = 0;
countS1REFnullMSS1 = countS1REFnullMSS1 + 1;
}
else if ( valueS1MSS1 > 1 )
{
valueS1MSS1 = 1;
countS1REFoneMSS1 = countS1REFoneMSS1 + 1;
}
REFS1MSS1[i,j] = valueS1MSS1;
valueS1MSS2 = (pi * (RADS1MSS2[i,j] - pathRadS1MSS2)) / (radsurfMSS1b2 * cos(s1zenith));
if ( valueS1MSS2 < 0 )
{
valueS1MSS2 = 0;
countS1REFnullMSS2 = countS1REFnullMSS2 + 1;
}
else if ( valueS1MSS2 > 1 )
{
valueS1MSS2 = 1;
countS1REFoneMSS2 = countS1REFoneMSS2 + 1;
}
REFS1MSS2[i,j] = valueS1MSS2;
valueS1MSS3 = (pi * (RADS1MSS3[i,j] - pathRadS1MSS3)) / (radsurfMSS1b3 * cos(s1zenith));
if ( valueS1MSS3 < 0 )
{
valueS1MSS3 = 0;
countS1REFnullMSS3 = countS1REFnullMSS3 + 1;
}
else if ( valueS1MSS3 > 1 )
{
valueS1MSS3 = 1;
countS1REFoneMSS3 = countS1REFoneMSS3 + 1;
}
REFS1MSS3[i,j] = valueS1MSS3;
valueS1MSS4 = (pi * (RADS1MSS4[i,j] - pathRadS1MSS4)) / (radsurfMSS1b4 * cos(s1zenith));
if ( valueS1MSS4 < 0 )
{
valueS1MSS4 = 0;
countS1REFnullMSS4 = countS1REFnullMSS4 + 1;
}
else if ( valueS1MSS4 > 1 )
{
valueS1MSS4 = 1;
countS1REFoneMSS4 = countS1REFoneMSS4 + 1;
}
REFS1MSS4[i,j] = valueS1MSS4;
}
}
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 1 Band 1: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS1REFnullMSS1, countS1REFoneMSS1);
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 1 Band 2: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS1REFnullMSS2, countS1REFoneMSS2);
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 1 Band 3: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS1REFnullMSS3, countS1REFoneMSS3);
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 1 Band 4: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS1REFnullMSS4, countS1REFoneMSS4);
CreatePyramid(REFS1MSS1);
CreatePyramid(REFS1MSS2);
CreatePyramid(REFS1MSS3);
CreatePyramid(REFS1MSS4);
CreateHistogram(REFS1MSS1);
CreateHistogram(REFS1MSS2);
CreateHistogram(REFS1MSS3);
CreateHistogram(REFS1MSS4);
CloseRaster(RADS1MSS1);
CloseRaster(RADS1MSS2);
CloseRaster(RADS1MSS3);
CloseRaster(RADS1MSS4);
printf("Reflectance calculation for Scene 1 (MSS) is done...\n\n\n");
}
#############################
#### Reflectance Scene 2
#############################
if ( sensors2 == 7 )
{
raster REFS2ETM1, REFS2ETM2, REFS2ETM3, REFS2ETM4, REFS2ETM5, REFS2ETM7;
numeric radsurfETMS2b1, radsurfETMS2b2, radsurfETMS2b3, radsurfETMS2b4, radsurfETMS2b5, radsurfETMS2b7;
numeric valueS2ETM1, valueS2ETM2, valueS2ETM3, valueS2ETM4, valueS2ETM5, valueS2ETM7;
numeric dosS2ETM1nullValCount = 0;
numeric dosS2ETM2nullValCount = 0;
numeric dosS2ETM3nullValCount = 0;
numeric dosS2ETM4nullValCount = 0;
numeric dosS2ETM5nullValCount = 0;
numeric dosS2ETM7nullValCount = 0;
numeric dosS2ETM1realArrayCount = 1;
numeric dosS2ETM2realArrayCount = 1;
numeric dosS2ETM3realArrayCount = 1;
numeric dosS2ETM4realArrayCount = 1;
numeric dosS2ETM5realArrayCount = 1;
numeric dosS2ETM7realArrayCount = 1;
numeric countS2REFnullETM1 = 0;
numeric countS2REFnullETM2 = 0;
numeric countS2REFnullETM3 = 0;
numeric countS2REFnullETM4 = 0;
numeric countS2REFnullETM5 = 0;
numeric countS2REFnullETM7 = 0;
numeric countS2REFoneETM1 = 0;
numeric countS2REFoneETM2 = 0;
numeric countS2REFoneETM3 = 0;
numeric countS2REFoneETM4 = 0;
numeric countS2REFoneETM5 = 0;
numeric countS2REFoneETM7 = 0;
radsurfETMS2b1 = ESETM1 / (dist2^2);
radsurfETMS2b2 = ESETM2 / (dist2^2);
radsurfETMS2b3 = ESETM3 / (dist2^2);
radsurfETMS2b4 = ESETM4 / (dist2^2);
radsurfETMS2b5 = ESETM5 / (dist2^2);
radsurfETMS2b7 = ESETM7 / (dist2^2);
printf("Surface Radiance ETM Band 1 in W/m^2µm (Scene 2): %12f\n", radsurfETMS2b1);
printf("Surface Radiance ETM Band 2 in W/m^2µm (Scene 2): %12f\n", radsurfETMS2b2);
printf("Surface Radiance ETM Band 3 in W/m^2µm (Scene 2): %12f\n", radsurfETMS2b3);
printf("Surface Radiance ETM Band 4 in W/m^2µm (Scene 2): %12f\n", radsurfETMS2b4);
printf("Surface Radiance ETM Band 5 in W/m^2µm (Scene 2): %12f\n", radsurfETMS2b5);
printf("Surface Radiance ETM Band 7 in W/m^2µm (Scene 2): %12f\n\n", radsurfETMS2b7);
for i = 1 to ETMlins
{
for j = 1 to ETMcols
{
if (IsNull(RADS2ETM1[i,j]) == 1)
{
dosS2ETM1nullValCount = dosS2ETM1nullValCount + 1;
}
if (IsNull(RADS2ETM2[i,j]) == 1)
{
dosS2ETM2nullValCount = dosS2ETM2nullValCount + 1;
}
if (IsNull(RADS2ETM3[i,j]) == 1)
{
dosS2ETM3nullValCount = dosS2ETM3nullValCount + 1;
}
if (IsNull(RADS2ETM4[i,j]) == 1)
{
dosS2ETM4nullValCount = dosS2ETM4nullValCount + 1;
}
if (IsNull(RADS2ETM5[i,j]) == 1)
{
dosS2ETM5nullValCount = dosS2ETM5nullValCount + 1;
}
if (IsNull(RADS2ETM7[i,j]) == 1)
{
dosS2ETM7nullValCount = dosS2ETM7nullValCount + 1;
}
}
}
numeric dosS2ETM1realSize = (ETMlins * ETMcols) - dosS2ETM1nullValCount;
numeric dosS2ETM2realSize = (ETMlins * ETMcols) - dosS2ETM2nullValCount;
numeric dosS2ETM3realSize = (ETMlins * ETMcols) - dosS2ETM3nullValCount;
numeric dosS2ETM4realSize = (ETMlins * ETMcols) - dosS2ETM4nullValCount;
numeric dosS2ETM5realSize = (ETMlins * ETMcols) - dosS2ETM5nullValCount;
numeric dosS2ETM7realSize = (ETMlins * ETMcols) - dosS2ETM7nullValCount;
array allValuesDosS2ETM1[dosS2ETM1realSize];
array allValuesDosS2ETM2[dosS2ETM2realSize];
array allValuesDosS2ETM3[dosS2ETM3realSize];
array allValuesDosS2ETM4[dosS2ETM4realSize];
array allValuesDosS2ETM5[dosS2ETM5realSize];
array allValuesDosS2ETM7[dosS2ETM7realSize];
numeric DNminCALCS2ETM1 = DNminCALC(Scene2Lin, Scene2Col, dosS2ETM1realSize);
numeric DNminCALCS2ETM2 = DNminCALC(Scene2Lin, Scene2Col, dosS2ETM2realSize);
numeric DNminCALCS2ETM3 = DNminCALC(Scene2Lin, Scene2Col, dosS2ETM3realSize);
numeric DNminCALCS2ETM4 = DNminCALC(Scene2Lin, Scene2Col, dosS2ETM4realSize);
numeric DNminCALCS2ETM5 = DNminCALC(Scene2Lin, Scene2Col, dosS2ETM5realSize);
numeric DNminCALCS2ETM7 = DNminCALC(Scene2Lin, Scene2Col, dosS2ETM7realSize);
for i = 1 to ETMlins
{
for j = 1 to ETMcols
{
if (IsNull(RADS2ETM1[i,j]) == 0)
{
allValuesDosS2ETM1[dosS2ETM1realArrayCount] = RADS2ETM1[i,j];
dosS2ETM1realArrayCount = dosS2ETM1realArrayCount + 1;
}
if (IsNull(RADS2ETM2[i,j]) == 0)
{
allValuesDosS2ETM2[dosS2ETM2realArrayCount] = RADS2ETM2[i,j];
dosS2ETM2realArrayCount = dosS2ETM2realArrayCount + 1;
}
if (IsNull(RADS2ETM3[i,j]) == 0)
{
allValuesDosS2ETM3[dosS2ETM3realArrayCount] = RADS2ETM3[i,j];
dosS2ETM3realArrayCount = dosS2ETM3realArrayCount + 1;
}
if (IsNull(RADS2ETM4[i,j]) == 0)
{
allValuesDosS2ETM4[dosS2ETM4realArrayCount] = RADS2ETM4[i,j];
dosS2ETM4realArrayCount = dosS2ETM4realArrayCount + 1;
}
if (IsNull(RADS2ETM5[i,j]) == 0)
{
allValuesDosS2ETM5[dosS2ETM5realArrayCount] = RADS2ETM5[i,j];
dosS2ETM5realArrayCount = dosS2ETM5realArrayCount + 1;
}
if (IsNull(RADS2ETM7[i,j]) == 0)
{
allValuesDosS2ETM7[dosS2ETM7realArrayCount] = RADS2ETM7[i,j];
dosS2ETM7realArrayCount = dosS2ETM7realArrayCount + 1;
}
}
}
########################### Scene 2 - Dn1000 - Band 1
numeric lastDOSS2ETM1 = dosS2ETM1realSize;
numeric hDOSS2ETM1 = 1;
while ( (hDOSS2ETM1 * 3 + 1) < lastDOSS2ETM1 - 1 )
{
hDOSS2ETM1 = 3 * hDOSS2ETM1 + 1;
}
while ( hDOSS2ETM1 > 0 )
{
for i = hDOSS2ETM1 - 1 to lastDOSS2ETM1 # for each of the h sets of elements
{
numeric keyDOSS2ETM1 = allValuesDosS2ETM1[i];
numeric jDOSS2ETM1 = i;
while (jDOSS2ETM1 >= hDOSS2ETM1 && allValuesDosS2ETM1[jDOSS2ETM1 - hDOSS2ETM1] > keyDOSS2ETM1)
{
allValuesDosS2ETM1[jDOSS2ETM1] = allValuesDosS2ETM1[jDOSS2ETM1 - hDOSS2ETM1];
jDOSS2ETM1 = jDOSS2ETM1 - hDOSS2ETM1;
}
allValuesDosS2ETM1[jDOSS2ETM1] = keyDOSS2ETM1;
}
hDOSS2ETM1 = floor(hDOSS2ETM1/3);
}
numeric minValueDosS2ETM1 = allValuesDosS2ETM1[1];
numeric dn1000S2ETM1 = 10000;
numeric actualCountDosS2ETM1 = 0;
for i = 1 to dosS2ETM1realSize
{
if (allValuesDosS2ETM1[i] == minValueDosS2ETM1)
{
actualCountDosS2ETM1 = actualCountDosS2ETM1 + 1;
if (actualCountDosS2ETM1 >= DNminCALCS2ETM1)
{
dn1000S2ETM1 = minValueDosS2ETM1;
go to dn1000S2ETM1jumper;
}
}
else
{
minValueDosS2ETM1 = allValuesDosS2ETM1[i+1];
actualCountDosS2ETM1 = 0;
}
}
dn1000S2ETM1jumper:
if (dn1000S2ETM1 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S2ETM1 = allValuesDosS2ETM1[1];
}
if (dn1000S2ETM1 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S2ETM1 = allValuesDosS2ETM1[1];
}
printf("dn1000 Scene 2 ETM1: %12f\n", dn1000S2ETM1);
########################### Scene 2 - Dn1000 - Band 2
numeric lastDOSS2ETM2 = dosS2ETM1realSize;
numeric hDOSS2ETM2 = 1;
while ( (hDOSS2ETM2 * 3 + 1) < lastDOSS2ETM2 - 1 )
{
hDOSS2ETM2 = 3 * hDOSS2ETM2 + 1;
}
while ( hDOSS2ETM2 > 0 )
{
for i = hDOSS2ETM2 - 1 to lastDOSS2ETM2
{
numeric keyDOSS2ETM2 = allValuesDosS2ETM2[i];
numeric jDOSS2ETM2 = i;
while (jDOSS2ETM2 >= hDOSS2ETM2 && allValuesDosS2ETM2[jDOSS2ETM2 - hDOSS2ETM2] > keyDOSS2ETM2)
{
allValuesDosS2ETM2[jDOSS2ETM2] = allValuesDosS2ETM2[jDOSS2ETM2 - hDOSS2ETM2];
jDOSS2ETM2 = jDOSS2ETM2 - hDOSS2ETM2;
}
allValuesDosS2ETM2[jDOSS2ETM2] = keyDOSS2ETM2;
}
hDOSS2ETM2 = floor(hDOSS2ETM2/3);
}
numeric minValueDosS2ETM2 = allValuesDosS2ETM2[1];
numeric dn1000S2ETM2 = 10000;
numeric actualCountDosS2ETM2 = 0;
for i = 1 to dosS2ETM2realSize
{
if (allValuesDosS2ETM2[i] == minValueDosS2ETM2)
{
actualCountDosS2ETM2 = actualCountDosS2ETM2 + 1;
if (actualCountDosS2ETM2 >= DNminCALCS2ETM2)
{
dn1000S2ETM2 = minValueDosS2ETM2;
go to dn1000S2ETM2jumper;
}
}
else
{
minValueDosS2ETM2 = allValuesDosS2ETM2[i+1];
actualCountDosS2ETM2 = 0;
}
}
dn1000S2ETM2jumper:
if (dn1000S2ETM2 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S2ETM2 = allValuesDosS2ETM2[1];
}
if (dn1000S2ETM2 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S2ETM2 = allValuesDosS2ETM2[1];
}
printf("dn1000 Scene 2 ETM2: %12f\n", dn1000S2ETM2);
########################### Scene 2 - Dn1000 - Band 3
numeric lastDOSS2ETM3 = dosS2ETM3realSize;
numeric hDOSS2ETM3 = 1;
while ( (hDOSS2ETM3 * 3 + 1) < lastDOSS2ETM3 - 1 )
{
hDOSS2ETM3 = 3 * hDOSS2ETM3 + 1;
}
while ( hDOSS2ETM3 > 0 )
{
for i = hDOSS2ETM3 - 1 to lastDOSS2ETM3 # for each of the h sets of elements
{
numeric keyDOSS2ETM3 = allValuesDosS2ETM3[i];
numeric jDOSS2ETM3 = i;
while (jDOSS2ETM3 >= hDOSS2ETM3 && allValuesDosS2ETM3[jDOSS2ETM3 - hDOSS2ETM3] > keyDOSS2ETM3)
{
allValuesDosS2ETM3[jDOSS2ETM3] = allValuesDosS2ETM3[jDOSS2ETM3 - hDOSS2ETM3];
jDOSS2ETM3 = jDOSS2ETM3 - hDOSS2ETM3;
}
allValuesDosS2ETM3[jDOSS2ETM3] = keyDOSS2ETM3;
}
hDOSS2ETM3 = floor(hDOSS2ETM3/3);
}
numeric minValueDosS2ETM3 = allValuesDosS2ETM3[1];
numeric dn1000S2ETM3 = 10000;
numeric actualCountDosS2ETM3 = 0;
for i = 1 to dosS2ETM3realSize
{
if (allValuesDosS2ETM3[i] == minValueDosS2ETM3)
{
actualCountDosS2ETM3 = actualCountDosS2ETM3 + 1;
if (actualCountDosS2ETM3 >= DNminCALCS2ETM3)
{
dn1000S2ETM3 = minValueDosS2ETM3;
go to dn1000S2ETM3jumper;
}
}
else
{
minValueDosS2ETM3 = allValuesDosS2ETM3[i+1];
actualCountDosS2ETM3 = 0;
}
}
dn1000S2ETM3jumper:
if (dn1000S2ETM3 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S2ETM3 = allValuesDosS2ETM3[1];
}
if (dn1000S2ETM3 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S2ETM3 = allValuesDosS2ETM3[1];
}
printf("dn1000 Scene 2 ETM3: %12f\n", dn1000S2ETM3);
########################### Scene 1 - Dn1000 - Band 4
numeric lastDOSS2ETM4 = dosS2ETM4realSize;
numeric hDOSS2ETM4 = 1;
while ( (hDOSS2ETM4 * 3 + 1) < lastDOSS2ETM4 - 1 )
{
hDOSS2ETM4 = 3 * hDOSS2ETM4 + 1;
}
while ( hDOSS2ETM4 > 0 )
{
for i = hDOSS2ETM4 - 1 to lastDOSS2ETM4
{
numeric keyDOSS2ETM4 = allValuesDosS2ETM4[i];
numeric jDOSS2ETM4 = i;
while (jDOSS2ETM4 >= hDOSS2ETM4 && allValuesDosS2ETM4[jDOSS2ETM4 - hDOSS2ETM4] > keyDOSS2ETM4)
{
allValuesDosS2ETM4[jDOSS2ETM4] = allValuesDosS2ETM4[jDOSS2ETM4 - hDOSS2ETM4];
jDOSS2ETM4 = jDOSS2ETM4 - hDOSS2ETM4;
}
allValuesDosS2ETM4[jDOSS2ETM4] = keyDOSS2ETM4;
}
hDOSS2ETM4 = floor(hDOSS2ETM4/3);
}
numeric minValueDosS2ETM4 = allValuesDosS2ETM4[1];
numeric dn1000S2ETM4 = 10000;
numeric actualCountDosS2ETM4 = 0;
for i = 1 to dosS2ETM4realSize
{
if (allValuesDosS2ETM4[i] == minValueDosS2ETM4)
{
actualCountDosS2ETM4 = actualCountDosS2ETM4 + 1;
if (actualCountDosS2ETM4 >= DNminCALCS2ETM4)
{
dn1000S2ETM4 = minValueDosS2ETM4;
go to dn1000S2ETM4jumper;
}
}
else
{
minValueDosS2ETM4 = allValuesDosS2ETM4[i+1];
actualCountDosS2ETM4 = 0;
}
}
dn1000S2ETM4jumper:
if (dn1000S2ETM4 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S2ETM4 = allValuesDosS2ETM4[1];
}
if (dn1000S2ETM4 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S2ETM4 = allValuesDosS2ETM4[1];
}
printf("dn1000 Scene 2 ETM4: %12f\n", dn1000S2ETM4);
########################### Scene 2 - Dn1000 - Band 5
numeric lastDOSS2ETM5 = dosS2ETM5realSize;
numeric hDOSS2ETM5 = 1;
while ( (hDOSS2ETM5 * 3 + 1) < lastDOSS2ETM5 - 1 )
{
hDOSS2ETM5 = 3 * hDOSS2ETM5 + 1;
}
while ( hDOSS2ETM5 > 0 )
{
for i = hDOSS2ETM5 - 1 to lastDOSS2ETM5 # for each of the h sets of elements
{
numeric keyDOSS2ETM5 = allValuesDosS2ETM5[i];
numeric jDOSS2ETM5 = i;
while (jDOSS2ETM5 >= hDOSS2ETM5 && allValuesDosS2ETM5[jDOSS2ETM5 - hDOSS2ETM5] > keyDOSS2ETM5)
{
allValuesDosS2ETM5[jDOSS2ETM5] = allValuesDosS2ETM5[jDOSS2ETM5 - hDOSS2ETM5];
jDOSS2ETM5 = jDOSS2ETM5 - hDOSS2ETM5;
}
allValuesDosS2ETM5[jDOSS2ETM5] = keyDOSS2ETM5;
}
hDOSS2ETM5 = floor(hDOSS2ETM5/3);
}
numeric minValueDosS2ETM5 = allValuesDosS2ETM5[1];
numeric dn1000S2ETM5 = 10000;
numeric actualCountDosS2ETM5 = 0;
for i = 1 to dosS2ETM5realSize
{
if (allValuesDosS2ETM5[i] == minValueDosS2ETM5)
{
actualCountDosS2ETM5 = actualCountDosS2ETM5 + 1;
if (actualCountDosS2ETM5 >= DNminCALCS2ETM5)
{
dn1000S2ETM5 = minValueDosS2ETM5;
go to dn1000S2ETM5jumper;
}
}
else
{
minValueDosS2ETM5 = allValuesDosS2ETM5[i+1];
actualCountDosS2ETM5 = 0;
}
}
dn1000S2ETM5jumper:
if (dn1000S2ETM5 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S2ETM5 = allValuesDosS2ETM5[1];
}
if (dn1000S2ETM5 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S2ETM5 = allValuesDosS2ETM5[1];
}
printf("dn1000 Scene 2 ETM5: %12f\n", dn1000S2ETM5);
########################### Scene 2 - Dn1000 - Band 7
numeric lastDOSS2ETM7 = dosS2ETM7realSize;
numeric hDOSS2ETM7 = 1;
while ( (hDOSS2ETM7 * 3 + 1) < lastDOSS2ETM7 - 1 )
{
hDOSS2ETM7 = 3 * hDOSS2ETM7 + 1;
}
while ( hDOSS2ETM7 > 0 )
{
for i = hDOSS2ETM7 - 1 to lastDOSS2ETM7 # for each of the h sets of elements
{
numeric keyDOSS2ETM7 = allValuesDosS2ETM7[i];
numeric jDOSS2ETM7 = i;
while (jDOSS2ETM7 >= hDOSS2ETM7 && allValuesDosS2ETM7[jDOSS2ETM7 - hDOSS2ETM7] > keyDOSS2ETM7)
{
allValuesDosS2ETM7[jDOSS2ETM7] = allValuesDosS2ETM7[jDOSS2ETM7 - hDOSS2ETM7];
jDOSS2ETM7 = jDOSS2ETM7 - hDOSS2ETM7;
}
allValuesDosS2ETM7[jDOSS2ETM7] = keyDOSS2ETM7;
}
hDOSS2ETM7 = floor(hDOSS2ETM7/3);
}
numeric minValueDosS2ETM7 = allValuesDosS2ETM7[1];
numeric dn1000S2ETM7 = 10000;
numeric actualCountDosS2ETM7 = 0;
for i = 1 to dosS2ETM7realSize
{
if (allValuesDosS2ETM7[i] == minValueDosS2ETM7)
{
actualCountDosS2ETM7 = actualCountDosS2ETM7 + 1;
if (actualCountDosS2ETM7 >= DNminCALCS2ETM7)
{
dn1000S2ETM7 = minValueDosS2ETM7;
go to dn1000S2ETM7jumper;
}
}
else
{
minValueDosS2ETM7 = allValuesDosS2ETM7[i+1];
actualCountDosS2ETM7 = 0;
}
}
dn1000S2ETM7jumper:
if (dn1000S2ETM7 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S2ETM7 = allValuesDosS2ETM7[1];
}
if (dn1000S2ETM7 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S2ETM7 = allValuesDosS2ETM7[1];
}
printf("dn1000 Scene 2 ETM7: %12f\n\n", dn1000S2ETM7);
################################### Pathradiance Calculation #######################################
numeric pathRadS2ETM1 = dn1000S2ETM1 - (0.01 * (radsurfETMS2b1 * cos(s2zenith)) / pi);
numeric pathRadS2ETM2 = dn1000S2ETM2 - (0.01 * (radsurfETMS2b2 * cos(s2zenith)) / pi);
numeric pathRadS2ETM3 = dn1000S2ETM3 - (0.01 * (radsurfETMS2b3 * cos(s2zenith)) / pi);
numeric pathRadS2ETM4 = dn1000S2ETM4 - (0.01 * (radsurfETMS2b4 * cos(s2zenith)) / pi);
numeric pathRadS2ETM5 = dn1000S2ETM5 - (0.01 * (radsurfETMS2b5 * cos(s2zenith)) / pi);
numeric pathRadS2ETM7 = dn1000S2ETM7 - (0.01 * (radsurfETMS2b7 * cos(s2zenith)) / pi);
printf("Pathradiance Scene 2 Band 1: %12f\n", pathRadS2ETM1);
printf("Pathradiance Scene 2 Band 2: %12f\n", pathRadS2ETM2);
printf("Pathradiance Scene 2 Band 3: %12f\n", pathRadS2ETM3);
printf("Pathradiance Scene 2 Band 4: %12f\n", pathRadS2ETM4);
printf("Pathradiance Scene 2 Band 5: %12f\n", pathRadS2ETM5);
printf("Pathradiance Scene 2 Band 7: %12f\n\n", pathRadS2ETM7);
################################# Reflectance Calculation with athmo correction
for i = 1 to ETMlins
{
for j = 1 to ETMcols
{
valueS2ETM1 = (pi * (RADS2ETM1[i,j] - pathRadS2ETM1)) / (radsurfETMS2b1 * cos(s2zenith));
if ( valueS2ETM1 < 0 )
{
valueS2ETM1 = 0;
countS2REFnullETM1 = countS2REFnullETM1 + 1;
}
else if ( valueS2ETM1 > 1 )
{
valueS2ETM1 = 1;
countS2REFoneETM1 = countS2REFoneETM1 + 1;
}
REFS2ETM1[i,j] = valueS2ETM1;
valueS2ETM2 = (pi * (RADS2ETM2[i,j] - pathRadS2ETM2)) / (radsurfETMS2b2 * cos(s2zenith));
if ( valueS2ETM2 < 0 )
{
valueS2ETM2 = 0;
countS2REFnullETM2 = countS2REFnullETM2 + 1;
}
else if ( valueS2ETM2 > 1 )
{
valueS2ETM2 = 1;
countS2REFoneETM2 = countS2REFoneETM2 + 1;
}
REFS2ETM2[i,j] = valueS2ETM2;
valueS2ETM3 = (pi * (RADS2ETM3[i,j] - pathRadS2ETM3)) / (radsurfETMS2b3 * cos(s2zenith));
if ( valueS2ETM3 < 0 )
{
valueS2ETM3 = 0;
countS2REFnullETM3 = countS2REFnullETM3 + 1;
}
else if ( valueS2ETM3 > 1 )
{
valueS2ETM3 = 1;
countS2REFoneETM3 = countS2REFoneETM3 + 1;
}
REFS2ETM3[i,j] = valueS2ETM3;
valueS2ETM4 = (pi * (RADS2ETM4[i,j] - pathRadS2ETM4)) / (radsurfETMS2b4 * cos(s2zenith));
if ( valueS2ETM4 < 0 )
{
valueS2ETM4 = 0;
countS2REFnullETM4 = countS2REFnullETM4 + 1;
}
else if ( valueS2ETM4 > 1 )
{
valueS2ETM4 = 1;
countS2REFoneETM4 = countS2REFoneETM4 + 1;
}
REFS2ETM4[i,j] = valueS2ETM4;
valueS2ETM5 = (pi * (RADS2ETM5[i,j] - pathRadS2ETM5)) / (radsurfETMS2b5 * cos(s2zenith));
if ( valueS2ETM5 < 0 )
{
valueS2ETM5 = 0;
countS2REFnullETM5 = countS2REFnullETM5 + 1;
}
else if ( valueS2ETM5 > 1 )
{
valueS2ETM5 = 1;
countS2REFoneETM5 = countS2REFoneETM5 + 1;
}
REFS2ETM5[i,j] = valueS2ETM5;
valueS2ETM7 = (pi * (RADS2ETM7[i,j] - pathRadS2ETM7)) / (radsurfETMS2b7 * cos(s2zenith));
if ( valueS2ETM7 < 0 )
{
valueS2ETM7 = 0;
countS2REFnullETM7 = countS2REFnullETM7 + 1;
}
else if ( valueS2ETM7 > 1 )
{
valueS2ETM7 = 1;
countS2REFoneETM7 = countS2REFoneETM7 + 1;
}
REFS2ETM7[i,j] = valueS2ETM7;
}
}
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 2 Band 1: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS2REFnullETM1, countS2REFoneETM1);
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 2 Band 2: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS2REFnullETM2, countS2REFoneETM2);
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 2 Band 3: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS2REFnullETM3, countS2REFoneETM3);
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 2 Band 4: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS2REFnullETM4, countS2REFoneETM4);
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 2 Band 5: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS2REFnullETM5, countS2REFoneETM5);
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 2 Band 7: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n\n", countS2REFnullETM7, countS2REFoneETM7);
CreatePyramid(REFS2ETM1);
CreatePyramid(REFS2ETM2);
CreatePyramid(REFS2ETM3);
CreatePyramid(REFS2ETM4);
CreatePyramid(REFS2ETM5);
CreatePyramid(REFS2ETM7);
CreateHistogram(REFS2ETM1);
CreateHistogram(REFS2ETM2);
CreateHistogram(REFS2ETM3);
CreateHistogram(REFS2ETM4);
CreateHistogram(REFS2ETM5);
CreateHistogram(REFS2ETM7);
CloseRaster(RADS2ETM1);
CloseRaster(RADS2ETM2);
CloseRaster(RADS2ETM3);
CloseRaster(RADS2ETM4);
CloseRaster(RADS2ETM5);
CloseRaster(RADS2ETM7);
printf("Reflectance calculation for Scene 2 (ETM) is done...\n\n\n");
}
else if ( sensors2 == 6 )
{
raster REFS2TM1, REFS2TM2, REFS2TM3, REFS2TM4, REFS2TM5, REFS2TM7;
numeric radsurfTMS2b1, radsurfTMS2b2, radsurfTMS2b3, radsurfTMS2b4, radsurfTMS2b5, radsurfTMS2b7;
numeric valueS2TM1, valueS2TM2, valueS2TM3, valueS2TM4, valueS2TM5, valueS2TM7;
numeric dosS2TM1nullValCount = 0;
numeric dosS2TM2nullValCount = 0;
numeric dosS2TM3nullValCount = 0;
numeric dosS2TM4nullValCount = 0;
numeric dosS2TM5nullValCount = 0;
numeric dosS2TM7nullValCount = 0;
numeric dosS2TM1realArrayCount = 1;
numeric dosS2TM2realArrayCount = 1;
numeric dosS2TM3realArrayCount = 1;
numeric dosS2TM4realArrayCount = 1;
numeric dosS2TM5realArrayCount = 1;
numeric dosS2TM7realArrayCount = 1;
numeric countS2REFnullTM1 = 0;
numeric countS2REFnullTM2 = 0;
numeric countS2REFnullTM3 = 0;
numeric countS2REFnullTM4 = 0;
numeric countS2REFnullTM5 = 0;
numeric countS2REFnullTM7 = 0;
numeric countS2REFoneTM1 = 0;
numeric countS2REFoneTM2 = 0;
numeric countS2REFoneTM3 = 0;
numeric countS2REFoneTM4 = 0;
numeric countS2REFoneTM5 = 0;
numeric countS2REFoneTM7 = 0;
radsurfTMS2b1 = ESTM1 / (dist2^2);
radsurfTMS2b2 = ESTM2 / (dist2^2);
radsurfTMS2b3 = ESTM3 / (dist2^2);
radsurfTMS2b4 = ESTM4 / (dist2^2);
radsurfTMS2b5 = ESTM5 / (dist2^2);
radsurfTMS2b7 = ESTM7 / (dist2^2);
printf("Surface Radiance TM Band 1 in W/m^2µm (Scene 2): %12f\n", radsurfTMS2b1);
printf("Surface Radiance TM Band 2 in W/m^2µm (Scene 2): %12f\n", radsurfTMS2b2);
printf("Surface Radiance TM Band 3 in W/m^2µm (Scene 2): %12f\n", radsurfTMS2b3);
printf("Surface Radiance TM Band 4 in W/m^2µm (Scene 2): %12f\n", radsurfTMS2b4);
printf("Surface Radiance TM Band 5 in W/m^2µm (Scene 2): %12f\n", radsurfTMS2b5);
printf("Surface Radiance TM Band 7 in W/m^2µm (Scene 2): %12f\n\n", radsurfTMS2b7);
for i = 1 to TMlins
{
for j = 1 to TMcols
{
if (IsNull(RADS2TM1[i,j]) == 1)
{
dosS2TM1nullValCount = dosS2TM1nullValCount + 1;
}
if (IsNull(RADS2TM2[i,j]) == 1)
{
dosS2TM2nullValCount = dosS2TM2nullValCount + 1;
}
if (IsNull(RADS2TM3[i,j]) == 1)
{
dosS2TM3nullValCount = dosS2TM3nullValCount + 1;
}
if (IsNull(RADS2TM4[i,j]) == 1)
{
dosS2TM4nullValCount = dosS2TM4nullValCount + 1;
}
if (IsNull(RADS2TM5[i,j]) == 1)
{
dosS2TM5nullValCount = dosS2TM5nullValCount + 1;
}
if (IsNull(RADS2TM7[i,j]) == 1)
{
dosS2TM7nullValCount = dosS2TM7nullValCount + 1;
}
}
}
numeric dosS2TM1realSize = (TMlins * TMcols) - dosS2TM1nullValCount;
numeric dosS2TM2realSize = (TMlins * TMcols) - dosS2TM2nullValCount;
numeric dosS2TM3realSize = (TMlins * TMcols) - dosS2TM3nullValCount;
numeric dosS2TM4realSize = (TMlins * TMcols) - dosS2TM4nullValCount;
numeric dosS2TM5realSize = (TMlins * TMcols) - dosS2TM5nullValCount;
numeric dosS2TM7realSize = (TMlins * TMcols) - dosS2TM7nullValCount;
array allValuesDosS2TM1[dosS2TM1realSize];
array allValuesDosS2TM2[dosS2TM2realSize];
array allValuesDosS2TM3[dosS2TM3realSize];
array allValuesDosS2TM4[dosS2TM4realSize];
array allValuesDosS2TM5[dosS2TM5realSize];
array allValuesDosS2TM7[dosS2TM7realSize];
numeric DNminCALCS2TM1 = DNminCALC(Scene2Lin, Scene2Col, dosS2TM1realSize);
numeric DNminCALCS2TM2 = DNminCALC(Scene2Lin, Scene2Col, dosS2TM2realSize);
numeric DNminCALCS2TM3 = DNminCALC(Scene2Lin, Scene2Col, dosS2TM3realSize);
numeric DNminCALCS2TM4 = DNminCALC(Scene2Lin, Scene2Col, dosS2TM4realSize);
numeric DNminCALCS2TM5 = DNminCALC(Scene2Lin, Scene2Col, dosS2TM5realSize);
numeric DNminCALCS2TM7 = DNminCALC(Scene2Lin, Scene2Col, dosS2TM7realSize);
for i = 1 to TMlins
{
for j = 1 to TMcols
{
if (IsNull(RADS2TM1[i,j]) == 0)
{
allValuesDosS2TM1[dosS2TM1realArrayCount] = RADS2TM1[i,j];
dosS2TM1realArrayCount = dosS2TM1realArrayCount + 1;
}
if (IsNull(RADS2TM2[i,j]) == 0)
{
allValuesDosS2TM2[dosS2TM2realArrayCount] = RADS2TM2[i,j];
dosS2TM2realArrayCount = dosS2TM2realArrayCount + 1;
}
if (IsNull(RADS2TM3[i,j]) == 0)
{
allValuesDosS2TM3[dosS2TM3realArrayCount] = RADS2TM3[i,j];
dosS2TM3realArrayCount = dosS2TM3realArrayCount + 1;
}
if (IsNull(RADS2TM4[i,j]) == 0)
{
allValuesDosS2TM4[dosS2TM4realArrayCount] = RADS2TM4[i,j];
dosS2TM4realArrayCount = dosS2TM4realArrayCount + 1;
}
if (IsNull(RADS2TM5[i,j]) == 0)
{
allValuesDosS2TM5[dosS2TM5realArrayCount] = RADS2TM5[i,j];
dosS2TM5realArrayCount = dosS2TM5realArrayCount + 1;
}
if (IsNull(RADS2TM7[i,j]) == 0)
{
allValuesDosS2TM7[dosS2TM7realArrayCount] = RADS2TM7[i,j];
dosS2TM7realArrayCount = dosS2TM7realArrayCount + 1;
}
}
}
########################### Scene 2 - Dn1000 - Band 1
numeric lastDOSS2TM1 = dosS2TM1realSize;
numeric hDOSS2TM1 = 1;
while ( (hDOSS2TM1 * 3 + 1) < lastDOSS2TM1 - 1 )
{
hDOSS2TM1 = 3 * hDOSS2TM1 + 1;
}
while ( hDOSS2TM1 > 0 )
{
for i = hDOSS2TM1 - 1 to lastDOSS2TM1 # for each of the h sets of elements
{
numeric keyDOSS2TM1 = allValuesDosS2TM1[i];
numeric jDOSS2TM1 = i;
while (jDOSS2TM1 >= hDOSS2TM1 && allValuesDosS2TM1[jDOSS2TM1 - hDOSS2TM1] > keyDOSS2TM1)
{
allValuesDosS2TM1[jDOSS2TM1] = allValuesDosS2TM1[jDOSS2TM1 - hDOSS2TM1];
jDOSS2TM1 = jDOSS2TM1 - hDOSS2TM1;
}
allValuesDosS2TM1[jDOSS2TM1] = keyDOSS2TM1;
}
hDOSS2TM1 = floor(hDOSS2TM1/3);
}
numeric minValueDosS2TM1 = allValuesDosS2TM1[1];
numeric dn1000S2TM1 = 10000;
numeric actualCountDosS2TM1 = 0;
for i = 1 to dosS2TM1realSize
{
if (allValuesDosS2TM1[i] == minValueDosS2TM1)
{
actualCountDosS2TM1 = actualCountDosS2TM1 + 1;
if (actualCountDosS2TM1 >= DNminCALCS2TM1)
{
dn1000S2TM1 = minValueDosS2TM1;
go to dn1000S2TM1jumper;
}
}
else
{
minValueDosS2TM1 = allValuesDosS2TM1[i+1];
actualCountDosS2TM1 = 0;
}
}
dn1000S2TM1jumper:
if (dn1000S2TM1 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S2TM1 = allValuesDosS2TM1[1];
}
if (dn1000S2TM1 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S2TM1 = allValuesDosS2TM1[1];
}
printf("dn1000 Scene 2 TM1: %12f\n", dn1000S2TM1);
########################### Scene 2 - Dn1000 - Band 2
numeric lastDOSS2TM2 = dosS2TM1realSize;
numeric hDOSS2TM2 = 1;
while ( (hDOSS2TM2 * 3 + 1) < lastDOSS2TM2 - 1 )
{
hDOSS2TM2 = 3 * hDOSS2TM2 + 1;
}
while ( hDOSS2TM2 > 0 )
{
for i = hDOSS2TM2 - 1 to lastDOSS2TM2
{
numeric keyDOSS2TM2 = allValuesDosS2TM2[i];
numeric jDOSS2TM2 = i;
while (jDOSS2TM2 >= hDOSS2TM2 && allValuesDosS2TM2[jDOSS2TM2 - hDOSS2TM2] > keyDOSS2TM2)
{
allValuesDosS2TM2[jDOSS2TM2] = allValuesDosS2TM2[jDOSS2TM2 - hDOSS2TM2];
jDOSS2TM2 = jDOSS2TM2 - hDOSS2TM2;
}
allValuesDosS2TM2[jDOSS2TM2] = keyDOSS2TM2;
}
hDOSS2TM2 = floor(hDOSS2TM2/3);
}
numeric minValueDosS2TM2 = allValuesDosS2TM2[1];
numeric dn1000S2TM2 = 10000;
numeric actualCountDosS2TM2 = 0;
for i = 1 to dosS2TM2realSize
{
if (allValuesDosS2TM2[i] == minValueDosS2TM2)
{
actualCountDosS2TM2 = actualCountDosS2TM2 + 1;
if (actualCountDosS2TM2 >= DNminCALCS2TM2)
{
dn1000S2TM2 = minValueDosS2TM2;
go to dn1000S2TM2jumper;
}
}
else
{
minValueDosS2TM2 = allValuesDosS2TM2[i+1];
actualCountDosS2TM2 = 0;
}
}
dn1000S2TM2jumper:
if (dn1000S2TM2 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S2TM2 = allValuesDosS2TM2[1];
}
if (dn1000S2TM2 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S2TM2 = allValuesDosS2TM2[1];
}
printf("dn1000 Scene 2 TM2: %12f\n", dn1000S2TM2);
########################### Scene 2 - Dn1000 - Band 3
numeric lastDOSS2TM3 = dosS2TM3realSize;
numeric hDOSS2TM3 = 1;
while ( (hDOSS2TM3 * 3 + 1) < lastDOSS2TM3 - 1 )
{
hDOSS2TM3 = 3 * hDOSS2TM3 + 1;
}
while ( hDOSS2TM3 > 0 )
{
for i = hDOSS2TM3 - 1 to lastDOSS2TM3 # for each of the h sets of elements
{
numeric keyDOSS2TM3 = allValuesDosS2TM3[i];
numeric jDOSS2TM3 = i;
while (jDOSS2TM3 >= hDOSS2TM3 && allValuesDosS2TM3[jDOSS2TM3 - hDOSS2TM3] > keyDOSS2TM3)
{
allValuesDosS2TM3[jDOSS2TM3] = allValuesDosS2TM3[jDOSS2TM3 - hDOSS2TM3];
jDOSS2TM3 = jDOSS2TM3 - hDOSS2TM3;
}
allValuesDosS2TM3[jDOSS2TM3] = keyDOSS2TM3;
}
hDOSS2TM3 = floor(hDOSS2TM3/3);
}
numeric minValueDosS2TM3 = allValuesDosS2TM3[1];
numeric dn1000S2TM3 = 10000;
numeric actualCountDosS2TM3 = 0;
for i = 1 to dosS2TM3realSize
{
if (allValuesDosS2TM3[i] == minValueDosS2TM3)
{
actualCountDosS2TM3 = actualCountDosS2TM3 + 1;
if (actualCountDosS2TM3 >= DNminCALCS2TM3)
{
dn1000S2TM3 = minValueDosS2TM3;
go to dn1000S2TM3jumper;
}
}
else
{
minValueDosS2TM3 = allValuesDosS2TM3[i+1];
actualCountDosS2TM3 = 0;
}
}
dn1000S2TM3jumper:
if (dn1000S2TM3 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S2TM3 = allValuesDosS2TM3[1];
}
if (dn1000S2TM3 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S2TM3 = allValuesDosS2TM3[1];
}
printf("dn1000 Scene 2 TM3: %12f\n", dn1000S2TM3);
########################### Scene 1 - Dn1000 - Band 4
numeric lastDOSS2TM4 = dosS2TM4realSize;
numeric hDOSS2TM4 = 1;
while ( (hDOSS2TM4 * 3 + 1) < lastDOSS2TM4 - 1 )
{
hDOSS2TM4 = 3 * hDOSS2TM4 + 1;
}
while ( hDOSS2TM4 > 0 )
{
for i = hDOSS2TM4 - 1 to lastDOSS2TM4
{
numeric keyDOSS2TM4 = allValuesDosS2TM4[i];
numeric jDOSS2TM4 = i;
while (jDOSS2TM4 >= hDOSS2TM4 && allValuesDosS2TM4[jDOSS2TM4 - hDOSS2TM4] > keyDOSS2TM4)
{
allValuesDosS2TM4[jDOSS2TM4] = allValuesDosS2TM4[jDOSS2TM4 - hDOSS2TM4];
jDOSS2TM4 = jDOSS2TM4 - hDOSS2TM4;
}
allValuesDosS2TM4[jDOSS2TM4] = keyDOSS2TM4;
}
hDOSS2TM4 = floor(hDOSS2TM4/3);
}
numeric minValueDosS2TM4 = allValuesDosS2TM4[1];
numeric dn1000S2TM4 = 10000;
numeric actualCountDosS2TM4 = 0;
for i = 1 to dosS2TM4realSize
{
if (allValuesDosS2TM4[i] == minValueDosS2TM4)
{
actualCountDosS2TM4 = actualCountDosS2TM4 + 1;
if (actualCountDosS2TM4 >= DNminCALCS2TM4)
{
dn1000S2TM4 = minValueDosS2TM4;
go to dn1000S2TM4jumper;
}
}
else
{
minValueDosS2TM4 = allValuesDosS2TM4[i+1];
actualCountDosS2TM4 = 0;
}
}
dn1000S2TM4jumper:
if (dn1000S2TM4 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S2TM4 = allValuesDosS2TM4[1];
}
if (dn1000S2TM4 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S2TM4 = allValuesDosS2TM4[1];
}
printf("dn1000 Scene 2 TM4: %12f\n", dn1000S2TM4);
########################### Scene 2 - Dn1000 - Band 5
numeric lastDOSS2TM5 = dosS2TM5realSize;
numeric hDOSS2TM5 = 1;
while ( (hDOSS2TM5 * 3 + 1) < lastDOSS2TM5 - 1 )
{
hDOSS2TM5 = 3 * hDOSS2TM5 + 1;
}
while ( hDOSS2TM5 > 0 )
{
for i = hDOSS2TM5 - 1 to lastDOSS2TM5 # for each of the h sets of elements
{
numeric keyDOSS2TM5 = allValuesDosS2TM5[i];
numeric jDOSS2TM5 = i;
while (jDOSS2TM5 >= hDOSS2TM5 && allValuesDosS2TM5[jDOSS2TM5 - hDOSS2TM5] > keyDOSS2TM5)
{
allValuesDosS2TM5[jDOSS2TM5] = allValuesDosS2TM5[jDOSS2TM5 - hDOSS2TM5];
jDOSS2TM5 = jDOSS2TM5 - hDOSS2TM5;
}
allValuesDosS2TM5[jDOSS2TM5] = keyDOSS2TM5;
}
hDOSS2TM5 = floor(hDOSS2TM5/3);
}
numeric minValueDosS2TM5 = allValuesDosS2TM5[1];
numeric dn1000S2TM5 = 10000;
numeric actualCountDosS2TM5 = 0;
for i = 1 to dosS2TM5realSize
{
if (allValuesDosS2TM5[i] == minValueDosS2TM5)
{
actualCountDosS2TM5 = actualCountDosS2TM5 + 1;
if (actualCountDosS2TM5 >= DNminCALCS2TM5)
{
dn1000S2TM5 = minValueDosS2TM5;
go to dn1000S2TM5jumper;
}
}
else
{
minValueDosS2TM5 = allValuesDosS2TM5[i+1];
actualCountDosS2TM5 = 0;
}
}
dn1000S2TM5jumper:
if (dn1000S2TM5 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S2TM5 = allValuesDosS2TM5[1];
}
if (dn1000S2TM5 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S2TM5 = allValuesDosS2TM5[1];
}
printf("dn1000 Scene 2 TM5: %12f\n", dn1000S2TM5);
########################### Scene 2 - Dn1000 - Band 7
numeric lastDOSS2TM7 = dosS2TM7realSize;
numeric hDOSS2TM7 = 1;
while ( (hDOSS2TM7 * 3 + 1) < lastDOSS2TM7 - 1 )
{
hDOSS2TM7 = 3 * hDOSS2TM7 + 1;
}
while ( hDOSS2TM7 > 0 )
{
for i = hDOSS2TM7 - 1 to lastDOSS2TM7 # for each of the h sets of elements
{
numeric keyDOSS2TM7 = allValuesDosS2TM7[i];
numeric jDOSS2TM7 = i;
while (jDOSS2TM7 >= hDOSS2TM7 && allValuesDosS2TM7[jDOSS2TM7 - hDOSS2TM7] > keyDOSS2TM7)
{
allValuesDosS2TM7[jDOSS2TM7] = allValuesDosS2TM7[jDOSS2TM7 - hDOSS2TM7];
jDOSS2TM7 = jDOSS2TM7 - hDOSS2TM7;
}
allValuesDosS2TM7[jDOSS2TM7] = keyDOSS2TM7;
}
hDOSS2TM7 = floor(hDOSS2TM7/3);
}
numeric minValueDosS2TM7 = allValuesDosS2TM7[1];
numeric dn1000S2TM7 = 10000;
numeric actualCountDosS2TM7 = 0;
for i = 1 to dosS2TM7realSize
{
if (allValuesDosS2TM7[i] == minValueDosS2TM7)
{
actualCountDosS2TM7 = actualCountDosS2TM7 + 1;
if (actualCountDosS2TM7 >= DNminCALCS2TM7)
{
dn1000S2TM7 = minValueDosS2TM7;
go to dn1000S2TM7jumper;
}
}
else
{
minValueDosS2TM7 = allValuesDosS2TM7[i+1];
actualCountDosS2TM7 = 0;
}
}
dn1000S2TM7jumper:
if (dn1000S2TM7 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S2TM7 = allValuesDosS2TM7[1];
}
if (dn1000S2TM7 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S2TM7 = allValuesDosS2TM7[1];
}
printf("dn1000 Scene 2 TM7: %12f\n\n", dn1000S2TM7);
################################### Pathradiance Calculation #######################################
numeric pathRadS2TM1 = dn1000S2TM1 - (0.01 * (radsurfTMS2b1 * cos(s2zenith)) / pi);
numeric pathRadS2TM2 = dn1000S2TM2 - (0.01 * (radsurfTMS2b2 * cos(s2zenith)) / pi);
numeric pathRadS2TM3 = dn1000S2TM3 - (0.01 * (radsurfTMS2b3 * cos(s2zenith)) / pi);
numeric pathRadS2TM4 = dn1000S2TM4 - (0.01 * (radsurfTMS2b4 * cos(s2zenith)) / pi);
numeric pathRadS2TM5 = dn1000S2TM5 - (0.01 * (radsurfTMS2b5 * cos(s2zenith)) / pi);
numeric pathRadS2TM7 = dn1000S2TM7 - (0.01 * (radsurfTMS2b7 * cos(s2zenith)) / pi);
printf("Pathradiance Scene 2 Band 1: %12f\n", pathRadS2TM1);
printf("Pathradiance Scene 2 Band 2: %12f\n", pathRadS2TM2);
printf("Pathradiance Scene 2 Band 3: %12f\n", pathRadS2TM3);
printf("Pathradiance Scene 2 Band 4: %12f\n", pathRadS2TM4);
printf("Pathradiance Scene 2 Band 5: %12f\n", pathRadS2TM5);
printf("Pathradiance Scene 2 Band 7: %12f\n\n", pathRadS2TM7);
################################# Reflectance Calculation with athmo correction
for i = 1 to TMlins
{
for j = 1 to TMcols
{
valueS2TM1 = (pi * (RADS2TM1[i,j] - pathRadS2TM1)) / (radsurfTMS2b1 * cos(s2zenith));
if ( valueS2TM1 < 0 )
{
valueS2TM1 = 0;
countS2REFnullTM1 = countS2REFnullTM1 + 1;
}
else if ( valueS2TM1 > 1 )
{
valueS2TM1 = 1;
countS2REFoneTM1 = countS2REFoneTM1 + 1;
}
REFS2TM1[i,j] = valueS2TM1;
valueS2TM2 = (pi * (RADS2TM2[i,j] - pathRadS2TM2)) / (radsurfTMS2b2 * cos(s2zenith));
if ( valueS2TM2 < 0 )
{
valueS2TM2 = 0;
countS2REFnullTM2 = countS2REFnullTM2 + 1;
}
else if ( valueS2TM2 > 1 )
{
valueS2TM2 = 1;
countS2REFoneTM2 = countS2REFoneTM2 + 1;
}
REFS2TM2[i,j] = valueS2TM2;
valueS2TM3 = (pi * (RADS2TM3[i,j] - pathRadS2TM3)) / (radsurfTMS2b3 * cos(s2zenith));
if ( valueS2TM3 < 0 )
{
valueS2TM3 = 0;
countS2REFnullTM3 = countS2REFnullTM3 + 1;
}
else if ( valueS2TM3 > 1 )
{
valueS2TM3 = 1;
countS2REFoneTM3 = countS2REFoneTM3 + 1;
}
REFS2TM3[i,j] = valueS2TM3;
valueS2TM4 = (pi * (RADS2TM4[i,j] - pathRadS2TM4)) / (radsurfTMS2b4 * cos(s2zenith));
if ( valueS2TM4 < 0 )
{
valueS2TM4 = 0;
countS2REFnullTM4 = countS2REFnullTM4 + 1;
}
else if ( valueS2TM4 > 1 )
{
valueS2TM4 = 1;
countS2REFoneTM4 = countS2REFoneTM4 + 1;
}
REFS2TM4[i,j] = valueS2TM4;
valueS2TM5 = (pi * (RADS2TM5[i,j] - pathRadS2TM5)) / (radsurfTMS2b5 * cos(s2zenith));
if ( valueS2TM5 < 0 )
{
valueS2TM5 = 0;
countS2REFnullTM5 = countS2REFnullTM5 + 1;
}
else if ( valueS2TM5 > 1 )
{
valueS2TM5 = 1;
countS2REFoneTM5 = countS2REFoneTM5 + 1;
}
REFS2TM5[i,j] = valueS2TM5;
valueS2TM7 = (pi * (RADS2TM7[i,j] - pathRadS2TM7)) / (radsurfTMS2b7 * cos(s2zenith));
if ( valueS2TM7 < 0 )
{
valueS2TM7 = 0;
countS2REFnullTM7 = countS2REFnullTM7 + 1;
}
else if ( valueS2TM7 > 1 )
{
valueS2TM7 = 1;
countS2REFoneTM7 = countS2REFoneTM7 + 1;
}
REFS2TM7[i,j] = valueS2TM7;
}
}
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 2 Band 1: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS2REFnullTM1, countS2REFoneTM1);
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 2 Band 2: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS2REFnullTM2, countS2REFoneTM2);
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 2 Band 3: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS2REFnullTM3, countS2REFoneTM3);
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 2 Band 4: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS2REFnullTM4, countS2REFoneTM4);
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 2 Band 5: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS2REFnullTM5, countS2REFoneTM5);
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 2 Band 7: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n\n", countS2REFnullTM7, countS2REFoneTM7);
CreatePyramid(REFS2TM1);
CreatePyramid(REFS2TM2);
CreatePyramid(REFS2TM3);
CreatePyramid(REFS2TM4);
CreatePyramid(REFS2TM5);
CreatePyramid(REFS2TM7);
CreateHistogram(REFS2TM1);
CreateHistogram(REFS2TM2);
CreateHistogram(REFS2TM3);
CreateHistogram(REFS2TM4);
CreateHistogram(REFS2TM5);
CreateHistogram(REFS2TM7);
CloseRaster(RADS2TM1);
CloseRaster(RADS2TM2);
CloseRaster(RADS2TM3);
CloseRaster(RADS2TM4);
CloseRaster(RADS2TM5);
CloseRaster(RADS2TM7);
printf("Reflectance calculation for Scene 2 (TM) is done...\n\n\n");
}
else if ( sensors2 == 5 ) # MSS 5 - Calib Werte nach Price J.C.1987
{
raster REFS2MSS1, REFS2MSS2, REFS2MSS3, REFS2MSS4;
numeric radsurfMSS2b1, radsurfMSS2b2, radsurfMSS2b3, radsurfMSS2b4;
numeric valueS2MSS1, valueS2MSS2, valueS2MSS3, valueS2MSS4;
numeric dosS2MSS1nullValCount = 0;
numeric dosS2MSS2nullValCount = 0;
numeric dosS2MSS3nullValCount = 0;
numeric dosS2MSS4nullValCount = 0;
numeric dosS2MSS1realArrayCount = 1;
numeric dosS2MSS2realArrayCount = 1;
numeric dosS2MSS3realArrayCount = 1;
numeric dosS2MSS4realArrayCount = 1;
numeric countS2REFnullMSS1 = 0;
numeric countS2REFnullMSS2 = 0;
numeric countS2REFnullMSS3 = 0;
numeric countS2REFnullMSS4 = 0;
numeric countS2REFoneMSS1 = 0;
numeric countS2REFoneMSS2 = 0;
numeric countS2REFoneMSS3 = 0;
numeric countS2REFoneMSS4 = 0;
radsurfMSS2b1 = ESMSS51 / (dist2^2);
radsurfMSS2b2 = ESMSS52 / (dist2^2);
radsurfMSS2b3 = ESMSS53 / (dist2^2);
radsurfMSS2b4 = ESMSS54 / (dist2^2);
printf("Surface Radiance MSS Band 1 in W/m^2µm (Scene 2): %12f\n", radsurfMSS2b1);
printf("Surface Radiance MSS Band 2 in W/m^2µm (Scene 2): %12f\n", radsurfMSS2b2);
printf("Surface Radiance MSS Band 3 in W/m^2µm (Scene 2): %12f\n", radsurfMSS2b3);
printf("Surface Radiance MSS Band 4 in W/m^2µm (Scene 2): %12f\n\n", radsurfMSS2b4);
for i = 1 to MSSlins
{
for j = 1 to MSScols
{
if (IsNull(RADS2MSS1[i,j]) == 1)
{
dosS2MSS1nullValCount = dosS2MSS1nullValCount + 1;
}
if (IsNull(RADS2MSS2[i,j]) == 1)
{
dosS2MSS2nullValCount = dosS2MSS2nullValCount + 1;
}
if (IsNull(RADS2MSS3[i,j]) == 1)
{
dosS2MSS3nullValCount = dosS2MSS3nullValCount + 1;
}
if (IsNull(RADS2MSS4[i,j]) == 1)
{
dosS2MSS4nullValCount = dosS2MSS4nullValCount + 1;
}
}
}
numeric dosS2MSS1realSize = (MSSlins * MSScols) - dosS2MSS1nullValCount;
numeric dosS2MSS2realSize = (MSSlins * MSScols) - dosS2MSS2nullValCount;
numeric dosS2MSS3realSize = (MSSlins * MSScols) - dosS2MSS3nullValCount;
numeric dosS2MSS4realSize = (MSSlins * MSScols) - dosS2MSS4nullValCount;
array allValuesDosS2MSS1[dosS2MSS1realSize];
array allValuesDosS2MSS2[dosS2MSS2realSize];
array allValuesDosS2MSS3[dosS2MSS3realSize];
array allValuesDosS2MSS4[dosS2MSS4realSize];
numeric DNminCALCS2MSS1 = DNminCALC(Scene2Lin, Scene2Col, dosS2MSS1realSize);
numeric DNminCALCS2MSS2 = DNminCALC(Scene2Lin, Scene2Col, dosS2MSS2realSize);
numeric DNminCALCS2MSS3 = DNminCALC(Scene2Lin, Scene2Col, dosS2MSS3realSize);
numeric DNminCALCS2MSS4 = DNminCALC(Scene2Lin, Scene2Col, dosS2MSS4realSize);
for i = 1 to MSSlins
{
for j = 1 to MSScols
{
if (IsNull(RADS2MSS1[i,j]) == 0)
{
allValuesDosS2MSS1[dosS2MSS1realArrayCount] = RADS2MSS1[i,j];
dosS2MSS1realArrayCount = dosS2MSS1realArrayCount + 1;
}
if (IsNull(RADS2MSS2[i,j]) == 0)
{
allValuesDosS2MSS2[dosS2MSS2realArrayCount] = RADS2MSS2[i,j];
dosS2MSS2realArrayCount = dosS2MSS2realArrayCount + 1;
}
if (IsNull(RADS2MSS3[i,j]) == 0)
{
allValuesDosS2MSS3[dosS2MSS3realArrayCount] = RADS2MSS3[i,j];
dosS2MSS3realArrayCount = dosS2MSS3realArrayCount + 1;
}
if (IsNull(RADS2MSS4[i,j]) == 0)
{
allValuesDosS2MSS4[dosS2MSS4realArrayCount] = RADS2MSS4[i,j];
dosS2MSS4realArrayCount = dosS2MSS4realArrayCount + 1;
}
}
}
########################### Scene 2 - Dn1000 - Band 1
numeric lastDOSS2MSS1 = dosS2MSS1realSize;
numeric hDOSS2MSS1 = 1;
while ( (hDOSS2MSS1 * 3 + 1) < lastDOSS2MSS1 - 1 )
{
hDOSS2MSS1 = 3 * hDOSS2MSS1 + 1;
}
while ( hDOSS2MSS1 > 0 )
{
for i = hDOSS2MSS1 - 1 to lastDOSS2MSS1 # for each of the h sets of elements
{
numeric keyDOSS2MSS1 = allValuesDosS2MSS1[i];
numeric jDOSS2MSS1 = i;
while (jDOSS2MSS1 >= hDOSS2MSS1 && allValuesDosS2MSS1[jDOSS2MSS1 - hDOSS2MSS1] > keyDOSS2MSS1)
{
allValuesDosS2MSS1[jDOSS2MSS1] = allValuesDosS2MSS1[jDOSS2MSS1 - hDOSS2MSS1];
jDOSS2MSS1 = jDOSS2MSS1 - hDOSS2MSS1;
}
allValuesDosS2MSS1[jDOSS2MSS1] = keyDOSS2MSS1;
}
hDOSS2MSS1 = floor(hDOSS2MSS1/3);
}
numeric minValueDosS2MSS1 = allValuesDosS2MSS1[1];
numeric dn1000S2MSS1 = 10000;
numeric actualCountDosS2MSS1 = 0;
for i = 1 to dosS2MSS1realSize
{
if (allValuesDosS2MSS1[i] == minValueDosS2MSS1)
{
actualCountDosS2MSS1 = actualCountDosS2MSS1 + 1;
if (actualCountDosS2MSS1 >= DNminCALCS2MSS1)
{
dn1000S2MSS1 = minValueDosS2MSS1;
go to dn1000S2MSS1jumper;
}
}
else
{
minValueDosS2MSS1 = allValuesDosS2MSS1[i+1];
actualCountDosS2MSS1 = 0;
}
}
dn1000S2MSS1jumper:
if (dn1000S2MSS1 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S2MSS1 = allValuesDosS2MSS1[1];
}
if (dn1000S2MSS1 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S2MSS1 = allValuesDosS2MSS1[1];
}
printf("dn1000 Scene 2 MSS1: %12f\n", dn1000S2MSS1);
########################### Scene 2 - Dn1000 - Band 2
numeric lastDOSS2MSS2 = dosS2MSS1realSize;
numeric hDOSS2MSS2 = 1;
while ( (hDOSS2MSS2 * 3 + 1) < lastDOSS2MSS2 - 1 )
{
hDOSS2MSS2 = 3 * hDOSS2MSS2 + 1;
}
while ( hDOSS2MSS2 > 0 )
{
for i = hDOSS2MSS2 - 1 to lastDOSS2MSS2
{
numeric keyDOSS2MSS2 = allValuesDosS2MSS2[i];
numeric jDOSS2MSS2 = i;
while (jDOSS2MSS2 >= hDOSS2MSS2 && allValuesDosS2MSS2[jDOSS2MSS2 - hDOSS2MSS2] > keyDOSS2MSS2)
{
allValuesDosS2MSS2[jDOSS2MSS2] = allValuesDosS2MSS2[jDOSS2MSS2 - hDOSS2MSS2];
jDOSS2MSS2 = jDOSS2MSS2 - hDOSS2MSS2;
}
allValuesDosS2MSS2[jDOSS2MSS2] = keyDOSS2MSS2;
}
hDOSS2MSS2 = floor(hDOSS2MSS2/3);
}
numeric minValueDosS2MSS2 = allValuesDosS2MSS2[1];
numeric dn1000S2MSS2 = 10000;
numeric actualCountDosS2MSS2 = 0;
for i = 1 to dosS2MSS2realSize
{
if (allValuesDosS2MSS2[i] == minValueDosS2MSS2)
{
actualCountDosS2MSS2 = actualCountDosS2MSS2 + 1;
if (actualCountDosS2MSS2 >= DNminCALCS2MSS2)
{
dn1000S2MSS2 = minValueDosS2MSS2;
go to dn1000S2MSS2jumper;
}
}
else
{
minValueDosS2MSS2 = allValuesDosS2MSS2[i+1];
actualCountDosS2MSS2 = 0;
}
}
dn1000S2MSS2jumper:
if (dn1000S2MSS2 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S2MSS2 = allValuesDosS2MSS2[1];
}
if (dn1000S2MSS2 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S2MSS2 = allValuesDosS2MSS2[1];
}
printf("dn1000 Scene 2 MSS2: %12f\n", dn1000S2MSS2);
########################### Scene 2 - Dn1000 - Band 3
numeric lastDOSS2MSS3 = dosS2MSS3realSize;
numeric hDOSS2MSS3 = 1;
while ( (hDOSS2MSS3 * 3 + 1) < lastDOSS2MSS3 - 1 )
{
hDOSS2MSS3 = 3 * hDOSS2MSS3 + 1;
}
while ( hDOSS2MSS3 > 0 )
{
for i = hDOSS2MSS3 - 1 to lastDOSS2MSS3 # for each of the h sets of elements
{
numeric keyDOSS2MSS3 = allValuesDosS2MSS3[i];
numeric jDOSS2MSS3 = i;
while (jDOSS2MSS3 >= hDOSS2MSS3 && allValuesDosS2MSS3[jDOSS2MSS3 - hDOSS2MSS3] > keyDOSS2MSS3)
{
allValuesDosS2MSS3[jDOSS2MSS3] = allValuesDosS2MSS3[jDOSS2MSS3 - hDOSS2MSS3];
jDOSS2MSS3 = jDOSS2MSS3 - hDOSS2MSS3;
}
allValuesDosS2MSS3[jDOSS2MSS3] = keyDOSS2MSS3;
}
hDOSS2MSS3 = floor(hDOSS2MSS3/3);
}
numeric minValueDosS2MSS3 = allValuesDosS2MSS3[1];
numeric dn1000S2MSS3 = 10000;
numeric actualCountDosS2MSS3 = 0;
for i = 1 to dosS2MSS3realSize
{
if (allValuesDosS2MSS3[i] == minValueDosS2MSS3)
{
actualCountDosS2MSS3 = actualCountDosS2MSS3 + 1;
if (actualCountDosS2MSS3 >= DNminCALCS2MSS3)
{
dn1000S2MSS3 = minValueDosS2MSS3;
go to dn1000S2MSS3jumper;
}
}
else
{
minValueDosS2MSS3 = allValuesDosS2MSS3[i+1];
actualCountDosS2MSS3 = 0;
}
}
dn1000S2MSS3jumper:
if (dn1000S2MSS3 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S2MSS3 = allValuesDosS2MSS3[1];
}
if (dn1000S2MSS3 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S2MSS3 = allValuesDosS2MSS3[1];
}
printf("dn1000 Scene 2 MSS3: %12f\n", dn1000S2MSS3);
########################### Scene 2 - Dn1000 - Band 4
numeric lastDOSS2MSS4 = dosS2MSS4realSize;
numeric hDOSS2MSS4 = 1;
while ( (hDOSS2MSS4 * 3 + 1) < lastDOSS2MSS4 - 1 )
{
hDOSS2MSS4 = 3 * hDOSS2MSS4 + 1;
}
while ( hDOSS2MSS4 > 0 )
{
for i = hDOSS2MSS4 - 1 to lastDOSS2MSS4
{
numeric keyDOSS2MSS4 = allValuesDosS2MSS4[i];
numeric jDOSS2MSS4 = i;
while (jDOSS2MSS4 >= hDOSS2MSS4 && allValuesDosS2MSS4[jDOSS2MSS4 - hDOSS2MSS4] > keyDOSS2MSS4)
{
allValuesDosS2MSS4[jDOSS2MSS4] = allValuesDosS2MSS4[jDOSS2MSS4 - hDOSS2MSS4];
jDOSS2MSS4 = jDOSS2MSS4 - hDOSS2MSS4;
}
allValuesDosS2MSS4[jDOSS2MSS4] = keyDOSS2MSS4;
}
hDOSS2MSS4 = floor(hDOSS2MSS4/3);
}
numeric minValueDosS2MSS4 = allValuesDosS2MSS4[1];
numeric dn1000S2MSS4 = 10000;
numeric actualCountDosS2MSS4 = 0;
for i = 1 to dosS2MSS4realSize
{
if (allValuesDosS2MSS4[i] == minValueDosS2MSS4)
{
actualCountDosS2MSS4 = actualCountDosS2MSS4 + 1;
if (actualCountDosS2MSS4 >= DNminCALCS2MSS4)
{
dn1000S2MSS4 = minValueDosS2MSS4;
go to dn1000S2MSS4jumper;
}
}
else
{
minValueDosS2MSS4 = allValuesDosS2MSS4[i+1];
actualCountDosS2MSS4 = 0;
}
}
dn1000S2MSS4jumper:
if (dn1000S2MSS4 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S2MSS4 = allValuesDosS2MSS4[1];
}
if (dn1000S2MSS4 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S2MSS4 = allValuesDosS2MSS4[1];
}
printf("dn1000 Scene 2 MSS4: %12f\n", dn1000S2MSS4);
################################### Pathradiance Calculation #######################################
numeric pathRadS2MSS1 = dn1000S2MSS1 - (0.01 * (radsurfMSS2b1 * cos(s2zenith)) / pi);
numeric pathRadS2MSS2 = dn1000S2MSS2 - (0.01 * (radsurfMSS2b2 * cos(s2zenith)) / pi);
numeric pathRadS2MSS3 = dn1000S2MSS3 - (0.01 * (radsurfMSS2b3 * cos(s2zenith)) / pi);
numeric pathRadS2MSS4 = dn1000S2MSS4 - (0.01 * (radsurfMSS2b4 * cos(s2zenith)) / pi);
printf("Pathradiance Scene 2 Band 1: %12f\n", pathRadS2MSS1);
printf("Pathradiance Scene 2 Band 2: %12f\n", pathRadS2MSS2);
printf("Pathradiance Scene 2 Band 3: %12f\n", pathRadS2MSS3);
printf("Pathradiance Scene 2 Band 4: %12f\n\n", pathRadS2MSS4);
################################# Reflectance Calculation with athmo correction
for i = 1 to MSSlins
{
for j = 1 to MSScols
{
valueS2MSS1 = (pi * (RADS2MSS1[i,j] - pathRadS2MSS1)) / (radsurfMSS2b1 * cos(s2zenith));
if ( valueS2MSS1 < 0 )
{
valueS2MSS1 = 0;
countS2REFnullMSS1 = countS2REFnullMSS1 + 1;
}
else if ( valueS2MSS1 > 1 )
{
valueS2MSS1 = 1;
countS2REFoneMSS1 = countS2REFoneMSS1 + 1;
}
REFS2MSS1[i,j] = valueS2MSS1;
valueS2MSS2 = (pi * (RADS2MSS2[i,j] - pathRadS2MSS2)) / (radsurfMSS2b2 * cos(s2zenith));
if ( valueS2MSS2 < 0 )
{
valueS2MSS2 = 0;
countS2REFnullMSS2 = countS2REFnullMSS2 + 1;
}
else if ( valueS2MSS2 > 1 )
{
valueS2MSS2 = 1;
countS2REFoneMSS2 = countS2REFoneMSS2 + 1;
}
REFS2MSS2[i,j] = valueS2MSS2;
valueS2MSS3 = (pi * (RADS2MSS3[i,j] - pathRadS2MSS3)) / (radsurfMSS2b3 * cos(s2zenith));
if ( valueS2MSS3 < 0 )
{
valueS2MSS3 = 0;
countS2REFnullMSS3 = countS2REFnullMSS3 + 1;
}
else if ( valueS2MSS3 > 1 )
{
valueS2MSS3 = 1;
countS2REFoneMSS3 = countS2REFoneMSS3 + 1;
}
REFS2MSS3[i,j] = valueS2MSS3;
valueS2MSS4 = (pi * (RADS2MSS4[i,j] - pathRadS2MSS4)) / (radsurfMSS2b4 * cos(s2zenith));
if ( valueS2MSS4 < 0 )
{
valueS2MSS4 = 0;
countS2REFnullMSS4 = countS2REFnullMSS4 + 1;
}
else if ( valueS2MSS4 > 1 )
{
valueS2MSS4 = 1;
countS2REFoneMSS4 = countS2REFoneMSS4 + 1;
}
REFS2MSS4[i,j] = valueS2MSS4;
}
}
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 2 Band 1: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS2REFnullMSS1, countS2REFoneMSS1);
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 2 Band 2: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS2REFnullMSS2, countS2REFoneMSS2);
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 2 Band 3: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS2REFnullMSS3, countS2REFoneMSS3);
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 2 Band 4: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS2REFnullMSS4, countS2REFoneMSS4);
CreatePyramid(REFS2MSS1);
CreatePyramid(REFS2MSS2);
CreatePyramid(REFS2MSS3);
CreatePyramid(REFS2MSS4);
CreateHistogram(REFS2MSS1);
CreateHistogram(REFS2MSS2);
CreateHistogram(REFS2MSS3);
CreateHistogram(REFS2MSS4);
CloseRaster(RADS2MSS1);
CloseRaster(RADS2MSS2);
CloseRaster(RADS2MSS3);
CloseRaster(RADS2MSS4);
printf("Reflectance calculation for Scene 2 (MSS) is done...\n\n\n");
}
else if ( sensors2 == 4 ) # MSS 4
{
raster REFS2MSS1, REFS2MSS2, REFS2MSS3, REFS2MSS4;
numeric radsurfMSS2b1, radsurfMSS2b2, radsurfMSS2b3, radsurfMSS2b4;
numeric valueS2MSS1, valueS2MSS2, valueS2MSS3, valueS2MSS4;
numeric dosS2MSS1nullValCount = 0;
numeric dosS2MSS2nullValCount = 0;
numeric dosS2MSS3nullValCount = 0;
numeric dosS2MSS4nullValCount = 0;
numeric dosS2MSS1realArrayCount = 1;
numeric dosS2MSS2realArrayCount = 1;
numeric dosS2MSS3realArrayCount = 1;
numeric dosS2MSS4realArrayCount = 1;
numeric countS2REFnullMSS1 = 0;
numeric countS2REFnullMSS2 = 0;
numeric countS2REFnullMSS3 = 0;
numeric countS2REFnullMSS4 = 0;
numeric countS2REFoneMSS1 = 0;
numeric countS2REFoneMSS2 = 0;
numeric countS2REFoneMSS3 = 0;
numeric countS2REFoneMSS4 = 0;
radsurfMSS2b1 = ESMSS41 / (dist2^2);
radsurfMSS2b2 = ESMSS42 / (dist2^2);
radsurfMSS2b3 = ESMSS43 / (dist2^2);
radsurfMSS2b4 = ESMSS44 / (dist2^2);
printf("Surface Radiance MSS Band 1 in W/m^2µm (Scene 2): %12f\n", radsurfMSS2b1);
printf("Surface Radiance MSS Band 2 in W/m^2µm (Scene 2): %12f\n", radsurfMSS2b2);
printf("Surface Radiance MSS Band 3 in W/m^2µm (Scene 2): %12f\n", radsurfMSS2b3);
printf("Surface Radiance MSS Band 4 in W/m^2µm (Scene 2): %12f\n\n", radsurfMSS2b4);
for i = 1 to MSSlins
{
for j = 1 to MSScols
{
if (IsNull(RADS2MSS1[i,j]) == 1)
{
dosS2MSS1nullValCount = dosS2MSS1nullValCount + 1;
}
if (IsNull(RADS2MSS2[i,j]) == 1)
{
dosS2MSS2nullValCount = dosS2MSS2nullValCount + 1;
}
if (IsNull(RADS2MSS3[i,j]) == 1)
{
dosS2MSS3nullValCount = dosS2MSS3nullValCount + 1;
}
if (IsNull(RADS2MSS4[i,j]) == 1)
{
dosS2MSS4nullValCount = dosS2MSS4nullValCount + 1;
}
}
}
numeric dosS2MSS1realSize = (MSSlins * MSScols) - dosS2MSS1nullValCount;
numeric dosS2MSS2realSize = (MSSlins * MSScols) - dosS2MSS2nullValCount;
numeric dosS2MSS3realSize = (MSSlins * MSScols) - dosS2MSS3nullValCount;
numeric dosS2MSS4realSize = (MSSlins * MSScols) - dosS2MSS4nullValCount;
array allValuesDosS2MSS1[dosS2MSS1realSize];
array allValuesDosS2MSS2[dosS2MSS2realSize];
array allValuesDosS2MSS3[dosS2MSS3realSize];
array allValuesDosS2MSS4[dosS2MSS4realSize];
numeric DNminCALCS2MSS1 = DNminCALC(Scene2Lin, Scene2Col, dosS2MSS1realSize);
numeric DNminCALCS2MSS2 = DNminCALC(Scene2Lin, Scene2Col, dosS2MSS2realSize);
numeric DNminCALCS2MSS3 = DNminCALC(Scene2Lin, Scene2Col, dosS2MSS3realSize);
numeric DNminCALCS2MSS4 = DNminCALC(Scene2Lin, Scene2Col, dosS2MSS4realSize);
for i = 1 to MSSlins
{
for j = 1 to MSScols
{
if (IsNull(RADS2MSS1[i,j]) == 0)
{
allValuesDosS2MSS1[dosS2MSS1realArrayCount] = RADS2MSS1[i,j];
dosS2MSS1realArrayCount = dosS2MSS1realArrayCount + 1;
}
if (IsNull(RADS2MSS2[i,j]) == 0)
{
allValuesDosS2MSS2[dosS2MSS2realArrayCount] = RADS2MSS2[i,j];
dosS2MSS2realArrayCount = dosS2MSS2realArrayCount + 1;
}
if (IsNull(RADS2MSS3[i,j]) == 0)
{
allValuesDosS2MSS3[dosS2MSS3realArrayCount] = RADS2MSS3[i,j];
dosS2MSS3realArrayCount = dosS2MSS3realArrayCount + 1;
}
if (IsNull(RADS2MSS4[i,j]) == 0)
{
allValuesDosS2MSS4[dosS2MSS4realArrayCount] = RADS2MSS4[i,j];
dosS2MSS4realArrayCount = dosS2MSS4realArrayCount + 1;
}
}
}
########################### Scene 2 - Dn1000 - Band 1
numeric lastDOSS2MSS1 = dosS2MSS1realSize;
numeric hDOSS2MSS1 = 1;
while ( (hDOSS2MSS1 * 3 + 1) < lastDOSS2MSS1 - 1 )
{
hDOSS2MSS1 = 3 * hDOSS2MSS1 + 1;
}
while ( hDOSS2MSS1 > 0 )
{
for i = hDOSS2MSS1 - 1 to lastDOSS2MSS1 # for each of the h sets of elements
{
numeric keyDOSS2MSS1 = allValuesDosS2MSS1[i];
numeric jDOSS2MSS1 = i;
while (jDOSS2MSS1 >= hDOSS2MSS1 && allValuesDosS2MSS1[jDOSS2MSS1 - hDOSS2MSS1] > keyDOSS2MSS1)
{
allValuesDosS2MSS1[jDOSS2MSS1] = allValuesDosS2MSS1[jDOSS2MSS1 - hDOSS2MSS1];
jDOSS2MSS1 = jDOSS2MSS1 - hDOSS2MSS1;
}
allValuesDosS2MSS1[jDOSS2MSS1] = keyDOSS2MSS1;
}
hDOSS2MSS1 = floor(hDOSS2MSS1/3);
}
numeric minValueDosS2MSS1 = allValuesDosS2MSS1[1];
numeric dn1000S2MSS1 = 10000;
numeric actualCountDosS2MSS1 = 0;
for i = 1 to dosS2MSS1realSize
{
if (allValuesDosS2MSS1[i] == minValueDosS2MSS1)
{
actualCountDosS2MSS1 = actualCountDosS2MSS1 + 1;
if (actualCountDosS2MSS1 >= DNminCALCS2MSS1)
{
dn1000S2MSS1 = minValueDosS2MSS1;
go to dn1000S2MSS1jumper;
}
}
else
{
minValueDosS2MSS1 = allValuesDosS2MSS1[i+1];
actualCountDosS2MSS1 = 0;
}
}
dn1000S2MSS1jumper:
if (dn1000S2MSS1 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S2MSS1 = allValuesDosS2MSS1[1];
}
if (dn1000S2MSS1 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S2MSS1 = allValuesDosS2MSS1[1];
}
printf("dn1000 Scene 2 MSS1: %12f\n", dn1000S2MSS1);
########################### Scene 2 - Dn1000 - Band 2
numeric lastDOSS2MSS2 = dosS2MSS1realSize;
numeric hDOSS2MSS2 = 1;
while ( (hDOSS2MSS2 * 3 + 1) < lastDOSS2MSS2 - 1 )
{
hDOSS2MSS2 = 3 * hDOSS2MSS2 + 1;
}
while ( hDOSS2MSS2 > 0 )
{
for i = hDOSS2MSS2 - 1 to lastDOSS2MSS2
{
numeric keyDOSS2MSS2 = allValuesDosS2MSS2[i];
numeric jDOSS2MSS2 = i;
while (jDOSS2MSS2 >= hDOSS2MSS2 && allValuesDosS2MSS2[jDOSS2MSS2 - hDOSS2MSS2] > keyDOSS2MSS2)
{
allValuesDosS2MSS2[jDOSS2MSS2] = allValuesDosS2MSS2[jDOSS2MSS2 - hDOSS2MSS2];
jDOSS2MSS2 = jDOSS2MSS2 - hDOSS2MSS2;
}
allValuesDosS2MSS2[jDOSS2MSS2] = keyDOSS2MSS2;
}
hDOSS2MSS2 = floor(hDOSS2MSS2/3);
}
numeric minValueDosS2MSS2 = allValuesDosS2MSS2[1];
numeric dn1000S2MSS2 = 10000;
numeric actualCountDosS2MSS2 = 0;
for i = 1 to dosS2MSS2realSize
{
if (allValuesDosS2MSS2[i] == minValueDosS2MSS2)
{
actualCountDosS2MSS2 = actualCountDosS2MSS2 + 1;
if (actualCountDosS2MSS2 >= DNminCALCS2MSS2)
{
dn1000S2MSS2 = minValueDosS2MSS2;
go to dn1000S2MSS2jumper;
}
}
else
{
minValueDosS2MSS2 = allValuesDosS2MSS2[i+1];
actualCountDosS2MSS2 = 0;
}
}
dn1000S2MSS2jumper:
if (dn1000S2MSS2 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S2MSS2 = allValuesDosS2MSS2[1];
}
if (dn1000S2MSS2 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S2MSS2 = allValuesDosS2MSS2[1];
}
printf("dn1000 Scene 2 MSS2: %12f\n", dn1000S2MSS2);
########################### Scene 2 - Dn1000 - Band 3
numeric lastDOSS2MSS3 = dosS2MSS3realSize;
numeric hDOSS2MSS3 = 1;
while ( (hDOSS2MSS3 * 3 + 1) < lastDOSS2MSS3 - 1 )
{
hDOSS2MSS3 = 3 * hDOSS2MSS3 + 1;
}
while ( hDOSS2MSS3 > 0 )
{
for i = hDOSS2MSS3 - 1 to lastDOSS2MSS3 # for each of the h sets of elements
{
numeric keyDOSS2MSS3 = allValuesDosS2MSS3[i];
numeric jDOSS2MSS3 = i;
while (jDOSS2MSS3 >= hDOSS2MSS3 && allValuesDosS2MSS3[jDOSS2MSS3 - hDOSS2MSS3] > keyDOSS2MSS3)
{
allValuesDosS2MSS3[jDOSS2MSS3] = allValuesDosS2MSS3[jDOSS2MSS3 - hDOSS2MSS3];
jDOSS2MSS3 = jDOSS2MSS3 - hDOSS2MSS3;
}
allValuesDosS2MSS3[jDOSS2MSS3] = keyDOSS2MSS3;
}
hDOSS2MSS3 = floor(hDOSS2MSS3/3);
}
numeric minValueDosS2MSS3 = allValuesDosS2MSS3[1];
numeric dn1000S2MSS3 = 10000;
numeric actualCountDosS2MSS3 = 0;
for i = 1 to dosS2MSS3realSize
{
if (allValuesDosS2MSS3[i] == minValueDosS2MSS3)
{
actualCountDosS2MSS3 = actualCountDosS2MSS3 + 1;
if (actualCountDosS2MSS3 >= DNminCALCS2MSS3)
{
dn1000S2MSS3 = minValueDosS2MSS3;
go to dn1000S2MSS3jumper;
}
}
else
{
minValueDosS2MSS3 = allValuesDosS2MSS3[i+1];
actualCountDosS2MSS3 = 0;
}
}
dn1000S2MSS3jumper:
if (dn1000S2MSS3 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S2MSS3 = allValuesDosS2MSS3[1];
}
if (dn1000S2MSS3 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S2MSS3 = allValuesDosS2MSS3[1];
}
printf("dn1000 Scene 2 MSS3: %12f\n", dn1000S2MSS3);
########################### Scene 2 - Dn1000 - Band 4
numeric lastDOSS2MSS4 = dosS2MSS4realSize;
numeric hDOSS2MSS4 = 1;
while ( (hDOSS2MSS4 * 3 + 1) < lastDOSS2MSS4 - 1 )
{
hDOSS2MSS4 = 3 * hDOSS2MSS4 + 1;
}
while ( hDOSS2MSS4 > 0 )
{
for i = hDOSS2MSS4 - 1 to lastDOSS2MSS4
{
numeric keyDOSS2MSS4 = allValuesDosS2MSS4[i];
numeric jDOSS2MSS4 = i;
while (jDOSS2MSS4 >= hDOSS2MSS4 && allValuesDosS2MSS4[jDOSS2MSS4 - hDOSS2MSS4] > keyDOSS2MSS4)
{
allValuesDosS2MSS4[jDOSS2MSS4] = allValuesDosS2MSS4[jDOSS2MSS4 - hDOSS2MSS4];
jDOSS2MSS4 = jDOSS2MSS4 - hDOSS2MSS4;
}
allValuesDosS2MSS4[jDOSS2MSS4] = keyDOSS2MSS4;
}
hDOSS2MSS4 = floor(hDOSS2MSS4/3);
}
numeric minValueDosS2MSS4 = allValuesDosS2MSS4[1];
numeric dn1000S2MSS4 = 10000;
numeric actualCountDosS2MSS4 = 0;
for i = 1 to dosS2MSS4realSize
{
if (allValuesDosS2MSS4[i] == minValueDosS2MSS4)
{
actualCountDosS2MSS4 = actualCountDosS2MSS4 + 1;
if (actualCountDosS2MSS4 >= DNminCALCS2MSS4)
{
dn1000S2MSS4 = minValueDosS2MSS4;
go to dn1000S2MSS4jumper;
}
}
else
{
minValueDosS2MSS4 = allValuesDosS2MSS4[i+1];
actualCountDosS2MSS4 = 0;
}
}
dn1000S2MSS4jumper:
if (dn1000S2MSS4 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S2MSS4 = allValuesDosS2MSS4[1];
}
if (dn1000S2MSS4 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S2MSS4 = allValuesDosS2MSS4[1];
}
printf("dn1000 Scene 2 MSS4: %12f\n", dn1000S2MSS4);
################################### Pathradiance Calculation #######################################
numeric pathRadS2MSS1 = dn1000S2MSS1 - (0.01 * (radsurfMSS2b1 * cos(s2zenith)) / pi);
numeric pathRadS2MSS2 = dn1000S2MSS2 - (0.01 * (radsurfMSS2b2 * cos(s2zenith)) / pi);
numeric pathRadS2MSS3 = dn1000S2MSS3 - (0.01 * (radsurfMSS2b3 * cos(s2zenith)) / pi);
numeric pathRadS2MSS4 = dn1000S2MSS4 - (0.01 * (radsurfMSS2b4 * cos(s2zenith)) / pi);
printf("Pathradiance Scene 2 Band 1: %12f\n", pathRadS2MSS1);
printf("Pathradiance Scene 2 Band 2: %12f\n", pathRadS2MSS2);
printf("Pathradiance Scene 2 Band 3: %12f\n", pathRadS2MSS3);
printf("Pathradiance Scene 2 Band 4: %12f\n\n", pathRadS2MSS4);
################################# Reflectance Calculation with athmo correction
for i = 1 to MSSlins
{
for j = 1 to MSScols
{
valueS2MSS1 = (pi * (RADS2MSS1[i,j] - pathRadS2MSS1)) / (radsurfMSS2b1 * cos(s2zenith));
if ( valueS2MSS1 < 0 )
{
valueS2MSS1 = 0;
countS2REFnullMSS1 = countS2REFnullMSS1 + 1;
}
else if ( valueS2MSS1 > 1 )
{
valueS2MSS1 = 1;
countS2REFoneMSS1 = countS2REFoneMSS1 + 1;
}
REFS2MSS1[i,j] = valueS2MSS1;
valueS2MSS2 = (pi * (RADS2MSS2[i,j] - pathRadS2MSS2)) / (radsurfMSS2b2 * cos(s2zenith));
if ( valueS2MSS2 < 0 )
{
valueS2MSS2 = 0;
countS2REFnullMSS2 = countS2REFnullMSS2 + 1;
}
else if ( valueS2MSS2 > 1 )
{
valueS2MSS2 = 1;
countS2REFoneMSS2 = countS2REFoneMSS2 + 1;
}
REFS2MSS2[i,j] = valueS2MSS2;
valueS2MSS3 = (pi * (RADS2MSS3[i,j] - pathRadS2MSS3)) / (radsurfMSS2b3 * cos(s2zenith));
if ( valueS2MSS3 < 0 )
{
valueS2MSS3 = 0;
countS2REFnullMSS3 = countS2REFnullMSS3 + 1;
}
else if ( valueS2MSS3 > 1 )
{
valueS2MSS3 = 1;
countS2REFoneMSS3 = countS2REFoneMSS3 + 1;
}
REFS2MSS3[i,j] = valueS2MSS3;
valueS2MSS4 = (pi * (RADS2MSS4[i,j] - pathRadS2MSS4)) / (radsurfMSS2b4 * cos(s2zenith));
if ( valueS2MSS4 < 0 )
{
valueS2MSS4 = 0;
countS2REFnullMSS4 = countS2REFnullMSS4 + 1;
}
else if ( valueS2MSS4 > 1 )
{
valueS2MSS4 = 1;
countS2REFoneMSS4 = countS2REFoneMSS4 + 1;
}
REFS2MSS4[i,j] = valueS2MSS4;
}
}
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 2 Band 1: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS2REFnullMSS1, countS2REFoneMSS1);
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 2 Band 2: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS2REFnullMSS2, countS2REFoneMSS2);
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 2 Band 3: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS2REFnullMSS3, countS2REFoneMSS3);
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 2 Band 4: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS2REFnullMSS4, countS2REFoneMSS4);
CreatePyramid(REFS2MSS1);
CreatePyramid(REFS2MSS2);
CreatePyramid(REFS2MSS3);
CreatePyramid(REFS2MSS4);
CreateHistogram(REFS2MSS1);
CreateHistogram(REFS2MSS2);
CreateHistogram(REFS2MSS3);
CreateHistogram(REFS2MSS4);
CloseRaster(RADS2MSS1);
CloseRaster(RADS2MSS2);
CloseRaster(RADS2MSS3);
CloseRaster(RADS2MSS4);
printf("Reflectance calculation for Scene 2 (MSS) is done...\n\n\n");
}
else # MSS 1, 2 and 3
{
raster REFS2MSS1, REFS2MSS2, REFS2MSS3, REFS2MSS4;
numeric radsurfMSS2b1, radsurfMSS2b2, radsurfMSS2b3, radsurfMSS2b4;
numeric valueS2MSS1, valueS2MSS2, valueS2MSS3, valueS2MSS4;
numeric dosS2MSS1nullValCount = 0;
numeric dosS2MSS2nullValCount = 0;
numeric dosS2MSS3nullValCount = 0;
numeric dosS2MSS4nullValCount = 0;
numeric dosS2MSS1realArrayCount = 1;
numeric dosS2MSS2realArrayCount = 1;
numeric dosS2MSS3realArrayCount = 1;
numeric dosS2MSS4realArrayCount = 1;
numeric countS2REFnullMSS1 = 0;
numeric countS2REFnullMSS2 = 0;
numeric countS2REFnullMSS3 = 0;
numeric countS2REFnullMSS4 = 0;
numeric countS2REFoneMSS1 = 0;
numeric countS2REFoneMSS2 = 0;
numeric countS2REFoneMSS3 = 0;
numeric countS2REFoneMSS4 = 0;
radsurfMSS2b1 = ESMSS11 / (dist2^2);
radsurfMSS2b2 = ESMSS12 / (dist2^2);
radsurfMSS2b3 = ESMSS13 / (dist2^2);
radsurfMSS2b4 = ESMSS14 / (dist2^2);
printf("Surface Radiance MSS Band 1 in W/m^2µm (Scene 2): %12f\n", radsurfMSS2b1);
printf("Surface Radiance MSS Band 2 in W/m^2µm (Scene 2): %12f\n", radsurfMSS2b2);
printf("Surface Radiance MSS Band 3 in W/m^2µm (Scene 2): %12f\n", radsurfMSS2b3);
printf("Surface Radiance MSS Band 4 in W/m^2µm (Scene 2): %12f\n\n", radsurfMSS2b4);
for i = 1 to MSSlins
{
for j = 1 to MSScols
{
if (IsNull(RADS2MSS1[i,j]) == 1)
{
dosS2MSS1nullValCount = dosS2MSS1nullValCount + 1;
}
if (IsNull(RADS2MSS2[i,j]) == 1)
{
dosS2MSS2nullValCount = dosS2MSS2nullValCount + 1;
}
if (IsNull(RADS2MSS3[i,j]) == 1)
{
dosS2MSS3nullValCount = dosS2MSS3nullValCount + 1;
}
if (IsNull(RADS2MSS4[i,j]) == 1)
{
dosS2MSS4nullValCount = dosS2MSS4nullValCount + 1;
}
}
}
numeric dosS2MSS1realSize = (MSSlins * MSScols) - dosS2MSS1nullValCount;
numeric dosS2MSS2realSize = (MSSlins * MSScols) - dosS2MSS2nullValCount;
numeric dosS2MSS3realSize = (MSSlins * MSScols) - dosS2MSS3nullValCount;
numeric dosS2MSS4realSize = (MSSlins * MSScols) - dosS2MSS4nullValCount;
array allValuesDosS2MSS1[dosS2MSS1realSize];
array allValuesDosS2MSS2[dosS2MSS2realSize];
array allValuesDosS2MSS3[dosS2MSS3realSize];
array allValuesDosS2MSS4[dosS2MSS4realSize];
numeric DNminCALCS2MSS1 = DNminCALC(Scene2Lin, Scene2Col, dosS2MSS1realSize);
numeric DNminCALCS2MSS2 = DNminCALC(Scene2Lin, Scene2Col, dosS2MSS2realSize);
numeric DNminCALCS2MSS3 = DNminCALC(Scene2Lin, Scene2Col, dosS2MSS3realSize);
numeric DNminCALCS2MSS4 = DNminCALC(Scene2Lin, Scene2Col, dosS2MSS4realSize);
for i = 1 to MSSlins
{
for j = 1 to MSScols
{
if (IsNull(RADS2MSS1[i,j]) == 0)
{
allValuesDosS2MSS1[dosS2MSS1realArrayCount] = RADS2MSS1[i,j];
dosS2MSS1realArrayCount = dosS2MSS1realArrayCount + 1;
}
if (IsNull(RADS2MSS2[i,j]) == 0)
{
allValuesDosS2MSS2[dosS2MSS2realArrayCount] = RADS2MSS2[i,j];
dosS2MSS2realArrayCount = dosS2MSS2realArrayCount + 1;
}
if (IsNull(RADS2MSS3[i,j]) == 0)
{
allValuesDosS2MSS3[dosS2MSS3realArrayCount] = RADS2MSS3[i,j];
dosS2MSS3realArrayCount = dosS2MSS3realArrayCount + 1;
}
if (IsNull(RADS2MSS4[i,j]) == 0)
{
allValuesDosS2MSS4[dosS2MSS4realArrayCount] = RADS2MSS4[i,j];
dosS2MSS4realArrayCount = dosS2MSS4realArrayCount + 1;
}
}
}
########################### Scene 2 - Dn1000 - Band 1
numeric lastDOSS2MSS1 = dosS2MSS1realSize;
numeric hDOSS2MSS1 = 1;
while ( (hDOSS2MSS1 * 3 + 1) < lastDOSS2MSS1 - 1 )
{
hDOSS2MSS1 = 3 * hDOSS2MSS1 + 1;
}
while ( hDOSS2MSS1 > 0 )
{
for i = hDOSS2MSS1 - 1 to lastDOSS2MSS1 # for each of the h sets of elements
{
numeric keyDOSS2MSS1 = allValuesDosS2MSS1[i];
numeric jDOSS2MSS1 = i;
while (jDOSS2MSS1 >= hDOSS2MSS1 && allValuesDosS2MSS1[jDOSS2MSS1 - hDOSS2MSS1] > keyDOSS2MSS1)
{
allValuesDosS2MSS1[jDOSS2MSS1] = allValuesDosS2MSS1[jDOSS2MSS1 - hDOSS2MSS1];
jDOSS2MSS1 = jDOSS2MSS1 - hDOSS2MSS1;
}
allValuesDosS2MSS1[jDOSS2MSS1] = keyDOSS2MSS1;
}
hDOSS2MSS1 = floor(hDOSS2MSS1/3);
}
numeric minValueDosS2MSS1 = allValuesDosS2MSS1[1];
numeric dn1000S2MSS1 = 10000;
numeric actualCountDosS2MSS1 = 0;
for i = 1 to dosS2MSS1realSize
{
if (allValuesDosS2MSS1[i] == minValueDosS2MSS1)
{
actualCountDosS2MSS1 = actualCountDosS2MSS1 + 1;
if (actualCountDosS2MSS1 >= DNminCALCS2MSS1)
{
dn1000S2MSS1 = minValueDosS2MSS1;
go to dn1000S2MSS1jumper;
}
}
else
{
minValueDosS2MSS1 = allValuesDosS2MSS1[i+1];
actualCountDosS2MSS1 = 0;
}
}
dn1000S2MSS1jumper:
if (dn1000S2MSS1 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S2MSS1 = allValuesDosS2MSS1[1];
}
if (dn1000S2MSS1 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S2MSS1 = allValuesDosS2MSS1[1];
}
printf("dn1000 Scene 2 MSS1: %12f\n", dn1000S2MSS1);
########################### Scene 2 - Dn1000 - Band 2
numeric lastDOSS2MSS2 = dosS2MSS1realSize;
numeric hDOSS2MSS2 = 1;
while ( (hDOSS2MSS2 * 3 + 1) < lastDOSS2MSS2 - 1 )
{
hDOSS2MSS2 = 3 * hDOSS2MSS2 + 1;
}
while ( hDOSS2MSS2 > 0 )
{
for i = hDOSS2MSS2 - 1 to lastDOSS2MSS2
{
numeric keyDOSS2MSS2 = allValuesDosS2MSS2[i];
numeric jDOSS2MSS2 = i;
while (jDOSS2MSS2 >= hDOSS2MSS2 && allValuesDosS2MSS2[jDOSS2MSS2 - hDOSS2MSS2] > keyDOSS2MSS2)
{
allValuesDosS2MSS2[jDOSS2MSS2] = allValuesDosS2MSS2[jDOSS2MSS2 - hDOSS2MSS2];
jDOSS2MSS2 = jDOSS2MSS2 - hDOSS2MSS2;
}
allValuesDosS2MSS2[jDOSS2MSS2] = keyDOSS2MSS2;
}
hDOSS2MSS2 = floor(hDOSS2MSS2/3);
}
numeric minValueDosS2MSS2 = allValuesDosS2MSS2[1];
numeric dn1000S2MSS2 = 10000;
numeric actualCountDosS2MSS2 = 0;
for i = 1 to dosS2MSS2realSize
{
if (allValuesDosS2MSS2[i] == minValueDosS2MSS2)
{
actualCountDosS2MSS2 = actualCountDosS2MSS2 + 1;
if (actualCountDosS2MSS2 >= DNminCALCS2MSS2)
{
dn1000S2MSS2 = minValueDosS2MSS2;
go to dn1000S2MSS2jumper;
}
}
else
{
minValueDosS2MSS2 = allValuesDosS2MSS2[i+1];
actualCountDosS2MSS2 = 0;
}
}
dn1000S2MSS2jumper:
if (dn1000S2MSS2 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S2MSS2 = allValuesDosS2MSS2[1];
}
if (dn1000S2MSS2 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S2MSS2 = allValuesDosS2MSS2[1];
}
printf("dn1000 Scene 2 MSS2: %12f\n", dn1000S2MSS2);
########################### Scene 2 - Dn1000 - Band 3
numeric lastDOSS2MSS3 = dosS2MSS3realSize;
numeric hDOSS2MSS3 = 1;
while ( (hDOSS2MSS3 * 3 + 1) < lastDOSS2MSS3 - 1 )
{
hDOSS2MSS3 = 3 * hDOSS2MSS3 + 1;
}
while ( hDOSS2MSS3 > 0 )
{
for i = hDOSS2MSS3 - 1 to lastDOSS2MSS3 # for each of the h sets of elements
{
numeric keyDOSS2MSS3 = allValuesDosS2MSS3[i];
numeric jDOSS2MSS3 = i;
while (jDOSS2MSS3 >= hDOSS2MSS3 && allValuesDosS2MSS3[jDOSS2MSS3 - hDOSS2MSS3] > keyDOSS2MSS3)
{
allValuesDosS2MSS3[jDOSS2MSS3] = allValuesDosS2MSS3[jDOSS2MSS3 - hDOSS2MSS3];
jDOSS2MSS3 = jDOSS2MSS3 - hDOSS2MSS3;
}
allValuesDosS2MSS3[jDOSS2MSS3] = keyDOSS2MSS3;
}
hDOSS2MSS3 = floor(hDOSS2MSS3/3);
}
numeric minValueDosS2MSS3 = allValuesDosS2MSS3[1];
numeric dn1000S2MSS3 = 10000;
numeric actualCountDosS2MSS3 = 0;
for i = 1 to dosS2MSS3realSize
{
if (allValuesDosS2MSS3[i] == minValueDosS2MSS3)
{
actualCountDosS2MSS3 = actualCountDosS2MSS3 + 1;
if (actualCountDosS2MSS3 >= DNminCALCS2MSS3)
{
dn1000S2MSS3 = minValueDosS2MSS3;
go to dn1000S2MSS3jumper;
}
}
else
{
minValueDosS2MSS3 = allValuesDosS2MSS3[i+1];
actualCountDosS2MSS3 = 0;
}
}
dn1000S2MSS3jumper:
if (dn1000S2MSS3 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S2MSS3 = allValuesDosS2MSS3[1];
}
if (dn1000S2MSS3 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S2MSS3 = allValuesDosS2MSS3[1];
}
printf("dn1000 Scene 2 MSS3: %12f\n", dn1000S2MSS3);
########################### Scene 1 - Dn1000 - Band 4
numeric lastDOSS2MSS4 = dosS2MSS4realSize;
numeric hDOSS2MSS4 = 1;
while ( (hDOSS2MSS4 * 3 + 1) < lastDOSS2MSS4 - 1 )
{
hDOSS2MSS4 = 3 * hDOSS2MSS4 + 1;
}
while ( hDOSS2MSS4 > 0 )
{
for i = hDOSS2MSS4 - 1 to lastDOSS2MSS4
{
numeric keyDOSS2MSS4 = allValuesDosS2MSS4[i];
numeric jDOSS2MSS4 = i;
while (jDOSS2MSS4 >= hDOSS2MSS4 && allValuesDosS2MSS4[jDOSS2MSS4 - hDOSS2MSS4] > keyDOSS2MSS4)
{
allValuesDosS2MSS4[jDOSS2MSS4] = allValuesDosS2MSS4[jDOSS2MSS4 - hDOSS2MSS4];
jDOSS2MSS4 = jDOSS2MSS4 - hDOSS2MSS4;
}
allValuesDosS2MSS4[jDOSS2MSS4] = keyDOSS2MSS4;
}
hDOSS2MSS4 = floor(hDOSS2MSS4/3);
}
numeric minValueDosS2MSS4 = allValuesDosS2MSS4[1];
numeric dn1000S2MSS4 = 10000;
numeric actualCountDosS2MSS4 = 0;
for i = 1 to dosS2MSS4realSize
{
if (allValuesDosS2MSS4[i] == minValueDosS2MSS4)
{
actualCountDosS2MSS4 = actualCountDosS2MSS4 + 1;
if (actualCountDosS2MSS4 >= DNminCALCS2MSS4)
{
dn1000S2MSS4 = minValueDosS2MSS4;
go to dn1000S2MSS4jumper;
}
}
else
{
minValueDosS2MSS4 = allValuesDosS2MSS4[i+1];
actualCountDosS2MSS4 = 0;
}
}
dn1000S2MSS4jumper:
if (dn1000S2MSS4 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S2MSS4 = allValuesDosS2MSS4[1];
}
if (dn1000S2MSS4 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S2MSS4 = allValuesDosS2MSS4[1];
}
printf("dn1000 Scene 2 MSS4: %12f\n", dn1000S2MSS4);
################################### Pathradiance Calculation #######################################
numeric pathRadS2MSS1 = dn1000S2MSS1 - (0.01 * (radsurfMSS2b1 * cos(s2zenith)) / pi);
numeric pathRadS2MSS2 = dn1000S2MSS2 - (0.01 * (radsurfMSS2b2 * cos(s2zenith)) / pi);
numeric pathRadS2MSS3 = dn1000S2MSS3 - (0.01 * (radsurfMSS2b3 * cos(s2zenith)) / pi);
numeric pathRadS2MSS4 = dn1000S2MSS4 - (0.01 * (radsurfMSS2b4 * cos(s2zenith)) / pi);
printf("Pathradiance Scene 2 Band 1: %12f\n", pathRadS2MSS1);
printf("Pathradiance Scene 2 Band 2: %12f\n", pathRadS2MSS2);
printf("Pathradiance Scene 2 Band 3: %12f\n", pathRadS2MSS3);
printf("Pathradiance Scene 2 Band 4: %12f\n\n", pathRadS2MSS4);
################################# Reflectance Calculation with athmo correction
for i = 1 to MSSlins
{
for j = 1 to MSScols
{
valueS2MSS1 = (pi * (RADS2MSS1[i,j] - pathRadS2MSS1)) / (radsurfMSS2b1 * cos(s2zenith));
if ( valueS2MSS1 < 0 )
{
valueS2MSS1 = 0;
countS2REFnullMSS1 = countS2REFnullMSS1 + 1;
}
else if ( valueS2MSS1 > 1 )
{
valueS2MSS1 = 1;
countS2REFoneMSS1 = countS2REFoneMSS1 + 1;
}
REFS2MSS1[i,j] = valueS2MSS1;
valueS2MSS2 = (pi * (RADS2MSS2[i,j] - pathRadS2MSS2)) / (radsurfMSS2b2 * cos(s2zenith));
if ( valueS2MSS2 < 0 )
{
valueS2MSS2 = 0;
countS2REFnullMSS2 = countS2REFnullMSS2 + 1;
}
else if ( valueS2MSS2 > 1 )
{
valueS2MSS2 = 1;
countS2REFoneMSS2 = countS2REFoneMSS2 + 1;
}
REFS2MSS2[i,j] = valueS2MSS2;
valueS2MSS3 = (pi * (RADS2MSS3[i,j] - pathRadS2MSS3)) / (radsurfMSS2b3 * cos(s2zenith));
if ( valueS2MSS3 < 0 )
{
valueS2MSS3 = 0;
countS2REFnullMSS3 = countS2REFnullMSS3 + 1;
}
else if ( valueS2MSS3 > 1 )
{
valueS2MSS3 = 1;
countS2REFoneMSS3 = countS2REFoneMSS3 + 1;
}
REFS2MSS3[i,j] = valueS2MSS3;
valueS2MSS4 = (pi * (RADS2MSS4[i,j] - pathRadS2MSS4)) / (radsurfMSS2b4 * cos(s2zenith));
if ( valueS2MSS4 < 0 )
{
valueS2MSS4 = 0;
countS2REFnullMSS4 = countS2REFnullMSS4 + 1;
}
else if ( valueS2MSS4 > 1 )
{
valueS2MSS4 = 1;
countS2REFoneMSS4 = countS2REFoneMSS4 + 1;
}
REFS2MSS4[i,j] = valueS2MSS4;
}
}
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 2 Band 1: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS2REFnullMSS1, countS2REFoneMSS1);
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 2 Band 2: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS2REFnullMSS2, countS2REFoneMSS2);
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 2 Band 3: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS2REFnullMSS3, countS2REFoneMSS3);
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 2 Band 4: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS2REFnullMSS4, countS2REFoneMSS4);
CreatePyramid(REFS2MSS1);
CreatePyramid(REFS2MSS2);
CreatePyramid(REFS2MSS3);
CreatePyramid(REFS2MSS4);
CreateHistogram(REFS2MSS1);
CreateHistogram(REFS2MSS2);
CreateHistogram(REFS2MSS3);
CreateHistogram(REFS2MSS4);
CloseRaster(RADS2MSS1);
CloseRaster(RADS2MSS2);
CloseRaster(RADS2MSS3);
CloseRaster(RADS2MSS4);
printf("Reflectance calculation for Scene 2 (MSS) is done...\n\n\n");
}
#############################
#### Reflectance Scene 3
#############################
if ( sensors3 == 7 )
{
raster REFS3ETM1, REFS3ETM2, REFS3ETM3, REFS3ETM4, REFS3ETM5, REFS3ETM7;
numeric radsurfETMS3b1, radsurfETMS3b2, radsurfETMS3b3, radsurfETMS3b4, radsurfETMS3b5, radsurfETMS3b7;
numeric valueS3ETM1, valueS3ETM2, valueS3ETM3, valueS3ETM4, valueS3ETM5, valueS3ETM7;
numeric dosS3ETM1nullValCount = 0;
numeric dosS3ETM2nullValCount = 0;
numeric dosS3ETM3nullValCount = 0;
numeric dosS3ETM4nullValCount = 0;
numeric dosS3ETM5nullValCount = 0;
numeric dosS3ETM7nullValCount = 0;
numeric dosS3ETM1realArrayCount = 1;
numeric dosS3ETM2realArrayCount = 1;
numeric dosS3ETM3realArrayCount = 1;
numeric dosS3ETM4realArrayCount = 1;
numeric dosS3ETM5realArrayCount = 1;
numeric dosS3ETM7realArrayCount = 1;
numeric countS3REFnullETM1 = 0;
numeric countS3REFnullETM2 = 0;
numeric countS3REFnullETM3 = 0;
numeric countS3REFnullETM4 = 0;
numeric countS3REFnullETM5 = 0;
numeric countS3REFnullETM7 = 0;
numeric countS3REFoneETM1 = 0;
numeric countS3REFoneETM2 = 0;
numeric countS3REFoneETM3 = 0;
numeric countS3REFoneETM4 = 0;
numeric countS3REFoneETM5 = 0;
numeric countS3REFoneETM7 = 0;
radsurfETMS3b1 = ESETM1 / (dist3^2);
radsurfETMS3b2 = ESETM2 / (dist3^2);
radsurfETMS3b3 = ESETM3 / (dist3^2);
radsurfETMS3b4 = ESETM4 / (dist3^2);
radsurfETMS3b5 = ESETM5 / (dist3^2);
radsurfETMS3b7 = ESETM7 / (dist3^2);
printf("Surface Radiance ETM Band 1 in W/m^2µm (Scene 3): %12f\n", radsurfETMS3b1);
printf("Surface Radiance ETM Band 2 in W/m^2µm (Scene 3): %12f\n", radsurfETMS3b2);
printf("Surface Radiance ETM Band 3 in W/m^2µm (Scene 3): %12f\n", radsurfETMS3b3);
printf("Surface Radiance ETM Band 4 in W/m^2µm (Scene 3): %12f\n", radsurfETMS3b4);
printf("Surface Radiance ETM Band 5 in W/m^2µm (Scene 3): %12f\n", radsurfETMS3b5);
printf("Surface Radiance ETM Band 7 in W/m^2µm (Scene 3): %12f\n\n", radsurfETMS3b7);
for i = 1 to ETMlins
{
for j = 1 to ETMcols
{
if (IsNull(RADS3ETM1[i,j]) == 1)
{
dosS3ETM1nullValCount = dosS3ETM1nullValCount + 1;
}
if (IsNull(RADS3ETM2[i,j]) == 1)
{
dosS3ETM2nullValCount = dosS3ETM2nullValCount + 1;
}
if (IsNull(RADS3ETM3[i,j]) == 1)
{
dosS3ETM3nullValCount = dosS3ETM3nullValCount + 1;
}
if (IsNull(RADS3ETM4[i,j]) == 1)
{
dosS3ETM4nullValCount = dosS3ETM4nullValCount + 1;
}
if (IsNull(RADS3ETM5[i,j]) == 1)
{
dosS3ETM5nullValCount = dosS3ETM5nullValCount + 1;
}
if (IsNull(RADS3ETM7[i,j]) == 1)
{
dosS3ETM7nullValCount = dosS3ETM7nullValCount + 1;
}
}
}
numeric dosS3ETM1realSize = (ETMlins * ETMcols) - dosS3ETM1nullValCount;
numeric dosS3ETM2realSize = (ETMlins * ETMcols) - dosS3ETM2nullValCount;
numeric dosS3ETM3realSize = (ETMlins * ETMcols) - dosS3ETM3nullValCount;
numeric dosS3ETM4realSize = (ETMlins * ETMcols) - dosS3ETM4nullValCount;
numeric dosS3ETM5realSize = (ETMlins * ETMcols) - dosS3ETM5nullValCount;
numeric dosS3ETM7realSize = (ETMlins * ETMcols) - dosS3ETM7nullValCount;
array allValuesDosS3ETM1[dosS3ETM1realSize];
array allValuesDosS3ETM2[dosS3ETM2realSize];
array allValuesDosS3ETM3[dosS3ETM3realSize];
array allValuesDosS3ETM4[dosS3ETM4realSize];
array allValuesDosS3ETM5[dosS3ETM5realSize];
array allValuesDosS3ETM7[dosS3ETM7realSize];
numeric DNminCALCS3ETM1 = DNminCALC(Scene3Lin, Scene3Col, dosS3ETM1realSize);
numeric DNminCALCS3ETM2 = DNminCALC(Scene3Lin, Scene3Col, dosS3ETM2realSize);
numeric DNminCALCS3ETM3 = DNminCALC(Scene3Lin, Scene3Col, dosS3ETM3realSize);
numeric DNminCALCS3ETM4 = DNminCALC(Scene3Lin, Scene3Col, dosS3ETM4realSize);
numeric DNminCALCS3ETM5 = DNminCALC(Scene3Lin, Scene3Col, dosS3ETM5realSize);
numeric DNminCALCS3ETM7 = DNminCALC(Scene3Lin, Scene3Col, dosS3ETM7realSize);
for i = 1 to ETMlins
{
for j = 1 to ETMcols
{
if (IsNull(RADS3ETM1[i,j]) == 0)
{
allValuesDosS3ETM1[dosS3ETM1realArrayCount] = RADS3ETM1[i,j];
dosS3ETM1realArrayCount = dosS3ETM1realArrayCount + 1;
}
if (IsNull(RADS3ETM2[i,j]) == 0)
{
allValuesDosS3ETM2[dosS3ETM2realArrayCount] = RADS3ETM2[i,j];
dosS3ETM2realArrayCount = dosS3ETM2realArrayCount + 1;
}
if (IsNull(RADS3ETM3[i,j]) == 0)
{
allValuesDosS3ETM3[dosS3ETM3realArrayCount] = RADS3ETM3[i,j];
dosS3ETM3realArrayCount = dosS3ETM3realArrayCount + 1;
}
if (IsNull(RADS3ETM4[i,j]) == 0)
{
allValuesDosS3ETM4[dosS3ETM4realArrayCount] = RADS3ETM4[i,j];
dosS3ETM4realArrayCount = dosS3ETM4realArrayCount + 1;
}
if (IsNull(RADS3ETM5[i,j]) == 0)
{
allValuesDosS3ETM5[dosS3ETM5realArrayCount] = RADS3ETM5[i,j];
dosS3ETM5realArrayCount = dosS3ETM5realArrayCount + 1;
}
if (IsNull(RADS3ETM7[i,j]) == 0)
{
allValuesDosS3ETM7[dosS3ETM7realArrayCount] = RADS3ETM7[i,j];
dosS3ETM7realArrayCount = dosS3ETM7realArrayCount + 1;
}
}
}
########################### Scene 3 - Dn1000 - Band 1
numeric lastDOSS3ETM1 = dosS3ETM1realSize;
numeric hDOSS3ETM1 = 1;
while ( (hDOSS3ETM1 * 3 + 1) < lastDOSS3ETM1 - 1 )
{
hDOSS3ETM1 = 3 * hDOSS3ETM1 + 1;
}
while ( hDOSS3ETM1 > 0 )
{
for i = hDOSS3ETM1 - 1 to lastDOSS3ETM1 # for each of the h sets of elements
{
numeric keyDOSS3ETM1 = allValuesDosS3ETM1[i];
numeric jDOSS3ETM1 = i;
while (jDOSS3ETM1 >= hDOSS3ETM1 && allValuesDosS3ETM1[jDOSS3ETM1 - hDOSS3ETM1] > keyDOSS3ETM1)
{
allValuesDosS3ETM1[jDOSS3ETM1] = allValuesDosS3ETM1[jDOSS3ETM1 - hDOSS3ETM1];
jDOSS3ETM1 = jDOSS3ETM1 - hDOSS3ETM1;
}
allValuesDosS3ETM1[jDOSS3ETM1] = keyDOSS3ETM1;
}
hDOSS3ETM1 = floor(hDOSS3ETM1/3);
}
numeric minValueDosS3ETM1 = allValuesDosS3ETM1[1];
numeric dn1000S3ETM1 = 10000;
numeric actualCountDosS3ETM1 = 0;
for i = 1 to dosS3ETM1realSize
{
if (allValuesDosS3ETM1[i] == minValueDosS3ETM1)
{
actualCountDosS3ETM1 = actualCountDosS3ETM1 + 1;
if (actualCountDosS3ETM1 >= DNminCALCS3ETM1)
{
dn1000S3ETM1 = minValueDosS3ETM1;
go to dn1000S3ETM1jumper;
}
}
else
{
minValueDosS3ETM1 = allValuesDosS3ETM1[i+1];
actualCountDosS3ETM1 = 0;
}
}
dn1000S3ETM1jumper:
if (dn1000S3ETM1 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S3ETM1 = allValuesDosS3ETM1[1];
}
if (dn1000S3ETM1 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S3ETM1 = allValuesDosS3ETM1[1];
}
printf("dn1000 Scene 3 ETM1: %12f\n", dn1000S3ETM1);
########################### Scene 3 - Dn1000 - Band 2
numeric lastDOSS3ETM2 = dosS3ETM1realSize;
numeric hDOSS3ETM2 = 1;
while ( (hDOSS3ETM2 * 3 + 1) < lastDOSS3ETM2 - 1 )
{
hDOSS3ETM2 = 3 * hDOSS3ETM2 + 1;
}
while ( hDOSS3ETM2 > 0 )
{
for i = hDOSS3ETM2 - 1 to lastDOSS3ETM2
{
numeric keyDOSS3ETM2 = allValuesDosS3ETM2[i];
numeric jDOSS3ETM2 = i;
while (jDOSS3ETM2 >= hDOSS3ETM2 && allValuesDosS3ETM2[jDOSS3ETM2 - hDOSS3ETM2] > keyDOSS3ETM2)
{
allValuesDosS3ETM2[jDOSS3ETM2] = allValuesDosS3ETM2[jDOSS3ETM2 - hDOSS3ETM2];
jDOSS3ETM2 = jDOSS3ETM2 - hDOSS3ETM2;
}
allValuesDosS3ETM2[jDOSS3ETM2] = keyDOSS3ETM2;
}
hDOSS3ETM2 = floor(hDOSS3ETM2/3);
}
numeric minValueDosS3ETM2 = allValuesDosS3ETM2[1];
numeric dn1000S3ETM2 = 10000;
numeric actualCountDosS3ETM2 = 0;
for i = 1 to dosS3ETM2realSize
{
if (allValuesDosS3ETM2[i] == minValueDosS3ETM2)
{
actualCountDosS3ETM2 = actualCountDosS3ETM2 + 1;
if (actualCountDosS3ETM2 >= DNminCALCS3ETM2)
{
dn1000S3ETM2 = minValueDosS3ETM2;
go to dn1000S3ETM2jumper;
}
}
else
{
minValueDosS3ETM2 = allValuesDosS3ETM2[i+1];
actualCountDosS3ETM2 = 0;
}
}
dn1000S3ETM2jumper:
if (dn1000S3ETM2 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S3ETM2 = allValuesDosS3ETM2[1];
}
if (dn1000S3ETM2 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S3ETM2 = allValuesDosS3ETM2[1];
}
printf("dn1000 Scene 3 ETM2: %12f\n", dn1000S3ETM2);
########################### Scene 1 - Dn1000 - Band 3
numeric lastDOSS3ETM3 = dosS3ETM3realSize;
numeric hDOSS3ETM3 = 1;
while ( (hDOSS3ETM3 * 3 + 1) < lastDOSS3ETM3 - 1 )
{
hDOSS3ETM3 = 3 * hDOSS3ETM3 + 1;
}
while ( hDOSS3ETM3 > 0 )
{
for i = hDOSS3ETM3 - 1 to lastDOSS3ETM3 # for each of the h sets of elements
{
numeric keyDOSS3ETM3 = allValuesDosS3ETM3[i];
numeric jDOSS3ETM3 = i;
while (jDOSS3ETM3 >= hDOSS3ETM3 && allValuesDosS3ETM3[jDOSS3ETM3 - hDOSS3ETM3] > keyDOSS3ETM3)
{
allValuesDosS3ETM3[jDOSS3ETM3] = allValuesDosS3ETM3[jDOSS3ETM3 - hDOSS3ETM3];
jDOSS3ETM3 = jDOSS3ETM3 - hDOSS3ETM3;
}
allValuesDosS3ETM3[jDOSS3ETM3] = keyDOSS3ETM3;
}
hDOSS3ETM3 = floor(hDOSS3ETM3/3);
}
numeric minValueDosS3ETM3 = allValuesDosS3ETM3[1];
numeric dn1000S3ETM3 = 10000;
numeric actualCountDosS3ETM3 = 0;
for i = 1 to dosS3ETM3realSize
{
if (allValuesDosS3ETM3[i] == minValueDosS3ETM3)
{
actualCountDosS3ETM3 = actualCountDosS3ETM3 + 1;
if (actualCountDosS3ETM3 >= DNminCALCS3ETM3)
{
dn1000S3ETM3 = minValueDosS3ETM3;
go to dn1000S3ETM3jumper;
}
}
else
{
minValueDosS3ETM3 = allValuesDosS3ETM3[i+1];
actualCountDosS3ETM3 = 0;
}
}
dn1000S3ETM3jumper:
if (dn1000S3ETM3 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S3ETM3 = allValuesDosS3ETM3[1];
}
if (dn1000S3ETM3 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S3ETM3 = allValuesDosS3ETM3[1];
}
printf("dn1000 Scene 3 ETM3: %12f\n", dn1000S3ETM3);
########################### Scene 3 - Dn1000 - Band 4
numeric lastDOSS3ETM4 = dosS3ETM4realSize;
numeric hDOSS3ETM4 = 1;
while ( (hDOSS3ETM4 * 3 + 1) < lastDOSS3ETM4 - 1 )
{
hDOSS3ETM4 = 3 * hDOSS3ETM4 + 1;
}
while ( hDOSS3ETM4 > 0 )
{
for i = hDOSS3ETM4 - 1 to lastDOSS3ETM4
{
numeric keyDOSS3ETM4 = allValuesDosS3ETM4[i];
numeric jDOSS3ETM4 = i;
while (jDOSS3ETM4 >= hDOSS3ETM4 && allValuesDosS3ETM4[jDOSS3ETM4 - hDOSS3ETM4] > keyDOSS3ETM4)
{
allValuesDosS3ETM4[jDOSS3ETM4] = allValuesDosS3ETM4[jDOSS3ETM4 - hDOSS3ETM4];
jDOSS3ETM4 = jDOSS3ETM4 - hDOSS3ETM4;
}
allValuesDosS3ETM4[jDOSS3ETM4] = keyDOSS3ETM4;
}
hDOSS3ETM4 = floor(hDOSS3ETM4/3);
}
numeric minValueDosS3ETM4 = allValuesDosS3ETM4[1];
numeric dn1000S3ETM4 = 10000;
numeric actualCountDosS3ETM4 = 0;
for i = 1 to dosS3ETM4realSize
{
if (allValuesDosS3ETM4[i] == minValueDosS3ETM4)
{
actualCountDosS3ETM4 = actualCountDosS3ETM4 + 1;
if (actualCountDosS3ETM4 >= DNminCALCS3ETM4)
{
dn1000S3ETM4 = minValueDosS3ETM4;
go to dn1000S3ETM4jumper;
}
}
else
{
minValueDosS3ETM4 = allValuesDosS3ETM4[i+1];
actualCountDosS3ETM4 = 0;
}
}
dn1000S3ETM4jumper:
if (dn1000S3ETM4 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S3ETM4 = allValuesDosS3ETM4[1];
}
if (dn1000S3ETM4 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S3ETM4 = allValuesDosS3ETM4[1];
}
printf("dn1000 Scene 3 ETM4: %12f\n", dn1000S3ETM4);
########################### Scene 3 - Dn1000 - Band 5
numeric lastDOSS3ETM5 = dosS3ETM5realSize;
numeric hDOSS3ETM5 = 1;
while ( (hDOSS3ETM5 * 3 + 1) < lastDOSS3ETM5 - 1 )
{
hDOSS3ETM5 = 3 * hDOSS3ETM5 + 1;
}
while ( hDOSS3ETM5 > 0 )
{
for i = hDOSS3ETM5 - 1 to lastDOSS3ETM5 # for each of the h sets of elements
{
numeric keyDOSS3ETM5 = allValuesDosS3ETM5[i];
numeric jDOSS3ETM5 = i;
while (jDOSS3ETM5 >= hDOSS3ETM5 && allValuesDosS3ETM5[jDOSS3ETM5 - hDOSS3ETM5] > keyDOSS3ETM5)
{
allValuesDosS3ETM5[jDOSS3ETM5] = allValuesDosS3ETM5[jDOSS3ETM5 - hDOSS3ETM5];
jDOSS3ETM5 = jDOSS3ETM5 - hDOSS3ETM5;
}
allValuesDosS3ETM5[jDOSS3ETM5] = keyDOSS3ETM5;
}
hDOSS3ETM5 = floor(hDOSS3ETM5/3);
}
numeric minValueDosS3ETM5 = allValuesDosS3ETM5[1];
numeric dn1000S3ETM5 = 10000;
numeric actualCountDosS3ETM5 = 0;
for i = 1 to dosS3ETM5realSize
{
if (allValuesDosS3ETM5[i] == minValueDosS3ETM5)
{
actualCountDosS3ETM5 = actualCountDosS3ETM5 + 1;
if (actualCountDosS3ETM5 >= DNminCALCS3ETM5)
{
dn1000S3ETM5 = minValueDosS3ETM5;
go to dn1000S3ETM5jumper;
}
}
else
{
minValueDosS3ETM5 = allValuesDosS3ETM5[i+1];
actualCountDosS3ETM5 = 0;
}
}
dn1000S3ETM5jumper:
if (dn1000S3ETM5 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S3ETM5 = allValuesDosS3ETM5[1];
}
if (dn1000S3ETM5 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S3ETM5 = allValuesDosS3ETM5[1];
}
printf("dn1000 Scene 3 ETM5: %12f\n", dn1000S3ETM5);
########################### Scene 3 - Dn1000 - Band 7
numeric lastDOSS3ETM7 = dosS3ETM7realSize;
numeric hDOSS3ETM7 = 1;
while ( (hDOSS3ETM7 * 3 + 1) < lastDOSS3ETM7 - 1 )
{
hDOSS3ETM7 = 3 * hDOSS3ETM7 + 1;
}
while ( hDOSS3ETM7 > 0 )
{
for i = hDOSS3ETM7 - 1 to lastDOSS3ETM7 # for each of the h sets of elements
{
numeric keyDOSS3ETM7 = allValuesDosS3ETM7[i];
numeric jDOSS3ETM7 = i;
while (jDOSS3ETM7 >= hDOSS3ETM7 && allValuesDosS3ETM7[jDOSS3ETM7 - hDOSS3ETM7] > keyDOSS3ETM7)
{
allValuesDosS3ETM7[jDOSS3ETM7] = allValuesDosS3ETM7[jDOSS3ETM7 - hDOSS3ETM7];
jDOSS3ETM7 = jDOSS3ETM7 - hDOSS3ETM7;
}
allValuesDosS3ETM7[jDOSS3ETM7] = keyDOSS3ETM7;
}
hDOSS3ETM7 = floor(hDOSS3ETM7/3);
}
numeric minValueDosS3ETM7 = allValuesDosS3ETM7[1];
numeric dn1000S3ETM7 = 10000;
numeric actualCountDosS3ETM7 = 0;
for i = 1 to dosS3ETM7realSize
{
if (allValuesDosS3ETM7[i] == minValueDosS3ETM7)
{
actualCountDosS3ETM7 = actualCountDosS3ETM7 + 1;
if (actualCountDosS3ETM7 >= DNminCALCS3ETM7)
{
dn1000S3ETM7 = minValueDosS3ETM7;
go to dn1000S3ETM7jumper;
}
}
else
{
minValueDosS3ETM7 = allValuesDosS3ETM7[i+1];
actualCountDosS3ETM7 = 0;
}
}
dn1000S3ETM7jumper:
if (dn1000S3ETM7 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S3ETM7 = allValuesDosS3ETM7[1];
}
if (dn1000S3ETM7 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S3ETM7 = allValuesDosS3ETM7[1];
}
printf("dn1000 Scene 3 ETM7: %12f\n\n", dn1000S3ETM7);
################################### Pathradiance Calculation #######################################
numeric pathRadS3ETM1 = dn1000S3ETM1 - (0.01 * (radsurfETMS3b1 * cos(s3zenith)) / pi);
numeric pathRadS3ETM2 = dn1000S3ETM2 - (0.01 * (radsurfETMS3b2 * cos(s3zenith)) / pi);
numeric pathRadS3ETM3 = dn1000S3ETM3 - (0.01 * (radsurfETMS3b3 * cos(s3zenith)) / pi);
numeric pathRadS3ETM4 = dn1000S3ETM4 - (0.01 * (radsurfETMS3b4 * cos(s3zenith)) / pi);
numeric pathRadS3ETM5 = dn1000S3ETM5 - (0.01 * (radsurfETMS3b5 * cos(s3zenith)) / pi);
numeric pathRadS3ETM7 = dn1000S3ETM7 - (0.01 * (radsurfETMS3b7 * cos(s3zenith)) / pi);
printf("Pathradiance Scene 3 Band 1: %12f\n", pathRadS3ETM1);
printf("Pathradiance Scene 3 Band 2: %12f\n", pathRadS3ETM2);
printf("Pathradiance Scene 3 Band 3: %12f\n", pathRadS3ETM3);
printf("Pathradiance Scene 3 Band 4: %12f\n", pathRadS3ETM4);
printf("Pathradiance Scene 3 Band 5: %12f\n", pathRadS3ETM5);
printf("Pathradiance Scene 3 Band 7: %12f\n\n", pathRadS3ETM7);
################################# Reflectance Calculation with athmo correction
for i = 1 to ETMlins
{
for j = 1 to ETMcols
{
valueS3ETM1 = (pi * (RADS3ETM1[i,j] - pathRadS3ETM1)) / (radsurfETMS3b1 * cos(s3zenith));
if ( valueS3ETM1 < 0 )
{
valueS3ETM1 = 0;
countS3REFnullETM1 = countS3REFnullETM1 + 1;
}
else if ( valueS3ETM1 > 1 )
{
valueS3ETM1 = 1;
countS3REFoneETM1 = countS3REFoneETM1 + 1;
}
REFS3ETM1[i,j] = valueS3ETM1;
valueS3ETM2 = (pi * (RADS3ETM2[i,j] - pathRadS3ETM2)) / (radsurfETMS3b2 * cos(s3zenith));
if ( valueS3ETM2 < 0 )
{
valueS3ETM2 = 0;
countS3REFnullETM2 = countS3REFnullETM2 + 1;
}
else if ( valueS3ETM2 > 1 )
{
valueS3ETM2 = 1;
countS3REFoneETM2 = countS3REFoneETM2 + 1;
}
REFS3ETM2[i,j] = valueS3ETM2;
valueS3ETM3 = (pi * (RADS3ETM3[i,j] - pathRadS3ETM3)) / (radsurfETMS3b3 * cos(s3zenith));
if ( valueS3ETM3 < 0 )
{
valueS3ETM3 = 0;
countS3REFnullETM3 = countS3REFnullETM3 + 1;
}
else if ( valueS3ETM3 > 1 )
{
valueS3ETM3 = 1;
countS3REFoneETM3 = countS3REFoneETM3 + 1;
}
REFS3ETM3[i,j] = valueS3ETM3;
valueS3ETM4 = (pi * (RADS3ETM4[i,j] - pathRadS3ETM4)) / (radsurfETMS3b4 * cos(s3zenith));
if ( valueS3ETM4 < 0 )
{
valueS3ETM4 = 0;
countS3REFnullETM4 = countS3REFnullETM4 + 1;
}
else if ( valueS3ETM4 > 1 )
{
valueS3ETM4 = 1;
countS3REFoneETM4 = countS3REFoneETM4 + 1;
}
REFS3ETM4[i,j] = valueS3ETM4;
valueS3ETM5 = (pi * (RADS3ETM5[i,j] - pathRadS3ETM5)) / (radsurfETMS3b5 * cos(s3zenith));
if ( valueS3ETM5 < 0 )
{
valueS3ETM5 = 0;
countS3REFnullETM5 = countS3REFnullETM5 + 1;
}
else if ( valueS3ETM5 > 1 )
{
valueS3ETM5 = 1;
countS3REFoneETM5 = countS3REFoneETM5 + 1;
}
REFS3ETM5[i,j] = valueS3ETM5;
valueS3ETM7 = (pi * (RADS3ETM7[i,j] - pathRadS3ETM7)) / (radsurfETMS3b7 * cos(s3zenith));
if ( valueS3ETM7 < 0 )
{
valueS3ETM7 = 0;
countS3REFnullETM7 = countS3REFnullETM7 + 1;
}
else if ( valueS3ETM7 > 1 )
{
valueS3ETM7 = 1;
countS3REFoneETM7 = countS3REFoneETM7 + 1;
}
REFS3ETM7[i,j] = valueS3ETM7;
}
}
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 3 Band 1: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS3REFnullETM1, countS3REFoneETM1);
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 3 Band 2: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS3REFnullETM2, countS3REFoneETM2);
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 3 Band 3: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS3REFnullETM3, countS3REFoneETM3);
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 3 Band 4: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS3REFnullETM4, countS3REFoneETM4);
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 3 Band 5: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS3REFnullETM5, countS3REFoneETM5);
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 3 Band 7: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n\n", countS3REFnullETM7, countS3REFoneETM7);
CreatePyramid(REFS3ETM1);
CreatePyramid(REFS3ETM2);
CreatePyramid(REFS3ETM3);
CreatePyramid(REFS3ETM4);
CreatePyramid(REFS3ETM5);
CreatePyramid(REFS3ETM7);
CreateHistogram(REFS3ETM1);
CreateHistogram(REFS3ETM2);
CreateHistogram(REFS3ETM3);
CreateHistogram(REFS3ETM4);
CreateHistogram(REFS3ETM5);
CreateHistogram(REFS3ETM7);
CloseRaster(RADS3ETM1);
CloseRaster(RADS3ETM2);
CloseRaster(RADS3ETM3);
CloseRaster(RADS3ETM4);
CloseRaster(RADS3ETM5);
CloseRaster(RADS3ETM7);
printf("Reflectance calculation for Scene 3 (ETM) is done...\n\n\n");
}
else if ( sensors3 == 6 )
{
raster REFS3TM1, REFS3TM2, REFS3TM3, REFS3TM4, REFS3TM5, REFS3TM7;
numeric radsurfTMS3b1, radsurfTMS3b2, radsurfTMS3b3, radsurfTMS3b4, radsurfTMS3b5, radsurfTMS3b7;
numeric valueS3TM1, valueS3TM2, valueS3TM3, valueS3TM4, valueS3TM5, valueS3TM7;
numeric dosS3TM1nullValCount = 0;
numeric dosS3TM2nullValCount = 0;
numeric dosS3TM3nullValCount = 0;
numeric dosS3TM4nullValCount = 0;
numeric dosS3TM5nullValCount = 0;
numeric dosS3TM7nullValCount = 0;
numeric dosS3TM1realArrayCount = 1;
numeric dosS3TM2realArrayCount = 1;
numeric dosS3TM3realArrayCount = 1;
numeric dosS3TM4realArrayCount = 1;
numeric dosS3TM5realArrayCount = 1;
numeric dosS3TM7realArrayCount = 1;
numeric countS3REFnullTM1 = 0;
numeric countS3REFnullTM2 = 0;
numeric countS3REFnullTM3 = 0;
numeric countS3REFnullTM4 = 0;
numeric countS3REFnullTM5 = 0;
numeric countS3REFnullTM7 = 0;
numeric countS3REFoneTM1 = 0;
numeric countS3REFoneTM2 = 0;
numeric countS3REFoneTM3 = 0;
numeric countS3REFoneTM4 = 0;
numeric countS3REFoneTM5 = 0;
numeric countS3REFoneTM7 = 0;
radsurfTMS3b1 = ESTM1 / (dist3^2);
radsurfTMS3b2 = ESTM2 / (dist3^2);
radsurfTMS3b3 = ESTM3 / (dist3^2);
radsurfTMS3b4 = ESTM4 / (dist3^2);
radsurfTMS3b5 = ESTM5 / (dist3^2);
radsurfTMS3b7 = ESTM7 / (dist3^2);
printf("Surface Radiance TM Band 1 in W/m^2µm (Scene 3): %12f\n", radsurfTMS3b1);
printf("Surface Radiance TM Band 2 in W/m^2µm (Scene 3): %12f\n", radsurfTMS3b2);
printf("Surface Radiance TM Band 3 in W/m^2µm (Scene 3): %12f\n", radsurfTMS3b3);
printf("Surface Radiance TM Band 4 in W/m^2µm (Scene 3): %12f\n", radsurfTMS3b4);
printf("Surface Radiance TM Band 5 in W/m^2µm (Scene 3): %12f\n", radsurfTMS3b5);
printf("Surface Radiance TM Band 7 in W/m^2µm (Scene 3): %12f\n\n", radsurfTMS3b7);
for i = 1 to TMlins
{
for j = 1 to TMcols
{
if (IsNull(RADS3TM1[i,j]) == 1)
{
dosS3TM1nullValCount = dosS3TM1nullValCount + 1;
}
if (IsNull(RADS3TM2[i,j]) == 1)
{
dosS3TM2nullValCount = dosS3TM2nullValCount + 1;
}
if (IsNull(RADS3TM3[i,j]) == 1)
{
dosS3TM3nullValCount = dosS3TM3nullValCount + 1;
}
if (IsNull(RADS3TM4[i,j]) == 1)
{
dosS3TM4nullValCount = dosS3TM4nullValCount + 1;
}
if (IsNull(RADS3TM5[i,j]) == 1)
{
dosS3TM5nullValCount = dosS3TM5nullValCount + 1;
}
if (IsNull(RADS3TM7[i,j]) == 1)
{
dosS3TM7nullValCount = dosS3TM7nullValCount + 1;
}
}
}
numeric dosS3TM1realSize = (TMlins * TMcols) - dosS3TM1nullValCount;
numeric dosS3TM2realSize = (TMlins * TMcols) - dosS3TM2nullValCount;
numeric dosS3TM3realSize = (TMlins * TMcols) - dosS3TM3nullValCount;
numeric dosS3TM4realSize = (TMlins * TMcols) - dosS3TM4nullValCount;
numeric dosS3TM5realSize = (TMlins * TMcols) - dosS3TM5nullValCount;
numeric dosS3TM7realSize = (TMlins * TMcols) - dosS3TM7nullValCount;
array allValuesDosS3TM1[dosS3TM1realSize];
array allValuesDosS3TM2[dosS3TM2realSize];
array allValuesDosS3TM3[dosS3TM3realSize];
array allValuesDosS3TM4[dosS3TM4realSize];
array allValuesDosS3TM5[dosS3TM5realSize];
array allValuesDosS3TM7[dosS3TM7realSize];
numeric DNminCALCS3TM1 = DNminCALC(Scene3Lin, Scene3Col, dosS3TM1realSize);
numeric DNminCALCS3TM2 = DNminCALC(Scene3Lin, Scene3Col, dosS3TM2realSize);
numeric DNminCALCS3TM3 = DNminCALC(Scene3Lin, Scene3Col, dosS3TM3realSize);
numeric DNminCALCS3TM4 = DNminCALC(Scene3Lin, Scene3Col, dosS3TM4realSize);
numeric DNminCALCS3TM5 = DNminCALC(Scene3Lin, Scene3Col, dosS3TM5realSize);
numeric DNminCALCS3TM7 = DNminCALC(Scene3Lin, Scene3Col, dosS3TM7realSize);
for i = 1 to TMlins
{
for j = 1 to TMcols
{
if (IsNull(RADS3TM1[i,j]) == 0)
{
allValuesDosS3TM1[dosS3TM1realArrayCount] = RADS3TM1[i,j];
dosS3TM1realArrayCount = dosS3TM1realArrayCount + 1;
}
if (IsNull(RADS3TM2[i,j]) == 0)
{
allValuesDosS3TM2[dosS3TM2realArrayCount] = RADS3TM2[i,j];
dosS3TM2realArrayCount = dosS3TM2realArrayCount + 1;
}
if (IsNull(RADS3TM3[i,j]) == 0)
{
allValuesDosS3TM3[dosS3TM3realArrayCount] = RADS3TM3[i,j];
dosS3TM3realArrayCount = dosS3TM3realArrayCount + 1;
}
if (IsNull(RADS3TM4[i,j]) == 0)
{
allValuesDosS3TM4[dosS3TM4realArrayCount] = RADS3TM4[i,j];
dosS3TM4realArrayCount = dosS3TM4realArrayCount + 1;
}
if (IsNull(RADS3TM5[i,j]) == 0)
{
allValuesDosS3TM5[dosS3TM5realArrayCount] = RADS3TM5[i,j];
dosS3TM5realArrayCount = dosS3TM5realArrayCount + 1;
}
if (IsNull(RADS3TM7[i,j]) == 0)
{
allValuesDosS3TM7[dosS3TM7realArrayCount] = RADS3TM7[i,j];
dosS3TM7realArrayCount = dosS3TM7realArrayCount + 1;
}
}
}
########################### Scene 3 - Dn1000 - Band 1
numeric lastDOSS3TM1 = dosS3TM1realSize;
numeric hDOSS3TM1 = 1;
while ( (hDOSS3TM1 * 3 + 1) < lastDOSS3TM1 - 1 )
{
hDOSS3TM1 = 3 * hDOSS3TM1 + 1;
}
while ( hDOSS3TM1 > 0 )
{
for i = hDOSS3TM1 - 1 to lastDOSS3TM1 # for each of the h sets of elements
{
numeric keyDOSS3TM1 = allValuesDosS3TM1[i];
numeric jDOSS3TM1 = i;
while (jDOSS3TM1 >= hDOSS3TM1 && allValuesDosS3TM1[jDOSS3TM1 - hDOSS3TM1] > keyDOSS3TM1)
{
allValuesDosS3TM1[jDOSS3TM1] = allValuesDosS3TM1[jDOSS3TM1 - hDOSS3TM1];
jDOSS3TM1 = jDOSS3TM1 - hDOSS3TM1;
}
allValuesDosS3TM1[jDOSS3TM1] = keyDOSS3TM1;
}
hDOSS3TM1 = floor(hDOSS3TM1/3);
}
numeric minValueDosS3TM1 = allValuesDosS3TM1[1];
numeric dn1000S3TM1 = 10000;
numeric actualCountDosS3TM1 = 0;
for i = 1 to dosS3TM1realSize
{
if (allValuesDosS3TM1[i] == minValueDosS3TM1)
{
actualCountDosS3TM1 = actualCountDosS3TM1 + 1;
if (actualCountDosS3TM1 >= DNminCALCS3TM1)
{
dn1000S3TM1 = minValueDosS3TM1;
go to dn1000S3TM1jumper;
}
}
else
{
minValueDosS3TM1 = allValuesDosS3TM1[i+1];
actualCountDosS3TM1 = 0;
}
}
dn1000S3TM1jumper:
if (dn1000S3TM1 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S3TM1 = allValuesDosS3TM1[1];
}
if (dn1000S3TM1 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S3TM1 = allValuesDosS3TM1[1];
}
printf("dn1000 Scene 3 TM1: %12f\n", dn1000S3TM1);
########################### Scene 3 - Dn1000 - Band 2
numeric lastDOSS3TM2 = dosS3TM1realSize;
numeric hDOSS3TM2 = 1;
while ( (hDOSS3TM2 * 3 + 1) < lastDOSS3TM2 - 1 )
{
hDOSS3TM2 = 3 * hDOSS3TM2 + 1;
}
while ( hDOSS3TM2 > 0 )
{
for i = hDOSS3TM2 - 1 to lastDOSS3TM2
{
numeric keyDOSS3TM2 = allValuesDosS3TM2[i];
numeric jDOSS3TM2 = i;
while (jDOSS3TM2 >= hDOSS3TM2 && allValuesDosS3TM2[jDOSS3TM2 - hDOSS3TM2] > keyDOSS3TM2)
{
allValuesDosS3TM2[jDOSS3TM2] = allValuesDosS3TM2[jDOSS3TM2 - hDOSS3TM2];
jDOSS3TM2 = jDOSS3TM2 - hDOSS3TM2;
}
allValuesDosS3TM2[jDOSS3TM2] = keyDOSS3TM2;
}
hDOSS3TM2 = floor(hDOSS3TM2/3);
}
numeric minValueDosS3TM2 = allValuesDosS3TM2[1];
numeric dn1000S3TM2 = 10000;
numeric actualCountDosS3TM2 = 0;
for i = 1 to dosS3TM2realSize
{
if (allValuesDosS3TM2[i] == minValueDosS3TM2)
{
actualCountDosS3TM2 = actualCountDosS3TM2 + 1;
if (actualCountDosS3TM2 >= DNminCALCS3TM2)
{
dn1000S3TM2 = minValueDosS3TM2;
go to dn1000S3TM2jumper;
}
}
else
{
minValueDosS3TM2 = allValuesDosS3TM2[i+1];
actualCountDosS3TM2 = 0;
}
}
dn1000S3TM2jumper:
if (dn1000S3TM2 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S3TM2 = allValuesDosS3TM2[1];
}
if (dn1000S3TM2 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S3TM2 = allValuesDosS3TM2[1];
}
printf("dn1000 Scene 3 TM2: %12f\n", dn1000S3TM2);
########################### Scene 1 - Dn1000 - Band 3
numeric lastDOSS3TM3 = dosS3TM3realSize;
numeric hDOSS3TM3 = 1;
while ( (hDOSS3TM3 * 3 + 1) < lastDOSS3TM3 - 1 )
{
hDOSS3TM3 = 3 * hDOSS3TM3 + 1;
}
while ( hDOSS3TM3 > 0 )
{
for i = hDOSS3TM3 - 1 to lastDOSS3TM3 # for each of the h sets of elements
{
numeric keyDOSS3TM3 = allValuesDosS3TM3[i];
numeric jDOSS3TM3 = i;
while (jDOSS3TM3 >= hDOSS3TM3 && allValuesDosS3TM3[jDOSS3TM3 - hDOSS3TM3] > keyDOSS3TM3)
{
allValuesDosS3TM3[jDOSS3TM3] = allValuesDosS3TM3[jDOSS3TM3 - hDOSS3TM3];
jDOSS3TM3 = jDOSS3TM3 - hDOSS3TM3;
}
allValuesDosS3TM3[jDOSS3TM3] = keyDOSS3TM3;
}
hDOSS3TM3 = floor(hDOSS3TM3/3);
}
numeric minValueDosS3TM3 = allValuesDosS3TM3[1];
numeric dn1000S3TM3 = 10000;
numeric actualCountDosS3TM3 = 0;
for i = 1 to dosS3TM3realSize
{
if (allValuesDosS3TM3[i] == minValueDosS3TM3)
{
actualCountDosS3TM3 = actualCountDosS3TM3 + 1;
if (actualCountDosS3TM3 >= DNminCALCS3TM3)
{
dn1000S3TM3 = minValueDosS3TM3;
go to dn1000S3TM3jumper;
}
}
else
{
minValueDosS3TM3 = allValuesDosS3TM3[i+1];
actualCountDosS3TM3 = 0;
}
}
dn1000S3TM3jumper:
if (dn1000S3TM3 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S3TM3 = allValuesDosS3TM3[1];
}
if (dn1000S3TM3 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S3TM3 = allValuesDosS3TM3[1];
}
printf("dn1000 Scene 3 TM3: %12f\n", dn1000S3TM3);
########################### Scene 3 - Dn1000 - Band 4
numeric lastDOSS3TM4 = dosS3TM4realSize;
numeric hDOSS3TM4 = 1;
while ( (hDOSS3TM4 * 3 + 1) < lastDOSS3TM4 - 1 )
{
hDOSS3TM4 = 3 * hDOSS3TM4 + 1;
}
while ( hDOSS3TM4 > 0 )
{
for i = hDOSS3TM4 - 1 to lastDOSS3TM4
{
numeric keyDOSS3TM4 = allValuesDosS3TM4[i];
numeric jDOSS3TM4 = i;
while (jDOSS3TM4 >= hDOSS3TM4 && allValuesDosS3TM4[jDOSS3TM4 - hDOSS3TM4] > keyDOSS3TM4)
{
allValuesDosS3TM4[jDOSS3TM4] = allValuesDosS3TM4[jDOSS3TM4 - hDOSS3TM4];
jDOSS3TM4 = jDOSS3TM4 - hDOSS3TM4;
}
allValuesDosS3TM4[jDOSS3TM4] = keyDOSS3TM4;
}
hDOSS3TM4 = floor(hDOSS3TM4/3);
}
numeric minValueDosS3TM4 = allValuesDosS3TM4[1];
numeric dn1000S3TM4 = 10000;
numeric actualCountDosS3TM4 = 0;
for i = 1 to dosS3TM4realSize
{
if (allValuesDosS3TM4[i] == minValueDosS3TM4)
{
actualCountDosS3TM4 = actualCountDosS3TM4 + 1;
if (actualCountDosS3TM4 >= DNminCALCS3TM4)
{
dn1000S3TM4 = minValueDosS3TM4;
go to dn1000S3TM4jumper;
}
}
else
{
minValueDosS3TM4 = allValuesDosS3TM4[i+1];
actualCountDosS3TM4 = 0;
}
}
dn1000S3TM4jumper:
if (dn1000S3TM4 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S3TM4 = allValuesDosS3TM4[1];
}
if (dn1000S3TM4 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S3TM4 = allValuesDosS3TM4[1];
}
printf("dn1000 Scene 3 TM4: %12f\n", dn1000S3TM4);
########################### Scene 3 - Dn1000 - Band 5
numeric lastDOSS3TM5 = dosS3TM5realSize;
numeric hDOSS3TM5 = 1;
while ( (hDOSS3TM5 * 3 + 1) < lastDOSS3TM5 - 1 )
{
hDOSS3TM5 = 3 * hDOSS3TM5 + 1;
}
while ( hDOSS3TM5 > 0 )
{
for i = hDOSS3TM5 - 1 to lastDOSS3TM5 # for each of the h sets of elements
{
numeric keyDOSS3TM5 = allValuesDosS3TM5[i];
numeric jDOSS3TM5 = i;
while (jDOSS3TM5 >= hDOSS3TM5 && allValuesDosS3TM5[jDOSS3TM5 - hDOSS3TM5] > keyDOSS3TM5)
{
allValuesDosS3TM5[jDOSS3TM5] = allValuesDosS3TM5[jDOSS3TM5 - hDOSS3TM5];
jDOSS3TM5 = jDOSS3TM5 - hDOSS3TM5;
}
allValuesDosS3TM5[jDOSS3TM5] = keyDOSS3TM5;
}
hDOSS3TM5 = floor(hDOSS3TM5/3);
}
numeric minValueDosS3TM5 = allValuesDosS3TM5[1];
numeric dn1000S3TM5 = 10000;
numeric actualCountDosS3TM5 = 0;
for i = 1 to dosS3TM5realSize
{
if (allValuesDosS3TM5[i] == minValueDosS3TM5)
{
actualCountDosS3TM5 = actualCountDosS3TM5 + 1;
if (actualCountDosS3TM5 >= DNminCALCS3TM5)
{
dn1000S3TM5 = minValueDosS3TM5;
go to dn1000S3TM5jumper;
}
}
else
{
minValueDosS3TM5 = allValuesDosS3TM5[i+1];
actualCountDosS3TM5 = 0;
}
}
dn1000S3TM5jumper:
if (dn1000S3TM5 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S3TM5 = allValuesDosS3TM5[1];
}
if (dn1000S3TM5 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S3TM5 = allValuesDosS3TM5[1];
}
printf("dn1000 Scene 3 TM5: %12f\n", dn1000S3TM5);
########################### Scene 3 - Dn1000 - Band 7
numeric lastDOSS3TM7 = dosS3TM7realSize;
numeric hDOSS3TM7 = 1;
while ( (hDOSS3TM7 * 3 + 1) < lastDOSS3TM7 - 1 )
{
hDOSS3TM7 = 3 * hDOSS3TM7 + 1;
}
while ( hDOSS3TM7 > 0 )
{
for i = hDOSS3TM7 - 1 to lastDOSS3TM7 # for each of the h sets of elements
{
numeric keyDOSS3TM7 = allValuesDosS3TM7[i];
numeric jDOSS3TM7 = i;
while (jDOSS3TM7 >= hDOSS3TM7 && allValuesDosS3TM7[jDOSS3TM7 - hDOSS3TM7] > keyDOSS3TM7)
{
allValuesDosS3TM7[jDOSS3TM7] = allValuesDosS3TM7[jDOSS3TM7 - hDOSS3TM7];
jDOSS3TM7 = jDOSS3TM7 - hDOSS3TM7;
}
allValuesDosS3TM7[jDOSS3TM7] = keyDOSS3TM7;
}
hDOSS3TM7 = floor(hDOSS3TM7/3);
}
numeric minValueDosS3TM7 = allValuesDosS3TM7[1];
numeric dn1000S3TM7 = 10000;
numeric actualCountDosS3TM7 = 0;
for i = 1 to dosS3TM7realSize
{
if (allValuesDosS3TM7[i] == minValueDosS3TM7)
{
actualCountDosS3TM7 = actualCountDosS3TM7 + 1;
if (actualCountDosS3TM7 >= DNminCALCS3TM7)
{
dn1000S3TM7 = minValueDosS3TM7;
go to dn1000S3TM7jumper;
}
}
else
{
minValueDosS3TM7 = allValuesDosS3TM7[i+1];
actualCountDosS3TM7 = 0;
}
}
dn1000S3TM7jumper:
if (dn1000S3TM7 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S3TM7 = allValuesDosS3TM7[1];
}
if (dn1000S3TM7 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S3TM7 = allValuesDosS3TM7[1];
}
printf("dn1000 Scene 3 TM7: %12f\n\n", dn1000S3TM7);
################################### Pathradiance Calculation #######################################
numeric pathRadS3TM1 = dn1000S3TM1 - (0.01 * (radsurfTMS3b1 * cos(s3zenith)) / pi);
numeric pathRadS3TM2 = dn1000S3TM2 - (0.01 * (radsurfTMS3b2 * cos(s3zenith)) / pi);
numeric pathRadS3TM3 = dn1000S3TM3 - (0.01 * (radsurfTMS3b3 * cos(s3zenith)) / pi);
numeric pathRadS3TM4 = dn1000S3TM4 - (0.01 * (radsurfTMS3b4 * cos(s3zenith)) / pi);
numeric pathRadS3TM5 = dn1000S3TM5 - (0.01 * (radsurfTMS3b5 * cos(s3zenith)) / pi);
numeric pathRadS3TM7 = dn1000S3TM7 - (0.01 * (radsurfTMS3b7 * cos(s3zenith)) / pi);
printf("Pathradiance Scene 3 Band 1: %12f\n", pathRadS3TM1);
printf("Pathradiance Scene 3 Band 2: %12f\n", pathRadS3TM2);
printf("Pathradiance Scene 3 Band 3: %12f\n", pathRadS3TM3);
printf("Pathradiance Scene 3 Band 4: %12f\n", pathRadS3TM4);
printf("Pathradiance Scene 3 Band 5: %12f\n", pathRadS3TM5);
printf("Pathradiance Scene 3 Band 7: %12f\n\n", pathRadS3TM7);
################################# Reflectance Calculation with athmo correction
for i = 1 to TMlins
{
for j = 1 to TMcols
{
valueS3TM1 = (pi * (RADS3TM1[i,j] - pathRadS3TM1)) / (radsurfTMS3b1 * cos(s3zenith));
if ( valueS3TM1 < 0 )
{
valueS3TM1 = 0;
countS3REFnullTM1 = countS3REFnullTM1 + 1;
}
else if ( valueS3TM1 > 1 )
{
valueS3TM1 = 1;
countS3REFoneTM1 = countS3REFoneTM1 + 1;
}
REFS3TM1[i,j] = valueS3TM1;
valueS3TM2 = (pi * (RADS3TM2[i,j] - pathRadS3TM2)) / (radsurfTMS3b2 * cos(s3zenith));
if ( valueS3TM2 < 0 )
{
valueS3TM2 = 0;
countS3REFnullTM2 = countS3REFnullTM2 + 1;
}
else if ( valueS3TM2 > 1 )
{
valueS3TM2 = 1;
countS3REFoneTM2 = countS3REFoneTM2 + 1;
}
REFS3TM2[i,j] = valueS3TM2;
valueS3TM3 = (pi * (RADS3TM3[i,j] - pathRadS3TM3)) / (radsurfTMS3b3 * cos(s3zenith));
if ( valueS3TM3 < 0 )
{
valueS3TM3 = 0;
countS3REFnullTM3 = countS3REFnullTM3 + 1;
}
else if ( valueS3TM3 > 1 )
{
valueS3TM3 = 1;
countS3REFoneTM3 = countS3REFoneTM3 + 1;
}
REFS3TM3[i,j] = valueS3TM3;
valueS3TM4 = (pi * (RADS3TM4[i,j] - pathRadS3TM4)) / (radsurfTMS3b4 * cos(s3zenith));
if ( valueS3TM4 < 0 )
{
valueS3TM4 = 0;
countS3REFnullTM4 = countS3REFnullTM4 + 1;
}
else if ( valueS3TM4 > 1 )
{
valueS3TM4 = 1;
countS3REFoneTM4 = countS3REFoneTM4 + 1;
}
REFS3TM4[i,j] = valueS3TM4;
valueS3TM5 = (pi * (RADS3TM5[i,j] - pathRadS3TM5)) / (radsurfTMS3b5 * cos(s3zenith));
if ( valueS3TM5 < 0 )
{
valueS3TM5 = 0;
countS3REFnullTM5 = countS3REFnullTM5 + 1;
}
else if ( valueS3TM5 > 1 )
{
valueS3TM5 = 1;
countS3REFoneTM5 = countS3REFoneTM5 + 1;
}
REFS3TM5[i,j] = valueS3TM5;
valueS3TM7 = (pi * (RADS3TM7[i,j] - pathRadS3TM7)) / (radsurfTMS3b7 * cos(s3zenith));
if ( valueS3TM7 < 0 )
{
valueS3TM7 = 0;
countS3REFnullTM7 = countS3REFnullTM7 + 1;
}
else if ( valueS3TM7 > 1 )
{
valueS3TM7 = 1;
countS3REFoneTM7 = countS3REFoneTM7 + 1;
}
REFS3TM7[i,j] = valueS3TM7;
}
}
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 3 Band 1: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS3REFnullTM1, countS3REFoneTM1);
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 3 Band 2: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS3REFnullTM2, countS3REFoneTM2);
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 3 Band 3: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS3REFnullTM3, countS3REFoneTM3);
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 3 Band 4: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS3REFnullTM4, countS3REFoneTM4);
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 3 Band 5: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS3REFnullTM5, countS3REFoneTM5);
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 3 Band 7: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n\n", countS3REFnullTM7, countS3REFoneTM7);
CreatePyramid(REFS3TM1);
CreatePyramid(REFS3TM2);
CreatePyramid(REFS3TM3);
CreatePyramid(REFS3TM4);
CreatePyramid(REFS3TM5);
CreatePyramid(REFS3TM7);
CreateHistogram(REFS3TM1);
CreateHistogram(REFS3TM2);
CreateHistogram(REFS3TM3);
CreateHistogram(REFS3TM4);
CreateHistogram(REFS3TM5);
CreateHistogram(REFS3TM7);
CloseRaster(RADS3TM1);
CloseRaster(RADS3TM2);
CloseRaster(RADS3TM3);
CloseRaster(RADS3TM4);
CloseRaster(RADS3TM5);
CloseRaster(RADS3TM7);
printf("Reflectance calculation for Scene 3 (TM) is done...\n\n\n");
}
else if ( sensors3 == 5 ) # MSS 5 - Calib Werte nach Price J.C.1987
{
raster REFS3MSS1, REFS3MSS2, REFS3MSS3, REFS3MSS4;
numeric radsurfMSS3b1, radsurfMSS3b2, radsurfMSS3b3, radsurfMSS3b4;
numeric valueS3MSS1, valueS3MSS2, valueS3MSS3, valueS3MSS4;
numeric dosS3MSS1nullValCount = 0;
numeric dosS3MSS2nullValCount = 0;
numeric dosS3MSS3nullValCount = 0;
numeric dosS3MSS4nullValCount = 0;
numeric dosS3MSS1realArrayCount = 1;
numeric dosS3MSS2realArrayCount = 1;
numeric dosS3MSS3realArrayCount = 1;
numeric dosS3MSS4realArrayCount = 1;
numeric countS3REFnullMSS1 = 0;
numeric countS3REFnullMSS2 = 0;
numeric countS3REFnullMSS3 = 0;
numeric countS3REFnullMSS4 = 0;
numeric countS3REFoneMSS1 = 0;
numeric countS3REFoneMSS2 = 0;
numeric countS3REFoneMSS3 = 0;
numeric countS3REFoneMSS4 = 0;
numeric countnoDOSS3REFnullMSS1 = 0;
numeric countnoDOSS3REFnullMSS2 = 0;
numeric countnoDOSS3REFnullMSS3 = 0;
numeric countnoDOSS3REFnullMSS4 = 0;
numeric countnoDOSS3REFoneMSS1 = 0;
numeric countnoDOSS3REFoneMSS2 = 0;
numeric countnoDOSS3REFoneMSS3 = 0;
numeric countnoDOSS3REFoneMSS4 = 0;
radsurfMSS3b1 = ESMSS51 / (dist3^2);
radsurfMSS3b2 = ESMSS52 / (dist3^2);
radsurfMSS3b3 = ESMSS53 / (dist3^2);
radsurfMSS3b4 = ESMSS54 / (dist3^2);
printf("Surface Radiance MSS Band 1 in W/m^2µm (Scene 3): %12f\n", radsurfMSS3b1);
printf("Surface Radiance MSS Band 2 in W/m^2µm (Scene 3): %12f\n", radsurfMSS3b2);
printf("Surface Radiance MSS Band 3 in W/m^2µm (Scene 3): %12f\n", radsurfMSS3b3);
printf("Surface Radiance MSS Band 4 in W/m^2µm (Scene 3): %12f\n\n", radsurfMSS3b4);
for i = 1 to MSSlins
{
for j = 1 to MSScols
{
if (IsNull(RADS3MSS1[i,j]) == 1)
{
dosS3MSS1nullValCount = dosS3MSS1nullValCount + 1;
}
if (IsNull(RADS3MSS2[i,j]) == 1)
{
dosS3MSS2nullValCount = dosS3MSS2nullValCount + 1;
}
if (IsNull(RADS3MSS3[i,j]) == 1)
{
dosS3MSS3nullValCount = dosS3MSS3nullValCount + 1;
}
if (IsNull(RADS3MSS4[i,j]) == 1)
{
dosS3MSS4nullValCount = dosS3MSS4nullValCount + 1;
}
}
}
numeric dosS3MSS1realSize = (MSSlins * MSScols) - dosS3MSS1nullValCount;
numeric dosS3MSS2realSize = (MSSlins * MSScols) - dosS3MSS2nullValCount;
numeric dosS3MSS3realSize = (MSSlins * MSScols) - dosS3MSS3nullValCount;
numeric dosS3MSS4realSize = (MSSlins * MSScols) - dosS3MSS4nullValCount;
array allValuesDosS3MSS1[dosS3MSS1realSize];
array allValuesDosS3MSS2[dosS3MSS2realSize];
array allValuesDosS3MSS3[dosS3MSS3realSize];
array allValuesDosS3MSS4[dosS3MSS4realSize];
numeric DNminCALCS3MSS1 = DNminCALC(Scene3Lin, Scene3Col, dosS3MSS1realSize);
numeric DNminCALCS3MSS2 = DNminCALC(Scene3Lin, Scene3Col, dosS3MSS2realSize);
numeric DNminCALCS3MSS3 = DNminCALC(Scene3Lin, Scene3Col, dosS3MSS3realSize);
numeric DNminCALCS3MSS4 = DNminCALC(Scene3Lin, Scene3Col, dosS3MSS4realSize);
for i = 1 to MSSlins
{
for j = 1 to MSScols
{
if (IsNull(RADS3MSS1[i,j]) == 0)
{
allValuesDosS3MSS1[dosS3MSS1realArrayCount] = RADS3MSS1[i,j];
dosS3MSS1realArrayCount = dosS3MSS1realArrayCount + 1;
}
if (IsNull(RADS3MSS2[i,j]) == 0)
{
allValuesDosS3MSS2[dosS3MSS2realArrayCount] = RADS3MSS2[i,j];
dosS3MSS2realArrayCount = dosS3MSS2realArrayCount + 1;
}
if (IsNull(RADS3MSS3[i,j]) == 0)
{
allValuesDosS3MSS3[dosS3MSS3realArrayCount] = RADS3MSS3[i,j];
dosS3MSS3realArrayCount = dosS3MSS3realArrayCount + 1;
}
if (IsNull(RADS3MSS4[i,j]) == 0)
{
allValuesDosS3MSS4[dosS3MSS4realArrayCount] = RADS3MSS4[i,j];
dosS3MSS4realArrayCount = dosS3MSS4realArrayCount + 1;
}
}
}
########################### Scene 3 - Dn1000 - Band 1
numeric lastDOSS3MSS1 = dosS3MSS1realSize;
numeric hDOSS3MSS1 = 1;
while ( (hDOSS3MSS1 * 3 + 1) < lastDOSS3MSS1 - 1 )
{
hDOSS3MSS1 = 3 * hDOSS3MSS1 + 1;
}
while ( hDOSS3MSS1 > 0 )
{
for i = hDOSS3MSS1 - 1 to lastDOSS3MSS1 # for each of the h sets of elements
{
numeric keyDOSS3MSS1 = allValuesDosS3MSS1[i];
numeric jDOSS3MSS1 = i;
while (jDOSS3MSS1 >= hDOSS3MSS1 && allValuesDosS3MSS1[jDOSS3MSS1 - hDOSS3MSS1] > keyDOSS3MSS1)
{
allValuesDosS3MSS1[jDOSS3MSS1] = allValuesDosS3MSS1[jDOSS3MSS1 - hDOSS3MSS1];
jDOSS3MSS1 = jDOSS3MSS1 - hDOSS3MSS1;
}
allValuesDosS3MSS1[jDOSS3MSS1] = keyDOSS3MSS1;
}
hDOSS3MSS1 = floor(hDOSS3MSS1/3);
}
numeric minValueDosS3MSS1 = allValuesDosS3MSS1[1];
numeric dn1000S3MSS1 = 10000;
numeric actualCountDosS3MSS1 = 0;
for i = 1 to dosS3MSS1realSize
{
if (allValuesDosS3MSS1[i] == minValueDosS3MSS1)
{
actualCountDosS3MSS1 = actualCountDosS3MSS1 + 1;
if (actualCountDosS3MSS1 >= DNminCALCS3MSS1)
{
dn1000S3MSS1 = minValueDosS3MSS1;
go to dn1000S3MSS1jumper;
}
}
else
{
minValueDosS3MSS1 = allValuesDosS3MSS1[i+1];
actualCountDosS3MSS1 = 0;
}
}
dn1000S3MSS1jumper:
if (dn1000S3MSS1 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S3MSS1 = allValuesDosS3MSS1[1];
}
if (dn1000S3MSS1 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S3MSS1 = allValuesDosS3MSS1[1];
}
printf("dn1000 Scene 3 MSS1: %12f\n", dn1000S3MSS1);
########################### Scene 3 - Dn1000 - Band 2
numeric lastDOSS3MSS2 = dosS3MSS1realSize;
numeric hDOSS3MSS2 = 1;
while ( (hDOSS3MSS2 * 3 + 1) < lastDOSS3MSS2 - 1 )
{
hDOSS3MSS2 = 3 * hDOSS3MSS2 + 1;
}
while ( hDOSS3MSS2 > 0 )
{
for i = hDOSS3MSS2 - 1 to lastDOSS3MSS2
{
numeric keyDOSS3MSS2 = allValuesDosS3MSS2[i];
numeric jDOSS3MSS2 = i;
while (jDOSS3MSS2 >= hDOSS3MSS2 && allValuesDosS3MSS2[jDOSS3MSS2 - hDOSS3MSS2] > keyDOSS3MSS2)
{
allValuesDosS3MSS2[jDOSS3MSS2] = allValuesDosS3MSS2[jDOSS3MSS2 - hDOSS3MSS2];
jDOSS3MSS2 = jDOSS3MSS2 - hDOSS3MSS2;
}
allValuesDosS3MSS2[jDOSS3MSS2] = keyDOSS3MSS2;
}
hDOSS3MSS2 = floor(hDOSS3MSS2/3);
}
numeric minValueDosS3MSS2 = allValuesDosS3MSS2[1];
numeric dn1000S3MSS2 = 10000;
numeric actualCountDosS3MSS2 = 0;
for i = 1 to dosS3MSS2realSize
{
if (allValuesDosS3MSS2[i] == minValueDosS3MSS2)
{
actualCountDosS3MSS2 = actualCountDosS3MSS2 + 1;
if (actualCountDosS3MSS2 >= DNminCALCS3MSS2)
{
dn1000S3MSS2 = minValueDosS3MSS2;
go to dn1000S3MSS2jumper;
}
}
else
{
minValueDosS3MSS2 = allValuesDosS3MSS2[i+1];
actualCountDosS3MSS2 = 0;
}
}
dn1000S3MSS2jumper:
if (dn1000S3MSS2 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S3MSS2 = allValuesDosS3MSS2[1];
}
if (dn1000S3MSS2 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S3MSS2 = allValuesDosS3MSS2[1];
}
printf("dn1000 Scene 3 MSS2: %12f\n", dn1000S3MSS2);
########################### Scene 3 - Dn1000 - Band 3
numeric lastDOSS3MSS3 = dosS3MSS3realSize;
numeric hDOSS3MSS3 = 1;
while ( (hDOSS3MSS3 * 3 + 1) < lastDOSS3MSS3 - 1 )
{
hDOSS3MSS3 = 3 * hDOSS3MSS3 + 1;
}
while ( hDOSS3MSS3 > 0 )
{
for i = hDOSS3MSS3 - 1 to lastDOSS3MSS3 # for each of the h sets of elements
{
numeric keyDOSS3MSS3 = allValuesDosS3MSS3[i];
numeric jDOSS3MSS3 = i;
while (jDOSS3MSS3 >= hDOSS3MSS3 && allValuesDosS3MSS3[jDOSS3MSS3 - hDOSS3MSS3] > keyDOSS3MSS3)
{
allValuesDosS3MSS3[jDOSS3MSS3] = allValuesDosS3MSS3[jDOSS3MSS3 - hDOSS3MSS3];
jDOSS3MSS3 = jDOSS3MSS3 - hDOSS3MSS3;
}
allValuesDosS3MSS3[jDOSS3MSS3] = keyDOSS3MSS3;
}
hDOSS3MSS3 = floor(hDOSS3MSS3/3);
}
numeric minValueDosS3MSS3 = allValuesDosS3MSS3[1];
numeric dn1000S3MSS3 = 10000;
numeric actualCountDosS3MSS3 = 0;
for i = 1 to dosS3MSS3realSize
{
if (allValuesDosS3MSS3[i] == minValueDosS3MSS3)
{
actualCountDosS3MSS3 = actualCountDosS3MSS3 + 1;
if (actualCountDosS3MSS3 >= DNminCALCS3MSS3)
{
dn1000S3MSS3 = minValueDosS3MSS3;
go to dn1000S3MSS3jumper;
}
}
else
{
minValueDosS3MSS3 = allValuesDosS3MSS3[i+1];
actualCountDosS3MSS3 = 0;
}
}
dn1000S3MSS3jumper:
if (dn1000S3MSS3 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S3MSS3 = allValuesDosS3MSS3[1];
}
if (dn1000S3MSS3 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S3MSS3 = allValuesDosS3MSS3[1];
}
printf("dn1000 Scene 3 MSS3: %12f\n", dn1000S3MSS3);
########################### Scene 3 - Dn1000 - Band 4
numeric lastDOSS3MSS4 = dosS3MSS4realSize;
numeric hDOSS3MSS4 = 1;
while ( (hDOSS3MSS4 * 3 + 1) < lastDOSS3MSS4 - 1 )
{
hDOSS3MSS4 = 3 * hDOSS3MSS4 + 1;
}
while ( hDOSS3MSS4 > 0 )
{
for i = hDOSS3MSS4 - 1 to lastDOSS3MSS4
{
numeric keyDOSS3MSS4 = allValuesDosS3MSS4[i];
numeric jDOSS3MSS4 = i;
while (jDOSS3MSS4 >= hDOSS3MSS4 && allValuesDosS3MSS4[jDOSS3MSS4 - hDOSS3MSS4] > keyDOSS3MSS4)
{
allValuesDosS3MSS4[jDOSS3MSS4] = allValuesDosS3MSS4[jDOSS3MSS4 - hDOSS3MSS4];
jDOSS3MSS4 = jDOSS3MSS4 - hDOSS3MSS4;
}
allValuesDosS3MSS4[jDOSS3MSS4] = keyDOSS3MSS4;
}
hDOSS3MSS4 = floor(hDOSS3MSS4/3);
}
numeric minValueDosS3MSS4 = allValuesDosS3MSS4[1];
numeric dn1000S3MSS4 = 10000;
numeric actualCountDosS3MSS4 = 0;
for i = 1 to dosS3MSS4realSize
{
if (allValuesDosS3MSS4[i] == minValueDosS3MSS4)
{
actualCountDosS3MSS4 = actualCountDosS3MSS4 + 1;
if (actualCountDosS3MSS4 >= DNminCALCS3MSS1)
{
dn1000S3MSS4 = minValueDosS3MSS4;
go to dn1000S3MSS4jumper;
}
}
else
{
minValueDosS3MSS4 = allValuesDosS3MSS4[i+1];
actualCountDosS3MSS4 = 0;
}
}
dn1000S3MSS4jumper:
if (dn1000S3MSS4 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S3MSS4 = allValuesDosS3MSS4[1];
}
if (dn1000S3MSS4 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S3MSS4 = allValuesDosS3MSS4[1];
}
printf("dn1000 Scene 3 MSS4: %12f\n", dn1000S3MSS4);
################################### Pathradiance Calculation #######################################
numeric pathRadS3MSS1 = dn1000S3MSS1 - (0.01 * (radsurfMSS3b1 * cos(s3zenith)) / pi);
numeric pathRadS3MSS2 = dn1000S3MSS2 - (0.01 * (radsurfMSS3b2 * cos(s3zenith)) / pi);
numeric pathRadS3MSS3 = dn1000S3MSS3 - (0.01 * (radsurfMSS3b3 * cos(s3zenith)) / pi);
numeric pathRadS3MSS4 = dn1000S3MSS4 - (0.01 * (radsurfMSS3b4 * cos(s3zenith)) / pi);
printf("Pathradiance Scene 3 Band 1: %12f\n", pathRadS3MSS1);
printf("Pathradiance Scene 3 Band 2: %12f\n", pathRadS3MSS2);
printf("Pathradiance Scene 3 Band 3: %12f\n", pathRadS3MSS3);
printf("Pathradiance Scene 3 Band 4: %12f\n\n", pathRadS3MSS4);
################################# Reflectance Calculation with athmo correction
for i = 1 to MSSlins
{
for j = 1 to MSScols
{
valueS3MSS1 = (pi * (RADS3MSS1[i,j] - pathRadS3MSS1)) / (radsurfMSS3b1 * cos(s3zenith));
if ( valueS3MSS1 < 0 )
{
valueS3MSS1 = 0;
countS3REFnullMSS1 = countS3REFnullMSS1 + 1;
}
else if ( valueS3MSS1 > 1 )
{
valueS3MSS1 = 1;
countS3REFoneMSS1 = countS3REFoneMSS1 + 1;
}
REFS3MSS1[i,j] = valueS3MSS1;
valueS3MSS2 = (pi * (RADS3MSS2[i,j] - pathRadS3MSS2)) / (radsurfMSS3b2 * cos(s3zenith));
if ( valueS3MSS2 < 0 )
{
valueS3MSS2 = 0;
countS3REFnullMSS2 = countS3REFnullMSS2 + 1;
}
else if ( valueS3MSS2 > 1 )
{
valueS3MSS2 = 1;
countS3REFoneMSS2 = countS3REFoneMSS2 + 1;
}
REFS3MSS2[i,j] = valueS3MSS2;
valueS3MSS3 = (pi * (RADS3MSS3[i,j] - pathRadS3MSS3)) / (radsurfMSS3b3 * cos(s3zenith));
if ( valueS3MSS3 < 0 )
{
valueS3MSS3 = 0;
countS3REFnullMSS3 = countS3REFnullMSS3 + 1;
}
else if ( valueS3MSS3 > 1 )
{
valueS3MSS3 = 1;
countS3REFoneMSS3 = countS3REFoneMSS3 + 1;
}
REFS3MSS3[i,j] = valueS3MSS3;
valueS3MSS4 = (pi * (RADS3MSS4[i,j] - pathRadS3MSS4)) / (radsurfMSS3b4 * cos(s3zenith));
if ( valueS3MSS4 < 0 )
{
valueS3MSS4 = 0;
countS3REFnullMSS4 = countS3REFnullMSS4 + 1;
}
else if ( valueS3MSS4 > 1 )
{
valueS3MSS4 = 1;
countS3REFoneMSS4 = countS3REFoneMSS4 + 1;
}
REFS3MSS4[i,j] = valueS3MSS4;
}
}
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 3 Band 1: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS3REFnullMSS1, countS3REFoneMSS1);
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 3 Band 2: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS3REFnullMSS2, countS3REFoneMSS2);
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 3 Band 3: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS3REFnullMSS3, countS3REFoneMSS3);
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 3 Band 4: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS3REFnullMSS4, countS3REFoneMSS4);
CreatePyramid(REFS3MSS1);
CreatePyramid(REFS3MSS2);
CreatePyramid(REFS3MSS3);
CreatePyramid(REFS3MSS4);
CreateHistogram(REFS3MSS1);
CreateHistogram(REFS3MSS2);
CreateHistogram(REFS3MSS3);
CreateHistogram(REFS3MSS4);
CloseRaster(RADS3MSS1);
CloseRaster(RADS3MSS2);
CloseRaster(RADS3MSS3);
CloseRaster(RADS3MSS4);
printf("Reflectance calculation for Scene 3 (MSS) is done...\n\n\n");
}
else if ( sensors3 == 4 ) # MSS 4
{
raster REFS3MSS1, REFS3MSS2, REFS3MSS3, REFS3MSS4;
numeric radsurfMSS3b1, radsurfMSS3b2, radsurfMSS3b3, radsurfMSS3b4;
numeric valueS3MSS1, valueS3MSS2, valueS3MSS3, valueS3MSS4;
numeric dosS3MSS1nullValCount = 0;
numeric dosS3MSS2nullValCount = 0;
numeric dosS3MSS3nullValCount = 0;
numeric dosS3MSS4nullValCount = 0;
numeric dosS3MSS1realArrayCount = 1;
numeric dosS3MSS2realArrayCount = 1;
numeric dosS3MSS3realArrayCount = 1;
numeric dosS3MSS4realArrayCount = 1;
numeric countS3REFnullMSS1 = 0;
numeric countS3REFnullMSS2 = 0;
numeric countS3REFnullMSS3 = 0;
numeric countS3REFnullMSS4 = 0;
numeric countS3REFoneMSS1 = 0;
numeric countS3REFoneMSS2 = 0;
numeric countS3REFoneMSS3 = 0;
numeric countS3REFoneMSS4 = 0;
radsurfMSS3b1 = ESMSS41 / (dist3^2);
radsurfMSS3b2 = ESMSS42 / (dist3^2);
radsurfMSS3b3 = ESMSS43 / (dist3^2);
radsurfMSS3b4 = ESMSS44 / (dist3^2);
printf("Surface Radiance MSS Band 1 in W/m^2µm (Scene 3): %12f\n", radsurfMSS3b1);
printf("Surface Radiance MSS Band 2 in W/m^2µm (Scene 3): %12f\n", radsurfMSS3b2);
printf("Surface Radiance MSS Band 3 in W/m^2µm (Scene 3): %12f\n", radsurfMSS3b3);
printf("Surface Radiance MSS Band 4 in W/m^2µm (Scene 3): %12f\n\n", radsurfMSS3b4);
for i = 1 to MSSlins
{
for j = 1 to MSScols
{
if (IsNull(RADS3MSS1[i,j]) == 1)
{
dosS3MSS1nullValCount = dosS3MSS1nullValCount + 1;
}
if (IsNull(RADS3MSS2[i,j]) == 1)
{
dosS3MSS2nullValCount = dosS3MSS2nullValCount + 1;
}
if (IsNull(RADS3MSS3[i,j]) == 1)
{
dosS3MSS3nullValCount = dosS3MSS3nullValCount + 1;
}
if (IsNull(RADS3MSS4[i,j]) == 1)
{
dosS3MSS4nullValCount = dosS3MSS4nullValCount + 1;
}
}
}
numeric dosS3MSS1realSize = (MSSlins * MSScols) - dosS3MSS1nullValCount;
numeric dosS3MSS2realSize = (MSSlins * MSScols) - dosS3MSS2nullValCount;
numeric dosS3MSS3realSize = (MSSlins * MSScols) - dosS3MSS3nullValCount;
numeric dosS3MSS4realSize = (MSSlins * MSScols) - dosS3MSS4nullValCount;
array allValuesDosS3MSS1[dosS3MSS1realSize];
array allValuesDosS3MSS2[dosS3MSS2realSize];
array allValuesDosS3MSS3[dosS3MSS3realSize];
array allValuesDosS3MSS4[dosS3MSS4realSize];
numeric DNminCALCS3MSS1 = DNminCALC(Scene3Lin, Scene3Col, dosS3MSS1realSize);
numeric DNminCALCS3MSS2 = DNminCALC(Scene3Lin, Scene3Col, dosS3MSS2realSize);
numeric DNminCALCS3MSS3 = DNminCALC(Scene3Lin, Scene3Col, dosS3MSS3realSize);
numeric DNminCALCS3MSS4 = DNminCALC(Scene3Lin, Scene3Col, dosS3MSS4realSize);
for i = 1 to MSSlins
{
for j = 1 to MSScols
{
if (IsNull(RADS3MSS1[i,j]) == 0)
{
allValuesDosS3MSS1[dosS3MSS1realArrayCount] = RADS3MSS1[i,j];
dosS3MSS1realArrayCount = dosS3MSS1realArrayCount + 1;
}
if (IsNull(RADS3MSS2[i,j]) == 0)
{
allValuesDosS3MSS2[dosS3MSS2realArrayCount] = RADS3MSS2[i,j];
dosS3MSS2realArrayCount = dosS3MSS2realArrayCount + 1;
}
if (IsNull(RADS3MSS3[i,j]) == 0)
{
allValuesDosS3MSS3[dosS3MSS3realArrayCount] = RADS3MSS3[i,j];
dosS3MSS3realArrayCount = dosS3MSS3realArrayCount + 1;
}
if (IsNull(RADS3MSS4[i,j]) == 0)
{
allValuesDosS3MSS4[dosS3MSS4realArrayCount] = RADS3MSS4[i,j];
dosS3MSS4realArrayCount = dosS3MSS4realArrayCount + 1;
}
}
}
########################### Scene 3 - Dn1000 - Band 1
numeric lastDOSS3MSS1 = dosS3MSS1realSize;
numeric hDOSS3MSS1 = 1;
while ( (hDOSS3MSS1 * 3 + 1) < lastDOSS3MSS1 - 1 )
{
hDOSS3MSS1 = 3 * hDOSS3MSS1 + 1;
}
while ( hDOSS3MSS1 > 0 )
{
for i = hDOSS3MSS1 - 1 to lastDOSS3MSS1 # for each of the h sets of elements
{
numeric keyDOSS3MSS1 = allValuesDosS3MSS1[i];
numeric jDOSS3MSS1 = i;
while (jDOSS3MSS1 >= hDOSS3MSS1 && allValuesDosS3MSS1[jDOSS3MSS1 - hDOSS3MSS1] > keyDOSS3MSS1)
{
allValuesDosS3MSS1[jDOSS3MSS1] = allValuesDosS3MSS1[jDOSS3MSS1 - hDOSS3MSS1];
jDOSS3MSS1 = jDOSS3MSS1 - hDOSS3MSS1;
}
allValuesDosS3MSS1[jDOSS3MSS1] = keyDOSS3MSS1;
}
hDOSS3MSS1 = floor(hDOSS3MSS1/3);
}
numeric minValueDosS3MSS1 = allValuesDosS3MSS1[1];
numeric dn1000S3MSS1 = 10000;
numeric actualCountDosS3MSS1 = 0;
for i = 1 to dosS3MSS1realSize
{
if (allValuesDosS3MSS1[i] == minValueDosS3MSS1)
{
actualCountDosS3MSS1 = actualCountDosS3MSS1 + 1;
if (actualCountDosS3MSS1 >= DNminCALCS3MSS1)
{
dn1000S3MSS1 = minValueDosS3MSS1;
go to dn1000S3MSS1jumper;
}
}
else
{
minValueDosS3MSS1 = allValuesDosS3MSS1[i+1];
actualCountDosS3MSS1 = 0;
}
}
dn1000S3MSS1jumper:
if (dn1000S3MSS1 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S3MSS1 = allValuesDosS3MSS1[1];
}
if (dn1000S3MSS1 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S3MSS1 = allValuesDosS3MSS1[1];
}
printf("dn1000 Scene 3 MSS1: %12f\n", dn1000S3MSS1);
########################### Scene 3 - Dn1000 - Band 2
numeric lastDOSS3MSS2 = dosS3MSS1realSize;
numeric hDOSS3MSS2 = 1;
while ( (hDOSS3MSS2 * 3 + 1) < lastDOSS3MSS2 - 1 )
{
hDOSS3MSS2 = 3 * hDOSS3MSS2 + 1;
}
while ( hDOSS3MSS2 > 0 )
{
for i = hDOSS3MSS2 - 1 to lastDOSS3MSS2
{
numeric keyDOSS3MSS2 = allValuesDosS3MSS2[i];
numeric jDOSS3MSS2 = i;
while (jDOSS3MSS2 >= hDOSS3MSS2 && allValuesDosS3MSS2[jDOSS3MSS2 - hDOSS3MSS2] > keyDOSS3MSS2)
{
allValuesDosS3MSS2[jDOSS3MSS2] = allValuesDosS3MSS2[jDOSS3MSS2 - hDOSS3MSS2];
jDOSS3MSS2 = jDOSS3MSS2 - hDOSS3MSS2;
}
allValuesDosS3MSS2[jDOSS3MSS2] = keyDOSS3MSS2;
}
hDOSS3MSS2 = floor(hDOSS3MSS2/3);
}
numeric minValueDosS3MSS2 = allValuesDosS3MSS2[1];
numeric dn1000S3MSS2 = 10000;
numeric actualCountDosS3MSS2 = 0;
for i = 1 to dosS3MSS2realSize
{
if (allValuesDosS3MSS2[i] == minValueDosS3MSS2)
{
actualCountDosS3MSS2 = actualCountDosS3MSS2 + 1;
if (actualCountDosS3MSS2 >= DNminCALCS3MSS2)
{
dn1000S3MSS2 = minValueDosS3MSS2;
go to dn1000S3MSS2jumper;
}
}
else
{
minValueDosS3MSS2 = allValuesDosS3MSS2[i+1];
actualCountDosS3MSS2 = 0;
}
}
dn1000S3MSS2jumper:
if (dn1000S3MSS2 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S3MSS2 = allValuesDosS3MSS2[1];
}
if (dn1000S3MSS2 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S3MSS2 = allValuesDosS3MSS2[1];
}
printf("dn1000 Scene 3 MSS2: %12f\n", dn1000S3MSS2);
########################### Scene 3 - Dn1000 - Band 3
numeric lastDOSS3MSS3 = dosS3MSS3realSize;
numeric hDOSS3MSS3 = 1;
while ( (hDOSS3MSS3 * 3 + 1) < lastDOSS3MSS3 - 1 )
{
hDOSS3MSS3 = 3 * hDOSS3MSS3 + 1;
}
while ( hDOSS3MSS3 > 0 )
{
for i = hDOSS3MSS3 - 1 to lastDOSS3MSS3 # for each of the h sets of elements
{
numeric keyDOSS3MSS3 = allValuesDosS3MSS3[i];
numeric jDOSS3MSS3 = i;
while (jDOSS3MSS3 >= hDOSS3MSS3 && allValuesDosS3MSS3[jDOSS3MSS3 - hDOSS3MSS3] > keyDOSS3MSS3)
{
allValuesDosS3MSS3[jDOSS3MSS3] = allValuesDosS3MSS3[jDOSS3MSS3 - hDOSS3MSS3];
jDOSS3MSS3 = jDOSS3MSS3 - hDOSS3MSS3;
}
allValuesDosS3MSS3[jDOSS3MSS3] = keyDOSS3MSS3;
}
hDOSS3MSS3 = floor(hDOSS3MSS3/3);
}
numeric minValueDosS3MSS3 = allValuesDosS3MSS3[1];
numeric dn1000S3MSS3 = 10000;
numeric actualCountDosS3MSS3 = 0;
for i = 1 to dosS3MSS3realSize
{
if (allValuesDosS3MSS3[i] == minValueDosS3MSS3)
{
actualCountDosS3MSS3 = actualCountDosS3MSS3 + 1;
if (actualCountDosS3MSS3 >= DNminCALCS3MSS3)
{
dn1000S3MSS3 = minValueDosS3MSS3;
go to dn1000S3MSS3jumper;
}
}
else
{
minValueDosS3MSS3 = allValuesDosS3MSS3[i+1];
actualCountDosS3MSS3 = 0;
}
}
dn1000S3MSS3jumper:
if (dn1000S3MSS3 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S3MSS3 = allValuesDosS3MSS3[1];
}
if (dn1000S3MSS3 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S3MSS3 = allValuesDosS3MSS3[1];
}
printf("dn1000 Scene 3 MSS3: %12f\n", dn1000S3MSS3);
########################### Scene 3 - Dn1000 - Band 4
numeric lastDOSS3MSS4 = dosS3MSS4realSize;
numeric hDOSS3MSS4 = 1;
while ( (hDOSS3MSS4 * 3 + 1) < lastDOSS3MSS4 - 1 )
{
hDOSS3MSS4 = 3 * hDOSS3MSS4 + 1;
}
while ( hDOSS3MSS4 > 0 )
{
for i = hDOSS3MSS4 - 1 to lastDOSS3MSS4
{
numeric keyDOSS3MSS4 = allValuesDosS3MSS4[i];
numeric jDOSS3MSS4 = i;
while (jDOSS3MSS4 >= hDOSS3MSS4 && allValuesDosS3MSS4[jDOSS3MSS4 - hDOSS3MSS4] > keyDOSS3MSS4)
{
allValuesDosS3MSS4[jDOSS3MSS4] = allValuesDosS3MSS4[jDOSS3MSS4 - hDOSS3MSS4];
jDOSS3MSS4 = jDOSS3MSS4 - hDOSS3MSS4;
}
allValuesDosS3MSS4[jDOSS3MSS4] = keyDOSS3MSS4;
}
hDOSS3MSS4 = floor(hDOSS3MSS4/3);
}
numeric minValueDosS3MSS4 = allValuesDosS3MSS4[1];
numeric dn1000S3MSS4 = 10000;
numeric actualCountDosS3MSS4 = 0;
for i = 1 to dosS3MSS4realSize
{
if (allValuesDosS3MSS4[i] == minValueDosS3MSS4)
{
actualCountDosS3MSS4 = actualCountDosS3MSS4 + 1;
if (actualCountDosS3MSS4 >= DNminCALCS3MSS4)
{
dn1000S3MSS4 = minValueDosS3MSS4;
go to dn1000S3MSS4jumper;
}
}
else
{
minValueDosS3MSS4 = allValuesDosS3MSS4[i+1];
actualCountDosS3MSS4 = 0;
}
}
dn1000S3MSS4jumper:
if (dn1000S3MSS4 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S3MSS4 = allValuesDosS3MSS4[1];
}
if (dn1000S3MSS4 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S3MSS4 = allValuesDosS3MSS4[1];
}
printf("dn1000 Scene 3 MSS4: %12f\n", dn1000S3MSS4);
################################### Pathradiance Calculation #######################################
numeric pathRadS3MSS1 = dn1000S3MSS1 - (0.01 * (radsurfMSS3b1 * cos(s3zenith)) / pi);
numeric pathRadS3MSS2 = dn1000S3MSS2 - (0.01 * (radsurfMSS3b2 * cos(s3zenith)) / pi);
numeric pathRadS3MSS3 = dn1000S3MSS3 - (0.01 * (radsurfMSS3b3 * cos(s3zenith)) / pi);
numeric pathRadS3MSS4 = dn1000S3MSS4 - (0.01 * (radsurfMSS3b4 * cos(s3zenith)) / pi);
printf("Pathradiance Scene 3 Band 1: %12f\n", pathRadS3MSS1);
printf("Pathradiance Scene 3 Band 2: %12f\n", pathRadS3MSS2);
printf("Pathradiance Scene 3 Band 3: %12f\n", pathRadS3MSS3);
printf("Pathradiance Scene 3 Band 4: %12f\n\n", pathRadS3MSS4);
################################# Reflectance Calculation with athmo correction
for i = 1 to MSSlins
{
for j = 1 to MSScols
{
valueS3MSS1 = (pi * (RADS3MSS1[i,j] - pathRadS3MSS1)) / (radsurfMSS3b1 * cos(s3zenith));
if ( valueS3MSS1 < 0 )
{
valueS3MSS1 = 0;
countS3REFnullMSS1 = countS3REFnullMSS1 + 1;
}
else if ( valueS3MSS1 > 1 )
{
valueS3MSS1 = 1;
countS3REFoneMSS1 = countS3REFoneMSS1 + 1;
}
REFS3MSS1[i,j] = valueS3MSS1;
valueS3MSS2 = (pi * (RADS3MSS2[i,j] - pathRadS3MSS2)) / (radsurfMSS3b2 * cos(s3zenith));
if ( valueS3MSS2 < 0 )
{
valueS3MSS2 = 0;
countS3REFnullMSS2 = countS3REFnullMSS2 + 1;
}
else if ( valueS3MSS2 > 1 )
{
valueS3MSS2 = 1;
countS3REFoneMSS2 = countS3REFoneMSS2 + 1;
}
REFS3MSS2[i,j] = valueS3MSS2;
valueS3MSS3 = (pi * (RADS3MSS3[i,j] - pathRadS3MSS3)) / (radsurfMSS3b3 * cos(s3zenith));
if ( valueS3MSS3 < 0 )
{
valueS3MSS3 = 0;
countS3REFnullMSS3 = countS3REFnullMSS3 + 1;
}
else if ( valueS3MSS3 > 1 )
{
valueS3MSS3 = 1;
countS3REFoneMSS3 = countS3REFoneMSS3 + 1;
}
REFS3MSS3[i,j] = valueS3MSS3;
valueS3MSS4 = (pi * (RADS3MSS4[i,j] - pathRadS3MSS4)) / (radsurfMSS3b4 * cos(s3zenith));
if ( valueS3MSS4 < 0 )
{
valueS3MSS4 = 0;
countS3REFnullMSS4 = countS3REFnullMSS4 + 1;
}
else if ( valueS3MSS4 > 1 )
{
valueS3MSS4 = 1;
countS3REFoneMSS4 = countS3REFoneMSS4 + 1;
}
REFS3MSS4[i,j] = valueS3MSS4;
}
}
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 3 Band 1: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS3REFnullMSS1, countS3REFoneMSS1);
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 3 Band 2: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS3REFnullMSS2, countS3REFoneMSS2);
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 3 Band 3: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS3REFnullMSS3, countS3REFoneMSS3);
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 3 Band 4: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS3REFnullMSS4, countS3REFoneMSS4);
CreatePyramid(REFS3MSS1);
CreatePyramid(REFS3MSS2);
CreatePyramid(REFS3MSS3);
CreatePyramid(REFS3MSS4);
CreateHistogram(REFS3MSS1);
CreateHistogram(REFS3MSS2);
CreateHistogram(REFS3MSS3);
CreateHistogram(REFS3MSS4);
CloseRaster(RADS3MSS1);
CloseRaster(RADS3MSS2);
CloseRaster(RADS3MSS3);
CloseRaster(RADS3MSS4);
printf("Reflectance calculation for Scene 3 (MSS) is done...\n\n\n");
}
else
{
raster REFS3MSS1, REFS3MSS2, REFS3MSS3, REFS3MSS4;
numeric radsurfMSS3b1, radsurfMSS3b2, radsurfMSS3b3, radsurfMSS3b4;
numeric valueS3MSS1, valueS3MSS2, valueS3MSS3, valueS3MSS4;
numeric dosS3MSS1nullValCount = 0;
numeric dosS3MSS2nullValCount = 0;
numeric dosS3MSS3nullValCount = 0;
numeric dosS3MSS4nullValCount = 0;
numeric dosS3MSS1realArrayCount = 1;
numeric dosS3MSS2realArrayCount = 1;
numeric dosS3MSS3realArrayCount = 1;
numeric dosS3MSS4realArrayCount = 1;
numeric countS3REFnullMSS1 = 0;
numeric countS3REFnullMSS2 = 0;
numeric countS3REFnullMSS3 = 0;
numeric countS3REFnullMSS4 = 0;
numeric countS3REFoneMSS1 = 0;
numeric countS3REFoneMSS2 = 0;
numeric countS3REFoneMSS3 = 0;
numeric countS3REFoneMSS4 = 0;
radsurfMSS3b1 = ESMSS11 / (dist3^2);
radsurfMSS3b2 = ESMSS12 / (dist3^2);
radsurfMSS3b3 = ESMSS13 / (dist3^2);
radsurfMSS3b4 = ESMSS14 / (dist3^2);
printf("Surface Radiance MSS Band 1 in W/m^2µm (Scene 3): %12f\n", radsurfMSS3b1);
printf("Surface Radiance MSS Band 2 in W/m^2µm (Scene 3): %12f\n", radsurfMSS3b2);
printf("Surface Radiance MSS Band 3 in W/m^2µm (Scene 3): %12f\n", radsurfMSS3b3);
printf("Surface Radiance MSS Band 4 in W/m^2µm (Scene 3): %12f\n\n", radsurfMSS3b4);
for i = 1 to MSSlins
{
for j = 1 to MSScols
{
if (IsNull(RADS3MSS1[i,j]) == 1)
{
dosS3MSS1nullValCount = dosS3MSS1nullValCount + 1;
}
if (IsNull(RADS3MSS2[i,j]) == 1)
{
dosS3MSS2nullValCount = dosS3MSS2nullValCount + 1;
}
if (IsNull(RADS3MSS3[i,j]) == 1)
{
dosS3MSS3nullValCount = dosS3MSS3nullValCount + 1;
}
if (IsNull(RADS3MSS4[i,j]) == 1)
{
dosS3MSS4nullValCount = dosS3MSS4nullValCount + 1;
}
}
}
numeric dosS3MSS1realSize = (MSSlins * MSScols) - dosS3MSS1nullValCount;
numeric dosS3MSS2realSize = (MSSlins * MSScols) - dosS3MSS2nullValCount;
numeric dosS3MSS3realSize = (MSSlins * MSScols) - dosS3MSS3nullValCount;
numeric dosS3MSS4realSize = (MSSlins * MSScols) - dosS3MSS4nullValCount;
array allValuesDosS3MSS1[dosS3MSS1realSize];
array allValuesDosS3MSS2[dosS3MSS2realSize];
array allValuesDosS3MSS3[dosS3MSS3realSize];
array allValuesDosS3MSS4[dosS3MSS4realSize];
numeric DNminCALCS3MSS1 = DNminCALC(Scene3Lin, Scene3Col, dosS3MSS1realSize);
numeric DNminCALCS3MSS2 = DNminCALC(Scene3Lin, Scene3Col, dosS3MSS2realSize);
numeric DNminCALCS3MSS3 = DNminCALC(Scene3Lin, Scene3Col, dosS3MSS3realSize);
numeric DNminCALCS3MSS4 = DNminCALC(Scene3Lin, Scene3Col, dosS3MSS4realSize);
for i = 1 to MSSlins
{
for j = 1 to MSScols
{
if (IsNull(RADS3MSS1[i,j]) == 0)
{
allValuesDosS3MSS1[dosS3MSS1realArrayCount] = RADS3MSS1[i,j];
dosS3MSS1realArrayCount = dosS3MSS1realArrayCount + 1;
}
if (IsNull(RADS3MSS2[i,j]) == 0)
{
allValuesDosS3MSS2[dosS3MSS2realArrayCount] = RADS3MSS2[i,j];
dosS3MSS2realArrayCount = dosS3MSS2realArrayCount + 1;
}
if (IsNull(RADS3MSS3[i,j]) == 0)
{
allValuesDosS3MSS3[dosS3MSS3realArrayCount] = RADS3MSS3[i,j];
dosS3MSS3realArrayCount = dosS3MSS3realArrayCount + 1;
}
if (IsNull(RADS3MSS4[i,j]) == 0)
{
allValuesDosS3MSS4[dosS3MSS4realArrayCount] = RADS3MSS4[i,j];
dosS3MSS4realArrayCount = dosS3MSS4realArrayCount + 1;
}
}
}
########################### Scene 1 - Dn1000 - Band 1
numeric lastDOSS3MSS1 = dosS3MSS1realSize;
numeric hDOSS3MSS1 = 1;
while ( (hDOSS3MSS1 * 3 + 1) < lastDOSS3MSS1 - 1 )
{
hDOSS3MSS1 = 3 * hDOSS3MSS1 + 1;
}
while ( hDOSS3MSS1 > 0 )
{
for i = hDOSS3MSS1 - 1 to lastDOSS3MSS1 # for each of the h sets of elements
{
numeric keyDOSS3MSS1 = allValuesDosS3MSS1[i];
numeric jDOSS3MSS1 = i;
while (jDOSS3MSS1 >= hDOSS3MSS1 && allValuesDosS3MSS1[jDOSS3MSS1 - hDOSS3MSS1] > keyDOSS3MSS1)
{
allValuesDosS3MSS1[jDOSS3MSS1] = allValuesDosS3MSS1[jDOSS3MSS1 - hDOSS3MSS1];
jDOSS3MSS1 = jDOSS3MSS1 - hDOSS3MSS1;
}
allValuesDosS3MSS1[jDOSS3MSS1] = keyDOSS3MSS1;
}
hDOSS3MSS1 = floor(hDOSS3MSS1/3);
}
numeric minValueDosS3MSS1 = allValuesDosS3MSS1[1];
numeric dn1000S3MSS1 = 10000;
numeric actualCountDosS3MSS1 = 0;
for i = 1 to dosS3MSS1realSize
{
if (allValuesDosS3MSS1[i] == minValueDosS3MSS1)
{
actualCountDosS3MSS1 = actualCountDosS3MSS1 + 1;
if (actualCountDosS3MSS1 >= DNminCALCS3MSS1)
{
dn1000S3MSS1 = minValueDosS3MSS1;
go to dn1000S3MSS1jumper;
}
}
else
{
minValueDosS3MSS1 = allValuesDosS3MSS1[i+1];
actualCountDosS3MSS1 = 0;
}
}
dn1000S3MSS1jumper:
if (dn1000S3MSS1 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S3MSS1 = allValuesDosS3MSS1[1];
}
if (dn1000S3MSS1 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S3MSS1 = allValuesDosS3MSS1[1];
}
printf("dn1000 Scene 3 MSS1: %12f\n", dn1000S3MSS1);
########################### Scene 3 - Dn1000 - Band 2
numeric lastDOSS3MSS2 = dosS3MSS1realSize;
numeric hDOSS3MSS2 = 1;
while ( (hDOSS3MSS2 * 3 + 1) < lastDOSS3MSS2 - 1 )
{
hDOSS3MSS2 = 3 * hDOSS3MSS2 + 1;
}
while ( hDOSS3MSS2 > 0 )
{
for i = hDOSS3MSS2 - 1 to lastDOSS3MSS2
{
numeric keyDOSS3MSS2 = allValuesDosS3MSS2[i];
numeric jDOSS3MSS2 = i;
while (jDOSS3MSS2 >= hDOSS3MSS2 && allValuesDosS3MSS2[jDOSS3MSS2 - hDOSS3MSS2] > keyDOSS3MSS2)
{
allValuesDosS3MSS2[jDOSS3MSS2] = allValuesDosS3MSS2[jDOSS3MSS2 - hDOSS3MSS2];
jDOSS3MSS2 = jDOSS3MSS2 - hDOSS3MSS2;
}
allValuesDosS3MSS2[jDOSS3MSS2] = keyDOSS3MSS2;
}
hDOSS3MSS2 = floor(hDOSS3MSS2/3);
}
numeric minValueDosS3MSS2 = allValuesDosS3MSS2[1];
numeric dn1000S3MSS2 = 10000;
numeric actualCountDosS3MSS2 = 0;
for i = 1 to dosS3MSS2realSize
{
if (allValuesDosS3MSS2[i] == minValueDosS3MSS2)
{
actualCountDosS3MSS2 = actualCountDosS3MSS2 + 1;
if (actualCountDosS3MSS2 >= DNminCALCS3MSS2)
{
dn1000S3MSS2 = minValueDosS3MSS2;
go to dn1000S3MSS2jumper;
}
}
else
{
minValueDosS3MSS2 = allValuesDosS3MSS2[i+1];
actualCountDosS3MSS2 = 0;
}
}
dn1000S3MSS2jumper:
if (dn1000S3MSS2 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S3MSS2 = allValuesDosS3MSS2[1];
}
if (dn1000S3MSS2 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S3MSS2 = allValuesDosS3MSS2[1];
}
printf("dn1000 Scene 3 MSS2: %12f\n", dn1000S3MSS2);
########################### Scene 1 - Dn1000 - Band 3
numeric lastDOSS3MSS3 = dosS3MSS3realSize;
numeric hDOSS3MSS3 = 1;
while ( (hDOSS3MSS3 * 3 + 1) < lastDOSS3MSS3 - 1 )
{
hDOSS3MSS3 = 3 * hDOSS3MSS3 + 1;
}
while ( hDOSS3MSS3 > 0 )
{
for i = hDOSS3MSS3 - 1 to lastDOSS3MSS3 # for each of the h sets of elements
{
numeric keyDOSS3MSS3 = allValuesDosS3MSS3[i];
numeric jDOSS3MSS3 = i;
while (jDOSS3MSS3 >= hDOSS3MSS3 && allValuesDosS3MSS3[jDOSS3MSS3 - hDOSS3MSS3] > keyDOSS3MSS3)
{
allValuesDosS3MSS3[jDOSS3MSS3] = allValuesDosS3MSS3[jDOSS3MSS3 - hDOSS3MSS3];
jDOSS3MSS3 = jDOSS3MSS3 - hDOSS3MSS3;
}
allValuesDosS3MSS3[jDOSS3MSS3] = keyDOSS3MSS3;
}
hDOSS3MSS3 = floor(hDOSS3MSS3/3);
}
numeric minValueDosS3MSS3 = allValuesDosS3MSS3[1];
numeric dn1000S3MSS3 = 10000;
numeric actualCountDosS3MSS3 = 0;
for i = 1 to dosS3MSS3realSize
{
if (allValuesDosS3MSS3[i] == minValueDosS3MSS3)
{
actualCountDosS3MSS3 = actualCountDosS3MSS3 + 1;
if (actualCountDosS3MSS3 >= DNminCALCS3MSS3)
{
dn1000S3MSS3 = minValueDosS3MSS3;
go to dn1000S3MSS3jumper;
}
}
else
{
minValueDosS3MSS3 = allValuesDosS3MSS3[i+1];
actualCountDosS3MSS3 = 0;
}
}
dn1000S3MSS3jumper:
if (dn1000S3MSS3 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S3MSS3 = allValuesDosS3MSS3[1];
}
if (dn1000S3MSS3 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S3MSS3 = allValuesDosS3MSS3[1];
}
printf("dn1000 Scene 3 MSS3: %12f\n", dn1000S3MSS3);
########################### Scene 3 - Dn1000 - Band 4
numeric lastDOSS3MSS4 = dosS3MSS4realSize;
numeric hDOSS3MSS4 = 1;
while ( (hDOSS3MSS4 * 3 + 1) < lastDOSS3MSS4 - 1 )
{
hDOSS3MSS4 = 3 * hDOSS3MSS4 + 1;
}
while ( hDOSS3MSS4 > 0 )
{
for i = hDOSS3MSS4 - 1 to lastDOSS3MSS4
{
numeric keyDOSS3MSS4 = allValuesDosS3MSS4[i];
numeric jDOSS3MSS4 = i;
while (jDOSS3MSS4 >= hDOSS3MSS4 && allValuesDosS3MSS4[jDOSS3MSS4 - hDOSS3MSS4] > keyDOSS3MSS4)
{
allValuesDosS3MSS4[jDOSS3MSS4] = allValuesDosS3MSS4[jDOSS3MSS4 - hDOSS3MSS4];
jDOSS3MSS4 = jDOSS3MSS4 - hDOSS3MSS4;
}
allValuesDosS3MSS4[jDOSS3MSS4] = keyDOSS3MSS4;
}
hDOSS3MSS4 = floor(hDOSS3MSS4/3);
}
numeric minValueDosS3MSS4 = allValuesDosS3MSS4[1];
numeric dn1000S3MSS4 = 10000;
numeric actualCountDosS3MSS4 = 0;
for i = 1 to dosS3MSS4realSize
{
if (allValuesDosS3MSS4[i] == minValueDosS3MSS4)
{
actualCountDosS3MSS4 = actualCountDosS3MSS4 + 1;
if (actualCountDosS3MSS4 >= DNminCALCS3MSS4)
{
dn1000S3MSS4 = minValueDosS3MSS4;
go to dn1000S3MSS4jumper;
}
}
else
{
minValueDosS3MSS4 = allValuesDosS3MSS4[i+1];
actualCountDosS3MSS4 = 0;
}
}
dn1000S3MSS4jumper:
if (dn1000S3MSS4 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S3MSS4 = allValuesDosS3MSS4[1];
}
if (dn1000S3MSS4 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S3MSS4 = allValuesDosS3MSS4[1];
}
printf("dn1000 Scene 3 MSS4: %12f\n", dn1000S3MSS4);
################################### Pathradiance Calculation #######################################
numeric pathRadS3MSS1 = dn1000S3MSS1 - (0.01 * (radsurfMSS3b1 * cos(s3zenith)) / pi);
numeric pathRadS3MSS2 = dn1000S3MSS2 - (0.01 * (radsurfMSS3b2 * cos(s3zenith)) / pi);
numeric pathRadS3MSS3 = dn1000S3MSS3 - (0.01 * (radsurfMSS3b3 * cos(s3zenith)) / pi);
numeric pathRadS3MSS4 = dn1000S3MSS4 - (0.01 * (radsurfMSS3b4 * cos(s3zenith)) / pi);
printf("Pathradiance Scene 3 Band 1: %12f\n", pathRadS3MSS1);
printf("Pathradiance Scene 3 Band 2: %12f\n", pathRadS3MSS2);
printf("Pathradiance Scene 3 Band 3: %12f\n", pathRadS3MSS3);
printf("Pathradiance Scene 3 Band 4: %12f\n\n", pathRadS3MSS4);
################################# Reflectance Calculation with athmo correction
for i = 1 to MSSlins
{
for j = 1 to MSScols
{
valueS3MSS1 = (pi * (RADS3MSS1[i,j] - pathRadS3MSS1)) / (radsurfMSS3b1 * cos(s3zenith));
if ( valueS3MSS1 < 0 )
{
valueS3MSS1 = 0;
countS3REFnullMSS1 = countS3REFnullMSS1 + 1;
}
else if ( valueS3MSS1 > 1 )
{
valueS3MSS1 = 1;
countS3REFoneMSS1 = countS3REFoneMSS1 + 1;
}
REFS3MSS1[i,j] = valueS3MSS1;
valueS3MSS2 = (pi * (RADS3MSS2[i,j] - pathRadS3MSS2)) / (radsurfMSS3b2 * cos(s3zenith));
if ( valueS3MSS2 < 0 )
{
valueS3MSS2 = 0;
countS3REFnullMSS2 = countS3REFnullMSS2 + 1;
}
else if ( valueS3MSS2 > 1 )
{
valueS3MSS2 = 1;
countS3REFoneMSS2 = countS3REFoneMSS2 + 1;
}
REFS3MSS2[i,j] = valueS3MSS2;
valueS3MSS3 = (pi * (RADS3MSS3[i,j] - pathRadS3MSS3)) / (radsurfMSS3b3 * cos(s3zenith));
if ( valueS3MSS3 < 0 )
{
valueS3MSS3 = 0;
countS3REFnullMSS3 = countS3REFnullMSS3 + 1;
}
else if ( valueS3MSS3 > 1 )
{
valueS3MSS3 = 1;
countS3REFoneMSS3 = countS3REFoneMSS3 + 1;
}
REFS3MSS3[i,j] = valueS3MSS3;
valueS3MSS4 = (pi * (RADS3MSS4[i,j] - pathRadS3MSS4)) / (radsurfMSS3b4 * cos(s3zenith));
if ( valueS3MSS4 < 0 )
{
valueS3MSS4 = 0;
countS3REFnullMSS4 = countS3REFnullMSS4 + 1;
}
else if ( valueS3MSS4 > 1 )
{
valueS3MSS4 = 1;
countS3REFoneMSS4 = countS3REFoneMSS4 + 1;
}
REFS3MSS4[i,j] = valueS3MSS4;
}
}
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 3 Band 1: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS3REFnullMSS1, countS3REFoneMSS1);
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 3 Band 2: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS3REFnullMSS2, countS3REFoneMSS2);
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 3 Band 3: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS3REFnullMSS3, countS3REFoneMSS3);
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 3 Band 4: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS3REFnullMSS4, countS3REFoneMSS4);
CreatePyramid(REFS3MSS1);
CreatePyramid(REFS3MSS2);
CreatePyramid(REFS3MSS3);
CreatePyramid(REFS3MSS4);
CreateHistogram(REFS3MSS1);
CreateHistogram(REFS3MSS2);
CreateHistogram(REFS3MSS3);
CreateHistogram(REFS3MSS4);
CloseRaster(RADS3MSS1);
CloseRaster(RADS3MSS2);
CloseRaster(RADS3MSS3);
CloseRaster(RADS3MSS4);
printf("Reflectance calculation for Scene 3 (MSS) is done...\n\n\n");
}
#############################
#### Reflectance Scene 4
#############################
if ( sensors4 == 7 )
{
raster REFS4ETM1, REFS4ETM2, REFS4ETM3, REFS4ETM4, REFS4ETM5, REFS4ETM7;
numeric radsurfETMS4b1, radsurfETMS4b2, radsurfETMS4b3, radsurfETMS4b4, radsurfETMS4b5, radsurfETMS4b7;
numeric valueS4ETM1, valueS4ETM2, valueS4ETM3, valueS4ETM4, valueS4ETM5, valueS4ETM7;
numeric dosS4ETM1nullValCount = 0;
numeric dosS4ETM2nullValCount = 0;
numeric dosS4ETM3nullValCount = 0;
numeric dosS4ETM4nullValCount = 0;
numeric dosS4ETM5nullValCount = 0;
numeric dosS4ETM7nullValCount = 0;
numeric dosS4ETM1realArrayCount = 1;
numeric dosS4ETM2realArrayCount = 1;
numeric dosS4ETM3realArrayCount = 1;
numeric dosS4ETM4realArrayCount = 1;
numeric dosS4ETM5realArrayCount = 1;
numeric dosS4ETM7realArrayCount = 1;
numeric countS4REFnullETM1 = 0;
numeric countS4REFnullETM2 = 0;
numeric countS4REFnullETM3 = 0;
numeric countS4REFnullETM4 = 0;
numeric countS4REFnullETM5 = 0;
numeric countS4REFnullETM7 = 0;
numeric countS4REFoneETM1 = 0;
numeric countS4REFoneETM2 = 0;
numeric countS4REFoneETM3 = 0;
numeric countS4REFoneETM4 = 0;
numeric countS4REFoneETM5 = 0;
numeric countS4REFoneETM7 = 0;
radsurfETMS4b1 = ESETM1 / (dist4^2);
radsurfETMS4b2 = ESETM2 / (dist4^2);
radsurfETMS4b3 = ESETM3 / (dist4^2);
radsurfETMS4b4 = ESETM4 / (dist4^2);
radsurfETMS4b5 = ESETM5 / (dist4^2);
radsurfETMS4b7 = ESETM7 / (dist4^2);
printf("Surface Radiance ETM Band 1 in W/m^2µm (Scene 4): %12f\n", radsurfETMS4b1);
printf("Surface Radiance ETM Band 2 in W/m^2µm (Scene 4): %12f\n", radsurfETMS4b2);
printf("Surface Radiance ETM Band 3 in W/m^2µm (Scene 4): %12f\n", radsurfETMS4b3);
printf("Surface Radiance ETM Band 4 in W/m^2µm (Scene 4): %12f\n", radsurfETMS4b4);
printf("Surface Radiance ETM Band 5 in W/m^2µm (Scene 4): %12f\n", radsurfETMS4b5);
printf("Surface Radiance ETM Band 7 in W/m^2µm (Scene 4): %12f\n\n", radsurfETMS4b7);
for i = 1 to ETMlins
{
for j = 1 to ETMcols
{
if (IsNull(RADS4ETM1[i,j]) == 1)
{
dosS4ETM1nullValCount = dosS4ETM1nullValCount + 1;
}
if (IsNull(RADS4ETM2[i,j]) == 1)
{
dosS4ETM2nullValCount = dosS4ETM2nullValCount + 1;
}
if (IsNull(RADS4ETM3[i,j]) == 1)
{
dosS4ETM3nullValCount = dosS4ETM3nullValCount + 1;
}
if (IsNull(RADS4ETM4[i,j]) == 1)
{
dosS4ETM4nullValCount = dosS4ETM4nullValCount + 1;
}
if (IsNull(RADS4ETM5[i,j]) == 1)
{
dosS4ETM5nullValCount = dosS4ETM5nullValCount + 1;
}
if (IsNull(RADS4ETM7[i,j]) == 1)
{
dosS4ETM7nullValCount = dosS4ETM7nullValCount + 1;
}
}
}
numeric dosS4ETM1realSize = (ETMlins * ETMcols) - dosS4ETM1nullValCount;
numeric dosS4ETM2realSize = (ETMlins * ETMcols) - dosS4ETM2nullValCount;
numeric dosS4ETM3realSize = (ETMlins * ETMcols) - dosS4ETM3nullValCount;
numeric dosS4ETM4realSize = (ETMlins * ETMcols) - dosS4ETM4nullValCount;
numeric dosS4ETM5realSize = (ETMlins * ETMcols) - dosS4ETM5nullValCount;
numeric dosS4ETM7realSize = (ETMlins * ETMcols) - dosS4ETM7nullValCount;
array allValuesDosS4ETM1[dosS4ETM1realSize];
array allValuesDosS4ETM2[dosS4ETM2realSize];
array allValuesDosS4ETM3[dosS4ETM3realSize];
array allValuesDosS4ETM4[dosS4ETM4realSize];
array allValuesDosS4ETM5[dosS4ETM5realSize];
array allValuesDosS4ETM7[dosS4ETM7realSize];
numeric DNminCALCS4ETM1 = DNminCALC(Scene4Lin, Scene4Col, dosS4ETM1realSize);
numeric DNminCALCS4ETM2 = DNminCALC(Scene4Lin, Scene4Col, dosS4ETM2realSize);
numeric DNminCALCS4ETM3 = DNminCALC(Scene4Lin, Scene4Col, dosS4ETM3realSize);
numeric DNminCALCS4ETM4 = DNminCALC(Scene4Lin, Scene4Col, dosS4ETM4realSize);
numeric DNminCALCS4ETM5 = DNminCALC(Scene4Lin, Scene4Col, dosS4ETM5realSize);
numeric DNminCALCS4ETM7 = DNminCALC(Scene4Lin, Scene4Col, dosS4ETM7realSize);
for i = 1 to ETMlins
{
for j = 1 to ETMcols
{
if (IsNull(RADS4ETM1[i,j]) == 0)
{
allValuesDosS4ETM1[dosS4ETM1realArrayCount] = RADS4ETM1[i,j];
dosS4ETM1realArrayCount = dosS4ETM1realArrayCount + 1;
}
if (IsNull(RADS4ETM2[i,j]) == 0)
{
allValuesDosS4ETM2[dosS4ETM2realArrayCount] = RADS4ETM2[i,j];
dosS4ETM2realArrayCount = dosS4ETM2realArrayCount + 1;
}
if (IsNull(RADS4ETM3[i,j]) == 0)
{
allValuesDosS4ETM3[dosS4ETM3realArrayCount] = RADS4ETM3[i,j];
dosS4ETM3realArrayCount = dosS4ETM3realArrayCount + 1;
}
if (IsNull(RADS4ETM4[i,j]) == 0)
{
allValuesDosS4ETM4[dosS4ETM4realArrayCount] = RADS4ETM4[i,j];
dosS4ETM4realArrayCount = dosS4ETM4realArrayCount + 1;
}
if (IsNull(RADS4ETM5[i,j]) == 0)
{
allValuesDosS4ETM5[dosS4ETM5realArrayCount] = RADS4ETM5[i,j];
dosS4ETM5realArrayCount = dosS4ETM5realArrayCount + 1;
}
if (IsNull(RADS4ETM7[i,j]) == 0)
{
allValuesDosS4ETM7[dosS4ETM7realArrayCount] = RADS4ETM7[i,j];
dosS4ETM7realArrayCount = dosS4ETM7realArrayCount + 1;
}
}
}
########################### Scene 4 - Dn1000 - Band 1
numeric lastDOSS4ETM1 = dosS4ETM1realSize;
numeric hDOSS4ETM1 = 1;
while ( (hDOSS4ETM1 * 3 + 1) < lastDOSS4ETM1 - 1 )
{
hDOSS4ETM1 = 3 * hDOSS4ETM1 + 1;
}
while ( hDOSS4ETM1 > 0 )
{
for i = hDOSS4ETM1 - 1 to lastDOSS4ETM1 # for each of the h sets of elements
{
numeric keyDOSS4ETM1 = allValuesDosS4ETM1[i];
numeric jDOSS4ETM1 = i;
while (jDOSS4ETM1 >= hDOSS4ETM1 && allValuesDosS4ETM1[jDOSS4ETM1 - hDOSS4ETM1] > keyDOSS4ETM1)
{
allValuesDosS4ETM1[jDOSS4ETM1] = allValuesDosS4ETM1[jDOSS4ETM1 - hDOSS4ETM1];
jDOSS4ETM1 = jDOSS4ETM1 - hDOSS4ETM1;
}
allValuesDosS4ETM1[jDOSS4ETM1] = keyDOSS4ETM1;
}
hDOSS4ETM1 = floor(hDOSS4ETM1/3);
}
numeric minValueDosS4ETM1 = allValuesDosS4ETM1[1];
numeric dn1000S4ETM1 = 10000;
numeric actualCountDosS4ETM1 = 0;
for i = 1 to dosS4ETM1realSize
{
if (allValuesDosS4ETM1[i] == minValueDosS4ETM1)
{
actualCountDosS4ETM1 = actualCountDosS4ETM1 + 1;
if (actualCountDosS4ETM1 >= DNminCALCS4ETM1)
{
dn1000S4ETM1 = minValueDosS4ETM1;
go to dn1000S4ETM1jumper;
}
}
else
{
minValueDosS4ETM1 = allValuesDosS4ETM1[i+1];
actualCountDosS4ETM1 = 0;
}
}
dn1000S4ETM1jumper:
if (dn1000S4ETM1 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S4ETM1 = allValuesDosS4ETM1[1];
}
if (dn1000S4ETM1 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S4ETM1 = allValuesDosS4ETM1[1];
}
printf("dn1000 Scene 4 ETM1: %12f\n", dn1000S4ETM1);
########################### Scene 4 - Dn1000 - Band 2
numeric lastDOSS4ETM2 = dosS4ETM1realSize;
numeric hDOSS4ETM2 = 1;
while ( (hDOSS4ETM2 * 3 + 1) < lastDOSS4ETM2 - 1 )
{
hDOSS4ETM2 = 3 * hDOSS4ETM2 + 1;
}
while ( hDOSS4ETM2 > 0 )
{
for i = hDOSS4ETM2 - 1 to lastDOSS4ETM2
{
numeric keyDOSS4ETM2 = allValuesDosS4ETM2[i];
numeric jDOSS4ETM2 = i;
while (jDOSS4ETM2 >= hDOSS4ETM2 && allValuesDosS4ETM2[jDOSS4ETM2 - hDOSS4ETM2] > keyDOSS4ETM2)
{
allValuesDosS4ETM2[jDOSS4ETM2] = allValuesDosS4ETM2[jDOSS4ETM2 - hDOSS4ETM2];
jDOSS4ETM2 = jDOSS4ETM2 - hDOSS4ETM2;
}
allValuesDosS4ETM2[jDOSS4ETM2] = keyDOSS4ETM2;
}
hDOSS4ETM2 = floor(hDOSS4ETM2/3);
}
numeric minValueDosS4ETM2 = allValuesDosS4ETM2[1];
numeric dn1000S4ETM2 = 10000;
numeric actualCountDosS4ETM2 = 0;
for i = 1 to dosS4ETM2realSize
{
if (allValuesDosS4ETM2[i] == minValueDosS4ETM2)
{
actualCountDosS4ETM2 = actualCountDosS4ETM2 + 1;
if (actualCountDosS4ETM2 >= DNminCALCS4ETM2)
{
dn1000S4ETM2 = minValueDosS4ETM2;
go to dn1000S4ETM2jumper;
}
}
else
{
minValueDosS4ETM2 = allValuesDosS4ETM2[i+1];
actualCountDosS4ETM2 = 0;
}
}
dn1000S4ETM2jumper:
if (dn1000S4ETM2 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S4ETM2 = allValuesDosS4ETM2[1];
}
if (dn1000S4ETM2 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S4ETM2 = allValuesDosS4ETM2[1];
}
printf("dn1000 Scene 4 ETM2: %12f\n", dn1000S4ETM2);
########################### Scene 4 - Dn1000 - Band 3
numeric lastDOSS4ETM3 = dosS4ETM3realSize;
numeric hDOSS4ETM3 = 1;
while ( (hDOSS4ETM3 * 3 + 1) < lastDOSS4ETM3 - 1 )
{
hDOSS4ETM3 = 3 * hDOSS4ETM3 + 1;
}
while ( hDOSS4ETM3 > 0 )
{
for i = hDOSS4ETM3 - 1 to lastDOSS4ETM3 # for each of the h sets of elements
{
numeric keyDOSS4ETM3 = allValuesDosS4ETM3[i];
numeric jDOSS4ETM3 = i;
while (jDOSS4ETM3 >= hDOSS4ETM3 && allValuesDosS4ETM3[jDOSS4ETM3 - hDOSS4ETM3] > keyDOSS4ETM3)
{
allValuesDosS4ETM3[jDOSS4ETM3] = allValuesDosS4ETM3[jDOSS4ETM3 - hDOSS4ETM3];
jDOSS4ETM3 = jDOSS4ETM3 - hDOSS4ETM3;
}
allValuesDosS4ETM3[jDOSS4ETM3] = keyDOSS4ETM3;
}
hDOSS4ETM3 = floor(hDOSS4ETM3/3);
}
numeric minValueDosS4ETM3 = allValuesDosS4ETM3[1];
numeric dn1000S4ETM3 = 10000;
numeric actualCountDosS4ETM3 = 0;
for i = 1 to dosS4ETM3realSize
{
if (allValuesDosS4ETM3[i] == minValueDosS4ETM3)
{
actualCountDosS4ETM3 = actualCountDosS4ETM3 + 1;
if (actualCountDosS4ETM3 >= DNminCALCS4ETM3)
{
dn1000S4ETM3 = minValueDosS4ETM3;
go to dn1000S4ETM3jumper;
}
}
else
{
minValueDosS4ETM3 = allValuesDosS4ETM3[i+1];
actualCountDosS4ETM3 = 0;
}
}
dn1000S4ETM3jumper:
if (dn1000S4ETM3 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S4ETM3 = allValuesDosS4ETM3[1];
}
if (dn1000S4ETM3 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S4ETM3 = allValuesDosS4ETM3[1];
}
printf("dn1000 Scene 4 ETM3: %12f\n", dn1000S4ETM3);
########################### Scene 4 - Dn1000 - Band 4
numeric lastDOSS4ETM4 = dosS4ETM4realSize;
numeric hDOSS4ETM4 = 1;
while ( (hDOSS4ETM4 * 3 + 1) < lastDOSS4ETM4 - 1 )
{
hDOSS4ETM4 = 3 * hDOSS4ETM4 + 1;
}
while ( hDOSS4ETM4 > 0 )
{
for i = hDOSS4ETM4 - 1 to lastDOSS4ETM4
{
numeric keyDOSS4ETM4 = allValuesDosS4ETM4[i];
numeric jDOSS4ETM4 = i;
while (jDOSS4ETM4 >= hDOSS4ETM4 && allValuesDosS4ETM4[jDOSS4ETM4 - hDOSS4ETM4] > keyDOSS4ETM4)
{
allValuesDosS4ETM4[jDOSS4ETM4] = allValuesDosS4ETM4[jDOSS4ETM4 - hDOSS4ETM4];
jDOSS4ETM4 = jDOSS4ETM4 - hDOSS4ETM4;
}
allValuesDosS4ETM4[jDOSS4ETM4] = keyDOSS4ETM4;
}
hDOSS4ETM4 = floor(hDOSS4ETM4/3);
}
numeric minValueDosS4ETM4 = allValuesDosS4ETM4[1];
numeric dn1000S4ETM4 = 10000;
numeric actualCountDosS4ETM4 = 0;
for i = 1 to dosS4ETM4realSize
{
if (allValuesDosS4ETM4[i] == minValueDosS4ETM4)
{
actualCountDosS4ETM4 = actualCountDosS4ETM4 + 1;
if (actualCountDosS4ETM4 >= DNminCALCS4ETM4)
{
dn1000S4ETM4 = minValueDosS4ETM4;
go to dn1000S4ETM4jumper;
}
}
else
{
minValueDosS4ETM4 = allValuesDosS4ETM4[i+1];
actualCountDosS4ETM4 = 0;
}
}
dn1000S4ETM4jumper:
if (dn1000S4ETM4 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S4ETM4 = allValuesDosS4ETM4[1];
}
if (dn1000S4ETM4 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S4ETM4 = allValuesDosS4ETM4[1];
}
printf("dn1000 Scene 4 ETM4: %12f\n", dn1000S4ETM4);
########################### Scene 4 - Dn1000 - Band 5
numeric lastDOSS4ETM5 = dosS4ETM5realSize;
numeric hDOSS4ETM5 = 1;
while ( (hDOSS4ETM5 * 3 + 1) < lastDOSS4ETM5 - 1 )
{
hDOSS4ETM5 = 3 * hDOSS4ETM5 + 1;
}
while ( hDOSS4ETM5 > 0 )
{
for i = hDOSS4ETM5 - 1 to lastDOSS4ETM5 # for each of the h sets of elements
{
numeric keyDOSS4ETM5 = allValuesDosS4ETM5[i];
numeric jDOSS4ETM5 = i;
while (jDOSS4ETM5 >= hDOSS4ETM5 && allValuesDosS4ETM5[jDOSS4ETM5 - hDOSS4ETM5] > keyDOSS4ETM5)
{
allValuesDosS4ETM5[jDOSS4ETM5] = allValuesDosS4ETM5[jDOSS4ETM5 - hDOSS4ETM5];
jDOSS4ETM5 = jDOSS4ETM5 - hDOSS4ETM5;
}
allValuesDosS4ETM5[jDOSS4ETM5] = keyDOSS4ETM5;
}
hDOSS4ETM5 = floor(hDOSS4ETM5/3);
}
numeric minValueDosS4ETM5 = allValuesDosS4ETM5[1];
numeric dn1000S4ETM5 = 10000;
numeric actualCountDosS4ETM5 = 0;
for i = 1 to dosS4ETM5realSize
{
if (allValuesDosS4ETM5[i] == minValueDosS4ETM5)
{
actualCountDosS4ETM5 = actualCountDosS4ETM5 + 1;
if (actualCountDosS4ETM5 >= DNminCALCS4ETM5)
{
dn1000S4ETM5 = minValueDosS4ETM5;
go to dn1000S4ETM5jumper;
}
}
else
{
minValueDosS4ETM5 = allValuesDosS4ETM5[i+1];
actualCountDosS4ETM5 = 0;
}
}
dn1000S4ETM5jumper:
if (dn1000S4ETM5 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S4ETM5 = allValuesDosS4ETM5[1];
}
if (dn1000S4ETM5 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S4ETM5 = allValuesDosS4ETM5[1];
}
printf("dn1000 Scene 4 ETM5: %12f\n", dn1000S4ETM5);
########################### Scene 4 - Dn1000 - Band 7
numeric lastDOSS4ETM7 = dosS4ETM7realSize;
numeric hDOSS4ETM7 = 1;
while ( (hDOSS4ETM7 * 3 + 1) < lastDOSS4ETM7 - 1 )
{
hDOSS4ETM7 = 3 * hDOSS4ETM7 + 1;
}
while ( hDOSS4ETM7 > 0 )
{
for i = hDOSS4ETM7 - 1 to lastDOSS4ETM7 # for each of the h sets of elements
{
numeric keyDOSS4ETM7 = allValuesDosS4ETM7[i];
numeric jDOSS4ETM7 = i;
while (jDOSS4ETM7 >= hDOSS4ETM7 && allValuesDosS4ETM7[jDOSS4ETM7 - hDOSS4ETM7] > keyDOSS4ETM7)
{
allValuesDosS4ETM7[jDOSS4ETM7] = allValuesDosS4ETM7[jDOSS4ETM7 - hDOSS4ETM7];
jDOSS4ETM7 = jDOSS4ETM7 - hDOSS4ETM7;
}
allValuesDosS4ETM7[jDOSS4ETM7] = keyDOSS4ETM7;
}
hDOSS4ETM7 = floor(hDOSS4ETM7/3);
}
numeric minValueDosS4ETM7 = allValuesDosS4ETM7[1];
numeric dn1000S4ETM7 = 10000;
numeric actualCountDosS4ETM7 = 0;
for i = 1 to dosS4ETM7realSize
{
if (allValuesDosS4ETM7[i] == minValueDosS4ETM7)
{
actualCountDosS4ETM7 = actualCountDosS4ETM7 + 1;
if (actualCountDosS4ETM7 >= DNminCALCS4ETM7)
{
dn1000S4ETM7 = minValueDosS4ETM7;
go to dn1000S4ETM7jumper;
}
}
else
{
minValueDosS4ETM7 = allValuesDosS4ETM7[i+1];
actualCountDosS4ETM7 = 0;
}
}
dn1000S4ETM7jumper:
if (dn1000S4ETM7 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S4ETM7 = allValuesDosS4ETM7[1];
}
if (dn1000S4ETM7 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S4ETM7 = allValuesDosS4ETM7[1];
}
printf("dn1000 Scene 4 ETM7: %12f\n\n", dn1000S4ETM7);
################################### Pathradiance Calculation #######################################
numeric pathRadS4ETM1 = dn1000S4ETM1 - (0.01 * (radsurfETMS4b1 * cos(s4zenith)) / pi);
numeric pathRadS4ETM2 = dn1000S4ETM2 - (0.01 * (radsurfETMS4b2 * cos(s4zenith)) / pi);
numeric pathRadS4ETM3 = dn1000S4ETM3 - (0.01 * (radsurfETMS4b3 * cos(s4zenith)) / pi);
numeric pathRadS4ETM4 = dn1000S4ETM4 - (0.01 * (radsurfETMS4b4 * cos(s4zenith)) / pi);
numeric pathRadS4ETM5 = dn1000S4ETM5 - (0.01 * (radsurfETMS4b5 * cos(s4zenith)) / pi);
numeric pathRadS4ETM7 = dn1000S4ETM7 - (0.01 * (radsurfETMS4b7 * cos(s4zenith)) / pi);
printf("Pathradiance Scene 4 Band 1: %12f\n", pathRadS4ETM1);
printf("Pathradiance Scene 4 Band 2: %12f\n", pathRadS4ETM2);
printf("Pathradiance Scene 4 Band 3: %12f\n", pathRadS4ETM3);
printf("Pathradiance Scene 4 Band 4: %12f\n", pathRadS4ETM4);
printf("Pathradiance Scene 4 Band 5: %12f\n", pathRadS4ETM5);
printf("Pathradiance Scene 4 Band 7: %12f\n\n", pathRadS4ETM7);
################################# Reflectance Calculation with athmo correction
for i = 1 to ETMlins
{
for j = 1 to ETMcols
{
valueS4ETM1 = (pi * (RADS4ETM1[i,j] - pathRadS4ETM1)) / (radsurfETMS4b1 * cos(s4zenith));
if ( valueS4ETM1 < 0 )
{
valueS4ETM1 = 0;
countS4REFnullETM1 = countS4REFnullETM1 + 1;
}
else if ( valueS4ETM1 > 1 )
{
valueS4ETM1 = 1;
countS4REFoneETM1 = countS4REFoneETM1 + 1;
}
REFS4ETM1[i,j] = valueS4ETM1;
valueS4ETM2 = (pi * (RADS4ETM2[i,j] - pathRadS4ETM2)) / (radsurfETMS4b2 * cos(s4zenith));
if ( valueS4ETM2 < 0 )
{
valueS4ETM2 = 0;
countS4REFnullETM2 = countS4REFnullETM2 + 1;
}
else if ( valueS4ETM2 > 1 )
{
valueS4ETM2 = 1;
countS4REFoneETM2 = countS4REFoneETM2 + 1;
}
REFS4ETM2[i,j] = valueS4ETM2;
valueS4ETM3 = (pi * (RADS4ETM3[i,j] - pathRadS4ETM3)) / (radsurfETMS4b3 * cos(s4zenith));
if ( valueS4ETM3 < 0 )
{
valueS4ETM3 = 0;
countS4REFnullETM3 = countS4REFnullETM3 + 1;
}
else if ( valueS4ETM3 > 1 )
{
valueS4ETM3 = 1;
countS4REFoneETM3 = countS4REFoneETM3 + 1;
}
REFS4ETM3[i,j] = valueS4ETM3;
valueS4ETM4 = (pi * (RADS4ETM4[i,j] - pathRadS4ETM4)) / (radsurfETMS4b4 * cos(s4zenith));
if ( valueS4ETM4 < 0 )
{
valueS4ETM4 = 0;
countS4REFnullETM4 = countS4REFnullETM4 + 1;
}
else if ( valueS4ETM4 > 1 )
{
valueS4ETM4 = 1;
countS4REFoneETM4 = countS4REFoneETM4 + 1;
}
REFS4ETM4[i,j] = valueS4ETM4;
valueS4ETM5 = (pi * (RADS4ETM5[i,j] - pathRadS4ETM5)) / (radsurfETMS4b5 * cos(s4zenith));
if ( valueS4ETM5 < 0 )
{
valueS4ETM5 = 0;
countS4REFnullETM5 = countS4REFnullETM5 + 1;
}
else if ( valueS4ETM5 > 1 )
{
valueS4ETM5 = 1;
countS4REFoneETM5 = countS4REFoneETM5 + 1;
}
REFS4ETM5[i,j] = valueS4ETM5;
valueS4ETM7 = (pi * (RADS4ETM7[i,j] - pathRadS4ETM7)) / (radsurfETMS4b7 * cos(s4zenith));
if ( valueS4ETM7 < 0 )
{
valueS4ETM7 = 0;
countS4REFnullETM7 = countS4REFnullETM7 + 1;
}
else if ( valueS4ETM7 > 1 )
{
valueS4ETM7 = 1;
countS4REFoneETM7 = countS4REFoneETM7 + 1;
}
REFS4ETM7[i,j] = valueS4ETM7;
}
}
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 4 Band 1: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS4REFnullETM1, countS4REFoneETM1);
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 4 Band 2: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS4REFnullETM2, countS4REFoneETM2);
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 4 Band 3: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS4REFnullETM3, countS4REFoneETM3);
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 4 Band 4: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS4REFnullETM4, countS4REFoneETM4);
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 4 Band 5: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS4REFnullETM5, countS4REFoneETM5);
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 4 Band 7: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n\n", countS4REFnullETM7, countS4REFoneETM7);
CreatePyramid(REFS4ETM1);
CreatePyramid(REFS4ETM2);
CreatePyramid(REFS4ETM3);
CreatePyramid(REFS4ETM4);
CreatePyramid(REFS4ETM5);
CreatePyramid(REFS4ETM7);
CreateHistogram(REFS4ETM1);
CreateHistogram(REFS4ETM2);
CreateHistogram(REFS4ETM3);
CreateHistogram(REFS4ETM4);
CreateHistogram(REFS4ETM5);
CreateHistogram(REFS4ETM7);
CloseRaster(RADS4ETM1);
CloseRaster(RADS4ETM2);
CloseRaster(RADS4ETM3);
CloseRaster(RADS4ETM4);
CloseRaster(RADS4ETM5);
CloseRaster(RADS4ETM7);
printf("Reflectance calculation for Scene 4 (ETM) is done...\n\n\n");
}
else if ( sensors4 == 6 )
{
raster REFS4TM1, REFS4TM2, REFS4TM3, REFS4TM4, REFS4TM5, REFS4TM7;
numeric radsurfTMS4b1, radsurfTMS4b2, radsurfTMS4b3, radsurfTMS4b4, radsurfTMS4b5, radsurfTMS4b7;
numeric valueS4TM1, valueS4TM2, valueS4TM3, valueS4TM4, valueS4TM5, valueS4TM7;
numeric dosS4TM1nullValCount = 0;
numeric dosS4TM2nullValCount = 0;
numeric dosS4TM3nullValCount = 0;
numeric dosS4TM4nullValCount = 0;
numeric dosS4TM5nullValCount = 0;
numeric dosS4TM7nullValCount = 0;
numeric dosS4TM1realArrayCount = 1;
numeric dosS4TM2realArrayCount = 1;
numeric dosS4TM3realArrayCount = 1;
numeric dosS4TM4realArrayCount = 1;
numeric dosS4TM5realArrayCount = 1;
numeric dosS4TM7realArrayCount = 1;
numeric countS4REFnullTM1 = 0;
numeric countS4REFnullTM2 = 0;
numeric countS4REFnullTM3 = 0;
numeric countS4REFnullTM4 = 0;
numeric countS4REFnullTM5 = 0;
numeric countS4REFnullTM7 = 0;
numeric countS4REFoneTM1 = 0;
numeric countS4REFoneTM2 = 0;
numeric countS4REFoneTM3 = 0;
numeric countS4REFoneTM4 = 0;
numeric countS4REFoneTM5 = 0;
numeric countS4REFoneTM7 = 0;
radsurfTMS4b1 = ESTM1 / (dist4^2);
radsurfTMS4b2 = ESTM2 / (dist4^2);
radsurfTMS4b3 = ESTM3 / (dist4^2);
radsurfTMS4b4 = ESTM4 / (dist4^2);
radsurfTMS4b5 = ESTM5 / (dist4^2);
radsurfTMS4b7 = ESTM7 / (dist4^2);
printf("Surface Radiance TM Band 1 in W/m^2µm (Scene 4): %12f\n", radsurfTMS4b1);
printf("Surface Radiance TM Band 2 in W/m^2µm (Scene 4): %12f\n", radsurfTMS4b2);
printf("Surface Radiance TM Band 3 in W/m^2µm (Scene 4): %12f\n", radsurfTMS4b3);
printf("Surface Radiance TM Band 4 in W/m^2µm (Scene 4): %12f\n", radsurfTMS4b4);
printf("Surface Radiance TM Band 5 in W/m^2µm (Scene 4): %12f\n", radsurfTMS4b5);
printf("Surface Radiance TM Band 7 in W/m^2µm (Scene 4): %12f\n\n", radsurfTMS4b7);
for i = 1 to TMlins
{
for j = 1 to TMcols
{
if (IsNull(RADS4TM1[i,j]) == 1)
{
dosS4TM1nullValCount = dosS4TM1nullValCount + 1;
}
if (IsNull(RADS4TM2[i,j]) == 1)
{
dosS4TM2nullValCount = dosS4TM2nullValCount + 1;
}
if (IsNull(RADS4TM3[i,j]) == 1)
{
dosS4TM3nullValCount = dosS4TM3nullValCount + 1;
}
if (IsNull(RADS4TM4[i,j]) == 1)
{
dosS4TM4nullValCount = dosS4TM4nullValCount + 1;
}
if (IsNull(RADS4TM5[i,j]) == 1)
{
dosS4TM5nullValCount = dosS4TM5nullValCount + 1;
}
if (IsNull(RADS4TM7[i,j]) == 1)
{
dosS4TM7nullValCount = dosS4TM7nullValCount + 1;
}
}
}
numeric dosS4TM1realSize = (TMlins * TMcols) - dosS4TM1nullValCount;
numeric dosS4TM2realSize = (TMlins * TMcols) - dosS4TM2nullValCount;
numeric dosS4TM3realSize = (TMlins * TMcols) - dosS4TM3nullValCount;
numeric dosS4TM4realSize = (TMlins * TMcols) - dosS4TM4nullValCount;
numeric dosS4TM5realSize = (TMlins * TMcols) - dosS4TM5nullValCount;
numeric dosS4TM7realSize = (TMlins * TMcols) - dosS4TM7nullValCount;
array allValuesDosS4TM1[dosS4TM1realSize];
array allValuesDosS4TM2[dosS4TM2realSize];
array allValuesDosS4TM3[dosS4TM3realSize];
array allValuesDosS4TM4[dosS4TM4realSize];
array allValuesDosS4TM5[dosS4TM5realSize];
array allValuesDosS4TM7[dosS4TM7realSize];
numeric DNminCALCS4TM1 = DNminCALC(Scene4Lin, Scene4Col, dosS4TM1realSize);
numeric DNminCALCS4TM2 = DNminCALC(Scene4Lin, Scene4Col, dosS4TM2realSize);
numeric DNminCALCS4TM3 = DNminCALC(Scene4Lin, Scene4Col, dosS4TM3realSize);
numeric DNminCALCS4TM4 = DNminCALC(Scene4Lin, Scene4Col, dosS4TM4realSize);
numeric DNminCALCS4TM5 = DNminCALC(Scene4Lin, Scene4Col, dosS4TM5realSize);
numeric DNminCALCS4TM7 = DNminCALC(Scene4Lin, Scene4Col, dosS4TM7realSize);
for i = 1 to TMlins
{
for j = 1 to TMcols
{
if (IsNull(RADS4TM1[i,j]) == 0)
{
allValuesDosS4TM1[dosS4TM1realArrayCount] = RADS4TM1[i,j];
dosS4TM1realArrayCount = dosS4TM1realArrayCount + 1;
}
if (IsNull(RADS4TM2[i,j]) == 0)
{
allValuesDosS4TM2[dosS4TM2realArrayCount] = RADS4TM2[i,j];
dosS4TM2realArrayCount = dosS4TM2realArrayCount + 1;
}
if (IsNull(RADS4TM3[i,j]) == 0)
{
allValuesDosS4TM3[dosS4TM3realArrayCount] = RADS4TM3[i,j];
dosS4TM3realArrayCount = dosS4TM3realArrayCount + 1;
}
if (IsNull(RADS4TM4[i,j]) == 0)
{
allValuesDosS4TM4[dosS4TM4realArrayCount] = RADS4TM4[i,j];
dosS4TM4realArrayCount = dosS4TM4realArrayCount + 1;
}
if (IsNull(RADS4TM5[i,j]) == 0)
{
allValuesDosS4TM5[dosS4TM5realArrayCount] = RADS4TM5[i,j];
dosS4TM5realArrayCount = dosS4TM5realArrayCount + 1;
}
if (IsNull(RADS4TM7[i,j]) == 0)
{
allValuesDosS4TM7[dosS4TM7realArrayCount] = RADS4TM7[i,j];
dosS4TM7realArrayCount = dosS4TM7realArrayCount + 1;
}
}
}
########################### Scene 4 - Dn1000 - Band 1
numeric lastDOSS4TM1 = dosS4TM1realSize;
numeric hDOSS4TM1 = 1;
while ( (hDOSS4TM1 * 3 + 1) < lastDOSS4TM1 - 1 )
{
hDOSS4TM1 = 3 * hDOSS4TM1 + 1;
}
while ( hDOSS4TM1 > 0 )
{
for i = hDOSS4TM1 - 1 to lastDOSS4TM1 # for each of the h sets of elements
{
numeric keyDOSS4TM1 = allValuesDosS4TM1[i];
numeric jDOSS4TM1 = i;
while (jDOSS4TM1 >= hDOSS4TM1 && allValuesDosS4TM1[jDOSS4TM1 - hDOSS4TM1] > keyDOSS4TM1)
{
allValuesDosS4TM1[jDOSS4TM1] = allValuesDosS4TM1[jDOSS4TM1 - hDOSS4TM1];
jDOSS4TM1 = jDOSS4TM1 - hDOSS4TM1;
}
allValuesDosS4TM1[jDOSS4TM1] = keyDOSS4TM1;
}
hDOSS4TM1 = floor(hDOSS4TM1/3);
}
numeric minValueDosS4TM1 = allValuesDosS4TM1[1];
numeric dn1000S4TM1 = 10000;
numeric actualCountDosS4TM1 = 0;
for i = 1 to dosS4TM1realSize
{
if (allValuesDosS4TM1[i] == minValueDosS4TM1)
{
actualCountDosS4TM1 = actualCountDosS4TM1 + 1;
if (actualCountDosS4TM1 >= DNminCALCS4TM1)
{
dn1000S4TM1 = minValueDosS4TM1;
go to dn1000S4TM1jumper;
}
}
else
{
minValueDosS4TM1 = allValuesDosS4TM1[i+1];
actualCountDosS4TM1 = 0;
}
}
dn1000S4TM1jumper:
if (dn1000S4TM1 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S4TM1 = allValuesDosS4TM1[1];
}
if (dn1000S4TM1 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S4TM1 = allValuesDosS4TM1[1];
}
printf("dn1000 Scene 4 TM1: %12f\n", dn1000S4TM1);
########################### Scene 4 - Dn1000 - Band 2
numeric lastDOSS4TM2 = dosS4TM1realSize;
numeric hDOSS4TM2 = 1;
while ( (hDOSS4TM2 * 3 + 1) < lastDOSS4TM2 - 1 )
{
hDOSS4TM2 = 3 * hDOSS4TM2 + 1;
}
while ( hDOSS4TM2 > 0 )
{
for i = hDOSS4TM2 - 1 to lastDOSS4TM2
{
numeric keyDOSS4TM2 = allValuesDosS4TM2[i];
numeric jDOSS4TM2 = i;
while (jDOSS4TM2 >= hDOSS4TM2 && allValuesDosS4TM2[jDOSS4TM2 - hDOSS4TM2] > keyDOSS4TM2)
{
allValuesDosS4TM2[jDOSS4TM2] = allValuesDosS4TM2[jDOSS4TM2 - hDOSS4TM2];
jDOSS4TM2 = jDOSS4TM2 - hDOSS4TM2;
}
allValuesDosS4TM2[jDOSS4TM2] = keyDOSS4TM2;
}
hDOSS4TM2 = floor(hDOSS4TM2/3);
}
numeric minValueDosS4TM2 = allValuesDosS4TM2[1];
numeric dn1000S4TM2 = 10000;
numeric actualCountDosS4TM2 = 0;
for i = 1 to dosS4TM2realSize
{
if (allValuesDosS4TM2[i] == minValueDosS4TM2)
{
actualCountDosS4TM2 = actualCountDosS4TM2 + 1;
if (actualCountDosS4TM2 >= DNminCALCS4TM2)
{
dn1000S4TM2 = minValueDosS4TM2;
go to dn1000S4TM2jumper;
}
}
else
{
minValueDosS4TM2 = allValuesDosS4TM2[i+1];
actualCountDosS4TM2 = 0;
}
}
dn1000S4TM2jumper:
if (dn1000S4TM2 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S4TM2 = allValuesDosS4TM2[1];
}
if (dn1000S4TM2 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S4TM2 = allValuesDosS4TM2[1];
}
printf("dn1000 Scene 4 TM2: %12f\n", dn1000S4TM2);
########################### Scene 4 - Dn1000 - Band 3
numeric lastDOSS4TM3 = dosS4TM3realSize;
numeric hDOSS4TM3 = 1;
while ( (hDOSS4TM3 * 3 + 1) < lastDOSS4TM3 - 1 )
{
hDOSS4TM3 = 3 * hDOSS4TM3 + 1;
}
while ( hDOSS4TM3 > 0 )
{
for i = hDOSS4TM3 - 1 to lastDOSS4TM3 # for each of the h sets of elements
{
numeric keyDOSS4TM3 = allValuesDosS4TM3[i];
numeric jDOSS4TM3 = i;
while (jDOSS4TM3 >= hDOSS4TM3 && allValuesDosS4TM3[jDOSS4TM3 - hDOSS4TM3] > keyDOSS4TM3)
{
allValuesDosS4TM3[jDOSS4TM3] = allValuesDosS4TM3[jDOSS4TM3 - hDOSS4TM3];
jDOSS4TM3 = jDOSS4TM3 - hDOSS4TM3;
}
allValuesDosS4TM3[jDOSS4TM3] = keyDOSS4TM3;
}
hDOSS4TM3 = floor(hDOSS4TM3/3);
}
numeric minValueDosS4TM3 = allValuesDosS4TM3[1];
numeric dn1000S4TM3 = 10000;
numeric actualCountDosS4TM3 = 0;
for i = 1 to dosS4TM3realSize
{
if (allValuesDosS4TM3[i] == minValueDosS4TM3)
{
actualCountDosS4TM3 = actualCountDosS4TM3 + 1;
if (actualCountDosS4TM3 >= DNminCALCS4TM3)
{
dn1000S4TM3 = minValueDosS4TM3;
go to dn1000S4TM3jumper;
}
}
else
{
minValueDosS4TM3 = allValuesDosS4TM3[i+1];
actualCountDosS4TM3 = 0;
}
}
dn1000S4TM3jumper:
if (dn1000S4TM3 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S4TM3 = allValuesDosS4TM3[1];
}
if (dn1000S4TM3 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S4TM3 = allValuesDosS4TM3[1];
}
printf("dn1000 Scene 4 TM3: %12f\n", dn1000S4TM3);
########################### Scene 4 - Dn1000 - Band 4
numeric lastDOSS4TM4 = dosS4TM4realSize;
numeric hDOSS4TM4 = 1;
while ( (hDOSS4TM4 * 3 + 1) < lastDOSS4TM4 - 1 )
{
hDOSS4TM4 = 3 * hDOSS4TM4 + 1;
}
while ( hDOSS4TM4 > 0 )
{
for i = hDOSS4TM4 - 1 to lastDOSS4TM4
{
numeric keyDOSS4TM4 = allValuesDosS4TM4[i];
numeric jDOSS4TM4 = i;
while (jDOSS4TM4 >= hDOSS4TM4 && allValuesDosS4TM4[jDOSS4TM4 - hDOSS4TM4] > keyDOSS4TM4)
{
allValuesDosS4TM4[jDOSS4TM4] = allValuesDosS4TM4[jDOSS4TM4 - hDOSS4TM4];
jDOSS4TM4 = jDOSS4TM4 - hDOSS4TM4;
}
allValuesDosS4TM4[jDOSS4TM4] = keyDOSS4TM4;
}
hDOSS4TM4 = floor(hDOSS4TM4/3);
}
numeric minValueDosS4TM4 = allValuesDosS4TM4[1];
numeric dn1000S4TM4 = 10000;
numeric actualCountDosS4TM4 = 0;
for i = 1 to dosS4TM4realSize
{
if (allValuesDosS4TM4[i] == minValueDosS4TM4)
{
actualCountDosS4TM4 = actualCountDosS4TM4 + 1;
if (actualCountDosS4TM4 >= DNminCALCS4TM4)
{
dn1000S4TM4 = minValueDosS4TM4;
go to dn1000S4TM4jumper;
}
}
else
{
minValueDosS4TM4 = allValuesDosS4TM4[i+1];
actualCountDosS4TM4 = 0;
}
}
dn1000S4TM4jumper:
if (dn1000S4TM4 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S4TM4 = allValuesDosS4TM4[1];
}
if (dn1000S4TM4 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S4TM4 = allValuesDosS4TM4[1];
}
printf("dn1000 Scene 4 TM4: %12f\n", dn1000S4TM4);
########################### Scene 4 - Dn1000 - Band 5
numeric lastDOSS4TM5 = dosS4TM5realSize;
numeric hDOSS4TM5 = 1;
while ( (hDOSS4TM5 * 3 + 1) < lastDOSS4TM5 - 1 )
{
hDOSS4TM5 = 3 * hDOSS4TM5 + 1;
}
while ( hDOSS4TM5 > 0 )
{
for i = hDOSS4TM5 - 1 to lastDOSS4TM5 # for each of the h sets of elements
{
numeric keyDOSS4TM5 = allValuesDosS4TM5[i];
numeric jDOSS4TM5 = i;
while (jDOSS4TM5 >= hDOSS4TM5 && allValuesDosS4TM5[jDOSS4TM5 - hDOSS4TM5] > keyDOSS4TM5)
{
allValuesDosS4TM5[jDOSS4TM5] = allValuesDosS4TM5[jDOSS4TM5 - hDOSS4TM5];
jDOSS4TM5 = jDOSS4TM5 - hDOSS4TM5;
}
allValuesDosS4TM5[jDOSS4TM5] = keyDOSS4TM5;
}
hDOSS4TM5 = floor(hDOSS4TM5/3);
}
numeric minValueDosS4TM5 = allValuesDosS4TM5[1];
numeric dn1000S4TM5 = 10000;
numeric actualCountDosS4TM5 = 0;
for i = 1 to dosS4TM5realSize
{
if (allValuesDosS4TM5[i] == minValueDosS4TM5)
{
actualCountDosS4TM5 = actualCountDosS4TM5 + 1;
if (actualCountDosS4TM5 >= DNminCALCS4TM5)
{
dn1000S4TM5 = minValueDosS4TM5;
go to dn1000S4TM5jumper;
}
}
else
{
minValueDosS4TM5 = allValuesDosS4TM5[i+1];
actualCountDosS4TM5 = 0;
}
}
dn1000S4TM5jumper:
if (dn1000S4TM5 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S4TM5 = allValuesDosS4TM5[1];
}
if (dn1000S4TM5 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S4TM5 = allValuesDosS4TM5[1];
}
printf("dn1000 Scene 4 TM5: %12f\n", dn1000S4TM5);
########################### Scene 4 - Dn1000 - Band 7
numeric lastDOSS4TM7 = dosS4TM7realSize;
numeric hDOSS4TM7 = 1;
while ( (hDOSS4TM7 * 3 + 1) < lastDOSS4TM7 - 1 )
{
hDOSS4TM7 = 3 * hDOSS4TM7 + 1;
}
while ( hDOSS4TM7 > 0 )
{
for i = hDOSS4TM7 - 1 to lastDOSS4TM7 # for each of the h sets of elements
{
numeric keyDOSS4TM7 = allValuesDosS4TM7[i];
numeric jDOSS4TM7 = i;
while (jDOSS4TM7 >= hDOSS4TM7 && allValuesDosS4TM7[jDOSS4TM7 - hDOSS4TM7] > keyDOSS4TM7)
{
allValuesDosS4TM7[jDOSS4TM7] = allValuesDosS4TM7[jDOSS4TM7 - hDOSS4TM7];
jDOSS4TM7 = jDOSS4TM7 - hDOSS4TM7;
}
allValuesDosS4TM7[jDOSS4TM7] = keyDOSS4TM7;
}
hDOSS4TM7 = floor(hDOSS4TM7/3);
}
numeric minValueDosS4TM7 = allValuesDosS4TM7[1];
numeric dn1000S4TM7 = 10000;
numeric actualCountDosS4TM7 = 0;
for i = 1 to dosS4TM7realSize
{
if (allValuesDosS4TM7[i] == minValueDosS4TM7)
{
actualCountDosS4TM7 = actualCountDosS4TM7 + 1;
if (actualCountDosS4TM7 >= DNminCALCS4TM7)
{
dn1000S4TM7 = minValueDosS4TM7;
go to dn1000S4TM7jumper;
}
}
else
{
minValueDosS4TM7 = allValuesDosS4TM7[i+1];
actualCountDosS4TM7 = 0;
}
}
dn1000S4TM7jumper:
if (dn1000S4TM7 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S4TM7 = allValuesDosS4TM7[1];
}
if (dn1000S4TM7 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S4TM7 = allValuesDosS4TM7[1];
}
printf("dn1000 Scene 4 TM7: %12f\n\n", dn1000S4TM7);
################################### Pathradiance Calculation #######################################
numeric pathRadS4TM1 = dn1000S4TM1 - (0.01 * (radsurfTMS4b1 * cos(s4zenith)) / pi);
numeric pathRadS4TM2 = dn1000S4TM2 - (0.01 * (radsurfTMS4b2 * cos(s4zenith)) / pi);
numeric pathRadS4TM3 = dn1000S4TM3 - (0.01 * (radsurfTMS4b3 * cos(s4zenith)) / pi);
numeric pathRadS4TM4 = dn1000S4TM4 - (0.01 * (radsurfTMS4b4 * cos(s4zenith)) / pi);
numeric pathRadS4TM5 = dn1000S4TM5 - (0.01 * (radsurfTMS4b5 * cos(s4zenith)) / pi);
numeric pathRadS4TM7 = dn1000S4TM7 - (0.01 * (radsurfTMS4b7 * cos(s4zenith)) / pi);
printf("Pathradiance Scene 4 Band 1: %12f\n", pathRadS4TM1);
printf("Pathradiance Scene 4 Band 2: %12f\n", pathRadS4TM2);
printf("Pathradiance Scene 4 Band 3: %12f\n", pathRadS4TM3);
printf("Pathradiance Scene 4 Band 4: %12f\n", pathRadS4TM4);
printf("Pathradiance Scene 4 Band 5: %12f\n", pathRadS4TM5);
printf("Pathradiance Scene 4 Band 7: %12f\n\n", pathRadS4TM7);
################################# Reflectance Calculation with athmo correction
for i = 1 to TMlins
{
for j = 1 to TMcols
{
valueS4TM1 = (pi * (RADS4TM1[i,j] - pathRadS4TM1)) / (radsurfTMS4b1 * cos(s4zenith));
if ( valueS4TM1 < 0 )
{
valueS4TM1 = 0;
countS4REFnullTM1 = countS4REFnullTM1 + 1;
}
else if ( valueS4TM1 > 1 )
{
valueS4TM1 = 1;
countS4REFoneTM1 = countS4REFoneTM1 + 1;
}
REFS4TM1[i,j] = valueS4TM1;
valueS4TM2 = (pi * (RADS4TM2[i,j] - pathRadS4TM2)) / (radsurfTMS4b2 * cos(s4zenith));
if ( valueS4TM2 < 0 )
{
valueS4TM2 = 0;
countS4REFnullTM2 = countS4REFnullTM2 + 1;
}
else if ( valueS4TM2 > 1 )
{
valueS4TM2 = 1;
countS4REFoneTM2 = countS4REFoneTM2 + 1;
}
REFS4TM2[i,j] = valueS4TM2;
valueS4TM3 = (pi * (RADS4TM3[i,j] - pathRadS4TM3)) / (radsurfTMS4b3 * cos(s4zenith));
if ( valueS4TM3 < 0 )
{
valueS4TM3 = 0;
countS4REFnullTM3 = countS4REFnullTM3 + 1;
}
else if ( valueS4TM3 > 1 )
{
valueS4TM3 = 1;
countS4REFoneTM3 = countS4REFoneTM3 + 1;
}
REFS4TM3[i,j] = valueS4TM3;
valueS4TM4 = (pi * (RADS4TM4[i,j] - pathRadS4TM4)) / (radsurfTMS4b4 * cos(s4zenith));
if ( valueS4TM4 < 0 )
{
valueS4TM4 = 0;
countS4REFnullTM4 = countS4REFnullTM4 + 1;
}
else if ( valueS4TM4 > 1 )
{
valueS4TM4 = 1;
countS4REFoneTM4 = countS4REFoneTM4 + 1;
}
REFS4TM4[i,j] = valueS4TM4;
valueS4TM5 = (pi * (RADS4TM5[i,j] - pathRadS4TM5)) / (radsurfTMS4b5 * cos(s4zenith));
if ( valueS4TM5 < 0 )
{
valueS4TM5 = 0;
countS4REFnullTM5 = countS4REFnullTM5 + 1;
}
else if ( valueS4TM5 > 1 )
{
valueS4TM5 = 1;
countS4REFoneTM5 = countS4REFoneTM5 + 1;
}
REFS4TM5[i,j] = valueS4TM5;
valueS4TM7 = (pi * (RADS4TM7[i,j] - pathRadS4TM7)) / (radsurfTMS4b7 * cos(s4zenith));
if ( valueS4TM7 < 0 )
{
valueS4TM7 = 0;
countS4REFnullTM7 = countS4REFnullTM7 + 1;
}
else if ( valueS4TM7 > 1 )
{
valueS4TM7 = 1;
countS4REFoneTM7 = countS4REFoneTM7 + 1;
}
REFS4TM7[i,j] = valueS4TM7;
}
}
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 4 Band 1: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS4REFnullTM1, countS4REFoneTM1);
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 4 Band 2: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS4REFnullTM2, countS4REFoneTM2);
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 4 Band 3: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS4REFnullTM3, countS4REFoneTM3);
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 4 Band 4: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS4REFnullTM4, countS4REFoneTM4);
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 4 Band 5: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS4REFnullTM5, countS4REFoneTM5);
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 4 Band 7: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n\n", countS4REFnullTM7, countS4REFoneTM7);
CreatePyramid(REFS4TM1);
CreatePyramid(REFS4TM2);
CreatePyramid(REFS4TM3);
CreatePyramid(REFS4TM4);
CreatePyramid(REFS4TM5);
CreatePyramid(REFS4TM7);
CreateHistogram(REFS4TM1);
CreateHistogram(REFS4TM2);
CreateHistogram(REFS4TM3);
CreateHistogram(REFS4TM4);
CreateHistogram(REFS4TM5);
CreateHistogram(REFS4TM7);
CloseRaster(RADS4TM1);
CloseRaster(RADS4TM2);
CloseRaster(RADS4TM3);
CloseRaster(RADS4TM4);
CloseRaster(RADS4TM5);
CloseRaster(RADS4TM7);
printf("Reflectance calculation for Scene 4 (TM) is done...\n\n\n");
}
else if ( sensors4 == 5 ) # MSS 5 - Calib Werte nach Price J.C.1987
{
raster REFS4MSS1, REFS4MSS2, REFS4MSS3, REFS4MSS4;
numeric radsurfMSS4b1, radsurfMSS4b2, radsurfMSS4b3, radsurfMSS4b4;
numeric valueS4MSS1, valueS4MSS2, valueS4MSS3, valueS4MSS4;
numeric dosS4MSS1nullValCount = 0;
numeric dosS4MSS2nullValCount = 0;
numeric dosS4MSS3nullValCount = 0;
numeric dosS4MSS4nullValCount = 0;
numeric dosS4MSS1realArrayCount = 1;
numeric dosS4MSS2realArrayCount = 1;
numeric dosS4MSS3realArrayCount = 1;
numeric dosS4MSS4realArrayCount = 1;
numeric countS4REFnullMSS1 = 0;
numeric countS4REFnullMSS2 = 0;
numeric countS4REFnullMSS3 = 0;
numeric countS4REFnullMSS4 = 0;
numeric countS4REFoneMSS1 = 0;
numeric countS4REFoneMSS2 = 0;
numeric countS4REFoneMSS3 = 0;
numeric countS4REFoneMSS4 = 0;
radsurfMSS4b1 = ESMSS51 / (dist4^2);
radsurfMSS4b2 = ESMSS52 / (dist4^2);
radsurfMSS4b3 = ESMSS53 / (dist4^2);
radsurfMSS4b4 = ESMSS54 / (dist4^2);
printf("Surface Radiance MSS Band 1 in W/m^2µm (Scene 4): %12f\n", radsurfMSS4b1);
printf("Surface Radiance MSS Band 2 in W/m^2µm (Scene 4): %12f\n", radsurfMSS4b2);
printf("Surface Radiance MSS Band 3 in W/m^2µm (Scene 4): %12f\n", radsurfMSS4b3);
printf("Surface Radiance MSS Band 4 in W/m^2µm (Scene 4): %12f\n\n", radsurfMSS4b4);
for i = 1 to MSSlins
{
for j = 1 to MSScols
{
if (IsNull(RADS4MSS1[i,j]) == 1)
{
dosS4MSS1nullValCount = dosS4MSS1nullValCount + 1;
}
if (IsNull(RADS4MSS2[i,j]) == 1)
{
dosS4MSS2nullValCount = dosS4MSS2nullValCount + 1;
}
if (IsNull(RADS4MSS3[i,j]) == 1)
{
dosS4MSS3nullValCount = dosS4MSS3nullValCount + 1;
}
if (IsNull(RADS4MSS4[i,j]) == 1)
{
dosS4MSS4nullValCount = dosS4MSS4nullValCount + 1;
}
}
}
numeric dosS4MSS1realSize = (MSSlins * MSScols) - dosS4MSS1nullValCount;
numeric dosS4MSS2realSize = (MSSlins * MSScols) - dosS4MSS2nullValCount;
numeric dosS4MSS3realSize = (MSSlins * MSScols) - dosS4MSS3nullValCount;
numeric dosS4MSS4realSize = (MSSlins * MSScols) - dosS4MSS4nullValCount;
array allValuesDosS4MSS1[dosS4MSS1realSize];
array allValuesDosS4MSS2[dosS4MSS2realSize];
array allValuesDosS4MSS3[dosS4MSS3realSize];
array allValuesDosS4MSS4[dosS4MSS4realSize];
numeric DNminCALCS4MSS1 = DNminCALC(Scene4Lin, Scene4Col, dosS4MSS1realSize);
numeric DNminCALCS4MSS2 = DNminCALC(Scene4Lin, Scene4Col, dosS4MSS2realSize);
numeric DNminCALCS4MSS3 = DNminCALC(Scene4Lin, Scene4Col, dosS4MSS3realSize);
numeric DNminCALCS4MSS4 = DNminCALC(Scene4Lin, Scene4Col, dosS4MSS4realSize);
for i = 1 to MSSlins
{
for j = 1 to MSScols
{
if (IsNull(RADS4MSS1[i,j]) == 0)
{
allValuesDosS4MSS1[dosS4MSS1realArrayCount] = RADS4MSS1[i,j];
dosS4MSS1realArrayCount = dosS4MSS1realArrayCount + 1;
}
if (IsNull(RADS4MSS2[i,j]) == 0)
{
allValuesDosS4MSS2[dosS4MSS2realArrayCount] = RADS4MSS2[i,j];
dosS4MSS2realArrayCount = dosS4MSS2realArrayCount + 1;
}
if (IsNull(RADS4MSS3[i,j]) == 0)
{
allValuesDosS4MSS3[dosS4MSS3realArrayCount] = RADS4MSS3[i,j];
dosS4MSS3realArrayCount = dosS4MSS3realArrayCount + 1;
}
if (IsNull(RADS4MSS4[i,j]) == 0)
{
allValuesDosS4MSS4[dosS4MSS4realArrayCount] = RADS4MSS4[i,j];
dosS4MSS4realArrayCount = dosS4MSS4realArrayCount + 1;
}
}
}
########################### Scene 4 - Dn1000 - Band 1
numeric lastDOSS4MSS1 = dosS4MSS1realSize;
numeric hDOSS4MSS1 = 1;
while ( (hDOSS4MSS1 * 3 + 1) < lastDOSS4MSS1 - 1 )
{
hDOSS4MSS1 = 3 * hDOSS4MSS1 + 1;
}
while ( hDOSS4MSS1 > 0 )
{
for i = hDOSS4MSS1 - 1 to lastDOSS4MSS1 # for each of the h sets of elements
{
numeric keyDOSS4MSS1 = allValuesDosS4MSS1[i];
numeric jDOSS4MSS1 = i;
while (jDOSS4MSS1 >= hDOSS4MSS1 && allValuesDosS4MSS1[jDOSS4MSS1 - hDOSS4MSS1] > keyDOSS4MSS1)
{
allValuesDosS4MSS1[jDOSS4MSS1] = allValuesDosS4MSS1[jDOSS4MSS1 - hDOSS4MSS1];
jDOSS4MSS1 = jDOSS4MSS1 - hDOSS4MSS1;
}
allValuesDosS4MSS1[jDOSS4MSS1] = keyDOSS4MSS1;
}
hDOSS4MSS1 = floor(hDOSS4MSS1/3);
}
numeric minValueDosS4MSS1 = allValuesDosS4MSS1[1];
numeric dn1000S4MSS1 = 10000;
numeric actualCountDosS4MSS1 = 0;
for i = 1 to dosS4MSS1realSize
{
if (allValuesDosS4MSS1[i] == minValueDosS4MSS1)
{
actualCountDosS4MSS1 = actualCountDosS4MSS1 + 1;
if (actualCountDosS4MSS1 >= DNminCALCS4MSS1)
{
dn1000S4MSS1 = minValueDosS4MSS1;
go to dn1000S4MSS1jumper;
}
}
else
{
minValueDosS4MSS1 = allValuesDosS4MSS1[i+1];
actualCountDosS4MSS1 = 0;
}
}
dn1000S4MSS1jumper:
if (dn1000S4MSS1 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S4MSS1 = allValuesDosS4MSS1[1];
}
if (dn1000S4MSS1 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S4MSS1 = allValuesDosS4MSS1[1];
}
printf("dn1000 Scene 4 MSS1: %12f\n", dn1000S4MSS1);
########################### Scene 4 - Dn1000 - Band 2
numeric lastDOSS4MSS2 = dosS4MSS1realSize;
numeric hDOSS4MSS2 = 1;
while ( (hDOSS4MSS2 * 3 + 1) < lastDOSS4MSS2 - 1 )
{
hDOSS4MSS2 = 3 * hDOSS4MSS2 + 1;
}
while ( hDOSS4MSS2 > 0 )
{
for i = hDOSS4MSS2 - 1 to lastDOSS4MSS2
{
numeric keyDOSS4MSS2 = allValuesDosS4MSS2[i];
numeric jDOSS4MSS2 = i;
while (jDOSS4MSS2 >= hDOSS4MSS2 && allValuesDosS4MSS2[jDOSS4MSS2 - hDOSS4MSS2] > keyDOSS4MSS2)
{
allValuesDosS4MSS2[jDOSS4MSS2] = allValuesDosS4MSS2[jDOSS4MSS2 - hDOSS4MSS2];
jDOSS4MSS2 = jDOSS4MSS2 - hDOSS4MSS2;
}
allValuesDosS4MSS2[jDOSS4MSS2] = keyDOSS4MSS2;
}
hDOSS4MSS2 = floor(hDOSS4MSS2/3);
}
numeric minValueDosS4MSS2 = allValuesDosS4MSS2[1];
numeric dn1000S4MSS2 = 10000;
numeric actualCountDosS4MSS2 = 0;
for i = 1 to dosS4MSS2realSize
{
if (allValuesDosS4MSS2[i] == minValueDosS4MSS2)
{
actualCountDosS4MSS2 = actualCountDosS4MSS2 + 1;
if (actualCountDosS4MSS2 >= DNminCALCS4MSS2)
{
dn1000S4MSS2 = minValueDosS4MSS2;
go to dn1000S4MSS2jumper;
}
}
else
{
minValueDosS4MSS2 = allValuesDosS4MSS2[i+1];
actualCountDosS4MSS2 = 0;
}
}
dn1000S4MSS2jumper:
if (dn1000S4MSS2 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S4MSS2 = allValuesDosS4MSS2[1];
}
if (dn1000S4MSS2 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S4MSS2 = allValuesDosS4MSS2[1];
}
printf("dn1000 Scene 4 MSS2: %12f\n", dn1000S4MSS2);
########################### Scene 4 - Dn1000 - Band 3
numeric lastDOSS4MSS3 = dosS4MSS3realSize;
numeric hDOSS4MSS3 = 1;
while ( (hDOSS4MSS3 * 3 + 1) < lastDOSS4MSS3 - 1 )
{
hDOSS4MSS3 = 3 * hDOSS4MSS3 + 1;
}
while ( hDOSS4MSS3 > 0 )
{
for i = hDOSS4MSS3 - 1 to lastDOSS4MSS3 # for each of the h sets of elements
{
numeric keyDOSS4MSS3 = allValuesDosS4MSS3[i];
numeric jDOSS4MSS3 = i;
while (jDOSS4MSS3 >= hDOSS4MSS3 && allValuesDosS4MSS3[jDOSS4MSS3 - hDOSS4MSS3] > keyDOSS4MSS3)
{
allValuesDosS4MSS3[jDOSS4MSS3] = allValuesDosS4MSS3[jDOSS4MSS3 - hDOSS4MSS3];
jDOSS4MSS3 = jDOSS4MSS3 - hDOSS4MSS3;
}
allValuesDosS4MSS3[jDOSS4MSS3] = keyDOSS4MSS3;
}
hDOSS4MSS3 = floor(hDOSS4MSS3/3);
}
numeric minValueDosS4MSS3 = allValuesDosS4MSS3[1];
numeric dn1000S4MSS3 = 10000;
numeric actualCountDosS4MSS3 = 0;
for i = 1 to dosS4MSS3realSize
{
if (allValuesDosS4MSS3[i] == minValueDosS4MSS3)
{
actualCountDosS4MSS3 = actualCountDosS4MSS3 + 1;
if (actualCountDosS4MSS3 >= DNminCALCS4MSS3)
{
dn1000S4MSS3 = minValueDosS4MSS3;
go to dn1000S4MSS3jumper;
}
}
else
{
minValueDosS4MSS3 = allValuesDosS4MSS3[i+1];
actualCountDosS4MSS3 = 0;
}
}
dn1000S4MSS3jumper:
if (dn1000S4MSS3 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S4MSS3 = allValuesDosS4MSS3[1];
}
if (dn1000S4MSS3 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S4MSS3 = allValuesDosS4MSS3[1];
}
printf("dn1000 Scene 4 MSS3: %12f\n", dn1000S4MSS3);
########################### Scene 4 - Dn1000 - Band 4
numeric lastDOSS4MSS4 = dosS4MSS4realSize;
numeric hDOSS4MSS4 = 1;
while ( (hDOSS4MSS4 * 3 + 1) < lastDOSS4MSS4 - 1 )
{
hDOSS4MSS4 = 3 * hDOSS4MSS4 + 1;
}
while ( hDOSS4MSS4 > 0 )
{
for i = hDOSS4MSS4 - 1 to lastDOSS4MSS4
{
numeric keyDOSS4MSS4 = allValuesDosS4MSS4[i];
numeric jDOSS4MSS4 = i;
while (jDOSS4MSS4 >= hDOSS4MSS4 && allValuesDosS4MSS4[jDOSS4MSS4 - hDOSS4MSS4] > keyDOSS4MSS4)
{
allValuesDosS4MSS4[jDOSS4MSS4] = allValuesDosS4MSS4[jDOSS4MSS4 - hDOSS4MSS4];
jDOSS4MSS4 = jDOSS4MSS4 - hDOSS4MSS4;
}
allValuesDosS4MSS4[jDOSS4MSS4] = keyDOSS4MSS4;
}
hDOSS4MSS4 = floor(hDOSS4MSS4/3);
}
numeric minValueDosS4MSS4 = allValuesDosS4MSS4[1];
numeric dn1000S4MSS4 = 10000;
numeric actualCountDosS4MSS4 = 0;
for i = 1 to dosS4MSS4realSize
{
if (allValuesDosS4MSS4[i] == minValueDosS4MSS4)
{
actualCountDosS4MSS4 = actualCountDosS4MSS4 + 1;
if (actualCountDosS4MSS4 >= DNminCALCS4MSS4)
{
dn1000S4MSS4 = minValueDosS4MSS4;
go to dn1000S4MSS4jumper;
}
}
else
{
minValueDosS4MSS4 = allValuesDosS4MSS4[i+1];
actualCountDosS4MSS4 = 0;
}
}
dn1000S4MSS4jumper:
if (dn1000S4MSS4 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S4MSS4 = allValuesDosS4MSS4[1];
}
if (dn1000S4MSS4 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S4MSS4 = allValuesDosS4MSS4[1];
}
printf("dn1000 Scene 4 MSS4: %12f\n", dn1000S4MSS4);
################################### Pathradiance Calculation #######################################
numeric pathRadS4MSS1 = dn1000S4MSS1 - (0.01 * (radsurfMSS4b1 * cos(s4zenith)) / pi);
numeric pathRadS4MSS2 = dn1000S4MSS2 - (0.01 * (radsurfMSS4b2 * cos(s4zenith)) / pi);
numeric pathRadS4MSS3 = dn1000S4MSS3 - (0.01 * (radsurfMSS4b3 * cos(s4zenith)) / pi);
numeric pathRadS4MSS4 = dn1000S4MSS4 - (0.01 * (radsurfMSS4b4 * cos(s4zenith)) / pi);
printf("Pathradiance Scene 4 Band 1: %12f\n", pathRadS4MSS1);
printf("Pathradiance Scene 4 Band 2: %12f\n", pathRadS4MSS2);
printf("Pathradiance Scene 4 Band 3: %12f\n", pathRadS4MSS3);
printf("Pathradiance Scene 4 Band 4: %12f\n\n", pathRadS4MSS4);
################################# Reflectance Calculation with athmo correction
for i = 1 to MSSlins
{
for j = 1 to MSScols
{
valueS4MSS1 = (pi * (RADS4MSS1[i,j] - pathRadS4MSS1)) / (radsurfMSS4b1 * cos(s4zenith));
if ( valueS4MSS1 < 0 )
{
valueS4MSS1 = 0;
countS4REFnullMSS1 = countS4REFnullMSS1 + 1;
}
else if ( valueS4MSS1 > 1 )
{
valueS4MSS1 = 1;
countS4REFoneMSS1 = countS4REFoneMSS1 + 1;
}
REFS4MSS1[i,j] = valueS4MSS1;
valueS4MSS2 = (pi * (RADS4MSS2[i,j] - pathRadS4MSS2)) / (radsurfMSS4b2 * cos(s4zenith));
if ( valueS4MSS2 < 0 )
{
valueS4MSS2 = 0;
countS4REFnullMSS2 = countS4REFnullMSS2 + 1;
}
else if ( valueS4MSS2 > 1 )
{
valueS4MSS2 = 1;
countS4REFoneMSS2 = countS4REFoneMSS2 + 1;
}
REFS4MSS2[i,j] = valueS4MSS2;
valueS4MSS3 = (pi * (RADS4MSS3[i,j] - pathRadS4MSS3)) / (radsurfMSS4b3 * cos(s4zenith));
if ( valueS4MSS3 < 0 )
{
valueS4MSS3 = 0;
countS4REFnullMSS3 = countS4REFnullMSS3 + 1;
}
else if ( valueS4MSS3 > 1 )
{
valueS4MSS3 = 1;
countS4REFoneMSS3 = countS4REFoneMSS3 + 1;
}
REFS4MSS3[i,j] = valueS4MSS3;
valueS4MSS4 = (pi * (RADS4MSS4[i,j] - pathRadS4MSS4)) / (radsurfMSS4b4 * cos(s4zenith));
if ( valueS4MSS4 < 0 )
{
valueS4MSS4 = 0;
countS4REFnullMSS4 = countS4REFnullMSS4 + 1;
}
else if ( valueS4MSS4 > 1 )
{
valueS4MSS4 = 1;
countS4REFoneMSS4 = countS4REFoneMSS4 + 1;
}
REFS4MSS4[i,j] = valueS4MSS4;
}
}
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 4 Band 1: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS4REFnullMSS1, countS4REFoneMSS1);
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 4 Band 2: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS4REFnullMSS2, countS4REFoneMSS2);
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 4 Band 3: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS4REFnullMSS3, countS4REFoneMSS3);
printf("Reflectance Computation (including DOS 1 Atmosphere Correction) Scene 4 Band 4: %5i pixels smaller zero set to zero and %5i pixels larger one set to one\n", countS4REFnullMSS4, countS4REFoneMSS4);
CreatePyramid(REFS4MSS1);
CreatePyramid(REFS4MSS2);
CreatePyramid(REFS4MSS3);
CreatePyramid(REFS4MSS4);
CreateHistogram(REFS4MSS1);
CreateHistogram(REFS4MSS2);
CreateHistogram(REFS4MSS3);
CreateHistogram(REFS4MSS4);
CloseRaster(RADS4MSS1);
CloseRaster(RADS4MSS2);
CloseRaster(RADS4MSS3);
CloseRaster(RADS4MSS4);
printf("Reflectance calculation for Scene 4 (MSS) is done...\n\n\n");
}
else if ( sensors4 == 4 ) # MSS 4
{
raster REFS4MSS1, REFS4MSS2, REFS4MSS3, REFS4MSS4;
numeric radsurfMSS4b1, radsurfMSS4b2, radsurfMSS4b3, radsurfMSS4b4;
numeric valueS4MSS1, valueS4MSS2, valueS4MSS3, valueS4MSS4;
numeric dosS4MSS1nullValCount = 0;
numeric dosS4MSS2nullValCount = 0;
numeric dosS4MSS3nullValCount = 0;
numeric dosS4MSS4nullValCount = 0;
numeric dosS4MSS1realArrayCount = 1;
numeric dosS4MSS2realArrayCount = 1;
numeric dosS4MSS3realArrayCount = 1;
numeric dosS4MSS4realArrayCount = 1;
numeric countS4REFnullMSS1 = 0;
numeric countS4REFnullMSS2 = 0;
numeric countS4REFnullMSS3 = 0;
numeric countS4REFnullMSS4 = 0;
numeric countS4REFoneMSS1 = 0;
numeric countS4REFoneMSS2 = 0;
numeric countS4REFoneMSS3 = 0;
numeric countS4REFoneMSS4 = 0;
radsurfMSS4b1 = ESMSS41 / (dist4^2);
radsurfMSS4b2 = ESMSS42 / (dist4^2);
radsurfMSS4b3 = ESMSS43 / (dist4^2);
radsurfMSS4b4 = ESMSS44 / (dist4^2);
printf("Surface Radiance MSS Band 1 in W/m^2µm (Scene 4): %12f\n", radsurfMSS4b1);
printf("Surface Radiance MSS Band 2 in W/m^2µm (Scene 4): %12f\n", radsurfMSS4b2);
printf("Surface Radiance MSS Band 3 in W/m^2µm (Scene 4): %12f\n", radsurfMSS4b3);
printf("Surface Radiance MSS Band 4 in W/m^2µm (Scene 4): %12f\n\n", radsurfMSS4b4);
for i = 1 to MSSlins
{
for j = 1 to MSScols
{
if (IsNull(RADS4MSS1[i,j]) == 1)
{
dosS4MSS1nullValCount = dosS4MSS1nullValCount + 1;
}
if (IsNull(RADS4MSS2[i,j]) == 1)
{
dosS4MSS2nullValCount = dosS4MSS2nullValCount + 1;
}
if (IsNull(RADS4MSS3[i,j]) == 1)
{
dosS4MSS3nullValCount = dosS4MSS3nullValCount + 1;
}
if (IsNull(RADS4MSS4[i,j]) == 1)
{
dosS4MSS4nullValCount = dosS4MSS4nullValCount + 1;
}
}
}
numeric dosS4MSS1realSize = (MSSlins * MSScols) - dosS4MSS1nullValCount;
numeric dosS4MSS2realSize = (MSSlins * MSScols) - dosS4MSS2nullValCount;
numeric dosS4MSS3realSize = (MSSlins * MSScols) - dosS4MSS3nullValCount;
numeric dosS4MSS4realSize = (MSSlins * MSScols) - dosS4MSS4nullValCount;
array allValuesDosS4MSS1[dosS4MSS1realSize];
array allValuesDosS4MSS2[dosS4MSS2realSize];
array allValuesDosS4MSS3[dosS4MSS3realSize];
array allValuesDosS4MSS4[dosS4MSS4realSize];
numeric DNminCALCS4MSS1 = DNminCALC(Scene4Lin, Scene4Col, dosS4MSS1realSize);
numeric DNminCALCS4MSS2 = DNminCALC(Scene4Lin, Scene4Col, dosS4MSS2realSize);
numeric DNminCALCS4MSS3 = DNminCALC(Scene4Lin, Scene4Col, dosS4MSS3realSize);
numeric DNminCALCS4MSS4 = DNminCALC(Scene4Lin, Scene4Col, dosS4MSS4realSize);
for i = 1 to MSSlins
{
for j = 1 to MSScols
{
if (IsNull(RADS4MSS1[i,j]) == 0)
{
allValuesDosS4MSS1[dosS4MSS1realArrayCount] = RADS4MSS1[i,j];
dosS4MSS1realArrayCount = dosS4MSS1realArrayCount + 1;
}
if (IsNull(RADS4MSS2[i,j]) == 0)
{
allValuesDosS4MSS2[dosS4MSS2realArrayCount] = RADS4MSS2[i,j];
dosS4MSS2realArrayCount = dosS4MSS2realArrayCount + 1;
}
if (IsNull(RADS4MSS3[i,j]) == 0)
{
allValuesDosS4MSS3[dosS4MSS3realArrayCount] = RADS4MSS3[i,j];
dosS4MSS3realArrayCount = dosS4MSS3realArrayCount + 1;
}
if (IsNull(RADS4MSS4[i,j]) == 0)
{
allValuesDosS4MSS4[dosS4MSS4realArrayCount] = RADS4MSS4[i,j];
dosS4MSS4realArrayCount = dosS4MSS4realArrayCount + 1;
}
}
}
########################### Scene 4 - Dn1000 - Band 1
numeric lastDOSS4MSS1 = dosS4MSS1realSize;
numeric hDOSS4MSS1 = 1;
while ( (hDOSS4MSS1 * 3 + 1) < lastDOSS4MSS1 - 1 )
{
hDOSS4MSS1 = 3 * hDOSS4MSS1 + 1;
}
while ( hDOSS4MSS1 > 0 )
{
for i = hDOSS4MSS1 - 1 to lastDOSS4MSS1 # for each of the h sets of elements
{
numeric keyDOSS4MSS1 = allValuesDosS4MSS1[i];
numeric jDOSS4MSS1 = i;
while (jDOSS4MSS1 >= hDOSS4MSS1 && allValuesDosS4MSS1[jDOSS4MSS1 - hDOSS4MSS1] > keyDOSS4MSS1)
{
allValuesDosS4MSS1[jDOSS4MSS1] = allValuesDosS4MSS1[jDOSS4MSS1 - hDOSS4MSS1];
jDOSS4MSS1 = jDOSS4MSS1 - hDOSS4MSS1;
}
allValuesDosS4MSS1[jDOSS4MSS1] = keyDOSS4MSS1;
}
hDOSS4MSS1 = floor(hDOSS4MSS1/3);
}
numeric minValueDosS4MSS1 = allValuesDosS4MSS1[1];
numeric dn1000S4MSS1 = 10000;
numeric actualCountDosS4MSS1 = 0;
for i = 1 to dosS4MSS1realSize
{
if (allValuesDosS4MSS1[i] == minValueDosS4MSS1)
{
actualCountDosS4MSS1 = actualCountDosS4MSS1 + 1;
if (actualCountDosS4MSS1 >= DNminCALCS4MSS1)
{
dn1000S4MSS1 = minValueDosS4MSS1;
go to dn1000S4MSS1jumper;
}
}
else
{
minValueDosS4MSS1 = allValuesDosS4MSS1[i+1];
actualCountDosS4MSS1 = 0;
}
}
dn1000S4MSS1jumper:
if (dn1000S4MSS1 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S4MSS1 = allValuesDosS4MSS1[1];
}
if (dn1000S4MSS1 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S4MSS1 = allValuesDosS4MSS1[1];
}
printf("dn1000 Scene 4 MSS1: %12f\n", dn1000S4MSS1);
########################### Scene 4 - Dn1000 - Band 2
numeric lastDOSS4MSS2 = dosS4MSS1realSize;
numeric hDOSS4MSS2 = 1;
while ( (hDOSS4MSS2 * 3 + 1) < lastDOSS4MSS2 - 1 )
{
hDOSS4MSS2 = 3 * hDOSS4MSS2 + 1;
}
while ( hDOSS4MSS2 > 0 )
{
for i = hDOSS4MSS2 - 1 to lastDOSS4MSS2
{
numeric keyDOSS4MSS2 = allValuesDosS4MSS2[i];
numeric jDOSS4MSS2 = i;
while (jDOSS4MSS2 >= hDOSS4MSS2 && allValuesDosS4MSS2[jDOSS4MSS2 - hDOSS4MSS2] > keyDOSS4MSS2)
{
allValuesDosS4MSS2[jDOSS4MSS2] = allValuesDosS4MSS2[jDOSS4MSS2 - hDOSS4MSS2];
jDOSS4MSS2 = jDOSS4MSS2 - hDOSS4MSS2;
}
allValuesDosS4MSS2[jDOSS4MSS2] = keyDOSS4MSS2;
}
hDOSS4MSS2 = floor(hDOSS4MSS2/3);
}
numeric minValueDosS4MSS2 = allValuesDosS4MSS2[1];
numeric dn1000S4MSS2 = 10000;
numeric actualCountDosS4MSS2 = 0;
for i = 1 to dosS4MSS2realSize
{
if (allValuesDosS4MSS2[i] == minValueDosS4MSS2)
{
actualCountDosS4MSS2 = actualCountDosS4MSS2 + 1;
if (actualCountDosS4MSS2 >= DNminCALCS4MSS2)
{
dn1000S4MSS2 = minValueDosS4MSS2;
go to dn1000S4MSS2jumper;
}
}
else
{
minValueDosS4MSS2 = allValuesDosS4MSS2[i+1];
actualCountDosS4MSS2 = 0;
}
}
dn1000S4MSS2jumper:
if (dn1000S4MSS2 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S4MSS2 = allValuesDosS4MSS2[1];
}
if (dn1000S4MSS2 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S4MSS2 = allValuesDosS4MSS2[1];
}
printf("dn1000 Scene 4 MSS2: %12f\n", dn1000S4MSS2);
########################### Scene 4 - Dn1000 - Band 3
numeric lastDOSS4MSS3 = dosS4MSS3realSize;
numeric hDOSS4MSS3 = 1;
while ( (hDOSS4MSS3 * 3 + 1) < lastDOSS4MSS3 - 1 )
{
hDOSS4MSS3 = 3 * hDOSS4MSS3 + 1;
}
while ( hDOSS4MSS3 > 0 )
{
for i = hDOSS4MSS3 - 1 to lastDOSS4MSS3 # for each of the h sets of elements
{
numeric keyDOSS4MSS3 = allValuesDosS4MSS3[i];
numeric jDOSS4MSS3 = i;
while (jDOSS4MSS3 >= hDOSS4MSS3 && allValuesDosS4MSS3[jDOSS4MSS3 - hDOSS4MSS3] > keyDOSS4MSS3)
{
allValuesDosS4MSS3[jDOSS4MSS3] = allValuesDosS4MSS3[jDOSS4MSS3 - hDOSS4MSS3];
jDOSS4MSS3 = jDOSS4MSS3 - hDOSS4MSS3;
}
allValuesDosS4MSS3[jDOSS4MSS3] = keyDOSS4MSS3;
}
hDOSS4MSS3 = floor(hDOSS4MSS3/3);
}
numeric minValueDosS4MSS3 = allValuesDosS4MSS3[1];
numeric dn1000S4MSS3 = 10000;
numeric actualCountDosS4MSS3 = 0;
for i = 1 to dosS4MSS3realSize
{
if (allValuesDosS4MSS3[i] == minValueDosS4MSS3)
{
actualCountDosS4MSS3 = actualCountDosS4MSS3 + 1;
if (actualCountDosS4MSS3 >= DNminCALCS4MSS3)
{
dn1000S4MSS3 = minValueDosS4MSS3;
go to dn1000S4MSS3jumper;
}
}
else
{
minValueDosS4MSS3 = allValuesDosS4MSS3[i+1];
actualCountDosS4MSS3 = 0;
}
}
dn1000S4MSS3jumper:
if (dn1000S4MSS3 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S4MSS3 = allValuesDosS4MSS3[1];
}
if (dn1000S4MSS3 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S4MSS3 = allValuesDosS4MSS3[1];
}
printf("dn1000 Scene 4 MSS3: %12f\n", dn1000S4MSS3);
########################### Scene 4 - Dn1000 - Band 4
numeric lastDOSS4MSS4 = dosS4MSS4realSize;
numeric hDOSS4MSS4 = 1;
while ( (hDOSS4MSS4 * 3 + 1) < lastDOSS4MSS4 - 1 )
{
hDOSS4MSS4 = 3 * hDOSS4MSS4 + 1;
}
while ( hDOSS4MSS4 > 0 )
{
for i = hDOSS4MSS4 - 1 to lastDOSS4MSS4
{
numeric keyDOSS4MSS4 = allValuesDosS4MSS4[i];
numeric jDOSS4MSS4 = i;
while (jDOSS4MSS4 >= hDOSS4MSS4 && allValuesDosS4MSS4[jDOSS4MSS4 - hDOSS4MSS4] > keyDOSS4MSS4)
{
allValuesDosS4MSS4[jDOSS4MSS4] = allValuesDosS4MSS4[jDOSS4MSS4 - hDOSS4MSS4];
jDOSS4MSS4 = jDOSS4MSS4 - hDOSS4MSS4;
}
allValuesDosS4MSS4[jDOSS4MSS4] = keyDOSS4MSS4;
}
hDOSS4MSS4 = floor(hDOSS4MSS4/3);
}
numeric minValueDosS4MSS4 = allValuesDosS4MSS4[1];
numeric dn1000S4MSS4 = 10000;
numeric actualCountDosS4MSS4 = 0;
for i = 1 to dosS4MSS4realSize
{
if (allValuesDosS4MSS4[i] == minValueDosS4MSS4)
{
actualCountDosS4MSS4 = actualCountDosS4MSS4 + 1;
if (actualCountDosS4MSS4 >= DNminCALCS4MSS4)
{
dn1000S4MSS4 = minValueDosS4MSS4;
go to dn1000S4MSS4jumper;
}
}
else
{
minValueDosS4MSS4 = allValuesDosS4MSS4[i+1];
actualCountDosS4MSS4 = 0;
}
}
dn1000S4MSS4jumper:
if (dn1000S4MSS4 < 0)
{
printf("dn1000 is negative, setting zero as default\n");
dn1000S4MSS4 = allValuesDosS4MSS4[1];
}
if (dn1000S4MSS4 == 10000)
{
printf("no dn1000 found, setting zero as default\n");
dn1000S4MSS4 = allValuesDosS4MSS4[1];
}
printf("dn1000 Scene 4 MSS4: %12f\n", dn1000S4MSS4);
################################### Pathradiance Calculation #######################################
numeric pathRadS4MSS1 = dn1000S4MSS1 - (0.01 * (radsurfMSS4b1 * cos(s4zenith)) / pi);
numeric pathRadS4MSS2 = dn1000S4MSS2 - (0.01 * (radsurfMSS4b2 * cos(s4zenith)) / pi);
numeric pathRadS4MSS3 = dn1000S4MSS3 - (0.01 * (radsurfMSS4b3 * cos(s4zenith)) / pi);
numeric pathRadS4MSS4 = dn1000S4MSS4 - (0.01 * (radsurfMSS4b4 * cos(s4zenith)) / pi);
printf("Pathradiance Scene 4 Band 1: %12f\n", pathRadS4MSS1);
printf("Pathradiance Scene 4 Band 2: %12f\n", pathRadS4MSS2);
printf("Pathradiance Scene 4 Band 3: %12f\n", pathRadS4MSS3);
printf("Pathradiance Scene 4 Band 4: %12f\n\n", pathRadS4MSS4);
################################# Reflectance Calculation with athmo correction
for i = 1 to MSSlins
{
for j = 1 to MSScols
{
valueS4MSS1 = (pi * (RADS4MSS1[i,j] - pathRadS4MSS1)) / (radsurfMSS4b1 * cos(s4zenith));
if ( valueS4MSS1 < 0 )
{
valueS4MSS1 = 0;
countS4REFnullMSS1 = countS4REFnullMSS1 + 1;
}
else if ( valueS4MSS1 > 1 )
{
valueS4MSS1 = 1;
countS4REFoneMSS1 = countS4REFoneMSS1 + 1;
}
REFS4MSS1[i,j] = valueS4MSS1;
valueS4MSS2 = (pi * (RADS4MSS2[i,j] - pathRadS4MSS2)) / (radsurfMSS4b2 * cos(s4zenith));
if ( valueS4MSS2 < 0 )
{
valueS4MSS2 = 0;
countS4REFnullMSS2 = countS4REFnullMSS2 + 1;
}
else if ( valueS4MSS2 > 1 )
{
valueS4MSS2 = 1;
countS4REFoneMSS2 = countS4REFoneMSS2 + 1;
}
REFS4MSS2[i,j] = valueS4MSS2;
valueS4MSS3 = (pi * (RADS4MSS3[i,j] - pathRadS4MSS3)) / (radsurfMSS4b3 * cos(s4zenith));
if ( valueS4MSS3 < 0 )
{
valueS4MSS3 = 0;
countS4REFnullMSS3 = countS4REFnullMSS3 + 1;
}
else if ( valueS4MSS3 > 1 )
{
valueS4MSS3 = 1;
countS4REFoneMSS3 = countS4REFoneMSS3 + 1;
}
REFS4MSS3[i,j] = valueS4MSS3;
valueS4MSS4 = (pi * (RADS4MSS4[i,j] - pathRadS4MSS4)) / (radsurfMSS4b4 * cos(s4zenith));
if ( valueS4MSS4 < 0 )
{
valueS4MSS4 = 0;
countS4REFnullMSS4 = countS4REFnullMSS4 + 1;
}
else if ( valueS4MSS4 > 1 )
{
valueS4MSS4 = 1;
countS4REFoneMSS4 = countS4REFoneMSS4 | |