diff --git a/Code/Radiometry/otbAtmosphericRadiativeTerms2.cxx b/Code/Radiometry/otbAtmosphericRadiativeTerms2.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..846b9e4a0917c6775d563023512e2899072a33cd
--- /dev/null
+++ b/Code/Radiometry/otbAtmosphericRadiativeTerms2.cxx
@@ -0,0 +1,610 @@
+/*=========================================================================
+
+ Program: ORFEO Toolbox
+ Language: C++
+ Date: $Date$
+ Version: $Revision$
+
+
+ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved.
+ See OTBCopyright.txt for details.
+
+
+ This software is distributed WITHOUT ANY WARRANTY; without even
+ the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ PURPOSE. See the above copyright notices for more information.
+
+=========================================================================*/
+
+#include "otbAtmosphericRadiativeTerms2.h"
+
+namespace otb
+{
+/************** AtmosphericRadiativeTermsSingleChannel2******************/
+/** Constructor */
+AtmosphericRadiativeTermsSingleChannel2::AtmosphericRadiativeTermsSingleChannel2() :
+ m_IntrinsicAtmosphericReflectance(0.04),
+ m_SphericalAlbedo(0.09),
+ m_TotalGaseousTransmission(0.95),
+ m_DownwardTransmittance(0.91),
+ m_UpwardTransmittance(0.94),
+ m_UpwardDiffuseTransmittance(0.09),
+ m_UpwardDirectTransmittance(0.85),
+ m_UpwardDiffuseTransmittanceForRayleigh(0.05),
+ m_UpwardDiffuseTransmittanceForAerosol(0.04),
+ m_WavelengthSpectralBand(0.0)
+{
+}
+
+/**PrintSelf method */
+void
+AtmosphericRadiativeTermsSingleChannel2
+::PrintSelf(std::ostream& os, itk::Indent indent) const
+{
+ Superclass::PrintSelf(os, indent);
+ os << indent << "Atmospheric Intrinsic Reflectance : " << m_IntrinsicAtmosphericReflectance << std::endl;
+ os << indent << "Atmosphere Shperical Albedo : " << m_SphericalAlbedo << std::endl;
+ os << indent << "Total Gaseous Transmission : " << m_TotalGaseousTransmission << std::endl;
+ os << indent << "Atmospher Downward Transmittance : " << m_DownwardTransmittance << std::endl;
+ os << indent << "Atmospher Upward Transmittance : " << m_UpwardTransmittance << std::endl;
+ os << indent << "Upward Diffuse Transmittance : " << m_UpwardDiffuseTransmittance << std::endl;
+ os << indent << "Upward Direct Transmittance : " << m_UpwardDirectTransmittance << std::endl;
+ os << indent << "Upward Diffuse Transmittance for Rayleigh: " << m_UpwardDiffuseTransmittanceForRayleigh << std::endl;
+ os << indent << "Upward Diffuse Transmittance for aerosols: " << m_UpwardDiffuseTransmittanceForAerosol << std::endl;
+}
+
+/***************** AtmosphericRadiativeTerms **************************/
+/**CONSTRUCTOR. */
+AtmosphericRadiativeTerms2
+::AtmosphericRadiativeTerms2()
+{
+ m_Values.clear();
+ m_IsInitialized = false;
+}
+
+void
+AtmosphericRadiativeTerms2
+::ValuesInitialization(unsigned int nbChannel)
+{
+ for (unsigned int j = 0; j < nbChannel; ++j)
+ {
+ ValueType temp = AtmosphericRadiativeTermsSingleChannel2::New();
+ m_Values.push_back(temp);
+ }
+ m_IsInitialized = true;
+}
+
+/** SET ACCESSORS WITH VECTORS. */
+void
+AtmosphericRadiativeTerms2
+::SetIntrinsicAtmosphericReflectances(const DataVectorType& vect)
+{
+ if (!m_IsInitialized)
+ {
+ this->ValuesInitialization(vect.size());
+
+ }
+ for (unsigned int nbChannel = 0; nbChannel < vect.size(); ++nbChannel)
+ {
+ m_Values[nbChannel]->SetIntrinsicAtmosphericReflectance(vect[nbChannel]);
+ }
+}
+void
+AtmosphericRadiativeTerms2
+::SetSphericalAlbedos(const DataVectorType& vect)
+{
+ if (!m_IsInitialized)
+ {
+ this->ValuesInitialization(vect.size());
+ }
+ for (unsigned int nbChannel = 0; nbChannel < vect.size(); ++nbChannel)
+ {
+ m_Values[nbChannel]->SetSphericalAlbedo(vect[nbChannel]);
+ }
+}
+void
+AtmosphericRadiativeTerms2
+::SetTotalGaseousTransmissions(const DataVectorType& vect)
+{
+ if (!m_IsInitialized)
+ {
+ this->ValuesInitialization(vect.size());
+ }
+ for (unsigned int nbChannel = 0; nbChannel < vect.size(); ++nbChannel)
+ {
+ m_Values[nbChannel]->SetTotalGaseousTransmission(vect[nbChannel]);
+ }
+
+}
+void
+AtmosphericRadiativeTerms2
+::SetDownwardTransmittances(const DataVectorType& vect)
+{
+ if (!m_IsInitialized)
+ {
+ this->ValuesInitialization(vect.size());
+ }
+ for (unsigned int nbChannel = 0; nbChannel < vect.size(); ++nbChannel)
+ {
+ m_Values[nbChannel]->SetDownwardTransmittance(vect[nbChannel]);
+ }
+}
+void
+AtmosphericRadiativeTerms2
+::SetUpwardTransmittances(const DataVectorType& vect)
+{
+ if (!m_IsInitialized)
+ {
+ this->ValuesInitialization(vect.size());
+ }
+ for (unsigned int nbChannel = 0; nbChannel < vect.size(); ++nbChannel)
+ {
+ m_Values[nbChannel]->SetUpwardTransmittance(vect[nbChannel]);
+ }
+}
+void
+AtmosphericRadiativeTerms2
+::SetUpwardDiffuseTransmittances(const DataVectorType& vect)
+{
+ if (!m_IsInitialized)
+ {
+ this->ValuesInitialization(vect.size());
+ }
+ for (unsigned int nbChannel = 0; nbChannel < vect.size(); ++nbChannel)
+ {
+ m_Values[nbChannel]->SetUpwardDiffuseTransmittance(vect[nbChannel]);
+ }
+}
+void
+AtmosphericRadiativeTerms2
+::SetUpwardDirectTransmittances(const DataVectorType& vect)
+{
+ if (!m_IsInitialized)
+ {
+ this->ValuesInitialization(vect.size());
+ }
+ for (unsigned int nbChannel = 0; nbChannel < vect.size(); ++nbChannel)
+ {
+ m_Values[nbChannel]->SetUpwardDirectTransmittance(vect[nbChannel]);
+ }
+}
+void
+AtmosphericRadiativeTerms2
+::SetUpwardDiffuseTransmittancesForRayleigh(const DataVectorType& vect)
+{
+ if (!m_IsInitialized)
+ {
+ this->ValuesInitialization(vect.size());
+ }
+ for (unsigned int nbChannel = 0; nbChannel < vect.size(); ++nbChannel)
+ {
+ m_Values[nbChannel]->SetUpwardDiffuseTransmittanceForRayleigh(vect[nbChannel]);
+ }
+}
+void
+AtmosphericRadiativeTerms2
+::SetUpwardDiffuseTransmittancesForAerosol(const DataVectorType& vect)
+{
+ if (!m_IsInitialized)
+ {
+ this->ValuesInitialization(vect.size());
+ }
+ for (unsigned int nbChannel = 0; nbChannel < vect.size(); ++nbChannel)
+ {
+ m_Values[nbChannel]->SetUpwardDiffuseTransmittanceForAerosol(vect[nbChannel]);
+ }
+}
+void
+AtmosphericRadiativeTerms2
+::SetWavelengthSpectralBand(const DataVectorType& vect)
+{
+ if (!m_IsInitialized)
+ {
+ this->ValuesInitialization(vect.size());
+ }
+ for (unsigned int nbChannel = 0; nbChannel < vect.size(); ++nbChannel)
+ {
+ m_Values[nbChannel]->SetWavelengthSpectralBand(vect[nbChannel]);
+ }
+}
+
+/** SET ACCESSORS WITH INDEX. */
+void
+AtmosphericRadiativeTerms2
+::SetValueByIndex(unsigned int id, const ValueType& val)
+{
+ if (m_IsInitialized)
+ {
+ if (m_Values.size() < id + 1)
+ {
+ while (id >= m_Values.size())
+ {
+ ValueType temp = AtmosphericRadiativeTermsSingleChannel2::New();
+ m_Values.push_back(temp);
+ }
+ }
+ m_Values[id] = val;
+ }
+ else
+ {
+ itkExceptionMacro(<< "Can't insert value before iniatilizing vector value..." << std::endl);
+ }
+}
+void
+AtmosphericRadiativeTerms2
+::SetIntrinsicAtmosphericReflectance(unsigned int id, const double& val)
+{
+ if (m_Values.size() < id + 1)
+ {
+ while (id >= m_Values.size())
+ {
+ ValueType temp = AtmosphericRadiativeTermsSingleChannel2::New();
+ m_Values.push_back(temp);
+ }
+ }
+ m_Values[id]->SetIntrinsicAtmosphericReflectance(val);
+}
+void
+AtmosphericRadiativeTerms2
+::SetSphericalAlbedo(unsigned int id, const double& val)
+{
+ if (m_Values.size() < id + 1)
+ {
+ while (id >= m_Values.size())
+ {
+ ValueType temp = AtmosphericRadiativeTermsSingleChannel2::New();
+ m_Values.push_back(temp);
+ }
+ }
+ m_Values[id]->SetSphericalAlbedo(val);
+}
+void
+AtmosphericRadiativeTerms2
+::SetTotalGaseousTransmission(unsigned int id, const double& val)
+{
+ if (m_Values.size() < id + 1)
+ {
+ while (id >= m_Values.size())
+ {
+ ValueType temp = AtmosphericRadiativeTermsSingleChannel2::New();
+ m_Values.push_back(temp);
+ }
+ }
+ m_Values[id]->SetTotalGaseousTransmission(val);
+}
+void
+AtmosphericRadiativeTerms2
+::SetDownwardTransmittance(unsigned int id, const double& val)
+{
+ if (m_Values.size() < id + 1)
+ {
+ while (id >= m_Values.size())
+ {
+ ValueType temp = AtmosphericRadiativeTermsSingleChannel2::New();
+ m_Values.push_back(temp);
+ }
+ }
+ m_Values[id]->SetDownwardTransmittance(val);
+}
+void
+AtmosphericRadiativeTerms2
+::SetUpwardTransmittance(unsigned int id, const double& val)
+{
+ if (m_Values.size() < id + 1)
+ {
+ while (id >= m_Values.size())
+ {
+ ValueType temp = AtmosphericRadiativeTermsSingleChannel2::New();
+ m_Values.push_back(temp);
+ }
+ }
+ m_Values[id]->SetUpwardTransmittance(val);
+}
+void
+AtmosphericRadiativeTerms2
+::SetUpwardDiffuseTransmittance(unsigned int id, const double& val)
+{
+ if (m_Values.size() < id + 1)
+ {
+ while (id >= m_Values.size())
+ {
+ ValueType temp = AtmosphericRadiativeTermsSingleChannel2::New();
+ m_Values.push_back(temp);
+ }
+ }
+ m_Values[id]->SetUpwardDiffuseTransmittance(val);
+}
+void
+AtmosphericRadiativeTerms2
+::SetUpwardDirectTransmittance(unsigned int id, const double& val)
+{
+ if (m_Values.size() < id + 1)
+ {
+ while (id >= m_Values.size())
+ {
+ ValueType temp = AtmosphericRadiativeTermsSingleChannel2::New();
+ m_Values.push_back(temp);
+ }
+ }
+ m_Values[id]->SetUpwardDirectTransmittance(val);
+}
+void
+AtmosphericRadiativeTerms2
+::SetUpwardDiffuseTransmittanceForRayleigh(unsigned int id, const double& val)
+{
+ if (m_Values.size() < id + 1)
+ {
+ while (id >= m_Values.size())
+ {
+ ValueType temp = AtmosphericRadiativeTermsSingleChannel2::New();
+ m_Values.push_back(temp);
+ }
+ }
+ m_Values[id]->SetUpwardDiffuseTransmittanceForRayleigh(val);
+}
+void
+AtmosphericRadiativeTerms2
+::SetUpwardDiffuseTransmittanceForAerosol(unsigned int id, const double& val)
+{
+ if (m_Values.size() < id + 1)
+ {
+ while (id >= m_Values.size())
+ {
+ ValueType temp = AtmosphericRadiativeTermsSingleChannel2::New();
+ m_Values.push_back(temp);
+ }
+ }
+ m_Values[id]->SetUpwardDiffuseTransmittanceForAerosol(val);
+}
+void
+AtmosphericRadiativeTerms2
+::SetWavelengthSpectralBand(unsigned int id, const double& val)
+{
+ if (m_Values.size() < id + 1)
+ {
+ while (id >= m_Values.size())
+ {
+ ValueType temp = AtmosphericRadiativeTermsSingleChannel2::New();
+ m_Values.push_back(temp);
+ }
+ }
+ m_Values[id]->SetWavelengthSpectralBand(val);
+}
+
+/** GET ACCESSORS WITH VECTORS. */
+AtmosphericRadiativeTerms2::DataVectorType
+AtmosphericRadiativeTerms2
+::GetIntrinsicAtmosphericReflectances() const
+{
+ DataVectorType vect(m_Values.size(), 0);
+ for (unsigned int nbChannel = 0; nbChannel < m_Values.size(); ++nbChannel)
+ {
+ vect[nbChannel] = m_Values[nbChannel]->GetIntrinsicAtmosphericReflectance();
+ }
+ return vect;
+}
+AtmosphericRadiativeTerms2::DataVectorType
+AtmosphericRadiativeTerms2
+::GetSphericalAlbedos() const
+{
+ DataVectorType vect(m_Values.size(), 0);
+ for (unsigned int nbChannel = 0; nbChannel < m_Values.size(); ++nbChannel)
+ {
+ vect[nbChannel] = m_Values[nbChannel]->GetSphericalAlbedo();
+ }
+ return vect;
+}
+AtmosphericRadiativeTerms2::DataVectorType
+AtmosphericRadiativeTerms2
+::GetTotalGaseousTransmissions() const
+{
+ DataVectorType vect(m_Values.size(), 0);
+ for (unsigned int nbChannel = 0; nbChannel < m_Values.size(); ++nbChannel)
+ {
+ vect[nbChannel] = m_Values[nbChannel]->GetTotalGaseousTransmission();
+ }
+ return vect;
+}
+AtmosphericRadiativeTerms2::DataVectorType
+AtmosphericRadiativeTerms2
+::GetDownwardTransmittances() const
+{
+ DataVectorType vect(m_Values.size(), 0);
+ for (unsigned int nbChannel = 0; nbChannel < m_Values.size(); ++nbChannel)
+ {
+ vect[nbChannel] = m_Values[nbChannel]->GetDownwardTransmittance();
+ }
+ return vect;
+}
+AtmosphericRadiativeTerms2::DataVectorType
+AtmosphericRadiativeTerms2
+::GetUpwardTransmittances() const
+{
+ DataVectorType vect(m_Values.size(), 0);
+ for (unsigned int nbChannel = 0; nbChannel < m_Values.size(); ++nbChannel)
+ {
+ vect[nbChannel] = m_Values[nbChannel]->GetUpwardTransmittance();
+ }
+ return vect;
+}
+AtmosphericRadiativeTerms2::DataVectorType
+AtmosphericRadiativeTerms2
+::GetUpwardDiffuseTransmittances() const
+{
+ DataVectorType vect(m_Values.size(), 0);
+ for (unsigned int nbChannel = 0; nbChannel < m_Values.size(); ++nbChannel)
+ {
+ vect[nbChannel] = m_Values[nbChannel]->GetUpwardDiffuseTransmittance();
+ }
+ return vect;
+}
+AtmosphericRadiativeTerms2::DataVectorType
+AtmosphericRadiativeTerms2
+::GetUpwardDirectTransmittances() const
+{
+ DataVectorType vect(m_Values.size(), 0);
+ for (unsigned int nbChannel = 0; nbChannel < m_Values.size(); ++nbChannel)
+ {
+ vect[nbChannel] = m_Values[nbChannel]->GetUpwardDirectTransmittance();
+ }
+ return vect;
+}
+AtmosphericRadiativeTerms2::DataVectorType
+AtmosphericRadiativeTerms2
+::GetUpwardDiffuseTransmittancesForRayleigh() const
+{
+ DataVectorType vect(m_Values.size(), 0);
+ for (unsigned int nbChannel = 0; nbChannel < m_Values.size(); ++nbChannel)
+ {
+ vect[nbChannel] = m_Values[nbChannel]->GetUpwardDiffuseTransmittanceForRayleigh();
+ }
+ return vect;
+}
+AtmosphericRadiativeTerms2::DataVectorType
+AtmosphericRadiativeTerms2
+::GetUpwardDiffuseTransmittancesForAerosol() const
+{
+ DataVectorType vect(m_Values.size(), 0);
+ for (unsigned int nbChannel = 0; nbChannel < m_Values.size(); ++nbChannel)
+ {
+ vect[nbChannel] = m_Values[nbChannel]->GetUpwardDiffuseTransmittanceForAerosol();
+ }
+ return vect;
+}
+AtmosphericRadiativeTerms2::DataVectorType
+AtmosphericRadiativeTerms2
+::GetWavelengthSpectralBand() const
+{
+ DataVectorType vect(m_Values.size(), 0);
+ for (unsigned int nbChannel = 0; nbChannel < m_Values.size(); ++nbChannel)
+ {
+ vect[nbChannel] = m_Values[nbChannel]->GetWavelengthSpectralBand();
+ }
+ return vect;
+}
+
+/** GET ACCESSORS WITH INDEX. */
+double
+AtmosphericRadiativeTerms2
+::GetIntrinsicAtmosphericReflectance(unsigned int id) const
+{
+ if (id >= m_Values.size()) itkExceptionMacro(<< " band index out of bounds: " << id
+ << " for " << m_Values.size() << " bands.");
+ return m_Values[id]->GetIntrinsicAtmosphericReflectance();
+}
+double
+AtmosphericRadiativeTerms2
+::GetSphericalAlbedo(unsigned int id) const
+{
+ if (id >= m_Values.size()) itkExceptionMacro(<< " band index out of bounds: " << id
+ << " for " << m_Values.size() << " bands.");
+ return m_Values[id]->GetSphericalAlbedo();
+}
+double
+AtmosphericRadiativeTerms2
+::GetTotalGaseousTransmission(unsigned int id) const
+{
+ if (id >= m_Values.size()) itkExceptionMacro(<< " band index out of bounds: " << id
+ << " for " << m_Values.size() << " bands.");
+ return m_Values[id]->GetTotalGaseousTransmission();
+}
+double
+AtmosphericRadiativeTerms2
+::GetDownwardTransmittance(unsigned int id) const
+{
+ if (id >= m_Values.size()) itkExceptionMacro(<< " band index out of bounds: " << id
+ << " for " << m_Values.size() << " bands.");
+ return m_Values[id]->GetDownwardTransmittance();
+}
+double
+AtmosphericRadiativeTerms2
+::GetUpwardTransmittance(unsigned int id) const
+{
+ if (id >= m_Values.size()) itkExceptionMacro(<< " band index out of bounds: " << id
+ << " for " << m_Values.size() << " bands.");
+ return m_Values[id]->GetUpwardTransmittance();
+}
+double
+AtmosphericRadiativeTerms2
+::GetUpwardDiffuseTransmittance(unsigned int id) const
+{
+ if (id >= m_Values.size()) itkExceptionMacro(<< " band index out of bounds: " << id
+ << " for " << m_Values.size() << " bands.");
+ return m_Values[id]->GetUpwardDiffuseTransmittance();
+}
+double
+AtmosphericRadiativeTerms2
+::GetUpwardDirectTransmittance(unsigned int id) const
+{
+ if (id >= m_Values.size()) itkExceptionMacro(<< " band index out of bounds: " << id
+ << " for " << m_Values.size() << " bands.");
+ return m_Values[id]->GetUpwardDirectTransmittance();
+}
+double
+AtmosphericRadiativeTerms2
+::GetUpwardDiffuseTransmittanceForRayleigh(unsigned int id) const
+{
+ if (id >= m_Values.size()) itkExceptionMacro(<< " band index out of bounds: " << id
+ << " for " << m_Values.size() << " bands.");
+ return m_Values[id]->GetUpwardDiffuseTransmittanceForRayleigh();
+}
+double
+AtmosphericRadiativeTerms2
+::GetUpwardDiffuseTransmittanceForAerosol(unsigned int id) const
+{
+ if (id >= m_Values.size()) itkExceptionMacro(<< " band index out of bounds: " << id
+ << " for " << m_Values.size() << " bands.");
+ return m_Values[id]->GetUpwardDiffuseTransmittanceForAerosol();
+}
+double
+AtmosphericRadiativeTerms2
+::GetWavelengthSpectralBand(unsigned int id) const
+{
+ if (id >= m_Values.size()) itkExceptionMacro(<< " band index out of bounds: " << id
+ << " for " << m_Values.size() << " bands.");
+ return m_Values[id]->GetWavelengthSpectralBand();
+}
+
+const AtmosphericRadiativeTerms2::ValueType
+AtmosphericRadiativeTerms2
+::GetValueByIndex(unsigned int id) const
+{
+ if (id >= m_Values.size()) itkExceptionMacro(<< " band index out of bounds: " << id
+ << " for " << m_Values.size() << " bands.");
+ return m_Values[id];
+}
+
+/**PrintSelf method */
+void
+AtmosphericRadiativeTerms2
+::PrintSelf(std::ostream& os, itk::Indent indent) const
+{
+ os << m_Values.size() << " channels:" << std::endl;
+ for (unsigned int i = 0; i < m_Values.size(); ++i)
+ {
+ os << "Channel " << i << " : " << std::endl;
+ //ValueType::(os, indent);
+ os << indent << "Intrinsic Atmospheric Reflectance : "
+ << m_Values[i]->GetIntrinsicAtmosphericReflectance() << std::endl;
+ os << indent << "Shperical Albedo of the Atmosphere : "
+ << m_Values[i]->GetSphericalAlbedo() << std::endl;
+ os << indent << "Total Gaseous Transmission : "
+ << m_Values[i]->GetTotalGaseousTransmission() << std::endl;
+ os << indent << "Atmosphere Downward Transmittance : "
+ << m_Values[i]->GetDownwardTransmittance() << std::endl;
+ os << indent << "Atmosphere Upward Transmittance : "
+ << m_Values[i]->GetUpwardTransmittance() << std::endl;
+ os << indent << "Upward Diffuse Transmittance : "
+ << m_Values[i]->GetUpwardDiffuseTransmittance() << std::endl;
+ os << indent << "Upward Direct Transmittance : "
+ << m_Values[i]->GetUpwardDirectTransmittance() << std::endl;
+ os << indent << "Rayleigh Upward Diffuse Transmittance : "
+ << m_Values[i]->GetUpwardDiffuseTransmittanceForRayleigh() << std::endl;
+ os << indent << "Aerosols Upward Diffuse Transmittance : "
+ << m_Values[i]->GetUpwardDiffuseTransmittanceForAerosol() << std::endl;
+ os << indent << "Wavelength : "
+ << m_Values[i]->GetWavelengthSpectralBand() << std::endl;
+ }
+}
+
+} // end namespace otb
diff --git a/Code/Radiometry/otbAtmosphericRadiativeTerms2.h b/Code/Radiometry/otbAtmosphericRadiativeTerms2.h
new file mode 100644
index 0000000000000000000000000000000000000000..69227c57dcbb3c6f0fa51a7ab87734dcec316457
--- /dev/null
+++ b/Code/Radiometry/otbAtmosphericRadiativeTerms2.h
@@ -0,0 +1,276 @@
+/*=========================================================================
+
+ Program: ORFEO Toolbox
+ Language: C++
+ Date: $Date$
+ Version: $Revision$
+
+
+ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved.
+ See OTBCopyright.txt for details.
+
+
+ This software is distributed WITHOUT ANY WARRANTY; without even
+ the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ PURPOSE. See the above copyright notices for more information.
+
+=========================================================================*/
+#ifndef __otbAtmosphericRadiativeTerms_h
+#define __otbAtmosphericRadiativeTerms_h
+
+#include "itkObject.h"
+#include "itkObjectFactory.h"
+#include "itkMacro.h"
+#include <vector>
+
+namespace otb
+{
+
+/** \class AtmosphericRadiativeTermsSingleChannel
+ * \brief This class contains all atmospheric radiative terms for one channel.
+ *
+ * Each value can be deducted from the atmospheric correction parameters (using 6S)
+ * or directly set by the user.
+ *
+ * \ingroup Radiometry
+ */
+
+class ITK_EXPORT AtmosphericRadiativeTermsSingleChannel2 : public itk::Object
+{
+public:
+ /** Standard typedefs */
+ typedef AtmosphericRadiativeTermsSingleChannel2 Self;
+ typedef itk::Object Superclass;
+ typedef itk::SmartPointer<Self> Pointer;
+ typedef itk::SmartPointer<const Self> ConstPointer;
+
+ /** Type macro */
+ itkTypeMacro(AtmosphericRadiativeTermsSingleChannel2, Object);
+
+ /** Creation through object factory macro */
+ itkNewMacro(Self);
+
+ /**
+ * Set/Get the intrinsic atmospheric reflectance.
+ */
+ itkSetMacro(IntrinsicAtmosphericReflectance, double);
+ itkGetMacro(IntrinsicAtmosphericReflectance, double);
+
+ /**
+ * Set/Get the spherical albedo of the atmosphere.
+ */
+ itkSetMacro(SphericalAlbedo, double);
+ itkGetMacro(SphericalAlbedo, double);
+ /**
+ * Set/Get the total gaseous transmission.
+ */
+ itkSetMacro(TotalGaseousTransmission, double);
+ itkGetMacro(TotalGaseousTransmission, double);
+
+ /**
+ * Set/Get the downward transmittance of the atmosphere.
+ */
+ itkSetMacro(DownwardTransmittance, double);
+ itkGetMacro(DownwardTransmittance, double);
+
+ /**
+ * Set/Get the upward transmittance of the atmosphere.
+ */
+ itkSetMacro(UpwardTransmittance, double);
+ itkGetMacro(UpwardTransmittance, double);
+
+ /**
+ * Set/Get the upward diffuse transmittance
+ */
+ itkSetMacro(UpwardDiffuseTransmittance, double);
+ itkGetMacro(UpwardDiffuseTransmittance, double);
+
+ /**
+ * Set/Get the upward direct transmittance
+ */
+ itkSetMacro(UpwardDirectTransmittance, double);
+ itkGetMacro(UpwardDirectTransmittance, double);
+
+ /**
+ * Set/Get the upward diffuse transmittance for rayleigh
+ */
+ itkSetMacro(UpwardDiffuseTransmittanceForRayleigh, double);
+ itkGetMacro(UpwardDiffuseTransmittanceForRayleigh, double);
+
+ /**
+ * Set/Get the upward diffuse transmittance for aerosols
+ */
+ itkSetMacro(UpwardDiffuseTransmittanceForAerosol, double);
+ itkGetMacro(UpwardDiffuseTransmittanceForAerosol, double);
+
+ /**
+ * Set/Get the wavelength
+ */
+ itkSetMacro(WavelengthSpectralBand, double);
+ itkGetMacro(WavelengthSpectralBand, double);
+
+protected:
+ /** Constructor */
+ AtmosphericRadiativeTermsSingleChannel2();
+ /** Destructor */
+ ~AtmosphericRadiativeTermsSingleChannel2() {}
+ /**PrintSelf method */
+ void PrintSelf(std::ostream& os, itk::Indent indent) const;
+
+private:
+ AtmosphericRadiativeTermsSingleChannel2(const Self &); //purposely not implemented
+ void operator =(const Self&); //purposely not implemented
+
+ /** The intrinsic atmospheric reflectance. */
+ double m_IntrinsicAtmosphericReflectance;
+
+ /** The spherical albedo of the atmosphere.*/
+ double m_SphericalAlbedo;
+
+ /**The total gaseous transmission (for all species). */
+ double m_TotalGaseousTransmission;
+
+ /** The downward transmittance. */
+ double m_DownwardTransmittance;
+
+ /** The upward transmittance. */
+ double m_UpwardTransmittance;
+
+ /** The upward diffuse transmittance. */
+ double m_UpwardDiffuseTransmittance;
+
+ /** The upward direct transmittance. */
+ double m_UpwardDirectTransmittance;
+
+ /** The upward diffuse transmittance for rayleigh. */
+ double m_UpwardDiffuseTransmittanceForRayleigh;
+
+ /** The upward diffuse transmittance for aerosols. */
+ double m_UpwardDiffuseTransmittanceForAerosol;
+
+ /** Wavelength associated with the data: not used in the computation, for reference only */
+ double m_WavelengthSpectralBand;
+};
+
+/** \class AtmosphericRadiativeTerms
+ * \brief This class is a vector of AtmosphericRadiativeTermsSingleChannel,
+ * it contains all atmospheric radiative terms for each studied channel.
+ *
+ * \ingroup AtmosphericRadiativeTermSingleChannel
+ * \ingroup Radiometry
+ */
+
+class ITK_EXPORT AtmosphericRadiativeTerms2 : public itk::Object
+{
+public:
+ /** Standard typedefs */
+ typedef AtmosphericRadiativeTerms2 Self;
+ typedef itk::Object Superclass;
+ typedef itk::SmartPointer<Self> Pointer;
+ typedef itk::SmartPointer<const Self> ConstPointer;
+
+ /** Type macro */
+ itkTypeMacro(AtmosphericRadiativeTerms2, Object);
+
+ /** Creation through object factory macro */
+ itkNewMacro(Self);
+
+ typedef AtmosphericRadiativeTermsSingleChannel2::Pointer ValueType;
+ typedef std::vector<ValueType> VectorValueType;
+ typedef std::vector<double> DataVectorType;
+ /**
+ * Set/Get the values.
+ */
+ void SetValues(const VectorValueType& val)
+ {
+ m_Values = val;
+ this->Modified();
+ }
+ VectorValueType& GetValues()
+ {
+ return m_Values;
+ }
+ const VectorValueType& GetValues() const
+ {
+ return m_Values;
+ }
+
+ /** Set/Get the data classified by channel. */
+ /** Set methods with vectors. */
+ void SetIntrinsicAtmosphericReflectances(const DataVectorType& vect);
+ void SetSphericalAlbedos(const DataVectorType& vect);
+ void SetTotalGaseousTransmissions(const DataVectorType& vect);
+ void SetDownwardTransmittances(const DataVectorType& vect);
+ void SetUpwardTransmittances(const DataVectorType& vect);
+
+ void SetUpwardDiffuseTransmittances(const DataVectorType& vect);
+ void SetUpwardDirectTransmittances(const DataVectorType& vect);
+ void SetUpwardDiffuseTransmittancesForRayleigh(const DataVectorType& vect);
+ void SetUpwardDiffuseTransmittancesForAerosol(const DataVectorType& vect);
+ void SetWavelengthSpectralBand(const DataVectorType& vect);
+
+ /** Set methods with index. */
+ void SetValueByIndex(unsigned int id, const ValueType& val);
+ void SetIntrinsicAtmosphericReflectance(unsigned int id, const double& val);
+ void SetSphericalAlbedo(unsigned int id, const double& val);
+ void SetTotalGaseousTransmission(unsigned int id, const double& val);
+ void SetDownwardTransmittance(unsigned int id, const double& val);
+ void SetUpwardTransmittance(unsigned int id, const double& val);
+
+ void SetUpwardDiffuseTransmittance(unsigned int id, const double& val);
+ void SetUpwardDirectTransmittance(unsigned int id, const double& val);
+ void SetUpwardDiffuseTransmittanceForRayleigh(unsigned int id, const double& val);
+ void SetUpwardDiffuseTransmittanceForAerosol(unsigned int id, const double& val);
+ void SetWavelengthSpectralBand(unsigned int id, const double& val);
+
+ /** Get methods with vectors. */
+ DataVectorType GetIntrinsicAtmosphericReflectances() const;
+ DataVectorType GetSphericalAlbedos() const;
+ DataVectorType GetTotalGaseousTransmissions() const;
+ DataVectorType GetDownwardTransmittances() const;
+ DataVectorType GetUpwardTransmittances() const;
+
+ DataVectorType GetUpwardDiffuseTransmittances() const;
+ DataVectorType GetUpwardDirectTransmittances() const;
+ DataVectorType GetUpwardDiffuseTransmittancesForRayleigh() const;
+ DataVectorType GetUpwardDiffuseTransmittancesForAerosol() const;
+ DataVectorType GetWavelengthSpectralBand() const;
+
+ /** Get methods with index. */
+ double GetIntrinsicAtmosphericReflectance(unsigned int id) const;
+ double GetSphericalAlbedo(unsigned int id) const;
+ double GetTotalGaseousTransmission(unsigned int id) const;
+ double GetDownwardTransmittance(unsigned int id) const;
+ double GetUpwardTransmittance(unsigned int id) const;
+ double GetUpwardDiffuseTransmittance(unsigned int id) const;
+ double GetUpwardDirectTransmittance(unsigned int id) const;
+ double GetUpwardDiffuseTransmittanceForRayleigh(unsigned int id) const;
+ double GetUpwardDiffuseTransmittanceForAerosol(unsigned int id) const;
+ double GetWavelengthSpectralBand(unsigned int id) const;
+
+ const ValueType GetValueByIndex(unsigned int id) const;
+
+ /** Initialization method.*/
+ void ValuesInitialization(unsigned int nbChannel);
+
+protected:
+ /** Constructor */
+ AtmosphericRadiativeTerms2();
+ /** Destructor */
+ ~AtmosphericRadiativeTerms2() {}
+ /**PrintSelf method */
+ void PrintSelf(std::ostream& os, itk::Indent indent) const;
+
+private:
+ AtmosphericRadiativeTerms2(const Self &); //purposely not implemented
+ void operator =(const Self&); //purposely not implemented
+
+ /** The vector containing each channel information. */
+ VectorValueType m_Values;
+ /** Boolean to know if m_Values has been initialized. */
+ bool m_IsInitialized;
+};
+
+} // end namespace otb
+
+#endif
\ No newline at end of file
diff --git a/Code/Radiometry/otbRadiometryCorrectionParametersToAtmosphericRadiativeTerms.h b/Code/Radiometry/otbRadiometryCorrectionParametersToAtmosphericRadiativeTerms.h
new file mode 100644
index 0000000000000000000000000000000000000000..3ba45922f405a6cb1953184f2b99fd545ee4d8fa
--- /dev/null
+++ b/Code/Radiometry/otbRadiometryCorrectionParametersToAtmosphericRadiativeTerms.h
@@ -0,0 +1,112 @@
+/*=========================================================================
+
+ Program: ORFEO Toolbox
+ Language: C++
+ Date: $Date$
+ Version: $Revision$
+
+
+ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved.
+ See OTBCopyright.txt for details.
+
+
+ This software is distributed WITHOUT ANY WARRANTY; without even
+ the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ PURPOSE. See the above copyright notices for more information.
+
+=========================================================================*/
+#ifndef __otbRadiometryCorrectionParametersToAtmosphericRadiativeTerms_h
+#define __otbRadiometryCorrectionParametersToAtmosphericRadiativeTerms_h
+
+#include "otbAtmosphericRadiativeTerms2.h"
+#include "otbAtmosphericCorrectionParameters.h"
+#include "otbSIXSTraits.h"
+
+namespace otb
+{
+
+/** \class RadiometryCorrectionParametersToAtmosphericRadiativeTerms
+ * \brief TODO.
+ *
+ * TODO
+ * \ingroup Radiometry
+ *
+ */
+ class ITK_EXPORT RadiometryCorrectionParametersToAtmosphericRadiativeTerms
+ {
+ public:
+
+ /** Call the varSol function*/
+ static AtmosphericRadiativeTerms2::Pointer Compute(AtmosphericCorrectionParameters* paramIn)
+ {
+ AtmosphericRadiativeTerms2::Pointer radTermsOut = AtmosphericRadiativeTerms2::New();
+
+ typedef AtmosphericCorrectionParameters::WavelengthSpectralBandVectorType WavelengthSpectralBandVectorType;
+ WavelengthSpectralBandVectorType WavelengthSpectralBandVector = paramIn->GetWavelengthSpectralBand();
+ unsigned int NbBand = WavelengthSpectralBandVector->Size();
+
+ radTermsOut->ValuesInitialization(NbBand);
+
+ double atmosphericReflectance(0.);
+ double atmosphericSphericalAlbedo(0.);
+ double totalGaseousTransmission(0.);
+ double downwardTransmittance(0.);
+ double upwardTransmittance(0.);
+ double upwardDiffuseTransmittance(0.);
+ double upwardDirectTransmittance(0.);
+ double upwardDiffuseTransmittanceForRayleigh(0.);
+ double upwardDiffuseTransmittanceForAerosol(0.);
+
+ for (unsigned int i = 0; i < NbBand; ++i)
+ {
+ atmosphericReflectance = 0.;
+ atmosphericSphericalAlbedo = 0.;
+ totalGaseousTransmission = 0.;
+ downwardTransmittance = 0.;
+ upwardTransmittance = 0.;
+ upwardDiffuseTransmittance = 0.;
+ upwardDirectTransmittance = 0.;
+ upwardDiffuseTransmittanceForRayleigh = 0.;
+ upwardDiffuseTransmittanceForAerosol = 0.;
+ SIXSTraits::ComputeAtmosphericParameters(
+ paramIn->GetSolarZenithalAngle(), /** The Solar zenithal angle */
+ paramIn->GetSolarAzimutalAngle(), /** The Solar azimutal angle */
+ paramIn->GetViewingZenithalAngle(), /** The Viewing zenithal angle */
+ paramIn->GetViewingAzimutalAngle(), /** The Viewing azimutal angle */
+ paramIn->GetMonth(), /** The Month */
+ paramIn->GetDay(), /** The Day (in the month) */
+ paramIn->GetAtmosphericPressure(), /** The Atmospheric pressure */
+ paramIn->GetWaterVaporAmount(), /** The Water vapor amount (Total water vapor content over vertical atmospheric column) */
+ paramIn->GetOzoneAmount(), /** The Ozone amount (Stratospheric ozone layer content) */
+ paramIn->GetAerosolModel(), /** The Aerosol model */
+ paramIn->GetAerosolOptical(), /** The Aerosol optical (radiative impact of aerosol for the reference wavelength 550-nm) */
+ paramIn->GetWavelengthSpectralBand()->GetNthElement(i), /** Wavelength for the spectral band definition */
+ /** Note : The Max wavelength spectral band value must be updated ! */
+ atmosphericReflectance, /** Atmospheric reflectance */
+ atmosphericSphericalAlbedo, /** atmospheric spherical albedo */
+ totalGaseousTransmission, /** Total gaseous transmission */
+ downwardTransmittance, /** downward transmittance */
+ upwardTransmittance, /** upward transmittance */
+ upwardDiffuseTransmittance, /** Upward diffuse transmittance */
+ upwardDirectTransmittance, /** Upward direct transmittance */
+ upwardDiffuseTransmittanceForRayleigh, /** Upward diffuse transmittance for rayleigh */
+ upwardDiffuseTransmittanceForAerosol /** Upward diffuse transmittance for aerosols */
+ );
+
+ radTermsOut->SetIntrinsicAtmosphericReflectance(i, atmosphericReflectance);
+ radTermsOut->SetSphericalAlbedo(i, atmosphericSphericalAlbedo);
+ radTermsOut->SetTotalGaseousTransmission(i, totalGaseousTransmission);
+ radTermsOut->SetDownwardTransmittance(i, downwardTransmittance);
+ radTermsOut->SetUpwardTransmittance(i, upwardTransmittance);
+ radTermsOut->SetUpwardDiffuseTransmittance(i, upwardDiffuseTransmittance);
+ radTermsOut->SetUpwardDirectTransmittance(i, upwardDirectTransmittance);
+ radTermsOut->SetUpwardDiffuseTransmittanceForRayleigh(i, upwardDiffuseTransmittanceForRayleigh);
+ radTermsOut->SetUpwardDiffuseTransmittanceForAerosol(i, upwardDiffuseTransmittanceForAerosol);
+ radTermsOut->SetWavelengthSpectralBand(i, paramIn->GetWavelengthSpectralBand()->GetNthElement(i)->GetCenterSpectralValue());
+ }
+
+ return radTermsOut;
+ }
+ };
+} //end namespace otb
+#endif
diff --git a/Testing/Code/Radiometry/CMakeLists.txt b/Testing/Code/Radiometry/CMakeLists.txt
index 39135effa2a8c265ac31d48654bcb1fad97bdef1..fa09859191b4d65257fa7a624f85445c7911978f 100644
--- a/Testing/Code/Radiometry/CMakeLists.txt
+++ b/Testing/Code/Radiometry/CMakeLists.txt
@@ -948,6 +948,16 @@ add_test(raTvAtmosphericCorrectionParametersTo6SAtmosphericRadiativeTerms ${RADI
${TEMP}/raTvCorrectionTo6SRadiative.txt
)
+# New test
+add_test(raTvAtmosphericCorrectionParametersToAtmosphericRadiativeTerms ${RADIOMETRY_TESTS4}
+--compare-ascii ${EPSILON_4}
+ ${BASELINE_FILES}/raTvSIXSTraitsComputeAtmosphericParametersTest.txt
+ ${TEMP}/raTvCorrectionTo6SRadiative.txt
+ otbAtmosphericCorrectionParametersToAtmosphericRadiativeTerms
+ ${INPUTDATA}/in6S_otb
+ ${TEMP}/raTvCorrectionTo6SRadiative.txt
+)
+
add_test(raTvAtmosphericCorrectionSequencementTest ${RADIOMETRY_TESTS4}
--compare-image ${EPSILON_10}
${BASELINE}/raTvRomaniaAtmosphericCorrectionSequencement.tif
@@ -2122,6 +2132,7 @@ set(Radiometry_SRCS4
otbRadiometryTests4.cxx
otbAtmosphericCorrectionParametersTo6SAtmosphericRadiativeTermsNew.cxx
otbAtmosphericCorrectionParametersTo6SAtmosphericRadiativeTerms.cxx
+otbAtmosphericCorrectionParametersToAtmosphericRadiativeTerms.cxx
otbAtmosphericCorrectionSequencement.cxx
otbEVIRAndBAndNIRVegetationIndexImageFilter.cxx
otbEVIMultiChannelRAndBAndNIRVegetationIndexImageFilter.cxx
diff --git a/Testing/Code/Radiometry/otbAtmosphericCorrectionParametersToAtmosphericRadiativeTerms.cxx b/Testing/Code/Radiometry/otbAtmosphericCorrectionParametersToAtmosphericRadiativeTerms.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..8c854a55820895bbbcf2ad4c5218c705b623de5e
--- /dev/null
+++ b/Testing/Code/Radiometry/otbAtmosphericCorrectionParametersToAtmosphericRadiativeTerms.cxx
@@ -0,0 +1,175 @@
+/*=========================================================================
+
+ Program: ORFEO Toolbox
+ Language: C++
+ Date: $Date$
+ Version: $Revision$
+
+
+ Copyright (c) Centre National d'Etudes Spatiales. All rights reserved.
+ See OTBCopyright.txt for details.
+
+
+ This software is distributed WITHOUT ANY WARRANTY; without even
+ the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ PURPOSE. See the above copyright notices for more information.
+
+=========================================================================*/
+
+#include "otbRadiometryCorrectionParametersToAtmosphericRadiativeTerms.h"
+#include "otbAtmosphericCorrectionParameters.h"
+#include "otbAtmosphericRadiativeTerms2.h"
+#include <vector>
+#include <fstream>
+#include <iostream>
+#include <iomanip>
+#include <cstdlib>
+
+int otbAtmosphericCorrectionParametersToAtmosphericRadiativeTerms(int argc, char * argv[])
+{
+ const char * wavelenghFile = argv[1];
+ const char * outputFile = argv[2];
+
+ typedef otb::RadiometryCorrectionParametersToAtmosphericRadiativeTerms CorrectionParametersToRadiativeTermsType;
+ typedef otb::AtmosphericCorrectionParameters CorrectionParametersType;
+ typedef otb::AtmosphericRadiativeTerms2 RadiativeTermsType;
+ typedef CorrectionParametersType::AerosolModelType AerosolModelType;
+ typedef otb::FilterFunctionValues FilterFunctionValuesType;
+ typedef FilterFunctionValuesType::WavelengthSpectralBandType ValueType;
+ typedef FilterFunctionValuesType::ValuesVectorType ValuesVectorType;
+
+ // Instantiating object
+ CorrectionParametersType::Pointer param = CorrectionParametersType::New();
+ AerosolModelType aerosolModel;
+ FilterFunctionValuesType::Pointer functionValues = FilterFunctionValuesType::New();
+ ValuesVectorType vect;
+
+ ValueType val = 0.0025;
+
+ vect.clear();
+
+ // Filter function values initialization
+ float minSpectralValue(0.);
+ float maxSpectralValue(0.);
+ float value(0.);
+ // Correction parameters initialization
+ double solarZenithalAngle(0.);
+ double solarAzimutalAngle(0.);
+ double viewingZenithalAngle(0.);
+ double viewingAzimutalAngle(0.);
+ unsigned int month(0);
+ unsigned int day(0);
+ double atmosphericPressure(0.);
+ double waterVaporAmount(0.);
+ double ozoneAmount(0.);
+ double aerosolOptical(0.);
+
+ std::ifstream fin;
+ std::ofstream fout;
+ //Read input file parameters
+ fin.open(wavelenghFile);
+ fin >> solarZenithalAngle; //asol;
+ fin >> solarAzimutalAngle; //phi0;
+ fin >> viewingZenithalAngle; //avis;
+ fin >> viewingAzimutalAngle; //phiv;
+ fin >> month; //month;
+ fin >> day; //jday;
+ fin >> atmosphericPressure; //pressure;
+ fin >> waterVaporAmount; //uw;
+ fin >> ozoneAmount; //uo3;
+ unsigned int aer(0);
+ fin >> aer; //iaer;
+ aerosolModel = static_cast<AerosolModelType>(aer);
+ fin >> aerosolOptical; //taer55;
+ fin >> minSpectralValue; //wlinf;
+ fin >> maxSpectralValue; //wlsup;
+
+ std::string line;
+ std::getline(fin, line);
+ while (std::getline(fin, line))
+ {
+ value = atof(line.c_str());
+ vect.push_back(value);
+ }
+
+ fin.close();
+ functionValues->SetFilterFunctionValues(vect);
+ functionValues->SetMinSpectralValue(minSpectralValue);
+ functionValues->SetMaxSpectralValue(maxSpectralValue);
+ functionValues->SetUserStep(val);
+ param->SetWavelengthSpectralBandWithIndex(0, functionValues);
+
+ // Set parameters
+ param->SetSolarZenithalAngle(static_cast<double>(solarZenithalAngle));
+ param->SetSolarAzimutalAngle(static_cast<double>(solarAzimutalAngle));
+ param->SetViewingZenithalAngle(static_cast<double>(viewingZenithalAngle));
+ param->SetViewingAzimutalAngle(static_cast<double>(viewingAzimutalAngle));
+ param->SetMonth(month);
+ param->SetDay(day);
+ param->SetAtmosphericPressure(static_cast<double>(atmosphericPressure));
+ param->SetWaterVaporAmount(static_cast<double>(waterVaporAmount));
+ param->SetOzoneAmount(static_cast<double>(ozoneAmount));
+ param->SetAerosolModel(aerosolModel);
+ param->SetAerosolOptical(static_cast<double>(aerosolOptical));
+
+ RadiativeTermsType::Pointer radiative = CorrectionParametersToRadiativeTermsType::Compute(param);
+
+
+ fout.open(outputFile);
+ fout << " ---------------------------------------------------------" << std::endl;
+ fout << "Inputs values:" << std::setprecision(10) << std::endl;
+ fout << " -----> SolarZenithalAngle : " << solarZenithalAngle << std::endl;
+ fout << " -----> SolarAzimutalAngle : " << solarAzimutalAngle << std::endl;
+ fout << " -----> ViewingZenithalAngle : " << viewingZenithalAngle << std::endl;
+ fout << " -----> ViewingAzimutalAngle : " << viewingAzimutalAngle << std::endl;
+ fout << " -----> Month : " << month << std::endl;
+ fout << " -----> Day : " << day << std::endl;
+ fout << " -----> AtmosphericPressure : " << atmosphericPressure << std::endl;
+ fout << " -----> WaterVaporAmount : " << waterVaporAmount << std::endl;
+ fout << " -----> OzoneAmount : " << ozoneAmount << std::endl;
+ fout << " -----> AerosolModel : " << aer << std::endl;
+ fout << " -----> AerosolOptical : " << aerosolOptical << std::endl;
+ fout << " -----> MinSpectralValue : " << minSpectralValue << std::endl;
+ fout << " -----> MaxSpectralValue : " << maxSpectralValue << std::endl;
+ fout << " -----> UserStep : " << functionValues->GetUserStep() << std::endl;
+ fout << " ---------------------------------------------------------" << std::endl;
+ fout << "Outputs values:" << std::endl;
+ fout << " -----> atmospheric reflectance : " <<
+ radiative->GetIntrinsicAtmosphericReflectance(0) << std::endl;
+ fout << " -----> atmospheric spherical albedo : " << radiative->GetSphericalAlbedo(0) <<
+ std::endl;
+ fout << " -----> total gaseous transmission : " <<
+ radiative->GetTotalGaseousTransmission(0) << std::endl;
+ fout << " -----> downward transmittance : " << radiative->GetDownwardTransmittance(0) <<
+ std::endl;
+ fout << " -----> upward transmittance : " << radiative->GetUpwardTransmittance(0) <<
+ std::endl;
+ fout << " -----> upward diffuse transmittance : " <<
+ radiative->GetUpwardDiffuseTransmittance(0) << std::endl;
+ fout << " -----> upward direct transmittance : " <<
+ radiative->GetUpwardDirectTransmittance(0) << std::endl;
+ fout << " -----> upward diffuse transmittance for rayleigh : " <<
+ radiative->GetUpwardDiffuseTransmittanceForRayleigh(0) << std::endl;
+ fout << " -----> upward diffuse transmittance for aerosols : " <<
+ radiative->GetUpwardDiffuseTransmittanceForAerosol(0) << std::endl;
+ fout << " -----> MinSpectralValue update: " << functionValues->GetMinSpectralValue() <<
+ std::endl;
+ fout << " -----> MaxSpectralValue update : " << functionValues->GetMaxSpectralValue() <<
+ std::endl;
+ fout << " ---------------------------------------------------------" << std::endl;
+ fout << "Input wavelength band values [" << functionValues->GetFilterFunctionValues().size() << "]:" << std::endl;
+ for (unsigned int i = 0; i < functionValues->GetFilterFunctionValues().size(); ++i)
+ {
+ fout << " " << functionValues->GetFilterFunctionValues()[i] << std::endl;
+ }
+ fout << " ---------------------------------------------------------" << std::endl;
+ fout << "Output wavelength band values 6S [" << functionValues->GetFilterFunctionValues6S().size() << "]:" <<
+ std::endl;
+ for (unsigned int i = 0; i < functionValues->GetFilterFunctionValues6S().size(); ++i)
+ {
+ fout << " " << functionValues->GetFilterFunctionValues6S()[i] << std::endl;
+ }
+ fout << std::endl;
+ fout.close();
+ return EXIT_SUCCESS;
+}
diff --git a/Testing/Code/Radiometry/otbRadiometryTests4.cxx b/Testing/Code/Radiometry/otbRadiometryTests4.cxx
index db230c7888e72fcadc6c508dbe746eef62758f1a..d4178fe75d87bd1140c44184f9ae914435148300 100644
--- a/Testing/Code/Radiometry/otbRadiometryTests4.cxx
+++ b/Testing/Code/Radiometry/otbRadiometryTests4.cxx
@@ -26,6 +26,7 @@ void RegisterTests()
{
REGISTER_TEST(otbAtmosphericCorrectionParametersTo6SAtmosphericRadiativeTermsNew);
REGISTER_TEST(otbAtmosphericCorrectionParametersTo6SAtmosphericRadiativeTerms);
+ REGISTER_TEST(otbAtmosphericCorrectionParametersToAtmosphericRadiativeTerms);
REGISTER_TEST(otbAtmosphericCorrectionSequencementTest);
REGISTER_TEST(otbEVIRAndBAndNIRVegetationIndexImageFilter);
REGISTER_TEST(otbEVIMultiChannelRAndBAndNIRVegetationIndexImageFilter);