Trade: support 1D and 3D images in AbstractImageConverter.

I wanted just 3D at first, but then thought why not do 1D as well. Lots
of dry copypasted code, nothing interesting to see here.

doc/changelog.dox

@@ -179,6 +179,7 @@ See also:
 -   New @ref Trade::SkinData class and @ref Trade::AbstractImporter::skin2D() /
     @ref Trade::AbstractImporter::skin3D() family of APIs for skin import, as
     well as support in @ref Trade::AnySceneImporter "AnySceneImporter"
+-   1D and 3D image support in @ref Trade::AbstractImageConverter
 -   @ref Trade::LightData got extended to support light attenuation and range
     parameters as well and spot light inner and outer angle
 -   @ref Trade::AbstractImporter, @ref Trade::AbstractImageConverter and

src/Magnum/Trade/AbstractImageConverter.cpp

@@ -95,6 +95,19 @@ void AbstractImageConverter::clearFlags(ImageConverterFlags flags) {
     setFlags(_flags & ~flags);
 }
 
+Containers::Optional<ImageData1D> AbstractImageConverter::convert(const ImageView1D& image) {
+    CORRADE_ASSERT(features() & ImageConverterFeature::Convert1D,
+        "Trade::AbstractImageConverter::convert(): 1D image conversion not supported", {});
+
+    Containers::Optional<ImageData1D> out = doConvert(image);
+    CORRADE_ASSERT(!out || !out->_data.deleter(), "Trade::AbstractImageConverter::convert(): implementation is not allowed to use a custom Array deleter", {});
+    return out;
+}
+
+Containers::Optional<ImageData1D> AbstractImageConverter::doConvert(const ImageView1D&) {
+    CORRADE_ASSERT_UNREACHABLE("Trade::AbstractImageConverter::convert(): 1D image conversion advertised but not implemented", {});
+}
+
 Containers::Optional<ImageData2D> AbstractImageConverter::convert(const ImageView2D& image) {
     CORRADE_ASSERT(features() & ImageConverterFeature::Convert2D,
         "Trade::AbstractImageConverter::convert(): 2D image conversion not supported", {});
@@ -140,6 +153,32 @@ Containers::Optional<CompressedImage2D> AbstractImageConverter::exportToCompress
 }
 #endif
 
+Containers::Optional<ImageData3D> AbstractImageConverter::convert(const ImageView3D& image) {
+    CORRADE_ASSERT(features() & ImageConverterFeature::Convert3D,
+        "Trade::AbstractImageConverter::convert(): 3D image conversion not supported", {});
+
+    Containers::Optional<ImageData3D> out = doConvert(image);
+    CORRADE_ASSERT(!out || !out->_data.deleter(), "Trade::AbstractImageConverter::convert(): implementation is not allowed to use a custom Array deleter", {});
+    return out;
+}
+
+Containers::Optional<ImageData3D> AbstractImageConverter::doConvert(const ImageView3D&) {
+    CORRADE_ASSERT_UNREACHABLE("Trade::AbstractImageConverter::convert(): 3D image conversion advertised but not implemented", {});
+}
+
+Containers::Optional<ImageData1D> AbstractImageConverter::convert(const CompressedImageView1D& image) {
+    CORRADE_ASSERT(features() & ImageConverterFeature::ConvertCompressed1D,
+        "Trade::AbstractImageConverter::convert(): compressed 1D image conversion not supported", {});
+
+    Containers::Optional<ImageData1D> out = doConvert(image);
+    CORRADE_ASSERT(!out || !out->_data.deleter(), "Trade::AbstractImageConverter::convert(): implementation is not allowed to use a custom Array deleter", {});
+    return out;
+}
+
+Containers::Optional<ImageData1D> AbstractImageConverter::doConvert(const CompressedImageView1D&) {
+    CORRADE_ASSERT_UNREACHABLE("Trade::AbstractImageConverter::convert(): compressed 1D image conversion advertised but not implemented", {});
+}
+
 Containers::Optional<ImageData2D> AbstractImageConverter::convert(const CompressedImageView2D& image) {
     CORRADE_ASSERT(features() & ImageConverterFeature::ConvertCompressed2D,
         "Trade::AbstractImageConverter::convert(): compressed 2D image conversion not supported", {});
@@ -153,10 +192,44 @@ Containers::Optional<ImageData2D> AbstractImageConverter::doConvert(const Compre
     CORRADE_ASSERT_UNREACHABLE("Trade::AbstractImageConverter::convert(): compressed 2D image conversion advertised but not implemented", {});
 }
 
+Containers::Optional<ImageData3D> AbstractImageConverter::convert(const CompressedImageView3D& image) {
+    CORRADE_ASSERT(features() & ImageConverterFeature::ConvertCompressed3D,
+        "Trade::AbstractImageConverter::convert(): compressed 3D image conversion not supported", {});
+
+    Containers::Optional<ImageData3D> out = doConvert(image);
+    CORRADE_ASSERT(!out || !out->_data.deleter(), "Trade::AbstractImageConverter::convert(): implementation is not allowed to use a custom Array deleter", {});
+    return out;
+}
+
+Containers::Optional<ImageData3D> AbstractImageConverter::doConvert(const CompressedImageView3D&) {
+    CORRADE_ASSERT_UNREACHABLE("Trade::AbstractImageConverter::convert(): compressed 3D image conversion advertised but not implemented", {});
+}
+
+Containers::Optional<ImageData1D> AbstractImageConverter::convert(const ImageData1D& image) {
+    return image.isCompressed() ? convert(CompressedImageView1D(image)) : convert(ImageView1D(image));
+}
+
 Containers::Optional<ImageData2D> AbstractImageConverter::convert(const ImageData2D& image) {
     return image.isCompressed() ? convert(CompressedImageView2D(image)) : convert(ImageView2D(image));
 }
 
+Containers::Optional<ImageData3D> AbstractImageConverter::convert(const ImageData3D& image) {
+    return image.isCompressed() ? convert(CompressedImageView3D(image)) : convert(ImageView3D(image));
+}
+
+Containers::Array<char> AbstractImageConverter::convertToData(const ImageView1D& image) {
+    CORRADE_ASSERT(features() >= ImageConverterFeature::Convert1DToData,
+        "Trade::AbstractImageConverter::convertToData(): 1D image conversion not supported", nullptr);
+
+    Containers::Array<char> out = doConvertToData(image);
+    CORRADE_ASSERT(!out.deleter(), "Trade::AbstractImageConverter::convertToData(): implementation is not allowed to use a custom Array deleter", {});
+    return out;
+}
+
+Containers::Array<char> AbstractImageConverter::doConvertToData(const ImageView1D&) {
+    CORRADE_ASSERT_UNREACHABLE("Trade::AbstractImageConverter::convertToData(): 1D image conversion advertised but not implemented", nullptr);
+}
+
 Containers::Array<char> AbstractImageConverter::convertToData(const ImageView2D& image) {
     CORRADE_ASSERT(features() >= ImageConverterFeature::Convert2DToData,
         "Trade::AbstractImageConverter::convertToData(): 2D image conversion not supported", nullptr);
@@ -176,6 +249,32 @@ Containers::Array<char> AbstractImageConverter::exportToData(const ImageView2D&
 }
 #endif
 
+Containers::Array<char> AbstractImageConverter::convertToData(const ImageView3D& image) {
+    CORRADE_ASSERT(features() >= ImageConverterFeature::Convert3DToData,
+        "Trade::AbstractImageConverter::convertToData(): 3D image conversion not supported", nullptr);
+
+    Containers::Array<char> out = doConvertToData(image);
+    CORRADE_ASSERT(!out.deleter(), "Trade::AbstractImageConverter::convertToData(): implementation is not allowed to use a custom Array deleter", {});
+    return out;
+}
+
+Containers::Array<char> AbstractImageConverter::doConvertToData(const ImageView3D&) {
+    CORRADE_ASSERT_UNREACHABLE("Trade::AbstractImageConverter::convertToData(): 3D image conversion advertised but not implemented", nullptr);
+}
+
+Containers::Array<char> AbstractImageConverter::convertToData(const CompressedImageView1D& image) {
+    CORRADE_ASSERT(features() >= ImageConverterFeature::ConvertCompressed1DToData,
+        "Trade::AbstractImageConverter::convertToData(): compressed 1D image conversion not supported", nullptr);
+
+    Containers::Array<char> out = doConvertToData(image);
+    CORRADE_ASSERT(!out.deleter(), "Trade::AbstractImageConverter::convertToData(): implementation is not allowed to use a custom Array deleter", {});
+    return out;
+}
+
+Containers::Array<char> AbstractImageConverter::doConvertToData(const CompressedImageView1D&) {
+    CORRADE_ASSERT_UNREACHABLE("Trade::AbstractImageConverter::convertToData(): compressed 1D image conversion advertised but not implemented", nullptr);
+}
+
 Containers::Array<char> AbstractImageConverter::convertToData(const CompressedImageView2D& image) {
     CORRADE_ASSERT(features() >= ImageConverterFeature::ConvertCompressed2DToData,
         "Trade::AbstractImageConverter::convertToData(): compressed 2D image conversion not supported", nullptr);
@@ -195,6 +294,23 @@ Containers::Array<char> AbstractImageConverter::exportToData(const CompressedIma
 }
 #endif
 
+Containers::Array<char> AbstractImageConverter::convertToData(const CompressedImageView3D& image) {
+    CORRADE_ASSERT(features() >= ImageConverterFeature::ConvertCompressed3DToData,
+        "Trade::AbstractImageConverter::convertToData(): compressed 3D image conversion not supported", nullptr);
+
+    Containers::Array<char> out = doConvertToData(image);
+    CORRADE_ASSERT(!out.deleter(), "Trade::AbstractImageConverter::convertToData(): implementation is not allowed to use a custom Array deleter", {});
+    return out;
+}
+
+Containers::Array<char> AbstractImageConverter::doConvertToData(const CompressedImageView3D&) {
+    CORRADE_ASSERT_UNREACHABLE("Trade::AbstractImageConverter::convertToData(): compressed 3D image conversion advertised but not implemented", nullptr);
+}
+
+Containers::Array<char> AbstractImageConverter::convertToData(const ImageData1D& image) {
+    return image.isCompressed() ? convertToData(CompressedImageView1D(image)) : convertToData(ImageView1D(image));
+}
+
 Containers::Array<char> AbstractImageConverter::convertToData(const ImageData2D& image) {
     return image.isCompressed() ? convertToData(CompressedImageView2D(image)) : convertToData(ImageView2D(image));
 }
@@ -205,6 +321,32 @@ Containers::Array<char> AbstractImageConverter::exportToData(const ImageData2D&
 }
 #endif
 
+Containers::Array<char> AbstractImageConverter::convertToData(const ImageData3D& image) {
+    return image.isCompressed() ? convertToData(CompressedImageView3D(image)) : convertToData(ImageView3D(image));
+}
+
+bool AbstractImageConverter::convertToFile(const ImageView1D& image, const Containers::StringView filename) {
+    CORRADE_ASSERT(features() & ImageConverterFeature::Convert1DToFile,
+        "Trade::AbstractImageConverter::convertToFile(): 1D image conversion not supported", {});
+
+    return doConvertToFile(image, filename);
+}
+
+bool AbstractImageConverter::doConvertToFile(const ImageView1D& image, const Containers::StringView filename) {
+    CORRADE_ASSERT(features() >= ImageConverterFeature::Convert1DToData, "Trade::AbstractImageConverter::convertToFile(): 1D image conversion advertised but not implemented", false);
+
+    const auto data = doConvertToData(image);
+    /* No deleter checks as it doesn't matter here */
+    if(!data) return false;
+
+    if(!Utility::Directory::write(filename, data)) {
+        Error() << "Trade::AbstractImageConverter::convertToFile(): cannot write to file" << filename;
+        return false;
+    }
+
+    return true;
+}
+
 bool AbstractImageConverter::convertToFile(const ImageView2D& image, const Containers::StringView filename) {
     CORRADE_ASSERT(features() & ImageConverterFeature::Convert2DToFile,
         "Trade::AbstractImageConverter::convertToFile(): 2D image conversion not supported", {});
@@ -233,6 +375,50 @@ bool AbstractImageConverter::exportToFile(const ImageView2D& image, const std::s
 }
 #endif
 
+bool AbstractImageConverter::convertToFile(const ImageView3D& image, const Containers::StringView filename) {
+    CORRADE_ASSERT(features() & ImageConverterFeature::Convert3DToFile,
+        "Trade::AbstractImageConverter::convertToFile(): 3D image conversion not supported", {});
+
+    return doConvertToFile(image, filename);
+}
+
+bool AbstractImageConverter::doConvertToFile(const ImageView3D& image, const Containers::StringView filename) {
+    CORRADE_ASSERT(features() >= ImageConverterFeature::Convert3DToData, "Trade::AbstractImageConverter::convertToFile(): 3D image conversion advertised but not implemented", false);
+
+    const auto data = doConvertToData(image);
+    /* No deleter checks as it doesn't matter here */
+    if(!data) return false;
+
+    if(!Utility::Directory::write(filename, data)) {
+        Error() << "Trade::AbstractImageConverter::convertToFile(): cannot write to file" << filename;
+        return false;
+    }
+
+    return true;
+}
+
+bool AbstractImageConverter::convertToFile(const CompressedImageView1D& image, const Containers::StringView filename) {
+    CORRADE_ASSERT(features() & ImageConverterFeature::ConvertCompressed1DToFile,
+        "Trade::AbstractImageConverter::convertToFile(): compressed 1D image conversion not supported", {});
+
+    return doConvertToFile(image, filename);
+}
+
+bool AbstractImageConverter::doConvertToFile(const CompressedImageView1D& image, Containers::StringView filename) {
+    CORRADE_ASSERT(features() >= ImageConverterFeature::ConvertCompressed1DToData, "Trade::AbstractImageConverter::convertToFile(): compressed 1D image conversion advertised but not implemented", false);
+
+    const auto data = doConvertToData(image);
+    /* No deleter checks as it doesn't matter here */
+    if(!data) return false;
+
+    if(!Utility::Directory::write(filename, data)) {
+        Error() << "Trade::AbstractImageConverter::convertToFile(): cannot write to file" << filename;
+        return false;
+    }
+
+    return true;
+}
+
 bool AbstractImageConverter::convertToFile(const CompressedImageView2D& image, const Containers::StringView filename) {
     CORRADE_ASSERT(features() & ImageConverterFeature::ConvertCompressed2DToFile,
         "Trade::AbstractImageConverter::convertToFile(): compressed 2D image conversion not supported", {});
@@ -261,6 +447,32 @@ bool AbstractImageConverter::exportToFile(const CompressedImageView2D& image, co
 }
 #endif
 
+bool AbstractImageConverter::convertToFile(const CompressedImageView3D& image, const Containers::StringView filename) {
+    CORRADE_ASSERT(features() & ImageConverterFeature::ConvertCompressed3DToFile,
+        "Trade::AbstractImageConverter::convertToFile(): compressed 3D image conversion not supported", {});
+
+    return doConvertToFile(image, filename);
+}
+
+bool AbstractImageConverter::doConvertToFile(const CompressedImageView3D& image, Containers::StringView filename) {
+    CORRADE_ASSERT(features() >= ImageConverterFeature::ConvertCompressed3DToData, "Trade::AbstractImageConverter::convertToFile(): compressed 3D image conversion advertised but not implemented", false);
+
+    const auto data = doConvertToData(image);
+    /* No deleter checks as it doesn't matter here */
+    if(!data) return false;
+
+    if(!Utility::Directory::write(filename, data)) {
+        Error() << "Trade::AbstractImageConverter::convertToFile(): cannot write to file" << filename;
+        return false;
+    }
+
+    return true;
+}
+
+bool AbstractImageConverter::convertToFile(const ImageData1D& image, const Containers::StringView filename) {
+    return image.isCompressed() ? convertToFile(CompressedImageView1D(image), filename) : convertToFile(ImageView1D(image), filename);
+}
+
 bool AbstractImageConverter::convertToFile(const ImageData2D& image, const Containers::StringView filename) {
     return image.isCompressed() ? convertToFile(CompressedImageView2D(image), filename) : convertToFile(ImageView2D(image), filename);
 }
@@ -271,18 +483,34 @@ bool AbstractImageConverter::exportToFile(const ImageData2D& image, const std::s
 }
 #endif
 
+bool AbstractImageConverter::convertToFile(const ImageData3D& image, const Containers::StringView filename) {
+    return image.isCompressed() ? convertToFile(CompressedImageView3D(image), filename) : convertToFile(ImageView3D(image), filename);
+}
+
 Debug& operator<<(Debug& debug, const ImageConverterFeature value) {
     debug << "Trade::ImageConverterFeature" << Debug::nospace;
 
     switch(value) {
         /* LCOV_EXCL_START */
         #define _c(v) case ImageConverterFeature::v: return debug << "::" #v;
+        _c(Convert1D)
         _c(Convert2D)
+        _c(Convert3D)
+        _c(ConvertCompressed1D)
         _c(ConvertCompressed2D)
+        _c(ConvertCompressed3D)
+        _c(Convert1DToFile)
         _c(Convert2DToFile)
+        _c(Convert3DToFile)
+        _c(ConvertCompressed1DToFile)
         _c(ConvertCompressed2DToFile)
+        _c(ConvertCompressed3DToFile)
+        _c(Convert1DToData)
         _c(Convert2DToData)
+        _c(Convert3DToData)
+        _c(ConvertCompressed1DToData)
         _c(ConvertCompressed2DToData)
+        _c(ConvertCompressed3DToData)
         #undef _c
         /* LCOV_EXCL_STOP */
     }
@@ -292,13 +520,25 @@ Debug& operator<<(Debug& debug, const ImageConverterFeature value) {
 
 Debug& operator<<(Debug& debug, const ImageConverterFeatures value) {
     return Containers::enumSetDebugOutput(debug, value, "Trade::ImageConverterFeatures{}", {
+        ImageConverterFeature::Convert1D,
         ImageConverterFeature::Convert2D,
+        ImageConverterFeature::Convert3D,
+        ImageConverterFeature::ConvertCompressed1D,
         ImageConverterFeature::ConvertCompressed2D,
+        ImageConverterFeature::ConvertCompressed3D,
+        ImageConverterFeature::Convert1DToData,
         ImageConverterFeature::Convert2DToData,
+        ImageConverterFeature::Convert3DToData,
+        ImageConverterFeature::ConvertCompressed1DToData,
         ImageConverterFeature::ConvertCompressed2DToData,
+        ImageConverterFeature::ConvertCompressed3DToData,
         /* These are implied by Convert[Compressed]ToData, so have to be last */
+        ImageConverterFeature::Convert1DToFile,
         ImageConverterFeature::Convert2DToFile,
-        ImageConverterFeature::ConvertCompressed2DToFile});
+        ImageConverterFeature::Convert3DToFile,
+        ImageConverterFeature::ConvertCompressed1DToFile,
+        ImageConverterFeature::ConvertCompressed2DToFile,
+        ImageConverterFeature::ConvertCompressed3DToFile});
 }
 
 Debug& operator<<(Debug& debug, const ImageConverterFlag value) {

src/Magnum/Trade/AbstractImageConverter.h

@@ -44,12 +44,19 @@ namespace Magnum { namespace Trade {
 @see @ref ImageConverterFeatures, @ref AbstractImageConverter::features()
 */
 enum class ImageConverterFeature: UnsignedInt {
+    /**
+     * Convert a 1D image with
+     * @ref AbstractImageConverter::convert(const ImageView1D&)
+     * @m_since_latest
+     */
+    Convert1D = 1 << 0,
+
     /**
      * Convert a 2D image with
      * @ref AbstractImageConverter::convert(const ImageView2D&)
      * @m_since_latest
      */
-    Convert2D = 1 << 0,
+    Convert2D = 1 << 1,
 
     #ifdef MAGNUM_BUILD_DEPRECATED
     /**
@@ -71,19 +78,47 @@ enum class ImageConverterFeature: UnsignedInt {
     ConvertCompressedImage CORRADE_DEPRECATED_ENUM("use ImageConverterFeature::Convert2D instead") = Convert2D,
     #endif
 
+    /**
+     * Convert a 3D image with
+     * @ref AbstractImageConverter::convert(const ImageView3D&)
+     * @m_since_latest
+     */
+    Convert3D = 1 << 3,
+
+    /**
+     * Convert a compressed 1D image with
+     * @ref AbstractImageConverter::convert(const CompressedImageView1D&)
+     * @m_since_latest
+     */
+    ConvertCompressed1D = 1 << 4,
+
     /**
      * Convert a compressed 2D image with
      * @ref AbstractImageConverter::convert(const CompressedImageView2D&)
      * @m_since_latest
      */
-    ConvertCompressed2D = 1 << 1,
+    ConvertCompressed2D = 1 << 5,
+
+    /**
+     * Convert a compressed 3D image with
+     * @ref AbstractImageConverter::convert(const CompressedImageView3D&)
+     * @m_since_latest
+     */
+    ConvertCompressed3D = 1 << 6,
+
+    /**
+     * Convert a 1D image to a file with
+     * @ref AbstractImageConverter::convertToFile(const ImageView1D&, Containers::StringView)
+     * @m_since_latest
+     */
+    Convert1DToFile = 1 << 7,
 
     /**
      * Convert a 2D image to a file with
      * @ref AbstractImageConverter::convertToFile(const ImageView2D&, Containers::StringView)
      * @m_since_latest
      */
-    Convert2DToFile = 1 << 2,
+    Convert2DToFile = 1 << 8,
 
     #ifdef MAGNUM_BUILD_DEPRECATED
     /**
@@ -94,12 +129,26 @@ enum class ImageConverterFeature: UnsignedInt {
     ConvertFile CORRADE_DEPRECATED_ENUM("use ImageConverterFeature::Convert2DToFile instead") = Convert2DToFile,
     #endif
 
+    /**
+     * Convert a 3D image to a file with
+     * @ref AbstractImageConverter::convertToFile(const ImageView3D&, Containers::StringView)
+     * @m_since_latest
+     */
+    Convert3DToFile = 1 << 9,
+
+    /**
+     * Convert a compressed 1D image to a file with
+     * @ref AbstractImageConverter::convertToFile(const CompressedImageView1D&, Containers::StringView)
+     * @m_since_latest
+     */
+    ConvertCompressed1DToFile = 1 << 10,
+
     /**
      * Convert a compressed 2D image to a file with
      * @ref AbstractImageConverter::convertToFile(const CompressedImageView2D&, Containers::StringView)
      * @m_since_latest
      */
-    ConvertCompressed2DToFile = 1 << 3,
+    ConvertCompressed2DToFile = 1 << 11,
 
     #ifdef MAGNUM_BUILD_DEPRECATED
     /**
@@ -110,13 +159,28 @@ enum class ImageConverterFeature: UnsignedInt {
     ConvertCompressedFile CORRADE_DEPRECATED_ENUM("use ImageConverterFeature::ConvertCompressed2DToFile instead") = ConvertCompressed2DToFile,
     #endif
 
+    /**
+     * Convert a compressed 3D image to a file with
+     * @ref AbstractImageConverter::convertToFile(const CompressedImageView3D&, Containers::StringView)
+     * @m_since_latest
+     */
+    ConvertCompressed3DToFile = 1 << 12,
+
+    /**
+     * Convert a 1D image to raw data with
+     * @ref AbstractImageConverter::convertToData(const ImageView1D&).
+     * Implies @ref ImageConverterFeature::Convert1DToFile.
+     * @m_since_latest
+     */
+    Convert1DToData = Convert1DToFile|(1 << 13),
+
     /**
      * Convert a 2D image to raw data with
      * @ref AbstractImageConverter::convertToData(const ImageView2D&).
      * Implies @ref ImageConverterFeature::Convert2DToFile.
      * @m_since_latest
      */
-    Convert2DToData = Convert2DToFile|(1 << 4),
+    Convert2DToData = Convert2DToFile|(1 << 13),
 
     #ifdef MAGNUM_BUILD_DEPRECATED
     /**
@@ -127,13 +191,29 @@ enum class ImageConverterFeature: UnsignedInt {
     ConvertData CORRADE_DEPRECATED_ENUM("use ImageConverterFeature::Convert2DToData instead") = Convert2DToData,
     #endif
 
+    /**
+     * Convert a 3D image to raw data with
+     * @ref AbstractImageConverter::convertToData(const ImageView3D&).
+     * Implies @ref ImageConverterFeature::Convert3DToFile.
+     * @m_since_latest
+     */
+    Convert3DToData = Convert3DToFile|(1 << 13),
+
+    /**
+     * Convert a compressed 1D image to raw data with
+     * @ref AbstractImageConverter::convertToData(const CompressedImageView1D&).
+     * Implies @ref ImageConverterFeature::ConvertCompressed1DToFile.
+     * @m_since_latest
+     */
+    ConvertCompressed1DToData = ConvertCompressed1DToFile|(1 << 13),
+
     /**
      * Convert a compressed 2D image to raw data with
      * @ref AbstractImageConverter::convertToData(const CompressedImageView2D&).
      * Implies @ref ImageConverterFeature::ConvertCompressed2DToFile.
      * @m_since_latest
      */
-    ConvertCompressed2DToData = ConvertCompressed2DToFile|(1 << 4),
+    ConvertCompressed2DToData = ConvertCompressed2DToFile|(1 << 13),
 
     #ifdef MAGNUM_BUILD_DEPRECATED
     /**
@@ -143,6 +223,14 @@ enum class ImageConverterFeature: UnsignedInt {
      */
     ConvertCompressedData CORRADE_DEPRECATED_ENUM("use ImageConverterFeature::ConvertCompressed2DToData instead") = ConvertCompressed2DToData,
     #endif
+
+    /**
+     * Convert a compressed 3D image to raw data with
+     * @ref AbstractImageConverter::convertToData(const CompressedImageView3D&).
+     * Implies @ref ImageConverterFeature::ConvertCompressed3DToFile.
+     * @m_since_latest
+     */
+    ConvertCompressed3DToData = ConvertCompressed3DToFile|(1 << 13)
 };
 
 /**
@@ -353,6 +441,21 @@ class MAGNUM_TRADE_EXPORT AbstractImageConverter: public PluginManager::Abstract
          */
         void clearFlags(ImageConverterFlags flags);
 
+        /**
+         * @brief Convert a 1D image
+         * @m_since_latest
+         *
+         * Available only if @ref ImageConverterFeature::Convert1D is
+         * supported. Returns converted image on success,
+         * @ref Containers::NullOpt otherwise. The implementation is allowed to
+         * return both a compressed an an uncompressed image, see documentation
+         * of a particular converter for more information.
+         * @see @ref features(), @ref convert(const CompressedImageView1D&),
+         *      @ref convert(const ImageData1D&), @ref convertToData(),
+         *      @ref convertToFile(), @ref ImageData::isCompressed()
+         */
+        Containers::Optional<ImageData1D> convert(const ImageView1D& image);
+
         /**
          * @brief Convert a 2D image
          * @m_since_latest
@@ -384,6 +487,36 @@ class MAGNUM_TRADE_EXPORT AbstractImageConverter: public PluginManager::Abstract
         CORRADE_DEPRECATED("use convert(const ImageView2D&) instead") Containers::Optional<CompressedImage2D> exportToCompressedImage(const ImageView2D& image);
         #endif
 
+        /**
+         * @brief Convert a 3D image
+         * @m_since_latest
+         *
+         * Available only if @ref ImageConverterFeature::Convert3D is
+         * supported. Returns converted image on success,
+         * @ref Containers::NullOpt otherwise. The implementation is allowed to
+         * return both a compressed an an uncompressed image, see documentation
+         * of a particular converter for more information.
+         * @see @ref features(), @ref convert(const CompressedImageView3D&),
+         *      @ref convert(const ImageData3D&), @ref convertToData(),
+         *      @ref convertToFile(), @ref ImageData::isCompressed()
+         */
+        Containers::Optional<ImageData3D> convert(const ImageView3D& image);
+
+        /**
+         * @brief Convert a compressed 1D image
+         * @m_since_latest
+         *
+         * Available only if @ref ImageConverterFeature::ConvertCompressed1D is
+         * supported. Returns converted image on success,
+         * @ref Containers::NullOpt otherwise. The implementation is allowed to
+         * return both a compressed an an uncompressed image, see documentation
+         * of a particular converter for more information.
+         * @see @ref features(), @ref convert(const ImageView1D&),
+         *      @ref convert(const ImageData1D&), @ref convertToData(),
+         *      @ref convertToFile(), @ref ImageData::isCompressed()
+         */
+        Containers::Optional<ImageData1D> convert(const CompressedImageView1D& image);
+
         /**
          * @brief Convert a compressed 2D image
          * @m_since_latest
@@ -399,6 +532,33 @@ class MAGNUM_TRADE_EXPORT AbstractImageConverter: public PluginManager::Abstract
          */
         Containers::Optional<ImageData2D> convert(const CompressedImageView2D& image);
 
+        /**
+         * @brief Convert a compressed 3D image
+         * @m_since_latest
+         *
+         * Available only if @ref ImageConverterFeature::ConvertCompressed3D is
+         * supported. Returns converted image on success,
+         * @ref Containers::NullOpt otherwise. The implementation is allowed to
+         * return both a compressed an an uncompressed image, see documentation
+         * of a particular converter for more information.
+         * @see @ref features(), @ref convert(const ImageView3D&),
+         *      @ref convert(const ImageData3D&), @ref convertToData(),
+         *      @ref convertToFile(), @ref ImageData::isCompressed()
+         */
+        Containers::Optional<ImageData3D> convert(const CompressedImageView3D& image);
+
+        /**
+         * @brief Convert a 1D image data
+         * @m_since_latest
+         *
+         * Based on whether the image is compressed or not, calls either
+         * @ref convert(const ImageView1D&) or
+         * @ref convert(const CompressedImageView1D&). See documentation of
+         * these two functions for details.
+         * @see @ref ImageData::isCompressed()
+         */
+        Containers::Optional<ImageData1D> convert(const ImageData1D& image);
+
         /**
          * @brief Convert a 2D image data
          * @m_since_latest
@@ -411,6 +571,30 @@ class MAGNUM_TRADE_EXPORT AbstractImageConverter: public PluginManager::Abstract
          */
         Containers::Optional<ImageData2D> convert(const ImageData2D& image);
 
+        /**
+         * @brief Convert a 3D image data
+         * @m_since_latest
+         *
+         * Based on whether the image is compressed or not, calls either
+         * @ref convert(const ImageView3D&) or
+         * @ref convert(const CompressedImageView3D&). See documentation of
+         * these two functions for details.
+         * @see @ref ImageData::isCompressed()
+         */
+        Containers::Optional<ImageData3D> convert(const ImageData3D& image);
+
+        /**
+         * @brief Convert a 1D image to a raw data
+         * @m_since_latest
+         *
+         * Available only if @ref ImageConverterFeature::Convert1DToData is
+         * supported. Returns data on success, @cpp nullptr @ce otherwise.
+         * @see @ref features(), @ref convertToData(const CompressedImageView1D&),
+         *      @ref convertToData(const ImageData1D&), @ref convert(),
+         *      @ref convertToFile()
+         */
+        Containers::Array<char> convertToData(const ImageView1D& image);
+
         /**
          * @brief Convert a 2D image to a raw data
          * @m_since_latest
@@ -432,6 +616,30 @@ class MAGNUM_TRADE_EXPORT AbstractImageConverter: public PluginManager::Abstract
         CORRADE_DEPRECATED("use convertToData(const ImageView2D&) instead") Containers::Array<char> exportToData(const ImageView2D& image);
         #endif
 
+        /**
+         * @brief Convert a 3D image to a raw data
+         * @m_since_latest
+         *
+         * Available only if @ref ImageConverterFeature::Convert3DToData is
+         * supported. Returns data on success, @cpp nullptr @ce otherwise.
+         * @see @ref features(), @ref convertToData(const CompressedImageView3D&),
+         *      @ref convertToData(const ImageData3D&), @ref convert(),
+         *      @ref convertToFile()
+         */
+        Containers::Array<char> convertToData(const ImageView3D& image);
+
+        /**
+         * @brief Convert a compressed 1D image to a raw data
+         * @m_since_latest
+         *
+         * Available only if @ref ImageConverterFeature::ConvertCompressed1DToData
+         * is supported. Returns data on success, @cpp nullptr @ce otherwise.
+         * @see @ref features(), @ref convertToData(const ImageView1D&),
+         *      @ref convertToData(const ImageData1D&), @ref convert(),
+         *      @ref convertToFile()
+         */
+        Containers::Array<char> convertToData(const CompressedImageView1D& image);
+
         /**
          * @brief Convert a compressed 2D image to a raw data
          * @m_since_latest
@@ -453,6 +661,30 @@ class MAGNUM_TRADE_EXPORT AbstractImageConverter: public PluginManager::Abstract
         CORRADE_DEPRECATED("use convertToData(const CompressedImageView2D&) instead") Containers::Array<char> exportToData(const CompressedImageView2D& image);
         #endif
 
+        /**
+         * @brief Convert a compressed 3D image to a raw data
+         * @m_since_latest
+         *
+         * Available only if @ref ImageConverterFeature::ConvertCompressed3DToData
+         * is supported. Returns data on success, @cpp nullptr @ce otherwise.
+         * @see @ref features(), @ref convertToData(const ImageView3D&),
+         *      @ref convertToData(const ImageData3D&), @ref convert()
+         *      @ref convertToFile()
+         */
+        Containers::Array<char> convertToData(const CompressedImageView3D& image);
+
+        /**
+         * @brief Convert a 1D image data to a raw data
+         * @m_since_latest
+         *
+         * Based on whether the image is compressed or not, calls either
+         * @ref convertToData(const ImageView1D&) or
+         * @ref convertToData(const CompressedImageView1D&). See documentation
+         * of these two functions for details.
+         * @see @ref ImageData::isCompressed()
+         */
+        Containers::Array<char> convertToData(const ImageData1D& image);
+
         /**
          * @brief Convert a 2D image data to a raw data
          * @m_since_latest
@@ -474,6 +706,31 @@ class MAGNUM_TRADE_EXPORT AbstractImageConverter: public PluginManager::Abstract
         CORRADE_DEPRECATED("use convertToData(const ImageView2D&) instead") Containers::Array<char> exportToData(const ImageData2D& image);
         #endif
 
+        /**
+         * @brief Convert a 3D image data to a raw data
+         * @m_since_latest
+         *
+         * Based on whether the image is compressed or not, calls either
+         * @ref convertToData(const ImageView3D&) or
+         * @ref convertToData(const CompressedImageView3D&). See documentation
+         * of these two functions for details.
+         * @see @ref ImageData::isCompressed()
+         */
+        Containers::Array<char> convertToData(const ImageData3D& image);
+
+        /**
+         * @brief Convert a 1D image to a file
+         * @m_since_latest
+         *
+         * Available only if @ref ImageConverterFeature::Convert1DToFile or
+         * @ref ImageConverterFeature::Convert1DToData is supported. Returns
+         * @cpp true @ce on success, @cpp false @ce otherwise.
+         * @see @ref features(), @ref convertToFile(const CompressedImageView1D&, Containers::StringView),
+         *      @ref convertToFile(const ImageData1D&, Containers::StringView),
+         *      @ref convert(), @ref convertToData()
+         */
+        bool convertToFile(const ImageView1D& image, Containers::StringView filename);
+
         /**
          * @brief Convert a 2D image to a file
          * @m_since_latest
@@ -497,6 +754,33 @@ class MAGNUM_TRADE_EXPORT AbstractImageConverter: public PluginManager::Abstract
         CORRADE_DEPRECATED("use convertToFile(const ImageView2D&, Containers::StringView) instead") bool exportToFile(const ImageView2D& image, const std::string& filename);
         #endif
 
+        /**
+         * @brief Convert a 3D image to a file
+         * @m_since_latest
+         *
+         * Available only if @ref ImageConverterFeature::Convert3DToFile or
+         * @ref ImageConverterFeature::Convert3DToData is supported. Returns
+         * @cpp true @ce on success, @cpp false @ce otherwise.
+         * @see @ref features(), @ref convertToFile(const CompressedImageView3D&, Containers::StringView),
+         *      @ref convertToFile(const ImageData3D&, Containers::StringView),
+         *      @ref convert(), @ref convertToData()
+         */
+        bool convertToFile(const ImageView3D& image, Containers::StringView filename);
+
+        /**
+         * @brief Convert a compressed 1D image to a file
+         * @m_since_latest
+         *
+         * Available only if @ref ImageConverterFeature::ConvertCompressed1DToFile
+         * or @ref ImageConverterFeature::ConvertCompressed1DToData is
+         * supported. Returns @cpp true @ce on success, @cpp false @ce
+         * otherwise.
+         * @see @ref features(), @ref convertToFile(const ImageView1D&, Containers::StringView),
+         *      @ref convertToFile(const ImageData1D&, Containers::StringView),
+         *      @ref convert(), @ref convertToData()
+         */
+        bool convertToFile(const CompressedImageView1D& image, Containers::StringView filename);
+
         /**
          * @brief Convert a compressed 2D image to a file
          * @m_since_latest
@@ -521,6 +805,32 @@ class MAGNUM_TRADE_EXPORT AbstractImageConverter: public PluginManager::Abstract
         CORRADE_DEPRECATED("use convertToFile(const CompressedImageView2D&, Containers::StringView) instead") bool exportToFile(const CompressedImageView2D& image, const std::string& filename);
         #endif
 
+        /**
+         * @brief Convert a compressed 3D image to a file
+         * @m_since_latest
+         *
+         * Available only if @ref ImageConverterFeature::ConvertCompressed3DToFile
+         * or @ref ImageConverterFeature::ConvertCompressed3DToData is
+         * supported. Returns @cpp true @ce on success, @cpp false @ce
+         * otherwise.
+         * @see @ref features(), @ref convertToFile(const ImageView3D&, Containers::StringView),
+         *      @ref convertToFile(const ImageData3D&, Containers::StringView),
+         *      @ref convert(), @ref convertToData()
+         */
+        bool convertToFile(const CompressedImageView3D& image, Containers::StringView filename);
+
+        /**
+         * @brief Convert a 1D image data to a file
+         * @m_since_latest
+         *
+         * Based on whether the image is compressed or not, calls either
+         * @ref convertToFile(const ImageView1D&, Containers::StringView) or
+         * @ref convertToFile(const CompressedImageView1D&, Containers::StringView).
+         * See documentation of these two functions for details.
+         * @see @ref ImageData::isCompressed()
+         */
+        bool convertToFile(const ImageData1D& image, Containers::StringView filename);
+
         /**
          * @brief Convert a 2D image data to a file
          * @m_since_latest
@@ -543,6 +853,18 @@ class MAGNUM_TRADE_EXPORT AbstractImageConverter: public PluginManager::Abstract
         CORRADE_DEPRECATED("use convertToFile(const ImageData2D&, Containers::StringView) instead") bool exportToFile(const ImageData2D& image, const std::string& filename);
         #endif
 
+        /**
+         * @brief Convert a 3D image data to a file
+         * @m_since_latest
+         *
+         * Based on whether the image is compressed or not, calls either
+         * @ref convertToFile(const ImageView3D&, Containers::StringView) or
+         * @ref convertToFile(const CompressedImageView3D&, Containers::StringView).
+         * See documentation of these two functions for details.
+         * @see @ref ImageData::isCompressed()
+         */
+        bool convertToFile(const ImageData3D& image, Containers::StringView filename);
+
     private:
         /** @brief Implementation for @ref features() */
         virtual ImageConverterFeatures doFeatures() const = 0;
@@ -563,30 +885,88 @@ class MAGNUM_TRADE_EXPORT AbstractImageConverter: public PluginManager::Abstract
          */
         virtual void doSetFlags(ImageConverterFlags flags);
 
+        /**
+         * @brief Implementation for @ref convert(const ImageView1D&)
+         * @m_since_latest
+         */
+        virtual Containers::Optional<ImageData1D> doConvert(const ImageView1D& image);
+
         /**
          * @brief Implementation for @ref convert(const ImageView2D&)
          * @m_since_latest
          */
         virtual Containers::Optional<ImageData2D> doConvert(const ImageView2D& image);
 
+        /**
+         * @brief Implementation for @ref convert(const ImageView3D&)
+         * @m_since_latest
+         */
+        virtual Containers::Optional<ImageData3D> doConvert(const ImageView3D& image);
+
+        /**
+         * @brief Implementation for @ref convert(const CompressedImageView1D&)
+         * @m_since_latest
+         */
+        virtual Containers::Optional<ImageData1D> doConvert(const CompressedImageView1D& image);
+
         /**
          * @brief Implementation for @ref convert(const CompressedImageView2D&)
          * @m_since_latest
          */
         virtual Containers::Optional<ImageData2D> doConvert(const CompressedImageView2D& image);
 
+        /**
+         * @brief Implementation for @ref convert(const CompressedImageView3D&)
+         * @m_since_latest
+         */
+        virtual Containers::Optional<ImageData3D> doConvert(const CompressedImageView3D& image);
+
+        /**
+         * @brief Implementation for @ref convertToData(const ImageView1D&)
+         * @m_since_latest
+         */
+        virtual Containers::Array<char> doConvertToData(const ImageView1D& image);
+
         /**
          * @brief Implementation for @ref convertToData(const ImageView2D&)
          * @m_since_latest
          */
         virtual Containers::Array<char> doConvertToData(const ImageView2D& image);
 
+        /**
+         * @brief Implementation for @ref convertToData(const ImageView3D&)
+         * @m_since_latest
+         */
+        virtual Containers::Array<char> doConvertToData(const ImageView3D& image);
+
+        /**
+         * @brief Implementation for @ref convertToData(const CompressedImageView1D&)
+         * @m_since_latest
+         */
+        virtual Containers::Array<char> doConvertToData(const CompressedImageView1D& image);
+
         /**
          * @brief Implementation for @ref convertToData(const CompressedImageView2D&)
          * @m_since_latest
          */
         virtual Containers::Array<char> doConvertToData(const CompressedImageView2D& image);
 
+        /**
+         * @brief Implementation for @ref convertToData(const CompressedImageView3D&)
+         * @m_since_latest
+         */
+        virtual Containers::Array<char> doConvertToData(const CompressedImageView3D& image);
+
+        /**
+         * @brief Implementation for @ref convertToFile(const ImageView1D&, Containers::StringView)
+         * @m_since_latest
+         *
+         * If @ref ImageConverterFeature::Convert1DToData is supported, default
+         * implementation calls @ref doConvertToData(const ImageView1D&) and
+         * saves the result to given file.
+         */
+        virtual bool doConvertToFile(const ImageView1D& image, Containers::StringView filename);
+
         /**
          * @brief Implementation for @ref convertToFile(const ImageView2D&, Containers::StringView)
          * @m_since_latest
@@ -597,6 +977,26 @@ class MAGNUM_TRADE_EXPORT AbstractImageConverter: public PluginManager::Abstract
          */
         virtual bool doConvertToFile(const ImageView2D& image, Containers::StringView filename);
 
+        /**
+         * @brief Implementation for @ref convertToFile(const ImageView3D&, Containers::StringView)
+         * @m_since_latest
+         *
+         * If @ref ImageConverterFeature::Convert3DToData is supported, default
+         * implementation calls @ref doConvertToData(const ImageView3D&) and
+         * saves the result to given file.
+         */
+        virtual bool doConvertToFile(const ImageView3D& image, Containers::StringView filename);
+
+        /**
+         * @brief Implementation for @ref convertToFile(const CompressedImageView1D&, Containers::StringView)
+         * @m_since_latest
+         *
+         * If @ref ImageConverterFeature::ConvertCompressed1DToData is
+         * supported, default implementation calls @ref doConvertToData(const CompressedImageView1D&)
+         * and saves the result to given file.
+         */
+        virtual bool doConvertToFile(const CompressedImageView1D& image, Containers::StringView filename);
+
         /**
          * @brief Implementation for @ref convertToFile(const CompressedImageView2D&, Containers::StringView)
          * @m_since_latest
@@ -607,6 +1007,16 @@ class MAGNUM_TRADE_EXPORT AbstractImageConverter: public PluginManager::Abstract
          */
         virtual bool doConvertToFile(const CompressedImageView2D& image, Containers::StringView filename);
 
+        /**
+         * @brief Implementation for @ref convertToFile(const CompressedImageView3D&, Containers::StringView)
+         * @m_since_latest
+         *
+         * If @ref ImageConverterFeature::ConvertCompressed3DToData is
+         * supported, default implementation calls @ref doConvertToData(const CompressedImageView3D&)
+         * and saves the result to given file.
+         */
+        virtual bool doConvertToFile(const CompressedImageView3D& image, Containers::StringView filename);
+
         ImageConverterFlags _flags;
 };