/usr/include/OTB-6.4/otbSamplingRateCalculator.h is in libotb-dev 6.4.0+dfsg-1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 | /*
* 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 otbSamplingRateCalculator_h
#define otbSamplingRateCalculator_h
#include "itkImageRegion.h"
#include "itkVectorContainer.h"
#include <set>
namespace otb
{
/** \class SamplingRateCalculator
* \brief This class is a sampling rate calculator.
*
* It computes sampling rates for each class, given input statistics on
* available samples, and a sampling strategy.
*
* \ingroup OTBSampling
*/
class ITK_EXPORT SamplingRateCalculator
: public itk::Object
{
public:
/** Standard typedefs */
typedef SamplingRateCalculator Self;
typedef itk::Object Superclass;
typedef itk::SmartPointer<Self> Pointer;
typedef itk::SmartPointer<const Self> ConstPointer;
/** typdefs **/
typedef std::map<std::string, unsigned long> ClassCountMapType;
typedef ClassCountMapType::const_iterator constItMapType;
typedef struct Triplet
{
unsigned long Required;
unsigned long Tot;
double Rate;
bool operator==(const struct Triplet & triplet) const;
} TripletType;
typedef std::map<std::string, TripletType > MapRateType;
/** Type macro */
itkNewMacro(Self);
/** Creation through object factory macro */
itkTypeMacro(SamplingRateCalculator, itk::Object);
/** Method to manually set the number of samples required in each class */
void SetNbOfSamplesByClass(const ClassCountMapType &required);
/** Method to set the same number of required samples in each class */
void SetNbOfSamplesAllClasses(unsigned long);
/** Method to set a percentage of samples for each class */
void SetPercentageOfSamples(double percent);
/** Method to set the total number of samples to generate */
void SetTotalNumberOfSamples(unsigned long value);
/** Method to choose a sampling strategy based on the smallest class.
* The number of samples in each class is set to this minimum size*/
void SetMinimumNbOfSamplesByClass(void);
/** Method to select all available samples */
void SetAllSamples(void);
/** Method to export sampling rates in a CSV file.
* Columns are : class name, required samples, total samples, rate.*/
void Write(std::string filename);
/** Method to import sampling rates from a CSV file.
* Columns are : class name, required samples, total samples, rate.*/
void Read(std::string filename);
/** Get macro to the computed sampling rates.*/
itkGetConstReferenceMacro(RatesByClass,MapRateType);
/** Set method to input the total number of samples in each class.
* This method should be called before the other Set... methods
* that apply a sampling strategy */
void SetClassCount(const ClassCountMapType& map);
/** Clear internal data */
void ClearRates(void);
static ClassCountMapType ReadRequiredSamples(const std::string& filename);
protected:
/** Constructor */
SamplingRateCalculator();
/** Destructor */
~SamplingRateCalculator() ITK_OVERRIDE {}
/**PrintSelf method */
void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE;
private:
SamplingRateCalculator(const Self &); //purposely not implemented
void operator =(const Self&); //purposely not implemented
/** Update the computed rate for a given class.*/
void UpdateRate(const std::string &name);
/** Internal sampling rates.*/
MapRateType m_RatesByClass;
};
} // End namespace otb
#endif
|