diff --git a/Examples/Application/ApplicationExample.cxx b/Examples/Application/ApplicationExample.cxx index b6ba4c772886fb887ee5ff0c0f85b831b1ac8f45..4c4f2179c41ea8e8fe22ccd66fb283691b58ed30 100644 --- a/Examples/Application/ApplicationExample.cxx +++ b/Examples/Application/ApplicationExample.cxx @@ -42,10 +42,10 @@ public: // Class declaration is followed by \code{ITK} public types for the class, the superclass and // smart pointers. - typedef ApplicationExample Self; - typedef Application Superclass; - typedef itk::SmartPointer<Self> Pointer; - typedef itk::SmartPointer<const Self> ConstPointer; + using Self = ApplicationExample; + using Superclass = Application; + using Pointer = itk::SmartPointer<Self>; + using ConstPointer = itk::SmartPointer<const Self>; // Following macros are necessary to respect ITK object factory mechanisms. Please report // to \ref{sec:FilterConventions} for additional information. diff --git a/Examples/BasicFilters/BandMathFilterExample.cxx b/Examples/BasicFilters/BandMathFilterExample.cxx index 98d13618c6bac6176ee144408c22d09c60876769..baaa6b931f4a5137eaf0f3e1c97268e51fe7f248 100644 --- a/Examples/BasicFilters/BandMathFilterExample.cxx +++ b/Examples/BasicFilters/BandMathFilterExample.cxx @@ -53,16 +53,16 @@ int main(int argc, char* argv[]) // writing the images. The BandMathImageFilter class // works with Image as input, so we need to define additional // filters to extract each layer of the multispectral image. - typedef double PixelType; - typedef otb::VectorImage<PixelType, 2> InputImageType; - typedef otb::Image<PixelType, 2> OutputImageType; - typedef otb::ImageList<OutputImageType> ImageListType; - typedef otb::VectorImageToImageListFilter<InputImageType, ImageListType> VectorImageToImageListType; - typedef otb::ImageFileReader<InputImageType> ReaderType; - typedef otb::ImageFileWriter<OutputImageType> WriterType; + using PixelType = double; + using InputImageType = otb::VectorImage<PixelType, 2>; + using OutputImageType = otb::Image<PixelType, 2>; + using ImageListType = otb::ImageList<OutputImageType>; + using VectorImageToImageListType = otb::VectorImageToImageListFilter<InputImageType, ImageListType>; + using ReaderType = otb::ImageFileReader<InputImageType>; + using WriterType = otb::ImageFileWriter<OutputImageType>; // We can now define the type for the filter - typedef otb::BandMathImageFilter<OutputImageType> FilterType; + using FilterType = otb::BandMathImageFilter<OutputImageType>; // We instantiate the filter, the reader, and the writer ReaderType::Pointer reader = ReaderType::New(); @@ -107,11 +107,12 @@ int main(int argc, char* argv[]) writer->Update(); // The muParser library also provides the possibility to extend existing built-in functions. For example, - // you can use the OTB expression "ndvi(b3, b4)" with the filter. In this instance, the mathematical expression would be "if(ndvi(b3, b4)>0.4, 255, 0)", which would return the same result. + // you can use the OTB expression "ndvi(b3, b4)" with the filter. In this instance, the mathematical expression would be "if(ndvi(b3, b4)>0.4, 255, 0)", which + // would return the same result. - typedef otb::Image<unsigned char, 2> OutputPrettyImageType; - typedef otb::ImageFileWriter<OutputPrettyImageType> PrettyImageFileWriterType; - typedef itk::CastImageFilter<OutputImageType, OutputPrettyImageType> CastImageFilterType; + using OutputPrettyImageType = otb::Image<unsigned char, 2>; + using PrettyImageFileWriterType = otb::ImageFileWriter<OutputPrettyImageType>; + using CastImageFilterType = itk::CastImageFilter<OutputImageType, OutputPrettyImageType>; PrettyImageFileWriterType::Pointer prettyWriter = PrettyImageFileWriterType::New(); CastImageFilterType::Pointer caster = CastImageFilterType::New(); diff --git a/Examples/BasicFilters/BandMathXImageFilterExample.cxx b/Examples/BasicFilters/BandMathXImageFilterExample.cxx index 7978a9c30b8822cf7e3198e03520256f2587f898..0837e9f4af235e1d062db24da678ef535da3cab7 100644 --- a/Examples/BasicFilters/BandMathXImageFilterExample.cxx +++ b/Examples/BasicFilters/BandMathXImageFilterExample.cxx @@ -67,15 +67,15 @@ int main(int argc, char* argv[]) // writing the images. The \doxygen{otb}{BandMathXImageFilter} class // works with \doxygen{otb}{VectorImage}. - typedef double PixelType; - typedef otb::VectorImage<PixelType, 2> ImageType; - typedef otb::ImageFileReader<ImageType> ReaderType; - typedef otb::ImageFileWriter<ImageType> WriterType; + using PixelType = double; + using ImageType = otb::VectorImage<PixelType, 2>; + using ReaderType = otb::ImageFileReader<ImageType>; + using WriterType = otb::ImageFileWriter<ImageType>; // We can now define the type for the filter: - typedef otb::BandMathXImageFilter<ImageType> FilterType; + using FilterType = otb::BandMathXImageFilter<ImageType>; // We instantiate the filter, the reader, and the writer: diff --git a/Examples/BasicFilters/DEMToRainbowExample.cxx b/Examples/BasicFilters/DEMToRainbowExample.cxx index fcceeae63cc27416400a727f6397176b82708a1c..7f8d627b636485a5eb6fc9e6ec5576fb2a100535 100644 --- a/Examples/BasicFilters/DEMToRainbowExample.cxx +++ b/Examples/BasicFilters/DEMToRainbowExample.cxx @@ -52,23 +52,23 @@ int main(int argc, char* argv[]) return EXIT_FAILURE; } - typedef double PixelType; - typedef unsigned char UCharPixelType; - typedef itk::RGBPixel<UCharPixelType> RGBPixelType; - typedef otb::Image<PixelType, 2> ImageType; - typedef otb::Image<RGBPixelType, 2> RGBImageType; - typedef otb::ImageFileWriter<RGBImageType> WriterType; + using PixelType = double; + using UCharPixelType = unsigned char; + using RGBPixelType = itk::RGBPixel<UCharPixelType>; + using ImageType = otb::Image<PixelType, 2>; + using RGBImageType = otb::Image<RGBPixelType, 2>; + using WriterType = otb::ImageFileWriter<RGBImageType>; WriterType::Pointer writer = WriterType::New(); writer->SetFileName(argv[1]); - typedef otb::DEMToImageGenerator<ImageType> DEMToImageGeneratorType; + using DEMToImageGeneratorType = otb::DEMToImageGenerator<ImageType>; DEMToImageGeneratorType::Pointer demToImage = DEMToImageGeneratorType::New(); - typedef DEMToImageGeneratorType::SizeType SizeType; - typedef DEMToImageGeneratorType::SpacingType SpacingType; - typedef DEMToImageGeneratorType::PointType PointType; + using SizeType = DEMToImageGeneratorType::SizeType; + using SpacingType = DEMToImageGeneratorType::SpacingType; + using PointType = DEMToImageGeneratorType::PointType; otb::DEMHandler::Instance()->OpenDEMDirectory(argv[8]); @@ -94,14 +94,14 @@ int main(int argc, char* argv[]) // the filter in charge of calling the functor we specify to do the work for // each pixel. Here it is the ScalarToRainbowRGBPixelFunctor. - typedef itk::ScalarToRGBColormapImageFilter<ImageType, RGBImageType> ColorMapFilterType; - ColorMapFilterType::Pointer colormapper = ColorMapFilterType::New(); + using ColorMapFilterType = itk::ScalarToRGBColormapImageFilter<ImageType, RGBImageType>; + ColorMapFilterType::Pointer colormapper = ColorMapFilterType::New(); colormapper->UseInputImageExtremaForScalingOff(); if (argc == 9) { - typedef otb::Functor::ScalarToRainbowRGBPixelFunctor<PixelType, RGBPixelType> ColorMapFunctorType; - ColorMapFunctorType::Pointer colormap = ColorMapFunctorType::New(); + using ColorMapFunctorType = otb::Functor::ScalarToRainbowRGBPixelFunctor<PixelType, RGBPixelType>; + ColorMapFunctorType::Pointer colormap = ColorMapFunctorType::New(); colormap->SetMinimumInputValue(0); colormap->SetMaximumInputValue(4000); colormapper->SetColormap(colormap); @@ -111,16 +111,16 @@ int main(int argc, char* argv[]) { if (strcmp(argv[9], "hot") == 0) { - typedef itk::Function::HotColormapFunction<PixelType, RGBPixelType> ColorMapFunctorType; - ColorMapFunctorType::Pointer colormap = ColorMapFunctorType::New(); + using ColorMapFunctorType = itk::Function::HotColormapFunction<PixelType, RGBPixelType>; + ColorMapFunctorType::Pointer colormap = ColorMapFunctorType::New(); colormap->SetMinimumInputValue(0); colormap->SetMaximumInputValue(4000); colormapper->SetColormap(colormap); } else { - typedef otb::Functor::ReliefColormapFunctor<PixelType, RGBPixelType> ColorMapFunctorType; - ColorMapFunctorType::Pointer colormap = ColorMapFunctorType::New(); + using ColorMapFunctorType = otb::Functor::ReliefColormapFunctor<PixelType, RGBPixelType>; + ColorMapFunctorType::Pointer colormap = ColorMapFunctorType::New(); colormap->SetMinimumInputValue(0); colormap->SetMaximumInputValue(4000); colormapper->SetColormap(colormap); diff --git a/Examples/BasicFilters/FrostImageFilter.cxx b/Examples/BasicFilters/FrostImageFilter.cxx index 913ac71a271f1fc1abb1b45243aacf1999da22e3..500daaa5f336dbeb47c0313ef0a6e7e6df75bc34 100644 --- a/Examples/BasicFilters/FrostImageFilter.cxx +++ b/Examples/BasicFilters/FrostImageFilter.cxx @@ -39,14 +39,14 @@ int main(int argc, char* argv[]) return EXIT_FAILURE; } - typedef unsigned char PixelType; - typedef otb::Image<PixelType, 2> InputImageType; - typedef otb::Image<PixelType, 2> OutputImageType; + using PixelType = unsigned char; + using InputImageType = otb::Image<PixelType, 2>; + using OutputImageType = otb::Image<PixelType, 2>; // The filter can be instantiated using the image types defined previously. - typedef otb::FrostImageFilter<InputImageType, OutputImageType> FilterType; - typedef otb::ImageFileReader<InputImageType> ReaderType; - typedef otb::ImageFileWriter<OutputImageType> WriterType; + using FilterType = otb::FrostImageFilter<InputImageType, OutputImageType>; + using ReaderType = otb::ImageFileReader<InputImageType>; + using WriterType = otb::ImageFileWriter<OutputImageType>; ReaderType::Pointer reader = ReaderType::New(); FilterType::Pointer filter = FilterType::New(); diff --git a/Examples/BasicFilters/HillShadingExample.cxx b/Examples/BasicFilters/HillShadingExample.cxx index a281e9aef85d86116d5ca7c35b719cbd832e9e19..053767bcadd06682e64890f2fb3c2fdf8036963f 100644 --- a/Examples/BasicFilters/HillShadingExample.cxx +++ b/Examples/BasicFilters/HillShadingExample.cxx @@ -48,14 +48,14 @@ int main(int argc, char* argv[]) return EXIT_FAILURE; } - typedef double PixelType; - typedef unsigned char UCharPixelType; - typedef itk::RGBPixel<UCharPixelType> RGBPixelType; - typedef otb::Image<PixelType, 2> ImageType; - typedef otb::Image<RGBPixelType, 2> RGBImageType; - typedef otb::Image<UCharPixelType, 2> ScalarImageType; - typedef otb::ImageFileWriter<RGBImageType> WriterType; - typedef otb::ImageFileWriter<ScalarImageType> ScalarWriterType; + using PixelType = double; + using UCharPixelType = unsigned char; + using RGBPixelType = itk::RGBPixel<UCharPixelType>; + using ImageType = otb::Image<PixelType, 2>; + using RGBImageType = otb::Image<RGBPixelType, 2>; + using ScalarImageType = otb::Image<UCharPixelType, 2>; + using WriterType = otb::ImageFileWriter<RGBImageType>; + using ScalarWriterType = otb::ImageFileWriter<ScalarImageType>; ScalarWriterType::Pointer writer = ScalarWriterType::New(); writer->SetFileName(argv[1]); @@ -63,13 +63,13 @@ int main(int argc, char* argv[]) WriterType::Pointer writer2 = WriterType::New(); writer2->SetFileName(argv[2]); - typedef otb::DEMToImageGenerator<ImageType> DEMToImageGeneratorType; + using DEMToImageGeneratorType = otb::DEMToImageGenerator<ImageType>; DEMToImageGeneratorType::Pointer demToImage = DEMToImageGeneratorType::New(); - typedef DEMToImageGeneratorType::SizeType SizeType; - typedef DEMToImageGeneratorType::SpacingType SpacingType; - typedef DEMToImageGeneratorType::PointType PointType; + using SizeType = DEMToImageGeneratorType::SizeType; + using SpacingType = DEMToImageGeneratorType::SpacingType; + using PointType = DEMToImageGeneratorType::PointType; otb::DEMHandler::Instance()->OpenDEMDirectory(argv[9]); @@ -113,35 +113,35 @@ int main(int argc, char* argv[]) // operations in its neighborhood. A convenient filter called \doxygen{otb}{HillShadingFilter} // is defined around this mechanism. - typedef otb::HillShadingFilter<ImageType, ImageType> HillShadingFilterType; - HillShadingFilterType::Pointer hillShading = HillShadingFilterType::New(); + using HillShadingFilterType = otb::HillShadingFilter<ImageType, ImageType>; + HillShadingFilterType::Pointer hillShading = HillShadingFilterType::New(); hillShading->SetRadius(1); hillShading->SetInput(demToImage->GetOutput()); hillShading->GetFunctor().SetXRes(res); hillShading->GetFunctor().SetYRes(res); - typedef itk::ShiftScaleImageFilter<ImageType, ScalarImageType> RescalerType; - RescalerType::Pointer rescaler = RescalerType::New(); + using RescalerType = itk::ShiftScaleImageFilter<ImageType, ScalarImageType>; + RescalerType::Pointer rescaler = RescalerType::New(); rescaler->SetScale(255.0); rescaler->SetInput(hillShading->GetOutput()); writer->SetInput(rescaler->GetOutput()); - typedef itk::ScalarToRGBColormapImageFilter<ImageType, RGBImageType> ColorMapFilterType; - ColorMapFilterType::Pointer colormapper = ColorMapFilterType::New(); + using ColorMapFilterType = itk::ScalarToRGBColormapImageFilter<ImageType, RGBImageType>; + ColorMapFilterType::Pointer colormapper = ColorMapFilterType::New(); colormapper->UseInputImageExtremaForScalingOff(); - typedef otb::Functor::ReliefColormapFunctor<PixelType, RGBPixelType> ColorMapFunctorType; - ColorMapFunctorType::Pointer colormap = ColorMapFunctorType::New(); + using ColorMapFunctorType = otb::Functor::ReliefColormapFunctor<PixelType, RGBPixelType>; + ColorMapFunctorType::Pointer colormap = ColorMapFunctorType::New(); colormap->SetMinimumInputValue(0); colormap->SetMaximumInputValue(4000); colormapper->SetColormap(colormap); colormapper->SetInput(demToImage->GetOutput()); - typedef itk::BinaryFunctorImageFilter<RGBImageType, ImageType, RGBImageType, otb::Functor::HillShadeModulationFunctor<RGBPixelType, PixelType, RGBPixelType>> - MultiplyFilterType; + using MultiplyFilterType = + itk::BinaryFunctorImageFilter<RGBImageType, ImageType, RGBImageType, otb::Functor::HillShadeModulationFunctor<RGBPixelType, PixelType, RGBPixelType>>; MultiplyFilterType::Pointer multiply = MultiplyFilterType::New(); multiply->SetInput1(colormapper->GetOutput()); diff --git a/Examples/BasicFilters/IndexedToRGBExample.cxx b/Examples/BasicFilters/IndexedToRGBExample.cxx index d7a8226949d33aa41c6e1a43f8c0ed00dc8f453b..05a1e15beef40eb1208765e8177d40f25f27d721 100644 --- a/Examples/BasicFilters/IndexedToRGBExample.cxx +++ b/Examples/BasicFilters/IndexedToRGBExample.cxx @@ -43,37 +43,37 @@ int main(int argc, char* argv[]) const char* outputRGBFilename = argv[2]; const char* outputScaledFilename = argv[3]; - typedef otb::Image<unsigned long, 2> ImageType; - typedef otb::Image<itk::RGBPixel<unsigned char>, 2> RGBImageType; + using ImageType = otb::Image<unsigned long, 2>; + using RGBImageType = otb::Image<itk::RGBPixel<unsigned char>, 2>; - typedef otb::ImageFileReader<ImageType> ReaderType; - ReaderType::Pointer reader = ReaderType::New(); + using ReaderType = otb::ImageFileReader<ImageType>; + ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputFilename); // The UnaryFunctorImageFilter is the filter in charge of calling the functor // we specify to do the work for each pixel. Here it is the ScalarToRGBPixelFunctor - typedef itk::Functor::ScalarToRGBPixelFunctor<unsigned long> ColorMapFunctorType; - typedef itk::UnaryFunctorImageFilter<ImageType, RGBImageType, ColorMapFunctorType> ColorMapFilterType; - ColorMapFilterType::Pointer colormapper = ColorMapFilterType::New(); + using ColorMapFunctorType = itk::Functor::ScalarToRGBPixelFunctor<unsigned long>; + using ColorMapFilterType = itk::UnaryFunctorImageFilter<ImageType, RGBImageType, ColorMapFunctorType>; + ColorMapFilterType::Pointer colormapper = ColorMapFilterType::New(); colormapper->SetInput(reader->GetOutput()); - typedef otb::ImageFileWriter<RGBImageType> WriterType; - WriterType::Pointer writer = WriterType::New(); + using WriterType = otb::ImageFileWriter<RGBImageType>; + WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outputRGBFilename); writer->SetInput(colormapper->GetOutput()); writer->Update(); // The following is just to produce the input image for the software guide - typedef otb::Image<unsigned char, 2> OutputImageType; - typedef itk::RescaleIntensityImageFilter<ImageType, OutputImageType> RescalerType; - RescalerType::Pointer rescaler = RescalerType::New(); + using OutputImageType = otb::Image<unsigned char, 2>; + using RescalerType = itk::RescaleIntensityImageFilter<ImageType, OutputImageType>; + RescalerType::Pointer rescaler = RescalerType::New(); rescaler->SetInput(reader->GetOutput()); - typedef otb::ImageFileWriter<OutputImageType> UCharWriterType; - UCharWriterType::Pointer writer2 = UCharWriterType::New(); + using UCharWriterType = otb::ImageFileWriter<OutputImageType>; + UCharWriterType::Pointer writer2 = UCharWriterType::New(); writer2->SetFileName(outputScaledFilename); writer2->SetInput(rescaler->GetOutput()); writer2->Update(); diff --git a/Examples/BasicFilters/LeeImageFilter.cxx b/Examples/BasicFilters/LeeImageFilter.cxx index d8c7aa947db0bbde16790f0024a444c1deb3c40c..2a1be0839fe8791fc725abd74a43455b1d46dd04 100644 --- a/Examples/BasicFilters/LeeImageFilter.cxx +++ b/Examples/BasicFilters/LeeImageFilter.cxx @@ -38,22 +38,22 @@ int main(int argc, char* argv[]) return EXIT_FAILURE; } - typedef unsigned char PixelType; + using PixelType = unsigned char; // The images are defined using the pixel type and the dimension. - typedef otb::Image<PixelType, 2> InputImageType; - typedef otb::Image<PixelType, 2> OutputImageType; + using InputImageType = otb::Image<PixelType, 2>; + using OutputImageType = otb::Image<PixelType, 2>; // The filter can be instantiated using the image types defined above. - typedef otb::LeeImageFilter<InputImageType, OutputImageType> FilterType; + using FilterType = otb::LeeImageFilter<InputImageType, OutputImageType>; // An ImageFileReader class is also instantiated in order to read // image data from a file. - typedef otb::ImageFileReader<InputImageType> ReaderType; + using ReaderType = otb::ImageFileReader<InputImageType>; // An ImageFileWriter is instantiated in order to write the // output image to a file. - typedef otb::ImageFileWriter<OutputImageType> WriterType; + using WriterType = otb::ImageFileWriter<OutputImageType>; // Both the filter and the reader are created by invoking their New() // methods and assigning the result to SmartPointers. diff --git a/Examples/BasicFilters/MeanShiftSegmentationFilterExample.cxx b/Examples/BasicFilters/MeanShiftSegmentationFilterExample.cxx index 9e665a35f21b216bc11ea6f433a1534233ee0f5e..ce3897a3a3c5a489e9858816c15281d07b9cc4da 100644 --- a/Examples/BasicFilters/MeanShiftSegmentationFilterExample.cxx +++ b/Examples/BasicFilters/MeanShiftSegmentationFilterExample.cxx @@ -63,19 +63,19 @@ int main(int argc, char* argv[]) const unsigned int Dimension = 2; - typedef float PixelType; - typedef unsigned int LabelPixelType; - typedef itk::RGBPixel<unsigned char> ColorPixelType; + using PixelType = float; + using LabelPixelType = unsigned int; + using ColorPixelType = itk::RGBPixel<unsigned char>; - typedef otb::VectorImage<PixelType, Dimension> ImageType; - typedef otb::Image<LabelPixelType, Dimension> LabelImageType; - typedef otb::Image<ColorPixelType, Dimension> RGBImageType; + using ImageType = otb::VectorImage<PixelType, Dimension>; + using LabelImageType = otb::Image<LabelPixelType, Dimension>; + using RGBImageType = otb::Image<ColorPixelType, Dimension>; - typedef otb::ImageFileReader<ImageType> ReaderType; - typedef otb::ImageFileWriter<ImageType> WriterType; - typedef otb::ImageFileWriter<LabelImageType> LabelWriterType; + using ReaderType = otb::ImageFileReader<ImageType>; + using WriterType = otb::ImageFileWriter<ImageType>; + using LabelWriterType = otb::ImageFileWriter<LabelImageType>; - typedef otb::MeanShiftSegmentationFilter<ImageType, LabelImageType, ImageType> FilterType; + using FilterType = otb::MeanShiftSegmentationFilter<ImageType, LabelImageType, ImageType>; // We instantiate the filter, the reader, and 2 writers (for the // labeled and clustered images). @@ -118,15 +118,15 @@ int main(int argc, char* argv[]) writer1->Update(); writer2->Update(); - typedef otb::PrintableImageFilter<ImageType> PrintableFilterType; - PrintableFilterType::Pointer printableImageFilter = PrintableFilterType::New(); + using PrintableFilterType = otb::PrintableImageFilter<ImageType>; + PrintableFilterType::Pointer printableImageFilter = PrintableFilterType::New(); printableImageFilter->SetChannel(1); printableImageFilter->SetChannel(2); printableImageFilter->SetChannel(3); - typedef PrintableFilterType::OutputImageType OutputImageType; - typedef otb::ImageFileWriter<OutputImageType> PrettyWriterType; + using OutputImageType = PrintableFilterType::OutputImageType; + using PrettyWriterType = otb::ImageFileWriter<OutputImageType>; PrettyWriterType::Pointer prettyWriter = PrettyWriterType::New(); @@ -135,14 +135,14 @@ int main(int argc, char* argv[]) prettyWriter->SetInput(printableImageFilter->GetOutput()); prettyWriter->Update(); - typedef otb::ImageFileWriter<RGBImageType> LabelRGBWriterType; + using LabelRGBWriterType = otb::ImageFileWriter<RGBImageType>; LabelRGBWriterType::Pointer labelRGBWriter = LabelRGBWriterType::New(); // Label to RGB image - typedef itk::Functor::ScalarToRGBPixelFunctor<LabelPixelType> FunctorType; - typedef itk::UnaryFunctorImageFilter<LabelImageType, RGBImageType, FunctorType> ColorLabelFilterType; - ColorLabelFilterType::Pointer labelToRGB = ColorLabelFilterType::New(); + using FunctorType = itk::Functor::ScalarToRGBPixelFunctor<LabelPixelType>; + using ColorLabelFilterType = itk::UnaryFunctorImageFilter<LabelImageType, RGBImageType, FunctorType>; + ColorLabelFilterType::Pointer labelToRGB = ColorLabelFilterType::New(); labelToRGB->SetInput(filter->GetLabelOutput()); diff --git a/Examples/BasicFilters/PrintableImageFilterExample.cxx b/Examples/BasicFilters/PrintableImageFilterExample.cxx index f632da523ccbc7faa000df846524fe12d88f3f65..cdbc271d4288e145c460fdf8b62af3c0e76cf26a 100644 --- a/Examples/BasicFilters/PrintableImageFilterExample.cxx +++ b/Examples/BasicFilters/PrintableImageFilterExample.cxx @@ -50,20 +50,20 @@ int main(int argc, char* argv[]) int greenChannelNumber = atoi(argv[4]); int blueChannelNumber = atoi(argv[5]); - typedef double InputPixelType; + using InputPixelType = double; const unsigned int Dimension = 2; - typedef otb::VectorImage<InputPixelType, Dimension> InputImageType; + using InputImageType = otb::VectorImage<InputPixelType, Dimension>; - typedef otb::ImageFileReader<InputImageType> ReaderType; + using ReaderType = otb::ImageFileReader<InputImageType>; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(inputFilename); // To easily convert the image to a printable format, i.e. 3 bands // unsigned char value, you can use the PrintableImageFilter. - typedef otb::PrintableImageFilter<InputImageType> PrintableFilterType; - PrintableFilterType::Pointer printableImageFilter = PrintableFilterType::New(); + using PrintableFilterType = otb::PrintableImageFilter<InputImageType>; + PrintableFilterType::Pointer printableImageFilter = PrintableFilterType::New(); printableImageFilter->SetInput(reader->GetOutput()); printableImageFilter->SetChannel(redChannelNumber); @@ -72,8 +72,8 @@ int main(int argc, char* argv[]) // When you create the writer to plug at the output of the printableImageFilter // you may want to use the direct type definition as it is a good way to avoid mismatch: - typedef PrintableFilterType::OutputImageType OutputImageType; - typedef otb::ImageFileWriter<OutputImageType> WriterType; + using OutputImageType = PrintableFilterType::OutputImageType; + using WriterType = otb::ImageFileWriter<OutputImageType>; WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outputFilename); diff --git a/Examples/BasicFilters/ScalingFilterExample.cxx b/Examples/BasicFilters/ScalingFilterExample.cxx index feef4ec7231e8f0e1a456196a52b04e59daa7f1e..adf2ff204c94daef7cbab0fba80986234a1aea33 100644 --- a/Examples/BasicFilters/ScalingFilterExample.cxx +++ b/Examples/BasicFilters/ScalingFilterExample.cxx @@ -40,28 +40,28 @@ int main(int argc, char* argv[]) return EXIT_FAILURE; } - typedef unsigned short InputPixelType; - typedef unsigned char OutputPixelType; - typedef otb::Image<InputPixelType, 2> InputImageType; - typedef otb::Image<OutputPixelType, 2> OutputImageType; + using InputPixelType = unsigned short; + using OutputPixelType = unsigned char; + using InputImageType = otb::Image<InputPixelType, 2>; + using OutputImageType = otb::Image<OutputPixelType, 2>; - typedef otb::ImageFileReader<InputImageType> ReaderType; - ReaderType::Pointer reader = ReaderType::New(); + using ReaderType = otb::ImageFileReader<InputImageType>; + ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(argv[1]); // The RescaleIntensityImageFilter is used to rescale the value - typedef itk::RescaleIntensityImageFilter<InputImageType, OutputImageType> RescalerType; - RescalerType::Pointer rescaler = RescalerType::New(); + using RescalerType = itk::RescaleIntensityImageFilter<InputImageType, OutputImageType>; + RescalerType::Pointer rescaler = RescalerType::New(); rescaler->SetInput(reader->GetOutput()); - typedef otb::ImageFileWriter<OutputImageType> WriterType; - WriterType::Pointer writer = WriterType::New(); + using WriterType = otb::ImageFileWriter<OutputImageType>; + WriterType::Pointer writer = WriterType::New(); writer->SetFileName(argv[2]); writer->SetInput(rescaler->GetOutput()); writer->Update(); - typedef itk::CastImageFilter<InputImageType, OutputImageType> CasterType; - CasterType::Pointer caster = CasterType::New(); + using CasterType = itk::CastImageFilter<InputImageType, OutputImageType>; + CasterType::Pointer caster = CasterType::New(); caster->SetInput(reader->GetOutput()); writer->SetFileName(argv[3]); diff --git a/Examples/ChangeDetection/CorrelChDet.cxx b/Examples/ChangeDetection/CorrelChDet.cxx index 7c2b4773384fa9bcd9cb85d2725da329bf6bf166..c590f049265e66a372de96885bb6ca1a8b179ecd 100644 --- a/Examples/ChangeDetection/CorrelChDet.cxx +++ b/Examples/ChangeDetection/CorrelChDet.cxx @@ -66,12 +66,12 @@ int main(int argc, char* argv[]) // We start by declaring the types for the two input images, the // change image and the image to be stored in a file for visualization. - typedef float InternalPixelType; - typedef unsigned char OutputPixelType; - typedef otb::Image<InternalPixelType, Dimension> InputImageType1; - typedef otb::Image<InternalPixelType, Dimension> InputImageType2; - typedef otb::Image<InternalPixelType, Dimension> ChangeImageType; - typedef otb::Image<OutputPixelType, Dimension> OutputImageType; + using InternalPixelType = float; + using OutputPixelType = unsigned char; + using InputImageType1 = otb::Image<InternalPixelType, Dimension>; + using InputImageType2 = otb::Image<InternalPixelType, Dimension>; + using ChangeImageType = otb::Image<InternalPixelType, Dimension>; + using OutputImageType = otb::Image<OutputPixelType, Dimension>; // We can now declare the types for the readers. Since the images // can be vey large, we will force the pipeline to use @@ -79,9 +79,9 @@ int main(int argc, char* argv[]) // streamed. This is achieved by using the // \doxygen{otb}{ImageFileWriter} class. - typedef otb::ImageFileReader<InputImageType1> ReaderType1; - typedef otb::ImageFileReader<InputImageType2> ReaderType2; - typedef otb::ImageFileWriter<OutputImageType> WriterType; + using ReaderType1 = otb::ImageFileReader<InputImageType1>; + using ReaderType2 = otb::ImageFileReader<InputImageType2>; + using WriterType = otb::ImageFileWriter<OutputImageType>; // The change detector will give a response which is normalized // between 0 and 1. Before @@ -89,13 +89,13 @@ int main(int argc, char* argv[]) // rescale the results of the change detection in order to use all // the output pixel type range of values. - typedef itk::ShiftScaleImageFilter<ChangeImageType, OutputImageType> RescalerType; + using RescalerType = itk::ShiftScaleImageFilter<ChangeImageType, OutputImageType>; // The \doxygen{otb}{CorrelationChangeDetector} is templated over // the types of the two input images and the type of the generated change // image. - typedef otb::CorrelationChangeDetector<InputImageType1, InputImageType2, ChangeImageType> FilterType; + using FilterType = otb::CorrelationChangeDetector<InputImageType1, InputImageType2, ChangeImageType>; // The different elements of the pipeline can now be instantiated. @@ -134,7 +134,7 @@ int main(int argc, char* argv[]) // command/observer design pattern. This is easily done by // attaching an observer to the filter. - typedef otb::CommandProgressUpdate<FilterType> CommandType; + using CommandType = otb::CommandProgressUpdate<FilterType>; CommandType::Pointer observer = CommandType::New(); filter->AddObserver(itk::ProgressEvent(), observer); diff --git a/Examples/ChangeDetection/DiffChDet.cxx b/Examples/ChangeDetection/DiffChDet.cxx index f28fc422fd89415e40ca9c15f826d4ad1cb492b5..8fab7fcfb1a50470d278325c1883d174d045ab13 100644 --- a/Examples/ChangeDetection/DiffChDet.cxx +++ b/Examples/ChangeDetection/DiffChDet.cxx @@ -70,19 +70,19 @@ int main(int argc, char* argv[]) // We start by declaring the types for the two input images, the // change image and the image to be stored in a file for visualization. - typedef float InternalPixelType; - typedef unsigned char OutputPixelType; - typedef otb::Image<InternalPixelType, Dimension> InputImageType1; - typedef otb::Image<InternalPixelType, Dimension> InputImageType2; - typedef otb::Image<InternalPixelType, Dimension> ChangeImageType; - typedef otb::Image<OutputPixelType, Dimension> OutputImageType; + using InternalPixelType = float; + using OutputPixelType = unsigned char; + using InputImageType1 = otb::Image<InternalPixelType, Dimension>; + using InputImageType2 = otb::Image<InternalPixelType, Dimension>; + using ChangeImageType = otb::Image<InternalPixelType, Dimension>; + using OutputImageType = otb::Image<OutputPixelType, Dimension>; // We can now declare the types for the readers and the writer. - typedef otb::ImageFileReader<InputImageType1> ReaderType1; - typedef otb::ImageFileReader<InputImageType2> ReaderType2; - typedef otb::ImageFileWriter<OutputImageType> WriterType; + using ReaderType1 = otb::ImageFileReader<InputImageType1>; + using ReaderType2 = otb::ImageFileReader<InputImageType2>; + using WriterType = otb::ImageFileWriter<OutputImageType>; // The change detector will give positive and negative values // depending on the sign of the difference. We are usually @@ -92,15 +92,15 @@ int main(int argc, char* argv[]) // rescale the results of the change detection in order to use the full range // of values of the output pixel type. - typedef itk::AbsImageFilter<ChangeImageType, ChangeImageType> AbsType; - typedef itk::RescaleIntensityImageFilter<ChangeImageType, OutputImageType> RescalerType; + using AbsType = itk::AbsImageFilter<ChangeImageType, ChangeImageType>; + using RescalerType = itk::RescaleIntensityImageFilter<ChangeImageType, OutputImageType>; // The \doxygen{otb}{MeanDifferenceImageFilter} is templated over // the types of the two input images and the type of the generated change // image. - typedef otb::MeanDifferenceImageFilter<InputImageType1, InputImageType2, ChangeImageType> FilterType; + using FilterType = otb::MeanDifferenceImageFilter<InputImageType1, InputImageType2, ChangeImageType>; // The different elements of the pipeline can now be instantiated. @@ -142,7 +142,7 @@ int main(int argc, char* argv[]) // command/observer design pattern. This is easily done by // attaching an observer to the filter. - typedef otb::CommandProgressUpdate<FilterType> CommandType; + using CommandType = otb::CommandProgressUpdate<FilterType>; CommandType::Pointer observer = CommandType::New(); filter->AddObserver(itk::ProgressEvent(), observer); diff --git a/Examples/ChangeDetection/KullbackLeiblerDistanceChDet.cxx b/Examples/ChangeDetection/KullbackLeiblerDistanceChDet.cxx index e60b6c1b80bf5a27d3896ec94bbc7dbf785e6e33..696c6fd378d989e6e698fc7bfe7059b99aa5ec45 100644 --- a/Examples/ChangeDetection/KullbackLeiblerDistanceChDet.cxx +++ b/Examples/ChangeDetection/KullbackLeiblerDistanceChDet.cxx @@ -99,12 +99,12 @@ int main(int argc, char* argv[]) char* fileNameOut = argv[3]; int winSize = atoi(argv[4]); - const unsigned int Dimension = 2; - typedef double PixelType; - typedef unsigned char OutputPixelType; + const unsigned int Dimension = 2; + using PixelType = double; + using OutputPixelType = unsigned char; - typedef otb::Image<PixelType, Dimension> ImageType; - typedef otb::Image<OutputPixelType, Dimension> OutputImageType; + using ImageType = otb::Image<PixelType, Dimension>; + using OutputImageType = otb::Image<OutputPixelType, Dimension>; // The \doxygen{otb}{KullbackLeiblerDistanceImageFilter} is templated over // the types of the two input images and the type of the generated change @@ -113,13 +113,13 @@ int main(int argc, char* argv[]) // example to perform a change detection through a distance between // distributions... - typedef otb::KullbackLeiblerDistanceImageFilter<ImageType, ImageType, ImageType> FilterType; + using FilterType = otb::KullbackLeiblerDistanceImageFilter<ImageType, ImageType, ImageType>; // The different elements of the pipeline can now be instantiated. Follow the // ratio of means change detector example. - typedef otb::ImageFileReader<ImageType> ReaderType; - typedef otb::ImageFileWriter<OutputImageType> WriterType; + using ReaderType = otb::ImageFileReader<ImageType>; + using WriterType = otb::ImageFileWriter<OutputImageType>; ReaderType::Pointer reader1 = ReaderType::New(); reader1->SetFileName(fileName1); @@ -138,8 +138,8 @@ int main(int argc, char* argv[]) filter->SetInput1(reader1->GetOutput()); filter->SetInput2(reader2->GetOutput()); - typedef itk::RescaleIntensityImageFilter<ImageType, OutputImageType> RescaleFilterType; - RescaleFilterType::Pointer rescaler = RescaleFilterType::New(); + using RescaleFilterType = itk::RescaleIntensityImageFilter<ImageType, OutputImageType>; + RescaleFilterType::Pointer rescaler = RescaleFilterType::New(); rescaler->SetInput(filter->GetOutput()); rescaler->SetOutputMinimum(0); diff --git a/Examples/ChangeDetection/KullbackLeiblerProfileChDet.cxx b/Examples/ChangeDetection/KullbackLeiblerProfileChDet.cxx index 2ec5e68636b69367b6e8d7a9609ff6a5ac5f17ef..b9aafd624e3c9116ab778dc55ab1e312dd5049ea 100644 --- a/Examples/ChangeDetection/KullbackLeiblerProfileChDet.cxx +++ b/Examples/ChangeDetection/KullbackLeiblerProfileChDet.cxx @@ -68,24 +68,24 @@ int main(int argc, char* argv[]) unsigned int gi = atoi(argv[7]); unsigned int bi = atoi(argv[8]); - const unsigned int Dimension = 2; - typedef double PixelType; - typedef unsigned char OutPixelType; + const unsigned int Dimension = 2; + using PixelType = double; + using OutPixelType = unsigned char; // The \doxygen{otb}{KullbackLeiblerProfileImageFilter} is templated over // the types of the two input images and the type of the generated change // image (which is now of multi-components), in a similar way as the // \doxygen{otb}{KullbackLeiblerDistanceImageFilter}. - typedef otb::Image<PixelType, Dimension> ImageType; - typedef otb::VectorImage<PixelType, Dimension> VectorImageType; - typedef otb::KullbackLeiblerProfileImageFilter<ImageType, ImageType, VectorImageType> FilterType; + using ImageType = otb::Image<PixelType, Dimension>; + using VectorImageType = otb::VectorImage<PixelType, Dimension>; + using FilterType = otb::KullbackLeiblerProfileImageFilter<ImageType, ImageType, VectorImageType>; - typedef otb::VectorImage<OutPixelType, Dimension> OutVectorImageType; - typedef otb::ImageFileReader<ImageType> ReaderType; - typedef otb::ImageFileWriter<OutVectorImageType> WriterType; - typedef otb::MultiChannelExtractROI<PixelType, PixelType> ChannelSelecterType; - typedef otb::VectorRescaleIntensityImageFilter<VectorImageType, OutVectorImageType> RescalerType; + using OutVectorImageType = otb::VectorImage<OutPixelType, Dimension>; + using ReaderType = otb::ImageFileReader<ImageType>; + using WriterType = otb::ImageFileWriter<OutVectorImageType>; + using ChannelSelecterType = otb::MultiChannelExtractROI<PixelType, PixelType>; + using RescalerType = otb::VectorRescaleIntensityImageFilter<VectorImageType, OutVectorImageType>; ReaderType::Pointer reader1 = ReaderType::New(); reader1->SetFileName(fileName1); diff --git a/Examples/ChangeDetection/MultivariateAlterationDetector.cxx b/Examples/ChangeDetection/MultivariateAlterationDetector.cxx index 3a2f9cb7640b3e9523c77628d0908401699ff232..e11b76142e0aa494f0ed2cd51b5dbad15778e664 100644 --- a/Examples/ChangeDetection/MultivariateAlterationDetector.cxx +++ b/Examples/ChangeDetection/MultivariateAlterationDetector.cxx @@ -80,10 +80,10 @@ int main(int argc, char* argv[]) // We then define the types for the input images and for the // change image. - typedef unsigned short InputPixelType; - typedef float OutputPixelType; - typedef otb::VectorImage<InputPixelType, Dimension> InputImageType; - typedef otb::VectorImage<OutputPixelType, Dimension> OutputImageType; + using InputPixelType = unsigned short; + using OutputPixelType = float; + using InputImageType = otb::VectorImage<InputPixelType, Dimension>; + using OutputImageType = otb::VectorImage<OutputPixelType, Dimension>; // We can now declare the types for the reader. Since the images // can be vey large, we will force the pipeline to use @@ -91,21 +91,21 @@ int main(int argc, char* argv[]) // streamed. This is achieved by using the // \doxygen{otb}{ImageFileWriter} class. - typedef otb::ImageFileReader<InputImageType> ReaderType; - typedef otb::ImageFileWriter<OutputImageType> WriterType; + using ReaderType = otb::ImageFileReader<InputImageType>; + using WriterType = otb::ImageFileWriter<OutputImageType>; // This is for rendering in software guide - typedef otb::PrintableImageFilter<InputImageType, InputImageType> InputPrintFilterType; - typedef otb::PrintableImageFilter<OutputImageType, OutputImageType> OutputPrintFilterType; - typedef InputPrintFilterType::OutputImageType VisuImageType; - typedef otb::ImageFileWriter<VisuImageType> VisuWriterType; + using InputPrintFilterType = otb::PrintableImageFilter<InputImageType, InputImageType>; + using OutputPrintFilterType = otb::PrintableImageFilter<OutputImageType, OutputImageType>; + using VisuImageType = InputPrintFilterType::OutputImageType; + using VisuWriterType = otb::ImageFileWriter<VisuImageType>; // The \doxygen{otb}{MultivariateAlterationDetectorImageFilter} is templated over // the type of the input images and the type of the generated change // image. - typedef otb::MultivariateAlterationDetectorImageFilter<InputImageType, OutputImageType> MADFilterType; + using MADFilterType = otb::MultivariateAlterationDetectorImageFilter<InputImageType, OutputImageType>; // The different elements of the pipeline can now be instantiated. diff --git a/Examples/ChangeDetection/RatioChDet.cxx b/Examples/ChangeDetection/RatioChDet.cxx index c12ffa03b09a090e36cc18ebfdf5c3f96d9fad84..e0ea00a98632de7404324d7b731408c23c929f3b 100644 --- a/Examples/ChangeDetection/RatioChDet.cxx +++ b/Examples/ChangeDetection/RatioChDet.cxx @@ -73,12 +73,12 @@ int main(int argc, char* argv[]) // We start by declaring the types for the two input images, the // change image and the image to be stored in a file for visualization. - typedef float InternalPixelType; - typedef unsigned char OutputPixelType; - typedef otb::Image<InternalPixelType, Dimension> InputImageType1; - typedef otb::Image<InternalPixelType, Dimension> InputImageType2; - typedef otb::Image<InternalPixelType, Dimension> ChangeImageType; - typedef otb::Image<OutputPixelType, Dimension> OutputImageType; + using InternalPixelType = float; + using OutputPixelType = unsigned char; + using InputImageType1 = otb::Image<InternalPixelType, Dimension>; + using InputImageType2 = otb::Image<InternalPixelType, Dimension>; + using ChangeImageType = otb::Image<InternalPixelType, Dimension>; + using OutputImageType = otb::Image<OutputPixelType, Dimension>; // We can now declare the types for the readers. Since the images // can be vey large, we will force the pipeline to use @@ -86,9 +86,9 @@ int main(int argc, char* argv[]) // streamed. This is achieved by using the // \doxygen{otb}{ImageFileWriter} class. - typedef otb::ImageFileReader<InputImageType1> ReaderType1; - typedef otb::ImageFileReader<InputImageType2> ReaderType2; - typedef otb::ImageFileWriter<OutputImageType> WriterType; + using ReaderType1 = otb::ImageFileReader<InputImageType1>; + using ReaderType2 = otb::ImageFileReader<InputImageType2>; + using WriterType = otb::ImageFileWriter<OutputImageType>; // The change detector will give a normalized result between 0 and @@ -96,14 +96,14 @@ int main(int argc, char* argv[]) // rescale the results of the change detection in order to use all // the output pixel type range of values. - typedef itk::ShiftScaleImageFilter<ChangeImageType, OutputImageType> RescalerType; + using RescalerType = itk::ShiftScaleImageFilter<ChangeImageType, OutputImageType>; // The \doxygen{otb}{MeanRatioImageFilter} is templated over // the types of the two input images and the type of the generated change // image. - typedef otb::MeanRatioImageFilter<InputImageType1, InputImageType2, ChangeImageType> FilterType; + using FilterType = otb::MeanRatioImageFilter<InputImageType1, InputImageType2, ChangeImageType>; // The different elements of the pipeline can now be instantiated. @@ -138,7 +138,7 @@ int main(int argc, char* argv[]) rescaler->SetInput(filter->GetOutput()); writer->SetInput(rescaler->GetOutput()); - typedef otb::CommandProgressUpdate<FilterType> CommandType; + using CommandType = otb::CommandProgressUpdate<FilterType>; CommandType::Pointer observer = CommandType::New(); filter->AddObserver(itk::ProgressEvent(), observer); diff --git a/Examples/Classification/ClassificationMapRegularizationExample.cxx b/Examples/Classification/ClassificationMapRegularizationExample.cxx index 7fa37401fc4f8dcd789e0d85128927cbc2fd11f3..7c0c0aa1cd8ba906c3163c8a95c815f87113f2ac 100644 --- a/Examples/Classification/ClassificationMapRegularizationExample.cxx +++ b/Examples/Classification/ClassificationMapRegularizationExample.cxx @@ -47,14 +47,14 @@ int main(int itkNotUsed(argc), char* argv[]) // single band input image for which each pixel value is a label coded // on 8 bits as an integer between 0 and 255. - typedef unsigned char IOLabelPixelType; // 8 bits - const unsigned int Dimension = 2; + using IOLabelPixelType = unsigned char; // 8 bits + const unsigned int Dimension = 2; // Thus, both input and output images are single band labeled images, // which are composed of the same type of pixels in this example // (unsigned char). - typedef otb::Image<IOLabelPixelType, Dimension> IOLabelImageType; + using IOLabelImageType = otb::Image<IOLabelPixelType, Dimension>; // We can now define the type for the neighborhood majority voting filter, @@ -65,7 +65,7 @@ int main(int itkNotUsed(argc), char* argv[]) // (\doxygen{itk}{BinaryBallStructuringElement}). // Neighborhood majority voting filter type - typedef otb::NeighborhoodMajorityVotingImageFilter<IOLabelImageType> NeighborhoodMajorityVotingFilterType; + using NeighborhoodMajorityVotingFilterType = otb::NeighborhoodMajorityVotingImageFilter<IOLabelImageType>; // Since the \doxygen{otb}{NeighborhoodMajorityVotingImageFilter} is a @@ -77,14 +77,14 @@ int main(int itkNotUsed(argc), char* argv[]) // structuring elements such as ovals. // Binary ball Structuring Element type - typedef NeighborhoodMajorityVotingFilterType::KernelType StructuringType; - typedef StructuringType::RadiusType RadiusType; + using StructuringType = NeighborhoodMajorityVotingFilterType::KernelType; + using RadiusType = StructuringType::RadiusType; // Finally, we define the reader and the writer. - typedef otb::ImageFileReader<IOLabelImageType> ReaderType; - typedef otb::ImageFileWriter<IOLabelImageType> WriterType; + using ReaderType = otb::ImageFileReader<IOLabelImageType>; + using WriterType = otb::ImageFileWriter<IOLabelImageType>; const char* inputFileName = argv[1]; diff --git a/Examples/Classification/DempsterShaferFusionOfClassificationMapsExample.cxx b/Examples/Classification/DempsterShaferFusionOfClassificationMapsExample.cxx index c9cc0a0a5f4a83e2c84af9e3f01d4bb0cc650bfc..ccc074120467118fc701d3ecdbe7c147ff60bede 100644 --- a/Examples/Classification/DempsterShaferFusionOfClassificationMapsExample.cxx +++ b/Examples/Classification/DempsterShaferFusionOfClassificationMapsExample.cxx @@ -47,11 +47,11 @@ // into masses of belief for each class label. -typedef unsigned short LabelPixelType; -typedef unsigned long ConfusionMatrixEltType; -typedef itk::VariableSizeMatrix<ConfusionMatrixEltType> ConfusionMatrixType; -typedef otb::ConfusionMatrixToMassOfBelief<ConfusionMatrixType, LabelPixelType> ConfusionMatrixToMassOfBeliefType; -typedef ConfusionMatrixToMassOfBeliefType::MapOfClassesType MapOfClassesType; +using LabelPixelType = unsigned short; +using ConfusionMatrixEltType = unsigned long; +using ConfusionMatrixType = itk::VariableSizeMatrix<ConfusionMatrixEltType>; +using ConfusionMatrixToMassOfBeliefType = otb::ConfusionMatrixToMassOfBelief<ConfusionMatrixType, LabelPixelType>; +using MapOfClassesType = ConfusionMatrixToMassOfBeliefType::MapOfClassesType; int CSVConfusionMatrixFileReader(const std::string fileName, MapOfClassesType& mapOfClassesRefClX, ConfusionMatrixType& confusionMatrixClX) @@ -163,9 +163,9 @@ int CSVConfusionMatrixFileReader(const std::string fileName, MapOfClassesType& m int main(int argc, char* argv[]) { // The input labeled images to be fused are expected to be scalar images. - const unsigned int Dimension = 2; - typedef otb::Image<LabelPixelType, Dimension> LabelImageType; - typedef otb::VectorImage<LabelPixelType, Dimension> VectorImageType; + const unsigned int Dimension = 2; + using LabelImageType = otb::Image<LabelPixelType, Dimension>; + using VectorImageType = otb::VectorImage<LabelPixelType, Dimension>; LabelPixelType nodataLabel = atoi(argv[argc - 3]); LabelPixelType undecidedLabel = atoi(argv[argc - 2]); @@ -178,23 +178,23 @@ int main(int argc, char* argv[]) // input classification maps to be fused as a single VectorImage for which each // band is a classification map. This VectorImage will then be the input of the // Dempster Shafer fusion filter \doxygen{otb}{DSFusionOfClassifiersImageFilter}. - typedef otb::ImageList<LabelImageType> LabelImageListType; - typedef otb::ImageListToVectorImageFilter<LabelImageListType, VectorImageType> ImageListToVectorImageFilterType; + using LabelImageListType = otb::ImageList<LabelImageType>; + using ImageListToVectorImageFilterType = otb::ImageListToVectorImageFilter<LabelImageListType, VectorImageType>; - typedef ConfusionMatrixToMassOfBeliefType::MassOfBeliefDefinitionMethod MassOfBeliefDefinitionMethod; + using MassOfBeliefDefinitionMethod = ConfusionMatrixToMassOfBeliefType::MassOfBeliefDefinitionMethod; // The Dempster Shafer fusion filter \doxygen{otb}{DSFusionOfClassifiersImageFilter} is declared. // Dempster Shafer - typedef otb::DSFusionOfClassifiersImageFilter<VectorImageType, LabelImageType> DSFusionOfClassifiersImageFilterType; + using DSFusionOfClassifiersImageFilterType = otb::DSFusionOfClassifiersImageFilter<VectorImageType, LabelImageType>; - typedef DSFusionOfClassifiersImageFilterType::VectorOfMapOfMassesOfBeliefType VectorOfMapOfMassesOfBeliefType; + using VectorOfMapOfMassesOfBeliefType = DSFusionOfClassifiersImageFilterType::VectorOfMapOfMassesOfBeliefType; // Both reader and writer are defined. Since the images // to classify can be very big, we will use a streamed writer which // will trigger the streaming ability of the fusion filter. - typedef otb::ImageFileReader<LabelImageType> ReaderType; - typedef otb::ImageFileWriter<LabelImageType> WriterType; + using ReaderType = otb::ImageFileReader<LabelImageType>; + using WriterType = otb::ImageFileWriter<LabelImageType>; // The image list of input classification maps is filled. Moreover, the input diff --git a/Examples/Classification/SOMImageClassificationExample.cxx b/Examples/Classification/SOMImageClassificationExample.cxx index 17ef8efc1c9fd5cc4d47ee6529b7d7d91459d991..9155a235caccbd61588e182c2637948af69a4267 100644 --- a/Examples/Classification/SOMImageClassificationExample.cxx +++ b/Examples/Classification/SOMImageClassificationExample.cxx @@ -43,28 +43,28 @@ int main(int itkNotUsed(argc), char* argv[]) // We will assume double precision input images and will also define // the type for the labeled pixels. - const unsigned int Dimension = 2; - typedef double PixelType; - typedef unsigned short LabeledPixelType; + const unsigned int Dimension = 2; + using PixelType = double; + using LabeledPixelType = unsigned short; // Our classifier will be generic enough to be able to process images // with any number of bands. We read the images as // \doxygen{otb}{VectorImage}s. The labeled image will be a scalar image. - typedef otb::VectorImage<PixelType, Dimension> ImageType; - typedef otb::Image<LabeledPixelType, Dimension> LabeledImageType; + using ImageType = otb::VectorImage<PixelType, Dimension>; + using LabeledImageType = otb::Image<LabeledPixelType, Dimension>; // We can now define the type for the classifier filter, which is // templated over its input and output image types and the SOM type. - typedef otb::SOMMap<ImageType::PixelType> SOMMapType; - typedef otb::SOMImageClassificationFilter<ImageType, LabeledImageType, SOMMapType> ClassificationFilterType; + using SOMMapType = otb::SOMMap<ImageType::PixelType>; + using ClassificationFilterType = otb::SOMImageClassificationFilter<ImageType, LabeledImageType, SOMMapType>; // And finally, we define the readers (for the input image and theSOM) // and the writer. Since the images, // to classify can be very big, we will use a streamed writer which // will trigger the streaming ability of the classifier. - typedef otb::ImageFileReader<ImageType> ReaderType; - typedef otb::ImageFileReader<SOMMapType> SOMReaderType; - typedef otb::ImageFileWriter<LabeledImageType> WriterType; + using ReaderType = otb::ImageFileReader<ImageType>; + using SOMReaderType = otb::ImageFileReader<SOMMapType>; + using WriterType = otb::ImageFileWriter<LabeledImageType>; // We instantiate the classifier and the reader objects and we set // the existing SOM obtained in a previous training step. diff --git a/Examples/Classification/SupervisedImageClassificationExample.cxx b/Examples/Classification/SupervisedImageClassificationExample.cxx index d48f0678a6b536caee4d804e55403c58a0b492d6..3ccc92cf8e28fb41dd299085bce7b644912bcb92 100644 --- a/Examples/Classification/SupervisedImageClassificationExample.cxx +++ b/Examples/Classification/SupervisedImageClassificationExample.cxx @@ -49,30 +49,30 @@ int main(int itkNotUsed(argc), char* argv[]) // We will assume double precision input images and will also define // the type for the labeled pixels. - const unsigned int Dimension = 2; - typedef double PixelType; - typedef unsigned short LabeledPixelType; + const unsigned int Dimension = 2; + using PixelType = double; + using LabeledPixelType = unsigned short; // Our classifier is generic enough to be able to process images // with any number of bands. We read the input image as a // \doxygen{otb}{VectorImage}. The labeled image will be a scalar image. - typedef otb::VectorImage<PixelType, Dimension> ImageType; - typedef otb::Image<LabeledPixelType, Dimension> LabeledImageType; + using ImageType = otb::VectorImage<PixelType, Dimension>; + using LabeledImageType = otb::Image<LabeledPixelType, Dimension>; // We can now define the type for the classifier filter, which is // templated over its input and output image types. - typedef otb::ImageClassificationFilter<ImageType, LabeledImageType> ClassificationFilterType; - typedef ClassificationFilterType::ModelType ModelType; + using ClassificationFilterType = otb::ImageClassificationFilter<ImageType, LabeledImageType>; + using ModelType = ClassificationFilterType::ModelType; // Moreover, it is necessary to define a \doxygen{otb}{MachineLearningModelFactory} // which is templated over its input and output pixel types. This factory is used // to parse the input model file and to define which classification method to use. - typedef otb::MachineLearningModelFactory<PixelType, LabeledPixelType> MachineLearningModelFactoryType; + using MachineLearningModelFactoryType = otb::MachineLearningModelFactory<PixelType, LabeledPixelType>; // And finally, we define the reader and the writer. Since the images // to classify can be very big, we will use a streamed writer which // will trigger the streaming ability of the classifier. - typedef otb::ImageFileReader<ImageType> ReaderType; - typedef otb::ImageFileWriter<LabeledImageType> WriterType; + using ReaderType = otb::ImageFileReader<ImageType>; + using WriterType = otb::ImageFileWriter<LabeledImageType>; // We instantiate the classifier and the reader objects and we set // the existing model obtained in a previous training step. diff --git a/Examples/DimensionReduction/ICAExample.cxx b/Examples/DimensionReduction/ICAExample.cxx index 804950e6264c86a6adcd30363619d8773a4f1339..2d55be58dee76e9b7a38e7bcd4822e33f85057cd 100644 --- a/Examples/DimensionReduction/ICAExample.cxx +++ b/Examples/DimensionReduction/ICAExample.cxx @@ -57,7 +57,7 @@ int main(int itkNotUsed(argc), char* argv[]) { - typedef double PixelType; + using PixelType = double; const unsigned int Dimension = 2; const char* inputFileName = argv[1]; const char* outputFilename = argv[2]; @@ -74,9 +74,9 @@ int main(int itkNotUsed(argc), char* argv[]) // since we will produce a multi-channel image (the independent // components) from a multi-channel input image. - typedef otb::VectorImage<PixelType, Dimension> ImageType; - typedef otb::ImageFileReader<ImageType> ReaderType; - typedef otb::ImageFileWriter<ImageType> WriterType; + using ImageType = otb::VectorImage<PixelType, Dimension>; + using ReaderType = otb::ImageFileReader<ImageType>; + using WriterType = otb::ImageFileWriter<ImageType>; // We instantiate now the image reader and we set the image file name. ReaderType::Pointer reader = ReaderType::New(); @@ -87,8 +87,8 @@ int main(int itkNotUsed(argc), char* argv[]) // internal structure of this filter is a filter-to-filter like structure. // We can now the instantiate the filter. - typedef otb::FastICAImageFilter<ImageType, ImageType, otb::Transform::FORWARD> FastICAFilterType; - FastICAFilterType::Pointer FastICAfilter = FastICAFilterType::New(); + using FastICAFilterType = otb::FastICAImageFilter<ImageType, ImageType, otb::Transform::FORWARD>; + FastICAFilterType::Pointer FastICAfilter = FastICAFilterType::New(); // We then set the number of independent // components required as output. We can choose to get less ICs than @@ -122,8 +122,8 @@ int main(int itkNotUsed(argc), char* argv[]) // covariance matrix or the transformation matrix // (which may not be square) has to be given. - typedef otb::FastICAImageFilter<ImageType, ImageType, otb::Transform::INVERSE> InvFastICAFilterType; - InvFastICAFilterType::Pointer invFilter = InvFastICAFilterType::New(); + using InvFastICAFilterType = otb::FastICAImageFilter<ImageType, ImageType, otb::Transform::INVERSE>; + InvFastICAFilterType::Pointer invFilter = InvFastICAFilterType::New(); invFilter->SetMeanValues(FastICAfilter->GetMeanValues()); invFilter->SetStdDevValues(FastICAfilter->GetStdDevValues()); @@ -154,9 +154,9 @@ int main(int itkNotUsed(argc), char* argv[]) // \end{figure} // This is for rendering in software guide - typedef otb::PrintableImageFilter<ImageType, ImageType> PrintFilterType; - typedef PrintFilterType::OutputImageType VisuImageType; - typedef otb::ImageFileWriter<VisuImageType> VisuWriterType; + using PrintFilterType = otb::PrintableImageFilter<ImageType, ImageType>; + using VisuImageType = PrintFilterType::OutputImageType; + using VisuWriterType = otb::ImageFileWriter<VisuImageType>; PrintFilterType::Pointer inputPrintFilter = PrintFilterType::New(); PrintFilterType::Pointer outputPrintFilter = PrintFilterType::New(); diff --git a/Examples/DimensionReduction/MNFExample.cxx b/Examples/DimensionReduction/MNFExample.cxx index 0299f602f7bfeadad31fa628c9511eb0d16cfb6f..da9343ba774855cf88dbf61fdabdb884b40518cb 100644 --- a/Examples/DimensionReduction/MNFExample.cxx +++ b/Examples/DimensionReduction/MNFExample.cxx @@ -66,7 +66,7 @@ int main(int itkNotUsed(argc), char* argv[]) { - typedef double PixelType; + using PixelType = double; const unsigned int Dimension = 2; const char* inputFileName = argv[1]; const char* outputFilename = argv[2]; @@ -83,9 +83,9 @@ int main(int itkNotUsed(argc), char* argv[]) // since we will produce a multi-channel image (the principal // components) from a multi-channel input image. - typedef otb::VectorImage<PixelType, Dimension> ImageType; - typedef otb::ImageFileReader<ImageType> ReaderType; - typedef otb::ImageFileWriter<ImageType> WriterType; + using ImageType = otb::VectorImage<PixelType, Dimension>; + using ReaderType = otb::ImageFileReader<ImageType>; + using WriterType = otb::ImageFileWriter<ImageType>; // We instantiate now the image reader and we set the image file name. ReaderType::Pointer reader = ReaderType::New(); @@ -105,7 +105,7 @@ int main(int itkNotUsed(argc), char* argv[]) // We define the type of the noise filter. // SoftwareGuide : BeginCodeSnippet - typedef otb::LocalActivityVectorImageFilter<ImageType, ImageType> NoiseFilterType; + using NoiseFilterType = otb::LocalActivityVectorImageFilter<ImageType, ImageType>; // SoftwareGuide : EndCodeSnippet @@ -114,8 +114,8 @@ int main(int itkNotUsed(argc), char* argv[]) // internal structure of this filter is a filter-to-filter like structure. // We can now the instantiate the filter. - typedef otb::MNFImageFilter<ImageType, ImageType, NoiseFilterType, otb::Transform::FORWARD> MNFFilterType; - MNFFilterType::Pointer MNFfilter = MNFFilterType::New(); + using MNFFilterType = otb::MNFImageFilter<ImageType, ImageType, NoiseFilterType, otb::Transform::FORWARD>; + MNFFilterType::Pointer MNFfilter = MNFFilterType::New(); // We then set the number of principal // components required as output. We can choose to get less PCs than @@ -150,8 +150,8 @@ int main(int itkNotUsed(argc), char* argv[]) // covariance matrix or the transformation matrix // (which may not be square) has to be given. - typedef otb::MNFImageFilter<ImageType, ImageType, NoiseFilterType, otb::Transform::INVERSE> InvMNFFilterType; - InvMNFFilterType::Pointer invFilter = InvMNFFilterType::New(); + using InvMNFFilterType = otb::MNFImageFilter<ImageType, ImageType, NoiseFilterType, otb::Transform::INVERSE>; + InvMNFFilterType::Pointer invFilter = InvMNFFilterType::New(); invFilter->SetMeanValues(MNFfilter->GetMeanValues()); if (normalization) @@ -182,9 +182,9 @@ int main(int itkNotUsed(argc), char* argv[]) // \end{figure} // This is for rendering in software guide - typedef otb::PrintableImageFilter<ImageType, ImageType> PrintFilterType; - typedef PrintFilterType::OutputImageType VisuImageType; - typedef otb::ImageFileWriter<VisuImageType> VisuWriterType; + using PrintFilterType = otb::PrintableImageFilter<ImageType, ImageType>; + using VisuImageType = PrintFilterType::OutputImageType; + using VisuWriterType = otb::ImageFileWriter<VisuImageType>; PrintFilterType::Pointer inputPrintFilter = PrintFilterType::New(); PrintFilterType::Pointer outputPrintFilter = PrintFilterType::New(); diff --git a/Examples/DimensionReduction/MaximumAutocorrelationFactor.cxx b/Examples/DimensionReduction/MaximumAutocorrelationFactor.cxx index 5de6d9be0357f2079b647bc140a1dc339982024d..c7a3510fa1b86254e06b1b9090493049c3aa3f41 100644 --- a/Examples/DimensionReduction/MaximumAutocorrelationFactor.cxx +++ b/Examples/DimensionReduction/MaximumAutocorrelationFactor.cxx @@ -54,8 +54,8 @@ int main(int itkNotUsed(argc), char* argv[]) // We then define the types for the input image and the // output image. - typedef otb::VectorImage<unsigned short, 2> InputImageType; - typedef otb::VectorImage<double, 2> OutputImageType; + using InputImageType = otb::VectorImage<unsigned short, 2>; + using OutputImageType = otb::VectorImage<double, 2>; // We can now declare the types for the reader. Since the images @@ -64,14 +64,14 @@ int main(int itkNotUsed(argc), char* argv[]) // streamed. This is achieved by using the // \doxygen{otb}{ImageFileWriter} class. - typedef otb::ImageFileReader<InputImageType> ReaderType; - typedef otb::ImageFileWriter<OutputImageType> WriterType; + using ReaderType = otb::ImageFileReader<InputImageType>; + using WriterType = otb::ImageFileWriter<OutputImageType>; // The \doxygen{otb}{MultivariateAlterationDetectorImageFilter} is templated over // the type of the input images and the type of the generated change // image. - typedef otb::MaximumAutocorrelationFactorImageFilter<InputImageType, OutputImageType> FilterType; + using FilterType = otb::MaximumAutocorrelationFactorImageFilter<InputImageType, OutputImageType>; // The different elements of the pipeline can now be instantiated. @@ -95,10 +95,10 @@ int main(int itkNotUsed(argc), char* argv[]) writer->Update(); // This is for rendering in software guide - typedef otb::PrintableImageFilter<InputImageType, InputImageType> InputPrintFilterType; - typedef otb::PrintableImageFilter<OutputImageType, OutputImageType> OutputPrintFilterType; - typedef InputPrintFilterType::OutputImageType VisuImageType; - typedef otb::ImageFileWriter<VisuImageType> VisuWriterType; + using InputPrintFilterType = otb::PrintableImageFilter<InputImageType, InputImageType>; + using OutputPrintFilterType = otb::PrintableImageFilter<OutputImageType, OutputImageType>; + using VisuImageType = InputPrintFilterType::OutputImageType; + using VisuWriterType = otb::ImageFileWriter<VisuImageType>; InputPrintFilterType::Pointer inputPrintFilter = InputPrintFilterType::New(); OutputPrintFilterType::Pointer outputPrintFilter = OutputPrintFilterType::New(); diff --git a/Examples/DimensionReduction/NAPCAExample.cxx b/Examples/DimensionReduction/NAPCAExample.cxx index b4f479eaa4b462dfb1709965322641e489747afd..3586dd81eaac17da35d1a565660fb7b154bdcd2c 100644 --- a/Examples/DimensionReduction/NAPCAExample.cxx +++ b/Examples/DimensionReduction/NAPCAExample.cxx @@ -67,7 +67,7 @@ int main(int itkNotUsed(argc), char* argv[]) { - typedef double PixelType; + using PixelType = double; const unsigned int Dimension = 2; const char* inputFileName = argv[1]; const char* outputFilename = argv[2]; @@ -84,9 +84,9 @@ int main(int itkNotUsed(argc), char* argv[]) // since we will produce a multi-channel image (the principal // components) from a multi-channel input image. - typedef otb::VectorImage<PixelType, Dimension> ImageType; - typedef otb::ImageFileReader<ImageType> ReaderType; - typedef otb::ImageFileWriter<ImageType> WriterType; + using ImageType = otb::VectorImage<PixelType, Dimension>; + using ReaderType = otb::ImageFileReader<ImageType>; + using WriterType = otb::ImageFileWriter<ImageType>; // We instantiate now the image reader and we set the image file name. ReaderType::Pointer reader = ReaderType::New(); @@ -106,7 +106,7 @@ int main(int itkNotUsed(argc), char* argv[]) // We define the type of the noise filter. // SoftwareGuide : BeginCodeSnippet - typedef otb::LocalActivityVectorImageFilter<ImageType, ImageType> NoiseFilterType; + using NoiseFilterType = otb::LocalActivityVectorImageFilter<ImageType, ImageType>; // SoftwareGuide : EndCodeSnippet @@ -116,8 +116,8 @@ int main(int itkNotUsed(argc), char* argv[]) // internal structure of this filter is a filter-to-filter like structure. // We can now the instantiate the filter. - typedef otb::NAPCAImageFilter<ImageType, ImageType, NoiseFilterType, otb::Transform::FORWARD> NAPCAFilterType; - NAPCAFilterType::Pointer napcafilter = NAPCAFilterType::New(); + using NAPCAFilterType = otb::NAPCAImageFilter<ImageType, ImageType, NoiseFilterType, otb::Transform::FORWARD>; + NAPCAFilterType::Pointer napcafilter = NAPCAFilterType::New(); // We then set the number of principal // components required as output. We can choose to get less PCs than @@ -152,8 +152,8 @@ int main(int itkNotUsed(argc), char* argv[]) // covariance matrix or the transformation matrix // (which may not be square) has to be given. - typedef otb::NAPCAImageFilter<ImageType, ImageType, NoiseFilterType, otb::Transform::INVERSE> InvNAPCAFilterType; - InvNAPCAFilterType::Pointer invFilter = InvNAPCAFilterType::New(); + using InvNAPCAFilterType = otb::NAPCAImageFilter<ImageType, ImageType, NoiseFilterType, otb::Transform::INVERSE>; + InvNAPCAFilterType::Pointer invFilter = InvNAPCAFilterType::New(); invFilter->SetMeanValues(napcafilter->GetMeanValues()); if (normalization) @@ -184,9 +184,9 @@ int main(int itkNotUsed(argc), char* argv[]) // \end{figure} // This is for rendering in software guide - typedef otb::PrintableImageFilter<ImageType, ImageType> PrintFilterType; - typedef PrintFilterType::OutputImageType VisuImageType; - typedef otb::ImageFileWriter<VisuImageType> VisuWriterType; + using PrintFilterType = otb::PrintableImageFilter<ImageType, ImageType>; + using VisuImageType = PrintFilterType::OutputImageType; + using VisuWriterType = otb::ImageFileWriter<VisuImageType>; PrintFilterType::Pointer inputPrintFilter = PrintFilterType::New(); PrintFilterType::Pointer outputPrintFilter = PrintFilterType::New(); diff --git a/Examples/DimensionReduction/PCAExample.cxx b/Examples/DimensionReduction/PCAExample.cxx index 581c9f6b97e37497a1dd14385179f7b1812a3e4e..9127983ce63f526e0e3cc95e150239b22129484d 100644 --- a/Examples/DimensionReduction/PCAExample.cxx +++ b/Examples/DimensionReduction/PCAExample.cxx @@ -46,7 +46,7 @@ int main(int itkNotUsed(argc), char* argv[]) { - typedef double PixelType; + using PixelType = double; const unsigned int Dimension = 2; const char* inputFileName = argv[1]; const char* outputFilename = argv[2]; @@ -62,9 +62,9 @@ int main(int itkNotUsed(argc), char* argv[]) // since we will produce a multi-channel image (the principal // components) from a multi-channel input image. - typedef otb::VectorImage<PixelType, Dimension> ImageType; - typedef otb::ImageFileReader<ImageType> ReaderType; - typedef otb::ImageFileWriter<ImageType> WriterType; + using ImageType = otb::VectorImage<PixelType, Dimension>; + using ReaderType = otb::ImageFileReader<ImageType>; + using WriterType = otb::ImageFileWriter<ImageType>; // We instantiate now the image reader and we set the image file name. ReaderType::Pointer reader = ReaderType::New(); @@ -74,8 +74,8 @@ int main(int itkNotUsed(argc), char* argv[]) // internal structure of this filter is a filter-to-filter like structure. // We can now the instantiate the filter. - typedef otb::PCAImageFilter<ImageType, ImageType, otb::Transform::FORWARD> PCAFilterType; - PCAFilterType::Pointer pcafilter = PCAFilterType::New(); + using PCAFilterType = otb::PCAImageFilter<ImageType, ImageType, otb::Transform::FORWARD>; + PCAFilterType::Pointer pcafilter = PCAFilterType::New(); // The only parameter needed for the PCA is the number of principal // components required as output. Principal components are linear combination of input components // (here the input image bands), @@ -102,8 +102,8 @@ int main(int itkNotUsed(argc), char* argv[]) // covariance matrix or the transformation matrix // (which may not be square) has to be given. - typedef otb::PCAImageFilter<ImageType, ImageType, otb::Transform::INVERSE> InvPCAFilterType; - InvPCAFilterType::Pointer invFilter = InvPCAFilterType::New(); + using InvPCAFilterType = otb::PCAImageFilter<ImageType, ImageType, otb::Transform::INVERSE>; + InvPCAFilterType::Pointer invFilter = InvPCAFilterType::New(); invFilter->SetInput(pcafilter->GetOutput()); invFilter->SetTransformationMatrix(pcafilter->GetTransformationMatrix()); @@ -131,9 +131,9 @@ int main(int itkNotUsed(argc), char* argv[]) // \end{figure} // This is for rendering in software guide - typedef otb::PrintableImageFilter<ImageType, ImageType> PrintFilterType; - typedef PrintFilterType::OutputImageType VisuImageType; - typedef otb::ImageFileWriter<VisuImageType> VisuWriterType; + using PrintFilterType = otb::PrintableImageFilter<ImageType, ImageType>; + using VisuImageType = PrintFilterType::OutputImageType; + using VisuWriterType = otb::ImageFileWriter<VisuImageType>; PrintFilterType::Pointer inputPrintFilter = PrintFilterType::New(); PrintFilterType::Pointer outputPrintFilter = PrintFilterType::New(); diff --git a/Examples/DisparityMap/FineRegistrationImageFilterExample.cxx b/Examples/DisparityMap/FineRegistrationImageFilterExample.cxx index 9acb897791a38a67017a50f518b2f0680d1a7338..831dc0f7b08f031785c35364360440c6480e22a0 100644 --- a/Examples/DisparityMap/FineRegistrationImageFilterExample.cxx +++ b/Examples/DisparityMap/FineRegistrationImageFilterExample.cxx @@ -82,22 +82,22 @@ int main(int argc, char** argv) const unsigned int ImageDimension = 2; - typedef double PixelType; - typedef itk::Vector<double, ImageDimension> DisplacementPixelType; + using PixelType = double; + using DisplacementPixelType = itk::Vector<double, ImageDimension>; - typedef unsigned char OutputPixelType; - typedef otb::Image<OutputPixelType, ImageDimension> OutputImageType; + using OutputPixelType = unsigned char; + using OutputImageType = otb::Image<OutputPixelType, ImageDimension>; // Several type of \doxygen{otb}{Image} are required to represent the input image, the metric field, // and the deformation field. // Allocate Images - typedef otb::Image<PixelType, ImageDimension> InputImageType; - typedef otb::Image<PixelType, ImageDimension> MetricImageType; - typedef otb::Image<DisplacementPixelType, ImageDimension> DisplacementFieldType; + using InputImageType = otb::Image<PixelType, ImageDimension>; + using MetricImageType = otb::Image<PixelType, ImageDimension>; + using DisplacementFieldType = otb::Image<DisplacementPixelType, ImageDimension>; - typedef otb::ImageFileReader<InputImageType> InputReaderType; - InputReaderType::Pointer fReader = InputReaderType::New(); + using InputReaderType = otb::ImageFileReader<InputImageType>; + InputReaderType::Pointer fReader = InputReaderType::New(); fReader->SetFileName(argv[1]); InputReaderType::Pointer mReader = InputReaderType::New(); @@ -108,7 +108,7 @@ int main(int argc, char** argv) // \doxygen{itk}{RecursiveGaussianImageFilter}: // Blur input images - typedef itk::RecursiveGaussianImageFilter<InputImageType, InputImageType> InputBlurType; + using InputBlurType = itk::RecursiveGaussianImageFilter<InputImageType, InputImageType>; InputBlurType::Pointer fBlur = InputBlurType::New(); fBlur->SetInput(fReader->GetOutput()); @@ -121,7 +121,7 @@ int main(int argc, char** argv) // Now, we declare and instantiate the \doxygen{otb}{FineRegistrationImageFilter} which is going to perform the registration: // Create the filter - typedef otb::FineRegistrationImageFilter<InputImageType, MetricImageType, DisplacementFieldType> RegistrationFilterType; + using RegistrationFilterType = otb::FineRegistrationImageFilter<InputImageType, MetricImageType, DisplacementFieldType>; RegistrationFilterType::Pointer registrator = RegistrationFilterType::New(); @@ -132,7 +132,7 @@ int main(int argc, char** argv) // \begin{itemize} // \item The area where the search is performed. This area is defined by its radius: - typedef RegistrationFilterType::SizeType RadiusType; + using RadiusType = RegistrationFilterType::SizeType; RadiusType searchRadius; @@ -162,8 +162,8 @@ int main(int argc, char** argv) if (argc > 11) { - typedef itk::MeanReciprocalSquareDifferenceImageToImageMetric<InputImageType, InputImageType> MRSDMetricType; - MRSDMetricType::Pointer mrsdMetric = MRSDMetricType::New(); + using MRSDMetricType = itk::MeanReciprocalSquareDifferenceImageToImageMetric<InputImageType, InputImageType>; + MRSDMetricType::Pointer mrsdMetric = MRSDMetricType::New(); registrator->SetMetric(mrsdMetric); // The \doxygen{itk}{MutualInformationImageToImageMetric} produces low value for poor matches, therefore, the filter has @@ -180,20 +180,20 @@ int main(int argc, char** argv) // \doxygen{otb}{ImageFileWriter} if you want to benefit // from the streaming features. - typedef otb::ImageOfVectorsToMonoChannelExtractROI<DisplacementFieldType, InputImageType> ChannelExtractionFilterType; - ChannelExtractionFilterType::Pointer channelExtractor = ChannelExtractionFilterType::New(); + using ChannelExtractionFilterType = otb::ImageOfVectorsToMonoChannelExtractROI<DisplacementFieldType, InputImageType>; + ChannelExtractionFilterType::Pointer channelExtractor = ChannelExtractionFilterType::New(); channelExtractor->SetInput(registrator->GetOutputDisplacementField()); channelExtractor->SetChannel(1); - typedef itk::RescaleIntensityImageFilter<InputImageType, OutputImageType> RescalerType; - RescalerType::Pointer fieldRescaler = RescalerType::New(); + using RescalerType = itk::RescaleIntensityImageFilter<InputImageType, OutputImageType>; + RescalerType::Pointer fieldRescaler = RescalerType::New(); fieldRescaler->SetInput(channelExtractor->GetOutput()); fieldRescaler->SetOutputMaximum(255); fieldRescaler->SetOutputMinimum(0); - typedef otb::ImageFileWriter<OutputImageType> DFWriterType; + using DFWriterType = otb::ImageFileWriter<OutputImageType>; DFWriterType::Pointer dfWriter = DFWriterType::New(); dfWriter->SetFileName(argv[3]); @@ -204,8 +204,8 @@ int main(int argc, char** argv) dfWriter->SetFileName(argv[4]); dfWriter->Update(); - typedef itk::WarpImageFilter<InputImageType, InputImageType, DisplacementFieldType> WarperType; - WarperType::Pointer warper = WarperType::New(); + using WarperType = itk::WarpImageFilter<InputImageType, InputImageType, DisplacementFieldType>; + WarperType::Pointer warper = WarperType::New(); InputImageType::PixelType padValue = 4.0; @@ -213,22 +213,22 @@ int main(int argc, char** argv) warper->SetDisplacementField(registrator->GetOutputDisplacementField()); warper->SetEdgePaddingValue(padValue); - typedef itk::RescaleIntensityImageFilter<MetricImageType, OutputImageType> MetricRescalerType; + using MetricRescalerType = itk::RescaleIntensityImageFilter<MetricImageType, OutputImageType>; MetricRescalerType::Pointer metricRescaler = MetricRescalerType::New(); metricRescaler->SetInput(registrator->GetOutput()); metricRescaler->SetOutputMinimum(0); metricRescaler->SetOutputMaximum(255); - typedef otb::ImageFileWriter<OutputImageType> WriterType; + using WriterType = otb::ImageFileWriter<OutputImageType>; WriterType::Pointer writer1 = WriterType::New(); writer1->SetInput(metricRescaler->GetOutput()); writer1->SetFileName(argv[5]); writer1->Update(); - typedef itk::CastImageFilter<InputImageType, OutputImageType> CastFilterType; - CastFilterType::Pointer caster = CastFilterType::New(); + using CastFilterType = itk::CastImageFilter<InputImageType, OutputImageType>; + CastFilterType::Pointer caster = CastFilterType::New(); caster->SetInput(warper->GetOutput()); diff --git a/Examples/DisparityMap/NCCRegistrationFilterExample.cxx b/Examples/DisparityMap/NCCRegistrationFilterExample.cxx index 3e30f466609364e9a84a0304a500ca9036d0defc..174494baeb80e8f57c2f08fdf93596a1d4a88b34 100644 --- a/Examples/DisparityMap/NCCRegistrationFilterExample.cxx +++ b/Examples/DisparityMap/NCCRegistrationFilterExample.cxx @@ -64,26 +64,26 @@ int main(int argc, char** argv) const unsigned int ImageDimension = 2; - typedef double PixelType; - typedef itk::Vector<double, ImageDimension> DisplacementPixelType; + using PixelType = double; + using DisplacementPixelType = itk::Vector<double, ImageDimension>; - typedef unsigned char OutputPixelType; - typedef otb::Image<OutputPixelType, ImageDimension> OutputImageType; + using OutputPixelType = unsigned char; + using OutputImageType = otb::Image<OutputPixelType, ImageDimension>; // Several type of \doxygen{otb}{Image} are required to represent the reference image (fixed) // the image we want to register (moving) and the deformation field. // Allocate Images - typedef otb::Image<PixelType, ImageDimension> MovingImageType; - typedef otb::Image<PixelType, ImageDimension> FixedImageType; - typedef otb::Image<DisplacementPixelType, ImageDimension> DisplacementFieldType; + using MovingImageType = otb::Image<PixelType, ImageDimension>; + using FixedImageType = otb::Image<PixelType, ImageDimension>; + using DisplacementFieldType = otb::Image<DisplacementPixelType, ImageDimension>; - typedef otb::ImageFileReader<FixedImageType> FixedReaderType; - FixedReaderType::Pointer fReader = FixedReaderType::New(); + using FixedReaderType = otb::ImageFileReader<FixedImageType>; + FixedReaderType::Pointer fReader = FixedReaderType::New(); fReader->SetFileName(argv[1]); - typedef otb::ImageFileReader<MovingImageType> MovingReaderType; - MovingReaderType::Pointer mReader = MovingReaderType::New(); + using MovingReaderType = otb::ImageFileReader<MovingImageType>; + MovingReaderType::Pointer mReader = MovingReaderType::New(); mReader->SetFileName(argv[2]); // To make the correlation estimation more robust, the first @@ -91,13 +91,13 @@ int main(int argc, char** argv) // \doxygen{itk}{RecursiveGaussianImageFilter}: // Blur input images - typedef itk::RecursiveGaussianImageFilter<FixedImageType, FixedImageType> FixedBlurType; + using FixedBlurType = itk::RecursiveGaussianImageFilter<FixedImageType, FixedImageType>; FixedBlurType::Pointer fBlur = FixedBlurType::New(); fBlur->SetInput(fReader->GetOutput()); fBlur->SetSigma(std::stof(argv[7])); - typedef itk::RecursiveGaussianImageFilter<MovingImageType, MovingImageType> MovingBlurType; + using MovingBlurType = itk::RecursiveGaussianImageFilter<MovingImageType, MovingImageType>; MovingBlurType::Pointer mBlur = MovingBlurType::New(); mBlur->SetInput(mReader->GetOutput()); @@ -106,7 +106,7 @@ int main(int argc, char** argv) // Now, we need to instantiate the NCCRegistrationFilter which is going to perform the registration: // Create the filter - typedef otb::NCCRegistrationFilter<FixedImageType, MovingImageType, DisplacementFieldType> RegistrationFilterType; + using RegistrationFilterType = otb::NCCRegistrationFilter<FixedImageType, MovingImageType, DisplacementFieldType>; RegistrationFilterType::Pointer registrator = RegistrationFilterType::New(); @@ -117,7 +117,7 @@ int main(int argc, char** argv) // \begin{itemize} // \item The area where the search is performed. This area is defined by its radius: - typedef RegistrationFilterType::RadiusType RadiusType; + using RadiusType = RegistrationFilterType::RadiusType; RadiusType radius; @@ -140,20 +140,20 @@ int main(int argc, char** argv) // \doxygen{otb}{ImageFileWriter} if you want to benefit // from the streaming features. - typedef otb::ImageOfVectorsToMonoChannelExtractROI<DisplacementFieldType, MovingImageType> ChannelExtractionFilterType; - ChannelExtractionFilterType::Pointer channelExtractor = ChannelExtractionFilterType::New(); + using ChannelExtractionFilterType = otb::ImageOfVectorsToMonoChannelExtractROI<DisplacementFieldType, MovingImageType>; + ChannelExtractionFilterType::Pointer channelExtractor = ChannelExtractionFilterType::New(); channelExtractor->SetInput(registrator->GetOutput()); channelExtractor->SetChannel(1); - typedef itk::RescaleIntensityImageFilter<MovingImageType, OutputImageType> RescalerType; - RescalerType::Pointer fieldRescaler = RescalerType::New(); + using RescalerType = itk::RescaleIntensityImageFilter<MovingImageType, OutputImageType>; + RescalerType::Pointer fieldRescaler = RescalerType::New(); fieldRescaler->SetInput(channelExtractor->GetOutput()); fieldRescaler->SetOutputMaximum(255); fieldRescaler->SetOutputMinimum(0); - typedef otb::ImageFileWriter<OutputImageType> DFWriterType; + using DFWriterType = otb::ImageFileWriter<OutputImageType>; DFWriterType::Pointer dfWriter = DFWriterType::New(); dfWriter->SetFileName(argv[3]); @@ -164,8 +164,8 @@ int main(int argc, char** argv) dfWriter->SetFileName(argv[4]); dfWriter->Update(); - typedef itk::WarpImageFilter<MovingImageType, MovingImageType, DisplacementFieldType> WarperType; - WarperType::Pointer warper = WarperType::New(); + using WarperType = itk::WarpImageFilter<MovingImageType, MovingImageType, DisplacementFieldType>; + WarperType::Pointer warper = WarperType::New(); MovingImageType::PixelType padValue = 4.0; @@ -173,11 +173,11 @@ int main(int argc, char** argv) warper->SetDisplacementField(registrator->GetOutput()); warper->SetEdgePaddingValue(padValue); - typedef itk::CastImageFilter<MovingImageType, OutputImageType> CastFilterType; - CastFilterType::Pointer caster = CastFilterType::New(); + using CastFilterType = itk::CastImageFilter<MovingImageType, OutputImageType>; + CastFilterType::Pointer caster = CastFilterType::New(); caster->SetInput(warper->GetOutput()); - typedef otb::ImageFileWriter<OutputImageType> WriterType; + using WriterType = otb::ImageFileWriter<OutputImageType>; WriterType::Pointer writer = WriterType::New(); writer->SetFileName(argv[5]); diff --git a/Examples/DisparityMap/StereoReconstructionExample.cxx b/Examples/DisparityMap/StereoReconstructionExample.cxx index 50ae95d22dd6ef428020b84a48b17f375fed5237..d553c5e1071391d148addb916bd9964d5363ca31 100644 --- a/Examples/DisparityMap/StereoReconstructionExample.cxx +++ b/Examples/DisparityMap/StereoReconstructionExample.cxx @@ -65,19 +65,19 @@ int main(int argc, char* argv[]) return EXIT_FAILURE; } - typedef otb::Image<float, 2> FloatImageType; - typedef otb::VectorImage<float, 2> FloatVectorImageType; + using FloatImageType = otb::Image<float, 2>; + using FloatVectorImageType = otb::VectorImage<float, 2>; - typedef otb::ImageFileReader<FloatImageType> ImageReaderType; + using ImageReaderType = otb::ImageFileReader<FloatImageType>; - typedef otb::ImageFileWriter<FloatImageType> WriterType; + using WriterType = otb::ImageFileWriter<FloatImageType>; - typedef unsigned char OutputPixelType; - typedef otb::Image<OutputPixelType, 2> OutputImageType; + using OutputPixelType = unsigned char; + using OutputImageType = otb::Image<OutputPixelType, 2>; - typedef itk::RescaleIntensityImageFilter<FloatImageType, OutputImageType> RescalerType; + using RescalerType = itk::RescaleIntensityImageFilter<FloatImageType, OutputImageType>; - typedef otb::ImageFileWriter<OutputImageType> OutputWriterType; + using OutputWriterType = otb::ImageFileWriter<OutputImageType>; // This example demonstrates the use of the following filters : // \begin{itemize} // \item \doxygen{otb}{StereorectificationDisplacementFieldSource} @@ -88,30 +88,30 @@ int main(int argc, char* argv[]) // \item \doxygen{otb}{DisparityMapToDEMFilter} // \end{itemize} - typedef otb::StereorectificationDisplacementFieldSource<FloatImageType, FloatVectorImageType> DisplacementFieldSourceType; + using DisplacementFieldSourceType = otb::StereorectificationDisplacementFieldSource<FloatImageType, FloatVectorImageType>; - typedef itk::Vector<double, 2> DisplacementType; - typedef otb::Image<DisplacementType> DisplacementFieldType; + using DisplacementType = itk::Vector<double, 2>; + using DisplacementFieldType = otb::Image<DisplacementType>; - typedef itk::VectorCastImageFilter<FloatVectorImageType, DisplacementFieldType> DisplacementFieldCastFilterType; + using DisplacementFieldCastFilterType = itk::VectorCastImageFilter<FloatVectorImageType, DisplacementFieldType>; - typedef otb::StreamingWarpImageFilter<FloatImageType, FloatImageType, DisplacementFieldType> WarpFilterType; + using WarpFilterType = otb::StreamingWarpImageFilter<FloatImageType, FloatImageType, DisplacementFieldType>; - typedef otb::BCOInterpolateImageFunction<FloatImageType> BCOInterpolationType; + using BCOInterpolationType = otb::BCOInterpolateImageFunction<FloatImageType>; - typedef otb::Functor::NCCBlockMatching<FloatImageType, FloatImageType> NCCBlockMatchingFunctorType; + using NCCBlockMatchingFunctorType = otb::Functor::NCCBlockMatching<FloatImageType, FloatImageType>; - typedef otb::PixelWiseBlockMatchingImageFilter<FloatImageType, FloatImageType, FloatImageType, FloatImageType, NCCBlockMatchingFunctorType> - NCCBlockMatchingFilterType; + using NCCBlockMatchingFilterType = + otb::PixelWiseBlockMatchingImageFilter<FloatImageType, FloatImageType, FloatImageType, FloatImageType, NCCBlockMatchingFunctorType>; - typedef otb::BandMathImageFilter<FloatImageType> BandMathFilterType; + using BandMathFilterType = otb::BandMathImageFilter<FloatImageType>; - typedef otb::SubPixelDisparityImageFilter<FloatImageType, FloatImageType, FloatImageType, FloatImageType, NCCBlockMatchingFunctorType> - NCCSubPixelDisparityFilterType; + using NCCSubPixelDisparityFilterType = + otb::SubPixelDisparityImageFilter<FloatImageType, FloatImageType, FloatImageType, FloatImageType, NCCBlockMatchingFunctorType>; - typedef otb::DisparityMapMedianFilter<FloatImageType, FloatImageType, FloatImageType> MedianFilterType; + using MedianFilterType = otb::DisparityMapMedianFilter<FloatImageType, FloatImageType, FloatImageType>; - typedef otb::DisparityMapToDEMFilter<FloatImageType, FloatImageType, FloatImageType, FloatVectorImageType, FloatImageType> DisparityToElevationFilterType; + using DisparityToElevationFilterType = otb::DisparityMapToDEMFilter<FloatImageType, FloatImageType, FloatImageType, FloatVectorImageType, FloatImageType>; double avgElevation = atof(argv[5]); otb::DEMHandler::Instance()->SetDefaultHeightAboveEllipsoid(avgElevation); diff --git a/Examples/FeatureExtraction/AsymmetricFusionOfLineDetectorExample.cxx b/Examples/FeatureExtraction/AsymmetricFusionOfLineDetectorExample.cxx index 99a929dc673a1586f400c0da8da6f8e803be3ecf..69e5c3840cef83a2c819afc3ed18b4540260ee3d 100644 --- a/Examples/FeatureExtraction/AsymmetricFusionOfLineDetectorExample.cxx +++ b/Examples/FeatureExtraction/AsymmetricFusionOfLineDetectorExample.cxx @@ -50,33 +50,33 @@ int main(int argc, char* argv[]) // choose to make all computations with floating point precision // and rescale the results between 0 and 255 in order to export PNG images. - typedef float InternalPixelType; - typedef unsigned char OutputPixelType; + using InternalPixelType = float; + using OutputPixelType = unsigned char; // The images are defined using the pixel type and the dimension. - typedef otb::Image<InternalPixelType, 2> InternalImageType; - typedef otb::Image<OutputPixelType, 2> OutputImageType; + using InternalImageType = otb::Image<InternalPixelType, 2>; + using OutputImageType = otb::Image<OutputPixelType, 2>; // The filter can be instantiated using the image types defined above. - typedef otb::AsymmetricFusionOfLineDetectorImageFilter<InternalImageType, InternalImageType> FilterType; + using FilterType = otb::AsymmetricFusionOfLineDetectorImageFilter<InternalImageType, InternalImageType>; // An \doxygen{otb}{ImageFileReader} class is also instantiated in order to read // image data from a file. - typedef otb::ImageFileReader<InternalImageType> ReaderType; + using ReaderType = otb::ImageFileReader<InternalImageType>; // An \doxygen{otb}{ImageFileWriter} is instantiated in order to write the // output image to a file. - typedef otb::ImageFileWriter<OutputImageType> WriterType; + using WriterType = otb::ImageFileWriter<OutputImageType>; // The intensity rescaling of the results will be carried out by the // \code{itk::RescaleIntensityImageFilter} which is templated by the // input and output image types. - typedef itk::RescaleIntensityImageFilter<InternalImageType, OutputImageType> RescalerType; + using RescalerType = itk::RescaleIntensityImageFilter<InternalImageType, OutputImageType>; // Both the filter and the reader are created by invoking their \code{New()} // methods and assigning the result to SmartPointers. diff --git a/Examples/FeatureExtraction/CloudDetectionExample.cxx b/Examples/FeatureExtraction/CloudDetectionExample.cxx index 286feb1f26494a35dededc3bcb8ac268b62302e1..11e15a548475865eb1de298e217b49149d266fe7 100644 --- a/Examples/FeatureExtraction/CloudDetectionExample.cxx +++ b/Examples/FeatureExtraction/CloudDetectionExample.cxx @@ -75,8 +75,8 @@ int main(int argc, char* argv[]) // Then we must decide what pixel type to use for the images. We choose to do // all the computations in double precision. - typedef double InputPixelType; - typedef double OutputPixelType; + using InputPixelType = double; + using OutputPixelType = double; // The images are defined using the pixel type and the // dimension. Please note that the @@ -84,28 +84,28 @@ int main(int argc, char* argv[]) // \doxygen{otb}{VectorImage} as input to handle multispectral // images. - typedef otb::VectorImage<InputPixelType, Dimension> VectorImageType; - typedef VectorImageType::PixelType VectorPixelType; - typedef otb::Image<OutputPixelType, Dimension> OutputImageType; + using VectorImageType = otb::VectorImage<InputPixelType, Dimension>; + using VectorPixelType = VectorImageType::PixelType; + using OutputImageType = otb::Image<OutputPixelType, Dimension>; // We define the functor type that the filter will use. We use the // \doxygen{otb}{CloudDetectionFunctor}. - typedef otb::Functor::CloudDetectionFunctor<VectorPixelType, OutputPixelType> FunctorType; + using FunctorType = otb::Functor::CloudDetectionFunctor<VectorPixelType, OutputPixelType>; // Now we can define the \doxygen{otb}{CloudDetectionFilter} that // takes a multi-spectral image as input and produces a binary // image. - typedef otb::CloudDetectionFilter<VectorImageType, OutputImageType, FunctorType> CloudDetectionFilterType; + using CloudDetectionFilterType = otb::CloudDetectionFilter<VectorImageType, OutputImageType, FunctorType>; // An \doxygen{otb}{ImageFileReader} class is also instantiated in // order to read image data from a file. Then, an // \doxygen{otb}{ImageFileWriter} is instantiated in order to write // the output image to a file. - typedef otb::ImageFileReader<VectorImageType> ReaderType; - typedef otb::ImageFileWriter<OutputImageType> WriterType; + using ReaderType = otb::ImageFileReader<VectorImageType>; + using WriterType = otb::ImageFileWriter<OutputImageType>; // The different filters composing our pipeline are created by invoking their // \code{New()} methods, assigning the results to smart pointers. @@ -157,13 +157,13 @@ int main(int argc, char* argv[]) // \end{figure} // Pretty image creation for printing - typedef otb::Image<unsigned char, Dimension> OutputPrettyImageType; - typedef otb::VectorImage<unsigned char, Dimension> InputPrettyImageType; - typedef otb::ImageFileWriter<OutputPrettyImageType> WriterPrettyOutputType; - typedef otb::ImageFileWriter<InputPrettyImageType> WriterPrettyInputType; - typedef itk::RescaleIntensityImageFilter<OutputImageType, OutputPrettyImageType> RescalerOutputType; - typedef otb::VectorRescaleIntensityImageFilter<VectorImageType, InputPrettyImageType> RescalerInputType; - typedef otb::MultiChannelExtractROI<InputPixelType, InputPixelType> ChannelExtractorType; + using OutputPrettyImageType = otb::Image<unsigned char, Dimension>; + using InputPrettyImageType = otb::VectorImage<unsigned char, Dimension>; + using WriterPrettyOutputType = otb::ImageFileWriter<OutputPrettyImageType>; + using WriterPrettyInputType = otb::ImageFileWriter<InputPrettyImageType>; + using RescalerOutputType = itk::RescaleIntensityImageFilter<OutputImageType, OutputPrettyImageType>; + using RescalerInputType = otb::VectorRescaleIntensityImageFilter<VectorImageType, InputPrettyImageType>; + using ChannelExtractorType = otb::MultiChannelExtractROI<InputPixelType, InputPixelType>; ChannelExtractorType::Pointer selecter = ChannelExtractorType::New(); RescalerInputType::Pointer inputRescaler = RescalerInputType::New(); diff --git a/Examples/FeatureExtraction/ComplexMomentPathExample.cxx b/Examples/FeatureExtraction/ComplexMomentPathExample.cxx index 909b582f5a269fa7c85996a178558bd1745b13f0..6032d5d493564ca3ed2eecd06c8826622973975e 100644 --- a/Examples/FeatureExtraction/ComplexMomentPathExample.cxx +++ b/Examples/FeatureExtraction/ComplexMomentPathExample.cxx @@ -59,10 +59,10 @@ int main(int argc, char* argv[]) const unsigned int Dimension = 2; - typedef itk::PolyLineParametricPath<Dimension> PathType; + using PathType = itk::PolyLineParametricPath<Dimension>; - typedef std::complex<double> ComplexType; - typedef otb::ComplexMomentPathFunction<PathType, ComplexType> CMType; + using ComplexType = std::complex<double>; + using CMType = otb::ComplexMomentPathFunction<PathType, ComplexType>; CMType::Pointer cmFunction = CMType::New(); @@ -70,7 +70,7 @@ int main(int argc, char* argv[]) path->Initialize(); - typedef PathType::ContinuousIndexType ContinuousIndexType; + using ContinuousIndexType = PathType::ContinuousIndexType; ContinuousIndexType cindex; diff --git a/Examples/FeatureExtraction/ComplexMomentsImageFunctionExample.cxx b/Examples/FeatureExtraction/ComplexMomentsImageFunctionExample.cxx index 538b99338765a845c93fe2dacf452773f12778c7..156c3cef662d1dc72eec804e99f9f50a37ec18ad 100644 --- a/Examples/FeatureExtraction/ComplexMomentsImageFunctionExample.cxx +++ b/Examples/FeatureExtraction/ComplexMomentsImageFunctionExample.cxx @@ -49,11 +49,11 @@ int main(int argc, char* argv[]) unsigned int P((unsigned char)::atoi(argv[2])); unsigned int Q((unsigned char)::atoi(argv[3])); - typedef unsigned char InputPixelType; - const unsigned int Dimension = 2; - typedef otb::Image<InputPixelType, Dimension> InputImageType; + using InputPixelType = unsigned char; + const unsigned int Dimension = 2; + using InputImageType = otb::Image<InputPixelType, Dimension>; - typedef otb::ImageFileReader<InputImageType> ReaderType; + using ReaderType = otb::ImageFileReader<InputImageType>; ReaderType::Pointer reader = ReaderType::New(); @@ -63,8 +63,8 @@ int main(int argc, char* argv[]) // input image type and the output complex type value, so we start by // defining: - typedef otb::ComplexMomentsImageFunction<InputImageType> CMType; - typedef CMType::OutputType OutputType; + using CMType = otb::ComplexMomentsImageFunction<InputImageType>; + using OutputType = CMType::OutputType; CMType::Pointer cmFunction = CMType::New(); diff --git a/Examples/FeatureExtraction/CorrelationLineDetectorExample.cxx b/Examples/FeatureExtraction/CorrelationLineDetectorExample.cxx index cfa79e5bf6b13cd74f59cc526d65ef75cd641896..f3ec4b2251314deacff9e0ebf3976845345ec4a2 100644 --- a/Examples/FeatureExtraction/CorrelationLineDetectorExample.cxx +++ b/Examples/FeatureExtraction/CorrelationLineDetectorExample.cxx @@ -54,33 +54,33 @@ int main(int argc, char* argv[]) // choose to make all computations with floating point precision // and rescale the results between 0 and 255 in order to export PNG images. - typedef float InternalPixelType; - typedef unsigned char OutputPixelType; + using InternalPixelType = float; + using OutputPixelType = unsigned char; // The images are defined using the pixel type and the dimension. - typedef otb::Image<InternalPixelType, 2> InternalImageType; - typedef otb::Image<OutputPixelType, 2> OutputImageType; + using InternalImageType = otb::Image<InternalPixelType, 2>; + using OutputImageType = otb::Image<OutputPixelType, 2>; // The filter can be instantiated using the image types defined above. - typedef otb::LineCorrelationDetectorImageFilter<InternalImageType, InternalImageType> FilterType; + using FilterType = otb::LineCorrelationDetectorImageFilter<InternalImageType, InternalImageType>; // An \doxygen{otb}{ImageFileReader} class is also instantiated in order to read // image data from a file. - typedef otb::ImageFileReader<InternalImageType> ReaderType; + using ReaderType = otb::ImageFileReader<InternalImageType>; // An \doxygen{otb}{ImageFileWriter} is instantiated in order to write the // output image to a file. - typedef otb::ImageFileWriter<OutputImageType> WriterType; + using WriterType = otb::ImageFileWriter<OutputImageType>; // The intensity rescaling of the results will be carried out by the // \code{itk::RescaleIntensityImageFilter} which is templated by the // input and output image types. - typedef itk::RescaleIntensityImageFilter<InternalImageType, OutputImageType> RescalerType; + using RescalerType = itk::RescaleIntensityImageFilter<InternalImageType, OutputImageType>; // Both the filter and the reader are created by invoking their \code{New()} // methods and assigning the result to SmartPointers. diff --git a/Examples/FeatureExtraction/EdgeDensityExample.cxx b/Examples/FeatureExtraction/EdgeDensityExample.cxx index 655469d5e13173fdcd6ddd323eb9f43107784bff..39571a9ddef6b2d88fd55095f83fd4166a70eed9 100644 --- a/Examples/FeatureExtraction/EdgeDensityExample.cxx +++ b/Examples/FeatureExtraction/EdgeDensityExample.cxx @@ -62,7 +62,7 @@ int main(int itkNotUsed(argc), char* argv[]) /*--*/ const unsigned int Dimension = 2; - typedef float PixelType; + using PixelType = float; /** Variables for the canny detector*/ const PixelType upperThreshold = static_cast<PixelType>(atof(argv[5])); @@ -73,25 +73,25 @@ int main(int itkNotUsed(argc), char* argv[]) // As usual, we start by defining the types for the images, the reader // and the writer. - typedef otb::Image<PixelType, Dimension> ImageType; - typedef otb::ImageFileReader<ImageType> ReaderType; - typedef otb::ImageFileWriter<ImageType> WriterType; + using ImageType = otb::Image<PixelType, Dimension>; + using ReaderType = otb::ImageFileReader<ImageType>; + using WriterType = otb::ImageFileWriter<ImageType>; // We define now the type for the function which will be used by the // edge density filter to estimate this density. Here we choose a // function which counts the number of non null pixels per area. The // function takes as template the type of the image to be processed. - typedef otb::BinaryImageDensityFunction<ImageType> CountFunctionType; + using CountFunctionType = otb::BinaryImageDensityFunction<ImageType>; // These {\em non null pixels} will be the result of an edge // detector. We use here the classical Canny edge detector, which is // templated over the input and output image types. - typedef itk::CannyEdgeDetectionImageFilter<ImageType, ImageType> CannyDetectorType; + using CannyDetectorType = itk::CannyEdgeDetectionImageFilter<ImageType, ImageType>; // Finally, we can define the type for the edge density filter which // takes as template the input and output image types, the edge // detector type, and the count function type.. - typedef otb::EdgeDensityImageFilter<ImageType, ImageType, CannyDetectorType, CountFunctionType> EdgeDensityFilterType; + using EdgeDensityFilterType = otb::EdgeDensityImageFilter<ImageType, ImageType, CannyDetectorType, CountFunctionType>; // We can now instantiate the different processing objects of the // pipeline using the \code{New()} method. @@ -137,9 +137,9 @@ int main(int itkNotUsed(argc), char* argv[]) /************* Image for printing **************/ - typedef otb::Image<unsigned char, 2> OutputImageType; + using OutputImageType = otb::Image<unsigned char, 2>; - typedef itk::RescaleIntensityImageFilter<ImageType, OutputImageType> RescalerType; + using RescalerType = itk::RescaleIntensityImageFilter<ImageType, OutputImageType>; RescalerType::Pointer rescaler = RescalerType::New(); @@ -148,8 +148,8 @@ int main(int itkNotUsed(argc), char* argv[]) rescaler->SetInput(filter->GetOutput()); - typedef otb::ImageFileWriter<OutputImageType> OutputWriterType; - OutputWriterType::Pointer outwriter = OutputWriterType::New(); + using OutputWriterType = otb::ImageFileWriter<OutputImageType>; + OutputWriterType::Pointer outwriter = OutputWriterType::New(); outwriter->SetFileName(prettyfilename); outwriter->SetInput(rescaler->GetOutput()); diff --git a/Examples/FeatureExtraction/FlusserMomentsImageFunctionExample.cxx b/Examples/FeatureExtraction/FlusserMomentsImageFunctionExample.cxx index 7c78689593781fe0b440fa057e17d10b8b81d097..ff63d86ae6b792a9f57908d1c1b4711154e49f9b 100644 --- a/Examples/FeatureExtraction/FlusserMomentsImageFunctionExample.cxx +++ b/Examples/FeatureExtraction/FlusserMomentsImageFunctionExample.cxx @@ -47,12 +47,12 @@ int main(int argc, char* argv[]) const char* inputFilename = argv[1]; const unsigned int radius = atoi(argv[2]); - typedef unsigned char InputPixelType; - const unsigned int Dimension = 2; + using InputPixelType = unsigned char; + const unsigned int Dimension = 2; - typedef otb::Image<InputPixelType, Dimension> InputImageType; + using InputImageType = otb::Image<InputPixelType, Dimension>; - typedef otb::ImageFileReader<InputImageType> ReaderType; + using ReaderType = otb::ImageFileReader<InputImageType>; ReaderType::Pointer reader = ReaderType::New(); @@ -62,8 +62,8 @@ int main(int argc, char* argv[]) // input image type and the output (real) type value, so we start by // defining: - typedef otb::FlusserMomentsImageFunction<InputImageType> FlusserType; - typedef FlusserType::OutputType MomentType; + using FlusserType = otb::FlusserMomentsImageFunction<InputImageType>; + using MomentType = FlusserType::OutputType; FlusserType::Pointer fmFunction = FlusserType::New(); diff --git a/Examples/FeatureExtraction/HarrisExample.cxx b/Examples/FeatureExtraction/HarrisExample.cxx index cde2e254a38da5c1a3523b52918909e5ea6a8e43..63f58fc31ab31b0676cfe13ede57a41d2ebba07b 100644 --- a/Examples/FeatureExtraction/HarrisExample.cxx +++ b/Examples/FeatureExtraction/HarrisExample.cxx @@ -53,23 +53,23 @@ int main(int argc, char* argv[]) double SigmaI((double)::atof(argv[4])); double Alpha((double)::atof(argv[5])); - typedef float InputPixelType; - const unsigned int Dimension = 2; - typedef unsigned char OutputPixelType; + using InputPixelType = float; + const unsigned int Dimension = 2; + using OutputPixelType = unsigned char; - typedef otb::Image<InputPixelType, Dimension> InputImageType; - typedef otb::Image<OutputPixelType, Dimension> OutputImageType; + using InputImageType = otb::Image<InputPixelType, Dimension>; + using OutputImageType = otb::Image<OutputPixelType, Dimension>; - typedef otb::ImageFileReader<InputImageType> ReaderType; + using ReaderType = otb::ImageFileReader<InputImageType>; // The \doxygen{otb}{HarrisImageFilter} is templated over the // input and output image types, so we start by // defining: - typedef otb::HarrisImageFilter<InputImageType, InputImageType> HarrisFilterType; - typedef itk::RescaleIntensityImageFilter<InputImageType, OutputImageType> RescalerType; + using HarrisFilterType = otb::HarrisImageFilter<InputImageType, InputImageType>; + using RescalerType = itk::RescaleIntensityImageFilter<InputImageType, OutputImageType>; - typedef otb::ImageFileWriter<OutputImageType> WriterType; + using WriterType = otb::ImageFileWriter<OutputImageType>; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); @@ -127,10 +127,10 @@ int main(int argc, char* argv[]) // templated over the input image type, the output being a // \doxygen{itk}{PointSet} with pixel type equal to the image pixel type. - typedef otb::HarrisImageToPointSetFilter<InputImageType> FunctionType; + using FunctionType = otb::HarrisImageToPointSetFilter<InputImageType>; // We declare now the filter and a pointer to the output point set. - typedef FunctionType::OutputPointSetType OutputPointSetType; + using OutputPointSetType = FunctionType::OutputPointSetType; FunctionType::Pointer harrisPoints = FunctionType::New(); OutputPointSetType::Pointer pointSet = OutputPointSetType::New(); @@ -155,17 +155,17 @@ int main(int argc, char* argv[]) // information on using \doxygen{itk}{PointSet}s) and declaring // an iterator to it. - typedef OutputPointSetType::PointsContainer ContainerType; - ContainerType* pointsContainer = pointSet->GetPoints(); - typedef ContainerType::Iterator IteratorType; - IteratorType itList = pointsContainer->Begin(); + using ContainerType = OutputPointSetType::PointsContainer; + ContainerType* pointsContainer = pointSet->GetPoints(); + using IteratorType = ContainerType::Iterator; + IteratorType itList = pointsContainer->Begin(); // And we get the points coordinates while (itList != pointsContainer->End()) { - typedef OutputPointSetType::PointType OutputPointType; - OutputPointType pCoordinate = (itList.Value()); + using OutputPointType = OutputPointSetType::PointType; + OutputPointType pCoordinate = (itList.Value()); otbLogMacro(Debug, << pCoordinate); ++itList; } diff --git a/Examples/FeatureExtraction/HuMomentsImageFunctionExample.cxx b/Examples/FeatureExtraction/HuMomentsImageFunctionExample.cxx index b98812c6814e3ea6587dfc6cd97f8f7a1cfe0a67..09331ca6b274e994db7e269163cb376da88a2157 100644 --- a/Examples/FeatureExtraction/HuMomentsImageFunctionExample.cxx +++ b/Examples/FeatureExtraction/HuMomentsImageFunctionExample.cxx @@ -47,12 +47,12 @@ int main(int argc, char* argv[]) const char* inputFilename = argv[1]; const unsigned int radius = atoi(argv[2]); - typedef unsigned char InputPixelType; - const unsigned int Dimension = 2; + using InputPixelType = unsigned char; + const unsigned int Dimension = 2; - typedef otb::Image<InputPixelType, Dimension> InputImageType; + using InputImageType = otb::Image<InputPixelType, Dimension>; - typedef otb::ImageFileReader<InputImageType> ReaderType; + using ReaderType = otb::ImageFileReader<InputImageType>; ReaderType::Pointer reader = ReaderType::New(); @@ -62,8 +62,8 @@ int main(int argc, char* argv[]) // input image type and the output (real) type value, so we start by // defining: - typedef otb::HuMomentsImageFunction<InputImageType> HuType; - typedef HuType::OutputType MomentType; + using HuType = otb::HuMomentsImageFunction<InputImageType>; + using MomentType = HuType::OutputType; HuType::Pointer hmFunction = HuType::New(); diff --git a/Examples/FeatureExtraction/LineSegmentDetectorExample.cxx b/Examples/FeatureExtraction/LineSegmentDetectorExample.cxx index 2f97370096c064912a9909f7c1aabd64e9a016de..96fc322a6dc7384d84ac40760fb3d0bd390d0a3c 100644 --- a/Examples/FeatureExtraction/LineSegmentDetectorExample.cxx +++ b/Examples/FeatureExtraction/LineSegmentDetectorExample.cxx @@ -45,14 +45,14 @@ int main(int argc, char* argv[]) const char* infname = argv[1]; const char* outfname = argv[2]; - typedef unsigned char InputPixelType; - typedef double PrecisionType; - const unsigned int Dimension = 2; + using InputPixelType = unsigned char; + using PrecisionType = double; + const unsigned int Dimension = 2; // As usual, we start by defining the types for the input image and // the image file reader. - typedef otb::Image<InputPixelType, Dimension> ImageType; - typedef otb::ImageFileReader<ImageType> ReaderType; + using ImageType = otb::Image<InputPixelType, Dimension>; + using ReaderType = otb::ImageFileReader<ImageType>; // We instantiate the reader and set the file name for the input image. ReaderType::Pointer reader = ReaderType::New(); @@ -64,13 +64,13 @@ int main(int argc, char* argv[]) // the coordinates of the detected segments will be given. It is // recommended to set this precision to a real type. The output of the // filter will be a \doxygen{otb}{VectorData}. - typedef otb::LineSegmentDetector<ImageType, PrecisionType> LsdFilterType; + using LsdFilterType = otb::LineSegmentDetector<ImageType, PrecisionType>; LsdFilterType::Pointer lsdFilter = LsdFilterType::New(); // We can now define the type for the writer, instantiate it and set // the file name for the output vector data. - typedef otb::VectorDataFileWriter<LsdFilterType::VectorDataType> WriterType; + using WriterType = otb::VectorDataFileWriter<LsdFilterType::VectorDataType>; WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outfname); diff --git a/Examples/FeatureExtraction/PanTexExample.cxx b/Examples/FeatureExtraction/PanTexExample.cxx index 9b2807b5fd1250328a820f485ef7ac4fc24d8c98..3066ca7e1b396f7a987d2f0cde8a2b3e65c2a176 100644 --- a/Examples/FeatureExtraction/PanTexExample.cxx +++ b/Examples/FeatureExtraction/PanTexExample.cxx @@ -61,17 +61,17 @@ int main(int argc, char* argv[]) const char* inprettyfname = argv[3]; const char* outprettyfname = argv[4]; - typedef double PixelType; - const int Dimension = 2; - typedef otb::Image<PixelType, Dimension> ImageType; + using PixelType = double; + const int Dimension = 2; + using ImageType = otb::Image<PixelType, Dimension>; // After defining the types for the pixels and the images used in the // example, we define the type for the PanTex filter. It is // templated by the input and output image types. - typedef otb::ScalarImageToPanTexTextureFilter<ImageType, ImageType> PanTexTextureFilterType; - typedef otb::ImageFileReader<ImageType> ReaderType; - typedef otb::ImageFileWriter<ImageType> WriterType; + using PanTexTextureFilterType = otb::ScalarImageToPanTexTextureFilter<ImageType, ImageType>; + using ReaderType = otb::ImageFileReader<ImageType>; + using WriterType = otb::ImageFileWriter<ImageType>; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); @@ -119,9 +119,9 @@ int main(int argc, char* argv[]) // Pretty image creation for printing - typedef otb::Image<unsigned char, Dimension> OutputPrettyImageType; - typedef otb::ImageFileWriter<OutputPrettyImageType> WriterPrettyOutputType; - typedef itk::RescaleIntensityImageFilter<ImageType, OutputPrettyImageType> RescalerOutputType; + using OutputPrettyImageType = otb::Image<unsigned char, Dimension>; + using WriterPrettyOutputType = otb::ImageFileWriter<OutputPrettyImageType>; + using RescalerOutputType = itk::RescaleIntensityImageFilter<ImageType, OutputPrettyImageType>; RescalerOutputType::Pointer outputRescaler = RescalerOutputType::New(); WriterPrettyOutputType::Pointer prettyOutputWriter = WriterPrettyOutputType::New(); diff --git a/Examples/FeatureExtraction/RatioLineDetectorExample.cxx b/Examples/FeatureExtraction/RatioLineDetectorExample.cxx index 51c519e07d7f6a62b7eb07502bba6d4edf3e6f84..1ea17023b82668e861995210864c4d584fede8ec 100644 --- a/Examples/FeatureExtraction/RatioLineDetectorExample.cxx +++ b/Examples/FeatureExtraction/RatioLineDetectorExample.cxx @@ -54,33 +54,33 @@ int main(int argc, char* argv[]) // choose to make all computations with floating point precision // and rescale the results between 0 and 255 in order to export PNG images. - typedef float InternalPixelType; - typedef unsigned char OutputPixelType; + using InternalPixelType = float; + using OutputPixelType = unsigned char; // The images are defined using the pixel type and the dimension. - typedef otb::Image<InternalPixelType, 2> InternalImageType; - typedef otb::Image<OutputPixelType, 2> OutputImageType; + using InternalImageType = otb::Image<InternalPixelType, 2>; + using OutputImageType = otb::Image<OutputPixelType, 2>; // The filter can be instantiated using the image types defined above. - typedef otb::LineRatioDetectorImageFilter<InternalImageType, InternalImageType> FilterType; + using FilterType = otb::LineRatioDetectorImageFilter<InternalImageType, InternalImageType>; // An \doxygen{otb}{ImageFileReader} class is also instantiated in order to read // image data from a file. - typedef otb::ImageFileReader<InternalImageType> ReaderType; + using ReaderType = otb::ImageFileReader<InternalImageType>; // An \doxygen{otb}{ImageFileWriter} is instantiated in order to write the // output image to a file. - typedef otb::ImageFileWriter<OutputImageType> WriterType; + using WriterType = otb::ImageFileWriter<OutputImageType>; // The intensity rescaling of the results will be carried out by the // \code{itk::RescaleIntensityImageFilter} which is templated by the // input and output image types. - typedef itk::RescaleIntensityImageFilter<InternalImageType, OutputImageType> RescalerType; + using RescalerType = itk::RescaleIntensityImageFilter<InternalImageType, OutputImageType>; // Both the filter and the reader are created by invoking their \code{New()} // methods and assigning the result to SmartPointers. diff --git a/Examples/FeatureExtraction/RightAngleDetectionExample.cxx b/Examples/FeatureExtraction/RightAngleDetectionExample.cxx index db09ada8a90f02221e10ef3fde3c8491df7894f0..6a20332b207c2620d3c0bdfcfc48b83b888dcf28 100644 --- a/Examples/FeatureExtraction/RightAngleDetectionExample.cxx +++ b/Examples/FeatureExtraction/RightAngleDetectionExample.cxx @@ -53,12 +53,12 @@ int main(int argc, char* argv[]) double angleThreshold = atof(argv[3]); double distanceThreshold = atof(argv[4]); - const unsigned int Dimension = 2; - typedef unsigned char PixelType; - typedef double PrecisionType; + const unsigned int Dimension = 2; + using PixelType = unsigned char; + using PrecisionType = double; - typedef otb::Image<PixelType, Dimension> ImageType; - typedef otb::ImageFileReader<ImageType> ReaderType; + using ImageType = otb::Image<PixelType, Dimension>; + using ReaderType = otb::ImageFileReader<ImageType>; auto reader = ReaderType::New(); reader->SetFileName(infname); @@ -70,20 +70,20 @@ int main(int argc, char* argv[]) // to store the detected lines which will be provided by the line // segment detector. - typedef otb::VectorData<PrecisionType> VectorDataType; + using VectorDataType = otb::VectorData<PrecisionType>; // The right angle detector's output is a vector data where each point // gives the coordinate of the detected angle. // // Next, We define the type for the line segment detector. A detailed // example for this detector can be found in section \ref{sec:LSD}. - typedef otb::LineSegmentDetector<ImageType, PrecisionType> LsdFilterType; + using LsdFilterType = otb::LineSegmentDetector<ImageType, PrecisionType>; // We can finally define the type for the right angle detection // filter. This filter is templated over the input vector data type // provided by the line segment detector. - typedef otb::VectorDataToRightAngleVectorDataFilter<VectorDataType> RightAngleFilterType; + using RightAngleFilterType = otb::VectorDataToRightAngleVectorDataFilter<VectorDataType>; // We instantiate the line segment detector and the right angle detector. @@ -101,7 +101,7 @@ int main(int argc, char* argv[]) rightAngleFilter->SetAngleThreshold(angleThreshold); rightAngleFilter->SetDistanceThreshold(distanceThreshold); - typedef otb::VectorDataFileWriter<LsdFilterType::VectorDataType> WriterType; + using WriterType = otb::VectorDataFileWriter<LsdFilterType::VectorDataType>; auto rightAngleWriter = WriterType::New(); diff --git a/Examples/FeatureExtraction/SFSExample.cxx b/Examples/FeatureExtraction/SFSExample.cxx index cf546cc1f0f7da1a445f635e74301fd44d41a6c3..1916fe0f0d9ec639b78cdae1ec67bd6513540ef8 100644 --- a/Examples/FeatureExtraction/SFSExample.cxx +++ b/Examples/FeatureExtraction/SFSExample.cxx @@ -61,7 +61,7 @@ int main(int itkNotUsed(argc), char* argv[]) { - typedef double PixelType; + using PixelType = double; const unsigned int Dimension = 2; std::string inName = argv[1]; @@ -86,13 +86,13 @@ int main(int itkNotUsed(argc), char* argv[]) // As with every OTB program, we start by defining the types for the // images, the readers and the writers. - typedef otb::Image<PixelType, Dimension> ImageType; - typedef otb::ImageFileReader<ImageType> ReaderType; - typedef otb::ImageFileWriter<ImageType> WriterType; + using ImageType = otb::Image<PixelType, Dimension>; + using ReaderType = otb::ImageFileReader<ImageType>; + using WriterType = otb::ImageFileWriter<ImageType>; // The we can instantiate the type for the SFS filter, which is // templated over the input and output pixel types. - typedef otb::SFSTexturesImageFilter<ImageType, ImageType> SFSFilterType; + using SFSFilterType = otb::SFSTexturesImageFilter<ImageType, ImageType>; // After that, we can instantiate the filter. We will also instantiate // the reader and one writer for each output image, since the SFS // filter generates 6 different features. @@ -181,9 +181,9 @@ int main(int itkNotUsed(argc), char* argv[]) // \end{figure} /************** pretty images for printing *********/ - typedef otb::Image<unsigned char, 2> OutputImageType; - typedef itk::RescaleIntensityImageFilter<ImageType, OutputImageType> RescalerType; - typedef otb::ImageFileWriter<OutputImageType> OutputWriterType; + using OutputImageType = otb::Image<unsigned char, 2>; + using RescalerType = itk::RescaleIntensityImageFilter<ImageType, OutputImageType>; + using OutputWriterType = otb::ImageFileWriter<OutputImageType>; RescalerType::Pointer rescaler = RescalerType::New(); rescaler->SetOutputMinimum(0); diff --git a/Examples/FeatureExtraction/SURFExample.cxx b/Examples/FeatureExtraction/SURFExample.cxx index 0c1afa2a1d6a06704fe2a7a41ca03f77055f12f2..85020bcc31030f0d1fb9d9ced370ab641385c298 100644 --- a/Examples/FeatureExtraction/SURFExample.cxx +++ b/Examples/FeatureExtraction/SURFExample.cxx @@ -63,18 +63,18 @@ int main(int argc, char* argv[]) // scalar image of float pixels. We also define the corresponding // image reader. - typedef float RealType; - typedef otb::Image<RealType, Dimension> ImageType; - typedef otb::ImageFileReader<ImageType> ReaderType; + using RealType = float; + using ImageType = otb::Image<RealType, Dimension>; + using ReaderType = otb::ImageFileReader<ImageType>; // The SURF descriptors will be stored in a point set containing the // vector of features. - typedef itk::VariableLengthVector<RealType> RealVectorType; - typedef itk::PointSet<RealVectorType, Dimension> PointSetType; + using RealVectorType = itk::VariableLengthVector<RealType>; + using PointSetType = itk::PointSet<RealVectorType, Dimension>; // The SURF filter itself is templated over the input image and the // generated point set. - typedef otb::ImageToSURFKeyPointSetFilter<ImageType, PointSetType> ImageToFastSURFKeyPointSetFilterType; + using ImageToFastSURFKeyPointSetFilterType = otb::ImageToSURFKeyPointSetFilter<ImageType, PointSetType>; // We instantiate the reader. ReaderType::Pointer reader = ReaderType::New(); @@ -94,10 +94,10 @@ int main(int argc, char* argv[]) // input image. In order to do this, we will create the following RGB // image and the corresponding writer: - typedef unsigned char PixelType; - typedef itk::RGBPixel<PixelType> RGBPixelType; - typedef otb::Image<RGBPixelType, 2> OutputImageType; - typedef otb::ImageFileWriter<OutputImageType> WriterType; + using PixelType = unsigned char; + using RGBPixelType = itk::RGBPixel<PixelType>; + using OutputImageType = otb::Image<RGBPixelType, 2>; + using WriterType = otb::ImageFileWriter<OutputImageType>; OutputImageType::Pointer outputImage = OutputImageType::New(); // We set the regions of the image by copying the information from the @@ -136,8 +136,8 @@ int main(int argc, char* argv[]) // going to walk through using an iterator. These are the types needed // for this task: - typedef PointSetType::PointsContainer PointsContainerType; - typedef PointsContainerType::Iterator PointsIteratorType; + using PointsContainerType = PointSetType::PointsContainer; + using PointsIteratorType = PointsContainerType::Iterator; // We set the iterator to the beginning of the point set. PointsIteratorType pIt = filter->GetOutput()->GetPoints()->Begin(); diff --git a/Examples/FeatureExtraction/TextureExample.cxx b/Examples/FeatureExtraction/TextureExample.cxx index 5705c69e64f14708a259f0274883f0ba4143af96..69198def26644c972d71fe694cce0db43205a6dc 100644 --- a/Examples/FeatureExtraction/TextureExample.cxx +++ b/Examples/FeatureExtraction/TextureExample.cxx @@ -54,16 +54,16 @@ int main(int argc, char* argv[]) const unsigned int xOffset = static_cast<unsigned int>(atoi(argv[5])); const unsigned int yOffset = static_cast<unsigned int>(atoi(argv[6])); - typedef double PixelType; - const int Dimension = 2; - typedef otb::Image<PixelType, Dimension> ImageType; + using PixelType = double; + const int Dimension = 2; + using ImageType = otb::Image<PixelType, Dimension>; // After defining the types for the pixels and the images used in the // example, we define the types for the textures filter. It is // templated by the input and output image types. - typedef otb::ScalarImageToTexturesFilter<ImageType, ImageType> TexturesFilterType; - typedef otb::ImageFileReader<ImageType> ReaderType; - typedef otb::ImageFileWriter<ImageType> WriterType; + using TexturesFilterType = otb::ScalarImageToTexturesFilter<ImageType, ImageType>; + using ReaderType = otb::ImageFileReader<ImageType>; + using WriterType = otb::ImageFileWriter<ImageType>; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); @@ -87,14 +87,14 @@ int main(int argc, char* argv[]) // The offset is always an array of N values, where N is the number of // dimensions of the image. - typedef ImageType::SizeType SizeType; - SizeType sradius; + using SizeType = ImageType::SizeType; + SizeType sradius; sradius.Fill(radius); texturesFilter->SetRadius(sradius); - typedef ImageType::OffsetType OffsetType; - OffsetType offset; + using OffsetType = ImageType::OffsetType; + OffsetType offset; offset[0] = xOffset; offset[1] = yOffset; @@ -117,12 +117,12 @@ int main(int argc, char* argv[]) writer->Update(); // Pretty image creation for printing - typedef otb::VectorImage<double, 2> VectorImageType; - typedef otb::VectorImage<unsigned char, 2> PrettyVectorImageType; - typedef otb::ImageFileWriter<PrettyVectorImageType> WriterPrettyOutputType; + using VectorImageType = otb::VectorImage<double, 2>; + using PrettyVectorImageType = otb::VectorImage<unsigned char, 2>; + using WriterPrettyOutputType = otb::ImageFileWriter<PrettyVectorImageType>; - typedef otb::ImageToVectorImageCastFilter<ImageType, VectorImageType> VectorCastFilterType; - typedef otb::VectorRescaleIntensityImageFilter<VectorImageType, PrettyVectorImageType> RescalerOutputType; + using VectorCastFilterType = otb::ImageToVectorImageCastFilter<ImageType, VectorImageType>; + using RescalerOutputType = otb::VectorRescaleIntensityImageFilter<VectorImageType, PrettyVectorImageType>; RescalerOutputType::Pointer outputRescaler = RescalerOutputType::New(); WriterPrettyOutputType::Pointer prettyOutputWriter = WriterPrettyOutputType::New(); diff --git a/Examples/FeatureExtraction/ThresholdToPointSetExample.cxx b/Examples/FeatureExtraction/ThresholdToPointSetExample.cxx index 44f2645a1b5f3b3f4c62d26da35971acc1f6f4cf..bf95ba45b4542073126c581fa6b5f48756a005cd 100644 --- a/Examples/FeatureExtraction/ThresholdToPointSetExample.cxx +++ b/Examples/FeatureExtraction/ThresholdToPointSetExample.cxx @@ -54,16 +54,16 @@ int main(int argc, char* argv[]) // The next step is to decide which pixel types to use for the input image // and the Point Set as well as their dimension. - typedef unsigned char PixelType; - const unsigned int Dimension = 2; + using PixelType = unsigned char; + const unsigned int Dimension = 2; - typedef otb::Image<PixelType, Dimension> ImageType; - typedef itk::PointSet<PixelType, Dimension> PointSetType; + using ImageType = otb::Image<PixelType, Dimension>; + using PointSetType = itk::PointSet<PixelType, Dimension>; // A reader is instantiated to read the input image - typedef otb::ImageFileReader<ImageType> ReaderType; - ReaderType::Pointer reader = ReaderType::New(); + using ReaderType = otb::ImageFileReader<ImageType>; + ReaderType::Pointer reader = ReaderType::New(); const char* filenamereader = argv[1]; reader->SetFileName(filenamereader); @@ -80,8 +80,8 @@ int main(int argc, char* argv[]) // Then we create the ThresholdImageToPointSetFilter and we pass the // parameters. - typedef otb::ThresholdImageToPointSetFilter<ImageType, PointSetType> FilterThresholdType; - FilterThresholdType::Pointer filterThreshold = FilterThresholdType::New(); + using FilterThresholdType = otb::ThresholdImageToPointSetFilter<ImageType, PointSetType>; + FilterThresholdType::Pointer filterThreshold = FilterThresholdType::New(); filterThreshold->SetLowerThreshold(lowerThreshold); filterThreshold->SetUpperThreshold(upperThreshold); filterThreshold->SetInput(0, reader->GetOutput()); @@ -100,10 +100,10 @@ int main(int argc, char* argv[]) // To display each point, we create an iterator on the list of points, // which is accessible through the method \code{GetPoints()} of the PointSet. - typedef PointSetType::PointsContainer ContainerType; - ContainerType* pointsContainer = pointSet->GetPoints(); - typedef ContainerType::Iterator IteratorType; - IteratorType itList = pointsContainer->Begin(); + using ContainerType = PointSetType::PointsContainer; + ContainerType* pointsContainer = pointSet->GetPoints(); + using IteratorType = ContainerType::Iterator; + IteratorType itList = pointsContainer->Begin(); // A while loop enable us to through the list a display the coordinate of // each point. diff --git a/Examples/FeatureExtraction/TouziEdgeDetectorExample.cxx b/Examples/FeatureExtraction/TouziEdgeDetectorExample.cxx index 7db34e035577d2282f2e651be609566a51c115a5..43b7d79a18e327586ebf32b116052e69d1d9ba11 100644 --- a/Examples/FeatureExtraction/TouziEdgeDetectorExample.cxx +++ b/Examples/FeatureExtraction/TouziEdgeDetectorExample.cxx @@ -63,33 +63,33 @@ int main(int argc, char* argv[]) // choose to make all computations with floating point precision // and rescale the results between 0 and 255 in order to export PNG images. - typedef float InternalPixelType; - typedef unsigned char OutputPixelType; + using InternalPixelType = float; + using OutputPixelType = unsigned char; // The images are defined using the pixel type and the dimension. - typedef otb::Image<InternalPixelType, 2> InternalImageType; - typedef otb::Image<OutputPixelType, 2> OutputImageType; + using InternalImageType = otb::Image<InternalPixelType, 2>; + using OutputImageType = otb::Image<OutputPixelType, 2>; // The filter can be instantiated using the image types defined above. - typedef otb::TouziEdgeDetectorImageFilter<InternalImageType, InternalImageType> FilterType; + using FilterType = otb::TouziEdgeDetectorImageFilter<InternalImageType, InternalImageType>; // An \doxygen{otb}{ImageFileReader} class is also instantiated in order to read // image data from a file. - typedef otb::ImageFileReader<InternalImageType> ReaderType; + using ReaderType = otb::ImageFileReader<InternalImageType>; // An \doxygen{otb}{ImageFileWriter} is instantiated in order to write the // output image to a file. - typedef otb::ImageFileWriter<OutputImageType> WriterType; + using WriterType = otb::ImageFileWriter<OutputImageType>; // The intensity rescaling of the results will be carried out by the // \code{itk::RescaleIntensityImageFilter} which is templated by the // input and output image types. - typedef itk::RescaleIntensityImageFilter<InternalImageType, OutputImageType> RescalerType; + using RescalerType = itk::RescaleIntensityImageFilter<InternalImageType, OutputImageType>; // Both the filter and the reader are created by invoking their \code{New()} // methods and assigning the result to SmartPointers. diff --git a/Examples/Filtering/CompositeFilterExample.cxx b/Examples/Filtering/CompositeFilterExample.cxx index 3c1a73a752697b0866b24b7e6c23fb481d382c49..208b94d02df94c8f487d4e31c4693c9aa4c7863d 100644 --- a/Examples/Filtering/CompositeFilterExample.cxx +++ b/Examples/Filtering/CompositeFilterExample.cxx @@ -57,10 +57,10 @@ public: // Next we have the standard declarations, used for object creation with // the object factory: - typedef CompositeExampleImageFilter Self; - typedef itk::ImageToImageFilter<TImageType, TImageType> Superclass; - typedef itk::SmartPointer<Self> Pointer; - typedef itk::SmartPointer<const Self> ConstPointer; + using Self = CompositeExampleImageFilter<TImageType>; + using Superclass = itk::ImageToImageFilter<TImageType, TImageType>; + using Pointer = itk::SmartPointer<Self>; + using ConstPointer = itk::SmartPointer<const Self>; /** Method for creation through object factory */ itkNewMacro(Self); @@ -75,7 +75,7 @@ public: // which determines the type of the threshold value. We then use the // convenience macros to define the Get and Set methods for this parameter. - typedef typename TImageType::PixelType PixelType; + using PixelType = typename TImageType::PixelType; itkGetMacro(Threshold, PixelType); itkSetMacro(Threshold, PixelType); @@ -88,9 +88,9 @@ protected: // enclosing image type: protected: - typedef itk::ThresholdImageFilter<TImageType> ThresholdType; - typedef itk::GradientMagnitudeImageFilter<TImageType, TImageType> GradientType; - typedef itk::RescaleIntensityImageFilter<TImageType, TImageType> RescalerType; + using ThresholdType = itk::ThresholdImageFilter<TImageType>; + using GradientType = itk::GradientMagnitudeImageFilter<TImageType, TImageType>; + using RescalerType = itk::RescaleIntensityImageFilter<TImageType, TImageType>; void GenerateData() override; @@ -187,11 +187,11 @@ int main(int argc, char* argv[]) return EXIT_FAILURE; } - typedef otb::Image<short, 2> ImageType; - typedef otb::ImageFileReader<ImageType> ReaderType; - typedef otb::ImageFileWriter<ImageType> WriterType; + using ImageType = otb::Image<short, 2>; + using ReaderType = otb::ImageFileReader<ImageType>; + using WriterType = otb::ImageFileWriter<ImageType>; - typedef otb::CompositeExampleImageFilter<ImageType> FilterType; + using FilterType = otb::CompositeExampleImageFilter<ImageType>; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); diff --git a/Examples/Filtering/DanielssonDistanceMapImageFilter.cxx b/Examples/Filtering/DanielssonDistanceMapImageFilter.cxx index 747e09f08cfdf74e21259fbc3fa4b67fcfa9e5ba..baca942dfee289479e622005eb02ac3a17516cad 100644 --- a/Examples/Filtering/DanielssonDistanceMapImageFilter.cxx +++ b/Examples/Filtering/DanielssonDistanceMapImageFilter.cxx @@ -66,10 +66,10 @@ int main(int argc, char* argv[]) // The input and output image types are now defined using their respective // pixel type and dimension. - typedef unsigned char InputPixelType; - typedef unsigned short OutputPixelType; - typedef otb::Image<InputPixelType, 2> InputImageType; - typedef otb::Image<OutputPixelType, 2> OutputImageType; + using InputPixelType = unsigned char; + using OutputPixelType = unsigned short; + using InputImageType = otb::Image<InputPixelType, 2>; + using OutputImageType = otb::Image<OutputPixelType, 2>; // The filter type can be instantiated using the input and output image // types defined above. A filter object is created with the \code{New()} @@ -79,20 +79,20 @@ int main(int argc, char* argv[]) // \index{itk::Danielsson\-Distance\-Map\-Image\-Filter!New()} // \index{itk::Danielsson\-Distance\-Map\-Image\-Filter!Pointer} - typedef itk::ConnectedComponentImageFilter<InputImageType, InputImageType> ConnectedType; - ConnectedType::Pointer connectedComponents = ConnectedType::New(); + using ConnectedType = itk::ConnectedComponentImageFilter<InputImageType, InputImageType>; + ConnectedType::Pointer connectedComponents = ConnectedType::New(); - typedef itk::DanielssonDistanceMapImageFilter<InputImageType, OutputImageType, OutputImageType> FilterType; - FilterType::Pointer filter = FilterType::New(); + using FilterType = itk::DanielssonDistanceMapImageFilter<InputImageType, OutputImageType, OutputImageType>; + FilterType::Pointer filter = FilterType::New(); - typedef itk::RescaleIntensityImageFilter<OutputImageType, OutputImageType> RescalerType; - RescalerType::Pointer scaler = RescalerType::New(); + using RescalerType = itk::RescaleIntensityImageFilter<OutputImageType, OutputImageType>; + RescalerType::Pointer scaler = RescalerType::New(); // // Reader and Writer types are instantiated. // - typedef otb::ImageFileReader<InputImageType> ReaderType; - typedef otb::ImageFileWriter<OutputImageType> WriterType; + using ReaderType = otb::ImageFileReader<InputImageType>; + using WriterType = otb::ImageFileWriter<OutputImageType>; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); diff --git a/Examples/Filtering/SecondDerivativeRecursiveGaussianImageFilter.cxx b/Examples/Filtering/SecondDerivativeRecursiveGaussianImageFilter.cxx index 580bd1cd15ea3c7bf9d989131578be38e3bedd4e..e7dacd6611a5b7868ff7bdb2d5983d41f3e9eef3 100644 --- a/Examples/Filtering/SecondDerivativeRecursiveGaussianImageFilter.cxx +++ b/Examples/Filtering/SecondDerivativeRecursiveGaussianImageFilter.cxx @@ -43,20 +43,20 @@ int main(int argc, char* argv[]) return EXIT_FAILURE; } - typedef float PixelType; - typedef float OutputPixelType; + using PixelType = float; + using OutputPixelType = float; const unsigned int Dimension = 2; - typedef otb::Image<PixelType, Dimension> ImageType; - typedef otb::Image<OutputPixelType, Dimension> OutputImageType; + using ImageType = otb::Image<PixelType, Dimension>; + using OutputImageType = otb::Image<OutputPixelType, Dimension>; - typedef otb::ImageFileReader<ImageType> ReaderType; - typedef otb::ImageFileWriter<OutputImageType> WriterType; + using ReaderType = otb::ImageFileReader<ImageType>; + using WriterType = otb::ImageFileWriter<OutputImageType>; - typedef itk::ImageDuplicator<OutputImageType> DuplicatorType; + using DuplicatorType = itk::ImageDuplicator<OutputImageType>; - typedef itk::RecursiveGaussianImageFilter<ImageType, ImageType> FilterType; + using FilterType = itk::RecursiveGaussianImageFilter<ImageType, ImageType>; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); diff --git a/Examples/Fusion/BayesianFusionImageFilter.cxx b/Examples/Fusion/BayesianFusionImageFilter.cxx index bfc9b5a94634edce50e7ca3b08ce2ed5e31fb9fc..50cc7d31d5fc916d307ed63071bee8fdf53613c7 100644 --- a/Examples/Fusion/BayesianFusionImageFilter.cxx +++ b/Examples/Fusion/BayesianFusionImageFilter.cxx @@ -103,19 +103,19 @@ int main(int argc, char* argv[]) // dimension. The panchromatic image is defined as an \doxygen{otb}{Image} // and the multispectral one as \doxygen{otb}{VectorImage}. - typedef double InternalPixelType; - const unsigned int Dimension = 2; - typedef otb::Image<InternalPixelType, Dimension> PanchroImageType; - typedef otb::VectorImage<InternalPixelType, Dimension> MultiSpecImageType; + using InternalPixelType = double; + const unsigned int Dimension = 2; + using PanchroImageType = otb::Image<InternalPixelType, Dimension>; + using MultiSpecImageType = otb::VectorImage<InternalPixelType, Dimension>; - typedef double OutputPixelType; - typedef otb::VectorImage<OutputPixelType, Dimension> OutputImageType; + using OutputPixelType = double; + using OutputImageType = otb::VectorImage<OutputPixelType, Dimension>; // We instantiate reader and writer types // - typedef otb::ImageFileReader<MultiSpecImageType> ReaderVectorType; - typedef otb::ImageFileReader<PanchroImageType> ReaderType; - typedef otb::ImageFileWriter<OutputImageType> WriterType; + using ReaderVectorType = otb::ImageFileReader<MultiSpecImageType>; + using ReaderType = otb::ImageFileReader<PanchroImageType>; + using WriterType = otb::ImageFileWriter<OutputImageType>; ReaderVectorType::Pointer multiSpectReader = ReaderVectorType::New(); ReaderVectorType::Pointer multiSpectInterpReader = ReaderVectorType::New(); @@ -130,7 +130,7 @@ int main(int argc, char* argv[]) // The Bayesian data fusion filter type is instantiated using the images types as // a template parameters. - typedef otb::BayesianFusionFilter<MultiSpecImageType, MultiSpecImageType, PanchroImageType, OutputImageType> BayesianFusionFilterType; + using BayesianFusionFilterType = otb::BayesianFusionFilter<MultiSpecImageType, MultiSpecImageType, PanchroImageType, OutputImageType>; // Next the filter is created by invoking the \code{New()} method and // assigning the result to a \doxygen{itk}{SmartPointer}. @@ -168,13 +168,13 @@ int main(int argc, char* argv[]) } // Create an 3 band images for the software guide - typedef unsigned char OutputPixelType2; - typedef otb::VectorImage<OutputPixelType2, Dimension> OutputVectorImageType; - typedef otb::ImageFileWriter<OutputVectorImageType> VectorWriterType; - typedef otb::VectorRescaleIntensityImageFilter<MultiSpecImageType, OutputVectorImageType> VectorRescalerType; - typedef otb::VectorRescaleIntensityImageFilter<OutputImageType, OutputVectorImageType> VectorRescalerBayesianType; - typedef otb::ImageToVectorImageCastFilter<PanchroImageType, MultiSpecImageType> CasterType; - typedef otb::MultiChannelExtractROI<OutputPixelType2, OutputPixelType2> ChannelExtractorType; + using OutputPixelType2 = unsigned char; + using OutputVectorImageType = otb::VectorImage<OutputPixelType2, Dimension>; + using VectorWriterType = otb::ImageFileWriter<OutputVectorImageType>; + using VectorRescalerType = otb::VectorRescaleIntensityImageFilter<MultiSpecImageType, OutputVectorImageType>; + using VectorRescalerBayesianType = otb::VectorRescaleIntensityImageFilter<OutputImageType, OutputVectorImageType>; + using CasterType = otb::ImageToVectorImageCastFilter<PanchroImageType, MultiSpecImageType>; + using ChannelExtractorType = otb::MultiChannelExtractROI<OutputPixelType2, OutputPixelType2>; multiSpectReader->GenerateOutputInformation(); multiSpectInterpReader->GenerateOutputInformation(); diff --git a/Examples/Fusion/PanSharpeningExample.cxx b/Examples/Fusion/PanSharpeningExample.cxx index 5be6ba95c95770f62d6c9cc3796b2b03c605d98f..8d30bf6ba2c0b0289006d9772cd06748054306dc 100644 --- a/Examples/Fusion/PanSharpeningExample.cxx +++ b/Examples/Fusion/PanSharpeningExample.cxx @@ -80,11 +80,11 @@ int main(int argc, char* argv[]) // \doxygen{otb}{Image} while the XS reader uses an // \doxygen{otb}{VectorImage}. - typedef otb::Image<double, 2> ImageType; - typedef otb::VectorImage<double, 2> VectorImageType; - typedef otb::ImageFileReader<ImageType> ReaderType; - typedef otb::ImageFileReader<VectorImageType> ReaderVectorType; - typedef otb::VectorImage<unsigned short int, 2> VectorIntImageType; + using ImageType = otb::Image<double, 2>; + using VectorImageType = otb::VectorImage<double, 2>; + using ReaderType = otb::ImageFileReader<ImageType>; + using ReaderVectorType = otb::ImageFileReader<VectorImageType>; + using VectorIntImageType = otb::VectorImage<unsigned short int, 2>; ReaderVectorType::Pointer readerXS = ReaderVectorType::New(); ReaderType::Pointer readerPAN = ReaderType::New(); @@ -96,26 +96,26 @@ int main(int argc, char* argv[]) // We declare the fusion filter an set its inputs using the readers: - typedef otb::SimpleRcsPanSharpeningFusionImageFilter<ImageType, VectorImageType, VectorIntImageType> FusionFilterType; - FusionFilterType::Pointer fusion = FusionFilterType::New(); + using FusionFilterType = otb::SimpleRcsPanSharpeningFusionImageFilter<ImageType, VectorImageType, VectorIntImageType>; + FusionFilterType::Pointer fusion = FusionFilterType::New(); fusion->SetPanInput(readerPAN->GetOutput()); fusion->SetXsInput(readerXS->GetOutput()); // And finally, we declare the writer and call its \code{Update()} method to // trigger the full pipeline execution. - typedef otb::ImageFileWriter<VectorIntImageType> WriterType; - WriterType::Pointer writer = WriterType::New(); + using WriterType = otb::ImageFileWriter<VectorIntImageType>; + WriterType::Pointer writer = WriterType::New(); writer->SetFileName(argv[3]); writer->SetInput(fusion->GetOutput()); writer->Update(); - typedef otb::PrintableImageFilter<VectorIntImageType> PrintableImageType; - PrintableImageType::Pointer printable = PrintableImageType::New(); + using PrintableImageType = otb::PrintableImageFilter<VectorIntImageType>; + PrintableImageType::Pointer printable = PrintableImageType::New(); - typedef otb::VectorImage<unsigned char, 2> VectorCharImageType; - typedef otb::ImageFileWriter<VectorCharImageType> PNGWriterType; - PNGWriterType::Pointer pngwriter = PNGWriterType::New(); + using VectorCharImageType = otb::VectorImage<unsigned char, 2>; + using PNGWriterType = otb::ImageFileWriter<VectorCharImageType>; + PNGWriterType::Pointer pngwriter = PNGWriterType::New(); printable->SetInput(fusion->GetOutput()); printable->SetChannel(3); @@ -125,8 +125,8 @@ int main(int argc, char* argv[]) pngwriter->SetInput(printable->GetOutput()); pngwriter->Update(); - typedef otb::PrintableImageFilter<VectorImageType> PrintableImageType2; - PrintableImageType2::Pointer printable2 = PrintableImageType2::New(); + using PrintableImageType2 = otb::PrintableImageFilter<VectorImageType>; + PrintableImageType2::Pointer printable2 = PrintableImageType2::New(); printable2->SetInput(readerXS->GetOutput()); printable2->SetChannel(3); printable2->SetChannel(2); @@ -135,7 +135,7 @@ int main(int argc, char* argv[]) pngwriter->SetInput(printable2->GetOutput()); pngwriter->Update(); - typedef otb::ImageToVectorImageCastFilter<ImageType, VectorImageType> VectorCastFilterType; + using VectorCastFilterType = otb::ImageToVectorImageCastFilter<ImageType, VectorImageType>; VectorCastFilterType::Pointer vectorCastFilter = VectorCastFilterType::New(); PNGWriterType::Pointer pngwriterPan = PNGWriterType::New(); diff --git a/Examples/Hyperspectral/HyperspectralUnmixingExample.cxx b/Examples/Hyperspectral/HyperspectralUnmixingExample.cxx index e45218c390298e7cf84f31a29fec2b9575340f57..f323ef644a08046672fe1665b5189b6a567be0d0 100644 --- a/Examples/Hyperspectral/HyperspectralUnmixingExample.cxx +++ b/Examples/Hyperspectral/HyperspectralUnmixingExample.cxx @@ -60,18 +60,18 @@ int main(int argc, char* argv[]) const unsigned int estimateNumberOfEndmembers = atoi(argv[6]); const unsigned int Dimension = 2; - typedef double PixelType; + using PixelType = double; // We start by defining the types for the images and the reader and // the writer. We choose to work with a \doxygen{otb}{VectorImage}, // since we will produce a multi-channel image (the principal // components) from a multi-channel input image. - typedef otb::VectorImage<PixelType, Dimension> ImageType; - typedef otb::ImageFileReader<ImageType> ReaderType; - typedef otb::ImageFileWriter<ImageType> WriterType; + using ImageType = otb::VectorImage<PixelType, Dimension>; + using ReaderType = otb::ImageFileReader<ImageType>; + using WriterType = otb::ImageFileWriter<ImageType>; - typedef otb::VectorRescaleIntensityImageFilter<ImageType, ImageType> RescalerType; - typedef otb::VectorImageToMatrixImageFilter<ImageType> VectorImageToMatrixImageFilterType; + using RescalerType = otb::VectorRescaleIntensityImageFilter<ImageType, ImageType>; + using VectorImageToMatrixImageFilterType = otb::VectorImageToMatrixImageFilter<ImageType>; // We set the seed of the random number generator. @@ -106,8 +106,8 @@ int main(int argc, char* argv[]) // needs to be estimated. // We can now the instantiate the filter. - typedef otb::VCAImageFilter<ImageType> VCAFilterType; - VCAFilterType::Pointer vca = VCAFilterType::New(); + using VCAFilterType = otb::VCAImageFilter<ImageType>; + VCAFilterType::Pointer vca = VCAFilterType::New(); vca->SetNumberOfEndmembers(estimateNumberOfEndmembers); vca->SetInput(rescaler->GetOutput()); @@ -122,8 +122,8 @@ int main(int argc, char* argv[]) // We can now procedd to the unmixing algorithm.Parameters // needed are the input image and the endmembers matrix. - typedef otb::UnConstrainedLeastSquareImageFilter<ImageType, ImageType, double> UCLSUnmixingFilterType; - UCLSUnmixingFilterType::Pointer unmixer = UCLSUnmixingFilterType::New(); + using UCLSUnmixingFilterType = otb::UnConstrainedLeastSquareImageFilter<ImageType, ImageType, double>; + UCLSUnmixingFilterType::Pointer unmixer = UCLSUnmixingFilterType::New(); unmixer->SetInput(rescaler->GetOutput()); unmixer->GetModifiableFunctor().SetMatrix(endMember2Matrix->GetMatrix()); @@ -152,11 +152,11 @@ int main(int argc, char* argv[]) // \label{fig:UNMIXING_FILTER} // \end{figure} - typedef otb::Image<PixelType, Dimension> MonoImageType; - typedef otb::MultiToMonoChannelExtractROI<PixelType, PixelType> ExtractROIFilterType; - typedef otb::Image<unsigned char, 2> OutputImageType; - typedef itk::RescaleIntensityImageFilter<MonoImageType, OutputImageType> PrettyRescalerType; - typedef otb::ImageFileWriter<OutputImageType> WriterType2; + using MonoImageType = otb::Image<PixelType, Dimension>; + using ExtractROIFilterType = otb::MultiToMonoChannelExtractROI<PixelType, PixelType>; + using OutputImageType = otb::Image<unsigned char, 2>; + using PrettyRescalerType = itk::RescaleIntensityImageFilter<MonoImageType, OutputImageType>; + using WriterType2 = otb::ImageFileWriter<OutputImageType>; for (unsigned int cpt = 0; cpt < 3; ++cpt) { diff --git a/Examples/IO/ComplexImageReadWrite.cxx b/Examples/IO/ComplexImageReadWrite.cxx index 1db668a546f06a5ab84a998b08fe1f38c5a6b4ad..6ebdd56696e89379337ef6dd533a663efb68dd82 100644 --- a/Examples/IO/ComplexImageReadWrite.cxx +++ b/Examples/IO/ComplexImageReadWrite.cxx @@ -55,14 +55,14 @@ int main(int argc, char* argv[]) const unsigned int Dimension = 2; - typedef std::complex<float> PixelType; - typedef otb::Image<PixelType, Dimension> ImageType; + using PixelType = std::complex<float>; + using ImageType = otb::Image<PixelType, Dimension>; // The image file reader and writer types are instantiated using the image // type. We can then create objects for both of them. - typedef otb::ImageFileReader<ImageType> ReaderType; - typedef otb::ImageFileWriter<ImageType> WriterType; + using ReaderType = otb::ImageFileReader<ImageType>; + using WriterType = otb::ImageFileWriter<ImageType>; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); diff --git a/Examples/IO/DEMToImageGenerator.cxx b/Examples/IO/DEMToImageGenerator.cxx index 04e1ea3d6a33beffc9773b6ea1ed32d5daf07f81..5e6925daba37e1bfd4f61d5a3d9107849a8f98d5 100644 --- a/Examples/IO/DEMToImageGenerator.cxx +++ b/Examples/IO/DEMToImageGenerator.cxx @@ -58,26 +58,26 @@ int main(int argc, char* argv[]) // The image type is now defined using pixel type and // dimension. The output image is defined as an \doxygen{otb}{Image}. - char* folderPath = argv[9]; - char* outputName = argv[1]; - const unsigned int Dimension = 2; - typedef otb::Image<double, Dimension> ImageType; + char* folderPath = argv[9]; + char* outputName = argv[1]; + const unsigned int Dimension = 2; + using ImageType = otb::Image<double, Dimension>; // The writer is defined - typedef otb::ImageFileWriter<ImageType> WriterType; + using WriterType = otb::ImageFileWriter<ImageType>; // The DEMToImageGenerator is defined using the image pixel // type as a template parameter. After that, the object can be instancied. - typedef otb::DEMToImageGenerator<ImageType> DEMToImageGeneratorType; + using DEMToImageGeneratorType = otb::DEMToImageGenerator<ImageType>; DEMToImageGeneratorType::Pointer object = DEMToImageGeneratorType::New(); // Input parameter types are defined to set the value in the \doxygen{otb}{DEMToImageGenerator}. - typedef DEMToImageGeneratorType::SizeType SizeType; - typedef DEMToImageGeneratorType::SpacingType SpacingType; - typedef DEMToImageGeneratorType::PointType PointType; + using SizeType = DEMToImageGeneratorType::SizeType; + using SpacingType = DEMToImageGeneratorType::SpacingType; + using PointType = DEMToImageGeneratorType::PointType; // Instantiating writer WriterType::Pointer writer = WriterType::New(); @@ -136,10 +136,10 @@ int main(int argc, char* argv[]) } // Pretty image creation for the printing - typedef otb::Image<unsigned char, Dimension> OutputPrettyImageType; - typedef otb::ImageFileWriter<OutputPrettyImageType> WriterPrettyType; - typedef itk::RescaleIntensityImageFilter<ImageType, OutputPrettyImageType> RescalerType; - typedef itk::ThresholdImageFilter<ImageType> ThresholderType; + using OutputPrettyImageType = otb::Image<unsigned char, Dimension>; + using WriterPrettyType = otb::ImageFileWriter<OutputPrettyImageType>; + using RescalerType = itk::RescaleIntensityImageFilter<ImageType, OutputPrettyImageType>; + using ThresholderType = itk::ThresholdImageFilter<ImageType>; ThresholderType::Pointer thresholder = ThresholderType::New(); RescalerType::Pointer rescaler = RescalerType::New(); diff --git a/Examples/IO/ExtractROI.cxx b/Examples/IO/ExtractROI.cxx index 5d5d0a5c34509488caf3d0e93e1f45f50ec0e071..78d7587b0bcadc6bfeb4d807cc6bdc4ee6cc4241 100644 --- a/Examples/IO/ExtractROI.cxx +++ b/Examples/IO/ExtractROI.cxx @@ -70,8 +70,8 @@ int main(int argc, char* argv[]) // As usual, we define the input and output pixel types. - typedef unsigned char InputPixelType; - typedef unsigned char OutputPixelType; + using InputPixelType = unsigned char; + using OutputPixelType = unsigned char; // First of all, we extract the multiband part by using the // \doxygen{otb}{MultiChannelExtractROI} class, which is templated @@ -79,7 +79,7 @@ int main(int argc, char* argv[]) // templated over the images types in order to force these images // to be of \doxygen{otb}{VectorImage} type. - typedef otb::MultiChannelExtractROI<InputPixelType, OutputPixelType> ExtractROIFilterType; + using ExtractROIFilterType = otb::MultiChannelExtractROI<InputPixelType, OutputPixelType>; // We create the extractor filter by using the \code{New} method of // the class and we set its parameters. @@ -101,8 +101,8 @@ int main(int argc, char* argv[]) // We will use the OTB readers and writers for file access. - typedef otb::ImageFileReader<ExtractROIFilterType::InputImageType> ReaderType; - typedef otb::ImageFileWriter<ExtractROIFilterType::InputImageType> WriterType; + using ReaderType = otb::ImageFileReader<ExtractROIFilterType::InputImageType>; + using WriterType = otb::ImageFileWriter<ExtractROIFilterType::InputImageType>; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); @@ -141,7 +141,7 @@ int main(int argc, char* argv[]) // memory usage point of view. // This class is also templated over the pixel types. - typedef otb::MultiToMonoChannelExtractROI<InputPixelType, OutputPixelType> ExtractROIMonoFilterType; + using ExtractROIMonoFilterType = otb::MultiToMonoChannelExtractROI<InputPixelType, OutputPixelType>; ExtractROIMonoFilterType::Pointer extractROIMonoFilter = ExtractROIMonoFilterType::New(); @@ -154,10 +154,10 @@ int main(int argc, char* argv[]) extractROIMonoFilter->SetChannel(4); - typedef otb::ImageFileReader<ExtractROIMonoFilterType::InputImageType> monoReaderType; - typedef otb::ImageFileWriter<ExtractROIMonoFilterType::OutputImageType> monoWriterType; - monoReaderType::Pointer monoReader = monoReaderType::New(); - monoWriterType::Pointer monoWriter = monoWriterType::New(); + using monoReaderType = otb::ImageFileReader<ExtractROIMonoFilterType::InputImageType>; + using monoWriterType = otb::ImageFileWriter<ExtractROIMonoFilterType::OutputImageType>; + monoReaderType::Pointer monoReader = monoReaderType::New(); + monoWriterType::Pointer monoWriter = monoWriterType::New(); monoReader->SetFileName(inputFilename); monoReader->Update(); // Needed to know the number of channels in the image diff --git a/Examples/IO/ImageReadCastWrite.cxx b/Examples/IO/ImageReadCastWrite.cxx index 3c1d2e8144d711a991f0fee03275a25ffbbf2351..c1a066c384f60b54962399540d91e97f77e791b3 100644 --- a/Examples/IO/ImageReadCastWrite.cxx +++ b/Examples/IO/ImageReadCastWrite.cxx @@ -59,12 +59,12 @@ int main(int argc, char* argv[]) // the image stored in the file. Instead, it is the type that will be // used to store the image as soon as it is read into memory. - typedef float InputPixelType; - typedef unsigned char OutputPixelType; - const unsigned int Dimension = 2; + using InputPixelType = float; + using OutputPixelType = unsigned char; + const unsigned int Dimension = 2; - typedef otb::Image<InputPixelType, Dimension> InputImageType; - typedef otb::Image<OutputPixelType, Dimension> OutputImageType; + using InputImageType = otb::Image<InputPixelType, Dimension>; + using OutputImageType = otb::Image<OutputPixelType, Dimension>; // We can now instantiate the types of the reader and writer. These two // classes are parameterized over the image type. @@ -72,13 +72,13 @@ int main(int argc, char* argv[]) // \index{otb::ImageFileReader!Instantiation} // \index{otb::ImageFileWriter!Instantiation} - typedef otb::ImageFileReader<InputImageType> ReaderType; - typedef otb::ImageFileWriter<OutputImageType> WriterType; + using ReaderType = otb::ImageFileReader<InputImageType>; + using WriterType = otb::ImageFileWriter<OutputImageType>; // Below we instantiate the RescaleIntensityImageFilter class that will // linearly scale the image intensities. - typedef itk::RescaleIntensityImageFilter<InputImageType, OutputImageType> FilterType; + using FilterType = itk::RescaleIntensityImageFilter<InputImageType, OutputImageType>; // A filter object is constructed and the minimum and maximum values of // the output are selected using the SetOutputMinimum() and diff --git a/Examples/IO/ImageReadRegionOfInterestWrite.cxx b/Examples/IO/ImageReadRegionOfInterestWrite.cxx index b169c652aa8c0e1267e123372c73326bcbbaa877..05661299cfd3a7e5ffe27e983a966b493a3a190e 100644 --- a/Examples/IO/ImageReadRegionOfInterestWrite.cxx +++ b/Examples/IO/ImageReadRegionOfInterestWrite.cxx @@ -53,17 +53,17 @@ int main(int argc, char* argv[]) // Image types are defined below. - typedef unsigned char InputPixelType; - typedef unsigned char OutputPixelType; - const unsigned int Dimension = 2; - typedef otb::Image<InputPixelType, Dimension> InputImageType; - typedef otb::Image<OutputPixelType, Dimension> OutputImageType; + using InputPixelType = unsigned char; + using OutputPixelType = unsigned char; + const unsigned int Dimension = 2; + using InputImageType = otb::Image<InputPixelType, Dimension>; + using OutputImageType = otb::Image<OutputPixelType, Dimension>; // The types for the \doxygen{otb}{ImageFileReader} and \doxygen{otb}{ImageFileWriter} // are instantiated using the image types. - typedef otb::ImageFileReader<InputImageType> ReaderType; - typedef otb::ImageFileWriter<OutputImageType> WriterType; + using ReaderType = otb::ImageFileReader<InputImageType>; + using WriterType = otb::ImageFileWriter<OutputImageType>; // The ExtractROI type is instantiated using // the input and output pixel types. Using the pixel types as @@ -74,7 +74,7 @@ int main(int argc, char* argv[]) // \doxygen{otb}{VectorImage}s. A filter object is created with the // New() method and assigned to a \doxygen{itk}{SmartPointer}. - typedef otb::ExtractROI<InputImageType::PixelType, OutputImageType::PixelType> FilterType; + using FilterType = otb::ExtractROI<InputImageType::PixelType, OutputImageType::PixelType>; FilterType::Pointer filter = FilterType::New(); diff --git a/Examples/IO/ImageReadWrite.cxx b/Examples/IO/ImageReadWrite.cxx index 1e01ad77cf2bd654b44553fb0095b5c310a5e2d8..2bf09ac11a3fc91d1fcd066468a67770ef10e511 100644 --- a/Examples/IO/ImageReadWrite.cxx +++ b/Examples/IO/ImageReadWrite.cxx @@ -78,9 +78,9 @@ int main(int argc, char* argv[]) // A typical selection for remote sensing images is illustrated in // the following lines. - typedef unsigned short PixelType; - const unsigned int Dimension = 2; - typedef otb::Image<PixelType, Dimension> ImageType; + using PixelType = unsigned short; + const unsigned int Dimension = 2; + using ImageType = otb::Image<PixelType, Dimension>; // Note that the dimension of the image in memory should match the one of // the image in file. There are a couple of special cases in which this @@ -94,8 +94,8 @@ int main(int argc, char* argv[]) // \index{otb::ImageFileReader!Instantiation} // \index{otb::ImageFileWriter!Instantiation} - typedef otb::ImageFileReader<ImageType> ReaderType; - typedef otb::ImageFileWriter<ImageType> WriterType; + using ReaderType = otb::ImageFileReader<ImageType>; + using WriterType = otb::ImageFileWriter<ImageType>; // Then, we create one object of each type using the New() method and // assigning the result to a \doxygen{itk}{SmartPointer}. diff --git a/Examples/IO/ImageSeriesIOExample.cxx b/Examples/IO/ImageSeriesIOExample.cxx index bd5f6fda12a6cd7d7d01226a36c96f52100ac20e..467eada48f9f6f92495f4c5d4080c2552fec683f 100644 --- a/Examples/IO/ImageSeriesIOExample.cxx +++ b/Examples/IO/ImageSeriesIOExample.cxx @@ -52,19 +52,19 @@ int main(int argc, char** argv) // We will start by defining the types for the input images and the // associated readers. - typedef unsigned short int PixelType; - const unsigned int Dimension = 2; + using PixelType = unsigned short; + const unsigned int Dimension = 2; - typedef otb::Image<PixelType, Dimension> InputImageType; + using InputImageType = otb::Image<PixelType, Dimension>; - typedef otb::ImageFileReader<InputImageType> ImageReaderType; + using ImageReaderType = otb::ImageFileReader<InputImageType>; // We will use a list of image file readers in order to open all the // input images at once. For this, we use the // \doxygen{otb}{ObjectList} object and we template it over the type // of the readers. - typedef otb::ObjectList<ImageReaderType> ReaderListType; + using ReaderListType = otb::ObjectList<ImageReaderType>; ReaderListType::Pointer readerList = ReaderListType::New(); @@ -73,7 +73,7 @@ int main(int argc, char** argv) // us to build a pipeline without really reading the images and using // lots of RAM. The \doxygen{otb}{ImageList} object will be used. - typedef otb::ImageList<InputImageType> ImageListType; + using ImageListType = otb::ImageList<InputImageType>; ImageListType::Pointer imageList = ImageListType::New(); @@ -101,9 +101,9 @@ int main(int argc, char** argv) // \doxygen{otb}{ImageListToVectorImageFilter} which is templated // over the input image list type and the output vector image type. - typedef otb::VectorImage<PixelType, Dimension> VectorImageType; + using VectorImageType = otb::VectorImage<PixelType, Dimension>; - typedef otb::ImageListToVectorImageFilter<ImageListType, VectorImageType> ImageListToVectorImageFilterType; + using ImageListToVectorImageFilterType = otb::ImageListToVectorImageFilter<ImageListType, VectorImageType>; ImageListToVectorImageFilterType::Pointer iL2VI = ImageListToVectorImageFilterType::New(); @@ -114,7 +114,7 @@ int main(int argc, char** argv) iL2VI->SetInput(imageList); - typedef otb::ImageFileWriter<VectorImageType> ImageWriterType; + using ImageWriterType = otb::ImageFileWriter<VectorImageType>; ImageWriterType::Pointer imageWriter = ImageWriterType::New(); diff --git a/Examples/IO/MetadataExample.cxx b/Examples/IO/MetadataExample.cxx index e2875c34df3994e0be11926e81c2f2e7c594d84e..2defc8098a6f0bcc05226af593dbec6ba0b2fcd2 100644 --- a/Examples/IO/MetadataExample.cxx +++ b/Examples/IO/MetadataExample.cxx @@ -52,12 +52,12 @@ int main(int itkNotUsed(argc), char* argv[]) // and writing the metadata to an output ASCII file. As usual we // start by defining the types needed for the image to be read. - typedef unsigned char InputPixelType; - const unsigned int Dimension = 2; + using InputPixelType = unsigned char; + const unsigned int Dimension = 2; - typedef otb::Image<InputPixelType, Dimension> InputImageType; + using InputImageType = otb::Image<InputPixelType, Dimension>; - typedef otb::ImageFileReader<InputImageType> ReaderType; + using ReaderType = otb::ImageFileReader<InputImageType>; // We can now instantiate the reader and get a pointer to the input image. diff --git a/Examples/IO/MultibandImageReadWrite.cxx b/Examples/IO/MultibandImageReadWrite.cxx index 59853d649cec9ca40b013c843ba70172ceb822e4..8973c806867eb14c7b52239f48e4be7a2781c7f4 100644 --- a/Examples/IO/MultibandImageReadWrite.cxx +++ b/Examples/IO/MultibandImageReadWrite.cxx @@ -63,9 +63,9 @@ int main(int argc, char* argv[]) // do: // - typedef unsigned short PixelType; - const unsigned int Dimension = 2; - typedef otb::VectorImage<PixelType, Dimension> ImageType; + using PixelType = unsigned short; + const unsigned int Dimension = 2; + using ImageType = otb::VectorImage<PixelType, Dimension>; // We can now instantiate the types of the reader and writer. These two // classes are parameterized over the image type. @@ -73,8 +73,8 @@ int main(int argc, char* argv[]) // \index{otb::ImageFileReader!Instantiation} // \index{otb::ImageFileWriter!Instantiation} - typedef otb::ImageFileReader<ImageType> ReaderType; - typedef otb::ImageFileWriter<ImageType> WriterType; + using ReaderType = otb::ImageFileReader<ImageType>; + using WriterType = otb::ImageFileWriter<ImageType>; // Then, we create one object of each type using the New() method and // assigning the result to a \doxygen{itk}{SmartPointer}. diff --git a/Examples/IO/VectorDataIOExample.cxx b/Examples/IO/VectorDataIOExample.cxx index 0eef2e3ccabeb993aff5a58a336e08fc33d54365..dc8b451ccfad8d612cb843e023244321f55c823c 100644 --- a/Examples/IO/VectorDataIOExample.cxx +++ b/Examples/IO/VectorDataIOExample.cxx @@ -64,14 +64,14 @@ int main(int argc, char* argv[]) return EXIT_FAILURE; } - typedef unsigned short int PixelType; + using PixelType = unsigned short; // We define the types for the vector data structure and the // corresponding file reader. - typedef otb::VectorData<PixelType, 2> VectorDataType; + using VectorDataType = otb::VectorData<PixelType, 2>; - typedef otb::VectorDataFileReader<VectorDataType> VectorDataFileReaderType; + using VectorDataFileReaderType = otb::VectorDataFileReader<VectorDataType>; // We can now instantiate the reader and read the data. VectorDataFileReaderType::Pointer reader = VectorDataFileReaderType::New(); @@ -81,15 +81,15 @@ int main(int argc, char* argv[]) // nodes containing the actual objects of the scene. This tree will // be accessed using an \doxygen{itk}{PreOrderTreeIterator}. - typedef VectorDataType::DataTreeType DataTreeType; - typedef itk::PreOrderTreeIterator<DataTreeType> TreeIteratorType; + using DataTreeType = VectorDataType::DataTreeType; + using TreeIteratorType = itk::PreOrderTreeIterator<DataTreeType>; // In this example we will only read polygon objects from the input // file before writing them to the output file. We define the type // for the polygon object as well as an iterator to the vertices. The // polygons obtained will be stored in an \doxygen{otb}{ObjectList}. - typedef otb::Polygon<double> PolygonType; - typedef otb::ObjectList<PolygonType> PolygonListType; + using PolygonType = otb::Polygon<double>; + using PolygonListType = otb::ObjectList<PolygonType>; PolygonListType::Pointer polygonList = PolygonListType::New(); // We get the data tree and instantiate an iterator to walk through it. @@ -118,7 +118,7 @@ int main(int argc, char* argv[]) VectorDataType::Pointer outVectorData = VectorDataType::New(); - typedef VectorDataType::DataNodeType DataNodeType; + using DataNodeType = VectorDataType::DataNodeType; // We fill the data structure with the nodes. The root node is a // document which is composed of folders. A list of polygons can be // seen as a multi polygon object. @@ -150,7 +150,7 @@ int main(int argc, char* argv[]) // And finally we write the vector data to a file using a generic // \doxygen{otb}{VectorDataFileWriter}. - typedef otb::VectorDataFileWriter<VectorDataType> WriterType; + using WriterType = otb::VectorDataFileWriter<VectorDataType>; WriterType::Pointer writer = WriterType::New(); writer->SetInput(outVectorData); diff --git a/Examples/Image/Image1.cxx b/Examples/Image/Image1.cxx index b6818eff52faa6030501a8f3aee44ce187d80220..f93d8206ebcfd6b9ed98557f22ecb40891f59dd4 100644 --- a/Examples/Image/Image1.cxx +++ b/Examples/Image/Image1.cxx @@ -31,7 +31,7 @@ #include "otbImage.h" -int main(int, char* []) +int main(int, char*[]) { // Then we must decide with what type to represent the pixels // and what the dimension of the image will be. With these two @@ -39,7 +39,7 @@ int main(int, char* []) // a 2D image, which is what we often use in remote sensing // applications, anyway, with \code{unsigned short} pixel data. // - typedef otb::Image<unsigned short, 2> ImageType; + using ImageType = otb::Image<unsigned short, 2>; // The image can then be created by invoking the \code{New()} operator // from the corresponding image type and assigning the result diff --git a/Examples/Image/Image2.cxx b/Examples/Image/Image2.cxx index 797cc357f35fb24537633719f0ac472564867a84..811640cab6fd531cc9466657471767fab8556d0f 100644 --- a/Examples/Image/Image2.cxx +++ b/Examples/Image/Image2.cxx @@ -32,10 +32,10 @@ int main(int, char* argv[]) // Then, the image type should be defined by specifying the // type used to represent pixels and the dimensions of the image. - typedef unsigned char PixelType; - const unsigned int Dimension = 2; + using PixelType = unsigned char; + const unsigned int Dimension = 2; - typedef otb::Image<PixelType, Dimension> ImageType; + using ImageType = otb::Image<PixelType, Dimension>; // Using the image type, it is now possible to instantiate the image reader // class. The image type is used as a template parameter to define how the @@ -51,7 +51,7 @@ int main(int, char* argv[]) // \index{otb::ImageFileReader!Instantiation} // \index{otb::Image!read} - typedef otb::ImageFileReader<ImageType> ReaderType; + using ReaderType = otb::ImageFileReader<ImageType>; // The reader type can now be used to create one reader object. A // \doxygen{itk}{SmartPointer} (defined by the \code{::Pointer} diff --git a/Examples/Image/Image3.cxx b/Examples/Image/Image3.cxx index b00873ccad1c7a3d87edff3bbb7409ccc52f0d69..8ab782ef5f3beb34f9ae3e0381b14ea0274aba74 100644 --- a/Examples/Image/Image3.cxx +++ b/Examples/Image/Image3.cxx @@ -32,10 +32,10 @@ #include "otbImage.h" -int main(int, char* []) +int main(int, char*[]) { // First the image type should be declared - typedef otb::Image<unsigned short, 2> ImageType; + using ImageType = otb::Image<unsigned short, 2>; // Then the image object can be created ImageType::Pointer image = ImageType::New(); diff --git a/Examples/Image/Image4.cxx b/Examples/Image/Image4.cxx index d3393191318407b2697067d983a8b90c47d7515b..0538d67953226d14fd8fffabfc5d76a6b43d1568 100644 --- a/Examples/Image/Image4.cxx +++ b/Examples/Image/Image4.cxx @@ -61,9 +61,9 @@ #include "otbImage.h" #include "itkPoint.h" -int main(int, char* []) +int main(int, char*[]) { - typedef otb::Image<unsigned short, 2> ImageType; + using ImageType = otb::Image<unsigned short, 2>; ImageType::Pointer image = ImageType::New(); @@ -164,7 +164,7 @@ int main(int, char* []) // dimension of the space. In this particular case, the dimension of the // point must match the dimension of the image. - typedef itk::Point<double, ImageType::ImageDimension> PointType; + using PointType = itk::Point<double, ImageType::ImageDimension>; // The Point class, like an \doxygen{itk}{Index}, is a relatively small and // simple object. For this reason, it is not reference-counted like the diff --git a/Examples/Image/Image5.cxx b/Examples/Image/Image5.cxx index 45eb939ab0998cfdbc593deec39edd3adead74c9..6cf21c08435f207cb02748f2b0672e49c748a912 100644 --- a/Examples/Image/Image5.cxx +++ b/Examples/Image/Image5.cxx @@ -58,16 +58,16 @@ int main(int argc, char* argv[]) // assume that the external block of memory uses the same data type to // represent the pixels. // - typedef unsigned char PixelType; - const unsigned int Dimension = 2; - typedef otb::Image<PixelType, Dimension> ImageType; + using PixelType = unsigned char; + const unsigned int Dimension = 2; + using ImageType = otb::Image<PixelType, Dimension>; // The type of the ImportImageFilter is instantiated in the // following line. // // \index{otb::ImportImageFilter!Instantiation} - typedef otb::ImportImageFilter<ImageType> ImportFilterType; + using ImportFilterType = otb::ImportImageFilter<ImageType>; // A filter object created using the \code{New()} method is then // assigned to a \code{SmartPointer}. @@ -174,8 +174,8 @@ int main(int argc, char* argv[]) // Finally, we can connect the output of this filter to a pipeline. // For simplicity we just use a writer here, but it could be any other filter. - typedef otb::ImageFileWriter<ImageType> WriterType; - WriterType::Pointer writer = WriterType::New(); + using WriterType = otb::ImageFileWriter<ImageType>; + WriterType::Pointer writer = WriterType::New(); writer->SetFileName(argv[1]); diff --git a/Examples/Image/ImageListExample.cxx b/Examples/Image/ImageListExample.cxx index 2f1a7da5ca7132ff29376b66deb2cab71d38e78e..717414b90b51416da22aefe67a7219acf5c192f0 100644 --- a/Examples/Image/ImageListExample.cxx +++ b/Examples/Image/ImageListExample.cxx @@ -49,18 +49,18 @@ int main(int itkNotUsed(argc), char* argv[]) // As usual, we start by defining the types for the pixel and image // types, as well as those for the readers and writers. - const unsigned int Dimension = 2; - typedef unsigned char InputPixelType; - typedef otb::Image<InputPixelType, Dimension> InputImageType; - typedef otb::ImageFileReader<InputImageType> ReaderType; - typedef otb::ImageFileWriter<InputImageType> WriterType; + const unsigned int Dimension = 2; + using InputPixelType = unsigned char; + using InputImageType = otb::Image<InputPixelType, Dimension>; + using ReaderType = otb::ImageFileReader<InputImageType>; + using WriterType = otb::ImageFileWriter<InputImageType>; // We can now define the type for the image list. The // \doxygen{otb}{ImageList} class is templated over the type of image // contained in it. This means that all images in a list must have the // same type. - typedef otb::ImageList<InputImageType> ImageListType; + using ImageListType = otb::ImageList<InputImageType>; // Let us assume now that we want to read an image from a file and // store it in a list. The first thing to do is to instantiate the diff --git a/Examples/Image/VectorImage.cxx b/Examples/Image/VectorImage.cxx index b6cfce05f4dad7b86a2429b4a2bff8ab1c97e8da..41badc06860acd6710e15e41cf3041efacebb711 100644 --- a/Examples/Image/VectorImage.cxx +++ b/Examples/Image/VectorImage.cxx @@ -46,7 +46,7 @@ #include "otbVectorImage.h" -int main(int, char* []) +int main(int, char*[]) { // The VectorImage class is templated over the type used to represent // the coordinate in space and over the dimension of the space. In @@ -55,8 +55,8 @@ int main(int, char* []) // // \index{otb::VectorImage!Instantiation} - typedef unsigned char PixelType; - typedef otb::VectorImage<PixelType, 2> ImageType; + using PixelType = unsigned char; + using ImageType = otb::VectorImage<PixelType, 2>; // Then the image object can be created ImageType::Pointer image = ImageType::New(); diff --git a/Examples/Installation/HelloWorld.cxx b/Examples/Installation/HelloWorld.cxx index f0040c92a6cce97ffa626e5b3ef0dca239906be4..211962f6349fe5ea6bae2939d7096dcca6a2c8a6 100644 --- a/Examples/Installation/HelloWorld.cxx +++ b/Examples/Installation/HelloWorld.cxx @@ -28,7 +28,7 @@ int main() { - typedef otb::Image<unsigned short, 2> ImageType; + using ImageType = otb::Image<unsigned short, 2>; ImageType::Pointer image = ImageType::New(); diff --git a/Examples/Iterators/ImageLinearIteratorWithIndex.cxx b/Examples/Iterators/ImageLinearIteratorWithIndex.cxx index 144eedb4cc8877a782b55da2a5710638fe5602c8..32a8f3861b0cd2cd8110d0e85321b03f36e23bab 100644 --- a/Examples/Iterators/ImageLinearIteratorWithIndex.cxx +++ b/Examples/Iterators/ImageLinearIteratorWithIndex.cxx @@ -113,14 +113,14 @@ int main(int argc, char* argv[]) const unsigned int Dimension = 2; - typedef itk::RGBPixel<unsigned char> RGBPixelType; - typedef otb::Image<RGBPixelType, Dimension> ImageType; + using RGBPixelType = itk::RGBPixel<unsigned char>; + using ImageType = otb::Image<RGBPixelType, Dimension>; - typedef itk::ImageLinearIteratorWithIndex<ImageType> IteratorType; - typedef itk::ImageLinearConstIteratorWithIndex<ImageType> ConstIteratorType; + using IteratorType = itk::ImageLinearIteratorWithIndex<ImageType>; + using ConstIteratorType = itk::ImageLinearConstIteratorWithIndex<ImageType>; - typedef otb::ImageFileReader<ImageType> ReaderType; - typedef otb::ImageFileWriter<ImageType> WriterType; + using ReaderType = otb::ImageFileReader<ImageType>; + using WriterType = otb::ImageFileWriter<ImageType>; ImageType::ConstPointer inputImage; ReaderType::Pointer reader = ReaderType::New(); diff --git a/Examples/Iterators/ImageLinearIteratorWithIndex2.cxx b/Examples/Iterators/ImageLinearIteratorWithIndex2.cxx index 56b7ce2f58759bee12db0797d063578b931b4e8e..96da9b9e6a52b2ac54f73c2792944bbd08913c5d 100644 --- a/Examples/Iterators/ImageLinearIteratorWithIndex2.cxx +++ b/Examples/Iterators/ImageLinearIteratorWithIndex2.cxx @@ -46,12 +46,12 @@ int main(int argc, char* argv[]) // First we declare the types of the images - typedef unsigned char PixelType; - typedef otb::Image<PixelType, 3> Image3DType; - typedef otb::Image<PixelType, 4> Image4DType; + using PixelType = unsigned char; + using Image3DType = otb::Image<PixelType, 3>; + using Image4DType = otb::Image<PixelType, 4>; - typedef otb::ImageFileReader<Image4DType> Reader4DType; - typedef otb::ImageFileWriter<Image3DType> Writer3DType; + using Reader4DType = otb::ImageFileReader<Image4DType>; + using Writer3DType = otb::ImageFileWriter<Image3DType>; Reader4DType::Pointer reader4D = Reader4DType::New(); reader4D->SetFileName(argv[1]); @@ -69,17 +69,17 @@ int main(int argc, char* argv[]) Image4DType::ConstPointer image4D = reader4D->GetOutput(); - Image3DType::Pointer image3D = Image3DType::New(); - typedef Image3DType::IndexType Index3DType; - typedef Image3DType::SizeType Size3DType; - typedef Image3DType::RegionType Region3DType; - typedef Image3DType::SpacingType Spacing3DType; - typedef Image3DType::PointType Origin3DType; + Image3DType::Pointer image3D = Image3DType::New(); + using Index3DType = Image3DType::IndexType; + using Size3DType = Image3DType::SizeType; + using Region3DType = Image3DType::RegionType; + using Spacing3DType = Image3DType::SpacingType; + using Origin3DType = Image3DType::PointType; - typedef Image4DType::IndexType Index4DType; - typedef Image4DType::SizeType Size4DType; - typedef Image4DType::SpacingType Spacing4DType; - typedef Image4DType::PointType Origin4DType; + using Index4DType = Image4DType::IndexType; + using Size4DType = Image4DType::SizeType; + using Spacing4DType = Image4DType::SpacingType; + using Origin4DType = Image4DType::PointType; Index3DType index3D; Size3DType size3D; @@ -111,12 +111,12 @@ int main(int argc, char* argv[]) image3D->SetRegions(region3D); image3D->Allocate(); - typedef itk::NumericTraits<PixelType>::AccumulateType SumType; - typedef itk::NumericTraits<SumType>::RealType MeanType; + using SumType = itk::NumericTraits<PixelType>::AccumulateType; + using MeanType = itk::NumericTraits<SumType>::RealType; const unsigned int timeLength = region4D.GetSize()[3]; - typedef itk::ImageLinearConstIteratorWithIndex<Image4DType> IteratorType; + using IteratorType = itk::ImageLinearConstIteratorWithIndex<Image4DType>; IteratorType it(image4D, region4D); it.SetDirection(3); // Walk along time dimension diff --git a/Examples/Iterators/ImageRandomConstIteratorWithIndex.cxx b/Examples/Iterators/ImageRandomConstIteratorWithIndex.cxx index 4e24eb6405f07124303b88d4de4b34523f381583..414fdf1f3d20e2ae7688bc555717d54253466452 100644 --- a/Examples/Iterators/ImageRandomConstIteratorWithIndex.cxx +++ b/Examples/Iterators/ImageRandomConstIteratorWithIndex.cxx @@ -60,11 +60,11 @@ int main(int argc, char* argv[]) const unsigned int Dimension = 2; - typedef unsigned short PixelType; - typedef otb::Image<PixelType, Dimension> ImageType; - typedef itk::ImageRandomConstIteratorWithIndex<ImageType> ConstIteratorType; + using PixelType = unsigned short; + using ImageType = otb::Image<PixelType, Dimension>; + using ConstIteratorType = itk::ImageRandomConstIteratorWithIndex<ImageType>; - typedef otb::ImageFileReader<ImageType> ReaderType; + using ReaderType = otb::ImageFileReader<ImageType>; ImageType::ConstPointer inputImage; ReaderType::Pointer reader = ReaderType::New(); diff --git a/Examples/Iterators/ImageRegionIterator.cxx b/Examples/Iterators/ImageRegionIterator.cxx index bbb348844d011ac2d665c1bd34767dbc9732c059..331d86fb171ceeeccae0e5591eaa88d0eadfa84d 100644 --- a/Examples/Iterators/ImageRegionIterator.cxx +++ b/Examples/Iterators/ImageRegionIterator.cxx @@ -63,14 +63,14 @@ int main(int argc, char* argv[]) const unsigned int Dimension = 2; - typedef unsigned char PixelType; - typedef otb::Image<PixelType, Dimension> ImageType; + using PixelType = unsigned char; + using ImageType = otb::Image<PixelType, Dimension>; - typedef itk::ImageRegionConstIterator<ImageType> ConstIteratorType; - typedef itk::ImageRegionIterator<ImageType> IteratorType; + using ConstIteratorType = itk::ImageRegionConstIterator<ImageType>; + using IteratorType = itk::ImageRegionIterator<ImageType>; - typedef otb::ImageFileReader<ImageType> ReaderType; - typedef otb::ImageFileWriter<ImageType> WriterType; + using ReaderType = otb::ImageFileReader<ImageType>; + using WriterType = otb::ImageFileWriter<ImageType>; // Information about the subregion to copy is read from the command line. The // subregion is defined by an \doxygen{itk}{ImageRegion} object, with a starting diff --git a/Examples/Iterators/ImageRegionIteratorWithIndex.cxx b/Examples/Iterators/ImageRegionIteratorWithIndex.cxx index 299585c7f25a719b907ed269c24688a7485da4d6..8fcffda237e14a38d30554dcc2548ca4be6eec0b 100644 --- a/Examples/Iterators/ImageRegionIteratorWithIndex.cxx +++ b/Examples/Iterators/ImageRegionIteratorWithIndex.cxx @@ -67,13 +67,13 @@ int main(int argc, char* argv[]) const unsigned int Dimension = 2; - typedef itk::RGBPixel<unsigned char> RGBPixelType; - typedef otb::Image<RGBPixelType, Dimension> ImageType; + using RGBPixelType = itk::RGBPixel<unsigned char>; + using ImageType = otb::Image<RGBPixelType, Dimension>; - typedef itk::ImageRegionIteratorWithIndex<ImageType> IteratorType; + using IteratorType = itk::ImageRegionIteratorWithIndex<ImageType>; - typedef otb::ImageFileReader<ImageType> ReaderType; - typedef otb::ImageFileWriter<ImageType> WriterType; + using ReaderType = otb::ImageFileReader<ImageType>; + using WriterType = otb::ImageFileWriter<ImageType>; ImageType::ConstPointer inputImage; ReaderType::Pointer reader = ReaderType::New(); diff --git a/Examples/Iterators/ImageSliceIteratorWithIndex.cxx b/Examples/Iterators/ImageSliceIteratorWithIndex.cxx index 60292584963bc8466a360c83141d3c2076f712ed..66dbf8336aa4be5a8245bd9d3e4f3de64cfd692e 100644 --- a/Examples/Iterators/ImageSliceIteratorWithIndex.cxx +++ b/Examples/Iterators/ImageSliceIteratorWithIndex.cxx @@ -117,17 +117,17 @@ int main(int argc, char* argv[]) // we need two image types, a 3D image for the input, and a 2D image for the // intensity projection. - typedef unsigned short PixelType; - typedef otb::Image<PixelType, 2> ImageType2D; - typedef otb::Image<PixelType, 3> ImageType3D; + using PixelType = unsigned short; + using ImageType2D = otb::Image<PixelType, 2>; + using ImageType3D = otb::Image<PixelType, 3>; // A slice iterator type is defined to walk the input image. - typedef itk::ImageLinearIteratorWithIndex<ImageType2D> LinearIteratorType; - typedef itk::ImageSliceConstIteratorWithIndex<ImageType3D> SliceIteratorType; + using LinearIteratorType = itk::ImageLinearIteratorWithIndex<ImageType2D>; + using SliceIteratorType = itk::ImageSliceConstIteratorWithIndex<ImageType3D>; - typedef otb::ImageFileReader<ImageType3D> ReaderType; - typedef otb::ImageFileWriter<ImageType2D> WriterType; + using ReaderType = otb::ImageFileReader<ImageType3D>; + using WriterType = otb::ImageFileWriter<ImageType2D>; ImageType3D::ConstPointer inputImage; ReaderType::Pointer reader = ReaderType::New(); diff --git a/Examples/Iterators/NeighborhoodIterators1.cxx b/Examples/Iterators/NeighborhoodIterators1.cxx index a6b92d91c95ac44565436ea6e7086a3c9660fdd0..e35b336bcae8e36c9298a570d0258f687e258c9b 100644 --- a/Examples/Iterators/NeighborhoodIterators1.cxx +++ b/Examples/Iterators/NeighborhoodIterators1.cxx @@ -68,12 +68,12 @@ int main(int argc, char* argv[]) // the boundary condition, has been omitted because the default condition is // appropriate for this algorithm. - typedef float PixelType; - typedef otb::Image<PixelType, 2> ImageType; - typedef otb::ImageFileReader<ImageType> ReaderType; + using PixelType = float; + using ImageType = otb::Image<PixelType, 2>; + using ReaderType = otb::ImageFileReader<ImageType>; - typedef itk::ConstNeighborhoodIterator<ImageType> NeighborhoodIteratorType; - typedef itk::ImageRegionIterator<ImageType> IteratorType; + using NeighborhoodIteratorType = itk::ConstNeighborhoodIterator<ImageType>; + using IteratorType = itk::ImageRegionIterator<ImageType>; // The following code creates and executes the OTB image reader. // The \code{Update} @@ -154,11 +154,11 @@ int main(int argc, char* argv[]) // is rescaled to intensity range $[0, 255]$ and cast to unsigned char so that // it can be saved and visualized as a PNG image. - typedef unsigned char WritePixelType; - typedef otb::Image<WritePixelType, 2> WriteImageType; - typedef otb::ImageFileWriter<WriteImageType> WriterType; + using WritePixelType = unsigned char; + using WriteImageType = otb::Image<WritePixelType, 2>; + using WriterType = otb::ImageFileWriter<WriteImageType>; - typedef itk::RescaleIntensityImageFilter<ImageType, WriteImageType> RescaleFilterType; + using RescaleFilterType = itk::RescaleIntensityImageFilter<ImageType, WriteImageType>; RescaleFilterType::Pointer rescaler = RescaleFilterType::New(); diff --git a/Examples/Iterators/NeighborhoodIterators2.cxx b/Examples/Iterators/NeighborhoodIterators2.cxx index e7833381e52f02ade97d40adcccf957f9c7eec2e..c615e5553a485d7ffee25c3aead641a6394369a7 100644 --- a/Examples/Iterators/NeighborhoodIterators2.cxx +++ b/Examples/Iterators/NeighborhoodIterators2.cxx @@ -63,12 +63,12 @@ int main(int argc, char* argv[]) return -1; } - typedef float PixelType; - typedef otb::Image<PixelType, 2> ImageType; - typedef otb::ImageFileReader<ImageType> ReaderType; + using PixelType = float; + using ImageType = otb::Image<PixelType, 2>; + using ReaderType = otb::ImageFileReader<ImageType>; - typedef itk::ConstNeighborhoodIterator<ImageType> NeighborhoodIteratorType; - typedef itk::ImageRegionIterator<ImageType> IteratorType; + using NeighborhoodIteratorType = itk::ConstNeighborhoodIterator<ImageType>; + using IteratorType = itk::ImageRegionIterator<ImageType>; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(argv[1]); @@ -130,11 +130,11 @@ int main(int argc, char* argv[]) // and right of Figure~\ref{fig:NeighborhoodExamples1}. Note that x-direction // operator produces the same output image as in the previous example. - typedef unsigned char WritePixelType; - typedef otb::Image<WritePixelType, 2> WriteImageType; - typedef otb::ImageFileWriter<WriteImageType> WriterType; + using WritePixelType = unsigned char; + using WriteImageType = otb::Image<WritePixelType, 2>; + using WriterType = otb::ImageFileWriter<WriteImageType>; - typedef itk::RescaleIntensityImageFilter<ImageType, WriteImageType> RescaleFilterType; + using RescaleFilterType = itk::RescaleIntensityImageFilter<ImageType, WriteImageType>; RescaleFilterType::Pointer rescaler = RescaleFilterType::New(); diff --git a/Examples/Iterators/NeighborhoodIterators3.cxx b/Examples/Iterators/NeighborhoodIterators3.cxx index 564097cfc64a47768991058b9f709fed476dd609..683c6104e1e3aa540fa2eac77219f90f840c1550 100644 --- a/Examples/Iterators/NeighborhoodIterators3.cxx +++ b/Examples/Iterators/NeighborhoodIterators3.cxx @@ -67,12 +67,12 @@ int main(int argc, char* argv[]) return -1; } - typedef float PixelType; - typedef otb::Image<PixelType, 2> ImageType; - typedef otb::ImageFileReader<ImageType> ReaderType; + using PixelType = float; + using ImageType = otb::Image<PixelType, 2>; + using ReaderType = otb::ImageFileReader<ImageType>; - typedef itk::ConstNeighborhoodIterator<ImageType> NeighborhoodIteratorType; - typedef itk::ImageRegionIterator<ImageType> IteratorType; + using NeighborhoodIteratorType = itk::ConstNeighborhoodIterator<ImageType>; + using IteratorType = itk::ImageRegionIterator<ImageType>; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(argv[1]); @@ -103,7 +103,7 @@ int main(int argc, char* argv[]) // created to hold the regions that will later on be returned by the face // calculator. - typedef itk::NeighborhoodAlgorithm ::ImageBoundaryFacesCalculator<ImageType> FaceCalculatorType; + using FaceCalculatorType = itk::NeighborhoodAlgorithm::ImageBoundaryFacesCalculator<ImageType>; FaceCalculatorType faceCalculator; FaceCalculatorType::FaceListType faceList; @@ -161,11 +161,11 @@ int main(int argc, char* argv[]) // face pixels, there is a corresponding increase in efficiency from disabling // bounds checking on interior pixels. - typedef unsigned char WritePixelType; - typedef otb::Image<WritePixelType, 2> WriteImageType; - typedef otb::ImageFileWriter<WriteImageType> WriterType; + using WritePixelType = unsigned char; + using WriteImageType = otb::Image<WritePixelType, 2>; + using WriterType = otb::ImageFileWriter<WriteImageType>; - typedef itk::RescaleIntensityImageFilter<ImageType, WriteImageType> RescaleFilterType; + using RescaleFilterType = itk::RescaleIntensityImageFilter<ImageType, WriteImageType>; RescaleFilterType::Pointer rescaler = RescaleFilterType::New(); diff --git a/Examples/Iterators/NeighborhoodIterators4.cxx b/Examples/Iterators/NeighborhoodIterators4.cxx index 828a96fc9ff129984accb30bdc86f4300b807243..d3bc066d2dc093c61eed3633f418542671ac6bfd 100644 --- a/Examples/Iterators/NeighborhoodIterators4.cxx +++ b/Examples/Iterators/NeighborhoodIterators4.cxx @@ -69,12 +69,12 @@ int main(int argc, char* argv[]) return -1; } - typedef float PixelType; - typedef otb::Image<PixelType, 2> ImageType; - typedef otb::ImageFileReader<ImageType> ReaderType; + using PixelType = float; + using ImageType = otb::Image<PixelType, 2>; + using ReaderType = otb::ImageFileReader<ImageType>; - typedef itk::ConstNeighborhoodIterator<ImageType> NeighborhoodIteratorType; - typedef itk::ImageRegionIterator<ImageType> IteratorType; + using NeighborhoodIteratorType = itk::ConstNeighborhoodIterator<ImageType>; + using IteratorType = itk::ImageRegionIterator<ImageType>; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(argv[1]); @@ -95,7 +95,7 @@ int main(int argc, char* argv[]) itk::NeighborhoodInnerProduct<ImageType> innerProduct; - typedef itk::NeighborhoodAlgorithm ::ImageBoundaryFacesCalculator<ImageType> FaceCalculatorType; + using FaceCalculatorType = itk::NeighborhoodAlgorithm::ImageBoundaryFacesCalculator<ImageType>; FaceCalculatorType faceCalculator; FaceCalculatorType::FaceListType faceList; @@ -173,11 +173,11 @@ int main(int argc, char* argv[]) // \protect\label{fig:NeighborhoodExample4} // \end{figure} - typedef unsigned char WritePixelType; - typedef otb::Image<WritePixelType, 2> WriteImageType; - typedef otb::ImageFileWriter<WriteImageType> WriterType; + using WritePixelType = unsigned char; + using WriteImageType = otb::Image<WritePixelType, 2>; + using WriterType = otb::ImageFileWriter<WriteImageType>; - typedef itk::RescaleIntensityImageFilter<ImageType, WriteImageType> RescaleFilterType; + using RescaleFilterType = itk::RescaleIntensityImageFilter<ImageType, WriteImageType>; RescaleFilterType::Pointer rescaler = RescaleFilterType::New(); diff --git a/Examples/Iterators/NeighborhoodIterators5.cxx b/Examples/Iterators/NeighborhoodIterators5.cxx index 33ea5516d22ef4f0779485da83bc5f6d6bf4af62..6718c9ce462c7069f395b24da654a602596d7ab4 100644 --- a/Examples/Iterators/NeighborhoodIterators5.cxx +++ b/Examples/Iterators/NeighborhoodIterators5.cxx @@ -67,12 +67,12 @@ int main(int argc, char* argv[]) return -1; } - typedef float PixelType; - typedef otb::Image<PixelType, 2> ImageType; - typedef otb::ImageFileReader<ImageType> ReaderType; + using PixelType = float; + using ImageType = otb::Image<PixelType, 2>; + using ReaderType = otb::ImageFileReader<ImageType>; - typedef itk::ConstNeighborhoodIterator<ImageType> NeighborhoodIteratorType; - typedef itk::ImageRegionIterator<ImageType> IteratorType; + using NeighborhoodIteratorType = itk::ConstNeighborhoodIterator<ImageType>; + using IteratorType = itk::ImageRegionIterator<ImageType>; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(argv[1]); @@ -93,7 +93,7 @@ int main(int argc, char* argv[]) itk::NeighborhoodInnerProduct<ImageType> innerProduct; - typedef itk::NeighborhoodAlgorithm ::ImageBoundaryFacesCalculator<ImageType> FaceCalculatorType; + using FaceCalculatorType = itk::NeighborhoodAlgorithm::ImageBoundaryFacesCalculator<ImageType>; FaceCalculatorType faceCalculator; FaceCalculatorType::FaceListType faceList; @@ -159,11 +159,11 @@ int main(int argc, char* argv[]) // derivatives or convolution products over the same neighborhood, slice-based // processing can increase efficiency and simplify the implementation. - typedef unsigned char WritePixelType; - typedef otb::Image<WritePixelType, 2> WriteImageType; - typedef otb::ImageFileWriter<WriteImageType> WriterType; + using WritePixelType = unsigned char; + using WriteImageType = otb::Image<WritePixelType, 2>; + using WriterType = otb::ImageFileWriter<WriteImageType>; - typedef itk::RescaleIntensityImageFilter<ImageType, WriteImageType> RescaleFilterType; + using RescaleFilterType = itk::RescaleIntensityImageFilter<ImageType, WriteImageType>; RescaleFilterType::Pointer rescaler = RescaleFilterType::New(); diff --git a/Examples/Iterators/NeighborhoodIterators6.cxx b/Examples/Iterators/NeighborhoodIterators6.cxx index a2402077f75af9d4d4f3abda8f73893546eaa271..afc136a7bddcb783383235aae47b67709be7b5ac 100644 --- a/Examples/Iterators/NeighborhoodIterators6.cxx +++ b/Examples/Iterators/NeighborhoodIterators6.cxx @@ -74,16 +74,16 @@ int main(int argc, char* argv[]) return -1; } - typedef float PixelType; - typedef otb::Image<PixelType, 2> ImageType; - typedef itk::NeighborhoodIterator<ImageType> NeighborhoodIteratorType; + using PixelType = float; + using ImageType = otb::Image<PixelType, 2>; + using NeighborhoodIteratorType = itk::NeighborhoodIterator<ImageType>; - typedef itk::FastMarchingImageFilter<ImageType, ImageType> FastMarchingFilterType; + using FastMarchingFilterType = itk::FastMarchingImageFilter<ImageType, ImageType>; FastMarchingFilterType::Pointer fastMarching = FastMarchingFilterType::New(); - typedef FastMarchingFilterType::NodeContainer NodeContainer; - typedef FastMarchingFilterType::NodeType NodeType; + using NodeContainer = FastMarchingFilterType::NodeContainer; + using NodeType = FastMarchingFilterType::NodeType; NodeContainer::Pointer seeds = NodeContainer::New(); @@ -217,11 +217,11 @@ int main(int argc, char* argv[]) // noise in the image is seen as small perturbations in each path. } // \protect\label{fig:NeighborhoodExample6} \end{figure} - typedef unsigned char WritePixelType; - typedef otb::Image<WritePixelType, 2> WriteImageType; - typedef otb::ImageFileWriter<WriteImageType> WriterType; + using WritePixelType = unsigned char; + using WriteImageType = otb::Image<WritePixelType, 2>; + using WriterType = otb::ImageFileWriter<WriteImageType>; - typedef itk::RescaleIntensityImageFilter<ImageType, WriteImageType> RescaleFilterType; + using RescaleFilterType = itk::RescaleIntensityImageFilter<ImageType, WriteImageType>; RescaleFilterType::Pointer rescaler = RescaleFilterType::New(); diff --git a/Examples/Iterators/ShapedNeighborhoodIterators1.cxx b/Examples/Iterators/ShapedNeighborhoodIterators1.cxx index cfc75e48ed4e9b4011133444782b6783e78065be..d994592eecd3ef9503633a4cad7a93961cb44134 100644 --- a/Examples/Iterators/ShapedNeighborhoodIterators1.cxx +++ b/Examples/Iterators/ShapedNeighborhoodIterators1.cxx @@ -57,15 +57,15 @@ int main(int argc, char* argv[]) // char} pixel type will do. The image and iterator types are defined using // the pixel type. - typedef unsigned char PixelType; - typedef otb::Image<PixelType, 2> ImageType; + using PixelType = unsigned char; + using ImageType = otb::Image<PixelType, 2>; - typedef itk::ConstShapedNeighborhoodIterator<ImageType> ShapedNeighborhoodIteratorType; + using ShapedNeighborhoodIteratorType = itk::ConstShapedNeighborhoodIterator<ImageType>; - typedef itk::ImageRegionIterator<ImageType> IteratorType; + using IteratorType = itk::ImageRegionIterator<ImageType>; - typedef otb::ImageFileReader<ImageType> ReaderType; - ReaderType::Pointer reader = ReaderType::New(); + using ReaderType = otb::ImageFileReader<ImageType>; + ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(argv[1]); try @@ -100,7 +100,7 @@ int main(int argc, char* argv[]) // The face calculator object introduced in // Section~\ref{sec:NeighborhoodExample3} is created and used as before. - typedef itk::NeighborhoodAlgorithm::ImageBoundaryFacesCalculator<ImageType> FaceCalculatorType; + using FaceCalculatorType = itk::NeighborhoodAlgorithm::ImageBoundaryFacesCalculator<ImageType>; FaceCalculatorType faceCalculator; FaceCalculatorType::FaceListType faceList; @@ -183,7 +183,7 @@ int main(int argc, char* argv[]) } } - typedef otb::ImageFileWriter<ImageType> WriterType; + using WriterType = otb::ImageFileWriter<ImageType>; WriterType::Pointer writer = WriterType::New(); writer->SetFileName(argv[2]); diff --git a/Examples/Iterators/ShapedNeighborhoodIterators2.cxx b/Examples/Iterators/ShapedNeighborhoodIterators2.cxx index ba78734d54349106db389b52fc5bae6b90510349..082d60a162cfe83325ba831198e5a3e835295b6a 100644 --- a/Examples/Iterators/ShapedNeighborhoodIterators2.cxx +++ b/Examples/Iterators/ShapedNeighborhoodIterators2.cxx @@ -43,12 +43,12 @@ int main(int argc, char* argv[]) return -1; } - typedef unsigned char PixelType; - typedef otb::Image<PixelType, 2> ImageType; - typedef otb::ImageFileReader<ImageType> ReaderType; + using PixelType = unsigned char; + using ImageType = otb::Image<PixelType, 2>; + using ReaderType = otb::ImageFileReader<ImageType>; - typedef itk::ConstShapedNeighborhoodIterator<ImageType> ShapedNeighborhoodIteratorType; - typedef itk::ImageRegionIterator<ImageType> IteratorType; + using ShapedNeighborhoodIteratorType = itk::ConstShapedNeighborhoodIterator<ImageType>; + using IteratorType = itk::ImageRegionIterator<ImageType>; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(argv[1]); @@ -70,7 +70,7 @@ int main(int argc, char* argv[]) output->SetRegions(reader->GetOutput()->GetRequestedRegion()); output->Allocate(); - typedef itk::NeighborhoodAlgorithm::ImageBoundaryFacesCalculator<ImageType> FaceCalculatorType; + using FaceCalculatorType = itk::NeighborhoodAlgorithm::ImageBoundaryFacesCalculator<ImageType>; FaceCalculatorType faceCalculator; FaceCalculatorType::FaceListType faceList; @@ -157,7 +157,7 @@ int main(int argc, char* argv[]) // \protect\label{fig:ShapedNeighborhoodExample2} // \end{figure} - typedef otb::ImageFileWriter<ImageType> WriterType; + using WriterType = otb::ImageFileWriter<ImageType>; WriterType::Pointer writer = WriterType::New(); writer->SetFileName(argv[2]); diff --git a/Examples/Learning/GenerateTrainingImageExample.cxx b/Examples/Learning/GenerateTrainingImageExample.cxx index c195330765eafa017e470f68e6b6e954668b0778..2bcd6ae5e9a58d20438332ebf58b81127e0092c1 100644 --- a/Examples/Learning/GenerateTrainingImageExample.cxx +++ b/Examples/Learning/GenerateTrainingImageExample.cxx @@ -50,16 +50,16 @@ int main(int argc, char* argv[]) const char* roiFilename = argv[2]; const char* outputFilename = argv[3]; - typedef unsigned char InputPixelType; - typedef unsigned char OutputPixelType; + using InputPixelType = unsigned char; + using OutputPixelType = unsigned char; const unsigned int Dimension = 2; - typedef otb::Image<InputPixelType, Dimension> InputImageType; - typedef otb::Image<OutputPixelType, Dimension> OutputImageType; + using InputImageType = otb::Image<InputPixelType, Dimension>; + using OutputImageType = otb::Image<OutputPixelType, Dimension>; - typedef otb::ImageFileReader<InputImageType> ReaderType; - typedef otb::ImageFileWriter<OutputImageType> WriterType; + using ReaderType = otb::ImageFileReader<InputImageType>; + using WriterType = otb::ImageFileWriter<OutputImageType>; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); @@ -73,13 +73,13 @@ int main(int argc, char* argv[]) OutputImageType::Pointer trainingImage = OutputImageType::New(); // Declare the type of the index to access images - typedef itk::Index<Dimension> myIndexType; + using myIndexType = itk::Index<Dimension>; // Declare the type of the size - typedef itk::Size<Dimension> mySizeType; + using mySizeType = itk::Size<Dimension>; // Declare the type of the Region - typedef itk::ImageRegion<Dimension> myRegionType; + using myRegionType = itk::ImageRegion<Dimension>; // Define their size, and start index mySizeType size; @@ -146,8 +146,8 @@ int main(int argc, char* argv[]) region.SetIndex(start); // Iterator creation - typedef itk::ImageRegionIterator<OutputImageType> IteratorType; - IteratorType it(trainingImage, region); + using IteratorType = itk::ImageRegionIterator<OutputImageType>; + IteratorType it(trainingImage, region); it.GoToBegin(); diff --git a/Examples/Learning/SEMModelEstimatorExample.cxx b/Examples/Learning/SEMModelEstimatorExample.cxx index d6113347484b00ccc0e3c093221e8eb08d159090..c1291eafd61a9059bbe31d1945321d012dc6b5d1 100644 --- a/Examples/Learning/SEMModelEstimatorExample.cxx +++ b/Examples/Learning/SEMModelEstimatorExample.cxx @@ -74,13 +74,13 @@ int main(int argc, char* argv[]) // considered for the templated \code{MeasurementVectorType}, which // will be used in the \code{ListSample} interface. - typedef double PixelType; + using PixelType = double; - typedef otb::VectorImage<PixelType, 2> ImageType; - typedef otb::ImageFileReader<ImageType> ReaderType; + using ImageType = otb::VectorImage<PixelType, 2>; + using ReaderType = otb::ImageFileReader<ImageType>; - typedef otb::Image<unsigned char, 2> OutputImageType; - typedef otb::ImageFileWriter<OutputImageType> WriterType; + using OutputImageType = otb::Image<unsigned char, 2>; + using WriterType = otb::ImageFileWriter<OutputImageType>; char* fileNameIn = argv[1]; char* fileNameImgInit = nullptr; @@ -97,8 +97,8 @@ int main(int argc, char* argv[]) // Once the input image is opened, the classifier may be initialised by // \code{SmartPointer}. - typedef otb::SEMClassifier<ImageType, OutputImageType> ClassifType; - ClassifType::Pointer classifier = ClassifType::New(); + using ClassifType = otb::SEMClassifier<ImageType, OutputImageType>; + ClassifType::Pointer classifier = ClassifType::New(); // Then, it follows, classical initializations of the pipeline. @@ -115,8 +115,8 @@ int main(int argc, char* argv[]) if (fileNameImgInit != nullptr) { - typedef otb::ImageFileReader<OutputImageType> ImgInitReaderType; - ImgInitReaderType::Pointer segReader = ImgInitReaderType::New(); + using ImgInitReaderType = otb::ImageFileReader<OutputImageType>; + ImgInitReaderType::Pointer segReader = ImgInitReaderType::New(); segReader->SetFileName(fileNameImgInit); segReader->Update(); classifier->SetClassLabels(segReader->GetOutput()); @@ -131,8 +131,8 @@ int main(int argc, char* argv[]) std::cerr << "Explicit component initialization\n"; - typedef ClassifType::ClassSampleType ClassSampleType; - typedef otb::Statistics::GaussianModelComponent<ClassSampleType> GaussianType; + using ClassSampleType = ClassifType::ClassSampleType; + using GaussianType = otb::Statistics::GaussianModelComponent<ClassSampleType>; for (int i = 0; i < numberOfClasses; ++i) { @@ -164,8 +164,8 @@ int main(int argc, char* argv[]) // classes before saving it to a file. We will use the // \doxygen{itk}{RescaleIntensityImageFilter} for this purpose. - typedef itk::RescaleIntensityImageFilter<OutputImageType, OutputImageType> RescalerType; - RescalerType::Pointer rescaler = RescalerType::New(); + using RescalerType = itk::RescaleIntensityImageFilter<OutputImageType, OutputImageType>; + RescalerType::Pointer rescaler = RescalerType::New(); rescaler->SetOutputMinimum(itk::NumericTraits<unsigned char>::min()); rescaler->SetOutputMaximum(itk::NumericTraits<unsigned char>::max()); diff --git a/Examples/Learning/SOMClassifierExample.cxx b/Examples/Learning/SOMClassifierExample.cxx index de113b80b0a0cff1968d4bf7c7a67923c9ded4c0..6dd1624667c3c8c6456a59ad8a302d4551678012 100644 --- a/Examples/Learning/SOMClassifierExample.cxx +++ b/Examples/Learning/SOMClassifierExample.cxx @@ -59,11 +59,11 @@ int main(int argc, char* argv[]) const char* mapFilename = argv[2]; const char* outputFilename = argv[3]; - typedef double InputPixelType; - typedef unsigned char LabelPixelType; - const unsigned int Dimension = 2; + using InputPixelType = double; + using LabelPixelType = unsigned char; + const unsigned int Dimension = 2; - typedef itk::VariableLengthVector<InputPixelType> PixelType; + using PixelType = itk::VariableLengthVector<InputPixelType>; // As for the SOM learning step, we must define the types for the // \code{otb::SOMMap}, and therefore, also for the distance to be @@ -71,12 +71,12 @@ int main(int argc, char* argv[]) // actually an \doxygen{otb}{ImageFileReader} which the appropriate // image type. - typedef itk::Statistics::EuclideanDistanceMetric<PixelType> DistanceType; - typedef otb::SOMMap<PixelType, DistanceType, Dimension> SOMMapType; - typedef otb::ImageFileReader<SOMMapType> SOMReaderType; + using DistanceType = itk::Statistics::EuclideanDistanceMetric<PixelType>; + using SOMMapType = otb::SOMMap<PixelType, DistanceType, Dimension>; + using SOMReaderType = otb::ImageFileReader<SOMMapType>; - typedef otb::VectorImage<InputPixelType, Dimension> InputImageType; - typedef otb::ImageFileReader<InputImageType> ReaderType; + using InputImageType = otb::VectorImage<InputPixelType, Dimension>; + using ReaderType = otb::ImageFileReader<InputImageType>; // The classification will be performed by the // \doxygen{otb}{SOMClassifier}, which, as most of the @@ -88,14 +88,14 @@ int main(int argc, char* argv[]) // \code{SOMClassifier} is templated over the sample type, the SOMMap // type and the pixel type for the labels. - typedef itk::Statistics::ListSample<PixelType> SampleType; - typedef otb::SOMClassifier<SampleType, SOMMapType, LabelPixelType> ClassifierType; + using SampleType = itk::Statistics::ListSample<PixelType>; + using ClassifierType = otb::SOMClassifier<SampleType, SOMMapType, LabelPixelType>; // // The result of the classification will be stored on an image and // saved to a file. Therefore, we define the types needed for this step. - typedef otb::Image<LabelPixelType, Dimension> OutputImageType; - typedef otb::ImageFileWriter<OutputImageType> WriterType; + using OutputImageType = otb::Image<LabelPixelType, Dimension>; + using WriterType = otb::ImageFileWriter<OutputImageType>; // // We can now start reading the input image and the SOM given as // inputs to the program. We instantiate the readers as usual. @@ -155,7 +155,7 @@ int main(int argc, char* argv[]) // We also declare an \doxygen{itk}{ImageRegionIterator} in order // to fill the output image with the class labels. - typedef itk::ImageRegionIterator<OutputImageType> OutputIteratorType; + using OutputIteratorType = itk::ImageRegionIterator<OutputImageType>; OutputIteratorType outIt(outputImage, outputImage->GetLargestPossibleRegion()); // diff --git a/Examples/Learning/SOMExample.cxx b/Examples/Learning/SOMExample.cxx index 5b1b90bcadcfaa8bbc5217b2a7acd8a80a449104..bad9b7ca1d8730b2955ceadf2eb356c51573c2b3 100644 --- a/Examples/Learning/SOMExample.cxx +++ b/Examples/Learning/SOMExample.cxx @@ -83,15 +83,15 @@ int main(int itkNotUsed(argc), char* argv[]) // a 2-dimensional SOM, where the neurons store RGB values with // floating point precision. - const unsigned int Dimension = 2; - typedef double PixelType; - typedef otb::VectorImage<PixelType, Dimension> ImageType; - typedef ImageType::PixelType VectorType; + const unsigned int Dimension = 2; + using PixelType = double; + using ImageType = otb::VectorImage<PixelType, Dimension>; + using VectorType = ImageType::PixelType; // The distance that we want to apply between the RGB values is the // Euclidean one. Of course we could choose to use other type of // distance, as for instance, a distance defined in any other color space. - typedef itk::Statistics::EuclideanDistanceMetric<VectorType> DistanceType; + using DistanceType = itk::Statistics::EuclideanDistanceMetric<VectorType>; // // We can now define the type for the map. The \doxygen{otb}{SOMMap} // class is templated over the neuron type -- \code{PixelType} here @@ -99,28 +99,28 @@ int main(int itkNotUsed(argc), char* argv[]) // number of dimensions of the map could be different from the one of // the images to be processed. - typedef otb::SOMMap<VectorType, DistanceType, Dimension> MapType; + using MapType = otb::SOMMap<VectorType, DistanceType, Dimension>; // // We are going to perform the learning directly on the pixels of the // input image. Therefore, the image type is defined using the same // pixel type as we used for the map. We also define the type for the // imge file reader. - typedef otb::ImageFileReader<ImageType> ReaderType; + using ReaderType = otb::ImageFileReader<ImageType>; // // Since the \doxygen{otb}{SOM} class works on lists of samples, it // will need to access the input image through an adaptor. Its type is // defined as follows: - typedef itk::Statistics::ListSample<VectorType> SampleListType; + using SampleListType = itk::Statistics::ListSample<VectorType>; // // We can now define the type for the SOM, which is templated over the // input sample list and the type of the map to be produced and the two // functors that hold the training behavior. - typedef otb::Functor::CzihoSOMLearningBehaviorFunctor LearningBehaviorFunctorType; - typedef otb::Functor::CzihoSOMNeighborhoodBehaviorFunctor NeighborhoodBehaviorFunctorType; - typedef otb::SOM<SampleListType, MapType, LearningBehaviorFunctorType, NeighborhoodBehaviorFunctorType> SOMType; + using LearningBehaviorFunctorType = otb::Functor::CzihoSOMLearningBehaviorFunctor; + using NeighborhoodBehaviorFunctorType = otb::Functor::CzihoSOMNeighborhoodBehaviorFunctor; + using SOMType = otb::SOM<SampleListType, MapType, LearningBehaviorFunctorType, NeighborhoodBehaviorFunctorType>; // // As an alternative to standard \code{SOMType}, one can decide to use // an \doxygen{otb}{PeriodicSOM}, which behaves like \doxygen{otb}{SOM} but @@ -199,12 +199,12 @@ int main(int itkNotUsed(argc), char* argv[]) // \doxygen{otb}{ImageFileWriter}. // Just for visualization purposes, we zoom the image, and pass it to the printable image filter - typedef otb::Image<PixelType, 2> SingleImageType; - typedef itk::ExpandImageFilter<SingleImageType, SingleImageType> ExpandType; - typedef otb::PerBandVectorImageFilter<MapType, MapType, ExpandType> VectorExpandType; - typedef itk::NearestNeighborInterpolateImageFunction<SingleImageType, double> InterpolatorType; - typedef otb::PrintableImageFilter<MapType> PrintableFilterType; - typedef otb::ImageFileWriter<PrintableFilterType::OutputImageType> PrintableWriterType; + using SingleImageType = otb::Image<PixelType, 2>; + using ExpandType = itk::ExpandImageFilter<SingleImageType, SingleImageType>; + using VectorExpandType = otb::PerBandVectorImageFilter<MapType, MapType, ExpandType>; + using InterpolatorType = itk::NearestNeighborInterpolateImageFunction<SingleImageType, double>; + using PrintableFilterType = otb::PrintableImageFilter<MapType>; + using PrintableWriterType = otb::ImageFileWriter<PrintableFilterType::OutputImageType>; InterpolatorType::Pointer interpolator = InterpolatorType::New(); VectorExpandType::Pointer expand = VectorExpandType::New(); @@ -259,16 +259,16 @@ int main(int itkNotUsed(argc), char* argv[]) // for the set of examples given to the map. The activation map is // stored as a scalar image and an integer pixel type is usually enough. - typedef unsigned char OutputPixelType; + using OutputPixelType = unsigned char; - typedef otb::Image<OutputPixelType, Dimension> OutputImageType; - typedef otb::ImageFileWriter<OutputImageType> ActivationWriterType; + using OutputImageType = otb::Image<OutputPixelType, Dimension>; + using ActivationWriterType = otb::ImageFileWriter<OutputImageType>; // In a similar way to the \doxygen{otb}{SOM} class the // \doxygen{otb}{SOMActivationBuilder} is templated over the sample // list given as input, the SOM map type and the activation map to be // built as output. - typedef otb::SOMActivationBuilder<SampleListType, MapType, OutputImageType> SOMActivationBuilderType; + using SOMActivationBuilderType = otb::SOMActivationBuilder<SampleListType, MapType, OutputImageType>; // We instantiate the activation map builder and set as input the SOM // map build before and the image (using the adaptor). @@ -287,8 +287,8 @@ int main(int itkNotUsed(argc), char* argv[]) // map obtained. // Just for visualization purposes, we zoom the image. - typedef itk::ExpandImageFilter<OutputImageType, OutputImageType> ExpandType2; - typedef itk::NearestNeighborInterpolateImageFunction<OutputImageType, double> InterpolatorType2; + using ExpandType2 = itk::ExpandImageFilter<OutputImageType, OutputImageType>; + using InterpolatorType2 = itk::NearestNeighborInterpolateImageFunction<OutputImageType, double>; InterpolatorType2::Pointer interpolator2 = InterpolatorType2::New(); ExpandType2::Pointer expand2 = ExpandType2::New(); diff --git a/Examples/Learning/SVMImageEstimatorClassificationMultiExample.cxx b/Examples/Learning/SVMImageEstimatorClassificationMultiExample.cxx index e79af559e1b34c690a1921bc1ddf1f5ba8eb5176..910b99e524c972060b501adf7642055feca05fc0 100644 --- a/Examples/Learning/SVMImageEstimatorClassificationMultiExample.cxx +++ b/Examples/Learning/SVMImageEstimatorClassificationMultiExample.cxx @@ -76,21 +76,21 @@ int main(int itkNotUsed(argc), char* argv[]) // input image will be an RGB image, we can read it as a 3 component // vector image. This simplifies the interfacing with OTB's SVM // framework. - typedef unsigned short InputPixelType; - const unsigned int Dimension = 2; + using InputPixelType = unsigned short; + const unsigned int Dimension = 2; - typedef otb::VectorImage<InputPixelType, Dimension> InputImageType; + using InputImageType = otb::VectorImage<InputPixelType, Dimension>; - typedef otb::Image<InputPixelType, Dimension> TrainingImageType; + using TrainingImageType = otb::Image<InputPixelType, Dimension>; // The \doxygen{otb}{LibSVMMachineLearningModel} class is templated over // the input (features) and the training (labels) values. - typedef otb::LibSVMMachineLearningModel<InputPixelType, InputPixelType> ModelType; + using ModelType = otb::LibSVMMachineLearningModel<InputPixelType, InputPixelType>; // As usual, we define the readers for the images. - typedef otb::ImageFileReader<InputImageType> InputReaderType; - typedef otb::ImageFileReader<TrainingImageType> TrainingReaderType; + using InputReaderType = otb::ImageFileReader<InputImageType>; + using TrainingReaderType = otb::ImageFileReader<TrainingImageType>; InputReaderType::Pointer inputReader = InputReaderType::New(); TrainingReaderType::Pointer trainingReader = TrainingReaderType::New(); @@ -112,15 +112,15 @@ int main(int itkNotUsed(argc), char* argv[]) // ListSamples. - typedef itk::BinaryThresholdImageFilter<TrainingImageType, TrainingImageType> ThresholdFilterType; - ThresholdFilterType::Pointer thresholder = ThresholdFilterType::New(); + using ThresholdFilterType = itk::BinaryThresholdImageFilter<TrainingImageType, TrainingImageType>; + ThresholdFilterType::Pointer thresholder = ThresholdFilterType::New(); thresholder->SetInput(trainingReader->GetOutput()); thresholder->SetLowerThreshold(1); thresholder->SetOutsideValue(0); thresholder->SetInsideValue(1); - typedef itk::Statistics::ImageToListSampleFilter<InputImageType, TrainingImageType> ImageToListSample; - typedef itk::Statistics::ImageToListSampleFilter<TrainingImageType, TrainingImageType> ImageToTargetListSample; + using ImageToListSample = itk::Statistics::ImageToListSampleFilter<InputImageType, TrainingImageType>; + using ImageToTargetListSample = itk::Statistics::ImageToListSampleFilter<TrainingImageType, TrainingImageType>; ImageToListSample::Pointer imToList = ImageToListSample::New(); imToList->SetInput(inputReader->GetOutput()); @@ -150,7 +150,7 @@ int main(int itkNotUsed(argc), char* argv[]) // is templated over the sample type (the type of the data to be // classified) and the label type (the type of the output of the classifier). - typedef otb::ImageClassificationFilter<InputImageType, TrainingImageType> ClassifierType; + using ClassifierType = otb::ImageClassificationFilter<InputImageType, TrainingImageType>; ClassifierType::Pointer classifier = ClassifierType::New(); @@ -181,7 +181,7 @@ int main(int itkNotUsed(argc), char* argv[]) // values to the output image. - typedef otb::ImageFileWriter<TrainingImageType> WriterType; + using WriterType = otb::ImageFileWriter<TrainingImageType>; WriterType::Pointer writer = WriterType::New(); @@ -198,17 +198,17 @@ int main(int itkNotUsed(argc), char* argv[]) // \doxygen{itk}{UnaryFunctorImageFilter} creates an image filter for that // converts scalar images to RGB images. - typedef itk::RGBPixel<unsigned char> RGBPixelType; - typedef otb::Image<RGBPixelType, 2> RGBImageType; - typedef itk::Functor::ScalarToRGBPixelFunctor<unsigned long> ColorMapFunctorType; - typedef itk::UnaryFunctorImageFilter<TrainingImageType, RGBImageType, ColorMapFunctorType> ColorMapFilterType; - ColorMapFilterType::Pointer colormapper = ColorMapFilterType::New(); + using RGBPixelType = itk::RGBPixel<unsigned char>; + using RGBImageType = otb::Image<RGBPixelType, 2>; + using ColorMapFunctorType = itk::Functor::ScalarToRGBPixelFunctor<unsigned long>; + using ColorMapFilterType = itk::UnaryFunctorImageFilter<TrainingImageType, RGBImageType, ColorMapFunctorType>; + ColorMapFilterType::Pointer colormapper = ColorMapFilterType::New(); colormapper->SetInput(classifier->GetOutput()); // We can now create an image file writer and save the image. - typedef otb::ImageFileWriter<RGBImageType> WriterRescaledType; + using WriterRescaledType = otb::ImageFileWriter<RGBImageType>; WriterRescaledType::Pointer writerRescaled = WriterRescaledType::New(); diff --git a/Examples/Learning/TrainMachineLearningModelFromImagesExample.cxx b/Examples/Learning/TrainMachineLearningModelFromImagesExample.cxx index 227776c73f5a5ee347b2249d9ad3d5085876c99e..1016a6581bc85983a4242d9d027ae9919f19825d 100644 --- a/Examples/Learning/TrainMachineLearningModelFromImagesExample.cxx +++ b/Examples/Learning/TrainMachineLearningModelFromImagesExample.cxx @@ -56,12 +56,12 @@ int main(int itkNotUsed(argc), char* argv[]) const char* trainingShpFileName = argv[2]; const char* outputModelFileName = argv[3]; - typedef unsigned int InputPixelType; - const unsigned int Dimension = 2; - typedef otb::VectorImage<InputPixelType, Dimension> InputImageType; - typedef otb::VectorData<double, 2> VectorDataType; - typedef otb::ImageFileReader<InputImageType> InputReaderType; - typedef otb::VectorDataFileReader<VectorDataType> VectorDataReaderType; + using InputPixelType = unsigned int; + const unsigned int Dimension = 2; + using InputImageType = otb::VectorImage<InputPixelType, Dimension>; + using VectorDataType = otb::VectorData<double, 2>; + using InputReaderType = otb::ImageFileReader<InputImageType>; + using VectorDataReaderType = otb::VectorDataFileReader<VectorDataType>; // In this framework, we must transform the input samples store in a vector // data into a \subdoxygen{itk}{Statistics}{ListSample} which is the structure @@ -74,7 +74,7 @@ int main(int itkNotUsed(argc), char* argv[]) // \doxygen{otb}{ListSampleGenerator} class. // VectorData projection filter - typedef otb::VectorDataIntoImageProjectionFilter<VectorDataType, InputImageType> VectorDataReprojectionType; + using VectorDataReprojectionType = otb::VectorDataIntoImageProjectionFilter<VectorDataType, InputImageType>; InputReaderType::Pointer inputReader = InputReaderType::New(); inputReader->SetFileName(inputImageFileName); @@ -98,8 +98,8 @@ int main(int itkNotUsed(argc), char* argv[]) vdreproj->Update(); - typedef otb::ListSampleGenerator<InputImageType, VectorDataType> ListSampleGeneratorType; - ListSampleGeneratorType::Pointer sampleGenerator; + using ListSampleGeneratorType = otb::ListSampleGenerator<InputImageType, VectorDataType>; + ListSampleGeneratorType::Pointer sampleGenerator; sampleGenerator = ListSampleGeneratorType::New(); sampleGenerator->SetInput(image); @@ -111,8 +111,8 @@ int main(int itkNotUsed(argc), char* argv[]) // std::cout << "Number of classes: " << sampleGenerator->GetNumberOfClasses() << std::endl; - // typedef ListSampleGeneratorType::ListSampleType ListSampleType; - // typedef otb::Statistics::ShiftScaleSampleListFilter<ListSampleType, ListSampleType> ShiftScaleFilterType; + // using ListSampleType = ListSampleGeneratorType::ListSampleType; + // using ShiftScaleFilterType = otb::Statistics::ShiftScaleSampleListFilter<ListSampleType, ListSampleType>; // // Shift scale the samples // ShiftScaleFilterType::Pointer trainingShiftScaleFilter = ShiftScaleFilterType::New(); @@ -132,7 +132,7 @@ int main(int itkNotUsed(argc), char* argv[]) // can be used to set classifier parameters. In the case of SVM, we set here the type // of the kernel. Other parameters are let with their default values. - typedef otb::SVMMachineLearningModel<InputImageType::InternalPixelType, ListSampleGeneratorType::ClassLabelType> SVMType; + using SVMType = otb::SVMMachineLearningModel<InputImageType::InternalPixelType, ListSampleGeneratorType::ClassLabelType>; SVMType::Pointer SVMClassifier = SVMType::New(); diff --git a/Examples/Learning/TrainMachineLearningModelFromSamplesExample.cxx b/Examples/Learning/TrainMachineLearningModelFromSamplesExample.cxx index ceacdeef13a72a6de4fd9288d6d846066a0e9b4d..1551fcf8bfb3d6431eb46f1e99a4cd51ec7c0283 100644 --- a/Examples/Learning/TrainMachineLearningModelFromSamplesExample.cxx +++ b/Examples/Learning/TrainMachineLearningModelFromSamplesExample.cxx @@ -62,14 +62,14 @@ int main(int argc, char* argv[]) // Input related typedefs - typedef float InputValueType; - typedef itk::VariableLengthVector<InputValueType> InputSampleType; - typedef itk::Statistics::ListSample<InputSampleType> InputListSampleType; + using InputValueType = float; + using InputSampleType = itk::VariableLengthVector<InputValueType>; + using InputListSampleType = itk::Statistics::ListSample<InputSampleType>; // Target related typedefs - typedef int TargetValueType; - typedef itk::FixedArray<TargetValueType, 1> TargetSampleType; - typedef itk::Statistics::ListSample<TargetSampleType> TargetListSampleType; + using TargetValueType = int; + using TargetSampleType = itk::FixedArray<TargetValueType, 1>; + using TargetListSampleType = itk::Statistics::ListSample<TargetSampleType>; InputListSampleType::Pointer InputListSample = InputListSampleType::New(); TargetListSampleType::Pointer TargetListSample = TargetListSampleType::New(); @@ -118,7 +118,7 @@ int main(int argc, char* argv[]) // OpenCV library (\cite{opencv_library}) which handles other classifiers than // the SVM. - typedef otb::SVMMachineLearningModel<InputValueType, TargetValueType> SVMType; + using SVMType = otb::SVMMachineLearningModel<InputValueType, TargetValueType>; SVMType::Pointer SVMClassifier = SVMType::New(); diff --git a/Examples/Markov/MarkovClassification1Example.cxx b/Examples/Markov/MarkovClassification1Example.cxx index d1b5cf4b331eccaf73ee728058fecb354b0c4eac..c37508180b431d4c760f9d20b668f85a5539fa66 100644 --- a/Examples/Markov/MarkovClassification1Example.cxx +++ b/Examples/Markov/MarkovClassification1Example.cxx @@ -69,17 +69,17 @@ int main(int argc, char* argv[]) const unsigned int Dimension = 2; - typedef double InternalPixelType; - typedef unsigned char LabelledPixelType; - typedef otb::Image<InternalPixelType, Dimension> InputImageType; - typedef otb::Image<LabelledPixelType, Dimension> LabelledImageType; + using InternalPixelType = double; + using LabelledPixelType = unsigned char; + using InputImageType = otb::Image<InternalPixelType, Dimension>; + using LabelledImageType = otb::Image<LabelledPixelType, Dimension>; // We define a reader for the image to be classified, an initialization for the // classification (which could be random) and a writer for the final // classification. - typedef otb::ImageFileReader<InputImageType> ReaderType; - typedef otb::ImageFileWriter<LabelledImageType> WriterType; + using ReaderType = otb::ImageFileReader<InputImageType>; + using WriterType = otb::ImageFileWriter<LabelledImageType>; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); @@ -94,7 +94,7 @@ int main(int argc, char* argv[]) // A \doxygen{otb}{MarkovRandomFieldFilter} is instantiated, this is the // main class which connect the other to do the Markov classification. - typedef otb::MarkovRandomFieldFilter<InputImageType, LabelledImageType> MarkovRandomFieldFilterType; + using MarkovRandomFieldFilterType = otb::MarkovRandomFieldFilter<InputImageType, LabelledImageType>; // An \doxygen{otb}{MRFSamplerRandomMAP}, which derives from the // \doxygen{otb}{MRFSampler}, is instantiated. The sampler is in charge of @@ -102,7 +102,7 @@ int main(int argc, char* argv[]) // \doxygen{otb}{MRFSamplerRandomMAP}, randomly pick one possible value // according to the MAP probability. - typedef otb::MRFSamplerRandom<InputImageType, LabelledImageType> SamplerType; + using SamplerType = otb::MRFSamplerRandom<InputImageType, LabelledImageType>; // An \doxygen{otb}{MRFOptimizerMetropoli}, which derives from the // \doxygen{otb}{MRFOptimizer}, is instantiated. The optimizer is in charge @@ -110,7 +110,7 @@ int main(int argc, char* argv[]) // \doxygen{otb}{MRFSamplerRandomMAP}, accept the proposal according to the // variation of energy it causes and a temperature parameter. - typedef otb::MRFOptimizerMetropolis OptimizerType; + using OptimizerType = otb::MRFOptimizerMetropolis; // Two energy, deriving from the \doxygen{otb}{MRFEnergy} class need to be instantiated. One energy // is required for the regularization, taking into account the relashionship between neighborhing pixels @@ -120,8 +120,8 @@ int main(int argc, char* argv[]) // The second energy is for the fidelity to the original data. Here it is done with an // \doxygen{otb}{MRFEnergyGaussianClassification} class, which defines a gaussian model for the data. - typedef otb::MRFEnergyPotts<LabelledImageType, LabelledImageType> EnergyRegularizationType; - typedef otb::MRFEnergyGaussianClassification<InputImageType, LabelledImageType> EnergyFidelityType; + using EnergyRegularizationType = otb::MRFEnergyPotts<LabelledImageType, LabelledImageType>; + using EnergyFidelityType = otb::MRFEnergyGaussianClassification<InputImageType, LabelledImageType>; // The different filters composing our pipeline are created by invoking their // \code{New()} methods, assigning the results to smart pointers. @@ -179,8 +179,8 @@ int main(int argc, char* argv[]) markovFilter->SetInput(reader->GetOutput()); - typedef itk::RescaleIntensityImageFilter<LabelledImageType, LabelledImageType> RescaleType; - RescaleType::Pointer rescaleFilter = RescaleType::New(); + using RescaleType = itk::RescaleIntensityImageFilter<LabelledImageType, LabelledImageType>; + RescaleType::Pointer rescaleFilter = RescaleType::New(); rescaleFilter->SetOutputMinimum(0); rescaleFilter->SetOutputMaximum(255); diff --git a/Examples/Markov/MarkovClassification2Example.cxx b/Examples/Markov/MarkovClassification2Example.cxx index 533e8e7e4709e3ce6fb1113112dc9d10d7d35cf3..cb1091b2b5f87e0e5bb3220c76085a0b244be7de 100644 --- a/Examples/Markov/MarkovClassification2Example.cxx +++ b/Examples/Markov/MarkovClassification2Example.cxx @@ -60,13 +60,13 @@ int main(int argc, char* argv[]) const unsigned int Dimension = 2; - typedef double InternalPixelType; - typedef unsigned char LabelledPixelType; - typedef otb::Image<InternalPixelType, Dimension> InputImageType; - typedef otb::Image<LabelledPixelType, Dimension> LabelledImageType; + using InternalPixelType = double; + using LabelledPixelType = unsigned char; + using InputImageType = otb::Image<InternalPixelType, Dimension>; + using LabelledImageType = otb::Image<LabelledPixelType, Dimension>; - typedef otb::ImageFileReader<InputImageType> ReaderType; - typedef otb::ImageFileWriter<LabelledImageType> WriterType; + using ReaderType = otb::ImageFileReader<InputImageType>; + using WriterType = otb::ImageFileWriter<LabelledImageType>; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); @@ -77,17 +77,17 @@ int main(int argc, char* argv[]) reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); - typedef otb::MarkovRandomFieldFilter<InputImageType, LabelledImageType> MarkovRandomFieldFilterType; + using MarkovRandomFieldFilterType = otb::MarkovRandomFieldFilter<InputImageType, LabelledImageType>; // And to declare these new type: - typedef otb::MRFSamplerRandomMAP<InputImageType, LabelledImageType> SamplerType; - // typedef otb::MRFSamplerRandom< InputImageType, LabelledImageType> SamplerType; + using SamplerType = otb::MRFSamplerRandomMAP<InputImageType, LabelledImageType>; + // using SamplerType = otb::MRFSamplerRandom< InputImageType, LabelledImageType>; - typedef otb::MRFOptimizerICM OptimizerType; + using OptimizerType = otb::MRFOptimizerICM; - typedef otb::MRFEnergyPotts<LabelledImageType, LabelledImageType> EnergyRegularizationType; - typedef otb::MRFEnergyGaussianClassification<InputImageType, LabelledImageType> EnergyFidelityType; + using EnergyRegularizationType = otb::MRFEnergyPotts<LabelledImageType, LabelledImageType>; + using EnergyFidelityType = otb::MRFEnergyGaussianClassification<InputImageType, LabelledImageType>; MarkovRandomFieldFilterType::Pointer markovFilter = MarkovRandomFieldFilterType::New(); EnergyRegularizationType::Pointer energyRegularization = EnergyRegularizationType::New(); @@ -132,8 +132,8 @@ int main(int argc, char* argv[]) markovFilter->SetInput(reader->GetOutput()); - typedef itk::RescaleIntensityImageFilter<LabelledImageType, LabelledImageType> RescaleType; - RescaleType::Pointer rescaleFilter = RescaleType::New(); + using RescaleType = itk::RescaleIntensityImageFilter<LabelledImageType, LabelledImageType>; + RescaleType::Pointer rescaleFilter = RescaleType::New(); rescaleFilter->SetOutputMinimum(0); rescaleFilter->SetOutputMaximum(255); diff --git a/Examples/Markov/MarkovClassification3Example.cxx b/Examples/Markov/MarkovClassification3Example.cxx index b72cc339d316c6535ebf5dfc51479cd05451bfbf..d71db512703364958e947b777c8a6d4c9b9f9c19 100644 --- a/Examples/Markov/MarkovClassification3Example.cxx +++ b/Examples/Markov/MarkovClassification3Example.cxx @@ -71,19 +71,19 @@ int main(int argc, char* argv[]) // The labeled image is of type unsigned char which allows up to 256 different // classes. - const unsigned int Dimension = 2; - typedef double InternalPixelType; - typedef unsigned char LabelledPixelType; + const unsigned int Dimension = 2; + using InternalPixelType = double; + using LabelledPixelType = unsigned char; - typedef otb::Image<InternalPixelType, Dimension> InputImageType; - typedef otb::Image<LabelledPixelType, Dimension> LabelledImageType; + using InputImageType = otb::Image<InternalPixelType, Dimension>; + using LabelledImageType = otb::Image<LabelledPixelType, Dimension>; // We define a reader for the image to be classified, an initialization for the // classification (which could be random) and a writer for the final // classification. - typedef otb::ImageFileReader<InputImageType> ReaderType; - typedef otb::ImageFileWriter<LabelledImageType> WriterType; + using ReaderType = otb::ImageFileReader<InputImageType>; + using WriterType = otb::ImageFileWriter<LabelledImageType>; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); @@ -99,7 +99,7 @@ int main(int argc, char* argv[]) // A MarkovRandomFieldFilter is instantiated, this is the // main class which connect the other to do the Markov classification. - typedef otb::MarkovRandomFieldFilter<InputImageType, LabelledImageType> MarkovRandomFieldFilterType; + using MarkovRandomFieldFilterType = otb::MarkovRandomFieldFilter<InputImageType, LabelledImageType>; // An MRFSamplerRandomMAP, which derives from the // MRFSampler, is instantiated. The sampler is in charge of @@ -107,7 +107,7 @@ int main(int argc, char* argv[]) // MRFSamplerRandomMAP, randomly pick one possible value // according to the MAP probability. - typedef otb::MRFSamplerRandom<InputImageType, LabelledImageType> SamplerType; + using SamplerType = otb::MRFSamplerRandom<InputImageType, LabelledImageType>; // An MRFOptimizerMetropolis, which derives from the // MRFOptimizer, is instantiated. The optimizer is in charge @@ -115,7 +115,7 @@ int main(int argc, char* argv[]) // MRFSamplerRandomMAP, accept the proposal according to the // variation of energy it causes and a temperature parameter. - typedef otb::MRFOptimizerMetropolis OptimizerType; + using OptimizerType = otb::MRFOptimizerMetropolis; // Two energy, deriving from the MRFEnergy class need to be instantiated. One energy // is required for the regularization, taking into account the relationship between neighboring pixels @@ -125,8 +125,8 @@ int main(int argc, char* argv[]) // The second energy is used for the fidelity to the original data. Here it is done with a // MRFEnergyFisherClassification class, which defines a Fisher distribution to model the data. - typedef otb::MRFEnergyPotts<LabelledImageType, LabelledImageType> EnergyRegularizationType; - typedef otb::MRFEnergyFisherClassification<InputImageType, LabelledImageType> EnergyFidelityType; + using EnergyRegularizationType = otb::MRFEnergyPotts<LabelledImageType, LabelledImageType>; + using EnergyFidelityType = otb::MRFEnergyFisherClassification<InputImageType, LabelledImageType>; // The different filters composing our pipeline are created by invoking their // New() methods, assigning the results to smart pointers. @@ -194,8 +194,8 @@ int main(int argc, char* argv[]) markovFilter->SetInput(reader->GetOutput()); - typedef itk::RescaleIntensityImageFilter<LabelledImageType, LabelledImageType> RescaleType; - RescaleType::Pointer rescaleFilter = RescaleType::New(); + using RescaleType = itk::RescaleIntensityImageFilter<LabelledImageType, LabelledImageType>; + RescaleType::Pointer rescaleFilter = RescaleType::New(); rescaleFilter->SetOutputMinimum(0); rescaleFilter->SetOutputMaximum(255); @@ -205,17 +205,17 @@ int main(int argc, char* argv[]) writer->Update(); // convert output image to color - typedef itk::RGBPixel<unsigned char> RGBPixelType; - typedef otb::Image<RGBPixelType, 2> RGBImageType; - typedef itk::Functor::ScalarToRGBPixelFunctor<unsigned long> ColorMapFunctorType; + using RGBPixelType = itk::RGBPixel<unsigned char>; + using RGBImageType = otb::Image<RGBPixelType, 2>; + using ColorMapFunctorType = itk::Functor::ScalarToRGBPixelFunctor<unsigned long>; - typedef itk::UnaryFunctorImageFilter<LabelledImageType, RGBImageType, ColorMapFunctorType> ColorMapFilterType; - ColorMapFilterType::Pointer colormapper = ColorMapFilterType::New(); + using ColorMapFilterType = itk::UnaryFunctorImageFilter<LabelledImageType, RGBImageType, ColorMapFunctorType>; + ColorMapFilterType::Pointer colormapper = ColorMapFilterType::New(); colormapper->SetInput(rescaleFilter->GetOutput()); // We can now create an image file writer and save the image. - typedef otb::ImageFileWriter<RGBImageType> WriterRescaledType; + using WriterRescaledType = otb::ImageFileWriter<RGBImageType>; WriterRescaledType::Pointer writerRescaled = WriterRescaledType::New(); diff --git a/Examples/Markov/MarkovRegularizationExample.cxx b/Examples/Markov/MarkovRegularizationExample.cxx index 8f23044653549c4e058f28bc732f35841df67403..71f8d57784bbd58cebaa9c9553a51cdcd009244e 100644 --- a/Examples/Markov/MarkovRegularizationExample.cxx +++ b/Examples/Markov/MarkovRegularizationExample.cxx @@ -64,11 +64,11 @@ int main(int argc, char* argv[]) const unsigned int Dimension = 2; - typedef unsigned char LabelledPixelType; - typedef otb::Image<LabelledPixelType, Dimension> LabelledImageType; + using LabelledPixelType = unsigned char; + using LabelledImageType = otb::Image<LabelledPixelType, Dimension>; - typedef otb::ImageFileReader<LabelledImageType> ReaderType; - typedef otb::ImageFileWriter<LabelledImageType> WriterType; + using ReaderType = otb::ImageFileReader<LabelledImageType>; + using WriterType = otb::ImageFileWriter<LabelledImageType>; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); @@ -80,14 +80,14 @@ int main(int argc, char* argv[]) reader->SetFileName(inputFilename); writer->SetFileName(outputFilename); - typedef otb::MarkovRandomFieldFilter<LabelledImageType, LabelledImageType> MarkovRandomFieldFilterType; + using MarkovRandomFieldFilterType = otb::MarkovRandomFieldFilter<LabelledImageType, LabelledImageType>; - typedef otb::MRFSamplerRandom<LabelledImageType, LabelledImageType> SamplerType; + using SamplerType = otb::MRFSamplerRandom<LabelledImageType, LabelledImageType>; - typedef otb::MRFOptimizerMetropolis OptimizerType; + using OptimizerType = otb::MRFOptimizerMetropolis; - typedef otb::MRFEnergyPotts<LabelledImageType, LabelledImageType> EnergyRegularizationType; - typedef otb::MRFEnergyPotts<LabelledImageType, LabelledImageType> EnergyFidelityType; + using EnergyRegularizationType = otb::MRFEnergyPotts<LabelledImageType, LabelledImageType>; + using EnergyFidelityType = otb::MRFEnergyPotts<LabelledImageType, LabelledImageType>; MarkovRandomFieldFilterType::Pointer markovFilter = MarkovRandomFieldFilterType::New(); EnergyRegularizationType::Pointer energyRegularization = EnergyRegularizationType::New(); @@ -107,8 +107,8 @@ int main(int argc, char* argv[]) // \doxygen{itk}{LabelStatisticsImageFilter} and more particularly the method // \code{GetNumberOfLabels()}. - typedef itk::LabelStatisticsImageFilter<LabelledImageType, LabelledImageType> LabelledStatType; - LabelledStatType::Pointer labelledStat = LabelledStatType::New(); + using LabelledStatType = itk::LabelStatisticsImageFilter<LabelledImageType, LabelledImageType>; + LabelledStatType::Pointer labelledStat = LabelledStatType::New(); labelledStat->SetInput(reader->GetOutput()); labelledStat->SetLabelInput(reader->GetOutput()); labelledStat->Update(); @@ -134,8 +134,8 @@ int main(int argc, char* argv[]) writer->Update(); - typedef itk::RescaleIntensityImageFilter<LabelledImageType, LabelledImageType> RescaleType; - RescaleType::Pointer rescaleFilter = RescaleType::New(); + using RescaleType = itk::RescaleIntensityImageFilter<LabelledImageType, LabelledImageType>; + RescaleType::Pointer rescaleFilter = RescaleType::New(); rescaleFilter->SetOutputMinimum(0); rescaleFilter->SetOutputMaximum(255); diff --git a/Examples/Markov/MarkovRestorationExample.cxx b/Examples/Markov/MarkovRestorationExample.cxx index 7bdb98a213b59d461eecc75120c8c3c8406b5303..fbadae46d1cb8e0b62c64fde1e630d3d6d9106ea 100644 --- a/Examples/Markov/MarkovRestorationExample.cxx +++ b/Examples/Markov/MarkovRestorationExample.cxx @@ -75,17 +75,17 @@ int main(int argc, char* argv[]) const unsigned int Dimension = 2; - typedef double InternalPixelType; - typedef unsigned char LabelledPixelType; - typedef otb::Image<InternalPixelType, Dimension> InputImageType; - typedef otb::Image<LabelledPixelType, Dimension> LabelledImageType; + using InternalPixelType = double; + using LabelledPixelType = unsigned char; + using InputImageType = otb::Image<InternalPixelType, Dimension>; + using LabelledImageType = otb::Image<LabelledPixelType, Dimension>; // We need to declare an additional reader for the initial state of the // MRF. This reader has to be instantiated on the LabelledImageType. - typedef otb::ImageFileReader<InputImageType> ReaderType; - typedef otb::ImageFileReader<LabelledImageType> ReaderLabelledType; - typedef otb::ImageFileWriter<LabelledImageType> WriterType; + using ReaderType = otb::ImageFileReader<InputImageType>; + using ReaderLabelledType = otb::ImageFileReader<LabelledImageType>; + using WriterType = otb::ImageFileWriter<LabelledImageType>; ReaderType::Pointer reader = ReaderType::New(); ReaderLabelledType::Pointer reader2 = ReaderLabelledType::New(); @@ -101,16 +101,16 @@ int main(int argc, char* argv[]) // We declare all the necessary types for the MRF: - typedef otb::MarkovRandomFieldFilter<InputImageType, LabelledImageType> MarkovRandomFieldFilterType; + using MarkovRandomFieldFilterType = otb::MarkovRandomFieldFilter<InputImageType, LabelledImageType>; - typedef otb::MRFSamplerRandom<InputImageType, LabelledImageType> SamplerType; + using SamplerType = otb::MRFSamplerRandom<InputImageType, LabelledImageType>; - typedef otb::MRFOptimizerMetropolis OptimizerType; + using OptimizerType = otb::MRFOptimizerMetropolis; // The regularization and the fidelity energy are declared and instantiated: - typedef otb::MRFEnergyEdgeFidelity<LabelledImageType, LabelledImageType> EnergyRegularizationType; - typedef otb::MRFEnergyGaussian<InputImageType, LabelledImageType> EnergyFidelityType; + using EnergyRegularizationType = otb::MRFEnergyEdgeFidelity<LabelledImageType, LabelledImageType>; + using EnergyFidelityType = otb::MRFEnergyGaussian<InputImageType, LabelledImageType>; MarkovRandomFieldFilterType::Pointer markovFilter = MarkovRandomFieldFilterType::New(); @@ -154,8 +154,8 @@ int main(int argc, char* argv[]) markovFilter->SetInput(reader->GetOutput()); - typedef itk::RescaleIntensityImageFilter<LabelledImageType, LabelledImageType> RescaleType; - RescaleType::Pointer rescaleFilter = RescaleType::New(); + using RescaleType = itk::RescaleIntensityImageFilter<LabelledImageType, LabelledImageType>; + RescaleType::Pointer rescaleFilter = RescaleType::New(); rescaleFilter->SetOutputMinimum(0); rescaleFilter->SetOutputMaximum(255); diff --git a/Examples/OBIA/HooverMetricsEstimation.cxx b/Examples/OBIA/HooverMetricsEstimation.cxx index 3a08bd9d296dcb44264b02a001a28d4418b3af54..bcd6adcc460a4fc6e149cea966a4e26bcb8c1019 100644 --- a/Examples/OBIA/HooverMetricsEstimation.cxx +++ b/Examples/OBIA/HooverMetricsEstimation.cxx @@ -74,18 +74,18 @@ int main(int argc, char* argv[]) // This type of label object allows storing generic attributes. Each region can store // a set of attributes: in this case, Hoover instances and metrics will be stored. - typedef otb::AttributesMapLabelObject<unsigned int, 2, float> LabelObjectType; - typedef itk::LabelMap<LabelObjectType> LabelMapType; - typedef otb::HooverMatrixFilter<LabelMapType> HooverMatrixFilterType; - typedef otb::HooverInstanceFilter<LabelMapType> InstanceFilterType; - - typedef otb::Image<unsigned int, 2> ImageType; - typedef itk::LabelImageToLabelMapFilter<ImageType, LabelMapType> ImageToLabelMapFilterType; - - typedef otb::VectorImage<float, 2> VectorImageType; - typedef otb::LabelMapToAttributeImageFilter<LabelMapType, VectorImageType> AttributeImageFilterType; - typedef otb::ImageFileReader<ImageType> ImageReaderType; - typedef otb::ImageFileWriter<VectorImageType> WriterType; + using LabelObjectType = otb::AttributesMapLabelObject<unsigned int, 2, float>; + using LabelMapType = itk::LabelMap<LabelObjectType>; + using HooverMatrixFilterType = otb::HooverMatrixFilter<LabelMapType>; + using InstanceFilterType = otb::HooverInstanceFilter<LabelMapType>; + + using ImageType = otb::Image<unsigned int, 2>; + using ImageToLabelMapFilterType = itk::LabelImageToLabelMapFilter<ImageType, LabelMapType>; + + using VectorImageType = otb::VectorImage<float, 2>; + using AttributeImageFilterType = otb::LabelMapToAttributeImageFilter<LabelMapType, VectorImageType>; + using ImageReaderType = otb::ImageFileReader<ImageType>; + using WriterType = otb::ImageFileWriter<VectorImageType>; ImageReaderType::Pointer gt_reader = ImageReaderType::New(); gt_reader->SetFileName(argv[1]); diff --git a/Examples/OBIA/LabelMapToVectorData.cxx b/Examples/OBIA/LabelMapToVectorData.cxx index 2f2a1423404845c1fd60146b0e0ae5524472ee87..b88ee2425cc5bd70baa727bbedfbac57d918ec81 100644 --- a/Examples/OBIA/LabelMapToVectorData.cxx +++ b/Examples/OBIA/LabelMapToVectorData.cxx @@ -68,23 +68,23 @@ int main(int argc, char* argv[]) // dimension. The input image is defined as an \doxygen{itk}{Image}, // the output is a \doxygen{otb}{VectorData}. - const unsigned int Dimension = 2; - typedef unsigned short LabelType; - typedef otb::Image<LabelType, Dimension> LabeledImageType; - typedef otb::VectorData<double, 2> VectorDataType; + const unsigned int Dimension = 2; + using LabelType = unsigned short; + using LabeledImageType = otb::Image<LabelType, Dimension>; + using VectorDataType = otb::VectorData<double, 2>; // We instantiate reader and writer types - typedef otb::ImageFileReader<LabeledImageType> LabeledReaderType; - typedef otb::VectorDataFileWriter<VectorDataType> WriterType; + using LabeledReaderType = otb::ImageFileReader<LabeledImageType>; + using WriterType = otb::VectorDataFileWriter<VectorDataType>; // Label map typedef // The Attribute Label Map is // instantiated using the image pixel types as template parameters. // The LabelObjectToPolygonFunctor is instantiated with LabelObjectType and PolygonType. - typedef otb::AttributesMapLabelObject<LabelType, Dimension, double> LabelObjectType; - typedef itk::LabelMap<LabelObjectType> LabelMapType; - typedef itk::LabelImageToLabelMapFilter<LabeledImageType, LabelMapType> LabelMapFilterType; + using LabelObjectType = otb::AttributesMapLabelObject<LabelType, Dimension, double>; + using LabelMapType = itk::LabelMap<LabelObjectType>; + using LabelMapFilterType = itk::LabelImageToLabelMapFilter<LabeledImageType, LabelMapType>; LabeledReaderType::Pointer lreader = LabeledReaderType::New(); WriterType::Pointer writer = WriterType::New(); @@ -106,7 +106,7 @@ int main(int argc, char* argv[]) // Then, the \doxygen{otb}{LabelMapToVectorDataFilter} is instantiated. This is // the main filter which performs the vectorization. - typedef otb::LabelMapToVectorDataFilter<LabelMapType, VectorDataType> LabelMapToVectorDataFilterType; + using LabelMapToVectorDataFilterType = otb::LabelMapToVectorDataFilter<LabelMapType, VectorDataType>; LabelMapToVectorDataFilterType::Pointer MyFilter = LabelMapToVectorDataFilterType::New(); diff --git a/Examples/OBIA/RadiometricAttributesLabelMapFilterExample.cxx b/Examples/OBIA/RadiometricAttributesLabelMapFilterExample.cxx index 1ab6443c048376eafa4f9cbd31dabafba345711c..848dd626742959986933b4f1715b6da5328bf9c6 100644 --- a/Examples/OBIA/RadiometricAttributesLabelMapFilterExample.cxx +++ b/Examples/OBIA/RadiometricAttributesLabelMapFilterExample.cxx @@ -84,31 +84,31 @@ int main(int argc, char* argv[]) const unsigned int Dimension = 2; // Labeled image type - typedef unsigned int LabelType; - typedef unsigned char MaskPixelType; - typedef double PixelType; - typedef otb::Image<LabelType, Dimension> LabeledImageType; - typedef otb::Image<MaskPixelType, Dimension> MaskImageType; - typedef otb::Image<PixelType, Dimension> ImageType; - typedef otb::VectorImage<PixelType, Dimension> VectorImageType; - typedef otb::VectorImage<unsigned char, Dimension> OutputVectorImageType; - typedef otb::ImageFileReader<LabeledImageType> LabeledReaderType; - typedef otb::ImageFileReader<ImageType> ReaderType; - typedef otb::ImageFileReader<VectorImageType> VectorReaderType; - typedef otb::ImageFileWriter<MaskImageType> WriterType; - typedef otb::ImageFileWriter<OutputVectorImageType> VectorWriterType; - typedef otb::VectorRescaleIntensityImageFilter<VectorImageType, OutputVectorImageType> VectorRescalerType; - typedef otb::MultiChannelExtractROI<unsigned char, unsigned char> ChannelExtractorType; + using LabelType = unsigned int; + using MaskPixelType = unsigned char; + using PixelType = double; + using LabeledImageType = otb::Image<LabelType, Dimension>; + using MaskImageType = otb::Image<MaskPixelType, Dimension>; + using ImageType = otb::Image<PixelType, Dimension>; + using VectorImageType = otb::VectorImage<PixelType, Dimension>; + using OutputVectorImageType = otb::VectorImage<unsigned char, Dimension>; + using LabeledReaderType = otb::ImageFileReader<LabeledImageType>; + using ReaderType = otb::ImageFileReader<ImageType>; + using VectorReaderType = otb::ImageFileReader<VectorImageType>; + using WriterType = otb::ImageFileWriter<MaskImageType>; + using VectorWriterType = otb::ImageFileWriter<OutputVectorImageType>; + using VectorRescalerType = otb::VectorRescaleIntensityImageFilter<VectorImageType, OutputVectorImageType>; + using ChannelExtractorType = otb::MultiChannelExtractROI<unsigned char, unsigned char>; // Label map typedef - typedef otb::AttributesMapLabelObject<LabelType, Dimension, double> LabelObjectType; - typedef itk::LabelMap<LabelObjectType> LabelMapType; - typedef itk::LabelImageToLabelMapFilter<LabeledImageType, LabelMapType> LabelMapFilterType; - typedef otb::ShapeAttributesLabelMapFilter<LabelMapType> ShapeLabelMapFilterType; - typedef otb::BandsStatisticsAttributesLabelMapFilter<LabelMapType, VectorImageType> RadiometricLabelMapFilterType; - typedef otb::AttributesMapOpeningLabelMapFilter<LabelMapType> OpeningLabelMapFilterType; - typedef itk::LabelMapToBinaryImageFilter<LabelMapType, MaskImageType> LabelMapToBinaryImageFilterType; - typedef itk::UnaryFunctorImageFilter<VectorImageType, ImageType, otb::Functor::NDVI<PixelType, PixelType>> NDVIImageFilterType; - typedef otb::ImageToVectorImageCastFilter<ImageType, VectorImageType> ImageToVectorImageCastFilterType; + using LabelObjectType = otb::AttributesMapLabelObject<LabelType, Dimension, double>; + using LabelMapType = itk::LabelMap<LabelObjectType>; + using LabelMapFilterType = itk::LabelImageToLabelMapFilter<LabeledImageType, LabelMapType>; + using ShapeLabelMapFilterType = otb::ShapeAttributesLabelMapFilter<LabelMapType>; + using RadiometricLabelMapFilterType = otb::BandsStatisticsAttributesLabelMapFilter<LabelMapType, VectorImageType>; + using OpeningLabelMapFilterType = otb::AttributesMapOpeningLabelMapFilter<LabelMapType>; + using LabelMapToBinaryImageFilterType = itk::LabelMapToBinaryImageFilter<LabelMapType, MaskImageType>; + using NDVIImageFilterType = itk::UnaryFunctorImageFilter<VectorImageType, ImageType, otb::Functor::NDVI<PixelType, PixelType>>; + using ImageToVectorImageCastFilterType = otb::ImageToVectorImageCastFilter<ImageType, VectorImageType>; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(reffname); @@ -122,8 +122,8 @@ int main(int argc, char* argv[]) // Firstly, segment the input image by using the Mean Shift algorithm (see \ref{sec:MeanShift} for deeper // explanations). - typedef otb::MeanShiftSegmentationFilter<VectorImageType, LabeledImageType, VectorImageType> FilterType; - FilterType::Pointer filter = FilterType::New(); + using FilterType = otb::MeanShiftSegmentationFilter<VectorImageType, LabeledImageType, VectorImageType>; + FilterType::Pointer filter = FilterType::New(); filter->SetSpatialBandwidth(spatialRadius); filter->SetRangeBandwidth(rangeRadius); filter->SetMinRegionSize(minRegionSize); diff --git a/Examples/Patented/SIFTDensityExample.cxx b/Examples/Patented/SIFTDensityExample.cxx index 90e818e5e9aea2d4dde0861b0862f6060a41f7cc..e235feb606b07de6f8ede46365bc44e5575d0212 100644 --- a/Examples/Patented/SIFTDensityExample.cxx +++ b/Examples/Patented/SIFTDensityExample.cxx @@ -55,27 +55,27 @@ int main(int itkNotUsed(argc), char* argv[]) const unsigned int radius = atoi(argv[6]); const unsigned int Dimension = 2; - typedef float PixelType; + using PixelType = float; // As usual, we start by defining the types for the images, the reader // and the writer. - typedef otb::Image<PixelType, Dimension> ImageType; - typedef otb::ImageFileReader<ImageType> ReaderType; - typedef otb::ImageFileWriter<ImageType> WriterType; + using ImageType = otb::Image<PixelType, Dimension>; + using ReaderType = otb::ImageFileReader<ImageType>; + using WriterType = otb::ImageFileWriter<ImageType>; // We define now the type for the keypoint detection. The keypoints // will be stored in vector form (they may contain many descriptors) // into a point set. The filter for detecting the SIFT is templated // over the input image type and the output pointset type. - typedef itk::VariableLengthVector<PixelType> RealVectorType; - typedef itk::PointSet<RealVectorType, Dimension> PointSetType; - typedef otb::ImageToSIFTKeyPointSetFilter<ImageType, PointSetType> DetectorType; + using RealVectorType = itk::VariableLengthVector<PixelType>; + using PointSetType = itk::PointSet<RealVectorType, Dimension>; + using DetectorType = otb::ImageToSIFTKeyPointSetFilter<ImageType, PointSetType>; // We can now define the filter which will compute the SIFT // density. It will be templated over the input and output image // types and the SIFT detector. - typedef otb::KeyPointDensityImageFilter<ImageType, ImageType, DetectorType> FilterType; + using FilterType = otb::KeyPointDensityImageFilter<ImageType, ImageType, DetectorType>; // We can instantiate the reader and the writer as wella s the // filter and the detector. The detector needs to be instantiated in // order to set its parameters. @@ -129,9 +129,9 @@ int main(int itkNotUsed(argc), char* argv[]) /************* Image for printing **************/ - typedef otb::Image<unsigned char, 2> OutputImageType; + using OutputImageType = otb::Image<unsigned char, 2>; - typedef itk::RescaleIntensityImageFilter<ImageType, OutputImageType> RescalerType; + using RescalerType = itk::RescaleIntensityImageFilter<ImageType, OutputImageType>; RescalerType::Pointer rescaler = RescalerType::New(); @@ -140,8 +140,8 @@ int main(int itkNotUsed(argc), char* argv[]) rescaler->SetInput(filter->GetOutput()); - typedef otb::ImageFileWriter<OutputImageType> OutputWriterType; - OutputWriterType::Pointer outwriter = OutputWriterType::New(); + using OutputWriterType = otb::ImageFileWriter<OutputImageType>; + OutputWriterType::Pointer outwriter = OutputWriterType::New(); outwriter->SetFileName(prettyfname); outwriter->SetInput(rescaler->GetOutput()); diff --git a/Examples/Patented/SIFTDisparityMapEstimation.cxx b/Examples/Patented/SIFTDisparityMapEstimation.cxx index e56bd0c55d00f87994e99f91ab753f80d875777b..be80a5044c3e5331dbc36520f1bf62dffa42af0a 100644 --- a/Examples/Patented/SIFTDisparityMapEstimation.cxx +++ b/Examples/Patented/SIFTDisparityMapEstimation.cxx @@ -65,35 +65,35 @@ int main(int argc, char* argv[]) // all the computations in floating point precision and rescale the results // between 0 and 255 in order to export PNG images. - typedef double RealType; - typedef unsigned char OutputPixelType; + using RealType = double; + using OutputPixelType = unsigned char; - typedef otb::Image<RealType, Dimension> ImageType; - typedef otb::Image<OutputPixelType, Dimension> OutputImageType; + using ImageType = otb::Image<RealType, Dimension>; + using OutputImageType = otb::Image<OutputPixelType, Dimension>; // The SIFTs obtained for the matching will be stored in vector // form inside a point set. So we need the following types: - typedef itk::VariableLengthVector<RealType> RealVectorType; - typedef itk::PointSet<RealVectorType, Dimension> PointSetType; + using RealVectorType = itk::VariableLengthVector<RealType>; + using PointSetType = itk::PointSet<RealVectorType, Dimension>; // The filter for computing the SIFTs has a type defined as follows: - typedef otb::SiftFastImageFilter<ImageType, PointSetType> ImageToSIFTKeyPointSetFilterType; + using ImageToSIFTKeyPointSetFilterType = otb::SiftFastImageFilter<ImageType, PointSetType>; // Although many choices for evaluating the distances during the // matching procedure exist, we choose here to use a simple // Euclidean distance. We can then define the type for the matching filter. - typedef itk::Statistics::EuclideanDistanceMetric<RealVectorType> DistanceType; - typedef otb::KeyPointSetsMatchingFilter<PointSetType, DistanceType> EuclideanDistanceMetricMatchingFilterType; + using DistanceType = itk::Statistics::EuclideanDistanceMetric<RealVectorType>; + using EuclideanDistanceMetricMatchingFilterType = otb::KeyPointSetsMatchingFilter<PointSetType, DistanceType>; // The following types are needed for dealing with the matched points. - typedef PointSetType::PointType PointType; - typedef std::pair<PointType, PointType> MatchType; - typedef std::vector<MatchType> MatchVectorType; - typedef EuclideanDistanceMetricMatchingFilterType::LandmarkListType LandmarkListType; + using PointType = PointSetType::PointType; + using MatchType = std::pair<PointType, PointType>; + using MatchVectorType = std::vector<MatchType>; + using LandmarkListType = EuclideanDistanceMetricMatchingFilterType::LandmarkListType; // We define the type for the image reader. - typedef otb::ImageFileReader<ImageType> ReaderType; + using ReaderType = otb::ImageFileReader<ImageType>; // Two readers are instantiated : one for the fixed image, and one // for the moving image. @@ -144,7 +144,7 @@ int main(int argc, char* argv[]) } // Displaying the matches - typedef itk::RescaleIntensityImageFilter<ImageType, OutputImageType> PrintableFilterType; + using PrintableFilterType = itk::RescaleIntensityImageFilter<ImageType, OutputImageType>; PrintableFilterType::Pointer printable1 = PrintableFilterType::New(); PrintableFilterType::Pointer printable2 = PrintableFilterType::New(); @@ -159,7 +159,7 @@ int main(int argc, char* argv[]) printable2->SetOutputMaximum(255); printable2->Update(); - typedef otb::Image<itk::RGBPixel<unsigned char>, 2> RGBImageType; + using RGBImageType = otb::Image<itk::RGBPixel<unsigned char>, 2>; RGBImageType::Pointer rgbimage1 = RGBImageType::New(); rgbimage1->SetRegions(printable1->GetOutput()->GetLargestPossibleRegion()); @@ -201,10 +201,10 @@ int main(int argc, char* argv[]) // deformation field is an image of vectors created by the // \doxygen{itk}{DisplacementFieldSource} class. - typedef itk::Vector<RealType, Dimension> VectorType; - typedef otb::Image<VectorType, Dimension> DisplacementFieldType; + using VectorType = itk::Vector<RealType, Dimension>; + using DisplacementFieldType = otb::Image<VectorType, Dimension>; - typedef itk::LandmarkDisplacementFieldSource<DisplacementFieldType> DisplacementSourceType; + using DisplacementSourceType = itk::LandmarkDisplacementFieldSource<DisplacementFieldType>; DisplacementSourceType::Pointer deformer = DisplacementSourceType::New(); // The deformation field needs information about the extent and @@ -216,8 +216,8 @@ int main(int argc, char* argv[]) deformer->SetOutputRegion(fixedImage->GetLargestPossibleRegion()); // We will need some intermediate variables in order to pass the // matched SIFTs to the deformation field source. - typedef DisplacementSourceType::LandmarkContainer LandmarkContainerType; - typedef DisplacementSourceType::LandmarkPointType LandmarkPointType; + using LandmarkContainerType = DisplacementSourceType::LandmarkContainer; + using LandmarkPointType = DisplacementSourceType::LandmarkPointType; LandmarkContainerType::Pointer sourceLandmarks = LandmarkContainerType::New(); LandmarkContainerType::Pointer targetLandmarks = LandmarkContainerType::New(); @@ -275,15 +275,15 @@ int main(int argc, char* argv[]) ++outIt; } - typedef itk::RescaleIntensityImageFilter<ImageType, OutputImageType> RescaleType; + using RescaleType = itk::RescaleIntensityImageFilter<ImageType, OutputImageType>; RescaleType::Pointer rescaler = RescaleType::New(); rescaler->SetInput(outdf); rescaler->SetOutputMinimum(0); rescaler->SetOutputMaximum(255); - typedef otb::ImageFileWriter<OutputImageType> WriterType; - WriterType::Pointer writer = WriterType::New(); + using WriterType = otb::ImageFileWriter<OutputImageType>; + WriterType::Pointer writer = WriterType::New(); writer->SetInput(rescaler->GetOutput()); writer->SetFileName(argv[3]); diff --git a/Examples/Patented/SIFTExample.cxx b/Examples/Patented/SIFTExample.cxx index 2edddf27fa994f23d69950e61692cf0f6efb8acd..697206fe3af26d16183a0063f8692bfc4b1acfb5 100644 --- a/Examples/Patented/SIFTExample.cxx +++ b/Examples/Patented/SIFTExample.cxx @@ -82,24 +82,24 @@ int main(int argc, char* argv[]) float threshold = atof(argv[6]); float ratio = atof(argv[7]); - typedef float RealType; + using RealType = float; const unsigned int Dimension = 2; // The \doxygen{otb}{ImageToSIFTKeyPointSetFilter} is templated over // its input image type and the output point set type. Therefore, we // start by defining the needed types. - typedef otb::Image<RealType, Dimension> ImageType; - typedef itk::VariableLengthVector<RealType> RealVectorType; - typedef otb::ImageFileReader<ImageType> ReaderType; - typedef itk::PointSet<RealVectorType, Dimension> PointSetType; + using ImageType = otb::Image<RealType, Dimension>; + using RealVectorType = itk::VariableLengthVector<RealType>; + using ReaderType = otb::ImageFileReader<ImageType>; + using PointSetType = itk::PointSet<RealVectorType, Dimension>; - typedef otb::ImageToSIFTKeyPointSetFilter<ImageType, PointSetType> ImageToSIFTKeyPointSetFilterType; + using ImageToSIFTKeyPointSetFilterType = otb::ImageToSIFTKeyPointSetFilter<ImageType, PointSetType>; // Since the SIFT detector produces a point set, we will need // iterators for the coordinates of the points and the data associated // with them. - typedef PointSetType::PointsContainer PointsContainerType; - typedef PointsContainerType::Iterator PointsIteratorType; + using PointsContainerType = PointSetType::PointsContainer; + using PointsIteratorType = PointsContainerType::Iterator; // We can now instantiate the reader and the SIFT filter and plug the pipeline. ReaderType::Pointer reader = ReaderType::New(); @@ -162,10 +162,10 @@ int main(int argc, char* argv[]) ImageType::OffsetType r = {{1, 0}}; ImageType::OffsetType l = {{-1, 0}}; - typedef itk::RGBPixel<unsigned char> RGBPixelType; - typedef otb::Image<RGBPixelType, 2> OutputImageType; + using RGBPixelType = itk::RGBPixel<unsigned char>; + using OutputImageType = otb::Image<RGBPixelType, 2>; - typedef otb::ImageFileWriter<OutputImageType> WriterType; + using WriterType = otb::ImageFileWriter<OutputImageType>; OutputImageType::Pointer outputImage = OutputImageType::New(); diff --git a/Examples/Patented/SIFTFastExample.cxx b/Examples/Patented/SIFTFastExample.cxx index 5ffeb433686bbec444eeded0e02e8153e28c6084..4a5f8251a674d1ccf26667f79cc2833e9a62dc1b 100644 --- a/Examples/Patented/SIFTFastExample.cxx +++ b/Examples/Patented/SIFTFastExample.cxx @@ -66,18 +66,18 @@ int main(int argc, char* argv[]) // scalar image of float pixels. We also define the corresponding // image reader. - typedef float RealType; - typedef otb::Image<RealType, Dimension> ImageType; - typedef otb::ImageFileReader<ImageType> ReaderType; + using RealType = float; + using ImageType = otb::Image<RealType, Dimension>; + using ReaderType = otb::ImageFileReader<ImageType>; // The SIFT descriptors will be stored in a point set containing the // vector of features. - typedef itk::VariableLengthVector<RealType> RealVectorType; - typedef itk::PointSet<RealVectorType, Dimension> PointSetType; + using RealVectorType = itk::VariableLengthVector<RealType>; + using PointSetType = itk::PointSet<RealVectorType, Dimension>; // The SIFT filter itself is templated over the input image and the // generated point set. - typedef otb::SiftFastImageFilter<ImageType, PointSetType> ImageToFastSIFTKeyPointSetFilterType; + using ImageToFastSIFTKeyPointSetFilterType = otb::SiftFastImageFilter<ImageType, PointSetType>; // We instantiate the reader. ReaderType::Pointer reader = ReaderType::New(); @@ -96,10 +96,10 @@ int main(int argc, char* argv[]) // input image. In order to do this, we will create the following RGB // image and the corresponding writer: - typedef unsigned char PixelType; - typedef itk::RGBPixel<PixelType> RGBPixelType; - typedef otb::Image<RGBPixelType, 2> OutputImageType; - typedef otb::ImageFileWriter<OutputImageType> WriterType; + using PixelType = unsigned char; + using RGBPixelType = itk::RGBPixel<PixelType>; + using OutputImageType = otb::Image<RGBPixelType, 2>; + using WriterType = otb::ImageFileWriter<OutputImageType>; OutputImageType::Pointer outputImage = OutputImageType::New(); // We set the regions of the image by copying the information from the @@ -138,8 +138,8 @@ int main(int argc, char* argv[]) // going to walk through using an iterator. These are the types needed // for this task: - typedef PointSetType::PointsContainer PointsContainerType; - typedef PointsContainerType::Iterator PointsIteratorType; + using PointsContainerType = PointSetType::PointsContainer; + using PointsIteratorType = PointsContainerType::Iterator; // We set the iterator to the beginning of the point set. PointsIteratorType pIt = filter->GetOutput()->GetPoints()->Begin(); diff --git a/Examples/Projections/EstimateRPCSensorModelExample.cxx b/Examples/Projections/EstimateRPCSensorModelExample.cxx index 67aaebd2767122020ed4ac651aef48cd41fb6a45..cdf0fb28d0a2222e07a1c6aab13ce1252cb6e4f0 100644 --- a/Examples/Projections/EstimateRPCSensorModelExample.cxx +++ b/Examples/Projections/EstimateRPCSensorModelExample.cxx @@ -60,13 +60,13 @@ int main(int argc, char* argv[]) // We declare the image type based on a particular pixel type and // dimension. In this case the \code{float} type is used for the pixels. - typedef otb::Image<float, 2> ImageType; - typedef otb::ImageFileReader<ImageType> ReaderType; + using ImageType = otb::Image<float, 2>; + using ReaderType = otb::ImageFileReader<ImageType>; - typedef otb::GCPsToRPCSensorModelImageFilter<ImageType> GCPsToSensorModelFilterType; + using GCPsToSensorModelFilterType = otb::GCPsToRPCSensorModelImageFilter<ImageType>; - typedef GCPsToSensorModelFilterType::Point2DType Point2DType; - typedef GCPsToSensorModelFilterType::Point3DType Point3DType; + using Point2DType = GCPsToSensorModelFilterType::Point2DType; + using Point3DType = GCPsToSensorModelFilterType::Point3DType; // We instantiate reader and writer types ReaderType::Pointer reader = ReaderType::New(); diff --git a/Examples/Projections/GeometriesProjectionExample.cxx b/Examples/Projections/GeometriesProjectionExample.cxx index 686ea45145804d7142c7173601c81ca70bf6cba7..3cd7a42788ed3831cecb8598553b173ee105c384 100644 --- a/Examples/Projections/GeometriesProjectionExample.cxx +++ b/Examples/Projections/GeometriesProjectionExample.cxx @@ -45,8 +45,8 @@ int main(int argc, char* argv[]) // is a single type for any kind of geometries set (OGR data source, or OGR // layer). - typedef otb::GeometriesSet InputGeometriesType; - typedef otb::GeometriesSet OutputGeometriesType; + using InputGeometriesType = otb::GeometriesSet; + using OutputGeometriesType = otb::GeometriesSet; // First, declare and instantiate the data source // \subdoxygen{otb}{ogr}{DataSource}. Then, encapsulate this data source into @@ -60,9 +60,9 @@ int main(int argc, char* argv[]) // pixels won't be read, only the header information using the // \code{UpdateOutputInformation()} method. - typedef otb::Image<unsigned short int, 2> ImageType; - typedef otb::ImageFileReader<ImageType> ImageReaderType; - ImageReaderType::Pointer imageReader = ImageReaderType::New(); + using ImageType = otb::Image<unsigned short int, 2>; + using ImageReaderType = otb::ImageFileReader<ImageType>; + ImageReaderType::Pointer imageReader = ImageReaderType::New(); imageReader->SetFileName(argv[2]); imageReader->UpdateOutputInformation(); @@ -71,8 +71,8 @@ int main(int argc, char* argv[]) // to use it when you design applications reading or saving vector // data. - typedef otb::GeometriesProjectionFilter GeometriesFilterType; - GeometriesFilterType::Pointer filter = GeometriesFilterType::New(); + using GeometriesFilterType = otb::GeometriesProjectionFilter; + GeometriesFilterType::Pointer filter = GeometriesFilterType::New(); // Information concerning the original projection of the vector data // will be automatically retrieved from the metadata. Nothing else diff --git a/Examples/Projections/OrthoRectificationExample.cxx b/Examples/Projections/OrthoRectificationExample.cxx index e3a2f4d1c5cdaf2a682c9b2bbc516f970134aba5..bb0415e5d69dbe806eebf5686b121d00ef730e61 100644 --- a/Examples/Projections/OrthoRectificationExample.cxx +++ b/Examples/Projections/OrthoRectificationExample.cxx @@ -54,10 +54,10 @@ int main(int argc, char* argv[]) // the number of stream divisions we want to apply when writing the // output image, which can be very large. - typedef otb::Image<int, 2> ImageType; - typedef otb::VectorImage<int, 2> VectorImageType; - typedef otb::ImageFileReader<VectorImageType> ReaderType; - typedef otb::ImageFileWriter<VectorImageType> WriterType; + using ImageType = otb::Image<int, 2>; + using VectorImageType = otb::VectorImage<int, 2>; + using ReaderType = otb::ImageFileReader<VectorImageType>; + using WriterType = otb::ImageFileWriter<VectorImageType>; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); @@ -71,8 +71,7 @@ int main(int argc, char* argv[]) // Software Guide : BeginCodeSnippet - typedef otb::GenericRSResampleImageFilter<VectorImageType, VectorImageType> - OrthoRectifFilterType; + using OrthoRectifFilterType = otb::GenericRSResampleImageFilter<VectorImageType, VectorImageType>; OrthoRectifFilterType::Pointer orthoRectifFilter = OrthoRectifFilterType::New(); @@ -80,8 +79,10 @@ int main(int argc, char* argv[]) // instantiate the map projection, set the {\em zone} and {\em hemisphere} // parameters and pass this projection to the orthorectification filter. - std::string wkt = otb::SpatialReference::FromUTM(atoi(argv[3]),*argv[4]=='N'? otb::SpatialReference::hemisphere::north : otb::SpatialReference::hemisphere::south).ToWkt(); - std::cout<<wkt<<std::endl; + std::string wkt = + otb::SpatialReference::FromUTM(atoi(argv[3]), *argv[4] == 'N' ? otb::SpatialReference::hemisphere::north : otb::SpatialReference::hemisphere::south) + .ToWkt(); + std::cout << wkt << std::endl; orthoRectifFilter->SetOutputProjectionRef(wkt); // We then wire the input image to the orthorectification filter. diff --git a/Examples/Projections/VectorDataExtractROIExample.cxx b/Examples/Projections/VectorDataExtractROIExample.cxx index 3194eea322bd8f9df819a9459f34b430e8a1c690..cd98c36c77dd317c9fb36b8a8038b54afacb13f9 100644 --- a/Examples/Projections/VectorDataExtractROIExample.cxx +++ b/Examples/Projections/VectorDataExtractROIExample.cxx @@ -56,25 +56,25 @@ int main(int argc, char* argv[]) const char* inImageName = argv[2]; const char* outVectorName = argv[3]; - typedef double Type; - typedef otb::VectorData<> VectorDataType; + using Type = double; + using VectorDataType = otb::VectorData<>; - typedef otb::VectorDataFileReader<VectorDataType> VectorDataFileReaderType; - typedef otb::VectorDataFileWriter<VectorDataType> VectorDataWriterType; + using VectorDataFileReaderType = otb::VectorDataFileReader<VectorDataType>; + using VectorDataWriterType = otb::VectorDataFileWriter<VectorDataType>; - typedef otb::RemoteSensingRegion<Type> TypedRegion; + using TypedRegion = otb::RemoteSensingRegion<Type>; - typedef otb::Image<unsigned char, 2> ImageType; - typedef otb::ImageFileReader<ImageType> ImageReaderType; - ImageReaderType::Pointer imageReader = ImageReaderType::New(); + using ImageType = otb::Image<unsigned char, 2>; + using ImageReaderType = otb::ImageFileReader<ImageType>; + ImageReaderType::Pointer imageReader = ImageReaderType::New(); imageReader->SetFileName(inImageName); imageReader->UpdateOutputInformation(); // After the usual declaration (you can check the source file for the details), // we can declare the \doxygen{otb}{VectorDataExtractROI}: - typedef otb::VectorDataExtractROI<VectorDataType> FilterType; - FilterType::Pointer filter = FilterType::New(); + using FilterType = otb::VectorDataExtractROI<VectorDataType>; + FilterType::Pointer filter = FilterType::New(); // Then, we need to specify the region to extract. This region is a bit special as // it contains also information related to its reference system (cartographic projection diff --git a/Examples/Projections/VectorDataProjectionExample.cxx b/Examples/Projections/VectorDataProjectionExample.cxx index 7a063a172bc5288e1220b6c1174c71d77a1ed4e8..282cb306e9e00bc94f98d0e9c39ba2376f79da08 100644 --- a/Examples/Projections/VectorDataProjectionExample.cxx +++ b/Examples/Projections/VectorDataProjectionExample.cxx @@ -51,15 +51,15 @@ int main(int argc, char* argv[]) // Declare the vector data type that you would like to use in your // application. - typedef otb::VectorData<double> InputVectorDataType; - typedef otb::VectorData<double> OutputVectorDataType; + using InputVectorDataType = otb::VectorData<double>; + using OutputVectorDataType = otb::VectorData<double>; // Declare and instantiate the vector data reader: // \doxygen{otb}{VectorDataFileReader}. The call to the // \code{UpdateOutputInformation()} method fill up the header information. - typedef otb::VectorDataFileReader<InputVectorDataType> VectorDataFileReaderType; - VectorDataFileReaderType::Pointer reader = VectorDataFileReaderType::New(); + using VectorDataFileReaderType = otb::VectorDataFileReader<InputVectorDataType>; + VectorDataFileReaderType::Pointer reader = VectorDataFileReaderType::New(); reader->SetFileName(argv[1]); reader->UpdateOutputInformation(); @@ -69,9 +69,9 @@ int main(int argc, char* argv[]) // pixels won't be read, only the header information using the // \code{UpdateOutputInformation()} method. - typedef otb::Image<unsigned short int, 2> ImageType; - typedef otb::ImageFileReader<ImageType> ImageReaderType; - ImageReaderType::Pointer imageReader = ImageReaderType::New(); + using ImageType = otb::Image<unsigned short int, 2>; + using ImageReaderType = otb::ImageFileReader<ImageType>; + ImageReaderType::Pointer imageReader = ImageReaderType::New(); imageReader->SetFileName(argv[2]); imageReader->UpdateOutputInformation(); @@ -80,8 +80,8 @@ int main(int argc, char* argv[]) // to use it when you design applications reading or saving vector // data. - typedef otb::VectorDataProjectionFilter<InputVectorDataType, OutputVectorDataType> VectorDataFilterType; - VectorDataFilterType::Pointer vectorDataProjection = VectorDataFilterType::New(); + using VectorDataFilterType = otb::VectorDataProjectionFilter<InputVectorDataType, OutputVectorDataType>; + VectorDataFilterType::Pointer vectorDataProjection = VectorDataFilterType::New(); // Information concerning the original projection of the vector data // will be automatically retrieved from the metadata. Nothing else @@ -99,8 +99,8 @@ int main(int argc, char* argv[]) // Finally, the result is saved into a new vector file. - typedef otb::VectorDataFileWriter<OutputVectorDataType> VectorDataFileWriterType; - VectorDataFileWriterType::Pointer writer = VectorDataFileWriterType::New(); + using VectorDataFileWriterType = otb::VectorDataFileWriter<OutputVectorDataType>; + VectorDataFileWriterType::Pointer writer = VectorDataFileWriterType::New(); writer->SetFileName(argv[3]); writer->SetInput(vectorDataProjection->GetOutput()); writer->Update(); diff --git a/Examples/Radiometry/ARVIMultiChannelRAndBAndNIRVegetationIndexImageFilter.cxx b/Examples/Radiometry/ARVIMultiChannelRAndBAndNIRVegetationIndexImageFilter.cxx index 6845750ac2c420db14567e6aa6dc0c85b720072e..f544a7cee5ea26fd6a2810de8443d371c4975d28 100644 --- a/Examples/Radiometry/ARVIMultiChannelRAndBAndNIRVegetationIndexImageFilter.cxx +++ b/Examples/Radiometry/ARVIMultiChannelRAndBAndNIRVegetationIndexImageFilter.cxx @@ -98,29 +98,29 @@ int main(int argc, char* argv[]) // dimension. The input image is defined as an \doxygen{otb}{VectorImage}, // the output is a \doxygen{otb}{Image}. - const unsigned int Dimension = 2; - typedef double InputPixelType; - typedef float OutputPixelType; - typedef otb::VectorImage<InputPixelType, Dimension> InputImageType; - typedef otb::Image<OutputPixelType, Dimension> OutputImageType; + const unsigned int Dimension = 2; + using InputPixelType = double; + using OutputPixelType = float; + using InputImageType = otb::VectorImage<InputPixelType, Dimension>; + using OutputImageType = otb::Image<OutputPixelType, Dimension>; // We instantiate reader and writer types - typedef otb::ImageFileReader<InputImageType> ReaderType; - typedef otb::ImageFileWriter<OutputImageType> WriterType; + using ReaderType = otb::ImageFileReader<InputImageType>; + using WriterType = otb::ImageFileWriter<OutputImageType>; // The ARVI (Atmospherically Resistant Vegetation Index) is // instantiated using the image pixel types as template parameters. // Note that we also can use other functors which operate with the // Red, Blue and Nir channels such as EVI, ARVI and TSARVI. - typedef otb::Functor::ARVI<InputPixelType, OutputPixelType> FunctorType; + using FunctorType = otb::Functor::ARVI<InputPixelType, OutputPixelType>; // The // \doxygen{itk}{UnaryFunctorImageFilter} // type is defined using the image types and the ARVI functor as // template parameters. We then instantiate the filter itself. - typedef itk::UnaryFunctorImageFilter<InputImageType, OutputImageType, FunctorType> ArviImageFilterType; + using ArviImageFilterType = itk::UnaryFunctorImageFilter<InputImageType, OutputImageType, FunctorType>; ArviImageFilterType::Pointer filter = ArviImageFilterType::New(); @@ -164,13 +164,13 @@ int main(int argc, char* argv[]) } // Pretty image creation for the printing - typedef otb::Image<unsigned char, Dimension> OutputPrettyImageType; - typedef otb::VectorImage<unsigned char, Dimension> OutputVectorPrettyImageType; - typedef otb::ImageFileWriter<OutputVectorPrettyImageType> WriterVectorPrettyType; - typedef otb::ImageFileWriter<OutputPrettyImageType> WriterPrettyType; - typedef itk::RescaleIntensityImageFilter<OutputImageType, OutputPrettyImageType> RescalerType; - typedef otb::VectorRescaleIntensityImageFilter<InputImageType, OutputVectorPrettyImageType> VectorRescalerType; - typedef otb::MultiChannelExtractROI<unsigned char, unsigned char> ChannelExtractorType; + using OutputPrettyImageType = otb::Image<unsigned char, Dimension>; + using OutputVectorPrettyImageType = otb::VectorImage<unsigned char, Dimension>; + using WriterVectorPrettyType = otb::ImageFileWriter<OutputVectorPrettyImageType>; + using WriterPrettyType = otb::ImageFileWriter<OutputPrettyImageType>; + using RescalerType = itk::RescaleIntensityImageFilter<OutputImageType, OutputPrettyImageType>; + using VectorRescalerType = otb::VectorRescaleIntensityImageFilter<InputImageType, OutputVectorPrettyImageType>; + using ChannelExtractorType = otb::MultiChannelExtractROI<unsigned char, unsigned char>; VectorRescalerType::Pointer vectRescaler = VectorRescalerType::New(); ChannelExtractorType::Pointer selecter = ChannelExtractorType::New(); @@ -194,7 +194,7 @@ int main(int argc, char* argv[]) vectPrettyWriter->SetFileName(argv[3]); vectPrettyWriter->SetInput(selecter->GetOutput()); - typedef itk::ThresholdImageFilter<OutputImageType> ThresholderType; + using ThresholderType = itk::ThresholdImageFilter<OutputImageType>; ThresholderType::Pointer thresholder = ThresholderType::New(); thresholder->SetInput(filter->GetOutput()); diff --git a/Examples/Radiometry/AVIMultiChannelRAndGAndNIRVegetationIndexImageFilter.cxx b/Examples/Radiometry/AVIMultiChannelRAndGAndNIRVegetationIndexImageFilter.cxx index d42f8cd56e1227d88f1fe1b8bd956538a4bb80aa..67598f04d5cdf71bfae526bfa9c9bab6ebb43dc3 100644 --- a/Examples/Radiometry/AVIMultiChannelRAndGAndNIRVegetationIndexImageFilter.cxx +++ b/Examples/Radiometry/AVIMultiChannelRAndGAndNIRVegetationIndexImageFilter.cxx @@ -85,27 +85,27 @@ int main(int argc, char* argv[]) // dimension. The input image is defined as an \doxygen{otb}{VectorImage}, // the output is a \doxygen{otb}{Image}. - const unsigned int Dimension = 2; - typedef double InputPixelType; - typedef float OutputPixelType; - typedef otb::VectorImage<InputPixelType, Dimension> InputImageType; - typedef otb::Image<OutputPixelType, Dimension> OutputImageType; + const unsigned int Dimension = 2; + using InputPixelType = double; + using OutputPixelType = float; + using InputImageType = otb::VectorImage<InputPixelType, Dimension>; + using OutputImageType = otb::Image<OutputPixelType, Dimension>; // We instantiate reader and writer types - typedef otb::ImageFileReader<InputImageType> ReaderType; - typedef otb::ImageFileWriter<OutputImageType> WriterType; + using ReaderType = otb::ImageFileReader<InputImageType>; + using WriterType = otb::ImageFileWriter<OutputImageType>; // The AVI (Angular Vegetation Index) is // instantiated using the image pixel types as template parameters. - typedef otb::Functor::AVI<InputPixelType, OutputPixelType> FunctorType; + using FunctorType = otb::Functor::AVI<InputPixelType, OutputPixelType>; // The // \doxygen{itk}{UnaryFunctorImageFilter} // type is defined using the image types and the AVI functor as // template parameters. We then instantiate the filter itself. - typedef itk::UnaryFunctorImageFilter<InputImageType, OutputImageType, FunctorType> AVIImageFilterTypeType; + using AVIImageFilterTypeType = itk::UnaryFunctorImageFilter<InputImageType, OutputImageType, FunctorType>; AVIImageFilterTypeType::Pointer filter = AVIImageFilterTypeType::New(); @@ -150,13 +150,13 @@ int main(int argc, char* argv[]) } // Pretty image creation for the printing - typedef otb::Image<unsigned char, Dimension> OutputPrettyImageType; - typedef otb::VectorImage<unsigned char, Dimension> OutputVectorPrettyImageType; - typedef otb::ImageFileWriter<OutputVectorPrettyImageType> WriterVectorPrettyType; - typedef otb::ImageFileWriter<OutputPrettyImageType> WriterPrettyType; - typedef itk::RescaleIntensityImageFilter<OutputImageType, OutputPrettyImageType> RescalerType; - typedef otb::VectorRescaleIntensityImageFilter<InputImageType, OutputVectorPrettyImageType> VectorRescalerType; - typedef otb::MultiChannelExtractROI<unsigned char, unsigned char> ChannelExtractorType; + using OutputPrettyImageType = otb::Image<unsigned char, Dimension>; + using OutputVectorPrettyImageType = otb::VectorImage<unsigned char, Dimension>; + using WriterVectorPrettyType = otb::ImageFileWriter<OutputVectorPrettyImageType>; + using WriterPrettyType = otb::ImageFileWriter<OutputPrettyImageType>; + using RescalerType = itk::RescaleIntensityImageFilter<OutputImageType, OutputPrettyImageType>; + using VectorRescalerType = otb::VectorRescaleIntensityImageFilter<InputImageType, OutputVectorPrettyImageType>; + using ChannelExtractorType = otb::MultiChannelExtractROI<unsigned char, unsigned char>; VectorRescalerType::Pointer vectRescaler = VectorRescalerType::New(); ChannelExtractorType::Pointer selecter = ChannelExtractorType::New(); @@ -180,7 +180,7 @@ int main(int argc, char* argv[]) vectPrettyWriter->SetFileName(argv[3]); vectPrettyWriter->SetInput(selecter->GetOutput()); - typedef itk::ThresholdImageFilter<OutputImageType> ThresholderType; + using ThresholderType = itk::ThresholdImageFilter<OutputImageType>; ThresholderType::Pointer thresholder = ThresholderType::New(); thresholder->SetInput(filter->GetOutput()); diff --git a/Examples/Radiometry/AtmosphericCorrectionSequencement.cxx b/Examples/Radiometry/AtmosphericCorrectionSequencement.cxx index 0db1572208dfc0b9f7b3517a814962769bdcaf95..f7167700e67d8e4a9b011e1487d3b317ac774caa 100644 --- a/Examples/Radiometry/AtmosphericCorrectionSequencement.cxx +++ b/Examples/Radiometry/AtmosphericCorrectionSequencement.cxx @@ -134,14 +134,14 @@ int main(int argc, char* argv[]) // the output image is a \doxygen{otb}{VectorImage}. To simplify, input and // output image types are the same one. - const unsigned int Dimension = 2; - typedef double PixelType; - typedef otb::VectorImage<PixelType, Dimension> ImageType; + const unsigned int Dimension = 2; + using PixelType = double; + using ImageType = otb::VectorImage<PixelType, Dimension>; // We instantiate reader and writer types - typedef otb::ImageFileReader<ImageType> ReaderType; - typedef otb::ImageFileWriter<ImageType> WriterType; - ReaderType::Pointer reader = ReaderType::New(); + using ReaderType = otb::ImageFileReader<ImageType>; + using WriterType = otb::ImageFileWriter<ImageType>; + ReaderType::Pointer reader = ReaderType::New(); // The \code{GenerateOutputInformation()} reader method is called // to know the number of component per pixel of the image. It is @@ -185,12 +185,12 @@ int main(int argc, char* argv[]) // \item $\beta_{k}$ is the absolute calibration bias for the channel k. // \end{itemize} - typedef otb::ImageToRadianceImageFilter<ImageType, ImageType> ImageToRadianceImageFilterType; + using ImageToRadianceImageFilterType = otb::ImageToRadianceImageFilter<ImageType, ImageType>; - ImageToRadianceImageFilterType::Pointer filterImageToRadiance = ImageToRadianceImageFilterType::New(); - typedef ImageToRadianceImageFilterType::VectorType VectorType; - VectorType alpha(nbOfComponent); - VectorType beta(nbOfComponent); + ImageToRadianceImageFilterType::Pointer filterImageToRadiance = ImageToRadianceImageFilterType::New(); + using VectorType = ImageToRadianceImageFilterType::VectorType; + VectorType alpha(nbOfComponent); + VectorType beta(nbOfComponent); alpha.Fill(0); beta.Fill(0); std::ifstream fin; @@ -234,10 +234,10 @@ int main(int argc, char* argv[]) // the month and the day of the acquisition. // \end{itemize} - typedef otb::RadianceToReflectanceImageFilter<ImageType, ImageType> RadianceToReflectanceImageFilterType; - RadianceToReflectanceImageFilterType::Pointer filterRadianceToReflectance = RadianceToReflectanceImageFilterType::New(); + using RadianceToReflectanceImageFilterType = otb::RadianceToReflectanceImageFilter<ImageType, ImageType>; + RadianceToReflectanceImageFilterType::Pointer filterRadianceToReflectance = RadianceToReflectanceImageFilterType::New(); - typedef RadianceToReflectanceImageFilterType::VectorType VectorType; + using VectorType = RadianceToReflectanceImageFilterType::VectorType; VectorType solarIllumination(nbOfComponent); solarIllumination.Fill(0); @@ -279,16 +279,16 @@ int main(int argc, char* argv[]) // \doxygen{otb}{AtmosphericRadiativeTerms} // types are defined and instancied. - typedef otb::RadiometryCorrectionParametersToAtmosphericRadiativeTerms RadiometryCorrectionParametersToRadiativeTermsType; + using RadiometryCorrectionParametersToRadiativeTermsType = otb::RadiometryCorrectionParametersToAtmosphericRadiativeTerms; - typedef otb::AtmosphericCorrectionParameters AtmosphericCorrectionParametersType; + using AtmosphericCorrectionParametersType = otb::AtmosphericCorrectionParameters; - typedef otb::ImageMetadataCorrectionParameters AcquisitionCorrectionParametersType; + using AcquisitionCorrectionParametersType = otb::ImageMetadataCorrectionParameters; - typedef otb::AtmosphericRadiativeTerms AtmosphericRadiativeTermsType; - typedef AtmosphericCorrectionParametersType::AerosolModelType AerosolModelType; - typedef otb::FilterFunctionValues FilterFunctionValuesType; - typedef FilterFunctionValuesType::ValuesVectorType ValuesVectorType; + using AtmosphericRadiativeTermsType = otb::AtmosphericRadiativeTerms; + using AerosolModelType = AtmosphericCorrectionParametersType::AerosolModelType; + using FilterFunctionValuesType = otb::FilterFunctionValues; + using ValuesVectorType = FilterFunctionValuesType::ValuesVectorType; AtmosphericCorrectionParametersType::Pointer dataAtmosphericCorrectionParameters = AtmosphericCorrectionParametersType::New(); AcquisitionCorrectionParametersType::Pointer dataAcquisitionCorrectionParameters = AcquisitionCorrectionParametersType::New(); @@ -412,7 +412,7 @@ int main(int argc, char* argv[]) // Atmospheric corrections can now start. // First, an instance of \doxygen{otb}{ReflectanceToSurfaceReflectanceImageFilter} is created. - typedef otb::ReflectanceToSurfaceReflectanceImageFilter<ImageType, ImageType> ReflectanceToSurfaceReflectanceImageFilterType; + using ReflectanceToSurfaceReflectanceImageFilterType = otb::ReflectanceToSurfaceReflectanceImageFilter<ImageType, ImageType>; ReflectanceToSurfaceReflectanceImageFilterType::Pointer filterReflectanceToSurfaceReflectanceImageFilter = ReflectanceToSurfaceReflectanceImageFilterType::New(); @@ -491,8 +491,8 @@ int main(int argc, char* argv[]) // terms internally. If the "acquisition" correction parameters are not // present, the filter will try to get them from the image metadata. - typedef otb::SurfaceAdjacencyEffectCorrectionSchemeFilter<ImageType, ImageType> SurfaceAdjacencyEffectCorrectionSchemeFilterType; - SurfaceAdjacencyEffectCorrectionSchemeFilterType::Pointer filterSurfaceAdjacencyEffectCorrectionSchemeFilter = + using SurfaceAdjacencyEffectCorrectionSchemeFilterType = otb::SurfaceAdjacencyEffectCorrectionSchemeFilter<ImageType, ImageType>; + SurfaceAdjacencyEffectCorrectionSchemeFilterType::Pointer filterSurfaceAdjacencyEffectCorrectionSchemeFilter = SurfaceAdjacencyEffectCorrectionSchemeFilterType::New(); // Four inputs are needed to compute the neighborhood contribution: diff --git a/Examples/Simulation/LAIAndPROSAILToSensorResponse.cxx b/Examples/Simulation/LAIAndPROSAILToSensorResponse.cxx index 71f4cc673fcadef9a386f6c52fca0ca9a07219d2..9f9215743287a184524ec70fc45d156d52c8c308 100644 --- a/Examples/Simulation/LAIAndPROSAILToSensorResponse.cxx +++ b/Examples/Simulation/LAIAndPROSAILToSensorResponse.cxx @@ -66,10 +66,10 @@ template <class TImage> class ITK_EXPORT ImageUniqueValuesCalculator : public itk::Object { public: - typedef ImageUniqueValuesCalculator<TImage> Self; - typedef itk::Object Superclass; - typedef itk::SmartPointer<Self> Pointer; - typedef itk::SmartPointer<const Self> ConstPointer; + using Self = ImageUniqueValuesCalculator<TImage>; + using Superclass = itk::Object; + using Pointer = itk::SmartPointer<Self>; + using ConstPointer = itk::SmartPointer<const Self>; itkNewMacro(Self); @@ -77,14 +77,14 @@ public: itkStaticConstMacro(ImageDimension, unsigned int, TImage::ImageDimension); - typedef typename TImage::PixelType PixelType; + using PixelType = typename TImage::PixelType; - typedef TImage ImageType; + using ImageType = TImage; - typedef std::vector<PixelType> ArrayType; + using ArrayType = std::vector<PixelType>; - typedef typename ImageType::Pointer ImagePointer; - typedef typename ImageType::ConstPointer ImageConstPointer; + using ImagePointer = typename ImageType::Pointer; + using ImageConstPointer = typename ImageType::ConstPointer; virtual void SetImage(const ImageType* image) { @@ -159,25 +159,25 @@ public: // \code{ProsailSimulatorFunctor} functor is defined here. // - typedef TLAI LAIPixelType; - typedef TLabel LabelPixelType; - typedef TMask MaskPixelType; - typedef TOutput OutputPixelType; - typedef TLabelSpectra LabelSpectraType; - typedef TLabelParameter LabelParameterType; - typedef TAcquistionParameter AcquistionParameterType; - typedef TSatRSR SatRSRType; - typedef typename SatRSRType::Pointer SatRSRPointerType; - typedef typename otb::ProspectModel ProspectType; - typedef typename otb::SailModel SailType; - - typedef double PrecisionType; - typedef std::pair<PrecisionType, PrecisionType> PairType; - typedef typename std::vector<PairType> VectorPairType; - typedef otb::SpectralResponse<PrecisionType, PrecisionType> ResponseType; - typedef ResponseType::Pointer ResponsePointerType; - typedef otb::ReduceSpectralResponse<ResponseType, SatRSRType> ReduceResponseType; - typedef typename ReduceResponseType::Pointer ReduceResponseTypePointerType; + using LAIPixelType = TLAI; + using LabelPixelType = TLabel; + using MaskPixelType = TMask; + using OutputPixelType = TOutput; + using LabelSpectraType = TLabelSpectra; + using LabelParameterType = TLabelParameter; + using AcquistionParameterType = TAcquistionParameter; + using SatRSRType = TSatRSR; + using SatRSRPointerType = typename SatRSRType::Pointer; + using ProspectType = typename otb::ProspectModel; + using SailType = typename otb::SailModel; + + using PrecisionType = double; + using PairType = std::pair<PrecisionType, PrecisionType>; + using VectorPairType = typename std::vector<PairType>; + using ResponseType = otb::SpectralResponse<PrecisionType, PrecisionType>; + using ResponsePointerType = ResponseType::Pointer; + using ReduceResponseType = otb::ReduceSpectralResponse<ResponseType, SatRSRType>; + using ReduceResponseTypePointerType = typename ReduceResponseType::Pointer; // In this example spectra are generated form $400$ to $2400nm$. the number of simulated band is set by \code{SimNbBands} value. // @@ -351,10 +351,10 @@ template <class TInputImage1, class TInputImage2, class TInputImage3, class TOut class ITK_EXPORT TernaryFunctorImageFilterWithNBands : public itk::TernaryFunctorImageFilter<TInputImage1, TInputImage2, TInputImage3, TOutputImage, TFunctor> { public: - typedef TernaryFunctorImageFilterWithNBands Self; - typedef itk::TernaryFunctorImageFilter<TInputImage1, TInputImage2, TInputImage3, TOutputImage, TFunctor> Superclass; - typedef itk::SmartPointer<Self> Pointer; - typedef itk::SmartPointer<const Self> ConstPointer; + using Self = TernaryFunctorImageFilterWithNBands<TInputImage1, TInputImage2, TInputImage3, TOutputImage, TFunctor>; + using Superclass = itk::TernaryFunctorImageFilter<TInputImage1, TInputImage2, TInputImage3, TOutputImage, TFunctor>; + using Pointer = itk::SmartPointer<Self>; + using ConstPointer = itk::SmartPointer<const Self>; /** Method for creation through the object factory. */ itkNewMacro(Self); @@ -422,48 +422,47 @@ int main(int argc, char* argv[]) // cloud mask, and \code{integer} label image // - typedef double LAIPixelType; - typedef unsigned short LabelType; - typedef unsigned short MaskPixelType; - typedef float OutputPixelType; + using LAIPixelType = double; + using LabelType = unsigned short; + using MaskPixelType = unsigned short; + using OutputPixelType = float; // Image typedef - typedef otb::Image<LAIPixelType, 2> LAIImageType; - typedef otb::Image<LabelType, 2> LabelImageType; - typedef otb::Image<MaskPixelType, 2> MaskImageType; - typedef otb::VectorImage<OutputPixelType, 2> SimulatedImageType; + using LAIImageType = otb::Image<LAIPixelType, 2>; + using LabelImageType = otb::Image<LabelType, 2>; + using MaskImageType = otb::Image<MaskPixelType, 2>; + using SimulatedImageType = otb::VectorImage<OutputPixelType, 2>; // reader typedef - typedef otb::ImageFileReader<LAIImageType> LAIReaderType; - typedef otb::ImageFileReader<LabelImageType> LabelReaderType; - typedef otb::ImageFileReader<MaskImageType> MaskReaderType; + using LAIReaderType = otb::ImageFileReader<LAIImageType>; + using LabelReaderType = otb::ImageFileReader<LabelImageType>; + using MaskReaderType = otb::ImageFileReader<MaskImageType>; // Leaf parameters typedef is defined. - typedef otb::LeafParameters LeafParametersType; - typedef LeafParametersType::Pointer LeafParametersPointerType; - typedef std::map<LabelType, LeafParametersPointerType> LabelParameterMapType; + using LeafParametersType = otb::LeafParameters; + using LeafParametersPointerType = LeafParametersType::Pointer; + using LabelParameterMapType = std::map<LabelType, LeafParametersPointerType>; // Sensor spectral response typedef is defined - typedef double PrecisionType; - typedef std::vector<PrecisionType> SpectraType; - typedef std::map<LabelType, SpectraType> SpectraParameterType; + using PrecisionType = double; + using SpectraType = std::vector<PrecisionType>; + using SpectraParameterType = std::map<LabelType, SpectraType>; // Acquisition response typedef is defined - typedef std::map<std::string, double> AcquistionParsType; + using AcquistionParsType = std::map<std::string, double>; // Satellite typedef is defined - typedef otb::SatelliteRSR<PrecisionType, PrecisionType> SatRSRType; + using SatRSRType = otb::SatelliteRSR<PrecisionType, PrecisionType>; // Filter type is the specific \code{TernaryFunctorImageFilterWithNBands} defined below with specific functor. - typedef otb::Functor::ProsailSimulatorFunctor<LAIPixelType, LabelType, MaskPixelType, SimulatedImageType::PixelType, SpectraParameterType, - LabelParameterMapType, AcquistionParsType, SatRSRType> - SimuFunctorType; - typedef otb::TernaryFunctorImageFilterWithNBands<LAIImageType, LabelImageType, MaskImageType, SimulatedImageType, SimuFunctorType> SimulatorType; + using SimuFunctorType = otb::Functor::ProsailSimulatorFunctor<LAIPixelType, LabelType, MaskPixelType, SimulatedImageType::PixelType, SpectraParameterType, + LabelParameterMapType, AcquistionParsType, SatRSRType>; + using SimulatorType = otb::TernaryFunctorImageFilterWithNBands<LAIImageType, LabelImageType, MaskImageType, SimulatedImageType, SimuFunctorType>; // Read the acquisition parameter file which is like // Angl val @@ -576,9 +575,9 @@ int main(int argc, char* argv[]) { std::string spectraFilename = rootPath; ss >> spectraFilename; - spectraFilename = rootPath + spectraFilename; - typedef otb::SpectralResponse<PrecisionType, PrecisionType> ResponseType; - ResponseType::Pointer resp = ResponseType::New(); + spectraFilename = rootPath + spectraFilename; + using ResponseType = otb::SpectralResponse<PrecisionType, PrecisionType>; + ResponseType::Pointer resp = ResponseType::New(); // Coefficient 100 since Aster database is given in % reflectance resp->Load(spectraFilename, 100.0); @@ -613,7 +612,7 @@ int main(int argc, char* argv[]) LabelImageType::Pointer labelImage = labelReader->GetOutput(); - typedef otb::ImageUniqueValuesCalculator<LabelImageType> UniqueCalculatorType; + using UniqueCalculatorType = otb::ImageUniqueValuesCalculator<LabelImageType>; UniqueCalculatorType::Pointer uniqueCalculator = UniqueCalculatorType::New(); @@ -665,8 +664,8 @@ int main(int argc, char* argv[]) cmiReader->SetFileName(cmifname); cmiReader->UpdateOutputInformation(); - typedef itk::OrImageFilter<MaskImageType, MaskImageType, MaskImageType> OrType; - OrType::Pointer orfilter = OrType::New(); + using OrType = itk::OrImageFilter<MaskImageType, MaskImageType, MaskImageType>; + OrType::Pointer orfilter = OrType::New(); orfilter->SetInput1(miReader->GetOutput()); orfilter->SetInput2(cmiReader->GetOutput()); @@ -724,8 +723,8 @@ int main(int argc, char* argv[]) // Write output image to disk - typedef otb::ImageFileWriter<SimulatedImageType> WriterType; - WriterType::Pointer writer = WriterType::New(); + using WriterType = otb::ImageFileWriter<SimulatedImageType>; + WriterType::Pointer writer = WriterType::New(); writer->SetFileName(outfname); writer->SetInput(simulator->GetOutput()); diff --git a/Examples/Simulation/LAIFromNDVIImageTransform.cxx b/Examples/Simulation/LAIFromNDVIImageTransform.cxx index 133e5dd6444ddfd50625cc421e9642dc5558bd98..e2cb6cd5b4e3a34629a1f18fe35427326081f0e3 100644 --- a/Examples/Simulation/LAIFromNDVIImageTransform.cxx +++ b/Examples/Simulation/LAIFromNDVIImageTransform.cxx @@ -53,19 +53,19 @@ int main(int argc, char* argv[]) return EXIT_FAILURE; } - const unsigned int Dimension = 2; - typedef otb::VectorImage<double, Dimension> InputImageType; - typedef otb::Image<double, Dimension> OutputImageType; - typedef otb::Image<unsigned char, Dimension> ImageVisuType; - typedef otb::ImageFileReader<InputImageType> ReaderType; - typedef otb::ImageFileWriter<OutputImageType> WriterType; - typedef otb::ImageFileWriter<ImageVisuType> VisuWriterType; - typedef otb::ImageFileWriter<InputImageType> InWriterType; + const unsigned int Dimension = 2; + using InputImageType = otb::VectorImage<double, Dimension>; + using OutputImageType = otb::Image<double, Dimension>; + using ImageVisuType = otb::Image<unsigned char, Dimension>; + using ReaderType = otb::ImageFileReader<InputImageType>; + using WriterType = otb::ImageFileWriter<OutputImageType>; + using VisuWriterType = otb::ImageFileWriter<ImageVisuType>; + using InWriterType = otb::ImageFileWriter<InputImageType>; // Filter type is a generic \doxygen{itk}{UnaryFunctorImageFilter} using Formosat2 specific LAI // \doxygen{otb}{LAIFromNDVIFormosat2Functor}. - typedef otb::Functor::LAIFromNDVIFormosat2Functor<InputImageType::InternalPixelType, OutputImageType::PixelType> FunctorType; - typedef itk::UnaryFunctorImageFilter<InputImageType, OutputImageType, FunctorType> LAIFRomNDVIImageFilterType; + using FunctorType = otb::Functor::LAIFromNDVIFormosat2Functor<InputImageType::InternalPixelType, OutputImageType::PixelType>; + using LAIFRomNDVIImageFilterType = itk::UnaryFunctorImageFilter<InputImageType, OutputImageType, FunctorType>; // Instantiating object @@ -124,7 +124,7 @@ int main(int argc, char* argv[]) visuWriter->SetFileName(OutputName3); - typedef itk::RescaleIntensityImageFilter<OutputImageType, ImageVisuType> RescalerTypeOut; + using RescalerTypeOut = itk::RescaleIntensityImageFilter<OutputImageType, ImageVisuType>; RescalerTypeOut::Pointer rescaler = RescalerTypeOut::New(); rescaler->SetInput(filter->GetOutput()); diff --git a/Examples/Simulation/ProsailModel.cxx b/Examples/Simulation/ProsailModel.cxx index 42e06f71691e029c1f55ba3199b175c9f5cd04ee..ecae20f2d404a2d6b0809f6ff6fa1e5e66540cdf 100644 --- a/Examples/Simulation/ProsailModel.cxx +++ b/Examples/Simulation/ProsailModel.cxx @@ -50,7 +50,7 @@ int main(int argc, char* argv[]) char* OutputName = argv[15]; // We now define leaf parameters, which characterize vegetation composition. - typedef otb::LeafParameters LeafParametersType; + using LeafParametersType = otb::LeafParameters; // Next the parameters variable is created by invoking the \code{New()}~method and @@ -86,8 +86,8 @@ int main(int argc, char* argv[]) // Leaf parameters are used as prospect input - typedef otb::ProspectModel ProspectType; - ProspectType::Pointer prospect = ProspectType::New(); + using ProspectType = otb::ProspectModel; + ProspectType::Pointer prospect = ProspectType::New(); prospect->SetInput(leafParams); @@ -118,7 +118,7 @@ int main(int argc, char* argv[]) double TTO = static_cast<double>(atof(argv[13])); double PSI = static_cast<double>(atof(argv[14])); - typedef otb::SailModel SailType; + using SailType = otb::SailModel; SailType::Pointer sail = SailType::New(); @@ -151,12 +151,9 @@ int main(int argc, char* argv[]) for (unsigned int i = 0; i < sail->GetViewingReflectance()->Size(); ++i) { - otbLogMacro(Debug, << "wavelength : " - << sail->GetViewingReflectance()->GetResponse()[i].first - << ". Viewing reflectance " - << sail->GetViewingReflectance()->GetResponse()[i].second - << ". Hemispherical reflectance " - << sail->GetHemisphericalReflectance()->GetResponse()[i].second); + otbLogMacro(Debug, << "wavelength : " << sail->GetViewingReflectance()->GetResponse()[i].first << ". Viewing reflectance " + << sail->GetViewingReflectance()->GetResponse()[i].second << ". Hemispherical reflectance " + << sail->GetHemisphericalReflectance()->GetResponse()[i].second); } std::ofstream outputFile(OutputName, std::ios::out); diff --git a/Examples/Tutorials/FilteringPipeline.cxx b/Examples/Tutorials/FilteringPipeline.cxx index cfe2abc76e3855c4949176419546a407af98fb22..43158b4535f971f5ffc556966702af3a9bd1e547 100644 --- a/Examples/Tutorials/FilteringPipeline.cxx +++ b/Examples/Tutorials/FilteringPipeline.cxx @@ -47,13 +47,13 @@ int main(int argc, char* argv[]) // We declare the image type, the reader and the writer as // before: - typedef otb::Image<unsigned char, 2> ImageType; + using ImageType = otb::Image<unsigned char, 2>; - typedef otb::ImageFileReader<ImageType> ReaderType; - ReaderType::Pointer reader = ReaderType::New(); + using ReaderType = otb::ImageFileReader<ImageType>; + ReaderType::Pointer reader = ReaderType::New(); - typedef otb::ImageFileWriter<ImageType> WriterType; - WriterType::Pointer writer = WriterType::New(); + using WriterType = otb::ImageFileWriter<ImageType>; + WriterType::Pointer writer = WriterType::New(); reader->SetFileName(argv[1]); writer->SetFileName(argv[2]); @@ -63,8 +63,8 @@ int main(int argc, char* argv[]) // in OTB. Here we are using the same type for the input and the // output images: - typedef itk::GradientMagnitudeImageFilter<ImageType, ImageType> FilterType; - FilterType::Pointer filter = FilterType::New(); + using FilterType = itk::GradientMagnitudeImageFilter<ImageType, ImageType>; + FilterType::Pointer filter = FilterType::New(); // Let's plug the pipeline: diff --git a/Examples/Tutorials/HelloWorldOTB.cxx b/Examples/Tutorials/HelloWorldOTB.cxx index 1979df092d92c09fcb207ccdee262f63c90b7980..45a0887f000127caeefb48ca8b76eee9b30ebc91 100644 --- a/Examples/Tutorials/HelloWorldOTB.cxx +++ b/Examples/Tutorials/HelloWorldOTB.cxx @@ -28,7 +28,7 @@ int main(int itkNotUsed(argc), char* itkNotUsed(argv)[]) { - typedef otb::Image<unsigned short, 2> ImageType; + using ImageType = otb::Image<unsigned short, 2>; ImageType::Pointer image = ImageType::New(); diff --git a/Examples/Tutorials/Multispectral.cxx b/Examples/Tutorials/Multispectral.cxx index 3c5272d45feb4778b045d4c1c745da6280e47c02..47ee5173e72e95f03f6bde1943c87a07af546487 100644 --- a/Examples/Tutorials/Multispectral.cxx +++ b/Examples/Tutorials/Multispectral.cxx @@ -49,11 +49,11 @@ int main(int argc, char* argv[]) // reader. As we have done in the previous example we get the filename from // the command line. - typedef unsigned short int PixelType; - typedef otb::VectorImage<PixelType, 2> VectorImageType; + using PixelType = unsigned short; + using VectorImageType = otb::VectorImage<PixelType, 2>; - typedef otb::ImageFileReader<VectorImageType> ReaderType; - ReaderType::Pointer reader = ReaderType::New(); + using ReaderType = otb::ImageFileReader<VectorImageType>; + ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(argv[1]); @@ -61,8 +61,8 @@ int main(int argc, char* argv[]) // only one of the spectral band we use the // \doxygen{otb}{MultiToMonoChannelExtractROI}. The declaration is as usual: - typedef otb::MultiToMonoChannelExtractROI<PixelType, PixelType> ExtractChannelType; - ExtractChannelType::Pointer extractChannel = ExtractChannelType::New(); + using ExtractChannelType = otb::MultiToMonoChannelExtractROI<PixelType, PixelType>; + ExtractChannelType::Pointer extractChannel = ExtractChannelType::New(); // We need to pass the parameters to the filter for the extraction. This // filter also allow extracting only a spatial subset of the image. However, // we will extract the whole channel in this case. @@ -89,9 +89,9 @@ int main(int argc, char* argv[]) // \doxygen{otb}{MultiToMonoChannelExtractROI} is a \doxygen{otb}{Image}, we // need to template the writer with this type. - typedef otb::Image<PixelType, 2> ImageType; - typedef otb::ImageFileWriter<ImageType> WriterType; - WriterType::Pointer writer = WriterType::New(); + using ImageType = otb::Image<PixelType, 2>; + using WriterType = otb::ImageFileWriter<ImageType>; + WriterType::Pointer writer = WriterType::New(); writer->SetFileName(argv[2]); writer->SetInput(extractChannel->GetOutput()); @@ -122,8 +122,8 @@ int main(int argc, char* argv[]) // by declaring the filter on a normal \doxygen{otb}{Image}. Note that we // don't need to specify any input for this filter. - typedef itk::ShiftScaleImageFilter<ImageType, ImageType> ShiftScaleType; - ShiftScaleType::Pointer shiftScale = ShiftScaleType::New(); + using ShiftScaleType = itk::ShiftScaleImageFilter<ImageType, ImageType>; + ShiftScaleType::Pointer shiftScale = ShiftScaleType::New(); shiftScale->SetScale(0.5); shiftScale->SetShift(10); @@ -134,8 +134,8 @@ int main(int argc, char* argv[]) // The filter is selected using the \code{SetFilter()} method and the input // by the usual \code{SetInput()} method. - typedef otb::PerBandVectorImageFilter<VectorImageType, VectorImageType, ShiftScaleType> VectorFilterType; - VectorFilterType::Pointer vectorFilter = VectorFilterType::New(); + using VectorFilterType = otb::PerBandVectorImageFilter<VectorImageType, VectorImageType, ShiftScaleType>; + VectorFilterType::Pointer vectorFilter = VectorFilterType::New(); vectorFilter->SetFilter(shiftScale); vectorFilter->SetInput(reader->GetOutput()); @@ -143,8 +143,8 @@ int main(int argc, char* argv[]) // Now, we just have to save the image using a writer templated over an // \doxygen{otb}{VectorImage}: - typedef otb::ImageFileWriter<VectorImageType> VectorWriterType; - VectorWriterType::Pointer writerVector = VectorWriterType::New(); + using VectorWriterType = otb::ImageFileWriter<VectorImageType>; + VectorWriterType::Pointer writerVector = VectorWriterType::New(); writerVector->SetFileName(argv[3]); writerVector->SetInput(vectorFilter->GetOutput()); diff --git a/Examples/Tutorials/OrthoFusion.cxx b/Examples/Tutorials/OrthoFusion.cxx index c0ead29574f94efba0267646cbeea59af4162b45..2f40ce9f87dc18acb6081f96e5a431eca7a2bf57 100644 --- a/Examples/Tutorials/OrthoFusion.cxx +++ b/Examples/Tutorials/OrthoFusion.cxx @@ -65,13 +65,13 @@ int main(int argc, char* argv[]) // We declare the different images, readers and writer: - typedef otb::Image<unsigned int, 2> ImageType; - typedef otb::VectorImage<unsigned int, 2> VectorImageType; - typedef otb::Image<double, 2> DoubleImageType; - typedef otb::VectorImage<double, 2> DoubleVectorImageType; - typedef otb::ImageFileReader<ImageType> ReaderType; - typedef otb::ImageFileReader<VectorImageType> VectorReaderType; - typedef otb::ImageFileWriter<VectorImageType> WriterType; + using ImageType = otb::Image<unsigned int, 2>; + using VectorImageType = otb::VectorImage<unsigned int, 2>; + using DoubleImageType = otb::Image<double, 2>; + using DoubleVectorImageType = otb::VectorImage<double, 2>; + using ReaderType = otb::ImageFileReader<ImageType>; + using VectorReaderType = otb::ImageFileReader<VectorImageType>; + using WriterType = otb::ImageFileWriter<VectorImageType>; ReaderType::Pointer readerPAN = ReaderType::New(); VectorReaderType::Pointer readerXS = VectorReaderType::New(); @@ -88,9 +88,9 @@ int main(int argc, char* argv[]) // \item the hemisphere // \end{itemize} - std::string wkt = otb::SpatialReference::FromUTM(atoi(argv[4]),argv[5][0]=='N' ? - otb::SpatialReference::hemisphere::north : - otb::SpatialReference::hemisphere::south).ToWkt(); + std::string wkt = + otb::SpatialReference::FromUTM(atoi(argv[4]), argv[5][0] == 'N' ? otb::SpatialReference::hemisphere::north : otb::SpatialReference::hemisphere::south) + .ToWkt(); // We will need to pass several parameters to the orthorectification // concerning the desired output region: @@ -114,7 +114,7 @@ int main(int argc, char* argv[]) // We declare the orthorectification filter. And provide the different // parameters: - typedef otb::GenericRSResampleImageFilter<ImageType, DoubleImageType> OrthoRectifFilterType; + using OrthoRectifFilterType = otb::GenericRSResampleImageFilter<ImageType, DoubleImageType>; OrthoRectifFilterType::Pointer orthoRectifPAN = OrthoRectifFilterType::New(); orthoRectifPAN->SetOutputProjectionRef(wkt); @@ -129,7 +129,7 @@ int main(int argc, char* argv[]) // Now we are able to have the orthorectified area from the PAN image. We just // have to follow a similar process for the XS image. - typedef otb::GenericRSResampleImageFilter<VectorImageType, DoubleVectorImageType> VectorOrthoRectifFilterType; + using VectorOrthoRectifFilterType = otb::GenericRSResampleImageFilter<VectorImageType, DoubleVectorImageType>; VectorOrthoRectifFilterType::Pointer orthoRectifXS = VectorOrthoRectifFilterType::New(); @@ -145,8 +145,8 @@ int main(int argc, char* argv[]) // It's time to declare the fusion filter and set its inputs: - typedef otb::SimpleRcsPanSharpeningFusionImageFilter<DoubleImageType, DoubleVectorImageType, VectorImageType> FusionFilterType; - FusionFilterType::Pointer fusion = FusionFilterType::New(); + using FusionFilterType = otb::SimpleRcsPanSharpeningFusionImageFilter<DoubleImageType, DoubleVectorImageType, VectorImageType>; + FusionFilterType::Pointer fusion = FusionFilterType::New(); fusion->SetPanInput(orthoRectifPAN->GetOutput()); fusion->SetXsInput(orthoRectifXS->GetOutput()); diff --git a/Examples/Tutorials/Pipeline.cxx b/Examples/Tutorials/Pipeline.cxx index 1b92caec2f33c50bddf678f36e652e41c9395e05..02a06931ddff760305860bddf81c46bf6811bd28 100644 --- a/Examples/Tutorials/Pipeline.cxx +++ b/Examples/Tutorials/Pipeline.cxx @@ -42,19 +42,19 @@ int main(int argc, char* argv[]) // is declared as an unsigned char (one byte) and the image is specified as // having two dimensions. - typedef otb::Image<unsigned char, 2> ImageType; + using ImageType = otb::Image<unsigned char, 2>; // To read the image, we need an \doxygen{otb}{ImageFileReader} // which is templated with the image type. - typedef otb::ImageFileReader<ImageType> ReaderType; - ReaderType::Pointer reader = ReaderType::New(); + using ReaderType = otb::ImageFileReader<ImageType>; + ReaderType::Pointer reader = ReaderType::New(); // Then, we need an \doxygen{otb}{ImageFileWriter} // also templated with the image type. - typedef otb::ImageFileWriter<ImageType> WriterType; - WriterType::Pointer writer = WriterType::New(); + using WriterType = otb::ImageFileWriter<ImageType>; + WriterType::Pointer writer = WriterType::New(); // The filenames are passed as arguments to the program. We keep it // simple for now and we don't check their validity. diff --git a/Examples/Tutorials/ScalingPipeline.cxx b/Examples/Tutorials/ScalingPipeline.cxx index 25053b87b9bb745d0d9f9920b2df72c5635aac72..c7450105c5f7d79e8fe84b6e53930ad272e8d24f 100644 --- a/Examples/Tutorials/ScalingPipeline.cxx +++ b/Examples/Tutorials/ScalingPipeline.cxx @@ -49,11 +49,11 @@ int main(int argc, char* argv[]) // We need to declare two different image types, one for the internal // processing and one to output the results: - typedef double PixelType; - typedef otb::Image<PixelType, 2> ImageType; + using PixelType = double; + using ImageType = otb::Image<PixelType, 2>; - typedef unsigned char OutputPixelType; - typedef otb::Image<OutputPixelType, 2> OutputImageType; + using OutputPixelType = unsigned char; + using OutputImageType = otb::Image<OutputPixelType, 2>; // We declare the reader with the image template using the pixel type // double. It is worth noticing that this instantiation does not imply @@ -63,11 +63,11 @@ int main(int argc, char* argv[]) // The writer is templated with the unsigned char image to be able to save // the result on one byte images (like png for example). - typedef otb::ImageFileReader<ImageType> ReaderType; - ReaderType::Pointer reader = ReaderType::New(); + using ReaderType = otb::ImageFileReader<ImageType>; + ReaderType::Pointer reader = ReaderType::New(); - typedef otb::ImageFileWriter<OutputImageType> WriterType; - WriterType::Pointer writer = WriterType::New(); + using WriterType = otb::ImageFileWriter<OutputImageType>; + WriterType::Pointer writer = WriterType::New(); reader->SetFileName(argv[1]); writer->SetFileName(argv[2]); @@ -75,8 +75,8 @@ int main(int argc, char* argv[]) // Now we are declaring the edge detection filter which is going to work with // double input and output. - typedef itk::CannyEdgeDetectionImageFilter<ImageType, ImageType> FilterType; - FilterType::Pointer filter = FilterType::New(); + using FilterType = itk::CannyEdgeDetectionImageFilter<ImageType, ImageType>; + FilterType::Pointer filter = FilterType::New(); // Here comes the interesting part: we declare the // \doxygen{itk}{RescaleIntensityImageFilter}. The input @@ -91,8 +91,8 @@ int main(int argc, char* argv[]) // This filter will actually rescale all the pixels of // the image but also cast the type of these pixels. - typedef itk::RescaleIntensityImageFilter<ImageType, OutputImageType> RescalerType; - RescalerType::Pointer rescaler = RescalerType::New(); + using RescalerType = itk::RescaleIntensityImageFilter<ImageType, OutputImageType>; + RescalerType::Pointer rescaler = RescalerType::New(); rescaler->SetOutputMinimum(0); rescaler->SetOutputMaximum(255);