latest from "nitro" and "coda-oss"

externals/coda-oss/modules/c++/except/include/except/Exception.h

@@ -55,6 +55,8 @@
   struct _Name##Exception : public _Base \
   { \
       _Name##Exception() = default; virtual ~_Name##Exception() = default; \
+      _Name##Exception(const _Name##Exception&) = default;  _Name##Exception& operator=(const _Name##Exception&) = default; \
+      _Name##Exception(_Name##Exception&&) = default;  _Name##Exception& operator=(_Name##Exception&&) = default; \
       _Name##Exception(const except::Context& c) : _Base(c){} \
       _Name##Exception(const std::string& msg) : _Base(msg){} \
       _Name##Exception(const except::Throwable& t, const except::Context& c) : _Base(t, c){} \

externals/coda-oss/modules/c++/except/include/except/Throwable.h

@@ -109,7 +109,7 @@ class Throwable
      * Get the trace
      * \return The trace (const)
      */
-    const Trace& getTrace() const
+    const Trace& getTrace() const noexcept
     {
         return mTrace;
     }
@@ -118,7 +118,7 @@ class Throwable
      * Get the trace
      * \return The trace (non-const)
      */
-    Trace& getTrace()
+    Trace& getTrace() noexcept
     {
         return mTrace;
     }
@@ -143,7 +143,7 @@ class Throwable
         return s.str();
     }
 
-    const std::vector<std::string>& getBacktrace() const
+    const std::vector<std::string>& getBacktrace() const noexcept
     {
         return mBacktrace;
     }

externals/coda-oss/modules/c++/except/include/except/Trace.h

@@ -63,15 +63,15 @@ struct Trace final
     /*!
      * Pops Context off the stack
      */
-    void popContext()
+    void popContext() noexcept
     {
         mStack.pop_front();
     }
 
     /*!
      * Gets first Context on stack
      */
-    const Context& getContext() const
+    const Context& getContext() const noexcept
     {
         return mStack.front();
     }
@@ -80,7 +80,7 @@ struct Trace final
      * Get the stack
      * \return The stack (const)
      */
-    const std::list<Context>& getStack() const
+    const std::list<Context>& getStack() const noexcept
     {
         return mStack;
     }
@@ -89,7 +89,7 @@ struct Trace final
      * Get the stack
      * \return The stack (non-const)
      */
-    std::list<Context>& getStack()
+    std::list<Context>& getStack() noexcept
     {
         return mStack;
     }

externals/nitro/modules/c++/nitf/include/nitf/ImageReader.hpp

@@ -25,12 +25,13 @@
 #pragma once
 
 #include <assert.h>
+#include <stdio.h>
 
 #include <vector>
 #include <string>
-#include <memory>
 
 #include <std/span>
+#include <std/cstddef> // std::byte
 
 #include "nitf/coda-oss.hpp"
 #include "nitf/ImageReader.h"
@@ -49,7 +50,7 @@ namespace nitf
     class BufferList /*final*/   // no "final", SWIG doesn't like it
     {
         std::vector<T*> buffer;
-        std::vector<std::unique_ptr<T[]>> buffer_;
+        std::vector<std::vector<T>> buffer_;
 
     public:
         BufferList(size_t nBands)
@@ -61,8 +62,8 @@ namespace nitf
         {
             for (size_t i = 0; i < size(); i++)
             {
-                buffer_[i].reset(new T[subWindowSize]);
-                buffer[i] = buffer_[i].get();
+                buffer_[i].resize(subWindowSize);
+                buffer[i] = buffer_[i].data();
             }
         }
 
@@ -81,7 +82,24 @@ namespace nitf
         {
             return buffer[i];
         }
+
+        int padded = 0;
+
+        using iterator = typename std::vector<std::vector<T>>::iterator;
+        iterator begin() { return buffer_.begin(); }
+        iterator end() { return buffer_.end(); }
+
+        using const_iterator = typename std::vector<std::vector<T>>::const_iterator;
+        const_iterator begin() const { return buffer_.begin(); }
+        const_iterator end() const { return buffer_.end(); }
+        const_iterator cbegin() const { return buffer_.cbegin(); }
+        const_iterator cend() const { return buffer_.cend(); }
     };
+    template<typename T>
+    inline size_t write(FILE* f, const std::vector<T>& buffer)
+    {
+        return fwrite(buffer.data(), sizeof(T), buffer.size() / sizeof(T), f);
+    }
 
 /*!
  *  \class ImageReader
@@ -121,6 +139,7 @@ DECLARE_CLASS(ImageReader)
         void* user_ = user;
         read(subWindow, static_cast<uint8_t**>(user_), padded);
     }
+    BufferList<std::byte> read(const nitf::SubWindow& subWindow, size_t nbpp);
 
     /*!
      *  Read a block directly from file

externals/nitro/modules/c++/nitf/include/nitf/ImageSubheader.hpp

@@ -287,6 +287,10 @@ DECLARE_CLASS(ImageSubheader)
 
     //! Get the actualBitsPerPixel
     nitf::Field getActualBitsPerPixel() const;
+    size_t actualBitsPerPixel() const
+    {
+        return getActualBitsPerPixel();
+    }
 
     //! Get the pixelJustification
     nitf::Field getPixelJustification() const;

externals/nitro/modules/c++/nitf/include/nitf/SubWindow.hpp

@@ -25,6 +25,8 @@
 #include <string>
 #include <vector>
 
+#include <std/optional>
+
 #include "nitf/SubWindow.h"
 #include "nitf/DownSampler.hpp"
 #include "nitf/Object.hpp"
@@ -87,9 +89,9 @@ DECLARE_CLASS(SubWindow)
     void setStartCol(uint32_t value);
     void setNumCols(uint32_t value);
     void setBandList(uint32_t * value);
+    void setBandList(std::vector<uint32_t>&&);
     void setNumBands(uint32_t value);
 
-
     /*!
      * Reference a DownSampler within the SubWindow
      * The SubWindow does NOT own the DownSampler
@@ -103,13 +105,16 @@ DECLARE_CLASS(SubWindow)
 
     /*!
      * Return the DownSampler that is referenced by this SubWindow.
-     * If no DownSampler is referenced, a NITFException is thrown.
      */
     nitf::DownSampler* getDownSampler() noexcept;
+    const nitf::DownSampler* getDownSampler() const noexcept;
 
 private:
     nitf::DownSampler* mDownSampler = nullptr;
     nitf_Error error{};
+
+    void updateBandList();
+    std::optional<std::vector<uint32_t>> bandList;
 };
 
 #if CODA_OSS_cpp14

externals/nitro/modules/c++/nitf/source/ImageReader.cpp

@@ -22,6 +22,9 @@
 
 #include "nitf/ImageReader.hpp"
 
+#undef min
+#undef max
+
 using namespace nitf;
 
 ImageReader::ImageReader(const ImageReader & x)
@@ -76,6 +79,29 @@ void ImageReader::setReadCaching()
     nitf_ImageReader_setReadCaching(getNativeOrThrow());
 }
 
+BufferList<std::byte> ImageReader::read(const nitf::SubWindow& window, size_t nbpp)
+{
+    // see py_ImageReader_read() and doRead() in test_buffered_read.cpp
+
+    const auto numBitsPerPixel = nbpp;
+    const size_t numBytesPerPixel = NITF_NBPP_TO_BYTES(numBitsPerPixel);
+    const auto numBytesPerBand = static_cast<size_t>(window.getNumRows()) * static_cast<size_t>(window.getNumCols()) *  numBytesPerPixel;
+
+    auto downsampler = window.getDownSampler();
+    const uint32_t rowSkip = downsampler ? downsampler->getRowSkip() : 1;
+    const uint32_t colSkip = downsampler ? downsampler->getColSkip() : 1;
+
+    auto imageDeblocker = getNativeOrThrow()->imageDeblocker;
+    const auto subimageSize = static_cast<size_t>(window.getNumRows() / rowSkip) *
+        (window.getNumCols() / colSkip) * nitf_ImageIO_pixelSize(imageDeblocker);
+
+    BufferList<std::byte> retval(window.getNumBands());
+    retval.initialize(subimageSize);
+    read(window, retval.data(), &retval.padded);
+
+    return std::move(retval);
+}
+
 extern "C" {
     NITF_BOOL nitf_ImageIO_getMaskInfo(nitf_ImageIO* nitf,
         uint32_t* imageDataOffset, uint32_t* blockRecordLength,

externals/nitro/modules/c++/nitf/source/SubWindow.cpp

@@ -29,10 +29,25 @@ SubWindow::SubWindow(const SubWindow & x)
     *this = x;
 }
 
+void SubWindow::updateBandList()
+{
+    assert(bandList.has_value());
+    setBandList(bandList->data());
+    setNumBands(gsl::narrow<uint32_t>(bandList->size()));
+}
+
 SubWindow & SubWindow::operator=(const SubWindow & x)
 {
     if (&x != this)
+    {
         setNative(x.getNative());
+
+        bandList = x.bandList;
+        if (bandList.has_value())
+        {
+            updateBandList();
+        }
+    }
     return *this;
 }
 
@@ -109,6 +124,12 @@ void SubWindow::setBandList(uint32_t * value)
 {
     getNativeOrThrow()->bandList = value;
 }
+void SubWindow::setBandList(std::vector<uint32_t>&& value)
+{
+    bandList = std::move(value);
+    updateBandList();
+}
+
 
 uint32_t SubWindow::getNumBands() const
 {
@@ -143,3 +164,7 @@ nitf::DownSampler* SubWindow::getDownSampler() noexcept
 {
     return mDownSampler;
 }
+const nitf::DownSampler* SubWindow::getDownSampler() const noexcept
+{
+    return mDownSampler;
+}

externals/nitro/modules/c++/nitf/tests/test_extract.cpp

@@ -0,0 +1,117 @@
+/* =========================================================================
+ * This file is part of NITRO
+ * =========================================================================
+ *
+ * (C) Copyright 2004 - 2014, MDA Information Systems LLC
+ *
+ * NITRO is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this program; if not, If not,
+ * see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+// modeled after nitf_extract.py
+
+#include <stdio.h>
+
+#include <string>
+#include <vector>
+#include <numeric> // std::iota
+
+#include <import/str.h>
+#include <import/sys.h>
+
+#include <import/nitf.hpp>
+
+template<typename T>
+inline std::vector<T> iota(size_t count, T value)
+{
+    std::vector<T> retval(count);
+    std::iota(retval.begin(), retval.end(), value);
+    return retval;
+}
+
+static  std::vector<std::string> extract_image(const nitf::ImageSubheader& subheader, uint32_t index, nitf::ImageReader& imageReader,
+    const std::string& outDir="", const std::string& baseName="")
+{
+    nitf::SubWindow window;
+    window.setNumRows(subheader.numRows());
+    window.setNumCols(subheader.numCols());
+    window.setBandList(iota(subheader.getBandCount(), static_cast<uint32_t>(0))); // window.bandList = list(range(subheader.getBandCount()))
+    const auto nbpp = subheader.actualBitsPerPixel(); //const auto nbpp = subheader.numBitsPerPixel();
+    const auto bandData = imageReader.read(window, nbpp);
+
+    std::vector<std::string> outNames;
+    size_t band = 0;
+    for (const auto& data : bandData) // for band, data in enumerate(bandData):
+    {
+        auto outName = str::format("%s_%d__%d_x_%d_%d_band_%d.out",
+            baseName.c_str(), index, window.getNumRows(), window.getNumCols(), static_cast<int>(nbpp), static_cast<int>(band));
+        outName = sys::Path::joinPaths(outDir, outName);
+        auto f = fopen(outName.c_str(), "wb"); // f = open(outName, "wb");
+        nitf::write(f, data); // fwrite(data.data(), sizeof(data[0]), data.size() / sizeof(data[0]), f);
+        fclose(f); // f.close();
+        outNames.push_back(outName);
+        band++;
+    }
+
+    return outNames;
+}
+
+static void extract_images(const std::string& fileName, const std::string& outDir = "")
+{
+    nitf::IOHandle handle(fileName);
+    nitf::Reader reader;
+    nitf::Record record = reader.read(handle);
+
+    uint32_t i = 0;
+    for (nitf::ImageSegment segment : record.getImages())
+    {
+        auto imReader = reader.newImageReader(i);
+        extract_image(segment.getSubheader(), i, imReader, outDir, sys::Path::basename(fileName));
+
+        i++;
+    }
+
+    handle.close();
+}
+
+int main(int argc, char **argv)
+{
+    try
+    {
+        //  Check argv and make sure we are happy
+        if (argc != 3)
+        {
+            std::cout << "Usage: %s <input-file> <output-file> \n" << argv[0]
+                    << std::endl;
+            exit( EXIT_FAILURE);
+        }
+
+        // Check that wew have a valid NITF
+        if (nitf::Reader::getNITFVersion(argv[1]) == nitf::Version::NITF_VER_UNKNOWN)
+        {
+            std::cout << "Invalid NITF: " << argv[1] << std::endl;
+            exit( EXIT_FAILURE);
+        }
+
+        extract_images(argv[1]);
+        return 0;
+    }
+    catch (const std::exception& ex)
+    {
+        std::cerr << "ERROR!: " << ex.what() << "\n";
+        return 1;
+    }
+}
+