Commit c4751d32 authored by Ludovic Hussonnois's avatar Ludovic Hussonnois

MRG: Merge remote-tracking branch 'remotes/origin/contingency_table' into develop

parents d3bd4b1f e4edd3c8
......@@ -22,6 +22,7 @@
// Validation
#include "otbConfusionMatrixCalculator.h"
#include "otbContingencyTableCalculator.h"
namespace otb
{
......@@ -48,6 +49,9 @@ public:
typedef ConfusionMatrixCalculatorType::ConfusionMatrixType ConfusionMatrixType;
typedef ConfusionMatrixCalculatorType::MapOfIndicesType MapOfIndicesType;
typedef ConfusionMatrixCalculatorType::ClassLabelType ClassLabelType;
typedef ContingencyTable<ClassLabelType> ContingencyTableType;
typedef ContingencyTableType::Pointer ContingencyTablePointerType;
protected:
void DoInit()
......@@ -72,32 +76,57 @@ protected:
void DoExecute()
{
// Enforce the need of class field name in supervised mode
if (GetClassifierCategory() == Supervised)
m_FeaturesInfo.SetClassFieldNames( GetChoiceNames( "cfield" ), GetSelectedItems( "cfield" ) );
if( m_FeaturesInfo.m_SelectedCFieldIdx.empty() && GetClassifierCategory() == Supervised )
{
m_FeaturesInfo.SetClassFieldNames( GetChoiceNames( "cfield" ), GetSelectedItems( "cfield" ) );
otbAppLogFATAL( << "No field has been selected for data labelling!" );
}
if( m_FeaturesInfo.m_SelectedCFieldIdx.empty() )
{
otbAppLogFATAL( << "No field has been selected for data labelling!" );
}
Superclass::DoExecute();
if (GetClassifierCategory() == Supervised)
{
ConfusionMatrixCalculatorType::Pointer confMatCalc = ComputeConfusionMatrix( m_PredictedList,
m_ClassificationSamplesWithLabel.labeledListSample );
WriteConfusionMatrix( confMatCalc );
}
else
{
ContingencyTablePointerType table = ComputeContingencyTable( m_PredictedList,
m_ClassificationSamplesWithLabel.labeledListSample );
WriteContingencyTable( table );
}
}
Superclass::DoExecute();
ContingencyTablePointerType ComputeContingencyTable(const TargetListSampleType::Pointer &predictedListSample,
const TargetListSampleType::Pointer &performanceLabeledListSample)
{
typedef ContingencyTableCalculator<ClassLabelType> ContigencyTableCalcutaltorType;
if (GetClassifierCategory() == Supervised)
{
ConfusionMatrixCalculatorType::Pointer confMatCalc = ComputeConfusionMatrix( m_PredictedList,
m_ClassificationSamplesWithLabel.labeledListSample );
WriteConfusionMatrix( confMatCalc );
}
else
{
// TODO Compute Contingency Table
}
ContigencyTableCalcutaltorType::Pointer contingencyTableCalculator = ContigencyTableCalcutaltorType::New();
contingencyTableCalculator->Compute(performanceLabeledListSample->Begin(),
performanceLabeledListSample->End(),predictedListSample->Begin(), predictedListSample->End());
otbAppLogINFO( "Training performances:" );
otbAppLogINFO(<<"Contingency table: reference labels (rows) vs. produced labels (cols)\n"<<contingencyTableCalculator->BuildContingencyTable());
return contingencyTableCalculator->BuildContingencyTable();
}
void WriteContingencyTable(const ContingencyTablePointerType& table)
{
if(IsParameterEnabled("io.confmatout"))
{
// Write contingency table
std::ofstream outFile;
outFile.open( this->GetParameterString( "io.confmatout" ).c_str() );
outFile << table->ToCSV();
}
}
ConfusionMatrixCalculatorType::Pointer
ComputeConfusionMatrix(const TargetListSampleType::Pointer &predictedListSample,
......@@ -111,7 +140,7 @@ protected:
confMatCalc->SetProducedLabels( predictedListSample );
confMatCalc->Compute();
otbAppLogINFO( "training performances" );
otbAppLogINFO( "Training performances:" );
LogConfusionMatrix( confMatCalc );
for( unsigned int itClasses = 0; itClasses < confMatCalc->GetNumberOfClasses(); itClasses++ )
......
......@@ -33,6 +33,7 @@ namespace Wrapper
template <class TInputValue, class TOutputValue>
LearningApplicationBase<TInputValue,TOutputValue>
::LearningApplicationBase() : m_RegressionFlag(false)
{
}
......@@ -59,7 +60,9 @@ LearningApplicationBase<TInputValue,TOutputValue>
InitUnsupervisedClassifierParams();
std::vector<std::string> allClassifier = GetChoiceKeys("classifier");
m_UnsupervisedClassifier.assign(allClassifier.begin() + m_SupervisedClassifier.size(), allClassifier.end());
// Check for empty unsupervised classifier
if( allClassifier.size() > m_UnsupervisedClassifier.size() )
m_UnsupervisedClassifier.assign( allClassifier.begin() + m_SupervisedClassifier.size(), allClassifier.end() );
}
template <class TInputValue, class TOutputValue>
......@@ -67,10 +70,16 @@ typename LearningApplicationBase<TInputValue,TOutputValue>::ClassifierCategory
LearningApplicationBase<TInputValue,TOutputValue>
::GetClassifierCategory()
{
bool foundUnsupervised =
std::find(m_UnsupervisedClassifier.begin(), m_UnsupervisedClassifier.end(),
GetParameterString("classifier")) != m_UnsupervisedClassifier.end();
return foundUnsupervised ? Unsupervised : Supervised;
if( m_UnsupervisedClassifier.empty() )
{
return Supervised;
}
else
{
bool foundUnsupervised = std::find( m_UnsupervisedClassifier.begin(), m_UnsupervisedClassifier.end(),
GetParameterString( "classifier" ) ) != m_UnsupervisedClassifier.end();
return foundUnsupervised ? Unsupervised : Supervised;
}
}
template <class TInputValue, class TOutputValue>
......
......@@ -125,7 +125,7 @@ protected:
{
m_SelectedCFieldIdx = selectedCFieldIdx;
// Handle only one class field name, if several are provided only the first one is used.
m_SelectedCFieldName = cFieldNames[selectedCFieldIdx.front()];
m_SelectedCFieldName = selectedCFieldIdx.empty() ? cFieldNames.front() : cFieldNames[selectedCFieldIdx.front()];
}
};
......
......@@ -392,6 +392,7 @@ otb_test_application(NAME apTvComputeConfusionMatrixExtraReferenceLabelsR
OPTIONS -in ${INPUTDATA}/Classification/QB_1_ortho_C7.tif
-ref raster
-ref.raster.in ${INPUTDATA}/Classification/clLabeledImageQB456_1_NoData_255.tif
-ref.raster.nodata 255
-nodatalabel 255
-out ${TEMP}/apTvComputeConfusionMatrixExtraRefLabelsROut.csv
VALID --compare-ascii ${NOTOL}
......@@ -403,6 +404,7 @@ otb_test_application(NAME apTvComputeConfusionMatrixR
OPTIONS -in ${OTBAPP_BASELINE}/clLabeledImageQB123_1.tif
-ref raster
-ref.raster.in ${INPUTDATA}/Classification/clLabeledImageQB456_1_NoData_255.tif
-ref.raster.nodata 255
-nodatalabel 255
-out ${TEMP}/apTvComputeConfusionMatrixTconfusionROut.csv
VALID --compare-ascii ${NOTOL}
......@@ -414,12 +416,27 @@ otb_test_application(NAME apTvComputeConfusionMatrixExtraProducedLabelsR
OPTIONS -in ${INPUTDATA}/Classification/clLabeledImageQB456_1_NoData_255.tif
-ref raster
-ref.raster.in ${INPUTDATA}/Classification/QB_1_ortho_C8.tif
-ref.raster.nodata 255
-nodatalabel 255
-out ${TEMP}/apTvComputeConfusionMatrixExtraProdLabelsROut.csv
VALID --compare-ascii ${NOTOL}
${OTBAPP_BASELINE_FILES}/apTvComputeConfusionMatrixExtraProdLabelsROut.csv
${TEMP}/apTvComputeConfusionMatrixExtraProdLabelsROut.csv)
#----------- ComputeContingencyTable TESTS ----------------
otb_test_application(NAME apTvComputeContingencyTableExtraProducedLabelsR
APP ComputeConfusionMatrix
OPTIONS -in ${INPUTDATA}/Classification/clLabeledImageQB456_1_NoData_255.tif
-ref raster
-ref.raster.in ${INPUTDATA}/Classification/QB_1_ortho_C8.tif
-ref.raster.nodata 255
-nodatalabel 255
-format contingencytable
-out ${TEMP}/apTvComputeContingencyTableExtraProdLabelsROut.csv
VALID --compare-ascii ${NOTOL}
${OTBAPP_BASELINE_FILES}/apTvComputeContingencyTableExtraProdLabelsROut.csv
${TEMP}/apTvComputeContingencyTableExtraProdLabelsROut.csv)
#----------- FusionOfClassifications TESTS ----------------
otb_test_application(NAME apTvFusionOfClassificationsDSPrecision6Inputs
......
/*
* Copyright (C) 2005-2017 Centre National d'Etudes Spatiales (CNES)
*
* This file is part of Orfeo Toolbox
*
* https://www.orfeo-toolbox.org/
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef otbContingencyTable_h
#define otbContingencyTable_h
#include <vector>
#include <iostream>
#include <iomanip>
#include <itkObject.h>
#include <itkObjectFactory.h>
#include <itkVariableSizeMatrix.h>
namespace otb
{
template<class TClassLabel>
class ContingencyTable : public itk::Object
{
public:
/** Standard class typedefs */
typedef ContingencyTable Self;
typedef itk::Object Superclass;
typedef itk::SmartPointer<Self> Pointer;
typedef itk::SmartPointer<const Self> ConstPointer;
/** Run-time type information (and related methods). */
itkTypeMacro(ContingencyTableCalculator, itk::Object);
/** Method for creation through the object factory. */
itkNewMacro(Self);
typedef itk::VariableSizeMatrix<unsigned long> MatrixType;
typedef std::vector<TClassLabel> LabelList;
MatrixType matrix;
void SetLabels(const LabelList &referenceLabels, const LabelList &producedLabels)
{
m_RefLabels = referenceLabels;
m_ProdLabels = producedLabels;
unsigned int rows = static_cast<unsigned int>(m_RefLabels.size());
unsigned int cols = static_cast<unsigned int>(m_ProdLabels.size());
matrix.SetSize( rows, cols );
matrix.Fill( 0 );
}
friend std::ostream &operator<<(std::ostream &o, const ContingencyTable<TClassLabel> &contingencyTable)
{
// Retrieve the maximal width from the matrix and the labels
size_t maxWidth = 6;
maxWidth = GetLabelsMaximumLength(contingencyTable.m_ProdLabels, maxWidth);
maxWidth = GetLabelsMaximumLength(contingencyTable.m_RefLabels, maxWidth);
for( unsigned int i = 0; i < contingencyTable.matrix.Rows(); ++i )
{
for( unsigned int j = 0; j < contingencyTable.matrix.Cols(); ++j )
{
std::ostringstream oss;
oss << contingencyTable.matrix( i, j );
size_t length = oss.str().length();
if( length > maxWidth )
maxWidth = length;
}
}
int width = static_cast<int>(maxWidth)+1;
// Write the first line of the matrix (produced labels)
o << std::setfill(' ') << std::setw( width ) << "labels";
for( size_t i = 0; i < contingencyTable.m_ProdLabels.size(); ++i )
{
o << std::setfill(' ') << std::setw( width ) << contingencyTable.m_ProdLabels[i];
}
o << std::endl;
// For each line write the reference label, then the count value
for( unsigned int i = 0; i < contingencyTable.matrix.Rows(); ++i )
{
o << std::setfill(' ') << std::setw( width ) << contingencyTable.m_RefLabels[i];
for( unsigned int j = 0; j < contingencyTable.matrix.Cols(); ++j )
{
o << std::setfill(' ') << std::setw( width ) << contingencyTable.matrix( i, j );
}
o << std::endl;
}
return o;
}
std::string ToCSV() const
{
const char separator = ',';
std::ostringstream oss;
oss << "labels";
for( size_t i = 0; i < m_ProdLabels.size(); ++i )
{
oss << separator << m_ProdLabels[i];
}
oss << std::endl;
// For each line write the reference label, then the count value
for( unsigned int i = 0; i < matrix.Rows(); ++i )
{
oss << m_RefLabels[i];
for( unsigned int j = 0; j < matrix.Cols(); ++j )
{
oss << separator << matrix( i, j );
}
oss << std::endl;
}
oss << std::endl;
return oss.str();
}
protected:
ContingencyTable()
{
SetLabels(LabelList{}, LabelList{});
}
~ContingencyTable() ITK_OVERRIDE {}
void PrintSelf(std::ostream& os, itk::Indent itkNotUsed(indent)) const ITK_OVERRIDE
{
os << *this;
}
private:
ContingencyTable(const Self &); //purposely not implemented
void operator=(const Self &); //purposely not implemented
static size_t GetLabelsMaximumLength(const LabelList& labels, size_t maxWidth)
{
size_t tmpMaxWidth = maxWidth;
for( size_t i = 0; i < labels.size(); ++i )
{
std::ostringstream oss;
oss << labels[i];
size_t length = oss.str().length();
if( length > tmpMaxWidth )
tmpMaxWidth = length;
}
return tmpMaxWidth;
}
LabelList m_RefLabels;
LabelList m_ProdLabels;
};
}
#endif //otbContingencyTable_h
/*
* Copyright (C) 2005-2017 Centre National d'Etudes Spatiales (CNES)
*
* This file is part of Orfeo Toolbox
*
* https://www.orfeo-toolbox.org/
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef otbContingencyTableCalculator_h
#define otbContingencyTableCalculator_h
#include "itkObject.h"
#include "itkObjectFactory.h"
#include "otbContingencyTable.h"
#include <map>
namespace otb
{
/**
* \brief ContingencyTableCalculator provide facilities to compute ContingencyTable.
*
* The ContingencyTableCalculator can be used with different structure type,
* the size of the label list should be the same for both list.
*
* \tparam TClassLabel the label data type
* \ingroup OTBUnsupervised
*/
template<class TClassLabel>
class ITK_EXPORT ContingencyTableCalculator : public itk::Object
{
public:
/** Standard class typedefs */
typedef ContingencyTableCalculator Self;
typedef itk::Object Superclass;
typedef itk::SmartPointer <Self> Pointer;
typedef itk::SmartPointer<const Self> ConstPointer;
/** Run-time type information (and related methods). */
itkTypeMacro(ContingencyTableCalculator, itk::Object);
/** Method for creation through the object factory. */
itkNewMacro(Self);
typedef ContingencyTable<TClassLabel> ContingencyTableType;
typedef typename ContingencyTableType::Pointer ContingencyTablePointerType;
typedef typename std::map<TClassLabel, unsigned long> CountMapType;
typedef typename std::map<TClassLabel, CountMapType > MapOfClassesType;
/** Populate the confusion Matrix for a image iteration.
* \tparam TRefListLabel data structure type which contain the reference labels.
* \tparam TProdListLabel data structure type which contain the produced labels.
*/
template<class TRefIterator, class TProdIterator>
void Compute(TRefIterator itRef, TProdIterator itProd, bool refHasNoData = false, typename TRefIterator::InternalPixelType refNoData = 0,
bool prodHasNoData = false, typename TProdIterator::InternalPixelType prodNoData = 0);
/** Populate the confusion Matrix with input which provide GetMeasurementVector()[0] access
* \tparam TRefListLabel data structure type which contain the reference labels.
* \tparam TProdListLabel data structure type which contain the produced labels.
*/
template<class TRefIterator, class TProdIterator>
void Compute(TRefIterator refBegin, TRefIterator refEnd, TProdIterator prodBegin, TProdIterator prodEnd);
itkGetConstMacro(NumberOfRefClasses, unsigned long);
itkGetConstMacro(NumberOfProdClasses, unsigned long);
itkGetConstMacro(NumberOfSamples, unsigned long);
void Clear();
ContingencyTablePointerType BuildContingencyTable();
protected:
ContingencyTableCalculator();
~ContingencyTableCalculator() ITK_OVERRIDE {}
//void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE;
private:
ContingencyTableCalculator(const Self &); //purposely not implemented
void operator=(const Self &); //purposely not implemented
MapOfClassesType m_LabelCount;
unsigned long m_NumberOfRefClasses;
unsigned long m_NumberOfProdClasses;
unsigned long m_NumberOfSamples;
};
}
#ifndef OTB_MANUAL_INSTANTIATION
#include "otbContingencyTableCalculator.txx"
#endif
#endif //otbContingencyTableCalculator_h
/*
* Copyright (C) 2005-2017 Centre National d'Etudes Spatiales (CNES)
*
* This file is part of Orfeo Toolbox
*
* https://www.orfeo-toolbox.org/
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef otbContingencyTableCalculator_txx
#define otbContingencyTableCalculator_txx
#include "otbContingencyTableCalculator.h"
#include "itkMacro.h"
#include "itkVariableLengthVector.h"
#include "itkListSample.h"
#include <set>
#include <iterator>
namespace otb
{
template<class TClassLabel>
ContingencyTableCalculator<TClassLabel>::ContingencyTableCalculator()
: m_NumberOfRefClasses(0), m_NumberOfProdClasses(0), m_NumberOfSamples(0)
{}
template<class TClassLabel>
void
ContingencyTableCalculator<TClassLabel>
::Clear()
{
m_LabelCount.clear();
m_NumberOfRefClasses = 0;
m_NumberOfProdClasses = 0;
m_NumberOfSamples = 0;
}
template<class TClassLabel>
template<class TRefIterator, class TProdIterator>
void
ContingencyTableCalculator<TClassLabel>
::Compute(TRefIterator refBegin, TRefIterator refEnd, TProdIterator prodBegin, TProdIterator prodEnd)
{
while( refBegin != refEnd && prodBegin != prodEnd )
{
++m_LabelCount[refBegin.GetMeasurementVector()[0]][prodBegin.GetMeasurementVector()[0]];
++refBegin;
++prodBegin;
++m_NumberOfSamples;
}
if( refBegin != refEnd || prodBegin != prodEnd )
itkExceptionMacro(<< "The references and produced labels did not end simultaneously.");
}
template<class TClassLabel>
template<class TRefIterator, class TProdIterator>
void
ContingencyTableCalculator<TClassLabel>
::Compute(TRefIterator itRef, TProdIterator itProd, bool refHasNoData, typename TRefIterator::InternalPixelType refNoData,
bool prodHasNoData, typename TProdIterator::InternalPixelType prodNoData)
{
while( !itRef.IsAtEnd() && !itProd.IsAtEnd() )
{
if((!prodHasNoData || itProd.Get()!=prodNoData)
&&(!refHasNoData || itRef.Get()!=refNoData))
{
++m_LabelCount[itRef.Get()][itProd.Get()];
++m_NumberOfSamples;
}
++itRef;
++itProd;
}
if( !itRef.IsAtEnd() || !itProd.IsAtEnd() )
itkExceptionMacro(<< "The references and produced labels did not end simultaneously.");
}
template<class TClassLabel>
typename ContingencyTableCalculator<TClassLabel>::ContingencyTablePointerType
ContingencyTableCalculator<TClassLabel>
::BuildContingencyTable()
{
std::set<TClassLabel> refLabels;
std::set<TClassLabel> prodLabels;
// Retrieve all labels needed to iterate over all labelCount
for(typename MapOfClassesType::const_iterator refIt = m_LabelCount.begin(); refIt != m_LabelCount.end(); ++refIt)
{
refLabels.insert(refIt->first);
CountMapType cmt = refIt->second;
for(typename CountMapType::const_iterator prodIt = cmt.begin(); prodIt != cmt.end(); ++prodIt)
{
prodLabels.insert(prodIt->first);
}
}
m_NumberOfRefClasses = refLabels.size();
m_NumberOfProdClasses = prodLabels.size();
unsigned int rows = static_cast<unsigned int>(m_NumberOfRefClasses);
unsigned int cols = static_cast<unsigned int>(m_NumberOfProdClasses);
std::vector<TClassLabel> referenceLabels(refLabels.begin(), refLabels.end());
std::vector<TClassLabel> producedLabels(prodLabels.begin(), prodLabels.end());
ContingencyTablePointerType contingencyTable = ContingencyTableType::New();
contingencyTable->SetLabels(referenceLabels, producedLabels);
for( unsigned int i = 0; i < rows; ++i )
for( unsigned int j = 0; j < cols; ++j )
contingencyTable->matrix(i,j) = m_LabelCount[referenceLabels[i]][producedLabels[j]];
return contingencyTable;
}
}
#endif
......@@ -20,6 +20,7 @@
#ifndef otbSharkKMeansMachineLearningModel_h
#define otbSharkKMeansMachineLearningModel_h
#include "boost/shared_ptr.hpp"
#include "itkLightObject.h"
#include "otbMachineLearningModel.h"
......
......@@ -21,6 +21,7 @@
#define otbSharkKMeansMachineLearningModel_txx
#include <fstream>
#include "boost/make_shared.hpp"
#include "itkMacro.h"
#include "otbSharkKMeansMachineLearningModel.h"
......@@ -54,7 +55,7 @@ SharkKMeansMachineLearningModel<TInputValue, TOutputValue>
m_Normalized( false ), m_K(2), m_MaximumNumberOfIterations( 10 )
{
// Default set HardClusteringModel
m_ClusteringModel = boost::shared_ptr<ClusteringModelType>(new ClusteringModelType( &m_Centroids ));
m_ClusteringModel = boost::make_shared<ClusteringModelType>( &m_Centroids );
}
......@@ -81,7 +82,7 @@ SharkKMeansMachineLearningModel<TInputValue, TOutputValue>
// Use a Hard Clustering Model for classification
shark::kMeans( data, m_K, m_Centroids, m_MaximumNumberOfIterations );
m_ClusteringModel = boost::shared_ptr<ClusteringModelType>(new ClusteringModelType( &m_Centroids ));
m_ClusteringModel = boost::make_shared<ClusteringModelType>( &m_Centroids );
}
template<class TInputValue, class TOutputValue>
......@@ -153,7 +154,7 @@ SharkKMeansMachineLearningModel<TInputValue, TOutputValue>
shark::Data<ClusteringOutputType> clusters;
try
{
clusters = ( *m_ClusteringModel )( inputSamples );
clusters = ( *m_ClusteringModel )( inputSamples );
}
catch( ... )
{
......
......@@ -3,10 +3,24 @@ set(OTBUnsupervisedTests
otbUnsupervisedTestDriver.cxx
otbMachineLearningUnsupervisedModelCanRead.cxx
otbTrainMachineLearningUnsupervisedModel.cxx
otbContingencyTableCalculatorTest.cxx
)
# Tests Declaration
otb_add_test(NAME leTuContingencyTableCalculatorNew COMMAND otbUnsupervisedTestDriver
otbContingencyTableCalculatorNew)
otb_add_test(NAME leTvContingencyTableCalculatorSetListSamples COMMAND otbUnsupervisedTestDriver
otbContingencyTableCalculatorSetListSamples 1000 4)
otb_add_test(NAME leTvContingencyTableCalculatorUpdate COMMAND otbUnsupervisedTestDriver
otbContingencyTableCalculatorCompute 4 3)
otb_add_test(NAME leTvContingencyTableCalculatorUpdateWithBaseline COMMAND otbUnsupervisedTestDriver
otbContingencyTableCalculatorComputeWithBaseline)
if(OTB_USE_SHARK)
set(OTBUnsupervisedTests ${OTBUnsupervisedTests} otbSharkUnsupervisedImageClassificationFilter.cxx)
include(tests-shark.cmake)
......
/*
* Copyright (C) 2005-2017 Centre National d'Etudes Spatiales (CNES)
*
* This file is part of Orfeo Toolbox
*
* https://www.orfeo-toolbox.org/
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "itkListSample.h"
#include "otbContingencyTableCalculator.h"
int otbContingencyTableCalculatorNew(int itkNotUsed(argc), char * itkNotUsed(argv) [])
{
typedef int ClassLabelType;
typedef otb::ContingencyTableCalculator<ClassLabelType> CalculatorType;
CalculatorType::Pointer calculator = CalculatorType::New();